init

.classpath

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="gen"/>
+	<classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
+	<classpathentry exported="true" kind="con" path="com.android.ide.eclipse.adt.LIBRARIES"/>
+	<classpathentry exported="true" kind="con" path="com.android.ide.eclipse.adt.DEPENDENCIES"/>
+	<classpathentry kind="output" path="bin/classes"/>
+</classpath>

.gitignore

@@ -0,0 +1,3 @@
+/bin
+/gen
+/.settings

.project

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>AndroidPdfViewer</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.ResourceManagerBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.PreCompilerBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.ApkBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>com.android.ide.eclipse.adt.AndroidNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

AndroidManifest.xml

@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="net.sf.andpdf.pdfviewer"
+    android:versionCode="19"
+    android:versionName="0.1.12b" >
+
+    <application
+        android:icon="@drawable/icon"
+        android:label="@string/app_name" >
+        <activity android:name=".PdfViewerActivity" >
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+
+                <category android:name="android.intent.category.DEFAULT" />
+
+                <data android:mimeType="application/pdf" />
+            </intent-filter>
+        </activity>
+        <activity
+            android:name=".PdfFileSelectActivity"
+            android:label="@string/app_name" >
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+
+    <uses-sdk android:minSdkVersion="3" />
+
+</manifest>

proguard-project.txt

@@ -0,0 +1,20 @@
+# To enable ProGuard in your project, edit project.properties
+# to define the proguard.config property as described in that file.
+#
+# Add project specific ProGuard rules here.
+# By default, the flags in this file are appended to flags specified
+# in ${sdk.dir}/tools/proguard/proguard-android.txt
+# You can edit the include path and order by changing the ProGuard
+# include property in project.properties.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# Add any project specific keep options here:
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}

project.properties

@@ -0,0 +1,14 @@
+# This file is automatically generated by Android Tools.
+# Do not modify this file -- YOUR CHANGES WILL BE ERASED!
+#
+# This file must be checked in Version Control Systems.
+#
+# To customize properties used by the Ant build system edit
+# "ant.properties", and override values to adapt the script to your
+# project structure.
+#
+# To enable ProGuard to shrink and obfuscate your code, uncomment this (available properties: sdk.dir, user.home):
+#proguard.config=${sdk.dir}\tools\proguard\proguard-android.txt:proguard-project.txt
+
+# Project target.
+target=android-21

res/layout/file_explorer.xml

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:orientation="vertical"
+    android:layout_width="fill_parent"
+    android:layout_height="fill_parent"
+    android:background="@drawable/violet"
+    >
+	<!-- Current absolute path -->
+   	<TextView  
+    	android:layout_width="fill_parent" 
+    	android:layout_height="wrap_content" 
+    	android:id="@+id/mPath"
+    	android:padding="5px"
+    	android:textSize="18sp"
+    	android:textColor="@drawable/white"
+    />
+    <!-- Current File Explorer Hierarchy -->
+	<ListView
+		android:layout_width="wrap_content" 
+    	android:layout_height="wrap_content" 
+    	android:id="@android:id/list"
+	/>
+    
+</LinearLayout>

res/layout/file_row.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:orientation="horizontal"
+    android:layout_width="fill_parent"
+    android:layout_height="fill_parent"
+    >
+    <!-- Item ICON -->
+	<ImageView  
+    	android:layout_width="30dip" 
+    	android:layout_height="30dip" 
+    	android:id="@+id/icon"
+    />
+    <!-- Item Name -->
+	<TextView
+		android:id="@+id/text"  
+    	android:layout_width="0dip" 
+    	android:layout_height="wrap_content" 
+    	android:layout_weight="1.0"
+    	android:layout_gravity="center_vertical"
+    	android:textColor="@drawable/black"
+    />
+</LinearLayout>

res/layout/main.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="fill_parent"
+    android:layout_height="fill_parent"
+    android:orientation="vertical" >
+
+    <TextView
+        android:layout_width="fill_parent"
+        android:layout_height="wrap_content"
+        android:text="@string/hello" />
+
+</LinearLayout>

res/layout/pdf_file_select.xml

@@ -0,0 +1,52 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:orientation="vertical"
+    android:layout_width="fill_parent"
+    android:layout_height="fill_parent"
+    >
+    
+	<!-- filename -->
+    <TextView
+        android:layout_width="wrap_content" android:layout_height="wrap_content"
+        android:layout_weight="0"
+        android:paddingBottom="0dip"
+        android:text="PDF-File:"/>
+    <EditText 
+        android:id="@+id/filename"
+        android:layout_width="fill_parent"
+        android:layout_height="wrap_content"
+        android:paddingBottom="0dip"
+        android:text="" 
+        android:hint="please enter a filename (e.g. /sdcard/download/test.pdf)" />
+
+	<!-- Show Images -->
+    <CheckBox android:id="@+id/cbAntiAlias"
+            android:paddingBottom="24sp"
+	        android:paddingTop="24sp"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="antialias" />
+    
+	<!-- Button 'Show' -->
+	<LinearLayout android:layout_width="fill_parent" android:layout_height="wrap_content" android:gravity="center_horizontal" android:orientation="horizontal" >
+		<Button android:id="@+id/btShow" android:layout_width="120px"  android:layout_height="40px" android:text="Show"></Button>
+		<Button android:id="@+id/btExit" android:layout_width="120px"  android:layout_height="40px" android:text="Exit"></Button>
+	</LinearLayout>
+	
+	<!-- Output -->
+    <EditText android:id="@+id/output"
+        android:layout_width="fill_parent" android:autoText="true"
+        android:capitalize="sentences"
+        android:layout_weight="1"
+        android:freezesText="true" android:layout_height="0dip"
+        android:text="[enter filename and press 'show']">
+        <requestFocus />
+    </EditText>
+    <ListView
+		android:layout_width="wrap_content" 
+    	android:layout_height="wrap_content" 
+    	android:id="@android:id/list"
+    	android:visibility="invisible"
+	/>
+    
+</LinearLayout>

res/values/color.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <drawable name="white">#FFFFFFFF</drawable>
+    <drawable name="black">#000000</drawable>
+    <drawable name="blue">#000000FF</drawable>
+    <drawable name="violet">#9370DB</drawable>
+</resources>

res/values/strings.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="hello">Hello World, PdfViewerActivity!</string>
+    <string name="app_name">Android PDF Viewer</string>
+</resources>

src/androswing/tree/DefaultMutableTreeNode.java

@@ -0,0 +1,30 @@
+package androswing.tree;
+
+import java.util.ArrayList;
+
+public class DefaultMutableTreeNode {
+	private DefaultMutableTreeNode parent;
+	private Object userObject; 
+	private ArrayList<DefaultMutableTreeNode> children;
+	protected DefaultMutableTreeNode(){
+		parent = null;
+		userObject = null;
+		children = new ArrayList<DefaultMutableTreeNode>();
+	}
+	protected Object getUserObject() {
+		return userObject;
+	}
+    protected void setUserObject(Object userObject) {
+    	this.userObject = userObject;
+	}
+
+	public void add(DefaultMutableTreeNode newChild) {
+		newChild.parent = this;
+		children.add(newChild);
+	}
+	public DefaultMutableTreeNode getParent() {
+		return parent;
+	}
+
+
+}

src/com/sun/pdfview/.cvsignore

@@ -0,0 +1 @@
+.DS_Store

src/com/sun/pdfview/BaseWatchable.java

@@ -0,0 +1,378 @@
+/*
+ * $Id: BaseWatchable.java,v 1.5 2009/02/09 17:14:32 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview;
+
+/**
+ * An abstract implementation of the watchable interface, that is extended
+ * by the parser and renderer to do their thing.
+ */
+public abstract class BaseWatchable implements Watchable, Runnable {
+
+    /** the current status, from the list in Watchable */
+    private int status = Watchable.UNKNOWN;
+    /** a lock for status-related operations */
+    private Object statusLock = new Object();
+    /** a lock for parsing operations */
+    private Object parserLock = new Object();
+    /** when to stop */
+    private Gate gate;
+    /** suppress local stack trace on setError. */
+    private static boolean SuppressSetErrorStackTrace = false;
+    /** the thread we are running in */
+    private Thread thread;
+
+    /** 
+     * Creates a new instance of BaseWatchable
+     */
+    protected BaseWatchable() {
+        setStatus(Watchable.NOT_STARTED);
+    }
+
+    /**
+     * Perform a single iteration of this watchable.  This is the minimum
+     * granularity which the go() commands operate over.
+     *
+     * @return one of three values: <ul>
+     *         <li> Watchable.RUNNING if there is still data to be processed
+     *         <li> Watchable.NEEDS_DATA if there is no data to be processed but
+     *              the execution is not yet complete
+     *         <li> Watchable.COMPLETED if the execution is complete
+     *  </ul>
+     */
+    protected abstract int iterate() throws Exception;
+
+    /** 
+     * Prepare for a set of iterations.  Called before the first iterate() call
+     * in a sequence.  Subclasses should extend this method if they need to do
+     * anything to setup.
+     */
+    protected void setup() {
+        // do nothing
+    }
+
+    /**
+     * Clean up after a set of iterations. Called after iteration has stopped
+     * due to completion, manual stopping, or error.
+     */
+    protected void cleanup() {
+        // do nothing
+    }
+
+    public void run() {
+        // System.out.println(Thread.currentThread().getName() + " starting");
+
+        // call setup once we started
+        if (getStatus() == Watchable.NOT_STARTED) {
+            setup();
+        }
+
+        setStatus(Watchable.PAUSED);
+
+        synchronized (parserLock) {
+            while (!isFinished() && getStatus() != Watchable.STOPPED) {
+                if (isExecutable()) {
+                    // set the status to running
+                    setStatus(Watchable.RUNNING);
+
+                    try {
+                        // keep going until the status is no longer running,
+                        // our gate tells us to stop, or no-one is watching
+                        while ((getStatus() == Watchable.RUNNING) &&
+                                (gate == null || !gate.iterate())) {
+                            // update the status based on this iteration
+                            setStatus(iterate());
+                        }
+
+                        // make sure we are paused
+                        if (getStatus() == Watchable.RUNNING) {
+                            setStatus(Watchable.PAUSED);
+                        }
+                    } catch (Exception ex) {
+                        setError(ex);
+                    }
+                } else {
+                    // System.out.println(getName() + " waiting: status = " + getStatusString());
+                    // wait for our status to change
+                    synchronized (statusLock) {
+                        if (!isExecutable()) {
+                            try {
+                                statusLock.wait();
+                            } catch (InterruptedException ie) {
+                                // ignore
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        // System.out.println(Thread.currentThread().getName() + " exiting: status = " + getStatusString());
+
+        // call cleanup when we are done
+        if (getStatus() == Watchable.COMPLETED ||
+                getStatus() == Watchable.ERROR) {
+
+            cleanup();
+        }
+
+        // notify that we are no longer running
+        thread = null;
+    }
+
+    /**
+     * Get the status of this watchable
+     *
+     * @return one of the well-known statuses
+     */
+    public int getStatus() {
+        return status;
+    }
+
+    /**
+     * Return whether this watchable has finished.  A watchable is finished
+     * when its status is either COMPLETED, STOPPED or ERROR
+     */
+    public boolean isFinished() {
+        int s = getStatus();
+        return (s == Watchable.COMPLETED ||
+                s == Watchable.ERROR);
+    }
+
+    /**
+     * return true if this watchable is ready to be executed
+     */
+    public boolean isExecutable() {
+        return ((status == Watchable.PAUSED || status == Watchable.RUNNING) &&
+                (gate == null || !gate.stop()));
+    }
+
+    /**
+     * Stop this watchable.  Stop will cause all processing to cease,
+     * and the watchable to be destroyed.
+     */
+    public void stop() {
+        setStatus(Watchable.STOPPED);
+    }
+
+    /**
+     * Start this watchable and run in a new thread until it is finished or
+     * stopped.
+     * Note the watchable may be stopped if go() with a
+     * different time is called during execution.
+     */
+    public synchronized void go() {
+        gate = null;
+
+        execute(false);
+    }
+
+    /**
+     * Start this watchable and run until it is finished or stopped.
+     * Note the watchable may be stopped if go() with a
+     * different time is called during execution.
+     *
+     * @param synchronous if true, run in this thread
+     */
+    public synchronized void go(boolean synchronous) {
+        gate = null;
+
+        execute(synchronous);
+    }
+
+    /**
+     * Start this watchable and run for the given number of steps or until
+     * finished or stopped.
+     *
+     * @param steps the number of steps to run for
+     */
+    public synchronized void go(int steps) {
+        gate = new Gate();
+        gate.setStopIterations(steps);
+
+        execute(false);
+    }
+
+    /**
+     * Start this watchable and run for the given amount of time, or until
+     * finished or stopped.
+     *
+     * @param millis the number of milliseconds to run for
+     */
+    public synchronized void go(long millis) {
+        gate = new Gate();
+        gate.setStopTime(millis);
+
+        execute(false);
+    }
+
+    /**
+     * Wait for this watchable to finish
+     */
+    public void waitForFinish() {
+        synchronized (statusLock) {
+            while (!isFinished() && getStatus() != Watchable.STOPPED) {
+                try {
+                    statusLock.wait();
+                } catch (InterruptedException ex) {
+                    // ignore
+                }
+            }
+        }
+    }
+
+    /**
+     * Start executing this watchable
+     *
+     * @param synchronous if true, run in this thread
+     */
+    protected synchronized void execute(boolean synchronous) {
+        // see if we're already running
+        if (thread != null) {
+            // we're already running. Make sure we wake up on any change.
+            synchronized (statusLock) {
+                statusLock.notifyAll();
+            }
+
+            return;
+        } else if (isFinished()) {
+            // we're all finished
+            return;
+        }
+
+        // we'return not running. Start up
+        if (synchronous) {
+            thread = Thread.currentThread();
+            run();
+        } else {
+            thread = new Thread(this);
+            thread.setName(getClass().getName());
+            thread.start();
+        }
+    }
+
+    /**
+     * Set the status of this watchable
+     */
+    protected void setStatus(int status) {
+        synchronized (statusLock) {
+            this.status = status;
+
+            // System.out.println(getName() + " status set to " + getStatusString());
+
+            statusLock.notifyAll();
+        }
+    }
+
+    /**
+     * return true if we would be suppressing setError stack traces.
+     * 
+     * @return  boolean
+     */
+    public static boolean isSuppressSetErrorStackTrace () {
+        return SuppressSetErrorStackTrace;
+    }
+
+    /**
+     * set suppression of stack traces from setError.
+     * 
+     * @param suppressTrace
+     */
+    public static void setSuppressSetErrorStackTrace(boolean suppressTrace) {
+        SuppressSetErrorStackTrace = suppressTrace;
+    }
+
+    /**
+     * Set an error on this watchable
+     */
+    protected void setError(Exception error) {
+        if (!SuppressSetErrorStackTrace) {
+            error.printStackTrace();
+        }
+
+        setStatus(Watchable.ERROR);
+    }
+
+    private String getStatusString() {
+        switch (getStatus()) {
+            case Watchable.NOT_STARTED:
+                return "Not started";
+            case Watchable.RUNNING:
+                return "Running";
+            case Watchable.NEEDS_DATA:
+                return "Needs Data";
+            case Watchable.PAUSED:
+                return "Paused";
+            case Watchable.STOPPED:
+                return "Stopped";
+            case Watchable.COMPLETED:
+                return "Completed";
+            case Watchable.ERROR:
+                return "Error";
+            default:
+                return "Unknown";
+
+        }
+    }
+
+    /** A class that lets us give it a target time or number of steps,
+     * and will tell us to stop after that much time or that many steps
+     */
+    class Gate {
+
+        /** whether this is a time-based (true) or step-based (false) gate */
+        private boolean timeBased;
+        /** the next gate, whether time or iterations */
+        private long nextGate;
+
+        /** set the stop time */
+        public void setStopTime(long millisFromNow) {
+            timeBased = true;
+            nextGate = System.currentTimeMillis() + millisFromNow;
+        }
+
+        /** set the number of iterations until we stop */
+        public void setStopIterations(int iterations) {
+            timeBased = false;
+            nextGate = iterations;
+        }
+
+        /** check whether we should stop.
+         */
+        public boolean stop() {
+            if (timeBased) {
+                return (System.currentTimeMillis() >= nextGate);
+            } else {
+                return (nextGate < 0);
+            }
+        }
+
+        /** Notify the gate of one iteration.  Returns true if we should
+         * stop or false if not
+         */
+        public boolean iterate() {
+            if (!timeBased) {
+                nextGate--;
+            }
+
+            return stop();
+        }
+    }
+}

src/com/sun/pdfview/Cache.java

@@ -0,0 +1,314 @@
+/*
+ * $Id: Cache.java,v 1.4 2009/02/12 13:53:56 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview;
+
+import java.lang.ref.SoftReference;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+import android.graphics.Bitmap;
+
+/**
+ * A cache of PDF pages and images.
+ */
+public class Cache {
+
+    /** the pages in the cache, mapped by page number */
+    private Map<Integer,SoftReference> pages;
+
+    /** Creates a new instance of a Cache */
+    public Cache() {
+        pages = Collections.synchronizedMap(new HashMap<Integer,SoftReference>());
+    }
+
+    /**
+     * Add a page to the cache.  This method should be used for
+     * pages which have already been completely rendered.  
+     * 
+     * @param pageNumber the page number of this page
+     * @param page the page to add
+     */
+    public void addPage(Integer pageNumber, PDFPage page) {
+        addPageRecord(pageNumber, page, null);
+    }
+
+    /**
+     * Add a page to the cache.  This method should be used for
+     * pages which are still in the process of being rendered.
+     *
+     * @param pageNumber the page number of this page
+     * @param page the page to add
+     * @param parser the parser which is parsing this page
+     */
+    public void addPage(Integer pageNumber, PDFPage page, PDFParser parser) {
+        addPageRecord(pageNumber, page, parser);
+    }
+
+    /**
+     * Add an image to the cache.  This method should be used for images
+     * which have already been completely rendered
+     *
+     * @param page page this image is associated with
+     * @param info the image info associated with this image
+     * @param image the image to add
+     */
+    public void addImage(PDFPage page, ImageInfo info, Bitmap image) {
+        addImageRecord(page, info, image, null);
+    }
+
+    /**
+     * Add an image to the cache.  This method should be used for images
+     * which are still in the process of being rendered.
+     *
+     * @param page the page this image is associated with
+     * @param info the image info associated with this image
+     * @param image the image to add
+     * @param renderer the renderer which is rendering this page
+     */
+    public void addImage(PDFPage page, ImageInfo info, Bitmap image,
+            PDFRenderer renderer) {
+        addImageRecord(page, info, image, renderer);
+    }
+
+    /**
+     * Get a page from the cache
+     * 
+     * @param pageNumber the number of the page to get
+     * @return the page, if it is in the cache, or null if not
+     */
+    public PDFPage getPage(Integer pageNumber) {
+        PageRecord rec = getPageRecord(pageNumber);
+        if (rec != null) {
+            return (PDFPage) rec.value;
+        }
+
+        // not found
+        return null;
+    }
+
+    /**
+     * Get a page's parser from the cache
+     *
+     * @param pageNumber the number of the page to get the parser for
+     * @return the parser, or null if it is not in the cache
+     */
+    public PDFParser getPageParser(Integer pageNumber) {
+        PageRecord rec = getPageRecord(pageNumber);
+        if (rec != null) {
+            return (PDFParser) rec.generator;
+        }
+
+        // not found
+        return null;
+    }
+
+    /**
+     * Get an image from the cache
+     *
+     * @param page the page the image is associated with
+     * @param info the image info that describes the image
+     *
+     * @return the image if it is in the cache, or null if not
+     */
+    public Bitmap getImage(PDFPage page, ImageInfo info) {
+        Record rec = getImageRecord(page, info);
+        if (rec != null) {
+            return (Bitmap) rec.value;
+        }
+
+        // not found 
+        return null;
+    }
+
+    /**
+     * Get an image's renderer from the cache
+     *
+     * @param page the page this image was generated from
+     * @param info the image info describing the image
+     * @return the renderer, or null if it is not in the cache
+     */
+    public PDFRenderer getImageRenderer(PDFPage page, ImageInfo info) {
+        Record rec = getImageRecord(page, info);
+        if (rec != null) {
+            return (PDFRenderer) rec.generator;
+        }
+
+        // not found
+        return null;
+    }
+
+    /**
+     * Remove a page and all its associated images, as well as its parser
+     * and renderers, from the cache
+     *
+     * @param pageNumber the number of the page to remove
+     */
+    public void removePage(Integer pageNumber) {
+        removePageRecord(pageNumber);
+    }
+
+    /**
+     * Remove an image and its associated renderer from the cache
+     *
+     * @param page the page the image is generated from
+     * @param info the image info of the image to remove
+     */
+    public void removeImage(PDFPage page, ImageInfo info) {
+        removeImageRecord(page, info);
+    }
+
+    /**
+     * The internal routine to add a page to the cache, and return the
+     * page record which was generated
+     */
+    PageRecord addPageRecord(Integer pageNumber, PDFPage page,
+            PDFParser parser) {
+        PageRecord rec = new PageRecord();
+        rec.value = page;
+        rec.generator = parser;
+
+        pages.put(pageNumber, new SoftReference<Record>(rec));
+
+        return rec;
+    }
+
+    /**
+     * Get a page's record from the cache
+     *
+     * @return the record, or null if it's not in the cache
+     */
+    PageRecord getPageRecord(Integer pageNumber) {
+        // System.out.println("Request for page " + pageNumber);
+        SoftReference ref = pages.get(pageNumber);
+        if (ref != null) {
+            String val = (ref.get() == null) ? " not in " : " in ";
+            // System.out.println("Page " + pageNumber + val + "cache");
+            return (PageRecord) ref.get();
+        }
+
+        // System.out.println("Page " + pageNumber + " not in cache");
+        // not in cache
+        return null;
+    }
+
+    /**
+     * Remove a page's record from the cache
+     */
+    PageRecord removePageRecord(Integer pageNumber) {
+        SoftReference ref = pages.remove(pageNumber);
+        if (ref != null) {
+            return (PageRecord) ref.get();
+        }
+
+        // not in cache
+        return null;
+    }
+
+    /**
+     * The internal routine to add an image to the cache and return the
+     * record that was generated.
+     */
+    Record addImageRecord(PDFPage page, ImageInfo info,
+            Bitmap image, PDFRenderer renderer) {
+        // first, find or create the relevant page record
+        Integer pageNumber = new Integer(page.getPageNumber());
+        PageRecord pageRec = getPageRecord(pageNumber);
+        if (pageRec == null) {
+            pageRec = addPageRecord(pageNumber, page, null);
+        }
+
+        // next, create the image record
+        Record rec = new Record();
+        rec.value = image;
+        rec.generator = renderer;
+
+        // add it to the cache
+        pageRec.images.put(info, new SoftReference<Record>(rec));
+
+        return rec;
+    }
+
+    /**
+     * Get an image's record from the cache
+     *
+     * @return the record, or null if it's not in the cache
+     */
+    Record getImageRecord(PDFPage page, ImageInfo info) {
+        // first find the relevant page record
+        Integer pageNumber = new Integer(page.getPageNumber());
+
+        // System.out.println("Request for image on page " + pageNumber);
+
+        PageRecord pageRec = getPageRecord(pageNumber);
+        if (pageRec != null) {
+            SoftReference ref = pageRec.images.get(info);
+            if (ref != null) {
+                String val = (ref.get() == null) ? " not in " : " in ";
+                // System.out.println("Image on page " + pageNumber + val + " cache");
+                return (Record) ref.get();
+            }
+        }
+
+        // System.out.println("Image on page " + pageNumber + " not in cache");
+        // not found
+        return null;
+    }
+
+    /**
+     * Remove an image's record from the cache
+     */
+    Record removeImageRecord(PDFPage page, ImageInfo info) {
+        // first find the relevant page record
+        Integer pageNumber = new Integer(page.getPageNumber());
+        PageRecord pageRec = getPageRecord(pageNumber);
+        if (pageRec != null) {
+            SoftReference ref = pageRec.images.remove(info);
+            if (ref != null) {
+                return (Record) ref.get();
+            }
+
+        }
+
+        return null;
+    }
+
+    /** the basic information about a page or image */
+    class Record {
+
+        /** the page or image itself */
+        Object value;
+        /** the thing generating the page, or null if done/not provided */
+        BaseWatchable generator;
+    }
+
+    /** the record stored for each page in the cache */
+    class PageRecord extends Record {
+
+        /** any images associated with the page */
+        Map<ImageInfo, SoftReference<Record>> images;
+
+        /** create a new page record */
+        public PageRecord() {
+            images = Collections.synchronizedMap(new HashMap<ImageInfo, SoftReference<Record>>());
+        }
+    }
+}

src/com/sun/pdfview/HexDump.java

@@ -0,0 +1,86 @@
+/*
+ * $Id: HexDump.java,v 1.3 2009/01/16 16:26:12 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview;
+
+import java.io.IOException;
+import java.io.RandomAccessFile;
+
+public class HexDump {
+
+    public static void printData(byte[] data) {
+        char[] parts = new char[17];
+        int partsloc = 0;
+        for (int i = 0; i < data.length; i++) {
+            int d = ((int) data[i]) & 0xff;
+            if (d == 0) {
+                parts[partsloc++] = '.';
+            } else if (d < 32 || d >= 127) {
+                parts[partsloc++] = '?';
+            } else {
+                parts[partsloc++] = (char) d;
+            }
+            if (i % 16 == 0) {
+                int start = Integer.toHexString(data.length).length();
+                int end = Integer.toHexString(i).length();
+
+                for (int j = start; j > end; j--) {
+                    System.out.print("0");
+                }
+                System.out.print(Integer.toHexString(i) + ": ");
+            }
+            if (d < 16) {
+                System.out.print("0" + Integer.toHexString(d));
+            } else {
+                System.out.print(Integer.toHexString(d));
+            }
+            if ((i & 15) == 15 || i == data.length - 1) {
+                System.out.println("      " + new String(parts));
+                partsloc = 0;
+            } else if ((i & 7) == 7) {
+                System.out.print("  ");
+                parts[partsloc++] = ' ';
+            } else if ((i & 1) == 1) {
+                System.out.print(" ");
+            }
+        }
+        System.out.println();
+    }
+
+    public static void main(String args[]) {
+        if (args.length != 1) {
+            System.out.println("Usage: ");
+            System.out.println("    HexDump <filename>");
+            System.exit(-1);
+        }
+
+        try {
+            RandomAccessFile raf = new RandomAccessFile(args[0], "r");
+
+            int size = (int) raf.length();
+            byte[] data = new byte[size];
+
+            raf.readFully(data);
+            printData(data);
+        } catch (IOException ioe) {
+            ioe.printStackTrace();
+        }
+    }
+}

src/com/sun/pdfview/Identity8BitCharsetEncoder.java

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2008 Pirion Systems Pty Ltd, 139 Warry St,
+ * Fortitude Valley, Queensland, Australia
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package com.sun.pdfview;
+
+import com.sun.pdfview.PDFStringUtil;
+
+import java.nio.charset.CharsetEncoder;
+import java.nio.charset.CoderResult;
+import java.nio.charset.Charset;
+import java.nio.CharBuffer;
+import java.nio.ByteBuffer;
+import java.util.Map;
+import java.util.HashMap;
+
+/**
+ * A {@link CharsetEncoder} that attempts to write out the lower 8 bits
+ * of any character. Characters >= 256 in value are regarded
+ * as unmappable.
+ *
+ * @author Luke Kirby
+ */
+public class Identity8BitCharsetEncoder extends CharsetEncoder {
+
+    public Identity8BitCharsetEncoder() {
+        super(null, 1, 1);
+    }
+
+    protected CoderResult encodeLoop(CharBuffer in, ByteBuffer out) {
+        while (in.remaining() > 0) {
+            if (out.remaining() < 1) {
+                return CoderResult.OVERFLOW;
+            }
+            final char c = in.get();
+            if (c >= 0 && c < 256) {
+                out.put((byte) c);
+            } else {
+                return CoderResult.unmappableForLength(1);
+            }
+        }
+        return CoderResult.UNDERFLOW;
+    }
+
+    @Override
+    public boolean isLegalReplacement(byte[] repl) {
+        // avoid referencing the non-existent character set
+        return true;
+    }
+}

src/com/sun/pdfview/ImageInfo.java

@@ -0,0 +1,78 @@
+/*
+ * $Id: ImageInfo.java,v 1.3 2009/01/16 16:26:11 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview;
+
+import android.graphics.Color;
+import android.graphics.RectF;
+
+
+
+public class ImageInfo {
+
+    int width;
+    int height;
+    RectF clip;
+    int bgColor;
+
+    public ImageInfo(int width, int height, RectF clip) {
+        this(width, height, clip, Color.WHITE);
+    }
+
+    public ImageInfo(int width, int height, RectF clip, int bgColor) {
+        this.width = width;
+        this.height = height;
+        this.clip = clip;
+        this.bgColor = bgColor;
+    }
+
+    // a hashcode that uses width, height and clip to generate its number
+    @Override
+    public int hashCode() {
+        int code = (width ^ height << 16);
+
+        if (clip != null) {
+            code ^= ((int) clip.width() | (int) clip.height()) << 8;
+            code ^= ((int) clip.left | (int) clip.top);
+        }
+
+        return code;
+    }
+
+    // an equals method that compares values
+    @Override
+    public boolean equals(Object o) {
+        if (!(o instanceof ImageInfo)) {
+            return false;
+        }
+
+        ImageInfo ii = (ImageInfo) o;
+
+        if (width != ii.width || height != ii.height) {
+            return false;
+        } else if (clip != null && ii.clip != null) {
+            return clip.equals(ii.clip);
+        } else if (clip == null && ii.clip == null) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}

src/com/sun/pdfview/NameTree.java

@@ -0,0 +1,126 @@
+/*
+ * $Id: NameTree.java,v 1.3 2009/01/16 16:26:09 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview;
+
+import java.io.IOException;
+
+/**
+ * A PDF name tree consists of three kinds of nodes:
+ * <ul>
+ * <li> The root node contains only a kids entry, pointing to many
+ *      other objects
+ * <li> An intermediate node contains the limits of all the children in
+ *      its subtree, and a kids entry for each child
+ * <li> A leaf node contains a set of name-to-object mappings in a dictionary,
+ *      as well as the limits of the data contained in that child.
+ * </ul>
+ * A PDF name tree is sorted in accordance with the String.compareTo() method.
+ */
+public class NameTree {
+
+    /** the root object */
+    private PDFObject root;
+
+    /** Creates a new instance of NameTree */
+    public NameTree(PDFObject root) {
+        this.root = root;
+    }
+
+    /**
+     * Find the PDF object corresponding to the given String in a name tree
+     *
+     * @param key the key we are looking for in the name tree
+     * @return the object associated with str,  if found, or null if not
+     */
+    public PDFObject find(String key) throws IOException {
+        return find(root, key);
+    }
+
+    /**
+     * Recursively walk the name tree looking for a given value
+     */
+    private PDFObject find(PDFObject root, String key)
+            throws IOException {
+        // first, look for a Names entry, meaning this is a leaf
+        PDFObject names = root.getDictRef("Names");
+        if (names != null) {
+            return findInArray(names.getArray(), key);
+        }
+
+        // no names given, look for kids
+        PDFObject kidsObj = root.getDictRef("Kids");
+        if (kidsObj != null) {
+            PDFObject[] kids = kidsObj.getArray();
+
+            for (int i = 0; i < kids.length; i++) {
+                // find the limits of this kid
+                PDFObject limitsObj = kids[i].getDictRef("Limits");
+                if (limitsObj != null) {
+                    String lowerLimit = limitsObj.getAt(0).getStringValue();
+                    String upperLimit = limitsObj.getAt(1).getStringValue();
+
+                    // are we in range?
+                    if ((key.compareTo(lowerLimit) >= 0) &&
+                            (key.compareTo(upperLimit) <= 0)) {
+
+                        // we are, so find in this child
+                        return find(kids[i], key);
+                    }
+                }
+            }
+        }
+
+        // no luck
+        return null;
+    }
+
+    /**
+     * Find an object in a (key,value) array.  Do this by splitting in half
+     * repeatedly.
+     */
+    private PDFObject findInArray(PDFObject[] array, String key)
+            throws IOException {
+        int start = 0;
+        int end = array.length / 2;
+
+        while (end >= start && start >= 0 && end < array.length) {
+            // find the key at the midpoint
+            int pos = start + ((end - start) / 2);
+            String posKey = array[pos * 2].getStringValue();
+
+            // compare the key to the key we are looking for
+            int comp = key.compareTo(posKey);
+            if (comp == 0) {
+                // they match.  Return the value
+                return array[(pos * 2) + 1];
+            } else if (comp > 0) {
+                // too big, search the top half of the tree
+                start = pos + 1;
+            } else if (comp < 0) {
+                // too small, search the bottom half of the tree
+                end = pos - 1;
+            }
+        }
+
+        // not found
+        return null;
+    }
+}

src/com/sun/pdfview/OutlineNode.java

@@ -0,0 +1,62 @@
+/*
+ * $Id: OutlineNode.java,v 1.3 2009/01/16 16:26:10 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview;
+
+import androswing.tree.DefaultMutableTreeNode;
+
+import com.sun.pdfview.action.PDFAction;
+
+public class OutlineNode extends DefaultMutableTreeNode {
+    // the name of this node
+
+    private String title;
+
+    /** 
+     * Create a new outline node
+     *
+     * @param title the node's visible name in the tree
+     */
+    public OutlineNode(String title) {
+        this.title = title;
+    }
+
+    /**
+     * Get the PDF action associated with this node
+     */
+    public PDFAction getAction() {
+        return (PDFAction) getUserObject();
+    }
+
+    /**
+     * Set the PDF action associated with this node
+     */
+    public void setAction(PDFAction action) {
+        setUserObject(action);
+    }
+
+    /**
+     * Return the node's visible name in the tree
+     */
+    @Override
+    public String toString() {
+        return title;
+    }
+}

src/com/sun/pdfview/PDFCmd.java

@@ -0,0 +1,61 @@
+/*
+ * $Id: PDFCmd.java,v 1.3 2009/01/16 16:26:13 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview;
+
+import android.graphics.RectF;
+
+/**
+ * The abstract superclass of all drawing commands for a PDFPage.
+ * @author Mike Wessler
+ */
+public abstract class PDFCmd {
+
+    /**
+     * mark the page or change the graphics state
+     * @param state the current graphics state;  may be modified during
+     * execution.
+     * @return the region of the page made dirty by executing this command
+     *         or null if no region was touched.  Note this value should be
+     *         in the coordinates of the image touched, not the page.
+     */
+    public abstract RectF execute(PDFRenderer state);
+
+    /**
+     * a human readable representation of this command
+     */
+    @Override
+    public String toString() {
+        String name = getClass().getName();
+        int lastDot = name.lastIndexOf('.');
+        if (lastDot >= 0) {
+            return name.substring(lastDot + 1);
+        } else {
+            return name;
+        }
+    }
+
+    /**
+     * the details of this command
+     */
+    public String getDetails() {
+        return super.toString();
+    }
+}

src/com/sun/pdfview/PDFDestination.java

@@ -0,0 +1,284 @@
+/*
+ * $Id: PDFDestination.java,v 1.3 2009/01/16 16:26:09 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview;
+
+import java.io.IOException;
+
+/**
+ * Represents a destination in a PDF file.  Destinations take 3 forms:
+ * <ul>
+ * <li> An explicit destination, which contains a reference to a page
+ *      as well as some stuff about how to fit it into the window.
+ * <li> A named destination, which uses the PDF file's Dests entry
+ *      in the document catalog to map a name to an explicit destination
+ * <li> A string destintation, which uses the PDF file's Dests entry.
+ *      in the name directory to map a string to an explicit destination.
+ * </ul>
+ *
+ * All three of these cases are handled by the getDestination() method.
+ */
+public class PDFDestination {
+
+    /** The known types of destination */
+    public static final int XYZ = 0;
+    public static final int FIT = 1;
+    public static final int FITH = 2;
+    public static final int FITV = 3;
+    public static final int FITR = 4;
+    public static final int FITB = 5;
+    public static final int FITBH = 6;
+    public static final int FITBV = 7;
+    /** the type of this destination (from the list above) */
+    private int type;
+    /** the page we refer to */
+    private PDFObject pageObj;
+    /** the left coordinate of the fit area, if applicable */
+    private float left;
+    /** the right coordinate of the fit area, if applicable */
+    private float right;
+    /** the top coordinate of the fit area, if applicable */
+    private float top;
+    /** the bottom coordinate of the fit area, if applicable */
+    private float bottom;
+    /** the zoom, if applicable */
+    private float zoom;
+
+    /** 
+     * Creates a new instance of PDFDestination
+     *
+     * @param pageObj the page object this destination refers to
+     * @param type the type of page this object refers to
+     */
+    protected PDFDestination(PDFObject pageObj, int type) {
+        this.pageObj = pageObj;
+        this.type = type;
+    }
+
+    /**
+     * Get a destination from either an array (explicit destination), a 
+     * name (named destination) or a string (name tree destination).
+     *
+     * @param obj the PDFObject representing this destination
+     * @param root the root of the PDF object tree
+     */
+    public static PDFDestination getDestination(PDFObject obj, PDFObject root)
+            throws IOException {
+        // resolve string and name issues
+        if (obj.getType() == PDFObject.NAME) {
+            obj = getDestFromName(obj, root);
+        } else if (obj.getType() == PDFObject.STRING) {
+            obj = getDestFromString(obj, root);
+        }
+
+        // make sure we have the right kind of object
+        if (obj == null || obj.getType() != PDFObject.ARRAY) {
+            throw new PDFParseException("Can't create destination from: " + obj);
+        }
+
+        // the array is in the form [page type args ... ]
+        PDFObject[] destArray = obj.getArray();
+
+        // create the destination based on the type
+        PDFDestination dest = null;
+        String type = destArray[1].getStringValue();
+        if (type.equals("XYZ")) {
+            dest = new PDFDestination(destArray[0], XYZ);
+        } else if (type.equals("Fit")) {
+            dest = new PDFDestination(destArray[0], FIT);
+        } else if (type.equals("FitH")) {
+            dest = new PDFDestination(destArray[0], FITH);
+        } else if (type.equals("FitV")) {
+            dest = new PDFDestination(destArray[0], FITV);
+        } else if (type.equals("FitR")) {
+            dest = new PDFDestination(destArray[0], FITR);
+        } else if (type.equals("FitB")) {
+            dest = new PDFDestination(destArray[0], FITB);
+        } else if (type.equals("FitBH")) {
+            dest = new PDFDestination(destArray[0], FITBH);
+        } else if (type.equals("FitBV")) {
+            dest = new PDFDestination(destArray[0], FITBV);
+        } else {
+            throw new PDFParseException("Unknown destination type: " + type);
+        }
+
+        // now fill in the arguments based on the type
+        switch (dest.getType()) {
+            case XYZ:
+                dest.setLeft(destArray[2].getFloatValue());
+                dest.setTop(destArray[3].getFloatValue());
+                dest.setZoom(destArray[4].getFloatValue());
+                break;
+            case FITH:
+                dest.setTop(destArray[2].getFloatValue());
+                break;
+            case FITV:
+                dest.setLeft(destArray[2].getFloatValue());
+                break;
+            case FITR:
+                dest.setLeft(destArray[2].getFloatValue());
+                dest.setBottom(destArray[3].getFloatValue());
+                dest.setRight(destArray[4].getFloatValue());
+                dest.setTop(destArray[5].getFloatValue());
+                break;
+            case FITBH:
+                dest.setTop(destArray[2].getFloatValue());
+                break;
+            case FITBV:
+                dest.setLeft(destArray[2].getFloatValue());
+                break;
+        }
+
+        return dest;
+    }
+
+    /**
+     * Get the type of this destination
+     */
+    public int getType() {
+        return type;
+    }
+
+    /**
+     * Get the PDF Page object associated with this destination
+     */
+    public PDFObject getPage() {
+        return pageObj;
+    }
+
+    /**
+     * Get the left coordinate value
+     */
+    public float getLeft() {
+        return left;
+    }
+
+    /** 
+     * Set the left coordinate value
+     */
+    public void setLeft(float left) {
+        this.left = left;
+    }
+
+    /**
+     * Get the right coordinate value
+     */
+    public float getRight() {
+        return right;
+    }
+
+    /** 
+     * Set the right coordinate value
+     */
+    public void setRight(float right) {
+        this.right = right;
+    }
+
+    /**
+     * Get the top coordinate value
+     */
+    public float getTop() {
+        return top;
+    }
+
+    /** 
+     * Set the top coordinate value
+     */
+    public void setTop(float top) {
+        this.top = top;
+    }
+
+    /**
+     * Get the bottom coordinate value
+     */
+    public float getBottom() {
+        return bottom;
+    }
+
+    /** 
+     * Set the bottom coordinate value
+     */
+    public void setBottom(float bottom) {
+        this.bottom = bottom;
+    }
+
+    /**
+     * Get the zoom value
+     */
+    public float getZoom() {
+        return zoom;
+    }
+
+    /** 
+     * Set the zoom value
+     */
+    public void setZoom(float zoom) {
+        this.zoom = zoom;
+    }
+
+    /**
+     * Get a destination, given a name.  This means the destination is in
+     * the root node's dests dictionary.
+     */
+    private static PDFObject getDestFromName(PDFObject name, PDFObject root)
+            throws IOException {
+        // find the dests object in the root node
+        PDFObject dests = root.getDictRef("Dests");
+        if (dests != null) {
+            // find this name in the dests dictionary
+            return dests.getDictRef(name.getStringValue());
+        }
+
+        // not found
+        return null;
+    }
+
+    /**
+     * Get a destination, given a string.  This means the destination is in
+     * the root node's names dictionary.
+     */
+    private static PDFObject getDestFromString(PDFObject str, PDFObject root)
+            throws IOException {
+        // find the names object in the root node
+        PDFObject names = root.getDictRef("Names");
+        if (names != null) {
+            // find the dests entry in the names dictionary
+            PDFObject dests = names.getDictRef("Dests");
+            if (dests != null) {
+                // create a name tree object
+                NameTree tree = new NameTree(dests);
+
+                // find the value we're looking for
+                PDFObject obj = tree.find(str.getStringValue());
+
+                // if we get back a dictionary, look for the /D value
+                if (obj != null && obj.getType() == PDFObject.DICTIONARY) {
+                    obj = obj.getDictRef("D");
+                }
+
+                // found it
+                return obj;
+            }
+        }
+
+        // not found
+        return null;
+    }
+}

src/com/sun/pdfview/PDFDocCharsetEncoder.java

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2008 Pirion Systems Pty Ltd, 139 Warry St,
+ * Fortitude Valley, Queensland, Australia
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package com.sun.pdfview;
+
+import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+import java.nio.charset.CharsetEncoder;
+import java.nio.charset.CoderResult;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Encodes into a PDFDocEncoding representation. Note that only 256 characters
+ * (if that) are represented in the PDFDocEncoding, so users should be
+ * prepared to deal with unmappable character exceptions.
+ *
+ * @see "PDF Reference version 1.7, Appendix D"
+ *
+ * @author Luke Kirby
+ */
+public class PDFDocCharsetEncoder extends CharsetEncoder {
+
+    /**
+     * Identify whether a particular character preserves the same byte value
+     * upon encoding in PDFDocEncoding
+     * @param ch the character
+     * @return whether the character is identity encoded
+     */
+    public static boolean isIdentityEncoding(char ch) {
+        return ch >= 0 && ch <= 255 && IDENT_PDF_DOC_ENCODING_MAP[ch];
+
+    }
+
+    /**
+     * For each character that exists in PDFDocEncoding, identifies whether
+     * the byte value in UTF-16BE is the same as it is in PDFDocEncoding
+     */
+    final static boolean[] IDENT_PDF_DOC_ENCODING_MAP = new boolean[256];
+
+    /**
+     * For non-identity encoded characters, maps from the character to
+     * the byte value in PDFDocEncoding. If an entry for a non-identity
+     * coded character is absent from this map, that character is unmappable
+     * in the PDFDocEncoding.
+     */
+    final static Map<Character,Byte> EXTENDED_TO_PDF_DOC_ENCODING_MAP =
+            new HashMap<Character,Byte>();
+    static
+    {
+        for (byte i = 0; i < PDFStringUtil.PDF_DOC_ENCODING_MAP.length; ++i) {
+            final char c = PDFStringUtil.PDF_DOC_ENCODING_MAP[i];
+            final boolean identical = (c == i);
+            IDENT_PDF_DOC_ENCODING_MAP[i] = identical;
+            if (!identical) {
+                EXTENDED_TO_PDF_DOC_ENCODING_MAP.put(c, i);
+            }
+        }
+    }
+
+    public PDFDocCharsetEncoder() {
+        super(null, 1, 1);
+    }
+
+    protected CoderResult encodeLoop(CharBuffer in, ByteBuffer out) {
+        while (in.remaining() > 0) {
+            if (out.remaining() < 1) {
+                return CoderResult.OVERFLOW;
+            }
+            final char c = in.get();
+            if (c >= 0 && c < 256 && IDENT_PDF_DOC_ENCODING_MAP[c]) {
+                out.put((byte) c);
+            } else {
+                final Byte mapped = EXTENDED_TO_PDF_DOC_ENCODING_MAP.get(c);
+                if (mapped != null) {
+                    out.put(mapped);
+                } else {
+                    return CoderResult.unmappableForLength(1);
+                }
+            }
+        }
+        return CoderResult.UNDERFLOW;
+    }
+
+    @Override
+    public boolean isLegalReplacement(byte[] repl) {
+        // avoid referencing the non-existent character set
+        return true;
+    }    
+}

src/com/sun/pdfview/PDFFile.java

@@ -0,0 +1,1557 @@
+/*
+ * $Id: PDFFile.java,v 1.15 2009/03/12 12:25:25 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.StringTokenizer;
+
+import net.sf.andpdf.pdfviewer.ByteBuffer;
+
+import android.graphics.RectF;
+
+import com.sun.pdfview.action.GoToAction;
+import com.sun.pdfview.action.PDFAction;
+import com.sun.pdfview.decrypt.EncryptionUnsupportedByPlatformException;
+import com.sun.pdfview.decrypt.EncryptionUnsupportedByProductException;
+import com.sun.pdfview.decrypt.IdentityDecrypter;
+import com.sun.pdfview.decrypt.PDFAuthenticationFailureException;
+import com.sun.pdfview.decrypt.PDFDecrypter;
+import com.sun.pdfview.decrypt.PDFDecrypterFactory;
+import com.sun.pdfview.decrypt.PDFPassword;
+import com.sun.pdfview.decrypt.UnsupportedEncryptionException;
+
+/**
+ * An encapsulation of a .pdf file.  The methods of this class
+ * can parse the contents of a PDF file, but those methods are
+ * hidden.  Instead, the public methods of this class allow
+ * access to the pages in the PDF file.  Typically, you create
+ * a new PDFFile, ask it for the number of pages, and then
+ * request one or more PDFPages.
+ * @author Mike Wessler
+ */
+public class PDFFile {
+
+    public final static int             NUL_CHAR = 0;
+    public final static int             FF_CHAR = 12;
+
+    private String versionString = "1.1";
+    private int majorVersion = 1;
+    private int minorVersion = 1;
+    /** the end of line character */
+    /** the comment text to begin the file to determine it's version */
+    private final static String VERSION_COMMENT = "%PDF-";
+    /**
+     * A ByteBuffer containing the file data
+     */
+    ByteBuffer buf;
+    /**
+     * the cross reference table mapping object numbers to locations
+     * in the PDF file
+     */
+    PDFXref[] objIdx;
+    /** the root PDFObject, as specified in the PDF file */
+    PDFObject root = null;
+    /** the Encrypt PDFObject, from the trailer */
+    PDFObject encrypt = null;
+
+    /** The Info PDFPbject, from the trailer, for simple metadata */
+    PDFObject info = null;
+
+    /** a mapping of page numbers to parsed PDF commands */
+    Cache cache;
+    /**
+     * whether the file is printable or not (trailer -> Encrypt -> P & 0x4)
+     */
+    private boolean printable = true;
+    /**
+     * whether the file is saveable or not (trailer -> Encrypt -> P & 0x10)
+     */
+    private boolean saveable = true;
+
+    /**
+     * The default decrypter for streams and strings. By default, no
+     * encryption is expected, and thus the IdentityDecrypter is used.
+     */
+    private PDFDecrypter defaultDecrypter = IdentityDecrypter.getInstance();
+
+    /**
+     * get a PDFFile from a .pdf file.  The file must me a random access file
+     * at the moment.  It should really be a file mapping from the nio package.
+     * <p>
+     * Use the getPage(...) methods to get a page from the PDF file.
+     * @param buf the RandomAccessFile containing the PDF.
+     * @throws IOException if there's a problem reading from the buffer
+     * @throws PDFParseException if the document appears to be malformed, or
+     *  its features are unsupported. If the file is encrypted in a manner that
+     *  the product or platform does not support then the exception's {@link
+     *  PDFParseException#getCause() cause} will be an instance of {@link
+     *  UnsupportedEncryptionException}.
+     * @throws PDFAuthenticationFailureException if the file is password
+     *  protected and requires a password
+     */
+    public PDFFile(ByteBuffer buf) throws IOException {
+	this(buf, null);
+    }
+
+    /**
+     * get a PDFFile from a .pdf file.  The file must me a random access file
+     * at the moment.  It should really be a file mapping from the nio package.
+     * <p>
+     * Use the getPage(...) methods to get a page from the PDF file.
+     * @param buf the RandomAccessFile containing the PDF.
+     * @param password the user or owner password
+     * @throws IOException if there's a problem reading from the buffer
+     * @throws PDFParseException if the document appears to be malformed, or
+     *  its features are unsupported. If the file is encrypted in a manner that
+     *  the product or platform does not support then the exception's {@link
+     *  PDFParseException#getCause() cause} will be an instance of {@link
+     *  UnsupportedEncryptionException}.
+     * @throws PDFAuthenticationFailureException if the file is password
+     *  protected and the supplied password does not decrypt the document
+     */
+    public PDFFile(ByteBuffer buf, PDFPassword password) throws IOException {
+        this.buf = buf;
+
+        cache = new Cache();
+
+        parseFile(password);
+    }
+
+    /**
+     * Gets whether the owner of the file has given permission to print
+     * the file.
+     * @return true if it is okay to print the file
+     */
+    public boolean isPrintable() {
+        return printable;
+    }
+
+    /**
+     * Gets whether the owner of the file has given permission to save
+     * a copy of the file.
+     * @return true if it is okay to save the file
+     */
+    public boolean isSaveable() {
+        return saveable;
+    }
+
+    /**
+     * get the root PDFObject of this PDFFile.  You generally shouldn't need
+     * this, but we've left it open in case you want to go spelunking.
+     */
+    public PDFObject getRoot() {
+        return root;
+    }
+
+    /**
+     * return the number of pages in this PDFFile.  The pages will be
+     * numbered from 1 to getNumPages(), inclusive.
+     */
+    public int getNumPages() {
+        try {
+            return root.getDictRef("Pages").getDictRef("Count").getIntValue();
+        } catch (Exception ioe) {
+            return 0;
+        }
+    }
+
+    /**
+     * Get metadata (e.g., Author, Title, Creator) from the Info dictionary
+     * as a string.
+     * @param name the name of the metadata key (e.g., Author)
+     * @return the info
+     * @throws IOException if the metadata cannot be read
+     */
+    public String getStringMetadata(String name)
+            throws IOException {
+        if (info != null) {
+            final PDFObject meta = info.getDictRef(name);
+            return meta != null ? meta.getTextStringValue() : null;
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Get the keys into the Info metadata, for use with
+     * {@link #getStringMetadata(String)}
+     * @return the keys present into the Info dictionary
+     * @throws IOException if the keys cannot be read
+     */
+    public Iterator<String> getMetadataKeys()
+            throws IOException {
+        if (info != null) {
+            return info.getDictKeys();
+        } else {
+            return Collections.<String>emptyList().iterator();
+        }
+    }
+
+
+    /**
+     * Used internally to track down PDFObject references.  You should never
+     * need to call this.
+     * <p>
+     * Since this is the only public method for tracking down PDF objects,
+     * it is synchronized.  This means that the PDFFile can only hunt down
+     * one object at a time, preventing the file's location from getting
+     * messed around.
+     * <p>
+     * This call stores the current buffer position before any changes are made
+     * and restores it afterwards, so callers need not know that the position
+     * has changed.
+     *
+     */
+    public synchronized PDFObject dereference(PDFXref ref, PDFDecrypter decrypter)
+            throws IOException {
+        int id = ref.getID();
+
+        // make sure the id is valid and has been read
+        if (id >= objIdx.length || objIdx[id] == null) {
+            return PDFObject.nullObj;
+        }
+
+        // check to see if this is already dereferenced
+        PDFObject obj = objIdx[id].getObject();
+        if (obj != null) {
+            return obj;
+        }
+
+        int loc = objIdx[id].getFilePos();
+        if (loc < 0) {
+            return PDFObject.nullObj;
+        }
+
+        // store the current position in the buffer
+        int startPos = buf.position();
+
+        // move to where this object is
+        buf.position(loc);
+
+        // read the object and cache the reference
+	obj= readObject(ref.getID(), ref.getGeneration(), decrypter);
+        if (obj == null) {
+            obj = PDFObject.nullObj;
+        }
+
+        objIdx[id].setObject(obj);
+
+        // reset to the previous position
+        buf.position(startPos);
+
+        return obj;
+    }
+
+    /**
+     * Is the argument a white space character according to the PDF spec?.
+     * ISO Spec 32000-1:2008 - Table 1
+     */
+    public static boolean isWhiteSpace(int c) {
+        switch (c) {
+            case NUL_CHAR:  // Null (NULL)
+            case '\t':      // Horizontal Tab (HT)
+            case '\n':      // Line Feed (LF)
+            case FF_CHAR:   // Form Feed (FF)
+            case '\r':      // Carriage Return (CR)
+            case ' ':       // Space (SP)
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    /**
+     * Is the argument a delimiter according to the PDF spec?<p>
+     *
+     * ISO 32000-1:2008 - Table 2
+     *
+     * @param c the character to test
+     */
+    public static boolean isDelimiter(int c) {
+        switch (c) {
+            case '(':   // LEFT PARENTHESIS
+            case ')':   // RIGHT PARENTHESIS
+            case '<':   // LESS-THAN-SIGN
+            case '>':   // GREATER-THAN-SIGN
+            case '[':   // LEFT SQUARE BRACKET
+            case ']':   // RIGHT SQUARE BRACKET
+            case '{':   // LEFT CURLY BRACKET
+            case '}':   // RIGHT CURLY BRACKET
+            case '/':   // SOLIDUS
+            case '%':   // PERCENT SIGN
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    /**
+     * return true if the character is neither a whitespace or a delimiter.
+     *
+     * @param c the character to test
+     * @return boolean
+     */
+    public static boolean isRegularCharacter (int c) {
+        return !(isWhiteSpace(c) || isDelimiter(c));
+    }
+
+    /**
+     * read the next object from the file
+     * @param objNum the object number of the object containing the object
+     *  being read; negative only if the object number is unavailable (e.g., if
+     *  reading from the trailer, or reading at the top level, in which
+     *  case we can expect to be reading an object description)
+     * @param objGen the object generation of the object containing the object
+     *  being read; negative only if the objNum is unavailable
+     * @param decrypter the decrypter to use
+     */
+    private PDFObject readObject(
+            int objNum, int objGen, PDFDecrypter decrypter) throws IOException {
+	return readObject(objNum, objGen, false, decrypter);
+    }
+
+    /**
+     * read the next object with a special catch for numbers
+     * @param numscan if true, don't bother trying to see if a number is
+     *  an object reference (used when already in the middle of testing for
+     *  an object reference, and not otherwise)
+     * @param objNum the object number of the object containing the object
+     *  being read; negative only if the object number is unavailable (e.g., if
+     *  reading from the trailer, or reading at the top level, in which
+     *  case we can expect to be reading an object description)
+     * @param objGen the object generation of the object containing the object
+     *  being read; negative only if the objNum is unavailable
+     * @param decrypter the decrypter to use
+     */
+    private PDFObject readObject(
+            int objNum, int objGen,
+            boolean numscan, PDFDecrypter decrypter) throws IOException {
+        // skip whitespace
+        int c;
+        PDFObject obj = null;
+        while (obj == null) {
+            while (isWhiteSpace(c = buf.get())) {
+            }
+            // check character for special punctuation:
+            if (c == '<') {
+                // could be start of <hex data>, or start of <<dictionary>>
+                c = buf.get();
+                if (c == '<') {
+                    // it's a dictionary
+		    obj= readDictionary(objNum, objGen, decrypter);
+                } else {
+                    buf.position(buf.position() - 1);
+		    obj= readHexString(objNum, objGen, decrypter);
+                }
+            } else if (c == '(') {
+		obj= readLiteralString(objNum, objGen, decrypter);
+            } else if (c == '[') {
+                // it's an array
+		obj= readArray(objNum, objGen, decrypter);
+            } else if (c == '/') {
+                // it's a name
+                obj = readName();
+            } else if (c == '%') {
+                // it's a comment
+                readLine();
+            } else if ((c >= '0' && c <= '9') || c == '-' || c == '+' || c == '.') {
+                // it's a number
+                obj = readNumber((char) c);
+                if (!numscan) {
+                    // It could be the start of a reference.
+                    // Check to see if there's another number, then "R".
+                    //
+                    // We can't use mark/reset, since this could be called
+                    // from dereference, which already is using a mark
+                    int startPos = buf.position();
+
+		    PDFObject testnum= readObject(-1, -1, true, decrypter);
+                    if (testnum != null &&
+                            testnum.getType() == PDFObject.NUMBER) {
+			PDFObject testR= readObject(-1, -1, true, decrypter);
+                        if (testR != null &&
+                                testR.getType() == PDFObject.KEYWORD &&
+                                testR.getStringValue().equals("R")) {
+                            // yup.  it's a reference.
+                            PDFXref xref = new PDFXref(obj.getIntValue(),
+                                    testnum.getIntValue());
+                            // Create a placeholder that will be dereferenced
+                            // as needed
+                            obj = new PDFObject(this, xref);
+                        } else if (testR != null &&
+                                testR.getType() == PDFObject.KEYWORD &&
+                                testR.getStringValue().equals("obj")) {
+                            // it's an object description
+			    obj= readObjectDescription(
+                                    obj.getIntValue(),
+                                    testnum.getIntValue(),
+                                    decrypter);
+                        } else {
+                            buf.position(startPos);
+                        }
+                    } else {
+                        buf.position(startPos);
+                    }
+                }
+            } else if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) {
+                // it's a keyword
+                obj = readKeyword((char) c);
+            } else {
+                // it's probably a closing character.
+                // throwback
+                buf.position(buf.position() - 1);
+                break;
+            }
+        }
+        return obj;
+    }
+
+    /**
+     * requires the next few characters (after whitespace) to match the
+     * argument.
+     * @param match the next few characters after any whitespace that
+     * must be in the file
+     * @return true if the next characters match; false otherwise.
+     */
+    private boolean nextItemIs(String match) throws IOException {
+        // skip whitespace
+        int c;
+        while (isWhiteSpace(c = buf.get())) {
+        }
+        for (int i = 0; i < match.length(); i++) {
+            if (i > 0) {
+                c = buf.get();
+            }
+            if (c != match.charAt(i)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * process a version string, to determine the major and minor versions
+     * of the file.
+     * 
+     * @param versionString
+     */
+    private void processVersion(String versionString) {
+        try {
+            StringTokenizer tokens = new StringTokenizer(versionString, ".");
+            majorVersion = Integer.parseInt(tokens.nextToken());
+            minorVersion = Integer.parseInt(tokens.nextToken());
+            this.versionString = versionString;
+        } catch (Exception e) {
+            // ignore
+        }
+    }
+
+    /**
+     * return the major version of the PDF header.
+     * 
+     * @return int
+     */
+    public int getMajorVersion() {
+        return majorVersion;
+    }
+
+    /**
+     * return the minor version of the PDF header.
+     * 
+     * @return int
+     */
+    public int getMinorVersion() {
+        return minorVersion;
+    }
+
+    /**
+     * return the version string from the PDF header.
+     * 
+     * @return String
+     */
+    public String getVersionString() {
+        return versionString;
+    }
+
+    /**
+     * read an entire &lt;&lt; dictionary &gt;&gt;.  The initial
+     * &lt;&lt; has already been read.
+     * @param objNum the object number of the object containing the dictionary
+     *  being read; negative only if the object number is unavailable, which
+     *  should only happen if we're reading a dictionary placed directly
+     *  in the trailer
+     * @param objGen the object generation of the object containing the object
+     *  being read; negative only if the objNum is unavailable
+     * @param decrypter the decrypter to use
+     * @return the Dictionary as a PDFObject.
+     */
+    private PDFObject readDictionary(
+            int objNum, int objGen, PDFDecrypter decrypter) throws IOException {
+        HashMap<String,PDFObject> hm = new HashMap<String,PDFObject>();
+        // we've already read the <<.  Now get /Name obj pairs until >>
+        PDFObject name;
+	while ((name= readObject(objNum, objGen, decrypter))!=null) {
+            // make sure first item is a NAME
+            if (name.getType() != PDFObject.NAME) {
+                throw new PDFParseException("First item in dictionary must be a /Name.  (Was " + name + ")");
+            }
+	    PDFObject value= readObject(objNum, objGen, decrypter);
+            if (value != null) {
+                hm.put(name.getStringValue(), value);
+            }
+        }
+        //	System.out.println("End of dictionary at location "+raf.getFilePointer());
+        if (!nextItemIs(">>")) {
+            throw new PDFParseException("End of dictionary wasn't '>>'");
+        }
+        //	System.out.println("Dictionary closed at location "+raf.getFilePointer());
+        return new PDFObject(this, PDFObject.DICTIONARY, hm);
+    }
+
+    /**
+     * read a character, and return its value as if it were a hexidecimal
+     * digit.
+     * @return a number between 0 and 15 whose value matches the next
+     * hexidecimal character.  Returns -1 if the next character isn't in
+     * [0-9a-fA-F]
+     */
+    private int readHexDigit() throws IOException {
+        int a;
+        while (isWhiteSpace(a = buf.get())) {
+        }
+        switch (a) {
+            case '0': case '1': case '2': case '3': case '4':
+            case '5': case '6': case '7': case '8': case '9':
+                a -= '0';
+                break;
+            case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
+                a -= 'a' - 10;
+                break;
+            case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
+                a -= 'A' - 10;
+                break;
+            default:
+                a = -1;
+                break;
+        }
+        return a;
+    }
+
+    /**
+     * return the 8-bit value represented by the next two hex characters.
+     * If the next two characters don't represent a hex value, return -1
+     * and reset the read head.  If there is only one hex character,
+     * return its value as if there were an implicit 0 after it.
+     */
+    private int readHexPair() throws IOException {
+        int first = readHexDigit();
+        if (first < 0) {
+            buf.position(buf.position() - 1);
+            return -1;
+        }
+        int second = readHexDigit();
+        if (second < 0) {
+            buf.position(buf.position() - 1);
+            return (first << 4);
+        } else {
+            return (first << 4) + second;
+        }
+    }
+
+    /**
+     * read a < hex string >.  The initial < has already been read.
+     * @param objNum the object number of the object containing the dictionary
+     *  being read; negative only if the object number is unavailable, which
+     *  should only happen if we're reading a string placed directly
+     *  in the trailer
+     * @param objGen the object generation of the object containing the object
+     *  being read; negative only if the objNum is unavailable
+     * @param decrypter the decrypter to use
+     */
+    private PDFObject readHexString(
+            int objNum, int objGen, PDFDecrypter decrypter) throws IOException {
+        // we've already read the <. Now get the hex bytes until >
+        int val;
+        StringBuffer sb = new StringBuffer();
+        while ((val = readHexPair()) >= 0) {
+            sb.append((char) val);
+        }
+        if (buf.get() != '>') {
+            throw new PDFParseException("Bad character in Hex String");
+        }
+        String unicodeString = unicode(sb.toString());
+        return new PDFObject(this, PDFObject.STRING,
+                             decrypter.decryptString(objNum, objGen, unicodeString));
+    }
+
+    /**
+     * take a string and determine if it is unicode by looking at the lead
+     * characters, and that the string must be a multiple of 2 chars long.
+     * Convert a unicoded string's characters into the true unicode.
+     *
+     * @param input
+     * @return
+     */
+    private String unicode(String input) {
+        // determine if we have unicode, if so, translate it
+        if (input.length() < 2 || (input.length() % 2) != 0) {
+            return input;
+        }
+        int c0 = input.charAt(0) & 0xFF;
+        int c1 = input.charAt(1) & 0xFF;
+        if ((c0 == 0xFE && c1 == 0xFF) ||
+                (c0 == 0xFF && c1 == 0xFE)) {
+            // we have unicode
+            boolean bigEndian = (input.charAt(1) == 0xFFFF);
+            StringBuffer out = new StringBuffer();
+            for (int i = 2; i < input.length(); i += 2) {
+                if (bigEndian) {
+                    out.append((char) (((input.charAt(i + 1) & 0xFF) << 8) +
+                            (input.charAt(i) & 0xFF)));
+                } else {
+                    out.append((char) (((input.charAt(i) & 0xFF) << 8) +
+                            (input.charAt(i + 1) & 0xFF)));
+                }
+            }
+            return out.toString();
+        } else {
+            return input;
+        }
+    }
+
+    /**
+     * <p>read a ( character string ).  The initial ( has already been read.
+     * Read until a *balanced* ) appears.</p>
+     *
+     * <p>PDF Reference Section 3.8.1, Table 3.31 "PDF Data Types" defines
+     * String data as:<pre>
+     * "text string     Bytes that represent characters encoded
+     *                  using either PDFDocEncoding or UTF-16BE with a
+     *                  leading byte-order marker (as defined in
+     *                  "Text String Type" on page 158.)
+     * </pre></p>
+     *
+     * <p>Section 5.3.2 defines character sequences and escapes.<br>
+     * "The strings must conform to the syntax for string objects.
+     * When a string is written by enclosing the data in parentheses,
+     * bytes whose values are the same as those of the ASCII characters
+     * left parenthesis (40), right parenthesis (41), and backslash (92)
+     * must be preceded by a backslash character. All other byte values
+     * between 0 and 255 may be used in a string object. <br>
+     * These rules apply to each individual byte in a string object,
+     * whether the string is interpreted by the text-showing operators
+     * as single-byte or multiple-byte character codes."</p>
+     *
+     * <p>This only reads 8 bit basic 'strings' so as to avoid a text string
+     * interpretation when one is not desired (e.g., for byte strings).
+     * For a text string interpretation of a string, use
+     * {@link PDFStringUtil#asTextString} ()} or
+     * {@link PDFObject#getTextStringValue()} </p>
+
+     * @param objNum the object number of the object containing the dictionary
+     *  being read; negative only if the object number is unavailable, which
+     *  should only happen if we're reading a dictionary placed directly
+     *  in the trailer
+     * @param objGen the object generation of the object containing the object
+     *  being read; negative only if the objNum is unavailable
+     * @param decrypter the decrypter to use
+     */
+    private PDFObject readLiteralString(
+            int objNum, int objGen, PDFDecrypter decrypter) throws IOException {
+        int c;
+
+        // we've already read the (.  now get the characters until a
+        // *balanced* ) appears.  Translate \r \n \t \b \f \( \) \\ \ddd
+        // if a cr/lf follows a backslash, ignore the cr/lf
+        int parencount = 1;
+        StringBuffer sb = new StringBuffer();
+
+        while (parencount > 0) {
+            c = buf.get() & 0xFF;
+            // process unescaped parenthesis
+            if (c == '(') {
+                parencount++;
+            } else if (c == ')') {
+                parencount--;
+                if (parencount == 0) {
+                    c = -1;
+                    break;
+                }
+            } else if (c == '\\') {
+                // time to do some work
+                c = buf.get() & 0xFF;
+                if (c >= '0' && c <= '9') {
+                    // \ddd form - three OCTAL digits
+                    int count = 0;
+                    int val = 0;
+                    while (c >= '0' && c <= '8' && count < 3) {
+                        val = val * 8 + c - '0';
+                        c = buf.get() & 0xFF;
+                        count++;
+                    }
+                    buf.position(buf.position() - 1);
+                    c = val;
+                } else if (c == 'r') {
+                    c = '\n';   // translate to 0Ah
+                } else if (c == 'n') {
+                    c = '\n';
+                } else if (c == 't') {
+                    c = '\t';
+                } else if (c == 'b') {
+                    c = '\b';
+                } else if (c == 'f') {
+                    c = '\f';
+                } else
+                //  ignore escaped EOL
+                if (c == '\r') {
+                    // check for following \n
+                    c = buf.get() & 0xFF;
+                    if (c != '\n') {
+                        buf.position(buf.position() - 1);
+                    }
+                    c = -1;
+                } else if (c == '\n') {
+                    c = -1;
+                }
+            }
+            if (c >= 0) {
+                sb.append((char) c);
+            }
+        }
+        String unicodeString = unicode(sb.toString());
+        return new PDFObject(this, PDFObject.STRING,
+                decrypter.decryptString(objNum, objGen, unicodeString));
+    }
+
+    /**
+     * Read a line of text.  This follows the semantics of readLine() in
+     * DataInput -- it reads character by character until a '/n' is
+     * encountered.  If a '/r' is encountered, it is discarded.
+     */
+    private String readLine() {
+        StringBuffer sb = new StringBuffer();
+
+        while (buf.remaining() > 0) {
+            char c = (char) buf.get();
+
+            if (c == '\r') {
+                if (buf.remaining() > 0) {
+                    char n = (char) buf.get(buf.position());
+                    if (n == '\n') {
+                        buf.get();
+                    }
+                }
+                break;
+            } else if (c == '\n') {
+                break;
+            }
+
+            sb.append(c);
+        }
+
+        return sb.toString();
+    }
+
+    /**
+     * read an [ array ].  The initial [ has already been read.  PDFObjects
+     * are read until ].
+     * @param objNum the object number of the object containing the dictionary
+     *  being read; negative only if the object number is unavailable, which
+     *  should only happen if we're reading an array placed directly
+     *  in the trailer
+     * @param objGen the object generation of the object containing the object
+     *  being read; negative only if the objNum is unavailable
+     * @param decrypter the decrypter to use
+     */
+    private PDFObject readArray(
+            int objNum, int objGen, PDFDecrypter decrypter) throws IOException {
+        // we've already read the [.  Now read objects until ]
+        ArrayList<PDFObject> ary = new ArrayList<PDFObject>();
+        PDFObject obj;
+	while((obj= readObject(objNum, objGen, decrypter))!=null) {
+            ary.add(obj);
+        }
+        if (buf.get() != ']') {
+            throw new PDFParseException("Array should end with ']'");
+        }
+        PDFObject[] objlist = new PDFObject[ary.size()];
+        for (int i = 0; i < objlist.length; i++) {
+            objlist[i] = (PDFObject) ary.get(i);
+        }
+        return new PDFObject(this, PDFObject.ARRAY, objlist);
+    }
+
+    /**
+     * read a /name.  The / has already been read.
+     */
+    private PDFObject readName() throws IOException {
+        // we've already read the / that begins the name.
+        // all we have to check for is #hh hex notations.
+        StringBuffer sb = new StringBuffer();
+        int c;
+        while (isRegularCharacter(c = buf.get())) {
+            if (c < '!' && c > '~') {
+                break;      // out-of-range, should have been hex
+            }
+            // H.3.2.4 indicates version 1.1 did not do hex escapes
+            if (c == '#' && (majorVersion != 1 && minorVersion != 1)) {
+                int hex = readHexPair();
+                if (hex >= 0) {
+                    c = hex;
+                } else {
+                    throw new PDFParseException("Bad #hex in /Name");
+                }
+            }
+            sb.append((char) c);
+        }
+        buf.position(buf.position() - 1);
+        return new PDFObject(this, PDFObject.NAME, sb.toString());
+    }
+
+    /**
+     * read a number.  The initial digit or . or - is passed in as the
+     * argument.
+     */
+    private PDFObject readNumber(char start) throws IOException {
+        // we've read the first digit (it's passed in as the argument)
+        boolean neg = start == '-';
+        boolean sawdot = start == '.';
+        double dotmult = sawdot ? 0.1 : 1;
+        double value = (start >= '0' && start <= '9') ? start - '0' : 0;
+        while (true) {
+            int c = buf.get();
+            if (c == '.') {
+                if (sawdot) {
+                    throw new PDFParseException("Can't have two '.' in a number");
+                }
+                sawdot = true;
+                dotmult = 0.1;
+            } else if (c >= '0' && c <= '9') {
+                int val = c - '0';
+                if (sawdot) {
+                    value += val * dotmult;
+                    dotmult *= 0.1;
+                } else {
+                    value = value * 10 + val;
+                }
+            } else {
+                buf.position(buf.position() - 1);
+                break;
+            }
+        }
+        if (neg) {
+            value = -value;
+        }
+        return new PDFObject(this, PDFObject.NUMBER, new Double(value));
+    }
+
+    /**
+     * read a bare keyword.  The initial character is passed in as the
+     * argument.
+     */
+    private PDFObject readKeyword(char start) throws IOException {
+        // we've read the first character (it's passed in as the argument)
+        StringBuffer sb = new StringBuffer(String.valueOf(start));
+        int c;
+        while (isRegularCharacter(c = buf.get())) {
+            sb.append((char) c);
+        }
+        buf.position(buf.position() - 1);
+        return new PDFObject(this, PDFObject.KEYWORD, sb.toString());
+    }
+
+    /**
+     * read an entire PDFObject.  The intro line, which looks something
+     * like "4 0 obj" has already been read.
+     * @param objNum the object number of the object being read, being
+     *  the first number in the intro line (4 in "4 0 obj")
+     * @param objGen the object generation of the object being read, being
+     *  the second number in the intro line (0 in "4 0 obj").
+     * @param decrypter the decrypter to use
+     */
+    private PDFObject readObjectDescription(
+            int objNum, int objGen, PDFDecrypter decrypter) throws IOException {
+        // we've already read the 4 0 obj bit.  Next thing up is the object.
+        // object descriptions end with the keyword endobj
+        long debugpos = buf.position();
+	PDFObject obj= readObject(objNum, objGen, decrypter);
+        // see if it's a dictionary.  If so, this could be a stream.
+	PDFObject endkey= readObject(objNum, objGen, decrypter);
+        if (endkey.getType() != PDFObject.KEYWORD) {
+            throw new PDFParseException("Expected 'stream' or 'endobj'");
+        }
+        if (obj.getType() == PDFObject.DICTIONARY && endkey.getStringValue().equals("stream")) {
+            // skip until we see \n
+            readLine();
+            ByteBuffer data = readStream(obj);
+            if (data == null) {
+                data = ByteBuffer.allocate(0);
+            }
+            obj.setStream(data);
+	    endkey= readObject(objNum, objGen, decrypter);
+        }
+        // at this point, obj is the object, keyword should be "endobj"
+        String endcheck = endkey.getStringValue();
+        if (endcheck == null || !endcheck.equals("endobj")) {
+            System.out.println("WARNING: object at " + debugpos + " didn't end with 'endobj'");
+        //throw new PDFParseException("Object musst end with 'endobj'");
+        }
+        obj.setObjectId(objNum, objGen);
+        return obj;
+    }
+
+    /**
+     * read the stream portion of a PDFObject.  Calls decodeStream to
+     * un-filter the stream as necessary.
+     *
+     * @param dict the dictionary associated with this stream.
+     * @return a ByteBuffer with the encoded stream data
+     */
+    private ByteBuffer readStream(PDFObject dict) throws IOException {
+        // pointer is at the start of a stream.  read the stream and
+        // decode, based on the entries in the dictionary
+        PDFObject lengthObj = dict.getDictRef("Length");
+        int length = -1;
+        if (lengthObj != null) {
+            length = lengthObj.getIntValue();
+        }
+        if (length < 0) {
+            throw new PDFParseException("Unknown length for stream");
+        }
+
+        // slice the data
+        int start = buf.position();
+        ByteBuffer streamBuf = buf.slice();
+        streamBuf.limit(length);
+
+        // move the current position to the end of the data
+        buf.position(buf.position() + length);
+        int ending = buf.position();
+
+        if (!nextItemIs("endstream")) {
+            System.out.println("read " + length + " chars from " + start + " to " +
+                    ending);
+            throw new PDFParseException("Stream ended inappropriately");
+        }
+
+        return streamBuf;
+    // now decode stream
+    // return PDFDecoder.decodeStream(dict, streamBuf);
+    }
+
+    /**
+     * read the cross reference table from a PDF file.  When this method
+     * is called, the file pointer must point to the start of the word
+     * "xref" in the file.  Reads the xref table and the trailer dictionary.
+     * If dictionary has a /Prev entry, move file pointer
+     * and read new trailer
+     * @param password
+     */
+    private void readTrailer(PDFPassword password)
+            throws
+            IOException,
+            PDFAuthenticationFailureException,
+            EncryptionUnsupportedByProductException,
+            EncryptionUnsupportedByPlatformException {
+        // the table of xrefs
+        objIdx = new PDFXref[50];
+
+        PDFDecrypter newDefaultDecrypter = null;
+
+        // read a bunch of nested trailer tables
+        while (true) {
+            // make sure we are looking at an xref table
+            if (!nextItemIs("xref")) {
+                throw new PDFParseException("Expected 'xref' at start of table");
+            }
+
+            // read a bunch of linked tabled
+            while (true) {
+                // read until the word "trailer"
+		PDFObject obj=readObject(-1, -1, IdentityDecrypter.getInstance());
+                if (obj.getType() == PDFObject.KEYWORD &&
+                        obj.getStringValue().equals("trailer")) {
+                    break;
+                }
+
+                // read the starting position of the reference
+                if (obj.getType() != PDFObject.NUMBER) {
+                    throw new PDFParseException("Expected number for first xref entry");
+                }
+                int refstart = obj.getIntValue();
+
+                // read the size of the reference table
+                obj = readObject(-1, -1, IdentityDecrypter.getInstance());
+                if (obj.getType() != PDFObject.NUMBER) {
+                    throw new PDFParseException("Expected number for length of xref table");
+                }
+                int reflen = obj.getIntValue();
+
+                // skip a line
+                readLine();
+
+                // extend the objIdx table, if necessary
+                if (refstart + reflen >= objIdx.length) {
+                    PDFXref nobjIdx[] = new PDFXref[refstart + reflen];
+                    System.arraycopy(objIdx, 0, nobjIdx, 0, objIdx.length);
+                    objIdx = nobjIdx;
+                }
+
+                // read reference lines
+                for (int refID = refstart; refID < refstart + reflen; refID++) {
+                    // each reference line is 20 bytes long
+                    byte[] refline = new byte[20];
+                    buf.get(refline);
+
+                    // ignore this line if the object ID is already defined
+                    if (objIdx[refID] != null) {
+                        continue;
+                    }
+
+                    // see if it's an active object
+                    if (refline[17] == 'n') {
+                        objIdx[refID] = new PDFXref(refline);
+                    } else {
+                        objIdx[refID] = new PDFXref(null);
+                    }
+                }
+            }
+
+            // at this point, the "trailer" word (not EOL) has been read.
+	    PDFObject trailerdict = readObject(-1, -1, IdentityDecrypter.getInstance());
+            if (trailerdict.getType() != PDFObject.DICTIONARY) {
+                throw new IOException("Expected dictionary after \"trailer\"");
+            }
+
+            // read the root object location
+            if (root == null) {
+                root = trailerdict.getDictRef("Root");
+                if (root != null) {
+                    root.setObjectId(PDFObject.OBJ_NUM_TRAILER,
+                            PDFObject.OBJ_NUM_TRAILER);
+                }
+            }
+
+            // read the encryption information
+            if (encrypt == null) {
+                encrypt = trailerdict.getDictRef("Encrypt");
+                if (encrypt != null) {
+                    encrypt.setObjectId(PDFObject.OBJ_NUM_TRAILER,
+                            PDFObject.OBJ_NUM_TRAILER);
+                }
+                newDefaultDecrypter =
+                        PDFDecrypterFactory.createDecryptor(
+                                encrypt,
+                                trailerdict.getDictRef("ID"),
+                                password);
+            }
+
+
+            if (info == null) {
+                info = trailerdict.getDictRef("Info");
+                if (info != null) {
+                    if (!info.isIndirect()) {
+                        throw new PDFParseException(
+                                "Info in trailer must be an indirect reference");
+                    }
+                    info.setObjectId(PDFObject.OBJ_NUM_TRAILER,
+                            PDFObject.OBJ_NUM_TRAILER);
+                }
+            }
+
+            // read the location of the previous xref table
+            PDFObject prevloc = trailerdict.getDictRef("Prev");
+            if (prevloc != null) {
+                buf.position(prevloc.getIntValue());
+            } else {
+                break;
+            }
+            // see if we have an optional Version entry
+
+
+            if (root.getDictRef("Version") != null) {
+                processVersion(root.getDictRef("Version").getStringValue());
+            }
+        }
+
+        // make sure we found a root
+        if (root == null) {
+            throw new PDFParseException("No /Root key found in trailer dictionary");
+        }
+
+        // check what permissions are relevant
+        if (encrypt != null) {
+            PDFObject permissions = encrypt.getDictRef("P");
+            if (permissions!=null && !newDefaultDecrypter.isOwnerAuthorised()) {
+                int perms= permissions != null ? permissions.getIntValue() : 0;
+                if (permissions!=null) {
+                    printable = (perms & 4) != 0;
+                    saveable = (perms & 16) != 0;
+                }
+            }
+            // Install the new default decrypter only after the trailer has
+            // been read, as nothing we're reading passing through is encrypted
+            defaultDecrypter = newDefaultDecrypter;
+        }
+
+        // dereference the root object
+        root.dereference();
+    }
+
+    /**
+     * build the PDFFile reference table.  Nothing in the PDFFile actually
+     * gets parsed, despite the name of this function.  Things only get
+     * read and parsed when they're needed.
+     * @param password
+     */
+    private void parseFile(PDFPassword password) throws IOException {
+        // start at the begining of the file
+        buf.rewind();
+        String versionLine = readLine();
+        if (versionLine.startsWith(VERSION_COMMENT)) {
+            processVersion(versionLine.substring(VERSION_COMMENT.length()));
+        }
+        buf.rewind();
+
+        // back up about 32 characters from the end of the file to find
+        // startxref\n
+        byte[] scan = new byte[32];
+        int scanPos = buf.remaining() - scan.length;
+        int loc = 0;
+
+        while (scanPos >= 0) {
+            buf.position(scanPos);
+            buf.get(scan);
+
+            // find startxref in scan
+            String scans = new String(scan);
+            loc = scans.indexOf("startxref");
+            if (loc > 0) {
+                if (scanPos + loc + scan.length <= buf.limit()) {
+                    scanPos = scanPos + loc;
+                    loc = 0;
+                }
+
+                break;
+            }
+            scanPos -= scan.length - 10;
+        }
+
+        if (scanPos < 0) {
+            throw new IOException("This may not be a PDF File");
+        }
+
+        buf.position(scanPos);
+        buf.get(scan);
+        String scans = new String(scan);
+
+        loc += 10;  // skip over "startxref" and first EOL char
+        if (scans.charAt(loc) < 32) {
+            loc++;
+        }  // skip over possible 2nd EOL char
+        while (scans.charAt(loc) == 32) {
+            loc++;
+        } // skip over possible leading blanks
+        // read number
+        int numstart = loc;
+        while (loc < scans.length() &&
+                scans.charAt(loc) >= '0' &&
+                scans.charAt(loc) <= '9') {
+            loc++;
+        }
+        int xrefpos = Integer.parseInt(scans.substring(numstart, loc));
+        buf.position(xrefpos);
+
+        try {
+            readTrailer(password);
+        } catch (UnsupportedEncryptionException e) {
+            throw new PDFParseException(e.getMessage(), e);
+        }
+    }
+
+    /**
+     * Gets the outline tree as a tree of OutlineNode, which is a subclass
+     * of DefaultMutableTreeNode.  If there is no outline tree, this method
+     * returns null.
+     */
+    public OutlineNode getOutline() throws IOException {
+        // find the outlines entry in the root object
+        PDFObject oroot = root.getDictRef("Outlines");
+        OutlineNode work = null;
+        OutlineNode outline = null;
+        if (oroot != null) {
+            // find the first child of the outline root
+            PDFObject scan = oroot.getDictRef("First");
+            outline = work = new OutlineNode("<top>");
+
+            // scan each sibling in turn
+            while (scan != null) {
+                // add the new node with it's name
+                String title = scan.getDictRef("Title").getTextStringValue();
+                OutlineNode build = new OutlineNode(title);
+                work.add(build);
+
+                // find the action
+                PDFAction action = null;
+
+                PDFObject actionObj = scan.getDictRef("A");
+                if (actionObj != null) {
+                    action = PDFAction.getAction(actionObj, getRoot());
+                } else {
+                    // try to create an action from a destination
+                    PDFObject destObj = scan.getDictRef("Dest");
+                    if (destObj != null) {
+                        try {
+                            PDFDestination dest =
+                                    PDFDestination.getDestination(destObj, getRoot());
+
+                            action = new GoToAction(dest);
+                        } catch (IOException ioe) {
+                            // oh well
+                        }
+                    }
+                }
+
+                // did we find an action?  If so, add it
+                if (action != null) {
+                    build.setAction(action);
+                }
+
+                // find the first child of this node
+                PDFObject kid = scan.getDictRef("First");
+                if (kid != null) {
+                    work = build;
+                    scan = kid;
+                } else {
+                    // no child.  Process the next sibling
+                    PDFObject next = scan.getDictRef("Next");
+                    while (next == null) {
+                        scan = scan.getDictRef("Parent");
+                        next = scan.getDictRef("Next");
+                        work = (OutlineNode) work.getParent();
+                        if (work == null) {
+                            break;
+                        }
+                    }
+                    scan = next;
+                }
+            }
+        }
+
+        return outline;
+    }
+
+    /**
+     * Gets the page number (starting from 1) of the page represented by
+     * a particular PDFObject.  The PDFObject must be a Page dictionary or
+     * a destination description (or an action).
+     * @return a number between 1 and the number of pages indicating the
+     * page number, or 0 if the PDFObject is not in the page tree.
+     */
+    public int getPageNumber(PDFObject page) throws IOException {
+        if (page.getType() == PDFObject.ARRAY) {
+            page = page.getAt(0);
+        }
+
+        // now we've got a page.  Make sure.
+        PDFObject typeObj = page.getDictRef("Type");
+        if (typeObj == null || !typeObj.getStringValue().equals("Page")) {
+            return 0;
+        }
+
+        int count = 0;
+        while (true) {
+            PDFObject parent = page.getDictRef("Parent");
+            if (parent == null) {
+                break;
+            }
+            PDFObject kids[] = parent.getDictRef("Kids").getArray();
+            for (int i = 0; i < kids.length; i++) {
+                if (kids[i].equals(page)) {
+                    break;
+                } else {
+                    PDFObject kcount = kids[i].getDictRef("Count");
+                    if (kcount != null) {
+                        count += kcount.getIntValue();
+                    } else {
+                        count += 1;
+                    }
+                }
+            }
+            page = parent;
+        }
+        return count;
+    }
+
+    /**
+     * Get the page commands for a given page in a separate thread.
+     *
+     * @param pagenum the number of the page to get commands for
+     */
+    public PDFPage getPage(int pagenum) {
+        return getPage(pagenum, false);
+    }
+
+    /**
+     * Get the page commands for a given page.
+     *
+     * @param pagenum the number of the page to get commands for
+     * @param wait if true, do not exit until the page is complete.
+     */
+    public PDFPage getPage(int pagenum, boolean wait) {
+        Integer key = new Integer(pagenum);
+        HashMap<String,PDFObject> resources = null;
+        PDFObject pageObj = null;
+        boolean needread = false;
+
+        PDFPage page = cache.getPage(key);
+        PDFParser parser = cache.getPageParser(key);
+        if (page == null) {
+            try {
+                // hunt down the page!
+                resources = new HashMap<String,PDFObject>();
+
+                PDFObject topPagesObj = root.getDictRef("Pages");
+                pageObj = findPage(topPagesObj, 0, pagenum, resources);
+
+                if (pageObj == null) {
+                    return null;
+                }
+
+                page = createPage(pagenum, pageObj);
+
+                byte[] stream = getContents(pageObj);
+                parser = new PDFParser(page, stream, resources);
+
+                cache.addPage(key, page, parser);
+            } catch (IOException ioe) {
+                System.out.println("GetPage inner loop:");
+                ioe.printStackTrace();
+                return null;
+            }
+        }
+
+        if (parser != null && !parser.isFinished()) {
+            parser.go(wait);
+        }
+
+        return page;
+    }
+
+    /**
+     * Stop the rendering of a particular image on this page
+     */
+    public void stop(int pageNum) {
+        PDFParser parser = cache.getPageParser(new Integer(pageNum));
+        if (parser != null) {
+            // stop it
+            parser.stop();
+        }
+    }
+
+    /**
+     * get the stream representing the content of a particular page.
+     *
+     * @param pageObj the page object to get the contents of
+     * @return a concatenation of any content streams for the requested
+     * page.
+     */
+    private byte[] getContents(PDFObject pageObj) throws IOException {
+        // concatenate all the streams
+        PDFObject contentsObj = pageObj.getDictRef("Contents");
+        if (contentsObj == null) {
+            throw new IOException("No page contents!");
+        }
+
+        PDFObject contents[] = contentsObj.getArray();
+
+        // see if we have only one stream (the easy case)
+        if (contents.length == 1) {
+            return contents[0].getStream();
+        }
+
+        // first get the total length of all the streams
+        int len = 0;
+        for (int i = 0; i < contents.length; i++) {
+            byte[] data = contents[i].getStream();
+            if (data == null) {
+                throw new PDFParseException("No stream on content " + i +
+                        ": " + contents[i]);
+            }
+            len += data.length;
+        }
+
+        // now assemble them all into one object
+        byte[] stream = new byte[len];
+        len = 0;
+        for (int i = 0; i < contents.length; i++) {
+            byte data[] = contents[i].getStream();
+            System.arraycopy(data, 0, stream, len, data.length);
+            len += data.length;
+        }
+
+        return stream;
+    }
+
+    /**
+     * Create a PDF Page object by finding the relevant inherited
+     * properties
+     *
+     * @param pageObj the PDF object for the page to be created
+     */
+    private PDFPage createPage(int pagenum, PDFObject pageObj)
+            throws IOException {
+        int rotation = 0;
+        RectF mediabox = null; // second choice, if no crop
+        RectF cropbox = null;  // first choice
+
+        PDFObject mediaboxObj = getInheritedValue(pageObj, "MediaBox");
+        if (mediaboxObj != null) {
+            mediabox = parseRect(mediaboxObj);
+        }
+
+        PDFObject cropboxObj = getInheritedValue(pageObj, "CropBox");
+        if (cropboxObj != null) {
+            cropbox = parseRect(cropboxObj);
+        }
+
+        PDFObject rotateObj = getInheritedValue(pageObj, "Rotate");
+        if (rotateObj != null) {
+            rotation = rotateObj.getIntValue();
+        }
+
+        RectF bbox = ((cropbox == null) ? mediabox : cropbox);
+
+        return new PDFPage(pagenum, bbox, rotation, cache);
+    }
+
+    /**
+     * Get the PDFObject representing the content of a particular page. Note
+     * that the number of the page need not have anything to do with the
+     * label on that page.  If there are two blank pages, and then roman
+     * numerals for the page number, then passing in 6 will get page (iv).
+     *
+     * @param pagedict the top of the pages tree
+     * @param start the page number of the first page in this dictionary
+     * @param getPage the number of the page to find; NOT the page's label.
+     * @param resources a HashMap that will be filled with any resource
+     *                  definitions encountered on the search for the page
+     */
+    private PDFObject findPage(PDFObject pagedict, int start, int getPage,
+            Map<String,PDFObject> resources) throws IOException {
+        PDFObject rsrcObj = pagedict.getDictRef("Resources");
+        if (rsrcObj != null) {
+            resources.putAll(rsrcObj.getDictionary());
+        }
+
+        PDFObject typeObj = pagedict.getDictRef("Type");
+        if (typeObj != null && typeObj.getStringValue().equals("Page")) {
+            // we found our page!
+            return pagedict;
+        }
+
+        // find the first child for which (start + count) > getPage
+        PDFObject kidsObj = pagedict.getDictRef("Kids");
+        if (kidsObj != null) {
+            PDFObject[] kids = kidsObj.getArray();
+            for (int i = 0; i < kids.length; i++) {
+                int count = 1;
+                // BUG: some PDFs (T1Format.pdf) don't have the Type tag.
+                // use the Count tag to indicate a Pages dictionary instead.
+                PDFObject countItem = kids[i].getDictRef("Count");
+                //                if (kids[i].getDictRef("Type").getStringValue().equals("Pages")) {
+                if (countItem != null) {
+                    count = countItem.getIntValue();
+                }
+
+                if (start + count >= getPage) {
+                    return findPage(kids[i], start, getPage, resources);
+                }
+
+                start += count;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Find a property value in a page that may be inherited.  If the value
+     * is not defined in the page itself, follow the page's "parent" links
+     * until the value is found or the top of the tree is reached.
+     *
+     * @param pageObj the object representing the page
+     * @param propName the name of the property we are looking for
+     */
+    private PDFObject getInheritedValue(PDFObject pageObj, String propName)
+            throws IOException {
+        // see if we have the property
+        PDFObject propObj = pageObj.getDictRef(propName);
+        if (propObj != null) {
+            return propObj;
+        }
+
+        // recursively see if any of our parent have it
+        PDFObject parentObj = pageObj.getDictRef("Parent");
+        if (parentObj != null) {
+            return getInheritedValue(parentObj, propName);
+        }
+
+        // no luck
+        return null;
+    }
+
+    /**
+     * get a Rectangle2D.Float representation for a PDFObject that is an
+     * array of four Numbers.
+     * @param obj a PDFObject that represents an Array of exactly four
+     * Numbers.
+     */
+    public RectF parseRect(PDFObject obj) throws IOException {
+        if (obj.getType() == PDFObject.ARRAY) {
+            PDFObject bounds[] = obj.getArray();
+            if (bounds.length == 4) {
+                return new RectF(bounds[0].getFloatValue(),
+                        bounds[1].getFloatValue(),
+                        bounds[2].getFloatValue() - bounds[0].getFloatValue(),
+                        bounds[3].getFloatValue() - bounds[1].getFloatValue());
+            } else {
+                throw new PDFParseException("Rectangle definition didn't have 4 elements");
+            }
+        } else {
+            throw new PDFParseException("Rectangle definition not an array");
+        }
+    }
+
+    /**
+     * Get the default decrypter for the document
+     * @return the default decrypter; never null, even for documents that
+     *  aren't encrypted
+     */
+    public PDFDecrypter getDefaultDecrypter() {
+        return defaultDecrypter;
+    }
+}

src/com/sun/pdfview/PDFImage.java

@@ -0,0 +1,692 @@
+/*
+ * $Id: PDFImage.java,v 1.9 2009/03/12 13:23:54 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.HashMap;
+import java.util.Map;
+
+import com.sun.pdfview.colorspace.PDFColorSpace;
+import com.sun.pdfview.function.FunctionType0;
+
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.graphics.Bitmap.Config;
+import android.util.Log;
+
+
+
+/**
+ * Encapsulates a PDF Image
+ */
+public class PDFImage {
+
+    private static final String TAG = "AWTPDF.pdfimage";
+
+    public static boolean sShowImages;
+
+	public static void dump(PDFObject obj) throws IOException {
+        p("dumping PDF object: " + obj);
+        if (obj == null) {
+            return;
+        }
+        HashMap dict = obj.getDictionary();
+        p("   dict = " + dict);
+        for (Object key : dict.keySet()) {
+            p("key = " + key + " value = " + dict.get(key));
+        }
+    }
+
+    public static void p(String string) {
+        System.out.println(string);
+    }
+    /** color key mask. Array of start/end pairs of ranges of color components to
+     *  mask out. If a component falls within any of the ranges it is clear. */
+    private int[] colorKeyMask = null;
+    /** the width of this image in pixels */
+    private int width;
+    /** the height of this image in pixels */
+    private int height;
+    /** the colorspace to interpret the samples in */
+    private PDFColorSpace colorSpace;
+    /** the number of bits per sample component */
+    private int bpc;
+    /** whether this image is a mask or not */
+    private boolean imageMask = false;
+    /** the SMask image, if any */
+    private PDFImage sMask;
+    /** the decode array */
+    private float[] decode;
+    /** the actual image data */
+    private PDFObject imageObj;
+
+    /** 
+     * Create an instance of a PDFImage
+     */
+    protected PDFImage(PDFObject imageObj) {
+        this.imageObj = imageObj;
+    }
+
+    /**
+     * Read a PDFImage from an image dictionary and stream
+     *
+     * @param obj the PDFObject containing the image's dictionary and stream
+     * @param resources the current resources
+     */
+    public static PDFImage createImage(PDFObject obj, Map resources)
+            throws IOException {
+        // create the image
+        PDFImage image = new PDFImage(obj);
+
+        // get the width (required)
+        PDFObject widthObj = obj.getDictRef("Width");
+        if (widthObj == null) {
+            throw new PDFParseException("Unable to read image width: " + obj);
+        }
+        image.setWidth(widthObj.getIntValue());
+
+        // get the height (required)
+        PDFObject heightObj = obj.getDictRef("Height");
+        if (heightObj == null) {
+            throw new PDFParseException("Unable to get image height: " + obj);
+        }
+        image.setHeight(heightObj.getIntValue());
+
+        // figure out if we are an image mask (optional)
+        PDFObject imageMaskObj = obj.getDictRef("ImageMask");
+        if (imageMaskObj != null) {
+            image.setImageMask(imageMaskObj.getBooleanValue());
+        }
+
+        // read the bpc and colorspace (required except for masks) 
+        if (image.isImageMask()) {
+            image.setBitsPerComponent(1);
+
+            // create the indexed color space for the mask
+            // [PATCHED by michal.busta@gmail.com] - default value od Decode according to PDF spec. is [0, 1]
+        	// so the color arry should be:  
+            int[] colors = {Color.BLACK, Color.WHITE};
+            
+            PDFObject imageMaskDecode = obj.getDictRef("Decode");
+            if (imageMaskDecode != null) {
+                PDFObject[] array = imageMaskDecode.getArray();
+                float decode0 = array[0].getFloatValue();
+                if (decode0 == 1.0f) {
+                    colors = new int[]{Color.WHITE, Color.BLACK};
+                }
+            }
+            // TODO [FHe]: support for indexed colorspace
+            image.setColorSpace(PDFColorSpace.getColorSpace(PDFColorSpace.COLORSPACE_GRAY));
+//          image.setColorSpace(new IndexedColor(colors));
+        } else {
+            // get the bits per component (required)
+            PDFObject bpcObj = obj.getDictRef("BitsPerComponent");
+            if (bpcObj == null) {
+                throw new PDFParseException("Unable to get bits per component: " + obj);
+            }
+            image.setBitsPerComponent(bpcObj.getIntValue());
+
+            // get the color space (required)
+            PDFObject csObj = obj.getDictRef("ColorSpace");
+            if (csObj == null) {
+                throw new PDFParseException("No ColorSpace for image: " + obj);
+            }
+
+            PDFColorSpace cs = PDFColorSpace.getColorSpace(csObj, resources);
+            image.setColorSpace(cs);
+        }
+
+        // read the decode array
+        PDFObject decodeObj = obj.getDictRef("Decode");
+        if (decodeObj != null) {
+            PDFObject[] decodeArray = decodeObj.getArray();
+
+            float[] decode = new float[decodeArray.length];
+            for (int i = 0; i < decodeArray.length; i++) {
+                decode[i] = decodeArray[i].getFloatValue();
+            }
+
+            image.setDecode(decode);
+        }
+
+        // read the soft mask.
+        // If ImageMask is true, this entry must not be present.
+        // (See implementation note 52 in Appendix H.)
+        if (imageMaskObj == null) {
+            PDFObject sMaskObj = obj.getDictRef("SMask");
+            if (sMaskObj == null) {
+                // try the explicit mask, if there is no SoftMask
+                sMaskObj = obj.getDictRef("Mask");
+            }
+
+            if (sMaskObj != null) {
+                if (sMaskObj.getType() == PDFObject.STREAM) {
+                    try {
+                        PDFImage sMaskImage = PDFImage.createImage(sMaskObj, resources);
+                        image.setSMask(sMaskImage);
+                    } catch (IOException ex) {
+                        p("ERROR: there was a problem parsing the mask for this object");
+                        dump(obj);
+                        ex.printStackTrace(System.out);
+                    }
+                } else if (sMaskObj.getType() == PDFObject.ARRAY) {
+                    // retrieve the range of the ColorKeyMask
+                    // colors outside this range will not be painted.
+                    try {
+                        image.setColorKeyMask(sMaskObj);
+                    } catch (IOException ex) {
+                        p("ERROR: there was a problem parsing the color mask for this object");
+                        dump(obj);
+                        ex.printStackTrace(System.out);
+                    }
+                }
+            }
+        }
+
+        return image;
+    }
+
+    /**
+     * Get the image that this PDFImage generates.
+     *
+     * @return a buffered image containing the decoded image data
+     */
+    public Bitmap getImage() {
+        try {
+            Bitmap bi = (Bitmap) imageObj.getCache();
+
+            if (bi == null) {
+            	if (!sShowImages)
+            		throw new UnsupportedOperationException("do not show images");
+            	byte[] imgBytes = imageObj.getStream();
+                bi = parseData(imgBytes);
+            	// TODO [FHe]: is the cache useful on Android?
+                imageObj.setCache(bi);
+            }
+//            if(bi != null)
+//            	ImageIO.write(bi, "png", new File("/tmp/test/" + System.identityHashCode(this) + ".png"));
+            return bi;
+        } catch (IOException ioe) {
+            System.out.println("Error reading image");
+            ioe.printStackTrace();
+            return null;
+        } catch (OutOfMemoryError e) {
+            // fix for too large images
+            Log.e(TAG, "image too large (OutOfMemoryError)");
+            int size = 15;
+            int max = size-1;
+            int half = size/2-1;
+            Bitmap bi = Bitmap.createBitmap(size, size, Config.RGB_565);
+            Canvas c = new Canvas(bi);
+            c.drawColor(Color.RED);
+            Paint p = new Paint();
+            p.setColor(Color.WHITE);
+            c.drawLine(0, 0, max, max, p);
+            c.drawLine(0, max, max, 0, p);
+            c.drawLine(half, 0, half, max, p);
+            c.drawLine(0, half, max, half, p);
+            return bi;
+		}
+    }
+
+	private Bitmap parseData(byte[] imgBytes) {
+		Bitmap bi;
+		long startTime = System.currentTimeMillis();
+		// parse the stream data into an actual image
+		Log.i(TAG, "Creating Image width="+getWidth() + ", Height="+getHeight()+", bpc="+getBitsPerComponent()+",cs="+colorSpace);
+		if (colorSpace == null) {
+			throw new UnsupportedOperationException("image without colorspace");
+		} else if (colorSpace.getType() == PDFColorSpace.COLORSPACE_RGB) {
+			int maxH = getHeight();
+			int maxW = getWidth();
+			if (imgBytes.length == 2*maxW*maxH) {
+				// decoded JPEG as RGB565
+				bi = Bitmap.createBitmap(maxW, maxH, Config.RGB_565);
+				bi.copyPixelsFromBuffer(ByteBuffer.wrap(imgBytes));
+			}
+			else {
+				// create RGB image
+				bi = Bitmap.createBitmap(getWidth(), getHeight(), Config.ARGB_8888);
+				int[] line = new int[maxW]; 
+				int n=0;
+				for (int h = 0; h<maxH; h++) {
+					for (int w = 0; w<getWidth(); w++) {
+						line[w] = ((0xff&(int)imgBytes[n])<<8|(0xff&(int)imgBytes[n+1]))<<8|(0xff&(int)imgBytes[n+2])|0xFF000000;
+	//            			line[w] = Color.rgb(0xff&(int)imgBytes[n], 0xff&(int)imgBytes[n+1],0xff&(int)imgBytes[n+2]);
+						n+=3;
+					}
+					bi.setPixels(line, 0, maxW, 0, h, maxW, 1);
+				}
+			}
+		}
+		else if (colorSpace.getType() == PDFColorSpace.COLORSPACE_GRAY) {
+			// create gray image
+			bi = Bitmap.createBitmap(getWidth(), getHeight(), Config.ARGB_8888);
+			int maxH = getHeight();
+			int maxW = getWidth();
+			int[] line = new int[maxW]; 
+			int n=0;
+			for (int h = 0; h<maxH; h++) {
+				for (int w = 0; w<getWidth(); w++) {
+					int gray = 0xff&(int)imgBytes[n];
+					line[w] = (gray<<8|gray)<<8|gray|0xFF000000;
+					n+=1;
+				}
+				bi.setPixels(line, 0, maxW, 0, h, maxW, 1);
+			}
+		}
+		else if (colorSpace.getType() == PDFColorSpace.COLORSPACE_INDEXED) {
+			// create indexed image
+			bi = Bitmap.createBitmap(getWidth(), getHeight(), Config.ARGB_8888);
+			int maxH = getHeight();
+			int maxW = getWidth();
+			int[] line = new int[maxW];
+			int[] comps = new int[1];
+			int n=0;
+			for (int h = 0; h<maxH; h++) {
+				for (int w = 0; w<getWidth(); w++) {
+					comps[0] = imgBytes[n]&0xff;
+					line[w] = colorSpace.toColor(comps);
+					n+=1;
+				}
+				bi.setPixels(line, 0, maxW, 0, h, maxW, 1);
+			}
+		}
+		else {
+			throw new UnsupportedOperationException("image with unsupported colorspace "+colorSpace);
+		}
+		long stopTime = System.currentTimeMillis();
+		Log.i(TAG, "millis for converting image="+(stopTime-startTime));
+		return bi;
+	}
+
+//    /**
+//     * <p>Parse the image stream into a buffered image.  Note that this is
+//     * guaranteed to be called after all the other setXXX methods have been 
+//     * called.</p>
+//     *
+//     * <p>NOTE: the color convolving is extremely slow on large images.
+//     * It would be good to see if it could be moved out into the rendering
+//     * phases, where we might be able to scale the image down first.</p
+//     */
+//    protected Bitmap parseData(byte[] data) {
+////        String hex;
+////        String name;
+////        synchronized (System.out) {
+////            System.out.println("\n\n" + name + ": " + data.length);
+////            for (int i = 0; i < data.length; i++) {
+////                hex = "0x" + Integer.toHexString(0xFF & data[i]);
+////                System.out.print(hex);
+////                if (i < data.length - 1) {
+////                    System.out.print(", ");
+////                }
+////                if ((i + 1) % 25 == 0) {
+////                    System.out.print("\n");
+////                }
+////            }
+////            System.out.println("\n");
+////            System.out.flush();
+////        }
+//        // create the data buffer
+//        DataBuffer db = new DataBufferByte(data, data.length);
+//
+//        // pick a color model, based on the number of components and
+//        // bits per component
+//        ColorModel cm = getColorModel();
+//
+//        // create a compatible raster
+//        SampleModel sm = cm.createCompatibleSampleModel(getWidth(), getHeight());
+//        WritableRaster raster =
+//                Raster.createWritableRaster(sm, db, new Point(0, 0));
+//
+//        /* 
+//         * Workaround for a bug on the Mac -- a class cast exception in
+//         * drawImage() due to the wrong data buffer type (?)
+//         */
+//        BufferedImage bi = null;
+//        if (cm instanceof IndexColorModel) {
+//            IndexColorModel icm = (IndexColorModel) cm;
+//
+//            // choose the image type based on the size
+//            int type = BufferedImage.TYPE_BYTE_BINARY;
+//            if (getBitsPerComponent() == 8) {
+//                type = BufferedImage.TYPE_BYTE_INDEXED;
+//            }
+//
+//            // create the image with an explicit indexed color model.
+//            bi = new BufferedImage(getWidth(), getHeight(), type, icm);
+//
+//            // set the data explicitly as well
+//            bi.setData(raster);
+//        } else {
+//            bi = new BufferedImage(cm, raster, true, null);
+//        }
+//
+//        // hack to avoid *very* slow conversion
+//        ColorSpace cs = cm.getColorSpace();
+//        ColorSpace rgbCS = ColorSpace.getInstance(ColorSpace.CS_sRGB);
+//
+//        // add in the alpha data supplied by the SMask, if any
+//        PDFImage sMaskImage = getSMask();
+//        if (sMaskImage != null) {
+//            BufferedImage si = sMaskImage.getImage();
+//
+//            BufferedImage outImage = new BufferedImage(getWidth(),
+//                    getHeight(), BufferedImage.TYPE_INT_ARGB);
+//
+//            int[] srcArray = new int[width];
+//            int[] maskArray = new int[width];
+//
+//            for (int i = 0; i < height; i++) {
+//                bi.getRGB(0, i, width, 1, srcArray, 0, width);
+//                si.getRGB(0, i, width, 1, maskArray, 0, width);
+//
+//                for (int j = 0; j < width; j++) {
+//                    int ac = 0xff000000;
+//
+//                    maskArray[j] = ((maskArray[j] & 0xff) << 24) | (srcArray[j] & ~ac);
+//                }
+//
+//                outImage.setRGB(0, i, width, 1, maskArray, 0, width);
+//            }
+//
+//            bi = outImage;
+//        }
+//
+//        return (bi);
+//    }
+
+    /**
+     * Get the image's width
+     */
+    public int getWidth() {
+        return width;
+    }
+
+    /**
+     * Set the image's width
+     */
+    protected void setWidth(int width) {
+        this.width = width;
+    }
+
+    /**
+     * Get the image's height
+     */
+    public int getHeight() {
+        return height;
+    }
+
+    /**
+     * Set the image's height
+     */
+    protected void setHeight(int height) {
+        this.height = height;
+    }
+
+    /**
+     * set the color key mask. It is an array of start/end entries
+     * to indicate ranges of color indicies that should be masked out.
+     * 
+     * @param maskArrayObject
+     */
+    private void setColorKeyMask(PDFObject maskArrayObject) throws IOException {
+        PDFObject[] maskObjects = maskArrayObject.getArray();
+        colorKeyMask = null;
+        int[] masks = new int[maskObjects.length];
+        for (int i = 0; i < masks.length; i++) {
+            masks[i] = maskObjects[i].getIntValue();
+        }
+        colorKeyMask = masks;
+    }
+
+    /**
+     * Get the colorspace associated with this image, or null if there
+     * isn't one
+     */
+    protected PDFColorSpace getColorSpace() {
+        return colorSpace;
+    }
+
+    /**
+     * Set the colorspace associated with this image
+     */
+    protected void setColorSpace(PDFColorSpace colorSpace) {
+        this.colorSpace = colorSpace;
+    }
+
+    /**
+     * Get the number of bits per component sample
+     */
+    protected int getBitsPerComponent() {
+        return bpc;
+    }
+
+    /**
+     * Set the number of bits per component sample
+     */
+    protected void setBitsPerComponent(int bpc) {
+        this.bpc = bpc;
+    }
+
+    /**
+     * Return whether or not this is an image mask
+     */
+    public boolean isImageMask() {
+        return imageMask;
+    }
+
+    /**
+     * Set whether or not this is an image mask
+     */
+    public void setImageMask(boolean imageMask) {
+        this.imageMask = imageMask;
+    }
+
+    /** 
+     * Return the soft mask associated with this image
+     */
+    public PDFImage getSMask() {
+        return sMask;
+    }
+
+    /**
+     * Set the soft mask image
+     */
+    protected void setSMask(PDFImage sMask) {
+        this.sMask = sMask;
+    }
+
+    /**
+     * Get the decode array
+     */
+    protected float[] getDecode() {
+        return decode;
+    }
+
+    /**
+     * Set the decode array
+     */
+    protected void setDecode(float[] decode) {
+        this.decode = decode;
+    }
+
+//    /**
+//     * get a Java ColorModel consistent with the current color space,
+//     * number of bits per component and decode array
+//     * 
+//     * @param bpc the number of bits per component
+//     */
+//    private ColorModel getColorModel() {
+//        PDFColorSpace cs = getColorSpace();
+//
+//        if (cs instanceof IndexedColor) {
+//            IndexedColor ics = (IndexedColor) cs;
+//
+//            byte[] components = ics.getColorComponents();
+//            int num = ics.getCount();
+//
+//            // process the decode array
+//            if (decode != null) {
+//                byte[] normComps = new byte[components.length];
+//
+//                // move the components array around
+//                for (int i = 0; i < num; i++) {
+//                    byte[] orig = new byte[1];
+//                    orig[0] = (byte) i;
+//
+//                    float[] res = normalize(orig, null, 0);
+//                    int idx = (int) res[0];
+//
+//                    normComps[i * 3] = components[idx * 3];
+//                    normComps[(i * 3) + 1] = components[(idx * 3) + 1];
+//                    normComps[(i * 3) + 2] = components[(idx * 3) + 2];
+//                }
+//
+//                components = normComps;
+//            }
+//
+//            // make sure the size of the components array is 2 ^ numBits
+//            // since if it's not, Java will complain
+//            int correctCount = 1 << getBitsPerComponent();
+//            if (correctCount < num) {
+//                byte[] fewerComps = new byte[correctCount * 3];
+//
+//                System.arraycopy(components, 0, fewerComps, 0, correctCount * 3);
+//
+//                components = fewerComps;
+//                num = correctCount;
+//            }
+//            if (colorKeyMask == null || colorKeyMask.length == 0) {
+//                return new IndexColorModel(getBitsPerComponent(), num, components,
+//                        0, false);
+//            } else {
+//                byte[] aComps = new byte[num * 4];
+//                int idx = 0;
+//                for (int i = 0; i < num; i++) {
+//                    aComps[idx++] = components[(i * 3)];
+//                    aComps[idx++] = components[(i * 3) + 1];
+//                    aComps[idx++] = components[(i * 3) + 2];
+//                    aComps[idx++] = (byte) 0xFF;
+//                }
+//                for (int i = 0; i < colorKeyMask.length; i += 2) {
+//                    for (int j = colorKeyMask[i]; j <= colorKeyMask[i + 1]; j++) {
+//                        aComps[(j * 4) + 3] = 0;    // make transparent
+//                    }
+//                }
+//                return new IndexColorModel(getBitsPerComponent(), num, aComps,
+//                        0, true);
+//            }
+//        } else {
+//            int[] bits = new int[cs.getNumComponents()];
+//            for (int i = 0; i < bits.length; i++) {
+//                bits[i] = getBitsPerComponent();
+//            }
+//
+//            return new DecodeComponentColorModel(cs.getColorSpace(), bits);
+//        }
+//    }
+
+    /**
+     * Normalize an array of values to match the decode array
+     */
+    private float[] normalize(byte[] pixels, float[] normComponents,
+            int normOffset) {
+        if (normComponents == null) {
+            normComponents = new float[normOffset + pixels.length];
+        }
+
+        float[] decodeArray = getDecode();
+
+        for (int i = 0; i < pixels.length; i++) {
+            int val = pixels[i] & 0xff;
+            int pow = ((int) Math.pow(2, getBitsPerComponent())) - 1;
+            float ymin = decodeArray[i * 2];
+            float ymax = decodeArray[(i * 2) + 1];
+
+            normComponents[normOffset + i] =
+                    FunctionType0.interpolate(val, 0, pow, ymin, ymax);
+        }
+
+        return normComponents;
+    }
+
+//    /**
+//     * A wrapper for ComponentColorSpace which normalizes based on the 
+//     * decode array.
+//     */
+//    class DecodeComponentColorModel extends ComponentColorModel {
+//
+//        public DecodeComponentColorModel(ColorSpace cs, int[] bpc) {
+//            super(cs, bpc, false, false, Transparency.OPAQUE,
+//                    DataBuffer.TYPE_BYTE);
+//
+//            if (bpc != null) {
+//                pixel_bits = bpc.length * bpc[0];
+//            }
+//        }
+//
+//        @Override
+//        public SampleModel createCompatibleSampleModel(int width, int height) {
+//            // workaround -- create a MultiPixelPackedSample models for 
+//            // single-sample, less than 8bpp color models
+//            if (getNumComponents() == 1 && getPixelSize() < 8) {
+//                return new MultiPixelPackedSampleModel(getTransferType(),
+//                        width,
+//                        height,
+//                        getPixelSize());
+//            }
+//
+//            return super.createCompatibleSampleModel(width, height);
+//        }
+//
+//        @Override
+//        public boolean isCompatibleRaster(Raster raster) {
+//            if (getNumComponents() == 1 && getPixelSize() < 8) {
+//                SampleModel sm = raster.getSampleModel();
+//
+//                if (sm instanceof MultiPixelPackedSampleModel) {
+//                    return (sm.getSampleSize(0) == getPixelSize());
+//                } else {
+//                    return false;
+//                }
+//            }
+//
+//            return super.isCompatibleRaster(raster);
+//        }
+//
+//        @Override
+//        public float[] getNormalizedComponents(Object pixel,
+//                float[] normComponents, int normOffset) {
+//            if (getDecode() == null) {
+//                return super.getNormalizedComponents(pixel, normComponents,
+//                        normOffset);
+//            }
+//
+//            return normalize((byte[]) pixel, normComponents, normOffset);
+//        }
+//    }
+}

src/com/sun/pdfview/PDFObject.java

@@ -0,0 +1,726 @@
+/*
+ * $Id: PDFObject.java,v 1.8 2009/03/15 20:47:38 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview;
+
+import java.io.IOException;
+import java.lang.ref.SoftReference;
+import java.util.*;
+
+import net.sf.andpdf.pdfviewer.ByteBuffer;
+
+import com.sun.pdfview.decode.PDFDecoder;
+import com.sun.pdfview.decrypt.PDFDecrypter;
+import com.sun.pdfview.decrypt.IdentityDecrypter;
+
+/**
+ * a class encapsulating all the possibilities of content for
+ * an object in a PDF file.
+ * <p>
+ * A PDF object can be a simple type, like a Boolean, a Number,
+ * a String, or the Null value.  It can also be a NAME, which
+ * looks like a string, but is a special type in PDF files, like
+ * "/Name".
+ * <p>
+ * A PDF object can also be complex types, including Array;
+ * Dictionary; Stream, which is a Dictionary plus an array of
+ * bytes; or Indirect, which is a reference to some other
+ * PDF object.  Indirect references will always be dereferenced
+ * by the time any data is returned from one of the methods
+ * in this class.
+ *
+ * @author Mike Wessler
+ */
+public class PDFObject {
+
+    /** an indirect reference*/
+    public static final int INDIRECT = 0;      // PDFXref
+    /** a Boolean */
+    public static final int BOOLEAN = 1;      // Boolean
+    /** a Number, represented as a double */
+    public static final int NUMBER = 2;       // Double
+    /** a String */
+    public static final int STRING = 3;       // String
+    /** a special string, seen in PDF files as /Name */
+    public static final int NAME = 4;         // String
+    /** an array of PDFObjects */
+    public static final int ARRAY = 5;        // Array of PDFObject
+    /** a Hashmap that maps String names to PDFObjects */
+    public static final int DICTIONARY = 6;   // HashMap(String->PDFObject)
+    /** a Stream: a Hashmap with a byte array */
+    public static final int STREAM = 7;        // HashMap + byte[]
+    /** the NULL object (there is only one) */
+    public static final int NULL = 8;         // null
+    /** a special PDF bare word, like R, obj, true, false, etc */
+    public static final int KEYWORD = 9;      // String
+    /**
+     * When a value of {@link #getObjGen objNum} or {@link #getObjGen objGen},
+     * indicates that the object is not top-level, and is embedded in another
+     * object
+     */
+    public static final int OBJ_NUM_EMBEDDED = -2;
+
+    /**
+     * When a value of {@link #getObjGen objNum} or {@link #getObjGen objGen},
+     * indicates that the object is not top-level, and is embedded directly
+     * in the trailer.
+     */
+    public static final int OBJ_NUM_TRAILER = -1;
+
+    /** the NULL PDFObject */
+    public static final PDFObject nullObj = new PDFObject(null, NULL, null);
+    /** the type of this object */
+    private int type;
+    /** the value of this object. It can be a wide number of things, defined by type */
+    private Object value;
+    /** the encoded stream, if this is a STREAM object */
+    private ByteBuffer stream;
+    /** a cached version of the decoded stream */
+    private SoftReference decodedStream;
+    /**
+     * the PDFFile from which this object came, used for
+     * dereferences
+     */
+    private PDFFile owner;
+    /**
+     * a cache of translated data.  This data can be
+     * garbage collected at any time, after which it will
+     * have to be rebuilt.
+     */
+    private SoftReference cache;
+
+    /** @see #getObjNum() */
+    private int objNum = OBJ_NUM_EMBEDDED;
+
+    /** @see #getObjGen() */
+    private int objGen = OBJ_NUM_EMBEDDED;
+
+    /**
+     * create a new simple PDFObject with a type and a value
+     * @param owner the PDFFile in which this object resides, used
+     * for dereferencing.  This may be null.
+     * @param type the type of object
+     * @param value the value.  For DICTIONARY, this is a HashMap.
+     * for ARRAY it's an ArrayList.  For NUMBER, it's a Double.
+     * for BOOLEAN, it's Boolean.TRUE or Boolean.FALSE.  For
+     * everything else, it's a String.
+     */
+    public PDFObject(PDFFile owner, int type, Object value) {
+        this.type = type;
+        if (type == NAME) {
+            value = ((String) value).intern();
+        } else if (type == KEYWORD && value.equals("true")) {
+            this.type = BOOLEAN;
+            value = Boolean.TRUE;
+        } else if (type == KEYWORD && value.equals("false")) {
+            this.type = BOOLEAN;
+            value = Boolean.FALSE;
+        }
+        this.value = value;
+        this.owner = owner;
+    }
+
+    /**
+     * create a new PDFObject that is the closest match to a
+     * given Java object.  Possibilities include Double, String,
+     * PDFObject[], HashMap, Boolean, or PDFParser.Tok,
+     * which should be "true" or "false" to turn into a BOOLEAN.
+     *
+     * @param obj the sample Java object to convert to a PDFObject.
+     * @throws PDFParseException if the object isn't one of the
+     * above examples, and can't be turned into a PDFObject.
+     */
+    public PDFObject(Object obj) throws PDFParseException {
+        this.owner = null;
+        this.value = obj;
+        if ((obj instanceof Double) || (obj instanceof Integer)) {
+            this.type = NUMBER;
+        } else if (obj instanceof String) {
+            this.type = NAME;
+        } else if (obj instanceof PDFObject[]) {
+            this.type = ARRAY;
+        } else if (obj instanceof Object[]) {
+            Object[] srcary = (Object[]) obj;
+            PDFObject[] dstary = new PDFObject[srcary.length];
+            for (int i = 0; i < srcary.length; i++) {
+                dstary[i] = new PDFObject(srcary[i]);
+            }
+            value = dstary;
+            this.type = ARRAY;
+        } else if (obj instanceof HashMap) {
+            this.type = DICTIONARY;
+        } else if (obj instanceof Boolean) {
+            this.type = BOOLEAN;
+        } else if (obj instanceof PDFParser.Tok) {
+            PDFParser.Tok tok = (PDFParser.Tok) obj;
+            if (tok.name.equals("true")) {
+                this.value = Boolean.TRUE;
+                this.type = BOOLEAN;
+            } else if (tok.name.equals("false")) {
+                this.value = Boolean.FALSE;
+                this.type = BOOLEAN;
+            } else {
+                this.value = tok.name;
+                this.type = NAME;
+            }
+        } else {
+            throw new PDFParseException("Bad type for raw PDFObject: " + obj);
+        }
+    }
+
+    /**
+     * create a new PDFObject based on a PDFXref
+     * @param owner the PDFFile from which the PDFXref was drawn
+     * @param xref the PDFXref to turn into a PDFObject
+     */
+    public PDFObject(PDFFile owner, PDFXref xref) {
+        this.type = INDIRECT;
+        this.value = xref;
+        this.owner = owner;
+    }
+
+    /**
+     * get the type of this object.  The object will be
+     * dereferenced, so INDIRECT will never be returned.
+     * @return the type of the object
+     */
+    public int getType() throws IOException {
+        if (type == INDIRECT) {
+            return dereference().getType();
+        }
+
+        return type;
+    }
+
+    /**
+     * set the stream of this object.  It should have been
+     * a DICTIONARY before the call.
+     * @param data the data, as a ByteBuffer.
+     */
+    public void setStream(ByteBuffer data) {
+        this.type = STREAM;
+        this.stream = data;
+    }
+
+    /**
+     * get the value in the cache.  May become null at any time.
+     * @return the cached value, or null if the value has been
+     * garbage collected.
+     */
+    public Object getCache() throws IOException {
+        if (type == INDIRECT) {
+            return dereference().getCache();
+        } else if (cache != null) {
+            return cache.get();
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * set the cached value.  The object may be garbage collected
+     * if no other reference exists to it.
+     * @param obj the object to be cached
+     */
+    public void setCache(Object obj) throws IOException {
+        if (type == INDIRECT) {
+            dereference().setCache(obj);
+            return;
+        } else {
+            cache = new SoftReference<Object>(obj);
+        }
+    }
+
+    /**
+     * get the stream from this object.  Will return null if this
+     * object isn't a STREAM.
+     * @return the stream, or null, if this isn't a STREAM.
+     */
+    public byte[] getStream() throws IOException {
+        if (type == INDIRECT) {
+            return dereference().getStream();
+        } else if (type == STREAM && stream != null) {
+            byte[] data = null;
+
+            synchronized (stream) {
+                // decode
+                ByteBuffer streamBuf = decodeStream();
+                // ByteBuffer streamBuf = stream;
+
+                // First try to use the array with no copying.  This can only
+                // be done if the buffer has a backing array, and is not a slice
+                if (streamBuf.hasArray() && streamBuf.arrayOffset() == 0) {
+                    byte[] ary = streamBuf.array();
+
+                    // make sure there is no extra data in the buffer
+                    if (ary.length == streamBuf.remaining()) {
+                        return ary;
+                    }
+                }
+
+                // Can't use the direct buffer, so copy the data (bad)
+                data = new byte[streamBuf.remaining()];
+                streamBuf.get(data);
+
+                // return the stream to its starting position
+                streamBuf.flip();
+            }
+
+            return data;
+        } else if (type == STRING) {
+            return PDFStringUtil.asBytes(getStringValue());
+        }
+
+        // wrong type
+        return null;
+    }
+
+    /**
+     * get the stream from this object as a byte buffer.  Will return null if 
+     * this object isn't a STREAM.
+     * @return the buffer, or null, if this isn't a STREAM.
+     */
+    public ByteBuffer getStreamBuffer() throws IOException {
+        if (type == INDIRECT) {
+            return dereference().getStreamBuffer();
+        } else if (type == STREAM && stream != null) {
+            synchronized (stream) {
+                ByteBuffer streamBuf = decodeStream();
+                // ByteBuffer streamBuf = stream;
+                return streamBuf.duplicate();
+            }
+        } else if (type == STRING) {
+            String src = getStringValue();
+            return ByteBuffer.wrap(src.getBytes());
+        }
+
+        // wrong type
+        return null;
+    }
+
+    /**
+     * Get the decoded stream value
+     */
+    private ByteBuffer decodeStream() throws IOException {
+        ByteBuffer outStream = null;
+
+        // first try the cache
+        if (decodedStream != null) {
+            outStream = (ByteBuffer) decodedStream.get();
+        }
+
+        // no luck in the cache, do the actual decoding
+        if (outStream == null) {
+            stream.rewind();
+            outStream = PDFDecoder.decodeStream(this, stream);
+            decodedStream = new SoftReference(outStream);
+        }
+
+        return outStream;
+    }
+
+    /**
+     * get the value as an int.  Will return 0 if this object
+     * isn't a NUMBER.
+     */
+    public int getIntValue() throws IOException {
+        if (type == INDIRECT) {
+            return dereference().getIntValue();
+        } else if (type == NUMBER) {
+            return ((Double) value).intValue();
+        }
+
+        // wrong type
+        return 0;
+    }
+
+    /**
+     * get the value as a float.  Will return 0 if this object
+     * isn't a NUMBER
+     */
+    public float getFloatValue() throws IOException {
+        if (type == INDIRECT) {
+            return dereference().getFloatValue();
+        } else if (type == NUMBER) {
+            return ((Double) value).floatValue();
+        }
+
+        // wrong type
+        return 0;
+    }
+
+    /**
+     * get the value as a double.  Will return 0 if this object
+     * isn't a NUMBER.
+     */
+    public double getDoubleValue() throws IOException {
+        if (type == INDIRECT) {
+            return dereference().getDoubleValue();
+        } else if (type == NUMBER) {
+            return ((Double) value).doubleValue();
+        }
+
+        // wrong type
+        return 0;
+    }
+
+    /**
+     * get the value as a String.  Will return null if the object
+     * isn't a STRING, NAME, or KEYWORD.  This method will <b>NOT</b>
+     * convert a NUMBER to a String. If the string is actually
+     * a text string (i.e., may be encoded in UTF16-BE or PdfDocEncoding),
+     * then one should use {@link #getTextStringValue()} or use one
+     * of the {@link PDFStringUtil} methods on the result from this
+     * method. The string value represents exactly the sequence of 8 bit
+     * characters present in the file, decrypted and decoded as appropriate,
+     * into a string containing only 8 bit character values - that is, each
+     * char will be between 0 and 255.
+     */
+    public String getStringValue() throws IOException {
+        if (type == INDIRECT) {
+            return dereference().getStringValue();
+        } else if (type == STRING || type == NAME || type == KEYWORD) {
+            return (String) value;
+        }
+
+        // wrong type
+        return null;
+    }
+
+    /**
+     * Get the value as a text string; i.e., a string encoded in UTF-16BE
+     * or PDFDocEncoding. Simple latin alpha-numeric characters are preserved in
+     * both these encodings.
+     * @return the text string value
+     * @throws IOException
+     */
+    public String getTextStringValue() throws IOException {
+	return PDFStringUtil.asTextString(getStringValue());
+    }
+
+    /**
+     * get the value as a PDFObject[].  If this object is an ARRAY,
+     * will return the array.  Otherwise, will return an array
+     * of one element with this object as the element.
+     */
+    public PDFObject[] getArray() throws IOException {
+        if (type == INDIRECT) {
+            return dereference().getArray();
+        } else if (type == ARRAY) {
+            PDFObject[] ary = (PDFObject[]) value;
+            return ary;
+        } else {
+            PDFObject[] ary = new PDFObject[1];
+            ary[0] = this;
+            return ary;
+        }
+    }
+
+    /**
+     * get the value as a boolean.  Will return false if this
+     * object is not a BOOLEAN
+     */
+    public boolean getBooleanValue() throws IOException {
+        if (type == INDIRECT) {
+            return dereference().getBooleanValue();
+        } else if (type == BOOLEAN) {
+            return value == Boolean.TRUE;
+        }
+
+        // wrong type
+        return false;
+    }
+
+    /**
+     * if this object is an ARRAY, get the PDFObject at some
+     * position in the array.  If this is not an ARRAY, returns
+     * null.
+     */
+    public PDFObject getAt(int idx) throws IOException {
+        if (type == INDIRECT) {
+            return dereference().getAt(idx);
+        } else if (type == ARRAY) {
+            PDFObject[] ary = (PDFObject[]) value;
+            return ary[idx];
+        }
+
+        // wrong type
+        return null;
+    }
+
+    /**
+     * get an Iterator over all the keys in the dictionary.  If
+     * this object is not a DICTIONARY or a STREAM, returns an
+     * Iterator over the empty list.
+     */
+    public Iterator getDictKeys() throws IOException {
+        if (type == INDIRECT) {
+            return dereference().getDictKeys();
+        } else if (type == DICTIONARY || type == STREAM) {
+            return ((HashMap) value).keySet().iterator();
+        }
+
+        // wrong type
+        return new ArrayList().iterator();
+    }
+
+    /**
+     * get the dictionary as a HashMap.  If this isn't a DICTIONARY
+     * or a STREAM, returns null
+     */
+    public HashMap<String,PDFObject> getDictionary() throws IOException {
+        if (type == INDIRECT) {
+            return dereference().getDictionary();
+        } else if (type == DICTIONARY || type == STREAM) {
+            return (HashMap<String,PDFObject>) value;
+        }
+
+        // wrong type
+        return new HashMap<String,PDFObject>();
+    }
+
+    /**
+     * get the value associated with a particular key in the
+     * dictionary.  If this isn't a DICTIONARY or a STREAM,
+     * or there is no such key, returns null.
+     */
+    public PDFObject getDictRef(String key) throws IOException {
+        if (type == INDIRECT) {
+            return dereference().getDictRef(key);
+        } else if (type == DICTIONARY || type == STREAM) {
+            key = key.intern();
+            HashMap h = (HashMap) value;
+            PDFObject obj = (PDFObject) h.get(key.intern());
+            return obj;
+        }
+
+        // wrong type
+        return null;
+    }
+
+    /**
+     * returns true only if this object is a DICTIONARY or a
+     * STREAM, and the "Type" entry in the dictionary matches a
+     * given value.
+     * @param match the expected value for the "Type" key in the
+     * dictionary
+     * @return whether the dictionary is of the expected type
+     */
+    public boolean isDictType(String match) throws IOException {
+        if (type == INDIRECT) {
+            return dereference().isDictType(match);
+        } else if (type != DICTIONARY && type != STREAM) {
+            return false;
+        }
+
+        PDFObject obj = getDictRef("Type");
+        return obj != null && obj.getStringValue().equals(match);
+    }
+
+    public PDFDecrypter getDecrypter() {
+        // PDFObjects without owners are always created as part of
+        // content instructions. Such objects will never have encryption
+        // applied to them, as the stream they're contained by is the
+        // unit of encryption. So, if someone asks for the decrypter for
+        // one of these in-stream objects, no decryption should
+        // ever be applied. This can be seen with inline images.
+        return owner != null ?
+                owner.getDefaultDecrypter() :
+                IdentityDecrypter.getInstance();
+    }
+
+     /**
+     * Set the object identifiers
+     * @param objNum the object number
+     * @param objGen the object generation number
+     */
+    public void setObjectId(int objNum, int objGen) {
+        assert objNum >= OBJ_NUM_TRAILER;
+        assert objGen >= OBJ_NUM_TRAILER;
+        this.objNum = objNum;
+        this.objGen = objGen;
+    }
+
+    /**
+     * Get the object number of this object; a negative value indicates that
+     * the object is not numbered, as it's not a top-level object: if the value
+     * is {@link #OBJ_NUM_EMBEDDED}, it is because it's embedded within
+     * another object. If the value is {@link #OBJ_NUM_TRAILER}, it's because
+     * it's an object from the trailer.
+     * @return the object number, if positive
+     */
+    public int getObjNum() {
+        return objNum;
+    }
+
+    /**
+     * Get the object generation number of this object; a negative value
+     * indicates that the object is not numbered, as it's not a top-level
+     * object: if the value is {@link #OBJ_NUM_EMBEDDED}, it is because it's
+     * embedded within another object. If the value is {@link
+     * #OBJ_NUM_TRAILER}, it's because it's an object from the trailer.
+     * @return the object generation number, if positive
+     */
+    public int getObjGen() {
+        return objGen;
+    }
+
+    /**
+     * return a representation of this PDFObject as a String.
+     * Does NOT dereference anything:  this is the only method
+     * that allows you to distinguish an INDIRECT PDFObject.
+     */
+    @Override
+    public String toString() {
+        try {
+            if (type == INDIRECT) {
+                StringBuffer str = new StringBuffer ();
+                str.append("Indirect to #" + ((PDFXref) value).getID());
+                try {
+                    str.append("\n" + dereference().toString());
+                } catch (Throwable t) {
+                    str.append(t.toString());
+                }
+                return str.toString();
+            } else if (type == BOOLEAN) {
+                return "Boolean: " + (getBooleanValue() ? "true" : "false");
+            } else if (type == NUMBER) {
+                return "Number: " + getDoubleValue();
+            } else if (type == STRING) {
+                return "String: " + getStringValue();
+            } else if (type == NAME) {
+                return "Name: /" + getStringValue();
+            } else if (type == ARRAY) {
+                return "Array, length=" + ((PDFObject[]) value).length;
+            } else if (type == DICTIONARY) {
+                StringBuffer sb = new StringBuffer();
+                PDFObject obj = getDictRef("Type");
+                if (obj != null) {
+                    sb.append(obj.getStringValue());
+                    obj = getDictRef("Subtype");
+                    if (obj == null) {
+                        obj = getDictRef("S");
+                    }
+                    if (obj != null) {
+                        sb.append("/" + obj.getStringValue());
+                    }
+                } else {
+                    sb.append("Untyped");
+                }
+                sb.append(" dictionary. Keys:");
+                HashMap hm = (HashMap) value;
+                Iterator it = hm.entrySet().iterator();
+                Map.Entry entry;
+                while (it.hasNext()) {
+                    entry = (Map.Entry) it.next();
+                    sb.append("\n   " + entry.getKey() + "  " + entry.getValue());
+                }
+                return sb.toString();
+            } else if (type == STREAM) {
+                byte[] st = getStream();
+                if (st == null) {
+                    return "Broken stream";
+                }
+                return "Stream: [[" + new String(st, 0, st.length > 30 ? 30 : st.length) + "]]";
+            } else if (type == NULL) {
+                return "Null";
+            } else if (type == KEYWORD) {
+                return "Keyword: " + getStringValue();
+            /*	    } else if (type==IMAGE) {
+            StringBuffer sb= new StringBuffer();
+            java.awt.Image im= (java.awt.Image)stream;
+            sb.append("Image ("+im.getWidth(null)+"x"+im.getHeight(null)+", with keys:");
+            HashMap hm= (HashMap)value;
+            Iterator it= hm.keySet().iterator();
+            while(it.hasNext()) {
+            sb.append(" "+(String)it.next());
+            }
+            return sb.toString();*/
+            } else {
+                return "Whoops!  big error!  Unknown type";
+            }
+        } catch (IOException ioe) {
+            return "Caught an error: " + ioe;
+        }
+    }
+
+    /**
+     * Make sure that this object is dereferenced.  Use the cache of
+     * an indirect object to cache the dereferenced value, if possible.
+     */
+    public PDFObject dereference() throws IOException {
+        if (type == INDIRECT) {
+            PDFObject obj = null;
+
+            if (cache != null) {
+                obj = (PDFObject) cache.get();
+            }
+
+            if (obj == null || obj.value == null) {
+                if (owner == null) {
+                    System.out.println("Bad seed (owner==null)!  Object=" + this);
+                }
+
+                obj = owner.dereference((PDFXref)value, getDecrypter());
+
+                cache = new SoftReference<PDFObject>(obj);
+            }
+
+            return obj;
+        } else {
+            // not indirect, no need to dereference
+            return this;
+        }
+    }
+
+    /**
+     * Identify whether the object is currently an indirect/cross-reference
+     * @return whether currently indirect
+     */
+    public boolean isIndirect() {
+        return (type == INDIRECT);
+    }
+
+    /** 
+     * Test whether two PDFObject are equal.  Objects are equal IFF they
+     * are the same reference OR they are both indirect objects with the
+     * same id and generation number in their xref
+     */
+    @Override
+    public boolean equals(Object o) {
+        if (super.equals(o)) {
+            // they are the same object
+            return true;
+        } else if (type == INDIRECT && o instanceof PDFObject) {
+            // they are both PDFObjects.  Check type and xref.
+            PDFObject obj = (PDFObject) o;
+
+            if (obj.type == INDIRECT) {
+                PDFXref lXref = (PDFXref) value;
+                PDFXref rXref = (PDFXref) obj.value;
+
+                return ((lXref.getID() == rXref.getID()) &&
+                        (lXref.getGeneration() == rXref.getGeneration()));
+            }
+        }
+
+        return false;
+    }
+}

src/com/sun/pdfview/PDFPage.java

@@ -0,0 +1,849 @@
+/*
+ * $Id: PDFPage.java,v 1.5 2009/02/12 13:53:56 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview;
+
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import net.sf.andpdf.utils.Utils;
+
+
+import android.graphics.Bitmap;
+import android.graphics.Color;
+import android.graphics.Matrix;
+import android.graphics.Paint;
+import android.graphics.Path;
+import android.graphics.PointF;
+import android.graphics.RectF;
+import android.graphics.Bitmap.Config;
+import android.graphics.Paint.Cap;
+import android.graphics.Paint.Join;
+
+/**
+ * A PDFPage encapsulates the parsed commands required to render a
+ * single page from a PDFFile.  The PDFPage is not itself drawable;
+ * instead, create a PDFImage to display something on the screen.
+ * <p>
+ * This file also contains all of the PDFCmd commands that might
+ * be a part of the command stream in a PDFPage.  They probably
+ * should be inner classes of PDFPage instead of separate non-public
+ * classes.
+ *
+ * @author Mike Wessler
+ */
+public class PDFPage {
+
+    /** the array of commands.  The length of this array will always
+     * be greater than or equal to the actual number of commands. */
+    private List<PDFCmd> commands;
+    /** whether this page has been finished.  If true, there will be no
+     * more commands added to the cmds list. */
+    private boolean finished = false;
+    /** the page number used to find this page */
+    private int pageNumber;
+    /** the bounding box of the page, in page coordinates */
+    private RectF bbox;
+    /** the rotation of this page, in degrees */
+    private int rotation;
+    /** a map from image info (width, height, clip) to a soft reference to the
+    rendered image */
+    private Cache cache;
+    /** a map from image info to weak references to parsers that are active */
+    private Map<ImageInfo,WeakReference> renderers;
+
+    // TODO [FHe]: just a quick hack
+    private static int parsedCommands;
+    public static int getParsedCommands() { return parsedCommands;}
+    private static int lastRenderedCommand;
+    public static int getLastRenderedCommand() { return lastRenderedCommand;}
+    
+    /**
+     * create a PDFPage with dimensions in bbox and rotation.
+     */
+    public PDFPage(RectF bbox, int rotation) {
+        this(-1, bbox, rotation, null);
+    }
+
+    /**
+     * create a PDFPage with dimensions in bbox and rotation.
+     */
+    public PDFPage(int pageNumber, RectF bbox, int rotation,
+            Cache cache) {
+        this.pageNumber = pageNumber;
+        this.cache = cache;
+
+        if (bbox == null) {
+            bbox = new RectF(0, 0, 1, 1);
+        }
+
+        if (rotation < 0) {
+            rotation += 360;
+        }
+
+        this.rotation = rotation;
+
+        if (rotation == 90 || rotation == 270) {
+            bbox = new RectF(bbox.left, bbox.top,
+                    bbox.height(), bbox.width());
+        }
+
+        this.bbox = bbox;
+
+        // initialize the cache of images and parsers
+        renderers = Collections.synchronizedMap(new HashMap<ImageInfo,WeakReference>());
+
+        // initialize the list of commands
+        commands = Collections.synchronizedList(new ArrayList<PDFCmd>(250));
+    }
+
+    /**
+     * Get the width and height of this image in the correct aspect ratio.
+     * The image returned will have at least one of the width and
+     * height values identical to those requested.  The other
+     * dimension may be smaller, so as to keep the aspect ratio
+     * the same as in the original page.
+     *
+     * @param width the maximum width of the image
+     * @param height the maximum height of the image
+     * @param clip the region in <b>page space</b> of the page to
+     * display.  It may be null, in which the page's defined crop box
+     * will be used.
+     */
+    public PointF getUnstretchedSize(int width, int height,
+            RectF clip) {
+        if (clip == null) {
+            clip = bbox;
+        } else {
+            if (getRotation() == 90 ||
+                    getRotation() == 270) {
+                clip = new RectF(clip.left, clip.top,
+                        clip.height(), clip.width());
+            }
+        }
+
+        float ratio = clip.height() / clip.width();
+        float askratio = height / width;
+        if (askratio > ratio) {
+            // asked for something too high
+            height = (int) (width * ratio + 0.5);
+        } else {
+            // asked for something too wide
+            width = (int) (height / ratio + 0.5);
+        }
+
+
+        return new PointF(width, height);
+    }
+
+    /**
+     * Get an image producer which can be used to draw the image
+     * represented by this PDFPage.  The ImageProducer is guaranteed to
+     * stay in sync with the PDFPage as commands are added to it.
+     *
+     * The image will contain the section of the page specified by the clip,
+     * scaled to fit in the area given by width and height.
+     *
+     * @param width the width of the image to be produced
+     * @param height the height of the image to be produced
+     * @param clip the region in <b>page space</b> of the entire page to
+     *        display
+     * @param observer an image observer who will be notified when the
+     *        image changes, or null
+     * @return an Image that contains the PDF data
+     */
+    public Bitmap getImage(int width, int height, RectF clip) {
+        return getImage(width, height, clip, true, false);
+    }
+
+    /**
+     * Get an image producer which can be used to draw the image
+     * represented by this PDFPage.  The ImageProducer is guaranteed to
+     * stay in sync with the PDFPage as commands are added to it.
+     *
+     * The image will contain the section of the page specified by the clip,
+     * scaled to fit in the area given by width and height.
+     *
+     * @param width the width of the image to be produced
+     * @param height the height of the image to be produced
+     * @param clip the region in <b>page space</b> of the entire page to
+     *             display
+     * @param observer an image observer who will be notified when the
+     *        image changes, or null
+     * @param drawbg if true, put a white background on the image.  If not,
+     *        draw no color (alpha 0) for the background.
+     * @param wait if true, do not return until this image is fully rendered.
+     * @return an Image that contains the PDF data
+     */
+    public Bitmap getImage(int width, int height, RectF clip,
+            boolean drawbg, boolean wait) {
+        // see if we already have this image
+        Bitmap image = null;
+        PDFRenderer renderer = null;
+        ImageInfo info = new ImageInfo(width, height, clip, Color.WHITE);
+
+//        if (cache != null) {
+//            image = cache.getImage(this, info);
+//            renderer = cache.getImageRenderer(this, info);
+//        }
+//
+        // not in the cache, so create it
+        if (image == null) {
+            if (drawbg) {
+                info.bgColor = Color.WHITE;
+            }
+
+            image = Bitmap.createBitmap(width, height, Config.RGB_565);
+            renderer = new PDFRenderer(this, info, image);
+
+//            if (cache != null) {
+//                cache.addImage(this, info, image, renderer);
+//            }
+
+            renderers.put(info, new WeakReference<PDFRenderer>(renderer));
+        }
+
+        // the renderer may be null if we are getting this image from the
+        // cache and rendering has completed.
+        if (renderer != null) {
+//            if (observer != null) {
+//                renderer.addObserver(observer);
+//            }
+
+            if (!renderer.isFinished()) {
+                renderer.go(wait);
+            }
+        }
+
+        // return the image
+        return image;
+    }
+
+    /**
+     * get the page number used to lookup this page
+     * @return the page number
+     */
+    public int getPageNumber() {
+        return pageNumber;
+    }
+
+    /**
+     * get the aspect ratio of the correctly oriented page.
+     * @return the width/height aspect ratio of the page
+     */
+    public float getAspectRatio() {
+        return getWidth() / getHeight();
+    }
+
+    /**
+     * get the bounding box of the page, before any rotation.
+     */
+    public RectF getBBox() {
+        return bbox;
+    }
+
+    /**
+     * get the width of this page, after rotation
+     */
+    public float getWidth() {
+        return (float) bbox.width();
+    }
+
+    /**
+     * get the height of this page, after rotation
+     */
+    public float getHeight() {
+        return (float) bbox.height();
+    }
+
+    /**
+     * get the rotation of this image
+     */
+    public int getRotation() {
+        return rotation;
+    }
+
+    /**
+     * Get the initial transform to map from a specified clip rectangle in
+     * pdf coordinates to an image of the specfied width and
+     * height in device coordinates
+     *
+     * @param width the width of the image
+     * @param height the height of the image
+     * @param clip the desired clip rectangle (in PDF space) or null to use
+     *             the page's bounding box
+     */
+    public Matrix getInitialTransform(int width, int height, RectF clip) {
+        Matrix mat = new Matrix();
+        switch (getRotation()) {
+            case 0:
+            	Utils.setMatValues(mat, 1, 0, 0, -1, 0, height);
+                break;
+            case 90:
+            	Utils.setMatValues(mat, 0, 1, 1, 0, 0, 0);
+                break;
+            case 180:
+            	Utils.setMatValues(mat, -1, 0, 0, 1, width, 0);
+                break;
+            case 270:
+            	Utils.setMatValues(mat, 0, -1, -1, 0, width, height);
+                break;
+        }
+
+        if (clip == null) {
+            clip = getBBox();
+        } else if (getRotation() == 90 || getRotation() == 270) {
+            int tmp = width;
+            width = height;
+            height = tmp;
+        }
+
+        // now scale the image to be the size of the clip
+        float scaleX = width / clip.width();
+        float scaleY = height / clip.height();
+        mat.preScale(scaleX, scaleY);
+
+        // create a transform that moves the top left corner of the clip region
+        // (minX, minY) to (0,0) in the image
+//        mat.setTranslate(-clip.top, -clip.left);
+        mat.preTranslate(-clip.top, -clip.left);
+
+        return mat;
+    }
+
+	/**
+     * get the current number of commands for this page
+     */
+    public int getCommandCount() {
+        return commands.size();
+    }
+
+    /**
+     * get the command at a given index
+     */
+    public PDFCmd getCommand(int index) {
+    	lastRenderedCommand = index; 
+        return commands.get(index);
+    }
+
+    /**
+     * get all the commands in the current page
+     */
+    public List<PDFCmd> getCommands() {
+        return commands;
+    }
+
+    /**
+     * get all the commands in the current page starting at the given index
+     */
+    public List getCommands(int startIndex) {
+        return getCommands(startIndex, getCommandCount());
+    }
+
+    /*
+     * get the commands in the page within the given start and end indices
+     */
+    public List getCommands(int startIndex, int endIndex) {
+        return commands.subList(startIndex, endIndex);
+    }
+
+    /**
+     * Add a single command to the page list.
+     */
+    public void addCommand(PDFCmd cmd) {
+        synchronized (commands) {
+            commands.add(cmd);
+        }
+        
+        // notify any outstanding images
+        updateImages();
+    }
+
+    /**
+     * add a collection of commands to the page list.  This is probably
+     * invoked as the result of an XObject 'do' command, or through a
+     * type 3 font.
+     */
+    public void addCommands(PDFPage page) {
+        addCommands(page, null);
+    }
+
+    /**
+     * add a collection of commands to the page list.  This is probably
+     * invoked as the result of an XObject 'do' command, or through a
+     * type 3 font.
+     * @param page the source of other commands.  It MUST be finished.
+     * @param extra a transform to perform before adding the commands.
+     * If null, no extra transform will be added.
+     */
+    public void addCommands(PDFPage page, Matrix extra) {
+        synchronized (commands) {
+            addPush();
+            if (extra != null) {
+                addXform(extra);
+            }
+            //addXform(page.getTransform());
+            commands.addAll(page.getCommands());
+            addPop();
+        }
+
+        // notify any outstanding images
+        updateImages();
+    }
+
+    /**
+     * Clear all commands off the current page
+     */
+    public void clearCommands() {
+        synchronized (commands) {
+            commands.clear();
+        }
+
+        // notify any outstanding images
+        updateImages();
+    }
+
+    /**
+     * get whether parsing for this PDFPage has been completed and all
+     * commands are in place.
+     */
+    public boolean isFinished() {
+        return finished;
+    }
+
+    /**
+     * wait for finish
+     */
+    public synchronized void waitForFinish() throws InterruptedException {
+        if (!finished) {
+            wait();
+        }
+    }
+
+    /**
+     * Stop the rendering of a particular image on this page
+     */
+    public void stop(int width, int height, RectF clip) {
+        ImageInfo info = new ImageInfo(width, height, clip);
+
+        synchronized (renderers) {
+            // find our renderer
+            WeakReference rendererRef = renderers.get(info);
+            if (rendererRef != null) {
+                PDFRenderer renderer = (PDFRenderer) rendererRef.get();
+                if (renderer != null) {
+                    // stop it
+                    renderer.stop();
+                }
+            }
+        }
+    }
+
+    /**
+     * The entire page is done.  This must only be invoked once.  All
+     * observers will be notified.
+     */
+    public synchronized void finish() {
+        //	System.out.println("Page finished!");
+        finished = true;
+        notifyAll();
+
+        // notify any outstanding images
+        updateImages();
+    }
+
+    /** push the graphics state */
+    public void addPush() {
+        addCommand(new PDFPushCmd());
+    }
+
+    /** pop the graphics state */
+    public void addPop() {
+        addCommand(new PDFPopCmd());
+    }
+
+    /** concatenate a transform to the graphics state */
+    public void addXform(Matrix mat) {
+        //	PDFXformCmd xc= lastXformCmd();
+        //	xc.at.concatenate(at);
+        addCommand(new PDFXformCmd(new Matrix(mat)));
+    }
+
+    /**
+     * set the stroke width
+     * @param w the width of the stroke
+     */
+    public void addStrokeWidth(float w) {
+        PDFChangeStrokeCmd sc = new PDFChangeStrokeCmd();
+//        if (w == 0) {
+//            w = 0.1f;
+//        }
+        sc.setWidth(w);
+        addCommand(sc);
+    }
+
+    /**
+     * set the end cap style
+     * @param capstyle the cap style:  0 = BUTT, 1 = ROUND, 2 = SQUARE
+     */
+    public void addEndCap(int capstyle) {
+        PDFChangeStrokeCmd sc = new PDFChangeStrokeCmd();
+
+        Cap cap = Paint.Cap.BUTT;
+        switch (capstyle) {
+            case 0:
+                cap = Paint.Cap.BUTT;
+                break;
+            case 1:
+                cap = Paint.Cap.ROUND;
+                break;
+            case 2:
+                cap = Paint.Cap.SQUARE;
+                break;
+        }
+        sc.setEndCap(cap);
+
+        addCommand(sc);
+    }
+
+    /**
+     * set the line join style
+     * @param joinstyle the join style: 0 = MITER, 1 = ROUND, 2 = BEVEL
+     */
+    public void addLineJoin(int joinstyle) {
+        PDFChangeStrokeCmd sc = new PDFChangeStrokeCmd();
+
+        Join join = Paint.Join.MITER;
+        switch (joinstyle) {
+            case 0:
+                join = Paint.Join.MITER;
+                break;
+            case 1:
+                join = Paint.Join.ROUND;
+                break;
+            case 2:
+                join = Paint.Join.BEVEL;
+                break;
+        }
+        sc.setLineJoin(join);
+
+        addCommand(sc);
+    }
+
+    /**
+     * set the miter limit
+     */
+    public void addMiterLimit(float limit) {
+        PDFChangeStrokeCmd sc = new PDFChangeStrokeCmd();
+
+        sc.setMiterLimit(limit);
+
+        addCommand(sc);
+    }
+
+    /**
+     * set the dash style
+     * @param dashary the array of on-off lengths
+     * @param phase offset of the array at the start of the line drawing
+     */
+    public void addDash(float[] dashary, float phase) {
+        PDFChangeStrokeCmd sc = new PDFChangeStrokeCmd();
+
+        sc.setDash(dashary, phase);
+
+        addCommand(sc);
+    }
+
+    /**
+     * set the current path
+     * @param path the path
+     * @param style the style: PDFShapeCmd.STROKE, PDFShapeCmd.FILL,
+     * PDFShapeCmd.BOTH, PDFShapeCmd.CLIP, or some combination.
+     */
+    public void addPath(Path path, int style) {
+        addCommand(new PDFShapeCmd(path, style));
+    }
+
+    /**
+     * set the fill paint
+     */
+    public void addFillPaint(PDFPaint p) {
+        addCommand(new PDFFillPaintCmd(p));
+    }
+
+    /** set the stroke paint */
+    public void addStrokePaint(PDFPaint p) {
+        addCommand(new PDFStrokePaintCmd(p));
+    }
+
+    /**
+     * set the fill alpha
+     */
+    public void addFillAlpha(float a) {
+        addCommand(new PDFFillAlphaCmd(a));
+    }
+
+    /** set the stroke alpha */
+    public void addStrokeAlpha(float a) {
+        addCommand(new PDFStrokeAlphaCmd(a));
+    }
+
+    /**
+     * draw an image
+     * @param image the image to draw
+     */
+    public void addImage(PDFImage image) {
+        addCommand(new PDFImageCmd(image));
+    }
+
+    /**
+     * Notify all images we know about that a command has been added
+     */
+    public void updateImages() {
+        parsedCommands = commands.size();
+        for (Iterator i = renderers.values().iterator(); i.hasNext();) {
+            WeakReference ref = (WeakReference) i.next();
+            PDFRenderer renderer = (PDFRenderer) ref.get();
+
+            if (renderer != null) {
+                if (renderer.getStatus() == Watchable.NEEDS_DATA) {
+                    // there are watchers.  Set the state to paused and
+                    // let the watcher decide when to start.
+                    renderer.setStatus(Watchable.PAUSED);
+                }
+            }
+        }
+    }
+}
+
+/**
+ * draw an image
+ */
+class PDFImageCmd extends PDFCmd {
+
+    PDFImage image;
+
+    public PDFImageCmd(PDFImage image) {
+        this.image = image;
+    }
+
+    public RectF execute(PDFRenderer state) {
+        return state.drawImage(image);
+    }
+}
+
+/**
+ * set the fill paint
+ */
+class PDFFillPaintCmd extends PDFCmd {
+
+    PDFPaint p;
+
+    public PDFFillPaintCmd(PDFPaint p) {
+        this.p = p;
+    }
+
+    public RectF execute(PDFRenderer state) {
+        state.setFillPaint(p);
+        return null;
+    }
+}
+
+/**
+ * set the stroke paint
+ */
+class PDFStrokePaintCmd extends PDFCmd {
+
+    PDFPaint p;
+
+    public PDFStrokePaintCmd(PDFPaint p) {
+        this.p = p;
+    }
+
+    public RectF execute(PDFRenderer state) {
+        state.setStrokePaint(p);
+        return null;
+    }
+}
+
+/**
+ * set the fill paint
+ */
+class PDFFillAlphaCmd extends PDFCmd {
+
+    float a;
+
+    public PDFFillAlphaCmd(float a) {
+        this.a = a;
+    }
+
+    public RectF execute(PDFRenderer state) {
+    	// TODO [FHe]: fill alpha
+//        state.setFillAlpha(a);
+        return null;
+    }
+}
+
+/**
+ * set the stroke paint
+ */
+class PDFStrokeAlphaCmd extends PDFCmd {
+
+    float a;
+
+    public PDFStrokeAlphaCmd(float a) {
+        this.a = a;
+    }
+
+    public RectF execute(PDFRenderer state) {
+    	// TODO [FHe]: stroke alpha
+//        state.setStrokeAlpha(a);
+        return null;
+    }
+}
+
+/**
+ * push the graphics state
+ */
+class PDFPushCmd extends PDFCmd {
+
+    public RectF execute(PDFRenderer state) {
+        state.push();
+        return null;
+    }
+}
+
+/**
+ * pop the graphics state
+ */
+class PDFPopCmd extends PDFCmd {
+
+    public RectF execute(PDFRenderer state) {
+        state.pop();
+        return null;
+    }
+}
+
+/**
+ * concatenate a transform to the graphics state
+ */
+class PDFXformCmd extends PDFCmd {
+
+    Matrix mat;
+
+    public PDFXformCmd(Matrix mat) {
+        if (mat == null) {
+            throw new RuntimeException("Null transform in PDFXformCmd");
+        }
+        this.mat = mat;
+    }
+
+    public RectF execute(PDFRenderer state) {
+        state.transform(mat);
+        return null;
+    }
+
+    public String toString(PDFRenderer state) {
+        return "PDFXformCmd: " + mat;
+    }
+
+    @Override
+    public String getDetails() {
+        StringBuffer buf = new StringBuffer();
+        buf.append("PDFXformCommand: \n");
+        buf.append(mat.toString());
+
+        return buf.toString();
+    }
+}
+
+/**
+ * change the stroke style
+ */
+class PDFChangeStrokeCmd extends PDFCmd {
+
+    float w, limit, phase;
+    Cap cap;
+    Join join;
+    float[] ary;
+
+    public PDFChangeStrokeCmd() {
+        this.w = PDFRenderer.NOWIDTH;
+        this.cap = PDFRenderer.NOCAP;
+        this.join = PDFRenderer.NOJOIN;
+        this.limit = PDFRenderer.NOLIMIT;
+        this.ary = PDFRenderer.NODASH;
+        this.phase = PDFRenderer.NOPHASE;
+    }
+
+    /**
+     * set the width of the stroke. Rendering needs to account for a minimum
+     * stroke width in creating the output.
+     *
+     * @param w float
+     */
+    public void setWidth(float w) {
+        this.w = w;
+    }
+
+    public void setEndCap(Cap cap) {
+        this.cap = cap;
+    }
+
+    public void setLineJoin(Join join) {
+        this.join = join;
+    }
+
+    public void setMiterLimit(float limit) {
+        this.limit = limit;
+    }
+
+    public void setDash(float[] ary, float phase) {
+        if (ary != null) {
+            // make sure no pairs start with 0, since having no opaque
+            // region doesn't make any sense.
+            for (int i = 0; i < ary.length - 1; i += 2) {
+                if (ary[i] == 0) {
+                    /* Give a very small value, since 0 messes java up */
+                    ary[i] = 0.00001f;
+                    break;
+                }
+            }
+        }
+        this.ary = ary;
+        this.phase = phase;
+    }
+
+    public RectF execute(PDFRenderer state) {
+        state.setStrokeParts(w, cap, join, limit, ary, phase);
+        return null;
+    }
+
+    public String toString(PDFRenderer state) {
+        return "STROKE: w=" + w + " cap=" + cap + " join=" + join + " limit=" + limit +
+                " ary=" + ary + " phase=" + phase;
+    }
+}
+

src/com/sun/pdfview/PDFPaint.java

@@ -0,0 +1,92 @@
+/*
+ * $Id: PDFPaint.java,v 1.4 2009/01/16 16:26:09 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview;
+
+
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.Path;
+import android.graphics.RectF;
+import android.graphics.Paint.Style;
+
+/**
+ * PDFPaint is some kind of shader that knows how to fill a path.
+ * At the moment, only a solid color is implemented, but gradients
+ * and textures should be possible, too.
+ * @author Mike Wessler
+ */
+public class PDFPaint {
+
+    private Paint mainPaint;
+    public static boolean s_doAntiAlias = false;
+
+    /**
+     * create a new PDFPaint based on a solid color
+     */
+    protected PDFPaint(int p) {
+        this.mainPaint = new Paint();
+        mainPaint.setColor(p);
+        mainPaint.setAntiAlias(s_doAntiAlias);
+    }
+
+    /**
+     * get the PDFPaint representing a solid color
+     */
+    public static PDFPaint getColorPaint(int c) {
+    	PDFPaint result = new PDFPaint(c); 
+//        result.getPaint().setStyle(Style.FILL);
+        result.getPaint().setStyle(Style.STROKE);
+        return result;
+    }
+
+    /**
+     * get the PDFPaint representing a generic paint
+     */
+    public static PDFPaint getPaint(int p) {
+    	PDFPaint result = new PDFPaint(p); 
+//        result.getPaint().setStyle(Style.STROKE);
+        result.getPaint().setStyle(Style.FILL);
+        return result;
+    }
+
+    /**
+     * fill a path with the paint, and record the dirty area.
+     * @param state the current graphics state
+     * @param g the graphics into which to draw
+     * @param s the path to fill
+     */
+    public RectF fill(PDFRenderer state, Canvas g, Path s) {
+        g.drawPath(s, mainPaint);
+
+        RectF bounds = new RectF();
+        RectF result = new RectF();
+        s.computeBounds(bounds, false);
+        g.getMatrix().mapRect(result, bounds);
+        return bounds;
+    }
+
+    /**
+     * get the primary color associated with this PDFPaint.
+     */
+    public Paint getPaint() {
+        return mainPaint;
+    }
+}

src/com/sun/pdfview/PDFParseException.java

@@ -0,0 +1,41 @@
+/*
+ * $Id: PDFParseException.java,v 1.4 2009/03/12 12:25:25 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview;
+
+import java.io.IOException;
+
+/**
+ * an exception class for recording parse errors in the PDF file
+ * @author Mike Wessler
+ */
+public class PDFParseException extends IOException {
+
+    public PDFParseException(String msg) {
+        super(msg);
+    }
+
+    public PDFParseException(String msg, Throwable cause) {
+	this(msg);
+        initCause(cause);
+    }
+
+    
+}

src/com/sun/pdfview/PDFParser.java

@@ -0,0 +1,1465 @@
+/*
+ * $Id: PDFParser.java,v 1.11 2009/03/15 20:47:38 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Stack;
+
+import net.sf.andpdf.pdfviewer.ByteBuffer;
+import net.sf.andpdf.utils.Utils;
+
+import android.graphics.Matrix;
+import android.graphics.Path;
+import android.graphics.RectF;
+import android.graphics.Path.Direction;
+import android.graphics.Path.FillType;
+import android.os.Debug;
+
+import com.sun.pdfview.colorspace.PDFColorSpace;
+import com.sun.pdfview.decode.PDFDecoder;
+import com.sun.pdfview.font.PDFFont;
+
+
+/**
+ * PDFParser is the class that parses a PDF content stream and
+ * produces PDFCmds for a PDFPage.  You should never ever see it run:
+ * it gets created by a PDFPage only if needed, and may even run in
+ * its own thread.
+ *
+ * @author Mike Wessler
+ */
+public class PDFParser extends BaseWatchable {
+    /** emit a file of DCT stream data. */
+    public final static String  DEBUG_DCTDECODE_DATA = "debugdctdecode";
+
+	static final boolean RELEASE = true;
+
+	static final int PDF_CMDS_RANGE1_MIN = 1;
+	static final int PDF_CMDS_RANGE1_MAX = Integer.MAX_VALUE;
+	static final int PDF_CMDS_RANGE2_MIN = 0;
+	static final int PDF_CMDS_RANGE2_MAX = 0;
+	
+	private int cmdCnt;
+
+    // ---- parsing variables
+
+    private Stack<Object> stack;          // stack of Object
+    private Stack<ParserState> parserStates;    // stack of RenderState
+    // the current render state
+    private ParserState state;
+    private Path path;
+    private int clip;
+    private int loc;
+    private boolean resend = false;
+    private Tok tok;
+    private boolean catchexceptions;   // Indicates state of BX...EX
+    /** a weak reference to the page we render into.  For the page
+     * to remain available, some other code must retain a strong reference to it.
+     */
+    private WeakReference pageRef;
+    /** the actual command, for use within a singe iteration.  Note that
+     * this must be released at the end of each iteration to assure the
+     * page can be collected if not in use
+     */
+    private PDFPage cmds;
+    // ---- result variables
+    byte[] stream;
+    HashMap<String,PDFObject> resources;
+//    public static int debuglevel = 4000;
+// TODO [FHe]: changed for debugging
+public static int debuglevel = -1;
+
+    public static void debug(String msg, int level) {
+        if (level > debuglevel) {
+            System.out.println(escape(msg));
+        }
+    }
+
+    public static String escape(String msg) {
+        StringBuffer sb = new StringBuffer();
+        for (int i = 0; i < msg.length(); i++) {
+            char c = msg.charAt(i);
+            if (c != '\n' && (c < 32 || c >= 127)) {
+                c = '?';
+            }
+            sb.append(c);
+        }
+        return sb.toString();
+    }
+
+    public static void setDebugLevel(int level) {
+        debuglevel = level;
+    }
+
+    /**
+     * Don't call this constructor directly.  Instead, use
+     * PDFFile.getPage(int pagenum) to get a PDFPage.  There should
+     * never be any reason for a user to create, access, or hold
+     * on to a PDFParser.
+     */
+    public PDFParser(PDFPage cmds, byte[] stream, 
+            HashMap<String,PDFObject> resources) {
+        super();
+
+        this.pageRef = new WeakReference<PDFPage>(cmds);
+        this.resources = resources;
+        if (resources == null) {
+            this.resources = new HashMap<String,PDFObject>();
+        }
+
+        this.stream = stream;
+        this.cmdCnt = 0;
+    }
+
+
+    /////////////////////////////////////////////////////////////////
+    //  B E G I N   R E A D E R   S E C T I O N
+    /////////////////////////////////////////////////////////////////
+    /**
+     * a token from a PDF Stream
+     */
+    class Tok {
+
+        /** begin bracket &lt; */
+        public static final int BRKB = 11;
+        /** end bracket &gt; */
+        public static final int BRKE = 10;
+        /** begin array [ */
+        public static final int ARYB = 9;
+        /** end array ] */
+        public static final int ARYE = 8;
+        /** String (, readString looks for trailing ) */
+        public static final int STR = 7;
+        /** begin brace { */
+        public static final int BRCB = 5;
+        /** end brace } */
+        public static final int BRCE = 4;
+        /** number */
+        public static final int NUM = 3;
+        /** keyword */
+        public static final int CMD = 2;
+        /** name (begins with /) */
+        public static final int NAME = 1;
+        /** unknown token */
+        public static final int UNK = 0;
+        /** end of stream */
+        public static final int EOF = -1;
+        /** the string value of a STR, NAME, or CMD token */
+        public String name;
+        /** the value of a NUM token */
+        public double value;
+        /** the type of the token */
+        public int type;
+
+        /** a printable representation of the token */
+        @Override
+        public String toString() {
+            if (type == NUM) {
+                return "NUM: " + value;
+            } else if (type == CMD) {
+                return "CMD: " + name;
+            } else if (type == UNK) {
+                return "UNK";
+            } else if (type == EOF) {
+                return "EOF";
+            } else if (type == NAME) {
+                return "NAME: " + name;
+            } else if (type == CMD) {
+                return "CMD: " + name;
+            } else if (type == STR) {
+                return "STR: (" + name;
+            } else if (type == ARYB) {
+                return "ARY [";
+            } else if (type == ARYE) {
+                return "ARY ]";
+            } else {
+                return "some kind of brace (" + type + ")";
+            }
+        }
+    }
+
+    /**
+     * put the current token back so that it is returned again by
+     * nextToken().
+     */
+    private void throwback() {
+        resend = true;
+    }
+
+    /**
+     * get the next token.
+     * TODO: this creates a new token each time.  Is this strictly
+     * necessary?
+     */
+    private Tok nextToken() {
+        if (resend) {
+            resend = false;
+            return tok;
+        }
+        tok = new Tok();
+        // skip whitespace
+        while (loc < stream.length && PDFFile.isWhiteSpace(stream[loc])) {
+            loc++;
+        }
+        if (loc >= stream.length) {
+            tok.type = Tok.EOF;
+            return tok;
+        }
+        int c = stream[loc++];
+        // examine the character:
+        while (c == '%') {
+            // skip comments
+            StringBuffer comment = new StringBuffer();
+            while (loc < stream.length && c != '\n') {
+                comment.append((char) c);
+                c = stream[loc++];
+            }
+            if (loc < stream.length) {
+                c = stream[loc++];      // eat the newline
+                if (c == '\r') {
+                    c = stream[loc++];  // eat a following return
+                }
+            }
+            if (!RELEASE)
+            	debug("Read comment: " + comment.toString(), -1);
+        }
+
+        if (c == '[') {
+            tok.type = Tok.ARYB;
+        } else if (c == ']') {
+            tok.type = Tok.ARYE;
+        } else if (c == '(') {
+            // read a string
+            tok.type = Tok.STR;
+            tok.name = readString();
+        } else if (c == '{') {
+            tok.type = Tok.BRCB;
+        } else if (c == '}') {
+            tok.type = Tok.BRCE;
+        } else if (c == '<' && stream[loc++] == '<') {
+            tok.type = Tok.BRKB;
+        } else if (c == '>' && stream[loc++] == '>') {
+            tok.type = Tok.BRKE;
+        } else if (c == '<') {
+            loc--;
+            tok.type = Tok.STR;
+            tok.name = readByteArray();
+        } else if (c == '/') {
+            tok.type = Tok.NAME;
+            tok.name = readName();
+        } else if (c == '.' || c == '-' || (c >= '0' && c <= '9')) {
+            loc--;
+            tok.type = Tok.NUM;
+            tok.value = readNum();
+        } else if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '\'' || c == '"') {
+            loc--;
+            tok.type = Tok.CMD;
+            tok.name = readName();
+        } else {
+            System.out.println("Encountered character: " + c + " (" + (char) c + ")");
+            tok.type = Tok.UNK;
+        }
+        if (!RELEASE)
+        	debug("Read token: " + tok, -1);
+        return tok;
+    }
+
+    /**
+     * read a name (sequence of non-PDF-delimiting characters) from the
+     * stream.
+     */
+    private String readName() {
+        int start = loc;
+        while (loc < stream.length && 
+                PDFFile.isRegularCharacter(stream[loc])) {
+            loc++;
+        }
+        return new String(stream, start, loc - start);
+    }
+
+    /**
+     * read a floating point number from the stream
+     */
+    private double readNum() {
+        int c = stream[loc++];
+        boolean neg = c == '-';
+        boolean sawdot = c == '.';
+        double dotmult = sawdot ? 0.1 : 1;
+        double value = (c >= '0' && c <= '9') ? c - '0' : 0;
+        while (true) {
+            c = stream[loc++];
+            if (c == '.') {
+                if (sawdot) {
+                    loc--;
+                    break;
+                }
+                sawdot = true;
+                dotmult = 0.1;
+            } else if (c >= '0' && c <= '9') {
+                int val = c - '0';
+                if (sawdot) {
+                    value += val * dotmult;
+                    dotmult *= 0.1;
+                } else {
+                    value = value * 10 + val;
+                }
+            } else {
+                loc--;
+                break;
+            }
+        }
+        if (neg) {
+            value = -value;
+        }
+        return value;
+    }
+
+    /**
+     * <p>read a String from the stream.  Strings begin with a '('
+     * character, which has already been read, and end with a balanced ')'
+     * character.  A '\' character starts an escape sequence of up
+     * to three octal digits.</p>
+     *
+     * <p>Parenthesis must be enclosed by a balanced set of parenthesis,
+     * so a string may enclose balanced parenthesis.</p>
+     *
+     * @return the string with escape sequences replaced with their
+     * values
+     */
+    private String readString() {
+        int start = loc;
+        int parenLevel = 0;
+        StringBuffer sb = new StringBuffer();
+        while (loc < stream.length) {
+            int c = stream[loc++];
+            if (c == ')') {
+                if (parenLevel-- == 0) {
+                    break;
+                }
+            } else if (c == '(') {
+                parenLevel++;
+            } else if (c == '\\') {
+                // escape sequences
+                c = stream[loc++];
+                if (c >= '0' && c <= '9') {
+                    int count = 0;
+                    int val = 0;
+                    while (c >= '0' && c <= '9' && count < 3) {
+                        val = val * 8 + c - '0';
+                        c = stream[loc++];
+                        count++;
+                    }
+                    loc--;
+                    c = val;
+                } else if (c == 'n') {
+                    c = '\n';
+                } else if (c == 'r') {
+                    c = '\r';
+                } else if (c == 't') {
+                    c = '\t';
+                } else if (c == 'b') {
+                    c = '\b';
+                } else if (c == 'f') {
+                    c = '\f';
+                } else if (c == '\\') {
+                    c = '\\';
+                } else if (c == '(') {
+                    c = '(';
+                } else if (c == ')') {
+                    c = ')';
+                }
+            }
+            sb.append((char) c);
+        }
+        return sb.toString();
+    }
+
+    /**
+     * read a byte array from the stream.  Byte arrays begin with a '<'
+     * character, which has already been read, and end with a '>'
+     * character.  Each byte in the array is made up of two hex characters,
+     * the first being the high-order bit.
+     *
+     * We translate the byte arrays into char arrays by combining two bytes
+     * into a character, and then translate the character array into a string.
+     * [JK FIXME this is probably a really bad idea!]
+     *
+     * @return the byte array
+     */
+    private String readByteArray() {
+        StringBuffer buf = new StringBuffer();
+
+        int count = 0;
+        char w = (char) 0;
+
+        // read individual bytes and format into a character array
+        while ((loc < stream.length) && (stream[loc] != '>')) {
+            char c = (char) stream[loc];
+            byte b = (byte) 0;
+
+            if (c >= '0' && c <= '9') {
+                b = (byte) (c - '0');
+            } else if (c >= 'a' && c <= 'f') {
+                b = (byte) (10 + (c - 'a'));
+            } else if (c >= 'A' && c <= 'F') {
+                b = (byte) (10 + (c - 'A'));
+            } else {
+                loc++;
+                continue;
+            }
+
+            // calculate where in the current byte this character goes
+            int offset = 1 - (count % 2);
+            w |= (0xf & b) << (offset * 4);
+
+            // increment to the next char if we've written four bytes
+            if (offset == 0) {
+                buf.append(w);
+                w = (char) 0;
+            }
+
+            count++;
+            loc++;
+        }
+
+        // ignore trailing '>'
+        loc++;
+
+        return buf.toString();
+    }
+
+    /////////////////////////////////////////////////////////////////
+    //  B E G I N   P A R S E R   S E C T I O N
+    /////////////////////////////////////////////////////////////////
+    /**
+     * Called to prepare for some iterations
+     */
+    @Override
+    public void setup() {
+        stack = new Stack<Object>();
+        parserStates = new Stack<ParserState>();
+        state = new ParserState();
+        path = new Path();
+        loc = 0;
+        clip = 0;
+
+        //initialize the ParserState
+        // TODO: check GRAY or RGB
+        state.fillCS =
+                PDFColorSpace.getColorSpace(PDFColorSpace.COLORSPACE_GRAY);
+        state.strokeCS =
+                PDFColorSpace.getColorSpace(PDFColorSpace.COLORSPACE_GRAY);
+        state.textFormat = new PDFTextFormat();
+
+    // HexDump.printData(stream);
+    // System.out.println(dumpStream());
+    }
+
+    /**
+     * parse the stream.  commands are added to the PDFPage initialized
+     * in the constructor as they are encountered.
+     * <p>
+     * Page numbers in comments refer to the Adobe PDF specification.<br>
+     * commands are listed in PDF spec 32000-1:2008 in Table A.1
+     *
+     * @return <ul><li>Watchable.RUNNING when there are commands to be processed
+     *             <li>Watchable.COMPLETED when the page is done and all
+     *                 the commands have been processed
+     *             <li>Watchable.STOPPED if the page we are rendering into is
+     *                 no longer available
+     *         </ul> 
+     */
+    public int iterate() throws Exception {
+        // make sure the page is still available, and create the reference
+        // to it for use within this iteration
+        cmds = (PDFPage) pageRef.get();
+        if (cmds == null) {
+            System.out.println("Page gone.  Stopping");
+            return Watchable.STOPPED;
+        }
+
+        Object obj = parseObject();
+
+        // if there's nothing left to parse, we're done
+        if (obj == null) {
+            return Watchable.COMPLETED;
+        }
+
+        if (obj instanceof Tok) {
+            // it's a command.  figure out what to do.
+            // (if not, the token will be "pushed" onto the stack)
+            String cmd = ((Tok) obj).name;
+            if (!RELEASE) {
+                cmdCnt += 1;
+                if (!(   
+                	   ((cmdCnt >= PDF_CMDS_RANGE1_MIN) &&(cmdCnt <= PDF_CMDS_RANGE1_MAX))
+                	|| ((cmdCnt >= PDF_CMDS_RANGE2_MIN) &&(cmdCnt <= PDF_CMDS_RANGE2_MAX))
+                )) {
+                    stack.setSize(0);
+                	return Watchable.RUNNING;
+                }
+            	debug("Command ["+cmdCnt+"]: " + cmd + " (stack size is " + stack.size() +":"+dump(stack)+ ")", 0);
+            }
+            if (cmd.equals("q")) {
+                // push the parser state
+                parserStates.push((ParserState) state.clone());
+
+                // push graphics state
+                cmds.addPush();
+            } else if (cmd.equals("Q")) {
+                processQCmd();
+            } else if (cmd.equals("cm")) {
+                // set transform to array of values
+                float[] elts = popFloat(6);
+                Matrix xform = new Matrix();
+                Utils.setMatValues(xform, elts);
+                cmds.addXform(xform);
+            } else if (cmd.equals("w")) {
+                // set stroke width
+                cmds.addStrokeWidth(popFloat());
+            } else if (cmd.equals("J")) {
+                // set end cap style
+                cmds.addEndCap(popInt());
+            } else if (cmd.equals("j")) {
+                // set line join style
+                cmds.addLineJoin(popInt());
+            } else if (cmd.equals("M")) {
+                // set miter limit
+                cmds.addMiterLimit(popInt());
+            } else if (cmd.equals("d")) {
+                // set dash style and phase
+                float phase = popFloat();
+                float[] dashary = popFloatArray();
+                cmds.addDash(dashary, phase);
+            } else if (cmd.equals("ri")) {
+                // TODO: do something with rendering intent (page 197)
+            } else if (cmd.equals("i")) {
+                popFloat();
+            // TODO: do something with flatness tolerance
+            } else if (cmd.equals("gs")) {
+                // set graphics state to values in a named dictionary
+                setGSState(popString());
+            } else if (cmd.equals("m")) {
+                // path move to
+                float y = popFloat();
+                float x = popFloat();
+                path.moveTo(x, y);
+            } else if (cmd.equals("l")) {
+                // path line to
+                float y = popFloat();
+                float x = popFloat();
+                path.lineTo(x, y);
+            } else if (cmd.equals("c")) {
+                // path curve to
+                float a[] = popFloat(6);
+                path.cubicTo(a[0], a[1], a[2], a[3], a[4], a[5]);
+            } else if (cmd.equals("v")) {
+                // path curve; first control point= start
+                float a[] = popFloat(4);
+                // TODO: remember last point
+                path.quadTo(a[0], a[1], a[2], a[3]);
+//                PointF cp = path.getCurrentPoint();
+//                path.curveTo((float) cp.getX(), (float) cp.getY(),
+//                        a[0], a[1], a[2], a[3]);
+            } else if (cmd.equals("y")) {
+                // path curve; last control point= end
+                float a[] = popFloat(4);
+                path.cubicTo(a[0], a[1], a[2], a[3], a[2], a[3]);
+            } else if (cmd.equals("h")) {
+                // path close
+                path.close();
+            } else if (cmd.equals("re")) {
+                // path add rectangle
+                float a[] = popFloat(4);
+                path.moveTo(a[0], a[1]);
+                path.lineTo(a[0] + a[2], a[1]);
+                path.lineTo(a[0] + a[2], a[1] + a[3]);
+                path.lineTo(a[0], a[1] + a[3]);
+                path.close();
+            } else if (cmd.equals("S")) {
+                // stroke the path
+                cmds.addPath(path, PDFShapeCmd.STROKE | clip);
+                clip = 0;
+                path = new Path();
+            } else if (cmd.equals("s")) {
+                // close and stroke the path
+                path.close();
+                cmds.addPath(path, PDFShapeCmd.STROKE | clip);
+                clip = 0;
+                path = new Path();
+            } else if (cmd.equals("f") || cmd.equals("F")) {
+                // fill the path (close/not close identical)
+                cmds.addPath(path, PDFShapeCmd.FILL | clip);
+                clip = 0;
+                path = new Path();
+            } else if (cmd.equals("f*")) {
+                // fill the path using even/odd rule
+                path.setFillType(FillType.EVEN_ODD);
+                cmds.addPath(path, PDFShapeCmd.FILL | clip);
+                clip = 0;
+                path = new Path();
+            } else if (cmd.equals("B")) {
+                // fill and stroke the path
+                cmds.addPath(path, PDFShapeCmd.BOTH | clip);
+                clip = 0;
+                path = new Path();
+            } else if (cmd.equals("B*")) {
+                // fill path using even/odd rule and stroke it
+                path.setFillType(FillType.EVEN_ODD);
+                cmds.addPath(path, PDFShapeCmd.BOTH | clip);
+                clip = 0;
+                path = new Path();
+            } else if (cmd.equals("b")) {
+                // close the path, then fill and stroke it
+                path.close();
+                cmds.addPath(path, PDFShapeCmd.BOTH | clip);
+                clip = 0;
+                path = new Path();
+            } else if (cmd.equals("b*")) {
+                // close path, fill using even/odd rule, then stroke it
+                path.close();
+                path.setFillType(FillType.EVEN_ODD);
+                cmds.addPath(path, PDFShapeCmd.BOTH | clip);
+                clip = 0;
+                path = new Path();
+            } else if (cmd.equals("n")) {
+                // clip with the path and discard it
+                if (clip != 0) {
+                    cmds.addPath(path, clip);
+                }
+                clip = 0;
+                path = new Path();
+            } else if (cmd.equals("W")) {
+                // mark this path for clipping!
+                clip = PDFShapeCmd.CLIP;
+            } else if (cmd.equals("W*")) {
+                // mark this path using even/odd rule for clipping
+                path.setFillType(FillType.EVEN_ODD);
+                clip = PDFShapeCmd.CLIP;
+            } else if (cmd.equals("sh")) {
+                // shade a region that is defined by the shader itself.
+                // shading the current space from a dictionary
+                // should only be used for limited-dimension shadings
+                String gdictname = popString();
+                // set up the pen to do a gradient fill according
+                // to the dictionary
+                PDFObject shobj = findResource(gdictname, "Shading");
+                doShader(shobj);
+
+
+            } else if (cmd.equals("CS")) {
+            	// TODO [FHe]: ignoring color space
+                // set the stroke color space
+                state.strokeCS = parseColorSpace(new PDFObject(stack.pop()));
+            } else if (cmd.equals("cs")) {
+            	// TODO [FHe]: ignoring color space
+                // set the fill color space
+                state.fillCS = parseColorSpace(new PDFObject(stack.pop()));
+            } else if (cmd.equals("SC")) {
+            	// TODO [FHe]: stroke color
+                // set the stroke color
+                int n = state.strokeCS.getNumComponents();
+                cmds.addStrokePaint(state.strokeCS.getPaint(popFloat(n)));
+            } else if (cmd.equals("SCN")) {
+            	// TODO [FHe]: stroke pattern
+//                if (state.strokeCS instanceof PatternSpace) {
+//                    cmds.addFillPaint(doPattern((PatternSpace) state.strokeCS));
+//                } else {
+//                    int n = state.strokeCS.getNumComponents();
+//                    cmds.addStrokePaint(state.strokeCS.getPaint(popFloat(n)));
+//                }
+            	int n = state.strokeCS.getNumComponents();
+                cmds.addStrokePaint(state.strokeCS.getPaint(popFloat(n)));
+            } else if (cmd.equals("sc")) {
+            	// TODO [FHe]: stroke color
+                // set the fill color
+                int n = state.fillCS.getNumComponents();
+                cmds.addFillPaint(state.fillCS.getFillPaint(popFloat(n)));
+            } else if (cmd.equals("scn")) {
+            	// TODO [FHe]: stroke pattern
+//                if (state.fillCS instanceof PatternSpace) {
+//                    cmds.addFillPaint(doPattern((PatternSpace) state.fillCS));
+//                } else {
+//                    int n = state.fillCS.getNumComponents();
+//                    cmds.addFillPaint(state.fillCS.getPaint(popFloat(n)));
+//                }
+	              int n = state.fillCS.getNumComponents();
+	              cmds.addFillPaint(state.fillCS.getFillPaint(popFloat(n)));
+            } else if (cmd.equals("G")) {
+                // set the stroke color to a Gray value
+                state.strokeCS = PDFColorSpace.getColorSpace(PDFColorSpace.COLORSPACE_GRAY);
+                cmds.addStrokePaint(state.strokeCS.getPaint(popFloat(1)));
+            } else if (cmd.equals("g")) {
+                // set the fill color to a Gray value
+                state.fillCS = PDFColorSpace.getColorSpace(PDFColorSpace.COLORSPACE_GRAY);
+                cmds.addFillPaint(state.fillCS.getFillPaint(popFloat(1)));
+            } else if (cmd.equals("RG")) {
+                // set the stroke color to an RGB value
+                state.strokeCS = PDFColorSpace.getColorSpace(PDFColorSpace.COLORSPACE_RGB);
+                cmds.addStrokePaint(state.strokeCS.getPaint(popFloat(3)));
+            } else if (cmd.equals("rg")) {
+                // set the fill color to an RGB value
+                state.fillCS = PDFColorSpace.getColorSpace(PDFColorSpace.COLORSPACE_RGB);
+                cmds.addFillPaint(state.fillCS.getFillPaint(popFloat(3)));
+            } else if (cmd.equals("K")) {
+            	// TODO [FHe]: ignoring cmyk
+//                // set the stroke color to a CMYK value
+//                state.strokeCS =
+//                        PDFColorSpace.getColorSpace(PDFColorSpace.COLORSPACE_CMYK);
+//                cmds.addStrokePaint(state.strokeCS.getPaint(popFloat(4)));
+            } else if (cmd.equals("k")) {
+            	// TODO [FHe]: ignoring cmyk
+//                // set the fill color to a CMYK value
+//                state.fillCS =
+//                        PDFColorSpace.getColorSpace(PDFColorSpace.COLORSPACE_CMYK);
+//                cmds.addFillPaint(state.fillCS.getPaint(popFloat(4)));
+            } else if (cmd.equals("Do")) {
+                // make a do call on the referenced object
+                PDFObject xobj = findResource(popString(), "XObject");
+                doXObject(xobj);
+            } else if (cmd.equals("BT")) {
+                processBTCmd();
+            } else if (cmd.equals("ET")) {
+                // end of text.  noop
+                state.textFormat.end();
+            } else if (cmd.equals("Tc")) {
+                // set character spacing
+                state.textFormat.setCharSpacing(popFloat());
+            } else if (cmd.equals("Tw")) {
+                // set word spacing
+                state.textFormat.setWordSpacing(popFloat());
+            } else if (cmd.equals("Tz")) {
+                // set horizontal scaling
+                state.textFormat.setHorizontalScale(popFloat());
+            } else if (cmd.equals("TL")) {
+                // set leading
+                state.textFormat.setLeading(popFloat());
+            } else if (cmd.equals("Tf")) {
+                // set text font
+                float sz = popFloat();
+                String fontref = popString();
+                state.textFormat.setFont(getFontFrom(fontref), sz);
+            } else if (cmd.equals("Tr")) {
+                // set text rendering mode
+                state.textFormat.setMode(popInt());
+            } else if (cmd.equals("Ts")) {
+                // set text rise
+                state.textFormat.setRise(popFloat());
+            } else if (cmd.equals("Td")) {
+                // set text matrix location
+                float y = popFloat();
+                float x = popFloat();
+                state.textFormat.carriageReturn(x, y);
+            } else if (cmd.equals("TD")) {
+                // set leading and matrix:  -y TL x y Td
+                float y = popFloat();
+                float x = popFloat();
+                state.textFormat.setLeading(-y);
+                state.textFormat.carriageReturn(x, y);
+            } else if (cmd.equals("Tm")) {
+                // set text matrix
+                state.textFormat.setMatrix(popFloat(6));
+            } else if (cmd.equals("T*")) {
+                // go to next line
+                state.textFormat.carriageReturn();
+            } else if (cmd.equals("Tj")) {
+                // show text
+                state.textFormat.doText(cmds, popString());
+            } else if (cmd.equals("\'")) {
+                // next line and show text:  T* string Tj
+                state.textFormat.carriageReturn();
+                state.textFormat.doText(cmds, popString());
+            } else if (cmd.equals("\"")) {
+                // draw string on new line with char & word spacing:
+                // aw Tw ac Tc string '
+                String string = popString();
+                float ac = popFloat();
+                float aw = popFloat();
+                state.textFormat.setWordSpacing(aw);
+                state.textFormat.setCharSpacing(ac);
+                state.textFormat.doText(cmds, string);
+            } else if (cmd.equals("TJ")) {
+                // show kerned string
+                state.textFormat.doText(cmds, popArray());
+            } else if (cmd.equals("BI")) {
+                // parse inline image
+                parseInlineImage();
+            } else if (cmd.equals("BX")) {
+                catchexceptions = true;     // ignore errors
+            } else if (cmd.equals("EX")) {
+                catchexceptions = false;    // stop ignoring errors
+            } else if (cmd.equals("MP")) {
+                // mark point (role= mark role name)
+                popString();
+            } else if (cmd.equals("DP")) {
+                // mark point with dictionary (role, ref)
+                // ref is either inline dict or name in "Properties" rsrc
+                Object ref = stack.pop();
+                popString();
+            } else if (cmd.equals("BMC")) {
+                // begin marked content (role)
+                popString();
+            } else if (cmd.equals("BDC")) {
+                // begin marked content with dict (role, ref)
+                // ref is either inline dict or name in "Properties" rsrc
+                Object ref = stack.pop();
+                popString();
+            } else if (cmd.equals("EMC")) {
+                // end marked content
+            } else if (cmd.equals("d0")) {
+                // character width in type3 fonts
+                popFloat(2);
+            } else if (cmd.equals("d1")) {
+                // character width in type3 fonts
+                popFloat(6);
+            } else if (cmd.equals("QBT")) {// 'Q' & 'BT' mushed together!
+                processQCmd();
+                processBTCmd();
+            } else {
+                if (catchexceptions) {
+                    if (!RELEASE)
+                    	debug("**** WARNING: Unknown command: " + cmd + " **************************", 10);
+                } else {
+                    throw new PDFParseException("Unknown command: " + cmd);
+                }
+            }
+            if (stack.size() != 0) {
+                if (!RELEASE)
+                	debug("**** WARNING! Stack not zero! (cmd=" + cmd + ", size=" + stack.size() + ") *************************", 4);
+                stack.setSize(0);
+            }
+        } else {
+            stack.push(obj);
+        }
+
+        // release or reference to the page object, so that it can be
+        // gc'd if it is no longer in use
+        cmds = null;
+
+        return Watchable.RUNNING;
+    }
+
+    /**
+     * abstracted command processing for Q command. Used directly and as
+     * part of processing of mushed QBT command.
+     */
+    private void processQCmd() {
+        // pop graphics state ('Q')
+        cmds.addPop();
+        // pop the parser state
+        state = (ParserState) parserStates.pop();
+    }
+
+    /**
+     * abstracted command processing for BT command. Used directly and as
+     * part of processing of mushed QBT command.
+     */
+    private void processBTCmd() {
+        // begin text block:  reset everything.
+        state.textFormat.reset();
+    }
+
+    /**
+     * Cleanup when iteration is done
+     */
+    @Override
+    public void cleanup() {
+        state.textFormat.flush();
+        cmds.finish();
+
+        stack = null;
+        parserStates = null;
+        state = null;
+        path = null;
+        cmds = null;
+    }
+    boolean errorwritten = false;
+
+    public void dumpStreamToError() {
+        if (errorwritten) {
+            return;
+        }
+        errorwritten = true;
+        try {
+            File oops = File.createTempFile("PDFError", ".err");
+            FileOutputStream fos = new FileOutputStream(oops);
+            fos.write(stream);
+            fos.close();
+        } catch (IOException ioe) { /* Do nothing */ }
+        ;
+    }
+
+    public String dumpStream() {
+        return escape(new String(stream).replace('\r', '\n'));
+    }
+
+    /**
+     * take a byte array and write a temporary file with it's data.
+     * This is intended to capture data for analysis, like after decoders.
+     *
+     * @param ary
+     * @param name
+     */
+    public static void emitDataFile (byte [] ary, String name) {
+        FileOutputStream ostr;
+
+        try {
+            File file = File.createTempFile ("DateFile", name);
+            ostr = new FileOutputStream (file);
+            System.out.println ("Write: " + file.getPath ());
+            ostr.write (ary);
+            ostr.close ();
+        } catch (IOException ex) {
+            // ignore
+        }
+    }
+
+    /////////////////////////////////////////////////////////////////
+    //  H E L P E R S
+    /////////////////////////////////////////////////////////////////
+    /**
+     * get a property from a named dictionary in the resources of this
+     * content stream.
+     * @param name the name of the property in the dictionary
+     * @param inDict the name of the dictionary in the resources
+     * @return the value of the property in the dictionary
+     */
+    private PDFObject findResource(String name, String inDict)
+            throws IOException {
+        if (inDict != null) {
+            PDFObject in = resources.get(inDict);
+            if (in == null || in.getType() != PDFObject.DICTIONARY) {
+                throw new PDFParseException("No dictionary called " + inDict + " found in the resources");
+            }
+            return in.getDictRef(name);
+        } else {
+            return resources.get(name);
+        }
+    }
+
+    /**
+     * Insert a PDF object into the command stream.  The object must
+     * either be an Image or a Form, which is a set of PDF commands
+     * in a stream.
+     * @param obj the object to insert, an Image or a Form.
+     */
+    private void doXObject(PDFObject obj) throws IOException {
+        String type = obj.getDictRef("Subtype").getStringValue();
+        if (type == null) {
+            type = obj.getDictRef ("S").getStringValue ();
+        }
+        if (type.equals("Image")) {
+            doImage(obj);
+        } else if (type.equals("Form")) {
+            doForm(obj);
+        } else {
+            throw new PDFParseException("Unknown XObject subtype: " + type);
+        }
+    }
+
+    /**
+     * Parse image data into a Java BufferedImage and add the image
+     * command to the page.
+     * @param obj contains the image data, and a dictionary describing
+     * the width, height and color space of the image.
+     */
+    private void doImage(PDFObject obj) throws IOException {
+        cmds.addImage(PDFImage.createImage(obj, resources));
+    }
+
+    /**
+     * Inject a stream of PDF commands onto the page.  Optimized to cache
+     * a parsed stream of commands, so that each Form object only needs
+     * to be parsed once.
+     * @param obj a stream containing the PDF commands, a transformation
+     * matrix, bounding box, and resources.
+     */
+    private void doForm(PDFObject obj) throws IOException {
+        // check to see if we've already parsed this sucker
+        PDFPage formCmds = (PDFPage) obj.getCache();
+        if (formCmds == null) {
+            // rats.  parse it.
+            Matrix at;
+            RectF bbox;
+            PDFObject matrix = obj.getDictRef("Matrix");
+            if (matrix == null) {
+                at = new Matrix();
+            } else {
+                float elts[] = new float[6];
+                for (int i = 0; i < elts.length; i++) {
+                    elts[i] = ((PDFObject) matrix.getAt(i)).getFloatValue();
+                }
+                at = new Matrix();
+                Utils.setMatValues(at, elts);
+            }
+            PDFObject bobj = obj.getDictRef("BBox");
+            bbox = new RectF(bobj.getAt(0).getFloatValue(),
+                    bobj.getAt(1).getFloatValue(),
+                    bobj.getAt(2).getFloatValue(),
+                    bobj.getAt(3).getFloatValue());
+            formCmds = new PDFPage(bbox, 0);
+            formCmds.addXform(at);
+
+            HashMap<String,PDFObject> r = new HashMap<String,PDFObject>(resources);
+            PDFObject rsrc = obj.getDictRef("Resources");
+            if (rsrc != null) {
+                r.putAll(rsrc.getDictionary());
+            }
+
+            PDFParser form = new PDFParser(formCmds, obj.getStream(), r);
+            form.go(true);
+
+            obj.setCache(formCmds);
+        }
+        cmds.addPush();
+        cmds.addCommands(formCmds);
+        cmds.addPop();
+    }
+
+//    /**
+//     * Set the values into a PatternSpace
+//     */
+//    private PDFPaint doPattern(PatternSpace patternSpace) throws IOException {
+//        float[] components = null;
+//
+//        String patternName = popString();
+//        PDFObject pattern = findResource(patternName, "Pattern");
+//
+//        if (pattern == null) {
+//            throw new PDFParseException("Unknown pattern : " + patternName);
+//        }
+//
+//        if (stack.size() > 0) {
+//            components = popFloat(stack.size());
+//        }
+//
+//        return patternSpace.getPaint(pattern, components, resources);
+//    }
+
+    /**
+     * Parse the next object out of the PDF stream.  This could be a
+     * Double, a String, a HashMap (dictionary), Object[] array, or
+     * a Tok containing a PDF command.
+     */
+    private Object parseObject() throws PDFParseException {
+        Tok t = nextToken();
+        if (t.type == Tok.NUM) {
+            return new Double(tok.value);
+        } else if (t.type == Tok.STR) {
+            return tok.name;
+        } else if (t.type == Tok.NAME) {
+            return tok.name;
+        } else if (t.type == Tok.BRKB) {
+            HashMap<String,PDFObject> hm = new HashMap<String,PDFObject>();
+            String name = null;
+            Object obj;
+            while ((obj = parseObject()) != null) {
+                if (name == null) {
+                    name = (String) obj;
+                } else {
+                    hm.put(name, new PDFObject(obj));
+                    name = null;
+                }
+            }
+            if (tok.type != Tok.BRKE) {
+                throw new PDFParseException("Inline dict should have ended with '>>'");
+            }
+            return hm;
+        } else if (t.type == Tok.ARYB) {
+            // build an array
+            ArrayList<Object> ary = new ArrayList<Object>();
+            Object obj;
+            while ((obj = parseObject()) != null) {
+                ary.add(obj);
+            }
+            if (tok.type != Tok.ARYE) {
+                throw new PDFParseException("Expected ']'");
+            }
+            return ary.toArray();
+        } else if (t.type == Tok.CMD) {
+            return t;
+        }
+        if (!RELEASE)
+        	debug("**** WARNING! parseObject unknown token! (t.type=" + t.type + ") *************************", 4);
+        return null;
+    }
+
+    /**
+     * Parse an inline image.  An inline image starts with BI (already
+     * read, contains a dictionary until ID, and then image data until
+     * EI.
+     */
+    private void parseInlineImage() throws IOException {
+        // build dictionary until ID, then read image until EI
+        HashMap<String,PDFObject> hm = new HashMap<String,PDFObject>();
+        while (true) {
+            Tok t = nextToken();
+            if (t.type == Tok.CMD && t.name.equals("ID")) {
+                break;
+            }
+            // it should be a name;
+            String name = t.name;
+            if (!RELEASE)
+            	debug("ParseInlineImage, token: " + name, 1000);
+            if (name.equals("BPC")) {
+                name = "BitsPerComponent";
+            } else if (name.equals("CS")) {
+                name = "ColorSpace";
+            } else if (name.equals("D")) {
+                name = "Decode";
+            } else if (name.equals("DP")) {
+                name = "DecodeParms";
+            } else if (name.equals("F")) {
+                name = "Filter";
+            } else if (name.equals("H")) {
+                name = "Height";
+            } else if (name.equals("IM")) {
+                name = "ImageMask";
+            } else if (name.equals("W")) {
+                name = "Width";
+            } else if (name.equals("I")) {
+                name = "Interpolate";
+            }
+            Object vobj = parseObject();
+            hm.put(name, new PDFObject(vobj));
+        }
+        if (stream[loc] == '\r') {
+            loc++;
+        }
+        if (stream[loc] == '\n' || stream[loc] == ' ') {
+            loc++;
+        }
+
+        
+        PDFObject imObj = (PDFObject) hm.get("ImageMask");
+        if (imObj != null && imObj.getBooleanValue()) {    	
+        	// [PATCHED by michal.busta@gmail.com] - default value according to PDF spec. is [0, 1]
+        	// there is no need to swap array - PDF image should handle this values 
+            Double[] decode = {new Double(0), new Double(1)};
+            
+            PDFObject decodeObj = (PDFObject) hm.get("Decode");
+            if (decodeObj != null) {
+                decode[0] = new Double(decodeObj.getAt(0).getDoubleValue());
+                decode[1] = new Double(decodeObj.getAt(1).getDoubleValue());
+            }
+
+            hm.put("Decode", new PDFObject(decode));
+        }
+
+        PDFObject obj = new PDFObject(null, PDFObject.DICTIONARY, hm);
+        int dstart = loc;
+
+        // now skip data until a whitespace followed by EI
+        while (!PDFFile.isWhiteSpace(stream[loc]) ||
+                stream[loc + 1] != 'E' ||
+                stream[loc + 2] != 'I') {
+            loc++;
+        }
+
+        // data runs from dstart to loc
+        byte[] data = new byte[loc - dstart];
+        System.arraycopy(stream, dstart, data, 0, loc - dstart);
+        obj.setStream(ByteBuffer.wrap(data));
+        loc += 3;
+        doImage(obj);
+    }
+
+    /**
+     * build a shader from a dictionary.
+     */
+    private void doShader(PDFObject shaderObj) throws IOException {
+    	// TODO [FHe]: shader
+//        PDFShader shader = PDFShader.getShader(shaderObj, resources);
+//
+//        cmds.addPush();
+//
+//        RectF bbox = shader.getBBox();
+//        if (bbox != null) {
+//            cmds.addFillPaint(shader.getPaint());
+//            Path tmp = new Path();
+//            tmp.addRect(bbox, Direction.CW);
+//            cmds.addPath(tmp, PDFShapeCmd.FILL);
+//        }
+//
+//        cmds.addPop();
+    }
+
+    /**
+     * get a PDFFont from the resources, given the resource name of the
+     * font.
+     *
+     * @param fontref the resource key for the font
+     */
+    private PDFFont getFontFrom(String fontref) throws IOException {
+        PDFObject obj = findResource(fontref, "Font");
+        return PDFFont.getFont(obj, resources);
+    }
+
+    /**
+     * add graphics state commands contained within a dictionary.
+     * @param name the resource name of the graphics state dictionary
+     */
+    private void setGSState(String name) throws IOException {
+        // obj must be a string that is a key to the "ExtGState" dict
+        PDFObject gsobj = findResource(name, "ExtGState");
+        // get LW, LC, LJ, Font, SM, CA, ML, D, RI, FL, BM, ca
+        // out of the reference, which is a dictionary
+        PDFObject d;
+        if ((d = gsobj.getDictRef("LW")) != null) {
+            cmds.addStrokeWidth(d.getFloatValue());
+        }
+        if ((d = gsobj.getDictRef("LC")) != null) {
+            cmds.addEndCap(d.getIntValue());
+        }
+        if ((d = gsobj.getDictRef("LJ")) != null) {
+            cmds.addLineJoin(d.getIntValue());
+        }
+        if ((d = gsobj.getDictRef("Font")) != null) {
+            state.textFormat.setFont(getFontFrom(d.getAt(0).getStringValue()),
+                    d.getAt(1).getFloatValue());
+        }
+        if ((d = gsobj.getDictRef("ML")) != null) {
+            cmds.addMiterLimit(d.getFloatValue());
+        }
+        if ((d = gsobj.getDictRef("D")) != null) {
+            PDFObject pdash[] = d.getAt(0).getArray();
+            float dash[] = new float[pdash.length];
+            for (int i = 0; i < pdash.length; i++) {
+                dash[i] = pdash[i].getFloatValue();
+            }
+            cmds.addDash(dash, d.getAt(1).getFloatValue());
+        }
+        if ((d = gsobj.getDictRef("CA")) != null) {
+            cmds.addStrokeAlpha(d.getFloatValue());
+        }
+        if ((d = gsobj.getDictRef("ca")) != null) {
+            cmds.addFillAlpha(d.getFloatValue());
+        }
+    // others: BM=blend mode
+    }
+
+    /**
+     * generate a PDFColorSpace description based on a PDFObject.  The
+     * object could be a standard name, or the name of a resource in
+     * the ColorSpace dictionary, or a color space name with a defining
+     * dictionary or stream.
+     */
+    private PDFColorSpace parseColorSpace(PDFObject csobj) throws IOException {
+        if (csobj == null) {
+            return state.fillCS;
+        }
+
+        return PDFColorSpace.getColorSpace(csobj, resources);
+    }
+
+    /**
+     * pop a single float value off the stack.
+     * @return the float value of the top of the stack
+     * @throws PDFParseException if the value on the top of the stack
+     * isn't a number
+     */
+    private float popFloat() throws PDFParseException {
+        Object obj = stack.pop();
+        if (obj instanceof Double) {
+            return ((Double) obj).floatValue();
+        } else {
+            throw new PDFParseException("Expected a number here.");
+        }
+    }
+
+    /**
+     * pop an array of float values off the stack.  This is equivalent
+     * to filling an array from end to front by popping values off the
+     * stack.
+     * @param count the number of numbers to pop off the stack
+     * @return an array of length <tt>count</tt>
+     * @throws PDFParseException if any of the values popped off the
+     * stack are not numbers.
+     */
+    private float[] popFloat(int count) throws PDFParseException {
+        float[] ary = new float[count];
+        for (int i = count - 1; i >= 0; i--) {
+            ary[i] = popFloat();
+        }
+        return ary;
+    }
+
+    /**
+     * pop a single integer value off the stack.
+     * @return the integer value of the top of the stack
+     * @throws PDFParseException if the top of the stack isn't a number.
+     */
+    private int popInt() throws PDFParseException {
+        Object obj = stack.pop();
+        if (obj instanceof Double) {
+            return ((Double) obj).intValue();
+        } else {
+            throw new PDFParseException("Expected a number here.");
+        }
+    }
+
+    /**
+     * pop an array of integer values off the stack.  This is equivalent
+     * to filling an array from end to front by popping values off the
+     * stack.
+     * @param count the number of numbers to pop off the stack
+     * @return an array of length <tt>count</tt>
+     * @throws PDFParseException if any of the values popped off the
+     * stack are not numbers.
+     */
+    private float[] popFloatArray() throws PDFParseException {
+        Object obj = stack.pop();
+        if (!(obj instanceof Object[])) {
+            throw new PDFParseException("Expected an [array] here.");
+        }
+        Object[] source = (Object[]) obj;
+        float[] ary = new float[source.length];
+        for (int i = 0; i < ary.length; i++) {
+            if (source[i] instanceof Double) {
+                ary[i] = ((Double) source[i]).floatValue();
+            } else {
+                throw new PDFParseException("This array doesn't consist only of floats.");
+            }
+        }
+        return ary;
+    }
+
+    /**
+     * pop a String off the stack.
+     * @return the String from the top of the stack
+     * @throws PDFParseException if the top of the stack is not a NAME
+     * or STR.
+     */
+    private String popString() throws PDFParseException {
+        Object obj = stack.pop();
+        if (!(obj instanceof String)) {
+            throw new PDFParseException("Expected string here: " + obj.toString());
+        } else {
+            return (String) obj;
+        }
+    }
+
+    /**
+     * pop a PDFObject off the stack.
+     * @return the PDFObject from the top of the stack
+     * @throws PDFParseException if the top of the stack does not contain
+     * a PDFObject.
+     */
+    private PDFObject popObject() throws PDFParseException {
+        Object obj = stack.pop();
+        if (!(obj instanceof PDFObject)) {
+            throw new PDFParseException("Expected a reference here: " + obj.toString());
+        }
+        return (PDFObject) obj;
+    }
+
+    /**
+     * pop an array off the stack
+     * @return the array of objects that is the top element of the stack
+     * @throws PDFParseException if the top element of the stack does not
+     * contain an array.
+     */
+    private Object[] popArray() throws PDFParseException {
+        Object obj = stack.pop();
+        if (!(obj instanceof Object[])) {
+            throw new PDFParseException("Expected an [array] here: " + obj.toString());
+        }
+        return (Object[]) obj;
+    }
+
+    /**
+     * A class to store state needed whiel rendering.  This includes the
+     * stroke and fill color spaces, as well as the text formatting
+     * parameters.
+     */
+    class ParserState implements Cloneable {
+
+        /** the fill color space */
+        PDFColorSpace fillCS;
+        /** the stroke color space */
+        PDFColorSpace strokeCS;
+        /** the text paramters */
+        PDFTextFormat textFormat;
+
+        /**
+         * Clone the render state.
+         */
+        @Override
+        public Object clone() {
+            ParserState newState = new ParserState();
+
+            // no need to clone color spaces, since they are immutable
+            // TODO: uncommented following 2 lines (mutable?)
+            newState.fillCS = fillCS;
+            newState.strokeCS = strokeCS;
+
+            // we do need to clone the textFormat
+            newState.textFormat = (PDFTextFormat) textFormat.clone();
+
+            return newState;
+        }
+    }
+    
+    private String dump(Stack<Object> stk) {
+    	if (stk == null)
+    		return "<null>";
+    	if (stk.size() == 0)
+    		return "[]";
+    	String result = "";
+    	String delimiter = "[";
+    	for (Object obj : stk) {
+			result += delimiter + dumpObj(obj);
+			delimiter = ",";
+		}
+    	result += "]";
+		return result;
+	}
+
+	private String dumpObj(Object obj) {
+		if (obj == null)
+			return "<null>";
+		if (obj instanceof Object[]) {
+			return dumpArray((Object[])obj);
+		}
+		return obj.toString();
+	}
+
+    private String dumpArray(Object[] objs) {
+    	if (objs == null)
+    		return "<null>";
+    	if (objs.length == 0)
+    		return "[]";
+    	String result = "";
+    	String delimiter = "[";
+    	for (Object obj : objs) {
+			result += delimiter + dumpObj(obj);
+			delimiter = ",";
+		}
+    	result += "]";
+		return result;
+	}
+    
+}

src/com/sun/pdfview/PDFRenderer.java

@@ -0,0 +1,810 @@
+/*
+ * $Id: PDFRenderer.java,v 1.8 2009/02/12 13:53:56 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview;
+
+import java.lang.ref.WeakReference;
+import java.util.Stack;
+
+import net.sf.andpdf.utils.BiCa;
+import net.sf.andpdf.utils.Utils;
+
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Matrix;
+import android.graphics.Paint;
+import android.graphics.Path;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.graphics.Bitmap.Config;
+import android.graphics.Paint.Cap;
+import android.graphics.Paint.Join;
+import android.graphics.Region.Op;
+import android.util.Log;
+
+/**
+ * This class turns a set of PDF Commands from a PDF page into an image.  It
+ * encapsulates the state of drawing in terms of stroke, fill, transform,
+ * etc., as well as pushing and popping these states.
+ *
+ * When the run method is called, this class goes through all remaining commands
+ * in the PDF Page and draws them to its buffered image.  It then updates any
+ * ImageConsumers with the drawn data.
+ */
+public class PDFRenderer extends BaseWatchable implements Runnable {
+
+	private static final String TAG = "APV.PDFRenderer";
+	
+	private int cmdCnt;
+	
+    /** the page we were generate from */
+    private PDFPage page;
+    /** where we are in the page's command list */
+    private int currentCommand;
+    /** a weak reference to the image we render into.  For the image
+     * to remain available, some other code must retain a strong reference to it.
+     */
+    private WeakReference<BiCa> imageRef;
+    /** the graphics object for use within an iteration.  Note this must be
+     * set to null at the end of each iteration, or the image will not be
+     * collected
+     */
+    private Canvas g;
+    private Paint g_p;
+    /** the current graphics state */
+    private GraphicsState state;
+    /** the stack of push()ed graphics states */
+    private Stack<GraphicsState> stack;
+    /** the total region of this image that has been written to */
+    private RectF globalDirtyRegion;
+    /** the last shape we drew (to check for overlaps) */
+    private Path lastShape;
+    /** the info about the image, if we need to recreate it */
+    private ImageInfo imageinfo;
+    /** the next time the image should be notified about updates */
+    private long then = 0;
+    /** the sum of all the individual dirty regions since the last update */
+    private RectF unupdatedRegion;
+    /** how long (in milliseconds) to wait between image updates */
+    public static final long UPDATE_DURATION = 200;
+    public static final float NOPHASE = -1000;
+    public static final float NOWIDTH = -1000;
+    public static final float NOLIMIT = -1000;
+    public static final Cap NOCAP = null;
+    public static final float[] NODASH = null;
+    public static final Join NOJOIN = null;
+
+    /**
+     * create a new PDFGraphics state
+     * @param page the current page
+     * @param imageinfo the paramters of the image to render
+     */
+    public PDFRenderer(PDFPage page, ImageInfo imageinfo, Bitmap bi) {
+        super();
+
+        this.page = page;
+        this.imageinfo = imageinfo;
+        this.imageRef = new WeakReference<BiCa>(new BiCa(bi,g));
+
+//        // initialize the list of observers
+//        observers = new ArrayList<ImageObserver>();
+        this.cmdCnt = 0;
+    }
+
+    /**
+     * create a new PDFGraphics state, given a Graphics2D. This version
+     * will <b>not</b> create an image, and you will get a NullPointerException
+     * if you attempt to call getImage().
+     * @param page the current page
+     * @param g the Graphics2D object to use for drawing
+     * @param imgbounds the bounds of the image into which to fit the page
+     * @param clip the portion of the page to draw, in page space, or null
+     * if the whole page should be drawn
+     * @param bgColor the color to draw the background of the image, or
+     * null for no color (0 alpha value)
+     */
+    public PDFRenderer(PDFPage page, Canvas g, RectF imgbounds,
+            RectF clip, int bgColor) {
+        super();
+
+        this.page = page;
+        this.g = g;
+        this.g_p = new Paint();
+        this.imageinfo = new ImageInfo((int)imgbounds.width(), (int)imgbounds.height(),
+                clip, bgColor);
+        g.translate(imgbounds.left, imgbounds.top);
+//	System.out.println("Translating by "+imgbounds.x+","+imgbounds.y);
+
+//        // initialize the list of observers
+//        observers = new ArrayList<ImageObserver>();
+        this.cmdCnt = 0;
+    }
+
+    /**
+     * Set up the graphics transform to match the clip region
+     * to the image size.
+     */
+    private void setupRendering(Canvas g) {
+//        g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
+//                RenderingHints.VALUE_ANTIALIAS_ON);
+//        g.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
+//                RenderingHints.VALUE_INTERPOLATION_BICUBIC);
+//        g.setRenderingHint(RenderingHints.KEY_ALPHA_INTERPOLATION,
+//                RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY);
+
+    	Paint g_p = new Paint();
+        g_p.setColor(imageinfo.bgColor);
+        g.drawRect(0, 0, imageinfo.width, imageinfo.height, g_p);
+
+        g_p.setColor(Color.BLACK);
+
+        // set the initial clip and transform on the graphics
+        Matrix mat = getInitialTransform();
+        g.setMatrix(mat);
+
+        // set up the initial graphics state
+        state = new GraphicsState();
+        state.cliprgn = null;
+    	state.strokePaint = PDFPaint.getColorPaint(Color.BLACK);
+    	state.fillPaint = PDFPaint.getPaint(Color.BLACK);
+        state.xform = g.getMatrix();
+
+        // initialize the stack
+        stack = new Stack<GraphicsState>();
+
+        // initialize the current command
+        currentCommand = 0;
+    }
+
+    /**
+     * push the current graphics state onto the stack.  Continue working
+     * with the current object; calling pop() restores the state of this
+     * object to its state when push() was called.
+     */
+    public void push() {
+        state.cliprgn = g.getClipBounds();
+        stack.push(state);
+
+        state = (GraphicsState) state.clone();
+    }
+
+    /**
+     * restore the state of this object to what it was when the previous
+     * push() was called.
+     */
+    public void pop() {
+        state = (GraphicsState) stack.pop();
+
+        setTransform(state.xform);
+        setClip(state.cliprgn);
+    }
+
+    /**
+     * draw an outline using the current stroke and draw paint
+     * @param s the path to stroke
+     * @return a Rectangle2D to which the current region being
+     * drawn will be added.  May also be null, in which case no dirty
+     * region will be recorded.
+     */
+    public RectF stroke(Path s) {
+//        g.setComposite(state.strokeAlpha);
+//        s = new GeneralPath(autoAdjustStrokeWidth(g, state.stroke).createStrokedShape(s));
+        return state.strokePaint.fill(this, g, s);
+    }
+
+//    /**
+//     * auto adjust the stroke width, according to 6.5.4, which presumes that
+//     * the device characteristics (an image) require a single pixel wide
+//     * line, even if the width is set to less. We determine the scaling to
+//     * see if we would produce a line that was too small, and if so, scale
+//     * it up to produce a graphics line of 1 pixel, or so. This matches our
+//     * output with Adobe Reader.
+//     * 
+//     * @param g
+//     * @param bs
+//     * @return
+//     */
+//    private BasicStroke autoAdjustStrokeWidth(Graphics2D g, BasicStroke bs) {
+//        AffineTransform bt = new AffineTransform(g.getTransform());
+//        float width = bs.getLineWidth() * (float) bt.getScaleX();
+//        BasicStroke stroke = bs;
+//        if (width < 1f) {
+//            if (bt.getScaleX() > 0.01) {
+//                width = 1.0f / (float) bt.getScaleX();
+//                stroke = new BasicStroke(width,
+//                        bs.getEndCap(),
+//                        bs.getLineJoin(),
+//                        bs.getMiterLimit(),
+//                        bs.getDashArray(),
+//                        bs.getDashPhase());
+//            } else {
+//                // prevent division by a really small number
+//                width = 1.0f;
+//            }
+//        }
+//        return stroke;
+//    }
+
+    /**
+     * draw an outline.
+     * @param p the path to draw
+     * @param bs the stroke with which to draw the path
+     */
+    public void draw(Path p) {
+        g.drawPath(p, state.fillPaint.getPaint());
+        g.drawPath(p, state.strokePaint.getPaint());
+    }
+
+    /**
+     * fill an outline using the current fill paint
+     * @param s the path to fill
+     */
+    public RectF fill(Path s) {
+        // g.setComposite(state.fillAlpha);
+        return state.fillPaint.fill(this, g, s);
+    }
+
+    /**
+     * draw an image.
+     * @param image the image to draw
+     */
+    public RectF drawImage(PDFImage image) {
+    	Matrix mat = new Matrix();
+    	Utils.setMatValues(mat, 
+    			1f / image.getWidth(), 0,
+                0, -1f / image.getHeight(),
+                0, 1
+        );
+
+        Bitmap bi = image.getImage();
+        if (image.isImageMask()) {
+            bi = getMaskedImage(bi);
+        }
+
+        /*
+        javax.swing.JFrame frame = new javax.swing.JFrame("Original Image");
+        frame.getContentPane().add(new javax.swing.JLabel(new javax.swing.ImageIcon(bi)));
+        frame.pack();
+        frame.show();
+         */
+
+        g.drawBitmap(bi, mat, null);
+
+        // get the total transform that was executed
+        Matrix matB = new Matrix(g.getMatrix());
+        matB.preConcat(mat);
+
+        float minx = 0;
+        float miny = 0;
+
+        float[] points = new float[]{
+            minx, miny, minx + bi.getWidth(), miny + bi.getHeight()
+        };
+        matB.mapPoints(points, 0, points, 0, 2);
+
+        return new RectF(points[0], points[1],
+                points[2] - points[0],
+                points[3] - points[1]);
+
+    }
+
+    /**
+     * add the path to the current clip.  The new clip will be the intersection
+     * of the old clip and given path.
+     */
+    public void clip(Path s) {
+        g.clipPath(s);
+    }
+
+    /**
+     * set the clip to be the given shape.  The current clip is not taken
+     * into account.
+     */
+    private void setClip(Rect s) {
+        state.cliprgn = s;
+        g.clipRect(s,Op.REPLACE);
+    }
+
+    /**
+     * get the current affinetransform
+     */
+    public Matrix getTransform() {
+        return state.xform;
+    }
+
+    /**
+     * concatenate the given transform with the current transform
+     */
+    public void transform(Matrix mat) {
+        state.xform.preConcat(mat);
+        g.setMatrix(state.xform);
+    }
+
+    /**
+     * replace the current transform with the given one.
+     */
+    public void setTransform(Matrix mat) {
+        state.xform = mat;
+        g.setMatrix(state.xform);
+    }
+
+    /**
+     * get the initial transform from page space to Java space
+     */
+    public Matrix getInitialTransform() {
+        return page.getInitialTransform(imageinfo.width,
+                imageinfo.height,
+                imageinfo.clip);
+    }
+
+    /**
+     * Set some or all aspects of the current stroke.
+     * @param w the width of the stroke, or NOWIDTH to leave it unchanged
+     * @param cap the end cap style, or NOCAP to leave it unchanged
+     * @param join the join style, or NOJOIN to leave it unchanged
+     * @param limit the miter limit, or NOLIMIT to leave it unchanged
+     * @param phase the phase of the dash array, or NOPHASE to leave it
+     * unchanged
+     * @param ary the dash array, or null to leave it unchanged.  phase
+     * and ary must both be valid, or phase must be NOPHASE while ary is null.
+     */
+    public void setStrokeParts(float w, Cap cap, Join join, float limit, float[] ary, float phase) {
+        if (w == NOWIDTH) {
+            w = state.lineWidth;
+        }
+        if (cap == NOCAP) {
+            cap = state.cap;
+        }
+        if (join == NOJOIN) {
+            join = state.join;
+        }
+        if (limit == NOLIMIT) {
+            limit = state.miterLimit;
+        }
+        if (phase == NOPHASE) {
+//            ary = state.stroke.getDashArray();
+//            phase = state.stroke.getDashPhase();
+        }
+        if (ary != null && ary.length == 0) {
+            ary = null;
+        }
+//        if (phase == NOPHASE) {
+//            state.stroke = new BasicStroke(w, cap, join, limit);
+//        } else {
+//            state.stroke = new BasicStroke(w, cap, join, limit, ary, phase);
+//        }
+        state.lineWidth = w;
+        state.cap = cap;
+        state.join = join;
+        state.miterLimit = limit;
+    }
+
+//    /**
+//     * get the current stroke as a BasicStroke
+//     */
+//    public BasicStroke getStroke() {
+//        return state.stroke;
+//    }
+//
+//    /**
+//     * set the current stroke as a BasicStroke
+//     */
+//    public void setStroke(BasicStroke bs) {
+//        state.stroke = bs;
+//    }
+
+    /**
+     * set the stroke color
+     */
+    public void setStrokePaint(PDFPaint paint) {
+        state.strokePaint = paint;
+    }
+
+    /**
+     * set the fill color
+     */
+    public void setFillPaint(PDFPaint paint) {
+        state.fillPaint = paint;
+    }
+
+//    /**
+//     * set the stroke alpha
+//     */
+//    public void setStrokeAlpha(float alpha) {
+//        state.strokeAlpha = AlphaComposite.getInstance(AlphaComposite.SRC_OVER,
+//                alpha);
+//    }
+//
+//    /**
+//     * set the stroke alpha
+//     */
+//    public void setFillAlpha(float alpha) {
+//        state.fillAlpha = AlphaComposite.getInstance(AlphaComposite.SRC_OVER,
+//                alpha);
+//    }
+
+//    /**
+//     * Add an image observer
+//     */
+//    public void addObserver(ImageObserver observer) {
+//        if (observer == null) {
+//            return;
+//        }
+//
+//        // update the new observer to the current state
+//        Image i = (Image) imageRef.get();
+//        if (rendererFinished()) {
+//            // if we're finished, just send a finished notification, don't
+//            // add to the list of observers
+//            // System.out.println("Late notify");
+//            observer.imageUpdate(i, ImageObserver.ALLBITS, 0, 0,
+//                    imageinfo.width, imageinfo.height);
+//            return;
+//        } else {
+//            // if we're not yet finished, add to the list of observers and
+//            // notify of the current dirty region
+//            synchronized (observers) {
+//                observers.add(observer);
+//            }
+//
+//            if (globalDirtyRegion != null) {
+//                observer.imageUpdate(i, ImageObserver.SOMEBITS,
+//                        (int) globalDirtyRegion.getMinX(),
+//                        (int) globalDirtyRegion.getMinY(),
+//                        (int) globalDirtyRegion.getWidth(),
+//                        (int) globalDirtyRegion.getHeight());
+//            }
+//        }
+//    }
+//
+//    /**
+//     * Remove an image observer
+//     */
+//    public void removeObserver(ImageObserver observer) {
+//        synchronized (observers) {
+//            observers.remove(observer);
+//        }
+//    }
+
+    /**
+     * Set the last shape drawn
+     */
+    public void setLastShape(Path shape) {
+        this.lastShape = shape;
+    }
+
+    /**
+     * Get the last shape drawn
+     */
+    public Path getLastShape() {
+        return lastShape;
+    }
+
+    /**
+     * Setup rendering.  Called before iteration begins
+     */
+    @Override
+    public void setup() {
+        Canvas graphics = null;
+
+        if (imageRef != null) {
+            BiCa bica = (BiCa) imageRef.get();
+            if (bica != null) {
+                graphics = bica.createCa();
+            }
+        } else {
+            graphics = g;
+        }
+
+
+        if (graphics != null) {
+            setupRendering(graphics);
+        }
+    }
+
+    /**
+     * Draws the next command in the PDFPage to the buffered image.
+     * The image will be notified about changes no less than every
+     * UPDATE_DURATION milliseconds.
+     *
+     * @return <ul><li>Watchable.RUNNING when there are commands to be processed
+     *             <li>Watchable.NEEDS_DATA when there are no commands to be
+     *                 processed, but the page is not yet complete
+     *             <li>Watchable.COMPLETED when the page is done and all
+     *                 the commands have been processed
+     *             <li>Watchable.STOPPED if the image we are rendering into
+     *                 has gone away
+     *         </ul>
+     */
+    public int iterate() throws Exception {
+        // make sure we have a page to render
+        if (page == null) {
+            return Watchable.COMPLETED;
+        }
+
+        // check if this renderer is based on a weak reference to a graphics
+        // object.  If it is, and the graphics is no longer valid, then just quit
+        Bitmap bi = null;
+        if (imageRef != null) {
+            BiCa bica = (BiCa) imageRef.get();
+            if (bica == null) {
+                System.out.println("Image went away.  Stopping");
+                return Watchable.STOPPED;
+            }
+            bi = bica.getBi();
+            g = bica.createCa();
+            g_p = new Paint();  // TODO [FHe]: performance - create new paint() called for every iteration? imageRef is empty?
+        }
+
+        // check if there are any commands to parse.  If there aren't,
+        // just return, but check if we'return really finished or not
+        if (currentCommand >= page.getCommandCount()) {
+            if (page.isFinished()) {
+                return Watchable.COMPLETED;
+            } else {
+                return Watchable.NEEDS_DATA;
+            }
+        }         
+        
+        // TODO [FHe]: display currentCommand / page.commandCount
+
+        // find the current command
+        PDFCmd cmd = page.getCommand(currentCommand++);
+        if (cmd == null) {
+            // uh oh.  Synchronization problem!
+            throw new PDFParseException("Command not found!");
+        }
+
+        if (!PDFParser.RELEASE) {
+        	cmdCnt += 1;
+        	Log.i(TAG, "CMD["+cmdCnt+"]: "+cmd.toString() + ": " + cmd.getDetails());
+        }
+		RectF dirtyRegion = null;
+        // execute the command
+try {
+        dirtyRegion = cmd.execute(this);
+}
+catch (Exception e) {
+	// TODO [FHe] remove if all commands are supported, now catch image not yet supp. excp.
+	Log.e(TAG, e.getMessage(), e);
+//	throw new PDFParseException(e.getMessage());
+}
+
+        // append to the global dirty region
+        globalDirtyRegion = addDirtyRegion(dirtyRegion, globalDirtyRegion);
+        unupdatedRegion = addDirtyRegion(dirtyRegion, unupdatedRegion);
+
+        long now = System.currentTimeMillis();
+        if (now > then || rendererFinished()) {
+            // now tell any observers, so they can repaint
+//            notifyObservers(bi, unupdatedRegion);
+            unupdatedRegion = null;
+            then = now + UPDATE_DURATION;
+        }
+
+        // if we are based on a reference to a graphics, don't hold on to it
+        // since that will prevent the image from being collected.
+        if (imageRef != null) {
+            g = null;
+        }
+
+        // if we need to stop, it will be caught at the start of the next
+        // iteration.
+        return Watchable.RUNNING;
+    }
+
+    /**
+     * Called when iteration has stopped
+     */
+    @Override
+    public void cleanup() {
+        page = null;
+        state = null;
+        stack = null;
+        globalDirtyRegion = null;
+        lastShape = null;
+
+//        observers.clear();
+
+    // keep around the image ref and image info for use in
+    // late addObserver() call
+    }
+
+    /**
+     * Append a rectangle to the total dirty region of this shape
+     */
+    private RectF addDirtyRegion(RectF region, RectF glob) {
+        if (region == null) {
+            return glob;
+        } else if (glob == null) {
+            return region;
+        } else {
+            glob.union(region);
+            return glob;
+        }
+    }
+
+    /**
+     * Determine if we are finished
+     */
+    private boolean rendererFinished() {
+        if (page == null) {
+            return true;
+        }
+
+        return (page.isFinished() && currentCommand == page.getCommandCount());
+    }
+
+//    /**
+//     * Notify the observer that a region of the image has changed
+//     */
+//    private void notifyObservers(BufferedImage bi, Rectangle2D region) {
+//        if (bi == null) {
+//            return;
+//        }
+//
+//        int startx, starty, width, height;
+//        int flags = 0;
+//
+//        // don't do anything if nothing is there or no one is listening
+//        if ((region == null && !rendererFinished()) || observers == null ||
+//                observers.size() == 0) {
+//            return;
+//        }
+//
+//        if (region != null) {
+//            // get the image data for the total dirty region
+//            startx = (int) Math.floor(region.getMinX());
+//            starty = (int) Math.floor(region.getMinY());
+//            width = (int) Math.ceil(region.getWidth());
+//            height = (int) Math.ceil(region.getHeight());
+//
+//            // sometimes width or height is negative.  Grrr...
+//            if (width < 0) {
+//                startx += width;
+//                width = -width;
+//            }
+//            if (height < 0) {
+//                starty += height;
+//                height = -height;
+//            }
+//
+//            flags = 0;
+//        } else {
+//            startx = 0;
+//            starty = 0;
+//            width = imageinfo.width;
+//            height = imageinfo.height;
+//        }
+//        if (rendererFinished()) {
+//            flags |= ImageObserver.ALLBITS;
+//            // forget about the Graphics -- allows the image to be
+//            // garbage collected.
+//            g = null;
+//        } else {
+//            flags |= ImageObserver.SOMEBITS;
+//        }
+//
+//        synchronized (observers) {
+//            for (Iterator i = observers.iterator(); i.hasNext();) {
+//                ImageObserver observer = (ImageObserver) i.next();
+//
+//                boolean result = observer.imageUpdate(bi, flags,
+//                        startx, starty,
+//                        width, height);
+//
+//                // if result is false, the observer no longer wants to
+//                // be notified of changes
+//                if (!result) {
+//                    i.remove();
+//                }
+//            }
+//        }
+//    }
+
+    /**
+     * Convert an image mask into an image by painting over any pixels
+     * that have a value in the image with the current paint
+     */
+    private Bitmap getMaskedImage(Bitmap bi) {
+        // get the color of the current paint
+        int col = state.fillPaint.getPaint().getColor();
+
+        // format as 8 bits each of ARGB
+        int paintColor = Color.alpha(col) << 24;
+        paintColor |= Color.red(col) << 16;
+        paintColor |= Color.green(col) << 8;
+        paintColor |= Color.blue(col);
+
+        // transparent (alpha = 1)
+        int noColor = 0;
+
+        // get the coordinates of the source image
+        int startX = 0;
+        int startY = 0;
+        int width = bi.getWidth();
+        int height = bi.getHeight();
+
+        // create a destion image of the same size
+        Bitmap dstImage = Bitmap.createBitmap(width, height, Config.ARGB_8888);
+
+        // copy the pixels row by row
+        for (int i = 0; i < height; i++) {
+            int[] srcPixels = new int[width];
+            int[] dstPixels = new int[srcPixels.length];
+
+            // read a row of pixels from the source
+            bi.getPixels(srcPixels, 0, 0, startX, startY+i, width, 1);
+//            bi.getRGB(startX, startY + i, width, 1, srcPixels, 0, height);
+
+            // figure out which ones should get painted
+            for (int j = 0; j < srcPixels.length; j++) {
+                if (srcPixels[j] == 0xff000000) {
+                    dstPixels[j] = paintColor;
+                } else {
+                    dstPixels[j] = noColor;
+                }
+            }
+
+            // write the destination image
+//            dstImage.setRGB(startX, startY + i, width, 1, dstPixels, 0, height);
+            dstImage.setPixels(dstPixels, 0, 0, startX, startY+i, width, 1);
+        }
+
+        return dstImage;
+    }
+
+    class GraphicsState implements Cloneable {
+
+        /** the clip region */
+        Rect cliprgn;
+        /** the current stroke */
+        Cap cap;
+        Join join;
+        float lineWidth;
+        float miterLimit;
+        /** the current paint for drawing strokes */
+        PDFPaint strokePaint;
+        /** the current paint for filling shapes */
+        PDFPaint fillPaint;
+        /** the current transform */
+        Matrix xform;
+
+        /** Clone this Graphics state.
+         *
+         * Note that cliprgn is not cloned.  It must be set manually from
+         * the current graphics object's clip
+         */
+        @Override
+        public Object clone() {
+            GraphicsState cState = new GraphicsState();
+            cState.cliprgn = null;
+            cState.cap = cap;
+            cState.join = join;
+            cState.strokePaint = strokePaint;
+            cState.fillPaint = fillPaint;
+            cState.xform = new Matrix(xform);
+            cState.lineWidth = lineWidth;
+            cState.miterLimit = miterLimit;
+            return cState;
+        }
+    }
+}

src/com/sun/pdfview/PDFShapeCmd.java

@@ -0,0 +1,215 @@
+/*
+ * $Id: PDFShapeCmd.java,v 1.3 2009/01/16 16:26:15 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview;
+
+import android.graphics.Path;
+import android.graphics.RectF;
+
+
+/**
+ * Encapsulates a path.  Also contains extra fields and logic to check
+ * for consecutive abutting anti-aliased regions.  We stroke the shared
+ * line between these regions again with a 1-pixel wide line so that
+ * the background doesn't show through between them.
+ *
+ * @author Mike Wessler
+ */
+public class PDFShapeCmd extends PDFCmd {
+
+    /** stroke the outline of the path with the stroke paint */
+    public static final int STROKE = 1;
+    /** fill the path with the fill paint */
+    public static final int FILL = 2;
+    /** perform both stroke and fill */
+    public static final int BOTH = 3;
+    /** set the clip region to the path */
+    public static final int CLIP = 4;
+    /** base path */
+    private Path gp;
+    /** the style */
+    private int style;
+    /** the bounding box of the path */
+    private RectF bounds;
+    /** the stroke style for the anti-antialias stroke */
+	// TODO [FHe]: againstroke 
+//    BasicStroke againstroke =
+//            new BasicStroke(2, BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL);
+
+    /**
+     * create a new PDFShapeCmd and check it against the previous one
+     * to find any shared edges.
+     * @param gp the path
+     * @param style the style: an OR of STROKE, FILL, or CLIP.  As a
+     * convenience, BOTH = STROKE | FILL.
+     */
+    public PDFShapeCmd(Path gp, int style) {
+        this.gp = new Path(gp);
+        this.style = style;
+        bounds = new RectF();
+        gp.computeBounds(bounds, false);
+    }
+
+    /**
+     * perform the stroke and record the dirty region
+     */
+    public RectF execute(PDFRenderer state) {
+        RectF rect = null;
+
+        if ((style & FILL) != 0) {
+            rect = state.fill(gp);
+
+        	// TODO [FHe]: againstroke 
+//            Path strokeagain = checkOverlap(state);
+//            if (strokeagain != null) {
+//                state.draw(strokeagain, againstroke);
+//            }
+
+            if (gp != null) {
+                state.setLastShape(gp);
+            }
+        }
+        if ((style & STROKE) != 0) {
+            RectF strokeRect = state.stroke(gp);
+            if (rect == null) {
+                rect = strokeRect;
+            } else {
+                rect.union(strokeRect);
+            }
+        }
+        if ((style & CLIP) != 0) {
+            state.clip(gp);
+        }
+
+        return rect;
+    }
+
+//    /**
+//     * Check for overlap with the previous shape to make anti-aliased shapes
+//     * that are near each other look good
+//     */
+//    private Path checkOverlap(PDFRenderer state) {
+//        if (style == FILL && gp != null && state.getLastShape() != null) {
+//            float mypoints[] = new float[16];
+//            float prevpoints[] = new float[16];
+//
+//            int mycount = getPoints(gp, mypoints);
+//            int prevcount = getPoints(state.getLastShape(), prevpoints);
+//
+//            // now check mypoints against prevpoints for opposite pairs:
+//            if (mypoints != null && prevpoints != null) {
+//                for (int i = 0; i < prevcount; i += 4) {
+//                    for (int j = 0; j < mycount; j += 4) {
+//                        if ((Math.abs(mypoints[j + 2] - prevpoints[i]) < 0.01 &&
+//                                Math.abs(mypoints[j + 3] - prevpoints[i + 1]) < 0.01 &&
+//                                Math.abs(mypoints[j] - prevpoints[i + 2]) < 0.01 &&
+//                                Math.abs(mypoints[j + 1] - prevpoints[i + 3]) < 0.01)) {
+//                            GeneralPath strokeagain = new GeneralPath();
+//                            strokeagain.moveTo(mypoints[j], mypoints[j + 1]);
+//                            strokeagain.lineTo(mypoints[j + 2], mypoints[j + 3]);
+//                            return strokeagain;
+//                        }
+//                    }
+//                }
+//            }
+//        }
+//
+//        // no issues
+//        return null;
+//    }
+//
+//    /**
+//     * Get an array of 16 points from a path
+//     * @return the number of points we actually got
+//     */
+//    private int getPoints(GeneralPath path, float[] mypoints) {
+//        int count = 0;
+//        float x = 0;
+//        float y = 0;
+//        float startx = 0;
+//        float starty = 0;
+//        float[] coords = new float[6];
+//
+//        PathIterator pi = path.getPathIterator(new AffineTransform());
+//        while (!pi.isDone()) {
+//            if (count >= mypoints.length) {
+//                mypoints = null;
+//                break;
+//            }
+//
+//            int pathtype = pi.currentSegment(coords);
+//            switch (pathtype) {
+//                case PathIterator.SEG_MOVETO:
+//                    startx = x = coords[0];
+//                    starty = y = coords[1];
+//                    break;
+//                case PathIterator.SEG_LINETO:
+//                    mypoints[count++] = x;
+//                    mypoints[count++] = y;
+//                    x = mypoints[count++] = coords[0];
+//                    y = mypoints[count++] = coords[1];
+//                    break;
+//                case PathIterator.SEG_QUADTO:
+//                    x = coords[2];
+//                    y = coords[3];
+//                    break;
+//                case PathIterator.SEG_CUBICTO:
+//                    x = mypoints[4];
+//                    y = mypoints[5];
+//                    break;
+//                case PathIterator.SEG_CLOSE:
+//                    mypoints[count++] = x;
+//                    mypoints[count++] = y;
+//                    x = mypoints[count++] = startx;
+//                    y = mypoints[count++] = starty;
+//                    break;
+//            }
+//
+//            pi.next();
+//        }
+//
+//        return count;
+//    }
+
+    /** Get detailed information about this shape
+     */
+    @Override
+    public String getDetails() {
+        StringBuffer sb = new StringBuffer();
+
+        RectF b = new RectF();
+        gp.computeBounds(b, false);
+        sb.append("ShapeCommand at: " + b.left + ", " + b.top + "\n");
+        sb.append("Size: " + b.width() + " x " + b.height() + "\n");
+
+        sb.append("Mode: ");
+        if ((style & FILL) != 0) {
+            sb.append("FILL ");
+        }
+        if ((style & STROKE) != 0) {
+            sb.append("STROKE ");
+        }
+        if ((style & CLIP) != 0) {
+            sb.append("CLIP");
+        }
+
+        return sb.toString();
+    }
+}

src/com/sun/pdfview/PDFStringUtil.java

@@ -0,0 +1,233 @@
+/*
+ * Copyright 2008 Pirion Systems Pty Ltd, 139 Warry St,
+ * Fortitude Valley, Queensland, Australia
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview;
+
+import java.io.*;
+import java.util.Map;
+import java.util.HashMap;
+import java.nio.CharBuffer;
+import java.nio.ByteBuffer;
+import java.nio.charset.CharacterCodingException;
+
+/**
+ * <p> Utility methods for dealing with PDF Strings, such as:
+ * <ul>
+ * <li>{@link #asTextString(String) converting to text strings}
+ * <li>{@link #asPDFDocEncoded(String) converting to PDFDocEncoded strings}
+ * <li>{@link #asUTF16BEEncoded converting to UTF-16BE strings}
+ * <li>converting basic strings between {@link #asBytes(String) byte} and
+ * {@link #asBasicString(byte[], int, int) string} representations
+ * </ul></p>
+ *
+ * <p>We refer to basic strings as those corresponding to the PDF 'string' type.
+ * PDFRenderer represents these as {@link String}s, though this is somewhat
+ * deceiving, as they are, effectively, just sequences of bytes, although byte
+ * values &lt;= 127 do correspond to the ASCII character set. Outside of this,
+ * the 'string' type, as repesented by basic strings do not possess any
+ * character set or encoding, and byte values &gt;= 128 are entirely acceptable.
+ * For a basic string as represented by a String, each character has a value
+ * less than 256 and is represented in the String as if the bytes represented as
+ * it were in ISO-8859-1 encoding. This, however, is merely for convenience. For
+ * strings that are user visible, and that don't merely represent some
+ * identifying token, the PDF standard employs a 'text string' type that offers
+ * the basic string as an encoding of in either UTF-16BE (with a byte order
+ * marking) or a specific 8-byte encoding, PDFDocEncoding. Using a basic string
+ * without conversion when the actual type is a 'text string' is erroneous
+ * (though without consequence if the string consists only of ASCII
+ * alphanumeric values). Care must be taken to either convert basic strings to
+ * text strings (also expressed as a String) when appropriate, using either the
+ * methods in this class, or {@link PDFObject#getTextStringValue()}}. For
+ * strings that are 'byte strings', {@link #asBytes(String)} or {@link
+ * PDFObject#getStream()} should be used. </p>.
+ *
+ * @author Luke Kirby
+ */
+public class PDFStringUtil {
+
+    /**
+     * <p>Take a basic PDF string and determine if it is in UTF-16BE encoding
+     * by looking at the lead characters for a byte order marking (BOM). If it
+     * appears to be UTF-16BE, we return the string representation of the
+     * UTF-16BE encoding of those bytes. If the BOM is not present, the bytes
+     * from the input string are decoded using the PDFDocEncoding charset.</p>
+     *
+     * <p>From the PDF Reference 1.7, p158:
+     *
+     * <blockquote>The text string type is used for character strings that are
+     * encoded in either PDFDocEncoding or the UTF-16BE Unicode character
+     * encoding scheme. PDFDocEncoding can encode all of the ISO Latin 1
+     * character set and is documented in Appendix D. UTF-16BE can encode all
+     * Unicode characters. UTF-16BE and Unicode character encoding are
+     * described in the Unicode Standard by the Unicode Consortium (see the
+     * Bibliography). Note that PDFDocEncoding does not support all Unicode
+     * characters whereas UTF-16BE does.</blockquote>
+     * </p>
+     *
+     * @param basicString the basic PDF string, as offered by {@link
+     *  PDFObject#getStringValue()}
+     * @return either the original input, or the input decoded as UTF-16
+     */
+    public static String asTextString(String basicString) {
+        if (basicString == null) {
+            return null;
+        }
+
+        if (basicString.length() >= 2) {
+            if ((basicString.charAt(0) == (char) 0xFE
+                    && basicString.charAt(1) == (char) 0xFF)) {
+                // found the BOM!
+                return asUTF16BEEncoded(basicString);
+            }
+        }
+
+        // it's not UTF16-BE encoded, so it must be
+        return asPDFDocEncoded(basicString);
+    }
+
+    /**
+     * Take a basic PDF string and produce a string of its bytes as encoded in
+     * PDFDocEncoding. The PDFDocEncoding is described in the PDF Reference.
+     *
+     * @param basicString the basic PDF string, as offered by {@link
+     *  PDFObject#getStringValue()}
+     * @return the decoding of the string's bytes in PDFDocEncoding
+     */
+    public static String asPDFDocEncoded(String basicString) {
+        final StringBuilder buf = new StringBuilder(basicString.length());
+        for (int i = 0; i < basicString.length(); ++i) {
+            final char c = PDF_DOC_ENCODING_MAP[basicString.charAt(i) & 0xFF];
+            buf.append(c);
+        }
+        return buf.toString();
+    }
+
+    public byte[] toPDFDocEncoded(String string)
+            throws CharacterCodingException {
+        // we can just grab array since we know that if charset completes
+        // without error then there's the output buffer will be exactly
+        // correct in size, since there's only ever 1 byte for one char.
+        return new PDFDocCharsetEncoder().encode(CharBuffer.wrap(string)).
+                array();
+    }
+
+    /**
+     * Take a basic PDF string and produce a string from its bytes as an
+     * UTF16-BE encoding. The first 2 bytes are presumed to be the big-endian
+     * byte markers, 0xFE and 0xFF; that is not checked by this method.
+     *
+     * @param basicString the basic PDF string, as offered by {@link
+     *  PDFObject#getStringValue()}
+     * @return the decoding of the string's bytes in UTF16-BE
+     */
+    public static String asUTF16BEEncoded(String basicString) {
+        try {
+            return new String(asBytes(basicString),
+                    2, basicString.length() - 2, "UTF-16BE");
+        } catch (UnsupportedEncodingException e) {
+            // UTF-16BE should always be available
+            throw new RuntimeException("No UTF-16BE charset!");
+        }
+    }
+
+    /**
+     * Get the corresponding byte array for a basic string. This is effectively
+     * the char[] array cast to bytes[], as chars in basic strings only use the
+     * least significant byte.
+     *
+     * @param basicString the basic PDF string, as offered by {@link
+     *  PDFObject#getStringValue()}
+     * @return the bytes corresponding to its characters
+     */
+    public static byte[] asBytes(String basicString) {
+        final byte[] b = new byte[basicString.length()];
+        for (int i = 0; i < b.length; ++i) {
+            b[i] = (byte) basicString.charAt(i);
+        }
+        return b;
+    }
+
+    /**
+     * Create a basic string from bytes. This is effectively the byte array
+     * cast to a char array and turned into a String.
+     * @param bytes the source of the bytes for the basic string
+     * @param offset the offset into butes where the string starts
+     * @param length the number of bytes to turn into a string
+     * @return the corresponding string
+     */
+    public static String asBasicString(
+            byte[] bytes, int offset, int length) {
+        final char[] c = new char[length];
+        for (int i = 0; i < c.length; ++i) {
+            c[i] = (char) bytes[i + offset];
+        }
+        return new String(c);
+    }
+
+    /**
+     * Create a basic string from bytes. This is effectively the byte array
+     * cast to a char array and turned into a String.
+     * @param bytes the bytes, all of which are used
+     * @return the corresponding string
+     */
+    public static String asBasicString(byte[] bytes) {
+        return asBasicString(bytes, 0, bytes.length);
+    }
+
+    /**
+     * Maps from PDFDocEncoding bytes to unicode characters. Table generated
+     * by PDFDocEncodingMapGenerator.
+     */
+    final static char[] PDF_DOC_ENCODING_MAP = new char[] {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,  //00-07
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,  //08-0F
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,  //10-17
+        0x02D8, 0x02C7, 0x02C6, 0x02D9, 0x02DD, 0x02DB, 0x02DA, 0x02DC,  //18-1F
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,  //20-27
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,  //28-2F
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,  //30-37
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,  //38-3F
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,  //40-47
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,  //48-4F
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,  //50-57
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,  //58-5F
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,  //60-67
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,  //68-6F
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,  //70-77
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0xFFFD,  //78-7F
+        0x2022, 0x2020, 0x2021, 0x2026, 0x2014, 0x2013, 0x0192, 0x2044,  //80-87
+        0x2039, 0x203A, 0x2212, 0x2030, 0x201E, 0x201C, 0x201D, 0x2018,  //88-8F
+        0x2019, 0x201A, 0x2122, 0xFB01, 0xFB02, 0x0141, 0x0152, 0x0160,  //90-97
+        0x0178, 0x017D, 0x0131, 0x0142, 0x0153, 0x0161, 0x017E, 0xFFFD,  //98-9F
+        0x20AC, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,  //A0-A7
+        0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0xFFFD, 0x00AE, 0x00AF,  //A8-AF
+        0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,  //B0-B7
+        0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,  //B8-BF
+        0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7,  //C0-C7
+        0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,  //C8-CF
+        0x00D0, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7,  //D0-D7
+        0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF,  //D8-DF
+        0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,  //E0-E7
+        0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,  //E8-EF
+        0x00F0, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7,  //F0-F7
+        0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x00FF,  //F8-FF
+    };
+
+
+
+}

src/com/sun/pdfview/PDFTextFormat.java

@@ -0,0 +1,353 @@
+/*
+ * $Id: PDFTextFormat.java,v 1.3 2009/01/16 16:26:11 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview;
+
+import java.util.Iterator;
+import java.util.List;
+
+import net.sf.andpdf.utils.Utils;
+
+import android.graphics.Matrix;
+import android.graphics.PointF;
+import android.graphics.RectF;
+import android.util.Log;
+
+import com.sun.pdfview.font.PDFFont;
+import com.sun.pdfview.font.PDFGlyph;
+
+
+/**
+ * a class encapsulating the text state
+ * @author Mike Wessler
+ */
+public class PDFTextFormat implements Cloneable {
+
+    /** character spacing */
+    private float tc = 0;
+    /** word spacing */
+    private float tw = 0;
+    /** horizontal scaling */
+    private float th = 1;
+    /** leading */
+    private float tl = 0;
+    /** rise amount */
+    private float tr = 0;
+    /** text mode */
+    private int tm = PDFShapeCmd.FILL;
+    /** text knockout */
+    private float tk = 0;
+    /** current matrix transform */
+    private Matrix cur;
+    /** matrix transform at start of line */
+    private Matrix line;
+    /** font */
+    private PDFFont font;
+    /** font size */
+    private float fsize = 1;
+    /** are we between BT and ET? */
+    private boolean inuse = false;
+    //    private Object array[]= new Object[1];
+    /** build text rep of word */
+    private StringBuffer word = new StringBuffer();
+
+    // this is where we build and keep the word list for this page.
+    /** start location of the hunk of text */
+    private PointF wordStart;
+    /** location of the end of the previous hunk of text */
+    private PointF prevEnd;
+
+    /**
+     * create a new PDFTextFormat, with initial values
+     */
+    public PDFTextFormat() {
+        cur = new Matrix();
+        line = new Matrix();
+        wordStart = new PointF(-100, -100);
+        prevEnd = new PointF(-100, -100);
+
+        tc = tw = tr = tk = 0;
+        tm = PDFShapeCmd.FILL;
+        th = 1;
+    }
+
+    /**
+     * reset the PDFTextFormat for a new run
+     */
+    public void reset() {
+        cur.reset();
+        line.reset();
+        inuse = true;
+        word.setLength(0);
+    }
+
+    /**
+     * end a span of text
+     */
+    public void end() {
+        inuse = false;
+    }
+
+    /** get the char spacing */
+    public float getCharSpacing() {
+        return tc;
+    }
+
+    /** set the character spacing */
+    public void setCharSpacing(float spc) {
+        this.tc = spc;
+    }
+
+    /** get the word spacing */
+    public float getWordSpacing() {
+        return tw;
+    }
+
+    /** set the word spacing */
+    public void setWordSpacing(float spc) {
+        this.tw = spc;
+    }
+
+    /**
+     * Get the horizontal scale
+     * @return the horizontal scale, in percent
+     */
+    public float getHorizontalScale() {
+        return th * 100;
+    }
+
+    /**
+     * set the horizontal scale.
+     * @param scl the horizontal scale, in percent (100=normal)
+     */
+    public void setHorizontalScale(float scl) {
+        this.th = scl / 100;
+    }
+
+    /** get the leading */
+    public float getLeading() {
+        return tl;
+    }
+
+    /** set the leading */
+    public void setLeading(float spc) {
+        this.tl = spc;
+    }
+
+    /** get the font */
+    public PDFFont getFont() {
+        return font;
+    }
+
+    /** get the font size */
+    public float getFontSize() {
+        return fsize;
+    }
+
+    /** set the font and size */
+    public void setFont(PDFFont f, float size) {
+        this.font = f;
+        this.fsize = size;
+    }
+
+    /**
+     * Get the mode of the text
+     */
+    public int getMode() {
+        return tm;
+    }
+
+    /**
+     * set the mode of the text.  The correspondence of m to mode is
+     * show in the following table.  m is a value from 0-7 in binary:
+     * 
+     * 000 Fill
+     * 001 Stroke
+     * 010 Fill + Stroke
+     * 011 Nothing
+     * 100 Fill + Clip
+     * 101 Stroke + Clip
+     * 110 Fill + Stroke + Clip
+     * 111 Clip
+     *
+     * Therefore: Fill corresponds to the low bit being 0; Clip
+     * corresponds to the hight bit being 1; and Stroke corresponds
+     * to the middle xor low bit being 1.
+     */
+    public void setMode(int m) {
+        int mode = 0;
+
+        if ((m & 0x1) == 0) {
+            mode |= PDFShapeCmd.FILL;
+        }
+        if ((m & 0x4) != 0) {
+            mode |= PDFShapeCmd.CLIP;
+        }
+        if (((m & 0x1) ^ ((m & 0x2) >> 1)) != 0) {
+            mode |= PDFShapeCmd.STROKE;
+        }
+
+        this.tm = mode;
+    }
+
+    /**
+     * Set the mode from another text format mode
+     *
+     * @param mode the text render mode using the
+     * codes from PDFShapeCmd and not the wacky PDF codes
+     */
+    public void setTextFormatMode(int mode) {
+        this.tm = mode;
+    }
+
+    /**
+     * Get the rise
+     */
+    public float getRise() {
+        return tr;
+    }
+
+    /**
+     * set the rise
+     */
+    public void setRise(float spc) {
+        this.tr = spc;
+    }
+
+    /**
+     * perform a carriage return
+     */
+    public void carriageReturn() {
+        carriageReturn(0, -tl);
+    }
+
+    /**
+     * perform a carriage return by translating by x and y.  The next
+     * carriage return will be relative to the new location.
+     */
+    public void carriageReturn(float x, float y) {
+    	Matrix trans = new Matrix();
+    	trans.setTranslate(x, y);
+        line.preConcat(trans);
+        cur.set(line);
+    }
+
+    /**
+     * Get the current transform
+     */
+    public Matrix getTransform() {
+        return cur;
+    }
+
+    /**
+     * set the transform matrix directly
+     */
+    public void setMatrix(float[] matrix) {
+        line = new Matrix();
+        Utils.setMatValues(line, matrix);
+        cur.set(line);
+    }
+
+    /**
+     * add some text to the page.
+     * @param cmds the PDFPage to add the commands to
+     * @param text the text to add
+     */
+    public void doText(PDFPage cmds, String text) {
+        PointF zero = new PointF();
+        Matrix scale = new Matrix();
+        Utils.setMatValues(scale, fsize, 0, 0, fsize * th, 0, tr);
+        Matrix at = new Matrix();
+
+        List l = font.getGlyphs(text);
+
+        for (Iterator i = l.iterator(); i.hasNext();) {
+            PDFGlyph glyph = (PDFGlyph) i.next();
+
+            at.set(cur);
+            at.preConcat(scale);
+            PointF advance = glyph.addCommands(cmds, at, tm);
+
+            float advanceX = (advance.x * fsize) + tc;
+            if (glyph.getChar() == ' ') {
+                advanceX += tw;
+            }
+            advanceX *= th;
+
+            cur.preTranslate(advanceX, advance.y);
+        }
+
+        float[] src = {zero.x, zero.y};
+        float[] dst = new float[src.length];
+        cur.mapPoints(dst, src);
+        prevEnd.set(dst[0], dst[1]);
+    }
+
+    /**
+     * add some text to the page.
+     * @param cmds the PDFPage to add the commands to
+     * @param ary an array of Strings and Doubles, where the Strings
+     * represent text to be added, and the Doubles represent kerning
+     * amounts.
+     */
+    public void doText(PDFPage cmds, Object ary[]) throws PDFParseException {
+        for (int i = 0; i < ary.length; i++) {
+            if (ary[i] instanceof String) {
+                doText(cmds, (String) ary[i]);
+            } else if (ary[i] instanceof Double) {
+                float val = ((Double) ary[i]).floatValue() / 1000f;
+                cur.preTranslate(-val * fsize * th, 0);
+            } else {
+                throw new PDFParseException("Bad element in TJ array");
+            }
+        }
+    }
+
+    /**
+     * finish any unfinished words.  TODO: write this!
+     */
+    public void flush() {
+        // TODO: finish any unfinished words
+    }
+
+    /** 
+     * Clone the text format
+     */
+    @Override
+    public Object clone() {
+        PDFTextFormat newFormat = new PDFTextFormat();
+
+        // copy values
+        newFormat.setCharSpacing(getCharSpacing());
+        newFormat.setWordSpacing(getWordSpacing());
+        newFormat.setHorizontalScale(getHorizontalScale());
+        newFormat.setLeading(getLeading());
+        newFormat.setTextFormatMode(getMode());
+        newFormat.setRise(getRise());
+
+        // copy immutable fields
+        newFormat.setFont(getFont(), getFontSize());
+
+        // clone transform (mutable)
+        // newFormat.getTransform().setTransform(getTransform());
+
+        return newFormat;
+    }
+}

src/com/sun/pdfview/PDFXref.java

@@ -0,0 +1,115 @@
+/*
+ * $Id: PDFXref.java,v 1.4 2009/02/12 13:53:56 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview;
+
+import java.lang.ref.SoftReference;
+
+/**
+ * a cross reference representing a line in the PDF cross referencing
+ * table.
+ * <p>
+ * There are two forms of the PDFXref, destinguished by absolutely nothing.
+ * The first type of PDFXref is used as indirect references in a PDFObject.
+ * In this type, the id is an index number into the object cross reference
+ * table.  The id will range from 0 to the size of the cross reference
+ * table.
+ * <p>
+ * The second form is used in the Java representation of the cross reference
+ * table.  In this form, the id is the file position of the start of the
+ * object in the PDF file.  See the use of both of these in the 
+ * PDFFile.dereference() method, which takes a PDFXref of the first form,
+ * and uses (internally) a PDFXref of the second form.
+ * <p>
+ * This is an unhappy state of affairs, and should be fixed.  Fortunatly,
+ * the two uses have already been factored out as two different methods.
+ *
+ * @author Mike Wessler
+ */
+public class PDFXref {
+
+    private int id;
+    private int generation;
+    // this field is only used in PDFFile.objIdx
+    private SoftReference<PDFObject> reference = null;
+
+    /**
+     * create a new PDFXref, given a parsed id and generation.
+     */
+    public PDFXref(int id, int gen) {
+        this.id = id;
+        this.generation = gen;
+    }
+
+    /**
+     * create a new PDFXref, given a sequence of bytes representing the
+     * fixed-width cross reference table line
+     */
+    public PDFXref(byte[] line) {
+        if (line == null) {
+            id = -1;
+            generation = -1;
+        } else {
+            id = Integer.parseInt(new String(line, 0, 10));
+            generation = Integer.parseInt(new String(line, 11, 5));
+        }
+    }
+
+    /**
+     * get the character index into the file of the start of this object
+     */
+    public int getFilePos() {
+        return id;
+    }
+
+    /**
+     * get the generation of this object
+     */
+    public int getGeneration() {
+        return generation;
+    }
+
+    /**
+     * get the object number of this object
+     */
+    public int getID() {
+        return id;
+    }
+
+    /**
+     * Get the object this reference refers to, or null if it hasn't been
+     * set.
+     * @return the object if it exists, or null if not
+     */
+    public PDFObject getObject() {
+        if (reference != null) {
+            return (PDFObject) reference.get();
+        }
+
+        return null;
+    }
+
+    /**
+     * Set the object this reference refers to.
+     */
+    public void setObject(PDFObject obj) {
+        this.reference = new SoftReference<PDFObject>(obj);
+    }
+}

src/com/sun/pdfview/RefImage.java

@@ -0,0 +1,57 @@
+/*
+ * $Id: RefImage.java,v 1.3 2009/01/16 16:26:10 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview;
+
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Bitmap.Config;
+
+
+/**
+ * A BufferedImage subclass that holds a strong reference to its graphics 
+ * object.  This means that the graphics will never go away as long as 
+ * someone holds a reference to this image, and createGraphics() and
+ * getGraphics() can be called multiple times safely, and will always return
+ * the same graphics object.
+ */
+public class RefImage {
+
+    /** a strong reference to the graphics object */
+	private Bitmap bi;
+    private Canvas g;
+
+    /** Creates a new instance of RefImage */
+    public RefImage(int width, int height, Config config) {
+    	bi = Bitmap.createBitmap(width, height, config);
+    }
+
+    /** 
+     * Create a graphics object only if it is currently null, otherwise
+     * return the existing graphics object.
+     */
+    public Canvas createGraphics() {
+        if (g == null) {
+            g = new Canvas(bi);
+        }
+
+        return g;
+    }
+}

src/com/sun/pdfview/Watchable.java

@@ -0,0 +1,73 @@
+/*
+ * $Id: Watchable.java,v 1.3 2009/01/16 16:26:15 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview;
+
+/**
+ * An interface for rendering or parsing, which can be stopped and started.
+ */
+public interface Watchable {
+
+    /** the possible statuses */
+    public static final int UNKNOWN = 0;
+    public static final int NOT_STARTED = 1;
+    public static final int PAUSED = 2;
+    public static final int NEEDS_DATA = 3;
+    public static final int RUNNING = 4;
+    public static final int STOPPED = 5;
+    public static final int COMPLETED = 6;
+    public static final int ERROR = 7;
+
+    /**
+     * Get the status of this watchable
+     *
+     * @return one of the well-known statuses
+     */
+    public int getStatus();
+
+    /**
+     * Stop this watchable.  Stop will cause all processing to cease,
+     * and the watchable to be destroyed.
+     */
+    public void stop();
+
+    /**
+     * Start this watchable and run until it is finished or stopped.
+     * Note the watchable may be stopped if go() with a
+     * different time is called during execution.
+     */
+    public void go();
+
+    /**
+     * Start this watchable and run for the given number of steps or until
+     * finished or stopped.
+     *
+     * @param steps the number of steps to run for
+     */
+    public void go(int steps);
+
+    /**
+     * Start this watchable and run for the given amount of time, or until
+     * finished or stopped.
+     *
+     * @param millis the number of milliseconds to run for
+     */
+    public void go(long millis);
+}

src/com/sun/pdfview/action/GoToAction.java

@@ -0,0 +1,70 @@
+/*
+ * $Id: GoToAction.java,v 1.2 2007/12/20 18:33:34 rbair Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package com.sun.pdfview.action;
+
+import java.io.IOException;
+
+import com.sun.pdfview.PDFObject;
+import com.sun.pdfview.PDFDestination;
+import com.sun.pdfview.PDFParseException;
+
+/**
+ * An action which specifies going to a particular destination
+ */
+public class GoToAction extends PDFAction {
+    /** the destination to go to */
+    private PDFDestination dest;
+    
+    /** 
+     * Creates a new instance of GoToAction from an object
+     *
+     * @param obj the PDFObject with the action information
+     */
+    public GoToAction(PDFObject obj, PDFObject root) throws IOException {
+        super("GoTo");
+        
+        // find the destination
+        PDFObject destObj = obj.getDictRef("D");
+        if (destObj == null) {
+            throw new PDFParseException("No destination in GoTo action " + obj);
+        }
+        
+        // parse it
+        dest = PDFDestination.getDestination(destObj, root);
+    }
+    
+    /**
+     * Create a new GoToAction from a destination
+     */
+    public GoToAction(PDFDestination dest) {
+        super("GoTo");
+    
+        this.dest = dest;
+    }
+      
+    /**
+     * Get the destination this action refers to
+     */
+    public PDFDestination getDestination() {
+        return dest;
+    }
+}

src/com/sun/pdfview/action/PDFAction.java

@@ -0,0 +1,100 @@
+/*
+ * $Id: PDFAction.java,v 1.2 2007/12/20 18:33:34 rbair Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package com.sun.pdfview.action;
+
+import java.io.IOException;
+
+import com.sun.pdfview.PDFObject;
+import com.sun.pdfview.PDFParseException;
+
+/**
+ * The common super-class of all PDF actions.
+ */
+public class PDFAction {
+    /** the type of this action */
+    private String type;
+    
+    /** the next action or array of actions */
+    private PDFObject next;
+    
+    /** Creates a new instance of PDFAction */
+    public PDFAction(String type) {
+        this.type = type;
+    }
+    
+    /**
+     * Get an action of the appropriate type from a PDFObject
+     *
+     * @param obj the PDF object containing the action to parse
+     * @param root the root of the PDF object tree
+     */
+    public static PDFAction getAction(PDFObject obj, PDFObject root)
+        throws IOException
+    {
+        // figure out the action type
+        PDFObject typeObj = obj.getDictRef("S");
+        if (typeObj == null) {
+            throw new PDFParseException("No action type in object: " + obj);
+        }
+        
+        // create the action based on the type
+        PDFAction action = null;
+        String type = typeObj.getStringValue();
+        if (type.equals("GoTo")) {
+            action = new GoToAction(obj, root);
+        } else {
+            /** [JK FIXME: Implement other action types! ] */
+            throw new PDFParseException("Unknown Action type: " + type);
+        }
+        
+        // figure out if there is a next action
+        PDFObject nextObj = obj.getDictRef("Next");
+        if (nextObj != null) {
+            action.setNext(nextObj);
+        }
+        
+        // return the action
+        return action;
+    }
+    
+    /**
+     * Get the type of this action
+     */
+    public String getType() {
+        return type;
+    }
+    
+    /**
+     * Get the next action or array of actions
+     */
+    public PDFObject getNext() {
+        return next;
+    }
+    
+    /**
+     * Set the next action or array of actions
+     */
+    public void setNext(PDFObject next) {
+        this.next = next;
+    }
+    
+}

src/com/sun/pdfview/colorspace/GrayColorSpace.java

@@ -0,0 +1,60 @@
+/*
+ * $Id: CalRGBColor.java,v 1.2 2007/12/20 18:33:34 rbair Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package com.sun.pdfview.colorspace;
+
+import android.graphics.Color;
+
+
+public class GrayColorSpace extends PDFColorSpace {
+	
+    public GrayColorSpace() {
+    }
+
+    /**
+     * get the number of components (3)
+     */
+    @Override public int getNumComponents() {
+	return 1;
+    }
+
+    @Override public int toColor(float[] fcomp) {
+    	return Color.rgb((int)(fcomp[0]*255),(int)(fcomp[0]*255),(int)(fcomp[0]*255));
+    }
+
+    @Override public int toColor(int[] icomp) {
+    	return Color.rgb(icomp[0],icomp[0],icomp[0]);
+    }
+
+    
+    /**
+     * get the type of this color space (TYPE_RGB)
+     */
+    @Override public int getType() {
+	return COLORSPACE_GRAY;
+    }
+
+	@Override
+	public String getName() {
+		return "G";
+	}
+
+}

src/com/sun/pdfview/colorspace/IndexedColor.java

@@ -0,0 +1,125 @@
+/*
+ * $Id: IndexedColor.java,v 1.4 2009/01/26 05:40:42 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview.colorspace;
+
+import java.io.IOException;
+
+import com.sun.pdfview.PDFObject;
+import com.sun.pdfview.PDFPaint;
+
+/**
+ * A PDFColorSpace for an IndexedColor model
+ *
+ * @author Mike Wessler
+ */
+public class IndexedColor extends PDFColorSpace {
+
+    /** the color table */
+    int table[];
+    /** size of the color table */
+    int count;
+
+    /**
+     * create a new IndexColor PDFColorSpace based on another PDFColorSpace,
+     * a count of colors, and a stream of values.  Every consecutive n bytes
+     * of the stream is interpreted as a color in the base ColorSpace, where
+     * n is the number of components in that color space.
+     *
+     * @param base the color space in which the data is interpreted
+     * @param count the number of colors in the table
+     * @param stream a stream of bytes.  The number of bytes must be count*n,
+     * where n is the number of components in the base colorspace.
+     */
+    public IndexedColor(PDFColorSpace base, int count, PDFObject stream) throws IOException {
+        count++;
+        this.count = count;
+        byte[] data = stream.getStream();
+        int nchannels = base.getNumComponents();
+        boolean offSized = (data.length / nchannels) < count;
+        table = new int[count];
+        float comps[] = new float[nchannels];
+        int loc = 0;
+        int finalloc = 0;
+        for (int i = 0; i < count; i++) {
+            for (int j = 0; j < comps.length; j++) {
+                if (loc < data.length) {
+                    comps[j] = (((int) data[loc++]) & 0xff) / 255f;
+                } else {
+                    comps[j] = 1.0f;
+                }
+            }
+            table[i] = base.toColor(comps);
+        }
+    }
+
+    /**
+     * create a new IndexColor PDFColorSpace based on a table of colors.  
+     * 
+     * @param table an array of colors
+     */
+    public IndexedColor(int[] table) throws IOException {
+        this.count = table.length;
+        this.table = table;
+    }
+
+    /**
+     * Get the number of indices
+     */
+    public int getCount() {
+        return count;
+    }
+
+    /**
+     * Get the table of color components
+     */
+    public int[] getColorTable() {
+        return table;
+    }
+
+    /**
+     * get the number of components of this colorspace (1)
+     */
+    @Override
+    public int getNumComponents() {
+        return 1;
+    }
+
+	@Override
+	public String getName() {
+		return "I";
+	}
+
+	@Override
+	public int getType() {
+		return COLORSPACE_INDEXED;
+	}
+
+	@Override
+	public int toColor(float[] comp) {
+		return table[(int)(255*comp[0])];
+	}
+	
+	@Override
+	public int toColor(int[] comp) {
+		return table[comp[0]];
+	}
+	
+}

src/com/sun/pdfview/colorspace/PDFColorSpace.java

@@ -0,0 +1,209 @@
+/*
+ * $Id: PDFColorSpace.java,v 1.5 2009/03/08 20:46:16 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview.colorspace;
+
+import java.io.IOException;
+import java.util.Map;
+
+import com.sun.pdfview.PDFObject;
+import com.sun.pdfview.PDFPaint;
+import com.sun.pdfview.PDFParseException;
+
+
+/**
+ * A color space that can convert a set of color components into
+ * PDFPaint.
+ * @author Mike Wessler
+ */
+public abstract class PDFColorSpace {
+	
+    /** the name of the device-dependent gray color space */
+    public static final int COLORSPACE_GRAY = 0;
+
+    /** the name of the device-dependent RGB color space */
+    public static final int COLORSPACE_RGB = 1;
+
+    /** the name of the device-dependent CMYK color space */
+    public static final int COLORSPACE_CMYK = 2;
+
+    /** the name of the pattern color space */
+    public static final int COLORSPACE_PATTERN = 3;
+
+    public static final int COLORSPACE_INDEXED = 4;
+
+    /** the device-dependent color spaces */
+    //    private static PDFColorSpace graySpace =
+    //            new PDFColorSpace(ColorSpace.getInstance(ColorSpace.CS_GRAY));
+    private static PDFColorSpace rgbSpace = new RGBColorSpace();
+    private static PDFColorSpace cmykSpace = new RGBColorSpace(); // TODO [FHe]
+
+    /** the pattern space */
+    private static PDFColorSpace patternSpace = new RGBColorSpace(); // TODO [FHe]
+
+    /** graySpace and the gamma correction for it. */
+    private static PDFColorSpace graySpace = new GrayColorSpace(); 
+
+
+    /**
+     * create a PDFColorSpace based on a Java ColorSpace
+     * @param cs the Java ColorSpace
+     */
+    protected PDFColorSpace() {
+    }
+
+    /**
+     * Get a color space by name
+     *
+     * @param name the name of one of the device-dependent color spaces
+     */
+    public static PDFColorSpace getColorSpace(int name) {
+        switch (name) {
+        case COLORSPACE_GRAY:
+            return graySpace;
+
+        case COLORSPACE_RGB:
+            return rgbSpace;
+
+        case COLORSPACE_CMYK:
+            return cmykSpace;
+
+        case COLORSPACE_PATTERN:
+            return patternSpace;
+
+        default:
+            throw new IllegalArgumentException("Unknown Color Space name: " +
+                name);
+        }
+    }
+
+    /**
+     * Get a color space specified in a PDFObject
+     *
+     * @param csobj the PDFObject with the colorspace information
+     */
+    public static PDFColorSpace getColorSpace(PDFObject csobj, Map resources)
+        throws IOException {
+        String name;
+
+        PDFObject colorSpaces = null;
+
+        if (resources != null) {
+            colorSpaces = (PDFObject) resources.get("ColorSpace");
+        }
+
+        if (csobj.getType() == PDFObject.NAME) {
+            name = csobj.getStringValue();
+
+            if (name.equals("DeviceGray") || name.equals("G")) {
+                return getColorSpace(COLORSPACE_GRAY);
+            } else if (name.equals("DeviceRGB") || name.equals("RGB")) {
+                return getColorSpace(COLORSPACE_RGB);
+            } else if (name.equals("DeviceCMYK") || name.equals("CMYK")) {
+                return getColorSpace(COLORSPACE_CMYK);
+            } else if (name.equals("Pattern")) {
+                return getColorSpace(COLORSPACE_PATTERN);
+            } else if (colorSpaces != null) {
+                csobj = (PDFObject) colorSpaces.getDictRef(name);
+            }
+        }
+
+        if (csobj == null) {
+            return null;
+        } else if (csobj.getCache() != null) {
+            return (PDFColorSpace) csobj.getCache();
+        }
+
+        PDFColorSpace value = null;
+
+        // csobj is [/name <<dict>>]
+        PDFObject[] ary = csobj.getArray();
+        name = ary[0].getStringValue();
+
+        if (name.equals("CalGray")) {
+            value = graySpace; // TODO [FHe]
+        } else if (name.equals("CalRGB")) {
+            value = rgbSpace; // TODO [FHe]
+        } else if (name.equals("Lab")) {
+            value = rgbSpace; // TODO [FHe]
+        } else if (name.equals("ICCBased")) {
+            value = rgbSpace; // TODO [FHe]
+        } else if (name.equals("Separation") || name.equals("DeviceN")) {
+            value = rgbSpace; // TODO [FHe]
+        } else if (name.equals("Indexed") || name.equals("I")) {
+            /**
+             * 4.5.5 [/Indexed baseColor hival lookup]
+             */
+            PDFColorSpace refspace = getColorSpace(ary[1], resources);
+
+            // number of indices= ary[2], data is in ary[3];
+            int count = ary[2].getIntValue();
+            value = new IndexedColor(refspace, count, ary[3]);
+        } else if (name.equals("Pattern")) {
+            return rgbSpace; // TODO [FHe]
+        } else {
+            throw new PDFParseException("Unknown color space: " + name +
+                " with " + ary[1]);
+        }
+
+        csobj.setCache(value);
+
+        return value;
+    }
+
+    /**
+     * get the number of components expected in the getPaint command
+     */
+    public abstract int getNumComponents();
+
+    /**
+     * get the PDFPaint representing the color described by the
+     * given color components
+     * @param components the color components corresponding to the given
+     * colorspace
+     * @return a PDFPaint object representing the closest Color to the
+     * given components.
+     */
+    public PDFPaint getPaint(float[] components) {
+		return PDFPaint.getColorPaint(toColor(components));
+    }
+    public PDFPaint getFillPaint(float[] components) {
+		return PDFPaint.getPaint(toColor(components));
+    }
+
+    /**
+     * get the type of this color space
+     */
+    public abstract int getType();
+    /**
+     * get the name of this color space
+     */
+    public abstract String getName();
+
+	public abstract int toColor(float[] fcomp);
+	
+	public abstract int toColor(int[] icomp);
+    
+	@Override
+	public String toString() {
+		return "ColorSpace["+getName()+"]";
+	}
+
+}

src/com/sun/pdfview/colorspace/RGBColorSpace.java

@@ -0,0 +1,61 @@
+/*
+ * $Id: CalRGBColor.java,v 1.2 2007/12/20 18:33:34 rbair Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package com.sun.pdfview.colorspace;
+
+import android.graphics.Color;
+
+
+public class RGBColorSpace extends PDFColorSpace {
+	
+    public RGBColorSpace() {
+    }
+
+    /**
+     * get the number of components (3)
+     */
+    @Override public int getNumComponents() {
+    	return 3;
+    }
+
+    @Override public int toColor(float[] fcomp) {
+    	return Color.rgb((int)(fcomp[0]*255),(int)(fcomp[1]*255),(int)(fcomp[2]*255));
+    }
+
+    @Override public int toColor(int[] icomp) {
+    	return Color.rgb(icomp[0],icomp[1],icomp[2]);
+    }
+
+    
+    /**
+     * get the type of this color space (TYPE_RGB)
+     */
+    @Override public int getType() {
+    	return COLORSPACE_RGB;
+    }
+
+	@Override
+	public String getName() {
+		return "RGB";
+	}
+
+
+}

src/com/sun/pdfview/decode/ASCII85Decode.java

@@ -0,0 +1,154 @@
+/*
+ * $Id: ASCII85Decode.java,v 1.3 2009/02/22 00:52:35 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview.decode;
+
+import java.io.ByteArrayOutputStream;
+
+import net.sf.andpdf.pdfviewer.ByteBuffer;
+
+import com.sun.pdfview.PDFFile;
+import com.sun.pdfview.PDFObject;
+import com.sun.pdfview.PDFParseException;
+
+/**
+ * decode ASCII85 text into a byte array.
+ * 
+ * @author Mike Wessler
+ */
+public class ASCII85Decode {
+
+    private ByteBuffer buf;
+
+    /**
+     * initialize the decoder with byte buffer in ASCII85 format
+     */
+    private ASCII85Decode(ByteBuffer buf) {
+        this.buf = buf;
+    }
+
+    /**
+     * get the next character from the input.
+     * @return the next character, or -1 if at end of stream
+     */
+    private int nextChar() {
+        // skip whitespace
+        // returns next character, or -1 if end of stream
+        while (buf.remaining() > 0) {
+            char c = (char) buf.get();
+
+            if (!PDFFile.isWhiteSpace(c)) {
+                return c;
+            }
+        }
+
+        // EOF reached
+        return -1;
+    }
+
+    /**
+     * decode the next five ASCII85 characters into up to four decoded
+     * bytes.  Return false when finished, or true otherwise.
+     *
+     * @param baos the ByteArrayOutputStream to write output to, set to the
+     *        correct position
+     * @return false when finished, or true otherwise.
+     */
+    private boolean decode5(ByteArrayOutputStream baos)
+            throws PDFParseException {
+        // stream ends in ~>
+        int[] five = new int[5];
+        int i;
+        for (i = 0; i < 5; i++) {
+            five[i] = nextChar();
+            if (five[i] == '~') {
+                if (nextChar() == '>') {
+                    break;
+                } else {
+                    throw new PDFParseException("Bad character in ASCII85Decode: not ~>");
+                }
+            } else if (five[i] >= '!' && five[i] <= 'u') {
+                five[i] -= '!';
+            } else if (five[i] == 'z') {
+                if (i == 0) {
+                    five[i] = 0;
+                    i = 4;
+                } else {
+                    throw new PDFParseException("Inappropriate 'z' in ASCII85Decode");
+                }
+            } else {
+                throw new PDFParseException("Bad character in ASCII85Decode: " + five[i] + " (" + (char) five[i] + ")");
+            }
+        }
+
+        if (i > 0) {
+            i -= 1;
+        }
+
+        int value =
+                five[0] * 85 * 85 * 85 * 85 +
+                five[1] * 85 * 85 * 85 +
+                five[2] * 85 * 85 +
+                five[3] * 85 +
+                five[4];
+
+        for (int j = 0; j < i; j++) {
+            int shift = 8 * (3 - j);
+            baos.write((byte) ((value >> shift) & 0xff));
+        }
+
+        return (i == 4);
+    }
+
+    /**
+     * decode the bytes
+     * @return the decoded bytes
+     */
+    private ByteBuffer decode() throws PDFParseException {
+        // start from the beginning of the data
+        buf.rewind();
+
+        // allocate the output buffer
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+
+        // decode the bytes 
+        while (decode5(baos)) {
+        }
+
+        return ByteBuffer.wrap(baos.toByteArray());
+    }
+
+    /**
+     * decode an array of bytes in ASCII85 format.
+     * <p>
+     * In ASCII85 format, every 5 characters represents 4 decoded
+     * bytes in base 85.  The entire stream can contain whitespace,
+     * and ends in the characters '~&gt;'.
+     *
+     * @param buf the encoded ASCII85 characters in a byte buffer
+     * @param params parameters to the decoder (ignored)
+     * @return the decoded bytes
+     */
+    public static ByteBuffer decode(ByteBuffer buf, PDFObject params)
+            throws PDFParseException {
+        ASCII85Decode me = new ASCII85Decode(buf);
+        return me.decode();
+    }
+}

src/com/sun/pdfview/decode/ASCIIHexDecode.java

@@ -0,0 +1,128 @@
+/*
+ * $Id: ASCIIHexDecode.java,v 1.2 2007/12/20 18:33:32 rbair Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package com.sun.pdfview.decode;
+
+import java.io.ByteArrayOutputStream;
+
+import net.sf.andpdf.pdfviewer.ByteBuffer;
+
+import com.sun.pdfview.PDFObject;
+import com.sun.pdfview.PDFParseException;
+import com.sun.pdfview.PDFFile;
+
+/**
+ * decode an array of hex nybbles into a byte array
+ *
+ * @author Mike Wessler
+ */
+public class ASCIIHexDecode {
+    private ByteBuffer buf;
+    
+    /**
+     * initialize the decoder with an array of bytes in ASCIIHex format
+     */
+    private ASCIIHexDecode(ByteBuffer buf) {
+	this.buf = buf;
+    }
+
+    /**
+     * get the next character from the input
+     * @return a number from 0-15, or -1 for the end character
+     */
+    private int readHexDigit() throws PDFParseException {    
+        // read until we hit a non-whitespace character or the
+        // end of the stream
+        while (buf.remaining() > 0) {
+            int c = (int) buf.get();
+        
+            // see if we found a useful character
+            if (!PDFFile.isWhiteSpace((char) c)) {
+                if (c >= '0' && c <= '9') {
+                    c -= '0';
+                } else if (c >= 'a' && c <= 'f') {
+                    c -= 'a' - 10;
+                } else if (c >= 'A' && c <= 'F') {
+                    c -= 'A' - 10;
+                } else if (c == '>') {
+                    c = -1;
+                } else {
+                    // unknown character
+                    throw new PDFParseException("Bad character " + c + 
+                                                "in ASCIIHex decode");
+                }
+                
+                // return the useful character
+                return c;
+            }
+        }
+        
+        // end of stream reached
+	throw new PDFParseException("Short stream in ASCIIHex decode");
+    }
+
+    /**
+     * decode the array
+     * @return the decoded bytes
+     */
+    private ByteBuffer decode() throws PDFParseException {
+        // start at the beginning of the buffer
+        buf.rewind();
+        
+        // allocate the output buffer
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        
+        while (true) {
+	    int first = readHexDigit();
+	    int second = readHexDigit();
+	    
+            if (first == -1) {
+                break;
+	    } else if (second == -1) {
+		baos.write((byte) (first << 4));
+		break;
+	    } else {
+                baos.write((byte) ((first << 4) + second));
+	    }
+	}
+        
+        return ByteBuffer.wrap(baos.toByteArray());
+    }
+
+    /**
+     * decode an array of bytes in ASCIIHex format.
+     * <p>
+     * ASCIIHex format consists of a sequence of Hexidecimal
+     * digits, with possible whitespace, ending with the
+     * '&gt;' character.
+     * 
+     * @param buf the encoded ASCII85 characters in a byte
+     *        buffer
+     * @param params parameters to the decoder (ignored)
+     * @return the decoded bytes
+     */
+    public static ByteBuffer decode(ByteBuffer buf, PDFObject params)
+	throws PDFParseException 
+    {
+	ASCIIHexDecode me = new ASCIIHexDecode(buf);
+	return me.decode();
+    }
+}

src/com/sun/pdfview/decode/CCITTCodes

@@ -0,0 +1,236 @@
+
+# $Id: CCITTCodes,v 1.2 2007/12/20 18:33:33 rbair Exp $
+#
+# Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+# Santa Clara, California 95054, U.S.A. All rights reserved.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+# 
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+
+# WHITE CODES
+00110101 0
+000111 1
+0111 2
+1000 3
+1011 4
+1100 5
+1110 6
+1111 7
+10011 8
+10100 9
+00111 10
+01000 11
+001000 12
+000011 13
+110100 14
+110101 15
+101010 16
+101011 17
+0100111 18
+0001100 19
+0001000 20
+0010111 21
+0000011 22
+0000100 23
+0101000 24
+0101011 25
+0010011 26
+0100100 27
+0011000 28
+00000010 29
+00000011 30
+00011010 31
+00011011 32
+00010010 33
+00010011 34
+00010100 35
+00010101 36
+00010110 37
+00010111 38
+00101000 39
+00101001 40
+00101010 41
+00101011 42
+00101100 43
+00101101 44
+00000100 45
+00000101 46
+00001010 47
+00001011 48
+01010010 49
+01010011 50
+01010100 51
+01010101 52
+00100100 53
+00100101 54
+01011000 55
+01011001 56
+01011010 57
+01011011 58
+01001010 59
+01001011 60
+00110010 61
+00110011 62
+00110100 63
+11011 64
+10010 128
+010111 192
+0110111 256
+00110110 320
+00110111 384
+01100100 448
+01100101 512
+01101000 576
+01100111 640
+011001100 704
+011001101 768
+011010010 832
+011010011 896
+011010100 960
+011010101 1024
+011010110 1088
+011010111 1152
+011011000 1216
+011011001 1280
+011011010 1344
+011011011 1408
+010011000 1472
+010011001 1536
+010011010 1600
+011000 1664
+010011011 1728
+00000001000 1792
+00000001100 1856
+00000001101 1920
+000000010010 1984
+000000010011 2048
+000000010100 2112
+000000010101 2176
+000000010110 2240
+000000010111 2304
+000000011100 2368
+000000011101 2432
+000000011110 2496
+000000011111 2560
+000000001111 -2
+0000000000 -1
+
+# BLACK CODES
+0000110111 0
+010 1
+11 2
+10 3
+011 4
+0011 5
+0010 6
+00011 7
+000101 8
+000100 9
+0000100 10
+0000101 11
+0000111 12
+00000100 13
+00000111 14
+000011000 15
+0000010111 16
+0000011000 17
+0000001000 18
+00001100111 19
+00001101000 20
+00001101100 21
+00000110111 22
+00000101000 23
+00000010111 24
+00000011000 25
+000011001010 26
+000011001011 27
+000011001100 28
+000011001101 29
+000001101000 30
+000001101001 31
+000001101010 32
+000001101011 33
+000011010010 34
+000011010011 35
+000011010100 36
+000011010101 37
+000011010110 38
+000011010111 39
+000001101100 40
+000001101101 41
+000011011010 42
+000011011011 43
+000001010100 44
+000001010101 45
+000001010110 46
+000001010111 47
+000001100100 48
+000001100101 49
+000001010010 50
+000001010011 51
+000000100100 52
+000000110111 53
+000000111000 54
+000000100111 55
+000000101000 56
+000001011000 57
+000001011001 58
+000000101011 59
+000000101100 60
+000001011010 61
+000001100110 62
+000001100111 63
+0000001111 64
+000011001000 128
+000011001001 192
+000001011011 256
+000000110011 320
+000000110100 384
+000000110101 448
+0000001101100 512
+0000001101101 576
+0000001001010 640
+0000001001011 704
+0000001001100 768
+0000001001101 832
+0000001110010 896
+0000001110011 960
+0000001110100 1024
+0000001110101 1088
+0000001110110 1152
+0000001110111 1216
+0000001010010 1280
+0000001010011 1344
+0000001010100 1408
+0000001010101 1472
+0000001011010 1536
+0000001011011 1600
+0000001100100 1664
+0000001100101 1728
+00000001000 1792
+00000001100 1856
+00000001101 1920
+000000010010 1984
+000000010011 2048
+000000010100 2112
+000000010101 2176
+000000010110 2240
+000000010111 2304
+000000011100 2368
+000000011101 2432
+000000011110 2496
+000000011111 2560
+000000001111 -2
+00000000000 -1

src/com/sun/pdfview/decode/CCITTFaxDecode.java

@@ -0,0 +1,96 @@
+package com.sun.pdfview.decode;
+
+import java.io.IOException;
+
+import net.sf.andpdf.pdfviewer.ByteBuffer;
+
+import com.sun.pdfview.PDFObject;
+
+public class CCITTFaxDecode {
+
+
+
+	protected static ByteBuffer decode(PDFObject dict, ByteBuffer buf,
+            PDFObject params) throws IOException {
+
+		byte[] bytes = new byte[buf.remaining()];
+	    buf.get(bytes, 0, bytes.length);
+		return ByteBuffer.wrap(decode(dict, bytes));
+	}
+
+
+	protected static byte[] decode(PDFObject dict, byte[] source) throws IOException {
+		int width = 1728;
+		PDFObject widthDef = dict.getDictRef("Width");
+		if (widthDef == null) {
+			widthDef = dict.getDictRef("W");
+		}
+		if (widthDef != null) {
+			width = widthDef.getIntValue();
+		}
+		int height = 0;
+		PDFObject heightDef = dict.getDictRef("Height");
+		if (heightDef == null) {
+			heightDef = dict.getDictRef("H");
+		}
+		if (heightDef != null) {
+			height = heightDef.getIntValue();
+		}
+
+		//
+		int columns = getOptionFieldInt(dict, "Columns", width);
+		int rows = getOptionFieldInt(dict, "Rows", height);
+		int k = getOptionFieldInt(dict, "K", 0);
+		int size = rows * ((columns + 7) >> 3);
+		byte[] destination = new byte[size];
+
+		boolean align = getOptionFieldBoolean(dict, "EncodedByteAlign", false);
+
+		CCITTFaxDecoder decoder = new CCITTFaxDecoder(1, columns, rows);
+		decoder.setAlign(align);
+		if (k == 0) {
+			decoder.decodeT41D(destination, source, 0, rows);
+		} else if (k > 0) {
+			decoder.decodeT42D(destination, source, 0, rows);
+		} else if (k < 0) {
+			decoder.decodeT6(destination, source, 0, rows);
+		}
+		if (!getOptionFieldBoolean(dict, "BlackIs1", false)) {
+			for (int i = 0; i < destination.length; i++) {
+				// bitwise not
+				destination[i] = (byte) ~destination[i];
+			}
+		}
+
+		return destination;
+	}
+
+	public static int getOptionFieldInt(PDFObject dict, String name, int defaultValue) throws IOException {
+
+		PDFObject dictParams =  dict.getDictRef("DecodeParms");
+
+		if (dictParams == null) {
+			return defaultValue;
+		}
+		PDFObject value = dictParams.getDictRef(name);
+		if (value == null) {
+			return defaultValue;
+		}
+		return value.getIntValue();
+	}
+
+	public static boolean getOptionFieldBoolean(PDFObject dict, String name, boolean defaultValue) throws IOException {
+
+		PDFObject dictParams =  dict.getDictRef("DecodeParms");
+
+		if (dictParams == null) {
+			return defaultValue;
+		}
+		PDFObject value = dictParams.getDictRef(name);
+		if (value == null) {
+			return defaultValue;
+		}
+		return value.getBooleanValue();
+	}
+
+}

src/com/sun/pdfview/decode/CCITTFaxDecoder.java

@@ -0,0 +1,1575 @@
+/*
+ * Based on the SUN code (see license beyond) changes are made to handle CCITTFax encoded
+ * data in a PDF image. This may or may not apply to real world CCITT documents.
+ *
+ * Copyright (c) 2007, intarsys consulting GmbH
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ *
+ * - Neither the name of intarsys nor the names of its contributors may be used
+ *   to endorse or promote products derived from this software without specific
+ *   prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+/*
+ * Copyright (c) 2001 Sun Microsystems, Inc. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * -Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * -Redistribution in binary form must reproduct the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * Neither the name of Sun Microsystems, Inc. or the names of contributors may
+ * be used to endorse or promote products derived from this software without
+ * specific prior written permission.
+ *
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING ANY
+ * IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
+ * NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN AND ITS LICENSORS SHALL NOT BE
+ * LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
+ * OR DISTRIBUTING THE SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR ITS
+ * LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT,
+ * INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER
+ * CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF THE USE OF
+ * OR INABILITY TO USE SOFTWARE, EVEN IF SUN HAS BEEN ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGES.
+ *
+ * You acknowledge that Software is not designed,licensed or intended for use in
+ * the design, construction, operation or maintenance of any nuclear facility.
+ */
+package com.sun.pdfview.decode;
+
+public class CCITTFaxDecoder {
+	static int[] table1 = { 0x00, // 0 bits are left in first byte - SHOULD
+			// NOT HAPPEN
+			0x01, // 1 bits are left in first byte
+			0x03, // 2 bits are left in first byte
+			0x07, // 3 bits are left in first byte
+			0x0f, // 4 bits are left in first byte
+			0x1f, // 5 bits are left in first byte
+			0x3f, // 6 bits are left in first byte
+			0x7f, // 7 bits are left in first byte
+			0xff // 8 bits are left in first byte
+	};
+
+	static int[] table2 = { 0x00, // 0
+			0x80, // 1
+			0xc0, // 2
+			0xe0, // 3
+			0xf0, // 4
+			0xf8, // 5
+			0xfc, // 6
+			0xfe, // 7
+			0xff // 8
+	};
+
+	// Table to be used when fillOrder = 2, for flipping bytes.
+	static byte[] flipTable = { 0, -128, 64, -64, 32, -96, 96, -32, 16, -112,
+			80, -48, 48, -80, 112, -16, 8, -120, 72, -56, 40, -88, 104, -24,
+			24, -104, 88, -40, 56, -72, 120, -8, 4, -124, 68, -60, 36, -92,
+			100, -28, 20, -108, 84, -44, 52, -76, 116, -12, 12, -116, 76, -52,
+			44, -84, 108, -20, 28, -100, 92, -36, 60, -68, 124, -4, 2, -126,
+			66, -62, 34, -94, 98, -30, 18, -110, 82, -46, 50, -78, 114, -14,
+			10, -118, 74, -54, 42, -86, 106, -22, 26, -102, 90, -38, 58, -70,
+			122, -6, 6, -122, 70, -58, 38, -90, 102, -26, 22, -106, 86, -42,
+			54, -74, 118, -10, 14, -114, 78, -50, 46, -82, 110, -18, 30, -98,
+			94, -34, 62, -66, 126, -2, 1, -127, 65, -63, 33, -95, 97, -31, 17,
+			-111, 81, -47, 49, -79, 113, -15, 9, -119, 73, -55, 41, -87, 105,
+			-23, 25, -103, 89, -39, 57, -71, 121, -7, 5, -123, 69, -59, 37,
+			-91, 101, -27, 21, -107, 85, -43, 53, -75, 117, -11, 13, -115, 77,
+			-51, 45, -83, 109, -19, 29, -99, 93, -35, 61, -67, 125, -3, 3,
+			-125, 67, -61, 35, -93, 99, -29, 19, -109, 83, -45, 51, -77, 115,
+			-13, 11, -117, 75, -53, 43, -85, 107, -21, 27, -101, 91, -37, 59,
+			-69, 123, -5, 7, -121, 71, -57, 39, -89, 103, -25, 23, -105, 87,
+			-41, 55, -73, 119, -9, 15, -113, 79, -49, 47, -81, 111, -17, 31,
+			-97, 95, -33, 63, -65, 127, -1, };
+
+	// The main 10 bit white runs lookup table
+	static short white[] = {
+	// 0 - 7
+			6430, 6400, 6400, 6400, 3225, 3225, 3225, 3225,
+			// 8 - 15
+			944, 944, 944, 944, 976, 976, 976, 976,
+			// 16 - 23
+			1456, 1456, 1456, 1456, 1488, 1488, 1488, 1488,
+			// 24 - 31
+			718, 718, 718, 718, 718, 718, 718, 718,
+			// 32 - 39
+			750, 750, 750, 750, 750, 750, 750, 750,
+			// 40 - 47
+			1520, 1520, 1520, 1520, 1552, 1552, 1552, 1552,
+			// 48 - 55
+			428, 428, 428, 428, 428, 428, 428, 428,
+			// 56 - 63
+			428, 428, 428, 428, 428, 428, 428, 428,
+			// 64 - 71
+			654, 654, 654, 654, 654, 654, 654, 654,
+			// 72 - 79
+			1072, 1072, 1072, 1072, 1104, 1104, 1104, 1104,
+			// 80 - 87
+			1136, 1136, 1136, 1136, 1168, 1168, 1168, 1168,
+			// 88 - 95
+			1200, 1200, 1200, 1200, 1232, 1232, 1232, 1232,
+			// 96 - 103
+			622, 622, 622, 622, 622, 622, 622, 622,
+			// 104 - 111
+			1008, 1008, 1008, 1008, 1040, 1040, 1040, 1040,
+			// 112 - 119
+			44, 44, 44, 44, 44, 44, 44, 44,
+			// 120 - 127
+			44, 44, 44, 44, 44, 44, 44, 44,
+			// 128 - 135
+			396, 396, 396, 396, 396, 396, 396, 396,
+			// 136 - 143
+			396, 396, 396, 396, 396, 396, 396, 396,
+			// 144 - 151
+			1712, 1712, 1712, 1712, 1744, 1744, 1744, 1744,
+			// 152 - 159
+			846, 846, 846, 846, 846, 846, 846, 846,
+			// 160 - 167
+			1264, 1264, 1264, 1264, 1296, 1296, 1296, 1296,
+			// 168 - 175
+			1328, 1328, 1328, 1328, 1360, 1360, 1360, 1360,
+			// 176 - 183
+			1392, 1392, 1392, 1392, 1424, 1424, 1424, 1424,
+			// 184 - 191
+			686, 686, 686, 686, 686, 686, 686, 686,
+			// 192 - 199
+			910, 910, 910, 910, 910, 910, 910, 910,
+			// 200 - 207
+			1968, 1968, 1968, 1968, 2000, 2000, 2000, 2000,
+			// 208 - 215
+			2032, 2032, 2032, 2032, 16, 16, 16, 16,
+			// 216 - 223
+			10257, 10257, 10257, 10257, 12305, 12305, 12305, 12305,
+			// 224 - 231
+			330, 330, 330, 330, 330, 330, 330, 330,
+			// 232 - 239
+			330, 330, 330, 330, 330, 330, 330, 330,
+			// 240 - 247
+			330, 330, 330, 330, 330, 330, 330, 330,
+			// 248 - 255
+			330, 330, 330, 330, 330, 330, 330, 330,
+			// 256 - 263
+			362, 362, 362, 362, 362, 362, 362, 362,
+			// 264 - 271
+			362, 362, 362, 362, 362, 362, 362, 362,
+			// 272 - 279
+			362, 362, 362, 362, 362, 362, 362, 362,
+			// 280 - 287
+			362, 362, 362, 362, 362, 362, 362, 362,
+			// 288 - 295
+			878, 878, 878, 878, 878, 878, 878, 878,
+			// 296 - 303
+			1904, 1904, 1904, 1904, 1936, 1936, 1936, 1936,
+			// 304 - 311
+			-18413, -18413, -16365, -16365, -14317, -14317, -10221, -10221,
+			// 312 - 319
+			590, 590, 590, 590, 590, 590, 590, 590,
+			// 320 - 327
+			782, 782, 782, 782, 782, 782, 782, 782,
+			// 328 - 335
+			1584, 1584, 1584, 1584, 1616, 1616, 1616, 1616,
+			// 336 - 343
+			1648, 1648, 1648, 1648, 1680, 1680, 1680, 1680,
+			// 344 - 351
+			814, 814, 814, 814, 814, 814, 814, 814,
+			// 352 - 359
+			1776, 1776, 1776, 1776, 1808, 1808, 1808, 1808,
+			// 360 - 367
+			1840, 1840, 1840, 1840, 1872, 1872, 1872, 1872,
+			// 368 - 375
+			6157, 6157, 6157, 6157, 6157, 6157, 6157, 6157,
+			// 376 - 383
+			6157, 6157, 6157, 6157, 6157, 6157, 6157, 6157,
+			// 384 - 391
+			-12275, -12275, -12275, -12275, -12275, -12275, -12275, -12275,
+			// 392 - 399
+			-12275, -12275, -12275, -12275, -12275, -12275, -12275, -12275,
+			// 400 - 407
+			14353, 14353, 14353, 14353, 16401, 16401, 16401, 16401,
+			// 408 - 415
+			22547, 22547, 24595, 24595, 20497, 20497, 20497, 20497,
+			// 416 - 423
+			18449, 18449, 18449, 18449, 26643, 26643, 28691, 28691,
+			// 424 - 431
+			30739, 30739, -32749, -32749, -30701, -30701, -28653, -28653,
+			// 432 - 439
+			-26605, -26605, -24557, -24557, -22509, -22509, -20461, -20461,
+			// 440 - 447
+			8207, 8207, 8207, 8207, 8207, 8207, 8207, 8207,
+			// 448 - 455
+			72, 72, 72, 72, 72, 72, 72, 72,
+			// 456 - 463
+			72, 72, 72, 72, 72, 72, 72, 72,
+			// 464 - 471
+			72, 72, 72, 72, 72, 72, 72, 72,
+			// 472 - 479
+			72, 72, 72, 72, 72, 72, 72, 72,
+			// 480 - 487
+			72, 72, 72, 72, 72, 72, 72, 72,
+			// 488 - 495
+			72, 72, 72, 72, 72, 72, 72, 72,
+			// 496 - 503
+			72, 72, 72, 72, 72, 72, 72, 72,
+			// 504 - 511
+			72, 72, 72, 72, 72, 72, 72, 72,
+			// 512 - 519
+			104, 104, 104, 104, 104, 104, 104, 104,
+			// 520 - 527
+			104, 104, 104, 104, 104, 104, 104, 104,
+			// 528 - 535
+			104, 104, 104, 104, 104, 104, 104, 104,
+			// 536 - 543
+			104, 104, 104, 104, 104, 104, 104, 104,
+			// 544 - 551
+			104, 104, 104, 104, 104, 104, 104, 104,
+			// 552 - 559
+			104, 104, 104, 104, 104, 104, 104, 104,
+			// 560 - 567
+			104, 104, 104, 104, 104, 104, 104, 104,
+			// 568 - 575
+			104, 104, 104, 104, 104, 104, 104, 104,
+			// 576 - 583
+			4107, 4107, 4107, 4107, 4107, 4107, 4107, 4107,
+			// 584 - 591
+			4107, 4107, 4107, 4107, 4107, 4107, 4107, 4107,
+			// 592 - 599
+			4107, 4107, 4107, 4107, 4107, 4107, 4107, 4107,
+			// 600 - 607
+			4107, 4107, 4107, 4107, 4107, 4107, 4107, 4107,
+			// 608 - 615
+			266, 266, 266, 266, 266, 266, 266, 266,
+			// 616 - 623
+			266, 266, 266, 266, 266, 266, 266, 266,
+			// 624 - 631
+			266, 266, 266, 266, 266, 266, 266, 266,
+			// 632 - 639
+			266, 266, 266, 266, 266, 266, 266, 266,
+			// 640 - 647
+			298, 298, 298, 298, 298, 298, 298, 298,
+			// 648 - 655
+			298, 298, 298, 298, 298, 298, 298, 298,
+			// 656 - 663
+			298, 298, 298, 298, 298, 298, 298, 298,
+			// 664 - 671
+			298, 298, 298, 298, 298, 298, 298, 298,
+			// 672 - 679
+			524, 524, 524, 524, 524, 524, 524, 524,
+			// 680 - 687
+			524, 524, 524, 524, 524, 524, 524, 524,
+			// 688 - 695
+			556, 556, 556, 556, 556, 556, 556, 556,
+			// 696 - 703
+			556, 556, 556, 556, 556, 556, 556, 556,
+			// 704 - 711
+			136, 136, 136, 136, 136, 136, 136, 136,
+			// 712 - 719
+			136, 136, 136, 136, 136, 136, 136, 136,
+			// 720 - 727
+			136, 136, 136, 136, 136, 136, 136, 136,
+			// 728 - 735
+			136, 136, 136, 136, 136, 136, 136, 136,
+			// 736 - 743
+			136, 136, 136, 136, 136, 136, 136, 136,
+			// 744 - 751
+			136, 136, 136, 136, 136, 136, 136, 136,
+			// 752 - 759
+			136, 136, 136, 136, 136, 136, 136, 136,
+			// 760 - 767
+			136, 136, 136, 136, 136, 136, 136, 136,
+			// 768 - 775
+			168, 168, 168, 168, 168, 168, 168, 168,
+			// 776 - 783
+			168, 168, 168, 168, 168, 168, 168, 168,
+			// 784 - 791
+			168, 168, 168, 168, 168, 168, 168, 168,
+			// 792 - 799
+			168, 168, 168, 168, 168, 168, 168, 168,
+			// 800 - 807
+			168, 168, 168, 168, 168, 168, 168, 168,
+			// 808 - 815
+			168, 168, 168, 168, 168, 168, 168, 168,
+			// 816 - 823
+			168, 168, 168, 168, 168, 168, 168, 168,
+			// 824 - 831
+			168, 168, 168, 168, 168, 168, 168, 168,
+			// 832 - 839
+			460, 460, 460, 460, 460, 460, 460, 460,
+			// 840 - 847
+			460, 460, 460, 460, 460, 460, 460, 460,
+			// 848 - 855
+			492, 492, 492, 492, 492, 492, 492, 492,
+			// 856 - 863
+			492, 492, 492, 492, 492, 492, 492, 492,
+			// 864 - 871
+			2059, 2059, 2059, 2059, 2059, 2059, 2059, 2059,
+			// 872 - 879
+			2059, 2059, 2059, 2059, 2059, 2059, 2059, 2059,
+			// 880 - 887
+			2059, 2059, 2059, 2059, 2059, 2059, 2059, 2059,
+			// 888 - 895
+			2059, 2059, 2059, 2059, 2059, 2059, 2059, 2059,
+			// 896 - 903
+			200, 200, 200, 200, 200, 200, 200, 200,
+			// 904 - 911
+			200, 200, 200, 200, 200, 200, 200, 200,
+			// 912 - 919
+			200, 200, 200, 200, 200, 200, 200, 200,
+			// 920 - 927
+			200, 200, 200, 200, 200, 200, 200, 200,
+			// 928 - 935
+			200, 200, 200, 200, 200, 200, 200, 200,
+			// 936 - 943
+			200, 200, 200, 200, 200, 200, 200, 200,
+			// 944 - 951
+			200, 200, 200, 200, 200, 200, 200, 200,
+			// 952 - 959
+			200, 200, 200, 200, 200, 200, 200, 200,
+			// 960 - 967
+			232, 232, 232, 232, 232, 232, 232, 232,
+			// 968 - 975
+			232, 232, 232, 232, 232, 232, 232, 232,
+			// 976 - 983
+			232, 232, 232, 232, 232, 232, 232, 232,
+			// 984 - 991
+			232, 232, 232, 232, 232, 232, 232, 232,
+			// 992 - 999
+			232, 232, 232, 232, 232, 232, 232, 232,
+			// 1000 - 1007
+			232, 232, 232, 232, 232, 232, 232, 232,
+			// 1008 - 1015
+			232, 232, 232, 232, 232, 232, 232, 232,
+			// 1016 - 1023
+			232, 232, 232, 232, 232, 232, 232, 232, };
+
+	// Additional make up codes for both White and Black runs
+	static short[] additionalMakeup = { 28679, 28679, 31752, (short) 32777,
+			(short) 33801, (short) 34825, (short) 35849, (short) 36873,
+			(short) 29703, (short) 29703, (short) 30727, (short) 30727,
+			(short) 37897, (short) 38921, (short) 39945, (short) 40969 };
+
+	// Initial black run look up table, uses the first 4 bits of a code
+	static short[] initBlack = {
+	// 0 - 7
+			3226, 6412, 200, 168, 38, 38, 134, 134, // 8 - 15
+			100, 100, 100, 100, 68, 68, 68, 68 };
+
+	//
+	static short[] twoBitBlack = { 292, 260, 226, 226 }; // 0 - 3
+
+	// Main black run table, using the last 9 bits of possible 13 bit code
+	static short black[] = {
+	// 0 - 7
+			62, 62, 30, 30, 0, 0, 0, 0,
+			// 8 - 15
+			0, 0, 0, 0, 0, 0, 0, 0,
+			// 16 - 23
+			0, 0, 0, 0, 0, 0, 0, 0,
+			// 24 - 31
+			0, 0, 0, 0, 0, 0, 0, 0,
+			// 32 - 39
+			3225, 3225, 3225, 3225, 3225, 3225, 3225, 3225,
+			// 40 - 47
+			3225, 3225, 3225, 3225, 3225, 3225, 3225, 3225,
+			// 48 - 55
+			3225, 3225, 3225, 3225, 3225, 3225, 3225, 3225,
+			// 56 - 63
+			3225, 3225, 3225, 3225, 3225, 3225, 3225, 3225,
+			// 64 - 71
+			588, 588, 588, 588, 588, 588, 588, 588,
+			// 72 - 79
+			1680, 1680, 20499, 22547, 24595, 26643, 1776, 1776,
+			// 80 - 87
+			1808, 1808, -24557, -22509, -20461, -18413, 1904, 1904,
+			// 88 - 95
+			1936, 1936, -16365, -14317, 782, 782, 782, 782,
+			// 96 - 103
+			814, 814, 814, 814, -12269, -10221, 10257, 10257,
+			// 104 - 111
+			12305, 12305, 14353, 14353, 16403, 18451, 1712, 1712,
+			// 112 - 119
+			1744, 1744, 28691, 30739, -32749, -30701, -28653, -26605,
+			// 120 - 127
+			2061, 2061, 2061, 2061, 2061, 2061, 2061, 2061,
+			// 128 - 135
+			424, 424, 424, 424, 424, 424, 424, 424,
+			// 136 - 143
+			424, 424, 424, 424, 424, 424, 424, 424,
+			// 144 - 151
+			424, 424, 424, 424, 424, 424, 424, 424,
+			// 152 - 159
+			424, 424, 424, 424, 424, 424, 424, 424,
+			// 160 - 167
+			750, 750, 750, 750, 1616, 1616, 1648, 1648,
+			// 168 - 175
+			1424, 1424, 1456, 1456, 1488, 1488, 1520, 1520,
+			// 176 - 183
+			1840, 1840, 1872, 1872, 1968, 1968, 8209, 8209,
+			// 184 - 191
+			524, 524, 524, 524, 524, 524, 524, 524,
+			// 192 - 199
+			556, 556, 556, 556, 556, 556, 556, 556,
+			// 200 - 207
+			1552, 1552, 1584, 1584, 2000, 2000, 2032, 2032,
+			// 208 - 215
+			976, 976, 1008, 1008, 1040, 1040, 1072, 1072,
+			// 216 - 223
+			1296, 1296, 1328, 1328, 718, 718, 718, 718,
+			// 224 - 231
+			456, 456, 456, 456, 456, 456, 456, 456,
+			// 232 - 239
+			456, 456, 456, 456, 456, 456, 456, 456,
+			// 240 - 247
+			456, 456, 456, 456, 456, 456, 456, 456,
+			// 248 - 255
+			456, 456, 456, 456, 456, 456, 456, 456,
+			// 256 - 263
+			326, 326, 326, 326, 326, 326, 326, 326,
+			// 264 - 271
+			326, 326, 326, 326, 326, 326, 326, 326,
+			// 272 - 279
+			326, 326, 326, 326, 326, 326, 326, 326,
+			// 280 - 287
+			326, 326, 326, 326, 326, 326, 326, 326,
+			// 288 - 295
+			326, 326, 326, 326, 326, 326, 326, 326,
+			// 296 - 303
+			326, 326, 326, 326, 326, 326, 326, 326,
+			// 304 - 311
+			326, 326, 326, 326, 326, 326, 326, 326,
+			// 312 - 319
+			326, 326, 326, 326, 326, 326, 326, 326,
+			// 320 - 327
+			358, 358, 358, 358, 358, 358, 358, 358,
+			// 328 - 335
+			358, 358, 358, 358, 358, 358, 358, 358,
+			// 336 - 343
+			358, 358, 358, 358, 358, 358, 358, 358,
+			// 344 - 351
+			358, 358, 358, 358, 358, 358, 358, 358,
+			// 352 - 359
+			358, 358, 358, 358, 358, 358, 358, 358,
+			// 360 - 367
+			358, 358, 358, 358, 358, 358, 358, 358,
+			// 368 - 375
+			358, 358, 358, 358, 358, 358, 358, 358,
+			// 376 - 383
+			358, 358, 358, 358, 358, 358, 358, 358,
+			// 384 - 391
+			490, 490, 490, 490, 490, 490, 490, 490,
+			// 392 - 399
+			490, 490, 490, 490, 490, 490, 490, 490,
+			// 400 - 407
+			4113, 4113, 6161, 6161, 848, 848, 880, 880,
+			// 408 - 415
+			912, 912, 944, 944, 622, 622, 622, 622,
+			// 416 - 423
+			654, 654, 654, 654, 1104, 1104, 1136, 1136,
+			// 424 - 431
+			1168, 1168, 1200, 1200, 1232, 1232, 1264, 1264,
+			// 432 - 439
+			686, 686, 686, 686, 1360, 1360, 1392, 1392,
+			// 440 - 447
+			12, 12, 12, 12, 12, 12, 12, 12,
+			// 448 - 455
+			390, 390, 390, 390, 390, 390, 390, 390,
+			// 456 - 463
+			390, 390, 390, 390, 390, 390, 390, 390,
+			// 464 - 471
+			390, 390, 390, 390, 390, 390, 390, 390,
+			// 472 - 479
+			390, 390, 390, 390, 390, 390, 390, 390,
+			// 480 - 487
+			390, 390, 390, 390, 390, 390, 390, 390,
+			// 488 - 495
+			390, 390, 390, 390, 390, 390, 390, 390,
+			// 496 - 503
+			390, 390, 390, 390, 390, 390, 390, 390,
+			// 504 - 511
+			390, 390, 390, 390, 390, 390, 390, 390, };
+
+	static byte[] twoDCodes = {
+	// 0 - 7
+			80, 88, 23, 71, 30, 30, 62, 62, // 8 - 15
+			4, 4, 4, 4, 4, 4, 4, 4, // 16 - 23
+			11, 11, 11, 11, 11, 11, 11, 11, // 24 - 31
+			11, 11, 11, 11, 11, 11, 11, 11, // 32 - 39
+			35, 35, 35, 35, 35, 35, 35, 35, // 40 - 47
+			35, 35, 35, 35, 35, 35, 35, 35, // 48 - 55
+			51, 51, 51, 51, 51, 51, 51, 51, // 56 - 63
+			51, 51, 51, 51, 51, 51, 51, 51, // 64 - 71
+			41, 41, 41, 41, 41, 41, 41, 41, // 72 - 79
+			41, 41, 41, 41, 41, 41, 41, 41, // 80 - 87
+			41, 41, 41, 41, 41, 41, 41, 41, // 88 - 95
+			41, 41, 41, 41, 41, 41, 41, 41, // 96 - 103
+			41, 41, 41, 41, 41, 41, 41, 41, // 104 - 111
+			41, 41, 41, 41, 41, 41, 41, 41, // 112 - 119
+			41, 41, 41, 41, 41, 41, 41, 41, // 120 - 127
+			41, 41, 41, 41, 41, 41, 41, 41, };
+
+	private int bitPointer;
+
+	private int bytePointer;
+
+	private byte[] data;
+
+	private int w;
+
+	private boolean align = false;
+
+	private int fillOrder;
+
+	// Data structures needed to store changing elements for the previous
+	// and the current scanline
+	private int changingElemSize = 0;
+
+	private int[] prevChangingElems;
+
+	private int[] currChangingElems;
+
+	// Element at which to start search in getNextChangingElement
+	private int lastChangingElement = 0;
+
+	private boolean fillBits = false;
+
+	/**
+	 * @param fillOrder
+	 *            The fill order of the compressed data bytes.
+	 * @param w
+	 * @param h
+	 */
+	public CCITTFaxDecoder(int fillOrder, int w, int h) {
+		this.fillOrder = fillOrder;
+		this.w = w;
+
+		this.bitPointer = 0;
+		this.bytePointer = 0;
+		this.prevChangingElems = new int[w];
+		this.currChangingElems = new int[w];
+	}
+
+	private boolean align() {
+		if (align && bitPointer != 0) {
+			bytePointer++;
+			bitPointer = 0;
+			return true;
+		}
+		return false;
+	}
+
+	protected boolean consumeEOL() {
+		// Get the next 12 bits.
+		int next12Bits = nextNBits(12);
+		if (next12Bits == 1) {
+			// EOL found & consumed
+			return true;
+		}
+		// no EOL - unread and return
+		updatePointer(12);
+		return false;
+	}
+
+	// Returns run length
+	private int decodeBlackCodeWord() {
+		int current;
+		int entry;
+		int bits;
+		int isT;
+		int code = -1;
+		int runLength = 0;
+		boolean isWhite = false;
+
+		while (!isWhite) {
+			current = nextLesserThan8Bits(4);
+			entry = initBlack[current];
+
+			// Get the 3 fields from the entry
+			isT = entry & 0x0001;
+			bits = (entry >>> 1) & 0x000f;
+			code = (entry >>> 5) & 0x07ff;
+
+			if (code == 100) {
+				current = nextNBits(9);
+				entry = black[current];
+
+				// Get the 3 fields from the entry
+				isT = entry & 0x0001;
+				bits = (entry >>> 1) & 0x000f;
+				code = (entry >>> 5) & 0x07ff;
+
+				if (bits == 12) {
+					// Additional makeup codes
+					updatePointer(5);
+					current = nextLesserThan8Bits(4);
+					entry = additionalMakeup[current];
+					bits = (entry >>> 1) & 0x07; // 3 bits 0000 0111
+					code = (entry >>> 4) & 0x0fff; // 12 bits
+					runLength += code;
+
+					updatePointer(4 - bits);
+				} else if (bits == 15) {
+					// EOL code
+					throw new RuntimeException(
+							"EOL code word encountered in Black run."); //$NON-NLS-1$
+				} else {
+					runLength += code;
+					updatePointer(9 - bits);
+					if (isT == 0) {
+						isWhite = true;
+					}
+				}
+			} else if (code == 200) {
+				// Is a Terminating code
+				current = nextLesserThan8Bits(2);
+				entry = twoBitBlack[current];
+				code = (entry >>> 5) & 0x07ff;
+				runLength += code;
+				bits = (entry >>> 1) & 0x0f;
+				updatePointer(2 - bits);
+				isWhite = true;
+			} else {
+				// Is a Terminating code
+				runLength += code;
+				updatePointer(4 - bits);
+				isWhite = true;
+			}
+		}
+
+		return runLength;
+	}
+
+	protected void decodeNextScanline(byte[] buffer, int lineOffset,
+			int bitOffset) {
+		int bits = 0;
+		int code = 0;
+		int isT = 0;
+		int current;
+		int entry;
+		int twoBits;
+		boolean isWhite = true;
+
+		// Initialize starting of the changing elements array
+		changingElemSize = 0;
+
+		// While scanline not complete
+		while (bitOffset < w) {
+			while (isWhite) {
+				// White run
+				current = nextNBits(10);
+				entry = white[current];
+
+				// Get the 3 fields from the entry
+				isT = entry & 0x0001;
+				bits = (entry >>> 1) & 0x0f;
+
+				if (bits == 12) { // Additional Make up code
+					// Get the next 2 bits
+					twoBits = nextLesserThan8Bits(2);
+					// Consolidate the 2 new bits and last 2 bits into 4 bits
+					current = ((current << 2) & 0x000c) | twoBits;
+					entry = additionalMakeup[current];
+					bits = (entry >>> 1) & 0x07; // 3 bits 0000 0111
+					code = (entry >>> 4) & 0x0fff; // 12 bits
+					bitOffset += code; // Skip white run
+
+					updatePointer(4 - bits);
+				} else if (bits == 0) { // ERROR
+					throw new RuntimeException("Invalid code encountered.");
+				} else if (bits == 15) {
+					// EOL recover
+					// move bits back...
+					updatePointer(10);
+					return;
+				} else {
+					// 11 bits - 0000 0111 1111 1111 = 0x07ff
+					code = (entry >>> 5) & 0x07ff;
+					bitOffset += code;
+
+					updatePointer(10 - bits);
+					if (isT == 0) {
+						isWhite = false;
+						currChangingElems[changingElemSize++] = bitOffset;
+					}
+				}
+			}
+
+			// Check whether this run completed one width, if so
+			// advance to next byte boundary for compression = 2.
+			if (bitOffset == w) {
+				align();
+				break;
+			}
+
+			while (isWhite == false) {
+				// Black run
+				current = nextLesserThan8Bits(4);
+				entry = initBlack[current];
+
+				// Get the 3 fields from the entry
+				isT = entry & 0x0001;
+				bits = (entry >>> 1) & 0x000f;
+				code = (entry >>> 5) & 0x07ff;
+
+				if (code == 100) {
+					current = nextNBits(9);
+					entry = black[current];
+
+					// Get the 3 fields from the entry
+					isT = entry & 0x0001;
+					bits = (entry >>> 1) & 0x000f;
+					code = (entry >>> 5) & 0x07ff;
+
+					if (bits == 12) {
+						// Additional makeup codes
+						updatePointer(5);
+						current = nextLesserThan8Bits(4);
+						entry = additionalMakeup[current];
+						bits = (entry >>> 1) & 0x07; // 3 bits 0000 0111
+						code = (entry >>> 4) & 0x0fff; // 12 bits
+
+						setToBlack(buffer, lineOffset, bitOffset, code);
+						bitOffset += code;
+
+						updatePointer(4 - bits);
+					} else if (bits == 15) {
+						// EOL recover
+						// unread bits ???
+						updatePointer(9);
+						return;
+					} else {
+						setToBlack(buffer, lineOffset, bitOffset, code);
+						bitOffset += code;
+
+						updatePointer(9 - bits);
+						if (isT == 0) {
+							isWhite = true;
+							currChangingElems[changingElemSize++] = bitOffset;
+						}
+					}
+				} else if (code == 200) {
+					// Is a Terminating code
+					current = nextLesserThan8Bits(2);
+					entry = twoBitBlack[current];
+					code = (entry >>> 5) & 0x07ff;
+					bits = (entry >>> 1) & 0x0f;
+
+					setToBlack(buffer, lineOffset, bitOffset, code);
+					bitOffset += code;
+
+					updatePointer(2 - bits);
+					isWhite = true;
+					currChangingElems[changingElemSize++] = bitOffset;
+				} else {
+					// Is a Terminating code
+					setToBlack(buffer, lineOffset, bitOffset, code);
+					bitOffset += code;
+
+					updatePointer(4 - bits);
+					isWhite = true;
+					currChangingElems[changingElemSize++] = bitOffset;
+				}
+			}
+
+			// Check whether this run completed one width
+			if (bitOffset == w) {
+				align();
+				break;
+			}
+		}
+
+		currChangingElems[changingElemSize++] = bitOffset;
+	}
+
+	// One-dimensional decoding methods
+	public void decodeT41D(byte[] buffer, byte[] compData, int startX,
+			int height) {
+		this.data = compData;
+		int scanlineStride = (w + 7) / 8;
+		bitPointer = 0;
+		bytePointer = 0;
+
+		int lineOffset = 0;
+		for (int i = 0; i < height; i++) {
+			consumeEOL();
+			decodeNextScanline(buffer, lineOffset, startX);
+			lineOffset += scanlineStride;
+		}
+	}
+
+	// Two-dimensional decoding methods
+	public void decodeT42D(byte[] buffer, byte[] compData, int startX,
+			int height) {
+		this.data = compData;
+		int scanlineStride = (w + 7) / 8;
+		bitPointer = 0;
+		bytePointer = 0;
+
+		int a0;
+		int a1;
+		int b1;
+		int b2;
+		int[] b = new int[2];
+		int entry;
+		int code;
+		int bits;
+		boolean isWhite;
+		int currIndex = 0;
+		int[] temp;
+
+		// The data must start with an EOL code
+		if (readEOL(true) != 1) {
+			throw new RuntimeException("First scanline must be 1D encoded."); //$NON-NLS-1$
+		}
+
+		int lineOffset = 0;
+		int bitOffset;
+
+		// Then the 1D encoded scanline data will occur, changing elements
+		// array gets set.
+		decodeNextScanline(buffer, lineOffset, startX);
+		lineOffset += scanlineStride;
+
+		for (int lines = 1; lines < height; lines++) {
+			// Every line must begin with an EOL followed by a bit which
+			// indicates whether the following scanline is 1D or 2D encoded.
+			if (readEOL(false) == 0) {
+				// 2D encoded scanline follows
+
+				// Initialize previous scanlines changing elements, and
+				// initialize current scanline's changing elements array
+				temp = prevChangingElems;
+				prevChangingElems = currChangingElems;
+				currChangingElems = temp;
+				currIndex = 0;
+
+				// a0 has to be set just before the start of this scanline.
+				a0 = -1;
+				isWhite = true;
+				bitOffset = startX;
+
+				lastChangingElement = 0;
+
+				while (bitOffset < w) {
+					// Get the next changing element
+					getNextChangingElement(a0, isWhite, b);
+
+					b1 = b[0];
+					b2 = b[1];
+
+					// Get the next seven bits
+					entry = nextLesserThan8Bits(7);
+
+					// Run these through the 2DCodes table
+					entry = (twoDCodes[entry] & 0xff);
+
+					// Get the code and the number of bits used up
+					code = (entry & 0x78) >>> 3;
+					bits = entry & 0x07;
+
+					if (code == 0) {
+						if (!isWhite) {
+							setToBlack(buffer, lineOffset, bitOffset, b2
+									- bitOffset);
+						}
+						bitOffset = a0 = b2;
+
+						// Set pointer to consume the correct number of bits.
+						updatePointer(7 - bits);
+					} else if (code == 1) {
+						// Horizontal
+						updatePointer(7 - bits);
+
+						// identify the next 2 codes.
+						int number;
+						if (isWhite) {
+							number = decodeWhiteCodeWord();
+							bitOffset += number;
+							currChangingElems[currIndex++] = bitOffset;
+
+							number = decodeBlackCodeWord();
+							setToBlack(buffer, lineOffset, bitOffset, number);
+							bitOffset += number;
+							currChangingElems[currIndex++] = bitOffset;
+						} else {
+							number = decodeBlackCodeWord();
+							setToBlack(buffer, lineOffset, bitOffset, number);
+							bitOffset += number;
+							currChangingElems[currIndex++] = bitOffset;
+
+							number = decodeWhiteCodeWord();
+							bitOffset += number;
+							currChangingElems[currIndex++] = bitOffset;
+						}
+
+						a0 = bitOffset;
+					} else if (code <= 8) {
+						// Vertical
+						a1 = b1 + (code - 5);
+
+						currChangingElems[currIndex++] = a1;
+
+						// We write the current color till a1 - 1 pos,
+						// since a1 is where the next color starts
+						if (!isWhite) {
+							setToBlack(buffer, lineOffset, bitOffset, a1
+									- bitOffset);
+						}
+						bitOffset = a0 = a1;
+						isWhite = !isWhite;
+
+						updatePointer(7 - bits);
+					} else {
+						throw new RuntimeException(
+								"Invalid code encountered while decoding 2D group 3 compressed data."); //$NON-NLS-1$
+					}
+				}
+
+				// Add the changing element beyond the current scanline for the
+				// other color too
+				currChangingElems[currIndex++] = bitOffset;
+				changingElemSize = currIndex;
+			} else {
+				// 1D encoded scanline follows
+				decodeNextScanline(buffer, lineOffset, startX);
+			}
+
+			lineOffset += scanlineStride;
+		}
+	}
+
+	public synchronized void decodeT6(byte[] buffer, byte[] compData,
+			int startX, int height) {
+		this.data = compData;
+		int scanlineStride = (w + 7) / 8;
+		bitPointer = 0;
+		bytePointer = 0;
+
+		int a0;
+		int a1;
+		int b1;
+		int b2;
+		int entry;
+		int code;
+		int bits;
+		boolean isWhite;
+		int currIndex;
+		int[] temp;
+
+		// Return values from getNextChangingElement
+		int[] b = new int[2];
+
+		// uncompressedMode - have written some code for this, but this
+		// has not been tested due to lack of test images using this optional
+
+		// Local cached reference
+		int[] cce = currChangingElems;
+
+		// Assume invisible preceding row of all white pixels and insert
+		// both black and white changing elements beyond the end of this
+		// imaginary scanline.
+		changingElemSize = 0;
+		cce[changingElemSize++] = w;
+		cce[changingElemSize++] = w;
+
+		int lineOffset = 0;
+		int bitOffset;
+
+		for (int lines = 0; lines < height; lines++) {
+			// a0 has to be set just before the start of the scanline.
+			a0 = -1;
+			isWhite = true;
+
+			// Assign the changing elements of the previous scanline to
+			// prevChangingElems and start putting this new scanline's
+			// changing elements into the currChangingElems.
+			temp = prevChangingElems;
+			prevChangingElems = currChangingElems;
+			cce = currChangingElems = temp;
+			currIndex = 0;
+
+			// Start decoding the scanline at startX in the raster
+			bitOffset = startX;
+
+			// Reset search start position for getNextChangingElement
+			lastChangingElement = 0;
+
+			// Till one whole scanline is decoded
+			while (bitOffset < w) {
+				// Get the next changing element
+				getNextChangingElement(a0, isWhite, b);
+				b1 = b[0];
+				b2 = b[1];
+
+				// Get the next seven bits
+				entry = nextLesserThan8Bits(7);
+				// Run these through the 2DCodes table
+				entry = (twoDCodes[entry] & 0xff);
+
+				// Get the code and the number of bits used up
+				code = (entry & 0x78) >>> 3;
+				bits = entry & 0x07;
+
+				if (code == 0) { // Pass
+					// We always assume WhiteIsZero format for fax.
+					if (!isWhite) {
+						if (b2 > w) {
+							b2 = w;
+						}
+						setToBlack(buffer, lineOffset, bitOffset, b2
+								- bitOffset);
+					}
+					bitOffset = a0 = b2;
+
+					// Set pointer to only consume the correct number of bits.
+					updatePointer(7 - bits);
+				} else if (code == 1) { // Horizontal
+					// Set pointer to only consume the correct number of bits.
+					updatePointer(7 - bits);
+
+					// identify the next 2 alternating color codes.
+					int number;
+					if (isWhite) {
+						// Following are white and black runs
+						number = decodeWhiteCodeWord();
+						bitOffset += number;
+						cce[currIndex++] = bitOffset;
+
+						number = decodeBlackCodeWord();
+						if (number > w - bitOffset) {
+							number = w - bitOffset;
+						}
+						setToBlack(buffer, lineOffset, bitOffset, number);
+						bitOffset += number;
+						cce[currIndex++] = bitOffset;
+					} else {
+						// First a black run and then a white run follows
+						number = decodeBlackCodeWord();
+						if (number > w - bitOffset) {
+							number = w - bitOffset;
+						}
+						setToBlack(buffer, lineOffset, bitOffset, number);
+						bitOffset += number;
+						cce[currIndex++] = bitOffset;
+
+						number = decodeWhiteCodeWord();
+						bitOffset += number;
+						cce[currIndex++] = bitOffset;
+					}
+
+					a0 = bitOffset;
+				} else if (code <= 8) { // Vertical
+					a1 = b1 + (code - 5);
+					cce[currIndex++] = a1;
+
+					// We write the current color till a1 - 1 pos,
+					// since a1 is where the next color starts
+					if (!isWhite) {
+						if (a1 > w) {
+							a1 = w;
+						}
+						setToBlack(buffer, lineOffset, bitOffset, a1
+								- bitOffset);
+					}
+					bitOffset = a0 = a1;
+					isWhite = !isWhite;
+
+					updatePointer(7 - bits);
+				} else if (code == 11) {
+					if (nextLesserThan8Bits(3) != 7) {
+						throw new RuntimeException(
+								"Invalid code encountered while decoding 2D group 4 compressed data."); //$NON-NLS-1$
+					}
+
+					int zeros = 0;
+					boolean exit = false;
+
+					while (!exit) {
+						while (nextLesserThan8Bits(1) != 1) {
+							zeros++;
+						}
+
+						if (zeros > 5) {
+							// Exit code
+
+							// Zeros before exit code
+							zeros = zeros - 6;
+
+							if (!isWhite && (zeros > 0)) {
+								cce[currIndex++] = bitOffset;
+							}
+
+							// Zeros before the exit code
+							bitOffset += zeros;
+							if (zeros > 0) {
+								// Some zeros have been written
+								isWhite = true;
+							}
+
+							// Read in the bit which specifies the color of
+							// the following run
+							if (nextLesserThan8Bits(1) == 0) {
+								if (!isWhite) {
+									cce[currIndex++] = bitOffset;
+								}
+								isWhite = true;
+							} else {
+								if (isWhite) {
+									cce[currIndex++] = bitOffset;
+								}
+								isWhite = false;
+							}
+
+							exit = true;
+						}
+
+						if (zeros == 5) {
+							if (!isWhite) {
+								cce[currIndex++] = bitOffset;
+							}
+							bitOffset += zeros;
+
+							// Last thing written was white
+							isWhite = true;
+						} else {
+							bitOffset += zeros;
+
+							cce[currIndex++] = bitOffset;
+							setToBlack(buffer, lineOffset, bitOffset, 1);
+							++bitOffset;
+
+							// Last thing written was black
+							isWhite = false;
+						}
+					}
+				} else {
+					// break line - seems to be a common failure
+					// unread
+					updatePointer(7 - bits);
+					// and mark lines as complete
+					bitOffset = w;
+					// throw new RuntimeException(
+					// "Invalid code encountered while decoding 2D group 4
+					// compressed data."); //$NON-NLS-1$
+				}
+			}
+
+			align();
+
+			// Add the changing element beyond the current scanline for the
+			// other color too
+			// make sure that the index does not exceed the bounds of the array
+			if (currIndex <= w) {
+				cce[currIndex++] = bitOffset;
+			}
+
+			// Number of changing elements in this scanline.
+			changingElemSize = currIndex;
+
+			lineOffset += scanlineStride;
+		}
+	}
+
+	// Returns run length
+	private int decodeWhiteCodeWord() {
+		int current;
+		int entry;
+		int bits;
+		int isT;
+		int twoBits;
+		int code = -1;
+		int runLength = 0;
+		boolean isWhite = true;
+
+		while (isWhite) {
+			current = nextNBits(10);
+			entry = white[current];
+
+			// Get the 3 fields from the entry
+			isT = entry & 0x0001;
+			bits = (entry >>> 1) & 0x0f;
+
+			if (bits == 12) { // Additional Make up code
+				// Get the next 2 bits
+				twoBits = nextLesserThan8Bits(2);
+				// Consolidate the 2 new bits and last 2 bits into 4 bits
+				current = ((current << 2) & 0x000c) | twoBits;
+				entry = additionalMakeup[current];
+				bits = (entry >>> 1) & 0x07; // 3 bits 0000 0111
+				code = (entry >>> 4) & 0x0fff; // 12 bits
+				runLength += code;
+				updatePointer(4 - bits);
+			} else if (bits == 0) { // ERROR
+				throw new RuntimeException("Invalid code encountered."); //$NON-NLS-1$
+			} else if (bits == 15) { // EOL
+				throw new RuntimeException(
+						"EOL code word encountered in White run."); //$NON-NLS-1$
+			} else {
+				// 11 bits - 0000 0111 1111 1111 = 0x07ff
+				code = (entry >>> 5) & 0x07ff;
+				runLength += code;
+				updatePointer(10 - bits);
+				if (isT == 0) {
+					isWhite = false;
+				}
+			}
+		}
+
+		return runLength;
+	}
+
+	private void getNextChangingElement(int a0, boolean isWhite, int[] ret) {
+		// Local copies of instance variables
+		int[] pce = this.prevChangingElems;
+		int ces = this.changingElemSize;
+
+		// If the previous match was at an odd element, we still
+		// have to search the preceeding element.
+		// int start = lastChangingElement & ~0x1;
+		int start = (lastChangingElement > 0) ? (lastChangingElement - 1) : 0;
+		if (isWhite) {
+			start &= ~0x1; // Search even numbered elements
+		} else {
+			start |= 0x1; // Search odd numbered elements
+		}
+
+		int i = start;
+		for (; i < ces; i += 2) {
+			int temp = pce[i];
+			if (temp > a0) {
+				lastChangingElement = i;
+				ret[0] = temp;
+				break;
+			}
+		}
+
+		if ((i + 1) < ces) {
+			ret[1] = pce[i + 1];
+		}
+	}
+
+	public boolean isAlign() {
+		return align;
+	}
+
+	public boolean isFillBits() {
+		return fillBits;
+	}
+
+	private int nextLesserThan8Bits(int bitsToGet) {
+		byte b;
+		byte next;
+		int l = data.length - 1;
+		int bp = this.bytePointer;
+
+		if (fillOrder == 1) {
+			b = data[bp];
+			if (bp == l) {
+				next = 0x00;
+			} else {
+				next = data[bp + 1];
+			}
+		} else if (fillOrder == 2) {
+			b = flipTable[data[bp] & 0xff];
+			if (bp == l) {
+				next = 0x00;
+			} else {
+				next = flipTable[data[bp + 1] & 0xff];
+			}
+		} else {
+			throw new RuntimeException("tag must be either 1 or 2."); //$NON-NLS-1$
+		}
+
+		int bitsLeft = 8 - bitPointer;
+		int bitsFromNextByte = bitsToGet - bitsLeft;
+
+		int shift = bitsLeft - bitsToGet;
+		int i1;
+		int i2;
+		if (shift >= 0) {
+			i1 = (b & table1[bitsLeft]) >>> shift;
+			bitPointer += bitsToGet;
+			if (bitPointer == 8) {
+				bitPointer = 0;
+				bytePointer++;
+			}
+		} else {
+			i1 = (b & table1[bitsLeft]) << (-shift);
+			i2 = (next & table2[bitsFromNextByte]) >>> (8 - bitsFromNextByte);
+
+			i1 |= i2;
+			bytePointer++;
+			bitPointer = bitsFromNextByte;
+		}
+
+		return i1;
+	}
+
+	private int nextNBits(int bitsToGet) {
+		byte b;
+		byte next;
+		byte next2next;
+		int l = data.length - 1;
+		int bp = this.bytePointer;
+
+		if (fillOrder == 1) {
+			b = data[bp];
+
+			if (bp == l) {
+				next = 0x00;
+				next2next = 0x00;
+			} else if ((bp + 1) == l) {
+				next = data[bp + 1];
+				next2next = 0x00;
+			} else {
+				next = data[bp + 1];
+				next2next = data[bp + 2];
+			}
+		} else if (fillOrder == 2) {
+			b = flipTable[data[bp] & 0xff];
+
+			if (bp == l) {
+				next = 0x00;
+				next2next = 0x00;
+			} else if ((bp + 1) == l) {
+				next = flipTable[data[bp + 1] & 0xff];
+				next2next = 0x00;
+			} else {
+				next = flipTable[data[bp + 1] & 0xff];
+				next2next = flipTable[data[bp + 2] & 0xff];
+			}
+		} else {
+			throw new RuntimeException("tag must be either 1 or 2."); //$NON-NLS-1$
+		}
+
+		int bitsLeft = 8 - bitPointer;
+		int bitsFromNextByte = bitsToGet - bitsLeft;
+		int bitsFromNext2NextByte = 0;
+		if (bitsFromNextByte > 8) {
+			bitsFromNext2NextByte = bitsFromNextByte - 8;
+			bitsFromNextByte = 8;
+		}
+
+		bytePointer++;
+
+		int i1 = (b & table1[bitsLeft]) << (bitsToGet - bitsLeft);
+		int i2 = (next & table2[bitsFromNextByte]) >>> (8 - bitsFromNextByte);
+
+		int i3 = 0;
+		if (bitsFromNext2NextByte != 0) {
+			i2 <<= bitsFromNext2NextByte;
+			i3 = (next2next & table2[bitsFromNext2NextByte]) >>> (8 - bitsFromNext2NextByte);
+			i2 |= i3;
+			bytePointer++;
+			bitPointer = bitsFromNext2NextByte;
+		} else {
+			if (bitsFromNextByte == 8) {
+				bitPointer = 0;
+				bytePointer++;
+			} else {
+				bitPointer = bitsFromNextByte;
+			}
+		}
+
+		int i = i1 | i2;
+		return i;
+	}
+
+	private int readEOL(boolean isFirstEOL) {
+		// Seek to the next EOL.
+		if (!seekEOL()) {
+			throw new RuntimeException("EOL not found");
+		}
+
+		if (!fillBits) {
+			int next12Bits = nextNBits(12);
+			if (isFirstEOL && (next12Bits == 0)) {
+				// Might have the case of EOL padding being used even
+				// though it was not flagged.
+				// This was observed to be the case in TIFFs produced
+				// by a well known vendor who shall remain nameless.
+				if (nextNBits(4) == 1) {
+					// EOL must be padded: reset the fillBits flag.
+					fillBits = true;
+					return 1;
+				}
+			}
+			if (next12Bits != 1) {
+				throw new RuntimeException(
+						"Scanline must begin with EOL code word."); //$NON-NLS-1$
+			}
+		} else {
+			// First EOL code word xxxx 0000 0000 0001 will occur
+			// As many fill bits will be present as required to make
+			// the EOL code of 12 bits end on a byte boundary.
+			int bitsLeft = 8 - bitPointer;
+
+			if (nextNBits(bitsLeft) != 0) {
+				throw new RuntimeException(
+						"All fill bits preceding EOL code must be 0."); //$NON-NLS-1$
+			}
+
+			// If the number of bitsLeft is less than 8, then to have a 12
+			// bit EOL sequence, two more bytes are certainly going to be
+			// required. The first of them has to be all zeros, so ensure
+			// that.
+			if (bitsLeft < 4) {
+				if (nextNBits(8) != 0) {
+					throw new RuntimeException(
+							"All fill bits preceding EOL code must be 0."); //$NON-NLS-1$
+				}
+			}
+
+			//
+			// Some encoders under Group 3 Fax compression 1D writes TIFF
+			// files without the fill bits, but say otherwise.
+			// Need to check for this here.
+			//
+			int next8 = nextNBits(8);
+
+			if (isFirstEOL && (next8 & 0xf0) == 0x10) {
+				//
+				// Fill bits are not actually used despite what the flag
+				// says. So switch fillBits off and then rewind so that
+				// only 12 bits have effectively been read.
+				//
+				fillBits = false;
+				updatePointer(4);
+			} else {
+				//
+				// This is the normal case.
+				// There might be a random number of fill bytes with 0s, so
+				// loop till the EOL of 0000 0001 is found, as long as all
+				// the bytes preceding it are 0's.
+				//
+				while (next8 != 1) {
+					// If not all zeros
+					if (next8 != 0) {
+						throw new RuntimeException("0 bits expected before EOL");
+					}
+					next8 = nextNBits(8);
+				}
+			}
+		}
+		// The next one bit signifies 1D/2D encoding of next line.
+		return nextLesserThan8Bits(1);
+	}
+
+	// Seeks to the next EOL in the compressed bitstream.
+	// Returns 'true' if and only if an EOL is found; if 'false'
+	// is returned it may be inferred that the EOF was reached first.
+	private boolean seekEOL() {
+		// Set maximum and current bit index into the compressed data.
+		int bitIndexMax = data.length * 8 - 1;
+		int bitIndex = bytePointer * 8 + bitPointer;
+
+		// Loop while at least 12 bits are available.
+		while (bitIndex <= bitIndexMax - 12) {
+			// Get the next 12 bits.
+			int next12Bits = nextNBits(12);
+			bitIndex += 12;
+
+			// Loop while the 12 bits are not unity, i.e., while the EOL
+			// has not been reached, and there is at least one bit left.
+			while (next12Bits != 1 && bitIndex < bitIndexMax) {
+				next12Bits = ((next12Bits & 0x000007ff) << 1)
+						| (nextLesserThan8Bits(1) & 0x00000001);
+				bitIndex++;
+			}
+
+			// If EOL reached, rewind the pointers and return 'true'.
+			if (next12Bits == 1) {
+				updatePointer(12);
+				return true;
+			}
+		}
+
+		// EOL not found: return 'false'.
+		return false;
+	}
+
+	public void setAlign(boolean align) {
+		this.align = align;
+	}
+
+	public void setFillBits(boolean fillBits) {
+		this.fillBits = fillBits;
+	}
+
+	private void setToBlack(byte[] buffer, int lineOffset, int bitOffset,
+			int numBits) {
+		int bitNum = (8 * lineOffset) + bitOffset;
+		int lastBit = bitNum + numBits;
+
+		int byteNum = bitNum >> 3;
+
+		// Handle bits in first byte
+		int shift = bitNum & 0x7;
+		if (shift > 0) {
+			int maskVal = 1 << (7 - shift);
+			byte val = buffer[byteNum];
+			while ((maskVal > 0) && (bitNum < lastBit)) {
+				val |= maskVal;
+				maskVal >>= 1;
+				++bitNum;
+			}
+			buffer[byteNum] = val;
+		}
+
+		// Fill in 8 bits at a time
+		byteNum = bitNum >> 3;
+		while (bitNum < (lastBit - 7)) {
+			buffer[byteNum++] = (byte) 255;
+			bitNum += 8;
+		}
+
+		// Fill in remaining bits
+		while (bitNum < lastBit) {
+			byteNum = bitNum >> 3;
+			buffer[byteNum] |= (1 << (7 - (bitNum & 0x7)));
+			++bitNum;
+		}
+	}
+
+	// Move pointer backwards by given amount of bits
+	private void updatePointer(int bitsToMoveBack) {
+		if (bitsToMoveBack > 8) {
+			bytePointer -= bitsToMoveBack / 8;
+			bitsToMoveBack %= 8;
+		}
+
+		int i = bitPointer - bitsToMoveBack;
+
+		if (i < 0) {
+			bytePointer--;
+			bitPointer = 8 + i;
+		} else {
+			bitPointer = i;
+		}
+	}
+}

src/com/sun/pdfview/decode/DCTDecode.java

@@ -0,0 +1,94 @@
+/*
+ * $Id: DCTDecode.java,v 1.2 2007/12/20 18:33:33 rbair Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package com.sun.pdfview.decode;
+
+import java.io.IOException;
+import java.nio.IntBuffer;
+
+import net.sf.andpdf.pdfviewer.ByteBuffer;
+
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Bitmap.Config;
+import android.util.Log;
+
+import com.sun.pdfview.PDFObject;
+import com.sun.pdfview.PDFParseException;
+import com.sun.pdfview.colorspace.PDFColorSpace;
+
+/**
+ * decode a DCT encoded array into a byte array.  This class uses Java's
+ * built-in JPEG image class to do the decoding.
+ *
+ * @author Mike Wessler
+ */
+public class DCTDecode {
+
+    /**
+     * decode an array of bytes in DCT format.
+     * <p>
+     * DCT is the format used by JPEG images, so this class simply
+     * loads the DCT-format bytes as an image, then reads the bytes out
+     * of the image to create the array.  Unfortunately, their most
+     * likely use is to get turned BACK into an image, so this isn't
+     * terribly efficient... but is is general... don't hit, please.
+     * <p>
+     * The DCT-encoded stream may have 1, 3 or 4 samples per pixel, depending
+     * on the colorspace of the image.  In decoding, we look for the colorspace
+     * in the stream object's dictionary to decide how to decode this image.
+     * If no colorspace is present, we guess 3 samples per pixel.
+     *
+     * @param dict the stream dictionary
+     * @param buf the DCT-encoded buffer
+     * @param params the parameters to the decoder (ignored)
+     * @return the decoded buffer
+     */
+    protected static ByteBuffer decode(PDFObject dict, ByteBuffer buf,
+        PDFObject params) throws PDFParseException
+    {
+	//	System.out.println("DCTDecode image info: "+params);
+        buf.rewind();
+        
+        // copy the data into a byte array required by createimage
+        byte[] ary = new byte[buf.remaining()];
+        buf.get(ary);
+
+        Bitmap img = BitmapFactory.decodeByteArray(ary, 0, ary.length);
+
+        if (img == null)
+        	throw new PDFParseException("could not decode image of compressed size "+ary.length);
+    	Config conf = img.getConfig();
+    	Log.e("ANDPDF.dctdecode", "decoded image type"+conf);
+    	int size = 4*img.getWidth()*img.getHeight();
+    	if (conf == Config.RGB_565) 
+    		size = 2*img.getWidth()*img.getHeight();
+    	// TODO [FHe]: else ... what do we get for gray? Config.ALPHA_8?
+    
+        java.nio.ByteBuffer byteBuf = java.nio.ByteBuffer.allocate(size);
+        img.copyPixelsToBuffer(byteBuf);
+        
+        ByteBuffer result = ByteBuffer.fromNIO(byteBuf);
+        result.reset();
+        return result;
+    }
+}
+

src/com/sun/pdfview/decode/FlateDecode.java

@@ -0,0 +1,102 @@
+/*
+ * $Id: FlateDecode.java,v 1.4 2009/01/03 17:23:30 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview.decode;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.zip.DataFormatException;
+import java.util.zip.Inflater;
+
+import net.sf.andpdf.pdfviewer.ByteBuffer;
+
+import com.sun.pdfview.PDFObject;
+import com.sun.pdfview.PDFParseException;
+
+/**
+ * decode a deFlated byte array
+ * @author Mike Wessler
+ */
+public class FlateDecode {
+
+    /**
+     * decode a byte buffer in Flate format.
+     * <p>
+     * Flate is a built-in Java algorithm.  It's part of the java.util.zip
+     * package.
+     *
+     * @param buf the deflated input buffer
+     * @param params parameters to the decoder (unused)
+     * @return the decoded (inflated) bytes
+     */
+    public static ByteBuffer decode(PDFObject dict, ByteBuffer buf,
+            PDFObject params) throws IOException {
+        Inflater inf = new Inflater(false);
+
+        int bufSize = buf.remaining();
+
+        // copy the data, since the array() method is not supported
+        // on raf-based ByteBuffers
+        byte[] data = new byte[bufSize];
+        buf.get(data);
+
+        // set the input to the inflater
+        inf.setInput(data);
+
+        // output to a byte-array output stream, since we don't
+        // know how big the output will be
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        byte[] decomp = new byte[bufSize];
+        int loc = 0;
+        int read = 0;
+
+        try {
+            while (!inf.finished()) {
+                read = inf.inflate(decomp);
+                if (read <= 0) {
+//		    System.out.println("Read = " + read + "! Params: " + params);
+                    if (inf.needsDictionary()) {
+                        throw new PDFParseException("Don't know how to ask for a dictionary in FlateDecode");
+                    } else {
+//			System.out.println("Inflate data length=" + buf.remaining());
+                        return ByteBuffer.allocate(0);
+                    //			throw new PDFParseException("Inflater wants more data... but it's already here!");
+                    }
+                }
+                baos.write(decomp, 0, read);
+            }
+        } catch (DataFormatException dfe) {
+            throw new PDFParseException("Data format exception:" + dfe.getMessage());
+        }
+
+        // return the output as a byte buffer
+        ByteBuffer outBytes = ByteBuffer.wrap(baos.toByteArray());
+
+        // undo a predictor algorithm, if any was used
+        if (params != null && params.getDictionary().containsKey("Predictor")) {
+            Predictor predictor = Predictor.getPredictor(params);
+            if (predictor != null) {
+                outBytes = predictor.unpredict(outBytes);
+            }
+        }
+
+        return outBytes;
+    }
+}

src/com/sun/pdfview/decode/LZWDecode.java

@@ -0,0 +1,204 @@
+/*
+ * $Id: LZWDecode.java,v 1.4 2009/02/22 00:45:32 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview.decode;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+import net.sf.andpdf.pdfviewer.ByteBuffer;
+
+import com.sun.pdfview.PDFObject;
+import com.sun.pdfview.PDFParseException;
+
+/**
+ * decode an LZW-encoded array of bytes.  LZW is a patented algorithm.
+ *
+ * <p>Feb 21, 2009 Legal statement on Intellectual Property from Unisys</p><pre>
+ * <b><u>LZW Patent Information</u></b> (http://www.unisys.com/about__unisys/lzw)
+ * <u>License Information on GIF and Other LZW-based Technologies
+ * </u><p>
+ * <b><i>Unisys U.S. LZW Patent No. 4,558,302 expired on June 20, 2003,
+ * the counterpart patents in the United Kingdom, France, Germany and
+ * Italy expired on June 18, 2004, the Japanese counterpart patents
+ * expired on June 20, 2004 and the counterpart Canadian patent
+ * expired on July 7, 2004.
+ * </i></b><p>
+ * Unisys Corporation holds and has patents pending on a number of
+ * improvements on the inventions claimed in the above-expired patents.
+ * Information on these improvement patents and terms under which they
+ * may be licensed can be obtained by contacting the following:
+ *<p>
+ * Unisys Corporation
+ * Welch Patent Licensing Department
+ * Mail Stop E8-114
+ * Unisys Way
+ * Blue Bell, PA  19424
+ *<p>
+ * Via the Internet, send email to Robert.Marley@unisys.com.
+ *<p>
+ * Via facsimile, send inquiries to Welch Patent Licensing Department at
+ * 215-986-3090.
+ *<p>
+ * The above is presented for information purposes only, and is subject
+ * to change by Unisys.  Additionally, this information should not be
+ * considered as legally obligating Unisys in any way with regard to license
+ * availability, or as to the terms and conditions offered for a license,
+ * or with regard to the interpretation of any license agreements.
+ * You should consult with your own legal counsel regarding your
+ * particular situation.
+ * </pre></p>
+ * 
+ * @author Mike Wessler
+ */
+public class LZWDecode {
+
+    ByteBuffer buf;
+    int bytepos;
+    int bitpos;
+    byte[] dict[] = new byte[4096][];
+    int dictlen = 0;
+    int bitspercode = 9;
+    static int STOP = 257;
+    static int CLEARDICT = 256;
+
+    /**
+     * initialize this decoder with an array of encoded bytes
+     * @param buf the buffer of bytes
+     */
+    private LZWDecode(ByteBuffer buf) throws PDFParseException {
+        for (int i = 0; i < 256; i++) {
+            dict[i] = new byte[1];
+            dict[i][0] = (byte) i;
+        }
+        dictlen = 258;
+        bitspercode = 9;
+        this.buf = buf;
+        bytepos = 0;
+        bitpos = 0;
+    }
+
+    /**
+     * reset the dictionary to the initial 258 entries
+     */
+    private void resetDict() {
+        dictlen = 258;
+        bitspercode = 9;
+    }
+
+    /**
+     * get the next code from the input stream
+     */
+    private int nextCode() {
+        int fillbits = bitspercode;
+        int value = 0;
+        if (bytepos >= buf.limit() - 1) {
+            return -1;
+        }
+        while (fillbits > 0) {
+            int nextbits = buf.get(bytepos);  // bitsource
+            int bitsfromhere = 8 - bitpos;  // how many bits can we take?
+            if (bitsfromhere > fillbits) { // don't take more than we need
+                bitsfromhere = fillbits;
+            }
+            value |= ((nextbits >> (8 - bitpos - bitsfromhere)) &
+                    (0xff >> (8 - bitsfromhere))) << (fillbits - bitsfromhere);
+            fillbits -= bitsfromhere;
+            bitpos += bitsfromhere;
+            if (bitpos >= 8) {
+                bitpos = 0;
+                bytepos++;
+            }
+        }
+        return value;
+    }
+
+    /**
+     * decode the array.
+     * @return the uncompressed byte array
+     */
+    private ByteBuffer decode() throws PDFParseException {
+        // algorithm derived from:
+        // http://www.rasip.fer.hr/research/compress/algorithms/fund/lz/lzw.html
+        // and the PDFReference
+        int cW = CLEARDICT;
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        while (true) {
+            int pW = cW;
+            cW = nextCode();
+            if (cW == -1) {
+                throw new PDFParseException("Missed the stop code in LZWDecode!");
+            }
+            if (cW == STOP) {
+                break;
+            } else if (cW == CLEARDICT) {
+                resetDict();
+            //		pW= -1;
+            } else if (pW == CLEARDICT) {
+                baos.write(dict[cW], 0, dict[cW].length);
+            } else {
+                if (cW < dictlen) {  // it's a code in the dictionary
+                    baos.write(dict[cW], 0, dict[cW].length);
+                    byte[] p = new byte[dict[pW].length + 1];
+                    System.arraycopy(dict[pW], 0, p, 0, dict[pW].length);
+                    p[dict[pW].length] = dict[cW][0];
+                    dict[dictlen++] = p;
+                } else {  // not in the dictionary (should==dictlen)
+                    //		    if (cW!=dictlen) {
+                    //			System.out.println("Got a bouncy code: "+cW+" (dictlen="+dictlen+")");
+                    //		    }
+                    byte[] p = new byte[dict[pW].length + 1];
+                    System.arraycopy(dict[pW], 0, p, 0, dict[pW].length);
+                    p[dict[pW].length] = p[0];
+                    baos.write(p, 0, p.length);
+                    dict[dictlen++] = p;
+                }
+                if (dictlen >= (1 << bitspercode) - 1 && bitspercode < 12) {
+                    bitspercode++;
+                }
+            }
+        }
+        return ByteBuffer.wrap(baos.toByteArray());
+    }
+
+    /**
+     * decode an array of LZW-encoded bytes to a byte array.
+     *
+     * @param buf the buffer of encoded bytes
+     * @param params parameters for the decoder (unused)
+     * @return the decoded uncompressed bytes
+     */
+    public static ByteBuffer decode(ByteBuffer buf, PDFObject params)
+            throws IOException {
+        // decode the array
+        LZWDecode me = new LZWDecode(buf);
+        ByteBuffer outBytes = me.decode();
+
+        // undo a predictor algorithm, if any was used
+        if (params != null && params.getDictionary().containsKey("Predictor")) {
+            Predictor predictor = Predictor.getPredictor(params);
+            if (predictor != null) {
+                outBytes = predictor.unpredict(outBytes);
+            }
+        }
+
+        return outBytes;
+    }
+}

src/com/sun/pdfview/decode/PDFDecoder.java

@@ -0,0 +1,122 @@
+/*
+ * $Id: PDFDecoder.java,v 1.5 2009/03/12 12:26:19 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview.decode;
+
+import java.io.IOException;
+
+import net.sf.andpdf.pdfviewer.ByteBuffer;
+
+import com.sun.pdfview.PDFObject;
+import com.sun.pdfview.PDFParseException;
+import com.sun.pdfview.decrypt.PDFDecrypterFactory;
+
+/**
+ * A PDF Decoder encapsulates all the methods of decoding a stream of bytes
+ * based on all the various encoding methods.
+ * <p>
+ * You should use the decodeStream() method of this object rather than using
+ * any of the decoders directly.
+ */
+public class PDFDecoder {
+
+    /** Creates a new instance of PDFDecoder */
+    private PDFDecoder() {
+    }
+
+    /**
+     * decode a byte[] stream using the filters specified in the object's
+     * dictionary (passed as argument 1).
+     * @param dict the dictionary associated with the stream
+     * @param streamBuf the data in the stream, as a byte buffer
+     */
+    public static ByteBuffer decodeStream(PDFObject dict, ByteBuffer streamBuf)
+            throws IOException {
+
+        PDFObject filter = dict.getDictRef("Filter");
+        if (filter == null) {
+            // just apply default decryption
+            return dict.getDecrypter().decryptBuffer(null, dict, streamBuf);
+        } else {
+            // apply filters
+            PDFObject ary[];
+            PDFObject params[];
+	    if (filter.getType() == PDFObject.NAME) {
+                ary = new PDFObject[1];
+                ary[0] = filter;
+                params = new PDFObject[1];
+                params[0] = dict.getDictRef("DecodeParms");
+            } else {
+                ary = filter.getArray();
+                PDFObject parmsobj = dict.getDictRef("DecodeParms");
+                if (parmsobj != null) {
+                    params = parmsobj.getArray();
+                } else {
+                    params = new PDFObject[ary.length];
+                }
+            }
+
+            // determine whether default encryption applies or if there's a
+            // specific Crypt filter; it must be the first filter according to
+            // the errata for PDF1.7
+            boolean specificCryptFilter =
+                    ary.length != 0 && ary[0].getStringValue().equals("Crypt");
+            if (!specificCryptFilter) {
+                // No Crypt filter, so should apply default decryption (if
+                // present!)
+                streamBuf = dict.getDecrypter().decryptBuffer(
+                        null, dict, streamBuf);
+            }
+
+            for (int i = 0; i < ary.length; i++) {
+                String enctype = ary[i].getStringValue();
+                if (enctype == null) {
+                } else if (enctype.equals("FlateDecode") || enctype.equals("Fl")) {
+                    streamBuf = FlateDecode.decode(dict, streamBuf, params[i]);
+                } else if (enctype.equals("LZWDecode") || enctype.equals("LZW")) {
+                    streamBuf = LZWDecode.decode(streamBuf, params[i]);
+                } else if (enctype.equals("ASCII85Decode") || enctype.equals("A85")) {
+                    streamBuf = ASCII85Decode.decode(streamBuf, params[i]);
+                } else if (enctype.equals("ASCIIHexDecode") || enctype.equals("AHx")) {
+                    streamBuf = ASCIIHexDecode.decode(streamBuf, params[i]);
+                } else if (enctype.equals("RunLengthDecode") || enctype.equals("RL")) {
+                    streamBuf = RunLengthDecode.decode(streamBuf, params[i]);
+                } else if (enctype.equals("DCTDecode") || enctype.equals("DCT")) {
+                    streamBuf = DCTDecode.decode(dict, streamBuf, params[i]);
+                } else if (enctype.equals("CCITTFaxDecode") || enctype.equals("CCF")) {
+                    streamBuf = CCITTFaxDecode.decode(dict, streamBuf, params[i]);
+                } else if (enctype.equals("Crypt")) {
+                    String cfName = PDFDecrypterFactory.CF_IDENTITY;
+                    if (params[i] != null) {
+                        final PDFObject nameObj = params[i].getDictRef("Name");
+                        if (nameObj != null && nameObj.getType() == PDFObject.NAME) {
+                            cfName = nameObj.getStringValue();
+                        }
+                    }
+                    streamBuf = dict.getDecrypter().decryptBuffer(cfName, null, streamBuf);
+                } else {
+                    throw new PDFParseException("Unknown coding method:" + ary[i].getStringValue());
+                }
+            }
+        }
+
+        return streamBuf;
+    }
+}

src/com/sun/pdfview/decode/PNGPredictor.java

@@ -0,0 +1,213 @@
+/*
+ * $Id: PNGPredictor.java,v 1.3 2009/02/12 13:53:58 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package com.sun.pdfview.decode;
+
+import java.io.IOException;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import net.sf.andpdf.pdfviewer.ByteBuffer;
+
+/**
+ * Undo prediction based on the PNG algorithm.
+ */
+public class PNGPredictor extends Predictor {
+    /** Creates a new instance of PNGPredictor */
+    public PNGPredictor() {
+        super (PNG);
+    }
+    
+    /**
+     * Undo data based on the png algorithm
+     */
+    public ByteBuffer unpredict(ByteBuffer imageData)
+        throws IOException
+    {
+        List<byte[]> rows = new ArrayList<byte[]>();
+        
+        byte[] curLine = null;
+        byte[] prevLine = null;
+        
+        // get the number of bytes per row
+        int rowSize = getColumns() * getColors() * getBitsPerComponent();
+        rowSize = (int) Math.ceil(rowSize / 8.0);
+        
+        while(imageData.remaining() >= rowSize + 1) {
+            // the first byte determines the algorithm
+            int algorithm = (int) (imageData.get() & 0xff);
+            
+            // read the rest of the line
+            curLine = new byte[rowSize];
+            imageData.get(curLine);
+            
+            // use the algorithm, Luke
+            switch (algorithm) {
+                case 0:
+                    // none
+                    break;
+                case 1:
+                    doSubLine(curLine);
+                    break;
+                case 2:
+                    doUpLine(curLine, prevLine);
+                    break;
+                case 3:
+                    doAverageLine(curLine, prevLine);
+                    break;
+                case 4:
+                    doPaethLine(curLine, prevLine);
+                    break;
+            }
+            
+            rows.add(curLine);
+            prevLine = curLine;
+        }
+        
+        // turn into byte array
+        ByteBuffer outBuf = ByteBuffer.allocate(rows.size() * rowSize);
+        for (Iterator i = rows.iterator(); i.hasNext();) {
+            outBuf.put((byte[]) i.next());
+        }
+        
+        // reset start pointer
+        outBuf.flip();
+        
+        // return
+        return outBuf;
+        
+    }
+    
+    /**
+     * Return the value of the Sub algorithm on the line (compare bytes to
+     * the previous byte of the same color on this line).
+     */
+    protected void doSubLine(byte[] curLine) {
+        // get the number of bytes per sample
+        int sub = (int) Math.ceil((getBitsPerComponent() * getColors()) / 8.0); 
+        
+        for (int i = 0; i < curLine.length; i++) {
+            int prevIdx = i - sub;
+            if (prevIdx >= 0) {
+                curLine[i] += curLine[prevIdx];
+            }
+        }
+    }
+    
+    /**
+     * Return the value of the up algorithm on the line (compare bytes to
+     * the same byte in the previous line)
+     */
+    protected void doUpLine(byte[] curLine, byte[] prevLine) {
+        if (prevLine == null) {
+            // do nothing if this is the first line
+            return;
+        }
+        
+        for (int i = 0; i < curLine.length; i++) {
+            curLine[i] += prevLine[i];
+        }
+    }
+    
+    /**
+     * Return the value of the average algorithm on the line (compare
+     * bytes to the average of the previous byte of the same color and 
+     * the same byte on the previous line)
+     */
+    protected void doAverageLine(byte[] curLine, byte[] prevLine) {
+         // get the number of bytes per sample
+        int sub = (int) Math.ceil((getBitsPerComponent() * getColors()) / 8.0); 
+        
+        for (int i = 0; i < curLine.length; i++) {
+            int raw = 0;
+            int prior = 0;
+            
+            // get the last value of this color
+            int prevIdx = i - sub;
+            if (prevIdx >= 0) {
+                raw = curLine[prevIdx] & 0xff;
+            }
+            
+            // get the value on the previous line
+            if (prevLine != null) {
+                prior = prevLine[i] & 0xff;
+            }
+            
+            // add the average
+            curLine[i] += (byte) Math.floor((raw + prior) / 2);
+        }      
+    }
+    
+     /**
+     * Return the value of the average algorithm on the line (compare
+     * bytes to the average of the previous byte of the same color and 
+     * the same byte on the previous line)
+     */
+    protected void doPaethLine(byte[] curLine, byte[] prevLine) {
+         // get the number of bytes per sample
+        int sub = (int) Math.ceil((getBitsPerComponent() * getColors()) / 8.0); 
+        
+        for (int i = 0; i < curLine.length; i++) {
+            int left = 0;
+            int up = 0;
+            int upLeft = 0;
+            
+            // get the last value of this color
+            int prevIdx = i - sub;
+            if (prevIdx >= 0) {
+                left = curLine[prevIdx] & 0xff;
+            }
+            
+            // get the value on the previous line
+            if (prevLine != null) {
+                up = prevLine[i] & 0xff;
+            }
+            
+            if (prevIdx > 0 && prevLine != null) {
+                upLeft = prevLine[prevIdx] & 0xff;
+            }
+            
+            // add the average
+            curLine[i] += (byte) paeth(left, up, upLeft);
+        }      
+    }
+    
+    /**
+     * The paeth algorithm
+     */
+    protected int paeth(int left, int up, int upLeft) {
+        int p = left + up - upLeft;
+        int pa = Math.abs(p - left);
+        int pb = Math.abs(p - up);
+        int pc = Math.abs(p - upLeft);
+        
+        if ((pa <= pb) && (pa <= pc)) {
+            return left;
+        } else if (pb <= pc) {
+            return up;
+        } else {
+            return upLeft;
+        }
+    }
+    
+}

src/com/sun/pdfview/decode/Predictor.java

@@ -0,0 +1,175 @@
+/*
+ * $Id: Predictor.java,v 1.2 2007/12/20 18:33:33 rbair Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package com.sun.pdfview.decode;
+
+import java.io.IOException;
+
+import net.sf.andpdf.pdfviewer.ByteBuffer;
+
+import com.sun.pdfview.PDFObject;
+import com.sun.pdfview.PDFParseException;
+
+/**
+ * The abstract superclass of various predictor objects that undo well-known
+ * prediction algorithms.
+ */
+public abstract class Predictor {
+    /** well known algorithms */
+    public static final int TIFF = 0;
+    public static final int PNG = 1;
+    
+    /** the algorithm to use */
+    private int algorithm;
+    
+    /** the number of colors per sample */
+    private int colors = 1;
+    
+    /** the number of bits per color component */
+    private int bpc = 8;
+    
+    /** the number of columns per row */
+    private int columns = 1;
+    
+    /** 
+     * Create an instance of a predictor.  Use <code>getPredictor()</code>
+     * instead of this.
+     */
+    protected Predictor(int algorithm) {
+        this.algorithm = algorithm;
+    }
+    
+    /**
+     * Actually perform this algorithm on decoded image data.
+     * Subclasses must implement this method
+     */
+    public abstract ByteBuffer unpredict(ByteBuffer imageData)
+        throws IOException;
+    
+    /**
+     * Get an instance of a predictor
+     *
+     * @param params the filter parameters
+     */
+    public static Predictor getPredictor(PDFObject params)
+        throws IOException
+    {
+        // get the algorithm (required)
+        PDFObject algorithmObj = params.getDictRef("Predictor");
+        if (algorithmObj == null) {
+            // no predictor
+            return null;
+        }
+        int algorithm = algorithmObj.getIntValue();
+    
+        // create the predictor object
+        Predictor predictor = null;
+        switch (algorithm) {
+            case 1:
+                // no predictor
+                return null;
+            case 2:
+                throw new PDFParseException("Tiff Predictor not supported");
+            case 10:
+            case 11:
+            case 12:
+            case 13:
+            case 14:
+            case 15:
+                predictor = new PNGPredictor();
+                break;
+            default:
+                throw new PDFParseException("Unknown predictor: " + algorithm);
+        }
+        
+        // read the colors (optional)
+        PDFObject colorsObj = params.getDictRef("Colors");
+        if (colorsObj != null) {
+            predictor.setColors(colorsObj.getIntValue());
+        }
+        
+        // read the bits per component (optional)
+        PDFObject bpcObj = params.getDictRef("BitsPerComponent");
+        if (bpcObj != null) {
+            predictor.setBitsPerComponent(bpcObj.getIntValue());
+        }
+        
+        // read the columns (optional)
+        PDFObject columnsObj = params.getDictRef("Columns");
+        if (columnsObj != null) {
+            predictor.setColumns(columnsObj.getIntValue());
+        }
+        
+        // all set
+        return predictor;
+    }
+    
+    /**
+     * Get the algorithm in use
+     *
+     * @return one of the known algorithm types
+     */
+    public int getAlgorithm() {
+        return algorithm;
+    }
+    
+    /**
+     * Get the number of colors per sample
+     */
+    public int getColors() {
+        return colors;
+    }
+    
+    /**
+     * Set the number of colors per sample
+     */
+    protected void setColors(int colors) {
+        this.colors = colors;
+    }
+    
+    /**
+     * Get the number of bits per color component
+     */
+    public int getBitsPerComponent() {
+        return bpc;
+    }
+    
+    /**
+     * Set the number of bits per color component
+     */
+    public void setBitsPerComponent(int bpc) {
+        this.bpc = bpc;
+    }
+    
+    /**
+     * Get the number of columns
+     */
+    public int getColumns() {
+        return columns;
+    }
+    
+    /**
+     * Set the number of columns
+     */
+    public void setColumns(int columns) {
+        this.columns = columns;
+    }
+}

src/com/sun/pdfview/decode/RunLengthDecode.java

@@ -0,0 +1,99 @@
+/*
+ * $Id: RunLengthDecode.java,v 1.1 2009/02/21 20:04:52 tomoke Exp $
+ *
+ * Copyright 2009 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview.decode;
+
+import java.io.ByteArrayOutputStream;
+
+import net.sf.andpdf.pdfviewer.ByteBuffer;
+
+import com.sun.pdfview.PDFObject;
+import com.sun.pdfview.PDFParseException;
+
+/**
+ * decode an array of Run Length encoded bytes into a byte array
+ *
+ * @author Mike Wessler
+ */
+public class RunLengthDecode {
+    /** the end of data in the RunLength encoding. */
+    private static final int RUN_LENGTH_EOD = 128;
+
+    private ByteBuffer buf;
+
+    /**
+     * initialize the decoder with an array of bytes in RunLength format
+     */
+    private RunLengthDecode(ByteBuffer buf) {
+        this.buf = buf;
+    }
+
+    /**
+     * decode the array
+     * @return the decoded bytes
+     */
+    private ByteBuffer decode() throws PDFParseException {
+        // start at the beginning of the buffer
+        buf.rewind();
+
+        // allocate the output buffer
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        byte dupAmount = -1;
+        byte[] buffer = new byte[128];
+        while ((dupAmount = buf.get()) != -1 &&
+                dupAmount != RUN_LENGTH_EOD) {
+            if (dupAmount <= 127) {
+                int amountToCopy = dupAmount + 1;
+                while (amountToCopy > 0) {
+                    buf.get(buffer, 0, amountToCopy);
+                    baos.write(buffer, 0, amountToCopy);
+                }
+            } else {
+                byte dupByte = buf.get();
+                for (int i = 0; i < 257 - (int) (dupAmount & 0xFF); i++) {
+                    baos.write(dupByte);
+                }
+            }
+        }
+        return ByteBuffer.wrap(baos.toByteArray());
+    }
+
+    /**
+     * decode an array of bytes in RunLength format.
+     * <p>
+     * RunLength format consists of a sequence of a byte-oriented format
+     * based on run length. There are a series of "runs", where
+     * a run is a length byte followed by 1 to 128 bytes of data.
+     * If the length is 0-127, the following length+1 (1 to 128) bytes are
+     * to be copied. If the length is 129 through 255, the following
+     * single byte is copied 257-length (2 to 128) times.
+     * A length value of 128 means and End of Data (EOD).
+     *
+     * @param buf the RUnLEngth encoded bytes in a byte buffer
+     *
+     * @param params parameters to the decoder (ignored)
+     * @return the decoded bytes
+     */
+    public static ByteBuffer decode(ByteBuffer buf, PDFObject params)
+            throws PDFParseException {
+        RunLengthDecode me = new RunLengthDecode(buf);
+        return me.decode();
+    }
+}

src/com/sun/pdfview/decrypt/CryptFilterDecrypter.java

@@ -0,0 +1,129 @@
+/*
+ * Copyright 2008 Pirion Systems Pty Ltd, 139 Warry St,
+ * Fortitude Valley, Queensland, Australia
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package com.sun.pdfview.decrypt;
+
+import com.sun.pdfview.PDFObject;
+import com.sun.pdfview.PDFParseException;
+
+import java.util.Map;
+
+import net.sf.andpdf.pdfviewer.ByteBuffer;
+
+/**
+ * Implements Version 4 standard decryption, whereby the Encrypt dictionary
+ * contains a list of named 'crypt filters', each of which is the equivalent
+ * of a {@link PDFDecrypter}. In addition to this list of crypt filters,
+ * the name of the filter to use for streams and the default filter to use
+ * for strings is specified. Requests to decode a stream with a named
+ * decrypter (typically Identity) instead of the default decrypter
+ * are honoured. 
+ *
+ * @author Luke Kirby
+ */
+public class CryptFilterDecrypter implements PDFDecrypter {
+
+    /** Maps from crypt filter names to their corresponding decrypters */
+    private Map<String, PDFDecrypter> decrypters;
+    /** The default decrypter for stream content */
+    private PDFDecrypter defaultStreamDecrypter;
+    /** The default decrypter for string content */
+    private PDFDecrypter defaultStringDecrypter;
+
+    /**
+     * Class constructor
+     * @param decrypters a map of crypt filter names to their corresponding
+     *  decrypters. Must already contain the Identity filter.
+     * @param defaultStreamCryptName the crypt filter name of the default
+     *  stream decrypter
+     * @param defaultStringCryptName the crypt filter name of the default
+     * string decrypter
+     * @throws PDFParseException if one of the named defaults is not
+     *  present in decrypters
+     */
+    public CryptFilterDecrypter(
+            Map<String, PDFDecrypter> decrypters,
+            String defaultStreamCryptName,
+            String defaultStringCryptName)
+            throws PDFParseException {
+
+        this.decrypters = decrypters;
+        assert this.decrypters.containsKey("Identity") :
+                "Crypt Filter map does not contain required Identity filter";
+        defaultStreamDecrypter = this.decrypters.get(defaultStreamCryptName);
+        if (defaultStreamDecrypter == null) {
+            throw new PDFParseException(
+                    "Unknown crypt filter specified as default for streams: " +
+                            defaultStreamCryptName);
+        }
+        defaultStringDecrypter = this.decrypters.get(defaultStringCryptName);
+        if (defaultStringDecrypter == null) {
+            throw new PDFParseException(
+                    "Unknown crypt filter specified as default for strings: " +
+                            defaultStringCryptName);
+        }
+    }
+
+    public ByteBuffer decryptBuffer(
+            String cryptFilterName, PDFObject streamObj, ByteBuffer streamBuf)
+            throws PDFParseException {
+        final PDFDecrypter decrypter;
+        if (cryptFilterName == null) {
+            decrypter = defaultStreamDecrypter;
+        } else {
+            decrypter = decrypters.get(cryptFilterName);
+            if (decrypter == null) {
+                throw new PDFParseException("Unknown CryptFilter: " +
+                        cryptFilterName);
+            }
+        }
+        return decrypter.decryptBuffer(
+                // elide the filter name to prevent V2 decrypters from
+                // complaining about a crypt filter name
+                null,
+                // if there's a specific crypt filter being used then objNum
+                // and objGen shouldn't contribute to the key, so we
+                // should make sure that no streamObj makes its way through
+                cryptFilterName != null ? null : streamObj,
+                streamBuf);
+    }
+
+    public String decryptString(int objNum, int objGen, String inputBasicString)
+            throws PDFParseException {
+        return defaultStringDecrypter.decryptString(objNum, objGen, inputBasicString);
+    }
+
+    public boolean isEncryptionPresent() {
+        for (final PDFDecrypter decrypter : decrypters.values()) {
+            if (decrypter.isEncryptionPresent()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public boolean isOwnerAuthorised() {
+        for (final PDFDecrypter decrypter : decrypters.values()) {
+            if (decrypter.isOwnerAuthorised()) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

src/com/sun/pdfview/decrypt/EncryptionUnsupportedByPlatformException.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2008 Pirion Systems Pty Ltd, 139 Warry St,
+ * Fortitude Valley, Queensland, Australia
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package com.sun.pdfview.decrypt;
+
+/**
+ * Identifies that the specified encryption mechanism, though supported by the
+ * product, is not supported by the platform that it is running on; i.e., that
+ * either the JCE does not support a required cipher or that its policy is
+ * such that a key of a given length can not be used.
+ *
+ * @author Luke Kirby
+ */
+public class EncryptionUnsupportedByPlatformException
+        extends UnsupportedEncryptionException {
+
+    public EncryptionUnsupportedByPlatformException(String message) {
+        super(message);
+    }
+
+    public EncryptionUnsupportedByPlatformException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}

src/com/sun/pdfview/decrypt/EncryptionUnsupportedByProductException.java

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2008 Pirion Systems Pty Ltd, 139 Warry St,
+ * Fortitude Valley, Queensland, Australia
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package com.sun.pdfview.decrypt;
+
+/**
+ * Identifies that the specified encryption mechanism is not
+ * supported by this product, that is, PDFRenderer, as opposed to
+ * a {@link EncryptionUnsupportedByPlatformException limitation in
+ * the platform}. 
+ *
+ * @author Luke Kirby
+ */
+public class EncryptionUnsupportedByProductException
+        extends UnsupportedEncryptionException {
+
+    public EncryptionUnsupportedByProductException(String message) {
+        super(message);
+    }
+}

src/com/sun/pdfview/decrypt/IdentityDecrypter.java

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2008 Pirion Systems Pty Ltd, 139 Warry St,
+ * Fortitude Valley, Queensland, Australia
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package com.sun.pdfview.decrypt;
+
+import net.sf.andpdf.pdfviewer.ByteBuffer;
+
+import com.sun.pdfview.PDFObject;
+import com.sun.pdfview.PDFParseException;
+
+
+/**
+ * Performs identity decryption; that is, inputs aren't encrypted and
+ * are returned right back.
+ *
+ * @Author Luke Kirby
+ */
+public class IdentityDecrypter implements PDFDecrypter {
+
+    private static IdentityDecrypter INSTANCE = new IdentityDecrypter();
+
+    public ByteBuffer decryptBuffer(String cryptFilterName,
+            PDFObject streamObj, ByteBuffer streamBuf)
+            throws PDFParseException {
+
+        if (cryptFilterName != null) {
+            throw new PDFParseException("This Encryption version does not support Crypt filters");
+        }
+
+        return streamBuf;
+    }
+
+    public String decryptString(int objNum, int objGen, String inputBasicString) {
+        return inputBasicString;
+    }
+
+    public static IdentityDecrypter getInstance() {
+        return INSTANCE;
+    }
+
+    public boolean isEncryptionPresent() {
+        return false;
+    }
+
+    public boolean isOwnerAuthorised() {
+        return false;
+    }
+}

src/com/sun/pdfview/decrypt/PDFAuthenticationFailureException.java

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2008 Pirion Systems Pty Ltd, 139 Warry St,
+ * Fortitude Valley, Queensland, Australia
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package com.sun.pdfview.decrypt;
+
+import com.sun.pdfview.PDFParseException;
+
+/**
+ * Identifies that the supplied password was incorrect or non-existent
+ * and required.
+ * @author Luke Kirby
+ */
+// TODO - consider having this not extend PDFParseException so that
+// it will be handled more explicitly?
+public class PDFAuthenticationFailureException extends PDFParseException {
+    public PDFAuthenticationFailureException(String message) {
+        super(message);
+    }
+}

src/com/sun/pdfview/decrypt/PDFDecrypter.java

@@ -0,0 +1,98 @@
+/*
+ * Copyright 2008 Pirion Systems Pty Ltd, 139 Warry St,
+ * Fortitude Valley, Queensland, Australia
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package com.sun.pdfview.decrypt;
+
+import net.sf.andpdf.pdfviewer.ByteBuffer;
+
+import com.sun.pdfview.PDFObject;
+import com.sun.pdfview.PDFParseException;
+import com.sun.pdfview.PDFStringUtil;
+
+
+/**
+ * A decrypter decrypts streams and strings in a PDF document. {@link
+ * #decryptBuffer(String, PDFObject, ByteBuffer)} } should be used for decoding
+ * streams, and {@link #decryptString(int, int, String)} for string values in
+ * the PDF. It is possible for strings and streams to be encrypted with
+ * different mechanisms, so the appropriate method must alwayus be used.
+ *
+ * @see "PDFReference 1.7, Section 3.5 Encryption"
+ * @author Luke Kirby
+ */
+public interface PDFDecrypter {
+
+    /**
+     * Decrypt a buffer of data
+     * @param cryptFilterName the name of the crypt filter, if V4
+     *  encryption is being used, where individual crypt filters may
+     *  be specified for individual streams. If encryption is not using
+     *  V4 encryption (indicated by V=4 in the Encrypt dictionary) then
+     *  this must be null. Null may also be specified with V4 encryption
+     *  to indicate that the default filter should be used.
+     * @param streamObj the object whose stream is being decrypted. The
+     *  containing object's number and generation contribute to the key used for
+     *  stream encrypted with the document's default encryption, so this is
+     *  typically required. Should be null only if a cryptFilterName is
+     *  specified, as objects with specific stream filters use the general
+     *  document key, rather than a stream-specific key.
+     * @param streamBuf the buffer to decrypt
+     * @return a buffer containing the decrypted stream, positioned at its
+     *  beginning; will only be the same buffer as streamBuf if the identity
+     *  decrypter is being used
+     * @throws PDFParseException if the named crypt filter does not exist, or
+     *  if a crypt filter is named when named crypt filters are not supported.
+     *  Problems due to incorrect passwords are revealed prior to this point.
+     */
+    public ByteBuffer decryptBuffer(
+            String cryptFilterName,
+            PDFObject streamObj,
+            ByteBuffer streamBuf)
+            throws PDFParseException;
+
+    /**
+     * Decrypt a {@link PDFStringUtil basic string}.
+     * @param objNum the object number of the containing object
+     * @param objGen the generation number of the containing object
+     * @param inputBasicString the string to be decrypted
+     * @return the decrypted string
+     * @throws PDFParseException if the named crypt filter does not exist, or
+     *  if a crypt filter is named when named crypt filters are not supported.
+     *  Problems due to incorrect passwords are revealed prior to this point.
+     */
+    public String decryptString(int objNum, int objGen, String inputBasicString)
+            throws PDFParseException;
+
+    /**
+     * Determine whether the password known by the decrypter indicates that
+     * the user is the owner of the document. Can be used, in conjunction
+     * with {@link #isEncryptionPresent()} to determine whether any
+     * permissions apply.
+     * @return whether owner authentication is being used to decrypt the
+     *  document
+     */
+    public boolean isOwnerAuthorised();
+
+    /**
+     * Determine whether this actually applies a decryption other than
+     * identity decryption.
+     * @return whether encryption is present
+     */
+    public boolean isEncryptionPresent();
+}

src/com/sun/pdfview/decrypt/PDFDecrypterFactory.java

@@ -0,0 +1,320 @@
+/*
+ * Copyright 2008 Pirion Systems Pty Ltd, 139 Warry St,
+ * Fortitude Valley, Queensland, Australia
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package com.sun.pdfview.decrypt;
+
+import com.sun.pdfview.PDFObject;
+import com.sun.pdfview.PDFParseException;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+/**
+ * Produces a {@link PDFDecrypter} for documents given a (possibly non-existent)
+ * Encrypt dictionary. Supports decryption of versions 1, 2 and 4 of the
+ * password-based encryption mechanisms as described in PDF Reference version
+ * 1.7. This means that it supports RC4 and AES encryption with keys of
+ * 40-128 bits; esentially, password-protected documents with compatibility
+ * up to Acrobat 8.
+ *
+ * @See "PDF Reference version 1.7, section 3.5: Encryption"
+ * @author Luke Kirby
+ */
+public class PDFDecrypterFactory {
+
+    /** The name of the standard Identity CryptFilter */
+    public static final String CF_IDENTITY = "Identity";
+
+    /** Default key length for versions where key length is optional */
+    private static final int DEFAULT_KEY_LENGTH = 40;
+
+    /**
+     * Create a decryptor for a given encryption dictionary. A check is
+     * immediately performed that the supplied password decrypts content
+     * described by the encryption specification.
+     *
+     * @param encryptDict the Encrypt dict as found in the document's trailer.
+     *  May be null, in which case the {@link IdentityDecrypter} will
+     *  be returned.
+     * @param documentId the object with key "ID" in the trailer's dictionary.
+     *  Should always be present if Encrypt is.
+     * @param password the password to use; may be <code>null</code>
+     * @return The decryptor that should be used for all encrypted data in the
+     *  PDF
+     * @throws IOException will typically be a {@link
+     *  com.sun.pdfview.PDFParseException}, indicating an IO problem, an error
+     *  in the structure of the document, or a failure to obtain various ciphers
+     *  from the installed JCE providers
+     * @throws EncryptionUnsupportedByPlatformException if the encryption
+     *  is not supported by the environment in which the code is executing
+     * @throws EncryptionUnsupportedByProductException if PDFRenderer does
+     *  not currently support the specified encryption
+     * @throws PDFAuthenticationFailureException if the supplied password
+     *  was not able to 
+     */
+    public static PDFDecrypter createDecryptor
+            (PDFObject encryptDict, PDFObject documentId, PDFPassword password)
+            throws
+            IOException,
+            EncryptionUnsupportedByPlatformException,
+            EncryptionUnsupportedByProductException,
+            PDFAuthenticationFailureException {
+
+        // none of the classes beyond us want to see a null PDFPassword
+        password = PDFPassword.nonNullPassword(password);
+
+        if (encryptDict == null) {
+            // No encryption specified
+            return IdentityDecrypter.getInstance();
+        } else {
+            PDFObject filter = encryptDict.getDictRef("Filter");
+            // this means that we'll fail if, for example, public key
+            // encryption is employed
+            if (filter != null && "Standard".equals(filter.getStringValue())) {
+                final PDFObject vObj = encryptDict.getDictRef("V");
+                int v = vObj != null ? vObj.getIntValue() : 0;
+                if (v == 1 || v == 2) {
+                    final PDFObject lengthObj =
+                            encryptDict.getDictRef("Length");
+                    final Integer length =
+                            lengthObj != null ? lengthObj.getIntValue() : null;
+                    return createStandardDecrypter(
+                            encryptDict, documentId, password, length, false,
+                            StandardDecrypter.EncryptionAlgorithm.RC4);
+                } else if (v == 4) {
+                    return createCryptFilterDecrypter(
+                            encryptDict, documentId, password, v);
+                } else {
+                    throw new EncryptionUnsupportedByPlatformException(
+                            "Unsupported encryption version: " + v);
+                }
+            } else if (filter == null) {
+                throw new PDFParseException(
+                        "No Filter specified in Encrypt dictionary");
+            } else {
+                throw new EncryptionUnsupportedByPlatformException(
+                        "Unsupported encryption Filter: " + filter +
+                                "; only Standard is supported.");
+            }
+        }
+    }
+
+    /**
+     * Create a decrypter working from a crypt filter dictionary, as in
+     * version 4 encryption
+     *
+     * @param encryptDict the Encrypt dictionary
+     * @param documentId the document ID
+     * @param password the provided password
+     * @param v the version of encryption being used; must be at least 4
+     * @return the decrypter corresponding to the scheme expressed in
+     * encryptDict
+     * @throws PDFAuthenticationFailureException if the provided password
+     *  does not decrypt this document
+     * @throws IOException if there is a problem reading the PDF, an invalid
+     *  document structure, or an inability to obtain the required ciphers
+     *  from the platform's JCE
+     * @throws EncryptionUnsupportedByPlatformException if the encryption
+     *  is not supported by the environment in which the code is executing
+     * @throws EncryptionUnsupportedByProductException if PDFRenderer does
+     *  not currently support the specified encryption
+     */
+    private static PDFDecrypter createCryptFilterDecrypter(
+            PDFObject encryptDict,
+            PDFObject documentId,
+            PDFPassword password,
+            int v)
+            throws
+            PDFAuthenticationFailureException,
+            IOException,
+            EncryptionUnsupportedByPlatformException,
+            EncryptionUnsupportedByProductException {
+
+        assert v >= 4 : "crypt filter decrypter not supported for " +
+                        "standard encryption prior to version 4";
+
+        // encryptMetadata is true if not present. Note that we don't actually
+        // use this to change our reading of metadata streams (that's all done
+        // internally by the document specifying a Crypt filter of None if
+        // appropriate), but it does affect the encryption key.
+        boolean encryptMetadata = true;
+        final PDFObject encryptMetadataObj =
+                encryptDict.getDictRef("EncryptMetadata");
+        if (encryptMetadataObj != null
+                && encryptMetadataObj.getType() == PDFObject.BOOLEAN) {
+            encryptMetadata = encryptMetadataObj.getBooleanValue();
+        }
+
+        // Assemble decrypters for each filter in the
+        // crypt filter (CF) dictionary
+        final Map<String, PDFDecrypter> cfDecrypters =
+                new HashMap<String, PDFDecrypter>();
+        final PDFObject cfDict = encryptDict.getDictRef("CF");
+        if (cfDict == null) {
+            throw new PDFParseException(
+                    "No CF value present in Encrypt dict for V4 encryption");
+        }
+        final Iterator<String> cfNameIt = cfDict.getDictKeys();
+        while (cfNameIt.hasNext()) {
+            final String cfName = cfNameIt.next();
+            final PDFObject cryptFilter = cfDict.getDictRef(cfName);
+
+            final PDFObject lengthObj = cryptFilter.getDictRef("Length");
+            // The Errata for PDF 1.7 explains that the value of
+            // Length in CF dictionaries is in bytes
+            final Integer length = lengthObj != null ?
+                    lengthObj.getIntValue() * 8 : null;
+
+            // CFM is the crypt filter method, describing whether RC4,
+            // AES, or None (i.e., identity) is the encryption mechanism
+            // used for the name crypt filter
+            final PDFObject cfmObj = cryptFilter.getDictRef("CFM");
+            final String cfm = cfmObj != null ?
+                    cfmObj.getStringValue() : "None";
+            final PDFDecrypter cfDecrypter;
+            if ("None".equals(cfm)) {
+                cfDecrypter = IdentityDecrypter.getInstance();
+            } else if ("V2".equals(cfm)) {
+                cfDecrypter = createStandardDecrypter(
+                        encryptDict, documentId, password, length,
+                        encryptMetadata,
+                        StandardDecrypter.EncryptionAlgorithm.RC4);
+            } else if ("AESV2".equals(cfm)) {
+                cfDecrypter = createStandardDecrypter(
+                        encryptDict, documentId, password, length,
+                        encryptMetadata,
+                        StandardDecrypter.EncryptionAlgorithm.AESV2);
+            } else {
+                throw new UnsupportedOperationException(
+                        "Unknown CryptFilter method: " + cfm);
+            }
+            cfDecrypters.put(cfName, cfDecrypter);
+        }
+
+        // always put Identity in last so that it will override any
+        // Identity filter sneakily declared in the CF entry
+        cfDecrypters.put(CF_IDENTITY, IdentityDecrypter.getInstance());
+
+        PDFObject stmFObj = encryptDict.getDictRef("StmF");
+        final String defaultStreamFilter =
+                stmFObj != null ? stmFObj.getStringValue() : CF_IDENTITY;
+
+        PDFObject strFObj = encryptDict.getDictRef("StrF");
+        final String defaultStringFilter =
+                strFObj != null ? strFObj.getStringValue() : CF_IDENTITY;
+
+        return new CryptFilterDecrypter(
+                cfDecrypters, defaultStreamFilter, defaultStringFilter);
+
+    }
+
+    /**
+     * Create a standard single-algorithm AES or RC4 decrypter. The Encrypt
+     * dictionary is used where possible, but where different encryption
+     * versions employ different mechanisms of specifying configuration or may
+     * be specified via a CF entry (e.g. key length), the value is specified as
+     * a parameter.
+     *
+     * @param encryptDict the Encrypt dictionary
+     * @param documentId the document ID
+     * @param password the password
+     * @param keyLength the key length, in bits; may be <code>null</code>
+     *  to use a {@link #DEFAULT_KEY_LENGTH default}
+     * @param encryptMetadata whether metadata is being encrypted
+     * @param encryptionAlgorithm, the encryption algorithm
+     * @return the decrypter
+     * @throws PDFAuthenticationFailureException if the provided password
+     *  is not the one expressed by the encryption dictionary
+     * @throws IOException if there is a problem reading the PDF content,
+     *  if the content does not comply with the PDF specification
+     * @throws EncryptionUnsupportedByPlatformException if the encryption
+     *  is not supported by the environment in which the code is executing
+     * @throws EncryptionUnsupportedByProductException if PDFRenderer does
+     *  not currently support the specified encryption
+     *
+     */
+    private static PDFDecrypter createStandardDecrypter(
+            PDFObject encryptDict,
+            PDFObject documentId,
+            PDFPassword password,
+            Integer keyLength,
+            boolean encryptMetadata,
+            StandardDecrypter.EncryptionAlgorithm encryptionAlgorithm)
+            throws
+            PDFAuthenticationFailureException,
+            IOException,
+            EncryptionUnsupportedByPlatformException,
+            EncryptionUnsupportedByProductException {
+
+        if (keyLength == null) {
+            keyLength = DEFAULT_KEY_LENGTH;
+        }
+
+        // R describes the revision of the security handler
+        final PDFObject rObj = encryptDict.getDictRef("R");
+        if (rObj == null) {
+            throw new PDFParseException(
+                    "No R entry present in Encrypt dictionary");
+        }
+
+        final int revision = rObj.getIntValue();
+        if (revision < 2 || revision > 4) {
+            throw new EncryptionUnsupportedByPlatformException(
+                    "Unsupported Standard security handler revision; R=" +
+                            revision);
+        }
+
+        // O describes validation details for the owner key
+        final PDFObject oObj = encryptDict.getDictRef("O");
+        if (oObj == null) {
+            throw new PDFParseException(
+                    "No O entry present in Encrypt dictionary");
+        }
+        final byte[] o = oObj.getStream();
+        if (o.length != 32) {
+            throw new PDFParseException("Expected owner key O " +
+                    "value of 32 bytes; found " + o.length);
+        }
+
+        // U describes validation details for the user key
+        final PDFObject uObj = encryptDict.getDictRef("U");
+        if (uObj == null) {
+            throw new PDFParseException(
+                    "No U entry present in Encrypt dictionary");
+        }
+        final byte[] u = uObj.getStream();
+        if (u.length != 32) {
+            throw new PDFParseException(
+                    "Expected user key U value of 32 bytes; found " + o.length);
+        }
+
+        // P describes the permissions regarding document usage
+        final PDFObject pObj = encryptDict.getDictRef("P");
+        if (pObj == null) {
+            throw new PDFParseException(
+                    "Required P entry in Encrypt dictionary not found");
+        }
+
+        return new StandardDecrypter(
+                encryptionAlgorithm, documentId, keyLength,
+                revision, o, u, pObj.getIntValue(), encryptMetadata, password);
+    }
+}

src/com/sun/pdfview/decrypt/PDFPassword.java

@@ -0,0 +1,277 @@
+/*
+ * Copyright 2008 Pirion Systems Pty Ltd, 139 Warry St,
+ * Fortitude Valley, Queensland, Australia
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package com.sun.pdfview.decrypt;
+
+import com.sun.pdfview.PDFDocCharsetEncoder;
+import com.sun.pdfview.Identity8BitCharsetEncoder;
+import com.sun.pdfview.PDFStringUtil;
+
+import java.util.*;
+import java.nio.charset.CodingErrorAction;
+import java.nio.charset.CharacterCodingException;
+import java.nio.charset.CharsetEncoder;
+import java.nio.CharBuffer;
+import java.nio.ByteBuffer;
+
+/**
+ * <p>Identifies a PDF Password, expressible either as a string or a
+ * byte sequence.</p>
+ *
+ * <p>In revisions up to version 1.e Expansion 3, the mapping between a string
+ * and the bytes corresponding to the password was poorly specified, meaning
+ * that the safest manner in which to specify a password was via a byte array.
+ * With 1.7 expansion 3, a still slightly problematic mapping was given for the
+ * Standard encryption algorithms through to version 4, and a very well
+ * specified mapping for the new version 5 encryption.</p>
+ *
+ * <p>So, for passwords specified in versions up to and including 4, a byte[]
+ * representation is the most accurate, but not necessarily the most convenient
+ * manner to provide passwords. For version 5, allowing passwords to be
+ * specified as Strings will be the preferred mechanism. Rather than specify two
+ * interfaces whenever a password can be provided - one for byte[] and one for
+ * String - we express the password as a class. This class can also offer a best
+ * guess at a String representation for a password for encryption versions up to
+ * and including 4.</p>
+ *
+ * @author Luke Kirby
+ */
+public class PDFPassword {
+
+    /** The empty password */
+    public static final PDFPassword EMPTY_PASSWORD =
+            new PDFPassword(new byte[0]);
+
+    /**
+     * Ensure a non-null PDFPassword by substituting the empty password
+     * for a null password
+     * @param password the password, may be null
+     * @return a non-null password
+     */
+    public static PDFPassword nonNullPassword(PDFPassword password) {
+        return password != null ? password : EMPTY_PASSWORD;
+    }
+
+    /** the password in bytes, if specified as such */
+    private byte[] passwordBytes = null;
+    /** the passwird as a string, if specified as such */
+    private String passwordString = null;
+
+    /**
+     * Construct a byte-based password
+     * @param passwordBytes the password bytes
+     */
+    public PDFPassword(byte[] passwordBytes) {
+        this.passwordBytes =
+                passwordBytes != null ? passwordBytes : new byte[0];
+    }
+
+    /**
+     * Construct a string-based password
+     * @param passwordString the password
+     */
+    public PDFPassword(String passwordString) {
+        this.passwordString = passwordString != null ? passwordString : "";
+    }
+
+    /**
+     * Get the password bytes.
+     *
+     * @param unicodeConversion whether the specific conversion from a unicode
+     * String, as present for version 5 encryption, should be used
+     * @return a list of possible password bytes
+     */
+    List<byte[]> getPasswordBytes(boolean unicodeConversion) {
+        // TODO - handle unicodeConversion when we support version 5
+        if (this.passwordBytes != null || this.passwordString == null) {
+            return Collections.singletonList(this.passwordBytes);
+        } else {
+            if (isAlphaNum7BitString(this.passwordString)) {
+                // there's no reasonthat this string would get encoded
+                // in any other way
+                return Collections.singletonList(
+                        PDFStringUtil.asBytes(passwordString));
+            } else {
+                return generatePossiblePasswordBytes(passwordString);
+            }
+        }
+    }
+
+    /**
+     * An array of password byte generators that attempts to enumerate the
+     * possible strategies that an encrypting application might take to convert
+     * a string to an array of bytes
+     */
+    private final static PasswordByteGenerator[] PASSWORD_BYTE_GENERATORS =
+            new PasswordByteGenerator[]{
+
+                    // The best option, and that recommended by the spec, is
+                    // straight PDFDocEncoding of the string but its not
+                    // mentioned what to do with undefined characters
+                    // (presumably, an encryption generating app should not
+                    // allow them, but there are no guarantees!). Plus, that
+                    // hasn't always been the case. There's also a possiblity
+                    // that we'll be presented with the byte encoding from
+                    // whatever code page is default on the system that
+                    // generated the password. I don't think we're going to try
+                    // all different code pages, though. Here are
+                    // a few ideas, anyway!
+
+                    // skip undefined chars
+                    new PDFDocEncodingByteGenerator(null),
+                    // replace undefined chars with 0
+                    new PDFDocEncodingByteGenerator(Byte.valueOf((byte) 0)),
+                    // replace undefined chars with ?
+                    new PDFDocEncodingByteGenerator(Byte.valueOf((byte) '?')),
+                    // just strip the higher 8 bits!
+                    new PasswordByteGenerator() {
+                        public byte[] generateBytes(String password) {
+                            return PDFStringUtil.asBytes(password);
+                        }
+                    },
+                    // skip 2-byte chars
+                    new IdentityEncodingByteGenerator(null),
+                    // replace 2-byte chars with 0
+                    new IdentityEncodingByteGenerator(Byte.valueOf((byte) 0)),
+                    // replace 2-byte chars with ?
+                    new IdentityEncodingByteGenerator(Byte.valueOf((byte) '?'))
+            };
+
+    /**
+     * Generate some possible byte representations of a string password
+     *
+     * @param passwordString the string password
+     * @return a list of unique possible byte representations
+     */
+    private static List<byte[]> generatePossiblePasswordBytes(
+            String passwordString) {
+
+        final List<byte[]> possibilties = new ArrayList<byte[]>();
+        for (final PasswordByteGenerator generator : PASSWORD_BYTE_GENERATORS) {
+            byte[] generated = generator.generateBytes(passwordString);
+            // avoid duplicates
+            boolean alreadyGenerated = false;
+            for (int i = 0; !alreadyGenerated && i < possibilties.size(); ++i) {
+                if (Arrays.equals(possibilties.get(i), generated)) {
+                    alreadyGenerated = true;
+                }
+            }
+            if (!alreadyGenerated) {
+                possibilties.add(generated);
+            }
+        }
+        return possibilties;
+    }
+
+    private boolean isAlphaNum7BitString(String string) {
+        for (int i = 0; i < string.length(); ++i) {
+            final char c = string.charAt(i);
+            if (c >= 127 || !Character.isLetterOrDigit(c)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Converts a string password to a byte[] representation
+     */
+    private static interface PasswordByteGenerator {
+        byte[] generateBytes(String password);
+    }
+
+    /**
+     * Converts strings to byte by employing a {@link CharsetEncoder} and a
+     * configurable mechanism to replace or ignore characters that are
+     * unrepresentable according to the encoder.
+     */
+    private static abstract class CharsetEncoderGenerator
+            implements PasswordByteGenerator {
+
+        private Byte replacementByte;
+
+        /**
+         * Class constructor
+         *
+         * @param replacementByte the byte to replace to use to represent any
+         * unrepresentable character, or null if unrepresentable characters
+         * should just be ignored
+         */
+        protected CharsetEncoderGenerator(Byte replacementByte) {
+            this.replacementByte = replacementByte;
+        }
+
+
+        public byte[] generateBytes(String password) {
+            final CharsetEncoder encoder = createCharsetEncoder();
+            if (replacementByte != null) {
+                encoder.replaceWith(new byte[]{replacementByte});
+                encoder.onUnmappableCharacter(CodingErrorAction.REPLACE);
+            } else {
+                encoder.onUnmappableCharacter(CodingErrorAction.IGNORE);
+            }
+            try {
+                final ByteBuffer b = encoder.encode(CharBuffer.wrap(password));
+                final byte[] bytes = new byte[b.remaining()];
+                b.get(bytes);
+                return bytes;
+            } catch (CharacterCodingException e) {
+                // shouldn't happen: unmappable characters should be the only
+                // problem, and we're not handling them with a report
+                return null;
+            }
+        }
+
+        protected abstract CharsetEncoder createCharsetEncoder();
+
+    }
+
+    /**
+     * Generate byte[] representations based on the PDFDocEncoding
+     */
+    private static class PDFDocEncodingByteGenerator
+            extends CharsetEncoderGenerator {
+
+        private PDFDocEncodingByteGenerator(Byte replacementByte) {
+            super(replacementByte);
+        }
+
+        protected CharsetEncoder createCharsetEncoder() {
+            return new PDFDocCharsetEncoder();
+        }
+    }
+
+    /**
+     * Generate byte[] representations based on a Unicode code point identity
+     * encoding; characters over 255 in value are considered unrepresentable
+     */
+    private static class IdentityEncodingByteGenerator
+            extends CharsetEncoderGenerator {
+
+        private IdentityEncodingByteGenerator(Byte replacementByte) {
+            super(replacementByte);
+        }
+
+        protected CharsetEncoder createCharsetEncoder() {
+            return new Identity8BitCharsetEncoder();
+        }
+    }
+
+}
+

src/com/sun/pdfview/decrypt/StandardDecrypter.java

@@ -0,0 +1,1121 @@
+/*
+ * Copyright 2008 Pirion Systems Pty Ltd, 139 Warry St,
+ * Fortitude Valley, Queensland, Australia
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package com.sun.pdfview.decrypt;
+
+import com.sun.pdfview.PDFObject;
+import com.sun.pdfview.PDFParseException;
+import com.sun.pdfview.PDFStringUtil;
+
+import javax.crypto.*;
+import javax.crypto.spec.IvParameterSpec;
+import javax.crypto.spec.SecretKeySpec;
+import java.io.IOException;
+
+import net.sf.andpdf.pdfviewer.ByteBuffer;
+
+import java.security.*;
+import java.util.List;
+import java.util.Arrays;
+
+/**
+ * Standard simple decrypter for versions 1, 2 and 4 of the Standard
+ * password-based decryption mechanisms, as described in section 3.5 of
+ * the PDF Reference version 1.7.
+ *
+ * @author Luke Kirby
+ */
+public class StandardDecrypter implements PDFDecrypter {
+
+    /**
+     * Extra salt to add to AES-based decryption keys, as per PDF Reference 1.7
+     */
+    private static final byte[] AESV2_SALT = {'s', 'A', 'l', 'T'};
+
+    /**
+     * Describes an encryption algorithm to be used, declaring not only the
+     * cipher type, but also key generation techniques
+     */
+    public enum EncryptionAlgorithm {
+        RC4, AESV2;
+
+        boolean isRC4() {
+            return this == RC4;
+        }
+
+        boolean isAES() {
+            return this == AESV2;
+        }
+
+    }
+
+    /**
+     * Padding used to bring passwords up to 32 bytes, as specified by the
+     * first step of Algorithm 3.2 in the PDF Reference version 1.7.
+     */
+    private final static byte[] PW_PADDING = new byte[]{
+            0x28, (byte) 0xBF, 0x4E, 0x5E, 0x4E, 0x75, (byte) 0x8A, 0x41,
+            0x64, 0x00, 0x4E, 0x56, (byte) 0xFF, (byte) 0xFA, 0x01, 0x08,
+            0x2E, 0x2E, 0x00, (byte) 0xB6, (byte) 0xD0, 0x68, 0x3E, (byte) 0x80,
+            0x2F, 0x0C, (byte) 0xA9, (byte) 0xFE, 0x64, 0x53, 0x69, 0x7A
+    };
+
+    /**
+     * The specification of the RC4 cipher for JCE interactions
+     */
+    private static final String CIPHER_RC4 = "RC4";
+    /**
+     * The key type for RC4 keys
+     */
+    private static final String KEY_RC4 = "RC4";
+
+    /**
+     * The specification of the AES cipher for JCE interactions. As per the
+     * spec, cipher-block chanining (CBC) mode and PKCS5 padding are used
+     */
+    private static final String CIPHER_AES = "AES/CBC/PKCS5Padding";
+    /**
+     * The key type for AES keys
+     */
+    private static final String KEY_AES = "AES";
+
+    /**
+     * Whether the owner password was specified
+     */
+    private boolean ownerAuthorised = false;
+
+    /**
+     * The general encryption key; may be mutated to form individual
+     * stream/string encryption keys
+     */
+    private byte[] generalKeyBytes;
+
+    /**
+     * The encryption algorithm being employed
+     */
+    private EncryptionAlgorithm encryptionAlgorithm;
+
+    /**
+     * Class constructor
+     *
+     * @param encryptionAlgorithm the algorithm used for encryption
+     * @param documentId the contents of the ID entry of the document's trailer
+     * dictionary; can be null, but according to the spec, shouldn't be. Is
+     * expected to be an array of two byte sequences.
+     * @param keyBitLength the length of the key in bits; should be a multiple
+     * of 8 between 40 and 128
+     * @param revision the revision of the Standard encryption security handler
+     * being employed. Should be 2, 3 or 4.
+     * @param oValue the value of the O entry from the Encrypt dictionary
+     * @param uValue the value of the U entry from the Encrypt dictionary
+     * @param pValue the value of the P entry from the Encrypt dictionary
+     * @param encryptMetadata whether metadata is being encrypted, as identified
+     * by the Encrypt dict (with default true if not explicitly identified)
+     * @param password the password; not null
+     * @throws IOException if there's a problem reading the file
+     * @throws EncryptionUnsupportedByPlatformException if the encryption is not
+     * supported by the environment in which the code is executing
+     * @throws EncryptionUnsupportedByProductException if PDFRenderer does not
+     * currently support the specified encryption
+     */
+    public StandardDecrypter(
+            EncryptionAlgorithm encryptionAlgorithm,
+            PDFObject documentId, int keyBitLength,
+            int revision, byte[] oValue, byte[] uValue, int pValue,
+            boolean encryptMetadata, PDFPassword password)
+            throws
+            IOException,
+            EncryptionUnsupportedByProductException,
+            EncryptionUnsupportedByPlatformException {
+
+        this.encryptionAlgorithm = encryptionAlgorithm;
+
+        // The spec (sensibly) demands that the documentId be present,
+        // but we'll play it safe
+        final byte[] firstDocIdValue;
+        if (documentId == null) {
+            firstDocIdValue = null;
+        } else {
+            firstDocIdValue = documentId.getAt(0).getStream();
+        }
+
+        testJceAvailability(keyBitLength);
+
+        try {
+            final List<byte[]> passwordBytePossibilities =
+                    password.getPasswordBytes(false);
+            for (int i = 0;
+                    generalKeyBytes == null && i < passwordBytePossibilities.size();
+                    ++i) {
+                final byte[] passwordBytes = passwordBytePossibilities.get(i);
+                generalKeyBytes = checkOwnerPassword(
+                        passwordBytes, firstDocIdValue, keyBitLength,
+                        revision, oValue, uValue, pValue, encryptMetadata);
+                if (generalKeyBytes != null) {
+                    // looks like the password was the owner password!
+                    ownerAuthorised = true;
+                } else {
+                    // try it as the user password
+                    generalKeyBytes = checkUserPassword(
+                            passwordBytes, firstDocIdValue, keyBitLength,
+                            revision, oValue, uValue, pValue, encryptMetadata);
+
+                }
+            }
+        } catch (GeneralSecurityException e) {
+            // Unexpected, as our test of JCE availability should have caught
+            // problems with cipher availability.
+            // It may well be a problem with document content?
+            throw new PDFParseException("Unable to check passwords: " +
+                    e.getMessage(), e);
+        }
+
+        if (generalKeyBytes == null) {
+            throw new PDFAuthenticationFailureException(
+                    "Password failed authentication for both " +
+                            "owner and user password");
+        }
+
+    }
+
+    public ByteBuffer decryptBuffer(
+            String cryptFilterName, PDFObject streamObj, ByteBuffer streamBuf)
+            throws PDFParseException {
+
+        if (cryptFilterName != null) {
+            throw new PDFParseException(
+                    "This encryption version does not support Crypt filters");
+        }
+
+        if (streamObj != null) {
+            checkNums(streamObj.getObjNum(), streamObj.getObjGen());
+        }
+
+        final byte[] decryptionKeyBytes;
+        if (streamObj == null) {
+            // lack of a stream object indicates the unsalted key should be
+            // used
+            decryptionKeyBytes = getUnsaltedDecryptionKey();
+        } else {
+            decryptionKeyBytes = getObjectSaltedDecryptionKey(
+                    streamObj.getObjNum(), streamObj.getObjGen());
+        }
+        return decryptBuffer(streamBuf, decryptionKeyBytes);
+    }
+
+    public String decryptString(int objNum, int objGen, String inputBasicString)
+            throws PDFParseException {
+        final byte[] crypted = PDFStringUtil.asBytes(inputBasicString);
+        final byte[] decryptionKey = getObjectSaltedDecryptionKey(objNum, objGen);
+        final ByteBuffer decrypted = decryptBuffer(ByteBuffer.wrap(crypted), decryptionKey);
+        return PDFStringUtil.asBasicString(decrypted.array(), decrypted.arrayOffset(), decrypted.limit());
+    }
+
+    public boolean isOwnerAuthorised() {
+        return ownerAuthorised;
+    }
+
+    public boolean isEncryptionPresent() {
+        return true;
+    }
+
+    /**
+     * Test that the platform (i.e., the JCE) can offer us all of the ciphers at
+     * the key length we need for content decryption. This shouldn't be a
+     * problem on the Java 5 platform unless a particularly restrictive policy
+     * file is in place. Calling this on construction should avoid problems like
+     * these being exposed as PDFParseExceptions as they're used during
+     * decryption and key establishment.
+     *
+     * @param keyBitLength the length of the content key, in bits
+     * @throws EncryptionUnsupportedByPlatformException if the platform does not
+     * support the required ciphers and key lengths
+     * @throws PDFParseException if there's an internal error while testing
+     * cipher availability
+     */
+    private void testJceAvailability(int keyBitLength)
+            throws
+            EncryptionUnsupportedByPlatformException, PDFParseException {
+
+        // we need to supply a little buffer for AES, which will look
+        // for an initialisation vector of 16 bytes
+        final byte[] junkBuffer = new byte[16];
+        Arrays.fill(junkBuffer, (byte) 0xAE);
+        // test using the longer key length for salted content so that
+        // we can check for maximum key length problems
+        final byte[] junkKey =
+                new byte[getSaltedContentKeyByteLength(keyBitLength / 8)];
+        Arrays.fill(junkKey, (byte) 0xAE);
+
+        try {
+            createAndInitialiseContentCipher(
+                    ByteBuffer.wrap(junkBuffer),
+                    junkKey);
+        } catch (PDFParseException e) {
+            throw new PDFParseException("Internal error; " +
+                    "failed to produce test cipher: " + e.getMessage());
+        } catch (NoSuchAlgorithmException e) {
+            throw new EncryptionUnsupportedByPlatformException(
+                    "JCE does not offer required cipher", e);
+        } catch (NoSuchPaddingException e) {
+            throw new EncryptionUnsupportedByPlatformException(
+                    "JCE does not offer required padding", e);
+        } catch (InvalidKeyException e) {
+            throw new EncryptionUnsupportedByPlatformException(
+                    "JCE does accept key size of " +
+                            (getSaltedContentKeyByteLength() * 8) +
+                            " bits- could it be a policy restriction?", e);
+        } catch (InvalidAlgorithmParameterException e) {
+            throw new EncryptionUnsupportedByPlatformException(
+                    "JCE did not accept cipher parameter", e);
+        }
+
+        try {
+            createMD5Digest();
+        } catch (NoSuchAlgorithmException e) {
+            throw new EncryptionUnsupportedByPlatformException(
+                    "No MD5 digest available from JCE", e);
+        }
+
+        if (encryptionAlgorithm != EncryptionAlgorithm.RC4) {
+            // we still need RC4 for U and O value checks. Check again!
+            final Cipher rc4;
+            try {
+                rc4 = createRC4Cipher();
+            } catch (GeneralSecurityException e) {
+                throw new EncryptionUnsupportedByPlatformException(
+                        "JCE did not offer RC4 cipher", e);
+            }
+            // 40 byte key is used for base U and O ciphers
+            final byte[] rc4JunkKey = new byte[5];
+            Arrays.fill(junkKey, (byte) 0xAE);
+            try {
+                initDecryption(rc4, createRC4Key(rc4JunkKey));
+            } catch (InvalidKeyException ex) {
+                throw new EncryptionUnsupportedByPlatformException(
+                        "JCE did not accept 40-bit RC4 key; " +
+                                "policy problem?",
+                        ex);
+            }
+        }
+    }
+
+    /**
+     * Decrypt a buffer
+     *
+     * @param encrypted the encrypted content
+     * @param decryptionKeyBytes the key to use for decryption
+     * @return a freshly allocated buffer containing the decrypted content
+     * @throws PDFParseException if there's a problem decrypting the content
+     */
+    private ByteBuffer decryptBuffer(
+            ByteBuffer encrypted, byte[] decryptionKeyBytes)
+            throws PDFParseException {
+
+        final Cipher cipher;
+        try {
+            cipher = createAndInitialiseContentCipher(
+                    encrypted, decryptionKeyBytes);
+        } catch (GeneralSecurityException e) {
+            // we should have caught this earlier in testCipherAvailability
+            throw new PDFParseException(
+                    "Unable to create cipher due to platform limitation: " +
+                            e.getMessage(), e);
+        }
+
+        try {
+            // the decrypted content will never be more than the encrypted
+            // content. Thanks to padding, this buffer will be at most 16
+            // bytes bigger than the encrypted content
+            final java.nio.ByteBuffer decryptedBuf =
+            	java.nio.ByteBuffer.allocate(encrypted.remaining());
+            cipher.doFinal(encrypted.toNIO(), decryptedBuf);
+            decryptedBuf.flip();
+            return ByteBuffer.fromNIO(decryptedBuf);
+//            return decryptedBuf;
+        } catch (GeneralSecurityException e) {
+            throw new PDFParseException(
+                    "Could not decrypt: " + e.getMessage(), e);
+        }
+    }
+
+    /**
+     * Setup the cipher for decryption
+     *
+     * @param encrypted the encrypted content; required by AES encryption so
+     * that the initialisation vector can be established
+     * @param decryptionKeyBytes the bytes for the decryption key
+     * @return a content decryption cypher, ready to accept input
+     * @throws PDFParseException if the encrypted buffer is malformed or on an
+     * internal error
+     * @throws NoSuchAlgorithmException if the cipher algorithm is not supported
+     * by the platform
+     * @throws NoSuchPaddingException if the cipher padding is not supported by
+     * the platform
+     * @throws InvalidKeyException if the key is invalid according to the
+     * cipher, or too long
+     * @throws InvalidAlgorithmParameterException if the cipher parameters are
+     * bad
+     */
+    private Cipher createAndInitialiseContentCipher(
+            ByteBuffer encrypted,
+            byte[] decryptionKeyBytes)
+            throws
+            PDFParseException,
+            NoSuchAlgorithmException,
+            NoSuchPaddingException,
+            InvalidKeyException,
+            InvalidAlgorithmParameterException {
+
+        final Cipher cipher;
+        if (encryptionAlgorithm.isRC4()) {
+            cipher = Cipher.getInstance(CIPHER_RC4);
+            cipher.init(Cipher.DECRYPT_MODE, createRC4Key(decryptionKeyBytes));
+        } else if (encryptionAlgorithm.isAES()) {
+            cipher = createAESCipher();
+            final byte[] initialisationVector = new byte[16];
+            if (encrypted.remaining() >= initialisationVector.length) {
+                encrypted.get(initialisationVector);
+            } else {
+                throw new PDFParseException(
+                        "AES encrypted stream too short - " +
+                                "no room for initialisation vector");
+            }
+
+            final SecretKeySpec aesKey =
+                    new SecretKeySpec(decryptionKeyBytes, KEY_AES);
+            final IvParameterSpec aesIv =
+                    new IvParameterSpec(initialisationVector);
+            cipher.init(Cipher.DECRYPT_MODE, aesKey, aesIv);
+        } else {
+            throw new PDFParseException(
+                    "Internal error - unhandled cipher type: " +
+                            encryptionAlgorithm);
+        }
+        return cipher;
+    }
+
+    /**
+     * Get the unsalted content decryption key, used for streams with specific
+     * crypt filters, which aren't specific to particular objects
+     *
+     * @return the general key
+     */
+    private byte[] getUnsaltedDecryptionKey() {
+        return generalKeyBytes;
+    }
+
+    /**
+     * Get a decryption key salted with an object number and object generation,
+     * for use when decrypting a string or stream within an object numbered so
+     *
+     * @param objNum the object number
+     * @param objGen the object generation
+     * @return the key to be used for decrypting data associated with the object
+     *         numbered so
+     * @throws PDFParseException if the MD5 digest is not available
+     */
+    private byte[] getObjectSaltedDecryptionKey(int objNum, int objGen)
+            throws PDFParseException {
+
+        byte[] decryptionKeyBytes;
+        final MessageDigest md5;
+        try {
+            md5 = createMD5Digest();
+        } catch (NoSuchAlgorithmException e) {
+            // unexpected, as we will already have tested availability
+            throw new PDFParseException("Unable to get MD5 digester", e);
+        }
+        md5.update(this.generalKeyBytes);
+        md5.update((byte) objNum);
+        md5.update((byte) (objNum >> 8));
+        md5.update((byte) (objNum >> 16));
+        md5.update((byte) objGen);
+        md5.update((byte) (objGen >> 8));
+        if (encryptionAlgorithm == EncryptionAlgorithm.AESV2) {
+            md5.update(AESV2_SALT);
+        }
+        final byte[] hash = md5.digest();
+        final int keyLen = getSaltedContentKeyByteLength();
+        decryptionKeyBytes = new byte[keyLen];
+        System.arraycopy(hash, 0, decryptionKeyBytes, 0, keyLen);
+        return decryptionKeyBytes;
+    }
+
+    /**
+     * Get the length of a salted key
+     *
+     * @return length in bytes
+     */
+    private int getSaltedContentKeyByteLength() {
+        return getSaltedContentKeyByteLength(generalKeyBytes.length);
+    }
+
+    /**
+     * Get the length of salted keys, in bytes. Unsalted keys will be the same
+     * length as {@link #generalKeyBytes}
+     *
+     * @param generalKeyByteLength the length of the general key, in bytes
+     * @return byte length of salted keys
+     */
+    private int getSaltedContentKeyByteLength(int generalKeyByteLength) {
+        return Math.min(generalKeyByteLength + 5, 16);
+    }
+
+    /**
+     * Check that object number and object generations are well-formed. It is
+     * possible for some {@link PDFObject}s to have uninitialised object numbers
+     * and generations, but such objects should not required decryption
+     *
+     * @param objNum the object number
+     * @param objGen the object generation
+     * @throws PDFParseException if the object numbering indicates that they
+     * aren't true object numbers
+     */
+    private void checkNums(int objNum, int objGen)
+            throws PDFParseException {
+        if (objNum < 0) {
+            throw new PDFParseException(
+                    "Internal error: Object has bogus object number");
+        } else if (objGen < 0) {
+            throw new PDFParseException(
+                    "Internal error: Object has bogus generation number");
+        }
+    }
+
+    /**
+     * Calculate what the U value should consist of given a particular key and
+     * document configuration. Correponds to Algorithms 3.4 and 3.5 of the
+     * PDF Reference version 1.7
+     *
+     * @param generalKey the general encryption key
+     * @param firstDocIdValue the value of the first element in the document's
+     * ID entry in the trailer dictionary
+     * @param revision the revision of the security handler
+     * @return the U value for the given configuration
+     * @throws GeneralSecurityException if there's an error getting required
+     * ciphers, etc. (unexpected, since a check for algorithm availability is
+     * performed on construction)
+     * @throws EncryptionUnsupportedByProductException if the revision is not
+     * supported
+     */
+    private byte[] calculateUValue(
+            byte[] generalKey, byte[] firstDocIdValue, int revision)
+            throws
+            GeneralSecurityException,
+            EncryptionUnsupportedByProductException {
+
+        if (revision == 2) {
+
+            // Algorithm 3.4: Computing the encryption dictionary’s U (user
+            // password) value (Revision 2)
+
+            // Step 1 is provided to us as the parameter generalKey:
+            //  Create an encryption key based on the user password string, as
+            //  described in Algorithm 3.2
+
+            // Step 2: Encrypt the 32-byte padding string shown in step 1 of
+            // Algorithm 3.2, using an RC4 encryption function with the
+            // encryption key from the preceding step.
+
+            Cipher rc4 = createRC4Cipher();
+            SecretKey key = createRC4Key(generalKey);
+            initEncryption(rc4, key);
+            return crypt(rc4, PW_PADDING);
+
+        } else if (revision >= 3) {
+
+            // Algorithm 3.5: Computing the encryption dictionary’s U (user
+            // password) value (Revision 3 or greater)
+
+            // Step 1 is provided to us as the parameter generalKey:
+            //  Create an encryption key based on the user password string, as
+            //  described in Algorithm 3.2
+
+            // Step 2: Initialize the MD5 hash function and pass the 32-byte
+            // padding string shown in step 1 of Algorithm 3.2 as input to this
+            // function
+            MessageDigest md5 = createMD5Digest();
+            md5.update(PW_PADDING);
+
+            // Step 3: Pass the first element of the file’s file identifier
+            // array (the value of the ID entry in the document’s trailer
+            // dictionary; see Table 3.13 on page 97) to the hash function and
+            // finish the hash. (See implementation note 26 in Appendix H.)
+            if (firstDocIdValue != null) {
+                md5.update(firstDocIdValue);
+            }
+            final byte[] hash = md5.digest();
+
+            // Step 4: Encrypt the 16-byte result of the hash, using an RC4
+            // encryption function with the encryption key from step 1.
+            Cipher rc4 = createRC4Cipher();
+            SecretKey key = createRC4Key(generalKey);
+            initEncryption(rc4, key);
+            final byte[] v = crypt(rc4, hash);
+
+            // Step 5: Do the following 19 times: Take the output from the
+            // previous invocation of the RC4 function and pass it as input to
+            // a new invocation of the function; use an encryption key generated
+            // by taking each byte of the original encryption key (obtained in
+            // step 1) and performing an XOR (exclusive or) operation between
+            // that byte and the single-byte value of the iteration counter
+            // (from 1 to 19).
+            rc4shuffle(v, generalKey, rc4);
+
+            // Step 6: Append 16 bytes of arbitrary padding to the output from
+            // the final invocation of the RC4 function and store the 32-byte
+            // result as the value of the U entry in the encryption dictionary.
+            assert v.length == 16;
+            final byte[] entryValue = new byte[32];
+            System.arraycopy(v, 0, entryValue, 0, v.length);
+            System.arraycopy(v, 0, entryValue, 16, v.length);
+            return entryValue;
+
+        } else {
+            throw new EncryptionUnsupportedByProductException(
+                    "Unsupported standard security handler revision " +
+                            revision);
+        }
+    }
+
+    /**
+     * Calculate what the O value of the Encrypt dict should look like given a
+     * particular configuration. Not used, but useful for reference; this
+     * process is reversed to determine whether a given password is the
+     * owner password. Corresponds to Algorithm 3.3 of the PDF Reference
+     * version 1.7.
+     *
+     * @see #checkOwnerPassword
+     * @param ownerPassword the owner password
+     * @param userPassword the user password
+     * @param keyBitLength the key length in bits (40-128)
+     * @param revision the security handler revision
+     * @return the O value entry
+     * @throws GeneralSecurityException if ciphers are unavailable or
+     *  inappropriately used
+     */
+    private byte[] calculuateOValue(
+            byte[] ownerPassword, byte[] userPassword,
+            int keyBitLength, int revision)
+            throws GeneralSecurityException {
+
+        // Steps 1-4
+        final byte[] rc4KeyBytes =
+                getInitialOwnerPasswordKeyBytes(
+                        ownerPassword, keyBitLength, revision);
+        final Cipher rc4 = createRC4Cipher();
+        initEncryption(rc4, createRC4Key(rc4KeyBytes));
+
+        // Step 5: Pad or truncate the user password string as described in step
+        // 1 of Algorithm 3.2.
+        // Step 6: Encrypt the result of step 5, using an RC4 encryption
+        // function with the encryption key obtained in step 4.
+        byte[] pwvalue = crypt(rc4, padPassword(userPassword));
+
+        // Step 7: (Revision 3 or greater) Do the following 19 times: Take the
+        // output from the previous invocation of the RC4 function and pass it
+        // as input to a new invocation of the function; use an encryption key
+        // generated by taking each byte of the encryption key obtained in step
+        // 4 and performing an XOR (exclusive or) operation between
+        if (revision >= 3) {
+            rc4shuffle(pwvalue, rc4KeyBytes, rc4);
+        }
+        assert pwvalue.length == 32;
+        return pwvalue;
+
+    }
+
+    /**
+     * Check to see whether a given password is the owner password. Corresponds
+     * to algorithm 3.6 of PDF Reference version 1.7.
+     *
+     * @param ownerPassword the suggested owner password (may be null or
+     * empty)
+     * @param firstDocIdValue the byte stream from the first element of the
+     *  value of the ID entry in the trailer dictionary
+     * @param keyBitLength the key length in bits
+     * @param revision the security handler revision
+     * @param oValue the O value from the Encrypt dictionary
+     * @param uValue the U value from the Encrypt dictionary
+     * @param pValue the P value from the Encrypt dictionary
+     * @param encryptMetadata the EncryptMetadata entry from the Encrypt dictionary
+     *  (or false if not present or revision &lt;= 3)
+     * @return the general/user key bytes if the owner password is currect,
+     *  <code>null</code> otherwise
+     * @throws GeneralSecurityException if there's a problem with
+     * cipher or digest usage; unexpected
+     * @throws EncryptionUnsupportedByProductException if PDFRenderer doesn't
+     * support the security handler revision
+     * @throws PDFParseException if the document is malformed
+     */
+    private byte[] checkOwnerPassword(
+            byte[] ownerPassword, byte[] firstDocIdValue, int keyBitLength,
+            int revision, byte[] oValue, byte[] uValue, int pValue,
+            boolean encryptMetadata)
+            throws
+            GeneralSecurityException,
+            EncryptionUnsupportedByProductException,
+            PDFParseException {
+
+        // Step 1: Compute an encryption key from the supplied password string,
+        // as described in steps 1 to 4 of Algorithm 3.3.
+        final byte[] rc4KeyBytes =
+                getInitialOwnerPasswordKeyBytes(ownerPassword,
+                        keyBitLength, revision);
+        final Cipher rc4 = createRC4Cipher();
+        initDecryption(rc4, createRC4Key(rc4KeyBytes));
+
+        // Step 2:
+        final byte[] possibleUserPassword;
+        if (revision == 2) {
+            // (Revision 2 only) Decrypt the value of the encryption
+            // dictionary’s O entry, using an RC4 encryption function with the
+            // encryption key computed in step 1.
+
+            possibleUserPassword = crypt(rc4, oValue);
+        } else if (revision >= 3) {
+            // (Revision 3 or greater) Do the following 20 times: Decrypt the
+            // value of the encryption dictionary’s O entry (first iteration) or
+            // the output from the previous iteration (all subsequent
+            // iterations), using an RC4 encryption function with a different
+            // encryption key at each iteration. The key is generated by taking
+            // the original key (obtained in step 1) and performing an XOR
+            // (exclusive or) operation between each byte of the key and the
+            // single-byte value of the iteration counter (from 19 to 0).
+
+            // unshuffle the O entry; the unshuffle operation also
+            // contains the final decryption with the original key
+            possibleUserPassword = new byte[32];
+            System.arraycopy(oValue, 0, possibleUserPassword, 0,
+                    possibleUserPassword.length);
+            rc4unshuffle(rc4, possibleUserPassword, rc4KeyBytes);
+        } else {
+            throw new EncryptionUnsupportedByProductException(
+                    "Unsupported revision: " + revision);
+        }
+
+        // Step 3: The result of step 2 purports to be the user password.
+        // Authenticate this user password using Algorithm 3.6. If it is
+        // correct, the password supplied is the correct owner password.
+        return checkUserPassword(
+                possibleUserPassword, firstDocIdValue, keyBitLength,
+                revision, oValue, uValue, pValue, encryptMetadata);
+
+    }
+
+    /**
+     * Establish the key to be used for the generation and validation
+     * of the user password via the O entry. Corresponds to steps 1-4 in
+     * Algorithm 3.3 of the PDF Reference version 1.7.
+     * @param ownerPassword the owner password
+     * @param keyBitLength the length of the key in bits
+     * @param revision the security handler revision
+     * @return the key bytes to use for generation/validation of the O entry
+     * @throws GeneralSecurityException if there's a problem wranling ciphers
+     */
+    private byte[] getInitialOwnerPasswordKeyBytes(
+            byte[] ownerPassword, int keyBitLength, int revision)
+            throws GeneralSecurityException {
+
+        final MessageDigest md5 = createMD5Digest();
+
+        // Step 1: Pad or truncate the owner password string as described in
+        // step 1 of Algorithm 3.2. If there is no owner password, use the user
+        // password instead. (See implementation note 27 in Appendix H.)
+        // Step 2: Initialize the MD5 hash function and pass the result of step 1 as
+        // input to this function.
+        md5.update(padPassword(ownerPassword));
+
+        // Step 3.(Revision 3 or greater) Do the following 50 times: Take the
+        // output from the previous MD5 hash and pass it as input into a new MD5
+        // hash
+        final byte[] hash = md5.digest();
+        if (revision >= 3) {
+            for (int i = 0; i < 50; ++i) {
+                md5.update(hash);
+                digestTo(md5, hash);
+            }
+        }
+
+        // Step 4: Create an RC4 encryption key using the first n bytes of
+        // the output from the final MD5 hash, where n is always 5 for revision
+        // 2 but, for revision 3 or greater, depends on the value of the
+        // encryption dictionary’s Length entry
+        final byte[] rc4KeyBytes = new byte[keyBitLength / 8];
+        System.arraycopy(hash, 0, rc4KeyBytes, 0, rc4KeyBytes.length);
+        return rc4KeyBytes;
+    }
+
+    /**
+     * Check to see whether a provided user password is correct with respect
+     * to an Encrypt dict configuration. Corresponds to algorithm 3.6 of
+     * the PDF Reference version 1.7
+     * @param userPassword the user password to test; may be null or empty
+     * @param firstDocIdValue the byte stream from the first element of the
+     *  value of the ID entry in the trailer dictionary
+     * @param keyBitLength the length of the key in bits
+     * @param revision the security handler revision
+     * @param oValue the O value from the Encrypt dictionary
+     * @param uValue the U value from the Encrypt dictionary
+     * @param pValue the P value from the Encrypt dictionary
+     * @param encryptMetadata the EncryptMetadata entry from the Encrypt dictionary
+     *  (or false if not present or revision &lt;= 3)
+     * @return the general/user encryption key if the user password is correct,
+     *  or null if incorrect
+     * @throws GeneralSecurityException if there's a problem with
+     * cipher or digest usage; unexpected
+     * @throws EncryptionUnsupportedByProductException if PDFRenderer doesn't
+     * support the security handler revision
+     * @throws PDFParseException if the document is improperly constructed
+     */
+    private byte[] checkUserPassword(
+            byte[] userPassword, byte[] firstDocIdValue, int keyBitLength,
+            int revision, byte[] oValue, byte[] uValue, int pValue,
+            boolean encryptMetadata)
+            throws
+            GeneralSecurityException,
+            EncryptionUnsupportedByProductException,
+            PDFParseException {
+
+        // Algorithm 3.6: Authenticating the user password
+
+        // Step 1: Perform all but the last step of Algorithm 3.4 (Revision 2)
+        // or Algorithm 3.5 (Revision 3 or greater) using the supplied password
+        // string
+        //
+        // I.e., figure out what the general key would be with the
+        // given password
+        // Algorithm 3.4/5,Step1:
+        // Determine general key based on user password, as per Algorithm 3.2
+        final byte[] generalKey = calculateGeneralEncryptionKey(
+                userPassword, firstDocIdValue, keyBitLength,
+                revision, oValue, pValue, encryptMetadata);
+        // Algorithm 3.4/5,RemainingSteps:
+        final byte[] calculatedUValue =
+                calculateUValue(generalKey, firstDocIdValue, revision);
+
+        // Step 2: If the result of step 1 is equal to the value of the
+        // encryption dictionary’s U entry (comparing on the first 16 bytes in
+        // the case of Revision 3 or greater), the password supplied is the
+        // correct user password. The key obtained in step 1 (that is, in the
+        // first step of Algorithm 3.4 or 3.5) can be used to decrypt the
+        // document using Algorithm 3.1 on page 119.
+        assert calculatedUValue.length == 32;
+        if (uValue.length != calculatedUValue.length) {
+            throw new PDFParseException("Improper U entry length; " +
+                    "expected 32, is " + uValue.length);
+        }
+        // Only the first 16 bytes are significant if using revision > 2
+        final int numSignificantBytes = revision == 2 ? 32 : 16;
+        for (int i = 0; i < numSignificantBytes; ++i) {
+            if (uValue[i] != calculatedUValue[i]) {
+                return null;
+            }
+        }
+        return generalKey;
+    }
+
+
+    /**
+     * Determine what the general encryption key is, given a configuration. This
+     * corresponds to Algorithm 3.2 of PDF Reference version 1.7.
+     *
+     * @param userPassword the desired user password; may be null or empty
+     * @param firstDocIdValue the byte stream from the first element of the
+     * value of the ID entry in the trailer dictionary
+     * @param keyBitLength the length of the key in bits
+     * @param revision the security handler revision
+     * @param oValue the O value from the Encrypt dictionary
+     * @param pValue the P value from the Encrypt dictionary
+     * @param encryptMetadata the EncryptMetadata entry from the Encrypt
+     * dictionary (or false if not present or revision &lt;= 3)
+     * @return the general encryption key
+     * @throws GeneralSecurityException if an error occurs when obtaining
+     *  and operating ciphers/digests
+     */
+    private byte[] calculateGeneralEncryptionKey(
+            byte[] userPassword, byte[] firstDocIdValue, int keyBitLength,
+            int revision, byte[] oValue, int pValue, boolean encryptMetadata)
+            throws GeneralSecurityException {
+
+        // Algorithm 3.2: Computing an encryption key
+
+        // Step 1: Pad or truncate the password string to exactly 32 bytes...
+        final byte[] paddedPassword = padPassword(userPassword);
+
+        // Step 2: Initialize the MD5 hash function and pass the result of step
+        // 1 as input to this function.
+        MessageDigest md5 = createMD5Digest();
+        md5.reset();
+        md5.update(paddedPassword);
+
+        // Step 3: Pass the value of the encryption dictionary’s O entry to the
+        // MD5 hash function. (Algorithm 3.3 shows how the O value is computed.)
+        md5.update(oValue);
+
+        // Step 4: Treat the value of the P entry as an unsigned 4-byte integer
+        // and pass these bytes to the MD5 hash function, low-order byte first
+        md5.update((byte) (pValue & 0xFF));
+        md5.update((byte) ((pValue >> 8) & 0xFF));
+        md5.update((byte) ((pValue >> 16) & 0xFF));
+        md5.update((byte) (pValue >> 24));
+
+        // Step 5: Pass the first element of the file’s file identifier array
+        // (the value of the ID entry in the document’s trailer dictionary; see
+        // Table 3.13 on page 97) to the MD5 hash function. (See implementation
+        // note 26 in Appendix H.)
+        if (firstDocIdValue != null) {
+            md5.update(firstDocIdValue);
+        }
+
+        // Step 6: (Revision 4 or greater) If document metadata is not being
+        // encrypted, pass 4 bytes with the value 0xFFFFFFFF to the MD5 hash
+        // function
+        if (revision >= 4 && !encryptMetadata) {
+            for (int i = 0; i < 4; ++i) {
+                md5.update((byte) 0xFF);
+            }
+        }
+
+        // Step 7: finish the hash
+        byte[] hash = md5.digest();
+
+        final int keyLen = revision == 2 ? 5 : (keyBitLength / 8);
+        final byte[] key = new byte[keyLen];
+
+        // Step 8: (Revision 3 or greater) Do the following 50 times: Take the
+        // output from the previous MD5 hash and pass the first n bytes of the
+        // output as input into a new MD5 hash, where n is the number of bytes
+        // of the encryption key as defined by the value of the encryption
+        // dictionary’s Length entry
+        if (revision >= 3) {
+            for (int i = 0; i < 50; ++i) {
+                md5.update(hash, 0, key.length);
+                digestTo(md5, hash);
+            }
+        }
+
+        // Set the encryption key to the first n bytes of the output from the
+        // final MD5 hash, where n is always 5 for revision 2 but, for revision
+        // 3 or greater, depends on the value of the encryption dictionary’s
+        // Length entry.
+        System.arraycopy(hash, 0, key, 0, key.length);
+        return key;
+    }
+
+    /**
+     * Pad a password as per step 1 of Algorithm 3.2 of the PDF Reference
+     * version 1.7
+     * @param password the password, may be null or empty
+     * @return the padded password, always 32 bytes long
+     */
+    private byte[] padPassword(byte[] password) {
+
+        if (password == null) {
+            password = new byte[0];
+        }
+
+        // Step 1: Pad or truncate the password string to exactly 32 bytes. If
+        // the password string is more than 32 bytes long, use only its first 32
+        // bytes; if it is less than 32 bytes long, pad it by appending the
+        // required number of additional bytes from the beginning of the
+        // following padding string:
+        // < 28 BF 4E 5E 4E 75 8A 41 64 00 4E 56 FF FA 01 08
+        //   2E 2E 00 B6 D0 68 3E 80 2F 0C A9 FE 64 53 69 7A >
+        // That is, if the password string is n bytes long, append the first 32
+        // − n bytes of the padding string to the end of the password string. If
+        // the password string is empty (zero-length), meaning there is no user
+        // password, substitute the entire padding string in its place.
+
+        byte[] padded = new byte[32];
+        // limit password to 32 bytes
+        final int numContributingPasswordBytes =
+                password.length > padded.length ?
+                padded.length : password.length;
+        System.arraycopy(password, 0, padded, 0, numContributingPasswordBytes);
+        // Copy padding
+        if (password.length < padded.length) {
+            System.arraycopy(PW_PADDING, 0, padded, password.length,
+                    padded.length - password.length);
+        }
+        return padded;
+    }
+
+    /**
+     * Encrypt some bytes
+     *
+     * @param cipher the cipher
+     * @param input the plaintext
+     * @return the crypt text
+     * @throws BadPaddingException if there's bad padding
+     * @throws IllegalBlockSizeException if the block size is bad
+     */
+    private byte[] crypt(Cipher cipher, byte[] input)
+            throws IllegalBlockSizeException, BadPaddingException {
+        return cipher.doFinal(input);
+    }
+
+    /**
+     * Initialise a cipher for encryption
+     *
+     * @param cipher the cipher
+     * @param key the encryption key
+     * @throws InvalidKeyException if the key is invalid for the cipher
+     */
+    private void initEncryption(Cipher cipher, SecretKey key)
+            throws InvalidKeyException {
+        cipher.init(Cipher.ENCRYPT_MODE, key);
+    }
+
+    /**
+     * Shuffle some input using a series of RC4 encryptions with slight
+     * mutations of an given key per iteration. Shuffling happens in place.
+     * Refer to the documentation of the algorithm steps where this is called.
+     *
+     * @param shuffle the bytes to be shuffled
+     * @param key the original key
+     * @param rc4 the cipher to use
+     * @throws GeneralSecurityException if there's a problem with cipher
+     *  operation
+     */
+    private void rc4shuffle(byte[] shuffle, byte[] key, Cipher rc4)
+            throws GeneralSecurityException {
+
+        final byte[] shuffleKey = new byte[key.length];
+        for (int i = 1; i <= 19; ++i) {
+            for (int j = 0; j < shuffleKey.length; ++j) {
+                shuffleKey[j] = (byte) (key[j] ^ i);
+            }
+            initEncryption(rc4, createRC4Key(shuffleKey));
+            cryptInPlace(rc4, shuffle);
+        }
+    }
+
+    /**
+     * Reverse the {@link #rc4shuffle} operation, and the operation
+     * that invariable preceeds it, thereby obtaining an original message
+     * @param rc4 the RC4 cipher to use
+     * @param shuffle the bytes in which shuffling will take place; unshuffling
+     *  happens in place
+     * @param key the encryption key
+     * @throws GeneralSecurityException if there's a problem with cipher
+     *  operation
+     */
+    private void rc4unshuffle(Cipher rc4, byte[] shuffle, byte[] key)
+            throws GeneralSecurityException {
+
+        // there's an extra unshuffle at the end with the original key -
+        // this is why we end with i == 0, where the shuffle key will be the key
+        final byte[] shuffleKeyBytes = new byte[key.length];
+        for (int i = 19; i >= 0; --i) {
+            for (int j = 0; j < shuffleKeyBytes.length; ++j) {
+                shuffleKeyBytes[j] = (byte) (key[j] ^ i);
+            }
+            initDecryption(rc4, createRC4Key(shuffleKeyBytes));
+            cryptInPlace(rc4, shuffle);
+        }
+    }
+
+    /**
+     * Encrypt/decrypt something in place
+     * @param rc4 the cipher to use; must be a stream cipher producing
+     *  identical output length to input (e.g., RC4)
+     * @param buffer the buffer to read input from and write output to
+     * @throws IllegalBlockSizeException if an inappropriate cipher is used
+     * @throws ShortBufferException if an inappropriate cipher is used
+     * @throws BadPaddingException if an inappropriate cipher is used
+     */
+    private void cryptInPlace(Cipher rc4, byte[] buffer)
+            throws IllegalBlockSizeException, ShortBufferException, BadPaddingException {
+        rc4.doFinal(buffer, 0, buffer.length, buffer);
+    }
+
+    /**
+     * Setup a cipher for decryption
+     * @param cipher the cipher
+     * @param aKey the cipher key
+     * @throws InvalidKeyException if the key is of an unacceptable size or
+     *  doesn't belong to the cipher
+     */
+    private void initDecryption(Cipher cipher, Key aKey)
+            throws InvalidKeyException {
+        cipher.init(Cipher.DECRYPT_MODE, aKey);
+    }
+
+    /**
+     * Create a new RC4 cipher. Should always be available for supported
+     * platforms.
+     * @return the cipher
+     * @throws NoSuchAlgorithmException if the RC4 cipher is unavailable
+     * @throws NoSuchPaddingException should not happen, as no padding
+     *  is specified
+     */
+    private Cipher createRC4Cipher()
+            throws NoSuchAlgorithmException, NoSuchPaddingException {
+        return Cipher.getInstance(CIPHER_RC4);
+    }
+
+    /**
+     * Create a new AES cipher. Should always be available for supported
+     * platforms.
+     * @return the new cipher
+     * @throws NoSuchAlgorithmException if the AES cipher is unavailable
+     * @throws NoSuchPaddingException if the required padding is unavailable
+     */
+    private Cipher createAESCipher()
+            throws NoSuchAlgorithmException, NoSuchPaddingException {
+        return Cipher.getInstance(CIPHER_AES);
+    }
+
+    /**
+     * Create an MD5 digest. Should always be available for supported
+     * platforms.
+     * @return the MD5 digest
+     * @throws NoSuchAlgorithmException if the digest is not available
+     */
+    private MessageDigest createMD5Digest()
+            throws NoSuchAlgorithmException {
+        return MessageDigest.getInstance("MD5");
+    }
+
+    /**
+     * Create an RC4 key
+     *
+     * @param keyBytes the bytes for the key
+     * @return the key
+     */
+    private SecretKeySpec createRC4Key(byte[] keyBytes) {
+        return new SecretKeySpec(keyBytes, KEY_RC4);
+    }
+
+    /**
+     * Hash into an existing byte array
+     * @param md5 the MD5 digest
+     * @param hash the hash destination
+     * @throws GeneralSecurityException if there's a problem hashing; e.g.,
+     *  if the buffer is too small
+     */
+    private void digestTo(MessageDigest md5, byte[] hash)
+                throws GeneralSecurityException {
+        md5.digest(hash, 0, hash.length);
+    }
+
+
+}

src/com/sun/pdfview/decrypt/UnsupportedEncryptionException.java

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2008 Pirion Systems Pty Ltd, 139 Warry St,
+ * Fortitude Valley, Queensland, Australia
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package com.sun.pdfview.decrypt;
+
+/**
+ * Identifies that the specified encryption mechanism is not
+ * supported by this product or platform.
+ *
+ * @see EncryptionUnsupportedByPlatformException
+ * @see EncryptionUnsupportedByProductException
+ * @author Luke Kirby
+ */
+public abstract class UnsupportedEncryptionException extends Exception {
+
+    protected UnsupportedEncryptionException(String message) {
+        super(message);
+    }
+
+    protected UnsupportedEncryptionException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}

src/com/sun/pdfview/font/BuiltinFont.java

@@ -0,0 +1,220 @@
+/*
+ * $Id: BuiltinFont.java,v 1.4 2009/03/15 20:47:38 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview.font;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Map;
+import java.util.Properties;
+
+import android.graphics.Typeface;
+
+import com.sun.pdfview.PDFObject;
+
+/**
+ * This class represents the 14 built-in fonts.  It reads these fonts
+ * from files in the "res" directory, as specified in
+ * BaseNames.properties.
+ */
+public class BuiltinFont extends Type1Font {
+
+    /** the properties file */
+    private static Properties props;
+    /** the fonts themselves */
+    private static Map fonts;
+    /** the names of the 14 base fonts */
+    private static final String[] baseFonts = {
+        "Courier", "Courier-Bold", "Courier-BoldOblique", "Courier-Oblique",
+        "Helvetica", "Helvetica-Bold", "Helvetica-BoldOblique",
+        "Helvetica-Oblique", "Times-Roman", "Times-Bold", "Times-BoldItalic",
+        "Times-Italic", "Symbol", "ZapfDingbats"
+    };
+    /** fonts others (e.g. Acrobad PDFWriter 3.02 for Windows) assume
+     *  are there, even though they're not in the spec.  Grrr...
+     *
+     * the format is <Name_in_PDF> <Builtin_To_Use>
+     */
+    private static final String[] mappedFonts = {
+        // map arial to helvetica
+        "Arial", "Helvetica",
+        "Arial,Bold", "Helvetica-Bold",
+        "Arial,BoldItalic", "Helvetica-BoldOblique",
+        "Arial,Italic", "Helvetica-Oblique",
+        // map TimesNewRoman to Times
+        "TimesNewRoman", "Times-Roman",
+        "TimesNewRoman,Bold", "Times-Bold",
+        "TimesNewRoman,BoldItalic", "Times-BoldItalic",
+        "TimesNewRoman,Italic", "Times-Italic",};
+
+    /**
+     * Create a new Builtin object based on the name of a built-in font
+     *
+     * This must be the name of one of the 14 built-in fonts!
+     *
+     * @param baseFont the name of the font, from the PDF file
+     * @param fontObj the object containing font information
+     */
+    public BuiltinFont(String baseFont, PDFObject fontObj) throws IOException {
+        super(baseFont, fontObj, null);
+
+        parseFont(baseFont);
+    }
+
+    /**
+     * create a new BuiltingFont object based on a description of the
+     * font from the PDF file. Parse the description for key information
+     * and use that to generate an appropriate font.
+     */
+    public BuiltinFont(String baseFont, PDFObject fontObj,
+            PDFFontDescriptor descriptor)
+            throws IOException {
+        super(baseFont, fontObj, descriptor);
+
+        String fontName = descriptor.getFontName();
+
+        // check if it's one of the 14 base fonts
+        for (int i = 0; i < baseFonts.length; i++) {
+            if (fontName.equalsIgnoreCase(baseFonts[i])) {
+                parseFont(fontName);
+                return;
+            }
+        }
+
+        // check if it's a mapped font
+        for (int i = 0; i < mappedFonts.length; i += 2) {
+            if (fontName.equalsIgnoreCase(mappedFonts[i])) {
+                parseFont(mappedFonts[i + 1]);
+                return;
+            }
+        }
+
+        int flags = descriptor.getFlags();
+        int style = ((flags & PDFFontDescriptor.FORCEBOLD) != 0) ? Typeface.BOLD : Typeface.NORMAL;
+
+        if (fontName.indexOf("Bold") > 0) {
+            style |= Typeface.BOLD;
+        }
+        if ((descriptor.getItalicAngle() != 0) || 
+            ((flags & PDFFontDescriptor.NONSYMBOLIC) != 0)) {
+            style |= Typeface.ITALIC;
+        }
+
+        String name = null;
+
+        if ((flags & PDFFontDescriptor.FIXED_PITCH) != 0) { // fixed width
+            if (((style & Typeface.BOLD) > 0) && ((style & Typeface.ITALIC) > 0)) {
+                name = "Courier-BoldOblique";
+            } else if ((style & Typeface.BOLD) > 0) {
+                name = "Courier-Bold";
+            } else if ((style & Typeface.ITALIC) > 0) {
+                name = "Courier-Oblique";
+            } else {
+                name = "Courier";
+            }
+        } else if ((flags & PDFFontDescriptor.SERIF) != 0) {  // serif font
+            if (((style & Typeface.BOLD) > 0) && ((style & Typeface.ITALIC) > 0)) {
+                name = "Times-BoldItalic";
+            } else if ((style & Typeface.BOLD) > 0) {
+                name = "Times-Bold";
+            } else if ((style & Typeface.ITALIC) > 0) {
+                name = "Times-Italic";
+            } else {
+                name = "Times-Roman";
+            }
+        } else {
+            if (((style & Typeface.BOLD) > 0) && ((style & Typeface.ITALIC) > 0)) {
+                name = "Helvetica-BoldOblique";
+            } else if ((style & Typeface.BOLD) > 0) {
+                name = "Helvetica-Bold";
+            } else if ((style & Typeface.ITALIC) > 0) {
+                name = "Helvetica-Oblique";
+            } else {
+                name = "Helvetica";
+            }
+        }
+
+        parseFont(name);
+    }
+
+    /**
+     * Parse a font given only the name of a builtin font
+     */
+    private void parseFont(String baseFont) throws IOException {
+        // load the base fonts properties files, if it isn't already loaded
+        if (props == null) {
+            props = new Properties();
+            props.load(BuiltinFont.class.getResourceAsStream("res/BaseFonts.properties"));
+        }
+
+        // make sure we're a known font
+        if (!props.containsKey(baseFont + ".file")) {
+            throw new IllegalArgumentException("Unknown Base Font: " + baseFont);
+        }
+
+        // get the font information from the properties file
+        String file = props.getProperty(baseFont + ".file");
+
+        // the size of the file
+        int length = Integer.parseInt(props.getProperty(baseFont + ".length"));
+        // the size of the unencrypted portion
+        int length1 = 0;
+        // the size of the encrypted portion
+        int length2 = 0;
+
+        // read the data from the file
+        byte[] data = new byte[length];
+//        if (true)
+//        	throw new UnsupportedOperationException("Native Fonts not yet supported!");
+        InputStream fontStream = BuiltinFont.class.getResourceAsStream("res/" + file);
+        int cur = 0;
+        while (cur < length) {
+            cur += fontStream.read(data, cur, length - cur);
+        }
+        fontStream.close();
+
+        // are we a pfb file?
+        if ((data[0] & 0xff) == 0x80) {
+            // read lengths from the file
+            length1 = (data[2] & 0xff);
+            length1 |= (data[3] & 0xff) << 8;
+            length1 |= (data[4] & 0xff) << 16;
+            length1 |= (data[5] & 0xff) << 24;
+            length1 += 6;
+
+            length2 = (data[length1 + 2] & 0xff);
+            length2 |= (data[length1 + 3] & 0xff) << 8;
+            length2 |= (data[length1 + 4] & 0xff) << 16;
+            length2 |= (data[length1 + 5] & 0xff) << 24;
+            length1 += 6;
+        } else {
+            // get the values from the properties file
+            length1 = Integer.parseInt(props.getProperty(baseFont + ".length1"));
+
+            if (props.containsKey(baseFont + ".length2")) {
+                length2 = Integer.parseInt(props.getProperty(baseFont + ".lenth2"));
+            } else {
+                length2 = length - length1;
+            }
+        }
+
+        parseFont(data, length1, length2);
+    }
+}

src/com/sun/pdfview/font/CIDFontType2.java

@@ -0,0 +1,274 @@
+/*
+ * $Id: CIDFontType2.java,v 1.5 2009/03/15 20:47:38 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview.font;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+import net.sf.andpdf.pdfviewer.ByteBuffer;
+
+import android.graphics.Path;
+
+import com.sun.pdfview.PDFObject;
+
+/**
+ * a font object derived from a CID font.
+ *
+ * @author Jonathan Kaplan
+ */
+public class CIDFontType2 extends TTFFont {
+
+    /**
+     * The width of each glyph from the DW and W arrays
+     */
+    private Map<Character, Float> widths = null;
+    /**
+     * The vertical width of each glyph from the DW2 and W2 arrays
+     */
+    private Map<Character, Float> widthsVertical = null;
+
+    /*
+     * the default width
+     */
+    private int defaultWidth = 1000;
+    /*
+     * the default vertical width
+     */
+    private int defaultWidthVertical = 1000;
+    /** the CIDtoGID map, if any */
+    private ByteBuffer cidToGidMap;
+
+    /**
+     * create a new CIDFontType2 object based on the name of a built-in font
+     * and the font descriptor
+     * @param baseName the name of the font, from the PDF file
+     * @param fontObj a dictionary that contains the DW (defaultWidth) and
+     * W (width) parameters
+     * @param descriptor a descriptor for the font
+     */
+    public CIDFontType2(String baseName, PDFObject fontObj,
+            PDFFontDescriptor descriptor) throws IOException {
+        super(baseName, fontObj, descriptor);
+
+        parseWidths(fontObj);
+
+        // read the CIDSystemInfo dictionary (required)
+        PDFObject systemInfoObj = fontObj.getDictRef("CIDSystemInfo");
+        // read the cid to gid map (optional)
+        PDFObject mapObj = fontObj.getDictRef("CIDToGIDMap");
+
+
+        // only read the map if it is a stream (if it is a name, it
+        // is "Identity" and can be ignored
+        if (mapObj != null && (mapObj.getType() == PDFObject.STREAM)) {
+            cidToGidMap = mapObj.getStreamBuffer();
+        }
+    }
+
+    /** Parse the Widths array and DW object */
+    private void parseWidths(PDFObject fontObj)
+            throws IOException {
+        // read the default width (otpional)
+        PDFObject defaultWidthObj = fontObj.getDictRef("DW");
+        if (defaultWidthObj != null) {
+            defaultWidth = defaultWidthObj.getIntValue();
+        }
+
+        int entryIdx = 0;
+        int first = 0;
+        int last = 0;
+        PDFObject[] widthArray;
+
+        // read the widths table 
+        PDFObject widthObj = fontObj.getDictRef("W");
+        if (widthObj != null) {
+
+            // initialize the widths array
+            widths = new HashMap<Character, Float>();
+
+            // parse the width array
+            widthArray = widthObj.getArray();
+
+            /* an entry can be in one of two forms:
+             *   <startIndex> <endIndex> <value> or
+             *   <startIndex> [ array of values ]
+             * we use the entryIdx to differentitate between them
+             */
+            for (int i = 0; i < widthArray.length; i++) {
+                if (entryIdx == 0) {
+                    // first value in an entry.  Just store it
+                    first = widthArray[i].getIntValue();
+                } else if (entryIdx == 1) {
+                    // second value -- is it an int or array?
+                    if (widthArray[i].getType() == PDFObject.ARRAY) {
+                        // add all the entries in the array to the width array
+                        PDFObject[] entries = widthArray[i].getArray();
+                        for (int c = 0; c < entries.length; c++) {
+                            Character key = new Character((char) (c + first));
+
+                            // value is width / default width
+                            float value = entries[c].getIntValue();
+                            widths.put(key, new Float(value));
+                        }
+                        // all done
+                        entryIdx = -1;
+                    } else {
+                        last = widthArray[i].getIntValue();
+                    }
+                } else {
+                    // third value.  Set a range
+                    int value = widthArray[i].getIntValue();
+
+                    // set the range
+                    for (int c = first; c <= last; c++) {
+                        widths.put(new Character((char) c), new Float(value));
+                    }
+
+                    // all done
+                    entryIdx = -1;
+                }
+
+                entryIdx++;
+            }
+        }
+
+        // read the optional vertical default width
+        defaultWidthObj = fontObj.getDictRef("DW2");
+        if (defaultWidthObj != null) {
+            defaultWidthVertical = defaultWidthObj.getIntValue();
+        }
+
+        // read the vertical widths table
+        widthObj = fontObj.getDictRef("W2");
+        if (widthObj != null) {
+
+            // initialize the widths array
+            widthsVertical = new HashMap<Character, Float>();
+
+            // parse the width2 array
+            widthArray = widthObj.getArray();
+
+            /* an entry can be in one of two forms:
+             *   <startIndex> <endIndex> <value> or
+             *   <startIndex> [ array of values ]
+             * we use the entryIdx to differentitate between them
+             */
+            entryIdx = 0;
+            first = 0;
+            last = 0;
+
+            for (int i = 0; i < widthArray.length; i++) {
+                if (entryIdx == 0) {
+                    // first value in an entry.  Just store it
+                    first = widthArray[i].getIntValue();
+                } else if (entryIdx == 1) {
+                    // second value -- is it an int or array?
+                    if (widthArray[i].getType() == PDFObject.ARRAY) {
+                        // add all the entries in the array to the width array
+                        PDFObject[] entries = widthArray[i].getArray();
+                        for (int c = 0; c < entries.length; c++) {
+                            Character key = new Character((char) (c + first));
+
+                            // value is width / default width
+                            float value = entries[c].getIntValue();
+                            widthsVertical.put(key, new Float(value));
+                        }
+                        // all done
+                        entryIdx = -1;
+                    } else {
+                        last = widthArray[i].getIntValue();
+                    }
+                } else {
+                    // third value.  Set a range
+                    int value = widthArray[i].getIntValue();
+
+                    // set the range
+                    for (int c = first; c <= last; c++) {
+                        widthsVertical.put(new Character((char) c), new Float(value));
+                    }
+
+                    // all done
+                    entryIdx = -1;
+                }
+
+                entryIdx++;
+            }
+        }
+    }
+
+    /** Get the default width in text space */
+    @Override
+    public int getDefaultWidth() {
+        return defaultWidth;
+    }
+
+    /** Get the width of a given character */
+    @Override
+    public float getWidth(char code, String name) {
+        if (widths == null) {
+            return 1f;
+        }
+        Float w = widths.get(new Character(code));
+        if (w == null) {
+            return 1f;
+        }
+
+        return w.floatValue() / getDefaultWidth();
+    }
+
+    /** Get the default vertical width in text space */
+    public int getDefaultWidthVertical() {
+        return defaultWidthVertical;
+    }
+
+    /** Get the vertical width of a given character */
+    public float getWidthVertical(char code, String name) {
+        if (widthsVertical == null) {
+            return 1f;
+        }
+        Float w = widthsVertical.get(new Character(code));
+        if (w == null) {
+            return 1f;
+        }
+
+        return w.floatValue() / getDefaultWidth();
+    }
+
+    /**
+     * Get the outline of a character given the character code.  We
+     * interpose here in order to avoid using the CMap of the font in
+     * a CID mapped font.
+     */
+    @Override
+    protected synchronized Path getOutline(char src, float width) {
+        int glyphId = (int) (src & 0xffff);
+
+        // check if there is a cidToGidMap
+        if (cidToGidMap != null) {
+            // read the map
+            glyphId = cidToGidMap.getChar(glyphId * 2);
+        }
+
+        // call getOutline on the glyphId
+        return getOutline(glyphId, width);
+    }
+}

src/com/sun/pdfview/font/FlPoint.java

@@ -0,0 +1,50 @@
+/*
+ * $Id: FlPoint.java,v 1.2 2007/12/20 18:33:31 rbair Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package com.sun.pdfview.font;
+
+/**
+ * A floating-point Point, with public fields.  Also contains a flag
+ * for "open" to indicate that the path this point is a member of has
+ * or hasn't been closed.
+ *
+ * @author Mike Wessler
+ */
+public class FlPoint {
+    /** x coordinate of the point */
+    public float x= 0;
+
+    /** y coordinate of the point */
+    public float y= 0;
+
+    /**
+     * whether the path this point is a part of is open or closed.
+     * used in Type1CFont.java.
+     */
+    public boolean open= false;
+    
+    /** reset the values to (0,0) and closed */
+    public final void reset() {
+	x= 0;
+	y= 0;
+	open= false;
+    }
+}

src/com/sun/pdfview/font/FontSupport.java

@@ -0,0 +1,397 @@
+/*
+ * $Id: FontSupport.java,v 1.3 2009/03/15 20:47:38 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview.font;
+
+/**
+ * some constants and utility functions for font support.
+ * @author Mike Wessler
+ */
+public class FontSupport {
+
+    /**
+     * names for glyphs in the standard Adobe order.  This is the ordering
+     * of the glyphs in a font, not the mapping of character number to
+     * character.
+     */
+    public static final String stdNames[] = {
+        ".notdef", "space", "exclam", "quotedbl", "numbersign", "dollar",
+        "percent", "ampersand", "quoteright", "parenleft", "parenright",
+        "asterisk", "plus", "comma", "hyphen", "period", "slash", "zero",
+        "one", "two", "three", "four", "five", "six", "seven", "eight",
+        "nine", "colon", "semicolon", "less", "equal", "greater", "question",
+        "at", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M",
+        "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z",
+        "bracketleft", "backslash", "bracketright", "asciicircum",
+        "underscore", "quoteleft", "a", "b", "c", "d", "e", "f", "g", "h",
+        "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v",
+        "w", "x", "y", "z", "braceleft", "bar", "braceright", "asciitilde",
+        "exclamdown", "cent", "sterling", "fraction", "yen", "florin",
+        "section", "currency", "quotesingle", "quotedblleft", "guillemotleft",
+        "guilsinglleft", "guilsinglright", "fi", "fl", "endash", "dagger",
+        "daggerdbl", "periodcentered", "paragraph", "bullet",
+        "quotesinglbase", "quotedblbase", "quotedblright", "guillemotright",
+        "ellipsis", "perthousand", "questiondown", "grave", "acute",
+        "circumflex", "tilde", "macron", "breve", "dotaccent", "dieresis",
+        "ring", "cedilla", "hungarumlaut", "ogonek", "caron", "emdash", "AE",
+        "ordfeminine", "Lslash", "Oslash", "OE", "ordmasculine", "ae",
+        "dotlessi", "lslash", "oslash", "oe", "germandbls", "onesuperior",
+        "logicalnot", "mu", "trademark", "Eth", "onehalf", "plusminus",
+        "Thorn", "onequarter", "divide", "brokenbar", "degree", "thorn",
+        "threequarters", "twosuperior", "registered", "minus", "eth",
+        "multiply", "threesuperior", "copyright", "Aacute", "Acircumflex",
+        "Adieresis", "Agrave", "Aring", "Atilde", "Ccedilla", "Eacute",
+        "Ecircumflex", "Edieresis", "Egrave", "Iacute", "Icircumflex",
+        "Idieresis", "Igrave", "Ntilde", "Oacute", "Ocircumflex", "Odieresis",
+        "Ograve", "Otilde", "Scaron", "Uacute", "Ucircumflex", "Udieresis",
+        "Ugrave", "Yacute", "Ydieresis", "Zcaron", "aacute", "acircumflex",
+        "adieresis", "agrave", "aring", "atilde", "ccedilla", "eacute",
+        "ecircumflex", "edieresis", "egrave", "iacute", "icircumflex",
+        "idieresis", "igrave", "ntilde", "oacute", "ocircumflex", "odieresis",
+        "ograve", "otilde", "scaron", "uacute", "ucircumflex", "udieresis",
+        "ugrave", "yacute", "ydieresis", "zcaron", "exclamsmall",
+        "Hungarumlautsmall", "dollaroldstyle", "dollarsuperior",
+        "ampersandsmall", "Acutesmall", "parenleftsuperior",
+        "parenrightsuperior", "twodotenleader", "onedotenleader",
+        "zerooldstyle", "oneoldstyle", "twooldstyle", "threeoldstyle",
+        "fouroldstyle", "fiveoldstyle", "sixoldstyle", "sevenoldstyle",
+        "eightoldstyle", "nineoldstyle", "commasuperior",
+        "threequartersemdash", "periodsuperior", "questionsmall", "asuperior",
+        "bsuperior", "centsuperior", "dsuperior", "esuperior", "isuperior",
+        "lsuperior", "msuperior", "nsuperior", "osuperior", "rsuperior",
+        "ssuperior", "tsuperior", "ff", "ffi", "ffl", "parenleftinferior",
+        "parenrightinferior", "Circumflexsmall", "hyphensuperior",
+        "Gravesmall", "Asmall", "Bsmall", "Csmall", "Dsmall", "Esmall",
+        "Fsmall", "Gsmall", "Hsmall", "Ismall", "Jsmall", "Ksmall", "Lsmall",
+        "Msmall", "Nsmall", "Osmall", "Psmall", "Qsmall", "Rsmall", "Ssmall",
+        "Tsmall", "Usmall", "Vsmall", "Wsmall", "Xsmall", "Ysmall", "Zsmall",
+        "colonmonetary", "onefitted", "rupiah", "Tildesmall",
+        "exclamdownsmall", "centoldstyle", "Lslashsmall", "Scaronsmall",
+        "Zcaronsmall", "Dieresissmall", "Brevesmall", "Caronsmall",
+        "Dotaccentsmall", "Macronsmall", "figuredash", "hypheninferior",
+        "Ogoneksmall", "Ringsmall", "Cedillasmall", "questiondownsmall",
+        "oneeighth", "threeeighths", "fiveeighths", "seveneighths",
+        "onethird", "twothirds", "zerosuperior", "foursuperior",
+        "fivesuperior", "sixsuperior", "sevensuperior", "eightsuperior",
+        "ninesuperior", "zeroinferior", "oneinferior", "twoinferior",
+        "threeinferior", "fourinferior", "fiveinferior", "sixinferior",
+        "seveninferior", "eightinferior", "nineinferior", "centinferior",
+        "dollarinferior", "periodinferior", "commainferior", "Agravesmall",
+        "Aacutesmall", "Acircumflexsmall", "Atildesmall", "Adieresissmall",
+        "Aringsmall", "AEsmall", "Ccedillasmall", "Egravesmall",
+        "Eacutesmall", "Ecircumflexsmall", "Edieresissmall", "Igravesmall",
+        "Iacutesmall", "Icircumflexsmall", "Idieresissmall", "Ethsmall",
+        "Ntildesmall", "Ogravesmall", "Oacutesmall", "Ocircumflexsmall",
+        "Otildesmall", "Odieresissmall", "OEsmall", "Oslashsmall",
+        "Ugravesmall", "Uacutesmall", "Ucircumflexsmall", "Udieresissmall",
+        "Yacutesmall", "Thornsmall", "Ydieresissmall", "001.000", "001.001",
+        "001.002", "001.003", "Black", "Bold", "Book", "Light", "Medium",
+        "Regular", "Roman", "Semibold"
+    };
+
+    /**
+     * characters for glyphs in the standard order.  These are string "values"
+     * to go with the names in stdNames.  Not all glyphs have been translated
+     * to their unicode values.  In many cases, the name of the glyph has
+     * been appended to an ASCII approximation of the glyph.  Strings longer
+     * than 3 characters have this characteristic.  To get the character,
+     * use the string if it contains 3 or fewer characters; otherwise,
+     * grab the first character off the string and use that.
+     */
+    static final String stdValues[] = {
+        "", " ", "!", "\"", "#", "$",
+        "%", "&", "'", "(", ")",
+        "*", "+", ",", "-", ".", "/", "0",
+        "1", "2", "3", "4", "5", "6", "7", "8",
+        "9", ":", ";", "<", "=", ">", "?",
+        "@", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M",
+        "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z",
+        "[", "\\", "]", "^",
+        "_", "`", "a", "b", "c", "d", "e", "f", "g", "h",
+        "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v",
+        "w", "x", "y", "z", "{", "|", "}", "~",
+        "\u00a1", "\u00a2", "\u00a3", "/fraction", "\u00a5", "Fflorin",
+        "\u00a7", "\u00a4", "\u00b4quotesingle", "\u201c", "?guillemotleft",
+        "\u2039", "\u203a", "fi", "fl", "--", "\u2020",
+        "\u2021", "\u00b7", "\u00b6", "\u2022",
+        "'quotesinglbase", "\"quotedblbase", "\"quotedblright", "?guillemotright",
+        "...ellipsis", "%perthousand", "?questiondown", "`grave", "'acute",
+        "^circumflex", "~tilde", "-macron", "?breve", "?dotaccent", "?dieresis",
+        "oring", "ccedilla", ":hungarumlaut", "?ogonek", ",caron", "---emdash", "AE",
+        "aordfeminine", "LLslash", "OOslash", "OE", "oordmasculine", "ae",
+        "idotlessi", "llslash", "ooslash", "oe", "Bgermandbls", "1onesuperior",
+        "~logicalnot", "?mu", "(TM)trademark", "?Eth", "1/2", "+/-",
+        "?Thorn", "1/4", "/divide", "|brokenbar", "*degree", "?thorn",
+        "3/4", "2twosuperior", "(R)", "-minus", "?eth",
+        "*multiply", "3threesuperior", "(C)", "AAacute", "AAcircumflex",
+        "AAdieresis", "AAgrave", "AAring", "AAtilde", "CCcedilla", "EEacute",
+        "EEcircumflex", "EEdieresis", "EEgrave", "IIacute", "IIcircumflex",
+        "IIdieresis", "IIgrave", "NNtilde", "OOacute", "OOcircumflex", "OOdieresis",
+        "OOgrave", "OOtilde", "SScaron", "UUacute", "UUcircumflex", "UUdieresis",
+        "UUgrave", "YYacute", "YYdieresis", "ZZcaron", "aaacute", "aacircumflex",
+        "aadieresis", "aagrave", "aaring", "aatilde", "cccedilla", "eeacute",
+        "eecircumflex", "eedieresis", "eegrave", "iiacute", "iicircumflex",
+        "iidieresis", "iigrave", "nntilde", "ooacute", "oocircumflex", "oodieresis",
+        "oograve", "ootilde", "sscaron", "uuacute", "uucircumflex", "uudieresis",
+        "uugrave", "yyacute", "yydieresis", "zzcaron", "!exclamsmall",
+        "?Hungarumlautsmall", "$dollaroldstyle", "$dollarsuperior",
+        "&ampersandsmall", "'Acutesmall", "/parenleftsuperior",
+        "\\parenrightsuperior", "?twodotenleader", "?onedotenleader",
+        "0zerooldstyle", "1oneoldstyle", "2twooldstyle", "3threeoldstyle",
+        "4fouroldstyle", "5fiveoldstyle", "6sixoldstyle", "7sevenoldstyle",
+        "8eightoldstyle", "9nineoldstyle", "'commasuperior",
+        "--threequartersemdash", ".periodsuperior", "?questionsmall", "aasuperior",
+        "bbsuperior", "ccentsuperior", "ddsuperior", "eesuperior", "iisuperior",
+        "llsuperior", "mmsuperior", "nnsuperior", "oosuperior", "rrsuperior",
+        "sssuperior", "ttsuperior", "ff", "ffi", "ffl", "\\parenleftinferior",
+        "/parenrightinferior", "^Circumflexsmall", "-hyphensuperior",
+        "`Gravesmall", "AAsmall", "BBsmall", "CCsmall", "DDsmall", "EEsmall",
+        "FFsmall", "GGsmall", "HHsmall", "IIsmall", "JJsmall", "KKsmall", "LLsmall",
+        "MMsmall", "NNsmall", "OOsmall", "PPsmall", "QQsmall", "RRsmall", "SSsmall",
+        "TTsmall", "UUsmall", "VVsmall", "WWsmall", "XXsmall", "YYsmall", "ZZsmall",
+        ":colonmonetary", "1onefitted", "?rupiah", "~Tildesmall",
+        "!exclamdownsmall", "ccentoldstyle", "LLslashsmall", "SScaronsmall",
+        "ZZcaronsmall", "?Dieresissmall", "?Brevesmall", "^Caronsmall",
+        "?Dotaccentsmall", "?Macronsmall", "--figuredash", "-hypheninferior",
+        "?Ogoneksmall", "oRingsmall", ",Cedillasmall", "?questiondownsmall",
+        "1/8oneeighth", "3/8threeeighths", "5/8fiveeighths", "7/8seveneighths",
+        "1/3onethird", "2/3twothirds", "0zerosuperior", "4foursuperior",
+        "5fivesuperior", "6sixsuperior", "7sevensuperior", "8eightsuperior",
+        "9ninesuperior", "0zeroinferior", "1oneinferior", "2twoinferior",
+        "3threeinferior", "4fourinferior", "5fiveinferior", "6sixinferior",
+        "7seveninferior", "8eightinferior", "9nineinferior", "ccentinferior",
+        "$dollarinferior", ".periodinferior", ",commainferior", "AAgravesmall",
+        "AAacutesmall", "AAcircumflexsmall", "AAtildesmall", "AAdieresissmall",
+        "AAringsmall", "AEAEsmall", "CCcedillasmall", "EEgravesmall",
+        "EEacutesmall", "EEcircumflexsmall", "EEdieresissmall", "IIgravesmall",
+        "IIacutesmall", "IIcircumflexsmall", "IIdieresissmall", "EthEthsmall",
+        "NNtildesmall", "OOgravesmall", "OOacutesmall", "OOcircumflexsmall",
+        "OOtildesmall", "OOdieresissmall", "OEOEsmall", "OOslashsmall",
+        "UUgravesmall", "UUacutesmall", "UUcircumflexsmall", "UUdieresissmall",
+        "YYacutesmall", "?Thornsmall", "YYdieresissmall", "?001.000", "?001.001",
+        "?001.002", "?001.003", " Black", " Bold", " Book", " Light", " Medium",
+        " Regular", " Roman", " Semibold",
+        /* extra mac stuff */
+        "?NUL", "?HT", " LF", " CR", "?DLE", "?DC1", "?DC2", "?DC3", "?DC4", "?RS",
+        "?US", "!=", "?DEL", "?infinity", "<=", ">=",
+        "?partialdiff", "?summation", "xproduct", "?pi", "?integral", "?Omega",
+        "?radical", "~=", "?Delta", " nbspace", "?lozenge", "?apple"
+    };
+
+    /**
+     * glyph order of the glyphs for the Type1C Expert character set.  These
+     * are indices into the glyph name array.
+     */
+    public static final int type1CExpertCharset[] = {
+        1, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 13, 14, 15, 99,
+        239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 27, 28, 249, 250,
+        251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264,
+        265, 266, 109, 110, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276,
+        277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290,
+        291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
+        305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318,
+        158, 155, 163, 319, 320, 321, 322, 323, 324, 325, 326, 150, 164, 169,
+        327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340,
+        341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
+        355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368,
+        369, 370, 371, 372, 373, 374, 375, 376, 377, 378
+    };
+
+    /**
+     * glyph order of the glyphs for the Type1C Expert Sub character set.
+     * These are indices into the glyph name array.
+     */
+    public static final int type1CExpertSubCharset[] = {
+        1, 231, 232, 235, 236, 237, 238, 13, 14, 15, 99, 239, 240, 241, 242,
+        243, 244, 245, 246, 247, 248, 27, 28, 249, 250, 251, 253, 254, 255,
+        256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 109, 110, 267,
+        268, 269, 270, 272, 300, 301, 302, 305, 314, 315, 158, 155, 163, 320,
+        321, 322, 323, 324, 325, 326, 150, 164, 169, 327, 328, 329, 330, 331,
+        332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345,
+        346
+    };
+
+    /**
+     * extra names for the Macintosh glyph set.  This array should be
+     * considered to be appended to the stdNames array.  The stdValues array
+     * already contains values for this set.
+     */
+    public static final String macExtras[] = { // index starts at 391=NUL
+        "NUL", "HT", "LF", "CR", "DLE", "DC1", "DC2", "DC3", "DC4", "RS",
+        "US", "notequal", "DEL", "infinity", "lessequal", "greaterequal",
+        "partialdiff", "summation", "product", "pi", "integral", "Omega",
+        "radical", "approxequal", "Delta", "nbspace", "lozenge", "apple"
+    };
+
+    /**
+     * character mapping from values to glyphs for the Macintosh MacRoman
+     * encoding
+     */
+    public static final int macRomanEncoding[] = {
+        391, 154, 167, 140, 146, 192, 221, 197, 226, 392, 393, 157, 162, 394,
+        199, 228, 395, 396, 397, 398, 399, 155, 158, 150, 163, 169, 164, 160,
+        166, 168, 400, 401, 1, 2, 3, 4, 5, 6, 7, 104, 9, 10, 11, 12, 13, 14,
+        15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
+        32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
+        49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 124,
+        66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
+        83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 403, 173, 175,
+        177, 178, 186, 189, 195, 200, 203, 201, 202, 205, 204, 206, 207, 210,
+        208, 209, 211, 214, 212, 213, 215, 216, 219, 217, 218, 220, 222, 225,
+        223, 224, 112, 161, 97, 98, 102, 116, 115, 149, 165, 170, 153, 125,
+        131, 402, 138, 141, 404, 156, 405, 406, 100, 152, 407, 408, 409, 410,
+        411, 139, 143, 412, 144, 147, 123, 96, 151, 413, 101, 414, 415, 106,
+        120, 121, 416, 174, 176, 191, 142, 148, 111, 137, 105, 119, 65, 8,
+        159, 417, 227, 198, 99, 103, 107, 108, 109, 110, 113, 114, 117, 118,
+        122, 172, 179, 171, 180, 181, 182, 183, 184, 185, 187, 188, 418, 190,
+        193, 194, 196, 145, 126, 127, 128, 129, 130, 132, 133, 134, 135, 136
+    };
+
+    /**
+     * character mapping from values to glyphs for the isoLatin1Encoding
+     */
+    public static final int isoLatin1Encoding[] = {
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
+        166, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
+        31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
+        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
+        65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
+        82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 145, 124, 125, 126, 127, 128,
+        129, 130, 131, 0, 132, 133, 0, 134, 135, 136, 1, 96, 97, 98, 103,
+        100, 160, 102, 131, 170, 139, 106, 151, 14, 165, 128, 161, 156, 164,
+        169, 125, 152, 115, 114, 133, 150, 143, 120, 158, 155, 163, 123, 174,
+        171, 172, 176, 173, 175, 138, 177, 181, 178, 179, 180, 185, 182, 183,
+        184, 154, 186, 190, 187, 188, 191, 189, 168, 141, 196, 193, 194, 195,
+        197, 157, 149, 203, 200, 201, 205, 202, 204, 144, 206, 210, 207, 208,
+        209, 214, 211, 212, 213, 167, 215, 219, 216, 217, 220, 218, 159, 147,
+        225, 222, 223, 224, 226, 162, 227
+    };
+
+    /**
+     * character mapping from values to glyphs for the Windows winAnsi
+     * character encoding
+     */
+    public static final int winAnsiEncoding[] = {
+        124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 145,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5,
+        6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
+        24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+        41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
+        58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
+        75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91,
+        92, 93, 94, 95, 0, 0, 0, 117, 101, 118, 121, 112, 113, 0, 122, 192,
+        107, 142, 0, 0, 0, 0, 65, 8, 105, 119, 116, 111, 137, 0, 153, 221,
+        108, 148, 0, 0, 198, 1, 96, 97, 98, 103, 100, 160, 102, 131, 170,
+        139, 106, 151, 14, 165, 128, 161, 156, 164, 169, 125, 152, 115, 114,
+        133, 150, 143, 120, 158, 155, 163, 123, 174, 171, 172, 176, 173, 175,
+        138, 177, 181, 178, 179, 180, 185, 182, 183, 184, 154, 186, 190, 187,
+        188, 191, 189, 168, 141, 196, 193, 194, 195, 197, 157, 149, 203, 200,
+        201, 205, 202, 204, 144, 206, 210, 207, 208, 209, 214, 211, 212, 213,
+        167, 215, 219, 216, 217, 220, 218, 159, 147, 225, 222, 223, 224, 226,
+        162, 227
+    };
+
+    /**
+     * character mapping from values to glyphs for Adobe's standard
+     * character encoding
+     */
+    public static final int standardEncoding[] = {
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
+        14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
+        31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
+        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
+        65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
+        82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105,
+        106, 107, 108, 109, 110, 0, 111, 112, 113, 114, 0, 115, 116, 117,
+        118, 119, 120, 121, 122, 0, 123, 0, 124, 125, 126, 127, 128, 129,
+        130, 131, 0, 132, 133, 0, 134, 135, 136, 137, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 138, 0, 139, 0, 0, 0, 0, 140, 141, 142, 143,
+        0, 0, 0, 0, 0, 144, 0, 0, 0, 145, 0, 0, 146, 147, 148, 149, 0, 0, 0,
+        0
+    };
+
+    /**
+     * get the name of a glyph from its encoding value (NOT the character
+     * value), using the standard encoding.
+     */
+    public static String getName (int i) {
+        if (i < stdNames.length) {
+            return stdNames[i];
+        } else {
+            i -= stdNames.length;
+            if (i < macExtras.length) {
+                return macExtras[i];
+            }
+        }
+        return ".notdef";
+    }
+
+    /**
+     * get the encoding value a glyph given its name and a name table.
+     * @param name the name of the glyph
+     * @param table the charset as an array of names
+     * @return the index of the name in the table, or -1 if the name
+     * cannot be found in the table
+     */
+    public static int findName (String name, String[] table) {
+        for (int i = 0; i < table.length; i++) {
+            if (name.equals (table[i])) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    /**
+     * get the encoding value of a glyph given its name and a charset.
+     * @param name the name of the glyph
+     * @param table the charset table
+     * @return the index of the name in the charset.
+     */
+    public static int findName (String name, int[] table) {
+        for (int i = 0; i < table.length; i++) {
+            if (name.equals (getName (table[i]))) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    /**
+     * get the encoding value of a glyph given its name, in the standard
+     * charset.  This is equivalent to findName(name, FontSupport.stdNames).
+     * @param name the name of the glyph
+     * @return the index of the name in stdNames, or -1 if the name doesn't
+     * appear in stdNames.
+     */
+    public static int getStrIndex (String name) {
+        for (int i = 0; i < stdNames.length; i++) {
+            if (name.equals (stdNames[i])) {
+                return i;
+            }
+        }
+        return -1;
+    }
+}

src/com/sun/pdfview/font/OutlineFont.java

@@ -0,0 +1,156 @@
+/*
+ * $Id: OutlineFont.java,v 1.3 2009/02/09 16:29:58 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview.font;
+
+import java.io.IOException;
+
+import android.graphics.Path;
+import android.graphics.PointF;
+
+import com.sun.pdfview.PDFObject;
+
+/**
+ * Supports width operations for Type1, Type1C, TrueType and Type3 fonts
+ */
+public abstract class OutlineFont extends PDFFont {
+
+    /** the first character code */
+    private int firstChar = -1;
+    /** the last character code */
+    private int lastChar = -1;
+    /** the widths for each character code */
+    private float[] widths;
+
+    /** Creates a new instance of OutlineFont */
+    public OutlineFont(String baseFont, PDFObject fontObj,
+            PDFFontDescriptor descriptor) throws IOException {
+        super(baseFont, descriptor);
+
+        PDFObject firstCharObj = fontObj.getDictRef("FirstChar");
+        PDFObject lastCharObj = fontObj.getDictRef("LastChar");
+        PDFObject widthArrayObj = fontObj.getDictRef("Widths");
+
+        if (firstCharObj != null) {
+            firstChar = firstCharObj.getIntValue();
+        }
+        if (lastCharObj != null) {
+            lastChar = lastCharObj.getIntValue();
+        }
+
+        if (widthArrayObj != null) {
+            PDFObject[] widthArray = widthArrayObj.getArray();
+
+            widths = new float[widthArray.length];
+
+            for (int i = 0; i < widthArray.length; i++) {
+                widths[i] = widthArray[i].getFloatValue() / getDefaultWidth();
+            }
+        }
+    }
+
+    /** Get the first character code */
+    public int getFirstChar() {
+        return firstChar;
+    }
+
+    /** Get the last character code */
+    public int getLastChar() {
+        return lastChar;
+    }
+
+    /** Get the default width in text space */
+    public int getDefaultWidth() {
+        return 1000;
+    }
+
+    /** Get the number of characters */
+    public int getCharCount() {
+        return (getLastChar() - getFirstChar()) + 1;
+    }
+
+    /** Get the width of a given character */
+    public float getWidth(char code, String name) {
+        int idx = (code & 0xff) - getFirstChar();
+
+        // make sure we're in range
+        if (idx < 0 || widths == null || idx >= widths.length) {
+            // try to get the missing width from the font descriptor
+            if (getDescriptor() != null) {
+                return getDescriptor().getMissingWidth();
+            } else {
+                return 0;
+            }
+        }
+
+        return widths[idx];
+    }
+
+    /**
+     * Get the glyph for a given character code and name
+     *
+     * The preferred method of getting the glyph should be by name.  If the
+     * name is null or not valid, then the character code should be used.
+     * If the both the code and the name are invalid, the undefined glyph 
+     * should be returned.
+     *
+     * Note this method must *always* return a glyph.  
+     *
+     * @param src the character code of this glyph
+     * @param name the name of this glyph or null if unknown
+     * @return a glyph for this character
+     */
+    protected PDFGlyph getGlyph(char src, String name) {
+        Path outline = null;
+        float width = getWidth(src, name);
+
+        // first try by name
+        if (name != null) {
+            outline = getOutline(name, width);
+        }
+
+        // now try by character code (guaranteed to return)
+        if (outline == null) {
+            outline = getOutline(src, width);
+        }
+
+        // calculate the advance
+        PointF advance = new PointF(width, 0);
+        return new PDFGlyph(src, name, outline, advance);
+    }
+
+    /**
+     * Get a glyph outline by name
+     *
+     * @param name the name of the desired glyph
+     * @return the glyph outline, or null if unavailable
+     */
+    protected abstract Path getOutline(String name, float width);
+
+    /**
+     * Get a glyph outline by character code
+     *
+     * Note this method must always return an outline 
+     *
+     * @param src the character code of the desired glyph
+     * @return the glyph outline
+     */
+    protected abstract Path getOutline(char src, float width);
+}

src/com/sun/pdfview/font/PDFCMap.java

@@ -0,0 +1,106 @@
+/*
+ * $Id: PDFCMap.java,v 1.3 2009/02/12 13:53:54 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview.font;
+
+import java.io.IOException;
+import java.util.HashMap;
+
+import com.sun.pdfview.PDFObject;
+
+/**
+ * A CMap maps from a character in a composite font to a font/glyph number
+ * pair in a CID font.
+ *
+ * @author  jkaplan
+ */
+public abstract class PDFCMap {
+    /**
+     * A cache of known CMaps by name
+     */
+    private static HashMap<String, PDFCMap> cache;
+    
+    /** Creates a new instance of CMap */
+    protected PDFCMap() {}
+    
+    /**
+     * Get a CMap, given a PDF object containing one of the following:
+     *  a string name of a known CMap
+     *  a stream containing a CMap definition
+     */
+    public static PDFCMap getCMap(PDFObject map) throws IOException {
+        if (map.getType() == PDFObject.NAME) {
+            return getCMap(map.getStringValue());
+        } else if (map.getType() == PDFObject.STREAM) {
+            return parseCMap(map);
+        } else {
+            throw new IOException("CMap type not Name or Stream!");
+        }
+    }
+       
+    /**
+     * Get a CMap, given a string name
+     */
+    public static PDFCMap getCMap(String mapName) throws IOException {
+        if (cache == null) {
+            populateCache();
+        }
+        
+        if (!cache.containsKey(mapName)) {
+            throw new IOException("Unknown CMap: " + mapName);
+        }
+            
+        return (PDFCMap) cache.get(mapName);
+    }
+    
+    /**
+     * Populate the cache with well-known types
+     */
+    protected static void populateCache() {
+        cache = new HashMap<String, PDFCMap>();
+    
+        // add the Identity-H map
+        cache.put("Identity-H", new PDFCMap() {
+            public char map(char src) {
+                return src;
+            }
+        });
+    }
+    
+    /**
+     * Parse a CMap from a CMap stream
+     */
+    protected static PDFCMap parseCMap(PDFObject map) throws IOException {
+        throw new IOException("Parsing CMap Files Unsupported!");
+    }
+    
+    /**
+     * Map a given source character to a destination character
+     */
+    public abstract char map(char src);
+    
+    /**
+     * Get the font number assoicated with a given source character
+     */
+    public int getFontID(char src) {
+        return 0;
+    }
+    
+}

src/com/sun/pdfview/font/PDFFont.java

@@ -0,0 +1,368 @@
+/*
+ * $Id: PDFFont.java,v 1.6 2009/03/15 20:47:38 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview.font;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import com.sun.pdfview.PDFObject;
+import com.sun.pdfview.PDFParseException;
+
+/**
+ * a Font definition for PDF files
+ * @author Mike Wessler
+ */
+public abstract class PDFFont {
+
+    /** the font SubType of this font */
+    private String subtype;
+    /** the postscript name of this font */
+    private String baseFont;
+    /** the font encoding (maps character ids to glyphs) */
+    private PDFFontEncoding encoding;
+    /** the font descriptor */
+    private PDFFontDescriptor descriptor;
+    /** the CMap that maps this font to unicode values */
+    private PDFCMap unicodeMap;
+    /** a cache of glyphs indexed by character */
+    private Map<Character,PDFGlyph> charCache;
+
+    /**
+     * get the PDFFont corresponding to the font described in a PDFObject.
+     * The object is actually a dictionary containing the following keys:<br>
+     * Type = "Font"<br>
+     * Subtype = (Type1 | TrueType | Type3 | Type0 | MMType1 | CIDFontType0 |
+     * CIDFontType2)<br>
+     * FirstChar = #<br>
+     * LastChar = #<br>
+     * Widths = array of #<br>
+     * Encoding = (some name representing a dictionary in the resources | an
+     * inline dictionary)
+     * <p>
+     * For Type1 and TrueType fonts, the dictionary also contains:<br>
+     * BaseFont = (some name, or XXXXXX+Name as a subset of font Name)
+     * <p>
+     * For Type3 font, the dictionary contains:<br>
+     * FontBBox = (rectangle)<br>
+     * FontMatrix = (array, typically [0.001, 0, 0, 0.001, 0, 0])<br>
+     * CharProcs = (dictionary)
+     * Resources = (dictionary)
+     */
+    public synchronized static PDFFont getFont(PDFObject obj,
+            HashMap<String,PDFObject> resources)
+            throws IOException {
+        // the obj is actually a dictionary containing:
+        //    Type (=Font)
+        //    Subtype (Type1, TrueType, Type3, Type0, MMType1, CIDFontType0,2)
+        //    FirstChar (int)
+        //    LastChar (int)
+        //    Widths (array)
+        //    Encoding (name or dict) : assumes StandardEncoding
+        // and........
+        // Type1 and TrueType fonts:
+        //    BaseFont (name)  // may be XXXXXX+Fontname as a subset.
+        //    FontDescriptor (dict)
+        // Type3 fonts:
+        //    FontBBox (rectangle)
+        //    FontMatrix (array) // e.g. [0.001 0 0 0.001 0 0]
+        //    CharProcs (dict)
+        //    Resources (dict)
+        //
+        // Font descriptor (Type1 and TrueType fonts):
+        //    FontName (name)
+        //    Flags (1=monospace, 2=serif, 4=script, 7=italic, 19=bold)
+        //    FontBBox (rectangle)
+        //    ItalicAngle (float)
+        //    Ascent (float)
+        //    Descent (float)
+        //    CapHeight (float)
+        //    StemV (float)
+        //    FontFile (stream for Type1 fonts)
+        //    FontFile2 (stream for TrueType fonts)
+        //    FontFile3 (stream for CFF/Type1C fonts)
+        //
+        // Font data can be Type1, TrueType(native), or Type1C
+        PDFFont font = (PDFFont) obj.getCache();
+        if (font != null) {
+            return font;
+        }
+
+        String baseFont = null;
+        PDFFontEncoding encoding = null;
+        PDFFontDescriptor descriptor = null;
+
+        String subType = obj.getDictRef("Subtype").getStringValue();
+        if (subType == null) {
+            subType = obj.getDictRef("S").getStringValue();
+        }
+        PDFObject baseFontObj = obj.getDictRef("BaseFont");
+        PDFObject encodingObj = obj.getDictRef("Encoding");
+        PDFObject descObj = obj.getDictRef("FontDescriptor");
+
+        if (baseFontObj != null) {
+            baseFont = baseFontObj.getStringValue();
+        } else {
+            baseFontObj = obj.getDictRef("Name");
+            if (baseFontObj != null) {
+                baseFont = baseFontObj.getStringValue();
+            }
+        }
+
+        if (encodingObj != null) {
+            encoding = new PDFFontEncoding(subType, encodingObj);
+        }
+
+        if (descObj != null) {
+            descriptor = new PDFFontDescriptor(descObj);
+        } else {
+            descriptor = new PDFFontDescriptor(baseFont);
+        }
+
+        if (subType.equals("Type0")) {
+            font = new Type0Font(baseFont, obj, descriptor);
+        } else if (subType.equals("Type1")) {
+            // load a type1 font
+            if (descriptor == null) {
+                // it's one of the built-in fonts
+                font = new BuiltinFont(baseFont, obj);
+            } else if (descriptor.getFontFile() != null) {
+                // it's a Type1 font, included.
+                font = new Type1Font(baseFont, obj, descriptor);
+            } else if (descriptor.getFontFile3() != null) {
+                // it's a CFF (Type1C) font
+                font = new Type1CFont(baseFont, obj, descriptor);
+            } else {
+                // no font info. Fake it based on the FontDescriptor
+                //		System.out.println("Fakeout native font");
+                font = new BuiltinFont(baseFont, obj, descriptor);
+            }
+        } else if (subType.equals("TrueType")) {
+            if (descriptor.getFontFile2() != null) {
+                // load a TrueType font
+                font = new TTFFont(baseFont, obj, descriptor);
+            } else {
+                // fake it with a built-in font
+                font = new BuiltinFont(baseFont, obj, descriptor);
+            }
+        } else if (subType.equals("Type3")) {
+            // load a type 3 font
+            font = new Type3Font(baseFont, obj, resources, descriptor);
+        } else if (subType.equals("CIDFontType2")) {
+            font = new CIDFontType2(baseFont, obj, descriptor);
+        } else if (subType.equals("CIDFontType0")) {
+            font = new CIDFontType2(baseFont, obj, descriptor);
+//            font = new CIDFontType0(baseFont, obj, descriptor);
+//            throw new IOException ("CIDFontType0 is unimplemented. " + obj);
+        } else {
+            throw new PDFParseException("Don't know how to handle a '" +
+                    subType + "' font");
+        }
+
+        font.setSubtype(subType);
+        font.setEncoding(encoding);
+
+        obj.setCache(font);
+        return font;
+    }
+
+    /**
+     * Get the subtype of this font.
+     * @return the subtype, one of: Type0, Type1, TrueType or Type3
+     */
+    public String getSubtype() {
+        return subtype;
+    }
+
+    /**
+     * Set the font subtype
+     */
+    public void setSubtype(String subtype) {
+        this.subtype = subtype;
+    }
+
+    /**
+     * Get the postscript name of this font
+     * @return the postscript name of this font
+     */
+    public String getBaseFont() {
+        return baseFont;
+    }
+
+    /**
+     * Set the postscript name of this font
+     * @param baseFont the postscript name of the font
+     */
+    public void setBaseFont(String baseFont) {
+        this.baseFont = baseFont;
+    }
+
+    /**
+     * Get the encoding for this font
+     * @return the encoding which maps from this font to actual characters
+     */
+    public PDFFontEncoding getEncoding() {
+        return encoding;
+    }
+
+    /**
+     * Set the encoding for this font
+     */
+    public void setEncoding(PDFFontEncoding encoding) {
+        this.encoding = encoding;
+    }
+
+    /**
+     * Get the descriptor for this font
+     * @return the font descriptor
+     */
+    public PDFFontDescriptor getDescriptor() {
+        return descriptor;
+    }
+
+    /**
+     * Set the descriptor font descriptor
+     */
+    public void setDescriptor(PDFFontDescriptor descriptor) {
+        this.descriptor = descriptor;
+    }
+
+    /**
+     * Get the CMap which maps the characters in this font to unicode names
+     */
+    public PDFCMap getUnicodeMap() {
+        return unicodeMap;
+    }
+
+    /**
+     * Set the CMap which maps the characters in this font to unicode names
+     */
+    public void setUnicodeMap(PDFCMap unicodeMap) {
+        this.unicodeMap = unicodeMap;
+    }
+
+    /**
+     * Get the glyphs associated with a given String in this font
+     *
+     * @param text the text to translate into glyphs
+     */
+    public List<PDFGlyph> getGlyphs(String text) {
+        List<PDFGlyph> outList = null;
+
+        // if we have an encoding, use it to get the commands
+        if (encoding != null) {
+            outList = encoding.getGlyphs(this, text);
+        } else {
+            // use the default mapping
+            char[] arry = text.toCharArray();
+            outList = new ArrayList<PDFGlyph>(arry.length);
+
+            for (int i = 0; i < arry.length; i++) {
+                // only look at 2 bytes when there is no encoding
+                char src = (char) (arry[i] & 0xff);
+                outList.add(getCachedGlyph(src, null));
+            }
+        }
+
+        return outList;
+    }
+
+    /**
+     * Get a glyph for a given character code.  The glyph is returned
+     * from the cache if available, or added to the cache if not
+     *
+     * @param src the character code of this glyph
+     * @param name the name of the glyph, or null if the name is unknown
+     * @return a glyph for this character
+     */
+    public PDFGlyph getCachedGlyph(char src, String name) {
+        if (charCache == null) {
+            charCache = new HashMap<Character,PDFGlyph>();
+        }
+
+        // try the cache
+        PDFGlyph glyph = (PDFGlyph) charCache.get(new Character(src));
+
+        // if it's not there, add it to the cache
+        if (glyph == null) {
+            glyph = getGlyph(src, name);
+            charCache.put(new Character(src), glyph);
+        }
+
+        return glyph;
+    }
+
+    /**
+     * Create a PDFFont given the base font name and the font descriptor
+     * @param baseFont the postscript name of this font
+     * @param descriptor the descriptor for the font
+     */
+    protected PDFFont(String baseFont, PDFFontDescriptor descriptor) {
+        setBaseFont(baseFont);
+        setDescriptor(descriptor);
+    }
+
+    /**
+     * Get the glyph for a given character code and name
+     *
+     * The preferred method of getting the glyph should be by name.  If the
+     * name is null or not valid, then the character code should be used.
+     * If the both the code and the name are invalid, the undefined glyph 
+     * should be returned.
+     *
+     * Note this method must *always* return a glyph.  
+     *
+     * @param src the character code of this glyph
+     * @param name the name of this glyph or null if unknown
+     * @return a glyph for this character
+     */
+    protected abstract PDFGlyph getGlyph(char src, String name);
+
+    /**
+     * Turn this font into a pretty String
+     */
+    @Override
+    public String toString() {
+        return getBaseFont();
+    }
+
+    /** 
+     * Compare two fonts base on the baseFont
+     */
+    @Override
+    public boolean equals(Object o) {
+        if (!(o instanceof PDFFont)) {
+            return false;
+        }
+
+        return ((PDFFont) o).getBaseFont().equals(getBaseFont());
+    }
+
+    /**
+     * Hash a font based on its base font
+     */
+    @Override
+    public int hashCode() {
+        return getBaseFont().hashCode();
+    }
+}

src/com/sun/pdfview/font/PDFFontDescriptor.java

@@ -0,0 +1,507 @@
+/*
+ * $Id: PDFFontDescriptor.java,v 1.4 2009/03/15 20:47:38 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview.font;
+
+import java.io.IOException;
+
+import android.graphics.RectF;
+
+import com.sun.pdfview.PDFObject;
+
+/**
+ *
+ * @author  jkaplan
+ */
+public class PDFFontDescriptor {
+
+    /** All glyphs have the same width. */
+    public final static int FIXED_PITCH = 1 << (1-1);
+    /** Glyphs have serifs. */
+    public final static int SERIF = 1 << (2-1);
+    /** Font contains glyphs outside the Adobe standard Latin. */
+    public final static int SYMBOLIC = 1 << (3-1);
+    /** Glyphs resemble cursive handwriting. */
+    public final static int SCRIPT = 1 << (4-1);
+    /** Font uses the Adobe standard Latic character set. */
+    public final static int NONSYMBOLIC = 1 << (6-1);
+    /** Glyphs have dominant vertical strokes that are slanted. */
+    public final static int ITALIC = 1 << (7-1);
+    /** Font contains no lowercase letters. */
+    public final static int ALLCAP = 1 << (17-1);
+    /** Font contains both uppercase and lowercase letters.. */
+    public final static int SMALLCAP = 1 << (18-1);
+    /** Determines whether bold glyphs shall be painted with
+     * extra pixels even at very small text sizes. */
+    public final static int FORCEBOLD = 1 << (19-1);
+    /** Holds value of property ascent. */
+    private int ascent;
+    /** Holds value of property capHeight. */
+    private int capHeight;
+    /** Holds value of property descent. */
+    private int descent;
+    /** Holds value of property flags. */
+    private int flags;
+    /** Holds the optional FontFamily (PDF 1.5) */
+    private String fontFamily;
+    /** Holds value of property fontName. */
+    private String fontName;
+    /** Holds the optional FontStretch (PDF 1.5) */
+    private String fontStretch;
+    /** Holds the optional FontWeight (PDF 1.5) */
+    private int fontWeight;
+    /** Holds value of property italicAngle. */
+    private int italicAngle;
+    /** Holds value of property stemV. */
+    private int stemV;
+    /** Holds value of property avgWidth. */
+    private int avgWidth = 0;
+    /** Holds value of property fontFile. */
+    private PDFObject fontFile;
+    /** Holds value of property fontFile2. */
+    private PDFObject fontFile2;
+    /** Holds value of property fontFile3. */
+    private PDFObject fontFile3;
+    /** Holds value of property leading. */
+    private int leading = 0;
+    /** Holds value of property maxWidth. */
+    private int maxWidth = 0;
+    /** Holds value of property misingWidth. */
+    private int missingWidth = 0;
+    /** Holds value of property stemH. */
+    private int stemH = 0;
+    /** Holds value of property xHeight. */
+    private int xHeight = 0;
+    /** Holds value of property charSet. */
+    private PDFObject charSet;
+    /** Holds value of property fontBBox. */
+    private RectF fontBBox;
+
+    /** Creates a new instance of PDFFontDescriptor */
+    public PDFFontDescriptor(String basefont) {
+        setFontName(basefont);
+    // [[MW TODO: find basefont info and fill in the rest of the
+    // descriptor?]]
+    }
+
+    /** Creates a new instance of PDFFontDescriptor */
+    public PDFFontDescriptor(PDFObject obj) throws IOException {
+        // required parameters
+        setAscent(obj.getDictRef("Ascent").getIntValue());
+        setCapHeight(obj.getDictRef("CapHeight").getIntValue());
+        setDescent(obj.getDictRef("Descent").getIntValue());
+        setFlags(obj.getDictRef("Flags").getIntValue());
+        setFontName(obj.getDictRef("FontName").getStringValue());
+        setItalicAngle(obj.getDictRef("ItalicAngle").getIntValue());
+        setStemV(obj.getDictRef("StemV").getIntValue());
+
+        // font bounding box
+        PDFObject[] bboxdef = obj.getDictRef("FontBBox").getArray();
+        float[] bboxfdef = new float[4];
+        for (int i = 0; i < 4; i++) {
+            bboxfdef[i] = bboxdef[i].getFloatValue();
+        }
+        setFontBBox(new RectF(bboxfdef[0], bboxfdef[1],
+                bboxfdef[2] - bboxfdef[0],
+                bboxfdef[3] - bboxfdef[1]));
+
+        // optional parameters
+        if (obj.getDictionary().containsKey("AvgWidth")) {
+            setAvgWidth(obj.getDictRef("AvgWidth").getIntValue());
+        }
+        if (obj.getDictionary().containsKey("FontFile")) {
+            setFontFile(obj.getDictRef("FontFile"));
+        }
+        if (obj.getDictionary().containsKey("FontFile2")) {
+            setFontFile2(obj.getDictRef("FontFile2"));
+        }
+        if (obj.getDictionary().containsKey("FontFile3")) {
+            setFontFile3(obj.getDictRef("FontFile3"));
+        }
+        if (obj.getDictionary().containsKey("Leading")) {
+            setLeading(obj.getDictRef("Leading").getIntValue());
+        }
+        if (obj.getDictionary().containsKey("MaxWidth")) {
+            setMaxWidth(obj.getDictRef("MaxWidth").getIntValue());
+        }
+        if (obj.getDictionary().containsKey("MissingWidth")) {
+            setMissingWidth(obj.getDictRef("MissingWidth").getIntValue());
+        }
+        if (obj.getDictionary().containsKey("StemH")) {
+            setStemH(obj.getDictRef("StemH").getIntValue());
+        }
+        if (obj.getDictionary().containsKey("XHeight")) {
+            setXHeight(obj.getDictRef("XHeight").getIntValue());
+        }
+        if (obj.getDictionary().containsKey("CharSet")) {
+            setCharSet(obj.getDictRef("CharSet"));
+        }
+        if (obj.getDictionary().containsKey("FontFamily")) {
+            setFontFamily(obj.getDictRef("FontFamily").getStringValue());
+        }
+        if (obj.getDictionary().containsKey("FontWeight")) {
+            setFontWeight(obj.getDictRef("FontWeight").getIntValue());
+        }
+        if (obj.getDictionary().containsKey("FontStretch")) {
+            setFontStretch(obj.getDictRef("FontStretch").getStringValue());
+        }
+    }
+
+    /** Getter for property ascent.
+     * @return Value of property ascent.
+     *
+     */
+    public int getAscent() {
+        return this.ascent;
+    }
+
+    /** Setter for property ascent.
+     * @param ascent New value of property ascent.
+     *
+     */
+    public void setAscent(int ascent) {
+        this.ascent = ascent;
+    }
+
+    /** Getter for property capHeight.
+     * @return Value of property capHeight.
+     *
+     */
+    public int getCapHeight() {
+        return this.capHeight;
+    }
+
+    /** Setter for property capHeight.
+     * @param capHeight New value of property capHeight.
+     *
+     */
+    public void setCapHeight(int capHeight) {
+        this.capHeight = capHeight;
+    }
+
+    /** Getter for property descent.
+     * @return Value of property descent.
+     *
+     */
+    public int getDescent() {
+        return this.descent;
+    }
+
+    /** Setter for property descent.
+     * @param descent New value of property descent.
+     *
+     */
+    public void setDescent(int descent) {
+        this.descent = descent;
+    }
+
+    /** Getter for property flags.
+     * @return Value of property flags.
+     *
+     */
+    public int getFlags() {
+        return this.flags;
+    }
+
+    /** Setter for property flags.
+     * @param flags New value of property flags.
+     *
+     */
+    public void setFlags(int flags) {
+        this.flags = flags;
+    }
+
+    /** Getter for property fontFamily. Option (PDF 1.5)
+     * @return Value of the property fontFamily
+     */
+    public String getFontFamily() {
+        return this.fontFamily;
+    }
+
+    /** Setter for property fontFamily.
+     * @param fontFamily New value of property fontFamily.
+     *
+     */
+    public void setFontFamily(String fontFamily) {
+        this.fontFamily = fontFamily;
+    }
+
+    /** Getter for property fontName.
+     * @return Value of property fontName.
+     *
+     */
+    public String getFontName() {
+        return this.fontName;
+    }
+
+    /** Setter for property fontName.
+     * @param fontName New value of property fontName.
+     *
+     */
+    public void setFontName(String fontName) {
+        this.fontName = fontName;
+    }
+
+    /** Getter for property fontStretch. Option (PDF 1.5)
+     * 
+     * @return Value of the property fontStretch
+     */
+    public String getFontStretch() {
+        return this.fontStretch;
+    }
+
+    /** Setter for property fontStretch. Possible values are:
+     * UltraCondensed, ExtraCondensed, Condensed, SemiCondensed,
+     * Normal, SemiExpanded, Expanded, ExtraExpanded or UltraExpanded
+     * We do not check at this time.
+     *
+     * @param fontStretch New value of property fontStretch.
+     *
+     */
+    public void setFontStretch(String fontStretch) {
+        this.fontStretch = fontStretch;
+    }
+
+    /** Getter for property fontWeight. Option (PDF 1.5)
+     *
+     * @return Value of the property fontWeight
+     */
+    public int getFontWeight() {
+        return this.fontWeight;
+    }
+
+    /** Setter for property fontWeight. Possible values are:
+     * 100, 200, 300, 400, 500, 600, 700, 800, 900
+     * We do not check at this time.
+     *
+     * @param fontWeight New value of property fontWeight.
+     *
+     */
+    public void setFontWeight(int fontWeight) {
+        this.fontWeight = fontWeight;
+    }
+
+    /** Getter for property italicAngle.
+     * @return Value of property italicAngle.
+     *
+     */
+    public int getItalicAngle() {
+        return this.italicAngle;
+    }
+
+    /** Setter for property italicAngle.
+     * @param italicAngle New value of property italicAngle.
+     *
+     */
+    public void setItalicAngle(int italicAngle) {
+        this.italicAngle = italicAngle;
+    }
+
+    /** Getter for property stemV.
+     * @return Value of property stemV.
+     *
+     */
+    public int getStemV() {
+        return this.stemV;
+    }
+
+    /** Setter for property stemV.
+     * @param stemV New value of property stemV.
+     *
+     */
+    public void setStemV(int stemV) {
+        this.stemV = stemV;
+    }
+
+    /** Getter for property avgWidth.
+     * @return Value of property avgWidth.
+     *
+     */
+    public int getAvgWidth() {
+        return this.avgWidth;
+    }
+
+    /** Setter for property avgWidth.
+     * @param avgWidth New value of property avgWidth.
+     *
+     */
+    public void setAvgWidth(int avgWidth) {
+        this.avgWidth = avgWidth;
+    }
+
+    /** Getter for property fontFile.
+     * @return Value of property fontFile.
+     *
+     */
+    public PDFObject getFontFile() {
+        return this.fontFile;
+    }
+
+    /** Setter for property fontFile.
+     * @param fontFile New value of property fontFile.
+     *
+     */
+    public void setFontFile(PDFObject fontFile) {
+        this.fontFile = fontFile;
+    }
+
+    /** Getter for property fontFile2.
+     * @return Value of property fontFile2.
+     *
+     */
+    public PDFObject getFontFile2() {
+        return this.fontFile2;
+    }
+
+    /** Setter for property fontFile2.
+     * @param fontFile2 New value of property fontFile2.
+     *
+     */
+    public void setFontFile2(PDFObject fontFile2) {
+        this.fontFile2 = fontFile2;
+    }
+
+    /** Getter for property fontFile3.
+     * @return Value of property fontFile3.
+     *
+     */
+    public PDFObject getFontFile3() {
+        return this.fontFile3;
+    }
+
+    /** Setter for property fontFile3.
+     * @param fontFile3 New value of property fontFile3.
+     *
+     */
+    public void setFontFile3(PDFObject fontFile3) {
+        this.fontFile3 = fontFile3;
+    }
+
+    /** Getter for property leading.
+     * @return Value of property leading.
+     *
+     */
+    public int getLeading() {
+        return this.leading;
+    }
+
+    /** Setter for property leading.
+     * @param leading New value of property leading.
+     *
+     */
+    public void setLeading(int leading) {
+        this.leading = leading;
+    }
+
+    /** Getter for property maxWidth.
+     * @return Value of property maxWidth.
+     *
+     */
+    public int getMaxWidth() {
+        return this.maxWidth;
+    }
+
+    /** Setter for property maxWidth.
+     * @param maxWidth New value of property maxWidth.
+     *
+     */
+    public void setMaxWidth(int maxWidth) {
+        this.maxWidth = maxWidth;
+    }
+
+    /** Getter for property misingWidth.
+     * @return Value of property misingWidth.
+     *
+     */
+    public int getMissingWidth() {
+        return this.missingWidth;
+    }
+
+    /** Setter for property misingWidth.
+     * @param missingWidth New value of property misingWidth.
+     */
+    public void setMissingWidth(int missingWidth) {
+        this.missingWidth = missingWidth;
+    }
+
+    /** Getter for property stemH.
+     * @return Value of property stemH.
+     *
+     */
+    public int getStemH() {
+        return this.stemH;
+    }
+
+    /** Setter for property stemH.
+     * @param stemH New value of property stemH.
+     *
+     */
+    public void setStemH(int stemH) {
+        this.stemH = stemH;
+    }
+
+    /** Getter for property xHeight.
+     * @return Value of property xHeight.
+     *
+     */
+    public int getXHeight() {
+        return this.xHeight;
+    }
+
+    /** Setter for property xHeight.
+     * @param xHeight New value of property xHeight.
+     *
+     */
+    public void setXHeight(int xHeight) {
+        this.xHeight = xHeight;
+    }
+
+    /** Getter for property charSet.
+     * @return Value of property charSet.
+     *
+     */
+    public PDFObject getCharSet() {
+        return this.charSet;
+    }
+
+    /** Setter for property charSet.
+     * @param charSet New value of property charSet.
+     *
+     */
+    public void setCharSet(PDFObject charSet) {
+        this.charSet = charSet;
+    }
+
+    /** Getter for property fontBBox.
+     * @return Value of property fontBBox.
+     *
+     */
+    public RectF getFontBBox() {
+        return this.fontBBox;
+    }
+
+    /** Setter for property fontBBox.
+     * @param fontBBox New value of property fontBBox.
+     *
+     */
+    public void setFontBBox(RectF fontBBox) {
+        this.fontBBox = fontBBox;
+    }
+}

src/com/sun/pdfview/font/PDFFontEncoding.java

@@ -0,0 +1,202 @@
+/*
+ * $Id: PDFFontEncoding.java,v 1.4 2009/02/12 13:53:54 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview.font;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import com.sun.pdfview.PDFObject;
+
+/**
+ * The PDFFont encoding encapsulates the mapping from character codes
+ * in the PDF document to glyphs of the font.
+ *
+ * Encodings take two basic forms.  For Type1, TrueType, and Type3 fonts,
+ * the encoding maps from character codes to Strings, which represent the
+ * glyphs of the font.  For Type0 fonts, the mapping is a CMap which maps
+ * character codes to characters in one of many descendant fonts.
+ *
+ * Note that the data in the PDF might be ASCII characters (bytes) or it might
+ * be a multi-byte format such as unicode.  For now we will assume all
+ * glyph ids fit into at most the two bytes of a character.
+ */
+public class PDFFontEncoding {
+
+    /** Encoding types */
+    private static final int TYPE_ENCODING = 0;
+    private static final int TYPE_CMAP = 1;
+    /** 
+     * the base encoding (an array of integers which can be mapped to names
+     * using the methods on FontSupport
+     */
+    private int[] baseEncoding;
+    /** any differences from the base encoding */
+    private Map<Character,String> differences;
+    /**
+     * a CMap for fonts encoded by CMap
+     */
+    private PDFCMap cmap;
+    /**
+     * the type of this encoding (encoding or CMap)
+     */
+    private int type;
+
+    /** Creates a new instance of PDFFontEncoding */
+    public PDFFontEncoding(String fontType, PDFObject encoding)
+            throws IOException {
+        if (encoding.getType() == PDFObject.NAME) {
+            // if the encoding is a String, it is the name of an encoding
+            // or the name of a CMap, depending on the type of the font
+            if (fontType.equals("Type0")) {
+                type = TYPE_CMAP;
+                cmap = PDFCMap.getCMap(encoding.getStringValue());
+            } else {
+                type = TYPE_ENCODING;
+
+                differences = new HashMap<Character,String>();
+                baseEncoding = this.getBaseEncoding(encoding.getStringValue());
+            }
+        } else {
+            // loook at the "Type" entry of the encoding to determine the type
+            String typeStr = encoding.getDictRef("Type").getStringValue();
+
+            if (typeStr.equals("Encoding")) {
+                // it is an encoding
+                type = TYPE_ENCODING;
+                parseEncoding(encoding);
+            } else if (typeStr.equals("CMap")) {
+                // it is a CMap
+                type = TYPE_CMAP;
+                cmap = PDFCMap.getCMap(encoding);
+            } else {
+                throw new IllegalArgumentException("Uknown encoding type: " + type);
+            }
+        }
+    }
+
+    /** Get the glyphs associated with a given String */
+    public List<PDFGlyph> getGlyphs(PDFFont font, String text) {
+        List<PDFGlyph> outList = new ArrayList<PDFGlyph>(text.length());
+
+        // go character by character through the text
+        char[] arry = text.toCharArray();
+        for (int i = 0; i < arry.length; i++) {
+            switch (type) {
+                case TYPE_ENCODING:
+                    outList.add(getGlyphFromEncoding(font, arry[i]));
+                    break;
+                case TYPE_CMAP:
+                    // 2 bytes -> 1 character in a CMap
+                    char c = (char) ((arry[i] & 0xff) << 8);
+                    if (i < arry.length - 1) {
+                        c |= (char) (arry[++i] & 0xff);
+                    }
+                    outList.add(getGlyphFromCMap(font, c));
+                    break;
+            }
+        }
+
+        return outList;
+    }
+
+    /**
+     * Get a glyph from an encoding, given a font and character
+     */
+    private PDFGlyph getGlyphFromEncoding(PDFFont font, char src) {
+        String charName = null;
+
+        // only deal with one byte of source
+        src &= 0xff;
+
+        // see if this character is in the differences list
+        if (differences.containsKey(new Character(src))) {
+            charName = (String) differences.get(new Character(src));
+        } else if (baseEncoding != null) {
+            // get the character name from the base encoding
+            int charID = baseEncoding[src];
+            charName = FontSupport.getName(charID);
+        }
+
+        return font.getCachedGlyph(src, charName);
+    }
+
+    /**
+     * Get a glyph from a CMap, given a Type0 font and a character
+     */
+    private PDFGlyph getGlyphFromCMap(PDFFont font, char src) {
+        int fontID = cmap.getFontID(src);
+        char charID = cmap.map(src);
+
+        if (font instanceof Type0Font) {
+            font = ((Type0Font) font).getDescendantFont(fontID);
+        }
+
+        return font.getCachedGlyph(charID, null);
+    }
+
+    /**
+     * Parse a PDF encoding object for the actual encoding
+     */
+    public void parseEncoding(PDFObject encoding) throws IOException {
+        differences = new HashMap<Character,String>();
+
+        // figure out the base encoding, if one exists
+        PDFObject baseEncObj = encoding.getDictRef("BaseEncoding");
+        if (baseEncObj != null) {
+            baseEncoding = getBaseEncoding(baseEncObj.getStringValue());
+        }
+
+        // parse the differences array
+        PDFObject diffArrayObj = encoding.getDictRef("Differences");
+        if (diffArrayObj != null) {
+            PDFObject[] diffArray = diffArrayObj.getArray();
+            int curPosition = -1;
+
+            for (int i = 0; i < diffArray.length; i++) {
+                if (diffArray[i].getType() == PDFObject.NUMBER) {
+                    curPosition = diffArray[i].getIntValue();
+                } else if (diffArray[i].getType() == PDFObject.NAME) {
+                    Character key = new Character((char) curPosition);
+                    differences.put(key, diffArray[i].getStringValue());
+                    curPosition++;
+                } else {
+                    throw new IllegalArgumentException("Unexpected type in diff array: " + diffArray[i]);
+                }
+            }
+        }
+    }
+
+    /** Get the base encoding for a given name */
+    private int[] getBaseEncoding(String encodingName) {
+        if (encodingName.equals("MacRomanEncoding")) {
+            return FontSupport.macRomanEncoding;
+        } else if (encodingName.equals("MacExpertEncoding")) {
+            return FontSupport.type1CExpertCharset;
+        } else if (encodingName.equals("WinAnsiEncoding")) {
+            return FontSupport.winAnsiEncoding;
+        } else {
+            throw new IllegalArgumentException("Unknown encoding: " + encodingName);
+        }
+    }
+}

src/com/sun/pdfview/font/PDFGlyph.java

@@ -0,0 +1,107 @@
+/*
+ * $Id: PDFGlyph.java,v 1.3 2009/02/09 16:35:01 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package com.sun.pdfview.font;
+
+
+import android.graphics.Matrix;
+import android.graphics.Path;
+import android.graphics.PointF;
+
+import com.sun.pdfview.PDFPage;
+import com.sun.pdfview.PDFShapeCmd;
+
+/**
+ * A single glyph in a stream of PDF text, which knows how to write itself
+ * onto a PDF command stream
+ */
+public class PDFGlyph {
+    /** the character code of this glyph */
+    private char src;
+    
+    /** the name of this glyph */
+    private String name;
+    
+    /** the advance from this glyph */
+    private PointF advance;
+    
+    /** the shape represented by this glyph (for all fonts but type 3) */
+    private Path shape;
+    
+    /** the PDFPage storing this glyph's commands (for type 3 fonts) */
+    private PDFPage page;
+    
+    /** Creates a new instance of PDFGlyph based on a shape */
+    public PDFGlyph(char src, String name, Path shape, 
+                    PointF advance) {
+        this.shape = shape;
+        this.advance = advance;
+        this.src = src;
+        this.name = name;
+    }
+    
+    /** Creates a new instance of PDFGlyph based on a page */
+    public PDFGlyph(char src, String name, PDFPage page, PointF advance) {
+        this.page = page;
+        this.advance = advance;
+        this.src = src;
+        this.name = name;
+    }
+       
+    /** Get the character code of this glyph */
+    public char getChar() {
+        return src;
+    }
+    
+    /** Get the name of this glyph */
+    public String getName() {
+        return name;
+    }
+    
+    /** Get the shape of this glyph */
+    public Path getShape() {
+        return shape;
+    }
+    
+    /** Get the PDFPage for a type3 font glyph */
+    public PDFPage getPage() {
+        return page;
+    }
+    
+    /** Add commands for this glyph to a page */
+    public PointF addCommands(PDFPage cmds, Matrix transform, int mode) {
+        if (shape != null) {
+            Path outline= new Path();
+            shape.transform(transform, outline);
+            cmds.addCommand(new PDFShapeCmd(outline, mode));
+        } else if (page != null) {
+            cmds.addCommands(page, transform);
+        }
+    
+        return advance;
+    }
+
+    public String toString () {
+        StringBuffer str = new StringBuffer ();
+        str.append(name);
+        return str.toString();
+    }
+}

src/com/sun/pdfview/font/TTFFont.java

@@ -0,0 +1,326 @@
+/*
+ * $Id: TTFFont.java,v 1.10 2009/02/23 15:29:19 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package com.sun.pdfview.font;
+
+import java.io.IOException;
+
+import net.sf.andpdf.utils.Utils;
+
+import android.graphics.Matrix;
+import android.graphics.Path;
+
+import com.sun.pdfview.PDFObject;
+import com.sun.pdfview.font.ttf.AdobeGlyphList;
+import com.sun.pdfview.font.ttf.CMap;
+import com.sun.pdfview.font.ttf.CmapTable;
+import com.sun.pdfview.font.ttf.Glyf;
+import com.sun.pdfview.font.ttf.GlyfCompound;
+import com.sun.pdfview.font.ttf.GlyfSimple;
+import com.sun.pdfview.font.ttf.GlyfTable;
+import com.sun.pdfview.font.ttf.HeadTable;
+import com.sun.pdfview.font.ttf.HmtxTable;
+import com.sun.pdfview.font.ttf.PostTable;
+import com.sun.pdfview.font.ttf.TrueTypeFont;
+
+
+/**
+ * A true-type font
+ */
+public class TTFFont extends OutlineFont {
+
+    /** the truetype font itself */
+    private TrueTypeFont font;
+    /** the number of units per em in the font */
+    private float unitsPerEm;
+
+    /**
+     * create a new TrueTypeFont object based on a description of the
+     * font from the PDF file.  If the description happens to contain
+     * an in-line true-type font file (under key "FontFile2"), use the
+     * true type font.  Otherwise, parse the description for key information
+     * and use that to generate an appropriate font.
+     */
+    public TTFFont(String baseFont, PDFObject fontObj,
+            PDFFontDescriptor descriptor)
+            throws IOException {
+        super(baseFont, fontObj, descriptor);
+
+        String fontName = descriptor.getFontName();
+        PDFObject ttfObj = descriptor.getFontFile2();
+
+        // try {
+        //    byte[] fontData = ttfObj.getStream();
+        //    java.io.FileOutputStream fis = new java.io.FileOutputStream("/tmp/" + fontName + ".ttf");
+        //    fis.write(fontData);
+        //    fis.flush();
+        //    fis.close();
+        // } catch (Exception ex) {
+        //    ex.printStackTrace();
+        // }
+        if (ttfObj != null) {
+            font = TrueTypeFont.parseFont(ttfObj.getStreamBuffer());
+            // read the units per em from the head table
+            HeadTable head = (HeadTable) font.getTable("head");
+            unitsPerEm = head.getUnitsPerEm();
+        } else {
+            font = null;
+        }
+//        System.out.println ("TTFFont: ttfObj: " + ttfObj + ", fontName: " + fontName);
+
+    }
+
+    /**
+     * Get the outline of a character given the character code
+     */
+    protected synchronized Path getOutline(char src, float width) {
+        // find the cmaps
+        CmapTable cmap = (CmapTable) font.getTable("cmap");
+
+        // if there are no cmaps, this is (hopefully) a cid-mapped font,
+        // so just trust the value we were given for src
+        if (cmap == null) {
+            return getOutline((int) src, width);
+        }
+
+        CMap[] maps = cmap.getCMaps();
+
+        // try the maps in order
+        for (int i = 0; i < maps.length; i++) {
+            int idx = maps[i].map(src);
+            if (idx != 0) {
+                return getOutline(idx, width);
+            }
+        }
+
+        // not found, return the empty glyph
+        return getOutline(0, width);
+    }
+
+    /**
+     * lookup the outline using the CMAPs, as specified in 32000-1:2008,
+     * 9.6.6.4, when an Encoding is specified.
+     * 
+     * @param val
+     * @param width
+     * @return GeneralPath
+     */
+    protected synchronized Path getOutlineFromCMaps(char val, float width) {
+        // find the cmaps
+        CmapTable cmap = (CmapTable) font.getTable("cmap");
+
+        if (cmap == null) {
+            return null;
+        }
+
+        // try maps in required order of (3, 1), (1, 0)
+        CMap map = cmap.getCMap((short) 3, (short) 1);
+        if (map == null) {
+            map = cmap.getCMap((short) 1, (short) 0);
+        }
+        int idx = map.map(val);
+        if (idx != 0) {
+            return getOutline(idx, width);
+        }
+
+        return null;
+    }
+
+    /**
+     * Get the outline of a character given the character name
+     */
+    protected synchronized Path getOutline(String name, float width) {
+        int idx;
+        PostTable post = (PostTable) font.getTable("post");
+        if (post != null) {
+        	idx = post.getGlyphNameIndex(name);
+        	if (idx != 0) {
+        		return getOutline(idx, width);
+        	}
+        	return null;
+        }
+        
+        Integer res = AdobeGlyphList.getGlyphNameIndex(name);
+        if(res != null) {
+        	idx = res;
+        	return getOutlineFromCMaps((char)idx, width);
+        }        		        
+        return null;
+    }
+
+    /**
+     * Get the outline of a character given the glyph id
+     */
+    protected synchronized Path getOutline(int glyphId, float width) {
+        // find the glyph itself
+        GlyfTable glyf = (GlyfTable) font.getTable("glyf");
+        Glyf g = glyf.getGlyph(glyphId);
+
+        Path gp = null;
+        if (g instanceof GlyfSimple) {
+            gp = renderSimpleGlyph((GlyfSimple) g);
+        } else if (g instanceof GlyfCompound) {
+            gp = renderCompoundGlyph(glyf, (GlyfCompound) g);
+        } else {
+            gp = new Path();
+        }
+
+        // calculate the advance
+        HmtxTable hmtx = (HmtxTable) font.getTable("hmtx");
+        float advance = (float) hmtx.getAdvance(glyphId) / (float) unitsPerEm;
+
+        // scale the glyph to match the desired advance
+        float widthfactor = width / advance;
+
+        // the base transform scales the glyph to 1x1
+        Matrix at = new Matrix();
+        at.setScale(1 / unitsPerEm, 1 / unitsPerEm);
+        Matrix tmp = new Matrix();
+        tmp.setScale(widthfactor, 1);
+        at.preConcat(tmp);
+
+        gp.transform(at);
+
+        return gp;
+    }
+
+    /**
+     * Render a simple glyf
+     */
+    protected Path renderSimpleGlyph(GlyfSimple g) {
+        // the current contour
+        int curContour = 0;
+
+        // the render state
+        RenderState rs = new RenderState();
+        rs.gp = new Path();
+
+        for (int i = 0; i < g.getNumPoints(); i++) {
+            PointRec rec = new PointRec(g, i);
+
+            if (rec.onCurve) {
+                addOnCurvePoint(rec, rs);
+            } else {
+                addOffCurvePoint(rec, rs);
+            }
+
+            // see if we just ended a contour
+            if (i == g.getContourEndPoint(curContour)) {
+                curContour++;
+
+                if (rs.firstOff != null) {
+                    addOffCurvePoint(rs.firstOff, rs);
+                }
+
+                if (rs.firstOn != null) {
+                    addOnCurvePoint(rs.firstOn, rs);
+                }
+
+                rs.firstOn = null;
+                rs.firstOff = null;
+                rs.prevOff = null;
+            }
+        }
+
+        return rs.gp;
+    }
+
+    /**
+     * Render a compound glyf
+     */
+    protected Path renderCompoundGlyph(GlyfTable glyf, GlyfCompound g) {
+        Path gp = new Path();
+
+        for (int i = 0; i < g.getNumComponents(); i++) {
+            // find and render the component glyf
+            GlyfSimple gs = (GlyfSimple) glyf.getGlyph(g.getGlyphIndex(i));
+            Path path = renderSimpleGlyph(gs);
+
+            // multiply the translations by units per em
+            float[] matrix = g.getTransform(i);
+
+            // transform and add path to the global path
+            Matrix mat = new Matrix();
+            Utils.setMatValues(mat, matrix);
+            gp.addPath(path, mat);
+        }
+
+        return gp;
+    }
+
+    /** add a point on the curve */
+    private void addOnCurvePoint(PointRec rec, RenderState rs) {
+        // if the point is on the curve, either move to it,
+        // or draw a line from the previous point
+        if (rs.firstOn == null) {
+            rs.firstOn = rec;
+            rs.gp.moveTo(rec.x, rec.y);
+        } else if (rs.prevOff != null) {
+            rs.gp.quadTo(rs.prevOff.x, rs.prevOff.y, rec.x, rec.y);
+            rs.prevOff = null;
+        } else {
+            rs.gp.lineTo(rec.x, rec.y);
+        }
+    }
+
+    /** add a point off the curve */
+    private void addOffCurvePoint(PointRec rec, RenderState rs) {
+        if (rs.prevOff != null) {
+            PointRec oc = new PointRec((rec.x + rs.prevOff.x) / 2,
+                    (rec.y + rs.prevOff.y) / 2,
+                    true);
+            addOnCurvePoint(oc, rs);
+        } else if (rs.firstOn == null) {
+            rs.firstOff = rec;
+        }
+        rs.prevOff = rec;
+    }
+
+    class RenderState {
+        // the shape itself
+        Path gp;
+        // the first off and on-curve points in the current segment
+        PointRec firstOn;
+        PointRec firstOff;
+        // the previous off and on-curve points in the current segment
+        PointRec prevOff;
+    }
+
+    /** a point on the stack of points */
+    class PointRec {
+
+        int x;
+        int y;
+        boolean onCurve;
+
+        public PointRec(int x, int y, boolean onCurve) {
+            this.x = x;
+            this.y = y;
+            this.onCurve = onCurve;
+        }
+
+        public PointRec(GlyfSimple g, int idx) {
+            x = g.getXCoord(idx);
+            y = g.getYCoord(idx);
+            onCurve = g.onCurve(idx);
+        }
+    }
+}

src/com/sun/pdfview/font/Type0Font.java

@@ -0,0 +1,68 @@
+/*
+ * $Id: Type0Font.java,v 1.2 2007/12/20 18:33:32 rbair Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package com.sun.pdfview.font;
+
+import java.io.IOException;
+
+import com.sun.pdfview.PDFObject;
+
+/**
+ * Type 0 fonts are composite fonts with a CMAP to map between
+ * source character codes and destination fonts/codes
+ *
+ * @author  Jonathan Kaplan
+ */
+public class Type0Font extends PDFFont {
+   
+    /**
+     * The decendant fonts, indexed by font number from the CMAP
+     */
+    PDFFont[] fonts;
+        
+    /** Creates a new instance of Type0Font */
+    public Type0Font(String baseFont, PDFObject fontObj,
+                     PDFFontDescriptor descriptor) throws IOException {
+        super (baseFont, descriptor);
+                         
+        PDFObject[] descendantFonts = fontObj.getDictRef("DescendantFonts").getArray();
+        
+        fonts = new PDFFont[descendantFonts.length];
+        
+        for (int i = 0; i < descendantFonts.length; i++) {
+            fonts[i] = PDFFont.getFont(descendantFonts[i], null);
+        }
+    }
+    
+    /** 
+     * Get a descendant font of this font by fontId
+     */
+    public PDFFont getDescendantFont(int fontID) {
+        return fonts[fontID];
+    }
+    
+    /**
+     * Get a character from the first font in the descendant fonts array
+     */
+    protected PDFGlyph getGlyph(char src, String name) {
+        return (getDescendantFont(0).getGlyph(src, name));
+    }
+}

src/com/sun/pdfview/font/Type1CFont.java

@@ -0,0 +1,1198 @@
+/*
+ * $Id: Type1CFont.java,v 1.3 2009/03/09 10:18:03 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview.font;
+
+import java.io.IOException;
+
+import net.sf.andpdf.utils.Utils;
+
+import android.graphics.Matrix;
+import android.graphics.Path;
+
+import com.sun.pdfview.PDFObject;
+
+
+/**
+ * A representation, with parser, of an Adobe Type 1C font.
+ * @author Mike Wessler
+ */
+public class Type1CFont extends OutlineFont {
+
+    String chr2name[] = new String[256];
+
+    byte[] data;
+
+    int pos;
+
+    byte[] subrs;
+
+    float[] stack = new float[100];
+
+    int stackptr = 0;
+
+    String names[];
+
+    int glyphnames[];
+
+    int encoding[] = new int[256];
+
+    String fontname;
+
+    Matrix at = Utils.createMatrix(0.001f, 0, 0, 0.001f, 0, 0);
+
+    int num;
+
+    float fnum;
+
+    int type;
+
+    static int CMD = 0;
+
+    static int NUM = 1;
+
+    static int FLT = 2;
+
+    /**
+     * create a new Type1CFont based on a font data stream and a descriptor
+     * @param baseFont the postscript name of this font
+     * @param src a stream containing the font
+     * @param descriptor the descriptor for this font
+     */
+    public Type1CFont (String baseFont, PDFObject src,
+                       PDFFontDescriptor descriptor) throws IOException {
+        super (baseFont, src, descriptor);
+
+        PDFObject dataObj = descriptor.getFontFile3 ();
+        data = dataObj.getStream ();
+        pos = 0;
+        parse ();
+
+        // TODO: free up (set to null) unused structures (data, subrs, stack)
+    }
+
+    /**
+     * a debug method for printing the data
+     */
+    private void printData () {
+        char[] parts = new char[17];
+        int partsloc = 0;
+        for (int i = 0; i < data.length; i++) {
+            int d = ((int) data[i]) & 0xff;
+            if (d == 0) {
+                parts[partsloc++] = '.';
+            } else if (d < 32 || d >= 127) {
+                parts[partsloc++] = '?';
+            } else {
+                parts[partsloc++] = (char) d;
+            }
+            if (d < 16) {
+                System.out.print ("0" + Integer.toHexString (d));
+            } else {
+                System.out.print (Integer.toHexString (d));
+            }
+            if ((i & 15) == 15) {
+                System.out.println ("      " + new String (parts));
+                partsloc = 0;
+            } else if ((i & 7) == 7) {
+                System.out.print ("  ");
+                parts[partsloc++] = ' ';
+            } else if ((i & 1) == 1) {
+                System.out.print (" ");
+            }
+        }
+        System.out.println ();
+    }
+
+    /**
+     * read the next decoded value from the stream
+     * @param charstring ????
+     */
+    private int readNext (boolean charstring) {
+        num = (int) (data[pos++]) & 0xff;
+        if (num == 30 && !charstring) { // goofy floatingpoint rep
+            readFNum ();
+            return type = FLT;
+        } else if (num == 28) {
+            num = (((int) data[pos]) << 8) + (((int) data[pos + 1]) & 0xff);
+            pos += 2;
+            return type = NUM;
+        } else if (num == 29 && !charstring) {
+            num = (((int) data[pos] & 0xff) << 24) |
+                    (((int) data[pos + 1] & 0xff) << 16) |
+                    (((int) data[pos + 2] & 0xff) << 8) |
+                    (((int) data[pos + 3] & 0xff));
+            pos += 4;
+            return type = NUM;
+        } else if (num == 12) {  // two-byte command
+            num = 1000 + ((int) (data[pos++]) & 0xff);
+            return type = CMD;
+        } else if (num < 32) {
+            return type = CMD;
+        } else if (num < 247) {
+            num -= 139;
+            return type = NUM;
+        } else if (num < 251) {
+            num = (num - 247) * 256 + (((int) data[pos++]) & 0xff) + 108;
+            return type = NUM;
+        } else if (num < 255) {
+            num = -(num - 251) * 256 - (((int) data[pos++]) & 0xff) - 108;
+            return type = NUM;
+        } else if (!charstring) { // dict shouldn't have a 255 code
+            printData ();
+            throw new RuntimeException ("Got a 255 code while reading dict");
+        } else { // num was 255
+            fnum = ((((int) data[pos] & 0xff) << 24) |
+                    (((int) data[pos + 1] & 0xff) << 16) |
+                    (((int) data[pos + 2] & 0xff) << 8) |
+                    (((int) data[pos + 3] & 0xff))) / 65536f;
+            pos += 4;
+            return type = FLT;
+        }
+    }
+
+    /**
+     * read the next funky floating point number from the input stream.
+     * value gets put into the fnum field.
+     */
+    public void readFNum () {
+        // work in nybbles: 0-9=0-9, a=. b=E, c=E-, d=rsvd e=neg f=end
+        float f = 0;
+        boolean neg = false;
+        int exp = 0;
+        int eval = 0;
+        float mul = 1;
+        byte work = data[pos++];
+        while (true) {
+            if (work == (byte) 0xdd) {
+                work = data[pos++];
+            }
+            int nyb = (work >> 4) & 0xf;
+            work = (byte) ((work << 4) | 0xd);
+            if (nyb < 10) {
+                if (exp != 0) {         // working on the exponent
+                    eval = eval * 10 + nyb;
+                } else if (mul == 1) {  // working on an int
+                    f = f * 10 + nyb;
+                } else {              // working on decimal part
+                    f += nyb * mul;
+                    mul /= 10f;
+                }
+            } else if (nyb == 0xa) {    // decimal
+                mul = 0.1f;
+            } else if (nyb == 0xb) {    // E+
+                exp = 1;
+            } else if (nyb == 0xc) {    // E-
+                exp = -1;
+            } else if (nyb == 0xe) {      // neg
+                neg = true;
+            } else {
+                break;
+            }
+        }
+        fnum = (neg ? -1 : 1) * f * (float) Math.pow (10, eval * exp);
+    }
+
+    /**
+     * read an integer from the input stream
+     * @param len the number of bytes in the integer
+     * @return the integer
+     */
+    private int readInt (int len) {
+        int n = 0;
+        for (int i = 0; i < len; i++) {
+            n = (n << 8) | (((int) data[pos++]) & 0xff);
+        }
+        return n;
+    }
+
+    /**
+     * read the next byte from the stream
+     * @return the byte
+     */
+    private int readByte () {
+        return ((int) data[pos++]) & 0xff;
+    }
+
+    // DICT structure:
+    // operand operator operand operator ...
+    // INDEX structure:
+    // count(2) offsize [offset offset ... offset] data
+    // offset array has count+1 entries
+    // data starts at 3+(count+1)*offsize
+    // offset for data is offset+2+(count+1)*offsize
+    /**
+     * get the size of the dictionary located within the stream at
+     * some offset.
+     * @param loc the index of the start of the dictionary
+     * @return the size of the dictionary, in bytes.
+     */
+    public int getIndexSize (int loc) {
+        //	System.out.println("Getting size of index at "+loc);
+        int hold = pos;
+        pos = loc;
+        int count = readInt (2);
+        if (count <= 0) {
+            return 2;
+        }
+        int encsz = readByte ();
+        if (encsz < 1 || encsz > 4) {
+            throw new RuntimeException ("Offsize: " + encsz +
+                    ", must be in range 1-4.");
+        }
+        // pos is now at the first offset.  last offset is at count*encsz
+        pos += count * encsz;
+        int end = readInt (encsz);
+        pos = hold;
+        return 2 + (count + 1) * encsz + end;
+    }
+
+    /**
+     * return the number of entries in an Index table.
+     *
+     * @param loc
+     * @return
+     */
+    public int getTableLength (int loc) {
+        int hold = pos;
+        pos = loc;
+        int count = readInt (2);
+        if (count <= 0) {
+            return 2;
+        }
+        pos = hold;
+        return count;
+    }
+
+    /**
+     * A range.  There's probably a version of this class floating around
+     * somewhere already in Java.
+     */
+    class Range {
+
+        private int start;
+
+        private int len;
+
+        public Range (int start, int len) {
+            this.start = start;
+            this.len = len;
+        }
+
+        public final int getStart () {
+            return start;
+        }
+
+        public final int getLen () {
+            return len;
+        }
+
+        public final int getEnd () {
+            return start + len;
+        }
+
+        public String toString () {
+            return "Range: start: " + start + ", len: " + len;
+        }
+    }
+
+    /**
+     * Get the range of a particular index in a dictionary.
+     * @param index the start of the dictionary.
+     * @param id the index of the entry in the dictionary
+     * @return a range describing the offsets of the start and end of
+     * the entry from the start of the file, not the dictionary
+     */
+    Range getIndexEntry (int index, int id) {
+        int hold = pos;
+        pos = index;
+        int count = readInt (2);
+        int encsz = readByte ();
+        if (encsz < 1 || encsz > 4) {
+            throw new RuntimeException ("Offsize: " + encsz +
+                    ", must be in range 1-4.");
+        }
+        pos += encsz * id;
+        int from = readInt (encsz);
+        Range r = new Range (from + 2 + index + encsz * (count + 1), readInt (
+                encsz) - from);
+        pos = hold;
+        return r;
+    }
+    // Top DICT: NAME    CODE   DEFAULT
+    // charstringtype    12 6    2
+    // fontmatrix        12 7    0.001 0 0 0.001
+    // charset           15      - (offset)  names of glyphs (ref to name idx)
+    // encoding          16      - (offset)  array of codes
+    // CharStrings       17      - (offset)
+    // Private           18      - (size, offset)
+    // glyph at position i in CharStrings has name charset[i]
+    // and code encoding[i]
+    int charstringtype = 2;
+
+    float temps[] = new float[32];
+
+    int charsetbase = 0;
+
+    int encodingbase = 0;
+
+    int charstringbase = 0;
+
+    int privatebase = 0;
+
+    int privatesize = 0;
+
+    int gsubrbase = 0;
+
+    int lsubrbase = 0;
+
+    int gsubrsoffset = 0;
+
+    int lsubrsoffset = 0;
+
+    int nglyphs = 1;
+
+    /**
+     * read a dictionary that exists within some range, parsing the entries
+     * within the dictionary.
+     */
+    private void readDict (Range r) {
+        //	System.out.println("reading dictionary from "+r.getStart()+" to "+r.getEnd());
+        pos = r.getStart ();
+        while (pos < r.getEnd ()) {
+            int cmd = readCommand (false);
+            if (cmd == 1006) { // charstringtype, default=2
+                charstringtype = (int) stack[0];
+            } else if (cmd == 1007) { // fontmatrix
+                if (stackptr == 4) {
+                    at = Utils.createMatrix((float) stack[0], (float) stack[1],
+                            (float) stack[2], (float) stack[3],
+                            0, 0);
+                } else {
+                    at = Utils.createMatrix((float) stack[0], (float) stack[1],
+                            (float) stack[2], (float) stack[3],
+                            (float) stack[4], (float) stack[5]);
+                }
+            } else if (cmd == 15) { // charset
+                charsetbase = (int) stack[0];
+            } else if (cmd == 16) { // encoding
+                encodingbase = (int) stack[0];
+            } else if (cmd == 17) { // charstrings
+                charstringbase = (int) stack[0];
+            } else if (cmd == 18) { // private
+                privatesize = (int) stack[0];
+                privatebase = (int) stack[1];
+            } else if (cmd == 19) { // subrs (in Private dict)
+                lsubrbase = privatebase + (int) stack[0];
+                lsubrsoffset = calcoffset (lsubrbase);
+            }
+            stackptr = 0;
+        }
+    }
+
+    /**
+     * read a complete command.  this may involve several numbers
+     * which go onto a stack before an actual command is read.
+     * @param charstring ????
+     * @return the command.  Some numbers may also be on the stack.
+     */
+    private int readCommand (boolean charstring) {
+        while (true) {
+            int t = readNext (charstring);
+            if (t == CMD) {
+                /*
+                System.out.print("CMD= "+num+", args=");
+                for (int i=0; i<stackptr; i++) {
+                System.out.print(" "+stack[i]);
+                }
+                System.out.println();
+                 */
+                return num;
+            } else {
+                stack[stackptr++] = (t == NUM) ? (float) num : fnum;
+            }
+        }
+    }
+
+    /**
+     * parse information about the encoding of this file.
+     * @param base the start of the encoding data
+     */
+    private void readEncodingData (int base) {
+        if (base == 0) {  // this is the StandardEncoding
+            //	    System.out.println("**** STANDARD ENCODING!");
+            System.arraycopy (FontSupport.standardEncoding, 0, encoding, 0,
+                    FontSupport.standardEncoding.length);
+        } else if (base == 1) {  // this is the expert encoding
+            System.out.println ("**** EXPERT ENCODING!");
+            // TODO: copy ExpertEncoding
+        } else {
+            pos = base;
+            int encodingtype = readByte ();
+            if ((encodingtype & 127) == 0) {
+                int ncodes = readByte ();
+                for (int i = 1; i < ncodes + 1; i++) {
+                    int idx = readByte () & 0xff;
+                    encoding[idx] = i;
+                }
+            } else if ((encodingtype & 127) == 1) {
+                int nranges = readByte ();
+                int p = 1;
+                for (int i = 0; i < nranges; i++) {
+                    int start = readByte ();
+                    int more = readByte ();
+                    for (int j = start; j < start + more + 1; j++) {
+                        encoding[j] = p++;
+                    }
+                }
+            } else {
+                System.out.println ("Bad encoding type: " + encodingtype);
+            }
+            // TODO: now check for supplemental encoding data
+        }
+    }
+
+    /**
+     * read the names of the glyphs.
+     * @param base the start of the glyph name table
+     */
+    private void readGlyphNames (int base) {
+        if (base == 0) {
+            glyphnames = new int[229];
+            for (int i = 0; i < glyphnames.length; i++) {
+                glyphnames[i] = i;
+            }
+            return;
+        } else if (base == 1) {
+            glyphnames = FontSupport.type1CExpertCharset;
+            return;
+        } else if (base == 2) {
+            glyphnames = FontSupport.type1CExpertSubCharset;
+            return;
+        }
+        // nglyphs has already been set.
+        glyphnames = new int[nglyphs];
+        glyphnames[0] = 0;
+        pos = base;
+        int t = readByte ();
+        if (t == 0) {
+            for (int i = 1; i < nglyphs; i++) {
+                glyphnames[i] = readInt (2);
+            }
+        } else if (t == 1) {
+            int n = 1;
+            while (n < nglyphs) {
+                int sid = readInt (2);
+                int range = readByte () + 1;
+                for (int i = 0; i < range; i++) {
+                    glyphnames[n++] = sid++;
+                }
+            }
+        } else if (t == 2) {
+            int n = 1;
+            while (n < nglyphs) {
+                int sid = readInt (2);
+                int range = readInt (2) + 1;
+                for (int i = 0; i < range; i++) {
+                    glyphnames[n++] = sid++;
+                }
+            }
+        }
+    }
+
+    /**
+     * read a list of names
+     * @param base the start of the name table
+     */
+    private void readNames (int base) {
+        pos = base;
+        int nextra = readInt (2);
+        names = new String[nextra];
+        //	safenames= new String[nextra];
+        for (int i = 0; i < nextra; i++) {
+            Range r = getIndexEntry (base, i);
+            names[i] = new String (data, r.getStart (), r.getLen ());
+            //	    System.out.println("Read name: "+i+" from "+r.getStart()+" to "+r.getEnd()+": "+safe(names[i]));
+        }
+    }
+
+    /**
+     * parse the font data.
+     * @param encdif a dictionary describing the encoding.
+     */
+    private void parse () throws IOException {
+        int majorVersion = readByte ();
+        int minorVersion = readByte ();
+        int hdrsz = readByte ();
+        int offsize = readByte ();
+        // jump over rest of header: base of font names index
+        int fnames = hdrsz;
+        // offset in the file of the array of font dicts
+        int topdicts = fnames + getIndexSize (fnames);
+        // offset in the file of local names
+        int theNames = topdicts + getIndexSize (topdicts);
+        // offset in the file of the array of global subroutines
+        gsubrbase = theNames + getIndexSize (theNames);
+        gsubrsoffset = calcoffset (gsubrbase);
+        // read extra names
+        readNames (theNames);
+        // does this file have more than one font?
+        pos = topdicts;
+        if (readInt (2) != 1) {
+            printData ();
+            throw new RuntimeException ("More than one font in this file!");
+        }
+        Range r = getIndexEntry (fnames, 0);
+        fontname = new String (data, r.getStart (), r.getLen ());
+        // read first dict
+        //	System.out.println("TOPDICT[0]:");
+        readDict (getIndexEntry (topdicts, 0));
+        // read the private dictionary
+        //	System.out.println("PRIVATE DICT:");
+        readDict (new Range (privatebase, privatesize));
+        // calculate the number of glyphs
+        pos = charstringbase;
+        nglyphs = readInt (2);
+        // now get the glyph names
+        //	System.out.println("GLYPHNAMES:");
+        readGlyphNames (charsetbase);
+        // now figure out the encoding
+        //	System.out.println("ENCODING:");
+        readEncodingData (encodingbase);
+    }
+
+    /**
+     * get the index of a particular name.  The name table starts with
+     * the standard names in FontSupport.stdNames, and is appended by
+     * any names in the name table from this font's dictionary.
+     */
+    private int getNameIndex (String name) {
+        int val = FontSupport.findName (name, FontSupport.stdNames);
+        if (val == -1) {
+            val = FontSupport.findName (name, names) + FontSupport.stdNames.length;
+        }
+        if (val == -1) {
+            val = 0;
+        }
+        return val;
+    }
+
+    /**
+     * convert a string to one in which any non-printable bytes are
+     * replaced by "<###>" where ## is the value of the byte.
+     */
+    private String safe (String src) {
+        StringBuffer sb = new StringBuffer ();
+        for (int i = 0; i < src.length (); i++) {
+            char c = src.charAt (i);
+            if (c >= 32 && c < 128) {
+                sb.append (c);
+            } else {
+                sb.append ("<" + (int) c + ">");
+            }
+        }
+        return sb.toString ();
+    }
+
+    /**
+     * Read the data for a glyph from the glyph table, and transform
+     * it based on the current transform.
+     *
+     * @param base the start of the glyph table
+     * @param offset the index of this glyph in the glyph table
+     */
+    private synchronized Path readGlyph (int base, int offset) {
+        FlPoint pt = new FlPoint ();
+
+        // find this entry
+        Range r = getIndexEntry (base, offset);
+
+        // create a path
+        Path gp = new Path ();
+
+
+        // rember the start position (for recursive calls due to seac)
+        int hold = pos;
+
+        // read the glyph itself
+        stackptr = 0;
+        parseGlyph (r, gp, pt);
+
+        // restore the start position
+        pos = hold;
+
+        gp.transform (at);
+
+        return gp;
+    }
+
+    /**
+     * calculate an offset code for a dictionary. Uses the count of entries
+     * to determine what the offset should be.
+     *
+     * @param base the index of the start of the dictionary
+     */
+    public int calcoffset (int base) {
+        int len = getTableLength (base);
+        if (len < 1240) {
+            return 107;
+        } else if (len < 33900) {
+            return 1131;
+        } else {
+            return 32768;
+        }
+    }
+
+    /**
+     * get the name associated with an ID.
+     * @param id the index of the name
+     * @return the name from the FontSupport.stdNames table augmented
+     * by the local name table
+     */
+    public String getSID (int id) {
+        if (id < FontSupport.stdNames.length) {
+            return FontSupport.stdNames[id];
+        } else {
+            id -= FontSupport.stdNames.length;
+            return names[id];
+        }
+    }
+
+    /**
+     * build an accented character out of two pre-defined glyphs.
+     * @param x the x offset of the accent
+     * @param y the y offset of the accent
+     * @param b the index of the base glyph
+     * @param a the index of the accent glyph
+     * @param gp the GeneralPath into which the combined glyph will be
+     * written.
+     */
+    private void buildAccentChar (float x, float y, char b, char a,
+                                  Path gp) {
+        // get the outline of the accent
+        Path pathA = getOutline (a, getWidth (a, null));
+
+        // undo the effect of the transform applied in read 
+        Matrix xformA = new Matrix();
+        xformA.setTranslate(x, y);
+        Matrix tmp = new Matrix(at);
+        if (tmp.invert(at)) {
+        	xformA.preConcat(tmp);
+        }
+        else {
+	        // oh well ...
+	    }
+        pathA.transform (xformA);
+
+        Path pathB = getOutline (b, getWidth (b, null));
+
+        Matrix xformB = new Matrix();
+        if (xformB.invert(at)) {
+            pathB.transform(xformB);
+        } else {
+            // ignore
+        }
+
+        gp.addPath(pathB);
+        gp.addPath(pathA);
+    }
+
+    /**
+     * parse a glyph defined in a particular range
+     * @param r the range of the glyph definition
+     * @param gp a GeneralPath in which to store the glyph outline
+     * @param pt a FlPoint representing the end of the current path
+     */
+    void parseGlyph (Range r, Path gp, FlPoint pt) {
+        pos = r.getStart ();
+        int i;
+        float x1, y1, x2, y2, x3, y3, ybase;
+        int hold;
+        int stemhints = 0;
+        while (pos < r.getEnd ()) {
+            int cmd = readCommand (true);
+            hold = 0;
+            switch (cmd) {
+                case 1: // hstem
+                case 3: // vstem
+                    stackptr = 0;
+                    break;
+                case 4: // vmoveto
+                    if (stackptr > 1) {  // this is the first call, arg1 is width
+                        stack[0] = stack[1];
+                    }
+                    pt.y += stack[0];
+                    if (pt.open) {
+                        gp.close();
+                    }
+                    pt.open = false;
+                    gp.moveTo (pt.x, pt.y);
+                    stackptr = 0;
+                    break;
+                case 5: // rlineto
+                    for (i = 0; i < stackptr;) {
+                        pt.x += stack[i++];
+                        pt.y += stack[i++];
+                        gp.lineTo (pt.x, pt.y);
+                    }
+                    pt.open = true;
+                    stackptr = 0;
+                    break;
+                case 6: // hlineto
+                    for (i = 0; i < stackptr;) {
+                        if ((i & 1) == 0) {
+                            pt.x += stack[i++];
+                        } else {
+                            pt.y += stack[i++];
+                        }
+                        gp.lineTo (pt.x, pt.y);
+                    }
+                    pt.open = true;
+                    stackptr = 0;
+                    break;
+                case 7: // vlineto
+                    for (i = 0; i < stackptr;) {
+                        if ((i & 1) == 0) {
+                            pt.y += stack[i++];
+                        } else {
+                            pt.x += stack[i++];
+                        }
+                        gp.lineTo (pt.x, pt.y);
+                    }
+                    pt.open = true;
+                    stackptr = 0;
+                    break;
+                case 8: // rrcurveto
+                    for (i = 0; i < stackptr;) {
+                        x1 = pt.x + stack[i++];
+                        y1 = pt.y + stack[i++];
+                        x2 = x1 + stack[i++];
+                        y2 = y1 + stack[i++];
+                        pt.x = x2 + stack[i++];
+                        pt.y = y2 + stack[i++];
+                        gp.cubicTo(x1, y1, x2, y2, pt.x, pt.y);
+                    }
+                    pt.open = true;
+                    stackptr = 0;
+                    break;
+                case 10: // callsubr
+                    hold = pos;
+                    i = (int) stack[--stackptr] + lsubrsoffset;
+                    Range lsubr = getIndexEntry (lsubrbase, i);
+                    parseGlyph (lsubr, gp, pt);
+                    pos = hold;
+                    break;
+                case 11: // return
+                    return;
+                case 14: // endchar
+                    // width x y achar bchar endchar == x y achar bchar seac
+                    if (stackptr == 5) {
+                        buildAccentChar (stack[1], stack[2], (char) stack[3],
+                                (char) stack[4], gp);
+                    }
+                    if (pt.open) {
+                        gp.close();
+                    }
+                    pt.open = false;
+                    stackptr = 0;
+                    break;
+                case 18: // hstemhm
+                    stemhints += stackptr / 2;
+                    stackptr = 0;
+                    break;
+                case 19: // hintmask
+                case 20: // cntrmask
+                    stemhints += stackptr / 2;
+                    pos += (stemhints - 1) / 8 + 1;
+                    stackptr = 0;
+                    break;
+                case 21: // rmoveto
+                    if (stackptr > 2) {
+                        stack[0] = stack[1];
+                        stack[1] = stack[2];
+                    }
+                    pt.x += stack[0];
+                    pt.y += stack[1];
+                    if (pt.open) {
+                        gp.close();
+                    }
+                    gp.moveTo (pt.x, pt.y);
+                    pt.open = false;
+                    stackptr = 0;
+                    break;
+                case 22: // hmoveto
+                    if (stackptr > 1) {
+                        stack[0] = stack[1];
+                    }
+                    pt.x += stack[0];
+                    if (pt.open) {
+                        gp.close();
+                    }
+                    gp.moveTo (pt.x, pt.y);
+                    pt.open = false;
+                    stackptr = 0;
+                    break;
+                case 23: // vstemhm
+                    stemhints += stackptr / 2;
+                    stackptr = 0;
+                    break;
+                case 24: // rcurveline
+                    for (i = 0; i < stackptr - 2;) {
+                        x1 = pt.x + stack[i++];
+                        y1 = pt.y + stack[i++];
+                        x2 = x1 + stack[i++];
+                        y2 = y1 + stack[i++];
+                        pt.x = x2 + stack[i++];
+                        pt.y = y2 + stack[i++];
+                        gp.cubicTo(x1, y1, x2, y2, pt.x, pt.y);
+                    }
+                    pt.x += stack[i++];
+                    pt.y += stack[i++];
+                    gp.lineTo (pt.x, pt.y);
+                    pt.open = true;
+                    stackptr = 0;
+                    break;
+                case 25: // rlinecurve
+                    for (i = 0; i < stackptr - 6;) {
+                        pt.x += stack[i++];
+                        pt.y += stack[i++];
+                        gp.lineTo (pt.x, pt.y);
+                    }
+                    x1 = pt.x + stack[i++];
+                    y1 = pt.y + stack[i++];
+                    x2 = x1 + stack[i++];
+                    y2 = y1 + stack[i++];
+                    pt.x = x2 + stack[i++];
+                    pt.y = y2 + stack[i++];
+                    gp.cubicTo(x1, y1, x2, y2, pt.x, pt.y);
+                    pt.open = true;
+                    stackptr = 0;
+                    break;
+                case 26: // vvcurveto
+                    i = 0;
+                    if ((stackptr & 1) == 1) { // odd number of arguments
+                        pt.x += stack[i++];
+                    }
+                    while (i < stackptr) {
+                        x1 = pt.x;
+                        y1 = pt.y + stack[i++];
+                        x2 = x1 + stack[i++];
+                        y2 = y1 + stack[i++];
+                        pt.x = x2;
+                        pt.y = y2 + stack[i++];
+                        gp.cubicTo(x1, y1, x2, y2, pt.x, pt.y);
+                    }
+                    pt.open = true;
+                    stackptr = 0;
+                    break;
+                case 27: // hhcurveto
+                    i = 0;
+                    if ((stackptr & 1) == 1) { // odd number of arguments
+                        pt.y += stack[i++];
+                    }
+                    while (i < stackptr) {
+                        x1 = pt.x + stack[i++];
+                        y1 = pt.y;
+                        x2 = x1 + stack[i++];
+                        y2 = y1 + stack[i++];
+                        pt.x = x2 + stack[i++];
+                        pt.y = y2;
+                        gp.cubicTo(x1, y1, x2, y2, pt.x, pt.y);
+                    }
+                    pt.open = true;
+                    stackptr = 0;
+                    break;
+                case 29: // callgsubr
+                    hold = pos;
+                    i = (int) stack[--stackptr] + gsubrsoffset;
+                    Range gsubr = getIndexEntry (gsubrbase, i);
+                    parseGlyph (gsubr, gp, pt);
+                    pos = hold;
+                    break;
+                case 30: // vhcurveto
+                    hold = 4;
+                case 31: // hvcurveto
+                    for (i = 0; i < stackptr;) {
+                        boolean hv = (((i + hold) & 4) == 0);
+                        x1 = pt.x + (hv ? stack[i++] : 0);
+                        y1 = pt.y + (hv ? 0 : stack[i++]);
+                        x2 = x1 + stack[i++];
+                        y2 = y1 + stack[i++];
+                        pt.x = x2 + (hv ? 0 : stack[i++]);
+                        pt.y = y2 + (hv ? stack[i++] : 0);
+                        if (i == stackptr - 1) {
+                            if (hv) {
+                                pt.x += stack[i++];
+                            } else {
+                                pt.y += stack[i++];
+                            }
+                        }
+                        gp.cubicTo(x1, y1, x2, y2, pt.x, pt.y);
+                    }
+                    pt.open = true;
+                    stackptr = 0;
+                    break;
+                case 1000: // old dotsection command.  ignore.
+                    stackptr = 0;
+                    break;
+                case 1003: // and
+                    x1 = stack[--stackptr];
+                    y1 = stack[--stackptr];
+                    stack[stackptr++] = ((x1 != 0) && (y1 != 0)) ? 1 : 0;
+                    break;
+                case 1004: // or
+                    x1 = stack[--stackptr];
+                    y1 = stack[--stackptr];
+                    stack[stackptr++] = ((x1 != 0) || (y1 != 0)) ? 1 : 0;
+                    break;
+                case 1005: // not
+                    x1 = stack[--stackptr];
+                    stack[stackptr++] = (x1 == 0) ? 1 : 0;
+                    break;
+                case 1009: // abs
+                    stack[stackptr - 1] = Math.abs (stack[stackptr - 1]);
+                    break;
+                case 1010: // add
+                    x1 = stack[--stackptr];
+                    y1 = stack[--stackptr];
+                    stack[stackptr++] = x1 + y1;
+                    break;
+                case 1011: // sub
+                    x1 = stack[--stackptr];
+                    y1 = stack[--stackptr];
+                    stack[stackptr++] = y1 - x1;
+                    break;
+                case 1012: // div
+                    x1 = stack[--stackptr];
+                    y1 = stack[--stackptr];
+                    stack[stackptr++] = y1 / x1;
+                    break;
+                case 1014: // neg
+                    stack[stackptr - 1] = -stack[stackptr - 1];
+                    break;
+                case 1015: // eq
+                    x1 = stack[--stackptr];
+                    y1 = stack[--stackptr];
+                    stack[stackptr++] = (x1 == y1) ? 1 : 0;
+                    break;
+                case 1018: // drop
+                    stackptr--;
+                    break;
+                case 1020: // put
+                    i = (int) stack[--stackptr];
+                    x1 = stack[--stackptr];
+                    temps[i] = x1;
+                    break;
+                case 1021: // get
+                    i = (int) stack[--stackptr];
+                    stack[stackptr++] = temps[i];
+                    break;
+                case 1022: // ifelse
+                    if (stack[stackptr - 2] > stack[stackptr - 1]) {
+                        stack[stackptr - 4] = stack[stackptr - 3];
+                    }
+                    stackptr -= 3;
+                    break;
+                case 1023: // random
+                    stack[stackptr++] = (float) Math.random ();
+                    break;
+                case 1024: // mul
+                    x1 = stack[--stackptr];
+                    y1 = stack[--stackptr];
+                    stack[stackptr++] = y1 * x1;
+                    break;
+                case 1026: // sqrt
+                    stack[stackptr - 1] = (float) Math.sqrt (stack[stackptr - 1]);
+                    break;
+                case 1027: // dup
+                    x1 = stack[stackptr - 1];
+                    stack[stackptr++] = x1;
+                    break;
+                case 1028: // exch
+                    x1 = stack[stackptr - 1];
+                    stack[stackptr - 1] = stack[stackptr - 2];
+                    stack[stackptr - 2] = x1;
+                    break;
+                case 1029: // index
+                    i = (int) stack[stackptr - 1];
+                    if (i < 0) {
+                        i = 0;
+                    }
+                    stack[stackptr - 1] = stack[stackptr - 2 - i];
+                    break;
+                case 1030: // roll
+                    i = (int) stack[--stackptr];
+                    int n = (int) stack[--stackptr];
+                    // roll n number by i (+ = upward)
+                    if (i > 0) {
+                        i = i % n;
+                    } else {
+                        i = n - (-i % n);
+                    }
+                    // x x x x i y y y -> y y y x x x x i (where i=3)
+                    if (i > 0) {
+                        float roll[] = new float[n];
+                        System.arraycopy (stack, stackptr - 1 - i, roll, 0, i);
+                        System.arraycopy (stack, stackptr - 1 - n, roll, i,
+                                n - i);
+                        System.arraycopy (roll, 0, stack, stackptr - 1 - n, n);
+                    }
+                    break;
+                case 1034: // hflex
+                    x1 = pt.x + stack[0];
+                    y1 = ybase = pt.y;
+                    x2 = x1 + stack[1];
+                    y2 = y1 + stack[2];
+                    pt.x = x2 + stack[3];
+                    pt.y = y2;
+                    gp.cubicTo(x1, y1, x2, y2, pt.x, pt.y);
+                    x1 = pt.x + stack[4];
+                    y1 = pt.y;
+                    x2 = x1 + stack[5];
+                    y2 = ybase;
+                    pt.x = x2 + stack[6];
+                    pt.y = y2;
+                    gp.cubicTo(x1, y1, x2, y2, pt.x, pt.y);
+                    pt.open = true;
+                    stackptr = 0;
+                    break;
+                case 1035: // flex
+                    x1 = pt.x + stack[0];
+                    y1 = pt.y + stack[1];
+                    x2 = x1 + stack[2];
+                    y2 = y1 + stack[3];
+                    pt.x = x2 + stack[4];
+                    pt.y = y2 + stack[5];
+                    gp.cubicTo(x1, y1, x2, y2, pt.x, pt.y);
+                    x1 = pt.x + stack[6];
+                    y1 = pt.y + stack[7];
+                    x2 = x1 + stack[8];
+                    y2 = y1 + stack[9];
+                    pt.x = x2 + stack[10];
+                    pt.y = y2 + stack[11];
+                    gp.cubicTo(x1, y1, x2, y2, pt.x, pt.y);
+                    pt.open = true;
+                    stackptr = 0;
+                    break;
+                case 1036: // hflex1
+                    ybase = pt.y;
+                    x1 = pt.x + stack[0];
+                    y1 = pt.y + stack[1];
+                    x2 = x1 + stack[2];
+                    y2 = y1 + stack[3];
+                    pt.x = x2 + stack[4];
+                    pt.y = y2;
+                    gp.cubicTo(x1, y1, x2, y2, pt.x, pt.y);
+                    x1 = pt.x + stack[5];
+                    y1 = pt.y;
+                    x2 = x1 + stack[6];
+                    y2 = y1 + stack[7];
+                    pt.x = x2 + stack[8];
+                    pt.y = ybase;
+                    gp.cubicTo(x1, y1, x2, y2, pt.x, pt.y);
+                    pt.open = true;
+                    stackptr = 0;
+                    break;
+                case 1037: // flex1
+                    ybase = pt.y;
+                    float xbase = pt.x;
+                    x1 = pt.x + stack[0];
+                    y1 = pt.y + stack[1];
+                    x2 = x1 + stack[2];
+                    y2 = y1 + stack[3];
+                    pt.x = x2 + stack[4];
+                    pt.y = y2 + stack[5];
+                    gp.cubicTo(x1, y1, x2, y2, pt.x, pt.y);
+                    x1 = pt.x + stack[6];
+                    y1 = pt.y + stack[7];
+                    x2 = x1 + stack[8];
+                    y2 = y1 + stack[9];
+                    if (Math.abs (x2 - xbase) > Math.abs (y2 - ybase)) {
+                        pt.x = x2 + stack[10];
+                        pt.y = ybase;
+                    } else {
+                        pt.x = xbase;
+                        pt.y = y2 + stack[10];
+                    }
+                    gp.cubicTo(x1, y1, x2, y2, pt.x, pt.y);
+                    pt.open = true;
+                    stackptr = 0;
+                    break;
+                default:
+                    System.out.println ("ERROR! TYPE1C CHARSTRING CMD IS " + cmd);
+                    break;
+            }
+        }
+    }
+
+    /**
+     * Get a glyph outline by name
+     *
+     * @param name the name of the desired glyph
+     * @return the glyph outline, or null if unavailable
+     */
+    protected Path getOutline (String name, float width) {
+        // first find the index of this name
+        int index = getNameIndex (name);
+
+        // now find the glyph with that name
+        for (int i = 0; i < glyphnames.length; i++) {
+            if (glyphnames[i] == index) {
+                return readGlyph (charstringbase, i);
+            }
+        }
+
+        // not found -- return the unknown glyph
+        return readGlyph (charstringbase, 0);
+    }
+
+    /**
+     * Get a glyph outline by character code
+     *
+     * Note this method must always return an outline 
+     *
+     * @param src the character code of the desired glyph
+     * @return the glyph outline
+     */
+    protected Path getOutline (char src, float width) {
+        // ignore high bits
+        int index = (int) (src & 0xff);
+
+        // if we use a standard encoding, the mapping is from glyph to SID
+        // therefore we must find the glyph index in the name table
+        if (encodingbase == 0 || encodingbase == 1) {
+            for (int i = 0; i < glyphnames.length; i++) {
+                if (glyphnames[i] == encoding[index]) {
+                    return readGlyph (charstringbase, i);
+                }
+            }
+        } else {
+            // for a custom encoding, the mapping is from glyph to GID, so
+            // we can just map the glyph directly
+            if (index > 0 && index < encoding.length) {
+                return readGlyph (charstringbase, encoding[index]);
+            }
+        }
+
+        // for some reason the glyph was not found, return the empty glyph
+        return readGlyph (charstringbase, 0);
+    }
+}
+

src/com/sun/pdfview/font/Type1Font.java

@@ -0,0 +1,858 @@
+/*
+ * $Id: Type1Font.java,v 1.5 2009/02/12 13:53:54 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview.font;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.TreeMap;
+
+import net.sf.andpdf.utils.Utils;
+
+import android.graphics.Matrix;
+import android.graphics.Path;
+import android.graphics.PointF;
+
+import com.sun.pdfview.PDFFile;
+import com.sun.pdfview.PDFObject;
+
+
+/**
+ * A representation, with parser, of an Adobe Type 1 font.
+ * @author Mike Wessler
+ */
+public class Type1Font extends OutlineFont {
+
+    String chr2name[];
+    int password;
+    byte[] subrs[];
+    int lenIV;
+    Map<String,Object> name2outline;
+    Map<String,FlPoint> name2width;
+    Matrix at;
+    /** the Type1 stack of command values */
+    float stack[] = new float[100];
+    /** the current position in the Type1 stack */
+    int sloc = 0;
+    /** the stack of postscript commands (used by callothersubr) */
+    float psStack[] = new float[3];
+    /** the current position in the postscript stack */
+    int psLoc = 0;
+
+    /**
+     * create a new Type1Font based on a font data stream and an encoding.
+     * @param baseName the postscript name of this font
+     * @param src the Font object as a stream with a dictionary
+     * @param descriptor the descriptor for this font
+     */
+    public Type1Font(String baseName, PDFObject src,
+            PDFFontDescriptor descriptor) throws IOException {
+        super(baseName, src, descriptor);
+
+        if (descriptor != null && descriptor.getFontFile() != null) {
+            // parse that file, filling name2outline and chr2name
+            int start = descriptor.getFontFile().getDictRef("Length1").getIntValue();
+            int len = descriptor.getFontFile().getDictRef("Length2").getIntValue();
+            byte font[] = descriptor.getFontFile().getStream();
+
+            parseFont(font, start, len);
+        }
+    }
+
+    /** Read a font from it's data, start position and length */
+    protected void parseFont(byte[] font, int start, int len) {
+        name2width = new HashMap<String,FlPoint>();
+
+        byte data[] = null;
+
+        if (isASCII(font, start)) {
+            byte[] bData = readASCII(font, start, start + len);
+            data = decrypt(bData, 0, bData.length, 55665, 4);
+        } else {
+            data = decrypt(font, start, start + len, 55665, 4);
+        }
+
+        // encoding is in cleartext area
+        chr2name = readEncoding(font);
+        int lenIVLoc = findSlashName(data, "lenIV");
+        PSParser psp = new PSParser(data, 0);
+        if (lenIVLoc < 0) {
+            lenIV = 4;
+        } else {
+            psp.setLoc(lenIVLoc + 6);
+            lenIV = Integer.parseInt(psp.readThing());
+        }
+        password = 4330;
+        int matrixloc = findSlashName(font, "FontMatrix");
+        if (matrixloc < 0) {
+            System.out.println("No FontMatrix!");
+            at = Utils.createMatrix(0.001f, 0, 0, 0.001f, 0, 0);
+        } else {
+            PSParser psp2 = new PSParser(font, matrixloc + 11);
+            // read [num num num num num num]
+            float xf[] = psp2.readArray(6);
+            //	    System.out.println("FONT MATRIX: "+xf);
+            at = Utils.createMatrix(xf);
+        }
+
+        subrs = readSubrs(data);
+        name2outline = new TreeMap<String,Object>(readChars(data));
+    // at this point, name2outline holds name -> byte[].
+    }
+
+    /**
+     * parse the encoding portion of the font definition
+     * @param d the font definition stream
+     * @return an array of the glyphs corresponding to each byte
+     */
+    private String[] readEncoding(byte[] d) {
+        byte[][] ary = readArray(d, "Encoding", "def");
+        String res[] = new String[256];
+        for (int i = 0; i < ary.length; i++) {
+            if (ary[i] != null) {
+                if (ary[i][0] == '/') {
+                    res[i] = new String(ary[i]).substring(1);
+                } else {
+                    res[i] = new String(ary[i]);
+                }
+            } else {
+                res[i] = null;
+            }
+        }
+        return res;
+    }
+
+    /**
+     * read the subroutines out of the font definition
+     * @param d the font definition stream
+     * @return an array of the subroutines, each as a byte array.
+     */
+    private byte[][] readSubrs(byte[] d) {
+        return readArray(d, "Subrs", "index");
+    }
+
+    /**
+     * read a named array out of the font definition.
+     * <p>
+     * this function attempts to parse an array out of a postscript
+     * definition without doing any postscript.  It's actually looking
+     * for things that look like "dup <i>id</i> <i>elt</i> put", and
+     * placing the <i>elt</i> at the <i>i</i>th position in the array.
+     * @param d the font definition stream
+     * @param key the name of the array
+     * @param end a string that appears at the end of the array
+     * @return an array consisting of a byte array for each entry
+     */
+    private byte[][] readArray(byte[] d, String key, String end) {
+        int i = findSlashName(d, key);
+        if (i < 0) {
+            // not found.
+            return new byte[0][];
+        }
+        // now find things that look like "dup id elt put"
+        // end at "def"
+        PSParser psp = new PSParser(d, i);
+        String type = psp.readThing();     // read the key (i is the start of the key)
+        double val;
+        type = psp.readThing();
+        if (type.equals("StandardEncoding")) {
+            byte[] stdenc[] = new byte[FontSupport.standardEncoding.length][];
+            for (i = 0; i < stdenc.length; i++) {
+                stdenc[i] = FontSupport.getName(FontSupport.standardEncoding[i]).getBytes();
+            }
+            return stdenc;
+        }
+        int len = Integer.parseInt(type);
+        byte[] out[] = new byte[len][];
+        byte[] line;
+        while (true) {
+            String s = psp.readThing();
+            if (s.equals("dup")) {
+                int id = Integer.parseInt(psp.readThing());
+                String elt = psp.readThing();
+                line = elt.getBytes();
+                if (Character.isDigit(elt.charAt(0))) {
+                    int hold = Integer.parseInt(elt);
+                    String special = psp.readThing();
+                    if (special.equals("-|") || special.equals("RD")) {
+                        psp.setLoc(psp.getLoc() + 1);
+                        line = psp.getNEncodedBytes(hold, password, lenIV);
+                    }
+                }
+                out[id] = line;
+            } else if (s.equals(end)) {
+                break;
+            }
+        }
+        return out;
+    }
+
+    /**
+     * decrypt an array using the Adobe Type 1 Font decryption algorithm.
+     * @param d the input array of bytes
+     * @param start where in the array to start decoding
+     * @param end where in the array to stop decoding
+     * @param key the decryption key
+     * @param skip how many bytes to skip initially
+     * @return the decrypted bytes.  The length of this array will be
+     * (start-end-skip) bytes long
+     */
+    private byte[] decrypt(byte[] d, int start, int end, int key, int skip) {
+        if (end - start - skip < 0) {
+            skip = 0;
+        }
+        byte[] o = new byte[end - start - skip];
+        int r = key;
+        int ipos;
+        int c1 = 52845;
+        int c2 = 22719;
+        for (ipos = start; ipos < end; ipos++) {
+            int c = d[ipos] & 0xff;
+            int p = (c ^ (r >> 8)) & 0xff;
+            r = ((c + r) * c1 + c2) & 0xffff;
+            if (ipos - start - skip >= 0) {
+                o[ipos - start - skip] = (byte) p;
+            }
+        }
+        return o;
+    }
+
+    /**
+     * Read data formatted as ASCII strings as binary data
+     *
+     * @param data the data, formatted as ASCII strings
+     * @param start where in the array to start decrypting
+     * @param end where in the array to stop decrypting
+     */
+    private byte[] readASCII(byte[] data, int start, int end) {
+        // each byte of output is derived from one character (two bytes) of
+        // input
+        byte[] o = new byte[(end - start) / 2];
+
+        int count = 0;
+        int bit = 0;
+
+        for (int loc = start; loc < end; loc++) {
+            char c = (char) (data[loc] & 0xff);
+            byte b = (byte) 0;
+
+            if (c >= '0' && c <= '9') {
+                b = (byte) (c - '0');
+            } else if (c >= 'a' && c <= 'f') {
+                b = (byte) (10 + (c - 'a'));
+            } else if (c >= 'A' && c <= 'F') {
+                b = (byte) (10 + (c - 'A'));
+            } else {
+                // linefeed or something.  Skip.
+                continue;
+            }
+
+            // which half of the byte are we?
+            if ((bit++ % 2) == 0) {
+                o[count] = (byte) (b << 4);
+            } else {
+                o[count++] |= b;
+            }
+        }
+
+        return o;
+    }
+
+    /** 
+     * Determine if data is in ASCII or binary format.  According to the spec,
+     * if any of the first 4 bytes are not character codes ('0' - '9' or
+     * 'A' - 'F' or 'a' - 'f'), then the data is binary.  Otherwise it is
+     * ASCII
+     */
+    private boolean isASCII(byte[] data, int start) {
+        // look at the first 4 bytes
+        for (int i = start; i < start + 4; i++) {
+            // get the byte as a character
+            char c = (char) (data[i] & 0xff);
+
+            if (c >= '0' && c <= '9') {
+                continue;
+            } else if (c >= 'a' && c <= 'f') {
+                continue;
+            } else if (c >= 'A' && c <= 'F') {
+                continue;
+            } else {
+                // out of range
+                return false;
+            }
+        }
+
+        // all were in range, so it is ASCII
+        return true;
+    }
+
+    /**
+     * PostScript reader (not a parser, as the name would seem to indicate).
+     */
+    class PSParser {
+
+        byte[] data;
+        int loc;
+
+        /**
+         * create a PostScript reader given some data and an initial offset
+         * into that data.
+         * @param data the bytes of the postscript information
+         * @param start an initial offset into the data
+         */
+        public PSParser(byte[] data, int start) {
+            this.data = data;
+            this.loc = start;
+        }
+
+        /**
+         * get the next postscript "word".  This is basically the next
+         * non-whitespace block between two whitespace delimiters.
+         * This means that something like " [2 4 53]" will produce
+         * three items, while " [2 4 56 ]" will produce four.
+         */
+        public String readThing() {
+            // skip whitespace
+            while (PDFFile.isWhiteSpace(data[loc])) {
+                loc++;
+            }
+            // read thing
+            int start = loc;
+            while (!PDFFile.isWhiteSpace(data[loc])) {
+                loc++;
+                if (!PDFFile.isRegularCharacter(data[loc])) {
+                    break;  // leave with the delimiter included
+                }
+            }
+            String s = new String(data, start, loc - start);
+            //	    System.out.println("Read: "+s);
+            return s;
+        }
+
+        /**
+         * read a set of numbers from the input.  This method doesn't
+         * pay any attention to "[" or "]" delimiters, and reads any
+         * non-numeric items as the number 0.
+         * @param count the number of items to read
+         * @return an array of count floats
+         */
+        public float[] readArray(int count) {
+            float[] ary = new float[count];
+            int idx = 0;
+            while (idx < count) {
+                String thing = readThing();
+                if (thing.charAt(0) == '[') {
+                    thing = thing.substring(1);
+                }
+                if (thing.endsWith("]")) {
+                    thing = thing.substring(0, thing.length() - 1);
+                }
+                if (thing.length() > 0) {
+                    ary[idx++] = Float.valueOf(thing).floatValue();
+                }
+            }
+            return ary;
+        }
+
+        /**
+         * get the current location within the input stream
+         */
+        public int getLoc() {
+            return loc;
+        }
+
+        /**
+         * set the current location within the input stream
+         */
+        public void setLoc(int loc) {
+            this.loc = loc;
+        }
+
+        /**
+         * treat the next n bytes of the input stream as encoded
+         * information to be decrypted.
+         * @param n the number of bytes to decrypt
+         * @param key the decryption key
+         * @param skip the number of bytes to skip at the beginning of the
+         * decryption
+         * @return an array of decrypted bytes.  The length of the array
+         * will be n-skip.
+         */
+        public byte[] getNEncodedBytes(int n, int key, int skip) {
+            byte[] result = decrypt(data, loc, loc + n, key, skip);
+            loc += n;
+            return result;
+        }
+    }
+
+    /**
+     * get the index into the byte array of a slashed name, like "/name".
+     * @param d the search array
+     * @param name the name to look for, without the initial /
+     * @return the index of the first occurance of /name in the array.
+     */
+    private int findSlashName(byte[] d, String name) {
+        int i;
+        for (i = 0; i < d.length; i++) {
+            if (d[i] == '/') {
+                // check for key
+                boolean found = true;
+                for (int j = 0; j < name.length(); j++) {
+                    if (d[i + j + 1] != name.charAt(j)) {
+                        found = false;
+                        break;
+                    }
+                }
+                if (found) {
+                    return i;
+                }
+            }
+        }
+        return -1;
+    }
+
+    /**
+     * get the character definitions of the font.
+     * @param d the font data
+     * @return a HashMap that maps string glyph names to byte arrays of
+     * decoded font data.
+     */
+    private HashMap<String,byte[]> readChars(byte[] d) {
+        // skip thru data until we find "/"+key
+        HashMap<String,byte[]> hm = new HashMap<String,byte[]>();
+        int i = findSlashName(d, "CharStrings");
+        if (i < 0) {
+            // not found
+            return hm;
+        }
+        PSParser psp = new PSParser(d, i);
+        // read /name len -| [len bytes] |-
+        // until "end"
+        while (true) {
+            String s = psp.readThing();
+            char c = s.charAt(0);
+            if (c == '/') {
+                int len = Integer.parseInt(psp.readThing());
+                String go = psp.readThing();  // it's -| or RD
+                if (go.equals("-|") || go.equals("RD")) {
+                    psp.setLoc(psp.getLoc() + 1);
+                    byte[] line = psp.getNEncodedBytes(len, password, lenIV);
+                    hm.put(s.substring(1), line);
+                }
+            } else if (s.equals("end")) {
+                break;
+            }
+        }
+        return hm;
+    }
+
+    /**
+     * pop the next item off the stack
+     */
+    private float pop() {
+        float val = 0;
+        if (sloc > 0) {
+            val = stack[--sloc];
+        }
+        return val;
+    }
+    int callcount = 0;
+
+    /**
+     * parse glyph data into a GeneralPath, and return the advance width.
+     * The working point is passed in as a parameter in order to allow
+     * recursion.
+     * @param cs the decrypted glyph data
+     * @param gp a GeneralPath into which the glyph shape will be stored
+     * @param pt a FlPoint object that will be used to generate the path
+     * @param wid a FlPoint into which the advance width will be placed.
+     */
+    private void parse(byte[] cs, Path gp, FlPoint pt, FlPoint wid) {
+        //	System.out.println("--- cmd length is "+cs.length);
+        int loc = 0;
+        float x1, x2, x3, y1, y2, y3;
+        while (loc < cs.length) {
+            int v = ((int) cs[loc++]) & 0xff;
+            if (v == 255) {
+                stack[sloc++] = ((((int) cs[loc]) & 0xff) << 24) +
+                        ((((int) cs[loc + 1]) & 0xff) << 16) +
+                        ((((int) cs[loc + 2]) & 0xff) << 8) +
+                        ((((int) cs[loc + 3]) & 0xff));
+                loc += 4;
+//		System.out.println("Pushed long "+stack[sloc-1]);
+            } else if (v >= 251) {
+                stack[sloc++] = -((v - 251) << 8) - (((int) cs[loc]) & 0xff) - 108;
+                loc++;
+//		System.out.println("Pushed lo "+stack[sloc-1]);
+            } else if (v >= 247) {
+                stack[sloc++] = ((v - 247) << 8) + (((int) cs[loc]) & 0xff) + 108;
+                loc++;
+//		System.out.println("Pushed hi "+stack[sloc-1]);
+            } else if (v >= 32) {
+                stack[sloc++] = v - 139;
+//		System.out.println("Pushed "+stack[sloc-1]);
+            } else {
+                //		System.out.println("CMD: "+v+" (stack is size "+sloc+")");
+                switch (v) {
+                    case 0:   // x
+                        throw new RuntimeException("Bad command (" + v + ")");
+                    case 1:   // hstem
+                        sloc = 0;
+                        break;
+                    case 2:   // x
+                        throw new RuntimeException("Bad command (" + v + ")");
+                    case 3:   // vstem
+                        sloc = 0;
+                        break;
+                    case 4:   // y vmoveto
+                        pt.y += pop();
+                        gp.moveTo(pt.x, pt.y);
+                        sloc = 0;
+                        break;
+                    case 5:   // x y rlineto
+                        pt.y += pop();
+                        pt.x += pop();
+                        gp.lineTo(pt.x, pt.y);
+                        sloc = 0;
+                        break;
+                    case 6:   // x hlineto
+                        pt.x += pop();
+                        gp.lineTo(pt.x, pt.y);
+                        sloc = 0;
+                        break;
+                    case 7:   // y vlineto
+                        pt.y += pop();
+                        gp.lineTo(pt.x, pt.y);
+                        sloc = 0;
+                        break;
+                    case 8:   // x1 y1 x2 y2 x3 y3 rcurveto
+                        y3 = pop();
+                        x3 = pop();
+                        y2 = pop();
+                        x2 = pop();
+                        y1 = pop();
+                        x1 = pop();
+                        gp.cubicTo(pt.x + x1, pt.y + y1,
+                                pt.x + x1 + x2, pt.y + y1 + y2,
+                                pt.x + x1 + x2 + x3, pt.y + y1 + y2 + y3);
+                        pt.x += x1 + x2 + x3;
+                        pt.y += y1 + y2 + y3;
+                        sloc = 0;
+                        break;
+                    case 9:   // closepath
+                        gp.close();
+                        sloc = 0;
+                        break;
+                    case 10:  // n callsubr
+                        int n = (int) pop();
+                        if (subrs[n] == null) {
+                            System.out.println("No subroutine #" + n);
+                        } else {
+                            callcount++;
+                            if (callcount > 10) {
+                                System.out.println("Call stack too large");
+                            //			    throw new RuntimeException("Call stack too large");
+                            } else {
+                                parse(subrs[n], gp, pt, wid);
+                            }
+                            callcount--;
+                        }
+                        break;
+                    case 11:  // return
+                        return;
+                    case 12:  // ext...
+                        v = ((int) cs[loc++]) & 0xff;
+                        if (v == 6) {  // s x y a b seac
+                            char b = (char) pop();
+                            char a = (char) pop();
+                            float y = pop();
+                            float x = pop();
+                            buildAccentChar(x, y, a, b, gp);
+                            sloc = 0;
+                        } else if (v == 7) {  // x y w h sbw
+                            wid.y = pop();
+                            wid.x = pop();
+                            pt.y = pop();
+                            pt.x = pop();
+                            sloc = 0;
+                        } else if (v == 12) {  // a b div -> a/b
+                            float b = pop();
+                            float a = pop();
+                            stack[sloc++] = a / b;
+                        } else if (v == 33) {  // a b setcurrentpoint
+                            pt.y = pop();
+                            pt.x = pop();
+                            gp.moveTo(pt.x, pt.y);
+                            sloc = 0;
+                        } else if (v == 0) { // dotsection
+                            sloc = 0;
+                        } else if (v == 1) {  // vstem3
+                            sloc = 0;
+                        } else if (v == 2) {  // hstem3
+                            sloc = 0;
+                        } else if (v == 16) {  // n callothersubr
+                            int cn = (int) pop();
+                            int countargs = (int) pop();
+
+                            //    System.out.println("Called othersubr with index "+cn);
+
+                            switch (cn) {
+                                case 0:
+                                    // push args2 and args3 onto stack
+                                    psStack[psLoc++] = pop();
+                                    psStack[psLoc++] = pop();
+                                    pop();
+                                    break;
+                                case 3:
+                                    // push 3 onto the postscript stack
+                                    psStack[psLoc++] = 3;
+                                    break;
+                                default:
+                                    // push arguments onto the postscript stack
+                                    for (int i = 0; i > countargs; i--) {
+                                        psStack[psLoc++] = pop();
+                                    }
+                                    break;
+                            }
+                        } else if (v == 17) {  // pop
+                            // pop from the postscript stack onto the type1 stack
+                            stack[sloc++] = psStack[psLoc - 1];
+                            psLoc--;
+                        } else {
+                            throw new RuntimeException("Bad command (" + v + ")");
+                        }
+                        break;
+                    case 13:  // s w hsbw
+                        wid.x = pop();
+                        wid.y = 0;
+                        pt.x = pop();
+                        pt.y = 0;
+                        //		    gp.moveTo(pt.x, pt.y);
+                        sloc = 0;
+                        break;
+                    case 14:  // endchar
+                        //		    return;
+                        break;
+                    case 15:  // x
+                    case 16:  // x
+                    case 17:  // x
+                    case 18:  // x
+                    case 19:  // x
+                    case 20:  // x
+                        throw new RuntimeException("Bad command (" + v + ")");
+                    case 21:  // x y rmoveto
+                        pt.y += pop();
+                        pt.x += pop();
+                        gp.moveTo(pt.x, pt.y);
+                        sloc = 0;
+                        break;
+                    case 22:  // x hmoveto
+                        pt.x += pop();
+                        gp.moveTo(pt.x, pt.y);
+                        sloc = 0;
+                        break;
+                    case 23:  // x
+                    case 24:  // x
+                    case 25:  // x
+                    case 26:  // x
+                    case 27:  // x
+                    case 28:  // x
+                    case 29:  // x
+                        throw new RuntimeException("Bad command (" + v + ")");
+                    case 30:  // y1 x2 y2 x3 vhcurveto
+                        x3 = pop();
+                        y2 = pop();
+                        x2 = pop();
+                        y1 = pop();
+                        x1 = y3 = 0;
+                        gp.cubicTo(pt.x, pt.y + y1,
+                                pt.x + x2, pt.y + y1 + y2,
+                                pt.x + x2 + x3, pt.y + y1 + y2);
+                        pt.x += x2 + x3;
+                        pt.y += y1 + y2;
+                        sloc = 0;
+                        break;
+                    case 31:  // x1 x2 y2 y3 hvcurveto
+                        y3 = pop();
+                        y2 = pop();
+                        x2 = pop();
+                        x1 = pop();
+                        y1 = x3 = 0;
+                        gp.cubicTo(pt.x + x1, pt.y,
+                                pt.x + x1 + x2, pt.y + y2,
+                                pt.x + x1 + x2, pt.y + y2 + y3);
+                        pt.x += x1 + x2;
+                        pt.y += y2 + y3;
+                        sloc = 0;
+                        break;
+                }
+            }
+        }
+    }
+
+    /**
+     * build an accented character out of two pre-defined glyphs.
+     * @param x the x offset of the accent
+     * @param y the y offset of the accent
+     * @param a the index of the accent glyph
+     * @param b the index of the base glyph
+     * @param gp the GeneralPath into which the combined glyph will be
+     * written.
+     */
+    private void buildAccentChar(float x, float y, char a, char b,
+            Path gp) {
+        // get the outline of the accent
+        Path pathA = getOutline(a, getWidth(a, null));
+
+        // undo the effect of the transform applied in read 
+        Matrix xformA = new Matrix();
+        if (xformA.invert(at)) {
+            xformA.setTranslate(x, y);
+            pathA.transform(xformA);
+        } else {
+        	Matrix tmp = new Matrix();
+        	tmp.setTranslate(x, y);
+            pathA.transform(tmp);
+        }
+
+        Path pathB = getOutline(b, getWidth(b, null));
+
+        Matrix xformB = new Matrix();
+        if (xformB.invert(at)) {
+            pathB.transform(xformB);
+        } else {
+            // ignore
+        }
+
+        gp.addPath(pathB);
+        gp.addPath(pathA);
+    }
+
+    /** 
+     * Get the width of a given character
+     *
+     * This method is overridden to work if the width array hasn't been
+     * populated (as for one of the 14 base fonts)
+     */
+    @Override
+    public float getWidth(char code, String name) {
+        // we don't have first and last chars, so therefore no width array
+        if (getFirstChar() == -1 || getLastChar() == -1) {
+            String key = chr2name[code & 0xff];
+
+            // use a name if one is provided
+            if (name != null) {
+                key = name;
+            }
+
+            if (key != null && name2outline.containsKey(key)) {
+                if (!name2width.containsKey(key)) {
+                    // glyph has not yet been parsed
+                    // getting the outline will force it to get read
+                    getOutline(key, 0);
+                }
+
+                FlPoint width = name2width.get(key);
+                if (width != null) {
+                    return width.x / getDefaultWidth();
+                }
+            }
+
+            return 0;
+        }
+
+        // return the width that has been specified
+        return super.getWidth(code, name);
+    }
+
+    /**
+     * Decrypt a glyph stored in byte form
+     */
+    private synchronized Path parseGlyph(byte[] cs, FlPoint advance,
+            Matrix at) {
+        Path gp = new Path();
+        FlPoint curpoint = new FlPoint();
+
+        sloc = 0;
+        parse(cs, gp, curpoint, advance);
+
+        gp.transform(at);
+        return gp;
+    }
+
+    /**
+     * Get a glyph outline by name
+     *
+     * @param name the name of the desired glyph
+     * @return the glyph outline, or null if unavailable
+     */
+    protected Path getOutline(String name, float width) {
+        // make sure we have a valid name
+        if (name == null || !name2outline.containsKey(name)) {
+            name = ".notdef";
+        }
+
+        // get whatever is stored in name. Could be a GeneralPath, could be byte[]
+        Object obj = name2outline.get(name);
+
+        // if it's a byte array, it needs to be parsed
+        // otherwise, just return the path
+        if (obj instanceof Path) {
+            return (Path) obj;
+        } else {
+            byte[] cs = (byte[]) obj;
+            FlPoint advance = new FlPoint();
+
+            Path gp = parseGlyph(cs, advance, at);
+
+            if (width != 0 && advance.x != 0) {
+                // scale the glyph to fit in the width
+                PointF p = new PointF(advance.x, advance.y);
+                float[]pts = new float[]{p.x,p.y};
+                at.mapPoints(pts);
+                p.x = pts[0];
+                p.y = pts[1];
+                float scale = width / p.x;
+                Matrix xform = new Matrix();
+                xform.setScale(scale, 1.0f);
+                gp.transform(xform);
+            }
+
+            // put the parsed object in the cache
+            name2outline.put(name, gp);
+            name2width.put(name, advance);
+            return gp;
+        }
+    }
+
+    /**
+     * Get a glyph outline by character code
+     *
+     * Note this method must always return an outline 
+     *
+     * @param src the character code of the desired glyph
+     * @return the glyph outline
+     */
+    protected Path getOutline(char src, float width) {
+        return getOutline(chr2name[src & 0xff], width);
+    }
+}
+

src/com/sun/pdfview/font/Type3Font.java

@@ -0,0 +1,189 @@
+/*
+ * $Id: Type3Font.java,v 1.3 2009/02/12 13:53:54 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview.font;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+import net.sf.andpdf.utils.Utils;
+
+import android.graphics.Matrix;
+import android.graphics.Path;
+import android.graphics.PointF;
+import android.graphics.RectF;
+
+import com.sun.pdfview.PDFObject;
+import com.sun.pdfview.PDFPage;
+import com.sun.pdfview.PDFParser;
+
+
+/**
+ * A Type 3 Font, in which each glyph consists of a sequence of PDF
+ * commands.
+ * 
+ * @author Mike Wessler
+ */
+public class Type3Font extends PDFFont {
+
+    /** resources for the character definitions */
+    HashMap<String,PDFObject> rsrc;
+    /** the character processes, mapped by name */
+    Map charProcs;
+    /** bounding box for the font characters */
+    RectF bbox;
+    /** affine transform for the font characters */
+    Matrix at;
+    /** the widths */
+    float[] widths;
+    /** the start code */
+    int firstChar;
+    /** the end code */
+    int lastChar;
+
+    /**
+     * Generate a Type 3 font.
+     * @param baseFont the postscript name of this font
+     * @param fontObj a dictionary containing references to the character
+     * definitions and font information
+     * @param resources a set of resources used by the character definitions
+     * @param descriptor the descriptor for this font
+     */
+    public Type3Font(String baseFont, PDFObject fontObj,
+            HashMap<String,PDFObject> resources, PDFFontDescriptor descriptor) throws IOException {
+        super(baseFont, descriptor);
+
+        rsrc = new HashMap<String,PDFObject>();
+
+        if (resources != null) {
+            rsrc.putAll(resources);
+        }
+
+        // get the transform matrix
+        PDFObject matrix = fontObj.getDictRef("FontMatrix");
+        float matrixAry[] = new float[6];
+        for (int i = 0; i < 6; i++) {
+            matrixAry[i] = matrix.getAt(i).getFloatValue();
+        }
+        at = Utils.createMatrix(matrixAry);
+
+        // get the scale from the matrix
+        float scale = matrixAry[0] + matrixAry[2];
+
+        // put all the resources in a Hash
+        PDFObject rsrcObj = fontObj.getDictRef("Resources");
+        if (rsrcObj != null) {
+            rsrc.putAll(rsrcObj.getDictionary());
+        }
+
+        // get the character processes, indexed by name
+        charProcs = fontObj.getDictRef("CharProcs").getDictionary();
+
+        // get the font bounding box
+        PDFObject[] bboxdef = fontObj.getDictRef("FontBBox").getArray();
+        float[] bboxfdef = new float[4];
+        for (int i = 0; i < 4; i++) {
+            bboxfdef[i] = bboxdef[i].getFloatValue();
+        }
+        bbox = new RectF(bboxfdef[0], bboxfdef[1],
+                bboxfdef[2] - bboxfdef[0],
+                bboxfdef[3] - bboxfdef[1]);
+        if (bbox.isEmpty()) {
+            bbox = null;
+        }
+
+        // get the widths
+        PDFObject[] widthArray = fontObj.getDictRef("Widths").getArray();
+        widths = new float[widthArray.length];
+        for (int i = 0; i < widthArray.length; i++) {
+            widths[i] = widthArray[i].getFloatValue();
+        }
+
+        // get first and last chars
+        firstChar = fontObj.getDictRef("FirstChar").getIntValue();
+        lastChar = fontObj.getDictRef("LastChar").getIntValue();
+    }
+
+    /**
+     * Get the first character code
+     */
+    public int getFirstChar() {
+        return firstChar;
+    }
+
+    /**
+     * Get the last character code
+     */
+    public int getLastChar() {
+        return lastChar;
+    }
+
+    /**
+     * Get the glyph for a given character code and name
+     *
+     * The preferred method of getting the glyph should be by name.  If the
+     * name is null or not valid, then the character code should be used.
+     * If the both the code and the name are invalid, the undefined glyph 
+     * should be returned.
+     *
+     * Note this method must *always* return a glyph.  
+     *
+     * @param src the character code of this glyph
+     * @param name the name of this glyph or null if unknown
+     * @return a glyph for this character
+     */
+    protected PDFGlyph getGlyph(char src, String name) {
+        if (name == null) {
+            throw new IllegalArgumentException("Glyph name required for Type3 font!" +
+                    "Source character: " + (int) src);
+        }
+
+        PDFObject pageObj = (PDFObject) charProcs.get(name);
+        if (pageObj == null) {
+            // glyph not found.  Return an empty glyph...
+            return new PDFGlyph(src, name, new Path(), new PointF(0, 0));
+        }
+
+        try {
+            PDFPage page = new PDFPage(bbox, 0);
+            page.addXform(at);
+
+            PDFParser prc = new PDFParser(page, pageObj.getStream(), rsrc);
+            prc.go(true);
+
+            float width = widths[src - firstChar];
+
+            PointF advance = new PointF(width, 0);
+            float[]pts = {advance.x,advance.y};
+            at.mapPoints(pts);
+            advance.x = pts[0];
+            advance.y = pts[1];
+
+            return new PDFGlyph(src, name, page, advance);
+        } catch (IOException ioe) {
+            // help!
+            System.out.println("IOException in Type3 font: " + ioe);
+            ioe.printStackTrace();
+            return null;
+        }
+    }
+}
+

src/com/sun/pdfview/font/ttf/AdobeGlyphList.java

@@ -0,0 +1,180 @@
+package com.sun.pdfview.font.ttf;
+
+import java.io.*;
+import java.util.*;
+
+/**
+ * Build an object which provides access to all the Adobe glyph names, using
+ * a unicode value, and which can translate a glyph name to one or more
+ * unicode values.
+ *
+# ###################################################################################
+# Copyright (c) 1997,1998,2002,2007 Adobe Systems Incorporated
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this documentation file to use, copy, publish, distribute,
+# sublicense, and/or sell copies of the documentation, and to permit
+# others to do the same, provided that:
+# - No modification, editing or other alteration of this document is
+# allowed; and
+# - The above copyright notice and this permission notice shall be
+# included in all copies of the documentation.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this documentation file, to create their own derivative works
+# from the content of this document to use, copy, publish, distribute,
+# sublicense, and/or sell the derivative works, and to permit others to do
+# the same, provided that the derived work is not represented as being a
+# copy or version of this document.
+#
+# Adobe shall not be liable to any party for any loss of revenue or profit
+# or for indirect, incidental, special, consequential, or other similar
+# damages, whether based on tort (including without limitation negligence
+# or strict liability), contract or other legal or equitable grounds even
+# if Adobe has been advised or had reason to know of the possibility of
+# such damages. The Adobe materials are provided on an "AS IS" basis.
+# Adobe specifically disclaims all express, statutory, or implied
+# warranties relating to the Adobe materials, including but not limited to
+# those concerning merchantability or fitness for a particular purpose or
+# non-infringement of any third party rights regarding the Adobe
+# materials.
+# ###################################################################################
+# Name:          Adobe Glyph List
+# Table version: 2.0
+# Date:          September 20, 2002
+#
+# See http://partners.adobe.com/asn/developer/typeforum/unicodegn.html
+#
+# Format: Semicolon-delimited fields:
+#            (1) glyph name
+#            (2) Unicode scalar value
+ *
+ * @author tomoke
+ */
+public class AdobeGlyphList {
+
+    /** provide a translation from a glyph name to the possible unicode values. */
+    static private HashMap<String, int[]> glyphToUnicodes;
+    /** provide a translation from a unicode value to a glyph name. */
+    static private HashMap<Integer, String> unicodeToGlyph;
+    /** the loader thread we are reading through. */
+    static Thread glyphLoaderThread = null;
+
+
+    static {
+        new AdobeGlyphList();
+    }
+
+    /** 
+     * <p>private constructor to restrict creation to a singleton.</p>
+     * 
+     * <p>We initialize by creating the storage and parsing the glyphlist
+     * into the tables.</p>
+     */
+    private AdobeGlyphList() {
+        glyphToUnicodes = new HashMap<String, int[]>(4500);
+        unicodeToGlyph = new HashMap<Integer, String>(4500);
+        glyphLoaderThread = new Thread(new Runnable() {
+
+            public void run() {
+                int[] codes;
+                StringTokenizer codeTokens;
+                String glyphName;
+                StringTokenizer tokens;
+                ArrayList<String> unicodes = new ArrayList<String>();
+
+                InputStream istr = getClass().getResourceAsStream("/com/sun/pdfview/font/ttf/resource/glyphlist.txt");
+
+                BufferedReader reader = new BufferedReader(new InputStreamReader(istr));
+                String line = "";
+                while (line != null) {
+                    try {
+                        unicodes.clear();
+                        line = reader.readLine();
+                        if (line == null) {
+                            break;
+                        }
+                        line = line.trim();
+                        if (line.length() > 0 && !line.startsWith("#")) {
+                            // ignore comment lines
+                            tokens = new StringTokenizer(line, ";");
+                            glyphName = tokens.nextToken();
+                            codeTokens = new StringTokenizer(tokens.nextToken(), " ");
+                            while (codeTokens.hasMoreTokens()) {
+                                unicodes.add(codeTokens.nextToken());
+                            }
+                            codes = new int[unicodes.size()];
+                            for (int i = 0; i < unicodes.size(); i++) {
+                                codes[i] = Integer.parseInt(unicodes.get(i), 16);
+                                unicodeToGlyph.put(new Integer(codes[i]), glyphName);
+                            }
+                            glyphToUnicodes.put(glyphName, codes);
+                        }
+
+                    } catch (IOException ex) {
+                        break;
+                    }
+                }
+            }
+        }, "Adobe Glyph Loader Thread");
+        glyphLoaderThread.setDaemon(true);
+        glyphLoaderThread.setPriority(Thread.MIN_PRIORITY);
+        glyphLoaderThread.start();
+    }
+
+    /**
+     * translate a glyph name into the possible unicode values that it
+     * might represent. It is possible to have more than one unicode
+     * value for a single glyph name.
+     *
+     * @param glyphName
+     * @return int[]
+     */
+    public static int[] getUnicodeValues(String glyphName) {
+        while (glyphLoaderThread != null && glyphLoaderThread.isAlive()) {
+            synchronized (glyphToUnicodes) {
+                try {
+                    glyphToUnicodes.wait(250);
+                } catch (InterruptedException ex) {
+                    // ignore
+                }
+            }
+        }
+        return glyphToUnicodes.get(glyphName);
+    }
+
+    /**
+     * return a single index for a glyph, though there may be multiples.
+     * 
+     * @param glyphName
+     * @return Integer
+     */
+    public static Integer getGlyphNameIndex(String glyphName) {
+        int [] unicodes = getUnicodeValues(glyphName);
+        if (unicodes == null) {
+            return null;
+        } else {
+            return new Integer(unicodes[0]);
+        }
+    }
+
+    /**
+     * translate a unicode value into a glyph name. It is possible for
+     * different unicode values to translate into the same glyph name.
+     *
+     * @param unicode
+     * @return String
+     */
+    public static String getGlyphName(int unicode) {
+        while (glyphLoaderThread != null && glyphLoaderThread.isAlive()) {
+            synchronized (glyphToUnicodes) {
+                try {
+                    glyphToUnicodes.wait(250);
+                } catch (InterruptedException ex) {
+                    // ignore
+                }
+            }
+        }
+        return unicodeToGlyph.get(new Integer(unicode));
+    }
+}

src/com/sun/pdfview/font/ttf/CMap.java

@@ -0,0 +1,184 @@
+/*
+ * $Id: CMap.java,v 1.4 2009/03/15 20:47:38 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.sun.pdfview.font.ttf;
+
+import net.sf.andpdf.pdfviewer.ByteBuffer;
+
+/**
+ *
+ * @author  jkaplan
+ */
+public abstract class CMap {
+
+    /**
+     * The format of this map
+     */
+    private short format;
+
+    /**
+     * The language of this map, or 0 for language-independent
+     */
+    private short language;
+
+    /** Creates a new instance of CMap 
+     * Don't use this directly, use <code>CMap.createMap()</code>
+     */
+    protected CMap (short format, short language) {
+        this.format = format;
+        this.language = language;
+    }
+
+    /**
+     * Create a map for the given format and language
+
+     * <p>The Macintosh standard character to glyph mapping is supported
+     * by format 0.</p>
+     *
+     * <p>Format 2 supports a mixed 8/16 bit mapping useful for Japanese,
+     * Chinese and Korean. </p>
+     *
+     * <p>Format 4 is used for 16 bit mappings.</p>
+     *
+     * <p>Format 6 is used for dense 16 bit mappings.</p>
+     *
+     * <p>Formats 8, 10, and 12 (properly 8.0, 10.0, and 12.0) are used
+     * for mixed 16/32-bit and pure 32-bit mappings.<br>
+     * This supports text encoded with surrogates in Unicode 2.0 and later.</p>
+     *
+     * <p>Reference:<br>
+     * http://developer.apple.com/textfonts/TTRefMan/RM06/Chap6cmap.html </p>
+     */
+    public static CMap createMap (short format, short language) {
+        CMap outMap = null;
+
+        switch (format) {
+            case 0: // CMap format 0 - single byte codes
+                outMap = new CMapFormat0 (language);
+                break;
+            case 4: // CMap format 4 - two byte encoding
+                outMap = new CMapFormat4 (language);
+                break;
+            case 6: // CMap format 6 - 16-bit, two byte encoding
+                outMap = new CMapFormat6 (language);
+                break;
+//            case 8: // CMap format 8 - Mixed 16-bit and 32-bit coverage
+//                outMap = new CMapFormat_8(language);
+//                break;
+//            // CMap format 10 - Format 10.0 is a bit like format 6, in that it
+//            // defines a trimmed array for a tight range of 32-bit character codes:
+//            case 10:
+//                outMap = new CMapFormat_10(language);
+//                break;
+//            // Format 12.0 is a bit like format 4, in that it defines
+//            // segments for sparse representation in 4-byte character space.
+//            case 12: // CMap format 12 -
+//                outMap = new CMapFormat_12(language);
+//                break;
+            default:
+                System.out.println ("Unsupport CMap format: " + format);
+                return null;
+        }
+
+        return outMap;
+    }
+
+    /**
+     * Get a map from the given data
+     *
+     * This method reads the format, data and length variables of
+     * the map.
+     */
+    public static CMap getMap (ByteBuffer data) {
+        short format = data.getShort ();
+        short lengthShort = data.getShort ();
+        int length = 0xFFFF & (int) lengthShort;
+//        System.out.println (
+//                "CMAP, length: " + length + ", short: " + lengthShort);
+
+        // make sure our slice of the data only contains up to the length
+        // of this table
+        data.limit (Math.min (length, data.limit ()));
+
+        short language = data.getShort ();
+
+        CMap outMap = createMap (format, language);
+        if (outMap == null) {
+            return null;
+        }
+
+        outMap.setData (data.limit (), data);
+
+        return outMap;
+    }
+
+    /**
+     * Get the format of this map
+     */
+    public short getFormat () {
+        return format;
+    }
+
+    /**
+     * Get the language of this map
+     */
+    public short getLanguage () {
+        return language;
+    }
+
+    /**
+     * Set the data for this map
+     */
+    public abstract void setData (int length, ByteBuffer data);
+
+    /**
+     * Get the data in this map as a byte buffer
+     */
+    public abstract ByteBuffer getData ();
+
+    /**
+     * Get the length of this map
+     */
+    public abstract short getLength ();
+
+    /**
+     * Map an 8 bit value to another 8 bit value
+     */
+    public abstract byte map (byte src);
+
+    /**
+     * Map a 16 bit value to another 16 but value
+     */
+    public abstract char map (char src);
+
+    /**
+     * Get the src code which maps to the given glyphID
+     */
+    public abstract char reverseMap (short glyphID);
+
+    /** Print a pretty string */
+    @Override
+    public String toString () {
+        String indent = "        ";
+
+        return indent + " format: " + getFormat () + " length: " +
+                getLength () + " language: " + getLanguage () + "\n";
+    }
+}

src/com/sun/pdfview/font/ttf/CMapFormat0.java

@@ -0,0 +1,151 @@
+/*
+ * $Id: CMapFormat0.java,v 1.2 2007/12/20 18:33:30 rbair Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package com.sun.pdfview.font.ttf;
+
+import net.sf.andpdf.pdfviewer.ByteBuffer;
+
+/**
+ *
+ * @author  jkaplan
+ */
+public class CMapFormat0 extends CMap {
+    
+    /**
+     * The glyph index array
+     */
+    private byte[] glyphIndex;
+    
+    /** Creates a new instance of CMapFormat0 */
+    protected CMapFormat0(short language) {
+        super((short) 0, language);
+    
+        byte[] initialIndex = new byte[256];
+        for (int i = 0; i < initialIndex.length; i++) {
+            initialIndex[i] = (byte) i;
+        }
+        setMap(initialIndex);
+    }
+    
+    /**
+     * Get the length of this table
+     */
+    public short getLength() {
+        return (short) 262;
+    }
+    
+    /** 
+     * Map from a byte
+     */
+    public byte map(byte src) {
+        int i = 0xff & src;
+        
+        return glyphIndex[i];
+    }
+    
+    /**
+     * Cannot map from short
+     */
+    public char map(char src) {
+        if (src  < 0 || src > 255) {
+            // out of range
+            return (char) 0;
+        }
+    
+        return (char) (map((byte) src) & 0xff);
+    }
+        
+    
+    /**
+     * Get the src code which maps to the given glyphID
+     */
+    public char reverseMap(short glyphID) {
+        for (int i = 0; i < glyphIndex.length; i++) {
+            if ((glyphIndex[i] & 0xff) == glyphID) {
+                return (char) i;
+            }
+        }
+        
+        return (char) 0;
+    }
+    
+    /**
+     * Set the entire map
+     */
+    public void setMap(byte[] glyphIndex) {
+        if (glyphIndex.length != 256) {
+            throw new IllegalArgumentException("Glyph map must be size 256!");
+        }
+        
+        this.glyphIndex = glyphIndex;
+    }
+    
+    /**
+     * Set a single mapping entry
+     */
+    public void setMap(byte src, byte dest) {
+        int i = 0xff & src;
+        
+        glyphIndex[i] = dest;
+    }
+    
+    /**
+     * Get the whole map
+     */
+    protected byte[] getMap() {
+        return glyphIndex;
+    }
+    
+    /**
+     * Get the data in this map as a ByteBuffer
+     */
+    public ByteBuffer getData() {
+        ByteBuffer buf = ByteBuffer.allocate(262);
+        
+        buf.putShort(getFormat());
+        buf.putShort(getLength());
+        buf.putShort(getLanguage());
+        buf.put(getMap());
+        
+        // reset the position to the beginning of the buffer
+        buf.flip();
+        
+        return buf;
+    }
+    
+    /** 
+     * Read the map in from a byte buffer
+     */
+    public void setData(int length, ByteBuffer data) {
+        if (length != 262) {
+            throw new IllegalArgumentException("Bad length for CMap format 0");
+        }
+        
+        if (data.remaining() != 256) {
+            throw new IllegalArgumentException("Wrong amount of data for CMap format 0");
+        }
+        
+        byte[] map = new byte[256];
+        data.get(map);
+        
+        setMap(map);
+    }
+}

src/com/sun/pdfview/font/ttf/CMapFormat4.java

@@ -0,0 +1,458 @@
+/*
+ * $Id: CMapFormat4.java,v 1.3 2009/02/12 13:53:57 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package com.sun.pdfview.font.ttf;
+
+import net.sf.andpdf.pdfviewer.ByteBuffer;
+
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.SortedMap;
+import java.util.TreeMap;
+
+/**
+ *
+ * @author  jkaplan
+ */
+public class CMapFormat4 extends CMap {
+   
+    /**
+     * The segments and associated data can be a char[] or an Integer
+     */
+    public SortedMap<Segment,Object> segments;
+    
+    /** Creates a new instance of CMapFormat0 */
+    protected CMapFormat4(short language) {
+        super((short) 4, language);
+    
+        segments = Collections.synchronizedSortedMap(new TreeMap<Segment,Object>());
+        
+        char[] map = new char[1];
+        map[0] = (char) 0;
+        addSegment((short) 0xffff, (short) 0xffff, map);
+    }
+    
+    /**
+     * Add a segment with a map 
+     */
+    public void addSegment(short startCode, short endCode, char[] map) {
+        if (map.length != (endCode - startCode) + 1) {
+            throw new IllegalArgumentException("Wrong number of entries in map");
+        }
+        
+        Segment s = new Segment(startCode, endCode, true);
+        // make sure we remove any old entries
+        segments.remove(s);
+        segments.put(s, map);
+    }
+    
+    /**
+     * Add a segment with an idDelta
+     */
+    public void addSegment(short startCode, short endCode, short idDelta) {
+        Segment s = new Segment(startCode, endCode, false);
+        // make sure we remove any old entries
+        segments.remove(s);
+        segments.put(s, new Integer(idDelta));
+    }
+    
+    /**
+     * Remove a segment
+     */
+    public void removeSegment(short startCode, short endCode) {
+        Segment s = new Segment(startCode, endCode, true);
+        segments.remove(s);
+    }
+    
+    /**
+     * Get the length of this table
+     */
+    public short getLength() {
+        // start with the size of the fixed header
+        short size = 16;
+        
+        // add the size of each segment header
+        size += segments.size() * 8;
+        
+        // add the total number of mappings times the size of a mapping
+        for (Iterator i = segments.keySet().iterator(); i.hasNext();) {
+            Segment s = (Segment) i.next();
+            
+            // see if there's a map
+            if (s.hasMap) {
+                // if there is, add its size
+                char[] map = (char[]) segments.get(s);
+                size += map.length * 2;
+            }
+        }
+        
+        return size;
+    }
+    
+    /** 
+     * Cannot map from a byte
+     */
+    public byte map(byte src) {
+        char c = map((char) src);
+        if (c < Byte.MIN_VALUE || c > Byte.MAX_VALUE) {
+            // out of range
+            return 0;
+        }
+    
+        return (byte) c;
+    }
+    
+    /**
+     * Map from char
+     */
+    public char map(char src) {
+        // find first segment with endcode > src
+        for (Iterator i = segments.keySet().iterator(); i.hasNext();) {
+            Segment s = (Segment) i.next();
+            
+            if (s.endCode >= src) {
+                // are we within range?
+                if (s.startCode <= src) {
+                    if (s.hasMap) {
+                        // return the index of this character in 
+                        // the segment's map
+                        char[] map = (char[]) segments.get(s);
+                        return map[src - s.startCode];
+                    } else {
+                        // return the character code + idDelta
+                        Integer idDelta = (Integer) segments.get(s);
+                        return (char) (src + idDelta.intValue());
+                    }
+                } else {
+                    // undefined character
+                    return (char) 0;
+                }
+            }
+        }
+        
+        // shouldn't get here!
+        return (char) 0;
+    }
+    
+    /**
+     * Get the src code which maps to the given glyphID
+     */
+    public char reverseMap(short glyphID) {
+        // look at each segment
+        for (Iterator i = segments.keySet().iterator(); i.hasNext();) {
+            Segment s = (Segment) i.next();
+            
+            // see if we have a map or a delta
+            if (s.hasMap) {
+                char[] map = (char[]) segments.get(s);
+                
+                // if we have a map, we have to iterate through it
+                for (int c = 0; c < map.length; c++) {
+                    if (map[c] == glyphID) {
+                        return (char) (s.startCode + c);
+                    }
+                }
+            } else {
+                Integer idDelta = (Integer) segments.get(s);
+                
+                // we can do the math to see if we're in range
+                int start = s.startCode + idDelta.intValue();
+                int end = s.endCode + idDelta.intValue();
+                
+                if (glyphID >= start && glyphID <= end) {
+                    // we're in the range
+                    return (char) (glyphID - idDelta.intValue());
+                }
+            }
+        }
+        
+        // not found!
+        return (char) 0;
+    }
+    
+    
+    /**
+     * Get the data in this map as a ByteBuffer
+     */
+    public void setData(int length, ByteBuffer data) {
+        // read the table size values
+        short segCount = (short) (data.getShort() / 2);
+        short searchRange = data.getShort();
+        short entrySelector = data.getShort();
+        short rangeShift = data.getShort();
+    
+        // create arrays to store segment info
+        short[] endCodes = new short[segCount];
+        short[] startCodes = new short[segCount];
+        short[] idDeltas = new short[segCount];
+        short[] idRangeOffsets = new short[segCount];
+          
+        // the start of the glyph array
+        int glyphArrayPos = 16 + (8 * segCount);
+        
+        // read the endCodes
+        for (int i = 0; i < segCount; i++) {
+           endCodes[i] = data.getShort();
+        }
+        
+        // read the pad
+        data.getShort();
+        
+        // read the start codes
+        for (int i = 0; i < segCount; i++) {
+            startCodes[i] = data.getShort();
+        }
+        
+        // read the idDeltas
+        for (int i = 0; i < segCount; i++) {
+            idDeltas[i] = data.getShort();
+        }
+        
+        // read the id range offsets
+        for (int i = 0; i < segCount; i++) {
+            idRangeOffsets[i] = data.getShort();
+            
+            // calculate the actual offset
+            if (idRangeOffsets[i] <= 0) {
+                // the easy way
+                addSegment(startCodes[i], endCodes[i], idDeltas[i]);
+            } else {
+                // find the start of the data segment
+                int offset = (data.position() - 2) + idRangeOffsets[i];
+            
+                // get the number of entries in the map
+                int size = (endCodes[i] - startCodes[i]) + 1;
+            
+                // allocate the actual map
+                char[] map = new char[size];
+                
+                // remember our offset
+                data.mark();
+                 
+                // read the mappings    
+                for (int c = 0; c < size; c++) {
+                    data.position(offset + (c * 2));
+                    map[c] = data.getChar();
+                }
+      
+                // reset the position
+                data.reset();
+                
+                addSegment(startCodes[i], endCodes[i], map);
+            }
+        }       
+    }
+    
+    /** 
+     * Get the data in the map as a byte buffer
+     */
+    public ByteBuffer getData() {
+        ByteBuffer buf = ByteBuffer.allocate(getLength());
+    
+        // write the header
+        buf.putShort(getFormat());
+        buf.putShort((short) getLength());
+        buf.putShort(getLanguage());
+        
+        // write the various values
+        buf.putShort((short) (getSegmentCount() * 2));
+        buf.putShort(getSearchRange());
+        buf.putShort(getEntrySelector());
+        buf.putShort(getRangeShift());
+        
+        // write the endCodes
+        for (Iterator i = segments.keySet().iterator(); i.hasNext();) {
+            Segment s = (Segment) i.next();
+            buf.putShort((short) s.endCode);
+        }
+        
+        // write the pad
+        buf.putShort((short) 0);
+        
+        // write the startCodes
+        for (Iterator i = segments.keySet().iterator(); i.hasNext();) {
+            Segment s = (Segment) i.next();
+            buf.putShort((short) s.startCode);
+        }
+        
+        // write the idDeltas for segments using deltas
+        for (Iterator i = segments.keySet().iterator(); i.hasNext();) {
+            Segment s = (Segment) i.next();
+            
+            if (!s.hasMap) {
+                Integer idDelta = (Integer) segments.get(s);
+                buf.putShort(idDelta.shortValue());
+            } else {
+                buf.putShort((short) 0);
+            }
+        }
+        
+        // the start of the glyph array
+        int glyphArrayOffset = 16 + (8 * getSegmentCount());
+        
+        // write the idRangeOffsets and maps for segments using maps
+        for (Iterator i = segments.keySet().iterator(); i.hasNext();) {
+            Segment s = (Segment) i.next();
+            
+            if (s.hasMap) {
+                // first set the offset, which is the number of bytes from the
+                // current position to the current offset
+                buf.putShort((short) (glyphArrayOffset - buf.position()));
+                
+                // remember the current position
+                buf.mark();
+                
+                // move the position to the offset
+                buf.position(glyphArrayOffset);
+                
+                // now write the map
+                char[] map = (char[]) segments.get(s);
+                for (int c = 0; c < map.length; c++) {
+                    buf.putChar(map[c]);
+                }
+                
+                // reset the data pointer
+                buf.reset();
+                
+                // update the offset
+                glyphArrayOffset += map.length * 2;
+            } else {
+                buf.putShort((short) 0);
+            }
+        }
+
+        // make sure we are at the end of the buffer before we flip
+        buf.position(glyphArrayOffset);
+        
+        // reset the data pointer
+        buf.flip();
+        
+        return buf;
+    }
+    
+    /**
+     * Get the segment count
+     */
+    public short getSegmentCount() {
+        return (short) segments.size();
+    }
+    
+    /**
+     * Get the search range
+     */
+    public short getSearchRange() {
+        double pow = Math.floor(Math.log(getSegmentCount()) / Math.log(2));
+        double pow2 = Math.pow(2, pow);
+        
+        return (short) (2 * pow2);
+    }
+    
+    /**
+     * Get the entry selector
+     */
+    public short getEntrySelector() {
+        int sr2 = getSearchRange() / 2;
+        return (short) (Math.log(sr2) / Math.log(2));
+    }
+    
+    /**
+     * Get the rangeShift()
+     */
+    public short getRangeShift() {
+        return (short) ((2 * getSegmentCount()) - getSearchRange());
+    }
+    
+    /** Get a pretty string */
+    @Override public String toString() {
+        StringBuffer buf = new StringBuffer();
+        String indent = "        ";
+        
+        buf.append(super.toString());
+        buf.append(indent + "SegmentCount : " + getSegmentCount() + "\n");
+        buf.append(indent + "SearchRange  : " + getSearchRange() + "\n");
+        buf.append(indent + "EntrySelector: " + getEntrySelector() + "\n");
+        buf.append(indent + "RangeShift   : " + getRangeShift() + "\n");
+        
+        for (Iterator i = segments.keySet().iterator(); i.hasNext();) {
+            Segment s = (Segment) i.next();
+            
+            buf.append(indent);
+            buf.append("Segment: " + Integer.toHexString(s.startCode));
+            buf.append("-" + Integer.toHexString(s.endCode) + " ");
+            buf.append("hasMap: " + s.hasMap + " ");
+            
+            if (!s.hasMap) {
+                buf.append("delta: " + segments.get(s));
+            }
+            
+            buf.append("\n");
+        }
+        
+        return buf.toString();
+    }
+    
+    class Segment implements Comparable {
+        /** the end code (highest code in this segment) */
+        int endCode;
+        
+        /** the start code (lowest code in this segment) */
+        int startCode;
+        
+        /** whether it is a map or a delta */
+        boolean hasMap;
+        
+        /** Create a new segment */
+        public Segment(short startCode, short endCode, boolean hasMap) {
+            // convert from unsigned short
+            this.endCode   = (0xffff & endCode);
+            this.startCode = (0xffff & startCode);
+            
+            this.hasMap = hasMap;
+        }
+        
+        /** Equals based on compareTo (only compares endCode) */
+        @Override public boolean equals(Object o) {
+            return (compareTo(o) == 0);
+        }
+        
+        /** Segments sort by increasing endCode */
+        public int compareTo(Object o) {
+            if (!(o instanceof Segment)) {
+                return -1;
+            }
+            
+            Segment s = (Segment) o;
+        
+            // if regions overlap at all, declare the segments equal,
+            // to avoid overlap in the segment list
+            if (((s.endCode >= startCode) && (s.endCode <= endCode)) ||
+                ((s.startCode >= startCode) && (s.startCode <= endCode))) {
+                return 0;
+            } if (endCode > s.endCode) {
+                return 1;
+            } else if (endCode < s.endCode) {
+                return -1;
+            } else {
+                return 0;
+            }
+        }
+    }
+}

src/com/sun/pdfview/font/ttf/CMapFormat6.java

@@ -0,0 +1,137 @@
+/*
+ * $Id: CMapFormat6.java,v 1.1 2009/02/16 00:26:24 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package com.sun.pdfview.font.ttf;
+
+import net.sf.andpdf.pdfviewer.ByteBuffer;
+
+import java.util.*;
+
+/**
+ *
+ * @author  jkaplan
+ */
+public class CMapFormat6 extends CMap {
+    /** First character code of subrange. */
+    private short firstCode;
+    /** Number of character codes in subrange. */
+    private short entryCount;
+    /** Array of glyph index values for character codes in the range. */
+    private short [] glyphIndexArray;
+    /** a reverse lookup from glyph id to index. */
+    private HashMap<Short,Short> glyphLookup = new HashMap<Short,Short>();
+
+    /** Creates a new instance of CMapFormat0 */
+    protected CMapFormat6(short language) {
+        super((short) 6, language);
+    }
+
+    /**
+     * Get the length of this table
+     */
+    public short getLength() {
+        // start with the size of the fixed header
+        short size = 5 * 2;
+
+        // add the size of each segment header
+        size += entryCount * 2;
+        return size;
+    }
+
+    /**
+     * Cannot map from a byte
+     */
+    public byte map(byte src) {
+        char c = map((char) src);
+        if (c < Byte.MIN_VALUE || c > Byte.MAX_VALUE) {
+            // out of range
+            return 0;
+        }
+        return (byte) c;
+    }
+
+    /**
+     * Map from char
+     */
+    public char map(char src) {
+
+        // find first segment with endcode > src
+        if (src < firstCode || src > (firstCode + entryCount)) {
+            // Codes outside of the range are assumed to be missing and are
+            // mapped to the glyph with index 0
+            return '\000';
+        }
+        return (char) glyphIndexArray[src - firstCode];
+    }
+
+    /**
+     * Get the src code which maps to the given glyphID
+     */
+    public char reverseMap(short glyphID) {
+        Short result = glyphLookup.get(new Short(glyphID));
+        if (result == null) {
+            return '\000';
+        }
+        return (char) result.shortValue();
+    }
+
+
+    /**
+     * Get the data in this map as a ByteBuffer
+     */
+    public void setData(int length, ByteBuffer data) {
+        // read the table size values
+        firstCode = data.getShort();
+        entryCount = data.getShort();
+
+        glyphIndexArray = new short [entryCount];
+        for (int i = 0; i < glyphIndexArray.length; i++) {
+            glyphIndexArray[i] = data.getShort();
+            glyphLookup.put(new Short(glyphIndexArray[i]),
+                            new Short((short) (i + firstCode)));
+        }
+    }
+
+    /**
+     * Get the data in the map as a byte buffer
+     */
+    public ByteBuffer getData() {
+        ByteBuffer buf = ByteBuffer.allocate(getLength());
+
+        // write the header
+        buf.putShort(getFormat());
+        buf.putShort((short) getLength());
+        buf.putShort(getLanguage());
+
+        // write the various values
+        buf.putShort(firstCode);
+        buf.putShort(entryCount);
+
+        // write the endCodes
+        for (int i = 0; i < glyphIndexArray.length; i++) {
+            buf.putShort(glyphIndexArray[i]);
+        }
+        // reset the data pointer
+        buf.flip();
+
+        return buf;
+    }
+}

src/com/sun/pdfview/font/ttf/CmapTable.java

@@ -0,0 +1,278 @@
+/*
+ * $Id: CmapTable.java,v 1.3 2009/02/12 13:53:57 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package com.sun.pdfview.font.ttf;
+
+import net.sf.andpdf.pdfviewer.ByteBuffer;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.SortedMap;
+import java.util.TreeMap;
+
+/**
+ * Represents the TTF "cmap" table
+ *
+ * @author  jkaplan
+ */
+public class CmapTable extends TrueTypeTable {
+    
+    /** Holds value of property version. */
+    private short version;
+    
+    /**
+     * Holds the CMap subtables, sorted properly
+     */
+    private SortedMap<CmapSubtable,CMap> subtables;
+    
+    /** Creates a new instance of CmapTable */
+    protected CmapTable() {
+        super(TrueTypeTable.CMAP_TABLE);
+        
+        setVersion((short) 0x0);
+    
+        subtables = Collections.synchronizedSortedMap(new TreeMap<CmapSubtable,CMap>());
+    }
+    
+      /**
+     * Add a CMap
+     */
+    public void addCMap(short platformID, short platformSpecificID,
+                        CMap cMap) {
+        CmapSubtable key = new CmapSubtable(platformID, platformSpecificID);
+        subtables.put(key, cMap);
+    }
+    
+    /**
+     * Get a CMap by platform and specific ID
+     */
+    public CMap getCMap(short platformID, short platformSpecificID) {
+        CmapSubtable key = new CmapSubtable(platformID, platformSpecificID);
+        return (CMap) subtables.get(key);
+    }
+    
+    /**
+     * Get all CMaps
+     */
+    public CMap[] getCMaps() {
+        Collection<CMap> c = subtables.values();
+        CMap[] maps = new CMap[c.size()];
+        
+        c.toArray(maps);
+        
+        return maps;
+    }
+    
+    /**
+     * Remove a CMap
+     */
+    public void removeCMap(short platformID, short platformSpecificID) {
+        CmapSubtable key = new CmapSubtable(platformID, platformSpecificID);
+        subtables.remove(key);
+    }
+    
+    @Override public void setData(ByteBuffer data) {
+        setVersion(data.getShort());
+        
+        short numberSubtables = data.getShort();
+        
+        for (int i = 0; i < numberSubtables; i++) {
+            short platformID = data.getShort();
+            short platformSpecificID = data.getShort();
+            int offset = data.getInt();
+            
+            data.mark();
+            
+            // get the position from the start of this buffer 
+            data.position(offset);
+            
+            ByteBuffer mapData = data.slice();
+            
+            data.reset();
+            
+            try {
+                CMap cMap = CMap.getMap(mapData);
+                if (cMap != null) {
+                    addCMap(platformID, platformSpecificID, cMap);
+                }
+            } catch (Exception ex) {
+                System.out.println("Error reading map.  PlatformID=" +
+                                    platformID + ", PlatformSpecificID=" + 
+                                    platformSpecificID);
+                System.out.println("Reason: " + ex);
+            }
+        }
+    }
+    
+    @Override public ByteBuffer getData() {
+        ByteBuffer buf = ByteBuffer.allocate(getLength());
+    
+        // write the table header
+        buf.putShort(getVersion());
+        buf.putShort((short) subtables.size());
+        
+        // the current offset to write to, starts at the end of the
+        // subtables
+        int curOffset = 4 + (subtables.size() * 8);
+        
+        // write the subtables
+        for (Iterator i = subtables.keySet().iterator(); i.hasNext();) {
+            CmapSubtable cms = (CmapSubtable) i.next();
+            CMap map = (CMap) subtables.get(cms);
+            
+            buf.putShort(cms.platformID);
+            buf.putShort(cms.platformSpecificID);
+            buf.putInt(curOffset);
+            
+            curOffset += map.getLength();
+        }
+        
+        // write the tables
+        for (Iterator i = subtables.values().iterator(); i.hasNext();) {
+            CMap map = (CMap) i.next();
+            buf.put(map.getData());
+        }
+        
+        // reset the position to the start of the buffer
+        buf.flip();
+        
+        return buf;
+    }
+    
+    /**
+     * Get the size of the table, in bytes
+     */
+    @Override public int getLength() {
+        // start with the size of the fixed data
+        int length = 4;
+       
+        // add the size of the subtables 
+        length += subtables.size() * 8;
+        
+        // add the size of the dynamic data
+        for (Iterator i = subtables.values().iterator(); i.hasNext();) {     
+            // add the size of the subtable data
+            CMap map = (CMap) i.next();
+            length += map.getLength();
+        }
+    
+        return length;
+    }
+    
+    
+    /** Getter for property version.
+     * @return Value of property version.
+     *
+     */
+    public short getVersion() {
+        return this.version;
+    }
+    
+    /** Setter for property version.
+     * @param version New value of property version.
+     *
+     */
+    public void setVersion(short version) {
+        this.version = version;
+    }
+
+    /**
+     * Get the number of tables
+     */
+    public short getNumberSubtables() {
+        return (short) subtables.size();
+    }
+    
+    /** Print a pretty string */
+    @Override public String toString() {
+        StringBuffer buf = new StringBuffer();
+        String indent = "    ";
+    
+        buf.append(indent + "Version: " + this.getVersion() + "\n");
+        buf.append(indent + "NumMaps: " + this.getNumberSubtables() + "\n");
+        
+        for (Iterator i = subtables.keySet().iterator(); i.hasNext();) {
+            CmapSubtable key = (CmapSubtable) i.next();
+            
+            buf.append(indent + "Map: platformID: " + key.platformID +
+                       " PlatformSpecificID: " + key.platformSpecificID + "\n");
+            
+            CMap map = (CMap) subtables.get(key);
+            
+            buf.append(map.toString());
+        }
+        
+        return buf.toString();
+    }
+    
+    class CmapSubtable implements Comparable {
+        /**
+         * The platformID for this subtable
+         */
+        short platformID;
+        
+        /**
+         * The platform-specific id
+         */
+        short platformSpecificID;
+        
+        /** 
+         * Create a Cmap subtable
+         */
+        protected CmapSubtable(short platformID, short platformSpecificID) {
+            this.platformID = platformID;
+            this.platformSpecificID = platformSpecificID;
+        }
+            
+        /**
+         * Compare two subtables
+         */
+        @Override public boolean equals(Object obj) {
+            return (compareTo(obj) == 0);
+        }
+        
+        /**
+         * Sort ascending by platform ID and then specific ID
+         */
+        public int compareTo(Object obj) {
+            if (!(obj instanceof CmapSubtable)) {
+                return -1;
+            }
+            
+            CmapSubtable cms = (CmapSubtable) obj;
+            if (platformID < cms.platformID) {
+                return -1;
+            } else if (platformID > cms.platformID) {
+                return 1;
+            } else {
+                if (platformSpecificID < cms.platformSpecificID) {
+                    return -1;
+                } else if (platformSpecificID > cms.platformSpecificID) {
+                    return 1;
+                } else {
+                    return 0;
+                }
+            }
+        }
+    }
+    
+}

src/com/sun/pdfview/font/ttf/Glyf.java

@@ -0,0 +1,208 @@
+/*
+ * $Id: Glyf.java,v 1.2 2007/12/20 18:33:31 rbair Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package com.sun.pdfview.font.ttf;
+
+import net.sf.andpdf.pdfviewer.ByteBuffer;
+
+/**
+ * A single glyph in a pdf font.  May be simple or compound via subclasses
+ */
+public class Glyf {
+    /** If true, the glyf is compound */
+    private boolean isCompound;
+    
+    /** the number of contours */
+    private short numContours;
+    
+    /** the minimum x value */
+    private short minX;
+    
+    /** the minimum y value */
+    private short minY;
+    
+    /** the maximum x value */
+    private short maxX;
+    
+    /** the maximum y value */
+    private short maxY;
+    
+    /** 
+     * Creates a new instance of glyf 
+     * Don't use this directly, use <code>Glyf.getGlyf()</code>
+     */
+    protected Glyf() {
+    }
+    
+    /**
+     * Get a map from the given data
+     *
+     * This method reads the format, data and length variables of
+     * the map.
+     */
+    public static Glyf getGlyf(ByteBuffer data) {
+        short numContours = data.getShort();
+        
+        Glyf g = null;
+        if (numContours == 0) {
+            // no glyph data
+            g = new Glyf();
+        } else if (numContours == -1) {
+            // compound glyf
+            g = new GlyfCompound();
+        } else if (numContours > 0) {
+            // simple glyf
+            g = new GlyfSimple();
+        } else {
+            throw new IllegalArgumentException("Unknown glyf type: " + 
+                                               numContours);
+        }
+        
+        g.setNumContours(numContours);
+        g.setMinX(data.getShort());
+        g.setMinY(data.getShort());
+        g.setMaxX(data.getShort());
+        g.setMaxY(data.getShort());
+        
+        // do glyphtype-specific parsing
+        g.setData(data);
+    
+        return g;
+    }
+   
+    /**
+     * Set the data for this glyf.  Do nothing, since a glyf with
+     * no contours has no glyf data.
+     */
+    public void setData(ByteBuffer data) {
+        return;
+    }
+    
+    /**
+     * Get the data in this glyf as a byte buffer.  Return the basic
+     * glyf data only, since there is no specific data.  This method returns
+     * the data un-flipped, so subclasses can simply append to the allocated
+     * buffer.
+     */
+    public ByteBuffer getData() {
+        ByteBuffer buf = ByteBuffer.allocate(getLength());
+        
+        buf.putShort(getNumContours());
+        buf.putShort(getMinX());
+        buf.putShort(getMinY());
+        buf.putShort(getMaxX());
+        buf.putShort(getMaxY());
+        
+        // don't flip the buffer, since it may be used by subclasses
+        return buf;
+    }
+    
+    /**
+     * Get the length of this glyf.  A glyf with no data has a length
+     * of 10 (2 bytes each for 5 short values)
+     */
+    public short getLength() {
+        return 10;
+    }
+    
+    /**
+     * Get whether this is a simple or compound glyf
+     */
+    public boolean isCompound() {
+        return isCompound;
+    }
+    
+    /** 
+     * Set whether this is a simple or compound glyf
+     */
+    protected void setCompound(boolean isCompound) {
+        this.isCompound = isCompound;
+    }
+    
+    /**
+     * Get the number of contours in this glyf
+     */
+    public short getNumContours() {
+        return numContours;
+    }
+    
+    /**
+     * Set the number of contours in this glyf
+     */
+    protected void setNumContours(short numContours) {
+        this.numContours = numContours;
+    }
+    
+    /**
+     * Get the minimum x in this glyf
+     */
+    public short getMinX() {
+        return minX;
+    }
+    
+    /**
+     * Set the minimum X in this glyf
+     */
+    protected void setMinX(short minX) {
+        this.minX = minX;
+    }
+    
+    /**
+     * Get the minimum y in this glyf
+     */
+    public short getMinY() {
+        return minY;
+    }
+    
+    /**
+     * Set the minimum Y in this glyf
+     */
+    protected void setMinY(short minY) {
+        this.minY = minY;
+    }
+    /**
+     * Get the maximum x in this glyf
+     */
+    public short getMaxX() {
+        return maxX;
+    }
+    
+    /**
+     * Set the maximum X in this glyf
+     */
+    protected void setMaxX(short maxX) {
+        this.maxX = maxX;
+    }
+    
+    /**
+     * Get the maximum y in this glyf
+     */
+    public short getMaxY() {
+        return maxY;
+    }
+    
+    /**
+     * Set the maximum Y in this glyf
+     */
+    protected void setMaxY(short maxY) {
+        this.maxY = maxY;
+    }
+}

src/com/sun/pdfview/font/ttf/GlyfCompound.java

@@ -0,0 +1,332 @@
+/*
+ * $Id: GlyfCompound.java,v 1.3 2009/02/12 13:53:57 tomoke Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package com.sun.pdfview.font.ttf;
+
+import net.sf.andpdf.pdfviewer.ByteBuffer;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A single simple glyph in a pdf font.
+ */
+public class GlyfCompound extends Glyf {
+    /** flags */
+    private static final int ARG_1_AND_2_ARE_WORDS    = 0x1;
+    private static final int ARGS_ARE_XY_VALUES       = 0x2;
+    private static final int ROUND_XY_TO_GRID         = 0x4;
+    private static final int WE_HAVE_A_SCALE          = 0x8;
+    private static final int MORE_COMPONENTS          = 0x20;
+    private static final int WE_HAVE_AN_X_AND_Y_SCALE = 0x40; 
+    private static final int WE_HAVE_A_TWO_BY_TWO     = 0x80;
+    private static final int WE_HAVE_INSTRUCTIONS     = 0x100;
+    private static final int USE_MY_METRICS 	      = 0x200;
+    private static final int OVERLAP_COMPOUND         = 0x400;
+
+    /** the flags for each compound glyph */
+    private GlyfComponent[] components;
+    
+    /** the instructions for the compound as a whole */
+    private byte[] instructions;
+    
+    /**
+     * Creates a new instance of a simple glyf
+     */
+    protected GlyfCompound() {
+    }
+    
+    /**
+     * Set the data for this glyf.
+     */
+    @Override public void setData(ByteBuffer data) {
+        // int pos = data.position();
+        // byte[] prdata = new byte[data.remaining()];
+        // data.get(prdata);
+        // HexDump.printData(prdata);
+        // data.position(pos);
+              
+        // read the contour end points
+        List<GlyfComponent> comps = new ArrayList<GlyfComponent>();
+        GlyfComponent cur = null;
+        boolean hasInstructions = false;
+        
+        do {
+            cur = new GlyfComponent();
+            cur.flags = data.getShort();
+            cur.glyphIndex = data.getShort();
+          
+            // read either e/f or matching points, as shorts or bytes...
+            if (((cur.flags & ARG_1_AND_2_ARE_WORDS) != 0) &&
+                ((cur.flags & ARGS_ARE_XY_VALUES) != 0)) {
+                cur.e = data.getShort();
+                cur.f = data.getShort();
+            } else if (!((cur.flags & ARG_1_AND_2_ARE_WORDS) != 0) &&
+                        ((cur.flags & ARGS_ARE_XY_VALUES) != 0)) {
+                cur.e = (float) data.get();
+                cur.f = (float) data.get();
+            } else if ( ((cur.flags & ARG_1_AND_2_ARE_WORDS) != 0) &&
+                       !((cur.flags & ARGS_ARE_XY_VALUES) != 0)) {
+                cur.compoundPoint = data.getShort();
+                cur.componentPoint = data.getShort();
+            } else {
+                cur.compoundPoint = data.get();
+                cur.componentPoint = data.get();
+            }
+         
+            // read the linear transform
+            if ((cur.flags & WE_HAVE_A_SCALE) != 0) {
+                cur.a = (float) data.getShort() / (float) (1 << 14);
+                cur.d = cur.a;
+            } else if ((cur.flags & WE_HAVE_AN_X_AND_Y_SCALE) != 0) {
+                cur.a = (float) data.getShort() / (float) (1 << 14);
+                cur.d = (float) data.getShort() / (float) (1 << 14);
+            } else if ((cur.flags & WE_HAVE_A_TWO_BY_TWO) != 0) {
+                cur.a = (float) data.getShort() / (float) (1 << 14);
+                cur.b = (float) data.getShort() / (float) (1 << 14);
+                cur.c = (float) data.getShort() / (float) (1 << 14);
+                cur.d = (float) data.getShort() / (float) (1 << 14);
+            }
+        
+            if ((cur.flags & WE_HAVE_INSTRUCTIONS) != 0) {
+  	        hasInstructions = true;
+            }
+
+            comps.add(cur);
+        } while ((cur.flags & MORE_COMPONENTS) != 0);
+
+        GlyfComponent[] componentArray = new GlyfComponent[comps.size()];
+        comps.toArray(componentArray);
+        setComponents(componentArray);
+        
+        byte[] instr = null;
+        if (hasInstructions) {
+            // read the instructions
+            short numInstructions = data.getShort();
+            instr = new byte[numInstructions];
+            for (int i = 0; i < instr.length; i++) {
+                instr[i] = data.get();
+            }
+        } else {
+            instr = new byte[0];
+        }
+        setInstructions(instr);
+    }
+    
+    /**
+     * Get the data in this glyf as a byte buffer.  Not implemented.
+     */
+    @Override public ByteBuffer getData() {
+        ByteBuffer buf = super.getData();
+        
+        // don't flip the buffer, since it may be used by subclasses
+        return buf;
+    }
+    
+    /**
+     * Get the length of this glyf.  Not implemented.
+     */
+    @Override public short getLength() {
+        
+        // start with the length of the superclass
+        short length = super.getLength();
+        return length;
+    }
+    
+    /**
+     * Get the number of components in this compound
+     */
+    public int getNumComponents() {
+        return components.length;
+    }
+    
+    /**
+     * Get a given flag
+     */
+    public short getFlag(int index) {
+        return components[index].flags;
+    }
+    
+    /**
+     * Get the glyf index for a given glyf
+     */
+    public short getGlyphIndex(int index) {
+        return components[index].glyphIndex;
+    }
+    
+    /**
+     * Get the base affine transform.  This is based on a whacy formula
+     * defined in the true type font spec.
+     */
+    public float[] getTransform(int index) {
+        GlyfComponent gc = components[index];
+
+        float m = (float) Math.max(Math.abs(gc.a), Math.abs(gc.b));
+        if (Math.abs(Math.abs(gc.a) - Math.abs(gc.c)) < (33 / 65536)) {
+            m *= 2;
+        }
+
+	float n = (float) Math.max(Math.abs(gc.c), Math.abs(gc.d));
+        if (Math.abs(Math.abs(gc.c) - Math.abs(gc.d)) < (33 / 65536)) {
+            n *= 2;
+        }
+        
+        float e = m * gc.e;
+        float f = n * gc.f;
+        
+        return new float[] { gc.a, gc.b, gc.c, gc.d, e, f }; 
+    }
+  
+    /**
+     * Get the point in the compound glyph to match
+     */
+    public int getCompoundPoint(int index) {
+        return components[index].compoundPoint;
+    }
+    
+    /**
+     * Get the point in the component glyph to match
+     */
+    public int getComponentPoint(int index) {
+        return components[index].componentPoint;
+    }
+ 
+    /**
+     * Determine whether args 1 and 2 are words or bytes
+     */
+    public boolean argsAreWords(int index) {
+        return ((getFlag(index) & ARG_1_AND_2_ARE_WORDS) != 0);
+    }
+    
+    /**
+     * Determine whether args 1 and 2 are xy values or point indices
+     */
+    public boolean argsAreXYValues(int index) {
+        return ((getFlag(index) & ARGS_ARE_XY_VALUES) != 0);
+    }
+    
+    /**
+     * Determine whether to round XY values to the grid
+     */
+    public boolean roundXYToGrid(int index) {
+        return ((getFlag(index) & ROUND_XY_TO_GRID) != 0);
+    }
+    
+    /**
+     * Determine whether there is a simple scale
+     */
+    public boolean hasAScale(int index) {
+        return ((getFlag(index) & WE_HAVE_A_SCALE) != 0);
+    }
+    
+    /**
+     * Determine whether there are more components left to read
+     */
+    protected boolean moreComponents(int index) {
+        return ((getFlag(index) & MORE_COMPONENTS) != 0);
+    }
+    
+    /**
+     * Determine whether there are separate scales on X and Y
+     */
+    protected boolean hasXYScale(int index) {
+        return ((getFlag(index) & WE_HAVE_AN_X_AND_Y_SCALE) != 0);
+    }
+    
+    /**
+     * Determine whether there is a 2x2 transform
+     */
+    protected boolean hasTwoByTwo(int index) {
+        return ((getFlag(index) & WE_HAVE_A_TWO_BY_TWO) != 0);
+    }
+    
+    /**
+     * Determine whether there are instructions
+     */
+    protected boolean hasInstructions(int index) {
+        return ((getFlag(index) & WE_HAVE_INSTRUCTIONS) != 0);
+    }
+    
+    /**
+     * Use the metrics of this component for the compound
+     */
+    public boolean useMetrics(int index) {
+        return ((getFlag(index) & USE_MY_METRICS) != 0);
+    }
+    
+    /**
+     * This component overlaps the existing compound
+     */
+    public boolean overlapCompound(int index) {
+        return ((getFlag(index) & OVERLAP_COMPOUND) != 0);
+    }
+    
+    /**
+     * Set the components
+     */
+    void setComponents(GlyfComponent[] components) {
+        this.components = components;
+    }
+    
+   /**
+    * Get the number of instructions
+    */
+    public short getNumInstructions() {
+        return (short) instructions.length;
+    }
+    
+    /**
+     * Get a given instruction
+     */
+    public byte getInstruction(int index) {
+        return instructions[index];
+    }
+    
+    /**
+     * Set the instructions
+     */
+    protected void setInstructions(byte[] instructions) {
+        this.instructions = instructions;
+    }
+    
+    /**
+     * The record for a single component of this compound glyph
+     */
+    class GlyfComponent {
+        /** flags */
+        short flags;
+        
+        /** the index of the component glyf */
+        short glyphIndex;
+        
+        /** the points to match */
+        int compoundPoint;
+        int componentPoint;
+        
+        /** affine transform of this component */
+        float a = 1.0f;
+        float b = 0.0f;
+        float c = 0.0f;
+        float d = 1.0f;
+        float e = 0.0f;
+        float f = 0.0f;
+    }
+}

src/com/sun/pdfview/font/ttf/GlyfSimple.java

@@ -0,0 +1,363 @@
+/*
+ * $Id: GlyfSimple.java,v 1.2 2007/12/20 18:33:31 rbair Exp $
+ *
+ * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
+ * Santa Clara, California 95054, U.S.A. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package com.sun.pdfview.font.ttf;
+
+import net.sf.andpdf.pdfviewer.ByteBuffer;
+
+/**
+ * A single simple glyph in a pdf font. 
+ */
+public class GlyfSimple extends Glyf {
+    /** the end points of the various contours */
+    private short[] contourEndPts;
+    
+    /** the instructions */
+    private byte[] instructions;
+    
+    /** the flags */
+    private byte[] flags;
+    
+    /** the x coordinates */
+    private short[] xCoords;
+    
+    /** the y coordinates */
+    private short[] yCoords;
+    
+    /** 
+     * Creates a new instance of a simple glyf
+     */
+    protected GlyfSimple() {
+    }
+    
+    /**
+     * Set the data for this glyf.
+     */
+    public void setData(ByteBuffer data) {
+        // int pos = data.position();
+        // byte[] prdata = new byte[data.remaining()];
+        // data.get(prdata);
+        // HexDump.printData(prdata);
+        // data.position(pos);
+        
+        
+        // read the contour end points
+        short[] contourEndPts = new short[getNumContours()];
+        for (int i = 0; i < contourEndPts.length; i++) {
+            contourEndPts[i] = data.getShort();
+        }
+        setContourEndPoints(contourEndPts);
+        
+        // the number of points in the glyf is the number of the end
+        // point in the last contour
+        int numPoints = getContourEndPoint(getNumContours() - 1) + 1;
+        
+        // read the instructions
+        short numInstructions = data.getShort();
+        byte[] instructions = new byte[numInstructions];
+        for (int i = 0; i < instructions.length; i++) {
+            instructions[i] = data.get();
+        }
+        setInstructions(instructions);
+        
+        // read the flags
+        byte[] flags = new byte[numPoints];
+        for (int i = 0; i < flags.length; i++) {
+            flags[i] = data.get();
+            
+            // check for repeats
+            if ((flags[i] & 0x8) != 0) {
+                byte f = flags[i];
+                int n = (int) (data.get() & 0xff);
+                for (int c = 0; c < n; c++) {
+                    flags[++i] =  f;
+                }
+            }
+        }
+        setFlags(flags);
+        
+        // read the x coordinates
+        short[] xCoords = new short[numPoints];
+        for (int i = 0; i < xCoords.length; i++) {
+             if (i > 0) {
+                 xCoords[i] = xCoords[i - 1];
+             }
+
+             // read this value
+            if (xIsByte(i)) {
+                int val = (int) (data.get() & 0xff);
+                if (!xIsSame(i)) {
+                    // the xIsSame bit controls the sign
+                    val = -val;
+                }
+                xCoords[i] += val;
+            } else if (!xIsSame(i)) {
+                xCoords[i] += data.getShort();
+            }
+        }
+        setXCoords(xCoords);
+        
+        // read the y coordinates
+        short[] yCoords = new short[numPoints];
+        for (int i = 0; i < yCoords.length; i++) {
+            if (i > 0) {
+                yCoords[i] = yCoords[i - 1];
+            } 
+            // read this value
+            if (yIsByte(i)) {   
+                int val = (int) (data.get() & 0xff);
+                if (!yIsSame(i)) {
+                    // the xIsSame bit controls the sign
+                    val = -val;
+                }
+                yCoords[i] += val;
+            } else if (!yIsSame(i)) {
+                yCoords[i] += data.getShort();
+            }
+        }
+        setYCoords(yCoords);
+    }
+    
+    /**
+     * Get the data in this glyf as a byte buffer.  Return the basic
+     * glyf data only, since there is no specific data.  This method returns
+     * the data un-flipped, so subclasses can simply append to the allocated
+     * buffer.
+     */
+    public ByteBuffer getData() {
+        ByteBuffer buf = super.getData();
+        
+        // write the contour end points
+        for (int i = 0; i < getNumContours(); i++) {
+            buf.putShort(getContourEndPoint(i));
+        }
+        
+        // write the instructions
+        buf.putShort(getNumInstructions());
+        for (int i = 0; i < getNumInstructions(); i++) {
+            buf.put(getInstruction(i));
+        }
+        
+        // write the flags
+        for (int i = 0; i < getNumPoints(); i++) {
+            // check for repeats
+            byte r = 0;
+            while (i > 0 && (getFlag(i) == getFlag(i - 1))) {
+                r++;
+                i++;
+            }
+            if (r > 0) {
+                buf.put(r);
+            } else {
+                buf.put(getFlag(i));
+            }
+        }
+        
+        // write the x coordinates
+        for (int i = 0; i < getNumPoints(); i++) {
+            if (xIsByte(i)) {
+                buf.put((byte) getXCoord(i));
+            } else if (!xIsSame(i)) {
+                buf.putShort(getXCoord(i));
+            }
+        }
+        
+        // write the y coordinates
+        for (int i = 0; i < getNumPoints(); i++) {
+            if (yIsByte(i)) {
+                buf.put((byte) getYCoord(i));
+            } else if (!yIsSame(i)) {
+                buf.putShort(getYCoord(i));
+            }
+        }
+        
+        // don't flip the buffer, since it may be used by subclasses
+        return buf;
+    }
+    
+    /**
+     * Get the length of this glyf. 
+     */
+    public short getLength() {
+        // start with the length of the superclass
+        short length = super.getLength();
+        
+        // add the length of the end points
+        length += getNumContours() * 2;
+        
+        // add the length of the instructions
+        length += 2 + getNumInstructions();
+        
+        // add the length of the flags, avoiding repeats
+        for (int i = 0; i < getNumPoints(); i++) {
+            // check for repeats
+            while (i > 0 && (getFlag(i) == getFlag(i - 1)));
+            length++;
+        }
+        
+        // add the length of the xCoordinates
+        for (int i = 0; i < getNumPoints(); i++) {
+            if (xIsByte(i)) {
+                length++;
+            } else if (!xIsSame(i)) {
+                length += 2;
+            }
+            
+            if (yIsByte(i)) {
+                length++;
+            } else if (!yIsSame(i)) {
+                length += 2;
+            }
+        }
+         
+        return length;
+    }
+    
+    /**
+     * Get the end point of a given contour
+     */
+    public short getContourEndPoint(int index) {
+        return contourEndPts[index];
+    }
+    
+    /**
+     * Set the number of contours in this glyf
+     */
+    protected void setContourEndPoints(short[] contourEndPts) {
+        this.contourEndPts = contourEndPts;
+    }
+    
+   /**
+    * Get the number of instructions
+    */
+    public short getNumInstructions() {
+        return (short) instructions.length;
+    }
+    
+    /**
+     * Get a given instruction
+     */
+    public byte getInstruction(int index) {
+        return instructions[index];
+    }
+    
+    /**
+     * Set the instructions
+     */
+    protected void setInstructions(byte[] instructions) {
+        this.instructions = instructions;
+    }
+    
+    /**
+     * Get the number of points in the glyf
+     */
+    public short getNumPoints() {
+        return (short) flags.length;
+    }
+    
+    /**
+     * Get a given flag
+     */
+    public byte getFlag(int pointIndex) {
+        return flags[pointIndex];
+    }
+    
+    /**
+     * Determine whether the given point is on the curve
+     */ 
+    public boolean onCurve(int pointIndex) {
+        return ((getFlag(pointIndex) & 0x1) != 0);
+    }
+    
+    /**
+     * Determine whether the x value for the given point is byte or short.
+     * If true, it is a byte, if false it is a short
+     */ 
+    protected boolean xIsByte(int pointIndex) {
+        return ((getFlag(pointIndex) & 0x2) != 0);
+    }
+    
+    /**
+     * Determine whether the x value for the given point is byte or short.
+     * If true, it is a byte, if false it is a short
+     */ 
+    protected boolean yIsByte(int pointIndex) {
+        return ((getFlag(pointIndex) & 0x4) != 0);
+    }
+    
+    /**
+     * Determine whether this flag repeats
+     */ 
+    protected boolean repeat(int pointIndex) {
+        return ((getFlag(pointIndex) & 0x8) != 0);
+    }
+    
+    /**
+     * Determine whether the x value for the given point is the same as 
+     * the previous value.
+     */ 
+    protected boolean xIsSame(int pointIndex) {
+        return ((getFlag(pointIndex) & 0x10) != 0);
+    }
+    
+    /**
+     * Determine whether the y value for the given point is the same as 
+     * the previous value.
+     */ 
+    protected boolean yIsSame(int pointIndex) {
+        return ((getFlag(pointIndex) & 0x20) != 0);
+    }
+    
+    /**
+     * Set the flags
+     */
+    protected void setFlags(byte[] flags) {
+        this.flags = flags;
+    }
+    
+    /**
+     * Get a given x coordinate
+     */
+    public short getXCoord(int pointIndex) {
+        return xCoords[pointIndex];
+    }
+    
+    /**
+     * Set the x coordinates
+     */
+    protected void setXCoords(short[] xCoords) {
+        this.xCoords = xCoords;
+    }
+    
+    /**
+     * Get a given y coordinate
+     */
+    public short getYCoord(int pointIndex) {
+        return yCoords[pointIndex];
+    }
+    
+    /**
+     * Set the x coordinates
+     */
+    protected void setYCoords(short[] yCoords) {
+        this.yCoords = yCoords;
+    }
+}