/// <summary> /// Perform drawing of a separator glyph. /// </summary> /// <param name="context">Render context.</param> /// <param name="displayRect">Display area available for drawing.</param> /// <param name="paletteBack">Background palette details.</param> /// <param name="paletteBorder">Border palette details.</param> /// <param name="orientation">Visual orientation of the content.</param> /// <param name="state">State associated with rendering.</param> /// <param name="canMove">Can the separator be moved.</param> public override void DrawSeparator(RenderContext context, Rectangle displayRect, IPaletteBack paletteBack, IPaletteBorder paletteBorder, Orientation orientation, PaletteState state, bool canMove) { // Let base class perform standard processing base.DrawSeparator(context, displayRect, paletteBack, paletteBorder, orientation, state, canMove); // If we are drawing the background then draw grab handles on top if (paletteBack.GetBackDraw(state) == InheritBool.True) { // Only draw grab handle if the user can move the separator if (canMove) DrawGrabHandleGlyph(context, displayRect, orientation, state); } }
/// <summary> /// Initialize a new instance of the ViewDrawForm class. /// </summary> /// <param name="paletteBack">Palette source for the background.</param> /// <param name="paletteBorder">Palette source for the border.</param> public ViewDrawForm(IPaletteBack paletteBack, IPaletteBorder paletteBorder) : base(paletteBack, paletteBorder) { // Create a status strip we can position for rendering _renderStrip = new StatusStrip(); }
/// <summary> /// Initialize a new instance of the ViewDrawRibbonAppMenu class. /// </summary> /// <param name="paletteBack">Palette source for the background.</param> /// <param name="paletteBorder">Palette source for the border.</param> /// <param name="fixedElement">Element to display at provided screen rect.</param> /// <param name="fixedScreenRect">Screen rectangle for showing the element at.</param> public ViewDrawRibbonAppMenu(IPaletteBack paletteBack, IPaletteBorder paletteBorder, ViewBase fixedElement, Rectangle fixedScreenRect) : base(paletteBack, paletteBorder) { _fixedElement = fixedElement; _fixedScreenRect = fixedScreenRect; }
/// <summary> /// Initialize a new instance of the ViewDrawDocker class. /// </summary> /// <param name="paletteBack">Palette source for the background.</param> /// <param name="paletteBorder">Palette source for the border.</param> /// <param name="paletteMetric">Palette source for metrics.</param> /// <param name="metricOverlay">Metric to use for border overlay.</param> public ViewDrawDocker(IPaletteBack paletteBack, IPaletteBorder paletteBorder, IPaletteMetric paletteMetric, PaletteMetricBool metricOverlay) : this(paletteBack, paletteBorder, paletteMetric, metricOverlay, PaletteMetricPadding.None, VisualOrientation.Top) { }
/// <summary> /// Initialize a new instance of the ViewDrawMenuImageCanvas class. /// </summary> /// <param name="paletteBack">Palette source for the background.</param> /// <param name="paletteBorder">Palette source for the border.</param> /// <param name="columnIndex">Menu item column index.</param> /// <param name="zeroHeight">Should the height be forced to zero.</param> public ViewDrawMenuImageCanvas(IPaletteBack paletteBack, IPaletteBorder paletteBorder, int columnIndex, bool zeroHeight) : base(paletteBack, paletteBorder, VisualOrientation.Top) { _columnIndex = columnIndex; _overridePreferredWidth = 0; _zeroHeight = zeroHeight; }
/// <summary> /// Initialize a new instance of the ViewDrawCanvas class. /// </summary> /// <param name="paletteBack">Palette source for the background.</param> /// <param name="paletteBorder">Palette source for the border.</param> /// <param name="orientation">Visual orientation of the content.</param> public ViewDrawCanvas(IPaletteBack paletteBack, IPaletteBorder paletteBorder, VisualOrientation orientation) : this(paletteBack, paletteBorder, null, PaletteMetricPadding.HeaderGroupPaddingPrimary, orientation) { }
/// <summary> /// Initialize a new instance of the PaletteBorderInheritForced class. /// </summary> /// <param name="inherit">Border palette to inherit from.</param> public PaletteBorderInheritForced(IPaletteBorder inherit) { // Remember inheritance border _inherit = inherit; // Default values _maxBorderEdges = PaletteDrawBorders.All; _forceGraphicsHint = PaletteGraphicsHint.Inherit; _borderIgnoreNormal = false; }
/// <summary> /// Initialize a new instance of the PaletteBorder class. /// </summary> /// <param name="inherit">Source for inheriting defaulted values.</param> /// <param name="needPaint">Delegate for notifying paint requests.</param> public PaletteBorder(IPaletteBorder inherit, NeedPaintHandler needPaint) { Debug.Assert(inherit != null); // Remember inheritance _inherit = inherit; // Store the provided paint notification delegate NeedPaint = needPaint; }
/// <summary> /// Initialize a new instance of the ViewDrawRibbonKeyTip class. /// </summary> /// <param name="keyTipInfo">Key tip information to display.</param> /// <param name="paletteBack">Background palette for appearance.</param> /// <param name="paletteBorder">Border palette for appearance.</param> /// <param name="paletteContent">Content palette for appearance.</param> public ViewDrawRibbonKeyTip(KeyTipInfo keyTipInfo, IPaletteBack paletteBack, IPaletteBorder paletteBorder, IPaletteContent paletteContent) : base(paletteBack, paletteBorder) { _keyTipInfo = keyTipInfo; // Create view for the key tip text _drawContent = new ViewDrawContent(paletteContent, this, VisualOrientation.Top); // Add content as filler for ourself Add(_drawContent, ViewDockStyle.Fill); }
/// <summary> /// Initialize a new instance of the PaletteBorderInheritOverride class. /// </summary> /// <param name="primary">First choice inheritence.</param> /// <param name="backup">Backup inheritence.</param> public PaletteBorderInheritOverride(IPaletteBorder primary, IPaletteBorder backup) { Debug.Assert(primary != null); Debug.Assert(backup != null); // Store incoming alternatives _primary = primary; _backup = backup; // Default other state _apply = true; _override = true; _state = PaletteState.Normal; }
/// <summary> /// Initialize a new instance of the PaletteBorderEdge class. /// </summary> /// <param name="inherit">Source for inheriting defaulted values.</param> /// <param name="needPaint">Delegate for notifying paint requests.</param> public PaletteBorderEdgeRedirect(IPaletteBorder inherit, NeedPaintHandler needPaint) : base(null, needPaint) { // Remember inheritance _inherit = inherit; // Default properties _borderWidth = -1; // Create the helper object that passes background // requests from the base clas and converts them into // border requests on ourself. _translate = new BackToBorder(this); SetInherit(_translate); }
/// <summary> /// Initialize a new instance of the ViewDrawCanvas class. /// </summary> /// <param name="paletteBack">Palette source for the background.</param> /// <param name="paletteBorder">Palette source for the border.</param> /// <param name="paletteMetric">Palette source for metric values.</param> /// <param name="metricPadding">Matric used to get padding values.</param> /// <param name="orientation">Visual orientation of the content.</param> public ViewDrawCanvas(IPaletteBack paletteBack, IPaletteBorder paletteBorder, IPaletteMetric paletteMetric, PaletteMetricPadding metricPadding, VisualOrientation orientation) { // Cache the starting values _paletteBorder = paletteBorder; _paletteBack = paletteBack; _paletteMetric = paletteMetric; _metricPadding = metricPadding; _orientation = orientation; _includeBorderEdge = orientation; _applyIncludeBorderEdge = false; _drawTabBorder = false; _drawCanvas = true; }
/// <summary> /// Initialize a new instance of the ViewDrawSplitCanvas class. /// </summary> /// <param name="paletteBack">Palette source for the background.</param> /// <param name="paletteBorder">Palette source for the border.</param> /// <param name="paletteMetric">Palette source for metric values.</param> /// <param name="metricPadding">Matric used to get padding values.</param> /// <param name="orientation">Visual orientation of the content.</param> public ViewDrawSplitCanvas(IPaletteBack paletteBack, IPaletteBorder paletteBorder, IPaletteMetric paletteMetric, PaletteMetricPadding metricPadding, VisualOrientation orientation) { // Cache the starting values _paletteBorder = paletteBorder; _paletteBack = paletteBack; _paletteBackDraw = new PaletteBackInheritForced(_paletteBack); _paletteBackDraw.ForceDraw = InheritBool.True; _paletteBackLight = new PaletteBackLightenColors(_paletteBack); _paletteMetric = paletteMetric; _paletteBorderNormal = paletteBorder; _paletteBackNormal = paletteBack; _metricPadding = metricPadding; _orientation = orientation; _drawTabBorder = false; _drawCanvas = true; _splitter = false; }
/// <summary> /// Initialize a new instance of the ViewDrawRibbonGroupButtonBackBorder class. /// </summary> /// <param name="ribbon">Reference to owning ribbon control.</param> /// <param name="groupItem">Reference to owning group item.</param> /// <param name="paletteBack">Palette to use for the background.</param> /// <param name="paletteBorder">Palette to use for the border.</param> /// <param name="constantBorder">Should the border be a constant normal state.</param> /// <param name="needPaint">Delegate for notifying paint requests.</param> public ViewDrawRibbonGroupButtonBackBorder(KryptonRibbon ribbon, KryptonRibbonGroupItem groupItem, IPaletteBack paletteBack, IPaletteBorder paletteBorder, bool constantBorder, NeedPaintHandler needPaint) { Debug.Assert(ribbon != null); Debug.Assert(groupItem != null); Debug.Assert(paletteBack != null); Debug.Assert(paletteBorder != null); // Remember incoming references _ribbon = ribbon; _groupItem = groupItem; _paletteBack = paletteBack; _paletteBackDraw = new PaletteBackInheritForced(paletteBack); _paletteBackDraw.ForceDraw = InheritBool.True; _paletteBackLight = new PaletteBackLightenColors(paletteBack); _paletteBorderAll = new PaletteBorderInheritForced(paletteBorder); _paletteBorderAll.ForceBorderEdges(PaletteDrawBorders.All); _paletteBorder = paletteBorder; _constantBorder = constantBorder; // Default other fields _checked = false; _drawNonTrackingAreas = true; // Create delegate used to process end of click action _finishDelegate = new EventHandler(ActionFinished); // Attach a controller to this element for the pressing of the button _controller = new GroupButtonController(_ribbon, this, needPaint); _controller.Click += new EventHandler(OnClick); _controller.ContextClick += new MouseEventHandler(OnContextClick); _controller.DropDown += new EventHandler(OnDropDown); MouseController = _controller; SourceController = _controller; KeyController = _controller; }
/// <summary> /// Gets the graphics drawing hint for the border. /// </summary> /// <param name="style">Border style.</param> /// <param name="state">Palette value should be applicable to this state.</param> /// <returns>PaletteGraphicsHint value.</returns> public override PaletteGraphicsHint GetBorderGraphicsHint(PaletteBorderStyle style, PaletteState state) { IPaletteBorder inherit = GetInherit(state); return(inherit?.GetBorderGraphicsHint(state) ?? Target.GetBorderGraphicsHint(style, state)); }
private void DrawBorder(IPaletteBorder paletteBorder, RenderContext context, Rectangle rect, PaletteState state) { // Do we need to draw the border? if (paletteBorder.GetBorderDraw(state) == InheritBool.True) context.Renderer.RenderStandardBorder.DrawBorder(context, rect, paletteBorder, VisualOrientation.Top, state); }
/// <summary> /// Sets the inheritence parent. /// </summary> public void SetInherit(IPaletteBorder inherit) { _inherit = inherit; }
/// <summary> /// Update the source palettes for drawing. /// </summary> /// <param name="paletteBack">Palette source for the background.</param> /// <param name="paletteBorder">Palette source for the border.</param> /// <param name="paletteMetric">Palette source for the metric.</param> public virtual void SetPalettes(IPaletteBack paletteBack, IPaletteBorder paletteBorder, IPaletteMetric paletteMetric) { Debug.Assert(paletteBorder != null); Debug.Assert(paletteBack != null); // Use newly provided palettes _paletteBack = paletteBack; // If not using a forced override decorator, then just store the new border palette // otherwise we update the decorator with the palette as the new inheritance to use if (_borderForced == null) _paletteBorder = paletteBorder; else _borderForced.SetInherit(paletteBorder); _paletteMetric = paletteMetric; }
/// <summary> /// Update the source palettes for drawing. /// </summary> /// <param name="paletteBack">Palette source for the background.</param> /// <param name="paletteBorder">Palette source for the border.</param> public virtual void SetPalettes(IPaletteBack paletteBack, IPaletteBorder paletteBorder) { SetPalettes(paletteBack, paletteBorder, null); }
private void DrawBackground(RenderContext context, Rectangle rect, IPaletteBack paletteBack, IPaletteBorder paletteBorder, PaletteState state) { GraphicsPath borderPath; Padding borderPadding; // Ask the border renderer for a path that encloses the border if (DrawTabBorder) { borderPath = context.Renderer.RenderTabBorder.GetTabBackPath(context, rect, paletteBorder, Orientation, state, TabBorderStyle); borderPadding = Padding.Empty; } else { borderPath = context.Renderer.RenderStandardBorder.GetBackPath(context, rect, paletteBorder, Orientation, state); borderPadding = context.Renderer.RenderStandardBorder.GetBorderRawPadding(paletteBorder, state, Orientation); } // Apply the padding depending on the orientation Rectangle enclosingRect = CommonHelper.ApplyPadding(_orientation, rect, borderPadding); // Render the background inside the border path _mementoBack = context.Renderer.RenderStandardBack.DrawBack(context, enclosingRect, borderPath, paletteBack, _orientation, state, _mementoBack); borderPath.Dispose(); }
/// <summary> /// Initialize a new instance of the PaletteRedirectBorder class. /// </summary> /// <param name="target">Initial palette target for redirection.</param> /// <param name="disabled">Redirection for disabled state requests.</param> /// <param name="normal">Redirection for normal state requests.</param> public PaletteRedirectBorder(IPalette target, IPaletteBorder disabled, IPaletteBorder normal) : this(target, disabled, normal, null, null, null, null, null, null, null) { }
/// <summary> /// Gets the padding used to position display elements completely inside border drawing. /// </summary> /// <param name="context">View layout context.</param> /// <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> /// <param name="tabBorderStyle">Style of tab border.</param> /// <returns>Padding structure detailing all four edges.</returns> public override Padding GetTabBorderDisplayPadding(ViewLayoutContext context, IPaletteBorder palette, PaletteState state, VisualOrientation orientation, TabBorderStyle tabBorderStyle) { Debug.Assert(palette != null); // Validate parameter reference if (palette == null) throw new ArgumentNullException("palette"); // Get the width of the border int borderWidth = palette.GetBorderWidth(state); // Cache the right to left setting bool rtl = (context.Control.RightToLeft == RightToLeft.Yes); Padding ret = Padding.Empty; switch (tabBorderStyle) { case TabBorderStyle.DockEqual: case TabBorderStyle.SquareEqualMedium: case TabBorderStyle.SquareEqualSmall: case TabBorderStyle.SquareEqualLarge: case TabBorderStyle.RoundedEqualMedium: case TabBorderStyle.RoundedEqualSmall: case TabBorderStyle.RoundedEqualLarge: ret = new Padding(borderWidth, borderWidth, borderWidth, 0); break; case TabBorderStyle.DockOutsize: ret = new Padding(borderWidth + _spacingTabDockOutsize, borderWidth + _spacingTabSquareOutsizeLarge, borderWidth + _spacingTabDockOutsize, 0); break; case TabBorderStyle.SquareOutsizeMedium: case TabBorderStyle.SquareOutsizeSmall: case TabBorderStyle.SquareOutsizeLarge: case TabBorderStyle.RoundedOutsizeMedium: case TabBorderStyle.RoundedOutsizeSmall: case TabBorderStyle.RoundedOutsizeLarge: ret = new Padding(borderWidth + _spacingTabOutsizePadding, borderWidth + _spacingTabOutsizePadding, borderWidth + _spacingTabOutsizePadding, 0); break; case TabBorderStyle.SlantEqualNear: case TabBorderStyle.SlantOutsizeNear: // Calculte the extra needed for the outsize variant int x = (tabBorderStyle == TabBorderStyle.SlantOutsizeNear ? _spacingTabOutsizePadding : 0); switch(orientation) { case VisualOrientation.Top: if (rtl) ret = new Padding(borderWidth + x, borderWidth + x, borderWidth + x + _spacingTabSlantPadding - 1, 0); else ret = new Padding(borderWidth + x + _spacingTabSlantPadding - 1, borderWidth + x, borderWidth + x, 0); break; case VisualOrientation.Left: ret = new Padding(borderWidth + x + _spacingTabSlantPadding - 1, borderWidth + x, borderWidth + x, 0); break; case VisualOrientation.Right: ret = new Padding(borderWidth + x, borderWidth + x, borderWidth + x + _spacingTabSlantPadding - 1, 0); break; case VisualOrientation.Bottom: if (rtl) ret = new Padding(borderWidth + x + _spacingTabSlantPadding - 1, borderWidth + x, borderWidth + x, 0); else ret = new Padding(borderWidth + x, borderWidth + x, borderWidth + x + _spacingTabSlantPadding - 1, 0); break; } break; case TabBorderStyle.SlantEqualFar: case TabBorderStyle.SlantOutsizeFar: // Calculte the extra needed for the outsize variant int y = (tabBorderStyle == TabBorderStyle.SlantOutsizeFar ? _spacingTabOutsizePadding : 0); switch (orientation) { case VisualOrientation.Top: if (rtl) ret = new Padding(borderWidth + y + _spacingTabSlantPadding - 1, borderWidth + y, borderWidth + y, 0); else ret = new Padding(borderWidth + y, borderWidth + y, borderWidth + y + _spacingTabSlantPadding - 1, 0); break; case VisualOrientation.Left: ret = new Padding(borderWidth + y, borderWidth + y, borderWidth + y + _spacingTabSlantPadding - 1, 0); break; case VisualOrientation.Right: ret = new Padding(borderWidth + y + _spacingTabSlantPadding - 1, borderWidth + y, borderWidth + y, 0); break; case VisualOrientation.Bottom: if (rtl) ret = new Padding(borderWidth + y, borderWidth + y, borderWidth + y + _spacingTabSlantPadding - 1, 0); else ret = new Padding(borderWidth + y + _spacingTabSlantPadding - 1, borderWidth + y, borderWidth + y, 0); break; } break; case TabBorderStyle.SlantEqualBoth: case TabBorderStyle.SlantOutsizeBoth: // Calculte the extra needed for the outsize variant int z = (tabBorderStyle == TabBorderStyle.SlantOutsizeBoth ? _spacingTabOutsizePadding : 0); ret = new Padding(borderWidth + z + _spacingTabSlantPadding - 1, borderWidth + z, borderWidth + z + _spacingTabSlantPadding - 1, 0); break; case TabBorderStyle.OneNote: // Is the current tab selected? bool selected = (state == PaletteState.CheckedNormal) || (state == PaletteState.CheckedPressed) || (state == PaletteState.CheckedTracking); // Find the correct edge padding values to use int lp = (selected ? _spacingTabOneNoteLPS : _spacingTabOneNoteLPI); int tp = (selected ? _spacingTabOneNoteTPS : _spacingTabOneNoteTPI); int bp = (selected ? _spacingTabOneNoteBPS : _spacingTabOneNoteBPI); int rp = (selected ? _spacingTabOneNoteRPS : _spacingTabOneNoteRPI); switch (orientation) { case VisualOrientation.Top: if (rtl) ret = new Padding(borderWidth + rp, borderWidth + tp, borderWidth + lp, bp); else ret = new Padding(borderWidth + lp, borderWidth + tp, borderWidth + rp, bp); break; case VisualOrientation.Left: ret = new Padding(borderWidth + rp, borderWidth + tp, borderWidth + lp, bp); break; case VisualOrientation.Right: ret = new Padding(borderWidth + lp, borderWidth + tp, borderWidth + rp, bp); break; case VisualOrientation.Bottom: if (rtl) ret = new Padding(borderWidth + lp, borderWidth + tp, borderWidth + rp, bp); else ret = new Padding(borderWidth + rp, borderWidth + tp, borderWidth + lp, bp); break; } break; case TabBorderStyle.SmoothEqual: ret = new Padding(borderWidth + _spacingTabSmoothLRE, borderWidth + _spacingTabSmoothTE, borderWidth + _spacingTabSmoothLRE, 0); break; case TabBorderStyle.SmoothOutsize: ret = new Padding(borderWidth + _spacingTabSmoothLRO, borderWidth + _spacingTabSmoothTO, borderWidth + _spacingTabSmoothLRO, 0); break; default: // Should never happen! Debug.Assert(false); break; } return ret; }
/// <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> /// 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> /// Set the redirection states. /// </summary> /// <param name="disabled">Redirection for disabled state requests.</param> /// <param name="normal">Redirection for normal state requests.</param> public virtual void SetRedirectStates(IPaletteBorder disabled, IPaletteBorder normal) { _disabled = disabled; _normal = normal; }
/// <summary> /// Initialize a new instance of the PaletteTabBorder class. /// </summary> /// <param name="inherit">Source for inheriting defaulted values.</param> /// <param name="needPaint">Delegate for notifying paint requests.</param> public PaletteTabBorder(IPaletteBorder inherit, NeedPaintHandler needPaint) : base(inherit, needPaint) { }
private void RenderCollapsedPressedBefore(RenderContext context) { switch (_lastRibbonShape) { default: case PaletteRibbonShape.Office2007: { IPaletteBack paletteBack = _ribbon.StateCommon.RibbonGroupCollapsedButton.PaletteBack; IPaletteBorder paletteBorder = _ribbon.StateCommon.RibbonGroupCollapsedButton.PaletteBorder; // Do we need to draw the background? if (paletteBack.GetBackDraw(PaletteState.Pressed) == InheritBool.True) { // Get the border path which the background is clipped to drawing within using (GraphicsPath borderPath = context.Renderer.RenderStandardBorder.GetBackPath(context, ClientRectangle, paletteBorder, VisualOrientation.Top, PaletteState.Pressed)) { Padding borderPadding = context.Renderer.RenderStandardBorder.GetBorderRawPadding(paletteBorder, PaletteState.Pressed, VisualOrientation.Top); // Apply the padding depending on the orientation Rectangle enclosingRect = CommonHelper.ApplyPadding(VisualOrientation.Top, ClientRectangle, borderPadding); // Render the background inside the border path _mementoStandardBack = context.Renderer.RenderStandardBack.DrawBack(context, enclosingRect, borderPath, paletteBack, VisualOrientation.Top, PaletteState.Pressed, _mementoStandardBack); } } // Do we need to draw the border? if (paletteBorder.GetBorderDraw(PaletteState.Pressed) == InheritBool.True) { context.Renderer.RenderStandardBorder.DrawBorder(context, ClientRectangle, paletteBorder, VisualOrientation.Top, PaletteState.Pressed); } } break; case PaletteRibbonShape.Office2010: { Rectangle drawRect = ClientRectangle; IPaletteRibbonBack paletteBack = _ribbon.StatePressed.RibbonGroupCollapsedBack; IPaletteRibbonBack paletteBorder = _ribbon.StatePressed.RibbonGroupCollapsedBorder; PaletteState state = PaletteState.Pressed; // Are we a group inside a context tab? if ((_ribbon.SelectedTab != null) && !string.IsNullOrEmpty(_ribbon.SelectedTab.ContextName)) { state = PaletteState.ContextPressed; } // Draw the group border _paletteContextBack.SetInherit(paletteBorder); _mementoRibbonBack1 = context.Renderer.RenderRibbon.DrawRibbonBack(_ribbon.RibbonShape, context, drawRect, state, _paletteContextBack, VisualOrientation.Top, false, _mementoRibbonBack1); Rectangle backRect = drawRect; backRect.Inflate(-2, -2); // Draw the inside background _mementoRibbonBack2 = context.Renderer.RenderRibbon.DrawRibbonBack(_ribbon.RibbonShape, context, backRect, state, paletteBack, VisualOrientation.Top, false, _mementoRibbonBack2); } break; } }
/// <summary> /// Gets and sets the palette to inherit from. /// </summary> public void SetInherit(IPaletteBorder paletteBorder) { Debug.Assert(paletteBorder != null); _inherit = paletteBorder; }
/// <summary> /// Generate a graphics path that encloses the border itself. /// </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> /// <param name="tabBorderStyle">Style of tab border.</param> /// <returns>GraphicsPath instance.</returns> public override GraphicsPath GetTabBorderPath(RenderContext context, Rectangle rect, IPaletteBorder palette, VisualOrientation orientation, PaletteState state, TabBorderStyle tabBorderStyle) { 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 in middle of the pen return CreateTabBorderBackPath(context.Control.RightToLeft, state, false, rect, palette.GetBorderWidth(state), tabBorderStyle, orientation, (palette.GetBorderGraphicsHint(state) == PaletteGraphicsHint.AntiAlias)); }
/// <summary> /// Gets the color border drawing style. /// </summary> /// <param name="style">Border style.</param> /// <param name="state">Palette value should be applicable to this state.</param> /// <returns>Color drawing style.</returns> public override PaletteColorStyle GetBorderColorStyle(PaletteBorderStyle style, PaletteState state) { IPaletteBorder inherit = GetInherit(state); return(inherit?.GetBorderColorStyle(state) ?? Target.GetBorderColorStyle(style, state)); }
/// <summary> /// Update the source palettes for drawing. /// </summary> /// <param name="paletteBack">Palette source for the background.</param> /// <param name="paletteBorder">Palette source for the border.</param> public virtual void SetPalettes(IPaletteBack paletteBack, IPaletteBorder paletteBorder) { SetPalettes(paletteBack, paletteBorder, _paletteMetric); }
/// <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)); }
private void DrawBorder(RenderContext context, Rectangle rect, IPaletteBorder paletteBorder, PaletteState state) { // Render the border over the background and children if (DrawTabBorder) context.Renderer.RenderTabBorder.DrawTabBorder(context, rect, _paletteBorder, _orientation, state, TabBorderStyle); else context.Renderer.RenderStandardBorder.DrawBorder(context, rect, _paletteBorder, _orientation, state); }
/// <summary> /// Initialize a new instance of the ViewDrawDocker class. /// </summary> /// <param name="paletteBack">Palette source for the background.</param> /// <param name="paletteBorder">Palette source for the border.</param> /// <param name="paletteMetric">Palette source for metrics.</param> public ViewDrawDocker(IPaletteBack paletteBack, IPaletteBorder paletteBorder, IPaletteMetric paletteMetric) : this(paletteBack, paletteBorder, paletteMetric, PaletteMetricBool.None) { }
/// <summary> /// Perform drawing of a separator glyph. /// </summary> /// <param name="context">Render context.</param> /// <param name="displayRect">Display area available for drawing.</param> /// <param name="paletteBack">Background palette details.</param> /// <param name="paletteBorder">Border palette details.</param> /// <param name="orientation">Visual orientation of the content.</param> /// <param name="state">State associated with rendering.</param> /// <param name="canMove">Can the separator be moved.</param> public abstract void DrawSeparator(RenderContext context, Rectangle displayRect, IPaletteBack paletteBack, IPaletteBorder paletteBorder, Orientation orientation, PaletteState state, bool canMove);
/// <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 abstract bool EvalTransparentPaint(IPaletteBack paletteBack, IPaletteBorder paletteBorder, PaletteState state);
/// <summary> /// the main difference with a Group row and a regular row is the way it is painted on the control. /// the Paint method is therefore overridden and specifies how the Group row is painted. /// Note: this method is not implemented optimally. It is merely used for demonstration purposes /// </summary> /// <param name="graphics"></param> /// <param name="clipBounds"></param> /// <param name="rowBounds"></param> /// <param name="rowIndex"></param> /// <param name="rowState"></param> /// <param name="isFirstDisplayedRow"></param> /// <param name="isLastVisibleRow"></param> protected override void Paint(System.Drawing.Graphics graphics, System.Drawing.Rectangle clipBounds, Rectangle rowBounds, int rowIndex, DataGridViewElementStates rowState, bool isFirstDisplayedRow, bool isLastVisibleRow) { if (this.isGroupRow) { KryptonOutlookGrid grid = (KryptonOutlookGrid)this.DataGridView; int rowHeadersWidth = grid.RowHeadersVisible ? grid.RowHeadersWidth : 0; int gridwidth = grid.Columns.GetColumnsWidth(DataGridViewElementStates.Visible); Rectangle myRowBounds = rowBounds; myRowBounds.Width = gridwidth; IPaletteBack paletteBack = grid.StateNormal.DataCell.Back; IPaletteBorder paletteBorder = grid.StateNormal.DataCell.Border; PaletteState state = PaletteState.Normal; if (grid.PreviousSelectedGroupRow == rowIndex) { state = PaletteState.CheckedNormal; } using (RenderContext renderContext = new RenderContext(grid, graphics, myRowBounds, grid.Renderer)) { using (GraphicsPath path = grid.Renderer.RenderStandardBorder.GetBackPath(renderContext, myRowBounds, paletteBorder, VisualOrientation.Top, PaletteState.Normal)) { //Back IDisposable unused = grid.Renderer.RenderStandardBack.DrawBack(renderContext, myRowBounds, path, paletteBack, VisualOrientation.Top, state, null); // We never save the memento for reuse later if (unused != null) { unused.Dispose(); unused = null; } } } //Set the icon and lines according to the renderer if (group.Collapsed) { if (KryptonManager.CurrentGlobalPalette.GetRenderer() == KryptonManager.RenderOffice2010) { graphics.DrawImage(Properties.Resources.CollapseIcon2010, rowBounds.Left + rowHeadersWidth - grid.HorizontalScrollingOffset + 4 + group.Level * 15, rowBounds.Bottom - 18, 11, 11); } else { graphics.DrawImage(Properties.Resources.ExpandIcon, rowBounds.Left + rowHeadersWidth - grid.HorizontalScrollingOffset + 4 + group.Level * 15, rowBounds.Bottom - 18, 11, 11); } } else { if (KryptonManager.CurrentGlobalPalette.GetRenderer() == KryptonManager.RenderOffice2010) { graphics.DrawImage(Properties.Resources.ExpandIcon2010, rowBounds.Left + rowHeadersWidth - grid.HorizontalScrollingOffset + 4 + group.Level * 15, rowBounds.Bottom - 18, 11, 11); } else { graphics.DrawImage(Properties.Resources.CollapseIcon, rowBounds.Left + rowHeadersWidth - grid.HorizontalScrollingOffset + 4 + group.Level * 15, rowBounds.Bottom - 18, 11, 11); } } // Draw the botton : solid line for 2007 palettes or dot line for 2010 palettes if (KryptonManager.CurrentGlobalPalette.GetRenderer() == KryptonManager.RenderOffice2010) { using (Pen focusPen = new Pen(Color.Gray)) { focusPen.DashStyle = System.Drawing.Drawing2D.DashStyle.Dash; graphics.DrawLine(focusPen, rowBounds.Left + rowHeadersWidth - grid.HorizontalScrollingOffset, rowBounds.Bottom - 1, gridwidth + 1, rowBounds.Bottom - 1); } } else { using (SolidBrush br = new SolidBrush(paletteBorder.GetBorderColor1(state))) { graphics.FillRectangle(br, rowBounds.Left + rowHeadersWidth - grid.HorizontalScrollingOffset, rowBounds.Bottom - 2, gridwidth + 1, 2); } } //Draw right vertical bar if (grid.CellBorderStyle == DataGridViewCellBorderStyle.SingleVertical || grid.CellBorderStyle == DataGridViewCellBorderStyle.Single) { using (SolidBrush br = new SolidBrush(paletteBorder.GetBorderColor1(state))) { graphics.FillRectangle(br, rowBounds.Left + rowHeadersWidth - grid.HorizontalScrollingOffset + gridwidth, rowBounds.Top, 1, rowBounds.Height); } } //Draw image group int imageoffset = 0; if (this.group.GroupImage != null) { graphics.DrawImage(this.group.GroupImage, rowHeadersWidth - grid.HorizontalScrollingOffset + 18 + group.Level * 15, rowBounds.Bottom - 22, 16, 16); imageoffset = 18; } //Draw text, using the current grid font int offsetText = rowHeadersWidth - grid.HorizontalScrollingOffset + 18 + imageoffset + group.Level * 15; //grid.GridPalette.GetContentShortTextFont(PaletteContentStyle.GridHeaderColumnList, state) TextRenderer.DrawText(graphics, group.Text, grid.GridPalette.GetContentShortTextFont(PaletteContentStyle.LabelBoldControl, state), new Rectangle(offsetText, rowBounds.Bottom - 20, rowBounds.Width - offsetText, rowBounds.Height), grid.GridPalette.GetContentShortTextColor1(PaletteContentStyle.LabelNormalControl, state), TextFormatFlags.EndEllipsis | TextFormatFlags.SingleLine | TextFormatFlags.PreserveGraphicsClipping); } else { base.Paint(graphics, clipBounds, rowBounds, rowIndex, rowState, isFirstDisplayedRow, isLastVisibleRow); } }
/// <summary> /// Initialize a new instance of the BackToBorder class. /// </summary> /// <param name="parent">Parent to get border values from.</param> public BackToBorder(IPaletteBorder parent) { Debug.Assert(parent != null); _parent = parent; }
/// <summary> /// Initialize a new instance of the ViewDrawGroupBoxDocker class. /// </summary> /// <param name="paletteBack">Palette source for the background.</param> /// <param name="paletteBorder">Palette source for the border.</param> public ViewDrawGroupBoxDocker(IPaletteBack paletteBack, IPaletteBorder paletteBorder) : base(paletteBack, paletteBorder) { CaptionOverlap = 0.5; }
/// <summary> /// Gets the padding used to position display elements completely inside border drawing. /// </summary> /// <param name="context">Layout context.</param> /// <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> /// <param name="tabBorderStyle">Style of tab border.</param> /// <returns>Padding structure detailing all four edges.</returns> public abstract Padding GetTabBorderDisplayPadding(ViewLayoutContext context, IPaletteBorder palette, PaletteState state, VisualOrientation orientation, TabBorderStyle tabBorderStyle);
/// <summary> /// Gets the image border alignment. /// </summary> /// <param name="style">Border style.</param> /// <param name="state">Palette value should be applicable to this state.</param> /// <returns>Image alignment style.</returns> public override PaletteRectangleAlign GetBorderImageAlign(PaletteBorderStyle style, PaletteState state) { IPaletteBorder inherit = GetInherit(state); return(inherit?.GetBorderImageAlign(state) ?? Target.GetBorderImageAlign(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> /// <param name="tabBorderStyle">Style of tab border.</param> public abstract void DrawTabBorder(RenderContext context, Rectangle rect, IPaletteBorder palette, VisualOrientation orientation, PaletteState state, TabBorderStyle tabBorderStyle);
/// <summary> /// Update the source palettes for drawing. /// </summary> /// <param name="paletteBorder">Palette source for the border.</param> public virtual void SetPalette(IPaletteBorder paletteBorder) { _inherit = paletteBorder; }
/// <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 abstract Padding GetBorderRawPadding(IPaletteBorder palette, PaletteState state, VisualOrientation orientation);
/// <summary> /// Initialize a new instance of the ViewDrawGroupBoxDocker class. /// </summary> /// <param name="paletteBack">Palette source for the background.</param> /// <param name="paletteBorder">Palette source for the border.</param> public ViewDrawGroupBoxDocker(IPaletteBack paletteBack, IPaletteBorder paletteBorder) : base(paletteBack, paletteBorder) =>
/// <summary> /// Generate a graphics path that encloses the border itself. /// </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> /// <param name="tabBorderStyle">Style of tab border.</param> /// <returns>GraphicsPath instance.</returns> public abstract GraphicsPath GetTabBorderPath(RenderContext context, Rectangle rect, IPaletteBorder palette, VisualOrientation orientation, PaletteState state, TabBorderStyle tabBorderStyle);
/// <summary> /// Perform rendering before child elements are rendered. /// </summary> /// <param name="context">Rendering context.</param> public override void RenderBefore(RenderContext context) { // Update the enabled state of the button Enabled = _ribbon.Enabled; IPaletteBack paletteBack = _ribbon.StateCommon.RibbonGroupDialogButton.PaletteBack; IPaletteBorder paletteBorder = _ribbon.StateCommon.RibbonGroupDialogButton.PaletteBorder; IPaletteRibbonGeneral paletteGeneral = _ribbon.StateCommon.RibbonGeneral; if (_ribbon.RibbonShape == PaletteRibbonShape.NeoAxis) { paletteBack = _ribbon.StateCommon.RibbonQATButton.PaletteBack; paletteBorder = _ribbon.StateCommon.RibbonQATButton.PaletteBorder; paletteGeneral = _ribbon.StateCommon.RibbonGeneral; } // Do we need to draw the background? if (paletteBack.GetBackDraw(State) == InheritBool.True) { // Get the border path which the background is clipped to drawing within using (GraphicsPath borderPath = context.Renderer.RenderStandardBorder.GetBackPath(context, ClientRectangle, paletteBorder, VisualOrientation.Top, State)) { Padding borderPadding = context.Renderer.RenderStandardBorder.GetBorderRawPadding(paletteBorder, State, VisualOrientation.Top); // Apply the padding depending on the orientation Rectangle enclosingRect = CommonHelper.ApplyPadding(VisualOrientation.Top, ClientRectangle, borderPadding); // Render the background inside the border path _mementoBack = context.Renderer.RenderStandardBack.DrawBack(context, enclosingRect, borderPath, paletteBack, VisualOrientation.Top, State, _mementoBack); } } // Do we need to draw the border? if (paletteBorder.GetBorderDraw(State) == InheritBool.True) { context.Renderer.RenderStandardBorder.DrawBorder(context, ClientRectangle, paletteBorder, VisualOrientation.Top, State); } // Find the content area inside the button rectangle Rectangle contentRect = ClientRectangle; var contentSize = new Size(-(ClientRectangle.Width - _imageSize.Width) / 2, -(ClientRectangle.Height - _imageSize.Height) / 2); contentRect.Inflate(contentSize); bool isMinibar = _ribbon.QATLocation == QATLocation.Above; // Decide if we are drawing an overflow or context arrow image if (Overflow) { context.Renderer.RenderGlyph.DrawRibbonOverflow(_ribbon.RibbonShape, context, contentRect, paletteGeneral, State); } else { context.Renderer.RenderGlyph.DrawRibbonContextArrow(_ribbon.RibbonShape, context, contentRect, paletteGeneral, State, isMinibar); } }