public CellDescriptor(MathNode content, string halign, string valign, int colspan, int rowspan)
{
Content = content;
HAlign = halign;
VAlign = valign;
ColSpan = colspan;
RowSpan = rowspan;
}
public static void HideProgress()
{
#if DEBUG
MathNode.Trace("Unloading progress message");
#endif
if (_form != null)
{
if (_form.IsDisposed || _form.Disposing)
{
_form = null;
}
}
if (_form != null)
{
_form.Close();
}
}
public override CodeExpression ExportCode(IMethodCompile method)
{
MathNode.Trace("{0}.ExportCode for {1}", this.GetType().Name, operaterType);
CodeExpression e1 = this[0].ExportCode(method);
if (!(this[0].DataType.Type.Equals(typeof(bool))))
{
e1 = new CodeBinaryOperatorExpression(e1, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(0));
}
CodeExpression e2 = this[1].ExportCode(method);
if (!(this[1].DataType.Type.Equals(typeof(bool))))
{
e2 = new CodeBinaryOperatorExpression(e2, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(0));
}
return(new CodeBinaryOperatorExpression(e1, operaterType, e2));
}
public override Shader GetShader()
{
if (m_original.DisplayMaterial)
{
var front = GetShaderPart(m_original.Front);
var back = GetShaderPart(m_original.Back);
var backfacing = new GeometryInfoNode("backfacepicker");
var flipper = new MixClosureNode("front or back");
var lp = new LightPathNode("lp for bf");
var mlt = new MathNode("toggle bf only when camera ray")
{
Operation = MathNode.Operations.Multiply
};
m_shader.AddNode(backfacing);
m_shader.AddNode(flipper);
m_shader.AddNode(lp);
m_shader.AddNode(mlt);
lp.outs.IsCameraRay.Connect(mlt.ins.Value1);
backfacing.outs.Backfacing.Connect(mlt.ins.Value2);
mlt.outs.Value.Connect(flipper.ins.Fac);
var frontclosure = front.GetClosureSocket();
var backclosure = back.GetClosureSocket();
frontclosure.Connect(flipper.ins.Closure1);
backclosure.Connect(flipper.ins.Closure2);
flipper.outs.Closure.Connect(m_shader.Output.ins.Surface);
}
else
{
var last = GetShaderPart(m_original.Front);
var lastclosure = last.GetClosureSocket();
lastclosure.Connect(m_shader.Output.ins.Surface);
}
m_shader.FinalizeGraph();
return(m_shader);
}
public override System.CodeDom.CodeExpression ExportCode(IMethodCompile method)
{
MathNode.Trace("{0}.ExportCode: [{1}]", this.GetType().Name, this[0].TraceInfo);
CodeMethodReferenceExpression mr = new CodeMethodReferenceExpression();
mr.MethodName = "Sqrt";
mr.TargetObject = new CodeTypeReferenceExpression(typeof(Math));
CodeExpression[] ps = new CodeExpression[1];
ps[0] = this[0].ExportCode(method);
if (!this[0].DataType.Type.Equals(typeof(double)))
{
ps[0] = new CodeCastExpression(typeof(double), VPLUtil.GetCoreExpressionFromCast(ps[0]));
}
return(new CodeMethodInvokeExpression(
mr,
ps));
}
public override bool Edit(UInt32 actionBranchId, Rectangle rcStart, ILimnorDesignerLoader loader, Form caller)
{
if (Owner == null)
{
Owner = loader.GetRootId();
}
try
{
_origiContext = VPLUtil.CurrentRunContext;
if (loader.Project.IsWebApplication)
{
if (this.RunAt == EnumWebRunAt.Client)
{
VPLUtil.CurrentRunContext = EnumRunContext.Client;
}
else
{
VPLUtil.CurrentRunContext = EnumRunContext.Server;
}
}
else
{
VPLUtil.CurrentRunContext = EnumRunContext.Server;
}
DlgMethod dlg = this.CreateMethodEditor(rcStart);
dlg.LoadMethod(this, EnumParameterEditType.ReadOnly);
if (dlg.EditSubAction(caller))
{
IsNewMethod = false;
loader.GetRootId().SaveAction(this, loader.Writer);
loader.NotifyChanges();
return(true);
}
}
catch (Exception err)
{
MathNode.Log(caller, err);
}
finally
{
ExitEditor();
VPLUtil.CurrentRunContext = _origiContext;
}
return(false);
}
public override object CloneExp(MathNode parent)
{
MathNodeVariable node = (MathNodeVariable)base.CloneExp(parent);
node.VariableName = _value;
node.SubscriptName = _subscript;
node._id = ID;
node.IsLocal = IsLocal;
node.IsParam = IsParam;
node.IsReturn = IsReturn;
node._passin = _passin;
if (_subscriptFont != null)
{
node._subscriptFont = (Font)_subscriptFont.Clone();
}
node.IsSuperscript = IsSuperscript;
node.Position = new Point(Position.X, Position.Y);
if (VariableType == null)
{
throw new MathException("VariableType is null when clone it. {0}", _value);
}
else
{
node.VariableType = (RaisDataType)VariableType.Clone();
}
if (ClonePorts)
{
if (_outports != null)
{
LinkLineNodeOutPort[] ports = new LinkLineNodeOutPort[_outports.Length];
for (int i = 0; i < ports.Length; i++)
{
_outports[i].ConstructorParameters = new object[] { node };
ports[i] = (LinkLineNodeOutPort)_outports[i].Clone();
}
node.OutPorts = ports;
}
if (_inport != null)
{
_inport.ConstructorParameters = new object[] { node };
node.InPort = (LinkLineNodeInPort)_inport.Clone();
}
}
return(node);
}
void _timerX_Tick(object sender, EventArgs e)
{
if (_timerX != null)
{
_timerX.Enabled = false;
_timerX = null;
}
string src = string.Empty;
string tgt = string.Empty;
try
{
src = _htmlFile;
tgt = Path.Combine(_projectFolder, Path.GetFileName(_htmlFile));
File.Copy(src, tgt, true);
src = Path.Combine(Path.GetDirectoryName(_htmlFile), string.Format(CultureInfo.InvariantCulture, "{0}.css", Path.GetFileNameWithoutExtension(_htmlFile)));
if (File.Exists(src))
{
tgt = Path.Combine(_projectFolder, Path.GetFileName(src));
File.Copy(src, tgt, true);
}
}
catch (Exception err)
{
MathNode.LogError(string.Format(CultureInfo.InvariantCulture, "Error copying from [{0}] to [{1}]. {2}", src, tgt, err.Message));
}
int p = _htmlFile.LastIndexOf('.');
if (p > 0)
{
src = string.Format(CultureInfo.InvariantCulture, "{0}.css", _htmlFile.Substring(0, p));
if (File.Exists(src))
{
tgt = Path.Combine(_projectFolder, Path.GetFileName(src));
try
{
File.Copy(src, tgt, true);
}
catch (Exception err)
{
MathNode.LogError(string.Format(CultureInfo.InvariantCulture, "Error copying from [{0}] to [{1}]. {2}", src, tgt, err.Message));
}
}
}
}
public override object EditValue(System.ComponentModel.ITypeDescriptorContext context, System.IServiceProvider provider, object value)
{
IWindowsFormsEditorService edSvc = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (edSvc != null)
{
edSvc.CloseDropDown();
IMethodSelector ts = (IMethodSelector)MathNode.GetService(typeof(IMethodSelector));
if (ts != null)
{
UITypeEditorEditStyle style = ts.GetUIEditorStyle(context);
if (style == UITypeEditorEditStyle.DropDown)
{
IDataSelectionControl dropdown = ts.GetUIEditorDropdown(context, provider, value);
if (dropdown != null)
{
edSvc.DropDownControl((Control)dropdown);
object v = dropdown.UITypeEditorSelectedValue;
if (v != null)
{
return(v);
}
}
}
else if (style == UITypeEditorEditStyle.Modal)
{
IDataSelectionControl modal = ts.GetUIEditorModal(context, provider, value);
if (modal != null)
{
if (edSvc.ShowDialog((Form)modal) == DialogResult.OK)
{
IMethodNode mn = context.Instance as IMethodNode;
if (mn != null)
{
mn.SetFunction(modal.UITypeEditorSelectedValue);
return(mn.GetFunctionName());
}
return(modal.UITypeEditorSelectedValue);
}
}
}
}
}
return(value);
}
public override string CreatePhpScript(StringCollection method)
{
MathNode.Trace("{0}.CreatePhpScript", this.GetType().Name);
string sum = ((IVariable)this[4]).CodeVariableName;
this[2].AssignPhpScriptCodeExp(this.GetParameterCodePhp(method, 0), ((MathNodeVariable)this[3]).CodeVariableName);
string fa = this.GetParameterCodePhp(method, 2);
this[2].AssignPhpScriptCodeExp(this.GetParameterCodePhp(method, 1), ((MathNodeVariable)this[3]).CodeVariableName);
string fb = this.GetParameterCodePhp(method, 2);
this[2].AssignPhpScriptCodeExp(null, ((MathNodeVariable)this[3]).CodeVariableName);
string f2 = MathNode.FormString("({0} + {1}) / 2.0", fa, fb);
string f = MathNode.FormString("{0} + {1}", f2, sum);
string ba = MathNode.FormString("({0} - {1}) / {2}", this.GetParameterCodePhp(method, 1), this.GetParameterCodePhp(method, 0), _intervals);
return(MathNode.FormString("({0}) * ({1})", ba, f));
}
public void SetEventLink(IEvent e)
{
IEventPointer ep = e as IEventPointer;
if (ep != null)
{
CompilerErrorCollection errors = DynamicLink.LinkEvent(ep, taskExecuter);
if (errors != null && errors.Count > 0)
{
StringCollection sc = new StringCollection();
for (int i = 0; i < errors.Count; i++)
{
sc.Add(errors[i].ErrorText);
}
MathNode.Log(sc);
}
}
}
public override void OnReadFromXmlNode(IXmlCodeReader serializer, XmlNode node)
{
base.OnReadFromXmlNode(serializer, node);
MethodId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_handlerId);
XmlObjectReader reader = (XmlObjectReader)serializer;
ClassPointer root = reader.ObjectList.RootPointer as ClassPointer;
MethodClass mc = root.GetCustomMethodById(MethodId);
if (mc == null)
{
MathNode.LogError(string.Format(System.Globalization.CultureInfo.InvariantCulture,
"Method {0} not found in class {1}", MethodId, root.ClassId));
}
else
{
_method = mc;
}
}
protected override object OnEditValue(ITypeDescriptorContext context, IServiceProvider provider, System.Windows.Forms.Design.IWindowsFormsEditorService service, object value)
{
IWithProject mc = context.Instance as IWithProject;
if (mc != null)
{
if (mc.Project == null)
{
MathNode.Log(TraceLogClass.GetForm(provider), new DesignerException("Project not set for {0} [{1}]", mc, mc.GetType()));
}
else
{
SetterClass val = value as SetterClass;
System.Drawing.Point curPoint = System.Windows.Forms.Cursor.Position;
rc.X = curPoint.X;
rc.Y = curPoint.Y;
DlgMethod dlg = val.CreateMethodEditor(rc);
try
{
dlg.LoadMethod(val, EnumParameterEditType.ReadOnly);
dlg.SetNameReadOnly();
if (service.ShowDialog((Form)dlg) == DialogResult.OK)
{
value = val;
ILimnorDesignerLoader l = LimnorProject.ActiveDesignerLoader as ILimnorDesignerLoader;
if (l != null)
{
DesignUtil.SaveCustomProperty(LimnorProject.ActiveDesignerLoader.Node, l.Writer, val.Property);
LimnorProject.ActiveDesignerLoader.NotifyChanges();
}
}
}
catch (Exception err)
{
MathNode.Log(TraceLogClass.GetForm(provider), err);
}
finally
{
val.ExitEditor();
}
}
}
return(value);
}
public static void ParseMML(XElement root, MathNode parentNode, MathConfig mc, int depth)
{
int recDepth = depth + 1;
foreach (XElement element in root.Elements())
{
//ToDo: implement namespaces
Console.WriteLine("{0} {1}", new String(' ', recDepth), element.Name);
MathNode mn = new MathNode(
element.Name.LocalName,
element.Attributes().ToDictionary(kvp => kvp.Name.ToString(), kvp => kvp.Value),
mc, parentNode);
element.Nodes()
.Where(x => x.NodeType == System.Xml.XmlNodeType.Text || x.NodeType == System.Xml.XmlNodeType.Whitespace)
.ToList()
.ForEach(x => mn.Text = mn.Text + string.Join(" ", ((XText)x).Value.Split(null)));
ParseMML(element, mn, mc, recDepth);
}
}
public override void LinkJumpedBranches(BranchList branches)
{
if (_jumpToId != 0)
{
if (_jumpToActionBranch == null || (_jumpToActionBranch.BranchId != _jumpToId && _jumpToActionBranch.FirstActionId != _jumpToId))
{
_jumpToActionBranch = branches.GetJumpToActionBranch(_jumpToId);
if (_jumpToActionBranch == null)
{
throw new DesignerException("Invalid jump id [{0}] for branch [{1}]", _jumpToId, this.BranchId);
}
MathNode.Trace("Action string jump from [{0},{1}] to [{2},{3}]", this.BranchId, this.Name, _jumpToActionBranch.BranchId, _jumpToActionBranch.Name);
}
_jumpToActionBranch.SetPreviousAction(this);
this.SetNextAction(_jumpToActionBranch);
}
base.LinkJumpedBranches(branches);
}
public bool OnSelectEntry(SearchTreeEntry entry, SearchWindowContext context)
{
if (!(entry is SearchTreeGroupEntry))
{
if (!GraphViewStaticBridge.HasGUIView(graphView))
{
return(false);
}
MathNode node = ScriptableObject.CreateInstance(entry.userData as Type) as MathNode;
AddNode(node);
Node nodeUI = CreateNode(node) as Node;
if (nodeUI != null)
{
if (m_InsertStack != null)
{
MathStackNode stackNode = m_InsertStack.userData as MathStackNode;
stackNode.InsertNode(m_InsertIndex, node);
m_InsertStack.InsertElement(m_InsertIndex, nodeUI);
}
else
{
graphView.AddElement(nodeUI);
Vector2 pointInWindow = context.screenMousePosition - position.position;
Vector2 pointInGraph = nodeUI.parent.WorldToLocal(pointInWindow);
nodeUI.SetPosition(new Rect(pointInGraph, Vector2.zero)); // it's ok to pass zero here because width/height is dynamic
}
nodeUI.Select(graphView, false);
}
else
{
Debug.LogError("Failed to create element for " + node);
return(false);
}
return(true);
}
return(false);
}
public override CodeExpression ExportCode(IMethodCompile method)
{
if (_passin != null)
{
return(_passin);
}
string s = method.GetParameterCodeNameById(this.Parameter.ID);
if (string.IsNullOrEmpty(s))
{
MathNode.Trace("Argument '{0}' is not an argument for method '{1}'", ArgumentName, method.MethodName);
return(ValueTypeUtil.GetDefaultCodeByType(Parameter.DataType.Type));
}
else
{
MathNode.Trace("{0}.ExportCode maps {1} to {2}", this.GetType().Name, ArgumentName, s);
return(new CodeArgumentReferenceExpression(s));
}
}
public void DeleteSelectedComponents()
{
try
{
bool bSaved = false;
ISelectionService ss = (ISelectionService)dsf.GetService(typeof(ISelectionService));
if (ss != null)
{
ICollection cc = ss.GetSelectedComponents();
if (cc != null)
{
IDesignerHost host = (IDesignerHost)dsf.GetService(typeof(IDesignerHost));
if (host != null)
{
CreateUndoTransaction("deleteSelectedComponent");
foreach (object v in cc)
{
if (v is System.ComponentModel.IComponent)
{
if (v != host.RootComponent)
{
if (!bSaved)
{
bSaved = true;
bLoading = true;
bLoading = false;
}
host.DestroyComponent((System.ComponentModel.IComponent)v);
}
}
}
root.Changed = true;
CommitUndoTransaction("deleteSelectedComponent");
}
}
}
}
catch (Exception err)
{
MathNode.Log(this.FindForm(), err);
RollbackUndoTransaction("deleteSelectedComponent");
}
}
public void RemoveEmptyScopes()
{
graphView.schedule.Execute(a =>
{
foreach (GraphElement element in graphView.graphElements.ToList())
{
Scope scope = element as Scope;
if (scope != null && !(scope is Group) && scope.containedElements.Count() == 0)
{
MathNode mathNode = scope.userData as MathNode;
DestroyNode(mathNode);
graphView.RemoveElement(scope);
}
}
});
}
private void timer1_Tick(object sender, EventArgs e)
{
timer1.Enabled = false;
tvGac.LoadGac();
//
StringCollection sc = new StringCollection();
List <Assembly> refs = _project.GetReferences(sc);
if (sc.Count > 0)
{
MathNode.Log(sc);
}
foreach (Assembly a in refs)
{
tvGac.Nodes.Add(new TreeNodeAssembly(a));
}
//add an empty node to make sure all nodes are visible
tvGac.Nodes.Add(new TreeNodeDummy());
}
public override void ExportPhpScriptCodeStatements(StringCollection method)
{
MathNode.Trace("ExportPhpScriptCodeStatements for {0}", this.GetType());
//0:function
//1:index
//2:begin
//3:end
//4:sum
OnPreparePhpScriptVariable(method);
string sum = ((IVariable)this[4]).CodeVariableName;
string declareSum = FormString("{0}={1};\r\n", ((IVariable)this[4]).CodeVariableName, ValueTypeUtil.GetDefaultPhpScriptCodeByType(((IVariable)this[4]).VariableType.Type));
method.Add(declareSum);
string idx = this[1].CreatePhpScript(method);
method.Add(FormString("for({0}={1};{2}<={3};({2})++)\r\n{\r\n", ((IVariable)this[1]).CodeVariableName, this[2].CreatePhpScript(method), idx, this[3].CreatePhpScript(method)));
method.Add(FormString("{0} = {0} + {1};\r\n", sum, this[0].CreatePhpScript(method)));
method.Add("}\r\n");
}
public override object CloneExp(MathNode parent)
{
MathNodeValue node = (MathNodeValue)base.CloneExp(parent);
node.ValueType = this.ValueType;
ICloneable ic = _value as ICloneable;
if (ic != null)
{
node.Value = ic.Clone();
}
else
{
if (this.ValueType.Type.IsValueType)
{
node.Value = _value;
}
}
return(node);
}
public RaisDataType GetRelatedType()
{
MathNode p = this.Parent;
if (p != null)
{
int n = p.ChildNodeCount;
if (n > 1)
{
for (int i = 0; i < n; i++)
{
if (p[i] != this)
{
return(p[i].DataType);
}
}
}
}
return(ValueType);
}
protected override void OnEditAction()
{
MethodDiagramViewer mv = this.DiagramViewer;
if (mv != null)
{
AB_ActionList av = this.ActionObject as AB_ActionList;
ActionList aList = av.Actions;
DlgActionList dlg = new DlgActionList();
dlg.LoadData(aList, mv.Method, mv.Project, mv.DesignerHolder);
Form f = this.FindForm();
#if DEBUG
MathNode.Trace("Showing dialog");
#endif
if (dlg.ShowDialog(f) == DialogResult.OK)
{
av.Actions = dlg.Result;
mv.Changed = true;
foreach (ActionItem a in aList)
{
if (a.Action != null && a.Action.Changed)
{
if (!mv.ChangedActions.ContainsKey(a.ActionId))
{
mv.ChangedActions.Add(a.ActionId, a.Action);
}
}
}
}
else
{
foreach (ActionItem a in aList)
{
if (a.Action != null && a.Action.Changed)
{
a.Action.ReloadFromXmlNode();
}
}
}
}
}
void mnu_separate(object sender, EventArgs e)
{
BinOperatorNode bin = Root.FocusedNode as BinOperatorNode;
if (bin != null)
{
BinOperatorNode bin2 = bin[1] as BinOperatorNode;
if (bin2 != null)
{
//modify it from {0} b {b2} to
//{0} b {b2[0]} b2 {b2[1]}
//
//new b[1] = {b2[0]}
//new b2[0] = new b => {0} b {b2[0]}
//new b2[1] = {b2[1]}
//MathNode b1 = bin[1];
//
MathNode np = bin.Parent;
int k = -1;
for (int i = 0; i < np.ChildNodeCount; i++)
{
if (np[i] == bin)
{
k = i;
break;
}
}
if (k >= 0)
{
BinOperatorNode nb2 = (BinOperatorNode)Activator.CreateInstance(bin2.GetType(), bin.Parent);
bin[1] = bin2[0];
nb2[0] = bin;
nb2[1] = bin2[1];
//
np[k] = nb2;
this.Refresh();
Root.SetFocus(bin);
}
}
}
}
/// <summary>
/// edit this action
/// </summary>
/// <param name="exp"></param>
private void showEditor(IMathExpression exp)
{
try
{
Rectangle rc = this.Parent.RectangleToScreen(this.Bounds);
IMathEditor dlg = exp.CreateEditor(rc);
IMathDesigner md = this.Parent as IMathDesigner;
if (md.TestDisabled)
{
dlg.DisableTest();
}
if (((Form)dlg).ShowDialog(this.FindForm()) == DialogResult.OK)
{
setChanged();
}
}
catch (Exception err)
{
MathNode.Log(this.FindForm(), err);
}
}
/// <summary>
/// declare a variable and initialize it with default value.
/// </summary>
/// <param name="supprtStatements"></param>
/// <param name="var"></param>
public static void DeclareVariable(CodeStatementCollection supprtStatements, IVariable var)
{
if (var is MathNodeVariableDummy)
{
return;
}
if (!VariableDeclared(supprtStatements, var.CodeVariableName))
{
MathNode.Trace("Declare variable {0}", var.TraceInfo);
CodeVariableDeclarationStatement p;
if (var.VariableType.Type.IsValueType)
{
p = new CodeVariableDeclarationStatement(new CodeTypeReference(var.VariableType.Type), var.CodeVariableName);
}
else
{
p = new CodeVariableDeclarationStatement(new CodeTypeReference(var.VariableType.Type), var.CodeVariableName, ValueTypeUtil.GetDefaultCodeByType(var.VariableType.Type));
}
supprtStatements.Add(p);
}
}
public override void OnReplaceNode(MathNode replaced)
{
if (this.Parent != null && this.Parent.ChildNodeCount > 1)
{
for (int i = 0; i < this.Parent.ChildNodeCount; i++)
{
if (this.Parent[i] != this)
{
if (!typeof(object).Equals(this.Parent[i].DataType.Type))
{
ValueType = this.Parent[i].DataType;
}
break;
}
}
}
else
{
ValueType = replaced.DataType;
}
}
public void Successfully_SortAscendingWithNestedMath()
{
var data = Data(SortConf);
var inner1 = new MathNode(MathOp.Add, Three, Two);
var inner2 = new MathNode(MathOp.Add, Five, Four);
var sub = new MathNode(MathOp.Subtract, inner1, inner2);
var inner3 = new MathNode(MathOp.Multiply, Six, One);
var add = new MathNode(MathOp.Add, sub, inner3);
var group = new GroupNode(null, new List <DiceAST> {
add
});
var func = new FunctionNode(FunctionScope.Group, "expand", new DiceAST[0], data);
func.Context.Expression = group;
var node = new SortNode(SortDirection.Ascending)
{
Expression = func
};
EvaluateNode(node, data, 0, "{3 + 2 - (5 + 4) + 6 * 1}.expand().sortAsc() => (2 + 3 - (4 + 5) + 1 * 6) => 2");
}
public override CodeExpression ExportCode(IMethodCompile method)
{
MathNode.Trace("{0}.ExportCode", this.GetType().Name);
CodeExpression e1 = this[0].ExportCode(method);
CodeExpression e2 = this[1].ExportCode(method);
CodeMethodInvokeExpression cmie = new CodeMethodInvokeExpression();
cmie.Method = new CodeMethodReferenceExpression();
cmie.Method.TargetObject = new CodeTypeReferenceExpression(typeof(CodeDomHelper));
if (shifLeft)
{
cmie.Method.MethodName = "ShifLeft";
}
else
{
cmie.Method.MethodName = "ShifRight";
}
cmie.Parameters.Add(e1);
cmie.Parameters.Add(e2);
return(cmie);
}
public override CodeExpression ExportCode(IMethodCompile method) //)
{
CodeStatementCollection supprtStatements = method.MethodCode.Statements;
if (this.UseDefaultValue)
{
if (_default == null)
{
MathNode.Trace("MathNodeParameter.ExportCode: Use default case 0:null");
return(ValueTypeUtil.GetDefaultCodeByType(this.DataType.Type));
}
else
{
MathNode.Trace("MathNodeParameter.ExportCode: Use default case 1:{0}", _default);
return(ObjectCreationCodeGen.ObjectCreationCode(_default));
}
}
else
{
if (this.InPort != null && this.InPort.LinkedPortID != 0)
{
MathNode.Trace("MathNodeParameter.ExportCode: call linked item");
IMathExpression rootContainer = this.root.RootContainer;
if (rootContainer == null)
{
throw new MathException(XmlSerialization.FormatString("Parameter {0} not associated with a root container", this.TraceInfo));
}
MathExpItem LinkedItem = rootContainer.GetItemByID(this.InPort.LinkedPortID);
if (LinkedItem == null)
{
throw new MathException(string.Format("Linked Port ID {0} from ({1}) does not match an item", InPort.LinkedPortID, this.TraceInfo));
}
CodeExpression ce = LinkedItem.ReturnCodeExpression(method);
return(RaisDataType.GetConversionCode(LinkedItem.MathExpression.DataType, ce, this.DataType, supprtStatements));
}
//
MathNode.Trace("MathNodeParameter.ExportCode: call MathNodeVariable.ExportCode");
return(base.ExportCode(method));
}
}
