Attachment #16923 for bug #37253

View | Details | Raw Unified | Return to bug 37253
Collapse All | Expand All

Lines 30-35 Link Here

(-)src/java/org/apache/fop/fo/flow/TableColumn.java (+9 lines)
30	import org.apache.fop.fo.ValidationException;	30	import org.apache.fop.fo.ValidationException;
31	import org.apache.fop.fo.expr.PropertyException;	31	import org.apache.fop.fo.expr.PropertyException;
32	import org.apache.fop.fo.properties.CommonBorderPaddingBackground;	32	import org.apache.fop.fo.properties.CommonBorderPaddingBackground;
		33	import org.apache.fop.fo.properties.FixedLength;
33		34
34	/**	35	/**
35	* Class modelling the fo:table-column object.	36	* Class modelling the fo:table-column object.
Lines 176-180 Link Here
176	sb.append(" column-width=").append(getColumnWidth());	177	sb.append(" column-width=").append(getColumnWidth());
177	return sb.toString();	178	return sb.toString();
178	}	179	}
		180
		181	/**
		182	* Sets a column width.
		183	* @param length
		184	*/
		185	public void setColumnWidth(Length columnWidth) {
		186	this.columnWidth = columnWidth;
		187	}
179	}	188	}
180		189




/*
 * Copyright 2005 The Apache Software Foundation.
 *
 * Licensed 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$ */

package org.apache.fop.render.txt.border;

import java.util.Arrays;

/**
 * This class is responsible for managing of dashed border elements.
 */
public class DashedBorderElement extends AbstractBorderElement {
    
    private static final char DASH_HORIZONTAL = '-';

    private static final char DASH_VERTICAL = '|';
    
    private static final char UNDEFINED = '?';
    
    private static final int UP2 = 1;
    
    private static final int RIGHT2 = 2;
    
    private static final int DOWN2 = 4;
    
    private static final int LEFT2 = 8;
    
    private static char[] map = new char[20];
    
    static {
        Arrays.fill(map, UNDEFINED);
        map[0] = ' ';
        map[UP2] = DASH_VERTICAL;
        map[DOWN2] = DASH_VERTICAL;
        map[UP2 + DOWN2] = DASH_VERTICAL;
        
        map[LEFT2] = DASH_HORIZONTAL;
        map[RIGHT2] = DASH_HORIZONTAL;
        map[LEFT2 + RIGHT2] = DASH_HORIZONTAL;
    }
    
    /**
     * Constructs a newly allocated <code>DashedBorderElement</code> object.
     * Fills <code>data</code> using superclass constructor.
     * 
     * @param type binary representation of type gives <code>data</code>
     */
    public DashedBorderElement(int type) {
        super(type);
    }

    /**
     * Merges dashed border element with instance of solid and double border
     * element, returns instance of <code>SolidAndDoubleBorderElement</code>. 
     * 
     * @param sdb instance of <code>SolidAndDoubleBorderElement</code> to merge
     * @return merged border element
     */
    private AbstractBorderElement mergeSolid(SolidAndDoubleBorderElement sdb) {
        AbstractBorderElement e = new SolidAndDoubleBorderElement(EN_SOLID, 0);
        for (int i = 0; i < 4; i++) {
            e.setData(i, Math.max(data[i], sdb.getData(i)));
        }
        return e;        
    }

    /**
     * Merges dashed border element with dashed border element and returns 
     * instance of <code>DashedBorderElement</code>. 
     * 
     * @param dbe instance of <code>DashedBorderElement</code> to merge
     * @return merged border element
     */
    private AbstractBorderElement mergeDashed(DashedBorderElement dbe) {
        for (int i = 0; i < 4; i++) {
            data[i] = Math.max(data[i], dbe.getData(i));
        }
        return this;
    }
    
    /**
     * Converts dashed border element to 
     * <code>SolidAndDoubleBorderElement</code>.
     * 
     * @return converted instance of <code>SolidAndDoubleBorderElement</code>
     */
    private AbstractBorderElement toSolidAndDouble() {
        AbstractBorderElement e = new SolidAndDoubleBorderElement(EN_SOLID, 0);
        for (int i = 0; i < 4; i++) {
            e.setData(i, data[i]);
        }
        return e;        
    }

    /**
     * Merges with border element.
     * @param e instance of AbstractBorderElement
     * @return instance of AbstractBorderElement
     */
    public AbstractBorderElement merge(AbstractBorderElement e) {
        AbstractBorderElement abe = this;
        if (e instanceof SolidAndDoubleBorderElement) {
            abe = mergeSolid((SolidAndDoubleBorderElement) e);
        } else if (e instanceof DashedBorderElement) {
            abe = mergeDashed((DashedBorderElement) e);
        } else {
            abe = e;
        }
        return abe;
    }

    /** 
     * @see org.apache.fop.render.txt.border.AbstractBorderElement#convert2Char()
     */
    public char convert2Char() {
        int key = 0;
        key += data[UP] * UP2;
        key += data[DOWN] * DOWN2;
        key += data[LEFT] * LEFT2;
        key += data[RIGHT] * RIGHT2;
        char ch = map[key];
        if (ch == UNDEFINED) {
            ch = toSolidAndDouble().convert2Char();
        }
        return ch;
    }
}




/*
 * Copyright 2005 The Apache Software Foundation.
 *
 * Licensed 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$ */

package org.apache.fop.render.txt.border;

import java.util.Arrays;

/**
 * This class is responsible for solid and double border elements managing.
 */
public class SolidAndDoubleBorderElement extends AbstractBorderElement {

    private static final char LIGHT_HORIZONTAL = '\u2500';

    private static final char LIGHT_VERTICAL = '\u2502';

    private static final char LIGHT_DOWN_AND_RIGHT = '\u250C';

    private static final char LIGHT_DOWN_AND_LEFT = '\u2510';

    private static final char LIGHT_UP_AND_RIGHT = '\u2514';

    private static final char LIGHT_UP_AND_LEFT = '\u2518';

    private static final char LIGHT_VERTICAL_AND_RIGHT = '\u251C';

    private static final char LIGHT_VERTICAL_AND_LEFT = '\u2524';

    private static final char LIGHT_DOWN_AND_HORIZONTAL = '\u252C';

    private static final char LIGHT_UP_AND_HORIZONTAL = '\u2534';

    private static final char LIGHT_VERTICAL_AND_HORIZONTAL = '\u253C';
    
    private static final char DOUBLE_HORIZONTAL = '\u2550';

    private static final char DOUBLE_VERTICAL = '\u2551';
    
    private static final char DOUBLE_DOWN_AND_RIGHT = '\u2554';    

    private static final char DOUBLE_DOWN_AND_LEFT = '\u2557';

    private static final char DOUBLE_UP_AND_RIGHT = '\u255A';

    private static final char DOUBLE_UP_AND_LEFT = '\u255D';
    
    private static final char DOUBLE_VERTICAL_AND_RIGHT = '\u2560';
    
    private static final char DOUBLE_VERTICAL_AND_LEFT = '\u2563';
    
    private static final char DOUBLE_DOWN_AND_HORIZONTAL = '\u2566';
    
    private static final char DOUBLE_UP_AND_HORIZONTAL = '\u2569';
    
    private static final char DOUBLE_VERTICAL_AND_HORIZONTAL = '\u256C';
    
    private static final char DOWN_SINGLE_AND_RIGHT_DOUBLE = '\u2552';
    
    private static final char DOWN_DOUBLE_AND_RIGHT_SINGLE = '\u2553';

    private static final char DOWN_SINGLE_AND_LEFT_DOUBLE = '\u2555';

    private static final char DOWN_DOUBLE_AND_LEFT_SINGLE = '\u2556';
    
    private static final char UP_SINGLE_AND_RIGHT_DOUBLE = '\u2558';
    
    private static final char UP_DOUBLE_AND_RIGHT_SINGLE = '\u2559';
    
    private static final char UP_SINGLE_AND_LEFT_DOUBLE = '\u255B';
    
    private static final char UP_DOUBLE_AND_LEFT_SINGLE = '\u255C';
    
    private static final char VERTICAL_SINGLE_AND_RIGHT_DOUBLE = '\u255E';
    
    private static final char VERTICAL_DOUBLE_AND_RIGHT_SINGLE = '\u255F';
    
    private static final char VERTICAL_SINGLE_AND_LEFT_DOUBLE = '\u2561';
    
    private static final char VERTICAL_DOUBLE_AND_LEFT_SINGLE = '\u2562';
    
    private static final char DOWN_SINGLE_AND_HORIZONTAL_DOUBLE = '\u2564';
    
    private static final char DOWN_DOUBLE_AND_HORIZONTAL_SINGLE = '\u2565';
    
    private static final char UP_SINGLE_AND_HORIZONTAL_DOUBLE = '\u2567';
    
    private static final char UP_DOUBLE_AND_HORIZONTAL_SINGLE = '\u2568';
    
    private static final char VERTICAL_SINGLE_AND_HORIZONTAL_DOUBLE = '\u256A';
    
    private static final char VERTICAL_DOUBLE_AND_HORIZONTAL_SINGLE = '\u256B';
    
    private static final char UNDEFINED = '?';
    
    private static final int UP3 = 1;

    private static final int DOWN3 = 3;

    private static final int LEFT3 = 9;

    private static final int RIGHT3 = 27;

    private static final char[] MAP = new char[100];

