public void SetData(ILimnorDesignPane designer)
{
_designPane = designer;
_prj = designer.Loader.Project;
labelFolder.Text = _prj.ProjectFolder;
labelIDE.Text = Path.GetDirectoryName(Application.ExecutablePath);
}
public bool Edit(XmlObjectWriter writer, IMethod context, Form caller, bool isNewAction)
{
LimnorProject project = _class.Project;
FormActionParameters dlgData = new FormActionParameters();
if (_parameters == null)
{
_parameters = new ParameterValueCollection();
}
ActionMethod.ValidateParameterValues(_parameters);
dlgData.SetScopeMethod(context);
dlgData.LoadAction(this, _class.XmlData);
DialogResult ret = dlgData.ShowDialog(caller);
if (ret == DialogResult.OK)
{
_class.SaveAction(this, writer);
ILimnorDesignPane pane = project.GetTypedData <ILimnorDesignPane>(_class.ClassId);
if (pane != null)
{
pane.OnActionChanged(_class.ClassId, this, isNewAction);
pane.OnNotifyChanges();
}
else
{
DesignUtil.WriteToOutputWindowAndLog("Error editong ActionAssignInstance. ClassPointer [{0}] is not in design mode when creating an action. Please close the design pane and re-open it.", _class.ClassId);
}
return(true);
}
return(false);
}
protected override IAction OnCreateAction(MenuItemDataMethod data, ILimnorDesignPane designPane)
{
ActionBranchParameter ab = (ActionBranchParameter)ClassPointer;
ActionBranchParameterPointer abp = new ActionBranchParameterPointer(ab, designPane.RootClass);
abp.MethodId = MethodViewer.Method.MethodID;
abp.BranchId = ActionBranch.BranchId;
IClass op = data.Owner;
data.ResetOwner(abp);
try
{
IAction act = data.CreateMethodAction(designPane, abp, MethodViewer.Method, MethodViewer.ActionsHolder);
if (act != null)
{
act.ScopeMethod = MethodViewer.Method;
act.ActionHolder = MethodViewer.ActionsHolder;
}
data.ResetOwner(op);
return(act);
}
catch
{
throw;
}
finally
{
data.ResetOwner(op);
}
}
public DesignObjects(UInt32 classId, ClassPointer rootPointer, ILimnorDesignPane pane, ObjectIDmap map)
{
_classId = classId;
_rootPointer = rootPointer;
_pane = pane;
_map = map;
}
public static DesignObjects RemoveDesignObjects(LimnorProject project, UInt32 classId)
{
ClassPointer rootPointer = null;
if (project.HasTypedData <ClassPointer>(classId))
{
rootPointer = project.GetTypedData <ClassPointer>(classId);
}
ILimnorDesignPane pane = null;
if (project.HasTypedData <ILimnorDesignPane>(classId))
{
pane = project.GetTypedData <ILimnorDesignPane>(classId);
}
ObjectIDmap map = null;
if (project.HasTypedData <ObjectIDmap>(classId))
{
map = project.GetTypedData <ObjectIDmap>(classId);
}
DesignObjects obj = new DesignObjects(classId, rootPointer, pane, map);
project.RemoveTypedData <ILimnorDesignPane>(classId);
project.RemoveTypedData <ClassPointer>(classId);
project.RemoveTypedData <ObjectIDmap>(classId);
return(obj);
}
private void buttonCopy_Click(object sender, EventArgs e)
{
if (dataGridView1.CurrentCell != null && _dataTable != null)
{
if (dataGridView1.CurrentCell.RowIndex >= 0 && dataGridView1.CurrentCell.RowIndex < _dataTable.Rows.Count)
{
ILimnorDesignPane pane = _prj.GetTypedData <ILimnorDesignPane>(_method.ClassId);
ActionItem ai = _dataTable.Rows[dataGridView1.CurrentCell.RowIndex][0] as ActionItem;
ActionItem aiNew = ai.CreateNewCopy();
ClassPointer cp = pane.RootClass;
cp.SaveAction(aiNew.Action, pane.Loader.Writer);
for (int i = 0; i < dataGridView1.Rows.Count; i++)
{
dataGridView1.Rows[i].Selected = false;
}
_dataTable.Rows.Add(aiNew);
dataGridView1.Rows[dataGridView1.Rows.Count - 1].Selected = true;
propertyGrid1.SelectedObject = aiNew.Action;
if (aiNew.Action != null)
{
if (aiNew.Action.ParameterValues != null)
{
foreach (ParameterValue v in aiNew.Action.ParameterValues)
{
v.SetParameterValueChangeEvent(onActionChanged);
}
}
}
}
}
}
public override ActionClass CreateSetPropertyAction(ILimnorDesignPane designPane, IClass holder, IMethod scopeMethod, IActionsHolder actsHolder)
{
PropertyPointer pp = new PropertyPointer();
pp.SetPropertyInfo(_val);
pp.Owner = Owner;
return(DesignUtil.CreateSetPropertyAction(pp, designPane, scopeMethod, actsHolder, designPane.PaneHolder.FindForm()));
}
public void SetData(ILimnorDesignPane data)
{
_designPane = data;
_folder = _designPane.Loader.Project.ProjectFolder;
_namespace = _designPane.Loader.GetRootId().Namespace;
if (string.IsNullOrEmpty(_namespace))
{
_namespace = _designPane.Loader.Namespace;
}
}
public override IAction CreateMethodAction(ILimnorDesignPane designPane, IClass holder, IMethod scopeMethod, IActionsHolder actsHolder)
{
IMethodPointer mi = DesignUtil.EditFrequentlyUsedMethodList(designPane.Loader.Project, designPane.RootXmlNode, _menuData, designPane, designPane.PaneHolder.FindForm());
if (mi != null)
{
return(DesignUtil.OnCreateAction(holder, mi, scopeMethod, actsHolder, designPane.PaneHolder, designPane.RootXmlNode));
}
return(null);
}
protected override IAction OnCreateAction(MenuItemDataMethod data, ILimnorDesignPane designPane)
{
IAction act = data.CreateMethodAction(designPane, this.LocalPointer, MethodViewer.Method, MethodViewer.ActionsHolder);
if (act != null)
{
act.ScopeMethod = MethodViewer.Method;
act.ActionHolder = MethodViewer.ActionsHolder;
}
return(act);
}
public void NotifyMethodChange(InterfaceElementMethod m)
{
ClassPointer cp = GetHolder();
if (cp != null && _owner != null)
{
ILimnorDesignPane pane = cp.Project.GetTypedData <ILimnorDesignPane>(cp.ClassId);
if (pane != null)
{
_owner.NotifyMethodChange(pane.Loader, m);
}
}
}
private void miAssignEvent_Click(object sender, EventArgs e)
{
if (OnBeforeUseComponent())
{
EventPath ep = this.Parent as EventPath;
if (ep != null)
{
ILimnorDesignPane dp = ep.Panes.Loader.DesignPane;
MenuItemDataEvent data = (MenuItemDataEvent)(((MenuItem)sender).Tag);
data.ExecuteMenuCommand(ep.Project, this.ClassPointer, dp.RootXmlNode, ep.Panes, null, null);
}
}
}
public void OnFinishEdit(UInt32 actionBranchId, ILimnorDesignerLoader loader)
{
try
{
ILimnorDesignPane dp = loader.DesignPane;
if (dp == null)
{
throw new DesignerException("ILimnorDesignPane not found for class {0}", loader.GetRootId());
}
IEvent ep = _event;
EventAction ea = null; //event-actions mapping
ClassPointer a = loader.GetRootId();
if (a != null)
{
List <EventAction> lst = a.EventHandlers;
if (lst != null)
{
foreach (EventAction e in lst)
{
if (e.GetAssignActionId() == actionBranchId && e.Event.IsSameObjectRef(ep))
{
ea = e;
break;
}
}
}
}
if (ea == null)
{
ea = new EventAction();
ea.Event = ep;
if (actionBranchId != 0)
{
ea.SetAssignActionId(actionBranchId);
}
}
_handlerOwner = ea;
ea.AddAction(this);
a.SaveEventHandler(ea);
dp.OnNotifyChanges();
dp.OnAssignAction(ea);
}
catch (Exception err)
{
MathNode.Log(TraceLogClass.MainForm, err);
}
finally
{
this.ExitEditor();
}
}
private void edit()
{
if (dataGridView1.CurrentCell != null && dataGridView1.CurrentCell.RowIndex >= 0 && dataGridView1.CurrentCell.RowIndex < _dataTable.Rows.Count)
{
ILimnorDesignPane pane = _prj.GetTypedData <ILimnorDesignPane>(_method.ClassId);
ActionItem ai = _dataTable.Rows[dataGridView1.CurrentCell.RowIndex][0] as ActionItem;
List <IAction> actList = DesignUtil.SelectAction(pane.Loader, ai.Action, null, false, _method, _method.CurrentActionsHolder, this.FindForm());
if (actList != null && actList.Count > 0)
{
ai = new ActionItem(actList[0]);
_dataTable.Rows[dataGridView1.CurrentCell.RowIndex][0] = ai;
}
}
}
private void createNewAction(MenuItemDataMethod data)
{
if (OnBeforeUseComponent())
{
EventPath ep = this.Parent as EventPath;
if (ep != null)
{
ILimnorDesignPane dp = ep.Panes.Loader.DesignPane;
IAction act = data.CreateMethodAction(dp, this.ClassPointer, null, null);
if (act != null)
{
}
}
}
}
public void OnChanged()
{
if (_rootClass == null && _prj != null)
{
_rootClass = _prj.GetTypedData <ClassPointer>(_action.ClassId);
_classId = _action.ClassId;
}
_action.OnPropertyChanged("ActionMethod", null, _rootClass.XmlData, null);
ILimnorDesignPane pane = _prj.GetTypedData <ILimnorDesignPane>(_classId);
if (pane != null)
{
pane.Loader.NotifyChanges();
}
}
private void miSetProperty_Click(object sender, EventArgs e)
{
if (OnBeforeUseComponent())
{
EventPath ep = this.Parent as EventPath;
if (ep != null)
{
ILimnorDesignPane dp = ep.Panes.Loader.DesignPane;
MenuItemDataProperty data = (MenuItemDataProperty)(((MenuItem)sender).Tag);
ActionClass act = data.CreateSetPropertyAction(dp, ClassPointer, null, null);
if (act != null)
{
}
}
}
}
private void btAdd_Click(object sender, EventArgs e)
{
ILimnorDesignPane pane = _prj.GetTypedData <ILimnorDesignPane>(_method.ClassId);
if (pane != null)
{
List <IAction> actList = DesignUtil.SelectAction(pane.Loader, null, null, true, _method, _method.CurrentActionsHolder, this.FindForm());
if (actList != null && actList.Count > 0)
{
foreach (IAction act in actList)
{
_dataTable.Rows.Add(new ActionItem(act));
}
}
}
}
public ComponentListControl(IWindowsFormsEditorService edSvc, IList <ComponentID> components, UInt32 selectedId, LimnorProject prj, bool isPageAddress, string pageAddr)
{
_srv = edSvc;
ComponentID non = new ComponentID(prj, 0, "none", typeof(void), "");
Items.Add(non);
if (components != null)
{
for (int i = 0; i < components.Count; i++)
{
if (typeof(WebPage).IsAssignableFrom(components[i].ComponentType))
{
ILimnorDesignPane pn = prj.GetTypedData <ILimnorDesignPane>(components[i].ComponentId);
if (pn != null)
{
IComponent ic = pn.RootClass.ObjectInstance as IComponent;
if (ic != null && ic.Site != null && ic.Site.DesignMode)
{
if (!string.IsNullOrEmpty(ic.Site.Name))
{
components[i].Rename(ic.Site.Name);
}
}
}
if (isPageAddress)
{
string pr = string.Format(CultureInfo.InvariantCulture, "{0}.html", components[i].ComponentName);
int n = Items.Add(pr);
if (string.Compare(pr, pageAddr, StringComparison.OrdinalIgnoreCase) == 0)
{
SelectedIndex = n;
}
}
else
{
int n = Items.Add(components[i]);
if (components[i].ComponentId == selectedId)
{
SelectedIndex = n;
}
}
}
}
}
}
private void createNewAction(MenuItemDataMethod data)
{
ILimnorDesignPane dp = Designer.Project.GetTypedData <ILimnorDesignPane>(Designer.ObjectMap.ClassId);
IAction act = OnCreateAction(data, dp);
if (act != null)
{
if (!(this.ClassPointer is LocalVariable))
{
if (MethodEditContext.IsWebPage)
{
if (!MethodEditContext.CheckAction(act, this.FindForm()))
{
return;
}
}
}
MethodDiagramViewer mv = MethodViewer.GetCurrentViewer();
act.ScopeMethod = _methodClass;
act.ActionHolder = MethodViewer.ActionsHolder;
double x0, y0;
ComponentIconEvent.CreateRandomPoint((double)((mv.Width - 20) / 2), out x0, out y0);
if (x0 < 0)
{
x0 = 10;
}
if (y0 < 0)
{
y0 = 10;
}
ActionViewer av = MethodViewer.AddNewAction(act, new Point((mv.Width - 20) / 2 + (int)x0, (mv.Height - 20) / 2 + (int)y0));
if (av.Parent == null)
{
#if DEBUG
MessageBox.Show("Adding action viewer failed (1)");
#endif
mv.Controls.Add(av);
}
else
{
}
}
}
public bool Edit(XmlObjectWriter writer, IMethod context, Form caller, bool isNewAction)
{
IMathExpression mathExp = MathExp;
if (mathExp != null)
{
ActionExecMath a2 = (ActionExecMath)this.Clone();
Rectangle rc = new Rectangle(0, 0, 100, 30);
System.Drawing.Point curPoint = System.Windows.Forms.Cursor.Position;
rc.X = curPoint.X;
rc.Y = curPoint.Y;
a2.MathExp.ScopeMethod = context;
IMathEditor dlg = a2.MathExp.CreateEditor(rc);
if (((Form)dlg).ShowDialog(caller) == DialogResult.OK)
{
MathExpMethod mem = new MathExpMethod();
mem.Action = this;
mem.MathExpression = dlg.MathExpression;
ActionMethod = mem;
if (_class != null)
{
LimnorProject project = _class.Project;
ILimnorDesignPane pane = project.GetTypedData <ILimnorDesignPane>(_class.ClassId);
if (pane != null)
{
pane.OnActionChanged(_class.ClassId, this, isNewAction);
pane.OnNotifyChanges();
}
else
{
DesignUtil.WriteToOutputWindowAndLog("Error Editng ActionExecMath. ClassPointer [{0}] is not in design mode when creating an action. Please close the design pane and re-open it.", _class.ClassId);
}
}
return(true);
}
}
return(false);
}
public override IAction CreateMethodAction(ILimnorDesignPane designPane, IClass holder, IMethod scopeMethod, IActionsHolder actsHolder)
{
ActionClass act = new ActionClass(designPane.RootClass); //holder.Host);
act.ActionMethod = _method.CreatePointer(holder);
act.ActionName = act.ActionMethod.DefaultActionName;
act.ActionHolder = actsHolder;
ClassPointer owner = holder.Host as ClassPointer;
if (owner == null)
{
owner = Owner.Host as ClassPointer;
if (owner == null)
{
owner = _pointer;
}
}
if (owner.CreateNewAction(act, designPane.Loader.Writer, scopeMethod, designPane.PaneHolder.FindForm()))
{
return(act);
}
return(null);
}
private void mi_delete(object sender, EventArgs e)
{
XmlNodeList nl = _root.XmlData.SelectNodes(string.Format(CultureInfo.InvariantCulture,
"//{0}/{1}//*[@{2}='{3}']", XmlTags.XML_ACTIONS, XmlTags.XML_ACTION, XmlTags.XMLATT_ClassID, this.ClassPointer.ClassId));
if (nl != null && nl.Count > 0)
{
MessageBox.Show(this.FindForm(), "Cannot delete this component. It is being used in actions", "Delete component", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
else
{
this.RemoveIcon();
if (DataXmlNode != null)
{
XmlNode np = DataXmlNode.ParentNode;
np.RemoveChild(DataXmlNode);
}
ILimnorDesignPane dp = _prj.GetTypedData <ILimnorDesignPane>(_root.ClassId);
if (dp != null)
{
dp.Loader.NotifyChanges();
}
}
}
private void edit(int idx)
{
if (dataGridView1.CurrentCell != null && dataGridView1.CurrentCell.RowIndex >= 0 && dataGridView1.CurrentCell.RowIndex < _dataTable.Rows.Count)
{
if (idx == 0)
{
Rectangle rc = dataGridView1.GetCellDisplayRectangle(dataGridView1.CurrentCell.ColumnIndex, dataGridView1.CurrentCell.RowIndex, true);
MathNodeRoot r = _dataTable.Rows[dataGridView1.CurrentCell.RowIndex][0] as MathNodeRoot;
r.ScopeMethod = _method;
r.Project = _prj;
dlgMathEditor dlg = new dlgMathEditor(this.Parent.RectangleToScreen(rc));
dlg.MathExpression = r;
dlg.SetScopeMethod(_method);
if (dlg.ShowDialog(this.FindForm()) == DialogResult.OK)
{
r = (MathNodeRoot)dlg.MathExpression;
_dataTable.Rows[dataGridView1.CurrentCell.RowIndex][0] = r;
}
}
else
{
ActionList aList = _dataTable.Rows[dataGridView1.CurrentCell.RowIndex][1] as ActionList;
ILimnorDesignPane pane = _prj.GetTypedData <ILimnorDesignPane>(_method.ClassId);
if (aList == null || aList.Count == 0)
{
List <IAction> actList = DesignUtil.SelectAction(pane.Loader, null, null, true, _method, _method.CurrentActionsHolder, this.FindForm());
if (actList != null && actList.Count > 0)
{
aList = new ActionList();
aList.Name = "Actions"; // actList[0].ToString();
foreach (IAction act in actList)
{
aList.Add(new ActionItem(act));
}
_dataTable.Rows[dataGridView1.CurrentCell.RowIndex][1] = aList;
}
else
{
return;
}
}
IMethodDialog imd = this.FindForm() as IMethodDialog;
MethodDesignerHolder v = null;
if (imd != null)
{
v = imd.GetEditor();
}
DlgActionList dlg = new DlgActionList();
dlg.LoadData(aList, _method, _prj, v);
if (dlg.ShowDialog(this.FindForm()) == DialogResult.OK)
{
aList = dlg.Result;
_dataTable.Rows[dataGridView1.CurrentCell.RowIndex][1] = aList;
if (v != null)
{
MethodDiagramViewer mv = v.GetCurrentViewer();
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();
}
}
}
}
}
}
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)
{
MethodClass scopeMethod = context.Instance as MethodClass;
if (scopeMethod != null)
{
//this version only edit FinalActions
ILimnorDesignPane dp = scopeMethod.Project.GetTypedData <ILimnorDesignPane>(scopeMethod.RootPointer.ClassId);
if (dp != null)
{
//save the method contents
BranchList bl = scopeMethod.ActionList;
string methodName = scopeMethod.MethodName;
ParameterClass returnType = scopeMethod.ReturnValue;
List <ComponentIcon> icons = scopeMethod.ComponentIconList;
//switch method contents
scopeMethod.ActionList = scopeMethod.FinalActions.Actions;
scopeMethod.SetName("FinalActions");
List <ComponentIcon> icons2 = new List <ComponentIcon>();
foreach (ComponentIcon ic in icons)
{
icons2.Add((ComponentIcon)ic.Clone());
}
foreach (ComponentIconSubscopeVariable ic in scopeMethod.FinalActions.ComponentIconList)
{
icons2.Add((ComponentIcon)ic.Clone());
}
scopeMethod.SetComponentIcons(icons2);
//
Rectangle rc = new Rectangle(Cursor.Position, new Size(32, 232));
if (scopeMethod.Owner == null)
{
scopeMethod.Owner = dp.Loader.GetRootId();
}
DlgMethod dlg = scopeMethod.CreateBlockScopeMethodEditor(rc, 1);
try
{
dlg.LoadMethod(scopeMethod, EnumParameterEditType.ReadOnly);
dlg.Text = string.Format(CultureInfo.InvariantCulture, "Specify final actionsfor {0}", methodName);
if (edSvc.ShowDialog(dlg) == DialogResult.OK)
{
scopeMethod.FinalActions.Actions = scopeMethod.ActionList;
List <ComponentIconSubscopeVariable> lst = new List <ComponentIconSubscopeVariable>();
foreach (ComponentIcon ic in scopeMethod.ComponentIconList)
{
ComponentIconSubscopeVariable sv = ic as ComponentIconSubscopeVariable;
if (sv != null)
{
lst.Add(sv);
}
}
scopeMethod.FinalActions.ComponentIconList = lst;
XmlObjectWriter xw = dp.Loader.Writer;
xw.WriteObject(scopeMethod.FinalActions.DataXmlNode, scopeMethod.FinalActions, null);
value = scopeMethod.FinalActions;
}
}
catch (Exception err)
{
MathNode.LogError(DesignerException.FormExceptionText(err));
}
finally
{
//restore method contents
scopeMethod.SetName(methodName);
scopeMethod.ActionList = bl;
scopeMethod.SetComponentIcons(icons);
scopeMethod.ExitEditor();
}
}
}
}
}
return(value);
}
public override IAction CreateMethodAction(ILimnorDesignPane designPane, IClass holder, IMethod scopeMethod, IActionsHolder actsHolder)
{
MethodInfoPointer mp = createPointer(designPane.PaneHolder, designPane.RootXmlNode);
return(DesignUtil.OnCreateAction(holder, mp, scopeMethod, actsHolder, designPane.PaneHolder, designPane.RootXmlNode));
}
public override ActionClass CreateSetPropertyAction(ILimnorDesignPane designPane, IClass holder, IMethod scopeMethod, IActionsHolder actsHolder)
{
return(MenuItemDataPropertySelector.createAction(holder, _property, designPane.Loader.Writer, designPane.Loader.Node, scopeMethod, actsHolder, designPane.PaneHolder.FindForm()));
}
public override bool Edit(UInt32 actionBranchId, Rectangle rcStart, ILimnorDesignerLoader loader, Form caller)
{
if (this.Owner == null)
{
this.Owner = loader.GetRootId();
}
DlgMethod dlg = this.CreateMethodEditor(rcStart);
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;
}
dlg.LoadMethod(this, EnumParameterEditType.Edit);
if (dlg.ShowDialog(caller) == DialogResult.OK)
{
_display = null;
XmlNode nodeMethodCollection = loader.Node.SelectSingleNode(XmlTags.XML_CONSTRUCTORS);
if (nodeMethodCollection == null)
{
nodeMethodCollection = loader.Node.OwnerDocument.CreateElement(XmlTags.XML_CONSTRUCTORS);
loader.Node.AppendChild(nodeMethodCollection);
}
XmlNode nodeMethod = nodeMethodCollection.SelectSingleNode(
string.Format(System.Globalization.CultureInfo.InvariantCulture,
"{0}[@{1}='{2}']",
XmlTags.XML_Item, XmlTags.XMLATT_MethodID, MemberId));
if (nodeMethod == null)
{
nodeMethod = nodeMethodCollection.OwnerDocument.CreateElement(XmlTags.XML_Item);
nodeMethodCollection.AppendChild(nodeMethod);
}
XmlUtil.SetAttribute(nodeMethod, XmlTags.XMLATT_MethodID, MemberId);
XmlUtil.SetAttribute(nodeMethod, XmlTags.XMLATT_NAME, Name);
XmlObjectWriter wr = loader.Writer;
wr.WriteObjectToNode(nodeMethod, this);
if (wr.HasErrors)
{
MathNode.Log(wr.ErrorCollection);
}
ILimnorDesignPane pane = loader.Project.GetTypedData <ILimnorDesignPane>(loader.ObjectMap.ClassId);
pane.OnNotifyChanges();
return(true);
}
}
catch (Exception err)
{
MathNode.Log(caller, err);
}
finally
{
ExitEditor();
VPLUtil.CurrentRunContext = _origiContext;
}
return(false);
}
public void SetData(string folder, string defaultNamespace)
{
_folder = folder;
_namespace = defaultNamespace;
_designPane = null;
}
public override IAction CreateMethodAction(ILimnorDesignPane designPane, IClass holder, IMethod scopeMethod, IActionsHolder actsHolder)
{
throw new NotImplementedException("MethodItemWrapper.CreateMethodAction");
}
