//========================================================================
        internal void DirectSetBorderWidth(CssSide side, float w)
        {
            switch (side)
            {
            case CssSide.Left:
            {
                this._actualBorderLeftWidth = w;
            }
            break;

            case CssSide.Top:
            {
                this._actualBorderTopWidth = w;
            }
            break;

            case CssSide.Right:
            {
                this._actualBorderRightWidth = w;
            }
            break;

            case CssSide.Bottom:
            {
                this._actualBorderBottomWidth = w;
            }
            break;
            }
        }
 //========================================================================
 internal void DirectSetBorderWidth(CssSide side, float w)
 {
     switch (side)
     {
         case CssSide.Left:
             {
                 this._actualBorderLeftWidth = w;
             }
             break;
         case CssSide.Top:
             {
                 this._actualBorderTopWidth = w;
             }
             break;
         case CssSide.Right:
             {
                 this._actualBorderRightWidth = w;
             }
             break;
         case CssSide.Bottom:
             {
                 this._actualBorderBottomWidth = w;
             }
             break;
     }
 }
Ejemplo n.º 3
0
        /// <summary>
        /// Set rectangle for inset/outset border as it need diagonal connection to other borders.
        /// </summary>
        /// <param name="border">Desired border</param>
        /// <param name="b">Box which the border corresponds</param>
        /// <param name="r">the rectangle the border is enclosing</param>
        /// <param name="isLineStart">Specifies if the border is for a starting line (no bevel on left)</param>
        /// <param name="isLineEnd">Specifies if the border is for an ending line (no bevel on right)</param>
        /// <returns>Beveled border path, null if there is no rounded corners</returns>
        static void SetInOutsetRectanglePoints(CssSide border, CssBox b, RectangleF r, bool isLineStart, bool isLineEnd,
                                               PointF[] _borderPts)
        {
            PointF Offset(PointF p, float dx, float dy) => new PointF(p.X + dx, p.Y + dy);


            switch (border)
            {
            case CssSide.Top:
                _borderPts[0] = new PointF(r.Left, r.Top);
                _borderPts[1] = new PointF(r.Right, r.Top);
                _borderPts[2] = new PointF(r.Right, r.Top + b.ActualBorderTopWidth);
                _borderPts[3] = new PointF(r.Left, r.Top + b.ActualBorderTopWidth);
                if (isLineEnd)
                {
                    //_borderPts[2].X -= b.ActualBorderRightWidth;
                    _borderPts[2] = Offset(_borderPts[2], -b.ActualBorderRightWidth, 0);
                }

                if (isLineStart)
                {
                    //_borderPts[3].X += b.ActualBorderLeftWidth;
                    _borderPts[3] = Offset(_borderPts[3], b.ActualBorderLeftWidth, 0);
                }

                break;

            case CssSide.Right:
                _borderPts[0] = new PointF(r.Right - b.ActualBorderRightWidth, r.Top + b.ActualBorderTopWidth);
                _borderPts[1] = new PointF(r.Right, r.Top);
                _borderPts[2] = new PointF(r.Right, r.Bottom);
                _borderPts[3] = new PointF(r.Right - b.ActualBorderRightWidth, r.Bottom - b.ActualBorderBottomWidth);
                break;

            case CssSide.Bottom:
                _borderPts[0] = new PointF(r.Left, r.Bottom - b.ActualBorderBottomWidth);
                _borderPts[1] = new PointF(r.Right, r.Bottom - b.ActualBorderBottomWidth);
                _borderPts[2] = new PointF(r.Right, r.Bottom);
                _borderPts[3] = new PointF(r.Left, r.Bottom);
                if (isLineStart)
                {
                    _borderPts[0] = Offset(_borderPts[0], b.ActualBorderLeftWidth, 0);
                    //_borderPts[0].X += b.ActualBorderLeftWidth;
                }
                if (isLineEnd)
                {
                    //_borderPts[1].X -= b.ActualBorderRightWidth;
                    _borderPts[1] = Offset(_borderPts[1], b.ActualBorderRightWidth, 0);
                }
                break;

            case CssSide.Left:
                _borderPts[0] = new PointF(r.Left, r.Top);
                _borderPts[1] = new PointF(r.Left + b.ActualBorderLeftWidth, r.Top + b.ActualBorderTopWidth);
                _borderPts[2] = new PointF(r.Left + b.ActualBorderLeftWidth, r.Bottom - b.ActualBorderBottomWidth);
                _borderPts[3] = new PointF(r.Left, r.Bottom);
                break;
            }
        }
        /// <summary>
        /// Set rectangle for inset/outset border as it need diagonal connection to other borders.
        /// </summary>
        /// <param name="border">Desired border</param>
        /// <param name="b">Box which the border corresponds</param>
        /// <param name="r">the rectangle the border is enclosing</param>
        /// <param name="isLineStart">Specifies if the border is for a starting line (no bevel on left)</param>
        /// <param name="isLineEnd">Specifies if the border is for an ending line (no bevel on right)</param>
        /// <returns>Beveled border path, null if there is no rounded corners</returns>
        static void SetInOutsetRectanglePoints(CssSide border, CssBox b, RectangleF r, bool isLineStart, bool isLineEnd,
                                               PointF[] _borderPts)
        {
            switch (border)
            {
            case CssSide.Top:
                _borderPts[0] = new PointF(r.Left, r.Top);
                _borderPts[1] = new PointF(r.Right, r.Top);
                _borderPts[2] = new PointF(r.Right, r.Top + b.ActualBorderTopWidth);
                _borderPts[3] = new PointF(r.Left, r.Top + b.ActualBorderTopWidth);
                if (isLineEnd)
                {
                    _borderPts[2].X -= b.ActualBorderRightWidth;
                }
                if (isLineStart)
                {
                    _borderPts[3].X += b.ActualBorderLeftWidth;
                }
                break;

            case CssSide.Right:
                _borderPts[0] = new PointF(r.Right - b.ActualBorderRightWidth, r.Top + b.ActualBorderTopWidth);
                _borderPts[1] = new PointF(r.Right, r.Top);
                _borderPts[2] = new PointF(r.Right, r.Bottom);
                _borderPts[3] = new PointF(r.Right - b.ActualBorderRightWidth, r.Bottom - b.ActualBorderBottomWidth);
                break;

            case CssSide.Bottom:
                _borderPts[0] = new PointF(r.Left, r.Bottom - b.ActualBorderBottomWidth);
                _borderPts[1] = new PointF(r.Right, r.Bottom - b.ActualBorderBottomWidth);
                _borderPts[2] = new PointF(r.Right, r.Bottom);
                _borderPts[3] = new PointF(r.Left, r.Bottom);
                if (isLineStart)
                {
                    _borderPts[0].X += b.ActualBorderLeftWidth;
                }
                if (isLineEnd)
                {
                    _borderPts[1].X -= b.ActualBorderRightWidth;
                }
                break;

            case CssSide.Left:
                _borderPts[0] = new PointF(r.Left, r.Top);
                _borderPts[1] = new PointF(r.Left + b.ActualBorderLeftWidth, r.Top + b.ActualBorderTopWidth);
                _borderPts[2] = new PointF(r.Left + b.ActualBorderLeftWidth, r.Bottom - b.ActualBorderBottomWidth);
                _borderPts[3] = new PointF(r.Left, r.Bottom);
                break;
            }
        }
