GNU Classpath (0.91) | |
Frames | No Frames |
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 JSlider}. 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 slider value (<code>null</code> permitted). 140: * 141: * @return <code>true</code> if the slider 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: /** Determines how extra space should be allocated. */ 251: private transient double resizeWeight; 252: 253: /** 254: * Indicates if the dividerSize property has been set by a client program or 255: * by the UI. 256: * 257: * @see #setUIProperty(String, Object) 258: * @see LookAndFeel#installProperty(JComponent, String, Object) 259: */ 260: private boolean clientDividerSizeSet = false; 261: 262: /** 263: * Indicates if the oneTouchExpandable property has been set by a client 264: * program or by the UI. 265: * 266: * @see #setUIProperty(String, Object) 267: * @see LookAndFeel#installProperty(JComponent, String, Object) 268: */ 269: private boolean clientOneTouchExpandableSet = false; 270: 271: /** 272: * Creates a new JSplitPane object with the given orientation, layout mode, 273: * and left and right components. 274: * 275: * @param newOrientation The orientation to use. 276: * @param newContinuousLayout The layout mode to use. 277: * @param newLeftComponent The left component. 278: * @param newRightComponent The right component. 279: * 280: * @throws IllegalArgumentException DOCUMENT ME! 281: */ 282: public JSplitPane(int newOrientation, boolean newContinuousLayout, 283: Component newLeftComponent, Component newRightComponent) 284: { 285: if (newOrientation != HORIZONTAL_SPLIT && newOrientation != VERTICAL_SPLIT) 286: throw new IllegalArgumentException("orientation is invalid."); 287: orientation = newOrientation; 288: continuousLayout = newContinuousLayout; 289: setLeftComponent(newLeftComponent); 290: setRightComponent(newRightComponent); 291: 292: updateUI(); 293: } 294: 295: /** 296: * Creates a new JSplitPane object using nonContinuousLayout mode, the given 297: * orientation and left and right components. 298: * 299: * @param newOrientation The orientation to use. 300: * @param newLeftComponent The left component. 301: * @param newRightComponent The right component. 302: */ 303: public JSplitPane(int newOrientation, Component newLeftComponent, 304: Component newRightComponent) 305: { 306: this(newOrientation, false, newLeftComponent, newRightComponent); 307: } 308: 309: /** 310: * Creates a new JSplitPane object with the given layout mode and 311: * orientation. 312: * 313: * @param newOrientation The orientation to use. 314: * @param newContinuousLayout The layout mode to use. 315: */ 316: public JSplitPane(int newOrientation, boolean newContinuousLayout) 317: { 318: this(newOrientation, newContinuousLayout, null, null); 319: } 320: 321: /** 322: * Creates a new JSplitPane object using a nonContinuousLayout mode and the 323: * given orientation. 324: * 325: * @param newOrientation The orientation to use. 326: */ 327: public JSplitPane(int newOrientation) 328: { 329: this(newOrientation, false, null, null); 330: } 331: 332: /** 333: * Creates a new JSplitPane object using HORIZONTAL_SPLIT and a 334: * nonContinuousLayout mode. 335: */ 336: public JSplitPane() 337: { 338: this(HORIZONTAL_SPLIT, false, new JButton("left button"), 339: new JButton("right button")); 340: } 341: 342: /** 343: * This method adds a component to the JSplitPane. The constraints object is 344: * a string that identifies where this component should go. If the 345: * constraints is not a known one, it will throw an 346: * IllegalArgumentException. The valid constraints are LEFT, TOP, RIGHT, 347: * BOTTOM and DIVIDER. 348: * 349: * @param comp The component to add. 350: * @param constraints The constraints string to use. 351: * @param index Where to place to component in the list of components. 352: * 353: * @throws IllegalArgumentException When the constraints is not a known 354: * identifier. 355: */ 356: protected void addImpl(Component comp, Object constraints, int index) 357: { 358: int left = 0; 359: int right = 1; 360: int div = 2; 361: int place; 362: if (constraints == null) 363: { 364: if (leftComponent == null) 365: constraints = LEFT; 366: else if (rightComponent == null) 367: constraints = RIGHT; 368: } 369: 370: if (constraints instanceof String) 371: { 372: String placement = (String) constraints; 373: 374: if (placement.equals(BOTTOM) || placement.equals(RIGHT)) 375: { 376: if (rightComponent != null) 377: remove(rightComponent); 378: rightComponent = comp; 379: } 380: else if (placement.equals(LEFT) || placement.equals(TOP)) 381: { 382: if (leftComponent != null) 383: remove(leftComponent); 384: leftComponent = comp; 385: } 386: else if (placement.equals(DIVIDER)) 387: constraints = null; 388: else 389: throw new 390: IllegalArgumentException("Constraints is not a known identifier."); 391: 392: // If no dividerLocation has been set, then we need to trigger an 393: // initial layout. 394: if (getDividerLocation() != -1) 395: resetToPreferredSizes(); 396: 397: super.addImpl(comp, constraints, index); 398: } 399: } 400: 401: /** 402: * Returns the object that provides accessibility features for this 403: * <code>JSplitPane</code> component. 404: * 405: * @return The accessible context (an instance of 406: * {@link AccessibleJSplitPane}). 407: */ 408: public AccessibleContext getAccessibleContext() 409: { 410: if (accessibleContext == null) 411: accessibleContext = new AccessibleJSplitPane(); 412: 413: return accessibleContext; 414: } 415: 416: /** 417: * This method returns the bottom component. 418: * 419: * @return The bottom component. 420: */ 421: public Component getBottomComponent() 422: { 423: return rightComponent; 424: } 425: 426: /** 427: * This method returns the location of the divider. This method is passed to 428: * the UI. 429: * 430: * @return The location of the divider. 431: */ 432: public int getDividerLocation() 433: { 434: if (ui != null) 435: return ((SplitPaneUI) ui).getDividerLocation(this); 436: else 437: return -1; 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: StringBuffer sb = new StringBuffer(); 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 DOCUMENT ME! 703: */ 704: public void setDividerLocation(double proportionalLocation) 705: { 706: if (proportionalLocation > 1 || proportionalLocation < 0) 707: throw new IllegalArgumentException 708: ("proportion has to be between 0 and 1."); 709: 710: int max = (orientation == HORIZONTAL_SPLIT) ? getWidth() : getHeight(); 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: if (ui != null && location != getDividerLocation()) 724: { 725: int oldLocation = getDividerLocation(); 726: if (location < 0) 727: ((SplitPaneUI) ui).resetToPreferredSizes(this); 728: else 729: ((SplitPaneUI) ui).setDividerLocation(this, location); 730: 731: firePropertyChange(DIVIDER_LOCATION_PROPERTY, oldLocation, 732: getDividerLocation()); 733: } 734: } 735: 736: /** 737: * This method sets the size of the divider. 738: * 739: * @param newSize The size of the divider. 740: */ 741: public void setDividerSize(int newSize) 742: { 743: clientDividerSizeSet = true; 744: if (newSize != dividerSize) 745: { 746: int oldSize = dividerSize; 747: dividerSize = newSize; 748: firePropertyChange(DIVIDER_SIZE_PROPERTY, oldSize, dividerSize); 749: } 750: } 751: 752: // This doesn't appear to do anything when set from user side. 753: // so it probably is only used from the UI side to change the 754: // lastDividerLocation var. 755: 756: /** 757: * This method sets the last location of the divider. 758: * 759: * @param newLastLocation The last location of the divider. 760: */ 761: public void setLastDividerLocation(int newLastLocation) 762: { 763: if (newLastLocation != lastDividerLocation) 764: { 765: int oldValue = lastDividerLocation; 766: lastDividerLocation = newLastLocation; 767: firePropertyChange(LAST_DIVIDER_LOCATION_PROPERTY, oldValue, 768: lastDividerLocation); 769: } 770: } 771: 772: /** 773: * This method sets the left component. 774: * 775: * @param comp The left component. 776: */ 777: public void setLeftComponent(Component comp) 778: { 779: if (comp != null) 780: add(comp, LEFT); 781: else 782: remove (leftComponent); 783: } 784: 785: /** 786: * This method sets whether the divider has one touch expandable buttons. 787: * The one touch expandable buttons can expand the size of either component 788: * to the maximum allowed size. 789: * 790: * @param newValue Whether the divider will have one touch expandable 791: * buttons. 792: */ 793: public void setOneTouchExpandable(boolean newValue) 794: { 795: clientOneTouchExpandableSet = true; 796: if (newValue != oneTouchExpandable) 797: { 798: boolean oldValue = oneTouchExpandable; 799: oneTouchExpandable = newValue; 800: firePropertyChange(ONE_TOUCH_EXPANDABLE_PROPERTY, oldValue, 801: oneTouchExpandable); 802: } 803: } 804: 805: /** 806: * Sets the orientation for the <code>JSplitPane</code> and sends a 807: * {@link PropertyChangeEvent} (with the property name 808: * {@link #ORIENTATION_PROPERTY}) to all registered listeners. 809: * 810: * @param orientation the orientation (either {@link #HORIZONTAL_SPLIT} 811: * or {@link #VERTICAL_SPLIT}). 812: * 813: * @throws IllegalArgumentException if <code>orientation</code> is not one of 814: * the listed values. 815: */ 816: public void setOrientation(int orientation) 817: { 818: if (orientation != HORIZONTAL_SPLIT && orientation != VERTICAL_SPLIT) 819: throw new IllegalArgumentException 820: ("orientation must be one of VERTICAL_SPLIT, HORIZONTAL_SPLIT"); 821: if (orientation != this.orientation) 822: { 823: int oldOrientation = this.orientation; 824: this.orientation = orientation; 825: firePropertyChange(ORIENTATION_PROPERTY, oldOrientation, 826: this.orientation); 827: } 828: } 829: 830: /** 831: * This method determines how extra space will be distributed among the left 832: * and right components. A value of 0 will allocate all extra space to the 833: * right component. A value of 1 indicates that all extra space will go to 834: * the left component. A value in between 1 and 0 will split the space 835: * accordingly. 836: * 837: * @param value The resize weight. 838: */ 839: public void setResizeWeight(double value) 840: { 841: if (value < 0.0 || value > 1.0) 842: throw new IllegalArgumentException("Value outside permitted range."); 843: if (this.resizeWeight != value) 844: { 845: double old = resizeWeight; 846: resizeWeight = value; 847: firePropertyChange(RESIZE_WEIGHT_PROPERTY, old, value); 848: } 849: } 850: 851: /** 852: * This method sets the right component. 853: * 854: * @param comp The right component. 855: */ 856: public void setRightComponent(Component comp) 857: { 858: if (comp != null) 859: add(comp, RIGHT); 860: else 861: remove (rightComponent); 862: } 863: 864: /** 865: * This method sets the top component. 866: * 867: * @param comp The top component. 868: */ 869: public void setTopComponent(Component comp) 870: { 871: if (comp != null) 872: add(comp, TOP); 873: else 874: add(new JButton("left button"), TOP); 875: } 876: 877: /** 878: * This method sets the UI used by the JSplitPane. 879: * 880: * @param ui The UI to use. 881: */ 882: public void setUI(SplitPaneUI ui) 883: { 884: super.setUI(ui); 885: } 886: 887: /** 888: * This method resets the UI to the one specified by the current Look and 889: * Feel. 890: */ 891: public void updateUI() 892: { 893: setUI((SplitPaneUI) UIManager.getUI(this)); 894: } 895: 896: /** 897: * This method returns a string identifier to determine which UI class it 898: * needs. 899: * 900: * @return A string that identifies it's UI class. 901: */ 902: public String getUIClassID() 903: { 904: return "SplitPaneUI"; 905: } 906: 907: /** 908: * Helper method for 909: * {@link LookAndFeel#installProperty(JComponent, String, Object)}. 910: * 911: * @param propertyName the name of the property 912: * @param value the value of the property 913: * 914: * @throws IllegalArgumentException if the specified property cannot be set 915: * by this method 916: * @throws ClassCastException if the property value does not match the 917: * property type 918: * @throws NullPointerException if <code>c</code> or 919: * <code>propertyValue</code> is <code>null</code> 920: */ 921: void setUIProperty(String propertyName, Object value) 922: { 923: if (propertyName.equals("dividerSize")) 924: { 925: if (! clientDividerSizeSet) 926: { 927: setDividerSize(((Integer) value).intValue()); 928: clientDividerSizeSet = false; 929: } 930: } 931: else if (propertyName.equals("oneTouchExpandable")) 932: { 933: if (! clientOneTouchExpandableSet) 934: { 935: setOneTouchExpandable(((Boolean) value).booleanValue()); 936: clientOneTouchExpandableSet = false; 937: } 938: } 939: else 940: { 941: super.setUIProperty(propertyName, value); 942: } 943: } 944: }
GNU Classpath (0.91) |