Subversion Repositories openrisc

/* BasicTableUI.java --

   Copyright (C) 2004 Free Software Foundation, Inc.

This file is part of GNU Classpath.

GNU Classpath is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation; either version 2, or (at your option)

any later version.

GNU Classpath is distributed in the hope that it will be useful, but

WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

General Public License for more details.

You should have received a copy of the GNU General Public License

along with GNU Classpath; see the file COPYING.  If not, write to the

Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

02110-1301 USA.

Linking this library statically or dynamically with other modules is

making a combined work based on this library.  Thus, the terms and

conditions of the GNU General Public License cover the whole

combination.

As a special exception, the copyright holders of this library give you

permission to link this library with independent modules to produce an

executable, regardless of the license terms of these independent

modules, and to copy and distribute the resulting executable under

terms of your choice, provided that you also meet, for each linked

independent module, the terms and conditions of the license of that

module.  An independent module is a module which is not derived from

or based on this library.  If you modify this library, you may extend

this exception to your version of the library, but you are not

obligated to do so.  If you do not wish to do so, delete this

exception statement from your version. */

package javax.swing.plaf.basic;

import java.awt.Color;

import java.awt.Component;

import java.awt.ComponentOrientation;

import java.awt.Dimension;

import java.awt.Graphics;

import java.awt.Point;

import java.awt.Rectangle;

import java.awt.event.ActionEvent;

import java.awt.event.FocusEvent;

import java.awt.event.FocusListener;

import java.awt.event.KeyEvent;

import java.awt.event.KeyListener;

import java.awt.event.MouseEvent;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import javax.swing.AbstractAction;

import javax.swing.Action;

import javax.swing.ActionMap;

import javax.swing.CellRendererPane;

import javax.swing.DefaultCellEditor;

import javax.swing.DefaultListSelectionModel;

import javax.swing.InputMap;

import javax.swing.JComponent;

import javax.swing.JTable;

import javax.swing.ListSelectionModel;

import javax.swing.LookAndFeel;

import javax.swing.SwingUtilities;

import javax.swing.TransferHandler;

import javax.swing.UIManager;

import javax.swing.border.Border;

import javax.swing.event.ChangeEvent;

import javax.swing.event.MouseInputListener;

import javax.swing.plaf.ActionMapUIResource;

import javax.swing.plaf.ComponentUI;

import javax.swing.plaf.TableUI;

import javax.swing.table.TableCellEditor;

import javax.swing.table.TableCellRenderer;

import javax.swing.table.TableColumn;

import javax.swing.table.TableColumnModel;

import javax.swing.table.TableModel;

public class BasicTableUI extends TableUI

{

  public static ComponentUI createUI(JComponent comp)

  {

    return new BasicTableUI();

  }

  protected FocusListener focusListener;

  protected KeyListener keyListener;

  protected MouseInputListener  mouseInputListener;

  protected CellRendererPane rendererPane;

  protected JTable table;

  /** The normal cell border. */

  Border cellBorder;

  /** The action bound to KeyStrokes. */

  TableAction action;

  /**

   * Listens for changes to the tables properties.

   */

  private PropertyChangeListener propertyChangeListener;

  /**

   * Handles key events for the JTable. Key events should be handled through

   * the InputMap/ActionMap mechanism since JDK1.3. This class is only there

   * for backwards compatibility.

   *

   * @author Roman Kennke (kennke@aicas.com)

   */

  public class KeyHandler implements KeyListener

  {

    /**

     * Receives notification that a key has been pressed and released.

     * Activates the editing session for the focused cell by pressing the

     * character keys.

     *

     * @param event the key event

     */

    public void keyTyped(KeyEvent event)

    {

      // Key events should be handled through the InputMap/ActionMap mechanism

      // since JDK1.3. This class is only there for backwards compatibility.

      // Editor activation is a specific kind of response to ''any''

      // character key. Hence it is handled here.

      if (!table.isEditing() && table.isEnabled())

        {

          int r = table.getSelectedRow();

          int c = table.getSelectedColumn();

          if (table.isCellEditable(r, c))

            table.editCellAt(r, c);

        }

    }

