Пример #1
0
        static void TestDriveEnums()
        {
            BorderSide topSide = BorderSide.Top;
            bool       isTop   = (topSide == BorderSide.Top);

            WriteLine($"isTop: {isTop}");
        }
Пример #2
0
            internal double this[int height, BorderSide side]
            {
                get
                {
                    height = TransformIndex(height);
                    switch (side)
                    {
                    case BorderSide.Left:
                        return(leftBorders[height]);

                    case BorderSide.Right:
                        return(rightBorders[height]);

                    default:
                        throw new ArgumentException();
                    }
                }
                set
                {
                    height = TransformIndex(height);
                    switch (side)
                    {
                    case BorderSide.Left:
                        leftBorders[height] = value;
                        break;

                    case BorderSide.Right:
                        rightBorders[height] = value;
                        break;

                    default:
                        throw new ArgumentException();
                    }
                }
            }
Пример #3
0
        protected override SceneID GetNextMap(IMovesBetweenScenes actor, BorderSide exitSide)
        {
            var position = actor.Position.Center;

            switch (exitSide)
            {
            case BorderSide.Right:
                position.X = (float)(Scene.Position.Right + actor.Position.Width * 4);
                break;

            case BorderSide.Left:
                position.X = (float)(Scene.Position.Left - actor.Position.Width * 4);
                break;

            case BorderSide.Top:
                position.Y = (float)(Scene.Position.Top - actor.Position.Height * 4);
                break;

            case BorderSide.Bottom:
                position.Y = (float)(Scene.Position.Bottom + actor.Position.Height * 4);
                break;
            }

            position = MasterTemplate.PositionInMapToPointInTemplate(CurrentMap, position);

            var nextMapIndex = MasterTemplate.MapRegions.FindIndex(p => p.Contains(position));

            if (nextMapIndex == -1)
            {
                throw new ArgumentException("Unable to find adjacent map");
            }

            return(new SceneID(CurrentMap.Name, nextMapIndex));
        }
Пример #4
0
        public static Vector2 GetAdjacent(this Vector2 vector, BorderSide side)
        {
            switch (side)
            {
            case BorderSide.Top: return(vector.Translate(0, -1));

            case BorderSide.Left: return(vector.Translate(-1, 0));

            case BorderSide.Right: return(vector.Translate(1, 0));

            case BorderSide.Bottom: return(vector.Translate(0, 1));

            case BorderSide.TopLeftCorner: return(vector.Translate(-1, -1));

            case BorderSide.TopRightCorner: return(vector.Translate(1, -1));

            case BorderSide.BottomLeftCorner: return(vector.Translate(-1, 1));

            case BorderSide.BottomRightCorner: return(vector.Translate(1, 1));

            case BorderSide.None: return(vector.Translate(0, 0));

            default: throw new NotImplementedException();
            }
        }
Пример #5
0
 public StyleBorder(BorderSide side, System.Drawing.Color color, LineStyle style, BorderWeight border)
 {
     this.Side   = side;
     this.Color  = color;
     this.Style  = style;
     this.Border = border;
 }
Пример #6
0
        /// <summary>
        /// Starts the new side rule.
        /// </summary>
        /// <param name="borderSide">Border side to be applied.</param>
        /// <returns>Next rule reference.</returns>
        public IFluentBorderWithAll WithSide(BorderSide borderSide)
        {
            currentBorderDefinition.Side = borderSide;
            Dirty();

            return(this);
        }
Пример #7
0
        public IEnumerable <Tile> GetAdjacentWhile(BorderSide side, Predicate <Tile> condition)
        {
            var tile = this;

            yield return(this);

            while (side != BorderSide.None)
            {
                var adjacent = tile.GetAdjacent(side);
                if (!adjacent.Position.CollidesWith(tile.TileMap.Position, false))
                {
                    break;
                }

                if (condition(adjacent))
                {
                    yield return(adjacent);
                }
                else
                {
                    break;
                }

                tile = adjacent;
            }
        }
Пример #8
0
    public void Foo()
    {
        BorderSide a = BorderSide.Right;

        Console.WriteLine(a.ToString()); // Right
        //gdy nie ma określonego flags to można sprawdzić czy jest okreslone .IsDefined()
    }
Пример #9
0
 public UnderlineInputBorder copyWith(BorderSide borderSide = null, BorderRadius borderRadius = null)
 {
     return(new UnderlineInputBorder(
                borderSide: borderSide ?? this.borderSide,
                borderRadius: borderRadius ?? this.borderRadius
                ));
 }
