1800 lines
58 KiB
C#
1800 lines
58 KiB
C#
namespace DevComponents.DotNetBar
|
|
{
|
|
using System;
|
|
using System.Drawing;
|
|
using System.ComponentModel;
|
|
using DevComponents.DotNetBar.Rendering;
|
|
using DevComponents.DotNetBar.Events;
|
|
|
|
/// <summary>
|
|
/// PopupItem Class can pop-up it's subitems on either the popup Bar
|
|
/// or menu.
|
|
/// </summary>
|
|
[System.ComponentModel.ToolboxItem(false),System.ComponentModel.DesignTimeVisible(false)]
|
|
public abstract class PopupItem:ImageItem,IDesignTimeProvider
|
|
{
|
|
#region Events
|
|
/// <summary>
|
|
/// Occurs when popup container is loading. Use this event to assign control to the popup container. If you want to use same control
|
|
/// that you added to the popup container after popup is closed you must handle the PopupContainerUnload event and remove the control
|
|
/// from the popup container so it is not disposed with the container.
|
|
/// </summary>
|
|
public event EventHandler PopupContainerLoad;
|
|
/// <summary>
|
|
/// Occurs when popup container is unloading. Use this event to save any state associated with the control that was contained by the container or
|
|
/// to remove the control from the container so it is not disposed with container.
|
|
/// </summary>
|
|
public event EventHandler PopupContainerUnload;
|
|
/// <summary>
|
|
/// Occurs when popup item is about to open.
|
|
/// </summary>
|
|
[System.ComponentModel.Description("Occurs when popup item is about to open.")]
|
|
public event DotNetBarManager.PopupOpenEventHandler PopupOpen;
|
|
|
|
/// <summary>
|
|
/// Occurs while popup item is closing.
|
|
/// </summary>
|
|
[System.ComponentModel.Description("Occurs when popup item is closing.")]
|
|
public event EventHandler PopupClose;
|
|
|
|
/// <summary>
|
|
/// Occurs while popup item is closing.
|
|
/// </summary>
|
|
[System.ComponentModel.Description("Occurs before popup is closed and allows you to cancel closing.")]
|
|
public event CancelableEventSourceHandler QueryPopupClose;
|
|
|
|
/// <summary>
|
|
/// Occurs after popup item has been closed.
|
|
/// </summary>
|
|
[System.ComponentModel.Description("Occurs after popup item has been closed.")]
|
|
public event EventHandler PopupFinalized;
|
|
|
|
/// <summary>
|
|
/// Occurs just before popup window is shown.
|
|
/// </summary>
|
|
[System.ComponentModel.Description("Occurs just before popup window is shown.")]
|
|
public event EventHandler PopupShowing;
|
|
#endregion
|
|
|
|
private MenuPanel m_PopupMenu;
|
|
private Bar m_PopupBar;
|
|
private PopupContainerControl m_PopupContainer=null;
|
|
private bool m_FilterInstalled;
|
|
protected SideBarImage m_SideBar;
|
|
private ePopupType m_PopupType;
|
|
private bool m_WasParentFocused;
|
|
private Size m_OldSubItemsImageSize; // For menus we need minimum sub items image size of 16x16 default is 12x12
|
|
private int m_PopupWidth=200;
|
|
private ePersonalizedMenus m_PersonalizedMenus=ePersonalizedMenus.Disabled;
|
|
private Point m_PopupLocation=Point.Empty;
|
|
private ePopupAnimation m_PopupAnimation=ePopupAnimation.ManagerControlled;
|
|
private System.Drawing.Font m_PopupFont=null;
|
|
private System.Windows.Forms.Control m_SourceControl=null;
|
|
private ePopupSide m_PopupSide=ePopupSide.Default;
|
|
private bool m_PopupPositionAdjusted = false;
|
|
|
|
/// <summary>
|
|
/// Creates new instance of PopupItem.
|
|
/// </summary>
|
|
public PopupItem():this("","") {}
|
|
/// <summary>
|
|
/// Creates new instance of PopupItem and assigns the name to it.
|
|
/// </summary>
|
|
/// <param name="sName">Item name</param>
|
|
public PopupItem(string sName):this(sName,""){}
|
|
/// <summary>
|
|
/// Creates new instance of PopupItem and assigns the name and text to it.
|
|
/// </summary>
|
|
/// <param name="sName">Item name.</param>
|
|
/// <param name="ItemText">Item text.</param>
|
|
public PopupItem(string sName, string ItemText):base(sName, ItemText)
|
|
{
|
|
m_PopupMenu=null;
|
|
m_PopupBar=null;
|
|
m_FilterInstalled=false;
|
|
m_PopupType=ePopupType.Menu;
|
|
m_SideBar=new SideBarImage();
|
|
m_WasParentFocused=false;
|
|
m_OldSubItemsImageSize=Size.Empty;
|
|
}
|
|
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
if(this.Expanded) ClosePopup();
|
|
base.Dispose(disposing);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Copies the PopupItem specific properties to new instance of the item.
|
|
/// </summary>
|
|
/// <param name="copy">New ButtonItem instance.</param>
|
|
protected override void CopyToItem(BaseItem copy)
|
|
{
|
|
base.CopyToItem(copy);
|
|
|
|
PopupItem popupItem=copy as PopupItem;
|
|
|
|
popupItem.PersonalizedMenus=this.PersonalizedMenus;
|
|
popupItem.PopUpSideBar=this.PopUpSideBar;
|
|
popupItem.PopupAnimation=this.PopupAnimation;
|
|
popupItem.PopupSide=this.PopupSide;
|
|
popupItem.PopupWidth=this.PopupWidth;
|
|
if(this.PopupClose!=null)
|
|
popupItem.PopupClose = (EventHandler)this.PopupClose.Clone();
|
|
if (this.PopupContainerLoad != null)
|
|
popupItem.PopupContainerLoad = (EventHandler)this.PopupContainerLoad.Clone();
|
|
if (this.PopupContainerUnload != null)
|
|
popupItem.PopupContainerUnload = (EventHandler)this.PopupContainerUnload.Clone();
|
|
if (this.PopupFinalized != null)
|
|
popupItem.PopupFinalized = (EventHandler) this.PopupFinalized.Clone();
|
|
if(this.PopupOpen!=null)
|
|
popupItem.PopupOpen = (DotNetBarManager.PopupOpenEventHandler)this.PopupOpen.Clone();
|
|
if (this.PopupShowing != null)
|
|
popupItem.PopupShowing = (EventHandler) this.PopupShowing.Clone();
|
|
popupItem.PopupType = this.PopupType;
|
|
popupItem.PopupWidth = this.PopupWidth;
|
|
}
|
|
|
|
protected internal override void OnItemAdded(BaseItem objItem)
|
|
{
|
|
base.OnItemAdded(objItem);
|
|
// Popup items don't need to recalculate size
|
|
if(this.SubItems.Count>1)
|
|
m_NeedRecalcSize=false;
|
|
}
|
|
|
|
/*public override void AddSubItem(BaseItem objItem, int Position)
|
|
{
|
|
base.AddSubItem(objItem, Position);
|
|
// Popup items don't need to recalculate size
|
|
if(this.SubItemsCount>1)
|
|
m_NeedRecalcSize=false;
|
|
}*/
|
|
|
|
protected internal override void Serialize(ItemSerializationContext context)
|
|
{
|
|
base.Serialize(context);
|
|
System.Xml.XmlElement ThisItem = context.ItemXmlElement;
|
|
ThisItem.SetAttribute("PopupType",System.Xml.XmlConvert.ToString(((int)m_PopupType)));
|
|
ThisItem.SetAttribute("PopupWidth",System.Xml.XmlConvert.ToString(m_PopupWidth));
|
|
ThisItem.SetAttribute("PersonalizedMenus",System.Xml.XmlConvert.ToString((int)m_PersonalizedMenus));
|
|
ThisItem.SetAttribute("panim",System.Xml.XmlConvert.ToString((int)m_PopupAnimation));
|
|
|
|
// Save Font information if needed
|
|
if(m_PopupFont!=null)
|
|
{
|
|
ThisItem.SetAttribute("fontname",m_PopupFont.Name);
|
|
ThisItem.SetAttribute("fontemsize",System.Xml.XmlConvert.ToString(m_PopupFont.Size));
|
|
ThisItem.SetAttribute("fontstyle",System.Xml.XmlConvert.ToString((int)m_PopupFont.Style));
|
|
}
|
|
}
|
|
|
|
public override void Deserialize(ItemSerializationContext context)
|
|
{
|
|
base.Deserialize(context);
|
|
System.Xml.XmlElement ItemXmlSource = context.ItemXmlElement;
|
|
m_PopupType=(ePopupType)System.Xml.XmlConvert.ToInt32(ItemXmlSource.GetAttribute("PopupType"));
|
|
m_PopupWidth=System.Xml.XmlConvert.ToInt32(ItemXmlSource.GetAttribute("PopupWidth"));
|
|
m_PersonalizedMenus=(ePersonalizedMenus)System.Xml.XmlConvert.ToInt32(ItemXmlSource.GetAttribute("PersonalizedMenus"));
|
|
|
|
if(ItemXmlSource.HasAttribute("panim"))
|
|
m_PopupAnimation=(ePopupAnimation)System.Xml.XmlConvert.ToInt32(ItemXmlSource.GetAttribute("panim"));
|
|
else
|
|
m_PopupAnimation=ePopupAnimation.SystemDefault;
|
|
|
|
m_PopupFont=null;
|
|
// Load font information if it exists
|
|
if(ItemXmlSource.HasAttribute("fontname"))
|
|
{
|
|
string FontName=ItemXmlSource.GetAttribute("fontname");
|
|
float FontSize=System.Xml.XmlConvert.ToSingle(ItemXmlSource.GetAttribute("fontemsize"));
|
|
System.Drawing.FontStyle FontStyle=(System.Drawing.FontStyle)System.Xml.XmlConvert.ToInt32(ItemXmlSource.GetAttribute("fontstyle"));
|
|
try
|
|
{
|
|
m_PopupFont=new Font(FontName,FontSize,FontStyle);
|
|
}
|
|
catch(Exception)
|
|
{
|
|
m_PopupFont=null;
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void InternalKeyDown(System.Windows.Forms.KeyEventArgs objArg)
|
|
{
|
|
if(this.Expanded)
|
|
{
|
|
if(m_PopupMenu!=null)
|
|
{
|
|
if(m_PopupMenu.FocusedItem()!=null)
|
|
m_PopupMenu.FocusedItem().InternalKeyDown(objArg);
|
|
if(m_PopupMenu!=null)
|
|
m_PopupMenu.ExKeyDown(objArg);
|
|
}
|
|
else if(m_PopupBar!=null)
|
|
{
|
|
m_PopupBar.ExKeyDown(objArg);
|
|
}
|
|
else if(m_PopupContainer!=null)
|
|
{
|
|
|
|
}
|
|
return;
|
|
}
|
|
base.InternalKeyDown(objArg);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Occurs when the mouse pointer is moved over the item. This is used by internal implementation only.
|
|
/// </summary>
|
|
[System.ComponentModel.Browsable(false),System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
|
|
public override void InternalMouseMove(System.Windows.Forms.MouseEventArgs objArg)
|
|
{
|
|
base.InternalMouseMove(objArg);
|
|
if(this.Expanded && m_PopupMenu!=null && !this.DesignMode)
|
|
{
|
|
System.Windows.Forms.Control container=this.ContainerControl as System.Windows.Forms.Control;
|
|
MenuPanel menuPanel = m_PopupMenu;
|
|
if (container != null)
|
|
{
|
|
Point p = container.PointToScreen(new Point(objArg.X, objArg.Y));
|
|
if (menuPanel != null && !menuPanel.IsDisposed)
|
|
{
|
|
p = menuPanel.PointToClient(p);
|
|
menuPanel.InternalMouseMove(new System.Windows.Forms.MouseEventArgs(objArg.Button, objArg.Clicks, p.X, p.Y, objArg.Delta));
|
|
}
|
|
}
|
|
}
|
|
else if(this.Expanded && m_PopupBar!=null && !this.DesignMode)
|
|
{
|
|
System.Windows.Forms.Control container=this.ContainerControl as System.Windows.Forms.Control;
|
|
Bar popupBar = m_PopupBar;
|
|
if(container!=null)
|
|
{
|
|
Point p=container.PointToScreen(new Point(objArg.X,objArg.Y));
|
|
if (popupBar != null && !popupBar.IsDisposed)
|
|
{
|
|
p = popupBar.PointToClient(p);
|
|
popupBar.InternalMouseMove(new System.Windows.Forms.MouseEventArgs(System.Windows.Forms.MouseButtons.None, objArg.Clicks, p.X, p.Y, objArg.Delta));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Occurs when the mouse pointer is over the item and a mouse button is released. This is used by internal implementation only.
|
|
/// </summary>
|
|
[System.ComponentModel.Browsable(false),System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
|
|
public override void InternalMouseUp(System.Windows.Forms.MouseEventArgs objArg)
|
|
{
|
|
base.InternalMouseUp(objArg);
|
|
if(this.Expanded && m_PopupMenu!=null && !this.DesignMode)
|
|
{
|
|
System.Windows.Forms.Control container=this.ContainerControl as System.Windows.Forms.Control;
|
|
if(container!=null)
|
|
{
|
|
Point p=container.PointToScreen(new Point(objArg.X,objArg.Y));
|
|
p=m_PopupMenu.PointToClient(p);
|
|
m_PopupMenu.InternalMouseUp(new System.Windows.Forms.MouseEventArgs(objArg.Button,objArg.Clicks,p.X,p.Y,objArg.Delta));
|
|
}
|
|
}
|
|
else if(this.Expanded && m_PopupBar!=null && !this.DesignMode)
|
|
{
|
|
System.Windows.Forms.Control container=this.ContainerControl as System.Windows.Forms.Control;
|
|
if(container!=null)
|
|
{
|
|
Point p=container.PointToScreen(new Point(objArg.X,objArg.Y));
|
|
p=m_PopupBar.PointToClient(p);
|
|
m_PopupBar.InternalMouseUp(new System.Windows.Forms.MouseEventArgs(objArg.Button,objArg.Clicks,p.X,p.Y,objArg.Delta));
|
|
}
|
|
}
|
|
}
|
|
|
|
protected override void OnSubItemGotFocus(BaseItem objItem)
|
|
{
|
|
// Make sure to collapse any other item that might be expanded
|
|
foreach(BaseItem item in this.SubItems)
|
|
{
|
|
PopupItem popup=item as PopupItem;
|
|
if(popup!=null && popup.Expanded && objItem!=item)
|
|
popup.Expanded=false;
|
|
}
|
|
base.OnSubItemGotFocus(objItem);
|
|
}
|
|
|
|
/*public override void KeyDown(System.Windows.Forms.KeyEventArgs objArg)
|
|
{
|
|
if(this.Expanded)
|
|
{
|
|
if(m_PopupMenu!=null)
|
|
{
|
|
m_PopupMenu.ExKeyDown(objArg);
|
|
}
|
|
else if(m_PopupBar!=null)
|
|
{
|
|
m_PopupBar.ExKeyDown(objArg);
|
|
}
|
|
return;
|
|
}
|
|
else if(objArg.KeyCode==System.Windows.Forms.Keys.Enter || objArg.KeyCode==System.Windows.Forms.Keys.Return)
|
|
{
|
|
if(SubItemsCount>0)
|
|
{
|
|
if(m_Parent!=null)
|
|
m_Parent.AutoExpand=true;
|
|
this.Expanded=true;
|
|
objArg.Handled=true;
|
|
return;
|
|
}
|
|
}
|
|
else if(objArg.KeyCode==System.Windows.Forms.Keys.Escape)
|
|
{
|
|
if(SubItemsCount>0 && this.Expanded)
|
|
{
|
|
if(m_Parent!=null)
|
|
m_Parent.AutoExpand=false;
|
|
this.Expanded=false;
|
|
objArg.Handled=true;
|
|
return;
|
|
}
|
|
}
|
|
|
|
base.KeyDown(objArg);
|
|
}*/
|
|
|
|
public override void ContainerLostFocus(bool appLostFocus)
|
|
{
|
|
base.ContainerLostFocus(appLostFocus);
|
|
if(this.Expanded)
|
|
{
|
|
this.Expanded=false;
|
|
if(m_Parent!=null)
|
|
m_Parent.AutoExpand=false;
|
|
}
|
|
}
|
|
|
|
public override void SubItemSizeChanged(BaseItem objChildItem)
|
|
{
|
|
if(m_PopupMenu!=null)
|
|
{
|
|
m_PopupMenu.RecalcSize();
|
|
//m_PopupMenu.Refresh();
|
|
}
|
|
else if(m_PopupBar!=null)
|
|
{
|
|
m_PopupBar.RecalcLayout();
|
|
//m_PopupBar.Refresh();
|
|
}
|
|
}
|
|
|
|
protected internal override void OnExpandChange()
|
|
{
|
|
base.OnExpandChange();
|
|
|
|
if(!this.Expanded)
|
|
m_PopupLocation=Point.Empty;
|
|
|
|
System.Windows.Forms.Control objCtrl=this.ContainerControl as System.Windows.Forms.Control;
|
|
|
|
if(!BaseItem.IsOnPopup(this) || this.Parent==null)
|
|
{
|
|
IOwner owner=this.GetOwner() as IOwner;
|
|
if(owner!=null && this.Name!="syscustomizepopupmenu")
|
|
{
|
|
if(this.Expanded)
|
|
owner.SetExpandedItem(this);
|
|
else if(owner.GetExpandedItem()==this)
|
|
owner.SetExpandedItem(null);
|
|
owner=null;
|
|
}
|
|
// Set/release focus to container so we can receive keyboard events...
|
|
if(objCtrl is Bar && !this.DesignMode)
|
|
{
|
|
if(this.Expanded)
|
|
{
|
|
m_WasParentFocused=false;
|
|
if(objCtrl.Focused)
|
|
m_WasParentFocused=true;
|
|
else
|
|
{
|
|
// TODO: To fix the focus menu expand comment this out
|
|
if(objCtrl is Bar)
|
|
{
|
|
Bar bar=objCtrl as Bar;
|
|
if(bar.BarState!=eBarState.Floating || bar.MenuBar)
|
|
{
|
|
bar.MenuFocus=true;
|
|
//objCtrl.Focus();
|
|
}
|
|
}
|
|
else
|
|
objCtrl.Focus();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(!m_WasParentFocused)
|
|
((Bar)objCtrl).ReleaseFocus();
|
|
Bar bar=objCtrl as Bar;
|
|
if(bar.BarState!=eBarState.Floating && !bar.MenuBar)
|
|
bar.MenuFocus=false;
|
|
m_WasParentFocused=false;
|
|
}
|
|
}
|
|
else if (objCtrl is ItemControl && !this.DesignMode)
|
|
{
|
|
if (this.Expanded)
|
|
{
|
|
m_WasParentFocused = false;
|
|
if (objCtrl.Focused)
|
|
m_WasParentFocused = true;
|
|
else
|
|
{
|
|
ItemControl bar = objCtrl as ItemControl;
|
|
bar.MenuFocus = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Close popup here instead of below since in some use cases setting MenuFocus=false
|
|
// Will dispose this item and we will not be able to unregister popup
|
|
if (!this.Expanded && (m_PopupMenu != null || m_PopupBar != null || m_PopupContainer != null))
|
|
{
|
|
ClosePopup();
|
|
}
|
|
|
|
if (!m_WasParentFocused)
|
|
((ItemControl)objCtrl).ReleaseFocus();
|
|
((ItemControl)objCtrl).MenuFocus=false;
|
|
m_WasParentFocused = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(!this.Expanded && (m_PopupMenu!=null || m_PopupBar!=null || m_PopupContainer!=null))
|
|
{
|
|
ClosePopup();
|
|
}
|
|
|
|
if(objCtrl==null)
|
|
return;
|
|
|
|
// if(this.Expanded && !this.ShowSubItems)
|
|
// return;
|
|
|
|
if(IsHandleValid(objCtrl))
|
|
{
|
|
this.Refresh();
|
|
}
|
|
|
|
if(this.Expanded && m_PopupMenu==null && m_PopupBar==null && m_PopupContainer==null)
|
|
{
|
|
if(IsHandleValid(objCtrl))
|
|
{
|
|
if(m_PopupType==ePopupType.Menu)
|
|
{
|
|
Point p,ps;
|
|
if(!m_PopupLocation.IsEmpty)
|
|
p=m_PopupLocation;
|
|
else if(m_PopupSide!=ePopupSide.Default)
|
|
p=GetDisplayLocation();
|
|
else if(this.Parent is CustomizeItem || this is CustomizeItem)
|
|
{
|
|
if(this.IsRightHanded)
|
|
p=new Point(m_Rect.Left+3,m_Rect.Top);
|
|
else
|
|
p=new Point(m_Rect.Right-2,m_Rect.Top-2);
|
|
}
|
|
else if(this.IsOnMenu)
|
|
{
|
|
if(this.IsRightHanded)
|
|
p=new Point(m_Rect.Left+2,m_Rect.Top-2);
|
|
else
|
|
p=new Point(m_Rect.Right,m_Rect.Top-2);
|
|
}
|
|
else
|
|
{
|
|
if(m_Orientation==eOrientation.Horizontal)
|
|
{
|
|
if(this.IsRightHanded)
|
|
p=new Point(m_Rect.Right,m_Rect.Bottom);
|
|
else
|
|
p=new Point(m_Rect.Left,m_Rect.Bottom);
|
|
}
|
|
else
|
|
{
|
|
p=new Point(m_Rect.Right,m_Rect.Top);
|
|
}
|
|
}
|
|
ps=objCtrl.PointToScreen(p);
|
|
PopupMenu(ps);
|
|
}
|
|
else if(m_PopupType==ePopupType.ToolBar)
|
|
{
|
|
// Popup on Bar
|
|
Point p,ps;
|
|
if(!m_PopupLocation.IsEmpty)
|
|
p=m_PopupLocation;
|
|
else if(m_PopupSide!=ePopupSide.Default)
|
|
p=GetDisplayLocation();
|
|
else if(this.IsOnMenu)
|
|
{
|
|
if(this.IsRightHanded)
|
|
p=new Point(m_Rect.Left+2,m_Rect.Top-2);
|
|
else
|
|
p=new Point(m_Rect.Right,m_Rect.Top-2);
|
|
}
|
|
else
|
|
{
|
|
if(m_Orientation==eOrientation.Horizontal)
|
|
{
|
|
if(this.IsRightHanded)
|
|
p=new Point(m_Rect.Right,m_Rect.Bottom);
|
|
else
|
|
p=new Point(m_Rect.Left,m_Rect.Bottom);
|
|
}
|
|
else
|
|
{
|
|
p=new Point(m_Rect.Right,m_Rect.Top);
|
|
}
|
|
}
|
|
ps=objCtrl.PointToScreen(p);
|
|
PopupBar(ps);
|
|
}
|
|
else if(m_PopupType==ePopupType.Container)
|
|
{
|
|
Point p,ps;
|
|
if(!m_PopupLocation.IsEmpty)
|
|
p=m_PopupLocation;
|
|
else if(m_PopupSide!=ePopupSide.Default)
|
|
p=GetDisplayLocation();
|
|
else if(this.IsOnMenu)
|
|
{
|
|
if(this.IsRightHanded)
|
|
p=new Point(m_Rect.Left+2,m_Rect.Top-2);
|
|
else
|
|
p=new Point(m_Rect.Right,m_Rect.Top-2);
|
|
|
|
}
|
|
else
|
|
{
|
|
if(m_Orientation==eOrientation.Horizontal)
|
|
{
|
|
if(this.IsRightHanded)
|
|
p=new Point(m_Rect.Right,m_Rect.Bottom);
|
|
else
|
|
p=new Point(m_Rect.Left,m_Rect.Bottom);
|
|
}
|
|
else
|
|
{
|
|
p=new Point(m_Rect.Right,m_Rect.Top);
|
|
}
|
|
}
|
|
ps=objCtrl.PointToScreen(p);
|
|
PopupContainer(ps);
|
|
}
|
|
}
|
|
}
|
|
objCtrl=null;
|
|
}
|
|
|
|
protected internal override void OnSubItemExpandChange(BaseItem objItem)
|
|
{
|
|
base.OnSubItemExpandChange(objItem);
|
|
if(objItem.Expanded)
|
|
{
|
|
foreach(BaseItem objExp in this.SubItems)
|
|
{
|
|
if(objExp.Expanded && objExp!=objItem)
|
|
objExp.Expanded=false;
|
|
}
|
|
}
|
|
}
|
|
|
|
protected virtual bool IsRightHanded
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
|
|
//if (NativeFunctions.RightHandedMenus)
|
|
// return true;
|
|
//System.Windows.Forms.Control c = this.ContainerControl as System.Windows.Forms.Control;
|
|
//if (c != null)
|
|
// return (c.RightToLeft == System.Windows.Forms.RightToLeft.Yes);
|
|
//return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Displays the sub-items on popup menu.
|
|
/// </summary>
|
|
/// <param name="p">Popup location.</param>
|
|
public void PopupMenu(Point p)
|
|
{
|
|
PopupMenu(p.X,p.Y);
|
|
}
|
|
|
|
protected internal IOwnerMenuSupport GetIOwnerMenuSupport()
|
|
{
|
|
return (this.GetOwner() as IOwnerMenuSupport);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the size of the popup before it is displayed.
|
|
/// </summary>
|
|
[System.ComponentModel.Browsable(false),System.ComponentModel.DesignerSerializationVisibility(System.ComponentModel.DesignerSerializationVisibility.Hidden)]
|
|
public System.Drawing.Size PopupSize
|
|
{
|
|
get
|
|
{
|
|
if(this.SubItemsImageSize.Width==ImageItem._InitalImageSize.Width && this.SubItemsImageSize.Height==ImageItem._InitalImageSize.Height)
|
|
{
|
|
m_OldSubItemsImageSize=this.SubItemsImageSize;
|
|
this.SubItemsImageSize=new Size(16,16);
|
|
}
|
|
|
|
if (m_PopupType == ePopupType.Container)
|
|
{
|
|
CreatePopupContainer(true);
|
|
if (m_PopupContainer != null)
|
|
return m_PopupContainer.Size;
|
|
return new Size(m_PopupWidth, 150);
|
|
}
|
|
|
|
foreach(BaseItem objItem in this.SubItems)
|
|
objItem.Orientation=eOrientation.Horizontal;
|
|
|
|
MenuPanel popupMenu=new MenuPanel();
|
|
System.Windows.Forms.Control objCtrl=this.ContainerControl as System.Windows.Forms.Control;
|
|
IOwnerMenuSupport ownerMenu=this.GetIOwnerMenuSupport();
|
|
|
|
popupMenu.Owner=this.GetOwner();
|
|
if(m_PopupFont!=null)
|
|
popupMenu.Font=m_PopupFont;
|
|
else if(objCtrl!=null && objCtrl.Font!=null)
|
|
popupMenu.Font = objCtrl.Font; // (System.Drawing.Font)objCtrl.Font.Clone();
|
|
|
|
if(ownerMenu!=null && ownerMenu.AlwaysShowFullMenus)
|
|
popupMenu.PersonalizedMenus=ePersonalizedMenus.Disabled;
|
|
else
|
|
popupMenu.PersonalizedMenus=m_PersonalizedMenus;
|
|
if(ownerMenu!=null && !ownerMenu.ShowFullMenusOnHover && (popupMenu.PersonalizedMenus==ePersonalizedMenus.DisplayOnHover || popupMenu.PersonalizedMenus==ePersonalizedMenus.Both))
|
|
popupMenu.PersonalizedMenus=ePersonalizedMenus.DisplayOnClick;
|
|
|
|
popupMenu.PopupAnimation=m_PopupAnimation;
|
|
|
|
if(ownerMenu!=null && (this.IsOnMenuBar || this.IsOnMenu))
|
|
{
|
|
popupMenu.PersonalizedAllVisible=ownerMenu.PersonalizedAllVisible;
|
|
}
|
|
|
|
if(this.Parent is CustomizeItem || this is CustomizeItem && !(this is QatCustomizeItem))
|
|
popupMenu.IsCustomizeMenu=true;
|
|
|
|
if(this.GetOwner() is DotNetBarManager && ((DotNetBarManager)this.GetOwner()).UseGlobalColorScheme)
|
|
popupMenu.ColorScheme=((DotNetBarManager)this.GetOwner()).ColorScheme;
|
|
if (objCtrl is Bar)
|
|
popupMenu.ColorScheme = ((Bar)objCtrl).ColorScheme;
|
|
else if (objCtrl is MenuPanel)
|
|
popupMenu.ColorScheme = ((MenuPanel)objCtrl).ColorScheme;
|
|
else if(objCtrl is PopupItemControl)
|
|
popupMenu.ColorScheme = ((PopupItemControl)objCtrl).GetColorScheme();
|
|
else if (BarFunctions.IsOffice2007Style(this.EffectiveStyle) && Rendering.GlobalManager.Renderer is Office2007Renderer)
|
|
popupMenu.ColorScheme = ((Office2007Renderer)Rendering.GlobalManager.Renderer).ColorTable.LegacyColors;
|
|
else
|
|
popupMenu.ColorScheme = new ColorScheme(this.EffectiveStyle);
|
|
|
|
popupMenu.SideBar=m_SideBar;
|
|
popupMenu.ParentItem=this;
|
|
popupMenu.CreateControl();
|
|
popupMenu.RecalcSize();
|
|
System.Drawing.Size size=popupMenu.Size;
|
|
popupMenu.Dispose();
|
|
popupMenu=null;
|
|
return size;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Invokes PopupOpen event.
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
protected virtual void OnPopupOpen(PopupOpenEventArgs e)
|
|
{
|
|
if (PopupOpen != null)
|
|
PopupOpen(this, e);
|
|
if (!e.Cancel)
|
|
{
|
|
IOwnerMenuSupport ownerMenu = this.GetIOwnerMenuSupport();
|
|
if(ownerMenu!=null)
|
|
ownerMenu.InvokePopupOpen(this, e);
|
|
}
|
|
}
|
|
|
|
private bool _VerifyPopupScreenPosition = true;
|
|
/// <summary>
|
|
/// Gets or sets whether popup on-screen position is verified and popup location adjusted so it does not cross boundaries of the screen.
|
|
/// </summary>
|
|
[DefaultValue(true), Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public bool VerifyPopupScreenPosition
|
|
{
|
|
get
|
|
{
|
|
return _VerifyPopupScreenPosition;
|
|
}
|
|
set
|
|
{
|
|
_VerifyPopupScreenPosition = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Displays the sub-items on popup menu.
|
|
/// </summary>
|
|
/// <param name="x">Horizontal coordinate in pixels of the upper left corner of a popup.</param>
|
|
/// <param name="y">Vertical coordinate in pixels of the upper left corner of a popup.</param>
|
|
public virtual void PopupMenu(int x, int y)
|
|
{
|
|
PopupMenu(x, y, _VerifyPopupScreenPosition);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Displays the sub-items on popup menu.
|
|
/// </summary>
|
|
/// <param name="x">Horizontal coordinate in pixels of the upper left corner of a popup.</param>
|
|
/// <param name="y">Vertical coordinate in pixels of the upper left corner of a popup.</param>
|
|
/// <param name="verifyScreenPosition">Indicates whether screen position of the menu is verified so the menu always appears on the screen.</param>
|
|
public virtual void PopupMenu(int x, int y, bool verifyScreenPosition)
|
|
{
|
|
PopupPositionAdjusted = false;
|
|
IOwnerMenuSupport ownerMenu=this.GetIOwnerMenuSupport();
|
|
|
|
//if(ownerMenu==null)
|
|
// throw(new InvalidOperationException("Current owner is not assigned or it does not have popup menu support."));
|
|
|
|
System.Windows.Forms.Control objCtrl=this.ContainerControl as System.Windows.Forms.Control;
|
|
|
|
if(ownerMenu!=null)
|
|
{
|
|
PopupOpenEventArgs args=new PopupOpenEventArgs();
|
|
OnPopupOpen(args);
|
|
if(args.Cancel)
|
|
{
|
|
this.Expanded=false;
|
|
return;
|
|
}
|
|
}
|
|
|
|
if(this.SubItemsImageSize.Width==ImageItem._InitalImageSize.Width && this.SubItemsImageSize.Height==ImageItem._InitalImageSize.Height)
|
|
{
|
|
m_OldSubItemsImageSize=this.SubItemsImageSize;
|
|
this.SubItemsImageSize=new Size(16,16);
|
|
}
|
|
|
|
foreach(BaseItem objItem in this.SubItems)
|
|
objItem.Orientation=eOrientation.Horizontal;
|
|
|
|
if(m_PopupMenu==null)
|
|
{
|
|
m_PopupMenu=new MenuPanel();
|
|
m_PopupMenu.Owner=this.GetOwner();
|
|
m_PopupMenu.UseWholeScreenForSizeChecking = !verifyScreenPosition;
|
|
|
|
if(m_PopupFont!=null)
|
|
m_PopupMenu.Font=m_PopupFont;
|
|
else if (objCtrl != null && objCtrl.Font != null)
|
|
{
|
|
if (objCtrl.GetType().Name.Contains("MetroTabStrip") && objCtrl.Parent != null && objCtrl.Parent.Font != null)
|
|
m_PopupMenu.Font = objCtrl.Parent.Font;
|
|
else
|
|
m_PopupMenu.Font = objCtrl.Font; // (System.Drawing.Font)objCtrl.Font.Clone();
|
|
}
|
|
|
|
if(ownerMenu!=null && ownerMenu.AlwaysShowFullMenus)
|
|
m_PopupMenu.PersonalizedMenus=ePersonalizedMenus.Disabled;
|
|
else
|
|
m_PopupMenu.PersonalizedMenus=m_PersonalizedMenus;
|
|
if(ownerMenu!=null && !ownerMenu.ShowFullMenusOnHover && (m_PopupMenu.PersonalizedMenus==ePersonalizedMenus.DisplayOnHover || m_PopupMenu.PersonalizedMenus==ePersonalizedMenus.Both))
|
|
m_PopupMenu.PersonalizedMenus=ePersonalizedMenus.DisplayOnClick;
|
|
|
|
m_PopupMenu.PopupAnimation=m_PopupAnimation;
|
|
|
|
if(ownerMenu!=null && (this.IsOnMenuBar || this.IsOnMenu))
|
|
{
|
|
m_PopupMenu.PersonalizedAllVisible=ownerMenu.PersonalizedAllVisible;
|
|
}
|
|
|
|
if(this.Parent is CustomizeItem || this is CustomizeItem && !(this is QatCustomizeItem))
|
|
m_PopupMenu.IsCustomizeMenu=true;
|
|
|
|
if(objCtrl is Bar)
|
|
{
|
|
Bar bar=(Bar)objCtrl;
|
|
m_PopupMenu.ColorScheme = bar.GetColorScheme();
|
|
m_PopupMenu.ShowToolTips = bar.ShowToolTips;
|
|
m_PopupMenu.AntiAlias = bar.AntiAlias;
|
|
if (objCtrl is ContextMenuBar)
|
|
m_PopupMenu.UseWholeScreenForSizeChecking = true;
|
|
}
|
|
else if(objCtrl is MenuPanel)
|
|
{
|
|
MenuPanel menuPanel = (MenuPanel)objCtrl;
|
|
m_PopupMenu.ColorScheme = menuPanel.ColorScheme;
|
|
m_PopupMenu.ShowToolTips = menuPanel.ShowToolTips;
|
|
m_PopupMenu.AntiAlias = menuPanel.AntiAlias;
|
|
}
|
|
else if(objCtrl is SideBar)
|
|
m_PopupMenu.ColorScheme=((SideBar)objCtrl).ColorScheme;
|
|
else if (objCtrl is ExplorerBar)
|
|
{
|
|
ExplorerBar eb = objCtrl as ExplorerBar;
|
|
m_PopupMenu.ColorScheme = eb.ColorScheme;
|
|
m_PopupMenu.AntiAlias = eb.AntiAlias;
|
|
}
|
|
else if (objCtrl is BarBaseControl)
|
|
m_PopupMenu.ColorScheme = ((BarBaseControl)objCtrl).ColorScheme;
|
|
else if (objCtrl is ItemControl)
|
|
{
|
|
ItemControl ic = (ItemControl)objCtrl;
|
|
m_PopupMenu.ColorScheme = ic.GetColorSchemeInternal();
|
|
m_PopupMenu.AntiAlias = ic.AntiAlias;
|
|
}
|
|
else if (objCtrl is PopupItemControl)
|
|
{
|
|
PopupItemControl bx = (PopupItemControl)objCtrl;
|
|
m_PopupMenu.ColorScheme = bx.GetColorScheme();
|
|
m_PopupMenu.AntiAlias = bx.AntiAlias;
|
|
}
|
|
else
|
|
{
|
|
if (this.Style == eDotNetBarStyle.StyleManagerControlled && GlobalManager.Renderer is Office2007Renderer)
|
|
{
|
|
m_PopupMenu.ColorScheme = ((Office2007Renderer)GlobalManager.Renderer).ColorTable.LegacyColors;
|
|
}
|
|
else
|
|
{
|
|
m_PopupMenu.ColorScheme = new ColorScheme(this.EffectiveStyle);
|
|
}
|
|
object own = this.GetOwner();
|
|
if (own is ItemControl)
|
|
{
|
|
m_PopupMenu.AntiAlias = ((ItemControl)own).AntiAlias;
|
|
}
|
|
else if (own is Bar)
|
|
{
|
|
m_PopupMenu.AntiAlias = ((Bar)own).AntiAlias;
|
|
}
|
|
}
|
|
|
|
if (objCtrl != null)
|
|
m_PopupMenu.RightToLeft = objCtrl.RightToLeft;
|
|
|
|
m_PopupMenu.SideBar=m_SideBar;
|
|
m_PopupMenu.ParentItem=this;
|
|
m_PopupMenu.CreateControl();
|
|
m_PopupMenu.RecalcSize();
|
|
}
|
|
|
|
// Make sure that menu is on-screen
|
|
ScreenInformation objScreen=BarFunctions.ScreenFromPoint(new Point(x,y));
|
|
if(objScreen == null && IsHandleValid(objCtrl))
|
|
objScreen=BarFunctions.ScreenFromControl(objCtrl);
|
|
|
|
Rectangle workingArea=objScreen.WorkingArea;
|
|
if (this.Parent == null)
|
|
{
|
|
workingArea = objScreen.Bounds;
|
|
m_PopupMenu.UseWholeScreenForSizeChecking = true;
|
|
}
|
|
|
|
if(this.IsRightHanded)
|
|
{
|
|
// When working with right-handed menus for TabletPC the coordinates passed here are
|
|
// the upper right x,y coordinates since menus are right aligned...
|
|
x-=m_PopupMenu.Width;
|
|
if (objScreen != null && x < workingArea.Left && verifyScreenPosition)
|
|
{
|
|
PopupPositionAdjusted = true;
|
|
// Push it to the right side
|
|
if(this.Displayed && objCtrl!=null && (m_PopupMenu.IsCustomizeMenu || this.IsOnMenu))
|
|
{
|
|
Point p,ps;
|
|
|
|
if(m_PopupMenu.IsCustomizeMenu)
|
|
{
|
|
p=new Point(m_Rect.Right,m_Rect.Bottom);
|
|
}
|
|
else
|
|
{
|
|
p=new Point(m_Rect.Right,m_Rect.Top);
|
|
}
|
|
|
|
ps=objCtrl.PointToScreen(p);
|
|
x=ps.X;
|
|
if (x + m_PopupMenu.Width > workingArea.Right)
|
|
{
|
|
x = workingArea.Right - m_PopupMenu.Width;
|
|
}
|
|
}
|
|
else
|
|
x=workingArea.Left;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (objScreen != null && (x + m_PopupMenu.Width > workingArea.Right || x < workingArea.Left) && verifyScreenPosition)
|
|
{
|
|
PopupPositionAdjusted = true;
|
|
if (x + m_PopupMenu.Width > workingArea.Right)
|
|
{
|
|
// Push it to the right side
|
|
if (this.Displayed && objCtrl != null && !(objCtrl is ContextMenuBar))
|
|
{
|
|
Point p, ps;
|
|
|
|
if (m_PopupMenu.IsCustomizeMenu)
|
|
{
|
|
p = new Point(m_Rect.Left, m_Rect.Bottom);
|
|
}
|
|
else
|
|
{
|
|
if (this.IsOnMenu)
|
|
p = new Point(m_Rect.Left, m_Rect.Top);
|
|
else
|
|
p = new Point(m_Rect.Right, m_Rect.Top);
|
|
}
|
|
|
|
ps = objCtrl.PointToScreen(p);
|
|
x = ps.X - m_PopupMenu.Width;
|
|
if (x + m_PopupMenu.Width > workingArea.Right)
|
|
x = workingArea.Right - m_PopupMenu.Width;
|
|
}
|
|
else
|
|
x = workingArea.Right - m_PopupMenu.Width;
|
|
}
|
|
else if (x < workingArea.Left)
|
|
x = workingArea.Left;
|
|
}
|
|
}
|
|
|
|
// Try to fit whole popup menu "nicely"
|
|
if (objScreen != null && verifyScreenPosition)
|
|
{
|
|
if (y + m_PopupMenu.Height > workingArea.Bottom)
|
|
{
|
|
// If this container is displayed then try to put it above the menu item
|
|
if (this.Displayed && objCtrl != null && objCtrl.Visible)
|
|
{
|
|
Point p = new Point(m_Rect.Left, m_Rect.Bottom - 1), ps;
|
|
ps = objCtrl.PointToScreen(p);
|
|
ps.Y += 2;
|
|
if (ps.Y - m_PopupMenu.Height >= workingArea.Top)
|
|
y = Math.Min(workingArea.Bottom, ps.Y) - m_PopupMenu.Height;
|
|
else if (this is ApplicationButton)
|
|
y = workingArea.Bottom - m_PopupMenu.Height - 4;
|
|
else if (this is DevComponents.DotNetBar.Metro.MetroAppButton)
|
|
y = workingArea.Bottom - m_PopupMenu.Height - 4;
|
|
}
|
|
else
|
|
y = workingArea.Bottom - m_PopupMenu.Height;
|
|
if (y < workingArea.Top)
|
|
y = workingArea.Top;
|
|
PopupPositionAdjusted = true;
|
|
}
|
|
}
|
|
x += _PopupOffset.X;
|
|
y += _PopupOffset.Y;
|
|
// If it still does not fit at this point, container will scale itself properly
|
|
// And allow item scrolling
|
|
m_PopupMenu.Location=new Point(x,y);
|
|
|
|
OnPopupShowing(EventArgs.Empty);
|
|
|
|
m_PopupMenu.Show();
|
|
|
|
if (this.ContainerControl is IKeyTipsControl)
|
|
{
|
|
IKeyTipsControl kc = this.ContainerControl as IKeyTipsControl;
|
|
m_PopupMenu.ShowKeyTips = kc.ShowKeyTips;
|
|
kc.ShowKeyTips = false;
|
|
}
|
|
|
|
this.Expanded=true;
|
|
|
|
if(ownerMenu!=null)
|
|
{
|
|
if(!(objCtrl is Bar) && !(objCtrl is MenuPanel))
|
|
{
|
|
ownerMenu.RegisterPopup(this);
|
|
m_FilterInstalled=true;
|
|
}
|
|
else if(objCtrl is Bar)
|
|
{
|
|
Bar bar=objCtrl as Bar;
|
|
if(bar.BarState!=eBarState.Popup)
|
|
{
|
|
ownerMenu.RegisterPopup(this);
|
|
m_FilterInstalled=true;
|
|
}
|
|
bar=null;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Raises PopupShowing event.
|
|
/// </summary>
|
|
/// <param name="e">Event arguments.</param>
|
|
protected virtual void OnPopupShowing(EventArgs e)
|
|
{
|
|
if (PopupShowing != null)
|
|
PopupShowing(this, e);
|
|
|
|
IOwnerMenuSupport ownerMenu = this.GetIOwnerMenuSupport();
|
|
if (ownerMenu != null)
|
|
ownerMenu.InvokePopupShowing(this, e);
|
|
}
|
|
/// <summary>
|
|
/// Displays the sub-items on popup toolbar.
|
|
/// </summary>
|
|
/// <param name="p">Popup location.</param>
|
|
public void PopupBar(Point p)
|
|
{
|
|
PopupBar(p.X,p.Y);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Displays the sub-items on popup toolbar.
|
|
/// </summary>
|
|
/// <param name="x">Horizontal coordinate in pixels of the upper left corner of a popup.</param>
|
|
/// <param name="y">Vertical coordinate in pixels of the upper left corner of a popup.</param>
|
|
public virtual void PopupBar(int x, int y)
|
|
{
|
|
//DotNetBarManager owner=this.GetOwner();
|
|
IOwnerMenuSupport ownerMenu=this.GetIOwnerMenuSupport();
|
|
//if(ownerMenu==null)
|
|
// throw(new InvalidOperationException("Current owner is not assigned or it does not have popup bar support."));
|
|
|
|
System.Windows.Forms.Control objCtrl=this.ContainerControl as System.Windows.Forms.Control;
|
|
|
|
if(ownerMenu!=null)
|
|
{
|
|
PopupOpenEventArgs args=new PopupOpenEventArgs();
|
|
if(PopupOpen!=null)
|
|
PopupOpen(this,args);
|
|
if(!args.Cancel)
|
|
ownerMenu.InvokePopupOpen(this,args);
|
|
if(args.Cancel)
|
|
{
|
|
this.Expanded=false;
|
|
return;
|
|
}
|
|
}
|
|
|
|
foreach(BaseItem objItem in this.SubItems)
|
|
objItem.Orientation=eOrientation.Horizontal;
|
|
|
|
if(m_PopupBar==null)
|
|
{
|
|
m_PopupBar=new Bar();
|
|
|
|
if(m_PopupFont!=null)
|
|
m_PopupBar.Font=m_PopupFont;
|
|
else if(objCtrl!=null && objCtrl.Font!=null)
|
|
m_PopupBar.Font=(System.Drawing.Font)objCtrl.Font.Clone();
|
|
if(objCtrl is Bar && ((Bar)objCtrl).ColorScheme!=null)
|
|
m_PopupBar.ColorScheme=((Bar)objCtrl).ColorScheme;
|
|
else if(objCtrl is MenuPanel && ((MenuPanel)objCtrl).ColorScheme!=null)
|
|
m_PopupBar.ColorScheme=((MenuPanel)objCtrl).ColorScheme;
|
|
else if (objCtrl is ItemControl && ((ItemControl)objCtrl).ColorScheme != null)
|
|
m_PopupBar.ColorScheme = ((ItemControl)objCtrl).ColorScheme;
|
|
else if (objCtrl is ButtonX && ((ButtonX)objCtrl).ColorScheme != null)
|
|
m_PopupBar.ColorScheme = ((ButtonX)objCtrl).ColorScheme;
|
|
else
|
|
m_PopupBar.ColorScheme = new ColorScheme(this.EffectiveStyle);
|
|
m_PopupBar.SetBarState(eBarState.Popup);
|
|
m_PopupBar.PopupAnimation=m_PopupAnimation;
|
|
m_PopupBar.Owner=this.GetOwner();
|
|
m_PopupBar.ParentItem=this;
|
|
if(objCtrl!=null)
|
|
m_PopupBar.RightToLeft = objCtrl.RightToLeft;
|
|
m_PopupBar.CreateControl();
|
|
m_PopupBar.SetDesignMode(this.DesignMode);
|
|
m_PopupBar.ThemeAware=this.ThemeAware;
|
|
|
|
if(objCtrl is IBarImageSize)
|
|
m_PopupBar.ImageSize=((IBarImageSize)objCtrl).ImageSize;
|
|
|
|
m_PopupBar.PopupWidth=m_PopupWidth;
|
|
|
|
m_PopupBar.RecalcSize();
|
|
}
|
|
|
|
// Make sure that menu is on-screen
|
|
ScreenInformation objScreen=null;
|
|
if(IsHandleValid(objCtrl))
|
|
{
|
|
objScreen=BarFunctions.ScreenFromControl(objCtrl);
|
|
}
|
|
else
|
|
{
|
|
objScreen=BarFunctions.ScreenFromPoint(new Point(x,y));
|
|
}
|
|
|
|
if(this.IsRightHanded)
|
|
x-=m_PopupBar.Width;
|
|
|
|
if(objScreen!=null && x+m_PopupBar.Width>objScreen.WorkingArea.Right)
|
|
{
|
|
// Push it to the right side
|
|
x=objScreen.WorkingArea.Right-m_PopupBar.Width;
|
|
}
|
|
else if(objScreen!=null && x<objScreen.WorkingArea.Left)
|
|
x=objScreen.WorkingArea.Left;
|
|
|
|
// Try to fit whole popup menu "nicely"
|
|
if(objScreen!=null && y+m_PopupBar.Height>objScreen.WorkingArea.Bottom)
|
|
{
|
|
// If this container is displayed then try to put it above the menu item
|
|
if(this.Displayed && objCtrl!=null)
|
|
{
|
|
Point p=new Point(m_Rect.Left,m_Rect.Bottom), ps;
|
|
ps=objCtrl.PointToScreen(p);
|
|
ps.Y+=2;
|
|
if(ps.Y-m_PopupBar.Height>=objScreen.WorkingArea.Top)
|
|
y=ps.Y-m_PopupBar.Height;
|
|
}
|
|
}
|
|
|
|
x += _PopupOffset.X;
|
|
y += _PopupOffset.Y;
|
|
|
|
// If it still does not fit at this point, container will scale itself properly
|
|
// And allow item scrolling
|
|
m_PopupBar.Location=new Point(x,y);
|
|
if(ownerMenu!=null)
|
|
ownerMenu.InvokePopupShowing(this,new EventArgs());
|
|
m_PopupBar.ShowBar();
|
|
this.Expanded=true;
|
|
|
|
if(ownerMenu!=null)
|
|
{
|
|
if(!(objCtrl is Bar) && !(objCtrl is MenuPanel))
|
|
{
|
|
ownerMenu.RegisterPopup(this);
|
|
m_FilterInstalled=true;
|
|
}
|
|
else if(objCtrl is Bar)
|
|
{
|
|
Bar bar=objCtrl as Bar;
|
|
if(bar.BarState!=eBarState.Popup)
|
|
{
|
|
ownerMenu.RegisterPopup(this);
|
|
m_FilterInstalled=true;
|
|
}
|
|
bar=null;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Displays popup container.
|
|
/// </summary>
|
|
/// <param name="p">Popup location.</param>
|
|
public void PopupContainer(Point p)
|
|
{
|
|
PopupContainer(p.X,p.Y);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates the popup container control which is a parent/holder control for the controls you want to display on the popup.
|
|
/// This method can be used if you do not wish to handle the PopupContainerLoad to add controls to the popup container.
|
|
/// After calling this method you can access PopupContainerControl property to add your controls to be displayed on the popup.
|
|
/// </summary>
|
|
/// <param name="fireLoadEvents">Indicates whether PopupContainerLoad events are fired.</param>
|
|
public virtual void CreatePopupContainer(bool fireLoadEvents)
|
|
{
|
|
if (this.PopupType != ePopupType.Container)
|
|
throw new InvalidOperationException("Method can only be called for PopupType set to ePopupType.Container");
|
|
|
|
if (m_PopupContainer == null)
|
|
{
|
|
m_PopupContainer = new PopupContainerControl();
|
|
m_PopupContainer.Owner = this.GetOwner();
|
|
m_PopupContainer.ParentItem = this;
|
|
m_PopupContainer.CreateControl();
|
|
m_PopupContainer.SetDesignMode(this.DesignMode);
|
|
m_PopupContainer.Width = m_PopupWidth;
|
|
|
|
if (fireLoadEvents)
|
|
{
|
|
IOwnerMenuSupport ownerMenu = this.GetIOwnerMenuSupport();
|
|
// Fire off events
|
|
if (PopupContainerLoad != null)
|
|
PopupContainerLoad(this, new EventArgs());
|
|
if (ownerMenu != null)
|
|
ownerMenu.InvokePopupContainerLoad(this, new EventArgs());
|
|
|
|
// Recalc Size would go here...
|
|
m_PopupContainer.RecalcSize();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Displays popup container.
|
|
/// </summary>
|
|
/// <param name="x">Horizontal coordinate in pixels of the upper left corner of a popup.</param>
|
|
/// <param name="y">Vertical coordinate in pixels of the upper left corner of a popup.</param>
|
|
public virtual void PopupContainer(int x, int y)
|
|
{
|
|
//DotNetBarManager owner=this.GetOwner();
|
|
IOwnerMenuSupport ownerMenu=this.GetIOwnerMenuSupport();
|
|
if(ownerMenu==null)
|
|
throw(new InvalidOperationException("Current owner is not assigned or it does not have popup bar support."));
|
|
|
|
CreatePopupContainer(true);
|
|
|
|
// Make sure that container is on-screen
|
|
System.Windows.Forms.Control objCtrl=this.ContainerControl as System.Windows.Forms.Control;
|
|
ScreenInformation objScreen=null;
|
|
if(IsHandleValid(objCtrl))
|
|
{
|
|
objScreen=BarFunctions.ScreenFromControl(objCtrl);
|
|
}
|
|
else
|
|
{
|
|
objScreen=BarFunctions.ScreenFromPoint(new Point(x,y));
|
|
}
|
|
|
|
if(this.IsRightHanded)
|
|
x-=m_PopupContainer.Width;
|
|
|
|
if(objScreen!=null && x+m_PopupContainer.Width>objScreen.WorkingArea.Right)
|
|
{
|
|
// Push it to the right side
|
|
x=objScreen.WorkingArea.Right-m_PopupContainer.Width;
|
|
}
|
|
else if(objScreen!=null && x<objScreen.WorkingArea.Left)
|
|
x=objScreen.WorkingArea.Left;
|
|
|
|
// Try to fit whole popup menu "nicely"
|
|
if(objScreen!=null && y+m_PopupContainer.Height>objScreen.WorkingArea.Bottom)
|
|
{
|
|
// If this container is displayed then try to put it above the menu item
|
|
if(this.Displayed && objCtrl!=null)
|
|
{
|
|
Point p=new Point(m_Rect.Left,m_Rect.Top), ps;
|
|
ps=objCtrl.PointToScreen(p);
|
|
ps.Y+=2;
|
|
if(ps.Y-m_PopupContainer.Height>=objScreen.WorkingArea.Top)
|
|
y=ps.Y-m_PopupContainer.Height;
|
|
}
|
|
}
|
|
|
|
x += _PopupOffset.X;
|
|
y += _PopupOffset.Y;
|
|
|
|
// If it still does not fit at this point, container will scale itself properly
|
|
// And allow item scrolling
|
|
m_PopupContainer.Location=new Point(x,y);
|
|
if(ownerMenu!=null)
|
|
ownerMenu.InvokePopupShowing(this,new EventArgs());
|
|
m_PopupContainer.Show();
|
|
this.Expanded=true;
|
|
|
|
if(ownerMenu!=null)
|
|
{
|
|
if(!(objCtrl is Bar) && !(objCtrl is MenuPanel))
|
|
{
|
|
ownerMenu.RegisterPopup(this);
|
|
m_FilterInstalled=true;
|
|
}
|
|
else if(objCtrl is Bar)
|
|
{
|
|
Bar bar=objCtrl as Bar;
|
|
if(bar.BarState!=eBarState.Popup)
|
|
{
|
|
ownerMenu.RegisterPopup(this);
|
|
m_FilterInstalled=true;
|
|
}
|
|
bar=null;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Displays the sub-items on popup specified by PopupType.
|
|
/// </summary>
|
|
/// <param name="p">Popup location.</param>
|
|
public virtual void Popup(Point p)
|
|
{
|
|
this.Popup(p.X,p.Y);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Displays the sub-items on popup specified by PopupType.
|
|
/// </summary>
|
|
/// <param name="x">Horizontal coordinate in pixels of the upper left corner of a popup.</param>
|
|
/// <param name="y">Vertical coordinate in pixels of the upper left corner of a popup.</param>
|
|
public virtual void Popup(int x, int y)
|
|
{
|
|
if(m_PopupBar!=null || m_PopupMenu!=null || m_PopupContainer!=null)
|
|
ClosePopup();
|
|
switch(m_PopupType)
|
|
{
|
|
case ePopupType.Container:
|
|
this.PopupContainer(x,y);
|
|
break;
|
|
case ePopupType.Menu:
|
|
this.PopupMenu(x,y);
|
|
break;
|
|
case ePopupType.ToolBar:
|
|
this.PopupBar(x,y);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Raises PopupClose event.
|
|
/// </summary>
|
|
/// <param name="e">Event arguments.</param>
|
|
protected virtual void OnPopupClose(EventArgs e)
|
|
{
|
|
IOwnerMenuSupport ownerMenu = this.GetIOwnerMenuSupport();
|
|
if (PopupClose != null)
|
|
PopupClose(this, e);
|
|
|
|
if (ownerMenu != null)
|
|
ownerMenu.InvokePopupClose(this, e);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Queries whether popup can be closed.
|
|
/// </summary>
|
|
/// <param name="eventSource">Source of closing request.</param>
|
|
/// <returns>true if popup can be closed otherwise false.</returns>
|
|
internal bool QueryPopupClosing(eEventSource eventSource)
|
|
{
|
|
CancelableEventSourceHandler handler = QueryPopupClose;
|
|
if (handler != null)
|
|
{
|
|
CancelableEventSourceArgs e = new CancelableEventSourceArgs(eventSource);
|
|
handler(this, e);
|
|
return !e.Cancel;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Closes the currently open popup.
|
|
/// </summary>
|
|
public virtual void ClosePopup()
|
|
{
|
|
if(m_OldSubItemsImageSize!=Size.Empty)
|
|
{
|
|
this.SubItemsImageSize=m_OldSubItemsImageSize;
|
|
m_OldSubItemsImageSize=Size.Empty;
|
|
}
|
|
|
|
//DotNetBarManager owner=this.GetOwner();
|
|
IOwnerMenuSupport ownerMenu=this.GetIOwnerMenuSupport();
|
|
|
|
if(ownerMenu!=null)
|
|
ownerMenu.UnregisterPopup(this);
|
|
m_FilterInstalled=false;
|
|
|
|
// Fire off events
|
|
if(m_PopupContainer!=null)
|
|
{
|
|
if(PopupContainerUnload!=null)
|
|
PopupContainerUnload(this,new EventArgs());
|
|
|
|
if(ownerMenu!=null)
|
|
ownerMenu.InvokePopupContainerUnload(this,new EventArgs());
|
|
}
|
|
|
|
if((m_PopupBar!=null || m_PopupMenu!=null || m_PopupContainer!=null) && ownerMenu!=null)
|
|
{
|
|
OnPopupClose(EventArgs.Empty);
|
|
}
|
|
|
|
if(m_PopupMenu!=null)
|
|
{
|
|
if (this.ContainerControl is IKeyTipsControl)
|
|
{
|
|
IKeyTipsControl kc = this.ContainerControl as IKeyTipsControl;
|
|
kc.ShowKeyTips = m_PopupMenu.ShowKeyTips;
|
|
m_PopupMenu.ShowKeyTips = false;
|
|
}
|
|
m_PopupMenu.Close();
|
|
m_PopupMenu.Dispose();
|
|
m_PopupMenu=null;
|
|
}
|
|
if(m_PopupBar!=null)
|
|
{
|
|
m_PopupBar.Hide();
|
|
m_PopupBar.Dispose();
|
|
m_PopupBar=null;
|
|
}
|
|
if(m_PopupContainer!=null)
|
|
{
|
|
m_PopupContainer.Hide();
|
|
m_PopupContainer.Dispose();
|
|
m_PopupContainer=null;
|
|
}
|
|
this.Expanded=false;
|
|
|
|
IOwner owner=this.GetOwner() as IOwner;
|
|
if(owner!=null && owner.ParentForm!=null)
|
|
{
|
|
owner.ParentForm.Update();
|
|
}
|
|
|
|
OnPopupFinalized(EventArgs.Empty);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Raises PopupFinalized event.
|
|
/// </summary>
|
|
/// <param name="e">Event arguments.</param>
|
|
protected virtual void OnPopupFinalized(EventArgs e)
|
|
{
|
|
if (PopupFinalized != null)
|
|
PopupFinalized(this, e);
|
|
}
|
|
/// <summary>
|
|
/// Indicates whether sub-items are shown on popup Bar or popup menu.
|
|
/// </summary>
|
|
[System.ComponentModel.Browsable(true),DevCoBrowsable(true),System.ComponentModel.Category("Appearance"),System.ComponentModel.Description("Indicates whether sub-items are shown on popup Bar or popup menu."),System.ComponentModel.DefaultValue(ePopupType.Menu)]
|
|
public virtual ePopupType PopupType
|
|
{
|
|
get
|
|
{
|
|
return m_PopupType;
|
|
}
|
|
set
|
|
{
|
|
if(m_PopupType==value)
|
|
return;
|
|
m_PopupType=value;
|
|
if(ShouldSyncProperties)
|
|
BarFunctions.SyncProperty(this, "PopupType");
|
|
NeedRecalcSize=true;
|
|
this.Refresh();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Indicates the font that will be used on the popup window.
|
|
/// </summary>
|
|
[System.ComponentModel.Browsable(true),DevCoBrowsable(true),System.ComponentModel.Category("Appearance"),System.ComponentModel.Description("Indicates the font that will be used on the popup window."),System.ComponentModel.DefaultValue(null)]
|
|
public virtual System.Drawing.Font PopupFont
|
|
{
|
|
get
|
|
{
|
|
return m_PopupFont;
|
|
}
|
|
set
|
|
{
|
|
if(m_PopupFont==value)
|
|
return;
|
|
m_PopupFont=value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Indicates side bar for pop-up window.
|
|
/// </summary>
|
|
[System.ComponentModel.Browsable(false),System.ComponentModel.Category("Appearance"),System.ComponentModel.Description("Indicates side bar for pop-up window.")]
|
|
public virtual SideBarImage PopUpSideBar
|
|
{
|
|
get
|
|
{
|
|
return m_SideBar;
|
|
}
|
|
set
|
|
{
|
|
m_SideBar=value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the location of popup in relation to it's parent.
|
|
/// </summary>
|
|
[Browsable(true), DevCoBrowsable(false), DefaultValue(ePopupSide.Default), Description("Indicates location of popup in relation to it's parent.")]
|
|
public virtual ePopupSide PopupSide
|
|
{
|
|
get {return m_PopupSide;}
|
|
set
|
|
{
|
|
m_PopupSide=value;
|
|
OnAppearanceChanged();
|
|
}
|
|
}
|
|
|
|
private System.Drawing.Point GetDisplayLocation()
|
|
{
|
|
System.Drawing.Point p=System.Drawing.Point.Empty;
|
|
if(this.Parent==null && !(this.ContainerControl is ButtonX))
|
|
return p;
|
|
|
|
if(m_PopupSide==ePopupSide.Right)
|
|
{
|
|
p.X=m_Rect.Right;
|
|
p.Y=m_Rect.Top;
|
|
}
|
|
else if(m_PopupSide==ePopupSide.Left)
|
|
{
|
|
System.Drawing.Size ps=this.PopupSize;
|
|
p.X=m_Rect.Left-ps.Width;
|
|
p.Y=m_Rect.Top;
|
|
}
|
|
else if(m_PopupSide==ePopupSide.Top)
|
|
{
|
|
System.Drawing.Size ps=this.PopupSize;
|
|
p.Y=m_Rect.Top-ps.Height;
|
|
//if(p.Y<0)
|
|
// p.Y=m_Rect.Bottom;
|
|
if(ps.Width>m_Rect.Width)
|
|
p.X=m_Rect.Left;
|
|
else
|
|
p.X=m_Rect.Right-ps.Width;
|
|
}
|
|
else if(m_PopupSide==ePopupSide.Bottom)
|
|
{
|
|
System.Drawing.Size ps=this.PopupSize;
|
|
p.Y=m_Rect.Bottom;
|
|
if(ps.Width>m_Rect.Width)
|
|
p.X=m_Rect.Left;
|
|
else
|
|
p.X=m_Rect.Right-ps.Width;
|
|
}
|
|
return p;
|
|
}
|
|
|
|
private static readonly Point DefaultPopupOffset = Point.Empty;
|
|
private Point _PopupOffset = DefaultPopupOffset;
|
|
/// <summary>
|
|
/// Gets or sets the popup offset.
|
|
/// </summary>
|
|
[Category("Behavior"), Description("Indicates popup offset.")]
|
|
public Point PopupOffset
|
|
{
|
|
get { return _PopupOffset; }
|
|
set { _PopupOffset = value; }
|
|
}
|
|
/// <summary>
|
|
/// Gets whether property should be serialized.
|
|
/// </summary>
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public bool ShouldSerializePopupOffset()
|
|
{
|
|
return _PopupOffset != DefaultPopupOffset;
|
|
}
|
|
/// <summary>
|
|
/// Resets property to its default value.
|
|
/// </summary>
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public void ResetPopupOffset()
|
|
{
|
|
this.PopupOffset = DefaultPopupOffset;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the popup location.
|
|
/// </summary>
|
|
[System.ComponentModel.Browsable(false),System.ComponentModel.DesignerSerializationVisibility(System.ComponentModel.DesignerSerializationVisibility.Hidden)]
|
|
public Point PopupLocation
|
|
{
|
|
get
|
|
{
|
|
if(m_PopupMenu!=null)
|
|
return m_PopupMenu.Location;
|
|
else if(m_PopupBar!=null)
|
|
return m_PopupBar.Location;
|
|
else if(m_PopupContainer!=null)
|
|
return m_PopupContainer.Location;
|
|
return m_PopupLocation;
|
|
}
|
|
set
|
|
{
|
|
m_PopupLocation=value;
|
|
if(m_PopupMenu!=null)
|
|
m_PopupMenu.Location=value;
|
|
else if(m_PopupBar!=null)
|
|
m_PopupBar.Location=value;
|
|
else if(m_PopupContainer!=null)
|
|
m_PopupContainer.Location=value;
|
|
}
|
|
}
|
|
|
|
protected internal override void OnBeforeItemRemoved(BaseItem objItem)
|
|
{
|
|
base.OnBeforeItemRemoved(objItem);
|
|
if(m_PopupBar!=null && objItem!=null)
|
|
m_PopupBar.Items.Remove(objItem);
|
|
}
|
|
|
|
protected internal override void OnAfterItemRemoved(BaseItem objItem, int itemIndex)
|
|
{
|
|
base.OnAfterItemRemoved(objItem, itemIndex);
|
|
if(this.Expanded && objItem==null)
|
|
this.Expanded=false;
|
|
if(m_PopupMenu!=null && !this.SuspendLayout)
|
|
m_PopupMenu.RecalcSize();
|
|
else if (m_PopupBar != null && !this.SuspendLayout)
|
|
m_PopupBar.RecalcLayout();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Indicates when menu items are displayed when MenuVisiblity is set to VisibleIfRecentlyUsed and RecentlyUsed is true.
|
|
/// </summary>
|
|
[System.ComponentModel.Browsable(true),DevCoBrowsable(true),System.ComponentModel.Category("Appearance"),System.ComponentModel.Description("Indicates when menu items are displayed when MenuVisiblity is set to VisibleIfRecentlyUsed and RecentlyUsed is true."),System.ComponentModel.DefaultValue(ePersonalizedMenus.Disabled)]
|
|
public virtual ePersonalizedMenus PersonalizedMenus
|
|
{
|
|
get
|
|
{
|
|
return m_PersonalizedMenus;
|
|
}
|
|
set
|
|
{
|
|
m_PersonalizedMenus=value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Indicates Animation type for Popups.
|
|
/// </summary>
|
|
[System.ComponentModel.Browsable(true),DevCoBrowsable(true),System.ComponentModel.Category("Behavior"),System.ComponentModel.Description("Indicates Animation type for Popups."),System.ComponentModel.DefaultValue(ePopupAnimation.ManagerControlled)]
|
|
public virtual ePopupAnimation PopupAnimation
|
|
{
|
|
get
|
|
{
|
|
return m_PopupAnimation;
|
|
}
|
|
set
|
|
{
|
|
m_PopupAnimation=value;
|
|
}
|
|
}
|
|
|
|
internal bool FilterInstalled
|
|
{
|
|
get
|
|
{
|
|
return m_FilterInstalled;
|
|
}
|
|
set
|
|
{
|
|
m_FilterInstalled=true;
|
|
}
|
|
}
|
|
|
|
protected internal override bool IsAnyOnHandle(IntPtr iHandle)
|
|
{
|
|
bool bRet=base.IsAnyOnHandle(iHandle);
|
|
if(!bRet && m_PopupContainer!=null && m_PopupContainer.Handle==iHandle)
|
|
bRet=true;
|
|
return bRet;
|
|
}
|
|
|
|
//***********************************************
|
|
// IDesignTimeProvider Implementation
|
|
//***********************************************
|
|
public InsertPosition GetInsertPosition(Point pScreen, BaseItem DragItem)
|
|
{
|
|
if(!this.Expanded)
|
|
return null;
|
|
if(m_PopupMenu!=null)
|
|
return m_PopupMenu.GetInsertPosition(pScreen,DragItem);
|
|
else if(m_PopupBar!=null)
|
|
return ((IDesignTimeProvider)m_PopupBar.ItemsContainer).GetInsertPosition(pScreen, DragItem);
|
|
return null;
|
|
}
|
|
public void DrawReversibleMarker(int iPos, bool Before)
|
|
{
|
|
if(!this.Expanded)
|
|
return;
|
|
if(m_PopupMenu!=null)
|
|
m_PopupMenu.DrawReversibleMarker(iPos, Before);
|
|
else if(m_PopupBar!=null)
|
|
((IDesignTimeProvider)m_PopupBar.Items).DrawReversibleMarker(iPos, Before);
|
|
}
|
|
public void InsertItemAt(BaseItem objItem, int iPos, bool Before)
|
|
{
|
|
if(!this.Expanded)
|
|
return;
|
|
if(m_PopupMenu!=null)
|
|
m_PopupMenu.InsertItemAt(objItem, iPos, Before);
|
|
else
|
|
((IDesignTimeProvider)m_PopupBar.Items).InsertItemAt(objItem, iPos, Before);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Specifies the inital width for the Bar that hosts pop-up items. Applies to PopupType.Toolbar only.
|
|
/// </summary>
|
|
[System.ComponentModel.Browsable(true),DevCoBrowsable(true),System.ComponentModel.Category("Layout"),System.ComponentModel.Description("Specifies the inital width for the Bar that hosts pop-up items. Applies to PopupType.Toolbar only."),System.ComponentModel.DefaultValue(200)]
|
|
public virtual int PopupWidth
|
|
{
|
|
get
|
|
{
|
|
return m_PopupWidth;
|
|
}
|
|
set
|
|
{
|
|
if(m_PopupWidth!=value && value>0)
|
|
{
|
|
m_PopupWidth=value;
|
|
if(ShouldSyncProperties)
|
|
BarFunctions.SyncProperty(this, "PopupWidth");
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the control that is displaying the context menu.
|
|
/// </summary>
|
|
[System.ComponentModel.Browsable(false),DevCoBrowsable(false),System.ComponentModel.Description("Gets the control that is displaying the context menu.")]
|
|
public System.Windows.Forms.Control SourceControl
|
|
{
|
|
get
|
|
{
|
|
return m_SourceControl;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the SourceControl for popup menu or toolbar.
|
|
/// </summary>
|
|
/// <param name="ctrl">Control that popup menu or toolbar was invoked for.</param>
|
|
public void SetSourceControl(System.Windows.Forms.Control ctrl)
|
|
{
|
|
m_SourceControl=ctrl;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the reference to the internal host PopupContainerControl control.
|
|
/// </summary>
|
|
[System.ComponentModel.Browsable(false)]
|
|
public PopupContainerControl PopupContainerControl
|
|
{
|
|
get
|
|
{
|
|
return m_PopupContainer;
|
|
}
|
|
}
|
|
|
|
[System.ComponentModel.Browsable(false)/*,System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)*/]
|
|
public System.Windows.Forms.Control PopupControl
|
|
{
|
|
get
|
|
{
|
|
if(m_PopupMenu!=null)
|
|
return m_PopupMenu;
|
|
else if(m_PopupBar!=null)
|
|
return m_PopupBar;
|
|
else if(m_PopupContainer!=null)
|
|
return m_PopupContainer;
|
|
return null;
|
|
}
|
|
}
|
|
|
|
protected override void OnDisplayedChanged()
|
|
{
|
|
if(!this.Displayed && this.Expanded)
|
|
this.Expanded=false;
|
|
}
|
|
|
|
internal virtual bool PopupPositionAdjusted
|
|
{
|
|
get { return m_PopupPositionAdjusted; }
|
|
set
|
|
{
|
|
m_PopupPositionAdjusted = value;
|
|
}
|
|
}
|
|
}
|
|
}
|