Subversion Repositories general

package ak.photoalbum.images;

import java.util.Map;
import java.util.HashMap;
import java.util.Comparator;
import java.util.Arrays;
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.awt.image.ImageObserver;
import java.awt.image.PixelGrabber;
import javax.imageio.ImageIO;
import org.apache.log4j.Logger;
import marcoschmidt.image.ImageInfo;
import ak.photoalbum.util.FileUtils;
import ak.photoalbum.util.FileNameComparator;

public class Thumbnailer
{
  protected static final String DEFAULT_FORMAT        = "jpg";
  protected static final String SMALL_SUFFIX          = ".small";
  protected static final String MEDIUM_SUFFIX         = ".medium";
  protected static final String DIR_SUFFIX            = ".dir";
  protected static final String DIR_PART_SUFFIX       = ".dir_part";
  protected static final int    DEFAULT_SMALL_WIDTH   = 120;
  protected static final int    DEFAULT_SMALL_HEIGHT  = 120;
  protected static final int    DEFAULT_MEDIUM_WIDTH  = 800;
  protected static final int    DEFAULT_MEDIUM_HEIGHT = 800;

  protected Logger       logger;
  protected ImageResizer resizer;
  protected int          smallWidth            = DEFAULT_SMALL_WIDTH;
  protected int          smallHeight           = DEFAULT_SMALL_HEIGHT;
  protected int          mediumWidth           = DEFAULT_MEDIUM_WIDTH;
  protected int          mediumHeight          = DEFAULT_MEDIUM_HEIGHT;
  protected File         cacheDir;
  protected String       format                = DEFAULT_FORMAT;
  protected Map          smallCache            = new HashMap();
  protected Map          mediumCache           = new HashMap();
  protected Map          dirCache              = new HashMap();
  protected File         imagesRoot;
  protected FileFilter   imagesFilter          = null;
  protected Comparator   fileNameComparator    = new FileNameComparator(true);
  protected Comparator   fileNameComparatorRev = new FileNameComparator(false);
  protected boolean      nativeMode            = true; // FIXME config

  protected File                dirTemplate;
  protected ThumbnailPosition[] dirThumbnailPositions;
  protected int[]               dirTemplateSize;
  protected long                dirTemplateTimestamp;

  public Thumbnailer()
  {
    this.logger = Logger.getLogger(this.getClass());
  }

  public String getMime()
  {
    return FileUtils.getMime(format);
  }

  public int[] getDirSize(File origin)
    throws IOException
  {
    if(dirTemplateSize == null
      || dirTemplateTimestamp != dirTemplate.lastModified())
    {
      dirTemplateSize      = getOriginSize(dirTemplate);
      dirTemplateTimestamp = dirTemplate.lastModified();
    }

    return dirTemplateSize;
  }

  public int[] getSmallSize(File origin)
    throws IOException
  {
    CachedFile cached = getCached(smallCache, origin);

    if(cached == null) {
      int[] originSize = getOriginSize(origin);

      return calcSizes(originSize[0], originSize[1], smallWidth, smallHeight);
    }
    else {
      int[] originSize = new int[2];

      originSize[0] = cached.getWidth();
      originSize[1] = cached.getHeight();

      return originSize;
    }
  }

  public int[] getMediumSize(File origin)
    throws IOException
  {
    CachedFile cached = getCached(mediumCache, origin);

    if(cached == null) {
      int[] originSize = getOriginSize(origin);

      return calcSizes(originSize[0], originSize[1], mediumWidth, mediumHeight);
    }
    else {
      int[] originSize = new int[2];

      originSize[0] = cached.getWidth();
      originSize[1] = cached.getHeight();

      return originSize;
    }
  }

  protected int[] getOriginSize(File origin)
    throws IOException
  {
    if(logger.isDebugEnabled())
      logger.debug("get size of " + origin.getCanonicalPath());

    ImageInfo       ii  = new ImageInfo();
    FileInputStream in  = null;
    int[]           res = new int[2];

    try {
      in = new FileInputStream(origin);
      ii.setInput(in);

      if(!ii.check()) {
        logger.warn("not supported format of " + origin.getCanonicalPath());
        res[0] = 0;
        res[1] = 0;
      }
      else{
        res[0] = ii.getWidth();
        res[1] = ii.getHeight();
      }
    }
    finally {
      if(in != null) in.close();
    }

    return res;
  }

