| /* |
| * Copyright (c) 1997, 1999, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| /* |
| * (C) Copyright Taligent, Inc. 1996 - 1997, All Rights Reserved |
| * (C) Copyright IBM Corp. 1996 - 1998, All Rights Reserved |
| * |
| * The original version of this source code and documentation is |
| * copyrighted and owned by Taligent, Inc., a wholly-owned subsidiary |
| * of IBM. These materials are provided under terms of a License |
| * Agreement between Taligent and Sun. This technology is protected |
| * by multiple US and International patents. |
| * |
| * This notice and attribution to Taligent may not be removed. |
| * Taligent is a registered trademark of Taligent, Inc. |
| * |
| */ |
| |
| package java.awt.font; |
| |
| /* |
| * one info for each side of each glyph |
| * separate infos for grow and shrink case |
| * !!! this doesn't really need to be a separate class. If we keep it |
| * separate, probably the newJustify code from TextLayout belongs here as well. |
| */ |
| |
| class TextJustifier { |
| private GlyphJustificationInfo[] info; |
| private int start; |
| private int limit; |
| |
| static boolean DEBUG = false; |
| |
| /** |
| * Initialize the justifier with an array of infos corresponding to each |
| * glyph. Start and limit indicate the range of the array to examine. |
| */ |
| TextJustifier(GlyphJustificationInfo[] info, int start, int limit) { |
| this.info = info; |
| this.start = start; |
| this.limit = limit; |
| |
| if (DEBUG) { |
| System.out.println("start: " + start + ", limit: " + limit); |
| for (int i = start; i < limit; i++) { |
| GlyphJustificationInfo gji = info[i]; |
| System.out.println("w: " + gji.weight + ", gp: " + |
| gji.growPriority + ", gll: " + |
| gji.growLeftLimit + ", grl: " + |
| gji.growRightLimit); |
| } |
| } |
| } |
| |
| public static final int MAX_PRIORITY = 3; |
| |
| /** |
| * Return an array of deltas twice as long as the original info array, |
| * indicating the amount by which each side of each glyph should grow |
| * or shrink. |
| * |
| * Delta should be positive to expand the line, and negative to compress it. |
| */ |
| public float[] justify(float delta) { |
| float[] deltas = new float[info.length * 2]; |
| |
| boolean grow = delta > 0; |
| |
| if (DEBUG) |
| System.out.println("delta: " + delta); |
| |
| // make separate passes through glyphs in order of decreasing priority |
| // until justifyDelta is zero or we run out of priorities. |
| int fallbackPriority = -1; |
| for (int p = 0; delta != 0; p++) { |
| /* |
| * special case 'fallback' iteration, set flag and recheck |
| * highest priority |
| */ |
| boolean lastPass = p > MAX_PRIORITY; |
| if (lastPass) |
| p = fallbackPriority; |
| |
| // pass through glyphs, first collecting weights and limits |
| float weight = 0; |
| float gslimit = 0; |
| float absorbweight = 0; |
| for (int i = start; i < limit; i++) { |
| GlyphJustificationInfo gi = info[i]; |
| if ((grow ? gi.growPriority : gi.shrinkPriority) == p) { |
| if (fallbackPriority == -1) { |
| fallbackPriority = p; |
| } |
| |
| if (i != start) { // ignore left of first character |
| weight += gi.weight; |
| if (grow) { |
| gslimit += gi.growLeftLimit; |
| if (gi.growAbsorb) { |
| absorbweight += gi.weight; |
| } |
| } else { |
| gslimit += gi.shrinkLeftLimit; |
| if (gi.shrinkAbsorb) { |
| absorbweight += gi.weight; |
| } |
| } |
| } |
| |
| if (i + 1 != limit) { // ignore right of last character |
| weight += gi.weight; |
| if (grow) { |
| gslimit += gi.growRightLimit; |
| if (gi.growAbsorb) { |
| absorbweight += gi.weight; |
| } |
| } else { |
| gslimit += gi.shrinkRightLimit; |
| if (gi.shrinkAbsorb) { |
| absorbweight += gi.weight; |
| } |
| } |
| } |
| } |
| } |
| |
| // did we hit the limit? |
| if (!grow) { |
| gslimit = -gslimit; // negative for negative deltas |
| } |
| boolean hitLimit = (weight == 0) || (!lastPass && ((delta < 0) == (delta < gslimit))); |
| boolean absorbing = hitLimit && absorbweight > 0; |
| |
| // predivide delta by weight |
| float weightedDelta = delta / weight; // not used if weight == 0 |
| |
| float weightedAbsorb = 0; |
| if (hitLimit && absorbweight > 0) { |
| weightedAbsorb = (delta - gslimit) / absorbweight; |
| } |
| |
| if (DEBUG) { |
| System.out.println("pass: " + p + |
| ", d: " + delta + |
| ", l: " + gslimit + |
| ", w: " + weight + |
| ", aw: " + absorbweight + |
| ", wd: " + weightedDelta + |
| ", wa: " + weightedAbsorb + |
| ", hit: " + (hitLimit ? "y" : "n")); |
| } |
| |
| // now allocate this based on ratio of weight to total weight |
| int n = start * 2; |
| for (int i = start; i < limit; i++) { |
| GlyphJustificationInfo gi = info[i]; |
| if ((grow ? gi.growPriority : gi.shrinkPriority) == p) { |
| if (i != start) { // ignore left |
| float d; |
| if (hitLimit) { |
| // factor in sign |
| d = grow ? gi.growLeftLimit : -gi.shrinkLeftLimit; |
| if (absorbing) { |
| // sign factored in already |
| d += gi.weight * weightedAbsorb; |
| } |
| } else { |
| // sign factored in already |
| d = gi.weight * weightedDelta; |
| } |
| |
| deltas[n] += d; |
| } |
| n++; |
| |
| if (i + 1 != limit) { // ignore right |
| float d; |
| if (hitLimit) { |
| d = grow ? gi.growRightLimit : -gi.shrinkRightLimit; |
| if (absorbing) { |
| d += gi.weight * weightedAbsorb; |
| } |
| } else { |
| d = gi.weight * weightedDelta; |
| } |
| |
| deltas[n] += d; |
| } |
| n++; |
| } else { |
| n += 2; |
| } |
| } |
| |
| if (!lastPass && hitLimit && !absorbing) { |
| delta -= gslimit; |
| } else { |
| delta = 0; // stop iteration |
| } |
| } |
| |
| if (DEBUG) { |
| float total = 0; |
| for (int i = 0; i < deltas.length; i++) { |
| total += deltas[i]; |
| System.out.print(deltas[i] + ", "); |
| if (i % 20 == 9) { |
| System.out.println(); |
| } |
| } |
| System.out.println("\ntotal: " + total); |
| System.out.println(); |
| } |
| |
| return deltas; |
| } |
| } |
