protected BranchGroupNode findInTree(GroupNode g, ApplianceObject ao) { // if a unit has been found the represents this portion of the // group tree, then don't search for mutual exclusion within it // (any such relationships will presumably be handled by the // the custom CIO) if (g.Decorations[UnitDecision.DECISION_KEY] != null) { return(null); } if (g.IsObject()) { if (((ObjectGroupNode)g).Object == ao) { return(g.Parent); } } else { IEnumerator e = ((BranchGroupNode)g).Children.GetEnumerator(); while (e.MoveNext()) { BranchGroupNode br = findInTree((GroupNode)e.Current, ao); if (br != null) { return(br); } } } return(null); }
/* * Member Methods */ protected void extractStates(BranchGroupNode bg, bool levelOne) { IEnumerator e = bg.Children.GetEnumerator(); while (e.MoveNext()) { GroupNode ig = (GroupNode)e.Current; if (levelOne && (ig.Name == ListGroupNode.LIST_SELECTION_STATE || ig.Name == ListGroupNode.LIST_LENGTH_STATE)) { continue; } if (ig.IsObject() && ((ObjectGroupNode)ig).Object.State) { _states.Add(((ObjectGroupNode)ig).Object); } if (!ig.IsObject()) { extractStates((BranchGroupNode)e.Current, false); } } }
protected bool readonlyHelper(BranchGroupNode bg) { IEnumerator e = bg.Children.GetEnumerator(); while (e.MoveNext()) { if (e.Current is ObjectGroupNode) { if (((ObjectGroupNode)e.Current).Object.State && !((ApplianceState)((ObjectGroupNode)e.Current).Object).ReadOnly) { return(false); } } else { if (!readonlyHelper((BranchGroupNode)e.Current)) { return(false); } } } return(true); }
protected void generateOrganization(GroupNode root, ArrayList dependedObjects) { IEnumerator e = dependedObjects.GetEnumerator(); while (e.MoveNext()) { ApplianceState state = (ApplianceState)e.Current; BranchGroupNode g = findInTree(root, state); if (g != null) { generateOrganizationAtGroupNode(g, state); } } }
public SmartCIO(Control control, GroupNode specSnippet) : base(control) { _specSnippet = specSnippet; // attempt to find labels if (!specSnippet.IsObject()) { _labels = specSnippet.Labels; } else if (specSnippet.IsObject()) { _labels = ((ObjectGroupNode)specSnippet).Object.Labels; } // create the Template group _templateGroup = new BranchGroupNode(); // extract the objects that make up this type block _objects = new Hashtable(); if (_specSnippet.IsObject()) { _objects[SINGLE_STATE] = ((ObjectGroupNode)specSnippet).Object; // determine the location of this group in its parent int parentIdx = _specSnippet.Parent.Children.IndexOf(_specSnippet); if (parentIdx < 0) // this should never happen { parentIdx = 0; } // make the template group _specSnippet.Parent.Children.Insert(parentIdx + 1, _templateGroup); _templateGroup.Parent = _specSnippet.Parent; } else { extractObjects(specSnippet); // make the template group ((BranchGroupNode)specSnippet).Children.Add(_templateGroup); _templateGroup.Parent = (BranchGroupNode)_specSnippet; } }
/* * Process Method */ public override PanelNode Process(GroupNode g, PanelNode p) { if (g is BranchGroupNode) { BranchGroupNode bg = (BranchGroupNode)g; if (bg.Children.Count == 2 && !g.ContainsGroups()) { IEnumerator child = bg.Children.GetEnumerator(); while (child.MoveNext()) { if (((ObjectGroupNode)child.Current).Decorations[UnitDecision.DECISION_KEY] == null || ((UnitDecision)((ObjectGroupNode)child.Current).Decorations[UnitDecision.DECISION_KEY]).Handled || ((UnitDecision)((ObjectGroupNode)child.Current).Decorations[UnitDecision.DECISION_KEY]).CIO.HasLabel()) { return(p); } } LabelCIO labelCIO = null; if (g.Labels != null) { labelCIO = new LabelCIO(g.Labels); } UnitDecision d = (UnitDecision)((ObjectGroupNode)bg.Children[0]).Decorations[UnitDecision.DECISION_KEY]; ConcreteInteractionObject cio1 = d.CIO; d.Handled = true; d = (UnitDecision)((ObjectGroupNode)bg.Children[1]).Decorations[UnitDecision.DECISION_KEY]; ConcreteInteractionObject cio2 = d.CIO; d.Handled = true; LabeledTwoCompRow r = new LabeledTwoCompRow(g, p, labelCIO, cio1, cio2); p.AddRow(r); } } return(p); }
protected void searchHelper(GroupNode g, Appliance a) { if (g.Decorations[UnitDecision.DECISION_KEY] != null) { return; } if (g.HasType()) { SmartCIO cio = a.GetUIGenerator().Core.SmartCIOMgr.GetSmartCIO(g.HighlevelType, g); if (cio != null) { cio.TemplateGroup.Decorations[UnitDecision.DECISION_KEY] = new UnitDecision(cio); } } if (g.IsObject() && ((ObjectGroupNode)g).Object.HighlevelType != null) { SmartCIO cio = a.GetUIGenerator().Core.SmartCIOMgr.GetSmartCIO(((ObjectGroupNode)g).Object.HighlevelType, g); if (cio != null) { cio.TemplateGroup.Decorations[UnitDecision.DECISION_KEY] = new UnitDecision(cio); } } else if (!g.IsObject()) { BranchGroupNode bg = (BranchGroupNode)g; if (bg.Count == 0) { return; } for (int i = 0; i < bg.Children.Count; i++) { searchHelper((GroupNode)bg.Children[i], a); } } }
protected void processHelper(GroupNode g, UIGenerator ui, ListNode node) { if (g == null) { return; } node = invokeRules(g, ui, node); if (g is ObjectGroupNode) { return; } BranchGroupNode bg = (BranchGroupNode)g; for (int i = 0; i < bg.Count; i++) { processHelper((GroupNode)bg.Children[i], ui, node); } }
protected Hashtable collectDependencies(GroupNode g, ApplianceState state) { Hashtable result = new Hashtable(); BranchGroupNode bg = (BranchGroupNode)g; IEnumerator e = bg.Children.GetEnumerator(); while (e.MoveNext()) { GroupNode ng = (GroupNode)e.Current; ArrayList deps = collectDependency(ng, state); filterDependencies(deps); result[ng] = deps; } return(result); }
protected void processHelper(GroupNode g, UIGenerator ui) { if (g == null) { return; } invokeRules(g, ui); if (g.IsObject()) { return; } BranchGroupNode bg = (BranchGroupNode)g; for (int i = 0; i < bg.Children.Count; i++) { processHelper((GroupNode)bg.Children[i], ui); } }
protected void phaseHelper(GroupNode g, PanelNode p) { PanelNode panel = p; if (g == null) { return; } panel = invokeRules(g, panel); if (g.IsObject()) { return; } BranchGroupNode bg = (BranchGroupNode)g; for (int i = 0; i < bg.Children.Count; i++) { phaseHelper((GroupNode)bg.Children[i], panel); } }
public TabbedOverlappingPanelsNode(BranchGroupNode g) { _tabbedPanel = new TabbedPanelsCIO(); _tabNodes = new ArrayList(); _groupToTabMap = new Hashtable(); IEnumerator e = g.Children.GetEnumerator(); while (e.MoveNext()) { TabbedPanelCIO p = new TabbedPanelCIO(((GroupNode)e.Current).Labels); ((TabbedPanelsCIO)_tabbedPanel).AddTab(p); TabPanelNode tp = new TabPanelNode(p, (GroupNode)e.Current); _groupToTabMap[e.Current] = tp; _tabNodes.Add(tp); AddPanel(tp); ((GroupNode)e.Current).Decorations[PanelDecision.DECISION_KEY] = new PanelDecision((PanelNode)tp.GetChildNode()); } }
protected void generateOrganizationAtGroupNode(BranchGroupNode g, ApplianceState state) { /* * Step #1: Extract and combine dependencies from each group * at this level of the tree, ignoring repeated states. * * Need to create a data structure here. It will be a Hashtable * of ArrayLists, hashed on the GroupNode ref. */ Hashtable groupDeps = collectDependencies(g, state); /* * Step #2: For every group & object that depends on the * state, check for mutual exclusion. */ ArrayList mutexSets = findMutualExclusion(g, state, groupDeps); ArrayList childSets = (ArrayList)mutexSets[0]; ArrayList depSets = (ArrayList)mutexSets[1]; /* * Step #3: Save the relevent information into a Decision and * store it in the root node of the tree. */ Decision d = new MutualExclusionDecision(state, childSets, depSets); // TODO: Allow multiple Multiple MutualExclusionDecisions to be // associated with a particular group if (g.Decorations[MutualExclusionDecision.DECISION_KEY] == null) { g.Decorations.Add(MutualExclusionDecision.DECISION_KEY, d); } }
protected int searchHelper(GroupNode g, bool listBelow, Appliance a) { if (g.IsObject()) { return(0); } BranchGroupNode bg = (BranchGroupNode)g; if (bg.Count == 0) { return(0); } ListDecision d = null; if (bg.IsList()) { d = new ListDecision(!listBelow); bg.Decorations[ListDecision.DECISION_KEY] = d; } int dim = 0; for (int i = 0; i < bg.Children.Count; i++) { dim = Math.Max(dim, searchHelper((GroupNode)bg.Children[i], d != null, a)); } if (d != null) { return(d.Dimensions = dim + 1); } return(dim); }
/* * Process Method */ public override void Process(GroupNode g, UIGenerator ui) { // look for MutualExclusionDecisions object o = g.Decorations[MutualExclusionDecision.DECISION_KEY]; if (o != null && o is MutualExclusionDecision) { MutualExclusionDecision d = (MutualExclusionDecision)o; if (!d.Handled && d.State.Type.ValueSpace is BooleanSpace && ((ArrayList)d.ChildSets[0]).Count == 0) { // we need a pointer to the GroupNode that contains the state // variable that we are looking at (because tree manipulations // will need to use it) BranchGroupNode bg = (BranchGroupNode)g; ObjectGroupNode stateGroup = null; IEnumerator e = bg.Children.GetEnumerator(); while (e.MoveNext()) { if (((GroupNode)e.Current).IsObject() && ((ObjectGroupNode)e.Current).Object == d.State) { stateGroup = (ObjectGroupNode)e.Current; break; } } // now we modify the tree to incluce a power panel BranchGroupNode newG = new BranchGroupNode(); newG.Parent = bg; newG.Children = bg.Children; bg.Children = new ArrayList(); // make two groups under the common group bg.Children.Add(stateGroup); bg.Children.Add(newG); d.State.InternalController = true; e = newG.Children.GetEnumerator(); while (e.MoveNext()) { ((GroupNode)e.Current).Parent = newG; } ArrayList n = (ArrayList)d.DependencySets[0]; ArrayList i = (ArrayList)d.DependencySets[1]; EqualsDependency equalDep = (EqualsDependency)i[0]; if ((bool)equalDep.Value) { n.Add(new EqualsDependency(equalDep.State, "false")); } else { n.Add(new EqualsDependency(equalDep.State, "true")); } OrganizationDecision newDecision = new InternalOverlapOrgDecision(d, d.State, bg.Children, d.DependencySets); g.Decorations.Add(OrganizationDecision.DECISION_KEY, newDecision); // make sure that other rules don't try to reorganize this node d.Handled = true; } } }
/* * Process Method */ public override ListNode Process(GroupNode g, ListNode list) { // look for MutualExclusionDecisions object o = g.Decorations[MutualExclusionDecision.DECISION_KEY]; if (o != null && o is MutualExclusionDecision) { MutualExclusionDecision d = (MutualExclusionDecision)o; if (!d.Handled && d.State.Type.ValueSpace is EnumeratedSpace) { EnumeratedSpace espc = (EnumeratedSpace)d.State.Type.ValueSpace; if (espc.GetItemCount() == (d.DependencySets.Count - 1)) { for (int i = 1; i < d.DependencySets.Count; i++) { ArrayList dep = (ArrayList)d.DependencySets[i]; if (dep.Count != 1) { // Globals.AddLogLine("size! " + dep.Count ); return(list); } if (!(dep[0] is EqualsDependency)) { // Globals.AddLogLine("not equals!"); return(list); } } } else { return(list); } // we need a pointer to the GroupNode that contains the state // variable that we are looking at (because tree manipulations // will need to use it) ObjectGroupNode stateGroup = null; BranchGroupNode bg = (BranchGroupNode)g; IEnumerator e = bg.Children.GetEnumerator(); while (e.MoveNext()) { if (e.Current is ObjectGroupNode && ((ObjectGroupNode)e.Current).Object == d.State) { stateGroup = (ObjectGroupNode)e.Current; break; } } // re-order the tree ArrayList childOrder = new ArrayList(); bg.Children.Remove(stateGroup); BranchGroupNode midG = new BranchGroupNode(); midG.Children = bg.Children; e = midG.Children.GetEnumerator(); while (e.MoveNext()) { ((GroupNode)e.Current).Parent = midG; } bg.Children = new ArrayList(); ArrayList dset = (ArrayList)d.ChildSets[0]; if (dset.Count > 0) { e = dset.GetEnumerator(); while (e.MoveNext()) { GroupNode c = (GroupNode)e.Current; c.Parent = bg; midG.Children.Remove(c); bg.Children.Add(c); } } bg.Children.Add(midG); midG.Parent = bg; stateGroup.Parent = bg; for (int i = 1; i < d.ChildSets.Count; i++) { dset = (ArrayList)d.ChildSets[i]; if (dset.Count > 1) { BranchGroupNode newG = new BranchGroupNode(); newG.Parent = midG; e = dset.GetEnumerator(); while (e.MoveNext()) { GroupNode c = (GroupNode)e.Current; c.Parent = newG; midG.Children.Remove(c); newG.Children.Add(c); } childOrder.Insert(i - 1, newG); } else if (dset.Count == 0) { BranchGroupNode newG = new BranchGroupNode(); newG.Parent = midG; midG.Children.Add(newG); childOrder.Insert(i - 1, newG); } else { childOrder.Insert(i - 1, dset[0]); } } d.DependencySets.RemoveAt(0); // now create StateValueListNodes from the re-orged group tree // these nodes will be picked up by an additional rule later // in the generation process StateValueListNode newList = null; for (int i = 0; i < childOrder.Count; i++) { GroupNode group = (GroupNode)childOrder[i]; ArrayList aryDeps = (ArrayList)d.DependencySets[i]; EqualsDependency eqDep = (EqualsDependency)aryDeps[0]; newList = new StateValueListNode(d.State, eqDep.Value); list.Add(newList); group.Decorations.Add(ListNodeDecision.DECISION_KEY, new ListNodeDecision(newList, d)); } d.Handled = true; } } return(list); }
/// <summary> /// This rule looks for InsufficientHeight layout problems, and attempts /// to fix them by splitting controls onto multiple tabbed panels. /// </summary> /// <param name="problem">the layout problem to fix</param> /// <param name="node">the root of the interface tree</param> /// <param name="ui">the UIGenerator object, which contains global variables to the layout process</param> public override InterfaceNode Process(LayoutProblem problem, InterfaceNode root, UIGenerator ui) { if (problem is InsufficientHeight) { InsufficientHeight prob = (InsufficientHeight)problem; // we will use tabs if the group associated with this panel // has only BranchGroupNodes as children, and each of those // groups has labels // Step #1: check if the above criteria are true if (prob.Panel.Group is BranchGroupNode) { BranchGroupNode bg = (BranchGroupNode)prob.Panel.Group; if (!bg.ContainsOnlyGroups()) { return(root); } while (bg.Count == 1) { bg = (BranchGroupNode)bg.Children[0]; if (!bg.ContainsOnlyGroups()) { return(root); } } IEnumerator e = bg.Children.GetEnumerator(); while (e.MoveNext()) { if (((GroupNode)e.Current).Labels == null) { return(root); } } // If we get here, all of the criteria have been met. // Now we insert our tabbed panel. TabbedOverlappingPanelsNode tabs = new TabbedOverlappingPanelsNode(bg); prob.Panel.Container.GetControl().Controls.Remove(prob.Panel.GetContainerCIO().GetControl()); if (prob.Panel.GetParent() != null) { prob.Panel.GetParent().AddPanel(tabs); prob.Panel.GetParent().RemovePanel(prob.Panel); } else { root = tabs; } // now we need to distribute the rows from the panel into the new tabbed panels IEnumerator row = prob.Panel.Rows.GetEnumerator(); while (row.MoveNext()) { Row r = (Row)row.Current; GroupNode g = r.Group; while (tabs[g] == null) { g = g.Parent; } ((PanelNode)tabs[g].GetChildNode()).AddRow(r); } // finally, add the components and the do the layout for the tabs tabs.SetLocation(prob.Panel.GetBounds().X, prob.Panel.GetBounds().Y); tabs.SetSize(prob.Panel.GetBounds().Width, prob.Panel.GetBounds().Height); tabs.AddComponents(prob.Panel.Container, ui.LayoutVars); tabs.DoLayout(ui.LayoutVars); } } return(root); }
/* * Process Method */ public override void Process(GroupNode g, UIGenerator ui) { // look for MutualExclusionDecisions object o = g.Decorations[MutualExclusionDecision.DECISION_KEY]; if (o != null && o is MutualExclusionDecision) { MutualExclusionDecision d = (MutualExclusionDecision)o; if (!d.Handled) { // this will never occur on an ObjectGroupNode BranchGroupNode bg = (BranchGroupNode)g; // we need a pointer to the GroupNode that contains the state // variable that we are looking at (because tree manipulations // will need to use it) ObjectGroupNode stateGroup = null; IEnumerator e = bg.Children.GetEnumerator(); while (e.MoveNext()) { if (((GroupNode)e.Current).IsObject() && ((ObjectGroupNode)e.Current).Object == d.State) { stateGroup = (ObjectGroupNode)e.Current; break; } } // re-order the tree ArrayList childOrder = new ArrayList(); bg.Children.Remove(stateGroup); BranchGroupNode midG = new BranchGroupNode(); midG.Children = bg.Children; e = midG.Children.GetEnumerator(); while (e.MoveNext()) { ((GroupNode)e.Current).Parent = midG; } bg.Children = new ArrayList(); ArrayList dset = (ArrayList)d.ChildSets[0]; if (dset.Count > 0) { e = dset.GetEnumerator(); while (e.MoveNext()) { GroupNode c = (GroupNode)e.Current; c.Parent = bg; midG.Children.Remove(c); bg.Children.Add(c); } } bg.Children.Add(stateGroup); bg.Children.Add(midG); midG.Parent = bg; stateGroup.Parent = bg; for (int i = 1; i < d.ChildSets.Count; i++) { dset = (ArrayList)d.ChildSets[i]; if (dset.Count > 1) { BranchGroupNode newG = new BranchGroupNode(); newG.Parent = midG; e = dset.GetEnumerator(); while (e.MoveNext()) { GroupNode c = (GroupNode)e.Current; c.Parent = newG; midG.Children.Remove(c); newG.Children.Add(c); } childOrder.Insert(i - 1, newG); } else if (dset.Count == 0) { BranchGroupNode newG = new BranchGroupNode(); newG.Parent = midG; newG.Children = new ArrayList(); midG.Children.Add(newG); childOrder.Insert(i - 1, newG); } else { childOrder.Insert(i - 1, dset[0]); } } d.DependencySets.RemoveAt(0); OrganizationDecision newDecision = new ExternalOverlapOrgDecision(d, d.State, childOrder, d.DependencySets); midG.Decorations.Add(OrganizationDecision.DECISION_KEY, newDecision); d.Handled = true; } } }
protected ArrayList findMutualExclusion(GroupNode g, ApplianceState state, Hashtable groupDeps) { ArrayList childSets = new ArrayList(); ArrayList depSets = new ArrayList(); // The first element in childSet is that set of all children // that do not depend on this state at all (there aren't // necessarily any) ArrayList noDepChildren = new ArrayList(); ArrayList noDeps = new ArrayList(); childSets.Add(noDepChildren); depSets.Add(noDeps); BranchGroupNode bg = (BranchGroupNode)g; IEnumerator e = bg.Children.GetEnumerator(); while (e.MoveNext()) { bool cont = false; GroupNode c = (GroupNode)e.Current; if (c.IsObject() && ((ObjectGroupNode)c).Object == state) { continue; // don't consider the } // depended child // if deps is null, then something is wrong ArrayList deps = (ArrayList)groupDeps[c]; if (deps.Count == 0) { noDepChildren.Add(c); continue; } ArrayList dset = null; for (int i = 1; i < depSets.Count; i++) { dset = (ArrayList)depSets[i]; // check if this element is mutex with sets[ i ] ArrayList merge = mergeTwoVectors(deps, dset); if (merge.Count != (deps.Count + dset.Count)) { depSets[i] = merge; dset = (ArrayList)childSets[i]; dset.Add(c); cont = true; break; } } if (cont) { continue; } depSets.Add(deps); dset = new ArrayList(); dset.Add(c); childSets.Add(dset); } ArrayList array = new ArrayList(); array.Add(childSets); array.Add(depSets); return(array); }
protected void gridSetupHelper(BranchGroupNode group, ArrayList listTables, DataTable current, DataGridTableStyle style) { IEnumerator e = group.Children.GetEnumerator(); while (e.MoveNext()) { if (e.Current is ListGroupNode) { ListGroupNode lg = (ListGroupNode)e.Current; // create a new table DataTable table = new DataTable(lg.FullPath); // create array for storing primary keys DataColumn[] keys = new DataColumn[listTables.Count + 1]; // add the table to the DataSet _dataSet.Tables.Add(table); IEnumerator list = listTables.GetEnumerator(); for (int i = 0; list.MoveNext(); i++) { DataTable parentTable = (DataTable)list.Current; string parentIndexCol = parentTable.TableName + "." + INDEX_COL_NAME; // add a column to reference the parent table index table.Columns.Add(parentIndexCol, Type.GetType("System.Int32")); // add column to primary key array keys[i] = table.Columns[parentIndexCol]; } // add the special column with an integer type table.Columns.Add(INDEX_COL_NAME, Type.GetType("System.Int32")); table.Columns[INDEX_COL_NAME].Unique = true; keys[listTables.Count] = table.Columns[INDEX_COL_NAME]; // set primary keys table.PrimaryKey = keys; // determine relation name string relationName = lg.Name; if (lg.Labels != null) { relationName = lg.Labels.GetShortestLabel(); } // make the parent/child DataRelation to the DataSet DataRelation r = new DataRelation(relationName, current.Columns[INDEX_COL_NAME], table.Columns[current.TableName + "." + INDEX_COL_NAME]); // add relation to the DataSet _dataSet.Relations.Add(r); // create the DataGridTableStyle DataGridTableStyle tableStyle = new DataGridTableStyle(); tableStyle.MappingName = table.TableName; tableStyle.ReadOnly = true; listTables.Add(table); gridSetupHelper(lg, listTables, table, tableStyle); listTables.RemoveAt(listTables.Count - 1); // add TableStyle after all columns have been found _listGrid.TableStyles.Add(tableStyle); } else if (e.Current is BranchGroupNode) { gridSetupHelper((BranchGroupNode)e.Current, listTables, current, style); } else if (e.Current is ObjectGroupNode) { ApplianceObject ao = ((ObjectGroupNode)e.Current).Object; string name = ao.FullName.Substring(current.TableName.Length + 1); if (ao.State) { DataGridColumnStyle columnStyle; Type type; if (((ApplianceState)ao).Type.ValueSpace.Space == PUC.Types.ValueSpace.BOOLEAN_SPACE) { type = true.GetType(); columnStyle = new DataGridBoolColumn(); } else { type = "".GetType(); columnStyle = new DataGridTextBoxColumn(); } columnStyle.MappingName = name; columnStyle.HeaderText = ao.Labels.GetShortestLabel(); columnStyle.ReadOnly = ((ApplianceState)ao).ReadOnly; if (!columnStyle.ReadOnly) { style.ReadOnly = false; } if (((ApplianceState)ao).Type.ValueSpace.Space == PUC.Types.ValueSpace.BINARY_SPACE) { columnStyle.ReadOnly = true; } DataColumn col = new DataColumn(name, type); _columnToStateMap[col] = ao; current.Columns.Add(col); style.GridColumnStyles.Add(columnStyle); } else if (ao is ApplianceCommand) { DataGridBoolColumn columnStyle = new DataGridBoolColumn(); columnStyle.MappingName = name; columnStyle.ReadOnly = style.ReadOnly = false; DataColumn col = new DataColumn(name, true.GetType()); _columnToStateMap[col] = ao; current.Columns.Add(col); style.GridColumnStyles.Add(columnStyle); } } } }
/* * Process Method */ public override void Process(GroupNode g, UIGenerator ui) { // look for MutualExclusionDecisions object o = g.Decorations[MutualExclusionDecision.DECISION_KEY]; if (o != null && o is MutualExclusionDecision) { MutualExclusionDecision d = (MutualExclusionDecision)o; if (!d.Handled && d.State.Type.ValueSpace is EnumeratedSpace) { object stateval = d.State.Value; EnumeratedSpace espc = (EnumeratedSpace)d.State.Type.ValueSpace; if (espc.GetItemCount() == (d.DependencySets.Count - 1)) { for (int i = 1; i < d.DependencySets.Count; i++) { ArrayList dep = (ArrayList)d.DependencySets[i]; if (dep.Count != 1) { // Globals.AddLogLine("size! " + dep.Count ); return; } if (!(dep[0] is EqualsDependency)) { // Globals.AddLogLine("not equals!"); return; } } } else { return; } // we need a pointer to the GroupNode that contains the state // variable that we are looking at (because tree manipulations // will need to use it) ObjectGroupNode stateGroup = null; BranchGroupNode bg = (BranchGroupNode)g; IEnumerator e = bg.Children.GetEnumerator(); while (e.MoveNext()) { if (((GroupNode)e.Current).IsObject() && ((ObjectGroupNode)e.Current).Object == d.State) { stateGroup = (ObjectGroupNode)e.Current; break; } } // re-order the tree ArrayList childOrder = new ArrayList(); bg.Children.Remove(stateGroup); BranchGroupNode midG = new BranchGroupNode(); midG.Children = bg.Children; e = midG.Children.GetEnumerator(); while (e.MoveNext()) { ((GroupNode)e.Current).Parent = midG; } bg.Children = new ArrayList(); ArrayList dset = (ArrayList)d.ChildSets[0]; if (dset.Count > 0) { e = dset.GetEnumerator(); while (e.MoveNext()) { GroupNode c = (GroupNode)e.Current; c.Parent = bg; midG.Children.Remove(c); bg.Children.Add(c); } } bg.Children.Add(midG); midG.Parent = bg; stateGroup.Parent = bg; for (int i = 1; i < d.ChildSets.Count; i++) { dset = (ArrayList)d.ChildSets[i]; if (dset.Count > 1) { BranchGroupNode newG = new BranchGroupNode(); newG.Parent = midG; e = dset.GetEnumerator(); while (e.MoveNext()) { GroupNode c = (GroupNode)e.Current; c.Parent = newG; midG.Children.Remove(c); newG.Children.Add(c); } childOrder.Insert(i - 1, newG); } else if (dset.Count == 0) { BranchGroupNode newG = new BranchGroupNode(); newG.Parent = midG; newG.Children = new ArrayList(); midG.Children.Add(newG); childOrder.Insert(i - 1, newG); } else { childOrder.Insert(i - 1, dset[0]); } } d.DependencySets.RemoveAt(0); OrganizationDecision newDecision = new TabbedOverlapOrgDecision(d, ui, d.State, childOrder, d.DependencySets, true); midG.Decorations.Add(OrganizationDecision.DECISION_KEY, newDecision); d.Handled = true; } } }