// *********************************
|
// 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;
|
|
namespace System.Windows.Forms
|
{
|
/// <summary>
|
/// Represents a tab that can contain RibbonPanel objects
|
/// </summary>
|
[DesignTimeVisible(false)]
|
[Designer(typeof(RibbonTabDesigner))]
|
public class RibbonTab : Component, IRibbonElement, IRibbonToolTip, IContainsRibbonComponents
|
{
|
#region Fields
|
private bool? _isopeninvisualstudiodesigner;
|
private bool _enabled;
|
private bool _pressed;
|
private bool _selected;
|
private bool _active;
|
private string _text;
|
private RibbonContext _context;
|
private int _offset;
|
private bool _visible = true;
|
|
private readonly RibbonToolTip _TT;
|
|
/// <summary>
|
/// Occurs when the mouse pointer enters the panel
|
/// </summary>
|
public event MouseEventHandler MouseEnter;
|
|
/// <summary>
|
/// Occurs when the mouse pointer leaves the panel
|
/// </summary>
|
public event MouseEventHandler MouseLeave;
|
|
/// <summary>
|
/// Occurs when the mouse pointer is moved inside the panel
|
/// </summary>
|
public event MouseEventHandler MouseMove;
|
|
#endregion
|
|
#region Ctor
|
|
public RibbonTab()
|
{
|
Panels = new RibbonPanelCollection(this);
|
_enabled = true;
|
|
//Initialize the ToolTip for this Item
|
_TT = new RibbonToolTip(this)
|
{
|
InitialDelay = 100,
|
AutomaticDelay = 800,
|
AutoPopDelay = 8000,
|
UseAnimation = true,
|
Active = false
|
};
|
_TT.Popup += _TT_Popup;
|
}
|
|
public RibbonTab(string text)
|
: this()
|
{
|
_text = text;
|
}
|
|
/// <summary>
|
/// Creates a new RibbonTab
|
/// </summary>
|
[Obsolete("Use 'public RibbonTab(string text)' instead!")]
|
public RibbonTab(Ribbon owner, string text)
|
: this(text)
|
{
|
}
|
|
/// <summary>
|
/// RibbonTab is open in Visual Studio Designer
|
/// </summary>
|
protected bool IsOpenInVisualStudioDesigner()
|
{
|
if (!_isopeninvisualstudiodesigner.HasValue)
|
{
|
_isopeninvisualstudiodesigner = LicenseManager.UsageMode == LicenseUsageMode.Designtime ||
|
this.DesignMode;
|
if (!_isopeninvisualstudiodesigner.Value)
|
{
|
try
|
{
|
using (var process = System.Diagnostics.Process.GetCurrentProcess())
|
{
|
_isopeninvisualstudiodesigner = process.ProcessName.ToLowerInvariant().Contains("devenv");
|
}
|
}
|
catch
|
{
|
}
|
}
|
}
|
return _isopeninvisualstudiodesigner.Value;
|
}
|
|
/// <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)
|
{
|
if (disposing && RibbonDesigner.Current == null)
|
{
|
// ADDED
|
_TT.Popup -= _TT_Popup;
|
|
_TT.Dispose();
|
try
|
{
|
foreach (RibbonPanel p in Panels)
|
p.Dispose();
|
}
|
catch (InvalidOperationException)
|
{
|
if (!IsOpenInVisualStudioDesigner())
|
{
|
throw;
|
}
|
}
|
}
|
|
base.Dispose(disposing);
|
}
|
|
#endregion
|
|
#region Events
|
|
|
public event EventHandler ScrollRightVisibleChanged;
|
public event EventHandler ScrollRightPressedChanged;
|
public event EventHandler ScrollRightBoundsChanged;
|
public event EventHandler ScrollRightSelectedChanged;
|
public event EventHandler ScrollLeftVisibleChanged;
|
public event EventHandler ScrollLeftPressedChanged;
|
public event EventHandler ScrollLeftSelectedChanged;
|
public event EventHandler ScrollLeftBoundsChanged;
|
public event EventHandler TabBoundsChanged;
|
public event EventHandler TabContentBoundsChanged;
|
public event EventHandler OwnerChanged;
|
public event EventHandler PressedChanged;
|
public event EventHandler ActiveChanged;
|
public event EventHandler TextChanged;
|
public event EventHandler ContextChanged;
|
public virtual event RibbonElementPopupEventHandler ToolTipPopUp;
|
|
#endregion
|
|
#region Props
|
|
private string _Name = string.Empty;
|
[Browsable(false)]
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
|
public virtual string Name
|
{
|
get
|
{
|
if (Site != null)
|
{
|
_Name = Site.Name;
|
}
|
return _Name;
|
}
|
set => _Name = value;
|
}
|
|
[DefaultValue(true)]
|
[Category("Behavior")]
|
[Description("Sets if the tab should be enabled")]
|
public bool Enabled
|
{
|
get
|
{
|
if (Owner != null)
|
{
|
return _enabled && Owner.Enabled;
|
}
|
|
return _enabled;
|
}
|
set
|
{
|
_enabled = value;
|
Owner.Invalidate();
|
|
foreach (RibbonPanel item in Panels)
|
{
|
item.Enabled = value;
|
}
|
}
|
}
|
|
/// <summary>
|
/// Gets if the right-side scroll button is currently visible
|
/// </summary>
|
[Browsable(false)]
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
public bool ScrollRightVisible { get; private set; }
|
|
/// <summary>
|
/// Gets if the right-side scroll button is currently selected
|
/// </summary>
|
[Browsable(false)]
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
public bool ScrollRightSelected { get; private set; }
|
|
/// <summary>
|
/// Gets if the right-side scroll button is currently pressed
|
/// </summary>
|
[Browsable(false)]
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
public bool ScrollRightPressed { get; private set; }
|
|
/// <summary>
|
/// Gets if the right-side scroll button bounds
|
/// </summary>
|
[Browsable(false)]
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
public Rectangle ScrollRightBounds { get; private set; }
|
|
/// <summary>
|
/// Gets if the left scroll button is currently visible
|
/// </summary>
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
[Browsable(false)]
|
public bool ScrollLeftVisible { get; private set; }
|
|
/// <summary>
|
/// Gets if the left scroll button bounds
|
/// </summary>
|
[Browsable(false)]
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
public Rectangle ScrollLeftBounds { get; private set; }
|
|
/// <summary>
|
/// Gets if the left scroll button is currently selected
|
/// </summary>
|
[Browsable(false)]
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
public bool ScrollLeftSelected { get; private set; }
|
|
/// <summary>
|
/// Gets if the left scroll button is currently pressed
|
/// </summary>
|
[Browsable(false)]
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
public bool ScrollLeftPressed { get; private set; }
|
|
/// <summary>
|
/// Gets the <see cref="TabBounds"/> property value
|
/// </summary>
|
[Browsable(false)]
|
public Rectangle Bounds => TabBounds;
|
|
/// <summary>
|
/// Gets the collection of panels that belong to this tab
|
/// </summary>
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
public RibbonPanelCollection Panels { get; }
|
|
/// <summary>
|
/// Gets the bounds of the little tab showing the text
|
/// </summary>
|
[Browsable(false)]
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
public Rectangle TabBounds { get; private set; }
|
|
/// <summary>
|
/// Gets the bounds of the tab content on the Ribbon
|
/// </summary>
|
[Browsable(false)]
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
public Rectangle TabContentBounds { get; private set; }
|
|
/// <summary>
|
/// Gets the Ribbon that contains this tab
|
/// </summary>
|
[Browsable(false)]
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
public Ribbon Owner { get; private set; }
|
|
/// <summary>
|
/// Gets a value indicating whether the state of the tab is being pressed by the mouse or a key
|
/// </summary>
|
[Browsable(false)]
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
public virtual bool Pressed => _pressed;
|
|
/// <summary>
|
/// Gets a value indicating whether the tab is selected
|
/// </summary>
|
[Browsable(false)]
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
public virtual bool Selected => _selected;
|
|
/// <summary>
|
/// Gets a value indicating if the tab is currently the active tab
|
/// </summary>
|
[Browsable(false)]
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
public virtual bool Active => _active;
|
|
/// <summary>
|
/// Gets or sets the object that contains data about the control
|
/// </summary>
|
[Description("An Object field for associating custom data for this control")]
|
[DefaultValue(null)]
|
[Category("Data")]
|
[TypeConverter(typeof(StringConverter))]
|
public object Tag { get; set; }
|
|
/// <summary>
|
/// Gets or sets the custom string data associated with this control
|
/// </summary>
|
[DefaultValue(null)]
|
[Category("Data")]
|
[Description("A string field for associating custom data for this control")]
|
public string Value { get; set; }
|
|
/// <summary>
|
/// Gets or sets the key combination that activates this element when the Alt key was pressed
|
/// </summary>
|
[Category("Behavior")]
|
[DefaultValue(null)]
|
public string AltKey { get; set; }
|
|
|
/// <summary>
|
/// Gets or sets the text that is to be displayed on the tab
|
/// </summary>
|
[Localizable(true)]
|
[Category("Appearance")]
|
public string Text
|
{
|
get => _text;
|
set
|
{
|
|
_text = value;
|
|
OnTextChanged(EventArgs.Empty);
|
|
if (Owner != null) Owner.OnRegionsChanged();
|
}
|
}
|
|
/// <summary>
|
/// Gets a value indicating whether the tab is attached to a Context
|
/// </summary>
|
[Browsable(false)]
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
public virtual bool Contextual => _context != null;
|
|
/// <summary>
|
/// Gets or sets the context this tab belongs to
|
/// </summary>
|
/// <remarks>Tabs on a context are highlighted with a special glow color</remarks>
|
[DefaultValue(null)]
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
|
public RibbonContext Context
|
{
|
get => _context;
|
set
|
{
|
_context = value;
|
|
OnContextChanged(EventArgs.Empty);
|
|
if (Owner != null)
|
{
|
Owner.OnRegionsChanged();
|
Owner.UpdateRegions();
|
}
|
}
|
}
|
|
/// <summary>
|
/// Gets or sets the visibility of this tab
|
/// </summary>
|
/// <remarks>Tabs on a context are highlighted with a special glow color</remarks>
|
[Category("Behavior")]
|
[Localizable(true)]
|
[DefaultValue(true)]
|
public bool Visible
|
{
|
get
|
{
|
if (Owner != null && !Owner.IsDesignMode() && !Owner.Visible)
|
return false;
|
|
//If this tab has a context, follow the visibility of the context.
|
return (Contextual) ? Context.Visible : _visible;
|
}
|
set
|
{
|
_visible = value;
|
if (Owner != null)
|
{
|
Owner.UpdateRegions();
|
if (Active)
|
{
|
EnsureAnyTabVisible();
|
}
|
else
|
{
|
Owner.Invalidate();
|
}
|
}
|
}
|
}
|
|
/// <summary>
|
/// Gets or sets the tool tip title
|
/// </summary>
|
[DefaultValue("")]
|
public string ToolTipTitle
|
{
|
get => _TT.ToolTipTitle;
|
set => _TT.ToolTipTitle = value;
|
}
|
|
/// <summary>
|
/// Gets or sets the image of the tool tip
|
/// </summary>
|
[DefaultValue(ToolTipIcon.None)]
|
public ToolTipIcon ToolTipIcon
|
{
|
get => _TT.ToolTipIcon;
|
set => _TT.ToolTipIcon = value;
|
}
|
|
/// <summary>
|
/// Gets or sets the tool tip text
|
/// </summary>
|
[DefaultValue(null)]
|
[Localizable(true)]
|
public string ToolTip { get; set; }
|
|
/// <summary>
|
/// Gets or sets the tool tip image
|
/// </summary>
|
[DefaultValue(null)]
|
[Localizable(true)]
|
public Image ToolTipImage
|
{
|
get => _TT.ToolTipImage;
|
set => _TT.ToolTipImage = value;
|
}
|
|
/// <summary>
|
/// Gets whether the tab should be drawn invisible.
|
/// </summary>
|
[Browsable(false)]
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
internal bool Invisible => Owner != null && Owner.HideSingleTabIfTextEmpty && Owner.Tabs.Count == 1 && string.IsNullOrEmpty(Text);
|
|
#endregion
|
|
#region IRibbonElement Members
|
|
public void OnPaint(object sender, RibbonElementPaintEventArgs e)
|
{
|
if (Owner == null) return;
|
|
Owner.Renderer.OnRenderRibbonTab(new RibbonTabRenderEventArgs(Owner, e.Graphics, e.Clip, this));
|
Owner.Renderer.OnRenderRibbonTabText(new RibbonTabRenderEventArgs(Owner, e.Graphics, e.Clip, this));
|
|
if (Active && (!Owner.Minimized || (Owner.Minimized && Owner.Expanded)))
|
{
|
int displayIndex = 0;
|
foreach (RibbonPanel panel in Panels)
|
{
|
if (panel.Visible)
|
{
|
panel.Index = displayIndex;
|
panel.IsFirstPanel = (displayIndex == 0);
|
|
panel.OnPaint(this, new RibbonElementPaintEventArgs(e.Clip, e.Graphics, panel.SizeMode, e.Control));
|
|
displayIndex++;
|
}
|
}
|
|
foreach (RibbonPanel panel in Panels)
|
{
|
if (panel.Visible)
|
{
|
panel.IsLastPanel = (panel.Index == displayIndex - 1);
|
break;
|
}
|
}
|
}
|
|
Owner.Renderer.OnRenderTabScrollButtons(new RibbonTabRenderEventArgs(Owner, e.Graphics, e.Clip, this));
|
}
|
|
/// <summary>
|
/// This method is not relevant for this class
|
/// </summary>
|
/// <exception cref="NotSupportedException">Always</exception>
|
public void SetBounds(Rectangle bounds)
|
{
|
throw new NotSupportedException();
|
}
|
|
/// <summary>
|
/// Gets or sets the context this tab belongs to
|
/// </summary>
|
/// <remarks>Tabs on a context are highlighted with a special glow color</remarks>
|
/// <param name="context"></param>
|
public void SetContext(RibbonContext context)
|
{
|
bool trigger = !context.Equals(context);
|
|
if (trigger)
|
OnContextChanged(EventArgs.Empty);
|
|
_context = context;
|
}
|
|
/// <summary>
|
/// Measures the size of the tab. The tab content bounds is measured by the Ribbon control
|
/// </summary>
|
/// <param name="sender"></param>
|
/// <param name="e"></param>
|
public Size MeasureSize(object sender, RibbonElementMeasureSizeEventArgs e)
|
{
|
if (!Visible && !Owner.IsDesignMode()) return new Size(0, 0);
|
|
return Size.Ceiling(e.Graphics.MeasureString(string.IsNullOrEmpty(Text) ? " " : Text, Owner.Font));
|
}
|
|
/// <summary>
|
/// Sets the value of the Owner Property
|
/// </summary>
|
internal void SetOwner(Ribbon owner)
|
{
|
Owner = owner;
|
|
Panels.SetOwner(owner);
|
|
OnOwnerChanged(EventArgs.Empty);
|
}
|
|
/// <summary>
|
/// When an item is removed from the RibbonItemCollection remove all its references.
|
/// </summary>
|
internal virtual void ClearOwner()
|
{
|
Owner = null;
|
OnOwnerChanged(EventArgs.Empty);
|
}
|
|
/// <summary>
|
/// Sets the value of the Pressed property
|
/// </summary>
|
/// <param name="pressed">Value that indicates if the element is pressed</param>
|
internal void SetPressed(bool pressed)
|
{
|
_pressed = pressed;
|
|
OnPressedChanged(EventArgs.Empty);
|
}
|
|
/// <summary>
|
/// Sets the value of the Selected property
|
/// </summary>
|
/// <param name="selected">Value that indicates if the element is selected</param>
|
internal void SetSelected(bool selected)
|
{
|
_selected = selected;
|
|
if (selected)
|
{
|
OnMouseEnter(new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0));
|
}
|
else
|
{
|
OnMouseLeave(new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0));
|
}
|
}
|
|
#endregion
|
|
#region Method Triggers
|
|
public void OnContextChanged(EventArgs e)
|
{
|
if (ContextChanged != null)
|
{
|
ContextChanged(this, e);
|
}
|
}
|
|
public void OnTextChanged(EventArgs e)
|
{
|
if (TextChanged != null)
|
{
|
TextChanged(this, e);
|
}
|
}
|
|
public void OnActiveChanged(EventArgs e)
|
{
|
if (ActiveChanged != null)
|
{
|
ActiveChanged(this, e);
|
}
|
}
|
|
public void OnPressedChanged(EventArgs e)
|
{
|
if (PressedChanged != null)
|
{
|
PressedChanged(this, e);
|
}
|
}
|
|
public void OnOwnerChanged(EventArgs e)
|
{
|
if (OwnerChanged != null)
|
{
|
OwnerChanged(this, e);
|
}
|
}
|
|
public void OnTabContentBoundsChanged(EventArgs e)
|
{
|
if (TabContentBoundsChanged != null)
|
{
|
TabContentBoundsChanged(this, e);
|
}
|
}
|
|
public void OnTabBoundsChanged(EventArgs e)
|
{
|
if (TabBoundsChanged != null)
|
{
|
TabBoundsChanged(this, e);
|
}
|
}
|
|
/// <summary>
|
/// Raises the <see cref="ScrollRightVisibleChanged"/> event
|
/// </summary>
|
/// <param name="e">Event data</param>
|
public void OnScrollRightVisibleChanged(EventArgs e)
|
{
|
if (ScrollRightVisibleChanged != null)
|
{
|
ScrollRightVisibleChanged(this, e);
|
}
|
}
|
|
/// <summary>
|
/// Raises the <see cref="ScrollRightPressedChanged"/> event
|
/// </summary>
|
/// <param name="e">Event data</param>
|
public void OnScrollRightPressedChanged(EventArgs e)
|
{
|
if (ScrollRightPressedChanged != null)
|
{
|
ScrollRightPressedChanged(this, e);
|
}
|
}
|
|
/// <summary>
|
/// Raises the <see cref="ScrollRightBoundsChanged"/> event
|
/// </summary>
|
/// <param name="e">Event data</param>
|
public void OnScrollRightBoundsChanged(EventArgs e)
|
{
|
if (ScrollRightBoundsChanged != null)
|
{
|
ScrollRightBoundsChanged(this, e);
|
}
|
}
|
|
/// <summary>
|
/// Raises the <see cref="ScrollRightSelectedChanged"/> event
|
/// </summary>
|
/// <param name="e">Event data</param>
|
public void OnScrollRightSelectedChanged(EventArgs e)
|
{
|
if (ScrollRightSelectedChanged != null)
|
{
|
ScrollRightSelectedChanged(this, e);
|
}
|
}
|
|
/// <summary>
|
/// Raises the <see cref="ScrollLeftVisibleChanged"/> event
|
/// </summary>
|
/// <param name="e">Event data</param>
|
public void OnScrollLeftVisibleChanged(EventArgs e)
|
{
|
if (ScrollLeftVisibleChanged != null)
|
{
|
ScrollLeftVisibleChanged(this, e);
|
}
|
}
|
|
/// <summary>
|
/// Raises the <see cref="ScrollLeftPressedChanged"/> event
|
/// </summary>
|
/// <param name="e">Event data</param>
|
public void OnScrollLeftPressedChanged(EventArgs e)
|
{
|
if (ScrollLeftPressedChanged != null)
|
{
|
ScrollLeftPressedChanged(this, e);
|
}
|
}
|
|
/// <summary>
|
/// Raises the <see cref="ScrollLeftBoundsChanged"/> event
|
/// </summary>
|
/// <param name="e">Event data</param>
|
public void OnScrollLeftBoundsChanged(EventArgs e)
|
{
|
if (ScrollLeftBoundsChanged != null)
|
{
|
ScrollLeftBoundsChanged(this, e);
|
}
|
}
|
|
/// <summary>
|
/// Raises the <see cref="ScrollLeftSelectedChanged"/> event
|
/// </summary>
|
/// <param name="e">Event data</param>
|
public void OnScrollLeftSelectedChanged(EventArgs e)
|
{
|
if (ScrollLeftSelectedChanged != null)
|
{
|
ScrollLeftSelectedChanged(this, e);
|
}
|
}
|
|
#endregion
|
|
#region Methods
|
/// <summary>
|
/// Sets the tab as active without sending the message to the Ribbon
|
/// </summary>
|
internal void SetActive(bool active)
|
{
|
bool trigger = _active != active;
|
|
_active = active;
|
|
if (trigger)
|
OnActiveChanged(EventArgs.Empty);
|
}
|
|
/// <summary>
|
/// Sets the value of the TabBounds property
|
/// </summary>
|
/// <param name="tabBounds">Rectangle representing the bounds of the tab</param>
|
internal void SetTabBounds(Rectangle tabBounds)
|
{
|
bool tigger = TabBounds != tabBounds;
|
|
TabBounds = tabBounds;
|
|
OnTabBoundsChanged(EventArgs.Empty);
|
}
|
|
/// <summary>
|
/// Sets the value of the TabContentBounds
|
/// </summary>
|
/// <param name="tabContentBounds">Rectangle representing the bounds of the tab's content</param>
|
internal void SetTabContentBounds(Rectangle tabContentBounds)
|
{
|
bool trigger = TabContentBounds != tabContentBounds;
|
|
TabContentBounds = tabContentBounds;
|
|
OnTabContentBoundsChanged(EventArgs.Empty);
|
}
|
|
/// <summary>
|
/// Gets the panel with the larger width and the specified size mode
|
/// </summary>
|
/// <param name="size">Size mode of panel to search</param>
|
/// <returns>Larger panel. Null if none of the specified size mode</returns>
|
private RibbonPanel GetLargerPanel(RibbonElementSizeMode size)
|
{
|
RibbonPanel result = null;
|
|
foreach (RibbonPanel panel in Panels)
|
{
|
if (panel.SizeMode != size) continue;
|
|
if (result == null) result = panel;
|
|
if (panel.Bounds.Width > result.Bounds.Width)
|
{
|
result = panel;
|
}
|
}
|
|
return result;
|
}
|
|
/// <summary>
|
/// Gets the panel with a larger size
|
/// </summary>
|
/// <returns></returns>
|
private RibbonPanel GetLargerPanel()
|
{
|
RibbonPanel largeLarger = GetLargerPanel(RibbonElementSizeMode.Large);
|
|
if (largeLarger != null) return largeLarger;
|
|
RibbonPanel mediumLarger = GetLargerPanel(RibbonElementSizeMode.Medium);
|
|
if (mediumLarger != null) return mediumLarger;
|
|
RibbonPanel compactLarger = GetLargerPanel(RibbonElementSizeMode.Compact);
|
|
if (compactLarger != null) return compactLarger;
|
|
RibbonPanel overflowLarger = GetLargerPanel(RibbonElementSizeMode.Overflow);
|
|
if (overflowLarger != null) return overflowLarger;
|
|
return null;
|
}
|
|
private bool AllPanelsOverflow()
|
{
|
|
foreach (RibbonPanel panel in Panels)
|
{
|
if (panel.SizeMode != RibbonElementSizeMode.Overflow)
|
{
|
return false;
|
}
|
}
|
|
return true;
|
}
|
|
/// <summary>
|
/// Updates the regions of the panels and its contents
|
/// </summary>
|
internal void UpdatePanelsRegions()
|
{
|
if (Panels.Count == 0) return;
|
if (Owner == null || Owner.IsDisposed) return;
|
|
if (!Owner.IsDesignMode())
|
_offset = 0;
|
|
int curRight = TabContentBounds.Left + Owner.PanelPadding.Left + _offset;
|
int curLeft = TabContentBounds.Right - Owner.PanelPadding.Right;
|
int panelsTop = TabContentBounds.Top + Owner.PanelPadding.Top;
|
int panelsVisibles = 0;
|
|
using (Graphics g = Owner.CreateGraphics())
|
{
|
//Check all at full size
|
foreach (RibbonPanel panel in Panels)
|
{
|
if (panel.Visible && Owner.RightToLeft == RightToLeft.No)
|
{
|
RibbonElementSizeMode sMode = panel.FlowsTo == RibbonPanelFlowDirection.Right ? RibbonElementSizeMode.Medium : RibbonElementSizeMode.Large;
|
//Set the bounds of the panel to let it know it's height
|
panel.SetBounds(new Rectangle(0, 0, 1, TabContentBounds.Height - Owner.PanelPadding.Vertical));
|
|
//Size of the panel
|
Size size = panel.MeasureSize(this, new RibbonElementMeasureSizeEventArgs(g, sMode));
|
|
//Creates the bounds of the panel
|
Rectangle bounds = new Rectangle(
|
curRight, panelsTop,
|
size.Width, size.Height);
|
|
//Set the bounds of the panel
|
panel.SetBounds(bounds);
|
|
//Let the panel know what size we have decided for it
|
panel.SetSizeMode(sMode);
|
|
//Update curRight
|
curRight = bounds.Right + Owner.PanelSpacing;
|
|
//Update panelsVisibles
|
panelsVisibles += 1;
|
}
|
else if (panel.Visible && Owner.RightToLeft == RightToLeft.Yes)
|
{
|
RibbonElementSizeMode sMode = panel.FlowsTo == RibbonPanelFlowDirection.Right ? RibbonElementSizeMode.Medium : RibbonElementSizeMode.Large;
|
|
//Set the bounds of the panel to let it know it's height
|
panel.SetBounds(new Rectangle(0, 0, 1, TabContentBounds.Height - Owner.PanelPadding.Vertical));
|
|
//Size of the panel
|
Size size = panel.MeasureSize(this, new RibbonElementMeasureSizeEventArgs(g, sMode));
|
|
curLeft -= size.Width + Owner.PanelSpacing;
|
|
//Creates the bounds of the panel
|
Rectangle bounds = new Rectangle(
|
curLeft, panelsTop,
|
size.Width, size.Height);
|
|
//Set the bounds of the panel
|
panel.SetBounds(bounds);
|
|
//Let the panel know what size we have decided for it
|
panel.SetSizeMode(sMode);
|
|
//Update curLeft
|
curLeft = bounds.Left - 1 - Owner.PanelSpacing;
|
|
//Update panelsVisibles
|
panelsVisibles += 1;
|
}
|
else
|
{
|
panel.SetBounds(Rectangle.Empty);
|
}
|
}
|
|
if (!Owner.IsDesignMode())
|
{
|
//check if there are visible panels
|
if (panelsVisibles > 0)
|
{
|
while (curRight > TabContentBounds.Right && !AllPanelsOverflow())
|
{
|
#region Down grade the larger panel one position
|
|
RibbonPanel larger = GetLargerPanel();
|
|
if (larger.SizeMode == RibbonElementSizeMode.Large)
|
larger.SetSizeMode(RibbonElementSizeMode.Medium);
|
else if (larger.SizeMode == RibbonElementSizeMode.Medium)
|
larger.SetSizeMode(RibbonElementSizeMode.Compact);
|
else if (larger.SizeMode == RibbonElementSizeMode.Compact)
|
larger.SetSizeMode(RibbonElementSizeMode.Overflow);
|
|
Size size = larger.MeasureSize(this, new RibbonElementMeasureSizeEventArgs(g, larger.SizeMode));
|
|
larger.SetBounds(new Rectangle(larger.Bounds.Location, new Size(size.Width + Owner.PanelMargin.Horizontal, size.Height)));
|
|
#endregion
|
|
//Reset x-axis reminder
|
curRight = TabContentBounds.Left + Owner.PanelPadding.Left;
|
|
//Re-arrange location because of the new bounds
|
foreach (RibbonPanel panel in Panels)
|
{
|
Size s = panel.Bounds.Size;
|
panel.SetBounds(new Rectangle(new Point(curRight, panelsTop), s));
|
curRight += panel.Bounds.Width + Owner.PanelSpacing;
|
}
|
|
}
|
}
|
}
|
|
//Update regions of all panels
|
foreach (RibbonPanel panel in Panels)
|
{
|
panel.UpdateItemsRegions(g, panel.SizeMode);
|
}
|
}
|
|
UpdateScrollBounds();
|
}
|
|
/// <summary>
|
/// Updates the bounds of the scroll bounds
|
/// </summary>
|
private void UpdateScrollBounds()
|
{
|
int w = 13;
|
bool scrBuffer = ScrollRightVisible;
|
bool sclBuffer = ScrollLeftVisible;
|
Rectangle rrBuffer = ScrollRightBounds;
|
Rectangle rlBuffer = ScrollLeftBounds;
|
|
if (Panels.Count == 0) return;
|
|
|
|
if (Panels[Panels.Count - 1].Bounds.Right > TabContentBounds.Right)
|
{
|
ScrollRightVisible = true;
|
}
|
else
|
{
|
ScrollRightVisible = false;
|
}
|
|
if (ScrollRightVisible != scrBuffer)
|
{
|
OnScrollRightVisibleChanged(EventArgs.Empty);
|
}
|
|
|
|
if (_offset < 0)
|
{
|
ScrollLeftVisible = true;
|
}
|
else
|
{
|
ScrollLeftVisible = false;
|
}
|
|
if (ScrollRightVisible != scrBuffer)
|
{
|
OnScrollLeftVisibleChanged(EventArgs.Empty);
|
}
|
|
if (ScrollLeftVisible || ScrollRightVisible)
|
{
|
ScrollRightBounds = Rectangle.FromLTRB(
|
Owner.ClientRectangle.Right - w,
|
TabContentBounds.Top,
|
Owner.ClientRectangle.Right,
|
TabContentBounds.Bottom);
|
|
ScrollLeftBounds = Rectangle.FromLTRB(
|
0,
|
TabContentBounds.Top,
|
w,
|
TabContentBounds.Bottom);
|
|
if (ScrollRightBounds != rrBuffer)
|
{
|
OnScrollRightBoundsChanged(EventArgs.Empty);
|
}
|
|
if (ScrollLeftBounds != rlBuffer)
|
{
|
OnScrollLeftBoundsChanged(EventArgs.Empty);
|
}
|
}
|
}
|
|
/// <summary>
|
/// Overriden. Returns a string representation of the tab
|
/// </summary>
|
/// <returns></returns>
|
public override string ToString()
|
{
|
return string.Format("Tab: {0}", Text);
|
}
|
|
/// <summary>
|
/// Raises the MouseEnter event
|
/// </summary>
|
/// <param name="e">Event data</param>
|
public virtual void OnMouseEnter(MouseEventArgs e)
|
{
|
if (MouseEnter != null)
|
{
|
MouseEnter(this, e);
|
}
|
}
|
|
/// <summary>
|
/// Raises the MouseLeave event
|
/// </summary>
|
/// <param name="e">Event data</param>
|
public virtual void OnMouseLeave(MouseEventArgs e)
|
{
|
_TT.Active = false;
|
|
if (MouseLeave != null)
|
{
|
MouseLeave(this, e);
|
}
|
}
|
|
/// <summary>
|
/// Raises the MouseMove event
|
/// </summary>
|
/// <param name="e">Event data</param>
|
public virtual void OnMouseMove(MouseEventArgs e)
|
{
|
if (MouseMove != null)
|
{
|
MouseMove(this, e);
|
}
|
if (!_TT.Active && !string.IsNullOrEmpty(ToolTip)) // ToolTip should be working without title as well - to get Office 2007 Look & Feel
|
{
|
if (ToolTip != _TT.GetToolTip(Owner))
|
{
|
_TT.SetToolTip(Owner, ToolTip);
|
}
|
_TT.Active = true;
|
}
|
}
|
|
/// <summary>
|
/// Sets the value of the <see cref="ScrollLeftPressed"/>
|
/// </summary>
|
/// <param name="pressed"></param>
|
internal void SetScrollLeftPressed(bool pressed)
|
{
|
ScrollLeftPressed = pressed;
|
|
if (pressed)
|
ScrollLeft();
|
|
OnScrollLeftPressedChanged(EventArgs.Empty);
|
}
|
|
/// <summary>
|
/// Sets the value of the <see cref="ScrollLeftSelected"/>
|
/// </summary>
|
/// <param name="selected"></param>
|
internal void SetScrollLeftSelected(bool selected)
|
{
|
ScrollLeftSelected = selected;
|
|
OnScrollLeftSelectedChanged(EventArgs.Empty);
|
}
|
|
/// <summary>
|
/// Sets the value of the <see cref="ScrollRightPressed"/>
|
/// </summary>
|
/// <param name="pressed"></param>
|
internal void SetScrollRightPressed(bool pressed)
|
{
|
ScrollRightPressed = pressed;
|
|
if (pressed) ScrollRight();
|
|
OnScrollRightPressedChanged(EventArgs.Empty);
|
}
|
|
/// <summary>
|
/// Sets the value of the <see cref="ScrollRightSelected"/>
|
/// </summary>
|
/// <param name="selected"></param>
|
internal void SetScrollRightSelected(bool selected)
|
{
|
ScrollRightSelected = selected;
|
|
OnScrollRightSelectedChanged(EventArgs.Empty);
|
}
|
|
/// <summary>
|
/// Presses the lef-scroll button
|
/// </summary>
|
public void ScrollLeft()
|
{
|
ScrollOffset(50);
|
}
|
|
/// <summary>
|
/// Presses the left-scroll button
|
/// </summary>
|
public void ScrollRight()
|
{
|
ScrollOffset(-50);
|
}
|
|
public void ScrollOffset(int amount)
|
{
|
_offset += amount;
|
|
foreach (RibbonPanel p in Panels)
|
{
|
p.SetBounds(new Rectangle(p.Bounds.Left + amount,
|
p.Bounds.Top, p.Bounds.Width, p.Bounds.Height));
|
}
|
|
if (Site != null && Site.DesignMode)
|
UpdatePanelsRegions();
|
|
UpdateScrollBounds();
|
|
Owner.Invalidate();
|
}
|
|
private void _TT_Popup(object sender, PopupEventArgs e)
|
{
|
if (ToolTipPopUp != null)
|
{
|
ToolTipPopUp(sender, new RibbonElementPopupEventArgs(this, e));
|
if (ToolTip != _TT.GetToolTip(Owner))
|
_TT.SetToolTip(Owner, ToolTip);
|
}
|
}
|
|
private void EnsureAnyTabVisible()
|
{
|
int myIndex = Owner.Tabs.IndexOf(this);
|
// check if any of the next tabs is visible
|
for (int i = myIndex; i < Owner.Tabs.Count; i++)
|
{
|
if (this == Owner.Tabs[i])
|
continue;
|
// check member, Property is false if control is hidden
|
if (Owner.Tabs[i]._visible)
|
{
|
Owner.ActiveTab = Owner.Tabs[i];
|
return; // return because Invalidate is done during setting the active tab
|
}
|
}
|
// check if any of the previous tabs is visible
|
for (int i = 0; i < myIndex; i++)
|
{
|
if (this == Owner.Tabs[i])
|
continue;
|
// check member, Property is false if control is hidden
|
if (Owner.Tabs[i]._visible)
|
{
|
Owner.ActiveTab = Owner.Tabs[i];
|
return; // return because Invalidate is done during setting the active tab
|
}
|
}
|
Owner.Invalidate();
|
}
|
|
#endregion
|
|
#region IContainsRibbonComponents Members
|
|
public IEnumerable<Component> GetAllChildComponents()
|
{
|
return Panels.ToArray();
|
}
|
|
#endregion
|
}
|
}
|
