/*******************************************************************************
* Copyright (c) 2006 Sybase, Inc. and others.
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Sybase, Inc. - initial API and implementation
*******************************************************************************/
package org.eclipse.jst.pagedesigner.css2.layout;
import java.text.BreakIterator;
import org.eclipse.draw2d.FigureUtilities;
import org.eclipse.draw2d.geometry.Dimension;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.FontMetrics;
/**
* Utility class for FlowFigures.
*
*/
public final class FlowUtilities extends FigureUtilities {
/**
* Returns the number of characters from the specified String that will fit
* in the available amount of space. An average character width can be
* provided as a hint for faster calculation.
*
* @param frag
* the TextFragmentBox
* @param string
* the String
* @param font
* the Font used for measuring
* @param availableWidth
* the available width in pixels
* @param avg
* 0.0, or an avg character width to use during calculation
* @param wrapping
* the word wrap style
* @return the number of characters that will fit in the space
*/
public static int setupFragmentBasedOnTextSpace(TextFragmentBox frag,
String string, Font font, int availableWidth, float avg,
int wrapping) {
int result = getTextForSpace(string, font, availableWidth, avg,
wrapping);
frag._length = result;
setupFragment(frag, font, string);
return result;
}
/**
* given the text string, font and available width and wrapping mode.
* Calculate how much text can fit into.
*
* @param string
* @param font
* @param availableWidth
* @param avg
* @param wrapping
* @return how much text can fit into
*/
public static int getTextForSpace(String string, Font font,
int availableWidth, float avg, int wrapping) {
if (string.length() == 0) {
return 0;
}
FontMetrics metrics = getFontMetrics(font);
BreakIterator breakItr = BreakIterator.getLineInstance();
breakItr.setText(string);
int MIN, min, max;
if (avg == 0.0) {
avg = metrics.getAverageCharWidth();
}
int firstBreak = breakItr.next();
int winNL = string.indexOf("\r\n"); //$NON-NLS-1$
int macNL = string.indexOf('\r');
int unixNL = string.indexOf('\n');
MIN = min = (wrapping == CSSTextLayout.WORD_WRAP_HARD) ? firstBreak : 1;
if (macNL == winNL) {
macNL = -1; // If the Mac newline is just the prefix to the win NL,
// ignore it
}
max = string.length() + 1;
if (winNL != -1) {
max = Math.min(max, winNL);
min = Math.min(min, winNL);
}
if (unixNL != -1) {
max = Math.min(max, unixNL);
min = Math.min(min, unixNL);
}
if (macNL != -1) {
max = Math.min(max, macNL);
min = Math.min(min, macNL);
}
int origMax = max;
// The size of the current guess
int guess = 0, guessSize = 0;
while ((max - min) > 1) {
// Pick a new guess size
// New guess is the last guess plus the missing width in pixels
// divided by the average character size in pixels
guess = guess + (int) ((availableWidth - guessSize) / avg);
if (guess >= max) {
guess = max - 1;
}
if (guess <= min) {
guess = min + 1;
}
// Measure the current guess
guessSize = getStringExtents2(string.substring(0, guess), font).width;
if (guessSize <= availableWidth) {
// We did not use the available width
min = guess;
} else {
// We exceeded the available width
max = guess;
}
}
int result = string.length();
switch (wrapping) {
case CSSTextLayout.WORD_WRAP_HARD:
if (min == string.length() || min == winNL || min == unixNL
|| min == macNL) {
result = min;
} else if (max == origMax
&& getStringExtents2(string.substring(0, max), font).width <= availableWidth) {
result = max;
} else {
result = Math.max(MIN, breakItr.preceding(Math.min(max, string
.length() - 1)));
}
break;
case CSSTextLayout.WORD_WRAP_SOFT:
if (min == string.length() || min == winNL || min == unixNL
|| min == macNL) {
result = min;
} else if (max == origMax
&& getStringExtents2(string.substring(0, max), font).width <= availableWidth) {
result = max;
} else if (breakItr.isBoundary(min)) {
result = min;
} else if (breakItr.isBoundary(Math.min(max, string.length() - 1))) {
result = max;
} else {
result = breakItr.preceding(Math.min(max, string.length() - 1));
}
if (result <= 0) {
result = min;
}
break;
// case CSSTextLayout.WORD_WRAP_TRUNCATE:
// if (min == string.length() || min == winNL || min == unixNL || min ==
// macNL)
// {
// result = frag._length = min;
// setupFragment(frag, font, string);
// if (frag.getWidth() <= availableWidth)
// return result;
// min -= 1;
// }
// else if (max == origMax && getStringExtents(string.substring(0, max),
// font).width <= availableWidth)
// {
// result = frag._length = max;
// setupFragment(frag, font, string);
// return result;
// }
// result = breakItr.preceding(Math.min(max + 1, string.length() - 1));
// if (result <= 0)
// {
// ELLIPSIS_SIZE =
// FigureUtilities.getStringExtents(CSSTextFigure.ELLIPSIS, font);
// getTextForSpace(frag, string, font, availableWidth -
// ELLIPSIS_SIZE.width, avg, CSSTextLayout.WORD_WRAP_SOFT);
// //frag.length = min;
// frag._truncated = true;
// result = breakItr.following(min);
// if (result == BreakIterator.DONE)
// result = string.length();
// }
// else
// {
// frag._length = result;
// }
}
return result;
}
/**
* @param string
* @param font
* @param availableWidth
* @param avg
* @return the text width
*/
public static int getTextInWidth(String string, Font font,
int availableWidth, float avg) {
if (string.length() == 0) {
return 0;
}
int guess = 0;
while (true) {
Dimension a = getTextExtents(string.substring(0, guess), font);
if (a.width >= availableWidth) {
return guess;
}
guess++;
if (guess == string.length()) {
return guess;
}
}
}
/**
* change the parent implementation of getStringExtents(). Don't expend the
* 1 width. So empty string will not have any width.
*
* @param s
* @param f
* @return the dimension
*/
public static Dimension getStringExtents2(String s, Font f) {
return new Dimension(getStringDimension(s, f));
}
static void setupFragment(TextFragmentBox frag, Font f, String s) {
// if (frag.length != s.length())
// we don't skip whitespace here. since already truncated in
// CSSTextLayout
// while (frag.length > 0 &&
// Character.isElementContentWhitespace(s.charAt(frag.length - 1)))
// frag.length--;
frag.setTextData(s.substring(0, frag._length));
Dimension d = getStringExtents2(s.substring(0, frag._length), f);
FontMetrics fm = getFontMetrics(f);
frag.setHeight(fm.getHeight());
frag.setAscent(fm.getAscent() + fm.getLeading());
if (frag._length > 0
&& Character.isWhitespace(s.charAt(frag._length - 1))) {
frag._isLastCharWhitespace = true;
} else {
frag._isLastCharWhitespace = false;
}
frag.setWidth(d.width);
}
private FlowUtilities()
{
// no instantiation
}
}