ViewVC Help
View File | Revision Log | Show Annotations | Download File | View Changeset | Root Listing
root/RomCheater/trunk/deps/WeifenLuo.WinFormsUI.Docking/WinFormsUI/Docking/VS2005AutoHideStrip.cs
Revision: 140
Committed: Fri May 11 11:29:29 2012 UTC (10 years, 7 months ago) by william
File size: 19805 byte(s)
Log Message:

File Contents

# 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     }