Source Code of org.gwtoolbox.widget.client.table.basic.BasicTable$ToolRowCell

package org.gwtoolbox.widget.client.table.basic;


import com.google.gwt.event.logical.shared.CloseEvent;
import com.google.gwt.event.logical.shared.CloseHandler;
import com.google.gwt.user.client.*;
import com.google.gwt.user.client.ui.*;
import org.gwtoolbox.widget.client.WidgetImages;
import org.gwtoolbox.widget.client.WidgetStyles;
import org.gwtoolbox.widget.client.button.SimpleMenuButton;
import org.gwtoolbox.widget.client.menu.MenuBuilder;
import org.gwtoolbox.widget.client.popup.Popup;
import org.gwtoolbox.widget.client.table.basic.selection.NoOpSelectionModel;
import org.gwtoolbox.widget.client.table.basic.selection.SelectionModel;
import org.gwtoolbox.widget.client.table.basic.sort.BasicTableSorter;
import org.gwtoolbox.widget.client.table.basic.sort.TableSorter;


/**
 * @author Uri Boness
 */
@SuppressWarnings({"MismatchedQueryAndUpdateOfCollection"})
public class BasicTable extends Composite {


    private static final int HEADER_ROW = 0;


    private static final boolean ASC_SORT_DIRECTION = true;
    private static final String STYLE_NAME = "BasicTable";
    private static final String HEADER_STYLE_NAME = "Header";
    private static final String ROW_STYLE_NAME = "Row";
    private static final String TOOL_ROW_STYLE_NAME = "ToolRow";
    private static final String CELL_STYLE_NAME = "Cell";


    private static final int INTERNAL_EVENT_BITS = Event.ONMOUSEDOWN | Event.ONMOUSEUP | Event.ONMOUSEMOVE;


    private final BasicColumnFormatter columnFormatter;
    private final BasicTableHeaderFormatter headerFormatter;
    private final BasicTableCellFormatter cellFormatter;
    private final BasicTableRowFormatter rowFormatter;


    private FlexTable table;


    private int currentSortColumn = -1;
    private boolean currentSortDirection = ASC_SORT_DIRECTION;
    private TableSorter sorter = new BasicTableSorter();
    private ColumnSortingListenerCollection sortingListeners = new ColumnSortingListenerCollection();


    private CellListenerCollection cellListeners = new CellListenerCollection();


    private SelectionModel selectionModel;


    public BasicTable() {


        table = new FlexTable();
        table.setCellPadding(0);
        table.setCellSpacing(0);
        
        table.insertRow(0);
        Element headerElement = table.getRowFormatter().getElement(0);
        UIObject.setStylePrimaryName(headerElement, HEADER_STYLE_NAME);


        columnFormatter = new BasicColumnFormatter();
        headerFormatter = new BasicTableHeaderFormatter();
        cellFormatter = new BasicTableCellFormatter(this);
        rowFormatter = new BasicTableRowFormatter(table.getRowFormatter());


        sortingListeners.add(new ColumnSortingListener() {
            public void sortChanged(int column, boolean asc) {
                getSelectionModel().getSelection().clear();
                getSorter().sort(BasicTable.this, column, asc);
            }
        });
        initWidget(table);
        setStyleName(STYLE_NAME);
        sinkEvents(INTERNAL_EVENT_BITS);
        setSelectionModel(NoOpSelectionModel.getInstance());
    }


    public SelectionModel getSelectionModel() {
        return selectionModel;
    }


    public void setSelectionModel(SelectionModel selectionModel) {
        if (this.selectionModel != null) {
            this.selectionModel.getSelection().clear();
            this.selectionModel.uninstall();
        }
        this.selectionModel = selectionModel;
        selectionModel.install(this);
    }


    public void clearSelectionModel() {
        setSelectionModel(NoOpSelectionModel.getInstance());
    }


    public void setHeaderText(int column, String text) {
        setHeaderWidget(column, new Label(text));
    }


    public void setHeaderHTML(int column, String html) {
        setHeaderWidget(column, new HTML(html));
    }


    public void setHeaderWidget(final int column, Widget widget) {
        setHeaderWidget(column, widget, null);
    }


