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
|
/*
* 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.
*/
/* $Id$ */
package org.apache.fop.render.afp.modca;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Iterator;
import org.apache.fop.render.afp.Streamable;
/**
* The document is the highest level of the MO:DCA data-stream document
* component hierarchy. Documents can be made up of pages, and the pages, which
* are at the intermediate level, can be made up of objects. Objects are at the
* lowest level, and can be bar codes, graphics, images, and presentation text.
*
* At each level of the hierarchy certain sets of MO:DCA data structures, called
* structured fields, are permissible. The document, pages and objects are
* bounded by structured fields that define their beginnings and their ends.
* These structured fields, called begin-end pairs, provide an envelope for the
* data-stream components. This feature enables a processor of the data stream
* that is not fully compliant with the architecture to bypass those objects
* that are beyond its scope, and to process the data stream to the best of its
* abilities.
*
* A presentation document is one that has been formatted and is intended for
* presentation, usually on a printer or display device. A data stream
* containing a presentation document should produce the same document content
* in the same format on different printers or display devices dependent,
* however, on the capabilities of each of the printers or display devices. A
* presentation document can reference resources that are to be included as part
* of the document to be presented.
*
*/
public final class Document extends AbstractResourceEnvironmentGroupContainer implements Streamable {
/** The document started state */
private boolean started = false;
/** The document completion state */
private boolean complete = false;
/**
* Constructor for the document object.
*
* @param factory
* the object factory
* @param name
* the name of the document
*/
public Document(Factory factory, String name) {
super(factory, name);
}
/**
* Method to mark the end of the page group.
*/
public void endDocument() {
complete = true;
}
/**
* Returns an indication if the page group is complete
*
* @return whether or not this page group is complete
*/
public boolean isComplete() {
return complete;
}
/** {@inheritDoc} */
protected void writeStart(OutputStream os) throws IOException {
byte[] data = new byte[17];
copySF(data, Type.BEGIN, Category.DOCUMENT);
os.write(data);
}
/** {@inheritDoc} */
protected void writeEnd(OutputStream os) throws IOException {
byte[] data = new byte[17];
copySF(data, Type.END, Category.DOCUMENT);
os.write(data);
}
/** {@inheritDoc} */
public String toString() {
return this.name;
}
/** {@inheritDoc} */
public void writeToStream(OutputStream os) throws IOException {
if (!started) {
writeStart(os);
started = true;
}
Iterator it = objects.iterator();
while (it.hasNext()) {
AbstractAFPObject ao = (AbstractAFPObject)it.next();
if (ao instanceof PageGroup && ((PageGroup)ao).isComplete()
|| ao instanceof PageObject && ((PageObject)ao).isComplete()) {
ao.writeToStream(os);
it.remove();
} else {
break;
}
}
if (complete) {
writeEnd(os);
}
}
}
|