Пример #10
0
        /**
         * Get the type of border to use for the selected border
         *
         * @param side -  - where to apply the color defInition
         * @return borderstyle - the type of border to use. default value is NONE if border style is not Set.
         * @see BorderStyle
         */
        public BorderStyle GetBorderStyle(BorderSide side)
        {
            CT_BorderPr    ctborder = GetBorder(side);
            ST_BorderStyle?border   = ctborder == null ? ST_BorderStyle.none : ctborder.style;

            return((BorderStyle)border);
        }
Пример #11
0
 public override InputBorder copyWith(BorderSide borderSide) {
     return new OutlineInputBorder(
         borderSide: borderSide ?? this.borderSide,
         borderRadius: this.borderRadius,
         gapPadding: this.gapPadding
     );
 }
Пример #12
0
        public static TableBorder lerp(TableBorder a, TableBorder b, float t)
        {
            if (a == null && b == null)
            {
                return(null);
            }

            if (a == null)
            {
                return(b.scale(t));
            }

            if (b == null)
            {
                return(a.scale(1.0f - t));
            }

            return(new TableBorder(
                       top: BorderSide.lerp(a.top, b.top, t),
                       right: BorderSide.lerp(a.right, b.right, t),
                       bottom: BorderSide.lerp(a.bottom, b.bottom, t),
                       left: BorderSide.lerp(a.left, b.left, t),
                       horizontalInside: BorderSide.lerp(a.horizontalInside, b.horizontalInside, t),
                       verticalInside: BorderSide.lerp(a.verticalInside, b.verticalInside, t)
                       ));
        }
Пример #13
0
    /// <summary>
    /// Return a random position on the broder of the screen
    /// </summary>
    /// <param name="offset"></param>
    /// <returns></returns>
    public static Vector3 RandomScreenBorderPosition(float offset)
    {
        BorderSide randomBorderSide = Variables.RandomSide();

        float randomScreenX = Random.Range(-screenConstraint.halfWidth, screenConstraint.halfWidth);

        float randomScreenY = Random.Range(-screenConstraint.halfHeight, screenConstraint.halfHeight);

        switch (randomBorderSide)
        {
        case BorderSide.TOP:
            return(new Vector3(randomScreenX, screenConstraint.halfHeight + offset, 0));

        case BorderSide.BOTTOM:
            return(new Vector3(randomScreenX, -screenConstraint.halfHeight - offset, 0));

        case BorderSide.LEFT:
            return(new Vector3(-screenConstraint.halfWidth - offset, randomScreenY, 0));

        case BorderSide.RIGHT:
            return(new Vector3(screenConstraint.halfWidth + offset, randomScreenY, 0));

        default:
            return(new Vector3(0, screenConstraint.halfHeight + offset, 0));
        }
    }
Пример #14
0
        public GridHelper SetBorder(BorderSide border)
        {
            this.headerHelper.SetBorder(border);

            this.columnHelper.SetBorder(border);

            return(this);
        }
Пример #15
0
        public List <ClickableComponent> GetBorder(BorderSide side)
        {
            List <ClickableComponent> inventory_slots = new List <ClickableComponent>();
            int row_size = capacity / rows;

            switch (side)
            {
            case BorderSide.Bottom:
            {
                for (int l = 0; l < inventory.Count; l++)
                {
                    if (l >= actualInventory.Count - row_size)
                    {
                        inventory_slots.Add(inventory[l]);
                    }
                }
                break;
            }

            case BorderSide.Top:
            {
                for (int k = 0; k < inventory.Count; k++)
                {
                    if (k < row_size)
                    {
                        inventory_slots.Add(inventory[k]);
                    }
                }
                break;
            }

            case BorderSide.Left:
            {
                for (int j = 0; j < inventory.Count; j++)
                {
                    if (j % row_size == 0)
                    {
                        inventory_slots.Add(inventory[j]);
                    }
                }
                break;
            }

            case BorderSide.Right:
            {
                for (int i = 0; i < inventory.Count; i++)
                {
                    if (i % row_size == row_size - 1)
                    {
                        inventory_slots.Add(inventory[i]);
                    }
                }
                break;
            }
            }
            return(inventory_slots);
        }
Пример #16
0
        public void should_be_able_to_parse_enum_by_value()
        {
            var parsedBottomEnumValue = (BorderSide)Enum.Parse(typeof(BorderSide), "3");

            // change the variable value to fix the test.
            const BorderSide expectedEnumValue = BorderSide.Left;

            Assert.Equal(expectedEnumValue, parsedBottomEnumValue);
        }
Пример #17
0
 public UnderlineInputBorder(
     BorderSide borderSide = null,
     BorderRadius borderRadius = null
 ) : base(borderSide: borderSide ?? new BorderSide()) {
     this.borderRadius = borderRadius ?? BorderRadius.only(
                             topLeft: Radius.circular(4.0f),
                             topRight: Radius.circular(4.0f)
                         );
 }
