/// <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 PaletteBackInheritNode class.
/// </summary>
/// <param name="inherit">Background palette to inherit from.</param>
public PaletteBackInheritNode(IPaletteBack inherit)
{
Debug.Assert(inherit != null);
// Remember inheritance border
_inherit = inherit;
}
/// <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 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 PaletteBack class.
/// </summary>
/// <param name="inherit">Source for inheriting defaulted values.</param>
/// <param name="needPaint">Delegate for notifying paint requests.</param>
public PaletteBack(IPaletteBack inherit,
NeedPaintHandler needPaint)
{
// Remember inheritance
_inherit = inherit;
// Store the provided paint notification delegate
NeedPaint = needPaint;
}
/// <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 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 PaletteBackInheritForced class.
/// </summary>
/// <param name="inherit">Background palette to inherit from.</param>
public PaletteBackInheritForced(IPaletteBack inherit)
{
Debug.Assert(inherit != null);
// Remember inheritance border
_inherit = inherit;
// Default values
_borderIgnoreNormal = false;
_forceGraphicsHint = PaletteGraphicsHint.Inherit;
}
/// <summary>
/// Initialize a new instance of the ViewDrawRibbonPanel class.
/// </summary>
/// <param name="ribbon">Reference to owning ribbon instance.</param>
/// <param name="paletteBack">Reference to palette for obtaining background colors.</param>
/// <param name="paintDelegate">Delegate for generating repaints.</param>
public ViewDrawRibbonPanel(KryptonRibbon ribbon,
IPaletteBack paletteBack,
NeedPaintHandler paintDelegate)
: base(paletteBack)
{
_ribbon = ribbon;
_paintDelegate = paintDelegate;
_compBlend = new Blend();
_compBlend.Positions = new float[] { 0.0f, 0.4f, 1.0f };
_compBlend.Factors = new float[] { 0.0f, 0.87f, 1.0f };
}
/// <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 PaletteInputControlBackStates class.
/// </summary>
/// <param name="inherit">Source for inheriting defaulted values.</param>
/// <param name="needPaint">Delegate for notifying paint requests.</param>
public PaletteInputControlBackStates(IPaletteBack inherit,
NeedPaintHandler needPaint)
{
Debug.Assert(inherit != null);
// Remember inheritance
_inherit = inherit;
// Store the provided paint notification delegate
NeedPaint = needPaint;
// Default the initial values
_color1 = Color.Empty;
}
/// <summary>
/// Initialize a new instance of the PaletteBackInheritOverride class.
/// </summary>
/// <param name="primary">First choice inheritence.</param>
/// <param name="backup">Backup inheritence.</param>
public PaletteBackInheritOverride(IPaletteBack primary,
IPaletteBack 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 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>
/// Perform drawing of a ribbon cluster edge.
/// </summary>
/// <param name="shape">Ribbon shape.</param>
/// <param name="context">Render context.</param>
/// <param name="displayRect">Display area available for drawing.</param>
/// <param name="paletteBack">Palette used for recovering drawing details.</param>
/// <param name="state">State associated with rendering.</param>
public override void DrawRibbonClusterEdge(PaletteRibbonShape shape,
RenderContext context,
Rectangle displayRect,
IPaletteBack paletteBack,
PaletteState state)
{
Debug.Assert(context != null);
Debug.Assert(paletteBack != null);
// Get the first border color
Color borderColor = paletteBack.GetBackColor1(state);
// We want to lighten it by merging with white
Color lightColor = CommonHelper.MergeColors(borderColor, BORDER_PERCENT,
Color.White, WHITE_PERCENT);
// Draw inside of the border edge in a lighter version of the border
using (SolidBrush drawBrush = new SolidBrush(lightColor))
context.Graphics.FillRectangle(drawBrush, displayRect);
}
/// <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>
/// Initialize a new instance of the PaletteRedirectBack 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>
/// <param name="pressed">Redirection for pressed state requests.</param>
/// <param name="tracking">Redirection for tracking state requests.</param>
/// <param name="checkedNormal">Redirection for checked normal state requests.</param>
/// <param name="checkedPressed">Redirection for checked pressed state requests.</param>
/// <param name="checkedTracking">Redirection for checked tracking state requests.</param>
/// <param name="focusOverride">Redirection for focus override state requests.</param>
/// <param name="normalDefaultOverride">Redirection for normal default override state requests.</param>
public PaletteRedirectBack(IPalette target,
IPaletteBack disabled,
IPaletteBack normal,
IPaletteBack pressed,
IPaletteBack tracking,
IPaletteBack checkedNormal,
IPaletteBack checkedPressed,
IPaletteBack checkedTracking,
IPaletteBack focusOverride,
IPaletteBack normalDefaultOverride)
: base(target)
{
// Remember state specific inheritance
_disabled = disabled;
_normal = normal;
_pressed = pressed;
_tracking = tracking;
_checkedNormal = checkedNormal;
_checkedPressed = checkedPressed;
_checkedTracking = checkedTracking;
_focusOverride = focusOverride;
_normalDefaultOverride = normalDefaultOverride;
}
/// <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)
{
_overlap = 0.5;
}
/// <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>
/// 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(IPaletteBack disabled,
IPaletteBack normal)
{
_disabled = disabled;
_normal = normal;
}
/// <summary>
/// Draw background to fill the specified path.
/// </summary>
/// <param name="context">Rendering context.</param>
/// <param name="rect">Target rectangle that encloses path.</param>
/// <param name="path">Graphics path.</param>
/// <param name="palette">Palette used for drawing.</param>
/// <param name="orientation">Visual orientation of the background.</param>
/// <param name="state">State associated with rendering.</param>
/// <param name="memento">Cache used for drawing.</param>
public abstract IDisposable DrawBack(RenderContext context,
Rectangle rect,
GraphicsPath path,
IPaletteBack palette,
VisualOrientation orientation,
PaletteState state,
IDisposable memento);
/// <summary>
/// Initialize a new instance of the ViewDrawPanel class.
/// </summary>
/// <param name="paletteBack">Palette source for the background.</param>
public ViewDrawPanel(IPaletteBack paletteBack)
{
Debug.Assert(paletteBack != null);
_paletteBack = paletteBack;
_orientation = VisualOrientation.Top;
}
/// <summary>
/// Gets a value indicating if background should be drawn.
/// </summary>
/// <param name="style">Background style.</param>
/// <param name="state">Palette value should be applicable to this state.</param>
/// <returns>InheritBool value.</returns>
public override InheritBool GetBackDraw(PaletteBackStyle style, PaletteState state)
{
IPaletteBack inherit = GetInherit(state);
return(inherit?.GetBackDraw(state) ?? Target.GetBackDraw(style, 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>
/// Gets the graphics drawing hint for the background.
/// </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 GetBackGraphicsHint(PaletteBackStyle style, PaletteState state)
{
IPaletteBack inherit = GetInherit(state);
return(inherit?.GetBackGraphicsHint(state) ?? Target.GetBackGraphicsHint(style, 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>
/// Initialize a new instance of the PaletteBackColor1 class.
/// </summary>
/// <param name="inherit">Source for inheriting defaulted values.</param>
/// <param name="needPaint">Delegate for notifying paint requests.</param>
public PaletteBackColor1(IPaletteBack inherit,
NeedPaintHandler needPaint)
: base(inherit, needPaint)
{
}
/// <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>
/// Sets the inheritence parent.
/// </summary>
public void SetInherit(IPaletteBack inherit)
{
_inherit = inherit;
}
/// <summary>
/// Initialize a new instance of the PaletteBackLightenColors class.
/// </summary>
/// <param name="inherit"></param>
public PaletteBackLightenColors(IPaletteBack inherit)
{
Inherit = inherit;
}
/// <summary>
/// Gets the background image style.
/// </summary>
/// <param name="style">Background style.</param>
/// <param name="state">Palette value should be applicable to this state.</param>
/// <returns>Image style value.</returns>
public override PaletteImageStyle GetBackImageStyle(PaletteBackStyle style, PaletteState state)
{
IPaletteBack inherit = GetInherit(state);
return(inherit?.GetBackImageStyle(state) ?? Target.GetBackImageStyle(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, null);
}
/// <summary>
/// Gets the color background angle.
/// </summary>
/// <param name="style">Background style.</param>
/// <param name="state">Palette value should be applicable to this state.</param>
/// <returns>Angle used for color drawing.</returns>
public override float GetBackColorAngle(PaletteBackStyle style, PaletteState state)
{
IPaletteBack inherit = GetInherit(state);
return(inherit?.GetBackColorAngle(state) ?? Target.GetBackColorAngle(style, state));
}
/// <summary>
/// Initialize a new instance of the ViewDrawPanel class.
/// </summary>
/// <param name="paletteBack">Palette source for the background.</param>
public ViewDrawPanel(IPaletteBack paletteBack)
{
Debug.Assert(paletteBack != null);
_paletteBack = paletteBack;
VisualOrientation = VisualOrientation.Top;
}
/// <summary>
/// Update the source palettes for drawing.
/// </summary>
/// <param name="paletteBack">Palette source for the background.</param>
public void SetPalettes(IPaletteBack paletteBack)
{
Debug.Assert(paletteBack != null);
// Use newly provided palettes
_paletteBack = paletteBack;
}
/// <summary>
/// Initialize a new instance of the PaletteRedirectBack 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 PaletteRedirectBack(IPalette target,
IPaletteBack disabled,
IPaletteBack normal)
: this(target, disabled, normal, null, null, null, null, null, null, null)
{
}
private void DrawBackground(IPaletteBack paletteBack,
RenderContext context,
Rectangle rect,
PaletteState state)
{
// 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, rect, _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, rect, borderPadding);
// Render the background inside the border path
_mementoBack = context.Renderer.RenderStandardBack.DrawBack(context, enclosingRect, borderPath,
paletteBack, VisualOrientation.Top,
state, _mementoBack);
}
}
}
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 PaletteBackLightenColors class.
/// </summary>
/// <param name="inherit"></param>
public PaletteBackLightenColors(IPaletteBack inherit)
{
_inherit = inherit;
}
/// <summary>
/// Gets the image alignment.
/// </summary>
/// <param name="style">Background style.</param>
/// <param name="state">Palette value should be applicable to this state.</param>
/// <returns>Image alignment style.</returns>
public override PaletteRectangleAlign GetBackImageAlign(PaletteBackStyle style, PaletteState state)
{
IPaletteBack inherit = GetInherit(state);
return(inherit?.GetBackImageAlign(state) ?? Target.GetBackImageAlign(style, state));
}
/// <summary>
/// Initialize a new instance of the PaletteBackColor1 class.
/// </summary>
/// <param name="inherit">Source for inheriting defaulted values.</param>
/// <param name="needPaint">Delegate for notifying paint requests.</param>
public PaletteBackColor1(IPaletteBack inherit,
NeedPaintHandler needPaint)
: base(inherit, needPaint)
{
}
/// <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);
}
/// <summary>
/// Perform drawing of a ribbon cluster edge.
/// </summary>
/// <param name="shape">Ribbon shape.</param>
/// <param name="context">Render context.</param>
/// <param name="displayRect">Display area available for drawing.</param>
/// <param name="paletteBack">Palette used for recovering drawing details.</param>
/// <param name="state">State associated with rendering.</param>
public abstract void DrawRibbonClusterEdge(PaletteRibbonShape shape,
RenderContext context,
Rectangle displayRect,
IPaletteBack paletteBack,
PaletteState state);
/// <summary>
/// Gets and sets the palette to inherit from.
/// </summary>
public void SetInherit(IPaletteBack paletteBack)
{
Debug.Assert(paletteBack != null);
_inherit = paletteBack;
}
/// <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>
/// 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);
}
}