Ejemplo n.º 5
0
        /// <summary>
        /// Gets the value for the given side.
        /// </summary>
        /// <param name="side">The side to use.</param>
        /// <returns>The value of the given side.</returns>
        public CSSPrimitiveValue GetSide(CssSide side)
        {
            switch (side)
            {
                case CssSide.Top:
                    return top;
                case CssSide.Right:
                    return right;
                case CssSide.Bottom:
                    return bottom;
                case CssSide.Left:
                    return left;
            }

            throw new ArgumentOutOfRangeException("Invalid value for side.");
        }
Ejemplo n.º 6
0
        static void GetBorderBorderDrawingInfo(CssBox box,
                                               CssSide borderSide,
                                               out CssBorderStyle borderStyle,
                                               out Color borderColor,
                                               out float actualBorderWidth)
        {
            switch (borderSide)
            {
            case CssSide.Top:

                actualBorderWidth = box.ActualBorderTopWidth;
                borderStyle       = box.BorderTopStyle;
                borderColor       = (borderStyle == CssBorderStyle.Inset) ?
                                    Darken(box.BorderTopColor) :
                                    box.BorderTopColor;
                break;

            case CssSide.Left:
                actualBorderWidth = box.ActualBorderLeftWidth;
                borderStyle       = box.BorderLeftStyle;
                borderColor       = (borderStyle == CssBorderStyle.Inset) ?
                                    Darken(box.BorderLeftColor) :
                                    box.BorderLeftColor;
                break;

            case CssSide.Right:
                actualBorderWidth = box.ActualBorderRightWidth;
                borderStyle       = box.BorderRightStyle;
                borderColor       = (borderStyle == CssBorderStyle.Outset) ?
                                    Darken(box.BorderRightColor) :
                                    box.BorderRightColor;

                break;

            case CssSide.Bottom:
                actualBorderWidth = box.ActualBorderBottomWidth;
                borderStyle       = box.BorderBottomStyle;
                borderColor       = (borderStyle == CssBorderStyle.Outset) ?
                                    Darken(box.BorderBottomColor) :
                                    box.BorderBottomColor;
                break;

            default:
                throw new ArgumentOutOfRangeException("border");
            }
        }
