headergrid.java

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

/*
 * Copyright 2006-2007 Queplix Corp.
 *
 * Licensed under the Queplix Public License, Version 1.1.1 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.queplix.com/solutions/commercial-open-source/queplix-public-license/
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 
 * License for the specific language governing permissions and limitations under
 * the License.
 */
package com.queplix.core.client.common.ui.grid;

import com.google.gwt.user.client.Command;
import com.google.gwt.user.client.DOM;
import com.google.gwt.user.client.DeferredCommand;
import com.google.gwt.user.client.Element;
import com.google.gwt.user.client.Event;
import com.google.gwt.user.client.ui.Grid;
import com.google.gwt.user.client.ui.SourcesTableEvents;
import com.google.gwt.user.client.ui.TableListener;
import com.queplix.core.client.common.StringUtil;
import com.queplix.core.client.common.event.EventSource;

/**
 * Header of DataGrid
 * @author Vasily Mikhailitchenko
 * @since 19 Dec 2006
 */
class HeaderGrid extends Grid implements TableListener {
    /**
     * None of cells selected.
     */
    private static final int COLUMN_UNSELECTED = -1;

    private static final int RESIZEABLE_AREA_OFFSET = 4;

    /**
     * Needed this for mouse events tracing
     */
    private int[] columnOffsets;
    /**
     * Current grid header captions
     */
    private String[] captions;
    /**
     * Current columns' sort orders
     */
    private Boolean[] sortOrders;
    /**
     * Is column resizing at the moment.
     */
    private boolean columnResizing;
    /**
     * Is cursor has resizing style (grid can turn to resizable state if user clicks mouse button).
     */
    private boolean cursorResizing;
    /**
     * Column to be resized
     */
    private int columnToResize;
    private int originalResizePosition;

    private Boolean initialSortOrder = null;
    private Boolean currentSortOrder;
    private int lastCellClicked = -1;

    private int lastColumnSelected = COLUMN_UNSELECTED;

    private boolean isColumnsFake = false;

    private GridModel model;
    private GridView view;

    private BaseInternalDataGrid dataGrid;
    private DataGrid parent;
    private GridElementsStrategy strategy;
    private GridSortListenerCollection sortListeners;

    public HeaderGrid(GridModel model,
                      GridView view,
                      DataGrid parent,
                      GridElementsStrategy strategy,
                      GridSortListenerCollection sortListeners) {

        // initialization
        this.model = model;
        this.view = view;
        this.parent = parent;
        this.strategy = strategy;
        this.sortListeners = sortListeners;

        resizeRows(1);
        sinkEvents(Event.MOUSEEVENTS);
        sinkEvents(Event.ONDBLCLICK);

        currentSortOrder = initialSortOrder;
        strategy.addTableListener(this);
        addTableListener(this);
    }

    public void setInternalDataGrid(BaseInternalDataGrid dataGrid){
        this.dataGrid = dataGrid;
    }

    public void resizeColumns(int columns) {
        if (columnOffsets == null || columnOffsets.length != columns) {
            columnOffsets = new int[columns];
            captions = new String[columns];
            sortOrders = new Boolean[columns];
        }
        super.resizeColumns(columns);
    }

    public void setupWidgets(final DataGridMeta dataGridMeta) {
        boolean performUpdate = false;
        if (dataGridMeta == null || dataGridMeta.getColumnsCount() < 1) {
            if(!isColumnsFake) {
                resizeColumns(1);
                setupFakeEmptyData();
                isColumnsFake = true;
                performUpdate = true;
            }
        } else {
            int columnsCount = dataGridMeta.getColumnsCount();
            if(getColumnCount() != columnsCount) {
                resizeColumns(columnsCount);
            }
            setupHeaders(dataGridMeta);
            isColumnsFake = false;
            performUpdate = true;
        }
        if(performUpdate) {
            removeColumnSelection();
            DeferredCommand.add(new Command() {
                public void execute() {
                    saveColumnsWidthAndOffsets();
    //                adaptGridSize();
                }
            });
        }
    }

