< prev index next >

src/java.desktop/share/classes/java/awt/Component.java

Print this page




2685      * replaced by {@code getPreferredSize()}.
2686      */
2687     @Deprecated
2688     public Dimension preferredSize() {
2689         /* Avoid grabbing the lock if a reasonable cached size value
2690          * is available.
2691          */
2692         Dimension dim = prefSize;
2693         if (dim == null || !(isPreferredSizeSet() || isValid())) {
2694             synchronized (getTreeLock()) {
2695                 prefSize = (peer != null) ?
2696                     peer.getPreferredSize() :
2697                     getMinimumSize();
2698                 dim = prefSize;
2699             }
2700         }
2701         return new Dimension(dim);
2702     }
2703 
2704     /**
2705      * Sets the minimum size of this component to a constant
2706      * value.  Subsequent calls to {@code getMinimumSize} will always
2707      * return this value.  Setting the minimum size to {@code null}
2708      * restores the default behavior.

2709      *
2710      * @param minimumSize the new minimum size of this component
2711      * @see #getMinimumSize
2712      * @see #isMinimumSizeSet
2713      * @since 1.5
2714      */
2715     public void setMinimumSize(Dimension minimumSize) {
2716         Dimension old;
2717         // If the minimum size was set, use it as the old value, otherwise
2718         // use null to indicate we didn't previously have a set minimum
2719         // size.
2720         if (minSizeSet) {
2721             old = this.minSize;
2722         }
2723         else {
2724             old = null;
2725         }
2726         this.minSize = minimumSize;
2727         minSizeSet = (minimumSize != null);
2728         firePropertyChange("minimumSize", old, minimumSize);












2729     }
2730 
2731     /**
2732      * Returns whether or not {@code setMinimumSize} has been
2733      * invoked with a non-null value.
2734      *
2735      * @return true if {@code setMinimumSize} has been invoked with a
2736      *              non-null value.
2737      * @since 1.5
2738      */
2739     public boolean isMinimumSizeSet() {
2740         return minSizeSet;
2741     }
2742 
2743     /**
2744      * Gets the minimum size of this component.
2745      * @return a dimension object indicating this component's minimum size
2746      * @see #getPreferredSize
2747      * @see LayoutManager
2748      */


2758      * replaced by {@code getMinimumSize()}.
2759      */
2760     @Deprecated
2761     public Dimension minimumSize() {
2762         /* Avoid grabbing the lock if a reasonable cached size value
2763          * is available.
2764          */
2765         Dimension dim = minSize;
2766         if (dim == null || !(isMinimumSizeSet() || isValid())) {
2767             synchronized (getTreeLock()) {
2768                 minSize = (peer != null) ?
2769                     peer.getMinimumSize() :
2770                     size();
2771                 dim = minSize;
2772             }
2773         }
2774         return new Dimension(dim);
2775     }
2776 
2777     /**
2778      * Sets the maximum size of this component to a constant
2779      * value.  Subsequent calls to {@code getMaximumSize} will always
2780      * return this value.  Setting the maximum size to {@code null}
2781      * restores the default behavior.

2782      *
2783      * @param maximumSize a {@code Dimension} containing the
2784      *          desired maximum allowable size
2785      * @see #getMaximumSize
2786      * @see #isMaximumSizeSet
2787      * @since 1.5
2788      */
2789     public void setMaximumSize(Dimension maximumSize) {
2790         // If the maximum size was set, use it as the old value, otherwise
2791         // use null to indicate we didn't previously have a set maximum
2792         // size.
2793         Dimension old;
2794         if (maxSizeSet) {
2795             old = this.maxSize;
2796         }
2797         else {
2798             old = null;









2799         }
2800         this.maxSize = maximumSize;
2801         maxSizeSet = (maximumSize != null);
2802         firePropertyChange("maximumSize", old, maximumSize);
2803     }
2804 
2805     /**
2806      * Returns true if the maximum size has been set to a non-{@code null}
2807      * value otherwise returns false.
2808      *
2809      * @return true if {@code maximumSize} is non-{@code null},
2810      *          false otherwise
2811      * @since 1.5
2812      */
2813     public boolean isMaximumSizeSet() {
2814         return maxSizeSet;
2815     }
2816 
2817     /**
2818      * Gets the maximum size of this component.




2685      * replaced by {@code getPreferredSize()}.
2686      */
2687     @Deprecated
2688     public Dimension preferredSize() {
2689         /* Avoid grabbing the lock if a reasonable cached size value
2690          * is available.
2691          */
2692         Dimension dim = prefSize;
2693         if (dim == null || !(isPreferredSizeSet() || isValid())) {
2694             synchronized (getTreeLock()) {
2695                 prefSize = (peer != null) ?
2696                     peer.getPreferredSize() :
2697                     getMinimumSize();
2698                 dim = prefSize;
2699             }
2700         }
2701         return new Dimension(dim);
2702     }
2703 
2704     /**
2705      * Sets the minimum size of this component to a constant value.
2706      * If the value is greater than maximum size, then maximum size is also
2707      * set to this value. Subsequent calls to {@code getMinimumSize} will 
2708      * always return this value.
2709      * Setting the minimum size to {@code null} restores the default behavior.
2710      *
2711      * @param minimumSize the new minimum size of this component
2712      * @see #getMinimumSize
2713      * @see #isMinimumSizeSet
2714      * @since 1.5
2715      */
2716     public void setMinimumSize(Dimension minimumSize) {
2717         Dimension old;
2718         // If the minimum size was set, use it as the old value, otherwise
2719         // use null to indicate we didn't previously have a set minimum
2720         // size.
2721         if (minSizeSet) {
2722             old = this.minSize;
2723         } else {

2724             old = null;
2725         }
2726         this.minSize = minimumSize;
2727         minSizeSet = (minimumSize != null);
2728         firePropertyChange("minimumSize", old, minimumSize);
2729         if (isMaximumSizeSet() && minimumSize != null) {
2730             Dimension lMaxSize = getMaximumSize();
2731             if (lMaxSize.width < minimumSize.width) {
2732                 lMaxSize.width = minimumSize.width;
2733             }
2734             if ( lMaxSize.height < minimumSize.height) {
2735                 lMaxSize.height = minimumSize.height;
2736             }
2737             if (!maxSize.equals(lMaxSize)) {
2738                 setMaximumSize(lMaxSize);
2739             }
2740         }
2741     }
2742 
2743     /**
2744      * Returns whether or not {@code setMinimumSize} has been
2745      * invoked with a non-null value.
2746      *
2747      * @return true if {@code setMinimumSize} has been invoked with a
2748      *              non-null value.
2749      * @since 1.5
2750      */
2751     public boolean isMinimumSizeSet() {
2752         return minSizeSet;
2753     }
2754 
2755     /**
2756      * Gets the minimum size of this component.
2757      * @return a dimension object indicating this component's minimum size
2758      * @see #getPreferredSize
2759      * @see LayoutManager
2760      */


