//------------------------------------------------------------------------------
/// <copyright from='1997' to='2002' company='Microsoft Corporation'>
///    Copyright (c) Microsoft Corporation. All Rights Reserved.
///
///    This source code is intended only as a supplement to Microsoft
///    Development Tools and/or on-line documentation.  See these other
///    materials for detailed information regarding Microsoft code samples.
///
/// </copyright>
//------------------------------------------------------------------------------
using System;
using System.Collections;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Windows.Forms;
using System.Drawing;

namespace SampleDesignerHost
{
	/// The IMenuCommandService keeps track of MenuCommands and Designer Verbs
	/// that are available at any single moment. It can invoke these commands
	/// and also handles the displaying of ContextMenus for designers that support them.
	public class SampleMenuCommandService : System.ComponentModel.Design.IMenuCommandService
	{
		private Hashtable commands; // added MenuCommands
		private Hashtable verbsFromMenuItems; // DesignerVerb values mapped to MenuItem keys
		private Hashtable menuItemsFromVerbs; // MenuItem values mapped to DesignerVerb keys
		private ArrayList globalVerbs; // verbs currently available to all designers
		private IDesignerHost host;
		private ContextMenu cm;
		private IComponent lastSelection; // needed to clean up local verbs from a previous selection
        private DefaultMenuCommands defaultCommands;

		public SampleMenuCommandService(IDesignerHost host)
		{
			this.host = host;
		}

		/// The IMenuCommandService deals with two kinds of verbs: 1) local verbs specific
		/// to each designer (i.e. Add/Remove Tab on a TabControl) which are added
		/// and removed on-demand, each time a designer is right-clicked, 2) the rarer
		/// global verbs, which once added are available to all designers,
		/// until removed. This method (not a standard part of IMenuCommandService) is used
		/// to add a local verb. If the verb is already in our global list, we don't add it 
		/// again. It is called through IMenuCommandService.ShowContextMenu().
		public void AddLocalVerb(DesignerVerb verb)
		{
			if ((globalVerbs == null) || (!globalVerbs.Contains(verb)))
			{
				if (cm == null)
				{
					cm = new ContextMenu();
					verbsFromMenuItems = new Hashtable();
					menuItemsFromVerbs = new Hashtable();
				}

				// Verbs and MenuItems are dually mapped to each other, so that we can
				// check for association given either half of the pair. All of our MenuItems
				// use the same event handler, but we can check the event sender to see
				// what verb to invoke. MenuItems like to only be assigned to one Menu in their
				// lifetime, so we have to create a single ContextMenu and use that thereafter.
				// If we were to instead create a ContextMenu every time we need to show one,
				// the MenuItems' click events might not work properly.
				//
				MenuItem menuItem = new MenuItem(verb.Text);
				menuItem.Click += new EventHandler(menuItem_Click);
				verbsFromMenuItems.Add(menuItem, verb);
				menuItemsFromVerbs.Add(verb, menuItem);
				cm.MenuItems.Add(menuItem);
			}
		}

		/// Remove a local verb, but only if it isn't in our global list.
		/// It is also called through IMenuCommandService.ShowContextMenu().
		public void RemoveLocalVerb(DesignerVerb verb)
		{
			if ((globalVerbs == null) || (!globalVerbs.Contains(verb)))
			{
				if (cm != null)
				{
					// Remove the verb and its mapped MenuItem from our tables and menu.
					MenuItem key = menuItemsFromVerbs[verb] as MenuItem;
					verbsFromMenuItems.Remove(key);
					menuItemsFromVerbs.Remove(verb);
					cm.MenuItems.Remove(key);
				}
			}				
		}

		#region Implementation of IMenuCommandService

		/// If a designer supports a MenuCommand, it will add it here.
		public void AddCommand(System.ComponentModel.Design.MenuCommand command)
		{
			if (commands == null)
			{
				commands = new Hashtable();
                defaultCommands = new DefaultMenuCommands(host as IServiceProvider);
                defaultCommands.AddTo(this);
			}

			// Only add a command if we haven't already.
			if (FindCommand(command.CommandID) == null)
			{
				commands.Add(command.CommandID, command);
			}
		}

		/// This is only called by external callers if someone wants to
		/// remove a verb that is available for all designers. We keep track of
		/// such verbs to make sure that they are not re-added or removed
		/// when we frequently manipulate our local verbs.
		public void RemoveVerb(System.ComponentModel.Design.DesignerVerb verb)
		{
			if (globalVerbs != null)
			{
				globalVerbs.Remove(verb);

				if (cm != null)
				{
					// Remove the verb and its mapped MenuItem from our tables and menu.
					MenuItem key = menuItemsFromVerbs[verb] as MenuItem;
					verbsFromMenuItems.Remove(key);
					menuItemsFromVerbs.Remove(verb);
					cm.MenuItems.Remove(key);
				}
			}
		}

		/// If a command is no longer viable for a designer, it is removed.
		public void RemoveCommand(System.ComponentModel.Design.MenuCommand command)
		{
			if (commands != null)
			{
				// Hashtable already has nothing happen if the command isn't there.
				commands.Remove(command.CommandID);
			}
		}

		/// Find a command based on its CommandID.
		public System.ComponentModel.Design.MenuCommand FindCommand(System.ComponentModel.Design.CommandID commandID)
		{
			if (commands != null)
			{
				MenuCommand command = commands[commandID] as MenuCommand;
				if (command != null)
				{
					return command;
				}
			}
			return null;
		}

		/// We only invoke commands that have been added.
		public bool GlobalInvoke(System.ComponentModel.Design.CommandID commandID)
		{
			MenuCommand command = FindCommand(commandID);
			if (command != null)
			{
				command.Invoke();
				return true;
			}
			return false;
		}

