1 /* 2 * Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 package javafx.scene.layout; 27 28 import static javafx.scene.layout.Region.USE_COMPUTED_SIZE; 29 import static javafx.scene.layout.Region.USE_PREF_SIZE; 30 import javafx.beans.property.BooleanProperty; 31 import javafx.beans.property.BooleanPropertyBase; 32 import javafx.beans.property.DoubleProperty; 33 import javafx.beans.property.DoublePropertyBase; 34 import javafx.beans.property.ObjectProperty; 35 import javafx.beans.property.ObjectPropertyBase; 36 import javafx.geometry.VPos; 37 38 39 /** 40 * Defines optional layout constraints for a row in a {@link GridPane}. 41 * If a RowConstraints object is added for a row in a gridpane, the gridpane 42 * will use those constraint values when computing the row's height and layout. 43 * <p> 44 * For example, to create a GridPane with 10 rows 50 pixels tall: 45 * <pre><code> 46 * GridPane gridpane = new GridPane(); 47 * for (int i = 0; i < 10; i++) { 48 * RowConstraints row = new RowConstraints(50); 49 * gridpane.getRowConstraints().add(row); 50 * } 51 * </code></pre> 52 * Or, to create a GridPane where rows take 25%, 50%, 25% of its width: 53 * <pre><code> 54 * GridPane gridpane = new GridPane(); 55 * RowConstraints row1 = new RowConstraints(); 56 * row1.setPercentWidth(25); 57 * RowConstraints row2 = new RowConstraints(); 58 * row2.setPercentWidth(50); 59 * RowConstraints row3 = new RowConstraints(); 60 * row3.setPercentWidth(25); 61 * gridpane.getRowConstraints().addAll(row1,row2,row3); 62 * </code></pre> 63 * 64 * Note that adding an empty RowConstraints object has the effect of not setting 65 * any constraints, leaving the GridPane to compute the row's layout based 66 * solely on its content's size preferences and constraints. 67 * 68 * @since JavaFX 2.0 69 */ 70 public class RowConstraints extends ConstraintsBase { 71 72 /** 73 * Creates a row constraints object with no properties set. 74 */ 75 public RowConstraints() { 76 super(); 77 } 78 79 /** 80 * Creates a row constraint object with a fixed height. 81 * This is a convenience for setting the preferred height constraint to the 82 * fixed value and the minHeight and maxHeight constraints to the USE_PREF_SIZE 83 * flag to ensure the row is always that height. 84 * 85 * @param height the height of the row 86 */ 87 public RowConstraints(double height) { 88 this(); 89 setMinHeight(USE_PREF_SIZE); 90 setPrefHeight(height); 91 setMaxHeight(USE_PREF_SIZE); 92 } 93 94 /** 95 * Creates a row constraint object with a fixed size range. 96 * This is a convenience for setting the minimum, preferred, and maximum 97 * height constraints. 98 * 99 */ 100 public RowConstraints(double minHeight, double prefHeight, double maxHeight) { 101 this(); 102 setMinHeight(minHeight); 103 setPrefHeight(prefHeight); 104 setMaxHeight(maxHeight); 105 } 106 107 /** 108 * Creates a row constraint object with a fixed size range, vertical 109 * grow priority, vertical alignment, and vertical fill behavior. 110 * 111 */ 112 public RowConstraints(double minHeight, double prefHeight, double maxHeight, Priority vgrow, VPos valignment, boolean fillHeight) { 113 this(minHeight, prefHeight, maxHeight); 114 setVgrow(vgrow); 115 setValignment(valignment); 116 setFillHeight(fillHeight); 117 } 118 119 /** 120 * The minimum height for the row. 121 * This property is ignored if percentHeight is set. 122 * <p> 123 * The default value is USE_COMPUTED_SIZE, which means the minimum height 124 * will be computed to be the largest minimum height of the row's content. 125 */ 126 private DoubleProperty minHeight; 127 128 public final void setMinHeight(double value) { 129 minHeightProperty().set(value); 130 } 131 132 public final double getMinHeight() { 133 return minHeight == null ? USE_COMPUTED_SIZE : minHeight.get(); 134 } 135 136 public final DoubleProperty minHeightProperty() { 137 if (minHeight == null) { 138 minHeight = new DoublePropertyBase(USE_COMPUTED_SIZE) { 139 140 @Override 141 protected void invalidated() { 142 requestLayout(); 143 } 144 145 @Override 146 public Object getBean() { 147 return RowConstraints.this; 148 } 149 150 @Override 151 public String getName() { 152 return "minHeight"; 153 } 154 }; 155 } 156 return minHeight; 157 } 158 159 /** 160 * The preferred height for the row. 161 * This property is ignored if percentHeight is set. 162 * <p> 163 * The default value is USE_COMPUTED_SIZE, which means the preferred height 164 * will be computed to be the largest preferred height of the row's content. 165 */ 166 private DoubleProperty prefHeight; 167 168 public final void setPrefHeight(double value) { 169 prefHeightProperty().set(value); 170 } 171 172 public final double getPrefHeight() { 173 return prefHeight == null ? USE_COMPUTED_SIZE : prefHeight.get(); 174 } 175 176 public final DoubleProperty prefHeightProperty() { 177 if (prefHeight == null) { 178 prefHeight = new DoublePropertyBase(USE_COMPUTED_SIZE) { 179 180 @Override 181 protected void invalidated() { 182 requestLayout(); 183 } 184 185 @Override 186 public Object getBean() { 187 return RowConstraints.this; 188 } 189 190 @Override 191 public String getName() { 192 return "prefHeight"; 193 } 194 }; 195 } 196 return prefHeight; 197 } 198 199 /** 200 * The maximum height for the row. 201 * This property is ignored if percentHeight is set. 202 * <p> 203 * The default value is USE_COMPUTED_SIZE, which means the maximum height 204 * will be computed to be the smallest maximum height of the row's content. 205 */ 206 private DoubleProperty maxHeight; 207 208 public final void setMaxHeight(double value) { 209 maxHeightProperty().set(value); 210 } 211 212 public final double getMaxHeight() { 213 return maxHeight == null ? USE_COMPUTED_SIZE : maxHeight.get(); 214 } 215 216 public final DoubleProperty maxHeightProperty() { 217 if (maxHeight == null) { 218 maxHeight = new DoublePropertyBase(USE_COMPUTED_SIZE) { 219 220 @Override 221 protected void invalidated() { 222 requestLayout(); 223 } 224 225 @Override 226 public Object getBean() { 227 return RowConstraints.this; 228 } 229 230 @Override 231 public String getName() { 232 return "maxHeight"; 233 } 234 }; 235 } 236 return maxHeight; 237 } 238 239 /** 240 * The height percentage of the row. If set to a value greater than 0, the 241 * row will be resized to that percentage of the available gridpane height and 242 * the other size constraints (minHeight, prefHeight, maxHeight, vgrow) will 243 * be ignored. 244 * 245 * The default value is -1, which means the percentage will be ignored. 246 */ 247 private DoubleProperty percentHeight; 248 249 public final void setPercentHeight(double value) { 250 percentHeightProperty().set(value); 251 } 252 253 public final double getPercentHeight() { 254 return percentHeight == null ? -1 : percentHeight.get(); 255 } 256 257 public final DoubleProperty percentHeightProperty() { 258 if (percentHeight == null) { 259 percentHeight = new DoublePropertyBase(-1) { 260 261 @Override 262 protected void invalidated() { 263 requestLayout(); 264 } 265 266 @Override 267 public Object getBean() { 268 return RowConstraints.this; 269 } 270 271 @Override 272 public String getName() { 273 return "percentHeight"; 274 } 275 }; 276 } 277 return percentHeight; 278 } 279 280 /** 281 * The vertical grow priority for the row. If set, the gridpane will 282 * use this priority to determine whether the row should be given any 283 * additional height if the gridpane is resized larger than its preferred height. 284 * This property is ignored if percentHeight is set. 285 * <p> 286 * This default value is null, which means that the row's grow priority 287 * will be derived from largest grow priority set on a content node. 288 */ 289 private ObjectProperty<Priority> vgrow; 290 291 public final void setVgrow(Priority value) { 292 vgrowProperty().set(value); 293 } 294 295 public final Priority getVgrow() { 296 return vgrow == null ? null : vgrow.get(); 297 } 298 299 public final ObjectProperty<Priority> vgrowProperty() { 300 if (vgrow == null) { 301 vgrow = new ObjectPropertyBase<Priority>() { 302 303 @Override 304 protected void invalidated() { 305 requestLayout(); 306 } 307 308 @Override 309 public Object getBean() { 310 return RowConstraints.this; 311 } 312 313 @Override 314 public String getName() { 315 return "vgrow"; 316 } 317 }; 318 } 319 return vgrow; 320 } 321 322 /** 323 * The vertical alignment for the row. If set, will be the default 324 * vertical alignment for nodes contained within the row. 325 * If this property is set to VPos.BASELINE, then the fillHeight property 326 * will be ignored and nodes will always be resized to their preferred heights. 327 */ 328 private ObjectProperty<VPos> valignment; 329 330 public final void setValignment(VPos value) { 331 valignmentProperty().set(value); 332 } 333 334 public final VPos getValignment() { 335 return valignment == null ? null : valignment.get(); 336 } 337 338 public final ObjectProperty<VPos> valignmentProperty() { 339 if (valignment == null) { 340 valignment = new ObjectPropertyBase<VPos>() { 341 342 @Override 343 protected void invalidated() { 344 requestLayout(); 345 } 346 347 @Override 348 public Object getBean() { 349 return RowConstraints.this; 350 } 351 352 @Override 353 public String getName() { 354 return "valignment"; 355 } 356 }; 357 } 358 return valignment; 359 } 360 361 /** 362 * The vertical fill policy for the row. The gridpane will 363 * use this property to determine whether nodes contained within the row 364 * should be expanded to fill the row's height or kept to their preferred heights. 365 * <p> 366 * The default value is true. 367 */ 368 private BooleanProperty fillHeight; 369 370 public final void setFillHeight(boolean value) { 371 fillHeightProperty().set(value); 372 } 373 374 public final boolean isFillHeight() { 375 return fillHeight == null ? true : fillHeight.get(); 376 } 377 378 public final BooleanProperty fillHeightProperty() { 379 if (fillHeight == null) { 380 fillHeight = new BooleanPropertyBase(true) { 381 @Override 382 protected void invalidated() { 383 requestLayout(); 384 } 385 386 @Override 387 public Object getBean() { 388 return RowConstraints.this; 389 } 390 391 @Override 392 public String getName() { 393 return "fillHeight"; 394 } 395 }; 396 } 397 return fillHeight; 398 } 399 400 /** 401 * Returns a string representation of this {@code RowConstraints} object. 402 * @return a string representation of this {@code RowConstraints} object. 403 */ 404 @Override public String toString() { 405 return "RowConstraints percentHeight="+getPercentHeight()+ 406 " minHeight="+getMinHeight()+ 407 " prefHeight="+getPrefHeight()+ 408 " maxHeight="+getMaxHeight()+ 409 " vgrow="+getVgrow()+ 410 " fillHeight="+isFillHeight()+ 411 " valignment="+getValignment(); 412 } 413 }