public bool CanResize(ResizeBar bar)
        {
            // Cannot resize when in prominent mode
            if (!_tabbedGroups.ResizeBarLock && (_tabbedGroups.ProminentLeaf == null))
            {
                // Find position of this ResizeBar in the Controls collection
                int barIndex = _control.Controls.IndexOf(bar);

                // Convert from control to children indexing
                int beforeIndex = (barIndex - 1) / 2;

                TabGroupBase before = _children[beforeIndex];
                TabGroupBase after  = _children[beforeIndex + 1];

                // If groups on both sides have no space then cannot resize there relative positions
                if (((before.Space <= 0m) && (after.Space <= 0m)))
                {
                    return(false);
                }
                else
                {
                    return(true);
                }
            }
            else
            {
                // Must exit prominent mode before resize can occur
                return(false);
            }
        }
        protected void AllocateMandatorySizes(ref int[] positions, ref int barSpace, ref int space)
        {
            // Process each control
            for (int index = 0, child = 0; index < _control.Controls.Count; index++)
            {
                ResizeBar bar = _control.Controls[index] as ResizeBar;

                // Is this a resize bar control?
                if (bar != null)
                {
                    // Length needed is dependant on direction
                    positions[index] = bar.Length;

                    // Add up how much space was allocated to ResizeBars
                    barSpace += positions[index];
                }
                else
                {
                    Size minimal = _children[child++].MinimumSize;

                    // Length needed is depends on direction
                    if (_direction == Direction.Vertical)
                    {
                        positions[index] = minimal.Height;
                    }
                    else
                    {
                        positions[index] = minimal.Width;
                    }
                }

                // Reduce available space by that just allocated
                space -= positions[index];
            }
        }
        protected TabGroupBase Insert(int index, TabGroupBase group)
        {
            // Range check index
            if (index < 0)
            {
                throw new ArgumentOutOfRangeException("index", index, "Insert index must be at least 0");
            }

            if (index >= _children.Count)
            {
                throw new ArgumentOutOfRangeException("index", index, "Cannot insert after end of current entries");
            }

            // Remember reference
            _children.Insert(index, group);

            // Create a resizing bar
            ResizeBar bar = new ResizeBar(_direction, this);

            // Append resize bar between existing entries and new entry
            _control.Controls.Add(bar);

            // Append new group control
            _control.Controls.Add(group.GroupControl);

            // Inserting at start of collection?
            if (index == 0)
            {
                // Reposition the bar and group to start of collection
                _control.Controls.SetChildIndex(bar, 0);
                _control.Controls.SetChildIndex(group.GroupControl, 0);
            }
            else
            {
                // Find correct index taking into account number of resize bars
                int pos = index * 2 - 1;

                // Reposition the bar and Window to correct relative ordering
                _control.Controls.SetChildIndex(bar, pos++);
                _control.Controls.SetChildIndex(group.GroupControl, pos);
            }

            // Allocate space for the new child
            AllocateSpace(group);

            // Update child layout to reflect new proportional spacing values
            RepositionChildren();

            // Mark layout as dirty
            if (_tabbedGroups.AutoCalculateDirty)
            {
                _tabbedGroups.Dirty = true;
            }

            return(group);
        }
        public void EndResizeOperation(ResizeBar bar, int delta)
        {
            // Find position of this ResizeBar in the Controls collection
            int barIndex = _control.Controls.IndexOf(bar);

            // Convert from control to children indexing
            int beforeIndex = (barIndex - 1) / 2;

            // The Window relating to this bar must be the one before it in the collection
            TabGroupBase before = _children[beforeIndex];

            // Is the Window being expanded
            DeltaGroupSpace(before, delta);
        }
        protected TabGroupBase Add(TabGroupBase group)
        {
            // Remember reference
            _children.Add(group);

            // First group added to sequence?
            if (_children.Count == 1)
            {
                // Add new child control
                _control.Controls.Add(group.GroupControl);
            }
            else
            {
                // Create a resizing bar
                ResizeBar bar = new ResizeBar(_direction, this);

                // Append resize bar between existing entries and new entry
                _control.Controls.Add(bar);

                // Append new group control
                _control.Controls.Add(group.GroupControl);
            }

            if (!_tabbedGroups.Initializing)
            {
                // Allocate space for the new child
                AllocateSpace(group);

                // Update child layout to reflect new proportional spacing values
                RepositionChildren();
            }

            // Mark layout as dirty
            if (_tabbedGroups.AutoCalculateDirty)
            {
                _tabbedGroups.Dirty = true;
            }

            return(group);
        }
        public bool StartResizeOperation(ResizeBar bar, ref Rectangle screenBoundary)
        {
            // Find position of this ResizeBar in the Controls collection
            int barIndex = _control.Controls.IndexOf(bar);

            // Convert from control to children indexing
            int beforeIndex = (barIndex - 1) / 2;

            // Get groups before and after the resize bar
            TabGroupBase before = _children[beforeIndex];
            TabGroupBase after  = _children[beforeIndex + 1];

            // Resizing boundary is defaulted to whole control area
            screenBoundary = _control.RectangleToScreen(_control.ClientRectangle);

            // Find screen rectangle for the groups either side of the bar
            Rectangle rectBefore = before.GroupControl.RectangleToScreen(before.GroupControl.ClientRectangle);
            Rectangle rectAfter  = after.GroupControl.RectangleToScreen(after.GroupControl.ClientRectangle);

            // Reduce the boundary in the appropriate direction
            if (_direction == Direction.Vertical)
            {
                screenBoundary.Y       = rectBefore.Y + before.MinimumSize.Height;
                screenBoundary.Height -= screenBoundary.Bottom - rectAfter.Bottom;
                screenBoundary.Height -= after.MinimumSize.Height;
            }
            else
            {
                screenBoundary.X      = rectBefore.X + before.MinimumSize.Width;
                screenBoundary.Width -= screenBoundary.Right - rectAfter.Right;
                screenBoundary.Width -= after.MinimumSize.Width;
            }

            // Allow resize operation to occur
            return(true);
        }
        internal void Replace(TabGroupBase orig, TabGroupBase replace)
        {
            // Find array position of old item
            int origPos = _children.IndexOf(orig);

            // Transfer across the space occupied
            replace.RealSpace = orig.RealSpace;

            // Is this the only Window entry?
            if (_children.Count == 1)
            {
                // Remove Window from appearance

                // Use helper method to circumvent form Close bug
                ControlHelper.RemoveAt(_control.Controls, 0);
            }
            else
            {
                int pos = 0;

                // Calculate position of Window to remove
                if (origPos != 0)
                {
                    pos = origPos * 2 - 1;
                }

                // Remove Window and bar

                // Use helper method to circumvent form Close bug
                ControlHelper.RemoveAt(_control.Controls, pos);
                ControlHelper.RemoveAt(_control.Controls, pos);
            }

            // Inserting at start of collection?
            if (origPos == 0)
            {
                if (_children.Count > 1)
                {
                    // Create a resizing bar
                    ResizeBar bar = new ResizeBar(_direction, this);

                    // Append resize bar between existing entries and new entry
                    _control.Controls.Add(bar);

                    // Reposition the bar and group to start of collection
                    _control.Controls.SetChildIndex(bar, 0);
                }

                // Append new group control
                _control.Controls.Add(replace.GroupControl);

                // Reposition the bar and group to start of collection
                _control.Controls.SetChildIndex(replace.GroupControl, 0);
            }
            else
            {
                // Create a resizing bar
                ResizeBar bar = new ResizeBar(_direction, this);

                // Append resize bar between existing entries and new entry
                _control.Controls.Add(bar);

                // Append new group control
                _control.Controls.Add(replace.GroupControl);

                // Find correct index taking into account number of resize bars
                int pos = origPos * 2 - 1;

                // Reposition the bar and Window to correct relative ordering
                _control.Controls.SetChildIndex(bar, pos++);
                _control.Controls.SetChildIndex(replace.GroupControl, pos);
            }

            // Update parentage
            replace.SetParent(this);

            // Replace the entry
            _children[origPos] = replace;

            // Update child layout to reflect new proportional spacing values
            RepositionChildren();

            // Mark layout as dirty
            if (_tabbedGroups.AutoCalculateDirty)
            {
                _tabbedGroups.Dirty = true;
            }
        }
        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 RepositionChildren(ref int[] positions, Rectangle clientRect, int delta)
        {
            // Process each control
            for (int index = 0; index < _control.Controls.Count; index++)
            {
                // Delta length for this particular control
                int newDelta = positions[index];

                ResizeBar bar = _control.Controls[index] as ResizeBar;

                if (bar != null)
                {
                    if (_direction == Direction.Vertical)
                    {
                        // Set new position
                        bar.Location = new Point(clientRect.X, delta);
                        bar.Width    = clientRect.Width;
                        bar.Height   = newDelta;

                        // Move delta down to next position
                        delta += newDelta;
                    }
                    else
                    {
                        // Set new position
                        bar.Location = new Point(delta, clientRect.Y);
                        bar.Height   = clientRect.Height;
                        bar.Width    = newDelta;

                        // Move delta across to next position
                        delta += newDelta;
                    }
                }
                else
                {
                    Control c = _control.Controls[index];

                    if (c != null)
                    {
                        if (newDelta == 0)
                        {
                            c.Hide();
                        }
                        else
                        {
                            // Set new position/size based on direction
                            if (_direction == Direction.Vertical)
                            {
                                c.Location = new Point(clientRect.X, delta);
                                c.Width    = clientRect.Width;
                                c.Height   = newDelta;
                            }
                            else
                            {
                                c.Location = new Point(delta, clientRect.Y);
                                c.Height   = clientRect.Height;
                                c.Width    = newDelta;
                            }

                            if (!c.Visible)
                            {
                                c.Show();
                            }

                            // Move delta to next position
                            delta += newDelta;
                        }
                    }
                }
            }
        }