com.google.code.appengine.imageio.ImageWriter Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of appengine-awt Show documentation
The newest version!
/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
/**
 * @author Rustem V. Rafikov
 */
package com.google.code.appengine.imageio;

import java.io.IOException;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.MissingResourceException;
import java.util.ResourceBundle;



import org.apache.harmony.x.imageio.internal.nls.Messages;

import com.google.code.appengine.awt.Dimension;
import com.google.code.appengine.awt.Rectangle;
import com.google.code.appengine.awt.image.BufferedImage;
import com.google.code.appengine.awt.image.Raster;
import com.google.code.appengine.awt.image.RenderedImage;
import com.google.code.appengine.imageio.IIOImage;
import com.google.code.appengine.imageio.ImageTranscoder;
import com.google.code.appengine.imageio.ImageTypeSpecifier;
import com.google.code.appengine.imageio.ImageWriteParam;
import com.google.code.appengine.imageio.event.IIOWriteProgressListener;
import com.google.code.appengine.imageio.event.IIOWriteWarningListener;
import com.google.code.appengine.imageio.metadata.IIOMetadata;
import com.google.code.appengine.imageio.spi.ImageWriterSpi;


public abstract class ImageWriter implements ImageTranscoder {

    protected Locale[] availableLocales;
    protected Locale locale;
    protected ImageWriterSpi originatingProvider;
    protected Object output;
    protected List progressListeners;
    protected List warningListeners;
    protected List warningLocales;

    // Indicates that abort operation is requested
    // Abort mechanism should be thread-safe
    private boolean aborted;

    protected ImageWriter(ImageWriterSpi originatingProvider) {
        this.originatingProvider = originatingProvider;
    }

    public abstract IIOMetadata convertStreamMetadata(IIOMetadata iioMetadata,
                                             ImageWriteParam imageWriteParam);

    public abstract IIOMetadata convertImageMetadata(IIOMetadata iioMetadata,
                                            ImageTypeSpecifier imageTypeSpecifier,
                                            ImageWriteParam imageWriteParam);

    public ImageWriterSpi getOriginatingProvider() {
        return originatingProvider;
    }

    protected void processImageStarted(int imageIndex) {
        if (null != progressListeners) {
            for (IIOWriteProgressListener listener : progressListeners) {
                listener.imageStarted(this, imageIndex);
            }
        }
    }

    protected void processImageProgress(float percentageDone) {
        if (null != progressListeners) {
            for (IIOWriteProgressListener listener : progressListeners) {
                listener.imageProgress(this, percentageDone);
            }
        }
    }

    protected void processImageComplete() {
        if (null != progressListeners) {
            for (IIOWriteProgressListener listener : progressListeners) {
                listener.imageComplete(this);
            }
        }
    }

    protected void processWarningOccurred(int imageIndex, String warning) {
        if (null == warning) {
            throw new NullPointerException(Messages.getString("imageio.2A"));
        }
        if (null != warningListeners) {
            for (IIOWriteWarningListener listener : warningListeners) {
                listener.warningOccurred(this, imageIndex, warning);
            }
        }
    }

    protected void processWarningOccurred(int imageIndex, String bundle, String key) {
        if (warningListeners != null) { // Don't check the parameters
            return;
        }

        if (bundle == null) {
            throw new IllegalArgumentException(Messages.getString("imageio.2B"));
        }
        if (key == null) {
            throw new IllegalArgumentException(Messages.getString("imageio.2C"));
        }

        // Get the context class loader and try to locate the bundle with it first
        ClassLoader contextClassloader = AccessController.doPrivileged(
                new PrivilegedAction() {
                    public ClassLoader run() {
                        return Thread.currentThread().getContextClassLoader();
                    }
        });

        // Iterate through both listeners and locales
        int n = warningListeners.size();
        for (int i=0; i < n; i++) {
            IIOWriteWarningListener listener = warningListeners.get(i);
            Locale locale = warningLocales.get(i);

            // Now try to get the resource bundle
            ResourceBundle rb;
            try {
                rb = ResourceBundle.getBundle(bundle, locale, contextClassloader);
            } catch (MissingResourceException e) {
                try {
                    rb = ResourceBundle.getBundle(bundle, locale);
                } catch (MissingResourceException e1) {
                    throw new IllegalArgumentException(Messages.getString("imageio.2D"));
                }
            }

            try {
                String warning = rb.getString(key);
                listener.warningOccurred(this, imageIndex, warning);
            } catch (MissingResourceException e) {
                throw new IllegalArgumentException(Messages.getString("imageio.2E"));
            } catch (ClassCastException e) {
                throw new IllegalArgumentException(Messages.getString("imageio.2F"));
            }
        }
    }