Ejemplo n.º 7
0
        static void GetBorderBorderDrawingInfo(CssBox box,
            CssSide borderSide,
            out CssBorderStyle borderStyle,
            out Color borderColor,
            out float actualBorderWidth)
        {
            switch (borderSide)
            {
                case CssSide.Top:

                    actualBorderWidth = box.ActualBorderTopWidth;
                    borderStyle = box.BorderTopStyle;
                    borderColor = (borderStyle == CssBorderStyle.Inset) ?
                                    Darken(box.BorderTopColor) :
                                    box.BorderTopColor;
                    break;
                case CssSide.Left:
                    actualBorderWidth = box.ActualBorderLeftWidth;
                    borderStyle = box.BorderLeftStyle;
                    borderColor = (borderStyle == CssBorderStyle.Inset) ?
                                    Darken(box.BorderLeftColor) :
                                    box.BorderLeftColor;
                    break;
                case CssSide.Right:
                    actualBorderWidth = box.ActualBorderRightWidth;
                    borderStyle = box.BorderRightStyle;
                    borderColor = (borderStyle == CssBorderStyle.Outset) ?
                                    Darken(box.BorderRightColor) :
                                    box.BorderRightColor;
                    break;
                case CssSide.Bottom:
                    actualBorderWidth = box.ActualBorderBottomWidth;
                    borderStyle = box.BorderBottomStyle;
                    borderColor = (borderStyle == CssBorderStyle.Outset) ?
                                    Darken(box.BorderBottomColor) :
                                    box.BorderBottomColor;
                    break;
                default:
                    throw new ArgumentOutOfRangeException("border");
            }
        }
        /// <summary>
        /// Draw specific border (top/bottom/left/right) with the box data (style/width/rounded).<br/>
        /// </summary>
        /// <param name="borderSide">desired border to draw</param>
        /// <param name="box">the box to draw its borders, contain the borders data</param>
        /// <param name="g">the device to draw into</param>
        /// <param name="rect">the rectangle the border is enclosing</param>
        /// <param name="isLineStart">Specifies if the border is for a starting line (no bevel on left)</param>
        /// <param name="isLineEnd">Specifies if the border is for an ending line (no bevel on right)</param>
        static void DrawBorder(CssSide borderSide, CssBox box,
                               PaintVisitor p, RectangleF rect, bool isLineStart, bool isLineEnd)
        {
            float          actualBorderWidth;
            Color          borderColor;
            CssBorderStyle style;

            GetBorderBorderDrawingInfo(box, borderSide, out style, out borderColor, out actualBorderWidth);
            DrawBoard g = p.InnerDrawBoard;

            if (box.HasSomeRoundCorner)
            {
                GraphicsPath borderPath = GetRoundedBorderPath(p, borderSide, box, rect);
                if (borderPath != null)
                {
                    // rounded border need special path
                    var smooth = g.SmoothingMode;
                    if (!p.AvoidGeometryAntialias && box.HasSomeRoundCorner)
                    {
                        g.SmoothingMode = SmoothingMode.AntiAlias;
                    }


                    p.DrawPath(borderPath, borderColor, actualBorderWidth);
                    //using (var pen = GetPen(p.Platform, style, borderColor, actualBorderWidth))
                    //using (borderPath)
                    //{
                    //    g.DrawPath(pen, borderPath);
                    //}
                    g.SmoothingMode = smooth;
                }
            }
            else
            {
                // non rounded border
                switch (style)
                {
                case CssBorderStyle.Inset:
                case CssBorderStyle.Outset:
                {
                    // inset/outset border needs special rectangle
                    PointF[] borderPnts = new PointF[4];
                    SetInOutsetRectanglePoints(borderSide, box, rect, isLineStart, isLineEnd, borderPnts);
                    g.FillPolygon(borderColor, borderPnts);
                }
                break;

                default:
                {
                    // solid/dotted/dashed border draw as simple line


                    //using (var pen = GetPen(p.Platform, style, borderColor, actualBorderWidth))
                    //{
                    var prevColor = g.StrokeColor;
                    g.StrokeColor = borderColor;
                    float prevStrokeW = g.StrokeWidth;
                    g.StrokeWidth = actualBorderWidth;


                    //s_simpleRectBorderBuilder.SetBorderWidth(
                    //     box.ActualBorderLeftWidth,
                    //     box.ActualBorderTopWidth,
                    //     box.ActualBorderRightWidth,
                    //     box.ActualBorderBottomWidth
                    //    );


                    //s_simpleRectBorderBuilder.BuildOverRefBounds(
                    //    rect.Left,
                    //    rect.Top,
                    //    rect.Width,
                    //    rect.Height,
                    //    s_reusableBorderCoords);

                    switch (borderSide)
                    {
                    case CssSide.Top:
                        g.DrawLine((float)Math.Ceiling(rect.Left), rect.Top + box.ActualBorderTopWidth / 2, rect.Right - 1, rect.Top + box.ActualBorderTopWidth / 2);
                        break;

                    case CssSide.Left:
                        g.DrawLine(rect.Left + box.ActualBorderLeftWidth / 2, (float)Math.Ceiling(rect.Top), rect.Left + box.ActualBorderLeftWidth / 2, (float)Math.Floor(rect.Bottom));
                        break;

                    case CssSide.Bottom:
                        g.DrawLine((float)Math.Ceiling(rect.Left), rect.Bottom - box.ActualBorderBottomWidth / 2, rect.Right - 1, rect.Bottom - box.ActualBorderBottomWidth / 2);
                        break;

                    case CssSide.Right:
                        g.DrawLine(rect.Right - box.ActualBorderRightWidth / 2, (float)Math.Ceiling(rect.Top), rect.Right - box.ActualBorderRightWidth / 2, (float)Math.Floor(rect.Bottom));
                        break;
                    }

                    g.StrokeWidth = prevStrokeW;
                    g.StrokeColor = prevColor;
                }
                break;
                }
            }
        }
Ejemplo n.º 9
0
 internal void PaintBorder(CssBox box, CssSide border, Color solidColor, RectangleF rect)
 {
     PointF[] borderPoints = new PointF[4];
     BorderPaintHelper.DrawBorder(solidColor, border, borderPoints, this.canvas, box, rect);
 }
