2105 lines
81 KiB
C#
2105 lines
81 KiB
C#
using System;
|
|
using System.ComponentModel;
|
|
using System.Drawing;
|
|
using System.Runtime.InteropServices;
|
|
using System.Windows.Forms;
|
|
using System.Collections;
|
|
|
|
namespace DevComponents.DotNetBar
|
|
{
|
|
/// <summary>
|
|
/// Represents RibbonStrip control internally used by RibbonControl.
|
|
/// </summary>
|
|
[ToolboxItem(false), ComVisible(false)]
|
|
public class RibbonStrip : ItemControl
|
|
{
|
|
private const int Office2010GlassExcludeTopPart = 29;
|
|
#region Private Variables & Constructor
|
|
private RibbonStripContainerItem m_StripContainer = null;
|
|
//private GenericItemContainer m_ItemContainer=null;
|
|
private RibbonTabItemGroupCollection m_Groups = null;
|
|
private int m_TabGroupHeight = 14;
|
|
private bool m_TabGroupsVisible = false;
|
|
private Font m_DefaultGroupFont = null;
|
|
private Font m_DefaultGroupFontAuto = null;
|
|
private int m_CaptionHeight = 0;
|
|
private bool m_CaptionVisible = false;
|
|
private bool m_AutoExpand = true;
|
|
//private GenericItemContainer m_CaptionContainer = null;
|
|
//private SystemCaptionItem m_SystemCaptionItem = null;
|
|
private int m_RibbonStripIndent = 46;
|
|
private Rectangle m_CaptionBounds = Rectangle.Empty;
|
|
private Rectangle m_QuickToolbarBounds = Rectangle.Empty;
|
|
private Rectangle m_SystemCaptionItemBounds = Rectangle.Empty;
|
|
private Rectangle[] m_CaptionTextBounds = null;
|
|
private Font m_CaptionFont = null;
|
|
private bool m_CanCustomize = true;
|
|
private ElementStyle m_DefaultBackgroundStyle = new ElementStyle();
|
|
private bool m_KeyTipsEnabled = true;
|
|
private string m_TitleText = "";
|
|
private bool m_CanSupportGlass = false;
|
|
|
|
public RibbonStrip()
|
|
{
|
|
this.SetStyle(ControlStyles.StandardDoubleClick, true);
|
|
|
|
m_StripContainer = new RibbonStripContainerItem(this);
|
|
m_StripContainer.GlobalItem = false;
|
|
m_StripContainer.ContainerControl = this;
|
|
m_StripContainer.Displayed = true;
|
|
m_StripContainer.SetOwner(this);
|
|
m_StripContainer.Style = eDotNetBarStyle.Office2003;
|
|
this.SetBaseItemContainer(m_StripContainer);
|
|
|
|
this.ColorScheme.Style = eDotNetBarStyle.Office2003;
|
|
|
|
this.AutoSize = true;
|
|
|
|
m_Groups = new RibbonTabItemGroupCollection();
|
|
m_Groups.Owner = this;
|
|
|
|
// Setup system caption item
|
|
m_StripContainer.SystemCaptionItem.Click += SystemCaptionClick;
|
|
}
|
|
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
m_StripContainer.SystemCaptionItem.Click -= SystemCaptionClick;
|
|
base.Dispose(disposing);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Events
|
|
/// <summary>
|
|
/// Occurs when text markup link from TitleText markup is clicked. Markup links can be created using "a" tag, for example:
|
|
/// <a name="MyLink">Markup link</a>
|
|
/// </summary>
|
|
[Description("Occurs when text markup link from TitleText markup is clicked.")]
|
|
public event MarkupLinkClickEventHandler TitleTextMarkupLinkClick;
|
|
#endregion
|
|
|
|
#region Internal Implementation
|
|
/// <summary>
|
|
/// Gets or sets whether RibbonStrip control employs the Windows Vista Glass support when available. This is managed automatically by Ribbon Control and
|
|
/// no setting is necessary on your part.
|
|
/// </summary>
|
|
[Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public bool CanSupportGlass
|
|
{
|
|
get { return m_CanSupportGlass; }
|
|
set { m_CanSupportGlass = value; }
|
|
}
|
|
|
|
internal override bool IsGlassEnabled
|
|
{
|
|
get
|
|
{
|
|
bool baseIsGlassEnabled = base.IsGlassEnabled;
|
|
if (!m_CanSupportGlass || !baseIsGlassEnabled) return false;
|
|
Form form = this.FindForm();
|
|
if (form is OfficeForm) return false;
|
|
if (form is RibbonForm)
|
|
return ((RibbonForm)form).IsGlassEnabled;
|
|
return baseIsGlassEnabled;
|
|
}
|
|
}
|
|
|
|
private TextMarkup.BodyElement m_TitleTextMarkup = null;
|
|
/// <summary>
|
|
/// Gets or sets the rich text displayed on Ribbon Title instead of the Form.Text property. This property supports text-markup.
|
|
/// You can use <font color="SysCaptionTextExtra"> markup to instruct the markup renderer to use Office 2007 system caption extra text color which
|
|
/// changes depending on the currently selected color table. Note that when using this property you should manage also the Form.Text property since
|
|
/// that is the text that will be displayed in Windows task-bar and elsewhere where system Form.Text property is used.
|
|
/// You can also use the hyperlinks as part of the text markup and handle the TitleTextMarkupLinkClick event to be notified when they are clicked.
|
|
/// </summary>
|
|
[Browsable(true), DefaultValue(""), Editor("DevComponents.DotNetBar.Design.TextMarkupUIEditor, DevComponents.DotNetBar.Design, Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf", typeof(System.Drawing.Design.UITypeEditor)), EditorBrowsable(EditorBrowsableState.Always), Category("Appearance"), Description("Indicates text displayed on Ribbon Title instead of the Form.Text property.")]
|
|
public string TitleText
|
|
{
|
|
get { return m_TitleText; }
|
|
set
|
|
{
|
|
if (value == null) value = "";
|
|
m_TitleText = value;
|
|
m_TitleTextMarkup = null;
|
|
|
|
if (!TextMarkup.MarkupParser.IsMarkup(ref m_TitleText))
|
|
return;
|
|
|
|
m_TitleTextMarkup = TextMarkup.MarkupParser.Parse(m_TitleText);
|
|
|
|
if (m_TitleTextMarkup != null)
|
|
m_TitleTextMarkup.HyperLinkClick += new EventHandler(InternalTitleTextMarkupLinkClick);
|
|
TitleTextMarkupLastArrangeBounds = Rectangle.Empty;
|
|
this.Invalidate();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Occurs when text markup link is clicked.
|
|
/// </summary>
|
|
private void InternalTitleTextMarkupLinkClick(object sender, EventArgs e)
|
|
{
|
|
TextMarkup.HyperLink link = sender as TextMarkup.HyperLink;
|
|
if (link != null)
|
|
{
|
|
if (TitleTextMarkupLinkClick != null)
|
|
TitleTextMarkupLinkClick(this, new MarkupLinkClickEventArgs(link.Name, link.HRef));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets reference to parsed markup body element if text was markup otherwise returns null.
|
|
/// </summary>
|
|
internal TextMarkup.BodyElement TitleTextMarkupBody
|
|
{
|
|
get { return m_TitleTextMarkup; }
|
|
}
|
|
|
|
internal Rectangle TitleTextMarkupLastArrangeBounds = Rectangle.Empty;
|
|
/// <summary>
|
|
/// Gets or sets whether KeyTips functionality is enabled. Default value is true.
|
|
/// </summary>
|
|
[DefaultValue(true), Browsable(true), Category("Behavior"), Description("Indicates whether KeyTips functionality is enabled.")]
|
|
public bool KeyTipsEnabled
|
|
{
|
|
get { return m_KeyTipsEnabled; }
|
|
set { m_KeyTipsEnabled = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether control can be customized and items added by end-user using context menu to the quick access toolbar.
|
|
/// Caption of the control must be visible for customization to be enabled. Default value is true.
|
|
/// </summary>
|
|
[DefaultValue(true), Browsable(true), Category("Customization"), Description("Indicates whether control can be customized. Caption must be visible for customization to be fully enabled.")]
|
|
public bool CanCustomize
|
|
{
|
|
get { return m_CanCustomize; }
|
|
set { m_CanCustomize = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the explicit height of the caption provided by control. Caption height when set is composed of the TabGroupHeight and
|
|
/// the value specified here. Default value is 0 which means that system default caption size is used.
|
|
/// </summary>
|
|
[Browsable(true), DefaultValue(0), Category("Appearance"), Description("Indicates explicit height of the caption provided by control")]
|
|
public int CaptionHeight
|
|
{
|
|
get { return m_CaptionHeight; }
|
|
set
|
|
{
|
|
m_CaptionHeight = value;
|
|
m_StripContainer.NeedRecalcSize = true;
|
|
}
|
|
}
|
|
|
|
internal bool HasVisibleTabs
|
|
{
|
|
get
|
|
{
|
|
foreach (BaseItem item in this.Items)
|
|
{
|
|
if (item.Visible) return true;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
internal Rectangle[] CaptionTextBounds
|
|
{
|
|
get { return m_CaptionTextBounds; }
|
|
set { m_CaptionTextBounds = value; }
|
|
}
|
|
|
|
internal Rectangle CaptionBounds
|
|
{
|
|
get { return m_CaptionBounds; }
|
|
set { m_CaptionBounds = value; }
|
|
}
|
|
[EditorBrowsable(EditorBrowsableState.Never), Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public Rectangle QuickToolbarBounds
|
|
{
|
|
get { return m_QuickToolbarBounds; }
|
|
set { m_QuickToolbarBounds = value; }
|
|
}
|
|
|
|
internal Rectangle SystemCaptionItemBounds
|
|
{
|
|
get { return m_SystemCaptionItemBounds; }
|
|
set { m_SystemCaptionItemBounds = value; }
|
|
}
|
|
|
|
internal SystemCaptionItem SystemCaptionItem
|
|
{
|
|
get { return m_StripContainer.SystemCaptionItem; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether custom caption line provided by the control is visible. Default value is false.
|
|
/// This property should be set to true when control is used on Office2007RibbonForm.
|
|
/// </summary>
|
|
[Browsable(true), DefaultValue(false), Category("Appearance"), Description("Indicates whether custom caption line provided by the control is visible.")]
|
|
public bool CaptionVisible
|
|
{
|
|
get { return m_CaptionVisible; }
|
|
set
|
|
{
|
|
m_CaptionVisible = value;
|
|
OnCaptionVisibleChanged();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the font for the form caption text when CaptionVisible=true. Default value is NULL which means that system font is used.
|
|
/// </summary>
|
|
[Browsable(true), DefaultValue(null), Category("Appearance"), Description("")]
|
|
public Font CaptionFont
|
|
{
|
|
get { return m_CaptionFont; }
|
|
set
|
|
{
|
|
m_CaptionFont = value;
|
|
m_StripContainer.NeedRecalcSize = true;
|
|
this.Invalidate();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the indent of the ribbon strip. The indent setting is useful when control is used with caption visible and the Office 2007
|
|
/// style start button. The indent specified here will move the ribbon strip so the start button does not overlap the tabs.
|
|
/// Value of this property is used only when CaptionVisible = true.
|
|
/// Default value is 46.
|
|
/// </summary>
|
|
[Browsable(true), DefaultValue(46), Category("Layout"), Description("Indicates indent of the ribbon strip.")]
|
|
public int RibbonStripIndent
|
|
{
|
|
get { return m_RibbonStripIndent; }
|
|
set
|
|
{
|
|
m_RibbonStripIndent = value;
|
|
this.RecalcLayout();
|
|
}
|
|
}
|
|
|
|
private void OnCaptionVisibleChanged()
|
|
{
|
|
m_StripContainer.NeedRecalcSize = true;
|
|
this.RecalcLayout();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the height in pixels of tab group line that is displayed above the RibbonTabItem objects that have group assigned.
|
|
/// Default value is 14 pixels. To show tab groups you need to assign the RibbonTabItem.Group property and set TabGroupsVisible=true.
|
|
/// </summary>
|
|
[Browsable(true), DevCoBrowsable(true), DefaultValue(14), Category("Tab Groups"), Description("Indicates height in pixels of tab group line that is displayed above the RibbonTabItem objects that have group assigned.")]
|
|
public int TabGroupHeight
|
|
{
|
|
get { return m_TabGroupHeight; }
|
|
set
|
|
{
|
|
m_TabGroupHeight = value;
|
|
m_StripContainer.NeedRecalcSize = true;
|
|
if (this.DesignMode)
|
|
this.RecalcLayout();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether tab group line that is displayed above the RibbonTabItem objects that have group assigned is visible.
|
|
/// Default value is false. To show tab groups you need to assign the RibbonTabItem.Group property and set TabGroupsVisible=true. Use TabGroupHeight
|
|
/// property to control height of the group line.
|
|
/// </summary>
|
|
[Browsable(true), DevCoBrowsable(true), DefaultValue(false), Category("Tab Groups"), Description("Indicates height in pixels of tab group line that is displayed above the RibbonTabItem objects that have group assigned.")]
|
|
public bool TabGroupsVisible
|
|
{
|
|
get { return m_TabGroupsVisible; }
|
|
set
|
|
{
|
|
m_TabGroupsVisible = value;
|
|
m_StripContainer.NeedRecalcSize = true;
|
|
if (this.DesignMode)
|
|
this.RecalcLayout();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Collection of RibbonTabItemGroup items. Groups are assigned optionally to one or more RibbonTabItem object through the RibbonTabItem.Group
|
|
/// property to visually group tabs that belong to same functions. These tabs should be positioned next to each other.
|
|
/// </summary>
|
|
[Editor("DevComponents.DotNetBar.Design.RibbonTabItemGroupCollectionEditor, DevComponents.DotNetBar.Design, Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf", typeof(System.Drawing.Design.UITypeEditor)), DesignerSerializationVisibility(DesignerSerializationVisibility.Content), Category("Tab Groups"), Browsable(true), DevCoBrowsable(true)]
|
|
public RibbonTabItemGroupCollection TabGroups
|
|
{
|
|
get { return m_Groups; }
|
|
}
|
|
|
|
internal eDotNetBarStyle EffectiveStyle
|
|
{
|
|
get
|
|
{
|
|
return m_StripContainer.EffectiveStyle;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Gets/Sets the visual style of the control.
|
|
/// </summary>
|
|
[Browsable(true), DevCoBrowsable(true), Category("Appearance"), Description("Specifies the visual style of the control."), DefaultValue(eDotNetBarStyle.Office2003)]
|
|
public eDotNetBarStyle Style
|
|
{
|
|
get
|
|
{
|
|
return m_StripContainer.Style;
|
|
}
|
|
set
|
|
{
|
|
this.ColorScheme.Style = value;
|
|
m_StripContainer.Style = value;
|
|
this.Invalidate();
|
|
this.RecalcLayout();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns collection of items on a bar.
|
|
/// </summary>
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content), Browsable(false)]
|
|
public SubItemsCollection Items
|
|
{
|
|
get
|
|
{
|
|
return m_StripContainer.RibbonStripContainer.SubItems;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns currently selected RibbonTabItem. RibbonTabItems are selected using the Checked property. Only a single
|
|
/// RibbonTabItem can be Checked at any given time.
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
public RibbonTabItem SelectedRibbonTabItem
|
|
{
|
|
get
|
|
{
|
|
foreach (BaseItem item in this.Items)
|
|
{
|
|
if (item is RibbonTabItem && ((RibbonTabItem)item).Checked)
|
|
return (RibbonTabItem)item;
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
|
|
internal override ItemPaintArgs GetItemPaintArgs(Graphics g)
|
|
{
|
|
ItemPaintArgs pa = base.GetItemPaintArgs(g);
|
|
RibbonControl rc = this.Parent as RibbonControl;
|
|
if (rc != null)
|
|
pa.ControlExpanded = rc.Expanded || rc.IsPopupMode;
|
|
return pa;
|
|
}
|
|
|
|
protected override void WndProc(ref Message m)
|
|
{
|
|
if (m.Msg == (int)WinApi.WindowsMessages.WM_NCHITTEST)
|
|
{
|
|
// Get position being tested...
|
|
int x = WinApi.LOWORD(m.LParam);
|
|
int y = WinApi.HIWORD(m.LParam);
|
|
Point p = PointToClient(new Point(x, y));
|
|
if (IsGlassEnabled && this.CaptionVisible)
|
|
{
|
|
Rectangle r = new Rectangle(this.Width - BarFunctions.CaptionButtonSize.Width * 3, 0, BarFunctions.CaptionButtonSize.Width * 3, BarFunctions.CaptionButtonSize.Height + 6);
|
|
if (r.Contains(p))
|
|
{
|
|
m.Result = new IntPtr((int)WinApi.WindowHitTestRegions.TransparentOrCovered);
|
|
return;
|
|
}
|
|
|
|
r = new Rectangle(0, 0, this.Width, 4);
|
|
if (r.Contains(p))
|
|
{
|
|
m.Result = new IntPtr((int)WinApi.WindowHitTestRegions.TransparentOrCovered);
|
|
return;
|
|
}
|
|
|
|
if (BarFunctions.IsWindows7 && this.IsMaximized)
|
|
{
|
|
Rectangle[] captionTextBounds = m_CaptionTextBounds;
|
|
if (captionTextBounds != null)
|
|
{
|
|
foreach (Rectangle item in captionTextBounds)
|
|
{
|
|
if (item.Contains(p))
|
|
{
|
|
m.Result = new IntPtr((int)WinApi.WindowHitTestRegions.TransparentOrCovered);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (this.CaptionVisible && !this.IsMaximized)
|
|
{
|
|
Rectangle r = new Rectangle(0, 0, this.Width, Dpi.Height4);
|
|
if (r.Contains(p))
|
|
{
|
|
m.Result = new IntPtr((int)WinApi.WindowHitTestRegions.TransparentOrCovered);
|
|
return;
|
|
}
|
|
}
|
|
|
|
eDotNetBarStyle effectiveStyle = this.EffectiveStyle;
|
|
if (m_CaptionVisible && (effectiveStyle == eDotNetBarStyle.Office2010 || StyleManager.IsMetro(effectiveStyle)) && (p.X < Dpi.Width28 && this.RightToLeft == RightToLeft.No || p.X > this.Width - Dpi.Width28 && this.RightToLeft == RightToLeft.Yes) && p.Y < Dpi.Height28)
|
|
{
|
|
m.Result = new IntPtr((int)WinApi.WindowHitTestRegions.TransparentOrCovered);
|
|
return;
|
|
}
|
|
else if (m_CaptionVisible && effectiveStyle == eDotNetBarStyle.Windows7 && (p.X < Dpi.Width28 && this.RightToLeft == RightToLeft.No || p.X > this.Width - Dpi.Width28 && this.RightToLeft == RightToLeft.Yes) && p.Y < Dpi.Height28)
|
|
{
|
|
m.Result = new IntPtr((int)WinApi.WindowHitTestRegions.TransparentOrCovered);
|
|
return;
|
|
}
|
|
}
|
|
|
|
base.WndProc(ref m);
|
|
}
|
|
|
|
internal bool IsMaximized
|
|
{
|
|
get
|
|
{
|
|
Form f = this.FindForm();
|
|
return (f != null && f.WindowState == FormWindowState.Maximized);
|
|
}
|
|
}
|
|
|
|
protected override void ClearBackground(ItemPaintArgs pa)
|
|
{
|
|
if (this.IsGlassEnabled)
|
|
{
|
|
RibbonForm f = this.FindForm() as RibbonForm;
|
|
if (f != null)
|
|
{
|
|
pa.Graphics.Clear(Color.Transparent);
|
|
pa.Graphics.SetClip(new Rectangle(0, 0, this.Width, f.GlassHeight - 1), System.Drawing.Drawing2D.CombineMode.Exclude);
|
|
}
|
|
base.ClearBackground(pa);
|
|
pa.Graphics.ResetClip();
|
|
}
|
|
else
|
|
base.ClearBackground(pa);
|
|
}
|
|
protected override Rectangle GetPaintControlBackgroundRectangle()
|
|
{
|
|
if (this.IsGlassEnabled && (this.EffectiveStyle == eDotNetBarStyle.Office2010 || StyleManager.IsMetro(this.EffectiveStyle)))
|
|
{
|
|
Rectangle r = base.GetPaintControlBackgroundRectangle();
|
|
r.Y += Office2010GlassExcludeTopPart;
|
|
r.Height -= Office2010GlassExcludeTopPart;
|
|
return r;
|
|
}
|
|
return base.GetPaintControlBackgroundRectangle();
|
|
}
|
|
protected override void PaintControlBackground(ItemPaintArgs pa)
|
|
{
|
|
bool resetClip = false;
|
|
eDotNetBarStyle effectiveStyle = this.EffectiveStyle;
|
|
|
|
bool isGlassEnabled = this.IsGlassEnabled;
|
|
RibbonForm ribbonForm = this.FindForm() as RibbonForm;
|
|
|
|
if (isGlassEnabled)
|
|
{
|
|
if (ribbonForm != null)
|
|
{
|
|
pa.Graphics.SetClip(new Rectangle(0, 0, this.Width, ribbonForm.GlassHeight - ((effectiveStyle == eDotNetBarStyle.Office2010 || StyleManager.IsMetro(effectiveStyle)) && pa.GlassEnabled ? Office2010GlassExcludeTopPart : 1)),
|
|
System.Drawing.Drawing2D.CombineMode.Exclude);
|
|
resetClip = true;
|
|
}
|
|
}
|
|
|
|
if (isGlassEnabled && (effectiveStyle == eDotNetBarStyle.Office2010 || StyleManager.IsMetro(effectiveStyle)))
|
|
{
|
|
ElementStyle style = GetBackgroundStyle();
|
|
if (style != null)
|
|
{
|
|
Rectangle r = new Rectangle(0, Office2010GlassExcludeTopPart - 2, this.Width, this.Height + 8);
|
|
using (System.Drawing.Drawing2D.GraphicsPath fillPath = new System.Drawing.Drawing2D.GraphicsPath())
|
|
{
|
|
fillPath.AddEllipse(r);
|
|
using (System.Drawing.Drawing2D.PathGradientBrush brush = new System.Drawing.Drawing2D.PathGradientBrush(fillPath))
|
|
{
|
|
brush.CenterColor = style.BackColor;
|
|
brush.SurroundColors = new Color[] { style.BackColor2 };
|
|
brush.CenterPoint = new PointF(r.Width / 2, r.Bottom - Office2010GlassExcludeTopPart / 2);
|
|
System.Drawing.Drawing2D.Blend blend = new System.Drawing.Drawing2D.Blend();
|
|
blend.Factors = new float[] { 0f, .85f, 1f, };
|
|
blend.Positions = new float[] { 0f, .65f, 1f };
|
|
brush.Blend = blend;
|
|
pa.Graphics.FillPath(brush, fillPath);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
base.PaintControlBackground(pa);
|
|
|
|
if (resetClip) pa.Graphics.ResetClip();
|
|
|
|
m_QuickToolbarBounds = Rectangle.Empty;
|
|
m_CaptionBounds = Rectangle.Empty;
|
|
m_SystemCaptionItemBounds = Rectangle.Empty;
|
|
|
|
Rendering.BaseRenderer renderer = GetRenderer();
|
|
RibbonControl ribbon = this.Parent as RibbonControl;
|
|
if (renderer != null && ribbon != null)
|
|
{
|
|
RibbonControlRendererEventArgs rargs = new RibbonControlRendererEventArgs(pa.Graphics, this.Parent as RibbonControl, pa.GlassEnabled);
|
|
rargs.ItemPaintArgs = pa;
|
|
renderer.DrawRibbonControlBackground(rargs);
|
|
|
|
if (ribbon.BackgroundImage != null && !this.IsBackstageOpen)
|
|
{
|
|
Rectangle br = GetBackgroundImageRect(ribbonForm);
|
|
BarFunctions.PaintBackgroundImage(pa.Graphics, br, ribbon.BackgroundImage,
|
|
ribbon.BackgroundImagePosition, 255);
|
|
}
|
|
|
|
if (m_CaptionVisible)
|
|
renderer.DrawQuickAccessToolbarBackground(new RibbonControlRendererEventArgs(pa.Graphics, this.Parent as RibbonControl, pa.GlassEnabled));
|
|
}
|
|
|
|
if (m_TabGroupsVisible)
|
|
{
|
|
PaintTabGroups(pa);
|
|
}
|
|
|
|
// Paint form caption text
|
|
if (renderer != null && m_CaptionVisible)
|
|
{
|
|
RibbonControlRendererEventArgs rer = new RibbonControlRendererEventArgs(pa.Graphics, this.Parent as RibbonControl, pa.GlassEnabled);
|
|
rer.ItemPaintArgs = pa;
|
|
renderer.DrawRibbonFormCaptionText(rer);
|
|
}
|
|
|
|
#if TRIAL
|
|
if (NativeFunctions.ColorExpAlt())
|
|
{
|
|
pa.Graphics.Clear(Color.White);
|
|
TextDrawing.DrawString(pa.Graphics, "Trial Version Expired :-(", this.Font, Color.FromArgb(128, Color.Black), this.ClientRectangle, eTextFormat.HorizontalCenter | eTextFormat.VerticalCenter);
|
|
}
|
|
//else
|
|
//{
|
|
// TextDrawing.DrawString(pa.Graphics, "Trial Version", this.Font, Color.FromArgb(128, Color.Black), new Rectangle(0, 0, this.Width - 12, this.Height-4), eTextFormat.Right | eTextFormat.Bottom);
|
|
//}
|
|
#endif
|
|
}
|
|
|
|
private Rectangle GetBackgroundImageRect(RibbonForm ribbonForm)
|
|
{
|
|
Rectangle br = this.ClientRectangle;
|
|
if (ribbonForm != null)
|
|
br.Inflate(ribbonForm.BorderSize - 1, 0);
|
|
return br;
|
|
}
|
|
|
|
private bool _TabGroupPaintSuspended = false;
|
|
/// <summary>
|
|
/// Gets or set whether TabGroup painting is suspended.
|
|
/// </summary>
|
|
internal bool TabGroupPaintSuspended
|
|
{
|
|
get { return _TabGroupPaintSuspended; }
|
|
set
|
|
{
|
|
if (_TabGroupPaintSuspended != value)
|
|
{
|
|
_TabGroupPaintSuspended = value;
|
|
this.Invalidate();
|
|
Form form = this.FindForm();
|
|
if (form != null) form.Invalidate();
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void PaintTabGroups(ItemPaintArgs pa)
|
|
{
|
|
if (m_Groups.Count == 0 || _TabGroupPaintSuspended)
|
|
return;
|
|
RibbonTabItemGroup currentGroup = null;
|
|
Rectangle groupRect = Rectangle.Empty;
|
|
Rectangle groupBounds = Rectangle.Empty;
|
|
int y = 0;
|
|
eDotNetBarStyle effectiveStyle = this.EffectiveStyle;
|
|
|
|
if (m_CaptionVisible)
|
|
{
|
|
if (effectiveStyle == eDotNetBarStyle.Office2010 || StyleManager.IsMetro(effectiveStyle))
|
|
y += 1;
|
|
else
|
|
y += (pa.GlassEnabled && effectiveStyle == eDotNetBarStyle.Windows7) ? 4 : 3;
|
|
}
|
|
|
|
foreach (RibbonTabItemGroup group in this.TabGroups)
|
|
group.DisplayPositions.Clear();
|
|
|
|
foreach (BaseItem item in this.Items)
|
|
{
|
|
#if TRIAL
|
|
if (NativeFunctions.ColorExpAlt())
|
|
return;
|
|
#endif
|
|
if (item is RibbonTabItem)
|
|
{
|
|
RibbonTabItem tab = item as RibbonTabItem;
|
|
if (tab.Group != currentGroup)
|
|
{
|
|
if (tab.Visible)
|
|
{
|
|
if (currentGroup != null)
|
|
PaintGroup(pa, currentGroup, groupRect, groupBounds);
|
|
currentGroup = tab.Group;
|
|
if (currentGroup != null)
|
|
{
|
|
currentGroup.DisplayPositions.Clear();
|
|
groupRect = new Rectangle(tab.DisplayRectangle.X, y, tab.DisplayRectangle.Width, ((effectiveStyle == eDotNetBarStyle.Office2010 || StyleManager.IsMetro(effectiveStyle)) ? tab.DisplayRectangle.Y : tab.DisplayRectangle.Y - 4));
|
|
groupBounds = new Rectangle(tab.DisplayRectangle.X, y, tab.DisplayRectangle.Width, tab.DisplayRectangle.Bottom - (StyleManager.IsMetro(effectiveStyle) ? 1 : m_TabGroupHeight));
|
|
}
|
|
}
|
|
}
|
|
else if (currentGroup != null)
|
|
{
|
|
if (tab.Visible)
|
|
{
|
|
groupRect.Width += (tab.DisplayRectangle.Right - groupRect.Right);
|
|
groupBounds.Width += (tab.DisplayRectangle.Right - groupBounds.Right);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
groupRect = Rectangle.Empty;
|
|
groupBounds = Rectangle.Empty;
|
|
}
|
|
}
|
|
else if (currentGroup != null)
|
|
{
|
|
PaintGroup(pa, currentGroup, groupRect, groupBounds);
|
|
}
|
|
}
|
|
|
|
if (currentGroup != null)
|
|
PaintGroup(pa, currentGroup, groupRect, groupBounds);
|
|
}
|
|
|
|
private void PaintGroup(ItemPaintArgs pa, RibbonTabItemGroup group, Rectangle rect, Rectangle groupBounds)
|
|
{
|
|
if (m_CaptionVisible && !m_QuickToolbarBounds.IsEmpty && rect.IntersectsWith(m_QuickToolbarBounds) || m_SystemCaptionItemBounds.IntersectsWith(groupBounds))
|
|
return;
|
|
eDotNetBarStyle effectiveStyle = this.EffectiveStyle;
|
|
|
|
if (effectiveStyle == eDotNetBarStyle.Office2010 || StyleManager.IsMetro(effectiveStyle))
|
|
group.DisplayPositions.Add(new Rectangle(rect.X, rect.Y, rect.Width + 1, rect.Height));
|
|
else
|
|
group.DisplayPositions.Add(rect);
|
|
|
|
|
|
if (BarFunctions.IsOffice2007Style(effectiveStyle))
|
|
{
|
|
RibbonTabGroupRendererEventArgs e = new RibbonTabGroupRendererEventArgs(pa.Graphics, group, rect, groupBounds, this.GetDefaultGroupFont(), pa, effectiveStyle);
|
|
Rendering.BaseRenderer renderer = GetRenderer();
|
|
renderer.DrawRibbonTabGroup(e);
|
|
}
|
|
else
|
|
{
|
|
ElementStyleDisplayInfo info = new ElementStyleDisplayInfo(group.Style, pa.Graphics, rect);
|
|
ElementStyleDisplay.Paint(info);
|
|
ElementStyleDisplay.PaintText(info, group.GroupTitle, this.GetDefaultGroupFont());
|
|
}
|
|
}
|
|
|
|
private Font GetDefaultGroupFont()
|
|
{
|
|
if (m_DefaultGroupFont == null)
|
|
{
|
|
try
|
|
{
|
|
if (m_DefaultGroupFontAuto == null)
|
|
m_DefaultGroupFontAuto = new Font(this.Font.Name, this.Font.SizeInPoints - 1);
|
|
}
|
|
catch
|
|
{
|
|
return this.Font;
|
|
}
|
|
return m_DefaultGroupFontAuto;
|
|
}
|
|
return m_DefaultGroupFont;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets default font for tab groups. This font will be used if font is not specified by group style element.
|
|
/// </summary>
|
|
[Browsable(true), DevCoBrowsable(true), Category("Tab Groups"), DefaultValue(null)]
|
|
public Font DefaultGroupFont
|
|
{
|
|
get { return m_DefaultGroupFont; }
|
|
set
|
|
{
|
|
m_DefaultGroupFont = value;
|
|
if (this.DesignMode)
|
|
this.Refresh();
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Resets DefaultGroupFont property to default value null.
|
|
/// </summary>
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public void ResetDefaultGroupFont()
|
|
{
|
|
TypeDescriptor.GetProperties(this)["DefaultGroupFont"].SetValue(this, null);
|
|
}
|
|
|
|
protected override void OnFontChanged(EventArgs e)
|
|
{
|
|
base.OnFontChanged(e);
|
|
m_DefaultGroupFont = null;
|
|
}
|
|
|
|
protected override ElementStyle GetBackgroundStyle()
|
|
{
|
|
if (this.BackgroundStyle.Custom)
|
|
return base.GetBackgroundStyle();
|
|
return m_DefaultBackgroundStyle;
|
|
}
|
|
|
|
internal void InitDefaultStyles()
|
|
{
|
|
m_DefaultBackgroundStyle.SetColorScheme(this.GetColorScheme());
|
|
// Initialize Default Styles
|
|
if (this.Parent is RibbonControl)
|
|
RibbonPredefinedColorSchemes.ApplyRibbonElementStyle(m_DefaultBackgroundStyle, (RibbonControl)this.Parent);
|
|
}
|
|
|
|
internal ElementStyle InternalGetBackgroundStyle()
|
|
{
|
|
return this.GetBackgroundStyle();
|
|
}
|
|
|
|
internal Rectangle GetItemContainerBounds()
|
|
{
|
|
Rectangle r = base.GetItemContainerRectangle();
|
|
if (m_TabGroupsVisible)
|
|
{
|
|
r.Y += m_TabGroupHeight + 1;
|
|
}
|
|
if (m_CaptionVisible)
|
|
{
|
|
r.Y += GetAbsoluteCaptionHeight();
|
|
}
|
|
if (m_CaptionVisible && m_RibbonStripIndent > 0)
|
|
{
|
|
eDotNetBarStyle effectiveStyle = this.EffectiveStyle;
|
|
if (effectiveStyle != eDotNetBarStyle.Office2010 && effectiveStyle != eDotNetBarStyle.Windows7 && !StyleManager.IsMetro(effectiveStyle))
|
|
{
|
|
if (this.RightToLeft == RightToLeft.No)
|
|
r.X += m_RibbonStripIndent;
|
|
r.Width -= m_RibbonStripIndent;
|
|
}
|
|
}
|
|
return r;
|
|
}
|
|
|
|
internal Rectangle GetCaptionContainerBounds()
|
|
{
|
|
Rectangle baseRect = base.GetItemContainerRectangle();
|
|
if (this.IsGlassEnabled)
|
|
baseRect.Y += 3;
|
|
return new Rectangle(baseRect.X, baseRect.Y, baseRect.Width, GetAbsoluteCaptionHeight());
|
|
}
|
|
|
|
private int GetCaptionHeight()
|
|
{
|
|
if (m_CaptionHeight == 0)
|
|
{
|
|
//int captionHeight = (SystemInformation.CaptionHeight + SystemInformation.FrameBorderSize.Height * NativeFunctions.BorderMultiplierFactor) -
|
|
//(System.Environment.OSVersion.Version.Major < 6?14:12);
|
|
int captionHeight = 16; // System.Environment.OSVersion.Version.Major < 6 ? 13 : 16;
|
|
if (StyleManager.Style == eStyle.OfficeMobile2014)
|
|
captionHeight = 20;
|
|
if (this.IsGlassEnabled && EffectiveStyle != eDotNetBarStyle.Office2010 && EffectiveStyle != eDotNetBarStyle.Windows7 && !StyleManager.IsMetro(EffectiveStyle))
|
|
captionHeight += 0;
|
|
else if (!this.IsGlassEnabled && EffectiveStyle == eDotNetBarStyle.Office2010)
|
|
captionHeight -= 2;
|
|
else if (!this.IsGlassEnabled && EffectiveStyle == eDotNetBarStyle.Windows7)
|
|
captionHeight -= 2;
|
|
else if (!this.IsGlassEnabled && StyleManager.IsMetro(EffectiveStyle))
|
|
captionHeight -= 2;
|
|
|
|
return captionHeight;
|
|
}
|
|
else
|
|
{
|
|
return m_CaptionHeight;
|
|
}
|
|
}
|
|
|
|
internal int GetAbsoluteCaptionHeight()
|
|
{
|
|
return Dpi.Height((GetCaptionHeight() + (!m_TabGroupsVisible ? m_TabGroupHeight : 0))) + Dpi.CaptionVerticalPadding;
|
|
}
|
|
|
|
internal int GetTotalCaptionHeight()
|
|
{
|
|
return Dpi.Height((GetCaptionHeight() + m_TabGroupHeight + ((this.EffectiveStyle == eDotNetBarStyle.Office2010 || this.EffectiveStyle == eDotNetBarStyle.Windows7 || StyleManager.IsMetro(this.EffectiveStyle)) ? 0 : 0)));
|
|
}
|
|
|
|
internal int GetGlassCaptionHeight()
|
|
{
|
|
if (this.EffectiveStyle == eDotNetBarStyle.Office2010 || StyleManager.IsMetro(this.EffectiveStyle))
|
|
return this.Height;
|
|
else
|
|
return GetTotalCaptionHeight();
|
|
}
|
|
|
|
protected override void OnPaint(PaintEventArgs e)
|
|
{
|
|
InitDefaultStyles();
|
|
base.OnPaint(e);
|
|
}
|
|
|
|
protected override void RecalcSize()
|
|
{
|
|
InitDefaultStyles();
|
|
base.RecalcSize();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether control is collapsed when RibbonTabItem is double clicked and expanded when RibbonTabItem is clicked.
|
|
/// </summary>
|
|
internal bool AutoExpand
|
|
{
|
|
get { return m_AutoExpand; }
|
|
set { m_AutoExpand = value; }
|
|
}
|
|
|
|
private bool m_AutoKeyboardExpand = true;
|
|
/// <summary>
|
|
/// Gets or sets whether control is collapsed when RibbonTabItem is double clicked and expanded when RibbonTabItem is clicked.
|
|
/// </summary>
|
|
internal bool AutoKeyboardExpand
|
|
{
|
|
get { return m_AutoKeyboardExpand; }
|
|
set { m_AutoKeyboardExpand = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns automatically calculated height of the control given current content.
|
|
/// </summary>
|
|
/// <returns>Height in pixels.</returns>
|
|
public override int GetAutoSizeHeight()
|
|
{
|
|
int i = base.GetAutoSizeHeight();
|
|
//if (m_TabGroupsVisible)
|
|
// i += m_TabGroupHeight + 1;
|
|
//if (m_CaptionVisible)
|
|
// i += m_CaptionHeight;
|
|
if (BarFunctions.IsOffice2007Style(this.EffectiveStyle))
|
|
{
|
|
Rendering.BaseRenderer renderer = GetRenderer();
|
|
if (renderer is Rendering.Office2007Renderer)
|
|
i += ((Rendering.Office2007Renderer)renderer).ColorTable.RibbonControl.CornerSize;
|
|
}
|
|
|
|
return i;
|
|
}
|
|
|
|
protected override bool OnMouseWheel(IntPtr hWnd, IntPtr wParam, IntPtr lParam)
|
|
{
|
|
Rectangle r = this.DisplayRectangle;
|
|
r.Location = this.PointToScreen(r.Location);
|
|
|
|
RibbonControl rc = this.Parent as RibbonControl;
|
|
|
|
if (this.Parent is RibbonControl)
|
|
{
|
|
r = this.Parent.DisplayRectangle;
|
|
r.Location = this.Parent.PointToScreen(r.Location);
|
|
if (rc.SelectedRibbonTabItem != null && rc.SelectedRibbonTabItem.Panel is IKeyTipsControl && ((IKeyTipsControl)rc.SelectedRibbonTabItem.Panel).ShowKeyTips)
|
|
return false;
|
|
}
|
|
|
|
if (rc != null && !rc.MouseWheelTabScrollEnabled) return false;
|
|
|
|
Point mousePos = Control.MousePosition;
|
|
bool expanded = true;
|
|
if (rc != null) expanded = rc.Expanded;
|
|
|
|
bool parentActive = true;
|
|
Form parentForm = this.FindForm();
|
|
if (parentForm != null && !BarFunctions.IsFormActive(parentForm))
|
|
parentActive = false;
|
|
|
|
if (parentActive && r.Contains(mousePos) && !this.ShowKeyTips && expanded && this.Items.Count > 0)
|
|
{
|
|
IntPtr handle = NativeFunctions.WindowFromPoint(new NativeFunctions.POINT(mousePos));
|
|
Control c = Control.FromChildHandle(handle);
|
|
if (c == null)
|
|
c = Control.FromHandle(handle);
|
|
if (c is RibbonBar || c is RibbonStrip || c is RibbonControl || c is RibbonPanel)
|
|
{
|
|
RibbonTabItem selectedTab = this.SelectedRibbonTabItem;
|
|
int start = 0;
|
|
int end = this.Items.Count - 1;
|
|
|
|
int direction = 1;
|
|
if ((wParam.ToInt64() & 0x80000000) > 0)
|
|
{
|
|
direction = -1;
|
|
end = 0;
|
|
}
|
|
if (selectedTab != null)
|
|
{
|
|
start = this.Items.IndexOf(selectedTab) + direction;
|
|
if (direction < 0 && start < 0) return false;
|
|
|
|
if (start == this.Items.Count)
|
|
start = 0;
|
|
else if (start < 0)
|
|
start = this.Items.Count - 1;
|
|
}
|
|
|
|
int index = start - direction;
|
|
do
|
|
{
|
|
index += direction;
|
|
if (index < 0 || index > this.Items.Count - 1) break;
|
|
|
|
if (this.Items[index] is RibbonTabItem && this.Items[index].Visible && this.Items[index].Enabled)
|
|
{
|
|
((RibbonTabItem)this.Items[index]).Checked = true;
|
|
return true;
|
|
}
|
|
} while (index != end);
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private ArrayList GetAllRibbonBars()
|
|
{
|
|
ArrayList list = new ArrayList();
|
|
if (!(this.Parent is RibbonControl))
|
|
return list;
|
|
|
|
foreach (Control c in this.Parent.Controls)
|
|
{
|
|
GetAllRibbonBars(c, list);
|
|
}
|
|
|
|
RibbonControl rc = this.Parent as RibbonControl;
|
|
if (!rc.Expanded && this.SelectedRibbonTabItem != null && this.SelectedRibbonTabItem.Panel != null && this.SelectedRibbonTabItem.Panel.Parent != rc)
|
|
{
|
|
GetAllRibbonBars(this.SelectedRibbonTabItem.Panel, list);
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
private void GetAllRibbonBars(Control c, ArrayList list)
|
|
{
|
|
if (c is RibbonBar)
|
|
list.Add(c);
|
|
|
|
foreach (Control child in c.Controls)
|
|
GetAllRibbonBars(child, list);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the collection of items with the specified name.
|
|
/// </summary>
|
|
/// <param name="ItemName">Item name to look for.</param>
|
|
/// <returns></returns>
|
|
public override ArrayList GetItems(string ItemName)
|
|
{
|
|
ArrayList list = new ArrayList(15);
|
|
BarFunctions.GetSubItemsByName(GetBaseItemContainer(), ItemName, list);
|
|
|
|
RibbonControl rc = this.GetRibbonControl();
|
|
if (rc != null && rc.QatPositionedBelowRibbon)
|
|
{
|
|
BarFunctions.GetSubItemsByName(rc.QatToolbar.GetBaseItemContainer(), ItemName, list);
|
|
}
|
|
|
|
ArrayList ribbonBars = GetAllRibbonBars();
|
|
foreach (RibbonBar b in ribbonBars)
|
|
BarFunctions.GetSubItemsByName(b.GetBaseItemContainer(), ItemName, list);
|
|
|
|
if (rc != null && rc.GlobalContextMenuBar != null)
|
|
BarFunctions.GetSubItemsByName(rc.GlobalContextMenuBar.ItemsContainer, ItemName, list);
|
|
|
|
return list;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the collection of items with the specified name and type.
|
|
/// </summary>
|
|
/// <param name="ItemName">Item name to look for.</param>
|
|
/// <param name="itemType">Item type to look for.</param>
|
|
/// <returns></returns>
|
|
public override ArrayList GetItems(string ItemName, Type itemType)
|
|
{
|
|
ArrayList list = new ArrayList(15);
|
|
BarFunctions.GetSubItemsByNameAndType(GetBaseItemContainer(), ItemName, list, itemType);
|
|
|
|
RibbonControl rc = this.GetRibbonControl();
|
|
if (rc != null && rc.QatPositionedBelowRibbon)
|
|
{
|
|
BarFunctions.GetSubItemsByNameAndType(rc.QatToolbar.GetBaseItemContainer(), ItemName, list, itemType);
|
|
}
|
|
|
|
ArrayList ribbonBars = GetAllRibbonBars();
|
|
foreach (RibbonBar b in ribbonBars)
|
|
BarFunctions.GetSubItemsByNameAndType(b.GetBaseItemContainer(), ItemName, list, itemType);
|
|
|
|
if (rc != null && rc.GlobalContextMenuBar != null)
|
|
BarFunctions.GetSubItemsByNameAndType(rc.GlobalContextMenuBar.ItemsContainer, ItemName, list, itemType);
|
|
|
|
return list;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the collection of items with the specified name and type.
|
|
/// </summary>
|
|
/// <param name="ItemName">Item name to look for.</param>
|
|
/// <param name="itemType">Item type to look for.</param>
|
|
/// <param name="useGlobalName">Indicates whether GlobalName property is used for searching.</param>
|
|
/// <returns></returns>
|
|
public override ArrayList GetItems(string ItemName, Type itemType, bool useGlobalName)
|
|
{
|
|
ArrayList list = new ArrayList(15);
|
|
BarFunctions.GetSubItemsByNameAndType(GetBaseItemContainer(), ItemName, list, itemType, useGlobalName);
|
|
|
|
RibbonControl rc = this.GetRibbonControl();
|
|
if (rc != null && rc.QatPositionedBelowRibbon)
|
|
{
|
|
BarFunctions.GetSubItemsByNameAndType(rc.QatToolbar.GetBaseItemContainer(), ItemName, list, itemType, useGlobalName);
|
|
}
|
|
|
|
ArrayList ribbonBars = GetAllRibbonBars();
|
|
foreach (RibbonBar b in ribbonBars)
|
|
BarFunctions.GetSubItemsByNameAndType(b.GetBaseItemContainer(), ItemName, list, itemType, useGlobalName);
|
|
|
|
if (rc != null && rc.GlobalContextMenuBar != null)
|
|
BarFunctions.GetSubItemsByNameAndType(rc.GlobalContextMenuBar.ItemsContainer, ItemName, list, itemType, useGlobalName);
|
|
|
|
return list;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the first item that matches specified name.
|
|
/// </summary>
|
|
/// <param name="ItemName">Item name to look for.</param>
|
|
/// <returns></returns>
|
|
public override BaseItem GetItem(string ItemName)
|
|
{
|
|
BaseItem item = BarFunctions.GetSubItemByName(GetBaseItemContainer(), ItemName);
|
|
if (item != null)
|
|
return item;
|
|
|
|
RibbonControl rc = this.GetRibbonControl();
|
|
if (rc != null && rc.QatPositionedBelowRibbon)
|
|
{
|
|
item = BarFunctions.GetSubItemByName(rc.QatToolbar.GetBaseItemContainer(), ItemName);
|
|
if (item != null)
|
|
return item;
|
|
}
|
|
|
|
ArrayList ribbonBars = GetAllRibbonBars();
|
|
foreach (RibbonBar b in ribbonBars)
|
|
{
|
|
if (b.OverflowState && b.OverflowRibbonBar != null)
|
|
item = BarFunctions.GetSubItemByName(b.OverflowRibbonBar.GetBaseItemContainer(), ItemName);
|
|
else
|
|
item = BarFunctions.GetSubItemByName(b.GetBaseItemContainer(), ItemName);
|
|
if (item != null)
|
|
return item;
|
|
}
|
|
|
|
if (rc != null && rc.GlobalContextMenuBar != null)
|
|
return BarFunctions.GetSubItemByName(rc.GlobalContextMenuBar.ItemsContainer, ItemName);
|
|
|
|
return null;
|
|
}
|
|
#endregion
|
|
|
|
#region KeyTips Support
|
|
private bool m_AltFocus = false;
|
|
private IKeyTipsControl m_AltFocusedControl = null;
|
|
|
|
/// <summary>
|
|
/// Called when ShowKeyTips on RibbonBar contained by this Ribbon is set to true
|
|
/// </summary>
|
|
internal void OnRibbonBarShowKeyTips(RibbonBar bar)
|
|
{
|
|
if (!m_AltFocus)
|
|
{
|
|
m_AltFocus = true;
|
|
}
|
|
|
|
if (m_AltFocusedControl != bar.Parent && bar.Parent is RibbonPanel)
|
|
{
|
|
if (m_AltFocusedControl != null)
|
|
m_AltFocusedControl.ShowKeyTips = false;
|
|
m_AltFocusedControl = bar.Parent as IKeyTipsControl;
|
|
if (m_AltFocusedControl != null)
|
|
m_AltFocusedControl.ShowKeyTips = true;
|
|
}
|
|
}
|
|
|
|
protected override void OnShowKeyTipsChanged()
|
|
{
|
|
//if (this.SelectedRibbonTabItem != null && this.SelectedRibbonTabItem.Panel != null)
|
|
//{
|
|
// Control panel = this.SelectedRibbonTabItem.Panel;
|
|
// foreach (Control c in panel.Controls)
|
|
// {
|
|
// if (c is RibbonBar && c.Visible)
|
|
// {
|
|
// ((RibbonBar)c).ShowKeyTips = this.ShowKeyTips;
|
|
// }
|
|
// }
|
|
//}
|
|
RibbonControl rc = this.GetRibbonControl();
|
|
if (rc != null && rc.QatPositionedBelowRibbon)
|
|
rc.QatToolbar.ShowKeyTips = this.ShowKeyTips;
|
|
base.OnShowKeyTipsChanged();
|
|
|
|
if (this.ShowKeyTips && !m_AltFocus)
|
|
GiveKeyTipsAltFocus();
|
|
}
|
|
|
|
internal void BackstageTabClosed(SuperTabControl tabControl)
|
|
{
|
|
if (m_AltFocusedControl == tabControl || m_AltFocusedControl == tabControl.TabStrip)
|
|
m_AltFocusedControl = null;
|
|
}
|
|
|
|
protected override bool OnKeyDown(IntPtr hWnd, IntPtr wParam, IntPtr lParam)
|
|
{
|
|
|
|
int wParamInt = WinApi.ToInt(wParam);
|
|
if (wParamInt == 27)
|
|
{
|
|
RibbonControl rc = this.GetRibbonControl();
|
|
if (rc != null)
|
|
rc.OnEscapeKeyDown();
|
|
}
|
|
|
|
if (m_AltFocus)
|
|
{
|
|
if (HasRegisteredPopups)
|
|
{
|
|
bool ret = base.OnKeyDown(hWnd, wParam, lParam);
|
|
if (!HasRegisteredPopups) ReleaseAltFocus();
|
|
}
|
|
Keys key = (Keys)NativeFunctions.MapVirtualKey((uint)wParam, 2);
|
|
if (key == Keys.None)
|
|
key = (Keys)wParamInt;
|
|
|
|
if (key == Keys.Escape)
|
|
{
|
|
bool reShowKeyTips = false;
|
|
if (!this.ShowKeyTips && m_AltFocusedControl != null)
|
|
{
|
|
if (m_AltFocusedControl is RibbonPanel)
|
|
reShowKeyTips = true;
|
|
}
|
|
|
|
ReleaseAltFocus();
|
|
|
|
if (reShowKeyTips)
|
|
{
|
|
GiveKeyTipsAltFocus();
|
|
}
|
|
|
|
return base.OnKeyDown(hWnd, wParam, lParam);
|
|
}
|
|
|
|
char accessKey = CharFromInt((int)key);
|
|
if (accessKey == char.MinValue)
|
|
{
|
|
ReleaseAltFocus();
|
|
return true;
|
|
}
|
|
else if (key == Keys.Space || key == Keys.Down || key == Keys.Right || key == Keys.Tab)
|
|
{
|
|
ReleaseAltFocus();
|
|
return false;
|
|
}
|
|
|
|
//if (m_AltFocusedControl != null && m_AltFocusedControl.ProcessMnemonicEx(accessKey))
|
|
//{
|
|
// ReleaseAltFocus();
|
|
// return true;
|
|
//}
|
|
//else
|
|
if (this.ProcessMnemonic(accessKey))
|
|
return true;
|
|
|
|
return true;
|
|
}
|
|
else if (wParamInt == 112 && Control.ModifierKeys == Keys.Control)
|
|
{
|
|
Form frm = this.FindForm();
|
|
if (BarFunctions.IsFormActive(frm))
|
|
{
|
|
// Collapse ribbon
|
|
RibbonControl rc = this.GetRibbonControl();
|
|
if (rc.AutoKeyboardExpand)
|
|
rc.Expanded = !rc.Expanded;
|
|
}
|
|
}
|
|
|
|
return base.OnKeyDown(hWnd, wParam, lParam);
|
|
}
|
|
|
|
private char CharFromInt(int key)
|
|
{
|
|
char[] ch = new char[1];
|
|
byte[] by = new byte[1];
|
|
try
|
|
{
|
|
by[0] = System.Convert.ToByte(key);
|
|
System.Text.Encoding.Default.GetDecoder().GetChars(by, 0, 1, ch, 0);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
return char.MinValue;
|
|
}
|
|
|
|
return ch[0];
|
|
}
|
|
|
|
private bool _IgnoreF10Key = false;
|
|
/// <summary>
|
|
/// Gets or sets whether F10 key is ignored as way to set KeyTips focus to Ribbon.
|
|
/// </summary>
|
|
[DefaultValue(false), Browsable(false)]
|
|
public bool IgnoreF10Key
|
|
{
|
|
get { return _IgnoreF10Key; }
|
|
set
|
|
{
|
|
_IgnoreF10Key = value;
|
|
}
|
|
}
|
|
|
|
protected override bool OnSysKeyUp(IntPtr hWnd, IntPtr wParam, IntPtr lParam)
|
|
{
|
|
int wParamInt = WinApi.ToInt(wParam);
|
|
if (wParamInt == 18 || wParamInt == 121 && !_IgnoreF10Key)
|
|
{
|
|
bool callBase = true;
|
|
if (m_AltFocus)
|
|
{
|
|
if (wParamInt == 18 || wParamInt == 121 && !_IgnoreF10Key)
|
|
callBase = false;
|
|
ReleaseAltFocus();
|
|
}
|
|
else
|
|
{
|
|
Form f = this.FindForm();
|
|
if (f == Form.ActiveForm)
|
|
{
|
|
callBase = false;
|
|
ActivateKeyTips();
|
|
}
|
|
}
|
|
if (!callBase)
|
|
return true;
|
|
}
|
|
return base.OnSysKeyUp(hWnd, wParam, lParam);
|
|
}
|
|
internal bool IsBackstageOpen
|
|
{
|
|
get
|
|
{
|
|
ApplicationButton appButton = GetApplicationButton() as ApplicationButton;
|
|
if (appButton != null && appButton.BackstageTab != null && appButton.Expanded && appButton.BackstageTabEnabled)
|
|
return true;
|
|
return false;
|
|
}
|
|
}
|
|
private void ActivateKeyTips()
|
|
{
|
|
ApplicationButton appButton = GetApplicationButton() as ApplicationButton;
|
|
|
|
if (appButton != null && appButton.BackstageTab != null && appButton.Expanded)
|
|
{
|
|
if (m_AltFocusedControl != null)
|
|
m_AltFocusedControl.ShowKeyTips = false;
|
|
m_AltFocusedControl = appButton.BackstageTab.TabStrip;
|
|
if (!m_AltFocusedControl.ShowKeyTips)
|
|
m_AltFocusedControl.ShowKeyTips = true;
|
|
}
|
|
else
|
|
GiveKeyTipsAltFocus();
|
|
}
|
|
|
|
private void GiveKeyTipsAltFocus()
|
|
{
|
|
if (!m_KeyTipsEnabled) return;
|
|
|
|
m_AltFocus = true;
|
|
this.ShowKeyTips = true;
|
|
SetupActiveWindowTimer();
|
|
}
|
|
|
|
private void ReleaseAltFocus()
|
|
{
|
|
if (m_AltFocus)
|
|
{
|
|
ReleaseActiveWindowTimer();
|
|
if (!this.ShowKeyTips && m_AltFocusedControl != null)
|
|
{
|
|
m_AltFocusedControl.ShowKeyTips = false;
|
|
m_AltFocusedControl = null;
|
|
}
|
|
this.ShowKeyTips = false;
|
|
}
|
|
|
|
m_AltFocus = false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets whether Ribbon is in key-tips mode including its child controls.
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
public bool IsInKeyTipsMode
|
|
{
|
|
get
|
|
{
|
|
return m_AltFocus | this.ShowKeyTips;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Forces the control to exit Ribbon Key-Tips mode.
|
|
/// </summary>
|
|
public void ExitKeyTipsMode()
|
|
{
|
|
ReleaseAltFocus();
|
|
}
|
|
|
|
internal void OnChildItemClick(BaseItem item)
|
|
{
|
|
if (this.ShowKeyTips || m_AltFocusedControl != null && m_AltFocusedControl.ShowKeyTips)
|
|
{
|
|
this.ShowKeyTips = false;
|
|
ReleaseAltFocus();
|
|
}
|
|
}
|
|
|
|
protected override bool OnSysMouseDown(IntPtr hWnd, IntPtr wParam, IntPtr lParam)
|
|
{
|
|
if (this.ShowKeyTips || m_AltFocusedControl != null && m_AltFocusedControl.ShowKeyTips)
|
|
{
|
|
this.ShowKeyTips = false;
|
|
ReleaseAltFocus();
|
|
}
|
|
|
|
RibbonControl rc = this.GetRibbonControl();
|
|
if (rc != null) rc.OnSysMouseDown(hWnd, wParam, lParam);
|
|
|
|
return base.OnSysMouseDown(hWnd, wParam, lParam);
|
|
}
|
|
|
|
protected override bool ProcessMnemonic(char charCode)
|
|
{
|
|
if (m_AltFocusedControl != null)
|
|
{
|
|
if (m_AltFocusedControl.ProcessMnemonicEx(charCode))
|
|
{
|
|
ReleaseAltFocus();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
if (!m_AltFocus && (Control.ModifierKeys & Keys.Alt) != Keys.Alt)
|
|
return false;
|
|
return base.ProcessMnemonic(charCode);
|
|
}
|
|
|
|
public override bool ProcessMnemonicEx(char charCode)
|
|
{
|
|
// If different ribbon tab item is selected we should not exit the Alt mode...
|
|
BaseItem item = null;
|
|
|
|
if (m_CaptionVisible)
|
|
{
|
|
item = GetItemForMnemonic(m_StripContainer.CaptionContainer, charCode, false, true);
|
|
if (item != null)
|
|
{
|
|
if (ProcessItemMnemonicKey(item))
|
|
{
|
|
ReleaseAltFocus();
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
RibbonControl rc = this.GetRibbonControl();
|
|
if (rc != null && rc.QatPositionedBelowRibbon)
|
|
{
|
|
if (rc.QatToolbar.ProcessMnemonicEx(charCode))
|
|
{
|
|
ReleaseAltFocus();
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (item == null)
|
|
{
|
|
item = GetItemForMnemonic(this.GetBaseItemContainer(), charCode, true, true);
|
|
}
|
|
|
|
if (item is RibbonTabItem && item.Visible)
|
|
{
|
|
if (!m_AltFocus)
|
|
{
|
|
GiveKeyTipsAltFocus();
|
|
}
|
|
this.ShowKeyTips = false;
|
|
if (item != this.SelectedRibbonTabItem)
|
|
{
|
|
// Switch the tab
|
|
item.RaiseClick();
|
|
//this.ShowKeyTips = true;
|
|
}
|
|
else if (this.SelectedRibbonTabItem != null && rc != null && !rc.Expanded && !rc.IsPopupMode)
|
|
rc.RibbonTabItemClick(this.SelectedRibbonTabItem);
|
|
if (this.SelectedRibbonTabItem != null && m_KeyTipsEnabled)
|
|
{
|
|
if (m_AltFocusedControl != null)
|
|
m_AltFocusedControl.ShowKeyTips = false;
|
|
m_AltFocusedControl = this.SelectedRibbonTabItem.Panel;
|
|
if (m_AltFocusedControl != null)
|
|
m_AltFocusedControl.ShowKeyTips = true;
|
|
}
|
|
|
|
// Keep the Alt focus
|
|
return true;
|
|
}
|
|
else if (item != null && ProcessItemMnemonicKey(item))
|
|
{
|
|
this.ShowKeyTips = false;
|
|
if (item is ApplicationButton)
|
|
{
|
|
ApplicationButton appButton = (ApplicationButton)item;
|
|
if (appButton.BackstageTab != null)
|
|
{
|
|
if (m_AltFocusedControl != null)
|
|
m_AltFocusedControl.ShowKeyTips = false;
|
|
m_AltFocusedControl = appButton.BackstageTab.TabStrip;
|
|
if (!m_AltFocusedControl.ShowKeyTips)
|
|
m_AltFocusedControl.ShowKeyTips = true;
|
|
}
|
|
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//if (base.ProcessMnemonicEx(charCode))
|
|
//{
|
|
// ReleaseAltFocus();
|
|
// return true;
|
|
//}
|
|
|
|
if (m_AltFocus && this.SelectedRibbonTabItem != null && this.SelectedRibbonTabItem.Panel != null)
|
|
{
|
|
Control panel = this.SelectedRibbonTabItem.Panel;
|
|
foreach (Control c in panel.Controls)
|
|
{
|
|
if (c is RibbonBar && c.Visible)
|
|
{
|
|
if (IsMnemonic(charCode, c.Text))
|
|
{
|
|
// Select RibbonBar for Alt+ Key access
|
|
this.ShowKeyTips = false;
|
|
((RibbonBar)c).ShowKeyTips = true;
|
|
if (m_AltFocusedControl != null)
|
|
m_AltFocusedControl.ShowKeyTips = false;
|
|
m_AltFocusedControl = (IKeyTipsControl)c;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected override void OnActiveWindowChanged()
|
|
{
|
|
ReleaseAltFocus();
|
|
base.OnActiveWindowChanged();
|
|
}
|
|
|
|
protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
|
|
{
|
|
return base.ProcessCmdKey(ref msg, keyData);
|
|
}
|
|
|
|
protected override bool ProcessDialogKey(Keys keyData)
|
|
{
|
|
return base.ProcessDialogKey(keyData);
|
|
}
|
|
#endregion
|
|
|
|
#region Caption Container Support
|
|
/// <summary>
|
|
/// Called when item on popup container is right-clicked.
|
|
/// </summary>
|
|
/// <param name="item">Instance of the item that is right-clicked.</param>
|
|
protected override void OnPopupItemRightClick(BaseItem item)
|
|
{
|
|
RibbonControl rc = this.GetRibbonControl();
|
|
if (rc != null)
|
|
rc.ShowCustomizeContextMenu(item, false);
|
|
}
|
|
//private RibbonControl GetRibbonControl()
|
|
//{
|
|
// Control parent = this.Parent;
|
|
// while (parent != null && !(parent is RibbonControl))
|
|
// parent = parent.Parent;
|
|
// if (parent is RibbonControl)
|
|
// return parent as RibbonControl;
|
|
// return null;
|
|
//}
|
|
protected override void OnMouseLeave(EventArgs e)
|
|
{
|
|
if (m_TitleTextMarkup != null)
|
|
m_TitleTextMarkup.MouseLeave(this);
|
|
base.OnMouseLeave(e);
|
|
}
|
|
|
|
internal bool MouseDownOnCaption
|
|
{
|
|
get
|
|
{
|
|
return m_MouseDownOnCaption;
|
|
}
|
|
}
|
|
|
|
private bool m_MouseDownOnCaption = false;
|
|
protected override void OnMouseDown(MouseEventArgs e)
|
|
{
|
|
m_MouseDownOnCaption = false;
|
|
if (m_CaptionVisible)
|
|
{
|
|
m_MouseDownOnCaption = HitTestCaption(new Point(e.X, e.Y));
|
|
if (e.Button == MouseButtons.Right && m_MouseDownOnCaption)
|
|
{
|
|
Form form = this.FindForm();
|
|
if (form != null)
|
|
{
|
|
const int TPM_RETURNCMD = 0x0100;
|
|
Point p = Control.MousePosition;
|
|
byte[] bx = BitConverter.GetBytes(p.X);
|
|
byte[] by = BitConverter.GetBytes(p.Y);
|
|
byte[] blp = new byte[] { bx[0], bx[1], by[0], by[1] };
|
|
int lParam = BitConverter.ToInt32(blp, 0);
|
|
this.Capture = false;
|
|
NativeFunctions.SendMessage(form.Handle, NativeFunctions.WM_SYSCOMMAND, NativeFunctions.TrackPopupMenu(
|
|
NativeFunctions.GetSystemMenu(form.Handle, false), TPM_RETURNCMD, Control.MousePosition.X, Control.MousePosition.Y, 0, form.Handle, IntPtr.Zero), lParam);
|
|
BarUtilities.InvokeDelayed(new MethodInvoker(delegate { m_MouseDownOnCaption = false; }), 500);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (m_TitleTextMarkup != null)
|
|
m_TitleTextMarkup.MouseDown(this, e);
|
|
|
|
e = TranslateMouseEventArgs(e);
|
|
}
|
|
|
|
if (e.Button == MouseButtons.Right && this.QuickToolbarBounds.Contains(e.X, e.Y))
|
|
{
|
|
RibbonControl rc = this.GetRibbonControl();
|
|
if (rc != null)
|
|
rc.OnRibbonStripRightClick(this, e.X, e.Y);
|
|
}
|
|
else if (e.Button == MouseButtons.Left && m_CaptionVisible && m_TabGroupsVisible && !m_StripContainer.RibbonStripContainer.DisplayRectangle.Contains(e.X, e.Y))
|
|
{
|
|
foreach (RibbonTabItemGroup group in this.TabGroups)
|
|
{
|
|
if (!group.Visible) continue;
|
|
foreach (Rectangle r in group.DisplayPositions)
|
|
{
|
|
if (r.Contains(e.X, e.Y))
|
|
{
|
|
if (!group.IsTabFromGroupSelected)
|
|
{
|
|
group.SelectFirstTab();
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
base.OnMouseDown(e);
|
|
}
|
|
|
|
private RibbonTabItemGroup HitTestTabItemGroup(Point p)
|
|
{
|
|
if (m_CaptionVisible && m_TabGroupsVisible && !m_StripContainer.RibbonStripContainer.DisplayRectangle.Contains(p.X, p.Y))
|
|
{
|
|
foreach (RibbonTabItemGroup group in this.TabGroups)
|
|
{
|
|
if (!group.Visible) continue;
|
|
foreach (Rectangle r in group.DisplayPositions)
|
|
{
|
|
if (r.Contains(p.X, p.Y))
|
|
{
|
|
return group;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
protected override void OnMouseUp(MouseEventArgs e)
|
|
{
|
|
if (m_CaptionVisible)
|
|
{
|
|
if (m_TitleTextMarkup != null)
|
|
m_TitleTextMarkup.MouseUp(this, e);
|
|
|
|
e = TranslateMouseEventArgs(e);
|
|
}
|
|
m_MouseDownOnCaption = false;
|
|
base.OnMouseUp(e);
|
|
}
|
|
|
|
internal BaseItem GetApplicationButton()
|
|
{
|
|
if (!this.CaptionVisible)
|
|
return null;
|
|
BaseItem cont = this.CaptionContainerItem;
|
|
|
|
if ((this.EffectiveStyle == eDotNetBarStyle.Office2010 || StyleManager.IsMetro(this.EffectiveStyle)) && this.Items.Count > 0)
|
|
{
|
|
foreach (BaseItem item in this.Items)
|
|
{
|
|
if (item is ApplicationButton) return item;
|
|
}
|
|
//return this.Items[0];
|
|
}
|
|
|
|
if (cont.SubItems.Count > 0 && cont.SubItems[0] is ApplicationButton)
|
|
return cont.SubItems[0];
|
|
|
|
if (cont.SubItems.Count > 0 && cont.SubItems[0] is ButtonItem && ((ButtonItem)cont.SubItems[0]).HotTrackingStyle == eHotTrackingStyle.Image)
|
|
return cont.SubItems[0];
|
|
|
|
return null;
|
|
}
|
|
|
|
protected override void OnMouseMove(MouseEventArgs e)
|
|
{
|
|
if (m_CaptionVisible)
|
|
{
|
|
if (e.Button == MouseButtons.Left && m_MouseDownOnCaption && HitTestCaption(new Point(e.X, e.Y)))
|
|
{
|
|
Form form = this.FindForm();
|
|
if (form != null && (form.WindowState == FormWindowState.Normal || BarFunctions.IsWindows7))
|
|
{
|
|
PopupItem popup = GetApplicationButton() as PopupItem;
|
|
if (popup != null && popup.Expanded) popup.Expanded = false;
|
|
const int HTCAPTION = 2;
|
|
Point p = Control.MousePosition;
|
|
byte[] bx = BitConverter.GetBytes(p.X);
|
|
byte[] by = BitConverter.GetBytes(p.Y);
|
|
byte[] blp = new byte[] { bx[0], bx[1], by[0], by[1] };
|
|
int lParam = BitConverter.ToInt32(blp, 0);
|
|
this.Capture = false;
|
|
NativeFunctions.SendMessage(form.Handle, NativeFunctions.WM_SYSCOMMAND, NativeFunctions.SC_MOVE + HTCAPTION, lParam);
|
|
m_MouseDownOnCaption = false;
|
|
return;
|
|
}
|
|
}
|
|
if (m_TitleTextMarkup != null)
|
|
m_TitleTextMarkup.MouseMove(this, e);
|
|
e = TranslateMouseEventArgs(e);
|
|
}
|
|
base.OnMouseMove(e);
|
|
}
|
|
|
|
protected override void InternalOnClick(MouseButtons mb, Point mousePos)
|
|
{
|
|
if (m_CaptionVisible)
|
|
{
|
|
MouseEventArgs e = new MouseEventArgs(mb, 0, mousePos.X, mousePos.Y, 0);
|
|
e = TranslateMouseEventArgs(e);
|
|
mousePos = new Point(e.X, e.Y);
|
|
}
|
|
|
|
base.InternalOnClick(mb, mousePos);
|
|
}
|
|
|
|
private MouseEventArgs TranslateMouseEventArgs(MouseEventArgs e)
|
|
{
|
|
if (e.Y <= 6)
|
|
{
|
|
Form form = this.FindForm();
|
|
if (form != null && form.WindowState == FormWindowState.Maximized && form is RibbonForm)
|
|
{
|
|
if (e.X <= 4)
|
|
{
|
|
BaseItem sb = GetApplicationButton();
|
|
if (sb != null)
|
|
{
|
|
e = new MouseEventArgs(e.Button, e.Clicks, sb.LeftInternal + 1, sb.TopInternal + 1, e.Delta);
|
|
}
|
|
}
|
|
else if (e.X >= this.Width - 6)
|
|
e = new MouseEventArgs(e.Button, e.Clicks, this.SystemCaptionItem.DisplayRectangle.Right - 4, this.SystemCaptionItem.DisplayRectangle.Top + 4, e.Delta);
|
|
else
|
|
e = new MouseEventArgs(e.Button, e.Clicks, e.X, this.CaptionContainerItem.TopInternal + 5, e.Delta);
|
|
}
|
|
}
|
|
return e;
|
|
}
|
|
|
|
//protected override void OnMouseUp(MouseEventArgs e)
|
|
//{
|
|
// base.OnMouseUp(e);
|
|
// if (m_CaptionVisible) m_CaptionContainer.InternalMouseUp(e);
|
|
//}
|
|
|
|
//protected override void OnClick(EventArgs e)
|
|
//{
|
|
// if (m_CaptionVisible) m_CaptionContainer.InternalClick(MouseButtons, MousePosition);
|
|
// base.OnClick(e);
|
|
//}
|
|
|
|
protected override void OnClick(EventArgs e)
|
|
{
|
|
if (m_CaptionVisible)
|
|
{
|
|
if (m_TitleTextMarkup != null)
|
|
m_TitleTextMarkup.Click(this);
|
|
}
|
|
base.OnClick(e);
|
|
}
|
|
|
|
protected override void OnDoubleClick(EventArgs e)
|
|
{
|
|
if (m_CaptionVisible)
|
|
{
|
|
// Check whether double click is on caption so window can be maximized/restored
|
|
Point p = this.PointToClient(Control.MousePosition);
|
|
if (HitTestCaption(p))
|
|
{
|
|
Form form = this.FindForm();
|
|
if (form != null && form.MaximizeBox && (form.FormBorderStyle == FormBorderStyle.Sizable || form.FormBorderStyle == FormBorderStyle.SizableToolWindow))
|
|
{
|
|
if (form.WindowState == FormWindowState.Normal)
|
|
{
|
|
NativeFunctions.PostMessage(form.Handle, NativeFunctions.WM_SYSCOMMAND, NativeFunctions.SC_MAXIMIZE, 0);
|
|
}
|
|
else if (form.WindowState == FormWindowState.Maximized)
|
|
{
|
|
NativeFunctions.PostMessage(form.Handle, NativeFunctions.WM_SYSCOMMAND, NativeFunctions.SC_RESTORE, 0);
|
|
}
|
|
}
|
|
}
|
|
//m_CaptionContainer.InternalDoubleClick(MouseButtons, MousePosition);
|
|
}
|
|
base.OnDoubleClick(e);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if point is inside the caption area.
|
|
/// </summary>
|
|
/// <param name="p">Client point coordinates.</param>
|
|
/// <returns>True if point is inside of caption area otherwise false.</returns>
|
|
protected bool HitTestCaption(Point p)
|
|
{
|
|
if (m_CaptionBounds.Contains(p) && m_CaptionTextBounds != null)
|
|
{
|
|
foreach (Rectangle r in m_CaptionTextBounds)
|
|
{
|
|
if (r.Contains(p))
|
|
return true;
|
|
}
|
|
}
|
|
if (BarFunctions.IsOffice2010Style(this.EffectiveStyle) && this.ClientRectangle.Contains(p))
|
|
{
|
|
if (HitTest(p.X, p.Y) == null && HitTestTabItemGroup(p) == null)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//protected override void PaintControl(ItemPaintArgs pa)
|
|
//{
|
|
// base.PaintControl(pa);
|
|
|
|
// if (m_CaptionContainer == null || this.IsDisposed || !m_CaptionVisible)
|
|
// return;
|
|
|
|
// m_CaptionContainer.Paint(pa);
|
|
//}
|
|
|
|
//protected override void RecalcSize()
|
|
//{
|
|
// base.RecalcSize();
|
|
|
|
// if (!BarFunctions.IsHandleValid(this) || IsUpdateSuspended || !m_CaptionVisible)
|
|
// return;
|
|
|
|
// m_CaptionContainer.LeftInternal = 0;
|
|
// m_CaptionContainer.TopInternal = 0;
|
|
// m_CaptionContainer.WidthInternal = this.Width;
|
|
// m_CaptionContainer.HeightInternal = m_CaptionHeight;
|
|
// m_CaptionContainer.RecalcSize();
|
|
//}
|
|
|
|
private void SystemCaptionClick(object sender, EventArgs e)
|
|
{
|
|
SystemCaptionItem sci = sender as SystemCaptionItem;
|
|
Form frm = this.FindForm();
|
|
|
|
if (frm == null)
|
|
return;
|
|
|
|
if (sci.LastButtonClick == sci.MouseDownButton)
|
|
{
|
|
if (sci.LastButtonClick == SystemButton.Minimize)
|
|
{
|
|
NativeFunctions.PostMessage(frm.Handle, NativeFunctions.WM_SYSCOMMAND, NativeFunctions.SC_MINIMIZE, 0);
|
|
}
|
|
else if (sci.LastButtonClick == SystemButton.Maximize)
|
|
{
|
|
NativeFunctions.PostMessage(frm.Handle, NativeFunctions.WM_SYSCOMMAND, NativeFunctions.SC_MAXIMIZE, 0);
|
|
}
|
|
else if (sci.LastButtonClick == SystemButton.Restore)
|
|
{
|
|
NativeFunctions.PostMessage(frm.Handle, NativeFunctions.WM_SYSCOMMAND, NativeFunctions.SC_RESTORE, 0);
|
|
}
|
|
else if (sci.LastButtonClick == SystemButton.Close)
|
|
{
|
|
NativeFunctions.PostMessage(frm.Handle, NativeFunctions.WM_SYSCOMMAND, NativeFunctions.SC_CLOSE, 0);
|
|
}
|
|
else if (sci.LastButtonClick == SystemButton.Help)
|
|
{
|
|
NativeFunctions.PostMessage(frm.Handle, NativeFunctions.WM_SYSCOMMAND, NativeFunctions.SC_CONTEXTHELP, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected override void OnResize(EventArgs e)
|
|
{
|
|
base.OnResize(e);
|
|
if (!m_CaptionVisible)
|
|
return;
|
|
|
|
Form frm = this.FindForm();
|
|
if (frm == null)
|
|
return;
|
|
|
|
if (frm.WindowState == FormWindowState.Maximized || frm.WindowState == FormWindowState.Minimized)
|
|
m_StripContainer.SystemCaptionItem.RestoreEnabled = true;
|
|
else
|
|
m_StripContainer.SystemCaptionItem.RestoreEnabled = false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns collection of items on a bar.
|
|
/// </summary>
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content), Browsable(false)]
|
|
public SubItemsCollection QuickToolbarItems
|
|
{
|
|
get { return m_StripContainer.CaptionContainer.SubItems; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the reference to the internal container item for the items displayed in control caption.
|
|
/// </summary>
|
|
[Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public GenericItemContainer CaptionContainerItem
|
|
{
|
|
get { return m_StripContainer.CaptionContainer; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the reference to the internal container for the ribbon tabs and other items.
|
|
/// </summary>
|
|
[Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public GenericItemContainer StripContainerItem
|
|
{
|
|
get { return m_StripContainer.RibbonStripContainer; }
|
|
}
|
|
|
|
//internal override bool MenuFocus
|
|
//{
|
|
// get
|
|
// {
|
|
// return base.MenuFocus;
|
|
// }
|
|
// set
|
|
// {
|
|
// if (this.MenuFocus != value)
|
|
// {
|
|
// if (m_CaptionVisible && (m_CaptionContainer.GetHotSubItem() != null || m_CaptionContainer.ExpandedItem()!=null))
|
|
// {
|
|
// if (value)
|
|
// {
|
|
// SetMenuFocus(value);
|
|
// m_CaptionContainer.SetSystemFocus();
|
|
// SetupActiveWindowTimer();
|
|
// this.Refresh();
|
|
// }
|
|
// else
|
|
// {
|
|
// ReleaseActiveWindowTimer();
|
|
// m_CaptionContainer.AutoExpand = false;
|
|
// m_CaptionContainer.ReleaseSystemFocus();
|
|
// m_CaptionContainer.ContainerLostFocus();
|
|
// base.MenuFocus = value;
|
|
// }
|
|
// }
|
|
// else
|
|
// base.MenuFocus = value;
|
|
// }
|
|
// }
|
|
//}
|
|
|
|
protected override void PaintKeyTips(Graphics g)
|
|
{
|
|
if (!this.ShowKeyTips)
|
|
return;
|
|
|
|
KeyTipsRendererEventArgs e = new KeyTipsRendererEventArgs(g, Rectangle.Empty, "", GetKeyTipFont(), null);
|
|
|
|
Rendering.BaseRenderer renderer = GetRenderer();
|
|
PaintContainerKeyTips(m_StripContainer.RibbonStripContainer, renderer, e);
|
|
if (m_CaptionVisible)
|
|
PaintContainerKeyTips(m_StripContainer.CaptionContainer, renderer, e);
|
|
}
|
|
|
|
protected override Rectangle GetKeyTipRectangle(Graphics g, BaseItem item, Font font, string keyTip)
|
|
{
|
|
Rectangle r = base.GetKeyTipRectangle(g, item, font, keyTip);
|
|
if (this.QuickToolbarItems.Contains(item))
|
|
r.Y += 4;
|
|
return r;
|
|
}
|
|
#endregion
|
|
|
|
#region Mdi Child System Item
|
|
internal void ClearMDIChildSystemItems(bool bRecalcLayout)
|
|
{
|
|
if (m_StripContainer.RibbonStripContainer == null)
|
|
return;
|
|
bool recalc = false;
|
|
try
|
|
{
|
|
if (this.Items.Contains("dotnetbarsysiconitem"))
|
|
{
|
|
this.Items.Remove("dotnetbarsysiconitem");
|
|
recalc = true;
|
|
}
|
|
if (this.Items.Contains("dotnetbarsysmenuitem"))
|
|
{
|
|
this.Items.Remove("dotnetbarsysmenuitem");
|
|
recalc = true;
|
|
}
|
|
if (bRecalcLayout && recalc)
|
|
this.RecalcLayout();
|
|
}
|
|
catch (Exception)
|
|
{
|
|
}
|
|
}
|
|
|
|
internal void ShowMDIChildSystemItems(System.Windows.Forms.Form objMdiChild, bool bRecalcLayout)
|
|
{
|
|
ClearMDIChildSystemItems(bRecalcLayout);
|
|
|
|
if (objMdiChild == null)
|
|
return;
|
|
|
|
MDISystemItem mdi = new MDISystemItem("dotnetbarsysmenuitem");
|
|
if (!objMdiChild.ControlBox)
|
|
mdi.CloseEnabled = false;
|
|
if (!objMdiChild.MinimizeBox)
|
|
mdi.MinimizeEnabled = false;
|
|
if (!objMdiChild.MaximizeBox)
|
|
{
|
|
mdi.RestoreEnabled = false;
|
|
}
|
|
mdi.ItemAlignment = eItemAlignment.Far;
|
|
mdi.Click += new System.EventHandler(this.MDISysItemClick);
|
|
|
|
this.Items.Add(mdi);
|
|
|
|
if (bRecalcLayout)
|
|
this.RecalcLayout();
|
|
}
|
|
|
|
private void MDISysItemClick(object sender, System.EventArgs e)
|
|
{
|
|
MDISystemItem mdi = sender as MDISystemItem;
|
|
Form frm = this.FindForm();
|
|
if (frm != null)
|
|
frm = frm.ActiveMdiChild;
|
|
if (frm == null)
|
|
{
|
|
ClearMDIChildSystemItems(true);
|
|
return;
|
|
}
|
|
if (mdi.LastButtonClick == SystemButton.Minimize)
|
|
{
|
|
NativeFunctions.PostMessage(frm.Handle, NativeFunctions.WM_SYSCOMMAND, NativeFunctions.SC_MINIMIZE, 0);
|
|
}
|
|
else if (mdi.LastButtonClick == SystemButton.Restore)
|
|
{
|
|
NativeFunctions.PostMessage(frm.Handle, NativeFunctions.WM_SYSCOMMAND, NativeFunctions.SC_RESTORE, 0);
|
|
}
|
|
else if (mdi.LastButtonClick == SystemButton.Close)
|
|
{
|
|
NativeFunctions.PostMessage(frm.Handle, NativeFunctions.WM_SYSCOMMAND, NativeFunctions.SC_CLOSE, 0);
|
|
}
|
|
else if (mdi.LastButtonClick == SystemButton.NextWindow)
|
|
{
|
|
NativeFunctions.PostMessage(frm.Handle, NativeFunctions.WM_SYSCOMMAND, NativeFunctions.SC_NEXTWINDOW, 0);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
internal void InvokeMouseDown(MouseEventArgs e)
|
|
{
|
|
OnMouseDown(e);
|
|
}
|
|
|
|
internal void InvokeMouseMove(MouseEventArgs e)
|
|
{
|
|
OnMouseMove(e);
|
|
}
|
|
|
|
internal void InvokeMouseUp(MouseEventArgs e)
|
|
{
|
|
OnMouseUp(e);
|
|
}
|
|
|
|
internal void InvokeClick(EventArgs e)
|
|
{
|
|
OnClick(e);
|
|
}
|
|
}
|
|
}
|