WinFormsUI/Docking/VS2005AutoHideStrip.cs

using System;
using System.Drawing;
using System.Windows.Forms;
using System.Drawing.Drawing2D;
using System.ComponentModel;

namespace WeifenLuo.WinFormsUI.Docking
{
    internal class VS2005AutoHideStrip : AutoHideStripBase
    {
        private class TabVS2005 : Tab
        {
            internal TabVS2005(IDockContent content)
                : base(content)
            {
            }

            private int m_tabX = 0;
            public int TabX
            {
                get { return m_tabX; }
                set { m_tabX = value; }
            }

            private int m_tabWidth = 0;
            public int TabWidth
            {
                get { return m_tabWidth; }
                set { m_tabWidth = value; }
            }

        }

        private const int _ImageHeight = 16;
        private const int _ImageWidth = 16;
        private const int _ImageGapTop = 2;
        private const int _ImageGapLeft = 4;
        private const int _ImageGapRight = 2;
        private const int _ImageGapBottom = 2;
        private const int _TextGapLeft = 0;
        private const int _TextGapRight = 0;
        private const int _TabGapTop = 3;
        private const int _TabGapLeft = 4;
        private const int _TabGapBetween = 10;

        #region Customizable Properties
        public Font TextFont
        {
            get { return DockPanel.Skin.AutoHideStripSkin.TextFont; }
        }

        private static StringFormat _stringFormatTabHorizontal;
        private StringFormat StringFormatTabHorizontal
        {
            get
            {
                if (_stringFormatTabHorizontal == null)
                {
                    _stringFormatTabHorizontal = new StringFormat();
                    _stringFormatTabHorizontal.Alignment = StringAlignment.Near;
                    _stringFormatTabHorizontal.LineAlignment = StringAlignment.Center;
                    _stringFormatTabHorizontal.FormatFlags = StringFormatFlags.NoWrap;
                    _stringFormatTabHorizontal.Trimming = StringTrimming.None;
                }

                if (RightToLeft == RightToLeft.Yes)
                    _stringFormatTabHorizontal.FormatFlags |= StringFormatFlags.DirectionRightToLeft;
                else
                    _stringFormatTabHorizontal.FormatFlags &= ~StringFormatFlags.DirectionRightToLeft;

                return _stringFormatTabHorizontal;
            }
        }

        private static StringFormat _stringFormatTabVertical;
        private StringFormat StringFormatTabVertical
        {
            get
            {
                if (_stringFormatTabVertical == null)
                {
                    _stringFormatTabVertical = new StringFormat();
                    _stringFormatTabVertical.Alignment = StringAlignment.Near;
                    _stringFormatTabVertical.LineAlignment = StringAlignment.Center;
                    _stringFormatTabVertical.FormatFlags = StringFormatFlags.NoWrap | StringFormatFlags.DirectionVertical;
                    _stringFormatTabVertical.Trimming = StringTrimming.None;
                }
                if (RightToLeft == RightToLeft.Yes)
                    _stringFormatTabVertical.FormatFlags |= StringFormatFlags.DirectionRightToLeft;
                else
                    _stringFormatTabVertical.FormatFlags &= ~StringFormatFlags.DirectionRightToLeft;

                return _stringFormatTabVertical;
            }
        }

        private static int ImageHeight
        {
            get { return _ImageHeight; }
        }

        private static int ImageWidth
        {
            get { return _ImageWidth; }
        }

        private static int ImageGapTop
        {
            get { return _ImageGapTop; }
        }

        private static int ImageGapLeft
        {
            get { return _ImageGapLeft; }
        }

        private static int ImageGapRight
        {
            get { return _ImageGapRight; }
        }

        private static int ImageGapBottom
        {
            get { return _ImageGapBottom; }
        }

        private static int TextGapLeft
        {
            get { return _TextGapLeft; }
        }

        private static int TextGapRight
        {
            get { return _TextGapRight; }
        }

        private static int TabGapTop
        {
            get { return _TabGapTop; }
        }

        private static int TabGapLeft
        {
            get { return _TabGapLeft; }
        }

        private static int TabGapBetween
        {
            get { return _TabGapBetween; }
        }

        private static Pen PenTabBorder
        {
            get { return SystemPens.GrayText; }
        }
        #endregion

        private static Matrix _matrixIdentity = new Matrix();
        private static Matrix MatrixIdentity
        {
            get { return _matrixIdentity; }
        }

        private static DockState[] _dockStates;
        private static DockState[] DockStates
        {
            get
            {
                if (_dockStates == null)
                {
                    _dockStates = new DockState[4];
                    _dockStates[0] = DockState.DockLeftAutoHide;
                    _dockStates[1] = DockState.DockRightAutoHide;
                    _dockStates[2] = DockState.DockTopAutoHide;
                    _dockStates[3] = DockState.DockBottomAutoHide;
                }
                return _dockStates;
            }
        }