    /**

     * Receives notification that a key has been pressed.

     *

     * @param event the key event

     */

    public void keyPressed(KeyEvent event)

    {

      // Key events should be handled through the InputMap/ActionMap mechanism

      // since JDK1.3. This class is only there for backwards compatibility.

    }

    /**

     * Receives notification that a key has been released.

     *

     * @param event the key event

     */

    public void keyReleased(KeyEvent event)

    {

      // Key events should be handled through the InputMap/ActionMap mechanism

      // since JDK1.3. This class is only there for backwards compatibility.

    }

  }

  public class FocusHandler implements FocusListener

  {

    public void focusGained(FocusEvent e)

    {

      // The only thing that is affected by a focus change seems to be

      // how the lead cell is painted. So we repaint this cell.

      repaintLeadCell();

    }

    public void focusLost(FocusEvent e)

    {

      // The only thing that is affected by a focus change seems to be

      // how the lead cell is painted. So we repaint this cell.

      repaintLeadCell();

    }

    /**

     * Repaints the lead cell in response to a focus change, to refresh

     * the display of the focus indicator.

     */

    private void repaintLeadCell()

    {

      int rowCount = table.getRowCount();

      int columnCount = table.getColumnCount();

      int rowLead = table.getSelectionModel().getLeadSelectionIndex();

      int columnLead = table.getColumnModel().getSelectionModel().

                                                       getLeadSelectionIndex();

      if (rowLead >= 0 && rowLead < rowCount && columnLead >= 0

          && columnLead < columnCount)

        {

          Rectangle dirtyRect = table.getCellRect(rowLead, columnLead, false);

          table.repaint(dirtyRect);

        }

    }

  }

  public class MouseInputHandler implements MouseInputListener

  {

    Point begin, curr;

    private void updateSelection(boolean controlPressed)

    {

      // Update the rows

      int lo_row = table.rowAtPoint(begin);

      int hi_row  = table.rowAtPoint(curr);

      ListSelectionModel rowModel = table.getSelectionModel();

      if (lo_row != -1 && hi_row != -1)

        {

          if (controlPressed && rowModel.getSelectionMode()

              != ListSelectionModel.SINGLE_SELECTION)

            rowModel.addSelectionInterval(lo_row, hi_row);

          else

            rowModel.setSelectionInterval(lo_row, hi_row);

        }

      // Update the columns

      int lo_col = table.columnAtPoint(begin);

      int hi_col = table.columnAtPoint(curr);

      ListSelectionModel colModel = table.getColumnModel().

        getSelectionModel();

      if (lo_col != -1 && hi_col != -1)

        {

          if (controlPressed && colModel.getSelectionMode() !=

              ListSelectionModel.SINGLE_SELECTION)

            colModel.addSelectionInterval(lo_col, hi_col);

          else

            colModel.setSelectionInterval(lo_col, hi_col);

        }

    }

    /**

     * For the double click, start the cell editor.

     */

    public void mouseClicked(MouseEvent e)

    {

      Point p = e.getPoint();

      int row = table.rowAtPoint(p);

      int col = table.columnAtPoint(p);

      if (table.isCellEditable(row, col))

        {

          // If the cell editor is the default editor, we request the

          // number of the required clicks from it. Otherwise,

          // require two clicks (double click).

          TableCellEditor editor = table.getCellEditor(row, col);

          if (editor instanceof DefaultCellEditor)

            {

              DefaultCellEditor ce = (DefaultCellEditor) editor;

              if (e.getClickCount() < ce.getClickCountToStart())

                return;

            }

          table.editCellAt(row, col);

        }

    }

    public void mouseDragged(MouseEvent e)

    {

      if (table.isEnabled())

        {

          curr = new Point(e.getX(), e.getY());

          updateSelection(e.isControlDown());

        }

    }

    public void mouseEntered(MouseEvent e)

    {

      // Nothing to do here.

    }

    public void mouseExited(MouseEvent e)

    {

      // Nothing to do here.

    }

    public void mouseMoved(MouseEvent e)

    {

      // Nothing to do here.

    }

