summaryrefslogtreecommitdiffstats
path: root/awt/javax/imageio/metadata/IIOMetadata.java
blob: 96cebf98d63bfb4481d527307253d3e3dd202b87 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

package javax.imageio.metadata;

import java.util.ArrayList;

import org.apache.harmony.x.imageio.metadata.IIOMetadataUtils;
import org.w3c.dom.Node;

/**
 * The class IIOMetadata represents the metadata (bundled with an image) as a
 * Dom-type tree.
 * 
 * @since Android 1.0
 */
public abstract class IIOMetadata {

    /**
     * Whether the standard metadata format is supported.
     */
    protected boolean standardFormatSupported;

    /**
     * The native metadata format name.
     */
    protected String nativeMetadataFormatName;

    /**
     * The native metadata format class name.
     */
    protected String nativeMetadataFormatClassName;

    /**
     * The extra metadata format names.
     */
    protected String[] extraMetadataFormatNames;

    /**
     * The extra metadata format class names.
     */
    protected String[] extraMetadataFormatClassNames;

    /**
     * The default controller.
     */
    protected IIOMetadataController defaultController;

    /**
     * The controller.
     */
    protected IIOMetadataController controller;

    /**
     * Instantiates a new IIOMetadata with no data set.
     */
    protected IIOMetadata() {
    }

    /**
     * Instantiates a new IIOMetadata with the specified data parameters.
     * 
     * @param standardMetadataFormatSupported
     *            whether the standard metadata format is supported.
     * @param nativeMetadataFormatName
     *            the native metadata format name.
     * @param nativeMetadataFormatClassName
     *            the native metadata format class name.
     * @param extraMetadataFormatNames
     *            the extra metadata format names.
     * @param extraMetadataFormatClassNames
     *            the extra metadata format class names.
     */
    protected IIOMetadata(boolean standardMetadataFormatSupported, String nativeMetadataFormatName,
            String nativeMetadataFormatClassName, String[] extraMetadataFormatNames,
            String[] extraMetadataFormatClassNames) {
        standardFormatSupported = standardMetadataFormatSupported;
        this.nativeMetadataFormatName = nativeMetadataFormatName;
        this.nativeMetadataFormatClassName = nativeMetadataFormatClassName;
        if (extraMetadataFormatNames == null) {
            if (extraMetadataFormatClassNames != null) {
                throw new IllegalArgumentException(
                        "extraMetadataFormatNames == null && extraMetadataFormatClassNames != null!");
            }
        } else {
            if (extraMetadataFormatClassNames == null) {
                throw new IllegalArgumentException(
                        "extraMetadataFormatNames != null && extraMetadataFormatClassNames == null!");
            }
            if (extraMetadataFormatNames.length == 0) {
                throw new IllegalArgumentException("extraMetadataFormatNames.length == 0!");
            }
            if (extraMetadataFormatClassNames.length != extraMetadataFormatNames.length) {
                throw new IllegalArgumentException(
                        "extraMetadataFormatClassNames.length != extraMetadataFormatNames.length!");
            }
            this.extraMetadataFormatNames = extraMetadataFormatNames.clone();
            this.extraMetadataFormatClassNames = extraMetadataFormatClassNames.clone();
        }
    }

    /**
     * Gets the metadata as tree-type document.
     * 
     * @param formatName
     *            the format name.
     * @return the node in tree format.
     */
    public abstract Node getAsTree(String formatName);

    /**
     * Checks if the metadata is read only.
     * 
     * @return true, if the metadata is read only.
     */
    public abstract boolean isReadOnly();

    /**
     * Merges the specified tree with this metadata tree.
     * 
     * @param formatName
     *            the format of the specified tree.
     * @param root
     *            the root node of the metadata tree.
     * @throws IIOInvalidTreeException
     *             if the specified tree is incompatible with the this metadata
     *             tree.
     */
    public abstract void mergeTree(String formatName, Node root) throws IIOInvalidTreeException;

    /**
     * Resets the controller.
     */
    public abstract void reset();

    /**
     * Gets the controller associated with this metadata document.
     * 
     * @return the controller.
     */
    public IIOMetadataController getController() {
        return controller;
    }

    /**
     * Checks whether this metadata has a controller.
     * 
     * @return true, if this metadata has a controller.
     */
    public boolean hasController() {
        return getController() != null;
    }

    /**
     * Activate the controller.
     * 
     * @return true, if successful.
     */
    public boolean activateController() {
        if (!hasController()) {
            throw new IllegalStateException("hasController() == false!");
        }
        return getController().activate(this);
    }

    /**
     * Gets the default controller.
     * 
     * @return the default controller.
     */
    public IIOMetadataController getDefaultController() {
        return defaultController;
    }

    /**
     * Gets the extra metadata format names.
     * 
     * @return the extra metadata format names.
     */
    public String[] getExtraMetadataFormatNames() {
        return extraMetadataFormatNames == null ? null : extraMetadataFormatNames.clone();
    }

