Наследование: System.ComponentModel.Component
Пример #1
0
		internal static Point ScreenToMenu (Menu menu, Point pnt)		
		{
			int x = pnt.X;
			int y = pnt.Y;
			XplatUI.ScreenToMenu (menu.Wnd.window.Handle, ref x, ref y);
			return new Point (x, y);
		}	
Пример #2
0
 private void AddBranchSpecificActions(Menu.MenuItemCollection items, bool needsLeadingSeparator)
 {
     var selectedRows = branchGrid.Grid.SelectedRows;
     if (selectedRows.Count > 0)
     {
         if (needsLeadingSeparator)
         {
             items.AddSeparator();
         }
         var row = selectedRows[0].DataRow;
         var branchId = row["ID"];
         var taskId = row["TaskID"];
         var builtInActions = new[]
         {
             new MenuAction("defaultInspect", "&Inspect", true,
                         () => SetCurrentBranch(branchId, taskId) ),
             new MenuAction("defaultOpen", "&Work on this", row["BasePath"] != DBNull.Value,
                         () => StartWorkOnBranch(branchId, taskId) ),
         };
         items.AddActions(builtInActions);
         var specificActions = _sourceRepository.GetBranchActions(branchId);
         if (specificActions.Count > 0)
         {
             items.AddSeparator();
             items.AddActions(specificActions);
         }
     }
 }
Пример #3
0
    private   void AddSubMenu( MenuCommand parentMenuCommand, Menu.MenuItemCollection items )
    {
      for ( int i = 0; i < items.Count; i++ )
      {
        // I know these menu items are actually MenuItemExs
        MenuItemEx item = (MenuItemEx)items[i];

        Bitmap bmp = ( item.Icon != null ) ? (Bitmap)item.Icon : 
          ( ( item.ImageList != null ) ? 
          (Bitmap)item.ImageList.Images[ item.ImageIndex ] : null ); 

        EventHandler hndl = item.ClickHandler;

        // if menu item does not have any ClickHandler then attach own
        if( hndl == null )
        {
          hndl = new EventHandler( RaiseMenuItemClick );
        }

        MenuCommand currentMenuCommand = new MenuCommand(item.Text, bmp,
          (Shortcut)item.Shortcut, hndl, item);
        
        currentMenuCommand.Checked = item.Checked;
        currentMenuCommand.Enabled = item.Enabled;
        
        parentMenuCommand.MenuCommands.Add(currentMenuCommand);
        
        if ( item.MenuItems.Count > 0 )
          AddSubMenu(currentMenuCommand, item.MenuItems);
      }
    }
Пример #4
0
 private void AddBuildSpecificActions(Menu.MenuItemCollection items, bool needsLeadingSeparator)
 {
     var selectedItems = builds.Grid.SelectedRows;
     if (selectedItems.Count > 0)
     {
         if (needsLeadingSeparator)
         {
             items.AddSeparator();
         }
         var row = selectedItems[0].DataRow;
         var buildId = row["ID"];
         var buildName = row["Name"];
         var builtInActions = new[]
         {
             new MenuAction("defaultOpen", "&Open", true,
                         () => SetCurrentBuild(buildId, buildName) ),
         };
         items.AddActions(builtInActions);
         var specificActions = _buildRepository.GetBuildActions(buildId);
         if (specificActions.Count > 0)
         {
             items.AddSeparator();
             items.AddActions(specificActions);
         }
     }
 }
 internal virtual void ItemsChanged(int change, Menu menu)
 {
     if (this.form != null)
     {
         this.form.MenuChanged(change, menu);
     }
 }
Пример #6
0
 private void AddTaskSpecificActions(Menu.MenuItemCollection items, bool needsLeadingSeparator)
 {
     var taskId = taskGrid.FindSelectedId();
     if (taskId != null)
     {
         var specificActions = _taskRepository.GetTaskActions(taskId);
         if (specificActions.Count > 0)
         {
             if (needsLeadingSeparator)
             {
                 items.AddSeparator();
             }
             items.AddActions(specificActions);
         }
         if (_sourceRepository != null)
         {
             if (specificActions.Count > 0)
             {
                 items.AddSeparator();
             }
             items.AddActions(
                 new MenuAction("createBranch", "Create branch for task {0}".FormatInvariant(taskId), true,
                     () => CreateBranch(taskId)),
                 new MenuAction("goToBranch", "Go to branch for task {0}".FormatInvariant(taskId), true,
                     () => GoToBranchFor(taskId))
             );
         }
     }
 }
