private void RenderBorder(RenderContext context, Rectangle rect) { Debug.Assert(context != null); // Do we need to draw the border? if (_paletteBorder.GetBorderDraw(State) == InheritBool.True) { if (Splitter) { bool mouseInSplit = MouseInSplit; switch (State) { case PaletteState.Tracking: DrawBorder(context, rect, _paletteBorder, PaletteState.Tracking); break; case PaletteState.Pressed: DrawBorder(context, rect, _paletteBorder, PaletteState.Tracking); using (Clipping clipToSplitter = new Clipping(context.Graphics, (mouseInSplit ? _splitRectangle : _nonSplitRectangle))) DrawBorder(context, rect, _paletteBorder, PaletteState.Pressed); break; default: DrawBorder(context, rect, _paletteBorder, State); break; } } else { DrawBorder(context, rect, _paletteBorder, State); } } }
/// <summary> /// Gets a value indicating if border should be drawn. /// </summary> /// <param name="state">Palette value should be applicable to this state.</param> /// <returns>InheritBool value.</returns> public override InheritBool GetBorderDraw(PaletteState state) { if (Apply) { InheritBool ret = _primary.GetBorderDraw(Override ? OverrideState : state); if (ret == InheritBool.Inherit) { ret = _backup.GetBorderDraw(state); } return(ret); } else { return(_backup.GetBorderDraw(state)); } }
/// <summary> /// Gets the actual border draw value. /// </summary> /// <param name="state">Palette value should be applicable to this state.</param> /// <returns>InheritBool value.</returns> public InheritBool GetBorderDraw(PaletteState state) { if (Draw != InheritBool.Inherit) { return(Draw); } else { return(_inherit.GetBorderDraw(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> /// Gets a value indicating if border should be drawn. /// </summary> /// <param name="style">Border style.</param> /// <param name="state">Palette value should be applicable to this state.</param> /// <returns>InheritBool value.</returns> public override InheritBool GetBorderDraw(PaletteBorderStyle style, PaletteState state) { IPaletteBorder inherit = GetInherit(state); if (inherit != null) { return(inherit.GetBorderDraw(state)); } else { return(Target.GetBorderDraw(style, state)); } }
/// <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; // 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; contentRect.Inflate(_contentSize); // 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); } }
/// <summary> /// Draw the canvas border. /// </summary> /// <param name="context"></param> public virtual void RenderBorder(RenderContext context) { Debug.Assert(context != null); // Do we need to draw the border? if (_paletteBorder.GetBorderDraw(State) == InheritBool.True) { // Render the border over the background and children if (DrawTabBorder) { context.Renderer.RenderTabBorder.DrawTabBorder(context, ClientRectangle, _paletteBorder, Orientation, State, TabBorderStyle); } else { context.Renderer.RenderStandardBorder.DrawBorder(context, ClientRectangle, _paletteBorder, Orientation, State); } } }
/// <summary> /// Perform rendering before child elements are rendered. /// </summary> /// <param name="context">Rendering context.</param> public override void RenderBefore(RenderContext context) { // Make sure we reflect the current enabled state if (!Enabled && _ribbon.InDesignHelperMode) { ElementState = PaletteState.Disabled; } IPaletteBack paletteBack = _ribbon.StateCommon.RibbonQATButton.PaletteBack; IPaletteBorder paletteBorder = _ribbon.StateCommon.RibbonQATButton.PaletteBorder; IPaletteRibbonGeneral 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); } base.RenderBefore(context); }
/// <summary> /// Perform rendering before child elements are rendered. /// </summary> /// <param name="context">Rendering context.</param> public override void RenderBefore(RenderContext context) { IPaletteBack paletteBack = _ribbon.StateCommon.RibbonGroupDialogButton.PaletteBack; IPaletteBorder paletteBorder = _ribbon.StateCommon.RibbonGroupDialogButton.PaletteBorder; IPaletteRibbonGeneral 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; contentRect.Inflate(_contentSize); // Draw the dialog box launcher glyph in the center context.Renderer.RenderGlyph.DrawRibbonDialogBoxLauncher(_ribbon.RibbonShape, context, contentRect, paletteGeneral, State); }
/// <summary> /// Gets a value indicating if border should be drawn. /// </summary> /// <param name="style">Border style.</param> /// <param name="state">Palette value should be applicable to this state.</param> /// <returns>InheritBool value.</returns> public override InheritBool GetBorderDraw(PaletteBorderStyle style, PaletteState state) { IPaletteBorder inherit = GetInherit(state); return(inherit?.GetBorderDraw(state) ?? Target.GetBorderDraw(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> /// Gets a value indicating if border should be drawn. /// </summary> /// <param name="state">Palette value should be applicable to this state.</param> /// <returns>InheritBool value.</returns> public override InheritBool GetBorderDraw(PaletteState state) => _inherit.GetBorderDraw(state);
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> /// 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> /// 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) { Debug.Assert(context != null); Debug.Assert(paletteBack != null); Debug.Assert(paletteBorder != null); // Validate parameter references if (context == null) throw new ArgumentNullException("context"); if (paletteBack == null) throw new ArgumentNullException("paletteBack"); if (paletteBorder == null) throw new ArgumentNullException("paletteBorder"); Debug.Assert(context.Control != null); Debug.Assert(!context.Control.IsDisposed); // Do we need to draw the background? if (paletteBack.GetBackDraw(state) == InheritBool.True) { // Convert from separator orientation to border orientation value VisualOrientation borderOrientation = (orientation == Orientation.Horizontal ? VisualOrientation.Top : VisualOrientation.Left); // Ask the border renderer for a path that encloses the border using (GraphicsPath borderPath = context.Renderer.RenderStandardBorder.GetBackPath(context, displayRect, paletteBorder, borderOrientation, state)) { // Get the padding needed for the drawing area inside the border Padding borderPadding = context.Renderer.RenderStandardBorder.GetBorderRawPadding(paletteBorder, state, borderOrientation); // The area available for border drawing if the client rectangle with padding applied Rectangle enclosingRect = CommonHelper.ApplyPadding(borderOrientation, displayRect, borderPadding); // Convert from the two state orientation to our four state orientation VisualOrientation vo = (orientation == Orientation.Horizontal) ? VisualOrientation.Top : VisualOrientation.Left; // Render the background inside the border path context.Renderer.RenderStandardBack.DrawBack(context, enclosingRect, borderPath, paletteBack, vo, state, null); } } // Do we need to draw the border? if (paletteBorder.GetBorderDraw(state) == InheritBool.True) { // Convert from the two state orientation to our four state orientation VisualOrientation vo = (orientation == Orientation.Horizontal) ? VisualOrientation.Top : VisualOrientation.Left; // Render the border over the background and children context.Renderer.RenderStandardBorder.DrawBorder(context, displayRect, paletteBorder, vo, state); } }
/// <summary> /// Gets the actual border draw value. /// </summary> /// <param name="state">Palette value should be applicable to this state.</param> /// <returns>InheritBool value.</returns> public InheritBool GetBorderDraw(PaletteState state) { return(_inherit.GetBorderDraw(state)); }
/// <summary> /// Gets the actual background draw value. /// </summary> /// <param name="state">Palette value should be applicable to this state.</param> /// <returns>InheritBool value.</returns> public InheritBool GetBackDraw(PaletteState state) { return(_parent.GetBorderDraw(state)); }
/// <summary> /// Gets the actual background draw value. /// </summary> /// <param name="state">Palette value should be applicable to this state.</param> /// <returns>InheritBool value.</returns> public InheritBool GetBackDraw(PaletteState state) => _parent.GetBorderDraw(state);