1:
37:
38:
39: package ;
40:
41: import ;
42: import ;
43: import ;
44: import ;
45: import ;
46: import ;
47:
48: import ;
49: import ;
50: import ;
51:
52: import ;
53:
54: public abstract class ImageWriter
55: implements ImageTranscoder
56: {
57: private boolean aborted;
58:
59: protected Locale[] availableLocales;
60: protected Locale locale;
61: protected ImageWriterSpi originatingProvider;
62: protected Object output;
63: protected List progressListeners = new ArrayList();
64: protected List warningListeners = new ArrayList();
65: protected List warningLocales = new ArrayList();
66:
67: protected ImageWriter(ImageWriterSpi originatingProvider)
68: {
69: this.originatingProvider = originatingProvider;
70: }
71:
72: private void checkOutputSet()
73: {
74: if (output == null)
75: throw new IllegalStateException("no output set");
76: }
77:
78: public void abort()
79: {
80: aborted = true;
81: }
82:
83: protected boolean abortRequested()
84: {
85: return aborted;
86: }
87:
88: public void addIIOWriteProgressListener(IIOWriteProgressListener listener)
89: {
90: if (listener == null)
91: return;
92:
93: progressListeners.add(listener);
94: }
95:
96: public void addIIOWriteWarningListener (IIOWriteWarningListener listener)
97: {
98: if (listener == null)
99: return;
100:
101: warningListeners.add(listener);
102: }
103:
104: public boolean canInsertEmpty(int imageIndex)
105: throws IOException
106: {
107: checkOutputSet();
108: return false;
109: }
110:
111: public boolean canInsertImage(int imageIndex)
112: throws IOException
113: {
114: checkOutputSet();
115: return false;
116: }
117:
118: public boolean canRemoveImage(int imageIndex)
119: throws IOException
120: {
121: checkOutputSet();
122: return false;
123: }
124:
125: public boolean canReplaceImageMetadata(int imageIndex)
126: throws IOException
127: {
128: checkOutputSet();
129: return false;
130: }
131:
132: public boolean canReplacePixels(int imageIndex)
133: throws IOException
134: {
135: checkOutputSet();
136: return false;
137: }
138:
139: public boolean canReplaceStreamMetadata()
140: throws IOException
141: {
142: checkOutputSet();
143: return false;
144: }
145:
146: public boolean canWriteEmpty()
147: throws IOException
148: {
149: checkOutputSet();
150: return false;
151: }
152:
153: public boolean canWriteRasters()
154: {
155: return false;
156: }
157:
158: public boolean canWriteSequence()
159: {
160: return false;
161: }
162:
163: protected void clearAbortRequest()
164: {
165: aborted = false;
166: }
167:
168: public abstract IIOMetadata convertImageMetadata (IIOMetadata inData,
169: ImageTypeSpecifier imageType,
170: ImageWriteParam param);
171:
172: public abstract IIOMetadata convertStreamMetadata (IIOMetadata inData,
173: ImageWriteParam param);
174:
175: public void dispose()
176: {
177:
178: }
179:
180: public Locale[] getAvailableLocales()
181: {
182: return availableLocales;
183: }
184:
185: public abstract IIOMetadata getDefaultImageMetadata (ImageTypeSpecifier imageType, ImageWriteParam param);
186:
187: public abstract IIOMetadata getDefaultStreamMetadata (ImageWriteParam param);
188:
189: public ImageWriteParam getDefaultWriteParam()
190: {
191: return new ImageWriteParam(getLocale());
192: }
193:
194: public Locale getLocale()
195: {
196: return locale;
197: }
198:
199: public int getNumThumbnailsSupported (ImageTypeSpecifier imageType, ImageWriteParam param,
200: IIOMetadata streamMetadata, IIOMetadata imageMetadata)
201: {
202: return 0;
203: }
204:
205: public ImageWriterSpi getOriginatingProvider()
206: {
207: return originatingProvider;
208: }
209:
210: public Object getOutput()
211: {
212: return output;
213: }
214:
215: public Dimension[] getPreferredThumbnailSizes (ImageTypeSpecifier imageType,
216: ImageWriteParam param,
217: IIOMetadata streamMetadata,
218: IIOMetadata imageMetadata)
219: {
220: return null;
221: }
222:
223: protected void processImageComplete()
224: {
225: Iterator it = progressListeners.iterator();
226:
227: while (it.hasNext())
228: {
229: IIOWriteProgressListener listener = (IIOWriteProgressListener) it.next();
230: listener.imageComplete(this);
231: }
232: }
233:
234: protected void processImageProgress(float percentageDone)
235: {
236: Iterator it = progressListeners.iterator();
237:
238: while (it.hasNext())
239: {
240: IIOWriteProgressListener listener = (IIOWriteProgressListener) it.next();
241: listener.imageProgress(this, percentageDone);
242: }
243: }
244:
245: protected void processImageStarted(int imageIndex)
246: {
247: Iterator it = progressListeners.iterator();
248:
249: while (it.hasNext())
250: {
251: IIOWriteProgressListener listener = (IIOWriteProgressListener) it.next();
252: listener.imageStarted(this, imageIndex);
253: }
254: }
255:
256: protected void processThumbnailComplete()
257: {
258: Iterator it = progressListeners.iterator();
259:
260: while (it.hasNext())
261: {
262: IIOWriteProgressListener listener = (IIOWriteProgressListener) it.next();
263: listener.thumbnailComplete(this);
264: }
265: }
266:
267: protected void processThumbnailProgress(float percentageDone)
268: {
269: Iterator it = progressListeners.iterator();
270:
271: while (it.hasNext())
272: {
273: IIOWriteProgressListener listener = (IIOWriteProgressListener) it.next();
274: listener.thumbnailProgress(this, percentageDone);
275: }
276: }
277:
278: protected void processThumbnailStarted(int imageIndex, int thumbnailIndex)
279: {
280: Iterator it = progressListeners.iterator();
281:
282: while (it.hasNext())
283: {
284: IIOWriteProgressListener listener = (IIOWriteProgressListener) it.next();
285: listener.thumbnailStarted(this, imageIndex, thumbnailIndex);
286: }
287: }
288:
289: protected void processWarningOccurred(int imageIndex, String warning)
290: {
291: Iterator it = warningListeners.iterator();
292:
293: while (it.hasNext())
294: {
295: IIOWriteWarningListener listener = (IIOWriteWarningListener) it.next();
296: listener.warningOccurred(this, imageIndex, warning);
297: }
298: }
299:
300: protected void processWriteAborted()
301: {
302: Iterator it = progressListeners.iterator();
303:
304: while (it.hasNext())
305: {
306: IIOWriteProgressListener listener = (IIOWriteProgressListener) it.next();
307: listener.writeAborted(this);
308: }
309: }
310:
311: public void removeAllIIOWriteProgressListeners()
312: {
313: progressListeners.clear();
314: }
315:
316: public void removeAllIIOWriteWarningListeners()
317: {
318: progressListeners.clear();
319: }
320:
321: public void removeIIOWriteProgressListener (IIOWriteProgressListener listener)
322: {
323: if (listener == null)
324: return;
325:
326: progressListeners.remove(listener);
327: }
328:
329: public void removeIIOWriteWarningListener (IIOWriteWarningListener listener)
330: {
331: if (listener == null)
332: return;
333:
334: warningListeners.remove(listener);
335: }
336:
337: public void reset()
338: {
339: setOutput(null);
340: setLocale(null);
341: removeAllIIOWriteWarningListeners();
342: removeAllIIOWriteProgressListeners();
343: clearAbortRequest();
344: }
345:
346: public void setLocale(Locale locale)
347: {
348: if (locale != null)
349: {
350:
351: boolean found = false;
352:
353: if (availableLocales != null)
354: for (int i = availableLocales.length - 1; i >= 0; --i)
355: if (availableLocales[i].equals(locale))
356: found = true;
357:
358: if (! found)
359: throw new IllegalArgumentException("looale not available");
360: }
361:
362: this.locale = locale;
363: }
364:
365: public void setOutput(Object output)
366: {
367: if (output != null)
368: {
369:
370: boolean found = false;
371: Class[] types = null;
372:
373: if (originatingProvider != null)
374: types = originatingProvider.getOutputTypes();
375:
376: if (types != null)
377: for (int i = types.length - 1; i >= 0; --i)
378: if (types[i].isInstance(output))
379: found = true;
380:
381: if (! found)
382: throw new IllegalArgumentException("output type not available");
383: }
384:
385: this.output = output;
386: }
387:
388: public abstract void write (IIOMetadata streamMetadata, IIOImage image, ImageWriteParam param)
389: throws IOException;
390: }