blob: 2d47c35ccc2c4e658971a7328eec16f0a923f20b (
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
|
/*
* $Id$
* Copyright (C) 2002 The Apache Software Foundation. All rights reserved.
* For details on use and redistribution please refer to the
* LICENSE file included with these sources.
*/
package org.apache.fop.layoutmgr;
/**
* This class is used to pass information to the getNextBreakPoss()
* method. It is set up by higher level LM and used by lower level LM.
*/
public class LayoutContext {
/**
* Values for flags.
*/
public static final int LINEBREAK_AT_LF_ONLY = 0x01;
/** Generated break possibility is first in a new area */
public static final int NEW_AREA = 0x02;
public static final int IPD_UNKNOWN = 0x04;
/** Signal to a Line LM that a higher level LM may provoke a change
* in the reference area, thus ref area IPD. The LineLM should return
* without looking for a line break.
*/
public static final int CHECK_REF_AREA = 0x08;
/**
* If this flag is set, it indicates that any leading fo:character
* objects with suppress-at-line-break="suppress" should not generate
* areas. This is the case at the beginning of each new LineArea
* except the first.
*/
public static final int SUPPRESS_LEADING_SPACE = 0x10;
public static final int FIRST_AREA = 0x20;
public static final int TRY_HYPHENATE = 0x40;
public static final int LAST_AREA = 0x80;
public static final int RESOLVE_LEADING_SPACE = 0x100;
public int flags; // Contains some set of flags defined above
/**
* Total available stacking dimension for a "galley-level" layout
* manager (Line or Flow). It is passed by the parent LM. For LineLM,
* the block LM determines this based on indent properties.
* These LM <b>may</b> wish to pass this information down to lower
* level LM to allow them to optimize returned break possibilities.
*/
MinOptMax stackLimit;
/** True if current top-level reference area is spanning. */
boolean bIsSpan;
/** inline-progression-dimension of nearest ancestor reference area */
int refIPD;
/** Current pending space-after or space-end from preceding area */
SpaceSpecifier trailingSpace;
/** Current pending space-before or space-start from ancestor areas */
SpaceSpecifier leadingSpace;
/** Current hyphenation context. May be null. */
private HyphContext hyphContext = null;
/** Stretch or shrink value when making areas. */
private double ipdAdjust = 0.0;
/** Stretch or shrink value when adding spaces. */
private double dSpaceAdjust = 0.0;
private int iLineHeight;
private int iBaseline;
public LayoutContext(LayoutContext parentLC) {
this.flags = parentLC.flags;
this.refIPD = parentLC.refIPD;
this.stackLimit = null; // Don't reference parent MinOptMax!
this.leadingSpace = parentLC.leadingSpace; //???
this.trailingSpace = parentLC.trailingSpace; //???
this.hyphContext = parentLC.hyphContext;
this.dSpaceAdjust = parentLC.dSpaceAdjust;
this.iLineHeight = parentLC.iLineHeight;
this.iBaseline = parentLC.iBaseline;
// Copy other fields as necessary. Use clone???
}
public LayoutContext(int flags) {
this.flags = flags;
this.refIPD = 0;
stackLimit = new MinOptMax(0);
leadingSpace = null;
trailingSpace = null;
}
public void setFlags(int flags) {
setFlags(flags, true);
}
public void setFlags(int flags, boolean bSet) {
if (bSet) {
this.flags |= flags;
} else {
this.flags &= ~flags;
}
}
public void unsetFlags(int flags) {
setFlags(flags, false);
}
public boolean isStart() {
return ((this.flags & NEW_AREA) != 0);
}
public boolean startsNewArea() {
return ((this.flags & NEW_AREA) != 0 && leadingSpace != null);
}
public boolean isFirstArea() {
return ((this.flags & FIRST_AREA) != 0);
}
public boolean isLastArea() {
return ((this.flags & LAST_AREA) != 0);
}
public boolean suppressLeadingSpace() {
return ((this.flags & SUPPRESS_LEADING_SPACE) != 0);
}
public void setLeadingSpace(SpaceSpecifier space) {
leadingSpace = space;
}
public SpaceSpecifier getLeadingSpace() {
return leadingSpace;
}
public boolean resolveLeadingSpace() {
return ((this.flags & RESOLVE_LEADING_SPACE) != 0);
}
public void setTrailingSpace(SpaceSpecifier space) {
trailingSpace = space;
}
public SpaceSpecifier getTrailingSpace() {
return trailingSpace;
}
public void setStackLimit(MinOptMax limit) {
stackLimit = limit;
}
public MinOptMax getStackLimit() {
return stackLimit;
}
public void setRefIPD(int ipd) {
refIPD = ipd;
}
public int getRefIPD() {
return refIPD;
}
public void setHyphContext(HyphContext hyph) {
hyphContext = hyph;
}
public HyphContext getHyphContext() {
return hyphContext;
}
public boolean tryHyphenate() {
return ((this.flags & TRY_HYPHENATE) != 0);
}
public void setSpaceAdjust(double adjust) {
dSpaceAdjust = adjust;
}
public double getSpaceAdjust() {
return dSpaceAdjust;
}
public void setIPDAdjust(double ipdA) {
ipdAdjust = ipdA;
}
public double getIPDAdjust() {
return ipdAdjust;
}
public void setLineHeight(int lh) {
iLineHeight = lh;
}
public int getLineHeight() {
return iLineHeight;
}
public void setBaseline(int bl) {
iBaseline = bl;
}
public int getBaseline() {
return iBaseline;
}
}
|