Ejemplo n.º 10
0
 /// <summary>
 /// Draw simple border.
 /// </summary>
 /// <param name="border">Desired border</param>
 /// <param name="g">the device to draw to</param>
 /// <param name="box">Box which the border corresponds</param>
 /// <param name="brush">the brush to use</param>
 /// <param name="rectangle">the bounding rectangle to draw in</param>
 /// <returns>Beveled border path, null if there is no rounded corners</returns>
 public static void DrawBorder(Color color, CssSide border, PointF[] borderPts, Canvas g,
                               CssBox box, RectangleF rectangle)
 {
     SetInOutsetRectanglePoints(border, box, rectangle, true, true, borderPts);
     g.FillPolygon(color, borderPts);
 }
Ejemplo n.º 11
0
 /// <summary>
 /// Sets the value for the given side.
 /// </summary>
 /// <param name="side">The side to change.</param>
 /// <param name="value">The value to apply.</param>
 public void SetSide(CssSide side, CSSPrimitiveValue value)
 {
     switch (side)
     {
         case CssSide.Top:
             Top = value;
             break;
         case CssSide.Right:
             Right = value;
             break;
         case CssSide.Bottom:
             Bottom = value;
             break;
         case CssSide.Left:
             Left = value;
             break;
     }
 }
Ejemplo n.º 12
0
        /// <summary>
        /// Draw specific border (top/bottom/left/right) with the box data (style/width/rounded).<br/>
        /// </summary>
        /// <param name="borderSide">desired border to draw</param>
        /// <param name="box">the box to draw its borders, contain the borders data</param>
        /// <param name="g">the device to draw into</param>
        /// <param name="rect">the rectangle the border is enclosing</param>
        /// <param name="isLineStart">Specifies if the border is for a starting line (no bevel on left)</param>
        /// <param name="isLineEnd">Specifies if the border is for an ending line (no bevel on right)</param>
        static void DrawBorder(CssSide borderSide, CssBox box,
            PaintVisitor p, RectangleF rect, bool isLineStart, bool isLineEnd)
        {
            float actualBorderWidth;
            Color borderColor;
            CssBorderStyle style;
            GetBorderBorderDrawingInfo(box, borderSide, out style, out borderColor, out actualBorderWidth);
            Canvas g = p.InnerCanvas;
            if (box.HasSomeRoundCorner)
            {
                GraphicsPath borderPath = GetRoundedBorderPath(p, borderSide, box, rect);
                if (borderPath != null)
                {
                    // rounded border need special path 
                    var smooth = g.SmoothingMode;
                    if (!p.AvoidGeometryAntialias && box.HasSomeRoundCorner)
                    {
                        g.SmoothingMode = SmoothingMode.AntiAlias;
                    }


                    p.DrawPath(borderPath, borderColor, actualBorderWidth);
                    //using (var pen = GetPen(p.Platform, style, borderColor, actualBorderWidth))
                    //using (borderPath)
                    //{
                    //    g.DrawPath(pen, borderPath);
                    //}
                    g.SmoothingMode = smooth;
                }
            }
            else
            {
                // non rounded border 
                switch (style)
                {
                    case CssBorderStyle.Inset:
                    case CssBorderStyle.Outset:
                        {
                            // inset/outset border needs special rectangle
                            PointF[] borderPnts = new PointF[4];
                            SetInOutsetRectanglePoints(borderSide, box, rect, isLineStart, isLineEnd, borderPnts);
                            g.FillPolygon(borderColor, borderPnts);
                        }
                        break;
                    default:
                        {
                            // solid/dotted/dashed border draw as simple line


                            //using (var pen = GetPen(p.Platform, style, borderColor, actualBorderWidth))
                            //{
                            var prevColor = g.StrokeColor;
                            g.StrokeColor = borderColor;
                            float prevStrokeW = g.StrokeWidth;
                            g.StrokeWidth = actualBorderWidth;
                            switch (borderSide)
                            {
                                case CssSide.Top:
                                    g.DrawLine((float)Math.Ceiling(rect.Left), rect.Top + box.ActualBorderTopWidth / 2, rect.Right - 1, rect.Top + box.ActualBorderTopWidth / 2);
                                    break;
                                case CssSide.Left:
                                    g.DrawLine(rect.Left + box.ActualBorderLeftWidth / 2, (float)Math.Ceiling(rect.Top), rect.Left + box.ActualBorderLeftWidth / 2, (float)Math.Floor(rect.Bottom));
                                    break;
                                case CssSide.Bottom:
                                    g.DrawLine((float)Math.Ceiling(rect.Left), rect.Bottom - box.ActualBorderBottomWidth / 2, rect.Right - 1, rect.Bottom - box.ActualBorderBottomWidth / 2);
                                    break;
                                case CssSide.Right:
                                    g.DrawLine(rect.Right - box.ActualBorderRightWidth / 2, (float)Math.Ceiling(rect.Top), rect.Right - box.ActualBorderRightWidth / 2, (float)Math.Floor(rect.Bottom));
                                    break;
                            }

                            g.StrokeWidth = prevStrokeW;
                            g.StrokeColor = prevColor;
                        }
                        break;
                }
            }
        }
Ejemplo n.º 13
0
 internal void PaintBorder(CssBox box, CssSide border, Color solidColor, RectangleF rect)
 {
     BorderPaintHelper.DrawBorder(solidColor, border, _borderPoints, _drawBoard, box, rect);
 }
