path: root/libjava/classpath/javax/swing/plaf/basic/BasicScrollPaneUI.java

/* BasicScrollPaneUI.java
   Copyright (C) 2002, 2004, 2005, 2006, 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.Dimension;
import java.awt.Graphics;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.event.ActionEvent;
import java.awt.event.ContainerEvent;
import java.awt.event.ContainerListener;
import java.awt.event.MouseWheelEvent;
import java.awt.event.MouseWheelListener;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;

import javax.swing.AbstractAction;
import javax.swing.ActionMap;
import javax.swing.InputMap;
import javax.swing.JComponent;
import javax.swing.JScrollBar;
import javax.swing.JScrollPane;
import javax.swing.JSlider;
import javax.swing.JViewport;
import javax.swing.LookAndFeel;
import javax.swing.ScrollPaneConstants;
import javax.swing.ScrollPaneLayout;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;
import javax.swing.border.Border;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import javax.swing.plaf.ActionMapUIResource;
import javax.swing.plaf.ComponentUI;
import javax.swing.plaf.ScrollPaneUI;
import javax.swing.plaf.UIResource;

/**
 * A UI delegate for the {@link JScrollPane} component.
 */
public class BasicScrollPaneUI extends ScrollPaneUI
  implements ScrollPaneConstants
{

  /**
   * Listens for changes in the state of the horizontal scrollbar's model and
   * updates the scrollpane accordingly.
   *
   * @author Roman Kennke (kennke@aicas.com)
   */
  public class HSBChangeListener implements ChangeListener
  {

    /**
     * Receives notification when the state of the horizontal scrollbar
     * model has changed.
     *
     * @param event the change event
     */
    public void stateChanged(ChangeEvent event)
    {
      JScrollBar hsb = scrollpane.getHorizontalScrollBar();
      JViewport vp = scrollpane.getViewport();
      Point viewPosition = vp.getViewPosition();
      viewPosition.x = hsb.getValue();
      vp.setViewPosition(viewPosition);
    }

  }

  /**
   * Listens for changes in the state of the vertical scrollbar's model and
   * updates the scrollpane accordingly.
   *
   * @author Roman Kennke (kennke@aicas.com)
   */
  public class VSBChangeListener implements ChangeListener
  {

    /**
     * Receives notification when the state of the vertical scrollbar
     * model has changed.
     *
     * @param event the change event
     */
    public void stateChanged(ChangeEvent event)
    {
      JScrollBar vsb = scrollpane.getVerticalScrollBar();
      JViewport vp = scrollpane.getViewport();
      Point viewPosition = vp.getViewPosition();
      viewPosition.y = vsb.getValue();
      vp.setViewPosition(viewPosition);
    }

  }

  /**
   * Listens for changes of the viewport's extent size and updates the
   * scrollpane accordingly.
   *
   * @author Roman Kennke (kennke@aicas.com)
   */
  public class ViewportChangeHandler implements ChangeListener
  {

    /**
     * Receives notification when the view's size, position or extent size
     * changes. When the extents size has changed, this method calls
     * {@link BasicScrollPaneUI#syncScrollPaneWithViewport()} to adjust the
     * scrollbars extents as well.
     *
     * @param event the change event
     */
    public void stateChanged(ChangeEvent event)
    {
      syncScrollPaneWithViewport();
    }

  }

  /**
   * Listens for property changes on the scrollpane and update the view
   * accordingly.
   *
   * @author Roman Kennke (kennke@aicas.com)
   */
  public class PropertyChangeHandler implements PropertyChangeListener
  {

    /**
     * Receives notification when any of the scrollpane's bound property
     * changes. This method calls the appropriate update method on the
     * <code>ScrollBarUI</code>.
     *
     * @param e the property change event
     *
     * @see BasicScrollPaneUI#updateColumnHeader(PropertyChangeEvent)
     * @see BasicScrollPaneUI#updateRowHeader(PropertyChangeEvent)
     * @see BasicScrollPaneUI#updateScrollBarDisplayPolicy(PropertyChangeEvent)
     * @see BasicScrollPaneUI#updateViewport(PropertyChangeEvent)
     */
    public void propertyChange(PropertyChangeEvent e)
    {
      String propName = e.getPropertyName();
      if (propName.equals("viewport"))
        updateViewport(e);
      else if (propName.equals("rowHeader"))
        updateRowHeader(e);
      else if (propName.equals("columnHeader"))
        updateColumnHeader(e);
      else if (propName.equals("horizontalScrollBarPolicy")
          || e.getPropertyName().equals("verticalScrollBarPolicy"))
        updateScrollBarDisplayPolicy(e);
      else if (propName.equals("verticalScrollBar"))
        {
          JScrollBar oldSb = (JScrollBar) e.getOldValue();
          oldSb.getModel().removeChangeListener(vsbChangeListener);
          JScrollBar newSb = (JScrollBar) e.getNewValue();
          newSb.getModel().addChangeListener(vsbChangeListener);
        }
      else if (propName.equals("horizontalScrollBar"))
        {
          JScrollBar oldSb = (JScrollBar) e.getOldValue();
          oldSb.getModel().removeChangeListener(hsbChangeListener);
          JScrollBar newSb = (JScrollBar) e.getNewValue();
          newSb.getModel().addChangeListener(hsbChangeListener);
        }
    }

  }

  /**
   * Listens for mouse wheel events and update the scrollpane accordingly.
   *
   * @author Roman Kennke (kennke@aicas.com)
   *
   * @since 1.4
   */
  protected class MouseWheelHandler implements MouseWheelListener
  {
    /**
     * Use to compute the visible rectangle.
     */
    final Rectangle rect = new Rectangle();

    /**
     * Scroll with the mouse wheel.
     *
     * @author Audrius Meskauskas (audriusa@Bioinformatics.org)
     */
    public void mouseWheelMoved(MouseWheelEvent e)
    {
      if (scrollpane.isWheelScrollingEnabled() && e.getScrollAmount() != 0)
        {
          // Try to scroll vertically first.
          JScrollBar scrollBar = scrollpane.getVerticalScrollBar();
          if (scrollBar == null || ! scrollBar.isVisible())
            scrollBar = scrollpane.getHorizontalScrollBar();
          if (scrollBar != null && scrollBar.isVisible())
            {
              int direction = e.getWheelRotation() < 0 ? -1 : 1;
              int scrollType = e.getScrollType();
              if (scrollType == MouseWheelEvent.WHEEL_UNIT_SCROLL)
                BasicScrollBarUI.scrollByUnits(scrollBar, direction,
                                               e.getScrollAmount());
              else if (scrollType == MouseWheelEvent.WHEEL_BLOCK_SCROLL)
                BasicScrollBarUI.scrollByBlock(scrollBar, direction);
            }
        }
    }
  }

  /**
   * Adds/removes the mouse wheel listener when the component is added/removed
   * to/from the scroll pane view port.
   *
   * @author Audrius Meskauskas (audriusa@bioinformatics.org)
   */
  class ViewportContainerListener implements ContainerListener
  {
    /**
     * Add the mouse wheel listener, allowing to scroll with the mouse.
     */
    public void componentAdded(ContainerEvent e)
    {
      e.getChild().addMouseWheelListener(mouseWheelListener);
    }

    /**
     * Remove the mouse wheel listener.
     */
    public void componentRemoved(ContainerEvent e)
    {
      e.getChild().removeMouseWheelListener(mouseWheelListener);
    }
  }

  /**
   * The number of pixels by that we should scroll the content that does
   * not implement Scrollable.
   */
  static int SCROLL_NON_SCROLLABLES = 10;

  /**
   * The number of rows to scroll per mouse wheel click. From impression,
   * Sun seems using the value 3.
   */
  static int ROWS_PER_WHEEL_CLICK = 3;

  /** The Scrollpane for which the UI is provided by this class. */
  protected JScrollPane scrollpane;

  /**
   * The horizontal scrollbar listener.
   */
  protected ChangeListener hsbChangeListener;

  /**
   * The vertical scrollbar listener.
   */
  protected ChangeListener vsbChangeListener;

  /**
   * The viewport listener.
   */
  protected ChangeListener viewportChangeListener;

  /**
   * The scrollpane property change listener.
   */
  protected PropertyChangeListener spPropertyChangeListener;

  /**
   * The mousewheel listener for the scrollpane.
   */
  MouseWheelListener mouseWheelListener;

  /**
   * The listener to add and remove the mouse wheel listener to/from
   * the component container.
   */
  ContainerListener containerListener;

  public static ComponentUI createUI(final JComponent c)
  {
    return new BasicScrollPaneUI();
  }

  protected void installDefaults(JScrollPane p)
  {
    scrollpane = p;
    LookAndFeel.installColorsAndFont(p, "ScrollPane.background",
                                     "ScrollPane.foreground",
                                     "ScrollPane.font");
    LookAndFeel.installBorder(p, "ScrollPane.border");

    // Install Viewport border.
    Border vpBorder = p.getViewportBorder();
    if (vpBorder == null || vpBorder instanceof UIResource)
      {
        vpBorder = UIManager.getBorder("ScrollPane.viewportBorder");
        p.setViewportBorder(vpBorder);
      }

    p.setOpaque(true);
  }

  protected void uninstallDefaults(JScrollPane p)
  {
    LookAndFeel.uninstallBorder(p);
    Border vpBorder = p.getViewportBorder();
    if (vpBorder != null && vpBorder instanceof UIResource)
      p.setViewportBorder(null);
  }

  public void installUI(final JComponent c)
  {
    super.installUI(c);
    installDefaults((JScrollPane) c);
    installListeners((JScrollPane) c);
    installKeyboardActions((JScrollPane) c);
  }

  /**
   * Installs the listeners on the scrollbars, the viewport and the scrollpane.
   *
   * @param sp the scrollpane on which to install the listeners
   */
  protected void installListeners(JScrollPane sp)
  {
    if (spPropertyChangeListener == null)
      spPropertyChangeListener = createPropertyChangeListener();
    sp.addPropertyChangeListener(spPropertyChangeListener);

    if (hsbChangeListener == null)
      hsbChangeListener = createHSBChangeListener();
    sp.getHorizontalScrollBar().getModel().addChangeListener(hsbChangeListener);

    if (vsbChangeListener == null)
      vsbChangeListener = createVSBChangeListener();
    sp.getVerticalScrollBar().getModel().addChangeListener(vsbChangeListener);

    if (viewportChangeListener == null)
      viewportChangeListener = createViewportChangeListener();

    if (mouseWheelListener == null)
      mouseWheelListener = createMouseWheelListener();

    if (containerListener == null)
      containerListener = new ViewportContainerListener();

    JViewport v = sp.getViewport();
    v.addChangeListener(viewportChangeListener);
    v.addContainerListener(containerListener);

    // Add mouse wheel listeners to the componets that are probably already
    // in the view port.
    for (int i = 0; i < v.getComponentCount(); i++)
      v.getComponent(i).addMouseWheelListener(mouseWheelListener);
  }

  InputMap getInputMap(int condition)
  {
    if (condition == JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT)
      return (InputMap) UIManager.get("ScrollPane.ancestorInputMap");
    return null;
  }

  /**
   * Returns the action map for the {@link JScrollPane}.  All scroll panes
   * share a single action map which is created the first time this method is
   * called, then stored in the UIDefaults table for subsequent access.
   *
   * @return The shared action map.
   */
  ActionMap getActionMap()
  {
    ActionMap map = (ActionMap) UIManager.get("ScrollPane.actionMap");

    if (map == null) // first time here
      {
        map = createActionMap();
        if (map != null)
          UIManager.put("ScrollPane.actionMap", map);
      }
    return map;
  }

  /**
   * Creates the action map shared by all {@link JSlider} instances.
   * This method is called once by {@link #getActionMap()} when it
   * finds no action map in the UIDefaults table...after the map is
   * created, it gets added to the defaults table so that subsequent
   * calls to {@link #getActionMap()} will return the same shared
   * instance.
   *
   * @return The action map.
   */
  ActionMap createActionMap()
  {
    ActionMap map = new ActionMapUIResource();
    map.put("scrollLeft",
            new AbstractAction("scrollLeft") {
              public void actionPerformed(ActionEvent event)
              {
                JScrollPane sp = (JScrollPane) event.getSource();
                JScrollBar sb = sp.getHorizontalScrollBar();
                if (sb.isVisible())
                  {
                    int delta = sb.getBlockIncrement(-1);
                    sb.setValue(sb.getValue() + delta);
                  }
              }
            }
    );
    map.put("scrollEnd",
            new AbstractAction("scrollEnd") {
              public void actionPerformed(ActionEvent event)
              {
                JScrollPane sp = (JScrollPane) event.getSource();
                JScrollBar sb1 = sp.getHorizontalScrollBar();
                if (sb1.isVisible())
                  {
                    sb1.setValue(sb1.getMaximum());
                  }
                JScrollBar sb2 = sp.getVerticalScrollBar();
                if (sb2.isVisible())
                  {
                    sb2.setValue(sb2.getMaximum());
                  }
              }
            }
    );
    map.put("unitScrollUp",
            new AbstractAction("unitScrollUp") {
              public void actionPerformed(ActionEvent event)
              {
                JScrollPane sp = (JScrollPane) event.getSource();
                JScrollBar sb = sp.getVerticalScrollBar();
                if (sb.isVisible())
                  {
                    int delta = sb.getUnitIncrement(-1);
                    sb.setValue(sb.getValue() + delta);
                  }
              }
            }
    );
    map.put("unitScrollLeft",
            new AbstractAction("unitScrollLeft") {
              public void actionPerformed(ActionEvent event)
              {
                JScrollPane sp = (JScrollPane) event.getSource();
                JScrollBar sb = sp.getHorizontalScrollBar();
                if (sb.isVisible())
                  {
                    int delta = sb.getUnitIncrement(-1);
                    sb.setValue(sb.getValue() + delta);
                  }
              }
            }
    );
    map.put("scrollUp",
            new AbstractAction("scrollUp") {
              public void actionPerformed(ActionEvent event)
              {
                JScrollPane sp = (JScrollPane) event.getSource();
                JScrollBar sb = sp.getVerticalScrollBar();
                if (sb.isVisible())
                  {
                    int delta = sb.getBlockIncrement(-1);
                    sb.setValue(sb.getValue() + delta);
                  }
              }
            }
    );
    map.put("scrollRight",
            new AbstractAction("scrollRight") {
              public void actionPerformed(ActionEvent event)
              {
                JScrollPane sp = (JScrollPane) event.getSource();
                JScrollBar sb = sp.getHorizontalScrollBar();
                if (sb.isVisible())
                  {
                    int delta = sb.getBlockIncrement(1);
                    sb.setValue(sb.getValue() + delta);
                  }
              }
            }
    );
    map.put("scrollHome",
            new AbstractAction("scrollHome") {
              public void actionPerformed(ActionEvent event)
              {
                JScrollPane sp = (JScrollPane) event.getSource();
                JScrollBar sb1 = sp.getHorizontalScrollBar();
                if (sb1.isVisible())
                  {
                    sb1.setValue(sb1.getMinimum());
                  }
                JScrollBar sb2 = sp.getVerticalScrollBar();
                if (sb2.isVisible())
                  {
                    sb2.setValue(sb2.getMinimum());
                  }
              }
            }
    );
    map.put("scrollDown",
            new AbstractAction("scrollDown") {
              public void actionPerformed(ActionEvent event)
              {
                JScrollPane sp = (JScrollPane) event.getSource();
                JScrollBar sb = sp.getVerticalScrollBar();
                if (sb.isVisible())
                  {
                    int delta = sb.getBlockIncrement(1);
                    sb.setValue(sb.getValue() + delta);
                  }
              }
            }
    );
    map.put("unitScrollDown",
            new AbstractAction("unitScrollDown") {
              public void actionPerformed(ActionEvent event)
              {
                JScrollPane sp = (JScrollPane) event.getSource();
                JScrollBar sb = sp.getVerticalScrollBar();
                if (sb.isVisible())
                  {
                    int delta = sb.getUnitIncrement(1);
                    sb.setValue(sb.getValue() + delta);
                  }
              }
            }
    );
    map.put("unitScrollRight",
            new AbstractAction("unitScrollRight") {
              public void actionPerformed(ActionEvent event)
              {
                JScrollPane sp = (JScrollPane) event.getSource();
                JScrollBar sb = sp.getHorizontalScrollBar();
                if (sb.isVisible())
                  {
                    int delta = sb.getUnitIncrement(1);
                    sb.setValue(sb.getValue() + delta);
                  }
              }
            }
    );
    return map;
  }

  /**
   * Installs additional keyboard actions on the scrollpane. This is a hook
   * method provided to subclasses in order to install their own keyboard
   * actions.
   *
   * @param sp the scrollpane to install keyboard actions on
   */
  protected void installKeyboardActions(JScrollPane sp)
  {
    InputMap keyMap = getInputMap(
        JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);
    SwingUtilities.replaceUIInputMap(sp,
        JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, keyMap);
    ActionMap map = getActionMap();
    SwingUtilities.replaceUIActionMap(sp, map);
  }

  /**
   * Uninstalls all keyboard actions from the JScrollPane that have been
   * installed by {@link #installKeyboardActions}. This is a hook method
   * provided to subclasses to add their own keyboard actions.
   *
   * @param sp the scrollpane to uninstall keyboard actions from
   */
  protected void uninstallKeyboardActions(JScrollPane sp)
  {
    SwingUtilities.replaceUIActionMap(sp, null);
    SwingUtilities.replaceUIInputMap(sp,
        JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, null);
  }

  /**
   * Creates and returns the change listener for the horizontal scrollbar.
   *
   * @return the change listener for the horizontal scrollbar
   */
  protected ChangeListener createHSBChangeListener()
  {
    return new HSBChangeListener();
  }

  /**
   * Creates and returns the change listener for the vertical scrollbar.
   *
   * @return the change listener for the vertical scrollbar
   */
  protected ChangeListener createVSBChangeListener()
  {
    return new VSBChangeListener();
  }

  /**
   * Creates and returns the change listener for the viewport.
   *
   * @return the change listener for the viewport
   */
  protected ChangeListener createViewportChangeListener()
  {
    return new ViewportChangeHandler();
  }

  /**
   * Creates and returns the property change listener for the scrollpane.
   *
   * @return the property change listener for the scrollpane
   */
  protected PropertyChangeListener createPropertyChangeListener()
  {
    return new PropertyChangeHandler();
  }

  /**
   * Creates and returns the mouse wheel listener for the scrollpane.
   *
   * @return the mouse wheel listener for the scrollpane
   *
   * @since 1.4
   */
  protected MouseWheelListener createMouseWheelListener()
  {
    return new MouseWheelHandler();
  }

  public void uninstallUI(final JComponent c)
  {
    uninstallDefaults((JScrollPane) c);
    uninstallListeners(c);
    installKeyboardActions((JScrollPane) c);
  }

  /**
   * Uninstalls all the listeners that have been installed in
   * {@link #installListeners(JScrollPane)}.
   *
   * @param c the scrollpane from which to uninstall the listeners
   */
  protected void uninstallListeners(JComponent c)
  {
    JScrollPane sp = (JScrollPane) c;
    sp.removePropertyChangeListener(spPropertyChangeListener);
    sp.getHorizontalScrollBar().getModel()
                               .removeChangeListener(hsbChangeListener);
    sp.getVerticalScrollBar().getModel()
                             .removeChangeListener(vsbChangeListener);

    JViewport v = sp.getViewport();
    v.removeChangeListener(viewportChangeListener);
    v.removeContainerListener(containerListener);

    for (int i = 0; i < v.getComponentCount(); i++)
      v.getComponent(i).removeMouseWheelListener(mouseWheelListener);

  }

  public Dimension getMinimumSize(JComponent c)
  {
    JScrollPane p = (JScrollPane) c;
    ScrollPaneLayout sl = (ScrollPaneLayout) p.getLayout();
    return sl.minimumLayoutSize(c);
  }

  public void paint(Graphics g, JComponent c)
  {
    Border vpBorder = scrollpane.getViewportBorder();
    if (vpBorder != null)
      {
        Rectangle r = scrollpane.getViewportBorderBounds();
        vpBorder.paintBorder(scrollpane, g, r.x, r.y, r.width, r.height);
      }
  }

  /**
   * Synchronizes the scrollbar and header settings positions and extent
   * with the viewport's view position and extent.
   */
  protected void syncScrollPaneWithViewport()
  {
    JViewport vp = scrollpane.getViewport();

    if (vp != null)
      {
        Dimension extentSize = vp.getExtentSize();
        Point viewPos = vp.getViewPosition();
        Dimension viewSize = vp.getViewSize();

        // Update the vertical scrollbar.
        JScrollBar vsb = scrollpane.getVerticalScrollBar();
        if (vsb != null)
          {
            int extent = extentSize.height;
            int max = viewSize.height;
            int val = Math.max(0, Math.min(viewPos.y, max - extent));
            vsb.setValues(val, extent, 0, max);
          }

        // Update the horizontal scrollbar.
        JScrollBar hsb = scrollpane.getHorizontalScrollBar();
        if (hsb != null)
          {
            int extent = extentSize.width;
            int max = viewSize.width;
            int val = Math.max(0, Math.min(viewPos.x, max - extent));
            hsb.setValues(val, extent, 0, max);
          }

        // Update the row header.
        JViewport rowHeader = scrollpane.getRowHeader();
        if (rowHeader != null)
          {
            Point p = new Point(0, viewPos.y);
            rowHeader.setViewPosition(p);
          }

        // Update the column header.
        JViewport colHeader = scrollpane.getColumnHeader();
        if (colHeader != null)
          {
            Point p = new Point(viewPos.x, 0);
            colHeader.setViewPosition(p);
          }
      }
  }

  /**
   * Receives notification when the <code>columnHeader</code> property has
   * changed on the scrollpane.
   *
   * @param ev the property change event
   */
  protected void updateColumnHeader(PropertyChangeEvent ev)
  {
    // TODO: Find out what should be done here. Or is this only a hook?
  }

  /**
   * Receives notification when the <code>rowHeader</code> property has changed
   * on the scrollpane.
   *
   * @param ev the property change event
   */
  protected void updateRowHeader(PropertyChangeEvent ev)
  {
    // TODO: Find out what should be done here. Or is this only a hook?
  }

  /**
   * Receives notification when the <code>scrollBarDisplayPolicy</code>
   * property has changed on the scrollpane.
   *
   * @param ev the property change event
   */
  protected void updateScrollBarDisplayPolicy(PropertyChangeEvent ev)
  {
    scrollpane.revalidate();
    scrollpane.repaint();
  }

  /**
   * Receives notification when the <code>viewport</code> property has changed
   * on the scrollpane.
   *
   * This method sets removes the viewportChangeListener from the old viewport
   * and adds it to the new viewport.
   *
   * @param ev the property change event
   */
  protected void updateViewport(PropertyChangeEvent ev)
  {
    JViewport oldViewport = (JViewport) ev.getOldValue();
    oldViewport.removeChangeListener(viewportChangeListener);
    JViewport newViewport = (JViewport) ev.getNewValue();
    newViewport.addChangeListener(viewportChangeListener);
    syncScrollPaneWithViewport();
  }
}