2770      * replaced by {@code getMinimumSize()}.
2771      */
2772     @Deprecated
2773     public Dimension minimumSize() {
2774         /* Avoid grabbing the lock if a reasonable cached size value
2775          * is available.
2776          */
2777         Dimension dim = minSize;
2778         if (dim == null || !(isMinimumSizeSet() || isValid())) {
2779             synchronized (getTreeLock()) {
2780                 minSize = (peer != null) ?
2781                     peer.getMinimumSize() :
2782                     size();
2783                 dim = minSize;
2784             }
2785         }
2786         return new Dimension(dim);
2787     }
2788 
2789     /**
2790      * Sets the maximum size of this component to a constant value.
2791      * If the value is smaller than minimum size, then maximum size is
2792      * set to minimum size. Subsequent calls to {@code getMaximumSize}
2793      * will return this or corrected value.
2794      * Setting the maximum size to {@code null} restores the default behavior.
2795      *
2796      * @param maximumSize a {@code Dimension} containing the
2797      *          desired maximum allowable size
2798      * @see #getMaximumSize
2799      * @see #isMaximumSizeSet
2800      * @since 1.5
2801      */
2802     public void setMaximumSize(Dimension maximumSize) {
2803         // If the maximum size was set, use it as the old value, otherwise
2804         // use null to indicate we didn't previously have a set maximum
2805         // size.
2806         Dimension old;
2807         if (maxSizeSet) {
2808             old = this.maxSize;
2809         } else {

2810             old = null;
2811         }
2812         if (isMinimumSizeSet() && maximumSize != null) {
2813             Dimension lMinSize = getMinimumSize();
2814             if (maximumSize.width < lMinSize.width) {
2815                 maximumSize.width = lMinSize.width;
2816             }
2817             if (maximumSize.height < lMinSize.height) {
2818                 maximumSize.height = lMinSize.height;
2819             }
2820         }
2821         this.maxSize = maximumSize;
2822         maxSizeSet = (maximumSize != null);
2823         firePropertyChange("maximumSize", old, maximumSize);
2824     }
2825 
2826     /**
2827      * Returns true if the maximum size has been set to a non-{@code null}
2828      * value otherwise returns false.
2829      *
2830      * @return true if {@code maximumSize} is non-{@code null},
2831      *          false otherwise
2832      * @since 1.5
2833      */
2834     public boolean isMaximumSizeSet() {
2835         return maxSizeSet;
2836     }
2837 
2838     /**
2839      * Gets the maximum size of this component.


< prev index next >