Ejemplo n.º 1
0
        private void LoadNode(PlanNode node)
        {
            // check if already loaded
            if (node.AddSubs)
            {
                return;
            }


            node.AddSubs = true;

            // go through downlinks

            OpLink[] downlinks = (from link in node.Link.Downlinks
                                  where node.Link.Confirmed.Contains(link.UserID) ||
                                  Uplinks.Contains(link.UserID)
                                  select link).ToArray();

            foreach (OpLink link in downlinks)
            {
                // if doesnt exist search for it
                if (!link.Trust.Loaded)
                {
                    Trust.Research(link.UserID, ProjectID, false);
                    continue;
                }

                Plans.Research(link.UserID);

                GuiUtils.InsertSubNode(node, CreateNode(link));
            }
        }
Ejemplo n.º 2
0
        private PlanNode CreateNode(OpLink link)
        {
            PlanNode node = new PlanNode(this, link, link.UserID == UserID);

            NodeMap[link.UserID] = node;

            return(node);
        }
Ejemplo n.º 3
0
        void RecurseFocus(PlanNode node)
        {
            // add parent to focus list
            Core.KeepData.SafeAdd(node.Link.UserID, true);

            // iterate through sub items
            foreach (PlanNode sub in node.Nodes)
            {
                RecurseFocus(sub);
            }
        }
Ejemplo n.º 4
0
        PlanNode GetSelected()
        {
            if (PlanStructure.SelectedNodes.Count == 0)
            {
                return(null);
            }

            PlanNode node = (PlanNode)PlanStructure.SelectedNodes[0];

            return(node);
        }
Ejemplo n.º 5
0
        public BlockRow(PlanNode node)
        {
            InitializeComponent();

            Node   = node;
            View   = node.View;
            UserID = node.Link.UserID;

            SetStyle(ControlStyles.UserPaint, true);
            SetStyle(ControlStyles.AllPaintingInWmPaint, true);

            BlackPen.DashStyle = DashStyle.Dot;
        }
Ejemplo n.º 6
0
        private void ExpandPath(PlanNode node, List <ulong> path)
        {
            if (!path.Contains(node.Link.UserID))
            {
                return;
            }

            // expand triggers even loading nodes two levels down, one level shown, the other hidden
            node.Expand();

            foreach (PlanNode sub in node.Nodes)
            {
                ExpandPath(sub, path);
            }
        }
Ejemplo n.º 7
0
        void PlanStructure_NodeExpanding(object sender, EventArgs e)
        {
            PlanNode node = sender as PlanNode;

            if (node == null)
            {
                return;
            }

            Debug.Assert(node.AddSubs);

            // node now expanded, get next level below children
            foreach (PlanNode child in node.Nodes)
            {
                LoadNode(child);
            }
        }
Ejemplo n.º 8
0
        private void PlanStructure_SelectedItemChanged(object sender, EventArgs e)
        {
            RefreshRows(); // updates selection box graphics

            // children searched on expand

            PlanNode node = GetSelected();

            if (node == null)
            {
                SetDetails(null);
                return;
            }
            // link research
            Trust.Research(node.Link.UserID, ProjectID, false);

            // plan research
            Plans.Research(node.Link.UserID);
        }
Ejemplo n.º 9
0
        private void VisiblePath(PlanNode node, List <ulong> path)
        {
            bool found = false;

            foreach (PlanNode sub in node.Nodes)
            {
                if (path.Contains(sub.Link.UserID))
                {
                    found = true;
                }
            }

            if (found)
            {
                node.Expand();

                foreach (PlanNode sub in node.Nodes)
                {
                    VisiblePath(sub, path);
                }
            }
        }
Ejemplo n.º 10
0
        void PlanStructure_NodeCollapsed(object sender, EventArgs e)
        {
            PlanNode node = sender as PlanNode;

            if (node == null)
            {
                return;
            }

            if (!node.AddSubs) // this node is already collapsed
            {
                return;
            }

            // remove nodes 2 levels down
            foreach (PlanNode child in node.Nodes)
            {
                UnloadNode(child, null);
            }

            Debug.Assert(node.AddSubs); // this is the top level, children hidden underneath
        }
Ejemplo n.º 11
0
        private void UnloadNode(PlanNode node, List <ulong> visible)
        {
            node.AddSubs = false;

            if (visible != null && node.IsVisible())
            {
                visible.Add(node.Link.UserID);
            }

            // for each child, call unload node, then clear
            foreach (PlanNode child in node.Nodes)
            {
                if (NodeMap.ContainsKey(child.Link.UserID))
                {
                    NodeMap.Remove(child.Link.UserID);
                }

                UnloadNode(child, visible);
            }

            // unloads children of node, not the node itself
            node.Nodes.Clear();
            node.Collapse();
        }