    private void setupFakeEmptyData() {
        setCaption(0, "", null);
        getCellFormatter().setStyleName(0, 0, view.getHeaderCellStyleName());
        getRowFormatter().setStyleName(0, view.getHeaderRowStyleName());
    }

    private void setupHeaders(DataGridMeta dataGridMeta) {
        SortColumn sortColumn = model.getSortColumn();
        for (int column = 0; column < dataGridMeta.getColumnsCount(); column++) {
            Boolean sortBy = null;
            DataGridColumn dataGridColumn = dataGridMeta.getColumn(column);
            int startSize = dataGridColumn.getWidth();
            if(startSize == DataGridColumn.SIZE_UNSPECIFIED){
                startSize = DataGrid.calcHeaderColumnWidth(dataGridColumn.getCaption().length());
            }
            if(startSize < DataGridColumn.MINIMAL_WIDTH) {//initialize start site on attach event
                startSize = DataGridColumn.MINIMAL_WIDTH;
            }
            if(sortColumn != null) {
                if(column == sortColumn.getColumnIndex()) {
                    sortBy = sortColumn.getAscending();
                }
            }

            String newCaption = dataGridMeta.getCaption(column);
            if(!equalToCurrentCaption(newCaption, column, sortBy)) {
                setCaption(column, newCaption, sortBy);
                strategy.setHeaderColumnWidth(this, column, startSize, 0);
                getCellFormatter().setStyleName(0, column, view.getHeaderCellStyleName());
            }
            dataGrid.resizeColumn(column, startSize, 0);
        }
        getRowFormatter().addStyleName(0, view.getHeaderRowStyleName());
        saveColumnsWidthAndOffsets();
        setWidth(StringUtil.pixelToSize(dataGrid.getOffsetWidth()));
//        adaptGridSize();
    }

    private void setCaption(int column, String newCaption, Boolean sortBy) {
        captions[column] = newCaption;
        sortOrders[column] = sortBy;
        strategy.setHeaderCellValue(this, 0, column, newCaption, sortBy);
    }

    private boolean equalToCurrentCaption(String newCaption, int column, Boolean sortBy) {
        String oldCaption = captions[column];
        Boolean oldSortBy = sortOrders[column];
        
        if(oldSortBy == null){
            return (oldCaption != null) && oldCaption.equalsIgnoreCase(newCaption) && (sortBy == null);
        } else {
            return (oldCaption != null) && oldCaption.equalsIgnoreCase(newCaption) && oldSortBy.equals(sortBy);
        }
    }

    /*private void adaptGridSize() {
        String size = StringUtil.pixelToSize(columnOffsets[columnOffsets.length - 1]);
        DialogHelper.showMessageDialog("Size: " + size);
        setWidth(size);
        dataGrid.setWidth(size);
    }
*/
    public void saveColumnsWidthAndOffsets() {
        int offset = 0;
        for (int column = 0; column < columnOffsets.length; column++) {
            offset += getHeaderCellOffsetWidth(column);
            columnOffsets[column] = offset;
        }
        DataGridMeta dataGridMeta = model.getDataGridMeta();
        for (int i = 0, n = dataGridMeta.getColumnsCount(); i < n; i++){
            if(dataGridMeta.getColumn(i).isResized()){
                dataGridMeta.getColumn(i).setWidth(getHeaderCellWidth(i));
            }
        }
    }

    public int getHeaderCellWidth(int column) {
        Element tr = DOM.getChild(getBodyElement(), 0);
        Element td = DOM.getChild(tr, column);
        return DOM.getIntAttribute(td, "width");
    }

    private int getHeaderCellOffsetWidth(int column) {
        Element tr = DOM.getChild(getBodyElement(), 0);
        Element td = DOM.getChild(tr, column);
        return DOM.getIntAttribute(td, "offsetWidth");
    }

    public void onBrowserEvent(Event event) {
        int x = DOM.eventGetClientX(event) - DOM.getAbsoluteLeft(getElement());
        switch (DOM.eventGetType(event)) {