1432 lines
53 KiB
C#
1432 lines
53 KiB
C#
using System;
|
|
using System.Text;
|
|
using System.Collections;
|
|
using System.ComponentModel;
|
|
using System.Drawing;
|
|
using System.Windows.Forms;
|
|
using DevComponents.DotNetBar.Rendering;
|
|
using DevComponents.Editors;
|
|
using DevComponents.DotNetBar.Ribbon;
|
|
|
|
namespace DevComponents.DotNetBar
|
|
{
|
|
/// <summary>
|
|
/// Represents rating item control which provides rating functionality.
|
|
/// </summary>
|
|
[ToolboxItem(false), DesignTimeVisible(false), DefaultEvent("RatingChanged"), Designer("DevComponents.DotNetBar.Design.RatingItemDesigner, DevComponents.DotNetBar.Design, Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf")]
|
|
public class RatingItem : PopupItem
|
|
{
|
|
#region Constructors
|
|
/// <summary>
|
|
/// Initializes a new instance of the RatingItem class.
|
|
/// </summary>
|
|
public RatingItem()
|
|
{
|
|
_BackgroundStyle.StyleChanged += new EventHandler(BackgroundStyleChanged);
|
|
_CustomImages = new RatingImages(this);
|
|
this.AutoCollapseOnClick = false;
|
|
}
|
|
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
if (BarUtilities.DisposeItemImages && !this.DesignMode)
|
|
{
|
|
BarUtilities.DisposeImage(ref _DefaultImage);
|
|
_CustomImages.Dispose();
|
|
}
|
|
base.Dispose(disposing);
|
|
}
|
|
#endregion
|
|
|
|
#region Events
|
|
/// <summary>
|
|
/// Occurs when Rating property has changed.
|
|
/// </summary>
|
|
[Description("Occurs when Rating property has changed.")]
|
|
public event EventHandler RatingChanged;
|
|
/// <summary>
|
|
/// Occurs when RatingValue property has changed.
|
|
/// </summary>
|
|
[Description("Occurs when Rating property has changed.")]
|
|
public event EventHandler RatingValueChanged;
|
|
/// <summary>
|
|
/// Occurs when Rating property is about to be changed and provides opportunity to cancel the change.
|
|
/// </summary>
|
|
[Description("Occurs when Rating property has changed.")]
|
|
public event RatingChangeEventHandler RatingChanging;
|
|
/// <summary>
|
|
/// Occurs when AverageRating property has changed.
|
|
/// </summary>
|
|
[Description("Occurs when AverageRating property has changed.")]
|
|
public event EventHandler AverageRatingChanged;
|
|
/// <summary>
|
|
/// Occurs when AverageRatingValue property has changed.
|
|
/// </summary>
|
|
[Description("Occurs when AverageRatingValue property has changed.")]
|
|
public event EventHandler AverageRatingValueChanged;
|
|
/// <summary>
|
|
/// Occurs when text markup link is clicked. Markup links can be created using "a" tag, for example:
|
|
/// <a name="MyLink">Markup link</a>
|
|
/// </summary>
|
|
public event MarkupLinkClickEventHandler MarkupLinkClick;
|
|
/// <summary>
|
|
/// Occurs when RatingValue property is set and it allows you to provide custom parsing for the values.
|
|
/// </summary>
|
|
public event ParseIntegerValueEventHandler ParseRatingValue;
|
|
/// <summary>
|
|
/// Occurs when AverageRatingValue property is set and it allows you to provide custom parsing for the values.
|
|
/// </summary>
|
|
public event ParseDoubleValueEventHandler ParseAverageRatingValue;
|
|
#endregion
|
|
|
|
#region Internal Implementation
|
|
public override BaseItem Copy()
|
|
{
|
|
RatingItem objCopy = new RatingItem();
|
|
objCopy.Name = this.Name;
|
|
this.CopyToItem(objCopy);
|
|
return objCopy;
|
|
}
|
|
/// <summary>
|
|
/// Copies the ButtonItem specific properties to new instance of the item.
|
|
/// </summary>
|
|
/// <param name="copy">New ButtonItem instance.</param>
|
|
protected override void CopyToItem(BaseItem copy)
|
|
{
|
|
RatingItem objCopy = copy as RatingItem;
|
|
objCopy.AverageRating = this.AverageRating;
|
|
objCopy.Rating = this.Rating;
|
|
objCopy.RatingOrientation = this.RatingOrientation;
|
|
objCopy.IsEditable = this.IsEditable;
|
|
objCopy.TextSpacing = this.TextSpacing;
|
|
objCopy.TextColor = this.TextColor;
|
|
objCopy.TextVisible = this.TextVisible;
|
|
base.CopyToItem(objCopy);
|
|
}
|
|
|
|
private double _AverageRating = 0;
|
|
/// <summary>
|
|
/// Gets or sets the average rating shown by control. Control will display average rating (if set) when no explicit
|
|
/// Rating value is set through Rating property. Minimum value is 0 and Maximum value is controlled by NumberOfStars property value.
|
|
/// </summary>
|
|
[DefaultValue(0d), Category("Data"), Description("Indicates average rating shown by control.")]
|
|
public double AverageRating
|
|
{
|
|
get { return _AverageRating; }
|
|
set
|
|
{
|
|
if (value < 0) value = 0;
|
|
if (value > _NumberOfStars) value = _NumberOfStars;
|
|
if (value != _AverageRating)
|
|
{
|
|
_AverageRating = value;
|
|
OnAverageRatingChanged(EventArgs.Empty);
|
|
this.Refresh();
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Raises the AverageRatingChanged event.
|
|
/// </summary>
|
|
/// <param name="eventArgs">Event data.</param>
|
|
protected virtual void OnAverageRatingChanged(EventArgs eventArgs)
|
|
{
|
|
if (AverageRatingChanged != null) AverageRatingChanged(this, eventArgs);
|
|
if (AverageRatingValueChanged != null) AverageRatingValueChanged(this, eventArgs);
|
|
}
|
|
/// <summary>
|
|
/// Gets or sets the AverageRating property. This property is provided for Data-Binding with NULL value support.
|
|
/// </summary>
|
|
[Bindable(true), Browsable(false), RefreshProperties(RefreshProperties.All), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), System.ComponentModel.TypeConverter(typeof(System.ComponentModel.StringConverter))]
|
|
public object AverageRatingValue
|
|
{
|
|
get
|
|
{
|
|
return AverageRating;
|
|
}
|
|
set
|
|
{
|
|
if (AcceptCustomAverageRatingValue(value))
|
|
return;
|
|
else if (IsNull(value))
|
|
this.AverageRating = 0;
|
|
else if (value is double || value is int || value is float)
|
|
{
|
|
this.AverageRating = (double)value;
|
|
}
|
|
else if (value is long)
|
|
{
|
|
string t = value.ToString();
|
|
this.AverageRating = double.Parse(t);
|
|
}
|
|
else if (value is string)
|
|
{
|
|
double i = 0;
|
|
#if FRAMEWORK20
|
|
if (double.TryParse(value.ToString(), out i))
|
|
this.AverageRating = i;
|
|
else
|
|
throw new ArgumentException("AverageRatingValue property expects either null/nothing value or double type.");
|
|
#else
|
|
this.AverageRating = double.Parse(value.ToString());
|
|
#endif
|
|
}
|
|
else
|
|
throw new ArgumentException("AverageRatingValue property expects either null/nothing value or double type.");
|
|
}
|
|
}
|
|
private bool AcceptCustomAverageRatingValue(object value)
|
|
{
|
|
ParseDoubleValueEventArgs e = new ParseDoubleValueEventArgs(value);
|
|
OnParseAverageRatingValue(e);
|
|
if (e.IsParsed)
|
|
{
|
|
this.AverageRating = e.ParsedValue;
|
|
}
|
|
|
|
return e.IsParsed;
|
|
}
|
|
/// <summary>
|
|
/// Raises the ParseAverageRatingValue event.
|
|
/// </summary>
|
|
/// <param name="e">Provides event arguments.</param>
|
|
protected virtual void OnParseAverageRatingValue(ParseDoubleValueEventArgs e)
|
|
{
|
|
if (ParseAverageRatingValue != null)
|
|
ParseAverageRatingValue(this, e);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the Rating value of the control and provides information about source of the rating change.
|
|
/// </summary>
|
|
/// <param name="newRating">New Rating value.</param>
|
|
/// <param name="eEventSource">Source of this change.</param>
|
|
public void SetRating(int newRating, eEventSource source)
|
|
{
|
|
if (newRating == _Rating) return;
|
|
RatingChangeEventArgs e = new RatingChangeEventArgs(newRating, _Rating, source);
|
|
OnRatingChanging(e);
|
|
if (e.Cancel) return;
|
|
newRating = e.NewRating;
|
|
_Rating = newRating;
|
|
OnRatingChanged(e);
|
|
ExecuteCommand();
|
|
this.Refresh();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Raises RatingChanging event.
|
|
/// </summary>
|
|
/// <param name="e">Event data</param>
|
|
protected virtual void OnRatingChanging(RatingChangeEventArgs e)
|
|
{
|
|
if (RatingChanging != null)
|
|
RatingChanging(this, e);
|
|
}
|
|
|
|
private int _Rating = 0;
|
|
/// <summary>
|
|
/// Gets or sets the rating value represented by the control. Default value is 0 which indicates
|
|
/// that there is no rating set. Maximum value is controlled by NumberOfStars property.
|
|
/// </summary>
|
|
[DefaultValue(0), Category("Data"), Description("Indicates rating value represented by the control.")]
|
|
public int Rating
|
|
{
|
|
get { return _Rating; }
|
|
set
|
|
{
|
|
if (value < 0) value = 0;
|
|
if (_Initialized && value > _NumberOfStars) value = _NumberOfStars;
|
|
if (_Rating != value)
|
|
{
|
|
SetRating(value, eEventSource.Code);
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Raises the RatingChanged event.
|
|
/// </summary>
|
|
/// <param name="eventArgs">Event data.</param>
|
|
protected virtual void OnRatingChanged(EventArgs eventArgs)
|
|
{
|
|
EventHandler handler = RatingChanged;
|
|
if (handler != null) handler(this, eventArgs);
|
|
|
|
handler = RatingValueChanged;
|
|
if (handler != null) handler(this, eventArgs);
|
|
}
|
|
/// <summary>
|
|
/// Gets or sets the Rating property value. This property is provided for Data-Binding with NULL value support.
|
|
/// </summary>
|
|
[Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), RefreshProperties(RefreshProperties.All), Bindable(true)]
|
|
public object RatingValue
|
|
{
|
|
get { return _Rating; }
|
|
set
|
|
{
|
|
if (AcceptCustomRatingValue(value))
|
|
return;
|
|
else if (IsNull(value))
|
|
this.Rating = 0;
|
|
else if (value is int)
|
|
{
|
|
this.Rating = (int)value;
|
|
}
|
|
else if (value is string)
|
|
{
|
|
int i = 0;
|
|
#if FRAMEWORK20
|
|
if (int.TryParse(value.ToString(), out i))
|
|
this.Rating = i;
|
|
else
|
|
throw new ArgumentException("RatingValue property expects either null/nothing value or int type.");
|
|
#else
|
|
this.Rating = int.Parse(value.ToString());
|
|
#endif
|
|
}
|
|
else
|
|
throw new ArgumentException("RatingValue property expects either null/nothing value or int type.");
|
|
}
|
|
}
|
|
protected virtual bool IsNull(object value)
|
|
{
|
|
if (value == null || value is DBNull) return true;
|
|
return false;
|
|
}
|
|
private bool AcceptCustomRatingValue(object value)
|
|
{
|
|
ParseIntegerValueEventArgs e = new ParseIntegerValueEventArgs(value);
|
|
OnParseRatingValue(e);
|
|
if (e.IsParsed)
|
|
{
|
|
this.Rating = e.ParsedValue;
|
|
}
|
|
|
|
return e.IsParsed;
|
|
}
|
|
/// <summary>
|
|
/// Raises the ParseRating event.
|
|
/// </summary>
|
|
/// <param name="e">Provides event arguments.</param>
|
|
protected virtual void OnParseRatingValue(ParseIntegerValueEventArgs e)
|
|
{
|
|
if (ParseRatingValue != null)
|
|
ParseRatingValue(this, e);
|
|
}
|
|
|
|
private bool _IsEditable = true;
|
|
/// <summary>
|
|
/// Gets or sets whether rating can be edited. Default value is true.
|
|
/// </summary>
|
|
[DefaultValue(true), Category("Behavior"), Description("Indicates whether rating can be edited.")]
|
|
public bool IsEditable
|
|
{
|
|
get { return _IsEditable; }
|
|
set
|
|
{
|
|
if (_IsEditable != value)
|
|
{
|
|
_IsEditable = value;
|
|
SetMouseOverIndex(-1);
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool _Initialized = false; // Gets set to true when control is first painted
|
|
RatingInfo[] _RatingInfo = new RatingInfo[5]; // Default number of stars
|
|
private Size _DefaultImageSize = new Size(13, 13);
|
|
public override void Paint(ItemPaintArgs p)
|
|
{
|
|
_Initialized = true;
|
|
|
|
PaintBackground(p);
|
|
|
|
Rectangle bounds = this.DisplayRectangle;
|
|
if (_RenderMenuSide)
|
|
PaintMenuItemSide(p, ref bounds);
|
|
bounds = GetClientRectangle(bounds);
|
|
if (_TextVisible && !_TextSize.IsEmpty)
|
|
PaintText(p, bounds);
|
|
|
|
Graphics g = p.Graphics;
|
|
|
|
if (_MouseOverRatingIndex >= 0)
|
|
{
|
|
RatingImage rated = GetRatedMouseOverImage();
|
|
RatingImage unrated = GetUnratedMouseOverImage();
|
|
for (int i = 0; i < _NumberOfStars; i++)
|
|
{
|
|
if (_RatingInfo[i].IsMouseOver)
|
|
g.DrawImage(rated.Image, _RatingInfo[i].Bounds, rated.SourceBounds, GraphicsUnit.Pixel);
|
|
else
|
|
g.DrawImage(unrated.Image, _RatingInfo[i].Bounds, unrated.SourceBounds, GraphicsUnit.Pixel);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int rating = Math.Min(_Rating, _NumberOfStars);
|
|
if (_AverageRating > 0 && rating == 0)
|
|
{
|
|
RatingImage rated = GetAverageRatedImage();
|
|
RatingImage unrated = GetUnratedImage();
|
|
for (int i = 0; i < _NumberOfStars; i++)
|
|
{
|
|
if (i + 1 <= _AverageRating)
|
|
g.DrawImage(rated.Image, _RatingInfo[i].Bounds, rated.SourceBounds, GraphicsUnit.Pixel);
|
|
else if (i + 1 == Math.Ceiling(_AverageRating))
|
|
{
|
|
int size = (int)((RatingOrientation == eOrientation.Horizontal ? _RatingInfo[i].Bounds.Width : _RatingInfo[i].Bounds.Height) * (_AverageRating - Math.Floor(_AverageRating)));
|
|
g.DrawImage(unrated.Image, _RatingInfo[i].Bounds, unrated.SourceBounds, GraphicsUnit.Pixel);
|
|
if (size > 0)
|
|
{
|
|
Region oldClip = g.Clip;
|
|
if (RatingOrientation == eOrientation.Horizontal)
|
|
g.SetClip(new Rectangle(_RatingInfo[i].Bounds.X, _RatingInfo[i].Bounds.Y, size, _RatingInfo[i].Bounds.Height), System.Drawing.Drawing2D.CombineMode.Intersect);
|
|
else
|
|
g.SetClip(new Rectangle(_RatingInfo[i].Bounds.X + (_RatingInfo[i].Bounds.Height - size), _RatingInfo[i].Bounds.Y, _RatingInfo[i].Bounds.Width, size), System.Drawing.Drawing2D.CombineMode.Intersect);
|
|
g.DrawImage(rated.Image, _RatingInfo[i].Bounds, rated.SourceBounds, GraphicsUnit.Pixel);
|
|
g.Clip = oldClip;
|
|
}
|
|
}
|
|
else
|
|
g.DrawImage(unrated.Image, _RatingInfo[i].Bounds, unrated.SourceBounds, GraphicsUnit.Pixel);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
RatingImage rated = GetRatedImage();
|
|
RatingImage unrated = GetUnratedImage();
|
|
for (int i = 0; i < _NumberOfStars; i++)
|
|
{
|
|
if (rating > 0 && i + 1 <= rating)
|
|
g.DrawImage(rated.Image, _RatingInfo[i].Bounds, rated.SourceBounds, GraphicsUnit.Pixel);
|
|
else
|
|
g.DrawImage(unrated.Image, _RatingInfo[i].Bounds, unrated.SourceBounds, GraphicsUnit.Pixel);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (this.Focused && this.DesignMode)
|
|
{
|
|
Rectangle r = this.DisplayRectangle;
|
|
r.Inflate(-1, -1);
|
|
DesignTime.DrawDesignTimeSelection(g, r, p.Colors.ItemDesignTimeBorder);
|
|
}
|
|
}
|
|
|
|
private void PaintText(ItemPaintArgs p, Rectangle bounds)
|
|
{
|
|
Color textColor = Color.Empty;
|
|
if (!_TextColor.IsEmpty)
|
|
textColor = _TextColor;
|
|
else
|
|
textColor = GetTextColor(p);
|
|
bool rtl = p.RightToLeft;
|
|
Rectangle textRect = bounds;
|
|
if (_BackgroundStyle.TextAlignment == eStyleTextAlignment.Far && !rtl || rtl && _BackgroundStyle.TextAlignment == eStyleTextAlignment.Near)
|
|
{
|
|
textRect.X = textRect.Right - _TextSize.Width;
|
|
textRect.Width = _TextSize.Width;
|
|
}
|
|
else
|
|
textRect.Width = _TextSize.Width;
|
|
Graphics g = p.Graphics;
|
|
Font font = p.Font;
|
|
eTextFormat textFormat = _BackgroundStyle.TextFormat;
|
|
|
|
if (_TextVisible && this.Text != "" && !textRect.IsEmpty && !textColor.IsEmpty)
|
|
{
|
|
if (this.TextMarkupBody != null)
|
|
{
|
|
TextMarkup.MarkupDrawContext d = new TextMarkup.MarkupDrawContext(g, font, textColor, rtl);
|
|
d.HotKeyPrefixVisible = !((textFormat & eTextFormat.HidePrefix) == eTextFormat.HidePrefix);
|
|
if ((textFormat & eTextFormat.VerticalCenter) == eTextFormat.VerticalCenter)
|
|
textRect.Y = this.TopInternal + (this.Bounds.Height - textRect.Height) / 2;
|
|
else if ((textFormat & eTextFormat.Bottom) == eTextFormat.Bottom)
|
|
textRect.Y += (this.Bounds.Height - textRect.Height) + 1;
|
|
|
|
this.TextMarkupBody.Bounds = textRect;
|
|
this.TextMarkupBody.Render(d);
|
|
}
|
|
else
|
|
{
|
|
#if FRAMEWORK20
|
|
if (p.GlassEnabled && this.Parent is CaptionItemContainer && !(p.ContainerControl is QatToolbar))
|
|
{
|
|
if (!p.CachedPaint)
|
|
Office2007RibbonControlPainter.PaintTextOnGlass(g, this.Text, font, textRect, TextDrawing.GetTextFormat(textFormat));
|
|
}
|
|
else
|
|
#endif
|
|
TextDrawing.DrawString(g, this.Text, font, textColor, textRect, textFormat);
|
|
}
|
|
}
|
|
}
|
|
|
|
private Color GetTextColor(ItemPaintArgs pa)
|
|
{
|
|
if (BarFunctions.IsOffice2007Style(this.EffectiveStyle) && pa.Renderer is Rendering.Office2007Renderer)
|
|
{
|
|
if ((pa.IsOnMenu || pa.IsOnPopupBar) && ((Rendering.Office2007Renderer)pa.Renderer).ColorTable.ButtonItemColors.Count > 0)
|
|
{
|
|
return GetEnabled(pa.ContainerControl) ? ((Rendering.Office2007Renderer)pa.Renderer).ColorTable.ButtonItemColors[0].Default.Text : pa.Colors.ItemDisabledText;
|
|
}
|
|
else
|
|
{
|
|
if ((pa.ContainerControl is RibbonStrip || pa.ContainerControl is Bar) && ((Rendering.Office2007Renderer)pa.Renderer).ColorTable.RibbonTabItemColors.Count > 0)
|
|
return ((Rendering.Office2007Renderer)pa.Renderer).ColorTable.RibbonTabItemColors[0].Default.Text;
|
|
Rendering.Office2007ButtonItemColorTable ct = ((Rendering.Office2007Renderer)pa.Renderer).ColorTable.ButtonItemColors[Enum.GetName(typeof(eButtonColor), eButtonColor.Orange)];
|
|
if (ct != null && !ct.Default.Text.IsEmpty)
|
|
return GetEnabled(pa.ContainerControl) ? ct.Default.Text : pa.Colors.ItemDisabledText;
|
|
}
|
|
}
|
|
else
|
|
return pa.Colors.ItemText;
|
|
|
|
return _TextColor;
|
|
}
|
|
|
|
private void PaintMenuItemSide(ItemPaintArgs pa, ref Rectangle r)
|
|
{
|
|
bool isOnMenu = this.IsOnMenu && !(this.Parent is ItemContainer);
|
|
Size objImageSize = GetMaxImageSize();
|
|
|
|
if (isOnMenu && (this.EffectiveStyle == eDotNetBarStyle.OfficeXP || this.EffectiveStyle == eDotNetBarStyle.Office2003 || this.EffectiveStyle == eDotNetBarStyle.VS2005 || BarFunctions.IsOffice2007Style(this.EffectiveStyle)))
|
|
{
|
|
Graphics g = pa.Graphics;
|
|
|
|
objImageSize.Width += 7;
|
|
r.Width -= objImageSize.Width + _MenuIndent;
|
|
if (!pa.RightToLeft)
|
|
r.X += objImageSize.Width + _MenuIndent;
|
|
if (this.IsOnCustomizeMenu)
|
|
objImageSize.Width += objImageSize.Height + 8;
|
|
Rectangle sideRect = new Rectangle(m_Rect.Left, m_Rect.Top, objImageSize.Width, m_Rect.Height);
|
|
if (pa.RightToLeft)
|
|
sideRect.X = m_Rect.Right - sideRect.Width;
|
|
// Draw side bar
|
|
//if (this.MenuVisibility == eMenuVisibility.VisibleIfRecentlyUsed && !this.RecentlyUsed)
|
|
//{
|
|
// if (!pa.Colors.MenuUnusedSide2.IsEmpty)
|
|
// {
|
|
// System.Drawing.Drawing2D.LinearGradientBrush gradient = BarFunctions.CreateLinearGradientBrush(new Rectangle(m_Rect.Left, m_Rect.Top, objImageSize.Width, m_Rect.Height), pa.Colors.MenuUnusedSide, pa.Colors.MenuUnusedSide2, pa.Colors.MenuUnusedSideGradientAngle);
|
|
// g.FillRectangle(gradient, sideRect);
|
|
// gradient.Dispose();
|
|
// }
|
|
// else
|
|
// g.FillRectangle(new SolidBrush(pa.Colors.MenuUnusedSide), sideRect);
|
|
//}
|
|
//else
|
|
{
|
|
if (!pa.Colors.MenuSide2.IsEmpty)
|
|
{
|
|
System.Drawing.Drawing2D.LinearGradientBrush gradient = BarFunctions.CreateLinearGradientBrush(sideRect, pa.Colors.MenuSide, pa.Colors.MenuSide2, pa.Colors.MenuSideGradientAngle);
|
|
g.FillRectangle(gradient, sideRect);
|
|
gradient.Dispose();
|
|
}
|
|
else
|
|
g.FillRectangle(new SolidBrush(pa.Colors.MenuSide), sideRect);
|
|
}
|
|
if (BarFunctions.IsOffice2007Style(this.EffectiveStyle) && GlobalManager.Renderer is Office2007Renderer)
|
|
{
|
|
Office2007MenuColorTable mt = ((Office2007Renderer)GlobalManager.Renderer).ColorTable.Menu;
|
|
if (mt != null && !mt.SideBorder.IsEmpty)
|
|
{
|
|
if (pa.RightToLeft)
|
|
DisplayHelp.DrawGradientLine(g, sideRect.X, sideRect.Y, sideRect.X, sideRect.Bottom - 1, mt.SideBorder, 1);
|
|
else
|
|
DisplayHelp.DrawGradientLine(g, sideRect.Right - 2, sideRect.Y, sideRect.Right - 2, sideRect.Bottom - 1, mt.SideBorder, 1);
|
|
}
|
|
if (mt != null && !mt.SideBorderLight.IsEmpty)
|
|
{
|
|
if (pa.RightToLeft)
|
|
DisplayHelp.DrawGradientLine(g, sideRect.X + 1, sideRect.Y, sideRect.X + 1, sideRect.Bottom - 1, mt.SideBorderLight, 1);
|
|
else
|
|
DisplayHelp.DrawGradientLine(g, sideRect.Right - 1, sideRect.Y, sideRect.Right - 1, sideRect.Bottom - 1, mt.SideBorderLight, 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (this.IsOnCustomizeMenu)
|
|
{
|
|
if (this.EffectiveStyle == eDotNetBarStyle.OfficeXP || this.EffectiveStyle == eDotNetBarStyle.Office2003 || this.EffectiveStyle == eDotNetBarStyle.VS2005 || BarFunctions.IsOffice2007Style(this.EffectiveStyle))
|
|
{
|
|
r.X += (objImageSize.Height + 8);
|
|
r.Width -= (objImageSize.Height + 8);
|
|
}
|
|
else
|
|
{
|
|
r.X += (objImageSize.Height + 4);
|
|
r.Width -= (objImageSize.Height + 4);
|
|
}
|
|
}
|
|
}
|
|
|
|
private RatingImage GetAverageRatedImage()
|
|
{
|
|
if (_CustomImages.AverageRated != null)
|
|
return new RatingImage(_CustomImages.AverageRated, new Rectangle(Point.Empty, _CustomImages.AverageRated.Size));
|
|
EnsureDefaultImage();
|
|
return new RatingImage(_DefaultImage, new Rectangle(0, 52, _DefaultImageSize.Width, _DefaultImageSize.Height));
|
|
}
|
|
|
|
private RatingImage GetRatedImage()
|
|
{
|
|
if (_CustomImages.Rated != null)
|
|
return new RatingImage(_CustomImages.Rated, new Rectangle(Point.Empty, _CustomImages.Rated.Size));
|
|
EnsureDefaultImage();
|
|
return new RatingImage(_DefaultImage, new Rectangle(0, 26, _DefaultImageSize.Width, _DefaultImageSize.Height));
|
|
}
|
|
|
|
private RatingImage GetUnratedImage()
|
|
{
|
|
if (_CustomImages.Unrated != null)
|
|
return new RatingImage(_CustomImages.Unrated, new Rectangle(Point.Empty, _CustomImages.Unrated.Size));
|
|
EnsureDefaultImage();
|
|
return new RatingImage(_DefaultImage, new Rectangle(0, 0, _DefaultImageSize.Width, _DefaultImageSize.Height));
|
|
}
|
|
|
|
private RatingImage GetUnratedMouseOverImage()
|
|
{
|
|
if (_CustomImages.UnratedMouseOver != null)
|
|
return new RatingImage(_CustomImages.UnratedMouseOver, new Rectangle(Point.Empty, _CustomImages.UnratedMouseOver.Size));
|
|
EnsureDefaultImage();
|
|
return new RatingImage(_DefaultImage, new Rectangle(0, 13, _DefaultImageSize.Width, _DefaultImageSize.Height));
|
|
}
|
|
|
|
private RatingImage GetRatedMouseOverImage()
|
|
{
|
|
if (_CustomImages.RatedMouseOver != null)
|
|
return new RatingImage(_CustomImages.RatedMouseOver, new Rectangle(Point.Empty, _CustomImages.RatedMouseOver.Size));
|
|
EnsureDefaultImage();
|
|
return new RatingImage(_DefaultImage, new Rectangle(0, 39, _DefaultImageSize.Width, _DefaultImageSize.Height));
|
|
}
|
|
|
|
private Image _DefaultImage = null;
|
|
private void EnsureDefaultImage()
|
|
{
|
|
if (_DefaultImage == null)
|
|
_DefaultImage = BarFunctions.LoadBitmap("SystemImages.Rating.png");
|
|
}
|
|
|
|
private struct RatingImage
|
|
{
|
|
/// <summary>
|
|
/// Initializes a new instance of the RatingImage structure.
|
|
/// </summary>
|
|
/// <param name="image"></param>
|
|
/// <param name="sourceBounds"></param>
|
|
public RatingImage(Image image, Rectangle sourceBounds)
|
|
{
|
|
Image = image;
|
|
SourceBounds = sourceBounds;
|
|
}
|
|
public Image Image;
|
|
public Rectangle SourceBounds;
|
|
}
|
|
|
|
private struct RatingInfo
|
|
{
|
|
public Rectangle Bounds;
|
|
public bool IsMouseOver;
|
|
}
|
|
|
|
public override void InternalMouseMove(System.Windows.Forms.MouseEventArgs e)
|
|
{
|
|
if (_IsEditable)
|
|
{
|
|
int mouseOverIndex = -1;
|
|
if (RatingOrientation == eOrientation.Horizontal)
|
|
{
|
|
for (int i = 0; i < _NumberOfStars; i++)
|
|
{
|
|
if (e.X >= _RatingInfo[i].Bounds.X && e.X <= _RatingInfo[i].Bounds.Right)
|
|
{
|
|
mouseOverIndex = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < _NumberOfStars; i++)
|
|
{
|
|
if (e.Y >= _RatingInfo[i].Bounds.Y && e.Y <= _RatingInfo[i].Bounds.Bottom && (!_TextVisible || _TextSize.IsEmpty) ||
|
|
_RatingInfo[i].Bounds.Contains(e.X, e.Y))
|
|
{
|
|
mouseOverIndex = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
SetMouseOverIndex(mouseOverIndex);
|
|
}
|
|
else
|
|
SetMouseOverIndex(-1);
|
|
|
|
base.InternalMouseMove(e);
|
|
}
|
|
|
|
public override void InternalClick(System.Windows.Forms.MouseButtons buttons, Point position)
|
|
{
|
|
if (_MouseOverRatingIndex >= 0)
|
|
SetRating(_MouseOverRatingIndex + 1, eEventSource.Mouse);
|
|
base.InternalClick(buttons, position);
|
|
}
|
|
|
|
private int _MouseOverRatingIndex = -1;
|
|
private void SetMouseOverIndex(int mouseOverIndex)
|
|
{
|
|
if (mouseOverIndex == _MouseOverRatingIndex) return;
|
|
_MouseOverRatingIndex=mouseOverIndex;
|
|
|
|
for (int i = 0; i < _NumberOfStars; i++)
|
|
{
|
|
_RatingInfo[i].IsMouseOver = (mouseOverIndex >= 0 && i <= mouseOverIndex);
|
|
}
|
|
Refresh();
|
|
}
|
|
|
|
public override void InternalMouseLeave()
|
|
{
|
|
if (_IsEditable)
|
|
{
|
|
SetMouseOverIndex(-1);
|
|
}
|
|
base.InternalMouseLeave();
|
|
}
|
|
|
|
private Rectangle GetClientRectangle()
|
|
{
|
|
return GetClientRectangle(this.DisplayRectangle);
|
|
}
|
|
private Rectangle GetClientRectangle(Rectangle bounds)
|
|
{
|
|
bounds.X += ElementStyleLayout.LeftWhiteSpace(_BackgroundStyle);
|
|
bounds.Y += ElementStyleLayout.TopWhiteSpace(_BackgroundStyle);
|
|
bounds.Width -= ElementStyleLayout.HorizontalStyleWhiteSpace(_BackgroundStyle);
|
|
bounds.Height -= ElementStyleLayout.VerticalStyleWhiteSpace(_BackgroundStyle);
|
|
return bounds;
|
|
}
|
|
|
|
private void UpdateRatingBounds()
|
|
{
|
|
Rectangle bounds = GetClientRectangle();
|
|
|
|
if (_TextVisible && !_TextSize.IsEmpty)
|
|
{
|
|
if (_BackgroundStyle.TextAlignment == eStyleTextAlignment.Far && this.IsRightToLeft || !this.IsRightToLeft && _BackgroundStyle.TextAlignment == eStyleTextAlignment.Near)
|
|
bounds.X += (_TextSpacing + _TextSize.Width + (_RenderMenuSide ? _MenuIndent : 0));
|
|
}
|
|
if (_RenderMenuSide)
|
|
{
|
|
if (_BackgroundStyle.TextAlignment == eStyleTextAlignment.Far && this.IsRightToLeft || !this.IsRightToLeft && _BackgroundStyle.TextAlignment == eStyleTextAlignment.Near)
|
|
{
|
|
Size objImageSize = GetMaxImageSize();
|
|
// Get the right image size that we will use for calculation
|
|
bounds.X += (objImageSize.Width + Dpi.Width7);
|
|
if (this.IsOnCustomizeMenu)
|
|
bounds.X += (bounds.Height + Dpi.Width2);
|
|
}
|
|
}
|
|
|
|
Size size = Dpi.ImageSize(DisplayHelp.MaxSize(_DefaultImageSize, _CustomImages.LargestImageSize));
|
|
if (bounds.Height > size.Height && this.RatingOrientation == eOrientation.Horizontal)
|
|
bounds.Y += (bounds.Height - size.Height) / 2;
|
|
|
|
if (this.RatingOrientation == eOrientation.Horizontal)
|
|
{
|
|
Point p = bounds.Location;
|
|
for (int i = 0; i < _NumberOfStars; i++)
|
|
{
|
|
_RatingInfo[i].Bounds = new Rectangle(p, size);
|
|
p.X += size.Width;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Point p = new Point(bounds.X, bounds.Bottom - size.Height);
|
|
for (int i = 0; i < _NumberOfStars; i++)
|
|
{
|
|
_RatingInfo[i].Bounds = new Rectangle(p, size);
|
|
p.Y -= size.Height;
|
|
}
|
|
}
|
|
}
|
|
|
|
private int _MenuIndent = 8;
|
|
private Size _TextSize = Size.Empty;
|
|
private bool _RenderMenuSide = false;
|
|
private Size _CalcSize = Size.Empty;
|
|
public override void RecalcSize()
|
|
{
|
|
Rectangle bounds = this.DisplayRectangle;
|
|
Size size = Dpi.ImageSize(DisplayHelp.MaxSize(_DefaultImageSize, _CustomImages.LargestImageSize));
|
|
|
|
if (this.RatingOrientation == eOrientation.Horizontal)
|
|
{
|
|
size.Width *= _NumberOfStars;
|
|
}
|
|
else
|
|
{
|
|
size.Height *= _NumberOfStars;
|
|
}
|
|
|
|
size.Width += ElementStyleLayout.HorizontalStyleWhiteSpace(_BackgroundStyle);
|
|
size.Height += ElementStyleLayout.VerticalStyleWhiteSpace(_BackgroundStyle);
|
|
|
|
_RenderMenuSide = false;
|
|
bool isOnMenu = this.IsOnMenu && !(this.Parent is ItemContainer);
|
|
if (isOnMenu && (this.EffectiveStyle == eDotNetBarStyle.OfficeXP || this.EffectiveStyle == eDotNetBarStyle.Office2003 || this.EffectiveStyle == eDotNetBarStyle.VS2005 || BarFunctions.IsOffice2007Style(this.EffectiveStyle)))
|
|
{
|
|
Size objImageSize = GetMaxImageSize();
|
|
// Get the right image size that we will use for calculation
|
|
size.Width += (objImageSize.Width + Dpi.Width7);
|
|
if (this.IsOnCustomizeMenu)
|
|
size.Width += (size.Height + Dpi.Width2);
|
|
size.Width += _MenuIndent;
|
|
_RenderMenuSide = true;
|
|
}
|
|
_TextSize = Size.Empty;
|
|
if (_TextVisible)
|
|
{
|
|
Control objCtrl = this.ContainerControl as Control;
|
|
if (objCtrl == null || objCtrl.Disposing || objCtrl.IsDisposed)
|
|
return;
|
|
|
|
Graphics g = BarFunctions.CreateGraphics(objCtrl);
|
|
if (g == null) return;
|
|
try
|
|
{
|
|
Size textSize = ButtonItemLayout.MeasureItemText(this, g, 0, objCtrl.Font, eTextFormat.Default, objCtrl.RightToLeft == RightToLeft.Yes);
|
|
textSize.Width += Dpi.Width1;
|
|
size.Width += _TextSpacing + textSize.Width;
|
|
size.Height = Math.Max(size.Height, textSize.Height);
|
|
_TextSize = textSize;
|
|
}
|
|
finally
|
|
{
|
|
g.Dispose();
|
|
}
|
|
}
|
|
|
|
_CalcSize = size;
|
|
bounds.Size = size;
|
|
|
|
if(!(this.ContainerControl is DevComponents.DotNetBar.Controls.RatingStar))
|
|
m_Rect = bounds;
|
|
UpdateRatingBounds();
|
|
base.RecalcSize();
|
|
}
|
|
|
|
internal Size CalcSize
|
|
{
|
|
get { return (_CalcSize); }
|
|
}
|
|
|
|
private Size GetMaxImageSize()
|
|
{
|
|
if (m_Parent != null)
|
|
{
|
|
ImageItem objParentImageItem = m_Parent as ImageItem;
|
|
if (objParentImageItem != null)
|
|
return objParentImageItem.SubItemsImageSize;
|
|
else
|
|
return this.ImageSize;
|
|
}
|
|
else
|
|
return this.ImageSize;
|
|
}
|
|
|
|
public override Rectangle Bounds
|
|
{
|
|
get { return (base.Bounds); }
|
|
|
|
set
|
|
{
|
|
if (base.Bounds.Equals(value) == false)
|
|
{
|
|
base.Bounds = value;
|
|
|
|
UpdateRatingBounds();
|
|
}
|
|
}
|
|
}
|
|
|
|
protected override void OnLeftLocationChanged(int oldValue)
|
|
{
|
|
UpdateRatingBounds();
|
|
base.OnLeftLocationChanged(oldValue);
|
|
}
|
|
|
|
protected override void OnTopLocationChanged(int oldValue)
|
|
{
|
|
UpdateRatingBounds();
|
|
base.OnTopLocationChanged(oldValue);
|
|
}
|
|
|
|
//protected override void OnExternalSizeChange()
|
|
//{
|
|
// UpdateRatingBounds();
|
|
// base.OnExternalSizeChange();
|
|
//}
|
|
|
|
protected virtual void PaintBackground(ItemPaintArgs p)
|
|
{
|
|
_BackgroundStyle.SetColorScheme(p.Colors);
|
|
Graphics g = p.Graphics;
|
|
ElementStyleDisplay.Paint(new ElementStyleDisplayInfo(_BackgroundStyle, g, this.DisplayRectangle));
|
|
}
|
|
|
|
internal void SetBackgroundStyle(ElementStyle elementStyle)
|
|
{
|
|
_BackgroundStyle.StyleChanged -= new EventHandler(BackgroundStyleChanged);
|
|
_BackgroundStyle = elementStyle;
|
|
_BackgroundStyle.StyleChanged += new EventHandler(BackgroundStyleChanged);
|
|
}
|
|
|
|
private ElementStyle _BackgroundStyle = new ElementStyle();
|
|
/// <summary>
|
|
/// Specifies the control background style. Default value is an empty style which means that container does not display any background.
|
|
/// </summary>
|
|
[Browsable(true), DevCoBrowsable(true), Category("Style"), Description("Gets or sets control background style."), DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public ElementStyle BackgroundStyle
|
|
{
|
|
get { return _BackgroundStyle; }
|
|
}
|
|
private void BackgroundStyleChanged(object sender, EventArgs e)
|
|
{
|
|
this.NeedRecalcSize = true;
|
|
this.OnAppearanceChanged();
|
|
}
|
|
|
|
private RatingImages _CustomImages;
|
|
/// <summary>
|
|
/// Gets the reference to custom rating images.
|
|
/// </summary>
|
|
[Browsable(true), Category("Images"), Description("Gets the reference to custom rating images."), DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public RatingImages CustomImages
|
|
{
|
|
get { return _CustomImages; }
|
|
}
|
|
|
|
private bool _TextVisible = true;
|
|
/// <summary>
|
|
/// Gets or sets whether text assigned to the check box is visible. Default value is true.
|
|
/// </summary>
|
|
[Browsable(true), DefaultValue(true), Category("Appearance"), Description("Indicates whether text assigned to the check box is visible.")]
|
|
public bool TextVisible
|
|
{
|
|
get { return _TextVisible; }
|
|
set
|
|
{
|
|
_TextVisible = value;
|
|
this.NeedRecalcSize = true;
|
|
OnAppearanceChanged();
|
|
}
|
|
}
|
|
|
|
private Color _TextColor = Color.Empty;
|
|
/// <summary>
|
|
/// Gets or sets the text color. Default value is Color.Empty which indicates that default color is used.
|
|
/// </summary>
|
|
[Browsable(true), Category("Appearance"), Description("Indicates text color.")]
|
|
public Color TextColor
|
|
{
|
|
get { return _TextColor; }
|
|
set
|
|
{
|
|
_TextColor = value;
|
|
OnAppearanceChanged();
|
|
}
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public bool ShouldSerializeTextColor()
|
|
{
|
|
return !_TextColor.IsEmpty;
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public void ResetTextColor()
|
|
{
|
|
this.TextColor = Color.Empty;
|
|
}
|
|
|
|
private int _TextSpacing = 0;
|
|
/// <summary>
|
|
/// Gets or sets the spacing between optional text and the rating.
|
|
/// </summary>
|
|
[DefaultValue(0), Category("Appearance"), Description("Gets or sets the spacing between optional text and the rating.")]
|
|
public int TextSpacing
|
|
{
|
|
get { return _TextSpacing; }
|
|
set
|
|
{
|
|
if (_TextSpacing != value)
|
|
{
|
|
_TextSpacing = value;
|
|
NeedRecalcSize = true;
|
|
this.Refresh();
|
|
}
|
|
}
|
|
}
|
|
|
|
private eOrientation _RatingOrientation = eOrientation.Horizontal;
|
|
/// <summary>
|
|
/// Gets or sets the orientation of rating control.
|
|
/// </summary>
|
|
[DefaultValue(eOrientation.Horizontal), Category("Appearance"), Description("Gets or sets the orientation of rating control.")]
|
|
public eOrientation RatingOrientation
|
|
{
|
|
get { return _RatingOrientation; }
|
|
set
|
|
{
|
|
if (_RatingOrientation != value)
|
|
{
|
|
_RatingOrientation = value;
|
|
NeedRecalcSize = true;
|
|
this.Refresh();
|
|
}
|
|
}
|
|
}
|
|
|
|
private int _NumberOfStars = 5;
|
|
/// <summary>
|
|
/// Indicates number of stars used for the rating. Minium value is 2 stars.
|
|
/// </summary>
|
|
[DefaultValue(5), Category("Appearance"), Description("Indicates number of stars used for the rating.")]
|
|
public int NumberOfStars
|
|
{
|
|
get { return _NumberOfStars; }
|
|
set
|
|
{
|
|
if (_NumberOfStars < 2) _NumberOfStars = 2;
|
|
if (_NumberOfStars != value)
|
|
{
|
|
_NumberOfStars = value;
|
|
if (_Rating > _NumberOfStars) _Rating = _NumberOfStars;
|
|
_RatingInfo = new RatingInfo[_NumberOfStars];
|
|
NeedRecalcSize = true;
|
|
this.Refresh();
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Markup Implementation
|
|
/// <summary>
|
|
/// Gets whether item supports text markup. Default is false.
|
|
/// </summary>
|
|
protected override bool IsMarkupSupported
|
|
{
|
|
get { return _EnableMarkup; }
|
|
}
|
|
|
|
private bool _EnableMarkup = true;
|
|
/// <summary>
|
|
/// Gets or sets whether text-markup support is enabled for items Text property. Default value is true.
|
|
/// Set this property to false to display HTML or other markup in the item instead of it being parsed as text-markup.
|
|
/// </summary>
|
|
[DefaultValue(true), Category("Appearance"), Description("Indicates whether text-markup support is enabled for items Text property.")]
|
|
public bool EnableMarkup
|
|
{
|
|
get { return _EnableMarkup; }
|
|
set
|
|
{
|
|
if (_EnableMarkup != value)
|
|
{
|
|
_EnableMarkup = value;
|
|
NeedRecalcSize = true;
|
|
OnTextChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
protected override void TextMarkupLinkClick(object sender, EventArgs e)
|
|
{
|
|
TextMarkup.HyperLink link = sender as TextMarkup.HyperLink;
|
|
if (link != null)
|
|
OnMarkupLinkClick(new MarkupLinkClickEventArgs(link.Name, link.HRef));
|
|
base.TextMarkupLinkClick(sender, e);
|
|
}
|
|
|
|
protected virtual void OnMarkupLinkClick(MarkupLinkClickEventArgs e)
|
|
{
|
|
if (this.MarkupLinkClick != null)
|
|
MarkupLinkClick(this, e);
|
|
}
|
|
#endregion
|
|
|
|
#region Property Hiding
|
|
[Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public override SubItemsCollection SubItems
|
|
{
|
|
get
|
|
{
|
|
return base.SubItems;
|
|
}
|
|
}
|
|
|
|
[Browsable(false)]
|
|
public override bool ClickAutoRepeat
|
|
{
|
|
get
|
|
{
|
|
return base.ClickAutoRepeat;
|
|
}
|
|
set
|
|
{
|
|
base.ClickAutoRepeat = value;
|
|
}
|
|
}
|
|
[Browsable(false)]
|
|
public override int ClickRepeatInterval
|
|
{
|
|
get
|
|
{
|
|
return base.ClickRepeatInterval;
|
|
}
|
|
set
|
|
{
|
|
base.ClickRepeatInterval = value;
|
|
}
|
|
}
|
|
[Browsable(false)]
|
|
public override ePersonalizedMenus PersonalizedMenus
|
|
{
|
|
get
|
|
{
|
|
return base.PersonalizedMenus;
|
|
}
|
|
set
|
|
{
|
|
base.PersonalizedMenus = value;
|
|
}
|
|
}
|
|
[Browsable(false)]
|
|
public override ePopupAnimation PopupAnimation
|
|
{
|
|
get
|
|
{
|
|
return base.PopupAnimation;
|
|
}
|
|
set
|
|
{
|
|
base.PopupAnimation = value;
|
|
}
|
|
}
|
|
[Browsable(false)]
|
|
public override Font PopupFont
|
|
{
|
|
get
|
|
{
|
|
return base.PopupFont;
|
|
}
|
|
set
|
|
{
|
|
base.PopupFont = value;
|
|
}
|
|
}
|
|
[Browsable(false)]
|
|
public override ePopupSide PopupSide
|
|
{
|
|
get
|
|
{
|
|
return base.PopupSide;
|
|
}
|
|
set
|
|
{
|
|
base.PopupSide = value;
|
|
}
|
|
}
|
|
[Browsable(false)]
|
|
public override ePopupType PopupType
|
|
{
|
|
get
|
|
{
|
|
return base.PopupType;
|
|
}
|
|
set
|
|
{
|
|
base.PopupType = value;
|
|
}
|
|
}
|
|
[Browsable(false)]
|
|
public override int PopupWidth
|
|
{
|
|
get
|
|
{
|
|
return base.PopupWidth;
|
|
}
|
|
set
|
|
{
|
|
base.PopupWidth = value;
|
|
}
|
|
}
|
|
[Browsable(false)]
|
|
public override ShortcutsCollection Shortcuts
|
|
{
|
|
get
|
|
{
|
|
return base.Shortcuts;
|
|
}
|
|
set
|
|
{
|
|
base.Shortcuts = value;
|
|
}
|
|
}
|
|
[Browsable(false)]
|
|
public override bool ShowSubItems
|
|
{
|
|
get
|
|
{
|
|
return base.ShowSubItems;
|
|
}
|
|
set
|
|
{
|
|
base.ShowSubItems = value;
|
|
}
|
|
}
|
|
[Browsable(false)]
|
|
public override bool Stretch
|
|
{
|
|
get
|
|
{
|
|
return base.Stretch;
|
|
}
|
|
set
|
|
{
|
|
base.Stretch = value;
|
|
}
|
|
}
|
|
[Browsable(false)]
|
|
public override bool ThemeAware
|
|
{
|
|
get
|
|
{
|
|
return base.ThemeAware;
|
|
}
|
|
set
|
|
{
|
|
base.ThemeAware = value;
|
|
}
|
|
}
|
|
[DefaultValue(false)]
|
|
public override bool AutoCollapseOnClick
|
|
{
|
|
get
|
|
{
|
|
return base.AutoCollapseOnClick;
|
|
}
|
|
set
|
|
{
|
|
base.AutoCollapseOnClick = value;
|
|
}
|
|
}
|
|
#endregion
|
|
}
|
|
|
|
#region RatingImages
|
|
/// <summary>
|
|
/// Defines the custom rating images for Rating control.
|
|
/// </summary>
|
|
[ToolboxItem(false), TypeConverter(typeof(System.ComponentModel.ExpandableObjectConverter))]
|
|
public class RatingImages
|
|
{
|
|
private RatingItem _Parent = null;
|
|
/// <summary>
|
|
/// Initializes a new instance of the RatingImages class.
|
|
/// </summary>
|
|
internal RatingImages(RatingItem parentItem)
|
|
{
|
|
_Parent = parentItem;
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
BarUtilities.DisposeImage(ref _AverageRated);
|
|
BarUtilities.DisposeImage(ref _Rated);
|
|
BarUtilities.DisposeImage(ref _RatedMouseOver);
|
|
BarUtilities.DisposeImage(ref _Unrated);
|
|
BarUtilities.DisposeImage(ref _UnratedMouseOver);
|
|
}
|
|
|
|
private Image _Unrated = null;
|
|
/// <summary>
|
|
/// Gets or sets the image used for unrated rating part.
|
|
/// </summary>
|
|
[DefaultValue(null), Description("Gets or sets the image used for unrated rating part.")]
|
|
public Image Unrated
|
|
{
|
|
get
|
|
{
|
|
return _Unrated;
|
|
}
|
|
set
|
|
{
|
|
if (_Unrated != value)
|
|
{
|
|
_Unrated = value;
|
|
OnImageChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
private Image _UnratedMouseOver = null;
|
|
/// <summary>
|
|
/// Gets or sets the image used for unrated rating part when mouse is over the control.
|
|
/// </summary>
|
|
[DefaultValue(null), Description("Gets or sets the image used for unrated rating part when mouse is over the control.")]
|
|
public Image UnratedMouseOver
|
|
{
|
|
get
|
|
{
|
|
return _UnratedMouseOver;
|
|
}
|
|
set
|
|
{
|
|
if (_UnratedMouseOver != value)
|
|
{
|
|
_UnratedMouseOver = value;
|
|
OnImageChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
private Image _Rated = null;
|
|
/// <summary>
|
|
/// Gets or sets the image used for rated part of the control.
|
|
/// </summary>
|
|
[DefaultValue(null), Description("Gets or sets the image used for rated part of the control.")]
|
|
public Image Rated
|
|
{
|
|
get
|
|
{
|
|
return _Rated;
|
|
}
|
|
set
|
|
{
|
|
if (_Rated != value)
|
|
{
|
|
_Rated = value;
|
|
OnImageChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
private Image _AverageRated = null;
|
|
/// <summary>
|
|
/// Gets or sets the image used for Average Rated part of the control.
|
|
/// </summary>
|
|
[DefaultValue(null), Description("Gets or sets the image used for Average Rated part of the control.")]
|
|
public Image AverageRated
|
|
{
|
|
get
|
|
{
|
|
return _AverageRated;
|
|
}
|
|
set
|
|
{
|
|
if (_AverageRated != value)
|
|
{
|
|
_AverageRated = value;
|
|
OnImageChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
private Image _RatedMouseOver = null;
|
|
/// <summary>
|
|
/// Gets or sets the image used for rated part of the control when mouse is over the control.
|
|
/// </summary>
|
|
[DefaultValue(null), Description("Gets or sets the image used for rated part of the control when mouse is over the control.")]
|
|
public Image RatedMouseOver
|
|
{
|
|
get
|
|
{
|
|
return _RatedMouseOver;
|
|
}
|
|
set
|
|
{
|
|
if (_RatedMouseOver != value)
|
|
{
|
|
_RatedMouseOver = value;
|
|
OnImageChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
private Size _LargestImageSize = Size.Empty;
|
|
internal Size LargestImageSize
|
|
{
|
|
get
|
|
{
|
|
return _LargestImageSize;
|
|
}
|
|
}
|
|
|
|
private void OnImageChanged()
|
|
{
|
|
_LargestImageSize = new Size();
|
|
if (_Unrated != null)
|
|
_LargestImageSize = DisplayHelp.MaxSize(_LargestImageSize, _Unrated.Size);
|
|
if (_UnratedMouseOver != null)
|
|
_LargestImageSize = DisplayHelp.MaxSize(_LargestImageSize, _UnratedMouseOver.Size);
|
|
if (_Rated != null)
|
|
_LargestImageSize = DisplayHelp.MaxSize(_LargestImageSize, _Rated.Size);
|
|
if (_RatedMouseOver != null)
|
|
_LargestImageSize = DisplayHelp.MaxSize(_LargestImageSize, _RatedMouseOver.Size);
|
|
if (_AverageRated != null)
|
|
_LargestImageSize = DisplayHelp.MaxSize(_LargestImageSize, _AverageRated.Size);
|
|
|
|
if (_Parent != null)
|
|
{
|
|
_Parent.NeedRecalcSize = true;
|
|
_Parent.OnAppearanceChanged();
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
/// <summary>
|
|
/// Delegate for Rating change events.
|
|
/// </summary>
|
|
public delegate void RatingChangeEventHandler(object sender, RatingChangeEventArgs e);
|
|
|
|
#region CheckBoxChangeEventArgs
|
|
/// <summary>
|
|
/// Represents event arguments for Rating change events.
|
|
/// </summary>
|
|
public class RatingChangeEventArgs : CancelEventArgs
|
|
{
|
|
/// <summary>
|
|
/// New Rating value being assigned.
|
|
/// </summary>
|
|
public int NewRating;
|
|
/// <summary>
|
|
/// Previous or current value (if RatingChanging event).
|
|
/// </summary>
|
|
public readonly int OldRating;
|
|
/// <summary>
|
|
/// Indicates the action that has caused the event.
|
|
/// </summary>
|
|
public readonly eEventSource EventSource = eEventSource.Code;
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the RatingChangeEventArgs class.
|
|
/// </summary>
|
|
/// <param name="newRating"></param>
|
|
/// <param name="oldRating"></param>
|
|
/// <param name="eventSource"></param>
|
|
public RatingChangeEventArgs(int newRating, int oldRating, eEventSource eventSource)
|
|
{
|
|
NewRating = newRating;
|
|
OldRating = oldRating;
|
|
EventSource = eventSource;
|
|
}
|
|
}
|
|
#endregion
|
|
}
|