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