Beispiel #1
0
        private void CalcThreadline(long currentTick)
        {
            // clear thread map so order of items is kept and we dont get threads switching around
            RemoveLines.Clear();
            foreach (var timeline in Threadlines.Values)
            {
                timeline.Sequence.Clear();
                timeline.DepthSet.Clear();

                if (!timeline.IsAlive)
                {
                    RemoveLines.Add(timeline.ThreadID);
                }
            }

            foreach (var id in RemoveLines)
            {
                Threadlines.Remove(id);
            }

            AddedNodes.Clear();

            foreach (var flow in XRay.FlowMap)
            {
                if (ShowThreads != null && !ShowThreads.Contains(flow.ThreadID))
                {
                    continue;
                }

                if (ShowThreads == null && !flow.IsAlive)
                {
                    continue;
                }

                long startTick  = 0;
                int  startDepth = XRay.MaxStack;

                foreach (var item in flow.EnumerateThreadline())
                {
                    if (startTick == 0)
                    {
                        startTick = item.StartTick;
                    }

                    // we should be reading into the past, if the next item is
                    // in the future, then we are reading space that the app as logged
                    // since this process was started (its nice cause we avoid locks on the timeline
                    if (item.StartTick > startTick)
                    {
                        break;
                    }

                    if (AddToTimeline(flow, item))
                    {
                        if (item.Depth < startDepth)
                        {
                            startDepth = item.Depth;
                        }
                    }
                }

                // add stack items that have been pushed off threadline (functions that haven't exited yet)
                for (int i = startDepth - 1; i >= 0; i--)
                {
                    var item = flow.Stack[i];

                    if (item != null)
                    {
                        AddToTimeline(flow, item);
                    }
                }
            }

            // remove empty threads
            var removeTimelines = Threadlines.Values.Where(t => t.Sequence.Count == 0).ToArray();

            foreach (var timeline in removeTimelines)
            {
                Threadlines.Remove(timeline.ThreadID);
            }
        }
        public void Render()
        {
            // clear and pre-process marked depencies
            RecalcDependencies();

            // figure out if we need to do a search
            if (SearchString != LastSearch)
            {
                DoSearch();
            }

            // draw layout
            ScreenSize.Width  = Renderer.ViewWidth * ZoomFactor;
            ScreenSize.Height = Renderer.ViewHeight * ZoomFactor;
            ScreenOffset.X    = PanOffset.X * ScreenSize.Width;  // +(Width * CenterFactor.X - ModelSize.Width * CenterFactor.X);
            ScreenOffset.Y    = PanOffset.Y * ScreenSize.Height; // +(Height * CenterFactor.Y - ModelSize.Height * CenterFactor.Y);

            if (ViewLayout == LayoutType.TreeMap)
            {
                DrawTreeMap(Renderer);

                if (ShowingOutside)
                {
                    Renderer.DrawTextBackground(XColors.BorderColor, InternalRoot.AreaF.Width, 0, PanelBorderWidth, InternalRoot.AreaF.Height);
                    DrawNode(InternalRoot, 0, true);
                }

                if (ShowingExternal)
                {
                    Renderer.DrawTextBackground(XColors.BorderColor, ExternalRoot.AreaF.X - PanelBorderWidth, 0, PanelBorderWidth, ExternalRoot.AreaF.Height);
                    DrawNode(ExternalRoot, 0, true);
                }

                DrawNode(CurrentRoot, 0, true);
            }

            else if (ViewLayout == LayoutType.CallGraph)
            {
                DrawCallGraph();

                // id 0 nodes are intermediates
                foreach (var node in PositionMap.Values)
                {
                    //foreach (var node in Graphs.SelectMany(g => g.Nodes()).Where(n => n.ID != 0))
                    DrawNode(node, 0, false);
                }
            }

            else if (ViewLayout == LayoutType.Timeline)
            {
                DrawTheadline();

                foreach (var node in ThreadlineNodes)
                {
                    DrawNode(node.Node, node.Area, node.LabelArea, 0, false, node.ShowHit);
                }
            }


            // draw ignored over nodes ignored may contain

            /*foreach (var ignored in IgnoredNodes.Values)
             *  if (PositionMap.ContainsKey(ignored.ID))
             *  {
             *      Renderer.DrawLine(XColors.IgnoredColor, 1, ignored.AreaF.UpperLeftCorner(), ignored.AreaF.LowerRightCorner(), false);
             *      Renderer.DrawLine(XColors.IgnoredColor, 1, ignored.AreaF.UpperRightCorner(), ignored.AreaF.LowerLeftCorner(), false);
             *  }*/

            // draw dividers for call graph

            /*if (ViewLayout == LayoutType.CallGraph)
             * {
             *  if (ShowRightOutsideArea)
             *      buffer.DrawLine(CallDividerPen, RightDivider, 0, RightDivider, Height);
             *
             *  if (ShowLeftOutsideArea)
             *      buffer.DrawLine(CallDividerPen, LeftDivider, 0, LeftDivider, Height);
             * }*/


            // draw dependency graph
            if (ViewLayout == LayoutType.CallGraph &&
                (GraphMode == CallGraphMode.Dependencies ||
                 GraphMode == CallGraphMode.Init ||
                 GraphMode == CallGraphMode.Intermediates))
            {
                foreach (var source in PositionMap.Values)
                {
                    if (source.EdgesOut == null)
                    {
                        continue;
                    }

                    foreach (var to in source.EdgesOut)
                    {
                        if (!PositionMap.ContainsKey(to))
                        {
                            continue;
                        }

                        var destination = PositionMap[to];

                        int penWidth = (source.Focused || destination.Focused) ? 2 : 1;

                        if ((!DrawCallGraphVertically && source.AreaF.X < destination.AreaF.X) ||
                            (DrawCallGraphVertically && source.AreaF.Y < destination.AreaF.Y))
                        {
                            DrawGraphEdge(penWidth, XColors.CallOutColor, source, destination);
                        }
                        else
                        {
                            DrawGraphEdge(penWidth, XColors.CallInColor, source, destination);
                        }
                    }
                }
            }


            // draw call graph
            if (XRay.FlowTracking && ViewLayout != LayoutType.Timeline)
            {
                foreach (var source in PositionMap.Values)
                {
                    if (source.XNode.CallsOut == null)
                    {
                        continue;
                    }

                    if (ViewLayout == LayoutType.TreeMap && source.ObjType == XObjType.Class && ShowMethods)
                    {
                        continue;
                    }

                    if (ViewLayout == LayoutType.CallGraph &&
                        GraphMode != CallGraphMode.Init &&
                        source.ObjType == XObjType.Class &&
                        ShowMethods)
                    {
                        continue;
                    }


                    foreach (var call in source.XNode.CallsOut)
                    {
                        if (!PositionMap.ContainsKey(call.Destination))
                        {
                            continue;
                        }

                        if (ShowThreads != null && !call.ThreadIDs.Any(id => ShowThreads.Contains(id)))
                        {
                            continue;
                        }

                        var destination = PositionMap[call.Destination];

                        // if there are items we're filtering on then only show calls to those nodes
                        if (FilteredNodes.Count > 0 && !IsNodeFiltered(true, source) && !IsNodeFiltered(true, destination))
                        {
                            continue;
                        }

                        // do after select filter so we can have ignored nodes inside selected, but not the otherway around
                        if (IgnoredNodes.Count > 0 && IsNodeFiltered(false, source) || IsNodeFiltered(false, destination))
                        {
                            continue;
                        }

                        int lineWidth = (source.Focused || destination.Focused) ? 2 : 1;

                        if (call.StillInside > 0 && ShowCalls)
                        {
                            if (ViewLayout == LayoutType.TreeMap)
                            {
                                Renderer.DrawCallLine(XColors.HoldingCallColor, lineWidth, source.CenterF, destination.CenterF, false, source, destination);
                            }
                            else if (ViewLayout == LayoutType.CallGraph)
                            {
                                DrawGraphEdge(lineWidth, XColors.HoldingCallColor, source, destination);
                            }
                        }

                        else if (ShowAllCalls &&
                                 GraphMode != CallGraphMode.Intermediates &&
                                 GraphMode != CallGraphMode.Init)
                        {
                            if (ViewLayout == LayoutType.TreeMap)
                            {
                                var callSource = PositionMap[call.Source];
                                var callDest   = PositionMap[call.Destination];

                                PointF start = callSource.CenterF;
                                PointF end   = callDest.CenterF;
                                PointF mid   = new PointF(start.X + (end.X - start.X) / 2, start.Y + (end.Y - start.Y) / 2);

                                Renderer.DrawCallLine(XColors.CallOutColor, lineWidth, start, mid, false, callSource, callDest);
                                Renderer.DrawCallLine(XColors.CallInColor, lineWidth, mid, end, false, callSource, callDest);
                            }
                            else if (ViewLayout == LayoutType.CallGraph)
                            {
                                if ((!DrawCallGraphVertically && source.AreaF.X < destination.AreaF.X) ||
                                    (DrawCallGraphVertically && source.AreaF.Y < destination.AreaF.Y))
                                {
                                    DrawGraphEdge(lineWidth, XColors.CallOutColor, source, destination);
                                }
                                else
                                {
                                    DrawGraphEdge(lineWidth, XColors.CallInColor, source, destination);
                                }
                            }
                        }

                        if (call.Hit > 0 && ShowCalls)
                        {
                            var color = XColors.CallPenColors[call.Hit];

                            if (ViewLayout == LayoutType.TreeMap)
                            {
                                Renderer.DrawCallLine(color, lineWidth, source.CenterF, destination.CenterF, true, source, destination);
                            }

                            else if (ViewLayout == LayoutType.CallGraph)
                            {
                                DrawGraphEdge(lineWidth, color, source, destination, true);
                            }
                        }
                    }
                }
            }

            XRay.DashOffset = (XRay.DashOffset == 0) ? 2 : XRay.DashOffset - 1;

            // draw mouse over label
            if (ViewLayout != LayoutType.Timeline)
            {
                DrawFooterLabel();
            }

            DrawToolTip();
        }