Пример #18
0
 public OutlineInputBorder(
     BorderSide borderSide = null,
     BorderRadius borderRadius = null,
     float gapPadding = 4.0f
 ) : base(borderSide: borderSide ?? new BorderSide()) {
     D.assert(gapPadding >= 0.0f);
     this.gapPadding = gapPadding;
     this.borderRadius = borderRadius ?? BorderRadius.all(Radius.circular(4.0f));
 }
Пример #19
0
        static void Main(string[] args)
        {
            BorderSide TopSide = BorderSide.Top;
            bool       IsTop   = (TopSide == BorderSide.Top);

            Days day = Days.Friday;

            Console.WriteLine(day);
        }
Пример #20
0
 public UnderlineTabIndicator(
     BorderSide borderSide     = null,
     EdgeInsetsGeometry insets = null)
 {
     borderSide      = borderSide ?? new BorderSide(width: 2.0f, color: Colors.white);
     insets          = insets ?? EdgeInsets.zero;
     this.borderSide = borderSide;
     this.insets     = insets;
 }
Пример #21
0
        private CT_BorderPr GetBorder(BorderSide side, bool ensure)
        {
            CT_BorderPr ctBorderPr;

            switch (side)
            {
            case BorderSide.TOP:
                ctBorderPr = this.border.top;
                if (ensure && ctBorderPr == null)
                {
                    ctBorderPr = this.border.AddNewTop();
                    break;
                }
                break;

            case BorderSide.RIGHT:
                ctBorderPr = this.border.right;
                if (ensure && ctBorderPr == null)
                {
                    ctBorderPr = this.border.AddNewRight();
                    break;
                }
                break;

            case BorderSide.BOTTOM:
                ctBorderPr = this.border.bottom;
                if (ensure && ctBorderPr == null)
                {
                    ctBorderPr = this.border.AddNewBottom();
                    break;
                }
                break;

            case BorderSide.LEFT:
                ctBorderPr = this.border.left;
                if (ensure && ctBorderPr == null)
                {
                    ctBorderPr = this.border.AddNewLeft();
                    break;
                }
                break;

            case BorderSide.DIAGONAL:
                ctBorderPr = this.border.diagonal;
                if (ensure && ctBorderPr == null)
                {
                    ctBorderPr = this.border.AddNewDiagonal();
                    break;
                }
                break;

            default:
                throw new ArgumentException("No suitable side specified for the border");
            }
            return(ctBorderPr);
        }
Пример #22
0
 public _OutlineBorder(
     ShapeBorder shape,
     BorderSide side
     )
 {
     D.assert(shape != null);
     D.assert(side != null);
     this.shape = shape;
     this.side  = side;
 }
Пример #23
0
        public GridHeaderHelper SetBorder(BorderSide border)
        {
            var cell = this.ContainerControl.GetLastCell();

            if (cell != null)
            {
                cell.SetBorder(border);
            }
            return(this);
        }
Пример #24
0
        public override ShapeBorder lerpTo(ShapeBorder b, float t) {
            if (b is UnderlineInputBorder) {
                return new UnderlineInputBorder(
                    borderSide: BorderSide.lerp(this.borderSide, (b as UnderlineInputBorder).borderSide, t),
                    borderRadius: BorderRadius.lerp(this.borderRadius, (b as UnderlineInputBorder).borderRadius, t)
                );
            }

            return base.lerpTo(b, t);
        }
Пример #25
0
        public override ShapeBorder lerpFrom(ShapeBorder a, float t) {
            if (a is UnderlineInputBorder) {
                return new UnderlineInputBorder(
                    borderSide: BorderSide.lerp((a as UnderlineInputBorder).borderSide, this.borderSide, t),
                    borderRadius: BorderRadius.lerp((a as UnderlineInputBorder).borderRadius, this.borderRadius, t)
                );
            }

            return base.lerpFrom(a, t);
        }
Пример #26
0
        public void should_be_able_to_parse_enum_by_name()
        {
            // pass without cast to BorderSide
            var parsedBottomEnumValue = (BorderSide)Enum.Parse(typeof(BorderSide), "Bottom");

            // change the variable value to fix the test.
            const BorderSide expectedEnumValue = BorderSide.Bottom;

            Assert.Equal(expectedEnumValue, parsedBottomEnumValue);
        }
