1770 lines
45 KiB
C#
1770 lines
45 KiB
C#
using System;
|
|
using System.ComponentModel;
|
|
using System.Drawing;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Threading;
|
|
using System.Windows.Forms;
|
|
using System.Xml;
|
|
using DevComponents.DotNetBar.Charts.Style;
|
|
|
|
namespace DevComponents.DotNetBar.Charts
|
|
{
|
|
[DesignTimeVisible(false)]
|
|
public abstract class ChartElement : INotifyPropertyChanged, INamed, IDisposable
|
|
{
|
|
#region Events
|
|
|
|
/// <summary>
|
|
/// Occurs when parent of the item has changed.
|
|
/// </summary>
|
|
public event EventHandler ParentChanged;
|
|
|
|
/// <summary>
|
|
/// Occurs when display/rendering of the item is invalidated.
|
|
/// </summary>
|
|
public event EventHandler RenderInvalid;
|
|
|
|
/// <summary>
|
|
/// Occurs when layout of the item is invalidated.
|
|
/// </summary>
|
|
public event EventHandler LayoutInvalid;
|
|
|
|
#endregion
|
|
|
|
#region Private variables
|
|
|
|
private string _Name = String.Empty;
|
|
|
|
private ChartControl _ChartControl;
|
|
private ChartElement _Parent;
|
|
private object _Tag;
|
|
|
|
#endregion
|
|
|
|
#region Public properties
|
|
|
|
#region ChartControl
|
|
|
|
/// <summary>
|
|
/// Gets the parent ChartControl
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public ChartControl ChartControl
|
|
{
|
|
get { return (GetChartControl()); }
|
|
internal set { _ChartControl = value; }
|
|
}
|
|
|
|
#region GetChartControl
|
|
|
|
private ChartControl GetChartControl()
|
|
{
|
|
if (_ChartControl != null)
|
|
return (_ChartControl);
|
|
|
|
ChartElement parent = _Parent;
|
|
|
|
while (parent != null)
|
|
{
|
|
if (parent.ChartControl != null)
|
|
return (parent.ChartControl);
|
|
|
|
parent = parent.Parent;
|
|
}
|
|
|
|
return (null);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region ChartPanel
|
|
|
|
/// <summary>
|
|
/// Gets the parent ChartPanel
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public ChartPanel ChartPanel
|
|
{
|
|
get { return (GetChartPanel()); }
|
|
}
|
|
|
|
#region GetChartPanel
|
|
|
|
private ChartPanel GetChartPanel()
|
|
{
|
|
ChartElement item = this;
|
|
|
|
while (item != null)
|
|
{
|
|
if (item is ChartPanel)
|
|
return ((ChartPanel)item);
|
|
|
|
item = item.Parent;
|
|
}
|
|
|
|
return (null);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Name
|
|
|
|
/// <summary>
|
|
/// Gets or sets the Name of the item.
|
|
/// </summary>
|
|
[DefaultValue("")]
|
|
[Description("Indicates the Name of the item.")]
|
|
public virtual string Name
|
|
{
|
|
get { return (_Name); }
|
|
set { _Name = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Parent
|
|
|
|
/// <summary>
|
|
/// Gets or sets the parent of the item.
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public virtual ChartElement Parent
|
|
{
|
|
get { return (_Parent); }
|
|
|
|
internal set
|
|
{
|
|
if (_Parent != value)
|
|
{
|
|
ChartElement oldParent = _Parent;
|
|
_Parent = value;
|
|
|
|
OnParentChanged(oldParent, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
#region OnParentChanged
|
|
|
|
/// <summary>
|
|
/// Called after parent of the item has changed.
|
|
/// </summary>
|
|
/// <param name="oldParent">Reference to old parent.</param>
|
|
/// <param name="newParent">Reference to new parent.</param>
|
|
protected virtual void OnParentChanged(ChartElement oldParent, ChartElement newParent)
|
|
{
|
|
if (oldParent != null)
|
|
oldParent.ParentChanged -= GrapdParentChanged;
|
|
|
|
if (newParent != null)
|
|
newParent.ParentChanged += GrapdParentChanged;
|
|
|
|
OnParentChanged(EventArgs.Empty);
|
|
}
|
|
|
|
void GrapdParentChanged(object sender, EventArgs e)
|
|
{
|
|
ChartElement parent = sender as ChartElement;
|
|
|
|
if (parent != null)
|
|
Parent = parent;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Raises ParentChanged event.
|
|
/// </summary>
|
|
/// <param name="e">Provides event arguments.</param>
|
|
protected virtual void OnParentChanged(EventArgs e)
|
|
{
|
|
EventHandler handler = ParentChanged;
|
|
|
|
if (handler != null)
|
|
handler(this, e);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region ParentChartContainer
|
|
|
|
/// <summary>
|
|
/// Gets the parent ChartContainer
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public ChartContainer ParentChartContainer
|
|
{
|
|
get { return (GetParentChartContainer()); }
|
|
}
|
|
|
|
#region GetParentChartContainer
|
|
|
|
private ChartContainer GetParentChartContainer()
|
|
{
|
|
ChartElement parent = _Parent;
|
|
|
|
while (parent != null)
|
|
{
|
|
if (parent is ChartContainer)
|
|
return ((ChartContainer)parent);
|
|
|
|
parent = parent.Parent;
|
|
}
|
|
|
|
return (null);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Tag
|
|
|
|
///<summary>
|
|
/// Gets or sets user-defined data associated with the object
|
|
///</summary>
|
|
[DefaultValue(null)]
|
|
[Description("User-defined data associated with the object")]
|
|
[TypeConverter(typeof(StringConverter))]
|
|
public object Tag
|
|
{
|
|
get { return (_Tag); }
|
|
set { _Tag = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region OnLayoutInvalid
|
|
|
|
/// <summary>
|
|
/// Raises LayoutInvalid event.
|
|
/// </summary>
|
|
/// <param name="e">Provides event arguments.</param>
|
|
protected virtual void OnLayoutInvalid(EventArgs e)
|
|
{
|
|
EventHandler handler = LayoutInvalid;
|
|
|
|
if (handler != null)
|
|
handler(this, e);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region OnRenderInvalid
|
|
|
|
/// <summary>
|
|
/// Raises RenderInvalid event.
|
|
/// </summary>
|
|
/// <param name="e">Provides event arguments.</param>
|
|
protected virtual void OnRenderInvalid(EventArgs e)
|
|
{
|
|
EventHandler handler = RenderInvalid;
|
|
|
|
if (handler != null)
|
|
handler(this, e);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region INotifyPropertyChanged Members
|
|
|
|
/// <summary>
|
|
/// Occurs when property value has changed.
|
|
/// </summary>
|
|
public event PropertyChangedEventHandler PropertyChanged;
|
|
|
|
/// <summary>
|
|
/// Raises the PropertyChanged event.
|
|
/// </summary>
|
|
/// <param name="e">Event arguments</param>
|
|
protected virtual void OnPropertyChanged(PropertyChangedEventArgs e)
|
|
{
|
|
PropertyChangedEventHandler eh = PropertyChanged;
|
|
|
|
if (eh != null)
|
|
eh(this, e);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Default PropertyChanged processing
|
|
/// </summary>
|
|
/// <param name="s"></param>
|
|
protected void OnPropertyChanged(string s)
|
|
{
|
|
if (PropertyChanged != null)
|
|
OnPropertyChanged(new PropertyChangedEventArgs(s));
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IDisposable
|
|
|
|
public virtual void Dispose()
|
|
{
|
|
Parent = null;
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
|
|
[ToolboxItem(false)]
|
|
public abstract class ChartVisualElement : ChartElement, IEffectiveStyle, IProcessSerialElement
|
|
{
|
|
#region Static variables
|
|
|
|
static Point _mouseDownPoint;
|
|
|
|
static Cursor _OpenHandCursor;
|
|
static Cursor _ClosedHandCursor;
|
|
|
|
#endregion
|
|
|
|
#region Private variables
|
|
|
|
private Es _States;
|
|
|
|
private Rectangle _BoundsRelative;
|
|
private Point _ScrollOffset;
|
|
|
|
private ChartVisualElement _HitItem;
|
|
|
|
#endregion
|
|
|
|
#region Constructor
|
|
|
|
/// <summary>
|
|
/// ChartVisualElement
|
|
/// </summary>
|
|
protected ChartVisualElement()
|
|
{
|
|
SetState(Es.Visible, true);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Abstract methods
|
|
|
|
/// <summary>
|
|
/// Performs the layout of the item
|
|
/// and sets the Size property to size that item will take.
|
|
/// </summary>
|
|
/// <param name="layoutInfo">Layout information.</param>
|
|
protected abstract void MeasureOverride(ChartLayoutInfo layoutInfo);
|
|
|
|
/// <summary>
|
|
/// Performs the arrange pass layout of the item when
|
|
/// the final position and size of the item has been set.
|
|
/// </summary>
|
|
/// <param name="layoutInfo">Layout information.</param>
|
|
protected abstract void ArrangeOverride(ChartLayoutInfo layoutInfo);
|
|
|
|
/// <summary>
|
|
/// Performs drawing of the item and its children.
|
|
/// </summary>
|
|
/// <param name="renderInfo">Holds contextual rendering information.</param>
|
|
protected abstract void RenderOverride(ChartRenderInfo renderInfo);
|
|
|
|
#endregion
|
|
|
|
#region Public properties
|
|
|
|
#region Bounds
|
|
|
|
/// <summary>
|
|
/// Gets or sets the absolute (scroll adjusted) bounds of the item.
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public virtual Rectangle Bounds
|
|
{
|
|
get { return (GetScrollBounds(_BoundsRelative)); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region BoundsRelative
|
|
|
|
/// <summary>
|
|
/// Gets or sets the relative bounds of the item.
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public virtual Rectangle BoundsRelative
|
|
{
|
|
get { return (_BoundsRelative); }
|
|
internal set { _BoundsRelative = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IsMouseOver
|
|
|
|
/// <summary>
|
|
/// Gets whether mouse is over the element.
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public virtual bool IsMouseOver
|
|
{
|
|
get { return (TestState(Es.MouseOver)); }
|
|
internal set { SetState(Es.MouseOver, value); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Size
|
|
|
|
/// <summary>
|
|
/// Gets or sets the Size of the item.
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public Size Size
|
|
{
|
|
get { return (_BoundsRelative.Size); }
|
|
internal set { _BoundsRelative.Size = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Visible
|
|
|
|
/// <summary>
|
|
/// Get or sets whether the item is visible
|
|
/// </summary>
|
|
[DefaultValue(true), Category("Appearance")]
|
|
[Description("Indicates whether the item is visible")]
|
|
public virtual bool Visible
|
|
{
|
|
get { return (TestState(Es.Visible)); }
|
|
|
|
set
|
|
{
|
|
if (Visible != value)
|
|
{
|
|
SetState(Es.Visible, value);
|
|
|
|
OnPropertyChangedEx("Visible", VisualChangeType.Layout);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Internal properties
|
|
|
|
#region Capture
|
|
|
|
internal virtual bool Capture
|
|
{
|
|
get { return (CapturedItem != null); }
|
|
|
|
set
|
|
{
|
|
if (ChartControl != null)
|
|
CapturedItem = (value == true) ? this : null;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region CapturedItem
|
|
|
|
internal ChartVisualElement CapturedItem
|
|
{
|
|
get
|
|
{
|
|
if (ChartControl != null)
|
|
return (ChartControl.CapturedItem);
|
|
|
|
return (null);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (ChartControl != null)
|
|
ChartControl.CapturedItem = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ChartCursor
|
|
|
|
internal Cursor ChartCursor
|
|
{
|
|
get
|
|
{
|
|
ChartControl cc = ChartControl;
|
|
|
|
if (cc != null)
|
|
return (cc.ChartCursor);
|
|
|
|
return (Cursors.Default);
|
|
}
|
|
|
|
set
|
|
{
|
|
ChartControl cc = ChartControl;
|
|
|
|
if (cc != null)
|
|
cc.ChartCursor = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ClosedHandCursor
|
|
|
|
internal Cursor ClosedHandCursor
|
|
{
|
|
get
|
|
{
|
|
if (_ClosedHandCursor == null)
|
|
_ClosedHandCursor = new Cursor(GetType(), "ClosedHand.cur");
|
|
|
|
return (_ClosedHandCursor);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region HitItem
|
|
|
|
internal ChartVisualElement HitItem
|
|
{
|
|
get { return (_HitItem); }
|
|
set { _HitItem = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Displayed
|
|
|
|
/// <summary>
|
|
/// Gets whether element is actually displayed on screen
|
|
/// </summary>
|
|
internal bool Displayed
|
|
{
|
|
get { return (TestState(Es.Displayed)); }
|
|
set { SetState(Es.Displayed, value); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IsMouseDown
|
|
|
|
/// <summary>
|
|
/// Gets whether mouse is down
|
|
/// </summary>
|
|
internal virtual bool IsMouseDown
|
|
{
|
|
get { return (Control.MouseButtons != MouseButtons.None); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region MouseDownPoint
|
|
|
|
/// <summary>
|
|
/// Gets the mouse down Point
|
|
/// </summary>
|
|
internal virtual Point MouseDownPoint
|
|
{
|
|
get { return (_mouseDownPoint); }
|
|
set { _mouseDownPoint = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region MouseOverElement
|
|
|
|
internal ChartVisualElement MouseOverElement
|
|
{
|
|
get { return (ChartControl.MouseOverElement); }
|
|
set { ChartControl.MouseOverElement = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region OpenHandCursor
|
|
|
|
internal Cursor OpenHandCursor
|
|
{
|
|
get
|
|
{
|
|
if (_OpenHandCursor == null)
|
|
_OpenHandCursor = new Cursor(GetType(), "OpenHand.cur");
|
|
|
|
return (_OpenHandCursor);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ScrollOffset
|
|
|
|
internal Point ScrollOffset
|
|
{
|
|
get { return (_ScrollOffset); }
|
|
set { _ScrollOffset = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Measure
|
|
|
|
/// <summary>
|
|
/// This method is used by the items internally to invoke the measure pass to
|
|
/// get item size. Override MeasureOverride method to perform actual measuring.
|
|
/// </summary>
|
|
/// <param name="layoutInfo">Holds contextual layout information.</param>
|
|
internal void Measure(ChartLayoutInfo layoutInfo)
|
|
{
|
|
MeasureOverride(layoutInfo);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Arrange
|
|
|
|
/// <summary>
|
|
/// This method is used by the items internally to invoke the arrange pass after
|
|
/// location and size of the item has been set. Override ArrangeOverride method
|
|
/// to perform internal arranging.
|
|
/// </summary>
|
|
/// <param name="layoutInfo"></param>
|
|
/// <param name="layoutBounds"></param>
|
|
internal void Arrange(ChartLayoutInfo layoutInfo)
|
|
{
|
|
Displayed = true;
|
|
|
|
_ScrollOffset = layoutInfo.ScrollOffset;
|
|
|
|
ArrangeOverride(layoutInfo);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Render
|
|
|
|
private int _RenderCount;
|
|
|
|
/// <summary>
|
|
/// This method is used by the items internally to invoke the rendering
|
|
/// for the item. Override RenderOverride method to perform actual rendering.
|
|
/// </summary>
|
|
/// <param name="renderInfo">Holds contextual rendering information.</param>
|
|
internal virtual void Render(ChartRenderInfo renderInfo)
|
|
{
|
|
if (Displayed == true && renderInfo.ClipRectangle.IntersectsWith(Bounds))
|
|
{
|
|
RenderOverride(renderInfo);
|
|
|
|
//Graphics g = renderInfo.Graphics;
|
|
|
|
//using (StringFormat sf = new StringFormat())
|
|
//{
|
|
// sf.LineAlignment = StringAlignment.Center;
|
|
// sf.Alignment = StringAlignment.Center;
|
|
|
|
// _RenderCount++;
|
|
|
|
// g.DrawString(_RenderCount.ToString(), SystemFonts.CaptionFont, Brushes.Red, Bounds, sf);
|
|
//}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region CancelCapture
|
|
|
|
///<summary>
|
|
/// Cancels any inprogress operations that may
|
|
/// have the mouse captured (resize, reorder).
|
|
///</summary>
|
|
public virtual void CancelCapture()
|
|
{
|
|
if (CapturedItem == this)
|
|
Capture = false;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region InvalidateRecalc
|
|
|
|
internal virtual void InvalidateRecalc()
|
|
{
|
|
InvalidateLayout();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region InvalidateLayout
|
|
|
|
/// <summary>
|
|
/// Invalidates the layout for the item.
|
|
/// </summary>
|
|
public virtual void InvalidateLayout()
|
|
{
|
|
ChartControl control = ChartControl;
|
|
|
|
if (control != null)
|
|
{
|
|
control.LayoutValid = false;
|
|
|
|
if (control.InUpdateLayout == true)
|
|
control.PostInternalUpdate = true;
|
|
else
|
|
control.Invalidate();
|
|
}
|
|
|
|
OnLayoutInvalid(EventArgs.Empty);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region InvalidateRender
|
|
|
|
/// <summary>
|
|
/// Invalidates the display state of the item
|
|
/// </summary>
|
|
public virtual void InvalidateRender()
|
|
{
|
|
ChartControl chartControl = ChartControl;
|
|
|
|
if (chartControl != null)
|
|
{
|
|
if (chartControl.InvokeRequired)
|
|
chartControl.BeginInvoke(new MethodInvoker(delegate { chartControl.InvalidateRender(this); }));
|
|
else
|
|
chartControl.InvalidateRender(this);
|
|
}
|
|
|
|
OnRenderInvalid(EventArgs.Empty);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Invalidates the display state of the item
|
|
/// </summary>
|
|
public virtual void InvalidateRender(Rectangle bounds)
|
|
{
|
|
ChartControl chartControl = ChartControl;
|
|
|
|
if (chartControl != null)
|
|
chartControl.InvalidateRender(bounds);
|
|
|
|
OnRenderInvalid(EventArgs.Empty);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region InvalidateLayoutBounds
|
|
|
|
/// <summary>
|
|
/// Invalidates the layout bounds
|
|
/// </summary>
|
|
public virtual void InvalidateLayoutBounds(ScrollBarLite sbar)
|
|
{
|
|
ChartControl.LayoutBoundsItem = this;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetElementAt
|
|
|
|
/// <summary>
|
|
/// Gets the visual chart element at the given Point.
|
|
/// </summary>
|
|
/// <param name="pt"></param>
|
|
/// <returns></returns>
|
|
public virtual ChartVisualElement GetElementAt(Point pt)
|
|
{
|
|
return (null);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetHitArea
|
|
|
|
/// <summary>
|
|
/// Gets the element Hit Area for the given Point.
|
|
/// </summary>
|
|
/// <param name="pt"></param>
|
|
/// <returns></returns>
|
|
public virtual ItemHitArea GetHitArea(Point pt)
|
|
{
|
|
return (ItemHitArea.None);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Mouse Handling
|
|
|
|
#region OnMouseEnter
|
|
|
|
/// <summary>
|
|
/// Called by top-level control to pass message into the grid
|
|
/// element. To handle it override corresponding On - virtual method.
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
internal virtual bool InternalMouseEnter(EventArgs e)
|
|
{
|
|
IsMouseOver = true;
|
|
|
|
return (OnMouseEnter(e));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called when the mouse enters the element.
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
protected virtual bool OnMouseEnter(EventArgs e)
|
|
{
|
|
return (true);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region OnMouseLeave
|
|
|
|
/// <summary>
|
|
/// Called by top-level control to pass message into the grid
|
|
/// element. To handle it override corresponding On - virtual method.
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
internal virtual bool InternalMouseLeave(EventArgs e)
|
|
{
|
|
IsMouseOver = false;
|
|
|
|
return (OnMouseLeave(e));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called when mouse leaves the element.
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
protected virtual bool OnMouseLeave(EventArgs e)
|
|
{
|
|
return (true);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region OnMouseHover
|
|
|
|
/// <summary>
|
|
/// Called by top-level control to pass message into the grid
|
|
/// element. To handle it override corresponding On - virtual method.
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
internal virtual bool InternalMouseHover(EventArgs e)
|
|
{
|
|
return (OnMouseHover(e));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called when mouse hovers over the element.
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
protected virtual bool OnMouseHover(EventArgs e)
|
|
{
|
|
return (false);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region OnMouseDown
|
|
|
|
/// <summary>
|
|
/// Called by top-level control to pass message into the grid
|
|
/// element. To handle it override corresponding On - virtual method.
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
internal virtual bool InternalMouseDown(MouseEventArgs e)
|
|
{
|
|
MouseDownPoint = e.Location;
|
|
|
|
bool handled = OnMouseDown(e);
|
|
|
|
if (handled == false)
|
|
{
|
|
ChartVisualElement parent = Parent as ChartVisualElement;
|
|
|
|
while (parent != null)
|
|
{
|
|
parent.OnMouseMoveEx(e);
|
|
|
|
if (parent.OnMouseDownEx(e) == true)
|
|
return (true);
|
|
|
|
parent = parent.Parent as ChartVisualElement;
|
|
}
|
|
}
|
|
|
|
return (false);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called when mouse button is pressed over the element.
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
protected virtual bool OnMouseDown(MouseEventArgs e)
|
|
{
|
|
return (true);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called when mouse button is pressed over the element.
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
protected virtual bool OnMouseDownEx(MouseEventArgs e)
|
|
{
|
|
return (true);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region OnMouseUp
|
|
|
|
/// <summary>
|
|
/// Called by top-level control to pass message into the grid
|
|
/// element. To handle it override corresponding On - virtual method.
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
internal virtual bool InternalMouseUp(MouseEventArgs e)
|
|
{
|
|
Capture = false;
|
|
|
|
return (OnMouseUp(e));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called when mouse button is released over the element.
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
protected virtual bool OnMouseUp(MouseEventArgs e)
|
|
{
|
|
return (true);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region OnMouseMove
|
|
|
|
/// <summary>
|
|
/// Called by top-level control to pass message into the chart
|
|
/// element. To handle it override corresponding On - virtual method.
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
internal virtual bool InternalMouseMove(MouseEventArgs e)
|
|
{
|
|
ChartVisualElement mouseOverElement = MouseOverElement;
|
|
|
|
if (this != mouseOverElement)
|
|
{
|
|
if (mouseOverElement != null)
|
|
mouseOverElement.InternalMouseLeave(e);
|
|
|
|
MouseOverElement = this;
|
|
|
|
InternalMouseEnter(e);
|
|
}
|
|
|
|
bool handled = OnMouseMove(e);
|
|
|
|
ChartVisualElement parent = Parent as ChartVisualElement;
|
|
|
|
while (parent != null)
|
|
{
|
|
if (handled == false)
|
|
handled = parent.OnMouseMove(e);
|
|
else
|
|
parent.OnMouseMoveEx(e);
|
|
|
|
parent = parent.Parent as ChartVisualElement;
|
|
}
|
|
|
|
return (false);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called when mouse is moved over the element.
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
protected virtual bool OnMouseMove(MouseEventArgs e)
|
|
{
|
|
return (false);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called when mouse is moved over the element.
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
protected virtual void OnMouseMoveEx(MouseEventArgs e)
|
|
{
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region OnMouseClick
|
|
|
|
/// <summary>
|
|
/// Called by top-level control to pass message into the grid
|
|
/// element. To handle it override corresponding On - virtual method.
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
internal virtual bool InternalMouseClick(MouseEventArgs e)
|
|
{
|
|
return (OnMouseClick(e));
|
|
}
|
|
/// <summary>
|
|
/// Called when mouse is clicked on the element.
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
protected virtual bool OnMouseClick(MouseEventArgs e)
|
|
{
|
|
return (true);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region OnMouseDoubleClick
|
|
|
|
/// <summary>
|
|
/// Called by top-level control to pass message into the grid
|
|
/// element. To handle it override corresponding On - virtual method.
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
internal virtual bool InternalMouseDoubleClick(MouseEventArgs e)
|
|
{
|
|
return (OnMouseDoubleClick(e));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called when mouse is double clicked on the element.
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
protected virtual bool OnMouseDoubleClick(MouseEventArgs e)
|
|
{
|
|
return (false);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region OnMouseWheel
|
|
|
|
/// <summary>
|
|
/// Called by top-level control to pass message into the grid
|
|
/// element. To handle it override corresponding On - virtual method.
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
internal virtual bool InternalMouseWheel(MouseEventArgs e)
|
|
{
|
|
bool handled = OnMouseWheel(e);
|
|
|
|
if (handled == false)
|
|
{
|
|
ChartVisualElement parent = Parent as ChartVisualElement;
|
|
|
|
while (parent != null)
|
|
{
|
|
if (parent.OnMouseWheel(e) == true)
|
|
return (true);
|
|
|
|
parent = parent.Parent as ChartVisualElement;
|
|
}
|
|
}
|
|
|
|
return (false);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called when mousewheel is moved while over the element.
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
protected virtual bool OnMouseWheel(MouseEventArgs e)
|
|
{
|
|
return (false);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Keyboard handling
|
|
|
|
/// <summary>
|
|
/// Called by top-level control to pass message into the grid
|
|
/// element. To handle it override corresponding On - virtual method.
|
|
/// </summary>
|
|
/// <param name="keyData"></param>
|
|
internal virtual void InternalKeyDown(Keys keyData)
|
|
{
|
|
OnKeyDown(keyData);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called when mouse button is pressed over the element.
|
|
/// </summary>
|
|
/// <param name="keyData"></param>
|
|
protected virtual void OnKeyDown(Keys keyData)
|
|
{
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region OnResize
|
|
|
|
internal virtual bool InternalOnResize(EventArgs e)
|
|
{
|
|
return (OnResize(e));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called when control is resized.
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
protected virtual bool OnResize(EventArgs e)
|
|
{
|
|
return (true);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region OnVisualStyleChanged
|
|
|
|
protected virtual void OnVisualStyleChanged(string property,
|
|
INotifyPropertyChanged oldValue, INotifyPropertyChanged newValue)
|
|
{
|
|
StyleVisualChangeHandler(oldValue, newValue);
|
|
|
|
OnPropertyChanged(property);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region StyleVisualChangeHandler
|
|
|
|
protected virtual void StyleVisualChangeHandler(
|
|
INotifyPropertyChanged oldValue, INotifyPropertyChanged newValue)
|
|
{
|
|
if (oldValue != null)
|
|
oldValue.PropertyChanged -= StyleChanged;
|
|
|
|
if (newValue != null)
|
|
newValue.PropertyChanged += StyleChanged;
|
|
}
|
|
|
|
#region StyleChanged
|
|
|
|
/// <summary>
|
|
/// Occurs when one of element visual styles has property changes.
|
|
/// Default implementation invalidates visual appearance of element.
|
|
/// </summary>
|
|
/// <param name="sender">VisualStyle that changed.</param>
|
|
/// <param name="e">Event arguments.</param>
|
|
protected virtual void StyleChanged(object sender, PropertyChangedEventArgs e)
|
|
{
|
|
VisualChangeType changeType = ((VisualPropertyChangedEventArgs)e).ChangeType;
|
|
|
|
if (changeType == VisualChangeType.Layout)
|
|
InvalidateLayout();
|
|
else
|
|
InvalidateRender();
|
|
|
|
if (ChartControl != null)
|
|
ChartControl.GlobalUpdateCount++;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region ApplyStyles
|
|
|
|
public virtual void ApplyStyles(BaseVisualStyle style, StyleType cs)
|
|
{
|
|
}
|
|
|
|
public virtual void ApplyStyles(BaseVisualStyle style)
|
|
{
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ApplyDefaults
|
|
|
|
public virtual void ApplyDefaults(BaseVisualStyle style, StyleType cs)
|
|
{
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ClearEffectiveStyles
|
|
|
|
protected virtual void ClearEffectiveStyles()
|
|
{ }
|
|
|
|
#endregion
|
|
|
|
#region GetElementStyle
|
|
|
|
public virtual void GetElementStyle(
|
|
IEffectiveStyle chartElement, StyleType styleType, ref BaseVisualStyle style)
|
|
{
|
|
ChartControl.DoGetElementStyleEvent(this, styleType, ref style);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetAdjustedBounds
|
|
|
|
internal Rectangle GetAdjustedBounds(Rectangle bounds, Thickness thickness)
|
|
{
|
|
if (thickness.IsEmpty == false)
|
|
{
|
|
if (bounds.Height > Dpi.Height(thickness.Vertical))
|
|
{
|
|
bounds.Y += Dpi.Height(thickness.Top);
|
|
bounds.Height -= Dpi.Height(thickness.Vertical);
|
|
}
|
|
|
|
if (bounds.Width > Dpi.Width(thickness.Horizontal))
|
|
{
|
|
bounds.X += Dpi.Width(thickness.Left);
|
|
bounds.Width -= Dpi.Width(thickness.Horizontal);
|
|
}
|
|
}
|
|
|
|
return (bounds);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetScrollBounds
|
|
|
|
internal Rectangle GetScrollBounds(Rectangle bounds)
|
|
{
|
|
bounds.X -= _ScrollOffset.X;
|
|
bounds.Y -= _ScrollOffset.Y;
|
|
|
|
return (bounds);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Export
|
|
|
|
/// <summary>
|
|
/// Exports the chart element to the specified file. The
|
|
/// specified file will be created and/or overwritten.
|
|
/// </summary>
|
|
/// <param name="fileName"></param>
|
|
/// <returns></returns>
|
|
public void Export(string fileName)
|
|
{
|
|
string dir = Path.GetDirectoryName(fileName);
|
|
|
|
if (dir != null)
|
|
{
|
|
if (Directory.Exists(dir) == false)
|
|
Directory.CreateDirectory(dir);
|
|
|
|
using (FileStream stream = new
|
|
FileStream(fileName, FileMode.Create, FileAccess.ReadWrite))
|
|
{
|
|
Export(stream);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Exports the chart element to the specified stream.
|
|
/// </summary>
|
|
/// <param name="stream"></param>
|
|
/// <returns></returns>
|
|
public void Export(Stream stream)
|
|
{
|
|
CultureInfo cinfo = Thread.CurrentThread.CurrentCulture;
|
|
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
|
|
|
|
SerialElementCollection sec = new SerialElementCollection();
|
|
|
|
sec = GetSerialData("");
|
|
|
|
using (StreamWriterNC sw = new StreamWriterNC(stream))
|
|
{
|
|
sw.WriteLine("<?xml version=\"1.0\"?>");
|
|
|
|
ExportData(sw, sec);
|
|
}
|
|
|
|
Thread.CurrentThread.CurrentCulture = cinfo;
|
|
}
|
|
|
|
#region ExportData
|
|
|
|
private void ExportData(StreamWriterNC sw, SerialElementCollection sec)
|
|
{
|
|
foreach (SerialElement se in sec)
|
|
{
|
|
switch (se.SerType)
|
|
{
|
|
case SerElementType.Start:
|
|
sw.WriteLine("<" + se.Name + ">");
|
|
break;
|
|
|
|
case SerElementType.ValueStart:
|
|
sw.Write("<" + se.Name + ">");
|
|
break;
|
|
|
|
case SerElementType.Value:
|
|
sw.Write(se.GetValueString());
|
|
break;
|
|
|
|
case SerElementType.DataValue:
|
|
sw.Write(se.GetDataValueString());
|
|
break;
|
|
|
|
case SerElementType.End:
|
|
case SerElementType.ValueEnd:
|
|
sw.WriteLine("</" + se.Name + ">");
|
|
break;
|
|
|
|
case SerElementType.Collection:
|
|
ExportData(sw, se.Sec);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Import
|
|
|
|
/// <summary>
|
|
/// Imoprts the chart element from the given file path.
|
|
/// </summary>
|
|
/// <param name="fileName"></param>
|
|
/// <returns></returns>
|
|
public void Import(string fileName)
|
|
{
|
|
if (File.Exists(fileName) == true)
|
|
{
|
|
using (FileStream stream = new
|
|
FileStream(fileName, FileMode.Open, FileAccess.Read))
|
|
{
|
|
Import(stream);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Imoprts the chart element from the given stream.
|
|
/// </summary>
|
|
/// <param name="stream"></param>
|
|
/// <returns></returns>
|
|
public void Import(Stream stream)
|
|
{
|
|
CultureInfo cinfo = Thread.CurrentThread.CurrentCulture;
|
|
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
|
|
|
|
SerialElementCollection sec;
|
|
|
|
stream.Position = 0;
|
|
|
|
using (XmlReader reader = XmlReader.Create(stream))
|
|
sec = ImportData(reader, 0);
|
|
|
|
if (sec.Count > 0)
|
|
PutSerialData(sec);
|
|
|
|
Thread.CurrentThread.CurrentCulture = cinfo;
|
|
}
|
|
|
|
#region ImportData
|
|
|
|
internal virtual SerialElementCollection ImportData(XmlReader reader, int depth)
|
|
{
|
|
SerialElementCollection sec = new SerialElementCollection();
|
|
|
|
string name = "";
|
|
|
|
bool read = depth > 0;
|
|
|
|
int arrayCount = 0;
|
|
|
|
while (read || reader.Read())
|
|
{
|
|
read = false;
|
|
|
|
switch (reader.NodeType)
|
|
{
|
|
case XmlNodeType.Element:
|
|
if (reader.Depth == depth)
|
|
{
|
|
if (reader.IsStartElement())
|
|
{
|
|
SerialElement se = sec.AddStartElement(reader.Name);
|
|
|
|
se.ArrayCount = GetArrayCount(reader);
|
|
|
|
arrayCount = se.ArrayCount;
|
|
}
|
|
}
|
|
else if (reader.Depth > depth)
|
|
{
|
|
SerialElementCollection sec2 = ImportData(reader, reader.Depth);
|
|
|
|
SerialElement se = sec.AddElement(sec2);
|
|
|
|
se.ArrayCount = arrayCount;
|
|
|
|
se.Name = reader.Name;
|
|
sec.Name = reader.Name;
|
|
|
|
sec.AddEndElement(reader.Name);
|
|
}
|
|
|
|
name = reader.Name;
|
|
break;
|
|
|
|
case XmlNodeType.Text:
|
|
sec.AddValue(name, reader.Value);
|
|
break;
|
|
|
|
case XmlNodeType.EndElement:
|
|
if (reader.Depth < depth)
|
|
return (sec);
|
|
|
|
sec.AddEndElement(reader.Name);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return (sec);
|
|
}
|
|
|
|
#region GetArrayCount
|
|
|
|
private int GetArrayCount(XmlReader reader)
|
|
{
|
|
if (reader.HasAttributes == true)
|
|
{
|
|
string count = reader.GetAttribute("count");
|
|
|
|
if (count != null)
|
|
return (int.Parse(count));
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region INotifyPropertyChanged Members
|
|
|
|
/// <summary>
|
|
/// Default PropertyChanged processing
|
|
/// </summary>
|
|
/// <param name="s"></param>
|
|
/// <param name="changeType">invalidate</param>
|
|
protected void OnPropertyChangedEx(string s, VisualChangeType changeType)
|
|
{
|
|
OnPropertyChanged(s);
|
|
|
|
switch (changeType)
|
|
{
|
|
case VisualChangeType.Layout:
|
|
InvalidateLayout();
|
|
break;
|
|
|
|
case VisualChangeType.Recalc:
|
|
InvalidateRecalc();
|
|
break;
|
|
|
|
default:
|
|
InvalidateRender();
|
|
break;
|
|
}
|
|
}
|
|
|
|
protected void OnStyleChanged(string property,
|
|
INotifyPropertyChanged oldValue, INotifyPropertyChanged newValue)
|
|
{
|
|
StyleVisualChangeHandler(oldValue, newValue);
|
|
|
|
OnPropertyChanged(property);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IsDesignerHosted
|
|
|
|
internal bool IsDesignerHosted
|
|
{
|
|
get
|
|
{
|
|
if (ChartControl != null)
|
|
return (ChartControl.DesignerHosted);
|
|
|
|
return (false);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ElementStates
|
|
|
|
[Flags]
|
|
private enum Es
|
|
{
|
|
LayoutBoundsValid = (1 << 0),
|
|
LayoutValid = (1 << 1),
|
|
|
|
MouseOver = (1 << 2),
|
|
Displayed = (1 << 3),
|
|
Visible = (1 << 4),
|
|
|
|
NeedsMeasured = (1 << 5),
|
|
}
|
|
|
|
#region TestState
|
|
|
|
private bool TestState(Es state)
|
|
{
|
|
return ((_States & state) == state);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region SetState
|
|
|
|
private void SetState(Es state, bool value)
|
|
{
|
|
if (value == true)
|
|
_States |= state;
|
|
else
|
|
_States &= ~state;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Copy/CopyTo
|
|
|
|
public virtual ChartVisualElement Copy()
|
|
{
|
|
return (null);
|
|
}
|
|
|
|
public virtual void CopyTo(ChartVisualElement copy)
|
|
{
|
|
copy.Name = Name;
|
|
copy.Size = Size;
|
|
copy.Tag = Tag;
|
|
|
|
copy.Visible = Visible;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetSerialData
|
|
|
|
internal virtual SerialElementCollection GetSerialData(string serialName)
|
|
{
|
|
if ((String.IsNullOrEmpty(Name) == false) || (Tag != null) || (Visible == false))
|
|
{
|
|
SerialElementCollection sec = new SerialElementCollection();
|
|
|
|
if (serialName != null)
|
|
{
|
|
if (serialName.Equals("") == true)
|
|
serialName = "ChartElement";
|
|
|
|
sec.AddStartElement(serialName);
|
|
}
|
|
|
|
sec.AddValue("Name", Name, String.Empty);
|
|
sec.AddValue("Tag", Tag, null);
|
|
sec.AddValue("Visible", Visible, true);
|
|
|
|
if (serialName != null)
|
|
sec.AddEndElement(serialName);
|
|
|
|
return (sec);
|
|
}
|
|
|
|
return (null);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region PutSerialData
|
|
|
|
internal void PutSerialData(SerialElementCollection sec)
|
|
{
|
|
sec.PutSerialData(this);
|
|
}
|
|
|
|
#region ProcessValue
|
|
|
|
void IProcessSerialElement.ProcessValue(SerialElement se)
|
|
{
|
|
ProcessValue(se);
|
|
}
|
|
|
|
internal virtual void ProcessValue(SerialElement se)
|
|
{
|
|
switch (se.Name)
|
|
{
|
|
case "Name":
|
|
Name = se.StringValue;
|
|
break;
|
|
|
|
case "Tag":
|
|
Tag = se.DataValue;
|
|
break;
|
|
|
|
case "Visible":
|
|
Visible = bool.Parse(se.StringValue);
|
|
break;
|
|
|
|
default:
|
|
throw new Exception("Unknown Serial Value (" + se.Name + ")");
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ProcessCollection
|
|
|
|
void IProcessSerialElement.ProcessCollection(SerialElement se)
|
|
{
|
|
ProcessCollection(se);
|
|
}
|
|
|
|
internal virtual void ProcessCollection(SerialElement se)
|
|
{
|
|
throw new Exception("Unknown Serial Collection (" + se.Name + ")");
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
}
|
|
|
|
#region ItemHitArea
|
|
|
|
///<summary>
|
|
/// Specifies the ItemHitArea hit areas
|
|
///</summary>
|
|
public enum ItemHitArea
|
|
{
|
|
///<summary>
|
|
/// None
|
|
///</summary>
|
|
None,
|
|
|
|
/// <summary>
|
|
/// Ancillary AxisX
|
|
/// </summary>
|
|
InAncillaryAxisX,
|
|
|
|
/// <summary>
|
|
/// Primary AxisX
|
|
/// </summary>
|
|
InPrimaryAxisX,
|
|
|
|
/// <summary>
|
|
/// Ancillary AxisY
|
|
/// </summary>
|
|
InAncillaryAxisY,
|
|
|
|
/// <summary>
|
|
/// Primary AxisX
|
|
/// </summary>
|
|
InPrimaryAxisY,
|
|
|
|
/// <summary>
|
|
/// ScrollBar ArrowIncrease
|
|
/// </summary>
|
|
ArrowIncrease,
|
|
|
|
/// <summary>
|
|
/// ScrollBar ArrowDecrease
|
|
/// </summary>
|
|
ArrowDecrease,
|
|
|
|
/// <summary>
|
|
/// ScrollBar TrackIncrease
|
|
/// </summary>
|
|
TrackIncrease,
|
|
|
|
/// <summary>
|
|
/// ScrollBar ArrowDecrease
|
|
/// </summary>
|
|
TrackDecrease,
|
|
|
|
/// <summary>
|
|
/// ScrollBar Thumb
|
|
/// </summary>
|
|
Thumb,
|
|
|
|
///<summary>
|
|
/// Content area
|
|
///</summary>
|
|
InContent,
|
|
|
|
///<summary>
|
|
/// Frame area
|
|
///</summary>
|
|
InFrame,
|
|
|
|
/// <summary>
|
|
/// PieSeriesPoint
|
|
/// </summary>
|
|
InPieSeriesPoint,
|
|
|
|
/// <summary>
|
|
/// Pie Center
|
|
/// </summary>
|
|
InPieCenter,
|
|
|
|
/// <summary>
|
|
/// Pie Ring Out (Out a ring level)
|
|
/// </summary>
|
|
InPieRingOut,
|
|
|
|
/// <summary>
|
|
/// In Markup area
|
|
/// </summary>
|
|
InMarkup,
|
|
}
|
|
|
|
#endregion
|
|
}
|