* Ext GWT 2.2.4 - Ext for GWT

* Copyright(c) 2007-2010, Ext JS, LLC.

* licensing@extjs.com

*

* http://extjs.com/license

*/

* This class encapsulates the user interface of an {@link Grid}. Methods of

* this class may be used to access user interface elements to enable special

* display effects. Do not change the DOM structure of the user interface. </p>

* <p />

* This class does not provide ways to manipulate the underlying data. The data

* model of a Grid is held in an {@link ListStore}.

*/

   * Icons used by Grid which can be overridden as needed. s

   */

  public class GridViewImages {

    private AbstractImagePrototype columns = GXT.IMAGES.grid_columns();

    private AbstractImagePrototype sortAsc = GXT.IMAGES.grid_sortAsc();

    private AbstractImagePrototype sortDesc = GXT.IMAGES.grid_sortDesc();

    public AbstractImagePrototype getColumns() {

      return columns;

    }

    public AbstractImagePrototype getSortAsc() {

      return sortAsc;

    }

    public AbstractImagePrototype getSortDesc() {

      return sortDesc;

    }

    public void setColumns(AbstractImagePrototype columnsIcon) {

      this.columns = columnsIcon;

    }

    public void setSortAsc(AbstractImagePrototype sortAscIcon) {

      this.sortAsc = sortAscIcon;

    }

    public void setSortDesc(AbstractImagePrototype sortDescIcon) {

      this.sortDesc = sortDescIcon;

    }

  }

  private static JavaScriptObject colRe;

  protected int activeHdIndex;

  protected boolean autoFill;

  protected int borderWidth = 2;

  protected ColumnModel cm;

  protected Listener<ColumnModelEvent> columnListener;

  protected boolean deferEmptyText;

  protected ListStore<ModelData> ds;

  // elements

  protected El el, mainWrap, mainHd, innerHd, scroller, mainBody, focusEl;

  protected String emptyText = "&nbsp;";

  protected boolean enableHdMenu = true;

  // config

  protected boolean enableRowBody;

  protected boolean focusEnabled = true;

  protected ColumnFooter footer;

  protected boolean forceFit;

  protected Grid<ModelData> grid;

  protected ColumnHeader header;

  protected int headerColumnIndex;

  protected boolean headerDisabled;

  protected GridViewImages images;

  protected int lastViewWidth;

  protected StoreListener<ModelData> listener;

  protected Element overRow;

  protected boolean preventScrollToTopOnRefresh;

  protected int scrollOffset = XDOM.getScrollBarWidth();

  protected boolean selectable = false;

  protected SortInfo sortState;

  protected int splitterWidth = 5;

  protected GridTemplates templates;

  protected boolean userResized;

  // we first render grid with a vbar, and remove as needed

  protected boolean vbar = true;

  protected GridViewConfig viewConfig;

  protected List<List<Widget>> widgetList = new ArrayList<List<Widget>>();

  private DelayedTask addTask = new DelayedTask(new Listener<BaseEvent>() {

    public void handleEvent(BaseEvent be) {

      calculateVBar(false);

      refreshFooterData();

    }

  });

  private boolean adjustForHScroll = true;

  private String cellSelector = "td.x-grid3-cell";

  private int cellSelectorDepth = 4;

  private DelayedTask removeTask = new DelayedTask(new Listener<BaseEvent>() {

    public void handleEvent(BaseEvent be) {

      calculateVBar(false);

      applyEmptyText();

      refreshFooterData();

      processRows(0, false);

    }

  });

  private String rowSelector = "div.x-grid3-row";

  private int rowSelectorDepth = 10;

  private boolean showDirtyCells = true;

  private boolean showInvalidCells;

  /**

   * Ensured the current row and column is visible.

   *

   * @param row the row index

   * @param col the column index

   * @param hscroll true to scroll horizontally if needed

   * @return the calculated point

   */

  public Point ensureVisible(int row, int col, boolean hscroll) {

    if (grid == null || !grid.isViewReady() || row < 0 || row > ds.getCount()) {

      return null;

    }

    if (col == -1) {

      col = 0;

    }

    Element rowEl = getRow(row);

    Element cellEl = null;

    if (!(!hscroll && col == 0)) {

      while (cm.isHidden(col)) {

        col++;

      }

      cellEl = getCell(row, col);

    }

    if (rowEl == null) {

      return null;

    }

    Element c = scroller.dom;

    int ctop = 0;

    Element p = rowEl, stope = el.dom;

    while (p != null && p != stope) {

      ctop += p.getOffsetTop();

      p = p.getOffsetParent().cast();

    }

    ctop -= mainHd.dom.getOffsetHeight();

    int cbot = ctop + rowEl.getOffsetHeight();

    int ch = c.getOffsetHeight();

    int stop = c.getScrollTop();

    int sbot = stop + ch;

    if (ctop < stop) {

      c.setScrollTop(ctop);

    } else if (cbot > sbot) {

      if (hscroll && (cm.getTotalWidth() > scroller.getWidth() - scrollOffset)) {

        cbot += scrollOffset;

      }

      c.setScrollTop(cbot -= ch);

    }

    if (hscroll && cellEl != null) {

      int cleft = cellEl.getOffsetLeft();

      int cright = cleft + cellEl.getOffsetWidth();

      int sleft = c.getScrollLeft();

      int sright = sleft + c.getOffsetWidth();

      if (cleft < sleft) {

        c.setScrollLeft(cleft);

      } else if (cright > sright) {

        c.setScrollLeft(cright - scroller.getStyleWidth());

      }

    }

    return cellEl != null ? fly(cellEl).getXY() : new Point(c.getScrollLeft(), fly(rowEl).getY());

  }

  /**

   * Returns the cell.

   *

   * @param elem the cell element or a child element

   * @return the cell element

   */

  public Element findCell(Element elem) {

    if (elem == null) {

      return null;

    }

    return fly(elem).findParentElement(cellSelector, cellSelectorDepth);

  }

  /**

   * Returns the cell index.

   *

   * @param elem the cell or child element

   * @param requiredStyle an optional required style name

   * @return the cell index or -1 if not found

   */

  public int findCellIndex(Element elem, String requiredStyle) {

    Element cell = findCell(elem);

    if (cell != null && (requiredStyle == null || fly(cell).hasStyleName(requiredStyle))) {

      return getCellIndex(cell);

    }

    return -1;

  }

  /**

   * Returns the row element.

   *

   * @param el the row element or any child element

   * @return the matching row element

   */

  public Element findRow(Element el) {

    if (el == null) {

      return null;

    }

    return fly(el).findParentElement(rowSelector, rowSelectorDepth);

  }

  /**

   * Returns the row index.

   *

   * @param elem the row or child of the row element

   * @return the index

   */

  public int findRowIndex(Element elem) {

    Element r = findRow(elem);

    return r != null ? r.getPropertyInt("rowIndex") : -1;

  }

  /**

   * Focus the cell and scrolls into view.

   *

   * @param rowIndex the row index

   * @param colIndex the column index

   * @param hscroll true to scroll horizontally

   */

  public void focusCell(int rowIndex, int colIndex, boolean hscroll) {

    Point xy = ensureVisible(rowIndex, colIndex, hscroll);

    if (xy != null) {

      focusEl.setXY(xy);

      if (focusEnabled) {

        focusGrid();

      }

    }

  }

  /**

   * Focus the row and scrolls into view.

   *

   * @param rowIndex the row index

   */

  public void focusRow(int rowIndex) {

    focusCell(rowIndex, 0, true);

  }

  /**

   * Returns the grid's body element.

   *

   * @return the body element

   */

  public El getBody() {

    return scroller;

  }

  /**

   * Returns the grid's &lt;TD> HtmlElement at the specified coordinates.

   *

   * @param row the row index in which to find the cell

   * @param col the column index of the cell

   * @return the &lt;TD> at the specified coordinates

   */

  public Element getCell(int row, int col) {

    // ROW DIV TABLE TR TD

    Element rowEl = getRow(row);

    return (Element) ((rowEl != null && rowEl.hasChildNodes())

        ? rowEl.getFirstChild().getFirstChild().getFirstChild().getChildNodes().getItem(col) : null);

  }

  /**

   * Returns the cell selector depth.

   *

   * @return the cell selector depth

   */

  public int getCellSelectorDepth() {

    return cellSelectorDepth;

  }

  /**

   * Returns the editor parent element.

   *

   * @return the editor element

   */

  public Element getEditorParent() {

    return scroller.dom;

  }

  /**

   * Returns the empty text.

   *

   * @return the empty text

   */

  public String getEmptyText() {

    return emptyText;

  }

  /**

   * Returns the grid's column header.

   *

   * @return the header

   */

  public ColumnHeader getHeader() {

    return header;

  }

  /**

   * Returns the &lt;TD> HtmlElement which represents the Grid's header cell for

   * the specified column index.

   *

   * @param index the column index

   * @return the &lt;TD> element.

   */

  public Element getHeaderCell(int index) {

    return mainHd.dom.getElementsByTagName("td").getItem(index);

  }

  /**

   * Returns the images used by grid.

   *

   * @return the images

   */

  public GridViewImages getImages() {

    if (images == null) {

      images = new GridViewImages();

    }

    return images;

  }

  /**

   * Return the &lt;TR> HtmlElement which represents a Grid row for the

   * specified index.

   *

   * @param row the row index

   * @return the &lt;TR> element

   */

  public Element getRow(int row) {

    if (row < 0) {

      return null;

    }

    return getRows().getItem(row);

  }

  /**

   * Return the &lt;TR> HtmlElement which represents a Grid row for the

   * specified model.

   *

   * @param m the model

   * @return the &lt;TR> element

   */

  public Element getRow(ModelData m) {

    return getRow(ds.indexOf(m));

  }

  /**

   * Returns the row selector depth.

   *

   * @return the row selector depth

   */

  public int getRowSelectorDepth() {

    return rowSelectorDepth;

  }

  /**

   * Returns the scroll element.

   *

   * @return the scroll element

   */

  public El getScroller() {

    return scroller;

  }

  /**

   * Returns the current scroll state.

   *

   * @return the scroll state

   */

  public Point getScrollState() {

    return new Point(scroller.getScrollLeft(), scroller.getScrollTop());

  }

  /**

   * Returns the view config.

   *

   * @return the view config

   */

  public GridViewConfig getViewConfig() {

    return viewConfig;

  }

  /**

   * Returns the widget at the current location.

   *

   * @param rowIndex the row index

   * @param colIndex the column index

   * @return the widget or null

   */

  public Widget getWidget(int rowIndex, int colIndex) {

    List<Widget> map = rowIndex < widgetList.size() ? widgetList.get(rowIndex) : null;

    return map != null && colIndex < map.size() ? map.get(colIndex) : null;

  }

  /**

   * Returns true if the grid width will be adjusted based on visibility of

   * horizontal scroll bar.

   *

   * @return true if adjusting

   */

  public boolean isAdjustForHScroll() {

    return adjustForHScroll;

  }

  /**

   * Returns true if auto fill is enabled.

   *

   * @return true for auto fill

   */

  public boolean isAutoFill() {

    return autoFill;

  }

  /**

   * Returns true if force fit is enabled.

   *

   * @return true for force fit

   */

  public boolean isForceFit() {

    return forceFit;

  }

  /**

   * Returns true if dirty cell markers are enabled.

   *

   * @return true of dirty cell markers

   */

  public boolean isShowDirtyCells() {

    return showDirtyCells;

  }

  /**

   * Returns true if invalid cell markers are enabled.

   *

   * @return true if enabled

   */

  public boolean isShowInvalidCells() {

    return showInvalidCells;

  }

  /**

   * Returns true if sorting is enabled.

   *

   * @return true for sorting

   */

  public boolean isSortingEnabled() {

    return !headerDisabled;

  }

  public void layout() {

    layout(false);

  }

  /**

   * Rebuilds the grid using its current configuration and data.

   *

   * @param headerToo true to refresh the header

   */

  public void refresh(boolean headerToo) {

    if (grid != null && grid.isViewReady()) {

      stopEditing();

      detachWidgets(0, -1, true);

      if (!preventScrollToTopOnRefresh) {

        scrollToTop();

      }

      mainBody.setInnerHtml(renderRows(0, -1));

      if (headerToo) {

        sortState = null;

        header.release();

        newColumnHeader();

        renderHeader();

        if (grid.isAttached()) {

          ComponentHelper.doAttach(header);

        }

        header.setEnableColumnResizing(grid.isColumnResize());

        header.setEnableColumnReorder(grid.isColumnReordering());

      }

      processRows(0, true);

      renderWidgets(0, -1);

      if (footer != null) {

        ComponentHelper.doDetach(footer);

        footer.el().removeFromParent();

      }

      if (cm.getAggregationRows().size() > 0) {

        footer = new ColumnFooter(grid, cm);

        renderFooter();

        if (grid.isAttached()) {

          ComponentHelper.doAttach(footer);

        }

      }

      calculateVBar(true);

      updateHeaderSortState();

      applyEmptyText();

      constrainFocusElement();

      fireEvent(Events.Refresh);

    }

  }

  /**

   * Scrolls the grid to the top.

   */

  public void scrollToTop() {

    scroller.setScrollTop(0);

    scroller.setScrollLeft(0);

  }

  /**

   * True to adjust the grid width when the horizontal scrollbar is hidden and

   * visible (defaults to true).

   *

   * @param adjustForHScroll true to adjust for horizontal scroll bar

   */

  public void setAdjustForHScroll(boolean adjustForHScroll) {

    this.adjustForHScroll = adjustForHScroll;

  }

  /**

   * True to auto expand the columns to fit the grid <b>when the grid is

   * created</b>.

   *

   * @param autoFill true to expand

   */

  public void setAutoFill(boolean autoFill) {

    this.autoFill = autoFill;

  }

  /**

   * The number of levels to search for cells in event delegation (defaults to

   * 4).

   *

   * @param cellSelectorDepth the cell selector depth

   */

  public void setCellSelectorDepth(int cellSelectorDepth) {

    this.cellSelectorDepth = cellSelectorDepth;

  }

  /**

   * Default text to display in the grid body when no rows are available

   * (defaults to '').

   *

   * @param emptyText the empty text

   */

  public void setEmptyText(String emptyText) {

    this.emptyText = emptyText;

  }

  /**

   * True to auto expand/contract the size of the columns to fit the grid width

   * and prevent horizontal scrolling.

   *

   * @param forceFit true to force fit

   */

  public void setForceFit(boolean forceFit) {

    this.forceFit = forceFit;

  }

  /**

   * The number of levels to search for rows in event delegation (defaults to

   * 10).

   *

   * @param rowSelectorDepth the row selector depth

   */

  public void setRowSelectorDepth(int rowSelectorDepth) {

    this.rowSelectorDepth = rowSelectorDepth;

  }

  /**

   * True to display a red triangle in the upper left corner of any cells which

   * are "dirty" as defined by any existing records in the data store (defaults

   * to true).

   *

   * @param showDirtyCells true to display the dirty flag

   */

  public void setShowDirtyCells(boolean showDirtyCells) {

    this.showDirtyCells = showDirtyCells;

  }

  /**

   * True to enabled invalid cell markers (defaults to false).

   *

   * @param showInvalidCells true to enable

   */

  public void setShowInvalidCells(boolean showInvalidCells) {

    this.showInvalidCells = showInvalidCells;

  }

  /**

   * True to allow column sorting when the user clicks a column (defaults to

   * true).

   *

   * @param sortable true for sortable columns

   */

  public void setSortingEnabled(boolean sortable) {

    this.headerDisabled = !sortable;

  }

  /**

   * Sets the view config.

   *

   * @param viewConfig the view config

   */

  public void setViewConfig(GridViewConfig viewConfig) {

    this.viewConfig = viewConfig;

  }

  protected void addRowStyle(Element elem, String style) {

    if (elem != null) {

      fly(elem).addStyleName(style);

    }

  }

  protected void afterRender() {

    mainBody.setInnerHtml(renderRows(0, -1));

    renderWidgets(0, -1);

    processRows(0, true);

    int sh = scroller.getHeight();

    int dh = mainBody.getHeight();

    boolean vbar = dh < sh;

    if (vbar) {

      this.vbar = !vbar;

      lastViewWidth = -1;

      layout();

    }

    applyEmptyText();

  }

  protected void applyEmptyText() {

    if (emptyText == null) {

      emptyText = "&nbsp;";

    }

    if (!hasRows()) {

      mainBody.setInnerHtml("<div class='x-grid-empty'>" + emptyText + "</div>");

    }

    syncHScroll();

  }

  protected void autoExpand(boolean preventUpdate) {

    if (!userResized && grid.getAutoExpandColumn() != null) {

      int tw = cm.getTotalWidth(false);

      int aw = grid.getWidth(true) - getScrollAdjust();

      if (tw != aw) {

        int ci = cm.getIndexById(grid.getAutoExpandColumn());

        assert ci != Style.DEFAULT : "auto expand column not found";

        if (cm.isHidden(ci)) {

          return;

        }

        int currentWidth = cm.getColumnWidth(ci);

        int cw = Math.min(Math.max(((aw - tw) + currentWidth), grid.getAutoExpandMin()), grid.getAutoExpandMax());

        if (cw != currentWidth) {

          cm.setColumnWidth(ci, cw, true);

          if (!preventUpdate) {

            updateColumnWidth(ci, cw);

          }

        }

      }

    }

  }

  protected void calculateVBar(boolean force) {

    if (force) {

      resize();

    }

    int sh = scroller.getHeight();

    int dh = mainBody.getHeight();

    boolean vbar = dh > sh;

    if (force || this.vbar != vbar) {

      this.vbar = vbar;

      lastViewWidth = -1;

      layout(true);

    }

  }

  @SuppressWarnings({"rawtypes", "unchecked"})

  protected GridEvent<?> createComponentEvent(Event event) {

    return new GridEvent(grid, event);

  }

  protected Menu createContextMenu(final int colIndex) {

    final Menu menu = new Menu();

    if (cm.isSortable(colIndex)) {

      MenuItem item = new MenuItem();

      item.setText(GXT.MESSAGES.gridView_sortAscText());

      item.setIcon(getImages().getSortAsc());

      item.addSelectionListener(new SelectionListener<MenuEvent>() {

        public void componentSelected(MenuEvent ce) {

          doSort(colIndex, SortDir.ASC);

        }

      });

      menu.add(item);

      item = new MenuItem();

      item.setText(GXT.MESSAGES.gridView_sortDescText());

      item.setIcon(getImages().getSortDesc());

      item.addSelectionListener(new SelectionListener<MenuEvent>() {

        public void componentSelected(MenuEvent ce) {

          doSort(colIndex, SortDir.DESC);

        }

      });

      menu.add(item);

    }

    MenuItem columns = new MenuItem();

    columns.setText(GXT.MESSAGES.gridView_columnsText());

    columns.setIcon(getImages().getColumns());

    columns.setData("gxt-columns", "true");

    final Menu columnMenu = new Menu();

    int cols = cm.getColumnCount();

    for (int i = 0; i < cols; i++) {

      if (shouldNotCount(i, false)) {

        continue;

      }

      final int fcol = i;

      final CheckMenuItem check = new CheckMenuItem();

      check.setHideOnClick(false);

      check.setText(cm.getColumnHeader(i));

      check.setChecked(!cm.isHidden(i));

      check.addSelectionListener(new SelectionListener<MenuEvent>() {

        public void componentSelected(MenuEvent ce) {

          cm.setHidden(fcol, !cm.isHidden(fcol));

          restrictMenu(columnMenu);

        }

      });

      columnMenu.add(check);

    }

    restrictMenu(columnMenu);

    columns.setSubMenu(columnMenu);

    menu.add(columns);

    return menu;

  }

  protected void detachWidget(int rowIndex, boolean remove) {

    List<Widget> m = rowIndex < widgetList.size() ? widgetList.get(rowIndex) : null;

    if (m != null) {

      for (Widget w : m) {

        ComponentHelper.doDetach(w);

        if (w != null) {

          El.fly(w.getElement()).removeFromParent();

        }

      }

      if (remove) {

        widgetList.remove(rowIndex);

      }

    }

  }

  protected void detachWidgets(int startRow, int endRow, boolean remove) {

    if (endRow == -1) {

      endRow = widgetList.size() - 1;

    }

    for (int i = endRow; i >= startRow; i--) {

      detachWidget(i, remove);

    }

  }

  protected void doAttach() {

    ComponentHelper.doAttach(header);

    ComponentHelper.doAttach(footer);

    resize();

    renderWidgets(0, -1);

  }

  protected void doDetach() {

    ComponentHelper.doDetach(header);

    ComponentHelper.doDetach(footer);

    detachWidgets(0, -1, false);

  }

  protected String doRender(List<ColumnData> cs, List<ModelData> rows, int startRow, int colCount, boolean stripe) {

    int last = colCount - 1;

    String tstyle = "width:" + getTotalWidth() + "px;";

    StringBuilder buf = new StringBuilder();

    for (int j = 0; j < rows.size(); j++) {

      ModelData model = (ModelData) rows.get(j);

      model = prepareData(model);

      Record r = ds.hasRecord(model) ? ds.getRecord(model) : null;

      int rowBodyColSpanCount = colCount;

      if (enableRowBody) {

        if (grid.getSelectionModel() instanceof CheckBoxSelectionModel<?>) {

          CheckBoxSelectionModel<?> sm = (CheckBoxSelectionModel<?>) grid.getSelectionModel();

          if (cm.getColumnById(sm.getColumn().getId()) != null) {

            rowBodyColSpanCount--;

          }

        }

        for (ColumnConfig c : cm.getColumns()) {

          if (c instanceof RowExpander || c instanceof RowNumberer) {

            rowBodyColSpanCount--;

          }

        }

      }

      int rowIndex = (j + startRow);

      if (GXT.isAriaEnabled()) {

        buf.append("<div role=\"row\" aria-level=\"2\" class=\"x-grid3-row ");

      } else {

        buf.append("<div class=\"x-grid3-row ");

      }

      if (stripe && ((rowIndex + 1) % 2 == 0)) {

        buf.append(" x-grid3-row-alt");

      }

      if (!selectable) {

        buf.append(" x-unselectable-single");

      }

      if (showDirtyCells && r != null && r.isDirty()) {

        buf.append(" x-grid3-dirty-row");

      }

      if (viewConfig != null) {

        buf.append(" ");

        buf.append(viewConfig.getRowStyle(model, rowIndex, ds));

      }

      buf.append("\" style=\"");

      buf.append(tstyle);

      buf.append("\" id=\"");

      buf.append(grid.getId());

      buf.append("_");

      buf.append(ds.getKeyProvider() != null ? ds.getKeyProvider().getKey(model) : XDOM.getUniqueId());

      buf.append("\"><table class=x-grid3-row-table role=presentation border=0 cellspacing=0 cellpadding=0 style=\"");

      buf.append(tstyle);

      buf.append("\"><tbody role=presentation><tr role=presentation>");

      widgetList.add(rowIndex, new ArrayList<Widget>());

      for (int i = 0; i < colCount; i++) {

        ColumnData c = cs.get(i);

        c.css = c.css == null ? "" : c.css;

        String rv = getRenderedValue(c, rowIndex, i, model, c.name);

        String role = "gridcell";

        if (GXT.isAriaEnabled()) {

          ColumnConfig cc = cm.getColumn(i);

          if (cc.isRowHeader()) {

            role = "rowheader";

          }

        }

        String attr = c.cellAttr != null ? c.cellAttr : "";

        String cellAttr = c.cellAttr != null ? c.cellAttr : "";

        buf.append("<td id=\"" + XDOM.getUniqueId() + "\" role=\"" + role

            + "\" class=\"x-grid3-col x-grid3-cell x-grid3-td-");

        buf.append(c.id);

        buf.append(" ");

        buf.append(i == 0 ? "x-grid-cell-first " : (i == last ? "x-grid3-cell-last " : ""));

        if (c.css != null) {

          buf.append(c.css);

        }

        if (showInvalidCells && r != null && !r.isValid(c.id)) {

          buf.append(" x-grid3-invalid-cell");

        }

        if (showDirtyCells && r != null && r.getChanges().containsKey(c.id)) {

          buf.append(" x-grid3-dirty-cell");

        }

        buf.append("\" style=\"");

        buf.append(c.style);

        buf.append("\" ");

        buf.append(cellAttr);

        buf.append("><div unselectable=\"");

        buf.append(selectable ? "off" : "on");

        buf.append("\" class=\"x-grid3-cell-inner x-grid3-col-");

        buf.append(c.id);

        buf.append("\" ");

        buf.append(attr);

        buf.append(">");

        buf.append(rv);

        buf.append("</div></td>");

      }

      buf.append("</tr>");

      if (enableRowBody) {

        buf.append("<tr class=x-grid3-row-body-tr style=\"\"><td colspan=");

        buf.append(rowBodyColSpanCount);

        buf.append(" class=x-grid3-body-cell><div class=x-grid3-row-body>${body}</div></td></tr>");

      }

      buf.append("</tbody></table></div>");

    }

    return buf.toString();

  }

  protected void doSort(int colIndex, SortDir sortDir) {

    ds.sort(cm.getDataIndex(colIndex), sortDir);

  }

  protected void fitColumns(boolean preventRefresh, boolean onlyExpand, int omitColumn) {

    int tw = cm.getTotalWidth(false);

    double aw = grid.el().getWidth(true) - getScrollAdjust();

    if (aw <= 0) {

      aw = grid.el().getStyleWidth();

    }

    if (aw < 20 || aw > 2000) { // not initialized, so don't screw up the

      // default widths

      return;

    }

    int extra = (int) aw - tw;

    if (extra == 0) {

      return;

    }

    int vc = cm.getColumnCount(true);

    int ac = vc - (omitColumn != -1 ? 1 : 0);

    if (ac == 0) {

      ac = 1;

      omitColumn = -1;

    }

    int colCount = cm.getColumnCount();

    Stack<Integer> cols = new Stack<Integer>();