Пример #7
0
 private TreeNode CreateMenuNode(Menu menu)
 {
     TreeNode node = new TreeNode(menu.Title) { Tag = menu };
     UpdateTreeNodeText(menu, "Title", node);
     treeView1.Nodes.Add(node);
     return node;
 }
        private static void AddItems(Menu.MenuItemCollection items, IntPtr hMenu, int index, ref int cmdId)
        {
            foreach (MenuItem menu in items)
            {
                string menuText = menu.Text;
                if (menu.IsParent)
                {
                    IntPtr popMenu = CreatePopupMenu();
                    InsertMenu(hMenu, index, MenuFlags.MF_BYPOSITION | MenuFlags.MF_POPUP, popMenu.ToInt32(), ref menuText);
                    AddItems(menu.MenuItems, popMenu, 0, ref cmdId);
                }
                else
                {
                    if (menuText == "-")
                        InsertMenu(hMenu, index, MenuFlags.MF_BYPOSITION | MenuFlags.MF_SEPARATOR, cmdId, ref menuText);
                    else
                        InsertMenu(hMenu, index, MenuFlags.MF_BYPOSITION, cmdId, ref menuText);
                    
                    cmdId++;
                }
                menu.Text = menuText;
                index++;
            }

        }
Пример #9
0
        // ***********************************************************************
        // METHOD: Init
        // INPUT : menu object to subclass
        // NOTES : Entry point method, subclasses the menu and iteratively marks
        //         child items as ownerdraw. Popup menus are not modified.
        public void Init(System.Windows.Forms.Menu menu)
        {
            // return if the menu is null
            if (menu == null)
            {
                return;
            }

            // Initialize the font object used to render the menu items
            if ((ItemFont == null))
            {
                ItemFont = new Font("Microsoft Sans Serif", 8.25F);
            }

            // Initialize the hashtable used to hold bitmap/item bindings
            if (menuItemIconCollection == null)
            {
                menuItemIconCollection = new Dictionary <MenuItem, string>();
            }

            // Iterate on all top-level menus and handle their items
            foreach (MenuItem popup in menu.MenuItems)
            {
                //  MakeItemOwnerDraw(popup);
                //  HandleChildMenuItems(popup);
                HandleChildMenuItems(popup);
            }
        }
 private void AddShelvesetSpecificActions(Menu.MenuItemCollection items, bool needsLeadingSeparator)
 {
     var selectedItems = shelvesetGrid.Grid.SelectedRows;
     if (selectedItems.Count > 0)
     {
         if (needsLeadingSeparator)
         {
             items.AddSeparator();
         }
         var row = selectedItems[0].DataRow;
         var shelvesetId = row["ID"];
         var shelvesetName = (string) row["Name"];
         var builtInActions = new[]
         {
             new MenuAction("defaultInspect", "&Inspect", true,
                            () => SetCurrentShelveset(shelvesetId, shelvesetName) ),
         };
         items.AddActions(builtInActions);
         var specificActions = _shelvesetRepository.GetShelvesetActions(shelvesetId);
         if (specificActions.Count > 0)
         {
             items.AddSeparator();
             items.AddActions(specificActions);
         }
     }
 }
Пример #11
0
 void OnMergeMenu(FreeCL.UI.MainMenu owner, System.Windows.Forms.Menu src)
 {
     foreach (System.Windows.Forms.MenuItem item in src.MenuItems)
     {
         HandleChildMenuItems(item);
     }
 }
Пример #12
0
        public static void AddControlMenuItems(Menu.MenuItemCollection pParent, AemInstance pInstance)
        {
            List<MenuItem> menuItems = new List<MenuItem>();
              MenuItem item;

              item = new MenuItem();
              item.Text = "Start instance";
              item.Click += new EventHandler(ControlStartInstance);
              menuItems.Add(item);

              item = new MenuItem();
              item.Text = "Stop instance";
              item.Click += new EventHandler(ControlStopInstance);
              menuItems.Add(item);

              item = new MenuItem();
              item.Text = "Kill instance";
              item.Click += new EventHandler(ControlKillInstance);
              menuItems.Add(item);

              foreach (MenuItem i in menuItems) {
            i.Tag = pInstance;
              }

              pParent.AddRange(menuItems.ToArray());
        }
 public TuringMachineSetup(Menu menuForm)
 {
     this.menuForm = menuForm;
     alphabetSetupForm = new AlphabetSetup(this);
     startingStringFrom = new StartingString(this);
     statesSetupForm = new States(this);
     InitializeComponent();
 }
