コード例 #1
0
		private DockSiteInfo GetDockSiteInfoV(IDockInfo pDock, int x, int y)
		{
			DockSiteInfo pInfo=new DockSiteInfo();
			Rectangle thisRect=new Rectangle(this.PointToScreen(new Point(0,0)),this.Size);
			Point pInsertionPoint=this.PointToClient(new Point(x,y));
			Control objCtrlToDock=pDock as Control;

			System.Drawing.Size objDockSize=pDock.PreferredDockSize(m_DockOrientation);

			if(this.Height==0)
			{
				thisRect.Height=10;
				if(this.Dock==System.Windows.Forms.DockStyle.Bottom)
					thisRect.Y-=10;
			}
			else if(this.Width==0)
			{
				thisRect.Width=10;
				if(this.Dock==System.Windows.Forms.DockStyle.Right)
					thisRect.X-=10;
			}

			// If mouse is not inside exit
			thisRect.Inflate(8,8); // m_DockMargin
			if(!thisRect.Contains(x,y) || pDock==null)
				return pInfo;

			bool bDockedHere=(pDock.DockedSite==this);
			int[] lineCount=new int[255];
			int iMaxDockLine=0;
			int iDockLine=-10;
			bool bDocked=false;
			foreach(Control objCtrl in this.Controls)
			{
				if(!objCtrl.Visible)
					continue;
				IDockInfo pCtrlDockInfo=objCtrl as IDockInfo;
				lineCount[pCtrlDockInfo.DockLine]++;
				iMaxDockLine=pCtrlDockInfo.DockLine;
			}

			int iLockedDockLine=-1;

			for(int i=0;i<this.Controls.Count;i++)
			{
				Control objCtrl=this.Controls[i];
				if(!objCtrl.Visible)
					continue;
				IDockInfo pCtrlDockInfo=objCtrl as IDockInfo;
				if(pInsertionPoint.X>objCtrl.Left+4 && ((pInsertionPoint.X<objCtrl.Left+objDockSize.Width-4 && objDockSize.Width<=objCtrl.Width) || pInsertionPoint.X<objCtrl.Right-4 && objDockSize.Width>objCtrl.Width))
				{
					if(pCtrlDockInfo.Stretch && objCtrl!=objCtrlToDock)
					{
						if(objCtrl is Bar && objCtrlToDock is Bar && ((Bar)objCtrl).LayoutType==eLayoutType.DockContainer && ((Bar)objCtrlToDock).LayoutType==eLayoutType.DockContainer  && ((Bar)objCtrl).CanTearOffTabs)
						{
							if(!objCtrl.Bounds.Contains(pInsertionPoint))
								continue;
							iDockLine=pCtrlDockInfo.DockLine;
							if(((Bar)objCtrl).IsPositionOnDockTab(x,y))
							{
								pInfo.DockLine=pCtrlDockInfo.DockLine;
								pInfo.DockOffset=pCtrlDockInfo.DockOffset;
								pInfo.InsertPosition=i;
								pInfo.objDockSite=this;
								pInfo.DockSide=this.Dock;
								pInfo.TabDockContainer=objCtrl as Bar;
								return pInfo;
							}
						}
						else
						{
							iDockLine=pCtrlDockInfo.DockLine-1;
						}
					}
					else
					{
						iDockLine=pCtrlDockInfo.DockLine;
					}
					break;
				}
				else if(objCtrl==objCtrlToDock && pInsertionPoint.X<=objCtrl.Left+4 && pInsertionPoint.X>objCtrl.Left && lineCount[pCtrlDockInfo.DockLine]>1)
				{
					int iInsertPosition=i;
					for(int iInsertIndex=i-1;iInsertIndex>=0;iInsertIndex--)
					{
						if(((IDockInfo)this.Controls[iInsertIndex]).DockLine==pDock.DockLine)
							iInsertPosition=iInsertIndex;
						else
							break;
					}
					pInfo.DockLine=pDock.DockLine;
					pInfo.DockOffset=pDock.DockOffset;
					pInfo.InsertPosition=iInsertPosition;
					pInfo.objDockSite=this;
					pInfo.DockSide=this.Dock;
					pInfo.NewLine=true;
					return pInfo;
				}
				else if(this.Dock==DockStyle.Left && objCtrl==objCtrlToDock && pInsertionPoint.X>=objCtrl.Right-4 && pInsertionPoint.X<objCtrl.Right && lineCount[pCtrlDockInfo.DockLine]==1 && pDock.DockLine!=iMaxDockLine)
				{
					int iInsertPosition=i;
					for(int iInsertIndex=i+1;iInsertIndex<this.Controls.Count;iInsertIndex++)
					{
						if(((IDockInfo)this.Controls[iInsertIndex]).DockLine==pDock.DockLine+1 && (((IDockInfo)this.Controls[iInsertIndex]).DockOffset<=pDock.DockOffset || pDock.Stretch) || ((IDockInfo)this.Controls[iInsertIndex]).DockLine==pDock.DockLine)
							iInsertPosition=iInsertIndex;
						else
							break;
					}
					pInfo.DockLine=pDock.DockLine+1;
					pInfo.DockOffset=pDock.DockOffset;
					pInfo.InsertPosition=iInsertPosition;
					pInfo.objDockSite=this;
					pInfo.DockSide=this.Dock;
					return pInfo;
				}
			}

			if(iDockLine==-10)
			{
				if(pInsertionPoint.X<=-5 && !(bDockedHere && pDock.DockLine==0 && lineCount[0]==1))
				{
					iDockLine=-1;
				}
				else if(!bDockedHere)
				{
					if(pInsertionPoint.X>this.Width)
						iDockLine=iMaxDockLine+1;
					else
						iDockLine=iMaxDockLine;
				}
				else if(pInsertionPoint.X>this.Width+4 && !(bDockedHere && pDock.DockLine==iMaxDockLine && lineCount[iMaxDockLine]==1))
				{
					iDockLine=iMaxDockLine+1;
				}

				if(iDockLine==-10)
				{
					pInfo.DockLine=pDock.DockLine;
					pInfo.DockOffset=pDock.DockOffset;
					pInfo.InsertPosition=this.Controls.GetChildIndex(objCtrlToDock);
					pInfo.objDockSite=this;
					pInfo.DockSide=this.Dock;
					return pInfo;
				}
			}

			if(iLockedDockLine!=-1)
			{
				if(this.Dock==DockStyle.Top && iDockLine<=iLockedDockLine)
					iDockLine=iLockedDockLine+1;
				else if(this.Dock==DockStyle.Bottom && iDockLine>=iLockedDockLine)
					iDockLine=iLockedDockLine-1;
			}

			// We have the docking line now, find right Docking offset for object to dock

			// First get the index of the docking line, default is at the end
			int iIndex=this.Controls.Count;
			for(int i=0;i<this.Controls.Count;i++)
			{
				Control objCtrl=this.Controls[i];
				if(!objCtrl.Visible)
					continue;
				IDockInfo pCtrlDockInfo=objCtrl as IDockInfo;
				if(pCtrlDockInfo.DockLine>=iDockLine)
				{
					iIndex=i;
					break;
				}
			}

			// Find the right insertion point based on X coordinate
			for(int i=iIndex;i<this.Controls.Count;i++)
			{
				Control objCtrl=this.Controls[i];
				if(!objCtrl.Visible)
					continue;
				IDockInfo pCtrlDockInfo=objCtrl as IDockInfo;
				if(pCtrlDockInfo.DockLine>iDockLine)
				{
					pInfo.InsertPosition=i;
					if(bDockedHere && i>0 && this.Controls.GetChildIndex(objCtrlToDock)<i)
						pInfo.InsertPosition=i-1;
					if(pInsertionPoint.Y+objDockSize.Height>this.Height)
						pInfo.DockOffset=this.Height-objDockSize.Height;
					else
						pInfo.DockOffset=pInsertionPoint.Y;
					pInfo.DockLine=iDockLine;
					pInfo.DockSide=this.Dock;
					pInfo.objDockSite=this;
					bDocked=true;
					break;
				}
				if(objCtrl.Bounds.Contains(pInsertionPoint))
				{
					if(objCtrl!=objCtrlToDock)
					{
						if(pInsertionPoint.Y>=objCtrl.Top && pInsertionPoint.Y<=objCtrl.Top+10)
						{
							// This is right position, insert before docked control
							pInfo.InsertPosition=i;
							if(bDockedHere && i>0 && this.Controls.GetChildIndex(objCtrlToDock)<i)
								pInfo.InsertPosition=i-1;
							pInfo.DockOffset=0;
							pInfo.DockLine=iDockLine;
							pInfo.DockSide=this.Dock;
							pInfo.objDockSite=this;
						}
						else
						{
							// Insert after docked control
							int iTmp=getDockLineHeight(i,iDockLine,false);
							if(iTmp+objDockSize.Height>=this.Height || pInsertionPoint.Y<iTmp)
								pInfo.DockOffset=objCtrl.Bottom;
							else
								pInfo.DockOffset=pInsertionPoint.Y;
							
							pInfo.InsertPosition=i+1;

							if(pDock.Stretch)
							{
								//if(iDockLine<iMaxDockLine)
								//	iDockLine++;
								pInfo.DockOffset=pDock.DockOffset;
							}
							if(bDockedHere && i>0 && this.Controls.GetChildIndex(objCtrlToDock)<i)
								pInfo.InsertPosition=i;

							pInfo.DockLine=iDockLine;
							pInfo.DockSide=this.Dock;
							pInfo.objDockSite=this;
						}
					}
					else
					{
						// This just tries to move control to the right, insertion point is over the object that needs to be docked
						pInfo.InsertPosition=i;
						pInfo.DockLine=iDockLine;
						pInfo.DockSide=this.Dock;
						pInfo.objDockSite=this;

						int iTmp=getDockLineHeight(i+1,pDock.DockLine,true);
						
						if(iTmp+objDockSize.Height+pInsertionPoint.Y>=this.Height)
							pInfo.DockOffset=this.Height-iTmp-objDockSize.Height;
						else
							pInfo.DockOffset=pInsertionPoint.Y;

						if(pInfo.DockOffset<0)
							pInfo.DockOffset=0;
					}
					bDocked=true;
					break;
				}
				else if(pInsertionPoint.Y<objCtrl.Top || pInsertionPoint.X<objCtrl.Left && iLockedDockLine<0)
				{
					// Dock it before this control, insertion point is in empty space before docked control
					pInfo.InsertPosition=i;
					if(bDockedHere && i>0 && this.Controls.GetChildIndex(objCtrlToDock)<i)
						pInfo.InsertPosition=i-1;
					if(pDock.Stretch)
						pInfo.DockOffset=pDock.DockOffset;
					else
						pInfo.DockOffset=pInsertionPoint.Y;
					pInfo.DockLine=iDockLine;
					pInfo.DockSide=this.Dock;
					pInfo.objDockSite=this;
					bDocked=true;
					break;
				}
			}

			if(!bDocked)
			{
				// Add it to the end
				if(iDockLine>=0)
				{
					if(bDockedHere)
						pInfo.InsertPosition=this.Controls.Count-1;
					else
						pInfo.InsertPosition=this.Controls.Count;

				}
				else
					pInfo.InsertPosition=0;

				if(pInsertionPoint.Y+objDockSize.Height>this.Height)
					pInfo.DockOffset=this.Height-objDockSize.Height;
				else
					pInfo.DockOffset=pInsertionPoint.Y;
				if(iDockLine>=0)
				{
					pInfo.DockLine=iDockLine;
				}
				else
					pInfo.DockLine=-1;

				pInfo.DockSide=this.Dock;
				pInfo.objDockSite=this;
			}

			// Snap it to the left
			if(pInfo.DockOffset<10)
				pInfo.DockOffset=0;

			if(m_DockOrientation==eOrientation.Horizontal)
			{
				if(objDockSize.Width>this.Width)
					pInfo.DockedWidth=this.Width;
				else
					pInfo.DockedWidth=objDockSize.Width;

				pInfo.DockedHeight=objDockSize.Height;
			}
			else
			{
				if(objDockSize.Height>this.Height)
					pInfo.DockedHeight=this.Height;
				else
					pInfo.DockedHeight=objDockSize.Height;

				pInfo.DockedWidth=objDockSize.Width;
			}

			return pInfo;
		}
