* Sencha GXT 3.0.0 - Sencha for GWT

* Copyright(c) 2007-2012, Sencha, Inc.

* licensing@sencha.com

*

* http://www.sencha.com/products/gxt/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 a {@link ListStore}.

*/

  /**

   * Define the appearance of a Grid.

   */

  public interface GridAppearance {

    Element findCell(Element elem);

    Element findRow(Element elem);

    Element getRowBody(Element row);

    NodeList<Element> getRows(XElement parent);

    void onCellSelect(Element cell, boolean select);

    void onRowHighlight(Element row, boolean highlight);

    void onRowOver(Element row, boolean over);

    void onRowSelect(Element row, boolean select);

    /**

     * Renders the HTML markup for the widget.

     *

     * @param sb the safe html builder

     */

    void render(SafeHtmlBuilder sb);

    SafeHtml renderEmptyContent(String emptyText);

    GridStyles styles();

  }

  @Shared

  public interface GridDataTableStyles extends CssResource {

    String cell();

    String cellDirty();

    String cellInner();

    String cellInvalid();

    String cellSelected();

    String dataTable();

    String headerRow();

    String row();

    String rowAlt();

    String rowBody();

    String rowBodyRow();

    String rowDirty();

    String rowHighlight();

    String rowOver();

    String rowSelected();

    String rowWrap();

  }

  public interface GridStyles extends GridDataTableStyles {

    String empty();

    String footer();

    String grid();

  }

    @Template("<div class=\"{0}\">{1}</div>")

    SafeHtml div(String classes, SafeHtml contents);

    @Template("<table cellpadding=\"0\" cellspacing=\"0\" class=\"{0}\" style=\"{1};table-layout: fixed\"><tbody>{3}</tbody><tbody>{2}</tbody></table>")

    SafeHtml table(String classes, SafeStyles tableStyles, SafeHtml contents, SafeHtml sizingHeads);

    @Template("<td cellindex=\"{0}\" class=\"{1}\" style=\"{2}\"><div class=\"{3}\" style=\"{4}\">{5}</div></td>")

    SafeHtml td(int cellIndex, String cellClasses, SafeStyles cellStyles, String textClasses, SafeStyles textStyles,

        SafeHtml contents);

    @Template("<td cellindex=\"{0}\" class=\"{1}\" style=\"{2}\" rowspan=\"{3}\">{4}</td>")

    SafeHtml tdRowSpan(int cellIndex, String classes, SafeStyles styles, int rowSpan, SafeHtml contents);

    @Template("<td colspan=\"{0}\" class=\"{1}\"><div class=\"{2}\">{3}</div></td>")

    SafeHtml tdWrap(int colspan, String cellClasses, String textClasses, SafeHtml content);

    @Template("<th class=\"{0}\" style=\"{1}\"></th>")

    SafeHtml th(String classes, SafeStyles cellStyles);

    @Template("<tr class=\"{0}\">{1}</tr>")

    SafeHtml tr(String classes, SafeHtml contents);

  }

  private static Logger logger = Logger.getLogger(GridView.class.getName());

  /**

   * Set to true to auto expand the columns to fit the grid when the grid is

   * created.

   */

  protected boolean autoFill;

  /**

   * The content area inside the scroller.

   */

  protected XElement body;

  /**

   * A border width calculation to be applied for browsers that do not use the

   * old IE box model.

   */

  protected int borderWidth = 2;

  /**

   * The grid's column model.

   */

  protected ColumnModel<M> cm;

  /**

   * The handler for column events such as move, width change and hide.

   */

  protected ColumnModelHandlers columnListener;

  /**

   * The main data table and body.

   */

  protected XElement dataTable, dataTableBody, dataTableSizingHead;

  protected int deferUpdateDelay = 500;

  protected boolean deferUpdates = false;

  /**

   * The list store that provides data for this grid view.

   */

  protected ListStore<M> ds;

  /**

   * The safe HTML value to display when the grid is empty (defaults to &nbsp;).

   */

  protected String emptyText = "&nbsp;";

  /**

   * True to enable a column spanning row body, as used by {@link RowExpander}

   * (defaults to false).

   */

  protected boolean enableRowBody = false;

  protected XElement focusEl;

  protected final FocusImpl focusImpl = FocusImpl.getFocusImplForPanel();

  protected ColumnFooter<M> footer;

  protected boolean forceFit;

  protected Grid<M> grid;

  protected ColumnHeader<M> header;

  protected int headerColumnIndex;

  protected boolean headerDisabled;

  /**

   * The inner head element.

   */

  protected XElement headerElem;

  protected int lastViewWidth;

  protected StoreHandlers<M> listener;

  protected Element overRow;

  protected boolean preventScrollToTopOnRefresh;

  /**

   * The scrollable area that contains the main body.

   */

  protected XElement scroller;

  protected int scrollOffset = XDOM.getScrollBarWidth();

  protected boolean selectable = false;

  protected SortInfo sortState;

  protected int splitterWidth = 5;

  protected StoreSortInfo<M> storeSortInfo;

  protected GridStyles styles;

  protected GridTemplates tpls = GWT.create(GridTemplates.class);

  protected String unselectable = CommonStyles.get().unselectableSingle();

  protected boolean userResized;

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

  protected boolean vbar = true;

  protected GridViewConfig<M> viewConfig;

  private DelayedTask addTask = new DelayedTask() {

    @Override

    public void onExecute() {

      calculateVBar(false);

      refreshFooterData();

    }

  };

  private boolean adjustForHScroll = true;

  private GridAppearance appearance;

  private ColumnConfig<M, ?> autoExpandColumn;

  private int autoExpandMax = 500;

  private int autoExpandMin = 25;

  private HandlerRegistration cmHandlerRegistration;

  /**

   * True to show vertical column lines between cells.

   */

  private boolean columnLines;

  /**

   * True to enable the grid to be focused (defaults to true).

   */

  private boolean focusEnabled = true;

  private DelayedTask removeTask = new DelayedTask() {

    @Override

    public void onExecute() {

      calculateVBar(false);

      applyEmptyText();

      refreshFooterData();

      processRows(0, false);

    }

  };

  /**

   * The numbers of rows the first column should span if row bodies are enabled

   * (defaults to 1).

   */

  private int rowBodyRowSpan = 1;

  private boolean showDirtyCells = true;

  private HandlerRegistration storeHandlerRegistration;

  private boolean stripeRows;

  private boolean trackMouseOver = true;

  /**

   * Creates a new grid view.

   */

  public GridView() {

    this(GWT.<GridAppearance> create(GridAppearance.class));

  }

  /**

   * Creates a new grid view.

   *

   * @param appearance the grid appearance

   */

  public GridView(GridAppearance appearance) {

    this.appearance = appearance;

    this.styles = appearance.styles();

  }

  /**

   * 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.size()) {

      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;

    int ctop = 0;

    Element p = rowEl, stope = grid.getElement();

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

      ctop += p.getOffsetTop();

      p = p.getOffsetParent();

    }

    ctop -= headerElem.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 ((cm.getTotalWidth() > scroller.getWidth(false) - 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.getComputedWidth());

      }

    }

    return cellEl != null ? fly(cellEl).getXY() : new Point(c.getAbsoluteLeft() + 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 appearance.findCell(elem);

  }

  /**

   * 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).hasClassName(requiredStyle))) {

      String index = cell.getAttribute("cellindex");

      return index.equals("") ? -1 : Integer.parseInt(index);

    }

    return -1;

  }

  /**

   * Returns the row element.

   *

   * @param elem the row element or any child element

   * @return the matching row element

   */

  public Element findRow(Element elem) {

    if (elem == null) {

      return null;

    }

    return appearance.findRow(elem);

  }

  /**

   * 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);

    if (r != null) {

      return r.getPropertyInt("rowindex");

    }

    return -1;

  }

  /**

   * Focuses the grid.

   */

  public void focus() {

    if (GXT.isGecko()) {

      Scheduler.get().scheduleDeferred(new ScheduledCommand() {

        @Override

        public void execute() {

          if (focusEl != null) {

            focusImpl.focus(focusEl);

          }

        }

      });

    } else if (focusEl != null) {

      focusImpl.focus(focusEl);

    }

  }

  /**

   * 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) {

        focus();

      }

    }

  }

  /**

   * Focus the row and scrolls into view.

   *

   * @param rowIndex the row index

   */

  public void focusRow(int rowIndex) {

    focusCell(rowIndex, 0, false);

  }

  /**

   * Returns the grid appearance.

   *

   * @return the grid appearance

   */

  public GridAppearance getAppearance() {

    return appearance;

  }

  /**

   * Returns the auto expand column id.

   *

   * @return the auto expand column id

   */

  public ColumnConfig<M, ?> getAutoExpandColumn() {

    return autoExpandColumn;

  }

  /**

   * Returns the auto expand maximum width.

   *

   * @return the max width in pixels

   */

  public int getAutoExpandMax() {

    return autoExpandMax;

  }

  /**

   * Returns the auto expand minimum width.

   *

   * @return the minimum width in pixels

   */

  public int getAutoExpandMin() {

    return autoExpandMin;

  }

  /**

   * Returns the body element.

   *

   * @return the body element

   */

  public XElement getBody() {

    return body;

  }

  /**

   * 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) {

    Element rowEl = getRow(row);

    if (rowEl == null || !rowEl.hasChildNodes() || col < 0) {

      return null;

    } else if (!enableRowBody) {

      return (Element) rowEl.getChildNodes().getItem(col);

    } else {

      return (Element) rowEl.getFirstChildElement().getFirstChildElement().getFirstChildElement().getFirstChildElement().getNextSiblingElement().getFirstChildElement().getChild(

          col);

    }

  }

  /**

   * Returns the editor parent element.

   *

   * @return the editor element

   */

  public Element getEditorParent() {

    return scroller;

  }

  /**

   * Returns the empty text.

   *

   * @return the empty text

   */

  public String getEmptyText() {

    return emptyText;

  }

  /**

   * Returns the grid's column header.

   *

   * @return the header

   */

  public ColumnHeader<M> getHeader() {

    return header;

  }

  /**

   * 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(M m) {

    return getRow(ds.indexOf(m));

  }

  public Element getRowBody(Element row) {

    return appearance.getRowBody(row);

  }

  /**

   * Returns the number of rows the first column should span when row bodies

   * have been enabled.

   *

   * @return the rowspan

   */

  public int getRowBodyRowSpan() {

    return rowBodyRowSpan;

  }

  /**

   * Returns the scroll element.

   *

   * @return the scroll element

   */

  public XElement 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.