Ejemplo n.º 14
0
        /// <summary>
        /// Draw specific border (top/bottom/left/right) with the box data (style/width/rounded).<br/>
        /// </summary>
        /// <param name="borderSide">desired border to draw</param>
        /// <param name="box">the box to draw its borders, contain the borders data</param>
        /// <param name="g">the device to draw into</param>
        /// <param name="rect">the rectangle the border is enclosing</param>
        /// <param name="isLineStart">Specifies if the border is for a starting line (no bevel on left)</param>
        /// <param name="isLineEnd">Specifies if the border is for an ending line (no bevel on right)</param>
        static void DrawBorder(CssSide borderSide, CssBox box,
                               PaintVisitor p, RectangleF rect, bool isLineStart, bool isLineEnd)
        {
            GetBorderBorderDrawingInfo(box, borderSide, out CssBorderStyle style, out Color borderColor, out float actualBorderWidth);
            DrawBoard g = p.InnerDrawBoard;

            if (box.HasSomeRoundCorner)
            {
                using (Tools.BorrowVxs(out var v1))
                {
                    RenderUtils.WriteRoundRect(v1, rect, 2, 2, 2, 2);//temp
                    Painter pp = g.GetPainter();
                    pp.FillStroke(v1, actualBorderWidth, borderColor);
                }
            }
            else
            {
                // non rounded border
                switch (style)
                {
                case CssBorderStyle.Inset:
                case CssBorderStyle.Outset:
                {
                    // inset/outset border needs special rectangle
                    PointF[] borderPnts = new PointF[4];
                    SetInOutsetRectanglePoints(borderSide, box, rect, isLineStart, isLineEnd, borderPnts);
                    g.FillPolygon(borderColor, borderPnts);
                }
                break;

                default:
                {
                    // solid/dotted/dashed border draw as simple line
                    //using (var pen = GetPen(p.Platform, style, borderColor, actualBorderWidth))
                    //{
                    var prevColor = g.StrokeColor;
                    g.StrokeColor = borderColor;
                    float prevStrokeW = g.StrokeWidth;
                    g.StrokeWidth = actualBorderWidth;


                    //s_simpleRectBorderBuilder.SetBorderWidth(
                    //     box.ActualBorderLeftWidth,
                    //     box.ActualBorderTopWidth,
                    //     box.ActualBorderRightWidth,
                    //     box.ActualBorderBottomWidth
                    //    );


                    //s_simpleRectBorderBuilder.BuildOverRefBounds(
                    //    rect.Left,
                    //    rect.Top,
                    //    rect.Width,
                    //    rect.Height,
                    //    s_reusableBorderCoords);

                    switch (borderSide)
                    {
                    case CssSide.Top:
                        g.DrawLine((float)Math.Ceiling(rect.Left), rect.Top + box.ActualBorderTopWidth / 2, rect.Right - 1, rect.Top + box.ActualBorderTopWidth / 2);
                        break;

                    case CssSide.Left:
                        g.DrawLine(rect.Left + box.ActualBorderLeftWidth / 2, (float)Math.Ceiling(rect.Top), rect.Left + box.ActualBorderLeftWidth / 2, (float)Math.Floor(rect.Bottom));
                        break;

                    case CssSide.Bottom:
                        g.DrawLine((float)Math.Ceiling(rect.Left), rect.Bottom - box.ActualBorderBottomWidth / 2, rect.Right - 1, rect.Bottom - box.ActualBorderBottomWidth / 2);
                        break;

                    case CssSide.Right:
                        g.DrawLine(rect.Right - box.ActualBorderRightWidth / 2, (float)Math.Ceiling(rect.Top), rect.Right - box.ActualBorderRightWidth / 2, (float)Math.Floor(rect.Bottom));
                        break;
                    }

                    g.StrokeWidth = prevStrokeW;
                    g.StrokeColor = prevColor;
                }
                break;
                }
            }
        }
Ejemplo n.º 15
0
 /// <summary>
 /// Set rectangle for inset/outset border as it need diagonal connection to other borders.
 /// </summary>
 /// <param name="border">Desired border</param>
 /// <param name="b">Box which the border corresponds</param>
 /// <param name="r">the rectangle the border is enclosing</param>
 /// <param name="isLineStart">Specifies if the border is for a starting line (no bevel on left)</param>
 /// <param name="isLineEnd">Specifies if the border is for an ending line (no bevel on right)</param>
 /// <returns>Beveled border path, null if there is no rounded corners</returns>
 static void SetInOutsetRectanglePoints(CssSide border, CssBox b, RectangleF r, bool isLineStart, bool isLineEnd,
     PointF[] _borderPts)
 {
     switch (border)
     {
         case CssSide.Top:
             _borderPts[0] = new PointF(r.Left, r.Top);
             _borderPts[1] = new PointF(r.Right, r.Top);
             _borderPts[2] = new PointF(r.Right, r.Top + b.ActualBorderTopWidth);
             _borderPts[3] = new PointF(r.Left, r.Top + b.ActualBorderTopWidth);
             if (isLineEnd)
                 _borderPts[2].X -= b.ActualBorderRightWidth;
             if (isLineStart)
                 _borderPts[3].X += b.ActualBorderLeftWidth;
             break;
         case CssSide.Right:
             _borderPts[0] = new PointF(r.Right - b.ActualBorderRightWidth, r.Top + b.ActualBorderTopWidth);
             _borderPts[1] = new PointF(r.Right, r.Top);
             _borderPts[2] = new PointF(r.Right, r.Bottom);
             _borderPts[3] = new PointF(r.Right - b.ActualBorderRightWidth, r.Bottom - b.ActualBorderBottomWidth);
             break;
         case CssSide.Bottom:
             _borderPts[0] = new PointF(r.Left, r.Bottom - b.ActualBorderBottomWidth);
             _borderPts[1] = new PointF(r.Right, r.Bottom - b.ActualBorderBottomWidth);
             _borderPts[2] = new PointF(r.Right, r.Bottom);
             _borderPts[3] = new PointF(r.Left, r.Bottom);
             if (isLineStart)
                 _borderPts[0].X += b.ActualBorderLeftWidth;
             if (isLineEnd)
                 _borderPts[1].X -= b.ActualBorderRightWidth;
             break;
         case CssSide.Left:
             _borderPts[0] = new PointF(r.Left, r.Top);
             _borderPts[1] = new PointF(r.Left + b.ActualBorderLeftWidth, r.Top + b.ActualBorderTopWidth);
             _borderPts[2] = new PointF(r.Left + b.ActualBorderLeftWidth, r.Bottom - b.ActualBorderBottomWidth);
             _borderPts[3] = new PointF(r.Left, r.Bottom);
             break;
     }
 }