    static {
        Arrays.fill(MAP, UNDEFINED);
        MAP[0] = ' ';
        MAP[UP3] = LIGHT_VERTICAL;
        MAP[DOWN3] = LIGHT_VERTICAL;
        MAP[RIGHT3] = LIGHT_HORIZONTAL;
        MAP[LEFT3] = LIGHT_HORIZONTAL;
        MAP[UP3 + DOWN3] = LIGHT_VERTICAL;
        MAP[LEFT3 + RIGHT3] = LIGHT_HORIZONTAL;
        MAP[UP3 + LEFT3] = LIGHT_UP_AND_LEFT;
        MAP[LEFT3 + DOWN3] = LIGHT_DOWN_AND_LEFT;
        MAP[DOWN3 + RIGHT3] = LIGHT_DOWN_AND_RIGHT;
        MAP[UP3 + RIGHT3] = LIGHT_UP_AND_RIGHT;
        MAP[UP3 + DOWN3 + RIGHT3] = LIGHT_VERTICAL_AND_RIGHT;
        MAP[UP3 + LEFT3 + DOWN3] = LIGHT_VERTICAL_AND_LEFT;
        MAP[LEFT3 + DOWN3 + RIGHT3] = LIGHT_DOWN_AND_HORIZONTAL;
        MAP[UP3 + LEFT3 + RIGHT3] = LIGHT_UP_AND_HORIZONTAL;
        MAP[UP3 + LEFT3 + DOWN3 + RIGHT3] = LIGHT_VERTICAL_AND_HORIZONTAL;
        //DOUBLE
        MAP[2 * UP3] = DOUBLE_VERTICAL;
        MAP[2 * DOWN3] = DOUBLE_VERTICAL;
        MAP[2 * RIGHT3] = DOUBLE_HORIZONTAL;
        MAP[2 * LEFT3] = DOUBLE_HORIZONTAL;
        MAP[2 * UP3 + 2 * DOWN3] = DOUBLE_VERTICAL;
        MAP[2 * LEFT3 + 2 * RIGHT3] = DOUBLE_HORIZONTAL;
        MAP[2 * UP3 + 2 * LEFT3] = DOUBLE_UP_AND_LEFT;
        MAP[2 * LEFT3 + 2 * DOWN3] = DOUBLE_DOWN_AND_LEFT;
        MAP[2 * DOWN3 + 2 * RIGHT3] = DOUBLE_DOWN_AND_RIGHT;
        MAP[2 * UP3 + 2 * RIGHT3] = DOUBLE_UP_AND_RIGHT;
        MAP[2 * UP3 + 2 * DOWN3 + 2 * RIGHT3] = DOUBLE_VERTICAL_AND_RIGHT;
        MAP[2 * UP3 + 2 * DOWN3 + 2 * LEFT3] = DOUBLE_VERTICAL_AND_LEFT;
        MAP[2 * DOWN3 + 2 * RIGHT3 + 2 * LEFT3] = DOUBLE_DOWN_AND_HORIZONTAL;
        MAP[2 * UP3 + 2 * RIGHT3 + 2 * LEFT3] = DOUBLE_UP_AND_HORIZONTAL;
        MAP[2 * UP3 + 2 * DOWN3 + 2 * RIGHT3 + 2 * LEFT3] = DOUBLE_VERTICAL_AND_HORIZONTAL;
        //DOUBLE&SINGLE
        MAP[DOWN3 + 2 * RIGHT3] = DOWN_SINGLE_AND_RIGHT_DOUBLE;
        MAP[2 * DOWN3 + RIGHT3] = DOWN_DOUBLE_AND_RIGHT_SINGLE;
        MAP[DOWN3 + 2 * LEFT3] = DOWN_SINGLE_AND_LEFT_DOUBLE;
        MAP[2 * DOWN3 + LEFT3] = DOWN_DOUBLE_AND_LEFT_SINGLE;
        MAP[UP3 + 2 * RIGHT3] = UP_SINGLE_AND_RIGHT_DOUBLE;
        MAP[2 * UP3 + RIGHT3] = UP_DOUBLE_AND_RIGHT_SINGLE;
        MAP[UP3 + 2 * LEFT3] = UP_SINGLE_AND_LEFT_DOUBLE;
        MAP[2 * UP3 + LEFT3] = UP_DOUBLE_AND_LEFT_SINGLE;
        MAP[UP3 + DOWN3 + 2 * RIGHT3] = VERTICAL_SINGLE_AND_RIGHT_DOUBLE;
        MAP[2 * UP3 + 2 * DOWN3 + RIGHT3] = VERTICAL_DOUBLE_AND_RIGHT_SINGLE;
        MAP[UP3 + DOWN3 + 2 * LEFT3] = VERTICAL_SINGLE_AND_LEFT_DOUBLE;
        MAP[2 * UP3 + 2 * DOWN3 + LEFT3] = VERTICAL_DOUBLE_AND_LEFT_SINGLE;
        MAP[DOWN3 + 2 * LEFT3 + 2 * RIGHT3] = DOWN_SINGLE_AND_HORIZONTAL_DOUBLE;
        MAP[2 * DOWN3 + LEFT3 + RIGHT3] = DOWN_DOUBLE_AND_HORIZONTAL_SINGLE;
        MAP[UP3 + 2 * LEFT3 + 2 * RIGHT3] = UP_SINGLE_AND_HORIZONTAL_DOUBLE;
        MAP[2 * UP3 + LEFT3 + RIGHT3] = UP_DOUBLE_AND_HORIZONTAL_SINGLE;
        MAP[UP3 + DOWN3 + 2 * LEFT3 + 2 * RIGHT3] = VERTICAL_SINGLE_AND_HORIZONTAL_DOUBLE;
        MAP[2 * UP3 + 2 * DOWN3 + LEFT3 + RIGHT3] = VERTICAL_DOUBLE_AND_HORIZONTAL_SINGLE;
    }

    /**
     * Initializes a newly created <code>SolidAndDoubleBorderElement</code> 
     * object so that it represents an empty border element.
     */
    public SolidAndDoubleBorderElement() {
    }

    /**
     * Constructs a newly allocated <code>SolidAndDoubleBorderElement</code> 
     * object. Fills <code>data</code> using binary representation of 
     * <code>type</code>. If border style is EN_DOUBLE, multiplies 
     * <code>data[side]</code> by 2 for every side to distinguish EN_SOLID and 
     * EN_DOUBLE.
     * 
     * @param style integer, representing border style.
     * @param type binary representation of type gives <code>data</code>
     */
    public SolidAndDoubleBorderElement(int style, int type) {
        super(type);
        if (style == EN_DOUBLE) {
            for (int i = 0; i < 4; i++) {
                data[i] *= 2;
            }
        }
    }
    
    /**
     * Merges with <code>sde</code>.
     * @param sde instance of SolidAndDoubleBorderElement
     * @return instance of AbstractBorderElement
     */
    public AbstractBorderElement mergeSolid(SolidAndDoubleBorderElement sde) {
        AbstractBorderElement e = new SolidAndDoubleBorderElement(EN_SOLID, 0);
        for (int i = 0; i < 4; i++) {
            if (sde.getData(i) != 0) {
                e.setData(i, sde.getData(i));
            } else {
                e.setData(i, data[i]);
            }
        }
        return e;
    }

    /**
     * Merges with e.
     * @param e instance of AbstractBorderElement
     * @return instance of AbstractBorderElement
     */
    public AbstractBorderElement merge(AbstractBorderElement e) {
        AbstractBorderElement abe = this;
        if (e instanceof SolidAndDoubleBorderElement) {
            abe = mergeSolid((SolidAndDoubleBorderElement) e);
        } else if (e instanceof DottedBorderElement) {
            abe = e;
        } else if (e instanceof DashedBorderElement) {
            abe = e.merge(this);
        }
        return abe;
    }
    
    /**
     * Maps to char.
     * @return resulting mapping char 
     */
    private char map2Char() {
        int key = 0;
        key += data[UP] * UP3;
        key += data[LEFT] * LEFT3;
        key += data[DOWN] * DOWN3;
        key += data[RIGHT] * RIGHT3;
        return MAP[key];
    }

    /**
     * Modifies data to nearest normal internal representation.
     */
    private void modifyData() {
        int c1 = 0;
        int c2 = 0;
        for (int i = 0; i < 4; i++) {
            c1 += (data[i] == 1) ? 1 : 0;
            c2 += (data[i] == 2) ? 1 : 0;
        }
        int m = c1 > c2 ? 1 : 0;
        int[] p = {0, m, 2 * (1 - m)};
        for (int i = 0; i < 4; i++) {
            data[i] = p[data[i]];
        }
    }

    /**
     * @see org.apache.fop.render.txt.border.AbstractBorderElement#convert2Char()
     */
    public char convert2Char() {
        char ch = map2Char();
        if (ch == UNDEFINED) {
            modifyData();
            ch = map2Char();
        }
        return ch;
    }
}




/*
 * Copyright 2005 The Apache Software Foundation.
 *
 * Licensed 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$ */

package org.apache.fop.render.txt.border;

import org.apache.fop.fo.Constants;
import org.apache.fop.render.txt.TXTState;

/**
 * This keeps all information about borders for current processed page.
 */
public class BorderManager {

    /** Matrix for storing information about one border element. */
    private AbstractBorderElement[][] borderInfo;

    /** Width of current processed border. */
    private int width;
    
    /** Height of current processed border. */
    private int height;

    /** x-coordinate of upper left point of current processed border. */
    private int startX;

    /** y-coordinate of upper left point of current processed border. */
    private int startY;

    /** Stores TXTState for transforming border elements. */
    private TXTState state;

    /**
     * Constructs BorderManger, using <code>pageWidth</code> and 
     * <code>pageHeight</code> for creating <code>borderInfo</code>.
     *  
     * @param pageWidth page width
     * @param pageHeight page height
     * @param state TXTState
     */
    public BorderManager(int pageWidth, int pageHeight, TXTState state) {
        this.state = state;
        borderInfo = new AbstractBorderElement[pageHeight][pageWidth];
    }

