From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository. --- libjava/javax/imageio/IIOException.h | 30 ++++ libjava/javax/imageio/IIOImage.h | 63 ++++++++ libjava/javax/imageio/IIOParam.h | 74 +++++++++ libjava/javax/imageio/IIOParamController.h | 30 ++++ libjava/javax/imageio/ImageIO$1.h | 38 +++++ .../javax/imageio/ImageIO$ImageReaderIterator.h | 39 +++++ .../javax/imageio/ImageIO$ImageWriterIterator.h | 39 +++++ libjava/javax/imageio/ImageIO$ReaderFormatFilter.h | 33 ++++ .../javax/imageio/ImageIO$ReaderMIMETypeFilter.h | 33 ++++ libjava/javax/imageio/ImageIO$ReaderObjectFilter.h | 33 ++++ libjava/javax/imageio/ImageIO$ReaderSuffixFilter.h | 33 ++++ libjava/javax/imageio/ImageIO$TranscoderFilter.h | 36 +++++ libjava/javax/imageio/ImageIO$WriterFormatFilter.h | 33 ++++ .../javax/imageio/ImageIO$WriterMIMETypeFilter.h | 33 ++++ libjava/javax/imageio/ImageIO$WriterObjectFilter.h | 35 +++++ libjava/javax/imageio/ImageIO$WriterSuffixFilter.h | 33 ++++ libjava/javax/imageio/ImageIO.h | 97 ++++++++++++ libjava/javax/imageio/ImageReadParam.h | 61 ++++++++ libjava/javax/imageio/ImageReader.h | 166 +++++++++++++++++++++ libjava/javax/imageio/ImageTranscoder.h | 36 +++++ libjava/javax/imageio/ImageTypeSpecifier.h | 69 +++++++++ libjava/javax/imageio/ImageWriteParam.h | 102 +++++++++++++ libjava/javax/imageio/ImageWriter.h | 140 +++++++++++++++++ .../javax/imageio/event/IIOReadProgressListener.h | 41 +++++ .../javax/imageio/event/IIOReadUpdateListener.h | 50 +++++++ .../javax/imageio/event/IIOReadWarningListener.h | 33 ++++ .../javax/imageio/event/IIOWriteProgressListener.h | 39 +++++ .../javax/imageio/event/IIOWriteWarningListener.h | 33 ++++ .../imageio/metadata/IIOInvalidTreeException.h | 49 ++++++ libjava/javax/imageio/metadata/IIOMetadata.h | 87 +++++++++++ .../javax/imageio/metadata/IIOMetadataController.h | 33 ++++ libjava/javax/imageio/metadata/IIOMetadataFormat.h | 82 ++++++++++ .../imageio/metadata/IIOMetadataFormatImpl$1.h | 35 +++++ .../IIOMetadataFormatImpl$IIOMetadataNodeAttr.h | 60 ++++++++ ...MetadataFormatImpl$IIOMetadataNodeAttrBounded.h | 53 +++++++ ...adataFormatImpl$IIOMetadataNodeAttrEnumerated.h | 51 +++++++ ...IIOMetadataFormatImpl$IIOMetadataNodeAttrList.h | 51 +++++++ .../metadata/IIOMetadataFormatImpl$NodeObject.h | 57 +++++++ .../IIOMetadataFormatImpl$NodeObjectArray.h | 51 +++++++ .../IIOMetadataFormatImpl$NodeObjectBounded.h | 53 +++++++ .../IIOMetadataFormatImpl$NodeObjectEnumerated.h | 51 +++++++ .../javax/imageio/metadata/IIOMetadataFormatImpl.h | 105 +++++++++++++ .../metadata/IIOMetadataNode$IIONamedNodeMap.h | 55 +++++++ .../imageio/metadata/IIOMetadataNode$IIONodeList.h | 50 +++++++ libjava/javax/imageio/metadata/IIOMetadataNode.h | 121 +++++++++++++++ .../javax/imageio/plugins/bmp/BMPImageWriteParam.h | 50 +++++++ .../javax/imageio/plugins/jpeg/JPEGHuffmanTable.h | 53 +++++++ .../imageio/plugins/jpeg/JPEGImageReadParam.h | 50 +++++++ .../imageio/plugins/jpeg/JPEGImageWriteParam.h | 60 ++++++++ libjava/javax/imageio/plugins/jpeg/JPEGQTable.h | 51 +++++++ libjava/javax/imageio/spi/IIORegistry.h | 40 +++++ libjava/javax/imageio/spi/IIOServiceProvider.h | 43 ++++++ libjava/javax/imageio/spi/ImageInputStreamSpi.h | 46 ++++++ libjava/javax/imageio/spi/ImageOutputStreamSpi.h | 46 ++++++ libjava/javax/imageio/spi/ImageReaderSpi.h | 48 ++++++ libjava/javax/imageio/spi/ImageReaderWriterSpi.h | 67 +++++++++ libjava/javax/imageio/spi/ImageTranscoderSpi.h | 38 +++++ libjava/javax/imageio/spi/ImageWriterSpi.h | 61 ++++++++ libjava/javax/imageio/spi/RegisterableService.h | 34 +++++ libjava/javax/imageio/spi/ServiceRegistry$1.h | 41 +++++ libjava/javax/imageio/spi/ServiceRegistry$2.h | 40 +++++ libjava/javax/imageio/spi/ServiceRegistry$Filter.h | 32 ++++ libjava/javax/imageio/spi/ServiceRegistry.h | 70 +++++++++ .../imageio/stream/FileCacheImageInputStream.h | 47 ++++++ .../imageio/stream/FileCacheImageOutputStream.h | 51 +++++++ .../javax/imageio/stream/FileImageInputStream.h | 43 ++++++ .../javax/imageio/stream/FileImageOutputStream.h | 45 ++++++ libjava/javax/imageio/stream/IIOByteBuffer.h | 45 ++++++ libjava/javax/imageio/stream/ImageInputStream.h | 86 +++++++++++ .../javax/imageio/stream/ImageInputStreamImpl.h | 105 +++++++++++++ libjava/javax/imageio/stream/ImageOutputStream.h | 108 ++++++++++++++ .../javax/imageio/stream/ImageOutputStreamImpl.h | 59 ++++++++ .../imageio/stream/MemoryCacheImageInputStream.h | 47 ++++++ .../imageio/stream/MemoryCacheImageOutputStream.h | 46 ++++++ 74 files changed, 4078 insertions(+) create mode 100644 libjava/javax/imageio/IIOException.h create mode 100644 libjava/javax/imageio/IIOImage.h create mode 100644 libjava/javax/imageio/IIOParam.h create mode 100644 libjava/javax/imageio/IIOParamController.h create mode 100644 libjava/javax/imageio/ImageIO$1.h create mode 100644 libjava/javax/imageio/ImageIO$ImageReaderIterator.h create mode 100644 libjava/javax/imageio/ImageIO$ImageWriterIterator.h create mode 100644 libjava/javax/imageio/ImageIO$ReaderFormatFilter.h create mode 100644 libjava/javax/imageio/ImageIO$ReaderMIMETypeFilter.h create mode 100644 libjava/javax/imageio/ImageIO$ReaderObjectFilter.h create mode 100644 libjava/javax/imageio/ImageIO$ReaderSuffixFilter.h create mode 100644 libjava/javax/imageio/ImageIO$TranscoderFilter.h create mode 100644 libjava/javax/imageio/ImageIO$WriterFormatFilter.h create mode 100644 libjava/javax/imageio/ImageIO$WriterMIMETypeFilter.h create mode 100644 libjava/javax/imageio/ImageIO$WriterObjectFilter.h create mode 100644 libjava/javax/imageio/ImageIO$WriterSuffixFilter.h create mode 100644 libjava/javax/imageio/ImageIO.h create mode 100644 libjava/javax/imageio/ImageReadParam.h create mode 100644 libjava/javax/imageio/ImageReader.h create mode 100644 libjava/javax/imageio/ImageTranscoder.h create mode 100644 libjava/javax/imageio/ImageTypeSpecifier.h create mode 100644 libjava/javax/imageio/ImageWriteParam.h create mode 100644 libjava/javax/imageio/ImageWriter.h create mode 100644 libjava/javax/imageio/event/IIOReadProgressListener.h create mode 100644 libjava/javax/imageio/event/IIOReadUpdateListener.h create mode 100644 libjava/javax/imageio/event/IIOReadWarningListener.h create mode 100644 libjava/javax/imageio/event/IIOWriteProgressListener.h create mode 100644 libjava/javax/imageio/event/IIOWriteWarningListener.h create mode 100644 libjava/javax/imageio/metadata/IIOInvalidTreeException.h create mode 100644 libjava/javax/imageio/metadata/IIOMetadata.h create mode 100644 libjava/javax/imageio/metadata/IIOMetadataController.h create mode 100644 libjava/javax/imageio/metadata/IIOMetadataFormat.h create mode 100644 libjava/javax/imageio/metadata/IIOMetadataFormatImpl$1.h create mode 100644 libjava/javax/imageio/metadata/IIOMetadataFormatImpl$IIOMetadataNodeAttr.h create mode 100644 libjava/javax/imageio/metadata/IIOMetadataFormatImpl$IIOMetadataNodeAttrBounded.h create mode 100644 libjava/javax/imageio/metadata/IIOMetadataFormatImpl$IIOMetadataNodeAttrEnumerated.h create mode 100644 libjava/javax/imageio/metadata/IIOMetadataFormatImpl$IIOMetadataNodeAttrList.h create mode 100644 libjava/javax/imageio/metadata/IIOMetadataFormatImpl$NodeObject.h create mode 100644 libjava/javax/imageio/metadata/IIOMetadataFormatImpl$NodeObjectArray.h create mode 100644 libjava/javax/imageio/metadata/IIOMetadataFormatImpl$NodeObjectBounded.h create mode 100644 libjava/javax/imageio/metadata/IIOMetadataFormatImpl$NodeObjectEnumerated.h create mode 100644 libjava/javax/imageio/metadata/IIOMetadataFormatImpl.h create mode 100644 libjava/javax/imageio/metadata/IIOMetadataNode$IIONamedNodeMap.h create mode 100644 libjava/javax/imageio/metadata/IIOMetadataNode$IIONodeList.h create mode 100644 libjava/javax/imageio/metadata/IIOMetadataNode.h create mode 100644 libjava/javax/imageio/plugins/bmp/BMPImageWriteParam.h create mode 100644 libjava/javax/imageio/plugins/jpeg/JPEGHuffmanTable.h create mode 100644 libjava/javax/imageio/plugins/jpeg/JPEGImageReadParam.h create mode 100644 libjava/javax/imageio/plugins/jpeg/JPEGImageWriteParam.h create mode 100644 libjava/javax/imageio/plugins/jpeg/JPEGQTable.h create mode 100644 libjava/javax/imageio/spi/IIORegistry.h create mode 100644 libjava/javax/imageio/spi/IIOServiceProvider.h create mode 100644 libjava/javax/imageio/spi/ImageInputStreamSpi.h create mode 100644 libjava/javax/imageio/spi/ImageOutputStreamSpi.h create mode 100644 libjava/javax/imageio/spi/ImageReaderSpi.h create mode 100644 libjava/javax/imageio/spi/ImageReaderWriterSpi.h create mode 100644 libjava/javax/imageio/spi/ImageTranscoderSpi.h create mode 100644 libjava/javax/imageio/spi/ImageWriterSpi.h create mode 100644 libjava/javax/imageio/spi/RegisterableService.h create mode 100644 libjava/javax/imageio/spi/ServiceRegistry$1.h create mode 100644 libjava/javax/imageio/spi/ServiceRegistry$2.h create mode 100644 libjava/javax/imageio/spi/ServiceRegistry$Filter.h create mode 100644 libjava/javax/imageio/spi/ServiceRegistry.h create mode 100644 libjava/javax/imageio/stream/FileCacheImageInputStream.h create mode 100644 libjava/javax/imageio/stream/FileCacheImageOutputStream.h create mode 100644 libjava/javax/imageio/stream/FileImageInputStream.h create mode 100644 libjava/javax/imageio/stream/FileImageOutputStream.h create mode 100644 libjava/javax/imageio/stream/IIOByteBuffer.h create mode 100644 libjava/javax/imageio/stream/ImageInputStream.h create mode 100644 libjava/javax/imageio/stream/ImageInputStreamImpl.h create mode 100644 libjava/javax/imageio/stream/ImageOutputStream.h create mode 100644 libjava/javax/imageio/stream/ImageOutputStreamImpl.h create mode 100644 libjava/javax/imageio/stream/MemoryCacheImageInputStream.h create mode 100644 libjava/javax/imageio/stream/MemoryCacheImageOutputStream.h (limited to 'libjava/javax/imageio') diff --git a/libjava/javax/imageio/IIOException.h b/libjava/javax/imageio/IIOException.h new file mode 100644 index 000000000..b303de898 --- /dev/null +++ b/libjava/javax/imageio/IIOException.h @@ -0,0 +1,30 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_IIOException__ +#define __javax_imageio_IIOException__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + class IIOException; + } + } +} + +class javax::imageio::IIOException : public ::java::io::IOException +{ + +public: + IIOException(::java::lang::String *); + IIOException(::java::lang::String *, ::java::lang::Throwable *); + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_IIOException__ diff --git a/libjava/javax/imageio/IIOImage.h b/libjava/javax/imageio/IIOImage.h new file mode 100644 index 000000000..ae23913df --- /dev/null +++ b/libjava/javax/imageio/IIOImage.h @@ -0,0 +1,63 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_IIOImage__ +#define __javax_imageio_IIOImage__ + +#pragma interface + +#include +extern "Java" +{ + namespace java + { + namespace awt + { + namespace image + { + class BufferedImage; + class Raster; + class RenderedImage; + } + } + } + namespace javax + { + namespace imageio + { + class IIOImage; + namespace metadata + { + class IIOMetadata; + } + } + } +} + +class javax::imageio::IIOImage : public ::java::lang::Object +{ + +public: + IIOImage(::java::awt::image::Raster *, ::java::util::List *, ::javax::imageio::metadata::IIOMetadata *); + IIOImage(::java::awt::image::RenderedImage *, ::java::util::List *, ::javax::imageio::metadata::IIOMetadata *); + virtual ::javax::imageio::metadata::IIOMetadata * getMetadata(); + virtual jint getNumThumbnails(); + virtual ::java::awt::image::Raster * getRaster(); + virtual ::java::awt::image::RenderedImage * getRenderedImage(); + virtual ::java::awt::image::BufferedImage * getThumbnail(jint); + virtual ::java::util::List * getThumbnails(); + virtual jboolean hasRaster(); + virtual void setMetadata(::javax::imageio::metadata::IIOMetadata *); + virtual void setRaster(::java::awt::image::Raster *); + virtual void setRenderedImage(::java::awt::image::RenderedImage *); + virtual void setThumbnails(::java::util::List *); +public: // actually protected + ::java::awt::image::RenderedImage * __attribute__((aligned(__alignof__( ::java::lang::Object)))) image; + ::javax::imageio::metadata::IIOMetadata * metadata; + ::java::awt::image::Raster * raster; + ::java::util::List * thumbnails; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_IIOImage__ diff --git a/libjava/javax/imageio/IIOParam.h b/libjava/javax/imageio/IIOParam.h new file mode 100644 index 000000000..ca81aea23 --- /dev/null +++ b/libjava/javax/imageio/IIOParam.h @@ -0,0 +1,74 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_IIOParam__ +#define __javax_imageio_IIOParam__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace java + { + namespace awt + { + class Point; + class Rectangle; + } + } + namespace javax + { + namespace imageio + { + class IIOParam; + class IIOParamController; + class ImageTypeSpecifier; + } + } +} + +class javax::imageio::IIOParam : public ::java::lang::Object +{ + +public: // actually protected + IIOParam(); +public: + virtual jboolean activateController(); + virtual ::javax::imageio::IIOParamController * getController(); + virtual ::javax::imageio::IIOParamController * getDefaultController(); + virtual ::java::awt::Point * getDestinationOffset(); + virtual ::javax::imageio::ImageTypeSpecifier * getDestinationType(); + virtual JArray< jint > * getSourceBands(); + virtual ::java::awt::Rectangle * getSourceRegion(); + virtual jint getSourceXSubsampling(); + virtual jint getSourceYSubsampling(); + virtual jint getSubsamplingXOffset(); + virtual jint getSubsamplingYOffset(); + virtual jboolean hasController(); + virtual void setController(::javax::imageio::IIOParamController *); + virtual void setDestinationType(::javax::imageio::ImageTypeSpecifier *); + virtual void setDestinationOffset(::java::awt::Point *); + virtual void setSourceBands(JArray< jint > *); + virtual void setSourceRegion(::java::awt::Rectangle *); + virtual void setSourceSubsampling(jint, jint, jint, jint); +public: // actually protected + ::javax::imageio::IIOParamController * __attribute__((aligned(__alignof__( ::java::lang::Object)))) controller; + ::javax::imageio::IIOParamController * defaultController; + ::java::awt::Point * destinationOffset; + ::javax::imageio::ImageTypeSpecifier * destinationType; + JArray< jint > * sourceBands; + ::java::awt::Rectangle * sourceRegion; + jint sourceXSubsampling; + jint sourceYSubsampling; + jint subsamplingXOffset; + jint subsamplingYOffset; +private: + jboolean no_controller; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_IIOParam__ diff --git a/libjava/javax/imageio/IIOParamController.h b/libjava/javax/imageio/IIOParamController.h new file mode 100644 index 000000000..3e9d52d50 --- /dev/null +++ b/libjava/javax/imageio/IIOParamController.h @@ -0,0 +1,30 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_IIOParamController__ +#define __javax_imageio_IIOParamController__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + class IIOParam; + class IIOParamController; + } + } +} + +class javax::imageio::IIOParamController : public ::java::lang::Object +{ + +public: + virtual jboolean activate(::javax::imageio::IIOParam *) = 0; + static ::java::lang::Class class$; +} __attribute__ ((java_interface)); + +#endif // __javax_imageio_IIOParamController__ diff --git a/libjava/javax/imageio/ImageIO$1.h b/libjava/javax/imageio/ImageIO$1.h new file mode 100644 index 000000000..9777688a0 --- /dev/null +++ b/libjava/javax/imageio/ImageIO$1.h @@ -0,0 +1,38 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_ImageIO$1__ +#define __javax_imageio_ImageIO$1__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + class ImageIO$1; + class ImageTranscoder; + } + } +} + +class javax::imageio::ImageIO$1 : public ::java::lang::Object +{ + +public: // actually package-private + ImageIO$1(::java::util::Iterator *); +public: + virtual jboolean hasNext(); + virtual ::javax::imageio::ImageTranscoder * ImageIO$1$next(); + virtual void remove(); + virtual ::java::lang::Object * next(); +private: + ::java::util::Iterator * __attribute__((aligned(__alignof__( ::java::lang::Object)))) val$spiIterator; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_ImageIO$1__ diff --git a/libjava/javax/imageio/ImageIO$ImageReaderIterator.h b/libjava/javax/imageio/ImageIO$ImageReaderIterator.h new file mode 100644 index 000000000..bb0285eee --- /dev/null +++ b/libjava/javax/imageio/ImageIO$ImageReaderIterator.h @@ -0,0 +1,39 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_ImageIO$ImageReaderIterator__ +#define __javax_imageio_ImageIO$ImageReaderIterator__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + class ImageIO$ImageReaderIterator; + class ImageReader; + } + } +} + +class javax::imageio::ImageIO$ImageReaderIterator : public ::java::lang::Object +{ + +public: + ImageIO$ImageReaderIterator(::java::util::Iterator *, ::java::lang::Object *); + ImageIO$ImageReaderIterator(::java::util::Iterator *); + jboolean hasNext(); + ::javax::imageio::ImageReader * ImageIO$ImageReaderIterator$next(); + void remove(); + ::java::lang::Object * next(); +public: // actually package-private + ::java::util::Iterator * __attribute__((aligned(__alignof__( ::java::lang::Object)))) it; + ::java::lang::Object * readerExtension; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_ImageIO$ImageReaderIterator__ diff --git a/libjava/javax/imageio/ImageIO$ImageWriterIterator.h b/libjava/javax/imageio/ImageIO$ImageWriterIterator.h new file mode 100644 index 000000000..dcf9101f0 --- /dev/null +++ b/libjava/javax/imageio/ImageIO$ImageWriterIterator.h @@ -0,0 +1,39 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_ImageIO$ImageWriterIterator__ +#define __javax_imageio_ImageIO$ImageWriterIterator__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + class ImageIO$ImageWriterIterator; + class ImageWriter; + } + } +} + +class javax::imageio::ImageIO$ImageWriterIterator : public ::java::lang::Object +{ + +public: + ImageIO$ImageWriterIterator(::java::util::Iterator *, ::java::lang::Object *); + ImageIO$ImageWriterIterator(::java::util::Iterator *); + jboolean hasNext(); + ::javax::imageio::ImageWriter * ImageIO$ImageWriterIterator$next(); + void remove(); + ::java::lang::Object * next(); +public: // actually package-private + ::java::util::Iterator * __attribute__((aligned(__alignof__( ::java::lang::Object)))) it; + ::java::lang::Object * writerExtension; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_ImageIO$ImageWriterIterator__ diff --git a/libjava/javax/imageio/ImageIO$ReaderFormatFilter.h b/libjava/javax/imageio/ImageIO$ReaderFormatFilter.h new file mode 100644 index 000000000..a1d35dbff --- /dev/null +++ b/libjava/javax/imageio/ImageIO$ReaderFormatFilter.h @@ -0,0 +1,33 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_ImageIO$ReaderFormatFilter__ +#define __javax_imageio_ImageIO$ReaderFormatFilter__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + class ImageIO$ReaderFormatFilter; + } + } +} + +class javax::imageio::ImageIO$ReaderFormatFilter : public ::java::lang::Object +{ + +public: + ImageIO$ReaderFormatFilter(::java::lang::String *); + jboolean filter(::java::lang::Object *); +private: + ::java::lang::String * __attribute__((aligned(__alignof__( ::java::lang::Object)))) formatName; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_ImageIO$ReaderFormatFilter__ diff --git a/libjava/javax/imageio/ImageIO$ReaderMIMETypeFilter.h b/libjava/javax/imageio/ImageIO$ReaderMIMETypeFilter.h new file mode 100644 index 000000000..7f7503278 --- /dev/null +++ b/libjava/javax/imageio/ImageIO$ReaderMIMETypeFilter.h @@ -0,0 +1,33 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_ImageIO$ReaderMIMETypeFilter__ +#define __javax_imageio_ImageIO$ReaderMIMETypeFilter__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + class ImageIO$ReaderMIMETypeFilter; + } + } +} + +class javax::imageio::ImageIO$ReaderMIMETypeFilter : public ::java::lang::Object +{ + +public: + ImageIO$ReaderMIMETypeFilter(::java::lang::String *); + jboolean filter(::java::lang::Object *); +private: + ::java::lang::String * __attribute__((aligned(__alignof__( ::java::lang::Object)))) MIMEType; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_ImageIO$ReaderMIMETypeFilter__ diff --git a/libjava/javax/imageio/ImageIO$ReaderObjectFilter.h b/libjava/javax/imageio/ImageIO$ReaderObjectFilter.h new file mode 100644 index 000000000..929530f2b --- /dev/null +++ b/libjava/javax/imageio/ImageIO$ReaderObjectFilter.h @@ -0,0 +1,33 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_ImageIO$ReaderObjectFilter__ +#define __javax_imageio_ImageIO$ReaderObjectFilter__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + class ImageIO$ReaderObjectFilter; + } + } +} + +class javax::imageio::ImageIO$ReaderObjectFilter : public ::java::lang::Object +{ + +public: + ImageIO$ReaderObjectFilter(::java::lang::Object *); + jboolean filter(::java::lang::Object *); +private: + ::java::lang::Object * __attribute__((aligned(__alignof__( ::java::lang::Object)))) object; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_ImageIO$ReaderObjectFilter__ diff --git a/libjava/javax/imageio/ImageIO$ReaderSuffixFilter.h b/libjava/javax/imageio/ImageIO$ReaderSuffixFilter.h new file mode 100644 index 000000000..b4dc85d13 --- /dev/null +++ b/libjava/javax/imageio/ImageIO$ReaderSuffixFilter.h @@ -0,0 +1,33 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_ImageIO$ReaderSuffixFilter__ +#define __javax_imageio_ImageIO$ReaderSuffixFilter__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + class ImageIO$ReaderSuffixFilter; + } + } +} + +class javax::imageio::ImageIO$ReaderSuffixFilter : public ::java::lang::Object +{ + +public: + ImageIO$ReaderSuffixFilter(::java::lang::String *); + jboolean filter(::java::lang::Object *); +private: + ::java::lang::String * __attribute__((aligned(__alignof__( ::java::lang::Object)))) fileSuffix; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_ImageIO$ReaderSuffixFilter__ diff --git a/libjava/javax/imageio/ImageIO$TranscoderFilter.h b/libjava/javax/imageio/ImageIO$TranscoderFilter.h new file mode 100644 index 000000000..48b9f104e --- /dev/null +++ b/libjava/javax/imageio/ImageIO$TranscoderFilter.h @@ -0,0 +1,36 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_ImageIO$TranscoderFilter__ +#define __javax_imageio_ImageIO$TranscoderFilter__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + class ImageIO$TranscoderFilter; + class ImageReader; + class ImageWriter; + } + } +} + +class javax::imageio::ImageIO$TranscoderFilter : public ::java::lang::Object +{ + +public: + ImageIO$TranscoderFilter(::javax::imageio::ImageReader *, ::javax::imageio::ImageWriter *); + jboolean filter(::java::lang::Object *); +private: + ::javax::imageio::ImageReader * __attribute__((aligned(__alignof__( ::java::lang::Object)))) reader; + ::javax::imageio::ImageWriter * writer; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_ImageIO$TranscoderFilter__ diff --git a/libjava/javax/imageio/ImageIO$WriterFormatFilter.h b/libjava/javax/imageio/ImageIO$WriterFormatFilter.h new file mode 100644 index 000000000..5b71fda59 --- /dev/null +++ b/libjava/javax/imageio/ImageIO$WriterFormatFilter.h @@ -0,0 +1,33 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_ImageIO$WriterFormatFilter__ +#define __javax_imageio_ImageIO$WriterFormatFilter__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + class ImageIO$WriterFormatFilter; + } + } +} + +class javax::imageio::ImageIO$WriterFormatFilter : public ::java::lang::Object +{ + +public: + ImageIO$WriterFormatFilter(::java::lang::String *); + jboolean filter(::java::lang::Object *); +private: + ::java::lang::String * __attribute__((aligned(__alignof__( ::java::lang::Object)))) formatName; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_ImageIO$WriterFormatFilter__ diff --git a/libjava/javax/imageio/ImageIO$WriterMIMETypeFilter.h b/libjava/javax/imageio/ImageIO$WriterMIMETypeFilter.h new file mode 100644 index 000000000..fc35a0d38 --- /dev/null +++ b/libjava/javax/imageio/ImageIO$WriterMIMETypeFilter.h @@ -0,0 +1,33 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_ImageIO$WriterMIMETypeFilter__ +#define __javax_imageio_ImageIO$WriterMIMETypeFilter__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + class ImageIO$WriterMIMETypeFilter; + } + } +} + +class javax::imageio::ImageIO$WriterMIMETypeFilter : public ::java::lang::Object +{ + +public: + ImageIO$WriterMIMETypeFilter(::java::lang::String *); + jboolean filter(::java::lang::Object *); +private: + ::java::lang::String * __attribute__((aligned(__alignof__( ::java::lang::Object)))) MIMEType; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_ImageIO$WriterMIMETypeFilter__ diff --git a/libjava/javax/imageio/ImageIO$WriterObjectFilter.h b/libjava/javax/imageio/ImageIO$WriterObjectFilter.h new file mode 100644 index 000000000..94500aed6 --- /dev/null +++ b/libjava/javax/imageio/ImageIO$WriterObjectFilter.h @@ -0,0 +1,35 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_ImageIO$WriterObjectFilter__ +#define __javax_imageio_ImageIO$WriterObjectFilter__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + class ImageIO$WriterObjectFilter; + class ImageTypeSpecifier; + } + } +} + +class javax::imageio::ImageIO$WriterObjectFilter : public ::java::lang::Object +{ + +public: + ImageIO$WriterObjectFilter(::javax::imageio::ImageTypeSpecifier *, ::java::lang::String *); + jboolean filter(::java::lang::Object *); +private: + ::javax::imageio::ImageTypeSpecifier * __attribute__((aligned(__alignof__( ::java::lang::Object)))) type; + ::java::lang::String * formatName; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_ImageIO$WriterObjectFilter__ diff --git a/libjava/javax/imageio/ImageIO$WriterSuffixFilter.h b/libjava/javax/imageio/ImageIO$WriterSuffixFilter.h new file mode 100644 index 000000000..9fc513410 --- /dev/null +++ b/libjava/javax/imageio/ImageIO$WriterSuffixFilter.h @@ -0,0 +1,33 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_ImageIO$WriterSuffixFilter__ +#define __javax_imageio_ImageIO$WriterSuffixFilter__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + class ImageIO$WriterSuffixFilter; + } + } +} + +class javax::imageio::ImageIO$WriterSuffixFilter : public ::java::lang::Object +{ + +public: + ImageIO$WriterSuffixFilter(::java::lang::String *); + jboolean filter(::java::lang::Object *); +private: + ::java::lang::String * __attribute__((aligned(__alignof__( ::java::lang::Object)))) fileSuffix; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_ImageIO$WriterSuffixFilter__ diff --git a/libjava/javax/imageio/ImageIO.h b/libjava/javax/imageio/ImageIO.h new file mode 100644 index 000000000..95309b7e7 --- /dev/null +++ b/libjava/javax/imageio/ImageIO.h @@ -0,0 +1,97 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_ImageIO__ +#define __javax_imageio_ImageIO__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace java + { + namespace awt + { + namespace image + { + class BufferedImage; + class RenderedImage; + } + } + namespace net + { + class URL; + } + } + namespace javax + { + namespace imageio + { + class ImageIO; + class ImageReader; + class ImageTypeSpecifier; + class ImageWriter; + namespace spi + { + class IIORegistry; + class ServiceRegistry$Filter; + } + namespace stream + { + class ImageInputStream; + class ImageOutputStream; + } + } + } +} + +class javax::imageio::ImageIO : public ::java::lang::Object +{ + + ImageIO(); + static ::java::util::Iterator * getReadersByFilter(::java::lang::Class *, ::javax::imageio::spi::ServiceRegistry$Filter *, ::java::lang::Object *); + static ::java::util::Iterator * getWritersByFilter(::java::lang::Class *, ::javax::imageio::spi::ServiceRegistry$Filter *, ::java::lang::Object *); +public: + static ::java::io::File * getCacheDirectory(); + static ::java::util::Iterator * getImageReadersByFormatName(::java::lang::String *); + static ::java::util::Iterator * getImageReadersByMIMEType(::java::lang::String *); + static ::java::util::Iterator * getImageReadersBySuffix(::java::lang::String *); + static ::java::util::Iterator * getImageWritersByFormatName(::java::lang::String *); + static ::java::util::Iterator * getImageWritersByMIMEType(::java::lang::String *); + static ::java::util::Iterator * getImageWritersBySuffix(::java::lang::String *); + static JArray< ::java::lang::String * > * getReaderFormatNames(); + static JArray< ::java::lang::String * > * getReaderMIMETypes(); +private: + static ::javax::imageio::spi::IIORegistry * getRegistry(); +public: + static jboolean getUseCache(); + static JArray< ::java::lang::String * > * getWriterFormatNames(); + static JArray< ::java::lang::String * > * getWriterMIMETypes(); + static void scanForPlugins(); + static void setCacheDirectory(::java::io::File *); + static void setUseCache(jboolean); + static jboolean write(::java::awt::image::RenderedImage *, ::java::lang::String *, ::java::io::File *); + static jboolean write(::java::awt::image::RenderedImage *, ::java::lang::String *, ::java::io::OutputStream *); + static jboolean write(::java::awt::image::RenderedImage *, ::java::lang::String *, ::javax::imageio::stream::ImageOutputStream *); + static ::java::awt::image::BufferedImage * read(::javax::imageio::stream::ImageInputStream *); + static ::java::awt::image::BufferedImage * read(::java::net::URL *); + static ::java::awt::image::BufferedImage * read(::java::io::InputStream *); + static ::java::awt::image::BufferedImage * read(::java::io::File *); + static ::javax::imageio::stream::ImageInputStream * createImageInputStream(::java::lang::Object *); + static ::javax::imageio::stream::ImageOutputStream * createImageOutputStream(::java::lang::Object *); + static ::javax::imageio::ImageReader * getImageReader(::javax::imageio::ImageWriter *); + static ::java::util::Iterator * getImageReaders(::java::lang::Object *); + static ::java::util::Iterator * getImageWriters(::javax::imageio::ImageTypeSpecifier *, ::java::lang::String *); + static ::javax::imageio::ImageWriter * getImageWriter(::javax::imageio::ImageReader *); + static ::java::util::Iterator * getImageTranscoders(::javax::imageio::ImageReader *, ::javax::imageio::ImageWriter *); +private: + static ::java::io::File * cacheDirectory; + static jboolean useCache; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_ImageIO__ diff --git a/libjava/javax/imageio/ImageReadParam.h b/libjava/javax/imageio/ImageReadParam.h new file mode 100644 index 000000000..1e406ce70 --- /dev/null +++ b/libjava/javax/imageio/ImageReadParam.h @@ -0,0 +1,61 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_ImageReadParam__ +#define __javax_imageio_ImageReadParam__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace java + { + namespace awt + { + class Dimension; + namespace image + { + class BufferedImage; + } + } + } + namespace javax + { + namespace imageio + { + class ImageReadParam; + } + } +} + +class javax::imageio::ImageReadParam : public ::javax::imageio::IIOParam +{ + +public: + ImageReadParam(); + virtual jboolean canSetSourceRenderSize(); + virtual ::java::awt::image::BufferedImage * getDestination(); + virtual JArray< jint > * getDestinationBands(); + virtual jint getSourceMaxProgressivePass(); + virtual jint getSourceMinProgressivePass(); + virtual jint getSourceNumProgressivePasses(); + virtual ::java::awt::Dimension * getSourceRenderSize(); + virtual void setDestination(::java::awt::image::BufferedImage *); + virtual void setDestinationBands(JArray< jint > *); + virtual void setSourceProgressivePasses(jint, jint); + virtual void setSourceRenderSize(::java::awt::Dimension *); +public: // actually protected + jboolean __attribute__((aligned(__alignof__( ::javax::imageio::IIOParam)))) canSetSourceRenderSize__; + ::java::awt::image::BufferedImage * destination; + JArray< jint > * destinationBands; + jint minProgressivePass; + jint numProgressivePasses; + ::java::awt::Dimension * sourceRenderSize; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_ImageReadParam__ diff --git a/libjava/javax/imageio/ImageReader.h b/libjava/javax/imageio/ImageReader.h new file mode 100644 index 000000000..83c507598 --- /dev/null +++ b/libjava/javax/imageio/ImageReader.h @@ -0,0 +1,166 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_ImageReader__ +#define __javax_imageio_ImageReader__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace java + { + namespace awt + { + class Rectangle; + namespace image + { + class BufferedImage; + class Raster; + class RenderedImage; + } + } + } + namespace javax + { + namespace imageio + { + class IIOImage; + class ImageReadParam; + class ImageReader; + class ImageTypeSpecifier; + namespace event + { + class IIOReadProgressListener; + class IIOReadUpdateListener; + class IIOReadWarningListener; + } + namespace metadata + { + class IIOMetadata; + } + namespace spi + { + class ImageReaderSpi; + } + } + } +} + +class javax::imageio::ImageReader : public ::java::lang::Object +{ + +public: // actually protected + ImageReader(::javax::imageio::spi::ImageReaderSpi *); +public: + virtual void abort(); +public: // actually protected + virtual jboolean abortRequested(); +public: + virtual void addIIOReadProgressListener(::javax::imageio::event::IIOReadProgressListener *); + virtual void addIIOReadUpdateListener(::javax::imageio::event::IIOReadUpdateListener *); + virtual void addIIOReadWarningListener(::javax::imageio::event::IIOReadWarningListener *); + virtual jboolean canReadRaster(); +public: // actually protected + virtual void clearAbortRequest(); +public: + virtual void dispose(); + virtual jfloat getAspectRatio(jint); + virtual JArray< ::java::util::Locale * > * getAvailableLocales(); + virtual ::javax::imageio::ImageReadParam * getDefaultReadParam(); + virtual ::java::lang::String * getFormatName(); + virtual jint getHeight(jint) = 0; + virtual ::javax::imageio::metadata::IIOMetadata * getImageMetadata(jint) = 0; + virtual ::java::util::Iterator * getImageTypes(jint) = 0; + virtual void setInput(::java::lang::Object *, jboolean, jboolean); + virtual void setInput(::java::lang::Object *, jboolean); + virtual void setInput(::java::lang::Object *); + virtual ::java::lang::Object * getInput(); + virtual ::java::util::Locale * getLocale(); + virtual jint getNumImages(jboolean) = 0; + virtual jint getNumThumbnails(jint); + virtual ::javax::imageio::spi::ImageReaderSpi * getOriginatingProvider(); + virtual ::javax::imageio::metadata::IIOMetadata * getStreamMetadata() = 0; + virtual jint getThumbnailHeight(jint, jint); + virtual jint getThumbnailWidth(jint, jint); + virtual jint getTileGridXOffset(jint); + virtual jint getTileGridYOffset(jint); + virtual jint getTileHeight(jint); + virtual jint getTileWidth(jint); + virtual jint getWidth(jint) = 0; + virtual jboolean hasThumbnails(jint); + virtual jboolean isIgnoringMetadata(); + virtual jboolean isImageTiled(jint); + virtual jboolean isRandomAccessEasy(jint); + virtual jboolean isSeekForwardOnly(); +public: // actually protected + virtual void processImageComplete(); + virtual void processImageProgress(jfloat); + virtual void processImageStarted(jint); + virtual void processImageUpdate(::java::awt::image::BufferedImage *, jint, jint, jint, jint, jint, jint, JArray< jint > *); + virtual void processPassComplete(::java::awt::image::BufferedImage *); + virtual void processPassStarted(::java::awt::image::BufferedImage *, jint, jint, jint, jint, jint, jint, jint, JArray< jint > *); + virtual void processReadAborted(); + virtual void processSequenceComplete(); + virtual void processSequenceStarted(jint); + virtual void processThumbnailComplete(); + virtual void processThumbnailPassComplete(::java::awt::image::BufferedImage *); + virtual void processThumbnailPassStarted(::java::awt::image::BufferedImage *, jint, jint, jint, jint, jint, jint, jint, JArray< jint > *); + virtual void processThumbnailProgress(jfloat); + virtual void processThumbnailStarted(jint, jint); + virtual void processThumbnailUpdate(::java::awt::image::BufferedImage *, jint, jint, jint, jint, jint, jint, JArray< jint > *); + virtual void processWarningOccurred(::java::lang::String *); + virtual void processWarningOccurred(::java::lang::String *, ::java::lang::String *); +public: + virtual ::java::awt::image::BufferedImage * read(jint, ::javax::imageio::ImageReadParam *) = 0; + virtual jboolean readerSupportsThumbnails(); + virtual ::java::awt::image::Raster * readRaster(jint, ::javax::imageio::ImageReadParam *); + virtual ::java::awt::image::BufferedImage * readThumbnail(jint, jint); + virtual void removeAllIIOReadProgressListeners(); + virtual void removeAllIIOReadUpdateListeners(); + virtual void removeAllIIOReadWarningListeners(); + virtual void removeIIOReadProgressListener(::javax::imageio::event::IIOReadProgressListener *); + virtual void removeIIOReadUpdateListener(::javax::imageio::event::IIOReadUpdateListener *); + virtual void removeIIOReadWarningListener(::javax::imageio::event::IIOReadWarningListener *); + virtual void setLocale(::java::util::Locale *); +public: // actually protected + static void checkReadParamBandSettings(::javax::imageio::ImageReadParam *, jint, jint); + static void computeRegions(::javax::imageio::ImageReadParam *, jint, jint, ::java::awt::image::BufferedImage *, ::java::awt::Rectangle *, ::java::awt::Rectangle *); + static ::java::awt::image::BufferedImage * getDestination(::javax::imageio::ImageReadParam *, ::java::util::Iterator *, jint, jint); +public: + virtual ::javax::imageio::metadata::IIOMetadata * getImageMetadata(jint, ::java::lang::String *, ::java::util::Set *); + virtual jint getMinIndex(); + virtual ::javax::imageio::ImageTypeSpecifier * getRawImageType(jint); +public: // actually protected + static ::java::awt::Rectangle * getSourceRegion(::javax::imageio::ImageReadParam *, jint, jint); +public: + virtual ::javax::imageio::metadata::IIOMetadata * getStreamMetadata(::java::lang::String *, ::java::util::Set *); + virtual ::java::awt::image::BufferedImage * read(jint); + virtual ::javax::imageio::IIOImage * readAll(jint, ::javax::imageio::ImageReadParam *); + virtual ::java::util::Iterator * readAll(::java::util::Iterator *); + virtual ::java::awt::image::RenderedImage * readAsRenderedImage(jint, ::javax::imageio::ImageReadParam *); + virtual ::java::awt::image::BufferedImage * readTile(jint, jint, jint); + virtual ::java::awt::image::Raster * readTileRaster(jint, jint, jint); + virtual void reset(); +private: + jboolean __attribute__((aligned(__alignof__( ::java::lang::Object)))) aborted; +public: // actually protected + JArray< ::java::util::Locale * > * availableLocales; + jboolean ignoreMetadata; + ::java::lang::Object * input; + ::java::util::Locale * locale; + jint minIndex; + ::javax::imageio::spi::ImageReaderSpi * originatingProvider; + ::java::util::List * progressListeners; + jboolean seekForwardOnly; + ::java::util::List * updateListeners; + ::java::util::List * warningListeners; + ::java::util::List * warningLocales; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_ImageReader__ diff --git a/libjava/javax/imageio/ImageTranscoder.h b/libjava/javax/imageio/ImageTranscoder.h new file mode 100644 index 000000000..b3661fdce --- /dev/null +++ b/libjava/javax/imageio/ImageTranscoder.h @@ -0,0 +1,36 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_ImageTranscoder__ +#define __javax_imageio_ImageTranscoder__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + class ImageTranscoder; + class ImageTypeSpecifier; + class ImageWriteParam; + namespace metadata + { + class IIOMetadata; + } + } + } +} + +class javax::imageio::ImageTranscoder : public ::java::lang::Object +{ + +public: + virtual ::javax::imageio::metadata::IIOMetadata * convertImageMetadata(::javax::imageio::metadata::IIOMetadata *, ::javax::imageio::ImageTypeSpecifier *, ::javax::imageio::ImageWriteParam *) = 0; + virtual ::javax::imageio::metadata::IIOMetadata * convertStreamMetadata(::javax::imageio::metadata::IIOMetadata *, ::javax::imageio::ImageWriteParam *) = 0; + static ::java::lang::Class class$; +} __attribute__ ((java_interface)); + +#endif // __javax_imageio_ImageTranscoder__ diff --git a/libjava/javax/imageio/ImageTypeSpecifier.h b/libjava/javax/imageio/ImageTypeSpecifier.h new file mode 100644 index 000000000..c8a33638b --- /dev/null +++ b/libjava/javax/imageio/ImageTypeSpecifier.h @@ -0,0 +1,69 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_ImageTypeSpecifier__ +#define __javax_imageio_ImageTypeSpecifier__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace java + { + namespace awt + { + namespace color + { + class ColorSpace; + } + namespace image + { + class BufferedImage; + class ColorModel; + class RenderedImage; + class SampleModel; + } + } + } + namespace javax + { + namespace imageio + { + class ImageTypeSpecifier; + } + } +} + +class javax::imageio::ImageTypeSpecifier : public ::java::lang::Object +{ + +public: + ImageTypeSpecifier(::java::awt::image::ColorModel *, ::java::awt::image::SampleModel *); + ImageTypeSpecifier(::java::awt::image::RenderedImage *); + static ::javax::imageio::ImageTypeSpecifier * createBanded(::java::awt::color::ColorSpace *, JArray< jint > *, JArray< jint > *, jint, jboolean, jboolean); + virtual ::java::awt::image::BufferedImage * createBufferedImage(jint, jint); + static ::javax::imageio::ImageTypeSpecifier * createFromBufferedImageType(jint); + static ::javax::imageio::ImageTypeSpecifier * createFromRenderedImage(::java::awt::image::RenderedImage *); + static ::javax::imageio::ImageTypeSpecifier * createGrayscale(jint, jint, jboolean); + static ::javax::imageio::ImageTypeSpecifier * createGrayscale(jint, jint, jboolean, jboolean); + static ::javax::imageio::ImageTypeSpecifier * createIndexed(JArray< jbyte > *, JArray< jbyte > *, JArray< jbyte > *, JArray< jbyte > *, jint, jint); + static ::javax::imageio::ImageTypeSpecifier * createInterleaved(::java::awt::color::ColorSpace *, JArray< jint > *, jint, jboolean, jboolean); + static ::javax::imageio::ImageTypeSpecifier * createPacked(::java::awt::color::ColorSpace *, jint, jint, jint, jint, jint, jboolean); + virtual jint getBitsPerBand(jint); + virtual jint getBufferedImageType(); + virtual ::java::awt::image::SampleModel * getSampleModel(jint, jint); + virtual ::java::awt::image::ColorModel * getColorModel(); + virtual jint getNumBands(); + virtual jint getNumComponents(); + virtual ::java::awt::image::SampleModel * getSampleModel(); +public: // actually protected + ::java::awt::image::ColorModel * __attribute__((aligned(__alignof__( ::java::lang::Object)))) colorModel; + ::java::awt::image::SampleModel * sampleModel; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_ImageTypeSpecifier__ diff --git a/libjava/javax/imageio/ImageWriteParam.h b/libjava/javax/imageio/ImageWriteParam.h new file mode 100644 index 000000000..100a3e5f9 --- /dev/null +++ b/libjava/javax/imageio/ImageWriteParam.h @@ -0,0 +1,102 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_ImageWriteParam__ +#define __javax_imageio_ImageWriteParam__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace java + { + namespace awt + { + class Dimension; + } + } + namespace javax + { + namespace imageio + { + class ImageWriteParam; + } + } +} + +class javax::imageio::ImageWriteParam : public ::javax::imageio::IIOParam +{ + +public: // actually protected + ImageWriteParam(); +public: + ImageWriteParam(::java::util::Locale *); + virtual jfloat getBitRate(jfloat); +private: + void checkSupportsCompression(); + void checkNotExplicitCompression(); + void checkCompressionTypesSet(); + void checkSupportsProgressiveEncoding(); + void checkSupportsTiling(); + void checkNotExplicitTiling(); + void checkTilingInitialized(); + void checkMode(jint); +public: + virtual jboolean canOffsetTiles(); + virtual jboolean canWriteCompressed(); + virtual jboolean canWriteProgressive(); + virtual jboolean canWriteTiles(); + virtual jint getCompressionMode(); + virtual jfloat getCompressionQuality(); + virtual JArray< ::java::lang::String * > * getCompressionQualityDescriptions(); + virtual JArray< jfloat > * getCompressionQualityValues(); + virtual ::java::lang::String * getCompressionType(); + virtual JArray< ::java::lang::String * > * getCompressionTypes(); + virtual ::java::util::Locale * getLocale(); + virtual ::java::lang::String * getLocalizedCompressionTypeName(); + virtual JArray< ::java::awt::Dimension * > * getPreferredTileSizes(); + virtual jint getProgressiveMode(); + virtual jint getTileGridXOffset(); + virtual jint getTileGridYOffset(); + virtual jint getTileHeight(); + virtual jint getTileWidth(); + virtual jint getTilingMode(); + virtual jboolean isCompressionLossless(); + virtual void setCompressionMode(jint); + virtual void setCompressionQuality(jfloat); + virtual void setCompressionType(::java::lang::String *); + virtual void setProgressiveMode(jint); + virtual void setTiling(jint, jint, jint, jint); + virtual void setTilingMode(jint); + virtual void unsetCompression(); + virtual void unsetTiling(); + static const jint MODE_DISABLED = 0; + static const jint MODE_DEFAULT = 1; + static const jint MODE_EXPLICIT = 2; + static const jint MODE_COPY_FROM_METADATA = 3; +public: // actually protected + jboolean __attribute__((aligned(__alignof__( ::javax::imageio::IIOParam)))) canOffsetTiles__; + jboolean canWriteCompressed__; + jboolean canWriteProgressive__; + jboolean canWriteTiles__; + jint compressionMode; + jfloat compressionQuality; + ::java::lang::String * compressionType; + JArray< ::java::lang::String * > * compressionTypes; + ::java::util::Locale * locale; + JArray< ::java::awt::Dimension * > * preferredTileSizes; + jint progressiveMode; + jint tileGridXOffset; + jint tileGridYOffset; + jint tileHeight; + jint tileWidth; + jint tilingMode; + jboolean tilingSet; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_ImageWriteParam__ diff --git a/libjava/javax/imageio/ImageWriter.h b/libjava/javax/imageio/ImageWriter.h new file mode 100644 index 000000000..db14cbdde --- /dev/null +++ b/libjava/javax/imageio/ImageWriter.h @@ -0,0 +1,140 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_ImageWriter__ +#define __javax_imageio_ImageWriter__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace java + { + namespace awt + { + class Dimension; + class Rectangle; + namespace image + { + class Raster; + class RenderedImage; + } + } + } + namespace javax + { + namespace imageio + { + class IIOImage; + class ImageTypeSpecifier; + class ImageWriteParam; + class ImageWriter; + namespace event + { + class IIOWriteProgressListener; + class IIOWriteWarningListener; + } + namespace metadata + { + class IIOMetadata; + } + namespace spi + { + class ImageWriterSpi; + } + } + } +} + +class javax::imageio::ImageWriter : public ::java::lang::Object +{ + +public: // actually protected + ImageWriter(::javax::imageio::spi::ImageWriterSpi *); +private: + void checkOutputSet(); +public: + virtual void abort(); +public: // actually protected + virtual jboolean abortRequested(); +public: + virtual void addIIOWriteProgressListener(::javax::imageio::event::IIOWriteProgressListener *); + virtual void addIIOWriteWarningListener(::javax::imageio::event::IIOWriteWarningListener *); + virtual jboolean canInsertEmpty(jint); + virtual jboolean canInsertImage(jint); + virtual jboolean canRemoveImage(jint); + virtual jboolean canReplaceImageMetadata(jint); + virtual jboolean canReplacePixels(jint); + virtual jboolean canReplaceStreamMetadata(); + virtual jboolean canWriteEmpty(); + virtual jboolean canWriteRasters(); + virtual jboolean canWriteSequence(); +public: // actually protected + virtual void clearAbortRequest(); +public: + virtual ::javax::imageio::metadata::IIOMetadata * convertImageMetadata(::javax::imageio::metadata::IIOMetadata *, ::javax::imageio::ImageTypeSpecifier *, ::javax::imageio::ImageWriteParam *) = 0; + virtual ::javax::imageio::metadata::IIOMetadata * convertStreamMetadata(::javax::imageio::metadata::IIOMetadata *, ::javax::imageio::ImageWriteParam *) = 0; + virtual void dispose(); + virtual JArray< ::java::util::Locale * > * getAvailableLocales(); + virtual ::javax::imageio::metadata::IIOMetadata * getDefaultImageMetadata(::javax::imageio::ImageTypeSpecifier *, ::javax::imageio::ImageWriteParam *) = 0; + virtual ::javax::imageio::metadata::IIOMetadata * getDefaultStreamMetadata(::javax::imageio::ImageWriteParam *) = 0; + virtual ::javax::imageio::ImageWriteParam * getDefaultWriteParam(); + virtual ::java::util::Locale * getLocale(); + virtual jint getNumThumbnailsSupported(::javax::imageio::ImageTypeSpecifier *, ::javax::imageio::ImageWriteParam *, ::javax::imageio::metadata::IIOMetadata *, ::javax::imageio::metadata::IIOMetadata *); + virtual ::javax::imageio::spi::ImageWriterSpi * getOriginatingProvider(); + virtual ::java::lang::Object * getOutput(); + virtual JArray< ::java::awt::Dimension * > * getPreferredThumbnailSizes(::javax::imageio::ImageTypeSpecifier *, ::javax::imageio::ImageWriteParam *, ::javax::imageio::metadata::IIOMetadata *, ::javax::imageio::metadata::IIOMetadata *); +public: // actually protected + virtual void processImageComplete(); + virtual void processImageProgress(jfloat); + virtual void processImageStarted(jint); + virtual void processThumbnailComplete(); + virtual void processThumbnailProgress(jfloat); + virtual void processThumbnailStarted(jint, jint); + virtual void processWarningOccurred(jint, ::java::lang::String *); + virtual void processWarningOccurred(jint, ::java::lang::String *, ::java::lang::String *); + virtual void processWriteAborted(); +public: + virtual void removeAllIIOWriteProgressListeners(); + virtual void removeAllIIOWriteWarningListeners(); + virtual void removeIIOWriteProgressListener(::javax::imageio::event::IIOWriteProgressListener *); + virtual void removeIIOWriteWarningListener(::javax::imageio::event::IIOWriteWarningListener *); + virtual void reset(); + virtual void setLocale(::java::util::Locale *); + virtual void setOutput(::java::lang::Object *); + virtual void write(::javax::imageio::metadata::IIOMetadata *, ::javax::imageio::IIOImage *, ::javax::imageio::ImageWriteParam *) = 0; + virtual void endInsertEmpty(); + virtual void endReplacePixels(); + virtual void endWriteEmpty(); + virtual void endWriteSequence(); + virtual void prepareInsertEmpty(jint, ::javax::imageio::ImageTypeSpecifier *, jint, jint, ::javax::imageio::metadata::IIOMetadata *, ::java::util::List *, ::javax::imageio::ImageWriteParam *); + virtual void prepareReplacePixels(jint, ::java::awt::Rectangle *); + virtual void prepareWriteEmpty(::javax::imageio::metadata::IIOMetadata *, ::javax::imageio::ImageTypeSpecifier *, jint, jint, ::javax::imageio::metadata::IIOMetadata *, ::java::util::List *, ::javax::imageio::ImageWriteParam *); + virtual void prepareWriteSequence(::javax::imageio::metadata::IIOMetadata *); + virtual void removeImage(jint); + virtual void replaceImageMetadata(jint, ::javax::imageio::metadata::IIOMetadata *); + virtual void replacePixels(::java::awt::image::RenderedImage *, ::javax::imageio::ImageWriteParam *); + virtual void replacePixels(::java::awt::image::Raster *, ::javax::imageio::ImageWriteParam *); + virtual void replaceStreamMetadata(::javax::imageio::metadata::IIOMetadata *); + virtual void write(::java::awt::image::RenderedImage *); + virtual void write(::javax::imageio::IIOImage *); + virtual void writeInsert(jint, ::javax::imageio::IIOImage *, ::javax::imageio::ImageWriteParam *); + virtual void writeToSequence(::javax::imageio::IIOImage *, ::javax::imageio::ImageWriteParam *); +private: + jboolean __attribute__((aligned(__alignof__( ::java::lang::Object)))) aborted; +public: // actually protected + JArray< ::java::util::Locale * > * availableLocales; + ::java::util::Locale * locale; + ::javax::imageio::spi::ImageWriterSpi * originatingProvider; + ::java::lang::Object * output; + ::java::util::List * progressListeners; + ::java::util::List * warningListeners; + ::java::util::List * warningLocales; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_ImageWriter__ diff --git a/libjava/javax/imageio/event/IIOReadProgressListener.h b/libjava/javax/imageio/event/IIOReadProgressListener.h new file mode 100644 index 000000000..3bad67116 --- /dev/null +++ b/libjava/javax/imageio/event/IIOReadProgressListener.h @@ -0,0 +1,41 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_event_IIOReadProgressListener__ +#define __javax_imageio_event_IIOReadProgressListener__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + class ImageReader; + namespace event + { + class IIOReadProgressListener; + } + } + } +} + +class javax::imageio::event::IIOReadProgressListener : public ::java::lang::Object +{ + +public: + virtual void imageComplete(::javax::imageio::ImageReader *) = 0; + virtual void imageProgress(::javax::imageio::ImageReader *, jfloat) = 0; + virtual void imageStarted(::javax::imageio::ImageReader *, jint) = 0; + virtual void readAborted(::javax::imageio::ImageReader *) = 0; + virtual void sequenceComplete(::javax::imageio::ImageReader *) = 0; + virtual void sequenceStarted(::javax::imageio::ImageReader *, jint) = 0; + virtual void thumbnailComplete(::javax::imageio::ImageReader *) = 0; + virtual void thumbnailProgress(::javax::imageio::ImageReader *, jfloat) = 0; + virtual void thumbnailStarted(::javax::imageio::ImageReader *, jint, jint) = 0; + static ::java::lang::Class class$; +} __attribute__ ((java_interface)); + +#endif // __javax_imageio_event_IIOReadProgressListener__ diff --git a/libjava/javax/imageio/event/IIOReadUpdateListener.h b/libjava/javax/imageio/event/IIOReadUpdateListener.h new file mode 100644 index 000000000..86c28ec70 --- /dev/null +++ b/libjava/javax/imageio/event/IIOReadUpdateListener.h @@ -0,0 +1,50 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_event_IIOReadUpdateListener__ +#define __javax_imageio_event_IIOReadUpdateListener__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace java + { + namespace awt + { + namespace image + { + class BufferedImage; + } + } + } + namespace javax + { + namespace imageio + { + class ImageReader; + namespace event + { + class IIOReadUpdateListener; + } + } + } +} + +class javax::imageio::event::IIOReadUpdateListener : public ::java::lang::Object +{ + +public: + virtual void imageUpdate(::javax::imageio::ImageReader *, ::java::awt::image::BufferedImage *, jint, jint, jint, jint, jint, jint, JArray< jint > *) = 0; + virtual void passComplete(::javax::imageio::ImageReader *, ::java::awt::image::BufferedImage *) = 0; + virtual void passStarted(::javax::imageio::ImageReader *, ::java::awt::image::BufferedImage *, jint, jint, jint, jint, jint, jint, jint, JArray< jint > *) = 0; + virtual void thumbnailPassComplete(::javax::imageio::ImageReader *, ::java::awt::image::BufferedImage *) = 0; + virtual void thumbnailPassStarted(::javax::imageio::ImageReader *, ::java::awt::image::BufferedImage *, jint, jint, jint, jint, jint, jint, jint, JArray< jint > *) = 0; + virtual void thumbnailUpdate(::javax::imageio::ImageReader *, ::java::awt::image::BufferedImage *, jint, jint, jint, jint, jint, jint, JArray< jint > *) = 0; + static ::java::lang::Class class$; +} __attribute__ ((java_interface)); + +#endif // __javax_imageio_event_IIOReadUpdateListener__ diff --git a/libjava/javax/imageio/event/IIOReadWarningListener.h b/libjava/javax/imageio/event/IIOReadWarningListener.h new file mode 100644 index 000000000..c74cf41d7 --- /dev/null +++ b/libjava/javax/imageio/event/IIOReadWarningListener.h @@ -0,0 +1,33 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_event_IIOReadWarningListener__ +#define __javax_imageio_event_IIOReadWarningListener__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + class ImageReader; + namespace event + { + class IIOReadWarningListener; + } + } + } +} + +class javax::imageio::event::IIOReadWarningListener : public ::java::lang::Object +{ + +public: + virtual void warningOccurred(::javax::imageio::ImageReader *, ::java::lang::String *) = 0; + static ::java::lang::Class class$; +} __attribute__ ((java_interface)); + +#endif // __javax_imageio_event_IIOReadWarningListener__ diff --git a/libjava/javax/imageio/event/IIOWriteProgressListener.h b/libjava/javax/imageio/event/IIOWriteProgressListener.h new file mode 100644 index 000000000..bb140af35 --- /dev/null +++ b/libjava/javax/imageio/event/IIOWriteProgressListener.h @@ -0,0 +1,39 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_event_IIOWriteProgressListener__ +#define __javax_imageio_event_IIOWriteProgressListener__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + class ImageWriter; + namespace event + { + class IIOWriteProgressListener; + } + } + } +} + +class javax::imageio::event::IIOWriteProgressListener : public ::java::lang::Object +{ + +public: + virtual void imageComplete(::javax::imageio::ImageWriter *) = 0; + virtual void imageProgress(::javax::imageio::ImageWriter *, jfloat) = 0; + virtual void imageStarted(::javax::imageio::ImageWriter *, jint) = 0; + virtual void thumbnailComplete(::javax::imageio::ImageWriter *) = 0; + virtual void thumbnailProgress(::javax::imageio::ImageWriter *, jfloat) = 0; + virtual void thumbnailStarted(::javax::imageio::ImageWriter *, jint, jint) = 0; + virtual void writeAborted(::javax::imageio::ImageWriter *) = 0; + static ::java::lang::Class class$; +} __attribute__ ((java_interface)); + +#endif // __javax_imageio_event_IIOWriteProgressListener__ diff --git a/libjava/javax/imageio/event/IIOWriteWarningListener.h b/libjava/javax/imageio/event/IIOWriteWarningListener.h new file mode 100644 index 000000000..220bf2321 --- /dev/null +++ b/libjava/javax/imageio/event/IIOWriteWarningListener.h @@ -0,0 +1,33 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_event_IIOWriteWarningListener__ +#define __javax_imageio_event_IIOWriteWarningListener__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + class ImageWriter; + namespace event + { + class IIOWriteWarningListener; + } + } + } +} + +class javax::imageio::event::IIOWriteWarningListener : public ::java::lang::Object +{ + +public: + virtual void warningOccurred(::javax::imageio::ImageWriter *, jint, ::java::lang::String *) = 0; + static ::java::lang::Class class$; +} __attribute__ ((java_interface)); + +#endif // __javax_imageio_event_IIOWriteWarningListener__ diff --git a/libjava/javax/imageio/metadata/IIOInvalidTreeException.h b/libjava/javax/imageio/metadata/IIOInvalidTreeException.h new file mode 100644 index 000000000..9980defda --- /dev/null +++ b/libjava/javax/imageio/metadata/IIOInvalidTreeException.h @@ -0,0 +1,49 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_metadata_IIOInvalidTreeException__ +#define __javax_imageio_metadata_IIOInvalidTreeException__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + namespace metadata + { + class IIOInvalidTreeException; + } + } + } + namespace org + { + namespace w3c + { + namespace dom + { + class Node; + } + } + } +} + +class javax::imageio::metadata::IIOInvalidTreeException : public ::javax::imageio::IIOException +{ + +public: + IIOInvalidTreeException(::java::lang::String *, ::org::w3c::dom::Node *); + IIOInvalidTreeException(::java::lang::String *, ::java::lang::Throwable *, ::org::w3c::dom::Node *); + virtual ::org::w3c::dom::Node * getOffendingNode(); +private: + static const jlong serialVersionUID = -1314083172544132777LL; +public: // actually protected + ::org::w3c::dom::Node * __attribute__((aligned(__alignof__( ::javax::imageio::IIOException)))) offendingNode; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_metadata_IIOInvalidTreeException__ diff --git a/libjava/javax/imageio/metadata/IIOMetadata.h b/libjava/javax/imageio/metadata/IIOMetadata.h new file mode 100644 index 000000000..33d5a6164 --- /dev/null +++ b/libjava/javax/imageio/metadata/IIOMetadata.h @@ -0,0 +1,87 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_metadata_IIOMetadata__ +#define __javax_imageio_metadata_IIOMetadata__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace javax + { + namespace imageio + { + namespace metadata + { + class IIOMetadata; + class IIOMetadataController; + class IIOMetadataFormat; + class IIOMetadataNode; + } + } + } + namespace org + { + namespace w3c + { + namespace dom + { + class Node; + } + } + } +} + +class javax::imageio::metadata::IIOMetadata : public ::java::lang::Object +{ + +public: // actually protected + IIOMetadata(); + IIOMetadata(jboolean, ::java::lang::String *, ::java::lang::String *, JArray< ::java::lang::String * > *, JArray< ::java::lang::String * > *); +public: + virtual jboolean activateController(); + virtual ::javax::imageio::metadata::IIOMetadataController * getController(); + virtual ::javax::imageio::metadata::IIOMetadataController * getDefaultController(); + virtual JArray< ::java::lang::String * > * getExtraMetadataFormatNames(); + virtual ::javax::imageio::metadata::IIOMetadataFormat * getMetadataFormat(::java::lang::String *); + virtual JArray< ::java::lang::String * > * getMetadataFormatNames(); + virtual ::java::lang::String * getNativeMetadataFormatName(); + virtual jboolean hasController(); + virtual jboolean isReadOnly() = 0; + virtual jboolean isStandardMetadataFormatSupported(); + virtual void reset() = 0; + virtual void setController(::javax::imageio::metadata::IIOMetadataController *); + virtual ::org::w3c::dom::Node * getAsTree(::java::lang::String *) = 0; +public: // actually protected + virtual ::javax::imageio::metadata::IIOMetadataNode * getStandardChromaNode(); + virtual ::javax::imageio::metadata::IIOMetadataNode * getStandardCompressionNode(); + virtual ::javax::imageio::metadata::IIOMetadataNode * getStandardDataNode(); + virtual ::javax::imageio::metadata::IIOMetadataNode * getStandardDimensionNode(); + virtual ::javax::imageio::metadata::IIOMetadataNode * getStandardDocumentNode(); + virtual ::javax::imageio::metadata::IIOMetadataNode * getStandardTextNode(); + virtual ::javax::imageio::metadata::IIOMetadataNode * getStandardTileNode(); + virtual ::javax::imageio::metadata::IIOMetadataNode * getStandardTransparencyNode(); +private: + void appendChild(::javax::imageio::metadata::IIOMetadataNode *, ::javax::imageio::metadata::IIOMetadataNode *); +public: // actually protected + virtual ::javax::imageio::metadata::IIOMetadataNode * getStandardTree(); +public: + virtual void mergeTree(::java::lang::String *, ::org::w3c::dom::Node *) = 0; + virtual void setFromTree(::java::lang::String *, ::org::w3c::dom::Node *); +public: // actually protected + ::javax::imageio::metadata::IIOMetadataController * __attribute__((aligned(__alignof__( ::java::lang::Object)))) controller; + ::javax::imageio::metadata::IIOMetadataController * defaultController; + JArray< ::java::lang::String * > * extraMetadataFormatClassNames; + JArray< ::java::lang::String * > * extraMetadataFormatNames; + ::java::lang::String * nativeMetadataFormatClassName; + ::java::lang::String * nativeMetadataFormatName; + jboolean standardFormatSupported; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_metadata_IIOMetadata__ diff --git a/libjava/javax/imageio/metadata/IIOMetadataController.h b/libjava/javax/imageio/metadata/IIOMetadataController.h new file mode 100644 index 000000000..e970191d6 --- /dev/null +++ b/libjava/javax/imageio/metadata/IIOMetadataController.h @@ -0,0 +1,33 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_metadata_IIOMetadataController__ +#define __javax_imageio_metadata_IIOMetadataController__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + namespace metadata + { + class IIOMetadata; + class IIOMetadataController; + } + } + } +} + +class javax::imageio::metadata::IIOMetadataController : public ::java::lang::Object +{ + +public: + virtual jboolean activate(::javax::imageio::metadata::IIOMetadata *) = 0; + static ::java::lang::Class class$; +} __attribute__ ((java_interface)); + +#endif // __javax_imageio_metadata_IIOMetadataController__ diff --git a/libjava/javax/imageio/metadata/IIOMetadataFormat.h b/libjava/javax/imageio/metadata/IIOMetadataFormat.h new file mode 100644 index 000000000..0744efbfc --- /dev/null +++ b/libjava/javax/imageio/metadata/IIOMetadataFormat.h @@ -0,0 +1,82 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_metadata_IIOMetadataFormat__ +#define __javax_imageio_metadata_IIOMetadataFormat__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace javax + { + namespace imageio + { + class ImageTypeSpecifier; + namespace metadata + { + class IIOMetadataFormat; + } + } + } +} + +class javax::imageio::metadata::IIOMetadataFormat : public ::java::lang::Object +{ + +public: + virtual jboolean canNodeAppear(::java::lang::String *, ::javax::imageio::ImageTypeSpecifier *) = 0; + virtual jint getAttributeDataType(::java::lang::String *, ::java::lang::String *) = 0; + virtual ::java::lang::String * getAttributeDefaultValue(::java::lang::String *, ::java::lang::String *) = 0; + virtual ::java::lang::String * getAttributeDescription(::java::lang::String *, ::java::lang::String *, ::java::util::Locale *) = 0; + virtual JArray< ::java::lang::String * > * getAttributeEnumerations(::java::lang::String *, ::java::lang::String *) = 0; + virtual jint getAttributeListMaxLength(::java::lang::String *, ::java::lang::String *) = 0; + virtual jint getAttributeListMinLength(::java::lang::String *, ::java::lang::String *) = 0; + virtual ::java::lang::String * getAttributeMaxValue(::java::lang::String *, ::java::lang::String *) = 0; + virtual ::java::lang::String * getAttributeMinValue(::java::lang::String *, ::java::lang::String *) = 0; + virtual JArray< ::java::lang::String * > * getAttributeNames(::java::lang::String *) = 0; + virtual jint getAttributeValueType(::java::lang::String *, ::java::lang::String *) = 0; + virtual JArray< ::java::lang::String * > * getChildNames(::java::lang::String *) = 0; + virtual jint getChildPolicy(::java::lang::String *) = 0; + virtual ::java::lang::String * getElementDescription(::java::lang::String *, ::java::util::Locale *) = 0; + virtual jint getElementMaxChildren(::java::lang::String *) = 0; + virtual jint getElementMinChildren(::java::lang::String *) = 0; + virtual jint getObjectArrayMaxLength(::java::lang::String *) = 0; + virtual jint getObjectArrayMinLength(::java::lang::String *) = 0; + virtual ::java::lang::Class * getObjectClass(::java::lang::String *) = 0; + virtual ::java::lang::Object * getObjectDefaultValue(::java::lang::String *) = 0; + virtual JArray< ::java::lang::Object * > * getObjectEnumerations(::java::lang::String *) = 0; + virtual ::java::lang::Comparable * getObjectMaxValue(::java::lang::String *) = 0; + virtual ::java::lang::Comparable * getObjectMinValue(::java::lang::String *) = 0; + virtual jint getObjectValueType(::java::lang::String *) = 0; + virtual ::java::lang::String * getRootName() = 0; + virtual jboolean isAttributeRequired(::java::lang::String *, ::java::lang::String *) = 0; + static const jint CHILD_POLICY_ALL = 1; + static const jint CHILD_POLICY_CHOICE = 3; + static const jint CHILD_POLICY_EMPTY = 0; + static const jint CHILD_POLICY_MAX = 5; + static const jint CHILD_POLICY_REPEAT = 5; + static const jint CHILD_POLICY_SEQUENCE = 4; + static const jint CHILD_POLICY_SOME = 2; + static const jint DATATYPE_BOOLEAN = 1; + static const jint DATATYPE_DOUBLE = 4; + static const jint DATATYPE_FLOAT = 3; + static const jint DATATYPE_INTEGER = 2; + static const jint DATATYPE_STRING = 0; + static const jint VALUE_ARBITRARY = 1; + static const jint VALUE_ENUMERATION = 16; + static const jint VALUE_LIST = 32; + static const jint VALUE_NONE = 0; + static const jint VALUE_RANGE = 2; + static const jint VALUE_RANGE_MAX_INCLUSIVE = 10; + static const jint VALUE_RANGE_MAX_INCLUSIVE_MASK = 8; + static const jint VALUE_RANGE_MIN_INCLUSIVE = 6; + static const jint VALUE_RANGE_MIN_INCLUSIVE_MASK = 4; + static const jint VALUE_RANGE_MIN_MAX_INCLUSIVE = 14; + static ::java::lang::Class class$; +} __attribute__ ((java_interface)); + +#endif // __javax_imageio_metadata_IIOMetadataFormat__ diff --git a/libjava/javax/imageio/metadata/IIOMetadataFormatImpl$1.h b/libjava/javax/imageio/metadata/IIOMetadataFormatImpl$1.h new file mode 100644 index 000000000..ade1fa0c7 --- /dev/null +++ b/libjava/javax/imageio/metadata/IIOMetadataFormatImpl$1.h @@ -0,0 +1,35 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_metadata_IIOMetadataFormatImpl$1__ +#define __javax_imageio_metadata_IIOMetadataFormatImpl$1__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + class ImageTypeSpecifier; + namespace metadata + { + class IIOMetadataFormatImpl$1; + } + } + } +} + +class javax::imageio::metadata::IIOMetadataFormatImpl$1 : public ::javax::imageio::metadata::IIOMetadataFormatImpl +{ + +public: // actually package-private + IIOMetadataFormatImpl$1(::java::lang::String *, jint); +public: + virtual jboolean canNodeAppear(::java::lang::String *, ::javax::imageio::ImageTypeSpecifier *); + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_metadata_IIOMetadataFormatImpl$1__ diff --git a/libjava/javax/imageio/metadata/IIOMetadataFormatImpl$IIOMetadataNodeAttr.h b/libjava/javax/imageio/metadata/IIOMetadataFormatImpl$IIOMetadataNodeAttr.h new file mode 100644 index 000000000..e1f5f93a4 --- /dev/null +++ b/libjava/javax/imageio/metadata/IIOMetadataFormatImpl$IIOMetadataNodeAttr.h @@ -0,0 +1,60 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_metadata_IIOMetadataFormatImpl$IIOMetadataNodeAttr__ +#define __javax_imageio_metadata_IIOMetadataFormatImpl$IIOMetadataNodeAttr__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + namespace metadata + { + class IIOMetadataFormatImpl$IIOMetadataNodeAttr; + } + } + } + namespace org + { + namespace w3c + { + namespace dom + { + class Element; + class TypeInfo; + } + } + } +} + +class javax::imageio::metadata::IIOMetadataFormatImpl$IIOMetadataNodeAttr : public ::javax::imageio::metadata::IIOMetadataNode +{ + +public: + IIOMetadataFormatImpl$IIOMetadataNodeAttr(::org::w3c::dom::Element *, ::java::lang::String *, ::java::lang::String *); + IIOMetadataFormatImpl$IIOMetadataNodeAttr(::org::w3c::dom::Element *, ::java::lang::String *, jint, jboolean, ::java::lang::String *); + virtual ::java::lang::String * getName(); + virtual ::org::w3c::dom::Element * getOwnerElement(); + virtual jint getDataType(); + virtual ::org::w3c::dom::TypeInfo * getSchemaTypeInfo(); + virtual jboolean getSpecified(); + virtual ::java::lang::String * getValue(); + virtual jboolean isId(); + virtual void setValue(::java::lang::String *); + virtual jboolean isRequired(); +public: // actually protected + ::org::w3c::dom::Element * __attribute__((aligned(__alignof__( ::javax::imageio::metadata::IIOMetadataNode)))) owner; + ::java::lang::String * name; + jint dataType; + jboolean required; + ::java::lang::String * defaultValue; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_metadata_IIOMetadataFormatImpl$IIOMetadataNodeAttr__ diff --git a/libjava/javax/imageio/metadata/IIOMetadataFormatImpl$IIOMetadataNodeAttrBounded.h b/libjava/javax/imageio/metadata/IIOMetadataFormatImpl$IIOMetadataNodeAttrBounded.h new file mode 100644 index 000000000..4a1a76e76 --- /dev/null +++ b/libjava/javax/imageio/metadata/IIOMetadataFormatImpl$IIOMetadataNodeAttrBounded.h @@ -0,0 +1,53 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_metadata_IIOMetadataFormatImpl$IIOMetadataNodeAttrBounded__ +#define __javax_imageio_metadata_IIOMetadataFormatImpl$IIOMetadataNodeAttrBounded__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + namespace metadata + { + class IIOMetadataFormatImpl; + class IIOMetadataFormatImpl$IIOMetadataNodeAttrBounded; + } + } + } + namespace org + { + namespace w3c + { + namespace dom + { + class Element; + } + } + } +} + +class javax::imageio::metadata::IIOMetadataFormatImpl$IIOMetadataNodeAttrBounded : public ::javax::imageio::metadata::IIOMetadataFormatImpl$IIOMetadataNodeAttr +{ + +public: + IIOMetadataFormatImpl$IIOMetadataNodeAttrBounded(::javax::imageio::metadata::IIOMetadataFormatImpl *, ::org::w3c::dom::Element *, ::java::lang::String *, jint, jboolean, ::java::lang::String *, ::java::lang::String *, ::java::lang::String *, jboolean, jboolean); + virtual ::java::lang::String * getMinValue(); + virtual ::java::lang::String * getMaxValue(); +public: // actually protected + ::java::lang::String * __attribute__((aligned(__alignof__( ::javax::imageio::metadata::IIOMetadataFormatImpl$IIOMetadataNodeAttr)))) minValue; + ::java::lang::String * maxValue; + jboolean minInclusive; + jboolean maxInclusive; +public: // actually package-private + ::javax::imageio::metadata::IIOMetadataFormatImpl * this$0; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_metadata_IIOMetadataFormatImpl$IIOMetadataNodeAttrBounded__ diff --git a/libjava/javax/imageio/metadata/IIOMetadataFormatImpl$IIOMetadataNodeAttrEnumerated.h b/libjava/javax/imageio/metadata/IIOMetadataFormatImpl$IIOMetadataNodeAttrEnumerated.h new file mode 100644 index 000000000..a81c56289 --- /dev/null +++ b/libjava/javax/imageio/metadata/IIOMetadataFormatImpl$IIOMetadataNodeAttrEnumerated.h @@ -0,0 +1,51 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_metadata_IIOMetadataFormatImpl$IIOMetadataNodeAttrEnumerated__ +#define __javax_imageio_metadata_IIOMetadataFormatImpl$IIOMetadataNodeAttrEnumerated__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace javax + { + namespace imageio + { + namespace metadata + { + class IIOMetadataFormatImpl; + class IIOMetadataFormatImpl$IIOMetadataNodeAttrEnumerated; + } + } + } + namespace org + { + namespace w3c + { + namespace dom + { + class Element; + } + } + } +} + +class javax::imageio::metadata::IIOMetadataFormatImpl$IIOMetadataNodeAttrEnumerated : public ::javax::imageio::metadata::IIOMetadataFormatImpl$IIOMetadataNodeAttr +{ + +public: + IIOMetadataFormatImpl$IIOMetadataNodeAttrEnumerated(::javax::imageio::metadata::IIOMetadataFormatImpl *, ::org::w3c::dom::Element *, ::java::lang::String *, jint, jboolean, ::java::lang::String *, ::java::util::List *); + virtual JArray< ::java::lang::Object * > * getEnumerations(); +public: // actually protected + ::java::util::List * __attribute__((aligned(__alignof__( ::javax::imageio::metadata::IIOMetadataFormatImpl$IIOMetadataNodeAttr)))) enumeratedValues; +public: // actually package-private + ::javax::imageio::metadata::IIOMetadataFormatImpl * this$0; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_metadata_IIOMetadataFormatImpl$IIOMetadataNodeAttrEnumerated__ diff --git a/libjava/javax/imageio/metadata/IIOMetadataFormatImpl$IIOMetadataNodeAttrList.h b/libjava/javax/imageio/metadata/IIOMetadataFormatImpl$IIOMetadataNodeAttrList.h new file mode 100644 index 000000000..fd5b373cb --- /dev/null +++ b/libjava/javax/imageio/metadata/IIOMetadataFormatImpl$IIOMetadataNodeAttrList.h @@ -0,0 +1,51 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_metadata_IIOMetadataFormatImpl$IIOMetadataNodeAttrList__ +#define __javax_imageio_metadata_IIOMetadataFormatImpl$IIOMetadataNodeAttrList__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + namespace metadata + { + class IIOMetadataFormatImpl; + class IIOMetadataFormatImpl$IIOMetadataNodeAttrList; + } + } + } + namespace org + { + namespace w3c + { + namespace dom + { + class Element; + } + } + } +} + +class javax::imageio::metadata::IIOMetadataFormatImpl$IIOMetadataNodeAttrList : public ::javax::imageio::metadata::IIOMetadataFormatImpl$IIOMetadataNodeAttr +{ + +public: + IIOMetadataFormatImpl$IIOMetadataNodeAttrList(::javax::imageio::metadata::IIOMetadataFormatImpl *, ::org::w3c::dom::Element *, ::java::lang::String *, jint, jboolean, jint, jint); + virtual jint getListMinLength(); + virtual jint getListMaxLength(); +public: // actually protected + jint __attribute__((aligned(__alignof__( ::javax::imageio::metadata::IIOMetadataFormatImpl$IIOMetadataNodeAttr)))) listMinLength; + jint listMaxLength; +public: // actually package-private + ::javax::imageio::metadata::IIOMetadataFormatImpl * this$0; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_metadata_IIOMetadataFormatImpl$IIOMetadataNodeAttrList__ diff --git a/libjava/javax/imageio/metadata/IIOMetadataFormatImpl$NodeObject.h b/libjava/javax/imageio/metadata/IIOMetadataFormatImpl$NodeObject.h new file mode 100644 index 000000000..fabfef491 --- /dev/null +++ b/libjava/javax/imageio/metadata/IIOMetadataFormatImpl$NodeObject.h @@ -0,0 +1,57 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_metadata_IIOMetadataFormatImpl$NodeObject__ +#define __javax_imageio_metadata_IIOMetadataFormatImpl$NodeObject__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + namespace metadata + { + class IIOMetadataFormatImpl; + class IIOMetadataFormatImpl$NodeObject; + } + } + } + namespace org + { + namespace w3c + { + namespace dom + { + class Element; + } + } + } +} + +class javax::imageio::metadata::IIOMetadataFormatImpl$NodeObject : public ::java::lang::Object +{ + +public: + IIOMetadataFormatImpl$NodeObject(::javax::imageio::metadata::IIOMetadataFormatImpl *, ::org::w3c::dom::Element *, ::java::lang::Class *, jboolean, ::java::lang::Object *); + virtual jint getValueType(); + virtual ::java::lang::Class * getClassType(); + virtual ::org::w3c::dom::Element * getOwnerElement(); + virtual ::java::lang::Object * getDefaultValue(); + virtual jboolean isRequired(); +public: // actually protected + ::org::w3c::dom::Element * __attribute__((aligned(__alignof__( ::java::lang::Object)))) owner; + ::java::lang::Class * classType; + jboolean required; + ::java::lang::Object * defaultValue; + jint valueType; +public: // actually package-private + ::javax::imageio::metadata::IIOMetadataFormatImpl * this$0; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_metadata_IIOMetadataFormatImpl$NodeObject__ diff --git a/libjava/javax/imageio/metadata/IIOMetadataFormatImpl$NodeObjectArray.h b/libjava/javax/imageio/metadata/IIOMetadataFormatImpl$NodeObjectArray.h new file mode 100644 index 000000000..4e9b819ed --- /dev/null +++ b/libjava/javax/imageio/metadata/IIOMetadataFormatImpl$NodeObjectArray.h @@ -0,0 +1,51 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_metadata_IIOMetadataFormatImpl$NodeObjectArray__ +#define __javax_imageio_metadata_IIOMetadataFormatImpl$NodeObjectArray__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + namespace metadata + { + class IIOMetadataFormatImpl; + class IIOMetadataFormatImpl$NodeObjectArray; + } + } + } + namespace org + { + namespace w3c + { + namespace dom + { + class Element; + } + } + } +} + +class javax::imageio::metadata::IIOMetadataFormatImpl$NodeObjectArray : public ::javax::imageio::metadata::IIOMetadataFormatImpl$NodeObject +{ + +public: + IIOMetadataFormatImpl$NodeObjectArray(::javax::imageio::metadata::IIOMetadataFormatImpl *, ::org::w3c::dom::Element *, ::java::lang::Class *, jint, jint); + virtual ::java::lang::Comparable * getArrayMinLength(); + virtual ::java::lang::Comparable * getArrayMaxLength(); +public: // actually protected + ::java::lang::Integer * __attribute__((aligned(__alignof__( ::javax::imageio::metadata::IIOMetadataFormatImpl$NodeObject)))) arrayMinLength; + ::java::lang::Integer * arrayMaxLength; +public: // actually package-private + ::javax::imageio::metadata::IIOMetadataFormatImpl * this$0; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_metadata_IIOMetadataFormatImpl$NodeObjectArray__ diff --git a/libjava/javax/imageio/metadata/IIOMetadataFormatImpl$NodeObjectBounded.h b/libjava/javax/imageio/metadata/IIOMetadataFormatImpl$NodeObjectBounded.h new file mode 100644 index 000000000..1605d23de --- /dev/null +++ b/libjava/javax/imageio/metadata/IIOMetadataFormatImpl$NodeObjectBounded.h @@ -0,0 +1,53 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_metadata_IIOMetadataFormatImpl$NodeObjectBounded__ +#define __javax_imageio_metadata_IIOMetadataFormatImpl$NodeObjectBounded__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + namespace metadata + { + class IIOMetadataFormatImpl; + class IIOMetadataFormatImpl$NodeObjectBounded; + } + } + } + namespace org + { + namespace w3c + { + namespace dom + { + class Element; + } + } + } +} + +class javax::imageio::metadata::IIOMetadataFormatImpl$NodeObjectBounded : public ::javax::imageio::metadata::IIOMetadataFormatImpl$NodeObject +{ + +public: + IIOMetadataFormatImpl$NodeObjectBounded(::javax::imageio::metadata::IIOMetadataFormatImpl *, ::org::w3c::dom::Element *, ::java::lang::Class *, ::java::lang::Object *, ::java::lang::Comparable *, ::java::lang::Comparable *, jboolean, jboolean); + virtual ::java::lang::Comparable * getMinValue(); + virtual ::java::lang::Comparable * getMaxValue(); +public: // actually protected + ::java::lang::Comparable * __attribute__((aligned(__alignof__( ::javax::imageio::metadata::IIOMetadataFormatImpl$NodeObject)))) minValue; + ::java::lang::Comparable * maxValue; + jboolean minInclusive; + jboolean maxInclusive; +public: // actually package-private + ::javax::imageio::metadata::IIOMetadataFormatImpl * this$0; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_metadata_IIOMetadataFormatImpl$NodeObjectBounded__ diff --git a/libjava/javax/imageio/metadata/IIOMetadataFormatImpl$NodeObjectEnumerated.h b/libjava/javax/imageio/metadata/IIOMetadataFormatImpl$NodeObjectEnumerated.h new file mode 100644 index 000000000..0dabd83e2 --- /dev/null +++ b/libjava/javax/imageio/metadata/IIOMetadataFormatImpl$NodeObjectEnumerated.h @@ -0,0 +1,51 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_metadata_IIOMetadataFormatImpl$NodeObjectEnumerated__ +#define __javax_imageio_metadata_IIOMetadataFormatImpl$NodeObjectEnumerated__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace javax + { + namespace imageio + { + namespace metadata + { + class IIOMetadataFormatImpl; + class IIOMetadataFormatImpl$NodeObjectEnumerated; + } + } + } + namespace org + { + namespace w3c + { + namespace dom + { + class Element; + } + } + } +} + +class javax::imageio::metadata::IIOMetadataFormatImpl$NodeObjectEnumerated : public ::javax::imageio::metadata::IIOMetadataFormatImpl$NodeObject +{ + +public: + IIOMetadataFormatImpl$NodeObjectEnumerated(::javax::imageio::metadata::IIOMetadataFormatImpl *, ::org::w3c::dom::Element *, ::java::lang::Class *, jboolean, ::java::lang::Object *, ::java::util::List *); + virtual JArray< ::java::lang::Object * > * getEnumerations(); +public: // actually protected + ::java::util::List * __attribute__((aligned(__alignof__( ::javax::imageio::metadata::IIOMetadataFormatImpl$NodeObject)))) enumeratedValues; +public: // actually package-private + ::javax::imageio::metadata::IIOMetadataFormatImpl * this$0; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_metadata_IIOMetadataFormatImpl$NodeObjectEnumerated__ diff --git a/libjava/javax/imageio/metadata/IIOMetadataFormatImpl.h b/libjava/javax/imageio/metadata/IIOMetadataFormatImpl.h new file mode 100644 index 000000000..b47defa84 --- /dev/null +++ b/libjava/javax/imageio/metadata/IIOMetadataFormatImpl.h @@ -0,0 +1,105 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_metadata_IIOMetadataFormatImpl__ +#define __javax_imageio_metadata_IIOMetadataFormatImpl__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace javax + { + namespace imageio + { + class ImageTypeSpecifier; + namespace metadata + { + class IIOMetadataFormat; + class IIOMetadataFormatImpl; + class IIOMetadataFormatImpl$NodeObject; + class IIOMetadataNode; + } + } + } +} + +class javax::imageio::metadata::IIOMetadataFormatImpl : public ::java::lang::Object +{ + +public: + IIOMetadataFormatImpl(::java::lang::String *, jint); + IIOMetadataFormatImpl(::java::lang::String *, jint, jint); +public: // actually protected + virtual void addAttribute(::java::lang::String *, ::java::lang::String *, jint, jboolean, ::java::lang::String *); + virtual void addAttribute(::java::lang::String *, ::java::lang::String *, jint, jboolean, ::java::lang::String *, ::java::util::List *); + virtual void addAttribute(::java::lang::String *, ::java::lang::String *, jint, jboolean, ::java::lang::String *, ::java::lang::String *, ::java::lang::String *, jboolean, jboolean); + virtual void addAttribute(::java::lang::String *, ::java::lang::String *, jint, jboolean, jint, jint); + virtual void addBooleanAttribute(::java::lang::String *, ::java::lang::String *, jboolean, jboolean); + virtual void addChildElement(::java::lang::String *, ::java::lang::String *); + virtual void addElement(::java::lang::String *, ::java::lang::String *, jint); + virtual void addElement(::java::lang::String *, ::java::lang::String *, jint, jint); +private: + void addNodeObject(::javax::imageio::metadata::IIOMetadataNode *, ::javax::imageio::metadata::IIOMetadataFormatImpl$NodeObject *); + ::javax::imageio::metadata::IIOMetadataFormatImpl$NodeObject * getNodeObject(::javax::imageio::metadata::IIOMetadataNode *); + void removeNodeObject(::javax::imageio::metadata::IIOMetadataNode *); +public: // actually protected + virtual void addObjectValue(::java::lang::String *, ::java::lang::Class *, jboolean, ::java::lang::Object *); + virtual void addObjectValue(::java::lang::String *, ::java::lang::Class *, jboolean, ::java::lang::Object *, ::java::util::List *); + virtual void addObjectValue(::java::lang::String *, ::java::lang::Class *, ::java::lang::Object *, ::java::lang::Comparable *, ::java::lang::Comparable *, jboolean, jboolean); + virtual void addObjectValue(::java::lang::String *, ::java::lang::Class *, jint, jint); +public: + virtual ::java::lang::String * getRootName(); +public: // actually protected + virtual ::java::lang::String * getResourceBaseName(); +public: + static ::javax::imageio::metadata::IIOMetadataFormat * getStandardFormatInstance(); + virtual jboolean canNodeAppear(::java::lang::String *, ::javax::imageio::ImageTypeSpecifier *) = 0; +public: // actually protected + virtual void removeAttribute(::java::lang::String *, ::java::lang::String *); + virtual void removeElement(::java::lang::String *); + virtual void removeObjectValue(::java::lang::String *); + virtual void setResourceBaseName(::java::lang::String *); +public: + virtual jint getAttributeDataType(::java::lang::String *, ::java::lang::String *); + virtual ::java::lang::String * getAttributeDefaultValue(::java::lang::String *, ::java::lang::String *); + virtual ::java::lang::String * getAttributeDescription(::java::lang::String *, ::java::lang::String *, ::java::util::Locale *); + virtual JArray< ::java::lang::String * > * getAttributeEnumerations(::java::lang::String *, ::java::lang::String *); + virtual jint getAttributeListMaxLength(::java::lang::String *, ::java::lang::String *); + virtual jint getAttributeListMinLength(::java::lang::String *, ::java::lang::String *); + virtual ::java::lang::String * getAttributeMaxValue(::java::lang::String *, ::java::lang::String *); + virtual ::java::lang::String * getAttributeMinValue(::java::lang::String *, ::java::lang::String *); + virtual JArray< ::java::lang::String * > * getAttributeNames(::java::lang::String *); + virtual jint getAttributeValueType(::java::lang::String *, ::java::lang::String *); + virtual JArray< ::java::lang::String * > * getChildNames(::java::lang::String *); + virtual jint getChildPolicy(::java::lang::String *); +private: + ::java::lang::String * getDescription(::java::lang::String *, ::java::util::Locale *); +public: + virtual ::java::lang::String * getElementDescription(::java::lang::String *, ::java::util::Locale *); + virtual jint getElementMaxChildren(::java::lang::String *); + virtual jint getElementMinChildren(::java::lang::String *); + virtual jint getObjectArrayMaxLength(::java::lang::String *); + virtual jint getObjectArrayMinLength(::java::lang::String *); + virtual ::java::lang::Class * getObjectClass(::java::lang::String *); + virtual ::java::lang::Object * getObjectDefaultValue(::java::lang::String *); + virtual JArray< ::java::lang::Object * > * getObjectEnumerations(::java::lang::String *); + virtual ::java::lang::Comparable * getObjectMaxValue(::java::lang::String *); + virtual ::java::lang::Comparable * getObjectMinValue(::java::lang::String *); + virtual jint getObjectValueType(::java::lang::String *); + virtual jboolean isAttributeRequired(::java::lang::String *, ::java::lang::String *); + static ::java::lang::String * standardMetadataFormatName; +private: + ::java::lang::String * __attribute__((aligned(__alignof__( ::java::lang::Object)))) rootName; + ::java::util::Map * nodes; + ::java::util::Map * childPolicies; + ::java::util::Map * childRanges; + ::java::lang::String * resourceBaseName; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_metadata_IIOMetadataFormatImpl__ diff --git a/libjava/javax/imageio/metadata/IIOMetadataNode$IIONamedNodeMap.h b/libjava/javax/imageio/metadata/IIOMetadataNode$IIONamedNodeMap.h new file mode 100644 index 000000000..9026a27d6 --- /dev/null +++ b/libjava/javax/imageio/metadata/IIOMetadataNode$IIONamedNodeMap.h @@ -0,0 +1,55 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_metadata_IIOMetadataNode$IIONamedNodeMap__ +#define __javax_imageio_metadata_IIOMetadataNode$IIONamedNodeMap__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + namespace metadata + { + class IIOMetadataNode; + class IIOMetadataNode$IIONamedNodeMap; + } + } + } + namespace org + { + namespace w3c + { + namespace dom + { + class Node; + } + } + } +} + +class javax::imageio::metadata::IIOMetadataNode$IIONamedNodeMap : public ::java::lang::Object +{ + +public: + IIOMetadataNode$IIONamedNodeMap(::javax::imageio::metadata::IIOMetadataNode *, ::java::util::HashMap *); + virtual ::org::w3c::dom::Node * getNamedItem(::java::lang::String *); + virtual ::org::w3c::dom::Node * setNamedItem(::org::w3c::dom::Node *); + virtual ::org::w3c::dom::Node * removeNamedItem(::java::lang::String *); + virtual ::org::w3c::dom::Node * item(jint); + virtual jint getLength(); + virtual ::org::w3c::dom::Node * getNamedItemNS(::java::lang::String *, ::java::lang::String *); + virtual ::org::w3c::dom::Node * setNamedItemNS(::org::w3c::dom::Node *); + virtual ::org::w3c::dom::Node * removeNamedItemNS(::java::lang::String *, ::java::lang::String *); +public: // actually package-private + ::java::util::HashMap * __attribute__((aligned(__alignof__( ::java::lang::Object)))) attrs; + ::javax::imageio::metadata::IIOMetadataNode * this$0; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_metadata_IIOMetadataNode$IIONamedNodeMap__ diff --git a/libjava/javax/imageio/metadata/IIOMetadataNode$IIONodeList.h b/libjava/javax/imageio/metadata/IIOMetadataNode$IIONodeList.h new file mode 100644 index 000000000..581abd9ca --- /dev/null +++ b/libjava/javax/imageio/metadata/IIOMetadataNode$IIONodeList.h @@ -0,0 +1,50 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_metadata_IIOMetadataNode$IIONodeList__ +#define __javax_imageio_metadata_IIOMetadataNode$IIONodeList__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + namespace metadata + { + class IIOMetadataNode; + class IIOMetadataNode$IIONodeList; + } + } + } + namespace org + { + namespace w3c + { + namespace dom + { + class Node; + } + } + } +} + +class javax::imageio::metadata::IIOMetadataNode$IIONodeList : public ::java::lang::Object +{ + + IIOMetadataNode$IIONodeList(::javax::imageio::metadata::IIOMetadataNode *); +public: + virtual ::org::w3c::dom::Node * item(jint); + virtual jint getLength(); +public: // actually package-private + IIOMetadataNode$IIONodeList(::javax::imageio::metadata::IIOMetadataNode *, ::javax::imageio::metadata::IIOMetadataNode$IIONodeList *); + ::java::util::List * __attribute__((aligned(__alignof__( ::java::lang::Object)))) children; + ::javax::imageio::metadata::IIOMetadataNode * this$0; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_metadata_IIOMetadataNode$IIONodeList__ diff --git a/libjava/javax/imageio/metadata/IIOMetadataNode.h b/libjava/javax/imageio/metadata/IIOMetadataNode.h new file mode 100644 index 000000000..bf2c50c53 --- /dev/null +++ b/libjava/javax/imageio/metadata/IIOMetadataNode.h @@ -0,0 +1,121 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_metadata_IIOMetadataNode__ +#define __javax_imageio_metadata_IIOMetadataNode__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + namespace metadata + { + class IIOMetadataNode; + class IIOMetadataNode$IIONodeList; + } + } + } + namespace org + { + namespace w3c + { + namespace dom + { + class Attr; + class Document; + class NamedNodeMap; + class Node; + class NodeList; + class TypeInfo; + class UserDataHandler; + } + } + } +} + +class javax::imageio::metadata::IIOMetadataNode : public ::java::lang::Object +{ + +public: + IIOMetadataNode(); + IIOMetadataNode(::java::lang::String *); + virtual ::java::lang::Object * getUserObject(); + virtual void setUserObject(::java::lang::Object *); + virtual jshort compareDocumentPosition(::org::w3c::dom::Node *); + virtual ::java::lang::String * getAttribute(::java::lang::String *); + virtual ::org::w3c::dom::Attr * getAttributeNode(::java::lang::String *); + virtual ::org::w3c::dom::Attr * getAttributeNodeNS(::java::lang::String *, ::java::lang::String *); + virtual ::java::lang::String * getAttributeNS(::java::lang::String *, ::java::lang::String *); + virtual ::java::lang::String * getBaseURI(); +private: + void getElementsRecurse(::javax::imageio::metadata::IIOMetadataNode$IIONodeList *, ::java::lang::String *); +public: + virtual ::org::w3c::dom::NodeList * getElementsByTagName(::java::lang::String *); + virtual ::org::w3c::dom::NodeList * getElementsByTagNameNS(::java::lang::String *, ::java::lang::String *); + virtual ::java::lang::String * getTagName(); + virtual jboolean hasAttribute(::java::lang::String *); + virtual jboolean hasAttributeNS(::java::lang::String *, ::java::lang::String *); + virtual void removeAttribute(::java::lang::String *); + virtual ::org::w3c::dom::Attr * removeAttributeNode(::org::w3c::dom::Attr *); + virtual void removeAttributeNS(::java::lang::String *, ::java::lang::String *); + virtual void setAttribute(::java::lang::String *, ::java::lang::String *); + virtual ::org::w3c::dom::Attr * setAttributeNode(::org::w3c::dom::Attr *); + virtual ::org::w3c::dom::Attr * setAttributeNodeNS(::org::w3c::dom::Attr *); + virtual void setAttributeNS(::java::lang::String *, ::java::lang::String *, ::java::lang::String *); + virtual jint getLength(); + virtual ::org::w3c::dom::Node * item(jint); + virtual ::org::w3c::dom::Node * appendChild(::org::w3c::dom::Node *); + virtual ::org::w3c::dom::Node * cloneNode(jboolean); + virtual ::org::w3c::dom::NamedNodeMap * getAttributes(); + virtual ::org::w3c::dom::NodeList * getChildNodes(); + virtual ::java::lang::Object * getFeature(::java::lang::String *, ::java::lang::String *); + virtual ::org::w3c::dom::Node * getFirstChild(); + virtual ::org::w3c::dom::Node * getLastChild(); + virtual ::java::lang::String * getLocalName(); + virtual ::java::lang::String * getNamespaceURI(); + virtual ::org::w3c::dom::Node * getNextSibling(); + virtual ::java::lang::String * getNodeName(); + virtual jshort getNodeType(); + virtual ::java::lang::String * getNodeValue(); + virtual ::org::w3c::dom::Document * getOwnerDocument(); + virtual ::org::w3c::dom::Node * getParentNode(); + virtual ::java::lang::String * getPrefix(); + virtual ::org::w3c::dom::Node * getPreviousSibling(); + virtual ::org::w3c::dom::TypeInfo * getSchemaTypeInfo(); + virtual ::java::lang::String * getTextContent(); + virtual ::java::lang::Object * getUserData(::java::lang::String *); + virtual jboolean hasAttributes(); + virtual jboolean hasChildNodes(); + virtual ::org::w3c::dom::Node * insertBefore(::org::w3c::dom::Node *, ::org::w3c::dom::Node *); + virtual jboolean isDefaultNamespace(::java::lang::String *); + virtual jboolean isEqualNode(::org::w3c::dom::Node *); + virtual jboolean isSameNode(::org::w3c::dom::Node *); + virtual jboolean isSupported(::java::lang::String *, ::java::lang::String *); + virtual ::java::lang::String * lookupNamespaceURI(::java::lang::String *); + virtual ::java::lang::String * lookupPrefix(::java::lang::String *); + virtual void normalize(); + virtual ::org::w3c::dom::Node * removeChild(::org::w3c::dom::Node *); + virtual ::org::w3c::dom::Node * replaceChild(::org::w3c::dom::Node *, ::org::w3c::dom::Node *); + virtual void setIdAttribute(::java::lang::String *, jboolean); + virtual void setIdAttributeNode(::org::w3c::dom::Attr *, jboolean); + virtual void setIdAttributeNS(::java::lang::String *, ::java::lang::String *, jboolean); + virtual void setNodeValue(::java::lang::String *); + virtual void setPrefix(::java::lang::String *); + virtual void setTextContent(::java::lang::String *); + virtual ::java::lang::Object * setUserData(::java::lang::String *, ::java::lang::Object *, ::org::w3c::dom::UserDataHandler *); +private: + ::java::lang::String * __attribute__((aligned(__alignof__( ::java::lang::Object)))) name; + ::java::util::HashMap * attrs; + ::java::util::List * children; + ::javax::imageio::metadata::IIOMetadataNode * parent; + ::java::lang::Object * obj; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_metadata_IIOMetadataNode__ diff --git a/libjava/javax/imageio/plugins/bmp/BMPImageWriteParam.h b/libjava/javax/imageio/plugins/bmp/BMPImageWriteParam.h new file mode 100644 index 000000000..d1757850d --- /dev/null +++ b/libjava/javax/imageio/plugins/bmp/BMPImageWriteParam.h @@ -0,0 +1,50 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_plugins_bmp_BMPImageWriteParam__ +#define __javax_imageio_plugins_bmp_BMPImageWriteParam__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + namespace plugins + { + namespace bmp + { + class BMPImageWriteParam; + } + } + } + } +} + +class javax::imageio::plugins::bmp::BMPImageWriteParam : public ::javax::imageio::ImageWriteParam +{ + +public: + BMPImageWriteParam(); + BMPImageWriteParam(::java::util::Locale *); + virtual void setTopDown(jboolean); + virtual jboolean isTopDown(); +private: + jboolean __attribute__((aligned(__alignof__( ::javax::imageio::ImageWriteParam)))) topDown; +public: // actually package-private + ::java::lang::String * rgb; + ::java::lang::String * rle8; + ::java::lang::String * rle4; + ::java::lang::String * bitfields; + static const jint BI_RGB = 0; + static const jint BI_RLE8 = 1; + static const jint BI_RLE4 = 2; + static const jint BI_BITFIELDS = 3; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_plugins_bmp_BMPImageWriteParam__ diff --git a/libjava/javax/imageio/plugins/jpeg/JPEGHuffmanTable.h b/libjava/javax/imageio/plugins/jpeg/JPEGHuffmanTable.h new file mode 100644 index 000000000..7aa9f84e5 --- /dev/null +++ b/libjava/javax/imageio/plugins/jpeg/JPEGHuffmanTable.h @@ -0,0 +1,53 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_plugins_jpeg_JPEGHuffmanTable__ +#define __javax_imageio_plugins_jpeg_JPEGHuffmanTable__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace javax + { + namespace imageio + { + namespace plugins + { + namespace jpeg + { + class JPEGHuffmanTable; + } + } + } + } +} + +class javax::imageio::plugins::jpeg::JPEGHuffmanTable : public ::java::lang::Object +{ + +public: + JPEGHuffmanTable(JArray< jshort > *, JArray< jshort > *); +private: + JPEGHuffmanTable(JArray< jshort > *, JArray< jshort > *, jboolean); + static JArray< jshort > * checkLengths(JArray< jshort > *); + static JArray< jshort > * checkValues(JArray< jshort > *, JArray< jshort > *); +public: + virtual JArray< jshort > * getLengths(); + virtual JArray< jshort > * getValues(); + virtual ::java::lang::String * toString(); +private: + JArray< jshort > * __attribute__((aligned(__alignof__( ::java::lang::Object)))) lengths; + JArray< jshort > * values; +public: + static ::javax::imageio::plugins::jpeg::JPEGHuffmanTable * StdACChrominance; + static ::javax::imageio::plugins::jpeg::JPEGHuffmanTable * StdACLuminance; + static ::javax::imageio::plugins::jpeg::JPEGHuffmanTable * StdDCChrominance; + static ::javax::imageio::plugins::jpeg::JPEGHuffmanTable * StdDCLuminance; + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_plugins_jpeg_JPEGHuffmanTable__ diff --git a/libjava/javax/imageio/plugins/jpeg/JPEGImageReadParam.h b/libjava/javax/imageio/plugins/jpeg/JPEGImageReadParam.h new file mode 100644 index 000000000..c45838215 --- /dev/null +++ b/libjava/javax/imageio/plugins/jpeg/JPEGImageReadParam.h @@ -0,0 +1,50 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_plugins_jpeg_JPEGImageReadParam__ +#define __javax_imageio_plugins_jpeg_JPEGImageReadParam__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace javax + { + namespace imageio + { + namespace plugins + { + namespace jpeg + { + class JPEGHuffmanTable; + class JPEGImageReadParam; + class JPEGQTable; + } + } + } + } +} + +class javax::imageio::plugins::jpeg::JPEGImageReadParam : public ::javax::imageio::ImageReadParam +{ + +public: + JPEGImageReadParam(); + virtual jboolean areTablesSet(); + virtual void setDecodeTables(JArray< ::javax::imageio::plugins::jpeg::JPEGQTable * > *, JArray< ::javax::imageio::plugins::jpeg::JPEGHuffmanTable * > *, JArray< ::javax::imageio::plugins::jpeg::JPEGHuffmanTable * > *); + virtual void unsetDecodeTables(); + virtual JArray< ::javax::imageio::plugins::jpeg::JPEGQTable * > * getQTables(); + virtual JArray< ::javax::imageio::plugins::jpeg::JPEGHuffmanTable * > * getDCHuffmanTables(); + virtual JArray< ::javax::imageio::plugins::jpeg::JPEGHuffmanTable * > * getACHuffmanTables(); +private: + JArray< ::javax::imageio::plugins::jpeg::JPEGQTable * > * __attribute__((aligned(__alignof__( ::javax::imageio::ImageReadParam)))) qTables; + JArray< ::javax::imageio::plugins::jpeg::JPEGHuffmanTable * > * DCHuffmanTables; + JArray< ::javax::imageio::plugins::jpeg::JPEGHuffmanTable * > * ACHuffmanTables; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_plugins_jpeg_JPEGImageReadParam__ diff --git a/libjava/javax/imageio/plugins/jpeg/JPEGImageWriteParam.h b/libjava/javax/imageio/plugins/jpeg/JPEGImageWriteParam.h new file mode 100644 index 000000000..03607d122 --- /dev/null +++ b/libjava/javax/imageio/plugins/jpeg/JPEGImageWriteParam.h @@ -0,0 +1,60 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_plugins_jpeg_JPEGImageWriteParam__ +#define __javax_imageio_plugins_jpeg_JPEGImageWriteParam__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace javax + { + namespace imageio + { + namespace plugins + { + namespace jpeg + { + class JPEGHuffmanTable; + class JPEGImageWriteParam; + class JPEGQTable; + } + } + } + } +} + +class javax::imageio::plugins::jpeg::JPEGImageWriteParam : public ::javax::imageio::ImageWriteParam +{ + +public: + JPEGImageWriteParam(::java::util::Locale *); + virtual void unsetCompression(); + virtual jboolean isCompressionLossless(); + virtual JArray< ::java::lang::String * > * getCompressionQualityDescriptions(); + virtual JArray< jfloat > * getCompressionQualityValues(); + virtual jboolean areTablesSet(); + virtual void setEncodeTables(JArray< ::javax::imageio::plugins::jpeg::JPEGQTable * > *, JArray< ::javax::imageio::plugins::jpeg::JPEGHuffmanTable * > *, JArray< ::javax::imageio::plugins::jpeg::JPEGHuffmanTable * > *); + virtual void unsetEncodeTables(); + virtual JArray< ::javax::imageio::plugins::jpeg::JPEGQTable * > * getQTables(); + virtual JArray< ::javax::imageio::plugins::jpeg::JPEGHuffmanTable * > * getDCHuffmanTables(); + virtual JArray< ::javax::imageio::plugins::jpeg::JPEGHuffmanTable * > * getACHuffmanTables(); + virtual void setOptimizeHuffmanTables(jboolean); + virtual jboolean getOptimizeHuffmanTables(); +private: + JArray< ::javax::imageio::plugins::jpeg::JPEGQTable * > * __attribute__((aligned(__alignof__( ::javax::imageio::ImageWriteParam)))) qTables; + JArray< ::javax::imageio::plugins::jpeg::JPEGHuffmanTable * > * DCHuffmanTables; + JArray< ::javax::imageio::plugins::jpeg::JPEGHuffmanTable * > * ACHuffmanTables; + jboolean optimize; + JArray< ::java::lang::String * > * compressionQualityDescriptions; + JArray< jfloat > * compressionQualityValues; + ::java::util::ResourceBundle * messages; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_plugins_jpeg_JPEGImageWriteParam__ diff --git a/libjava/javax/imageio/plugins/jpeg/JPEGQTable.h b/libjava/javax/imageio/plugins/jpeg/JPEGQTable.h new file mode 100644 index 000000000..366202f56 --- /dev/null +++ b/libjava/javax/imageio/plugins/jpeg/JPEGQTable.h @@ -0,0 +1,51 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_plugins_jpeg_JPEGQTable__ +#define __javax_imageio_plugins_jpeg_JPEGQTable__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace javax + { + namespace imageio + { + namespace plugins + { + namespace jpeg + { + class JPEGQTable; + } + } + } + } +} + +class javax::imageio::plugins::jpeg::JPEGQTable : public ::java::lang::Object +{ + +public: + JPEGQTable(JArray< jint > *); +private: + JPEGQTable(JArray< jint > *, jboolean); + static JArray< jint > * checkTable(JArray< jint > *); +public: + virtual JArray< jint > * getTable(); + virtual ::javax::imageio::plugins::jpeg::JPEGQTable * getScaledInstance(jfloat, jboolean); + virtual ::java::lang::String * toString(); +private: + JArray< jint > * __attribute__((aligned(__alignof__( ::java::lang::Object)))) table; +public: + static ::javax::imageio::plugins::jpeg::JPEGQTable * K1Luminance; + static ::javax::imageio::plugins::jpeg::JPEGQTable * K1Div2Luminance; + static ::javax::imageio::plugins::jpeg::JPEGQTable * K2Chrominance; + static ::javax::imageio::plugins::jpeg::JPEGQTable * K2Div2Chrominance; + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_plugins_jpeg_JPEGQTable__ diff --git a/libjava/javax/imageio/spi/IIORegistry.h b/libjava/javax/imageio/spi/IIORegistry.h new file mode 100644 index 000000000..4b15c121f --- /dev/null +++ b/libjava/javax/imageio/spi/IIORegistry.h @@ -0,0 +1,40 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_spi_IIORegistry__ +#define __javax_imageio_spi_IIORegistry__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + namespace spi + { + class IIORegistry; + } + } + } +} + +class javax::imageio::spi::IIORegistry : public ::javax::imageio::spi::ServiceRegistry +{ + +public: + static ::javax::imageio::spi::IIORegistry * getDefaultInstance(); +private: + IIORegistry(); +public: + void registerApplicationClasspathSpis(); +private: + static ::java::util::HashSet * defaultCategories; + static ::java::util::HashMap * instances; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_spi_IIORegistry__ diff --git a/libjava/javax/imageio/spi/IIOServiceProvider.h b/libjava/javax/imageio/spi/IIOServiceProvider.h new file mode 100644 index 000000000..befcd09cc --- /dev/null +++ b/libjava/javax/imageio/spi/IIOServiceProvider.h @@ -0,0 +1,43 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_spi_IIOServiceProvider__ +#define __javax_imageio_spi_IIOServiceProvider__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + namespace spi + { + class IIOServiceProvider; + class ServiceRegistry; + } + } + } +} + +class javax::imageio::spi::IIOServiceProvider : public ::java::lang::Object +{ + +public: + IIOServiceProvider(::java::lang::String *, ::java::lang::String *); + IIOServiceProvider(); + virtual void onRegistration(::javax::imageio::spi::ServiceRegistry *, ::java::lang::Class *); + virtual void onDeregistration(::javax::imageio::spi::ServiceRegistry *, ::java::lang::Class *); + virtual ::java::lang::String * getVendorName(); + virtual ::java::lang::String * getVersion(); + virtual ::java::lang::String * getDescription(::java::util::Locale *) = 0; +public: // actually protected + ::java::lang::String * __attribute__((aligned(__alignof__( ::java::lang::Object)))) vendorName; + ::java::lang::String * version; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_spi_IIOServiceProvider__ diff --git a/libjava/javax/imageio/spi/ImageInputStreamSpi.h b/libjava/javax/imageio/spi/ImageInputStreamSpi.h new file mode 100644 index 000000000..946842c61 --- /dev/null +++ b/libjava/javax/imageio/spi/ImageInputStreamSpi.h @@ -0,0 +1,46 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_spi_ImageInputStreamSpi__ +#define __javax_imageio_spi_ImageInputStreamSpi__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + namespace spi + { + class ImageInputStreamSpi; + } + namespace stream + { + class ImageInputStream; + } + } + } +} + +class javax::imageio::spi::ImageInputStreamSpi : public ::javax::imageio::spi::IIOServiceProvider +{ + +public: // actually protected + ImageInputStreamSpi(); +public: + ImageInputStreamSpi(::java::lang::String *, ::java::lang::String *, ::java::lang::Class *); + virtual ::java::lang::Class * getInputClass(); + virtual jboolean canUseCacheFile(); + virtual jboolean needsCacheFile(); + virtual ::javax::imageio::stream::ImageInputStream * createInputStreamInstance(::java::lang::Object *, jboolean, ::java::io::File *) = 0; + virtual ::javax::imageio::stream::ImageInputStream * createInputStreamInstance(::java::lang::Object *); +public: // actually protected + ::java::lang::Class * __attribute__((aligned(__alignof__( ::javax::imageio::spi::IIOServiceProvider)))) inputClass; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_spi_ImageInputStreamSpi__ diff --git a/libjava/javax/imageio/spi/ImageOutputStreamSpi.h b/libjava/javax/imageio/spi/ImageOutputStreamSpi.h new file mode 100644 index 000000000..6ac36b4aa --- /dev/null +++ b/libjava/javax/imageio/spi/ImageOutputStreamSpi.h @@ -0,0 +1,46 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_spi_ImageOutputStreamSpi__ +#define __javax_imageio_spi_ImageOutputStreamSpi__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + namespace spi + { + class ImageOutputStreamSpi; + } + namespace stream + { + class ImageOutputStream; + } + } + } +} + +class javax::imageio::spi::ImageOutputStreamSpi : public ::javax::imageio::spi::IIOServiceProvider +{ + +public: // actually protected + ImageOutputStreamSpi(); +public: + ImageOutputStreamSpi(::java::lang::String *, ::java::lang::String *, ::java::lang::Class *); + virtual ::java::lang::Class * getOutputClass(); + virtual jboolean canUseCacheFile(); + virtual jboolean needsCacheFile(); + virtual ::javax::imageio::stream::ImageOutputStream * createOutputStreamInstance(::java::lang::Object *, jboolean, ::java::io::File *) = 0; + virtual ::javax::imageio::stream::ImageOutputStream * createOutputStreamInstance(::java::lang::Object *); +public: // actually protected + ::java::lang::Class * __attribute__((aligned(__alignof__( ::javax::imageio::spi::IIOServiceProvider)))) outputClass; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_spi_ImageOutputStreamSpi__ diff --git a/libjava/javax/imageio/spi/ImageReaderSpi.h b/libjava/javax/imageio/spi/ImageReaderSpi.h new file mode 100644 index 000000000..554b52ee7 --- /dev/null +++ b/libjava/javax/imageio/spi/ImageReaderSpi.h @@ -0,0 +1,48 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_spi_ImageReaderSpi__ +#define __javax_imageio_spi_ImageReaderSpi__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace javax + { + namespace imageio + { + class ImageReader; + namespace spi + { + class ImageReaderSpi; + } + } + } +} + +class javax::imageio::spi::ImageReaderSpi : public ::javax::imageio::spi::ImageReaderWriterSpi +{ + +public: // actually protected + ImageReaderSpi(); +public: + ImageReaderSpi(::java::lang::String *, ::java::lang::String *, JArray< ::java::lang::String * > *, JArray< ::java::lang::String * > *, JArray< ::java::lang::String * > *, ::java::lang::String *, JArray< ::java::lang::Class * > *, JArray< ::java::lang::String * > *, jboolean, ::java::lang::String *, ::java::lang::String *, JArray< ::java::lang::String * > *, JArray< ::java::lang::String * > *, jboolean, ::java::lang::String *, ::java::lang::String *, JArray< ::java::lang::String * > *, JArray< ::java::lang::String * > *); + virtual jboolean canDecodeInput(::java::lang::Object *) = 0; + virtual ::javax::imageio::ImageReader * createReaderInstance(); + virtual ::javax::imageio::ImageReader * createReaderInstance(::java::lang::Object *) = 0; + virtual JArray< ::java::lang::String * > * getImageWriterSpiNames(); + virtual JArray< ::java::lang::Class * > * getInputTypes(); + virtual jboolean isOwnReader(::javax::imageio::ImageReader *); + static JArray< ::java::lang::Class * > * STANDARD_INPUT_TYPE; +public: // actually protected + JArray< ::java::lang::Class * > * __attribute__((aligned(__alignof__( ::javax::imageio::spi::ImageReaderWriterSpi)))) inputTypes; + JArray< ::java::lang::String * > * writerSpiNames; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_spi_ImageReaderSpi__ diff --git a/libjava/javax/imageio/spi/ImageReaderWriterSpi.h b/libjava/javax/imageio/spi/ImageReaderWriterSpi.h new file mode 100644 index 000000000..91930cd20 --- /dev/null +++ b/libjava/javax/imageio/spi/ImageReaderWriterSpi.h @@ -0,0 +1,67 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_spi_ImageReaderWriterSpi__ +#define __javax_imageio_spi_ImageReaderWriterSpi__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace javax + { + namespace imageio + { + namespace metadata + { + class IIOMetadataFormat; + } + namespace spi + { + class ImageReaderWriterSpi; + } + } + } +} + +class javax::imageio::spi::ImageReaderWriterSpi : public ::javax::imageio::spi::IIOServiceProvider +{ + +public: + ImageReaderWriterSpi(); + ImageReaderWriterSpi(::java::lang::String *, ::java::lang::String *, JArray< ::java::lang::String * > *, JArray< ::java::lang::String * > *, JArray< ::java::lang::String * > *, ::java::lang::String *, jboolean, ::java::lang::String *, ::java::lang::String *, JArray< ::java::lang::String * > *, JArray< ::java::lang::String * > *, jboolean, ::java::lang::String *, ::java::lang::String *, JArray< ::java::lang::String * > *, JArray< ::java::lang::String * > *); + virtual JArray< ::java::lang::String * > * getFormatNames(); + virtual JArray< ::java::lang::String * > * getFileSuffixes(); + virtual JArray< ::java::lang::String * > * getMIMETypes(); + virtual ::java::lang::String * getPluginClassName(); + virtual jboolean isStandardStreamMetadataFormatSupported(); + virtual ::java::lang::String * getNativeStreamMetadataFormatName(); + virtual JArray< ::java::lang::String * > * getExtraStreamMetadataFormatNames(); + virtual jboolean isStandardImageMetadataFormatSupported(); + virtual ::java::lang::String * getNativeImageMetadataFormatName(); + virtual JArray< ::java::lang::String * > * getExtraImageMetadataFormatNames(); + virtual ::javax::imageio::metadata::IIOMetadataFormat * getStreamMetadataFormat(::java::lang::String *); + virtual ::javax::imageio::metadata::IIOMetadataFormat * getImageMetadataFormat(::java::lang::String *); +public: // actually protected + JArray< ::java::lang::String * > * __attribute__((aligned(__alignof__( ::javax::imageio::spi::IIOServiceProvider)))) names; + JArray< ::java::lang::String * > * suffixes; + JArray< ::java::lang::String * > * MIMETypes; + ::java::lang::String * pluginClassName; + jboolean supportsStandardStreamMetadataFormat; + ::java::lang::String * nativeStreamMetadataFormatName; + ::java::lang::String * nativeStreamMetadataFormatClassName; + JArray< ::java::lang::String * > * extraStreamMetadataFormatNames; + JArray< ::java::lang::String * > * extraStreamMetadataFormatClassNames; + jboolean supportsStandardImageMetadataFormat; + ::java::lang::String * nativeImageMetadataFormatName; + ::java::lang::String * nativeImageMetadataFormatClassName; + JArray< ::java::lang::String * > * extraImageMetadataFormatNames; + JArray< ::java::lang::String * > * extraImageMetadataFormatClassNames; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_spi_ImageReaderWriterSpi__ diff --git a/libjava/javax/imageio/spi/ImageTranscoderSpi.h b/libjava/javax/imageio/spi/ImageTranscoderSpi.h new file mode 100644 index 000000000..368c2ad63 --- /dev/null +++ b/libjava/javax/imageio/spi/ImageTranscoderSpi.h @@ -0,0 +1,38 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_spi_ImageTranscoderSpi__ +#define __javax_imageio_spi_ImageTranscoderSpi__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + class ImageTranscoder; + namespace spi + { + class ImageTranscoderSpi; + } + } + } +} + +class javax::imageio::spi::ImageTranscoderSpi : public ::javax::imageio::spi::IIOServiceProvider +{ + +public: // actually protected + ImageTranscoderSpi(); +public: + ImageTranscoderSpi(::java::lang::String *, ::java::lang::String *); + virtual ::java::lang::String * getReaderServiceProviderName() = 0; + virtual ::java::lang::String * getWriterServiceProviderName() = 0; + virtual ::javax::imageio::ImageTranscoder * createTranscoderInstance() = 0; + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_spi_ImageTranscoderSpi__ diff --git a/libjava/javax/imageio/spi/ImageWriterSpi.h b/libjava/javax/imageio/spi/ImageWriterSpi.h new file mode 100644 index 000000000..55d9bdb8e --- /dev/null +++ b/libjava/javax/imageio/spi/ImageWriterSpi.h @@ -0,0 +1,61 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_spi_ImageWriterSpi__ +#define __javax_imageio_spi_ImageWriterSpi__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace java + { + namespace awt + { + namespace image + { + class RenderedImage; + } + } + } + namespace javax + { + namespace imageio + { + class ImageTypeSpecifier; + class ImageWriter; + namespace spi + { + class ImageWriterSpi; + } + } + } +} + +class javax::imageio::spi::ImageWriterSpi : public ::javax::imageio::spi::ImageReaderWriterSpi +{ + +public: // actually protected + ImageWriterSpi(); +public: + ImageWriterSpi(::java::lang::String *, ::java::lang::String *, JArray< ::java::lang::String * > *, JArray< ::java::lang::String * > *, JArray< ::java::lang::String * > *, ::java::lang::String *, JArray< ::java::lang::Class * > *, JArray< ::java::lang::String * > *, jboolean, ::java::lang::String *, ::java::lang::String *, JArray< ::java::lang::String * > *, JArray< ::java::lang::String * > *, jboolean, ::java::lang::String *, ::java::lang::String *, JArray< ::java::lang::String * > *, JArray< ::java::lang::String * > *); + virtual jboolean canEncodeImage(::javax::imageio::ImageTypeSpecifier *) = 0; + virtual jboolean canEncodeImage(::java::awt::image::RenderedImage *); + virtual ::javax::imageio::ImageWriter * createWriterInstance(); + virtual ::javax::imageio::ImageWriter * createWriterInstance(::java::lang::Object *) = 0; + virtual JArray< ::java::lang::String * > * getImageReaderSpiNames(); + virtual JArray< ::java::lang::Class * > * getOutputTypes(); + virtual jboolean isFormatLossless(); + virtual jboolean isOwnWriter(::javax::imageio::ImageWriter *); + static JArray< ::java::lang::Class * > * STANDARD_OUTPUT_TYPE; +public: // actually protected + JArray< ::java::lang::Class * > * __attribute__((aligned(__alignof__( ::javax::imageio::spi::ImageReaderWriterSpi)))) outputTypes; + JArray< ::java::lang::String * > * readerSpiNames; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_spi_ImageWriterSpi__ diff --git a/libjava/javax/imageio/spi/RegisterableService.h b/libjava/javax/imageio/spi/RegisterableService.h new file mode 100644 index 000000000..fcd4e140f --- /dev/null +++ b/libjava/javax/imageio/spi/RegisterableService.h @@ -0,0 +1,34 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_spi_RegisterableService__ +#define __javax_imageio_spi_RegisterableService__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + namespace spi + { + class RegisterableService; + class ServiceRegistry; + } + } + } +} + +class javax::imageio::spi::RegisterableService : public ::java::lang::Object +{ + +public: + virtual void onRegistration(::javax::imageio::spi::ServiceRegistry *, ::java::lang::Class *) = 0; + virtual void onDeregistration(::javax::imageio::spi::ServiceRegistry *, ::java::lang::Class *) = 0; + static ::java::lang::Class class$; +} __attribute__ ((java_interface)); + +#endif // __javax_imageio_spi_RegisterableService__ diff --git a/libjava/javax/imageio/spi/ServiceRegistry$1.h b/libjava/javax/imageio/spi/ServiceRegistry$1.h new file mode 100644 index 000000000..431ba3115 --- /dev/null +++ b/libjava/javax/imageio/spi/ServiceRegistry$1.h @@ -0,0 +1,41 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_spi_ServiceRegistry$1__ +#define __javax_imageio_spi_ServiceRegistry$1__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + namespace spi + { + class ServiceRegistry; + class ServiceRegistry$1; + } + } + } +} + +class javax::imageio::spi::ServiceRegistry$1 : public ::java::lang::Object +{ + +public: // actually package-private + ServiceRegistry$1(::javax::imageio::spi::ServiceRegistry *); +public: + virtual jboolean hasNext(); + virtual ::java::lang::Object * next(); + virtual void remove(); +public: // actually package-private + jint __attribute__((aligned(__alignof__( ::java::lang::Object)))) index; + ::javax::imageio::spi::ServiceRegistry * this$0; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_spi_ServiceRegistry$1__ diff --git a/libjava/javax/imageio/spi/ServiceRegistry$2.h b/libjava/javax/imageio/spi/ServiceRegistry$2.h new file mode 100644 index 000000000..0934d4ac2 --- /dev/null +++ b/libjava/javax/imageio/spi/ServiceRegistry$2.h @@ -0,0 +1,40 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_spi_ServiceRegistry$2__ +#define __javax_imageio_spi_ServiceRegistry$2__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + namespace spi + { + class ServiceRegistry; + class ServiceRegistry$2; + } + } + } +} + +class javax::imageio::spi::ServiceRegistry$2 : public ::java::lang::Object +{ + +public: // actually package-private + ServiceRegistry$2(::javax::imageio::spi::ServiceRegistry *, ::java::util::Map *); +public: + virtual jint compare(::java::lang::Object *, ::java::lang::Object *); +public: // actually package-private + ::javax::imageio::spi::ServiceRegistry * __attribute__((aligned(__alignof__( ::java::lang::Object)))) this$0; +private: + ::java::util::Map * val$cons; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_spi_ServiceRegistry$2__ diff --git a/libjava/javax/imageio/spi/ServiceRegistry$Filter.h b/libjava/javax/imageio/spi/ServiceRegistry$Filter.h new file mode 100644 index 000000000..10fd5aaff --- /dev/null +++ b/libjava/javax/imageio/spi/ServiceRegistry$Filter.h @@ -0,0 +1,32 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_spi_ServiceRegistry$Filter__ +#define __javax_imageio_spi_ServiceRegistry$Filter__ + +#pragma interface + +#include +extern "Java" +{ + namespace javax + { + namespace imageio + { + namespace spi + { + class ServiceRegistry$Filter; + } + } + } +} + +class javax::imageio::spi::ServiceRegistry$Filter : public ::java::lang::Object +{ + +public: + virtual jboolean filter(::java::lang::Object *) = 0; + static ::java::lang::Class class$; +} __attribute__ ((java_interface)); + +#endif // __javax_imageio_spi_ServiceRegistry$Filter__ diff --git a/libjava/javax/imageio/spi/ServiceRegistry.h b/libjava/javax/imageio/spi/ServiceRegistry.h new file mode 100644 index 000000000..79a48fe3f --- /dev/null +++ b/libjava/javax/imageio/spi/ServiceRegistry.h @@ -0,0 +1,70 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_spi_ServiceRegistry__ +#define __javax_imageio_spi_ServiceRegistry__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace javax + { + namespace imageio + { + namespace spi + { + class ServiceRegistry; + class ServiceRegistry$Filter; + } + } + } +} + +class javax::imageio::spi::ServiceRegistry : public ::java::lang::Object +{ + +public: + ServiceRegistry(::java::util::Iterator *); + static ::java::util::Iterator * lookupProviders(::java::lang::Class *, ::java::lang::ClassLoader *); + static ::java::util::Iterator * lookupProviders(::java::lang::Class *); + virtual ::java::util::Iterator * getCategories(); +private: + jboolean registerServiceProvider(::java::lang::Object *, jint); +public: + virtual jboolean registerServiceProvider(::java::lang::Object *, ::java::lang::Class *); + virtual void registerServiceProvider(::java::lang::Object *); + virtual void registerServiceProviders(::java::util::Iterator *); +private: + jboolean deregisterServiceProvider(::java::lang::Object *, jint); +public: + virtual jboolean deregisterServiceProvider(::java::lang::Object *, ::java::lang::Class *); + virtual void deregisterServiceProvider(::java::lang::Object *); + virtual void deregisterAll(::java::lang::Class *); + virtual void deregisterAll(); + virtual void finalize(); + virtual jboolean contains(::java::lang::Object *); +private: + jint getCategoryID(::java::lang::Class *); +public: + virtual ::java::util::Iterator * getServiceProviders(::java::lang::Class *, jboolean); + virtual ::java::util::Iterator * getServiceProviders(::java::lang::Class *, ::javax::imageio::spi::ServiceRegistry$Filter *, jboolean); + virtual ::java::lang::Object * getServiceProviderByClass(::java::lang::Class *); + virtual jboolean setOrdering(::java::lang::Class *, ::java::lang::Object *, ::java::lang::Object *); + virtual jboolean unsetOrdering(::java::lang::Class *, ::java::lang::Object *, ::java::lang::Object *); +private: + jboolean addConstraint(jint, ::java::lang::Object *, ::java::lang::Object *); + jboolean removeConstraint(jint, ::java::lang::Object *, ::java::lang::Object *); +public: // actually package-private + JArray< ::java::lang::Class * > * __attribute__((aligned(__alignof__( ::java::lang::Object)))) categories; +private: + JArray< ::java::util::LinkedList * > * providers; + JArray< ::java::util::IdentityHashMap * > * constraints; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_spi_ServiceRegistry__ diff --git a/libjava/javax/imageio/stream/FileCacheImageInputStream.h b/libjava/javax/imageio/stream/FileCacheImageInputStream.h new file mode 100644 index 000000000..728ed37bd --- /dev/null +++ b/libjava/javax/imageio/stream/FileCacheImageInputStream.h @@ -0,0 +1,47 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_stream_FileCacheImageInputStream__ +#define __javax_imageio_stream_FileCacheImageInputStream__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace javax + { + namespace imageio + { + namespace stream + { + class FileCacheImageInputStream; + } + } + } +} + +class javax::imageio::stream::FileCacheImageInputStream : public ::javax::imageio::stream::ImageInputStreamImpl +{ + +public: + FileCacheImageInputStream(::java::io::InputStream *, ::java::io::File *); + virtual void close(); +private: + void checkStreamClosed(); +public: + virtual jboolean isCached(); + virtual jboolean isCachedFile(); + virtual jboolean isCachedMemory(); + virtual jint read(); + virtual jint read(JArray< jbyte > *, jint, jint); +private: + ::java::io::InputStream * __attribute__((aligned(__alignof__( ::javax::imageio::stream::ImageInputStreamImpl)))) stream; + ::java::io::File * cacheDir; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_stream_FileCacheImageInputStream__ diff --git a/libjava/javax/imageio/stream/FileCacheImageOutputStream.h b/libjava/javax/imageio/stream/FileCacheImageOutputStream.h new file mode 100644 index 000000000..c473085e9 --- /dev/null +++ b/libjava/javax/imageio/stream/FileCacheImageOutputStream.h @@ -0,0 +1,51 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_stream_FileCacheImageOutputStream__ +#define __javax_imageio_stream_FileCacheImageOutputStream__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace javax + { + namespace imageio + { + namespace stream + { + class FileCacheImageOutputStream; + } + } + } +} + +class javax::imageio::stream::FileCacheImageOutputStream : public ::javax::imageio::stream::ImageOutputStreamImpl +{ + +public: + FileCacheImageOutputStream(::java::io::OutputStream *, ::java::io::File *); + virtual void close(); + virtual jboolean isCached(); + virtual jboolean isCachedFile(); + virtual jboolean isCachedMemory(); + virtual jint read(); + virtual jint read(JArray< jbyte > *, jint, jint); + virtual void write(JArray< jbyte > *, jint, jint); + virtual void write(jint); + virtual jlong length(); + virtual void seek(jlong); + virtual void flushBefore(jlong); +private: + ::java::io::OutputStream * __attribute__((aligned(__alignof__( ::javax::imageio::stream::ImageOutputStreamImpl)))) stream; + ::java::io::File * cacheFile; + ::java::io::RandomAccessFile * cache; + jlong maxPos; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_stream_FileCacheImageOutputStream__ diff --git a/libjava/javax/imageio/stream/FileImageInputStream.h b/libjava/javax/imageio/stream/FileImageInputStream.h new file mode 100644 index 000000000..801e2cb1d --- /dev/null +++ b/libjava/javax/imageio/stream/FileImageInputStream.h @@ -0,0 +1,43 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_stream_FileImageInputStream__ +#define __javax_imageio_stream_FileImageInputStream__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace javax + { + namespace imageio + { + namespace stream + { + class FileImageInputStream; + } + } + } +} + +class javax::imageio::stream::FileImageInputStream : public ::javax::imageio::stream::ImageInputStreamImpl +{ + +public: + FileImageInputStream(::java::io::File *); + FileImageInputStream(::java::io::RandomAccessFile *); + virtual void close(); + virtual jlong length(); + virtual jint read(); + virtual jint read(JArray< jbyte > *, jint, jint); + virtual void seek(jlong); +private: + ::java::io::RandomAccessFile * __attribute__((aligned(__alignof__( ::javax::imageio::stream::ImageInputStreamImpl)))) file; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_stream_FileImageInputStream__ diff --git a/libjava/javax/imageio/stream/FileImageOutputStream.h b/libjava/javax/imageio/stream/FileImageOutputStream.h new file mode 100644 index 000000000..8075f4577 --- /dev/null +++ b/libjava/javax/imageio/stream/FileImageOutputStream.h @@ -0,0 +1,45 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_stream_FileImageOutputStream__ +#define __javax_imageio_stream_FileImageOutputStream__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace javax + { + namespace imageio + { + namespace stream + { + class FileImageOutputStream; + } + } + } +} + +class javax::imageio::stream::FileImageOutputStream : public ::javax::imageio::stream::ImageOutputStreamImpl +{ + +public: + FileImageOutputStream(::java::io::File *); + FileImageOutputStream(::java::io::RandomAccessFile *); + virtual void close(); + virtual jlong length(); + virtual jint read(); + virtual jint read(JArray< jbyte > *, jint, jint); + virtual void seek(jlong); + virtual void write(JArray< jbyte > *, jint, jint); + virtual void write(jint); +private: + ::java::io::RandomAccessFile * __attribute__((aligned(__alignof__( ::javax::imageio::stream::ImageOutputStreamImpl)))) file; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_stream_FileImageOutputStream__ diff --git a/libjava/javax/imageio/stream/IIOByteBuffer.h b/libjava/javax/imageio/stream/IIOByteBuffer.h new file mode 100644 index 000000000..0e5e0c145 --- /dev/null +++ b/libjava/javax/imageio/stream/IIOByteBuffer.h @@ -0,0 +1,45 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_stream_IIOByteBuffer__ +#define __javax_imageio_stream_IIOByteBuffer__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace javax + { + namespace imageio + { + namespace stream + { + class IIOByteBuffer; + } + } + } +} + +class javax::imageio::stream::IIOByteBuffer : public ::java::lang::Object +{ + +public: + IIOByteBuffer(JArray< jbyte > *, jint, jint); + virtual JArray< jbyte > * getData(); + virtual void setData(JArray< jbyte > *); + virtual jint getOffset(); + virtual void setOffset(jint); + virtual jint getLength(); + virtual void setLength(jint); +private: + JArray< jbyte > * __attribute__((aligned(__alignof__( ::java::lang::Object)))) data; + jint offset; + jint length; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_stream_IIOByteBuffer__ diff --git a/libjava/javax/imageio/stream/ImageInputStream.h b/libjava/javax/imageio/stream/ImageInputStream.h new file mode 100644 index 000000000..99c6304c4 --- /dev/null +++ b/libjava/javax/imageio/stream/ImageInputStream.h @@ -0,0 +1,86 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_stream_ImageInputStream__ +#define __javax_imageio_stream_ImageInputStream__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace java + { + namespace nio + { + class ByteOrder; + } + } + namespace javax + { + namespace imageio + { + namespace stream + { + class IIOByteBuffer; + class ImageInputStream; + } + } + } +} + +class javax::imageio::stream::ImageInputStream : public ::java::lang::Object +{ + +public: + virtual void setByteOrder(::java::nio::ByteOrder *) = 0; + virtual ::java::nio::ByteOrder * getByteOrder() = 0; + virtual jint read() = 0; + virtual jint read(JArray< jbyte > *) = 0; + virtual jint read(JArray< jbyte > *, jint, jint) = 0; + virtual void readBytes(::javax::imageio::stream::IIOByteBuffer *, jint) = 0; + virtual jboolean readBoolean() = 0; + virtual jbyte readByte() = 0; + virtual jint readUnsignedByte() = 0; + virtual jshort readShort() = 0; + virtual jint readUnsignedShort() = 0; + virtual jchar readChar() = 0; + virtual jint readInt() = 0; + virtual jlong readUnsignedInt() = 0; + virtual jlong readLong() = 0; + virtual jfloat readFloat() = 0; + virtual jdouble readDouble() = 0; + virtual ::java::lang::String * readLine() = 0; + virtual ::java::lang::String * readUTF() = 0; + virtual void readFully(JArray< jbyte > *, jint, jint) = 0; + virtual void readFully(JArray< jbyte > *) = 0; + virtual void readFully(JArray< jshort > *, jint, jint) = 0; + virtual void readFully(JArray< jchar > *, jint, jint) = 0; + virtual void readFully(JArray< jint > *, jint, jint) = 0; + virtual void readFully(JArray< jlong > *, jint, jint) = 0; + virtual void readFully(JArray< jfloat > *, jint, jint) = 0; + virtual void readFully(JArray< jdouble > *, jint, jint) = 0; + virtual jlong getStreamPosition() = 0; + virtual jint getBitOffset() = 0; + virtual void setBitOffset(jint) = 0; + virtual jint readBit() = 0; + virtual jlong readBits(jint) = 0; + virtual jlong length() = 0; + virtual jint skipBytes(jint) = 0; + virtual jlong skipBytes(jlong) = 0; + virtual void seek(jlong) = 0; + virtual void mark() = 0; + virtual void reset() = 0; + virtual void flushBefore(jlong) = 0; + virtual void flush() = 0; + virtual jlong getFlushedPosition() = 0; + virtual jboolean isCached() = 0; + virtual jboolean isCachedMemory() = 0; + virtual jboolean isCachedFile() = 0; + virtual void close() = 0; + static ::java::lang::Class class$; +} __attribute__ ((java_interface)); + +#endif // __javax_imageio_stream_ImageInputStream__ diff --git a/libjava/javax/imageio/stream/ImageInputStreamImpl.h b/libjava/javax/imageio/stream/ImageInputStreamImpl.h new file mode 100644 index 000000000..42b2f1204 --- /dev/null +++ b/libjava/javax/imageio/stream/ImageInputStreamImpl.h @@ -0,0 +1,105 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_stream_ImageInputStreamImpl__ +#define __javax_imageio_stream_ImageInputStreamImpl__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace java + { + namespace nio + { + class ByteOrder; + } + } + namespace javax + { + namespace imageio + { + namespace stream + { + class IIOByteBuffer; + class ImageInputStreamImpl; + } + } + } +} + +class javax::imageio::stream::ImageInputStreamImpl : public ::java::lang::Object +{ + +public: + ImageInputStreamImpl(); +public: // actually protected + virtual void checkClosed(); +public: + virtual void close(); +public: // actually protected + virtual void finalize(); +public: + virtual void flush(); + virtual void flushBefore(jlong); + virtual jint getBitOffset(); + virtual ::java::nio::ByteOrder * getByteOrder(); + virtual jlong getFlushedPosition(); + virtual jlong getStreamPosition(); + virtual jboolean isCached(); + virtual jboolean isCachedFile(); + virtual jboolean isCachedMemory(); + virtual jlong length(); + virtual void mark(); + virtual jint read() = 0; + virtual jint read(JArray< jbyte > *, jint, jint) = 0; + virtual jint read(JArray< jbyte > *); + virtual jint readBit(); + virtual jlong readBits(jint); + virtual jboolean readBoolean(); + virtual jbyte readByte(); + virtual void readBytes(::javax::imageio::stream::IIOByteBuffer *, jint); + virtual jchar readChar(); + virtual jdouble readDouble(); + virtual jfloat readFloat(); + virtual void readFully(JArray< jbyte > *); + virtual void readFully(JArray< jbyte > *, jint, jint); + virtual void readFully(JArray< jchar > *, jint, jint); + virtual void readFully(JArray< jdouble > *, jint, jint); + virtual void readFully(JArray< jfloat > *, jint, jint); + virtual void readFully(JArray< jint > *, jint, jint); + virtual void readFully(JArray< jlong > *, jint, jint); + virtual void readFully(JArray< jshort > *, jint, jint); + virtual jint readInt(); + virtual ::java::lang::String * readLine(); + virtual jlong readLong(); + virtual jshort readShort(); + virtual jint readUnsignedByte(); + virtual jlong readUnsignedInt(); + virtual jint readUnsignedShort(); + virtual ::java::lang::String * readUTF(); + virtual void reset(); + virtual void seek(jlong); + virtual void setBitOffset(jint); + virtual void setByteOrder(::java::nio::ByteOrder *); + virtual jint skipBytes(jint); + virtual jlong skipBytes(jlong); +private: + void readFullyPrivate(JArray< jbyte > *, jint, jint); + jboolean __attribute__((aligned(__alignof__( ::java::lang::Object)))) closed; + ::java::util::Stack * markStack; +public: // actually package-private + JArray< jbyte > * buffer; +public: // actually protected + jint bitOffset; + ::java::nio::ByteOrder * byteOrder; + jlong flushedPos; + jlong streamPos; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_stream_ImageInputStreamImpl__ diff --git a/libjava/javax/imageio/stream/ImageOutputStream.h b/libjava/javax/imageio/stream/ImageOutputStream.h new file mode 100644 index 000000000..7557e0a67 --- /dev/null +++ b/libjava/javax/imageio/stream/ImageOutputStream.h @@ -0,0 +1,108 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_stream_ImageOutputStream__ +#define __javax_imageio_stream_ImageOutputStream__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace java + { + namespace nio + { + class ByteOrder; + } + } + namespace javax + { + namespace imageio + { + namespace stream + { + class IIOByteBuffer; + class ImageOutputStream; + } + } + } +} + +class javax::imageio::stream::ImageOutputStream : public ::java::lang::Object +{ + +public: + virtual void flushBefore(jlong) = 0; + virtual void write(JArray< jbyte > *) = 0; + virtual void write(JArray< jbyte > *, jint, jint) = 0; + virtual void write(jint) = 0; + virtual void writeBit(jint) = 0; + virtual void writeBits(jlong, jint) = 0; + virtual void writeBoolean(jboolean) = 0; + virtual void writeByte(jint) = 0; + virtual void writeBytes(::java::lang::String *) = 0; + virtual void writeChar(jint) = 0; + virtual void writeChars(JArray< jchar > *, jint, jint) = 0; + virtual void writeChars(::java::lang::String *) = 0; + virtual void writeDouble(jdouble) = 0; + virtual void writeDoubles(JArray< jdouble > *, jint, jint) = 0; + virtual void writeFloat(jfloat) = 0; + virtual void writeFloats(JArray< jfloat > *, jint, jint) = 0; + virtual void writeInt(jint) = 0; + virtual void writeInts(JArray< jint > *, jint, jint) = 0; + virtual void writeLong(jlong) = 0; + virtual void writeLongs(JArray< jlong > *, jint, jint) = 0; + virtual void writeShort(jint) = 0; + virtual void writeShorts(JArray< jshort > *, jint, jint) = 0; + virtual void writeUTF(::java::lang::String *) = 0; + virtual void setByteOrder(::java::nio::ByteOrder *) = 0; + virtual ::java::nio::ByteOrder * getByteOrder() = 0; + virtual jint read() = 0; + virtual jint read(JArray< jbyte > *) = 0; + virtual jint read(JArray< jbyte > *, jint, jint) = 0; + virtual void readBytes(::javax::imageio::stream::IIOByteBuffer *, jint) = 0; + virtual jboolean readBoolean() = 0; + virtual jbyte readByte() = 0; + virtual jint readUnsignedByte() = 0; + virtual jshort readShort() = 0; + virtual jint readUnsignedShort() = 0; + virtual jchar readChar() = 0; + virtual jint readInt() = 0; + virtual jlong readUnsignedInt() = 0; + virtual jlong readLong() = 0; + virtual jfloat readFloat() = 0; + virtual jdouble readDouble() = 0; + virtual ::java::lang::String * readLine() = 0; + virtual ::java::lang::String * readUTF() = 0; + virtual void readFully(JArray< jbyte > *, jint, jint) = 0; + virtual void readFully(JArray< jbyte > *) = 0; + virtual void readFully(JArray< jshort > *, jint, jint) = 0; + virtual void readFully(JArray< jchar > *, jint, jint) = 0; + virtual void readFully(JArray< jint > *, jint, jint) = 0; + virtual void readFully(JArray< jlong > *, jint, jint) = 0; + virtual void readFully(JArray< jfloat > *, jint, jint) = 0; + virtual void readFully(JArray< jdouble > *, jint, jint) = 0; + virtual jlong getStreamPosition() = 0; + virtual jint getBitOffset() = 0; + virtual void setBitOffset(jint) = 0; + virtual jint readBit() = 0; + virtual jlong readBits(jint) = 0; + virtual jlong length() = 0; + virtual jint skipBytes(jint) = 0; + virtual jlong skipBytes(jlong) = 0; + virtual void seek(jlong) = 0; + virtual void mark() = 0; + virtual void reset() = 0; + virtual void flush() = 0; + virtual jlong getFlushedPosition() = 0; + virtual jboolean isCached() = 0; + virtual jboolean isCachedMemory() = 0; + virtual jboolean isCachedFile() = 0; + virtual void close() = 0; + static ::java::lang::Class class$; +} __attribute__ ((java_interface)); + +#endif // __javax_imageio_stream_ImageOutputStream__ diff --git a/libjava/javax/imageio/stream/ImageOutputStreamImpl.h b/libjava/javax/imageio/stream/ImageOutputStreamImpl.h new file mode 100644 index 000000000..a45df4698 --- /dev/null +++ b/libjava/javax/imageio/stream/ImageOutputStreamImpl.h @@ -0,0 +1,59 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_stream_ImageOutputStreamImpl__ +#define __javax_imageio_stream_ImageOutputStreamImpl__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace javax + { + namespace imageio + { + namespace stream + { + class ImageOutputStreamImpl; + } + } + } +} + +class javax::imageio::stream::ImageOutputStreamImpl : public ::javax::imageio::stream::ImageInputStreamImpl +{ + +public: + ImageOutputStreamImpl(); +public: // actually protected + virtual void flushBits(); +public: + virtual void write(JArray< jbyte > *); + virtual void write(JArray< jbyte > *, jint, jint) = 0; + virtual void write(jint) = 0; + virtual void writeBit(jint); + virtual void writeBits(jlong, jint); + virtual void writeBoolean(jboolean); + virtual void writeByte(jint); + virtual void writeBytes(::java::lang::String *); + virtual void writeChar(jint); + virtual void writeChars(JArray< jchar > *, jint, jint); + virtual void writeChars(::java::lang::String *); + virtual void writeDouble(jdouble); + virtual void writeDoubles(JArray< jdouble > *, jint, jint); + virtual void writeFloat(jfloat); + virtual void writeFloats(JArray< jfloat > *, jint, jint); + virtual void writeInt(jint); + virtual void writeInts(JArray< jint > *, jint, jint); + virtual void writeLong(jlong); + virtual void writeLongs(JArray< jlong > *, jint, jint); + virtual void writeShort(jint); + virtual void writeShorts(JArray< jshort > *, jint, jint); + virtual void writeUTF(::java::lang::String *); + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_stream_ImageOutputStreamImpl__ diff --git a/libjava/javax/imageio/stream/MemoryCacheImageInputStream.h b/libjava/javax/imageio/stream/MemoryCacheImageInputStream.h new file mode 100644 index 000000000..c83efe112 --- /dev/null +++ b/libjava/javax/imageio/stream/MemoryCacheImageInputStream.h @@ -0,0 +1,47 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_stream_MemoryCacheImageInputStream__ +#define __javax_imageio_stream_MemoryCacheImageInputStream__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace javax + { + namespace imageio + { + namespace stream + { + class MemoryCacheImageInputStream; + } + } + } +} + +class javax::imageio::stream::MemoryCacheImageInputStream : public ::javax::imageio::stream::ImageInputStreamImpl +{ + +public: + MemoryCacheImageInputStream(::java::io::InputStream *); + virtual void close(); + virtual void flushBefore(jlong); + virtual jboolean isCached(); + virtual jboolean isCachedFile(); + virtual jboolean isCachedMemory(); + virtual jint read(); + virtual jint read(JArray< jbyte > *, jint, jint); + virtual void seek(jlong); +private: + ::java::io::InputStream * __attribute__((aligned(__alignof__( ::javax::imageio::stream::ImageInputStreamImpl)))) stream; + ::java::io::BufferedInputStream * buffer; + jint READLIMIT; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_stream_MemoryCacheImageInputStream__ diff --git a/libjava/javax/imageio/stream/MemoryCacheImageOutputStream.h b/libjava/javax/imageio/stream/MemoryCacheImageOutputStream.h new file mode 100644 index 000000000..a7643c1ea --- /dev/null +++ b/libjava/javax/imageio/stream/MemoryCacheImageOutputStream.h @@ -0,0 +1,46 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __javax_imageio_stream_MemoryCacheImageOutputStream__ +#define __javax_imageio_stream_MemoryCacheImageOutputStream__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace javax + { + namespace imageio + { + namespace stream + { + class MemoryCacheImageOutputStream; + } + } + } +} + +class javax::imageio::stream::MemoryCacheImageOutputStream : public ::javax::imageio::stream::ImageOutputStreamImpl +{ + +public: + MemoryCacheImageOutputStream(::java::io::OutputStream *); + virtual void close(); + virtual void flushBefore(jlong); + virtual jboolean isCached(); + virtual jboolean isCachedFile(); + virtual jboolean isCachedMemory(); + virtual jint read(); + virtual jint read(JArray< jbyte > *, jint, jint); + virtual void write(JArray< jbyte > *, jint, jint); + virtual void write(jint); +private: + ::java::io::OutputStream * __attribute__((aligned(__alignof__( ::javax::imageio::stream::ImageOutputStreamImpl)))) stream; +public: + static ::java::lang::Class class$; +}; + +#endif // __javax_imageio_stream_MemoryCacheImageOutputStream__ -- cgit v1.2.3