  public void rebuildCache()
    throws IOException
  {
    logger.info("rebuild cache");

    deleteCache();
    buildCache();
  }

  public void deleteCache()
    throws IOException
  {
    logger.info("delete cache");

    deleteCache(cacheDir);
  }

  public void buildCache()
    throws IOException
  {
    logger.info("build cache");

    buildCache(imagesRoot);
  }

  public void reloadCache()
    throws IOException
  {
    logger.info("reload cache");

    smallCache.clear();
    mediumCache.clear();
    dirCache.clear();
    loadCaches(cacheDir);
  }

  protected void deleteCache(File dir)
    throws IOException
  {
    File[] children = dir.listFiles();

    if(children == null) return; // the dir does not exists

    Arrays.sort(children, fileNameComparator);

    for(int i = 0; i < children.length; i++) {
      if(children[i].isDirectory())
        deleteCache(children[i]);
      else
        children[i].delete();
    }
    dir.delete();
  }

  protected void buildCache(File dir)
    throws IOException
  {
    File[] children;

    if(imagesFilter == null)
      children = dir.listFiles();
    else
      children = dir.listFiles(imagesFilter);

    if(children == null) return; // the dir does not exists

    Arrays.sort(children, fileNameComparator);

    for(int i = 0; i < children.length; i++) {
      if(children[i].isDirectory()) {
        writeDir(children[i], null);
        buildCache(children[i]);
      }
      else {
        writeSmall(children[i], null);
        writeMedium(children[i], null);
      }
    }
  }

  protected CachedFile getCached(Map cache, File imageFile)
    throws IOException
  {
    CachedFile cached = (CachedFile)cache.get(imageFile.getCanonicalPath());

    if(cached == null || !cached.getFile().exists()) {
      logger.debug("not found in cache");
      return null;
    }

    if(cached.getOriginTimestamp() != imageFile.lastModified()) {
      cached.getFile().delete();
      cache.remove(imageFile.getCanonicalPath());
      logger.debug("timestamps dont match");
      return null;
    }

    return cached;
  }

  protected boolean writeCached(Map cache, File imageFile, OutputStream out)
    throws IOException
  {
    CachedFile cached = getCached(cache, imageFile);

    if(cached == null) return false;

    if(logger.isDebugEnabled())
      logger.debug("write cached " + imageFile.getCanonicalPath());

    if(out != null) {
      FileInputStream in = null;

      try {
        in  = new FileInputStream(cached.getFile());
        FileUtils.copyStreams(in, out);
      }
      finally {
        if(in != null) in.close();
      }
    }

    return true;
  }

  protected File getCacheFile(File dir, File imageFile, String suffix)
  {
    return new File(dir, imageFile.getName() + suffix + "." + format);
  }

  protected void cacheThumbnail(Map cache, File imageFile,
      BufferedImage thumbnail, String suffix, int width, int height)
    throws IOException
  {
    logger.debug("cache thumbnail " + suffix + " "
      + imageFile.getCanonicalPath());

    File dir       = getCacheFileDir(imageFile);
    File cacheFile = getCacheFile(dir, imageFile, suffix);

    dir.mkdirs();
    ImageIO.write(thumbnail, format, cacheFile);

    cache.put(imageFile.getCanonicalPath(),
      new CachedFile(cacheFile, imageFile,
      cacheFile.lastModified(), imageFile.lastModified(), width, height));
  }

  public void startup()
    throws IOException
  {
    logger.info("startup");
    loadCaches(cacheDir);
    logger.info("started");
  }

