Code:
/ DotNET / DotNET / 8.0 / untmp / whidbey / REDBITS / ndp / fx / src / WinForms / Managed / System / WinForms / ToolStripSplitStackLayout.cs / 1 / ToolStripSplitStackLayout.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
namespace System.Windows.Forms {
using System;
using System.Windows.Forms.Layout;
using System.Drawing;
using System.Diagnostics;
using System.Globalization;
internal class ToolStripSplitStackLayout : LayoutEngine {
private int backwardsWalkingIndex;
private int forwardsWalkingIndex;
private ToolStrip toolStrip;
private int overflowSpace;
private bool overflowRequired;
private Point noMansLand;
private Rectangle displayRectangle = Rectangle.Empty;
#if DEBUG
internal static readonly TraceSwitch DebugLayoutTraceSwitch = new TraceSwitch("DebugLayout", "Debug ToolStrip Layout code");
#else
internal static readonly TraceSwitch DebugLayoutTraceSwitch;
#endif
internal ToolStripSplitStackLayout(ToolStrip owner) {
this.toolStrip = owner;
}
// this is the index we use to send items to the overflow
// if we run out of room
protected int BackwardsWalkingIndex {
get {
return backwardsWalkingIndex;
}
set {
backwardsWalkingIndex = value;
}
}
// this is the index we use to walk the items and make
// decisions if there is enough room.
protected int ForwardsWalkingIndex {
get {
return forwardsWalkingIndex;
}
set {
forwardsWalkingIndex = value;
}
}
private Size OverflowButtonSize {
get {
ToolStrip toolStrip = this.ToolStrip;
if (!toolStrip.CanOverflow) {
return Size.Empty;
}
// since we havent parented the item yet - the auto size wont have reset the size yet.
Size overflowButtonSize = toolStrip.OverflowButton.AutoSize ? toolStrip.OverflowButton.GetPreferredSize(displayRectangle.Size) : toolStrip.OverflowButton.Size;
return overflowButtonSize + toolStrip.OverflowButton.Margin.Size;
}
}
private int OverflowSpace {
get {
return overflowSpace;
}
set {
overflowSpace = value;
}
}
private bool OverflowRequired {
get {
return overflowRequired;
}
set {
overflowRequired = value;
}
}
// the current winbar we're operating over.
public ToolStrip ToolStrip {
get {
return toolStrip;
}
}
//
// This method will mark whether items should be placed in the overflow or on the main winbar.
//
private void CalculatePlacementsHorizontal() {
ResetItemPlacements();
ToolStrip toolStrip = this.ToolStrip;
int currentWidth = 0; //toolStrip.Padding.Horizontal;
if (ToolStrip.CanOverflow) {
// determine the locations of all the items.
for (ForwardsWalkingIndex = 0; ForwardsWalkingIndex < toolStrip.Items.Count; ForwardsWalkingIndex++) {
ToolStripItem item = toolStrip.Items[ForwardsWalkingIndex];
if (!((IArrangedElement)item).ParticipatesInLayout) {
// skip over items not participating in layout. E.G. not visible items
continue;
}
// if we have something set to overflow always we need to show an overflow button
if (item.Overflow == ToolStripItemOverflow.Always) {
#if DEBUG
if (DebugLayoutTraceSwitch.TraceVerbose) { Debug.WriteLine(String.Format(CultureInfo.CurrentCulture, "OverflowRequired - item set to alaways overflow: {0} ", item)); }
#endif
OverflowRequired = true;
}
if (item.Overflow != ToolStripItemOverflow.Always && item.Placement == ToolStripItemPlacement.None) {
// since we havent parented the item yet - the auto size wont have reset the size yet.
Size itemSize = item.AutoSize ? item.GetPreferredSize(this.displayRectangle.Size) : item.Size;
currentWidth += itemSize.Width + item.Margin.Horizontal;
int overflowWidth = (OverflowRequired) ? OverflowButtonSize.Width : 0;
if (currentWidth > displayRectangle.Width - overflowWidth) {
#if DEBUG
if (DebugLayoutTraceSwitch.TraceVerbose) { Debug.WriteLine("SendNextItemToOverflow to fres space for " + item.ToString()); }
#endif
int spaceRecovered = SendNextItemToOverflow((currentWidth + overflowWidth) - displayRectangle.Width, true);
currentWidth -= spaceRecovered;
}
}
}
}
PlaceItems();
}
//
// This method will mark whether items should be placed in the overflow or on the main winbar.
//
private void CalculatePlacementsVertical() {
ResetItemPlacements();
ToolStrip toolStrip = this.ToolStrip;
int currentHeight = 0; //toolStrip.Padding.Vertical;
if (ToolStrip.CanOverflow) {
// determine the locations of all the items.
for (ForwardsWalkingIndex = 0; ForwardsWalkingIndex < ToolStrip.Items.Count; ForwardsWalkingIndex++) {
ToolStripItem item = toolStrip.Items[ForwardsWalkingIndex];
if (!((IArrangedElement)item).ParticipatesInLayout) {
// skip over items not participating in layout. E.G. not visible items
continue;
}
// if we have something set to overflow always we need to show an overflow button
if (item.Overflow == ToolStripItemOverflow.Always) {
OverflowRequired = true;
#if DEBUG
if (DebugLayoutTraceSwitch.TraceVerbose) Debug.WriteLine(String.Format(CultureInfo.CurrentCulture, "OverflowRequired - item set to always overflow: {0} ", item));
#endif
}
if (item.Overflow != ToolStripItemOverflow.Always && item.Placement == ToolStripItemPlacement.None) {
// since we havent parented the item yet - the auto size wont have reset the size yet.
Size itemSize = item.AutoSize ? item.GetPreferredSize(displayRectangle.Size) : item.Size;
int overflowWidth = (OverflowRequired) ? OverflowButtonSize.Height : 0;
currentHeight += itemSize.Height + item.Margin.Vertical;
#if DEBUG
if (DebugLayoutTraceSwitch.TraceVerbose) { Debug.WriteLine(String.Format(CultureInfo.CurrentCulture, "Adding {0} Size {1} to currentHeight = {2}", item.ToString(), itemSize, currentHeight)); }
#endif
if (currentHeight > displayRectangle.Height - overflowWidth) {
#if DEBUG
if (DebugLayoutTraceSwitch.TraceVerbose) { Debug.WriteLine(String.Format(CultureInfo.CurrentCulture, "Got to {0} and realized that currentHeight = {1} is larger than displayRect {2} minus overflow {3}", item.ToString(), currentHeight, displayRectangle, overflowWidth)); }
#endif
int spaceRecovered = SendNextItemToOverflow(currentHeight - displayRectangle.Height, false);
currentHeight -= spaceRecovered;
}
}
}
}
PlaceItems();
}
internal override Size GetPreferredSize(IArrangedElement container, Size proposedConstraints) {
// undone be more clever here - perhaps figure out the biggest element and return that.
if (!(container is ToolStrip)) {
throw new NotSupportedException(SR.GetString(SR.ToolStripSplitStackLayoutContainerMustBeAToolStrip));
}
if (toolStrip.LayoutStyle == ToolStripLayoutStyle.HorizontalStackWithOverflow) {
return ToolStrip.GetPreferredSizeHorizontal(container, proposedConstraints);
}
else {
return ToolStrip.GetPreferredSizeVertical(container, proposedConstraints);
}
}
// each time we perform a complete layout this stuff should be re-initialized
private void InvalidateLayout() {
forwardsWalkingIndex = 0;
backwardsWalkingIndex = -1;
overflowSpace = 0;
overflowRequired = false;
displayRectangle = Rectangle.Empty;
}
// this is part of the LayoutEngine - called when we need to do a layout.
internal override bool LayoutCore(IArrangedElement container, LayoutEventArgs layoutEventArgs) {
if (!(container is ToolStrip)) {
throw new NotSupportedException(SR.GetString(SR.ToolStripSplitStackLayoutContainerMustBeAToolStrip));
}
InvalidateLayout();
this.displayRectangle = toolStrip.DisplayRectangle;
// pick a location that's outside of the displayed region to send
// items that will potentially clobber/overlay others.
noMansLand = displayRectangle.Location;
noMansLand.X += toolStrip.ClientSize.Width + 1;
noMansLand.Y += toolStrip.ClientSize.Height + 1;
if (toolStrip.LayoutStyle == ToolStripLayoutStyle.HorizontalStackWithOverflow) {
LayoutHorizontal();
}
else {
LayoutVertical();
}
return CommonProperties.GetAutoSize(container);
}
private bool LayoutHorizontal() {
ToolStrip toolStrip = ToolStrip;
Rectangle clientRectangle = toolStrip.ClientRectangle;
#if DEBUG
if (DebugLayoutTraceSwitch.TraceVerbose) { Debug.WriteLine("_________________________\r\nHorizontal Layout:" + toolStrip.ToString() + displayRectangle.ToString()); }
#endif
int lastRight = displayRectangle.Right;// - toolStrip.Padding.Right;
int lastLeft = displayRectangle.Left;// + toolStrip.Padding.Left;
bool needsMoreSpace = false;
Size itemSize = Size.Empty;
Rectangle alignedLeftItems = Rectangle.Empty;
Rectangle alignedRightItems = Rectangle.Empty;
// this will determine where the item should be placed.
CalculatePlacementsHorizontal();
bool needOverflow = toolStrip.CanOverflow && ((OverflowRequired) || (OverflowSpace >= OverflowButtonSize.Width));
toolStrip.OverflowButton.Visible = needOverflow;
// if we require the overflow, it should stick up against the edge of the toolstrip.
if (needOverflow) {
if (toolStrip.RightToLeft == RightToLeft.No) {
lastRight = clientRectangle.Right;
}
else {
lastLeft = clientRectangle.Left;
}
}
for (int j = -1; j < toolStrip.Items.Count; j++) {
ToolStripItem item = null;
if (j == -1) {
// the first time through place the overflow button if its required.
if (needOverflow) {
item = toolStrip.OverflowButton;
item.SetPlacement(ToolStripItemPlacement.Main);
itemSize = OverflowButtonSize;
}
else {
item = toolStrip.OverflowButton;
item.SetPlacement(ToolStripItemPlacement.None);
continue;
}
}
else {
item = toolStrip.Items[j];
if (!((IArrangedElement)item).ParticipatesInLayout) {
// skip over items not participating in layout. E.G. not visible items
continue;
}
// since we havent parented the item yet - the auto size wont have reset the size yet.
itemSize = item.AutoSize ? item.GetPreferredSize(Size.Empty) : item.Size;
}
// if it turns out we dont need the overflow (because there are no Overflow.Always items and the width of everything
// in the overflow is less than the width of the overflow button then reset the placement of the as needed items to
// main.
if (!needOverflow && (item.Overflow == ToolStripItemOverflow.AsNeeded && item.Placement == ToolStripItemPlacement.Overflow)) {
#if DEBUG
if (DebugLayoutTraceSwitch.TraceVerbose) { Debug.WriteLine(String.Format(CultureInfo.CurrentCulture, "Resetting {0} to Main - we dont need it to overflow", item)); }
#endif
item.SetPlacement(ToolStripItemPlacement.Main);
}
// Now do the guts of setting X, Y and parenting.
// We need to honor left to right and head and tail.
// In RTL.Yes, Head is to the Right, Tail is to the Left
// In RTL.No, Head is to the Left, Tail is to the Right
if ((item != null) && (item.Placement == ToolStripItemPlacement.Main)) {
int x = displayRectangle.Left;
int y = displayRectangle.Top;
Padding itemMargin = item.Margin;
if (((item.Alignment == ToolStripItemAlignment.Right) && (toolStrip.RightToLeft == RightToLeft.No)) || ((item.Alignment == ToolStripItemAlignment.Left) && (toolStrip.RightToLeft == RightToLeft.Yes))) {
// lastRight x Margin.Right
// [Item]<----------[Item]----------->|
// Margin.Left
// this item should be placed to the right
// we work backwards from the right edge - that is place items from right to left.
x = lastRight - (itemMargin.Right + itemSize.Width);
y += itemMargin.Top;
lastRight = x - itemMargin.Left;
alignedRightItems = (alignedRightItems == Rectangle.Empty) ? new Rectangle(x,y,itemSize.Width, itemSize.Height)
: Rectangle.Union(alignedRightItems, new Rectangle(x,y,itemSize.Width, itemSize.Height));
}
else {
// x Margin.Right lastLeft
// |<----------[Item]------------>|
// Margin.Left
// this item should be placed to the left
// we work forwards from the left - that is place items from left to right
x = lastLeft + itemMargin.Left;
y += itemMargin.Top;
lastLeft = x + itemSize.Width + itemMargin.Right;
alignedLeftItems = (alignedLeftItems == Rectangle.Empty) ? new Rectangle(x,y,itemSize.Width, itemSize.Height)
: Rectangle.Union(alignedLeftItems, new Rectangle(x,y,itemSize.Width, itemSize.Height));
}
item.ParentInternal = ToolStrip;
Point itemLocation = new Point(x,y);
if (!clientRectangle.Contains(x, y)) {
item.SetPlacement(ToolStripItemPlacement.None);
}
else if (alignedRightItems.Width > 0 && alignedLeftItems.Width > 0 && alignedRightItems.IntersectsWith(alignedLeftItems)) {
itemLocation = noMansLand;
item.SetPlacement(ToolStripItemPlacement.None);
}
if (item.AutoSize) {
// autosized items stretch from edge-edge
itemSize.Height = Math.Max(displayRectangle.Height - itemMargin.Vertical, 0);
}
else {
// non autosized items are vertically centered
Rectangle bounds = LayoutUtils.VAlign(item.Size, displayRectangle, AnchorStyles.None);
itemLocation.Y = bounds.Y;
}
SetItemLocation(item, itemLocation, itemSize);
}
else {
item.ParentInternal = (item.Placement == ToolStripItemPlacement.Overflow) ? toolStrip.OverflowButton.DropDown : null;
}
#if DEBUG
if (DebugLayoutTraceSwitch.TraceVerbose) { Debug.WriteLine(String.Format(CultureInfo.CurrentCulture, "Item {0} Placement {1} Bounds {2} Parent {3}", item.ToString(), item.Placement.ToString(), item.Bounds.ToString(), (item.ParentInternal == null) ? "null" : item.ParentInternal.ToString())); }
#endif
}
//
return needsMoreSpace;
}
private bool LayoutVertical() {
#if DEBUG
if (DebugLayoutTraceSwitch.TraceVerbose) { Debug.WriteLine("_________________________\r\nVertical Layout" + displayRectangle.ToString()); }
#endif
ToolStrip toolStrip = ToolStrip;
Rectangle clientRectangle = toolStrip.ClientRectangle;
int lastBottom = displayRectangle.Bottom;
int lastTop = displayRectangle.Top;
bool needsMoreSpace = false;
Size itemSize = Size.Empty;
Rectangle alignedLeftItems = Rectangle.Empty;
Rectangle alignedRightItems = Rectangle.Empty;
Size toolStripPreferredSize = displayRectangle.Size;
DockStyle dock = toolStrip.Dock;
if (toolStrip.AutoSize && (!toolStrip.IsInToolStripPanel && (dock == DockStyle.Left) || (dock == DockStyle.Right))) {
// if we're autosizing, make sure we pad out items to the preferred width, not the
// width of the display rectangle.
toolStripPreferredSize = ToolStrip.GetPreferredSizeVertical(toolStrip, Size.Empty) - toolStrip.Padding.Size;
}
CalculatePlacementsVertical();
bool needOverflow = toolStrip.CanOverflow && ((OverflowRequired) || (OverflowSpace >= OverflowButtonSize.Height));
toolStrip.OverflowButton.Visible = needOverflow;
for (int j = -1; j < ToolStrip.Items.Count; j++) {
ToolStripItem item = null;
if (j == -1) {
// the first time through place the overflow button if its required.
if (needOverflow) {
item = toolStrip.OverflowButton;
item.SetPlacement(ToolStripItemPlacement.Main);
}
else {
item = toolStrip.OverflowButton;
item.SetPlacement(ToolStripItemPlacement.None);
continue;
}
itemSize = OverflowButtonSize;
}
else {
item = toolStrip.Items[j];
if (!((IArrangedElement)item).ParticipatesInLayout) {
// skip over items not participating in layout. E.G. not visible items
continue;
}
// since we havent parented the item yet - the auto size wont have reset the size yet.
itemSize = item.AutoSize ? item.GetPreferredSize(Size.Empty) : item.Size;
}
// if it turns out we dont need the overflow (because there are no Overflow.Always items and the height of everything
// in the overflow is less than the width of the overflow button then reset the placement of the as needed items to
// main.
if (!needOverflow && (item.Overflow == ToolStripItemOverflow.AsNeeded && item.Placement == ToolStripItemPlacement.Overflow)) {
#if DEBUG
if (DebugLayoutTraceSwitch.TraceVerbose) { Debug.WriteLine(String.Format(CultureInfo.CurrentCulture, "Resetting {0} to Main - we dont need it to overflow", item)); }
#endif
item.SetPlacement(ToolStripItemPlacement.Main);
}
// Now do the guts of setting X, Y and parenting.
// Vertical split stack management ignores left to right.
// Items aligned to the Head are placed from Top to Bottom
// Items aligned to the Tail are placed from Bottom to Top
if ((item != null) && (item.Placement == ToolStripItemPlacement.Main)) {
Padding itemMargin = item.Margin;
int x = displayRectangle.Left + itemMargin.Left;
int y = displayRectangle.Top;
switch (item.Alignment) {
case ToolStripItemAlignment.Right:
y = lastBottom - (itemMargin.Bottom + itemSize.Height);
lastBottom = y - itemMargin.Top;
alignedRightItems = (alignedRightItems == Rectangle.Empty) ? new Rectangle(x,y,itemSize.Width, itemSize.Height)
: Rectangle.Union(alignedRightItems, new Rectangle(x,y,itemSize.Width, itemSize.Height));
break;
case ToolStripItemAlignment.Left:
default:
y = lastTop + itemMargin.Top;
lastTop = y + itemSize.Height + itemMargin.Bottom;
alignedLeftItems = (alignedLeftItems == Rectangle.Empty) ? new Rectangle(x,y,itemSize.Width, itemSize.Height)
: Rectangle.Union(alignedLeftItems, new Rectangle(x,y,itemSize.Width, itemSize.Height));
break;
}
item.ParentInternal = ToolStrip;
Point itemLocation = new Point(x,y);
if (!clientRectangle.Contains(x, y)) {
item.SetPlacement(ToolStripItemPlacement.None);
}
else if (alignedRightItems.Width > 0 && alignedLeftItems.Width > 0 && alignedRightItems.IntersectsWith(alignedLeftItems)) {
itemLocation = noMansLand;
item.SetPlacement(ToolStripItemPlacement.None);
}
if (item.AutoSize) {
// autosized items stretch from edge-edge
itemSize.Width = Math.Max(toolStripPreferredSize.Width - itemMargin.Horizontal -1, 0);
}
else {
// non autosized items are horizontally centered
Rectangle bounds = LayoutUtils.HAlign(item.Size, displayRectangle, AnchorStyles.None);
itemLocation.X = bounds.X;
}
SetItemLocation(item, itemLocation, itemSize);
}
else {
item.ParentInternal = (item.Placement == ToolStripItemPlacement.Overflow) ? toolStrip.OverflowButton.DropDown : null;
}
#if DEBUG
if (DebugLayoutTraceSwitch.TraceVerbose) { Debug.WriteLine(String.Format(CultureInfo.CurrentCulture, "Item {0} Placement {1} Bounds {2} Parent {3}", item.ToString(), item.Placement.ToString(), item.Bounds.ToString(), (item.ParentInternal == null) ? "null" : item.ParentInternal.ToString())); }
#endif
}
//
return needsMoreSpace;
}
private void SetItemLocation(ToolStripItem item, Point itemLocation, Size itemSize) {
// make sure that things that dont fit within the display rectangle arent laid out.
if ((item.Placement == ToolStripItemPlacement.Main)
&& !(item is ToolStripOverflowButton)) { // overflow buttons can be placed outside the display rect.
bool horizontal = (ToolStrip.LayoutStyle == ToolStripLayoutStyle.HorizontalStackWithOverflow);
Rectangle displayRect = displayRectangle;
Rectangle itemBounds = new Rectangle(itemLocation, itemSize);
// in horizontal if something bleeds over the top/bottom that's ok - its left/right we care about
// same in vertical.
if (horizontal) {
if ((itemBounds.Right > displayRectangle.Right)
|| (itemBounds.Left < displayRectangle.Left)) {
#if DEBUG
if (DebugLayoutTraceSwitch.TraceVerbose) { Debug.WriteLine(String.Format(CultureInfo.CurrentCulture, "[SplitStack.SetItemLocation] Sending Item {0} to NoMansLand as it doesnt fit horizontally within the DRect", item)); }
#endif
itemLocation = noMansLand;
item.SetPlacement(ToolStripItemPlacement.None);
}
}
else {
if ((itemBounds.Bottom > displayRectangle.Bottom)
|| (itemBounds.Top < displayRectangle.Top)) {
#if DEBUG
if (DebugLayoutTraceSwitch.TraceVerbose) { Debug.WriteLine(String.Format(CultureInfo.CurrentCulture, "[SplitStack.SetItemLocation] Sending Item {0} to NoMansLand as it doesnt fit verticallu within the DRect", item)); }
#endif
itemLocation = noMansLand;
item.SetPlacement(ToolStripItemPlacement.None);
}
}
}
item.SetBounds(new Rectangle(itemLocation, itemSize));
}
private void PlaceItems() {
ToolStrip toolStrip = this.ToolStrip;
for (int i = 0; i < toolStrip.Items.Count; i++) {
ToolStripItem item = toolStrip.Items[i];
// if we havent placed the items, place them now.
if (item.Placement == ToolStripItemPlacement.None) {
if (item.Overflow != ToolStripItemOverflow.Always) {
// as needed items will have already been placed into the overflow if they
// needed to move over.
item.SetPlacement(ToolStripItemPlacement.Main);
}
else {
item.SetPlacement(ToolStripItemPlacement.Overflow);
}
}
}
}
private void ResetItemPlacements() {
ToolStrip toolStrip = this.ToolStrip;
for (int i = 0; i < toolStrip.Items.Count; i++) {
if (toolStrip.Items[i].Placement == ToolStripItemPlacement.Overflow) {
toolStrip.Items[i].ParentInternal = null;
}
toolStrip.Items[i].SetPlacement(ToolStripItemPlacement.None);
}
}
//
// This method is called when we are walking through the item collection and we have realized that we
// need to free up "X" amount of space to be able to fit an item onto the winbar.
private int SendNextItemToOverflow(int spaceNeeded, bool horizontal) {
#if DEBUG
if (DebugLayoutTraceSwitch.TraceVerbose) { Debug.WriteLine(String.Format(CultureInfo.CurrentCulture, "SendNextItemToOverflow attempting to free {0}", spaceNeeded)); }
#endif
Debug.Indent();
int freedSpace = 0;
int backIndex = BackwardsWalkingIndex;
BackwardsWalkingIndex = (backIndex == -1) ? ToolStrip.Items.Count - 1 : backIndex -1;
for (; BackwardsWalkingIndex >= 0; BackwardsWalkingIndex--) {
ToolStripItem item = ToolStrip.Items[BackwardsWalkingIndex];
if (!((IArrangedElement)item).ParticipatesInLayout) {
// skip over items not participating in layout. E.G. not visible items
continue;
}
Padding itemMargin = item.Margin;
// look for items that say they're ok for overflowing.
// not looking at ones that Always overflow - as the forward walker already skips these.
if (item.Overflow == ToolStripItemOverflow.AsNeeded && item.Placement != ToolStripItemPlacement.Overflow) {
#if DEBUG
if (DebugLayoutTraceSwitch.TraceVerbose) { Debug.WriteLine(String.Format(CultureInfo.CurrentCulture, "Found candidate for sending to overflow {0}", item.ToString())); }
#endif
// since we havent parented the item yet - the auto size wont have reset the size yet.
Size itemSize = item.AutoSize ? item.GetPreferredSize(displayRectangle.Size) : item.Size;
if (BackwardsWalkingIndex <= ForwardsWalkingIndex) {
// we've found an item that the forwards walking guy has already marched past,
// we need to let him know how much space we're freeing by sending this guy over
// to the overflow.
freedSpace += (horizontal) ? itemSize.Width + itemMargin.Horizontal : itemSize.Height + itemMargin.Vertical;
#if DEBUG
if (DebugLayoutTraceSwitch.TraceVerbose) { Debug.WriteLine(String.Format(CultureInfo.CurrentCulture, "Sweet! {0} FreedSpace - which is now {1}", itemSize, freedSpace.ToString(CultureInfo.InvariantCulture))); }
#endif
}
// send the item to the overflow.
item.SetPlacement(ToolStripItemPlacement.Overflow);
if (this.OverflowRequired == false) {
// this is the first item we're sending down.
// we now need to account for the width or height of the overflow button
spaceNeeded += (horizontal) ? OverflowButtonSize.Width : OverflowButtonSize.Height;
#if DEBUG
if (DebugLayoutTraceSwitch.TraceVerbose) { Debug.WriteLine(String.Format(CultureInfo.CurrentCulture, "Turns out we now need an overflow button, space needed now: {0}", spaceNeeded.ToString(CultureInfo.InvariantCulture))); }
#endif
this.OverflowRequired = true;
}
this.OverflowSpace += (horizontal) ? itemSize.Width + itemMargin.Horizontal : itemSize.Height + itemMargin.Vertical;
}
if (freedSpace > spaceNeeded) {
break;
}
}
Debug.Unindent();
return freedSpace;
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- HitTestParameters3D.cs
- VectorConverter.cs
- DictionaryTraceRecord.cs
- ProtectedConfigurationProviderCollection.cs
- ServiceDescriptionReflector.cs
- PropertyCondition.cs
- SystemIPGlobalProperties.cs
- TagPrefixAttribute.cs
- ContextMenu.cs
- HttpInputStream.cs
- MDIClient.cs
- ProxyFragment.cs
- UICuesEvent.cs
- GPRECT.cs
- ByteStorage.cs
- MessageBox.cs
- TdsParserSafeHandles.cs
- TargetControlTypeCache.cs
- XmlMtomReader.cs
- TypeToken.cs
- Error.cs
- Int32Storage.cs
- GridSplitterAutomationPeer.cs
- ResourceReferenceKeyNotFoundException.cs
- SqlDataReader.cs
- TextViewBase.cs
- ComplexLine.cs
- ListViewInsertionMark.cs
- XmlILTrace.cs
- PenThread.cs
- TimeIntervalCollection.cs
- DataGrid.cs
- DataTable.cs
- DataGridViewColumnCollection.cs
- DbDataRecord.cs
- AttributeQuery.cs
- AttachmentCollection.cs
- QueryOperatorEnumerator.cs
- ConfigXmlText.cs
- ColorTransformHelper.cs
- DescendantOverDescendantQuery.cs
- Dictionary.cs
- ForeignConstraint.cs
- IntegerValidatorAttribute.cs
- SubtreeProcessor.cs
- CheckBoxBaseAdapter.cs
- MethodRental.cs
- DispatchWrapper.cs
- Parameter.cs
- ExpressionServices.cs
- SymbolType.cs
- PresentationTraceSources.cs
- AttributedMetaModel.cs
- ReverseInheritProperty.cs
- NamespaceDecl.cs
- OleDbParameter.cs
- FrameworkReadOnlyPropertyMetadata.cs
- MessageHeaderInfoTraceRecord.cs
- SqlWebEventProvider.cs
- FileSystemEventArgs.cs
- StrongBox.cs
- PanelDesigner.cs
- MemberMemberBinding.cs
- CollectionConverter.cs
- PermissionSetEnumerator.cs
- Comparer.cs
- EventTrigger.cs
- metadatamappinghashervisitor.hashsourcebuilder.cs
- HealthMonitoringSectionHelper.cs
- OperationResponse.cs
- TabControlToolboxItem.cs
- TypedReference.cs
- processwaithandle.cs
- WebPageTraceListener.cs
- SRef.cs
- PieceNameHelper.cs
- KeyPressEvent.cs
- QueryGenerator.cs
- RectAnimationUsingKeyFrames.cs
- RoleManagerSection.cs
- SocketException.cs
- CultureSpecificCharacterBufferRange.cs
- storepermission.cs
- CodeRemoveEventStatement.cs
- WorkflowCreationContext.cs
- XsltException.cs
- ConditionedDesigner.cs
- EventHandlers.cs
- FormsAuthenticationConfiguration.cs
- TextBoxBase.cs
- TreeNodeStyleCollection.cs
- base64Transforms.cs
- AssociationSetMetadata.cs
- TextRunProperties.cs
- DiscoveryClient.cs
- EncryptedReference.cs
- RegexMatchCollection.cs
- MetadataHelper.cs
- MsmqDiagnostics.cs
- XPathDescendantIterator.cs