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
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
|
/*
* Copyright 1999-2005 The Apache Software Foundation.
*
* Licensed 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.area;
import java.awt.Rectangle;
import java.awt.geom.Rectangle2D;
import java.io.ObjectOutputStream;
import java.io.ObjectInputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.HashMap;
import java.util.Iterator;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.fop.fo.Constants;
import org.apache.fop.fo.pagination.SimplePageMaster;
/**
* Page viewport that specifies the viewport area and holds the page contents.
* This is the top level object for a page and remains valid for the life
* of the document and the area tree.
* This object may be used as a key to reference a page.
* This is the level that creates the page.
* The page (reference area) is then rendered inside the page object
*/
public class PageViewport implements Resolvable, Cloneable {
private Page page;
private Rectangle2D viewArea;
private boolean clip = false;
private String pageNumberString = null;
private SimplePageMaster spm = null;
// list of id references and the rectangle on the page
private Map idReferences = null;
// this keeps a list of currently unresolved areas or extensions
// once an idref is resolved it is removed
// when this is empty the page can be rendered
private HashMap unresolvedIDRefs = new HashMap();
private Map pendingResolved = null;
// hashmap of markers for this page
// start and end are added by the fo that contains the markers
private Map markerFirstStart = null;
private Map markerLastStart = null;
private Map markerFirstAny = null;
private Map markerLastEnd = null;
private Map markerLastAny = null;
/**
* logging instance
*/
protected static Log log = LogFactory.getLog(PageViewport.class);
/**
* Create a page viewport.
* @param spm SimplePageMaster indicating the page and region dimensions
*/
public PageViewport(SimplePageMaster spm, String pageStr) {
this.spm = spm;
int pageWidth = spm.getPageWidth().getValue();
int pageHeight = spm.getPageHeight().getValue();
pageNumberString = pageStr;
viewArea = new Rectangle(0, 0, pageWidth, pageHeight);
page = new Page(spm);
createSpan(false);
}
/**
* Create a page viewport
* @param spm SimplePageMaster indicating the page and region dimensions
* @param p Page Reference Area
* @param bounds Page Viewport dimensions
*/
public PageViewport(SimplePageMaster spm, String pageStr, Page p, Rectangle2D bounds) {
this.spm = spm;
this.pageNumberString = pageStr;
this.page = p;
this.viewArea = bounds;
}
/**
* Set if this viewport should clip.
* @param c true if this viewport should clip
*/
public void setClip(boolean c) {
clip = c;
}
/**
* Get the view area rectangle of this viewport.
* @return the rectangle for this viewport
*/
public Rectangle2D getViewArea() {
return viewArea;
}
/**
* Get the page reference area with the contents.
* @return the page reference area
*/
public Page getPage() {
return page;
}
/**
* Get the page number of this page.
* @return the string that represents this page
*/
public String getPageNumberString() {
return pageNumberString;
}
/**
* Get the key for this page viewport.
* This is used so that a serializable key can be used to
* lookup the page or some other reference.
*
* @return a unique page viewport key for this area tree
*/
public String getKey() {
return toString();
}
/**
* Add an idref to this page.
* All idrefs found for child areas of this PageViewport are added
* to unresolvedIDRefs, for subsequent resolution by AreaTreeHandler
* calls to this object's resolveIDRef().
*
* @param id the idref
* @param res the child element of this page that needs this
* idref resolved
*/
public void addUnresolvedIDRef(String idref, Resolvable res) {
if (unresolvedIDRefs == null) {
unresolvedIDRefs = new HashMap();
}
List list = (List)unresolvedIDRefs.get(idref);
if (list == null) {
list = new ArrayList();
unresolvedIDRefs.put(idref, list);
}
list.add(res);
}
/**
* Check if this page has been fully resolved.
* @return true if the page is resolved and can be rendered
*/
public boolean isResolved() {
return unresolvedIDRefs == null
|| unresolvedIDRefs.size() == 0;
}
/**
* Get the unresolved idrefs for this page.
* @return String array of idref's that still have not been resolved
*/
public String[] getIDRefs() {
return (unresolvedIDRefs == null) ? null :
(String[]) unresolvedIDRefs.keySet().toArray(new String[] {});
}
/**
* @see org.apache.fop.area.Resolveable#resolveIDRef(String, List)
*/
public void resolveIDRef(String id, List pages) {
if (page == null) {
if (pendingResolved == null) {
pendingResolved = new HashMap();
}
pendingResolved.put(id, pages);
} else {
if (unresolvedIDRefs != null) {
List todo = (List)unresolvedIDRefs.get(id);
if (todo != null) {
for (int count = 0; count < todo.size(); count++) {
Resolvable res = (Resolvable)todo.get(count);
res.resolveIDRef(id, pages);
}
}
}
}
if (unresolvedIDRefs != null && pages != null) {
unresolvedIDRefs.remove(id);
if (unresolvedIDRefs.isEmpty()) {
unresolvedIDRefs = null;
}
}
}
/**
* Add the markers for this page.
* Only the required markers are kept.
* For "first-starting-within-page" it adds the markers
* that are starting only if the marker class name is not
* already added.
* For "first-including-carryover" it adds any starting marker
* if the marker class name is not already added.
* For "last-starting-within-page" it adds all marks that
* are starting, replacing earlier markers.
* For "last-ending-within-page" it adds all markers that
* are ending, replacing earlier markers.
*
* Should this logic be placed in the Page layout manager.
*
* @param marks the map of markers to add
* @param starting if the area being added is starting or ending
* @param isfirst if the area being added has is-first trait
* @param islast if the area being added has is-last trait
*/
public void addMarkers(Map marks, boolean starting,
boolean isfirst, boolean islast) {
if (marks == null) {
return;
}
// at the start of the area, register is-first and any areas
if (starting) {
if (isfirst) {
if (markerFirstStart == null) {
markerFirstStart = new HashMap();
}
if (markerFirstAny == null) {
markerFirstAny = new HashMap();
}
// first on page: only put in new values, leave current
for (Iterator iter = marks.keySet().iterator(); iter.hasNext();) {
Object key = iter.next();
if (!markerFirstStart.containsKey(key)) {
markerFirstStart.put(key, marks.get(key));
log.trace("page " + pageNumberString + ": " + "Adding marker " + key + " to FirstStart");
}
if (!markerFirstAny.containsKey(key)) {
markerFirstAny.put(key, marks.get(key));
log.trace("page " + pageNumberString + ": " + "Adding marker " + key + " to FirstAny");
}
}
if (markerLastStart == null) {
markerLastStart = new HashMap();
}
// last on page: replace all
markerLastStart.putAll(marks);
log.trace("page " + pageNumberString + ": " + "Adding all markers to LastStart");
} else {
if (markerFirstAny == null) {
markerFirstAny = new HashMap();
}
// first on page: only put in new values, leave current
for (Iterator iter = marks.keySet().iterator(); iter.hasNext();) {
Object key = iter.next();
if (!markerFirstAny.containsKey(key)) {
markerFirstAny.put(key, marks.get(key));
log.trace("page " + pageNumberString + ": " + "Adding marker " + key + " to FirstAny");
}
}
}
}
// at the end of the area, register is-last and any areas
else {
if (islast) {
if (markerLastEnd == null) {
markerLastEnd = new HashMap();
}
// last on page: replace all
markerLastEnd.putAll(marks);
log.trace("page " + pageNumberString + ": " + "Adding all markers to LastEnd");
}
if (markerLastAny == null) {
markerLastAny = new HashMap();
}
// last on page: replace all
markerLastAny.putAll(marks);
log.trace("page " + pageNumberString + ": " + "Adding all markers to LastAny");
}
}
/**
* Get a marker from this page.
* This will retrieve a marker with the class name
* and position.
*
* @param name The class name of the marker to retrieve
* @param pos the position to retrieve
* @return Object the marker found or null
*/
public Object getMarker(String name, int pos) {
Object mark = null;
String posName = null;
switch (pos) {
case Constants.EN_FSWP:
if (markerFirstStart != null) {
mark = markerFirstStart.get(name);
posName = "FSWP";
}
if (mark == null && markerFirstAny != null) {
mark = markerFirstAny.get(name);
posName = "FirstAny after " + posName;
}
break;
case Constants.EN_FIC:
if (markerFirstAny != null) {
mark = markerFirstAny.get(name);
posName = "FIC";
}
break;
case Constants.EN_LSWP:
if (markerLastStart != null) {
mark = markerLastStart.get(name);
posName = "LSWP";
}
if (mark == null && markerLastAny != null) {
mark = markerLastAny.get(name);
posName = "LastAny after " + posName;
}
break;
case Constants.EN_LEWP:
if (markerLastEnd != null) {
mark = markerLastEnd.get(name);
posName = "LEWP";
}
if (mark == null && markerLastAny != null) {
mark = markerLastAny.get(name);
posName = "LastAny after " + posName;
}
break;
}
log.trace("page " + pageNumberString + ": " + "Retrieving marker " + name + "at position " + posName);
return mark;
}
/**
* Save the page contents to an object stream.
* The map of unresolved references are set on the page so that
* the resolvers can be properly serialized and reloaded.
* @param out the object output stream to write the contents
* @throws Exception if there is a problem saving the page
*/
public void savePage(ObjectOutputStream out) throws Exception {
// set the unresolved references so they are serialized
page.setUnresolvedReferences(unresolvedIDRefs);
out.writeObject(page);
page = null;
}
/**
* Load the page contents from an object stream.
* This loads the page contents from the stream and
* if there are any unresolved references that were resolved
* while saved they will be resolved on the page contents.
* @param in the object input stream to read the page from
* @throws Exception if there is an error loading the page
*/
public void loadPage(ObjectInputStream in) throws Exception {
page = (Page) in.readObject();
unresolvedIDRefs = page.getUnresolvedReferences();
if (unresolvedIDRefs != null && pendingResolved != null) {
for (Iterator iter = pendingResolved.keySet().iterator();
iter.hasNext();) {
String id = (String) iter.next();
resolveIDRef(id, (List)pendingResolved.get(id));
}
pendingResolved = null;
}
}
/**
* Clone this page.
* Used by the page master to create a copy of an original page.
* @return a copy of this page and associated viewports
*/
public Object clone() {
Page p = (Page)page.clone();
PageViewport ret = new PageViewport(spm, pageNumberString,
p, (Rectangle2D)viewArea.clone());
ret.pageNumberString = pageNumberString;
return ret;
}
/**
* Clear the page contents to save memory.
* This object is kept for the life of the area tree since
* it holds id and marker information and is used as a key.
*/
public void clear() {
page = null;
}
/**
* @see java.lang.Object#toString()
*/
public String toString() {
StringBuffer sb = new StringBuffer(64);
sb.append("PageViewport: page=");
sb.append(getPageNumberString());
return sb.toString();
}
/**
* @return Returns the spm.
*/
public SimplePageMaster getSPM() {
return spm;
}
/**
* Convenience method to get BodyRegion of this PageViewport
* @return BodyRegion object
*/
public BodyRegion getBodyRegion() {
return (BodyRegion) getPage().getRegionViewport(
Constants.FO_REGION_BODY).getRegionReference();
}
/**
* Convenience method to create a new Span for this
* this PageViewport.
*
* @param spanAll whether this is a single-column span
* @return Span object created
*/
public Span createSpan(boolean spanAll) {
return getBodyRegion().getMainReference().createSpan(spanAll);
}
/**
* Convenience method to get the span-reference-area currently
* being processed
*
* @return span currently being processed.
*/
public Span getCurrentSpan() {
return getBodyRegion().getMainReference().getCurrentSpan();
}
/**
* Convenience method to get the normal-flow-reference-area
* currently being processed
*
* @return span currently being processed.
*/
public NormalFlow getCurrentFlow() {
return getCurrentSpan().getCurrentFlow();
}
/**
* Convenience method to increment the Span to the
* next NormalFlow to be processed, and to return that flow.
*
* @return the next NormalFlow in the Span.
*/
public NormalFlow moveToNextFlow() {
return getCurrentSpan().moveToNextFlow();
}
/**
* Convenience method to return a given region-reference-area,
* keyed by the Constants class identifier for the corresponding
* formatting object (ie. Constants.FO_REGION_BODY, FO_REGION_START,
* etc.)
*
* @param id the Constants class identifier for the region.
* @return the corresponding region-reference-area for this page.
*/
public RegionReference getRegionReference(int id) {
return getPage().getRegionViewport(id).getRegionReference();
}
}
|