Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / WinForms / Managed / System / WinForms / ToolStripPanelRow.cs / 1305376 / ToolStripPanelRow.cs
//#define DEBUG_PAINT
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
/*
*/
namespace System.Windows.Forms {
using System.Drawing;
using System.Windows.Forms.Layout;
using System.Collections.Specialized;
using System.Collections;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
///
/// Collection of child controls.
///
[Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), SRDescription(SR.ControlControlsDescr)]
internal ToolStripPanelRowControlCollection ControlsInternal {
get {
ToolStripPanelRowControlCollection controlsCollection = (ToolStripPanelRowControlCollection)Properties.GetObject(PropControlsCollection);
if (controlsCollection == null) {
controlsCollection = CreateControlsInstance();
Properties.SetObject(PropControlsCollection, controlsCollection);
}
return controlsCollection;
}
}
internal ArrangedElementCollection Cells {
get {
return ControlsInternal.Cells;
}
}
internal bool CachedBoundsMode {
get {
return state[stateCachedBoundsMode];
}
set {
state[stateCachedBoundsMode] = value;
}
}
private ToolStripPanelRowManager RowManager {
get {
if (rowManager == null) {
rowManager = (Orientation == Orientation.Horizontal) ? new HorizontalRowManager(this) as ToolStripPanelRowManager
: new VerticalRowManager(this) as ToolStripPanelRowManager;
Initialized = true;
}
return rowManager;
}
}
///
/// Retrieves our internal property storage object. If you have a property
/// whose value is not always set, you should store it in here to save
/// space.
///
internal PropertyStore Properties {
get {
return propertyStore;
}
}
///
/// returns true if there is enough space to "raft" the control
/// ow returns false
///
public bool CanMove(ToolStrip toolStripToDrag) {
return !ToolStripPanel.Locked && !Locked && RowManager.CanMove(toolStripToDrag);
}
///
///
///
/// Should not be exposed as this returns an unexposed type.
///
///
///
Rectangle IArrangedElement.DisplayRectangle {
get {
Rectangle displayRectangle = this.Bounds;
return displayRectangle;
}
}
///
///
bool IArrangedElement.ParticipatesInLayout {
get {
return Visible;
}
}
///
///
void IArrangedElement.PerformLayout(IArrangedElement container, string propertyName) {
if (suspendCount <= 0) {
OnLayout(new LayoutEventArgs(container, propertyName));
}
}
#region MouseStuff
#if DEBUG
internal static readonly TraceSwitch ToolStripPanelMouseDebug = new TraceSwitch("ToolStripPanelMouse", "Debug WinBar WM_MOUSEACTIVATE code");
#else
internal static readonly TraceSwitch ToolStripPanelMouseDebug;
#endif
internal Rectangle DragBounds {
get {
return RowManager.DragBounds;
}
}
///
/// grows all controls after the index to be their preferred size.
/// reports back how much space was used.
///
protected virtual int GrowControlsAfter(int index, int growBy) {
if (growBy < 0) {
Debug.Fail("why was a negative number given to growControlsAfter?");
return 0;
}
int spaceToFree = growBy;
for (int i = index + 1; i < Row.ControlsInternal.Count; i++) {
// grow the n+1 item first if it was previously shrunk.
int freedSpace = Grow(i, spaceToFree);
if (freedSpace >= 0) {
spaceToFree -= freedSpace;
if (spaceToFree <= 0) {
return growBy;
}
}
}
return growBy - spaceToFree;
}
///
/// grows all controls before the index to be their preferred size.
/// reports back how much space was used.
///
protected virtual int GrowControlsBefore(int index, int growBy) {
if (growBy < 0) {
Debug.Fail("why was a negative number given to growControlsAfter?");
return 0;
}
int spaceToFree = growBy;
// grow the n-1 item first if it was previously shrunk.
for (int i = index - 1; i >= 0; i--) {
spaceToFree -= Grow(i, spaceToFree);
if (spaceToFree <= 0) {
return growBy; // we've already gotten all the free space.
}
}
return growBy - spaceToFree;
}
public virtual void MoveControl(ToolStrip movingControl, Point startClientLocation, Point endClientLocation) {
// ToolStripPanel.Join(movingControl, endScreenLocation);
}
public virtual void LeaveRow(ToolStrip toolStripToDrag) {
}
public virtual void JoinRow(ToolStrip toolStripToDrag, Point locationToDrag) {
}
protected internal virtual void OnControlAdded(Control c, int index) {
}
protected internal virtual void OnControlRemoved(Control c, int index) {
}
protected internal virtual void OnBoundsChanged(Rectangle oldBounds, Rectangle newBounds) {
}
}
private class HorizontalRowManager : ToolStripPanelRowManager {
private const int DRAG_BOUNDS_INFLATE = 4;
public HorizontalRowManager(ToolStripPanelRow owner): base (owner) {
owner.SuspendLayout();
FlowLayoutSettings.WrapContents = false;
FlowLayoutSettings.FlowDirection = FlowDirection.LeftToRight;
owner.ResumeLayout(false);
}
public override Rectangle DisplayRectangle {
get {
Rectangle displayRect = ((IArrangedElement)Row).DisplayRectangle;
if (ToolStripPanel != null) {
Rectangle raftingDisplayRectangle = ToolStripPanel.DisplayRectangle;
if ((!ToolStripPanel.Visible || LayoutUtils.IsZeroWidthOrHeight(raftingDisplayRectangle)) && (ToolStripPanel.ParentInternal != null)){
// if were layed out before we're visible we have the wrong display rectangle, so we need to calculate it.
displayRect.Width = ToolStripPanel.ParentInternal.DisplayRectangle.Width - (ToolStripPanel.Margin.Horizontal + ToolStripPanel.Padding.Horizontal) - Row.Margin.Horizontal;
}
else {
displayRect.Width = raftingDisplayRectangle.Width - Row.Margin.Horizontal;
}
}
return displayRect;
}
}
public override Rectangle DragBounds {
get {
Rectangle dragBounds = Row.Bounds;
int index = ToolStripPanel.RowsInternal.IndexOf(Row);
if (index > 0) {
Rectangle previousRowBounds = ToolStripPanel.RowsInternal[index - 1].Bounds;
int y = previousRowBounds.Y + previousRowBounds.Height - (previousRowBounds.Height >> 2);
dragBounds.Height += dragBounds.Y - y;
dragBounds.Y = y;
}
if (index < ToolStripPanel.RowsInternal.Count - 1) {
Rectangle nextRowBounds = ToolStripPanel.RowsInternal[index + 1].Bounds;
dragBounds.Height += (nextRowBounds.Height >> 2) + Row.Margin.Bottom + ToolStripPanel.RowsInternal[index + 1].Margin.Top;
}
dragBounds.Width += Row.Margin.Horizontal + ToolStripPanel.Padding.Horizontal +5;
dragBounds.X -= Row.Margin.Left + ToolStripPanel.Padding.Left +4;
return dragBounds;
}
}
///
/// returns true if there is enough space to "raft" the control
/// ow returns false
///
public override bool CanMove(ToolStrip toolStripToDrag) {
if (base.CanMove(toolStripToDrag)) {
Size totalSize = Size.Empty;
for (int i = 0; i < Row.ControlsInternal.Count; i++ ){
totalSize += Row.GetMinimumSize(Row.ControlsInternal[i] as ToolStrip);
}
totalSize += Row.GetMinimumSize(toolStripToDrag as ToolStrip);
return totalSize.Width < DisplayRectangle.Width;
}
Debug.WriteLineIf(ToolStripPanelRow.ToolStripPanelRowCreationDebug.TraceVerbose, "HorizontalRM.CanMove returns false - not enough room");
return false;
}
protected internal override int FreeSpaceFromRow(int spaceToFree) {
int requiredSpace = spaceToFree;
// take a look at the last guy. if his right edge exceeds
// the new bounds, then we should go ahead and push him into view.
if (spaceToFree > 0){
// we should shrink the last guy and then move him.
ToolStripPanelCell lastCellOnRow = GetNextVisibleCell(Row.Cells.Count-1, /*forward*/false);
if (lastCellOnRow == null) {
return 0;
}
Padding cellMargin = lastCellOnRow.Margin;
// only check margin.left as we are only concerned with getting right edge of
// the toolstrip into view. (space after the fact doesnt count).
if (cellMargin.Left >= spaceToFree) {
cellMargin.Left -= spaceToFree;
cellMargin.Right = 0;
spaceToFree = 0;
}
else {
spaceToFree -= lastCellOnRow.Margin.Left;
cellMargin.Left = 0;
cellMargin.Right = 0;
}
lastCellOnRow.Margin = cellMargin;
// start moving the toolstrips before this guy.
spaceToFree -= MoveLeft(Row.Cells.Count -1, spaceToFree);
if (spaceToFree > 0) {
spaceToFree -= lastCellOnRow.Shrink(spaceToFree);
}
}
return requiredSpace - Math.Max(0,spaceToFree);
}
public override void MoveControl(ToolStrip movingControl, Point clientStartLocation, Point clientEndLocation) {
if (Row.Locked) {
return;
}
if (DragBounds.Contains(clientEndLocation)) {
int index = Row.ControlsInternal.IndexOf(movingControl);
int deltaX = clientEndLocation.X - clientStartLocation.X;
if (deltaX < 0) {
// moving to the left
MoveLeft(index, deltaX * -1);
}
else {
MoveRight(index, deltaX);
}
}
else {
base.MoveControl(movingControl, clientStartLocation, clientEndLocation);
}
}
private int MoveLeft(int index, int spaceToFree) {
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "MoveLeft: " + spaceToFree.ToString(CultureInfo.InvariantCulture));
int freedSpace = 0;
Row.SuspendLayout();
try {
if (spaceToFree == 0 || index < 0) {
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "MoveLeft Early EXIT - 0 ");
return 0;
}
// remove all margins starting from the index.
for (int i = index; i >= 0; i--) {
ToolStripPanelCell cell = (ToolStripPanelCell)Row.Cells[i];
if (!cell.Visible && !cell.ControlInDesignMode) {
continue;
}
int requiredSpace = spaceToFree - freedSpace;
Padding cellMargin = cell.Margin;
if (cellMargin.Horizontal >= requiredSpace) {
freedSpace += requiredSpace;
cellMargin.Left -= requiredSpace;
cellMargin.Right = 0;
cell.Margin = cellMargin;
}
else {
freedSpace += cell.Margin.Horizontal;
cellMargin.Left = 0;
cellMargin.Right = 0;
cell.Margin = cellMargin;
}
if (freedSpace >= spaceToFree) {
// add the space we freed to the next guy.
if (index +1 < Row.Cells.Count) {
cell = GetNextVisibleCell(index+1, /*forward*/true);
if (cell != null) {
cellMargin = cell.Margin;
cellMargin.Left += spaceToFree;
cell.Margin = cellMargin;
}
}
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "MoveLeft Recovered (Margin only): " + spaceToFree.ToString(CultureInfo.InvariantCulture));
return spaceToFree;
}
}
}
finally {
Row.ResumeLayout(true);
}
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "MoveLeft Recovered Partial (Shrink): " + freedSpace.ToString(CultureInfo.InvariantCulture));
return freedSpace;
}
private int MoveRight(int index, int spaceToFree) {
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "MoveRight: " + spaceToFree.ToString(CultureInfo.InvariantCulture));
int freedSpace = 0;
Row.SuspendLayout();
try {
if (spaceToFree == 0 || index < 0 || index >= Row.ControlsInternal.Count) {
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "MoveRight Early EXIT - 0 ");
return 0;
}
ToolStripPanelCell cell;
Padding cellMargin;
// remove all margins after this point in the index.
for (int i = index+1; i < Row.Cells.Count; i++) {
cell = (ToolStripPanelCell)Row.Cells[i];
if (!cell.Visible && !cell.ControlInDesignMode) {
continue;
}
int requiredSpace = spaceToFree - freedSpace;
cellMargin = cell.Margin;
if (cellMargin.Horizontal >= requiredSpace) {
freedSpace += requiredSpace;
cellMargin.Left -= requiredSpace;
cellMargin.Right = 0;
cell.Margin = cellMargin;
}
else {
freedSpace += cell.Margin.Horizontal;
cellMargin.Left = 0;
cellMargin.Right = 0;
cell.Margin = cellMargin;
}
break;
}
// add in the space at the end of the row.
if (Row.Cells.Count > 0 && (spaceToFree > freedSpace)) {
ToolStripPanelCell lastCell = GetNextVisibleCell(Row.Cells.Count -1, /*forward*/false);
if (lastCell != null) {
freedSpace += DisplayRectangle.Right - lastCell.Bounds.Right;
}
else {
freedSpace += DisplayRectangle.Width;
}
}
// set the margin of the control that's moving.
if (spaceToFree <= freedSpace) {
// add the space we freed to the first guy.
cell = GetNextVisibleCell(index, /*forward*/true);
if (cell == null) {
cell = Row.Cells[index] as ToolStripPanelCell;
}
Debug.Assert(cell != null, "Dont expect cell to be null here, what's going on?");
if (cell != null) {
cellMargin = cell.Margin;
cellMargin.Left += spaceToFree;
cell.Margin = cellMargin;
}
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "MoveRight Recovered (Margin only): " + spaceToFree.ToString(CultureInfo.InvariantCulture));
return spaceToFree;
}
// Now start shrinking.
for (int i = index+1; i < Row.Cells.Count; i++) {
cell = (ToolStripPanelCell)Row.Cells[i];
if (!cell.Visible && !cell.ControlInDesignMode) {
continue;
}
int requiredSpace = spaceToFree - freedSpace;
freedSpace += cell.Shrink(requiredSpace);
if (spaceToFree >= freedSpace) {
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "MoveRight Recovered (Shrink): " + spaceToFree.ToString(CultureInfo.InvariantCulture));
Row.ResumeLayout(true);
return spaceToFree;
}
}
if (Row.Cells.Count == 1) {
cell = GetNextVisibleCell(index,/*forward*/true);
if (cell != null) {
cellMargin = cell.Margin;
cellMargin.Left += freedSpace;
cell.Margin = cellMargin;
}
}
}
finally {
Row.ResumeLayout(true);
}
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "MoveRight Recovered Partial (Shrink): " + freedSpace.ToString(CultureInfo.InvariantCulture));
return freedSpace;
}
public override void LeaveRow(ToolStrip toolStripToDrag) {
// this code is here to properly add space to the next control when the
// toolStripToDrag has been removed from the row.
Row.SuspendLayout();
int index = Row.ControlsInternal.IndexOf(toolStripToDrag);
if (index >= 0) {
if (index < Row.ControlsInternal.Count -1 /*not the last one in the row*/) {
ToolStripPanelCell cell = (ToolStripPanelCell)Row.Cells[index];
if (cell.Visible) {
int spaceOccupiedByCell = cell.Margin.Horizontal + cell.Bounds.Width;
// add the space occupied by the cell to the next one.
ToolStripPanelCell nextCell = GetNextVisibleCell(index+1, /*forward*/true);
if (nextCell != null) {
Padding nextCellMargin = nextCell.Margin;
nextCellMargin.Left += spaceOccupiedByCell;
nextCell.Margin = nextCellMargin;
}
}
}
// remove the control from the row.
((IList)Row.Cells).RemoveAt(index);
}
Row.ResumeLayout(true);
}
protected internal override void OnControlAdded(Control control, int index) {
}
protected internal override void OnControlRemoved(Control control, int index) {
}
public override void JoinRow(ToolStrip toolStripToDrag, Point locationToDrag) {
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "Horizontal JoinRow called " );
int index;
if (!Row.ControlsInternal.Contains(toolStripToDrag)) {
Row.SuspendLayout();
try {
if (Row.ControlsInternal.Count > 0) {
// walk through the columns and determine which column you want to insert into.
for (index = 0; index < Row.Cells.Count; index++) {
ToolStripPanelCell cell = Row.Cells[index] as ToolStripPanelCell;
if (!cell.Visible && !cell.ControlInDesignMode) {
continue;
}
// [: ] [: x ]
if (Row.Cells[index].Bounds.Contains(locationToDrag)) {
break;
}
// take into account the following scenarios
// [: ] x [: ]
// x [: ] [: ]
if (Row.Cells[index].Bounds.X >= locationToDrag.X) {
break;
}
}
Control controlToPushAside = Row.ControlsInternal[index];
// Plop the new control in the midst of the row in question.
if (index < Row.ControlsInternal.Count) {
Row.ControlsInternal.Insert(index, toolStripToDrag);
}
else {
Row.ControlsInternal.Add(toolStripToDrag);
}
// since layout is suspended the control may not be set to its preferred size yet
int controlToDragWidth = (toolStripToDrag.AutoSize) ? toolStripToDrag.PreferredSize.Width : toolStripToDrag.Width;
//
// now make it look like it belongs in the row.
//
// PUSH the controls after it to the right
int requiredSpace = controlToDragWidth;
if (index == 0) {
// make sure we account for the left side
requiredSpace += locationToDrag.X;
}
int freedSpace = 0;
if (index < Row.ControlsInternal.Count -1) {
ToolStripPanelCell nextCell = (ToolStripPanelCell)Row.Cells[index+1];
Padding nextCellMargin = nextCell.Margin;
// if we've already got the empty space
// (available to us via the margin) use that.
if (nextCellMargin.Left > requiredSpace) {
nextCellMargin.Left -= requiredSpace;
nextCell.Margin = nextCellMargin;
freedSpace = requiredSpace;
}
else {
// otherwise we've got to
// push all controls after this point to the right
// this dumps the extra stuff into the margin of index+1
freedSpace = MoveRight(index+1, requiredSpace - freedSpace);
// refetch the margin for "index+1" and remove the freed space
// from it - we want to actually put this to use on the control
// before this one - we're making room for the control at
// position "index"
if (freedSpace > 0) {
nextCellMargin = nextCell.Margin;
nextCellMargin.Left = Math.Max(0, nextCellMargin.Left - freedSpace);
nextCell.Margin = nextCellMargin;
}
}
}
else {
// we're adding to the end.
ToolStripPanelCell nextCell = GetNextVisibleCell(Row.Cells.Count-2, /*forward*/false);
ToolStripPanelCell lastCell = GetNextVisibleCell(Row.Cells.Count-1, /*forward*/false);
// count the stuff at the end of the row as freed space
if (nextCell != null && lastCell != null) {
Padding lastCellMargin = lastCell.Margin;
lastCellMargin.Left = Math.Max(0,locationToDrag.X - nextCell.Bounds.Right);
lastCell.Margin = lastCellMargin;
freedSpace=requiredSpace;
}
}
// If we still need more space, then...
// PUSH the controls before it to the left
if (freedSpace < requiredSpace && index > 0) {
freedSpace = MoveLeft(index - 1, requiredSpace - freedSpace);
}
if (index == 0) {
// if the index is zero and there were controls in the row
// we need to take care of pushing over the new cell.
if (freedSpace - controlToDragWidth > 0) {
ToolStripPanelCell newCell = Row.Cells[index] as ToolStripPanelCell;
Padding newCellMargin = newCell.Margin;
newCellMargin.Left = freedSpace - controlToDragWidth;
newCell.Margin = newCellMargin;
}
}
}
else {
// we're adding to the beginning.
Row.ControlsInternal.Add(toolStripToDrag);
#if DEBUG
ISupportToolStripPanel ctg = toolStripToDrag as ISupportToolStripPanel;
ToolStripPanelRow newPanelRow = ctg.ToolStripPanelRow;
Debug.Assert(newPanelRow == Row, "we should now be in the new panel row.");
#endif
if (Row.Cells.Count >0 || toolStripToDrag.IsInDesignMode) {
// we're adding to the beginning.
ToolStripPanelCell cell = GetNextVisibleCell(Row.Cells.Count-1, /*forward*/false);
if (cell == null && toolStripToDrag.IsInDesignMode) {
cell = (ToolStripPanelCell)Row.Cells[Row.Cells.Count-1];
}
if (cell != null) {
Padding cellMargin = cell.Margin;
cellMargin.Left = Math.Max(0,locationToDrag.X-Row.Margin.Left);
cell.Margin = cellMargin;
}
}
}
}
finally {
Row.ResumeLayout(true);
}
}
}
protected internal override void OnBoundsChanged(Rectangle oldBounds, Rectangle newBounds) {
base.OnBoundsChanged(oldBounds, newBounds);
}
}
private class VerticalRowManager : ToolStripPanelRowManager {
private const int DRAG_BOUNDS_INFLATE = 4;
public VerticalRowManager(ToolStripPanelRow owner): base (owner) {
owner.SuspendLayout();
FlowLayoutSettings.WrapContents = false;
FlowLayoutSettings.FlowDirection = FlowDirection.TopDown;
owner.ResumeLayout(false);
}
public override Rectangle DisplayRectangle {
get {
Rectangle displayRect = ((IArrangedElement)Row).DisplayRectangle;
if (ToolStripPanel != null) {
Rectangle raftingDisplayRectangle = ToolStripPanel.DisplayRectangle;
if ((!ToolStripPanel.Visible || LayoutUtils.IsZeroWidthOrHeight(raftingDisplayRectangle)) && (ToolStripPanel.ParentInternal != null)){
// if were layed out before we're visible we have the wrong display rectangle, so we need to calculate it.
displayRect.Height = ToolStripPanel.ParentInternal.DisplayRectangle.Height - (ToolStripPanel.Margin.Vertical + ToolStripPanel.Padding.Vertical) - Row.Margin.Vertical;
}
else {
displayRect.Height = raftingDisplayRectangle.Height - Row.Margin.Vertical;
}
}
return displayRect;
}
}
public override Rectangle DragBounds {
get {
Rectangle dragBounds = Row.Bounds;
int index = ToolStripPanel.RowsInternal.IndexOf(Row);
///
if (index > 0) {
Rectangle previousRowBounds = ToolStripPanel.RowsInternal[index - 1].Bounds;
int x = previousRowBounds.X + previousRowBounds.Width - (previousRowBounds.Width >> 2);
dragBounds.Width += dragBounds.X - x;
dragBounds.X = x;
}
if (index < ToolStripPanel.RowsInternal.Count - 1) {
Rectangle nextRowBounds = ToolStripPanel.RowsInternal[index + 1].Bounds;
dragBounds.Width += (nextRowBounds.Width >> 2) + Row.Margin.Right + ToolStripPanel.RowsInternal[index + 1].Margin.Left;
}
dragBounds.Height += Row.Margin.Vertical + ToolStripPanel.Padding.Vertical +5;
dragBounds.Y -= Row.Margin.Top+ ToolStripPanel.Padding.Top +4;
return dragBounds;
}
}
///
/// returns true if there is enough space to "raft" the control
/// ow returns false
///
public override bool CanMove(ToolStrip toolStripToDrag) {
if (base.CanMove(toolStripToDrag)) {
Size totalSize = Size.Empty;
for (int i = 0; i < Row.ControlsInternal.Count; i++ ){
totalSize += Row.GetMinimumSize(Row.ControlsInternal[i] as ToolStrip);
}
totalSize += Row.GetMinimumSize(toolStripToDrag);
return totalSize.Height < DisplayRectangle.Height;
}
Debug.WriteLineIf(ToolStripPanelRow.ToolStripPanelRowCreationDebug.TraceVerbose, "VerticalRM.CanMove returns false - not enough room");
return false;
}
protected internal override int FreeSpaceFromRow(int spaceToFree) {
int requiredSpace = spaceToFree;
// take a look at the last guy. if his right edge exceeds
// the new bounds, then we should go ahead and push him into view.
if (spaceToFree > 0){
// we should shrink the last guy and then move him.
ToolStripPanelCell lastCellOnRow = GetNextVisibleCell(Row.Cells.Count-1, /*forward*/false);
if (lastCellOnRow == null) {
return 0;
}
Padding cellMargin = lastCellOnRow.Margin;
// only check margin.left as we are only concerned with getting right edge of
// the toolstrip into view. (space after the fact doesnt count).
if (cellMargin.Top >= spaceToFree) {
cellMargin.Top -= spaceToFree;
cellMargin.Bottom = 0;
spaceToFree = 0;
}
else {
spaceToFree -= lastCellOnRow.Margin.Top;
cellMargin.Top = 0;
cellMargin.Bottom = 0;
}
lastCellOnRow.Margin = cellMargin;
// start moving the toolstrips before this guy.
spaceToFree -= MoveUp(Row.Cells.Count -1, spaceToFree);
if (spaceToFree > 0) {
spaceToFree -= lastCellOnRow.Shrink(spaceToFree);
}
}
return requiredSpace - Math.Max(0,spaceToFree);
}
public override void MoveControl(ToolStrip movingControl, Point clientStartLocation, Point clientEndLocation) {
if (Row.Locked) {
return;
}
if (DragBounds.Contains(clientEndLocation)) {
int index = Row.ControlsInternal.IndexOf(movingControl);
int deltaY = clientEndLocation.Y - clientStartLocation.Y;
if (deltaY < 0) {
// moving to the left
MoveUp(index, deltaY * -1);
}
else {
MoveDown(index, deltaY);
}
}
else {
base.MoveControl(movingControl, clientStartLocation, clientEndLocation);
}
}
private int MoveUp(int index, int spaceToFree) {
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "MoveUp: " + spaceToFree.ToString(CultureInfo.InvariantCulture));
int freedSpace = 0;
Row.SuspendLayout();
try {
if (spaceToFree == 0 || index < 0) {
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "MoveUp Early EXIT - 0 ");
return 0;
}
// remove all margins starting from the index.
for (int i = index; i >= 0; i--) {
ToolStripPanelCell cell = (ToolStripPanelCell)Row.Cells[i];
if (!cell.Visible && !cell.ControlInDesignMode) {
continue;
}
int requiredSpace = spaceToFree - freedSpace;
Padding cellMargin = cell.Margin;
if (cellMargin.Vertical >= requiredSpace) {
freedSpace += requiredSpace;
cellMargin.Top -= requiredSpace;
cellMargin.Bottom = 0;
cell.Margin = cellMargin;
}
else {
freedSpace += cell.Margin.Vertical;
cellMargin.Top = 0;
cellMargin.Bottom = 0;
cell.Margin = cellMargin;
}
if (freedSpace >= spaceToFree) {
// add the space we freed to the next guy.
if (index +1 < Row.Cells.Count) {
cell = GetNextVisibleCell(index+1, /*forward*/true);
if (cell != null) {
cellMargin = cell.Margin;
cellMargin.Top += spaceToFree;
cell.Margin = cellMargin;
}
}
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "MoveUp Recovered (Margin only): " + spaceToFree.ToString(CultureInfo.InvariantCulture));
return spaceToFree;
}
}
}
finally {
Row.ResumeLayout(true);
}
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "MoveLeft Recovered Partial (Shrink): " + freedSpace.ToString(CultureInfo.InvariantCulture));
return freedSpace;
}
private int MoveDown(int index, int spaceToFree) {
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "MoveDown: " + spaceToFree.ToString(CultureInfo.InvariantCulture));
int freedSpace = 0;
Row.SuspendLayout();
try {
if (spaceToFree == 0 || index < 0 || index >= Row.ControlsInternal.Count) {
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "MoveDown Early EXIT - 0 ");
return 0;
}
ToolStripPanelCell cell;
Padding cellMargin;
// remove all margins after this point in the index.
for (int i = index+1; i < Row.Cells.Count; i++) {
cell = (ToolStripPanelCell)Row.Cells[i];
if (!cell.Visible && !cell.ControlInDesignMode) {
continue;
}
int requiredSpace = spaceToFree - freedSpace;
cellMargin = cell.Margin;
if (cellMargin.Vertical >= requiredSpace) {
freedSpace += requiredSpace;
cellMargin.Top -= requiredSpace;
cellMargin.Bottom = 0;
cell.Margin = cellMargin;
}
else {
freedSpace += cell.Margin.Vertical;
cellMargin.Top = 0;
cellMargin.Bottom = 0;
cell.Margin = cellMargin;
}
break;
}
// add in the space at the end of the row.
if (Row.Cells.Count > 0 && (spaceToFree > freedSpace)) {
ToolStripPanelCell lastCell = GetNextVisibleCell(Row.Cells.Count -1, /*forward*/false);
if (lastCell != null) {
freedSpace += DisplayRectangle.Bottom - lastCell.Bounds.Bottom;
}
else {
freedSpace += DisplayRectangle.Height;
}
}
// set the margin of the control that's moving.
if (spaceToFree <= freedSpace) {
// add the space we freed to the first guy.
cell = (ToolStripPanelCell)Row.Cells[index];
cellMargin = cell.Margin;
cellMargin.Top += spaceToFree;
cell.Margin = cellMargin;
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "MoveDown Recovered (Margin only): " + spaceToFree.ToString(CultureInfo.InvariantCulture));
return spaceToFree;
}
// Now start shrinking.
for (int i = index+1; i < Row.Cells.Count; i++) {
cell = (ToolStripPanelCell)Row.Cells[i];
if (!cell.Visible && !cell.ControlInDesignMode) {
continue;
}
int requiredSpace = spaceToFree - freedSpace;
freedSpace += cell.Shrink(requiredSpace);
if (spaceToFree >= freedSpace) {
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "MoveDown Recovered (Shrink): " + spaceToFree.ToString(CultureInfo.InvariantCulture));
Row.ResumeLayout(true);
return spaceToFree;
}
}
if (Row.Cells.Count == 1) {
cell = GetNextVisibleCell(index,/*forward*/true);
if (cell != null) {
cellMargin = cell.Margin;
cellMargin.Top += freedSpace;
cell.Margin = cellMargin;
}
}
}
finally {
Row.ResumeLayout(true);
}
int recoveredSpace = spaceToFree - freedSpace;
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "MoveDown Recovered Partial (Shrink): " + recoveredSpace.ToString(CultureInfo.InvariantCulture));
return recoveredSpace;
}
protected internal override void OnBoundsChanged(Rectangle oldBounds, Rectangle newBounds) {
base.OnBoundsChanged(oldBounds, newBounds);
// if our bounds have changed - we should shove the toolbars up so they're in view.
if (Row.Cells.Count > 0) {
// take a look at the last guy. if his right edge exceeds
// the new bounds, then we should go ahead and push him into view.
ToolStripPanelCell lastCell = GetNextVisibleCell(Row.Cells.Count -1, /*forward=*/false);
int spaceToFree = (lastCell != null)? lastCell.Bounds.Bottom - newBounds.Height : 0;
if (spaceToFree > 0){
// we should shrink the last guy and then move him.
ToolStripPanelCell lastCellOnRow = GetNextVisibleCell(Row.Cells.Count-1, /*forward*/false);
Padding cellMargin = lastCellOnRow.Margin;
// only check margin.left as we are only concerned with getting bottom edge of
// the toolstrip into view. (space after the fact doesnt count).
if (cellMargin.Top >= spaceToFree) {
cellMargin.Top -= spaceToFree;
cellMargin.Bottom = 0;
lastCellOnRow.Margin = cellMargin;
spaceToFree = 0;
}
else {
spaceToFree -= lastCellOnRow.Margin.Top;
cellMargin.Top = 0;
cellMargin.Bottom = 0;
lastCellOnRow.Margin = cellMargin;
}
spaceToFree -= lastCellOnRow.Shrink(spaceToFree);
// start moving the toolstrips before this guy.
MoveUp(Row.Cells.Count -1, spaceToFree);
}
}
}
protected internal override void OnControlRemoved(Control c, int index) {
}
protected internal override void OnControlAdded(Control control, int index) {
}
public override void JoinRow(ToolStrip toolStripToDrag, Point locationToDrag) {
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "Vertical JoinRow called " );
int index;
if (!Row.ControlsInternal.Contains(toolStripToDrag)) {
Row.SuspendLayout();
try {
if (Row.ControlsInternal.Count > 0) {
// walk through the columns and determine which column you want to insert into.
for (index = 0; index < Row.Cells.Count; index++) {
ToolStripPanelCell cell = Row.Cells[index] as ToolStripPanelCell;
if (!cell.Visible && !cell.ControlInDesignMode) {
continue;
}
// [: ] [: x ]
if (cell.Bounds.Contains(locationToDrag)) {
break;
}
// take into account the following scenarios
// [: ] x [: ]
// x [: ] [: ]
if (cell.Bounds.Y >= locationToDrag.Y) {
break;
}
}
Control controlToPushAside = Row.ControlsInternal[index];
// Plop the new control in the midst of the row in question.
if (index < Row.ControlsInternal.Count) {
Row.ControlsInternal.Insert(index, toolStripToDrag);
}
else {
Row.ControlsInternal.Add(toolStripToDrag);
}
// since layout is suspended the control may not be set to its preferred size yet
int controlToDragWidth = (toolStripToDrag.AutoSize) ? toolStripToDrag.PreferredSize.Height : toolStripToDrag.Height;
//
// now make it look like it belongs in the row.
//
// PUSH the controls after it to the right
int requiredSpace = controlToDragWidth;
if (index == 0) {
// make sure we account for the left side
requiredSpace += locationToDrag.Y;
}
int freedSpace = 0;
if (index < Row.ControlsInternal.Count -1) {
ToolStripPanelCell nextCell = GetNextVisibleCell(index+1, /*forward*/true);
if (nextCell != null) {
Padding nextCellMargin = nextCell.Margin;
// if we've already got the empty space
// (available to us via the margin) use that.
if (nextCellMargin.Top > requiredSpace) {
nextCellMargin.Top -= requiredSpace;
nextCell.Margin = nextCellMargin;
freedSpace = requiredSpace;
}
else {
// otherwise we've got to
// push all controls after this point to the right
// this dumps the extra stuff into the margin of index+1
freedSpace = MoveDown(index+1, requiredSpace - freedSpace);
// refetch the margin for "index+1" and remove the freed space
// from it - we want to actually put this to use on the control
// before this one - we're making room for the control at
// position "index"
if (freedSpace > 0) {
nextCellMargin = nextCell.Margin;
nextCellMargin.Top -= freedSpace;
nextCell.Margin = nextCellMargin;
}
}
}
}
else {
// we're adding to the end.
ToolStripPanelCell nextCell = GetNextVisibleCell(Row.Cells.Count-2, /*forward*/false);
ToolStripPanelCell lastCell = GetNextVisibleCell(Row.Cells.Count-1, /*forward*/false);
// count the stuff at the end of the row as freed space
if (nextCell != null && lastCell != null) {
Padding lastCellMargin = lastCell.Margin;
lastCellMargin.Top = Math.Max(0,locationToDrag.Y - nextCell.Bounds.Bottom);
lastCell.Margin = lastCellMargin;
freedSpace=requiredSpace;
}
}
// If we still need more space, then...
// PUSH the controls before it to the left
if (freedSpace < requiredSpace && index > 0) {
freedSpace = MoveUp(index - 1, requiredSpace - freedSpace);
}
if (index == 0) {
// if the index is zero and there were controls in the row
// we need to take care of pushing over the new cell.
if (freedSpace - controlToDragWidth > 0) {
ToolStripPanelCell newCell = Row.Cells[index] as ToolStripPanelCell;
Padding newCellMargin = newCell.Margin;
newCellMargin.Top = freedSpace - controlToDragWidth;
newCell.Margin = newCellMargin;
}
}
}
else {
// we're adding to the beginning.
Row.ControlsInternal.Add(toolStripToDrag);
#if DEBUG
ISupportToolStripPanel ctg = toolStripToDrag as ISupportToolStripPanel;
ToolStripPanelRow newPanelRow = ctg.ToolStripPanelRow;
Debug.Assert(newPanelRow == Row, "we should now be in the new panel row.");
#endif
if (Row.Cells.Count >0) {
ToolStripPanelCell cell = GetNextVisibleCell(Row.Cells.Count-1, /*forward*/false);
if (cell != null) {
Padding cellMargin = cell.Margin;
cellMargin.Top = Math.Max(0,locationToDrag.Y-Row.Margin.Top);
cell.Margin = cellMargin;
}
}
}
}
finally {
Row.ResumeLayout(true);
}
}
}
public override void LeaveRow(ToolStrip toolStripToDrag) {
// this code is here to properly add space to the next control when the
// toolStripToDrag has been removed from the row.
Row.SuspendLayout();
int index = Row.ControlsInternal.IndexOf(toolStripToDrag);
if (index >= 0) {
if (index < Row.ControlsInternal.Count -1 /*not the last one in the row*/) {
ToolStripPanelCell cell = (ToolStripPanelCell)Row.Cells[index];
if (cell.Visible) {
int spaceOccupiedByCell = cell.Margin.Vertical + cell.Bounds.Height;
// add the space occupied by the cell to the next one.
ToolStripPanelCell nextCell = GetNextVisibleCell(index+1, /*forward*/true);
if (nextCell != null) {
Padding nextCellMargin = nextCell.Margin;
nextCellMargin.Top += spaceOccupiedByCell;
nextCell.Margin = nextCellMargin;
}
}
}
// remove the control from the row.
((IList)Row.Cells).RemoveAt(index);
}
Row.ResumeLayout(true);
}
}
///
/// ToolStripPanelRowControlCollection
///
/// this class represents the collection of controls on a particular row.
/// when you add and remove controls from this collection - you also add and remove
/// controls to and from the ToolStripPanel.Control's collection (which happens
/// to be externally readonly.)
///
/// This class is used to represent the IArrangedElement.Children for the ToolStripPanelRow -
/// which means that this collection represents the IArrangedElements to layout for
/// a particular ToolStripPanelRow.
///
/// We need to keep copies of the controls in both the ToolStripPanelRowControlCollection and
/// the ToolStripPanel.Control collection as the ToolStripPanel.Control collection
/// is responsible for parenting and unparenting the controls (ToolStripPanelRows do NOT derive from
/// Control and thus are NOT hwnd backed).
///
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Never)]
public int Add(Control value) {
ISupportToolStripPanel control = value as ISupportToolStripPanel;
if (value == null) {
throw new ArgumentNullException("value");
}
if (control == null) {
throw new NotSupportedException(SR.GetString(SR.TypedControlCollectionShouldBeOfType, typeof(ToolStrip).Name));
}
int index = InnerList.Add(control.ToolStripPanelCell);
OnAdd(control, index);
return index;
}
///
/// [To be supplied.]
///
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
[EditorBrowsable(EditorBrowsableState.Never)]
public void AddRange(Control[] value) {
if (value == null) {
throw new ArgumentNullException("value");
}
ToolStripPanel currentOwner = ToolStripPanel;
if (currentOwner != null) {
currentOwner.SuspendLayout();
}
try {
for (int i = 0; i < value.Length; i++) {
this.Add(value[i]);
}
}
finally {
if (currentOwner != null) {
currentOwner.ResumeLayout();
}
}
}
///
/// [To be supplied.]
///
public bool Contains(Control value) {
for (int i = 0; i < Count; i++) {
if (GetControl(i) == value) {
return true;
}
}
return false;
}
///
/// [To be supplied.]
///
public virtual void Clear() {
if (owner != null) {
ToolStripPanel.SuspendLayout();
}
try {
while (Count != 0) {
RemoveAt(Count - 1);
}
}
finally {
if (owner != null) {
ToolStripPanel.ResumeLayout();
}
}
}
public override IEnumerator GetEnumerator() { return new ToolStripPanelCellToControlEnumerator(InnerList); }
private Control GetControl(int index) {
Control control = null;
ToolStripPanelCell cell = null;
if (index < Count && index >= 0) {
cell = (ToolStripPanelCell)(InnerList[index]);
control = (cell != null) ? cell.Control : null;
}
return control;
}
private int IndexOfControl(Control c) {
for (int i = 0; i < Count; i++) {
ToolStripPanelCell cell = (ToolStripPanelCell)(InnerList[i]);
if (cell.Control == c) {
return i;
}
}
return -1;
}
void IList.Clear() { Clear(); }
bool IList.IsFixedSize { get { return InnerList.IsFixedSize; } }
bool IList.Contains(object value) { return InnerList.Contains(value); }
bool IList.IsReadOnly { get { return InnerList.IsReadOnly; } }
void IList.RemoveAt(int index) { RemoveAt(index); }
void IList.Remove(object value) { Remove(value as Control); }
int IList.Add(object value) { return Add(value as Control); }
int IList.IndexOf(object value) { return IndexOf(value as Control); }
void IList.Insert(int index, object value) { Insert(index, value as Control); }
///
/// [To be supplied.]
///
public int IndexOf(Control value) {
for (int i = 0; i < Count; i++) {
if (GetControl(i) == value) {
return i;
}
}
return -1;
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Never)]
public void Insert(int index, Control value) {
if (value == null) {
throw new ArgumentNullException("value");
}
ISupportToolStripPanel control = value as ISupportToolStripPanel;
if (control == null) {
throw new NotSupportedException(SR.GetString(SR.TypedControlCollectionShouldBeOfType, typeof(ToolStrip).Name));
}
InnerList.Insert(index, control.ToolStripPanelCell);
OnAdd(control, index);
}
///
/// Do proper cleanup of ownership, etc.
///
private void OnAfterRemove(Control control, int index) {
if (owner != null) {
// unfortunately we dont know the index of the control in the ToolStripPanel's
// control collection, as all rows share this collection.
// To unparent this control we need to use Remove instead of RemoveAt.
using (LayoutTransaction t = new LayoutTransaction(ToolStripPanel, control, PropertyNames.Parent)) {
owner.ToolStripPanel.Controls.Remove(control);
owner.OnControlRemoved(control, index);
}
}
}
private void OnAdd(ISupportToolStripPanel controlToBeDragged, int index) {
if (owner != null) {
LayoutTransaction layoutTransaction = null;
if (ToolStripPanel != null && ToolStripPanel.ParentInternal != null) {
layoutTransaction = new LayoutTransaction(ToolStripPanel, ToolStripPanel.ParentInternal, PropertyNames.Parent);
}
try {
if (controlToBeDragged != null) {
controlToBeDragged.ToolStripPanelRow = owner;
Control control = controlToBeDragged as Control;
if (control != null) {
control.ParentInternal = owner.ToolStripPanel;
owner.OnControlAdded(control, index);
}
}
}
finally {
if (layoutTransaction != null) {
layoutTransaction.Dispose();
}
}
}
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Never)]
public void Remove(Control value) {
int index = IndexOfControl(value);
RemoveAt(index);
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Never)]
public void RemoveAt(int index) {
if (index >= 0 && index < Count) {
Control control = GetControl(index);
ToolStripPanelCell cell = InnerList[index] as ToolStripPanelCell;
InnerList.RemoveAt(index);
OnAfterRemove(control, index);
}
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Never)]
public void CopyTo(Control[] array, int index) {
if (array == null) {
throw new ArgumentNullException("array");
}
if (index < 0) {
throw new ArgumentOutOfRangeException("index");
}
if (index >= array.Length || InnerList.Count > array.Length - index) {
throw new ArgumentException(SR.GetString(SR.ToolStripPanelRowControlCollectionIncorrectIndexLength));
}
for (int i = 0; i < InnerList.Count; i++) {
array[index++] = GetControl(i);
}
}
/// We want to pretend like we're only holding controls... so everywhere we've returned controls.
/// but the problem is if you do a foreach, you'll get the cells not the controls. So we've got
/// to sort of write a wrapper class around the ArrayList enumerator.
private class ToolStripPanelCellToControlEnumerator : IEnumerator, ICloneable {
private IEnumerator arrayListEnumerator;
internal ToolStripPanelCellToControlEnumerator(ArrayList list) {
arrayListEnumerator = ((IEnumerable)list).GetEnumerator();
}
public virtual Object Current {
get {
ToolStripPanelCell cell = arrayListEnumerator.Current as ToolStripPanelCell;
Debug.Assert(cell != null, "Expected ToolStripPanel cells only!!!" + arrayListEnumerator.Current.GetType().ToString());
return (cell == null) ? null : cell.Control;
}
}
public Object Clone() {
return MemberwiseClone();
}
public virtual bool MoveNext() {
return arrayListEnumerator.MoveNext();
}
public virtual void Reset() {
arrayListEnumerator.Reset();
}
}
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//#define DEBUG_PAINT
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
/*
*/
namespace System.Windows.Forms {
using System.Drawing;
using System.Windows.Forms.Layout;
using System.Collections.Specialized;
using System.Collections;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
///
/// Collection of child controls.
///
[Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), SRDescription(SR.ControlControlsDescr)]
internal ToolStripPanelRowControlCollection ControlsInternal {
get {
ToolStripPanelRowControlCollection controlsCollection = (ToolStripPanelRowControlCollection)Properties.GetObject(PropControlsCollection);
if (controlsCollection == null) {
controlsCollection = CreateControlsInstance();
Properties.SetObject(PropControlsCollection, controlsCollection);
}
return controlsCollection;
}
}
internal ArrangedElementCollection Cells {
get {
return ControlsInternal.Cells;
}
}
internal bool CachedBoundsMode {
get {
return state[stateCachedBoundsMode];
}
set {
state[stateCachedBoundsMode] = value;
}
}
private ToolStripPanelRowManager RowManager {
get {
if (rowManager == null) {
rowManager = (Orientation == Orientation.Horizontal) ? new HorizontalRowManager(this) as ToolStripPanelRowManager
: new VerticalRowManager(this) as ToolStripPanelRowManager;
Initialized = true;
}
return rowManager;
}
}
///
/// Retrieves our internal property storage object. If you have a property
/// whose value is not always set, you should store it in here to save
/// space.
///
internal PropertyStore Properties {
get {
return propertyStore;
}
}
///
/// returns true if there is enough space to "raft" the control
/// ow returns false
///
public bool CanMove(ToolStrip toolStripToDrag) {
return !ToolStripPanel.Locked && !Locked && RowManager.CanMove(toolStripToDrag);
}
///
///
///
/// Should not be exposed as this returns an unexposed type.
///
///
///
Rectangle IArrangedElement.DisplayRectangle {
get {
Rectangle displayRectangle = this.Bounds;
return displayRectangle;
}
}
///
///
bool IArrangedElement.ParticipatesInLayout {
get {
return Visible;
}
}
///
///
void IArrangedElement.PerformLayout(IArrangedElement container, string propertyName) {
if (suspendCount <= 0) {
OnLayout(new LayoutEventArgs(container, propertyName));
}
}
#region MouseStuff
#if DEBUG
internal static readonly TraceSwitch ToolStripPanelMouseDebug = new TraceSwitch("ToolStripPanelMouse", "Debug WinBar WM_MOUSEACTIVATE code");
#else
internal static readonly TraceSwitch ToolStripPanelMouseDebug;
#endif
internal Rectangle DragBounds {
get {
return RowManager.DragBounds;
}
}
///
/// grows all controls after the index to be their preferred size.
/// reports back how much space was used.
///
protected virtual int GrowControlsAfter(int index, int growBy) {
if (growBy < 0) {
Debug.Fail("why was a negative number given to growControlsAfter?");
return 0;
}
int spaceToFree = growBy;
for (int i = index + 1; i < Row.ControlsInternal.Count; i++) {
// grow the n+1 item first if it was previously shrunk.
int freedSpace = Grow(i, spaceToFree);
if (freedSpace >= 0) {
spaceToFree -= freedSpace;
if (spaceToFree <= 0) {
return growBy;
}
}
}
return growBy - spaceToFree;
}
///
/// grows all controls before the index to be their preferred size.
/// reports back how much space was used.
///
protected virtual int GrowControlsBefore(int index, int growBy) {
if (growBy < 0) {
Debug.Fail("why was a negative number given to growControlsAfter?");
return 0;
}
int spaceToFree = growBy;
// grow the n-1 item first if it was previously shrunk.
for (int i = index - 1; i >= 0; i--) {
spaceToFree -= Grow(i, spaceToFree);
if (spaceToFree <= 0) {
return growBy; // we've already gotten all the free space.
}
}
return growBy - spaceToFree;
}
public virtual void MoveControl(ToolStrip movingControl, Point startClientLocation, Point endClientLocation) {
// ToolStripPanel.Join(movingControl, endScreenLocation);
}
public virtual void LeaveRow(ToolStrip toolStripToDrag) {
}
public virtual void JoinRow(ToolStrip toolStripToDrag, Point locationToDrag) {
}
protected internal virtual void OnControlAdded(Control c, int index) {
}
protected internal virtual void OnControlRemoved(Control c, int index) {
}
protected internal virtual void OnBoundsChanged(Rectangle oldBounds, Rectangle newBounds) {
}
}
private class HorizontalRowManager : ToolStripPanelRowManager {
private const int DRAG_BOUNDS_INFLATE = 4;
public HorizontalRowManager(ToolStripPanelRow owner): base (owner) {
owner.SuspendLayout();
FlowLayoutSettings.WrapContents = false;
FlowLayoutSettings.FlowDirection = FlowDirection.LeftToRight;
owner.ResumeLayout(false);
}
public override Rectangle DisplayRectangle {
get {
Rectangle displayRect = ((IArrangedElement)Row).DisplayRectangle;
if (ToolStripPanel != null) {
Rectangle raftingDisplayRectangle = ToolStripPanel.DisplayRectangle;
if ((!ToolStripPanel.Visible || LayoutUtils.IsZeroWidthOrHeight(raftingDisplayRectangle)) && (ToolStripPanel.ParentInternal != null)){
// if were layed out before we're visible we have the wrong display rectangle, so we need to calculate it.
displayRect.Width = ToolStripPanel.ParentInternal.DisplayRectangle.Width - (ToolStripPanel.Margin.Horizontal + ToolStripPanel.Padding.Horizontal) - Row.Margin.Horizontal;
}
else {
displayRect.Width = raftingDisplayRectangle.Width - Row.Margin.Horizontal;
}
}
return displayRect;
}
}
public override Rectangle DragBounds {
get {
Rectangle dragBounds = Row.Bounds;
int index = ToolStripPanel.RowsInternal.IndexOf(Row);
if (index > 0) {
Rectangle previousRowBounds = ToolStripPanel.RowsInternal[index - 1].Bounds;
int y = previousRowBounds.Y + previousRowBounds.Height - (previousRowBounds.Height >> 2);
dragBounds.Height += dragBounds.Y - y;
dragBounds.Y = y;
}
if (index < ToolStripPanel.RowsInternal.Count - 1) {
Rectangle nextRowBounds = ToolStripPanel.RowsInternal[index + 1].Bounds;
dragBounds.Height += (nextRowBounds.Height >> 2) + Row.Margin.Bottom + ToolStripPanel.RowsInternal[index + 1].Margin.Top;
}
dragBounds.Width += Row.Margin.Horizontal + ToolStripPanel.Padding.Horizontal +5;
dragBounds.X -= Row.Margin.Left + ToolStripPanel.Padding.Left +4;
return dragBounds;
}
}
///
/// returns true if there is enough space to "raft" the control
/// ow returns false
///
public override bool CanMove(ToolStrip toolStripToDrag) {
if (base.CanMove(toolStripToDrag)) {
Size totalSize = Size.Empty;
for (int i = 0; i < Row.ControlsInternal.Count; i++ ){
totalSize += Row.GetMinimumSize(Row.ControlsInternal[i] as ToolStrip);
}
totalSize += Row.GetMinimumSize(toolStripToDrag as ToolStrip);
return totalSize.Width < DisplayRectangle.Width;
}
Debug.WriteLineIf(ToolStripPanelRow.ToolStripPanelRowCreationDebug.TraceVerbose, "HorizontalRM.CanMove returns false - not enough room");
return false;
}
protected internal override int FreeSpaceFromRow(int spaceToFree) {
int requiredSpace = spaceToFree;
// take a look at the last guy. if his right edge exceeds
// the new bounds, then we should go ahead and push him into view.
if (spaceToFree > 0){
// we should shrink the last guy and then move him.
ToolStripPanelCell lastCellOnRow = GetNextVisibleCell(Row.Cells.Count-1, /*forward*/false);
if (lastCellOnRow == null) {
return 0;
}
Padding cellMargin = lastCellOnRow.Margin;
// only check margin.left as we are only concerned with getting right edge of
// the toolstrip into view. (space after the fact doesnt count).
if (cellMargin.Left >= spaceToFree) {
cellMargin.Left -= spaceToFree;
cellMargin.Right = 0;
spaceToFree = 0;
}
else {
spaceToFree -= lastCellOnRow.Margin.Left;
cellMargin.Left = 0;
cellMargin.Right = 0;
}
lastCellOnRow.Margin = cellMargin;
// start moving the toolstrips before this guy.
spaceToFree -= MoveLeft(Row.Cells.Count -1, spaceToFree);
if (spaceToFree > 0) {
spaceToFree -= lastCellOnRow.Shrink(spaceToFree);
}
}
return requiredSpace - Math.Max(0,spaceToFree);
}
public override void MoveControl(ToolStrip movingControl, Point clientStartLocation, Point clientEndLocation) {
if (Row.Locked) {
return;
}
if (DragBounds.Contains(clientEndLocation)) {
int index = Row.ControlsInternal.IndexOf(movingControl);
int deltaX = clientEndLocation.X - clientStartLocation.X;
if (deltaX < 0) {
// moving to the left
MoveLeft(index, deltaX * -1);
}
else {
MoveRight(index, deltaX);
}
}
else {
base.MoveControl(movingControl, clientStartLocation, clientEndLocation);
}
}
private int MoveLeft(int index, int spaceToFree) {
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "MoveLeft: " + spaceToFree.ToString(CultureInfo.InvariantCulture));
int freedSpace = 0;
Row.SuspendLayout();
try {
if (spaceToFree == 0 || index < 0) {
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "MoveLeft Early EXIT - 0 ");
return 0;
}
// remove all margins starting from the index.
for (int i = index; i >= 0; i--) {
ToolStripPanelCell cell = (ToolStripPanelCell)Row.Cells[i];
if (!cell.Visible && !cell.ControlInDesignMode) {
continue;
}
int requiredSpace = spaceToFree - freedSpace;
Padding cellMargin = cell.Margin;
if (cellMargin.Horizontal >= requiredSpace) {
freedSpace += requiredSpace;
cellMargin.Left -= requiredSpace;
cellMargin.Right = 0;
cell.Margin = cellMargin;
}
else {
freedSpace += cell.Margin.Horizontal;
cellMargin.Left = 0;
cellMargin.Right = 0;
cell.Margin = cellMargin;
}
if (freedSpace >= spaceToFree) {
// add the space we freed to the next guy.
if (index +1 < Row.Cells.Count) {
cell = GetNextVisibleCell(index+1, /*forward*/true);
if (cell != null) {
cellMargin = cell.Margin;
cellMargin.Left += spaceToFree;
cell.Margin = cellMargin;
}
}
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "MoveLeft Recovered (Margin only): " + spaceToFree.ToString(CultureInfo.InvariantCulture));
return spaceToFree;
}
}
}
finally {
Row.ResumeLayout(true);
}
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "MoveLeft Recovered Partial (Shrink): " + freedSpace.ToString(CultureInfo.InvariantCulture));
return freedSpace;
}
private int MoveRight(int index, int spaceToFree) {
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "MoveRight: " + spaceToFree.ToString(CultureInfo.InvariantCulture));
int freedSpace = 0;
Row.SuspendLayout();
try {
if (spaceToFree == 0 || index < 0 || index >= Row.ControlsInternal.Count) {
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "MoveRight Early EXIT - 0 ");
return 0;
}
ToolStripPanelCell cell;
Padding cellMargin;
// remove all margins after this point in the index.
for (int i = index+1; i < Row.Cells.Count; i++) {
cell = (ToolStripPanelCell)Row.Cells[i];
if (!cell.Visible && !cell.ControlInDesignMode) {
continue;
}
int requiredSpace = spaceToFree - freedSpace;
cellMargin = cell.Margin;
if (cellMargin.Horizontal >= requiredSpace) {
freedSpace += requiredSpace;
cellMargin.Left -= requiredSpace;
cellMargin.Right = 0;
cell.Margin = cellMargin;
}
else {
freedSpace += cell.Margin.Horizontal;
cellMargin.Left = 0;
cellMargin.Right = 0;
cell.Margin = cellMargin;
}
break;
}
// add in the space at the end of the row.
if (Row.Cells.Count > 0 && (spaceToFree > freedSpace)) {
ToolStripPanelCell lastCell = GetNextVisibleCell(Row.Cells.Count -1, /*forward*/false);
if (lastCell != null) {
freedSpace += DisplayRectangle.Right - lastCell.Bounds.Right;
}
else {
freedSpace += DisplayRectangle.Width;
}
}
// set the margin of the control that's moving.
if (spaceToFree <= freedSpace) {
// add the space we freed to the first guy.
cell = GetNextVisibleCell(index, /*forward*/true);
if (cell == null) {
cell = Row.Cells[index] as ToolStripPanelCell;
}
Debug.Assert(cell != null, "Dont expect cell to be null here, what's going on?");
if (cell != null) {
cellMargin = cell.Margin;
cellMargin.Left += spaceToFree;
cell.Margin = cellMargin;
}
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "MoveRight Recovered (Margin only): " + spaceToFree.ToString(CultureInfo.InvariantCulture));
return spaceToFree;
}
// Now start shrinking.
for (int i = index+1; i < Row.Cells.Count; i++) {
cell = (ToolStripPanelCell)Row.Cells[i];
if (!cell.Visible && !cell.ControlInDesignMode) {
continue;
}
int requiredSpace = spaceToFree - freedSpace;
freedSpace += cell.Shrink(requiredSpace);
if (spaceToFree >= freedSpace) {
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "MoveRight Recovered (Shrink): " + spaceToFree.ToString(CultureInfo.InvariantCulture));
Row.ResumeLayout(true);
return spaceToFree;
}
}
if (Row.Cells.Count == 1) {
cell = GetNextVisibleCell(index,/*forward*/true);
if (cell != null) {
cellMargin = cell.Margin;
cellMargin.Left += freedSpace;
cell.Margin = cellMargin;
}
}
}
finally {
Row.ResumeLayout(true);
}
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "MoveRight Recovered Partial (Shrink): " + freedSpace.ToString(CultureInfo.InvariantCulture));
return freedSpace;
}
public override void LeaveRow(ToolStrip toolStripToDrag) {
// this code is here to properly add space to the next control when the
// toolStripToDrag has been removed from the row.
Row.SuspendLayout();
int index = Row.ControlsInternal.IndexOf(toolStripToDrag);
if (index >= 0) {
if (index < Row.ControlsInternal.Count -1 /*not the last one in the row*/) {
ToolStripPanelCell cell = (ToolStripPanelCell)Row.Cells[index];
if (cell.Visible) {
int spaceOccupiedByCell = cell.Margin.Horizontal + cell.Bounds.Width;
// add the space occupied by the cell to the next one.
ToolStripPanelCell nextCell = GetNextVisibleCell(index+1, /*forward*/true);
if (nextCell != null) {
Padding nextCellMargin = nextCell.Margin;
nextCellMargin.Left += spaceOccupiedByCell;
nextCell.Margin = nextCellMargin;
}
}
}
// remove the control from the row.
((IList)Row.Cells).RemoveAt(index);
}
Row.ResumeLayout(true);
}
protected internal override void OnControlAdded(Control control, int index) {
}
protected internal override void OnControlRemoved(Control control, int index) {
}
public override void JoinRow(ToolStrip toolStripToDrag, Point locationToDrag) {
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "Horizontal JoinRow called " );
int index;
if (!Row.ControlsInternal.Contains(toolStripToDrag)) {
Row.SuspendLayout();
try {
if (Row.ControlsInternal.Count > 0) {
// walk through the columns and determine which column you want to insert into.
for (index = 0; index < Row.Cells.Count; index++) {
ToolStripPanelCell cell = Row.Cells[index] as ToolStripPanelCell;
if (!cell.Visible && !cell.ControlInDesignMode) {
continue;
}
// [: ] [: x ]
if (Row.Cells[index].Bounds.Contains(locationToDrag)) {
break;
}
// take into account the following scenarios
// [: ] x [: ]
// x [: ] [: ]
if (Row.Cells[index].Bounds.X >= locationToDrag.X) {
break;
}
}
Control controlToPushAside = Row.ControlsInternal[index];
// Plop the new control in the midst of the row in question.
if (index < Row.ControlsInternal.Count) {
Row.ControlsInternal.Insert(index, toolStripToDrag);
}
else {
Row.ControlsInternal.Add(toolStripToDrag);
}
// since layout is suspended the control may not be set to its preferred size yet
int controlToDragWidth = (toolStripToDrag.AutoSize) ? toolStripToDrag.PreferredSize.Width : toolStripToDrag.Width;
//
// now make it look like it belongs in the row.
//
// PUSH the controls after it to the right
int requiredSpace = controlToDragWidth;
if (index == 0) {
// make sure we account for the left side
requiredSpace += locationToDrag.X;
}
int freedSpace = 0;
if (index < Row.ControlsInternal.Count -1) {
ToolStripPanelCell nextCell = (ToolStripPanelCell)Row.Cells[index+1];
Padding nextCellMargin = nextCell.Margin;
// if we've already got the empty space
// (available to us via the margin) use that.
if (nextCellMargin.Left > requiredSpace) {
nextCellMargin.Left -= requiredSpace;
nextCell.Margin = nextCellMargin;
freedSpace = requiredSpace;
}
else {
// otherwise we've got to
// push all controls after this point to the right
// this dumps the extra stuff into the margin of index+1
freedSpace = MoveRight(index+1, requiredSpace - freedSpace);
// refetch the margin for "index+1" and remove the freed space
// from it - we want to actually put this to use on the control
// before this one - we're making room for the control at
// position "index"
if (freedSpace > 0) {
nextCellMargin = nextCell.Margin;
nextCellMargin.Left = Math.Max(0, nextCellMargin.Left - freedSpace);
nextCell.Margin = nextCellMargin;
}
}
}
else {
// we're adding to the end.
ToolStripPanelCell nextCell = GetNextVisibleCell(Row.Cells.Count-2, /*forward*/false);
ToolStripPanelCell lastCell = GetNextVisibleCell(Row.Cells.Count-1, /*forward*/false);
// count the stuff at the end of the row as freed space
if (nextCell != null && lastCell != null) {
Padding lastCellMargin = lastCell.Margin;
lastCellMargin.Left = Math.Max(0,locationToDrag.X - nextCell.Bounds.Right);
lastCell.Margin = lastCellMargin;
freedSpace=requiredSpace;
}
}
// If we still need more space, then...
// PUSH the controls before it to the left
if (freedSpace < requiredSpace && index > 0) {
freedSpace = MoveLeft(index - 1, requiredSpace - freedSpace);
}
if (index == 0) {
// if the index is zero and there were controls in the row
// we need to take care of pushing over the new cell.
if (freedSpace - controlToDragWidth > 0) {
ToolStripPanelCell newCell = Row.Cells[index] as ToolStripPanelCell;
Padding newCellMargin = newCell.Margin;
newCellMargin.Left = freedSpace - controlToDragWidth;
newCell.Margin = newCellMargin;
}
}
}
else {
// we're adding to the beginning.
Row.ControlsInternal.Add(toolStripToDrag);
#if DEBUG
ISupportToolStripPanel ctg = toolStripToDrag as ISupportToolStripPanel;
ToolStripPanelRow newPanelRow = ctg.ToolStripPanelRow;
Debug.Assert(newPanelRow == Row, "we should now be in the new panel row.");
#endif
if (Row.Cells.Count >0 || toolStripToDrag.IsInDesignMode) {
// we're adding to the beginning.
ToolStripPanelCell cell = GetNextVisibleCell(Row.Cells.Count-1, /*forward*/false);
if (cell == null && toolStripToDrag.IsInDesignMode) {
cell = (ToolStripPanelCell)Row.Cells[Row.Cells.Count-1];
}
if (cell != null) {
Padding cellMargin = cell.Margin;
cellMargin.Left = Math.Max(0,locationToDrag.X-Row.Margin.Left);
cell.Margin = cellMargin;
}
}
}
}
finally {
Row.ResumeLayout(true);
}
}
}
protected internal override void OnBoundsChanged(Rectangle oldBounds, Rectangle newBounds) {
base.OnBoundsChanged(oldBounds, newBounds);
}
}
private class VerticalRowManager : ToolStripPanelRowManager {
private const int DRAG_BOUNDS_INFLATE = 4;
public VerticalRowManager(ToolStripPanelRow owner): base (owner) {
owner.SuspendLayout();
FlowLayoutSettings.WrapContents = false;
FlowLayoutSettings.FlowDirection = FlowDirection.TopDown;
owner.ResumeLayout(false);
}
public override Rectangle DisplayRectangle {
get {
Rectangle displayRect = ((IArrangedElement)Row).DisplayRectangle;
if (ToolStripPanel != null) {
Rectangle raftingDisplayRectangle = ToolStripPanel.DisplayRectangle;
if ((!ToolStripPanel.Visible || LayoutUtils.IsZeroWidthOrHeight(raftingDisplayRectangle)) && (ToolStripPanel.ParentInternal != null)){
// if were layed out before we're visible we have the wrong display rectangle, so we need to calculate it.
displayRect.Height = ToolStripPanel.ParentInternal.DisplayRectangle.Height - (ToolStripPanel.Margin.Vertical + ToolStripPanel.Padding.Vertical) - Row.Margin.Vertical;
}
else {
displayRect.Height = raftingDisplayRectangle.Height - Row.Margin.Vertical;
}
}
return displayRect;
}
}
public override Rectangle DragBounds {
get {
Rectangle dragBounds = Row.Bounds;
int index = ToolStripPanel.RowsInternal.IndexOf(Row);
///
if (index > 0) {
Rectangle previousRowBounds = ToolStripPanel.RowsInternal[index - 1].Bounds;
int x = previousRowBounds.X + previousRowBounds.Width - (previousRowBounds.Width >> 2);
dragBounds.Width += dragBounds.X - x;
dragBounds.X = x;
}
if (index < ToolStripPanel.RowsInternal.Count - 1) {
Rectangle nextRowBounds = ToolStripPanel.RowsInternal[index + 1].Bounds;
dragBounds.Width += (nextRowBounds.Width >> 2) + Row.Margin.Right + ToolStripPanel.RowsInternal[index + 1].Margin.Left;
}
dragBounds.Height += Row.Margin.Vertical + ToolStripPanel.Padding.Vertical +5;
dragBounds.Y -= Row.Margin.Top+ ToolStripPanel.Padding.Top +4;
return dragBounds;
}
}
///
/// returns true if there is enough space to "raft" the control
/// ow returns false
///
public override bool CanMove(ToolStrip toolStripToDrag) {
if (base.CanMove(toolStripToDrag)) {
Size totalSize = Size.Empty;
for (int i = 0; i < Row.ControlsInternal.Count; i++ ){
totalSize += Row.GetMinimumSize(Row.ControlsInternal[i] as ToolStrip);
}
totalSize += Row.GetMinimumSize(toolStripToDrag);
return totalSize.Height < DisplayRectangle.Height;
}
Debug.WriteLineIf(ToolStripPanelRow.ToolStripPanelRowCreationDebug.TraceVerbose, "VerticalRM.CanMove returns false - not enough room");
return false;
}
protected internal override int FreeSpaceFromRow(int spaceToFree) {
int requiredSpace = spaceToFree;
// take a look at the last guy. if his right edge exceeds
// the new bounds, then we should go ahead and push him into view.
if (spaceToFree > 0){
// we should shrink the last guy and then move him.
ToolStripPanelCell lastCellOnRow = GetNextVisibleCell(Row.Cells.Count-1, /*forward*/false);
if (lastCellOnRow == null) {
return 0;
}
Padding cellMargin = lastCellOnRow.Margin;
// only check margin.left as we are only concerned with getting right edge of
// the toolstrip into view. (space after the fact doesnt count).
if (cellMargin.Top >= spaceToFree) {
cellMargin.Top -= spaceToFree;
cellMargin.Bottom = 0;
spaceToFree = 0;
}
else {
spaceToFree -= lastCellOnRow.Margin.Top;
cellMargin.Top = 0;
cellMargin.Bottom = 0;
}
lastCellOnRow.Margin = cellMargin;
// start moving the toolstrips before this guy.
spaceToFree -= MoveUp(Row.Cells.Count -1, spaceToFree);
if (spaceToFree > 0) {
spaceToFree -= lastCellOnRow.Shrink(spaceToFree);
}
}
return requiredSpace - Math.Max(0,spaceToFree);
}
public override void MoveControl(ToolStrip movingControl, Point clientStartLocation, Point clientEndLocation) {
if (Row.Locked) {
return;
}
if (DragBounds.Contains(clientEndLocation)) {
int index = Row.ControlsInternal.IndexOf(movingControl);
int deltaY = clientEndLocation.Y - clientStartLocation.Y;
if (deltaY < 0) {
// moving to the left
MoveUp(index, deltaY * -1);
}
else {
MoveDown(index, deltaY);
}
}
else {
base.MoveControl(movingControl, clientStartLocation, clientEndLocation);
}
}
private int MoveUp(int index, int spaceToFree) {
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "MoveUp: " + spaceToFree.ToString(CultureInfo.InvariantCulture));
int freedSpace = 0;
Row.SuspendLayout();
try {
if (spaceToFree == 0 || index < 0) {
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "MoveUp Early EXIT - 0 ");
return 0;
}
// remove all margins starting from the index.
for (int i = index; i >= 0; i--) {
ToolStripPanelCell cell = (ToolStripPanelCell)Row.Cells[i];
if (!cell.Visible && !cell.ControlInDesignMode) {
continue;
}
int requiredSpace = spaceToFree - freedSpace;
Padding cellMargin = cell.Margin;
if (cellMargin.Vertical >= requiredSpace) {
freedSpace += requiredSpace;
cellMargin.Top -= requiredSpace;
cellMargin.Bottom = 0;
cell.Margin = cellMargin;
}
else {
freedSpace += cell.Margin.Vertical;
cellMargin.Top = 0;
cellMargin.Bottom = 0;
cell.Margin = cellMargin;
}
if (freedSpace >= spaceToFree) {
// add the space we freed to the next guy.
if (index +1 < Row.Cells.Count) {
cell = GetNextVisibleCell(index+1, /*forward*/true);
if (cell != null) {
cellMargin = cell.Margin;
cellMargin.Top += spaceToFree;
cell.Margin = cellMargin;
}
}
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "MoveUp Recovered (Margin only): " + spaceToFree.ToString(CultureInfo.InvariantCulture));
return spaceToFree;
}
}
}
finally {
Row.ResumeLayout(true);
}
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "MoveLeft Recovered Partial (Shrink): " + freedSpace.ToString(CultureInfo.InvariantCulture));
return freedSpace;
}
private int MoveDown(int index, int spaceToFree) {
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "MoveDown: " + spaceToFree.ToString(CultureInfo.InvariantCulture));
int freedSpace = 0;
Row.SuspendLayout();
try {
if (spaceToFree == 0 || index < 0 || index >= Row.ControlsInternal.Count) {
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "MoveDown Early EXIT - 0 ");
return 0;
}
ToolStripPanelCell cell;
Padding cellMargin;
// remove all margins after this point in the index.
for (int i = index+1; i < Row.Cells.Count; i++) {
cell = (ToolStripPanelCell)Row.Cells[i];
if (!cell.Visible && !cell.ControlInDesignMode) {
continue;
}
int requiredSpace = spaceToFree - freedSpace;
cellMargin = cell.Margin;
if (cellMargin.Vertical >= requiredSpace) {
freedSpace += requiredSpace;
cellMargin.Top -= requiredSpace;
cellMargin.Bottom = 0;
cell.Margin = cellMargin;
}
else {
freedSpace += cell.Margin.Vertical;
cellMargin.Top = 0;
cellMargin.Bottom = 0;
cell.Margin = cellMargin;
}
break;
}
// add in the space at the end of the row.
if (Row.Cells.Count > 0 && (spaceToFree > freedSpace)) {
ToolStripPanelCell lastCell = GetNextVisibleCell(Row.Cells.Count -1, /*forward*/false);
if (lastCell != null) {
freedSpace += DisplayRectangle.Bottom - lastCell.Bounds.Bottom;
}
else {
freedSpace += DisplayRectangle.Height;
}
}
// set the margin of the control that's moving.
if (spaceToFree <= freedSpace) {
// add the space we freed to the first guy.
cell = (ToolStripPanelCell)Row.Cells[index];
cellMargin = cell.Margin;
cellMargin.Top += spaceToFree;
cell.Margin = cellMargin;
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "MoveDown Recovered (Margin only): " + spaceToFree.ToString(CultureInfo.InvariantCulture));
return spaceToFree;
}
// Now start shrinking.
for (int i = index+1; i < Row.Cells.Count; i++) {
cell = (ToolStripPanelCell)Row.Cells[i];
if (!cell.Visible && !cell.ControlInDesignMode) {
continue;
}
int requiredSpace = spaceToFree - freedSpace;
freedSpace += cell.Shrink(requiredSpace);
if (spaceToFree >= freedSpace) {
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "MoveDown Recovered (Shrink): " + spaceToFree.ToString(CultureInfo.InvariantCulture));
Row.ResumeLayout(true);
return spaceToFree;
}
}
if (Row.Cells.Count == 1) {
cell = GetNextVisibleCell(index,/*forward*/true);
if (cell != null) {
cellMargin = cell.Margin;
cellMargin.Top += freedSpace;
cell.Margin = cellMargin;
}
}
}
finally {
Row.ResumeLayout(true);
}
int recoveredSpace = spaceToFree - freedSpace;
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "MoveDown Recovered Partial (Shrink): " + recoveredSpace.ToString(CultureInfo.InvariantCulture));
return recoveredSpace;
}
protected internal override void OnBoundsChanged(Rectangle oldBounds, Rectangle newBounds) {
base.OnBoundsChanged(oldBounds, newBounds);
// if our bounds have changed - we should shove the toolbars up so they're in view.
if (Row.Cells.Count > 0) {
// take a look at the last guy. if his right edge exceeds
// the new bounds, then we should go ahead and push him into view.
ToolStripPanelCell lastCell = GetNextVisibleCell(Row.Cells.Count -1, /*forward=*/false);
int spaceToFree = (lastCell != null)? lastCell.Bounds.Bottom - newBounds.Height : 0;
if (spaceToFree > 0){
// we should shrink the last guy and then move him.
ToolStripPanelCell lastCellOnRow = GetNextVisibleCell(Row.Cells.Count-1, /*forward*/false);
Padding cellMargin = lastCellOnRow.Margin;
// only check margin.left as we are only concerned with getting bottom edge of
// the toolstrip into view. (space after the fact doesnt count).
if (cellMargin.Top >= spaceToFree) {
cellMargin.Top -= spaceToFree;
cellMargin.Bottom = 0;
lastCellOnRow.Margin = cellMargin;
spaceToFree = 0;
}
else {
spaceToFree -= lastCellOnRow.Margin.Top;
cellMargin.Top = 0;
cellMargin.Bottom = 0;
lastCellOnRow.Margin = cellMargin;
}
spaceToFree -= lastCellOnRow.Shrink(spaceToFree);
// start moving the toolstrips before this guy.
MoveUp(Row.Cells.Count -1, spaceToFree);
}
}
}
protected internal override void OnControlRemoved(Control c, int index) {
}
protected internal override void OnControlAdded(Control control, int index) {
}
public override void JoinRow(ToolStrip toolStripToDrag, Point locationToDrag) {
Debug.WriteLineIf(ToolStripPanelMouseDebug.TraceVerbose, "Vertical JoinRow called " );
int index;
if (!Row.ControlsInternal.Contains(toolStripToDrag)) {
Row.SuspendLayout();
try {
if (Row.ControlsInternal.Count > 0) {
// walk through the columns and determine which column you want to insert into.
for (index = 0; index < Row.Cells.Count; index++) {
ToolStripPanelCell cell = Row.Cells[index] as ToolStripPanelCell;
if (!cell.Visible && !cell.ControlInDesignMode) {
continue;
}
// [: ] [: x ]
if (cell.Bounds.Contains(locationToDrag)) {
break;
}
// take into account the following scenarios
// [: ] x [: ]
// x [: ] [: ]
if (cell.Bounds.Y >= locationToDrag.Y) {
break;
}
}
Control controlToPushAside = Row.ControlsInternal[index];
// Plop the new control in the midst of the row in question.
if (index < Row.ControlsInternal.Count) {
Row.ControlsInternal.Insert(index, toolStripToDrag);
}
else {
Row.ControlsInternal.Add(toolStripToDrag);
}
// since layout is suspended the control may not be set to its preferred size yet
int controlToDragWidth = (toolStripToDrag.AutoSize) ? toolStripToDrag.PreferredSize.Height : toolStripToDrag.Height;
//
// now make it look like it belongs in the row.
//
// PUSH the controls after it to the right
int requiredSpace = controlToDragWidth;
if (index == 0) {
// make sure we account for the left side
requiredSpace += locationToDrag.Y;
}
int freedSpace = 0;
if (index < Row.ControlsInternal.Count -1) {
ToolStripPanelCell nextCell = GetNextVisibleCell(index+1, /*forward*/true);
if (nextCell != null) {
Padding nextCellMargin = nextCell.Margin;
// if we've already got the empty space
// (available to us via the margin) use that.
if (nextCellMargin.Top > requiredSpace) {
nextCellMargin.Top -= requiredSpace;
nextCell.Margin = nextCellMargin;
freedSpace = requiredSpace;
}
else {
// otherwise we've got to
// push all controls after this point to the right
// this dumps the extra stuff into the margin of index+1
freedSpace = MoveDown(index+1, requiredSpace - freedSpace);
// refetch the margin for "index+1" and remove the freed space
// from it - we want to actually put this to use on the control
// before this one - we're making room for the control at
// position "index"
if (freedSpace > 0) {
nextCellMargin = nextCell.Margin;
nextCellMargin.Top -= freedSpace;
nextCell.Margin = nextCellMargin;
}
}
}
}
else {
// we're adding to the end.
ToolStripPanelCell nextCell = GetNextVisibleCell(Row.Cells.Count-2, /*forward*/false);
ToolStripPanelCell lastCell = GetNextVisibleCell(Row.Cells.Count-1, /*forward*/false);
// count the stuff at the end of the row as freed space
if (nextCell != null && lastCell != null) {
Padding lastCellMargin = lastCell.Margin;
lastCellMargin.Top = Math.Max(0,locationToDrag.Y - nextCell.Bounds.Bottom);
lastCell.Margin = lastCellMargin;
freedSpace=requiredSpace;
}
}
// If we still need more space, then...
// PUSH the controls before it to the left
if (freedSpace < requiredSpace && index > 0) {
freedSpace = MoveUp(index - 1, requiredSpace - freedSpace);
}
if (index == 0) {
// if the index is zero and there were controls in the row
// we need to take care of pushing over the new cell.
if (freedSpace - controlToDragWidth > 0) {
ToolStripPanelCell newCell = Row.Cells[index] as ToolStripPanelCell;
Padding newCellMargin = newCell.Margin;
newCellMargin.Top = freedSpace - controlToDragWidth;
newCell.Margin = newCellMargin;
}
}
}
else {
// we're adding to the beginning.
Row.ControlsInternal.Add(toolStripToDrag);
#if DEBUG
ISupportToolStripPanel ctg = toolStripToDrag as ISupportToolStripPanel;
ToolStripPanelRow newPanelRow = ctg.ToolStripPanelRow;
Debug.Assert(newPanelRow == Row, "we should now be in the new panel row.");
#endif
if (Row.Cells.Count >0) {
ToolStripPanelCell cell = GetNextVisibleCell(Row.Cells.Count-1, /*forward*/false);
if (cell != null) {
Padding cellMargin = cell.Margin;
cellMargin.Top = Math.Max(0,locationToDrag.Y-Row.Margin.Top);
cell.Margin = cellMargin;
}
}
}
}
finally {
Row.ResumeLayout(true);
}
}
}
public override void LeaveRow(ToolStrip toolStripToDrag) {
// this code is here to properly add space to the next control when the
// toolStripToDrag has been removed from the row.
Row.SuspendLayout();
int index = Row.ControlsInternal.IndexOf(toolStripToDrag);
if (index >= 0) {
if (index < Row.ControlsInternal.Count -1 /*not the last one in the row*/) {
ToolStripPanelCell cell = (ToolStripPanelCell)Row.Cells[index];
if (cell.Visible) {
int spaceOccupiedByCell = cell.Margin.Vertical + cell.Bounds.Height;
// add the space occupied by the cell to the next one.
ToolStripPanelCell nextCell = GetNextVisibleCell(index+1, /*forward*/true);
if (nextCell != null) {
Padding nextCellMargin = nextCell.Margin;
nextCellMargin.Top += spaceOccupiedByCell;
nextCell.Margin = nextCellMargin;
}
}
}
// remove the control from the row.
((IList)Row.Cells).RemoveAt(index);
}
Row.ResumeLayout(true);
}
}
///
/// ToolStripPanelRowControlCollection
///
/// this class represents the collection of controls on a particular row.
/// when you add and remove controls from this collection - you also add and remove
/// controls to and from the ToolStripPanel.Control's collection (which happens
/// to be externally readonly.)
///
/// This class is used to represent the IArrangedElement.Children for the ToolStripPanelRow -
/// which means that this collection represents the IArrangedElements to layout for
/// a particular ToolStripPanelRow.
///
/// We need to keep copies of the controls in both the ToolStripPanelRowControlCollection and
/// the ToolStripPanel.Control collection as the ToolStripPanel.Control collection
/// is responsible for parenting and unparenting the controls (ToolStripPanelRows do NOT derive from
/// Control and thus are NOT hwnd backed).
///
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Never)]
public int Add(Control value) {
ISupportToolStripPanel control = value as ISupportToolStripPanel;
if (value == null) {
throw new ArgumentNullException("value");
}
if (control == null) {
throw new NotSupportedException(SR.GetString(SR.TypedControlCollectionShouldBeOfType, typeof(ToolStrip).Name));
}
int index = InnerList.Add(control.ToolStripPanelCell);
OnAdd(control, index);
return index;
}
///
/// [To be supplied.]
///
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
[EditorBrowsable(EditorBrowsableState.Never)]
public void AddRange(Control[] value) {
if (value == null) {
throw new ArgumentNullException("value");
}
ToolStripPanel currentOwner = ToolStripPanel;
if (currentOwner != null) {
currentOwner.SuspendLayout();
}
try {
for (int i = 0; i < value.Length; i++) {
this.Add(value[i]);
}
}
finally {
if (currentOwner != null) {
currentOwner.ResumeLayout();
}
}
}
///
/// [To be supplied.]
///
public bool Contains(Control value) {
for (int i = 0; i < Count; i++) {
if (GetControl(i) == value) {
return true;
}
}
return false;
}
///
/// [To be supplied.]
///
public virtual void Clear() {
if (owner != null) {
ToolStripPanel.SuspendLayout();
}
try {
while (Count != 0) {
RemoveAt(Count - 1);
}
}
finally {
if (owner != null) {
ToolStripPanel.ResumeLayout();
}
}
}
public override IEnumerator GetEnumerator() { return new ToolStripPanelCellToControlEnumerator(InnerList); }
private Control GetControl(int index) {
Control control = null;
ToolStripPanelCell cell = null;
if (index < Count && index >= 0) {
cell = (ToolStripPanelCell)(InnerList[index]);
control = (cell != null) ? cell.Control : null;
}
return control;
}
private int IndexOfControl(Control c) {
for (int i = 0; i < Count; i++) {
ToolStripPanelCell cell = (ToolStripPanelCell)(InnerList[i]);
if (cell.Control == c) {
return i;
}
}
return -1;
}
void IList.Clear() { Clear(); }
bool IList.IsFixedSize { get { return InnerList.IsFixedSize; } }
bool IList.Contains(object value) { return InnerList.Contains(value); }
bool IList.IsReadOnly { get { return InnerList.IsReadOnly; } }
void IList.RemoveAt(int index) { RemoveAt(index); }
void IList.Remove(object value) { Remove(value as Control); }
int IList.Add(object value) { return Add(value as Control); }
int IList.IndexOf(object value) { return IndexOf(value as Control); }
void IList.Insert(int index, object value) { Insert(index, value as Control); }
///
/// [To be supplied.]
///
public int IndexOf(Control value) {
for (int i = 0; i < Count; i++) {
if (GetControl(i) == value) {
return i;
}
}
return -1;
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Never)]
public void Insert(int index, Control value) {
if (value == null) {
throw new ArgumentNullException("value");
}
ISupportToolStripPanel control = value as ISupportToolStripPanel;
if (control == null) {
throw new NotSupportedException(SR.GetString(SR.TypedControlCollectionShouldBeOfType, typeof(ToolStrip).Name));
}
InnerList.Insert(index, control.ToolStripPanelCell);
OnAdd(control, index);
}
///
/// Do proper cleanup of ownership, etc.
///
private void OnAfterRemove(Control control, int index) {
if (owner != null) {
// unfortunately we dont know the index of the control in the ToolStripPanel's
// control collection, as all rows share this collection.
// To unparent this control we need to use Remove instead of RemoveAt.
using (LayoutTransaction t = new LayoutTransaction(ToolStripPanel, control, PropertyNames.Parent)) {
owner.ToolStripPanel.Controls.Remove(control);
owner.OnControlRemoved(control, index);
}
}
}
private void OnAdd(ISupportToolStripPanel controlToBeDragged, int index) {
if (owner != null) {
LayoutTransaction layoutTransaction = null;
if (ToolStripPanel != null && ToolStripPanel.ParentInternal != null) {
layoutTransaction = new LayoutTransaction(ToolStripPanel, ToolStripPanel.ParentInternal, PropertyNames.Parent);
}
try {
if (controlToBeDragged != null) {
controlToBeDragged.ToolStripPanelRow = owner;
Control control = controlToBeDragged as Control;
if (control != null) {
control.ParentInternal = owner.ToolStripPanel;
owner.OnControlAdded(control, index);
}
}
}
finally {
if (layoutTransaction != null) {
layoutTransaction.Dispose();
}
}
}
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Never)]
public void Remove(Control value) {
int index = IndexOfControl(value);
RemoveAt(index);
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Never)]
public void RemoveAt(int index) {
if (index >= 0 && index < Count) {
Control control = GetControl(index);
ToolStripPanelCell cell = InnerList[index] as ToolStripPanelCell;
InnerList.RemoveAt(index);
OnAfterRemove(control, index);
}
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Never)]
public void CopyTo(Control[] array, int index) {
if (array == null) {
throw new ArgumentNullException("array");
}
if (index < 0) {
throw new ArgumentOutOfRangeException("index");
}
if (index >= array.Length || InnerList.Count > array.Length - index) {
throw new ArgumentException(SR.GetString(SR.ToolStripPanelRowControlCollectionIncorrectIndexLength));
}
for (int i = 0; i < InnerList.Count; i++) {
array[index++] = GetControl(i);
}
}
/// We want to pretend like we're only holding controls... so everywhere we've returned controls.
/// but the problem is if you do a foreach, you'll get the cells not the controls. So we've got
/// to sort of write a wrapper class around the ArrayList enumerator.
private class ToolStripPanelCellToControlEnumerator : IEnumerator, ICloneable {
private IEnumerator arrayListEnumerator;
internal ToolStripPanelCellToControlEnumerator(ArrayList list) {
arrayListEnumerator = ((IEnumerable)list).GetEnumerator();
}
public virtual Object Current {
get {
ToolStripPanelCell cell = arrayListEnumerator.Current as ToolStripPanelCell;
Debug.Assert(cell != null, "Expected ToolStripPanel cells only!!!" + arrayListEnumerator.Current.GetType().ToString());
return (cell == null) ? null : cell.Control;
}
}
public Object Clone() {
return MemberwiseClone();
}
public virtual bool MoveNext() {
return arrayListEnumerator.MoveNext();
}
public virtual void Reset() {
arrayListEnumerator.Reset();
}
}
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- GetPageCompletedEventArgs.cs
- TracedNativeMethods.cs
- GeneralTransformGroup.cs
- RemotingException.cs
- Privilege.cs
- StatusStrip.cs
- IgnoreSectionHandler.cs
- ProxyWebPartConnectionCollection.cs
- XNodeNavigator.cs
- StructuralCache.cs
- EventListener.cs
- TypeDescriptorContext.cs
- IImplicitResourceProvider.cs
- Ref.cs
- HighContrastHelper.cs
- CallTemplateAction.cs
- RegexRunnerFactory.cs
- XPathPatternParser.cs
- StringKeyFrameCollection.cs
- BaseComponentEditor.cs
- DiscoveryRequestHandler.cs
- PagePropertiesChangingEventArgs.cs
- DocumentEventArgs.cs
- TdsEnums.cs
- SkipQueryOptionExpression.cs
- ViewSimplifier.cs
- EventData.cs
- ObjectFullSpanRewriter.cs
- BeginEvent.cs
- ActivationWorker.cs
- DesignDataSource.cs
- RuleElement.cs
- SimpleLine.cs
- RouteTable.cs
- MulticastDelegate.cs
- TableLayoutStyleCollection.cs
- EventLogPermissionAttribute.cs
- XmlImplementation.cs
- SimpleWebHandlerParser.cs
- ScrollChangedEventArgs.cs
- AuthenticationService.cs
- MemberRelationshipService.cs
- Bitmap.cs
- Trace.cs
- ApplicationHost.cs
- DrawingState.cs
- SqlWebEventProvider.cs
- controlskin.cs
- DictionaryTraceRecord.cs
- DependencySource.cs
- Trace.cs
- MenuItemCollectionEditorDialog.cs
- TabControlCancelEvent.cs
- EmulateRecognizeCompletedEventArgs.cs
- PrinterUnitConvert.cs
- MemberRelationshipService.cs
- TakeQueryOptionExpression.cs
- Assembly.cs
- BitmapSizeOptions.cs
- DataSourceDescriptorCollection.cs
- SourceInterpreter.cs
- SystemIPInterfaceProperties.cs
- ReliableInputConnection.cs
- WrappedIUnknown.cs
- TimeSpanConverter.cs
- CaseExpr.cs
- GridViewSelectEventArgs.cs
- SmtpCommands.cs
- InfoCardAsymmetricCrypto.cs
- AnonymousIdentificationModule.cs
- BindingElementExtensionElement.cs
- Pkcs9Attribute.cs
- DebugView.cs
- GradientStopCollection.cs
- AttributeEmitter.cs
- DrawingAttributes.cs
- CodeDefaultValueExpression.cs
- BinaryParser.cs
- TransactionScope.cs
- HashCodeCombiner.cs
- HttpProtocolImporter.cs
- UidManager.cs
- HyperLinkDesigner.cs
- DiscoveryVersion.cs
- CheckBoxField.cs
- UIElementIsland.cs
- PeerTransportSecuritySettings.cs
- InputProcessorProfiles.cs
- OrderPreservingMergeHelper.cs
- QueryAccessibilityHelpEvent.cs
- XmlDataImplementation.cs
- Component.cs
- EncoderParameters.cs
- Run.cs
- LogAppendAsyncResult.cs
- Predicate.cs
- IndexOutOfRangeException.cs
- TextTreeFixupNode.cs
- Monitor.cs
- LinqDataSourceSelectEventArgs.cs