private void maakHelpMenu()
 {
     ToolStripDropDownItem menu;
     menu = new ToolStripMenuItem("Help");
     menu.DropDownItems.Add("Over \"Schets\"", null, this.about);
     menuStrip.Items.Add(menu);
 }

		public ToolStripDropDownItemProvider (ToolStripDropDownItem dropDrownItem) :
			base (dropDrownItem)
		{
			this.dropDrownItem = dropDrownItem;
			itemProviders = new Dictionary<ToolStripItem, FragmentControlProvider> ();
			
		}

        // Constructor required by plugins
        public DynamicMenu(ToolStripDropDownItem tsmiHost)
        {
            Debug.Assert(tsmiHost != null);
            if(tsmiHost == null) throw new ArgumentNullException("tsmiHost");

            m_tsicHost = tsmiHost.DropDownItems;
        }

 public static List<ToolStripItem> CreateGroupItems(ToolStripDropDownItem dropDownItem)
 {
     List<ToolStripItem> ret = new List<ToolStripItem>();
     DropDownMenuReorderable dropDown = null;
     if(dropDownItem != null) {
         dropDown = (DropDownMenuReorderable)dropDownItem.DropDown;
         while(dropDown.Items.Count > 0) {
             dropDown.Items[0].Dispose();
         }
         dropDown.ItemsClear();
     }
     const string key = "groups";
     foreach(Group group in GroupsManager.Groups) {
         if(group.Paths.Count == 0 || !QTUtility2.PathExists(group.Paths[0])) continue;
         QMenuItem item = new QMenuItem(group.Name, MenuGenre.Group);
         item.SetImageReservationKey(group.Paths[0], null);
         if(dropDown != null) {
             dropDown.AddItem(item, key);
         }
         ret.Add(item);
         if(!group.Startup) continue;
         if(StartUpTabFont == null) {
             StartUpTabFont = new Font(item.Font, FontStyle.Underline);
         }
         item.Font = StartUpTabFont;
     }
     if(dropDownItem != null) {
         dropDownItem.Enabled = dropDown.Items.Count > 0;
     }
     return ret;
 }

 private void AddSubMenuNodes(IEnumerable<ConnectionInfo> nodes, ToolStripDropDownItem toolStripMenuItem)
 {
     foreach (var connectionInfo in nodes)
     {
         var newItem = CreateMenuItem(connectionInfo);
         toolStripMenuItem.DropDownItems.Add(newItem);
     }
 }

		private static void Endisable(ToolStripDropDownItem tsddi, bool enable, PropagationMode mode) {
			
			if((mode & PropagationMode.CHILDREN) == PropagationMode.CHILDREN) {
				foreach(ToolStripItem tsi in tsddi.DropDownItems) {
					Endisable(tsi, enable, PropagationMode.CHILDREN);
				}
			}
			tsddi.Enabled = enable;
		}

 private void HookItem(ToolStripDropDownItem t)
 {
     t.Click += SubHook;
     t.Tag = this;
     if (!t.HasDropDownItems) return;
     foreach (ToolStripMenuItem item in t.DropDownItems)
     {
         HookItem(item);
     }
 }

        public OpenWithMenu(ToolStripDropDownItem tsmiHost)
        {
            if(tsmiHost == null) { Debug.Assert(false); return; }

            m_tsmiHost = tsmiHost;
            m_dynMenu = new DynamicMenu(m_tsmiHost);
            m_dynMenu.MenuClick += this.OnOpenUrl;

            m_tsmiHost.DropDownOpening += this.OnMenuOpening;
        }

 private void AddBodyGlyphs(ToolStripDropDownItem item)
 {
     if ((item != null) && (((ToolStripMenuItemDesigner) this.designerHost.GetDesigner(item)) != null))
     {
         foreach (ToolStripItem item2 in item.DropDownItems)
         {
             this.AddItemBodyGlyph(item2);
         }
     }
 }

 protected void UpdateDropDownText(ToolStripDropDownItem dropDownItem, object ItemTag)
 {
     foreach (ToolStripItem item in dropDownItem.DropDownItems)
     {
         if (ItemTag.Equals(item.Tag))
         {
             dropDownItem.Text = item.Text;
             break;
         }
     }
 }

 protected static void PerformDropDownClick(ToolStripDropDownItem dropDownItem, object ItemTag)
 {
     foreach (ToolStripItem item in dropDownItem.DropDownItems)
     {
         if (ItemTag.Equals(item.Tag))
         {
             item.PerformClick();
             break;
         }
     }
 }

 public MruController(string subKeyName, ToolStripDropDownItem recentMenu, EventHandler onItemClick)
 {
     if (string.IsNullOrWhiteSpace(subKeyName))
         throw new ArgumentNullException("subKeyName");
     if (recentMenu == null)
         throw new ArgumentNullException("parentMenuItem");
     if (onItemClick == null)
         throw new ArgumentNullException("onItemClick");
     SubKeyName = string.Concat(@"Software\", subKeyName);
     RecentMenu = recentMenu;
     OnItemClick = onItemClick;
     RefreshRecentMenu();
 }

 private bool CheckDropDownBounds(ToolStripDropDownItem dropDownItem, Glyph childGlyph, GlyphCollection glyphs)
 {
     if (dropDownItem == null)
     {
         return false;
     }
     Rectangle bounds = childGlyph.Bounds;
     Rectangle rect = base.BehaviorService.ControlRectInAdornerWindow(dropDownItem.DropDown);
     if (!bounds.IntersectsWith(rect))
     {
         glyphs.Insert(0, childGlyph);
     }
     return true;
 }

		private void RecursiveMenuItems(ToolStripDropDownItem item)
		{
			if (item.HasDropDownItems)
			{
				foreach (var cItem in item.DropDownItems)
				{
					if (cItem is ToolStripMenuItem)
					{
						RecursiveMenuItems((ToolStripMenuItem)cItem);
					}
				}
			}

			SetColorsOnMenuItem((ToolStripMenuItem)item);
		}

 internal static void GetAllDbData(ToolStripDropDownItem toolStripMenu)
 {
     using (UPdatabase ctx = new UPdatabase())
     {
         var allRows = ctx.UpData.ToList();
         if (toolStripMenu.DropDownItems.Count != 0)
         {
             toolStripMenu.DropDownItems.Clear();
         }
         foreach (var name in allRows)
         {
             toolStripMenu.DropDownItems.Add(name.ID + "-" + name.UserName, null, myClickHandler);
             item = ctx.UpData.FirstOrDefault(s => s.UserName == name.UserName);
         }
     }
 }

        void LoadConfigNodes(ConfigEntitySection configs, ToolStripDropDownItem root)
        {
            foreach (ConfigEntitySection section in configs.Sections)
            {
                SectionMenu node = new SectionMenu(section);

                LoadConfigNodes(section, node);
                root.DropDownItems.Add(node);
            }

            foreach (ConfigFileEntity config in configs.List)
            {
                ConfigMenu node = new ConfigMenu(config);
                root.DropDownItems.Add(node);
            }
        }

 public PersistenceController(Model model, Control view, ToolStripDropDownItem recentMenu, EventHandler onItemClick)
 {
     Model = model;
     View = view;
     var filter = Properties.Settings.Default.LibraryFilter;
     OpenFileDialog = new OpenFileDialog
     {
         Filter = filter,
         Title = "Select the library file to open"
     };
     SaveFileDialog = new SaveFileDialog
     {
         Filter = filter,
         Title = "Save library file"
     };
     MruController = new MruController(Application.ProductName + @"\LibraryMRU", recentMenu, onItemClick);
 }

		public MediaController(Model model, StatusController statusController, ToolStripDropDownItem recentMenu, EventHandler onItemClick)
		{
			Model = model;
			StatusController = statusController;
            var filter = Properties.Settings.Default.MediaFilter;
			OpenFileDialog = new OpenFileDialog
			{
				Filter = filter,
				Multiselect = true,
				Title = "Select the media file(s) to add"
			};
			FolderBrowserDialog = new FolderBrowserDialog
			{
				Description = "Select the media folder to add"
			};
			MruController = new MruController(Application.ProductName + @"\MediaMRU", recentMenu, onItemClick);
		}

        /// <summary>
        /// Applies resources to the specified <see cref="ToolStripDropDownItem"/>
        /// and its child drop down items.
        /// </summary>
        /// <param name="resources">The <see cref="ComponentResourceManager"/> used to apply the resources.</param>
        /// <param name="dropDownItem">The <see cref="ToolStripDropDownItem"/> to apply the resources to.</param>
        /// <exception cref="ArgumentNullException"><paramref name="resources"/> is <c>null</c> -or- <paramref name="dropDownItem"/> is <c>null</c>.</exception>
        public static void ApplyResources(ComponentResourceManager resources, ToolStripDropDownItem dropDownItem)
        {
            if (resources == null)
            {
                throw new ArgumentNullException("resources");
            }

            if (dropDownItem == null)
            {
                throw new ArgumentNullException("dropDownItem");
            }

            for (int i = 0; i < dropDownItem.DropDownItems.Count; i++)
            {
                LocalizationHelper.ApplyResources(resources, dropDownItem.DropDownItems[i]);
            }

            resources.ApplyResources(dropDownItem, dropDownItem.Name);
        }

        /// <summary>
        /// Populates the list box with the list of undo/redo actions, and displays the form
        /// directly below the tool strip button.
        /// </summary>
        /// <param name="dropDownButton">Tool strip button under which this form should be displayed</param>
        /// <param name="undo">true if this is "undo", false for "redo"</param>
        /// <param name="undoManager">the UndoManager</param>
        public void ShowList(ToolStripDropDownItem dropDownButton, bool undo, UndoManager undoManager)
        {
            Point location =
                dropDownButton.Owner.PointToScreen(new Point(dropDownButton.Bounds.Left, dropDownButton.Bounds.Bottom));
            Left = location.X;
            Top = location.Y;
            _undo = undo;
            _undoManager = undoManager;
            listBox.Items.Clear();
            IEnumerable<String> descriptions = undo ? undoManager.UndoDescriptions : undoManager.RedoDescriptions;
            foreach (String description in descriptions)
            {
                listBox.Items.Add(description);
            }
            UpdateSelectedIndex(0);

            Height = listBox.ItemHeight * Math.Min(MAX_DISPLAY_ITEMS, listBox.Items.Count) + label.Height + TOTAL_BORDER_WIDTH;
            Show(dropDownButton.Owner);
            listBox.Focus();
        }