//
   // $Id$
   //
   // jupload - A file upload applet.
   //
   // Copyright 2008 The JUpload Team
   //
   // Created: 12 fevr. 08
   // Creator: etienne_sf
  // Last modified: $Date$
  //
  // 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.
  //
  // This program is distributed in the hope that it will be useful,
  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  // GNU General Public License for more details.
  //
  // 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., 675 Mass Ave, Cambridge, MA 02139, USA.
  
  package wjhk.jupload2.filedata.helper;
  
  import java.awt.Image;
  import java.awt.geom.AffineTransform;
  import java.awt.image.AffineTransformOp;
  import java.awt.image.BufferedImage;
  import java.awt.image.ImageObserver;
  
  import wjhk.jupload2.exception.JUploadException;
  import wjhk.jupload2.exception.JUploadIOException;
  import wjhk.jupload2.filedata.DefaultFileData;
  import wjhk.jupload2.filedata.PictureFileData;
  import wjhk.jupload2.policies.PictureUploadPolicy;
  
  /**
   * Class that contains various utilities about picture, mainly about picture transformation.
   * 
   * @author etienne_sf
   */
  public class ImageHelper implements ImageObserver {
  
      /**
       * hasToTransformPicture indicates whether the picture should be transformed. Null if unknown. This can happen (for
       * instance) if no calcul where done (during initialization), or after rotating the picture back to the original
       * orientation. <BR>
       * <B>Note:</B> this attribute is from the class Boolean (and not a simple boolean), to allow null value, meaning
       * <I>unknown</I>.
       */
      private Boolean hasToTransformPicture = null;
  
      /**
       * The {@link PictureFileData} that this helper will have to help.
       */
      private PictureFileData pictureFileData;
  
      /**
       * Current rotation of the picture: 0 to 3.
       * 
       * @see PictureFileData
       */
      private int quarterRotation;
  
      /**
       * Maximum width for the current transformation
       */
      private int maxWidth;
  
      /**
       * Maximum height for the current transformation
       */
      private int maxHeight;
  
      /**
       * Defines the number of pixel for the current picture. Used to update the progress bar.
       * 
       * @see #getBufferedImage(boolean, BufferedImage)
       * @see #imageUpdate(Image, int, int, int, int, int)
       */
      private int nbPixelsTotal = -1;
  
      /**
       * Indicates the number of pixels that have been read.
       * 
       * @see #nbPixelsTotal
       * @see #imageUpdate(Image, int, int, int, int, int)
       */
      private int nbPixelsRead = 0;
  
      /**
       * Width of picture, after rescaling but without rotation. It should be scale*originalWidth, but, due to rounding
       * number, it can be transformed to scale*originalWidth-1.
       * 
       * @see #initScale()
       */
     private int scaledNonRotatedWidth = -1;
 
     /**
      * Same as {@link #scaledNonRotatedWidth}
      */
     private int scaledNonRotatedHeight = -1;
 
     /**
      * The value that has the progress bar when starting to load the picture. The
      * {@link #imageUpdate(Image, int, int, int, int, int)} method will add from 0 to 100, to indicate progress with a
      * percentage value of picture loading.
      */
     private int progressBarBaseValue = 0;
 
     /**
      * Current scaling factor. If less than 1, means a picture reduction.
      * 
      * @see #initScale()
      */
     private double scale = 1;
 
     /**
      * Width of picture, after re-scaling and rotation. It should be scale*originalWidth or scale*originalHeight
      * (depending on the rotation). But, due to rounding number, it can be transformed to scale*originalWidth-1 or
      * scale*originalHeight-1.
      * 
      * @see #initScale()
      */
     private int scaledRotatedWidth = -1;
 
     /**
      * Same as {@link #scaledRotatedWidth}, for the height.
      */
     private int scaledRotatedHeight = -1;
 
     /**
      * The current upload policy must be a {@link PictureUploadPolicy}
      */
     PictureUploadPolicy uploadPolicy;
 
     /**
      * Standard constructor.
      * 
      * @param uploadPolicy The current upload policy
      * @param pictureFileData The picture file data to help
      * @param targetMaxWidth
      * @param targetMaxHeight
      * @param quarterRotation Current quarter rotation (from 0 to 3)
      * @throws JUploadIOException
      */
     public ImageHelper(PictureUploadPolicy uploadPolicy, PictureFileData pictureFileData, int targetMaxWidth,
             int targetMaxHeight, int quarterRotation) throws JUploadIOException {
         this.uploadPolicy = uploadPolicy;
         this.pictureFileData = pictureFileData;
         this.maxWidth = targetMaxWidth;
         this.maxHeight = targetMaxHeight;
         this.quarterRotation = quarterRotation;
 
         // Pre-calculation: should the current picture be rescaled, to match the
         // given target size ?
         initScale();
     }
 
     /**
      * Intialization of scale factor, for the current picture state. The scale is based on the maximum width and height,
      * the current rotation, and the picture size.
      */
     private void initScale() throws JUploadIOException {
         double theta = Math.toRadians(90 * this.quarterRotation);
 
         // The width and height depend on the current rotation :
         // calculation of the width and height of picture after
         // rotation.
         int nonScaledRotatedWidth = this.pictureFileData.getOriginalWidth();
         int nonScaledRotatedHeight = this.pictureFileData.getOriginalHeight();
         if (this.quarterRotation % 2 != 0) {
             // 90 degrees or 270 degrees rotation: width and height are
             // switched.
             nonScaledRotatedWidth = this.pictureFileData.getOriginalHeight();
             nonScaledRotatedHeight = this.pictureFileData.getOriginalWidth();
         }
         // Now, we can compare these width and height to the maximum
         // width and height
         double scaleWidth = ((this.maxWidth < 0) ? 1 : ((double) this.maxWidth) / nonScaledRotatedWidth);
         double scaleHeight = ((this.maxHeight < 0) ? 1 : ((double) this.maxHeight) / nonScaledRotatedHeight);
         this.scale = Math.min(scaleWidth, scaleHeight);
         if (this.scale < 1) {
             // With number rounding, it can happen that width or size
             // became one pixel too big. Let's correct it.
             if ((this.maxWidth > 0 && this.maxWidth < (int) (this.scale * Math.cos(theta) * nonScaledRotatedWidth))
                     || (this.maxHeight > 0 && this.maxHeight < (int) (this.scale * Math.cos(theta) * nonScaledRotatedHeight))) {
                 scaleWidth = ((this.maxWidth < 0) ? 1 : ((double) this.maxWidth - 1) / (nonScaledRotatedWidth));
                 scaleHeight = ((this.maxHeight < 0) ? 1 : ((double) this.maxHeight - 1) / (nonScaledRotatedHeight));
                 this.scale = Math.min(scaleWidth, scaleHeight);
             }
         }
 
         // These variables contain the actual width and height after
         // rescaling, and before rotation.
         this.scaledRotatedWidth = nonScaledRotatedWidth;
         this.scaledRotatedHeight = nonScaledRotatedHeight;
         // Is there any rescaling to do ?
         // Patch for the first bug, tracked in the sourceforge bug
         // tracker ! ;-)
         if (this.scale < 1) {
             this.scaledRotatedWidth *= this.scale;
             this.scaledRotatedHeight *= this.scale;
             this.uploadPolicy.displayDebug("Resizing factor (scale): " + this.scale, 30);
         } else {
             this.uploadPolicy.displayDebug("Resizing factor (scale): no resizing (calculated scale was " + this.scale
                     + ")", 30);
         }
         // Due to rounded numbers, the resulting targetWidth or
         // targetHeight
         // may be one pixel too big. Let's check that.
         if (this.scaledRotatedWidth > this.maxWidth) {
             this.uploadPolicy.displayDebug("Correcting rounded width: " + this.scaledRotatedWidth + " to "
                     + this.maxWidth, 50);
             this.scaledRotatedWidth = this.maxWidth;
         }
         if (this.scaledRotatedHeight > this.maxHeight) {
             this.uploadPolicy.displayDebug("Correcting rounded height: " + this.scaledRotatedHeight + " to "
                     + this.maxHeight, 50);
             this.scaledRotatedHeight = this.maxHeight;
         }
 
         // getBufferedImage will need the two following value:
         if (this.quarterRotation % 2 == 0) {
             this.scaledNonRotatedWidth = this.scaledRotatedWidth;
             this.scaledNonRotatedHeight = this.scaledRotatedHeight;
         } else {
             this.scaledNonRotatedWidth = this.scaledRotatedHeight;
             this.scaledNonRotatedHeight = this.scaledRotatedWidth;
         }
     }
 
     /**
      * This function indicate if the picture has to be modified. For instance : a maximum width, height, a target
      * format...
      * 
      * @return true if the picture must be transformed. false if the file can be directly transmitted.
      * @throws JUploadException Contains any exception that could be thrown in this method
      */
     public boolean hasToTransformPicture() throws JUploadException {
         // Animated gif must be transmit as is, as I can't find a way to
         // recreate them.
         if (DefaultFileData.getExtension(this.pictureFileData.getFileName()).equalsIgnoreCase("gif")) {
             // If this is an animated gif, no transformation... I can't succeed
             // to create a transformed picture file for them.
             ImageReaderWriterHelper irwh = new ImageReaderWriterHelper(this.uploadPolicy, this.pictureFileData);
             int nbImages = irwh.getNumImages(true);
             irwh.dispose();
             irwh = null;
             if (nbImages > 1) {
                 // Too bad. We can not transform it.
                 this.hasToTransformPicture = Boolean.FALSE;
                 this.uploadPolicy
                         .displayWarn("No transformation for gif picture file, that contain several pictures. (see JUpload documentation for details)");
             }
         }
 
         // Did we already estimate if transformation is needed ?
         if (this.hasToTransformPicture == null) {
 
             // First : the easiest test. Should we block metadata ?
             if (this.hasToTransformPicture == null && !(this.uploadPolicy).getPictureTransmitMetadata()) {
                 this.hasToTransformPicture = Boolean.TRUE;
                 this.uploadPolicy.displayDebug(this.pictureFileData.getFileName()
                         + " : hasToTransformPicture=true (pictureTransmitMetadata is false)", 80);
             }
             // Second : another easy test. A rotation is needed ?
             if (this.hasToTransformPicture == null && this.quarterRotation != 0) {
                 this.uploadPolicy.displayDebug(this.pictureFileData.getFileName()
                         + " : hasToTransformPicture = true (quarterRotation != 0)", 10);
                 this.hasToTransformPicture = Boolean.TRUE;
             }
 
             // Third : the picture format is the same ?
             String targetFormat = this.uploadPolicy.getImageFileConversionInfo().getTargetFormatOrNull(
                     this.pictureFileData.getFileExtension());
             if (this.hasToTransformPicture == null && targetFormat != null) {
                 this.uploadPolicy.displayDebug(this.pictureFileData.getFileName()
                         + " : hasToTransformPicture = true (targetPictureFormat)", 10);
                 this.hasToTransformPicture = Boolean.TRUE;
             }
 
             // Fourth : should we resize the picture ?
             if (this.hasToTransformPicture == null && this.scale < 1) {
                 this.uploadPolicy.displayDebug(this.pictureFileData.getFileName()
                         + " : hasToTransformPicture = true (scale < 1)", 10);
                 this.hasToTransformPicture = Boolean.TRUE;
             }
 
             // If we find no reason to transform the picture, then let's let the
             // picture unmodified.
             if (this.hasToTransformPicture == null) {
                 this.uploadPolicy.displayDebug(this.pictureFileData.getFileName() + " : hasToTransformPicture = false",
                         10);
                 this.hasToTransformPicture = Boolean.FALSE;
                 this.uploadPolicy.displayDebug(this.pictureFileData.getFileName() + " : hasToTransformPicture = false",
                         10);
             }
         }
 
         return this.hasToTransformPicture.booleanValue();
     }// end of hasToTransformPicture
 
     /**
      * This function resizes the picture, if necessary, according to the maxWidth and maxHeight, given to the
      * ImageHelper constructor. <BR>
      * This function should only be called if isPicture is true. Otherwise, an exception is raised. <BR>
      * Note (Update given by David Gnedt): the highquality will condition the call of getScaledInstance, instead of a
      * basic scale Transformation. The generated picture is of better quality, but this is longer, especially on 'small'
      * CPU. Time samples, with one picture from my canon EOS20D, on a PII 500M: <BR>
      * ~3s for the full screen preview with highquality to false, and a quarter rotation. 12s to 20s with highquality to
      * true. <BR>
      * ~5s for the first (small) preview of the picture, with both highquality to false or true.
      * 
      * @param highquality (added by David Gnedt): if set to true, the BufferedImage.getScaledInstance() is called. This
      *            generates better image, but consumes more CPU.
      * @param sourceBufferedImage The image to resize or rotate or both or no tranformation...
      * @return A BufferedImage which contains the picture according to current parameters (resizing, rotation...), or
      *         null if this is not a picture.
      * @throws JUploadException Contains any exception thrown from within this method.
      */
     public BufferedImage getBufferedImage(boolean highquality, BufferedImage sourceBufferedImage)
             throws JUploadException {
         long msGetBufferedImage = System.currentTimeMillis();
         double theta = Math.toRadians(90 * this.quarterRotation);
 
         BufferedImage returnedBufferedImage = null;
 
         this.uploadPolicy.displayDebug("getBufferedImage: start", 10);
 
         try {
             AffineTransform transform = new AffineTransform();
 
             if (this.quarterRotation != 0) {
                 double translationX = 0, translationY = 0;
                 this.uploadPolicy.displayDebug("getBufferedImage: quarter: " + this.quarterRotation, 50);
 
                 // quarterRotation is one of 0, 1, 2, 3 : see addRotation.
                 // If we're here : it's not 0, so it's one of 1, 2 or 3.
                 switch (this.quarterRotation) {
                     case 1:
                         translationX = 0;
                         translationY = -this.scaledRotatedWidth;
                         break;
                     case 2:
                         translationX = -this.scaledRotatedWidth;
                         translationY = -this.scaledRotatedHeight;
                         break;
                     case 3:
                         translationX = -this.scaledRotatedHeight;
                         translationY = 0;
                         break;
                     default:
                         this.uploadPolicy.displayWarn("Invalid quarterRotation : " + this.quarterRotation);
                         this.quarterRotation = 0;
                         theta = 0;
                 }
                 transform.rotate(theta);
                 transform.translate(translationX, translationY);
             }
 
             // If we have to rescale the picture, we first do it:
             if (this.scale < 1) {
                 if (highquality) {
                     this.uploadPolicy
                             .displayDebug("getBufferedImage: Resizing picture(using high quality picture)", 30);
 
                     // SCALE_AREA_AVERAGING forces the picture calculation
                     // algorithm.
                     // Other parameters give bad picture quality.
                     Image img = sourceBufferedImage.getScaledInstance(this.scaledNonRotatedWidth,
                             this.scaledNonRotatedHeight, Image.SCALE_AREA_AVERAGING);
 
                     // the localBufferedImage may be 'unknown'.
                     int localImageType = sourceBufferedImage.getType();
                     if (localImageType == BufferedImage.TYPE_CUSTOM) {
                         localImageType = BufferedImage.TYPE_INT_BGR;
                     }
 
                     BufferedImage tempBufferedImage = new BufferedImage(this.scaledNonRotatedWidth,
                             this.scaledNonRotatedHeight, localImageType);
 
                     // drawImage can be long. Let's follow its progress,
                     // with the applet progress bar.
                     this.nbPixelsTotal = this.scaledNonRotatedWidth * this.scaledNonRotatedHeight;
                     this.nbPixelsRead = 0;
 
                     // Let's draw the picture: this code do the rescaling.
                     this.uploadPolicy.displayDebug("getBufferedImage: Before drawImage", 50);
                     tempBufferedImage.getGraphics().drawImage(img, 0, 0, this);
                     this.uploadPolicy.displayDebug("getBufferedImage: After drawImage", 50);
 
                     tempBufferedImage.flush();
 
                     img.flush();
                     img = null;
                     PictureFileData.freeMemory("ImageHelper.getBufferedImage()", this.uploadPolicy);
 
                     // tempBufferedImage contains the rescaled picture. It's
                     // the source image for the next step (rotation).
                     sourceBufferedImage = tempBufferedImage;
                     tempBufferedImage = null;
                 } else {
                     // 'low' quality
                     //
                     // The scale method adds scaling before current
                     // transformation.
                     this.uploadPolicy.displayDebug(
                             "getBufferedImage: Resizing picture(using standard quality picture)", 50);
                     transform.scale(this.scale, this.scale);
                 }
             }
 
             if (transform.isIdentity()) {
                 returnedBufferedImage = sourceBufferedImage;
             } else {
                 AffineTransformOp affineTransformOp = null;
                 // Pictures are Ok.
                 affineTransformOp = new AffineTransformOp(transform, AffineTransformOp.TYPE_NEAREST_NEIGHBOR);
                 returnedBufferedImage = affineTransformOp.createCompatibleDestImage(sourceBufferedImage, null);
                 // Checks, after the fact the pictures produces by the Canon
                 // EOS 30D are not properly resized: colors are 'strange'
                 // after resizing.
                 this.uploadPolicy.displayDebug("getBufferedImage: returnedBufferedImage.getColorModel(): "
                         + sourceBufferedImage.getColorModel().toString(), 50);
                 this.uploadPolicy.displayDebug("getBufferedImage: returnedBufferedImage.getColorModel(): "
                         + sourceBufferedImage.getColorModel().toString(), 50);
                 affineTransformOp.filter(sourceBufferedImage, returnedBufferedImage);
                 affineTransformOp = null;
 
                 returnedBufferedImage.flush();
             }
         } catch (Exception e) {
             throw new JUploadException(e.getClass().getName() + " (" + this.getClass().getName()
                     + ".getBufferedImage()) : " + e.getMessage());
         }
 
         if (returnedBufferedImage != null && this.uploadPolicy.getDebugLevel() >= 50) {
             this.uploadPolicy.displayDebug("getBufferedImage: " + returnedBufferedImage, 50);
             this.uploadPolicy.displayDebug("getBufferedImage: MinX=" + returnedBufferedImage.getMinX(), 50);
             this.uploadPolicy.displayDebug("getBufferedImage: MinY=" + returnedBufferedImage.getMinY(), 50);
         }
 
         this.uploadPolicy.displayDebug("getBufferedImage: was " + (System.currentTimeMillis() - msGetBufferedImage)
                 + " ms long", 50);
         PictureFileData.freeMemory("ImageHelper.getBufferedImage()", this.uploadPolicy);
         return returnedBufferedImage;
     }
 
     /**
      * This method is a work in progress
      * 
      * @param highquality
      * @param sourceBufferedImage
      * @return The calculated BufferedImage, resized and rotated according to the current configuration.
      * @throws JUploadException
      */
     BufferedImage getBufferedImage2(boolean highquality, BufferedImage sourceBufferedImage) throws JUploadException {
         long msGetBufferedImage = System.currentTimeMillis();
         BufferedImage dest = null;
 
         // Scale factor calculation
         this.uploadPolicy.displayDebug("getBufferedImage: quarter: " + this.quarterRotation, 50);
 
         // quarterRotation is one of 0, 1, 2, 3 : see addRotation.
         @SuppressWarnings("unused")
         int maxWidthBeforeRotation, maxHeigthBeforeRotation, widthBeforeRotation, heigthBeforeRotation, widthAfterRotation, heigthAfterRotation;
         @SuppressWarnings("unused")
         double theta = Math.toRadians(90 * this.quarterRotation);
         switch (this.quarterRotation) {
             case 0:
             case 2:
                 maxWidthBeforeRotation = this.uploadPolicy.getMaxWidth();
                 maxHeigthBeforeRotation = this.uploadPolicy.getMaxHeight();
                 widthBeforeRotation = sourceBufferedImage.getWidth();
                 heigthBeforeRotation = sourceBufferedImage.getHeight();
                 widthAfterRotation = sourceBufferedImage.getWidth();
                 heigthAfterRotation = sourceBufferedImage.getHeight();
                 break;
             case 1:
             case 3:
                 maxWidthBeforeRotation = this.uploadPolicy.getMaxHeight();
                 maxHeigthBeforeRotation = this.uploadPolicy.getMaxWidth();
                 widthBeforeRotation = sourceBufferedImage.getHeight();
                 heigthBeforeRotation = sourceBufferedImage.getWidth();
                 widthAfterRotation = sourceBufferedImage.getHeight();
                 heigthAfterRotation = sourceBufferedImage.getWidth();
                 break;
             default:
                 throw new JUploadException("Invalid quarter rotation: <" + this.quarterRotation + ">");
         }
         double scaleWidthBeforeRotation = widthBeforeRotation / maxWidthBeforeRotation;
         double scaleHeigthBeforeRotation = heigthBeforeRotation / maxHeigthBeforeRotation;
         double scale = Math.min(scaleWidthBeforeRotation, scaleHeigthBeforeRotation);
 
         // First: we scale the picture... if necessary.
         @SuppressWarnings("unused")
         Image scaledPicture = sourceBufferedImage;
         if (scale < 1) {
             int targetWidthBeforeRotation, targetHeigthBeforeRotation;
             if (scaleWidthBeforeRotation < scaleHeigthBeforeRotation) {
                 // The constraint is on the width.
                 targetWidthBeforeRotation = maxWidthBeforeRotation;
                 targetHeigthBeforeRotation = (int) (heigthBeforeRotation * scale);
             } else {
                 // The constraint is on the heigth
                 targetHeigthBeforeRotation = maxHeigthBeforeRotation;
                 targetWidthBeforeRotation = (int) (widthBeforeRotation * scale);
             }
             int scale_xxx = highquality ? Image.SCALE_SMOOTH : Image.SCALE_FAST;
             scaledPicture = sourceBufferedImage.getScaledInstance(targetWidthBeforeRotation,
                     targetHeigthBeforeRotation, scale_xxx);
         }// if (scale < 1)
 
         // Then, rotation of the scaled picture.
         if (this.quarterRotation != 0) {
             @SuppressWarnings("unused")
             AffineTransform rotationTransform;
             switch (this.quarterRotation) {
                 case 0:
                 case 2:
                     maxWidthBeforeRotation = this.uploadPolicy.getMaxWidth();
                     maxHeigthBeforeRotation = this.uploadPolicy.getMaxHeight();
                     widthBeforeRotation = sourceBufferedImage.getWidth();
                     heigthBeforeRotation = sourceBufferedImage.getHeight();
                     widthAfterRotation = sourceBufferedImage.getWidth();
                     heigthAfterRotation = sourceBufferedImage.getHeight();
                     break;
                 case 1:
                 case 3:
                     maxWidthBeforeRotation = this.uploadPolicy.getMaxHeight();
                     maxHeigthBeforeRotation = this.uploadPolicy.getMaxWidth();
                     widthBeforeRotation = sourceBufferedImage.getHeight();
                     heigthBeforeRotation = sourceBufferedImage.getWidth();
                     widthAfterRotation = sourceBufferedImage.getHeight();
                     heigthAfterRotation = sourceBufferedImage.getWidth();
                     break;
                 default:
                     throw new JUploadException("Invalid quarter rotation: <" + this.quarterRotation + ">");
             }
             // TODO finish this new version
             // dest = new BufferedImage(widthAfterRotation, heigthAfterRotation,
             // BufferedImage.TYPE_BYTE_INDEXED,sourceBufferedImage.getColorModel())
 
             // It's finished !
             this.uploadPolicy.displayDebug("getBufferedImage: was " + (System.currentTimeMillis() - msGetBufferedImage)
                     + " ms long", 50);
         }
         return dest;
     }
 
     /**
      * Implementation of the ImageObserver interface. Used to follow the drawImage progression, and update the applet
      * progress bar.
      * 
      * @param img
      * @param infoflags
      * @param x
      * @param y
      * @param width
      * @param height
      * @return Whether or not the work must go on.
      */
     public boolean imageUpdate(Image img, int infoflags, int x, int y, int width, int height) {
         if ((infoflags & ImageObserver.WIDTH) == ImageObserver.WIDTH) {
             this.progressBarBaseValue = this.uploadPolicy.getContext().getUploadPanel().getPreparationProgressBar()
                     .getValue();
             this.uploadPolicy.displayDebug("  imageUpdate (start of), progressBar geValue: "
                     + this.progressBarBaseValue, 50);
             int max = this.uploadPolicy.getContext().getUploadPanel().getPreparationProgressBar().getMaximum();
             this.uploadPolicy.displayDebug("  imageUpdate (start of), progressBar maximum: " + max, 50);
         } else if ((infoflags & ImageObserver.SOMEBITS) == ImageObserver.SOMEBITS) {
             this.nbPixelsRead += width * height;
             int percentage = (int) ((long) this.nbPixelsRead * 100 / this.nbPixelsTotal);
             this.uploadPolicy.getContext().getUploadPanel().getPreparationProgressBar()
                     .setValue(this.progressBarBaseValue + percentage);
             // TODO: drawImage in another thread, to allow repaint of the
             // progress bar ?
             // Current status: the progress bar is only updated ... when
             // draImage returns, that is: when everything is finished. NO
             // interest.
             this.uploadPolicy.getContext().getUploadPanel().getPreparationProgressBar().repaint();
         } else if ((infoflags & ImageObserver.ALLBITS) == ImageObserver.ALLBITS) {
             this.uploadPolicy.displayDebug("  imageUpdate, total number of pixels: " + this.nbPixelsRead + " read", 50);
         }
 
         // We want to go on, after these bits
         return true;
     }
 }