using System.Collections.Generic;
|
using System.Drawing;
|
|
namespace System.Windows.Forms
|
{
|
/// <summary>
|
/// Provides mouse functionality to RibbonTab, RibbonPanel and RibbonItem objects on a specified Control
|
/// </summary>
|
public class RibbonMouseSensor : IDisposable
|
{
|
|
#region Fields
|
|
private RibbonItem _lastMouseDown;
|
#endregion
|
|
#region Constructor
|
|
/// <summary>
|
/// Initializes inner fields
|
/// </summary>
|
private RibbonMouseSensor()
|
{
|
Tabs = new List<RibbonTab>();
|
Panels = new List<RibbonPanel>();
|
Items = new List<RibbonItem>();
|
|
}
|
|
/// <summary>
|
/// Creates a new Empty Sensor
|
/// </summary>
|
/// <param name="control">Control to listen mouse events</param>
|
/// <param name="ribbon">Ribbon that will be affected</param>
|
public RibbonMouseSensor(Control control, Ribbon ribbon)
|
: this()
|
{
|
Control = control ?? throw new ArgumentNullException(nameof(control));
|
Ribbon = ribbon ?? throw new ArgumentNullException(nameof(ribbon));
|
|
AddHandlers();
|
}
|
|
/// <summary>
|
/// Creates a new Sensor for specified objects
|
/// </summary>
|
/// <param name="control">Control to listen mouse events</param>
|
/// <param name="ribbon">Ribbon that will be affected</param>
|
/// <param name="tabs">Tabs that will be sensed</param>
|
/// <param name="panels">Panels that will be sensed</param>
|
/// <param name="items">Items that will be sensed</param>
|
public RibbonMouseSensor(Control control, Ribbon ribbon, IEnumerable<RibbonTab> tabs, IEnumerable<RibbonPanel> panels, IEnumerable<RibbonItem> items)
|
: this(control, ribbon)
|
{
|
if (tabs != null) Tabs.AddRange(tabs);
|
if (panels != null) Panels.AddRange(panels);
|
if (items != null) Items.AddRange(items);
|
}
|
|
/// <summary>
|
/// Creates a new Sensor for the specified RibbonTab
|
/// </summary>
|
/// <param name="control">Control to listen to mouse events</param>
|
/// <param name="ribbon">Ribbon that will be affected</param>
|
/// <param name="tab">Tab that will be sensed, from which all panels and items will be extracted to sensing also.</param>
|
public RibbonMouseSensor(Control control, Ribbon ribbon, RibbonTab tab)
|
: this(control, ribbon)
|
{
|
Tabs.Add(tab);
|
Panels.AddRange(tab.Panels);
|
|
foreach (RibbonPanel panel in tab.Panels)
|
{
|
Items.AddRange(panel.Items);
|
}
|
}
|
|
/// <summary>
|
/// Creates a new Sensor for only the specified items
|
/// </summary>
|
/// <param name="control">Control to listen to mouse events</param>
|
/// <param name="ribbon">Ribbon that will be affected</param>
|
/// <param name="itemsSource">Items that will be sensed</param>
|
public RibbonMouseSensor(Control control, Ribbon ribbon, IEnumerable<RibbonItem> itemsSource)
|
: this(control, ribbon)
|
{
|
ItemsSource = itemsSource;
|
|
/* If an item in a dropdown list (i.e. Combobox dropdown) is selected when the dropdown is shown,
|
* make it the last hit item. When the mouse is moved onto an item, the previous item will be deselected.
|
* Otherwise the initial item will never be unselected until it is moused over.
|
*/
|
foreach (RibbonItem item in itemsSource)
|
{
|
if (item.Selected)
|
HittedItem = item;
|
}
|
}
|
|
#endregion
|
|
#region Properties
|
|
/// <summary>
|
/// Gets the control where the sensor listens to mouse events
|
/// </summary>
|
public Control Control { get; }
|
|
/// <summary>
|
/// Gets if the sensor has already been
|
/// </summary>
|
public bool Disposed { get; private set; }
|
|
/// <summary>
|
/// Gets the RibbonTab hitted by the last <see cref="HitTest"/>
|
/// </summary>
|
internal RibbonTab HittedTab { get; set; }
|
|
/// <summary>
|
/// Gets if the test hit resulted on some scroll button of the hitted tab
|
/// </summary>
|
internal bool HittedTabScroll => HittedTabScrollLeft || HittedTabScrollRight;
|
|
/// <summary>
|
/// Gets or sets if the last hit test resulted on the left scroll of the hitted tab
|
/// </summary>
|
internal bool HittedTabScrollLeft { get; set; }
|
|
/// <summary>
|
/// Gets or sets if the last hit test resulted on the right scroll of the hitted tab
|
/// </summary>
|
internal bool HittedTabScrollRight { get; set; }
|
|
/// <summary>
|
/// Gets the RibbonPanel hitted by the last <see cref="HitTest"/>
|
/// </summary>
|
internal RibbonPanel HittedPanel { get; set; }
|
|
/// <summary>
|
/// Gets the RibbonItem hitted by the last <see cref="HitTest"/>
|
/// </summary>
|
internal RibbonItem HittedItem { get; set; }
|
|
/// <summary>
|
/// Gets the RibbonItem (on other RibbonItem) hitted by the last <see cref="HitTest"/>
|
/// </summary>
|
internal RibbonItem HittedSubItem { get; set; }
|
|
[Obsolete("use IsSuspended")]
|
public bool IsSupsended { get { return IsSuspended; } }
|
/// <summary>
|
/// Gets if the sensor is currently suspended
|
/// </summary>
|
public bool IsSuspended { get; private set; }
|
|
/// <summary>
|
/// Gets or ests the source of items what limits the sensing.
|
/// If collection is null, all items on the <see cref="Items"/> property will be sensed.
|
/// </summary>
|
public IEnumerable<RibbonItem> ItemsSource { get; set; }
|
|
/// <summary>
|
/// Gets the collection of items this sensor affects.
|
/// </summary>
|
|
/////@Todo: Sensing can be limitated by the <see cref="ItemsLimit"/> property
|
public List<RibbonItem> Items { get; }
|
|
/// <summary>
|
/// Gets or sets the Panel that will be the limit to be sensed.
|
/// If set to null, all panels in the <see cref="Panels"/> property will be sensed.
|
/// </summary>
|
public RibbonPanel PanelLimit { get; set; }
|
|
/// <summary>
|
/// Gets the collection of panels this sensor affects.
|
/// Sensing can be limitated by the <see cref="PanelLimit"/> property
|
/// </summary>
|
public List<RibbonPanel> Panels { get; }
|
|
/// <summary>
|
/// Gets the ribbon this sensor responds to
|
/// </summary>
|
public Ribbon Ribbon { get; }
|
|
|
/// <summary>
|
/// Gets or sets the last selected tab
|
/// </summary>
|
internal RibbonTab SelectedTab { get; set; }
|
|
|
/// <summary>
|
/// Gets or sets the last selected panel
|
/// </summary>
|
internal RibbonPanel SelectedPanel { get; set; }
|
|
|
/// <summary>
|
/// Gets or sets the last selected item
|
/// </summary>
|
internal RibbonItem SelectedItem { get; set; }
|
|
/// <summary>
|
/// Gets or sets the last selected sub-item
|
/// </summary>
|
internal RibbonItem SelectedSubItem { get; set; }
|
|
|
/// <summary>
|
/// Gets or sets the Tab that will be the only to be sensed.
|
/// If set to null, all tabs in the <see cref="Tabs"/> property will be sensed.
|
/// </summary>
|
public RibbonTab TabLimit { get; set; }
|
|
/// <summary>
|
/// Gets the collection of tabs this sensor affects.
|
/// Sensing can be limitated by the <see cref="TabLimit"/> property
|
/// </summary>
|
public List<RibbonTab> Tabs { get; }
|
|
#endregion
|
|
#region Methods
|
|
/// <summary>
|
/// Adds the necessary handlers to the control
|
/// </summary>
|
private void AddHandlers()
|
{
|
if (Control == null)
|
{
|
throw new ArgumentNullException(nameof(Control), "Control is Null, cant Add RibbonMouseSensor Handles");
|
}
|
|
Control.MouseMove += Control_MouseMove;
|
Control.MouseLeave += Control_MouseLeave;
|
Control.MouseDown += Control_MouseDown;
|
Control.MouseUp += Control_MouseUp;
|
Control.MouseClick += Control_MouseClick;
|
Control.MouseDoubleClick += Control_MouseDoubleClick;
|
//Control.MouseEnter
|
}
|
|
private void Control_MouseDoubleClick(object sender, MouseEventArgs e)
|
{
|
if (IsSuspended || Disposed) return;
|
|
#region Panel
|
if (HittedPanel != null)
|
{
|
HittedPanel.OnDoubleClick(e);
|
}
|
#endregion
|
|
#region Item
|
|
if (HittedItem != null)
|
{
|
HittedItem.OnDoubleClick(e);
|
}
|
|
#endregion
|
|
#region SubItem
|
|
if (HittedSubItem != null)
|
{
|
HittedSubItem.OnDoubleClick(e);
|
}
|
|
#endregion
|
|
}
|
|
private void Control_MouseClick(object sender, MouseEventArgs e)
|
{
|
if (IsSuspended || Disposed) return;
|
|
#region Panel
|
if (HittedPanel != null)
|
{
|
HittedPanel.OnClick(e);
|
}
|
#endregion
|
|
#region Item
|
|
//Kevin Carbis - Added _lastMouseDown variable to track if our click originated with this control.
|
//Sometimes when scrolling your mouse moves off the thumb while dragging and your mouseup event
|
//is not the same control that you started with. This omits firing the click event on the control you
|
//eventually release the mouse over if it wasn't the control you started with.
|
if (HittedItem != null && HittedItem == _lastMouseDown)
|
{
|
////Kevin Carbis - this fixes the focus problem with textboxes when a different item is clicked
|
////and the edit box is still visible. This will now close the edit box for the textbox that previously
|
////had the focus. Otherwise the first click on a button would close the textbox and you would have to click twice.
|
////Control.Focus();
|
//if (_ribbon.ActiveTextBox != null)
|
// (_ribbon.ActiveTextBox as RibbonTextBox).EndEdit();
|
|
//foreach (RibbonPanel pnl in HittedItem.OwnerTab.Panels)
|
//{
|
// foreach (RibbonItem itm in pnl.Items)
|
// {
|
// if (itm is RibbonTextBox && itm != HittedItem)
|
// {
|
// RibbonTextBox txt = (RibbonTextBox)itm;
|
// txt.EndEdit();
|
// }
|
// }
|
//}
|
|
HittedItem.OnClick(e);
|
}
|
|
#endregion
|
|
#region SubItem
|
|
if (HittedSubItem != null)
|
{
|
HittedSubItem.OnClick(e);
|
}
|
|
#endregion
|
}
|
|
/// <summary>
|
/// Handles the MouseUp event on the control
|
/// </summary>
|
/// <param name="sender"></param>
|
/// <param name="e"></param>
|
private void Control_MouseUp(object sender, MouseEventArgs e)
|
{
|
if (IsSuspended || Disposed) return;
|
|
#region Tab Scrolls
|
if (HittedTab != null)
|
{
|
if (HittedTab.ScrollLeftVisible)
|
{
|
HittedTab.SetScrollLeftPressed(false);
|
Control.Invalidate(HittedTab.ScrollLeftBounds);
|
}
|
if (HittedTab.ScrollRightVisible)
|
{
|
HittedTab.SetScrollRightPressed(false);
|
Control.Invalidate(HittedTab.ScrollRightBounds);
|
}
|
}
|
#endregion
|
|
#region Panel
|
if (HittedPanel != null)
|
{
|
HittedPanel.SetPressed(false);
|
HittedPanel.OnMouseUp(e);
|
Control.Invalidate(HittedPanel.Bounds);
|
}
|
#endregion
|
|
#region Item
|
|
if (HittedItem != null)
|
{
|
HittedItem.SetPressed(false);
|
HittedItem.OnMouseUp(e);
|
Control.Invalidate(HittedItem.Bounds);
|
}
|
|
#endregion
|
|
#region SubItem
|
|
if (HittedSubItem != null)
|
{
|
HittedSubItem.SetPressed(false);
|
HittedSubItem.OnMouseUp(e);
|
Control.Invalidate(Rectangle.Intersect(HittedItem.Bounds, HittedSubItem.Bounds));
|
}
|
|
#endregion
|
}
|
|
/// <summary>
|
/// Handles the MouseDown on the control
|
/// </summary>
|
/// <param name="sender"></param>
|
/// <param name="e"></param>
|
private void Control_MouseDown(object sender, MouseEventArgs e)
|
{
|
if (IsSuspended || Disposed) return;
|
|
HitTest(e.Location);
|
_lastMouseDown = HittedItem;
|
|
#region Tab Scrolls
|
if (HittedTab != null)
|
{
|
if (HittedTabScrollLeft)
|
{
|
HittedTab.SetScrollLeftPressed(true);
|
Control.Invalidate(HittedTab.ScrollLeftBounds);
|
}
|
|
if (HittedTabScrollRight)
|
{
|
HittedTab.SetScrollRightPressed(true);
|
Control.Invalidate(HittedTab.ScrollRightBounds);
|
}
|
}
|
#endregion
|
|
#region Panel
|
if (HittedPanel != null)
|
{
|
HittedPanel.SetPressed(true);
|
HittedPanel.OnMouseDown(e);
|
Control.Invalidate(HittedPanel.Bounds);
|
}
|
#endregion
|
|
#region Item
|
|
if (HittedItem != null)
|
{
|
HittedItem.SetPressed(true);
|
HittedItem.OnMouseDown(e);
|
Control.Invalidate(HittedItem.Bounds);
|
}
|
|
#endregion
|
|
#region SubItem
|
|
if (HittedSubItem != null)
|
{
|
HittedSubItem.SetPressed(true);
|
HittedSubItem.OnMouseDown(e);
|
Control.Invalidate(Rectangle.Intersect(HittedItem.Bounds, HittedSubItem.Bounds));
|
}
|
|
#endregion
|
}
|
|
/// <summary>
|
/// Handles the MouseLeave on the control
|
/// </summary>
|
/// <param name="sender"></param>
|
/// <param name="e"></param>
|
private void Control_MouseLeave(object sender, EventArgs e)
|
{
|
if (IsSuspended || Disposed) return;
|
}
|
|
/// <summary>
|
/// Handles the MouseMove on the control
|
/// </summary>
|
/// <param name="sender"></param>
|
/// <param name="e"></param>
|
private void Control_MouseMove(object sender, MouseEventArgs e)
|
{
|
if (IsSuspended || Disposed) return;
|
//Console.WriteLine("MouseMove " + Control.Name);
|
HitTest(e.Location);
|
|
#region Selected ones
|
|
if (SelectedPanel != null && SelectedPanel != HittedPanel)
|
{
|
SelectedPanel.SetSelected(false);
|
SelectedPanel.OnMouseLeave(e);
|
Control.Invalidate(SelectedPanel.Bounds);
|
}
|
|
if (SelectedItem != null && SelectedItem != HittedItem)
|
{
|
SelectedItem.SetSelected(false);
|
SelectedItem.OnMouseLeave(e);
|
Control.Invalidate(SelectedItem.Bounds);
|
}
|
|
if (SelectedSubItem != null && SelectedSubItem != HittedSubItem)
|
{
|
SelectedSubItem.SetSelected(false);
|
SelectedSubItem.OnMouseLeave(e);
|
Control.Invalidate(Rectangle.Intersect(SelectedItem.Bounds, SelectedSubItem.Bounds));
|
}
|
|
#endregion
|
|
#region Tab Scrolls
|
if (HittedTab != null)
|
{
|
if (HittedTab.ScrollLeftVisible)
|
{
|
HittedTab.SetScrollLeftSelected(HittedTabScrollLeft);
|
Control.Invalidate(HittedTab.ScrollLeftBounds);
|
}
|
if (HittedTab.ScrollRightVisible)
|
{
|
HittedTab.SetScrollRightSelected(HittedTabScrollRight);
|
Control.Invalidate(HittedTab.ScrollRightBounds);
|
}
|
}
|
#endregion
|
|
#region Panel
|
if (HittedPanel != null)
|
{
|
if (HittedPanel == SelectedPanel)
|
{
|
HittedPanel.OnMouseMove(e);
|
}
|
else
|
{
|
|
HittedPanel.SetSelected(true);
|
HittedPanel.OnMouseEnter(e);
|
Control.Invalidate(HittedPanel.Bounds);
|
}
|
}
|
#endregion
|
|
#region Item
|
|
if (HittedItem != null)
|
{
|
if (HittedItem == SelectedItem)
|
{
|
HittedItem.OnMouseMove(e);
|
}
|
else
|
{
|
|
HittedItem.SetSelected(true);
|
HittedItem.OnMouseEnter(e);
|
Control.Invalidate(HittedItem.Bounds);
|
}
|
}
|
|
#endregion
|
|
#region SubItem
|
|
if (HittedSubItem != null)
|
{
|
if (HittedSubItem == SelectedSubItem)
|
{
|
HittedSubItem.OnMouseMove(e);
|
}
|
else
|
{
|
HittedSubItem.SetSelected(true);
|
HittedSubItem.OnMouseEnter(e);
|
Control.Invalidate(Rectangle.Intersect(HittedItem.Bounds, HittedSubItem.Bounds));
|
}
|
}
|
|
#endregion
|
}
|
|
/// <summary>
|
/// Performs a hit-test and specifies hitted objects on properties: <see cref="HittedPanel"/>,
|
/// <see cref="HittedTab"/>, <see cref="HittedItem"/> and <see cref="HittedSubItem"/>
|
/// </summary>
|
/// <param name="p"></param>
|
internal void HitTest(Point p)
|
{
|
SelectedTab = HittedTab;
|
SelectedPanel = HittedPanel;
|
SelectedItem = HittedItem;
|
SelectedSubItem = HittedSubItem;
|
|
HittedTab = null;
|
HittedTabScrollLeft = false;
|
HittedTabScrollRight = false;
|
HittedPanel = null;
|
HittedItem = null;
|
HittedSubItem = null;
|
|
#region Tabs
|
if (TabLimit != null && TabLimit.Visible)
|
{
|
if (TabLimit.TabContentBounds.Contains(p))
|
{
|
HittedTab = TabLimit;
|
}
|
}
|
else
|
{
|
foreach (RibbonTab tab in Tabs)
|
{
|
if (tab.Visible && tab.TabContentBounds.Contains(p))
|
{
|
HittedTab = tab; break;
|
}
|
}
|
}
|
#endregion
|
|
#region TabScrolls
|
|
if (HittedTab != null)
|
{
|
HittedTabScrollLeft = HittedTab.ScrollLeftVisible && HittedTab.ScrollLeftBounds.Contains(p);
|
HittedTabScrollRight = HittedTab.ScrollRightVisible && HittedTab.ScrollRightBounds.Contains(p);
|
}
|
|
#endregion
|
|
if (!HittedTabScroll)
|
{
|
#region Panels
|
|
if (PanelLimit != null && PanelLimit.Visible)
|
{
|
if (PanelLimit.Bounds.Contains(p))
|
{
|
HittedPanel = PanelLimit;
|
}
|
}
|
else
|
{
|
foreach (RibbonPanel pnl in Panels)
|
{
|
if (pnl.Visible && pnl.Bounds.Contains(p))
|
{
|
HittedPanel = pnl; break;
|
}
|
}
|
}
|
|
#endregion
|
|
#region Item
|
|
IEnumerable<RibbonItem> items = Items;
|
|
if (ItemsSource != null) items = ItemsSource;
|
|
foreach (RibbonItem item in items)
|
{
|
if (item.OwnerPanel != null && item.OwnerPanel.OverflowMode && !(Control is RibbonPanelPopup))
|
continue;
|
|
if (!item.Visible)
|
continue;
|
|
if (item.Bounds.Contains(p))
|
{
|
HittedItem = item; break;
|
}
|
}
|
|
#endregion
|
|
#region Subitem
|
|
IContainsSelectableRibbonItems container = HittedItem as IContainsSelectableRibbonItems;
|
IScrollableRibbonItem scrollable = HittedItem as IScrollableRibbonItem;
|
|
|
if (container != null)
|
{
|
Rectangle sensibleBounds = scrollable != null ? scrollable.ContentBounds : HittedItem.Bounds;
|
|
foreach (RibbonItem item in container.GetItems())
|
{
|
if (!item.Visible)
|
continue;
|
|
Rectangle actualBounds = item.Bounds;
|
actualBounds.Intersect(sensibleBounds);
|
|
if (actualBounds.Contains(p))
|
{
|
HittedSubItem = item;
|
}
|
}
|
}
|
|
#endregion
|
}
|
}
|
|
/// <summary>
|
/// Removes the added handlers to the Control
|
/// </summary>
|
private void RemoveHandlers()
|
{
|
//Do not Change State because if Text or Image of RibbonItem is Changed in Runtime RemoveHandlers() is called
|
/*
|
foreach (RibbonItem item in Items)
|
{
|
item.SetSelected(false);
|
item.SetPressed(false);
|
}
|
*/
|
|
Control.MouseMove -= Control_MouseMove;
|
Control.MouseLeave -= Control_MouseLeave;
|
Control.MouseDown -= Control_MouseDown;
|
Control.MouseUp -= Control_MouseUp;
|
|
// ADDED
|
Control.MouseClick -= Control_MouseClick;
|
Control.MouseDoubleClick -= Control_MouseDoubleClick;
|
}
|
|
/// <summary>
|
/// Resumes the sensing after being suspended by <see cref="Suspend"/>
|
/// </summary>
|
public void Resume()
|
{
|
IsSuspended = false;
|
}
|
|
/// <summary>
|
/// Suspends sensing until <see cref="Resume"/> is called
|
/// </summary>
|
public void Suspend()
|
{
|
IsSuspended = true;
|
}
|
|
#endregion
|
|
#region IDisposable Members
|
|
/// <summary>
|
/// Dispose
|
/// </summary>
|
public void Dispose()
|
{
|
Dispose(true);
|
GC.SuppressFinalize(this);
|
}
|
|
/// <summary>
|
/// Clean up any resources being used.
|
/// </summary>
|
/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
|
protected virtual void Dispose(bool disposing)
|
{
|
if (disposing)
|
{
|
Disposed = true;
|
RemoveHandlers();
|
}
|
}
|
|
#endregion
|
}
|
}
|
