コード例 #1
0
        /// <summary>
        ///     Create a ColumnPermutation object with a given set of
        ///     visible columns, in the order they should be displayed.
        /// </summary>
        /// <param name="totalColumns">
        ///     The total number of columns that can be visible. This
        ///     should correspond to the ColumnCount on the multicolumn tree.
        /// </param>
        /// <param name="visibleColumns">The columns that are visible.</param>
        /// <param name="preferLeftBlanks">
        ///     If there is a choice, attach blank cells to the
        ///     cell on the right instead of the cell on the left. Generally corresponds to the
        ///     RightToLeft property on the tree control.
        /// </param>
        public ColumnPermutation(int totalColumns, int[] visibleColumns, bool preferLeftBlanks)
        {
            var columns = new int[totalColumns];
            int i;

            // Initialize to -1
            for (i = 0; i < totalColumns; ++i)
            {
                columns[i] = -1;
            }

            // Walk the visibleColumns array and fill in the values. When we're done,
            // if (myColumns[i] != -1) then myVisibleColumns[myColumns[i]] == i
            int targetColumn;
            var visibleColumnCount = visibleColumns.Length;

            for (i = 0; i < visibleColumnCount; ++i)
            {
                targetColumn = visibleColumns[i];
                if (columns[targetColumn] != -1) // Let this throw naturally if the argument is out of range
                {
                    throw new ArgumentException(VirtualTreeStrings.GetString(VirtualTreeStrings.DuplicateColumnException), "visibleColumns");
                }
                columns[targetColumn] = i;
            }

            myColumns = columns;
            if (visibleColumns.IsReadOnly)
            {
                myVisibleColumns = visibleColumns;
            }
            else
            {
                myVisibleColumns = (int[])visibleColumns.Clone();
            }

            myPreferLeftBlanks = preferLeftBlanks;
        }
コード例 #2
0
        /// <summary>
        ///     Change the visible order to match the new order. This allows
        ///     a secondary ordering permutation, such as that used by the header control,
        ///     to work well with our permutation. This routine is optimized to expect a
        ///     single column moving, but will work correctly with any order modification.
        /// </summary>
        /// <param name="oldOrder">The old order, should correspond to the current display order.</param>
        /// <param name="newOrder">The new order. Compare columns to old order to deduce current display order.</param>
        public void ChangeVisibleColumnOrder(int[] oldOrder, int[] newOrder)
        {
            var columns = myVisibleColumns.Length;

            if (oldOrder.Length != columns &&
                newOrder.Length != columns)
            {
                throw new ArgumentException(VirtualTreeStrings.GetString(VirtualTreeStrings.InvalidColumnOrderArrayException));
            }

            // The algorithm finds the old values in the new array and moves a column
            // as soon as it is found. To make an accurate move, this means that the
            // positions that have already moved need to be marked as already processed,
            // so we duplicate the old array to enable writing to it.
            var startOrder = oldOrder.Clone() as int[];
            var startIndex = 0;
            var newIndex   = 0;
            int startCurrent;
            int newCurrent;
            var totalMarked             = 0;
            var permanentlyPassedMarked = 0;

            while (startIndex < columns &&
                   newIndex < columns)
            {
                if (-1 == (startCurrent = startOrder[startIndex]))
                {
                    // Slot already handle, go look for one that hasn't been
                    ++startIndex;
                    ++permanentlyPassedMarked;
                }
                else if (startCurrent == (newCurrent = newOrder[newIndex]))
                {
                    ++startIndex;
                    ++newIndex;
                }
                else
                {
                    // The values are different. The first step is to find the
                    // new value in the old array. We care about the position of
                    // the new value, as well as the number of already handled values
                    // after the located, which can be calculated by seeing how
                    // many marked values we pass on the value.
                    var passedMarked    = 0;
                    var foundStartIndex = -1;
                    int testValue;
                    for (var i = startIndex + 1; i < columns; ++i)
                    {
                        testValue = startOrder[i];
                        if (testValue == newCurrent)
                        {
                            foundStartIndex = i;
                            break;
                        }
                        else if (testValue == -1)
                        {
                            ++passedMarked;
                        }
                    }
                    if (foundStartIndex == -1)
                    {
                        // We're not going to find any more
                        break;
                    }

                    // Update the arrays accordingly
                    MoveVisibleColumn(foundStartIndex + (totalMarked - permanentlyPassedMarked - passedMarked), newIndex);

                    // Mark this node as processed
                    ++totalMarked;
                    startOrder[foundStartIndex] = -1;

                    // Move to next new item
                    ++newIndex;
                }
            }
        }