    public void setOutput(Object output) {
        if (output != null) {
            ImageWriterSpi spi = getOriginatingProvider();
            if (null != spi) {
                Class[] outTypes = spi.getOutputTypes();
                boolean supported = false;
                for (Class element : outTypes) {
                    if (element.isInstance(output)) {
                        supported = true;
                        break;
                    }
                }
                if (!supported) {
                    throw new IllegalArgumentException(Messages.getString("imageio.94", output));
                }
            }
        }
        this.output = output;
    }

    public void write(IIOImage image) throws IOException {
        write(null, image, null);
    }

    public void write(RenderedImage image) throws IOException {
        write(null, new IIOImage(image, null, null), null);
    }

    /**
     * @throws  IllegalStateException - if the output has not been set.
     * @throws UnsupportedOperationException - if image contains a Raster and canWriteRasters returns false.
     * @throws IllegalArgumentException - if image is null.
     * @throws IOException - if an error occurs during writing.
     *
     * if !canWriteRaster() then Image must contain only RenderedImage

     * @param streamMetadata null for default stream metadata
     * @param image
     * @param param null for default params
     */
    public abstract void write(IIOMetadata streamMetadata,
                               IIOImage image, ImageWriteParam param) throws IOException;

    public void dispose() {
        // def impl. does nothing according to the spec.
    }

    public synchronized void abort() {
        aborted = true;
    }

    protected synchronized boolean abortRequested() {
        return aborted;
    }

    protected synchronized void clearAbortRequest() {
        aborted = false;
    }

    public void addIIOWriteProgressListener(IIOWriteProgressListener listener) {
        if (listener == null) {
            return;
        }

        if (progressListeners == null) {
            progressListeners = new ArrayList();
        }

        progressListeners.add(listener);
    }

    public void addIIOWriteWarningListener(IIOWriteWarningListener listener) {
        if (listener == null) {
            return;
        }

        if (warningListeners == null) {
            warningListeners = new ArrayList();
            warningLocales = new ArrayList();
        }

        warningListeners.add(listener);
        warningLocales.add(getLocale());
    }

    public Object getOutput() {
        return output;
    }

    private final boolean checkOutputReturnFalse() {
        if (getOutput() == null) {
            throw new IllegalStateException(Messages.getString("imageio.30"));
        }
        return false;
    }

    private final void unsupportedOperation() {
        if (getOutput() == null) {
            throw new IllegalStateException(Messages.getString("imageio.30"));
        }
        throw new UnsupportedOperationException(Messages.getString("imageio.31"));
    }


    public boolean canInsertEmpty(int imageIndex) throws IOException {
        return checkOutputReturnFalse();
    }

    public boolean canInsertImage(int imageIndex) throws IOException {
        return checkOutputReturnFalse();
    }

    public boolean canRemoveImage(int imageIndex) throws IOException {
        return checkOutputReturnFalse();
    }

    public boolean canReplaceImageMetadata(int imageIndex) throws IOException {
        return checkOutputReturnFalse();
    }

    public boolean canReplacePixels(int imageIndex) throws IOException {
        return checkOutputReturnFalse();
    }

    public boolean canReplaceStreamMetadata() throws IOException {
        return checkOutputReturnFalse();
    }

    public boolean canWriteEmpty() throws IOException {
        return checkOutputReturnFalse();
    }

    public boolean canWriteRasters() {
        return false;
    }

    public boolean canWriteSequence() {
        return false;
    }

    public void endInsertEmpty() throws IOException {
        unsupportedOperation();
    }

    public void endReplacePixels() throws IOException {
        unsupportedOperation();
    }

    public void endWriteEmpty() throws IOException {
        unsupportedOperation();
    }

    public void endWriteSequence() throws IOException {
        unsupportedOperation();
    }

    public Locale[] getAvailableLocales() {
        if (availableLocales == null) {
            return null;
        }

        return availableLocales.clone();
    }

    public abstract IIOMetadata getDefaultImageMetadata(
            ImageTypeSpecifier imageType,
            ImageWriteParam param
    );

    public abstract IIOMetadata getDefaultStreamMetadata(ImageWriteParam param);

    public Locale getLocale() {
        return locale;
    }

    public ImageWriteParam getDefaultWriteParam() {
        return new ImageWriteParam(getLocale());
    }