Ejemplo n.º 12
0
        public BlockRow(PlanNode node)
        {
            InitializeComponent();

            Node = node;
            View = node.View;
            UserID = node.Link.UserID;

            SetStyle(ControlStyles.UserPaint, true);
            SetStyle(ControlStyles.AllPaintingInWmPaint, true);

            BlackPen.DashStyle = DashStyle.Dot;
        }
Ejemplo n.º 13
0
        private PlanNode CreateNode(OpLink link)
        {
            PlanNode node = new PlanNode(this, link, link.UserID == UserID);

            NodeMap[link.UserID] = node;

            return node;
        }
Ejemplo n.º 14
0
        private void VisiblePath(PlanNode node, List<ulong> path)
        {
            bool found = false;

            foreach (PlanNode sub in node.Nodes)
                if (path.Contains(sub.Link.UserID))
                    found = true;

            if (found)
            {
                node.Expand();

                foreach (PlanNode sub in node.Nodes)
                    VisiblePath(sub, path);
            }
        }
Ejemplo n.º 15
0
        private void LoadNode(PlanNode node)
        {
            // check if already loaded
            if (node.AddSubs)
                return;

            node.AddSubs = true;

            // go through downlinks

            OpLink[] downlinks = (from link in node.Link.Downlinks
                                  where node.Link.Confirmed.Contains(link.UserID) ||
                                        Uplinks.Contains(link.UserID)
                                  select link).ToArray();

            foreach (OpLink link in downlinks)
            {
                // if doesnt exist search for it
                if (!link.Trust.Loaded)
                {
                    Trust.Research(link.UserID, ProjectID, false);
                    continue;
                }

                Plans.Research(link.UserID);

                GuiUtils.InsertSubNode(node, CreateNode(link));
            }
        }
Ejemplo n.º 16
0
        private void ExpandPath(PlanNode node, List<ulong> path)
        {
            if (!path.Contains(node.Link.UserID))
                return;

            // expand triggers even loading nodes two levels down, one level shown, the other hidden
            node.Expand();

            foreach (PlanNode sub in node.Nodes)
                ExpandPath(sub, path);
        }
Ejemplo n.º 17
0
 private void RemoveNode(PlanNode node)
 {
     UnloadNode(node, null);           // unload subs
     NodeMap.Remove(node.Link.UserID); // remove from map
     node.Remove();                    // remove from tree
 }
Ejemplo n.º 18
0
        void RecurseFocus(PlanNode node)
        {
            // add parent to focus list
            Core.KeepData.SafeAdd(node.Link.UserID, true);

            // iterate through sub items
            foreach (PlanNode sub in node.Nodes)
                RecurseFocus(sub);
        }
Ejemplo n.º 19
0
 private void RemoveNode(PlanNode node)
 {
     UnloadNode(node, null); // unload subs
     NodeMap.Remove(node.Link.UserID); // remove from map
     node.Remove(); // remove from tree
 }