    /**
     * Adds border element to <code>borderInfo</code>.
     * 
     * @param x x-coordinate
     * @param y y-coordinate
     * @param style border-style
     * @param type border element type, binary representation of wich gives 
     *         information about availability or absence of corresponding side. 
     */
    public void addBorderElement(int x, int y, int style, int type) {
        AbstractBorderElement be = null;

        if (style == Constants.EN_SOLID || style == Constants.EN_DOUBLE) {
            be = new SolidAndDoubleBorderElement(style, type);
        } else if (style == Constants.EN_DOTTED) {
            be = new DottedBorderElement();
        } else if (style == Constants.EN_DASHED) {
            be = new DashedBorderElement(type);
        } else {
            return;
        }
        be.transformElement(state);

        if (borderInfo[y][x] != null) {
            borderInfo[y][x] = borderInfo[y][x].merge(be);
        } else {
            borderInfo[y][x] = be;
        }
    }

    /**
     * @param x x-coordinate
     * @param y y-coordinate
     * @return if border element at point (x,y) is available, returns instance 
     * of Character, created on char, given by corresponding border element, 
     * otherwise returns null. 
     */
    public Character getCharacter(int x, int y) {
        Character c = null;
        if (borderInfo[y][x] != null) {
            c = new Character(borderInfo[y][x].convert2Char());
        }
        return c;
    }

    /**
     * @return width of current processed border.
     */
    public int getWidth() {
        return width;
    }
    
    /**
     * Sets width of current processed border.
     * @param width width of border
     */
    public void setWidth(int width) {
        this.width = width;
    }
    
    /**
     * @return height of current processed border.
     */
    public int getHeight() {
        return height;
    }

    /**
     * Sets height of current processed border.
     * @param height height of border
     */
    public void setHeight(int height) {
        this.height = height;
    }

    /**
     * @return x-coordinate of upper left point of current processed border.
     */
    public int getStartX() {
        return startX;
    }

    /**
     * Sets x-coordinate of upper left point of current processed border.
     * @param startX x-coordinate of upper left border's point.
     */
    public void setStartX(int startX) {
        this.startX = startX;
    }

    /**
     * @return y-coordinate of upper left point of current processed border.
     */
    public int getStartY() {
        return startY;
    }

    /**
     * Sets y-coordinate of upper left point of current processed border.
     * @param startY y-coordinate of upper left border's point.
     */
    public void setStartY(int startY) {
        this.startY = startY;
    }
}




/*
 * Copyright 2005 The Apache Software Foundation.
 *
 * Licensed 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$ */

package org.apache.fop.render.txt.border;

import java.awt.Point;
import java.util.Arrays;

import org.apache.fop.area.CTM;
import org.apache.fop.fo.Constants;
import org.apache.fop.render.txt.TXTState;

/**
 * This class keeps information about abstract border element, i.e. specifies
 * border element for one text position.
 */
public abstract class AbstractBorderElement implements Constants {

    /**
     * Constant for a line segment, directing from a center of symbol up 
     * the the symbol boundary.
     */
    public static final int UP = 0;

    /**
     * Constant for a line segment, directing from a center of symbol right 
     * the the symbol boundary.
     */
    public static final int RIGHT = 1;

    /**
     * Constant for a line segment, directing from a center of symbol down 
     * the the symbol boundary.
     */
    public static final int DOWN = 2;

    /**
     * Constant for a line segment, directing from a center of symbol left 
     * the the symbol boundary.
     */
    public static final int LEFT = 3;

    /**
     * I-th element of this array specify, if there line from center of symbol
     * to corresponding side (UP, RIGHT, DOWN, LEFT).
     */
    protected int[] data = {0, 0, 0, 0};

    /**
     * Initializes a newly created <code>AbstractBorderElement</code> object 
     * so that it represents an empty border element.
     */
    public AbstractBorderElement() {
    }

    /**
     * Constructs a newly allocated <code>AbstractBorderElement</code> object.
     * Fills array <code>data</code> using binary representation of 
     * <code>type</code>.
     * 
     * @param type binary representation of type gives <code>data</code>
     */
    public AbstractBorderElement(int type) {
        for (int i = 0; i < 4; i++) {
            data[i] = (type >> i) & 1;
        }
    }

    /**
     * Returns value of side's element of <code>data</code>.
     * 
     * @param side integer, representing side
     * @return value of side's element
     */
    public int getData(int side) {
        return data[side];
    }

    /**
     * Sets a value for <code>data[side]</code>.
     * 
     * @param side integer, representing side
     * @param value a new value for <code>data[side]</code>
     */
    public void setData(int side, int value) {
        data[side] = value;
    }

    /**
     * Transform border element in according with <code>state</code>.
     * @param state instance of TXTState
     */
    public void transformElement(TXTState state) {
        // here we'll get CTM^-1 without shift
        double[] da = state.getResultCTM().toArray();
        CTM ctm = new CTM(da[0], -da[1], -da[2], da[3], 0, 0);

        Point[] pa = new Point[4];
        pa[0] = new Point(0, data[UP]);
        pa[1] = new Point(data[RIGHT], 0);
        pa[2] = new Point(0, -data[DOWN]);
        pa[3] = new Point(-data[LEFT], 0);

        Arrays.fill(data, 0);
        for (int i = 0; i < 4; i++) {
            Point p = state.transformPoint(pa[i], ctm);

            int length = (int) p.distance(0, 0);
            if (p.x == 0 && p.y > 0) {
                data[UP] = length;
            } else if (p.x == 0 && p.y < 0) {
                data[DOWN] = length;
            } else if (p.x > 0 && p.y == 0) {
                data[RIGHT] = length;
            } else if (p.x < 0 && p.y == 0) {
                data[LEFT] = length;
            }
        }
    }

    /**
     * Merges with border element.
     * @param e instance of AbstractBorderElement
     * @return instance of AbstractBorderElement
     */
    public abstract AbstractBorderElement merge(AbstractBorderElement e);

    /**
     * Convert internal representation of border element to char.
     * @return corresponding char
     */
    public abstract char convert2Char();
}




/*
 * Copyright 2005 The Apache Software Foundation.
 *
 * Licensed 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$ */

package org.apache.fop.render.txt.border;

/**
 * This class is responsible for managing of dotted border elements.
 */
public class DottedBorderElement extends AbstractBorderElement {
    
    private static final char MIDDLE_DOT = '\u00B7';

    /**
     * Merges dotted border element with another border element. Here merging
     * is quite simple: returning <code>this</code> without any comparing.
     * 
     * @param e instance of AbstractBorderElement
     * @return instance of DottedBorderElement
     */
    public AbstractBorderElement merge(AbstractBorderElement e) {
        return this;
    }

    /**
     * @see org.apache.fop.render.txt.border.AbstractBorderElement#convert2Char()
     */
    public char convert2Char() {
        return MIDDLE_DOT;
    }
}




/*
 * Copyright 2005 The Apache Software Foundation.
 *
 * Licensed 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$ */

package org.apache.fop.render.txt;

/**
 * This class has a few convenient static methods for number quantization.
 */
public final class Helper {

    /**
     * Don't let anyone instantiate this class.
     */
    private Helper() { }

    /**
     * Returns nearest integer to <code>x</code>, divisible by 
     * <code>quantum</code>. 
     * 
     * @param x integer for quantization
     * @param quantum integer, representing quantization
     * @return computed nearest integer
     */
    public static int round(int x, int quantum) {
        int ceil = ceil(x, quantum);
        int floor = floor(x, quantum);
        return (ceil - x < x - floor) ? ceil : floor;
    }

    /**
     * Returns minimal possible integer, greater or equal than 
     * <code>x</code>, divisible by <code>quantum</code>.
     *         
     * @param x integer for quantization
     * @param quantum integer, representing quantization
     * @return computed nearest integer
     */
    public static int ceil(int x, int quantum) {
        int dx = (x < 0) || (x % quantum == 0) ? 0 : 1;
        return (x / quantum + dx) * quantum;
    }

    /**
     * Returns maximum possible integer, less or equal than
     * <code>oldValue</code>, divisible by <code>quantum</code>.
     * 
     * @param x integer for quantization
     * @param quantum integer, representing quantization
     * @return computed nearest integer
     */
    public static int floor(int x, int quantum) {
        int dx = (x > 0) || (x % quantum == 0) ? 0 : -1;
        return (x / quantum + dx) * quantum;
    }

    /**
     * Returns the closest integer to <code>x/y</code> fraction.
     * It's possible to consider this methos as a analog of Math.round(x/y), 
     * without having deal with non-integer.
     * 
     * @param x integer, fraction numerator
     * @param y  integer, fraction denominator
     * @return the value of the fraction rounded to the nearest
     * @see java.lang.Math#round(double)
     */
    public static int roundPosition(int x, int y) {
        return round(x, y) / y;
    }

    /**
     * Returns the smallest integer that is greater than or equal to the 
     * <code>x/y</code> fraction.
     * It's possible to consider this function as a analog of Math.ceil(x/y), 
     * without having deal with non-integer.
     * 
     * @param x integer, fraction numerator
     * @param y  integer, fraction denominator
     * @return the smallest integer that is greater than or equal to 
     *         <code>x/y</code> fraction
     * @see java.lang.Math#ceil(double)
     */
    public static int ceilPosition(int x, int y) {
        return ceil(x, y) / y;
    }
    
    
    /**
     * Returns the largest integer that is less than or equal to the
     * argument and is equal to <code>x/y</code> fraction.
     * It's possible to consider this function as a analog of Math.floor(x/y), 
     * without having deal with non-integer.
     * 
     * @param x integer, fraction numerator
     * @param y integer, fraction denominator
     * @return the largest integer that is less than or equal to 
     *            the argument and is equal to <code>x/y</code> fraction
     * @see java.lang.Math#ceil(double)
     */
    public static int floorPosition(int x, int y) {
        return floor(x, y) / y;
    }
}




/*
 * Copyright 2005 The Apache Software Foundation.
 *
 * Licensed 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$ */

package org.apache.fop.render.txt;

import java.io.OutputStream;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

