IDEPixelBorder = false;
                    break;
                case VisualAppearance.MultiDocument:
                default:
                    IDEPixelBorder = true;
                    break;
            }
        }

        [Category("Appearance")]
        [DefaultValue(true)]
        public virtual bool IDEPixelArea
        {
            get { return _idePixelArea; }
			
            set 
            {
                if (_idePixelArea != value)
                {
                    _idePixelArea = value;

                    Recalculate();
                    Invalidate();
                }
            }
        }

        public void ResetIDEPixelArea()
        {
            IDEPixelArea = true;
        }

        [Category("Appearance")]
        [DefaultValue(false)]
        public virtual bool SelectedTextOnly
        {
            get { return _selectedTextOnly; }
			
            set 
            {
                if (_selectedTextOnly != value)
                {
                    _selectedTextOnly = value;

                    _recalculate = true;
                    Invalidate();
                }
            }
        }

        public void ResetSelectedTextOnly()
        {
            SelectedTextOnly = false;
        }

        [Category("Behavour")]
        [DefaultValue(200)]
        public int MouseLeaveTimeout
        {
            get { return _leaveTimeout; }
            
            set 
            { 
                if (_leaveTimeout != value)
                {
                    _leaveTimeout = value;
                    _overTimer.Interval = value;
                }
            }
        }

        public void ResetMouseLeaveTimeout()
        {
            _leaveTimeout = 200;
        }

        [Category("Behavour")]
        [DefaultValue(true)]
        public bool DragFromControl
        {
            get { return _dragFromControl; }
            set { _dragFromControl = value ; }
        }
        
        public void ResetDragFromControl()
        {
            DragFromControl = true;
        }
        
        [Category("Appearance")]
        [DefaultValue(false)]
        public virtual HideTabsModes HideTabsMode
        {
            get { return _hideTabsMode; }
			
            set 
            {
                if (_hideTabsMode != value)
                {
                    _hideTabsMode = value;

                    Recalculate();
                    Invalidate();
                }
            }
        }

        protected bool ShouldSerializeHideTabsMode()
        {
            return HideTabsMode != HideTabsModes.ShowAlways;
        }

        public void ResetHideTabsMode()
        {
            HideTabsMode = HideTabsModes.ShowAlways;
        }

        [Category("Appearance")]
        [DefaultValue(false)]
        public virtual bool HoverSelect
        {
            get { return _hoverSelect; }
			
            set 
            {
                if (_hoverSelect != value)
                {
                    _hoverSelect = value;

                    _recalculate = true;
                    Invalidate();
                }
            }
        }

        public void ResetHoverSelect()
        {
            HoverSelect = false;
        }

        [Category("Behavour")]
        [DefaultValue(true)]
        public virtual bool RecordFocus
        {
            get { return _recordFocus; }
			
            set 
            {
                if (_recordFocus != value)
                    _recordFocus = value;
            }
        }

        public void ResetRecordFocus()
        {
            RecordFocus = true;
        }

        [Browsable(false)]
        [DefaultValue(-1)]
        public virtual int SelectedIndex
        {
            get { return _pageSelected; }

            set
            {
                if ((value >= 0) && (value < _tabPages.Count))
                {
                    if (_pageSelected != value)
                    {
                        // Raise selection changing event
                        OnSelectionChanging(EventArgs.Empty);

                        // Any page currently selected?
                        if (_pageSelected != -1)
                            DeselectPage(_tabPages[_pageSelected]);

                        _pageSelected = value;

                        if (_pageSelected != -1)
                        {
                            SelectPage(_tabPages[_pageSelected]);

                            // If newly selected page is scrolled off the left hand side
                            if (_pageSelected < _startPage)
                                _startPage = _pageSelected;  // then bring it into view
                        }

                        // Change in selection causes tab pages sizes to change
                        if (_boldSelected)
                        {
                            Recalculate();
                            Invalidate();
                        }

                        // Raise selection change event
                        OnSelectionChanged(EventArgs.Empty);

                        Invalidate();
                    }
                }
            }
        }

        [Browsable(false)]
        [DefaultValue(null)]
        public virtual TabPage SelectedTab
        {
            get 
            {
                // If nothing is selected we return null
                if (_pageSelected == -1)
                    return null;
                else
                    return _tabPages[_pageSelected];
            }

            set
            {
                // Cannot change selection to be none of the tabs
                if (value != null)
                {
                    // Get the requested page from the collection
                    int index = _tabPages.IndexOf(value);

                    // If a valid known page then using existing property to perform switch
                    if (index != -1)
                        this.SelectedIndex = index;
                }
            }
        }

        public virtual void MakePageVisible(TabPage page)
        {
            MakePageVisible(_tabPages.IndexOf(page));
        }

        public virtual void MakePageVisible(int index)
        {
            // Only relevant if we do not shrink all pages to fit and not in multiline
            if (!_shrinkPagesToFit && !_multiline)
            {
                // Range check the request page
                if ((index >= 0) && (index < _tabPages.Count))
                {
                    // Is requested page before those shown?
                    if (index < _startPage)
                    {
                        // Define it as the new start page
                        _startPage = index;

                        _recalculate = true;
                        Invalidate();
                    }
                    else
                    {
                        // Find the last visible position
                        int xMax = GetMaximumDrawPos();

                        Rectangle rect = (Rectangle)_tabRects[index];

                        // Is the page drawn off over the maximum position?
                        if (rect.Right >= xMax)
                        {
                            // Need to find the new start page to bring this one into view
                            int newStart = index;

                            // Space left over for other tabs to be drawn inside
                            int spaceLeft = xMax - rect.Width - _tabsAreaRect.Left - _tabsAreaStartInset;

                            do
                            {
                                // Is there a previous tab to check?
                                if (newStart == 0)
                                    break;

                                Rectangle rectStart = (Rectangle)_tabRects[newStart - 1];
		
                                // Is there enough space to draw it?
                                if (rectStart.Width > spaceLeft)
                                    break;

                                // Move to new tab and reduce available space left
                                newStart--;
                                spaceLeft -= rectStart.Width;

                            } while(true);

                            // Define the new starting page
                            _startPage = newStart;

                            _recalculate = true;
                            Invalidate();
                        }
                    }
                }
            }
        }

        protected override bool ProcessMnemonic(char key)
        {
            int total = _tabPages.Count;
            int index = this.SelectedIndex + 1;
            
            for(int count=0; count<total; count++, index++)
            {
                // Range check the index
                if (index >= total)
                    index = 0;

                TabPage page = _tabPages[index];
        
                // Find position of first mnemonic character
                int position = page.Title.IndexOf('&');

                // Did we find a mnemonic indicator?
                if (IsMnemonic(key, page.Title))
                {
                    // Select this page
                    this.SelectedTab = page;
                
                    return true;
                }
            }
                        
            return false;
        }

        protected override void OnResize(EventArgs e)
        {
            Recalculate();
            Invalidate();
            
            base.OnResize(e);
        }

        protected override void OnSizeChanged(EventArgs e)
        {
            Recalculate();
            Invalidate();

            base.OnSizeChanged(e);
        }

        public virtual void OnPopupMenuDisplay(CancelEventArgs e)
        {
            // Has anyone registered for the event?
            if (PopupMenuDisplay != null)
                PopupMenuDisplay(this, e);
        }

        public virtual void OnSelectionChanging(EventArgs e)
        {
            // Has anyone registered for the event?
            if (SelectionChanging != null)
                SelectionChanging(this, e);
        }

        public virtual void OnSelectionChanged(EventArgs e)
        {
            // Has anyone registered for the event?
            if (SelectionChanged != null)
                SelectionChanged(this, e);
        }

        public virtual void OnClosePressed(EventArgs e)
        {
            // Has anyone registered for the event?
            if (ClosePressed != null)
                ClosePressed(this, e);
        }

        public virtual void OnPageGotFocus(EventArgs e)
        {
            // Has anyone registered for the event?
            if (PageGotFocus != null)
                PageGotFocus(this, e);
        }
		
        public virtual void OnPageLostFocus(EventArgs e)
        {
            // Has anyone registered for the event?
            if (PageLostFocus != null)
                PageLostFocus(this, e);
        }

        public virtual void OnPageDragStart(MouseEventArgs e)
        {
            // Has anyone registered for the event?
            if (PageDragStart != null)