/// <summary> /// Gets the border rounding. /// </summary> /// <param name="state">Palette value should be applicable to this state.</param> /// <returns>Border rounding.</returns> public override int GetBorderRounding(PaletteState state) { if (Apply) { int ret = _primary.GetBorderRounding(Override ? OverrideState : state); if (ret == -1) { ret = _backup.GetBorderRounding(state); } return(ret); } else { return(_backup.GetBorderRounding(state)); } }
/// <summary> /// Gets the border rounding. /// </summary> /// <param name="state">Palette value should be applicable to this state.</param> /// <returns>Border rounding.</returns> public int GetBorderRounding(PaletteState state) { if (Rounding != -1) { return(Rounding); } else { return(_inherit.GetBorderRounding(state)); } }
/// <summary> /// Gets the border corner rounding. /// </summary> /// <param name="style">Border style.</param> /// <param name="state">Palette value should be applicable to this state.</param> /// <returns>Integer rounding.</returns> public override int GetBorderRounding(PaletteBorderStyle style, PaletteState state) { IPaletteBorder inherit = GetInherit(state); if (inherit != null) { return(inherit.GetBorderRounding(state)); } else { return(Target.GetBorderRounding(style, state)); } }
/// <summary> /// Gets the border rounding. /// </summary> /// <param name="state">Palette value should be applicable to this state.</param> /// <returns>Border rounding.</returns> public int GetBorderRounding(PaletteState state) { return(_inherit.GetBorderRounding(state)); }
/// <summary> /// Gets the border rounding. /// </summary> /// <param name="state">Palette value should be applicable to this state.</param> /// <returns>Border rounding.</returns> public override int GetBorderRounding(PaletteState state) => _inherit.GetBorderRounding(state);
/// <summary> /// Draw border on the inside edge of the specified rectangle. /// </summary> /// <param name="context">Rendering context.</param> /// <param name="rect">Target rectangle.</param> /// <param name="palette">Palette used for drawing.</param> /// <param name="orientation">Visual orientation of the border.</param> /// <param name="state">State associated with rendering.</param> public override void DrawBorder(RenderContext context, Rectangle rect, IPaletteBorder palette, VisualOrientation orientation, PaletteState state) { Debug.Assert(context != null); Debug.Assert(palette != null); // Validate parameter references if (context == null) throw new ArgumentNullException("context"); if (palette == null) throw new ArgumentNullException("palette"); Debug.Assert(context.Control != null); Debug.Assert(!context.Control.IsDisposed); PaletteDrawBorders borders = palette.GetBorderDrawBorders(state); // Is there anything to actually draw? if ((rect.Width > 0) && (rect.Height > 0) && CommonHelper.HasABorder(borders)) { // Only use anti aliasing if the border is rounded SmoothingMode smoothMode = (palette.GetBorderRounding(state) > 0 ? SmoothingMode.AntiAlias : SmoothingMode.Default); // We want to draw using anti aliasing for a nice smooth effect using (GraphicsHint hint = new GraphicsHint(context.Graphics, palette.GetBorderGraphicsHint(state))) { // Cache commonly used values int borderWidth = palette.GetBorderWidth(state); // Get the orientation correct borders value borders = CommonHelper.OrientateDrawBorders(borders, orientation); // Is there any border to actually draw? if (borderWidth > 0) { using (Clipping clip = new Clipping(context.Graphics, rect)) { // We always create the first border path variant GraphicsPath borderPath0 = CreateBorderBackPath(true, true, rect, borders, borderWidth, palette.GetBorderRounding(state), (smoothMode == SmoothingMode.AntiAlias), 0); GraphicsPath borderPath1 = null; // We only need the second border path if the two borders used are opposite each other if ((borders == PaletteDrawBorders.TopBottom) || (borders == PaletteDrawBorders.LeftRight)) { borderPath1 = CreateBorderBackPath(true, true, rect, borders, borderWidth, palette.GetBorderRounding(state), (smoothMode == SmoothingMode.AntiAlias), 1); } // Get the rectangle to use when dealing with gradients Rectangle gradientRect = context.GetAlignedRectangle(palette.GetBorderColorAlign(state), rect); // Use standard helper routine to create appropriate color brush PaletteColorStyle colorStyle = palette.GetBorderColorStyle(state); using (Pen borderPen = new Pen(CreateColorBrush(gradientRect, palette.GetBorderColor1(state), palette.GetBorderColor2(state), colorStyle, palette.GetBorderColorAngle(state), orientation), borderWidth)) { if (colorStyle == PaletteColorStyle.Dashed) borderPen.DashPattern = new float[] { 2, 2 }; context.Graphics.DrawPath(borderPen, borderPath0); // Optionally also draw the second path if (borderPath1 != null) context.Graphics.DrawPath(borderPen, borderPath1); } Image borderImage = palette.GetBorderImage(state); PaletteImageStyle borderImageStyle = palette.GetBorderImageStyle(state); // Do we need to draw the image? if (ShouldDrawImage(borderImage)) { // Get the rectangle to use when dealing with gradients Rectangle imageRect = context.GetAlignedRectangle(palette.GetBorderImageAlign(state), rect); // Use standard helper routine to create appropriate image brush using (Pen borderPen = new Pen(CreateImageBrush(imageRect, borderImage, borderImageStyle), borderWidth)) { context.Graphics.DrawPath(borderPen, borderPath0); // Optionally also draw the second path if (borderPath1 != null) context.Graphics.DrawPath(borderPen, borderPath1); } } // Remember to dispose of resources borderPath0.Dispose(); if (borderPath1 != null) borderPath1.Dispose(); } } } } }
/// <summary> /// Generate a graphics path that is the outside edge of the border. /// </summary> /// <param name="context">Rendering context.</param> /// <param name="rect">Target rectangle.</param> /// <param name="palette">Palette used for drawing.</param> /// <param name="orientation">Visual orientation of the border.</param> /// <param name="state">State associated with rendering.</param> /// <returns>GraphicsPath instance.</returns> public override GraphicsPath GetOutsideBorderPath(RenderContext context, Rectangle rect, IPaletteBorder palette, VisualOrientation orientation, PaletteState state) { Debug.Assert(context != null); Debug.Assert(palette != null); // Validate parameter references if (context == null) throw new ArgumentNullException("context"); if (palette == null) throw new ArgumentNullException("palette"); Debug.Assert(context.Control != null); Debug.Assert(!context.Control.IsDisposed); // Use helper to create a border path on the outside return CreateBorderBackPath(true, false, rect, CommonHelper.OrientateDrawBorders(palette.GetBorderDrawBorders(state), orientation), palette.GetBorderWidth(state), palette.GetBorderRounding(state), (palette.GetBorderGraphicsHint(state) == PaletteGraphicsHint.AntiAlias), 0); }
/// <summary> /// Gets the padding used to position display elements completely inside border drawing. /// </summary> /// <param name="palette">Palette used for drawing.</param> /// <param name="state">State associated with rendering.</param> /// <param name="orientation">Visual orientation of the border.</param> /// <returns>Padding structure detailing all four edges.</returns> public override Padding GetBorderDisplayPadding(IPaletteBorder palette, PaletteState state, VisualOrientation orientation) { Debug.Assert(palette != null); // Validate parameter reference if (palette == null) throw new ArgumentNullException("palette"); PaletteDrawBorders borders = palette.GetBorderDrawBorders(state); // If there is at least one border to be drawn if (CommonHelper.HasABorder(borders)) { int borderWidth = palette.GetBorderWidth(state); // Divide the rounding effect by PI to get the actual pixel distance needed // for offseting. But add 2 so it starts indenting on a rounding of just 1. int roundPadding = Convert.ToInt16((palette.GetBorderRounding(state) + borderWidth + 2) / Math.PI); // If not involving rounding then padding for an edge is just the border width int squarePadding = borderWidth; // Borders thicker than 1 need extra offsetting, by half the extra width if (borderWidth > 1) { int halfExtra = borderWidth / 2; roundPadding += halfExtra; } // Enforce the width of the border as the minimum to ensure // it still works as expected for small values of rounding if (roundPadding < borderWidth) roundPadding = borderWidth; switch (borders) { case PaletteDrawBorders.Bottom: return new Padding(0, 0, 0, squarePadding); case PaletteDrawBorders.BottomLeft: return new Padding(roundPadding, 0, 0, roundPadding); case PaletteDrawBorders.BottomLeftRight: return new Padding(roundPadding, 0, roundPadding, roundPadding); case PaletteDrawBorders.BottomRight: return new Padding(0, 0, roundPadding, roundPadding); case PaletteDrawBorders.Left: return new Padding(squarePadding, 0, 0, 0); case PaletteDrawBorders.LeftRight: return new Padding(squarePadding, 0, squarePadding, 0); case PaletteDrawBorders.Top: return new Padding(0, squarePadding, 0, 0); case PaletteDrawBorders.Right: return new Padding(0, 0, squarePadding, 0); case PaletteDrawBorders.TopBottom: return new Padding(0, squarePadding, 0, squarePadding); case PaletteDrawBorders.TopBottomLeft: return new Padding(roundPadding, roundPadding, 0, roundPadding); case PaletteDrawBorders.TopBottomRight: return new Padding(0, roundPadding, roundPadding, roundPadding); case PaletteDrawBorders.TopLeft: return new Padding(roundPadding, roundPadding, 0, 0); case PaletteDrawBorders.TopLeftRight: return new Padding(roundPadding, roundPadding, roundPadding, 0); case PaletteDrawBorders.TopRight: return new Padding(0, roundPadding, roundPadding, 0); case PaletteDrawBorders.All: return new Padding(roundPadding); default: // Should never happen! Debug.Assert(false); return Padding.Empty; } } else return Padding.Empty; }
/// <summary> /// Evaluate if transparent painting is needed for background or border palettes. /// </summary> /// <param name="paletteBack">Background palette to test.</param> /// <param name="paletteBorder">Background palette to test.</param> /// <param name="state">Element state associated with palette.</param> /// <returns>True if transparent painting required.</returns> public override bool EvalTransparentPaint(IPaletteBack paletteBack, IPaletteBorder paletteBorder, PaletteState state) { int rounding = paletteBorder.GetBorderRounding(state); // If the border takes up some visual space if (paletteBorder.GetBorderWidth(state) > 0) { // If the border is not being painted then it must be transparent if (paletteBorder.GetBorderDraw(state) == InheritBool.False) return true; else { // If there is rounding causing transparent corners if (paletteBorder.GetBorderRounding(state) > 0) return true; else { // If the first color has alpha channel then has transparency if (paletteBorder.GetBorderColor1(state).A < 255) return true; else { // Does the draw style require use of the second color? if (paletteBorder.GetBorderColorStyle(state) != PaletteColorStyle.Solid) { // If the second color has alpha channel then has transparency if (paletteBorder.GetBorderColor2(state).A < 255) return true; } } } } } // The border does not cause transparency, check the background return EvalTransparentPaint(paletteBack, state); }
/// <summary> /// Gets the border corner rounding. /// </summary> /// <param name="style">Border style.</param> /// <param name="state">Palette value should be applicable to this state.</param> /// <returns>Integer rounding.</returns> public override int GetBorderRounding(PaletteBorderStyle style, PaletteState state) { IPaletteBorder inherit = GetInherit(state); return(inherit?.GetBorderRounding(state) ?? Target.GetBorderRounding(style, state)); }