001: /*
002: * Copyright (c) 2002-2007 JGoodies Karsten Lentzsch. All Rights Reserved.
003: *
004: * Redistribution and use in source and binary forms, with or without
005: * modification, are permitted provided that the following conditions are met:
006: *
007: * o Redistributions of source code must retain the above copyright notice,
008: * this list of conditions and the following disclaimer.
009: *
010: * o Redistributions in binary form must reproduce the above copyright notice,
011: * this list of conditions and the following disclaimer in the documentation
012: * and/or other materials provided with the distribution.
013: *
014: * o Neither the name of JGoodies Karsten Lentzsch nor the names of
015: * its contributors may be used to endorse or promote products derived
016: * from this software without specific prior written permission.
017: *
018: * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
019: * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
020: * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
021: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
022: * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
023: * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
024: * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
025: * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
026: * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
027: * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
028: * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
029: */
030:
031: package com.jgoodies.forms.layout;
032:
033: import java.awt.Container;
034: import java.io.Serializable;
035: import java.util.List;
036:
037: /**
038: * Describes sizes that provide lower and upper bounds
039: * as used by the JGoodies FormLayout.
040: *
041: * @author Karsten Lentzsch
042: * @version $Revision: 1.9 $
043: *
044: * @see Sizes
045: * @see ConstantSize
046: */
047: public final class BoundedSize implements Size, Serializable {
048:
049: /**
050: * Holds the base size.
051: */
052: private final Size basis;
053:
054: /**
055: * Holds an optional lower bound.
056: */
057: private Size lowerBound;
058:
059: /**
060: * Holds an optional upper bound.
061: */
062: private Size upperBound;
063:
064: // Instance Creation ****************************************************
065:
066: /**
067: * Constructs a BoundedSize for the given basis using the
068: * specified lower and upper bounds.<p>
069: *
070: * TODO: Consider throwing an IllegalArgumentException,
071: * if the lower bound and upper bound are both <code>null</code>.
072: *
073: * @param basis the base size
074: * @param lowerBound the lower bound size
075: * @param upperBound the upper bound size
076: *
077: * @throws NullPointerException if the basis is null
078: *
079: * @since 1.1
080: */
081: public BoundedSize(Size basis, Size lowerBound, Size upperBound) {
082: if (basis == null)
083: throw new NullPointerException(
084: "The basis of a bounded size must not be null.");
085: this .basis = basis;
086: this .lowerBound = lowerBound;
087: this .upperBound = upperBound;
088: }
089:
090: // Accessors ************************************************************
091:
092: /**
093: * Returns the base size, which is not-<code>null</code>.
094: *
095: * @return the base size
096: *
097: * @since 1.1
098: */
099: public Size getBasis() {
100: return basis;
101: }
102:
103: /**
104: * Returns the optional lower bound.
105: *
106: * @return the optional lower bound
107: *
108: * @since 1.1
109: */
110: public Size getLowerBound() {
111: return lowerBound;
112: }
113:
114: /**
115: * Returns the optional upper bound.
116: *
117: * @return the optional upper bound
118: *
119: * @since 1.1
120: */
121: public Size getUpperBound() {
122: return upperBound;
123: }
124:
125: // Implementation of the Size Interface *********************************
126:
127: /**
128: * Returns this size as pixel size. Neither requires the component
129: * list nor the specified measures. Honors the lower and upper bound.<p>
130: *
131: * Invoked by <code>FormSpec</code> to determine the size of a column or
132: * row.
133: *
134: * @param container the layout container
135: * @param components the list of components to measure
136: * @param minMeasure the measure used to determine the minimum size
137: * @param prefMeasure the measure used to determine the preferred size
138: * @param defaultMeasure the measure used to determine the default size
139: * @return the maximum size in pixels
140: * @see FormSpec#maximumSize(Container, List, FormLayout.Measure, FormLayout.Measure, FormLayout.Measure)
141: */
142: public int maximumSize(Container container, List components,
143: FormLayout.Measure minMeasure,
144: FormLayout.Measure prefMeasure,
145: FormLayout.Measure defaultMeasure) {
146: int size = basis.maximumSize(container, components, minMeasure,
147: prefMeasure, defaultMeasure);
148: if (lowerBound != null) {
149: size = Math.max(size, lowerBound
150: .maximumSize(container, components, minMeasure,
151: prefMeasure, defaultMeasure));
152: }
153: if (upperBound != null) {
154: size = Math.min(size, upperBound
155: .maximumSize(container, components, minMeasure,
156: prefMeasure, defaultMeasure));
157: }
158: return size;
159: }
160:
161: /**
162: * Describes if this Size can be compressed, if container space gets scarce.
163: * Used by the FormLayout size computations in <code>#compressedSizes</code>
164: * to check whether a column or row can be compressed or not.<p>
165: *
166: * BoundedSizes are compressible if the base Size is compressible.
167: *
168: * @return <code>true</code> if and only if the basis is compressible
169: *
170: * @since 1.1
171: */
172: public boolean compressible() {
173: return getBasis().compressible();
174: }
175:
176: // Overriding Object Behavior *******************************************
177:
178: /**
179: * Indicates whether some other BoundedSize is "equal to" this one.
180: *
181: * @param object the object with which to compare
182: * @return <code>true</code> if this object is the same as the object
183: * argument, <code>false</code> otherwise.
184: * @see Object#hashCode()
185: * @see java.util.Hashtable
186: */
187: public boolean equals(Object object) {
188: if (this == object)
189: return true;
190: if (!(object instanceof BoundedSize))
191: return false;
192: BoundedSize size = (BoundedSize) object;
193: return basis.equals(size.basis)
194: && ((lowerBound == null && size.lowerBound == null) || (lowerBound != null && lowerBound
195: .equals(size.lowerBound)))
196: && ((upperBound == null && size.upperBound == null) || (upperBound != null && upperBound
197: .equals(size.upperBound)));
198: }
199:
200: /**
201: * Returns a hash code value for the object. This method is
202: * supported for the benefit of hashtables such as those provided by
203: * <code>java.util.Hashtable</code>.
204: *
205: * @return a hash code value for this object.
206: * @see Object#equals(Object)
207: * @see java.util.Hashtable
208: */
209: public int hashCode() {
210: int hashValue = basis.hashCode();
211: if (lowerBound != null) {
212: hashValue = hashValue * 37 + lowerBound.hashCode();
213: }
214: if (upperBound != null) {
215: hashValue = hashValue * 37 + upperBound.hashCode();
216: }
217: return hashValue;
218: }
219:
220: /**
221: * Returns a string representation of this size object.
222: *
223: * <strong>Note:</strong> The string representation may change
224: * at any time. It is strongly recommended to not use this string
225: * for parsing purposes.
226: *
227: * @return a string representation of the constant size
228: */
229: public String toString() {
230: if (lowerBound != null) {
231: return upperBound == null ? "max(" + basis + ';'
232: + lowerBound + ')' : "max(" + lowerBound + ';'
233: + "min(" + basis + ';' + upperBound + "))";
234: } else if (upperBound != null) {
235: return "min(" + basis + ';' + upperBound + ')';
236: } else {
237: return "bounded(" + basis + ')';
238: }
239: }
240:
241: }
|