Initial implementation of CTM (coordinate transformation matrix) to handle reference-orienation and writing-mode issues

git-svn-id: https://svn.apache.org/repos/asf/xmlgraphics/fop/trunk@194642 13f79535-47bb-0310-9956-ffa450edef68

12 files changed, 385 insertions, 73 deletions

diff --git a/src/org/apache/fop/area/BodyRegion.java b/src/org/apache/fop/area/BodyRegion.java
index 78693d71f..f6f292683 100644
--- a/src/org/apache/fop/area/BodyRegion.java
+++ b/src/org/apache/fop/area/BodyRegion.java
@@ -13,6 +13,8 @@ public class BodyRegion extends RegionReference {
     BeforeFloat beforeFloat;
     MainReference mainReference;
     Footnote footnote;
+    private int columnGap;
+    private int columnCount;
 
     /** Maximum block progression dimension. Note: min=opt=max */
     private MinOptMax maxBPD;
@@ -24,6 +26,16 @@ public class BodyRegion extends RegionReference {
         super(BODY);
     }
 
+    // Number of columns when not spanning
+    public void setColumnCount(int colCount) {
+	this.columnCount = colCount;
+    }
+
+    // A length (mpoints)
+    public void setColumnGap(int colGap) {
+	this.columnGap = colGap;
+    }
+
     public void setParent(Area area) {
 	super.setParent(area);
 	// Only if not scrolling or overflow !!!
diff --git a/src/org/apache/fop/area/CTM.java b/src/org/apache/fop/area/CTM.java
new file mode 100644
index 000000000..6ed7ea726
--- /dev/null
+++ b/src/org/apache/fop/area/CTM.java
@@ -0,0 +1,170 @@
+/*
+ * $Id$
+ * Copyright (C) 2001 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.area;
+
+import java.awt.geom.Rectangle2D;
+import java.awt.Rectangle;
+import java.io.Serializable;
+
+import org.apache.fop.fo.properties.WritingMode;
+
+/**
+ * Describe a PDF or PostScript style coordinate transformation matrix (CTM).
+ * The matrix encodes translations, scaling and rotations of the coordinate
+ * system used to render pages.
+ */
+
+public class CTM implements Serializable {
+    private double a,b,c,d,e,f;
+
+    private static CTM s_CTM_lrtb = new CTM(1,0,0,-1,0,0);
+    private static CTM s_CTM_rltb = new CTM(-1,0,0,-1,0,0);
+    private static CTM s_CTM_tbrl = new CTM(0,-1,-1,0,0,0);
+/**
+ * Create the identity matrix
+ */
+    public CTM() {
+        a=1;
+        b=0;
+        c=0;
+        d=1;
+        e=0;
+        f=0;
+    }
+
+    /**
+     * Initialize a CTM from the passed arguments.
+     */
+    public CTM(double a, double b, double c, double d, double e, double f) {
+        this.a = a;
+        this.b = b;
+        this.c = c;
+        this.d = d;
+        this.e = e;
+        this.f = f;
+    }
+
+    /**
+     * Initialize a CTM to the identity matrix with a translation
+     * specified by x and y.
+     */
+    public CTM(double x, double y) {
+        this.a = 1;
+        this.b = 0;
+        this.c = 0;
+        this.d = 1;
+        this.e = x;
+        this.f = y;
+    }
+
+    /**
+     * Return a CTM which will transform coordinates for a particular writing-mode
+     * into normalized first quandrant coordinates.
+     * @param wm A writing mode constant from fo.properties.WritingMode, ie.
+     * one of LR_TB, RL_TB, TB_RL.
+     * @param ipd The inline-progression dimension of the reference area whose
+     * CTM is being set..
+     * @param bpd The block-progression dimension of the reference area whose
+     * CTM is being set.
+     */
+    static public CTM getWMctm(int wm, int ipd, int bpd) {
+        switch (wm) {
+            case WritingMode.LR_TB:
+                return s_CTM_lrtb.translate(0,bpd);
+            case WritingMode.RL_TB:
+                return  s_CTM_rltb.translate(ipd, bpd);
+            case WritingMode.TB_RL: // CJK
+                return s_CTM_tbrl.translate(bpd, ipd);
+	    default:
+		return null;
+        }
+    }
+
+    /**
+     * Multiply new passed CTM with this one and generate a new result CTM.
+     * @param premult The CTM to multiply with this one. The new one will be
+     * the first multiplicand.
+     * @return CTM The result of multiplying premult * this.
+     */
+    public CTM multiply(CTM premult) {
+        CTM rslt= new CTM (
+            (premult.a * a) + (premult.b * c),
+            (premult.a * b) + (premult.b * d),
+            (premult.c * a) + (premult.d * c),
+            (premult.c * b) + (premult.d * d),
+            (premult.e * a) + (premult.f * c) + e,
+            (premult.e * b) + (premult.f * d) + f
+        );
+        return rslt;
+    }
+
+    /**
+     * Rotate this CTM by "angle" radians and return a new result CTM.
+     * This is used to account for reference-orientation.
+     * @param angle The angle in radians. Positive angles are measured counter-
+     * clockwise.
+     * @return CTM The result of rotating this CTM.
+     */
+    public CTM rotate(double angle) {
+	double rad = Math.toRadians(angle);
+	double cos = Math.cos(rad);
+	double sin = Math.sin(rad);
+        CTM rotate= new CTM(cos, sin, -sin, cos, 0, 0);
+        return multiply(rotate);
+    }
+
+    /**
+     * Translate this CTM by the passed x and y values and return a new result CTM.
+     * @param x The amount to translate along the x axis.
+     * @param y The amount to translate along the y axis.
+     * @return CTM The result of translating this CTM.
+     */
+    public CTM translate(double x, double y) {
+        CTM translate= new CTM(1,0,0,1,x,y);
+        return multiply(translate);
+    }
+
+    /**
+     * Scale this CTM by the passed x and y values and return a new result CTM.
+     * @param x The amount to scale along the x axis.
+     * @param y The amount to scale along the y axis.
+     * @return CTM The result of scaling this CTM.
+     */
+    public CTM scale(double x, double y) {
+        CTM scale= new CTM(x,0,0,y,0,0);
+        return multiply(scale);
+    }
+
+    /**
+     * Transform a rectangle by the CTM to produce a rectangle in the transformed
+     * coordinate system.
+     * @param inRect The rectangle in the original coordinate system
+     * @return Rectangle2D The rectangle in the transformed coordinate system.
+     */
+    public Rectangle2D transform(Rectangle2D inRect) {
+        // Store as 2 sets of 2 points and transform those, then
+        // recalculate the width and height
+        int x1t = (int)(inRect.getX()*a + inRect.getY()*c + e);
+        int y1t = (int)(inRect.getX()*b + inRect.getY()*d + f);
+        int x2t = (int)((inRect.getX()+inRect.getWidth())*a +
+            (inRect.getY()+inRect.getHeight())*c + e);
+        int y2t = (int)((inRect.getX()+inRect.getWidth())*b +
+            (inRect.getY()+inRect.getHeight())*d + f);
+        // Normalize with x1 < x2
+        if (x1t > x2t) {
+            int tmp = x2t;
+            x2t = x1t;
+            x1t = tmp;
+        }
+        if (y1t > y2t) {
+            int tmp = y2t;
+            y2t = y1t;
+            y1t = tmp;
+        }
+        return new Rectangle(x1t, y1t, x2t-x1t, y2t-y1t);
+    }
+}
diff --git a/src/org/apache/fop/area/RegionReference.java b/src/org/apache/fop/area/RegionReference.java
index 709bbbc43..f4fd6734b 100644
--- a/src/org/apache/fop/area/RegionReference.java
+++ b/src/org/apache/fop/area/RegionReference.java
@@ -18,11 +18,23 @@ public class RegionReference extends Area implements Serializable {
     public static final int END = 3;
     public static final int AFTER = 4;
     int regionClass = BEFORE;
+    private CTM ctm;
 
     public RegionReference(int type) {
         regionClass = type;
     }
 
+    /**
+     * Set the Coordinate Transformation Matrix which transforms content
+     * coordinates in this region reference area which are specified in
+     * terms of "start" and "before" into coordinates in a system which
+     * is positioned in "absolute" directions (with origin at lower left of
+     * the region reference area.
+     */
+    public void setCTM(CTM ctm) {
+        this.ctm = ctm;
+    }
+
     // the list of block areas from the static flow
     ArrayList blocks = new ArrayList();
 
diff --git a/src/org/apache/fop/datatypes/FODimension.java b/src/org/apache/fop/datatypes/FODimension.java
new file mode 100644
index 000000000..e9acf32a9
--- /dev/null
+++ b/src/org/apache/fop/datatypes/FODimension.java
@@ -0,0 +1,26 @@
+/*
+ * $Id$
+ * Copyright (C) 2001 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.datatypes;
+
+
+/**
+ * This datatype hold a pair of resolved lengths,
+ * specifiying the dimensions in
+ * both inline and block-progression-directions.
+ */
+public class FODimension {
+
+    public int ipd;
+    public int bpd;
+
+
+    public FODimension(int ipd, int bpd) {
+	this.ipd = ipd;
+	this.bpd = bpd;
+    }
+}
diff --git a/src/org/apache/fop/fo/PropertyManager.java b/src/org/apache/fop/fo/PropertyManager.java
index dfbabd383..6048d4937 100644
--- a/src/org/apache/fop/fo/PropertyManager.java
+++ b/src/org/apache/fop/fo/PropertyManager.java
@@ -7,6 +7,10 @@
 
 package org.apache.fop.fo;
 
+
+import java.awt.geom.Rectangle2D;
+import org.apache.fop.area.CTM;
+import org.apache.fop.datatypes.FODimension;
 import org.apache.fop.layout.FontState;
 import org.apache.fop.layout.FontInfo;
 import org.apache.fop.layout.BorderAndPadding;
@@ -20,6 +24,7 @@ import org.apache.fop.layout.AbsolutePositionProps;
 import org.apache.fop.fo.properties.BreakAfter;
 import org.apache.fop.fo.properties.BreakBefore;
 import org.apache.fop.fo.properties.Constants;
+import org.apache.fop.fo.properties.WritingMode;
 import org.apache.fop.layout.HyphenationProps;
 import org.apache.fop.apps.FOPException;
 import java.text.MessageFormat;
@@ -187,6 +192,7 @@ public class PropertyManager {
         }
     }
 
+
     public MarginProps getMarginProps() {
         MarginProps props = new MarginProps();
 
@@ -199,13 +205,15 @@ public class PropertyManager {
             this.properties.get("margin-left").getLength().mvalue();
         props.marginRight =
             this.properties.get("margin-right").getLength().mvalue();
-        /*
-         * // need to get opt, min and max
-         * props.spaceBefore = this.properties.get("space-before").getLength().mvalue();
-         * props.spaceAfter = this.properties.get("space-after").getLength().mvalue();
-         * props.startIndent = this.properties.get("start-indent").getLength().mvalue();
-         * props.endIndent = this.properties.get("end-indent").getLength().mvalue();
-         */
+
+        // For now, we only get the optimum value for space-before and after
+        props.spaceBefore = this.properties.get("space-before").getSpace().
+	    getOptimum().getLength().mvalue();
+        props.spaceAfter = this.properties.get("space-after").getSpace().
+	    getOptimum().getLength().mvalue();
+        props.startIndent = this.properties.get("start-indent").getLength().mvalue();
+        props.endIndent = this.properties.get("end-indent").getLength().mvalue();
+
         return props;
     }
 
@@ -247,4 +255,69 @@ public class PropertyManager {
         AbsolutePositionProps props = new AbsolutePositionProps();
         return props;
     }
+
+    public CTM getCTMandRelDims(Rectangle2D absVPrect, FODimension reldims) {
+	int width, height;
+        // We will use the absolute reference-orientation to set up the CTM.
+        // The value here is relative to its ancestor reference area.
+        int absRefOrient =
+            getAbsRefOrient(this.properties.get("reference-orientation").
+			    getNumber().intValue());
+        if (absRefOrient % 180 == 0) {
+            width = (int)absVPrect.getWidth();
+            height = (int)absVPrect.getHeight();
+        }
+        else {
+            // invert width and height since top left are rotated by 90 (cl or ccl)
+            height = (int)absVPrect.getWidth();
+            width = (int)absVPrect.getHeight();
+        }
+        /* Set up the CTM for the content of this reference area. This will transform
+         * region content coordinates in writing-mode relative into absolute page-relative
+         * which will then be translated based on the position of the region viewport
+         * (Note: scrolling between region vp and ref area when doing online content!)
+         */
+         CTM ctm = new CTM(absVPrect.getX(), absVPrect.getY());
+         // First transform for rotation
+         if (absRefOrient != 0) {
+            // Rotation implies translation to keep the drawing area in the
+            // first quadrant. Note: rotation is counter-clockwise
+             switch (absRefOrient) {
+               case 90:
+                ctm = ctm.translate(height, 0); // height = absVPrect.width
+                break;
+            case 180:
+                ctm = ctm.translate(width, height);
+                break;
+            case 270:
+                ctm = ctm.translate(0, width); // width = absVPrect.height
+                break;
+           }
+           ctm = ctm.rotate(absRefOrient);
+         }
+        int wm = this.properties.get("writing-mode").getEnum();
+        /* Since we've already put adjusted width and height values for the
+         * top and left positions implied by the reference-orientation, we
+         * can set ipd and bpd appropriately based on the writing mode.
+         */
+
+        if (wm == WritingMode.LR_TB || wm == WritingMode.RL_TB) {
+            reldims.ipd = width;
+            reldims.bpd = height;
+        }
+        else {
+            reldims.ipd=height;
+            reldims.bpd=width;
+        }
+	// Set a rectangle to be the writing-mode relative version???
+	// Now transform for writing mode
+        return ctm.multiply(CTM.getWMctm(wm, reldims.ipd, reldims.bpd));
+    }
+
+    /**
+     * Calculate absolute reference-orientation relative to media orientation.
+     */
+    private int getAbsRefOrient(int myRefOrient) {
+	return myRefOrient;
+    }
 }
diff --git a/src/org/apache/fop/fo/pagination/Region.java b/src/org/apache/fop/fo/pagination/Region.java
index cfbc8c27f..eec03b821 100644
--- a/src/org/apache/fop/fo/pagination/Region.java
+++ b/src/org/apache/fop/fo/pagination/Region.java
@@ -8,14 +8,18 @@
 package org.apache.fop.fo.pagination;
 
 import java.awt.Rectangle;
+import java.awt.geom.Rectangle2D;
 
 // FOP
+
+import org.apache.fop.datatypes.FODimension;
 import org.apache.fop.fo.FObj;
 import org.apache.fop.fo.FONode;
 import org.apache.fop.fo.PropertyList;
 import org.apache.fop.layout.BorderAndPadding;
 import org.apache.fop.layout.BackgroundProps;
 import org.apache.fop.apps.FOPException;
+import org.apache.fop.area.CTM;
 import org.apache.fop.area.RegionViewport;
 import org.apache.fop.area.RegionReference;
 
@@ -75,21 +79,30 @@ public abstract class Region extends FObj {
     /**
      * Creates a RegionViewport Area object for this pagination Region.
      */
-    public RegionViewport makeRegionViewport(Rectangle pageRefRect) {
-	return new RegionViewport(getViewportRectangle(pageRefRect));
+    public RegionViewport makeRegionViewport(FODimension reldims, CTM pageCTM) {
+        Rectangle2D relRegionRect = getViewportRectangle(reldims);
+        Rectangle2D absRegionRect = pageCTM.transform(relRegionRect);
+        // Get the region viewport rectangle in absolute coords by
+        // transforming it using the page CTM
+	return new RegionViewport(absRegionRect);
     }
 
 
-    abstract protected Rectangle getViewportRectangle(Rectangle pageRefRect);
-
+    abstract protected Rectangle getViewportRectangle(FODimension pageRefRect);
 
-    public RegionReference makeRegionReferenceArea() {
+    /**
+     * Create the region reference area for this region master.
+     * @param absRegVPRect The region viewport rectangle is "absolute" coordinates
+     * where x=distance from left, y=distance from bottom, width=right-left
+     * height=top-bottom
+     */
+    public RegionReference makeRegionReferenceArea(Rectangle2D absRegVPRect) {
 	RegionReference r = new RegionReference(getRegionAreaClass());
-	setRegionTraits(r);
+	setRegionTraits(r, absRegVPRect);
 	return r;
     }
 
-    protected void setRegionTraits(RegionReference r) {
+    protected void setRegionTraits(RegionReference r, Rectangle2D absRegVPRect) {
         // Common Border, Padding, and Background Properties
         BorderAndPadding bap = propMgr.getBorderAndPadding();
         BackgroundProps bProps = propMgr.getBackgroundProps();
@@ -99,9 +112,9 @@ public abstract class Region extends FObj {
         // this.properties.get("clip");
         // this.properties.get("display-align");
         this.overflow = this.properties.get("overflow").getEnum();
-        // this.properties.get("reference-orientation");
-        // this.properties.get("writing-mode");
-                    
+	FODimension reldims = new FODimension(0,0);
+	r.setCTM(propMgr.getCTMandRelDims(absRegVPRect, reldims));
+
 	//r.setBackground(bProps);
     }
 
diff --git a/src/org/apache/fop/fo/pagination/RegionAfter.java b/src/org/apache/fop/fo/pagination/RegionAfter.java
index c1466001c..a44dd2569 100644
--- a/src/org/apache/fop/fo/pagination/RegionAfter.java
+++ b/src/org/apache/fop/fo/pagination/RegionAfter.java
@@ -9,6 +9,7 @@ package org.apache.fop.fo.pagination;
 
 // FOP
 import org.apache.fop.fo.*;
+import org.apache.fop.datatypes.FODimension;
 import org.apache.fop.apps.FOPException;
 import org.apache.fop.area.RegionReference;
 
@@ -23,13 +24,11 @@ public class RegionAfter extends RegionBA {
     }
 
 
-    protected Rectangle getViewportRectangle (Rectangle pageRefRect) {
+    protected Rectangle getViewportRectangle (FODimension reldims) {
 	// Depends on extent and precedence
 	Rectangle vpRect =
-	    new Rectangle((int)pageRefRect.getX(),
-			  (int)pageRefRect.getY() - (int)pageRefRect.getHeight() + 
-			  getExtent(),
-			  (int)pageRefRect.getWidth(), getExtent());
+	    new Rectangle(0, reldims.bpd - getExtent(),
+			  reldims.ipd, getExtent());
 	if (getPrecedence() == false) {
 	    adjustIPD(vpRect);
 	}
diff --git a/src/org/apache/fop/fo/pagination/RegionBefore.java b/src/org/apache/fop/fo/pagination/RegionBefore.java
index f829ef6b5..de79eb28e 100644
--- a/src/org/apache/fop/fo/pagination/RegionBefore.java
+++ b/src/org/apache/fop/fo/pagination/RegionBefore.java
@@ -8,6 +8,8 @@
 package org.apache.fop.fo.pagination;
 
 // FOP
+
+import org.apache.fop.datatypes.FODimension;
 import org.apache.fop.fo.*;
 import org.apache.fop.apps.FOPException;
 import org.apache.fop.area.RegionReference;
@@ -40,10 +42,14 @@ public class RegionBefore extends RegionBA {
     }
 
 
-    protected Rectangle getViewportRectangle (Rectangle pageRefRect) {
+    protected Rectangle getViewportRectangle (FODimension reldims) {
 	// Depends on extent and precedence
-	Rectangle vpRect = new Rectangle(pageRefRect);
-	vpRect.height = getExtent();
+      // This should return rectangle in writing-mode coordinates relative
+      // to the page-reference area rectangle
+      // This means the origin is (start, before) and the dimensions are (ipd,bpd)
+      // Before is always 0, start depends on extent
+      // ipd depends on precedence, bpd=extent
+	Rectangle vpRect = new Rectangle(0, 0, reldims.ipd, getExtent());
 	if (getPrecedence() == false) {
 	    adjustIPD(vpRect);
 	}
diff --git a/src/org/apache/fop/fo/pagination/RegionBody.java b/src/org/apache/fop/fo/pagination/RegionBody.java
index e99561772..181f6378a 100644
--- a/src/org/apache/fop/fo/pagination/RegionBody.java
+++ b/src/org/apache/fop/fo/pagination/RegionBody.java
@@ -8,12 +8,15 @@
 package org.apache.fop.fo.pagination;
 
 import java.awt.Rectangle;
+import java.awt.geom.Rectangle2D;
 
 // FOP
+
 import org.apache.fop.fo.FONode;
 import org.apache.fop.fo.PropertyList;
 import org.apache.fop.fo.properties.Overflow;
 import org.apache.fop.datatypes.ColorType;
+import org.apache.fop.datatypes.FODimension;
 import org.apache.fop.apps.FOPException;
 import org.apache.fop.area.RegionReference;
 import org.apache.fop.area.BodyRegion;
@@ -27,43 +30,19 @@ public class RegionBody extends Region {
         super(parent);
     }
 
-    protected Rectangle getViewportRectangle (Rectangle pageRefRect)
+    protected Rectangle getViewportRectangle (FODimension reldims)
     {
         // Common Margin Properties-Block
+	// Need these in writing-mode relative coordinates
+	// Or shall we get absolute and transform to relative using writing mode?
         MarginProps mProps = propMgr.getMarginProps();
-        return
-	    new Rectangle((int)pageRefRect.getX() + mProps.marginLeft,
-			  (int)pageRefRect.getY() - mProps.marginTop,
-			  (int)pageRefRect.getWidth() - mProps.marginLeft -
-			  mProps.marginRight,
-			  (int)pageRefRect.getHeight() - mProps.marginTop -
-			  mProps.marginBottom);
+        return new Rectangle( mProps.startIndent, mProps.spaceBefore,
+			      reldims.ipd - mProps.startIndent - mProps.endIndent,
+			      reldims.bpd - mProps.spaceBefore - mProps.spaceAfter);
     }
 
-    protected void setRegionTraits(RegionReference r) {
-	super.setRegionTraits(r);
-
-        String columnCountAsString =
-            this.properties.get("column-count").getString();
-        int columnCount = 1;
-        try {
-            columnCount = Integer.parseInt(columnCountAsString);
-        } catch (NumberFormatException nfe) {
-            log.error("Bad value on region body 'column-count'");
-            columnCount = 1;
-        }
-        if ((columnCount > 1) && (overflow == Overflow.SCROLL)) {
-            // recover by setting 'column-count' to 1. This is allowed but
-            // not required by the spec.
-            log.error("Setting 'column-count' to 1 because "
-                                   + "'overflow' is set to 'scroll'");
-            columnCount = 1;
-        }
-//         r.setColumnCount(columnCount);
-
-//         int columnGap =
-//             this.properties.get("column-gap").getLength().mvalue();
-//         r.setColumnGap(columnGap);
+    protected void setRegionTraits(RegionReference r, Rectangle2D absRegVPRect) {
+	super.setRegionTraits(r, absRegVPRect);
 
 //         r.setBackgroundColor(backgroundColor);
     }
@@ -84,9 +63,24 @@ public class RegionBody extends Region {
     /**
      * Override the inherited method.
      */
-    public RegionReference makeRegionReferenceArea() {
+    public RegionReference makeRegionReferenceArea(Rectangle2D absRegVPRect) {
 	// Should set some column stuff here I think, or put it elsewhere
-	return new BodyRegion();
+	BodyRegion body = new BodyRegion();
+        int columnCount=
+            this.properties.get("column-count").getNumber().intValue();
+        if ((columnCount > 1) && (overflow == Overflow.SCROLL)) {
+            // recover by setting 'column-count' to 1. This is allowed but
+            // not required by the spec.
+            log.error("Setting 'column-count' to 1 because "
+                                   + "'overflow' is set to 'scroll'");
+            columnCount = 1;
+        }
+	body.setColumnCount(columnCount);
+
+        int columnGap =
+             this.properties.get("column-gap").getLength().mvalue();
+	body.setColumnGap(columnGap);
+	return body;
     }
 
 }
diff --git a/src/org/apache/fop/fo/pagination/RegionEnd.java b/src/org/apache/fop/fo/pagination/RegionEnd.java
index 68f4cabd2..32cacef50 100644
--- a/src/org/apache/fop/fo/pagination/RegionEnd.java
+++ b/src/org/apache/fop/fo/pagination/RegionEnd.java
@@ -11,6 +11,7 @@ import java.awt.Rectangle;
 
 // FOP
 import org.apache.fop.fo.*;
+import org.apache.fop.datatypes.FODimension;
 import org.apache.fop.apps.FOPException;
 import org.apache.fop.area.RegionReference;
 
@@ -24,18 +25,15 @@ public class RegionEnd extends RegionSE {
     }
 
 
-    protected Rectangle getViewportRectangle (Rectangle pageRefRect) {
+    protected Rectangle getViewportRectangle (FODimension reldims) {
 	// Depends on extent and precedence
 	Rectangle vpRect =
-	    new Rectangle((int)pageRefRect.getX() + (int)pageRefRect.getWidth() -
-			  getExtent(),
-			  (int)pageRefRect.getY(),
-			  getExtent(), (int)pageRefRect.getHeight());
+	    new Rectangle(reldims.ipd - getExtent(), 0,
+			  getExtent(), reldims.bpd);
 	adjustIPD(vpRect);
 	return vpRect;
     }
 
-
     protected String getDefaultRegionName() {
         return "xsl-region-end";
     }
diff --git a/src/org/apache/fop/fo/pagination/RegionStart.java b/src/org/apache/fop/fo/pagination/RegionStart.java
index bd61b2c8c..e74384837 100644
--- a/src/org/apache/fop/fo/pagination/RegionStart.java
+++ b/src/org/apache/fop/fo/pagination/RegionStart.java
@@ -12,6 +12,7 @@ import java.awt.Rectangle;
 
 // FOP
 import org.apache.fop.fo.*;
+import org.apache.fop.datatypes.FODimension;
 import org.apache.fop.apps.FOPException;
 import org.apache.fop.area.RegionReference;
 
@@ -24,12 +25,12 @@ public class RegionStart extends RegionSE {
     }
 
 
-    protected Rectangle getViewportRectangle (Rectangle pageRefRect) {
+    protected Rectangle getViewportRectangle (FODimension reldims) {
 	// Depends on extent and precedence
+        // This is the rectangle relative to the page-reference area in
+        // writing-mode relative coordinates
 	Rectangle vpRect =
-	    new Rectangle((int)pageRefRect.getX(),
-			  (int)pageRefRect.getY(),
-			  getExtent(), (int)pageRefRect.getHeight());
+	    new Rectangle(0, 0, getExtent(), reldims.bpd);
 	adjustIPD(vpRect);
 	return vpRect;
     }
diff --git a/src/org/apache/fop/fo/pagination/SimplePageMaster.java b/src/org/apache/fop/fo/pagination/SimplePageMaster.java
index d5b6d9f4e..42b4c4f0e 100644
--- a/src/org/apache/fop/fo/pagination/SimplePageMaster.java
+++ b/src/org/apache/fop/fo/pagination/SimplePageMaster.java
@@ -10,6 +10,8 @@ package org.apache.fop.fo.pagination;
 // FOP
 import org.apache.fop.fo.*;
 import org.apache.fop.fo.properties.*;
+import org.apache.fop.area.CTM;
+import org.apache.fop.datatypes.FODimension;
 import org.apache.fop.area.PageViewport;
 import org.apache.fop.area.Page;
 import org.apache.fop.area.RegionViewport;
@@ -19,6 +21,7 @@ import org.apache.fop.layout.PageMaster;
 import org.apache.fop.apps.FOPException;
 
 import java.awt.Rectangle;
+import java.awt.geom.Rectangle2D;
 import java.util.HashMap;
 import java.util.Iterator;
 import org.xml.sax.Attributes;
@@ -73,7 +76,7 @@ public class SimplePageMaster extends FObj {
         // this.properties.get("reference-orientation");
         // this.properties.get("writing-mode");
 
-        // Common Margin Properties-Block
+        // Get absolute margin properties (top, left, bottom, right)
         MarginProps mProps = propMgr.getMarginProps();
 
 	/* Create the page reference area rectangle in first quadrant coordinates
@@ -82,13 +85,18 @@ public class SimplePageMaster extends FObj {
 	 * The media rectangle itself is (0,0,pageWidth,pageHeight).
 	 */
 	Rectangle pageRefRect =
-	    new Rectangle(mProps.marginLeft, pageHeight - mProps.marginTop,
+	    new Rectangle(mProps.marginLeft, mProps.marginBottom,
 			  pageWidth - mProps.marginLeft - mProps.marginRight,
 			  pageHeight - mProps.marginTop - mProps.marginBottom);
 
 	// ??? KL shouldn't this take the viewport too???
 	Page page = new Page();  // page reference area
 
+        // Set up the CTM on the page reference area based on writing-mode
+        // and reference-orientation
+	FODimension reldims=new FODimension(0,0);
+	CTM pageCTM = propMgr.getCTMandRelDims(pageRefRect, reldims);
+
 	// Create a RegionViewport/ reference area pair for each page region
 
 	boolean bHasBody=false;
@@ -96,8 +104,8 @@ public class SimplePageMaster extends FObj {
         for (Iterator regenum = _regions.values().iterator();
                 regenum.hasNext(); ) {
             Region r = (Region)regenum.next();
-	    RegionViewport rvp = r.makeRegionViewport(pageRefRect);
-	    rvp.setRegion(r.makeRegionReferenceArea());
+	    RegionViewport rvp = r.makeRegionViewport(reldims, pageCTM);
+	    rvp.setRegion(r.makeRegionReferenceArea(rvp.getViewArea()));
 	    page.setRegion(r.getRegionAreaClass(), rvp);
 	    if (r.getRegionAreaClass() == RegionReference.BODY) {
 		bHasBody = true;