コード例 #2
0
		/*private void GetInsertPointAbove(ref DockSiteInfo pInfo, int iStartFrom, int iAboveLine, int iPosX, int iItemWidth, int iCtrlToDockIndex)
		{
			pInfo.InsertPosition=0;
			pInfo.DockLine=iAboveLine-1;

			if(iStartFrom==0 || iAboveLine==0)
			{
				// This is easy case
				if(iPosX+iItemWidth>this.Width)
				{
					pInfo.DockOffset=this.Width-iItemWidth;
					if(pInfo.DockOffset<0)
						pInfo.DockOffset=0;
				}
				else
					pInfo.DockOffset=iPosX;
				return;
			}

			// We will need to scan to find right insertion point
			Control objCtrl;
			IDockInfo pCtrlDockInfo;
			pInfo.InsertPosition=-1;
			int iStopIndex=0;
			if(iCtrlToDockIndex>0 && iCtrlToDockIndex<iStartFrom)
				iStopIndex=iCtrlToDockIndex;

			for(int i=iStartFrom;i>=iStopIndex;i--)
			{
				objCtrl=this.Controls[i];
				pCtrlDockInfo=objCtrl as IDockInfo;
				if(pCtrlDockInfo.DockLine==iAboveLine-1)
				{
					// Mouse inside this control, add after it
					if(objCtrl.Left<iPosX)
					{
						pInfo.InsertPosition=i+1;
					}
					else
					{
						// Mouse on the left side of the control, add before it
						if(i>0)
							pInfo.InsertPosition=i-1;
						break;
					}
					pInfo.DockOffset=iPosX;
				}
				else if(pCtrlDockInfo.DockLine<iAboveLine)
					break;
			}

			if(pInfo.InsertPosition<0)
			{
				// Could not determine it
				GetInsertPointAbove(ref pInfo,0,0,iPosX,iItemWidth,iCtrlToDockIndex);
			}
		}*/

		/*private void GetInsertPointBelow(ref DockSiteInfo pInfo, int iStartFrom, int iBelowLine, int iPosX, int iItemWidth, int iCtrlToDockIndex)
		{
			pInfo.InsertPosition=0;
			pInfo.DockLine=iBelowLine+1;
			int iStopIndex=this.Controls.Count;

			if(iStartFrom==this.Controls.Count)
			{
				// This is easy case
				if(iPosX+iItemWidth>this.Width)
				{
					pInfo.DockOffset=this.Width-iItemWidth;
					if(pInfo.DockOffset<0)
						pInfo.DockOffset=0;
				}
				else
					pInfo.DockOffset=iPosX;
				pInfo.InsertPosition=this.Controls.Count;

				return;
			}

			// We will need to scan to find right insertion point
			Control objCtrl;
			
			if(iCtrlToDockIndex>0)
				iStopIndex=iCtrlToDockIndex;
			
			objCtrl=null;
			IDockInfo pCtrlDockInfo;
			pInfo.InsertPosition=-1;
			for(int i=iStartFrom;i<iStopIndex;i++)
			{
				objCtrl=this.Controls[i];
				pCtrlDockInfo=objCtrl as IDockInfo;
				if(pCtrlDockInfo.DockLine==iBelowLine+1)
				{
					// Mouse inside this control, add after it
					if(objCtrl.Left<iPosX)
					{
						pInfo.InsertPosition=i+1;
					}
					else
					{
						// Mouse on the left side of the control, add before it
						if(i>0)
							pInfo.InsertPosition=i;
						break;
					}
					pInfo.DockOffset=iPosX;
				}
				else if(pCtrlDockInfo.DockLine>iBelowLine)
					break;
			}

			if(pInfo.InsertPosition<0)
			{
				// Could not determine it
				GetInsertPointBelow(ref pInfo,this.Controls.Count,iBelowLine,iPosX,iItemWidth,iCtrlToDockIndex);
			}
		}*/

		/// <summary>
		/// Returns the docking information for current position.
		/// </summary>
		/// <param name="pDock">Controls docking provider.</param>
		/// <param name="x">Horizontal assumed docking position.</param>
		/// <param name="y">Vertical assumed docking position.</param>
		/// <returns>Docking information.</returns>
		public DockSiteInfo GetDockSiteInfo(IDockInfo pDock, int x, int y)
		{
			if(m_DockOrientation==eOrientation.Horizontal)
			{
				return GetDockSiteInfoH(pDock,x,y);
			}
			else
			{
				return GetDockSiteInfoV(pDock,x,y);
			}
		}
