lwtreegrid.java

Zaval Light-Weight Visual Components Library (LwVCL) is a pure Java alternative to humble AWT-based

  * @param <code>m</code> the tree model.
  */
  public /*C#virtual*/ void setTreeModel(TreeModel m)
  {
    TreeModel data = tree.getModel();
    if (m != data)
    {
      if (data != null) data.removeTreeListener(this);
      data = m;
      tree.setModel(data);
      if (data != null) data.addTreeListener(this);
      if (this.data != null) this.data.clear();
      iTreeIndex();
      iMetric();
    }
  }

 /**
  * Gets the tree model.
  * @return a tree model.
  */
  public TreeModel getTreeModel() {
    return tree.getModel();
  }

  public int getRows () {
    return getTreeModel().getItemsCount();
  }

  public int getCols () {
    return gridCols;
  }

  public /*C#override*/ int getGridRows ()  {
    vTreeIndex();
    return itemByRow.size();
  }

  public /*C#override*/ int getGridCols () {
    return getCols();
  }

  public Object get(int row, int col)
  {
    if (row >= getRows() || col >= getCols()) throw new IndexOutOfBoundsException();

    if (col != 0 && data != null)
    {
      Item item = getItemByRow (row, false);
      Object[] a = (Object[])data.get(item);
      return a == null || a.length < col ?null:a[col - 1];
    }
    return null;
  }

  public void actionPerformed (LwActionEvent e)
  {
    stopEditing(true);
    iMetric();
    iTreeIndex();
    PosController c = getPosController();
    if (c != null)
    {
      if (c.getCurrentLine() >= getGridRows()) c.clearPos();
      else
      {
        c.invalidate();
        c.validate();
      }
    }
    repaint();
  }

  public void put(int row, int col, Object o) {
    if (col == 0) throw new IllegalArgumentException();
    put (getItemByRow(row, false), row, col, o);
  }

  public void put(Item item, int row, int col, Object o)
  {
    if (col == 0) throw new IllegalArgumentException();
    if (data == null) data = new Hashtable();
    Object[] cells = (Object[])data.get(item);
    int      len   = (cells == null)?0:cells.length;
    if (len < col)
    {
      Object[] na = new Object[col];
      if (cells != null) System.arraycopy(cells, 0, na, 0, cells.length);
      cells = na;
      if (cells.length + 1 > gridCols) gridCols = cells.length + 1;
      perform (new MatrixEvent(this, getRows(), len));
    }
    Object prev = cells[col-1];
    cells[col-1] = o;
    data.put(item, cells);
    perform (new MatrixEvent(this, row, col, prev));
  }

  public void addMatrixListener (MatrixListener m) {
    if (listeners == null) listeners = new Vector();
    if (!listeners.contains(m)) listeners.addElement(m);
  }

  public void removeMatrixListener(MatrixListener l) {
    if (listeners != null) listeners.removeElement(l);
  }

  public void itemInserted(TreeEvent e)
  {
    if (tree.isOpen(getTreeModel().getRoot())) {
      iTreeIndex();
      iMetric();
    }
    perform (new MatrixEvent (this, getRows() - 1, getCols()));
  }

  public void itemRemoved (TreeEvent e)
  {
    iTreeIndex();
    iMetric();

    if (data != null)
    {
      data.remove (e.getItem ());
      perform (new MatrixEvent (this, getRows() + 1, getCols()));
    }
  }

  public void itemModified(TreeEvent e) {
    iMetric();
  }

  public /*C#override*/ void setSOLocation (int dx, int dy)
  {
    if (dx != this.dx || dy != this.dy)
    {
      tree.invalidate();
      super.setSOLocation(dx, dy);
    }
  }

 /**
  * It is impossible to use the method to define the row height. In this case the runtime
  * exception will be thrown.
  */
  public /*C#override*/ void setRowHeight (int row, int h)  {
    throw new RuntimeException();
  }

 /**
  * Converts and returns the model row by the specified grid row.
  * @param <code>gridRow</code> the specified grid row.
  * @return a model row.
  */
  public int getModelRow(int gridRow) {
    return getDataRow(getItemByRow(gridRow, true));
  }

 /**
  * Gets the selected tree item.
  * @return a selected tree item.
  */
  public Item getSelectedItem()
  {
    PosController c = getPosController ();
    if (c != null && c.getCurrentLine() >= 0) return getItemByRow(c.getCurrentLine(), true);
    return null;
  }

  public /*C#override*/ void startEditing (int row, int col) {
    if (col != 0) super.startEditing(row, col);
  }

 /**
  * Returns the tree item by the specified model row. Draw attention that the method requires
  * model row not a visible grid row.
  * @param <code>row</code> the specified model row.
  * @return a tree item.
  */
  public Item getItemByRow (int row) {
    return getItemByRow(row, false);
  }

 /**
  * Performs the specified matrix event.
  * @param <code>e</code> the specified matrix event.
  */
  protected void perform(MatrixEvent e)
  {
    if (listeners != null)
    {
      for (int i=0; i<listeners.size(); i++)
      {
        MatrixListener l = (MatrixListener)listeners.elementAt(i);
        if (e.getID() == MatrixEvent.MATRIX_RESIZED) l.matrixResized(e);
        else l.cellModified(e);
      }
    }
  }

  protected /*C#override*/ void rCustomMetric()
  {
    Insets ins = getCellInsets();
    tree.setGaps(-1, ins.top + ins.bottom + getNetGap() + extraRowHeight*2);

    vTreeIndex();
    int start = 0;
    if (colWidths != null)
    {
      start = colWidths.length;
      if (colWidths.length != getGridCols())
      {
        int[] na = new int[getGridCols()];
        System.arraycopy(colWidths, 0, na, 0, Math.min(colWidths.length, na.length));
        colWidths = na;
      }
    }
    else colWidths = new int[getGridCols()];
    for (;start<colWidths.length; start++) colWidths[start] = DEF_COLWIDTH;
  }

  protected /*C#override*/ void rPsMetric()
  {
    Insets ins = getCellInsets();
    tree.setGaps(-1, ins.top + ins.bottom + getNetGap());
    vTreeIndex();
    colWidths = new int[getGridCols()];
    Insets cellInsets = getCellInsets();
    int addW = cellInsets.left + cellInsets.right;
    for (int i=1; i<colWidths.length ;i++)
    {
      for (int j=0; j<getGridRows(); j++)
      {
        LwView v = getView(j, i, dataToPaint(j, i));
        if (v != null)
        {
          Dimension ps = v.getPreferredSize();
          ps.width  += addW;
          if (ps.width  > colWidths[i] ) colWidths [i] = ps.width;
        }
        else if (DEF_COLWIDTH  > colWidths [i]) colWidths [i] = DEF_COLWIDTH;
      }
    }
    colWidths[0] = tree.getPreferredSize().width + addW;
  }

  protected /*C#override*/ Object dataToPaint (int row, int col)
  {
    if (col > 0)
    {
      Item i = getItemByRow(row, true);
      Object[] a = (Object[])data.get(i);
      return a == null || a.length < col ?null:a[col - 1];
    }
    return null;
  }

  protected /*C#override*/ Object getDataToEdit (int row, int col) {
    return getModel().get(getDataRow(getItemByRow(row, true)), col);
  }

  protected /*C#override*/ void setEditedData (int row, int col, Object value) {
    getModel().put (getDataRow(getItemByRow(row, true)), col, value);
  }

  protected /*C#override*/ int rowHeight(int r) {
    Insets cellInsets = getCellInsets();
    return tree.getItemMetrics((Item)itemByRow.elementAt(r)).getHeight() + cellInsets.top + cellInsets.bottom + 2*getExtraHeight();
  }

  private Item getItemByRow (int row, boolean onlyVisible) {
    vTreeIndex();
    return onlyVisible?(Item)itemByRow.elementAt(row):
                        getItemByRow(getTreeModel().getRoot(), row, new int[] { 0 } );
  }

  private Item getItemByRow (Item root, int row, int[] c)
  {
    if (row == c[0]) return root;
    c[0]++;
    TreeModel data = getTreeModel();
    for (int i=0; i<data.getChildrenCount(root); i++)
    {
      Item res = getItemByRow(data.getChildAt(root, i), row, c);
      if (res != null) return res;
    }
    return null;
  }

   private int getDataRow (Item item) {
     int[] c = new int[1];
     return getDataRow(getTreeModel().getRoot(), item, c)?c[0]:-1;
   }

   private boolean getDataRow (Item root, Item item, int[] c)
   {
     if (root == item) return true;
     c[0]++;
     TreeModel data = getTreeModel ();
     int size = data.getChildrenCount(root);
     for (int i=0; i<size; i++) if (getDataRow(data.getChildAt(root, i), item, c)) return true;
     return false;
   }

  private void iTreeIndex() {
    itemByRow.removeAllElements();
  }

  private void vTreeIndex() {
    if (itemByRow.size() == 0) rTreeIndex(getTreeModel().getRoot());
  }

  private void rTreeIndex(Item root)
  {
    itemByRow.addElement(root);
    if (tree.isOpen(root))
    {
      TreeModel data = getTreeModel ();
      int       size = data.getChildrenCount(root);
      for (int i=0; i<size; i++)
        rTreeIndex(data.getChildAt(root, i));
    }
  }

  private int getExtraHeight() {
    return isUsePsMetric()?0:extraRowHeight;
  }
}