import org.apache.fop.apps.FOPException;
import org.apache.fop.apps.FOUserAgent;
import org.apache.fop.area.AreaTreeHandler;
import org.apache.fop.datatypes.CompoundDatatype;
import org.apache.fop.datatypes.Length;
import org.apache.fop.datatypes.PercentBaseContext;
import org.apache.fop.fo.Constants;
import org.apache.fop.fo.FONode;
import org.apache.fop.fo.FOText;
import org.apache.fop.fo.expr.NumericProperty;
import org.apache.fop.fo.expr.RelativeNumericProperty;
import org.apache.fop.fo.flow.Block;
import org.apache.fop.fo.flow.BlockContainer;
import org.apache.fop.fo.flow.ExternalGraphic;
import org.apache.fop.fo.flow.Inline;
import org.apache.fop.fo.flow.ListBlock;
import org.apache.fop.fo.flow.ListItem;
import org.apache.fop.fo.flow.PageNumber;
import org.apache.fop.fo.flow.Table;
import org.apache.fop.fo.flow.TableCell;
import org.apache.fop.fo.flow.TableColumn;
import org.apache.fop.fo.pagination.PageSequence;
import org.apache.fop.fo.properties.CommonAbsolutePosition;
import org.apache.fop.fo.properties.CommonBorderPaddingBackground;
import org.apache.fop.fo.properties.CommonFont;
import org.apache.fop.fo.properties.CommonMarginBlock;
import org.apache.fop.fo.properties.FixedLength;
import org.apache.fop.fo.properties.Property;
import org.apache.fop.fo.properties.SpaceProperty;
import org.apache.fop.layoutmgr.BlockLayoutManager;

/**
 * Handler for formatting objects in case of rendering to txt.
 * 
 * This handler gets page-sequence, modifies formatting objects and return them
 * to superclass. So areas are generated from modified FO. Idea of modifying is
 * to quantize FO properties, making them divisible by width of char or height 
 * of char.
 */
public class TXTHandler extends AreaTreeHandler {

    /** Percent base context. Needed for line-height. */
    private static final PercentBaseContext CONTEXT 
        = new BlockLayoutManager(new Block(null));

    /** Modified font size in millipoints. */
    private static final int MODIFIED_FONT_SIZE = 10000;

    /** Quantum for each side (BEFORE, AFTER, START, END). */
    private final int[] quantum = {TXTRenderer.CHAR_HEIGHT,
            TXTRenderer.CHAR_HEIGHT, TXTRenderer.CHAR_WIDTH,
            TXTRenderer.CHAR_WIDTH};

    /** Keeps overpatching for each side. */
    private int[] overPatching = new int[4];

    /**
     * Keeps last overpatching for each side. Needed for selective modifying of
     * start-indent and end-indent.
     */
    private int[] lastOverPatching = new int[4];

    /**
     * Constructs a newly allocated <code>TXTHandler</code> object.
     * 
     * @param userAgent FOUserAgent
     * @param stream OutputStream
     * @throws FOPException if the RenderPagesModel cannot be created
     */
    public TXTHandler(FOUserAgent userAgent, OutputStream stream)
            throws FOPException {
        super(userAgent, Constants.RENDER_TXT, stream);
    }

    /**
     * Sets a component <code>CP_LENGTH</code> of <code>cd</code> to
     * <code>value</code>.

     * @param cd  CompoundDatatype
     * @param value  new integer value
     */
    private static void setLength(CompoundDatatype cd, int value) {
        cd.setComponent(Constants.CP_LENGTH, new FixedLength(value), true);
    }

    /**
     * Sets components <code>CP_MINIMUM, CP_OPTIMUM, CP_MAXIMUM</code> of
     * <code>cd</code> to <code>p</code>.
     * 
     * @param cd instance of CompoundDatatype for modifying.
     * @param p  property for setting.
     */
    private static void setMinOptMax(CompoundDatatype cd, Property p) {
        cd.setComponent(Constants.CP_MINIMUM, p, true);
        cd.setComponent(Constants.CP_OPTIMUM, p, true);
        cd.setComponent(Constants.CP_MAXIMUM, p, true);
    }

    /**
     * Modifies border of side. If there is no border of given side, does
     * nothing, otherwise sets border-width to half of char width or char height
     * depending on side. <p> 
     * Difference between values of new border-width and old border-width is 
     * saved in <code>lastOverPatching</code>.
     * 
     * @param side side to modify.
     * @param bpb instance of CommonBorderPaddingBackground for modifying.
     */
    private void modifyBorder(int side, CommonBorderPaddingBackground bpb) {
        CommonBorderPaddingBackground.BorderInfo bi = bpb.getBorderInfo(side);

        if (bi != null) {
            int width = bpb.getBorderWidth(side, false);
            setLength(bi.getWidth(), quantum[side] / 2);
            lastOverPatching[side] += bpb.getBorderWidth(side, false) - width;
        }
    }

    /**
     * Modifies padding of side. First rounds padding to nearest integer,
     * divisible by char width or char height depending on side. If border of
     * given side is available, modifies padding in such a way, so sum of border
     * width and padding will be divisible by char width or char height,
     * depending on side. <p>
     * Difference between values of new padding and old padding is saved 
     * in <code>lastOverPatching</code>.
     * 
     * @param side side to modify.
     * @param bpb instance of CommonBorderPaddingBackground for modifying.
     */
    private void modifyPadding(int side, CommonBorderPaddingBackground bpb) {
        int oldPadding = bpb.getPadding(side, false, null);
        int newPadding = Helper.round(oldPadding, quantum[side]);
        if (bpb.getBorderInfo(side) != null) {
            newPadding = Math.max(newPadding, quantum[side])
                    - bpb.getBorderWidth(side, false);
        }

        setLength(bpb.getPaddingLengthProperty(side), newPadding);
        lastOverPatching[side] += newPadding - oldPadding;
    }

    /**
     * Modifies borders and paddings of <code>bpb</code>.
     * 
     * @param bpb instance of CommonBorderPaddingBackground for modifying.
     */
    private void modifyBPB(CommonBorderPaddingBackground bpb) {
        modifyBorder(CommonBorderPaddingBackground.BEFORE, bpb);
        modifyBorder(CommonBorderPaddingBackground.AFTER, bpb);
        modifyBorder(CommonBorderPaddingBackground.START, bpb);
        modifyBorder(CommonBorderPaddingBackground.END, bpb);

        modifyPadding(CommonBorderPaddingBackground.BEFORE, bpb);
        modifyPadding(CommonBorderPaddingBackground.AFTER, bpb);
        modifyPadding(CommonBorderPaddingBackground.START, bpb);
        modifyPadding(CommonBorderPaddingBackground.END, bpb);
    }

    /**
     * Rounds optimum value of <code>space</code> to nearest integer,
     * divisible by <code>q</code>.
     * 
     * @param space instance of SpaceProperty.
     * @param q integer.
     */
    private void modifySpace(SpaceProperty space, int q) {
        int value = space.getOptimum(null).getLength().getValue();
        setMinOptMax(space, new FixedLength(Helper.round(value, q)));
    }

    /**
     * @param length instance of Length.
     * @param q integer.
     * @return instance of Length, having value nearest to value of
     *         <code>length</code>, and divisible by <code>q</code>.
     */
    private Length roundLength(Length length, int q) {
        int x = Helper.round(length.getValue(), q);
        return new FixedLength(x);
    }

    /**
     * @param length instance of Length.
     * @param q integer.
     * @return instance of Length, having minimal value, greater value of
     *         <code>length</code>, and divisible by <code>q</code>.
     */
    private Length ceilLength(Length length, int q) {
        int x = Helper.ceil(length.getValue(), q);
        return new FixedLength(x);
    }

    /**
     * Modifies indent for given side. Summarizes value of indent and modifing
     * error (i.e. overPatching). Rounds result to nearest integer, divisible by
     * quantum.
     * 
     * @param indent Length to modify.
     * @param side an integer, representing side.
     * @return modified Length.
     */
    private Length modifyIndent(Length indent, int side) {
        if (indent instanceof NumericProperty) {
            overPatching[side] += lastOverPatching[side];
        }
        int newValue = indent.getValue() + overPatching[side];
        newValue = Helper.round(newValue, quantum[side]);
        return new FixedLength(newValue);
    }

    /**
     * Modifies Common Margin Properties-Block:
     * <ul>
     * <li>margin-top, margin-left, margin-bottom, margin-right
     * <li>start-indent, end-indent
     * <li>space-before, space-after.
     * </ul>
     * 
     * @param cmb instance of CommonMarginBlock to modify.
     */
    private void modifyCommonMarginBlock(CommonMarginBlock cmb) {
        cmb.marginTop = roundLength(cmb.marginTop, TXTRenderer.CHAR_HEIGHT);
        cmb.marginBottom = roundLength(cmb.marginBottom,
                TXTRenderer.CHAR_HEIGHT);
        cmb.marginLeft = roundLength(cmb.marginLeft, TXTRenderer.CHAR_WIDTH);
        cmb.marginRight = roundLength(cmb.marginRight, TXTRenderer.CHAR_WIDTH);

        modifySpace(cmb.spaceBefore, TXTRenderer.CHAR_HEIGHT);
        modifySpace(cmb.spaceAfter, TXTRenderer.CHAR_HEIGHT);

        if (!(cmb.startIndent instanceof RelativeNumericProperty)) {
            cmb.startIndent = modifyIndent(cmb.startIndent,
                    CommonBorderPaddingBackground.START);
        }
        if (!(cmb.endIndent instanceof RelativeNumericProperty)) {
            cmb.endIndent = modifyIndent(cmb.endIndent,
                    CommonBorderPaddingBackground.END);
        }
    }

