axsidebar.cs

SharpDevelop2.0.0 c#开发免费工具

			base.OnMouseMove(e);
			mousePosition = new Point(e.X, e.Y);
			if (e.Button == MouseButtons.Left) {
				int tab = -1;
				for (int i = 0; i < sideTabs.Count; ++i) {
					if (sideTabs[i].SideTabStatus == SideTabStatus.Selected) {
						tab = i;
						break;
					}
				}
				
				if (tab != -1) {
					if (IsDragStarted(mouseDownPosition, e.Location)) {
						Tabs.DragOverTab = Tabs[tab];
						DoDragDrop(Tabs.DragOverTab, DragDropEffects.All);
					}
					Refresh();
				}
			}
		}
		
		internal static bool IsDragStarted(Point mouseDownPos, Point mouseMovePos)
		{
			Size dragSize = SystemInformation.DragSize;
			if (dragSize.Width < 3) dragSize.Width = 3;
			if (dragSize.Height < 3) dragSize.Height = 3;
			mouseDownPos.Offset(-dragSize.Width / 2, -dragSize.Width / 2);
			Rectangle r = new Rectangle(mouseDownPos, dragSize);
			return !r.Contains(mouseMovePos);
		}
		
		//
		//	protected override void OnLostFocus(EventArgs e)
		//	{
		//		base.OnLostFocus(e);
		//		ExitRenameMode();
		//		Refresh();
		//	}
		
		protected override void OnMouseWheel(MouseEventArgs e)
		{
			base.OnMouseWheel(e);
			if (scrollBar.Visible) {
				int newvalue;
				
				if (System.Windows.Forms.SystemInformation.MouseWheelScrollLines > 0) {
					newvalue = scrollBar.Value - Math.Sign(e.Delta) * System.Windows.Forms.SystemInformation.MouseWheelScrollLines;
				} else {
					newvalue = scrollBar.Value - Math.Sign(e.Delta) * scrollBar.LargeChange;
				}
				scrollBar.Value = Math.Max(scrollBar.Minimum, Math.Min(scrollBar.Maximum, newvalue));
				ScrollBarScrolled(null, null);
			}
		}
		
		Point mouseDownPosition;
		
		protected override void OnMouseDown(MouseEventArgs e)
		{
			base.OnMouseDown(e);
			if (e.Button == MouseButtons.Left) {
				mouseDownPosition = e.Location;
				
				AxSideTab tab = GetTabAt(e.X, e.Y);
				if (tab != null) {
					mouseDownTab = tab;
					tab.SideTabStatus = SideTabStatus.Selected;
					Refresh();
				}
			}
		}
		AxSideTab mouseDownTab = null;
		
		protected override void OnMouseUp(MouseEventArgs e)
		{
			if (mouseDownTab != null) {
				ActiveTab    = mouseDownTab;
				mouseDownTab.SideTabStatus = SideTabStatus.Normal;
				mouseDownTab = null;
			}
			
			ExitRenameMode();
			Refresh();
			base.OnMouseUp(e);
		}
		
		Rectangle activeTabMemberArea;
		
		protected override void OnPaint(PaintEventArgs e)
		{
			Graphics g = e.Graphics;
			int i = 0;
			
			int lastUpperY = 0;
			
			for (; i < sideTabs.Count; ++i) {
				AxSideTab tab = sideTabs[i];
				
				int yPos = i * (Font.Height + 4 + 1);
				tab.DrawTabHeader(g, Font, new Point(0, yPos), Width);
				lastUpperY = yPos + Font.Height + 4;
				
				if (tab == activeTab) {
					break;
				}
			}
			
			int bottom = Height;
			
			for (int j = sideTabs.Count - 1; j > i; --j) {
				AxSideTab tab = sideTabs[j];
				
				int yPos = Height - (-j + sideTabs.Count ) * (Font.Height + 4 + 1);
				
				if (yPos < lastUpperY + (Font.Height + 4 + 1))
					break;
				
				bottom = yPos;
				tab.DrawTabHeader(g, Font, new Point(0, yPos), Width);
			}
			
			if (activeTab != null) {
				bool b = scrollBar.Maximum > (bottom - lastUpperY) / 20 || scrollBar.Value != 0;
				scrollBar.Visible  = b;
				activeTabMemberArea = new Rectangle(0, lastUpperY,
				                                    Width - (scrollBar.Visible ? (SystemInformation.VerticalScrollBarWidth) : 0)  - 4, bottom - lastUpperY);
				sideTabContent.Bounds  = activeTabMemberArea;
				scrollBar.Location     = new Point(Width - SystemInformation.VerticalScrollBarWidth - 4,
				                                   lastUpperY);
				scrollBar.Width    = SystemInformation.VerticalScrollBarWidth;
				scrollBar.Height   = activeTabMemberArea.Height;
			}
		}
		
		
		void ScrollBarScrolled(object sender, ScrollEventArgs e)
		{
			activeTab.ScrollIndex = scrollBar.Value;
			sideTabContent.Refresh();
		}
		
		protected class SideTabContent : UserControl
		{
			AxSideBar sideBar = null;
			Point   mousePosition;
			
			public AxSideBar SideBar {
				get {
					return sideBar;
				}
				set {
					sideBar = value;
				}
			}
			
			public SideTabContent()
			{
				ResizeRedraw = true;
				AllowDrop = true;
				
				SetStyle(ControlStyles.UserPaint, true);
				SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
				SetStyle(ControlStyles.AllPaintingInWmPaint, true);
				SetStyle(ControlStyles.CacheText, true);
			}
			
			
			////////////////////////////////////////////////////////////////////////////////
			
			protected override void OnPaint(PaintEventArgs e)
			{
				if (sideBar != null) {
					sideBar.activeTab.DrawTabContent(e.Graphics, Font, new Rectangle(0, 0, Width, Height));
				}
			}
			
			////////////////////////////////////////////////////////////////////////////
			// Drag and Drop
			protected override void OnDragEnter(DragEventArgs e)
			{
				base.OnDragEnter(e);
				sideBar.ExitRenameMode();
				if (sideBar.activeTab.CanDragDrop) {
					if (e.Data.GetDataPresent(typeof(string)) || e.Data.GetDataPresent(typeof(AxSideTabItem))) {
						e.Effect = GetDragDropEffect(e);
					} else {
						e.Effect = DragDropEffects.None;
					}
				} else {
					e.Effect = DragDropEffects.None;
				}
			}
			
			protected override void OnDragLeave(EventArgs e)
			{
				base.OnDragLeave(e);
				sideBar.Tabs.DragOverTab = null;
				sideBar.ClearDraggings(sideBar.activeTab);
				Refresh();
			}
			
			protected override void OnDragDrop(DragEventArgs e)
			{
				base.OnDragDrop(e);
				
				Point p = PointToClient(new Point(e.X, e.Y));
				if (e.Data.GetDataPresent(typeof(AxSideTabItem))) {
					AxSideTabItem draggedItem = (AxSideTabItem)e.Data.GetData(typeof(AxSideTabItem));
					switch (e.Effect) {
						case DragDropEffects.Move:
							AxSideTabItem item = sideBar.activeTab.GetItemAt(p.X, p.Y);
							
							if (item != sideBar.activeTab.ChoosedItem) {
								int idx = sideBar.activeTab.Items.DraggedIndex;
								if (idx != -1) {
									sideBar.activeTab.Items.Remove(draggedItem);
									sideBar.activeTab.Items.Insert(idx, draggedItem);
								}
							}
							break;
						case DragDropEffects.Copy:
							AxSideTabItem newItem = draggedItem.Clone();
							newItem.SideTabItemStatus = SideTabItemStatus.Normal;
							sideBar.activeTab.Items.Add(newItem);
							break;
					}
					sideBar.ClearDraggings(sideBar.activeTab);
					sideBar.Tabs.DragOverTab = null;
					sideBar.Refresh();
				} else if (e.Data.GetDataPresent(typeof(string))) {
					if (sideBar.Tabs.DragOverTab != null) {
						string str = (string)e.Data.GetData(typeof(string));
						sideBar.Tabs.DragOverTab.Items.Add("Text:" + str.Trim(), str);
					}
					sideBar.Tabs.DragOverTab = null;
					Refresh();
				} else {
					sideBar.Tabs.DragOverTab = null;
					sideBar.Refresh();
				}
			}
			
			void ClearDraggings(AxSideTab tab)
			{
				foreach (AxSideTabItem item in tab.Items) {
					if (item.SideTabItemStatus == SideTabItemStatus.Drag) {
						item.SideTabItemStatus = SideTabItemStatus.Normal;
					}
				}
			}
			
			protected override void OnDragOver(DragEventArgs e)
			{
				base.OnDragOver(e);
				sideBar.ExitRenameMode();
				Point p = PointToClient(new Point(e.X, e.Y));
				
				if (e.Data.GetDataPresent(typeof(AxSideTabItem))) {
					// drag move item inside the activeTabMembarArea
					if (sideBar.activeTab.CanDragDrop) {
						AxSideTabItem item = sideBar.activeTab.GetItemAt(p.X, p.Y);
						if (item == null) {
							sideBar.ClearDraggings(sideBar.activeTab);
							sideBar.Refresh();
						} else
							if (item != sideBar.activeTab.ChoosedItem) {
							if (item.SideTabItemStatus != SideTabItemStatus.Drag) {
								sideBar.ClearDraggings(sideBar.activeTab);
								item.SideTabItemStatus = SideTabItemStatus.Drag;
								sideBar.Tabs.DragOverTab       = sideBar.activeTab;
								sideBar.Refresh();
							}
						} else {
							sideBar.ClearDraggings(sideBar.activeTab);
							sideBar.activeTab.SideTabStatus = SideTabStatus.Dragged;
							sideBar.Refresh();
						}
						
						e.Effect = GetDragDropEffect(e);
					} else {
						e.Effect = DragDropEffects.None;
					}
				} else if (e.Data.GetDataPresent(typeof(string))) {
					if (sideBar.activeTab != sideBar.Tabs.DragOverTab) {
						sideBar.Tabs.DragOverTab = sideBar.activeTab;
						sideBar.Refresh();
					}
				}
				
				//			else if (e.Data.GetDataPresent(typeof(SideTab))) {
				//				int tabIndex = GetTabIndexAt(p.X, p.Y);
				//				if (tabIndex != -1) {
				//					SideTab tab = Tabs.DragOverTab;
				//					Tabs.Remove(tab);
				//					Tabs.Insert(tabIndex, tab);
				//					Refresh();
				//				}
				//				e.Effect = DragDropEffects.Move;
				//			}
			}
			
			
			////////////////////////////////////////////////////////////////////////////
			// Mouse Handling
			protected override void OnMouseLeave(EventArgs e)
			{
				base.OnMouseLeave(e);
				sideBar.activeTab.SelectedItem = null;
				Refresh();
			}
			
			Point mouseDownPos;
			
			protected override void OnMouseMove(MouseEventArgs e)
			{
				base.OnMouseMove(e);
				if (e.Button == MouseButtons.Left) {
					AxSideTabItem item = sideBar.activeTab.GetItemAt(e.X, e.Y);
					
					if (item != null) {
						if (IsDragStarted(mouseDownPos, e.Location)) {
							sideBar.Tabs.DragOverTab = sideBar.activeTab;
							SpecialDataObject dataObject = new SpecialDataObject();
							dataObject.SetData(item.Tag);
							dataObject.SetData(item);
							
							DoDragDrop(dataObject, sideBar.activeTab.CanDragDrop ? DragDropEffects.All : (DragDropEffects.Copy | DragDropEffects.None));
						}
						Refresh();
					}
				} else {
					AxSideTabItem oldItem = sideBar.activeTab.SelectedItem;
					sideBar.activeTab.SelectedItem = null;
					mousePosition = new Point(e.X, e.Y);
					AxSideTabItem item = sideBar.activeTab.GetItemAt(e.X, e.Y);
					
					if (item != null) {
						sideBar.activeTab.SelectedItem = item;
					}
					
					if (oldItem != sideBar.activeTab.SelectedItem) {
						sideBar.Refresh();
					}
				}
			}
			
			protected override void OnMouseDown(MouseEventArgs e)
			{
				base.OnMouseDown(e);
				mouseDownPos = e.Location;
				sideBar.activeTab.ChoosedItem = sideBar.activeTab.SelectedItem;
				Refresh();
			}
			
			protected override void OnMouseUp(MouseEventArgs e)
			{
				if (sideBar != null) {
					sideBar.ExitRenameMode();
					Refresh();
				}
				base.OnMouseUp(e);
			}
		}
		
		public class SideTabCollection : ICollection, IEnumerable
		{
			ArrayList list = new ArrayList();
			AxSideTab dragOverTab;
			AxSideBar sideBar;
			
			public AxSideTab this[int index] {
				get {
					return (AxSideTab)list[index];
				}
				set {
					list[index] = value;
				}
			}
			
			public AxSideTab DragOverTab {
				get {
					return dragOverTab;
				}
				set {
					if (dragOverTab != null) {
						dragOverTab.SideTabStatus = SideTabStatus.Normal;
					}
					dragOverTab = value;
					if (dragOverTab != null) {
						dragOverTab.SideTabStatus = SideTabStatus.Dragged;
					}
				}
			}
			public SideTabCollection(AxSideBar sideBar)
			{
				this.sideBar = sideBar;
			}
			public int Count {
				get {
					return list.Count;
				}
			}
			
			public virtual bool IsSynchronized {
				get {
					return false;
				}
			}
			
			public virtual object SyncRoot {
				get {
					return this;
				}
			}
			
			public virtual AxSideTab Add(AxSideTab item)
			{
				list.Add(item);
				return item;
			}
			
			public virtual AxSideTab Add(string name)
			{
				return Add(sideBar.SideTabFactory.CreateSideTab(sideBar, name));
			}
			
			public virtual void Clear()
			{
				list.Clear();
			}
			
			public bool Contains(AxSideTab item)
			{
				return list.Contains(item);
			}
			
			public IEnumerator GetEnumerator()
			{
				return list.GetEnumerator();
			}
			
			public int IndexOf(AxSideTab item)
			{
				return list.IndexOf(item);
			}
			
			public void CopyTo(Array dest, int index)
			{
				list.CopyTo(dest, index);
			}
			
			public virtual AxSideTab Insert(int index, AxSideTab item)
			{
				list.Insert(index, item);
				return item;
			}
			
			public virtual AxSideTab Insert(int index, string name)
			{
				return Insert(index, sideBar.SideTabFactory.CreateSideTab(sideBar, name));
			}
			
			public virtual void Remove(AxSideTab item)
			{
				if (item == sideBar.ActiveTab) {
					int index =  IndexOf(item);
					if (index > 0) {
						sideBar.ActiveTab = this[index - 1];
					} else if (index < Count - 1) {
						sideBar.ActiveTab = this[index + 1];
					} else {
						sideBar.ActiveTab = null;
					}
				}
				list.Remove(item);
			}
			
			public virtual void RemoveAt(int index)
			{
				list.RemoveAt(index);
			}
		}
	}
	
	public class SpecialDataObject : System.Windows.Forms.IDataObject
	{
		ArrayList dataObjects = new ArrayList();
		public object GetData(string format)
		{
			return GetData(format, true);
		}
		
		public object GetData(System.Type format)
		{
			foreach (object o in dataObjects) {
				if (o.GetType() == format) {
					return o;
				}
			}
			return null;
		}
		
		public object GetData(string str, bool autoConvert)
		{
			foreach (object o in dataObjects) {
				if (o == null) {
					continue;
				}
				string typeStr = o.GetType().ToString();
				if (typeStr == str) {
					return o;
				}
				
				if (typeStr == "ICSharpCode.SharpDevelop.Gui.SharpDevelopSideTabItem" && str == "TimeSprint.Alexandria.UI.SideBar.AxSideTabItem") {
					return o;
				}
				
			}
			return null;
		}
		
		public bool GetDataPresent(string format)
		{
			return GetDataPresent(format, true);
		}
		
		public bool GetDataPresent(System.Type format)
		{
			return GetData(format) != null;
		}
		
		public bool GetDataPresent(string format, bool autoConvert)
		{
			return GetData(format, autoConvert) != null;
		}
		
		public string[] GetFormats()
		{
			return new string[0];
		}
		public string[] GetFormats(bool autoConvert)
		{
			return new string[0];
		}
		
		public void SetData(object data)
		{
			dataObjects.Add(data);
		}
		
		public void SetData(string format, object data)
		{
			
		}
		public void SetData(System.Type format, object data)
		{
			
		}
		public void SetData(string format, bool autoConvert, object data)
		{
			
		}
	}
}