		/// This is called whenever the user right-clicks on a designer. It removes any local verbs
		/// added by a previous, different selection and adds the local verbs for the current (primary)
		/// selection. Then it displays the ContextMenu.
		public void ShowContextMenu(System.ComponentModel.Design.CommandID menuID, int x, int y)
		{
			ISelectionService ss = host.GetService(typeof(ISelectionService)) as ISelectionService;

			// If this is the same component as was last right-clicked on, then we don't need to
			// make any changes to our collection of local verbs.
			//
			if ((lastSelection != null) && (lastSelection != ss.PrimarySelection))
			{
                IDesigner d = host.GetDesigner(lastSelection);
                if (d != null)
                {
                    foreach (DesignerVerb verb in d.Verbs)
                    {
                        RemoveLocalVerb(verb);
                    }
                }
			}

			// Update the local verbs for the new selection, if it is indeed new.
			if (lastSelection != ss.PrimarySelection)
			{
                IDesigner d = host.GetDesigner(ss.PrimarySelection as IComponent);
                if (d.Verbs.Count == 0)
                {
                    FillVerbs(ss.PrimarySelection as IComponent, d);                
                }
				foreach (DesignerVerb verb in d.Verbs)
				{
					AddLocalVerb(verb);
				}
			}

			// Display our ContextMenu! Note that the coordinate parameters to this method
			// are in screen coordinates, so we've got to translate them into client coordinates.
			//
			//if (cm != null) 
			{
				Control ps = ss.PrimarySelection as Control;
                if (ps == null)
                {
                    ps = VisualPascalABC.Form1.Form1_object;
                }
				Point s = ps.PointToScreen(new Point(0, 0));
				VisualPascalABC.Form1.Form1_object.cm_Designer.Show(ps, new Point(x - s.X, y - s.Y));
                //VisualPascalABC.Form1.Form1_object.cm_Designer.Show(ps, Cursor.Position);
            }

			// ss.PrimarySelection might be old news by the next right-click. We need to 
			// be able to remove its verbs if we get a different selection next time
			// this method is called. We can't remove them right now because we aren't sure
			// if the MenuItem click events have finished yet (and removing verbs kills
			// their MenuItem mapping). So we save the selection and do it next time if necessary.
			//
			lastSelection = ss.PrimarySelection as IComponent;
		}

        public void FillVerbs(IComponent comp, IDesigner d)
        {
            //DesignerVerb dv = new DesignerVerb("horiz", new EventHandler(VisualPascalABC.Form1.Form1_object.ExecSendToBack));
            
            //d.Verbs.Add(dv);
        }

		/// This is only called by external callers if someone wants to
		/// remove a verb that is available for all designers. We keep track of
		/// such verbs to make sure that they are not re-added or removed
		/// when we frequently manipulate our local verbs.
		public void AddVerb(System.ComponentModel.Design.DesignerVerb verb)
		{
			if (globalVerbs == null)
			{
				globalVerbs = new ArrayList();
			}

			globalVerbs.Add(verb);

			if (cm == null)
			{
				cm = new ContextMenu();
				verbsFromMenuItems = new Hashtable();
				menuItemsFromVerbs = new Hashtable();
			}

			// Verbs and MenuItems are dually mapped to each other, so that we can
			// check for association given either half of the pair. All of our MenuItems
			// use the same event handler, but we can check the event sender to see
			// what verb to invoke. We have to have a stable ContextMenu, and we need
			// to add the MenuItems to it now. If we try to add the MenuItems on-demand
			// right before we show a ContextMenu, the clicks events won't work.
			//
			MenuItem menuItem = new MenuItem(verb.Text);
			menuItem.Click += new EventHandler(menuItem_Click);
			verbsFromMenuItems.Add(menuItem, verb);
			menuItemsFromVerbs.Add(verb, menuItem);
			cm.MenuItems.Add(menuItem);
		}

		/// This is frequently called to get the current list of available verbs. We have
		/// to be careful in what verbs we return, however, because the information contained
		/// in menuItemsFromVerbs and verbsFromMenuItems will not be current if there has been
		/// no right-click since the last selection change. Thus we return the global verbs
		/// plus any additional local verbs for the current selection.
		public System.ComponentModel.Design.DesignerVerbCollection Verbs
		{
			get
			{
				ISelectionService ss = host.GetService(typeof(ISelectionService)) as ISelectionService;
				ArrayList currentVerbs;
				if (globalVerbs != null)
				{
					currentVerbs = new ArrayList(globalVerbs);
				}
				else
				{
					currentVerbs = new ArrayList();
				}

				foreach (DesignerVerb verb in host.GetDesigner(ss.PrimarySelection as IComponent).Verbs)
				{
					if (!currentVerbs.Contains(verb))
					{
						currentVerbs.Add(verb);
					}
				}

				if (currentVerbs.Count > 0)
				{
					DesignerVerb[] ret = new DesignerVerb[currentVerbs.Count];
					currentVerbs.CopyTo(ret);
					return new DesignerVerbCollection(ret);
				}
				else
				{
					return new DesignerVerbCollection();
				}
			}
		}

		#endregion

		/// All of our MenuItems' click events are handled by this method. It checks the
		/// mapping to see which verb is associated with the MenuItem that sent the event
		/// and then invokes that verb.
		private void menuItem_Click(object sender, EventArgs e)
		{
			MenuItem key = sender as MenuItem;
			DesignerVerb v = verbsFromMenuItems[key] as DesignerVerb;
			v.Invoke();
		}
	}
}