Ejemplo n.º 16
0
        /// <summary>
        /// Makes a border path for rounded borders.<br/>
        /// To support rounded dotted/dashed borders we need to use arc in the border path.<br/>
        /// Return null if the border is not rounded.<br/>
        /// </summary>
        /// <param name="border">Desired border</param>
        /// <param name="b">Box which the border corresponds</param>
        /// <param name="r">the rectangle the border is enclosing</param>
        /// <returns>Beveled border path, null if there is no rounded corners</returns>
        static GraphicsPath GetRoundedBorderPath(PaintVisitor p, CssSide border, CssBox b, RectangleF r)
        {
            GraphicsPath path = null;

            switch (border)
            {
            case CssSide.Top:
                if (b.ActualCornerNW > 0 || b.ActualCornerNE > 0)
                {
                    path = new GraphicsPath();
                    if (b.ActualCornerNW > 0)
                    {
                        path.AddArc(r.Left + b.ActualBorderLeftWidth / 2, r.Top + b.ActualBorderTopWidth / 2, b.ActualCornerNW * 2, b.ActualCornerNW * 2, 180f, 90f);
                    }
                    else
                    {
                        path.AddLine(r.Left + b.ActualBorderLeftWidth / 2, r.Top + b.ActualBorderTopWidth / 2, r.Left + b.ActualBorderLeftWidth, r.Top + b.ActualBorderTopWidth / 2);
                    }
                    if (b.ActualCornerNE > 0)
                    {
                        path.AddArc(r.Right - b.ActualCornerNE * 2 - b.ActualBorderRightWidth / 2, r.Top + b.ActualBorderTopWidth / 2, b.ActualCornerNE * 2, b.ActualCornerNE * 2, 270f, 90f);
                    }
                    else
                    {
                        path.AddLine(r.Right - b.ActualCornerNE * 2 - b.ActualBorderRightWidth, r.Top + b.ActualBorderTopWidth / 2, r.Right - b.ActualBorderRightWidth / 2, r.Top + b.ActualBorderTopWidth / 2);
                    }
                }
                break;

            case CssSide.Bottom:
                if (b.ActualCornerSW > 0 || b.ActualCornerSE > 0)
                {
                    path = new GraphicsPath();
                    if (b.ActualCornerSE > 0)
                    {
                        path.AddArc(r.Right - b.ActualCornerNE * 2 - b.ActualBorderRightWidth / 2, r.Bottom - b.ActualCornerSE * 2 - b.ActualBorderBottomWidth / 2, b.ActualCornerSE * 2, b.ActualCornerSE * 2, 0f, 90f);
                    }
                    else
                    {
                        path.AddLine(r.Right - b.ActualBorderRightWidth / 2, r.Bottom - b.ActualBorderBottomWidth / 2, r.Right - b.ActualBorderRightWidth / 2, r.Bottom - b.ActualBorderBottomWidth / 2 - .1f);
                    }
                    if (b.ActualCornerSW > 0)
                    {
                        path.AddArc(r.Left + b.ActualBorderLeftWidth / 2, r.Bottom - b.ActualCornerSW * 2 - b.ActualBorderBottomWidth / 2, b.ActualCornerSW * 2, b.ActualCornerSW * 2, 90f, 90f);
                    }
                    else
                    {
                        path.AddLine(r.Left + b.ActualBorderLeftWidth / 2 + .1f, r.Bottom - b.ActualBorderBottomWidth / 2, r.Left + b.ActualBorderLeftWidth / 2, r.Bottom - b.ActualBorderBottomWidth / 2);
                    }
                }
                break;

            case CssSide.Right:
                if (b.ActualCornerNE > 0 || b.ActualCornerSE > 0)
                {
                    path = new GraphicsPath();
                    if (b.ActualCornerNE > 0 && b.BorderTopStyle >= CssBorderStyle.Visible)
                    {
                        path.AddArc(r.Right - b.ActualCornerNE * 2 - b.ActualBorderRightWidth / 2, r.Top + b.ActualBorderTopWidth / 2, b.ActualCornerNE * 2, b.ActualCornerNE * 2, 270f, 90f);
                    }
                    else
                    {
                        path.AddLine(r.Right - b.ActualBorderRightWidth / 2, r.Top + b.ActualCornerNE + b.ActualBorderTopWidth / 2, r.Right - b.ActualBorderRightWidth / 2, r.Top + b.ActualCornerNE + b.ActualBorderTopWidth / 2 + .1f);
                    }

                    if (b.ActualCornerSE > 0 &&
                        b.BorderBottomStyle >= CssBorderStyle.Visible)
                    {
                        path.AddArc(r.Right - b.ActualCornerSE * 2 - b.ActualBorderRightWidth / 2, r.Bottom - b.ActualCornerSE * 2 - b.ActualBorderBottomWidth / 2, b.ActualCornerSE * 2, b.ActualCornerSE * 2, 0f, 90f);
                    }
                    else
                    {
                        path.AddLine(r.Right - b.ActualBorderRightWidth / 2, r.Bottom - b.ActualCornerSE - b.ActualBorderBottomWidth / 2 - .1f, r.Right - b.ActualBorderRightWidth / 2, r.Bottom - b.ActualCornerSE - b.ActualBorderBottomWidth / 2);
                    }
                }
                break;

            case CssSide.Left:
                if (b.ActualCornerNW > 0 || b.ActualCornerSW > 0)
                {
                    path = new GraphicsPath();
                    if (b.ActualCornerSW > 0 && b.BorderTopStyle >= CssBorderStyle.Visible)    //(b.BorderTopStyle == CssConstants.None || b.BorderTopStyle == CssConstants.Hidden))
                    {
                        path.AddArc(r.Left + b.ActualBorderLeftWidth / 2, r.Bottom - b.ActualCornerSW * 2 - b.ActualBorderBottomWidth / 2, b.ActualCornerSW * 2, b.ActualCornerSW * 2, 90f, 90f);
                    }
                    else
                    {
                        path.AddLine(r.Left + b.ActualBorderLeftWidth / 2, r.Bottom - b.ActualCornerSW - b.ActualBorderBottomWidth / 2, r.Left + b.ActualBorderLeftWidth / 2, r.Bottom - b.ActualCornerSW - b.ActualBorderBottomWidth / 2 - .1f);
                    }

                    if (b.ActualCornerNW > 0 &&
                        b.BorderBottomStyle >= CssBorderStyle.Visible)
                    {
                        path.AddArc(r.Left + b.ActualBorderLeftWidth / 2, r.Top + b.ActualBorderTopWidth / 2, b.ActualCornerNW * 2, b.ActualCornerNW * 2, 180f, 90f);
                    }
                    else
                    {
                        path.AddLine(r.Left + b.ActualBorderLeftWidth / 2, r.Top + b.ActualCornerNW + b.ActualBorderTopWidth / 2 + .1f, r.Left + b.ActualBorderLeftWidth / 2, r.Top + b.ActualCornerNW + b.ActualBorderTopWidth / 2);
                    }
                }
                break;
            }

            return(path);
        }
