1621 lines
50 KiB
C#
1621 lines
50 KiB
C#
using System;
|
|
using System.Drawing;
|
|
using System.ComponentModel;
|
|
|
|
namespace DevComponents.DotNetBar
|
|
{
|
|
/// <summary>
|
|
/// Item container for dockable windows.
|
|
/// </summary>
|
|
[System.ComponentModel.ToolboxItem(false), System.ComponentModel.DesignTimeVisible(false), Designer("DevComponents.DotNetBar.Design.DockContainerItemDesigner, DevComponents.DotNetBar.Design, Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf")]
|
|
public class DockContainerItem:ImageItem
|
|
{
|
|
/// <summary>
|
|
/// Occurs when container control needs to be assigned to the item.
|
|
/// </summary>
|
|
public event EventHandler ContainerLoadControl;
|
|
public event ControlContainerItem.ControlContainerSerializationEventHandler ContainerControlSerialize;
|
|
public event ControlContainerItem.ControlContainerSerializationEventHandler ContainerControlDeserialize;
|
|
|
|
private System.Windows.Forms.Control m_Control=null;
|
|
private bool m_MouseOver=false;
|
|
private bool m_InternalResize=false;
|
|
private Size m_MinimumSize=new Size(32,32);
|
|
private Size m_DefaultFloatingSize=new Size(128,128);
|
|
|
|
private System.Drawing.Image m_Image=null;
|
|
private int m_ImageIndex=-1;
|
|
private System.Drawing.Image m_TabImage=null;
|
|
private System.Drawing.Icon m_Icon=null;
|
|
|
|
private int m_MinFormClientSize=64;
|
|
private int m_DelayedWidth=-1;
|
|
private int m_DelayedHeight=-1;
|
|
private eTabItemColor m_PredefinedTabColor = eTabItemColor.Default;
|
|
|
|
/// <summary>
|
|
/// Creates new instance of ControlContainerItem and assigns item name.
|
|
/// </summary>
|
|
public DockContainerItem():this("","") {}
|
|
/// <summary>
|
|
/// Creates new instance of ControlContainerItem and assigns item name.
|
|
/// </summary>
|
|
/// <param name="sName">Item name.</param>
|
|
public DockContainerItem(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 DockContainerItem(string sName, string ItemText):base(sName,ItemText)
|
|
{
|
|
m_SupportedOrientation=eSupportedOrientation.Both;
|
|
this.Stretch=true;
|
|
this.CanCustomize=false;
|
|
m_Displayed=true; // need so the hosted control can be hidden...
|
|
this.GlobalItem = false;
|
|
}
|
|
|
|
internal void InitControl()
|
|
{
|
|
EventArgs e=new EventArgs();
|
|
if(ContainerLoadControl!=null)
|
|
ContainerLoadControl(this,e);
|
|
IOwnerItemEvents owner=this.GetIOwnerItemEvents();
|
|
if(owner!=null)
|
|
owner.InvokeContainerLoadControl(this,e);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Overriden. Returns the copy of the ControlContainerItem.
|
|
/// </summary>
|
|
/// <returns>Copy of the ControlContainerItem.</returns>
|
|
public override BaseItem Copy()
|
|
{
|
|
DockContainerItem objCopy = new DockContainerItem(this.Name);
|
|
this.CopyToItem(objCopy);
|
|
return objCopy;
|
|
}
|
|
protected override void CopyToItem(BaseItem copy)
|
|
{
|
|
DockContainerItem objCopy=copy as DockContainerItem;
|
|
base.CopyToItem(objCopy);
|
|
objCopy.SetImageIndex(m_ImageIndex);
|
|
if(m_Icon!=null)
|
|
objCopy.Icon=m_Icon.Clone() as Icon;
|
|
if(objCopy.Image!=null)
|
|
objCopy.Image=m_Image.Clone() as Image;
|
|
objCopy.ContainerLoadControl=this.ContainerLoadControl;
|
|
objCopy.InitControl();
|
|
}
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
if (BarUtilities.DisposeItemImages && !this.DesignMode)
|
|
{
|
|
BarUtilities.DisposeImage(ref m_Image);
|
|
BarUtilities.DisposeImage(ref m_Icon);
|
|
}
|
|
m_Control=null;
|
|
base.Dispose(disposing);
|
|
}
|
|
protected internal override void Serialize(ItemSerializationContext context)
|
|
{
|
|
base.Serialize(context);
|
|
System.Xml.XmlElement ThisItem = context.ItemXmlElement;
|
|
System.Xml.XmlElement xmlElem=null, xmlElem2=null;
|
|
// Serialize Images
|
|
if(m_Image!=null || m_ImageIndex>=0)
|
|
{
|
|
xmlElem=ThisItem.OwnerDocument.CreateElement("images");
|
|
ThisItem.AppendChild(xmlElem);
|
|
|
|
if(m_ImageIndex>=0)
|
|
xmlElem.SetAttribute("imageindex",System.Xml.XmlConvert.ToString(m_ImageIndex));
|
|
|
|
if(m_Image!=null)
|
|
{
|
|
xmlElem2=ThisItem.OwnerDocument.CreateElement("image");
|
|
xmlElem2.SetAttribute("type","default");
|
|
xmlElem.AppendChild(xmlElem2);
|
|
BarFunctions.SerializeImage(m_Image,xmlElem2);
|
|
}
|
|
}
|
|
else if(m_Icon!=null)
|
|
{
|
|
xmlElem=ThisItem.OwnerDocument.CreateElement("images");
|
|
ThisItem.AppendChild(xmlElem);
|
|
|
|
xmlElem2=ThisItem.OwnerDocument.CreateElement("image");
|
|
xmlElem2.SetAttribute("type","icon");
|
|
xmlElem.AppendChild(xmlElem2);
|
|
BarFunctions.SerializeIcon(m_Icon,xmlElem2);
|
|
}
|
|
|
|
if(m_MinimumSize.Width!=32 || m_MinimumSize.Height!=32)
|
|
{
|
|
ThisItem.SetAttribute("minw",m_MinimumSize.Width.ToString());
|
|
ThisItem.SetAttribute("minh",m_MinimumSize.Height.ToString());
|
|
}
|
|
|
|
if(m_DefaultFloatingSize.Width!=128 || m_DefaultFloatingSize.Height!=128)
|
|
{
|
|
ThisItem.SetAttribute("defw",m_DefaultFloatingSize.Width.ToString());
|
|
ThisItem.SetAttribute("defh",m_DefaultFloatingSize.Height.ToString());
|
|
}
|
|
|
|
if(m_MinFormClientSize!=64)
|
|
{
|
|
ThisItem.SetAttribute("csize",m_MinFormClientSize.ToString());
|
|
}
|
|
|
|
if(m_PredefinedTabColor!=eTabItemColor.Default)
|
|
ThisItem.SetAttribute("PredefinedTabColor", System.Xml.XmlConvert.ToString(((int)m_PredefinedTabColor)));
|
|
|
|
|
|
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;
|
|
|
|
// Load Images
|
|
foreach(System.Xml.XmlElement xmlElem in ItemXmlSource.ChildNodes)
|
|
{
|
|
if(xmlElem.Name=="images")
|
|
{
|
|
if(xmlElem.HasAttribute("imageindex"))
|
|
m_ImageIndex=System.Xml.XmlConvert.ToInt32(xmlElem.GetAttribute("imageindex"));
|
|
|
|
foreach(System.Xml.XmlElement xmlElem2 in xmlElem.ChildNodes)
|
|
{
|
|
if(xmlElem2.GetAttribute("type")=="default")
|
|
{
|
|
m_Image=BarFunctions.DeserializeImage(xmlElem2);
|
|
m_ImageIndex=-1;
|
|
}
|
|
else if(xmlElem2.GetAttribute("type")=="icon")
|
|
{
|
|
m_Icon=BarFunctions.DeserializeIcon(xmlElem2);
|
|
m_ImageIndex=-1;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(ItemXmlSource.HasAttribute("minw"))
|
|
{
|
|
m_MinimumSize=new Size(System.Xml.XmlConvert.ToInt32(ItemXmlSource.GetAttribute("minw")),System.Xml.XmlConvert.ToInt32(ItemXmlSource.GetAttribute("minh")));
|
|
}
|
|
|
|
if(ItemXmlSource.HasAttribute("defw"))
|
|
{
|
|
m_DefaultFloatingSize=new Size(System.Xml.XmlConvert.ToInt32(ItemXmlSource.GetAttribute("defw")),System.Xml.XmlConvert.ToInt32(ItemXmlSource.GetAttribute("defh")));
|
|
}
|
|
|
|
if(ItemXmlSource.HasAttribute("csize"))
|
|
m_MinFormClientSize=System.Xml.XmlConvert.ToInt32(ItemXmlSource.GetAttribute("csize"));
|
|
else
|
|
m_MinFormClientSize=64;
|
|
|
|
if (ItemXmlSource.HasAttribute("PredefinedTabColor"))
|
|
m_PredefinedTabColor = (eTabItemColor)System.Xml.XmlConvert.ToInt32(ItemXmlSource.GetAttribute("PredefinedTabColor"));
|
|
else
|
|
m_PredefinedTabColor = eTabItemColor.Default;
|
|
|
|
InitControl();
|
|
|
|
if (m_Control == null && context.DockControls != null && context.DockControls.ContainsKey(this.Name))
|
|
{
|
|
this.Control = context.DockControls[this.Name] as System.Windows.Forms.Control;
|
|
context.DockControls.Remove(this.Name);
|
|
}
|
|
|
|
if(ContainerControlDeserialize!=null)
|
|
this.ContainerControlDeserialize(this,new ControlContainerSerializationEventArgs(ItemXmlSource));
|
|
IOwnerItemEvents owner=this.GetIOwnerItemEvents();
|
|
if(owner!=null)
|
|
owner.InvokeContainerControlDeserialize(this,new ControlContainerSerializationEventArgs(ItemXmlSource));
|
|
}
|
|
|
|
private DockItemAccessibleObject _AccessibleObject = null;
|
|
protected override System.Windows.Forms.AccessibleObject CreateAccessibilityInstance()
|
|
{
|
|
if (_AccessibleObject == null)
|
|
_AccessibleObject = new DockItemAccessibleObject(this);
|
|
return _AccessibleObject;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the reference to the contained control.
|
|
/// </summary>
|
|
[System.ComponentModel.Browsable(true),DevCoBrowsable(false),DefaultValue(null),Description("Indicates the control hosted on dockable window"),Category("Docking")]
|
|
public System.Windows.Forms.Control Control
|
|
{
|
|
get
|
|
{
|
|
return m_Control;
|
|
}
|
|
set
|
|
{
|
|
if(m_Control!=null)
|
|
{
|
|
if(m_Control.Parent!=null)
|
|
{
|
|
if(!(this.DesignMode && this.Site!=null))
|
|
{
|
|
m_Control.Visible=false;
|
|
}
|
|
m_Control.Parent.Controls.Remove(m_Control);
|
|
}
|
|
}
|
|
m_Control=value;
|
|
if(m_Control!=null)
|
|
{
|
|
if(m_Control is PanelDockContainer)
|
|
((PanelDockContainer)m_Control).DockContainerItem=this;
|
|
|
|
if(m_Control is System.Windows.Forms.ListBox)
|
|
((System.Windows.Forms.ListBox)m_Control).IntegralHeight=false;
|
|
|
|
if(m_Control.Parent!=null)
|
|
m_Control.Parent.Controls.Remove(m_Control);
|
|
|
|
m_Control.Dock=System.Windows.Forms.DockStyle.None;
|
|
|
|
// Check auto-size property
|
|
PropertyDescriptorCollection props=TypeDescriptor.GetProperties(m_Control);
|
|
if(props.Find("AutoSize",true)!=null)
|
|
{
|
|
props.Find("AutoSize",true).SetValue(m_Control,false);
|
|
}
|
|
|
|
if(!(this.DesignMode && this.Site!=null))
|
|
{
|
|
m_Control.Visible=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);
|
|
if(this.DesignMode && this.Site!=null && m_Control.Visible && !this.Selected)
|
|
m_Control.SendToBack();
|
|
}
|
|
}
|
|
|
|
OnDisplayedChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns category for this item. If item cannot be customzied using the
|
|
/// customize dialog category is empty string.
|
|
/// </summary>
|
|
[Browsable(false),DevCoBrowsable(false),DefaultValue(""),Category("Design"),Description("Indicates item category used to group similar items at design-time.")]
|
|
public override string Category
|
|
{
|
|
get {return base.Category;}
|
|
set {base.Category=value;}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether Click event will be auto repeated when mouse button is kept pressed over the item.
|
|
/// </summary>
|
|
[Browsable(false),DevCoBrowsable(false),DefaultValue(false),Category("Behavior"),Description("Gets or sets whether Click event will be auto repeated when mouse button is kept pressed over the item.")]
|
|
public override bool ClickAutoRepeat
|
|
{
|
|
get {return base.ClickAutoRepeat;}
|
|
set {base.ClickAutoRepeat=value;}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the auto-repeat interval for the click event when mouse button is kept pressed over the item.
|
|
/// </summary>
|
|
[Browsable(false),DevCoBrowsable(false),DefaultValue(600),Category("Behavior"),Description("Gets or sets the auto-repeat interval for the click event when mouse button is kept pressed over the item.")]
|
|
public override int ClickRepeatInterval
|
|
{
|
|
get {return base.ClickRepeatInterval;}
|
|
set {base.ClickRepeatInterval=value;}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets item description. This description is displayed in
|
|
/// Customize dialog to describe the item function in an application.
|
|
/// </summary>
|
|
[Browsable(false),DevCoBrowsable(false),DefaultValue(""),Category("Design"),Description("Indicates description of the item that is displayed during design.")]
|
|
public override string Description
|
|
{
|
|
get {return base.Description;}
|
|
set {base.Description=value;}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets item alignment inside the container.
|
|
/// </summary>
|
|
[Browsable(false),DevCoBrowsable(false),DefaultValue(eItemAlignment.Near),Category("Appearance"),Description("Determines alignment of the item inside the container.")]
|
|
public override eItemAlignment ItemAlignment
|
|
{
|
|
get {return base.ItemAlignment;}
|
|
set {base.ItemAlignment=value;}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the collection of shortcut keys associated with the item.
|
|
/// </summary>
|
|
[Browsable(false),DevCoBrowsable(false),Category("Design"),Description("Indicates list of shortcut keys for this item."),System.ComponentModel.Editor("DevComponents.DotNetBar.Design.ShortcutsDesigner, DevComponents.DotNetBar.Design, Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf",typeof(System.Drawing.Design.UITypeEditor)),System.ComponentModel.TypeConverter("DevComponents.DotNetBar.Design.ShortcutsConverter, DevComponents.DotNetBar.Design, Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf"),System.ComponentModel.DesignerSerializationVisibility(System.ComponentModel.DesignerSerializationVisibility.Hidden)]
|
|
public override ShortcutsCollection Shortcuts
|
|
{
|
|
get {return base.Shortcuts;}
|
|
set {base.Shortcuts=value;}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether item will display sub items.
|
|
/// </summary>
|
|
[Browsable(false),DevCoBrowsable(false),DefaultValue(true),Category("Behavior"),Description("Determines whether sub-items are displayed.")]
|
|
public override bool ShowSubItems
|
|
{
|
|
get {return base.ShowSubItems;}
|
|
set {base.ShowSubItems=value;}
|
|
}
|
|
|
|
// private void ControlResize(object sender, EventArgs e)
|
|
// {
|
|
// if(m_Painting || m_InternalResize)
|
|
// return;
|
|
// m_ControlSize=m_Control.Size;
|
|
// }
|
|
protected override void OnExternalSizeChange()
|
|
{
|
|
//if (this.DesignMode)
|
|
ResizeControl();
|
|
base.OnExternalSizeChange();
|
|
}
|
|
private void ResizeControl()
|
|
{
|
|
if(m_InternalResize)
|
|
return;
|
|
m_InternalResize=true;
|
|
try
|
|
{
|
|
Rectangle r=this.DisplayRectangle;
|
|
|
|
Size objImageSize=GetMaxImageSize();
|
|
bool bOnMenu=this.IsOnMenu;
|
|
if (bOnMenu && EffectiveStyle != eDotNetBarStyle.Office2000)
|
|
{
|
|
objImageSize.Width+=7;
|
|
r.Width-=objImageSize.Width;
|
|
r.X+=objImageSize.Width;
|
|
}
|
|
|
|
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(m_Control!=null)
|
|
{
|
|
r.Inflate(-2, -2);
|
|
if (r.Width > 0 && r.Height > 0)
|
|
{
|
|
if (!m_Control.Size.Equals(r.Size))
|
|
{
|
|
m_Control.SuspendLayout();
|
|
m_Control.Size = r.Size;
|
|
m_Control.ResumeLayout();
|
|
}
|
|
Point loc = r.Location;
|
|
loc.Offset((r.Width - m_Control.Width) / 2, (r.Height - m_Control.Height) / 2);
|
|
if (loc.X != m_Control.Location.X || loc.Y != m_Control.Location.Y)
|
|
m_Control.Location = loc;
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
m_InternalResize=false;
|
|
}
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Overriden. 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 && EffectiveStyle != eDotNetBarStyle.Office2000)
|
|
{
|
|
objImageSize.Width+=7;
|
|
r.Width-=objImageSize.Width;
|
|
r.X+=objImageSize.Width;
|
|
if(this.IsOnCustomizeMenu)
|
|
objImageSize.Width+=objImageSize.Height+8;
|
|
// Draw side bar
|
|
if(!pa.Colors.MenuSide2.IsEmpty)
|
|
{
|
|
System.Drawing.Drawing2D.LinearGradientBrush gradient=BarFunctions.CreateLinearGradientBrush(new Rectangle(m_Rect.Left,m_Rect.Top,objImageSize.Width,m_Rect.Height),pa.Colors.MenuSide,pa.Colors.MenuSide2,pa.Colors.MenuSideGradientAngle);
|
|
g.FillRectangle(gradient,m_Rect.Left,m_Rect.Top,objImageSize.Width,m_Rect.Height);
|
|
gradient.Dispose();
|
|
}
|
|
else
|
|
g.FillRectangle(new SolidBrush(pa.Colors.MenuSide),m_Rect.Left,m_Rect.Top,objImageSize.Width,m_Rect.Height);
|
|
}
|
|
|
|
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 && this.Style==eDotNetBarStyle.OfficeXP)
|
|
//{
|
|
// g.FillRectangle(new SolidBrush(pa.Colors.MenuBackground),r);
|
|
//}
|
|
|
|
// Draw text if needed
|
|
if(m_Control==null)
|
|
{
|
|
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)
|
|
{
|
|
ResizeControl();
|
|
}
|
|
|
|
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.DesignMode)
|
|
{
|
|
r=this.DisplayRectangle;
|
|
r.Inflate(-1,-1);
|
|
DesignTime.DrawDesignTimeSelection(g,r,pa.Colors.ItemDesignTimeBorder);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Overriden. 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();
|
|
|
|
if(m_Control==null)
|
|
{
|
|
// 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.Office2000)
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
else
|
|
m_Rect.Height=m_MinimumSize.Height+4;
|
|
|
|
// Default width
|
|
//if(m_Control!=null)
|
|
m_Rect.Width=m_MinimumSize.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;
|
|
}
|
|
finally
|
|
{
|
|
g.Dispose();
|
|
}
|
|
}
|
|
}
|
|
|
|
Size objImageSize=GetMaxImageSize();
|
|
if (this.IsOnMenu && EffectiveStyle != eDotNetBarStyle.Office2000)
|
|
{
|
|
// 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();
|
|
}
|
|
|
|
protected internal override void OnContainerChanged(object objOldContainer)
|
|
{
|
|
base.OnContainerChanged(objOldContainer);
|
|
ParentControlChanged();
|
|
//this.RefreshBarText();
|
|
}
|
|
|
|
private void ParentControlChanged()
|
|
{
|
|
if(m_Control!=null)
|
|
{
|
|
System.Windows.Forms.Control objCtrl=this.ContainerControl as System.Windows.Forms.Control;
|
|
if(objCtrl!=m_Control.Parent)
|
|
{
|
|
bool bTextBoxMultiLine=false;
|
|
if(m_Control.Parent!=null)
|
|
{
|
|
// Must set the multiline=false on text box becouse it was crashing otherwise under certain conditions
|
|
if(m_Control is System.Windows.Forms.TextBox && ((System.Windows.Forms.TextBox)m_Control).Multiline)
|
|
{
|
|
bTextBoxMultiLine=true;
|
|
((System.Windows.Forms.TextBox)m_Control).Multiline=false;
|
|
}
|
|
m_Control.Parent.Controls.Remove(m_Control);
|
|
}
|
|
|
|
if(objCtrl!=null)
|
|
{
|
|
objCtrl.Controls.Add(m_Control);
|
|
if(m_Control is System.Windows.Forms.TextBox && bTextBoxMultiLine)
|
|
((System.Windows.Forms.TextBox)m_Control).Multiline=true;
|
|
if(m_Control.Visible)
|
|
m_Control.Refresh();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
protected internal override void OnProcessDelayedCommands()
|
|
{
|
|
if(m_DelayedWidth>=0)
|
|
{
|
|
int v=m_DelayedWidth;
|
|
m_DelayedWidth=-1;
|
|
this.Width=v;
|
|
}
|
|
if(m_DelayedHeight>0)
|
|
{
|
|
int v=m_DelayedHeight;
|
|
m_DelayedHeight=-1;
|
|
this.Height=v;
|
|
}
|
|
}
|
|
|
|
protected internal override void OnVisibleChanged(bool newValue)
|
|
{
|
|
if(m_Control!=null && !newValue)
|
|
{
|
|
if(!(this.DesignMode && this.Site!=null))
|
|
m_Control.Visible=newValue;
|
|
else
|
|
{
|
|
if(newValue)
|
|
m_Control.SendToBack();
|
|
else
|
|
m_Control.BringToFront();
|
|
}
|
|
}
|
|
Bar bar=this.ContainerControl as Bar;
|
|
if(bar!=null && bar.LayoutType==eLayoutType.DockContainer)
|
|
{
|
|
bar.OnDockContainerVisibleChanged(this);
|
|
if (bar.AutoHide)
|
|
{
|
|
bar.RefreshAutoHidePanel();
|
|
bar.RefreshDockTab(true);
|
|
}
|
|
else
|
|
bar.RefreshDockTab(true);
|
|
}
|
|
base.OnVisibleChanged(newValue);
|
|
}
|
|
protected override void OnDisplayedChanged()
|
|
{
|
|
if(this.Displayed)
|
|
{
|
|
this.Refresh();
|
|
Bar bar=this.ContainerControl as Bar;
|
|
if (bar != null)
|
|
{
|
|
//bar.MinClientSize = m_MinFormClientSize;
|
|
bar.SyncBarCaption();
|
|
}
|
|
}
|
|
|
|
if(m_Control!=null && !(this.IsOnCustomizeMenu || this.IsOnCustomizeDialog))
|
|
{
|
|
ResizeControl();
|
|
if(!(this.DesignMode && this.Site!=null))
|
|
m_Control.Visible=this.Displayed;
|
|
else
|
|
{
|
|
if(this.Displayed)
|
|
m_Control.BringToFront();
|
|
else
|
|
m_Control.SendToBack();
|
|
ResizeControl();
|
|
}
|
|
}
|
|
base.OnDisplayedChanged();
|
|
}
|
|
|
|
protected override void OnIsOnCustomizeDialogChanged()
|
|
{
|
|
base.OnIsOnCustomizeDialogChanged();
|
|
CustomizeChanged();
|
|
}
|
|
|
|
protected override void OnDesignModeChanged()
|
|
{
|
|
base.OnDesignModeChanged();
|
|
CustomizeChanged();
|
|
}
|
|
|
|
protected override void OnIsOnCustomizeMenuChanged()
|
|
{
|
|
base.OnIsOnCustomizeMenuChanged();
|
|
CustomizeChanged();
|
|
}
|
|
|
|
private void CustomizeChanged()
|
|
{
|
|
if(m_Control!=null)
|
|
{
|
|
if(this.DesignMode && this.Site!=null)
|
|
return;
|
|
|
|
if(this.IsOnCustomizeMenu || this.IsOnCustomizeDialog || this.DesignMode)
|
|
{
|
|
m_Control.Enabled=false;
|
|
}
|
|
else
|
|
{
|
|
if(!(this.DesignMode && this.Site!=null))
|
|
m_Control.Visible=this.Displayed;
|
|
m_Control.Enabled=true;
|
|
}
|
|
}
|
|
}
|
|
|
|
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; // (Font)System.Windows.Forms.SystemInformation.MenuFont;
|
|
}
|
|
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(this.DesignMode && this.Site!=null)
|
|
return;
|
|
|
|
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;
|
|
// 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;
|
|
// this.Refresh();
|
|
// }
|
|
// }
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public override void OnGotFocus()
|
|
{
|
|
base.OnGotFocus();
|
|
if(m_Control==null)
|
|
return;
|
|
if(m_Control.Focused || this.IsOnCustomizeMenu || this.IsOnCustomizeDialog || this.DesignMode)
|
|
return;
|
|
m_Control.Focus();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets a value indicating whether the item is visible.
|
|
/// </summary>
|
|
public override bool Visible
|
|
{
|
|
get
|
|
{
|
|
if(this.IsOnMenu)
|
|
return false;
|
|
Bar objTlb=this.ContainerControl as Bar;
|
|
if(objTlb!=null)
|
|
{
|
|
if(objTlb.BarState==eBarState.Docked || objTlb.BarState==eBarState.Floating || objTlb.BarState==eBarState.AutoHide)
|
|
return base.Visible;
|
|
else
|
|
return false;
|
|
}
|
|
return base.Visible;
|
|
}
|
|
set
|
|
{
|
|
base.Visible=value;
|
|
}
|
|
}
|
|
|
|
// Property Editor support for ImageIndex selection
|
|
[System.ComponentModel.Browsable(false),System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
|
|
public System.Windows.Forms.ImageList ImageList
|
|
{
|
|
get
|
|
{
|
|
IOwner owner=this.GetOwner() as IOwner;
|
|
if(owner!=null)
|
|
return owner.Images;
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Specifies the Tab image. Image specified here is used only on Tab when there are multiple dock containers on Bar.
|
|
/// </summary>
|
|
[Browsable(true),DevCoBrowsable(true),DefaultValue(null),Category("Appearance"),Description("Specifies the Tab image. Image specified here is used only on Tab when there are multiple dock containers on Bar.")]
|
|
public System.Drawing.Image Image
|
|
{
|
|
get
|
|
{
|
|
return m_Image;
|
|
}
|
|
set
|
|
{
|
|
m_Image=value;
|
|
m_TabImage=null;
|
|
Bar bar=this.ContainerControl as Bar;
|
|
if(bar!=null)
|
|
bar.RefreshDockContainerItem(this);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Specifies the index of the Tab image if ImageList is used. Image specified here is used only on Tab when there are multiple dock containers on Bar.
|
|
/// </summary>
|
|
[Browsable(true),DevCoBrowsable(true),DefaultValue(-1),Category("Appearance"),Description("Specifies the index of the Tab image if ImageList is used. Image specified here is used only on Tab when there are multiple dock containers on Bar."),System.ComponentModel.Editor("DevComponents.DotNetBar.Design.ImageIndexEditor, DevComponents.DotNetBar.Design, Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf", typeof(System.Drawing.Design.UITypeEditor)),System.ComponentModel.TypeConverter(typeof(System.Windows.Forms.ImageIndexConverter))]
|
|
public int ImageIndex
|
|
{
|
|
get
|
|
{
|
|
return m_ImageIndex;
|
|
}
|
|
set
|
|
{
|
|
if(m_ImageIndex!=value)
|
|
{
|
|
m_ImageIndex=value;
|
|
if(ShouldSyncProperties)
|
|
BarFunctions.SyncProperty(this, "ImageIndex");
|
|
m_TabImage=null;
|
|
Bar bar=this.ContainerControl as Bar;
|
|
if(bar!=null)
|
|
bar.RefreshDockContainerItem(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Specifies the Button icon. Icons support multiple image sizes and alpha blending.
|
|
/// </summary>
|
|
[Browsable(true),DevCoBrowsable(true),Category("Appearance"),Description("Specifies the Button icon. Icons support multiple image sizes and alpha blending."),DefaultValue(null)]
|
|
public System.Drawing.Icon Icon
|
|
{
|
|
get
|
|
{
|
|
return m_Icon;
|
|
}
|
|
set
|
|
{
|
|
NeedRecalcSize=true;
|
|
m_Icon=value;
|
|
|
|
m_TabImage=null;
|
|
Bar bar=this.ContainerControl as Bar;
|
|
if(bar!=null)
|
|
bar.RefreshDockContainerItem(this);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the predefined tab color. Default value is eTabItemColor.Default which means that default color is used.
|
|
/// </summary>
|
|
[Browsable(true), DevCoBrowsable(true), DefaultValue(eTabItemColor.Default), Category("Style"), Description("Applies predefined color to tab.")]
|
|
public eTabItemColor PredefinedTabColor
|
|
{
|
|
get { return m_PredefinedTabColor; }
|
|
set
|
|
{
|
|
if(m_PredefinedTabColor!=value)
|
|
{
|
|
m_PredefinedTabColor = value;
|
|
Bar bar=this.ContainerControl as Bar;
|
|
if(bar!=null && bar.DockTabControl!=null)
|
|
{
|
|
TabItem tab = GetTabItem(bar.DockTabControl);
|
|
if(tab!=null)
|
|
tab.PredefinedColor=m_PredefinedTabColor;
|
|
}
|
|
if (this.DesignMode)
|
|
{
|
|
System.Windows.Forms.Control c = this.ContainerControl as System.Windows.Forms.Control;
|
|
if(c!=null)
|
|
c.Refresh();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private TabItem GetTabItem(TabStrip dockTabControl)
|
|
{
|
|
foreach (TabItem tab in dockTabControl.Tabs)
|
|
{
|
|
if (tab.AttachedItem == this)
|
|
return tab;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
internal System.Drawing.Image TabImage
|
|
{
|
|
get
|
|
{
|
|
if(m_TabImage==null)
|
|
{
|
|
System.Drawing.Image img=this.GetImage();
|
|
if(img!=null)
|
|
{
|
|
if(img.Width==16 && img.Height==16)
|
|
{
|
|
m_TabImage=(System.Drawing.Image)img.Clone();
|
|
}
|
|
else
|
|
{
|
|
m_TabImage=new Bitmap(img,16,16);
|
|
Graphics g=Graphics.FromImage(m_TabImage);
|
|
g.DrawImage(img,new Rectangle(0,0,16,16),0,0,16,16,GraphicsUnit.Pixel);
|
|
g.Dispose();
|
|
}
|
|
}
|
|
}
|
|
|
|
return m_TabImage;
|
|
}
|
|
}
|
|
|
|
private Image GetImage()
|
|
{
|
|
if(m_Image!=null)
|
|
return m_Image;
|
|
return GetImageFromImageList(m_ImageIndex);
|
|
}
|
|
|
|
internal void SetImageIndex(int iImageIndex)
|
|
{
|
|
m_ImageIndex=iImageIndex;
|
|
}
|
|
|
|
private Image GetImageFromImageList(int ImageIndex)
|
|
{
|
|
if(ImageIndex>=0)
|
|
{
|
|
IOwner owner=this.GetOwner() as IOwner;
|
|
if(owner!=null)
|
|
{
|
|
if(owner.Images!=null && owner.Images.Images.Count>0 && ImageIndex<owner.Images.Images.Count)
|
|
return owner.Images.Images[ImageIndex];
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether tab that dock container item is on is selected.
|
|
/// </summary>
|
|
[Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public bool Selected
|
|
{
|
|
get
|
|
{
|
|
if(this.Visible)
|
|
{
|
|
Bar bar= this.ContainerControl as Bar;
|
|
if(bar!=null)
|
|
{
|
|
return (bar.SelectedDockContainerItem == this);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
set
|
|
{
|
|
if(this.Visible)
|
|
{
|
|
Bar bar= this.ContainerControl as Bar;
|
|
if(bar!=null)
|
|
{
|
|
bar.SelectedDockContainerItem = this;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the width of the item in pixels.
|
|
/// </summary>
|
|
[Browsable(false),DevCoBrowsable(false),DefaultValue(0),Category("Layout"),Description("Indicates the width of the item in pixels."), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public int Width
|
|
{
|
|
get
|
|
{
|
|
return this.DisplayRectangle.Width;
|
|
}
|
|
set
|
|
{
|
|
if(value<m_MinimumSize.Width)
|
|
value=m_MinimumSize.Width;
|
|
if(value>=m_MinimumSize.Width)
|
|
{
|
|
Bar bar=this.ContainerControl as Bar;
|
|
GenericItemContainer parent=this.Parent as GenericItemContainer;
|
|
if(parent!=null && parent.SystemContainer && bar!=null && bar.LayoutType==eLayoutType.DockContainer && bar.Stretch)
|
|
{
|
|
bar.OnDockContainerWidthChanged(this,value);
|
|
m_DelayedWidth=-1;
|
|
}
|
|
else
|
|
m_DelayedWidth=value;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the height of the item in pixels.
|
|
/// </summary>
|
|
[Browsable(false),DevCoBrowsable(true),DefaultValue(0),Category("Layout"),Description("Indicates height of the item in pixels."), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public int Height
|
|
{
|
|
get
|
|
{
|
|
return this.DisplayRectangle.Height;
|
|
}
|
|
set
|
|
{
|
|
if(value<m_MinimumSize.Height)
|
|
value=m_MinimumSize.Height;
|
|
if(value>=m_MinimumSize.Height)
|
|
{
|
|
Bar bar=this.ContainerControl as Bar;
|
|
GenericItemContainer parent=this.Parent as GenericItemContainer;
|
|
if(parent!=null && parent.SystemContainer && bar!=null && bar.LayoutType==eLayoutType.DockContainer && bar.Stretch)
|
|
{
|
|
bar.OnDockContainerHeightChanged(this,value);
|
|
m_DelayedHeight=-1;
|
|
}
|
|
else
|
|
m_DelayedHeight=value;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the minimum size of the item. When used please note that layout logic for dockable windows expects that
|
|
/// all DockContainerItems that are in particular docking side have exact same minimum size. When setting this property it is
|
|
/// best to set the same value for all DockContainerItem instances you create.
|
|
/// </summary>
|
|
[Browsable(false),DevCoBrowsable(false),Category("Layout"),Description("Gets or sets the minimum size of the item.")]
|
|
public System.Drawing.Size MinimumSize
|
|
{
|
|
get
|
|
{
|
|
return m_MinimumSize;
|
|
}
|
|
set
|
|
{
|
|
m_MinimumSize=value;
|
|
if(m_MinimumSize.Width>m_DefaultFloatingSize.Width)
|
|
m_DefaultFloatingSize.Width=m_MinimumSize.Width;
|
|
if(m_MinimumSize.Height>m_DefaultFloatingSize.Height)
|
|
m_DefaultFloatingSize.Height=m_MinimumSize.Height;
|
|
Bar bar=this.ContainerControl as Bar;
|
|
if(bar!=null)
|
|
bar.OnDockContainerMinimumSizeChanged(this);
|
|
if(m_MinimumSize.Width>this.Width)
|
|
this.Width=m_MinimumSize.Width;
|
|
if(m_MinimumSize.Height>this.Height)
|
|
this.Height=m_MinimumSize.Height;
|
|
}
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public bool ShouldSerializeMinimumSize()
|
|
{
|
|
if(m_MinimumSize.Width!=32 || m_MinimumSize.Height!=32)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public void ResetMinimumSize()
|
|
{
|
|
this.MinimumSize = new Size(32,32);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the default floating size of the Bar that is containing this item.
|
|
/// </summary>
|
|
[Browsable(true),DevCoBrowsable(true),System.ComponentModel.Category("Layout"),System.ComponentModel.Description("Gets or sets the default floating size of the Bar that is containing this item.")]
|
|
public System.Drawing.Size DefaultFloatingSize
|
|
{
|
|
get
|
|
{
|
|
return m_DefaultFloatingSize;
|
|
}
|
|
set
|
|
{
|
|
if(value.Width<m_MinimumSize.Width)
|
|
value.Width=m_MinimumSize.Width;
|
|
if(value.Height<m_MinimumSize.Height)
|
|
value.Height=m_MinimumSize.Height;
|
|
m_DefaultFloatingSize=value;
|
|
}
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public bool ShouldSerializeDefaultFloatingSize()
|
|
{
|
|
if(m_DefaultFloatingSize.Width!=128 || m_DefaultFloatingSize.Height!=128)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the minimum size of the form client area that is tried to maintain when dockable window is resized.
|
|
/// </summary>
|
|
[Obsolete("This property is obsolete and it will be removed in next version"), EditorBrowsable(EditorBrowsableState.Never),Browsable(false),DevCoBrowsable(false),System.ComponentModel.DefaultValue(64),System.ComponentModel.Category("Layout"),System.ComponentModel.Description("Gets or sets the minimum size of the form client area that is tried to maintain when dockable window is resized."), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public int MinFormClientSize
|
|
{
|
|
get {return m_MinFormClientSize;}
|
|
set
|
|
{
|
|
m_MinFormClientSize=value;
|
|
//if(this.Displayed)
|
|
//{
|
|
// Bar bar=this.ContainerControl as Bar;
|
|
// if(bar!=null)
|
|
// bar.MinClientSize=m_MinFormClientSize;
|
|
//}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether the item expands automatically to fill out the remaining space inside the container. Applies to Items on stretchable, no-wrap Bars only.
|
|
/// </summary>
|
|
[Browsable(false),DevCoBrowsable(false),DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public override bool Stretch
|
|
{
|
|
get
|
|
{
|
|
return base.Stretch;
|
|
}
|
|
set
|
|
{
|
|
base.Stretch=value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether item can be customized by end user.
|
|
/// </summary>
|
|
[Browsable(false),DevCoBrowsable(false),DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),Category("Behavior"),Description("Indicates whether item can be customized by user.")]
|
|
public override bool CanCustomize
|
|
{
|
|
get
|
|
{
|
|
return base.CanCustomize;
|
|
}
|
|
set
|
|
{
|
|
base.CanCustomize=value;
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Occurs after an item has been removed.
|
|
/// </summary>
|
|
/// <param name="item">Item being removed.</param>
|
|
protected internal override void OnAfterItemRemoved(BaseItem item, int itemIndex)
|
|
{
|
|
base.OnAfterItemRemoved(item, itemIndex);
|
|
ParentControlChanged();
|
|
}
|
|
|
|
[System.ComponentModel.Browsable(false),System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
|
|
public override bool IsWindowed
|
|
{
|
|
get {return true;}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Occurs after text has changed.
|
|
/// </summary>
|
|
protected override void OnTextChanged()
|
|
{
|
|
base.OnTextChanged();
|
|
if(this.ContainerControl is Bar /*&& !this.Displayed*/) // Refresh Tab Text even when dock container item is selected.
|
|
((Bar)this.ContainerControl).RefreshDockContainerItem(this);
|
|
}
|
|
|
|
protected override void OnTooltipChanged()
|
|
{
|
|
base.OnTooltipChanged();
|
|
if (this.ContainerControl is Bar) // Refresh Tab Tooltip even when dock container item is selected.
|
|
((Bar)this.ContainerControl).RefreshDockContainerItem(this);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns whether item is in design mode or not.
|
|
/// </summary>
|
|
[System.ComponentModel.Browsable(false),DevCoBrowsable(false)]
|
|
public override bool DesignMode
|
|
{
|
|
get
|
|
{
|
|
return (base.DesignMode || this.Site!=null && this.Site.DesignMode);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Occurs after item visual style has changed.
|
|
/// </summary>
|
|
protected override void OnStyleChanged()
|
|
{
|
|
base.OnStyleChanged();
|
|
if(m_Control is PanelDockContainer)
|
|
{
|
|
if(!((PanelDockContainer)m_Control).UseCustomStyle)
|
|
((PanelDockContainer)m_Control).ColorSchemeStyle=this.Style;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether item is global or not.
|
|
/// This flag is used to propagate property changes to all items with the same name.
|
|
/// Setting for example Visible property on the item that has GlobalItem set to true will
|
|
/// set visible property to the same value on all items with the same name.
|
|
/// </summary>
|
|
[Browsable(true), DevCoBrowsable(true), DefaultValue(false), Category("Behavior"), Description("Indicates whether certain global properties are propagated to all items with the same name when changed.")]
|
|
public override bool GlobalItem
|
|
{
|
|
get { return base.GlobalItem; }
|
|
set { base.GlobalItem = value; }
|
|
}
|
|
|
|
private eDockContainerClose _CanClose = eDockContainerClose.Inherit;
|
|
/// <summary>
|
|
/// Gets or sets the close button behavior on the host Bar. Default value is eDockContainerClose.Inherit which means that Bar.CanHide will control whether DockContainerItem can be closed.
|
|
/// </summary>
|
|
[Category("Behavior"), DefaultValue(eDockContainerClose.Inherit), Description("Specifies close button behavior on the host Bar. Default value is eDockContainerClose.Inherit which means that Bar.CanHide will control whether DockContainerItem can be closed.")]
|
|
public eDockContainerClose CanClose
|
|
{
|
|
get { return _CanClose; }
|
|
set
|
|
{
|
|
if (value != _CanClose)
|
|
{
|
|
eDockContainerClose oldValue = _CanClose;
|
|
_CanClose = value;
|
|
OnCanCloseChanged(oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void OnCanCloseChanged(eDockContainerClose oldValue, eDockContainerClose newValue)
|
|
{
|
|
Bar bar = this.ContainerControl as Bar;
|
|
if(bar!=null)
|
|
bar.DockContainerItemCanCloseChanged(this, oldValue, newValue);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets a value indicating whether the item is enabled.
|
|
/// </summary>
|
|
[System.ComponentModel.Browsable(false), DevCoBrowsable(false), System.ComponentModel.DefaultValue(true), System.ComponentModel.Category("Behavior"), System.ComponentModel.Description("Indicates whether is item enabled.")]
|
|
public override bool Enabled
|
|
{
|
|
get { return base.Enabled; }
|
|
set { base.Enabled = value; }
|
|
}
|
|
|
|
}
|
|
|
|
#region DockItemAccessibleObject
|
|
public class DockItemAccessibleObject : System.Windows.Forms.AccessibleObject
|
|
{
|
|
private DockContainerItem m_Owner = null;
|
|
private bool m_Hot = false;
|
|
public DockItemAccessibleObject(DockContainerItem owner)
|
|
{
|
|
m_Owner = owner;
|
|
|
|
}
|
|
|
|
internal DockContainerItem Owner
|
|
{
|
|
get { return m_Owner; }
|
|
}
|
|
|
|
public override string Name
|
|
{
|
|
get
|
|
{
|
|
if (m_Owner == null)
|
|
return "";
|
|
|
|
if (m_Owner.AccessibleName != "")
|
|
return m_Owner.AccessibleName;
|
|
|
|
if (m_Owner.Text != null)
|
|
return m_Owner.Text.Replace("&", "");
|
|
|
|
return m_Owner.Tooltip;
|
|
}
|
|
set
|
|
{
|
|
m_Owner.AccessibleName = value;
|
|
}
|
|
}
|
|
|
|
public override string Description
|
|
{
|
|
get
|
|
{
|
|
if (m_Owner == null)
|
|
return "";
|
|
if (m_Owner.AccessibleDescription != "")
|
|
return m_Owner.AccessibleDescription;
|
|
return "";
|
|
}
|
|
}
|
|
|
|
public override System.Windows.Forms.AccessibleRole Role
|
|
{
|
|
get
|
|
{
|
|
if (m_Owner == null || !m_Owner.IsAccessible)
|
|
return System.Windows.Forms.AccessibleRole.None;
|
|
|
|
if (m_Owner.AccessibleRole != System.Windows.Forms.AccessibleRole.Default)
|
|
return m_Owner.AccessibleRole;
|
|
return System.Windows.Forms.AccessibleRole.Pane;
|
|
}
|
|
}
|
|
|
|
public override System.Windows.Forms.AccessibleStates State
|
|
{
|
|
get
|
|
{
|
|
if (m_Owner == null)
|
|
return System.Windows.Forms.AccessibleStates.Unavailable;
|
|
//System.Diagnostics.Trace.WriteLine("Getting state for "+m_Owner.Text);
|
|
System.Windows.Forms.AccessibleStates state = 0;
|
|
|
|
if (!m_Owner.IsAccessible)
|
|
return System.Windows.Forms.AccessibleStates.Unavailable;
|
|
|
|
if (!m_Owner.Displayed || !m_Owner.Visible)
|
|
state |= System.Windows.Forms.AccessibleStates.Invisible;
|
|
else if (!m_Owner.GetEnabled())
|
|
{
|
|
state = System.Windows.Forms.AccessibleStates.Unavailable;
|
|
return state;
|
|
}
|
|
else
|
|
{
|
|
if (m_Owner.Selected)
|
|
state |= (System.Windows.Forms.AccessibleStates.Selected);
|
|
else
|
|
state |= System.Windows.Forms.AccessibleStates.Selectable | System.Windows.Forms.AccessibleStates.Focusable;
|
|
}
|
|
|
|
return state;
|
|
}
|
|
}
|
|
|
|
public override System.Windows.Forms.AccessibleObject Parent
|
|
{
|
|
get
|
|
{
|
|
if (m_Owner == null)
|
|
return null;
|
|
if (m_Owner.Parent != null)
|
|
{
|
|
if (!(m_Owner.Parent is GenericItemContainer && ((GenericItemContainer)m_Owner.Parent).SystemContainer))
|
|
return m_Owner.Parent.AccessibleObject;
|
|
}
|
|
|
|
System.Windows.Forms.Control control = m_Owner.ContainerControl as System.Windows.Forms.Control;
|
|
if (control != null)
|
|
return control.AccessibilityObject;
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public override System.Drawing.Rectangle Bounds
|
|
{
|
|
get
|
|
{
|
|
if (m_Owner == null)
|
|
return System.Drawing.Rectangle.Empty;
|
|
|
|
System.Windows.Forms.Control objCtrl = m_Owner.ContainerControl as System.Windows.Forms.Control;
|
|
if (objCtrl != null)
|
|
return objCtrl.RectangleToScreen(m_Owner.DisplayRectangle);
|
|
return m_Owner.Bounds;
|
|
}
|
|
}
|
|
|
|
public override int GetChildCount()
|
|
{
|
|
if (m_Owner == null)
|
|
return 0;
|
|
return m_Owner.Control != null ? 1 : 0;
|
|
}
|
|
|
|
public override System.Windows.Forms.AccessibleObject GetChild(int iIndex)
|
|
{
|
|
if (m_Owner == null || iIndex < 0 || iIndex >= 1 || m_Owner.Control == null)
|
|
return null;
|
|
return m_Owner.Control.AccessibilityObject;
|
|
}
|
|
|
|
public override string DefaultAction
|
|
{
|
|
get
|
|
{
|
|
if (m_Owner.AccessibleDefaultActionDescription != "")
|
|
return m_Owner.AccessibleDefaultActionDescription;
|
|
return "Select";
|
|
}
|
|
}
|
|
|
|
public override void DoDefaultAction()
|
|
{
|
|
if (m_Owner == null)
|
|
return;
|
|
|
|
m_Owner.Selected = true;
|
|
//System.Windows.Forms.Control cont = m_Owner.ContainerControl as System.Windows.Forms.Control;
|
|
//if (cont is MenuPanel && !(cont is IAccessibilitySupport))
|
|
//{
|
|
// cont = ((MenuPanel)cont).ParentItem.ContainerControl as System.Windows.Forms.Control;
|
|
//}
|
|
|
|
//IAccessibilitySupport ias = cont as IAccessibilitySupport;
|
|
//if (ias != null)
|
|
//{
|
|
// ias.DoDefaultActionItem = m_Owner;
|
|
// NativeFunctions.PostMessage(cont.Handle, NativeFunctions.WM_USER + 107, IntPtr.Zero, IntPtr.Zero);
|
|
//}
|
|
|
|
base.DoDefaultAction();
|
|
}
|
|
|
|
public override string KeyboardShortcut
|
|
{
|
|
get
|
|
{
|
|
return m_Owner.ShortcutString;
|
|
}
|
|
}
|
|
|
|
public override System.Windows.Forms.AccessibleObject GetSelected()
|
|
{
|
|
if (m_Owner == null)
|
|
return base.GetSelected();
|
|
|
|
return base.GetSelected();
|
|
}
|
|
|
|
public override System.Windows.Forms.AccessibleObject HitTest(int x, int y)
|
|
{
|
|
if (m_Owner == null)
|
|
return base.HitTest(x, y);
|
|
|
|
Point screen = new Point(x, y);
|
|
if (m_Owner.Control != null)
|
|
{
|
|
System.Windows.Forms.Control cont = m_Owner.Control;
|
|
if (cont != null)
|
|
{
|
|
Point p = cont.PointToClient(screen);
|
|
if (cont.ClientRectangle.Contains(p))
|
|
return cont.AccessibilityObject;
|
|
}
|
|
}
|
|
return base.HitTest(x, y);
|
|
}
|
|
|
|
public override System.Windows.Forms.AccessibleObject Navigate(System.Windows.Forms.AccessibleNavigation navdir)
|
|
{
|
|
if (m_Owner == null)
|
|
return base.Navigate(navdir);
|
|
|
|
if (navdir == System.Windows.Forms.AccessibleNavigation.FirstChild || navdir == System.Windows.Forms.AccessibleNavigation.LastChild)
|
|
{
|
|
if (m_Owner.Control != null)
|
|
return m_Owner.Control.AccessibilityObject;
|
|
}
|
|
|
|
return base.Navigate(navdir);
|
|
}
|
|
|
|
}
|
|
#endregion
|
|
|
|
/// <summary>
|
|
/// Specifies the behavior of the close button on host bar for the DockContainerItem.
|
|
/// </summary>
|
|
public enum eDockContainerClose
|
|
{
|
|
/// <summary>
|
|
/// Closing of the bar is inherited from the host bar. Bar.CanHide property will control close button visibility.
|
|
/// </summary>
|
|
Inherit,
|
|
/// <summary>
|
|
/// Closing of the DockContainerItem is allowed.
|
|
/// </summary>
|
|
Yes,
|
|
/// <summary>
|
|
/// Closing of DockContainerItem is not allowed.
|
|
/// </summary>
|
|
No
|
|
}
|
|
}
|