747 lines
26 KiB
C#
747 lines
26 KiB
C#
using System;
|
|
using System.Drawing;
|
|
using System.ComponentModel;
|
|
using System.Windows.Forms;
|
|
using DevComponents.DotNetBar.Rendering;
|
|
|
|
namespace DevComponents.DotNetBar
|
|
{
|
|
/// <summary>
|
|
/// Summary description for ControlContainerItem.
|
|
/// </summary>
|
|
[System.ComponentModel.ToolboxItem(false), System.ComponentModel.DesignTimeVisible(false), Designer("DevComponents.DotNetBar.Design.SimpleBaseItemDesigner, DevComponents.DotNetBar.Design, Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf")]
|
|
public class ControlContainerItem:ImageItem,IPersonalizedMenuItem
|
|
{
|
|
/// <summary>
|
|
/// Occurs when container control needs to be assigned to the item.
|
|
/// </summary>
|
|
public event EventHandler ContainerLoadControl;
|
|
public delegate void ControlContainerSerializationEventHandler(object sender, ControlContainerSerializationEventArgs e);
|
|
public event ControlContainerSerializationEventHandler ContainerControlSerialize;
|
|
public event ControlContainerSerializationEventHandler ContainerControlDeserialize;
|
|
|
|
// IPersonalizedMenuItem Implementation
|
|
private eMenuVisibility m_MenuVisibility=eMenuVisibility.VisibleAlways;
|
|
private bool m_RecentlyUsed=false;
|
|
private System.Windows.Forms.Control m_Control=null;
|
|
private bool m_MouseOver=false;
|
|
private bool m_AllowItemResize=true;
|
|
|
|
/// <summary>
|
|
/// Creates new instance of ControlContainerItem and assigns item name.
|
|
/// </summary>
|
|
public ControlContainerItem():this("","") {}
|
|
/// <summary>
|
|
/// Creates new instance of ControlContainerItem and assigns item name.
|
|
/// </summary>
|
|
/// <param name="sName">Item name.</param>
|
|
public ControlContainerItem(string sName):this(sName,""){}
|
|
/// <summary>
|
|
/// Creates new instance of ControlContainerItem and assigns item name and item text.
|
|
/// </summary>
|
|
/// <param name="sName">Item name.</param>
|
|
/// <param name="ItemText">Item text.</param>
|
|
public ControlContainerItem(string sName, string ItemText):base(sName,ItemText)
|
|
{
|
|
m_SupportedOrientation=eSupportedOrientation.Horizontal;
|
|
}
|
|
|
|
internal void InitControl()
|
|
{
|
|
EventArgs e=new EventArgs();
|
|
if(ContainerLoadControl!=null)
|
|
ContainerLoadControl(this,e);
|
|
IOwnerItemEvents owner=this.GetIOwnerItemEvents();
|
|
if(owner!=null)
|
|
owner.InvokeContainerLoadControl(this,e);
|
|
CustomizeChanged();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Overridden. Returns the copy of the ControlContainerItem.
|
|
/// </summary>
|
|
/// <returns>Copy of the ControlContainerItem.</returns>
|
|
public override BaseItem Copy()
|
|
{
|
|
ControlContainerItem objCopy=new ControlContainerItem(this.Name);
|
|
objCopy.AllowItemResize = this.AllowItemResize;
|
|
this.CopyToItem(objCopy);
|
|
return objCopy;
|
|
}
|
|
protected override void CopyToItem(BaseItem copy)
|
|
{
|
|
ControlContainerItem objCopy=copy as ControlContainerItem;
|
|
base.CopyToItem(objCopy);
|
|
objCopy.ContainerLoadControl=this.ContainerLoadControl;
|
|
objCopy.InitControl();
|
|
}
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
if(m_Control!=null)
|
|
{
|
|
m_Control.Enter -= new EventHandler(HostedControlEnter);
|
|
m_Control.GotFocus -= new EventHandler(HostedControlGotFocus);
|
|
m_Control.Resize -= new EventHandler(HostedControlResized);
|
|
// if(m_Control.Parent!=null && (!m_Control.Parent.Disposing && !(m_Control.Parent is Bar && ((Bar)m_Control.Parent).IsDisposing)))
|
|
// {
|
|
// m_Control.Parent.Controls.Remove(m_Control);
|
|
// }
|
|
m_Control=null;
|
|
}
|
|
base.Dispose(disposing);
|
|
}
|
|
protected internal override void Serialize(ItemSerializationContext context)
|
|
{
|
|
base.Serialize(context);
|
|
System.Xml.XmlElement ThisItem = context.ItemXmlElement;
|
|
ThisItem.SetAttribute("AllowResize",System.Xml.XmlConvert.ToString(m_AllowItemResize));
|
|
|
|
if(ContainerControlSerialize!=null)
|
|
this.ContainerControlSerialize(this,new ControlContainerSerializationEventArgs(ThisItem));
|
|
IOwnerItemEvents owner=this.GetIOwnerItemEvents();
|
|
if(owner!=null)
|
|
owner.InvokeContainerControlSerialize(this,new ControlContainerSerializationEventArgs(ThisItem));
|
|
|
|
}
|
|
public override void Deserialize(ItemSerializationContext context)
|
|
{
|
|
base.Deserialize(context);
|
|
System.Xml.XmlElement ItemXmlSource = context.ItemXmlElement;
|
|
m_AllowItemResize=System.Xml.XmlConvert.ToBoolean(ItemXmlSource.GetAttribute("AllowResize"));
|
|
InitControl();
|
|
|
|
if(ContainerControlDeserialize!=null)
|
|
this.ContainerControlDeserialize(this,new ControlContainerSerializationEventArgs(ItemXmlSource));
|
|
IOwnerItemEvents owner=this.GetIOwnerItemEvents();
|
|
if(owner!=null)
|
|
owner.InvokeContainerControlDeserialize(this,new ControlContainerSerializationEventArgs(ItemXmlSource));
|
|
}
|
|
|
|
// IPersonalizedMenuItem Impementation
|
|
/// <summary>
|
|
/// Indicates item's visiblity when on pop-up menu.
|
|
/// </summary>
|
|
[System.ComponentModel.Browsable(true),DevCoBrowsable(true),System.ComponentModel.Category("Appearance"),System.ComponentModel.Description("Indicates item's visiblity when on pop-up menu.")]
|
|
public eMenuVisibility MenuVisibility
|
|
{
|
|
get
|
|
{
|
|
return m_MenuVisibility;
|
|
}
|
|
set
|
|
{
|
|
if(m_MenuVisibility!=value)
|
|
{
|
|
m_MenuVisibility=value;
|
|
if(ShouldSyncProperties)
|
|
BarFunctions.SyncProperty(this, "MenuVisibility");
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Indicates whether item was recently used.
|
|
/// </summary>
|
|
[System.ComponentModel.Browsable(false),System.ComponentModel.DesignerSerializationVisibility(System.ComponentModel.DesignerSerializationVisibility.Hidden)]
|
|
public bool RecentlyUsed
|
|
{
|
|
get
|
|
{
|
|
return m_RecentlyUsed;
|
|
}
|
|
set
|
|
{
|
|
if(m_RecentlyUsed!=value)
|
|
{
|
|
m_RecentlyUsed=value;
|
|
if(ShouldSyncProperties)
|
|
BarFunctions.SyncProperty(this, "RecentlyUsed");
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets/Sets informational text (tooltip) for the item.
|
|
/// </summary>
|
|
[System.ComponentModel.Browsable(false),DevCoBrowsable(false),System.ComponentModel.DefaultValue(""),System.ComponentModel.Category("Appearance"),System.ComponentModel.Description("Indicates the text that is displayed when mouse hovers over the item."),System.ComponentModel.Localizable(true)]
|
|
public override string Tooltip
|
|
{
|
|
get
|
|
{
|
|
|
|
return base.Tooltip;
|
|
}
|
|
set
|
|
{
|
|
base.Tooltip=value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the reference to the control that is managed by the item.
|
|
/// </summary>
|
|
[Category("Data"), DefaultValue(null), Description("Indicates the control that is managed by the item.")]
|
|
public System.Windows.Forms.Control Control
|
|
{
|
|
get
|
|
{
|
|
return m_Control;
|
|
}
|
|
set
|
|
{
|
|
if(m_Control!=null)
|
|
{
|
|
if(m_Control.Parent!=null)
|
|
m_Control.Parent.Controls.Remove(m_Control);
|
|
m_Control.Enter -= new EventHandler(HostedControlEnter);
|
|
m_Control.GotFocus -= new EventHandler(HostedControlGotFocus);
|
|
m_Control.Resize -= new EventHandler(HostedControlResized);
|
|
}
|
|
m_Control=value;
|
|
if(m_Control!=null)
|
|
{
|
|
m_Control.Enter += new EventHandler(HostedControlEnter);
|
|
m_Control.GotFocus += new EventHandler(HostedControlGotFocus);
|
|
m_Control.Resize += new EventHandler(HostedControlResized);
|
|
if(m_Control.Parent!=null)
|
|
m_Control.Parent.Controls.Remove(m_Control);
|
|
m_Control.Dock=System.Windows.Forms.DockStyle.None;
|
|
|
|
//if (m_Control is System.Windows.Forms.ListBox)
|
|
//{
|
|
// TypeDescriptor.GetProperties(m_Control)["IntegralHeight"].SetValue(m_Control, false);
|
|
//}
|
|
//if (!(m_Control is ItemControl) && TypeDescriptor.GetProperties(m_Control).Find("AutoSize", true) != null)
|
|
// TypeDescriptor.GetProperties(m_Control)["AutoSize"].SetValue(m_Control, false);
|
|
|
|
System.Windows.Forms.Control objCtrl=null;
|
|
if(this.ContainerControl!=null)
|
|
{
|
|
objCtrl=this.ContainerControl as System.Windows.Forms.Control;
|
|
if(objCtrl!=null)
|
|
{
|
|
objCtrl.Controls.Add(m_Control);
|
|
m_Control.Refresh();
|
|
}
|
|
}
|
|
if(!this.Displayed)
|
|
m_Control.Visible=false;
|
|
}
|
|
}
|
|
}
|
|
|
|
void HostedControlResized(object sender, EventArgs e)
|
|
{
|
|
NeedRecalcSize = true;
|
|
if (this.ContainerControl is MenuPanel)
|
|
((MenuPanel)this.ContainerControl).RecalcLayout();
|
|
}
|
|
|
|
private void HostedControlGotFocus(object sender, EventArgs e)
|
|
{
|
|
SetMenuHotSubItem();
|
|
}
|
|
|
|
private void SetMenuHotSubItem()
|
|
{
|
|
if (this.IsOnMenu)
|
|
{
|
|
MenuPanel panel = this.ContainerControl as MenuPanel;
|
|
if (panel != null && panel.HotSubItem != this)
|
|
panel.HotSubItem = this;
|
|
}
|
|
}
|
|
private void HostedControlEnter(object sender, EventArgs e)
|
|
{
|
|
SetMenuHotSubItem();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Overridden. Draws the item.
|
|
/// </summary>
|
|
/// <param name="g">Target Graphics object.</param>
|
|
public override void Paint(ItemPaintArgs pa)
|
|
{
|
|
if(this.SuspendLayout)
|
|
return;
|
|
|
|
System.Drawing.Graphics g = pa.Graphics;
|
|
|
|
if (m_Control != null && m_Control.Visible != this.Displayed && !m_Control.Visible)
|
|
CustomizeChanged(); // Determine based on customize status
|
|
|
|
Rectangle r = this.DisplayRectangle;
|
|
|
|
Size objImageSize = GetMaxImageSize();
|
|
bool bOnMenu = this.IsOnMenu;
|
|
if (bOnMenu && this.Parent is ItemContainer)
|
|
bOnMenu = false;
|
|
|
|
if (this.Orientation == eOrientation.Horizontal)
|
|
{
|
|
if (bOnMenu && !this.Stretch)
|
|
{
|
|
objImageSize.Width += 7;
|
|
r.Width -= objImageSize.Width;
|
|
r.X += objImageSize.Width;
|
|
if (this.IsOnCustomizeMenu)
|
|
objImageSize.Width += objImageSize.Height + 8;
|
|
|
|
// Draw side bar
|
|
Rectangle sideRect = new Rectangle(m_Rect.Left, m_Rect.Top, objImageSize.Width, m_Rect.Height);
|
|
if (this.MenuVisibility == eMenuVisibility.VisibleIfRecentlyUsed && !this.RecentlyUsed)
|
|
{
|
|
if (!pa.Colors.MenuUnusedSide2.IsEmpty)
|
|
{
|
|
System.Drawing.Drawing2D.LinearGradientBrush gradient = BarFunctions.CreateLinearGradientBrush(sideRect, pa.Colors.MenuUnusedSide, pa.Colors.MenuUnusedSide2, pa.Colors.MenuUnusedSideGradientAngle);
|
|
g.FillRectangle(gradient, sideRect);
|
|
gradient.Dispose();
|
|
}
|
|
else
|
|
g.FillRectangle(new SolidBrush(pa.Colors.MenuUnusedSide), sideRect);
|
|
}
|
|
else
|
|
{
|
|
if (!pa.Colors.MenuSide2.IsEmpty)
|
|
{
|
|
System.Drawing.Drawing2D.LinearGradientBrush gradient = BarFunctions.CreateLinearGradientBrush(sideRect, pa.Colors.MenuSide, pa.Colors.MenuSide2, pa.Colors.MenuSideGradientAngle);
|
|
g.FillRectangle(gradient, sideRect);
|
|
gradient.Dispose();
|
|
}
|
|
else
|
|
g.FillRectangle(new SolidBrush(pa.Colors.MenuSide), sideRect);
|
|
}
|
|
if (BarFunctions.IsOffice2007Style(EffectiveStyle) && GlobalManager.Renderer is Office2007Renderer)
|
|
{
|
|
Office2007MenuColorTable mt = ((Office2007Renderer)GlobalManager.Renderer).ColorTable.Menu;
|
|
if (mt != null && !mt.SideBorder.IsEmpty)
|
|
{
|
|
if (pa.RightToLeft)
|
|
DisplayHelp.DrawGradientLine(g, sideRect.X + 1, sideRect.Y, sideRect.X + 1, sideRect.Bottom - 1, mt.SideBorder, 1);
|
|
else
|
|
DisplayHelp.DrawGradientLine(g, sideRect.Right - 2, sideRect.Y, sideRect.Right - 2, sideRect.Bottom - 1, mt.SideBorder, 1);
|
|
}
|
|
if (mt != null && !mt.SideBorderLight.IsEmpty)
|
|
{
|
|
if (pa.RightToLeft)
|
|
DisplayHelp.DrawGradientLine(g, sideRect.X, sideRect.Y, sideRect.X, sideRect.Bottom - 1, mt.SideBorder, 1);
|
|
else
|
|
DisplayHelp.DrawGradientLine(g, sideRect.Right - 1, sideRect.Y, sideRect.Right - 1, sideRect.Bottom - 1, mt.SideBorderLight, 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
if(this.IsOnCustomizeMenu)
|
|
{
|
|
if (EffectiveStyle != eDotNetBarStyle.Office2000)
|
|
{
|
|
r.X+=(objImageSize.Height+8);
|
|
r.Width-=(objImageSize.Height+8);
|
|
}
|
|
else
|
|
{
|
|
r.X+=(objImageSize.Height+4);
|
|
r.Width-=(objImageSize.Height+4);
|
|
}
|
|
}
|
|
|
|
if (bOnMenu && EffectiveStyle != eDotNetBarStyle.Office2000)
|
|
{
|
|
//g.FillRectangle(new SolidBrush(pa.Colors.MenuBackground),r);
|
|
}
|
|
//else if(this.Style==eDotNetBarStyle.OfficeXP && !this.IsOnMenuBar)
|
|
// g.FillRectangle(new SolidBrush(ColorFunctions.ToolMenuFocusBackColor(g)),this.DisplayRectangle);
|
|
//else
|
|
// g.FillRectangle(SystemBrushes.Control,this.DisplayRectangle);
|
|
|
|
// Draw text if needed
|
|
if (m_Control == null || this.GetDesignMode() || this.IsOnCustomizeMenu)
|
|
{
|
|
string text=m_Text;
|
|
if(text=="")
|
|
text="Container";
|
|
eTextFormat objStringFormat=GetStringFormat();
|
|
Font objFont=this.GetFont();
|
|
Rectangle rText=new Rectangle(r.X+8,r.Y,r.Width,r.Height);
|
|
if (EffectiveStyle == eDotNetBarStyle.Office2000)
|
|
{
|
|
TextDrawing.DrawString(g, text, objFont, SystemColors.ControlText, rText, objStringFormat);
|
|
}
|
|
else
|
|
{
|
|
TextDrawing.DrawString(g, text, objFont, SystemColors.ControlText, rText, objStringFormat);
|
|
}
|
|
Size textSize = TextDrawing.MeasureString(g, text, objFont, 0, objStringFormat);
|
|
r.X += (int)textSize.Width + 8;
|
|
r.Width -= ((int)textSize.Width + 8);
|
|
}
|
|
else if (m_Control != null)
|
|
{
|
|
r.Inflate(-2, -2);
|
|
if (m_AllowItemResize)
|
|
{
|
|
m_Control.Width = r.Width;
|
|
}
|
|
Point loc = r.Location;
|
|
loc.Offset((r.Width - m_Control.Width) / 2, (r.Height - m_Control.Height) / 2);
|
|
|
|
ScrollableControl scc = pa.ContainerControl as ScrollableControl;
|
|
if (scc != null && scc.AutoScroll /*&& !(scc is ItemPanel)*/)
|
|
loc.Offset(scc.AutoScrollPosition.X, scc.AutoScrollPosition.Y);
|
|
|
|
if (m_Control.Location != loc &&
|
|
(!(m_Control is Controls.ComboBoxEx && ContainerControl is RibbonBar) || IsOnPopup(this)) || _ControlLocationUpdatePending)
|
|
{
|
|
m_Control.Location = loc;
|
|
_ControlLocationUpdatePending = false;
|
|
}
|
|
}
|
|
|
|
if(this.IsOnCustomizeMenu && this.Visible)
|
|
{
|
|
// Draw check box if this item is visible
|
|
Rectangle rBox=new Rectangle(m_Rect.Left,m_Rect.Top,m_Rect.Height,m_Rect.Height);
|
|
if (EffectiveStyle != eDotNetBarStyle.Office2000)
|
|
rBox.Inflate(-1,-1);
|
|
BarFunctions.DrawMenuCheckBox(pa, rBox, EffectiveStyle, m_MouseOver);
|
|
}
|
|
}
|
|
|
|
if (this.Focused && (this.GetDesignMode() || m_Control == null && this.DesignMode))
|
|
{
|
|
r = this.DisplayRectangle;
|
|
r.Inflate(-1, -1);
|
|
DesignTime.DrawDesignTimeSelection(g, r, pa.Colors.ItemDesignTimeBorder);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// IBlock member implementation
|
|
/// </summary>
|
|
[Browsable(false), DevCoBrowsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), EditorBrowsable(EditorBrowsableState.Never)]
|
|
public override System.Drawing.Rectangle Bounds
|
|
{
|
|
get { return base.Bounds; }
|
|
set
|
|
{
|
|
if (base.Bounds != value)
|
|
{
|
|
bool topLocationChanged = base.Bounds.Top != value.Top;
|
|
bool leftLocationChanged = base.Bounds.Left != value.Left;
|
|
base.Bounds = value;
|
|
if (topLocationChanged || leftLocationChanged)
|
|
UpdateControlLocation();
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool _ControlLocationUpdatePending = false;
|
|
private void UpdateControlLocation()
|
|
{
|
|
if (m_Control == null) return;
|
|
if (this.IsLayoutPassInProgress)
|
|
{
|
|
_ControlLocationUpdatePending = true;
|
|
return;
|
|
}
|
|
Rectangle r = this.DisplayRectangle;
|
|
r.Inflate(-2, -2);
|
|
m_Control.Location = r.Location;
|
|
_ControlLocationUpdatePending = false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Overridden. Recalculates the size of the item.
|
|
/// </summary>
|
|
public override void RecalcSize()
|
|
{
|
|
if(this.SuspendLayout)
|
|
return;
|
|
|
|
bool bOnMenu=this.IsOnMenu;
|
|
|
|
if(m_Control==null && !this.DesignMode)
|
|
InitControl();
|
|
|
|
// Default Height
|
|
if(this.Parent!=null && this.Parent is ImageItem)
|
|
m_Rect.Height=((ImageItem)this.Parent).SubItemsImageSize.Height+4;
|
|
else
|
|
m_Rect.Height=this.SubItemsImageSize.Height+4;
|
|
|
|
if (EffectiveStyle == eDotNetBarStyle.OfficeXP || EffectiveStyle == eDotNetBarStyle.Office2003 || EffectiveStyle == eDotNetBarStyle.VS2005)
|
|
{
|
|
if(m_Control!=null && m_Rect.Height<(m_Control.Height+2))
|
|
m_Rect.Height=m_Control.Height+2;
|
|
}
|
|
else
|
|
{
|
|
if(m_Control!=null && m_Rect.Height<(m_Control.Height+2))
|
|
m_Rect.Height=m_Control.Height+2;
|
|
}
|
|
|
|
// Default width
|
|
if(m_Control!=null)
|
|
{
|
|
if (this.Stretch)
|
|
m_Rect.Width = 32;
|
|
else
|
|
{
|
|
m_Rect.Width = m_Control.Width + 4;
|
|
}
|
|
}
|
|
else
|
|
m_Rect.Width=64+4;
|
|
|
|
// Calculate Item Height
|
|
if(m_Control==null)
|
|
{
|
|
string text=m_Text;
|
|
if(text=="")
|
|
text="Container";
|
|
System.Windows.Forms.Control objCtrl=this.ContainerControl as System.Windows.Forms.Control;
|
|
if(objCtrl!=null && IsHandleValid(objCtrl))
|
|
{
|
|
Graphics g=BarFunctions.CreateGraphics(objCtrl);
|
|
try
|
|
{
|
|
Size textSize = TextDrawing.MeasureString(g, text, GetFont(), 0, GetStringFormat());
|
|
if (textSize.Height > this.SubItemsImageSize.Height && textSize.Height > m_Rect.Height)
|
|
m_Rect.Height = (int)textSize.Height + 4;
|
|
m_Rect.Width = (int)textSize.Width + 8;
|
|
}
|
|
finally
|
|
{
|
|
g.Dispose();
|
|
}
|
|
}
|
|
}
|
|
|
|
Size objImageSize=GetMaxImageSize();
|
|
if (this.IsOnMenu && EffectiveStyle != eDotNetBarStyle.Office2000 && !this.Stretch && !(this.Parent is ItemContainer))
|
|
{
|
|
// THis is side bar that will need to be drawn for DotNet style
|
|
m_Rect.Width+=(objImageSize.Width+7);
|
|
}
|
|
|
|
if(this.IsOnCustomizeMenu)
|
|
m_Rect.Width+=(objImageSize.Height+2);
|
|
|
|
// Always call base implementation to reset resize flag
|
|
base.RecalcSize();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called when size of the item is changed externally.
|
|
/// </summary>
|
|
protected override void OnExternalSizeChange()
|
|
{
|
|
base.OnExternalSizeChange();
|
|
if(m_AllowItemResize)
|
|
NeedRecalcSize=true;
|
|
}
|
|
|
|
protected internal override void OnContainerChanged(object objOldContainer)
|
|
{
|
|
base.OnContainerChanged(objOldContainer);
|
|
if(m_Control!=null)
|
|
{
|
|
System.Windows.Forms.Control objCtrl=this.ContainerControl as System.Windows.Forms.Control;
|
|
if(m_Control.Parent!=null && objCtrl!=m_Control.Parent)
|
|
m_Control.Parent.Controls.Remove(m_Control);
|
|
|
|
if(objCtrl!=null && m_Control.Parent==null)
|
|
{
|
|
objCtrl.Controls.Add(m_Control);
|
|
m_Control.Refresh();
|
|
}
|
|
}
|
|
}
|
|
|
|
protected internal override void OnVisibleChanged(bool newValue)
|
|
{
|
|
if(m_Control!=null && !newValue)
|
|
m_Control.Visible=newValue;
|
|
base.OnVisibleChanged(newValue);
|
|
}
|
|
protected override void OnDisplayedChanged()
|
|
{
|
|
if (!this.Displayed && m_Control != null && !(this.IsOnCustomizeMenu || this.IsOnCustomizeDialog || this.GetDesignMode()))
|
|
{
|
|
m_Control.Visible=this.Displayed;
|
|
}
|
|
}
|
|
|
|
protected override void OnIsOnCustomizeDialogChanged()
|
|
{
|
|
base.OnIsOnCustomizeDialogChanged();
|
|
CustomizeChanged();
|
|
}
|
|
|
|
protected override void OnDesignModeChanged()
|
|
{
|
|
base.OnDesignModeChanged();
|
|
CustomizeChanged();
|
|
}
|
|
|
|
protected override void OnIsOnCustomizeMenuChanged()
|
|
{
|
|
base.OnIsOnCustomizeMenuChanged();
|
|
CustomizeChanged();
|
|
}
|
|
|
|
private bool m_CustomizeChangedExecuting = false;
|
|
private void CustomizeChanged()
|
|
{
|
|
if(m_Control!=null)
|
|
{
|
|
if (m_CustomizeChangedExecuting) return;
|
|
m_CustomizeChangedExecuting = true;
|
|
try
|
|
{
|
|
if (this.IsOnCustomizeMenu || this.IsOnCustomizeDialog || this.GetDesignMode())
|
|
{
|
|
m_Control.Visible = false;
|
|
}
|
|
else
|
|
{
|
|
m_Control.Visible = this.Displayed;
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
m_CustomizeChangedExecuting = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
private Size GetMaxImageSize()
|
|
{
|
|
if(m_Parent!=null)
|
|
{
|
|
ImageItem objParentImageItem=m_Parent as ImageItem;
|
|
if(objParentImageItem!=null)
|
|
return objParentImageItem.SubItemsImageSize;
|
|
else
|
|
return this.ImageSize;
|
|
}
|
|
else
|
|
return this.ImageSize;
|
|
}
|
|
private eTextFormat GetStringFormat()
|
|
{
|
|
eTextFormat format = eTextFormat.Default;
|
|
format |= eTextFormat.SingleLine;
|
|
format |= eTextFormat.EndEllipsis;
|
|
format |= eTextFormat.VerticalCenter;
|
|
return format;
|
|
|
|
|
|
//StringFormat sfmt=BarFunctions.CreateStringFormat(); //new StringFormat(StringFormat.GenericDefault);
|
|
//sfmt.HotkeyPrefix=System.Drawing.Text.HotkeyPrefix.Show;
|
|
////sfmt.FormatFlags=sfmt.FormatFlags & ~(sfmt.FormatFlags & StringFormatFlags.DisableKerning);
|
|
//sfmt.FormatFlags=sfmt.FormatFlags | StringFormatFlags.NoWrap;
|
|
//sfmt.Trimming=StringTrimming.EllipsisCharacter;
|
|
//sfmt.Alignment=System.Drawing.StringAlignment.Near;
|
|
//sfmt.LineAlignment=System.Drawing.StringAlignment.Center;
|
|
|
|
//return sfmt;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the Font object to be used for drawing the item text.
|
|
/// </summary>
|
|
/// <returns>Font object.</returns>
|
|
protected virtual Font GetFont()
|
|
{
|
|
System.Windows.Forms.Control objCtrl=this.ContainerControl as System.Windows.Forms.Control;
|
|
if(objCtrl!=null)
|
|
return (Font)objCtrl.Font;
|
|
return SystemFonts.DefaultFont;
|
|
}
|
|
protected internal override bool IsAnyOnHandle(IntPtr iHandle)
|
|
{
|
|
bool bRet=base.IsAnyOnHandle(iHandle);
|
|
if(!bRet && m_Control!=null && m_Control.Handle==iHandle)
|
|
bRet=true;
|
|
return bRet;
|
|
}
|
|
protected override void OnEnabledChanged()
|
|
{
|
|
base.OnEnabledChanged();
|
|
if(m_Control!=null)
|
|
m_Control.Enabled=this.Enabled;
|
|
}
|
|
|
|
[System.ComponentModel.Browsable(false),System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
|
|
public override void InternalMouseEnter()
|
|
{
|
|
base.InternalMouseEnter();
|
|
if(!m_MouseOver)
|
|
{
|
|
m_MouseOver=true;
|
|
if(this.IsOnCustomizeMenu && this.Visible)
|
|
this.Refresh();
|
|
}
|
|
}
|
|
|
|
[System.ComponentModel.Browsable(false),System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
|
|
public override void InternalMouseLeave()
|
|
{
|
|
base.InternalMouseLeave();
|
|
if(m_MouseOver)
|
|
{
|
|
m_MouseOver=false;
|
|
if (this.IsOnCustomizeMenu && this.Visible)
|
|
this.Refresh();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Specifies whether contained control can be automatically resized to fill the item container.
|
|
/// </summary>
|
|
[System.ComponentModel.Browsable(true),DevCoBrowsable(true),System.ComponentModel.Category("Behavior"),System.ComponentModel.Description("Specifies whether contained control can be automatically resized to fill the item container.")]
|
|
public bool AllowItemResize
|
|
{
|
|
get {return m_AllowItemResize;}
|
|
set {m_AllowItemResize=value;}
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public override void OnGotFocus()
|
|
{
|
|
base.OnGotFocus();
|
|
if(m_Control==null)
|
|
return;
|
|
if (m_Control.Focused || this.IsOnCustomizeMenu || this.IsOnCustomizeDialog || this.GetDesignMode())
|
|
return;
|
|
m_Control.Focus();
|
|
}
|
|
|
|
[System.ComponentModel.Browsable(false),System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
|
|
public override bool IsWindowed
|
|
{
|
|
get {return true;}
|
|
}
|
|
|
|
private bool GetDesignMode()
|
|
{
|
|
if (this.ContainerControl is IBarDesignerServices && ((IBarDesignerServices)this.ContainerControl).Designer != null)
|
|
return false;
|
|
return base.DesignMode;
|
|
}
|
|
}
|
|
|
|
public class ControlContainerSerializationEventArgs : EventArgs
|
|
{
|
|
private readonly System.Xml.XmlElement xmlstore;
|
|
public ControlContainerSerializationEventArgs(System.Xml.XmlElement xmlstorage)
|
|
{
|
|
this.xmlstore=xmlstorage;
|
|
}
|
|
public System.Xml.XmlElement XmlStorage
|
|
{
|
|
get{return this.xmlstore;}
|
|
}
|
|
}
|
|
}
|