    public void setHeaderWidget(final int column, Widget widget, MenuBuilder menuBuilder) {
        final HeaderCell cell = new HeaderCell(widget) {
            protected void handleClick(Event event) {
                if (sortLabel.isSortable()) {
                    boolean direction = (currentSortColumn == column) ? !currentSortDirection : ASC_SORT_DIRECTION;
                    sort(getCell().getColumn(), direction);
                }
            }
        };
        table.setWidget(HEADER_ROW, column, cell);
        table.getCellFormatter().setWordWrap(HEADER_ROW, column, false);
        table.getCellFormatter().setStyleName(HEADER_ROW, column, "hidden-overflow");
    }


    public BasicColumnFormatter getColumnFormatter() {
        return columnFormatter;
    }


    public BasicTableCellFormatter getCellFormatter() {
        return cellFormatter;
    }


    public BasicTableRowFormatter getRowFormatter() {
        return rowFormatter;
    }


    public BasicTableHeaderFormatter getHeaderFormatter() {
        return headerFormatter;
    }


    public int getRowCount() {
        return table.getRowCount() - 1;
    }


    public int getColumnCount() {
        return table.getCellCount(HEADER_ROW);
    }


    public void setBorder(int width) {
        table.setBorderWidth(width);
    }


    public void insertToolRow(int beforeRow, Widget tool) {
        table.insertRow(beforeRow + 1);
        getRowFormatter().setStylePrimaryName(beforeRow, TOOL_ROW_STYLE_NAME);
        table.setWidget(beforeRow + 1, 0, new ToolRowCell(tool));
        table.getCellFormatter().setWordWrap(beforeRow + 1, 0, false);
        table.getCellFormatter().setStylePrimaryName(beforeRow + 1, 0, "hidden-overflow");
        getCellFormatter().setColSpan(beforeRow, 0, getColumnCount());
    }


    public void insertRow(int beforeRow) {
        table.insertRow(beforeRow + 1);
        getRowFormatter().setStylePrimaryName(beforeRow, ROW_STYLE_NAME);
        Element element = getRowFormatter().getElement(beforeRow);
    }


    public void insertCell(int beforeRow, int beforeColumn) {
        table.insertCell(beforeRow + 1, beforeColumn);
        getRowFormatter().setStylePrimaryName(beforeRow, ROW_STYLE_NAME);
        Element element = getRowFormatter().getElement(beforeRow);
    }


    public void removeRow(int row) {
        table.removeRow(row + 1);
    }


    public void removeCell(int row, int column) {
        table.removeCell(row + 1, column);
    }


    public void removeCells(int row, int column, int num) {
        table.removeCells(row + 1, column, num);
    }


    public void removeAllRows() {
        while (getRowCount() != 0) {
            removeRow(0);
        }
    }


    public void setWidet(int row, int column, Widget widget) {
        setWidet(row, column, widget, null);
    }


    public void setWidet(final int row, int column, Widget widget, Object userData) {
        if (table.isCellPresent(row + 1, column)) {
            TableCell cell = (TableCell) table.getWidget(row + 1, column);
            cell.setContent(widget);
            return;
        }


        final RowCell cell = new RowCell(widget, userData) {
            protected void handleMouseOut(Event event) {
                Cell c = getCell();
                selectionModel.handleCellMouseOut(c.getRow(), c.getColumn(), event);
            }


            protected void handleMouseOver(Event event) {
                Cell c = getCell();
                selectionModel.handleCellMouseEntered(c.getRow(), c.getColumn(), event);
            }


            protected void handleClick(Event event) {
                Cell c = getCell();
                selectionModel.handleCellClicked(c.getRow(), c.getColumn(), event);
            }


            protected void handleMouseDown(Event event) {
                Cell c = getCell();
                selectionModel.handleCellMouseDown(c.getRow(), c.getColumn(), event);
            }


            protected void handleMouseUp(Event event) {
                Cell c = getCell();
                selectionModel.handleCellMouseUp(c.getRow(), c.getColumn(), event);
            }
        };
        table.setWidget(row + 1, column, cell);
        table.getCellFormatter().setWordWrap(row + 1, column, false);
        table.getCellFormatter().setStylePrimaryName(row + 1, column, "hidden-overflow");
        getRowFormatter().setStylePrimaryName(row, ROW_STYLE_NAME);
        getCellFormatter().setWordWrap(row, column, false);
    }