Ejemplo n.º 20
0
        void Trust_Update(ulong key)
        {
            // copied from linkTree's source
            OpLink link = Trust.GetLink(key, ProjectID);

            if (link == null)
            {
                if (NodeMap.ContainsKey(key))
                {
                    RemoveNode(NodeMap[key]);
                }

                return;
            }

            /*above should do this now
             * if (!link.Projects.Contains(ProjectID) && !link.Downlinks.ContainsKey(ProjectID))
             * {
             *  if (NodeMap.ContainsKey(key))
             *      RemoveNode(NodeMap[key]);
             *
             *  return;
             * }*/

            PlanNode node = null;

            if (NodeMap.ContainsKey(key))
            {
                node = NodeMap[key];
            }

            TreeListNode parent = null;
            OpLink       uplink = GetTreeHigher(link);

            if (uplink == null)
            {
                parent = PlanStructure.virtualParent;
            }

            else if (NodeMap.ContainsKey(uplink.UserID))
            {
                parent = NodeMap[uplink.UserID];
            }

            else if (uplink.IsLoopRoot)
            {
                parent = new TreeListNode(); // ensures that tree is refreshed
            }
            // if nodes status unchanged
            if (node != null && parent != null && node.Parent == parent)
            {
                node.UpdateName();
                Invalidate();
                return;
            }

            // only if parent is visible
            if (parent != null)
            {
                RefreshUplinks();
                RefreshStructure();
            }

            ////////////////////////////////////////////////////////////////////

            /*
             * // update uplinks
             * if (key == DhtID || Uplinks.Contains(key))
             *  RefreshUplinks();
             *
             *
             * // create a node item, or get the current one
             * PlanNode node = null;
             *
             * if (NodeMap.ContainsKey(key))
             *  node = NodeMap[key];
             * else
             *  node = new PlanNode(this, link, key == DhtID);
             *
             *
             * // get the right parent node for this item
             * TreeListNode parent = null;
             *
             * OpLink parentLink = link.GetHigher(ProjectID, false);
             *
             * if (parentLink == null) // dont combine below, causes next if to fail
             *  parent = Uplinks.Contains(key) ? PlanStructure.virtualParent : null;
             *
             * else if (NodeMap.ContainsKey(parentLink.DhtID))
             *  parent = NodeMap[parentLink.DhtID];
             *
             * else
             *  parent = null; // branch this link is apart of is not visible in current display
             *
             *
             * // remember settings
             * bool selected = node.Selected;
             *
             *
             * if (node.Parent != parent)
             * {
             *  List<ulong> visible = new List<ulong>();
             *
             *  // remove previous instance of node
             *  if (node.Parent != null)
             *  {
             *      if (node.IsVisible())
             *          visible.Add(link.DhtID);
             *
             *      UnloadNode(node, visible);
             *      NodeMap.Remove(link.DhtID);
             *      node.Remove();
             *  }
             *
             *
             *  // if node changes to be sub of another root 3 levels down, whole branch must be reloaded
             *  if (parent == null || parent == PlanStructure.virtualParent)
             *  {
             *      if(Uplinks.Contains(key))
             *          RefreshStructure();
             *
             *      return;
             *  }
             *
             *  // if new parent is hidden, dont bother adding till user expands
             *  PlanNode newParent = parent as PlanNode; // null if root
             *
             *  if (newParent != null && newParent.AddSubs == false)
             *      return;
             *
             *
             *  // copy node to start fresh
             *  PlanNode newNode = CreateNode(node.Link);
             *
             *
             *  // check if parent should be moved to project header
             *  if (newParent != null)
             *  {
             *      Utilities.InsertSubNode(newParent, newNode);
             *
             *      // if we are a visible child, must load hidden sub nodes
             *      if (newParent.IsVisible() && newParent.IsExpanded)
             *          LoadNode(newNode);
             *  }
             *
             *  // if node itself is the root
             *  else
             *  {
             *      LoadNode(newNode);
             *
             *      // remove previous
             *      foreach (PlanNode old in PlanStructure.Nodes)
             *          UnloadNode(old, visible);
             *
             *      PlanStructure.Nodes.Clear();
             *      PlanStructure.Nodes.Add(newNode);
             *  }
             *
             *  node = newNode;
             *
             *
             *  // recurse to each previously visible node
             *  foreach (ulong id in visible)
             *  {
             *      List<ulong> uplinks = Links.GetUplinkIDs(id, ProjectID);
             *
             *      foreach (PlanNode root in PlanStructure.Nodes) // should only be one root
             *          VisiblePath(root, uplinks);
             *  }
             * }
             *
             * node.UpdateName();
             *
             *
             * node.Selected = selected;*/
        }