    /**
     * Modifies fo:table attributes:
     * <ul>
     * <li>Common Margin Properties Block
     * <li>Common Border, Padding, and Background Properties
     * <li>columns.
     * </ul>
     * 
     * @param table Table to modify.
     */
    private void modifyTable(Table table) {
        CommonMarginBlock cmb = table.getCommonMarginBlock();
        if (table.getBorderCollapse() == Constants.EN_COLLAPSE) {
            // If border-collapse == "collapse", add space-after in order to
            // impove interaction with other FO.
            int value = cmb.spaceAfter.getOptimum(null).getLength().getValue();
            value += TXTRenderer.CHAR_HEIGHT;
            setMinOptMax(cmb.spaceAfter, new FixedLength(value));
        }
        modifyCommonMarginBlock(cmb);

        modifyBPB(table.getCommonBorderPaddingBackground());

        // modify all table-columns
        List columnList = table.getColumns();
        Iterator iter = columnList.iterator();
        while (iter.hasNext()) {
            modifyTableColumn((TableColumn) iter.next());
        }
    }

    /**
     * Modifies fo:table-column attributes:
     * <ul>
     * <li>width.
     * </ul>
     * 
     * @param column TableColumn to modify.
     */
    private void modifyTableColumn(TableColumn column) {
        column.setColumnWidth(ceilLength(column.getColumnWidth(), 
                TXTRenderer.CHAR_WIDTH));
    }

    /**
     * Modifies padding of fo:table-cell.
     * 
     * @param side side.
     * @param bpb instance of CommonBorderPaddingBackground to modify.
     */
    private void modifyCellPadding(int side, CommonBorderPaddingBackground bpb) {
        if (bpb.getBorderInfo(side) == null) {
            int oldPadding = bpb.getPadding(side, false, null);
            int newPadding = oldPadding + quantum[side] / 2;
            setLength(bpb.getPaddingLengthProperty(side), newPadding);
        }
    }

    /**
     * Modifies table-cell properties:
     * <ul>
     * <li>Common Border, Padding, and Background Properties.
     * </ul>
     * 
     * @param c TableCell to modify.
     */
    private void modifyTableCell(TableCell c) {
        CommonBorderPaddingBackground bpb = c
                .getCommonBorderPaddingBackground();
        modifyBPB(bpb);
        modifyCellPadding(CommonBorderPaddingBackground.BEFORE, bpb);
        modifyCellPadding(CommonBorderPaddingBackground.AFTER, bpb);
        modifyCellPadding(CommonBorderPaddingBackground.START, bpb);
        modifyCellPadding(CommonBorderPaddingBackground.END, bpb);
    }

    /**
     * Modifies Common Absolute Position Properties:
     * <ul>
     * <li>left
     * <li>top.
     * </ul>
     * 
     * @param cap CommonAbsolutePosition to modify.
     */
    private void modifyCommonAbsolutePosition(CommonAbsolutePosition cap) {
        if (cap.absolutePosition == Constants.EN_ABSOLUTE) {
            cap.left = roundLength(cap.left, TXTRenderer.CHAR_WIDTH);
            cap.top = roundLength(cap.top, TXTRenderer.CHAR_HEIGHT);
        }
    }

    /**
     * Modifies line-height property. Sets a value of line-height to max(char
     * height; lowest integer, divisible by char height).
     * 
     * @param lineHeight SpaceProperty to modify.
     */
    private void modifyLineHeight(SpaceProperty lineHeight) {
        Property p = lineHeight.getOptimum(null);
        int value = p.getLength().getValue(CONTEXT);

        int height = TXTRenderer.CHAR_HEIGHT;
        int newValue = Math.max(Helper.floor(value, height), height);
        setMinOptMax(lineHeight, new FixedLength(newValue));
    }

    /**
     * Modifies Common Font Properties:
     * <ul>
     * <li>font-family = Courier;
     * <li>font-size = MODIFIED_FONT_SIZE;
     * <li>font-stretch = EN_NORMAL;
     * <li>font-weight = EN_NORMAL.
     * </ul>
     * 
     * @param cf the font to modify.
     */
    private void modifyCommonFont(CommonFont cf) {
        if (cf != null) {
            cf.fontFamily = "Courier";
            cf.fontSize = new FixedLength(MODIFIED_FONT_SIZE);
            cf.fontStretch = Constants.EN_NORMAL;
            cf.fontWeight = Constants.EN_NORMAL;
        }
    }

    /**
     * Modifies fo:block:
     * <ul>
     * <li>Common Border, Padding, and Background Properties
     * <li>Common Margin Properties-Block
     * <li>Common Font Properties
     * <li>line-height.
     * </ul>
     * 
     * @param block Block to modify.
     */
    private void modifyBlock(Block block) {
        modifyBPB(block.getCommonBorderPaddingBackground());
        modifyCommonMarginBlock(block.getCommonMarginBlock());
        modifyCommonFont(block.getCommonFont());
        modifyLineHeight(block.getLineHeight());
    }

    /**
     * Modifies fo:block-container:
     * <ul>
     * <li>Common Border, Padding, and Background Properties
     * <li>Common Margin Properties-Block
     * <li>Common Absolute Position Properties.
     * </ul>
     * 
     * @param bc BlockContainer to modify.
     */
    private void modifyBlockContainer(BlockContainer bc) {
        modifyBPB(bc.getCommonBorderPaddingBackground());
        modifyCommonMarginBlock(bc.getCommonMarginBlock());
        modifyCommonAbsolutePosition(bc.getCommonAbsolutePosition());
    }

    /**
     * Modifies fo:inline:
     * <ul>
     * <li>Common Font Properties
     * </ul>
     * 
     * @param inline Inline to modify.
     */
    private void modifyInline(Inline inline) {
        modifyCommonFont(inline.getCommonFont());
    }

    /**
     * Modifies FOText:
     * <ul>
     * <li>Common Font Properties
     * </ul>
     * 
     * @param text FOText to modify.
     */
    private void modifyFOText(FOText text) {
        modifyCommonFont(text.getCommonFont());
    }

    /**
     * Modifies fo:external-graphic:
     * <ul>
     * <li>Common Border, Padding, and Background Properties
     * <li>line-height.
     * </ul>
     * 
     * @param eg ExternalGraphic to modify.
     */
    private void modifyExternalGraphic(ExternalGraphic eg) {
        modifyBPB(eg.getCommonBorderPaddingBackground());
        modifyLineHeight(eg.getLineHeight());
    }

    /**
     * Modifies fo:list-block:
     * <ul>
     * <li>Common Border, Padding, and Background Properties
     * <li>Common Margin Properties-Block.
     * </ul>
     * 
     * @param lb ListBlock to modify.
     */
    private void modifyListBlock(ListBlock lb) {
        modifyBPB(lb.getCommonBorderPaddingBackground());
        modifyCommonMarginBlock(lb.getCommonMarginBlock());
    }

    /**
     * Modifies fo:list-item:
     * <ul>
     * <li>Common Border, Padding, and Background Properties
     * <li>Common Margin Properties-Block.
     * </ul>
     * <p>
     * Make refinement for fo:list-item-label and fo:list-item-body.
     * 
     * @param li ListItem to modify.
     */
    private void modifyListItem(ListItem li) {
        modifyBPB(li.getCommonBorderPaddingBackground());
        modifyCommonMarginBlock(li.getCommonMarginBlock());
        refinement(li.getLabel());
        refinement(li.getBody());
    }
    
    /**
     * Does refinement for particular node. Modifies node's properties and
     * refines its children recursively.
     * 
     * @param node the node to refine.
     */
    private void refinement(FONode node) {
        int[] saveOverPatching = (int[]) overPatching.clone();
        Arrays.fill(lastOverPatching, 0);

        if (node instanceof Block) {
            modifyBlock((Block) node);
        } else if (node instanceof BlockContainer) {
            modifyBlockContainer((BlockContainer) node);
        } else if (node instanceof Inline) {
            modifyInline((Inline) node);
        } else if (node instanceof FOText) {
            modifyFOText((FOText) node);
        } else if (node instanceof Table) {
            modifyTable((Table) node);
            Arrays.fill(overPatching, 0);
        } else if (node instanceof TableCell) {
            modifyTableCell((TableCell) node);
        } else if (node instanceof ExternalGraphic) {
            modifyExternalGraphic((ExternalGraphic) node);
        } else if (node instanceof ListBlock) {
            modifyListBlock((ListBlock) node);
        } else if (node instanceof ListItem) {
            modifyListItem((ListItem) node);
        } else if (node instanceof PageNumber) {
            modifyCommonFont(((PageNumber) node).getCommonFont());
        }

        Iterator it = node.getChildNodes();
        if (it != null) {
            while (it.hasNext()) {
                refinement((FONode) it.next());
            }
        }
        overPatching = saveOverPatching;
    }

    /**
     * Run refinement for:
     * <ul>
     * <li>mainflow (xsl-region-body)
     * <li>staticflow (xsl-region-before, xsl-region-after, xsl-region-start,
     * xsl-region-end).
     * </ul>
     * 
     * @param pageSequence PageSequence to refine.
     */
    public void endPageSequence(PageSequence pageSequence) {
        Arrays.fill(overPatching, 0);

        refinement(pageSequence.getMainFlow());

        if (pageSequence.getStaticContent("xsl-region-before") != null) {
            refinement(pageSequence.getStaticContent("xsl-region-before"));
        }
        if (pageSequence.getStaticContent("xsl-region-after") != null) {
            refinement(pageSequence.getStaticContent("xsl-region-after"));
        }
        if (pageSequence.getStaticContent("xsl-region-start") != null) {
            refinement(pageSequence.getStaticContent("xsl-region-start"));
        }
        if (pageSequence.getStaticContent("xsl-region-end") != null) {
            refinement(pageSequence.getStaticContent("xsl-region-end"));
        }

        super.endPageSequence(pageSequence);
    }
}




 
package org.apache.fop.render.txt;

import java.awt.Point;
import java.awt.geom.Rectangle2D;
import java.io.IOException;
import java.io.OutputStream;
import java.util.List;