        protected void loadFileCache(File file)
    throws IOException
        {
                /* FIXME use this optimization?
    String dirEnd    = DIR_SUFFIX    + "." + format;
    String smallEnd  = SMALL_SUFFIX  + "." + format;
    String mediumEnd = MEDIUM_SUFFIX + "." + format;
    */

    File origin = null;
    Map  cache  = null;

    if(file.getName().endsWith(SMALL_SUFFIX + "." + format)) {
      origin = getOriginFile(file, SMALL_SUFFIX);
      cache  = smallCache;

      if(logger.isDebugEnabled())
        logger.debug("load cached small " + file.getCanonicalPath()
          + " for " + origin.getCanonicalPath());
    }
    else if(file.getName().endsWith(MEDIUM_SUFFIX + "." + format)) {
      origin = getOriginFile(file, MEDIUM_SUFFIX);
      cache  = mediumCache;

      if(logger.isDebugEnabled())
        logger.debug("load cached medium " + file.getCanonicalPath()
          + " for " + origin.getCanonicalPath());
    }
    else if(file.getName().endsWith(DIR_SUFFIX + "." + format)) {
      origin = getOriginFile(file, DIR_SUFFIX);
      cache  = dirCache;

      if(logger.isDebugEnabled())
        logger.debug("load cached dir " + file.getCanonicalPath()
          + " for " + origin.getCanonicalPath());
    }
    else if(file.getName().endsWith(DIR_PART_SUFFIX + "." + format)) {
      if(logger.isDebugEnabled())
        logger.debug("skip cached dir part " + file.getCanonicalPath());
    }
    else {
      if(logger.isInfoEnabled())
        logger.warn(
          "unknown type of cached " + file.getCanonicalPath());
    }

    if(origin != null && cache != null) {
      loadCacheInfo(file, origin, cache);
    }
    else {
      file.delete();

      if(logger.isDebugEnabled())
        logger.debug("deleted (unknown origin)");
    }
        }

        protected void loadCacheInfo(File file, File origin, Map cache)
    throws IOException
        {
    long  originTimestamp = origin.lastModified();
    long  cachedTimestamp = file.lastModified();
    int[] sizes           = getOriginSize(file);

    if(origin.exists() && cachedTimestamp >= originTimestamp) {
      cache.put(origin.getCanonicalPath(),
        new CachedFile(file, origin, cachedTimestamp,
          originTimestamp, sizes[0], sizes[1]));

      logger.debug("added");
    }
    else {
      file.delete();

      if(logger.isDebugEnabled())
        logger.debug("deleted: " + origin.exists()
          + " " + cachedTimestamp + " " + originTimestamp);
    }
        }

  protected void loadCaches(File dir)
    throws IOException
  {
    if(logger.isDebugEnabled())
      logger.debug("load caches in " + dir.getCanonicalPath());

    File[] children = dir.listFiles();

    if(children == null) return; // the dir does not exists

    for(int i = 0; i < children.length; i++) {
      if(children[i].isDirectory())
        loadCaches(children[i]);
      else
        loadFileCache(children[i]);
    }
  }

  protected File getOriginFile(File cached, String suffix)
    throws IOException
  {
    String fileEnd    = suffix + "." + format;
    String fileName   = cached.getName();
    String cachedPath = cached.getParentFile().getCanonicalPath();
    String cacheRoot  = cacheDir.getCanonicalPath();

    fileName = fileName.substring(0, fileName.length() - fileEnd.length());

    if(!cacheRoot.equals(cachedPath))
      if(!cacheRoot.endsWith(File.separator)) cacheRoot += File.separator;

    return new File(imagesRoot, cachedPath.substring(cacheRoot.length())
      + File.separator + fileName);
  }

  protected File getCacheFileDir(File imageFile)
    throws IOException
  {
    String imagePath = imageFile.getParentFile().getCanonicalPath();
    String rootPath  = imagesRoot.getCanonicalPath();

    if(imagePath.equals(rootPath)) return cacheDir;
    if(!rootPath.endsWith(File.separator)) rootPath += File.separator;

    if(!imagePath.startsWith(rootPath))
      throw new RuntimeException("Image " + imageFile.getCanonicalPath()
        + " is not under images root " + imagesRoot.getCanonicalPath());

    return new File(cacheDir, imagePath.substring(rootPath.length()));
  }

  public void writeSmall(File imageFile, OutputStream out)
    throws IOException
  {
    if(logger.isInfoEnabled())
      logger.info("write small " + imageFile.getCanonicalPath());

    if(writeCached(smallCache, imageFile, out)) return;

                if(nativeMode) {
                        File dir       = getCacheFileDir(imageFile);
                        File cacheFile = getCacheFile(dir, imageFile, SMALL_SUFFIX);

        createThumbnailNative(dir, cacheFile, imageFile, smallWidth, smallHeight);
                        loadCacheInfo(cacheFile, imageFile, smallCache);
      writeCached(smallCache, imageFile, out);
                }
                else {
        BufferedImage small = createThumbnail(imageFile, smallWidth, smallHeight);

            if(small != null) {
                // a thumbnail returned - save it into the cache dir
              int sizes[] = calcSizes(
                small.getWidth(null), small.getHeight(null), smallWidth, smallHeight);
              cacheThumbnail(
                smallCache, imageFile, small, SMALL_SUFFIX, sizes[0], sizes[1]);

              if(out != null) ImageIO.write(small, format, out);
            }
                }
  }