Пример #27
0
      /// <summary>See <c>WpfExtensions</c> for details.</summary>
      public static void DrawRectangle(DrawingContext dc, Rect rect, Paint paint, CornerRadius corners, CornerStyle cornerStyle, BorderSide borderSide, bool snapToPixel) {
         // get brush and stroke resources
         if (paint == null) return;
         var fill = paint.Fill;
         var strokes = paint.GetStrokePens().ToArray();
         var hasFill = (fill != null);
         var hasStroke = (strokes.Length > 0 && borderSide != BorderSide.None);
         if (!hasFill && !hasStroke) return;

         // compute the drawing rectangle with offset for pixel snapping 
         // (assumptions: the box itself is pixel snapped, all strokes have same thickness, and the thickness is a whole number)
         var halfThickness = Math.Round(hasStroke ? strokes[0].Thickness : 0.0) / 2;
         if (snapToPixel && hasStroke) {
            rect = new Rect(rect.X + halfThickness, rect.Y + halfThickness, (rect.Width - 2 * halfThickness).Max(0), (rect.Height - 2 * halfThickness).Max(0));
         }

         // select drawing function based on the corners complexity 
         DrawingFunction fillFunc = null;
         if (corners.IsZero()) {
            fillFunc = _drawSimpleRectangle;
         } else if (corners.IsUniform()) {
            fillFunc = _drawRoundedRectangle;
         } else {
            fillFunc = _drawComplexRectangle;
         }

         // draw the border 
         if (hasStroke) {
            if (paint.IsA<QuadPaint>()) {
               rect = _drawSide(dc, rect, null, strokes[0], corners, cornerStyle, BorderSide.Left);
               rect = _drawSide(dc, rect, null, strokes[1], corners, cornerStyle, BorderSide.Top);
               rect = _drawSide(dc, rect, null, strokes[2], corners, cornerStyle, BorderSide.Right);
               rect = _drawSide(dc, rect, null, strokes[3], corners, cornerStyle, BorderSide.Bottom);
               corners = _inflateCorners(corners, strokes[3]);
            } else {
               var strokeFunc = (borderSide == BorderSide.All ? fillFunc : _drawSide);
               foreach (var stroke in strokes) {
                  rect = strokeFunc(dc, rect, null, stroke, corners, cornerStyle, borderSide);
                  corners = _inflateCorners(corners, stroke);
               }
            }
         }

         // draw the background
         if (hasFill) {
            if (snapToPixel) {
               rect = _deflateRect(rect, -halfThickness);
            }
            if (paint.FillMode == BrushMappingMode.Absolute) {
               fill = _mapAbsoluteFill(fill, rect);
            }
            fillFunc(dc, rect, fill, null, corners, cornerStyle, borderSide);
         }

      }
Пример #28
0
        static void Main(string[] args)
        {
            UnitConverter feetToInches = new UnitConverter(12);
            UnitConverter milesToFeet  = new UnitConverter(5280);

            Console.WriteLine(feetToInches.Convert(30));                     // 360
            Console.WriteLine(feetToInches.Convert(100));                    // 1200
            Console.WriteLine(feetToInches.Convert(milesToFeet.Convert(1))); // 63360

            Panda p1 = new Panda("Pan Dee");
            Panda p2 = new Panda("Pan Dah");

            Console.WriteLine(p1.Name);
            Console.WriteLine(p2.Name);
            Console.WriteLine(Panda.Population);

            BorderSide topSide = BorderSide.Top;
            bool       isTrue  = (topSide == BorderSide.Top); // true

            foreach (char s in "house")
            {
                Console.Write(s + " ");
            }

            Stock msft = new Stock();

            msft.CurrentPrice  = 30;
            msft.CurrentPrice -= 3;
            Console.WriteLine(msft.CurrentPrice);


            string msc = MyStaticClass.MyMethod();

            Console.WriteLine(msc);

            MyNonStaticClass mnsc = new MyNonStaticClass();

            Console.WriteLine(mnsc.MyMethod());

            Shares share = new Shares {
                Name = "MyShares", SharesOwned = 1000
            };

            Console.WriteLine(share.Name);
            Console.WriteLine(share.SharesOwned);

            House mansion = new House {
                Name = "Mansion", Mortage = 250000
            };

            Console.WriteLine(mansion.Name);
            Console.WriteLine(mansion.Mortage);

            Console.ReadLine();
        }
Пример #29
0
 public OutlineInputBorder copyWith(
     BorderSide borderSide,
     BorderRadius borderRadius,
     float? gapPadding
 ) {
     return new OutlineInputBorder(
         borderSide: borderSide ?? this.borderSide,
         borderRadius: borderRadius ?? this.borderRadius,
         gapPadding: gapPadding ?? this.gapPadding
     );
 }
