private void RemoveNode(GoalNode node, List <ulong> visible) { RefreshParents(node); UnloadNode(node, visible); RemoveFromMap(node.Goal); node.Remove(); }
private void RefreshParents(GoalNode node) { GoalNode parent = node.Parent as GoalNode; while (parent != null) { parent.RefreshProgress(); parent = parent.Parent as GoalNode; } }
private void GoalTree_MouseClick(object sender, MouseEventArgs e) { if (e.Button != MouseButtons.Right) { return; } GoalNode node = GoalTree.GetNodeAt(e.Location) as GoalNode; if (node == null) { return; } ContextMenuStripEx menu = new ContextMenuStripEx(); bool owned = IsOwned(node); bool root = false; GoalNode parent = node.ParentNode() as GoalNode; if (parent == null && node.Goal.Person == Core.UserID && Head.Person == Core.UserID) { root = true; } if (owned) { menu.Items.Add(new GoalMenuItem("Edit", node.Goal, null, Goal_Edit)); menu.Items.Add(new GoalMenuItem("View Schedule", node.Goal, PlanRes.Schedule.ToBitmap(), Goal_Schedule)); menu.Items.Add("-"); } if (root) { menu.Items.Add(new GoalMenuItem("Archive", node.Goal, PlanRes.archive, Goal_Archive)); } if (owned) { menu.Items.Add(new GoalMenuItem("Delete", node.Goal, PlanRes.delete, Goal_Delete)); } if (!owned) { menu.Items.Add(new GoalMenuItem("Details", node.Goal, PlanRes.details, Goal_View)); } menu.Show(GoalTree, e.Location); }
private GoalNode CreateNode(PlanGoal goal) { GoalNode node = new GoalNode(this, goal); if (!TreeMap.ContainsKey(goal.Person)) { TreeMap[goal.Person] = new List <GoalNode>(); } TreeMap[goal.Person].Add(node); return(node); }
private void ExpandPath(GoalNode node, List <ulong> uplinks) { if (!uplinks.Contains(node.Goal.Person)) { return; } // expand triggers even loading nodes two levels down, one level shown, the other hidden node.Expand(); foreach (GoalNode sub in node.Nodes) { ExpandPath(sub, uplinks); } }
private bool LowNode() { GoalNode above = Parent as GoalNode; while (above != null) { if (above.Goal.Person == Panel.View.UserID) { return(true); } above = above.Parent as GoalNode; } return(false); }
private bool IsOwned(GoalNode node) { GoalNode parent = node.ParentNode() as GoalNode; if (parent != null && parent.Goal.Person == Core.UserID) { return(true); } if (parent == null && node.Goal.Person == Core.UserID && Head.Person == Core.UserID) { return(true); } return(false); }
void GoalTree_NodeExpanding(object sender, EventArgs e) { GoalNode node = sender as GoalNode; if (node == null) { return; } Debug.Assert(node.AddSubs); // search invisible children of expanded nodes so ready when expanded foreach (GoalNode child in node.Nodes) { LoadNode(child); } }
private void ReloadGoals() { TreeMap.Clear(); GoalTree.Nodes.Clear(); List <ulong> uplinks = Trust.GetUplinkIDs(View.UserID, View.ProjectID); uplinks.Add(View.UserID); // show all branches if (!MineOnly.Checked) { GoalNode root = CreateNode(Head); LoadNode(root); GoalTree.Nodes.Add(root); ExpandPath(root, uplinks); } // show only our branch else if (Head != null) { foreach (ulong id in uplinks) { OpPlan plan = Plans.GetPlan(id, true); if (plan != null && plan.GoalMap.ContainsKey(Head.Ident)) { foreach (PlanGoal goal in plan.GoalMap[Head.Ident]) { if (goal.Person == View.UserID) { GoalNode root = CreateNode(goal); LoadNode(root); InsertSubNode(GoalTree.virtualParent, root); root.Expand(); } } } } } Reselect(); }
public void InsertSubNode(TreeListNode parent, GoalNode node) { int index = 0; foreach (TreeListNode entry in parent.Nodes) { if (string.Compare(node.Text, entry.Text, true) < 0) { parent.Nodes.Insert(index, node); node.RefreshProgress(); return; } else { index++; } } parent.Nodes.Insert(index, node); node.RefreshProgress(); }
private void GoalTree_SelectedItemChanged(object sender, EventArgs e) { if (GoalTree.SelectedNodes.Count == 0) { return; } GoalNode node = GoalTree.SelectedNodes[0] as GoalNode; if (node == null) { return; } Plans.Research(node.Goal.Person); Trust.Research(node.Goal.Person, View.ProjectID, false); UpdatePlanItems(node); View.SetDetails(node.Goal, null); }
private void GoalTree_MouseDoubleClick(object sender, MouseEventArgs e) { GoalNode node = GoalTree.GetNodeAt(e.Location) as GoalNode; if (node == null) { return; } bool owned = IsOwned(node); EditGoalMode editMode = owned ? EditGoalMode.Edit : EditGoalMode.View; EditGoal form = new EditGoal(editMode, View, node.Goal); if (form.ShowDialog(this) == DialogResult.OK) { if (owned) { View.ChangesMade(); } } }
private void LoadNode(GoalNode node) { // check if already loaded if (node.AddSubs) { return; } node.AddSubs = true; // load that person specified by the node OpPlan plan = Plans.GetPlan(node.Goal.Person, true); if (plan == null) { Plans.Research(node.Goal.Person); return; } if (!plan.GoalMap.ContainsKey(Head.Ident)) { return; } // read the person's goals foreach (PlanGoal goal in plan.GoalMap[Head.Ident]) { // if the upbranch matches the node's down branch, add if (goal.BranchDown == 0 || goal.BranchUp != node.Goal.BranchDown) { continue; } if (CheckGoal(plan.UserID, goal)) { InsertSubNode(node, CreateNode(goal)); } } }
private void VisiblePath(GoalNode node, List <ulong> path) { bool found = false; foreach (GoalNode sub in node.Nodes) { if (path.Contains(sub.Goal.Person)) { found = true; } } if (found) { node.Expand(); foreach (GoalNode sub in node.Nodes) { VisiblePath(sub, path); } } }
void GoalTree_NodeCollapsed(object sender, EventArgs e) { GoalNode node = sender as GoalNode; if (node == null) { return; } if (!node.AddSubs) // this node is already collapsed { return; } // remove nodes 2 levels down foreach (GoalNode child in node.Nodes) { UnloadNode(child, null); } Debug.Assert(node.AddSubs); // this is the top level, children hidden underneath }
private void UnloadNode(GoalNode node, List <ulong> visible) { node.AddSubs = false; // for each child, call unload node, then clear foreach (GoalNode child in node.Nodes) { RemoveFromMap(child.Goal); if (visible != null && child.IsVisible()) { visible.Add(child.Goal.Person); } UnloadNode(child, visible); } node.Nodes.Clear(); node.Collapse(); }
public void TrustUpdate(ulong key) { if (Head == null) { return; } List <ulong> visible = new List <ulong>(); // remove key from all parent sub items // if link changed children confirmations, this takes care of that during the re-add if (MineOnly.Checked) { return; } if (key == Head.Person || MineOnly.Checked) { ReloadGoals(); return; } else if (TreeMap.ContainsKey(key)) { List <GoalNode> list = new List <GoalNode>(TreeMap[key]); foreach (GoalNode node in list) { RemoveNode(node, visible); } } List <ulong> myUplinks = Trust.GetUplinkIDs(View.UserID, View.ProjectID); List <ulong> linkUplinks = Trust.GetUplinkIDs(key, View.ProjectID); // each uplink from this key can assign goals, we need to see if a re-add is necessary foreach (ulong uplink in linkUplinks) { OpPlan plan = Plans.GetPlan(uplink, true); if (plan != null && TreeMap.ContainsKey(uplink)) { foreach (GoalNode treeNode in TreeMap[uplink]) { // look through goals for assignments for this link if (treeNode.AddSubs && plan.GoalMap.ContainsKey(Head.Ident)) { foreach (PlanGoal goal in plan.GoalMap[Head.Ident]) { if (goal.Person == key && treeNode.Goal.BranchDown == goal.BranchUp && CheckGoal(plan.UserID, goal)) { GoalNode node = CreateNode(goal); InsertSubNode(treeNode, node); RefreshParents(node); if (treeNode.IsExpanded) { LoadNode(node); } } } } } } } // make removed nodes that were visible, visible again foreach (ulong id in visible) { List <ulong> uplinks = Trust.GetUplinkIDs(id, View.ProjectID); foreach (GoalNode root in GoalTree.Nodes) // should only be one root { VisiblePath(root, uplinks); } } Reselect(); }
private void UpdatePlanItems(GoalNode node) { PlanListItem ReselectPlanItem = null; if (PlanList.SelectedItems.Count > 0) ReselectPlanItem = PlanList.SelectedItems[0] as PlanListItem; PlanList.Items.Clear(); if (node == null) { Selected = null; DelegateLink.Hide(); PlanList.Columns[0].Text = "Plan"; //splitContainer2.Panel1Collapsed = true; return; } Selected = node.Goal; // set delegate task vis if (Selected.Person == Core.UserID && Trust.HasSubs(Selected.Person, View.ProjectID )) DelegateLink.Show(); else DelegateLink.Hide(); if (Selected.Person == Core.UserID) AddItemLink.Show(); else AddItemLink.Hide(); // name's Plan for <goal> PlanList.Columns[0].Text = Core.GetName(node.Goal.Person) + "'s Plan for " + node.Goal.Title; // set plan items OpPlan plan = Plans.GetPlan(Selected.Person, true); if (plan == null) // re-searched at during selection return; if (plan.ItemMap.ContainsKey(Head.Ident)) foreach (PlanItem item in plan.ItemMap[Head.Ident]) if (item.BranchUp == Selected.BranchDown) { PlanListItem row = new PlanListItem(item); if (ReselectPlanItem != null && item == ReselectPlanItem.Item) row.Selected = true; PlanList.Items.Add(row); FormatTime(row); } PlanList.Invalidate(); }
private void UnloadNode(GoalNode node, List<ulong> visible) { node.AddSubs = false; // for each child, call unload node, then clear foreach (GoalNode child in node.Nodes) { RemoveFromMap(child.Goal); if (visible != null && child.IsVisible()) visible.Add(child.Goal.Person); UnloadNode(child, visible); } node.Nodes.Clear(); node.Collapse(); }
private GoalNode CreateNode(PlanGoal goal) { GoalNode node = new GoalNode(this, goal); if (!TreeMap.ContainsKey(goal.Person)) TreeMap[goal.Person] = new List<GoalNode>(); TreeMap[goal.Person].Add(node); return node; }
private void LoadNode(GoalNode node) { // check if already loaded if (node.AddSubs) return; node.AddSubs = true; // load that person specified by the node OpPlan plan = Plans.GetPlan(node.Goal.Person, true); if (plan == null) { Plans.Research(node.Goal.Person); return; } if (!plan.GoalMap.ContainsKey(Head.Ident)) return; // read the person's goals foreach (PlanGoal goal in plan.GoalMap[Head.Ident]) { // if the upbranch matches the node's down branch, add if (goal.BranchDown == 0 || goal.BranchUp != node.Goal.BranchDown) continue; if (CheckGoal(plan.UserID, goal)) InsertSubNode(node, CreateNode(goal)); } }
private void UpdatePlanItems(GoalNode node) { PlanListItem ReselectPlanItem = null; if (PlanList.SelectedItems.Count > 0) { ReselectPlanItem = PlanList.SelectedItems[0] as PlanListItem; } PlanList.Items.Clear(); if (node == null) { Selected = null; DelegateLink.Hide(); PlanList.Columns[0].Text = "Plan"; //splitContainer2.Panel1Collapsed = true; return; } Selected = node.Goal; // set delegate task vis if (Selected.Person == Core.UserID && Trust.HasSubs(Selected.Person, View.ProjectID)) { DelegateLink.Show(); } else { DelegateLink.Hide(); } if (Selected.Person == Core.UserID) { AddItemLink.Show(); } else { AddItemLink.Hide(); } // name's Plan for <goal> PlanList.Columns[0].Text = Core.GetName(node.Goal.Person) + "'s Plan for " + node.Goal.Title; // set plan items OpPlan plan = Plans.GetPlan(Selected.Person, true); if (plan == null) // re-searched at during selection { return; } if (plan.ItemMap.ContainsKey(Head.Ident)) { foreach (PlanItem item in plan.ItemMap[Head.Ident]) { if (item.BranchUp == Selected.BranchDown) { PlanListItem row = new PlanListItem(item); if (ReselectPlanItem != null && item == ReselectPlanItem.Item) { row.Selected = true; } PlanList.Items.Add(row); FormatTime(row); } } } PlanList.Invalidate(); }
private bool IsOwned(GoalNode node) { GoalNode parent = node.ParentNode() as GoalNode; if (parent != null && parent.Goal.Person == Core.UserID) return true; if (parent == null && node.Goal.Person == Core.UserID && Head.Person == Core.UserID) return true; return false; }
private void RemoveNode(GoalNode node, List<ulong> visible) { RefreshParents(node); UnloadNode(node, visible); RemoveFromMap(node.Goal); node.Remove(); }
private void ExpandPath(GoalNode node, List<ulong> uplinks) { if (!uplinks.Contains(node.Goal.Person)) return; // expand triggers even loading nodes two levels down, one level shown, the other hidden node.Expand(); foreach (GoalNode sub in node.Nodes) ExpandPath(sub, uplinks); }
public void InsertSubNode(TreeListNode parent, GoalNode node) { int index = 0; foreach (TreeListNode entry in parent.Nodes) if (string.Compare(node.Text, entry.Text, true) < 0) { parent.Nodes.Insert(index, node); node.RefreshProgress(); return; } else index++; parent.Nodes.Insert(index, node); node.RefreshProgress(); }
public void PlanUpdate(OpPlan plan) { if (Head == null) { return; } if (!plan.Loaded) { Plans.LoadPlan(plan.UserID); } // update progress of high levels for updated plan not in tree map because it is hidden if (plan.GoalMap.ContainsKey(Head.Ident) || plan.ItemMap.ContainsKey(Head.Ident)) { List <ulong> uplinks = Trust.GetUplinkIDs(plan.UserID, View.ProjectID); uplinks.Add(plan.UserID); if (uplinks.Contains(Head.Person)) { foreach (ulong id in uplinks) { if (TreeMap.ContainsKey(id)) { foreach (GoalNode node in TreeMap[id]) { node.RefreshProgress(); } } } } } if (!TreeMap.ContainsKey(plan.UserID)) { return; } if (MineOnly.Checked) { List <ulong> myUplinks = Trust.GetUplinkIDs(View.UserID, View.ProjectID); myUplinks.Add(View.UserID); if (myUplinks.Contains(plan.UserID)) { ReloadGoals(); return; } } List <PlanGoal> updated = new List <PlanGoal>(); if (plan.GoalMap.ContainsKey(Head.Ident)) { updated = plan.GoalMap[Head.Ident]; } List <ulong> visible = new List <ulong>(); foreach (GoalNode oldNode in TreeMap[plan.UserID]) { // if root if (oldNode.Goal.BranchDown == 0) { foreach (PlanGoal updatedGoal in updated) { if (updatedGoal.BranchDown == 0) { oldNode.Update(updatedGoal); RefreshParents(oldNode); break; } } } // go through displayed goals, if doesn't exist in update, remove List <GoalNode> removeList = new List <GoalNode>(); foreach (GoalNode original in oldNode.Nodes) { bool remove = true; foreach (PlanGoal updatedGoal in updated) { if (oldNode.Goal.BranchDown == updatedGoal.BranchUp && original.Goal.BranchDown == updatedGoal.BranchDown) { remove = false; original.Update(updatedGoal); RefreshParents(original); } } if (remove) { removeList.Add(original); } } foreach (GoalNode node in removeList) { RemoveNode(node, visible); } // go through updated goals, if isn't shown in display, add foreach (PlanGoal updatedGoal in updated) { bool add = true; // if not in subs, add if (updatedGoal.BranchDown == 0) { continue; } if (oldNode.Goal.BranchDown != updatedGoal.BranchUp) { continue; } foreach (GoalNode original in oldNode.Nodes) { if (oldNode.Goal.BranchDown == updatedGoal.BranchUp && original.Goal.BranchDown == updatedGoal.BranchDown) { add = false; } } //crit check this is hit if (add && oldNode.AddSubs && CheckGoal(plan.UserID, updatedGoal)) { GoalNode node = CreateNode(updatedGoal); InsertSubNode(oldNode, node); RefreshParents(node); if (oldNode.IsExpanded) { LoadNode(node); } } } } Reselect(); }
private void VisiblePath(GoalNode node, List<ulong> path) { bool found = false; foreach (GoalNode sub in node.Nodes) if (path.Contains(sub.Goal.Person)) found = true; if (found) { node.Expand(); foreach (GoalNode sub in node.Nodes) VisiblePath(sub, path); } }