  public void writeMedium(File imageFile, OutputStream out)
    throws IOException
  {
    if(logger.isInfoEnabled())
      logger.info("write medium " + imageFile.getCanonicalPath());

    if(writeCached(mediumCache, imageFile, out)) return;

                if(nativeMode) {
                        File dir       = getCacheFileDir(imageFile);
                        File cacheFile = getCacheFile(dir, imageFile, MEDIUM_SUFFIX);

        createThumbnailNative(dir, cacheFile, imageFile, mediumWidth, mediumHeight);
                        loadCacheInfo(cacheFile, imageFile, mediumCache);
      writeCached(mediumCache, imageFile, out);
                }
                else {
        BufferedImage medium = createThumbnail(imageFile, mediumWidth, mediumHeight);

            if(medium != null) {
                // a image returned - save it into the cache dir
              int sizes[] = calcSizes(medium.getWidth(null), medium.getHeight(null),
                mediumWidth, mediumHeight);
              cacheThumbnail(
                mediumCache, imageFile, medium, MEDIUM_SUFFIX, sizes[0], sizes[1]);

              if(out != null) ImageIO.write(medium, format, out);
            }
          }
  }

  public void writeDir(File dir, OutputStream out)
    throws IOException
  {
    if(logger.isInfoEnabled())
      logger.info("write dir " + dir.getCanonicalPath());

    if(writeCached(dirCache, dir, out)) return;

    BufferedImage thumbnail = createDirThumbnail(dir);

    if(thumbnail != null) {
      if(dirTemplateSize == null
        || dirTemplateTimestamp != dirTemplate.lastModified())
      {
        dirTemplateSize      = getOriginSize(dirTemplate);
        dirTemplateTimestamp = dirTemplate.lastModified();
      }

      cacheThumbnail(dirCache, dir, thumbnail, DIR_SUFFIX,
        dirTemplateSize[0], dirTemplateSize[1]);

      if(out != null) ImageIO.write(thumbnail, format, out);
    }
  }

  synchronized protected BufferedImage createThumbnail(File imageFile,
      int width, int height)
    throws IOException
  {
    if(logger.isDebugEnabled())
      logger.debug("create thumbnail " + imageFile.getCanonicalPath());

    Image image = loadImage(imageFile.getCanonicalPath());
      // = ImageIO.read(imageFile);
    int[] sizes;

    if(image == null) {   // not supported format
      logger.warn("unsupported format for origin or operation interrupted");

      return null;
    }
    else {
      sizes = calcSizes(image.getWidth(null), image.getHeight(null),
        width, height);
      logger.debug("resize to " + sizes[0] + "x" + sizes[1]);

      return resizer.resize(image, sizes[0], sizes[1]);
    }
  }

  synchronized protected BufferedImage createThumbnailNative(File dir, File cacheFile,
                File imageFile, int width, int height)
    throws IOException
  {
    if(logger.isDebugEnabled())
      logger.debug("create thumbnail2 " + imageFile.getCanonicalPath() + " to "
        +       cacheFile.getCanonicalPath());

    dir.mkdirs();

                // FIMXE: 1) make util path (and params?) configurable
                Process process = Runtime.getRuntime().exec(new String[] {
                        "/usr/local/bin/convert",
                        "-size",      width + "x" + height,
                        "-thumbnail", width + "x" + height,
      imageFile.getCanonicalPath(),
        cacheFile.getCanonicalPath()
                });

    // FIXME make it finner
    BufferedReader in = new BufferedReader(new InputStreamReader(process.getErrorStream()));
    String line;
    while((line = in.readLine()) != null) {
        System.out.println("EXEC: " + line);
    }

                try {
            int res = process.waitFor();

            if(logger.isDebugEnabled())
              logger.debug("process exited with result " + res);
                }
                catch(InterruptedException ex) {
      logger.debug("process interrupted");
                }

    return null;
  }

