コード例 #1
0
        /// <summary>
        ///     If the application developer has specified a GroupSizeReductionOrder, this
        ///     takes the next group in that order and tells it to reduce to its next size.
        ///     If no GroupSizeReductionOrder was specified, or if we need to collapse RibbonGroups
        ///     beyond what was specified by the developer, we reduce groups from right-to-left,
        ///     step by step in cyclical order.
        /// </summary>
        /// <returns>
        ///     Returns true if a group was located and resized successfully, false otherwise.
        /// </returns>
        internal bool DecreaseNextGroupSize()
        {
            bool resizeSuccessful = false;

            if (GroupSizeReductionOrder != null)
            {
                while (_groupReduceOrderLocation < GroupSizeReductionOrder.Count - 1 && !resizeSuccessful)
                {
                    // Find the group who's next to be reduced.
                    RibbonGroup targetGroup = FindRibbonGroupWithName(GroupSizeReductionOrder[++_groupReduceOrderLocation]);

                    if (targetGroup == null)
                    {
                        resizeSuccessful = false;
                    }
                    else
                    {
                        resizeSuccessful = targetGroup.DecreaseGroupSize();
                    }
                    _groupReductionResizeStatus.Add(resizeSuccessful);
                }
            }

            if (!resizeSuccessful)
            {
                // Either no GroupSizeReductionOrder was specified, or we've run out of predefined orderings.
                // In this case we should begin reducing groups in size right-to-left, step by step, in cyclical
                // order.
                resizeSuccessful = DefaultCyclicalReduceGroup();
            }

            return(resizeSuccessful);
        }
コード例 #2
0
        /// <summary>
        ///     From right-to-left, finds the next group who can be reduced in size.  If the leftmost
        ///     group is encountered reduction will continue in a cyclical fashion back at the rightmost
        ///     RibbonGroup.
        /// </summary>
        /// <returns>True if a group was successfully located and reduced in size, false otherwise.</returns>
        private bool DefaultCyclicalReduceGroup()
        {
            bool resizeSuccessful = false;

            if (_groupAutoResizeIndex == null)
            {
                _groupAutoResizeIndex = Items.Count - 1;
            }

            bool resizesRemain = true;

            while (resizesRemain && !resizeSuccessful)
            {
                int numAttempts = 0;
                do
                {
                    numAttempts++;
                    RibbonGroup group = ItemContainerGenerator.ContainerFromIndex((_groupAutoResizeIndex--).Value) as RibbonGroup;
                    if (group != null)
                    {
                        resizeSuccessful = group.DecreaseGroupSize();
                    }

                    if (resizeSuccessful == true)
                    {
                        _automaticResizeOrder.Add(_groupAutoResizeIndex.Value + 1);
                    }

                    // If we have underflowed our Groups collection, start again at the end.  This
                    // is what makes our group reduction cyclical.
                    if (_groupAutoResizeIndex.Value < 0)
                    {
                        _groupAutoResizeIndex = Items.Count - 1;
                        break;
                    }
                } while (resizeSuccessful == false);

                // If we failed to resize during this pass, and we attempted to resize for every
                // group, then there are no reamining groups to resize.
                if (numAttempts == Items.Count)
                {
                    resizesRemain = false;
                }
            }

            return(resizeSuccessful);
        }