From 6025b6016517c6d898d8957d1d7e03ba71431912 Mon Sep 17 00:00:00 2001 From: tknall Date: Fri, 1 Dec 2006 12:20:24 +0000 Subject: Initial import of release 2.2. git-svn-id: https://joinup.ec.europa.eu/svn/pdf-as/trunk@4 7b5415b0-85f9-ee4d-85bd-d5d0c3b42d1c --- src/main/java/com/lowagie/text/Rectangle.java | 955 ++++++++++++++++++++++++++ 1 file changed, 955 insertions(+) create mode 100644 src/main/java/com/lowagie/text/Rectangle.java (limited to 'src/main/java/com/lowagie/text/Rectangle.java') diff --git a/src/main/java/com/lowagie/text/Rectangle.java b/src/main/java/com/lowagie/text/Rectangle.java new file mode 100644 index 0000000..801ace0 --- /dev/null +++ b/src/main/java/com/lowagie/text/Rectangle.java @@ -0,0 +1,955 @@ +/* + * $Id: Rectangle.java,v 1.76 2005/12/12 08:31:40 blowagie Exp $ + * $Name: $ + * + * Copyright 1999, 2000, 2001, 2002 by Bruno Lowagie. + * + * The contents of this file are subject to the Mozilla Public License Version 1.1 + * (the "License"); you may not use this file except in compliance with the License. + * You may obtain a copy of the License at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the License. + * + * The Original Code is 'iText, a free JAVA-PDF library'. + * + * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by + * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie. + * All Rights Reserved. + * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer + * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved. + * + * Contributor(s): all the names of the contributors are added in the source code + * where applicable. + * + * Alternatively, the contents of this file may be used under the terms of the + * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the + * provisions of LGPL are applicable instead of those above. If you wish to + * allow use of your version of this file only under the terms of the LGPL + * License and not to allow others to use your version of this file under + * the MPL, indicate your decision by deleting the provisions above and + * replace them with the notice and other provisions required by the LGPL. + * If you do not delete the provisions above, a recipient may use your version + * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE. + * + * This library is free software; you can redistribute it and/or modify it + * under the terms of the MPL as stated above or under the terms of the GNU + * Library General Public License as published by the Free Software Foundation; + * either version 2 of the License, or any later version. + * + * This library 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 Library general Public License for more + * details. + * + * If you didn't download this code from the following link, you should check if + * you aren't using an obsolete version: + * http://www.lowagie.com/iText/ + */ + +package com.lowagie.text; + +import java.awt.Color; +import java.util.ArrayList; +import java.util.Properties; +import java.util.Set; +import com.lowagie.text.pdf.GrayColor; + +/** + * A Rectangle is the representation of a geometric figure. + * + * Rectangles support constant width borders using + * {@link #setBorderWidth(float)}and {@link #setBorder(int)}. They also + * support borders that vary in width/color on each side using methods like + * {@link #setBorderWidthLeft(float)}or + * {@link #setBorderColorLeft(java.awt.Color)}. + * + * @see Element + * @see Table + * @see Cell + * @see HeaderFooter + */ + +public class Rectangle implements Element, MarkupAttributes { + + // static membervariables (concerning the presence of borders) + + /** This is the value that will be used as undefined . */ + public static final int UNDEFINED = -1; + + /** This represents one side of the border of the Rectangle. */ + public static final int TOP = 1; + + /** This represents one side of the border of the Rectangle. */ + public static final int BOTTOM = 2; + + /** This represents one side of the border of the Rectangle. */ + public static final int LEFT = 4; + + /** This represents one side of the border of the Rectangle. */ + public static final int RIGHT = 8; + + /** This represents a rectangle without borders. */ + public static final int NO_BORDER = 0; + + /** This represents a type of border. */ + public static final int BOX = TOP + BOTTOM + LEFT + RIGHT; + + // membervariables + + /** the lower left x-coordinate. */ + protected float llx; + + /** the lower left y-coordinate. */ + protected float lly; + + /** the upper right x-coordinate. */ + protected float urx; + + /** the upper right y-coordinate. */ + protected float ury; + + /** This represents the status of the 4 sides of the rectangle. */ + protected int border = UNDEFINED; + + /** This is the width of the border around this rectangle. */ + protected float borderWidth = UNDEFINED; + + /** The color of the border of this rectangle. */ + protected Color color = null; + + /** The color of the left border of this rectangle. */ + protected Color borderColorLeft = null; + + /** The color of the right border of this rectangle. */ + protected Color borderColorRight = null; + + /** The color of the top border of this rectangle. */ + protected Color borderColorTop = null; + + /** The color of the bottom border of this rectangle. */ + protected Color borderColorBottom = null; + + /** The width of the left border of this rectangle. */ + protected float borderWidthLeft = UNDEFINED; + + /** The width of the right border of this rectangle. */ + protected float borderWidthRight = UNDEFINED; + + /** The width of the top border of this rectangle. */ + protected float borderWidthTop = UNDEFINED; + + /** The width of the bottom border of this rectangle. */ + protected float borderWidthBottom = UNDEFINED; + + /** Whether variable width borders are used. */ + protected boolean useVariableBorders = false; + + /** This is the color of the background of this rectangle. */ + protected Color background = null; + + protected int rotation = 0; + + /** Contains extra markupAttributes */ + protected Properties markupAttributes; + + // constructors + + /** + * Constructs a Rectangle -object. + * + * @param llx + * lower left x + * @param lly + * lower left y + * @param urx + * upper right x + * @param ury + * upper right y + */ + + public Rectangle(float llx, float lly, float urx, float ury) { + this.llx = llx; + this.lly = lly; + this.urx = urx; + this.ury = ury; + } + + /** + * Constructs a Rectangle -object starting from the origin + * (0, 0). + * + * @param urx + * upper right x + * @param ury + * upper right y + */ + + public Rectangle(float urx, float ury) { + this(0, 0, urx, ury); + } + + /** + * Constructs a Rectangle -object. + * + * @param rect + * another Rectangle + */ + + public Rectangle(Rectangle rect) { + this(rect.llx, rect.lly, rect.urx, rect.ury); + cloneNonPositionParameters(rect); + } + + /** + * Copies all of the parameters from a Rectangle object + * except the position. + * + * @param rect + * Rectangle to copy from + */ + + public void cloneNonPositionParameters(Rectangle rect) { + this.rotation = rect.rotation; + this.border = rect.border; + this.borderWidth = rect.borderWidth; + this.color = rect.color; + this.background = rect.background; + this.borderColorLeft = rect.borderColorLeft; + this.borderColorRight = rect.borderColorRight; + this.borderColorTop = rect.borderColorTop; + this.borderColorBottom = rect.borderColorBottom; + this.borderWidthLeft = rect.borderWidthLeft; + this.borderWidthRight = rect.borderWidthRight; + this.borderWidthTop = rect.borderWidthTop; + this.borderWidthBottom = rect.borderWidthBottom; + this.useVariableBorders = rect.useVariableBorders; + } + + /** + * Copies all of the parameters from a Rectangle object + * except the position. + * + * @param rect + * Rectangle to copy from + */ + + public void softCloneNonPositionParameters(Rectangle rect) { + if (rect.rotation != 0) + this.rotation = rect.rotation; + if (rect.border != UNDEFINED) + this.border = rect.border; + if (rect.borderWidth != UNDEFINED) + this.borderWidth = rect.borderWidth; + if (rect.color != null) + this.color = rect.color; + if (rect.background != null) + this.background = rect.background; + if (rect.borderColorLeft != null) + this.borderColorLeft = rect.borderColorLeft; + if (rect.borderColorRight != null) + this.borderColorRight = rect.borderColorRight; + if (rect.borderColorTop != null) + this.borderColorTop = rect.borderColorTop; + if (rect.borderColorBottom != null) + this.borderColorBottom = rect.borderColorBottom; + if (rect.borderWidthLeft != UNDEFINED) + this.borderWidthLeft = rect.borderWidthLeft; + if (rect.borderWidthRight != UNDEFINED) + this.borderWidthRight = rect.borderWidthRight; + if (rect.borderWidthTop != UNDEFINED) + this.borderWidthTop = rect.borderWidthTop; + if (rect.borderWidthBottom != UNDEFINED) + this.borderWidthBottom = rect.borderWidthBottom; + if (useVariableBorders) + this.useVariableBorders = rect.useVariableBorders; + } + + // implementation of the Element interface + + /** + * Processes the element by adding it (or the different parts) to an + * ElementListener. + * + * @param listener + * an ElementListener + * @return true if the element was processed successfully + */ + + public boolean process(ElementListener listener) { + try { + return listener.add(this); + } catch (DocumentException de) { + return false; + } + } + + /** + * Gets the type of the text element. + * + * @return a type + */ + + public int type() { + return Element.RECTANGLE; + } + + /** + * Gets all the chunks in this element. + * + * @return an ArrayList + */ + + public ArrayList getChunks() { + return new ArrayList(); + } + + // methods + + /** + * Switches lowerleft with upperright + */ + public void normalize() { + if (llx > urx) { + float a = llx; + llx = urx; + urx = a; + } + if (lly > ury) { + float a = lly; + lly = ury; + ury = a; + } + } + + /** + * Gets a Rectangle that is altered to fit on the page. + * + * @param top + * the top position + * @param bottom + * the bottom position + * @return a Rectangle + */ + + public Rectangle rectangle(float top, float bottom) { + Rectangle tmp = new Rectangle(this); + if (top() > top) { + tmp.setTop(top); + tmp.setBorder(border - (border & TOP)); + } + if (bottom() < bottom) { + tmp.setBottom(bottom); + tmp.setBorder(border - (border & BOTTOM)); + } + return tmp; + } + + /** + * Swaps the values of urx and ury and of lly and llx in order to rotate the + * rectangle. + * + * @return a Rectangle + */ + + public Rectangle rotate() { + Rectangle rect = new Rectangle(lly, llx, ury, urx); + rect.rotation = rotation + 90; + rect.rotation %= 360; + return rect; + } + + // methods to set the membervariables + + /** + * Sets the lower left x-coordinate. + * + * @param value + * the new value + */ + + public void setLeft(float value) { + llx = value; + } + + /** + * Sets the upper right x-coordinate. + * + * @param value + * the new value + */ + + public void setRight(float value) { + urx = value; + } + + /** + * Sets the upper right y-coordinate. + * + * @param value + * the new value + */ + + public void setTop(float value) { + ury = value; + } + + /** + * Sets the lower left y-coordinate. + * + * @param value + * the new value + */ + + public void setBottom(float value) { + lly = value; + } + + /** + * Enables/Disables the border on the specified sides. The border is + * specified as an integer bitwise combination of the constants: + * LEFT, RIGHT, TOP, BOTTOM. + * + * @see #enableBorderSide(int) + * @see #disableBorderSide(int) + * @param value + * the new value + */ + + public void setBorder(int value) { + border = value; + } + + /** + * Enables the border on the specified side. + * + * @param side + * the side to enable. One of LEFT, RIGHT, TOP, BOTTOM + * + */ + public void enableBorderSide(int side) { + if (border == UNDEFINED) { + border = 0; + } + border |= side; + } + + /** + * Disables the border on the specified side. + * + * @param side + * the side to disable. One of LEFT, RIGHT, TOP, BOTTOM + * + */ + public void disableBorderSide(int side) { + if (border == UNDEFINED) { + border = 0; + } + border &= ~side; + } + + /** + * Sets the borderwidth of the table. + * + * @param value + * the new value + */ + + public void setBorderWidth(float value) { + borderWidth = value; + } + + /** + * Sets the color of the border. + * + * @param value + * the new value + */ + + public void setBorderColor(Color value) { + color = value; + } + + /** + * Sets the value of the border color + * + * @param value + * a color value + */ + public void setBorderColorRight(Color value) { + borderColorRight = value; + } + + /** + * Sets the value of the border color + * + * @param value + * a color value + */ + public void setBorderColorLeft(Color value) { + borderColorLeft = value; + } + + /** + * Sets the value of the border color + * + * @param value + * a color value + */ + public void setBorderColorTop(Color value) { + borderColorTop = value; + } + + /** + * Sets the value of the border color + * + * @param value + * a color value + */ + public void setBorderColorBottom(Color value) { + borderColorBottom = value; + } + + /** + * Sets the backgroundcolor of the rectangle. + * + * @param value + * the new value + */ + + public void setBackgroundColor(Color value) { + background = value; + } + + /** + * Sets the grayscale of the rectangle. + * + * @param value + * the new value + */ + + public void setGrayFill(float value) { + background = new GrayColor(value); + } + + // methods to get the membervariables + + /** + * Returns the lower left x-coordinate. + * + * @return the lower left x-coordinate + */ + + public float left() { + return llx; + } + + /** + * Returns the upper right x-coordinate. + * + * @return the upper right x-coordinate + */ + + public float right() { + return urx; + } + + /** + * Returns the upper right y-coordinate. + * + * @return the upper right y-coordinate + */ + + public float top() { + return ury; + } + + /** + * Returns the lower left y-coordinate. + * + * @return the lower left y-coordinate + */ + + public float bottom() { + return lly; + } + + /** + * Returns the lower left x-coordinate, considering a given margin. + * + * @param margin + * a margin + * @return the lower left x-coordinate + */ + + public float left(float margin) { + return llx + margin; + } + + /** + * Returns the upper right x-coordinate, considering a given margin. + * + * @param margin + * a margin + * @return the upper right x-coordinate + */ + + public float right(float margin) { + return urx - margin; + } + + /** + * Returns the upper right y-coordinate, considering a given margin. + * + * @param margin + * a margin + * @return the upper right y-coordinate + */ + + public float top(float margin) { + return ury - margin; + } + + /** + * Returns the lower left y-coordinate, considering a given margin. + * + * @param margin + * a margin + * @return the lower left y-coordinate + */ + + public float bottom(float margin) { + return lly + margin; + } + + /** + * Returns the width of the rectangle. + * + * @return a width + */ + + public float width() { + return urx - llx; + } + + /** + * Returns the height of the rectangle. + * + * @return a height + */ + + public float height() { + return ury - lly; + } + + /** + * Indicates if the table has borders. + * + * @return a boolean + */ + + public boolean hasBorders() { + return (border > 0) + && ((borderWidth > 0) || (borderWidthLeft > 0) + || (borderWidthRight > 0) || (borderWidthTop > 0) || (borderWidthBottom > 0)); + } + + /** + * Indicates if the table has a some type of border. + * + * @param type + * the type of border + * @return a boolean + */ + + public boolean hasBorder(int type) { + return border != UNDEFINED && (border & type) == type; + } + + /** + * Returns the exact type of the border. + * + * @return a value + */ + + public int border() { + return border; + } + + /** + * Gets the borderwidth. + * + * @return a value + */ + + public float borderWidth() { + return borderWidth; + } + + /** + * Gets the color of the border. + * + * @return a value + */ + + public Color borderColor() { + return color; + } + + /** + * Gets the backgroundcolor. + * + * @return a value + */ + + public Color backgroundColor() { + return background; + } + + /** + * Gets the grayscale. + * + * @return a value + */ + + public float grayFill() { + if (background instanceof GrayColor) + return ((GrayColor)background).getGray(); + else + return 0; + } + + /** + * Gets the rotation of the rectangle + * + * @return a rotation value + */ + public int getRotation() { + return rotation; + } + + /** + * @see com.lowagie.text.MarkupAttributes#setMarkupAttribute(java.lang.String, + * java.lang.String) + */ + public void setMarkupAttribute(String name, String value) { + if (markupAttributes == null) + markupAttributes = new Properties(); + markupAttributes.put(name, value); + } + + /** + * @see com.lowagie.text.MarkupAttributes#setMarkupAttributes(java.util.Properties) + */ + public void setMarkupAttributes(Properties markupAttributes) { + this.markupAttributes = markupAttributes; + } + + /** + * @see com.lowagie.text.MarkupAttributes#getMarkupAttribute(java.lang.String) + */ + public String getMarkupAttribute(String name) { + return (markupAttributes == null) ? null : String + .valueOf(markupAttributes.get(name)); + } + + /** + * @see com.lowagie.text.MarkupAttributes#getMarkupAttributeNames() + */ + public Set getMarkupAttributeNames() { + return Chunk.getKeySet(markupAttributes); + } + + /** + * @see com.lowagie.text.MarkupAttributes#getMarkupAttributes() + */ + public Properties getMarkupAttributes() { + return markupAttributes; + } + + /** + * Gets the color of a border. + * + * @return a color value + */ + public Color getBorderColorLeft() { + if (borderColorLeft == null) return color; + return borderColorLeft; + } + + /** + * Gets the color of a border. + * + * @return a color value + */ + public Color getBorderColorRight() { + if (borderColorRight == null) return color; + return borderColorRight; + } + + /** + * Gets the color of a border. + * + * @return a color value + */ + public Color getBorderColorTop() { + if (borderColorTop == null) return color; + return borderColorTop; + } + + /** + * Gets the color of a border. + * + * @return a color value + */ + public Color getBorderColorBottom() { + if (borderColorBottom == null) return color; + return borderColorBottom; + } + + /** + * Gets the width of a border. + * + * @return a width + */ + public float getBorderWidthLeft() { + return getVariableBorderWidth(borderWidthLeft, LEFT); + } + + /** + * Sets the width of a border + * + * @param borderWidthLeft + * a width + */ + public void setBorderWidthLeft(float borderWidthLeft) { + this.borderWidthLeft = borderWidthLeft; + updateBorderBasedOnWidth(borderWidthLeft, LEFT); + } + + /** + * Gets the width of a border. + * + * @return a width + */ + public float getBorderWidthRight() { + return getVariableBorderWidth(borderWidthRight, RIGHT); + } + + /** + * Sets the width of a border + * + * @param borderWidthRight + * a width + */ + public void setBorderWidthRight(float borderWidthRight) { + this.borderWidthRight = borderWidthRight; + updateBorderBasedOnWidth(borderWidthRight, RIGHT); + } + + /** + * Gets the width of a border. + * + * @return a width + */ + public float getBorderWidthTop() { + return getVariableBorderWidth(borderWidthTop, TOP); + } + + /** + * Sets the width of a border + * + * @param borderWidthTop + * a width + */ + public void setBorderWidthTop(float borderWidthTop) { + this.borderWidthTop = borderWidthTop; + updateBorderBasedOnWidth(borderWidthTop, TOP); + } + + /** + * Gets the width of a border. + * + * @return a width + */ + public float getBorderWidthBottom() { + return getVariableBorderWidth(borderWidthBottom, BOTTOM); + } + + /** + * Sets the width of a border + * + * @param borderWidthBottom + * a width + */ + public void setBorderWidthBottom(float borderWidthBottom) { + this.borderWidthBottom = borderWidthBottom; + updateBorderBasedOnWidth(borderWidthBottom, BOTTOM); + } + + /** + * Updates the border flag for a side based on the specified width. A width + * of 0 will disable the border on that side. Any other width enables it. + * + * @param width + * width of border + * @param side + * border side constant + */ + + private void updateBorderBasedOnWidth(float width, int side) { + useVariableBorders = true; + if (width > 0) { + enableBorderSide(side); + } else { + disableBorderSide(side); + } + } + + private float getVariableBorderWidth(float variableWidthValue, int side) { + if ((border & side) != 0) { + return variableWidthValue != UNDEFINED ? variableWidthValue + : borderWidth; + } else { + return 0; + } + } + + /** + * Indicates whether variable width borders are being used. Returns true if + * setBorderWidthLeft, setBorderWidthRight, setBorderWidthTop, or + * setBorderWidthBottom has been called. + * + * @return true if variable width borders are in use + * + */ + public boolean isUseVariableBorders() { + return useVariableBorders; + } + + /** + * Sets a parameter indicating if the rectangle has variable borders + * + * @param useVariableBorders + * indication if the rectangle has variable borders + */ + public void setUseVariableBorders(boolean useVariableBorders) { + this.useVariableBorders = useVariableBorders; + } + + /** + * @see java.lang.Object#toString() + */ + public String toString() { + StringBuffer buf = new StringBuffer("Rectangle: "); + buf.append(width()); + buf.append("x"); + buf.append(height()); + buf.append(" (rot: "); + buf.append(rotation); + buf.append(" degrees)"); + return buf.toString(); + } + +} \ No newline at end of file -- cgit v1.2.3