    /**
     * Gets the metadata format.
     * 
     * @param formatName
     *            the format name.
     * @return the metadata format.
     */
    public IIOMetadataFormat getMetadataFormat(String formatName) {
        return IIOMetadataUtils.instantiateMetadataFormat(formatName, standardFormatSupported,
                nativeMetadataFormatName, nativeMetadataFormatClassName, extraMetadataFormatNames,
                extraMetadataFormatClassNames);
    }

    /**
     * Gets the native metadata format name.
     * 
     * @return the native metadata format name.
     */
    public String getNativeMetadataFormatName() {
        return nativeMetadataFormatName;
    }

    /**
     * Checks if the standard metadata format is supported.
     * 
     * @return true, if the standard metadata format is supported.
     */
    public boolean isStandardMetadataFormatSupported() {
        return standardFormatSupported;
    }

    /**
     * Gets the metadata format names.
     * 
     * @return the metadata format names.
     */
    public String[] getMetadataFormatNames() {
        ArrayList<String> res = new ArrayList<String>();

        String nativeMetadataFormatName = getNativeMetadataFormatName();
        boolean standardFormatSupported = isStandardMetadataFormatSupported();
        String extraMetadataFormatNames[] = getExtraMetadataFormatNames();

        if (standardFormatSupported) {
            res.add(IIOMetadataFormatImpl.standardMetadataFormatName);
        }
        if (nativeMetadataFormatName != null) {
            res.add(nativeMetadataFormatName);
        }
        if (extraMetadataFormatNames != null) {
            for (String extraMetadataFormatName : extraMetadataFormatNames) {
                res.add(extraMetadataFormatName);
            }
        }

        return res.size() > 0 ? res.toArray(new String[0]) : null;
    }

    /**
     * Gets the standard chroma node.
     * 
     * @return the standard chroma node.
     */
    protected IIOMetadataNode getStandardChromaNode() {
        return null;
    }

    /**
     * Gets the standard compression node.
     * 
     * @return the standard compression node.
     */
    protected IIOMetadataNode getStandardCompressionNode() {
        return null;
    }

    /**
     * Gets the standard data node.
     * 
     * @return the standard data node.
     */
    protected IIOMetadataNode getStandardDataNode() {
        return null;
    }

    /**
     * Gets the standard dimension node.
     * 
     * @return the standard dimension node.
     */
    protected IIOMetadataNode getStandardDimensionNode() {
        return null;
    }

    /**
     * Gets the standard document node.
     * 
     * @return the standard document node.
     */
    protected IIOMetadataNode getStandardDocumentNode() {
        return null;
    }

    /**
     * Gets the standard text node.
     * 
     * @return the standard text node.
     */
    protected IIOMetadataNode getStandardTextNode() {
        return null;
    }

    /**
     * Gets the standard tile node.
     * 
     * @return the standard tile node.
     */
    protected IIOMetadataNode getStandardTileNode() {
        return null;
    }

    /**
     * Gets the standard transparency node.
     * 
     * @return the standard transparency node.
     */
    protected IIOMetadataNode getStandardTransparencyNode() {
        return null;
    }

    /**
     * Gets the metadata as a tree in standard format.
     * 
     * @return the metadata as a tree in standard format.
     */
    protected final IIOMetadataNode getStandardTree() {
        // Create root node
        IIOMetadataNode root = new IIOMetadataNode(IIOMetadataFormatImpl.standardMetadataFormatName);

        Node node;
        if ((node = getStandardChromaNode()) != null) {
            root.appendChild(node);
        }
        if ((node = getStandardCompressionNode()) != null) {
            root.appendChild(node);
        }
        if ((node = getStandardDataNode()) != null) {
            root.appendChild(node);
        }
        if ((node = getStandardDimensionNode()) != null) {
            root.appendChild(node);
        }
        if ((node = getStandardDocumentNode()) != null) {
            root.appendChild(node);
        }
        if ((node = getStandardTextNode()) != null) {
            root.appendChild(node);
        }
        if ((node = getStandardTileNode()) != null) {
            root.appendChild(node);
        }
        if ((node = getStandardTransparencyNode()) != null) {
            root.appendChild(node);
        }

        return root;
    }

    /**
     * Sets the controller.
     * 
     * @param controller
     *            the new controller.
     */
    public void setController(IIOMetadataController controller) {
        this.controller = controller;
    }

    /**
     * Sets the from tree.
     * 
     * @param formatName
     *            the name of the metatdata format of the from tree.
     * @param root
     *            the root node of the from tree.
     * @throws IIOInvalidTreeException
     *             if the tree or its format is not compatible with this
     *             metadata.
     */
    public void setFromTree(String formatName, Node root) throws IIOInvalidTreeException {
        reset();
        mergeTree(formatName, root);
    }
}