private void resizePanels()
{
Size screenSize;
if (_inputPanel != null && _inputPanel.Enabled)
{
screenSize = new System.Drawing.Size(
_inputPanel.VisibleDesktop.Width,
_inputPanel.VisibleDesktop.Height);
}
else
{
screenSize = this.ClientSize;
}
this.logPanel.Size = screenSize;
this.logBox.Size = new System.Drawing.Size(this.logPanel.Size.Width,
this.logPanel.Size.Height -
this.logBox.Location.Y);
IEnumerator en = _appliances.GetEnumerator();
while (en.MoveNext())
{
Appliance a = (Appliance)en.Current;
UIGenerator ui = a.GetUIGenerator();
InterfaceNode root = ui.InterfaceRoot;
ui.Size = screenSize;
root.SetSize(ui.Size.Width, ui.Size.Height);
root.DoLayout(ui.LayoutVars);
}
}
private InterfaceNode AddInterface(Type currentInterface, Dictionary <string, InterfaceNode> interfaceNodes)
{
var fullName = GetName(currentInterface);
var assemblyQualifiedName = $"{currentInterface.Namespace ?? string.Empty}.{currentInterface.Name ?? string.Empty}, {currentInterface.Assembly.FullName}";
if (string.IsNullOrEmpty(assemblyQualifiedName))
{
//if (assemblyQualifiedName == "Root.Code.Apis.E01D.Api_I`1")
//{
//}
Debug.WriteLine($"Passing on {assemblyQualifiedName}");
return(null);
}
if (!interfaceNodes.TryGetValue(fullName, out InterfaceNode currentInterfaceNode))
{
currentInterfaceNode = new InterfaceNode()
{
Interface = currentInterface.TypeHandle,
FullName = fullName
};
interfaceNodes.Add(fullName, currentInterfaceNode);
}
return(currentInterfaceNode);
}
public override ProblemCollection Check(TypeNode typeNode)
{
if (typeNode.Interfaces.Any())
{
InterfaceNode foundServiceInterface = typeNode.Interfaces.First(i => i.FullName.EndsWith(".IBaseService"));
if (foundServiceInterface != null)
{
bool foundUsage = false;
TypeNode serviceManagerTypeNode = foundServiceInterface.DeclaringModule.Types.First(t => t.FullName.EndsWith(".ServiceManager"));
if (serviceManagerTypeNode != null)
{
Member member = serviceManagerTypeNode.Members.First(t => t.FullName.EndsWith(".RegisterAllServices"));
var method = member as Method;
if (method != null)
{
foundUsage = method.Instructions.Any(opcode => opcode.Value != null && opcode.Value.ToString().Contains(typeNode.FullName + "("));
}
}
if (!foundUsage)
{
Resolution resolution = GetResolution(typeNode.FullName);
var problem = new Problem(resolution);
Problems.Add(problem);
}
}
}
return(Problems);
}
private string GetTableName(InterfaceNode type)
{
string mClassName = type.Name.Identifier.Substring(1, type.Name.Identifier.Length - 1);
foreach (AttributeNode attr in type.Attributes)
{
if (attr.Name.GenericIdentifier.ToLower() == "table")
{
if (attr.Arguments.Count > 0)
{
DDW.StringPrimitive pe = (DDW.StringPrimitive)attr.Arguments[0].Expression;
if (pe != null)
{
return(pe.Value.ToString());
}
else
{
return(mClassName);
}
}
else
{
return(mClassName);
}
}
}
return(mClassName);
}
private void PUCFrame_Resize(object sender, System.EventArgs e)
{
if (this.ClientSize.Width == 0 && this.ClientSize.Height == 0)
{
// this happens when the window is minimized
return;
}
this.logPanel.Size = this.ClientSize;
this.logBox.Size = new System.Drawing.Size(this.logPanel.Size.Width,
this.logPanel.Size.Height -
this.logBox.Location.Y);
IEnumerator en = _appliances.GetEnumerator();
while (en.MoveNext())
{
Appliance a = (Appliance)en.Current;
UIGenerator ui = a.GetUIGenerator();
InterfaceNode root = ui.InterfaceRoot;
ui.Size = this.ClientSize;
root.SetSize(ui.Size.Width, ui.Size.Height);
root.DoLayout(ui.LayoutVars);
}
}
/*
* Organizer Method
*/
public override void AddOrganization(GroupNode group, InterfaceNode currentNode)
{
VerticallyNonOverlappingPanelsNode non = new VerticallyNonOverlappingPanelsNode();
OverlappingPanelsNode over = new OverlappingPanelsNode();
currentNode.InsertAsParent(non);
non.AddPanel(over);
Hashtable deps = new Hashtable(_dependencies.Count);
IEnumerator e = _dependencies.Keys.GetEnumerator();
PanelNode newP = null;
while (e.MoveNext())
{
GroupNode g = (GroupNode)e.Current;
ArrayList aryDeps = (ArrayList)_dependencies[g];
newP = new PanelNode(g);
over.AddPanel(newP);
deps[aryDeps] = newP;
g.Decorations.Add(PanelDecision.DECISION_KEY, new PanelDecision(this, newP));
}
_activePanel = newP;
_dependencies = deps;
_uiValid = true;
this.ValueChanged(_state);
}
public override void Process(InterfaceNode node, UIGenerator ui)
{
if (node is PanelNode)
{
((ScrollingPanel)((PanelNode)node).GetContainerCIO().GetControl()).DisplayPolicy = ScrollBarDisplay.AsNeeded;
}
}
public XmlElement Visit(InterfaceNode n)
{
var el = makeNode(n, "interface");
addProperty(el, "name", n.Name);
addProperty(el, "body", n.Body);
return(el);
}
/*
* Process Method
*/
/// <summary>
/// Input to this rule phase is an array that contains two items. The
/// first item is the current interface tree, and the second item is an
/// array of LayoutProblem objects. Rules of this phase attemp to fix
/// these problems.
/// </summary>
/// <param name="o">an array containg the interface tree and a list of layout problems</param>
/// <param name="ui">a UIGenerator object that contains global variables for this process</param>
/// <returns></returns>
public override object Process(object o, UIGenerator ui)
{
InterfaceNode root = (InterfaceNode)o;
processRules(root, ui);
return(root);
}
protected InterfaceNode recoverRoot(InterfaceNode currentRoot)
{
while (currentRoot.GetParent() != null)
{
currentRoot = currentRoot.GetParent();
}
return(currentRoot);
}
public MethodNode GetInterfaceMethod(InterfaceNode _interface, string method_name)
{
var methods = GetInterfaceMethods(_interface);
if (!methods.ContainsKey(method_name))
{
return(null);
}
return(methods[method_name]);
}
public virtual AstNode VisitInterface(InterfaceNode n)
{
Visit(n.Attributes);
Visit(n.AccessModifier);
Visit(n.Name);
Visit(n.GenericTypeParameters);
Visit(n.Interfaces);
Visit(n.TypeConstraints);
Visit(n.Members);
return(n);
}
private void BeforeExpand(TreeNode parentNode, CodeInterface codeInterface)
{
InterfaceNode cn = new InterfaceNode(codeInterface, this);
if (codeInterface.Members.Count > 0)
{
AddNodeWithChilds(parentNode.Nodes, cn);
}
else
{
parentNode.Nodes.Add(cn);
}
}
public TestModelBuilder AddInterface(string name, string baseName = null)
{
var node = new InterfaceNode(name);
ModelService.AddNode(node);
if (baseName != null)
{
var baseNode = ModelService.GetTestNodeByName(baseName);
AddInheritance(node, baseNode);
}
return(this);
}
/// <inheritdoc />
public Node Visit(InterfaceParseNode tpn)
{
var ret = new InterfaceNode(tpn.Token, tpn);
if (tpn.Name != null)
{
ret.Name = tpn.Name;
}
foreach (var p in tpn.Body)
{
ret.Body.Add((SignatureNode)p.Visit(this));
}
return(ret);
}
public TestModelBuilder AddInterface(string name, string baseName = null, ModelOrigin origin = ModelOrigin.SourceCode)
{
var node = new InterfaceNode(ModelNodeId.Create(), name, origin, false);
ModelService.AddNode(node);
ModelService.AddItemToCurrentGroup(node);
if (baseName != null)
{
var baseNode = GetNodeByName(baseName);
AddInheritance(node, baseNode);
}
return(this);
}
protected void WalkInterfaceNode(InterfaceNode node)
{
if (node == null)
{
return;
}
var properties = new List <PropertyNode>();
var methods = new List <MethodNode>();
node.Members?.ForEach(m => PrepareMembers(m, properties, null, methods));
properties.ForEach(p => VisitPropertyNode(p));
methods.ForEach(m => VisitMethodNode(m));
}
/*
* Organizer Method
*/
public override void AddOrganization(GroupNode group, InterfaceNode currentNode)
{
TabbedOverlappingPanelsNode tab = new TabbedOverlappingPanelsNode(_state);
MultiplePanelNode non = null;
if (_vertical)
{
non = new HorizontallyNonOverlappingPanelsNode((PanelNode)currentNode, tab);
}
else
{
non = new VerticallyNonOverlappingPanelsNode();
currentNode.InsertAsParent(non);
non.AddPanel(tab);
}
Hashtable deps = new Hashtable(_dependencies.Count);
IEnumerator e = _dependencies.Keys.GetEnumerator();
PanelNode newP = null;
while (e.MoveNext())
{
GroupNode g = (GroupNode)e.Current;
ArrayList aryDeps = (ArrayList)_dependencies[g];
EqualsDependency eqDep = (EqualsDependency)aryDeps[0];
try
{
newP = (PanelNode)tab.GetNodeByValue((int)eqDep.Value).GetChildNode();
newP.Group = g;
}
catch (Exception) { Globals.GetFrame(eqDep.State.Appliance).AddLogLine("Error in TabbedControlPanelOrganizer... Line 82"); }
deps[aryDeps] = newP;
g.Decorations.Add(PanelDecision.DECISION_KEY, new PanelDecision(this, newP));
}
_activePanel = newP;
_dependencies = deps;
_uiValid = true;
this.ValueChanged(_state);
}
/*
* Process Method
*/
public override object Process(object o, UIGenerator ui)
{
InterfaceNode root = (InterfaceNode)o;
root.SetSize(ui.Size.Width, ui.Size.Height);
// add components also calculates minimum and preferred sizes
root.AddComponents(ui.Panel, ui.LayoutVars);
root.DoLayout(ui.LayoutVars);
// Globals.AddLogLine( _interfaceRoot.ToString() );
object[] items = new object[2];
items[0] = root;
items[1] = ui.LayoutVars.LayoutProblems;
return(items);
}
public Dictionary <string, MethodNode> GetInterfaceMethods(InterfaceNode _interface)
{
var ret = new Dictionary <string, MethodNode>();
foreach (var method in _interface.methods)
{
var method_name = method.identifier.ToString();
var parameters = new List <string>();
foreach (var parameter in method.parameters)
{
parameters.Add(parameter.type.ToString());
}
method_name += "(" + string.Join(",", parameters) + ")";
ret[method_name] = method;
}
return(ret);
}
public TestModelBuilder AddInterface(string name, string baseName = null)
{
var node = new InterfaceNode(name);
ModelService.AddNode(node);
if (baseName == null)
{
return(this);
}
ModelService.TryGetTestNodeByName(baseName).Match(
some => AddBase(name, baseName),
() => throw new Exception($"Base {baseName} wa not found.")
);
return(this);
}
protected void processRules(InterfaceNode node, UIGenerator ui)
{
IEnumerator rule = _rules.GetEnumerator();
while (rule.MoveNext())
{
((TreeTraversalRule)rule.Current).Process(node, ui);
}
if (node is MultiplePanelNode)
{
IEnumerator child = ((MultiplePanelNode)node).Panels.GetEnumerator();
while (child.MoveNext())
{
processRules((InterfaceNode)child.Current, ui);
}
}
}
/*
* Process Method
*/
/// <summary>
/// Input to this rule phase is an array that contains two items. The
/// first item is the current interface tree, and the second item is an
/// array of LayoutProblem objects. Rules of this phase attemp to fix
/// these problems.
/// </summary>
/// <param name="o">an array containg the interface tree and a list of layout problems</param>
/// <param name="ui">a UIGenerator object that contains global variables for this process</param>
/// <returns></returns>
public override object Process(object o, UIGenerator ui)
{
object[] items = (object[])o;
InterfaceNode root = (InterfaceNode)items[0];
Hashtable problems = (Hashtable)((Hashtable)items[1]).Clone();
IEnumerator problem = problems.Values.GetEnumerator();
while (problem.MoveNext())
{
IEnumerator rule = _rules.GetEnumerator();
while (rule.MoveNext())
{
root = ((FixLayoutRule)rule.Current).Process((LayoutProblem)problem.Current, root, ui);
}
}
ui.InterfaceRoot = root;
return(root);
}
public override ProblemCollection Check(TypeNode type)
{
InterfaceNode node = type as InterfaceNode;
if (node != null)
{
StringBuilder sb = new System.Text.StringBuilder(node.Name.Name);
sb[0] = char.ToUpper(sb[0]);
sb[1] = char.ToUpper(sb[1]);
var pascalInterfaceName = sb.ToString();
if (!node.Name.Name.Equals(pascalInterfaceName))
{
this.Problems.Add(new Problem(this.GetResolution(), node.SourceContext));
}
}
return(Problems);
}
private void DebugServerFrame_Resize(object sender, System.EventArgs e)
{
if (this.ClientSize.Width == 0 && this.ClientSize.Height == 0)
{
// this happens when the window is minimized
return;
}
this.logPanel.Size = this.ClientSize;
this.logBox.Size = new System.Drawing.Size(this.logPanel.Size.Width,
this.logPanel.Size.Height -
this.logBox.Location.Y);
if (_appliance != null)
{
UIGenerator ui = _appliance.GetUIGenerator();
InterfaceNode root = ui.InterfaceRoot;
ui.Size = this.ClientSize;
root.SetSize(ui.Size.Width, ui.Size.Height);
root.DoLayout(ui.LayoutVars);
}
}
/*
* Abstract Methods
*/
public abstract void AddOrganization(GroupNode group, InterfaceNode currentNode);
private void MenuItem_新建接口模块_Click_1(object sender, RoutedEventArgs e)
{
InterfaceNode parentnode = tree1.SelectedItem as InterfaceNode;
parentnode.CreateChild(false);
}
public AstNode VisitInterface(InterfaceNode n)
{
if (!n.Attributes.IsNullOrEmpty())
{
foreach (var a in n.Attributes)
{
Visit(a);
}
}
Visit(n.AccessModifier ?? new KeywordNode("private"));
Append(" interface ");
Visit(n.Name);
if (!n.GenericTypeParameters.IsNullOrEmpty())
{
Append("<");
Visit(n.GenericTypeParameters[0]);
for (var i = 1; i < n.GenericTypeParameters.Count; i++)
{
Append(", ");
Visit(n.GenericTypeParameters[i]);
}
Append(">");
}
Append(" ");
if (!n.Interfaces.IsNullOrEmpty())
{
Append(": ");
Visit(n.Interfaces[0]);
for (var i = 1; i < n.Interfaces.Count; i++)
{
Append(", ");
Visit(n.Interfaces[i]);
}
}
if (!n.GenericTypeParameters.IsNullOrEmpty() && !n.TypeConstraints.IsNullOrEmpty())
{
IncreaseIndent();
AppendLineAndIndent();
Visit(n.TypeConstraints[0]);
foreach (var tc in n.TypeConstraints.Skip(1))
{
AppendLineAndIndent();
Visit(tc);
}
DecreaseIndent();
}
AppendLineAndIndent();
AppendLine("{");
IncreaseIndent();
AppendLineAndIndent();
foreach (var m in n.Members.OrEmptyIfNull())
{
Visit(m);
AppendLineAndIndent();
}
DecreaseIndent();
AppendLineAndIndent();
AppendLine("}");
return(n);
}
private SyntaxNode Node(SyntaxType parent, int start, int end, List <Token> tokens, List <Error> compileErrors)
{
switch (parent)
{
case SyntaxType.Program:
{
SyntaxNode node = new ProgramNode();
for (var i = start; i < end; i++)
{
switch (tokens[i].Type)
{
case TokenType.ClassDeclaration:
{
var newStart = i + 1;
var left = 1;
var right = 0;
while (left != right)
{
i++;
if (i >= end)
{
compileErrors.Add(new Error("Missing end of class declaration"));
return(null);
}
switch (tokens[i].Type)
{
case TokenType.ClassDeclaration:
case TokenType.InterfaceDeclaration:
left++;
break;
case TokenType.ClassEndDeclaration:
right++;
break;
}
}
var childNode = Node(SyntaxType.Class, newStart, i, tokens, compileErrors);
if (childNode == null)
{
return(null);
}
node.Nodes.Add(childNode);
break;
}
case TokenType.InterfaceDeclaration:
{
var newStart = i + 1;
var left = 1;
var right = 0;
while (left != right)
{
i++;
if (i >= end)
{
compileErrors.Add(new Error("Missing end of interface declaration"));
return(null);
}
switch (tokens[i].Type)
{
case TokenType.ClassDeclaration:
case TokenType.InterfaceDeclaration:
left++;
break;
case TokenType.ClassEndDeclaration:
right++;
break;
}
}
var childNode = Node(SyntaxType.Interface, newStart, i, tokens, compileErrors);
if (childNode == null)
{
return(null);
}
node.Nodes.Add(childNode);
break;
}
default:
{
if (IsTokenWhiteSpace(tokens[i]))
{
continue;
}
compileErrors.Add(new Error("Unexpected expression in program body"));
return(null);
}
}
}
return(node);
}
case SyntaxType.Class:
{
SyntaxNode node = new ClassNode(tokens[start - 1], tokens[end]);
for (var i = start; i < end; i++)
{
switch (tokens[i].Type)
{
case TokenType.MethodDeclaration:
{
var newStart = i + 1;
var left = 1;
var right = 0;
while (left != right)
{
i++;
if (i >= end)
{
compileErrors.Add(new Error("Missing end of method declaration"));
return(null);
}
switch (tokens[i].Type)
{
case TokenType.MethodDeclaration:
case TokenType.MainMethodDeclaration:
left++;
break;
case TokenType.MethodEndDeclaration:
right++;
break;
}
}
var childNode = Node(SyntaxType.MethodDeclaring, newStart, i, tokens, compileErrors);
if (childNode == null)
{
return(null);
}
node.Nodes.Add(childNode);
break;
}
case TokenType.MainMethodDeclaration:
{
var newStart = i + 1;
var left = 1;
var right = 0;
while (left != right)
{
i++;
if (i >= end)
{
compileErrors.Add(new Error("Missing end of main method declaration"));
return(null);
}
switch (tokens[i].Type)
{
case TokenType.MethodDeclaration:
case TokenType.MainMethodDeclaration:
left++;
break;
case TokenType.MethodEndDeclaration:
right++;
break;
}
}
var childNode = Node(SyntaxType.MainMethodDeclaring, newStart, i, tokens, compileErrors);
if (childNode == null)
{
return(null);
}
node.Nodes.Add(childNode);
break;
}
default:
{
if (IsTokenWhiteSpace(tokens[i]))
{
continue;
}
compileErrors.Add(new Error("Unexpected expression in class body"));
return(null);
}
}
}
return(node);
}
case SyntaxType.Interface:
{
SyntaxNode node = new InterfaceNode(tokens[start - 1], tokens[end]);
for (var i = start; i < end; i++)
{
if (tokens[i].Type == TokenType.MethodDeclaration)
{
node.Nodes.Add(new InterfaceMethodNode(tokens[i]));
}
else if (IsTokenWhiteSpace(tokens[i]))
{
}
else
{
compileErrors.Add(new Error("Unexpected expression in interface body"));
return(null);
}
}
return(node);
}
case SyntaxType.MethodDeclaring:
case SyntaxType.MainMethodDeclaring:
{
SyntaxNode node = new MethodNode(tokens[start - 1], tokens[end], parent == SyntaxType.MainMethodDeclaring);
Node(parent, start, end, tokens, compileErrors, node, "method");
return(node);
}
case SyntaxType.Switch:
{
SyntaxNode node = new SwitchNode(tokens[start - 1], tokens[end]);
Node(parent, start, end, tokens, compileErrors, node, "switch");
return(node);
}
case SyntaxType.SwitchCase:
{
SyntaxNode node = new SwitchCase(tokens[start - 1], tokens[start - 1].Type == TokenType.SwitchDefaultCase);
Node(parent, start, end, tokens, compileErrors, node, "switch case");
return(node);
}
case SyntaxType.IfTruePart:
{
SyntaxNode node = new IfTrueNode(tokens[start - 1].Childs[0]);
Node(parent, start, end, tokens, compileErrors, node, "if");
return(node);
}
case SyntaxType.IfFalsePart:
{
SyntaxNode node = new IfElseNode();
Node(parent, start, end, tokens, compileErrors, node, "else");
return(node);
}
case SyntaxType.ElifPart:
{
SyntaxNode node = new ElifNode(tokens[start - 1].Childs[0]);
Node(parent, start, end, tokens, compileErrors, node, "else-if");
return(node);
}
case SyntaxType.For:
{
SyntaxNode node = new ForNode(tokens[start - 1], tokens[end]);
Node(parent, start, end, tokens, compileErrors, node, "for");
return(node);
}
case SyntaxType.Foreach:
{
SyntaxNode node = new ForeachNode(tokens[start - 1], tokens[end]);
Node(parent, start, end, tokens, compileErrors, node, "foreach");
return(node);
}
case SyntaxType.While:
{
SyntaxNode node = new WhileNode(tokens[start - 1].Childs[0]);
Node(parent, start, end, tokens, compileErrors, node, "while");
return(node);
}
case SyntaxType.DoWhile:
{
SyntaxNode node = new DoWhileNode(tokens[end].Childs[0]);
Node(parent, start, end, tokens, compileErrors, node, "do-while");
return(node);
}
default:
{
compileErrors.Add(new Error("Not implemented parser behaviour"));
return(null);
}
}
}
private void InterfaceEdited(string newValue, string path)
{
Node node = d_treeview.NodeStore.FindPath(path);
if (node == null)
{
return;
}
string val = newValue.Trim();
List <Undo.IAction> actions = new List <Undo.IAction>();
if (node is InterfaceNode)
{
InterfaceNode n = (InterfaceNode)node;
if (n.Target == val)
{
return;
}
if (val == "")
{
// Remove interface
actions.Add(new Undo.RemoveInterfaceVariable((Wrappers.Node)d_wrapper, n.Name, n.ChildName, n.VariableName));
string expr = "0";
Cdn.VariableFlags flags = Cdn.VariableFlags.None;
if (node.Variable != null)
{
expr = node.Variable.Expression.AsString;
flags = node.Variable.Flags;
}
// Add normal property instead
actions.Add(new Undo.AddVariable(d_wrapper, n.Name, expr, flags));
}
else
{
string child;
string prop;
if (!ParseInterface(val, out child, out prop))
{
return;
}
d_blockInterfaceRemove = true;
actions.Add(new Undo.RemoveInterfaceVariable((Wrappers.Node)d_wrapper, n.Name, n.ChildName, n.VariableName));
actions.Add(new Undo.AddInterfaceProperty((Wrappers.Node)d_wrapper, n.Name, child, prop));
}
}
else if (val != "")
{
string child;
string prop;
if (!ParseInterface(val, out child, out prop))
{
return;
}
actions.Add(new Undo.RemoveVariable(d_wrapper, node.Variable));
actions.Add(new Undo.AddInterfaceProperty((Wrappers.Node)d_wrapper, node.Variable.Name, child, prop));
}
else
{
return;
}
try
{
d_actions.Do(new Undo.Group(actions));
}
catch (GLib.GException err)
{
// Display could not remove, or something
Error(this, err);
}
d_blockInterfaceRemove = false;
}