  synchronized protected BufferedImage createDirThumbnail(File dir)
    throws IOException
  {
        long timeStart = System.currentTimeMillis();

    if(logger.isDebugEnabled())
      logger.debug("create dir thumbnail " + dir.getCanonicalPath());

    Image         template = loadImage(dirTemplate.getCanonicalPath());
    BufferedImage dirThumbnail;
    Graphics      graphics;
    int           count;
    File[]        firstFiles;

    if(template == null) {   // not supported format
      logger.warn("unsupported format for template or operation interrupted");

      return null;
    }

    dirThumbnail = createBufferedImage(template);

    graphics     = dirThumbnail.getGraphics();
    count        = dirThumbnailPositions.length;
    firstFiles   = new File[count];
    count        = getFirstFiles(dir, count, firstFiles, 0);

    for(int i = 0; i < count; i++) {
      Image         image;
      BufferedImage thumbnail = null;
      int[]         sizes;

                        if(nativeMode) {
                                File cacheFileDir = getCacheFileDir(firstFiles[i]);
                                File cacheFile    = getCacheFile(cacheFileDir, firstFiles[i], DIR_PART_SUFFIX);
                createThumbnailNative(cacheFileDir, cacheFile, firstFiles[i],
                        dirThumbnailPositions[i].getWidth(), dirThumbnailPositions[i].getHeight());
              image     = loadImage(cacheFile.getCanonicalPath());
              thumbnail = createBufferedImage(image);
                        }
                        else {
              image = loadImage(firstFiles[i].getCanonicalPath());
      }

      if(image == null) {   // not supported format
        logger.warn("unsupported format for origin or operation interrupted");

        return null;
      }
      else {
        sizes = calcSizes(image.getWidth(null), image.getHeight(null),
          dirThumbnailPositions[i].getWidth(),
          dirThumbnailPositions[i].getHeight());
      }

                        if(!nativeMode) {
        thumbnail = resizer.resize(image, sizes[0], sizes[1]);
      }

      graphics.drawImage(thumbnail,
        getXPosition(dirThumbnailPositions[i].getX(),
          dirThumbnailPositions[i].getWidth(), sizes[0],
          dirThumbnailPositions[i].getHorAlign()),
        getYPosition(dirThumbnailPositions[i].getY(),
          dirThumbnailPositions[i].getHeight(), sizes[1],
          dirThumbnailPositions[i].getVertAlign()),
        null);
    }

    if(logger.isDebugEnabled()) {
      logger.debug("dir thumbnail created in "
        + (System.currentTimeMillis() - timeStart) + " ms");
    }

    return dirThumbnail;
  }

  protected Image loadImage(String fileName)
  {
        long timeStart = System.currentTimeMillis();

    // FIXME: probably toolbox reads an image not by every request but
    //        caches it
    Toolkit toolkit = Toolkit.getDefaultToolkit();
    Image   image   = toolkit.getImage(fileName);

    toolkit.prepareImage(image, -1, -1, null);

    while(true) {
      int status = toolkit.checkImage(image, -1, -1, null);

      if((status & ImageObserver.ALLBITS) != 0) break;
      if((status & ImageObserver.ERROR)   != 0) return null;

      try {
        Thread.sleep(100);
      }
      catch(Exception ex) {
        return null;
      }
    }

    if(logger.isDebugEnabled()) {
      logger.debug("image " + fileName + " loaded in "
        + (System.currentTimeMillis() - timeStart) + " ms");
    }

    return image;
  }

  protected int[] calcSizes(int width, int height, int maxWidth, int maxHeight)
  {
    int[]  result = new int[2];
    double xRate;
    double yRate;

    if(width == 0 || height == 0) {
      result[0] = 0;
      result[1] = 0;
      return result;
    }

    xRate  = (double)maxWidth  / (double)width;
    yRate  = (double)maxHeight / (double)height;
    if(xRate >= 1.0 || yRate >= 1.0) {
      result[0] = width;
      result[1] = height;
    }
    else if(xRate > yRate) {
      result[0] = maxHeight * width / height;
      result[1] = maxHeight;
    }
    else {
      result[0] = maxWidth;
      result[1] = maxWidth * height / width;
    }

    return result;
  }

