Context Navigation

source: stable/HeuristicLab.ExtLibs/HeuristicLab.WinFormsUI/2.7.0/WinFormsUI-2.7.0/Docking/DockPanel.DockDragHandler.cs @ 16123

Visit:

Last change on this file since 16123 was 8616, checked in by mkommend, 12 years ago
#1939: Added DockPanelSuite 2.7.0 to ExtLibs.
File size: 32.7 KB

Line
1	using System;
2	using System.Collections.Generic;
3	using System.Text;
4	using System.Windows.Forms;
5	using System.Drawing;
6	using System.Drawing.Drawing2D;
7	using System.ComponentModel;
8
9	namespace WeifenLuo.WinFormsUI.Docking
10	{
11	partial class DockPanel
12	{
13	private sealed class DockDragHandler : DragHandler
14	{
15	private class DockIndicator : DragForm
16	{
17	#region IHitTest
18	private interface IHitTest
19	{
20	DockStyle HitTest(Point pt);
21	DockStyle Status { get; set; }
22	}
23	#endregion
24
25	#region PanelIndicator
26	private class PanelIndicator : PictureBox, IHitTest
27	{
28	private static Image _imagePanelLeft = Resources.DockIndicator_PanelLeft;
29	private static Image _imagePanelRight = Resources.DockIndicator_PanelRight;
30	private static Image _imagePanelTop = Resources.DockIndicator_PanelTop;
31	private static Image _imagePanelBottom = Resources.DockIndicator_PanelBottom;
32	private static Image _imagePanelFill = Resources.DockIndicator_PanelFill;
33	private static Image _imagePanelLeftActive = Resources.DockIndicator_PanelLeft_Active;
34	private static Image _imagePanelRightActive = Resources.DockIndicator_PanelRight_Active;
35	private static Image _imagePanelTopActive = Resources.DockIndicator_PanelTop_Active;
36	private static Image _imagePanelBottomActive = Resources.DockIndicator_PanelBottom_Active;
37	private static Image _imagePanelFillActive = Resources.DockIndicator_PanelFill_Active;
38
39	public PanelIndicator(DockStyle dockStyle)
40	{
41	m_dockStyle = dockStyle;
42	SizeMode = PictureBoxSizeMode.AutoSize;
43	Image = ImageInactive;
44	}
45
46	private DockStyle m_dockStyle;
47	private DockStyle DockStyle
48	{
49	get { return m_dockStyle; }
50	}
51
52	private DockStyle m_status;
53	public DockStyle Status
54	{
55	get { return m_status; }
56	set
57	{
58	if (value != DockStyle && value != DockStyle.None)
59	throw new InvalidEnumArgumentException();
60
61	if (m_status == value)
62	return;
63
64	m_status = value;
65	IsActivated = (m_status != DockStyle.None);
66	}
67	}
68
69	private Image ImageInactive
70	{
71	get
72	{
73	if (DockStyle == DockStyle.Left)
74	return _imagePanelLeft;
75	else if (DockStyle == DockStyle.Right)
76	return _imagePanelRight;
77	else if (DockStyle == DockStyle.Top)
78	return _imagePanelTop;
79	else if (DockStyle == DockStyle.Bottom)
80	return _imagePanelBottom;
81	else if (DockStyle == DockStyle.Fill)
82	return _imagePanelFill;
83	else
84	return null;
85	}
86	}
87
88	private Image ImageActive
89	{
90	get
91	{
92	if (DockStyle == DockStyle.Left)
93	return _imagePanelLeftActive;
94	else if (DockStyle == DockStyle.Right)
95	return _imagePanelRightActive;
96	else if (DockStyle == DockStyle.Top)
97	return _imagePanelTopActive;
98	else if (DockStyle == DockStyle.Bottom)
99	return _imagePanelBottomActive;
100	else if (DockStyle == DockStyle.Fill)
101	return _imagePanelFillActive;
102	else
103	return null;
104	}
105	}
106
107	private bool m_isActivated = false;
108	private bool IsActivated
109	{
110	get { return m_isActivated; }
111	set
112	{
113	m_isActivated = value;
114	Image = IsActivated ? ImageActive : ImageInactive;
115	}
116	}
117
118	public DockStyle HitTest(Point pt)
119	{
120	return this.Visible && ClientRectangle.Contains(PointToClient(pt)) ? DockStyle : DockStyle.None;
121	}
122	}
123	#endregion PanelIndicator
124
125	#region PaneIndicator
126	private class PaneIndicator : PictureBox, IHitTest
127	{
128	private struct HotSpotIndex
129	{
130	public HotSpotIndex(int x, int y, DockStyle dockStyle)
131	{
132	m_x = x;
133	m_y = y;
134	m_dockStyle = dockStyle;
135	}
136
137	private int m_x;
138	public int X
139	{
140	get { return m_x; }
141	}
142
143	private int m_y;
144	public int Y
145	{
146	get { return m_y; }
147	}
148
149	private DockStyle m_dockStyle;
150	public DockStyle DockStyle
151	{
152	get { return m_dockStyle; }
153	}
154	}
155
156	private static Bitmap _bitmapPaneDiamond = Resources.DockIndicator_PaneDiamond;
157	private static Bitmap _bitmapPaneDiamondLeft = Resources.DockIndicator_PaneDiamond_Left;
158	private static Bitmap _bitmapPaneDiamondRight = Resources.DockIndicator_PaneDiamond_Right;
159	private static Bitmap _bitmapPaneDiamondTop = Resources.DockIndicator_PaneDiamond_Top;
160	private static Bitmap _bitmapPaneDiamondBottom = Resources.DockIndicator_PaneDiamond_Bottom;
161	private static Bitmap _bitmapPaneDiamondFill = Resources.DockIndicator_PaneDiamond_Fill;
162	private static Bitmap _bitmapPaneDiamondHotSpot = Resources.DockIndicator_PaneDiamond_HotSpot;
163	private static Bitmap _bitmapPaneDiamondHotSpotIndex = Resources.DockIndicator_PaneDiamond_HotSpotIndex;
164	private static HotSpotIndex[] _hotSpots = new HotSpotIndex[]
165	{
166	new HotSpotIndex(1, 0, DockStyle.Top),
167	new HotSpotIndex(0, 1, DockStyle.Left),
168	new HotSpotIndex(1, 1, DockStyle.Fill),
169	new HotSpotIndex(2, 1, DockStyle.Right),
170	new HotSpotIndex(1, 2, DockStyle.Bottom)
171	};
172	private static GraphicsPath _displayingGraphicsPath = DrawHelper.CalculateGraphicsPathFromBitmap(_bitmapPaneDiamond);
173
174	public PaneIndicator()
175	{
176	SizeMode = PictureBoxSizeMode.AutoSize;
177	Image = _bitmapPaneDiamond;
178	Region = new Region(DisplayingGraphicsPath);
179	}
180
181	public static GraphicsPath DisplayingGraphicsPath
182	{
183	get { return _displayingGraphicsPath; }
184	}
185
186	public DockStyle HitTest(Point pt)
187	{
188	if (!Visible)
189	return DockStyle.None;
190
191	pt = PointToClient(pt);
192	if (!ClientRectangle.Contains(pt))
193	return DockStyle.None;
194
195	for (int i = _hotSpots.GetLowerBound(0); i <= _hotSpots.GetUpperBound(0); i++)
196	{
197	if (_bitmapPaneDiamondHotSpot.GetPixel(pt.X, pt.Y) == _bitmapPaneDiamondHotSpotIndex.GetPixel(_hotSpots[i].X, _hotSpots[i].Y))
198	return _hotSpots[i].DockStyle;
199	}
200
201	return DockStyle.None;
202	}
203
204	private DockStyle m_status = DockStyle.None;
205	public DockStyle Status
206	{
207	get { return m_status; }
208	set
209	{
210	m_status = value;
211	if (m_status == DockStyle.None)
212	Image = _bitmapPaneDiamond;
213	else if (m_status == DockStyle.Left)
214	Image = _bitmapPaneDiamondLeft;
215	else if (m_status == DockStyle.Right)
216	Image = _bitmapPaneDiamondRight;
217	else if (m_status == DockStyle.Top)
218	Image = _bitmapPaneDiamondTop;
219	else if (m_status == DockStyle.Bottom)
220	Image = _bitmapPaneDiamondBottom;
221	else if (m_status == DockStyle.Fill)
222	Image = _bitmapPaneDiamondFill;
223	}
224	}
225	}
226	#endregion PaneIndicator
227
228	#region consts
229	private int _PanelIndicatorMargin = 10;
230	#endregion
231
232	private DockDragHandler m_dragHandler;
233
234	public DockIndicator(DockDragHandler dragHandler)
235	{
236	m_dragHandler = dragHandler;
237	Controls.AddRange(new Control[] {
238	PaneDiamond,
239	PanelLeft,
240	PanelRight,
241	PanelTop,
242	PanelBottom,
243	PanelFill
244	});
245	Region = new Region(Rectangle.Empty);
246	}
247
248	private PaneIndicator m_paneDiamond = null;
249	private PaneIndicator PaneDiamond
250	{
251	get
252	{
253	if (m_paneDiamond == null)
254	m_paneDiamond = new PaneIndicator();
255
256	return m_paneDiamond;
257	}
258	}
259
260	private PanelIndicator m_panelLeft = null;
261	private PanelIndicator PanelLeft
262	{
263	get
264	{
265	if (m_panelLeft == null)
266	m_panelLeft = new PanelIndicator(DockStyle.Left);
267
268	return m_panelLeft;
269	}
270	}
271
272	private PanelIndicator m_panelRight = null;
273	private PanelIndicator PanelRight
274	{
275	get
276	{
277	if (m_panelRight == null)
278	m_panelRight = new PanelIndicator(DockStyle.Right);
279
280	return m_panelRight;
281	}
282	}
283
284	private PanelIndicator m_panelTop = null;
285	private PanelIndicator PanelTop
286	{
287	get
288	{
289	if (m_panelTop == null)
290	m_panelTop = new PanelIndicator(DockStyle.Top);
291
292	return m_panelTop;
293	}
294	}
295
296	private PanelIndicator m_panelBottom = null;
297	private PanelIndicator PanelBottom
298	{
299	get
300	{
301	if (m_panelBottom == null)
302	m_panelBottom = new PanelIndicator(DockStyle.Bottom);
303
304	return m_panelBottom;
305	}
306	}
307
308	private PanelIndicator m_panelFill = null;
309	private PanelIndicator PanelFill
310	{
311	get
312	{
313	if (m_panelFill == null)
314	m_panelFill = new PanelIndicator(DockStyle.Fill);
315
316	return m_panelFill;
317	}
318	}
319
320	private bool m_fullPanelEdge = false;
321	public bool FullPanelEdge
322	{
323	get { return m_fullPanelEdge; }
324	set
325	{
326	if (m_fullPanelEdge == value)
327	return;
328
329	m_fullPanelEdge = value;
330	RefreshChanges();
331	}
332	}
333
334	public DockDragHandler DragHandler
335	{
336	get { return m_dragHandler; }
337	}
338
339	public DockPanel DockPanel
340	{
341	get { return DragHandler.DockPanel; }
342	}
343
344	private DockPane m_dockPane = null;
345	public DockPane DockPane
346	{
347	get { return m_dockPane; }
348	internal set
349	{
350	if (m_dockPane == value)
351	return;
352
353	DockPane oldDisplayingPane = DisplayingPane;
354	m_dockPane = value;
355	if (oldDisplayingPane != DisplayingPane)
356	RefreshChanges();
357	}
358	}
359
360	private IHitTest m_hitTest = null;
361	private IHitTest HitTestResult
362	{
363	get { return m_hitTest; }
364	set
365	{
366	if (m_hitTest == value)
367	return;
368
369	if (m_hitTest != null)
370	m_hitTest.Status = DockStyle.None;
371
372	m_hitTest = value;
373	}
374	}
375
376	private DockPane DisplayingPane
377	{
378	get { return ShouldPaneDiamondVisible() ? DockPane : null; }
379	}
380
381	private void RefreshChanges()
382	{
383	Region region = new Region(Rectangle.Empty);
384	Rectangle rectDockArea = FullPanelEdge ? DockPanel.DockArea : DockPanel.DocumentWindowBounds;
385
386	rectDockArea = RectangleToClient(DockPanel.RectangleToScreen(rectDockArea));
387	if (ShouldPanelIndicatorVisible(DockState.DockLeft))
388	{
389	PanelLeft.Location = new Point(rectDockArea.X + _PanelIndicatorMargin, rectDockArea.Y + (rectDockArea.Height - PanelRight.Height) / 2);
390	PanelLeft.Visible = true;
391	region.Union(PanelLeft.Bounds);
392	}
393	else
394	PanelLeft.Visible = false;
395
396	if (ShouldPanelIndicatorVisible(DockState.DockRight))
397	{
398	PanelRight.Location = new Point(rectDockArea.X + rectDockArea.Width - PanelRight.Width - _PanelIndicatorMargin, rectDockArea.Y + (rectDockArea.Height - PanelRight.Height) / 2);
399	PanelRight.Visible = true;
400	region.Union(PanelRight.Bounds);
401	}
402	else
403	PanelRight.Visible = false;
404
405	if (ShouldPanelIndicatorVisible(DockState.DockTop))
406	{
407	PanelTop.Location = new Point(rectDockArea.X + (rectDockArea.Width - PanelTop.Width) / 2, rectDockArea.Y + _PanelIndicatorMargin);
408	PanelTop.Visible = true;
409	region.Union(PanelTop.Bounds);
410	}
411	else
412	PanelTop.Visible = false;
413
414	if (ShouldPanelIndicatorVisible(DockState.DockBottom))
415	{
416	PanelBottom.Location = new Point(rectDockArea.X + (rectDockArea.Width - PanelBottom.Width) / 2, rectDockArea.Y + rectDockArea.Height - PanelBottom.Height - _PanelIndicatorMargin);
417	PanelBottom.Visible = true;
418	region.Union(PanelBottom.Bounds);
419	}
420	else
421	PanelBottom.Visible = false;
422
423	if (ShouldPanelIndicatorVisible(DockState.Document))
424	{
425	Rectangle rectDocumentWindow = RectangleToClient(DockPanel.RectangleToScreen(DockPanel.DocumentWindowBounds));
426	PanelFill.Location = new Point(rectDocumentWindow.X + (rectDocumentWindow.Width - PanelFill.Width) / 2, rectDocumentWindow.Y + (rectDocumentWindow.Height - PanelFill.Height) / 2);
427	PanelFill.Visible = true;
428	region.Union(PanelFill.Bounds);
429	}
430	else
431	PanelFill.Visible = false;
432
433	if (ShouldPaneDiamondVisible())
434	{
435	Rectangle rect = RectangleToClient(DockPane.RectangleToScreen(DockPane.ClientRectangle));
436	PaneDiamond.Location = new Point(rect.Left + (rect.Width - PaneDiamond.Width) / 2, rect.Top + (rect.Height - PaneDiamond.Height) / 2);
437	PaneDiamond.Visible = true;
438	using (GraphicsPath graphicsPath = PaneIndicator.DisplayingGraphicsPath.Clone() as GraphicsPath)
439	{
440	Point[] pts = new Point[]
441	{
442	new Point(PaneDiamond.Left, PaneDiamond.Top),
443	new Point(PaneDiamond.Right, PaneDiamond.Top),
444	new Point(PaneDiamond.Left, PaneDiamond.Bottom)
445	};
446	using (Matrix matrix = new Matrix(PaneDiamond.ClientRectangle, pts))
447	{
448	graphicsPath.Transform(matrix);
449	}
450	region.Union(graphicsPath);
451	}
452	}
453	else
454	PaneDiamond.Visible = false;
455
456	Region = region;
457	}
458
459	private bool ShouldPanelIndicatorVisible(DockState dockState)
460	{
461	if (!Visible)
462	return false;
463
464	if (DockPanel.DockWindows[dockState].Visible)
465	return false;
466
467	return DragHandler.DragSource.IsDockStateValid(dockState);
468	}
469
470	private bool ShouldPaneDiamondVisible()
471	{
472	if (DockPane == null)
473	return false;
474
475	if (!DockPanel.AllowEndUserNestedDocking)
476	return false;
477
478	return DragHandler.DragSource.CanDockTo(DockPane);
479	}
480
481	public override void Show(bool bActivate)
482	{
483	base.Show(bActivate);
484	Bounds = SystemInformation.VirtualScreen;
485	RefreshChanges();
486	}
487
488	public void TestDrop()
489	{
490	Point pt = Control.MousePosition;
491	DockPane = DockHelper.PaneAtPoint(pt, DockPanel);
492
493	if (TestDrop(PanelLeft, pt) != DockStyle.None)
494	HitTestResult = PanelLeft;
495	else if (TestDrop(PanelRight, pt) != DockStyle.None)
496	HitTestResult = PanelRight;
497	else if (TestDrop(PanelTop, pt) != DockStyle.None)
498	HitTestResult = PanelTop;
499	else if (TestDrop(PanelBottom, pt) != DockStyle.None)
500	HitTestResult = PanelBottom;
501	else if (TestDrop(PanelFill, pt) != DockStyle.None)
502	HitTestResult = PanelFill;
503	else if (TestDrop(PaneDiamond, pt) != DockStyle.None)
504	HitTestResult = PaneDiamond;
505	else
506	HitTestResult = null;
507
508	if (HitTestResult != null)
509	{
510	if (HitTestResult is PaneIndicator)
511	DragHandler.Outline.Show(DockPane, HitTestResult.Status);
512	else
513	DragHandler.Outline.Show(DockPanel, HitTestResult.Status, FullPanelEdge);
514	}
515	}
516
517	private static DockStyle TestDrop(IHitTest hitTest, Point pt)
518	{
519	return hitTest.Status = hitTest.HitTest(pt);
520	}
521	}
522
523	private class DockOutline : DockOutlineBase
524	{
525	public DockOutline()
526	{
527	m_dragForm = new DragForm();
528	SetDragForm(Rectangle.Empty);
529	DragForm.BackColor = SystemColors.ActiveCaption;
530	DragForm.Opacity = 0.5;
531	DragForm.Show(false);
532	}
533
534	DragForm m_dragForm;
535	private DragForm DragForm
536	{
537	get { return m_dragForm; }
538	}
539
540	protected override void OnShow()
541	{
542	CalculateRegion();
543	}
544
545	protected override void OnClose()
546	{
547	DragForm.Close();
548	}
549
550	private void CalculateRegion()
551	{
552	if (SameAsOldValue)
553	return;
554
555	if (!FloatWindowBounds.IsEmpty)
556	SetOutline(FloatWindowBounds);
557	else if (DockTo is DockPanel)
558	SetOutline(DockTo as DockPanel, Dock, (ContentIndex != 0));
559	else if (DockTo is DockPane)
560	SetOutline(DockTo as DockPane, Dock, ContentIndex);
561	else
562	SetOutline();
563	}
564
565	private void SetOutline()
566	{
567	SetDragForm(Rectangle.Empty);
568	}
569
570	private void SetOutline(Rectangle floatWindowBounds)
571	{
572	SetDragForm(floatWindowBounds);
573	}
574
575	private void SetOutline(DockPanel dockPanel, DockStyle dock, bool fullPanelEdge)
576	{
577	Rectangle rect = fullPanelEdge ? dockPanel.DockArea : dockPanel.DocumentWindowBounds;
578	rect.Location = dockPanel.PointToScreen(rect.Location);
579	if (dock == DockStyle.Top)
580	{
581	int height = dockPanel.GetDockWindowSize(DockState.DockTop);
582	rect = new Rectangle(rect.X, rect.Y, rect.Width, height);
583	}
584	else if (dock == DockStyle.Bottom)
585	{
586	int height = dockPanel.GetDockWindowSize(DockState.DockBottom);
587	rect = new Rectangle(rect.X, rect.Bottom - height, rect.Width, height);
588	}
589	else if (dock == DockStyle.Left)
590	{
591	int width = dockPanel.GetDockWindowSize(DockState.DockLeft);
592	rect = new Rectangle(rect.X, rect.Y, width, rect.Height);
593	}
594	else if (dock == DockStyle.Right)
595	{
596	int width = dockPanel.GetDockWindowSize(DockState.DockRight);
597	rect = new Rectangle(rect.Right - width, rect.Y, width, rect.Height);
598	}
599	else if (dock == DockStyle.Fill)
600	{
601	rect = dockPanel.DocumentWindowBounds;
602	rect.Location = dockPanel.PointToScreen(rect.Location);
603	}
604
605	SetDragForm(rect);
606	}
607
608	private void SetOutline(DockPane pane, DockStyle dock, int contentIndex)
609	{
610	if (dock != DockStyle.Fill)
611	{
612	Rectangle rect = pane.DisplayingRectangle;
613	if (dock == DockStyle.Right)
614	rect.X += rect.Width / 2;
615	if (dock == DockStyle.Bottom)
616	rect.Y += rect.Height / 2;
617	if (dock == DockStyle.Left \|\| dock == DockStyle.Right)
618	rect.Width -= rect.Width / 2;
619	if (dock == DockStyle.Top \|\| dock == DockStyle.Bottom)
620	rect.Height -= rect.Height / 2;
621	rect.Location = pane.PointToScreen(rect.Location);
622
623	SetDragForm(rect);
624	}
625	else if (contentIndex == -1)
626	{
627	Rectangle rect = pane.DisplayingRectangle;
628	rect.Location = pane.PointToScreen(rect.Location);
629	SetDragForm(rect);
630	}
631	else
632	{
633	using (GraphicsPath path = pane.TabStripControl.GetOutline(contentIndex))
634	{
635	RectangleF rectF = path.GetBounds();
636	Rectangle rect = new Rectangle((int)rectF.X, (int)rectF.Y, (int)rectF.Width, (int)rectF.Height);
637	using (Matrix matrix = new Matrix(rect, new Point[] { new Point(0, 0), new Point(rect.Width, 0), new Point(0, rect.Height) }))
638	{
639	path.Transform(matrix);
640	}
641	Region region = new Region(path);
642	SetDragForm(rect, region);
643	}
644	}
645	}
646
647	private void SetDragForm(Rectangle rect)
648	{
649	DragForm.Bounds = rect;
650	if (rect == Rectangle.Empty)
651	DragForm.Region = new Region(Rectangle.Empty);
652	else if (DragForm.Region != null)
653	DragForm.Region = null;
654	}
655
656	private void SetDragForm(Rectangle rect, Region region)
657	{
658	DragForm.Bounds = rect;
659	DragForm.Region = region;
660	}
661	}
662
663	public DockDragHandler(DockPanel panel)
664	: base(panel)
665	{
666	}
667
668	public new IDockDragSource DragSource
669	{
670	get { return base.DragSource as IDockDragSource; }
671	set { base.DragSource = value; }
672	}
673
674	private DockOutlineBase m_outline;
675	public DockOutlineBase Outline
676	{
677	get { return m_outline; }
678	private set { m_outline = value; }
679	}
680
681	private DockIndicator m_indicator;
682	private DockIndicator Indicator
683	{
684	get { return m_indicator; }
685	set { m_indicator = value; }
686	}
687
688	private Rectangle m_floatOutlineBounds;
689	private Rectangle FloatOutlineBounds
690	{
691	get { return m_floatOutlineBounds; }
692	set { m_floatOutlineBounds = value; }
693	}
694
695	public void BeginDrag(IDockDragSource dragSource)
696	{
697	DragSource = dragSource;
698
699	if (!BeginDrag())
700	{
701	DragSource = null;
702	return;
703	}
704
705	Outline = new DockOutline();
706	Indicator = new DockIndicator(this);
707	Indicator.Show(false);
708
709	FloatOutlineBounds = DragSource.BeginDrag(StartMousePosition);
710	}
711
712	protected override void OnDragging()
713	{
714	TestDrop();
715	}
716
717	protected override void OnEndDrag(bool abort)
718	{
719	DockPanel.SuspendLayout(true);
720
721	Outline.Close();
722	Indicator.Close();
723
724	EndDrag(abort);
725
726	// Queue a request to layout all children controls
727	DockPanel.PerformMdiClientLayout();
728
729	DockPanel.ResumeLayout(true, true);
730
731	DragSource.EndDrag();
732
733	DragSource = null;
734	}
735
736	private void TestDrop()
737	{
738	Outline.FlagTestDrop = false;
739
740	Indicator.FullPanelEdge = ((Control.ModifierKeys & Keys.Shift) != 0);
741
742	if ((Control.ModifierKeys & Keys.Control) == 0)
743	{
744	Indicator.TestDrop();
745
746	if (!Outline.FlagTestDrop)
747	{
748	DockPane pane = DockHelper.PaneAtPoint(Control.MousePosition, DockPanel);
749	if (pane != null && DragSource.IsDockStateValid(pane.DockState))
750	pane.TestDrop(DragSource, Outline);
751	}
752
753	if (!Outline.FlagTestDrop && DragSource.IsDockStateValid(DockState.Float))
754	{
755	FloatWindow floatWindow = DockHelper.FloatWindowAtPoint(Control.MousePosition, DockPanel);
756	if (floatWindow != null)
757	floatWindow.TestDrop(DragSource, Outline);
758	}
759	}
760	else
761	Indicator.DockPane = DockHelper.PaneAtPoint(Control.MousePosition, DockPanel);
762
763	if (!Outline.FlagTestDrop)
764	{
765	if (DragSource.IsDockStateValid(DockState.Float))
766	{
767	Rectangle rect = FloatOutlineBounds;
768	rect.Offset(Control.MousePosition.X - StartMousePosition.X, Control.MousePosition.Y - StartMousePosition.Y);
769	Outline.Show(rect);
770	}
771	}
772
773	if (!Outline.FlagTestDrop)
774	{
775	Cursor.Current = Cursors.No;
776	Outline.Show();
777	}
778	else
779	Cursor.Current = DragControl.Cursor;
780	}
781
782	private void EndDrag(bool abort)
783	{
784	if (abort)
785	return;
786
787	if (!Outline.FloatWindowBounds.IsEmpty)
788	DragSource.FloatAt(Outline.FloatWindowBounds);
789	else if (Outline.DockTo is DockPane)
790	{
791	DockPane pane = Outline.DockTo as DockPane;
792	DragSource.DockTo(pane, Outline.Dock, Outline.ContentIndex);
793	}
794	else if (Outline.DockTo is DockPanel)
795	{
796	DockPanel panel = Outline.DockTo as DockPanel;
797	panel.UpdateDockWindowZOrder(Outline.Dock, Outline.FlagFullEdge);
798	DragSource.DockTo(panel, Outline.Dock);
799	}
800	}
801	}
802
803	private DockDragHandler m_dockDragHandler = null;
804	private DockDragHandler GetDockDragHandler()
805	{
806	if (m_dockDragHandler == null)
807	m_dockDragHandler = new DockDragHandler(this);
808	return m_dockDragHandler;
809	}
810
811	internal void BeginDrag(IDockDragSource dragSource)
812	{
813	GetDockDragHandler().BeginDrag(dragSource);
814	}
815	}
816	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Update cookies preferences