        private static GraphicsPath _graphicsPath;
        internal static GraphicsPath GraphicsPath
        {
            get
            {
                if (_graphicsPath == null)
                    _graphicsPath = new GraphicsPath();

                return _graphicsPath;
            }
        }

        public VS2005AutoHideStrip(DockPanel panel)
            : base(panel)
        {
            SetStyle(ControlStyles.ResizeRedraw |
                ControlStyles.UserPaint |
                ControlStyles.AllPaintingInWmPaint |
                ControlStyles.OptimizedDoubleBuffer, true);
            BackColor = SystemColors.ControlLight;
        }

        protected override void OnPaint(PaintEventArgs e)
        {
            Graphics g = e.Graphics;

            Color startColor = DockPanel.Skin.AutoHideStripSkin.DockStripGradient.StartColor;
            Color endColor = DockPanel.Skin.AutoHideStripSkin.DockStripGradient.EndColor;
            LinearGradientMode gradientMode = DockPanel.Skin.AutoHideStripSkin.DockStripGradient.LinearGradientMode;
            using (LinearGradientBrush brush = new LinearGradientBrush(ClientRectangle, startColor, endColor, gradientMode))
            {
                g.FillRectangle(brush, ClientRectangle);
            }

            DrawTabStrip(g);
        }

        protected override void OnLayout(LayoutEventArgs levent)
        {
            CalculateTabs();
            base.OnLayout(levent);
        }

        private void DrawTabStrip(Graphics g)
        {
            DrawTabStrip(g, DockState.DockTopAutoHide);
            DrawTabStrip(g, DockState.DockBottomAutoHide);
            DrawTabStrip(g, DockState.DockLeftAutoHide);
            DrawTabStrip(g, DockState.DockRightAutoHide);
        }

        private void DrawTabStrip(Graphics g, DockState dockState)
        {
            Rectangle rectTabStrip = GetLogicalTabStripRectangle(dockState);

            if (rectTabStrip.IsEmpty)
                return;

            Matrix matrixIdentity = g.Transform;
            if (dockState == DockState.DockLeftAutoHide || dockState == DockState.DockRightAutoHide)
            {
                Matrix matrixRotated = new Matrix();
                matrixRotated.RotateAt(90, new PointF((float)rectTabStrip.X + (float)rectTabStrip.Height / 2,
                    (float)rectTabStrip.Y + (float)rectTabStrip.Height / 2));
                g.Transform = matrixRotated;
            }

            foreach (Pane pane in GetPanes(dockState))
            {
                foreach (TabVS2005 tab in pane.AutoHideTabs)
                    DrawTab(g, tab);
            }
            g.Transform = matrixIdentity;
        }

        private void CalculateTabs()
        {
            CalculateTabs(DockState.DockTopAutoHide);
            CalculateTabs(DockState.DockBottomAutoHide);
            CalculateTabs(DockState.DockLeftAutoHide);
            CalculateTabs(DockState.DockRightAutoHide);
        }

        private void CalculateTabs(DockState dockState)
        {
            Rectangle rectTabStrip = GetLogicalTabStripRectangle(dockState);

            int imageHeight = rectTabStrip.Height - ImageGapTop - ImageGapBottom;
            int imageWidth = ImageWidth;
            if (imageHeight > ImageHeight)
                imageWidth = ImageWidth * (imageHeight / ImageHeight);

            int x = TabGapLeft + rectTabStrip.X;
            foreach (Pane pane in GetPanes(dockState))
            {
                foreach (TabVS2005 tab in pane.AutoHideTabs)
                {
                    int width = imageWidth + ImageGapLeft + ImageGapRight +
                        TextRenderer.MeasureText(tab.Content.DockHandler.TabText, TextFont).Width +
                        TextGapLeft + TextGapRight;
                    tab.TabX = x;
                    tab.TabWidth = width;
                    x += width;
                }

                x += TabGapBetween;
            }
        }

        private Rectangle RtlTransform(Rectangle rect, DockState dockState)
        {
            Rectangle rectTransformed;
            if (dockState == DockState.DockLeftAutoHide || dockState == DockState.DockRightAutoHide)
                rectTransformed = rect;
            else
                rectTransformed = DrawHelper.RtlTransform(this, rect);

            return rectTransformed;
        }

        private GraphicsPath GetTabOutline(TabVS2005 tab, bool transformed, bool rtlTransform)
        {
            DockState dockState = tab.Content.DockHandler.DockState;
            Rectangle rectTab = GetTabRectangle(tab, transformed);
            if (rtlTransform)
                rectTab = RtlTransform(rectTab, dockState);
            bool upTab = (dockState == DockState.DockLeftAutoHide || dockState == DockState.DockBottomAutoHide);
            DrawHelper.GetRoundedCornerTab(GraphicsPath, rectTab, upTab);

            return GraphicsPath;
        }

