headergrid.java

CRM源码This file describes some issues that should be implemented in future and how it should be imple

            case Event.ONMOUSEDOWN:
                if(DOM.eventGetButton(event) == Event.BUTTON_RIGHT) {
                    invertSelection(x);
                } else {
                    startColumnResize(x);
                }
                break;
            case Event.ONDBLCLICK:
                autoresizeColumn(x);
                break;
            case Event.ONMOUSEUP:
                stopColumnResize();
                break;
            case Event.ONMOUSEMOVE:
                setupCursor(x);
                performColumnResize(x);
                break;
        }
    }

    /**
     * Invert column selection with the given coordinate. If column tuns to selected state and another column is already selected, then deselect it.
     * @param x column width coordinate
     */
    private void invertSelection(int x) {
        if(!isColumnsFake) {
            int column = getColumnNumber(x);
            invertColumnSelection(column);
        }
    }

    /**
     * Invert the given column selection. If column tuns to selected state and another column is already selected, then deselect it.
     * @param column column number
     */
    private void invertColumnSelection(int column) {
        if(lastColumnSelected == column) {
            removeColumnSelection();
        } else {
            setSelectedColumn(column);
        }
    }

    /**
     * Set the given column selected.
     * @param column given column
     */
    public void setSelectedColumn(int column) {
        if(column != lastColumnSelected) {
            deselectColumn(lastColumnSelected);
            selectColumn(column);
            lastColumnSelected = column;
            fireColumnSelected(COLUMN_UNSELECTED);
        }
    }

    /**
     * Removes selection from currently selected column
     */
    public void removeColumnSelection() {
        deselectColumn(lastColumnSelected);
        lastColumnSelected = COLUMN_UNSELECTED;
        fireColumnSelected(COLUMN_UNSELECTED);
    }

    /**
     * Makes header column selected.
     * @param column column number
     */
    private void selectColumn(int column) {
        if(column >= 0 && column < getColumnCount()) {
            getCellFormatter().addStyleName(0, column, view.getSelectedHeaderCellStyleName());
        }
    }

    /**
     * Makes header column not selected.
     * @param column column number
     */
    private void deselectColumn(int column) {
        if(column >= 0 && column < getColumnCount()) {
            getCellFormatter().removeStyleName(0, column, view.getSelectedHeaderCellStyleName());
        }
    }

    /**
     * Returns the column number by its x position. 
     * @param x width position
     * @return column number
     */
    private int getColumnNumber(int x) {
        int columnNum = COLUMN_UNSELECTED;
        for (int column = 0; column < columnOffsets.length; column++) {
            if (x < columnOffsets[column]) {
                columnNum = column;
                break;
            }
        }
        return columnNum;
    }

    /**
     * Last selected column. If at least one column selected, then value will be positive, otherwise negative.  
     * @return Last selected column.
     */
    public int getSelectedColumn() {
        return lastColumnSelected;
    }

    protected void fireColumnSelected(int column) {
        Events.COLUMN_SELECTED.setData(new Integer(column));
        getEventSource().fireEvent(Events.COLUMN_SELECTED);
    }

    public void handleMouseUpEvent(int x) {
        stopColumnResize();
    }

    public void autoresizeParticularColumn(int column, boolean saveToMeta){
        int newWidth = findMaximumRowWidth(column);
        int delta = newWidth - getHeaderCellWidth(column);
        strategy.setHeaderColumnWidth(this, column, newWidth, delta);
        dataGrid.resizeColumn(column, newWidth, delta);
        model.getDataGridMeta().getColumn(column).setResized(true);

        if(saveToMeta){
            saveColumnsWidthAndOffsets();
//            adaptGridSize();
        }
    }

    private void autoresizeColumn(int x){
        if(!isColumnsFake) {
            for (int column = 0; column < columnOffsets.length; column++) {
                if (x > (columnOffsets[column] - RESIZEABLE_AREA_OFFSET) && x < (columnOffsets[column] + RESIZEABLE_AREA_OFFSET)) {
                    cursorResizing = true;
                    columnToResize = column;
                    autoresizeParticularColumn(columnToResize, true);
                    parent.adjustHeaderPosition();
                }
            }
        }
    }

    private int findMaximumRowWidth(int column) {
        int longest = 0;
        for(int i = 0, n = dataGrid.getRowCount(); i < n; i++) {
            int txtLength = dataGrid.getText(i, column).length();
            if(txtLength > longest) {
                longest = txtLength;
            }
        }
        int captionLength = model.getDataGridMeta().getCaption(column).length();
        return Math.max(DataGrid.calcHeaderColumnWidth(captionLength), DataGrid.calcColumnWidth(longest));
    }

    private void setupCursor(int x) {
        if (!columnResizing) {
            String columnResizeStyleName = view.getColumnResizeStyleName();
            if(cursorResizing) {
                if (x < (columnOffsets[columnToResize] - RESIZEABLE_AREA_OFFSET) || x > (columnOffsets[columnToResize] + RESIZEABLE_AREA_OFFSET)) {
                    cursorResizing = false;
                    removeStyleName(columnResizeStyleName);
                }
            } else {
                for (int column = 0; column < columnOffsets.length; column++) {
                    if (x > (columnOffsets[column] - RESIZEABLE_AREA_OFFSET) && x < (columnOffsets[column] + RESIZEABLE_AREA_OFFSET)) {
                        cursorResizing = true;
                        columnToResize = column;
                        addStyleName(columnResizeStyleName);
                        break;
                    }
                    if (x < (columnOffsets[column] + 2 * RESIZEABLE_AREA_OFFSET)) {
                        break;
                    }
                }
            }
        }
    }

    public void performColumnResize(int x) {
        if (columnResizing) {
            int delta = x - originalResizePosition;
            int width = getHeaderCellWidth(columnToResize) + delta;
            if (width > DataGridColumn.MINIMAL_WIDTH) {
                strategy.setHeaderColumnWidth(this, columnToResize, width, delta);
                dataGrid.resizeColumn(columnToResize, width, delta);
                originalResizePosition = x;

                parent.adjustHeaderPosition();
            }
        }
    }

    private void startColumnResize(int x) {
        if (cursorResizing) {
            columnResizing = true;
            originalResizePosition = x;
            DOM.setCapture(getElement()); // to capture last column resize
        }
    }

    private void stopColumnResize() {
        if (columnResizing) {
            DOM.releaseCapture(getElement());
            columnResizing = false;
            if(!isColumnsFake) {
                model.getDataGridMeta().getColumn(columnToResize).setResized(true);
            }
            saveColumnsWidthAndOffsets();
        }
    }

    public void onCellClicked(SourcesTableEvents sender, int row, int cell) {
        if(!isColumnsFake) {
            if(cell != lastCellClicked){
                currentSortOrder = SortColumnImpl.getNextSortOrder(initialSortOrder);
            } else {
                currentSortOrder = SortColumnImpl.getNextSortOrder(currentSortOrder);
            }
            sortListeners.fireEvent(parent, new SortColumnImpl(cell, currentSortOrder));
            lastCellClicked = cell;
        }
    }

    // -------------------- public events ------------------------
    public static interface Events {
        com.queplix.core.client.common.event.Event/*]<Integer>[*/ COLUMN_SELECTED = new com.queplix.core.client.common.event.Event/*]<Integer>[*/();
    }

    private EventSource eventSource = new EventSource(this);

    public EventSource getEventSource() {
        return eventSource;
    }
    // ----------------- end of public events --------------------
}