Пример #30
0
 private void AlterSideStyle(BorderSide bSide)
 {
     if ((_sides & bSide) == bSide)
     {
         this._sides &= (~bSide);
     }
     else
     {
         this._sides |= bSide;
     }
 }
Пример #31
0
 public NotificationDot(
     string content,
     BorderSide borderSide = null,
     EdgeInsets margin     = null,
     Key key = null
     ) : base(key: key)
 {
     this.content    = content;
     this.borderSide = borderSide;
     this.margin     = margin;
 }
Пример #32
0
 public Border(int iWidth, Color color, BorderSide border)
 {
     Width = iWidth;
     Colour = color;
     Side = border;
 }
Пример #33
0
 /**
  * Set the type of border to use for the selected border
  *
  * @param side  -  - where to apply the color defInition
  * @param style - border style
  * @see BorderStyle
  */
 public void SetBorderStyle(BorderSide side, BorderStyle style)
 {
     GetBorder(side, true).style = (ST_BorderStyle)Enum.GetValues(typeof(ST_BorderStyle)).GetValue((int)style + 1);
 }
Пример #34
0
 private static Rect _drawSimpleRectangle(DrawingContext dc, Rect rect, Brush fill, Pen stroke, CornerRadius corners, CornerStyle cornerStyle, BorderSide borderSide) {
    dc.DrawRectangle(fill, stroke, rect);
    return _deflateRect(rect, stroke);
 }
Пример #35
0
 internal static void DoDrawBorder(Graphics gr, ScrollBarBorderStyle style, Color c, Rectangle rect, BorderSide sides, Color parentColor)
 {
     if (((style != ScrollBarBorderStyle.None) && (rect.Width > 0)) && ((rect.Height > 0) && (sides != BorderSide.None)))
     {
         Pen pen = GetPen(c);
         if ((rect.Width == 1) && (rect.Height == 1))
         {
             DrawPixel(gr, c, rect.Left, rect.Top);
         }
         else if (rect.Width == 1)
         {
             if ((sides & (BorderSide.Right | BorderSide.Left)) != BorderSide.None)
             {
                 gr.DrawLine(pen, rect.Left, rect.Top, rect.Left, rect.Bottom - 1);
             }
         }
         else if (rect.Height == 1)
         {
             if ((sides & (BorderSide.Down | BorderSide.Up)) != BorderSide.None)
             {
                 gr.DrawLine(pen, rect.Left, rect.Top, rect.Right - 1, rect.Top);
             }
         }
         else
         {
             int left = rect.Left;
             int top = rect.Top;
             int num3 = rect.Right - 1;
             int num4 = rect.Bottom - 1;
             if ((style == ScrollBarBorderStyle.Solid) || ((style == ScrollBarBorderStyle.Rounded) && ((rect.Width == 2) || (rect.Height == 2))))
             {
                 if ((sides & BorderSide.Left) == BorderSide.Left)
                 {
                     gr.DrawLine(pen, left, top, left, num4);
                 }
                 if ((sides & BorderSide.Up) == BorderSide.Up)
                 {
                     gr.DrawLine(pen, left, top, num3, top);
                 }
                 if ((sides & BorderSide.Right) == BorderSide.Right)
                 {
                     gr.DrawLine(pen, num3, top, num3, num4);
                 }
                 if ((sides & BorderSide.Down) == BorderSide.Down)
                 {
                     gr.DrawLine(pen, left, num4, num3, num4);
                 }
             }
             else
             {
                 if (rect.Width == 3)
                 {
                     if ((sides & BorderSide.Up) == BorderSide.Up)
                     {
                         if ((sides & BorderSide.Left) == BorderSide.None)
                         {
                             gr.DrawLine(pen, left, top, left + 1, top);
                         }
                         else if ((sides & BorderSide.Right) == BorderSide.None)
                         {
                             gr.DrawLine(pen, left + 1, top, num3, top);
                         }
                         else
                         {
                             DrawPixel(gr, c, left + 1, top);
                         }
                     }
                     if ((sides & BorderSide.Down) == BorderSide.Down)
                     {
                         if ((sides & BorderSide.Left) == BorderSide.None)
                         {
                             gr.DrawLine(pen, left, num4, left + 1, num4);
                         }
                         else if ((sides & BorderSide.Right) == BorderSide.None)
                         {
                             gr.DrawLine(pen, left + 1, num4, num3, num4);
                         }
                         else
                         {
                             DrawPixel(gr, c, left + 1, num4);
                         }
                     }
                 }
                 else
                 {
                     if ((sides & BorderSide.Up) == BorderSide.Up)
                     {
                         gr.DrawLine(pen, left + (((sides & BorderSide.Left) == BorderSide.Left) ? 1 : 0), top, num3 - (((sides & BorderSide.Right) == BorderSide.Right) ? 1 : 0), top);
                     }
                     if ((sides & BorderSide.Down) == BorderSide.Down)
                     {
                         gr.DrawLine(pen, left + (((sides & BorderSide.Left) == BorderSide.Left) ? 1 : 0), num4, num3 - (((sides & BorderSide.Right) == BorderSide.Right) ? 1 : 0), num4);
                     }
                 }
                 if (rect.Height == 3)
                 {
                     if ((sides & BorderSide.Left) == BorderSide.Left)
                     {
                         if ((sides & BorderSide.Up) == BorderSide.None)
                         {
                             gr.DrawLine(pen, left, top, left, top + 1);
                         }
                         else if ((sides & BorderSide.Down) == BorderSide.None)
                         {
                             gr.DrawLine(pen, left, top + 1, left, num4);
                         }
                         else
                         {
                             DrawPixel(gr, c, left, top + 1);
                         }
                     }
                     if ((sides & BorderSide.Right) == BorderSide.Right)
                     {
                         if ((sides & BorderSide.Up) == BorderSide.None)
                         {
                             gr.DrawLine(pen, num3, top, num3, top + 1);
                         }
                         else if ((sides & BorderSide.Down) == BorderSide.None)
                         {
                             gr.DrawLine(pen, num3, top + 1, num3, num4);
                         }
                         else
                         {
                             DrawPixel(gr, c, num3, top + 1);
                         }
                     }
                 }
                 else
                 {
                     if ((sides & BorderSide.Left) == BorderSide.Left)
                     {
                         gr.DrawLine(pen, left, top + (((sides & BorderSide.Up) == BorderSide.Up) ? 1 : 0), left, num4 - (((sides & BorderSide.Down) == BorderSide.Down) ? 1 : 0));
                     }
                     if ((sides & BorderSide.Right) == BorderSide.Right)
                     {
                         gr.DrawLine(pen, num3, top + (((sides & BorderSide.Up) == BorderSide.Up) ? 1 : 0), num3, num4 - (((sides & BorderSide.Down) == BorderSide.Down) ? 1 : 0));
                     }
                 }
                 if (parentColor != Color.Transparent)
                 {
                     if ((sides & (BorderSide.Up | BorderSide.Left)) == (BorderSide.Up | BorderSide.Left))
                     {
                         DrawPixel(gr, parentColor, left, top);
                     }
                     if ((sides & (BorderSide.Right | BorderSide.Up)) == (BorderSide.Right | BorderSide.Up))
                     {
                         DrawPixel(gr, parentColor, num3, top);
                     }
                     if ((sides & (BorderSide.Down | BorderSide.Left)) == (BorderSide.Down | BorderSide.Left))
                     {
                         DrawPixel(gr, parentColor, left, num4);
                     }
                     if ((sides & (BorderSide.Down | BorderSide.Right)) == (BorderSide.Down | BorderSide.Right))
                     {
                         DrawPixel(gr, parentColor, num3, num4);
                     }
                 }
             }
         }
     }
 }
