1 /* JScrollPane.java -- 2 Copyright (C) 2002, 2004, 2005 Free Software Foundation, Inc. 3 4 This file is part of GNU Classpath. 5 6 GNU Classpath is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 2, or (at your option) 9 any later version. 10 11 GNU Classpath is distributed in the hope that it will be useful, but 12 WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with GNU Classpath; see the file COPYING. If not, write to the 18 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 19 02110-1301 USA. 20 21 Linking this library statically or dynamically with other modules is 22 making a combined work based on this library. Thus, the terms and 23 conditions of the GNU General Public License cover the whole 24 combination. 25 26 As a special exception, the copyright holders of this library give you 27 permission to link this library with independent modules to produce an 28 executable, regardless of the license terms of these independent 29 modules, and to copy and distribute the resulting executable under 30 terms of your choice, provided that you also meet, for each linked 31 independent module, the terms and conditions of the license of that 32 module. An independent module is a module which is not derived from 33 or based on this library. If you modify this library, you may extend 34 this exception to your version of the library, but you are not 35 obligated to do so. If you do not wish to do so, delete this 36 exception statement from your version. */ 37 38 39 package javax.swing; 40 41 import java.awt.Component; 42 import java.awt.ComponentOrientation; 43 import java.awt.Insets; 44 import java.awt.LayoutManager; 45 import java.awt.Rectangle; 46 import java.beans.PropertyChangeEvent; 47 import java.beans.PropertyChangeListener; 48 49 import javax.accessibility.Accessible; 50 import javax.accessibility.AccessibleContext; 51 import javax.swing.border.Border; 52 import javax.swing.event.ChangeEvent; 53 import javax.swing.event.ChangeListener; 54 import javax.swing.plaf.ScrollPaneUI; 55 import javax.swing.plaf.UIResource; 56 57 /** 58 * A component that embeds another component and enables it to be scrolled 59 * both in horizontal and vertical direction. 60 * 61 * <table> 62 * <tr><th>Property </th><th>Stored in </th><th>Bound?</th></tr> 63 * <tr><td>columnHeader </td><td>scrollPane </td><td>yes </td></tr> 64 * <tr><td>columnHeaderView </td><td>columnHeader </td><td>no </td></tr> 65 * <tr><td>componentOrientation </td><td>scrollPane </td><td>yes </td></tr> 66 * <tr><td>horizontalScrollBar </td><td>scrollPane </td><td>yes </td></tr> 67 * <tr><td>horizontalScrollBarPolicy </td><td>scrollPane </td><td>yes </td></tr> 68 * <tr><td>layout </td><td>scrollPane </td><td>yes </td></tr> 69 * <tr><td>rowHeader </td><td>scrollPane </td><td>yes </td></tr> 70 * <tr><td>rowHeaderView </td><td>rowHeader </td><td>no </td></tr> 71 * <tr><td>validateRoot </td><td>scrollPane </td><td>no </td></tr> 72 * <tr><td>verticalScrollBar </td><td>scrollPane </td><td>yes </td></tr> 73 * <tr><td>verticalScrollBarPolicy </td><td>scrollPane </td><td>yes </td></tr> 74 * <tr><td>viewport </td><td>scrollPane </td><td>yes </td></tr> 75 * <tr><td>viewportBorder </td><td>scrollPane </td><td>yes </td></tr> 76 * <tr><td>viewportBorderBounds </td><td>scrollPane </td><td>no </td></tr> 77 * <tr><td>viewportView </td><td>viewport </td><td>no </td></tr> 78 * <tr><td>wheelScrollingEnabled </td><td>scrollPane </td><td>yes </td></tr> 79 * </table> 80 */ 81 public class JScrollPane extends JComponent 82 implements Accessible, ScrollPaneConstants 83 { 84 /** 85 * Provides accessibility support for the <code>JScrollPane</code>. 86 * 87 * @author Roman Kennke (kennke@aicas.com) 88 */ 89 protected class AccessibleJScrollPane extends AccessibleJComponent 90 implements ChangeListener, PropertyChangeListener 91 { 92 93 /** 94 * The viewport of the underlying scrollpane. 95 */ 96 protected JViewport viewPort; 97 98 /** 99 * Creates a new <code>AccessibleJScrollPane</code> object. This 100 * initializes the <code>viewport</code> field with the current viewport 101 * from the scrollpane associated with this 102 * <code>AccessibleJScrollPane</code>. 103 */ AccessibleJScrollPane()104 public AccessibleJScrollPane() 105 { 106 viewPort = getViewport(); 107 viewPort.addChangeListener(this); 108 viewPort.addPropertyChangeListener(this); 109 } 110 111 /** 112 * Receives notification when the state of the viewport changes. 113 * 114 * @param event the change event 115 */ stateChanged(ChangeEvent event)116 public void stateChanged(ChangeEvent event) 117 { 118 // TODO: Figure out what should be done here, if anything. 119 } 120 121 /** 122 * Receives notification if any of the viewport's bound properties changes. 123 * 124 * @param e the propery change event 125 */ propertyChange(PropertyChangeEvent e)126 public void propertyChange(PropertyChangeEvent e) 127 { 128 // TODO: Figure out what should be done here, if anything. 129 } 130 131 /** 132 * Resets the <code>viewPort</code> field when the scrollpane's viewport 133 * changes. This method is called by 134 * {@link JScrollPane#setViewport(JViewport)} in order to update the 135 * <code>viewPort</code> field and set up the listeners on this viewport 136 * correctly. 137 */ resetViewPort()138 public void resetViewPort() 139 { 140 viewPort.removeChangeListener(this); 141 viewPort.removePropertyChangeListener(this); 142 viewPort = getViewport(); 143 viewPort.addChangeListener(this); 144 viewPort.addPropertyChangeListener(this); 145 } 146 } 147 148 private static final long serialVersionUID = 5203525440012340014L; 149 150 protected JViewport columnHeader; 151 protected JViewport rowHeader; 152 153 protected Component lowerLeft; 154 protected Component lowerRight; 155 protected Component upperLeft; 156 protected Component upperRight; 157 158 protected JScrollBar horizontalScrollBar; 159 protected int horizontalScrollBarPolicy; 160 protected JScrollBar verticalScrollBar; 161 protected int verticalScrollBarPolicy; 162 163 protected JViewport viewport; 164 165 private Border viewportBorder; 166 167 private boolean wheelScrollingEnabled; 168 getColumnHeader()169 public JViewport getColumnHeader() 170 { 171 return columnHeader; 172 } 173 getCorner(String key)174 public Component getCorner(String key) 175 { 176 if (getComponentOrientation() 177 == ComponentOrientation.LEFT_TO_RIGHT) 178 { 179 if (key == LOWER_LEADING_CORNER) 180 key = LOWER_LEFT_CORNER; 181 else if (key == LOWER_TRAILING_CORNER) 182 key = LOWER_RIGHT_CORNER; 183 else if (key == UPPER_LEADING_CORNER) 184 key = UPPER_LEFT_CORNER; 185 else if (key == UPPER_TRAILING_CORNER) 186 key = UPPER_RIGHT_CORNER; 187 } 188 else if (getComponentOrientation() 189 == ComponentOrientation.RIGHT_TO_LEFT) 190 { 191 if (key == LOWER_LEADING_CORNER) 192 key = LOWER_RIGHT_CORNER; 193 else if (key == LOWER_TRAILING_CORNER) 194 key = LOWER_LEFT_CORNER; 195 else if (key == UPPER_LEADING_CORNER) 196 key = UPPER_RIGHT_CORNER; 197 else if (key == UPPER_TRAILING_CORNER) 198 key = UPPER_LEFT_CORNER; 199 } 200 201 if (key == LOWER_RIGHT_CORNER) 202 return lowerRight; 203 else if (key == UPPER_RIGHT_CORNER) 204 return upperRight; 205 else if (key == LOWER_LEFT_CORNER) 206 return lowerLeft; 207 else if (key == UPPER_LEFT_CORNER) 208 return upperLeft; 209 return null; 210 } 211 getHorizontalScrollBar()212 public JScrollBar getHorizontalScrollBar() 213 { 214 return horizontalScrollBar; 215 } 216 getHorizontalScrollBarPolicy()217 public int getHorizontalScrollBarPolicy() 218 { 219 return horizontalScrollBarPolicy; 220 } 221 getRowHeader()222 public JViewport getRowHeader() 223 { 224 return rowHeader; 225 } 226 getVerticalScrollBar()227 public JScrollBar getVerticalScrollBar() 228 { 229 return verticalScrollBar; 230 } 231 getVerticalScrollBarPolicy()232 public int getVerticalScrollBarPolicy() 233 { 234 return verticalScrollBarPolicy; 235 } 236 getViewport()237 public JViewport getViewport() 238 { 239 return viewport; 240 } 241 getViewportBorder()242 public Border getViewportBorder() 243 { 244 return viewportBorder; 245 } 246 getViewportBorderBounds()247 public Rectangle getViewportBorderBounds() 248 { 249 if (viewportBorder == null) 250 { 251 if (getViewport() == null) 252 return new Rectangle(0, 0, 0, 0); 253 else 254 return getViewport().getBounds(); 255 } 256 else 257 { 258 Insets i = viewportBorder.getBorderInsets(getViewport()); 259 if (getViewport() == null) 260 return new Rectangle(0, 0, i.left + i.right, i.top + i.bottom); 261 else 262 { 263 Rectangle b = getViewport().getBounds(); 264 return new Rectangle(b.x - i.left, 265 b.y - i.top, 266 b.width + i.left + i.right, 267 b.height + i.top + i.bottom); 268 } 269 } 270 } 271 isWheelScrollingEnabled()272 public boolean isWheelScrollingEnabled() 273 { 274 return wheelScrollingEnabled; 275 } 276 277 278 sync()279 private void sync() 280 { 281 LayoutManager m = super.getLayout(); 282 if (m != null && m instanceof ScrollPaneLayout) 283 { 284 ScrollPaneLayout sl = (ScrollPaneLayout) m; 285 sl.syncWithScrollPane(this); 286 } 287 } 288 removeNonNull(Component c)289 private void removeNonNull(Component c) 290 { 291 if (c != null) 292 remove(c); 293 } 294 addNonNull(Component c, Object constraints)295 private void addNonNull(Component c, Object constraints) 296 { 297 if (c != null) 298 add(c, constraints); 299 } 300 setComponentOrientation(ComponentOrientation co)301 public void setComponentOrientation(ComponentOrientation co) 302 { 303 ComponentOrientation old = super.getComponentOrientation(); 304 super.setComponentOrientation(co); 305 firePropertyChange("componentOrientation", old, co); 306 sync(); 307 } 308 setColumnHeader(JViewport h)309 public void setColumnHeader(JViewport h) 310 { 311 if (columnHeader == h) 312 return; 313 314 JViewport old = columnHeader; 315 removeNonNull(old); 316 columnHeader = h; 317 addNonNull(h, JScrollPane.COLUMN_HEADER); 318 firePropertyChange("columnHeader", old, h); 319 sync(); 320 } 321 setColumnHeaderView(Component c)322 public void setColumnHeaderView(Component c) 323 { 324 if (columnHeader == null) 325 setColumnHeader(createViewport()); 326 columnHeader.setView(c); 327 sync(); 328 } 329 setCorner(String key, Component c)330 public void setCorner(String key, Component c) 331 { 332 if (getComponentOrientation() 333 == ComponentOrientation.LEFT_TO_RIGHT) 334 { 335 if (key == LOWER_LEADING_CORNER) 336 key = LOWER_LEFT_CORNER; 337 else if (key == LOWER_TRAILING_CORNER) 338 key = LOWER_RIGHT_CORNER; 339 else if (key == UPPER_LEADING_CORNER) 340 key = UPPER_LEFT_CORNER; 341 else if (key == UPPER_TRAILING_CORNER) 342 key = UPPER_RIGHT_CORNER; 343 } 344 else if (getComponentOrientation() 345 == ComponentOrientation.RIGHT_TO_LEFT) 346 { 347 if (key == LOWER_LEADING_CORNER) 348 key = LOWER_RIGHT_CORNER; 349 else if (key == LOWER_TRAILING_CORNER) 350 key = LOWER_LEFT_CORNER; 351 else if (key == UPPER_LEADING_CORNER) 352 key = UPPER_RIGHT_CORNER; 353 else if (key == UPPER_TRAILING_CORNER) 354 key = UPPER_LEFT_CORNER; 355 } 356 357 if (key == LOWER_RIGHT_CORNER) 358 { 359 removeNonNull(lowerRight); 360 lowerRight = c; 361 addNonNull(c, JScrollPane.LOWER_RIGHT_CORNER); 362 } 363 else if (key == UPPER_RIGHT_CORNER) 364 { 365 removeNonNull(upperRight); 366 upperRight = c; 367 addNonNull(c, JScrollPane.UPPER_RIGHT_CORNER); 368 } 369 else if (key == LOWER_LEFT_CORNER) 370 { 371 removeNonNull(lowerLeft); 372 lowerLeft = c; 373 addNonNull(c, JScrollPane.LOWER_LEFT_CORNER); 374 } 375 else if (key == UPPER_LEFT_CORNER) 376 { 377 removeNonNull(upperLeft); 378 upperLeft = c; 379 addNonNull(c, JScrollPane.UPPER_LEFT_CORNER); 380 } 381 else 382 throw new IllegalArgumentException("unknown corner " + key); 383 sync(); 384 } 385 setHorizontalScrollBar(JScrollBar h)386 public void setHorizontalScrollBar(JScrollBar h) 387 { 388 if (horizontalScrollBar == h) 389 return; 390 391 JScrollBar old = horizontalScrollBar; 392 removeNonNull(old); 393 horizontalScrollBar = h; 394 addNonNull(h, JScrollPane.HORIZONTAL_SCROLLBAR); 395 firePropertyChange("horizontalScrollBar", old, h); 396 sync(); 397 398 } 399 setHorizontalScrollBarPolicy(int h)400 public void setHorizontalScrollBarPolicy(int h) 401 { 402 if (horizontalScrollBarPolicy == h) 403 return; 404 405 if (h != HORIZONTAL_SCROLLBAR_AS_NEEDED 406 && h != HORIZONTAL_SCROLLBAR_NEVER 407 && h != HORIZONTAL_SCROLLBAR_ALWAYS) 408 throw new IllegalArgumentException("unknown horizontal scrollbar policy"); 409 410 int old = horizontalScrollBarPolicy; 411 horizontalScrollBarPolicy = h; 412 firePropertyChange("horizontalScrollBarPolicy", old, h); 413 sync(); 414 revalidate(); 415 } 416 setLayout(LayoutManager l)417 public void setLayout(LayoutManager l) 418 { 419 LayoutManager old = super.getLayout(); 420 ScrollPaneLayout tmp = (ScrollPaneLayout) l; 421 super.setLayout(l); 422 tmp.syncWithScrollPane(this); 423 firePropertyChange("layout", old, l); 424 sync(); 425 } 426 setRowHeader(JViewport v)427 public void setRowHeader(JViewport v) 428 { 429 if (rowHeader == v) 430 return; 431 432 JViewport old = rowHeader; 433 removeNonNull(old); 434 rowHeader = v; 435 addNonNull(v, JScrollPane.ROW_HEADER); 436 firePropertyChange("rowHeader", old, v); 437 sync(); 438 } 439 setRowHeaderView(Component c)440 public void setRowHeaderView(Component c) 441 { 442 if (rowHeader == null) 443 setRowHeader(createViewport()); 444 rowHeader.setView(c); 445 sync(); 446 } 447 setVerticalScrollBar(JScrollBar v)448 public void setVerticalScrollBar(JScrollBar v) 449 { 450 if (verticalScrollBar == v) 451 return; 452 453 JScrollBar old = verticalScrollBar; 454 removeNonNull(old); 455 verticalScrollBar = v; 456 addNonNull(v, JScrollPane.VERTICAL_SCROLLBAR); 457 firePropertyChange("verticalScrollBar", old, v); 458 sync(); 459 } 460 setVerticalScrollBarPolicy(int v)461 public void setVerticalScrollBarPolicy(int v) 462 { 463 if (verticalScrollBarPolicy == v) 464 return; 465 466 if (v != VERTICAL_SCROLLBAR_AS_NEEDED 467 && v != VERTICAL_SCROLLBAR_NEVER 468 && v != VERTICAL_SCROLLBAR_ALWAYS) 469 throw new IllegalArgumentException("unknown vertical scrollbar policy"); 470 471 int old = verticalScrollBarPolicy; 472 verticalScrollBarPolicy = v; 473 firePropertyChange("verticalScrollBarPolicy", old, v); 474 sync(); 475 revalidate(); 476 } 477 setWheelScrollingEnabled(boolean b)478 public void setWheelScrollingEnabled(boolean b) 479 { 480 if (wheelScrollingEnabled == b) 481 return; 482 483 boolean old = wheelScrollingEnabled; 484 wheelScrollingEnabled = b; 485 firePropertyChange("wheelScrollingEnabled", old, b); 486 sync(); 487 } 488 setViewport(JViewport v)489 public void setViewport(JViewport v) 490 { 491 if (viewport == v) 492 return; 493 494 JViewport old = viewport; 495 removeNonNull(old); 496 viewport = v; 497 addNonNull(v, JScrollPane.VIEWPORT); 498 revalidate(); 499 repaint(); 500 firePropertyChange("viewport", old, v); 501 sync(); 502 if (accessibleContext != null) 503 { 504 AccessibleJScrollPane asp = (AccessibleJScrollPane) accessibleContext; 505 asp.resetViewPort(); 506 } 507 } 508 setViewportBorder(Border b)509 public void setViewportBorder(Border b) 510 { 511 if (viewportBorder == b) 512 return; 513 514 Border old = viewportBorder; 515 viewportBorder = b; 516 firePropertyChange("viewportBorder", old, b); 517 sync(); 518 } 519 setViewportView(Component view)520 public void setViewportView(Component view) 521 { 522 if (getViewport() == null) 523 { 524 setViewport(createViewport()); 525 } 526 527 if (view != null) 528 { 529 getViewport().setView(view); 530 } 531 sync(); 532 } 533 isValidateRoot()534 public boolean isValidateRoot() 535 { 536 return true; 537 } 538 539 /** 540 * Creates a new <code>JScrollPane</code> without a view. The scrollbar 541 * policy is set to {@link #VERTICAL_SCROLLBAR_AS_NEEDED} and 542 * {@link #HORIZONTAL_SCROLLBAR_AS_NEEDED}. 543 */ JScrollPane()544 public JScrollPane() 545 { 546 this(null); 547 } 548 549 /** 550 * Creates a new <code>JScrollPane</code> that embeds the specified 551 * <code>view</code> component, displaying vertical and horizontal scrollbars 552 * as needed. 553 * 554 * @param view the component that is embedded inside the JScrollPane 555 */ JScrollPane(Component view)556 public JScrollPane(Component view) 557 { 558 this(view, 559 VERTICAL_SCROLLBAR_AS_NEEDED, 560 HORIZONTAL_SCROLLBAR_AS_NEEDED); 561 } 562 563 /** 564 * Creates a new <code>JScrollPane</code> without a view; The scrollbar 565 * policies are set to <code>vsbPolicy</code> and <code>hsbPolicy</code>. 566 * 567 * @param vsbPolicy the vertical scrollbar policy to set 568 * @param hsbPolicy the vertical scrollbar policy to set 569 * 570 * @see ScrollPaneConstants#HORIZONTAL_SCROLLBAR_ALWAYS 571 * @see ScrollPaneConstants#HORIZONTAL_SCROLLBAR_AS_NEEDED 572 * @see ScrollPaneConstants#HORIZONTAL_SCROLLBAR_NEVER 573 * @see ScrollPaneConstants#VERTICAL_SCROLLBAR_ALWAYS 574 * @see ScrollPaneConstants#VERTICAL_SCROLLBAR_AS_NEEDED 575 * @see ScrollPaneConstants#VERTICAL_SCROLLBAR_NEVER 576 */ JScrollPane(int vsbPolicy, int hsbPolicy)577 public JScrollPane(int vsbPolicy, int hsbPolicy) 578 { 579 this(null, vsbPolicy, hsbPolicy); 580 } 581 582 /** 583 * Creates a new <code>JScrollPane</code> that embeds the specified 584 * <code>view</code> component; The scrollbar 585 * policies are set to <code>vsbPolicy</code> and <code>hsbPolicy</code>. 586 * 587 * @param vsbPolicy the vertical scrollbar policy to set 588 * @param hsbPolicy the vertical scrollbar policy to set 589 * 590 * @see ScrollPaneConstants#HORIZONTAL_SCROLLBAR_ALWAYS 591 * @see ScrollPaneConstants#HORIZONTAL_SCROLLBAR_AS_NEEDED 592 * @see ScrollPaneConstants#HORIZONTAL_SCROLLBAR_NEVER 593 * @see ScrollPaneConstants#VERTICAL_SCROLLBAR_ALWAYS 594 * @see ScrollPaneConstants#VERTICAL_SCROLLBAR_AS_NEEDED 595 * @see ScrollPaneConstants#VERTICAL_SCROLLBAR_NEVER 596 */ JScrollPane(Component view, int vsbPolicy, int hsbPolicy)597 public JScrollPane(Component view, int vsbPolicy, int hsbPolicy) 598 { 599 wheelScrollingEnabled = true; 600 setVerticalScrollBarPolicy(vsbPolicy); 601 setVerticalScrollBar(createVerticalScrollBar()); 602 setHorizontalScrollBarPolicy(hsbPolicy); 603 setHorizontalScrollBar(createHorizontalScrollBar()); 604 viewport = createViewport(); 605 if (view != null) 606 getViewport().setView(view); 607 add(viewport,0); 608 setLayout(new ScrollPaneLayout()); 609 setOpaque(false); 610 updateUI(); 611 } 612 613 createHorizontalScrollBar()614 public JScrollBar createHorizontalScrollBar() 615 { 616 return new ScrollBar(SwingConstants.HORIZONTAL); 617 } 618 createVerticalScrollBar()619 public JScrollBar createVerticalScrollBar() 620 { 621 return new ScrollBar(SwingConstants.VERTICAL); 622 } 623 createViewport()624 protected JViewport createViewport() 625 { 626 return new JViewport(); 627 } 628 getUIClassID()629 public String getUIClassID() 630 { 631 return "ScrollPaneUI"; 632 } 633 updateUI()634 public void updateUI() 635 { 636 setUI((ScrollPaneUI) UIManager.getUI(this)); 637 } 638 639 /** 640 * This method returns the scrollpane's UI delegate. 641 * 642 * @return The scrollpane's UI delegate. 643 */ getUI()644 public ScrollPaneUI getUI() 645 { 646 return (ScrollPaneUI) ui; 647 } 648 649 /** 650 * This method sets the scrollpane's UI delegate. 651 * 652 * @param ui The scrollpane's UI delegate. 653 */ setUI(ScrollPaneUI ui)654 public void setUI(ScrollPaneUI ui) 655 { 656 super.setUI(ui); 657 } 658 659 protected class ScrollBar 660 extends JScrollBar 661 implements UIResource 662 { 663 private static final long serialVersionUID = -42032395320987283L; 664 ScrollBar(int orientation)665 public ScrollBar(int orientation) 666 { 667 super(orientation); 668 } 669 getBlockIncrement(int direction)670 public int getBlockIncrement(int direction) 671 { 672 Component view = JScrollPane.this.getViewport().getView(); 673 if (view == null || (! (view instanceof Scrollable))) 674 return super.getBlockIncrement(direction); 675 else 676 { 677 Scrollable s = (Scrollable) view; 678 return s.getScrollableBlockIncrement(JScrollPane.this.getViewport().getViewRect(), 679 this.getOrientation(), 680 direction); 681 } 682 } 683 getUnitIncrement(int direction)684 public int getUnitIncrement(int direction) 685 { 686 Component view = JScrollPane.this.getViewport().getView(); 687 if (view == null || (! (view instanceof Scrollable))) 688 return super.getUnitIncrement(direction); 689 else 690 { 691 Scrollable s = (Scrollable) view; 692 return s.getScrollableUnitIncrement(JScrollPane.this.getViewport().getViewRect(), 693 this.getOrientation(), 694 direction); 695 } 696 } 697 } 698 699 /** 700 * Returns the accessible context associated with this 701 * <code>JScrollPane</code>. 702 * 703 * @return the accessible context associated with this 704 * <code>JScrollPane</code> 705 */ getAccessibleContext()706 public AccessibleContext getAccessibleContext() 707 { 708 if (accessibleContext == null) 709 accessibleContext = new AccessibleJScrollPane(); 710 return accessibleContext; 711 } 712 } 713