コード例 #3
0
        private void SetupDockingHintWindows(Bar barMouseOver, IDockInfo barDockInfo)
		{
			Rectangle parentFormScreenRect=Rectangle.Empty;
			const int HINT_EDGE_OFFSET=32;
			if(m_TopDockSite.Parent.Parent!=null)
			{
				parentFormScreenRect=new Rectangle(m_TopDockSite.Parent.PointToScreen(Point.Empty),m_TopDockSite.Parent.Size);
				parentFormScreenRect.Y+=m_TopDockSite.Height;
				parentFormScreenRect.Height-=m_TopDockSite.Height;
			}
			else
			{
				parentFormScreenRect=m_TopDockSite.Parent.Bounds;
				parentFormScreenRect.Y+=m_TopDockSite.Height;
				parentFormScreenRect.Height-=m_TopDockSite.Height;
			}

			if(!this.DesignMode)
			{
				// Left Docking Hint
				if(barDockInfo.CanDockLeft)
				{
					if(m_DockingHintLeft==null)
					{
						m_DockingHintLeft=new DockingHint(eDockingHintSide.Left, GetEffectiveStyle());
						m_DockingHintLeft.Location=new Point(parentFormScreenRect.X+HINT_EDGE_OFFSET,parentFormScreenRect.Y+(parentFormScreenRect.Height-m_DockingHintLeft.Height)/2);
						m_DockingHintLeft.ShowFocusless();
					}
				}
				else if(m_DockingHintLeft!=null)
				{
					m_DockingHintLeft.Close();
					m_DockingHintLeft.Dispose();
					m_DockingHintLeft=null;
				}

				// Right Docking Hint
				if(barDockInfo.CanDockRight)
				{
					if(m_DockingHintRight==null)
					{
						m_DockingHintRight=new DockingHint(eDockingHintSide.Right, GetEffectiveStyle());
						m_DockingHintRight.Location=new Point(parentFormScreenRect.Right-HINT_EDGE_OFFSET-m_DockingHintRight.Width,parentFormScreenRect.Y+(parentFormScreenRect.Height-m_DockingHintRight.Height)/2);
						m_DockingHintRight.ShowFocusless();
					}
				}
				else if(m_DockingHintRight!=null)
				{
					m_DockingHintRight.Close();
					m_DockingHintRight.Dispose();
					m_DockingHintRight=null;
				}

				// Top Docking Hint
				if(barDockInfo.CanDockTop)
				{
					if(m_DockingHintTop==null)
					{
						m_DockingHintTop=new DockingHint(eDockingHintSide.Top, GetEffectiveStyle());
						m_DockingHintTop.Location=new Point(parentFormScreenRect.X+(parentFormScreenRect.Width-m_DockingHintTop.Width)/2,parentFormScreenRect.Y+HINT_EDGE_OFFSET);
						m_DockingHintTop.ShowFocusless();
					}
				}
				else if(m_DockingHintTop!=null)
				{
					m_DockingHintTop.Close();
					m_DockingHintTop.Dispose();
					m_DockingHintTop=null;
				}

				// Bottom Docking Hint
				if(barDockInfo.CanDockBottom)
				{
					if(m_DockingHintBottom==null)
					{
						m_DockingHintBottom=new DockingHint(eDockingHintSide.Bottom, GetEffectiveStyle());
						m_DockingHintBottom.Location=new Point(parentFormScreenRect.X+(parentFormScreenRect.Width-m_DockingHintBottom.Width)/2,parentFormScreenRect.Bottom-HINT_EDGE_OFFSET-m_DockingHintBottom.Height);
						m_DockingHintBottom.ShowFocusless();
					}
				}
				else if(m_DockingHintBottom!=null)
				{
					m_DockingHintBottom.Close();
					m_DockingHintBottom.Dispose();
					m_DockingHintBottom=null;
				}
			}

			// Middle docking hint
			bool bShowMidHint=false;
			eDockingHintSide hintSides=eDockingHintSide.All;
			if(barMouseOver==null)
			{
				hintSides=eDockingHintSide.Top;
				if(barDockInfo.CanDockBottom)
					hintSides=eDockingHintSide.Bottom;
				if(barDockInfo.CanDockLeft)
					hintSides=hintSides | eDockingHintSide.Left;
				if(barDockInfo.CanDockRight)
					hintSides=hintSides | eDockingHintSide.Right;
				if(barDockInfo.CanDockTop)
					hintSides=hintSides | eDockingHintSide.Top;
				else
					hintSides=hintSides & ~(hintSides & eDockingHintSide.Top);
				if(this.IsDocumentDockingEnabled && barDockInfo.CanDockDocument)
				{
					hintSides=eDockingHintSide.All;
				}
			}
			else
			{
				if(!barDockInfo.CanDockTab)
					hintSides=hintSides & ~(hintSides & eDockingHintSide.DockTab);
			}
			
			if(m_DockingHintMiddle==null)
			{
				if(barMouseOver!=null)
					m_DockingHintMiddle=new DockingHint(hintSides,true, GetEffectiveStyle());
				else
                    m_DockingHintMiddle = new DockingHint(hintSides, true, GetEffectiveStyle());
				bShowMidHint=true;
			}
			else
			{
				if(barMouseOver!=null)
					m_DockingHintMiddle.DockingHintSides=hintSides; // eDockingHintSide.All;
				else
					m_DockingHintMiddle.DockingHintSides=hintSides; //eDockingHintSide.Sides;
			}

			Point midLocation=new Point(parentFormScreenRect.X+(parentFormScreenRect.Width-m_DockingHintMiddle.Width)/2,
				parentFormScreenRect.Y+(parentFormScreenRect.Height-m_DockingHintMiddle.Height)/2);

			if(barMouseOver!=null)
			{
				Point p=barMouseOver.PointToScreen(Point.Empty);
				midLocation=new Point(p.X+(barMouseOver.Width-m_DockingHintMiddle.Width)/2,
					p.Y+(barMouseOver.Height-m_DockingHintMiddle.Height)/2);
			}

			Rectangle r=new Rectangle(midLocation,m_DockingHintMiddle.Size);
			if(m_DockingHintLeft!=null && r.IntersectsWith(m_DockingHintLeft.Bounds))
			{
				if(Control.MousePosition.Y<m_DockingHintLeft.Top)
					midLocation.Y=m_DockingHintLeft.Top-m_DockingHintMiddle.Height;
				else
					midLocation.Y=m_DockingHintLeft.Bottom;
			}
			else if(m_DockingHintRight!=null && r.IntersectsWith(m_DockingHintRight.Bounds))
			{
				if(Control.MousePosition.Y<m_DockingHintRight.Top)
					midLocation.Y=m_DockingHintRight.Top-m_DockingHintMiddle.Height;
				else
					midLocation.Y=m_DockingHintRight.Bottom;
			}
			else if(m_DockingHintTop!=null && r.IntersectsWith(m_DockingHintTop.Bounds))
			{
				if(Control.MousePosition.X>m_DockingHintTop.Left)
					midLocation.X=m_DockingHintTop.Right;
				else
					midLocation.X=m_DockingHintTop.Left-m_DockingHintMiddle.Width;
			}
			else if(m_DockingHintBottom!=null && r.IntersectsWith(m_DockingHintBottom.Bounds))
			{
				if(Control.MousePosition.X>m_DockingHintBottom.Left)
					midLocation.X=m_DockingHintBottom.Right;
				else
					midLocation.X=m_DockingHintBottom.Left-m_DockingHintMiddle.Width;
			}

			if(m_DockingHintMiddle.Location!=midLocation)
			{
				m_DockingHintMiddle.Location=midLocation;
			}

			if(bShowMidHint)
			{
				m_DockingHintMiddle.ShowFocusless();
			}

		}