Ejemplo n.º 21
0
        private void BlockRow_Paint(object sender, PaintEventArgs e)
        {
            if (DisplayBuffer == null)
            {
                DisplayBuffer = new Bitmap(Width, Height);
            }

            if (!Redraw)
            {
                e.Graphics.DrawImage(DisplayBuffer, 0, 0);
                return;
            }
            Redraw = false;

            // background
            Graphics buffer = Graphics.FromImage(DisplayBuffer);

            buffer.Clear(Color.White);
            //buffer.SmoothingMode = SmoothingMode.AntiAlias;


            // draw tick lines
            foreach (int mark in View.ScheduleSlider.SmallMarks)
            {
                buffer.DrawLine(SmallPen, mark, 0, mark, Height);
            }

            foreach (int mark in View.ScheduleSlider.BigMarks)
            {
                buffer.DrawLine(BigPen, mark, 0, mark, Height);
            }

            //buffer.DrawLine(RefPen, View.ScheduleSlider.RefMark, 0, View.ScheduleSlider.RefMark, Height);

            // setup vars
            Rectangle tempRect = new Rectangle();

            tempRect.Y      = 0;
            tempRect.Height = Height;

            StartTime     = View.GetStartTime().ToUniversalTime();
            EndTime       = View.GetEndTime().ToUniversalTime();
            TicksperPixel = View.ScheduleSlider.TicksperPixel;


            // draw higher plans
            BlockAreas.Clear();
            GoalAreas.Clear();


            Uplinks = View.Core.Trust.GetUnconfirmedUplinkIDs(UserID, View.ProjectID);

            // upnodes just used for scope calc now
            List <PlanNode> upnodes  = new List <PlanNode>();
            PlanNode        nextNode = Node;

            while (nextNode.Parent.GetType() == typeof(PlanNode))
            {
                nextNode = (PlanNode)nextNode.Parent;
                upnodes.Add(nextNode);
            }

            upnodes.Reverse();


            // draw plans for each node above in the current block layered on top of one another
            // if we want to change to loop doesnt inherit other loop member's plans, replace foreach uplinks with upnodes
            // not obvious behaviour

            int level = 0;

            //foreach (ulong uplink in Uplinks)
            foreach (PlanNode node in upnodes)
            {
                ulong uplink = node.Link.UserID;

                foreach (PlanBlock block in GetBlocks(uplink))
                {
                    // scope -1 everyone or current level 0 highest + scope is >= than current node
                    if ((block.Scope == -1 || (level + block.Scope >= upnodes.Count)) &&
                        BlockinRange(block, ref tempRect))
                    {
                        buffer.FillRectangle(GetMask(uplink, true), tempRect);
                        BlockAreas.Add(new BlockArea(tempRect, block, level, false));
                    }
                }

                level++;
            }

            // draw local plans
            List <List <DrawBlock> > layers = new List <List <DrawBlock> >();

            // arrange visible blocks
            foreach (PlanBlock block in GetBlocks(UserID))
            {
                if (BlockinRange(block, ref tempRect))
                {
                    AddDrawBlock(new DrawBlock(block, tempRect), layers);
                }
            }

            List <KeyValuePair <string, PointF> > StringList = new List <KeyValuePair <string, PointF> >();

            // draw blocks
            if (layers.Count > 0)
            {
                int y     = 2;
                int yStep = (Height - 2) / layers.Count;

                foreach (List <DrawBlock> list in layers)
                {
                    foreach (DrawBlock item in list)
                    {
                        if (item.Above == null)
                        {
                            item.Rect.Y      = y;
                            item.Rect.Height = yStep - 1;

                            DrawBlock down = item.Below;
                            while (down != null)
                            {
                                item.Rect.Height += yStep;
                                down              = down.Below;
                            }

                            BlockAreas.Add(new BlockArea(item.Rect, item.Block, level, true));

                            Rectangle fill = item.Rect;
                            fill.Height = Height - y;
                            buffer.FillRectangle(GetMask(UserID, true), fill);

                            if (item.Block == View.SelectedBlock)
                            {
                                buffer.DrawRectangle(SelectPen, item.Rect);
                            }

                            SizeF size = buffer.MeasureString(item.Block.Title, Tahoma);

                            if (size.Width < item.Rect.Width - 2 && size.Height < item.Rect.Height - 2)
                            {
                                StringList.Add(new KeyValuePair <string, PointF>(item.Block.Title,
                                                                                 new PointF(item.Rect.X + (item.Rect.Width - size.Width) / 2, item.Rect.Y + (item.Rect.Height - size.Height) / 2)));
                            }
                        }
                    }

                    y += yStep;
                }
            }

            // scan higher's goal lists for assigned goals to this id
            if (View.SelectedGoalID != 0)
            {
                // cache what to draw, look at how goals control get progress status
                // color goal bars solid red / blue / gray
                // cache strings, draw after goals

                //Uplinks.Add(Node.Link.DhtID); // add self to scan
                upnodes.Add(Node);

                foreach (PlanNode node in upnodes)
                {
                    ulong  userID = node.Link.UserID;
                    OpPlan upPlan = View.Plans.GetPlan(userID, true);

                    if (upPlan != null)
                    {
                        if (upPlan.GoalMap.ContainsKey(View.SelectedGoalID))
                        {
                            foreach (PlanGoal goal in upPlan.GoalMap[View.SelectedGoalID])
                            {
                                if (goal.Project == View.ProjectID && goal.Person == UserID)
                                {
                                    if (StartTime < goal.End && goal.End < EndTime)
                                    {
                                        int x = (int)((goal.End.Ticks - StartTime.Ticks) / TicksperPixel);

                                        int completed = 0, total = 0;
                                        View.Plans.GetEstimate(goal, ref completed, ref total);

                                        // draw divider line with little right triangles in top / bottom
                                        buffer.FillRectangle(WhiteBrush, new Rectangle(x - 4, 2, 2, Height - 4));

                                        if (total > 0)
                                        {
                                            int progress = completed * (Height - 4) / total;
                                            buffer.FillRectangle(GreenBrush, new Rectangle(x - 4, 2 + (Height - 4) - progress, 2, progress));
                                        }

                                        buffer.FillPolygon(GetMask(UserID, false), new Point[] {
                                            new Point(x - 6, 2),
                                            new Point(x, 2),
                                            new Point(x, Height - 2),
                                            new Point(x - 6, Height - 2),
                                            new Point(x - 2, Height - 2 - 5),
                                            new Point(x - 2, 2 + 5)
                                        });

                                        GoalAreas.Add(new BlockArea(new Rectangle(x - 6, 2, 6, Height - 4), goal));
                                    }
                                }
                            }
                        }
                    }
                }
            }

            // draw strings
            foreach (KeyValuePair <string, PointF> pair in StringList)
            {
                buffer.DrawString(pair.Key, Tahoma, blackBrush, pair.Value);
            }

            // draw selection
            if (Node.Selected)
            {
                if (View.PlanStructure.Focused)
                {
                    buffer.FillRectangle(Highlight, 0, 0, Width, 2);
                    buffer.FillRectangle(Highlight, 0, Height - 2, Width, 2);
                }

                else
                {
                    buffer.DrawLine(BlackPen, 1, 0, Width - 1, 0);
                    buffer.DrawLine(BlackPen, 0, Height - 1, Width, Height - 1);
                }
            }

            // Copy buffer to display
            e.Graphics.DrawImage(DisplayBuffer, 0, 0);
        }
