fop/src/java/org/apache/fop/fo/flow/table/GridUnit.java

/*
 * 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$ */

package org.apache.fop.fo.flow.table;

import org.apache.fop.fo.FONode;
import org.apache.fop.fo.properties.CommonBorderPaddingBackground;
import org.apache.fop.fo.properties.CommonBorderPaddingBackground.BorderInfo;
import org.apache.fop.layoutmgr.table.CollapsingBorderModel;

/**
 * This class represents one grid unit inside a table.
 */
public class GridUnit {

    /**
     * Indicates that the grid unit is in the first row of the table part (header, footer,
     * body).
     */
    public static final int FIRST_IN_PART = 0;

    /**
     * Indicates that the grid unit is in the last row of the table part (header, footer,
     * body).
     */
    public static final int LAST_IN_PART = 1;

    /** Indicates that the primary grid unit has a pending keep-with-next. */
    public static final int KEEP_WITH_NEXT_PENDING = 2;

    /** Indicates that the primary grid unit has a pending keep-with-previous. */
    public static final int KEEP_WITH_PREVIOUS_PENDING = 3;

    /** Primary grid unit */
    private PrimaryGridUnit primary;

    /** Table cell which occupies this grid unit */
    protected TableCell cell;

    /** Table row occupied by this grid unit (may be null). */
    private TableRow row;

    /** index of grid unit within cell in column direction */
    private int colSpanIndex;

    /** index of grid unit within cell in row direction */
    private int rowSpanIndex;

    /** flags for the grid unit */
    private byte flags = 0;

    ConditionalBorder borderBefore;
    ConditionalBorder borderAfter;
    BorderSpecification borderStart;
    BorderSpecification borderEnd;

    protected CollapsingBorderModel collapsingBorderModel;

    /**
     * Creates a new grid unit.
     * 
     * @param table the containing table
     * @param colSpanIndex index of this grid unit in the span, in column direction
     * @param rowSpanIndex index of this grid unit in the span, in row direction
     */
    protected GridUnit(Table table, int colSpanIndex, int rowSpanIndex) {
        this(colSpanIndex, rowSpanIndex);
        setBorders(table);
    }

    /**
     * Creates a new grid unit.
     * 
     * @param cell table cell which occupies this grid unit
     * @param colSpanIndex index of this grid unit in the span, in column direction
     * @param rowSpanIndex index of this grid unit in the span, in row direction
     */
    protected GridUnit(TableCell cell, int colSpanIndex, int rowSpanIndex) {
        this(colSpanIndex, rowSpanIndex);
        this.cell = cell;
        setBorders(cell.getTable());
    }

    /**
     * Creates a new grid unit.
     * 
     * @param primary the before-start grid unit of the cell containing this grid unit
     * @param colSpanIndex index of this grid unit in the span, in column direction
     * @param rowSpanIndex index of this grid unit in the span, in row direction
     */
    GridUnit(PrimaryGridUnit primary, int colSpanIndex, int rowSpanIndex) {
        this(primary.getCell(), colSpanIndex, rowSpanIndex);
        this.primary = primary;
    }

    private GridUnit(int colSpanIndex, int rowSpanIndex) {
        this.colSpanIndex = colSpanIndex;
        this.rowSpanIndex = rowSpanIndex;
    }

    private void setBorders(Table table/*TODO*/) {
        if (!table.isSeparateBorderModel()) {
            collapsingBorderModel = CollapsingBorderModel.getBorderModelFor(table
                    .getBorderCollapse());
            setBordersFromCell();
        }
    }

    /**
     * Prepares the borders of this grid unit for upcoming resolution, in the collapsing
     * model.
     */
    protected void setBordersFromCell() {
        borderBefore = cell.borderBefore.copy();
        if (rowSpanIndex > 0) {
            borderBefore.nonLeadingTrailing = BorderSpecification.getDefaultBorder();
        }
        borderAfter = cell.borderAfter.copy();
        if (!isLastGridUnitRowSpan()) {
            borderAfter.nonLeadingTrailing = BorderSpecification.getDefaultBorder();
        }
        if (colSpanIndex == 0) {
            borderStart = cell.borderStart;
        } else {
            borderStart = BorderSpecification.getDefaultBorder();
        }
        if (isLastGridUnitColSpan()) {
            borderEnd = cell.borderEnd;
        } else {
            borderEnd = BorderSpecification.getDefaultBorder();
        }
    }

    public TableCell getCell() {
        return cell;
    }

