ojluni/src/main/java/sun/font/Decoration.java - platform/libcore - Git at Google

 /*
  * 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 IBM Corp. 1999-2003, All Rights Reserved
  *
  */

 package sun.font;

 import java.util.Map;

 import java.awt.BasicStroke;
 import java.awt.Color;
 import java.awt.Graphics2D;
 import java.awt.Paint;
 import java.awt.RenderingHints;
 import java.awt.Shape;
 import java.awt.Stroke;

 import java.awt.font.TextAttribute;

 import java.awt.geom.Area;
 import java.awt.geom.Line2D;
 import java.awt.geom.Rectangle2D;
 import java.awt.geom.GeneralPath;

 import static sun.font.AttributeValues.*;
 import static sun.font.EAttribute.*;

 /**
  * This class handles underlining, strikethrough, and foreground and
  * background styles on text.  Clients simply acquire instances
  * of this class and hand them off to ExtendedTextLabels or GraphicComponents.
  */
 public class Decoration {

     /**
      * This interface is implemented by clients that use Decoration.
      * Unfortunately, interface methods have to public;  ideally these
      * would be package-private.
      */
     public interface Label {
         CoreMetrics getCoreMetrics();
         Rectangle2D getLogicalBounds();

         void handleDraw(Graphics2D g2d, float x, float y);
         Rectangle2D handleGetCharVisualBounds(int index);
         Rectangle2D handleGetVisualBounds();
         Shape handleGetOutline(float x, float y);
     }

     private Decoration() {
     }

     /**
      * Return a Decoration which does nothing.
      */
     public static Decoration getPlainDecoration() {

         return PLAIN;
     }

     private static final int VALUES_MASK =
         AttributeValues.getMask(EFOREGROUND, EBACKGROUND, ESWAP_COLORS,
                                 ESTRIKETHROUGH, EUNDERLINE, EINPUT_METHOD_HIGHLIGHT,
                                 EINPUT_METHOD_UNDERLINE);

     public static Decoration getDecoration(AttributeValues values) {
         if (values == null || !values.anyDefined(VALUES_MASK)) {
             return PLAIN;
         }

         values = values.applyIMHighlight();

         return new DecorationImpl(values.getForeground(),
                                   values.getBackground(),
                                   values.getSwapColors(),
                                   values.getStrikethrough(),
                                   Underline.getUnderline(values.getUnderline()),
                                   Underline.getUnderline(values.getInputMethodUnderline()));
     }

     /**
      * Return a Decoration appropriate for the the given Map.
      * @param attributes the Map used to determine the Decoration
      */
     public static Decoration getDecoration(Map attributes) {
         if (attributes == null) {
             return PLAIN;
         }
         return getDecoration(AttributeValues.fromMap(attributes));
     }

     public void drawTextAndDecorations(Label label,
                                 Graphics2D g2d,
                                 float x,
                                 float y) {

         label.handleDraw(g2d, x, y);
     }

     public Rectangle2D getVisualBounds(Label label) {

         return label.handleGetVisualBounds();
     }

     public Rectangle2D getCharVisualBounds(Label label, int index) {

         return label.handleGetCharVisualBounds(index);
     }

     Shape getOutline(Label label,
                      float x,
                      float y) {

         return label.handleGetOutline(x, y);
     }

     private static final Decoration PLAIN = new Decoration();

     private static final class DecorationImpl extends Decoration {

         private Paint fgPaint = null;
         private Paint bgPaint = null;
         private boolean swapColors = false;
         private boolean strikethrough = false;
         private Underline stdUnderline = null; // underline from TextAttribute.UNDERLINE_ON
         private Underline imUnderline = null; // input method underline

         DecorationImpl(Paint foreground,
                        Paint background,
                        boolean swapColors,
                        boolean strikethrough,
                        Underline stdUnderline,
                        Underline imUnderline) {

             fgPaint = (Paint) foreground;
             bgPaint = (Paint) background;

             this.swapColors = swapColors;
             this.strikethrough = strikethrough;

             this.stdUnderline = stdUnderline;
             this.imUnderline = imUnderline;
         }

         private static boolean areEqual(Object lhs, Object rhs) {

             if (lhs == null) {
                 return rhs == null;
             }
             else {
                 return lhs.equals(rhs);
             }
         }

         public boolean equals(Object rhs) {

             if (rhs == this) {
                 return true;
             }
             if (rhs == null) {
                 return false;
             }

             DecorationImpl other = null;
             try {
                 other = (DecorationImpl) rhs;
             }
             catch(ClassCastException e) {
                 return false;
             }

             if (!(swapColors == other.swapColors &&
                         strikethrough == other.strikethrough)) {
                 return false;
             }

             if (!areEqual(stdUnderline, other.stdUnderline)) {
                 return false;
             }
             if (!areEqual(fgPaint, other.fgPaint)) {
                 return false;
             }
             if (!areEqual(bgPaint, other.bgPaint)) {
                 return false;
             }
             return areEqual(imUnderline, other.imUnderline);
         }

         public int hashCode() {

             int hc = 1;
             if (strikethrough) {
                 hc |= 2;
             }
             if (swapColors) {
                 hc |= 4;
             }
             if (stdUnderline != null) {
                 hc += stdUnderline.hashCode();
             }
             return hc;
         }

         /**
         * Return the bottom of the Rectangle which encloses pixels
         * drawn by underlines.
         */
         private float getUnderlineMaxY(CoreMetrics cm) {

             float maxY = 0;
             if (stdUnderline != null) {

                 float ulBottom = cm.underlineOffset;
                 ulBottom += stdUnderline.getLowerDrawLimit(cm.underlineThickness);
                 maxY = Math.max(maxY, ulBottom);
             }

             if (imUnderline != null) {

                 float ulBottom = cm.underlineOffset;
                 ulBottom += imUnderline.getLowerDrawLimit(cm.underlineThickness);
                 maxY = Math.max(maxY, ulBottom);
             }

             return maxY;
         }

         private void drawTextAndEmbellishments(Label label,
                                                Graphics2D g2d,
                                                float x,
                                                float y) {

             label.handleDraw(g2d, x, y);

             if (!strikethrough && stdUnderline == null && imUnderline == null) {
                 return;
             }

             float x1 = x;
             float x2 = x1 + (float)label.getLogicalBounds().getWidth();

             CoreMetrics cm = label.getCoreMetrics();
             if (strikethrough) {
                 Stroke savedStroke = g2d.getStroke();
                 g2d.setStroke(new BasicStroke(cm.strikethroughThickness,
                                               BasicStroke.CAP_BUTT,
                                               BasicStroke.JOIN_MITER));
                 float strikeY = y + cm.strikethroughOffset;
                 g2d.draw(new Line2D.Float(x1, strikeY, x2, strikeY));
                 g2d.setStroke(savedStroke);
             }

             float ulOffset = cm.underlineOffset;
             float ulThickness = cm.underlineThickness;

             if (stdUnderline != null) {
                 stdUnderline.drawUnderline(g2d, ulThickness, x1, x2, y + ulOffset);
             }

             if (imUnderline != null) {
                 imUnderline.drawUnderline(g2d, ulThickness, x1, x2, y + ulOffset);
             }
         }

         public void drawTextAndDecorations(Label label,
                                     Graphics2D g2d,
                                     float x,
                                     float y) {

             if (fgPaint == null && bgPaint == null && swapColors == false) {
                 drawTextAndEmbellishments(label, g2d, x, y);
             }
             else {
                 Paint savedPaint = g2d.getPaint();
                 Paint foreground, background;

                 if (swapColors) {
                     background = fgPaint==null? savedPaint : fgPaint;
                     if (bgPaint == null) {
                         if (background instanceof Color) {
                             Color bg = (Color)background;
                             // 30/59/11 is standard weights, tweaked a bit
                             int brightness = 33 * bg.getRed()
                                 + 53 * bg.getGreen()
                                 + 14 * bg.getBlue();
                             foreground = brightness > 18500 ? Color.BLACK : Color.WHITE;
                         } else {
                             foreground = Color.WHITE;
                         }
                     } else {
                         foreground = bgPaint;
                     }
                 }
                 else {
                     foreground = fgPaint==null? savedPaint : fgPaint;
                     background = bgPaint;
                 }

                 if (background != null) {

                     Rectangle2D bgArea = label.getLogicalBounds();
                     bgArea = new Rectangle2D.Float(x + (float)bgArea.getX(),
                                                 y + (float)bgArea.getY(),
                                                 (float)bgArea.getWidth(),
                                                 (float)bgArea.getHeight());

                     g2d.setPaint(background);
                     g2d.fill(bgArea);
                 }

                 g2d.setPaint(foreground);
                 drawTextAndEmbellishments(label, g2d, x, y);
                 g2d.setPaint(savedPaint);
             }
         }

         public Rectangle2D getVisualBounds(Label label) {

             Rectangle2D visBounds = label.handleGetVisualBounds();

             if (swapColors || bgPaint != null || strikethrough
                         || stdUnderline != null || imUnderline != null) {

                 float minX = 0;
                 Rectangle2D lb = label.getLogicalBounds();

                 float minY = 0, maxY = 0;

                 if (swapColors || bgPaint != null) {

                     minY = (float)lb.getY();
                     maxY = minY + (float)lb.getHeight();
                 }

                 maxY = Math.max(maxY, getUnderlineMaxY(label.getCoreMetrics()));

                 Rectangle2D ab = new Rectangle2D.Float(minX, minY, (float)lb.getWidth(), maxY-minY);
                 visBounds.add(ab);
             }

             return visBounds;
         }

         Shape getOutline(Label label,
                          float x,
                          float y) {

             if (!strikethrough && stdUnderline == null && imUnderline == null) {
                 return label.handleGetOutline(x, y);
             }

             CoreMetrics cm = label.getCoreMetrics();

             // NOTE:  The performace of the following code may
             // be very poor.
             float ulThickness = cm.underlineThickness;
             float ulOffset = cm.underlineOffset;

             Rectangle2D lb = label.getLogicalBounds();
             float x1 = x;
             float x2 = x1 + (float)lb.getWidth();

             Area area = null;

             if (stdUnderline != null) {
                 Shape ul = stdUnderline.getUnderlineShape(ulThickness,
                                                           x1, x2, y+ulOffset);
                 area = new Area(ul);
             }

             if (strikethrough) {
                 Stroke stStroke = new BasicStroke(cm.strikethroughThickness,
                                                   BasicStroke.CAP_BUTT,
                                                   BasicStroke.JOIN_MITER);
                 float shiftY = y + cm.strikethroughOffset;
                 Line2D line = new Line2D.Float(x1, shiftY, x2, shiftY);
                 Area slArea = new Area(stStroke.createStrokedShape(line));
                 if(area == null) {
                     area = slArea;
                 } else {
                     area.add(slArea);
                 }
             }

             if (imUnderline != null) {
                 Shape ul = imUnderline.getUnderlineShape(ulThickness,
                                                          x1, x2, y+ulOffset);
                 Area ulArea = new Area(ul);
                 if (area == null) {
                     area = ulArea;
                 }
                 else {
                     area.add(ulArea);
                 }
             }

             // area won't be null here, since at least one underline exists.
             area.add(new Area(label.handleGetOutline(x, y)));

             return new GeneralPath(area);
         }


         public String toString() {
             StringBuffer buf = new StringBuffer();
             buf.append(super.toString());
             buf.append("[");
             if (fgPaint != null) buf.append("fgPaint: " + fgPaint);
             if (bgPaint != null) buf.append(" bgPaint: " + bgPaint);
             if (swapColors) buf.append(" swapColors: true");
             if (strikethrough) buf.append(" strikethrough: true");
             if (stdUnderline != null) buf.append(" stdUnderline: " + stdUnderline);
             if (imUnderline != null) buf.append(" imUnderline: " + imUnderline);
             buf.append("]");
             return buf.toString();
         }
     }
 }
	/*
	* 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 IBM Corp. 1999-2003, All Rights Reserved
	*
	*/

	package sun.font;

	import java.util.Map;

	import java.awt.BasicStroke;
	import java.awt.Color;
	import java.awt.Graphics2D;
	import java.awt.Paint;
	import java.awt.RenderingHints;
	import java.awt.Shape;
	import java.awt.Stroke;

	import java.awt.font.TextAttribute;

	import java.awt.geom.Area;
	import java.awt.geom.Line2D;
	import java.awt.geom.Rectangle2D;
	import java.awt.geom.GeneralPath;

	import static sun.font.AttributeValues.*;
	import static sun.font.EAttribute.*;

	/**
	* This class handles underlining, strikethrough, and foreground and
	* background styles on text. Clients simply acquire instances
	* of this class and hand them off to ExtendedTextLabels or GraphicComponents.
	*/
	public class Decoration {

	/**
	* This interface is implemented by clients that use Decoration.
	* Unfortunately, interface methods have to public; ideally these
	* would be package-private.
	*/
	public interface Label {
	CoreMetrics getCoreMetrics();
	Rectangle2D getLogicalBounds();

	void handleDraw(Graphics2D g2d, float x, float y);
	Rectangle2D handleGetCharVisualBounds(int index);
	Rectangle2D handleGetVisualBounds();
	Shape handleGetOutline(float x, float y);
	}

	private Decoration() {
	}

	/**
	* Return a Decoration which does nothing.
	*/
	public static Decoration getPlainDecoration() {

	return PLAIN;
	}

	private static final int VALUES_MASK =
	AttributeValues.getMask(EFOREGROUND, EBACKGROUND, ESWAP_COLORS,
	ESTRIKETHROUGH, EUNDERLINE, EINPUT_METHOD_HIGHLIGHT,
	EINPUT_METHOD_UNDERLINE);

	public static Decoration getDecoration(AttributeValues values) {
	if (values == null \|\| !values.anyDefined(VALUES_MASK)) {
	return PLAIN;
	}

	values = values.applyIMHighlight();

	return new DecorationImpl(values.getForeground(),
	values.getBackground(),
	values.getSwapColors(),
	values.getStrikethrough(),
	Underline.getUnderline(values.getUnderline()),
	Underline.getUnderline(values.getInputMethodUnderline()));
	}

	/**
	* Return a Decoration appropriate for the the given Map.
	* @param attributes the Map used to determine the Decoration
	*/
	public static Decoration getDecoration(Map attributes) {
	if (attributes == null) {
	return PLAIN;
	}
	return getDecoration(AttributeValues.fromMap(attributes));
	}

	public void drawTextAndDecorations(Label label,
	Graphics2D g2d,
	float x,
	float y) {

	label.handleDraw(g2d, x, y);
	}

	public Rectangle2D getVisualBounds(Label label) {

	return label.handleGetVisualBounds();
	}

	public Rectangle2D getCharVisualBounds(Label label, int index) {

	return label.handleGetCharVisualBounds(index);
	}

	Shape getOutline(Label label,
	float x,
	float y) {

	return label.handleGetOutline(x, y);
	}

	private static final Decoration PLAIN = new Decoration();

	private static final class DecorationImpl extends Decoration {

	private Paint fgPaint = null;
	private Paint bgPaint = null;
	private boolean swapColors = false;
	private boolean strikethrough = false;
	private Underline stdUnderline = null; // underline from TextAttribute.UNDERLINE_ON
	private Underline imUnderline = null; // input method underline

	DecorationImpl(Paint foreground,
	Paint background,
	boolean swapColors,
	boolean strikethrough,
	Underline stdUnderline,
	Underline imUnderline) {

	fgPaint = (Paint) foreground;
	bgPaint = (Paint) background;

	this.swapColors = swapColors;
	this.strikethrough = strikethrough;

	this.stdUnderline = stdUnderline;
	this.imUnderline = imUnderline;
	}

	private static boolean areEqual(Object lhs, Object rhs) {

	if (lhs == null) {
	return rhs == null;
	}
	else {
	return lhs.equals(rhs);
	}
	}

	public boolean equals(Object rhs) {

	if (rhs == this) {
	return true;
	}
	if (rhs == null) {
	return false;
	}

	DecorationImpl other = null;
	try {
	other = (DecorationImpl) rhs;
	}
	catch(ClassCastException e) {
	return false;
	}

	if (!(swapColors == other.swapColors &&
	strikethrough == other.strikethrough)) {
	return false;
	}

	if (!areEqual(stdUnderline, other.stdUnderline)) {
	return false;
	}
	if (!areEqual(fgPaint, other.fgPaint)) {
	return false;
	}
	if (!areEqual(bgPaint, other.bgPaint)) {
	return false;
	}
	return areEqual(imUnderline, other.imUnderline);
	}

	public int hashCode() {

	int hc = 1;
	if (strikethrough) {
	hc \|= 2;
	}
	if (swapColors) {
	hc \|= 4;
	}
	if (stdUnderline != null) {
	hc += stdUnderline.hashCode();
	}
	return hc;
	}

	/**
	* Return the bottom of the Rectangle which encloses pixels
	* drawn by underlines.
	*/
	private float getUnderlineMaxY(CoreMetrics cm) {

	float maxY = 0;
	if (stdUnderline != null) {

	float ulBottom = cm.underlineOffset;
	ulBottom += stdUnderline.getLowerDrawLimit(cm.underlineThickness);
	maxY = Math.max(maxY, ulBottom);
	}

	if (imUnderline != null) {

	float ulBottom = cm.underlineOffset;
	ulBottom += imUnderline.getLowerDrawLimit(cm.underlineThickness);
	maxY = Math.max(maxY, ulBottom);
	}

	return maxY;
	}

	private void drawTextAndEmbellishments(Label label,
	Graphics2D g2d,
	float x,
	float y) {

	label.handleDraw(g2d, x, y);

	if (!strikethrough && stdUnderline == null && imUnderline == null) {
	return;
	}

	float x1 = x;
	float x2 = x1 + (float)label.getLogicalBounds().getWidth();

	CoreMetrics cm = label.getCoreMetrics();
	if (strikethrough) {
	Stroke savedStroke = g2d.getStroke();
	g2d.setStroke(new BasicStroke(cm.strikethroughThickness,
	BasicStroke.CAP_BUTT,
	BasicStroke.JOIN_MITER));
	float strikeY = y + cm.strikethroughOffset;
	g2d.draw(new Line2D.Float(x1, strikeY, x2, strikeY));
	g2d.setStroke(savedStroke);
	}

	float ulOffset = cm.underlineOffset;
	float ulThickness = cm.underlineThickness;

	if (stdUnderline != null) {
	stdUnderline.drawUnderline(g2d, ulThickness, x1, x2, y + ulOffset);
	}

	if (imUnderline != null) {
	imUnderline.drawUnderline(g2d, ulThickness, x1, x2, y + ulOffset);
	}
	}

	public void drawTextAndDecorations(Label label,
	Graphics2D g2d,
	float x,
	float y) {

	if (fgPaint == null && bgPaint == null && swapColors == false) {
	drawTextAndEmbellishments(label, g2d, x, y);
	}
	else {
	Paint savedPaint = g2d.getPaint();
	Paint foreground, background;

	if (swapColors) {
	background = fgPaint==null? savedPaint : fgPaint;
	if (bgPaint == null) {
	if (background instanceof Color) {
	Color bg = (Color)background;
	// 30/59/11 is standard weights, tweaked a bit
	int brightness = 33 * bg.getRed()
	+ 53 * bg.getGreen()
	+ 14 * bg.getBlue();
	foreground = brightness > 18500 ? Color.BLACK : Color.WHITE;
	} else {
	foreground = Color.WHITE;
	}
	} else {
	foreground = bgPaint;
	}
	}
	else {
	foreground = fgPaint==null? savedPaint : fgPaint;
	background = bgPaint;
	}

	if (background != null) {

	Rectangle2D bgArea = label.getLogicalBounds();
	bgArea = new Rectangle2D.Float(x + (float)bgArea.getX(),
	y + (float)bgArea.getY(),
	(float)bgArea.getWidth(),
	(float)bgArea.getHeight());

	g2d.setPaint(background);
	g2d.fill(bgArea);
	}

	g2d.setPaint(foreground);
	drawTextAndEmbellishments(label, g2d, x, y);
	g2d.setPaint(savedPaint);
	}
	}

	public Rectangle2D getVisualBounds(Label label) {

	Rectangle2D visBounds = label.handleGetVisualBounds();

	if (swapColors \|\| bgPaint != null \|\| strikethrough
	\|\| stdUnderline != null \|\| imUnderline != null) {

	float minX = 0;
	Rectangle2D lb = label.getLogicalBounds();

	float minY = 0, maxY = 0;

	if (swapColors \|\| bgPaint != null) {

	minY = (float)lb.getY();
	maxY = minY + (float)lb.getHeight();
	}

	maxY = Math.max(maxY, getUnderlineMaxY(label.getCoreMetrics()));

	Rectangle2D ab = new Rectangle2D.Float(minX, minY, (float)lb.getWidth(), maxY-minY);
	visBounds.add(ab);
	}

	return visBounds;
	}

	Shape getOutline(Label label,
	float x,
	float y) {

	if (!strikethrough && stdUnderline == null && imUnderline == null) {
	return label.handleGetOutline(x, y);
	}

	CoreMetrics cm = label.getCoreMetrics();

	// NOTE: The performace of the following code may
	// be very poor.
	float ulThickness = cm.underlineThickness;
	float ulOffset = cm.underlineOffset;

	Rectangle2D lb = label.getLogicalBounds();
	float x1 = x;
	float x2 = x1 + (float)lb.getWidth();

	Area area = null;

	if (stdUnderline != null) {
	Shape ul = stdUnderline.getUnderlineShape(ulThickness,
	x1, x2, y+ulOffset);
	area = new Area(ul);
	}

	if (strikethrough) {
	Stroke stStroke = new BasicStroke(cm.strikethroughThickness,
	BasicStroke.CAP_BUTT,
	BasicStroke.JOIN_MITER);
	float shiftY = y + cm.strikethroughOffset;
	Line2D line = new Line2D.Float(x1, shiftY, x2, shiftY);
	Area slArea = new Area(stStroke.createStrokedShape(line));
	if(area == null) {
	area = slArea;
	} else {
	area.add(slArea);
	}
	}

	if (imUnderline != null) {
	Shape ul = imUnderline.getUnderlineShape(ulThickness,
	x1, x2, y+ulOffset);
	Area ulArea = new Area(ul);
	if (area == null) {
	area = ulArea;
	}
	else {
	area.add(ulArea);
	}
	}

	// area won't be null here, since at least one underline exists.
	area.add(new Area(label.handleGetOutline(x, y)));

	return new GeneralPath(area);
	}


	public String toString() {
	StringBuffer buf = new StringBuffer();
	buf.append(super.toString());
	buf.append("[");
	if (fgPaint != null) buf.append("fgPaint: " + fgPaint);
	if (bgPaint != null) buf.append(" bgPaint: " + bgPaint);
	if (swapColors) buf.append(" swapColors: true");
	if (strikethrough) buf.append(" strikethrough: true");
	if (stdUnderline != null) buf.append(" stdUnderline: " + stdUnderline);
	if (imUnderline != null) buf.append(" imUnderline: " + imUnderline);
	buf.append("]");
	return buf.toString();
	}
	}
	}