/// <summary>
/// Parses Node recursively
/// </summary>
/// <param name="node">Node to parse</param>
/// <param name="condition">Base condition, optional</param>
/// <returns>Collection of widgets</returns>
public static ElementManager ParseChildNode(QLNode node, ElementManagerController elementManagerController, ElementManagerCollection parent, ExpressionBool condition = null)
{
ExpressionFactory expressionFactory = new ExpressionFactory(elementManagerController);
switch (node)
{
case ConditionalNode conditionalNode:
// Parse condition
ExpressionBool newCondition = expressionFactory.GetCondition(conditionalNode);
newCondition = (condition == null) ? newCondition : condition.Combine(newCondition, ExpressionOperator.And) as ExpressionBool;
// Add children with new condition
parent.AddChildren(conditionalNode.Children.Select(o => ParseChildNode(o, elementManagerController, parent, newCondition)).Where(o => o != null));
return(null);
case QuestionNode questionNode:
return(CreateElementManager(questionNode, condition, parent, elementManagerController, null));
case ComputedNode computedNode:
ExpressionValue expression = expressionFactory.ParseExpressionNode(computedNode.Expression);
return(CreateElementManager(computedNode, condition, parent, elementManagerController, expression));
}
throw new NotImplementedException();
}
/// <summary>
/// Parses (AST)Node recursively
/// </summary>
/// <param name="node">Node to parse</param>
/// <param name="condition">Base condition, optional</param>
/// <returns>Collection of widgets</returns>
public static ElementManager ParseChildNode(Node node, ElementManagerController elementManagerController, ElementManagerCollection parent, ExpressionBool condition = null)
{
switch (node.Type)
{
case NodeType.CONDITIONAL:
ExpressionFactory expressionFactory = new ExpressionFactory(elementManagerController);
// Parse condition
ExpressionBool newCondition = expressionFactory.GetCondition(node as ConditionalNode);
newCondition = (condition == null) ? newCondition : condition.Combine(newCondition, ExpressionOperator.And) as ExpressionBool;
// Add children with new condition
parent.AddChildren(node.Children.Select(o => ParseChildNode(o, elementManagerController, parent, newCondition)).Where(o => o != null));
// return parent
return(null);
case NodeType.FORM:
throw new InvalidOperationException("Cannot stack form nodes");
case NodeType.QUESTION:
return(CreateElementManager(node as QuestionNode, condition, parent, elementManagerController));
case NodeType.COMPUTED:
return(CreateComputedWidget(node as ComputedNode, condition, parent, elementManagerController));
}
throw new NotImplementedException();
}
public static FormManager CreateForm(FormNode node, ElementManagerController elementManagerController)
{
FormManager form = new FormManager(node.FormName, node.FormName, elementManagerController);
// Add all children
form.AddChildren(node.Children.Select(o => ParseChildNode(o, elementManagerController, form)).Where(o => o != null));
return(form);
}
public void Initialize()
{
_style = new WindowsStyleProperties();
_widgetController = new ElementManagerDisplayContollerWindows(null, 10);
_controlFactory = new ControlFactory(_widgetController);
_intWidget = new IntQuestionManager("a", "q1", null, _widgetController);
_boolWidget = new BoolQuestionManager("b", "q2", null, _widgetController);
_stringWidget = new StringQuestionManager("c", "q3", null, _widgetController);
}
public ElementManager(string identifier, string text, string xmlName, ElementManagerController controller, ExpressionBool activationExpression = null)
{
Text = text;
Identifier = identifier;
XMLElementName = xmlName;
_elementManagerController = controller;
_activationExpression = activationExpression;
Active = activationExpression == null;
}
/// <summary>
/// Adds QLS to a form
/// </summary>
/// <param name="formManager">Target form</param>
/// <param name="qLSNode">Styling for the form</param>
/// <param name="controller">Controller for object creation</param>
/// <returns>Styled form</returns>
public static FormManager ApplyQLS(FormManager formManager, QLSNode qLSNode, ElementManagerController controller, ref List <string> errors)
{
if (formManager.Identifier != qLSNode.ID)
{
errors.Add("Identifiers of ql and qls do not match!");
return(formManager);
}
List <ElementManagerLeaf> children = formManager.Children.Select(o => (ElementManagerLeaf)o).ToList();
return(ReconstructElementCollection(formManager, ref children, qLSNode, controller) as FormManager);
}
public ExpressionFactory(ElementManagerController widgetController)
{
_widgetController = widgetController;
}
public ElementManagerLeaf(string identifier, string text, string xmlName, ElementManagerCollection parent, ElementManagerController controller, ExpressionBool activationExpression = null) :
base(identifier, text, xmlName, controller, activationExpression)
{
Parent = parent;
}
public LazyElementExpressionLink(ElementManagerController elementManagerController, string questionElementManagerID)
{
_elementManagerController = elementManagerController;
QuestionElementManagerID = questionElementManagerID;
}
private static ElementManagerCollection AddQLSToCollection(QLSNode qlsNode, ElementManagerCollection parent, ElementManagerController controller)
{
switch (qlsNode.NodeType)
{
case QLSNodeType.Page:
return(new PageManager(qlsNode.ID, qlsNode.ID, parent, controller));
case QLSNodeType.Section:
return(new SectionManager(qlsNode.ID, qlsNode.ID, parent, controller));
}
throw new NotImplementedException();
}
public ExpressionFactory(ElementManagerController elementManagerController)
{
_elementManagerController = elementManagerController;
}
public ElementManagerCollection(string identifyer, string text, string xmlName, ElementManagerController controller, ExpressionBool activationExpression = null) :
base(identifyer, text, xmlName, controller, activationExpression)
{
_children = new List <ElementManager>();
}
public QuestionElementManager(string identifyer, string text, ElementManager parent, ElementManagerController controller, ExpressionBool activationExpression = null, TypedExpressionValue <T> answerExpression = null) :
base(identifyer, text, "question", parent, controller, activationExpression)
{
Answer = new QuestionElementValue <T>(default(T), false);
IsAnswered = false;
_answerExpression = answerExpression;
}
public FormManager(string identifier, string text, ElementManagerController controller, ExpressionBool activationExpression = null) :
base(identifier, text, "form", controller, activationExpression)
{
}
public PageManager(string identifyer, string text, ElementManager parent, ElementManagerController controller, ExpressionBool activationExpression = null) :
base(identifyer, text, "page", parent, controller, activationExpression)
{
}
private static ElementManagerLeaf CreateElementManager(IQuestionable identifiedNode, ExpressionBool condition, ElementManagerCollection parent, ElementManagerController elementManagerController, ExpressionValue activationExpression)
{
switch (identifiedNode.ValueType)
{
case QValueType.Boolean:
return(new BoolQuestionManager(identifiedNode.ID, identifiedNode.Text, parent, elementManagerController, condition, activationExpression as ExpressionBool));
case QValueType.Integer:
return(new IntQuestionManager(identifiedNode.ID, identifiedNode.Text, parent, elementManagerController, condition, activationExpression as ExpressionInt));
case QValueType.Text:
return(new StringQuestionManager(identifiedNode.ID, identifiedNode.Text, parent, elementManagerController, condition, activationExpression as ExpressionText));
case QValueType.Money:
return(new MoneyQuestionManager(identifiedNode.ID, identifiedNode.Text, parent, elementManagerController, condition, activationExpression as ExpressionDouble));
case QValueType.Hex:
return(new HexQuestionManager(identifiedNode.ID, identifiedNode.Text, parent, elementManagerController, condition, activationExpression as ExpressionHex));
}
throw new InvalidOperationException("Unsupported type: " + identifiedNode.ValueType);
}
public StringQuestionManager(string identifyer, string text, ElementManager parent, ElementManagerController controller, ExpressionBool activationExpression = null, TypedExpressionValue <string> answerExpression = null) :
base(identifyer, text, parent, controller, activationExpression, answerExpression)
{
}
/// <summary>
/// Creates widget from QuestionNode
/// </summary>
/// <param name="questionNode">Node to parse</param>
/// <returns>Parsed widget</returns>
private static ElementManagerLeaf CreateElementManager(QuestionNode questionNode, ExpressionBool condition, ElementManager parent, ElementManagerController elementManagerController)
{
switch (questionNode.ValueType)
{
case QValueType.BOOLEAN:
return(new BoolQuestionManager(questionNode.ID, questionNode.Text, parent, elementManagerController, condition));
case QValueType.INTEGER:
return(new IntQuestionManager(questionNode.ID, questionNode.Text, parent, elementManagerController, condition));
case QValueType.TEXT:
return(new StringQuestionManager(questionNode.ID, questionNode.Text, parent, elementManagerController, condition));
case QValueType.MONEY:
return(new MoneyQuestionManager(questionNode.ID, questionNode.Text, parent, elementManagerController, condition));
}
throw new InvalidOperationException("Unsupported type: " + questionNode.ValueType);
}
/// <summary>
/// Creates widget with computed value
/// </summary>
/// <param name="node">Node</param>
/// <param name="condition">Condition of widget</param>
/// <param name="elementManagerController">Widget controller</param>
/// <returns></returns>
private static ElementManagerLeaf CreateComputedWidget(ComputedNode node, ExpressionBool condition, ElementManager parent, ElementManagerController elementManagerController)
{
ExpressionFactory expressionFactory = new ExpressionFactory(elementManagerController);
ExpressionValue expression = expressionFactory.ParseExpressionNode(node.Expression);
switch (node.Expression.GetQValueType())
{
case QValueType.BOOLEAN:
return(new BoolQuestionManager(node.ID, node.Text, parent, elementManagerController, condition, expression as ExpressionBool));
case QValueType.INTEGER:
return(new IntQuestionManager(node.ID, node.Text, parent, elementManagerController, condition, expression as ExpressionInt));
case QValueType.MONEY:
return(new MoneyQuestionManager(node.ID, node.Text, parent, elementManagerController, condition, expression as ExpressionDouble));
}
throw new NotImplementedException();
}
public ElementFactory(ElementManagerController widgetController)
{
_widgetController = widgetController;
}
public SectionManager(string identifier, string text, ElementManagerCollection parent, ElementManagerController controller, ExpressionBool activationExpression = null) :
base(identifier, text, "section", parent, controller, activationExpression)
{
}
public ControlFactory(ElementManagerController widgetController) : base(widgetController)
{
}
public HexQuestionManager(string identifier, string text, ElementManagerCollection parent, ElementManagerController controller, ExpressionBool activationExpression = null, TypedExpressionValue <Hexadecimal> answerExpression = null)
: base(identifier, text, parent, controller, activationExpression, answerExpression)
{
}
/// <summary>
/// Creates the elementManager style as provided by the QLS node by inserting
/// the manager objects provided by the QLS and insterts the given children into
/// the tree on the positions defined in the QLS
/// </summary>
/// <param name="collection">Collection element to be reconstructed</param>
/// <param name="children">Children that can occur as a child of the collection element</param>
/// <param name="qlsChildren">Children of the QLS node that mached the collection node</param>
/// <param name="controller">ElementManagerController for element creation</param>
/// <returns>Element manager collection that contains all QLS defined children</returns>
private static ElementManagerCollection ReconstructElementCollection(ElementManagerCollection collection, ref List <ElementManagerLeaf> children, QLSNode qlsNode, ElementManagerController controller)
{
collection.Children.Clear();
foreach (QLSNode node in qlsNode.Children)
{
switch (node.NodeType)
{
case QLSNodeType.Page:
case QLSNodeType.Section:
ElementManagerCollection collectionChild = AddQLSToCollection(node, collection, controller);
collectionChild = ReconstructElementCollection(collectionChild, ref children, node, controller);
collection.AddChild(collectionChild);
break;
case QLSNodeType.Question:
IEnumerable <ElementManagerLeaf> foundMatches = children.Where(o => o.Identifier == node.ID).Select(o => o as ElementManagerLeaf);
if (foundMatches.Count() != 1)
{
throw new InvalidOperationException(string.Format("Identifier: {0}, used in QLS, was found {1} times in QL!", node.ID, foundMatches.Count()));
}
ElementManagerLeaf child = foundMatches.First();
children.Remove(child);
collection.AddChild(AddQLSToLeaf(node, child));
break;
}
}
collection.AddStyle(qlsNode.NodeStyles.ToArray());
return(collection);
}
