1 /* 2 * Copyright (c) 1997, 1999, 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 /* 27 * (C) Copyright Taligent, Inc. 1996 - 1997, All Rights Reserved 28 * (C) Copyright IBM Corp. 1996 - 1998, All Rights Reserved 29 * 30 * The original version of this source code and documentation is 31 * copyrighted and owned by Taligent, Inc., a wholly-owned subsidiary 32 * of IBM. These materials are provided under terms of a License 33 * Agreement between Taligent and Sun. This technology is protected 34 * by multiple US and International patents. 35 * 36 * This notice and attribution to Taligent may not be removed. 37 * Taligent is a registered trademark of Taligent, Inc. 38 */ 39 40 package java.awt.font; 41 42 /** 43 * The {@code GlyphJustificationInfo} class represents information 44 * about the justification properties of a glyph. A glyph is the visual 45 * representation of one or more characters. Many different glyphs can 46 * be used to represent a single character or combination of characters. 47 * The four justification properties represented by 48 * {@code GlyphJustificationInfo} are weight, priority, absorb and 49 * limit. 50 * <p> 51 * Weight is the overall 'weight' of the glyph in the line. Generally it is 52 * proportional to the size of the font. Glyphs with larger weight are 53 * allocated a correspondingly larger amount of the change in space. 54 * <p> 55 * Priority determines the justification phase in which this glyph is used. 56 * All glyphs of the same priority are examined before glyphs of the next 57 * priority. If all the change in space can be allocated to these glyphs 58 * without exceeding their limits, then glyphs of the next priority are not 59 * examined. There are four priorities, kashida, whitespace, interchar, 60 * and none. KASHIDA is the first priority examined. NONE is the last 61 * priority examined. 62 * <p> 63 * Absorb determines whether a glyph absorbs all change in space. Within a 64 * given priority, some glyphs may absorb all the change in space. If any of 65 * these glyphs are present, no glyphs of later priority are examined. 66 * <p> 67 * Limit determines the maximum or minimum amount by which the glyph can 68 * change. Left and right sides of the glyph can have different limits. 69 * <p> 70 * Each {@code GlyphJustificationInfo} represents two sets of 71 * metrics, which are <i>growing</i> and <i>shrinking</i>. Growing 72 * metrics are used when the glyphs on a line are to be 73 * spread apart to fit a larger width. Shrinking metrics are used when 74 * the glyphs are to be moved together to fit a smaller width. 75 */ 76 77 public final class GlyphJustificationInfo { 78 79 /** 80 * Constructs information about the justification properties of a 81 * glyph. 82 * @param weight the weight of this glyph when allocating space. Must be non-negative. 83 * @param growAbsorb if {@code true} this glyph absorbs 84 * all extra space at this priority and lower priority levels when it 85 * grows 86 * @param growPriority the priority level of this glyph when it 87 * grows 88 * @param growLeftLimit the maximum amount by which the left side of this 89 * glyph can grow. Must be non-negative. 90 * @param growRightLimit the maximum amount by which the right side of this 91 * glyph can grow. Must be non-negative. 92 * @param shrinkAbsorb if {@code true}, this glyph absorbs all 93 * remaining shrinkage at this and lower priority levels when it 94 * shrinks 95 * @param shrinkPriority the priority level of this glyph when 96 * it shrinks 97 * @param shrinkLeftLimit the maximum amount by which the left side of this 98 * glyph can shrink. Must be non-negative. 99 * @param shrinkRightLimit the maximum amount by which the right side 100 * of this glyph can shrink. Must be non-negative. 101 */ 102 public GlyphJustificationInfo(float weight, 103 boolean growAbsorb, 104 int growPriority, 105 float growLeftLimit, 106 float growRightLimit, 107 boolean shrinkAbsorb, 108 int shrinkPriority, 109 float shrinkLeftLimit, 110 float shrinkRightLimit) 111 { 112 if (weight < 0) { 113 throw new IllegalArgumentException("weight is negative"); 114 } 115 116 if (!priorityIsValid(growPriority)) { 117 throw new IllegalArgumentException("Invalid grow priority"); 118 } 119 if (growLeftLimit < 0) { 120 throw new IllegalArgumentException("growLeftLimit is negative"); 121 } 122 if (growRightLimit < 0) { 123 throw new IllegalArgumentException("growRightLimit is negative"); 124 } 125 126 if (!priorityIsValid(shrinkPriority)) { 127 throw new IllegalArgumentException("Invalid shrink priority"); 128 } 129 if (shrinkLeftLimit < 0) { 130 throw new IllegalArgumentException("shrinkLeftLimit is negative"); 131 } 132 if (shrinkRightLimit < 0) { 133 throw new IllegalArgumentException("shrinkRightLimit is negative"); 134 } 135 136 this.weight = weight; 137 this.growAbsorb = growAbsorb; 138 this.growPriority = growPriority; 139 this.growLeftLimit = growLeftLimit; 140 this.growRightLimit = growRightLimit; 141 this.shrinkAbsorb = shrinkAbsorb; 142 this.shrinkPriority = shrinkPriority; 143 this.shrinkLeftLimit = shrinkLeftLimit; 144 this.shrinkRightLimit = shrinkRightLimit; 145 } 146 147 private static boolean priorityIsValid(int priority) { 148 149 return priority >= PRIORITY_KASHIDA && priority <= PRIORITY_NONE; 150 } 151 152 /** The highest justification priority. */ 153 public static final int PRIORITY_KASHIDA = 0; 154 155 /** The second highest justification priority. */ 156 public static final int PRIORITY_WHITESPACE = 1; 157 158 /** The second lowest justification priority. */ 159 public static final int PRIORITY_INTERCHAR = 2; 160 161 /** The lowest justification priority. */ 162 public static final int PRIORITY_NONE = 3; 163 164 /** 165 * The weight of this glyph. 166 */ 167 public final float weight; 168 169 /** 170 * The priority level of this glyph as it is growing. 171 */ 172 public final int growPriority; 173 174 /** 175 * If {@code true}, this glyph absorbs all extra 176 * space at this and lower priority levels when it grows. 177 */ 178 public final boolean growAbsorb; 179 180 /** 181 * The maximum amount by which the left side of this glyph can grow. 182 */ 183 public final float growLeftLimit; 184 185 /** 186 * The maximum amount by which the right side of this glyph can grow. 187 */ 188 public final float growRightLimit; 189 190 /** 191 * The priority level of this glyph as it is shrinking. 192 */ 193 public final int shrinkPriority; 194 195 /** 196 * If {@code true},this glyph absorbs all remaining shrinkage at 197 * this and lower priority levels as it shrinks. 198 */ 199 public final boolean shrinkAbsorb; 200 201 /** 202 * The maximum amount by which the left side of this glyph can shrink 203 * (a positive number). 204 */ 205 public final float shrinkLeftLimit; 206 207 /** 208 * The maximum amount by which the right side of this glyph can shrink 209 * (a positive number). 210 */ 211 public final float shrinkRightLimit; 212 }