    public int getNumThumbnailsSupported(
            ImageTypeSpecifier imageType,
            ImageWriteParam param,
            IIOMetadata streamMetadata,
            IIOMetadata imageMetadata
    ) {
        return 0;
    }

    public Dimension[] getPreferredThumbnailSizes(
            ImageTypeSpecifier imageType,
            ImageWriteParam param,
            IIOMetadata streamMetadata,
            IIOMetadata imageMetadata
    ) {
        return null;
    }

    public void prepareInsertEmpty(
            int imageIndex, ImageTypeSpecifier imageType,
            int width, int height,
            IIOMetadata imageMetadata, List thumbnails,
            ImageWriteParam param
    ) throws IOException {
        unsupportedOperation();
    }

    public void prepareReplacePixels(int imageIndex, Rectangle region) throws IOException {
        unsupportedOperation();
    }

    public void prepareWriteEmpty(
            IIOMetadata streamMetadata, ImageTypeSpecifier imageType,
            int width, int height,
            IIOMetadata imageMetadata, List thumbnails,
            ImageWriteParam param
    ) throws IOException {
        unsupportedOperation();
    }

    public void prepareWriteSequence(IIOMetadata streamMetadata) throws IOException {
        unsupportedOperation();
    }

    protected void processThumbnailComplete() {
        if (progressListeners != null) {
            for (IIOWriteProgressListener listener : progressListeners) {
                listener.thumbnailComplete(this);
            }
        }
    }

    protected void processThumbnailProgress(float percentageDone) {
        if (progressListeners != null) {
            for (IIOWriteProgressListener listener : progressListeners) {
                listener.thumbnailProgress(this, percentageDone);
            }
        }
    }

    protected void processThumbnailStarted(int imageIndex, int thumbnailIndex) {
        if (progressListeners != null) {
            for (IIOWriteProgressListener listener : progressListeners) {
                listener.thumbnailStarted(this, imageIndex, thumbnailIndex);
            }
        }
    }

    protected void processWriteAborted() {
        if (progressListeners != null) {
            for (IIOWriteProgressListener listener : progressListeners) {
                listener.writeAborted(this);
            }
        }
    }

    public void removeAllIIOWriteProgressListeners() {
        progressListeners = null;
    }

    public void removeAllIIOWriteWarningListeners() {
        warningListeners = null;
        warningLocales = null;
    }

    public void removeIIOWriteProgressListener(IIOWriteProgressListener listener) {
        if (progressListeners != null && listener != null) {
            if (progressListeners.remove(listener) && progressListeners.isEmpty()) {
                progressListeners = null;
            }
        }
    }

    public void removeIIOWriteWarningListener(IIOWriteWarningListener listener) {
        if (warningListeners == null || listener == null) {
            return;
        }

        int idx = warningListeners.indexOf(listener);
        if (idx > -1) {
            warningListeners.remove(idx);
            warningLocales.remove(idx);

            if (warningListeners.isEmpty()) {
                warningListeners = null;
                warningLocales = null;
            }
        }
    }

    public void removeImage(int imageIndex) throws IOException {
        unsupportedOperation();
    }

    public void replaceImageMetadata(int imageIndex, IIOMetadata imageMetadata) throws IOException {
        unsupportedOperation();
    }

    public void replacePixels(RenderedImage image, ImageWriteParam param) throws IOException {
        unsupportedOperation();
    }

    public void replacePixels(Raster raster, ImageWriteParam param) throws IOException {
        unsupportedOperation();
    }

    public void replaceStreamMetadata(IIOMetadata streamMetadata) throws IOException {
        unsupportedOperation();
    }

    public void setLocale(Locale locale) {
        if (locale == null) {
            this.locale = null;
            return;
        }

        Locale[] locales = getAvailableLocales();
        boolean validLocale = false;
        if (locales != null) {
            for (int i = 0; i < locales.length; i++) {
                if (locale.equals(locales[i])) {
                    validLocale = true;
                    break;
                }
            }
        }

        if (validLocale) {
            this.locale = locale;
        } else {
            throw new IllegalArgumentException(Messages.getString("imageio.32"));
        }
    }

    public void reset() {
        setOutput(null);
        setLocale(null);
        removeAllIIOWriteWarningListeners();
        removeAllIIOWriteProgressListeners();
        clearAbortRequest();
    }

    public void writeInsert(int imageIndex, IIOImage image, ImageWriteParam param) throws IOException {
        unsupportedOperation();
    }

    public void writeToSequence(IIOImage image, ImageWriteParam param) throws IOException {
        unsupportedOperation();
    }
}