import org.apache.fop.apps.FOPException;
import org.apache.fop.area.Area;
import org.apache.fop.area.CTM;
import org.apache.fop.area.PageViewport;
import org.apache.fop.area.inline.Image;
import org.apache.fop.area.inline.TextArea;
import org.apache.fop.datatypes.ColorType;
import org.apache.fop.render.AbstractPathOrientedRenderer;
import org.apache.fop.render.txt.border.AbstractBorderElement;
import org.apache.fop.render.txt.border.BorderManager;

/**
 * Renderer that renders areas to plain text.
 * 
 * @author Art Welch
 * @author <a href="mailto:mark-fop@inomial.com">Mark Lillywhite</a> (to use
 *         the new Renderer interface)
 */
public class TXTRenderer extends AbstractPathOrientedRenderer {
    
    private static final char LIGHT_SHADE = '\u2591';
    
    private static final char MEDIUM_SHADE = '\u2592';
    
    private static final char DARK_SHADE = '\u2593';

    private static final char FULL_BLOCK = '\u2588';
    public static final String MIME_TYPE = "text/plain";

    private static final char IMAGE_CHAR = '#';
     * the current stream to add Text commands to
     */
    private PCLStream currentStream;

    /**The stream for output */
    private OutputStream outputStream;

    /** The current stream to add Text commands to. */
    private TXTStream currentStream;
    private int divisions = -1;
    private int paperheight = -1;    // Paper height in decipoints?
    private int orientation = -1;    // -1=default/unknown, 0=portrait, 1=landscape.
    private int topmargin = -1;      // Top margin in decipoints?
    private int leftmargin = -1;     // Left margin in decipoints?
    private int fullmargin = 0;
    private final boolean debug = false;

    /** Buffer for text. */
    private StringBuffer[] charData;

    /** Buffer for background and images. */
    private StringBuffer[] decoData;

    /** Height of one symbol in Courier font size of 10pt. */
    public static final int CHAR_HEIGHT = 7860;

    /** Width of one symbol in Courier font size of 10pt. */
    public static final int CHAR_WIDTH = 6000;

    /** Current processing page width. */
    private int pageWidth;

    /** Current processing page height. */
    private int pageHeight;

    /**
     * Every line except the last line on a page (which will end with
     * pageEnding) will be terminated with this string.
     */
    private String lineEnding = "\r\n";

    /** Every page except the last one will end with this string. */
     */
    private String pageEnding = "\f";

    /** Equals true, if current page is first. */
    private boolean firstPage = false;

    /** Manager for storing border's information. */
    private BorderManager bm;
    
    /** Char for current filling. */
    private char fillChar;

    /** Saves current coordinate transformation. */
    private TXTState currentState = new TXTState();

    /**
     * Constructs a newly allocated <code>TXTRenderer</code> object.
     */
    public TXTRenderer() {
    }

    /**
     * Indicates if point (x, y) lay inside currentPage.
     * 
     * @param x x coordinate
     * @param y y coordinate
     * @return <b>true</b> if point lay inside page
     */
    public boolean isLayInside(int x, int y) {
        return (x >= 0) && (x < pageWidth) && (y >= 0) && (y < pageHeight);
    }

    /**
     * Add char to text buffer.
     * 
     * @param x  x coordinate
     * @param y  y coordinate
     * @param ch  char to add
     * @param ischar boolean, repersenting is character adding to text buffer
     */
    protected void addChar(int x, int y, char ch, boolean ischar) {
        Point point = currentState.transformPoint(x, y);
        putChar(point.x, point.y, ch, ischar);
    }

    /**
     * Add char to text or background buffer.
     * 
     * @param x x coordinate
     * @param y x coordinate
     * @param ch char to add
     * @param ischar indicates if it char or background
     */
    protected void putChar(int x, int y, char ch, boolean ischar) {
        if (isLayInside(x, y)) {
            StringBuffer sb = ischar ? charData[y] : decoData[y];
            while (sb.length() <= x) {
                sb.append(' ');
            }
            sb.setCharAt(x, ch);
        }
    }

    /**
     * Adds string to text buffer (<code>charData</code>). <p>
     * Chars of string map in turn.
     * 
     * @param row x coordinate
     * @param col y coordinate
     * @param s string to add
     */
    protected void addString(int row, int col, String s) {
        for (int l = 0; l < s.length(); l++) {
            addChar(col + l, row, s.charAt(l), true);
        }
    }

    /**
     * Render TextArea to Text.
     * 
     * @param area  inline area to render
     */
    protected void renderText(TextArea area) {
        int col = Helper.ceilPosition(this.currentIPPosition, CHAR_WIDTH);
        int row = Helper.ceilPosition(this.currentBPPosition, CHAR_HEIGHT);

        String s = area.getText();

        addString(row, col, s);

        super.renderText(area);
    }

    /**
     * @see org.apache.fop.render.Renderer#renderPage(PageViewport)
     */
    public void renderPage(PageViewport page) throws IOException, FOPException {
        if (firstPage) {
            firstPage = false;
        } else {
            currentStream.add(pageEnding);
        }

        Rectangle2D bounds = page.getViewArea();
        double width = bounds.getWidth();
        double height = bounds.getHeight();

        pageWidth = Helper.ceilPosition((int) width, CHAR_WIDTH);
        pageHeight = Helper.ceilPosition((int) height, CHAR_HEIGHT);
        
        // init buffers
        charData = new StringBuffer[pageHeight];
        decoData = new StringBuffer[pageHeight];
        for (int i = 0; i < pageHeight; i++) {
            charData[i] = new StringBuffer();
            decoData[i] = new StringBuffer();
        }

        bm = new BorderManager(pageWidth, pageHeight, currentState);

        super.renderPage(page);

        flushBorderToBuffer();
        flushBuffer();
    }

    /**
     * Projects current page borders (i.e.<code>bm</code>) to buffer for 
     * background and images (i.e.<code>decoData</code>). 
     */
    private void flushBorderToBuffer() {
        for (int x = 0; x < pageWidth; x++) {
            for (int y = 0; y < pageHeight; y++) {
                Character c = bm.getCharacter(x, y);
                if (c != null) {
                    putChar(x, y, c.charValue(), false);
                }
            }
        }
    }

    /**
     * Write out the buffer to output stream.
     */
    private void flushBuffer() {
        for (int row = 0; row < pageHeight; row++) {
            StringBuffer cr = charData[row];
            StringBuffer dr = decoData[row];
            StringBuffer outr = null;

            if (cr != null && dr == null) {
                outr = cr;
            } else if (dr != null && cr == null) {
                outr = dr;
            } else if (cr != null && dr != null) {
                int len = dr.length();
                if (cr.length() > len) {
                    len = cr.length();
                }
                outr = new StringBuffer();
                for (int countr = 0; countr < len; countr++) {
                    if (countr < cr.length() && cr.charAt(countr) != ' ') {
                        outr.append(cr.charAt(countr));
                    } else if (countr < dr.length()) {
                        outr.append(dr.charAt(countr));
                    } else {
                        outr.append(' ');
                    }
                }
            }

            if (outr != null) {
                currentStream.add(outr.toString());
            }
            if (row < pageHeight) {
                currentStream.add(lineEnding);
            }
        }
    }

    /**
     * @see org.apache.fop.render.Renderer#startRenderer(java.io.OutputStream)
     */
    public void startRenderer(OutputStream os) throws IOException {
        log.info("Rendering areas to TEXT.");
        this.outputStream = os;
        currentStream = new TXTStream(os);
        firstPage = true;
    }

    /**
     * @see org.apache.fop.render.Renderer#stopRenderer()
     */
    public void stopRenderer() throws IOException {
        log.info("writing out TEXT");
        outputStream.flush();
        super.stopRenderer();
    }

    /**
     * Does nothing.
     * @see org.apache.fop.render.AbstractPathOrientedRenderer
     */
    protected void restoreStateStackAfterBreakOut(List breakOutList) {
    }

    /**
     * Does nothing.
     * @return null
     * @see org.apache.fop.render.AbstractPathOrientedRenderer
     */
    protected List breakOutOfStateStack() {
        return null;
    }

    /**
     * Does nothing.
     * @see org.apache.fop.render.AbstractPathOrientedRenderer
     */
    protected void saveGraphicsState() {
    }

    /**
     * Does nothing.
     * @see org.apache.fop.render.AbstractPathOrientedRenderer
     */
    protected void restoreGraphicsState() {
    }

    /**
     * Does nothing.
     * @see org.apache.fop.render.AbstractPathOrientedRenderer
     */
    protected void beginTextObject() {
    }

    /**
     * Does nothing.
     * @see org.apache.fop.render.AbstractPathOrientedRenderer
     */
    protected void endTextObject() {
    }

    /**
     * Does nothing.
     * @see org.apache.fop.render.AbstractPathOrientedRenderer
     */
    protected void clip() {
    }

    /**
     * Does nothing.
     * @see org.apache.fop.render.AbstractPathOrientedRenderer
     */
    protected void clipRect(float x, float y, float width, float height) {
    }

    /**
     * Does nothing. 
     * @see org.apache.fop.render.AbstractPathOrientedRenderer
     */
    protected void moveTo(float x, float y) {
    }

    /**
     * Does nothing. 
     * @see org.apache.fop.render.AbstractPathOrientedRenderer
     */
    protected void lineTo(float x, float y) {
    }

    /**
     * Does nothing.
     * @see org.apache.fop.render.AbstractPathOrientedRenderer
     */
    protected void closePath() {
    }

    /**
     * Fills rectangle startX, startY, width, height with char 
     * <code>charToFill</code>.
     * 
     * @param startX x-coordinate of upper left point
     * @param startY y-coordinate of upper left point
     * @param width width of rectangle
     * @param height height of rectangle
     * @param charToFill filling char 
     */
    private void fillRect(int startX, int startY, int width, int height, 
            char charToFill) {
        for (int x = startX; x < startX + width; x++) {
            for (int y = startY; y < startY + height; y++) {
                addChar(x, y, charToFill, false);
            }
        }
    }
    