Пример #14
0
 public override void MergeMenu(System.Windows.Forms.Menu menuSrc)
 {
     if (OnMergeMenu != null)
     {
         OnMergeMenu(this, menuSrc);
     }
     base.MergeMenu(menuSrc);
 }
Пример #15
0
		public MenuItemProvider (SWF.MenuItem menuItem) :
			base (menuItem)
		{
			this.menuItem = menuItem;
			parentMenu = mainMenu =	menuItem.GetMainMenu ();
			if (parentMenu == null)
				parentMenu = menuItem.GetContextMenu ();
		}
Пример #16
0
 // ***********************************************************************
 // HELPER: HandleChildMenuItems
 // INPUT : popup menu
 // NOTES : Mark the current item as owner draw and recursively processes
 //         all children
 public virtual void HandleChildMenuItems(Menu popupMenu)
 {
     // Mark as ownerdraw the current item and iterate on its children
     foreach (MenuItem item in popupMenu.MenuItems)
     {
         MakeItemOwnerDraw(item);
         HandleChildMenuItems(item);
     }
 }
Пример #17
0
 private void HandleChildMenuItems(System.Windows.Forms.Menu popupMenu)
 {
     foreach (System.Windows.Forms.MenuItem item in popupMenu.MenuItems)
     {
         MakeItemOwnerDraw(item);
         HookPopupMenuItem(item);
         HandleChildMenuItems(item);
     }
 }
Пример #18
0
        GameState state; //индикатор состояния игры

        #endregion Fields

        #region Constructors

        public yobaivan()
        {
            InitializeComponent();
            Canvas = this.CreateGraphics(); //рисуем на всей форме
            state = new GameState();
            state = GameState.start;
            menu = new Menu();
            game = new Game();
        }
Пример #19
0
 private static SWF.Menu GetRootMenu(SWF.MenuItem item)
 {
     SWF.Menu parentMenu = item.GetMainMenu();
     if (parentMenu == null)
     {
         parentMenu = item.GetContextMenu();
     }
     return(parentMenu);
 }
Пример #20
0
 public MenuItemProvider(SWF.MenuItem menuItem) :
     base(menuItem)
 {
     this.menuItem = menuItem;
     parentMenu    = mainMenu = menuItem.GetMainMenu();
     if (parentMenu == null)
     {
         parentMenu = menuItem.GetContextMenu();
     }
 }
Пример #21
0
 public void selectControlbyName(Menu name)
 {
     foreach (MenuControl menuControl in menuControls){
         if (menuControl.accessMenuName == name){
             menuControl.activateControl();
             currentMenuIndex = menuControls.IndexOf(menuControl);
             break;
         }
     }
 }
Пример #22
0
		private void UpdateItems()
		{
			this.selectedMenuItem = null;

			this.MenuItems.Clear();

			Size imageSize = GetImageSize(this.items);
			foreach (CommandBarItem item in this.items)
			{
				this.MenuItems.Add(new MenuBarItem(item, imageSize, this.font, this.mnemonics));
			}
		}
Пример #23
0
        public MainWindow()
            : base("MD", 640, 480)
        {
            this.WindowState = WindowState.Maximized;

            // Client area
            VariableContainer clientarea = new VariableContainer();

            // Menu items
            MenuItem[] menuitems = new MenuItem[]
            {
                MenuItem.Create("File", new MenuItem[]
                {
                    MenuItem.Create("Import", delegate
                    {
                        using(var fd = new WinForms.OpenFileDialog())
                        {
                            fd.Filter = "MP3 Files |*.mp3";
                            if (fd.ShowDialog() == WinForms.DialogResult.OK)
                            {
                                string file = fd.FileName;
                                AudioContext ac = new AudioContext();
                                MemoryAudioSource mas = new MP3AudioFeed(file).Copy(4096, 4096 * 100);

                                SpectrogramView sp = new SpectrogramView(mas);
                                clientarea.Client = sp;

                                AudioOutput ao = new AudioOutput(mas.Play);
                                ao.Play();
                            }
                            else
                            {
                                return;
                            }
                        }
                    }),
                    MenuItem.Create("Exit", delegate
                    {
                        this.Close();
                    })
                })
            };

            // Menu and splitter
            Menu menu = new Menu(menuitems);
            SplitContainer sc = new SplitContainer(Axis.Vertical, menu.WithBorder(0.0, 0.0, 0.0, 1.0), clientarea);
            sc.NearSize = 30.0;

            // Main layer container
            LayerContainer lc = new LayerContainer(sc);

            this.Control = lc;
        }
