Source for javax.swing.JSplitPane

   1: /* JSplitPane.java -- 
   2:    Copyright (C) 2004, 2006,  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.Graphics;
  43: import java.beans.PropertyChangeEvent;
  44: 
  45: import javax.accessibility.Accessible;
  46: import javax.accessibility.AccessibleContext;
  47: import javax.accessibility.AccessibleRole;
  48: import javax.accessibility.AccessibleState;
  49: import javax.accessibility.AccessibleStateSet;
  50: import javax.accessibility.AccessibleValue;
  51: import javax.swing.plaf.SplitPaneUI;
  52: 
  53: /**
  54:  * This class implements JSplitPane. It is used to divide two components. By
  55:  * dragging the SplitPane's divider, the user can resize the two components.
  56:  * Note that the divider cannot resize a component to smaller than it's
  57:  * minimum size.
  58:  */
  59: public class JSplitPane extends JComponent implements Accessible
  60: {
  61: 
  62:   /**
  63:    * Provides the accessibility features for the <code>JSplitPane</code>
  64:    * component.
  65:    */
  66:   protected class AccessibleJSplitPane extends JComponent.AccessibleJComponent
  67:     implements AccessibleValue
  68:   {
  69:   private static final long serialVersionUID = -1788116871416305366L;
  70:   
  71:     /**
  72:      * Creates a new <code>AccessibleJSplitPane</code> instance.
  73:      */
  74:     protected AccessibleJSplitPane()
  75:     {
  76:       // Nothing to do here.
  77:     }
  78: 
  79:     /**
  80:      * Returns a set containing the current state of the {@link JSplitPane} 
  81:      * component.
  82:      *
  83:      * @return The accessible state set.
  84:      */
  85:     public AccessibleStateSet getAccessibleStateSet()
  86:     {
  87:       AccessibleStateSet result = super.getAccessibleStateSet();
  88:       if (getOrientation() == HORIZONTAL_SPLIT)
  89:         {
  90:           result.add(AccessibleState.HORIZONTAL);
  91:         }
  92:       else if (getOrientation() == VERTICAL_SPLIT)
  93:         {
  94:           result.add(AccessibleState.VERTICAL);
  95:         }
  96:       return result;
  97:     }
  98: 
  99:     /**
 100:      * Returns the accessible role for the <code>JSplitPane</code> component.
 101:      *
 102:      * @return {@link AccessibleRole#SPLIT_PANE}.
 103:      */
 104:     public AccessibleRole getAccessibleRole()
 105:     {
 106:       return AccessibleRole.SPLIT_PANE;
 107:     }
 108: 
 109:     /**
 110:      * Returns an object that provides access to the current, minimum and 
 111:      * maximum values for the {@link JSplitPane}.  Since this class implements 
 112:      * {@link AccessibleValue}, it returns itself.
 113:      *
 114:      * @return The accessible value.
 115:      */
 116:     public AccessibleValue getAccessibleValue()
 117:     {
 118:       return this;
 119:     }
 120: 
 121:     /**
 122:      * Returns the current divider location for the {@link JSplitPane} 
 123:      * component, as an {@link Integer}.
 124:      *
 125:      * @return The current divider location.
 126:      */
 127:     public Number getCurrentAccessibleValue()
 128:     {
 129:       return new Integer(getDividerLocation());
 130:     }
 131: 
 132:     /**
 133:      * Sets the divider location for the {@link JSplitPane} component and sends 
 134:      * a {@link PropertyChangeEvent} (with the property name 
 135:      * {@link AccessibleContext#ACCESSIBLE_VALUE_PROPERTY}) to all registered
 136:      * listeners.  If the supplied value is <code>null</code>, this method 
 137:      * does nothing and returns <code>false</code>.
 138:      *
 139:      * @param value  the new divider location (<code>null</code> permitted).
 140:      *
 141:      * @return <code>true</code> if the divider location value is updated, and 
 142:      *     <code>false</code> otherwise.
 143:      */
 144:     public boolean setCurrentAccessibleValue(Number value)
 145:     {
 146:       if (value == null)
 147:         return false;
 148:       Number oldValue = getCurrentAccessibleValue();
 149:       setDividerLocation(value.intValue());
 150:       firePropertyChange(AccessibleContext.ACCESSIBLE_VALUE_PROPERTY, oldValue, 
 151:                          new Integer(value.intValue()));
 152:       return true;
 153:     }
 154: 
 155:     /**
 156:      * Returns the minimum divider location for the {@link JSplitPane} 
 157:      * component, as an {@link Integer}.
 158:      *
 159:      * @return The minimum divider location.
 160:      */
 161:     public Number getMinimumAccessibleValue()
 162:     {
 163:       return new Integer(getMinimumDividerLocation());
 164:     }
 165: 
 166:     /**
 167:      * Returns the maximum divider location for the {@link JSplitPane} 
 168:      * component, as an {@link Integer}.
 169:      *
 170:      * @return The maximum divider location.
 171:      */
 172:     public Number getMaximumAccessibleValue()
 173:     {
 174:       return new Integer(getMaximumDividerLocation());
 175:     }
 176:   }
 177: 
 178:   private static final long serialVersionUID = -5634142046175988380L;
 179:   
 180:   /** The constraints string used to add components to the bottom. */
 181:   public static final String BOTTOM = "bottom";
 182: 
 183:   /** The property fired when the continuousLayout property changes. */
 184:   public static final String CONTINUOUS_LAYOUT_PROPERTY = "continuousLayout";
 185: 
 186:   /** The property fired when the divider property changes. */
 187:   public static final String DIVIDER = "divider";
 188: 
 189:   /** The property fired when the divider location property changes. */
 190:   public static final String DIVIDER_LOCATION_PROPERTY = "dividerLocation";
 191: 
 192:   /** The property fired when the divider size property changes. */
 193:   public static final String DIVIDER_SIZE_PROPERTY = "dividerSize";
 194: 
 195:   /**
 196:    * The value of the orientation when the components are split horizontally.
 197:    */
 198:   public static final int HORIZONTAL_SPLIT = 1;
 199: 
 200:   /** The property fired when the last divider location property changes. */
 201:   public static final String LAST_DIVIDER_LOCATION_PROPERTY = 
 202:     "lastDividerLocation";
 203: 
 204:   /** The constraints string used to add components to the left. */
 205:   public static final String LEFT = "left";
 206: 
 207:   /** The property fired when the one touch expandable property changes. */
 208:   public static final String ONE_TOUCH_EXPANDABLE_PROPERTY = 
 209:     "oneTouchExpandable";
 210: 
 211:   /** The property fired when the orientation property changes. */
 212:   public static final String ORIENTATION_PROPERTY = "orientation";
 213: 
 214:   /** The property fired when the resize weight property changes. */
 215:   public static final String RESIZE_WEIGHT_PROPERTY = "resizeWeight";
 216: 
 217:   /** The constraints string used to add components to the right. */
 218:   public static final String RIGHT = "right";
 219: 
 220:   /** The constraints string used to add components to the top. */
 221:   public static final String TOP = "top";
 222: 
 223:   /** The value of the orientation when the components are split vertically. */
 224:   public static final int VERTICAL_SPLIT = 0;
 225: 
 226:   /** Whether the JSplitPane uses continuous layout. */
 227:   protected boolean continuousLayout;
 228: 
 229:   /** Whether the JSplitPane uses one touch expandable buttons. */
 230:   protected boolean oneTouchExpandable = false;
 231: 
 232:   // This is the master dividerSize variable and sets the 
 233:   // BasicSplitPaneDivider one accordingly
 234: 
 235:   /** The size of the divider. */
 236:   protected int dividerSize = 10;
 237: 
 238:   /** The last location of the divider given by the UI. */
 239:   protected int lastDividerLocation;
 240: 
 241:   /** The orientation of the JSplitPane. */
 242:   protected int orientation;
 243: 
 244:   /** The component on the top or left. */
 245:   protected Component leftComponent;
 246: 
 247:   /** The component on the right or bottom. */
 248:   protected Component rightComponent;
 249: 
 250:   /**
 251:    * The divider location.
 252:    */
 253:   private int dividerLocation;
 254: 
 255:   /** Determines how extra space should be allocated. */
 256:   private transient double resizeWeight;
 257: 
 258:   /**
 259:    * Indicates if the dividerSize property has been set by a client program or
 260:    * by the UI.
 261:    *
 262:    * @see #setUIProperty(String, Object)
 263:    * @see LookAndFeel#installProperty(JComponent, String, Object)
 264:    */
 265:   private boolean clientDividerSizeSet = false;
 266: 
 267:   /**
 268:    * Indicates if the oneTouchExpandable property has been set by a client
 269:    * program or by the UI.
 270:    *
 271:    * @see #setUIProperty(String, Object)
 272:    * @see LookAndFeel#installProperty(JComponent, String, Object)
 273:    */
 274:   private boolean clientOneTouchExpandableSet = false;
 275: 
 276:   /**
 277:    * Creates a new JSplitPane object with the given orientation, layout mode,
 278:    * and left and right components.
 279:    *
 280:    * @param newOrientation The orientation to use.
 281:    * @param newContinuousLayout The layout mode to use.
 282:    * @param newLeftComponent The left component.
 283:    * @param newRightComponent The right component.
 284:    *
 285:    * @throws IllegalArgumentException DOCUMENT ME!
 286:    */
 287:   public JSplitPane(int newOrientation, boolean newContinuousLayout,
 288:                     Component newLeftComponent, Component newRightComponent)
 289:   {
 290:     if (newOrientation != HORIZONTAL_SPLIT && newOrientation != VERTICAL_SPLIT)
 291:       throw new IllegalArgumentException("orientation is invalid.");
 292:     orientation = newOrientation;
 293:     continuousLayout = newContinuousLayout;
 294:     setLeftComponent(newLeftComponent);
 295:     setRightComponent(newRightComponent);
 296:     dividerLocation = -1;
 297:     updateUI();
 298:   }
 299: 
 300:   /**
 301:    * Creates a new JSplitPane object using nonContinuousLayout mode, the given
 302:    * orientation and left and right components.
 303:    *
 304:    * @param newOrientation The orientation to use.
 305:    * @param newLeftComponent The left component.
 306:    * @param newRightComponent The right component.
 307:    */
 308:   public JSplitPane(int newOrientation, Component newLeftComponent,
 309:                     Component newRightComponent)
 310:   {
 311:     this(newOrientation, false, newLeftComponent, newRightComponent);
 312:   }
 313: 
 314:   /**
 315:    * Creates a new JSplitPane object with the given layout mode and
 316:    * orientation.
 317:    *
 318:    * @param newOrientation The orientation to use.
 319:    * @param newContinuousLayout The layout mode to use.
 320:    */
 321:   public JSplitPane(int newOrientation, boolean newContinuousLayout)
 322:   {
 323:     this(newOrientation, newContinuousLayout, null, null);
 324:   }
 325: 
 326:   /**
 327:    * Creates a new JSplitPane object using a nonContinuousLayout mode and the
 328:    * given orientation.
 329:    *
 330:    * @param newOrientation The orientation to use.
 331:    */
 332:   public JSplitPane(int newOrientation)
 333:   {
 334:     this(newOrientation, false, null, null);
 335:   }
 336: 
 337:   /**
 338:    * Creates a new JSplitPane object using HORIZONTAL_SPLIT and a
 339:    * nonContinuousLayout mode.
 340:    */
 341:   public JSplitPane()
 342:   {
 343:     this(HORIZONTAL_SPLIT, false, new JButton("left button"),
 344:          new JButton("right button"));
 345:   }
 346: 
 347:   /**
 348:    * This method adds a component to the JSplitPane. The constraints object is
 349:    * a string that identifies where this component should go. If the
 350:    * constraints is not a known one, it will throw an
 351:    * IllegalArgumentException. The valid constraints are LEFT, TOP, RIGHT,
 352:    * BOTTOM and DIVIDER.
 353:    *
 354:    * @param comp The component to add.
 355:    * @param constraints The constraints string to use.
 356:    * @param index Where to place to component in the list of components.
 357:    *
 358:    * @throws IllegalArgumentException When the constraints is not a known 
 359:    * identifier.
 360:    */
 361:   protected void addImpl(Component comp, Object constraints, int index)
 362:   {
 363:     if (constraints == null)
 364:       {
 365:         if (leftComponent == null)
 366:           constraints = LEFT;
 367:         else if (rightComponent == null)
 368:           constraints = RIGHT;
 369:       }
 370: 
 371:     if (constraints instanceof String)
 372:       {
 373:         String placement = (String) constraints;
 374: 
 375:         if (placement.equals(BOTTOM) || placement.equals(RIGHT))
 376:           {
 377:             if (rightComponent != null)
 378:               remove(rightComponent);
 379:             rightComponent = comp;
 380:           }
 381:         else if (placement.equals(LEFT) || placement.equals(TOP))
 382:           {
 383:             if (leftComponent != null)
 384:               remove(leftComponent);
 385:             leftComponent = comp;
 386:           }
 387:         else if (placement.equals(DIVIDER))
 388:           constraints = null;
 389:         else
 390:           throw new 
 391:             IllegalArgumentException("Constraints is not a known identifier.");
 392: 
 393:         // If no dividerLocation has been set, then we need to trigger an
 394:         // initial layout.
 395:         if (getDividerLocation() != -1)
 396:           resetToPreferredSizes();
 397: 
 398:         super.addImpl(comp, constraints, index);
 399:       }
 400:   }
 401: 
 402:   /**
 403:    * Returns the object that provides accessibility features for this
 404:    * <code>JSplitPane</code> component.
 405:    *
 406:    * @return The accessible context (an instance of 
 407:    *     {@link AccessibleJSplitPane}).
 408:    */
 409:   public AccessibleContext getAccessibleContext()
 410:   {
 411:     if (accessibleContext == null)
 412:       accessibleContext = new AccessibleJSplitPane();
 413:     
 414:     return accessibleContext;
 415:   }
 416: 
 417:   /**
 418:    * This method returns the bottom component.
 419:    *
 420:    * @return The bottom component.
 421:    */
 422:   public Component getBottomComponent()
 423:   {
 424:     return rightComponent;
 425:   }
 426: 
 427:   /**
 428:    * This method returns the location of the divider. This method is passed to
 429:    * the UI.
 430:    *
 431:    * @return The location of the divider.
 432:    */
 433:   public int getDividerLocation()
 434:   {
 435:     return dividerLocation;
 436:   }
 437: 
 438:   /**
 439:    * This method returns the size of the divider.
 440:    *
 441:    * @return The size of the divider.
 442:    */
 443:   public int getDividerSize()
 444:   {
 445:     return dividerSize;
 446:   }
 447: 
 448:   /**
 449:    * This method returns the last divider location.
 450:    *
 451:    * @return The last divider location.
 452:    */
 453:   public int getLastDividerLocation()
 454:   {
 455:     return lastDividerLocation;
 456:   }
 457: 
 458:   /**
 459:    * This method returns the left component.
 460:    *
 461:    * @return The left component.
 462:    */
 463:   public Component getLeftComponent()
 464:   {
 465:     return leftComponent;
 466:   }
 467: 
 468:   /**
 469:    * This method returns the maximum divider location. This method is passed
 470:    * to  the UI.
 471:    *
 472:    * @return DOCUMENT ME!
 473:    */
 474:   public int getMaximumDividerLocation()
 475:   {
 476:     if (ui != null)
 477:       return ((SplitPaneUI) ui).getMaximumDividerLocation(this);
 478:     else
 479:       return -1;
 480:   }
 481: 
 482:   /**
 483:    * This method returns the minimum divider location. This method is passed
 484:    * to the UI.
 485:    *
 486:    * @return The minimum divider location.
 487:    */
 488:   public int getMinimumDividerLocation()
 489:   {
 490:     if (ui != null)
 491:       return ((SplitPaneUI) ui).getMinimumDividerLocation(this);
 492:     else
 493:       return -1;
 494:   }
 495: 
 496:   /**
 497:    * This method returns the orientation that the JSplitPane is using.
 498:    *
 499:    * @return The current orientation.
 500:    */
 501:   public int getOrientation()
 502:   {
 503:     return orientation;
 504:   }
 505: 
 506:   /**
 507:    * This method returns the current resize weight.
 508:    *
 509:    * @return The current resize weight.
 510:    */
 511:   public double getResizeWeight()
 512:   {
 513:     return resizeWeight;
 514:   }
 515: 
 516:   /**
 517:    * This method returns the right component.
 518:    *
 519:    * @return The right component.
 520:    */
 521:   public Component getRightComponent()
 522:   {
 523:     return rightComponent;
 524:   }
 525: 
 526:   /**
 527:    * This method returns the top component.
 528:    *
 529:    * @return The top component.
 530:    */
 531:   public Component getTopComponent()
 532:   {
 533:     return leftComponent;
 534:   }
 535: 
 536:   /**
 537:    * This method returns the UI.
 538:    *
 539:    * @return The UI.
 540:    */
 541:   public SplitPaneUI getUI()
 542:   {
 543:     return (SplitPaneUI) ui;
 544:   }
 545: 
 546:   /**
 547:    * This method returns true if the JSplitPane is using a continuousLayout.
 548:    *
 549:    * @return True if using a continuousLayout.
 550:    */
 551:   public boolean isContinuousLayout()
 552:   {
 553:     return continuousLayout;
 554:   }
 555: 
 556:   /**
 557:    * This method returns true if the divider has one touch expandable buttons.
 558:    *
 559:    * @return True if one touch expandable is used.
 560:    */
 561:   public boolean isOneTouchExpandable()
 562:   {
 563:     return oneTouchExpandable;
 564:   }
 565: 
 566:   /**
 567:    * This method returns true.
 568:    *
 569:    * @return true.
 570:    */
 571:   public boolean isValidateRoot()
 572:   {
 573:     return true;
 574:   }
 575: 
 576:   /**
 577:    * This method overrides JComponent's paintChildren so the UI can be
 578:    * messaged when the children have finished painting.
 579:    *
 580:    * @param g The Graphics object to paint with.
 581:    */
 582:   protected void paintChildren(Graphics g)
 583:   {
 584:     super.paintChildren(g);
 585:     if (ui != null)
 586:       ((SplitPaneUI) ui).finishedPaintingChildren(this, g);
 587:   }
 588: 
 589:   /**
 590:    * Returns an implementation-dependent string describing the attributes of
 591:    * this <code>JSplitPane</code>.
 592:    *
 593:    * @return A string describing the attributes of this <code>JSplitPane</code>
 594:    *         (never <code>null</code>).
 595:    */
 596:   protected String paramString()
 597:   {
 598:     // FIXME: the next line can be restored once PR27208 is fixed
 599:     String superParamStr = ""; //super.paramString();
 600:     StringBuffer sb = new StringBuffer();
 601:     sb.append(",continuousLayout=").append(isContinuousLayout());
 602:     sb.append(",dividerSize=").append(getDividerSize());
 603:     sb.append(",lastDividerLocation=").append(getLastDividerLocation());
 604:     sb.append(",oneTouchExpandable=").append(isOneTouchExpandable());
 605:     sb.append(",orientation=");
 606:     if (orientation == HORIZONTAL_SPLIT)
 607:       sb.append("HORIZONTAL_SPLIT");
 608:     else
 609:       sb.append("VERTICAL_SPLIT");
 610:     return superParamStr + sb.toString();
 611:   }
 612: 
 613:   /**
 614:    * This method removes the given component from the JSplitPane.
 615:    *
 616:    * @param component The Component to remove.
 617:    */
 618:   public void remove(Component component)
 619:   {
 620:     if (component == leftComponent)
 621:       leftComponent = null;
 622:     else if (component == rightComponent)
 623:       rightComponent = null;
 624:     super.remove(component);
 625:   }
 626: 
 627:   /**
 628:    * This method removes the component at the given index.
 629:    *
 630:    * @param index The index of the component to remove.
 631:    */
 632:   public void remove(int index)
 633:   {
 634:     Component component = getComponent(index);
 635:     if (component == leftComponent)
 636:       leftComponent = null;
 637:     else if (component == rightComponent)
 638:       rightComponent = null;
 639:     super.remove(index);
 640:   }
 641: 
 642:   /**
 643:    * This method removes all components from the JSplitPane.
 644:    */
 645:   public void removeAll()
 646:   {
 647:     leftComponent = null;
 648:     rightComponent = null;
 649:     super.removeAll();
 650:   }
 651: 
 652:   /**
 653:    * This method resets all children of the JSplitPane to their preferred
 654:    * sizes.
 655:    */
 656:   public void resetToPreferredSizes()
 657:   {
 658:     if (ui != null)
 659:       ((SplitPaneUI) ui).resetToPreferredSizes(this);
 660:   }
 661: 
 662:   /**
 663:    * This method sets the bottom component.
 664:    *
 665:    * @param comp The Component to be placed at the bottom.
 666:    */
 667:   public void setBottomComponent(Component comp)
 668:   {
 669:     if (comp != null)
 670:       add(comp, BOTTOM);
 671:     else
 672:       add(new JButton("right button"), BOTTOM);
 673:   }
 674: 
 675:   /**
 676:    * This method sets the layout mode for the JSplitPane.
 677:    *
 678:    * @param newContinuousLayout Whether the JSplitPane is in continuousLayout
 679:    *        mode.
 680:    */
 681:   public void setContinuousLayout(boolean newContinuousLayout)
 682:   {
 683:     if (newContinuousLayout != continuousLayout)
 684:       {
 685:         boolean oldValue = continuousLayout;
 686:         continuousLayout = newContinuousLayout;
 687:         firePropertyChange(CONTINUOUS_LAYOUT_PROPERTY, oldValue,
 688:                            continuousLayout);
 689:       }
 690:   }
 691: 
 692:   /**
 693:    * This method sets the location of the divider. A value of 0 sets the
 694:    * divider to the farthest left. A value of 1 sets the divider to the
 695:    * farthest right.
 696:    *
 697:    * @param proportionalLocation A double that describes the location of the
 698:    *        divider.
 699:    *
 700:    * @throws IllegalArgumentException if <code>proportionalLocation</code> is
 701:    *     not in the range from 0.0 to 1.0 inclusive.
 702:    */
 703:   public void setDividerLocation(double proportionalLocation)
 704:   {
 705:     if (proportionalLocation > 1 || proportionalLocation < 0)
 706:       throw new IllegalArgumentException
 707:         ("proportion has to be between 0 and 1.");
 708: 
 709:     int max = ((orientation == HORIZONTAL_SPLIT) ? getWidth() : getHeight())
 710:               - getDividerSize();
 711:     setDividerLocation((int) (proportionalLocation * max));
 712:   }
 713: 
 714:   /**
 715:    * This method sets the location of the divider.
 716:    * 
 717:    * @param location The location of the divider. The negative value forces to
 718:    *          compute the new location from the preferred sizes of the split
 719:    *          pane components.
 720:    */
 721:   public void setDividerLocation(int location)
 722:   {
 723:     int oldLocation = dividerLocation;
 724:     dividerLocation = location;
 725:     SplitPaneUI ui = getUI();
 726:     if (ui != null)
 727:       ui.setDividerLocation(this, location);
 728:     firePropertyChange(DIVIDER_LOCATION_PROPERTY, oldLocation, 
 729:                        location);
 730:   }
 731: 
 732:   /**
 733:    * This method sets the size of the divider.
 734:    *
 735:    * @param newSize The size of the divider.
 736:    */
 737:   public void setDividerSize(int newSize)
 738:   {
 739:     clientDividerSizeSet = true;
 740:     if (newSize != dividerSize)
 741:       {
 742:         int oldSize = dividerSize;
 743:         dividerSize = newSize;
 744:         firePropertyChange(DIVIDER_SIZE_PROPERTY, oldSize, dividerSize);
 745:       }
 746:   }
 747: 
 748:   // This doesn't appear to do anything when set from user side.
 749:   // so it probably is only used from the UI side to change the
 750:   // lastDividerLocation var.
 751: 
 752:   /**
 753:    * This method sets the last location of the divider.
 754:    *
 755:    * @param newLastLocation The last location of the divider.
 756:    */
 757:   public void setLastDividerLocation(int newLastLocation)
 758:   {
 759:     if (newLastLocation != lastDividerLocation)
 760:       {
 761:         int oldValue = lastDividerLocation;
 762:         lastDividerLocation = newLastLocation;
 763:         firePropertyChange(LAST_DIVIDER_LOCATION_PROPERTY, oldValue,
 764:                            lastDividerLocation);
 765:       }
 766:   }
 767: 
 768:   /**
 769:    * This method sets the left component.
 770:    *
 771:    * @param comp The left component.
 772:    */
 773:   public void setLeftComponent(Component comp)
 774:   {    
 775:     if (comp != null)
 776:       add(comp, LEFT);
 777:     else
 778:       remove (leftComponent);
 779:   }
 780: 
 781:   /**
 782:    * This method sets whether the divider has one touch expandable buttons.
 783:    * The one touch expandable buttons can expand the size of either component
 784:    * to the maximum allowed size.
 785:    *
 786:    * @param newValue Whether the divider will have one touch expandable
 787:    *        buttons.
 788:    */
 789:   public void setOneTouchExpandable(boolean newValue)
 790:   {
 791:     clientOneTouchExpandableSet = true;
 792:     if (newValue != oneTouchExpandable)
 793:       {
 794:         boolean oldValue = oneTouchExpandable;
 795:         oneTouchExpandable = newValue;
 796:         firePropertyChange(ONE_TOUCH_EXPANDABLE_PROPERTY, oldValue,
 797:                            oneTouchExpandable);
 798:       }
 799:   }
 800: 
 801:   /**
 802:    * Sets the orientation for the <code>JSplitPane</code> and sends a 
 803:    * {@link PropertyChangeEvent} (with the property name 
 804:    * {@link #ORIENTATION_PROPERTY}) to all registered listeners.
 805:    *
 806:    * @param orientation  the orientation (either {@link #HORIZONTAL_SPLIT}
 807:    * or {@link #VERTICAL_SPLIT}).
 808:    *
 809:    * @throws IllegalArgumentException if <code>orientation</code> is not one of
 810:    *     the listed values.
 811:    */
 812:   public void setOrientation(int orientation)
 813:   {
 814:     if (orientation != HORIZONTAL_SPLIT && orientation != VERTICAL_SPLIT)
 815:       throw new IllegalArgumentException
 816:         ("orientation must be one of VERTICAL_SPLIT, HORIZONTAL_SPLIT");
 817:     if (orientation != this.orientation)
 818:       {
 819:         int oldOrientation = this.orientation;
 820:         this.orientation = orientation;
 821:         firePropertyChange(ORIENTATION_PROPERTY, oldOrientation,
 822:                            this.orientation);
 823:       }
 824:   }
 825: 
 826:   /**
 827:    * This method determines how extra space will be distributed among the left
 828:    * and right components. A value of 0 will allocate all extra space to the
 829:    * right component. A value of 1 indicates that all extra space will go to
 830:    * the left component. A value in between 1 and 0 will split the space
 831:    * accordingly.
 832:    *
 833:    * @param value The resize weight.
 834:    */
 835:   public void setResizeWeight(double value)
 836:   {
 837:     if (value < 0.0 || value > 1.0)
 838:       throw new IllegalArgumentException("Value outside permitted range.");
 839:     if (this.resizeWeight != value)
 840:       { 
 841:         double old = resizeWeight;
 842:         resizeWeight = value;
 843:         firePropertyChange(RESIZE_WEIGHT_PROPERTY, old, value);
 844:       }
 845:   }
 846: 
 847:   /**
 848:    * This method sets the right component.
 849:    *
 850:    * @param comp The right component.
 851:    */
 852:   public void setRightComponent(Component comp)
 853:   {
 854:     if (comp != null)
 855:       add(comp, RIGHT);
 856:     else
 857:       remove (rightComponent);
 858:   }
 859: 
 860:   /**
 861:    * This method sets the top component.
 862:    *
 863:    * @param comp The top component.
 864:    */
 865:   public void setTopComponent(Component comp)
 866:   {
 867:     if (comp != null)
 868:       add(comp, TOP);
 869:     else
 870:       add(new JButton("left button"), TOP);
 871:   }
 872: 
 873:   /**
 874:    * This method sets the UI used by the JSplitPane.
 875:    *
 876:    * @param ui The UI to use.
 877:    */
 878:   public void setUI(SplitPaneUI ui)
 879:   {
 880:     super.setUI(ui);
 881:   }
 882: 
 883:   /**
 884:    * This method resets the UI to the one specified by the current Look and
 885:    * Feel.
 886:    */
 887:   public void updateUI()
 888:   {
 889:     setUI((SplitPaneUI) UIManager.getUI(this));
 890:   }
 891: 
 892:   /**
 893:    * This method returns a string identifier to determine which UI class it
 894:    * needs.
 895:    *
 896:    * @return A string that identifies it's UI class.
 897:    */
 898:   public String getUIClassID()
 899:   {
 900:     return "SplitPaneUI";
 901:   }
 902: 
 903:   /**
 904:    * Helper method for
 905:    * {@link LookAndFeel#installProperty(JComponent, String, Object)}.
 906:    * 
 907:    * @param propertyName the name of the property
 908:    * @param value the value of the property
 909:    *
 910:    * @throws IllegalArgumentException if the specified property cannot be set
 911:    *         by this method
 912:    * @throws ClassCastException if the property value does not match the
 913:    *         property type
 914:    * @throws NullPointerException if <code>c</code> or
 915:    *         <code>propertyValue</code> is <code>null</code>
 916:    */
 917:   void setUIProperty(String propertyName, Object value)
 918:   {
 919:     if (propertyName.equals("dividerSize"))
 920:       {
 921:         if (! clientDividerSizeSet)
 922:           {
 923:             setDividerSize(((Integer) value).intValue());
 924:             clientDividerSizeSet = false;
 925:           }
 926:       }
 927:     else if (propertyName.equals("oneTouchExpandable"))
 928:       {
 929:         if (! clientOneTouchExpandableSet)
 930:           {
 931:             setOneTouchExpandable(((Boolean) value).booleanValue());
 932:             clientOneTouchExpandableSet = false;
 933:           }
 934:       }
 935:     else
 936:       {
 937:         super.setUIProperty(propertyName, value);
 938:       }
 939:   }
 940: }