public Window Add(Window value)
{
// Use base class to process actual collection operation
base.List.Add(value as object);
return value;
}
public WindowDetail(DockingManager manager)
{
// Default the state
_parentZone = null;
_parentWindow = null;
_manager = manager;
// Get correct starting state from manager
this.BackColor = _manager.BackColor;
this.ForeColor = _manager.InactiveTextColor;
}
protected void InternalConstruct(VisualStyle style, Direction direction, bool zoneMinMax)
{
// Remember initial state
_style = style;
_direction = direction;
_maximizedWindow = null;
_suppressReposition = false;
_zoneMinMax = zoneMinMax;
// Create the control used to resize the whole Zone
_resizeBar = new ResizeBar(_direction, this);
// Place last in the list of child Controls
Controls.Add(_resizeBar);
// Start of very small and let first content determine new size
this.Size = new Size(0,0);
// Do not inherit the parent BackColor, we want the .Control color as
// this blends in with the way all the docking windows are drawn
this.BackColor = SystemColors.Control;
this.ForeColor = SystemColors.ControlText;
}
public virtual void AddedToParent(Window parent) {}
public virtual void RemovedFromParent(Window parent) {}
public override void RemovedFromParent(Window parent)
{
if (parent != null)
{
Size minSize = parent.MinimalSize;
// Remove our height from the minimum size of the parent
minSize.Height -= _fixedLength;
minSize.Width -= _fixedLength;
parent.MinimalSize = minSize;
}
}
public virtual void PerformRestore(Window w) {}
public void Insert(int index, Window value)
{
// Use base class to process actual collection operation
base.List.Insert(index, value as object);
}
public bool Contains(Window value)
{
// Use base class to process actual collection operation
return base.List.Contains(value as object);
}
protected void GetWindowContentFriends(Window match,
out StringCollection best,
out StringCollection next,
out StringCollection previous)
{
best = new StringCollection();
next = new StringCollection();
previous = new StringCollection();
bool before = true;
foreach(Window w in _windows)
{
WindowContent wc = w as WindowContent;
// Is this the Window we are searching for?
if (w == match)
{
if (wc != null)
{
// Best friends are those in the matching Window
foreach(Content content in wc.Contents)
best.Add(content.Title);
}
before = false;
}
else
{
if (wc != null)
{
// Remember all found Content in appropriate next/previous collection
foreach(Content content in wc.Contents)
{
if (before)
previous.Add(content.Title);
else
next.Add(content.Title);
}
}
}
}
}
public override void PropogateNameValue(PropogateName name, object value)
{
base.PropogateNameValue(name, value);
// Reduce flicker during update
SuspendLayout();
if (name == PropogateName.ZoneMinMax)
{
if (_zoneMinMax != (bool)value)
{
// Remember the new value
_zoneMinMax = (bool)value;
// If turning off the min/max ability
if (!_zoneMinMax)
_maximizedWindow = null; // no window can be currently maximized
// Get child windows to retest the maximize capability
OnRefreshMaximize(EventArgs.Empty);
}
}
// Update each resize bar control
foreach(Control c in this.Controls)
{
ResizeBar rb = c as ResizeBar;
if (rb != null)
rb.PropogateNameValue(name, value);
}
// Recalculate positions using new values
RepositionControls();
ResumeLayout();
}
public override Restore RecordRestore(Window w, object child, Restore childRestore)
{
Content c = child as Content;
// We currently only understand Windows that have Content as children
if (c != null)
{
StringCollection best;
StringCollection next;
StringCollection previous;
GetWindowContentFriends(w, out best, out next, out previous);
// Create a restore object that will find the correct WindowContent to
// place a Content in within a specified Zone, or it will create a new
// WindowContent in an appropriate relative ordering
Restore zoneRestore = new RestoreZoneAffinity(childRestore, c, best, next, previous);
if (_state == State.Floating)
{
// Create a restore object to find the correct Floating Form to restore inside
// or it will create a new Floating Form as appropriate
return new RestoreContentFloatingAffinity(zoneRestore, _state, c, best, ZoneHelper.ContentNames(this));
}
else
{
StringCollection zoneBest;
StringCollection zoneNext;
StringCollection zonePrevious;
StringCollection zoneNextAll;
StringCollection zonePreviousAll;
GetZoneContentFriends(c, out zoneBest, out zoneNext, out zonePrevious,
out zoneNextAll, out zonePreviousAll);
// Create a restore object able to find the correct Zone in the appropriate
// docking direction and then restore into that Zone. If no appropriate Zone
// found then create a new one
return new RestoreContentDockingAffinity(zoneRestore, _state, c, zoneBest,
zoneNext, zonePrevious,
zoneNextAll, zonePreviousAll);
}
}
return null;
}
public void RestoreWindow()
{
// Remember the newly maximized Window
_maximizedWindow = null;
// Inform all interested parties of change
OnRefreshMaximize(EventArgs.Empty);
RepositionControls();
}
public bool IsWindowMaximized(Window w)
{
return (w == _maximizedWindow);
}
protected void RemoveWindowSpace(Window w)
{
// Is there only a single Window left?
if (_windows.Count == 1)
{
// Give it all the space
_windows[0].ZoneArea = 100m;
}
else
{
// Is there any space to reallocate?
if (w.ZoneArea > 0)
{
// Total up all the values
Decimal totalAllocated = 0m;
// How much space should we add to each of the others
Decimal freedSpace = w.ZoneArea / (_windows.Count - 1);
foreach(Window entry in _windows)
{
if (entry != w)
{
// We only retain a sensible level of precision
Decimal newSpace = Decimal.Round(entry.ZoneArea + freedSpace, _spacePrecision);
// Assign back new space
entry.ZoneArea = newSpace;
// Total up all space so far
totalAllocated += newSpace;
}
}
// Look for minor errors due not all fractions can be accurately represented in binary!
if (totalAllocated > 100m)
{
Decimal correction = totalAllocated - 100m;
// Remove from first entry
foreach(Window entry in _windows)
{
if (entry != w)
{
// Apply correction to this window
entry.ZoneArea = totalAllocated - 100m;
break;
}
}
}
else if (totalAllocated < 100m)
{
Decimal correction = 100m - totalAllocated;
// Remove from first entry
foreach(Window entry in _windows)
{
if (entry != w)
{
// Apply correction to this window
entry.ZoneArea += 100m - totalAllocated;
break;
}
}
}
// Window no longer has any space
w.ZoneArea = 0m;
}
}
}
public void ModifyWindowSpace(Window w, Decimal newSpace)
{
// Double check this Window is a member of the collection
if (_windows.Contains(w))
{
// Cannot reallocate space if it is the only element
if (_windows.Count > 1)
{
int otherWindows = _windows.Count - 1;
// Limit the resize allowed
if (newSpace > 100m)
newSpace = 100m;
if (newSpace <= 0m)
newSpace = 0m;
if (newSpace != w.ZoneArea)
{
// How much needs to be reallocated to other windows
Decimal diff = w.ZoneArea - newSpace;
// Reducing the amount of space?
if (diff > 0m)
{
// How much to give each of the other windows
Decimal extra = diff / otherWindows;
// Looping counters
Decimal allocated = 0m;
int found = 0;
foreach(Window target in _windows)
{
// We only process the other windows
if (target != w)
{
// Allocate it extra space
target.ZoneArea += extra;
// Keep count of total extra allocated
allocated += extra;
// Count number of others processed
found++;
// The last window to be allocated needs to also be given any rouding
// errors that occur from previous division, to ensure that the total
// space it always exactly equal to 100.
if (found == otherWindows)
target.ZoneArea += (diff - allocated);
}
}
}
else
{
// Easier to work with positive than negative numbers
diff = -diff;
while(diff > 0m)
{
// How much to grab from each of the other windows
Decimal extra = diff / otherWindows;
foreach(Window target in _windows)
{
// We only process the other windows
if (target != w)
{
if (target.ZoneArea > 0m)
{
if (target.ZoneArea < extra)
{
// Keep count of total left to grab
diff -= target.ZoneArea;
// Window no longer has any ZoneArea
target.ZoneArea = 0m;
}
else
{
// Allocate it extra space
target.ZoneArea -= extra;
// Keep count of total left to grab
diff -= extra;
}
}
}
}
}
}
w.ZoneArea = newSpace;
}
}
}
// Recalculate the size and position of each Window and resize bar
RepositionControls();
}
public virtual Restore RecordRestore(Window w, object child, Restore childRestore)
{
return null;
}
protected override void OnWindowsClearing()
{
base.OnWindowsClearing();
// Make sure no Window is recorded as maximized
_maximizedWindow = null;
// Remove all child controls
Controls.Clear();
if (!this.AutoDispose)
{
// Add back the Zone resize bar
Controls.Add(_resizeBar);
Invalidate();
}
}
public void AddRange(Window[] values)
{
// Use existing method to add each array entry
foreach(Window page in values)
Add(page);
}
protected override void OnWindowRemoving(int index, object value)
{
base.OnWindowRemoving(index, value);
Window w = value as Window;
// If the Window being removed the maximized one?
if (_maximizedWindow == w)
_maximizedWindow = null;
// Is this the only Window entry?
if (_windows.Count == 1)
{
// Remove Window from appearance
// Use helper method to circumvent form Close bug
ControlHelper.RemoveAt(this.Controls, 0);
}
else
{
int pos = 0;
// Calculate position of Window to remove
if (index != 0)
pos = index * 2 - 1;
// Remove Window and bar
// Use helper method to circumvent form Close bug
ControlHelper.RemoveAt(this.Controls, pos);
ControlHelper.RemoveAt(this.Controls, pos);
}
// Redistribute space taken up by Window to other windows
RemoveWindowSpace(w);
}
public int IndexOf(Window value)
{
// Find the 0 based index of the requested entry
return base.List.IndexOf(value);
}
protected void AllocateWindowSpace(Window w)
{
// Is this the only Window?
if (_windows.Count == 1)
{
// Give it all the space
w.ZoneArea = 100m;
}
else
{
// Calculate how much space it should have
Decimal newSpace = 100m / _windows.Count;
// How much space should we steal from each of the others
Decimal reduceSpace = newSpace / (_windows.Count - 1);
// Actual space acquired
Decimal allocatedSpace = 0m;
foreach(Window entry in _windows)
{
if (entry != w)
{
// How much space the entry currently has
Decimal currentSpace = entry.ZoneArea;
// How much space to steal from it
Decimal xferSpace = reduceSpace;
// Does it have at least the requested amount of space?
if (currentSpace < xferSpace)
xferSpace = currentSpace;
// Transfer the space across
currentSpace -= xferSpace;
// Round the sensible number of decimal places
currentSpace = Decimal.Round(currentSpace, _spacePrecision);
// Update window with new space allocation
entry.ZoneArea = currentSpace;
allocatedSpace += currentSpace;
}
}
// Assign allocated space to new window
w.ZoneArea = 100m - allocatedSpace;
}
}
public void Remove(Window value)
{
// Use base class to process actual collection operation
base.List.Remove(value as object);
}
protected void ModifyWindowSpace(Window w, int vector)
{
// Remove any maximized state
if (_maximizedWindow != null)
{
// Make the maximized Window have all the space
foreach(Window entry in _windows)
{
if (entry == _maximizedWindow)
entry.ZoneArea = 100m;
else
entry.ZoneArea = 0m;
}
// Remove maximized state
_maximizedWindow = null;
// Inform all interested parties of change
OnRefreshMaximize(EventArgs.Empty);
}
Rectangle clientRect = this.ClientRectangle;
RepositionZoneBar(ref clientRect);
// Space available for allocation
int space;
// New pixel length of the modified Window
int newLength = vector;
if (_direction == Direction.Vertical)
{
space = clientRect.Height;
// New pixel size is requested change plus original
// height minus the minimal size that is always added
newLength += w.Height;
newLength -= w.MinimalSize.Height;
}
else
{
space = clientRect.Width;
// New pixel size is requested change plus original
// width minus the minimal size that is always added
newLength += w.Width;
newLength -= w.MinimalSize.Width;
}
int barSpace = 0;
// Create temporary array of working values
Position[] positions = new Position[Controls.Count - 1];
// Pass 1, allocate all the space needed for each ResizeBar and the
// minimal amount of space that each Window requests.
AllocateMandatorySizes(ref positions, ref barSpace, ref space);
// What is the new percentage it needs?
Decimal newPercent = 0m;
// Is there any room to allow a percentage calculation
if ((newLength > 0) && (space > 0))
newPercent = (Decimal)newLength / (Decimal)space * 100;
// What is the change in area
Decimal reallocate = newPercent - w.ZoneArea;
// Find the Window after this one
Window nextWindow = _windows[_windows.IndexOf(w) + 1];
if ((nextWindow.ZoneArea - reallocate) < 0m)
reallocate = nextWindow.ZoneArea;
// Modify the Window in question
w.ZoneArea += reallocate;
// Reverse modify the Window afterwards
nextWindow.ZoneArea -= reallocate;
// Update the visual appearance
RepositionControls();
}
public override void PerformRestore(Window w)
{
// We are only ever called for a WindowContent object
WindowContent wc = w as WindowContent;
int bestIndex = -1;
foreach(String s in _previous)
{
if (wc.Contents.Contains(s))
{
int previousIndex = wc.Contents.IndexOf(wc.Contents[s]);
if (previousIndex > bestIndex)
bestIndex = previousIndex;
}
}
// Did we find a previous Content?
if (bestIndex >= 0)
{
// Great, insert after it
wc.Contents.Insert(bestIndex + 1, _content);
}
else
{
bestIndex = wc.Contents.Count;
foreach(String s in _next)
{
if (wc.Contents.Contains(s))
{
int nextIndex = wc.Contents.IndexOf(wc.Contents[s]);
if (nextIndex < bestIndex)
bestIndex = nextIndex;
}
}
// Insert before the found entry (or at end if non found)
wc.Contents.Insert(bestIndex, _content);
}
// Should this content become selected?
if (_selected)
_content.BringToFront();
}
public override void RemovedFromParent(Window parent)
{
if (parent != null)
{
if (this.Dock != DockStyle.None)
{
Size minSize = parent.MinimalSize;
if (this.Dock == DockStyle.Left)
{
// Remove our width from the minimum size of the parent
minSize.Width -= _fixedLength;
}
else
{
// Remove our height from the minimum size of the parent
minSize.Height -= _fixedLength;
}
parent.MinimalSize = minSize;
}
}
}