Пример #24
0
        public override void AddMenuItem(string menuPath, Menu.MenuItem item)
        {
            base.AddMenuItem(menuPath, item);
            Menu.MenuItem baseNode = findNode(menuPath, MenuData);
            //if(baseNode == null)

            ToolStripItemCollection coll = (ToolStripItemCollection)baseNode.Tag;
            ToolStripMenuItem tsItem = new ToolStripMenuItem();
            tsItem.Text = item.Name;
            tsItem.Click += delegate { if(item.Command!=null) item.Command(); };
            coll.Add(tsItem);
            item.Tag = tsItem.DropDownItems;
        }
Пример #25
0
        GameState state; //индикатор состояния игры

        #endregion Fields

        #region Constructors

        public jumper()
        {
            InitializeComponent();
            Canvas = this.CreateGraphics(); //рисуем на всей форме
            state = new GameState();
            state = GameState.start;
            menu = new Menu();
            game = new Game();
            context = BufferedGraphicsManager.Current;
            context.MaximumBuffer = new Size(this.Width + 1, this.Height + 1);
            canvas = context.Allocate(this.CreateGraphics(), new Rectangle(0, 0, this.Width, this.Height));
            direction = Direction.Nothing;
        }
Пример #26
0
 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>
        /// Default constructor for FerdaToolBar class.
        ///</summary>
        public FerdaToolBar(ILocalizationManager lockManager, IIconProvider provider, 
            Menu.FerdaMenu menu)
            : base()
        {
            this.iconProvider = provider;
            this.menu = menu;

            localizationManager = lockManager;
            ResManager = localizationManager.ResManager;

            SetupFile();
            SetupOther();
        }
Пример #28
0
 private void AddSubMenu(MenuCommand parentMenuCommand, Menu.MenuItemCollection items)
 {
     for ( int i = 0; i < items.Count; i++ )
     {
         // I know these menu items are actually MenuItemExs
         MenuItemEx item = (MenuItemEx)items[i];
         MenuCommand currentMenuCommand = new MenuCommand(item.Text, (Bitmap)item.Icon,
             (Shortcut)item.Shortcut, item.ClickHandler, item);
         parentMenuCommand.MenuCommands.Add(currentMenuCommand);
         if ( item.MenuItems.Count > 0 )
             AddSubMenu(currentMenuCommand, item.MenuItems);
     }
 }
Пример #29
0
		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// <p>Merge menu2 into menu1.</p>
		/// <p>Side effect: This method changes the main menu of the form if one of the two
		/// passed in menus is set as main menu of the form!</p>
		/// </summary>
		/// <remarks>This method is called recursively.</remarks>
		/// <param name="menu1">Menu being merged into.</param>
		/// <param name="menu2">Menu to be merged into menu1.</param>
		/// ------------------------------------------------------------------------------------
		internal void MergeMenu(Menu menu1, Menu menu2)
		{
			if (menu1 == menu2)
				return;

			if (menu2.MenuItems.Count <= 0)
				return;

			for (int n2 = 0; n2 < menu2.MenuItems.Count; n2++)
			{
				MenuItem item2 = menu2.MenuItems[n2];
				MenuItem item1;
				switch (item2.MergeType)
				{
					case MenuMerge.Add:
						menu1.MenuItems.Add(FindMergePosition(menu1, item2.MergeOrder),
							CopyMenu(item2, true));
						break;
					case MenuMerge.Replace:
					case MenuMerge.MergeItems:
						int n1;
						for (n1 = FindMergePosition(menu1, item2.MergeOrder - 1);
							n1 < menu1.MenuItems.Count; n1++)
						{
							item1 = menu1.MenuItems[n1];
							if (item1.MergeOrder != item2.MergeOrder)
							{
								menu1.MenuItems.Add(n1, CopyMenu(item2, true));
								break;
							}
							if (item1.MergeType != MenuMerge.Add)
							{
								if (item1.MergeType != MenuMerge.MergeItems
									|| item2.MergeType != MenuMerge.MergeItems)
								{
									item1.Dispose();
									menu1.MenuItems.Add(n1, CopyMenu(item2, true));
									break;
								}
								MergeMenu(item1, item2);
								break;
							}
						}
						if (n1 >= menu1.MenuItems.Count)
							menu1.MenuItems.Add(n1, CopyMenu(item2, true));
						break;
					case MenuMerge.Remove:
						break;
				}
			}
		}
 private FormPluginManager(Form1 form)
 {
     _form = form;
     var menuItem = new MenuItem { Text = "Plugins" };
     _form.Menu.MenuItems.Add(menuItem);
     _pluginsMenu = menuItem;
     menuItem.MenuItems.Add(new MenuItem("Load...", (sender, ev) =>
     {
         var dlg = new OpenFileDialog { DefaultExt = "*.dll", Filter = ".net images|*.dll" };
         if (dlg.ShowDialog() == DialogResult.OK && dlg.FileName.Length > 0)
         {
             Load(dlg.FileName, false);
         }
     }));
 }