    public void mousePressed(MouseEvent e)

    {

      if (table.isEnabled())

        {

          ListSelectionModel rowModel = table.getSelectionModel();

          ListSelectionModel colModel = table.getColumnModel().getSelectionModel();

          int rowLead = rowModel.getLeadSelectionIndex();

          int colLead = colModel.getLeadSelectionIndex();

          begin = new Point(e.getX(), e.getY());

          curr = new Point(e.getX(), e.getY());

          //if control is pressed and the cell is already selected, deselect it

          if (e.isControlDown() && table.isCellSelected(

              table.rowAtPoint(begin), table.columnAtPoint(begin)))

            {

              table.getSelectionModel().

              removeSelectionInterval(table.rowAtPoint(begin),

                                      table.rowAtPoint(begin));

              table.getColumnModel().getSelectionModel().

              removeSelectionInterval(table.columnAtPoint(begin),

                                      table.columnAtPoint(begin));

            }

          else

            updateSelection(e.isControlDown());

          // If we were editing, but the moved to another cell, stop editing

          if (rowLead != rowModel.getLeadSelectionIndex() ||

              colLead != colModel.getLeadSelectionIndex())

            if (table.isEditing())

              table.editingStopped(new ChangeEvent(e));

          // Must request focus explicitly.

          table.requestFocusInWindow();

        }

    }

    public void mouseReleased(MouseEvent e)

    {

      if (table.isEnabled())

        {

          begin = null;

          curr = null;

        }

    }

  }

  /**

   * Listens for changes to the model property of the JTable and adjusts some

   * settings.

   *

   * @author Roman Kennke (kennke@aicas.com)

   */

  private class PropertyChangeHandler implements PropertyChangeListener

  {

    /**

     * Receives notification if one of the JTable's properties changes.

     *

     * @param ev the property change event

     */

    public void propertyChange(PropertyChangeEvent ev)

    {

      String propName = ev.getPropertyName();

      if (propName.equals("model"))

        {

          ListSelectionModel rowSel = table.getSelectionModel();

          rowSel.clearSelection();

          ListSelectionModel colSel = table.getColumnModel().getSelectionModel();

          colSel.clearSelection();

          TableModel model = table.getModel();

          // Adjust lead and anchor selection indices of the row and column

          // selection models.

          if (model.getRowCount() > 0)

            {

              rowSel.setAnchorSelectionIndex(0);

              rowSel.setLeadSelectionIndex(0);

            }

          else

            {

              rowSel.setAnchorSelectionIndex(-1);

              rowSel.setLeadSelectionIndex(-1);

            }

          if (model.getColumnCount() > 0)

            {

              colSel.setAnchorSelectionIndex(0);

              colSel.setLeadSelectionIndex(0);

            }

          else

            {

              colSel.setAnchorSelectionIndex(-1);

              colSel.setLeadSelectionIndex(-1);

            }

        }

    }

  }

  protected FocusListener createFocusListener()

  {

    return new FocusHandler();

  }

  protected MouseInputListener createMouseInputListener()

  {

    return new MouseInputHandler();

  }

  /**

   * Creates and returns a key listener for the JTable.

   *

   * @return a key listener for the JTable

   */

  protected KeyListener createKeyListener()

  {

    return new KeyHandler();

  }

  /**

   * Return the maximum size of the table. The maximum height is the row

    * height times the number of rows. The maximum width is the sum of

    * the maximum widths of each column.

    *

    *  @param comp the component whose maximum size is being queried,

    *  this is ignored.

    *  @return a Dimension object representing the maximum size of the table,

    *  or null if the table has no elements.

   */

  public Dimension getMaximumSize(JComponent comp)

  {

    int maxTotalColumnWidth = 0;

    for (int i = 0; i < table.getColumnCount(); i++)

      maxTotalColumnWidth += table.getColumnModel().getColumn(i).getMaxWidth();

    return new Dimension(maxTotalColumnWidth, getHeight());

  }

  /**

   * Return the minimum size of the table. The minimum height is the row

    * height times the number of rows. The minimum width is the sum of

    * the minimum widths of each column.

    *

    *  @param comp the component whose minimum size is being queried,

    *  this is ignored.

    *  @return a Dimension object representing the minimum size of the table,

    *  or null if the table has no elements.

   */

