Пример #1
0
        private void Draw(TNode node, D2dGraphics g)
        {
            RectangleF             boundRect = node.Bounds;
            D2dEllipse             bounds    = (D2dEllipse)boundRect;
            D2dLinearGradientBrush brush
                = m_theme.FillGradientBrush;

            brush.StartPoint = boundRect.Location;
            brush.EndPoint   = new PointF(boundRect.Right, boundRect.Bottom);
            g.FillEllipse(bounds, brush);
            g.DrawEllipse(bounds, m_theme.OutlineBrush);
            g.DrawText(node.TitleText, m_theme.TextFormat, boundRect, m_theme.TextBrush);
        }
Пример #2
0
        private void DrawPseudostate(TNode state, D2dGraphics g, bool outline)
        {
            RectangleF bounds       = state.Bounds;
            D2dEllipse ellipse      = (D2dEllipse)bounds;
            D2dEllipse innerEllipse = ellipse;

            innerEllipse.RadiusX = 4;
            innerEllipse.RadiusY = 4;
            PointF c = ellipse.Center;

            g.FillEllipse(ellipse, m_theme.FillBrush);

            switch (state.Type)
            {
            case StateType.Start:
                g.FillEllipse(innerEllipse, m_theme.TextBrush);
                break;

            case StateType.Final:
                g.DrawEllipse(ellipse, m_theme.OutlineBrush, 3.0f);
                g.FillEllipse(innerEllipse, m_theme.TextBrush);
                break;

            case StateType.ShallowHistory:
                g.DrawText("H", m_centerText, bounds, m_theme.TextBrush);
                break;

            case StateType.DeepHistory:
                g.DrawText("H*", m_centerText, bounds, m_theme.TextBrush);
                break;

            case StateType.Conditional:
                g.DrawText("C", m_centerText, bounds, m_theme.TextBrush);
                break;
            }

            if (outline && state.Type != StateType.Final)
            {
                g.DrawEllipse(ellipse, m_theme.OutlineBrush);
            }
        }
Пример #3
0
        private void Draw(TNode state, D2dGraphics g, bool outline)
        {
            RectangleF bounds = state.Bounds;

            if (state.Type != StateType.Normal)
            {
                DrawPseudostate(state, g, outline);
            }
            else
            {
                float scaleX     = g.Transform.M11; // assume no rotation.
                float radInPixel = scaleX * CornerRadius;

                IComplexState <TNode, TEdge> complexState = state as IComplexState <TNode, TEdge>;

                StateIndicators indicators = state.Indicators;
                if ((indicators & StateIndicators.Active) != 0)
                {
                    if (radInPixel > MinRadiusInPixel)
                    {
                        D2dEllipse ellipse = new D2dEllipse();
                        ellipse.RadiusX = CornerRadius;
                        ellipse.RadiusY = CornerRadius;
                        ellipse.Center  = bounds.Location;
                        g.FillEllipse(ellipse, Color.SpringGreen);
                    }
                }


                if (radInPixel > MinRadiusInPixel)
                {
                    m_stateRect.Rect = bounds;
                    D2dLinearGradientBrush gradbrush = m_theme.FillGradientBrush;
                    gradbrush.StartPoint = bounds.Location;
                    gradbrush.EndPoint   = new PointF(bounds.Right, bounds.Bottom);

                    g.FillRoundedRectangle(m_stateRect, gradbrush);
                    if (outline)
                    {
                        g.DrawRoundedRectangle(m_stateRect, m_theme.OutlineBrush);
                    }
                }
                else
                {
                    g.FillRectangle(bounds, m_theme.FillBrush);
                    if (outline)
                    {
                        g.DrawRectangle(bounds, m_theme.OutlineBrush);
                    }
                }
                g.DrawLine(bounds.Left, bounds.Top + m_fontHeight + Margin,
                           bounds.Right, bounds.Top + m_fontHeight + Margin, m_theme.OutlineBrush);

                if ((scaleX * m_fontHeight) > MinFontHeightInPixel)
                {
                    g.DrawText(complexState.TitleText, m_theme.TextFormat,
                               new PointF(bounds.X + CornerRadius, bounds.Y + Margin), m_theme.TextBrush);
                }



                //RectangleF textBounds = new RectangleF(
                //    (float)(bounds.Left + 4),
                //    (float)(bounds.Top + m_fontHeight + 2),
                //    (float)(bounds.Width - 5),
                //    (float)(bounds.Height - m_fontHeight - 4));

                //g.DrawString(complexState.Text, m_theme.Font, m_theme.TextBrush, textBounds, s_stateTextFormat);

                //IList<int> partitionWidths = complexState.PartitionSizes;
                //if (partitionWidths.Count > 0)
                //{
                //    // draw AND-state dividers
                //    int lastDivider = bounds.Left;
                //    foreach (int width in partitionWidths)
                //    {
                //        g.DrawLine(
                //            m_dividerPen,
                //            lastDivider, bounds.Y + m_fontHeight + Margin,
                //            lastDivider, bounds.Y + bounds.Height);

                //        lastDivider += width;
                //    }
                //}
            }
        }