    /**
     * Returns the fo:table-row element (if any) this grid unit belongs to.
     * 
     * @return the row containing this grid unit, or null if there is no fo:table-row
     * element in the corresponding table-part
     */
    public TableRow getRow() {
        return row;
    }

    void setRow(TableRow row) {
        this.row = row;
    }

    public TableBody getBody() {
        FONode node = getCell();
        while (node != null && !(node instanceof TableBody)) {
            node = node.getParent();
        }
        return (TableBody) node;
    }

    /**
     * Returns the before-start grid unit of the cell containing this grid unit.
     * 
     * @return the before-start grid unit of the cell containing this grid unit.
     */
    public PrimaryGridUnit getPrimary() {
        return primary;
    }

    /**
     * Is this grid unit the before-start grid unit of the cell?
     * 
     * @return true if this grid unit is the before-start grid unit of the cell
     */
    public boolean isPrimary() {
        return false;
    }

    /**
     * Does this grid unit belong to an empty cell?
     * 
     * @return true if this grid unit belongs to an empty cell
     */
    public boolean isEmpty() {
        return cell == null;
    }

    /** @return true if the grid unit is the last in column spanning direction */
    public boolean isLastGridUnitColSpan() {
        return (colSpanIndex == cell.getNumberColumnsSpanned() - 1);
    }

    /** @return true if the grid unit is the last in row spanning direction */
    public boolean isLastGridUnitRowSpan() {
        return (rowSpanIndex == cell.getNumberRowsSpanned() - 1);
    }

    /**
     * @return the index of the grid unit inside a cell in row direction
     */
    public int getRowSpanIndex() {
        return rowSpanIndex;
    }

    /**
     * @return the index of the grid unit inside a cell in column direction
     */
    public int getColSpanIndex() {
        return colSpanIndex;
    }

    /**
     * Returns the resolved border-before of this grid unit, in the collapsing-border
     * model.
     * 
     * @param which one of {@link ConditionalBorder#NORMAL},
     * {@link ConditionalBorder#LEADING_TRAILING} or {@link ConditionalBorder#REST}
     * @return the corresponding border
     */
    public BorderInfo getBorderBefore(int which) {
        switch (which) {
        case ConditionalBorder.NORMAL:
            return borderBefore.nonLeadingTrailing.getBorderInfo();
        case ConditionalBorder.LEADING_TRAILING:
            return borderBefore.leadingTrailing.getBorderInfo();
        case ConditionalBorder.REST:
            return borderBefore.rest.getBorderInfo();
        default:
            assert false;
            return null;
        }
    }

    /**
     * Returns the resolved border-after of this grid unit, in the collapsing-border
     * model.
     * 
     * @param which one of {@link ConditionalBorder#NORMAL},
     * {@link ConditionalBorder#LEADING_TRAILING} or {@link ConditionalBorder#REST}
     * @return the corresponding border
     */
    public BorderInfo getBorderAfter(int which) {
        switch (which) {
        case ConditionalBorder.NORMAL:
            return borderAfter.nonLeadingTrailing.getBorderInfo();
        case ConditionalBorder.LEADING_TRAILING:
            return borderAfter.leadingTrailing.getBorderInfo();
        case ConditionalBorder.REST:
            return borderAfter.rest.getBorderInfo();
        default:
            assert false;
            return null;
        }
    }

    /**
     * Returns the resolved border-start of this grid unit, in the collapsing-border
     * model.
     * 
     * @return the corresponding border
     */
    public BorderInfo getBorderStart() {
        return borderStart.getBorderInfo();
    }

    /**
     * Returns the resolved border-end of this grid unit, in the collapsing-border
     * model.
     * 
     * @return the corresponding border
     */
    public BorderInfo getBorderEnd() {
        return borderEnd.getBorderInfo();
    }

    /**
     * Resolve collapsing borders for the given cell. Used in case of the collapsing
     * border model.
     * 
     * @param other neighbouring grid unit
     * @param side the side to resolve (one of
     * CommonBorderPaddingBackground.BEFORE|AFTER|START|END)
     */
    void resolveBorder(GridUnit other, int side) {
        switch (side) {
        case CommonBorderPaddingBackground.BEFORE:
            borderBefore.resolve(other.borderAfter, false, true, false);
            break;
        case CommonBorderPaddingBackground.AFTER:
            borderAfter.resolve(other.borderBefore, false, true, false);
            break;
        case CommonBorderPaddingBackground.START:
            BorderSpecification resolvedBorder = collapsingBorderModel.determineWinner(
                    borderStart, other.borderEnd);
            if (resolvedBorder != null) {
                this.borderStart = resolvedBorder;
                other.borderEnd = resolvedBorder;
            }
            break;
        case CommonBorderPaddingBackground.END:
            resolvedBorder = collapsingBorderModel.determineWinner(
                    borderEnd, other.borderStart);
            if (resolvedBorder != null) {
                this.borderEnd = resolvedBorder;
                other.borderStart = resolvedBorder;
            }
            break;
        default: assert false;
        }
    }