コード例 #4
0
		private bool DockingHintHandler(ref DockSiteInfo dockInfo, IDockInfo barDockInfo, int x, int y)
		{
			if(!m_DockingHintSetup)
			{
				m_DockingHintSetup=true;
				return true;
			}
			// Determine whether mouse is inside of any of our bars
			Bar barMouseOver=null;
			foreach(Bar bar in this.Bars)
			{
				if(bar.Visible && (bar!=barDockInfo || this.DesignMode || bar.DockSide==eDockSide.Document))
				{
					Point p=bar.PointToClient(new Point(x,y));
					if(bar.LayoutType==eLayoutType.DockContainer && bar.ClientRectangle.Contains(p) && bar.DockSide!=eDockSide.None && CanDockToBar(barDockInfo, bar))
					{
						barMouseOver=bar;
						break;
					}
				}
			}

			// Setup Docking Hints Windows
			SetupDockingHintWindows(barMouseOver,barDockInfo);

			bool bMiddleDockHint=false;
			dockInfo.DockSiteZOrderIndex=-1;

			eMouseOverHintSide dockHintSide=eMouseOverHintSide.None;
			if(m_DockingHintLeft!=null)
			{
				dockHintSide=m_DockingHintLeft.ExMouseMove(x,y);
			}
			if(m_DockingHintRight!=null)
			{
				eMouseOverHintSide ds=m_DockingHintRight.ExMouseMove(x,y);
				if(dockHintSide==eMouseOverHintSide.None)
					dockHintSide=ds;
			}
			if(m_DockingHintTop!=null)
			{
				eMouseOverHintSide ds=m_DockingHintTop.ExMouseMove(x,y);
				if(dockHintSide==eMouseOverHintSide.None)
					dockHintSide=ds;
			}
			if(m_DockingHintBottom!=null)
			{
				eMouseOverHintSide ds=m_DockingHintBottom.ExMouseMove(x,y);
				if(dockHintSide==eMouseOverHintSide.None)
					dockHintSide=ds;
			}
			if(m_DockingHintMiddle!=null)
			{
				eMouseOverHintSide ds=m_DockingHintMiddle.ExMouseMove(x,y);
				if(dockHintSide==eMouseOverHintSide.None)
				{
					dockHintSide=ds;
					if(ds!=eMouseOverHintSide.None)
						bMiddleDockHint=true;
					if(bMiddleDockHint && this.IsDocumentDockingEnabled && barDockInfo.CanDockDocument && barMouseOver==null && barDockInfo.CanDockDocument)
					{
						if(!barDockInfo.CanDockTop && ds==eMouseOverHintSide.Top)
							dockHintSide=eMouseOverHintSide.DockTab;
						else if(!barDockInfo.CanDockBottom && ds==eMouseOverHintSide.Bottom)
							dockHintSide=eMouseOverHintSide.DockTab;
						else if(!barDockInfo.CanDockLeft && ds==eMouseOverHintSide.Left)
							dockHintSide=eMouseOverHintSide.DockTab;
						else if(!barDockInfo.CanDockRight && ds==eMouseOverHintSide.Right)
							dockHintSide=eMouseOverHintSide.DockTab;
					}
				}
			}
			
			dockInfo.MouseOverBar=barMouseOver;
			if(barMouseOver==null || !bMiddleDockHint)
			{
				if(m_EnableFullSizeDock)
				{
					dockInfo.FullSizeDock=!bMiddleDockHint;
					dockInfo.PartialSizeDock=bMiddleDockHint;
				}
				switch(dockHintSide)
				{
					case eMouseOverHintSide.Left:
					{
                        dockInfo.MouseOverDockSide = eDockSide.Left;
						if(barDockInfo.DockSide!=eDockSide.Left)
						{
							dockInfo.DockSide=DockStyle.Left;
                            if (bMiddleDockHint)
                            {
                                dockInfo.DockLine = 999;
                                dockInfo.InsertPosition = 999;
                            }
                            else
                            {
                                dockInfo.DockLine = -1;
                                dockInfo.InsertPosition = 0;
                            }
                            dockInfo.NewLine = true;
						}
						else
						{
							dockInfo.DockSide=DockStyle.Left;
							dockInfo.DockLine=barDockInfo.DockLine;
							dockInfo.DockOffset=barDockInfo.DockOffset;
							dockInfo.InsertPosition=m_LeftDockSite.Controls.IndexOf(barDockInfo as Control);
						}
						dockInfo.objDockSite=m_LeftDockSite;
						break;
					}
					case eMouseOverHintSide.Right:
					{
                        dockInfo.MouseOverDockSide = eDockSide.Right;
						if(barDockInfo.DockSide!=eDockSide.Right)
						{
							dockInfo.DockSide=DockStyle.Right;
                            if (bMiddleDockHint)
                            {
                                dockInfo.DockLine = -1;
                                dockInfo.InsertPosition = 0;
                            }
                            else
                            {
                                dockInfo.DockLine = 999;
                                dockInfo.InsertPosition = 999;
                            }
                            dockInfo.NewLine = true;
						}
						else
						{
							dockInfo.DockSide=DockStyle.Right;
							dockInfo.DockLine=barDockInfo.DockLine;
							dockInfo.DockOffset=barDockInfo.DockOffset;
							dockInfo.InsertPosition=m_RightDockSite.Controls.IndexOf(barDockInfo as Control);
						}
						dockInfo.objDockSite=m_RightDockSite;
						break;
					}
				
					case eMouseOverHintSide.Top:
					{
                        dockInfo.MouseOverDockSide = eDockSide.Top;
						if(barDockInfo.DockSide!=eDockSide.Top)
						{
							dockInfo.DockSide=DockStyle.Top;
                            if (bMiddleDockHint)
                            {
                                dockInfo.DockLine = 999;
                                dockInfo.InsertPosition = 999;
                            }
                            else
                            {
                                dockInfo.DockLine = -1;
                                dockInfo.InsertPosition = 0;
                            }
							
                            dockInfo.NewLine = true;
						}
						else
						{
							dockInfo.DockSide=DockStyle.Top;
							dockInfo.DockLine=barDockInfo.DockLine;
							dockInfo.DockOffset=barDockInfo.DockOffset;
							dockInfo.InsertPosition=m_TopDockSite.Controls.IndexOf(barDockInfo as Control);
						}
						dockInfo.objDockSite=m_TopDockSite;
						break;
					}
					case eMouseOverHintSide.Bottom:
					{
                        dockInfo.MouseOverDockSide = eDockSide.Bottom;
						if(barDockInfo.DockSide!=eDockSide.Bottom)
						{
							dockInfo.DockSide=DockStyle.Bottom;
                            if (bMiddleDockHint)
                            {
                                dockInfo.DockLine = -1;
                                dockInfo.InsertPosition = 0;
                            }
                            else
                            {
                                dockInfo.DockLine = 999;
                                dockInfo.InsertPosition = 999;
                            }
							dockInfo.NewLine=true;
						}
						else
						{
							dockInfo.DockSide=DockStyle.Bottom;
							dockInfo.DockLine=barDockInfo.DockLine;
							dockInfo.DockOffset=barDockInfo.DockOffset;
							dockInfo.InsertPosition=m_BottomDockSite.Controls.IndexOf(barDockInfo as Control);
						}
						dockInfo.objDockSite=m_BottomDockSite;
						break;
					}
					case eMouseOverHintSide.DockTab:
					{
						if(this.IsDocumentDockingEnabled)
						{
							dockInfo.objDockSite=m_FillDockSite;
							dockInfo.DockSide=DockStyle.Fill;
							dockInfo.MouseOverDockSide=eDockSide.Document;
						}
						break;
					}
				}
			}
			else
			{
				switch(dockHintSide)
				{
					case eMouseOverHintSide.DockTab:
					{
						dockInfo.MouseOverDockSide=eDockSide.Document;
						if(barMouseOver!=null)
						{
							//if(((Bar)barDockInfo).TempTabBar==barMouseOver)
							{
								dockInfo.TabDockContainer=barMouseOver;
								dockInfo.DockSide=barMouseOver.Parent.Dock;
								dockInfo.objDockSite=barMouseOver.Parent as DockSite;
							}
//							else
//							{
//								if(barDockInfo.DockSide!=eDockSide.None)
//								{
//									dockInfo.DockSide=barMouseOver.Parent.Dock;
//									dockInfo.objDockSite=barMouseOver.Parent as DockSite;
//									dockInfo.DockLine=barDockInfo.DockLine;
//									dockInfo.DockOffset=barDockInfo.DockOffset;
//								}
//								else
//								{
//									dockInfo.TabDockContainer=barMouseOver;
//								}
//							}
						}
						break;
					}
					case eMouseOverHintSide.Right:
					{
						dockInfo.MouseOverDockSide=eDockSide.Right;
						dockInfo.DockSide=barMouseOver.Parent.Dock;
						dockInfo.objDockSite=barMouseOver.DockedSite as DockSite;
						switch(barMouseOver.DockSide)
						{
							case eDockSide.Top:
							case eDockSide.Bottom:
							{
                                dockInfo.DockLine = 0; // barMouseOver.DockLine;
								dockInfo.InsertPosition=barMouseOver.Parent.Controls.IndexOf(barMouseOver)+1;
								dockInfo.DockOffset=barMouseOver.DockOffset+1;
								break;
							}
							default:
							{
								dockInfo.DockLine=barMouseOver.DockLine+1;
								dockInfo.InsertPosition=barMouseOver.Parent.Controls.IndexOf(barMouseOver);
								dockInfo.InsertPosition++;
								dockInfo.NewLine=true;
								break;
							}
						}
						break;
					}
					case eMouseOverHintSide.Left:
					{
						dockInfo.MouseOverDockSide=eDockSide.Left;
						dockInfo.DockSide=barMouseOver.Parent.Dock;
						dockInfo.objDockSite=barMouseOver.DockedSite as DockSite;
						switch(barMouseOver.DockSide)
						{
							case eDockSide.Top:
							case eDockSide.Bottom:
							{
                                dockInfo.DockLine = 0; // barMouseOver.DockLine;
								dockInfo.InsertPosition=barMouseOver.Parent.Controls.IndexOf(barMouseOver);
								dockInfo.DockOffset=barMouseOver.DockOffset-1;
								break;
							}
							default:
							{
                                dockInfo.DockLine = 0; // barMouseOver.DockLine - 1;
								dockInfo.InsertPosition=barMouseOver.Parent.Controls.IndexOf(barMouseOver);
								dockInfo.NewLine=true;
								break;
							}
						}
						break;
					}
					case eMouseOverHintSide.Top:
					{
						dockInfo.MouseOverDockSide=eDockSide.Top;
						dockInfo.DockSide=barMouseOver.Parent.Dock;
						dockInfo.objDockSite=barMouseOver.DockedSite as DockSite;
						switch(barMouseOver.DockSide)
						{
							case eDockSide.Top:
							case eDockSide.Bottom:
							{
                                dockInfo.DockLine = 0; // barMouseOver.DockLine - 1;
								dockInfo.InsertPosition=barMouseOver.Parent.Controls.IndexOf(barMouseOver);
								dockInfo.NewLine=true;
								break;
							}
							default:
							{
                                dockInfo.DockLine = 0;// barMouseOver.DockLine;
								dockInfo.InsertPosition=barMouseOver.Parent.Controls.IndexOf(barMouseOver);
								dockInfo.DockOffset=barMouseOver.DockOffset-1;
								break;
							}
						}
						break;
					}
					case eMouseOverHintSide.Bottom:
					{
						dockInfo.MouseOverDockSide=eDockSide.Bottom;
						dockInfo.DockSide=barMouseOver.Parent.Dock;
						dockInfo.objDockSite=barMouseOver.DockedSite as DockSite;
						switch(barMouseOver.DockSide)
						{
							case eDockSide.Top:
							case eDockSide.Bottom:
							{
								dockInfo.DockLine=barMouseOver.DockLine+1;
								dockInfo.InsertPosition=barMouseOver.Parent.Controls.IndexOf(barMouseOver);
								if(barMouseOver.DockSide==eDockSide.Bottom)
									dockInfo.InsertPosition++;
								dockInfo.NewLine=true;
								break;
							}
							default:
							{
                                dockInfo.DockLine = 0; // barMouseOver.DockLine;
								dockInfo.InsertPosition=barMouseOver.Parent.Controls.IndexOf(barMouseOver)+1;
								dockInfo.DockOffset=barMouseOver.DockOffset+1;
								break;
							}
						}
						break;
					}
				}
			}

			dockInfo.UseOutline=true;
			return true;
		}
