--- a/servlet/src/digilib/auth/AuthOps.java	Thu Jan 14 14:30:30 2010 +0100
+++ b/servlet/src/digilib/auth/AuthOps.java	Fri Feb 05 20:58:38 2010 +0100
@@ -20,33 +20,96 @@
 
 package digilib.auth;
 
+import java.util.List;
 
-import java.io.*;
-import java.util.*;
-import javax.servlet.http.*;
+import javax.servlet.http.HttpServletRequest;
 
+import digilib.servlet.DigilibRequest;
+
+/** Class of operations requiring authentication. */
 public interface AuthOps {
 
-  /**
-   *  check if the request must be authorized to access filepath
-   */
-  public boolean isAuthRequired(String filepath, HttpServletRequest request) throws AuthOpException;
+	/** Test if the request must be authorized to access the filepath.
+	 *
+	 * Information about the user is taken from the ServletRequest.
+	 * @param filepath filepath to be accessed.
+	 * @param request ServletRequest with user information.
+	 * @throws AuthOpException Exception thrown on error.
+	 * @return true if the user request must be authorized.
+	 */
+	public boolean isAuthRequired(String filepath, HttpServletRequest request)
+		throws AuthOpException;
 
-  /**
-   *  check if the request is allowed to access filepath
-   */
-  public boolean isAuthorized(String filepath, HttpServletRequest request) throws AuthOpException;
+	/** Test if the request must be authorized to access the filepath.
+	 *
+	 * Information about the user is taken from the DigilibRequest.
+	 * @param request DigilibRequest with user information.
+	 * @throws AuthOpException Exception thrown on error.
+	 * @return true if the user request must be authorized.
+	 */
+	public boolean isAuthRequired(DigilibRequest request)
+		throws AuthOpException;
+
+	/** Test if the request is allowed to access filepath.
+	 * 
+	 * @param filepath filepath to be acessed.
+	 * @param request Request with user information.
+	 * @throws AuthOpException Exception thrown on error.
+	 * @return true if the request is allowed.
+	 */
+	public boolean isAuthorized(String filepath, HttpServletRequest request)
+		throws AuthOpException;
+
+	/** Test if the request is allowed to access filepath.
+	 * 
+	 * @param request Request with user information.
+	 * @throws AuthOpException Exception thrown on error.
+	 * @return true if the request is allowed.
+	 */
+	public boolean isAuthorized(DigilibRequest request)
+		throws AuthOpException;
 
-  /**
-   *  return a list of authorization roles needed for request
-   *  to access the specified path
-   *    (does not look at request address for now)
-   */
-  public List rolesForPath(String filepath, HttpServletRequest request) throws AuthOpException;
+	/** Authorization roles needed for request.
+	 *
+	 * Returns the list of authorization roles that are needed to access the
+	 * specified path. No list means the path is free.
+	 *
+	 * The location information of the request is also considered.
+	 *
+	 * @param filepath filepath to be accessed.
+	 * @param request ServletRequest with address information.
+	 * @throws AuthOpException Exception thrown on error.
+	 * @return List of Strings with role names.
+	 */
+	public List<String> rolesForPath(String filepath, HttpServletRequest request)
+		throws AuthOpException;
 
-  /**
-   * check request authorization against a list of roles
-   */
-  public boolean isRoleAuthorized(List roles, HttpServletRequest request);
+	/** Authorization roles needed for request.
+	 *
+	 * Returns the list of authorization roles that are needed to access the
+	 * specified path. No list means the path is free.
+	 *
+	 * The location information of the request is also considered.
+	 *
+	 * @param request DigilibRequest with address information.
+	 * @throws AuthOpException Exception thrown on error.
+	 * @return List of Strings with role names.
+	 */
+	public List<String> rolesForPath(DigilibRequest request)
+		throws AuthOpException;
+
+	/** Test request authorization against a list of roles.
+	 * @param roles List of Strings with role names.
+	 * @param request ServletRequest with address information.
+	 * @return true if the user information in the request authorizes one of the roles.
+	 */
+	public boolean isRoleAuthorized(List<String> roles, HttpServletRequest request);
+
+	/** Test request authorization against a list of roles.
+	 * @param roles List of Strings with role names.
+	 * @param request ServletRequest with address information.
+	 * @return true if the user information in the request authorizes one of the roles.
+	 */
+	public boolean isRoleAuthorized(List<String> roles, DigilibRequest request);
 
 }

--- a/servlet/src/digilib/auth/AuthOpsImpl.java	Thu Jan 14 14:30:30 2010 +0100
+++ b/servlet/src/digilib/auth/AuthOpsImpl.java	Fri Feb 05 20:58:38 2010 +0100
@@ -20,58 +20,112 @@
 
 package digilib.auth;
 
+import java.util.List;
+
 import javax.servlet.http.HttpServletRequest;
-import java.util.*;
+
+import org.apache.log4j.Logger;
 
-import digilib.*;
+import digilib.servlet.DigilibRequest;
 