        private void DrawTab(Graphics g, TabVS2005 tab)
        {
            Rectangle rectTabOrigin = GetTabRectangle(tab);
            if (rectTabOrigin.IsEmpty)
                return;

            DockState dockState = tab.Content.DockHandler.DockState;
            IDockContent content = tab.Content;

            GraphicsPath path = GetTabOutline(tab, false, true);

            Color startColor = DockPanel.Skin.AutoHideStripSkin.TabGradient.StartColor;
            Color endColor = DockPanel.Skin.AutoHideStripSkin.TabGradient.EndColor;
            LinearGradientMode gradientMode = DockPanel.Skin.AutoHideStripSkin.TabGradient.LinearGradientMode;
            g.FillPath(new LinearGradientBrush(rectTabOrigin, startColor, endColor, gradientMode), path);
            g.DrawPath(PenTabBorder, path);

            // Set no rotate for drawing icon and text
            Matrix matrixRotate = g.Transform;
            g.Transform = MatrixIdentity;

            // Draw the icon
            Rectangle rectImage = rectTabOrigin;
            rectImage.X += ImageGapLeft;
            rectImage.Y += ImageGapTop;
            int imageHeight = rectTabOrigin.Height - ImageGapTop - ImageGapBottom;
            int imageWidth = ImageWidth;
            if (imageHeight > ImageHeight)
                imageWidth = ImageWidth * (imageHeight / ImageHeight);
            rectImage.Height = imageHeight;
            rectImage.Width = imageWidth;
            rectImage = GetTransformedRectangle(dockState, rectImage);

            if (dockState == DockState.DockLeftAutoHide || dockState == DockState.DockRightAutoHide)
            {
                // The DockState is DockLeftAutoHide or DockRightAutoHide, so rotate the image 90 degrees to the right. 
                Rectangle rectTransform = RtlTransform(rectImage, dockState);
                Point[] rotationPoints =
                { 
                    new Point(rectTransform.X + rectTransform.Width, rectTransform.Y), 
                    new Point(rectTransform.X + rectTransform.Width, rectTransform.Y + rectTransform.Height), 
                    new Point(rectTransform.X, rectTransform.Y)
                };

                using (Icon rotatedIcon = new Icon(((Form)content).Icon, 16, 16))
                {
                    g.DrawImage(rotatedIcon.ToBitmap(), rotationPoints);
                }
            }
            else
            {
                // Draw the icon normally without any rotation.
                g.DrawIcon(((Form)content).Icon, RtlTransform(rectImage, dockState));
            }

            // Draw the text
            Rectangle rectText = rectTabOrigin;
            rectText.X += ImageGapLeft + imageWidth + ImageGapRight + TextGapLeft;
            rectText.Width -= ImageGapLeft + imageWidth + ImageGapRight + TextGapLeft;
            rectText = RtlTransform(GetTransformedRectangle(dockState, rectText), dockState);

            Color textColor = DockPanel.Skin.AutoHideStripSkin.TabGradient.TextColor;

            if (dockState == DockState.DockLeftAutoHide || dockState == DockState.DockRightAutoHide)
                g.DrawString(content.DockHandler.TabText, TextFont, new SolidBrush(textColor), rectText, StringFormatTabVertical);
            else
                g.DrawString(content.DockHandler.TabText, TextFont, new SolidBrush(textColor), rectText, StringFormatTabHorizontal);

            // Set rotate back
            g.Transform = matrixRotate;
        }

        private Rectangle GetLogicalTabStripRectangle(DockState dockState)
        {
            return GetLogicalTabStripRectangle(dockState, false);
        }

