/// <summary> /// Gets a value indicating which borders to draw. /// </summary> /// <param name="state">Palette value should be applicable to this state.</param> /// <returns>PaletteDrawBorders value.</returns> public override PaletteDrawBorders GetBorderDrawBorders(PaletteState state) { if (_forceBorders) { return(_forceBorderEdges); } else { // If no border edges are allowed then provide none if ((MaxBorderEdges == PaletteDrawBorders.None) || (BorderIgnoreNormal && (state == PaletteState.Normal) ) ) { return(PaletteDrawBorders.None); } else { // Get the requested set of edges PaletteDrawBorders inheritEdges = _inherit.GetBorderDrawBorders(state); // Limit the edges to those allowed return(inheritEdges & MaxBorderEdges); } } }
/// <summary> /// Gets a value indicating which borders to draw. /// </summary> /// <param name="state">Palette value should be applicable to this state.</param> /// <returns>PaletteDrawBorders value.</returns> public override PaletteDrawBorders GetBorderDrawBorders(PaletteState state) { if (Apply) { PaletteDrawBorders ret = _primary.GetBorderDrawBorders(Override ? OverrideState : state); if (ret == PaletteDrawBorders.Inherit) { ret = _backup.GetBorderDrawBorders(state); } return(ret); } else { return(_backup.GetBorderDrawBorders(state)); } }
/// <summary> /// Gets the actual borders to draw value. /// </summary> /// <param name="state">Palette value should be applicable to this state.</param> /// <returns>PaletteDrawBorders value.</returns> public PaletteDrawBorders GetBorderDrawBorders(PaletteState state) { if (DrawBorders != PaletteDrawBorders.Inherit) { return(DrawBorders); } else { return(_inherit.GetBorderDrawBorders(state)); } }
/// <summary> /// Gets a value indicating which borders to draw. /// </summary> /// <param name="style">Border style.</param> /// <param name="state">Palette value should be applicable to this state.</param> /// <returns>PaletteDrawBorders value.</returns> public override PaletteDrawBorders GetBorderDrawBorders(PaletteBorderStyle style, PaletteState state) { IPaletteBorder inherit = GetInherit(state); if (inherit != null) { return(inherit.GetBorderDrawBorders(state)); } else { return(Target.GetBorderDrawBorders(style, state)); } }
/// <summary> /// Gets the actual borders to draw value. /// </summary> /// <param name="state">Palette value should be applicable to this state.</param> /// <returns>PaletteDrawBorders value.</returns> public PaletteDrawBorders GetBorderDrawBorders(PaletteState state) { return(_inherit.GetBorderDrawBorders(state)); }
/// <summary> /// Gets a value indicating which borders to draw. /// </summary> /// <param name="style">Border style.</param> /// <param name="state">Palette value should be applicable to this state.</param> /// <returns>PaletteDrawBorders value.</returns> public override PaletteDrawBorders GetBorderDrawBorders(PaletteBorderStyle style, PaletteState state) { IPaletteBorder inherit = GetInherit(state); return(inherit?.GetBorderDrawBorders(state) ?? Target.GetBorderDrawBorders(style, 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 raw padding used per edge of the border. /// </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 GetBorderRawPadding(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); switch (borders) { case PaletteDrawBorders.Bottom: return new Padding(0, 0, 0, borderWidth); case PaletteDrawBorders.BottomLeft: return new Padding(borderWidth, 0, 0, borderWidth); case PaletteDrawBorders.BottomLeftRight: return new Padding(borderWidth, 0, borderWidth, borderWidth); case PaletteDrawBorders.BottomRight: return new Padding(0, 0, borderWidth, borderWidth); case PaletteDrawBorders.Left: return new Padding(borderWidth, 0, 0, 0); case PaletteDrawBorders.LeftRight: return new Padding(borderWidth, 0, borderWidth, 0); case PaletteDrawBorders.Top: return new Padding(0, borderWidth, 0, 0); case PaletteDrawBorders.Right: return new Padding(0, 0, borderWidth, 0); case PaletteDrawBorders.TopBottom: return new Padding(0, borderWidth, 0, borderWidth); case PaletteDrawBorders.TopBottomLeft: return new Padding(borderWidth, borderWidth, 0, borderWidth); case PaletteDrawBorders.TopBottomRight: return new Padding(0, borderWidth, borderWidth, borderWidth); case PaletteDrawBorders.TopLeft: return new Padding(borderWidth, borderWidth, 0, 0); case PaletteDrawBorders.TopLeftRight: return new Padding(borderWidth, borderWidth, borderWidth, 0); case PaletteDrawBorders.TopRight: return new Padding(0, borderWidth, borderWidth, 0); case PaletteDrawBorders.All: return new Padding(borderWidth); default: // Should never happen! Debug.Assert(false); return Padding.Empty; } } else return Padding.Empty; }
/// <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; }