abstractmenueditorcontrol.cs

全功能c#编译器

				if (menu.MenuItems[i].MenuItems.Count > 0) {
					ControlPaint.DrawMenuGlyph(g, (int)(menuItemAreas[i].Right - r), 
					                              (int)(menuItemAreas[i].Y), 
					                              r, r, MenuGlyph.Arrow);
				}
			}
		}
		
		protected override void OnPaint(PaintEventArgs pe)
		{
			Graphics g = pe.Graphics;
			Font     f = System.Windows.Forms.SystemInformation.MenuFont;
			
			MeasureMenuItems();
			
			for (int i = 0; i < menu.MenuItems.Count; ++i) {
				DrawItem(g, i, this.selectedItem == i, i == mouseOverItem);
			}
			
			if (MenuEditorFocused) {
				DrawTypeHere(g, this.selectedItem == menu.MenuItems.Count, mouseOverItem == menu.MenuItems.Count);
				ShowSubMenuEditor();
			}
		}
		
		public void CloseSubMenuEditor()
		{
			if (this.subMenuEditor != null) {
				try {
					subMenuEditor.Parent.Controls.Remove(subMenuEditor);
				} catch (Exception e) {
					Console.WriteLine(e);
				}
				subMenuEditor.Parent = null;
				try {
					this.subMenuEditor.Dispose();
					this.subMenuEditor = null;
				} catch (Exception e) {
					Console.WriteLine(e);
				}
			}
		}
		
		protected override void Dispose(bool disposing)
		{
			base.Dispose(disposing);
			CloseSubMenuEditor();
		}
		
		protected virtual void ShowSubMenuEditor()
		{
			if (this.selectedItem >= 0 && this.selectedItem < menu.MenuItems.Count) {
				if (menu.MenuItems[this.selectedItem].Checked) {
					CloseSubMenuEditor();
				} else {
					if (subMenuEditor == null || subMenuEditor.menu != menu.MenuItems[this.selectedItem]) {
						SubMenuEditorControl panel = new SubMenuEditorControl(host, this, menu.MenuItems[this.selectedItem]);
						panel.Location = GetSubmenuLocation(this.selectedItem);
						rootControl.Parent.Controls.Add(panel);
						panel.BringToFront();
						if (this.subMenuEditor != null) {
							CloseSubMenuEditor();
						}
						this.subMenuEditor = panel;
					}
				}
			} else if (this.selectedItem == menu.MenuItems.Count) {
				CloseSubMenuEditor();
			}
		}
		
		protected virtual Point GetSubmenuLocation(int menuIndex)
		{
			// implementation for a top leven menu
			RectangleF r;
			if (menuItemAreas == null || menuIndex >= menu.MenuItems.Count || menuIndex < 0) {
				r = typeArea;
			} else {
				r = menuItemAreas[menuIndex];
			}
			
			return new Point((int)(Left + r.X),
			                 (int)(Top  + SystemInformation.MenuHeight));
		}
		
		int GetItemIndex(int x, int y)
		{
			if (menuItemAreas != null) {
				for (int i = 0; i < menuItemAreas.Length; ++i) {
					if (menuItemAreas[i].Contains(x, y)) {
						return i;
					}
				}
			}
			return -1;
		}
		
		protected override void OnMouseDown(System.Windows.Forms.MouseEventArgs e)
		{
			int itemIndex = GetItemIndex(e.X, e.Y);
			AbstractMenuEditorControl.MenuEditorFocused = true;
			
			Select();
			if (itemIndex == -1 && typeArea.Contains(e.X, e.Y)) {
				SelectedItem = menu.MenuItems.Count;
			} else {
				SelectedItem = itemIndex;
			}
		}
		
		protected override void OnMouseLeave(System.EventArgs e)
		{
			base.OnMouseLeave(e);
			if (-1 != mouseOverItem) {
				mouseOverItem = -1;
				Refresh();
			}
		}
		
		
		protected override void OnMouseMove(System.Windows.Forms.MouseEventArgs e)
		{
			int itemIndex = GetItemIndex(e.X, e.Y);
			
			int newMouseOver;
			bool newIsMouseOverLeftSpacing = e.X < GetLeftSpacing();
			 
			if (itemIndex == -1 && typeArea.Contains(e.X, e.Y)) {
				newMouseOver = menu.MenuItems.Count;
				newIsMouseOverLeftSpacing = false;
			} else {
				newMouseOver = itemIndex;
				if (itemIndex >= 0 && itemIndex < menu.MenuItems.Count) {
					newIsMouseOverLeftSpacing &= menu.MenuItems[itemIndex].MenuItems.Count == 0;
				}
			}
			
			if (newMouseOver != mouseOverItem || newIsMouseOverLeftSpacing != isMouseOverLeftSpacing) {
				mouseOverItem = newMouseOver;
				isMouseOverLeftSpacing = newIsMouseOverLeftSpacing;
				Refresh();
			}
		}
		
		
		protected override void OnMouseUp(MouseEventArgs e)
		{
			base.OnMouseUp(e);
			if (oldSelectedItem == selectedItem) {
				int itemIndex = GetItemIndex(e.X, e.Y);
				
				if (itemIndex == -1 && typeArea.Contains(e.X, e.Y)) {
//					if (menu.MenuItems.Count == selectedItem) {
//						EditMode(menu.MenuItems.Count);
//					}
				} else {
					if (itemIndex == selectedItem && itemIndex != -1) {
						if (isMouseOverLeftSpacing) {
							menu.MenuItems[itemIndex].Checked = !menu.MenuItems[itemIndex].Checked;
							Refresh();
						} else {
							EditMode(itemIndex);
						}
					}
				} 
			}
		}
		
		protected override void OnKeyPress(System.Windows.Forms.KeyPressEventArgs e)
		{
			base.OnKeyPress(e);
			EditMode(selectedItem);
			if (itemEditor != null) {
				itemEditor.Text = String.Empty;
				itemEditor.AppendText(e.KeyChar.ToString());
			}
		}
		
		protected override bool ProcessDialogKey(System.Windows.Forms.Keys keyData)
		{
			switch (keyData) {
				case Keys.Home:
					SelectItem(ItemSelection.First);
					return true;
				case Keys.End:
					SelectItem(ItemSelection.Last);
					return true;
				case Keys.Return:
					EditMode(this.SelectedItem);
					return true;
				case Keys.Left:
					SelectItem(ItemSelection.Prev);
					return true;
				case Keys.Right:
					SelectItem(ItemSelection.Next);
					return true;
				case Keys.Up:
					if (subMenuEditor != null) {
						subMenuEditor.Focus();
						subMenuEditor.SelectItem(ItemSelection.Last);
					}
					return true;
				case Keys.Down:
					if (subMenuEditor != null) {
						subMenuEditor.Focus();
						subMenuEditor.SelectItem(ItemSelection.First);
					}
					return true;
				case Keys.Escape: {
					SelectedItem = -1;
					AbstractMenuEditorControl.MenuEditorFocused = false;
					Refresh();
					ISelectionService selectionService = (ISelectionService)host.GetService(typeof(ISelectionService));
					selectionService.SetSelectedComponents(new object[] { host.RootComponent });
					return true;
				}
				case Keys.Back:
				case Keys.Delete: {
					if (itemEditor != null && !itemEditor.Focused) {
						DeleteCommand();
						return true;
					}
					break;
				}
				
			}
			return base.ProcessDialogKey(keyData);
		}
		public void DeleteCommand()
		{
			if (selectedItem >= 0 && selectedItem < menu.MenuItems.Count) { //  && subMenuEditor == null
				ISelectionService selectionService = (ISelectionService)host.GetService(typeof(ISelectionService));
				if (selectedItem == 0) {
					selectionService.SetSelectedComponents(new object[] { });
				} else {
					selectionService.SetSelectedComponents(new object[] { menu.MenuItems[selectedItem - 1] });
				}
				ComponentChangeService componentChangeService = (ComponentChangeService)host.GetService(typeof(IComponentChangeService));
				
				PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(menu);
				System.ComponentModel.PropertyDescriptor myProperty = properties.Find("MenuItems", false);
				
				object[] oldArray = new object[menu.MenuItems.Count];
				menu.MenuItems.CopyTo(oldArray, 0);
				MenuItem item = menu.MenuItems[selectedItem];
				
				DesignerTransaction transaction = host.CreateTransaction("remove menu item");
				componentChangeService.OnComponentChanging(menu, myProperty);
				menu.MenuItems.Remove(item);
				componentChangeService.OnComponentChanged(menu, myProperty, oldArray, menu.MenuItems);
				
				host.DestroyComponent(item);
				transaction.Commit();
				SetSize(null, null);
				Refresh();
			}
		}
		
		public void SelectItem(ItemSelection selection)
		{
			switch (selection) {
				case ItemSelection.Last:
					SelectedItem =  menu.MenuItems.Count;
					break;
				case ItemSelection.First:
					SelectedItem = 0;
					break;
				case ItemSelection.Next:
					this.SelectedItem  = (SelectedItem == menu.MenuItems.Count ? 0 : selectedItem + 1);
					break;
				case ItemSelection.Prev:
					this.SelectedItem  = (SelectedItem == 0 ? menu.MenuItems.Count : selectedItem - 1);
					break;
			}
		}
		
		void EditMode(int itemNumber)
		{
			if (itemNumber < 0 || !canEditMenuItems) {
				return;
			}
			try {
				itemEditor = new ItemEditor(this);
				RectangleF r = itemNumber >= menu.MenuItems.Count ? this.typeArea : menuItemAreas[itemNumber];
				SizeF      s = itemNumber >= menu.MenuItems.Count ? this.typeSize : menuItemSize[itemNumber];
				int yOffset = (int)((r.Height - s.Height) / 2);
				itemEditor.SetBounds((int)r.X + 2 + this.GetLeftSpacing(),
				                     (int)r.Y + yOffset, 
				                     (int)r.Width - 4, 
				                     (int)r.Height);
				
				if (itemNumber >= menu.MenuItems.Count) {
					DesignerTransaction transaction = host.CreateTransaction("create menu item");
					ComponentChangeService componentChangeService = (ComponentChangeService)host.GetService(typeof(IComponentChangeService));
					MenuItem newItem = (MenuItem)host.CreateComponent(typeof(MenuItem));
					componentChangeService.OnComponentAdding(newItem);
					
					newItem.Text = newItem.Site.Name;
					menu.MenuItems.Add(newItem);
					componentChangeService.OnComponentAdded(newItem);
					transaction.Commit();
					MeasureMenuItems();
				}
				itemEditor.SetItem(menu.MenuItems[itemNumber]);
				base.Controls.Add(itemEditor);
				MenuEditorFocused = true;
				itemEditor.Select();
				MenuEditorFocused = true;
				Refresh();
			} catch (Exception e) {
				Console.WriteLine(e);
				if (itemEditor != null) {
					base.Controls.Remove(itemEditor);
					itemEditor.Dispose();
					itemEditor = null;
				}
			}
		}
	}
}