Пример #36
0
 private static Rect _drawComplexRectangle(DrawingContext dc, Rect rect, Brush fill, Pen stroke, CornerRadius corners, CornerStyle cornerStyle, BorderSide borderSide) {
    var geometry = new StreamGeometry();
    using (var ctx = geometry.Open()) {
       AddRectangleFigure(ctx, rect, (fill != null), (stroke != null), corners, cornerStyle);
    }
    geometry.Freeze();
    dc.DrawGeometry(fill, stroke, geometry);
    return _deflateRect(rect, stroke);
 }
Пример #37
0
 private static Rect _drawRoundedRectangle(DrawingContext dc, Rect rect, Brush fill, Pen stroke, CornerRadius corners, CornerStyle cornerStyle, BorderSide borderSide) {
    var r = corners.TopLeft;
    dc.DrawRoundedRectangle(fill, stroke, rect, r, r);
    return _deflateRect(rect, stroke);
 }
Пример #38
0
 /**
  * Gets border color
  *
  * @param side the border side
  * @return the used color
  */
 public XSSFColor GetBorderColor(BorderSide side)
 {
     switch (side)
     {
         case BorderSide.BOTTOM:
             return GetBottomBorderXSSFColor();
         case BorderSide.RIGHT:
             return GetRightBorderXSSFColor();
         case BorderSide.TOP:
             return GetTopBorderXSSFColor();
         case BorderSide.LEFT:
             return GetLeftBorderXSSFColor();
         default:
             throw new ArgumentException("Unknown border: " + side);
     }
 }
