import java.awt.Rectangle;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.apache.fop.util.*;

        setForeignAttributes(spm.getForeignAttributes());

        if (original.foreignAttributes != null) {

            setForeignAttributes(original.foreignAttributes);

        }

     * @param mediaBox the MediaBox area

     * @param cropBox the CropBox area

     * @param bleedBox the BleedBox area

     * @param trimBox the TrimBox area

     * @param pageIndex index of the page (zero-based)

                            int pageWidth, int pageHeight, int pageIndex) {

        Rectangle2D mediaBox = new Rectangle2D.Double(0, 0, pageWidth, pageHeight);

        return makePage(resources, pageIndex, mediaBox, mediaBox, mediaBox, mediaBox);

    }

    /**

     * Make a /Page object. The page is assigned an object number immediately

     * so references can already be made. The page must be added to the

     * PDFDocument later using addObject().

     *

     * @param resources resources object to use

     * @param pageWidth width of the page in points

     * @param pageHeight height of the page in points

     *

     * @return the created /Page object

     */

    public PDFPage makePage(PDFResources resources,

     * @param mediaBox the MediaBox

     * @param cropBox the CropBox. If null, mediaBox is used.

     * @param bleedBox the BleedBox. If null, cropBox is used.

     * @param trimBox the TrimBox. If null, bleedBox is used.

    /**

     * Sets the "CropBox" entry

     * @param box the bleed rectangle

     */

    public void setCropBox(Rectangle2D box) {

        put("CropBox", toPDFArray(box));

    }  

import java.awt.geom.Point2D;

import org.apache.fop.render.extensions.prepress.PageScale;

        if (getPageViewport(pageNum).getForeignAttributes() != null) {

            String scale = (String) getPageViewport(pageNum).getForeignAttributes().get(

                    PageScale.EXT_PAGE_SCALE);

            Point2D scales = PageScale.getScale(scale);

            if (scales != null) {

                scaleX *= scales.getX();

                scaleY *= scales.getY();

            }

        }

package org.apache.fop.render.extensions.prepress;

import java.awt.*;

import java.text.MessageFormat;

import java.util.Map;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import org.apache.fop.util.QName;

import org.apache.fop.fo.extensions.ExtensionElementMapping;

import org.apache.fop.fo.properties.FixedLength;

/**

 * This class is used to calculate the effective boundaries of a page including special-purpose

 * boxes used in prepress. These are specified using extension attributes:

 * bleedBox, trimBox and cropBox. The semantics are further described on the website.

 */

public class PageBoundaries {

    /**

     * The extension attribute for calculating the PDF BleedBox area - specifies the bleed width.

     */

    public static final QName EXT_BLEED

            = new QName(ExtensionElementMapping.URI, null, "bleed");

    /**

     * The extension attribute for the PDF CropBox area.

     */

    public static final QName EXT_CROP_OFFSET

            = new QName(ExtensionElementMapping.URI, null, "crop-offset");

    /**

     * The extension attribute for the PDF CropBox area.

     */

    public static final QName EXT_CROP_BOX

            = new QName(ExtensionElementMapping.URI, null, "crop-box");

    private static final Pattern SIZE_UNIT_PATTERN

            = Pattern.compile("^(-?\\d*\\.?\\d*)(px|in|cm|mm|pt|pc|mpt)$");

    private static final Pattern WHITESPACE_PATTERN = Pattern.compile("\\s+");

    private Rectangle trimBox;

    private Rectangle bleedBox;

    private Rectangle mediaBox;

    private Rectangle cropBox;

    /**

     * Creates a new instance.

     * @param pageSize the page size (in mpt) defined by the simple-page-master.

     * @param bleed the bleed value (raw value as given in the property value)

     * @param cropOffset the crop-offset value (raw value as given in the property value)

     * @param cropBoxSelector the crop-box, valid values: (trim-box|bleed-box|media-box)

     */

    public PageBoundaries(Dimension pageSize, String bleed, String cropOffset,

            String cropBoxSelector) {

        calculate(pageSize, bleed, cropOffset, cropBoxSelector);

    }

    /**

     * Creates a new instance.

     * @param pageSize the page size (in mpt) defined by the simple-page-master.

     * @param foreignAttributes the foreign attributes for the page

     *                  (used to extract the extension attribute values)

     */

    public PageBoundaries(Dimension pageSize, Map foreignAttributes) {

        String bleed = (String)foreignAttributes.get(EXT_BLEED);

        String cropOffset = (String)foreignAttributes.get(EXT_CROP_OFFSET);

        String cropBoxSelector = (String)foreignAttributes.get(EXT_CROP_BOX);

        calculate(pageSize, bleed, cropOffset, cropBoxSelector);

    }

    private void calculate(Dimension pageSize, String bleed, String cropOffset,

            String cropBoxSelector) {

        this.trimBox = new Rectangle(pageSize);

        this.bleedBox = getBleedBoxRectangle(this.trimBox, bleed);

        Rectangle cropMarksBox = getCropMarksAreaRectangle(trimBox, cropOffset);

        //MediaBox includes all of the following three rectangles

        this.mediaBox = new Rectangle();

        this.mediaBox.add(this.trimBox);

        this.mediaBox.add(this.bleedBox);

        this.mediaBox.add(cropMarksBox);

        if ("trim-box".equals(cropBoxSelector)) {

            this.cropBox = this.trimBox;

        } else if ("bleed-box".equals(cropBoxSelector)) {

            this.cropBox = this.bleedBox;

        } else if ("media-box".equals(cropBoxSelector)

                || cropBoxSelector == null

                || "".equals(cropBoxSelector)) {

            this.cropBox = this.mediaBox;

        } else {

            final String err = "The crop-box has invalid value: {0}, "

                + "possible values of crop-box: (trim-box|bleed-box|media-box)";

            throw new IllegalArgumentException(MessageFormat.format(err,

                    new Object[]{cropBoxSelector}));

        }

    }

    /**

     * Returns the trim box for the page. This is equal to the page size given in XSL-FO.

     * After production the printed media is trimmed to this rectangle.

     * @return the trim box

     */

    public Rectangle getTrimBox() {

        return this.trimBox;

    }

    /**

     * Returns the bleed box for the page.

     * @return the bleed box

     */

    public Rectangle getBleedBox() {

        return this.bleedBox;

    }

    /**

     * Returns the media box for the page.

     * @return the media box

     */

    public Rectangle getMediaBox() {

        return this.mediaBox;

    }

    /**

     * Returns the crop box for the page. The crop box is used by Adobe Acrobat to select which

     * parts of the document shall be displayed and it also defines the rectangle to which a

     * RIP will clip the document. For bitmap output, this defines the size of the bitmap.

     * @return the crop box

     */

    public Rectangle getCropBox() {

        return this.cropBox;

    }

    /**

     * The BleedBox is calculated by expanding the TrimBox by the bleed widths.

     *

     * @param trimBox the TrimBox rectangle

     * @param bleed   the given bleed widths

     * @return the calculated BleedBox rectangle

     */

    private static Rectangle getBleedBoxRectangle(Rectangle trimBox, String bleed) {

        return getRectangleUsingOffset(trimBox, bleed);

    }

    /**

     * The MediaBox is calculated by expanding the TrimBox by the crop offsets.

     *

     * @param trimBox     the TrimBox rectangle

     * @param cropOffsets the given crop offsets

     * @return the calculated MediaBox rectangle

     */

    private static Rectangle getCropMarksAreaRectangle(Rectangle trimBox, String cropOffsets) {

        return getRectangleUsingOffset(trimBox, cropOffsets);

    }

    private static Rectangle getRectangleUsingOffset(Rectangle originalRect, String offset) {

        if (offset == null || "".equals(offset) || originalRect == null) {

            return originalRect;

        }

        String[] offsets = WHITESPACE_PATTERN.split(offset);

        int[] coords = new int[4]; // top, right, bottom, left

        switch (offsets.length) {

        case 1:

            coords[0] = getLengthIntValue(offsets[0]);

            coords[1] = coords[0];

            coords[2] = coords[0];

            coords[3] = coords[0];

            break;

        case 2:

            coords[0] = getLengthIntValue(offsets[0]);

            coords[1] = getLengthIntValue(offsets[1]);

            coords[2] = coords[0];

            coords[3] = coords[1];

            break;

        case 3:

            coords[0] = getLengthIntValue(offsets[0]);

            coords[1] = getLengthIntValue(offsets[1]);

            coords[2] = getLengthIntValue(offsets[2]);

            coords[3] = coords[1];

            break;

        case 4:

            coords[0] = getLengthIntValue(offsets[0]);

            coords[1] = getLengthIntValue(offsets[1]);

            coords[2] = getLengthIntValue(offsets[2]);

            coords[3] = getLengthIntValue(offsets[3]);

            break;

        default:

            // TODO throw appropriate exception that can be caught by the event

            // notification mechanism

            throw new IllegalArgumentException("Too many arguments");

        }

        return new Rectangle(originalRect.x - coords[3],

                originalRect.y - coords[2],

                originalRect.width + coords[3] + coords[1],

                originalRect.height + coords[0] + coords[2]);

    }

    private static int getLengthIntValue(final String length) {

        final String err = "Incorrect length value: {0}";

        Matcher m = SIZE_UNIT_PATTERN.matcher(length);

        if (m.find()) {

            return FixedLength.getInstance(Double.parseDouble(m.group(1)),

                    m.group(2)).getLength().getValue();

        } else {

            throw new IllegalArgumentException(MessageFormat.format(err, new Object[]{length}));

        }

    }

}

/*

 * Licensed to the Apache Software Foundation (ASF) under one or more

 * contributor license agreements.  See the NOTICE file distributed with

 * this work for additional information regarding copyright ownership.

 * The ASF licenses this file to You under the Apache License, Version 2.0

 * (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.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

/* $Id: PageScaleAttributes.java 800142 2009-08-02 19:41:37Z jeremias $ */

package org.apache.fop.render.extensions.prepress;

import java.awt.geom.Point2D;

import java.text.MessageFormat;

import java.util.regex.Pattern;

import org.apache.fop.util.QName;

import org.apache.fop.fo.extensions.ExtensionElementMapping;

/**

 * This class provides utility methods to parse the 'fox:scale' extension attribute.

 */

public final class PageScale {

    /**

     * The extension 'scale' attribute for the simple-page-master element.

     */

    public static final QName EXT_PAGE_SCALE

            = new QName(ExtensionElementMapping.URI, null, "scale");

    private static final Pattern WHITESPACE_PATTERN = Pattern.compile("\\s+");

    /**

     * Utility classes should not have a public or default constructor

     */

    private PageScale() {

    }

    /**

     * Compute scale parameters from given fox:scale attribute which has the format: scaleX [scaleY]

     * If scaleY is not defined, it equals scaleX.

     * @param scale scale attribute, input format: scaleX [scaleY]

     * @return the pair of (sx, sy) values

     */

    public static Point2D getScale(String scale) {

        // TODO throw appropriate exceptions that can be caught by the event

        // notification mechanism

        final String err = "Extension 'scale' attribute has incorrect value(s): {0}";

        if (scale == null || scale.equals("")) {

            return null;

        }

        String[] scales = WHITESPACE_PATTERN.split(scale);

        double scaleX;

        try {

            scaleX = Double.parseDouble(scales[0]);

        } catch (NumberFormatException nfe) {

            throw new IllegalArgumentException(MessageFormat.format(err, new Object[]{scale}));

        }

        double scaleY;

        switch (scales.length) {

        case 1:

            scaleY = scaleX;

            break;

        case 2:

            try {

                scaleY = Double.parseDouble(scales[1]);

            } catch (NumberFormatException nfe) {

                throw new IllegalArgumentException(MessageFormat.format(err, new Object[]{scale}));

            }

            break;

        default:

            throw new IllegalArgumentException("Too many arguments");

        }

        if (scaleX <= 0 || scaleY <= 0) {

            throw new IllegalArgumentException(MessageFormat.format(err, new Object[]{scale}));

        }

        return new Point2D.Double(scaleX, scaleY);

    }

}

import org.apache.fop.render.extensions.prepress.PageBoundaries;

import org.apache.fop.render.extensions.prepress.PageScale;

            at.translate(bounds.getMinX() / -1000f, bounds.getMinY() / -1000f);

            /* why did we have this???

            */

import java.awt.geom.Rectangle2D.Double;

import org.apache.fop.render.extensions.prepress.PageBoundaries;

import org.apache.fop.render.extensions.prepress.PageScale;

    private Double toPointAndScale(Rectangle box, double scaleX, double scaleY) {

        return new Rectangle2D.Double(box.getX() * scaleX / 1000,

                box.getY() * scaleY / 1000,

                box.getWidth() * scaleX / 1000,

                box.getHeight() * scaleY / 1000);

    }

/*

 * Licensed to the Apache Software Foundation (ASF) under one or more

 * contributor license agreements.  See the NOTICE file distributed with

 * this work for additional information regarding copyright ownership.

 * The ASF licenses this file to You under the Apache License, Version 2.0

 * (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.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

/* $Id: ConversionUtils.java 746664 2009-02-22 12:40:44Z jeremias $ */

package org.apache.fop.util;

/**

 * This class contains utility methods for conversions, like

 * a java.lang.String to an array of int or double.

 */

public final class ConversionUtils {

    /**

     * Converts the given base <code>String</code> into

     * an array of <code>int</code>, splitting the base along the

     * given separator pattern.

     * <em>Note: this method assumes the input is a string containing

     * only decimal integers, signed or unsigned, that are parsable

     * by <code>java.lang.Integer.parseInt(String)</code>. If this

     * is not the case, the resulting <code>NumberFormatException</code>

     * will have to be handled by the caller.</em>

     *

     * @param baseString    the base string

     * @param separatorPattern  the pattern separating the integer values

     *        (if this is <code>null</code>, the baseString is parsed as one

     *         integer value)

     * @return  an array of <code>int</code> whose size is equal to the number

     *          values in the input string; <code>null</code> if this number

     *          is equal to zero.

     */

    public static int[] toIntArray(String baseString, String separatorPattern) {

        if (baseString == null || "".equals(baseString)) {

            return null;

        }

        if (separatorPattern == null || "".equals(separatorPattern)) {

            return new int[] {Integer.parseInt(baseString)};

        }

        String[] values = baseString.split(separatorPattern);

        int numValues = values.length;

        if (numValues == 0) {

            return null;

        }

        int[] returnArray = new int[numValues];

        for (int i = 0; i < numValues; ++i) {

            returnArray[i] = Integer.parseInt(values[i]);

        }

        return returnArray;

    }

    /**

     * Converts the given base <code>String</code> into

     * an array of <code>double</code>, splitting the base along the

     * given separator pattern.

     * <em>Note: this method assumes the input is a string containing

     * only decimal doubles, signed or unsigned, that are parsable

     * by <code>java.lang.Double.parseDouble(String)</code>. If this

     * is not the case, the resulting <code>NumberFormatException</code>

     * will have to be handled by the caller.</em>

     *

     * @param baseString    the base string

     * @param separatorPattern  the pattern separating the integer values

     *        (if this is <code>null</code>, the baseString is parsed as one

     *         double value)

     * @return  an array of <code>double</code> whose size is equal to the number

     *          values in the input string; <code>null</code> if this number

     *          is equal to zero.

     */

    public static double[] toDoubleArray(String baseString, String separatorPattern) {

        if (baseString == null || "".equals(baseString)) {

            return null;

        }

        if (separatorPattern == null || "".equals(separatorPattern)) {

            return new double[] {Double.parseDouble(baseString)};

        }

        String[] values = baseString.split(separatorPattern);

        int numValues = values.length;

        if (numValues == 0) {

            return null;

        }

        double[] returnArray = new double[numValues];

        for (int i = 0; i < numValues; ++i) {

            returnArray[i] = Double.parseDouble(values[i]);

        }

        return returnArray;

    }

}

/*

 * Licensed to the Apache Software Foundation (ASF) under one or more

 * contributor license agreements.  See the NOTICE file distributed with

 * this work for additional information regarding copyright ownership.

 * The ASF licenses this file to You under the Apache License, Version 2.0

 * (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.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

/* $Id: XMLConstants.java 746664 2009-02-22 12:40:44Z jeremias $ */

package org.apache.fop.util;

/**

 * A collection of constants for XML handling.

 */

public interface XMLConstants {

    /** "CDATA" constant */

    String CDATA = "CDATA";

    /** XML namespace prefix */

    String XML_PREFIX = "xml";

    /** XML namespace URI */

    String XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace";

    /** xml:space attribute */

    org.apache.xmlgraphics.util.QName XML_SPACE = new org.apache.xmlgraphics.util.QName(

            XML_NAMESPACE, XML_PREFIX, "space");

    /** XMLNS namespace prefix */

    String XMLNS_PREFIX = "xmlns";

    /** XMLNS namespace URI */

    String XMLNS_NAMESPACE_URI = "http://www.w3.org/2000/xmlns/";

    /** Namespace prefix for XLink */

    String XLINK_PREFIX = "xlink";

    /** XML namespace for XLink */

    String XLINK_NAMESPACE = "http://www.w3.org/1999/xlink";

    /** xlink:href attribute */

    org.apache.xmlgraphics.util.QName XLINK_HREF = new org.apache.xmlgraphics.util.QName(

            XLINK_NAMESPACE, XLINK_PREFIX, "href");

}

/*

 * Licensed to the Apache Software Foundation (ASF) under one or more

 * contributor license agreements.  See the NOTICE file distributed with

 * this work for additional information regarding copyright ownership.

 * The ASF licenses this file to You under the Apache License, Version 2.0

 * (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.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

/* $Id: XMLUtil.java 820672 2009-10-01 14:48:27Z jeremias $ */

package org.apache.fop.util;

import java.awt.Rectangle;

import java.awt.geom.Rectangle2D;

import org.xml.sax.Attributes;

import org.xml.sax.SAXException;

import org.xml.sax.helpers.AttributesImpl;

/**

 * A collection of utility method for XML handling.

 */

public class XMLUtil implements XMLConstants {

    /**

     * Returns an attribute value as a boolean value.

     * @param attributes the Attributes object

     * @param name the name of the attribute

     * @param defaultValue the default value if the attribute is not specified

     * @return the attribute value as a boolean

     */

    public static boolean getAttributeAsBoolean(Attributes attributes, String name,

            boolean defaultValue) {

        String s = attributes.getValue(name);

        if (s == null) {

            return defaultValue;

        } else {

            return Boolean.valueOf(s).booleanValue();

        }

    }

    /**

     * Returns an attribute value as a int value.

     * @param attributes the Attributes object

     * @param name the name of the attribute

     * @param defaultValue the default value if the attribute is not specified

     * @return the attribute value as an int

     */

    public static int getAttributeAsInt(Attributes attributes, String name,

            int defaultValue) {

        String s = attributes.getValue(name);

        if (s == null) {

            return defaultValue;

        } else {

            return Integer.parseInt(s);

        }

    }

    /**

     * Returns an attribute value as a int value.

     * @param attributes the Attributes object

     * @param name the name of the attribute

     * @return the attribute value as an int

     * @throws SAXException if the attribute is missing

     */

    public static int getAttributeAsInt(Attributes attributes, String name) throws SAXException {

        String s = attributes.getValue(name);

        if (s == null) {

            throw new SAXException("Attribute '" + name + "' is missing");

        } else {

            return Integer.parseInt(s);

        }

    }

    /**

     * Returns an attribute value as a Integer value.

     * @param attributes the Attributes object

     * @param name the name of the attribute

     * @return the attribute value as an Integer or null if the attribute is missing

     */

    public static Integer getAttributeAsInteger(Attributes attributes, String name) {

        String s = attributes.getValue(name);

        if (s == null) {

            return null;

        } else {

            return new Integer(s);

        }

    }

    /**

     * Returns an attribute value as a Rectangle2D value. The string value is expected as 4

     * double-precision numbers separated by whitespace.

     * @param attributes the Attributes object

     * @param name the name of the attribute

     * @return the attribute value as an Rectangle2D

     */

    public static Rectangle2D getAttributeAsRectangle2D(Attributes attributes, String name) {

        String s = attributes.getValue(name).trim();

        double[] values = ConversionUtils.toDoubleArray(s, "\\s");

        if (values.length != 4) {

            throw new IllegalArgumentException("Rectangle must consist of 4 double values!");

        }

        return new Rectangle2D.Double(values[0], values[1], values[2], values[3]);

    }

    /**

     * Returns an attribute value as a Rectangle value. The string value is expected as 4

     * integer numbers separated by whitespace.

     * @param attributes the Attributes object

     * @param name the name of the attribute

     * @return the attribute value as an Rectangle

     */

    public static Rectangle getAttributeAsRectangle(Attributes attributes, String name) {

        String s = attributes.getValue(name);

        if (s == null) {

            return null;

        }

        int[] values = ConversionUtils.toIntArray(s.trim(), "\\s");

        if (values.length != 4) {

            throw new IllegalArgumentException("Rectangle must consist of 4 int values!");

        }

        return new Rectangle(values[0], values[1], values[2], values[3]);

    }

    /**

     * Returns an attribute value as a integer array. The string value is expected as 4

     * integer numbers separated by whitespace.

     * @param attributes the Attributes object

     * @param name the name of the attribute

     * @return the attribute value as an int array

     */

    public static int[] getAttributeAsIntArray(Attributes attributes, String name) {

        String s = attributes.getValue(name);

        if (s == null) {

            return null;

        } else {

            return ConversionUtils.toIntArray(s.trim(), "\\s");

        }

    }

    /**

     * Adds an attribute to a given {@link AttributesImpl} instance.

     * @param atts the attributes collection

     * @param attribute the attribute to add

     * @param value the attribute's CDATA value

     */

    public static void addAttribute(AttributesImpl atts,

            org.apache.xmlgraphics.util.QName attribute, String value) {

        atts.addAttribute(attribute.getNamespaceURI(),

                attribute.getLocalName(), attribute.getQName(), XMLUtil.CDATA, value);

    }

    /**

     * Adds an attribute to a given {@link AttributesImpl} instance. The attribute will be

     * added in the default namespace.

     * @param atts the attributes collection

     * @param localName the local name of the attribute

     * @param value the attribute's CDATA value

     */

    public static void addAttribute(AttributesImpl atts, String localName, String value) {

        atts.addAttribute("", localName, localName, XMLUtil.CDATA, value);

    }

}

/*

 * Licensed to the Apache Software Foundation (ASF) under one or more

 * contributor license agreements.  See the NOTICE file distributed with

 * this work for additional information regarding copyright ownership.

 * The ASF licenses this file to You under the Apache License, Version 2.0

 * (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.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

/* $Id: PageScaleTest.java 803440 2009-08-12 10:46:39Z vhennebert $ */

package org.apache.fop.render.extensions.prepress;

import java.awt.geom.Point2D;

import junit.framework.TestCase;

/**

 * Tests for the fox:scale extension property.

 */

public class PageScaleTest extends TestCase {

    /**

     * Default constructor.

     */

    public PageScaleTest() {

        super();

    }

    /**

     * Creates a test case with the given name.

     *

     * @param name name for the test case

     */

    public PageScaleTest(String name) {

        super(name);

    }

    /** 1 value is used for both x and y. */

    public void testScale1() {

        Point2D res = PageScale.getScale(".5");

        assertEquals(0.5, res.getX(), 0.0);

        assertEquals(0.5, res.getY(), 0.0);

    }

    /** Two values, used resp. for x and y. */

    public void testScale2() {

        Point2D res = PageScale.getScale("1. \t \n 1.2");

        assertEquals(1.0, res.getX(), 0.0);

        assertEquals(1.2, res.getY(), 0.0);

    }

    /** Scale must not contain units. */

    public void testScaleFail() {

        try {

            PageScale.getScale("0.5mm 0.5cm");

            fail("Expected IllegalArgumentException. Scale shouldn't contain units");

        } catch (IllegalArgumentException iae) {

            // Good!

        }

    }

    /** @{code null} is returned when scale is unspecified. */

    public void testScaleNull() {

        Point2D res = PageScale.getScale(null);

        assertNull("Result should be null", res);

        res = PageScale.getScale("");

        assertNull("Result should be null", res);

    }

}

import org.apache.fop.render.extensions.prepress.PageBoundariesTest;

import org.apache.fop.render.extensions.prepress.PageScaleTest;

        suite.addTest(new TestSuite(PageBoundariesTest.class));

        suite.addTest(new TestSuite(PageScaleTest.class));