    /**
     * Fills a rectangular area with the current filling char.
     * @see org.apache.fop.render.AbstractPathOrientedRenderer
     */
    protected void fillRect(float x, float y, float width, float height) {
        fillRect(bm.getStartX(), bm.getStartY(), bm.getWidth(), bm.getHeight(),
                fillChar);
    }
    
    /**
     * Changes current filling char.
     * @see org.apache.fop.render.AbstractPathOrientedRenderer
     */
    protected void updateColor(ColorType col, boolean fill) {
        if (col == null) {
            return;
        }
        // fillShade evaluation was taken from fop-0.20.5 
        double fillShade = 0.30f * col.getRed() 
                         + 0.59f * col.getGreen() 
                         + 0.11f * col.getBlue();
        fillShade = 1 - fillShade;
        
        if (fillShade > 0.8f) {
            fillChar = FULL_BLOCK;
        } else if (fillShade > 0.6f) {
            fillChar = DARK_SHADE;
        } else if (fillShade > 0.4f) {
            fillChar = MEDIUM_SHADE;
        } else if (fillShade > 0.2f) {
            fillChar = LIGHT_SHADE;
        } else {
            fillChar = ' ';
        }
    }

    /** 
     * Does nothing. 
     * @param url  String
     * @param pos  Rectangle2D
     */
    protected void drawImage(String url, Rectangle2D pos) {
    }
    
    /**
     * Fills image rectangle with a <code>IMAGE_CHAR</code>.
     * @see org.apache.fop.render.AbstractPathOrientedRenderer
     */
    public void renderImage(Image image, Rectangle2D pos) {
        int x1 = Helper.ceilPosition(currentIPPosition, CHAR_WIDTH);
        int y1 = Helper.ceilPosition(currentBPPosition, CHAR_HEIGHT);
        int width = Helper.ceilPosition((int) pos.getWidth(), CHAR_WIDTH);
        int height = Helper.ceilPosition((int) pos.getHeight(), CHAR_HEIGHT);
        
        fillRect(x1, y1, width, height, IMAGE_CHAR);
    }

    
    /**
     * Returns the closest integer to the multiplication of a number and 1000.
     * 
     * @param x  the value of the argument, multiplied by 
     *            1000 and rounded
     * @return the value of the argument multiplied by 
     *         1000 and rounded to the nearest integer
     */
    protected int toMilli(float x) {
        return Math.round(x * 1000f);
    }

    /**
     * Adds one element of border.
     * 
     * @param x  x coordinate
     * @param y  y coordinate
     * @param style  integer, representing border style
     * @param type  integer, representing border element type 
     */
    private void addBitOfBorder(int x, int y, int style, int type) {
        Point point = currentState.transformPoint(x, y);
        if (isLayInside(point.x, point.y)) {
            bm.addBorderElement(point.x, point.y, style, type);
        }
    }

    /**
     * @see org.apache.fop.render.AbstractPathOrientedRenderer
     */
    protected void drawBorderLine(float x1, float y1, float x2, float y2,
            boolean horz, boolean startOrBefore, int style, ColorType col) {

        int borderHeight = bm.getHeight();
        int borderWidth = bm.getWidth();
        int borderStartX = bm.getStartX();
        int borderStartY = bm.getStartY();

        int x, y;
        if (horz && startOrBefore) { // BEFORE
            x = borderStartX;
            y = borderStartY;
        } else if (horz && !startOrBefore) { // AFTER
            x = borderStartX;
            y = borderStartY + borderHeight - 1;
        } else if (!horz && startOrBefore) { // START
            x = borderStartX;
            y = borderStartY;
        } else { // END
            x = borderStartX + borderWidth - 1;
            y = borderStartY;
        }

        int dx, dy, length, startType, endType;
        if (horz) {
            length = borderWidth;
            dx = 1;
            dy = 0;
            startType = 1 << AbstractBorderElement.RIGHT;
            endType = 1 << AbstractBorderElement.LEFT;
        } else {
            length = borderHeight;
            dx = 0;
            dy = 1;
            startType = 1 << AbstractBorderElement.DOWN;
            endType = 1 << AbstractBorderElement.UP;
        }

        addBitOfBorder(x, y, style, startType);
        for (int i = 0; i < length - 2; i++) {
            x += dx;
            y += dy;
            addBitOfBorder(x, y, style, startType + endType);
        }
        x += dx;
        y += dy;
        addBitOfBorder(x, y, style, endType);
    }

    /**
     * @see org.apache.fop.render.AbstractPathOrientedRenderer 
     */
    protected void drawBackAndBorders(Area area, float startx, float starty,
            float width, float height) {
        bm.setWidth(Helper.ceilPosition(toMilli(width), CHAR_WIDTH));
        bm.setHeight(Helper.ceilPosition(toMilli(height), CHAR_HEIGHT));
        bm.setStartX(Helper.ceilPosition(toMilli(startx), CHAR_WIDTH));
        bm.setStartY(Helper.ceilPosition(toMilli(starty), CHAR_HEIGHT));

        super.drawBackAndBorders(area, startx, starty, width, height);
    }

    /**
     * @see org.apache.fop.render.AbstractRenderer#startVParea(CTM)
     */
    protected void startVParea(CTM ctm) {
        currentState.push(ctm);
    }

    /**
     * @see org.apache.fop.render.AbstractRenderer#endVParea()
     */
    protected void endVParea() {
        currentState.pop();
    }
}




/*
 * Copyright 2005 The Apache Software Foundation.
 *
 * Licensed 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$ */

package org.apache.fop.render.txt;

import java.awt.Point;
import java.awt.geom.Rectangle2D;
import java.util.Iterator;
import java.util.LinkedList;

import org.apache.fop.area.CTM;

/**
 * This keeps information about the current state when writing to txt, i.e. 
 * manages coordinate transformation matrices for getting absolute coordinates.
 */
public class TXTState {

    /** Keeps all coordinate transformation matrices during rendering. */
    private LinkedList stackCTM = new LinkedList();

    /**
     * Current result coordinate transformation matrix. It's product of 
     * all matrices in order, saved in <code>stackCTM</code>.
     */
    private CTM resultCTM = new CTM();

    /**
     * Constructs a newly allocated <code>TXTState</code> object.
     */
    public TXTState() {
    }

    /**
     * Updates result coordinate transformation matrix 
     * (i.e. <code>resultCTM</code>), multipliing it by given matrix.
     * 
     * @param ctm CTM
     */
    private void updateResultCTM(CTM ctm) {
        resultCTM = resultCTM.multiply(ctm);
    }

    /**
     * Recalculate current result coordinate transformation matrix.
     */
    private void calcResultCTM() {
        resultCTM = new CTM();
        for (Iterator i = stackCTM.iterator(); i.hasNext();) {
            updateResultCTM((CTM) i.next());
        }
    }

    /**
     * Push the current coordinate transformation matrix onto the stack and 
     * reevaluate <code>resultCTM</code>.
     * 
     * @param ctm  instance of CTM
     */
    public void push(CTM ctm) {
        stackCTM.addLast(ctm);
        updateResultCTM(ctm);
    }

    /**
     * Pop the coordinate transformation matrix from the stack and reevaluate
     * <code>resultCTM</code>.
     */
    public void pop() {
        stackCTM.removeLast();
        calcResultCTM();
    }
    
    /**
     * Modifies coordinate transformation matrix in such a way, so 
     * x-shift and y-shift will be transformed in text positions.
     * 
     * @param ctm CTM to modify
     * @return instance of CTM
     */
    public CTM refineCTM(CTM ctm) {
        double[] da = ctm.toArray();
        // refine x-shift
        da[4] = Helper.roundPosition((int) da[4], TXTRenderer.CHAR_WIDTH);
        // refine y-shift
        da[5] = Helper.roundPosition((int) da[5], TXTRenderer.CHAR_HEIGHT);
        
        return new CTM(da[0], da[1], da[2], da[3], da[4], da[5]);
    }

    /**
     * Transforms <code>point</code> using <code>ctm</code>.
     * 
     * @param p Point
     * @param ctm CTM
     * @return transformed Point
     */
    public Point transformPoint(Point p, CTM ctm) {
        Rectangle2D r = new Rectangle2D.Double(p.x, p.y, 0, 0);
        CTM nctm = refineCTM(ctm);
        r = nctm.transform(r);
        return new Point((int) r.getX(), (int) r.getY());
    }

    /**
     * Transforms point (x, y) using <code>resultCTM</code>.
     * 
     * @param x x-coordinate
     * @param y y-coordinate
     * @return transformed Point
     */
    public Point transformPoint(int x, int y) {
        return transformPoint(new Point(x, y), resultCTM);
    }

    /**
     * @return current result coordinate transformation matrix
     */
    public CTM getResultCTM() {
        return resultCTM;
    }
}

Lines 47-53 Link Here