  protected int getXPosition(int left, int maxWidth, int width, int align)
  {
    if(align == ThumbnailPosition.ALIGN_HOR_LEFT)
      return left;
    else if(align == ThumbnailPosition.ALIGN_HOR_RIGHT)
      return left + (maxWidth - width);
    else if(align == ThumbnailPosition.ALIGN_HOR_CENTER)
      return left + (maxWidth - width) / 2;
    else
      throw new RuntimeException("Unknown align type: " + align);
  }

  protected int getYPosition(int top, int maxHeight, int height, int align)
  {
    if(align == ThumbnailPosition.ALIGN_VERT_TOP)
      return top;
    else if(align == ThumbnailPosition.ALIGN_VERT_BOTTOM)
      return top + (maxHeight - height);
    else if(align == ThumbnailPosition.ALIGN_VERT_CENTER)
      return top + (maxHeight - height) / 2;
    else
      throw new RuntimeException("Unknown align type: " + align);
  }

  protected int getFirstFiles(File dir, int count, File[] files, int pos)
  {
    File[] children;

    if(imagesFilter == null)
      children = dir.listFiles();
    else
      children = dir.listFiles(imagesFilter);

    if(children == null) return 0; // the dir does not exists

    Arrays.sort(children, fileNameComparatorRev);

    for(int i = 0; i < children.length && pos < count; i++) {
      if(children[i].isDirectory())
        ; //pos = getFirstFiles(children[i], count, files, pos);
      else {
        files[pos++] = children[i];
      }
    }

    return pos;
  }

  protected BufferedImage createBufferedImage(Image image)
  {
    if(image == null) return null;

    int width  = image.getWidth(null);
    int height = image.getHeight(null);

    if(width < 1 || height < 1) return null;

    // get pixels
    int[]        pixels = new int[width * height];
    PixelGrabber pg     = new PixelGrabber(image,
      0, 0, width, height, pixels, 0, width);

    try  {
      pg.grabPixels();
    }
    catch(InterruptedException e) {
      return null;
    }

    if((pg.getStatus() & ImageObserver.ABORT) != 0) return null;

    // create buffered image
    BufferedImage buffered = new BufferedImage(width, height,
      BufferedImage.TYPE_INT_RGB);

    for(int y = 0; y < height; y++) {
      for(int x = 0; x < width; x++)
        buffered.setRGB(x, y, pixels[y * width + x]);
    }

    return buffered;
  }

  public ImageResizer getResizer()
  {
    return resizer;
  }

  public void setResizer(ImageResizer resizer)
  {
    this.resizer = resizer;
  }

  public String getFormat()
  {
    return format;
  }

  public void setFormat(String format)
  {
    this.format = format;
  }

  public File getCacheDir()
  {
    return cacheDir;
  }

  public void setCacheDir(File dir)
  {
    this.cacheDir = dir;
  }

  public File getImagesRoot()
  {
    return imagesRoot;
  }

  public void setImagesRoot(File dir)
  {
    this.imagesRoot = dir;
  }

  public int getSmallWidth()
  {
    return smallWidth;
  }

  public void setSmallWidth(int width)
  {
    this.smallWidth = width;
  }

  public int getSmallHeight()
  {
    return smallHeight;
  }

  public void setSmallHeight(int height)
  {
    this.smallHeight = height;
  }

  public int getMediumWidth()
  {
    return mediumWidth;
  }

  public void setMediumWidth(int width)
  {
    this.mediumWidth = width;
  }

  public int getMediumHeight()
  {
    return mediumHeight;
  }

  public void setMediumHeight(int height)
  {
    this.mediumHeight = height;
  }

  public FileFilter getImagesFilter()
  {
    return imagesFilter;
  }

  public void setImagesFilter(FileFilter filter)
  {
    this.imagesFilter = filter;
  }

  public File getDirTemplate()
  {
    return dirTemplate;
  }

  public void setDirTemplate(File dirTemplate)
  {
    this.dirTemplate = dirTemplate;
  }

  public ThumbnailPosition[] getDirThumbnailPositions()
  {
    return dirThumbnailPositions;
  }

  public void setDirThumbnailPositions(
    ThumbnailPosition[] dirThumbnailPositions)
  {
    this.dirThumbnailPositions = dirThumbnailPositions;
  }
}