private void GenerateTabbedHotAreas(ArrayList controlList, bool suppress)
{
// Check each control in turn
foreach (Control c in controlList)
{
ZoneSequence zs = c as ZoneSequence;
// Look for zone sequences
if (zs != null)
{
// Find index within the list of child controls
int controlIndex = Container.Controls.IndexOf(c);
// Only interested in controls associated with docking
if (controlIndex < _outerIndex)
{
// Process all children, looking for tabbed content
foreach (Control zc in zs.Controls)
{
WindowContentTabbed wct = zc as WindowContentTabbed;
// Only interested in providing indicators for the WCT
if (wct != null)
{
// Not allowed to redock a content back to itself
bool disallowTabbed = (WindowContent != null) && (WindowContent == wct);
// Generate new hot area for the tabbed content window
_hotAreas.Add(new HotAreaTabbed(Squares, this, _dockingManager, zs, wct, disallowTabbed, suppress));
}
}
}
}
}
}
/// <summary>
/// Initializes a new instance of the HotZoneTabbed class.
/// </summary>
/// <param name="hotArea">Screen area that is hot.</param>
/// <param name="newSize">New size of hot zone.</param>
/// <param name="wct">Tabbed content instance.</param>
/// <param name="itself">Being moved within itself.</param>
public HotZoneTabbed(Rectangle hotArea, Rectangle newSize, WindowContentTabbed wct, bool itself)
: base(hotArea, newSize)
{
// Remember state
_wct = wct;
_itself = itself;
// Instead of a single rectangle for the dragging indicator we want to provide
// two rectangles. One for the main area and another to show a tab extending
// below it. This ensures the user can tell that it will be added as a new tab
// page of the control.
int tabHeight = _tabPageHeight;
// Make sure the tab rectangle does not extend past end of control
if (newSize.Height < (tabHeight + DragWidth))
{
tabHeight = newSize.Height - DragWidth * 3;
}
// Create the tab page extension
_tabRect = new Rectangle(newSize.X + _tabPageLeft,
newSize.Bottom - tabHeight - DragWidth,
_tabPageWidth,
tabHeight + DragWidth);
// Make sure tab rectangle does not draw off right side of control
if (_tabRect.Right > newSize.Right)
{
_tabRect.Width -= _tabRect.Right - newSize.Right;
}
// We want the intersection between the top left and top right corners to be displayed
_tabRectTL = new Rectangle(_tabRect.X, _tabRect.Y, DragWidth, DragWidth);
_tabRectTR = new Rectangle(_tabRect.Right - DragWidth, _tabRect.Y, DragWidth, DragWidth);
// Reduce the main area by the height of the above item
NewSize = new Rectangle(newSize.Left, newSize.Top, newSize.Width, newSize.Height - tabHeight);
}
/// <summary>
/// Initializes a new instance of the TabStub class.
/// </summary>
/// <param name="style">Visual style for drawing.</param>
/// <param name="stubsShowAll">Initial stubs value.</param>
private TabStub(VisualStyle style, bool stubsShowAll)
{
// Default state
_wct = null;
_style = style;
_hoverOver = -1;
_hoverItem = -1;
_selectedIndex = -1;
_defaultFont = true;
_defaultColor = true;
_stubsShowAll = stubsShowAll;
_edge = Edge.None;
_drawTabs = new ArrayList();
_tabPages = new TabPageCollection();
_colorDetails = new ColorDetails();
_colorDetails.Style = _style;
base.Font = new Font(SystemInformation.MenuFont, FontStyle.Regular);
// Hookup to collection events
_tabPages.Cleared += new CollectionClear(OnClearedPages);
_tabPages.Inserted += new CollectionChange(OnInsertedPage);
_tabPages.Removing += new CollectionChange(OnRemovingPage);
_tabPages.Removed += new CollectionChange(OnRemovedPage);
// Need notification when the MenuFont is changed
Microsoft.Win32.SystemEvents.UserPreferenceChanged += new
UserPreferenceChangedEventHandler(OnPreferenceChanged);
// Default default colors
DefineBackColor(SystemColors.Control);
// Create the Timer for handling hovering over items
_hoverTimer = new Timer();
_hoverTimer.Interval = _hoverInterval;
_hoverTimer.Tick += new EventHandler(OnTimerExpire);
}
/// <summary>
/// Initialize a new instance of the HotAreaTabbed class.
/// </summary>
/// <param name="squares">Squares or diamonds.</param>
/// <param name="redocker">Reference to the redocker.</param>
/// <param name="manager">Reference to docking manager.</param>
/// <param name="zs">Sequence containing the tabbed content.</param>
/// <param name="wct">Tabbed content instance.</param>
/// <param name="disallowTabbed">Allow to drop in tabbed area.</param>
/// <param name="suppress">Suppress indicators if match found.</param>
public HotAreaTabbed(bool squares,
RedockerContent redocker,
DockingManager manager,
ZoneSequence zs,
WindowContentTabbed wct,
bool disallowTabbed,
bool suppress)
: base(manager)
{
// Remember initial values
_wct = wct;
_zs = zs;
_squares = squares;
_suppress = suppress;
_disallowTabbed = disallowTabbed;
// Not currently inside the hot area
_hotInside = false;
_disallowInsert = false;
// Calculate the tabbed rectangle in screen coordinates
_tabbedRect = wct.RectangleToScreen(wct.ClientRectangle);
// Check for situations that need extra attention...
//
// (1) Do not allow a WindowContent from a ZoneSequence to be redocked into the
// same ZoneSequence. As removing it will cause the Zone to be destroyed and
// so it cannot be added back again. Is not logical anyway.
//
// (2) If the source is in this ZoneSequence we might need to adjust the insertion
// index because the item being removed will reduce the count for when the insert
// takes place.
bool indexAdjustTest = false;
WindowContent redockWC = redocker.WindowContent;
if (_zs.Windows.Count == 1)
{
if (redocker.WindowContent != null)
{
if (redocker.WindowContent == _zs.Windows[0])
{
if ((redocker.Content == null) || (redocker.WindowContent.Contents.Count == 1))
{
_disallowInsert = true;
}
}
}
}
else
{
if (_zs.Windows.Contains(redockWC))
{
if ((redocker.Content == null) || (redocker.WindowContent.Contents.Count == 1))
{
indexAdjustTest = true;
}
}
}
// Create the left/top and right/bottom hot zones
if (!_disallowInsert)
{
Rectangle zoneRectLT = zs.RectangleToScreen(zs.ClientRectangle);
Rectangle tabbedRect = zs.Windows[0].RectangleToScreen(zs.Windows[0].ClientRectangle);
// Adjust the rectangle to give rough idea of new size
if (zs.Direction == LayoutDirection.Vertical)
{
zoneRectLT.X = tabbedRect.X;
zoneRectLT.Width = tabbedRect.Width;
zoneRectLT.Height = zoneRectLT.Height / (zs.Windows.Count + 1);
}
else
{
zoneRectLT.Y = tabbedRect.Y;
zoneRectLT.Height = tabbedRect.Height;
zoneRectLT.Width = zoneRectLT.Width / (zs.Windows.Count + 1);
}
// Store the rectangle for use with the RB as well
Rectangle zoneRectRB = zoneRectLT;
// Find our current index as starting point for insertion
int indexLT = zs.Windows.IndexOf(wct);
// The RB is inserted after the current position
int indexRB = indexLT + 1;
// If inserting after the first window
if (indexLT > 0)
{
// Move the indicator position to overlap the previous position
if (zs.Direction == LayoutDirection.Vertical)
{
zoneRectLT.Y += zs.Windows[indexLT].Top - (zoneRectLT.Height / 2);
}
else
{
zoneRectLT.X += zs.Windows[indexLT].Left - (zoneRectLT.Width / 2);
}
}
// Do we need to check if the removed WC is before the insert point?
if (indexAdjustTest)
{
// If the source window content is before the target then the
// index needs decreasing to ensure its removal is accounted for
if (zs.Windows.IndexOf(redocker.WindowContent) < indexLT)
{
indexLT--;
}
}
// Create the actual hot zone
_hotLT = new HotZoneSequence(zoneRectLT, zoneRectLT, zs, indexLT);
// If inserting before the last window
if (indexRB < zs.Windows.Count)
{
// Move the indicator position to overlap the next position
if (zs.Direction == LayoutDirection.Vertical)
{
zoneRectRB.Y += zs.Windows[indexRB - 1].Bottom - (zoneRectRB.Height / 2);
}
else
{
zoneRectRB.X += zs.Windows[indexRB - 1].Right - (zoneRectRB.Width / 2);
}
}
else
{
// Move the indicator position to the end of our position
if (zs.Direction == LayoutDirection.Vertical)
{
zoneRectRB.Y += zs.Windows[indexRB - 1].Bottom - zoneRectRB.Height;
}
else
{
zoneRectRB.X += zs.Windows[indexRB - 1].Right - zoneRectRB.Width;
}
}
// Do we need to check if the removed WC is before the insert point?
if (indexAdjustTest)
{
// If the source window content is before the target then the
// index needs decreasing to ensure its removal is accounted for
if (zs.Windows.IndexOf(redocker.WindowContent) < indexRB)
{
indexRB--;
}
}
// Create the actual hot zone
_hotRB = new HotZoneSequence(zoneRectRB, zoneRectRB, zs, indexRB);
}
// Create the insert into middle hot zone
if (!_disallowTabbed)
{
_hotMiddle = new HotZoneTabbed(_tabbedRect, _tabbedRect, wct, false);
}
}