    public void setText(int row, int column, String text) {
        setWidet(row, column, new Label(text));
    }


    public void setHTML(int row, int column, String html) {
        setWidet(row, column, new HTML(html));
    }


    public Widget getWidget(int row, int column) {
        return getRowCell(row, column).getContent();
    }


    public void setUserData(int row, int column, Object userData) {
        getRowCell(row, column).setUserData(userData);
    }


    public Object getUserData(int row, int column) {
        return getRowCell(row, column).getUserData();
    }


    public void addCell(int row) {
        table.addCell(row + 1);
        getRowFormatter().setStylePrimaryName(row, ROW_STYLE_NAME);
    }


    public void clearCell(int row, int column) {
        table.clearCell(row + 1, column);
    }


    public int getCellCount(int row) {
        return table.getCellCount(row + 1);
    }


    public void setCellPadding(int padding) {
        table.setCellPadding(padding);
    }


    public void setCellSpacing(int spacing) {
        table.setCellSpacing(spacing);
    }


    public boolean isCellPresent(int row, int column) {
        return table.isCellPresent(row + 1, column);
    }


    public void addColumnSortingListener(ColumnSortingListener listener) {
        sortingListeners.add(listener);
    }


    public void removeColumnSortingListener(ColumnSortingListener listener) {
        sortingListeners.remove(listener);
    }


    public void clearColumnSortingListeners() {
        sortingListeners.clear();
    }


    public void addCellListener(CellListener listener) {
        cellListeners.add(listener);
    }


    public void removeCellListener(CellListener listener) {
        cellListeners.remove(listener);
    }


    public void clearCellListeners() {
        cellListeners.clear();
    }


    public void setSorter(TableSorter sorter) {
        this.sorter = sorter;
    }


    public TableSorter getSorter() {
        return sorter;
    }


    public void sort(int column, boolean asc) {
        if (currentSortColumn == column && currentSortDirection == asc) {
            return;
        }
        if (currentSortColumn >= 0) {
            getHeaderCell(currentSortColumn).setSort(null);
        }
        currentSortColumn = column;
        currentSortDirection = asc;
        getHeaderCell(column).setSort(currentSortDirection);


        // do we really need to execute it in a deferred command?
        DeferredCommand.addCommand(new Command() {
            public void execute() {
                sortingListeners.notifySortChanged(currentSortColumn, currentSortDirection);
            }
        });
    }


    public FlexTable getFlexTable() {
        return table;
    }


    public boolean isToolRow(int row) {
        Widget widget = table.getWidget(row + 1, 0);
        return (widget instanceof ToolRowCell);
    }


    //============================================== Helper Methods ====================================================


    private RowCell getRowCell(int row, int column) {
        return (RowCell) table.getWidget(row + 1, column);
    }


    private ToolRowCell getToolRowCell(int row) {
        return (ToolRowCell) table.getWidget(row + 1, 0);
    }


    private HeaderCell getHeaderCell(int column) {
        return (HeaderCell) table.getWidget(HEADER_ROW, column);
    }


    //============================================== Inner Classes =====================================================


    public class BasicColumnFormatter {


        public void addStyleName(int col, String styleName) {
            table.getColumnFormatter().setStyleName(col, styleName);
        }


        public String getStyleName(int column) {
            return table.getColumnFormatter().getStyleName(column);
        }


        public String getStylePrimaryName(int column) {
            return table.getColumnFormatter().getStylePrimaryName(column);
        }


        public void removeStyleName(int column, String styleName) {
            table.getColumnFormatter().removeStyleName(column, styleName);
        }


        public void setStyleName(int column, String styleName) {
            table.getColumnFormatter().setStyleName(column, styleName);
        }


        public void setStylePrimaryName(int column, String styleName) {
            table.getColumnFormatter().setStylePrimaryName(column, styleName);
        }


        public void setWidth(int column, String width) {
            table.getColumnFormatter().setWidth(column, width);
        }


    }


    public class BasicTableHeaderFormatter {


        public void setStyleName(String styleName) {
            table.getRowFormatter().setStyleName(HEADER_ROW, styleName);
        }


