/// <summary> /// get/create a single thread group of actions containing the given branch id. /// it is used for loading debugger viewer /// </summary> /// <param name="branchId">the given branch id to be included in the result group</param> /// <returns>the action group containing the given branch id</returns> public IActionGroup GetThreadGroup(UInt32 branchId) { List <ActionBranch> independentThreads = FindoutActionThreads(false); foreach (ActionBranch a in independentThreads) { if (a.ContainsAction(branchId)) { IActionGroup g = a as IActionGroup; if (g != null) { g = (IActionGroup)g.Clone(); g.ResetGroupId(_method.MethodID); //all threads has the same group id. they can be distinguished at runtime by thread id return(g); } AB_ActionString s = a as AB_ActionString; if (s != null) { IActionGroup sg = s.GetThreadGroup(branchId); sg.ResetGroupId(_method.MethodID); //all threads has the same group id. they can be distinguished at runtime by thread id return(sg); } List <UInt32> used = new List <uint>(); AB_ActionGroup ag = new AB_ActionGroup(_actsHolder); ag.SetOwnerMethod(used, _method); ag.BranchId = _method.MethodID; //all threads has the same group id. they can be distinguished at runtime by thread id ag.AppendAction(a); return(ag); } } return(null); }
/// <summary> /// before executing an action in a method. /// it can be called from different threads /// </summary> /// <param name="objectKey">ObjectKey of the owner of the method</param> /// <param name="methodWholeId">method id</param> /// <param name="branchId">action branch id of the action to be executed</param> /// <param name="executer">object instance executing the method</param> public void BeforeExecuteAction(string objectKey, UInt64 methodWholeId, UInt32 branchId, object executer) { if (_ComponentDebugger.Stopping) { return; } int threadId = System.Threading.Thread.CurrentThread.ManagedThreadId; _ComponentDebugger.IncrementStackLevel(threadId); //check if it is at a break point MethodClass mc = _ComponentDebugger.GetMethod(methodWholeId); if (mc != null) { //MethodClass mc = mc0.Clone() as MethodClass; IActionGroup g = mc; ActionBranch branch = mc.GetBranchByIdInGroup(branchId, ref g); if (branch != null) { if (_ComponentDebugger.ShouldBreak(threadId) || branch.BreakBeforeExecute) { _ComponentDebugger.SetSelectedObject(executer); _ComponentDebugger.SetAtBreak(threadId, true); _debugUI.ShowBreakPoint(_ComponentDebugger); branch.AtBreak = EnumActionBreakStatus.Before; _ComponentDebugger.ShowBreakPointInMethod(threadId, mc, g, branch); waitForBreakPoint(threadId); } } } }
public override void LoadActions(IActionGroup actions) { _actions = actions as AB_Squential; ContentReadOnly = true; LoadMethod(actions.ActionList.Method, EnumParameterEditType.TypeReadOnly); // SetDebugBehavior(); }
private void clearBreakPointInMethod(int threadId, MethodClass method, IActionGroup group, ActionBranch branch) { MethodDesignerHolder h = getViewer(threadId, method, group, branch); if (h != null) { h.ClearBreakpoint(); } }
public ActionSetSummary(IActionGroup grp, string routingDesc) { m_actionset = grp; m_routingDesc = routingDesc; foreach (IAction action in grp.Actions) { m_actionSummaryList.Add(new ActionSummary(action)); } }
private void WriteActionGroup(IActionGroup actionGroup) { foreach (IActionGroup subActionGroup in actionGroup.ActionGroups) { WriteActionGroup(subActionGroup); } foreach (IAction action in actionGroup.Actions) { WriteAction(action); } }
/// <summary> /// find the smallest group containing the branch /// </summary> /// <param name="id"></param> /// <param name="group"></param> /// <returns></returns> public ActionBranch GetBranchInGroup(UInt32 id, ref IActionGroup group) { foreach (ActionBranch ab in this) { ActionBranch a = ab.GetBranchInGroup(id, ref group); if (a != null) { return(a); } } return(null); }
/// <summary> /// find the smallest group containing the branch /// </summary> /// <param name="id"></param> /// <param name="group"></param> /// <returns></returns> public override ActionBranch GetBranchInGroup(UInt32 id, ref IActionGroup group) { ActionBranch a = base.GetBranchInGroup(id, ref group); if (a != null) { return(a); } if (_list != null) { return(_list.GetBranchInGroup(id, ref group)); } return(null); }
private void showBreakPointInMethod(int threadId, MethodClass method, IActionGroup group, ActionBranch branch) { MethodDesignerHolder h = getViewer(threadId, method, group, branch); if (h == null) { IActionGroup g = (IActionGroup)(group.Clone()); g = g.GetThreadGroup(branch.BranchId); //create a viewer SplitContainer c = getLastContainer(splitContainer1); SplitContainer newContainer = new SplitContainer(); newContainer.Dock = DockStyle.Fill; c.Panel2.Controls.Add(newContainer); c.Panel2Collapsed = false; newContainer.Panel2Collapsed = true; h = Activator.CreateInstance(g.ViewerHolderType, this, _designer) as MethodDesignerHolder; h.ThreadId = threadId; h.SetBackgroundText(group.GroupName); h.Dock = DockStyle.Fill; newContainer.Panel1.Controls.Add(h); h.LoadActions(g); _currentThreadId = threadId; h.DesignerSelected += new EventHandler(h_DesignerSelected); newContainer.Panel1.GotFocus += new EventHandler(Panel1_GotFocus); newContainer.SplitterMoved += new SplitterEventHandler(newContainer_SplitterMoved); newContainer.Resize += new EventHandler(newContainer_Resize); } else { if (h.ActionGroup.GroupFinished) { h.ActionGroup.GroupFinished = false; ThreadDebug td = ThreadData(threadId); if (td.Status == EnumRunStatus.Finished) { FormDebugger f = this.FindForm() as FormDebugger; if (f != null) { td.Status = f.DebugCommandStatus; } else { td.Status = EnumRunStatus.Run; } } UpdateViewersBackColor(); } } h.UpdateBreakpoint(branch); }
/// <summary> /// find the smallest group containing the branch /// </summary> /// <param name="id"></param> /// <param name="group"></param> /// <returns></returns> public override ActionBranch GetBranchInGroup(UInt32 id, ref IActionGroup group) { if (this.BranchId == id) { return(this); } IActionGroup g = this; ActionBranch a = base.GetBranchInGroup(id, ref g); if (a != null) { group = g; return(a); } return(null); }
public void Initialise(IPolicy policy, IPolicyChannel channel, IActionGroup group) { //if the action group has changed, don't bother trying to select the //same action that was selected prior to this call if (group != m_actionGroup) { m_selectedActionIndex = -1; } m_policy = policy; m_channel = channel; m_actionGroup = group; FillCatalogActions(); FillAssignedActions(); this.actiongroupNameTextBox.Focus(); }
/// <summary> /// find the smallest group containing the branch /// </summary> /// <param name="id"></param> /// <param name="group"></param> /// <returns></returns> public override ActionBranch GetBranchInGroup(UInt32 id, ref IActionGroup group) { ActionBranch a = base.GetBranchInGroup(id, ref group); if (a == null) { if (_ifActions != null) { a = _ifActions.GetBranchInGroup(id, ref group); } } if (a == null) { if (_elseActions != null) { a = _elseActions.GetBranchInGroup(id, ref group); } } return(a); }
public ActionBranch GetJumpToActionBranch(UInt32 branchId) { foreach (ActionBranch a in this) { if (a.BranchId == branchId) { return(a); } AB_ActionString abs = a as AB_ActionString; if (abs != null) { if (abs.ActionCount > 0) { if (abs.ActionList[0].BranchId == branchId) { return(a); } } } else { IActionGroup ia = a as IActionGroup; if (ia != null) { if (ia.ActionList != null) { ActionBranch ab = ia.ActionList.GetJumpToActionBranch(branchId); if (ab != null) { return(ab); } } } } } return(null); }
private bool GetActions() { bool ret = false; if (m_channel.Actions != null) { IActionMatrixCell cell = m_channel.Actions[m_activeSenderAddressCollection, m_activeRecipientAddressCollection]; if (cell != null) { m_actiongroup = cell.ActionConditionGroups[0].ActionGroup; ret = true; } } return ret; }
/// <summary> /// Removes an ActionGroup from a policy set's master catalogue /// </summary> /// <param name="policySet">The policy set from whose catalogue we will remove the ActionGroup</param> /// <param name="actionGroup">The ActionGroup to remove</param> private static void RemoveActionGroup(IPolicySet policySet, IActionGroup actionGroup) { if (null == policySet || null == actionGroup) { return; } foreach (IActionGroup childActionGroup in actionGroup.ActionGroups) { RemoveActionGroup(policySet, childActionGroup); } foreach (IAction childAction in actionGroup.Actions) { RemoveAction(policySet, childAction); } policySet.MasterCatalogue.ActionGroups.Remove(actionGroup); }
private void WriteActionGroup(XmlNode xmlParentNode, IActionGroup actionGroup) { XmlNode xmlActionGroupNode = m_xmlDocument.CreateElement("ActionGroup"); xmlParentNode.AppendChild(xmlActionGroupNode); XmlHelpers.AddIdAttribute(xmlActionGroupNode, actionGroup); XmlHelpers.AddAttribute(xmlActionGroupNode, "precedence", actionGroup.Precedence.ToString(CultureInfo.InvariantCulture)); XmlHelpers.AddReadOnlyAttribute(xmlActionGroupNode, actionGroup.ReadOnly); WriteActionGroups(xmlActionGroupNode, actionGroup.ActionGroups); WriteActions(xmlActionGroupNode, actionGroup.Actions); }
public void SetActions(IActionGroup actiongroup) { Display(); }
public void WriteActionGroup(IActionGroup actionGroup) { if (null == actionGroup) return; CollectionInserter<IActionGroup>.Insert(m_actionGroups, actionGroup); }
private MethodDesignerHolder getViewer(int threadId, SplitContainer c, MethodClass method, IActionGroup group, ActionBranch branch) { for (int i = 0; i < c.Panel1.Controls.Count; i++) { MethodDesignerHolder h = c.Panel1.Controls[i] as MethodDesignerHolder; if (h != null) { if (h.ThreadId == threadId) { if (h.Method.WholeActionId == method.WholeActionId) { if (group.GroupId == h.ActionGroup.GroupId) { if (h.ActionList.ContainsAction(branch.BranchId)) { return(h); } } } } } } for (int i = 0; i < c.Panel2.Controls.Count; i++) { SplitContainer s = c.Panel2.Controls[i] as SplitContainer; if (s != null) { MethodDesignerHolder h = getViewer(threadId, s, method, group, branch); if (h != null) { return(h); } } } return(null); }
private MethodDesignerHolder getViewer(int threadId, MethodClass method, IActionGroup group, ActionBranch branch) { return(getViewer(threadId, splitContainer1, method, group, branch)); }
void m_actiongroupControl_OnGroupnameChanged(object sender, string text, IActionGroup group) { if (text != group.Name.Value) { group.Name.Value = text; UpdateChannelStateUI(); StateMachine.ChildForm.IsModified = true; } }
/// <summary> /// finish execute an action /// </summary> /// <param name="objectKey"></param> /// <param name="methodWholeId"></param> /// <param name="branchId"></param> /// <param name="executer"></param> public void AfterExecuteAction(string objectKey, UInt64 methodWholeId, UInt32 branchId, object executer) { if (_ComponentDebugger.Stopping) { return; } int threadId = System.Threading.Thread.CurrentThread.ManagedThreadId; _ComponentDebugger.DecrementStackLevel(threadId); //check if it is at a break point MethodClass mc = _ComponentDebugger.GetMethod(methodWholeId); if (mc != null) { IActionGroup g = mc; ActionBranch branch = mc.GetBranchByIdInGroup(branchId, ref g); if (branch != null) { IActionGroup g0 = branch as IActionGroup; if (g0 != null) { //finished calling a group of actions MethodDesignerHolder h = _ComponentDebugger.GetViewer(threadId, g0.GroupId); if (h != null) { h.ActionGroup.GroupFinished = true; _ComponentDebugger.UpdateViewersBackColor(); } } else { ISingleAction sa = branch as ISingleAction; if (sa != null) { CustomMethodPointer ac = sa.ActionData.ActionMethod as CustomMethodPointer; if (ac != null) { //finished calling a custom action MethodDesignerHolder h = _ComponentDebugger.GetViewer(threadId, ac.MethodDef.MethodID); if (h != null) { h.ActionGroup.GroupFinished = true; _ComponentDebugger.UpdateViewersBackColor(); } } } } EnumRunStatus status = _ComponentDebugger.GetRunStatus(threadId); bool b = (status == EnumRunStatus.Pause || status == EnumRunStatus.StepInto); if (!b) { if (status == EnumRunStatus.StepOver && _ComponentDebugger.ReachStepOver(threadId)) { b = true; } if (!b) { if (status == EnumRunStatus.StepOut && _ComponentDebugger.ReachStepOut(threadId)) { b = true; } } } if (b || branch.BreakAfterExecute) { _ComponentDebugger.SetSelectedObject(executer); _ComponentDebugger.SetAtBreak(threadId, true); _debugUI.ShowBreakPoint(_ComponentDebugger); branch.AtBreak = EnumActionBreakStatus.After; _ComponentDebugger.ShowBreakPointInMethod(threadId, mc, g, branch); waitForBreakPoint(threadId); branch.AtBreak = EnumActionBreakStatus.None; _ComponentDebugger.ShowBreakPointInMethod(threadId, mc, g, branch); } else { branch.AtBreak = EnumActionBreakStatus.None; _ComponentDebugger.ClearBreakPointInMethod(threadId, mc, g, branch); } } } }
public void ClearBreakPointInMethod(int threadId, MethodClass method, IActionGroup group, ActionBranch branch) { this.Invoke(miClearBreakPointInMethod, threadId, method, group, branch); }
private static bool ValidateActionGroup(string policyName, IActionGroup actionGroup, PolicySetValidator.AddViolationMessageHandler AddMessage) { if (0 < actionGroup.Actions.Count) { ValidateActions(policyName, actionGroup.Actions, AddMessage); return true; } foreach (IActionGroup subActionGroup in actionGroup.ActionGroups) { if (ValidateActionGroup(policyName, subActionGroup, AddMessage)) return true; } return false; }