Ejemplo n.º 22
0
        private void RefreshStructure()
        {
            PlanStructure.BeginUpdate();


            // save selected
            PlanNode selected = GetSelected();

            // save visible while unloading
            List <ulong> visible = new List <ulong>();

            foreach (TreeListNode node in PlanStructure.Nodes)
            {
                if (node.GetType() == typeof(PlanNode))
                {
                    UnloadNode((PlanNode)node, visible);
                }
            }


            NodeMap.Clear();
            PlanStructure.Nodes.Clear();


            // nodes
            ThreadedList <OpLink> roots = null;

            if (Trust.ProjectRoots.SafeTryGetValue(ProjectID, out roots))
            {
                roots.LockReading(delegate()
                {
                    foreach (OpLink root in roots)
                    {
                        if (Uplinks.Contains(root.UserID))
                        {
                            PlanNode node = CreateNode(root);

                            Plans.Research(root.UserID);

                            LoadNode(node);

                            GuiUtils.InsertSubNode(PlanStructure.virtualParent, node);

                            ExpandPath(node, Uplinks);
                        }

                        if (root.IsLoopRoot &&
                            root.Downlinks.Count > 0 &&
                            Uplinks.Contains(root.Downlinks[0].UserID))
                        {
                            foreach (OpLink downlink in root.Downlinks)
                            {
                                if (!root.IsLoopedTo(downlink))
                                {
                                    PlanNode node = CreateNode(downlink);

                                    Plans.Research(downlink.UserID);

                                    LoadNode(node);

                                    GuiUtils.InsertSubNode(PlanStructure.virtualParent, node);

                                    ExpandPath(node, Uplinks);
                                }
                            }
                        }
                    }
                });
            }

            // restore visible
            foreach (ulong id in visible)
            {
                foreach (TreeListNode node in PlanStructure.Nodes)
                {
                    if (node.GetType() == typeof(PlanNode))
                    {
                        List <ulong> uplinks = Trust.GetUnconfirmedUplinkIDs(id, ProjectID);
                        uplinks.Add(id);
                        VisiblePath((PlanNode)node, uplinks);
                    }
                }
            }

            // restore selected
            if (selected != null)
            {
                if (NodeMap.ContainsKey(selected.Link.UserID))
                {
                    PlanStructure.Select(NodeMap[selected.Link.UserID]);
                }
            }


            PlanStructure.EndUpdate();
        }
Ejemplo n.º 23
0
        private void UnloadNode(PlanNode node, List<ulong> visible)
        {
            node.AddSubs = false;

            if (visible != null && node.IsVisible())
                visible.Add(node.Link.UserID);

            // for each child, call unload node, then clear
            foreach (PlanNode child in node.Nodes)
            {
                if (NodeMap.ContainsKey(child.Link.UserID))
                    NodeMap.Remove(child.Link.UserID);

                UnloadNode(child, visible);
            }

            // unloads children of node, not the node itself
            node.Nodes.Clear();
            node.Collapse();
        }