Esempio n. 1
0
        /// <summary>
        /// Generic construction of new MenuCommand instance.
        /// </summary>
        /// <param name="text">Display text for command.</param>
        /// <param name="imageList">Source for accessing command image.</param>
        /// <param name="imageIndex">Index into source ImageList.</param>
        /// <param name="shortcut">Keyboard combination to click command.</param>
        /// <param name="clickHandler">Handler for processing click event.</param>
        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;

            // This is not a clone
            _original = null;

            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();
        }
Esempio n. 2
0
        /// <summary>
        /// Edits the specified object's value using the editor style indicated by GetEditStyle.
        /// </summary>
        /// <param name="context">An ITypeDescriptorContext that can be used to gain additional context information.</param>
        /// <param name="provider">An IServiceProvider that this editor can use to obtain services.</param>
        /// <param name="value">The object to edit.</param>
        /// <returns></returns>
        public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
        {
            if ((context != null) && (context.Instance != null) && (provider != null))
            {
                // Convert to the correct class.
                MenuCommandCollection commands = value as MenuCommandCollection;

                // Create the dialog used to edit the menu commands
                MenuCollectionDialog dialog = new MenuCollectionDialog(commands);

                // Give user the chance to modify the nodes
                if (dialog.ShowDialog() == DialogResult.OK)
                {
                    // Reflect changes back into original copy and generate appropriate
                    // component changes to designer to reflect these changes
                    SynchronizeCollections(commands, dialog.Commands, context);

                    // Notify container that value has been changed
                    context.OnComponentChanged();

                    // Need to repaint the control to take account of new values
                    MenuControl mc = context.Instance as MenuControl;

                    // Just in case it is null
                    if (mc != null)
                    {
                        mc.Invalidate();
                    }
                }
            }

            // Return the original value
            return(value);
        }
Esempio n. 3
0
        /// <summary>
        /// Initializes a new instance of the MenuCollectionDialog class.
        /// </summary>
        /// <param name="original">Original MenuCommand instances to be edited.</param>
        public MenuCollectionDialog(MenuCommandCollection original)
        {
            // Required for Windows Form Designer support
            InitializeComponent();

            // Add menu commands to a node collection
            AddToNodeCollection(original, treeControl1.Nodes);

            // Set correct initial state of the buttons
            UpdateButtonState();
        }
Esempio n. 4
0
        private void CommandsFromNodes(MenuCommandCollection commands, NodeCollection nodes)
        {
            // Process each tree node in turn
            foreach (Node n in nodes)
            {
                // Cast to correct type
                MenuCommand command = n.Tag as MenuCommand;

                // Add into the command collection
                commands.Add(command);

                // Remove any existing children
                command.MenuCommands.Clear();

                // Populate with children
                CommandsFromNodes(command.MenuCommands, n.Nodes);
            }
        }
Esempio n. 5
0
        /// <summary>
        /// Dispose of resources.
        /// </summary>
        /// <param name="disposing">Disposing.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                // Must get rid of collections as they cache information
                if (_menuItems != null)
                {
                    _menuItems.Dispose();
                    _menuItems = null;
                }

                if (_original != null)
                {
                    _original.Dispose();
                    _original = null;
                }
            }

            base.Dispose(disposing);
        }
Esempio n. 6
0
        private void AddToNodeCollection(MenuCommandCollection commands, NodeCollection nodes)
        {
            // Add each command in turn
            foreach (MenuCommand command in commands)
            {
                string text = command.Text;

                // Use a string to make it easier to select a node
                if (text.Length == 0)
                {
                    text = "<Empty>";
                }
                else if (text.Equals("-"))
                {
                    text = "(Separator)";
                }

                // Create a node to represent the command
                Node n = new Node(text);

                // Attach a copy of the menu command to the node instance
                n.Tag = command.Clone();

                // Add to end of the node collection
                nodes.Add(n);

                // Get access to the copy of the original
                MenuCommand clone = n.Tag as MenuCommand;

                // We want to know whenever the menu text is changed
                clone.PropertyChanged += new Crownwood.DotNetMagic.Menus.MenuCommand.PropChangeHandler(OnPropertyChanged);

                // Add any child commands
                AddToNodeCollection(command.MenuCommands, n.Nodes);
            }
        }
Esempio n. 7
0
        private void SynchronizeCollections(MenuCommandCollection orig,
                                            MenuCommandCollection copy,
                                            ITypeDescriptorContext context)
        {
            // Make a note of all original commands that are still in copy
            Hashtable both = new Hashtable();

            // First pass, scan looking for nodes that are in original and copy
            foreach (MenuCommand copyChild in copy)
            {
                // Does this node have an back pointer to its original?
                if (copyChild.Original != null)
                {
                    // Then make a note that it is in both collections
                    both.Add(copyChild.Original, copyChild.Original);

                    // Update the original from the copy
                    copyChild.Original.UpdateInstance(copyChild);
                }
            }

            int origCount = orig.Count;

            // Second pass, remove commands in the original but not in the copy
            for (int i = 0; i < origCount; i++)
            {
                // Get access to the indexed command from original
                MenuCommand origChild = orig[i];

                // If not in the found collection...
                if (!both.ContainsKey(origChild))
                {
                    // ...then it has been removed from the copy, so delete it
                    orig.Remove(origChild);

                    // Must remove from context container so it is removed from designer tray
                    context.Container.Remove(origChild as IComponent);

                    // Must also remove everything below the command
                    RemoveAllChildren(origChild, context);

                    // Reduce the count and index to reflect change in collection contents
                    --i;
                    --origCount;
                }
            }

            int copyCount = copy.Count;

            // Third pass, add new commands from copy but not in original
            for (int i = 0; i < copyCount; i++)
            {
                // Get access to the indexed node from copy
                MenuCommand copyChild = copy[i];

                // If this command is a new one then it will not have an 'original' property
                if (copyChild.Original == null)
                {
                    // Add this node into the original at indexed position
                    orig.Insert(i, copyChild);

                    // It references itself in the new collection
                    copyChild.Original = copyChild;

                    // Must add into context container so it is added to the designer tray
                    context.Container.Add(copyChild as IComponent);

                    // Must also add everything below the command
                    AddAllChildren(copyChild, context);
                }
            }

            // Fourth pass, set correct ordering to match copy
            for (int i = 0; i < copyCount; i++)
            {
                // Grab indexed item from the copy
                MenuCommand copyChild = copy[i];

                // Get the command to look for in original
                MenuCommand origChild = copyChild.Original;

                // Find its indexed position in original collection
                int origIndex = orig.IndexOf(origChild);

                // If this is not its required position
                if (origIndex != i)
                {
                    // Remove it from collection
                    orig.Remove(origChild);

                    // Insert back in correct place
                    orig.Insert(i, origChild);
                }
            }

            // Fifth pass, process all children
            foreach (MenuCommand copyChild in copy)
            {
                // Does this node has an back pointer to its original?
                if (copyChild.Original != null)
                {
                    // Recurse down into the child collections
                    SynchronizeCollections(copyChild.Original.MenuCommands, copyChild.MenuCommands, context);
                }
            }
        }