+/** Basic implementation of AuthOps interface.
+ *
+ * Provides basic implementations. Only rolesForPath needs to be implemented
+ * by specific implementations.
+ */
 public abstract class AuthOpsImpl implements AuthOps {
 
-  protected Utils util;
-
+	/** general logger for this class */
+	protected Logger logger = Logger.getLogger(this.getClass());
+	
+  /** Default constructor. */  
   public AuthOpsImpl() {
-    util = new Utils();
-    try {
-      init();
-    } catch (AuthOpException e) {
-    }
-  }
-
-  public AuthOpsImpl(Utils u) {
-    util = u;
     try {
       init();
     } catch (AuthOpException e) {
     }
   }
 
+
+  /** Test if the request is allowed to access filepath.
+   * @param filepath filepath to be acessed.
+   * @param request Request with user information.
+   * @throws AuthOpException Exception thrown on error.
+   * @return true if the request is allowed.
+   */
   public boolean isAuthRequired(String filepath, HttpServletRequest request) throws AuthOpException {
     // check permissions
-    List rolesRequired = rolesForPath(filepath, request);
+    List<String> rolesRequired = rolesForPath(filepath, request);
     return (rolesRequired != null);
   }
 
+  /**
+   * @see digilib.auth.AuthOps#isAuthRequired(digilib.servlet.DigilibRequest)
+   */
+  public boolean isAuthRequired(DigilibRequest request)
+	  throws AuthOpException {
+		// check permissions
+		List<String> rolesRequired = rolesForPath(request);
+		return (rolesRequired != null);
+  }
+
+  /** Return authorization roles needed for request.
+   *
+   * Returns a list of authorization roles that would be allowed to access the
+   * specified path. The location information of the request is considered also.
+   * @param filepath filepath to be accessed.
+   * @param request ServletRequest with address information.
+   * @throws AuthOpException Exception thrown on error.
+   * @return List of Strings with role names.
+   */
   public boolean isAuthorized(String filepath, HttpServletRequest request) throws AuthOpException {
-    List rolesAllowed = rolesForPath(filepath, request);
+    List<String> rolesAllowed = rolesForPath(filepath, request);
     return isRoleAuthorized(rolesAllowed, request);
   }
 
-  public boolean isRoleAuthorized(List roles, HttpServletRequest request) {
-    ListIterator r = roles.listIterator();
-    String s = "";
-    while (r.hasNext()) {
-      s = (String)r.next();
-      util.dprintln(5, "Testing role: "+s);
+  /**
+   * @see digilib.auth.AuthOps#isAuthorized(digilib.servlet.DigilibRequest)
+   */
+  public boolean isAuthorized(DigilibRequest request)
+	  throws AuthOpException {
+		List<String> rolesAllowed = rolesForPath(request);
+		return isRoleAuthorized(rolesAllowed, request);
+  }
+
+  /** Test request authorization against a list of roles.
+   * @param roles List of Strings with role names.
+   * @param request ServletRequest with address information.
+   * @return true if the user information in the request authorizes one of the roles.
+   */
+  public boolean isRoleAuthorized(List<String> roles, HttpServletRequest request) {
+    for (String s: roles) {
+      logger.debug("Testing role: "+s);
       if (request.isUserInRole(s)) {
-        util.dprintln(5, "Role Authorized");
+      	logger.debug("Role Authorized");
         return true;
       }
     }
     return false;
   }
 
+  /**
+   * @see digilib.auth.AuthOps#isRoleAuthorized(java.util.List, digilib.servlet.DigilibRequest)
+   */
+  public boolean isRoleAuthorized(List<String> roles, DigilibRequest request) {
+	for (String s: roles) {
+	  logger.debug("Testing role: "+s);
+	  if (((HttpServletRequest)request.getServletRequest()).isUserInRole(s)) {
+	  	logger.debug("Role Authorized");
+		return true;
+	  }
+	}
+	return false;
+  }
+
   public abstract void init() throws AuthOpException;
 
-  public abstract List rolesForPath(String filepath, HttpServletRequest request) throws AuthOpException;
+  public abstract List<String> rolesForPath(String filepath, HttpServletRequest request) throws AuthOpException;
+
+  public abstract List<String> rolesForPath(DigilibRequest request) throws AuthOpException;
 
 }

--- a/servlet/src/digilib/auth/HashTree.java	Thu Jan 14 14:30:30 2010 +0100
+++ b/servlet/src/digilib/auth/HashTree.java	Fri Feb 05 20:58:38 2010 +0100
@@ -1,80 +1,113 @@
 /*  HashTree -- Tree in a Hashtable
 
-  Digital Image Library servlet components
+ Digital Image Library servlet components
 
-  Copyright (C) 2001, 2002 Robert Casties (robcast@mail.berlios.de)
+ Copyright (C) 2001, 2002 Robert Casties (robcast@mail.berlios.de)
 
-  This program is free software; you can redistribute  it and/or modify it
-  under  the terms of  the GNU General  Public License as published by the
-  Free Software Foundation;  either version 2 of the  License, or (at your
-  option) any later version.
-   
-  Please read license.txt for the full details. A copy of the GPL
-  may be found at http://www.gnu.org/copyleft/lgpl.html
+ This program is free software; you can redistribute  it and/or modify it
+ under  the terms of  the GNU General  Public License as published by the
+ Free Software Foundation;  either version 2 of the  License, or (at your
+ option) any later version.
+ 
+ Please read license.txt for the full details. A copy of the GPL
+ may be found at http://www.gnu.org/copyleft/lgpl.html
 
-  You should have received a copy of the GNU General Public License
-  along with this program; if not, write to the Free Software
-  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 
-*/
+ */
 
 package digilib.auth;
 
-import java.util.*;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.StringTokenizer;
 
+/**
+ * Tree representation wrapper for a HashMap.
+ * 
+ * The HashTree is constructed from a HashMap filled with 'branches' with
+ * 'leaves'. The branches are stored as String keys in the HashMap. The String
+ * values are leaves.
+ * 
+ * Branches are matched in 'twigs' separated by 'twig separator' Strings. The
+ * return values for a match are leaf values separated by 'leaf separator'
+ * Strings.
+ * 
+ * @author casties
+ */
 public class HashTree {
 
-  private Hashtable table;
-  private String twigSep = "/";
-  private String leafSep = ",";
+    private Map<String, String> table;
 
-  public HashTree() {
-    table = new Hashtable();
-  }
+    private String twigSep = "/";
+
+    private String leafSep = ",";
 
-  public HashTree(Hashtable t, String twig_separator, String leaf_separator) {
-    table = t;
-    twigSep = twig_separator;
-    leafSep = leaf_separator;
-    optimizeTable();
-  }
+    /**
+     * Constructor of a HashTree.
+     * 
+     * Creates a HashTree wrapper around a given HashMap, using the given twig
+     * separator and leaf separator.
+     * 
+     * @param t
+     * @param twig_separator
+     * @param leaf_separator
+     */
+    public HashTree(Map<String, String> t, String twig_separator, String leaf_separator) {
+        table = t;
+        twigSep = twig_separator;
+        leafSep = leaf_separator;
+        optimizeTable();
+    }
 
-  void optimizeTable() {
-  }
-
-  List match(String branch) {
-    String b = "";
-    String m;
-    LinkedList matches = new LinkedList();
+    void optimizeTable() {
+    }
 
-    // split branch
-    StringTokenizer twig = new StringTokenizer(branch, twigSep);
-    // walk branch and check with tree
-    while (twig.hasMoreTokens()) {
-      if (b.length() == 0) {
-        b = twig.nextToken();
-      } else {
-        b += twigSep + twig.nextToken();
-      }
-      m = (String)table.get(b);
-      //System.out.println("CHECK: "+b+" = "+m);
-      if (m != null) {
-        if (m.indexOf(leafSep) < 0) {
-          // single leaf
-          matches.add(m);
+    /**
+     * Matches the given branch against the HashTree.
+     * 
+     * Returns a LinkedList of all leaves on all matching branches in the tree.
+     * Branches in the tree match if they are substrings starting at the same
+     * root.
+     * 
+     * @param branch
+     * @return
+     */
+    List<String> match(String branch) {
+        String b = "";
+        String m;
+        LinkedList<String> matches = new LinkedList<String>();
+
+        // split branch
+        StringTokenizer twig = new StringTokenizer(branch, twigSep);
+        // walk branch and check with tree
+        while (twig.hasMoreTokens()) {
+            if (b.length() == 0) {
+                b = twig.nextToken();
+            } else {
+                b += twigSep + twig.nextToken();
+            }
+            m = table.get(b);
+            if (m != null) {
+                if (m.indexOf(leafSep) < 0) {
+                    // single leaf
+                    matches.add(m);
+                } else {
+                    // split leaves
+                    StringTokenizer leaf = new StringTokenizer(m, leafSep);
+                    while (leaf.hasMoreTokens()) {
+                        matches.add(leaf.nextToken());
+                    }
+                }
+            }
+        }
+        if (matches.size() > 0) {
+            return matches;
         } else {
-          // split leaves
-          StringTokenizer leaf = new StringTokenizer(m, leafSep);
-          while (leaf.hasMoreTokens()) {
-            matches.add(leaf.nextToken());
-          }
+            return null;
         }
-      }
     }
-    if (matches.size() > 0) {
-      return matches;
-    } else {
-      return null;
-    }
-  }
 }

--- a/servlet/src/digilib/auth/XMLAuthOps.java	Thu Jan 14 14:30:30 2010 +0100
+++ b/servlet/src/digilib/auth/XMLAuthOps.java	Fri Feb 05 20:58:38 2010 +0100
@@ -20,78 +20,148 @@
 
 package digilib.auth;
 
+import java.io.File;
+import java.util.List;
+import java.util.Map;
+
 import javax.servlet.http.HttpServletRequest;
-import java.util.*;
-import java.io.*;
 
-import digilib.*;
-import digilib.io.*;
+import digilib.io.XMLListLoader;
+import digilib.servlet.DigilibRequest;
 
-
+/** Implementation of AuthOps using XML files.
+ *
+ * The configuration file is read by an XMLListLoader into HashTree objects for 
+ * authentication paths and IP numbers.
+ */
 public class XMLAuthOps extends AuthOpsImpl {
 
-  private String configFile = "/docuserver/www/digitallibrary/WEB-INF/digilib-auth.xml";
-  private HashTree authPaths;
-  private HashTree authIPs;
+	private File configFile;
+	private HashTree authPaths;
+	private HashTree authIPs;
+
+	/** Constructor taking an XML config file.
+	 *
+	 * @param u utils object
+	 * @param confFile Configuration file.
+	 * @throws AuthOpException Exception thrown on error.
+	 */
+	public XMLAuthOps(File confFile) throws AuthOpException {
+		configFile = confFile;
+		init();
+	}
+
+	/** Set configuration file.
+	 *
+	 * @param confFile XML config file.
+	 * @throws AuthOpException Exception thrown on error.
+	 */
+	public void setConfig(File confFile) throws AuthOpException {
+		configFile = confFile;
+		init();
+	}
 
-  public XMLAuthOps(Utils u, String confFile) throws AuthOpException {
-    util = u;
-    configFile = confFile;
-    init();
-  }
-
-  public void setConfig(String confFile) throws AuthOpException {
-    configFile = confFile;
-    init();
-  }
+	/** Initialize.
+	 *
+	 * Read configuration files and setup authentication arrays.
+	 *
+	 * @throws AuthOpException Exception thrown on error.
+	 */
+	public void init() throws AuthOpException {
+		logger.debug("xmlauthops.init (" + configFile + ")");
+		Map<String, String> pathList = null;
+		Map<String, String> ipList = null;
+		try {
+			// load authPaths
+			XMLListLoader pathLoader =
+				new XMLListLoader("digilib-paths", "path", "name", "role");
+			pathList = pathLoader.loadURL(configFile.toURL().toString());
+			// load authIPs
+			XMLListLoader ipLoader =
+				new XMLListLoader("digilib-addresses", "address", "ip", "role");
+			ipList = ipLoader.loadURL(configFile.toURL().toString());
+		} catch (Exception e) {
+			throw new AuthOpException(
+				"ERROR loading authorization config file: " + e);
+		}
+		if ((pathList == null) || (ipList == null)) {
+			throw new AuthOpException("ERROR unable to load authorization config file!");
+		}
+		// setup path tree
+		authPaths = new HashTree(pathList, "/", ",");
+		// setup ip tree
+		authIPs = new HashTree(ipList, ".", ",");
+	}
 
-  public void init() throws AuthOpException {
-    util.dprintln(10, "xmlauthops.init ("+configFile+")");
-    Hashtable pathList = null;
-    Hashtable ipList = null;
-    try {
-      // create data loader for auth-path file
-      File confFile = new File(configFile);
-      // load authPaths
-      XMLListLoader pathLoader = new XMLListLoader("digilib-paths", "path", "name", "role");
-      pathList = pathLoader.loadURL(confFile.toURL().toString());
-      // load authIPs
-      XMLListLoader ipLoader = new XMLListLoader("digilib-addresses", "address", "ip", "role");
-      ipList = ipLoader.loadURL(confFile.toURL().toString());
-    }
-    catch (Exception e) {
-      throw new AuthOpException("ERROR loading authorization config file: "+e);
-    }
-    if ((pathList == null)||(ipList == null)) {
-      throw new AuthOpException("ERROR unable to load authorization config file!");
-    }
-    // setup path tree
-    authPaths = new HashTree(pathList, "/", ",");
-    // setup ip tree
-    authIPs = new HashTree(ipList, ".", ",");
-  }
+	/** Return authorization roles needed for request.
+	 *
+	 * Returns the list of authorization roles that are needed to access the
+	 * specified path. No list means the path is free.
+	 *
+	 * The location information of the request is also considered.
+	 *
+	 * @param filepath filepath to be accessed.
+	 * @param request ServletRequest with address information.
+	 * @throws AuthOpException Exception thrown on error.
+	 * @return List of Strings with role names.
+	 */
+	public List<String> rolesForPath(String filepath, HttpServletRequest request)
+		throws digilib.auth.AuthOpException {
+		logger.debug("rolesForPath ("
+				+ filepath
+				+ ") by ["
+				+ request.getRemoteAddr()
+				+ "]");
 
-  public List rolesForPath(String filepath, HttpServletRequest request) throws digilib.auth.AuthOpException {
-    util.dprintln(4, "rolesForPath ("+filepath+") by ["+request.getRemoteAddr()+"]");
+		// check if the requests address provides a role
+		List<String> provided = authIPs.match(request.getRemoteAddr());
+		if ((provided != null) && (provided.contains("ALL"))) {
+			// ALL switches off checking;
+			return null;
+		}
+		// which roles are required?
+		List<String> required = authPaths.match(filepath);
+		// do any provided roles match?
+		if ((provided != null) && (required != null)) {
+			for (int i = 0; i < provided.size(); i++) {
+				if (required.contains(provided.get(i))) {
+					// satisfied
+					return null;
+				}
+			}
+		}
+		return required;
+	}
 
-    // check if the requests address provides a role
-    List provided = authIPs.match(request.getRemoteAddr());
-    if ((provided != null)&&(provided.contains("ALL"))) {
-      // ALL switches off checking;
-      return null;
-    }
-    // which roles are required?
-    List required = authPaths.match(filepath);
-    // do any provided roles match?
-    if ((provided != null)&&(required != null)) {
-      for (int i = 0; i < provided.size(); i++) {
-        if (required.contains(provided.get(i))) {
-          // satisfied
-          return null;
-        }
-      }
-    }
-    return required;
-  }
+	/**
+	 * @see digilib.auth.AuthOps#rolesForPath(digilib.servlet.DigilibRequest)
+	 */
+	public List<String> rolesForPath(DigilibRequest request) throws AuthOpException {
+		logger.debug("rolesForPath ("
+				+ request.getFilePath()
+				+ ") by ["
+				+ request.getServletRequest().getRemoteAddr()
+				+ "]");
+
+		// check if the requests address provides a role
+		List<String> provided =
+			authIPs.match(request.getServletRequest().getRemoteAddr());
+		if ((provided != null) && (provided.contains("ALL"))) {
+			// ALL switches off checking;
+			return null;
+		}
+		// which roles are required?
+		List<String> required = authPaths.match(request.getFilePath());
+		// do any provided roles match?
+		if ((provided != null) && (required != null)) {
+			for (int i = 0; i < provided.size(); i++) {
+				if (required.contains(provided.get(i))) {
+					// satisfied
+					return null;
+				}
+			}
+		}
+		return required;
+	}
 
 }

--- a/servlet/src/digilib/image/DocuImage.java	Thu Jan 14 14:30:30 2010 +0100
+++ b/servlet/src/digilib/image/DocuImage.java	Fri Feb 05 20:58:38 2010 +0100
@@ -2,7 +2,7 @@
 
   Digital Image Library servlet components
 
-  Copyright (C) 2001, 2002 Robert Casties (robcast@mail.berlios.de)
+  Copyright (C) 2001, 2002, 2003 Robert Casties (robcast@mail.berlios.de)
 
   This program is free software; you can redistribute  it and/or modify it
   under  the terms of  the GNU General  Public License as published by the
@@ -14,55 +14,211 @@
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
-  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 
 */
 
 package digilib.image;
 
-import javax.servlet.*;
-import javax.servlet.http.*;
-import java.io.*;
-import java.util.*;
+import java.awt.Rectangle;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.Iterator;
+
+import digilib.io.ImageFile;
+import digilib.io.FileOpException;
 
-import java.awt.image.*;
-import java.awt.image.renderable.*;
-
-import digilib.*;
-import digilib.io.*;
-
+/** The basic class for the representation of a digilib image.
+ *
+ * The actual image object is hidden in the class, only methods for loading,
+ * manipulation, and saving are exported. This strategy enables implementations
+ * using different toolkits that rely on different image base classes (like
+ * JIMI, Java2D and JAI).
+ */
 public interface DocuImage {
 
-  public String[] getKnownFileTypes();
+	/** Loads an image file into the Object.
+	 * 
+	 * @param f Image File.
+	 * @throws FileOpException Exception thrown if any error occurs.
+	 */
+	public void loadImage(ImageFile f) throws FileOpException;
+
+	/** This DocuImage support the loadSubImage operation.
+	 * 
+	 * @return boolean
+	 */
+	public boolean isSubimageSupported();
 
-  /**
-   *  send an image file as-is
-   */
-  public void sendFile(File f, ServletResponse res) throws FileOpException;
+	/** Load only a subsampled region of the image file.
+	 * 
+	 * @param f
+	 * @param region
+	 * @param subsample
+	 * @throws FileOpException
+	 */
+	public void loadSubimage(ImageFile f, Rectangle region, int subsample)
+		throws FileOpException;
+
+	/** Writes the current image to a ServletResponse.
+	 *
+	 * The image is encoded to the mime-type <code>mt</code> and sent to the output
+	 * stream of the <code>ServletResponse</code> <code>res</code>.
+	 *
+	 * Currently only mime-types "image/jpeg" and "image/png" are supported.
+	 * 
+	 * @param mt mime-type of the image to be sent.
+	 * @param res ServletResponse where the image is sent.
+	 * @throws FileOpException Exception thrown on any error.
+	 */
+	public void writeImage(String mt, OutputStream ostream)
+		throws FileOpException;
 
-  /**
-   *  load image file
-   */
-  public void loadImage(File f) throws FileOpException;
+	/** The width of the current image in pixel.
+	 * 
+	 * @return Image width in pixels.
+	 */
+	public int getWidth();
+
+	/** The height of the current image in pixel.
+	 * 
+	 * @return Image height in pixels.
+	 */
+	public int getHeight();
+
+	/** The mime-type of the current image.
+	 * 
+	 * @return String the mime-type of this image.
+	 */
+	public String getMimetype();
 
-  /**
-   *  write image with mime type mt to Stream
-   */
-  public void writeImage(String mt, ServletResponse res) throws FileOpException;
+	/** Crops the current image.
+	 * 
+	 * Cuts out a region of the size <code>width</code> x <code>height</code> at
+	 * the offset <code>xoff</code>, <code>yoff</code> from the current image
+	 * and replaces the current image with the result.
+	 * 
+	 * @param xoff X offset of crop region
+	 * @param yoff Y offset of crop region
+	 * @param width width of crop region
+	 * @param height height of crop region
+	 * @throws ImageOpException
+	 */
+	public void crop(int xoff, int yoff, int width, int height)
+		throws ImageOpException;
+
+	/** Scales the current image.
+	 * 
+	 * Replaces the current image with an image scaled by the factor
+	 * <code>scale</code>.
+	 * 
+	 * @param scale scaling factor
+	 * @throws ImageOpException
+	 */
+	public void scale(double scaleX, double scaleY) throws ImageOpException;
 
-  /**
-   *  get the image height and width
-   */
-  public int getWidth();
-  public int getHeight();
+	/** Crops and scales the current image.
+	 *
+	 * The current image is cropped to a rectangle of <code>width</code>,
+	 * <code>height</code> at position <code>x_off</code>, <code>y_off</code>. The
+	 * resulting image is scaled by the factor <code>scale</code> using the
+	 * interpolation quality <code>qual</code> (0=worst).
+	 * 
+	 * @param x_off x offset of the crop rectangle in pixel.
+	 * @param y_off y offset of the crop rectangle in pixel.
+	 * @param width width of the crop rectangle in pixel.
+	 * @param height height of the crop rectangle in pixel.
+	 * @param scale scaling factor.
+	 * @param qual interpolation quality (0=worst).
+	 * @throws ImageOpException exception thrown on any error.
+	 */
+	public void cropAndScale(
+		int x_off,
+		int y_off,
+		int width,
+		int height,
+		double scale,
+		int qual)
+		throws ImageOpException;
+
+	/** Rotates the current image.
+	 * 
+	 * Replaces the current image with a rotated image. The image is rotated
+	 * around the center by the <code>angle</code> 
+	 * given in degrees [0, 360] clockwise.
+	 * Image size and aspect ratio are likely to change.
+	 * 
+	 * @param angle rotation angle in degree
+	 */
+	public void rotate(double angle) throws ImageOpException;
+
+	/** Mirrors the current image.
+	 * 
+	 * Replaces  the current image with a mirrored image. The mirror axis goes
+	 * through the center of the image and is rotated by <code>angle</code>
+	 * degrees. Currently only horizontal and vertical mirroring (0 and 90
+	 * degree) are supported. 
+	 * 
+	 * @param angle angle of mirror axis
+	 * @throws ImageOpException
+	 */
+	public void mirror(double angle) throws ImageOpException;
 
-  /**
-   *  crop and scale image
-   *    take rectangle width,height at position x_off,y_off
-   *    and scale by scale with interpolation quality qual (0=worst)
-   */
-  public void cropAndScale(
-                int x_off, int y_off,
-                int width, int height,
-                float scale, int qual) throws ImageOpException;
+	/** Enhances brightness and contrast of the current image.
+	 * 
+	 * Replaces the current image with a brightness and contrast enhanced image.
+	 * Contrast is enhanced by multiplying the pixel value with the constant
+	 * <code>mult</code>. Brightness is enhanced by adding the constant
+	 * <code>add</code> to the pixel value. Operation: p1 = (p0*mult)+add.
+	 * 
+	 * @param mult multiplicative constant for contrast enhancement
+	 * @param add additive constant for brightness enhancement
+	 * @throws ImageOpException
+	 */
+	public void enhance(float mult, float add) throws ImageOpException;
+
+	/** Manipulates the colors of the current image.
+	 * 
+	 * Replaces the current image with a color modified image.
+	 * For the red, green and blue color channels all pixel values are multiplied
+	 * by the constant
+	 * <code>m</code> and added to the constant
+	 * <code>a</code>. Operation: p1 = (p0*m)+a.
+	 * 
+	 * @param rgbm multiplicative constants for red, green, blue
+	 * @param rgba additive constant for red, green, blue
+	 * @throws ImageOpException
+	 */
+	public void enhanceRGB(float[] rgbm, float[] rgba)
+		throws ImageOpException;
+
+	/**
+	 * Returns the interpolation quality.
+	 * @return int
+	 */
+	public int getQuality();
+
+	/**
+	 * Sets the interpolation quality.
+	 * @param quality The quality to set
+	 */
+	public void setQuality(int quality);
+	
+	/** Frees all resources bound to the DocuImage.
+	 * 
+	 * Things that should be freed are image objects and open files.
+	 * 
+	 */
+	public void dispose();
+
+    /**
+     * Check image size and type and store in ImageFile f
+     */
+    public boolean identify(ImageFile imgf) throws IOException;
+
+    /**
+     * Returns a list of supported image formats
+     */
+	public Iterator<String> getSupportedFormats();
+
 }

--- a/servlet/src/digilib/image/DocuImageImpl.java	Thu Jan 14 14:30:30 2010 +0100
+++ b/servlet/src/digilib/image/DocuImageImpl.java	Fri Feb 05 20:58:38 2010 +0100
@@ -2,7 +2,7 @@
 
   Digital Image Library servlet components
 
-  Copyright (C) 2001, 2002 Robert Casties (robcast@mail.berlios.de)
+  Copyright (C) 2001, 2002, 2003 Robert Casties (robcast@mail.berlios.de)
 
   This program is free software; you can redistribute  it and/or modify it
   under  the terms of  the GNU General  Public License as published by the
@@ -14,71 +14,153 @@
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
-  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 
 */
 
 package digilib.image;
 
-import java.io.*;
-import javax.servlet.ServletResponse;
+import java.awt.Rectangle;
+import java.io.File;
+import java.io.IOException;
+import java.io.RandomAccessFile;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+import org.apache.log4j.Logger;
+import org.marcoschmidt.image.ImageInfo;
 
-import digilib.*;
-import digilib.io.*;
+import digilib.io.FileOpException;
+import digilib.io.ImageFile;
 
+/** Simple abstract implementation of the <code>DocuImage</code> interface.
+ *
+ * This implementation provides basic functionality for the utility methods like
+ * <code>SetUtils</code>, and <code>getKnownFileTypes</code>. Image methods like
+ * <code>loadImage</code>, <code>writeImage</code>, <code>getWidth</code>,
+ * <code>getHeight</code>, <code>crop</code> and <code>scale</code> must be
+ * implemented by derived classes.
+ */
 public abstract class DocuImageImpl implements DocuImage {
 
-  protected Utils util = null;
-
-  public DocuImageImpl() {
-    util = new Utils();
-  }
-
-  public DocuImageImpl(Utils u) {
-    util = u;
-  }
+	/** logger */
+	protected static final Logger logger = Logger.getLogger(DocuImage.class);
+	
+	/** Interpolation quality. */
+	protected int quality = 0;
+	
+	/** epsilon for float comparisons. */
+	public final double epsilon = 1e-5;
+	
+	/** image mime-type */
+	protected String mimeType = null;
 
-  public void setUtils(Utils u) {
-    util = u;
-  }
+	/**
+	 * Returns the quality.
+	 * @return int
+	 */
+	public int getQuality() {
+		return quality;
+	}
 
-  protected String[] knownFileTypes = {"jpg", "png", "gif", "tiff"};
-
-  public String[] getKnownFileTypes() {
-    return knownFileTypes;
-  }
+	/**
+	 * Sets the quality.
+	 * @param quality The quality to set
+	 */
+	public void setQuality(int quality) {
+		this.quality = quality;
+	}
 
-  /**
-   *  send an image file as-is
-   */
-  public void sendFile(File f, ServletResponse response) throws FileOpException {
-    util.dprintln(4, "sendFile("+f+")");
-    String mimeType = FileOps.mimeForFile(f);
-    if (mimeType == null) {
-      util.dprintln(2, "ERROR(sendFile): unknown file Type");
-      throw new FileOpException("Unknown file type.");
+    /** Check image size and type and store in ImageFile f */
+    public boolean identify(ImageFile imgf) throws IOException {
+        // fileset to store the information
+        File f = imgf.getFile();
+        if (f == null) {
+            throw new IOException("File not found!");
+        }
+        RandomAccessFile raf = new RandomAccessFile(f, "r");
+        // set up ImageInfo object
+        ImageInfo iif = new ImageInfo();
+        iif.setInput(raf);
+        iif.setCollectComments(false);
+        iif.setDetermineImageNumber(false);
+        logger.debug("identifying (ImageInfo) " + f);
+        // try with ImageInfo first
+        if (iif.check()) {
+            ImageSize d = new ImageSize(iif.getWidth(), iif.getHeight());
+            imgf.setSize(d);
+            imgf.setMimetype(iif.getMimeType());
+            //logger.debug("  format:"+iif.getFormatName());
+            raf.close();
+            logger.debug("image size: " + imgf.getSize());
+            return true;
+        }
+        return false;
     }
-    response.setContentType(mimeType);
-    // open file
-    try {
-      FileInputStream inFile = new FileInputStream(f);
-      OutputStream outStream = response.getOutputStream();
-      byte dataBuffer[] = new byte[1024];
-      int len;
-      while ((len = inFile.read(dataBuffer)) != -1) {
-        // copy out file
-        outStream.write(dataBuffer, 0, len);
-      }
-      inFile.close();
-    } catch (IOException e) {
-      util.dprintln(2, "ERROR(sendFile): unable to send file");
-      throw new FileOpException("Unable to send file.");
-    }
-  }
+        
+    /** Crop and scale the current image.
+	 *
+	 * The current image is cropped to a rectangle of width, height at position
+	 * x_off, y_off. The resulting image is scaled by the factor scale using the
+	 * interpolation quality qual (0=worst).
+	 * 
+	 * @param x_off X offset of the crop rectangle in pixel.
+	 * @param y_off Y offset of the crop rectangle in pixel.
+	 * @param width Width of the crop rectangle in pixel.
+	 * @param height Height of the crop rectangle in pixel.
+	 * @param scale Scaling factor.
+	 * @param qual Interpolation quality (0=worst).
+	 * @throws ImageOpException Exception thrown on any error.
+	 */
+	public void cropAndScale(
+		int x_off, int y_off, int width, int height, double scale, int qual) 
+		throws ImageOpException {
+
+		setQuality(qual);
+		crop(x_off, y_off, width, height);
+		scale(scale, scale);
+	}
+	
+	public String getMimetype() {
+		return mimeType;
+	}
+
+	public void rotate(double angle) throws ImageOpException {
+		// just a do-nothing implementation
+	}
 
-  public abstract void loadImage(File f) throws FileOpException;
-  public abstract void writeImage(String mt, ServletResponse res) throws FileOpException;
-  public abstract int getWidth();
-  public abstract int getHeight();
-  public abstract void cropAndScale(int x_off, int y_off, int width, int height, float scale, int qual)  throws ImageOpException;
+	public void mirror(double angle) throws ImageOpException {
+		// just a do-nothing implementation
+	}
+
+	public void enhance(float mult, float add) throws ImageOpException {
+		// just a do-nothing implementation
+	}
+
+	public boolean isSubimageSupported() {
+		// partial loading not supported per default
+		return false;
+	}
+
+	public void loadSubimage(ImageFile f, Rectangle region, int subsample)
+		throws FileOpException {
+		// empty implementation
+	}
+
+	public void enhanceRGB(float[] rgbm, float[] rgba)
+		throws ImageOpException {
+		// emtpy implementation
+	}
+
+	public void dispose() {
+		// emtpy implementation
+	}
+
+	public Iterator<String> getSupportedFormats() {
+		List<String> empty = new LinkedList<String>();
+		return empty.iterator();
+	}
+	
+
 }

--- a/servlet/src/digilib/image/ImageLoaderDocuImage.java	Thu Jan 14 14:30:30 2010 +0100
+++ b/servlet/src/digilib/image/ImageLoaderDocuImage.java	Fri Feb 05 20:58:38 2010 +0100
@@ -1,164 +1,570 @@
 /* ImageLoaderDocuImage -- Image class implementation using JDK 1.4 ImageLoader
 
-  Digital Image Library servlet components
+ Digital Image Library servlet components
 
-  Copyright (C) 2001, 2002 Robert Casties (robcast@mail.berlios.de)
+ Copyright (C) 2002, 2003 Robert Casties (robcast@mail.berlios.de)
 
-  This program is free software; you can redistribute  it and/or modify it
-  under  the terms of  the GNU General  Public License as published by the
-  Free Software Foundation;  either version 2 of the  License, or (at your
-  option) any later version.
-   
-  Please read license.txt for the full details. A copy of the GPL
-  may be found at http://www.gnu.org/copyleft/lgpl.html
+ This program is free software; you can redistribute  it and/or modify it
+ under  the terms of  the GNU General  Public License as published by the
+ Free Software Foundation;  either version 2 of the  License, or (at your
+ option) any later version.
+ 
+ Please read license.txt for the full details. A copy of the GPL
+ may be found at http://www.gnu.org/copyleft/lgpl.html
 
-  You should have received a copy of the GNU General Public License
-  along with this program; if not, write to the Free Software
-  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-
-*/
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
 
 package digilib.image;
 
-import javax.servlet.*;
-import javax.servlet.http.*;
-import java.io.*;
-import java.util.*;
+import java.awt.Image;
+import java.awt.Rectangle;
+import java.awt.RenderingHints;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.Rectangle2D;
+import java.awt.image.AffineTransformOp;
+import java.awt.image.BufferedImage;
+import java.awt.image.ConvolveOp;
+import java.awt.image.Kernel;
+import java.awt.image.RescaleOp;
+import java.io.File;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.RandomAccessFile;
+import java.util.Arrays;
+import java.util.Iterator;
 
-import java.awt.*;
-import java.awt.image.*;
-import java.awt.geom.*;
-import java.awt.image.renderable.*;
+import javax.imageio.IIOImage;
+import javax.imageio.ImageIO;
+import javax.imageio.ImageReadParam;
+import javax.imageio.ImageReader;
+import javax.imageio.ImageWriteParam;
+import javax.imageio.ImageWriter;
+import javax.imageio.stream.FileImageInputStream;
+import javax.imageio.stream.ImageInputStream;
+import javax.imageio.stream.ImageOutputStream;
 
-import javax.imageio.*;
+import digilib.io.FileOpException;
+import digilib.io.FileOps;
+import digilib.io.ImageFile;
+import digilib.io.ImageFileset;
 
-import digilib.*;
-import digilib.io.*;
-
+/** Implementation of DocuImage using the ImageLoader API of Java 1.4 and Java2D. */
 public class ImageLoaderDocuImage extends DocuImageImpl {
 
-  private BufferedImage img;
+	/** image object */
+	protected BufferedImage img;
+
+	/** interpolation type */
+	protected RenderingHints renderHint;
 
-  public ImageLoaderDocuImage() {
-  }
+	/** ImageIO image reader */
+	protected ImageReader reader;
 
-  public ImageLoaderDocuImage(Utils u) {
-    util = u;
-  }
+	/** File that was read */
+	protected File imgFile;
+
+	/* loadSubimage is supported. */
+	public boolean isSubimageSupported() {
+		return true;
+	}
 
-  /**
-   *  load image file
-   */
-  public void loadImage(File f) throws FileOpException {
-    util.dprintln(10, "loadImage!");
-    System.gc();
-    try {
-      for (int i = 0; i < ImageIO.getReaderFormatNames().length; i++) {
-    System.out.println("ImageLoader reader:"+ImageIO.getReaderFormatNames()[i]);
-      }
-      for (int i = 0; i < ImageIO.getWriterFormatNames().length; i++) {
-    System.out.println("ImageLoader writer:"+ImageIO.getWriterFormatNames()[i]);
-      }
-      img = ImageIO.read(f);
-      if (img == null) {
-        util.dprintln(3, "ERROR(loadImage): unable to load file");
-        throw new FileOpException("Unable to load File!");
-      }
-    }
-    catch (IOException e) {
-      throw new FileOpException("Error reading image.");
-    }
-  }
+	public void setQuality(int qual) {
+		quality = qual;
+		renderHint = new RenderingHints(null);
+		// hint.put(RenderingHints.KEY_ANTIALIASING,
+		// RenderingHints.VALUE_ANTIALIAS_OFF);
+		// setup interpolation quality
+		if (qual > 0) {
+			logger.debug("quality q1");
+			renderHint.put(RenderingHints.KEY_INTERPOLATION,
+					RenderingHints.VALUE_INTERPOLATION_BICUBIC);
+		} else {
+			logger.debug("quality q0");
+			renderHint.put(RenderingHints.KEY_INTERPOLATION,
+					RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
+		}
+	}
+
+	public int getHeight() {
+		int h = 0;
+		try {
+			if (img == null) {
+				h = reader.getHeight(0);
+			} else {
+				h = img.getHeight();
+			}
+		} catch (IOException e) {
+			logger.debug("error in getHeight", e);
+		}
+		return h;
+	}
 
-  /**
-   *  write image of type mt to Stream
-   */
-  public void writeImage(String mt, ServletResponse res)
-         throws FileOpException {
-    util.dprintln(10, "writeImage!");
-    try {
-      // setup output
-      String type = "png";
-      if (mt == "image/jpeg") {
-        type = "jpeg";
-      } else if (mt == "image/png") {
-        type = "png";
-      } else {
-        // unknown mime type
-        util.dprintln(2, "ERROR(writeImage): Unknown mime type "+mt);
-        throw new FileOpException("Unknown mime type: "+mt);
-      }
-      res.setContentType(mt);
-      // render output
-      if (ImageIO.write(img, type, res.getOutputStream())) {
-        // writing was OK
-        return;
-      } else {
-        throw new FileOpException("Error writing image: Unknown image format!");
-      }
-    } catch (IOException e) {
-      // e.printStackTrace();
-      throw new FileOpException("Error writing image.");
-    }
-  }
+	public int getWidth() {
+		int w = 0;
+		try {
+			if (img == null) {
+				w = reader.getWidth(0);
+			} else {
+				w = img.getWidth();
+			}
+		} catch (IOException e) {
+			logger.debug("error in getHeight", e);
+		}
+		return w;
+	}
+
+	/* returns a list of supported image formats */
+	public Iterator<String> getSupportedFormats() {
+		String[] formats = ImageIO.getReaderFormatNames();
+		return Arrays.asList(formats).iterator();
+	}
 
-  public int getWidth() {
-    if (img != null) {
-      return img.getWidth();
-    }
-    return 0;
-  }
-
-  public int getHeight() {
-    if (img != null) {
-      return img.getHeight();
-    }
-    return 0;
-  }
-
-  /**
-   *  crop and scale image
-   *    take rectangle width,height at position x_off,y_off
-   *    and scale by scale
-   */
-   public void cropAndScale(int x_off, int y_off, int width, int height,
-         float scale, int qual) throws ImageOpException {
-    util.dprintln(10, "cropAndScale!");
-
-    int scaleInt = 0;
-    // setup interpolation quality
-    if (qual > 0) {
-      util.dprintln(4, "quality q1");
-      scaleInt = AffineTransformOp.TYPE_BILINEAR;
-    } else {
-      util.dprintln(4, "quality q0");
-      scaleInt = AffineTransformOp.TYPE_NEAREST_NEIGHBOR;
+    /** Check image size and type and store in ImageFile f */
+    public boolean identify(ImageFile imgf) throws IOException {
+        // try parent method first
+        if (super.identify(imgf)) {
+            return true;
+        }
+        // fileset to store the information
+        ImageFileset imgfs = imgf.getParent();
+        File f = imgf.getFile();
+        if (f == null) {
+            throw new IOException("File not found!");
+        }
+        logger.debug("identifying (ImageIO) " + f);
+        /*
+         * try ImageReader
+         */
+        RandomAccessFile raf = new RandomAccessFile(f, "r");
+        ImageInputStream istream = ImageIO.createImageInputStream(raf);
+        Iterator<ImageReader> readers = ImageIO.getImageReaders(istream);
+        if (readers.hasNext()) {
+            ImageReader reader = readers.next();
+            /* are there more readers? */
+            logger.debug("ImageIO: this reader: " + reader.getClass());
+            while (readers.hasNext()) {
+                logger.debug("ImageIO: next reader: "
+                        + readers.next().getClass());
+            }
+            try {
+                reader.setInput(istream);
+                ImageSize d = new ImageSize(reader.getWidth(0), reader.getHeight(0));
+                imgf.setSize(d);
+                //String t = reader.getFormatName();
+                String t = FileOps.mimeForFile(f);
+                imgf.setMimetype(t);
+                //logger.debug("  format:"+t);
+                if (imgfs != null) {
+                    imgfs.setAspect(d);
+                }
+                return true;
+            } finally {
+                // dispose the reader to free resources
+                reader.dispose();
+                raf.close();
+            }
+        }
+        throw new FileOpException("ERROR: unknown image file format!");
     }
 
-    // setup Crop
-    BufferedImage croppedImg = img.getSubimage(x_off, y_off, width, height);
+    
+    /* load image file */
+	public void loadImage(ImageFile f) throws FileOpException {
+		logger.debug("loadImage " + f.getFile());
+		try {
+			img = ImageIO.read(f.getFile());
+			if (img == null) {
+				throw new FileOpException("Unable to load File!");
+			}
+		} catch (IOException e) {
+			throw new FileOpException("Error reading image.");
+		}
+	}
+
+	/**
+	 * Get an ImageReader for the image file.
+	 * 
+	 * @return
+	 */
+	public ImageReader getReader(ImageFile f) throws IOException {
+		logger.debug("preloadImage " + f.getFile());
+		if (reader != null) {
+			logger.debug("Reader was not null!");
+			// clean up old reader
+			dispose();
+		}
+		// System.gc();
+		RandomAccessFile rf = new RandomAccessFile(f.getFile(), "r");
+		ImageInputStream istream = new FileImageInputStream(rf);
+		// Iterator readers = ImageIO.getImageReaders(istream);
+		String mt = f.getMimetype();
+		logger.debug("File type:" + mt);
+		Iterator<ImageReader> readers = ImageIO.getImageReadersByMIMEType(mt);
+		if (!readers.hasNext()) {
+			throw new FileOpException("Unable to load File!");
+		}
+		reader = readers.next();
+		/* are there more readers? */
+		logger.debug("ImageIO: this reader: " + reader.getClass());
+		while (readers.hasNext()) {
+			logger.debug("ImageIO: next reader: " + readers.next().getClass());
+		}
+		// */
+		reader.setInput(istream);
+		imgFile = f.getFile();
+		return reader;
+	}
+
+	/* Load an image file into the Object. */
+	public void loadSubimage(ImageFile f, Rectangle region, int prescale)
+			throws FileOpException {
+		logger.debug("loadSubimage");
+		// System.gc();
+		try {
+			if ((reader == null) || (imgFile != f.getFile())) {
+				getReader(f);
+			}
+			// set up reader parameters
+			ImageReadParam readParam = reader.getDefaultReadParam();
+			readParam.setSourceRegion(region);
+			if (prescale > 1) {
+				readParam.setSourceSubsampling(prescale, prescale, 0, 0);
+			}
+			// read image
+			logger.debug("loading..");
+			img = reader.read(0, readParam);
+			logger.debug("loaded");
+		} catch (IOException e) {
+			throw new FileOpException("Unable to load File!");
+		}
+		if (img == null) {
+			throw new FileOpException("Unable to load File!");
+		}
+	}
 
-    img = null; // free img
-    util.dprintln(3, "CROP:"+croppedImg.getWidth()+"x"+croppedImg.getHeight()); //DEBUG
-//    util.dprintln(2, "  time "+(System.currentTimeMillis()-startTime)+"ms");
+	/* write image of type mt to Stream */
+	public void writeImage(String mt, OutputStream ostream)
+			throws FileOpException {
+		logger.debug("writeImage");
+		// setup output
+		ImageWriter writer = null;
+		ImageOutputStream imgout = null;
+		try {
+			imgout = ImageIO.createImageOutputStream(ostream);
+			if (mt == "image/jpeg") {
+				/*
+				 * JPEG doesn't do transparency so we have to convert any RGBA
+				 * image to RGB :-( *Java2D BUG*
+				 */
+				if (img.getColorModel().hasAlpha()) {
+					logger.debug("BARF: JPEG with transparency!!");
+					int w = img.getWidth();
+					int h = img.getHeight();
+					// BufferedImage.TYPE_INT_RGB seems to be fastest (JDK1.4.1,
+					// OSX)
+					int destType = BufferedImage.TYPE_INT_RGB;
+					BufferedImage img2 = new BufferedImage(w, h, destType);
+					img2.createGraphics().drawImage(img, null, 0, 0);
+					img = img2;
+				}
+				writer = (ImageWriter) ImageIO.getImageWritersByFormatName(
+						"jpeg").next();
+				if (writer == null) {
+					throw new FileOpException("Unable to get JPEG writer");
+				}
+				ImageWriteParam param = writer.getDefaultWriteParam();
+				if (quality > 1) {
+					// change JPEG compression quality
+					param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
+					//logger.debug("JPEG qual before: "
+					//		+ Float.toString(param.getCompressionQuality()));
+					param.setCompressionQuality(0.9f);
+					//logger.debug("JPEG qual now: "
+					//		+ Float.toString(param.getCompressionQuality()));
+				}
+				writer.setOutput(imgout);
+				// render output
+				logger.debug("writing");
+				writer.write(null, new IIOImage(img, null, null), param);
+			} else if (mt == "image/png") {
+				// render output
+				writer = (ImageWriter) ImageIO.getImageWritersByFormatName(
+						"png").next();
+				if (writer == null) {
+					throw new FileOpException("Unable to get PNG writer");
+				}
+				writer.setOutput(imgout);
+				logger.debug("writing");
+				writer.write(img);
+			} else {
+				// unknown mime type
+				throw new FileOpException("Unknown mime type: " + mt);
+			}
 
-    if (croppedImg == null) {
-      util.dprintln(2, "ERROR(cropAndScale): error in crop");
-      throw new ImageOpException("Unable to crop");
-    }
+		} catch (IOException e) {
+			throw new FileOpException("Error writing image.");
+		} finally {
+			// clean up
+			if (writer != null) {
+				writer.dispose();
+			}
+		}
+	}
+
+	public void scale(double scale, double scaleY) throws ImageOpException {
+		logger.debug("scale");
+		/* for downscaling in high quality the image is blurred first */
+		if ((scale <= 0.5) && (quality > 1)) {
+			int bl = (int) Math.floor(1 / scale);
+			blur(bl);
+		}
+		/* then scaled */
+		AffineTransformOp scaleOp = new AffineTransformOp(AffineTransform
+				.getScaleInstance(scale, scale), renderHint);
+		BufferedImage scaledImg = null;
+		// enforce destination image type (*Java2D BUG*)
+		int type = img.getType();
+		// FIXME: which type would be best?
+		if ((quality > 0) && (type != 0)) {
+			logger.debug("creating destination image");
+			Rectangle2D dstBounds = scaleOp.getBounds2D(img);
+			scaledImg = new BufferedImage((int) dstBounds.getWidth(),
+					(int) dstBounds.getHeight(), type);
+		}
+		logger.debug("scaling...");
+		scaledImg = scaleOp.filter(img, scaledImg);
+		if (scaledImg == null) {
+			throw new ImageOpException("Unable to scale");
+		}
+		// DEBUG
+		logger.debug("destination image type " + scaledImg.getType());
+		logger.debug("SCALE: " + scale + " ->" + scaledImg.getWidth() + "x"
+				+ scaledImg.getHeight());
+		img = scaledImg;
+		scaledImg = null;
+	}
 
-    // setup scale
-    AffineTransformOp scaleOp = new AffineTransformOp(
-                      AffineTransform.getScaleInstance(scale, scale),
-                      scaleInt);
-    BufferedImage scaledImg = scaleOp.filter(croppedImg, null);
-    croppedImg = null; // free opCrop
+	public void blur(int radius) throws ImageOpException {
+		// DEBUG
+		logger.debug("blur: " + radius);
+		// minimum radius is 2
+		int klen = Math.max(radius, 2);
+		// FIXME: use constant kernels for most common sizes
+		int ksize = klen * klen;
+		// kernel is constant 1/k
+		float f = 1f / ksize;
+		float[] kern = new float[ksize];
+		for (int i = 0; i < ksize; i++) {
+			kern[i] = f;
+		}
+		Kernel blur = new Kernel(klen, klen, kern);
+		// blur with convolve operation
+		ConvolveOp blurOp = new ConvolveOp(blur, ConvolveOp.EDGE_NO_OP,
+				renderHint);
+		// blur needs explicit destination image type for color *Java2D BUG*
+		BufferedImage blurredImg = null;
+		if (img.getType() == BufferedImage.TYPE_3BYTE_BGR) {
+			blurredImg = new BufferedImage(img.getWidth(), img.getHeight(), img
+					.getType());
+		}
+		blurredImg = blurOp.filter(img, blurredImg);
+		if (blurredImg == null) {
+			throw new ImageOpException("Unable to scale");
+		}
+		img = blurredImg;
+	}
+
+	public void crop(int x_off, int y_off, int width, int height)
+			throws ImageOpException {
+		// setup Crop
+		BufferedImage croppedImg = img.getSubimage(x_off, y_off, width, height);
+		// DEBUG
+		// util.dprintln(2, " time
+		// "+(System.currentTimeMillis()-startTime)+"ms");
+		if (croppedImg == null) {
+			throw new ImageOpException("Unable to crop");
+		}
+		logger.debug("CROP:" + croppedImg.getWidth() + "x"
+				+ croppedImg.getHeight());
+		img = croppedImg;
+	}
+
+	public void enhance(float mult, float add) throws ImageOpException {
+		/*
+		 * Only one constant should work regardless of the number of bands
+		 * according to the JDK spec. Doesn't work on JDK 1.4 for OSX and Linux
+		 * (at least). RescaleOp scaleOp = new RescaleOp( (float)mult,
+		 * (float)add, null); scaleOp.filter(img, img);
+		 */
+
+		/* The number of constants must match the number of bands in the image. */
+		int ncol = img.getColorModel().getNumComponents();
+		float[] dm = new float[ncol];
+		float[] da = new float[ncol];
+		for (int i = 0; i < ncol; i++) {
+			dm[i] = (float) mult;
+			da[i] = (float) add;
+		}
+		RescaleOp scaleOp = new RescaleOp(dm, da, null);
+		scaleOp.filter(img, img);
+	}
+
+	public void enhanceRGB(float[] rgbm, float[] rgba) throws ImageOpException {
+
+		/*
+		 * The number of constants must match the number of bands in the image.
+		 * We do only 3 (RGB) bands.
+		 */
+
+		int ncol = img.getColorModel().getNumColorComponents();
+		if ((ncol != 3) || (rgbm.length != 3) || (rgba.length != 3)) {
+			logger
+					.debug("ERROR(enhance): unknown number of color bands or coefficients ("
+							+ ncol + ")");
+			return;
+		}
+		RescaleOp scaleOp = new RescaleOp(rgbOrdered(rgbm), rgbOrdered(rgba),
+				null);
+		scaleOp.filter(img, img);
+	}
 
-    if (scaledImg == null) {
-      util.dprintln(2, "ERROR(cropAndScale): error in scale");
-      throw new ImageOpException("Unable to scale");
-    }
-    img = scaledImg;
-  }
+	/**
+	 * Ensures that the array f is in the right order to map the images RGB
+	 * components. (not shure what happens
+	 */
+	public float[] rgbOrdered(float[] fa) {
+		/*
+		 * TODO: this is UGLY, UGLY!!
+		 */
+		float[] fb;
+		int t = img.getType();
+		if (img.getColorModel().hasAlpha()) {
+			fb = new float[4];
+			if ((t == BufferedImage.TYPE_INT_ARGB)
+					|| (t == BufferedImage.TYPE_INT_ARGB_PRE)) {
+				// RGB Type
+				fb[0] = fa[0];
+				fb[1] = fa[1];
+				fb[2] = fa[2];
+				fb[3] = 1f;
+			} else {
+				// this isn't tested :-(
+				fb[0] = 1f;
+				fb[1] = fa[0];
+				fb[2] = fa[1];
+				fb[3] = fa[2];
+			}
+		} else {
+			fb = new float[3];
+			if (t == BufferedImage.TYPE_3BYTE_BGR) {
+				// BGR Type (actually it looks like RBG...)
+				fb[0] = fa[0];
+				fb[1] = fa[2];
+				fb[2] = fa[1];
+			} else {
+				fb[0] = fa[0];
+				fb[1] = fa[1];
+				fb[2] = fa[2];
+			}
+		}
+		return fb;
+	}
 
+	public void rotate(double angle) throws ImageOpException {
+		// setup rotation
+		double rangle = Math.toRadians(angle);
+		// create offset to make shure the rotated image has no negative
+		// coordinates
+		double w = img.getWidth();
+		double h = img.getHeight();
+		AffineTransform trafo = new AffineTransform();
+		// center of rotation
+		double x = (w / 2);
+		double y = (h / 2);
+		trafo.rotate(rangle, x, y);
+		// try rotation to see how far we're out of bounds
+		AffineTransformOp rotOp = new AffineTransformOp(trafo, renderHint);
+		Rectangle2D rotbounds = rotOp.getBounds2D(img);
+		double xoff = rotbounds.getX();
+		double yoff = rotbounds.getY();
+		// move image back in line
+		trafo
+				.preConcatenate(AffineTransform.getTranslateInstance(-xoff,
+						-yoff));
+		// transform image
+		rotOp = new AffineTransformOp(trafo, renderHint);
+		BufferedImage rotImg = rotOp.filter(img, null);
+		// calculate new bounding box
+		// Rectangle2D bounds = rotOp.getBounds2D(img);
+		if (rotImg == null) {
+			throw new ImageOpException("Unable to rotate");
+		}
+		img = rotImg;
+		// crop new image (with self-made rounding)
+		/*
+		 * img = rotImg.getSubimage( (int) (bounds.getX()+0.5), (int)
+		 * (bounds.getY()+0.5), (int) (bounds.getWidth()+0.5), (int)
+		 * (bounds.getHeight()+0.5));
+		 */
+	}
+
+	public void mirror(double angle) throws ImageOpException {
+		// setup mirror
+		double mx = 1;
+		double my = 1;
+		double tx = 0;
+		double ty = 0;
+		if (Math.abs(angle - 0) < epsilon) { // 0 degree
+			mx = -1;
+			tx = getWidth();
+		} else if (Math.abs(angle - 90) < epsilon) { // 90 degree
+			my = -1;
+			ty = getHeight();
+		} else if (Math.abs(angle - 180) < epsilon) { // 180 degree
+			mx = -1;
+			tx = getWidth();
+		} else if (Math.abs(angle - 270) < epsilon) { // 270 degree
+			my = -1;
+			ty = getHeight();
+		} else if (Math.abs(angle - 360) < epsilon) { // 360 degree
+			mx = -1;
+			tx = getWidth();
+		}
+		AffineTransformOp mirOp = new AffineTransformOp(new AffineTransform(mx,
+				0, 0, my, tx, ty), renderHint);
+		BufferedImage mirImg = mirOp.filter(img, null);
+		if (mirImg == null) {
+			throw new ImageOpException("Unable to mirror");
+		}
+		img = mirImg;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see java.lang.Object#finalize()
+	 */
+	protected void finalize() throws Throwable {
+		dispose();
+		super.finalize();
+	}
+
+	public void dispose() {
+		// we must dispose the ImageReader because it keeps the filehandle
+		// open!
+		if (reader != null) {
+			reader.dispose();
+			reader = null;
+		}
+		img = null;
+	}
+
+	public Image getImage(){
+		return (Image) img;
+	}
+	
+	
 }

--- a/servlet/src/digilib/image/JAIDocuImage.java	Thu Jan 14 14:30:30 2010 +0100
+++ b/servlet/src/digilib/image/JAIDocuImage.java	Fri Feb 05 20:58:38 2010 +0100
@@ -1,168 +1,491 @@
 /* JAIDocuImage -- Image class implementation using JAI (Java Advanced Imaging)
 
-  Digital Image Library servlet components
+ Digital Image Library servlet components
 
-  Copyright (C) 2001, 2002 Robert Casties (robcast@mail.berlios.de)
+ Copyright (C) 2001, 2002, 2003 Robert Casties (robcast@mail.berlios.de)
 
-  This program is free software; you can redistribute  it and/or modify it
-  under  the terms of  the GNU General  Public License as published by the
-  Free Software Foundation;  either version 2 of the  License, or (at your
-  option) any later version.
-   
-  Please read license.txt for the full details. A copy of the GPL
-  may be found at http://www.gnu.org/copyleft/lgpl.html
+ This program is free software; you can redistribute  it and/or modify it
+ under  the terms of  the GNU General  Public License as published by the
+ Free Software Foundation;  either version 2 of the  License, or (at your
+ option) any later version.
+ 
+ Please read license.txt for the full details. A copy of the GPL
+ may be found at http://www.gnu.org/copyleft/lgpl.html
 
-  You should have received a copy of the GNU General Public License
-  along with this program; if not, write to the Free Software
-  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
-*/
+ */
 
 package digilib.image;
 
-import javax.servlet.*;
-import javax.servlet.http.*;
-import java.io.*;
-import java.util.*;
+import java.awt.Rectangle;
+import java.awt.RenderingHints;
+import java.awt.image.RenderedImage;
+import java.awt.image.renderable.ParameterBlock;
+import java.io.File;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.Iterator;
+import java.util.List;
 
-import java.awt.*;
-import java.awt.image.*;
-import java.awt.image.renderable.*;
-import javax.media.jai.*;
+import javax.media.jai.BorderExtender;
+import javax.media.jai.Interpolation;
+import javax.media.jai.JAI;
+import javax.media.jai.KernelJAI;
+import javax.media.jai.ParameterBlockJAI;
+import javax.media.jai.RenderedOp;
+import javax.media.jai.operator.TransposeDescriptor;
+import javax.media.jai.operator.TransposeType;
 
-import digilib.*;
-import digilib.io.*;
+import com.sun.media.jai.codec.ImageCodec;
 
+import digilib.io.FileOpException;
+import digilib.io.FileOps;
+import digilib.io.ImageFile;
+import digilib.io.ImageFileset;
 
+/** A DocuImage implementation using Java Advanced Imaging Library. */
 public class JAIDocuImage extends DocuImageImpl {
 
-  private RenderedImage img;
+	protected RenderedImage img;
 
-  public JAIDocuImage() {
-  }
-
-  public JAIDocuImage(Utils u) {
-    util = u;
-  }
+	protected Interpolation interpol = null;
 
-  /**
-   *  load image file
-   */
-  public void loadImage(File f) throws FileOpException {
-    System.gc();
-    img = JAI.create("fileload", f.getAbsolutePath());
-    if (img == null) {
-      util.dprintln(3, "ERROR(loadImage): unable to load file");
-      throw new FileOpException("Unable to load File!");
-    }
-  }
+	/*
+	 * static { // we could set our own tile cache size here TileCache tc =
+	 * JAI.createTileCache(100*1024*1024);
+	 * JAI.getDefaultInstance().setTileCache(tc); }
+	 */
+
+	public boolean isSubimageSupported() {
+		return true;
+	}
 
-  /**
-   *  write image of type mt to Stream
-   */
-  public void writeImage(String mt, ServletResponse res)
-         throws FileOpException {
-    try {
-    // setup output
-    ParameterBlock pb3 = new ParameterBlock();
-    pb3.addSource(img);
-    pb3.add(res.getOutputStream());
-    if (mt == "image/jpeg") {
-      pb3.add("JPEG");
-    } else if (mt == "image/png") {
-      pb3.add("PNG");
-    } else {
-      // unknown mime type
-      util.dprintln(2, "ERROR(writeImage): Unknown mime type "+mt);
-      throw new FileOpException("Unknown mime type: "+mt);
-    }
-    res.setContentType(mt);
-    // render output
-    JAI.create("encode", pb3);
-
-    } catch (IOException e) {
-      throw new FileOpException("Error writing image.");
-    }
-  }
+	/*
+	 * Real setQuality implementation. Creates the correct Interpolation.
+	 */
+	public void setQuality(int qual) {
+		quality = qual;
+		// setup interpolation quality
+		if (qual > 1) {
+			logger.debug("quality q2");
+			interpol = Interpolation.getInstance(Interpolation.INTERP_BICUBIC);
+		} else if (qual == 1) {
+			logger.debug("quality q1");
+			interpol = Interpolation.getInstance(Interpolation.INTERP_BILINEAR);
+		} else {
+			logger.debug("quality q0");
+			interpol = Interpolation.getInstance(Interpolation.INTERP_NEAREST);
+		}
+	}
 
-  public int getWidth() {
-    if (img != null) {
-      return img.getWidth();
-    }
-    return 0;
-  }
-
-  public int getHeight() {
-    if (img != null) {
-      return img.getHeight();
-    }
-    return 0;
-  }
-
-
-  /**
-   *  crop and scale image
-   *    take rectangle width,height at position x_off,y_off
-   *    and scale by scale
-   */
-   public void cropAndScale(int x_off, int y_off, int width, int height,
-         float scale, int qual) throws ImageOpException {
-
-    Interpolation scaleInt = null;
-    // setup interpolation quality
-    if (qual > 1) {
-      util.dprintln(4, "quality q2");
-      scaleInt = Interpolation.getInstance(Interpolation.INTERP_BICUBIC);
-    } else if (qual == 1) {
-      util.dprintln(4, "quality q1");
-      scaleInt = Interpolation.getInstance(Interpolation.INTERP_BILINEAR);
-    } else {
-      util.dprintln(4, "quality q0");
-      scaleInt = Interpolation.getInstance(Interpolation.INTERP_NEAREST);
+	/* returns a list of supported image formats */
+    @SuppressWarnings("unchecked") // ImageCodec.getCodecs() returns a naked Enumeration
+    public Iterator<String> getSupportedFormats() {
+        Enumeration<ImageCodec> codecs = ImageCodec.getCodecs();
+        List<String> formats = new ArrayList<String>();
+        for (ImageCodec codec = codecs.nextElement(); codecs.hasMoreElements(); codec = codecs
+                .nextElement()) {
+            logger.debug("known format:"+codec.getFormatName());
+            formats.add(codec.getFormatName());
+        }
+        logger.debug("tilecachesize:"
+                + JAI.getDefaultInstance().getTileCache().getMemoryCapacity());
+        return formats.iterator();
     }
 
-    // setup Crop
-    ParameterBlock pb1 = new ParameterBlock();
-    pb1.addSource(img);
-    pb1.add((float)x_off);
-    pb1.add((float)y_off);
-    pb1.add((float)width);
-    pb1.add((float)height);
-    RenderedImage croppedImg = JAI.create("crop", pb1);
-    img = null; // free img
+	/* Check image size and type and store in ImageFile f */
+	public boolean identify(ImageFile imgf) throws IOException {
+		// try parent method first
+		if (super.identify(imgf)) {
+			return true;
+		}
+		// fileset to store the information
+		ImageFileset imgfs = imgf.getParent();
+		File f = imgf.getFile();
+		if (f == null) {
+			throw new IOException("File not found!");
+		}
+		/*
+		 * try JAI
+		 */
+		logger.debug("identifying (JAI) " + f);
+		try {
+			RenderedOp img = JAI.create("fileload", f.getAbsolutePath());
+			ImageSize d = new ImageSize(img.getWidth(), img.getHeight());
+			imgf.setSize(d);
+			String t = FileOps.mimeForFile(f);
+			imgf.setMimetype(t);
+			// logger.debug(" format:"+t);
+			if (imgfs != null) {
+				imgfs.setAspect(d);
+			}
+			logger.debug("image size: " + imgf.getSize());
+			return true;
+		} catch (Exception e) {
+			throw new FileOpException("ERROR: unknown image file format!");
+		}
+	}
+
+	/* Load an image file into the Object. */
+	public void loadImage(ImageFile f) throws FileOpException {
+		img = JAI.create("fileload", f.getFile().getAbsolutePath());
+		if (img == null) {
+			throw new FileOpException("Unable to load File!");
+		}
+	}
+
+	/* Load an image file into the Object. */
+	public void loadSubimage(ImageFile f, Rectangle region, int subsample)
+			throws FileOpException {
+		logger.debug("loadSubimage");
+		img = JAI.create("fileload", f.getFile().getAbsolutePath());
+		if ((region.width < img.getWidth())
+				|| (region.height < img.getHeight())) {
+			// setup Crop
+			ParameterBlock cp = new ParameterBlock();
+			cp.addSource(img);
+			cp.add((float) region.x);
+			cp.add((float) region.y);
+			cp.add((float) region.width);
+			cp.add((float) region.height);
+			logger.debug("loadSubimage: crop");
+			img = JAI.create("crop", cp);
+		}
+		if (subsample > 1) {
+			float sc = 1f / subsample;
+			ParameterBlockJAI sp = new ParameterBlockJAI("scale");
+			sp.addSource(img);
+			sp.setParameter("xScale", sc);
+			sp.setParameter("yScale", sc);
+			sp.setParameter("interpolation", Interpolation
+					.getInstance(Interpolation.INTERP_NEAREST));
+			// scale
+			logger.debug("loadSubimage: scale");
+			img = JAI.create("scale", sp);
+		}
+	}
 
-    util.dprintln(3, "CROP:"+croppedImg.getWidth()+"x"+croppedImg.getHeight()); //DEBUG
+	/* Write the current image to an OutputStream. */
+	public void writeImage(String mt, OutputStream ostream)
+			throws FileOpException {
+		try {
+			// setup output
+			ParameterBlock pb3 = new ParameterBlock();
+			pb3.addSource(img);
+			pb3.add(ostream);
+			if (mt == "image/jpeg") {
+				pb3.add("JPEG");
+			} else if (mt == "image/png") {
+				pb3.add("PNG");
+			} else {
+				// unknown mime type
+				throw new FileOpException("Unknown mime type: " + mt);
+			}
+			// render output
+			JAI.create("encode", pb3);
+
+		} catch (IOException e) {
+			throw new FileOpException("Error writing image.");
+		}
+	}
+
+	/**
+	 * The width of the curent image in pixel.
+	 * 
+	 * @return Image width in pixels.
+	 */
+	public int getWidth() {
+		if (img != null) {
+			return img.getWidth();
+		}
+		return 0;
+	}
+
+	/**
+	 * The height of the curent image in pixel.
+	 * 
+	 * @return Image height in pixels.
+	 */
+	public int getHeight() {
+		if (img != null) {
+			return img.getHeight();
+		}
+		return 0;
+	}
 
-    if (croppedImg == null) {
-      util.dprintln(2, "ERROR(cropAndScale): error in crop");
-      throw new ImageOpException("Unable to crop");
-    }
+	/* scales the current image */
+	public void scale(double scale, double scaleY) throws ImageOpException {
+		logger.debug("scale");
+		if ((scale < 1) && (img.getColorModel().getPixelSize() == 1)
+				&& (quality > 0)) {
+			/*
+			 * "SubsampleBinaryToGray" for downscaling BW
+			 */
+			scaleBinary((float) scale);
+		} else if ((scale <= 0.5) && (quality > 1)) {
+			/*
+			 * blur and "Scale" for downscaling color images
+			 */
+			if ((scale <= 0.5) && (quality > 1)) {
+				int bl = (int) Math.floor(1 / scale);
+				// don't blur more than 3
+				blur(Math.min(bl, 3));
+			}
+			scaleAll((float) scale);
+		} else {
+			/*
+			 * "Scale" for the rest
+			 */
+			scaleAll((float) scale);
+		}
+
+		// DEBUG
+		logger.debug("SCALE: " + scale + " ->" + img.getWidth() + "x"
+				+ img.getHeight());
+
+	}
+
+	public void scaleAll(float scale) throws ImageOpException {
+		RenderedImage scaledImg;
+		// DEBUG
+		logger.debug("scaleAll: " + scale);
+		ParameterBlockJAI param = new ParameterBlockJAI("Scale");
+		param.addSource(img);
+		param.setParameter("xScale", scale);
+		param.setParameter("yScale", scale);
+		param.setParameter("interpolation", interpol);
+		// hint with border extender
+		RenderingHints hint = new RenderingHints(JAI.KEY_BORDER_EXTENDER,
+				BorderExtender.createInstance(BorderExtender.BORDER_COPY));
+		// scale
+		scaledImg = JAI.create("Scale", param, hint);
+
+		if (scaledImg == null) {
+			throw new ImageOpException("Unable to scale");
+		}
+		img = scaledImg;
+	}
 
-    // setup scale
-    ParameterBlock pb2 = new ParameterBlock();
-    pb2.addSource(croppedImg);
-    pb2.add(scale);
-    pb2.add(scale);
-    pb2.add(0f);
-    pb2.add(0f);
-    pb2.add(scaleInt);
-    // the following is nice but way too slow...
-    //if (opCrop.getColorModel().getPixelSize() < 8) {
-    // change color model if necessary
-    //  util.dprintln("converting color model...");
-    //  BufferedImage bi = new BufferedImage(1, 1, BufferedImage.TYPE_BYTE_GRAY);
-    //  ImageLayout lay = new ImageLayout(bi);
-    //  rh = new RenderingHints(JAI.KEY_IMAGE_LAYOUT, lay);
-    //}
-    RenderedImage scaledImg = JAI.create("scale", pb2);
-    croppedImg = null; // free opCrop
+	public void blur(int radius) throws ImageOpException {
+		RenderedImage blurredImg;
+		int klen = Math.max(radius, 2);
+		logger.debug("blur: " + klen);
+		int ksize = klen * klen;
+		float f = 1f / ksize;
+		float[] kern = new float[ksize];
+		for (int i = 0; i < ksize; i++) {
+			kern[i] = f;
+		}
+		KernelJAI blur = new KernelJAI(klen, klen, kern);
+		ParameterBlockJAI param = new ParameterBlockJAI("Convolve");
+		param.addSource(img);
+		param.setParameter("kernel", blur);
+		// hint with border extender
+		RenderingHints hint = new RenderingHints(JAI.KEY_BORDER_EXTENDER,
+				BorderExtender.createInstance(BorderExtender.BORDER_COPY));
+		blurredImg = JAI.create("Convolve", param, hint);
+		if (blurredImg == null) {
+			throw new ImageOpException("Unable to scale");
+		}
+		img = blurredImg;
+	}
+
+	public void scaleBinary(float scale) throws ImageOpException {
+		RenderedImage scaledImg;
+		// DEBUG
+		logger.debug("scaleBinary: " + scale);
+		ParameterBlockJAI param = new ParameterBlockJAI("SubsampleBinaryToGray");
+		param.addSource(img);
+		param.setParameter("xScale", scale);
+		param.setParameter("yScale", scale);
+		// hint with border extender
+		RenderingHints hint = new RenderingHints(JAI.KEY_BORDER_EXTENDER,
+				BorderExtender.createInstance(BorderExtender.BORDER_COPY));
+		// scale
+		scaledImg = JAI.create("SubsampleBinaryToGray", param, hint);
+		if (scaledImg == null) {
+			throw new ImageOpException("Unable to scale");
+		}
+		img = scaledImg;
+	}
+
+	/* crops the current image */
+	public void crop(int x_off, int y_off, int width, int height)
+			throws ImageOpException {
+		// setup Crop
+		ParameterBlock param = new ParameterBlock();
+		param.addSource(img);
+		param.add((float) x_off);
+		param.add((float) y_off);
+		param.add((float) width);
+		param.add((float) height);
+		RenderedImage croppedImg = JAI.create("crop", param);
+
+		logger.debug("CROP: " + x_off + "," + y_off + ", " + width + ","
+				+ height + " ->" + croppedImg.getWidth() + "x"
+				+ croppedImg.getHeight());
+		// DEBUG
+
+		if (croppedImg == null) {
+			throw new ImageOpException("Unable to crop");
+		}
+		img = croppedImg;
+	}
+
+	/* rotates the current image */
+	public void rotate(double angle) throws ImageOpException {
+		RenderedImage rotImg;
+		// convert degrees to radians
+		double rangle = Math.toRadians(angle);
+		double x = img.getWidth() / 2;
+		double y = img.getHeight() / 2;
+
+		// optimize rotation by right angles
+		TransposeType rotOp = null;
+		if (Math.abs(angle - 0) < epsilon) {
+			// 0 degree
+			return;
+		} else if (Math.abs(angle - 90) < epsilon) {
+			// 90 degree
+			rotOp = TransposeDescriptor.ROTATE_90;
+		} else if (Math.abs(angle - 180) < epsilon) {
+			// 180 degree
+			rotOp = TransposeDescriptor.ROTATE_180;
+		} else if (Math.abs(angle - 270) < epsilon) {
+			// 270 degree
+			rotOp = TransposeDescriptor.ROTATE_270;
+		} else if (Math.abs(angle - 360) < epsilon) {
+			// 360 degree
+			return;
+		}
+		if (rotOp != null) {
+			// use Transpose operation
+			ParameterBlock pb = new ParameterBlock();
+			pb.addSource(img);
+			pb.add(rotOp);
+			rotImg = JAI.create("transpose", pb);
+		} else {
+			// setup "normal" rotation
+			ParameterBlock param = new ParameterBlock();
+			param.addSource(img);
+			param.add((float) x);
+			param.add((float) y);
+			param.add((float) rangle);
+			param.add(interpol);
 
-    if (scaledImg == null) {
-      util.dprintln(2, "ERROR(cropAndScale): error in scale");
-      throw new ImageOpException("Unable to scale");
-    }
+			rotImg = JAI.create("rotate", param);
+		}
+
+		logger.debug("ROTATE: " + x + "," + y + ", " + angle + " (" + rangle
+				+ ")" + " ->" + rotImg.getWidth() + "x" + rotImg.getHeight());
+		// DEBUG
+
+		if (rotImg == null) {
+			throw new ImageOpException("Unable to rotate");
+		}
+		img = rotImg;
+	}
+
+	/*
+	 * mirrors the current image works only horizontal and vertical
+	 */
+	public void mirror(double angle) throws ImageOpException {
+		RenderedImage mirImg;
+		// only mirroring by right angles
+		TransposeType rotOp = null;
+		if (Math.abs(angle) < epsilon) {
+			// 0 degree
+			rotOp = TransposeDescriptor.FLIP_HORIZONTAL;
+		} else if (Math.abs(angle - 90) < epsilon) {
+			// 90 degree
+			rotOp = TransposeDescriptor.FLIP_VERTICAL;
+		} else if (Math.abs(angle - 180) < epsilon) {
+			// 180 degree
+			rotOp = TransposeDescriptor.FLIP_HORIZONTAL;
+		} else if (Math.abs(angle - 270) < epsilon) {
+			// 270 degree
+			rotOp = TransposeDescriptor.FLIP_VERTICAL;
+		} else if (Math.abs(angle - 360) < epsilon) {
+			// 360 degree
+			rotOp = TransposeDescriptor.FLIP_HORIZONTAL;
+		}
+		// use Transpose operation
+		ParameterBlock param = new ParameterBlock();
+		param.addSource(img);
+		param.add(rotOp);
+		mirImg = JAI.create("transpose", param);
+
+		if (mirImg == null) {
+			throw new ImageOpException("Unable to flip");
+		}
+		img = mirImg;
+	}
 
-    img = scaledImg;
-  }
+	/* contrast and brightness enhancement */
+	public void enhance(float mult, float add) throws ImageOpException {
+		RenderedImage enhImg;
+		double[] ma = { mult };
+		double[] aa = { add };
+		// use Rescale operation
+		ParameterBlock param = new ParameterBlock();
+		param.addSource(img);
+		param.add(ma);
+		param.add(aa);
+		enhImg = JAI.create("rescale", param);
+
+		logger.debug("ENHANCE: *" + mult + ", +" + add + " ->"
+				+ enhImg.getWidth() + "x" + enhImg.getHeight());
+		// DEBUG
+
+		if (enhImg == null) {
+			throw new ImageOpException("Unable to enhance");
+		}
+		img = enhImg;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see digilib.image.DocuImage#enhanceRGB(float[], float[])
+	 */
+	public void enhanceRGB(float[] rgbm, float[] rgba) throws ImageOpException {
+		RenderedImage enhImg;
+		int nb = rgbm.length;
+		double[] ma = new double[nb];
+		double[] aa = new double[nb];
+		for (int i = 0; i < nb; i++) {
+			ma[i] = rgbm[i];
+			aa[i] = rgba[i];
+		}
+		// use Rescale operation
+		ParameterBlock param = new ParameterBlock();
+		param.addSource(img);
+		param.add(ma);
+		param.add(aa);
+		enhImg = JAI.create("rescale", param);
+
+		logger.debug("ENHANCE_RGB: *" + rgbm + ", +" + rgba + " ->"
+				+ enhImg.getWidth() + "x" + enhImg.getHeight());
+		// DEBUG
+
+		if (enhImg == null) {
+			throw new ImageOpException("Unable to enhanceRGB");
+		}
+		img = enhImg;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see digilib.image.DocuImage#dispose()
+	 */
+	public void dispose() {
+		img = null;
+	}
 
 }

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/servlet/src/digilib/image/JAIImageLoaderDocuImage.java	Fri Feb 05 20:58:38 2010 +0100
@@ -0,0 +1,184 @@
+/* JAIImageLoaderDocuImage -- Image class implementation using JAI's ImageLoader Plugin
+
+  Digital Image Library servlet components
+
+  Copyright (C) 2002, 2003 Robert Casties (robcast@mail.berlios.de)
+
+  This program is free software; you can redistribute  it and/or modify it
+  under  the terms of  the GNU General  Public License as published by the
+  Free Software Foundation;  either version 2 of the  License, or (at your
+  option) any later version.
+   
+  Please read license.txt for the full details. A copy of the GPL
+  may be found at http://www.gnu.org/copyleft/lgpl.html
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*/
+
+package digilib.image;
+
+import java.awt.Rectangle;
+import java.awt.image.renderable.ParameterBlock;
+import java.io.File;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.RandomAccessFile;
+import java.util.Iterator;
+
+import javax.imageio.ImageIO;
+import javax.imageio.ImageReadParam;
+import javax.imageio.ImageReader;
+import javax.imageio.stream.FileImageInputStream;
+import javax.imageio.stream.ImageInputStream;
+import javax.media.jai.JAI;
+
+import digilib.io.FileOpException;
+import digilib.io.ImageFile;
+
+/** DocuImage implementation using the Java Advanced Imaging API and the ImageLoader
+ * API of Java 1.4.
+ */
+public class JAIImageLoaderDocuImage extends JAIDocuImage {
+
+	/** ImageIO image reader */
+	protected ImageReader reader;
+	/** current image file */
+	protected File imgFile;
+
+	/* loadSubimage is supported. */
+	public boolean isSubimageSupported() {
+		return true;
+	}
+
+	public int getHeight() {
+		int h = 0;
+		try {
+			if (img == null) {
+				h = reader.getHeight(0);
+			} else {
+				h = img.getHeight();
+			}
+		} catch (IOException e) {
+			logger.debug("error in getHeight", e);
+		}
+		return h;
+	}
+
+	public int getWidth() {
+		int w = 0;
+		try {
+			if (img == null) {
+				w = reader.getWidth(0);
+			} else {
+				w = img.getWidth();
+			}
+		} catch (IOException e) {
+			logger.debug("error in getHeight", e);
+		}
+		return w;
+	}
+
+	/* Load an image file into the Object. */
+	public void loadImage(ImageFile f) throws FileOpException {
+		logger.debug("loadImage: "+f.getFile());
+		//System.gc();
+		img = JAI.create("ImageRead", f.getFile().getAbsolutePath());
+		if (img == null) {
+			throw new FileOpException("Unable to load File!");
+		}
+	}
+
+	/* Get an ImageReader for the image file. */
+	public ImageReader getReader(ImageFile f) throws IOException {
+		logger.debug("preloadImage: "+f.getFile());
+		//System.gc();
+		RandomAccessFile rf = new RandomAccessFile(f.getFile(), "r");
+		ImageInputStream istream = new FileImageInputStream(rf);
+		//Iterator readers = ImageIO.getImageReaders(istream);
+		Iterator<ImageReader> readers = ImageIO.getImageReadersByMIMEType(f.getMimetype());
+		if (! readers.hasNext()) {
+			throw new FileOpException("Unable to load File!");
+		}
+		reader = readers.next();
+		logger.debug("JAIImageIO: this reader: " + reader.getClass());
+		while (readers.hasNext()) {
+			logger.debug("  next reader: " + readers.next().getClass());
+		}
+		reader.setInput(istream);
+		return reader;
+	}
+
+	/* Load an image file into the Object. */
+	public void loadSubimage(ImageFile f, Rectangle region, int prescale)
+		throws FileOpException {
+		logger.debug("loadSubimage: "+f.getFile());
+		//System.gc();
+		try {
+			if ((reader == null) || (imgFile != f.getFile())) {
+				getReader(f);
+			}
+			ImageReadParam readParam = reader.getDefaultReadParam();
+			readParam.setSourceRegion(region);
+			readParam.setSourceSubsampling(prescale, prescale, 0, 0);
+			img = reader.read(0, readParam);
+			/* JAI imageread seems to ignore the readParam :-(
+			ImageInputStream istream = (ImageInputStream) reader.getInput();
+			ParameterBlockJAI pb = new ParameterBlockJAI("imageread");
+			pb.setParameter("Input", istream);
+			pb.setParameter("ReadParam", readParam);
+			pb.setParameter("Reader", reader);
+			img = JAI.create("imageread", pb);
+			*/
+		} catch (IOException e) {
+			throw new FileOpException("Unable to load File!");
+		}
+		if (img == null) {
+			throw new FileOpException("Unable to load File!");
+		}
+		imgFile = f.getFile();
+	}
+
+
+	/* Write the current image to an OutputStream. */
+	public void writeImage(String mt, OutputStream ostream)
+		throws FileOpException {
+		logger.debug("writeImage");
+		try {
+			// setup output
+			ParameterBlock pb3 = new ParameterBlock();
+			pb3.addSource(img);
+			pb3.add(ostream);
+			if (mt == "image/jpeg") {
+				pb3.add("JPEG");
+			} else if (mt == "image/png") {
+				pb3.add("PNG");
+			} else {
+				// unknown mime type
+				throw new FileOpException("Unknown mime type: " + mt);
+			}
+			// render output
+			JAI.create("ImageWrite", pb3);
+		} catch (IOException e) {
+			throw new FileOpException("Error writing image.");
+		}
+	}
+
+	/* (non-Javadoc)
+	 * @see java.lang.Object#finalize()
+	 */
+	protected void finalize() throws Throwable {
+		dispose();
+		super.finalize();
+	}
+
+	public void dispose() {
+		// we must dispose the ImageReader because it keeps the filehandle open!
+		reader.dispose();
+		reader = null;
+		img = null;
+	}
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/servlet/src/digilib/io/AliasingDocuDirCache.java	Fri Feb 05 20:58:38 2010 +0100
@@ -0,0 +1,96 @@
+/*
+ * AliasingDocuDirCache -- DocuDirCache using alias entries from config file
+ * 
+ * Digital Image Library servlet components
+ * 
+ * Copyright (C) 2003 Robert Casties (robcast@mail.berlios.de)
+ * 
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ * 
+ * Please read license.txt for the full details. A copy of the GPL may be found
+ * at http://www.gnu.org/copyleft/lgpl.html
+ * 
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+ * Place, Suite 330, Boston, MA 02111-1307 USA
+ * 
+ * Created on 04.11.2003
+ */
+
+package digilib.io;
+
+import java.io.File;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import digilib.servlet.DigilibConfiguration;
+
+/**
+ * @author casties
+ *  
+ */
+public class AliasingDocuDirCache extends DocuDirCache {
+
+	/**
+	 * @param baseDirs
+	 * @param fileClasses
+	 * @param confFileName
+	 * @throws FileOpException
+	 */
+	public AliasingDocuDirCache(String[] baseDirs, int[] fileClasses,
+			File confFile, DigilibConfiguration dlConfig)
+			throws FileOpException {
+		// create standard DocuDirCache
+		super(baseDirs, fileClasses, dlConfig);
+		Map<String,String> pathMap = null;
+		// read alias config file
+		try {
+			// load into pathMap
+			XMLListLoader mapLoader = new XMLListLoader("digilib-aliases",
+					"mapping", "link", "dir");
+			pathMap = mapLoader.loadURL(confFile.toURL().toString());
+		} catch (Exception e) {
+			throw new FileOpException("ERROR loading mapping file: " + e);
+		}
+		if (pathMap == null) {
+			throw new FileOpException("ERROR: unable to load mapping file!");
+		}
+
+		/*
+		 * load map entries into cache
+		 */
+
+		for (Entry<String, String> linkdir: pathMap.entrySet()) {
+			if (linkdir.getValue() == null) {
+				logger.error("Key mismatch in mapping file!");
+				break;	
+			}
+			DocuDirectory destDir = new DocuDirectory(linkdir.getValue(), this);
+			if (destDir.isValid()) {
+				logger.debug("Aliasing dir: " + linkdir.getKey());
+				// add the alias name
+				putName(FileOps.normalName(linkdir.getKey()), destDir);
+				// add the real dir
+				putDir(destDir);
+			}
+		}
+	}
+
+	/**
+	 * Adds a DocuDirectory under another name to the cache.
+	 * 
+	 * @param name
+	 * @param newdir
+	 */
+    public void putName(String name, DocuDirectory newdir) {
+        if (map.containsKey(name)) {
+            logger.warn("Duplicate key in AliasingDocuDirCache.put -- ignored!");
+        } else {
+            map.put(name, newdir);
+        }
+    }
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/servlet/src/digilib/io/DocuDirCache.java	Fri Feb 05 20:58:38 2010 +0100
@@ -0,0 +1,361 @@
+/*
+ * DocuDirCache.java
+ * 
+ * Digital Image Library servlet components
+ * 
+ * Copyright (C) 2003 Robert Casties (robcast@mail.berlios.de)
+ * 
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ * 
+ * Please read license.txt for the full details. A copy of the GPL may be found
+ * at http://www.gnu.org/copyleft/lgpl.html
+ * 
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+ * Place, Suite 330, Boston, MA 02111-1307 USA
+ * 
+ * Created on 03.03.2003
+ */
+
+package digilib.io;
+
+import java.io.File;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.log4j.Logger;
+
+import digilib.servlet.DigilibConfiguration;
+
+/**
+ * @author casties
+ */
+public class DocuDirCache {
+
+	/** general logger for this class */
+	Logger logger = Logger.getLogger(this.getClass());
+
+	/** HashMap of directories */
+	Map<String, DocuDirectory> map = null;
+
+	/** names of base directories */
+	String[] baseDirNames = null;
+
+	/** array of allowed file classes (image/text) */
+	private int[] fileClasses = null;
+
+	/** number of files in the whole cache (approximate) */
+	long numFiles = 0;
+
+	/** number of cache hits */
+	long hits = 0;
+
+	/** number of cache misses */
+	long misses = 0;
+
+	/** use safe (but slow) indexing */
+	boolean safeDirIndex = false;
+
+	/** the root directory element */
+	public static Directory ROOT = null;
+
+	/**
+	 * Constructor with array of base directory names and file classes.
+	 * 
+	 * @param bd
+	 *            base directory names
+	 */
+	public DocuDirCache(String[] bd, int[] fileClasses,
+			DigilibConfiguration dlConfig) {
+		baseDirNames = bd;
+		map = new HashMap<String, DocuDirectory>();
+		this.fileClasses = fileClasses;
+		safeDirIndex = dlConfig.getAsBoolean("safe-dir-index");
+	}
+
+	/**
+	 * Constructor with array of base directory names.
+	 * 
+	 * @param bd
+	 *            base directory names
+	 */
+	public DocuDirCache(String[] bd) {
+		baseDirNames = bd;
+		map = new HashMap<String, DocuDirectory>();
+		// default file class is CLASS_IMAGE
+		fileClasses = new int[1];
+		fileClasses[0] = FileOps.CLASS_IMAGE;
+	}
+
+	/**
+	 * The number of directories in the cache.
+	 * 
+	 * @return
+	 */
+	public int size() {
+		return (map != null) ? map.size() : 0;
+	}
+
+	/**
+	 * Add a DocuDirectory to the cache.
+	 * 
+	 * @param newdir
+	 */
+	public void put(DocuDirectory newdir) {
+		String s = newdir.getDirName();
+		if (map.containsKey(s)) {
+			logger.warn("Duplicate key in DocuDirCache.put -- ignoring!");
+		} else {
+			map.put(s, newdir);
+			numFiles += newdir.size();
+		}
+	}
+
+	/**
+	 * Add a directory to the cache and check its parents.
+	 * 
+	 * @param newDir
+	 */
+	public synchronized void putDir(DocuDirectory newDir) {
+		put(newDir);
+		String parent = FileOps.parent(newDir.getDirName());
+		if (parent != "") {
+			// check the parent in the cache
+			DocuDirectory pd = (DocuDirectory) map.get(parent);
+			if (pd == null) {
+				// the parent is unknown
+				pd = new DocuDirectory(parent, this);
+				putDir(pd);
+			}
+			newDir.setParent(pd);
+		}
+	}
+
+	/**
+	 * Get a list with all children of a directory.
+	 * 
+	 * Returns a List of DocuDirectory's. Returns an empty List if the directory
+	 * has no children. If recurse is false then only direct children are
+	 * returned.
+	 * 
+	 * @param dirname
+	 * @param recurse
+	 *            find all children and their children.
+	 * @return
+	 */
+	public List<DocuDirectory> getChildren(String dirname, boolean recurse) {
+		List<DocuDirectory> l = new LinkedList<DocuDirectory>();
+		for (DocuDirectory dd: map.values()) {
+			if (recurse) {
+				if (dd.getDirName().startsWith(dirname)) {
+					l.add(dd);
+				}
+			} else {
+				if (FileOps.parent(dd.getDirName()).equals(dirname)) {
+					l.add(dd);
+				}
+			}
+		}
+		return l;
+	}
+
+	/**
+	 * Returns the DocuDirent with the pathname <code>fn</code> and the index
+	 * <code>in</code> and the class <code>fc</code>.
+	 * 
+	 * If <code>fn</code> is a file then the corresponding DocuDirent is
+	 * returned and the index is ignored.
+	 * 
+	 * @param fn
+	 *            digilib pathname
+	 * @param in
+	 *            file index
+	 * @param fc
+	 *            file class
+	 * @return
+	 */
+	public DocuDirent getFile(String fn, int in, int fc) {
+		DocuDirectory dd;
+		// file number is 1-based, vector index is 0-based
+		int n = in - 1;
+		// first, assume fn is a directory and look in the cache
+		dd = (DocuDirectory) map.get(fn);
+        // logger.debug("fn: " + fn);
+        // logger.debug("dd: " + dd);
+		if (dd == null) {
+			// cache miss
+			misses++;
+			/*
+			 * see if fn is a directory
+			 */
+			File f = new File(baseDirNames[0], fn);
+			if (f.isDirectory()) {
+                // logger.debug(fn + " is a dir");
+				dd = new DocuDirectory(fn, this);
+				if (dd.isValid()) {
+					// add to the cache
+					putDir(dd);
+				}
+			} else {
+				/*
+				 * maybe it's a file
+				 */
+				// get the parent directory string (like we store it in the
+				// cache)
+				String d = FileOps.parent(fn);
+				// try it in the cache
+                // logger.debug(fn + " is a file in dir " + d);
+				dd = (DocuDirectory) map.get(d);
+				if (dd == null) {
+					// try to read from disk
+					dd = new DocuDirectory(d, this);
+					if (dd.isValid()) {
+						// add to the cache
+                        // logger.debug(dd + " is valid");
+						putDir(dd);
+					} else {
+						// invalid path
+						return null;
+					}
+				} else {
+					// it was not a real cache miss
+					misses--;
+				}
+				// get the file's index
+				n = dd.indexOf(f.getName(), fc);
+                // logger.debug(f.getName() + ", index is " + n + ", fc = " + fc);
+			}
+		} else {
+			// cache hit
+			hits++;
+		}
+		dd.refresh();
+        // logger.debug(dd + " refreshed");
+		if (dd.isValid()) {
+			try {
+                // logger.debug(dd + " is valid");
+				return dd.get(n, fc);
+			} catch (IndexOutOfBoundsException e) {
+                // logger.debug(fn + " not found in directory");
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * Returns the DocuDirectory indicated by the pathname <code>fn</code>.
+	 * 
+	 * If <code>fn</code> is a file then its parent directory is returned.
+	 * 
+	 * @param fn
+	 *            digilib pathname
+	 * @return
+	 */
+	public DocuDirectory getDirectory(String fn) {
+		DocuDirectory dd;
+		// first, assume fn is a directory and look in the cache
+		dd = (DocuDirectory) map.get(fn);
+		if (dd == null) {
+			// cache miss
+			misses++;
+			// see if it's a directory
+			File f = new File(baseDirNames[0], fn);
+			if (f.isDirectory()) {
+				dd = new DocuDirectory(fn, this);
+				if (dd.isValid()) {
+					// add to the cache
+					putDir(dd);
+				}
+			} else {
+				// maybe it's a file
+				if (f.canRead()) {
+					// try the parent directory in the cache
+					dd = (DocuDirectory) map.get(f.getParent());
+					if (dd == null) {
+						// try to read from disk
+						dd = new DocuDirectory(f.getParent(), this);
+						if (dd.isValid()) {
+							// add to the cache
+							putDir(dd);
+						} else {
+							// invalid path
+							return null;
+						}
+					} else {
+						// not a real cache miss then
+						misses--;
+					}
+				} else {
+					// it's not even a file :-(
+					return null;
+				}
+			}
+		} else {
+			// cache hit
+			hits++;
+		}
+		dd.refresh();
+		if (dd.isValid()) {
+			return dd;
+		}
+		return null;
+	}
+
+	/**
+	 * @return String[]
+	 */
+	public String[] getBaseDirNames() {
+		return baseDirNames;
+	}
+
+	/**
+	 * @return long
+	 */
+	public long getNumFiles() {
+		return numFiles;
+	}
+
+	/**
+	 * Sets the baseDirNames.
+	 * 
+	 * @param baseDirNames
+	 *            The baseDirNames to set
+	 */
+	public void setBaseDirNames(String[] baseDirNames) {
+		this.baseDirNames = baseDirNames;
+	}
+
+	/**
+	 * @return long
+	 */
+	public long getHits() {
+		return hits;
+	}
+
+	/**
+	 * @return long
+	 */
+	public long getMisses() {
+		return misses;
+	}
+
+	/**
+	 * @return
+	 */
+	public int[] getFileClasses() {
+		return fileClasses;
+	}
+
+	/**
+	 * @param fileClasses
+	 */
+	public void setFileClasses(int[] fileClasses) {
+		this.fileClasses = fileClasses;
+	}
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/servlet/src/digilib/io/DocuDirectory.java	Fri Feb 05 20:58:38 2010 +0100
@@ -0,0 +1,576 @@
+/* DocuDirectory -- Directory of DocuFilesets.
+
+ Digital Image Library servlet components
+
+ Copyright (C) 2003 Robert Casties (robcast@mail.berlios.de)
+
+ This program is free software; you can redistribute  it and/or modify it
+ under  the terms of  the GNU General  Public License as published by the
+ Free Software Foundation;  either version 2 of the  License, or (at your
+ option) any later version.
+ 
+ Please read license.txt for the full details. A copy of the GPL
+ may be found at http://www.gnu.org/copyleft/lgpl.html
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+ * Created on 25.02.2003
+ */
+
+package digilib.io;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import org.xml.sax.SAXException;
+
+/**
+ * @author casties
+ */
+public class DocuDirectory extends Directory {
+
+	/** list of files (DocuDirent) */
+	private List<List<DocuDirent>> list = null;
+
+	/** directory object is valid (exists on disk) */
+	private boolean isValid = false;
+
+	/** reference of the parent DocuDirCache */
+	private DocuDirCache cache = null;
+
+	/** directory name (digilib canonical form) */
+	private String dirName = null;
+
+	/** directory metadata */
+	private MetadataMap dirMeta = null;
+
+	/** state of metadata is valid */
+	private boolean metaChecked = false;
+
+	/** unresolved file metadata */
+	private Map<String, MetadataMap> unresolvedFileMeta = null;
+
+	/** time of last access of this object (not the filesystem) */
+	private long objectATime = 0;
+
+	/** time directory was last modified on the file system */
+	private long dirMTime = 0;
+
+	/**
+	 * Constructor with digilib directory path and a parent DocuDirCache.
+	 * 
+	 * Directory names at the given path are appended to the base directories
+	 * from the cache. The directory is checked on disk and isValid is set.
+	 * 
+	 * @see readDir
+	 * 
+	 * @param path
+	 *            digilib directory path name
+	 * @param cache
+	 *            parent DocuDirCache
+	 */
+	public DocuDirectory(String path, DocuDirCache cache) {
+		this.dirName = path;
+		this.cache = cache;
+		initDir();
+		checkDir();
+	}
+
+	/**
+	 * Sets and checks the dir object.
+	 *  
+	 */
+	protected void initDir() {
+		String baseDirName = cache.getBaseDirNames()[0];
+		// clear directory first
+		//list = new ArrayList[FileOps.NUM_CLASSES];
+
+		list = new ArrayList<List<DocuDirent>>(FileOps.NUM_CLASSES);
+		// create empty list
+		for (int i=0; i < FileOps.NUM_CLASSES; ++i) {
+		    list.add(null);
+		}
+		isValid = false;
+		dirMTime = 0;
+		// the first directory has to exist
+		dir = new File(baseDirName, dirName);
+	}
+
+	/**
+	 * number of DocuFiles in this directory.
+	 *  
+	 */
+	public int size() {
+		return ((list != null) && (list.get(0) != null)) ? list.get(0).size() : 0;
+	}
+
+	/**
+	 * number of files of this class in this directory.
+	 * 
+	 * @param fc
+	 *            fileClass
+	 */
+	public int size(int fc) {
+		return ((list != null) && (list.get(fc) != null)) ? list.get(fc).size() : 0;
+	}
+
+	/**
+	 * Returns the ImageFile at the index.
+	 * 
+	 * @param index
+	 * @return
+	 */
+	public ImageFileset get(int index) {
+		if ((list == null) || (list.get(0) == null) || (index >= list.get(0).size())) {
+			return null;
+		}
+		return (ImageFileset) list.get(0).get(index);
+	}
+
+	/**
+	 * Returns the file of the class at the index.
+	 * 
+	 * @param index
+	 * @param fc
+	 *            fileClass
+	 * @return
+	 */
+	public DocuDirent get(int index, int fc) {
+		if ((list == null) || (list.get(fc) == null) || (index >= list.get(fc).size())) {
+			return null;
+		}
+		return (DocuDirent) list.get(fc).get(index);
+	}
+
+	/**
+	 * Checks if the directory exists on the filesystem.
+	 * 
+	 * Sets isValid.
+	 * 
+	 * @return
+	 */
+	public boolean checkDir() {
+		if (dir == null) {
+			initDir();
+		}
+		isValid = dir.isDirectory();
+		return isValid;
+	}
+
+	/**
+	 * Read the filesystem directory and fill this object.
+	 * 
+	 * Clears the List and (re)reads all files.
+	 * 
+	 * @return boolean the directory exists
+	 */
+	public synchronized boolean readDir() {
+		// check directory first
+		checkDir();
+		if (!isValid) {
+			return false;
+		}
+		// first file extension to try for scaled directories
+		String scalext = null;
+		// read all filenames
+		logger.debug("reading directory " + dir.getPath());
+		/*
+		 * using ReadableFileFilter is safer (we won't get directories with file
+		 * extensions) but slower.
+		 */
+		File[] allFiles = null;
+		if (cache.safeDirIndex) {
+			allFiles = dir.listFiles(new FileOps.ReadableFileFilter());
+		} else {
+			allFiles = dir.listFiles();
+		}
+		//logger.debug("  done");
+		if (allFiles == null) {
+			// not a directory
+			return false;
+		}
+		// list of base dirs from the parent cache
+		String[] baseDirNames = cache.getBaseDirNames();
+		// number of base dirs
+		int nb = baseDirNames.length;
+		// array of base dirs
+		Directory[] dirs = new Directory[nb];
+		// first entry is this directory
+		dirs[0] = this;
+		// fill array with the remaining directories
+		for (int j = 1; j < nb; j++) {
+			File d = new File(baseDirNames[j], dirName);
+			if (d.isDirectory()) {
+				dirs[j] = new Directory(d);
+				logger.debug("  reading scaled directory " + d.getPath());
+				dirs[j].readDir();
+				//logger.debug("    done");
+			}
+		}
+
+		// go through all file classes
+		for (int classIdx = 0; classIdx < FileOps.NUM_CLASSES; classIdx++) {
+			int fileClass = cache.getFileClasses()[classIdx];
+			//logger.debug("filtering directory "+dir.getPath()+" for class
+			// "+fc);
+			File[] fileList = FileOps.listFiles(allFiles, FileOps
+					.filterForClass(fileClass));
+			//logger.debug(" done");
+			// number of files in the directory
+			int numFiles = fileList.length;
+			if (numFiles > 0) {
+				// create new list
+				list.set(fileClass, new ArrayList<DocuDirent>(numFiles));
+				// sort the file names alphabetically and iterate the list
+				// Arrays.sort(fileList); // not needed <hertzhaft>
+				Map<Integer, Object> hints = FileOps.newHints(FileOps.HINT_BASEDIRS, dirs);
+				hints.put(FileOps.HINT_FILEEXT, scalext);
+				for (int i = 0; i < numFiles; i++) {
+					DocuDirent f = FileOps.fileForClass(fileClass, fileList[i],
+							hints);
+					// add the file to our list
+                    // logger.debug(f.getName());
+
+					list.get(fileClass).add(f);
+					f.setParent(this);
+				}
+                // we sort the inner ArrayList (the list of files not the list of file types)
+				// for binarySearch to work (DocuDirent's natural sort order is by filename)
+                Collections.sort(list.get(fileClass));
+			}
+		}
+		// clear the scaled directories
+		for (int j = 1; j < nb; j++) {
+			if (dirs[j] != null) {
+				dirs[j].clearFilenames();
+			}
+		}
+		// update number of cached files if this was the first time
+		if (dirMTime == 0) {
+			cache.numFiles += size();
+		}
+		dirMTime = dir.lastModified();
+		// read metadata as well
+		readMeta();
+		return isValid;
+	}
+
+	/**
+	 * Check to see if the directory has been modified and reread if necessary.
+	 * 
+	 * @return boolean the directory is valid
+	 */
+	public boolean refresh() {
+		if (isValid) {
+			if (dir.lastModified() > dirMTime) {
+				// on-disk modification time is more recent
+				readDir();
+			}
+			touch();
+		}
+		return isValid;
+	}
+
+	/**
+	 * Read directory metadata.
+	 *  
+	 */
+	public void readMeta() {
+		// check for directory metadata...
+		File mf = new File(dir, "index.meta");
+		if (mf.canRead()) {
+			XMLMetaLoader ml = new XMLMetaLoader();
+			try {
+				// read directory meta file
+				Map<String, MetadataMap> fileMeta = ml.loadURL(mf.getAbsolutePath());
+				if (fileMeta == null) {
+					return;
+				}
+				// meta for the directory itself is in the "" bin
+				dirMeta = fileMeta.remove("");
+				// read meta for files in this directory
+				readFileMeta(fileMeta, null);
+				// is there meta for other files left?
+				if (fileMeta.size() > 0) {
+					unresolvedFileMeta = fileMeta;
+				}
+			} catch (SAXException e) {
+				logger.warn("error parsing index.meta", e);
+			} catch (IOException e) {
+				logger.warn("error reading index.meta", e);
+			}
+		}
+		readParentMeta();
+		metaChecked = true;
+	}
+
+	/**
+	 * Read metadata from all known parent directories.
+	 *  
+	 */
+	public void readParentMeta() {
+		// check the parent directories for additional file meta
+		Directory dd = parent;
+		String path = dir.getName();
+		while (dd != null) {
+			if (((DocuDirectory) dd).hasUnresolvedFileMeta()) {
+				readFileMeta(((DocuDirectory) dd).unresolvedFileMeta, path);
+			}
+			// prepend parent dir path
+			path = dd.dir.getName() + "/" + path;
+			// become next parent
+			dd = dd.parent;
+		}
+	}
+
+	/**
+	 * Read metadata for the files in this directory.
+	 * 
+	 * Takes a Map with meta-information, adding the relative path before the
+	 * lookup.
+	 * 
+	 * @param fileMeta
+	 * @param relPath
+	 * @param fc
+	 *            fileClass
+	 */
+	protected void readFileMeta(Map<String,MetadataMap> fileMeta, String relPath) {
+		if (list == null) {
+			// there are no files
+			return;
+		}
+		String path = (relPath != null) ? (relPath + "/") : "";
+		// go through all file classes
+		for (int nc = 0; nc < list.size(); nc++) {
+			int fc = cache.getFileClasses()[nc];
+			if (list.get(fc) == null) {
+				continue;
+			}
+			// iterate through the list of files in this directory
+			for (DocuDirent f: list.get(fc)) {
+				// prepend path to the filename
+				String fn = path + f.getName();
+				// look up meta for this file and remove from dir
+				MetadataMap meta = fileMeta.remove(fn);
+				if (meta != null) {
+					// store meta in file
+					f.setFileMeta(meta);
+				}
+			}
+		}
+	}
+
+	protected void notifyChildMeta(MetadataMap childmeta) {
+		List<DocuDirectory> children = cache.getChildren(this.dirName, true);
+		if (children.size() > 0) {
+			/*for (DocuDirectory d: children) {
+				// TODO: finish this!
+				//((DocuDirectory) i.next()).readFileMeta()
+			}*/
+		}
+	}
+
+	/**
+	 * Update access time.
+	 * 
+	 * @return long time of last access.
+	 */
+	public long touch() {
+		long t = objectATime;
+		objectATime = System.currentTimeMillis();
+		return t;
+	}
+
+	/**
+	 * Searches for the file with the name <code>fn</code>.
+	 * 
+	 * Searches the directory for the file with the name <code>fn</code> and
+	 * returns its index. Returns -1 if the file cannot be found.
+	 * 
+	 * @param fn
+	 *            filename
+	 * @param fc
+	 *            file class
+	 * @return int index of file <code>fn</code>
+	 */
+	public int indexOf(String fn) {
+		int fc = FileOps.classForFilename(fn);
+		return indexOf(fn, fc);
+	}
+
+	/**
+	 * Searches for the file with the name <code>fn</code> and class fc.
+	 * 
+	 * Searches the directory for the file with the name <code>fn</code> and
+	 * returns its index. Returns -1 if the file cannot be found.
+	 * 
+	 * @param fn
+	 *            filename
+	 * @return int index of file <code>fn</code>
+	 */
+	public int indexOf(String fn, int fc) {
+		if (!isRead()) {
+			// read directory now
+			if (!readDir()) {
+				return -1;
+			}
+		}
+		List<DocuDirent> fileList = list.get(fc);
+		// empty directory?
+		if (fileList == null) {
+			return -1;
+		}
+        
+		// search for exact match (DocuDirent does compareTo<String>)
+        // OBS: fileList needs to be sorted first (see )! <hertzhaft>
+		int idx = Collections.binarySearch(fileList, fn);
+		if (idx >= 0) {
+			return idx;
+		} else {
+            logger.debug(fn + " not found by binarysearch");
+			// try closest matches without extension
+			idx = -idx - 1;
+			if ((idx < fileList.size())
+					&& isBaseInList(fileList, idx, fn)) {
+				// idx matches
+				return idx;
+			} else if ((idx > 0)
+					&& isBaseInList(fileList, idx-1, fn)) {
+				// idx-1 matches
+				return idx - 1;
+			} else if ((idx + 1 < fileList.size())
+					&& isBaseInList(fileList, idx+1, fn)) {
+				// idx+1 matches
+				return idx + 1;
+			}
+
+		}
+		return -1;
+	}
+
+	private boolean isBaseInList(List<DocuDirent> fl, int idx, String fn) {
+		String dfn = FileOps.basename((fl.get(idx))
+				.getName());
+		return (dfn.equals(fn)||dfn.equals(FileOps.basename(fn))); 
+	}
+	
+	
+	/**
+	 * Finds the DocuDirent with the name <code>fn</code>.
+	 * 
+	 * Searches the directory for the DocuDirent with the name <code>fn</code>
+	 * and returns it. Returns null if the file cannot be found.
+	 * 
+	 * @param fn
+	 *            filename
+	 * @return DocuDirent
+	 */
+	public DocuDirent find(String fn) {
+		int fc = FileOps.classForFilename(fn);
+		int i = indexOf(fn, fc);
+		if (i >= 0) {
+			return (DocuDirent) list.get(0).get(i);
+		}
+		return null;
+	}
+
+	/**
+	 * Finds the DocuDirent with the name <code>fn</code> and class
+	 * <code>fc</code>.
+	 * 
+	 * Searches the directory for the DocuDirent with the name <code>fn</code>
+	 * and returns it. Returns null if the file cannot be found.
+	 * 
+	 * @param fn
+	 *            filename
+	 * @return DocuDirent
+	 */
+	public DocuDirent find(String fn, int fc) {
+		int i = indexOf(fn, fc);
+		if (i >= 0) {
+			return (DocuDirent) list.get(fc).get(i);
+		}
+		return null;
+	}
+
+	/**
+	 * Returns the digilib canonical name.
+	 * 
+	 * @return
+	 */
+	public String getDirName() {
+		return dirName;
+	}
+
+	/**
+	 * The directory is valid (exists on disk).
+	 * 
+	 * @return boolean
+	 */
+	public boolean isValid() {
+		return isValid;
+	}
+
+	/**
+	 * The directory has been read from disk.
+	 * 
+	 * @return
+	 */
+	public boolean isRead() {
+		return (dirMTime != 0);
+	}
+
+	/**
+	 * @return long
+	 */
+	public long getAccessTime() {
+		return objectATime;
+	}
+
+	/**
+	 * @return Hashtable
+	 */
+	public MetadataMap getDirMeta() {
+		return dirMeta;
+	}
+
+	/**
+	 * Checks metadata
+	 *  
+	 */
+	public void checkMeta() {
+		if (metaChecked) {
+			return;
+		} else {
+			readMeta();
+		}
+	}
+
+	/**
+	 * @return long
+	 */
+	public long getDirMTime() {
+		return dirMTime;
+	}
+
+	/**
+	 * Sets the dirMeta.
+	 * 
+	 * @param dirMeta
+	 *            The dirMeta to set
+	 */
+	public void setDirMeta(MetadataMap dirMeta) {
+		this.dirMeta = dirMeta;
+	}
+
+	public boolean hasUnresolvedFileMeta() {
+		return (this.unresolvedFileMeta != null);
+	}
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/servlet/src/digilib/io/DocuDirent.java	Fri Feb 05 20:58:38 2010 +0100
@@ -0,0 +1,167 @@
+/*
+ * DocuDirent.java -- Abstract directory entry in a DocuDirectory
+ * 
+ * Digital Image Library servlet components
+ * 
+ * Copyright (C) 2003 Robert Casties (robcast@mail.berlios.de)
+ * 
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ * 
+ * Please read license.txt for the full details. A copy of the GPL may be found
+ * at http://www.gnu.org/copyleft/lgpl.html
+ * 
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+ * Place, Suite 330, Boston, MA 02111-1307 USA
+ * 
+ * Created on 15.09.2003 by casties
+ *  
+ */
+package digilib.io;
+
+import java.io.File;
+import java.util.Map;
+
+import org.apache.log4j.Logger;
+
+/**
+ * Abstract directory entry in a DocuDirectory.
+ * 
+ * @author casties
+ *  
+ */
+public abstract class DocuDirent implements Comparable<Object> {
+
+	/** the file class of this file */
+	protected static int fileClass = FileOps.CLASS_NONE;
+	/** HashMap with metadata */
+	protected MetadataMap fileMeta = null;
+	/** Is the Metadata valid */
+	protected boolean metaChecked = false;
+	/** the parent directory */
+	protected Directory parent = null;
+
+	/**
+	 * Checks metadata and does something with it.
+	 *  
+	 */
+	public abstract void checkMeta();
+
+	/**
+	 * gets the (default) File
+	 * 
+	 * @return
+	 */
+	public abstract File getFile();
+
+	/**
+	 * Reads meta-data for this Fileset if there is any.
+	 *  
+	 */
+	public void readMeta() {
+		if ((fileMeta != null) || (getFile() == null)) {
+			// there is already metadata or there is no file
+			return;
+		}
+		// metadata is in the file {filename}.meta
+		String fn = getFile().getAbsolutePath();
+		File mf = new File(fn + ".meta");
+		if (mf.canRead()) {
+			XMLMetaLoader ml = new XMLMetaLoader();
+			try {
+				// read meta file
+				Map<String, MetadataMap> meta = ml.loadURL(mf.getAbsolutePath());
+				if (meta == null) {
+					return;
+				}
+				fileMeta = meta.get(getName());
+			} catch (Exception e) {
+				Logger.getLogger(this.getClass()).warn("error reading file .meta", e);
+			}
+		}
+	}
+
+	/**
+	 * The name of the file.
+	 * 
+	 * If this is a Fileset, the method returns the name of the default file
+	 * (for image filesets the highest resolution file).
+	 * 
+	 * @return
+	 */
+	public String getName() {
+		File f = getFile();
+		return (f != null) ? f.getName() : null;
+	} 
+	
+	/**
+	 * Returns the parent Directory.
+	 * 
+	 * @return DocuDirectory
+	 */
+	public Directory getParent() {
+		return parent;
+	}
+	
+	/**
+	 * Sets the parent Directory.
+	 * 
+	 * @param parent
+	 *            The parent to set
+	 */
+	public void setParent(Directory parent) {
+		this.parent = parent;
+	} 
+	
+	/**
+	 * Returns the meta-data for this file(set).
+	 * 
+	 * @return HashMap
+	 */
+	public MetadataMap getFileMeta() {
+		return fileMeta;
+	} 
+	
+	/**
+	 * Sets the meta-data for this file(set) .
+	 * 
+	 * @param fileMeta
+	 *            The fileMeta to set
+	 */
+	public void setFileMeta(MetadataMap fileMeta) {
+		this.fileMeta = fileMeta;
+	} 
+	
+	/**
+	 * @return
+	 */
+	public boolean isMetaChecked() {
+		return metaChecked;
+	} 
+	
+	/**
+	 * @return
+	 */
+	public static int getFileClass() {
+		return fileClass;
+	}
+
+	/** Comparator using the file name.
+	 * Compares to a String (for binarySearch)
+     * or to another DocuDirent (for sort)
+	 * 
+	 * @see java.lang.Comparable#compareTo(java.lang.Object)
+	 */
+	public int compareTo(Object arg0) {
+		if (arg0 instanceof DocuDirent) {
+		    return getName().compareTo(((DocuDirent) arg0).getName());
+		} else {
+		    return getName().compareTo((String) arg0);
+		}
+	}
+
+	
+}