        public void setStyleName(int column, String styleName) {
            getHeaderCell(column).setStyleName(styleName);
        }


        public void addStyleName(String styleName) {
            table.getRowFormatter().addStyleName(HEADER_ROW, styleName);
        }


        public void removeStyleName(String styleName) {
            table.getRowFormatter().removeStyleName(HEADER_ROW, styleName);
        }


        public Element getElement() {
            return table.getRowFormatter().getElement(HEADER_ROW);
        }


        public Element getElement(int column) {
            return table.getCellFormatter().getElement(HEADER_ROW, column);
        }


        public String getStyleName() {
            return table.getRowFormatter().getStyleName(HEADER_ROW);
        }


        public String getStylePrimaryName() {
            return table.getRowFormatter().getStylePrimaryName(HEADER_ROW);
        }


        public void setStylePrimaryName(String styleName) {
            table.getRowFormatter().setStylePrimaryName(HEADER_ROW, styleName);
        }


        public void setVisible(int column, boolean visible) {
            table.getCellFormatter().setVisible(HEADER_ROW, column, visible);
        }


        public void setVisible(boolean visible) {
            table.getRowFormatter().setVisible(HEADER_ROW, visible);
        }


        public boolean isVisible() {
            return table.getRowFormatter().isVisible(HEADER_ROW);
        }


        public void setVerticalAlign(HasVerticalAlignment.VerticalAlignmentConstant align) {
            table.getRowFormatter().setVerticalAlign(HEADER_ROW, align);
        }


        public void setHorizontalAlignment(int column, HasHorizontalAlignment.HorizontalAlignmentConstant align) {
            getHeaderCell(column).setHorizontalAlignment(align);
        }


        public void setSortable(int column, boolean sortable) {
            getHeaderCell(column).setSortable(sortable);
        }


        public void setMenuBar(int column, MenuBuilder menuBuilder) {
            getHeaderCell(column).setMenuBar(menuBuilder);
        }
    }


    public class BasicTableRowFormatter {


        private final HTMLTable.RowFormatter rowFormatter;


        public BasicTableRowFormatter(HTMLTable.RowFormatter rowFormatter) {
            this.rowFormatter = rowFormatter;
        }


        public void setStyleName(int row, String styleName) {
            rowFormatter.setStyleName(row + 1, styleName);
        }


        public void addStyleName(int row, String styleName) {
            rowFormatter.addStyleName(row + 1, styleName);
        }


        public void removeStyleName(int row, String styleName) {
            rowFormatter.removeStyleName(row + 1, styleName);
        }


        public Element getElement(int row) {
            return rowFormatter.getElement(row + 1);
        }


        public String getStyleName(int row) {
            return rowFormatter.getStyleName(row + 1);
        }


        public String getStylePrimaryName(int row) {
            return rowFormatter.getStylePrimaryName(row + 1);
        }


        public void setStylePrimaryName(int row, String styleName) {
            rowFormatter.setStylePrimaryName(row + 1, styleName);
        }


        public void setVisible(int row, boolean visible) {
            rowFormatter.setVisible(row + 1, visible);
        }


        public boolean isVisible(int row) {
            return rowFormatter.isVisible(row + 1);
        }


        public void setVerticalAlign(int row, HasVerticalAlignment.VerticalAlignmentConstant align) {
            rowFormatter.setVerticalAlign(row + 1, align);
        }


    }


    public static class BasicTableCellFormatter {


        private final BasicTable table;


        private final FlexTable.FlexCellFormatter cellFormatter;


        public BasicTableCellFormatter(BasicTable table) {
            this.table = table;
            this.cellFormatter = table.table.getFlexCellFormatter();
        }


        public void setStyleName(int row, int column, String styleName) {
            cellFormatter.setStyleName(row + 1, column, styleName);
        }


        public void setHorizontalAlignment(int row, int column, HasHorizontalAlignment.HorizontalAlignmentConstant align) {
            table.getRowCell(row, column).setHorizontalAlignment(align);
        }


        public void setVerticalAlignment(int row, int column, HasVerticalAlignment.VerticalAlignmentConstant align) {
            table.getRowCell(row, column).setVerticalAlignment(align);
        }