  public Dimension getMinimumSize(JComponent comp)

  {

    int minTotalColumnWidth = 0;

    for (int i = 0; i < table.getColumnCount(); i++)

      minTotalColumnWidth += table.getColumnModel().getColumn(i).getMinWidth();

    return new Dimension(minTotalColumnWidth, getHeight());

  }

  /**

   * Returns the preferred size for the table of that UI.

   *

   * @param comp ignored, the <code>table</code> field is used instead

   *

   * @return the preferred size for the table of that UI

   */

  public Dimension getPreferredSize(JComponent comp)

  {

    int prefTotalColumnWidth = 0;

    TableColumnModel tcm = table.getColumnModel();

    for (int i = 0; i < tcm.getColumnCount(); i++)

      {

        TableColumn col = tcm.getColumn(i);

        prefTotalColumnWidth += col.getPreferredWidth();

      }

    return new Dimension(prefTotalColumnWidth, getHeight());

  }

  /**

   * Returns the table height. This helper method is used by

   * {@link #getMinimumSize(JComponent)}, {@link #getPreferredSize(JComponent)}

   * and {@link #getMaximumSize(JComponent)} to determine the table height.

   *

   * @return the table height

   */

  private int getHeight()

  {

    int height = 0;

    int rowCount = table.getRowCount();

    if (rowCount > 0 && table.getColumnCount() > 0)

      {

        Rectangle r = table.getCellRect(rowCount - 1, 0, true);

        height = r.y + r.height;

      }

    return height;

  }

  protected void installDefaults()

  {

    LookAndFeel.installColorsAndFont(table, "Table.background",

                                     "Table.foreground", "Table.font");

    table.setGridColor(UIManager.getColor("Table.gridColor"));

    table.setSelectionForeground(UIManager.getColor("Table.selectionForeground"));

    table.setSelectionBackground(UIManager.getColor("Table.selectionBackground"));

    table.setOpaque(true);

  }

  /**

   * Installs keyboard actions on the table.

   */

  protected void installKeyboardActions()

  {

    // Install the input map.

    InputMap inputMap =

      (InputMap) SharedUIDefaults.get("Table.ancestorInputMap");

    SwingUtilities.replaceUIInputMap(table,

                                 JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT,

                                 inputMap);

    // FIXME: The JDK uses a LazyActionMap for parentActionMap

    SwingUtilities.replaceUIActionMap(table, getActionMap());

  }

  /**

   * Fetches the action map from  the UI defaults, or create a new one

   * if the action map hasn't been initialized.

   *

   * @return the action map

   */

  private ActionMap getActionMap()

  {

    ActionMap am = (ActionMap) UIManager.get("Table.actionMap");

    if (am == null)

      {

        am = createDefaultActions();

        UIManager.getLookAndFeelDefaults().put("Table.actionMap", am);

      }

    return am;

  }

  private ActionMap createDefaultActions()

