protected void OnPageDragStart(object sender, MouseEventArgs e)
{
if (this.RedockAllowed)
{
// There must be a selected page for this event to occur
IDE.Controls.TabPage page = _tabControl.SelectedTab;
// Event page must specify its Content object
Content c = page.Tag as Content;
// Remember the position of the tab before it is removed
_dragPageIndex = _tabControl.TabPages.IndexOf(page);
// Remove page from TabControl
_tabControl.TabPages.Remove(page);
// Force the entire window to redraw to ensure the Redocker does not start drawing
// the XOR indicator before the window repaints itself. Otherwise the repainted
// control will interfere with the XOR indicator.
this.Refresh();
// Start redocking activity for the single Content of this WindowContent
_redocker = new RedockerContent(_tabControl, c, this, new Point(e.X, e.Y));
}
}
public bool PreFilterMessage(ref Message m)
{
// Has a key been pressed?
if (m.Msg == (int)Win32.Msgs.WM_KEYDOWN)
{
// Is it the ESCAPE key?
if ((int)m.WParam == (int)Win32.VirtualKeys.VK_ESCAPE)
{
// Are we in redocking mode?
if (_redocker != null)
{
// Cancel the redocking activity
_redocker.QuitTrackingMode(null);
// Put back the page that was removed when dragging started
RestoreDraggingPage();
// No longer need the object
_redocker = null;
return(true);
}
}
}
return(false);
}
protected override void OnMouseDown(MouseEventArgs e)
{
// The double click event will cause the control to be destroyed as
// the Contents are restored to their alternative positions, so need to
// double check the control is not already dead
if (!IsDisposed)
{
// Left mouse down begins a redocking action
if (e.Button == MouseButtons.Left)
{
if (this.ParentWindow.RedockAllowed)
{
WindowContent wc = this.ParentWindow as WindowContent;
// Is our parent a WindowContent instance?
if (wc != null)
{
// Start redocking activity for the whole WindowContent
_redocker = new RedockerContent(this, wc, new Point(e.X, e.Y));
}
}
}
this.Focus();
}
base.OnMouseDown(e);
}
protected override void OnMouseUp(MouseEventArgs e)
{
// The double click event will cause the control to be destroyed as
// the Contents are restored to their alternative positions, so need to
// double check the control is not already dead
if (!IsDisposed)
{
// Are we currently in a redocking state?
if (_redocker != null)
{
// Let the redocker finish off
_redocker.OnMouseUp(e);
// No longer need the object
_redocker = null;
}
// Right mouse button can generate a Context event
if (e.Button == MouseButtons.Right)
{
// Get screen coordinates of the mouse
Point pt = this.PointToScreen(new Point(e.X, e.Y));
// Box to transfer as parameter
OnContext(pt);
}
}
base.OnMouseUp(e);
}
public HotZoneFloating(Rectangle hotArea, Rectangle newSize, Point offset, RedockerContent redocker)
: base(hotArea, newSize)
{
// Store initial state
_offset = offset;
_redocker = redocker;
Size floatSize = CalculateFloatingSize();
float widthPercentage = (float)floatSize.Width / (float)_newSize.Width;
float heightPercentage = (float)floatSize.Height / (float)_newSize.Height;
_newSize.Width = floatSize.Width;
_newSize.Height = floatSize.Height + SystemInformation.ToolWindowCaptionHeight;
_offset.X = (int)((float)_offset.X * widthPercentage);
_offset.Y = (int)((float)_offset.Y * heightPercentage);
// We do not want the indicator to be too far away from the cursor, so limit check the offset
if (_offset.X > newSize.Width)
{
_offset.X = newSize.Width;
}
if (_offset.Y > newSize.Height)
{
_offset.Y = newSize.Height;
}
}
public WindowDetailCaption(DockingManager manager,
Size fixedSize,
EventHandler closeHandler,
EventHandler restoreHandler,
EventHandler invertAutoHideHandler,
ContextHandler contextHandler)
: base(manager)
{
// Setup correct color remapping depending on initial colors
DefineButtonRemapping();
// Default state
_maxButton = null;
_hideButton = null;
_maxInterface = null;
_redocker = null;
_showCloseButton = true;
_showHideButton = true;
_ignoreHideButton = false;
_pinnedImage = false;
// Prevent flicker with double buffering and all painting inside WM_PAINT
SetStyle(ControlStyles.DoubleBuffer, true);
SetStyle(ControlStyles.AllPaintingInWmPaint, true);
// Our size is always fixed at the required length in both directions
// as one of the sizes will be provided for us because of our docking
this.Size = fixedSize;
if (closeHandler != null)
{
this.Close += closeHandler;
}
if (restoreHandler != null)
{
this.Restore += restoreHandler;
}
if (invertAutoHideHandler != null)
{
this.InvertAutoHide += invertAutoHideHandler;
}
if (contextHandler != null)
{
this.Context += contextHandler;
}
// Let derived classes override the button creation
CreateButtons();
// Need to hook into message pump so that the ESCAPE key can be
// intercepted when in redocking mode
Application.AddMessageFilter(this);
}
public FloatingForm(DockingManager dockingManager, Zone zone, ContextHandler contextHandler)
{
// The caller is responsible for setting our initial screen location
this.StartPosition = FormStartPosition.Manual;
// Not in task bar to prevent clutter
this.ShowInTaskbar = false;
// Make sure the main Form owns us
this.Owner = dockingManager.Container.FindForm();
// Need to know when the Zone is removed
this.ControlRemoved += new ControlEventHandler(OnZoneRemoved);
// Add the Zone as the only content of the Form
Controls.Add(zone);
// Default state
_redocker = null;
_intercept = false;
_zone = zone;
_dockingManager = dockingManager;
// Assign any event handler for context menu
if (contextHandler != null)
{
this.Context += contextHandler;
}
// Default color
this.BackColor = _dockingManager.BackColor;
this.ForeColor = _dockingManager.InactiveTextColor;
// Monitor changes in the Zone content
_zone.Windows.Inserted += new CollectionChange(OnWindowInserted);
_zone.Windows.Removing += new CollectionChange(OnWindowRemoving);
_zone.Windows.Removed += new CollectionChange(OnWindowRemoved);
if (_zone.Windows.Count == 1)
{
// The first Window to be added. Tell it to hide details
_zone.Windows[0].HideDetails();
// Monitor change in window title
_zone.Windows[0].FullTitleChanged += new EventHandler(OnFullTitleChanged);
// Grab any existing title
this.Text = _zone.Windows[0].FullTitle;
}
// Need to hook into message pump so that the ESCAPE key can be
// intercepted when in redocking mode
Application.AddMessageFilter(this);
}
protected void OnPageDragQuit(object sender, MouseEventArgs e)
{
// Are we currently in a redocking state?
if (_redocker != null)
{
// Put back the page that was removed when dragging started
RestoreDraggingPage();
// No longer need the object
_redocker = null;
}
}
protected Size CalculateFloatingSize()
{
Size floatingSize = new Size(0, 0);
// Get specific redocker type
RedockerContent redock = _redocker as RedockerContent;
switch (redock.DockingSource)
{
case RedockerContent.Source.RawContent:
// Whole Form is size requested by single Content
floatingSize = redock.Content.FloatingSize;
break;
case RedockerContent.Source.WindowContent:
// Find the largest requested floating size
foreach (Content c in redock.WindowContent.Contents)
{
if (c.FloatingSize.Width > floatingSize.Width)
{
floatingSize.Width = c.FloatingSize.Width;
}
if (c.FloatingSize.Height > floatingSize.Height)
{
floatingSize.Height = c.FloatingSize.Height;
}
}
// Apply same size to all Content objects
foreach (Content c in redock.WindowContent.Contents)
{
c.FloatingSize = floatingSize;
}
break;
case RedockerContent.Source.ContentInsideWindow:
// Whole Form is size requested by single Content
floatingSize = redock.Content.FloatingSize;
break;
case RedockerContent.Source.FloatingForm:
// Use the requested size
floatingSize.Width = _newSize.Width;
floatingSize.Height = _newSize.Height;
break;
}
return(floatingSize);
}
public void AddHotZones(Redocker redock, HotZoneCollection collection)
{
RedockerContent redocker = redock as RedockerContent;
// Allow the contained Zone a chance to expose HotZones
foreach (Control c in this.Controls)
{
IHotZoneSource ag = c as IHotZoneSource;
// Does this control expose an interface for its own HotZones?
if (ag != null)
{
ag.AddHotZones(redock, collection);
}
}
}
protected override void OnDoubleClick(EventArgs e)
{
// The double click event will cause the control to be destroyed as
// the Contents are restored to their alternative positions, so need to
// double check the control is not already dead
if (!IsDisposed)
{
// Are we currently in a redocking state?
if (_redocker != null)
{
// No longer need the object
_redocker = null;
}
}
// Fire attached event handlers
OnRestore();
}
public void AddHotZones(Redocker redock, HotZoneCollection collection)
{
RedockerContent redocker = redock as RedockerContent;
bool itself = false;
bool nullZone = false;
// We process differently for WindowContent to redock into itself!
if ((redocker.WindowContent != null) && (redocker.WindowContent == this))
{
itself = true;
}
// We do not allow a Content to redock into its existing container
if (itself && !_contents.Contains(redocker.Content))
{
nullZone = true;
}
Rectangle newSize = this.RectangleToScreen(this.ClientRectangle);
Rectangle hotArea = _tabControl.RectangleToScreen(_tabControl.ClientRectangle);;
// Find any caption detail and use that area as the hot area
foreach (WindowDetail wd in _windowDetails)
{
WindowDetailCaption wdc = wd as WindowDetailCaption;
if (wdc != null)
{
hotArea = wdc.RectangleToScreen(wdc.ClientRectangle);
hotArea.Inflate(_hotAreaInflate, _hotAreaInflate);
break;
}
}
if (nullZone)
{
collection.Add(new HotZoneNull(hotArea));
}
else
{
collection.Add(new HotZoneTabbed(hotArea, newSize, this, itself));
}
}
protected void OnPageDragEnd(object sender, MouseEventArgs e)
{
// Are we currently in a redocking state?
if (_redocker != null)
{
// Let the redocker finish off
bool moved = _redocker.OnMouseUp(e);
// If the tab was not positioned somewhere else
if (!moved)
{
// Put back the page that was removed when dragging started
RestoreDraggingPage();
}
// No longer need the object
_redocker = null;
}
}
public WindowContentTabbed(DockingManager manager, VisualStyle vs)
: base(manager, vs)
{
_redocker = null;
_activeContent = null;
// Create the TabControl used for viewing the Content windows
_tabControl = new IDE.Controls.TabControl();
// It should always occupy the remaining space after all details
_tabControl.Dock = DockStyle.Fill;
// Show tabs only if two or more tab pages exist
_tabControl.HideTabsMode = IDE.Controls.TabControl.HideTabsModes.HideUsingLogic;
// Hook into the TabControl notifications
_tabControl.GotFocus += new EventHandler(OnTabControlGotFocus);
_tabControl.LostFocus += new EventHandler(OnTabControlLostFocus);
_tabControl.PageGotFocus += new EventHandler(OnTabControlGotFocus);
_tabControl.PageLostFocus += new EventHandler(OnTabControlLostFocus);
_tabControl.SelectionChanged += new EventHandler(OnSelectionChanged);
_tabControl.PageDragStart += new MouseEventHandler(OnPageDragStart);
_tabControl.PageDragMove += new MouseEventHandler(OnPageDragMove);
_tabControl.PageDragEnd += new MouseEventHandler(OnPageDragEnd);
_tabControl.PageDragQuit += new MouseEventHandler(OnPageDragQuit);
_tabControl.DoubleClickTab += new IDE.Controls.TabControl.DoubleClickTabHandler(OnDoubleClickTab);
_tabControl.Font = manager.TabControlFont;
_tabControl.BackColor = manager.BackColor;
_tabControl.ForeColor = manager.InactiveTextColor;
// Define the visual style required
_tabControl.Style = vs;
// Allow developers a chance to override default settings
manager.OnTabControlCreated(_tabControl);
switch (vs)
{
case VisualStyle.IDE:
Controls.Add(_tabControl);
break;
case VisualStyle.Plain:
// Only the border at the pages edge and not around the whole control
_tabControl.InsetBorderPagesOnly = !_manager.PlainTabBorder;
// We want a border around the TabControl so it is indented and looks consistent
// with the Plain look and feel, so use the helper Control 'BorderForControl'
BorderForControl bfc = new BorderForControl(_tabControl, _plainBorder);
// It should always occupy the remaining space after all details
bfc.Dock = DockStyle.Fill;
// Define the default border border
bfc.BackColor = _manager.BackColor;
// When in 'VisualStyle.Plain' we need to
Controls.Add(bfc);
break;
}
// Need to hook into message pump so that the ESCAPE key can be
// intercepted when in redocking mode
Application.AddMessageFilter(this);
}
public override bool ApplyChange(Point screenPos, Redocker parent)
{
// Should always be the appropriate type
RedockerContent redock = parent as RedockerContent;
DockingManager dockingManager = redock.DockingManager;
Zone newZone = null;
// Manageing Zones should remove display AutoHide windows
dockingManager.RemoveShowingAutoHideWindows();
switch (redock.DockingSource)
{
case RedockerContent.Source.RawContent:
{
// Perform State specific Restore actions
redock.Content.ContentBecomesFloating();
// Create a new Window to host Content
Window w = dockingManager.CreateWindowForContent(redock.Content);
// We need to create a Zone for containing the transfered content
newZone = dockingManager.CreateZoneForContent(State.Floating);
// Add into Zone
newZone.Windows.Add(w);
}
break;
case RedockerContent.Source.WindowContent:
// Perform State specific Restore actions
foreach (Content c in redock.WindowContent.Contents)
{
c.ContentBecomesFloating();
}
// Remove WindowContent from old Zone
if (redock.WindowContent.ParentZone != null)
{
redock.WindowContent.ParentZone.Windows.Remove(redock.WindowContent);
}
// We need to create a Zone for containing the transfered content
newZone = dockingManager.CreateZoneForContent(State.Floating);
// Add into new Zone
newZone.Windows.Add(redock.WindowContent);
break;
case RedockerContent.Source.ContentInsideWindow:
{
// Perform State specific Restore actions
redock.Content.ContentBecomesFloating();
// Remove Content from existing WindowContent
if (redock.Content.ParentWindowContent != null)
{
redock.Content.ParentWindowContent.Contents.Remove(redock.Content);
}
// Create a new Window to host Content
Window w = dockingManager.CreateWindowForContent(redock.Content);
// We need to create a Zone for containing the transfered content
newZone = dockingManager.CreateZoneForContent(State.Floating);
// Add into Zone
newZone.Windows.Add(w);
}
break;
case RedockerContent.Source.FloatingForm:
redock.FloatingForm.Location = new Point(screenPos.X - _offset.X,
screenPos.Y - _offset.Y);
return(false);
}
dockingManager.UpdateInsideFill();
// Create a new floating form
FloatingForm floating = new FloatingForm(redock.DockingManager, newZone,
new ContextHandler(dockingManager.OnShowContextMenu));
// Find screen location/size
_drawRect = new Rectangle(screenPos.X, screenPos.Y, _newSize.Width, _newSize.Height);
// Adjust for mouse starting position relative to source control
_drawRect.X -= _offset.X;
_drawRect.Y -= _offset.Y;
// Define its location/size
floating.Location = new Point(_drawRect.Left, _drawRect.Top);
floating.Size = new Size(_drawRect.Width, _drawRect.Height);
// Show it!
floating.Show();
return(true);
}
public override bool ApplyChange(Point screenPos, Redocker parent)
{
// We are only called from the RedockerContent class
RedockerContent redock = parent as RedockerContent;
DockingManager dockingManager = redock.DockingManager;
// Reduce flicker during transition
dockingManager.Container.SuspendLayout();
// Need to create a new Zone
Zone zone;
if (redock.DockingSource == RedockerContent.Source.FloatingForm)
{
// Make every Content object in the Floating Zone
// record its current state as the Floating state
redock.FloatingForm.ExitFloating();
zone = redock.FloatingForm.Zone;
}
else
{
zone = dockingManager.CreateZoneForContent(_state);
}
// Insert Zone at end of Controls collection
dockingManager.Container.Controls.Add(zone);
// Adjust ordering
switch (_position)
{
case Position.Inner:
dockingManager.ReorderZoneToInnerMost(zone);
break;
case Position.Index:
// Manageing Zones should remove display AutoHide windows
dockingManager.RemoveShowingAutoHideWindows();
// Place new Zone AFTER the one given, so need to increase index by one
dockingManager.Container.Controls.SetChildIndex(zone, _newIndex + 1);
break;
case Position.Outer:
dockingManager.ReorderZoneToOuterMost(zone);
break;
}
switch (redock.DockingSource)
{
case RedockerContent.Source.RawContent:
{
// Create a new Window to host Content
Window w = dockingManager.CreateWindowForContent(redock.Content);
// Add into Zone
zone.Windows.Add(w);
}
break;
case RedockerContent.Source.WindowContent:
// Remove WindowContent from old Zone
if (redock.WindowContent.ParentZone != null)
{
// If the source is leaving the Floating state then need to record Restore positions
if (redock.WindowContent.State == State.Floating)
{
foreach (Content c in redock.WindowContent.Contents)
{
c.ContentLeavesFloating();
}
}
redock.WindowContent.ParentZone.Windows.Remove(redock.WindowContent);
}
// Add into new Zone
zone.Windows.Add(redock.WindowContent);
break;
case RedockerContent.Source.ContentInsideWindow:
{
// Remove Content from existing WindowContent
if (redock.Content.ParentWindowContent != null)
{
// If the source is leaving the Floating state then need to record Restore position
if (redock.Content.ParentWindowContent.State == State.Floating)
{
redock.Content.ContentLeavesFloating();
}
redock.Content.ParentWindowContent.Contents.Remove(redock.Content);
}
// Create a new WindowContent to host Content
Window w = dockingManager.CreateWindowForContent(redock.Content);
// Add into Zone
zone.Windows.Add(w);
}
break;
case RedockerContent.Source.FloatingForm:
DockStyle ds;
Direction direction;
dockingManager.ValuesFromState(_state, out ds, out direction);
// Define correct docking style to match state
zone.Dock = ds;
ZoneSequence zs = zone as ZoneSequence;
// Define correct display direction to match state
if (zs != null)
{
zs.Direction = direction;
}
// Ensure the Zone recalculates contents according to new state
zone.State = _state;
break;
}
// Define correct size of the new Zone
switch (_state)
{
case State.DockLeft:
case State.DockRight:
zone.Width = _newSize.Width;
break;
case State.DockTop:
case State.DockBottom:
zone.Height = _newSize.Height;
break;
}
dockingManager.UpdateInsideFill();
// Reduce flicker during transition
dockingManager.Container.ResumeLayout();
return(true);
}
protected override void WndProc(ref Message m)
{
// Want to notice when the window is maximized
if (m.Msg == (int)Win32.Msgs.WM_NCLBUTTONDBLCLK)
{
// Redock and kill ourself
Restore();
// We do not want to let the base process the message as the
// restore might fail due to lack of permission to restore to
// old state. In that case we do not want to maximize the window
return;
}
else if (m.Msg == (int)Win32.Msgs.WM_NCLBUTTONDOWN)
{
if (!_intercept)
{
// Perform a hit test against our own window to determine
// which area the mouse press is over at the moment.
uint result = User32.SendMessage(this.Handle, (int)Win32.Msgs.WM_NCHITTEST, 0, (uint)m.LParam);
// Only want to override the behviour of moving the window via the caption box
if (result == HITTEST_CAPTION)
{
// Remember new state
_intercept = true;
// Capture the mouse until the mouse us is received
this.Capture = true;
// Ensure that we gain focus and look active
this.Activate();
// Get mouse position to inscreen coordinates
Win32.POINT mousePos;
mousePos.x = (short)((uint)m.LParam & 0x0000FFFFU);
mousePos.y = (short)(uint)(((uint)m.LParam & 0xFFFF0000U) >> 16);
// Find adjustment to bring screen to client coordinates
Point topLeft = PointToScreen(new Point(0, 0));
topLeft.Y -= SystemInformation.CaptionHeight;
topLeft.X -= SystemInformation.BorderSize.Width;
// Begin a redocking activity
_redocker = new RedockerContent(this, new Point(mousePos.x - topLeft.X,
mousePos.y - topLeft.Y));
return;
}
}
}
else if (m.Msg == (int)Win32.Msgs.WM_MOUSEMOVE)
{
if (_intercept)
{
Win32.POINT mousePos;
mousePos.x = (short)((uint)m.LParam & 0x0000FFFFU);
mousePos.y = (short)(uint)(((uint)m.LParam & 0xFFFF0000U) >> 16);
_redocker.OnMouseMove(new MouseEventArgs(MouseButtons.Left,
0,
mousePos.x,
mousePos.y,
0));
return;
}
}
else if (m.Msg == (int)Win32.Msgs.WM_LBUTTONUP)
{
if (_intercept)
{
Win32.POINT mousePos;
mousePos.x = (short)((uint)m.LParam & 0x0000FFFFU);
mousePos.y = (short)(uint)(((uint)m.LParam & 0xFFFF0000U) >> 16);
_redocker.OnMouseUp(new MouseEventArgs(MouseButtons.Left, 0,
mousePos.x, mousePos.y, 0));
// Release capture
this.Capture = false;
// Reset state
_intercept = false;
return;
}
}
else if ((m.Msg == (int)Win32.Msgs.WM_NCRBUTTONUP) ||
(m.Msg == (int)Win32.Msgs.WM_NCMBUTTONDOWN) ||
(m.Msg == (int)Win32.Msgs.WM_NCMBUTTONUP) ||
(m.Msg == (int)Win32.Msgs.WM_RBUTTONDOWN) ||
(m.Msg == (int)Win32.Msgs.WM_RBUTTONUP) ||
(m.Msg == (int)Win32.Msgs.WM_MBUTTONDOWN) ||
(m.Msg == (int)Win32.Msgs.WM_MBUTTONUP))
{
// Prevent middle and right mouse buttons from interrupting
// the correct operation of left mouse dragging
return;
}
else if (m.Msg == (int)Win32.Msgs.WM_NCRBUTTONDOWN)
{
if (!_intercept)
{
// Get screen coordinates of the mouse
Win32.POINT mousePos;
mousePos.x = (short)((uint)m.LParam & 0x0000FFFFU);
mousePos.y = (short)(uint)(((uint)m.LParam & 0xFFFF0000U) >> 16);
// Box to transfer as parameter
OnContext(new Point(mousePos.x, mousePos.y));
return;
}
}
base.WndProc(ref m);
}
public override bool ApplyChange(Point screenPos, Redocker parent)
{
// We are only called from the RedockerContent class
RedockerContent redock = parent as RedockerContent;
DockingManager dockingManager = redock.DockingManager;
bool becomeFloating = (_zs.State == State.Floating);
// Reduce flicker during transition
dockingManager.Container.SuspendLayout();
// Manageing Zones should remove display AutoHide windows
dockingManager.RemoveShowingAutoHideWindows();
switch (redock.DockingSource)
{
case RedockerContent.Source.RawContent:
{
// Perform State specific Restore actions
if (becomeFloating)
{
redock.Content.ContentBecomesFloating();
}
// Create a new Window to host Content
Window w = dockingManager.CreateWindowForContent(redock.Content);
// Add into Zone
_zs.Windows.Insert(_index, w);
}
break;
case RedockerContent.Source.WindowContent:
{
// Is the destination Zone in the Floating state?
if (becomeFloating)
{
foreach (Content c in redock.WindowContent.Contents)
{
c.ContentBecomesFloating();
}
}
else
{
if (redock.WindowContent.State == State.Floating)
{
foreach (Content c in redock.WindowContent.Contents)
{
c.ContentLeavesFloating();
}
}
}
// Check if the WindowContent source is in same Zone
if (redock.WindowContent.ParentZone == _zs)
{
// Find current position of source WindowContent
int currPos = _zs.Windows.IndexOf(redock.WindowContent);
// If current window is before the new position then the current
// window will disappear before the new one is inserted,so need to
// adjust down the new insertion point
if (currPos < _index)
{
_index--;
}
}
// Create a new Window to host Content
WindowContent wc = dockingManager.CreateWindowForContent(null) as WindowContent;
// Transfer content across
int count = redock.WindowContent.Contents.Count;
for (int index = 0; index < count; index++)
{
Content c = redock.WindowContent.Contents[0];
// Remove from existing location
redock.WindowContent.Contents.RemoveAt(0);
// Add into new WindowContent host
wc.Contents.Add(c);
}
// Add into host into Zone
_zs.Windows.Insert(_index, wc);
}
break;
case RedockerContent.Source.ContentInsideWindow:
{
// Perform State specific Restore actions
if (becomeFloating)
{
redock.Content.ContentBecomesFloating();
}
else
{
if (redock.Content.ParentWindowContent.State == State.Floating)
{
redock.Content.ContentLeavesFloating();
}
}
// Remove Content from existing WindowContent
if (redock.Content.ParentWindowContent != null)
{
// Will removing the Content cause the WindowContent to die?
if (redock.Content.ParentWindowContent.Contents.Count == 1)
{
// Check if the WindowContent source is in same Zone
if (redock.Content.ParentWindowContent.ParentZone == _zs)
{
// Find current position of source WindowContent
int currPos = _zs.Windows.IndexOf(redock.Content.ParentWindowContent);
// If current window is before the new position then the current
// window will disappear before the new one is inserted,so need to
// adjust down the new insertion point
if (currPos < _index)
{
_index--;
}
}
}
redock.Content.ParentWindowContent.Contents.Remove(redock.Content);
}
// Create a new Window to host Content
Window w = dockingManager.CreateWindowForContent(redock.Content);
// Add into Zone
_zs.Windows.Insert(_index, w);
}
break;
case RedockerContent.Source.FloatingForm:
{
// Perform State specific Restore actions
if (!becomeFloating)
{
// Make every Content object in the Floating Zone
// record its current state as the Floating state
redock.FloatingForm.ExitFloating();
}
int count = redock.FloatingForm.Zone.Windows.Count;
for (int index = count - 1; index >= 0; index--)
{
// Remember the Window reference
Window w = redock.FloatingForm.Zone.Windows[index];
// Remove from floating collection
redock.FloatingForm.Zone.Windows.RemoveAt(index);
// Add into new ZoneSequence destination
_zs.Windows.Insert(_index, w);
}
}
break;
}
dockingManager.UpdateInsideFill();
// Reduce flicker during transition
dockingManager.Container.ResumeLayout();
return(true);
}
public override bool ApplyChange(Point screenPos, Redocker parent)
{
// If docking back to itself then refuse to apply the change, this will cause the
// WindowContentTabbed object to put back the content which is the desired effect
if (_itself)
{
return(false);
}
// We are only called from the RedockerContent class
RedockerContent redock = parent as RedockerContent;
DockingManager dockingManager = redock.DockingManager;
bool becomeFloating = (_wct.ParentZone.State == State.Floating);
// Reduce flicker during transition
dockingManager.Container.SuspendLayout();
// Manageing Zones should remove display AutoHide windows
dockingManager.RemoveShowingAutoHideWindows();
switch (redock.DockingSource)
{
case RedockerContent.Source.RawContent:
{
// Perform State specific Restore actions
if (becomeFloating)
{
redock.Content.ContentBecomesFloating();
}
_wct.Contents.Add(redock.Content);
}
break;
case RedockerContent.Source.WindowContent:
{
// Perform State specific Restore actions
if (becomeFloating)
{
foreach (Content c in redock.WindowContent.Contents)
{
c.ContentBecomesFloating();
}
}
else
{
// If the source is leaving the Floating state then need to record Restore positions
if (redock.WindowContent.State == State.Floating)
{
foreach (Content c in redock.WindowContent.Contents)
{
c.ContentLeavesFloating();
}
}
}
int count = redock.WindowContent.Contents.Count;
for (int index = 0; index < count; index++)
{
Content c = redock.WindowContent.Contents[0];
// Remove Content from previous WindowContent
redock.WindowContent.Contents.RemoveAt(0);
// Add into new WindowContent
_wct.Contents.Add(c);
}
}
break;
case RedockerContent.Source.ContentInsideWindow:
{
// Perform State specific Restore actions
if (becomeFloating)
{
redock.Content.ContentBecomesFloating();
}
else
{
// If the source is leaving the Floating state then need to record Restore position
if (redock.Content.ParentWindowContent.State == State.Floating)
{
redock.Content.ContentLeavesFloating();
}
}
// Remove Content from existing WindowContent
if (redock.Content.ParentWindowContent != null)
{
redock.Content.ParentWindowContent.Contents.Remove(redock.Content);
}
_wct.Contents.Add(redock.Content);
}
break;
case RedockerContent.Source.FloatingForm:
{
// Perform State specific Restore actions
if (!becomeFloating)
{
// Make every Content object in the Floating Zone
// record its current state as the Floating state
redock.FloatingForm.ExitFloating();
}
int wCount = redock.FloatingForm.Zone.Windows.Count;
for (int wIndex = 0; wIndex < wCount; wIndex++)
{
WindowContent wc = redock.FloatingForm.Zone.Windows[0] as WindowContent;
if (wc != null)
{
int cCount = wc.Contents.Count;
for (int cIndex = 0; cIndex < cCount; cIndex++)
{
// Get reference to first content in collection
Content c = wc.Contents[0];
// Remove from old WindowContent
wc.Contents.RemoveAt(0);
// Add into new WindowContentTabbed
_wct.Contents.Add(c);
}
}
}
}
break;
}
dockingManager.UpdateInsideFill();
// Reduce flicker during transition
dockingManager.Container.ResumeLayout();
return(true);
}