public void CreateViewer(MathNodeRoot item)
{
MathExpViewer mv = holder.AddMathViewer(item, 50, 50);
ReturnIcon ri = holder.CreateReturnIcon(item.DataType);
LinkLineNode.JoinToEnd((LinkLineNode)mv.OutputPorts[0].NextNode, ri.InPort);
}
protected override void OnSave(XmlNode node)
{
if (_methodPointer != null)
{
MathNodeRoot r = this.root;
if (r != null)
{
XmlObjectWriter xw = r.Writer as XmlObjectWriter;
if (xw != null)
{
XmlNode nodeMethod = node.SelectSingleNode(XmlSerialization.XML_METHOD);
if (nodeMethod == null)
{
nodeMethod = node.OwnerDocument.CreateElement(XmlSerialization.XML_METHOD);
node.AppendChild(nodeMethod);
}
xw.WriteObjectToNode(nodeMethod, _methodPointer);
XmlUtil.SetAttribute(nodeMethod, XmlTags.XMLATT_NodeId, ID);
}
else
{
throw new DesignerException("Writer not available calling MathNodeMethodPointer.OnSave");
}
}
}
}
public ReturnIcon(RaisDataType dataType)
{
Location = new Point(300, 300);
SaveLocation();
this.Size = new Size(32, 32);
System.Drawing.ToolboxBitmapAttribute tba = TypeDescriptor.GetAttributes(this.GetType())[typeof(System.Drawing.ToolboxBitmapAttribute)] as System.Drawing.ToolboxBitmapAttribute;
if (tba != null)
{
bmp = (System.Drawing.Bitmap)tba.GetImage(this.GetType());
}
MathNodeRoot root = new MathNodeRoot();
root.IsVariableHolder = true;
var = new MathNodeVariableDummy(root);
root[0] = var;
if (dataType != null)
{
var.VariableType = dataType;
var.TypeDefined = true;
}
LinkLineNodeInPort port = new LinkLineNodeInPort(var);
port.ClearLine();
port.SetPrevious(null);
port.Owner = this;
port.HideLabel();
var.InPort = port;
port.Owner = this;
port.Label.Visible = false;
port.Location = new Point(this.Left + this.Width / 2 - port.Width / 2, this.Top - port.Height);
port.SaveLocation();
}
public static bool ActionUseInput(IAction a)
{
if (a != null)
{
List <ParameterValue> pvs = a.ParameterValues;
if (pvs != null && pvs.Count > 0)
{
foreach (ParameterValue p in pvs)
{
if (p.ValueType == EnumValueType.MathExpression)
{
MathNodeRoot mr = p.MathExpression as MathNodeRoot;
if (mr != null)
{
return(mr.UseInput);
}
}
else if (p.ValueType == EnumValueType.Property)
{
ActionInput ai = p.Property as ActionInput;
if (ai != null)
{
return(true);
}
}
}
}
}
return(false);
}
public static void ActionSetInputName(IAction a, string name, DataTypePointer type)
{
if (a != null)
{
if (a.ActionCondition != null)
{
a.ActionCondition.SetActionInputName(name, type.BaseClassType);
}
List <ParameterValue> pvs = a.ParameterValues;
if (pvs != null && pvs.Count > 0)
{
foreach (ParameterValue p in pvs)
{
if (p.ValueType == EnumValueType.MathExpression)
{
MathNodeRoot mr = p.MathExpression as MathNodeRoot;
if (mr != null)
{
mr.SetActionInputName(name, type.BaseClassType);
}
}
else if (p.ValueType == EnumValueType.Property)
{
ActionInput ai = p.Property as ActionInput;
if (ai != null)
{
ai.SetActionInputName(name, type);
}
}
}
}
}
}
public override void OnDoubleClick(Control host)
{
Form f = host.FindForm();
host.Cursor = System.Windows.Forms.Cursors.WaitCursor;
if (f != null)
{
f.Cursor = System.Windows.Forms.Cursors.WaitCursor;
}
IObjectPointer pp = _valuePointer;
IMethod method = null;
MathNodeRoot r = this.root;
if (r != null)
{
method = r.ScopeMethod;
}
FrmObjectExplorer dlg = DesignUtil.GetPropertySelector(pp, method, null);
if (dlg != null)
{
if (dlg.ShowDialog(f) == DialogResult.OK)
{
_valuePointer = dlg.SelectedObject as IObjectPointer;
host.Invalidate();
}
}
host.Cursor = System.Windows.Forms.Cursors.Default;
if (f != null)
{
f.Cursor = System.Windows.Forms.Cursors.Default;
}
}
public static void ActionFindItemByType <T>(IAction a, List <T> results)
{
if (a != null)
{
List <ParameterValue> pvs = a.ParameterValues;
if (pvs != null && pvs.Count > 0)
{
foreach (ParameterValue p in pvs)
{
if (p.ValueType == EnumValueType.MathExpression)
{
MathNodeRoot mr = p.MathExpression as MathNodeRoot;
if (mr != null)
{
mr.FindItemByType <T>(results);
}
}
else if (p.ValueType == EnumValueType.Property)
{
object v = p.Property;
if (v is T)
{
results.Add((T)v);
}
}
}
}
}
}
public void SetVariable(IVariable variable)
{
if (variable == null)
{
throw new MathException("variable cannot be null");
}
var = variable;
if (variable is MathNode)
{
root = ((MathNode)variable).root;
}
if (root == null)
{
//create a root for drawing the variable
root = new MathNodeRoot();
if (var is MathNode)
{
root[0] = (MathNode)var;
((MathNode)var).IsFocused = false;
}
else
{
}
root.SetFont(this.Font);
}
}
public override object EditValue(System.ComponentModel.ITypeDescriptorContext context, IServiceProvider provider, object value)
{
if (context != null && context.Instance != null && provider != null)
{
IWindowsFormsEditorService service = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (service != null)
{
IWithProject mc = context.Instance as IWithProject;
if (mc == null)
{
MathNode.Log(new DesignerException("{0} does not implement IWithProject", context.Instance.GetType()));
}
else
{
if (mc.Project == null)
{
MathNode.Log(new DesignerException("Project not set for {0} [{1}]", mc, mc.GetType()));
}
else
{
Rectangle rc = new Rectangle(System.Windows.Forms.Cursor.Position, new Size(20, 60));
IMathExpression im = value as IMathExpression;
if (im == null)
{
im = new MathNodeRoot();
}
}
}
}
}
return(value);
}
public override void OnReadFromXmlNode(IXmlCodeReader serializer, XmlNode node)
{
base.OnReadFromXmlNode(serializer, node);
XmlNode nd = node.SelectSingleNode(XML_VAR);
if (nd != null)
{
MathNodeRoot root = new MathNodeRoot();
root.IsVariableHolder = true;
root[0] = var;
var.Load(nd);
if (var.InPort != null)
{
var.InPort.Owner = this;
var.InPort.Label.Visible = false;
}
if (var.OutPorts != null)
{
LinkLineNodeOutPort[] o = var.OutPorts;
for (int i = 0; i < o.Length; i++)
{
o[i].Owner = this;
}
}
}
this.Size = new Size(32, 32);
}
public DrawingVariable(Control owner)
: base(owner)
{
root = new MathNodeRoot();
var = (IVariable)root[0];
this.Size = new Size(20, 20);
RelativePosition = new RelativePosition(this, -20, -20, true, true);
}
public void Add(MathNodeRoot condition, ActionList act)
{
if (_decisionTable == null)
{
_decisionTable = new List <DecisionItem>();
}
_decisionTable.Add(new DecisionItem(condition, act));
}
private void btAdd_Click(object sender, EventArgs e)
{
MathNodeRoot r = new MathNodeRoot();
r.Project = _prj;
r.ScopeMethod = _method;
_dataTable.Rows.Add(r, null);
}
public override void SetValue(object component, object value)
{
MathNodeRoot r = value as MathNodeRoot;
if (r != null)
{
_owner.Condition = r;
}
}
public virtual void OnReadFromXmlNode(IXmlCodeReader reader, XmlNode node)
{
_exp = new MathNodeRoot();
_hasData = XmlUtil.GetAttributeBoolDefFalse(node, XMLATT_HasData);
if (_hasData)
{
_exp.OnReadFromXmlNode(reader, node);
}
}
public override void FindItemByType <T>(List <T> results)
{
MathNodeRoot r = RepeatCount.MathExpression as MathNodeRoot;
if (r != null)
{
r.FindItemByType <T>(results);
}
base.FindItemByType <T>(results);
}
/// <summary>
/// set the input variable name to all input variables
/// </summary>
/// <param name="name"></param>
public override void SetInputName(string name, DataTypePointer type)
{
if (RepeatCount.MathExpression != null)
{
MathNodeRoot r = RepeatCount.MathExpression as MathNodeRoot;
if (r != null)
{
r.SetActionInputName(name, type.BaseClassType);
}
}
base.SetInputName(name, type);
}
public override object Clone()
{
DrawingVariable clone = (DrawingVariable)base.Clone();
clone.LabelVisible = _labelVisible;
if (root != null)
{
MathNodeRoot r = (MathNodeRoot)root.Clone();
clone.SetDrawingAttributes(r);
}
return(clone);
}
// Overrides the ConvertFrom method of TypeConverter.
public override object ConvertFrom(ITypeDescriptorContext context,
CultureInfo culture, object value)
{
if (value is string)
{
MathNodeRoot r = new MathNodeRoot();
MathNodeStringValue mv = new MathNodeStringValue(r);
mv.Value = (string)value;
r[1] = mv;
return(r);
}
return(base.ConvertFrom(context, culture, value));
}
public override PropertyDescriptorCollection GetProperties(Attribute[] attributes)
{
PropertyDescriptorCollection ps = TypeDescriptor.GetProperties(this, attributes, true);
if (VPLUtil.GetBrowseableProperties(attributes))
{
MathNodeRoot mr = MathExp as MathNodeRoot;
if (mr != null)
{
}
}
return(ps);
}
public override void SetOwnerMethod(List <UInt32> used, MethodClass m)
{
base.SetOwnerMethod(used, m);
RepeatCount.ScopeMethod = m;
if (RepeatCount.MathExpression != null)
{
MathNodeRoot r = RepeatCount.MathExpression as MathNodeRoot;
if (r != null)
{
r.Project = m.Project;
}
}
}
public override void SetFunction(object func)
{
MathNodeRoot math = func as MathNodeRoot;
if (math != null)
{
MathNodeMethodInvoke mi = math[1] as MathNodeMethodInvoke;
if (mi != null)
{
this.MethodReference = mi.MethodReference;
}
}
}
public override void Execute(List <ParameterClass> eventParameters)
{
CompileResult cr = null;
int i = 0;
while (true)
{
if (RepeatCount.ValueType == EnumValueType.ConstantValue)
{
if (i < (int)RepeatCount.ConstantValue.GetValue(ConstObjectPointer.VALUE_Value))
{
break;
}
}
else if (RepeatCount.ValueType == EnumValueType.MathExpression)
{
MathNodeRoot r = RepeatCount.MathExpression as MathNodeRoot;
if (r == null)
{
break;
}
else
{
cr = r.DebugCompileUnit;
cr.Execute();
if (!Convert.ToBoolean(cr.ReturnValue))
{
break;
}
}
}
else
{
IObjectPointer p = RepeatCount.Property;
if (p == null)
{
break;
}
if (p.ObjectInstance == null)
{
break;
}
if (i < (int)(p.ObjectInstance))
{
break;
}
}
ExecuteActions(eventParameters);
i++;
}
}
public override object Clone()
{
ReturnIcon obj = (ReturnIcon)base.Clone();
if (bmp != null)
{
obj.SetBmp((Bitmap)bmp.Clone());
}
MathNodeRoot root = (MathNodeRoot)var.root.Clone();
obj.SetVar((MathNodeVariableDummy)root[0]);
obj.TypeDefined = this.TypeDefined;
return(obj);
}
public MathExpCtrl()
{
pen = new Pen(Color.Black, 1);
pen.DashStyle = System.Drawing.Drawing2D.DashStyle.Dot;
InitializeComponent();
_lblForScroll = new Label();
this.Controls.Add(_lblForScroll);
_lblForScroll.BorderStyle = BorderStyle.None;
_lblForScroll.Text = "";
_lblForScroll.Size = new Size(1, 1);
_lblForScroll.Location = new Point(0, 0);
mathExp = new MathNodeRoot();
mathExp.Position = new Point(8, 8);
initMathExp();
//
}
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
if (context != null && context.Instance != null && provider != null)
{
IWindowsFormsEditorService edSvc = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (edSvc != null)
{
FieldCalculatorCollection calculators = context.Instance as FieldCalculatorCollection;
if (calculators != null)
{
FieldCalculator ev = (FieldCalculator)value;
if (ev == null)
{
ev = new FieldCalculator();
ev.FieldName = context.PropertyDescriptor.Name;
}
MathNodeRoot root = ev.GetExpression();
if (root == null)
{
root = new MathNodeRoot();
ev.SetExpression(root);
}
System.Drawing.Point curPoint = System.Windows.Forms.Cursor.Position;
rc.X = curPoint.X;
rc.Y = curPoint.Y;
IMathEditor dlg = root.CreateEditor(rc);
dlg.SetScopeMethod(root.ScopeMethod);
dlg.MathExpression = (IMathExpression)root.Clone();
dlg.MathExpression.ScopeMethod = root.ScopeMethod;
dlg.MathExpression.EnableUndo = true;
if (edSvc.ShowDialog((Form)dlg) == DialogResult.OK)
{
root = (MathNodeRoot)dlg.MathExpression;
ev = new FieldCalculator();
ev.SetExpression(root);
ev.FieldName = context.PropertyDescriptor.Name;
value = ev;
calculators.SetItem(ev);
}
}
}
}
return(value);
}
/// <summary>
///
/// </summary>
/// <param name="MathExpression"></param>
/// <param name="x"></param>
/// <param name="y"></param>
/// <returns></returns>
public MathExpViewer AddMathViewer(MathNodeRoot MathExpression, int x, int y)
{
string name = CreateName(XmlSerialization.XML_Math);
IDesignerHost host = (IDesignerHost)dsf.GetService(typeof(IDesignerHost));
MathExpViewer v = (MathExpViewer)host.CreateComponent(typeof(MathExpViewer));
root.Controls.Add(v);
v.Visible = true;
v.Location = new Point(x, y);
//
v.LoadData((MathNodeRoot)MathExpression.Clone());
//
v.Name = name;
v.Site.Name = v.Name;
propertyGrid1.SelectedObject = v;
root.Refresh();
root.Changed = true;
return(v);
}
protected void SaveVariable(XmlNode node)
{
MathNodeVariable v = Variable as MathNodeVariable;
MathNodeRoot r = v.Parent as MathNodeRoot;
XmlSerialization.WriteValueToChildNode(node, "Font", r.TextFont);
XmlNode nd = node.SelectSingleNode("Var");
if (nd == null)
{
nd = node.OwnerDocument.CreateElement("Var");
node.AppendChild(nd);
}
else
{
nd.RemoveAll();
}
v.Save(nd);
}
public VariableMap CloneExp(MathNodeRoot root)
{
VariableList vlist = root.FindAllInputVariables();
VariableMap obj = new VariableMap();
foreach (KeyValuePair <IVariable, ICompileableItem> kv in this)
{
IVariable v = vlist.FindMatchingPublicVariable(kv.Key);
if (v == null)
{
throw new MathException("Variable not found for {0}", kv.Key);
}
//at this time, assume the root alread get the right clone owner
kv.Value.SetCloneOwner(root.ActionContext);
ICompileableItem item = (ICompileableItem)kv.Value.Clone();
obj.Add(v, item);
}
return(obj);
}
public override object Clone()
{
Parameter p = (Parameter)base.Clone();
p.Method = this.Method;
p.Fixed = Fixed;
p.TextFont = TextFont;
p.TextColor = TextColor;
p.Location = Location;
p.TransferLocalService(_localServices);
MathNodeRoot r = Variable.MathExpression;
MathNodeRoot r0 = (MathNodeRoot)r.Clone();
MathNodeVariable v = r0[0] as MathNodeVariable;
p.SetCodeVariable(v);
if (_castTo != null)
{
p.ProgEntity = (ProgramEntity)_castTo.Clone();
}
return(p);
}