    /**
     * For the given side, integrates in the conflict resolution the border segment of the
     * given parent element.
     * 
     * @param side the side to consider (either CommonBorderPaddingBackground.BEFORE or
     * AFTER)
     * @param parent a table element whose corresponding border coincides on the given
     * side
     */
    void integrateBorderSegment(int side, TableFObj parent, boolean withLeadingTrailing,
            boolean withNonLeadingTrailing, boolean withRest) {
        switch (side) {
        case CommonBorderPaddingBackground.BEFORE:
            borderBefore.integrateSegment(parent.borderBefore, withLeadingTrailing,
                    withNonLeadingTrailing, withRest);
            break;
        case CommonBorderPaddingBackground.AFTER:
            borderAfter.integrateSegment(parent.borderAfter, withLeadingTrailing,
                    withNonLeadingTrailing, withRest);
            break;
        default: assert false;
        }
    }

    /**
     * For the given side, integrates in the conflict resolution the border segment of the
     * given parent element.
     * 
     * @param side the side to consider (one of
     * CommonBorderPaddingBackground.BEFORE|AFTER|START|END)
     * @param parent a table element whose corresponding border coincides on the given side
     */
    void integrateBorderSegment(int side, TableFObj parent) {
        switch (side) {
        case CommonBorderPaddingBackground.BEFORE:
        case CommonBorderPaddingBackground.AFTER:
            integrateBorderSegment(side, parent, true, true, true);
            break;
        case CommonBorderPaddingBackground.START:
            borderStart = collapsingBorderModel.determineWinner(borderStart,
                    parent.borderStart);
            break;
        case CommonBorderPaddingBackground.END:
            borderEnd = collapsingBorderModel.determineWinner(borderEnd,
                    parent.borderEnd);
            break;
        default: assert false;
        }
    }

    void integrateCompetingBorder(int side, ConditionalBorder competitor,
            boolean withLeadingTrailing, boolean withNonLeadingTrailing, boolean withRest) {
        switch (side) {
        case CommonBorderPaddingBackground.BEFORE:
            borderBefore.integrateCompetingSegment(competitor, withLeadingTrailing,
                    withNonLeadingTrailing, withRest);
            break;
        case CommonBorderPaddingBackground.AFTER:
            borderAfter.integrateCompetingSegment(competitor, withLeadingTrailing,
                    withNonLeadingTrailing, withRest);
            break;
        default: assert false;
        }
    }

    /**
     * Returns a flag for this GridUnit.
     * 
     * @param which the requested flag
     * @return the value of the flag
     */
    public boolean getFlag(int which) {
        return (flags & (1 << which)) != 0;
    }

    /**
     * Sets a flag on a GridUnit.
     * 
     * @param which the flag to set
     * @param value the new value for the flag
     */
    public void setFlag(int which, boolean value) {
        if (value) {
            flags |= (1 << which); // set flag
        } else {
            flags &= ~(1 << which); // clear flag
        }
    }

    /**
     * Sets the given flag on this grid unit.
     * 
     * @param which the flag to set
     */
    public void setFlag(int which) {
        setFlag(which, true);
    }

    /** {@inheritDoc} */
    public String toString() {
        StringBuffer buffer = new StringBuffer();
        if (isEmpty()) {
            buffer.append("EMPTY");
        } else if (isPrimary()) {
            buffer.append("Primary");
        }
        buffer.append("GridUnit:");
        if (colSpanIndex > 0) {
            buffer.append(" colSpan=").append(colSpanIndex);
            if (isLastGridUnitColSpan()) {
                buffer.append("(last)");
            }
        }
        if (rowSpanIndex > 0) {
            buffer.append(" rowSpan=").append(rowSpanIndex);
            if (isLastGridUnitRowSpan()) {
                buffer.append("(last)");
            }
        }
        if (!isPrimary() && getPrimary() != null) {
            buffer.append(" primary=").append(getPrimary().getRowIndex());
            buffer.append("/").append(getPrimary().getColIndex());
            if (getPrimary().getCell() != null) {
                buffer.append(" id=" + getPrimary().getCell().getId());
            }
        }
        buffer.append(" flags=").append(Integer.toBinaryString(flags));
        return buffer.toString();
    }

}