(-)src/java/org/apache/fop/render/txt/TXTStream.java (-1 / +1 lines)
47	}	47	}
48		48
49	try {	49	try {
50	byte buff[] = str.getBytes("UTF-8");	50	byte[] buff = str.getBytes("UTF-8");
51	out.write(buff);	51	out.write(buff);
52	} catch (IOException e) {	52	} catch (IOException e) {
53	throw new RuntimeException(e.toString());	53	throw new RuntimeException(e.toString());

Return to bug 37253

Lines 33-38 Link Here

(-)src/java/org/apache/fop/render/RendererFactory.java (+3 lines)
33	import org.apache.fop.fo.FOEventHandler;	33	import org.apache.fop.fo.FOEventHandler;
34	import org.apache.fop.render.mif.MIFHandler;	34	import org.apache.fop.render.mif.MIFHandler;
35	import org.apache.fop.render.rtf.RTFHandler;	35	import org.apache.fop.render.rtf.RTFHandler;
		36	import org.apache.fop.render.txt.TXTHandler;
36		37
37	/**	38	/**
38	* Factory for FOEventHandlers and Renderers.	39	* Factory for FOEventHandlers and Renderers.
Lines 132-137 Link Here
132	return new MIFHandler(userAgent, out);	133	return new MIFHandler(userAgent, out);
133	} else if (renderType == Constants.RENDER_RTF) {	134	} else if (renderType == Constants.RENDER_RTF) {
134	return new RTFHandler(userAgent, out);	135	return new RTFHandler(userAgent, out);
		136	} else if (renderType == Constants.RENDER_TXT) {
		137	return new TXTHandler(userAgent, out);
135	} else {	138	} else {
136	if (renderType < Constants.RENDER_MIN_CONST	139	if (renderType < Constants.RENDER_MIN_CONST
137	\|\| renderType > Constants.RENDER_MAX_CONST) {	140	\|\| renderType > Constants.RENDER_MAX_CONST) {

Line 0 Link Here

(-)src/java/org/apache/fop/render/txt/border/DashedBorderElement.java (+141 lines)
		1	/*
		2	* Copyright 2005 The Apache Software Foundation.
		3	*
		4	* Licensed under the Apache License, Version 2.0 (the "License");
		5	* you may not use this file except in compliance with the License.
		6	* You may obtain a copy of the License at
		7	*
		8	* http://www.apache.org/licenses/LICENSE-2.0
		9	*
		10	* Unless required by applicable law or agreed to in writing, software
		11	* distributed under the License is distributed on an "AS IS" BASIS,
		12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		13	* See the License for the specific language governing permissions and
		14	* limitations under the License.
		15	*/
		16
		17	/* $Id$ */
		18
		19	package org.apache.fop.render.txt.border;
		20
		21	import java.util.Arrays;
		22
		23	/**
		24	* This class is responsible for managing of dashed border elements.
		25	*/
		26	public class DashedBorderElement extends AbstractBorderElement {
		27
		28	private static final char DASH_HORIZONTAL = '-';
		29
		30	private static final char DASH_VERTICAL = '\|';
		31
		32	private static final char UNDEFINED = '?';
		33
		34	private static final int UP2 = 1;
		35
		36	private static final int RIGHT2 = 2;
		37
		38	private static final int DOWN2 = 4;
		39
		40	private static final int LEFT2 = 8;
		41
		42	private static char[] map = new char[20];
		43
		44	static {
		45	Arrays.fill(map, UNDEFINED);
		46	map[0] = ' ';
		47	map[UP2] = DASH_VERTICAL;
		48	map[DOWN2] = DASH_VERTICAL;
		49	map[UP2 + DOWN2] = DASH_VERTICAL;
		50
		51	map[LEFT2] = DASH_HORIZONTAL;
		52	map[RIGHT2] = DASH_HORIZONTAL;
		53	map[LEFT2 + RIGHT2] = DASH_HORIZONTAL;
		54	}
		55
		56	/**
		57	* Constructs a newly allocated <code>DashedBorderElement</code> object.
		58	* Fills <code>data</code> using superclass constructor.
		59	*
		60	* @param type binary representation of type gives <code>data</code>
		61	*/
		62	public DashedBorderElement(int type) {
		63	super(type);
		64	}
65
66	/**
67	* Merges dashed border element with instance of solid and double border
68	* element, returns instance of <code>SolidAndDoubleBorderElement</code>.
69	*
70	* @param sdb instance of <code>SolidAndDoubleBorderElement</code> to merge
71	* @return merged border element
72	*/
73	private AbstractBorderElement mergeSolid(SolidAndDoubleBorderElement sdb) {
74	AbstractBorderElement e = new SolidAndDoubleBorderElement(EN_SOLID, 0);
75	for (int i = 0; i < 4; i++) {
76	e.setData(i, Math.max(data[i], sdb.getData(i)));
77	}
78	return e;
79	}
80
81	/**
82	* Merges dashed border element with dashed border element and returns
83	* instance of <code>DashedBorderElement</code>.
84	*
85	* @param dbe instance of <code>DashedBorderElement</code> to merge
86	* @return merged border element
87	*/
88	private AbstractBorderElement mergeDashed(DashedBorderElement dbe) {
89	for (int i = 0; i < 4; i++) {
90	data[i] = Math.max(data[i], dbe.getData(i));
91	}
92	return this;
93	}
94
95	/**
96	* Converts dashed border element to
97	* <code>SolidAndDoubleBorderElement</code>.
98	*
99	* @return converted instance of <code>SolidAndDoubleBorderElement</code>
100	*/
101	private AbstractBorderElement toSolidAndDouble() {
102	AbstractBorderElement e = new SolidAndDoubleBorderElement(EN_SOLID, 0);
103	for (int i = 0; i < 4; i++) {
104	e.setData(i, data[i]);
105	}
106	return e;
107	}
108
109	/**
110	* Merges with border element.
111	* @param e instance of AbstractBorderElement
112	* @return instance of AbstractBorderElement
113	*/
114	public AbstractBorderElement merge(AbstractBorderElement e) {
115	AbstractBorderElement abe = this;
116	if (e instanceof SolidAndDoubleBorderElement) {
117	abe = mergeSolid((SolidAndDoubleBorderElement) e);
118	} else if (e instanceof DashedBorderElement) {
119	abe = mergeDashed((DashedBorderElement) e);
120	} else {
121	abe = e;
122	}
123	return abe;
124	}
125
126	/**
127	* @see org.apache.fop.render.txt.border.AbstractBorderElement#convert2Char()
128	*/
129	public char convert2Char() {
130	int key = 0;
131	key += data[UP] * UP2;
132	key += data[DOWN] * DOWN2;
133	key += data[LEFT] * LEFT2;
134	key += data[RIGHT] * RIGHT2;
135	char ch = map[key];
136	if (ch == UNDEFINED) {
137	ch = toSolidAndDouble().convert2Char();
138	}
139	return ch;
140	}
141	}

Line 0 Link Here

(-)src/java/org/apache/fop/render/txt/Helper.java (+117 lines)
		1	/*
		2	* Copyright 2005 The Apache Software Foundation.
		3	*
		4	* Licensed under the Apache License, Version 2.0 (the "License");
		5	* you may not use this file except in compliance with the License.
		6	* You may obtain a copy of the License at
		7	*
		8	* http://www.apache.org/licenses/LICENSE-2.0
		9	*
		10	* Unless required by applicable law or agreed to in writing, software
		11	* distributed under the License is distributed on an "AS IS" BASIS,
		12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		13	* See the License for the specific language governing permissions and
		14	* limitations under the License.
		15	*/
		16
		17	/* $Id$ */
		18
		19	package org.apache.fop.render.txt;
		20
		21	/**
		22	* This class has a few convenient static methods for number quantization.
		23	*/
		24	public final class Helper {
		25
		26	/**
		27	* Don't let anyone instantiate this class.
		28	*/
		29	private Helper() { }
		30
		31	/**
		32	* Returns nearest integer to <code>x</code>, divisible by
		33	* <code>quantum</code>.
		34	*
		35	* @param x integer for quantization
		36	* @param quantum integer, representing quantization
		37	* @return computed nearest integer
		38	*/
		39	public static int round(int x, int quantum) {
		40	int ceil = ceil(x, quantum);
		41	int floor = floor(x, quantum);
		42	return (ceil - x < x - floor) ? ceil : floor;
		43	}
		44
		45	/**
		46	* Returns minimal possible integer, greater or equal than
		47	* <code>x</code>, divisible by <code>quantum</code>.
		48	*
		49	* @param x integer for quantization
		50	* @param quantum integer, representing quantization
		51	* @return computed nearest integer
		52	*/
		53	public static int ceil(int x, int quantum) {
		54	int dx = (x < 0) \|\| (x % quantum == 0) ? 0 : 1;
		55	return (x / quantum + dx) * quantum;
		56	}
		57
		58	/**
		59	* Returns maximum possible integer, less or equal than
		60	* <code>oldValue</code>, divisible by <code>quantum</code>.
		61	*
		62	* @param x integer for quantization
		63	* @param quantum integer, representing quantization
		64	* @return computed nearest integer
65	*/
66	public static int floor(int x, int quantum) {
67	int dx = (x > 0) \|\| (x % quantum == 0) ? 0 : -1;
68	return (x / quantum + dx) * quantum;
69	}
70
71	/**
72	* Returns the closest integer to <code>x/y</code> fraction.
73	* It's possible to consider this methos as a analog of Math.round(x/y),
74	* without having deal with non-integer.
75	*
76	* @param x integer, fraction numerator
77	* @param y integer, fraction denominator
78	* @return the value of the fraction rounded to the nearest
79	* @see java.lang.Math#round(double)
80	*/
81	public static int roundPosition(int x, int y) {
82	return round(x, y) / y;
83	}
84
85	/**
86	* Returns the smallest integer that is greater than or equal to the
87	* <code>x/y</code> fraction.
88	* It's possible to consider this function as a analog of Math.ceil(x/y),
89	* without having deal with non-integer.
90	*
91	* @param x integer, fraction numerator
92	* @param y integer, fraction denominator
93	* @return the smallest integer that is greater than or equal to
94	* <code>x/y</code> fraction
95	* @see java.lang.Math#ceil(double)
96	*/
97	public static int ceilPosition(int x, int y) {
98	return ceil(x, y) / y;
99	}
100
101
102	/**
103	* Returns the largest integer that is less than or equal to the
104	* argument and is equal to <code>x/y</code> fraction.
105	* It's possible to consider this function as a analog of Math.floor(x/y),
106	* without having deal with non-integer.
107	*
108	* @param x integer, fraction numerator
109	* @param y integer, fraction denominator
110	* @return the largest integer that is less than or equal to
111	* the argument and is equal to <code>x/y</code> fraction
112	* @see java.lang.Math#ceil(double)
113	*/
114	public static int floorPosition(int x, int y) {
115	return floor(x, y) / y;
116	}
117	}