Пример #31
0
 public bool Execute(ScriptExecutionService service)
 {
     System.Windows.Forms.Menu m = service.GetMenuItem(this.m_Path);
     if (m == null)
     {
         return(false);
     }
     if (m is MenuItem)
     {
         ((MenuItem)m).PerformClick();
     }
     else
     {
         return(false);
     }
     return(true);
 }
Пример #32
0
        public MenuEngine(MainForm form, Menu rootMenu)
        {
            Form = form;
            Form.Execute += OnExecute;
            Form.ShortcutPressed += OnShortcutPressed;
            State = new MenuState(rootMenu);

            _textChangedTimer = new Timer();
            _textChangedTimer.Elapsed += (s, e) =>  OnTextChangedTimerElapsed();
            _textChangedTimer.Interval = 100;

            SearchBar.TextChanged += (s, e) => OnTextBoxTextChanged();
            SearchBar.KeyDown += OnTextBoxKeyDown;
            ListBox.SelectedIndexChanged += (s, a) => OnSelectedIndexChanged();

            ClearSearchBar();
        }
Пример #33
0
        private static SWF.Control GetWnd(SWF.MenuItem item, out SWF.Menu parentMenu)
        {
            parentMenu = GetRootMenu(item);

            if (item.Parent != null && item.Parent.Wnd != null)
            {
                return(item.Parent.Wnd);
            }
            else if (parentMenu != null && parentMenu.Wnd != null)
            {
                return(parentMenu.Wnd);
            }
            else
            {
                return(null);
            }
        }
Пример #34
0
        public DialogResult ShowDialog(MobileRemoteUI parentForm, Menu menu)
        {
            this._contentPanel.Controls.Clear();
            _labels = new List<ImageLabel>();
            _ui = parentForm;

            //_roundedBar.Dock = DockStyle.Top;
            //this.Controls.Add(_roundedBar);

            AddMenuItems(parentForm, _expand, _menuDown, _menuUp, _font, _labels, 5, menu.MenuItems, this._contentPanel.Controls);
            this._contentPanel.BackColor = Color.Black;

            _currentLabels = _labels;

            HandleSelections(_labels[0]);

            return base.ShowDialog(parentForm, true);
        }
		private void AddMenuTreeNodes(TreeNodeCollection nodes, Menu.MenuItemCollection menuItems)
		{
			for (int index = 0; index < menuItems.Count; index++)
			{
				MenuItem menuItem = menuItems[index];

				if (menuItem.Tag != null || (menuItem.MenuItems != null && menuItem.MenuItems.Count > 0))
				{
					NuGenMenuItemShortcut menuItemShortcut = new NuGenMenuItemShortcut(menuItem);
					TreeNode node = nodes.Add(menuItemShortcut.GetText());
					node.Tag = menuItemShortcut;

					if (menuItem.MenuItems != null && menuItem.MenuItems.Count > 0)
					{
						AddMenuTreeNodes(node.Nodes, menuItem.MenuItems);
					}
				}
			}
		}