        private Rectangle GetLogicalTabStripRectangle(DockState dockState, bool transformed)
        {
            if (!DockHelper.IsDockStateAutoHide(dockState))
                return Rectangle.Empty;

            int leftPanes = GetPanes(DockState.DockLeftAutoHide).Count;
            int rightPanes = GetPanes(DockState.DockRightAutoHide).Count;
            int topPanes = GetPanes(DockState.DockTopAutoHide).Count;
            int bottomPanes = GetPanes(DockState.DockBottomAutoHide).Count;

            int x, y, width, height;

            height = MeasureHeight();
            if (dockState == DockState.DockLeftAutoHide && leftPanes > 0)
            {
                x = 0;
                y = (topPanes == 0) ? 0 : height;
                width = Height - (topPanes == 0 ? 0 : height) - (bottomPanes == 0 ? 0 : height);
            }
            else if (dockState == DockState.DockRightAutoHide && rightPanes > 0)
            {
                x = Width - height;
                if (leftPanes != 0 && x < height)
                    x = height;
                y = (topPanes == 0) ? 0 : height;
                width = Height - (topPanes == 0 ? 0 : height) - (bottomPanes == 0 ? 0 : height);
            }
            else if (dockState == DockState.DockTopAutoHide && topPanes > 0)
            {
                x = leftPanes == 0 ? 0 : height;
                y = 0;
                width = Width - (leftPanes == 0 ? 0 : height) - (rightPanes == 0 ? 0 : height);
            }
            else if (dockState == DockState.DockBottomAutoHide && bottomPanes > 0)
            {
                x = leftPanes == 0 ? 0 : height;
                y = Height - height;
                if (topPanes != 0 && y < height)
                    y = height;
                width = Width - (leftPanes == 0 ? 0 : height) - (rightPanes == 0 ? 0 : height);
            }
            else
                return Rectangle.Empty;

            if (!transformed)
                return new Rectangle(x, y, width, height);
            else
                return GetTransformedRectangle(dockState, new Rectangle(x, y, width, height));
        }

        private Rectangle GetTabRectangle(TabVS2005 tab)
        {
            return GetTabRectangle(tab, false);
        }

        private Rectangle GetTabRectangle(TabVS2005 tab, bool transformed)
        {
            DockState dockState = tab.Content.DockHandler.DockState;
            Rectangle rectTabStrip = GetLogicalTabStripRectangle(dockState);

            if (rectTabStrip.IsEmpty)
                return Rectangle.Empty;

            int x = tab.TabX;
            int y = rectTabStrip.Y +
                (dockState == DockState.DockTopAutoHide || dockState == DockState.DockRightAutoHide ?
                0 : TabGapTop);
            int width = tab.TabWidth;
            int height = rectTabStrip.Height - TabGapTop;

            if (!transformed)
                return new Rectangle(x, y, width, height);
            else
                return GetTransformedRectangle(dockState, new Rectangle(x, y, width, height));
        }

        private Rectangle GetTransformedRectangle(DockState dockState, Rectangle rect)
        {
            if (dockState != DockState.DockLeftAutoHide && dockState != DockState.DockRightAutoHide)
                return rect;

            PointF[] pts = new PointF[1];
            // the center of the rectangle
            pts[0].X = (float)rect.X + (float)rect.Width / 2;
            pts[0].Y = (float)rect.Y + (float)rect.Height / 2;
            Rectangle rectTabStrip = GetLogicalTabStripRectangle(dockState);
            Matrix matrix = new Matrix();
            matrix.RotateAt(90, new PointF((float)rectTabStrip.X + (float)rectTabStrip.Height / 2,
                (float)rectTabStrip.Y + (float)rectTabStrip.Height / 2));
            matrix.TransformPoints(pts);

            return new Rectangle((int)(pts[0].X - (float)rect.Height / 2 + .5F),
                (int)(pts[0].Y - (float)rect.Width / 2 + .5F),
                rect.Height, rect.Width);
        }

        protected override IDockContent HitTest(Point ptMouse)
        {
            foreach (DockState state in DockStates)
            {
                Rectangle rectTabStrip = GetLogicalTabStripRectangle(state, true);
                if (!rectTabStrip.Contains(ptMouse))
                    continue;

                foreach (Pane pane in GetPanes(state))
                {
                    foreach (TabVS2005 tab in pane.AutoHideTabs)
                    {
                        GraphicsPath path = GetTabOutline(tab, true, true);
                        if (path.IsVisible(ptMouse))
                            return tab.Content;
                    }
                }
            }

            return null;
        }

        protected internal override int MeasureHeight()
        {
            return Math.Max(ImageGapBottom +
                ImageGapTop + ImageHeight,
                TextFont.Height) + TabGapTop;
        }

        protected override void OnRefreshChanges()
        {
            CalculateTabs();
            Invalidate();
        }