コード例 #5
0
		private bool CanDockToBar(IDockInfo barDockInfo, Bar referenceBar)
		{
            if (!referenceBar.AcceptDropItems)
                return false;

			if(referenceBar.DockSide==eDockSide.Bottom && !barDockInfo.CanDockBottom)
				return false;
			if(referenceBar.DockSide==eDockSide.Left && !barDockInfo.CanDockLeft)
				return false;
			if(referenceBar.DockSide==eDockSide.Right && !barDockInfo.CanDockRight)
				return false;
			if(referenceBar.DockSide==eDockSide.Document && !barDockInfo.CanDockDocument)
				return false;
			if(referenceBar.DockSide==eDockSide.Top && !barDockInfo.CanDockTop)
				return false;

			return true;
		}
コード例 #6
0
		DockSiteInfo IOwnerBarSupport.GetDockInfo(IDockInfo pDock, int x, int y)
		{
			DockSiteInfo objRet=new DockSiteInfo();

			// Prevent Docking if Ctrl key is pressed
			if((Control.ModifierKeys & Keys.Control)!=0)
				return objRet;

			if(((Bar)pDock).LayoutType==eLayoutType.DockContainer)
			{
                if (pDock.CanDockBottom || pDock.CanDockLeft || pDock.CanDockRight || pDock.CanDockTop || pDock.CanDockDocument)
                {
                    if (DockingHintHandler(ref objRet, pDock, x, y))
                        return objRet;
                }
                return objRet;
			}

			if(pDock.CanDockTop && m_ToolbarTopDockSite!=null)
			{
                objRet = m_ToolbarTopDockSite.GetDockSiteInfo(pDock, x, y);
				if(objRet.objDockSite!=null)
					return objRet;
			}

			if(pDock.CanDockBottom && m_ToolbarBottomDockSite!=null)
			{
                objRet = m_ToolbarBottomDockSite.GetDockSiteInfo(pDock, x, y);
				if(objRet.objDockSite!=null)
					return objRet;
			}

			if(pDock.CanDockLeft && m_ToolbarLeftDockSite!=null)
			{
                objRet = m_ToolbarLeftDockSite.GetDockSiteInfo(pDock, x, y);
				if(objRet.objDockSite!=null)
					return objRet;
			}

			if(pDock.CanDockRight && m_ToolbarRightDockSite!=null)
			{
                objRet = m_ToolbarRightDockSite.GetDockSiteInfo(pDock, x, y);
				if(objRet.objDockSite!=null)
					return objRet;
			}

			return objRet;
		}