        public void addStyleName(int row, int column, String styleName) {
            table.getRowCell(row, column).addStyleName(styleName);
        }


        public void setVisible(int row, int column, boolean visible) {
            cellFormatter.setVisible(row + 1, column, visible);
        }


        public boolean isVisible(int row, int column) {
            return cellFormatter.isVisible(row + 1, column);
        }


        public void removeStyleName(int row, int column, String styleName) {
            table.getRowCell(row, column).removeStyleName(styleName);
        }


        public String getStyleName(int row, int column) {
            return table.getRowCell(row, column).getStyleName();
        }


        public Element getElement(int row, int column) {
            return cellFormatter.getElement(row + 1, column);
        }


        public void setStylePrimaryName(int row, int column, String styleName) {
            table.getRowCell(row, column).setStylePrimaryName(styleName);
        }


        public String getStylePrimaryName(int row, int column) {
            return table.getRowCell(row, column).getStylePrimaryName();
        }


        public void setHeight(int row, int column, String height) {
            cellFormatter.setHeight(row, column, height);
        }


        public void setWidth(int row, int column, String width) {
            cellFormatter.setWidth(row + 1, column, width);
        }


        public void setWordWrap(int row, int column, boolean wrap) {
            cellFormatter.setWordWrap(row + 1, column, wrap);
        }


        public void setColSpan(int row, int column, int span) {
            cellFormatter.setColSpan(row + 1, column, span);
        }


        public void setRowSpan(int row, int column, int span) {
            cellFormatter.setRowSpan(row + 1, column, span);
        }
    }


    protected class HeaderCell extends TableCell {


        protected final SortLabel sortLabel;
        private final Label resizeHandle;
        private SimpleMenuButton button;


        private boolean hovering;


        public HeaderCell() {
            this(null);
        }


        public HeaderCell(Widget content) {
            this(content, false);
        }


        public HeaderCell(Widget content, boolean sortable) {
            super(null);
            sortLabel = new SortLabel(content, sortable);
            setContent(sortLabel);
            sinkEvents(Event.ONMOUSEOVER | Event.ONMOUSEOUT | Event.ONCLICK);


            resizeHandle = new Label();
            resizeHandle.addMouseListener(new ResizeHandleMouseListener(resizeHandle, this, BasicTable.this));
            resizeHandle.setStylePrimaryName("Split");
            resizeHandle.setSize("2px", "100%");
            hp.add(resizeHandle);
            hp.setCellWidth(resizeHandle, "2px");
            hp.setCellHeight(resizeHandle, "100%");
        }


        public void onBrowserEvent(Event event) {
            switch (event.getTypeInt()) {
                case Event.ONMOUSEOVER:
                    hovering = true;
                    updateUI();
                    break;
                case Event.ONMOUSEOUT:
                    hovering = false;
                    if (button != null && button.isMenuOpen()) {
                        return;
                    }
                    updateUI();
                    break;
                case Event.ONCLICK:
                    handleClick(event);
                    break;
            }
        }


        private void updateUI() {
            if (hovering && sortLabel.isSortable()) {
                addStyleDependentName("hover");
            } else if (!hovering && sortLabel.isSortable()) {
                removeStyleDependentName("hover");
            }
            if (button != null) {
                button.setVisible(hovering);
            }
        }


        @SuppressWarnings({"UnusedDeclaration"})
        protected void handleClick(Event event) {
        }


        public void setSort(Boolean asc) {
            if (asc == null) {
                removeStyleDependentName("sort");
            } else {
                addStyleDependentName("sort");
            }
            sortLabel.setSort(asc);
        }


        public void setSortable(boolean sortable) {
            sortLabel.setSortable(sortable);
            if (sortable) {
                addStyleDependentName("sortable");
            } else {
                removeStyleDependentName("sortable");
            }
        }


