/// <summary>
/// Helper routine to draw an image taking into account various properties.
/// </summary>
/// <param name="context">Rendering context.</param>
/// <param name="image">Image to be drawn.</param>
/// <param name="remapTransparent">Color that should become transparent.</param>
/// <param name="imageRect">Destination rectangle.</param>
/// <param name="orientation">Visual orientation.</param>
/// <param name="effect">Drawing effect.</param>
/// <param name="remapColor">Image color to remap.</param>
/// <param name="remapNew">New color for remap.</param>
protected static void DrawImageHelper(ViewContext context,
Image image,
Color remapTransparent,
Rectangle imageRect,
VisualOrientation orientation,
PaletteImageEffect effect,
Color remapColor,
Color remapNew)
{
Debug.Assert(context != null);
// Prevent problems with multiple threads using the same palette images
// by only allowing a single thread to draw the provided image at a time
lock (_threadLock)
{
// Validate reference parameter
if (context == null) throw new ArgumentNullException("context");
// Use image attributes class to modify image drawing for effects
ImageAttributes attribs = new ImageAttributes();
switch (effect)
{
case PaletteImageEffect.Disabled:
attribs.SetColorMatrix(CommonHelper.MatrixDisabled);
break;
case PaletteImageEffect.GrayScale:
attribs.SetColorMatrix(_matrixGrayScale, ColorMatrixFlag.SkipGrays);
break;
case PaletteImageEffect.GrayScaleRed:
attribs.SetColorMatrix(_matrixGrayScaleRed, ColorMatrixFlag.SkipGrays);
break;
case PaletteImageEffect.GrayScaleGreen:
attribs.SetColorMatrix(_matrixGrayScaleGreen, ColorMatrixFlag.SkipGrays);
break;
case PaletteImageEffect.GrayScaleBlue:
attribs.SetColorMatrix(_matrixGrayScaleBlue, ColorMatrixFlag.SkipGrays);
break;
case PaletteImageEffect.Light:
attribs.SetColorMatrix(_matrixLight);
break;
case PaletteImageEffect.LightLight:
attribs.SetColorMatrix(_matrixLightLight);
break;
case PaletteImageEffect.Dark:
attribs.SetColorMatrix(_matrixDark);
break;
case PaletteImageEffect.DarkDark:
attribs.SetColorMatrix(_matrixDarkDark);
break;
case PaletteImageEffect.Inherit:
// Should never happen!
Debug.Assert(false);
break;
}
// Do we need to remap a colors in the bitmap?
if ((remapTransparent != Color.Empty) ||
((remapColor != Color.Empty) && (remapNew != Color.Empty)))
{
List<ColorMap> colorMaps = new List<ColorMap>();
// Create remapping for the transparent color
if (remapTransparent != Color.Empty)
{
ColorMap remap = new ColorMap();
remap.OldColor = remapTransparent;
remap.NewColor = Color.Transparent;
colorMaps.Add(remap);
}
// Create remapping from source to target colors
if ((remapColor != Color.Empty) && (remapNew != Color.Empty))
{
ColorMap remap = new ColorMap();
remap.OldColor = remapColor;
remap.NewColor = remapNew;
colorMaps.Add(remap);
}
attribs.SetRemapTable(colorMaps.ToArray(), ColorAdjustType.Bitmap);
}
int translateX = 0;
int translateY = 0;
float rotation = 0f;
// Perform any transformations needed for orientation
switch (orientation)
{
case VisualOrientation.Bottom:
// Translate to opposite side of origin, so the rotate can
// then bring it back to original position but mirror image
translateX = imageRect.X * 2 + imageRect.Width;
translateY = imageRect.Y * 2 + imageRect.Height;
rotation = 180f;
break;
case VisualOrientation.Left:
// Invert the dimensions of the rectangle for drawing upwards
imageRect = new Rectangle(imageRect.X, imageRect.Y, imageRect.Height, imageRect.Width);
// Translate back from a quarter left turn to the original place
translateX = imageRect.X - imageRect.Y;
translateY = imageRect.X + imageRect.Y + imageRect.Width;
rotation = -90f;
break;
case VisualOrientation.Right:
// Invert the dimensions of the rectangle for drawing upwards
imageRect = new Rectangle(imageRect.X, imageRect.Y, imageRect.Height, imageRect.Width);
// Translate back from a quarter right turn to the original place
translateX = imageRect.X + imageRect.Y + imageRect.Height;
translateY = -(imageRect.X - imageRect.Y);
rotation = 90f;
break;
}
// Apply the transforms if we have any to apply
if ((translateX != 0) || (translateY != 0))
context.Graphics.TranslateTransform(translateX, translateY);
if (rotation != 0f)
context.Graphics.RotateTransform(rotation);
try
{
// Finally, just draw the image and let the transforms do the rest
context.Graphics.DrawImage(image, imageRect, 0, 0, imageRect.Width, imageRect.Height, GraphicsUnit.Pixel, attribs);
}
catch (ArgumentException)
{
}
finally
{
if (rotation != 0f)
context.Graphics.RotateTransform(-rotation);
// Remove the applied transforms
if ((translateX != 0) | (translateY != 0))
context.Graphics.TranslateTransform(-translateX, -translateY);
}
}
}
/// <summary>
/// Evaluate the need for drawing transparent areas.
/// </summary>
/// <param name="context">Evaluation context.</param>
/// <returns>True if transparent areas exist; otherwise false.</returns>
public override bool EvalTransparentPaint(ViewContext context)
{
return _child.EvalTransparentPaint(context);
}
/// <summary>
/// Helper routine to draw an image taking into account various properties.
/// </summary>
/// <param name="context">Rendering context.</param>
/// <param name="icon">Icon to be drawn.</param>
/// <param name="iconRect">Destination rectangle.</param>
/// <param name="orientation">Visual orientation.</param>
protected static void DrawIconHelper(ViewContext context,
Icon icon,
Rectangle iconRect,
VisualOrientation orientation)
{
Debug.Assert(context != null);
// Validate reference parameter
if (context == null) throw new ArgumentNullException("context");
try
{
// Finally, just draw the icon and let the transforms do the rest
context.Graphics.DrawIcon(icon, iconRect);
}
finally
{
}
}
/// <summary>
/// Gets the short text drawing rectangle.
/// </summary>
/// <returns>Rectangle of short text drawing.</returns>
public Rectangle ShortTextRect(ViewContext context)
{
Debug.Assert(context != null);
// Validate incoming reference
if (context == null) throw new ArgumentNullException("context");
Rectangle textRect = Rectangle.Empty;
// If we have some content to investigate
if (_paletteContent.GetContentDraw(State) == InheritBool.True)
textRect = context.Renderer.RenderStandardContent.GetContentShortTextRectangle(_memento);
return textRect;
}
/// <summary>
/// Evaluate the need for drawing transparent areas.
/// </summary>
/// <param name="context">Evaluation context.</param>
/// <returns>True if transparent areas exist; otherwise false.</returns>
public override bool EvalTransparentPaint(ViewContext context)
{
Debug.Assert(context != null);
// Ask the renderer to evaluate the given palette
return context.Renderer.EvalTransparentPaint(_paletteBack, State);
}
/// <summary>
/// Evaluate the need for drawing transparent areas.
/// </summary>
/// <param name="context">Evaluation context.</param>
/// <returns>True if transparent areas exist; otherwise false.</returns>
public override bool EvalTransparentPaint(ViewContext context)
{
return true;
}
/// <summary>
/// Get a value indicating if the content image is being displayed.
/// </summary>
/// <param name="context">ViewLayoutContext context.</param>
public bool IsImageDisplayed(ViewContext context)
{
Debug.Assert(context != null);
// Validate incoming reference
if (context == null) throw new ArgumentNullException("context");
bool isDisplayed = false;
// If we have some content to investigate
if (_paletteContent.GetContentDraw(State) == InheritBool.True)
isDisplayed = context.Renderer.RenderStandardContent.GetContentImageDisplayed(_memento);
return isDisplayed;
}
/// <summary>
/// Evaluate the need for drawing transparent areas.
/// </summary>
/// <param name="context">Evaluation context.</param>
/// <returns>True if transparent areas exist; otherwise false.</returns>
public override bool EvalTransparentPaint(ViewContext context)
{
Debug.Assert(context != null);
// Ensure that child elements have correct palette state
CheckPaletteState(context);
// Ask the renderer to evaluate the given palette
return _drawCanvas.EvalTransparentPaint(context);
}
/// <summary>
/// Check that the palette and state are correct.
/// </summary>
/// <param name="context">Reference to the view context.</param>
protected virtual void CheckPaletteState(ViewContext context)
{
// Default to using this element calculated state
PaletteState buttonState = State;
// If the actual control is not enabled, force to disabled state
if (!IsFixed && !context.Control.Enabled)
buttonState = PaletteState.Disabled;
// Apply the checked state if not fixed
if (!IsFixed && Checked)
{
// Is the checked button allowed to become unchecked
if (AllowUncheck)
{
// Show feedback on tracking and presssed
switch (buttonState)
{
case PaletteState.Normal:
buttonState = PaletteState.CheckedNormal;
break;
case PaletteState.Tracking:
buttonState = PaletteState.CheckedTracking;
break;
case PaletteState.Pressed:
buttonState = PaletteState.CheckedPressed;
break;
}
}
else
{
// Always use the normal state as user cannot uncheck the button
buttonState = PaletteState.CheckedNormal;
}
}
// If the child elements are not in correct state
if (_forcePaletteUpdate || (_drawCanvas.ElementState != buttonState))
{
// No longer need to force the palettes to be updated
_forcePaletteUpdate = false;
// Switch the child elements over to correct state
_drawCanvas.ElementState = buttonState;
_drawContent.ElementState = buttonState;
_drawSplitBorder.ElementState = buttonState;
_drawDropDownButton.ElementState = buttonState;
// Push the correct palettes into them
switch (buttonState)
{
case PaletteState.Disabled:
_paletteCurrent = _paletteDisabled;
break;
case PaletteState.Normal:
_paletteCurrent = _paletteNormal;
break;
case PaletteState.CheckedNormal:
_paletteCurrent = _paletteCheckedNormal;
break;
case PaletteState.Pressed:
_paletteCurrent = _palettePressed;
break;
case PaletteState.CheckedPressed:
_paletteCurrent = _paletteCheckedPressed;
break;
case PaletteState.Tracking:
_paletteCurrent = _paletteTracking;
break;
case PaletteState.CheckedTracking:
_paletteCurrent = _paletteCheckedTracking;
break;
default:
// Should never happen!
Debug.Assert(false);
break;
}
// Update with the correct palettes
_drawCanvas.SetPalettes(_paletteCurrent.PaletteBack, _paletteCurrent.PaletteBorder);
_drawContent.SetPalette(_paletteCurrent.PaletteContent);
_edgeRedirect.SetPalette(_paletteCurrent.PaletteBorder);
}
}
/// <summary>
/// Perform a layout of the view.
/// </summary>
/// <param name="renderer">Renderer provider.</param>
/// <returns>True if it contains transparent painting.</returns>
public bool EvalTransparentPaint(IRenderer renderer)
{
Debug.Assert(renderer != null);
Debug.Assert(Root != null);
// Validate incoming reference
if (renderer == null) throw new ArgumentNullException("renderer");
// Create a layout context for calculating size and positioning
using (ViewContext context = new ViewContext(this,
_control,
_alignControl,
renderer))
{
// Ask the view to perform operation
return Root.EvalTransparentPaint(context);
}
}
/// <summary>
/// Check that the palette and state are correct.
/// </summary>
/// <param name="context">Reference to the view context.</param>
protected override void CheckPaletteState(ViewContext context)
{
PaletteState state = ElementState;
// If the drop down calendar is showing then always draw button as pressed
if (_dateTimePicker.IsDropped)
state = PaletteState.Pressed;
else
{
// If the button is in a normal state (not being tracked or pressed)
if ((ElementState == PaletteState.Normal) ||
(ElementState == PaletteState.CheckedNormal))
{
// If the control is active then use the checked normal appearance, otherwise not active and so use the normal appearance
if (_dateTimePicker.IsActive || (_dateTimePicker.IsFixedActive && (_dateTimePicker.InputControlStyle == InputControlStyle.Standalone)))
state = PaletteState.CheckedNormal;
else
state = PaletteState.Normal;
}
}
ElementState = state;
foreach (ViewBase child in this)
child.ElementState = state;
}
/// <summary>
/// Evaluate the need for drawing transparent areas.
/// </summary>
/// <param name="context">Evaluation context.</param>
/// <returns>True if transparent areas exist; otherwise false.</returns>
public override bool EvalTransparentPaint(ViewContext context)
{
Debug.Assert(context != null);
// Check each child in turn for transparent areas
foreach (ViewBase child in this)
{
// Only investigate visible children
if (child.Visible)
{
// Any child that returns 'true' completes the process
if (child.EvalTransparentPaint(context))
return true;
}
}
// Nothing found
return false;
}
/// <summary>
/// Evaluate the need for drawing transparent areas.
/// </summary>
/// <param name="context">Evaluation context.</param>
/// <returns>True if transparent areas exist; otherwise false.</returns>
public override bool EvalTransparentPaint(ViewContext context)
{
Debug.Assert(context != null);
// Check with the base canvas first
if (base.EvalTransparentPaint(context))
return true;
// If drawing the other elements over the top of the border
// then we need to check each element as any of them could
// have an impact on the transparent drawing.
if (!DrawBorderLast)
{
// Check each child that is docked against an edge
foreach (ViewBase child in this.Reverse())
{
// Only position visible children
if (child.Visible)
{
switch(GetDock(child))
{
case ViewDockStyle.Top:
case ViewDockStyle.Bottom:
case ViewDockStyle.Left:
case ViewDockStyle.Right:
if (child.EvalTransparentPaint(context))
return true;
break;
}
}
}
}
// Could not find anything that needs transparent painting
return false;
}
private void CheckPaletteState(ViewContext context)
{
// Default to using this element calculated state
PaletteState buttonState = State;
// If the actual control is not enabled, force to disabled state
if (!IsFixed && !context.Control.Enabled)
buttonState = PaletteState.Disabled;
else if (buttonState == PaletteState.Disabled)
buttonState = PaletteState.Normal;
if (!IsFixed)
{
if (Checked)
{
switch (buttonState)
{
case PaletteState.Normal:
case PaletteState.CheckedNormal:
buttonState = PaletteState.CheckedNormal;
break;
case PaletteState.Tracking:
case PaletteState.CheckedTracking:
buttonState = PaletteState.CheckedTracking;
break;
case PaletteState.Pressed:
case PaletteState.CheckedPressed:
buttonState = PaletteState.CheckedPressed;
break;
}
}
else
{
switch (buttonState)
{
case PaletteState.Normal:
case PaletteState.CheckedNormal:
buttonState = PaletteState.Normal;
break;
case PaletteState.Tracking:
case PaletteState.CheckedTracking:
buttonState = PaletteState.Tracking;
break;
case PaletteState.Pressed:
case PaletteState.CheckedPressed:
buttonState = PaletteState.Pressed;
break;
}
}
}
// Set the correct palette based on state
switch (buttonState)
{
case PaletteState.Disabled:
_currentText = Navigator.StateDisabled.RibbonTab.TabDraw;
_currentBack = Navigator.StateDisabled.RibbonTab.TabDraw;
_currentContent = Navigator.StateDisabled.RibbonTab.Content;
break;
case PaletteState.Normal:
_currentText = _overrideStateNormal;
_currentBack = _overrideStateNormal;
_currentContent = _overrideStateNormal;
break;
case PaletteState.Tracking:
_currentText = _overrideStateTracking;
_currentBack = _overrideStateTracking;
_currentContent = _overrideStateTracking;
break;
case PaletteState.Pressed:
_currentText = _overrideStatePressed;
_currentBack = _overrideStatePressed;
_currentContent = _overrideStatePressed;
break;
case PaletteState.CheckedNormal:
case PaletteState.CheckedTracking:
case PaletteState.CheckedPressed:
_currentText = _overrideStateSelected;
_currentBack = _overrideStateSelected;
_currentContent = _overrideStateSelected;
break;
default:
// Should never happen!
Debug.Assert(false);
break;
}
// Switch the child elements over to correct state
ElementState = buttonState;
this[0][0].ElementState = buttonState;
// Update content palette with the current ribbon text palette
_contentProvider.PaletteRibbonText = _currentText;
_contentProvider.PaletteContent = _currentContent;
}
private void CheckPaletteState(ViewContext context)
{
// Should control be enabled or disabled
bool enabled = IsFixed || context.Control.Enabled;
// Ensure we and child and in correct enabled state
Enabled = enabled;
// Better check we have a child!
if (Count > 0)
this[0].Enabled = enabled;
// If disabled...
if (!enabled)
{
//...must always be using the normal overrides
_paletteContextCurrent.SetInherit(_overrideStateNormal);
}
else
{
// Default to using this element calculated state
PaletteState buttonState = State;
// Update the checked state
Checked = (_ribbon.SelectedTab == RibbonTab);
// Is this tab a context tab?
bool contextTab = !string.IsNullOrEmpty(RibbonTab.ContextName);
// Apply the checked state if not fixed
if (!IsFixed)
{
if (Checked)
{
switch (buttonState)
{
case PaletteState.Normal:
case PaletteState.CheckedNormal:
case PaletteState.ContextCheckedNormal:
if (contextTab)
buttonState = PaletteState.ContextCheckedNormal;
else
buttonState = PaletteState.CheckedNormal;
break;
case PaletteState.Tracking:
case PaletteState.CheckedTracking:
case PaletteState.ContextCheckedTracking:
if (contextTab)
buttonState = PaletteState.ContextCheckedTracking;
else
buttonState = PaletteState.CheckedTracking;
break;
}
}
else
{
switch (buttonState)
{
case PaletteState.CheckedNormal:
case PaletteState.ContextCheckedNormal:
buttonState = PaletteState.Normal;
break;
case PaletteState.Tracking:
case PaletteState.CheckedTracking:
case PaletteState.ContextCheckedTracking:
if (contextTab)
buttonState = PaletteState.ContextTracking;
else
buttonState = PaletteState.Tracking;
break;
}
}
}
// Set the correct palette based on state
switch (buttonState)
{
case PaletteState.Disabled:
case PaletteState.Normal:
_overrideCurrent = _overrideStateNormal;
break;
case PaletteState.Tracking:
_overrideCurrent = _overrideStateTracking;
break;
case PaletteState.CheckedNormal:
_overrideCurrent = _overrideStateCheckedNormal;
break;
case PaletteState.CheckedTracking:
_overrideCurrent = _overrideStateCheckedTracking;
break;
case PaletteState.ContextTracking:
_overrideCurrent = _overrideStateContextTracking;
break;
case PaletteState.ContextCheckedNormal:
_overrideCurrent = _overrideStateContextCheckedNormal;
break;
case PaletteState.ContextCheckedTracking:
_overrideCurrent = _overrideStateContextCheckedTracking;
break;
default:
// Should never happen!
Debug.Assert(false);
break;
}
// Switch the child elements over to correct state
ElementState = buttonState;
// Better check we have a child!
if (Count > 0)
this[0].ElementState = buttonState;
// Update the actual source palette
_paletteContextCurrent.SetInherit(_overrideCurrent);
}
}
/// <summary>
/// Evaluate the need for drawing transparent areas.
/// </summary>
/// <param name="context">Evaluation context.</param>
/// <returns>True if transparent areas exist; otherwise false.</returns>
public override bool EvalTransparentPaint(ViewContext context)
{
Debug.Assert(context != null);
return false;
}