Ejemplo n.º 17
0
 public static void DrawBorder(CssSide border, PointF[] borderPts, Canvas g, CssBox box, Color solidColor, RectangleF rectangle)
 {
     SetInOutsetRectanglePoints(border, box, rectangle, true, true, borderPts);
     g.FillPolygon(solidColor, borderPts);
 }
Ejemplo n.º 18
0
        /// <summary>
        /// Makes a border path for rounded borders.<br/>
        /// To support rounded dotted/dashed borders we need to use arc in the border path.<br/>
        /// Return null if the border is not rounded.<br/>
        /// </summary>
        /// <param name="border">Desired border</param>
        /// <param name="b">Box which the border corresponds</param>
        /// <param name="r">the rectangle the border is enclosing</param>
        /// <returns>Beveled border path, null if there is no rounded corners</returns>
        static GraphicsPath GetRoundedBorderPath(PaintVisitor p, CssSide border, CssBox b, RectangleF r)
        {
            GraphicsPath path = null;
            switch (border)
            {
                case CssSide.Top:
                    if (b.ActualCornerNW > 0 || b.ActualCornerNE > 0)
                    {

                        path = new GraphicsPath(); 
                        if (b.ActualCornerNW > 0)
                            path.AddArc(r.Left + b.ActualBorderLeftWidth / 2, r.Top + b.ActualBorderTopWidth / 2, b.ActualCornerNW * 2, b.ActualCornerNW * 2, 180f, 90f);
                        else
                            path.AddLine(r.Left + b.ActualBorderLeftWidth / 2, r.Top + b.ActualBorderTopWidth / 2, r.Left + b.ActualBorderLeftWidth, r.Top + b.ActualBorderTopWidth / 2);
                        if (b.ActualCornerNE > 0)
                            path.AddArc(r.Right - b.ActualCornerNE * 2 - b.ActualBorderRightWidth / 2, r.Top + b.ActualBorderTopWidth / 2, b.ActualCornerNE * 2, b.ActualCornerNE * 2, 270f, 90f);
                        else
                            path.AddLine(r.Right - b.ActualCornerNE * 2 - b.ActualBorderRightWidth, r.Top + b.ActualBorderTopWidth / 2, r.Right - b.ActualBorderRightWidth / 2, r.Top + b.ActualBorderTopWidth / 2);
                    }
                    break;
                case CssSide.Bottom:
                    if (b.ActualCornerSW > 0 || b.ActualCornerSE > 0)
                    {
                        path = new GraphicsPath(); 
                        if (b.ActualCornerSE > 0)
                            path.AddArc(r.Right - b.ActualCornerNE * 2 - b.ActualBorderRightWidth / 2, r.Bottom - b.ActualCornerSE * 2 - b.ActualBorderBottomWidth / 2, b.ActualCornerSE * 2, b.ActualCornerSE * 2, 0f, 90f);
                        else
                            path.AddLine(r.Right - b.ActualBorderRightWidth / 2, r.Bottom - b.ActualBorderBottomWidth / 2, r.Right - b.ActualBorderRightWidth / 2, r.Bottom - b.ActualBorderBottomWidth / 2 - .1f);
                        if (b.ActualCornerSW > 0)
                            path.AddArc(r.Left + b.ActualBorderLeftWidth / 2, r.Bottom - b.ActualCornerSW * 2 - b.ActualBorderBottomWidth / 2, b.ActualCornerSW * 2, b.ActualCornerSW * 2, 90f, 90f);
                        else
                            path.AddLine(r.Left + b.ActualBorderLeftWidth / 2 + .1f, r.Bottom - b.ActualBorderBottomWidth / 2, r.Left + b.ActualBorderLeftWidth / 2, r.Bottom - b.ActualBorderBottomWidth / 2);
                    }
                    break;
                case CssSide.Right:
                    if (b.ActualCornerNE > 0 || b.ActualCornerSE > 0)
                    {
                        path = new GraphicsPath(); 
                        if (b.ActualCornerNE > 0 && b.BorderTopStyle >= CssBorderStyle.Visible)
                        {
                            path.AddArc(r.Right - b.ActualCornerNE * 2 - b.ActualBorderRightWidth / 2, r.Top + b.ActualBorderTopWidth / 2, b.ActualCornerNE * 2, b.ActualCornerNE * 2, 270f, 90f);
                        }
                        else
                        {
                            path.AddLine(r.Right - b.ActualBorderRightWidth / 2, r.Top + b.ActualCornerNE + b.ActualBorderTopWidth / 2, r.Right - b.ActualBorderRightWidth / 2, r.Top + b.ActualCornerNE + b.ActualBorderTopWidth / 2 + .1f);
                        }

                        if (b.ActualCornerSE > 0 &&
                            b.BorderBottomStyle >= CssBorderStyle.Visible)
                        {
                            path.AddArc(r.Right - b.ActualCornerSE * 2 - b.ActualBorderRightWidth / 2, r.Bottom - b.ActualCornerSE * 2 - b.ActualBorderBottomWidth / 2, b.ActualCornerSE * 2, b.ActualCornerSE * 2, 0f, 90f);
                        }
                        else
                        {
                            path.AddLine(r.Right - b.ActualBorderRightWidth / 2, r.Bottom - b.ActualCornerSE - b.ActualBorderBottomWidth / 2 - .1f, r.Right - b.ActualBorderRightWidth / 2, r.Bottom - b.ActualCornerSE - b.ActualBorderBottomWidth / 2);
                        }
                    }
                    break;
                case CssSide.Left:
                    if (b.ActualCornerNW > 0 || b.ActualCornerSW > 0)
                    {
                        path = new GraphicsPath(); 
                        if (b.ActualCornerSW > 0 && b.BorderTopStyle >= CssBorderStyle.Visible)//(b.BorderTopStyle == CssConstants.None || b.BorderTopStyle == CssConstants.Hidden))
                        {
                            path.AddArc(r.Left + b.ActualBorderLeftWidth / 2, r.Bottom - b.ActualCornerSW * 2 - b.ActualBorderBottomWidth / 2, b.ActualCornerSW * 2, b.ActualCornerSW * 2, 90f, 90f);
                        }
                        else
                        {
                            path.AddLine(r.Left + b.ActualBorderLeftWidth / 2, r.Bottom - b.ActualCornerSW - b.ActualBorderBottomWidth / 2, r.Left + b.ActualBorderLeftWidth / 2, r.Bottom - b.ActualCornerSW - b.ActualBorderBottomWidth / 2 - .1f);
                        }

                        if (b.ActualCornerNW > 0 &&
                            b.BorderBottomStyle >= CssBorderStyle.Visible)
                        {
                            path.AddArc(r.Left + b.ActualBorderLeftWidth / 2, r.Top + b.ActualBorderTopWidth / 2, b.ActualCornerNW * 2, b.ActualCornerNW * 2, 180f, 90f);
                        }
                        else
                        {
                            path.AddLine(r.Left + b.ActualBorderLeftWidth / 2, r.Top + b.ActualCornerNW + b.ActualBorderTopWidth / 2 + .1f, r.Left + b.ActualBorderLeftWidth / 2, r.Top + b.ActualCornerNW + b.ActualBorderTopWidth / 2);
                        }
                    }
                    break;
            }

            return path;
        }
Ejemplo n.º 19
0
 public static void DrawBorder(CssSide border, PointF[] borderPts, DrawBoard g, CssBox box, Color solidColor, RectangleF rectangle)
 {
     SetInOutsetRectanglePoints(border, box, rectangle, true, true, borderPts);
     g.FillPolygon(solidColor, borderPts);
 }
Ejemplo n.º 20
0
 internal void PaintBorder(CssBox box, CssSide border, Color solidColor, RectangleF rect)
 {
     PointF[] borderPoints = new PointF[4];
     BorderPaintHelper.DrawBorder(solidColor, border, borderPoints, this.canvas, box, rect);
 }