        public void setMenuBar(MenuBuilder menuBuilder) {
            if (button == null) {
                PushButton pbutton = new PushButton(WidgetImages.Instance.get().tableHeaderButton().createImage());
                pbutton.setStyleName("nostyle");
                pbutton.getUpHoveringFace().setImage(WidgetImages.Instance.get().tableHeaderButton_Hover().createImage());
                pbutton.setWidth("15px");
                pbutton.setHeight("100%");
                button = new SimpleMenuButton(pbutton, true);
                button.addCloseHandler(new CloseHandler<Popup>() {
                    public void onClose(CloseEvent<Popup> basicPopup2CloseEvent) {
                        updateUI();
                    }
                });
                hp.insert(button, 1);
                hp.setCellWidth(button, "15px");
                hp.setCellHeight(button, "100%");
                button.setVisible(false);
            }
            menuBuilder.build(button.getMenu());
        }
    }


    protected class RowCell extends TableCell {


        public RowCell(Widget content, Object userData) {
            super(content, userData);
            if (content instanceof HasWordWrap) {
                ((HasWordWrap) content).setWordWrap(false);
            }
            sinkEvents(Event.MOUSEEVENTS | Event.ONDBLCLICK | Event.ONCONTEXTMENU | Event.ONCLICK);
        }


        public void onBrowserEvent(Event event) {
            switch (event.getTypeInt()) {
                case Event.ONCLICK:
                    handleClick(event);
                    break;
                case Event.ONMOUSEOVER:
                    handleMouseOver(event);
                    break;
                case Event.ONMOUSEOUT:
                    handleMouseOut(event);
                    break;
                case Event.ONMOUSEDOWN:
                    handleMouseDown(event);
                    break;
                case Event.ONMOUSEUP:
                    handleMouseUp(event);
                    break;
                case Event.ONDBLCLICK:
                    Cell cell = getCell();
                    handleDoubleClick(cell.getRow(), cell.getColumn(), event);
                    break;
                case Event.ONCONTEXTMENU:
                    cell = getCell();
                    handleDoubleClick(cell.getRow(), cell.getColumn(), event);
            }
        }


        protected void handleClick(Event event) {
        }


        protected void handleMouseOver(Event event) {
        }


        protected void handleMouseOut(Event event) {
        }


        protected void handleMouseDown(Event event) {
        }


        protected void handleMouseUp(Event event) {
        }


        @SuppressWarnings({"UnusedDeclaration"})
        protected void handleContextMenu(int row, int column, Event event) {
            cellListeners.notifyRightClick(row, column, event);
        }


        @SuppressWarnings({"UnusedDeclaration"})
        protected void handleDoubleClick(int row, int column, Event event) {
            cellListeners.notifyDoubleClick(row, column, event);
        }
    }


    protected class ToolRowCell extends TableCell {


        public ToolRowCell(Widget content) {
            super(content);
        }


    }


    /**
     * Will serve later on to add context menu to the headers as well as column dragging capabilities.
     */
    protected class TableCell extends Composite {


        protected final Grid main;


        protected final HorizontalPanel hp;


        private Object userData;


        public TableCell() {
            this(null);
        }


        public TableCell(Widget content) {
            this(content, null);
        }


        public TableCell(Widget content, Object userData) {
            this.userData = userData;


            main = new Grid(1, 1);
            main.setCellPadding(0);
            main.setCellSpacing(0);
            if (content != null) {
                main.setWidget(0, 0, content);
            }
            main.setSize("100%", "100%");


            hp = new HorizontalPanel();
            hp.setSize("100%", "100%");
            hp.add(main);
            hp.setCellWidth(main, "100%");
            initWidget(hp);
            setStylePrimaryName(CELL_STYLE_NAME);
        }


        public Cell getCell() {
            Element td = DOM.getParent(getElement());
            Element tr = DOM.getParent(td);
            Element tbody = DOM.getParent(tr);
            int column = DOM.getChildIndex(tr, td);
            int row = DOM.getChildIndex(tbody, tr) - 1;
            return new Cell(row, column);
        }


        public void setTextContent(String text) {
            setContent(new Label(text));
        }


        public void setHTMLContent(String html) {
            setContent(new HTML(html));
        }


        public void setContent(Widget widget) {
            main.setWidget(0, 0, widget);
        }


        public Widget getContent() {
            return main.getWidget(0, 0);
        }


        public Object getUserData() {
            return userData;
        }


        public void setUserData(Object userData) {
            this.userData = userData;
        }


        public void setVerticalAlignment(HasVerticalAlignment.VerticalAlignmentConstant align) {
            main.getCellFormatter().setVerticalAlignment(0, 0, align);
        }


