public static string ConvertShortcutToString(Shortcut shortcut)
		{
			string shortcutString = Convert.ToString(shortcut);
			StringBuilder result = new StringBuilder(shortcutString);

			if (shortcutString.StartsWith("Alt"))
			{
				result.Insert(3, " + ");
			}
			else if (shortcutString.StartsWith("CtrlShift"))
			{
				result.Insert(9, " + ");
				result.Insert(4, " + ");
			}
			else if (shortcutString.StartsWith("Ctrl"))
			{
				result.Insert(4, " + ");
			}
			else if (shortcutString.StartsWith("Shift"))
			{
				result.Insert(5, " + ");
			}

			return result.ToString();
		}

		public TextShortcut(string methodName,
			string shortName, string longName, Shortcut shortcut)
		{
			MethodName = methodName;
			_shortcut = shortcut;
			ShortName = shortName;
			LongName = longName;
		}

		private void Initialize(Bitmap bitmap, Shortcut shortcut, EventHandler handler, ImageList list, int imageIndex)
		{
			OwnerDraw = true;
			this.Shortcut = shortcut;
			icon = bitmap;
			clickHandler = handler;
			imageList = list;
			this.imageIndex = imageIndex;
		}

		/// <summary>
		/// Initialize a new instance of the <see cref="ConfigurationUICommand"/> class.
		/// </summary>		
		/// <param name="serviceProvider">The a mechanism for retrieving a service object; that is, an object that provides custom support to other objects.</param>
		/// <param name="text">The text for the command.</param>
		/// <param name="longText">The text that will be in the status bar.</param>
		/// <param name="commandState">One of the <see cref="CommandState"/> values.</param>		
		/// <param name="command">The command to execute.</param>		
		/// <param name="shortcut">A short cut for the command.</param>
		/// <param name="insertionPoint">One of the <see cref="InsertionPoint"/> values.</param>
		/// <param name="icon">The icon for the command.</param>
		public ConfigurationUICommand(IServiceProvider serviceProvider, string text,
			string longText, CommandState commandState,
			ConfigurationNodeCommand command, Shortcut shortcut,
			InsertionPoint insertionPoint, Icon icon) 
			: this(serviceProvider,
			text, longText, commandState, NodeMultiplicity.Allow, command, null,
			shortcut, insertionPoint, icon)
		{			
		}

        private static string ShortcutToString(Shortcut shortcut)
        {
            if (shortcut != Shortcut.None)
            {
                Keys keys = (Keys)shortcut;
                return TypeDescriptor.GetConverter(keys.GetType()).ConvertToString(keys);
            }

            return null;
        }

		protected bool RegisterHotkey(Shortcut key)
		{	//register hotkey
			int mod=0;
			Keys k2=Keys.None;
			if (((int)key & (int)Keys.Alt)==(int)Keys.Alt) {mod+=(int)Win32.Modifiers.MOD_ALT;k2=Keys.Alt;}
			if (((int)key & (int)Keys.Shift)==(int)Keys.Shift) {mod+=(int)Win32.Modifiers.MOD_SHIFT;k2=Keys.Shift;}
			if (((int)key & (int)Keys.Control)==(int)Keys.Control) {mod+=(int)Win32.Modifiers.MOD_CONTROL;k2=Keys.Control;}
			
			System.Diagnostics.Debug.Write(mod.ToString()+" ");
			System.Diagnostics.Debug.WriteLine((((int)key)-((int)k2)).ToString());

			return Win32.User32.RegisterHotKey(m_Window.Handle,this.GetType().GetHashCode(),(int)mod,((int)key)-((int)k2));
		}

 private static MenuItem AddMenuItem(
     Menu menu, string text, EventHandler handler, object context,
     Shortcut shortcut = Shortcut.None)
 {
     var item = new MenuItem(text, handler)
     {
         Tag = context,
         Shortcut = shortcut,
         ShowShortcut = shortcut != Shortcut.None
     };
     menu.MenuItems.Add(item);
     return item;
 }

 /// <summary>
 /// <para>Initializes a new instance of the class with a specified caption, event handler, associated shortcut key, icon, status bar text, and the insertion point for the menu item.</para>
 /// </summary>
 /// <param name="text">
 /// <para>The caption for the menu item.</para>
 /// </param>
 /// <param name="command">
 /// <para>The <see cref="ConfigurationNodeCommand"/> to execute.</para>
 /// </param>
 /// <param name="node">
 /// <para>The <see cref="ConfigurationNode"/> to execute the command upon.</para>
 /// </param>
 /// <param name="shortcut">
 /// <para>One of the <see cref="Shortcut"/> values.</para>
 /// </param>
 /// <param name="statusBarText">
 /// <para>The text for the status bar.</para>
 /// </param>
 /// <param name="insertionPoint">
 /// <para>One of the <see cref="InsertionPoint"/> values.</para>
 /// </param>
 public ConfigurationMenuItem(string text, ConfigurationNodeCommand command, ConfigurationNode node, Shortcut shortcut, string statusBarText, InsertionPoint insertionPoint)
     : base(text, null, shortcut)
 {
     if (command == null)
     {
         throw new ArgumentNullException("command");
     }
     if (node == null)
     {
         throw new ArgumentNullException("node");
     }
     this.statusBarText = statusBarText;
     this.insertionPoint = insertionPoint;
     this.command = command;
     this.node = node;
 }

	public MenuItem(MenuMerge mergeType, int mergeOrder, Shortcut shortcut,
					String text, EventHandler onClick, EventHandler onPopup,
					EventHandler onSelect, MenuItem[] items)
			: base(items)
			{
				this.flags = ItemFlags.Default;
				this.mergeType = mergeType;
				this.mergeOrder = mergeOrder;
				this.shortcut = shortcut;
				this.text = text;
				if(onClick != null)
				{
					Click += onClick;
				}
				if(onPopup != null)
				{
					Popup += onPopup;
				}
				if(onSelect != null)
				{
					Select += onSelect;
				}
			}

 public MenuCommand(string text, Shortcut shortcut, EventHandler clickHandler)
 {
     InternalConstruct(text, null, -1, shortcut, clickHandler);
 }

		public ToolBarItem(Image image, string text, EventHandler clickHandler, Shortcut shortcut)
		{
			Initialize(image, text, clickHandler, shortCut, null);
		}

 public MxMenuItem(string text, string helpText, Shortcut shortcut)
     : base(MenuMerge.Add, 0, shortcut, text, null, null, null, null)
 {
     this._helpText = helpText;
     if (shortcut != Shortcut.None)
     {
         this._shortcutText = TypeDescriptor.GetConverter(typeof(Keys)).ConvertToString((Keys) shortcut);
     }
     base.OwnerDraw = true;
 }

 public bool ShouldIgnore(Shortcut shortcut)
 {
     if (maskedShortcuts != null && maskedShortcuts.Contains(shortcut))
         return true;
     return false;
 }

        public override void Execute(DirectoryInfo targetDirectory, PortableEnvironment portableEnvironment)
        {
            var shortcut = new Shortcut
                               {
                                   FileName = Path.Combine(portableEnvironment.Shortcuts.StartMenuTargetDirectory, FileName),
                                   Target = Path.Combine(targetDirectory.FullName, Target),
                                   Arguments = Arguments,
                                   WorkingDirectory = string.IsNullOrWhiteSpace(WorkingDirectory) ? null : Path.Combine(targetDirectory.FullName, WorkingDirectory),
                                   IconPath = string.IsNullOrWhiteSpace(IconPath) ? null : Path.Combine(targetDirectory.FullName, IconPath),
                                   DisplayMode = DisplayMode,
                                   Description = Description,
                               };

            // Create the link file.
            portableEnvironment.Shortcuts.Add(shortcut);
        }

 /// <summary>
 /// Instructs the command manager to ignore the shortcut until
 /// UnignoreShortcut is called.
 ///
 /// LIMITATION: You cannot currently ignore an AdvancedShortcut
 /// (i.e. one based on Keys instead of Shortcut).
 /// </summary>
 public void IgnoreShortcut(Shortcut shortcut)
 {
     if (maskedShortcuts == null)
         maskedShortcuts = new HashSet();
     bool isNewElement = maskedShortcuts.Add(shortcut);
     Debug.Assert(isNewElement, "Shortcut " + shortcut + " was already masked");
 }

 /// <summary>
 /// Instructs the command manager to respond to the shortcut again.
 /// </summary>
 public void UnignoreShortcut(Shortcut shortcut)
 {
     Trace.Assert(maskedShortcuts != null, "UnignoreShortcut called before IgnoreShortcut");
     if (maskedShortcuts != null)
     {
         bool wasPresent = maskedShortcuts.Remove(shortcut);
         Trace.Assert(wasPresent, "Shortcut " + shortcut + " was not masked");
         if (maskedShortcuts.Count == 0)
             maskedShortcuts = null;
     }
 }

        protected bool RegisterHotkey(Shortcut key)
        {
            //register hotkey
            int mod = 0;
            Keys k2 = Keys.None;
            if (((int)key & (int)Keys.Alt) == (int)Keys.Alt)
            {
                mod |= (int)Win32.Modifiers.MOD_ALT;
                k2 |= Keys.Alt;
            }

            if (((int)key & (int)Keys.Shift) == (int)Keys.Shift)
            {
                mod |= (int)Win32.Modifiers.MOD_SHIFT;
                k2 |= Keys.Shift;
            }

            if (((int)key & (int)Keys.Control) == (int)Keys.Control)
            {
                mod |= (int)Win32.Modifiers.MOD_CONTROL;
                k2 |= Keys.Control;
            }

            int nonModifiedKey = (int)key - (int)k2;

            return Win32.User32.RegisterHotKey(m_Window.Handle, this.GetType().GetHashCode(), (int)mod, nonModifiedKey);
        }

		public MenuItemEx(string name, ImageList imageList, int imageIndex, Shortcut shortcut, EventHandler handler) : this(name, handler)
		{
			Initialize(icon, shortcut, handler, imageList, imageIndex);
		}

        protected void InternalConstruct(string text, 
                                         ImageList imageList, 
                                         int imageIndex, 
                                         Shortcut shortcut, 
                                         EventHandler clickHandler)
        {
            // Save parameters
            _text = text;
            _imageList = imageList;
            _imageIndex = imageIndex;
            _shortcut = shortcut;
            _description = text;

            if (clickHandler != null)
                Click += clickHandler;

            // Define defaults for others
            _enabled = true;
            _checked = false;
            _radioCheck = false;
            _break = false;
            _tag = null;
            _visible = true;
            _infrequent = false;
            _image = null;

            // Create the collection of embedded menu commands
            _menuItems = new MenuCommandCollection();
        }

            /// <summary>
            /// Load all configuration and override the current values
            /// </summary>
            /// <returns></returns>
            public static bool ConfigurationLoad()
            {
                // Check if config file is present
                Restore(ConfigFile);
                bool Protocols = false;
                if (File.Exists(ConfigFile))
                {
                    try
                    {
                        XmlDocument configuration = new XmlDocument();
                        configuration.Load(ConfigFile);
                        lock (Configuration.ShortcutKeylist)
                        {
                            Configuration.ShortcutKeylist = new List<Shortcut>();
                        }
                        lock (Ignoring.IgnoreList)
                        {
                            Ignoring.IgnoreList.Clear();
                        }
                        lock (Configuration.HighlighterList)
                        {
                            Configuration.HighlighterList = new List<Network.Highlighter>();
                        }
                        lock (NetworkData.Networks)
                        {
                            NetworkData.Networks.Clear();
                        }
                        lock (Configuration.UserData.History)
                        {
                            Configuration.UserData.History.Clear();
                        }
                        Commands.ClearAliases();
                        foreach (XmlNode node in configuration.ChildNodes)
                        {
                            if (node.Name == "configuration.pidgeon")
                            {
                                foreach (XmlNode curr in node.ChildNodes)
                                {
                                    if (curr.Name == "history")
                                    {
                                        lock (Configuration.UserData.History)
                                        {
                                            Configuration.UserData.History.Add(curr.InnerText);
                                        }
                                        continue;
                                    }
                                    if (curr.Attributes == null)
                                    {
                                        continue;
                                    }
                                    if (curr.Attributes.Count > 0)
                                    {
                                        if (curr.Name.StartsWith("extension.", StringComparison.Ordinal))
                                        {
                                            Configuration.SetConfig(curr.Name.Substring(10), curr.InnerText);
                                            continue;
                                        }
                                        if (curr.Name == "alias")
                                        {
                                            Commands.RegisterAlias(curr.Attributes[0].InnerText, curr.Attributes[1].InnerText, bool.Parse(curr.Attributes[2].InnerText));
                                            continue;
                                        }
                                        if (curr.Name == "network")
                                        {
                                            if (curr.Attributes.Count > 3)
                                            {
                                                NetworkData.NetworkInfo info = new NetworkData.NetworkInfo();
                                                foreach (XmlAttribute xx in curr.Attributes)
                                                {
                                                    switch (xx.Name.ToLower())
                                                    {
                                                        case "name":
                                                            info.Name = xx.Value;
                                                            break;
                                                        case "server":
                                                            info.Server = xx.Value;
                                                            break;
                                                        case "ssl":
                                                            info.SSL = bool.Parse(xx.Value);
                                                            break;
                                                    }
                                                }
                                                lock (NetworkData.Networks)
                                                {
                                                    NetworkData.Networks.Add(info);
                                                }
                                            }
                                            continue;
                                        }
                                        if (curr.Name == "window")
                                        {
                                            string name = curr.InnerText;
                                            PidgeonGtkToolkit.PidgeonForm.Info w = new PidgeonGtkToolkit.PidgeonForm.Info();
                                            if (curr.Attributes == null)
                                            {
                                                continue;
//.........这里部分代码省略.........