// *********************************
|
// Message from Original Author:
|
//
|
// 2008 Jose Menendez Poo
|
// Please give me credit if you use this code. It's all I ask.
|
// Contact me for more info: menendezpoo@gmail.com
|
// *********************************
|
//
|
// Original project from http://ribbon.codeplex.com/
|
// Continue to support and maintain by http://officeribbon.codeplex.com/
|
|
using System.Collections.Generic;
|
using System.ComponentModel;
|
using System.Drawing;
|
using System.Drawing.Drawing2D;
|
|
namespace System.Windows.Forms
|
{
|
public class RibbonOrbDropDown
|
: RibbonPopup
|
{
|
#region const
|
|
private const bool DefaultAutoSizeContentButtons = true;
|
private const int DefaultContentButtonsMinWidth = 150;
|
private const int DefaultContentRecentItemsMinWidth = 150;
|
|
#endregion
|
|
#region Fields
|
internal RibbonOrbMenuItem LastPoppedMenuItem;
|
private Rectangle designerSelectedBounds;
|
private readonly int glyphGap = 3;
|
private Padding _contentMargin;
|
private DateTime OpenedTime; //Steve - capture time popup was shown
|
private string _recentItemsCaption;
|
|
//private GlobalHook _keyboardHook;
|
private int _contentButtonsWidth = DefaultContentButtonsMinWidth;
|
|
#endregion
|
|
#region Ctor
|
|
internal RibbonOrbDropDown(Ribbon ribbon)
|
{
|
DoubleBuffered = true;
|
Ribbon = ribbon;
|
MenuItems = new RibbonOrbMenuItemCollection();
|
RecentItems = new RibbonOrbRecentItemCollection();
|
OptionItems = new RibbonOrbOptionButtonCollection();
|
|
MenuItems.SetOwner(Ribbon);
|
RecentItems.SetOwner(Ribbon);
|
OptionItems.SetOwner(Ribbon);
|
|
OptionItemsPadding = 6;
|
Size = new Size(527, 447);
|
BorderRoundness = 8;
|
|
//if (!(Site != null && Site.DesignMode))
|
//{
|
// _keyboardHook = new GlobalHook(GlobalHook.HookTypes.Keyboard);
|
// _keyboardHook.KeyUp += new KeyEventHandler(_keyboardHook_KeyUp);
|
//}
|
}
|
|
/// <summary>
|
/// Clean up any resources being used.
|
/// </summary>
|
/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
|
protected override void Dispose(bool disposing)
|
{
|
base.Dispose(disposing);
|
if (Sensor != null && !Sensor.Disposed)
|
{
|
Sensor.Dispose();
|
}
|
//if (_keyboardHook != null)
|
//{
|
// _keyboardHook.Dispose();
|
//}
|
}
|
//Finalize is called by base class "System.ComponentModel.Component"
|
|
#endregion
|
|
#region Props
|
|
/// <summary>
|
/// Gets all items involved in the dropdown
|
/// </summary>
|
internal List<RibbonItem> AllItems
|
{
|
get
|
{
|
List<RibbonItem> lst = new List<RibbonItem>();
|
lst.AddRange(MenuItems); lst.AddRange(RecentItems); lst.AddRange(OptionItems);
|
return lst;
|
}
|
}
|
|
/// <summary>
|
/// Gets the margin of the content bounds
|
/// </summary>
|
[Browsable(false)]
|
public Padding ContentMargin
|
{
|
get
|
{
|
if (_contentMargin.Size.IsEmpty)
|
{
|
_contentMargin = new Padding(6, 17, 6, 29);
|
}
|
|
return _contentMargin;
|
}
|
}
|
|
/// <summary>
|
/// Gets the bounds of the content (where menu buttons are)
|
/// </summary>
|
[Browsable(false)]
|
public Rectangle ContentBounds => Rectangle.FromLTRB(ContentMargin.Left, ContentMargin.Top,
|
ClientRectangle.Right - ContentMargin.Right,
|
ClientRectangle.Bottom - ContentMargin.Bottom);
|
|
/// <summary>
|
/// Gets the bounds of the content part that contains the buttons on the left
|
/// </summary>
|
[Browsable(false)]
|
public Rectangle ContentButtonsBounds
|
{
|
get
|
{
|
Rectangle r = ContentBounds;
|
r.Width = _contentButtonsWidth;
|
if (Ribbon.RightToLeft == RightToLeft.Yes)
|
r.X = ContentBounds.Right - _contentButtonsWidth;
|
return r;
|
}
|
}
|
|
/// <summary>
|
/// Gets or sets the minimum width for the content buttons.
|
/// </summary>
|
[DefaultValue(DefaultContentButtonsMinWidth)]
|
public int ContentButtonsMinWidth { get; set; } = DefaultContentButtonsMinWidth;
|
|
/// <summary>
|
/// Gets the bounds fo the content part that contains the recent-item list
|
/// </summary>
|
[Browsable(false)]
|
public Rectangle ContentRecentItemsBounds
|
{
|
get
|
{
|
Rectangle r = ContentBounds;
|
r.Width -= _contentButtonsWidth;
|
|
//Steve - Recent Items Caption
|
r.Height -= ContentRecentItemsCaptionBounds.Height;
|
r.Y += ContentRecentItemsCaptionBounds.Height;
|
|
if (Ribbon.RightToLeft == RightToLeft.No)
|
r.X += _contentButtonsWidth;
|
|
return r;
|
}
|
}
|
/// <summary>
|
/// Gets the bounds of the caption area on the content part of the recent-item list
|
/// </summary>
|
[Browsable(false)]
|
public Rectangle ContentRecentItemsCaptionBounds
|
{
|
get
|
{
|
if (RecentItemsCaption != null)
|
{
|
//Lets measure the height of the text so we take into account the font and its size
|
SizeF cs;
|
using (Graphics g = CreateGraphics())
|
{
|
cs = g.MeasureString(RecentItemsCaption, Ribbon.RibbonTabFont);
|
}
|
Rectangle r = ContentBounds;
|
r.Width -= _contentButtonsWidth;
|
r.Height = Convert.ToInt32(cs.Height) + Ribbon.ItemMargin.Top + Ribbon.ItemMargin.Bottom; //padding
|
r.Height += RecentItemsCaptionLineSpacing; //Spacing for the divider line
|
|
if (Ribbon.RightToLeft == RightToLeft.No)
|
r.X += _contentButtonsWidth;
|
return r;
|
}
|
|
return Rectangle.Empty;
|
}
|
}
|
|
/// <summary>
|
/// Gets the bounds of the caption area on the content part of the recent-item list
|
/// </summary>
|
[Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
public int RecentItemsCaptionLineSpacing { get; } = 8;
|
|
/// <summary>
|
/// Gets or sets the minimum width for the recent items.
|
/// </summary>
|
[DefaultValue(DefaultContentRecentItemsMinWidth)]
|
public int ContentRecentItemsMinWidth { get; set; } = DefaultContentRecentItemsMinWidth;
|
|
/// <summary>
|
/// Gets if currently on design mode
|
/// </summary>
|
private bool RibbonInDesignMode => RibbonDesigner.Current != null;
|
|
/// <summary>
|
/// Gets the collection of items shown in the menu area
|
/// </summary>
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
public RibbonOrbMenuItemCollection MenuItems { get; }
|
|
/// <summary>
|
/// Gets the collection of items shown in the options area (bottom)
|
/// </summary>
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
public RibbonOrbOptionButtonCollection OptionItems { get; }
|
|
[DefaultValue(6)]
|
[Description("Spacing between option buttons (those on the bottom)")]
|
public int OptionItemsPadding { get; set; }
|
|
/// <summary>
|
/// Gets the collection of items shown in the recent items area
|
/// </summary>
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
public RibbonOrbRecentItemCollection RecentItems { get; }
|
|
/// <summary>
|
/// Gets or Sets the caption for the Recent Items area
|
/// </summary>
|
[DefaultValue(null)]
|
public string RecentItemsCaption
|
{
|
get => _recentItemsCaption;
|
set { _recentItemsCaption = value; Invalidate(); }
|
}
|
|
/// <summary>
|
/// Gets the ribbon that owns this dropdown
|
/// </summary>
|
[Browsable(false)]
|
public Ribbon Ribbon { get; }
|
|
/// <summary>
|
/// Gets the sensor of the dropdown
|
/// </summary>
|
[Browsable(false)]
|
public RibbonMouseSensor Sensor { get; private set; }
|
|
/// <summary>
|
/// Gets the bounds of the glyph
|
/// </summary>
|
internal Rectangle ButtonsGlyphBounds
|
{
|
get
|
{
|
Size s = new Size(50, 18);
|
Rectangle rf = ContentButtonsBounds;
|
Rectangle r = new Rectangle(rf.Left + (rf.Width - s.Width * 2) / 2, rf.Top + glyphGap, s.Width, s.Height);
|
|
if (MenuItems.Count > 0)
|
{
|
r.Y = MenuItems[MenuItems.Count - 1].Bounds.Bottom + glyphGap;
|
}
|
|
return r;
|
}
|
}
|
|
/// <summary>
|
/// Gets the bounds of the glyph
|
/// </summary>
|
internal Rectangle ButtonsSeparatorGlyphBounds
|
{
|
get
|
{
|
Size s = new Size(18, 18);
|
|
Rectangle r = ButtonsGlyphBounds;
|
|
r.X = r.Right + glyphGap;
|
|
return r;
|
}
|
}
|
|
/// <summary>
|
/// Gets the bounds of the recent items add glyph
|
/// </summary>
|
internal Rectangle RecentGlyphBounds
|
{
|
get
|
{
|
Size s = new Size(50, 18);
|
Rectangle rf = ContentRecentItemsBounds;
|
Rectangle r = new Rectangle(rf.Left + glyphGap, rf.Top + glyphGap, s.Width, s.Height);
|
|
if (RecentItems.Count > 0)
|
{
|
r.Y = RecentItems[RecentItems.Count - 1].Bounds.Bottom + glyphGap;
|
}
|
|
return r;
|
}
|
}
|
|
/// <summary>
|
/// Gets the bounds of the option items add glyph
|
/// </summary>
|
internal Rectangle OptionGlyphBounds
|
{
|
get
|
{
|
Size s = new Size(50, 18);
|
Rectangle rf = ContentBounds;
|
Rectangle r = new Rectangle(rf.Right - s.Width, rf.Bottom + glyphGap, s.Width, s.Height);
|
|
if (OptionItems.Count > 0)
|
{
|
r.X = OptionItems[OptionItems.Count - 1].Bounds.Left - s.Width - glyphGap;
|
}
|
|
return r;
|
}
|
}
|
|
[DefaultValue(DefaultAutoSizeContentButtons)]
|
public bool AutoSizeContentButtons { get; set; } = DefaultAutoSizeContentButtons;
|
|
#endregion
|
|
#region Methods
|
|
internal void HandleDesignerItemRemoved(RibbonItem item)
|
{
|
if (MenuItems.Contains(item))
|
{
|
MenuItems.Remove(item);
|
}
|
else if (RecentItems.Contains(item))
|
{
|
RecentItems.Remove(item);
|
}
|
else if (OptionItems.Contains(item))
|
{
|
OptionItems.Remove(item);
|
}
|
|
OnRegionsChanged();
|
}
|
|
/// <summary>
|
/// Gets the height that a separator should be on the DropDown
|
/// </summary>
|
/// <param name="s"></param>
|
/// <returns></returns>
|
private int SeparatorHeight(RibbonSeparator s)
|
{
|
if (!string.IsNullOrEmpty(s.Text))
|
{
|
return 20;
|
}
|
|
return 3;
|
}
|
|
/// <summary>
|
/// Updates the regions and bounds of items
|
/// </summary>
|
private void UpdateRegions()
|
{
|
int curtop = 0;
|
int curright = 0;
|
int menuItemHeight = 44;
|
int recentHeight = 22;
|
int mbuttons = 1; //margin
|
int mrecent = 1; //margin
|
int buttonsHeight = 0;
|
int recentsHeight = 0;
|
|
if (AutoSizeContentButtons)
|
{
|
#region important to do the item max width check before the ContentBounds and other stuff is used (internal Property stuff)
|
int itemMaxWidth = 0;
|
using (Graphics g = CreateGraphics())
|
{
|
foreach (RibbonItem item in MenuItems)
|
{
|
int width = item.MeasureSize(this, new RibbonElementMeasureSizeEventArgs(g, RibbonElementSizeMode.DropDown)).Width;
|
if (width > itemMaxWidth)
|
itemMaxWidth = width;
|
}
|
}
|
itemMaxWidth = Math.Min(itemMaxWidth, ContentBounds.Width - ContentRecentItemsMinWidth);
|
itemMaxWidth = Math.Max(itemMaxWidth, ContentButtonsMinWidth);
|
_contentButtonsWidth = itemMaxWidth;
|
#endregion
|
}
|
|
Rectangle rcontent = ContentBounds;
|
Rectangle rbuttons = ContentButtonsBounds;
|
Rectangle rrecent = ContentRecentItemsBounds;
|
|
foreach (RibbonItem item in AllItems)
|
{
|
item.SetSizeMode(RibbonElementSizeMode.DropDown);
|
item.SetCanvas(this);
|
}
|
|
#region Menu Items
|
|
curtop = rcontent.Top + 1;
|
|
foreach (RibbonItem item in MenuItems)
|
{
|
Rectangle ritem = new Rectangle(rbuttons.Left + mbuttons, curtop, rbuttons.Width - mbuttons * 2, menuItemHeight);
|
|
if (item is RibbonSeparator) ritem.Height = SeparatorHeight(item as RibbonSeparator);
|
|
item.SetBounds(ritem);
|
|
curtop += ritem.Height;
|
}
|
|
buttonsHeight = curtop - rcontent.Top + 1;
|
|
#endregion
|
|
#region Recent List
|
|
//curtop = rbuttons.Top; //Steve - for recent documents
|
curtop = rrecent.Top; //Steve - for recent documents
|
|
foreach (RibbonItem item in RecentItems)
|
{
|
Rectangle ritem = new Rectangle(rrecent.Left + mrecent, curtop, rrecent.Width - mrecent * 2, recentHeight);
|
|
if (item is RibbonSeparator) ritem.Height = SeparatorHeight(item as RibbonSeparator);
|
|
item.SetBounds(ritem);
|
|
curtop += ritem.Height;
|
}
|
|
recentsHeight = curtop - rbuttons.Top;
|
|
#endregion
|
|
#region Set size
|
|
int actualHeight = Math.Max(buttonsHeight, recentsHeight);
|
|
if (RibbonDesigner.Current != null)
|
{
|
actualHeight += ButtonsGlyphBounds.Height + glyphGap * 2;
|
}
|
|
Height = actualHeight + ContentMargin.Vertical;
|
rcontent = ContentBounds;
|
|
#endregion
|
|
#region Option buttons
|
|
curright = ClientSize.Width - ContentMargin.Right;
|
|
using (Graphics g = CreateGraphics())
|
{
|
foreach (RibbonItem item in OptionItems)
|
{
|
Size s = item.MeasureSize(this, new RibbonElementMeasureSizeEventArgs(g, RibbonElementSizeMode.DropDown));
|
curtop = rcontent.Bottom + (ContentMargin.Bottom - s.Height) / 2;
|
item.SetBounds(new Rectangle(new Point(curright - s.Width, curtop), s));
|
curright = item.Bounds.Left - OptionItemsPadding;
|
}
|
}
|
|
#endregion
|
}
|
|
/// <summary>
|
/// Refreshes the sensor
|
/// </summary>
|
private void UpdateSensor()
|
{
|
if (Sensor != null && !Sensor.Disposed)
|
{
|
Sensor.Dispose();
|
}
|
|
Sensor = new RibbonMouseSensor(this, Ribbon, AllItems);
|
}
|
|
/// <summary>
|
/// Updates all areas and bounds of items
|
/// </summary>
|
internal void OnRegionsChanged()
|
{
|
UpdateRegions();
|
UpdateSensor();
|
UpdateDesignerSelectedBounds();
|
Invalidate();
|
}
|
|
/// <summary>
|
/// Selects the specified item on the designer
|
/// </summary>
|
/// <param name="item"></param>
|
internal void SelectOnDesigner(RibbonItem item)
|
{
|
if (RibbonDesigner.Current != null)
|
{
|
RibbonDesigner.Current.SelectedElement = item;
|
UpdateDesignerSelectedBounds();
|
Invalidate();
|
}
|
}
|
|
/// <summary>
|
/// Updates the selection bounds on the designer
|
/// </summary>
|
internal void UpdateDesignerSelectedBounds()
|
{
|
designerSelectedBounds = Rectangle.Empty;
|
|
if (RibbonInDesignMode)
|
{
|
RibbonItem item = RibbonDesigner.Current.SelectedElement as RibbonItem;
|
|
if (item != null && AllItems.Contains(item))
|
{
|
designerSelectedBounds = item.Bounds;
|
}
|
}
|
}
|
|
protected override void OnMouseDown(MouseEventArgs e)
|
{
|
base.OnMouseDown(e);
|
|
if (RibbonInDesignMode)
|
{
|
#region DesignMode clicks
|
if (ContentBounds.Contains(e.Location))
|
{
|
if (ContentButtonsBounds.Contains(e.Location))
|
{
|
foreach (RibbonItem item in MenuItems)
|
{
|
if (item.Bounds.Contains(e.Location))
|
{
|
SelectOnDesigner(item);
|
break;
|
}
|
}
|
}
|
else if (ContentRecentItemsBounds.Contains(e.Location))
|
{
|
foreach (RibbonItem item in RecentItems)
|
{
|
if (item.Bounds.Contains(e.Location))
|
{
|
SelectOnDesigner(item);
|
break;
|
}
|
}
|
}
|
}
|
if (ButtonsGlyphBounds.Contains(e.Location))
|
{
|
RibbonDesigner.Current.CreateOrbMenuItem(typeof(RibbonOrbMenuItem));
|
}
|
else if (ButtonsSeparatorGlyphBounds.Contains(e.Location))
|
{
|
RibbonDesigner.Current.CreateOrbMenuItem(typeof(RibbonSeparator));
|
}
|
else if (RecentGlyphBounds.Contains(e.Location))
|
{
|
RibbonDesigner.Current.CreateOrbRecentItem(typeof(RibbonOrbRecentItem));
|
}
|
else if (OptionGlyphBounds.Contains(e.Location))
|
{
|
RibbonDesigner.Current.CreateOrbOptionItem(typeof(RibbonOrbOptionButton));
|
}
|
else
|
{
|
foreach (RibbonItem item in OptionItems)
|
{
|
if (item.Bounds.Contains(e.Location))
|
{
|
SelectOnDesigner(item);
|
break;
|
}
|
}
|
}
|
#endregion
|
}
|
|
}
|
|
protected override void OnOpening(CancelEventArgs e)
|
{
|
base.OnOpening(e);
|
|
UpdateRegions();
|
}
|
|
protected override void OnPaint(PaintEventArgs e)
|
{
|
base.OnPaint(e);
|
|
Ribbon.Renderer.OnRenderOrbDropDownBackground(
|
new RibbonOrbDropDownEventArgs(Ribbon, this, e.Graphics, e.ClipRectangle));
|
|
foreach (RibbonItem item in AllItems)
|
{
|
item.OnPaint(this, new RibbonElementPaintEventArgs(e.ClipRectangle, e.Graphics, RibbonElementSizeMode.DropDown));
|
}
|
|
if (RibbonInDesignMode)
|
{
|
using (SolidBrush b = new SolidBrush(Color.FromArgb(50, Color.Blue)))
|
{
|
e.Graphics.FillRectangle(b, ButtonsGlyphBounds);
|
e.Graphics.FillRectangle(b, RecentGlyphBounds);
|
e.Graphics.FillRectangle(b, OptionGlyphBounds);
|
e.Graphics.FillRectangle(b, ButtonsSeparatorGlyphBounds);
|
}
|
|
using (StringFormat sf = StringFormatFactory.Center(StringTrimming.None))
|
{
|
e.Graphics.DrawString("+", Font, Brushes.White, ButtonsGlyphBounds, sf);
|
e.Graphics.DrawString("+", Font, Brushes.White, RecentGlyphBounds, sf);
|
e.Graphics.DrawString("+", Font, Brushes.White, OptionGlyphBounds, sf);
|
e.Graphics.DrawString("---", Font, Brushes.White, ButtonsSeparatorGlyphBounds, sf);
|
}
|
|
using (Pen p = new Pen(Color.Black))
|
{
|
p.DashStyle = DashStyle.Dot;
|
e.Graphics.DrawRectangle(p, designerSelectedBounds);
|
}
|
|
//e.Graphics.DrawString("Press ESC to Hide", Font, Brushes.Black, Width - 100f, 2f);
|
}
|
}
|
|
protected override void OnClosed(EventArgs e)
|
{
|
Ribbon.OrbPressed = false;
|
Ribbon.OrbSelected = false;
|
LastPoppedMenuItem = null;
|
foreach (RibbonItem item in AllItems)
|
{
|
item.SetSelected(false);
|
item.SetPressed(false);
|
}
|
base.OnClosed(e);
|
}
|
|
protected override void OnShowed(EventArgs e)
|
{
|
base.OnShowed(e);
|
OpenedTime = DateTime.Now;
|
UpdateSensor();
|
}
|
|
protected override void OnMouseClick(MouseEventArgs e)
|
{
|
if (Ribbon.RectangleToScreen(Ribbon.OrbBounds).Contains(PointToScreen(e.Location)))
|
{
|
Ribbon.OnOrbClicked(EventArgs.Empty);
|
//Steve - if click time is within the double click time after the drop down was shown, then this is a double click
|
if (DateTime.Compare(DateTime.Now, OpenedTime.AddMilliseconds(SystemInformation.DoubleClickTime)) < 0)
|
Ribbon.OnOrbDoubleClicked(EventArgs.Empty);
|
}
|
|
base.OnMouseClick(e);
|
}
|
|
protected override void OnMouseDoubleClick(MouseEventArgs e)
|
{
|
base.OnMouseDoubleClick(e);
|
|
if (Ribbon.RectangleToScreen(Ribbon.OrbBounds).Contains(PointToScreen(e.Location)))
|
{
|
Ribbon.OnOrbDoubleClicked(EventArgs.Empty);
|
}
|
}
|
|
private void _keyboardHook_KeyUp(object sender, KeyEventArgs e)
|
{
|
//base.OnKeyUp(e);
|
if (e.KeyCode == Keys.Down)
|
{
|
RibbonItem NextItem = null;
|
RibbonItem SelectedItem = null;
|
foreach (RibbonItem itm in MenuItems)
|
{
|
if (itm.Selected)
|
{
|
SelectedItem = itm;
|
break;
|
}
|
}
|
if (SelectedItem != null)
|
{
|
//get the next item in the chain
|
int Index = MenuItems.IndexOf(SelectedItem);
|
NextItem = GetNextSelectableMenuItem(Index + 1);
|
}
|
else
|
{
|
//nothing found so lets search through the recent buttons
|
foreach (RibbonItem itm in RecentItems)
|
{
|
if (itm.Selected)
|
{
|
SelectedItem = itm;
|
itm.SetSelected(false);
|
itm.RedrawItem();
|
break;
|
}
|
}
|
if (SelectedItem != null)
|
{
|
//get the next item in the chain
|
int Index = RecentItems.IndexOf(SelectedItem);
|
NextItem = GetNextSelectableRecentItem(Index + 1);
|
}
|
else
|
{
|
//nothing found so lets search through the option buttons
|
foreach (RibbonItem itm in OptionItems)
|
{
|
if (itm.Selected)
|
{
|
SelectedItem = itm;
|
itm.SetSelected(false);
|
itm.RedrawItem();
|
break;
|
}
|
}
|
if (SelectedItem != null)
|
{
|
//get the next item in the chain
|
int Index = OptionItems.IndexOf(SelectedItem);
|
NextItem = GetNextSelectableOptionItem(Index + 1);
|
}
|
}
|
}
|
//last check to make sure we found a selected item
|
if (SelectedItem == null)
|
{
|
//we should have the right item by now so lets select it
|
NextItem = GetNextSelectableMenuItem(0);
|
if (NextItem != null)
|
{
|
NextItem.SetSelected(true);
|
NextItem.RedrawItem();
|
}
|
}
|
else
|
{
|
SelectedItem.SetSelected(false);
|
SelectedItem.RedrawItem();
|
|
NextItem.SetSelected(true);
|
NextItem.RedrawItem();
|
}
|
//_sensor.SelectedItem = NextItem;
|
//_sensor.HittedItem = NextItem;
|
}
|
else if (e.KeyCode == Keys.Up)
|
{
|
}
|
}
|
private RibbonItem GetNextSelectableMenuItem(int StartIndex)
|
{
|
for (int idx = StartIndex; idx < MenuItems.Count; idx++)
|
{
|
RibbonButton btn = MenuItems[idx] as RibbonButton;
|
if (btn != null)
|
return btn;
|
}
|
//nothing found so lets move on to the recent items
|
RibbonItem NextItem = GetNextSelectableRecentItem(0);
|
if (NextItem == null)
|
{
|
//nothing found so lets try the option items
|
NextItem = GetNextSelectableOptionItem(0);
|
if (NextItem == null)
|
{
|
//nothing again so go back to the top of the menu items
|
NextItem = GetNextSelectableMenuItem(0);
|
}
|
}
|
return NextItem;
|
}
|
private RibbonItem GetNextSelectableRecentItem(int StartIndex)
|
{
|
for (int idx = StartIndex; idx < RecentItems.Count; idx++)
|
{
|
RibbonButton btn = RecentItems[idx] as RibbonButton;
|
if (btn != null)
|
return btn;
|
}
|
//nothing found so lets move on to the option items
|
RibbonItem NextItem = GetNextSelectableOptionItem(0);
|
if (NextItem == null)
|
{
|
//nothing found so lets try the menu items
|
NextItem = GetNextSelectableMenuItem(0);
|
if (NextItem == null)
|
{
|
//nothing again so go back to the top of the recent items
|
NextItem = GetNextSelectableRecentItem(0);
|
}
|
}
|
return NextItem;
|
}
|
private RibbonItem GetNextSelectableOptionItem(int StartIndex)
|
{
|
for (int idx = StartIndex; idx < OptionItems.Count; idx++)
|
{
|
RibbonButton btn = OptionItems[idx] as RibbonButton;
|
if (btn != null)
|
return btn;
|
}
|
//nothing found so lets move on to the menu items
|
RibbonItem NextItem = GetNextSelectableMenuItem(0);
|
if (NextItem == null)
|
{
|
//nothing found so lets try the recent items
|
NextItem = GetNextSelectableRecentItem(0);
|
if (NextItem == null)
|
{
|
//nothing again so go back to the top of the option items
|
NextItem = GetNextSelectableOptionItem(0);
|
}
|
}
|
return NextItem;
|
}
|
#endregion
|
|
}
|
}
|
