/*******************************************************************************
* 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.util.List;
import org.eclipse.draw2d.Graphics;
import org.eclipse.draw2d.geometry.Dimension;
import org.eclipse.draw2d.geometry.Rectangle;
import org.eclipse.jst.jsf.common.ui.internal.logging.Logger;
import org.eclipse.jst.pagedesigner.PDPlugin;
import org.eclipse.jst.pagedesigner.css2.property.TextDecorationMeta;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Font;
/**
* @author mengbo
*/
public class TextLayoutSupport {
private static final Logger _log = PDPlugin
.getLogger(TextLayoutSupport.class);
private static final String[] DELIMITERS = { "\r\n", //$NON-NLS-1$
"\n", //$NON-NLS-1$
"\r" //$NON-NLS-1$
};
static private int delimeterLength;
/**
* Reuses an existing <code>TextFragmentBox</code>, or creates a new one.
*
* @param i
* the index
* @param fragments
* the original list of fragments
* @return a TextFragmentBox
*/
// copied from TextLayout
protected static TextFragmentBox getFragment(int i, List fragments) {
if (fragments.size() > i) {
return (TextFragmentBox) fragments.get(i);
}
TextFragmentBox box = new TextFragmentBox();
fragments.add(box);
return box;
}
/**
* Returns the average character width of given TextFragmentbox
*
* @param fragment
* the TextFragmentBox
* @return the average character width
*/
public static float getAverageCharWidth(TextFragmentBox fragment) {
if (fragment._width != 0 && fragment._length != 0) {
return fragment._width / (float) fragment._length;
}
return 0.0f;
}
// ----------------------------------------------------------------------------------------
/**
* this method will create a set of TextFragment. Each fragment will offset
* to the original text (whole text for the text figure).
* @param context
* @param text
* @param fragments
* @param font
* @param wrappingStyle
* @param trimLeading
*/
public static void layoutNormal(FlowContext context, String text,
List fragments, Font font, int wrappingStyle, boolean trimLeading) {
int i = 0; // The index of the current fragment;
int offset = 0;
if (trimLeading) {
offset = 1;
text = text.substring(1);
}
int length = 0; // The length of the current fragment
float prevAvgCharWidth;
LineBox currentLine;
TextFragmentBox fragment;
while (text.length() > 0) {
fragment = null;
prevAvgCharWidth = 0f;
fragment = getFragment(i, fragments);
prevAvgCharWidth = getAverageCharWidth(fragment);
// Check for newline, if it exists, call context.endLine and skip
// over the newline
// Exccept for first time through, don't do this.
if (i != 0) {
boolean changed = false;
if (text.charAt(0) == '\r') {
text = text.substring(1);
changed = true;
offset += 1;
}
if (text.length() != 0 && text.charAt(0) == '\n') {
text = text.substring(1);
changed = true;
offset += 1;
}
if (changed) {
context.endLine();
}
}
fragment._offset = offset;
// This loop is done at most twice.
// The second time through, a context.endLine()
// was requested, and the loop will break.
while (true) {
currentLine = context.getCurrentLine();
length = FlowUtilities.setupFragmentBasedOnTextSpace(fragment,
text, font, currentLine.getAvailableWidth(),
prevAvgCharWidth, wrappingStyle);
if (fragment._width <= currentLine.getAvailableWidth()
|| !context.isCurrentLineOccupied()) {
break;
}
context.endLine();
}
// fragment.x = context.getCurrentX();
context.addToCurrentLine(fragment);
text = text.substring(length);
offset += length;
if (text.length() > 0) {
context.endLine();
}
i++;
}
// Remove the remaining unused fragments.
while (i < fragments.size()) {
fragments.remove(fragments.size() - 1);
}
}
/**
* @param context
* @param text
* @param fragments
* @param font
*/
public static void layoutNoWrap(FlowContext context, String text,
List fragments, Font font) {
TextFragmentBox fragment;
int i = 0;
int offset = 0;
while (offset < text.length()) {
int result = nextLineBreak(text, offset);
fragment = getFragment(i++, fragments);
fragment._length = result - offset;
fragment._offset = offset;
FlowUtilities.setupFragment(fragment, font, text.substring(offset));
context.getCurrentLine().add(fragment);
offset = result + delimeterLength;
if (delimeterLength != 0) {
// in nextLineBreak we fo
context.endLine();
}
}
// Remove the remaining unused fragments.
while (i < fragments.size()) {
fragments.remove(i++);
}
}
private static int nextLineBreak(String text, int offset) {
int result = text.length();
delimeterLength = 0;
int current;
for (int i = 0; i < DELIMITERS.length; i++) {
current = text.indexOf(DELIMITERS[i], offset);
if (current != -1 && current < result) {
result = current;
delimeterLength = DELIMITERS[i].length();
}
}
return result;
}
/**
* @param g
* @param fragments
* @param font
* @param textDecoration
*/
public static void paintTextFigure(Graphics g, List fragments, Font font,
int textDecoration) {
paintTextFigure(g, fragments, font, null, textDecoration);
}
/**
* @param g
* @param rect
* @param textDecoration
*/
public static void paintTextDecoration(Graphics g, Rectangle rect,
int textDecoration) {
if ((textDecoration & TextDecorationMeta.UNDERLINE) != 0) {
g.drawLine(rect.x, rect.y + rect.height - 1, rect.x + rect.width
- 1, rect.y + rect.height - 1);
}
if ((textDecoration & TextDecorationMeta.OVERLINE) != 0) {
g.drawLine(rect.x, rect.y + 1, rect.x + rect.width - 1, rect.y + 1);
}
if ((textDecoration & TextDecorationMeta.LINETHROUGH) != 0) {
g.drawLine(rect.x, rect.y + rect.height / 2, rect.x + rect.width
- 1, rect.y + rect.height / 2);
}
}
/**
* @param g
* @param fragments
* @param font
* @param color
* @param textDecoration
*/
public static void paintTextFigure(Graphics g, List fragments, Font font,
Color color, int textDecoration) {
// FIXME: It happens there is problem in this method's parameters. what
// exception should be catched?
try {
TextFragmentBox frag;
// XXX: adjust font. Here is not using setFont(), because that will
// result in revalidate
g.setFont(font);
for (int i = 0; i < fragments.size(); i++) {
frag = (TextFragmentBox) fragments.get(i);
// if (!g.getClip(Rectangle.SINGLETON).intersects(frag))
// continue;
String draw;
draw = frag.getTextData();
if (color != null) {
g.setForegroundColor(color);
}
g.drawText(draw, frag._x, frag._y);
if ((textDecoration & TextDecorationMeta.UNDERLINE) != 0) {
g.drawLine(frag._x, frag._y + frag.getHeight() - 1, frag._x
+ frag.getWidth(), frag._y + frag.getHeight() - 1);
}
if ((textDecoration & TextDecorationMeta.OVERLINE) != 0) {
g.drawLine(frag._x, frag._y, frag._x + frag.getWidth(),
frag._y);
}
if ((textDecoration & TextDecorationMeta.LINETHROUGH) != 0) {
g.drawLine(frag._x, frag._y + frag.getHeight() / 2, frag._x
+ frag.getWidth(), frag._y + frag.getHeight() / 2);
}
if (Debug.DEBUG_BASELINE) {
g.drawLine(frag._x, frag._y + frag.getAscent(), frag._x
+ frag.getWidth(), frag._y + frag.getAscent());
}
}
} catch (Exception e) {
// "Error in text painting:"
_log.info("TextLayoutSupport.Info.1", e); //$NON-NLS-1$
}
}
/**
*
* @param g
* @param fragments
* @param text
* all the text in the Text figure.
* @param font
* @param color
* @param textDecoration
* @param start
* @param end
* @param selectionForeColor
* @param selectionBackColor
*/
public static void paintTextFigureWithSelection(Graphics g, List fragments,
String text, Font font, Color color, int textDecoration, int start,
int end, Color selectionForeColor, Color selectionBackColor) {
// FIXME: It happens there is problem in this method's parameters. what
// exception should be catched?
try {
TextFragmentBox frag;
Color originalForeground = g.getForegroundColor();
Color originalBackgroud = g.getBackgroundColor();
// XXX: adjust font. Here is not using setFont(), because that will
// result in revalidate
g.setFont(font);
for (int i = 0, n = fragments.size(); i < n; i++) {
frag = (TextFragmentBox) fragments.get(i);
// to make things simpler, we always draw the line using default
// color
if (color != null) {
g.setForegroundColor(color);
}
// if (!g.getClip(Rectangle.SINGLETON).intersects(frag))
// continue;
String draw;
draw = frag.getTextData();
if (frag._offset >= end || frag._offset + frag._length <= start) {
// we are not in selection. no need to change color
g.drawText(draw, frag._x, frag._y);
paintTextDecoration(g, frag.getRectangle(), textDecoration);
} else if (frag._offset >= start
&& frag._offset + frag._length <= end) {
// we are fully in selection
g.setForegroundColor(selectionForeColor);
g.setBackgroundColor(selectionBackColor);
g
.fillRectangle(frag._x, frag._y, FlowUtilities
.getTextExtents(draw, font).width, frag
.getHeight());
g.drawText(draw, frag._x, frag._y);
paintTextDecoration(g, frag.getRectangle(), textDecoration);
} else {
// partial of the fragment's text is in selection.
// draw the original string first
g.drawText(draw, frag._x, frag._y);
// then override with the selected parts.
g.setForegroundColor(selectionForeColor);
g.setBackgroundColor(selectionBackColor);
int partialStart = frag._offset > start ? frag._offset
: start;
int partialEnd = (frag._offset + frag._length > end) ? end
: (frag._offset + frag._length);
int x = 0;
String skip = text.substring(frag._offset, partialStart);
x = FlowUtilities.getTextExtents(skip, font).width;
String todraw = text.substring(partialStart, partialEnd);
if (todraw.length() > 0) {
Dimension dimension = FlowUtilities.getTextExtents(skip
+ todraw, font);
g.fillRectangle(frag._x + x, frag._y, dimension.width
- x, dimension.height);
g.drawText(skip + todraw, frag._x, frag._y);
if (color != null) {
g.setForegroundColor(color);
} else {
g.setForegroundColor(originalForeground);
}
g.drawText(skip, frag._x, frag._y);
paintTextDecoration(g, frag.getRectangle(),
textDecoration);
g.setForegroundColor(selectionForeColor);
paintTextDecoration(g,
new Rectangle(frag._x + x, frag._y,
dimension.width - x, dimension.height),
textDecoration);
}
}
// we do this in each loop, to make sure we are using correct
// color
g.setForegroundColor(originalForeground);
g.setBackgroundColor(originalBackgroud);
}
} catch (Exception e) {
// "Error in text painting:"
_log.info("TextLayoutSupport.Info.1", e); //$NON-NLS-1$
}
}
/**
* @param textAlign
* @param rect
* @param textWidth
* @return the x value
*/
public static int getBeginX(Object textAlign, Rectangle rect, int textWidth) {
int x = rect.x;
if (textAlign != null) {
String align = textAlign.toString();
if ("left".equalsIgnoreCase(align)) //$NON-NLS-1$
{
x = rect.x + 1;
} else if ("right".equalsIgnoreCase(align)) //$NON-NLS-1$
{
x = rect.x + rect.width - textWidth - 1;
if (x < 1) {
x = 1;
}
} else if ("center".equalsIgnoreCase(align)) //$NON-NLS-1$
{
int offset = (rect.width - textWidth) / 2;
if (offset <= 0) {
offset = 0;
}
x = x + offset + 1;
}
}
return x;
}
private TextLayoutSupport()
{
// no instantiation
}
}