Пример #39
0
      private static Rect _drawSide(DrawingContext dc, Rect rect, Brush fill, Pen stroke, CornerRadius corners, CornerStyle cornerStyle, BorderSide borderSide) {
         var full = stroke.Thickness;
         var half = full / 2.0;

         var x0 = rect.Left;
         var x1 = rect.Right;
         var y0 = rect.Top;
         var y1 = rect.Bottom;
         
         var TL = corners.TopLeft;
         var TR = corners.TopRight;
         var BR = corners.BottomRight;
         var BL = corners.BottomLeft;

         var SQ = 0.0;
         switch (cornerStyle) {
            case CornerStyle.Diagonal:
               SQ = 1.0 / 2.0;
               break;
            case CornerStyle.Round:
               SQ = 1.0 - 1.0 / Math.Sqrt(2); 
               break;
            case CornerStyle.Concave:
               SQ = 1.0 / Math.Sqrt(2);
               break;
         }
            
         var hasCorners = false;

         var R = new double[4];
         var P = new Point[4];
         switch (borderSide) {
            case BorderSide.Left: 
               if (TL > 0) {
                  R[0] = TL;
                  P[0].X = x0 + SQ * (TL - full);
                  P[0].Y = y0 + SQ * TL;
                  hasCorners = true;
               }
               P[1].X = x0;
               P[1].Y = y0 + (TL - half);
               P[2].X = x0;
               P[2].Y = y1 - (BL - half);
               if (BL > 0) {
                  R[3] = BL;
                  P[3].X = x0 + SQ * BL;
                  P[3].Y = y1 - SQ * BL;
                  hasCorners = true;
               }
               rect.X += full;
               rect.Width = (rect.Width - full).Max(0);
               break;

            case BorderSide.Top:
               if (TR > 0) {
                  R[0] = TR;
                  P[0].X = x1 - SQ * TR;
                  P[0].Y = y0 + SQ * (TR - full);
                  hasCorners = true;
               }
               P[1].X = x1 - (TR - half);
               P[1].Y = y0;
               P[2].X = x0 + (TL - half);
               P[2].Y = y0;
               if (TL > 0) {
                  R[3] = TL;
                  P[3].X = x0 + SQ * (TL - full);
                  P[3].Y = y0 + SQ * TL;
                  hasCorners = true;
               }
               rect.Y += full;
               rect.Height = (rect.Height - full).Max(0);
               break;

            case BorderSide.Right:
               if (BR > 0) {
                  R[0] = BR;
                  P[0].X = x1 - SQ * (BR + full);
                  P[0].Y = y1 - SQ * BR;
                  hasCorners = true;
               }
               P[1].X = x1;
               P[1].Y = y1 - (BR - half);
               P[2].X = x1;
               P[2].Y = y0 + (TR - half);
               if (TR > 0) {
                  R[3] = TR;
                  P[3].X = x1 - SQ * TR;
                  P[3].Y = y0 + SQ * (TR - full);
                  hasCorners = true;
               }
               rect.Width = (rect.Width - full).Max(0);
               break;

            case BorderSide.Bottom:
               if (BL > 0) {
                  R[0] = BL;
                  P[0].X = x0 + SQ * (BL - full);
                  P[0].Y = y1 - SQ * (BL - full);
                  hasCorners = true;
               }
               P[1].X = x0 + (BL - half);
               P[1].Y = y1;
               P[2].X = x1 - (BR - half);
               P[2].Y = y1;
               if (BR > 0) {
                  R[3] = BR;
                  P[3].X = x1 - SQ * (BR - full);
                  P[3].Y = y1 - SQ * (BR - full);
                  hasCorners = true;
               }
               rect.Height = (rect.Height - full).Max(0);
               break;

            default:
               return rect;
         }

         if (!hasCorners) {
            dc.DrawLine(stroke, P[1], P[2]);
         } else {
            var sg = new StreamGeometry();
            var gc = sg.Open();
            switch (cornerStyle) {
               case CornerStyle.Concave:
               case CornerStyle.Round:
                  var sweep = (cornerStyle == CornerStyle.Round ? SweepDirection.Counterclockwise : SweepDirection.Clockwise);
                  if (R[0] == 0) {
                     gc.BeginFigure(P[1], false, false);
                  } else {
                     gc.BeginFigure(P[0], false, false);
                     gc.ArcTo(P[1], new Size(R[0], R[0]), 0, false, sweep, true, false);
                  }
                  gc.LineTo(P[2], true, false);
                  if (R[3] != 0) {
                     gc.ArcTo(P[3], new Size(R[3], R[3]), 0, false, sweep, true, false);
                  }
                  break;
               case CornerStyle.Diagonal:
                  if (R[0] == 0) {
                     gc.BeginFigure(P[1], false, false);
                  } else {
                     gc.BeginFigure(P[0], false, false);
                     gc.LineTo(P[1], true, false);
                  }
                  gc.LineTo(P[2], true, false);
                  if (R[3] != 0) {
                     gc.LineTo(P[3], true, false);
                  }
                  break;
            }
            gc.Close();
            sg.Freeze();
            dc.DrawGeometry(null, stroke, sg);
         }
         return rect;
      }