        public void setHorizontalAlignment(HasHorizontalAlignment.HorizontalAlignmentConstant align) {
            main.getCellFormatter().setHorizontalAlignment(0, 0, align);
        }




    }


    public static class SortLabel extends Composite {


        private Image image;


        private boolean sortable;


        public SortLabel(Widget content, boolean sortable) {
            this.sortable = sortable;
            HorizontalPanel main = new HorizontalPanel();
            main.setSpacing(0);


            main.add(content);
            image = WidgetImages.Instance.get().sort_None().createImage();
            image.setSize("13px", "5px");


            main.add(image);
            main.setCellVerticalAlignment(image, HorizontalPanel.ALIGN_MIDDLE);


            initWidget(main);
            setStylePrimaryName("SortLabel");
        }


        public void setSort(Boolean asc) {
            if (!sortable) {
                return;
            }
            if (asc == null) {
                WidgetImages.Instance.get().sort_None().applyTo(image);
            } else if (asc) {
                WidgetImages.Instance.get().sort_Asc().applyTo(image);
            } else {
                WidgetImages.Instance.get().sort_Desc().applyTo(image);
            }
        }


        public boolean isSortable() {
            return sortable;
        }


        public void setSortable(boolean sortable) {
            this.sortable = sortable;
            if (!sortable) {
                WidgetImages.Instance.get().sort_None().applyTo(image);
            }
        }
    }


    //============================================= Column Resizing ====================================================


    // this slitter is final and static as it is shared by all tables


    private final static Label splitter = new Label();


    // the splitter is added to the root panel once when this class is loaded, and for the rest, whenever the splitter
    // is used only its visibility is modified.
    static {
        splitter.setStyleName("BasicTableHeaderResizeIndicator");
        WidgetStyles.putInDragLayer(splitter);
        splitter.setVisible(false);
        RootPanel.get().add(splitter);
    }


    protected static class ResizeHandleMouseListener extends MouseListenerAdapter {


        private final Label handle;
        private final HeaderCell headerCell;
        private final BasicTable table;


        private boolean dragging = false;
        private int draggedColumn = -1;
        private int draggingXOffset = -1;
        private int tableRight = -1;


        public ResizeHandleMouseListener(Label handle, HeaderCell headerCell, BasicTable table) {
            this.handle = handle;
            this.headerCell = headerCell;
            this.table = table;
        }


        public void onMouseDown(Widget sender, int x, int y) {
            dragging = true;
            Cell cell = headerCell.getCell();
            draggedColumn = cell.getColumn();
            draggingXOffset = x + sender.getAbsoluteLeft();
            tableRight = table.getAbsoluteLeft() + table.getOffsetWidth();
            RootPanel.get().setWidgetPosition(splitter, draggingXOffset, table.getAbsoluteTop());
            splitter.setSize("1px", table.getOffsetHeight() + "px");
            splitter.setVisible(true);
            Event.setCapture(handle.getElement());
        }


        public void onMouseUp(Widget sender, int x, int y) {
            if (!dragging) {
                return;
            }
            x = sender.getAbsoluteLeft() + x;
            Event.releaseCapture(handle.getElement());
            dragging = false;
            int delta = x - draggingXOffset;
            int newWidth = table.table.getFlexCellFormatter().getElement(HEADER_ROW, draggedColumn).getOffsetWidth() + delta;
            table.getColumnFormatter().setWidth(draggedColumn, newWidth + "px");
            draggedColumn = -1;
            draggingXOffset = -1;
            splitter.setVisible(false);
        }


        public void onMouseMove(Widget sender, int x, int y) {
            if (!dragging) {
                return;
            }
            x = sender.getAbsoluteLeft() + x;
            int left = table.getAbsoluteLeft();
            if (x > tableRight) {
                x = tableRight;
            } else if (x < left) {
                x = left;
            }
            RootPanel.get().setWidgetPosition(splitter, x, table.getAbsoluteTop());
        }
    }


}
Source Code of org.gwtoolbox.widget.client.table.basic.BasicTable$ToolRowCell

Related Classes of org.gwtoolbox.widget.client.table.basic.BasicTable$ToolRowCell