  {

    ActionMapUIResource am = new ActionMapUIResource();

    Action action = new TableAction();

    am.put("cut", TransferHandler.getCutAction());

    am.put("copy", TransferHandler.getCopyAction());

    am.put("paste", TransferHandler.getPasteAction());

    am.put("cancel", action);

    am.put("selectAll", action);

    am.put("clearSelection", action);

    am.put("startEditing", action);

    am.put("selectNextRow", action);

    am.put("selectNextRowCell", action);

    am.put("selectNextRowExtendSelection", action);

    am.put("selectNextRowChangeLead", action);

    am.put("selectPreviousRow", action);

    am.put("selectPreviousRowCell", action);

    am.put("selectPreviousRowExtendSelection", action);

    am.put("selectPreviousRowChangeLead", action);

    am.put("selectNextColumn", action);

    am.put("selectNextColumnCell", action);

    am.put("selectNextColumnExtendSelection", action);

    am.put("selectNextColumnChangeLead", action);

    am.put("selectPreviousColumn", action);

    am.put("selectPreviousColumnCell", action);

    am.put("selectPreviousColumnExtendSelection", action);

    am.put("selectPreviousColumnChangeLead", action);

    am.put("scrollLeftChangeSelection", action);

    am.put("scrollLeftExtendSelection", action);

    am.put("scrollRightChangeSelection", action);

    am.put("scrollRightExtendSelection", action);

    am.put("scrollUpChangeSelection", action);

    am.put("scrollUpExtendSelection", action);

    am.put("scrollDownChangeSelection", action);

    am.put("scrolldownExtendSelection", action);

    am.put("selectFirstColumn", action);

    am.put("selectFirstColumnExtendSelection", action);

    am.put("selectLastColumn", action);

    am.put("selectLastColumnExtendSelection", action);

    am.put("selectFirstRow", action);

    am.put("selectFirstRowExtendSelection", action);

    am.put("selectLastRow", action);

    am.put("selectLastRowExtendSelection", action);

    am.put("addToSelection", action);

    am.put("toggleAndAnchor", action);

    am.put("extendTo", action);

    am.put("moveSelectionTo", action);

    return am;

  }

  /**

   * This class implements the actions that we want to happen

   * when specific keys are pressed for the JTable.  The actionPerformed

   * method is called when a key that has been registered for the JTable

   * is received.

   */

  private static class TableAction

    extends AbstractAction

  {

    /**

     * What to do when this action is called.

     *

     * @param e the ActionEvent that caused this action.

     */

    public void actionPerformed(ActionEvent e)

    {

      JTable table = (JTable) e.getSource();

      DefaultListSelectionModel rowModel

          = (DefaultListSelectionModel) table.getSelectionModel();

      DefaultListSelectionModel colModel

          = (DefaultListSelectionModel) table.getColumnModel().getSelectionModel();

      int rowLead = rowModel.getLeadSelectionIndex();

      int rowMax = table.getModel().getRowCount() - 1;

      int colLead = colModel.getLeadSelectionIndex();

      int colMax = table.getModel().getColumnCount() - 1;

      // The command with which the action has been called is stored

      // in this undocumented action value. This allows us to have only

      // one Action instance to serve all keyboard input for JTable.

      String command = (String) getValue("__command__");

      if (command.equals("selectPreviousRowExtendSelection"))

        {

          rowModel.setLeadSelectionIndex(Math.max(rowLead - 1, 0));

        }

      else if (command.equals("selectLastColumn"))

        {

          colModel.setSelectionInterval(colMax, colMax);

        }

      else if (command.equals("startEditing"))

        {

          if (table.isCellEditable(rowLead, colLead))

            table.editCellAt(rowLead, colLead);

        }

      else if (command.equals("selectFirstRowExtendSelection"))

        {

          rowModel.setLeadSelectionIndex(0);

        }

      else if (command.equals("selectFirstColumn"))

        {

          colModel.setSelectionInterval(0, 0);

        }

      else if (command.equals("selectFirstColumnExtendSelection"))

        {

          colModel.setLeadSelectionIndex(0);

        }

      else if (command.equals("selectLastRow"))

        {

          rowModel.setSelectionInterval(rowMax, rowMax);

        }

      else if (command.equals("selectNextRowExtendSelection"))

        {

          rowModel.setLeadSelectionIndex(Math.min(rowLead + 1, rowMax));

        }

      else if (command.equals("selectFirstRow"))

        {

          rowModel.setSelectionInterval(0, 0);

        }

      else if (command.equals("selectNextColumnExtendSelection"))

        {

          colModel.setLeadSelectionIndex(Math.min(colLead + 1, colMax));

        }

      else if (command.equals("selectLastColumnExtendSelection"))

        {

          colModel.setLeadSelectionIndex(colMax);

        }

      else if (command.equals("selectPreviousColumnExtendSelection"))

        {

          colModel.setLeadSelectionIndex(Math.max(colLead - 1, 0));

        }

      else if (command.equals("selectNextRow"))

        {

          rowModel.setSelectionInterval(Math.min(rowLead + 1, rowMax),

                                        Math.min(rowLead + 1, rowMax));

        }