git-svn-id: https://svn.apache.org/repos/asf/xmlgraphics/fop/trunk@195406 13f79535-47bb-0310-9956-ffa450edef68tags/Alt-Design-integration-base
@@ -14,9 +14,11 @@ import org.apache.fop.datatypes.*; | |||
import org.apache.fop.layout.*; | |||
import org.apache.fop.layout.FontState; | |||
import org.apache.fop.apps.FOPException; | |||
import org.apache.fop.layoutmgr.list.ListBlockLayoutManager; | |||
// Java | |||
import java.util.Iterator; | |||
import java.util.List; | |||
public class ListBlock extends FObj { | |||
@@ -36,6 +38,11 @@ public class ListBlock extends FObj { | |||
super(parent); | |||
} | |||
public void addLayoutManager(List list) { | |||
ListBlockLayoutManager blm = new ListBlockLayoutManager(this); | |||
list.add(blm); | |||
} | |||
public void setup() throws FOPException { | |||
// Common Accessibility Properties |
@@ -13,11 +13,15 @@ import org.apache.fop.fo.properties.*; | |||
import org.apache.fop.layout.*; | |||
import org.apache.fop.layout.FontState; | |||
import org.apache.fop.apps.FOPException; | |||
import org.apache.fop.layoutmgr.list.ListItemLayoutManager; | |||
// Java | |||
import java.util.Iterator; | |||
import java.util.List; | |||
public class ListItem extends FObj { | |||
ListItemLabel label = null; | |||
ListItemBody body = null; | |||
int align; | |||
int alignLast; | |||
@@ -33,43 +37,64 @@ public class ListItem extends FObj { | |||
super(parent); | |||
} | |||
public void addLayoutManager(List list) { | |||
if(label != null && body != null) { | |||
ListItemLayoutManager blm = new ListItemLayoutManager(this); | |||
blm.setLabel(label.getItemLayoutManager()); | |||
blm.setBody(body.getItemLayoutManager()); | |||
list.add(blm); | |||
} | |||
} | |||
public void setup() { | |||
// Common Accessibility Properties | |||
AccessibilityProps mAccProps = propMgr.getAccessibilityProps(); | |||
// Common Accessibility Properties | |||
AccessibilityProps mAccProps = propMgr.getAccessibilityProps(); | |||
// Common Aural Properties | |||
AuralProps mAurProps = propMgr.getAuralProps(); | |||
// Common Aural Properties | |||
AuralProps mAurProps = propMgr.getAuralProps(); | |||
// Common Border, Padding, and Background Properties | |||
BorderAndPadding bap = propMgr.getBorderAndPadding(); | |||
BackgroundProps bProps = propMgr.getBackgroundProps(); | |||
// Common Border, Padding, and Background Properties | |||
BorderAndPadding bap = propMgr.getBorderAndPadding(); | |||
BackgroundProps bProps = propMgr.getBackgroundProps(); | |||
// Common Margin Properties-Block | |||
MarginProps mProps = propMgr.getMarginProps(); | |||
// Common Margin Properties-Block | |||
MarginProps mProps = propMgr.getMarginProps(); | |||
// Common Relative Position Properties | |||
RelativePositionProps mRelProps = propMgr.getRelativePositionProps(); | |||
// Common Relative Position Properties | |||
RelativePositionProps mRelProps = propMgr.getRelativePositionProps(); | |||
// this.properties.get("break-after"); | |||
// this.properties.get("break-before"); | |||
setupID(); | |||
// this.properties.get("keep-together"); | |||
// this.properties.get("keep-with-next"); | |||
// this.properties.get("keep-with-previous"); | |||
// this.properties.get("relative-align"); | |||
// this.properties.get("break-after"); | |||
// this.properties.get("break-before"); | |||
setupID(); | |||
// this.properties.get("keep-together"); | |||
// this.properties.get("keep-with-next"); | |||
// this.properties.get("keep-with-previous"); | |||
// this.properties.get("relative-align"); | |||
this.align = this.properties.get("text-align").getEnum(); | |||
this.alignLast = this.properties.get("text-align-last").getEnum(); | |||
this.lineHeight = | |||
this.properties.get("line-height").getLength().mvalue(); | |||
this.spaceBefore = | |||
this.properties.get("space-before.optimum").getLength().mvalue(); | |||
this.spaceAfter = | |||
this.properties.get("space-after.optimum").getLength().mvalue(); | |||
this.align = this.properties.get("text-align").getEnum(); | |||
this.alignLast = this.properties.get("text-align-last").getEnum(); | |||
this.lineHeight = | |||
this.properties.get("line-height").getLength().mvalue(); | |||
this.spaceBefore = | |||
this.properties.get("space-before.optimum").getLength().mvalue(); | |||
this.spaceAfter = | |||
this.properties.get("space-after.optimum").getLength().mvalue(); | |||
} | |||
public void addChild(FONode child) { | |||
if ("fo:list-item-label".equals(child.getName())) { | |||
label = (ListItemLabel)child; | |||
} else if ("fo:list-item-body".equals(child.getName())) { | |||
body = (ListItemBody)child; | |||
} else if("fo:marker".equals(child.getName())) { | |||
// marker | |||
} else { | |||
// error | |||
} | |||
} | |||
public boolean generatesInlineAreas() { | |||
return false; | |||
} |
@@ -13,6 +13,7 @@ import org.apache.fop.fo.properties.*; | |||
import org.apache.fop.layout.*; | |||
import org.apache.fop.layout.FontState; | |||
import org.apache.fop.apps.FOPException; | |||
import org.apache.fop.layoutmgr.list.Item; | |||
// Java | |||
import java.util.Iterator; | |||
@@ -23,6 +24,11 @@ public class ListItemBody extends FObj { | |||
super(parent); | |||
} | |||
public Item getItemLayoutManager() { | |||
Item item = new Item(this); | |||
return item; | |||
} | |||
public void setup() { | |||
// Common Accessibility Properties |
@@ -13,6 +13,7 @@ import org.apache.fop.fo.properties.*; | |||
import org.apache.fop.layout.*; | |||
import org.apache.fop.layout.FontState; | |||
import org.apache.fop.apps.FOPException; | |||
import org.apache.fop.layoutmgr.list.Item; | |||
// Java | |||
import java.util.Enumeration; | |||
@@ -23,7 +24,12 @@ public class ListItemLabel extends FObj { | |||
super(parent); | |||
} | |||
public void setup() throws FOPException { | |||
public Item getItemLayoutManager() { | |||
Item itemLabel = new Item(this); | |||
return itemLabel; | |||
} | |||
public void setup() { | |||
// Common Accessibility Properties | |||
AccessibilityProps mAccProps = propMgr.getAccessibilityProps(); |
@@ -0,0 +1,238 @@ | |||
/* | |||
* $Id$ | |||
* Copyright (C) 2001-2002 The Apache Software Foundation. All rights reserved. | |||
* For details on use and redistribution please refer to the | |||
* LICENSE file included with these sources. | |||
*/ | |||
package org.apache.fop.layoutmgr.list; | |||
import org.apache.fop.fo.PropertyManager; | |||
import org.apache.fop.layoutmgr.BlockStackingLayoutManager; | |||
import org.apache.fop.layoutmgr.LayoutManager; | |||
import org.apache.fop.layoutmgr.LeafPosition; | |||
import org.apache.fop.layoutmgr.BreakPoss; | |||
import org.apache.fop.layoutmgr.LayoutContext; | |||
import org.apache.fop.layoutmgr.PositionIterator; | |||
import org.apache.fop.layoutmgr.BreakPossPosIter; | |||
import org.apache.fop.layoutmgr.Position; | |||
import org.apache.fop.fo.FObj; | |||
import org.apache.fop.area.Area; | |||
import org.apache.fop.area.Block; | |||
import org.apache.fop.area.MinOptMax; | |||
import org.apache.fop.layout.BorderAndPadding; | |||
import org.apache.fop.layout.BackgroundProps; | |||
import java.util.ArrayList; | |||
/** | |||
* LayoutManager for a table-cell FO. | |||
* A cell contains blocks. These blocks fill the cell. | |||
*/ | |||
public class Item extends BlockStackingLayoutManager { | |||
private BorderAndPadding borderProps = null; | |||
private BackgroundProps backgroundProps; | |||
private Block curBlockArea; | |||
private ArrayList childBreaks = new ArrayList(); | |||
private int xoffset; | |||
private int yoffset; | |||
private int itemIPD; | |||
/** | |||
* Create a new Cell layout manager. | |||
* @param fobj the formatting object for the cell | |||
*/ | |||
public Item(FObj fobj) { | |||
super(fobj); | |||
} | |||
protected void initProperties(PropertyManager propMgr) { | |||
borderProps = propMgr.getBorderAndPadding(); | |||
backgroundProps = propMgr.getBackgroundProps(); | |||
} | |||
/** | |||
* Get the next break possibility for this cell. | |||
* A cell contains blocks so there are breaks around the blocks | |||
* and inside the blocks. | |||
* | |||
* @param context the layout context | |||
* @return the next break possibility | |||
*/ | |||
public BreakPoss getNextBreakPoss(LayoutContext context) { | |||
LayoutManager curLM; // currently active LM | |||
MinOptMax stackSize = new MinOptMax(); | |||
// if starting add space before | |||
// stackSize.add(spaceBefore); | |||
BreakPoss lastPos = null; | |||
itemIPD = context.getRefIPD(); | |||
while ((curLM = getChildLM()) != null) { | |||
if(curLM.generatesInlineAreas()) { | |||
// error | |||
curLM.setFinished(true); | |||
continue; | |||
} | |||
// Set up a LayoutContext | |||
int ipd = context.getRefIPD(); | |||
BreakPoss bp; | |||
LayoutContext childLC = new LayoutContext(0); | |||
childLC.setStackLimit(MinOptMax.subtract(context.getStackLimit(), | |||
stackSize)); | |||
childLC.setRefIPD(ipd); | |||
while (!curLM.isFinished()) { | |||
if ((bp = curLM.getNextBreakPoss(childLC)) != null) { | |||
stackSize.add(bp.getStackingSize()); | |||
if (stackSize.min > context.getStackLimit().max) { | |||
// reset to last break | |||
if (lastPos != null) { | |||
reset(lastPos.getPosition()); | |||
} else { | |||
curLM.resetPosition(null); | |||
} | |||
break; | |||
} | |||
lastPos = bp; | |||
childBreaks.add(bp); | |||
childLC.setStackLimit(MinOptMax.subtract( | |||
context.getStackLimit(), stackSize)); | |||
} | |||
} | |||
BreakPoss breakPoss = new BreakPoss( | |||
new LeafPosition(this, childBreaks.size() - 1)); | |||
breakPoss.setStackingSize(stackSize); | |||
return breakPoss; | |||
} | |||
setFinished(true); | |||
return null; | |||
} | |||
/** | |||
* Set the y offset of this cell. | |||
* This offset is used to set the absolute position of the cell. | |||
* | |||
* @param off the y direction offset | |||
*/ | |||
public void setYOffset(int off) { | |||
yoffset = off; | |||
} | |||
/** | |||
* Set the x offset of this cell. | |||
* This offset is used to set the absolute position of the cell. | |||
* | |||
* @param off the x offset | |||
*/ | |||
public void setXOffset(int off) { | |||
xoffset = off; | |||
} | |||
/** | |||
* Add the areas for the break points. | |||
* The cell contains block stacking layout managers | |||
* that add block areas. | |||
* | |||
* @param parentIter the iterator of the break positions | |||
* @param layoutContext the layout context for adding the areas | |||
*/ | |||
public void addAreas(PositionIterator parentIter, | |||
LayoutContext layoutContext) { | |||
getParentArea(null); | |||
addID(); | |||
LayoutManager childLM; | |||
int iStartPos = 0; | |||
LayoutContext lc = new LayoutContext(0); | |||
while (parentIter.hasNext()) { | |||
LeafPosition lfp = (LeafPosition) parentIter.next(); | |||
// Add the block areas to Area | |||
PositionIterator breakPosIter = | |||
new BreakPossPosIter(childBreaks, iStartPos, | |||
lfp.getLeafPos() + 1); | |||
iStartPos = lfp.getLeafPos() + 1; | |||
while ((childLM = breakPosIter.getNextChildLM()) != null) { | |||
childLM.addAreas(breakPosIter, lc); | |||
} | |||
} | |||
if(borderProps != null) { | |||
addBorders(curBlockArea, borderProps); | |||
} | |||
if(backgroundProps != null) { | |||
addBackground(curBlockArea, backgroundProps); | |||
} | |||
flush(); | |||
childBreaks.clear(); | |||
curBlockArea = null; | |||
} | |||
/** | |||
* Return an Area which can contain the passed childArea. The childArea | |||
* may not yet have any content, but it has essential traits set. | |||
* In general, if the LayoutManager already has an Area it simply returns | |||
* it. Otherwise, it makes a new Area of the appropriate class. | |||
* It gets a parent area for its area by calling its parent LM. | |||
* Finally, based on the dimensions of the parent area, it initializes | |||
* its own area. This includes setting the content IPD and the maximum | |||
* BPD. | |||
* | |||
* @param childArea the child area to get the parent for | |||
* @return the parent area | |||
*/ | |||
public Area getParentArea(Area childArea) { | |||
if (curBlockArea == null) { | |||
curBlockArea = new Block(); | |||
curBlockArea.setPositioning(Block.ABSOLUTE); | |||
// set position | |||
curBlockArea.setXOffset(xoffset); | |||
curBlockArea.setYOffset(yoffset); | |||
curBlockArea.setWidth(itemIPD); | |||
//curBlockArea.setHeight(); | |||
// Set up dimensions | |||
Area parentArea = parentLM.getParentArea(curBlockArea); | |||
int referenceIPD = parentArea.getIPD(); | |||
curBlockArea.setIPD(referenceIPD); | |||
// Get reference IPD from parentArea | |||
setCurrentArea(curBlockArea); // ??? for generic operations | |||
} | |||
return curBlockArea; | |||
} | |||
/** | |||
* Add the child to the cell block area. | |||
* | |||
* @param childArea the child to add to the cell | |||
* @return unused | |||
*/ | |||
public boolean addChild(Area childArea) { | |||
if (curBlockArea != null) { | |||
curBlockArea.addBlock((Block) childArea); | |||
return false; | |||
} | |||
return false; | |||
} | |||
/** | |||
* Reset the position of the layout. | |||
* | |||
* @param resetPos the position to reset to | |||
*/ | |||
public void resetPosition(Position resetPos) { | |||
if (resetPos == null) { | |||
reset(null); | |||
} | |||
} | |||
} | |||
@@ -0,0 +1,229 @@ | |||
/* | |||
* $Id$ | |||
* Copyright (C) 2002 The Apache Software Foundation. All rights reserved. | |||
* For details on use and redistribution please refer to the | |||
* LICENSE file included with these sources. | |||
*/ | |||
package org.apache.fop.layoutmgr.list; | |||
import org.apache.fop.fo.PropertyManager; | |||
import org.apache.fop.layoutmgr.BlockStackingLayoutManager; | |||
import org.apache.fop.layoutmgr.LayoutManager; | |||
import org.apache.fop.layoutmgr.LeafPosition; | |||
import org.apache.fop.layoutmgr.BreakPoss; | |||
import org.apache.fop.layoutmgr.LayoutContext; | |||
import org.apache.fop.layoutmgr.PositionIterator; | |||
import org.apache.fop.layoutmgr.BreakPossPosIter; | |||
import org.apache.fop.layoutmgr.Position; | |||
import org.apache.fop.fo.FObj; | |||
import org.apache.fop.area.Area; | |||
import org.apache.fop.area.Block; | |||
import org.apache.fop.area.MinOptMax; | |||
import org.apache.fop.layout.BorderAndPadding; | |||
import org.apache.fop.layout.BackgroundProps; | |||
import java.util.ArrayList; | |||
import java.util.List; | |||
/** | |||
* LayoutManager for a table FO. | |||
* A table consists of columns, table header, table footer and multiple | |||
* table bodies. | |||
* The header, footer and body add the areas created from the table cells. | |||
* The table then creates areas for the columns, bodies and rows | |||
* the render background. | |||
*/ | |||
public class ListBlockLayoutManager extends BlockStackingLayoutManager { | |||
private List columns = null; | |||
private BorderAndPadding borderProps = null; | |||
private BackgroundProps backgroundProps; | |||
private Block curBlockArea; | |||
private ArrayList bodyBreaks = new ArrayList(); | |||
private class SectionPosition extends LeafPosition { | |||
protected List list; | |||
protected SectionPosition(LayoutManager lm, int pos, List l) { | |||
super(lm, pos); | |||
list = l; | |||
} | |||
} | |||
/** | |||
* Create a new table layout manager. | |||
* | |||
* @param fobj the table formatting object | |||
*/ | |||
public ListBlockLayoutManager(FObj fobj) { | |||
super(fobj); | |||
} | |||
protected void initProperties(PropertyManager propMgr) { | |||
borderProps = propMgr.getBorderAndPadding(); | |||
backgroundProps = propMgr.getBackgroundProps(); | |||
} | |||
/** | |||
* Get the next break possibility. | |||
* The break possibility depends on the height of the header and footer | |||
* and possible breaks inside the table body. | |||
* | |||
* @param context the layout context for finding breaks | |||
* @return the next break possibility | |||
*/ | |||
public BreakPoss getNextBreakPoss(LayoutContext context) { | |||
ListItemLayoutManager curLM; // currently active LM | |||
MinOptMax stackSize = new MinOptMax(); | |||
// if starting add space before | |||
// stackSize.add(spaceBefore); | |||
BreakPoss lastPos = null; | |||
while ((curLM = (ListItemLayoutManager)getChildLM()) != null) { | |||
// Make break positions | |||
// Set up a LayoutContext | |||
int ipd = context.getRefIPD(); | |||
BreakPoss bp; | |||
LayoutContext childLC = new LayoutContext(0); | |||
childLC.setStackLimit( | |||
MinOptMax.subtract(context.getStackLimit(), | |||
stackSize)); | |||
childLC.setRefIPD(ipd); | |||
while (!curLM.isFinished()) { | |||
if ((bp = curLM.getNextBreakPoss(childLC)) != null) { | |||
stackSize.add(bp.getStackingSize()); | |||
if (stackSize.opt > context.getStackLimit().max) { | |||
// reset to last break | |||
if (lastPos != null) { | |||
reset(lastPos.getPosition()); | |||
} else { | |||
curLM.resetPosition(null); | |||
} | |||
break; | |||
} | |||
lastPos = bp; | |||
bodyBreaks.add(bp); | |||
childLC.setStackLimit(MinOptMax.subtract( | |||
context.getStackLimit(), stackSize)); | |||
} | |||
} | |||
BreakPoss breakPoss = new BreakPoss( | |||
new LeafPosition(this, bodyBreaks.size() - 1)); | |||
breakPoss.setStackingSize(stackSize); | |||
return breakPoss; | |||
} | |||
setFinished(true); | |||
return null; | |||
} | |||
/** | |||
* The table area is a reference area that contains areas for | |||
* columns, bodies, rows and the contents are in cells. | |||
* | |||
* @param parentIter the position iterator | |||
* @param layoutContext the layout context for adding areas | |||
*/ | |||
public void addAreas(PositionIterator parentIter, | |||
LayoutContext layoutContext) { | |||
getParentArea(null); | |||
addID(); | |||
// add column, body then row areas | |||
// add table header areas | |||
int tableHeight = 0; | |||
ListItemLayoutManager childLM; | |||
int iStartPos = 0; | |||
LayoutContext lc = new LayoutContext(0); | |||
while (parentIter.hasNext()) { | |||
LeafPosition lfp = (LeafPosition) parentIter.next(); | |||
// Add the block areas to Area | |||
PositionIterator breakPosIter = | |||
new BreakPossPosIter(bodyBreaks, iStartPos, | |||
lfp.getLeafPos() + 1); | |||
iStartPos = lfp.getLeafPos() + 1; | |||
while ((childLM = (ListItemLayoutManager)breakPosIter.getNextChildLM()) != null) { | |||
childLM.addAreas(breakPosIter, lc); | |||
tableHeight += childLM.getListItemHeight(); | |||
} | |||
} | |||
// add footer areas | |||
curBlockArea.setHeight(tableHeight); | |||
if(borderProps != null) { | |||
addBorders(curBlockArea, borderProps); | |||
} | |||
if(backgroundProps != null) { | |||
addBackground(curBlockArea, backgroundProps); | |||
} | |||
flush(); | |||
bodyBreaks.clear(); | |||
curBlockArea = null; | |||
} | |||
/** | |||
* Return an Area which can contain the passed childArea. The childArea | |||
* may not yet have any content, but it has essential traits set. | |||
* In general, if the LayoutManager already has an Area it simply returns | |||
* it. Otherwise, it makes a new Area of the appropriate class. | |||
* It gets a parent area for its area by calling its parent LM. | |||
* Finally, based on the dimensions of the parent area, it initializes | |||
* its own area. This includes setting the content IPD and the maximum | |||
* BPD. | |||
* | |||
* @param childArea the child area | |||
* @return the parent area of the child | |||
*/ | |||
public Area getParentArea(Area childArea) { | |||
if (curBlockArea == null) { | |||
curBlockArea = new Block(); | |||
// Set up dimensions | |||
// Must get dimensions from parent area | |||
Area parentArea = parentLM.getParentArea(curBlockArea); | |||
int referenceIPD = parentArea.getIPD(); | |||
curBlockArea.setIPD(referenceIPD); | |||
// Get reference IPD from parentArea | |||
setCurrentArea(curBlockArea); // ??? for generic operations | |||
} | |||
return curBlockArea; | |||
} | |||
/** | |||
* Add the child area to this layout manager. | |||
* | |||
* @param childArea the child area to add | |||
* @return unused | |||
*/ | |||
public boolean addChild(Area childArea) { | |||
if (curBlockArea != null) { | |||
curBlockArea.addBlock((Block) childArea); | |||
return false; | |||
} | |||
return false; | |||
} | |||
/** | |||
* Reset the position of this layout manager. | |||
* | |||
* @param resetPos the position to reset to | |||
*/ | |||
public void resetPosition(Position resetPos) { | |||
if (resetPos == null) { | |||
reset(null); | |||
} | |||
} | |||
} | |||
@@ -0,0 +1,284 @@ | |||
/* | |||
* $Id$ | |||
* Copyright (C) 2002 The Apache Software Foundation. All rights reserved. | |||
* For details on use and redistribution please refer to the | |||
* LICENSE file included with these sources. | |||
*/ | |||
package org.apache.fop.layoutmgr.list; | |||
import org.apache.fop.fo.PropertyManager; | |||
import org.apache.fop.layoutmgr.BlockStackingLayoutManager; | |||
import org.apache.fop.layoutmgr.LayoutManager; | |||
import org.apache.fop.layoutmgr.LeafPosition; | |||
import org.apache.fop.layoutmgr.BreakPoss; | |||
import org.apache.fop.layoutmgr.LayoutContext; | |||
import org.apache.fop.layoutmgr.PositionIterator; | |||
import org.apache.fop.layoutmgr.BreakPossPosIter; | |||
import org.apache.fop.layoutmgr.Position; | |||
import org.apache.fop.fo.FObj; | |||
import org.apache.fop.area.Area; | |||
import org.apache.fop.area.Block; | |||
import org.apache.fop.area.MinOptMax; | |||
import org.apache.fop.layout.BorderAndPadding; | |||
import org.apache.fop.layout.BackgroundProps; | |||
import java.util.Iterator; | |||
import java.util.ArrayList; | |||
import java.util.List; | |||
/** | |||
* LayoutManager for a list-item FO. | |||
* The list item contains a list item label and a list item body. | |||
*/ | |||
public class ListItemLayoutManager extends BlockStackingLayoutManager { | |||
private Item label; | |||
private Item body; | |||
private Block curBlockArea; | |||
private List cellList = null; | |||
private List columns = null; | |||
private int listItemHeight; | |||
private int yoffset; | |||
private BorderAndPadding borderProps = null; | |||
private BackgroundProps backgroundProps; | |||
private class ItemPosition extends LeafPosition { | |||
protected List cellBreaks; | |||
protected ItemPosition(LayoutManager lm, int pos, List l) { | |||
super(lm, pos); | |||
cellBreaks = l; | |||
} | |||
} | |||
/** | |||
* Create a new list item layout manager. | |||
* | |||
* @param fobj the list-item formatting object | |||
*/ | |||
public ListItemLayoutManager(FObj fobj) { | |||
super(fobj); | |||
} | |||
protected void initProperties(PropertyManager propMgr) { | |||
borderProps = propMgr.getBorderAndPadding(); | |||
backgroundProps = propMgr.getBackgroundProps(); | |||
} | |||
public void setLabel(Item item) { | |||
label = item; | |||
label.setParentLM(this); | |||
} | |||
public void setBody(Item item) { | |||
body = item; | |||
body.setParentLM(this); | |||
} | |||
/** | |||
* Get the next break possibility. | |||
* | |||
* @param context the layout context for getting breaks | |||
* @return the next break possibility | |||
*/ | |||
public BreakPoss getNextBreakPoss(LayoutContext context) { | |||
Item curLM; // currently active LM | |||
BreakPoss lastPos = null; | |||
ArrayList breakList = new ArrayList(); | |||
int min = 0; | |||
int opt = 0; | |||
int max = 0; | |||
int stage = 0; | |||
while (true) { | |||
if(stage == 0) { | |||
curLM = label; | |||
} else if (stage == 1) { | |||
curLM = body; | |||
} else { | |||
break; | |||
} | |||
ArrayList childBreaks = new ArrayList(); | |||
MinOptMax stackSize = new MinOptMax(); | |||
// Set up a LayoutContext | |||
// the ipd is from the current column | |||
int ipd = context.getRefIPD(); | |||
BreakPoss bp; | |||
LayoutContext childLC = new LayoutContext(0); | |||
childLC.setStackLimit( | |||
MinOptMax.subtract(context.getStackLimit(), | |||
stackSize)); | |||
if (stage == 0) { | |||
childLC.setRefIPD(24000); | |||
} else if (stage == 1) { | |||
childLC.setRefIPD(context.getRefIPD() - 24000); | |||
} | |||
stage++; | |||
while (!curLM.isFinished()) { | |||
if ((bp = curLM.getNextBreakPoss(childLC)) != null) { | |||
stackSize.add(bp.getStackingSize()); | |||
if (stackSize.min > context.getStackLimit().max) { | |||
// reset to last break | |||
if (lastPos != null) { | |||
curLM.resetPosition(lastPos.getPosition()); | |||
} else { | |||
curLM.resetPosition(null); | |||
} | |||
break; | |||
} | |||
lastPos = bp; | |||
childBreaks.add(bp); | |||
childLC.setStackLimit(MinOptMax.subtract( | |||
context.getStackLimit(), stackSize)); | |||
} | |||
} | |||
// the min is the maximum min of the label and body | |||
if (stackSize.min > min) { | |||
min = stackSize.min; | |||
} | |||
// the optimum is the minimum of all optimums | |||
if (stackSize.opt > opt) { | |||
opt = stackSize.opt; | |||
} | |||
// the maximum is the largest maximum | |||
if (stackSize.max > max) { | |||
max = stackSize.max; | |||
} | |||
breakList.add(childBreaks); | |||
} | |||
listItemHeight = opt; | |||
MinOptMax itemSize = new MinOptMax(min, opt, max); | |||
setFinished(true); | |||
ItemPosition rp = new ItemPosition(this, breakList.size() - 1, breakList); | |||
BreakPoss breakPoss = new BreakPoss(rp); | |||
breakPoss.setStackingSize(itemSize); | |||
return breakPoss; | |||
} | |||
/** | |||
* Set the y position offset of this list item. | |||
* This is used to set the position of the areas returned by this list item. | |||
* | |||
* @param off the y offset | |||
*/ | |||
public void setYOffset(int off) { | |||
yoffset = off; | |||
} | |||
/** | |||
* Add the areas for the break points. | |||
* This sets the offset of each cell as it is added. | |||
* | |||
* @param parentIter the position iterator | |||
* @param layoutContext the layout context for adding areas | |||
*/ | |||
public void addAreas(PositionIterator parentIter, | |||
LayoutContext layoutContext) { | |||
getParentArea(null); | |||
addID(); | |||
Item childLM; | |||
int iStartPos = 0; | |||
LayoutContext lc = new LayoutContext(0); | |||
while (parentIter.hasNext()) { | |||
ItemPosition lfp = (ItemPosition) parentIter.next(); | |||
// Add the block areas to Area | |||
int xoffset = 0; | |||
for (Iterator iter = lfp.cellBreaks.iterator(); iter.hasNext();) { | |||
List cellsbr = (List)iter.next(); | |||
PositionIterator breakPosIter; | |||
breakPosIter = new BreakPossPosIter(cellsbr, 0, cellsbr.size()); | |||
iStartPos = lfp.getLeafPos() + 1; | |||
while ((childLM = (Item)breakPosIter.getNextChildLM()) != null) { | |||
if(childLM == body) { | |||
childLM.setXOffset(24000); | |||
} | |||
childLM.addAreas(breakPosIter, lc); | |||
} | |||
xoffset += 100000; | |||
} | |||
} | |||
curBlockArea.setHeight(listItemHeight); | |||
flush(); | |||
} | |||
/** | |||
* Get the height of the list item after adjusting. | |||
* Should only be called after adding the list item areas. | |||
* | |||
* @return the height of this list item after adjustment | |||
*/ | |||
public int getListItemHeight() { | |||
return listItemHeight; | |||
} | |||
/** | |||
* Return an Area which can contain the passed childArea. The childArea | |||
* may not yet have any content, but it has essential traits set. | |||
* In general, if the LayoutManager already has an Area it simply returns | |||
* it. Otherwise, it makes a new Area of the appropriate class. | |||
* It gets a parent area for its area by calling its parent LM. | |||
* Finally, based on the dimensions of the parent area, it initializes | |||
* its own area. This includes setting the content IPD and the maximum | |||
* BPD. | |||
* | |||
* @param childArea the child area | |||
* @return the parent are for the child | |||
*/ | |||
public Area getParentArea(Area childArea) { | |||
if (curBlockArea == null) { | |||
curBlockArea = new Block(); | |||
// Set up dimensions | |||
Area parentArea = parentLM.getParentArea(curBlockArea); | |||
int referenceIPD = parentArea.getIPD(); | |||
curBlockArea.setIPD(referenceIPD); | |||
curBlockArea.setWidth(referenceIPD); | |||
// Get reference IPD from parentArea | |||
setCurrentArea(curBlockArea); // ??? for generic operations | |||
} | |||
return curBlockArea; | |||
} | |||
/** | |||
* Add the child. | |||
* Rows return the areas returned by the child elements. | |||
* This simply adds the area to the parent layout manager. | |||
* | |||
* @param childArea the child area | |||
* @return unused | |||
*/ | |||
public boolean addChild(Area childArea) { | |||
if (curBlockArea != null) { | |||
curBlockArea.addBlock((Block) childArea); | |||
return false; | |||
} | |||
return false; | |||
} | |||
/** | |||
* Reset the position of this layout manager. | |||
* | |||
* @param resetPos the position to reset to | |||
*/ | |||
public void resetPosition(Position resetPos) { | |||
if (resetPos == null) { | |||
reset(null); | |||
} | |||
} | |||
} | |||
@@ -167,8 +167,10 @@ public class Row extends BlockStackingLayoutManager { | |||
if (stackSize.min > min) { | |||
min = stackSize.min; | |||
} | |||
// the optimum is the average of all optimums | |||
opt += stackSize.opt; | |||
// the optimum is the minimum of all optimums | |||
if (stackSize.opt > opt) { | |||
opt = stackSize.opt; | |||
} | |||
// the maximum is the largest maximum | |||
if (stackSize.max > max) { | |||
max = stackSize.max; | |||
@@ -176,10 +178,6 @@ public class Row extends BlockStackingLayoutManager { | |||
breakList.add(childBreaks); | |||
} | |||
opt = opt / cellcount; | |||
if (opt < min) { | |||
opt = min; | |||
} | |||
rowHeight = opt; | |||
MinOptMax rowSize = new MinOptMax(min, opt, max); |