protected void InternalConstruct(TabbedGroups tabbedGroups, TabGroupBase parent)
{
// Assign initial values
_tabbedGroups = tabbedGroups;
_parent = parent;
_unique = _count++;
// Defaults
_tag = null;
_space = 100m;
_minSize = new Size(_tabbedGroups.DefaultGroupMinimumWidth,
_tabbedGroups.DefaultGroupMinimumHeight);
}
public TabGroupLeaf(TabbedGroups tabbedGroups, TabGroupBase parent)
: base(tabbedGroups, parent)
{
// Create our managed tab control instance
_tabControl = new Controls.TabControl();
// We need page drag to begin when mouse dragged a small distance
_tabControl.DragFromControl = false;
// We need to monitor attempts to drag into the tab control
_dragEntered = false;
_tabControl.AllowDrop = true;
_tabControl.DragDrop += new DragEventHandler(OnControlDragDrop);
_tabControl.DragEnter += new DragEventHandler(OnControlDragEnter);
_tabControl.DragLeave += new EventHandler(OnControlDragLeave);
// Need notification when page drag begins
_tabControl.PageDragStart += new MouseEventHandler(OnPageDragStart);
_tabControl.PageDragMove += new MouseEventHandler(OnPageDragMove);
_tabControl.PageDragEnd += new MouseEventHandler(OnPageDragEnd);
_tabControl.PageDragQuit += new MouseEventHandler(OnPageDragQuit);
// Hook into tab page collection events
_tabControl.TabPages.Cleared += new CollectionClear(OnTabPagesCleared);
_tabControl.TabPages.Inserted += new CollectionChange(OnTabPagesInserted);
_tabControl.TabPages.Removed += new CollectionChange(OnTabPagesRemoved);
// Hook into page level events
_tabControl.GotFocus += new EventHandler(OnGainedFocus);
_tabControl.PageGotFocus += new EventHandler(OnGainedFocus);
_tabControl.ClosePressed += new EventHandler(OnClose);
// Manager only created at start of drag operation
_targetManager = null;
// DefinePopupMenuForControl(_tabControl);
// Setup the correct 'HideTabsMode' for the control
Notify(TabGroupBase.NotifyCode.DisplayTabMode);
// Define the default setup of TabControl and allow developer to customize
_tabbedGroups.OnTabControlCreated(_tabControl);
}
public TargetManager(TabbedGroups host, TabGroupLeaf leaf, Controls.TabControl source)
{
// Define state
_host = host;
_leaf = leaf;
_source = source;
_lastTarget = null;
// Create collection to hold generated targets
_targets = new TargetCollection();
// Process each potential leaf in turn
TabGroupLeaf tgl = host.FirstLeaf();
while(tgl != null)
{
// Create all possible targets for this leaf
CreateTargets(tgl);
// Enumerate all leafs
tgl = host.NextLeaf(tgl);
}
}
public TabGroupBase(TabbedGroups tabbedGroups, TabGroupBase parent)
{
InternalConstruct(tabbedGroups, parent);
}
protected void CompactRemoveEmptyTabLeafs(TabbedGroups.CompactFlags flags)
{
// Should we check for empty leaf nodes?
if ((flags & Controls.TabbedGroups.CompactFlags.RemoveEmptyTabLeaf) != 0)
{
int count = _children.Count;
for(int index=0; index<count; index++)
{
// Only interested in leaf entries
if (_children[index].IsLeaf)
{
TabGroupLeaf tgl = (TabGroupLeaf)_children[index];
// Is this an empty leaf node?
if (tgl.Count == 0)
{
// Update active leaf setting
if (_tabbedGroups.ActiveLeaf == tgl)
{
TabGroupLeaf newLeaf = _tabbedGroups.NextLeaf(tgl);
if (newLeaf == null)
newLeaf = _tabbedGroups.PreviousLeaf(tgl);
_tabbedGroups.ActiveLeaf = newLeaf;
}
// Need to remove the redundant entry
RemoveAt(index);
// Reduce number of entries left to check
count--;
// Move backwards so the next increment stays on same index
index--;
// Mark layout as dirty
if (_tabbedGroups.AutoCalculateDirty)
_tabbedGroups.Dirty = true;
}
}
}
}
}
public TabGroupBase(TabbedGroups tabbedGroups)
{
InternalConstruct(tabbedGroups, null);
}
protected void CompactReduceSameDirection(TabbedGroups.CompactFlags flags)
{
bool changed = false;
// Should we check for same direction sub-sequences?
if ((flags & Controls.TabbedGroups.CompactFlags.ReduceSameDirection) != 0)
{
int count = _children.Count;
for(int index=0; index<count; index++)
{
// Only interested in sequence entries
if (_children[index].IsSequence)
{
TabGroupSequence tgs = (TabGroupSequence)_children[index];
// Does it run in same direction as ourself?
if (_direction == tgs.Direction)
{
// Remember how much space the base entry occupies
Decimal temp = tgs.RealSpace;
// Find the child control to be replaced
int childPos = _control.Controls.IndexOf(tgs.GroupControl);
// Need to remove a resize bar before the control?
if (childPos > 0)
ControlHelper.RemoveAt(_control.Controls, childPos);
// Remove the actual control
ControlHelper.RemoveAt(_control.Controls, childPos);
// Remove the intermediate group
_children.RemoveAt(index);
// Reflect change in size
count--;
Decimal totalAllocated = 0m;
// Add in each sub group in turn
int subCount = tgs.Count;
bool firstInsert = true;
for(int subIndex=0; subIndex<subCount; subIndex++)
{
TabGroupBase tgb = tgs[subIndex];
// What percentage of original space did it have?
Decimal orig = tgb.RealSpace;
// Give it the same proportion of new space
Decimal update = Decimal.Round(temp / 100 * orig, SPACE_PRECISION);
// Keep total actually allocated
totalAllocated += update;
// Use new proportion
tgb.RealSpace = update;
// Update parentage
tgb.SetParent(this);
// Does new child control need a resizing bar?
if ((childPos > 0) && !firstInsert)
{
// Create a resizing bar
ResizeBar bar = new ResizeBar(_direction, this);
_control.Controls.Add(bar);
_control.Controls.SetChildIndex(bar, childPos++);
}
// Add new child control in its place
_control.Controls.Add(tgb.GroupControl);
_control.Controls.SetChildIndex(tgb.GroupControl, childPos++);
// Insert at current position
_children.Insert(index, tgb);
// Adjust variables to reflect increased size
index++;
count++;
firstInsert = false;
}
// Assign any remainder to last group
_children[index-1].RealSpace += temp - totalAllocated;
// Need controls repositioned
changed = true;
// Mark layout as dirty
if (_tabbedGroups.AutoCalculateDirty)
_tabbedGroups.Dirty = true;
}
}
}
}
// Change in contents requires entries to be repositioned
if (changed)
RepositionChildren();
}
protected void CompactReduceSingleEntries(TabbedGroups.CompactFlags flags)
{
bool changed = false;
// Should we check for single instance nodes?
if ((flags & Controls.TabbedGroups.CompactFlags.ReduceSingleEntries) != 0)
{
int count = _children.Count;
for(int index=0; index<count; index++)
{
// Only interested in sequence entries
if (_children[index].IsSequence)
{
TabGroupSequence tgs = (TabGroupSequence)_children[index];
// Does this entry only have a single child
if (tgs.Count == 1)
{
// Remember how much space the base entry occupies
Decimal temp = tgs.RealSpace;
// Get reference to only child
TabGroupBase child = tgs[0];
// Update parentage
child.SetParent(this);
// Find the child control to be replaced
int childPos = _control.Controls.IndexOf(tgs.GroupControl);
// Remove it
ControlHelper.RemoveAt(_control.Controls, childPos);
// Add new child control in its place
_control.Controls.Add(child.GroupControl);
_control.Controls.SetChildIndex(child.GroupControl, childPos);
// Replace the middle object with the child
_children.RemoveAt(index);
_children.Insert(index, child);
// Restore its correct spacing
child.RealSpace = temp;
// Need controls repositioned
changed = true;
// Mark layout as dirty
if (_tabbedGroups.AutoCalculateDirty)
_tabbedGroups.Dirty = true;
}
}
}
}
// Change in contents requires entries to be repositioned
if (changed)
RepositionChildren();
}
public TabGroupSequence(TabbedGroups tabbedGroups, TabGroupBase parent, Direction direction)
: base(tabbedGroups, parent)
{
InternalConstruct(null, direction);
}
public TabGroupSequence(TabbedGroups tabbedGroups, TabGroupBase parent)
: base(tabbedGroups, parent)
{
InternalConstruct(null, Direction.Horizontal);
}
public TabGroupSequence(TabbedGroups tabbedGroups)
: base(tabbedGroups)
{
// Root instance always defaults to being horizontal
InternalConstruct(tabbedGroups, Direction.Horizontal);
}
public void Compact(TabbedGroups.CompactFlags flags)
{
// Compact each child sequence
foreach(TabGroupBase tgb in _children)
if (tgb.IsSequence)
(tgb as TabGroupSequence).Compact(flags);
// Remove dangling entries
CompactRemoveEmptyTabLeafs(flags);
CompactRemoveEmptyTabSequences(flags);
// Integrate single entries
CompactReduceSingleEntries(flags);
// Integrate sub-sequences which run in same direction
CompactReduceSameDirection(flags);
}
protected void CompactRemoveEmptyTabSequences(TabbedGroups.CompactFlags flags)
{
// Should we check for empty sequence nodes?
if ((flags & Controls.TabbedGroups.CompactFlags.RemoveEmptyTabSequence) != 0)
{
int count = _children.Count;
for(int index=0; index<count; index++)
{
// Only interested in sequence entries
if (_children[index].IsSequence)
{
TabGroupSequence tgs = (TabGroupSequence)_children[index];
// Is this an empty sequence node?
if (tgs.Count == 0)
{
// Need to remove the redundant entry
RemoveAt(index);
// Reduce number of entries left to check
count--;
// Move backwards so the next increment stays on same index
index--;
// Mark layout as dirty
if (_tabbedGroups.AutoCalculateDirty)
_tabbedGroups.Dirty = true;
}
}
}
}
}