Пример #36
0
		protected MenuItem MakeMenu (Menu parent, ChoiceGroup group)
		{
			string label = group.Label.Replace("_", "&");
			MenuItem menu = new MenuItem(label);
			group.ReferenceWidget = menu;
			//although we put off populating the menu until it is actually displayed,
			//we have to put a dummy menu item in there in order to get the system to fire the right event.
			menu.MenuItems.Add(new MenuItem("dummy"));
			parent.MenuItems.Add(menu);

			//needed for mousing around
			menu.Popup += new System.EventHandler(group.OnDisplay);

#if DEBUG
			//needed for unit testing
			menu.Click += new System.EventHandler(group.OnDisplay);
#endif
			return menu;
		}
Пример #37
0
 internal override void DoProperMenuSelection(ICollection selComponents)
 {
     foreach (object obj2 in selComponents)
     {
         System.Windows.Forms.Menu menu = obj2 as System.Windows.Forms.Menu;
         if (menu != null)
         {
             MenuItem item = menu as MenuItem;
             if (item != null)
             {
                 System.Windows.Forms.Menu menu2 = base.menuEditorService.GetMenu();
                 MenuItem parent = item;
                 while (parent.Parent is MenuItem)
                 {
                     parent = (MenuItem)parent.Parent;
                 }
                 if (menu2 != parent.Parent)
                 {
                     base.menuEditorService.SetMenu(parent.Parent);
                 }
                 if (selComponents.Count == 1)
                 {
                     base.menuEditorService.SetSelection(item);
                 }
             }
             else
             {
                 base.menuEditorService.SetMenu(menu);
             }
             break;
         }
         if ((this.Menu != null) && (this.Menu.MenuItems.Count == 0))
         {
             base.menuEditorService.SetMenu(null);
         }
         else
         {
             base.menuEditorService.SetMenu(this.Menu);
         }
         System.Design.NativeMethods.SendMessage(this.Control.Handle, 0x86, 1, 0);
     }
 }
 private void AddRevisionSpecificActions(Menu.MenuItemCollection items, bool needsLeadingSeparator)
 {
     var selectedItems = activityRevisions.Grid.SelectedRows;
     if (selectedItems.Count > 0)
     {
         if (needsLeadingSeparator)
         {
             items.AddSeparator();
         }
         var row = selectedItems[0].DataRow;
         var revisionId = row["ID"];
         var builtInActions = new[]
         {
             new MenuAction("defaultOpen", "&Open", true,
                         () => SetCurrentRevision(revisionId) ),
         };
         items.AddActions(builtInActions);
         // TODO: Should there be specific actions per revision?  Maybe an external view, like TFS has...
     }
 }
        /// <summary>
        /// Default constructor for the class
        /// </summary>
        /// <param name="locManager">Interface that takes care of the localization</param>
        /// <param name="menuDisp">Menu displayer</param>
        /// <param name="modManager">Modules Manager</param>
        /// <param name="iconProvider">Provider of the icons</param>
        /// <param name="toolBar">ToolBar of the application</param>
        public NewBoxControl(Menu.ILocalizationManager locManager,
            Menu.IMenuDisplayer menuDisp, ModulesManager.ModulesManager modManager,
            IIconProvider iconProvider, Menu.IMenuDisplayer toolBar)
        {
            treeView = new NewBoxTreeView(locManager, menuDisp, modManager, iconProvider, toolBar);
            treeView.WidthConstant = this.heightConstant;
            treeView.BorderStyle = BorderStyle.FixedSingle;
            textBox = new RichTextBox();
            treeView.TextBox = textBox;
            textBox.BorderStyle = BorderStyle.Fixed3D;
            textBox.ReadOnly = true;
            this.Controls.Add(textBox);
            this.Controls.Add(treeView);

            //InitializeComponent things
            this.Name = "FerdaArchive";
            this.Size = new System.Drawing.Size(170, 500);
            this.ResumeLayout(false);
            this.PerformLayout();
        }
 private static MenuItem FindMenu(Menu.MenuItemCollection items, int id, ref int cmdId)
 {
     MenuItem findMenu = null;
     foreach (MenuItem menu in items)
     {
         if (menu.IsParent)
         {
             findMenu = FindMenu(menu.MenuItems, id, ref cmdId);
             if (findMenu != null)
                 return findMenu;
         }
         else
         {
             if (cmdId == id)
                 return menu;
             cmdId++;
         }
     }
     return findMenu;
 }
Пример #41
0
 public MenuProvider(SWF.Menu menu) :
     base(menu)
 {
     itemProviders = new Dictionary <SWF.MenuItem, MenuItemProvider> ();
 }