        protected override AutoHideStripBase.Tab CreateTab(IDockContent content)
        {
            return new TabVS2005(content);
        }
    }
}
Revision:	140
Committed:	Fri May 11 11:29:29 2012 UTC (10 years, 10 months ago) by william
File size:	19805 byte(s)
Log Message:
#	User	Rev	Content
1	william	140	using System;
2			using System.Drawing;
3			using System.Windows.Forms;
4			using System.Drawing.Drawing2D;
5			using System.ComponentModel;
6
7			namespace WeifenLuo.WinFormsUI.Docking
8			{
9			internal class VS2005AutoHideStrip : AutoHideStripBase
10			{
11			private class TabVS2005 : Tab
12			{
13			internal TabVS2005(IDockContent content)
14			: base(content)
15			{
16			}
17
18			private int m_tabX = 0;
19			public int TabX
20			{
21			get { return m_tabX; }
22			set { m_tabX = value; }
23			}
24
25			private int m_tabWidth = 0;
26			public int TabWidth
27			{
28			get { return m_tabWidth; }
29			set { m_tabWidth = value; }
30			}
31
32			}
33
34			private const int _ImageHeight = 16;
35			private const int _ImageWidth = 16;
36			private const int _ImageGapTop = 2;
37			private const int _ImageGapLeft = 4;
38			private const int _ImageGapRight = 2;
39			private const int _ImageGapBottom = 2;
40			private const int _TextGapLeft = 0;
41			private const int _TextGapRight = 0;
42			private const int _TabGapTop = 3;
43			private const int _TabGapLeft = 4;
44			private const int _TabGapBetween = 10;
45
46			#region Customizable Properties
47			public Font TextFont
48			{
49			get { return DockPanel.Skin.AutoHideStripSkin.TextFont; }
50			}
51
52			private static StringFormat _stringFormatTabHorizontal;
53			private StringFormat StringFormatTabHorizontal
54			{
55			get
56			{
57			if (_stringFormatTabHorizontal == null)
58			{
59			_stringFormatTabHorizontal = new StringFormat();
60			_stringFormatTabHorizontal.Alignment = StringAlignment.Near;
61			_stringFormatTabHorizontal.LineAlignment = StringAlignment.Center;
62			_stringFormatTabHorizontal.FormatFlags = StringFormatFlags.NoWrap;
63			_stringFormatTabHorizontal.Trimming = StringTrimming.None;
64			}
65
66			if (RightToLeft == RightToLeft.Yes)
67			_stringFormatTabHorizontal.FormatFlags \|= StringFormatFlags.DirectionRightToLeft;
68			else
69			_stringFormatTabHorizontal.FormatFlags &= ~StringFormatFlags.DirectionRightToLeft;
70
71			return _stringFormatTabHorizontal;
72			}
73			}
74
75			private static StringFormat _stringFormatTabVertical;
76			private StringFormat StringFormatTabVertical
77			{
78			get
79			{
80			if (_stringFormatTabVertical == null)
81			{
82			_stringFormatTabVertical = new StringFormat();
83			_stringFormatTabVertical.Alignment = StringAlignment.Near;
84			_stringFormatTabVertical.LineAlignment = StringAlignment.Center;
85			_stringFormatTabVertical.FormatFlags = StringFormatFlags.NoWrap \| StringFormatFlags.DirectionVertical;
86			_stringFormatTabVertical.Trimming = StringTrimming.None;
87			}
88			if (RightToLeft == RightToLeft.Yes)
89			_stringFormatTabVertical.FormatFlags \|= StringFormatFlags.DirectionRightToLeft;
90			else
91			_stringFormatTabVertical.FormatFlags &= ~StringFormatFlags.DirectionRightToLeft;
92
93			return _stringFormatTabVertical;
94			}
95			}
96
97			private static int ImageHeight
98			{
99			get { return _ImageHeight; }
100			}
101
102			private static int ImageWidth
103			{
104			get { return _ImageWidth; }
105			}
106
107			private static int ImageGapTop
108			{
109			get { return _ImageGapTop; }
110			}
111
112			private static int ImageGapLeft
113			{
114			get { return _ImageGapLeft; }
115			}
116
117			private static int ImageGapRight
118			{
119			get { return _ImageGapRight; }
120			}
121
122			private static int ImageGapBottom
123			{
124			get { return _ImageGapBottom; }
125			}
126
127			private static int TextGapLeft
128			{
129			get { return _TextGapLeft; }
130			}
131
132			private static int TextGapRight
133			{
134			get { return _TextGapRight; }
135			}
136
137			private static int TabGapTop
138			{
139			get { return _TabGapTop; }
140			}
141
142			private static int TabGapLeft
143			{
144			get { return _TabGapLeft; }
145			}
146
147			private static int TabGapBetween
148			{
149			get { return _TabGapBetween; }
150			}
151
152			private static Pen PenTabBorder
153			{
154			get { return SystemPens.GrayText; }
155			}
156			#endregion
157
158			private static Matrix _matrixIdentity = new Matrix();
159			private static Matrix MatrixIdentity
160			{
161			get { return _matrixIdentity; }
162			}
163
164			private static DockState[] _dockStates;
165			private static DockState[] DockStates
166			{
167			get
168			{
169			if (_dockStates == null)
170			{
171			_dockStates = new DockState[4];
172			_dockStates[0] = DockState.DockLeftAutoHide;
173			_dockStates[1] = DockState.DockRightAutoHide;
174			_dockStates[2] = DockState.DockTopAutoHide;
175			_dockStates[3] = DockState.DockBottomAutoHide;
176			}
177			return _dockStates;
178			}
179			}
180
181			private static GraphicsPath _graphicsPath;
182			internal static GraphicsPath GraphicsPath
183			{
184			get
185			{
186			if (_graphicsPath == null)
187			_graphicsPath = new GraphicsPath();
188
189			return _graphicsPath;
190			}
191			}
192
193			public VS2005AutoHideStrip(DockPanel panel)
194			: base(panel)
195			{
196			SetStyle(ControlStyles.ResizeRedraw \|
197			ControlStyles.UserPaint \|
198			ControlStyles.AllPaintingInWmPaint \|
199			ControlStyles.OptimizedDoubleBuffer, true);
200			BackColor = SystemColors.ControlLight;
201			}
202
203			protected override void OnPaint(PaintEventArgs e)
204			{
205			Graphics g = e.Graphics;
206
207			Color startColor = DockPanel.Skin.AutoHideStripSkin.DockStripGradient.StartColor;
208			Color endColor = DockPanel.Skin.AutoHideStripSkin.DockStripGradient.EndColor;
209			LinearGradientMode gradientMode = DockPanel.Skin.AutoHideStripSkin.DockStripGradient.LinearGradientMode;
210			using (LinearGradientBrush brush = new LinearGradientBrush(ClientRectangle, startColor, endColor, gradientMode))
211			{
212			g.FillRectangle(brush, ClientRectangle);
213			}
214
215			DrawTabStrip(g);
216			}
217
218			protected override void OnLayout(LayoutEventArgs levent)
219			{
220			CalculateTabs();
221			base.OnLayout(levent);
222			}
223
224			private void DrawTabStrip(Graphics g)
225			{
226			DrawTabStrip(g, DockState.DockTopAutoHide);
227			DrawTabStrip(g, DockState.DockBottomAutoHide);
228			DrawTabStrip(g, DockState.DockLeftAutoHide);
229			DrawTabStrip(g, DockState.DockRightAutoHide);
230			}
231
232			private void DrawTabStrip(Graphics g, DockState dockState)
233			{
234			Rectangle rectTabStrip = GetLogicalTabStripRectangle(dockState);
235
236			if (rectTabStrip.IsEmpty)
237			return;
238
239			Matrix matrixIdentity = g.Transform;
240			if (dockState == DockState.DockLeftAutoHide \|\| dockState == DockState.DockRightAutoHide)
241			{
242			Matrix matrixRotated = new Matrix();
243			matrixRotated.RotateAt(90, new PointF((float)rectTabStrip.X + (float)rectTabStrip.Height / 2,
244			(float)rectTabStrip.Y + (float)rectTabStrip.Height / 2));
245			g.Transform = matrixRotated;
246			}
247
248			foreach (Pane pane in GetPanes(dockState))
249			{
250			foreach (TabVS2005 tab in pane.AutoHideTabs)
251			DrawTab(g, tab);
252			}
253			g.Transform = matrixIdentity;
254			}
255
256			private void CalculateTabs()
257			{
258			CalculateTabs(DockState.DockTopAutoHide);
259			CalculateTabs(DockState.DockBottomAutoHide);
260			CalculateTabs(DockState.DockLeftAutoHide);
261			CalculateTabs(DockState.DockRightAutoHide);
262			}
263
264			private void CalculateTabs(DockState dockState)
265			{
266			Rectangle rectTabStrip = GetLogicalTabStripRectangle(dockState);
267
268			int imageHeight = rectTabStrip.Height - ImageGapTop - ImageGapBottom;
269			int imageWidth = ImageWidth;
270			if (imageHeight > ImageHeight)
271			imageWidth = ImageWidth * (imageHeight / ImageHeight);
272
273			int x = TabGapLeft + rectTabStrip.X;
274			foreach (Pane pane in GetPanes(dockState))
275			{
276			foreach (TabVS2005 tab in pane.AutoHideTabs)
277			{
278			int width = imageWidth + ImageGapLeft + ImageGapRight +
279			TextRenderer.MeasureText(tab.Content.DockHandler.TabText, TextFont).Width +
280			TextGapLeft + TextGapRight;
281			tab.TabX = x;
282			tab.TabWidth = width;
283			x += width;
284			}
285
286			x += TabGapBetween;
287			}
288			}
289
290			private Rectangle RtlTransform(Rectangle rect, DockState dockState)
291			{
292			Rectangle rectTransformed;
293			if (dockState == DockState.DockLeftAutoHide \|\| dockState == DockState.DockRightAutoHide)
294			rectTransformed = rect;
295			else
296			rectTransformed = DrawHelper.RtlTransform(this, rect);
297
298			return rectTransformed;
299			}
300
301			private GraphicsPath GetTabOutline(TabVS2005 tab, bool transformed, bool rtlTransform)
302			{
303			DockState dockState = tab.Content.DockHandler.DockState;
304			Rectangle rectTab = GetTabRectangle(tab, transformed);
305			if (rtlTransform)
306			rectTab = RtlTransform(rectTab, dockState);
307			bool upTab = (dockState == DockState.DockLeftAutoHide \|\| dockState == DockState.DockBottomAutoHide);
308			DrawHelper.GetRoundedCornerTab(GraphicsPath, rectTab, upTab);
309
310			return GraphicsPath;
311			}
312
313			private void DrawTab(Graphics g, TabVS2005 tab)
314			{
315			Rectangle rectTabOrigin = GetTabRectangle(tab);
316			if (rectTabOrigin.IsEmpty)
317			return;
318
319			DockState dockState = tab.Content.DockHandler.DockState;
320			IDockContent content = tab.Content;
321
322			GraphicsPath path = GetTabOutline(tab, false, true);
323
324			Color startColor = DockPanel.Skin.AutoHideStripSkin.TabGradient.StartColor;
325			Color endColor = DockPanel.Skin.AutoHideStripSkin.TabGradient.EndColor;
326			LinearGradientMode gradientMode = DockPanel.Skin.AutoHideStripSkin.TabGradient.LinearGradientMode;
327			g.FillPath(new LinearGradientBrush(rectTabOrigin, startColor, endColor, gradientMode), path);
328			g.DrawPath(PenTabBorder, path);
329
330			// Set no rotate for drawing icon and text
331			Matrix matrixRotate = g.Transform;
332			g.Transform = MatrixIdentity;
333
334			// Draw the icon
335			Rectangle rectImage = rectTabOrigin;
336			rectImage.X += ImageGapLeft;
337			rectImage.Y += ImageGapTop;
338			int imageHeight = rectTabOrigin.Height - ImageGapTop - ImageGapBottom;
339			int imageWidth = ImageWidth;
340			if (imageHeight > ImageHeight)
341			imageWidth = ImageWidth * (imageHeight / ImageHeight);
342			rectImage.Height = imageHeight;
343			rectImage.Width = imageWidth;
344			rectImage = GetTransformedRectangle(dockState, rectImage);
345
346			if (dockState == DockState.DockLeftAutoHide \|\| dockState == DockState.DockRightAutoHide)
347			{
348			// The DockState is DockLeftAutoHide or DockRightAutoHide, so rotate the image 90 degrees to the right.
349			Rectangle rectTransform = RtlTransform(rectImage, dockState);
350			Point[] rotationPoints =
351			{
352			new Point(rectTransform.X + rectTransform.Width, rectTransform.Y),
353			new Point(rectTransform.X + rectTransform.Width, rectTransform.Y + rectTransform.Height),
354			new Point(rectTransform.X, rectTransform.Y)
355			};
356
357			using (Icon rotatedIcon = new Icon(((Form)content).Icon, 16, 16))
358			{
359			g.DrawImage(rotatedIcon.ToBitmap(), rotationPoints);
360			}
361			}
362			else
363			{
364			// Draw the icon normally without any rotation.
365			g.DrawIcon(((Form)content).Icon, RtlTransform(rectImage, dockState));
366			}
367
368			// Draw the text
369			Rectangle rectText = rectTabOrigin;
370			rectText.X += ImageGapLeft + imageWidth + ImageGapRight + TextGapLeft;
371			rectText.Width -= ImageGapLeft + imageWidth + ImageGapRight + TextGapLeft;
372			rectText = RtlTransform(GetTransformedRectangle(dockState, rectText), dockState);
373
374			Color textColor = DockPanel.Skin.AutoHideStripSkin.TabGradient.TextColor;
375
376			if (dockState == DockState.DockLeftAutoHide \|\| dockState == DockState.DockRightAutoHide)
377			g.DrawString(content.DockHandler.TabText, TextFont, new SolidBrush(textColor), rectText, StringFormatTabVertical);
378			else
379			g.DrawString(content.DockHandler.TabText, TextFont, new SolidBrush(textColor), rectText, StringFormatTabHorizontal);
380
381			// Set rotate back
382			g.Transform = matrixRotate;
383			}
384
385			private Rectangle GetLogicalTabStripRectangle(DockState dockState)
386			{
387			return GetLogicalTabStripRectangle(dockState, false);
388			}
389
390			private Rectangle GetLogicalTabStripRectangle(DockState dockState, bool transformed)
391			{
392			if (!DockHelper.IsDockStateAutoHide(dockState))
393			return Rectangle.Empty;
394
395			int leftPanes = GetPanes(DockState.DockLeftAutoHide).Count;
396			int rightPanes = GetPanes(DockState.DockRightAutoHide).Count;
397			int topPanes = GetPanes(DockState.DockTopAutoHide).Count;
398			int bottomPanes = GetPanes(DockState.DockBottomAutoHide).Count;
399
400			int x, y, width, height;
401
402			height = MeasureHeight();
403			if (dockState == DockState.DockLeftAutoHide && leftPanes > 0)
404			{
405			x = 0;
406			y = (topPanes == 0) ? 0 : height;
407			width = Height - (topPanes == 0 ? 0 : height) - (bottomPanes == 0 ? 0 : height);
408			}
409			else if (dockState == DockState.DockRightAutoHide && rightPanes > 0)
410			{
411			x = Width - height;
412			if (leftPanes != 0 && x < height)
413			x = height;
414			y = (topPanes == 0) ? 0 : height;
415			width = Height - (topPanes == 0 ? 0 : height) - (bottomPanes == 0 ? 0 : height);
416			}
417			else if (dockState == DockState.DockTopAutoHide && topPanes > 0)
418			{
419			x = leftPanes == 0 ? 0 : height;
420			y = 0;
421			width = Width - (leftPanes == 0 ? 0 : height) - (rightPanes == 0 ? 0 : height);
422			}
423			else if (dockState == DockState.DockBottomAutoHide && bottomPanes > 0)
424			{
425			x = leftPanes == 0 ? 0 : height;
426			y = Height - height;
427			if (topPanes != 0 && y < height)
428			y = height;
429			width = Width - (leftPanes == 0 ? 0 : height) - (rightPanes == 0 ? 0 : height);
430			}
431			else
432			return Rectangle.Empty;
433
434			if (!transformed)
435			return new Rectangle(x, y, width, height);
436			else
437			return GetTransformedRectangle(dockState, new Rectangle(x, y, width, height));
438			}
439
440			private Rectangle GetTabRectangle(TabVS2005 tab)
441			{
442			return GetTabRectangle(tab, false);
443			}
444
445			private Rectangle GetTabRectangle(TabVS2005 tab, bool transformed)
446			{
447			DockState dockState = tab.Content.DockHandler.DockState;
448			Rectangle rectTabStrip = GetLogicalTabStripRectangle(dockState);
449
450			if (rectTabStrip.IsEmpty)
451			return Rectangle.Empty;
452
453			int x = tab.TabX;
454			int y = rectTabStrip.Y +
455			(dockState == DockState.DockTopAutoHide \|\| dockState == DockState.DockRightAutoHide ?
456			0 : TabGapTop);
457			int width = tab.TabWidth;
458			int height = rectTabStrip.Height - TabGapTop;
459
460			if (!transformed)
461			return new Rectangle(x, y, width, height);
462			else
463			return GetTransformedRectangle(dockState, new Rectangle(x, y, width, height));
464			}
465
466			private Rectangle GetTransformedRectangle(DockState dockState, Rectangle rect)
467			{
468			if (dockState != DockState.DockLeftAutoHide && dockState != DockState.DockRightAutoHide)
469			return rect;
470
471			PointF[] pts = new PointF[1];
472			// the center of the rectangle
473			pts[0].X = (float)rect.X + (float)rect.Width / 2;
474			pts[0].Y = (float)rect.Y + (float)rect.Height / 2;
475			Rectangle rectTabStrip = GetLogicalTabStripRectangle(dockState);
476			Matrix matrix = new Matrix();
477			matrix.RotateAt(90, new PointF((float)rectTabStrip.X + (float)rectTabStrip.Height / 2,
478			(float)rectTabStrip.Y + (float)rectTabStrip.Height / 2));
479			matrix.TransformPoints(pts);
480
481			return new Rectangle((int)(pts[0].X - (float)rect.Height / 2 + .5F),
482			(int)(pts[0].Y - (float)rect.Width / 2 + .5F),
483			rect.Height, rect.Width);
484			}
485
486			protected override IDockContent HitTest(Point ptMouse)
487			{
488			foreach (DockState state in DockStates)
489			{
490			Rectangle rectTabStrip = GetLogicalTabStripRectangle(state, true);
491			if (!rectTabStrip.Contains(ptMouse))
492			continue;
493
494			foreach (Pane pane in GetPanes(state))
495			{
496			foreach (TabVS2005 tab in pane.AutoHideTabs)
497			{
498			GraphicsPath path = GetTabOutline(tab, true, true);
499			if (path.IsVisible(ptMouse))
500			return tab.Content;
501			}
502			}
503			}
504
505			return null;
506			}
507
508			protected internal override int MeasureHeight()
509			{
510			return Math.Max(ImageGapBottom +
511			ImageGapTop + ImageHeight,
512			TextFont.Height) + TabGapTop;
513			}
514
515			protected override void OnRefreshChanges()
516			{
517			CalculateTabs();
518			Invalidate();
519			}
520
521			protected override AutoHideStripBase.Tab CreateTab(IDockContent content)
522			{
523			return new TabVS2005(content);
524			}
525			}
526			}