jscrollpane.java

Mac OS X 10.4.9 for x86 Source Code gcc 实现源代码

      }
  }

  public void setHorizontalScrollBarPolicy(int h)
  {
    if (horizontalScrollBarPolicy == h)
      return;
    
    if (h != HORIZONTAL_SCROLLBAR_AS_NEEDED
        && h != HORIZONTAL_SCROLLBAR_NEVER
        && h != HORIZONTAL_SCROLLBAR_ALWAYS)
      throw new IllegalArgumentException("unknown horizontal scrollbar policy");    

    int old = horizontalScrollBarPolicy;
    horizontalScrollBarPolicy = h;
    firePropertyChange("horizontalScrollBarPolicy", old, h);
    sync();
  }

  public void setLayout(LayoutManager l)
  {
    LayoutManager old = super.getLayout();
    ScrollPaneLayout tmp = (ScrollPaneLayout) l;
    super.setLayout(l);
    tmp.syncWithScrollPane(this);
    firePropertyChange("layout", old, l);
    sync();
  }

  public void setRowHeader(JViewport v)
  {
    if (rowHeader == v)
      return;
    
    JViewport old = rowHeader;
    removeNonNull(old);
    rowHeader = v;
    addNonNull(v);
    firePropertyChange("rowHeader", old, v);
    sync();
  }

  public void setRowHeaderView(Component c)
  {
    if (rowHeader == null)
      setRowHeader(createViewport());
    rowHeader.setView(c);
    sync();
  }

  public void setVerticalScrollBar(JScrollBar v)
  {
    if (verticalScrollBar == v)
      return;
    
    JScrollBar old = verticalScrollBar;
    removeNonNull(old);
    verticalScrollBar = v;
    addNonNull(v);
    firePropertyChange("verticalScrollBar", old, v);
    sync();

    if (old != null)
      {
        BoundedRangeModel model = old.getModel();
        if (model != null)
          model.removeChangeListener(scrollListener);
      }
    if (v != null)
      {
        BoundedRangeModel model = v.getModel();
        if (model != null)
          model.addChangeListener(scrollListener);
      }
  }

  public void setVerticalScrollBarPolicy(int v)
  {
    if (verticalScrollBarPolicy == v)
      return;
    
    if (v != VERTICAL_SCROLLBAR_AS_NEEDED
        && v != VERTICAL_SCROLLBAR_NEVER
        && v != VERTICAL_SCROLLBAR_ALWAYS)
      throw new IllegalArgumentException("unknown vertical scrollbar policy");    
    
    int old = verticalScrollBarPolicy;
    verticalScrollBarPolicy = v;
    firePropertyChange("verticalScrollBarPolicy", old, v);
    sync();
  }

  public void setWheelScrollingEnabled(boolean b)
  {
    if (wheelScrollingEnabled == b)
      return;
    
    boolean old = wheelScrollingEnabled;
    wheelScrollingEnabled = b;
    firePropertyChange("wheelScrollingEnabled", old, b);
    sync();
  }

  public void setViewport(JViewport v)
  {
    if (viewport == v)
      return;
    
    JViewport old = viewport;
    removeNonNull(old);
    if (old != null)
      old.removeChangeListener(scrollListener);
    viewport = v;
    if (v != null)
      v.addChangeListener(scrollListener);
    addNonNull(v);
    revalidate();
    repaint();
    firePropertyChange("viewport", old, v);
    sync();
  }

  public void setViewportBorder(Border b)
  {
    if (viewportBorder == b)
      return;
    
    Border old = viewportBorder;
    viewportBorder = b;
    firePropertyChange("viewportBorder", old, b);
    sync();
  }
    
  public void setViewportView(Component view)
  {
    if (getViewport() == null)
      {
        setViewport(createViewport());
      }
	
    if (view != null)
      {
        getViewport().setView(view);
      }
    sync();
  }

  public boolean isValidateRoot()
  {
    return true;
  }

  ChangeListener createScrollListener()
  {
    return new ChangeListener() 
      {
        
        public void stateChanged(ChangeEvent event)
        {
          JScrollBar vsb = JScrollPane.this.getVerticalScrollBar();
          JScrollBar hsb = JScrollPane.this.getHorizontalScrollBar();
          JViewport vp = JScrollPane.this.getViewport();

          if (vp != null && event.getSource() == vp)
            {
              // if the viewport changed, we should update the VSB / HSB
              // models according to the new vertical and horizontal sizes

              Rectangle vr = vp.getViewRect();
              Dimension vs = vp.getViewSize();
              if (vsb != null
                  && (vsb.getMinimum() != 0
                      || vsb.getMaximum() != vs.height
                      || vsb.getValue() != vr.y
                      || vsb.getVisibleAmount() != vr.height))
                vsb.setValues(vr.y, vr.height, 0, vs.height);

              if (hsb != null
                  && (hsb.getMinimum() != 0
                      || hsb.getMaximum() != vs.width
                      || hsb.getValue() != vr.width
                      || hsb.getVisibleAmount() != vr.height))
                hsb.setValues(vr.x, vr.width, 0, vs.width);
            }
          else
            {
              // otherwise we got a change update from either the VSB or
              // HSB model, and we need to update the viewport positions of
              // both the main viewport and any row or column headers to
              // match.

              int xpos = 0;
              int ypos = 0;
              
              if (vsb != null)
                ypos = vsb.getValue();
              
              if (hsb != null)
                xpos = hsb.getValue();

              Point pt = new Point(xpos, ypos);

              if (vp != null
                  && vp.getViewPosition() != pt)
                vp.setViewPosition(pt);

              pt.x = 0;

              if (rowHeader != null 
                  && rowHeader.getViewPosition() != pt)
                rowHeader.setViewPosition(pt);
              
              pt.x = xpos;
              pt.y = 0;

              if (columnHeader != null 
                  && columnHeader.getViewPosition() != pt)
                columnHeader.setViewPosition(pt);

            }
        }
      };
  }


  public JScrollPane() 
  {
    this(null);
  }
    
  public JScrollPane(Component view) 
  {
    this(view, 
         VERTICAL_SCROLLBAR_AS_NEEDED, 
         HORIZONTAL_SCROLLBAR_AS_NEEDED);
  }

  public JScrollPane(int vsbPolicy, int hsbPolicy) 
  {
    this(null, vsbPolicy, hsbPolicy);
  }

  public JScrollPane(Component view, int vsbPolicy, int hsbPolicy) 
  {
    scrollListener = createScrollListener();
    setVerticalScrollBarPolicy(vsbPolicy);
    setVerticalScrollBar(createVerticalScrollBar());
    setHorizontalScrollBarPolicy(hsbPolicy);
    setHorizontalScrollBar(createHorizontalScrollBar());
    setViewportView(view);
    setLayout(new ScrollPaneLayout());
    setOpaque(false);
    updateUI();
  }

  
  public JScrollBar createHorizontalScrollBar()
  {
    return new ScrollBar(SwingConstants.HORIZONTAL);
  }

  public JScrollBar createVerticalScrollBar()
  {
    return new ScrollBar(SwingConstants.VERTICAL);
  }
    
  protected JViewport createViewport()
  {
    return new JViewport();
  }

  public String getUIClassID()
  {
    return "ScrollPaneUI";
  }
  
  public void updateUI()
  {
    ScrollPaneUI b = (ScrollPaneUI)UIManager.getUI(this);
    setUI(b);
  }  

  /**
   * This method returns the scrollpane's UI delegate.
   *
   * @return The scrollpane's UI delegate.
   */
  public ScrollPaneUI getUI()
  {
    return (ScrollPaneUI) ui;
  }

  /**
   * This method sets the scrollpane's UI delegate.
   *
   * @param ui The scrollpane's UI delegate.
   */
  public void setUI(ScrollPaneUI ui)
  {
    super.setUI(ui);
  }

  protected class ScrollBar 
    extends JScrollBar
    implements UIResource
  {
    public ScrollBar(int orientation)
    {
      super(orientation);
    }

    public int getBlockIncrement(int direction)
    {
      Component view = JScrollPane.this.getViewport().getView();
      if (view == null || (! (view instanceof Scrollable)))
        return super.getBlockIncrement(direction);
      else
        {
          Scrollable s = (Scrollable) view;
          return s.getScrollableBlockIncrement(JScrollPane.this.getViewport().getViewRect(), 
                                               this.getOrientation(),
                                               direction);
        }
    }

    public int getUnitIncrement(int direction)
    {
      Component view = JScrollPane.this.getViewport().getView();
      if (view == null || (! (view instanceof Scrollable)))
        return super.getUnitIncrement(direction);
      else
        {
          Scrollable s = (Scrollable) view;
          return s.getScrollableUnitIncrement(JScrollPane.this.getViewport().getViewRect(), 
                                              this.getOrientation(),
                                              direction);
        }
    }
  }
}