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
(Generate patch)

Comparing trunk/deps/WeifenLuo.WinFormsUI.Docking/WinFormsUI/Docking/VS2005AutoHideStrip.cs (file contents):
Revision 140 by william, Fri May 11 11:29:29 2012 UTC vs.
Revision 640 by william, Sat Jun 8 20:31:20 2013 UTC

# Line 202 | Line 202 | namespace WeifenLuo.WinFormsUI.Docking
202  
203          protected override void OnPaint(PaintEventArgs e)
204          {
205 <            Graphics g = e.Graphics;
205 >            try
206 >            {
207 >                Graphics g = e.Graphics;
208 >
209 >                Color startColor = DockPanel.Skin.AutoHideStripSkin.DockStripGradient.StartColor;
210 >                Color endColor = DockPanel.Skin.AutoHideStripSkin.DockStripGradient.EndColor;
211 >                LinearGradientMode gradientMode = DockPanel.Skin.AutoHideStripSkin.DockStripGradient.LinearGradientMode;
212 >                using (LinearGradientBrush brush = new LinearGradientBrush(ClientRectangle, startColor, endColor, gradientMode))
213 >                {
214 >                    g.FillRectangle(brush, ClientRectangle);
215 >                }
216  
217 <            Color startColor = DockPanel.Skin.AutoHideStripSkin.DockStripGradient.StartColor;
218 <            Color endColor = DockPanel.Skin.AutoHideStripSkin.DockStripGradient.EndColor;
219 <            LinearGradientMode gradientMode = DockPanel.Skin.AutoHideStripSkin.DockStripGradient.LinearGradientMode;
210 <            using (LinearGradientBrush brush = new LinearGradientBrush(ClientRectangle, startColor, endColor, gradientMode))
217 >                DrawTabStrip(g);
218 >            }
219 >            catch (Exception)
220              {
221 <                g.FillRectangle(brush, ClientRectangle);
221 >                throw;
222              }
214
215            DrawTabStrip(g);
223          }
224  
225          protected override void OnLayout(LayoutEventArgs levent)
# Line 231 | Line 238 | namespace WeifenLuo.WinFormsUI.Docking
238  
239          private void DrawTabStrip(Graphics g, DockState dockState)
240          {
241 <            Rectangle rectTabStrip = GetLogicalTabStripRectangle(dockState);
241 >            try
242 >            {
243 >                Rectangle rectTabStrip = GetLogicalTabStripRectangle(dockState);
244  
245 <            if (rectTabStrip.IsEmpty)
246 <                return;
245 >                if (rectTabStrip.IsEmpty)
246 >                    return;
247  
248 <            Matrix matrixIdentity = g.Transform;
249 <            if (dockState == DockState.DockLeftAutoHide || dockState == DockState.DockRightAutoHide)
250 <            {
251 <                Matrix matrixRotated = new Matrix();
252 <                matrixRotated.RotateAt(90, new PointF((float)rectTabStrip.X + (float)rectTabStrip.Height / 2,
253 <                    (float)rectTabStrip.Y + (float)rectTabStrip.Height / 2));
254 <                g.Transform = matrixRotated;
255 <            }
248 >                Matrix matrixIdentity = g.Transform;
249 >                if (dockState == DockState.DockLeftAutoHide || dockState == DockState.DockRightAutoHide)
250 >                {
251 >                    Matrix matrixRotated = new Matrix();
252 >                    matrixRotated.RotateAt(90, new PointF((float)rectTabStrip.X + (float)rectTabStrip.Height / 2,
253 >                        (float)rectTabStrip.Y + (float)rectTabStrip.Height / 2));
254 >                    g.Transform = matrixRotated;
255 >                }
256  
257 <            foreach (Pane pane in GetPanes(dockState))
257 >                foreach (Pane pane in GetPanes(dockState))
258 >                {
259 >                    foreach (TabVS2005 tab in pane.AutoHideTabs)
260 >                        DrawTab(g, tab);
261 >                }
262 >                g.Transform = matrixIdentity;
263 >            }
264 >            catch (Exception)
265              {
266 <                foreach (TabVS2005 tab in pane.AutoHideTabs)
251 <                    DrawTab(g, tab);
266 >                throw;
267              }
253            g.Transform = matrixIdentity;
268          }
269  
270          private void CalculateTabs()
# Line 263 | Line 277 | namespace WeifenLuo.WinFormsUI.Docking
277  
278          private void CalculateTabs(DockState dockState)
279          {
280 <            Rectangle rectTabStrip = GetLogicalTabStripRectangle(dockState);
280 >            try
281 >            {
282 >                Rectangle rectTabStrip = GetLogicalTabStripRectangle(dockState);
283  
284 <            int imageHeight = rectTabStrip.Height - ImageGapTop - ImageGapBottom;
285 <            int imageWidth = ImageWidth;
286 <            if (imageHeight > ImageHeight)
287 <                imageWidth = ImageWidth * (imageHeight / ImageHeight);
284 >                int imageHeight = rectTabStrip.Height - ImageGapTop - ImageGapBottom;
285 >                int imageWidth = ImageWidth;
286 >                if (imageHeight > ImageHeight)
287 >                    imageWidth = ImageWidth * (imageHeight / ImageHeight);
288  
289 <            int x = TabGapLeft + rectTabStrip.X;
290 <            foreach (Pane pane in GetPanes(dockState))
275 <            {
276 <                foreach (TabVS2005 tab in pane.AutoHideTabs)
289 >                int x = TabGapLeft + rectTabStrip.X;
290 >                foreach (Pane pane in GetPanes(dockState))
291                  {
292 <                    int width = imageWidth + ImageGapLeft + ImageGapRight +
293 <                        TextRenderer.MeasureText(tab.Content.DockHandler.TabText, TextFont).Width +
294 <                        TextGapLeft + TextGapRight;
295 <                    tab.TabX = x;
296 <                    tab.TabWidth = width;
297 <                    x += width;
298 <                }
292 >                    foreach (TabVS2005 tab in pane.AutoHideTabs)
293 >                    {
294 >                        int width = imageWidth + ImageGapLeft + ImageGapRight +
295 >                            TextRenderer.MeasureText(tab.Content.DockHandler.TabText, TextFont).Width +
296 >                            TextGapLeft + TextGapRight;
297 >                        tab.TabX = x;
298 >                        tab.TabWidth = width;
299 >                        x += width;
300 >                    }
301  
302 <                x += TabGapBetween;
302 >                    x += TabGapBetween;
303 >                }
304 >            }
305 >            catch (Exception)
306 >            {
307 >                throw;
308              }
309          }
310  
311          private Rectangle RtlTransform(Rectangle rect, DockState dockState)
312          {
313 <            Rectangle rectTransformed;
314 <            if (dockState == DockState.DockLeftAutoHide || dockState == DockState.DockRightAutoHide)
315 <                rectTransformed = rect;
316 <            else
317 <                rectTransformed = DrawHelper.RtlTransform(this, rect);
313 >            try
314 >            {
315 >                Rectangle rectTransformed;
316 >                if (dockState == DockState.DockLeftAutoHide || dockState == DockState.DockRightAutoHide)
317 >                    rectTransformed = rect;
318 >                else
319 >                    rectTransformed = DrawHelper.RtlTransform(this, rect);
320  
321 <            return rectTransformed;
321 >                return rectTransformed;
322 >            }
323 >            catch (Exception)
324 >            {
325 >                throw;
326 >            }
327          }
328  
329          private GraphicsPath GetTabOutline(TabVS2005 tab, bool transformed, bool rtlTransform)
330          {
331 <            DockState dockState = tab.Content.DockHandler.DockState;
332 <            Rectangle rectTab = GetTabRectangle(tab, transformed);
333 <            if (rtlTransform)
334 <                rectTab = RtlTransform(rectTab, dockState);
335 <            bool upTab = (dockState == DockState.DockLeftAutoHide || dockState == DockState.DockBottomAutoHide);
336 <            DrawHelper.GetRoundedCornerTab(GraphicsPath, rectTab, upTab);
331 >            try
332 >            {
333 >                DockState dockState = tab.Content.DockHandler.DockState;
334 >                Rectangle rectTab = GetTabRectangle(tab, transformed);
335 >                if (rtlTransform)
336 >                    rectTab = RtlTransform(rectTab, dockState);
337 >                bool upTab = (dockState == DockState.DockLeftAutoHide || dockState == DockState.DockBottomAutoHide);
338 >                DrawHelper.GetRoundedCornerTab(GraphicsPath, rectTab, upTab);
339  
340 <            return GraphicsPath;
340 >                return GraphicsPath;
341 >            }
342 >            catch (Exception)
343 >            {
344 >                throw;
345 >            }
346          }
347  
348          private void DrawTab(Graphics g, TabVS2005 tab)
349          {
350 <            Rectangle rectTabOrigin = GetTabRectangle(tab);
351 <            if (rectTabOrigin.IsEmpty)
352 <                return;
353 <
354 <            DockState dockState = tab.Content.DockHandler.DockState;
355 <            IDockContent content = tab.Content;
356 <
357 <            GraphicsPath path = GetTabOutline(tab, false, true);
358 <
359 <            Color startColor = DockPanel.Skin.AutoHideStripSkin.TabGradient.StartColor;
360 <            Color endColor = DockPanel.Skin.AutoHideStripSkin.TabGradient.EndColor;
361 <            LinearGradientMode gradientMode = DockPanel.Skin.AutoHideStripSkin.TabGradient.LinearGradientMode;
362 <            g.FillPath(new LinearGradientBrush(rectTabOrigin, startColor, endColor, gradientMode), path);
363 <            g.DrawPath(PenTabBorder, path);
364 <
365 <            // Set no rotate for drawing icon and text
366 <            Matrix matrixRotate = g.Transform;
367 <            g.Transform = MatrixIdentity;
368 <
369 <            // Draw the icon
370 <            Rectangle rectImage = rectTabOrigin;
371 <            rectImage.X += ImageGapLeft;
372 <            rectImage.Y += ImageGapTop;
373 <            int imageHeight = rectTabOrigin.Height - ImageGapTop - ImageGapBottom;
374 <            int imageWidth = ImageWidth;
375 <            if (imageHeight > ImageHeight)
376 <                imageWidth = ImageWidth * (imageHeight / ImageHeight);
377 <            rectImage.Height = imageHeight;
378 <            rectImage.Width = imageWidth;
379 <            rectImage = GetTransformedRectangle(dockState, rectImage);
380 <
381 <            if (dockState == DockState.DockLeftAutoHide || dockState == DockState.DockRightAutoHide)
382 <            {
383 <                // The DockState is DockLeftAutoHide or DockRightAutoHide, so rotate the image 90 degrees to the right.
384 <                Rectangle rectTransform = RtlTransform(rectImage, dockState);
385 <                Point[] rotationPoints =
350 >            try
351 >            {
352 >                Rectangle rectTabOrigin = GetTabRectangle(tab);
353 >                if (rectTabOrigin.IsEmpty)
354 >                    return;
355 >
356 >                DockState dockState = tab.Content.DockHandler.DockState;
357 >                IDockContent content = tab.Content;
358 >
359 >                GraphicsPath path = GetTabOutline(tab, false, true);
360 >
361 >                Color startColor = DockPanel.Skin.AutoHideStripSkin.TabGradient.StartColor;
362 >                Color endColor = DockPanel.Skin.AutoHideStripSkin.TabGradient.EndColor;
363 >                LinearGradientMode gradientMode = DockPanel.Skin.AutoHideStripSkin.TabGradient.LinearGradientMode;
364 >
365 >                if (rectTabOrigin.Width == 0)
366 >                {
367 >                    // rectangle width cannot be 0
368 >                    rectTabOrigin.Width = 1;
369 >                }
370 >
371 >                g.FillPath(new LinearGradientBrush(rectTabOrigin, startColor, endColor, gradientMode), path);
372 >                g.DrawPath(PenTabBorder, path);
373 >
374 >                // Set no rotate for drawing icon and text
375 >                Matrix matrixRotate = g.Transform;
376 >                g.Transform = MatrixIdentity;
377 >
378 >                // Draw the icon
379 >                Rectangle rectImage = rectTabOrigin;
380 >                rectImage.X += ImageGapLeft;
381 >                rectImage.Y += ImageGapTop;
382 >                int imageHeight = rectTabOrigin.Height - ImageGapTop - ImageGapBottom;
383 >                int imageWidth = ImageWidth;
384 >                if (imageHeight > ImageHeight)
385 >                    imageWidth = ImageWidth * (imageHeight / ImageHeight);
386 >                rectImage.Height = imageHeight;
387 >                rectImage.Width = imageWidth;
388 >                rectImage = GetTransformedRectangle(dockState, rectImage);
389 >
390 >                if (dockState == DockState.DockLeftAutoHide || dockState == DockState.DockRightAutoHide)
391 >                {
392 >                    // The DockState is DockLeftAutoHide or DockRightAutoHide, so rotate the image 90 degrees to the right.
393 >                    Rectangle rectTransform = RtlTransform(rectImage, dockState);
394 >                    Point[] rotationPoints =
395                  {
396                      new Point(rectTransform.X + rectTransform.Width, rectTransform.Y),
397                      new Point(rectTransform.X + rectTransform.Width, rectTransform.Y + rectTransform.Height),
398                      new Point(rectTransform.X, rectTransform.Y)
399                  };
400  
401 <                using (Icon rotatedIcon = new Icon(((Form)content).Icon, 16, 16))
401 >                    using (Icon rotatedIcon = new Icon(((Form)content).Icon, 16, 16))
402 >                    {
403 >                        g.DrawImage(rotatedIcon.ToBitmap(), rotationPoints);
404 >                    }
405 >                }
406 >                else
407                  {
408 <                    g.DrawImage(rotatedIcon.ToBitmap(), rotationPoints);
408 >                    // Draw the icon normally without any rotation.
409 >                    g.DrawIcon(((Form)content).Icon, RtlTransform(rectImage, dockState));
410                  }
361            }
362            else
363            {
364                // Draw the icon normally without any rotation.
365                g.DrawIcon(((Form)content).Icon, RtlTransform(rectImage, dockState));
366            }
411  
412 <            // Draw the text
413 <            Rectangle rectText = rectTabOrigin;
414 <            rectText.X += ImageGapLeft + imageWidth + ImageGapRight + TextGapLeft;
415 <            rectText.Width -= ImageGapLeft + imageWidth + ImageGapRight + TextGapLeft;
416 <            rectText = RtlTransform(GetTransformedRectangle(dockState, rectText), dockState);
412 >                // Draw the text
413 >                Rectangle rectText = rectTabOrigin;
414 >                rectText.X += ImageGapLeft + imageWidth + ImageGapRight + TextGapLeft;
415 >                rectText.Width -= ImageGapLeft + imageWidth + ImageGapRight + TextGapLeft;
416 >                rectText = RtlTransform(GetTransformedRectangle(dockState, rectText), dockState);
417  
418 <            Color textColor = DockPanel.Skin.AutoHideStripSkin.TabGradient.TextColor;
418 >                Color textColor = DockPanel.Skin.AutoHideStripSkin.TabGradient.TextColor;
419  
420 <            if (dockState == DockState.DockLeftAutoHide || dockState == DockState.DockRightAutoHide)
421 <                g.DrawString(content.DockHandler.TabText, TextFont, new SolidBrush(textColor), rectText, StringFormatTabVertical);
422 <            else
423 <                g.DrawString(content.DockHandler.TabText, TextFont, new SolidBrush(textColor), rectText, StringFormatTabHorizontal);
420 >                if (dockState == DockState.DockLeftAutoHide || dockState == DockState.DockRightAutoHide)
421 >                    g.DrawString(content.DockHandler.TabText, TextFont, new SolidBrush(textColor), rectText, StringFormatTabVertical);
422 >                else
423 >                    g.DrawString(content.DockHandler.TabText, TextFont, new SolidBrush(textColor), rectText, StringFormatTabHorizontal);
424  
425 <            // Set rotate back
426 <            g.Transform = matrixRotate;
425 >                // Set rotate back
426 >                g.Transform = matrixRotate;
427 >            }
428 >            catch (Exception)
429 >            {
430 >                throw;
431 >            }
432          }
433  
434          private Rectangle GetLogicalTabStripRectangle(DockState dockState)
# Line 389 | Line 438 | namespace WeifenLuo.WinFormsUI.Docking
438  
439          private Rectangle GetLogicalTabStripRectangle(DockState dockState, bool transformed)
440          {
441 <            if (!DockHelper.IsDockStateAutoHide(dockState))
442 <                return Rectangle.Empty;
441 >            try
442 >            {
443 >                if (!DockHelper.IsDockStateAutoHide(dockState))
444 >                    return Rectangle.Empty;
445  
446 <            int leftPanes = GetPanes(DockState.DockLeftAutoHide).Count;
447 <            int rightPanes = GetPanes(DockState.DockRightAutoHide).Count;
448 <            int topPanes = GetPanes(DockState.DockTopAutoHide).Count;
449 <            int bottomPanes = GetPanes(DockState.DockBottomAutoHide).Count;
446 >                int leftPanes = GetPanes(DockState.DockLeftAutoHide).Count;
447 >                int rightPanes = GetPanes(DockState.DockRightAutoHide).Count;
448 >                int topPanes = GetPanes(DockState.DockTopAutoHide).Count;
449 >                int bottomPanes = GetPanes(DockState.DockBottomAutoHide).Count;
450  
451 <            int x, y, width, height;
451 >                int x, y, width, height;
452  
453 <            height = MeasureHeight();
454 <            if (dockState == DockState.DockLeftAutoHide && leftPanes > 0)
455 <            {
456 <                x = 0;
457 <                y = (topPanes == 0) ? 0 : height;
458 <                width = Height - (topPanes == 0 ? 0 : height) - (bottomPanes == 0 ? 0 : height);
459 <            }
460 <            else if (dockState == DockState.DockRightAutoHide && rightPanes > 0)
461 <            {
462 <                x = Width - height;
463 <                if (leftPanes != 0 && x < height)
464 <                    x = height;
465 <                y = (topPanes == 0) ? 0 : height;
466 <                width = Height - (topPanes == 0 ? 0 : height) - (bottomPanes == 0 ? 0 : height);
467 <            }
468 <            else if (dockState == DockState.DockTopAutoHide && topPanes > 0)
469 <            {
470 <                x = leftPanes == 0 ? 0 : height;
471 <                y = 0;
472 <                width = Width - (leftPanes == 0 ? 0 : height) - (rightPanes == 0 ? 0 : height);
453 >                height = MeasureHeight();
454 >                if (dockState == DockState.DockLeftAutoHide && leftPanes > 0)
455 >                {
456 >                    x = 0;
457 >                    y = (topPanes == 0) ? 0 : height;
458 >                    width = Height - (topPanes == 0 ? 0 : height) - (bottomPanes == 0 ? 0 : height);
459 >                }
460 >                else if (dockState == DockState.DockRightAutoHide && rightPanes > 0)
461 >                {
462 >                    x = Width - height;
463 >                    if (leftPanes != 0 && x < height)
464 >                        x = height;
465 >                    y = (topPanes == 0) ? 0 : height;
466 >                    width = Height - (topPanes == 0 ? 0 : height) - (bottomPanes == 0 ? 0 : height);
467 >                }
468 >                else if (dockState == DockState.DockTopAutoHide && topPanes > 0)
469 >                {
470 >                    x = leftPanes == 0 ? 0 : height;
471 >                    y = 0;
472 >                    width = Width - (leftPanes == 0 ? 0 : height) - (rightPanes == 0 ? 0 : height);
473 >                }
474 >                else if (dockState == DockState.DockBottomAutoHide && bottomPanes > 0)
475 >                {
476 >                    x = leftPanes == 0 ? 0 : height;
477 >                    y = Height - height;
478 >                    if (topPanes != 0 && y < height)
479 >                        y = height;
480 >                    width = Width - (leftPanes == 0 ? 0 : height) - (rightPanes == 0 ? 0 : height);
481 >                }
482 >                else
483 >                    return Rectangle.Empty;
484 >
485 >                if (!transformed)
486 >                    return new Rectangle(x, y, width, height);
487 >                else
488 >                    return GetTransformedRectangle(dockState, new Rectangle(x, y, width, height));
489              }
490 <            else if (dockState == DockState.DockBottomAutoHide && bottomPanes > 0)
490 >            catch (Exception)
491              {
492 <                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);
492 >                throw;
493              }
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));
494          }
495  
496          private Rectangle GetTabRectangle(TabVS2005 tab)
# Line 444 | Line 500 | namespace WeifenLuo.WinFormsUI.Docking
500  
501          private Rectangle GetTabRectangle(TabVS2005 tab, bool transformed)
502          {
503 <            DockState dockState = tab.Content.DockHandler.DockState;
504 <            Rectangle rectTabStrip = GetLogicalTabStripRectangle(dockState);
503 >            try
504 >            {
505 >                DockState dockState = tab.Content.DockHandler.DockState;
506 >                Rectangle rectTabStrip = GetLogicalTabStripRectangle(dockState);
507 >
508 >                if (rectTabStrip.IsEmpty)
509 >                    return Rectangle.Empty;
510  
511 <            if (rectTabStrip.IsEmpty)
512 <                return Rectangle.Empty;
511 >                int x = tab.TabX;
512 >                int y = rectTabStrip.Y +
513 >                    (dockState == DockState.DockTopAutoHide || dockState == DockState.DockRightAutoHide ?
514 >                    0 : TabGapTop);
515 >                int width = tab.TabWidth;
516 >                int height = rectTabStrip.Height - TabGapTop;
517  
518 <            int x = tab.TabX;
519 <            int y = rectTabStrip.Y +
520 <                (dockState == DockState.DockTopAutoHide || dockState == DockState.DockRightAutoHide ?
521 <                0 : TabGapTop);
522 <            int width = tab.TabWidth;
523 <            int height = rectTabStrip.Height - TabGapTop;
524 <
525 <            if (!transformed)
526 <                return new Rectangle(x, y, width, height);
462 <            else
463 <                return GetTransformedRectangle(dockState, new Rectangle(x, y, width, height));
518 >                if (!transformed)
519 >                    return new Rectangle(x, y, width, height);
520 >                else
521 >                    return GetTransformedRectangle(dockState, new Rectangle(x, y, width, height));
522 >            }
523 >            catch (Exception)
524 >            {
525 >                throw;
526 >            }
527          }
528  
529          private Rectangle GetTransformedRectangle(DockState dockState, Rectangle rect)
530          {
531 <            if (dockState != DockState.DockLeftAutoHide && dockState != DockState.DockRightAutoHide)
532 <                return rect;
531 >            try
532 >            {
533 >                if (dockState != DockState.DockLeftAutoHide && dockState != DockState.DockRightAutoHide)
534 >                    return rect;
535 >
536 >                PointF[] pts = new PointF[1];
537 >                // the center of the rectangle
538 >                pts[0].X = (float)rect.X + (float)rect.Width / 2;
539 >                pts[0].Y = (float)rect.Y + (float)rect.Height / 2;
540 >                Rectangle rectTabStrip = GetLogicalTabStripRectangle(dockState);
541 >                Matrix matrix = new Matrix();
542 >                matrix.RotateAt(90, new PointF((float)rectTabStrip.X + (float)rectTabStrip.Height / 2,
543 >                    (float)rectTabStrip.Y + (float)rectTabStrip.Height / 2));
544 >                matrix.TransformPoints(pts);
545  
546 <            PointF[] pts = new PointF[1];
547 <            // the center of the rectangle
548 <            pts[0].X = (float)rect.X + (float)rect.Width / 2;
549 <            pts[0].Y = (float)rect.Y + (float)rect.Height / 2;
550 <            Rectangle rectTabStrip = GetLogicalTabStripRectangle(dockState);
551 <            Matrix matrix = new Matrix();
552 <            matrix.RotateAt(90, new PointF((float)rectTabStrip.X + (float)rectTabStrip.Height / 2,
553 <                (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);
546 >                return new Rectangle((int)(pts[0].X - (float)rect.Height / 2 + .5F),
547 >                    (int)(pts[0].Y - (float)rect.Width / 2 + .5F),
548 >                    rect.Height, rect.Width);
549 >            }
550 >            catch (Exception)
551 >            {
552 >                throw;
553 >            }
554          }
555  
556          protected override IDockContent HitTest(Point ptMouse)
557          {
558 <            foreach (DockState state in DockStates)
558 >            try
559              {
560 <                Rectangle rectTabStrip = GetLogicalTabStripRectangle(state, true);
491 <                if (!rectTabStrip.Contains(ptMouse))
492 <                    continue;
493 <
494 <                foreach (Pane pane in GetPanes(state))
560 >                foreach (DockState state in DockStates)
561                  {
562 <                    foreach (TabVS2005 tab in pane.AutoHideTabs)
562 >                    Rectangle rectTabStrip = GetLogicalTabStripRectangle(state, true);
563 >                    if (!rectTabStrip.Contains(ptMouse))
564 >                        continue;
565 >
566 >                    foreach (Pane pane in GetPanes(state))
567                      {
568 <                        GraphicsPath path = GetTabOutline(tab, true, true);
569 <                        if (path.IsVisible(ptMouse))
570 <                            return tab.Content;
568 >                        foreach (TabVS2005 tab in pane.AutoHideTabs)
569 >                        {
570 >                            GraphicsPath path = GetTabOutline(tab, true, true);
571 >                            if (path.IsVisible(ptMouse))
572 >                                return tab.Content;
573 >                        }
574                      }
575                  }
503            }
576  
577 <            return null;
577 >                return null;
578 >            }
579 >            catch (Exception)
580 >            {
581 >                throw;
582 >            }
583          }
584  
585          protected internal override int MeasureHeight()

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines