2582 lines
83 KiB
C#
2582 lines
83 KiB
C#
namespace DevComponents.DotNetBar
|
|
{
|
|
using System;
|
|
using System.Drawing;
|
|
using System.Collections;
|
|
using System.Windows.Forms;
|
|
|
|
/// <summary>
|
|
/// Defines the generic container item that is used by toolbar, menu bar and other control for item layout.
|
|
/// </summary>
|
|
[System.ComponentModel.ToolboxItem(false),System.ComponentModel.DesignTimeVisible(false)]
|
|
public class GenericItemContainer:ImageItem, IDesignTimeProvider
|
|
{
|
|
#region Private Variables
|
|
protected int m_PaddingLeft, m_PaddingTop, m_PaddingBottom, m_PaddingRight, m_ItemSpacing;
|
|
private int m_FirstItemSpacing = 0;
|
|
protected eBorderType m_BorderType;
|
|
protected internal Color m_BackgroundColor;
|
|
protected bool m_WrapItems;
|
|
protected DisplayMoreItem m_MoreItems;
|
|
private bool m_MoreItemsOnMenu;
|
|
private bool m_EqualButtonSize;
|
|
private int m_DisplayedItems=0;
|
|
|
|
//private bool m_Stretch;
|
|
private bool m_SystemContainer;
|
|
private bool m_HaveCustomizeItem=false;
|
|
|
|
private eLayoutType m_LayoutType=eLayoutType.Toolbar;
|
|
|
|
private bool m_Scroll=false; // Indicates whether we use scrolling in container. Applies only to the "Task List" container.
|
|
private int m_ScrollTopPosition=0; // Indicates the first visible item from the top when scroll is used.
|
|
private bool m_TopScroll=false, m_BottomScroll=false;
|
|
private ScrollButton m_TopScrollButton=null,m_BottomScrollButton=null;
|
|
|
|
// Used to eat the mouse move messages when user is using the keyboard to browse through the
|
|
// top level menus. The problem was that on each repaint the mouse move was fired even though the
|
|
// mouse did not move at all. So if mouse was over an menu item it was not possible to switch to the
|
|
// new menu item becouse mouse was "holding" the focus.
|
|
private bool m_IgnoreDuplicateMouseMove=false;
|
|
private System.Windows.Forms.MouseEventArgs m_LastMouseMoveEvent=null;
|
|
private int m_MinWidth=0, m_MinHeight=0;
|
|
private bool m_Painting=false;
|
|
private bool m_EventHeight=true;
|
|
private bool m_UseMoreItemsButton=true;
|
|
private eContainerVerticalAlignment m_ToolbarItemsAlign = eContainerVerticalAlignment.Bottom;
|
|
private bool m_TrackSubItemsImageSize = true;
|
|
internal bool OverflowEnabled = true;
|
|
#endregion
|
|
|
|
#region Events
|
|
/// <summary>
|
|
/// Occurs when new item is added to the container.
|
|
/// </summary>
|
|
internal EventHandler ItemAdded;
|
|
#endregion
|
|
|
|
public GenericItemContainer()
|
|
{
|
|
// We contain other controls
|
|
m_IsContainer=true;
|
|
m_PaddingLeft=1;
|
|
m_PaddingTop=1;
|
|
m_PaddingBottom=1;
|
|
m_PaddingRight=1;
|
|
m_ItemSpacing=0;
|
|
m_BackgroundColor=Color.Empty;
|
|
m_BorderType=eBorderType.None;
|
|
m_WrapItems=false;
|
|
m_MoreItems=null;
|
|
m_EqualButtonSize=false;
|
|
//m_Stretch=false;
|
|
m_MoreItemsOnMenu=false;
|
|
m_SystemContainer=false;
|
|
this.AccessibleRole=System.Windows.Forms.AccessibleRole.Grouping;
|
|
}
|
|
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
if(m_TopScrollButton!=null)
|
|
{
|
|
if(m_TopScrollButton.Parent!=null)
|
|
m_TopScrollButton.Parent.Controls.Remove(m_TopScrollButton);
|
|
m_TopScrollButton.Dispose();
|
|
m_TopScrollButton=null;
|
|
}
|
|
|
|
if(m_BottomScrollButton!=null)
|
|
{
|
|
if(m_BottomScrollButton.Parent!=null)
|
|
m_BottomScrollButton.Parent.Controls.Remove(m_BottomScrollButton);
|
|
m_BottomScrollButton.Dispose();
|
|
m_BottomScrollButton=null;
|
|
}
|
|
|
|
base.Dispose(disposing);
|
|
}
|
|
|
|
internal int MinHeight
|
|
{
|
|
get {return m_MinHeight;}
|
|
set {m_MinHeight=value;}
|
|
}
|
|
internal int MinWidth
|
|
{
|
|
get {return m_MinWidth;}
|
|
set {m_MinWidth=value;}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns copy of GenericItemContainer item
|
|
/// </summary>
|
|
public override BaseItem Copy()
|
|
{
|
|
GenericItemContainer objCopy=new GenericItemContainer();
|
|
this.CopyToItem(objCopy);
|
|
|
|
return objCopy;
|
|
}
|
|
protected override void CopyToItem(BaseItem copy)
|
|
{
|
|
GenericItemContainer objCopy=copy as GenericItemContainer;
|
|
base.CopyToItem(objCopy);
|
|
|
|
objCopy.WrapItems=m_WrapItems;
|
|
objCopy.EqualButtonSize=m_EqualButtonSize;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Paints this base container
|
|
/// </summary>
|
|
public override void Paint(ItemPaintArgs pa)
|
|
{
|
|
if (this.SuspendLayout || m_Painting)
|
|
return;
|
|
eDotNetBarStyle effectiveStyle = EffectiveStyle;
|
|
m_Painting = true;
|
|
try
|
|
{
|
|
System.Drawing.Graphics g = pa.Graphics;
|
|
|
|
if (m_NeedRecalcSize)
|
|
{
|
|
RecalcSize();
|
|
}
|
|
int x = m_Rect.Left, y = m_Rect.Top;
|
|
Rectangle thisRect = new Rectangle(m_Rect.Left, m_Rect.Top, m_Rect.Width, m_Rect.Height);
|
|
|
|
switch (m_BorderType)
|
|
{
|
|
case eBorderType.Bump:
|
|
System.Windows.Forms.ControlPaint.DrawBorder3D(g, m_Rect, System.Windows.Forms.Border3DStyle.Bump, System.Windows.Forms.Border3DSide.All);
|
|
thisRect.Inflate(-2, -2);
|
|
break;
|
|
case eBorderType.Etched:
|
|
System.Windows.Forms.ControlPaint.DrawBorder3D(g, m_Rect, System.Windows.Forms.Border3DStyle.Etched, System.Windows.Forms.Border3DSide.All);
|
|
thisRect.Inflate(-2, -2);
|
|
break;
|
|
case eBorderType.Raised:
|
|
System.Windows.Forms.ControlPaint.DrawBorder3D(g, m_Rect, System.Windows.Forms.Border3DStyle.RaisedInner, System.Windows.Forms.Border3DSide.All);
|
|
thisRect.Inflate(-2, -2);
|
|
break;
|
|
case eBorderType.Sunken:
|
|
System.Windows.Forms.ControlPaint.DrawBorder3D(g, m_Rect, System.Windows.Forms.Border3DStyle.SunkenOuter, System.Windows.Forms.Border3DSide.All);
|
|
thisRect.Inflate(-2, -2);
|
|
break;
|
|
case eBorderType.SingleLine:
|
|
// TODO: Beta 2 fix --> g.DrawRectangle(new Pen(SystemBrushes.ControlDark,1),m_Rect);
|
|
Pen pen = new Pen(SystemBrushes.ControlDark, 1);
|
|
NativeFunctions.DrawRectangle(g, pen, m_Rect);
|
|
pen.Dispose();
|
|
thisRect.Inflate(-1, -1);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (!m_BackgroundColor.IsEmpty)
|
|
{
|
|
SolidBrush brush = new SolidBrush(m_BackgroundColor);
|
|
g.FillRectangle(brush, thisRect);
|
|
brush.Dispose();
|
|
}
|
|
//else if(m_Style==eDotNetBarStyle.Office2000 || this.IsOnMenuBar)
|
|
// g.FillRectangle(SystemBrushes.Control,thisRect);
|
|
//else
|
|
// g.FillRectangle(new SolidBrush(ColorFunctions.ToolMenuFocusBackColor(g)),thisRect);
|
|
g.SetClip(thisRect);
|
|
if (m_SubItems != null)
|
|
{
|
|
BaseItem objItem = null;
|
|
int iDisplayed = 0;
|
|
ThemeToolbar theme = null;
|
|
ThemeToolbarParts part = ThemeToolbarParts.Separator;
|
|
ThemeToolbarStates state = ThemeToolbarStates.Normal;
|
|
if (this.IsThemed)
|
|
theme = pa.ThemeToolbar;
|
|
|
|
for (int iCurrentItem = 0; iCurrentItem < m_SubItems.Count; iCurrentItem++)
|
|
{
|
|
objItem = m_SubItems[iCurrentItem] as BaseItem;
|
|
if (objItem.Visible && objItem.Displayed)
|
|
{
|
|
if (objItem.BeginGroup && iDisplayed > 0 && m_LayoutType != eLayoutType.DockContainer && !(objItem is ItemContainer && BarFunctions.IsOffice2007Style(objItem.EffectiveStyle)))
|
|
{
|
|
if (m_Orientation == eOrientation.Vertical || m_LayoutType == eLayoutType.TaskList)
|
|
{
|
|
if (objItem.TopInternal == m_PaddingTop + m_Rect.Top || objItem.LeftInternal > m_PaddingLeft + m_Rect.Left)
|
|
{
|
|
// Vertical line on the left side
|
|
if (effectiveStyle == eDotNetBarStyle.Office2000)
|
|
System.Windows.Forms.ControlPaint.DrawBorder3D(g, objItem.LeftInternal - 4, objItem.TopInternal + 1, 2, m_Rect.Height - m_PaddingTop - m_PaddingBottom - 4, System.Windows.Forms.Border3DStyle.Etched, System.Windows.Forms.Border3DSide.Left);
|
|
else
|
|
{
|
|
if (theme != null)
|
|
{
|
|
part = ThemeToolbarParts.Separator;
|
|
theme.DrawBackground(g, part, state, new Rectangle(objItem.LeftInternal - 4, objItem.TopInternal + 1, 6, m_Rect.Height - m_PaddingBottom - 2));
|
|
}
|
|
else
|
|
{
|
|
using (Pen pen = new Pen(pa.Colors.ItemSeparator))
|
|
{
|
|
if (effectiveStyle == eDotNetBarStyle.OfficeXP)
|
|
g.DrawLine(pen, objItem.LeftInternal - 2, objItem.TopInternal + 1, objItem.LeftInternal - 2, m_Rect.Bottom - m_PaddingBottom - 2);
|
|
else
|
|
{
|
|
g.DrawLine(pen, objItem.LeftInternal - 2, objItem.TopInternal + 2, objItem.LeftInternal - 2, m_Rect.Bottom - m_PaddingBottom - 4);
|
|
Pen penLight = new Pen(pa.Colors.ItemSeparatorShade, 1);
|
|
g.DrawLine(penLight, objItem.LeftInternal - 1, objItem.TopInternal + 3, objItem.LeftInternal - 1, m_Rect.Bottom - m_PaddingBottom - 5);
|
|
penLight.Dispose();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Point start = new Point(objItem.LeftInternal + m_PaddingLeft, objItem.TopInternal - 2);
|
|
Point end = new Point(objItem.DisplayRectangle.Right - m_PaddingRight, objItem.TopInternal - 2);
|
|
if (this.LayoutType == eLayoutType.TaskList)
|
|
{
|
|
start.X = this.LeftInternal + 1;
|
|
end.X = this.DisplayRectangle.Right - 2;
|
|
}
|
|
|
|
// Horizontal line
|
|
if (effectiveStyle == eDotNetBarStyle.Office2000)
|
|
System.Windows.Forms.ControlPaint.DrawBorder3D(g, m_Rect.Left + m_PaddingLeft + 2, objItem.TopInternal - 4, objItem.WidthInternal - 2, 2, System.Windows.Forms.Border3DStyle.Etched, System.Windows.Forms.Border3DSide.Top);
|
|
else
|
|
{
|
|
if (theme != null)
|
|
{
|
|
part = ThemeToolbarParts.SeparatorVert;
|
|
theme.DrawBackground(g, part, state, new Rectangle(start.X, start.Y, end.X - start.X, 6));
|
|
}
|
|
else
|
|
{
|
|
using (Pen pen = new Pen(pa.Colors.ItemSeparator))
|
|
{
|
|
if (effectiveStyle == eDotNetBarStyle.OfficeXP)
|
|
g.DrawLine(pen, start, end);
|
|
else
|
|
{
|
|
g.DrawLine(pen, start, end);
|
|
start.Offset(0, 1);
|
|
end.Offset(0, 1);
|
|
using (Pen penLight = new Pen(pa.Colors.ItemSeparatorShade, 1))
|
|
g.DrawLine(penLight, start, end);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (objItem.TopInternal == m_PaddingTop + m_Rect.Top || objItem.LeftInternal > m_PaddingLeft + m_Rect.Left)
|
|
{
|
|
// Vertical line on the left side
|
|
if (effectiveStyle == eDotNetBarStyle.Office2000)
|
|
System.Windows.Forms.ControlPaint.DrawBorder3D(g, objItem.LeftInternal - 4, objItem.TopInternal + 1, 2, objItem.HeightInternal - 2, System.Windows.Forms.Border3DStyle.Etched, System.Windows.Forms.Border3DSide.Left);
|
|
else
|
|
{
|
|
if (theme != null)
|
|
{
|
|
part = ThemeToolbarParts.Separator;
|
|
theme.DrawBackground(g, part, state, new Rectangle(objItem.LeftInternal - 4, objItem.TopInternal + 1, 6, objItem.HeightInternal - 3));
|
|
}
|
|
else
|
|
{
|
|
using (Pen pen = new Pen(pa.Colors.ItemSeparator))
|
|
{
|
|
if (effectiveStyle == eDotNetBarStyle.OfficeXP)
|
|
g.DrawLine(pen, objItem.LeftInternal - 2, objItem.TopInternal + 1, objItem.LeftInternal - 2, objItem.TopInternal + 1 + objItem.HeightInternal - 3);
|
|
else
|
|
{
|
|
g.DrawLine(pen, objItem.LeftInternal - 2, objItem.TopInternal + 4, objItem.LeftInternal - 2, objItem.TopInternal + 4 + objItem.HeightInternal - 8);
|
|
Pen penLight = new Pen(pa.Colors.ItemSeparatorShade, 1);
|
|
g.DrawLine(penLight, objItem.LeftInternal - 1, objItem.TopInternal + 5, objItem.LeftInternal - 1, objItem.TopInternal + 5 + objItem.HeightInternal - 8);
|
|
penLight.Dispose();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Horizontal line
|
|
if (effectiveStyle == eDotNetBarStyle.Office2000)
|
|
System.Windows.Forms.ControlPaint.DrawBorder3D(g, m_Rect.Left + m_PaddingLeft + 2, objItem.TopInternal - 4, m_Rect.Width - m_PaddingLeft - m_PaddingRight - 4, 2, System.Windows.Forms.Border3DStyle.Etched, System.Windows.Forms.Border3DSide.Top);
|
|
else
|
|
{
|
|
if (theme != null)
|
|
{
|
|
part = ThemeToolbarParts.SeparatorVert;
|
|
theme.DrawBackground(g, part, state, new Rectangle(m_Rect.Left + m_PaddingLeft + 2, objItem.TopInternal - 4, m_Rect.Width - m_PaddingRight - 2, 6));
|
|
}
|
|
else
|
|
{
|
|
using (Pen pen = new Pen(pa.Colors.ItemSeparator))
|
|
{
|
|
if (effectiveStyle == eDotNetBarStyle.OfficeXP)
|
|
g.DrawLine(pen, m_Rect.Left + m_PaddingLeft + 2, objItem.TopInternal - 2, m_Rect.Right - m_PaddingRight - 2, objItem.TopInternal - 2);
|
|
else
|
|
{
|
|
g.DrawLine(pen, m_Rect.Left + m_PaddingLeft + 2, objItem.TopInternal - 2, m_Rect.Right - m_PaddingRight - 2, objItem.TopInternal - 2);
|
|
Pen penLight = new Pen(pa.Colors.ItemSeparatorShade, 1);
|
|
g.DrawLine(penLight, m_Rect.Left + m_PaddingLeft + 6, objItem.TopInternal - 1, m_Rect.Right - m_PaddingRight - 4, objItem.TopInternal - 1);
|
|
penLight.Dispose();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (g.ClipBounds.IntersectsWith(objItem.DisplayRectangle))
|
|
objItem.Paint(pa);
|
|
iDisplayed++;
|
|
}
|
|
|
|
// Paint the Display More Items button if needed
|
|
if (m_MoreItems != null)
|
|
{
|
|
//Point loc = GetMoreItemsLocation();
|
|
//m_MoreItems.LeftInternal = loc.X;
|
|
//m_MoreItems.TopInternal = loc.Y;
|
|
|
|
//if(m_Orientation==eOrientation.Vertical)
|
|
//{
|
|
// m_MoreItems.LeftInternal=m_Rect.Left+m_PaddingLeft;
|
|
// m_MoreItems.TopInternal=m_Rect.Bottom-m_MoreItems.HeightInternal-m_PaddingBottom;
|
|
//}
|
|
//else
|
|
//{
|
|
// m_MoreItems.LeftInternal=m_Rect.Right-m_MoreItems.WidthInternal-m_PaddingRight;
|
|
// m_MoreItems.TopInternal=m_Rect.Top+m_PaddingTop;
|
|
//}
|
|
m_MoreItems.Paint(pa);
|
|
}
|
|
|
|
// if(m_LayoutType==eLayoutType.TaskList && m_Scroll)
|
|
// {
|
|
//
|
|
// }
|
|
}
|
|
}
|
|
g.ResetClip();
|
|
}
|
|
finally
|
|
{
|
|
m_Painting = false;
|
|
}
|
|
}
|
|
|
|
public eBorderType BorderType
|
|
{
|
|
get
|
|
{
|
|
return m_BorderType;
|
|
}
|
|
set
|
|
{
|
|
m_BorderType=value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set/Get does container wraps item into the new line when they exceed the container size
|
|
/// </summary>
|
|
public bool WrapItems
|
|
{
|
|
get
|
|
{
|
|
return m_WrapItems;
|
|
}
|
|
set
|
|
{
|
|
m_WrapItems=value;
|
|
}
|
|
}
|
|
|
|
public int ItemSpacing
|
|
{
|
|
get
|
|
{
|
|
return m_ItemSpacing;
|
|
}
|
|
set
|
|
{
|
|
if(m_ItemSpacing==value)
|
|
return;
|
|
m_ItemSpacing=value;
|
|
NeedRecalcSize=true;
|
|
}
|
|
}
|
|
|
|
protected virtual int FirstItemSpacing
|
|
{
|
|
get { return m_FirstItemSpacing; }
|
|
set { m_FirstItemSpacing = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Specifies whether to display more items on popup menu or Bar.
|
|
/// </summary>
|
|
public bool MoreItemsOnMenu
|
|
{
|
|
get
|
|
{
|
|
return m_MoreItemsOnMenu;
|
|
}
|
|
set
|
|
{
|
|
m_MoreItemsOnMenu=value;
|
|
}
|
|
}
|
|
|
|
internal DisplayMoreItem MoreItems
|
|
{
|
|
get
|
|
{
|
|
return m_MoreItems;
|
|
}
|
|
}
|
|
|
|
public override void RecalcSize()
|
|
{
|
|
if(this.SuspendLayout)
|
|
return;
|
|
this.IsLayoutPass = true;
|
|
m_RecalculatingSize=true;
|
|
|
|
switch(m_LayoutType)
|
|
{
|
|
case eLayoutType.Toolbar:
|
|
RecalcSizeToolbar();
|
|
break;
|
|
case eLayoutType.TaskList:
|
|
RecalcSizeTaskList();
|
|
break;
|
|
case eLayoutType.DockContainer:
|
|
RecalcSizeDockContainer(false);
|
|
break;
|
|
}
|
|
base.RecalcSize();
|
|
m_RecalculatingSize=false;
|
|
this.IsLayoutPass = false;
|
|
}
|
|
|
|
private void RecalcSizeDockContainer(bool bFitContainer)
|
|
{
|
|
int iX=0, iY=0, iMaxWidth=0, iMaxHeight=0;
|
|
bool bOneDisplayed=false;
|
|
if(this.SuspendLayout)
|
|
return;
|
|
|
|
m_DisplayedItems=0;
|
|
|
|
int paddingLeft = Dpi.Width(m_PaddingLeft);
|
|
iX=paddingLeft+m_Rect.Left;
|
|
int paddingTop = Dpi.Height(m_PaddingTop);
|
|
iY=paddingTop+m_Rect.Top;
|
|
if(m_SubItems!=null)
|
|
{
|
|
for(int itemIndex=0;itemIndex<this.SubItems.Count;itemIndex++)
|
|
{
|
|
BaseItem item=this.SubItems[itemIndex];
|
|
item.RecalcSize();
|
|
if(item.WidthInternal>iMaxWidth)
|
|
iMaxWidth=item.WidthInternal;
|
|
if(item.HeightInternal>iMaxHeight)
|
|
iMaxHeight=item.HeightInternal;
|
|
|
|
item.LeftInternal=iX;
|
|
item.TopInternal=iY;
|
|
|
|
if(!item.Visible)
|
|
{
|
|
item.Displayed=false;
|
|
continue;
|
|
}
|
|
else
|
|
m_DisplayedItems++;
|
|
if(!bOneDisplayed && (item.Displayed || itemIndex==this.SubItems.Count-1))
|
|
{
|
|
item.Displayed=true;
|
|
bOneDisplayed=true;
|
|
}
|
|
else
|
|
{
|
|
item.Displayed=false;
|
|
}
|
|
}
|
|
|
|
if(!bOneDisplayed)
|
|
{
|
|
foreach(BaseItem item in m_SubItems)
|
|
if(item.Visible)
|
|
{
|
|
item.Displayed=true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
int paddingRight = Dpi.Width(m_PaddingRight);
|
|
int paddingBottom = Dpi.Height(m_PaddingBottom);
|
|
if((bFitContainer || this.Stretch))
|
|
{
|
|
if(iMaxWidth+paddingLeft+paddingRight<m_Rect.Width || iMaxHeight+paddingTop+paddingBottom<m_Rect.Height)
|
|
{
|
|
if(iMaxWidth+paddingLeft+paddingRight<m_Rect.Width)
|
|
iMaxWidth=m_Rect.Width-paddingLeft-paddingRight;
|
|
if(iMaxHeight+paddingTop+paddingBottom<m_Rect.Height)
|
|
iMaxHeight=m_Rect.Height-paddingTop-paddingBottom;
|
|
}
|
|
Bar bar=this.ContainerControl as Bar;
|
|
// Following code lets us resized Dockable Bars when docked...
|
|
if(bar!=null && (bar.BarState==eBarState.Docked || bar.BarState==eBarState.AutoHide))
|
|
{
|
|
if(MinWidth>0 && iMaxWidth+paddingLeft+paddingRight<MinWidth && this.Orientation==eOrientation.Vertical)
|
|
iMaxWidth=MinWidth-(paddingLeft+paddingRight);
|
|
else if(MinHeight>0 && iMaxHeight+paddingTop+paddingBottom<MinHeight && this.Orientation==eOrientation.Horizontal)
|
|
iMaxHeight=MinHeight-(paddingTop+paddingBottom);
|
|
}
|
|
}
|
|
|
|
Size newSize = new Size(iMaxWidth, iMaxHeight);
|
|
foreach(BaseItem item in m_SubItems)
|
|
item.Size = newSize;
|
|
|
|
if(this.Stretch)
|
|
{
|
|
if(m_Orientation==eOrientation.Horizontal)
|
|
{
|
|
m_Rect.Height=paddingTop+iMaxHeight+paddingBottom;
|
|
// Only if suggested Width is less than our width change it
|
|
if(m_Rect.Width<iMaxWidth+paddingLeft+paddingRight)
|
|
m_Rect.Width=paddingLeft+iMaxWidth+paddingRight;
|
|
}
|
|
else if(m_Orientation==eOrientation.Vertical)
|
|
{
|
|
m_Rect.Width=paddingLeft+iMaxWidth+paddingRight;
|
|
// Only if suggested Height is less than our height change it
|
|
if(m_Rect.Height<iMaxHeight+paddingBottom+paddingTop)
|
|
m_Rect.Height=paddingTop+iMaxHeight+paddingBottom;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_Rect.Width=paddingLeft+iMaxWidth+paddingRight;
|
|
m_Rect.Height=paddingTop+iMaxHeight+paddingBottom;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recalculate Size of this item
|
|
/// </summary>
|
|
private void RecalcSizeToolbar()
|
|
{
|
|
if(this.SuspendLayout)
|
|
return;
|
|
|
|
bool isRightToLeft = false;
|
|
Control containerControl = this.ContainerControl as Control;
|
|
if (containerControl != null)
|
|
isRightToLeft = (containerControl.RightToLeft == RightToLeft.Yes);
|
|
|
|
// This object for now have only border but it will have more potentially
|
|
int iX=0, iY=0, iMaxItem=0, iMaxItemWidth=0, iMaxItemHeight=0;
|
|
int iWidth=0, iHeight=0;
|
|
int iGroupLineSize=3;
|
|
int iLines=0;
|
|
bool bDisplayed=true;
|
|
bool bAdjustSize=false, bSetSize=false; // If horizontal orientation we need to make sure that Height of all items is same
|
|
int iDisplayed=0;
|
|
BaseItem objItem=null;
|
|
ArrayList FarAlignLines=null;
|
|
Stack FarAlignItems=null;
|
|
ArrayList StretchLines=null;
|
|
ArrayList StretchLinesISCount=null; // Holds the count of number of items stretched per line
|
|
ArrayList ItemsToStretch=null;
|
|
|
|
if(m_MoreItems!=null && m_MoreItems.Expanded)
|
|
m_MoreItems.Expanded=false;
|
|
|
|
if (EffectiveStyle == eDotNetBarStyle.Office2000)
|
|
iGroupLineSize=6;
|
|
|
|
int paddingLeft = Dpi.Width(m_PaddingLeft);
|
|
iX=paddingLeft+m_Rect.Left;
|
|
int paddingTop = Dpi.Height(m_PaddingTop);
|
|
iY=paddingTop+m_Rect.Top;
|
|
|
|
int iVisibleCount=this.VisibleSubItems;
|
|
int iVisible=0;
|
|
|
|
int paddingRight = Dpi.Width(m_PaddingRight);
|
|
int paddingBottom = Dpi.Height(m_PaddingBottom);
|
|
if(m_SubItems!=null)
|
|
{
|
|
bool bRepeat=false;
|
|
int iRepeatCount=0;
|
|
|
|
if(m_WrapItems || this.Stretch)
|
|
FarAlignLines=new ArrayList(3);
|
|
|
|
if(this.Stretch)
|
|
{
|
|
StretchLines=new ArrayList(3);
|
|
StretchLinesISCount=new ArrayList(3);
|
|
}
|
|
|
|
bool callRecalcSize = OnBeforeLayout();
|
|
int mItemSpacing = Dpi.Width(m_ItemSpacing);
|
|
int firstItemSpacing = Dpi.Width(m_FirstItemSpacing);
|
|
do
|
|
{
|
|
iDisplayed=0;
|
|
for (int iCurrentItem=0;iCurrentItem<m_SubItems.Count;iCurrentItem++)
|
|
{
|
|
objItem=m_SubItems[iCurrentItem] as BaseItem;
|
|
if(objItem!=null && objItem.Visible)
|
|
{
|
|
iVisible++;
|
|
if((objItem.SupportedOrientation==eSupportedOrientation.Horizontal && m_Orientation==eOrientation.Vertical) || (objItem.SupportedOrientation==eSupportedOrientation.Vertical && m_Orientation==eOrientation.Horizontal))
|
|
{
|
|
objItem.Displayed=false;
|
|
continue;
|
|
}
|
|
|
|
int itemSpacing = (iDisplayed > 1 || firstItemSpacing == 0) ? mItemSpacing : firstItemSpacing;
|
|
|
|
if(callRecalcSize)
|
|
objItem.RecalcSize();
|
|
if(bSetSize)
|
|
{
|
|
if(m_Orientation==eOrientation.Vertical)
|
|
objItem.WidthInternal=iMaxItemWidth;
|
|
else
|
|
objItem.HeightInternal=iMaxItemHeight;
|
|
}
|
|
|
|
switch(m_Orientation)
|
|
{
|
|
case eOrientation.Horizontal:
|
|
{
|
|
// Wrap to next line if needed
|
|
if(m_WrapItems)
|
|
{
|
|
if(objItem.BeginGroup && iDisplayed>0)
|
|
iX+=iGroupLineSize;
|
|
if (iX + objItem.WidthInternal + itemSpacing > m_Rect.Right && iX > paddingLeft + m_Rect.Left)
|
|
{
|
|
iY += (iMaxItem + itemSpacing);
|
|
if(objItem.BeginGroup)
|
|
iY+=iGroupLineSize;
|
|
iX=paddingLeft+m_Rect.Left;
|
|
iMaxItem=0;
|
|
iLines++;
|
|
|
|
if(FarAlignItems!=null)
|
|
FarAlignItems=null;
|
|
if(ItemsToStretch!=null)
|
|
ItemsToStretch=null;
|
|
}
|
|
}
|
|
else if(bDisplayed)
|
|
{
|
|
if(objItem.BeginGroup && iDisplayed>0)
|
|
iX+=iGroupLineSize;
|
|
// If not wrapping then make sure that items fits into one line, otherwise we need to display the mark that lets them see the rest
|
|
if (OverflowEnabled && (iX + objItem.WidthInternal + itemSpacing > m_Rect.Right - paddingRight && iX > paddingLeft + m_Rect.Left || (iX + objItem.WidthInternal + itemSpacing + DisplayMoreItem.FixedSize > m_Rect.Right && iCurrentItem + 1 < m_SubItems.Count && iVisible < iVisibleCount)))
|
|
{
|
|
if(iCurrentItem==0)
|
|
iMaxItem=objItem.HeightInternal;
|
|
// Items don't fit any more the rest won't be visible
|
|
iX += (itemSpacing + DisplayMoreItem.FixedSize);
|
|
bDisplayed=false;
|
|
}
|
|
}
|
|
|
|
if(bDisplayed)
|
|
{
|
|
if(iDisplayed>0)
|
|
iX += itemSpacing;
|
|
objItem.LeftInternal = GetItemLayoutX(objItem, iX);
|
|
objItem.TopInternal = GetItemLayoutY(objItem, iY);
|
|
//iX+=objItem.WidthInternal+m_ItemSpacing;
|
|
iX+=GetItemLayoutWidth(objItem);
|
|
if(objItem.HeightInternal>iMaxItem)
|
|
{
|
|
iMaxItem=objItem.HeightInternal;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case eOrientation.Vertical:
|
|
{
|
|
// Wrap to next line if needed
|
|
if(m_WrapItems)
|
|
{
|
|
if(objItem.BeginGroup && iDisplayed>0)
|
|
iY+=iGroupLineSize;
|
|
if (iY + objItem.HeightInternal + itemSpacing > m_Rect.Bottom && iY > paddingTop + m_Rect.Top)
|
|
{
|
|
iX += (iMaxItem + itemSpacing);
|
|
if(objItem.BeginGroup)
|
|
iX+=iGroupLineSize;
|
|
iY=paddingTop+m_Rect.Top;
|
|
iMaxItem=0;
|
|
iLines++;
|
|
|
|
if(FarAlignItems!=null)
|
|
FarAlignItems=null;
|
|
if(ItemsToStretch!=null)
|
|
ItemsToStretch=null;
|
|
}
|
|
}
|
|
else if(bDisplayed)
|
|
{
|
|
if(objItem.BeginGroup && iDisplayed>0)
|
|
iY+=iGroupLineSize;
|
|
// If not wrapping then make sure that items fits into one line, otherwise we need to display the mark that lets them see the rest
|
|
if (iY + objItem.HeightInternal + itemSpacing > m_Rect.Bottom && iY > paddingTop + m_Rect.Top || (iY + objItem.HeightInternal + itemSpacing + DisplayMoreItem.FixedSize > m_Rect.Bottom && iCurrentItem + 1 < m_SubItems.Count && iVisible < iVisibleCount))
|
|
{
|
|
if(iCurrentItem==0)
|
|
iMaxItem=objItem.WidthInternal;
|
|
// Items don't fit any more the rest won't be visible
|
|
iY += (itemSpacing + DisplayMoreItem.FixedSize);
|
|
bDisplayed=false;
|
|
}
|
|
}
|
|
if(bDisplayed)
|
|
{
|
|
if(iDisplayed>0)
|
|
iY += itemSpacing;
|
|
objItem.LeftInternal=iX;
|
|
objItem.TopInternal=iY;
|
|
iY+=GetItemLayoutHeight(objItem);
|
|
if(objItem.WidthInternal>iMaxItem)
|
|
{
|
|
iMaxItem=objItem.WidthInternal;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if(bDisplayed)
|
|
{
|
|
if(objItem.WidthInternal!=iMaxItemWidth)
|
|
{
|
|
if(m_Orientation==eOrientation.Vertical && iMaxItemWidth!=0 && !bSetSize)
|
|
bAdjustSize=true;
|
|
if(objItem.WidthInternal>iMaxItemWidth)
|
|
iMaxItemWidth=objItem.WidthInternal;
|
|
}
|
|
if(objItem.HeightInternal!=iMaxItemHeight)
|
|
{
|
|
if(m_Orientation==eOrientation.Horizontal && iMaxItemHeight!=0 && !bSetSize)
|
|
bAdjustSize=true;
|
|
if(objItem.HeightInternal>iMaxItemHeight)
|
|
iMaxItemHeight=objItem.HeightInternal;
|
|
}
|
|
iDisplayed++;
|
|
}
|
|
|
|
objItem.Displayed=bDisplayed;
|
|
|
|
// Save right (Far) aligned items so we can adjust thiere position at the end
|
|
if(bDisplayed && FarAlignLines!=null && objItem.ItemAlignment==eItemAlignment.Far || FarAlignItems!=null)
|
|
{
|
|
if(FarAlignItems==null)
|
|
{
|
|
FarAlignItems=new Stack();
|
|
FarAlignLines.Add(FarAlignItems);
|
|
}
|
|
FarAlignItems.Push(objItem);
|
|
// no stretch after item has been far aligned
|
|
StretchLines=null;
|
|
}
|
|
|
|
// Save Items that we need to stretch
|
|
if(bDisplayed && objItem.Stretch && StretchLines!=null || ItemsToStretch!=null)
|
|
{
|
|
if(ItemsToStretch==null)
|
|
{
|
|
ItemsToStretch=new ArrayList(5);
|
|
StretchLines.Add(ItemsToStretch);
|
|
StretchLinesISCount.Add(0);
|
|
}
|
|
ItemsToStretch.Add(objItem);
|
|
if(objItem.Stretch)
|
|
StretchLinesISCount[StretchLinesISCount.Count-1]=(int)StretchLinesISCount[StretchLinesISCount.Count-1]+1;
|
|
}
|
|
|
|
|
|
// Track the size if this container
|
|
if(iX>iWidth)
|
|
iWidth=iX;
|
|
if(iY>iHeight)
|
|
iHeight=iY;
|
|
}
|
|
else if(objItem!=null)
|
|
objItem.Displayed=false;
|
|
}
|
|
// Check do we have to repeat the process
|
|
// This is needed if container is in wrap mode and some items do not fit
|
|
// This is done to ensure the minimum size of the container for example
|
|
// if container with is smaller than width of one single item inside the
|
|
// container width has to be set to widest item in the list and then the
|
|
// size has to be recalculated again.
|
|
if(m_WrapItems && iLines>0 && iRepeatCount<1)
|
|
{
|
|
if(m_Orientation==eOrientation.Horizontal && (iWidth>m_Rect.Width || bAdjustSize))
|
|
{
|
|
bRepeat=true;
|
|
m_Rect.Width=iWidth+paddingLeft+paddingRight;
|
|
iX=paddingLeft+m_Rect.Left;
|
|
iY=paddingTop+m_Rect.Top;
|
|
iWidth=0;
|
|
iHeight=0;
|
|
}
|
|
else if(m_Orientation==eOrientation.Vertical && (iHeight>m_Rect.Height || bAdjustSize))
|
|
{
|
|
bRepeat=true;
|
|
m_Rect.Height=iHeight+paddingTop+paddingBottom;
|
|
iX=paddingLeft+m_Rect.Left;
|
|
iY=paddingTop+m_Rect.Top;
|
|
iWidth=0;
|
|
iHeight=0;
|
|
}
|
|
if(bAdjustSize)
|
|
{
|
|
if(m_EventHeight)
|
|
bSetSize=true;
|
|
bAdjustSize=false;
|
|
}
|
|
// Reset alignment collections since new iteration can cause different lines
|
|
if(bRepeat && iRepeatCount+1<2)
|
|
{
|
|
if(FarAlignLines!=null && FarAlignLines.Count>0)
|
|
FarAlignLines=new ArrayList(3);
|
|
// Reset stretch collection for same reason
|
|
if(StretchLines!=null && StretchLines.Count>0)
|
|
{
|
|
StretchLines=new ArrayList(3);
|
|
StretchLinesISCount=new ArrayList(3);
|
|
}
|
|
}
|
|
}
|
|
iRepeatCount++;
|
|
} while (bRepeat && iRepeatCount<2);
|
|
}
|
|
|
|
if(m_EqualButtonSize)
|
|
{
|
|
// Make all buttons same width, do the same thing as loop above
|
|
iX=paddingLeft+m_Rect.Left;
|
|
iY=paddingTop+m_Rect.Top;
|
|
iWidth=0;
|
|
iHeight=0;
|
|
bDisplayed=true;
|
|
iLines=0;
|
|
bAdjustSize=false; // Size will be adjusted reset
|
|
iDisplayed=0;
|
|
|
|
// Reset alignment collections since new iteration can cause different lines
|
|
if(FarAlignLines!=null && FarAlignLines.Count>0)
|
|
FarAlignLines=new ArrayList(3);
|
|
// Reset stretch collection for same reason
|
|
if(StretchLines!=null && StretchLines.Count>0)
|
|
{
|
|
StretchLines=new ArrayList(3);
|
|
StretchLinesISCount=new ArrayList(3);
|
|
}
|
|
|
|
for (int iCurrentItem=0;iCurrentItem<m_SubItems.Count;iCurrentItem++)
|
|
{
|
|
objItem=m_SubItems[iCurrentItem] as BaseItem;
|
|
if(objItem!=null && objItem.Visible)
|
|
{
|
|
if((objItem.SupportedOrientation==eSupportedOrientation.Horizontal && m_Orientation==eOrientation.Vertical) || (objItem.SupportedOrientation==eSupportedOrientation.Vertical && m_Orientation==eOrientation.Horizontal))
|
|
{
|
|
objItem.Displayed=false;
|
|
continue;
|
|
}
|
|
int itemSpacing = (iDisplayed > 1 || m_FirstItemSpacing == 0) ? m_ItemSpacing : m_FirstItemSpacing;
|
|
if(objItem.SystemItem)
|
|
{
|
|
if(m_Orientation==eOrientation.Vertical)
|
|
objItem.WidthInternal=iMaxItemWidth;
|
|
else
|
|
objItem.HeightInternal=iMaxItemHeight;
|
|
}
|
|
else
|
|
{
|
|
objItem.WidthInternal=iMaxItemWidth;
|
|
objItem.HeightInternal=iMaxItemHeight;
|
|
}
|
|
|
|
switch(m_Orientation)
|
|
{
|
|
case eOrientation.Horizontal:
|
|
{
|
|
// Wrap to next line if needed
|
|
if(m_WrapItems)
|
|
{
|
|
if(objItem.BeginGroup)
|
|
iX+=iGroupLineSize;
|
|
if (iX + objItem.WidthInternal + itemSpacing > m_Rect.Right && iX > paddingLeft + paddingRight)
|
|
{
|
|
iY += (iMaxItem + itemSpacing);
|
|
if(objItem.BeginGroup)
|
|
iY+=iGroupLineSize;
|
|
iX=paddingLeft+m_Rect.Left;
|
|
iMaxItem=0;
|
|
iLines++;
|
|
|
|
if(FarAlignItems!=null)
|
|
FarAlignItems=null;
|
|
if(ItemsToStretch!=null)
|
|
ItemsToStretch=null;
|
|
}
|
|
}
|
|
else if(bDisplayed)
|
|
{
|
|
if(objItem.BeginGroup)
|
|
iX+=iGroupLineSize;
|
|
// If not wrapping then make sure that items fits into one line, otherwise we need to display the mark that lets them see the rest
|
|
if (iX + objItem.WidthInternal + itemSpacing > m_Rect.Right && iX > paddingLeft + m_Rect.Left || (iX + objItem.WidthInternal + itemSpacing + DisplayMoreItem.FixedSize > m_Rect.Right && iCurrentItem + 1 < m_SubItems.Count && iVisible < iVisibleCount))
|
|
{
|
|
// Items don't fit any more the rest won't be visible
|
|
iX += (itemSpacing + DisplayMoreItem.FixedSize);
|
|
bDisplayed=false;
|
|
}
|
|
}
|
|
|
|
if(bDisplayed)
|
|
{
|
|
objItem.LeftInternal=iX;
|
|
objItem.TopInternal=iY;
|
|
iX += objItem.WidthInternal + itemSpacing;
|
|
if(objItem.HeightInternal>iMaxItem)
|
|
{
|
|
iMaxItem=objItem.HeightInternal;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case eOrientation.Vertical:
|
|
{
|
|
// Wrap to next line if needed
|
|
if(m_WrapItems)
|
|
{
|
|
if (iY + objItem.HeightInternal + itemSpacing > m_Rect.Bottom && iY > paddingTop + paddingBottom)
|
|
{
|
|
iX += (iMaxItem + itemSpacing);
|
|
iY=paddingTop+m_Rect.Top;
|
|
iMaxItem=0;
|
|
iLines++;
|
|
|
|
if(FarAlignItems!=null)
|
|
FarAlignItems=null;
|
|
if(ItemsToStretch!=null)
|
|
ItemsToStretch=null;
|
|
}
|
|
}
|
|
else if(bDisplayed)
|
|
{
|
|
// If not wrapping then make sure that items fits into one line, otherwise we need to display the mark that lets them see the rest
|
|
if (iY + objItem.HeightInternal + itemSpacing > m_Rect.Bottom && iY > paddingTop + m_Rect.Top || (iY + objItem.HeightInternal + itemSpacing + DisplayMoreItem.FixedSize > m_Rect.Bottom && iCurrentItem + 1 < m_SubItems.Count && iVisible < iVisibleCount))
|
|
{
|
|
// Items don't fit any more the rest won't be visible
|
|
iY += (itemSpacing + DisplayMoreItem.FixedSize);
|
|
bDisplayed=false;
|
|
}
|
|
}
|
|
|
|
if(bDisplayed)
|
|
{
|
|
objItem.LeftInternal=iX;
|
|
objItem.TopInternal=iY;
|
|
iY += objItem.HeightInternal + itemSpacing;
|
|
if(objItem.WidthInternal>iMaxItem)
|
|
{
|
|
iMaxItem=objItem.WidthInternal;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
objItem.Displayed=bDisplayed;
|
|
if(bDisplayed)
|
|
iDisplayed++;
|
|
|
|
// Save right (Far) aligned items so we can adjust thiere position at the end
|
|
if(bDisplayed && FarAlignLines!=null && objItem.ItemAlignment==eItemAlignment.Far || FarAlignItems!=null)
|
|
{
|
|
if(FarAlignItems==null)
|
|
{
|
|
FarAlignItems=new Stack();
|
|
FarAlignLines.Add(FarAlignItems);
|
|
}
|
|
FarAlignItems.Push(objItem);
|
|
// no stretch after item has been far aligned
|
|
StretchLines=null;
|
|
}
|
|
|
|
// Save Items that we need to stretch, but not after item is far aligned
|
|
if(bDisplayed && objItem.Stretch && StretchLines!=null || ItemsToStretch!=null)
|
|
{
|
|
if(ItemsToStretch==null)
|
|
{
|
|
ItemsToStretch=new ArrayList(5);
|
|
StretchLines.Add(ItemsToStretch);
|
|
StretchLinesISCount.Add(0);
|
|
}
|
|
ItemsToStretch.Add(objItem);
|
|
if(objItem.Stretch)
|
|
StretchLinesISCount[StretchLinesISCount.Count-1]=(int)StretchLinesISCount[StretchLinesISCount.Count-1]+1;
|
|
}
|
|
|
|
// Track the size if this container
|
|
if(iX>iWidth)
|
|
iWidth=iX;
|
|
if(iY>iHeight)
|
|
iHeight=iY;
|
|
}
|
|
}
|
|
}
|
|
|
|
m_DisplayedItems=iDisplayed;
|
|
|
|
if (_FillsContainerControl)
|
|
{
|
|
if (m_Orientation == eOrientation.Vertical)
|
|
iMaxItemWidth = m_Rect.Width - paddingLeft;
|
|
else
|
|
iMaxItemHeight = m_Rect.Height - paddingTop;
|
|
bAdjustSize = true;
|
|
}
|
|
|
|
if (bAdjustSize)
|
|
{
|
|
if(m_Orientation==eOrientation.Vertical)
|
|
{
|
|
foreach(BaseItem objTmp in this.SubItems)
|
|
{
|
|
if(m_EventHeight)
|
|
objTmp.WidthInternal=iMaxItemWidth;
|
|
else if (m_ToolbarItemsAlign == eContainerVerticalAlignment.Bottom)
|
|
objTmp.LeftInternal+=(iMaxItemWidth-objTmp.WidthInternal);
|
|
else if (m_ToolbarItemsAlign == eContainerVerticalAlignment.Middle)
|
|
objTmp.LeftInternal += (iMaxItemWidth - objTmp.WidthInternal) / 2;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
foreach(BaseItem objTmp in this.SubItems)
|
|
{
|
|
if (m_EventHeight)
|
|
objTmp.HeightInternal = iMaxItemHeight;
|
|
else if (m_ToolbarItemsAlign == eContainerVerticalAlignment.Bottom)
|
|
objTmp.TopInternal += (iMaxItemHeight - objTmp.HeightInternal);
|
|
else if (m_ToolbarItemsAlign == eContainerVerticalAlignment.Middle && iMaxItemHeight != objTmp.HeightInternal)
|
|
objTmp.TopInternal += (int)Math.Ceiling((float)(iMaxItemHeight - objTmp.HeightInternal) / 2) /*+ 1*/;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Add max width or height depending on arrange type...
|
|
switch(m_Orientation)
|
|
{
|
|
case eOrientation.Horizontal:
|
|
{
|
|
iHeight+=iMaxItem;
|
|
break;
|
|
}
|
|
case eOrientation.Vertical:
|
|
{
|
|
iWidth+=iMaxItem;
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if(this.Stretch)
|
|
{
|
|
if(m_Orientation==eOrientation.Horizontal)
|
|
{
|
|
m_Rect.Height=iHeight+paddingBottom-m_Rect.Top;
|
|
|
|
// Only if suggested Width is less than our width change it
|
|
// This will disable stretchable items support for wrapable containers, every line width
|
|
// would have to be tracked so stretchable items can work
|
|
if(StretchLines!=null && StretchLines.Count>0)
|
|
StretchItems(StretchLines,StretchLinesISCount,iWidth+paddingRight-m_Rect.Left);
|
|
if(m_Rect.Width<iWidth+ paddingRight -m_Rect.Left)
|
|
m_Rect.Width=iWidth+ paddingRight -m_Rect.Left;
|
|
//else if(StretchLines!=null && StretchLines.Count>0)
|
|
// StretchItems(StretchLines,StretchLinesISCount,iWidth+m_PaddingRight-m_Rect.Left);
|
|
}
|
|
else if(m_Orientation==eOrientation.Vertical)
|
|
{
|
|
m_Rect.Width=iWidth+paddingRight-m_Rect.Left;
|
|
|
|
if(StretchLines!=null && StretchLines.Count>0)
|
|
StretchItems(StretchLines,StretchLinesISCount,iHeight+paddingBottom-m_Rect.Top);
|
|
// Only if suggested Height is less than our height change it
|
|
if(m_Rect.Height<iHeight+paddingBottom-m_Rect.Top)
|
|
m_Rect.Height=iHeight+paddingBottom-m_Rect.Top;
|
|
//else if(StretchLines!=null && StretchLines.Count>0)
|
|
// StretchItems(StretchLines,StretchLinesISCount,iHeight+m_PaddingBottom-m_Rect.Top);
|
|
}
|
|
else
|
|
{
|
|
m_Rect.Width=iWidth+paddingRight-m_Rect.Left;
|
|
m_Rect.Height=iHeight+paddingBottom-m_Rect.Top;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// If all items did not fit and we are not wrapping take suggested sizes
|
|
if(!m_WrapItems && !bDisplayed)
|
|
{
|
|
// Horizontal, just adjust Height, we will honor width
|
|
if(m_Orientation==eOrientation.Horizontal)
|
|
m_Rect.Height=iHeight+paddingBottom-m_Rect.Top;
|
|
else if(m_Orientation==eOrientation.Vertical)
|
|
m_Rect.Width=iWidth+paddingRight-m_Rect.Left;
|
|
}
|
|
else
|
|
{
|
|
// If there are no items take suggested width by container control
|
|
if(m_DisplayedItems>0)
|
|
{
|
|
m_Rect.Width=iWidth+paddingRight-m_Rect.Left;
|
|
m_Rect.Height=iHeight+paddingBottom-m_Rect.Top;
|
|
}
|
|
/*else
|
|
{
|
|
m_Rect.Width=m_PaddingLeft+m_PaddingRight;
|
|
m_Rect.Height=m_PaddingTop+m_PaddingBottom;
|
|
}*/
|
|
}
|
|
}
|
|
|
|
// If we don't wrap and there are items left to display
|
|
if(!m_WrapItems && !bDisplayed && m_UseMoreItemsButton)
|
|
CreateMoreItemsButton(isRightToLeft);
|
|
else if(m_MoreItems!=null)
|
|
{
|
|
// Clean up, we don't need this anymore
|
|
m_MoreItems.Dispose();
|
|
m_MoreItems=null;
|
|
}
|
|
|
|
// Align Items if needed
|
|
if(FarAlignLines!=null && FarAlignLines.Count>0)
|
|
AlignItemsFar(FarAlignLines);
|
|
|
|
if (isRightToLeft && m_Orientation == eOrientation.Horizontal)
|
|
MirrorPositionItems();
|
|
|
|
m_NeedRecalcSize=false;
|
|
if(m_Parent!=null)
|
|
{
|
|
m_Parent.SubItemSizeChanged(this);
|
|
}
|
|
}
|
|
|
|
protected virtual int GetItemLayoutX(BaseItem objItem, int iX)
|
|
{
|
|
return iX;
|
|
}
|
|
|
|
protected virtual int GetItemLayoutY(BaseItem objItem, int iY)
|
|
{
|
|
return iY;
|
|
}
|
|
|
|
protected virtual int GetItemLayoutHeight(BaseItem objItem)
|
|
{
|
|
return objItem.HeightInternal;
|
|
}
|
|
|
|
protected virtual int GetItemLayoutWidth(BaseItem objItem)
|
|
{
|
|
return objItem.WidthInternal;
|
|
}
|
|
|
|
protected virtual bool OnBeforeLayout()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
protected void MirrorPositionItems()
|
|
{
|
|
Rectangle bounds = this.DisplayRectangle;
|
|
foreach (BaseItem item in this.SubItems)
|
|
{
|
|
item.LeftInternal = bounds.Right - ((item.DisplayRectangle.X-bounds.X) + item.DisplayRectangle.Width);
|
|
}
|
|
}
|
|
|
|
private void RecalcSizeTaskList()
|
|
{
|
|
int paddingTop = Dpi.Width(m_PaddingTop);
|
|
int paddingLeft = Dpi.Height(m_PaddingLeft);
|
|
int iX=m_Rect.Left+paddingLeft, iY=m_Rect.Top+paddingTop, iMaxItemWidth=0, iMaxItemHeight=0;
|
|
int iWidth=0, iHeight=0;
|
|
int iGroupLineSize=3;
|
|
bool bDisplayed=true;
|
|
int iDisplayed=0;
|
|
Stack FarAlignItems=null;
|
|
|
|
if (EffectiveStyle == eDotNetBarStyle.Office2000)
|
|
iGroupLineSize=6;
|
|
|
|
if(m_EqualButtonSize)
|
|
{
|
|
foreach(BaseItem item in m_SubItems)
|
|
{
|
|
item.Orientation=eOrientation.Horizontal;
|
|
item.RecalcSize();
|
|
if(item.WidthInternal>iMaxItemWidth)
|
|
iMaxItemWidth=item.WidthInternal;
|
|
if(item.HeightInternal>iMaxItemHeight)
|
|
iMaxItemHeight=item.HeightInternal;
|
|
}
|
|
}
|
|
|
|
for(int iCurrentItem=0;iCurrentItem<m_SubItems.Count;iCurrentItem++)
|
|
{
|
|
BaseItem objItem=m_SubItems[iCurrentItem] as BaseItem;
|
|
objItem.Orientation=eOrientation.Horizontal;
|
|
if(objItem==null || !objItem.Visible)
|
|
continue;
|
|
|
|
if(!m_EqualButtonSize)
|
|
objItem.RecalcSize();
|
|
|
|
if(objItem.BeginGroup && iDisplayed>0)
|
|
iY+=iGroupLineSize;
|
|
|
|
if(!m_EqualButtonSize)
|
|
{
|
|
if(objItem.WidthInternal>iMaxItemWidth)
|
|
iMaxItemWidth=objItem.WidthInternal;
|
|
if(objItem.HeightInternal>iMaxItemHeight)
|
|
iMaxItemHeight=objItem.HeightInternal;
|
|
}
|
|
else
|
|
{
|
|
objItem.WidthInternal=iMaxItemWidth;
|
|
objItem.HeightInternal=iMaxItemHeight;
|
|
}
|
|
|
|
objItem.TopInternal=iY;
|
|
objItem.LeftInternal=iX;
|
|
iY+=objItem.HeightInternal;
|
|
objItem.Displayed=bDisplayed;
|
|
if(!bDisplayed)
|
|
continue;
|
|
|
|
if(iY>m_Rect.Bottom)
|
|
{
|
|
bDisplayed=false;
|
|
FarAlignItems=null;
|
|
objItem.Displayed=false;
|
|
continue;
|
|
}
|
|
|
|
if(FarAlignItems!=null && FarAlignItems.Count>0)
|
|
FarAlignItems.Push(objItem);
|
|
|
|
iDisplayed++;
|
|
if(objItem.ItemAlignment==eItemAlignment.Far)
|
|
{
|
|
if(FarAlignItems==null)
|
|
FarAlignItems=new Stack(10);
|
|
FarAlignItems.Push(objItem);
|
|
}
|
|
}
|
|
int paddingRight = Dpi.Width(m_PaddingRight);
|
|
iWidth=iMaxItemWidth+paddingLeft+paddingRight;
|
|
int paddingBottom = Dpi.Width(m_PaddingBottom);
|
|
iHeight=iY+paddingBottom-m_Rect.Top;
|
|
m_DisplayedItems=iDisplayed;
|
|
if(this.Stretch)
|
|
{
|
|
if(bDisplayed && FarAlignItems!=null && FarAlignItems.Count>0)
|
|
{
|
|
// We need to move "far" align items to the appropriate position at the bottom
|
|
AlignItemsFar(FarAlignItems, eOrientation.Vertical); // Vertical becouse this is "vertical layout"
|
|
}
|
|
Bar bar=this.ContainerControl as Bar;
|
|
if(bar==null || bar!=null && bar.DockSide!=eDockSide.Top && bar.DockSide!=eDockSide.Bottom)
|
|
m_Rect.Width=iWidth;
|
|
if(m_Rect.Height<iHeight)
|
|
{
|
|
if(m_Rect.Height<36)
|
|
m_Rect.Height=36;
|
|
// We need to scroll content
|
|
m_Scroll=true;
|
|
RepositionItems();
|
|
}
|
|
else
|
|
{
|
|
m_Scroll=false;
|
|
m_ScrollTopPosition=0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_Rect.Width=iWidth;
|
|
if(m_Rect.Height>iHeight && bDisplayed)
|
|
m_Rect.Height=iHeight;
|
|
if(!bDisplayed)
|
|
{
|
|
if(m_Rect.Height<36)
|
|
m_Rect.Height=36;
|
|
// We need to scroll content
|
|
m_Scroll=true;
|
|
RepositionItems();
|
|
}
|
|
else
|
|
{
|
|
m_Scroll=false;
|
|
m_ScrollTopPosition=0;
|
|
}
|
|
}
|
|
|
|
if(m_MoreItems!=null)
|
|
{
|
|
m_MoreItems.Dispose();
|
|
m_MoreItems=null;
|
|
}
|
|
|
|
SetupScrollButtons();
|
|
}
|
|
private int GroupLineSize
|
|
{
|
|
get
|
|
{
|
|
if (EffectiveStyle == eDotNetBarStyle.Office2000)
|
|
return 6;
|
|
return 3;
|
|
}
|
|
}
|
|
private void RepositionItems()
|
|
{
|
|
int iTop=0;
|
|
int iDisplayed=0;
|
|
int iGroupLineSize=this.GroupLineSize;
|
|
bool bDisplayed=true;
|
|
m_TopScroll=false;
|
|
m_BottomScroll=false;
|
|
|
|
// Move "invisible" items up
|
|
for(int i=m_ScrollTopPosition-1;i>=0;i--)
|
|
{
|
|
BaseItem objItem=m_SubItems[i];
|
|
if(!objItem.Visible)
|
|
continue;
|
|
iTop-=objItem.HeightInternal;
|
|
objItem.TopInternal=iTop;
|
|
objItem.Displayed=false;
|
|
if(objItem.BeginGroup && i>0)
|
|
iTop-=iGroupLineSize;
|
|
}
|
|
// Move visible items down
|
|
iTop=m_Rect.Top;
|
|
for(int i=m_ScrollTopPosition;i<m_SubItems.Count;i++)
|
|
{
|
|
BaseItem objItem=m_SubItems[i];
|
|
if(!objItem.Visible)
|
|
continue;
|
|
objItem.Displayed=bDisplayed;
|
|
if(!bDisplayed)
|
|
continue;
|
|
if(objItem.BeginGroup && iDisplayed>0)
|
|
iTop+=iGroupLineSize;
|
|
objItem.TopInternal=iTop;
|
|
iTop+=objItem.HeightInternal;
|
|
if(iTop>m_Rect.Bottom)
|
|
{
|
|
objItem.Displayed=false;
|
|
bDisplayed=false;
|
|
continue;
|
|
}
|
|
iDisplayed++;
|
|
}
|
|
|
|
m_DisplayedItems=iDisplayed;
|
|
|
|
if(!bDisplayed)
|
|
m_BottomScroll=true;
|
|
if(m_ScrollTopPosition>0)
|
|
m_TopScroll=true;
|
|
}
|
|
|
|
private void SetupScrollButtons()
|
|
{
|
|
bool bDestroyTop=false,bDestroyBottom=false;
|
|
if(!m_Scroll)
|
|
{
|
|
bDestroyTop=true;
|
|
bDestroyBottom=true;
|
|
}
|
|
else
|
|
{
|
|
if(!m_TopScroll)
|
|
bDestroyTop=true;
|
|
if(!m_BottomScroll)
|
|
bDestroyBottom=true;
|
|
}
|
|
if(bDestroyTop)
|
|
{
|
|
if(m_TopScrollButton!=null)
|
|
{
|
|
if(m_TopScrollButton.Parent!=null)
|
|
m_TopScrollButton.Parent.Controls.Remove(m_TopScrollButton);
|
|
m_TopScrollButton.Dispose();
|
|
m_TopScrollButton=null;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(m_TopScrollButton==null)
|
|
{
|
|
System.Windows.Forms.Control ctrl=this.ContainerControl as System.Windows.Forms.Control;
|
|
if(ctrl!=null)
|
|
{
|
|
m_TopScrollButton=new ScrollButton();
|
|
m_TopScrollButton.Orientation=eOrientation.Vertical;
|
|
m_TopScrollButton.ButtonAlignment=eItemAlignment.Near;
|
|
ctrl.Controls.Add(m_TopScrollButton);
|
|
m_TopScrollButton.Click+=new EventHandler(ScrollClick);
|
|
}
|
|
}
|
|
if(m_TopScrollButton!=null)
|
|
{
|
|
m_TopScrollButton.Location=m_Rect.Location;
|
|
m_TopScrollButton.Size=new Size(m_Rect.Width,10);
|
|
m_TopScrollButton.BringToFront();
|
|
}
|
|
}
|
|
|
|
if(bDestroyBottom)
|
|
{
|
|
if(m_BottomScrollButton!=null)
|
|
{
|
|
if(m_BottomScrollButton.Parent!=null)
|
|
m_BottomScrollButton.Parent.Controls.Remove(m_BottomScrollButton);
|
|
m_BottomScrollButton.Dispose();
|
|
m_BottomScrollButton=null;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(m_BottomScrollButton==null)
|
|
{
|
|
System.Windows.Forms.Control ctrl=this.ContainerControl as System.Windows.Forms.Control;
|
|
if(ctrl!=null)
|
|
{
|
|
m_BottomScrollButton=new ScrollButton();
|
|
m_BottomScrollButton.Orientation=eOrientation.Vertical;
|
|
m_BottomScrollButton.ButtonAlignment=eItemAlignment.Far;
|
|
ctrl.Controls.Add(m_BottomScrollButton);
|
|
m_BottomScrollButton.Click+=new EventHandler(ScrollClick);
|
|
}
|
|
}
|
|
if(m_BottomScrollButton!=null)
|
|
{
|
|
m_BottomScrollButton.Location=new Point(m_Rect.X,m_Rect.Bottom-10);
|
|
m_BottomScrollButton.Size=new Size(m_Rect.Width,10);
|
|
m_BottomScrollButton.BringToFront();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ScrollClick(object sender, EventArgs e)
|
|
{
|
|
if(sender==m_TopScrollButton)
|
|
{
|
|
m_ScrollTopPosition--;
|
|
}
|
|
else
|
|
{
|
|
m_ScrollTopPosition++;
|
|
}
|
|
RepositionItems();
|
|
SetupScrollButtons();
|
|
this.Refresh();
|
|
}
|
|
|
|
private void AlignItemsFar(Stack FarAlignItems, eOrientation orientation)
|
|
{
|
|
int iPos=0;
|
|
int iGroupLineSize=this.GroupLineSize;
|
|
if(orientation==eOrientation.Horizontal)
|
|
{
|
|
int paddingRight = Dpi.Width(m_PaddingRight);
|
|
iPos=m_Rect.Right-paddingRight;
|
|
if(m_MoreItems!=null)
|
|
iPos-=m_MoreItems.WidthInternal;
|
|
while(FarAlignItems.Count>0)
|
|
{
|
|
BaseItem objItem=FarAlignItems.Pop() as BaseItem;
|
|
if(objItem.Displayed && objItem.Visible)
|
|
{
|
|
objItem.LeftInternal=iPos- GetItemLayoutWidth(objItem);
|
|
iPos=objItem.LeftInternal-m_ItemSpacing;
|
|
if(objItem.BeginGroup)
|
|
iPos-=iGroupLineSize;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int paddingBottom = Dpi.Height(m_PaddingBottom);
|
|
iPos=m_Rect.Bottom-paddingBottom;
|
|
if(m_MoreItems!=null)
|
|
iPos-=m_MoreItems.HeightInternal;
|
|
while(FarAlignItems.Count>0)
|
|
{
|
|
BaseItem objItem=FarAlignItems.Pop() as BaseItem;
|
|
if(objItem.Displayed && objItem.Visible)
|
|
{
|
|
objItem.TopInternal=iPos-GetItemLayoutHeight(objItem);
|
|
iPos=objItem.TopInternal-m_ItemSpacing;
|
|
if(objItem.BeginGroup)
|
|
iPos-=iGroupLineSize;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
private void AlignItemsFar(ArrayList FarAlignLines, eOrientation orientation)
|
|
{
|
|
if(orientation==eOrientation.Horizontal)
|
|
{
|
|
foreach(Stack FarAlignItems in FarAlignLines)
|
|
AlignItemsFar(FarAlignItems,orientation);
|
|
}
|
|
else
|
|
{
|
|
foreach(Stack FarAlignItems in FarAlignLines)
|
|
AlignItemsFar(FarAlignItems,orientation);
|
|
}
|
|
}
|
|
private void AlignItemsFar(ArrayList FarAlignLines)
|
|
{
|
|
AlignItemsFar(FarAlignLines, this.Orientation);
|
|
}
|
|
|
|
private void StretchItems(ArrayList StretchLines, ArrayList StretchLinesISCount, int CalculatedSize)
|
|
{
|
|
int iOffset=0;
|
|
int iStretch=0;
|
|
for(int i=0;i<StretchLines.Count;i++)
|
|
{
|
|
ArrayList StretchLine=StretchLines[i] as ArrayList;
|
|
if(m_Orientation==eOrientation.Horizontal)
|
|
iStretch=(this.WidthInternal-CalculatedSize)/(int)StretchLinesISCount[i];
|
|
else
|
|
iStretch=(this.HeightInternal-CalculatedSize)/(int)StretchLinesISCount[i];
|
|
|
|
foreach(BaseItem objItem in StretchLine)
|
|
{
|
|
if(objItem.Stretch)
|
|
{
|
|
if(m_Orientation==eOrientation.Horizontal)
|
|
{
|
|
objItem.LeftInternal+=iOffset;
|
|
objItem.WidthInternal+=iStretch;
|
|
}
|
|
else
|
|
{
|
|
objItem.TopInternal+=iOffset;
|
|
objItem.HeightInternal+=iStretch;
|
|
}
|
|
iOffset+=iStretch;
|
|
}
|
|
else
|
|
{
|
|
if(m_Orientation==eOrientation.Horizontal)
|
|
objItem.LeftInternal+=iOffset;
|
|
else
|
|
objItem.TopInternal+=iOffset;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
protected virtual void CreateMoreItemsButton(bool isRightToLeft)
|
|
{
|
|
if(m_MoreItems==null)
|
|
{
|
|
m_MoreItems=new DisplayMoreItem();
|
|
m_MoreItems.Style=m_Style;
|
|
m_MoreItems.SetParent(this);
|
|
m_MoreItems.ThemeAware=this.ThemeAware;
|
|
}
|
|
if(m_MoreItemsOnMenu)
|
|
m_MoreItems.PopupType=ePopupType.Menu;
|
|
else
|
|
m_MoreItems.PopupType=ePopupType.ToolBar;
|
|
m_MoreItems.Orientation=m_Orientation;
|
|
m_MoreItems.Displayed=true;
|
|
|
|
if(m_Orientation==eOrientation.Vertical)
|
|
{
|
|
int paddingLeft = Dpi.Width(m_PaddingLeft);
|
|
int paddingRight = Dpi.Width(m_PaddingRight);
|
|
m_MoreItems.WidthInternal=m_Rect.Width-(paddingLeft+paddingRight);
|
|
m_MoreItems.RecalcSize();
|
|
}
|
|
else
|
|
{
|
|
int paddingTop = Dpi.Width(m_PaddingTop);
|
|
int paddingBottom = Dpi.Height(m_PaddingBottom);
|
|
m_MoreItems.HeightInternal=m_Rect.Height-(paddingTop+paddingBottom);
|
|
m_MoreItems.RecalcSize();
|
|
}
|
|
|
|
Point loc = GetMoreItemsLocation(isRightToLeft);
|
|
m_MoreItems.LeftInternal = loc.X;
|
|
m_MoreItems.TopInternal = loc.Y;
|
|
}
|
|
|
|
protected virtual Point GetMoreItemsLocation(bool isRightToLeft)
|
|
{
|
|
if (m_MoreItems == null)
|
|
return Point.Empty;
|
|
Point p = Point.Empty;
|
|
int paddingLeft = Dpi.Width(m_PaddingLeft);
|
|
if (m_Orientation == eOrientation.Vertical)
|
|
{
|
|
p.X = m_Rect.Left + paddingLeft;
|
|
int paddingBottom = Dpi.Height(m_PaddingBottom);
|
|
p.Y = m_Rect.Bottom - m_MoreItems.HeightInternal - paddingBottom;
|
|
}
|
|
else
|
|
{
|
|
if (isRightToLeft)
|
|
{
|
|
p.X = m_Rect.X + paddingLeft;
|
|
}
|
|
else
|
|
{
|
|
int paddingRight = Dpi.Width(m_PaddingRight);
|
|
p.X = m_Rect.Right - m_MoreItems.WidthInternal - paddingRight;
|
|
}
|
|
p.Y = m_Rect.Top + Dpi.Height(m_PaddingTop);
|
|
}
|
|
|
|
return p;
|
|
}
|
|
|
|
/// <summary>
|
|
/// This must be called by child item to let the parent know that its size
|
|
/// has been changed.
|
|
/// </summary>
|
|
public override void SubItemSizeChanged(BaseItem objChildItem)
|
|
{
|
|
//if(!objChildItem.Visible || !objChildItem.Displayed)
|
|
//{
|
|
// return;
|
|
//}
|
|
NeedRecalcSize=true;
|
|
if(this.Displayed)
|
|
{
|
|
if(m_Parent==null)
|
|
{
|
|
if(this.ContainerControl is Bar)
|
|
((Bar)this.ContainerControl).RecalcLayout();
|
|
else if(this.ContainerControl is MenuPanel)
|
|
((MenuPanel)this.ContainerControl).RecalcSize();
|
|
}
|
|
else
|
|
m_Parent.SubItemSizeChanged(this);
|
|
}
|
|
else
|
|
{
|
|
if(m_Parent==null)
|
|
this.RecalcSize();
|
|
else
|
|
m_Parent.SubItemSizeChanged(this);
|
|
}
|
|
}
|
|
|
|
public override void InternalMouseHover()
|
|
{
|
|
if(m_MoreItems!=null && m_MoreItems.Expanded && m_HotSubItem!=m_MoreItems && this.DesignMode)
|
|
{
|
|
m_MoreItems.Expanded=false;
|
|
}
|
|
base.InternalMouseHover();
|
|
}
|
|
|
|
public override void InternalMouseDown(System.Windows.Forms.MouseEventArgs objArg)
|
|
{
|
|
if(m_MoreItems!=null && m_MoreItems.Expanded && m_HotSubItem!=m_MoreItems && !this.DesignMode)
|
|
{
|
|
m_MoreItems.Expanded=false;
|
|
}
|
|
base.InternalMouseDown(objArg);
|
|
}
|
|
|
|
/// <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(m_HotSubItem==null && (this.IsOnMenuBar || this.LayoutType==eLayoutType.Toolbar))
|
|
{
|
|
BaseItem expanded=this.ExpandedItem();
|
|
if(expanded!=null && expanded is PopupItem)
|
|
expanded.InternalMouseUp(objArg);
|
|
}
|
|
}
|
|
|
|
public override void InternalMouseMove(System.Windows.Forms.MouseEventArgs objArg)
|
|
{
|
|
if(m_IgnoreDuplicateMouseMove)
|
|
{
|
|
if(m_LastMouseMoveEvent==null)
|
|
{
|
|
m_LastMouseMoveEvent=new System.Windows.Forms.MouseEventArgs(objArg.Button,objArg.Clicks,objArg.X,objArg.Y,objArg.Delta);
|
|
return;
|
|
}
|
|
if(m_LastMouseMoveEvent.X!=objArg.X || m_LastMouseMoveEvent.Y!=objArg.Y ||
|
|
m_LastMouseMoveEvent.Button!=objArg.Button)
|
|
{
|
|
m_IgnoreDuplicateMouseMove=false;
|
|
m_LastMouseMoveEvent=null;
|
|
}
|
|
else
|
|
return;
|
|
}
|
|
|
|
//DotNetBarManager owner=this.GetOwner();
|
|
//if(!this.DesignMode && owner!=null && owner.GetFocusItem()!=null)
|
|
// return;
|
|
|
|
// Call base implementation if we don't have the more items button
|
|
if(m_MoreItems==null || !m_MoreItems.DisplayRectangle.Contains(objArg.X,objArg.Y) || this.DesignMode)
|
|
{
|
|
bool bMenuBar=this.IsOnMenuBar;
|
|
if (bMenuBar || this.LayoutType == eLayoutType.Toolbar)
|
|
{
|
|
BaseItem expanded = this.ExpandedItem();
|
|
if (expanded != null)
|
|
expanded.InternalMouseMove(objArg);
|
|
m_CheckMouseMovePressed = true;
|
|
}
|
|
else
|
|
m_CheckMouseMovePressed = false;
|
|
|
|
if(objArg.Button==System.Windows.Forms.MouseButtons.None || this.DesignMode || (bMenuBar || this.LayoutType==eLayoutType.Toolbar))
|
|
base.InternalMouseMove(objArg);
|
|
|
|
return;
|
|
}
|
|
// Mouse is over our more items button
|
|
BaseItem objNew=m_MoreItems;
|
|
if(objNew!=m_HotSubItem)
|
|
{
|
|
if(m_HotSubItem!=null)
|
|
{
|
|
m_HotSubItem.InternalMouseLeave();
|
|
//if(objNew!=null && m_AutoExpand && m_HotSubItem.Expanded)
|
|
if(objNew!=null && m_HotSubItem.Expanded)
|
|
m_HotSubItem.Expanded=false;
|
|
}
|
|
|
|
if(objNew!=null)
|
|
{
|
|
if(m_AutoExpand)
|
|
{
|
|
BaseItem objItem=ExpandedItem();
|
|
if(objItem!=null && objItem!=objNew)
|
|
objItem.Expanded=false;
|
|
}
|
|
objNew.InternalMouseEnter();
|
|
objNew.InternalMouseMove(objArg);
|
|
if (m_AutoExpand && objNew.GetEnabled() && objNew.ShowSubItems)
|
|
{
|
|
if(objNew is PopupItem)
|
|
{
|
|
PopupItem pi=objNew as PopupItem;
|
|
ePopupAnimation oldAnim=pi.PopupAnimation;
|
|
pi.PopupAnimation=ePopupAnimation.None;
|
|
objNew.Expanded=true;
|
|
pi.PopupAnimation=oldAnim;
|
|
}
|
|
else
|
|
objNew.Expanded=true;
|
|
}
|
|
m_HotSubItem=objNew;
|
|
}
|
|
else
|
|
m_HotSubItem=null;
|
|
}
|
|
else if(m_HotSubItem!=null)
|
|
{
|
|
m_HotSubItem.InternalMouseMove(objArg);
|
|
}
|
|
}
|
|
|
|
public override void InternalKeyDown(System.Windows.Forms.KeyEventArgs objArg)
|
|
{
|
|
base.InternalKeyDown(objArg);
|
|
if(SubItems.Count==0 || objArg.Handled)
|
|
return;
|
|
|
|
BaseItem objExpanded=this.ExpandedItem();
|
|
|
|
if(objExpanded!=null)
|
|
{
|
|
objExpanded.InternalKeyDown(objArg);
|
|
if(objArg.Handled)
|
|
return;
|
|
}
|
|
|
|
if(objArg.KeyCode==System.Windows.Forms.Keys.Right || objArg.KeyCode==System.Windows.Forms.Keys.Tab || objArg.KeyCode==System.Windows.Forms.Keys.Left)
|
|
{
|
|
m_IgnoreDuplicateMouseMove=true;
|
|
// Select next object
|
|
if(m_HotSubItem!=null)
|
|
{
|
|
m_HotSubItem.InternalMouseLeave();
|
|
if(m_AutoExpand && m_HotSubItem.Expanded)
|
|
{
|
|
m_HotSubItem.Expanded=false;
|
|
}
|
|
}
|
|
if(objArg.KeyCode==System.Windows.Forms.Keys.Left)
|
|
{
|
|
int iIndex=0;
|
|
if(m_HotSubItem!=null)
|
|
iIndex=this.SubItems.IndexOf(m_HotSubItem)-1;
|
|
if(iIndex<0)
|
|
iIndex=this.SubItems.Count-1;
|
|
BaseItem objNew=null;
|
|
bool bRepeat=false;
|
|
do
|
|
{
|
|
for(int i=iIndex;i>=0;i--)
|
|
{
|
|
objNew=this.SubItems[i];
|
|
if (objNew.Visible && objNew.GetEnabled())
|
|
{
|
|
iIndex=i;
|
|
break;
|
|
}
|
|
}
|
|
if (!this.SubItems[iIndex].Visible || !this.SubItems[iIndex].GetEnabled())
|
|
{
|
|
if(!bRepeat)
|
|
{
|
|
iIndex=this.SubItems.Count-1;
|
|
bRepeat=true;
|
|
}
|
|
else
|
|
bRepeat=false;
|
|
}
|
|
else
|
|
bRepeat=false;
|
|
} while(bRepeat);
|
|
m_HotSubItem=this.SubItems[iIndex];
|
|
}
|
|
else
|
|
{
|
|
int iIndex=0;
|
|
if(m_HotSubItem!=null)
|
|
iIndex=this.SubItems.IndexOf(m_HotSubItem)+1;
|
|
while (iIndex < this.SubItems.Count && (!this.SubItems[iIndex].Visible || !this.SubItems[iIndex].GetEnabled()))
|
|
iIndex++;
|
|
if(iIndex>=this.SubItems.Count)
|
|
iIndex=0;
|
|
BaseItem objNew=null;
|
|
for(int i=iIndex;i<this.SubItems.Count;i++)
|
|
{
|
|
objNew=this.SubItems[i];
|
|
if (objNew.Visible && objNew.GetEnabled())
|
|
{
|
|
iIndex=i;
|
|
break;
|
|
}
|
|
}
|
|
m_HotSubItem=this.SubItems[iIndex];
|
|
}
|
|
|
|
m_HotSubItem.InternalMouseEnter();
|
|
m_HotSubItem.InternalMouseMove(new MouseEventArgs(MouseButtons.None, 0, m_HotSubItem.LeftInternal + 2, m_HotSubItem.TopInternal + 2, 0));
|
|
//if(m_AutoExpand)
|
|
//{
|
|
BaseItem objItem=this.ExpandedItem();
|
|
if(objItem!=null && objItem!=m_HotSubItem)
|
|
objItem.Expanded=false;
|
|
//}
|
|
if(m_AutoExpand && m_HotSubItem.ShowSubItems && (this.IsOnMenuBar || this.IsOnMenu && m_HotSubItem.SubItems.Count>0))
|
|
{
|
|
m_HotSubItem.Expanded=true;
|
|
if(m_HotSubItem is PopupItem && ((PopupItem)m_HotSubItem).PopupControl is MenuPanel)
|
|
((MenuPanel)((PopupItem)m_HotSubItem).PopupControl).SelectFirstItem();
|
|
}
|
|
|
|
objArg.Handled=true;
|
|
}
|
|
if (objArg.KeyCode == System.Windows.Forms.Keys.Down && this.IsOnMenuBar)
|
|
{
|
|
m_IgnoreDuplicateMouseMove = true;
|
|
// Select next object
|
|
if (m_HotSubItem != null && !m_HotSubItem.Expanded && m_HotSubItem.VisibleSubItems > 0)
|
|
m_HotSubItem.Expanded = true;
|
|
|
|
}
|
|
else if (objArg.KeyCode == System.Windows.Forms.Keys.Escape)
|
|
{
|
|
if (objExpanded != null)
|
|
{
|
|
objExpanded.Expanded = false;
|
|
objArg.Handled = true;
|
|
}
|
|
else
|
|
{
|
|
Control cc = this.ContainerControl as Control;
|
|
if (cc is Bar)
|
|
{
|
|
Bar bar = cc as Bar;
|
|
if (bar.BarState == eBarState.Popup)
|
|
{
|
|
bar.ParentItem.Expanded = false;
|
|
}
|
|
else
|
|
{
|
|
if (this.AutoExpand)
|
|
this.AutoExpand = false;
|
|
else if (bar.Focused || bar.MenuFocus)
|
|
{
|
|
bar.MenuFocus = false;
|
|
bar.ReleaseFocus();
|
|
}
|
|
}
|
|
objArg.Handled = true;
|
|
}
|
|
else if (cc is ItemControl)
|
|
{
|
|
ItemControl ic = cc as ItemControl;
|
|
if (this.AutoExpand)
|
|
this.AutoExpand = false;
|
|
else if (ic.Focused || ic.MenuFocus)
|
|
{
|
|
ic.MenuFocus = false;
|
|
ic.ReleaseFocus();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
BaseItem objItem = this.ExpandedItem();
|
|
if (objItem != null)
|
|
objItem.InternalKeyDown(objArg);
|
|
else
|
|
{
|
|
int key = 0;
|
|
if (objArg.Shift)
|
|
{
|
|
try
|
|
{
|
|
byte[] keyState = new byte[256];
|
|
if (NativeFunctions.GetKeyboardState(keyState))
|
|
{
|
|
byte[] chars = new byte[2];
|
|
if (NativeFunctions.ToAscii((uint)objArg.KeyValue, 0, keyState, chars, 0) != 0)
|
|
{
|
|
key = chars[0];
|
|
}
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
key = 0;
|
|
}
|
|
}
|
|
|
|
if (key == 0)
|
|
key = (int)NativeFunctions.MapVirtualKey((uint)objArg.KeyValue, 2);
|
|
|
|
bool b = false;
|
|
if (key > 0)
|
|
b = AccessKeyDown(key);
|
|
if (b)
|
|
objArg.Handled = true;
|
|
if (!b && m_HotSubItem != null)
|
|
m_HotSubItem.InternalKeyDown(objArg);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Checks whether Access key is pressed and expands item if it was. Applies to menu bar items only
|
|
// Assumes that NO item is expanded when call is made
|
|
private bool AccessKeyDown(int KeyCode)
|
|
{
|
|
char[] ch=new char[1];
|
|
byte[] by=new byte[1];
|
|
try
|
|
{
|
|
by[0]=System.Convert.ToByte(KeyCode);
|
|
System.Text.Encoding.Default.GetDecoder().GetChars(by,0,1,ch,0);
|
|
}
|
|
catch(Exception)
|
|
{
|
|
return false;
|
|
}
|
|
string s=ch[0].ToString();
|
|
if(s=="")
|
|
return false;
|
|
ch[0]=(s.ToLower())[0];
|
|
BaseItem expandedItem=this.ExpandedItem();
|
|
if(expandedItem!=null && expandedItem is PopupItem && ((PopupItem)expandedItem).PopupType==ePopupType.Menu)
|
|
{
|
|
System.Windows.Forms.KeyEventArgs ke=new System.Windows.Forms.KeyEventArgs((System.Windows.Forms.Keys)KeyCode);
|
|
expandedItem.InternalKeyDown(ke);
|
|
if(ke.Handled)
|
|
{
|
|
m_IgnoreDuplicateMouseMove=true;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
foreach(BaseItem objItem in this.SubItems)
|
|
{
|
|
if (objItem.Visible && objItem.GetEnabled() && objItem.Displayed && objItem.AccessKey == ch[0])
|
|
{
|
|
if(objItem is ButtonItem && ((ButtonItem)objItem).ButtonStyle==eButtonStyle.Default && !this.IsOnMenuBar && !this.IsOnMenu)
|
|
continue;
|
|
if (objItem.SubItems.Count > 0 && objItem.ShowSubItems && objItem.GetEnabled())
|
|
{
|
|
if(objItem.Expanded)
|
|
{
|
|
objItem.InternalKeyDown(new System.Windows.Forms.KeyEventArgs((System.Windows.Forms.Keys)KeyCode));
|
|
}
|
|
else
|
|
ExpandItem(objItem);
|
|
}
|
|
else
|
|
objItem.RaiseClick();
|
|
m_IgnoreDuplicateMouseMove=true;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
internal bool SysKeyDown(int KeyCode)
|
|
{
|
|
return AccessKeyDown(KeyCode);
|
|
// char[] ch=new char[1];
|
|
// byte[] by=new byte[1];
|
|
// by[0]=System.Convert.ToByte(KeyCode);
|
|
// System.Text.Encoding.Default.GetDecoder().GetChars(by,0,1,ch,0);
|
|
// string s=ch[0].ToString();
|
|
// ch[0]=(s.ToLower())[0];
|
|
// foreach(BaseItem objItem in this.SubItems)
|
|
// {
|
|
// if(objItem.Displayed && objItem.AccessKey==ch[0])
|
|
// {
|
|
// if(!objItem.Expanded)
|
|
// {
|
|
// ExpandItem(objItem);
|
|
//// // Set the focus here so it can be properly released...
|
|
//// Bar bar=this.ContainerControl as Bar;
|
|
//// if(bar!=null)
|
|
//// bar.Focus();
|
|
//// if(m_HotSubItem!=null)
|
|
//// m_HotSubItem.InternalMouseLeave();
|
|
//// m_HotSubItem=objItem;
|
|
//// objItem.InternalMouseEnter();
|
|
//// objItem.Expanded=true;
|
|
//// if(objItem is PopupItem)
|
|
//// this.AutoExpand=true;
|
|
// }
|
|
// return true;
|
|
// }
|
|
// }
|
|
// return false;
|
|
}
|
|
|
|
private void ExpandItem(BaseItem objItem)
|
|
{
|
|
// Set the focus here so it can be properly released...
|
|
Control cc = this.ContainerControl as Control;
|
|
//if(bar!=null && !bar.Focused) // Commented out to fix menu bar taking the focus
|
|
// bar.Focus();
|
|
if (cc is Bar && !cc.Focused)
|
|
((Bar)cc).MenuFocus = true;
|
|
|
|
if(m_HotSubItem!=null)
|
|
m_HotSubItem.InternalMouseLeave();
|
|
m_HotSubItem=objItem;
|
|
objItem.InternalMouseEnter();
|
|
objItem.InternalMouseMove(new MouseEventArgs(MouseButtons.None, 0, objItem.LeftInternal + 2, objItem.TopInternal + 2, 0));
|
|
objItem.Expanded=true;
|
|
if(objItem is PopupItem)
|
|
{
|
|
this.AutoExpand=true;
|
|
// If it is a menu select first menu item inside...
|
|
PopupItem popup=objItem as PopupItem;
|
|
if(popup.PopupType==ePopupType.Menu && popup.PopupControl is MenuPanel)
|
|
{
|
|
((MenuPanel)popup.PopupControl).SelectFirstItem();
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool EqualButtonSize
|
|
{
|
|
get
|
|
{
|
|
return m_EqualButtonSize;
|
|
}
|
|
set
|
|
{
|
|
if(m_EqualButtonSize!=value)
|
|
{
|
|
m_EqualButtonSize=value;
|
|
NeedRecalcSize=true;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*public bool Stretch
|
|
{
|
|
get
|
|
{
|
|
return m_Stretch;
|
|
}
|
|
set
|
|
{
|
|
if(m_Stretch!=value)
|
|
{
|
|
m_Stretch=value;
|
|
m_NeedRecalcSize=true;
|
|
}
|
|
}
|
|
}*/
|
|
|
|
public override void ContainerLostFocus(bool appLostFocus)
|
|
{
|
|
base.ContainerLostFocus(appLostFocus);
|
|
if(m_MoreItems!=null)
|
|
m_MoreItems.ContainerLostFocus(appLostFocus);
|
|
IOwnerMenuSupport ownersupport=this.GetOwner() as IOwnerMenuSupport;
|
|
if(this.IsOnMenuBar && ownersupport!=null)
|
|
ownersupport.PersonalizedAllVisible=false;
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called when item owner has changed.
|
|
/// </summary>
|
|
protected override void OnOwnerChanged()
|
|
{
|
|
base.OnOwnerChanged();
|
|
if(this.GetOwner() is Bar)
|
|
{
|
|
this.RefreshImageSize();
|
|
}
|
|
}
|
|
|
|
protected internal override void OnSubItemExpandChange(BaseItem objItem)
|
|
{
|
|
base.OnSubItemExpandChange(objItem);
|
|
if(objItem.Expanded)
|
|
{
|
|
foreach(BaseItem objExp in this.SubItems)
|
|
{
|
|
if(objExp!=objItem && objExp is PopupItem && objExp.Expanded)
|
|
objExp.Expanded=false;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets a value indicating whether the item is expanded or not. For Popup items this would indicate whether the item is popped up or not.
|
|
/// </summary>
|
|
[System.ComponentModel.Browsable(false),System.ComponentModel.DefaultValue(false),System.ComponentModel.DesignerSerializationVisibility(System.ComponentModel.DesignerSerializationVisibility.Hidden)]
|
|
public override bool Expanded
|
|
{
|
|
get
|
|
{
|
|
return m_Expanded;
|
|
}
|
|
set
|
|
{
|
|
base.Expanded=value;
|
|
if(!value && this.ContainerControl is ItemControl)
|
|
BaseItem.CollapseSubItems(this);
|
|
}
|
|
}
|
|
|
|
internal void SetSystemFocus()
|
|
{
|
|
if(m_HotSubItem!=null || this.SubItems.Count==0)
|
|
return;
|
|
|
|
BaseItem exp = this.ExpandedItem();
|
|
if (exp != null)
|
|
{
|
|
m_HotSubItem = exp;
|
|
m_HotSubItem.InternalMouseEnter();
|
|
m_HotSubItem.InternalMouseMove(new MouseEventArgs(MouseButtons.None, 0, m_HotSubItem.LeftInternal + 2, m_HotSubItem.TopInternal + 2, 0));
|
|
return;
|
|
}
|
|
|
|
foreach(BaseItem objItem in this.SubItems)
|
|
{
|
|
if(!objItem.SystemItem && objItem.Displayed && objItem.Visible)
|
|
{
|
|
m_HotSubItem=objItem;
|
|
m_HotSubItem.InternalMouseEnter();
|
|
m_HotSubItem.InternalMouseMove(new MouseEventArgs(MouseButtons.None, 0, m_HotSubItem.LeftInternal + 2, m_HotSubItem.TopInternal + 2, 0));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void ReleaseSystemFocus()
|
|
{
|
|
CollapseSubItems(this);
|
|
if(m_HotSubItem!=null)
|
|
{
|
|
Control c = this.ContainerControl as Control;
|
|
if (c != null)
|
|
{
|
|
Point p = c.PointToClient(Control.MousePosition);
|
|
if (m_HotSubItem.DisplayRectangle.Contains(p))
|
|
return;
|
|
}
|
|
m_HotSubItem.InternalMouseLeave();
|
|
m_HotSubItem=null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether container is system container used internally by DotNetBar.
|
|
/// </summary>
|
|
[System.ComponentModel.Browsable(false),DevCoBrowsable(false),System.ComponentModel.DesignerSerializationVisibility(System.ComponentModel.DesignerSerializationVisibility.Hidden),System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
|
|
public bool SystemContainer
|
|
{
|
|
get
|
|
{
|
|
return m_SystemContainer;
|
|
}
|
|
set
|
|
{
|
|
m_SystemContainer=value;
|
|
}
|
|
}
|
|
|
|
public bool HaveCustomizeItem
|
|
{
|
|
get
|
|
{
|
|
return m_HaveCustomizeItem;
|
|
}
|
|
}
|
|
|
|
protected internal override void OnItemAdded(BaseItem objItem)
|
|
{
|
|
base.OnItemAdded(objItem);
|
|
if (ItemAdded != null)
|
|
ItemAdded(objItem, new EventArgs());
|
|
if(objItem is CustomizeItem)
|
|
m_HaveCustomizeItem=true;
|
|
else if(this.SystemContainer && objItem is DockContainerItem)
|
|
{
|
|
Bar bar=this.ContainerControl as Bar;
|
|
if(bar!=null && bar.LayoutType==eLayoutType.DockContainer)
|
|
{
|
|
if(this.VisibleSubItems>1)
|
|
{
|
|
objItem.Displayed=false;
|
|
}
|
|
bar.RefreshDockTab(true);
|
|
}
|
|
}
|
|
}
|
|
protected internal override void OnAfterItemRemoved(BaseItem objItem, int itemIndex)
|
|
{
|
|
base.OnAfterItemRemoved(objItem, itemIndex);
|
|
if(objItem is CustomizeItem)
|
|
m_HaveCustomizeItem=false;
|
|
else if(this.SystemContainer)
|
|
{
|
|
Bar bar=this.ContainerControl as Bar;
|
|
if(bar!=null)
|
|
bar.OnSubItemRemoved(objItem);
|
|
}
|
|
}
|
|
|
|
protected internal override bool IsAnyOnHandle(IntPtr iHandle)
|
|
{
|
|
if(m_MoreItems!=null)
|
|
{
|
|
if(m_MoreItems.IsAnyOnHandle(iHandle))
|
|
return true;
|
|
}
|
|
return base.IsAnyOnHandle(iHandle);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Return Sub Item at specified location
|
|
/// </summary>
|
|
public override BaseItem ItemAtLocation(int x, int y)
|
|
{
|
|
if (m_SubItems != null)
|
|
{
|
|
foreach (BaseItem objSub in m_SubItems)
|
|
{
|
|
if (objSub.IsContainer)
|
|
{
|
|
BaseItem item = objSub.ItemAtLocation(x, y);
|
|
if (item != null)
|
|
return item;
|
|
}
|
|
else
|
|
{
|
|
if ((objSub.Visible || this.IsOnCustomizeMenu) && objSub.Displayed && objSub.DisplayRectangle.Contains(x, y))
|
|
{
|
|
return objSub;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
|
|
public override bool AutoExpand
|
|
{
|
|
get
|
|
{
|
|
return base.AutoExpand;
|
|
}
|
|
set
|
|
{
|
|
base.AutoExpand=value;
|
|
if(this.SystemContainer)
|
|
{
|
|
Bar bar=this.ContainerControl as Bar;
|
|
if(bar!=null)
|
|
{
|
|
// TODO: To fix the focus menu expand comment this out
|
|
// if(this.AutoExpand && !bar.Focused)
|
|
// bar.Focus();
|
|
// else if(!this.AutoExpand && bar.Focused)
|
|
// bar.ReleaseFocus();
|
|
if(this.AutoExpand && !bar.MenuFocus)
|
|
bar.MenuFocus=true;
|
|
else if(!this.AutoExpand && bar.MenuFocus)
|
|
bar.MenuFocus=false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
internal bool EventHeight
|
|
{
|
|
get {return m_EventHeight;}
|
|
set {m_EventHeight=value;}
|
|
}
|
|
|
|
internal bool UseMoreItemsButton
|
|
{
|
|
get {return m_UseMoreItemsButton;}
|
|
set {m_UseMoreItemsButton=value;}
|
|
}
|
|
|
|
internal eContainerVerticalAlignment ToolbarItemsAlign
|
|
{
|
|
get { return m_ToolbarItemsAlign; }
|
|
set { m_ToolbarItemsAlign = value; }
|
|
}
|
|
|
|
public virtual eLayoutType LayoutType
|
|
{
|
|
get
|
|
{
|
|
return m_LayoutType;
|
|
}
|
|
set
|
|
{
|
|
if(m_LayoutType==value)
|
|
return;
|
|
m_LayoutType=value;
|
|
NeedRecalcSize=true;
|
|
if(m_LayoutType==eLayoutType.TaskList)
|
|
{
|
|
base.Orientation=eOrientation.Horizontal;
|
|
}
|
|
else
|
|
{
|
|
if(this.ContainerControl!=null && this.ContainerControl is Bar)
|
|
{
|
|
Bar bar=this.ContainerControl as Bar;
|
|
if(bar.DockedSite!=null && bar.DockedSite is DockSite)
|
|
base.Orientation=((DockSite)bar.DockedSite).DockOrientation;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.ComponentModel.Browsable(false)]
|
|
public override eOrientation Orientation
|
|
{
|
|
get
|
|
{
|
|
if(m_LayoutType==eLayoutType.TaskList)
|
|
return eOrientation.Vertical;
|
|
return base.Orientation;
|
|
}
|
|
set
|
|
{
|
|
if(m_LayoutType==eLayoutType.TaskList)
|
|
return;
|
|
base.Orientation=value;
|
|
}
|
|
}
|
|
|
|
public Color BackColor
|
|
{
|
|
get
|
|
{
|
|
if(!m_BackgroundColor.IsEmpty)
|
|
return m_BackgroundColor;
|
|
else if (EffectiveStyle == eDotNetBarStyle.Office2000 || this.IsOnMenuBar)
|
|
return SystemColors.Control;
|
|
else
|
|
return ColorFunctions.ToolMenuFocusBackColor();
|
|
}
|
|
set
|
|
{
|
|
if(m_BackgroundColor!=value)
|
|
{
|
|
m_BackgroundColor=value;
|
|
this.Refresh();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// When parent items does recalc size for its sub-items it should query
|
|
/// image size and store biggest image size into this property.
|
|
/// </summary>
|
|
[System.ComponentModel.Browsable(false), System.ComponentModel.DesignerSerializationVisibility(System.ComponentModel.DesignerSerializationVisibility.Hidden), System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
|
|
public override System.Drawing.Size SubItemsImageSize
|
|
{
|
|
get
|
|
{
|
|
return base.SubItemsImageSize;
|
|
}
|
|
set
|
|
{
|
|
if(m_TrackSubItemsImageSize)
|
|
base.SubItemsImageSize = value;
|
|
}
|
|
}
|
|
|
|
internal bool TrackSubItemsImageSize
|
|
{
|
|
get { return m_TrackSubItemsImageSize; }
|
|
set
|
|
{
|
|
m_TrackSubItemsImageSize = value;
|
|
if (!m_TrackSubItemsImageSize)
|
|
base.SubItemsImageSize = new Size(16, 16);
|
|
}
|
|
}
|
|
|
|
//***********************************************
|
|
// IDesignTimeProvider Implementation
|
|
//***********************************************
|
|
public InsertPosition GetInsertPosition(Point pScreen, BaseItem DragItem)
|
|
{
|
|
return DesignTimeProviderContainer.GetInsertPosition(this, pScreen, DragItem);
|
|
}
|
|
public void DrawReversibleMarker(int iPos, bool Before)
|
|
{
|
|
DesignTimeProviderContainer.DrawReversibleMarker(this, iPos, Before);
|
|
return;
|
|
}
|
|
|
|
public void InsertItemAt(BaseItem objItem, int iPos, bool Before)
|
|
{
|
|
DesignTimeProviderContainer.InsertItemAt(this, objItem, iPos, Before);
|
|
return;
|
|
}
|
|
|
|
private int GetAppendPosition(BaseItem objParent)
|
|
{
|
|
int iPos=-1;
|
|
for(int i=objParent.SubItems.Count-1;i>=0;i--)
|
|
{
|
|
if(objParent.SubItems[i].SystemItem)
|
|
iPos=i;
|
|
else
|
|
break;
|
|
}
|
|
return iPos;
|
|
}
|
|
|
|
public int PaddingLeft
|
|
{
|
|
get{return m_PaddingLeft;}
|
|
set{m_PaddingLeft=value;}
|
|
}
|
|
public int PaddingRight
|
|
{
|
|
get{return m_PaddingRight;}
|
|
set{m_PaddingRight=value;}
|
|
}
|
|
public int PaddingTop
|
|
{
|
|
get{return m_PaddingTop;}
|
|
set{m_PaddingTop=value;}
|
|
}
|
|
public int PaddingBottom
|
|
{
|
|
get{return m_PaddingBottom;}
|
|
set{m_PaddingBottom=value;}
|
|
}
|
|
|
|
private bool _FillsContainerControl = false;
|
|
/// <summary>
|
|
/// Gets or sets whether item container fills the container control completely.
|
|
/// </summary>
|
|
public bool FillsContainerControl
|
|
{
|
|
get { return _FillsContainerControl; }
|
|
set { _FillsContainerControl = value; }
|
|
}
|
|
}
|
|
}
|