Пример #40
0
        /**
         * Get the color to use for the selected border
         *
         * @param side - where to apply the color defInition
         * @return color - color to use as XSSFColor. null if color is not set
         */
        public XSSFColor GetBorderColor(BorderSide side)
        {
            CT_BorderPr borderPr = GetBorder(side);

            if (borderPr != null && borderPr.IsSetColor())
            {
                XSSFColor clr = new XSSFColor(borderPr.color);
                if (_theme != null)
                {
                    _theme.InheritFromThemeAsRequired(clr);
                }
                return clr;
            }
            else
            {
                // No border set
                return null;
            }
        }
Пример #41
0
 /**
  * Set the color to use for the selected border
  *
  * @param side  - where to apply the color defInition
  * @param color - the color to use
  */
 public void SetBorderColor(BorderSide side, XSSFColor color)
 {
     CT_BorderPr borderPr = GetBorder(side, true);
     if (color == null) borderPr.UnsetColor();
     else
         borderPr.color = color.GetCTColor();
 }
Пример #42
0
 private CT_BorderPr GetBorder(BorderSide side)
 {
     return GetBorder(side, false);
 }
Пример #43
0
 private CT_BorderPr GetBorder(BorderSide side, bool ensure)
 {
     CT_BorderPr borderPr;
     switch (side)
     {
         case BorderSide.TOP:
             borderPr = border.top;
             if (ensure && borderPr == null) borderPr = border.AddNewTop();
             break;
         case BorderSide.RIGHT:
             borderPr = border.right;
             if (ensure && borderPr == null) borderPr = border.AddNewRight();
             break;
         case BorderSide.BOTTOM:
             borderPr = border.bottom;
             if (ensure && borderPr == null) borderPr = border.AddNewBottom();
             break;
         case BorderSide.LEFT:
             borderPr = border.left;
             if (ensure && borderPr == null) borderPr = border.AddNewLeft();
             break;
         case BorderSide.DIAGONAL:
             borderPr = border.diagonal;
             if (ensure && borderPr == null) borderPr = border.AddNewDiagonal();
             break;
         default:
             throw new ArgumentException("No suitable side specified for the border");
     }
     return borderPr;
 }
Пример #44
0
 /**
  * Get the type of border to use for the selected border
  *
  * @param side -  - where to apply the color defInition
  * @return borderstyle - the type of border to use. default value is NONE if border style is not Set.
  * @see BorderStyle
  */
 public BorderStyle GetBorderStyle(BorderSide side)
 {
     CT_BorderPr ctborder = GetBorder(side);
     ST_BorderStyle? border = ctborder == null ? ST_BorderStyle.none : ctborder.style;
     return (BorderStyle)border;
 }
Пример #45
0
 /**
  * Set the color to use for the selected border
  *
  * @param side - where to apply the color defInition
  * @param color - the color to use
  */
 public void SetBorderColor(BorderSide side, XSSFColor color)
 {
     switch (side)
     {
         case BorderSide.BOTTOM:
             SetBottomBorderColor(color);
             break;
         case BorderSide.RIGHT:
             SetRightBorderColor(color);
             break;
         case BorderSide.TOP:
             SetTopBorderColor(color);
             break;
         case BorderSide.LEFT:
             SetLeftBorderColor(color);
             break;
     }
 }
Пример #46
0
 /// <summary>Gets the total stroke thickness, computed from the sum of the thicknesses of all the individual stroke pens along the specified border side(s).</summary>
 public Thickness GetTotalStrokeThickness(BorderSide borders) {
    if (borders == BorderSide.None) return new Thickness();
    var t = new Thickness(GetTotalStrokeThickness());
    switch (borders) {
       case BorderSide.All: return t;
       case BorderSide.Left: t.Right = t.Top = t.Bottom = 0; break;
       case BorderSide.Right: t.Left = t.Top = t.Bottom = 0; break;
       case BorderSide.Top: t.Bottom = t.Left = t.Right = 0; break;
       case BorderSide.Bottom: t.Top = t.Left = t.Right = 0; break;
    }
    return t;
 }