668 lines
22 KiB
C#
668 lines
22 KiB
C#
using System;
|
|
using System.Text;
|
|
using System.Windows.Forms;
|
|
using System.Drawing;
|
|
using System.ComponentModel;
|
|
using System.Drawing.Drawing2D;
|
|
using System.Drawing.Text;
|
|
using DevComponents.DotNetBar.Rendering;
|
|
using System.Reflection;
|
|
|
|
namespace DevComponents.DotNetBar
|
|
{
|
|
/// <summary>
|
|
/// Represents the class for the BaseItem non-popup based control host.
|
|
/// </summary>
|
|
[ToolboxItem(false)]
|
|
public abstract class BaseItemControl : Control
|
|
{
|
|
#region Private Variables
|
|
private BaseItem m_Item = null;
|
|
private ElementStyle m_BackgroundStyle = null;
|
|
private ColorScheme m_ColorScheme = null;
|
|
private bool m_DesignModeInternal = false;
|
|
private bool m_AntiAlias = true;
|
|
#endregion
|
|
|
|
#region Constructor Dispose
|
|
/// <summary>
|
|
/// Creates new instance of the object.
|
|
/// </summary>
|
|
public BaseItemControl()
|
|
{
|
|
if (!ColorFunctions.ColorsLoaded)
|
|
{
|
|
NativeFunctions.RefreshSettings();
|
|
NativeFunctions.OnDisplayChange();
|
|
ColorFunctions.LoadColors();
|
|
}
|
|
|
|
this.SetStyle(ControlStyles.UserPaint, true);
|
|
this.SetStyle(ControlStyles.AllPaintingInWmPaint, true);
|
|
this.SetStyle(ControlStyles.Opaque, true);
|
|
this.SetStyle(ControlStyles.ResizeRedraw, true);
|
|
this.SetStyle(ControlStyles.StandardDoubleClick, true);
|
|
this.SetStyle(DisplayHelp.DoubleBufferFlag, true);
|
|
this.SetStyle(ControlStyles.SupportsTransparentBackColor, true);
|
|
|
|
m_ColorScheme = new ColorScheme(eDotNetBarStyle.Office2007);
|
|
m_BackgroundStyle = new ElementStyle();
|
|
m_BackgroundStyle.SetColorScheme(m_ColorScheme);
|
|
m_BackgroundStyle.StyleChanged += new EventHandler(this.VisualPropertyChanged);
|
|
}
|
|
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
if (disposing && m_Item != null)
|
|
m_Item.Dispose();
|
|
base.Dispose(disposing);
|
|
}
|
|
#endregion
|
|
|
|
#region Internal Implementation
|
|
|
|
protected override void ScaleControl(SizeF factor, BoundsSpecified specified)
|
|
{
|
|
if (Dpi.RecordScalePerControl)
|
|
Dpi.SetScaling(factor);
|
|
if (m_Item != null)
|
|
{
|
|
m_Item.NotifyScaleItem(factor);
|
|
RecalcLayout();
|
|
}
|
|
base.ScaleControl(factor, specified);
|
|
}
|
|
|
|
internal bool IsValidationCancelled
|
|
{
|
|
get
|
|
{
|
|
PropertyInfo pi=this.GetType().GetProperty("ValidationCancelled", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
|
|
if (pi != null)
|
|
return (bool)pi.GetValue(this, null);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
#if FRAMEWORK20
|
|
protected override void OnBindingContextChanged(EventArgs e)
|
|
{
|
|
base.OnBindingContextChanged(e);
|
|
if (m_Item != null)
|
|
m_Item.UpdateBindings();
|
|
}
|
|
#endif
|
|
|
|
protected bool GetDesignMode()
|
|
{
|
|
if (!m_DesignModeInternal)
|
|
return this.DesignMode;
|
|
return m_DesignModeInternal;
|
|
}
|
|
|
|
protected virtual ElementStyle GetBackgroundStyle()
|
|
{
|
|
return m_BackgroundStyle;
|
|
}
|
|
|
|
internal void SetDesignMode(bool mode)
|
|
{
|
|
m_DesignModeInternal = mode;
|
|
if(m_Item!=null)
|
|
m_Item.SetDesignMode(mode);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the instance of BaseItem object hosted by this control.
|
|
/// </summary>
|
|
protected virtual BaseItem HostItem
|
|
{
|
|
get { return m_Item; }
|
|
set
|
|
{
|
|
m_Item = value;
|
|
if (m_Item != null)
|
|
{
|
|
m_Item.Displayed = true;
|
|
m_Item.ContainerControl = this;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the color scheme used by control. Color scheme for Office2007 style will be retrieved from the current renderer instead of
|
|
/// local color scheme referenced by ColorScheme property.
|
|
/// </summary>
|
|
/// <returns>An instance of ColorScheme object.</returns>
|
|
protected virtual ColorScheme GetColorScheme()
|
|
{
|
|
if (m_Item != null && BarFunctions.IsOffice2007Style(m_Item.EffectiveStyle))
|
|
{
|
|
BaseRenderer r = GetRenderer();
|
|
if (r is Office2007Renderer)
|
|
return ((Office2007Renderer)r).ColorTable.LegacyColors;
|
|
}
|
|
return m_ColorScheme;
|
|
}
|
|
|
|
private bool _CallBasePaintBackground = true;
|
|
/// <summary>
|
|
/// Gets or sets whether during painting OnPaintBackground on base control is called when BackColor=Transparent.
|
|
/// </summary>
|
|
[Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public bool CallBasePaintBackground
|
|
{
|
|
get { return _CallBasePaintBackground; }
|
|
set
|
|
{
|
|
_CallBasePaintBackground = value;
|
|
}
|
|
}
|
|
|
|
internal void InternalPaint(PaintEventArgs e)
|
|
{
|
|
OnPaint(e);
|
|
}
|
|
|
|
protected override void OnPaint(PaintEventArgs e)
|
|
{
|
|
if ((this.BackColor.IsEmpty || this.BackColor == Color.Transparent) && _CallBasePaintBackground)
|
|
{
|
|
base.OnPaintBackground(e);
|
|
}
|
|
|
|
if (m_BackgroundStyle != null)
|
|
m_BackgroundStyle.SetColorScheme(this.GetColorScheme());
|
|
|
|
PaintBackground(e);
|
|
PaintControl(e);
|
|
|
|
if (this.Focused && /*this.ShowFocusCues &&*/ this.FocusCuesEnabled)
|
|
{
|
|
PaintFocusCues(e);
|
|
}
|
|
|
|
base.OnPaint(e);
|
|
}
|
|
|
|
private bool _FocusCuesEnabled = true;
|
|
/// <summary>
|
|
/// Gets or sets whether control displays focus cues when focused.
|
|
/// </summary>
|
|
[DefaultValue(true), Category("Behavior"), Description("Indicates whether control displays focus cues when focused.")]
|
|
public virtual bool FocusCuesEnabled
|
|
{
|
|
get { return _FocusCuesEnabled; }
|
|
set
|
|
{
|
|
_FocusCuesEnabled = value;
|
|
if (this.Focused) this.Invalidate();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Paints the control focus cues.
|
|
/// </summary>
|
|
/// <param name="e">Paint event information.</param>
|
|
protected virtual void PaintFocusCues(PaintEventArgs e)
|
|
{
|
|
ControlPaint.DrawFocusRectangle(e.Graphics, this.ClientRectangle);
|
|
}
|
|
|
|
protected virtual void PaintBackground(PaintEventArgs e)
|
|
{
|
|
Graphics g = e.Graphics;
|
|
Rectangle r = this.ClientRectangle;
|
|
ElementStyle style = this.GetBackgroundStyle();
|
|
|
|
if (!this.BackColor.IsEmpty && this.BackColor != Color.Transparent)
|
|
{
|
|
DisplayHelp.FillRectangle(g, r, this.BackColor);
|
|
}
|
|
|
|
if (this.BackgroundImage != null)
|
|
base.OnPaintBackground(e);
|
|
|
|
if (style.Custom)
|
|
{
|
|
SmoothingMode sm = g.SmoothingMode;
|
|
if (m_AntiAlias)
|
|
g.SmoothingMode = SmoothingMode.HighQuality;
|
|
ElementStyleDisplayInfo displayInfo = new ElementStyleDisplayInfo(style, e.Graphics, r);
|
|
ElementStyleDisplay.Paint(displayInfo);
|
|
if (m_AntiAlias)
|
|
g.SmoothingMode = sm;
|
|
}
|
|
}
|
|
|
|
protected virtual void PaintControl(PaintEventArgs e)
|
|
{
|
|
SmoothingMode sm = e.Graphics.SmoothingMode;
|
|
TextRenderingHint th = e.Graphics.TextRenderingHint;
|
|
Graphics g = e.Graphics;
|
|
|
|
if (m_AntiAlias)
|
|
{
|
|
g.SmoothingMode = SmoothingMode.AntiAlias;
|
|
g.TextRenderingHint = DisplayHelp.AntiAliasTextRenderingHint;
|
|
}
|
|
|
|
ItemPaintArgs pa = GetItemPaintArgs(g);
|
|
pa.ClipRectangle = e.ClipRectangle;
|
|
|
|
if (m_Item != null) m_Item.Paint(pa);
|
|
|
|
if (m_AntiAlias)
|
|
{
|
|
g.SmoothingMode = sm;
|
|
g.TextRenderingHint = th;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates the Graphics object for the control.
|
|
/// </summary>
|
|
/// <returns>The Graphics object for the control.</returns>
|
|
public new Graphics CreateGraphics()
|
|
{
|
|
Graphics g = base.CreateGraphics();
|
|
if (m_AntiAlias)
|
|
{
|
|
g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
|
|
#if FRAMEWORK20
|
|
if (!SystemInformation.IsFontSmoothingEnabled)
|
|
#endif
|
|
g.TextRenderingHint = DisplayHelp.AntiAliasTextRenderingHint;
|
|
}
|
|
return g;
|
|
}
|
|
|
|
protected virtual ItemPaintArgs GetItemPaintArgs(Graphics g)
|
|
{
|
|
ItemPaintArgs pa = new ItemPaintArgs(this as IOwner, this, g, GetColorScheme());
|
|
pa.Renderer = this.GetRenderer();
|
|
pa.DesignerSelection = false;
|
|
pa.GlassEnabled = !this.DesignMode && WinApi.IsGlassEnabled;
|
|
return pa;
|
|
}
|
|
|
|
private Rendering.BaseRenderer m_DefaultRenderer = null;
|
|
private Rendering.BaseRenderer m_Renderer = null;
|
|
private eRenderMode m_RenderMode = eRenderMode.Global;
|
|
/// <summary>
|
|
/// Returns the renderer control will be rendered with.
|
|
/// </summary>
|
|
/// <returns>The current renderer.</returns>
|
|
public virtual Rendering.BaseRenderer GetRenderer()
|
|
{
|
|
if (m_RenderMode == eRenderMode.Global && Rendering.GlobalManager.Renderer != null)
|
|
return Rendering.GlobalManager.Renderer;
|
|
else if (m_RenderMode == eRenderMode.Custom && m_Renderer != null)
|
|
return m_Renderer;
|
|
|
|
if (m_DefaultRenderer == null)
|
|
m_DefaultRenderer = new Rendering.Office2007Renderer();
|
|
|
|
return m_Renderer;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the redering mode used by control. Default value is eRenderMode.Global which means that static GlobalManager.Renderer is used. If set to Custom then Renderer property must
|
|
/// also be set to the custom renderer that will be used.
|
|
/// </summary>
|
|
[Browsable(false), DefaultValue(eRenderMode.Global)]
|
|
public eRenderMode RenderMode
|
|
{
|
|
get { return m_RenderMode; }
|
|
set
|
|
{
|
|
if (m_RenderMode != value)
|
|
{
|
|
m_RenderMode = value;
|
|
this.Invalidate(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the custom renderer used by the items on this control. RenderMode property must also be set to eRenderMode.Custom in order renderer
|
|
/// specified here to be used.
|
|
/// </summary>
|
|
[Browsable(false), DefaultValue(null)]
|
|
public DevComponents.DotNetBar.Rendering.BaseRenderer Renderer
|
|
{
|
|
get
|
|
{
|
|
return m_Renderer;
|
|
}
|
|
set { m_Renderer = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Specifies the background style of the control.
|
|
/// </summary>
|
|
[Browsable(true), DevCoBrowsable(true), Category("Style"), Description("Gets or sets bar background style."), DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public ElementStyle BackgroundStyle
|
|
{
|
|
get { return m_BackgroundStyle; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resets style to default value. Used by windows forms designer.
|
|
/// </summary>
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public void ResetBackgroundStyle()
|
|
{
|
|
m_BackgroundStyle.StyleChanged -= new EventHandler(this.VisualPropertyChanged);
|
|
m_BackgroundStyle = new ElementStyle();
|
|
m_BackgroundStyle.StyleChanged += new EventHandler(this.VisualPropertyChanged);
|
|
OnBackgroundStyleChanged();
|
|
this.Invalidate();
|
|
}
|
|
|
|
protected virtual void OnBackgroundStyleChanged()
|
|
{
|
|
}
|
|
|
|
private void VisualPropertyChanged(object sender, EventArgs e)
|
|
{
|
|
OnVisualPropertyChanged();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called when visual property of the control has changed so the control can be updated.
|
|
/// </summary>
|
|
protected virtual void OnVisualPropertyChanged()
|
|
{
|
|
if (this.GetDesignMode() ||
|
|
this.Parent != null && this.Parent.Site != null && this.Parent.Site.DesignMode)
|
|
{
|
|
this.RecalcLayout();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets Bar Color Scheme.
|
|
/// </summary>
|
|
[Browsable(false), DevCoBrowsable(false), Category("Appearance"), Description("Gets or sets Bar Color Scheme."), DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public ColorScheme ColorScheme
|
|
{
|
|
get { return m_ColorScheme; }
|
|
set
|
|
{
|
|
if (value == null)
|
|
throw new ArgumentException("NULL is not a valid value for this property.");
|
|
m_ColorScheme = value;
|
|
if (this.Visible)
|
|
this.Refresh();
|
|
}
|
|
}
|
|
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
|
|
public bool ShouldSerializeColorScheme()
|
|
{
|
|
return m_ColorScheme.SchemeChanged;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether anti-alias smoothing is used while painting. Default value is false.
|
|
/// </summary>
|
|
[DefaultValue(true), Browsable(true), Category("Appearance"), Description("Gets or sets whether anti-aliasing is used while painting.")]
|
|
public bool AntiAlias
|
|
{
|
|
get { return m_AntiAlias; }
|
|
set
|
|
{
|
|
if (m_AntiAlias != value)
|
|
{
|
|
m_AntiAlias = value;
|
|
this.Invalidate();
|
|
}
|
|
}
|
|
}
|
|
|
|
protected override void OnParentChanged(EventArgs e)
|
|
{
|
|
base.OnParentChanged(e);
|
|
//if (this.Parent != null && (this.Images != null || this.ImagesLarge != null || this.ImagesMedium != null))
|
|
//{
|
|
// foreach (BaseItem panel in m_BaseItemContainer.SubItems)
|
|
// {
|
|
// foreach (BaseItem item in panel.SubItems)
|
|
// {
|
|
// if (item is ImageItem)
|
|
// ((ImageItem)item).OnImageChanged();
|
|
// }
|
|
// }
|
|
//}
|
|
|
|
if (this.DesignMode && m_Item!=null)
|
|
m_Item.SetDesignMode(this.DesignMode);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Forces the button to perform internal layout.
|
|
/// </summary>
|
|
public virtual void RecalcLayout()
|
|
{
|
|
if (m_Item == null) return;
|
|
|
|
Rectangle r = GetItemBounds();
|
|
m_Item.Bounds = r;
|
|
this.RecalcSize();
|
|
m_Item.Bounds = r;
|
|
this.Invalidate();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recalculates the size of the internal item.
|
|
/// </summary>
|
|
protected virtual void RecalcSize()
|
|
{
|
|
m_Item.RecalcSize();
|
|
}
|
|
|
|
protected virtual Rectangle GetItemBounds()
|
|
{
|
|
Rectangle r = this.ClientRectangle;
|
|
r.X += ElementStyleLayout.LeftWhiteSpace(this.BackgroundStyle);
|
|
r.Width -= ElementStyleLayout.HorizontalStyleWhiteSpace(this.BackgroundStyle);
|
|
r.Y += ElementStyleLayout.TopWhiteSpace(this.BackgroundStyle);
|
|
r.Height -= ElementStyleLayout.VerticalStyleWhiteSpace(this.BackgroundStyle);
|
|
|
|
return r;
|
|
}
|
|
|
|
protected override void OnResize(EventArgs e)
|
|
{
|
|
RecalcLayout();
|
|
base.OnResize(e);
|
|
}
|
|
|
|
protected override void OnTextChanged(EventArgs e)
|
|
{
|
|
m_Item.Text = this.Text;
|
|
this.RecalcLayout();
|
|
base.OnTextChanged(e);
|
|
}
|
|
|
|
protected override void OnFontChanged(EventArgs e)
|
|
{
|
|
base.OnFontChanged(e);
|
|
BarUtilities.InvalidateFontChange(m_Item);
|
|
this.RecalcLayout();
|
|
}
|
|
|
|
protected override void OnEnabledChanged(EventArgs e)
|
|
{
|
|
m_Item.Enabled = this.Enabled;
|
|
base.OnEnabledChanged(e);
|
|
}
|
|
|
|
private bool m_MouseFocus = false;
|
|
protected override void OnGotFocus(EventArgs e)
|
|
{
|
|
if (!m_MouseFocus)
|
|
m_Item.OnGotFocus();
|
|
m_MouseFocus = false;
|
|
base.OnGotFocus(e);
|
|
}
|
|
|
|
protected override void OnLostFocus(EventArgs e)
|
|
{
|
|
m_Item.OnLostFocus();
|
|
base.OnLostFocus(e);
|
|
}
|
|
|
|
protected override void OnMouseEnter(EventArgs e)
|
|
{
|
|
m_Item.InternalMouseEnter();
|
|
base.OnMouseEnter(e);
|
|
}
|
|
|
|
protected override void OnMouseMove(MouseEventArgs e)
|
|
{
|
|
m_Item.InternalMouseMove(e);
|
|
base.OnMouseMove(e);
|
|
}
|
|
|
|
protected override void OnMouseLeave(EventArgs e)
|
|
{
|
|
m_Item.InternalMouseLeave();
|
|
base.OnMouseLeave(e);
|
|
}
|
|
|
|
protected override void OnMouseHover(EventArgs e)
|
|
{
|
|
m_Item.InternalMouseHover();
|
|
base.OnMouseHover(e);
|
|
}
|
|
|
|
protected virtual MouseButtons MouseDownFocusButtons
|
|
{
|
|
get { return MouseButtons.Left; }
|
|
}
|
|
|
|
protected override void OnMouseDown(MouseEventArgs e)
|
|
{
|
|
if ((e.Button & MouseDownFocusButtons) != 0)
|
|
{
|
|
if (!this.Focused && this.GetStyle(ControlStyles.Selectable))
|
|
{
|
|
m_MouseFocus = true;
|
|
this.Select();
|
|
}
|
|
}
|
|
|
|
m_Item.InternalMouseDown(e);
|
|
base.OnMouseDown(e);
|
|
}
|
|
|
|
protected override void OnMouseUp(MouseEventArgs e)
|
|
{
|
|
m_Item.InternalMouseUp(e);
|
|
base.OnMouseUp(e);
|
|
}
|
|
|
|
protected override void OnClick(EventArgs e)
|
|
{
|
|
m_Item.InternalClick(Control.MouseButtons, this.PointToClient(Control.MousePosition));
|
|
base.OnClick(e);
|
|
}
|
|
|
|
protected override void OnDoubleClick(EventArgs e)
|
|
{
|
|
m_Item.InternalDoubleClick(Control.MouseButtons, this.PointToClient(Control.MousePosition));
|
|
base.OnDoubleClick(e);
|
|
}
|
|
|
|
protected override void OnKeyDown(KeyEventArgs e)
|
|
{
|
|
m_Item.InternalKeyDown(e);
|
|
base.OnKeyDown(e);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets/Sets the visual style for the control.
|
|
/// </summary>
|
|
[Browsable(true), Category("Appearance"), Description("Specifies the visual style of the control."), DefaultValue(eDotNetBarStyle.Office2007)]
|
|
public virtual eDotNetBarStyle Style
|
|
{
|
|
get
|
|
{
|
|
return m_Item.Style;
|
|
}
|
|
set
|
|
{
|
|
m_Item.Style = value;
|
|
if(!BarFunctions.IsOffice2007Style(value))
|
|
this.GetColorScheme().Style = value;
|
|
this.RecalcLayout();
|
|
}
|
|
}
|
|
|
|
protected override bool ProcessMnemonic(char charCode)
|
|
{
|
|
if (IsMnemonic(charCode, m_Item.Text))
|
|
{
|
|
if (ProcessAccelerator())
|
|
return true;
|
|
}
|
|
return base.ProcessMnemonic(charCode);
|
|
}
|
|
|
|
protected virtual bool ProcessAccelerator()
|
|
{
|
|
m_Item.RaiseClick(eEventSource.Keyboard);
|
|
return true;
|
|
}
|
|
#endregion
|
|
|
|
#region Layout Support
|
|
private int m_UpdateSuspendCount = 0;
|
|
/// <summary>
|
|
/// Indicates to control that all further update operations should not result in layout and refresh of control content.
|
|
/// Use this method to optimize the addition of new items to the control. This method supports nested calls meaning
|
|
/// that multiple calls are allowed but they must be ended with appropriate number of EndUpdate calls.
|
|
/// IsUpdateSuspended property returns whether update is suspended.
|
|
/// </summary>
|
|
public void BeginUpdate()
|
|
{
|
|
m_UpdateSuspendCount++;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Indicates that update operation is complete and that control should perform layout and refresh to show changes. See BeginUpdate
|
|
/// for more details.
|
|
/// </summary>
|
|
public void EndUpdate()
|
|
{
|
|
EndUpdate(true);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Indicates that update operation is complete and that control should perform layout and refresh to show changes. See BeginUpdate
|
|
/// for more details.
|
|
/// </summary>
|
|
public void EndUpdate(bool callRecalcLayout)
|
|
{
|
|
if (m_UpdateSuspendCount > 0)
|
|
{
|
|
m_UpdateSuspendCount--;
|
|
if (m_UpdateSuspendCount == 0 && callRecalcLayout)
|
|
this.RecalcLayout();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets whether control layout is suspended becouse of the call to BeginUpdate method.
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
public bool IsUpdateSuspended
|
|
{
|
|
get { return m_UpdateSuspendCount > 0; }
|
|
}
|
|
#endregion
|
|
}
|
|
}
|