• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  *
3  * (C) Copyright IBM Corp. 1998-2007 - All Rights Reserved
4  *
5  */
6 
7 #ifndef __GLYPHPOSITIONADJUSTMENTS_H
8 #define __GLYPHPOSITIONADJUSTMENTS_H
9 
10 /**
11  * \file
12  * \internal
13  */
14 
15 #include "LETypes.h"
16 #include "OpenTypeTables.h"
17 
18 U_NAMESPACE_BEGIN
19 
20 class LEGlyphStorage;
21 class LEFontInstance;
22 
23 class GlyphPositionAdjustments : public UMemory
24 {
25 private:
26     class Adjustment : public UMemory {
27     public:
28 
29         inline Adjustment();
30         inline Adjustment(float xPlace, float yPlace, float xAdv, float yAdv, le_int32 baseOff = -1);
31         inline ~Adjustment();
32 
33         inline float    getXPlacement() const;
34         inline float    getYPlacement() const;
35         inline float    getXAdvance() const;
36         inline float    getYAdvance() const;
37 
38         inline le_int32 getBaseOffset() const;
39 
40         inline void     setXPlacement(float newXPlacement);
41         inline void     setYPlacement(float newYPlacement);
42         inline void     setXAdvance(float newXAdvance);
43         inline void     setYAdvance(float newYAdvance);
44 
45         inline void     setBaseOffset(le_int32 newBaseOffset);
46 
47         inline void    adjustXPlacement(float xAdjustment);
48         inline void    adjustYPlacement(float yAdjustment);
49         inline void    adjustXAdvance(float xAdjustment);
50         inline void    adjustYAdvance(float yAdjustment);
51 
52     private:
53         float xPlacement;
54         float yPlacement;
55         float xAdvance;
56         float yAdvance;
57 
58         le_int32 baseOffset;
59 
60         // allow copying of this class because all of its fields are simple types
61     };
62 
63     class EntryExitPoint : public UMemory
64     {
65     public:
66         inline EntryExitPoint();
67         inline ~EntryExitPoint();
68 
69         inline le_bool isCursiveGlyph() const;
70         inline le_bool baselineIsLogicalEnd() const;
71 
72         LEPoint *getEntryPoint(LEPoint &entryPoint) const;
73         LEPoint *getExitPoint(LEPoint &exitPoint) const;
74 
75         inline void clearEntryPoint();
76         inline void clearExitPoint();
77         inline void setEntryPoint(LEPoint &newEntryPoint, le_bool baselineIsLogicalEnd);
78         inline void setExitPoint(LEPoint &newExitPoint, le_bool baselineIsLogicalEnd);
79         inline void setCursiveGlyph(le_bool baselineIsLogicalEnd);
80 
81     private:
82         enum EntryExitFlags
83         {
84             EEF_HAS_ENTRY_POINT         = 0x80000000L,
85             EEF_HAS_EXIT_POINT          = 0x40000000L,
86             EEF_IS_CURSIVE_GLYPH        = 0x20000000L,
87             EEF_BASELINE_IS_LOGICAL_END = 0x10000000L
88         };
89 
90         le_uint32 fFlags;
91         LEPoint fEntryPoint;
92         LEPoint fExitPoint;
93     };
94 
95     le_int32 fGlyphCount;
96     EntryExitPoint *fEntryExitPoints;
97     Adjustment *fAdjustments;
98 
99     GlyphPositionAdjustments();
100 
101 public:
102     GlyphPositionAdjustments(le_int32 glyphCount);
103     ~GlyphPositionAdjustments();
104 
105     inline le_bool hasCursiveGlyphs() const;
106     inline le_bool isCursiveGlyph(le_int32 index) const;
107     inline le_bool baselineIsLogicalEnd(le_int32 index) const;
108 
109     const LEPoint *getEntryPoint(le_int32 index, LEPoint &entryPoint) const;
110     const LEPoint *getExitPoint(le_int32 index, LEPoint &exitPoint) const;
111 
112     inline float getXPlacement(le_int32 index) const;
113     inline float getYPlacement(le_int32 index) const;
114     inline float getXAdvance(le_int32 index) const;
115     inline float getYAdvance(le_int32 index) const;
116 
117     inline le_int32 getBaseOffset(le_int32 index) const;
118 
119     inline void setXPlacement(le_int32 index, float newXPlacement);
120     inline void setYPlacement(le_int32 index, float newYPlacement);
121     inline void setXAdvance(le_int32 index, float newXAdvance);
122     inline void setYAdvance(le_int32 index, float newYAdvance);
123 
124     inline void setBaseOffset(le_int32 index, le_int32 newBaseOffset);
125 
126     inline void adjustXPlacement(le_int32 index, float xAdjustment);
127     inline void adjustYPlacement(le_int32 index, float yAdjustment);
128     inline void adjustXAdvance(le_int32 index, float xAdjustment);
129     inline void adjustYAdvance(le_int32 index, float yAdjustment);
130 
131     void clearEntryPoint(le_int32 index);
132     void clearExitPoint(le_int32 index);
133     void setEntryPoint(le_int32 index, LEPoint &newEntryPoint, le_bool baselineIsLogicalEnd);
134     void setExitPoint(le_int32 index, LEPoint &newExitPoint, le_bool baselineIsLogicalEnd);
135     void setCursiveGlyph(le_int32 index, le_bool baselineIsLogicalEnd);
136 
137     void applyCursiveAdjustments(LEGlyphStorage &glyphStorage, le_bool rightToLeft, const LEFontInstance *fontInstance);
138 };
139 
Adjustment()140 inline GlyphPositionAdjustments::Adjustment::Adjustment()
141   : xPlacement(0), yPlacement(0), xAdvance(0), yAdvance(0), baseOffset(-1)
142 {
143     // nothing else to do!
144 }
145 
Adjustment(float xPlace,float yPlace,float xAdv,float yAdv,le_int32 baseOff)146 inline GlyphPositionAdjustments::Adjustment::Adjustment(float xPlace, float yPlace, float xAdv, float yAdv, le_int32 baseOff)
147   : xPlacement(xPlace), yPlacement(yPlace), xAdvance(xAdv), yAdvance(yAdv), baseOffset(baseOff)
148 {
149     // nothing else to do!
150 }
151 
~Adjustment()152 inline GlyphPositionAdjustments::Adjustment::~Adjustment()
153 {
154     // nothing to do!
155 }
156 
getXPlacement()157 inline float GlyphPositionAdjustments::Adjustment::getXPlacement() const
158 {
159     return xPlacement;
160 }
161 
getYPlacement()162 inline float GlyphPositionAdjustments::Adjustment::getYPlacement() const
163 {
164     return yPlacement;
165 }
166 
getXAdvance()167 inline float GlyphPositionAdjustments::Adjustment::getXAdvance() const
168 {
169     return xAdvance;
170 }
171 
getYAdvance()172 inline float GlyphPositionAdjustments::Adjustment::getYAdvance() const
173 {
174     return yAdvance;
175 }
176 
getBaseOffset()177 inline le_int32 GlyphPositionAdjustments::Adjustment::getBaseOffset() const
178 {
179     return baseOffset;
180 }
181 
setXPlacement(float newXPlacement)182 inline void GlyphPositionAdjustments::Adjustment::setXPlacement(float newXPlacement)
183 {
184     xPlacement = newXPlacement;
185 }
186 
setYPlacement(float newYPlacement)187 inline void GlyphPositionAdjustments::Adjustment::setYPlacement(float newYPlacement)
188 {
189     yPlacement = newYPlacement;
190 }
191 
setXAdvance(float newXAdvance)192 inline void GlyphPositionAdjustments::Adjustment::setXAdvance(float newXAdvance)
193 {
194     xAdvance = newXAdvance;
195 }
196 
setYAdvance(float newYAdvance)197 inline void GlyphPositionAdjustments::Adjustment::setYAdvance(float newYAdvance)
198 {
199     yAdvance = newYAdvance;
200 }
201 
setBaseOffset(le_int32 newBaseOffset)202 inline void GlyphPositionAdjustments::Adjustment::setBaseOffset(le_int32 newBaseOffset)
203 {
204     baseOffset = newBaseOffset;
205 }
206 
adjustXPlacement(float xAdjustment)207 inline void GlyphPositionAdjustments::Adjustment::adjustXPlacement(float xAdjustment)
208 {
209     xPlacement += xAdjustment;
210 }
211 
adjustYPlacement(float yAdjustment)212 inline void GlyphPositionAdjustments::Adjustment::adjustYPlacement(float yAdjustment)
213 {
214     yPlacement += yAdjustment;
215 }
216 
adjustXAdvance(float xAdjustment)217 inline void GlyphPositionAdjustments::Adjustment::adjustXAdvance(float xAdjustment)
218 {
219     xAdvance += xAdjustment;
220 }
221 
adjustYAdvance(float yAdjustment)222 inline void GlyphPositionAdjustments::Adjustment::adjustYAdvance(float yAdjustment)
223 {
224     yAdvance += yAdjustment;
225 }
226 
EntryExitPoint()227 inline GlyphPositionAdjustments::EntryExitPoint::EntryExitPoint()
228     : fFlags(0)
229 {
230     fEntryPoint.fX = fEntryPoint.fY = fExitPoint.fX = fExitPoint.fY = 0;
231 }
232 
~EntryExitPoint()233 inline GlyphPositionAdjustments::EntryExitPoint::~EntryExitPoint()
234 {
235     // nothing special to do
236 }
237 
isCursiveGlyph()238 inline le_bool GlyphPositionAdjustments::EntryExitPoint::isCursiveGlyph() const
239 {
240     return (fFlags & EEF_IS_CURSIVE_GLYPH) != 0;
241 }
242 
baselineIsLogicalEnd()243 inline le_bool GlyphPositionAdjustments::EntryExitPoint::baselineIsLogicalEnd() const
244 {
245     return (fFlags & EEF_BASELINE_IS_LOGICAL_END) != 0;
246 }
247 
clearEntryPoint()248 inline void GlyphPositionAdjustments::EntryExitPoint::clearEntryPoint()
249 {
250     fFlags &= ~EEF_HAS_ENTRY_POINT;
251 }
252 
clearExitPoint()253 inline void GlyphPositionAdjustments::EntryExitPoint::clearExitPoint()
254 {
255     fFlags &= ~EEF_HAS_EXIT_POINT;
256 }
257 
setEntryPoint(LEPoint & newEntryPoint,le_bool baselineIsLogicalEnd)258 inline void GlyphPositionAdjustments::EntryExitPoint::setEntryPoint(LEPoint &newEntryPoint, le_bool baselineIsLogicalEnd)
259 {
260     if (baselineIsLogicalEnd) {
261         fFlags |= (EEF_HAS_ENTRY_POINT | EEF_IS_CURSIVE_GLYPH | EEF_BASELINE_IS_LOGICAL_END);
262     } else {
263         fFlags |= (EEF_HAS_ENTRY_POINT | EEF_IS_CURSIVE_GLYPH);
264     }
265 
266     fEntryPoint = newEntryPoint;
267 }
268 
setExitPoint(LEPoint & newExitPoint,le_bool baselineIsLogicalEnd)269 inline void GlyphPositionAdjustments::EntryExitPoint::setExitPoint(LEPoint &newExitPoint, le_bool baselineIsLogicalEnd)
270 {
271     if (baselineIsLogicalEnd) {
272         fFlags |= (EEF_HAS_EXIT_POINT | EEF_IS_CURSIVE_GLYPH | EEF_BASELINE_IS_LOGICAL_END);
273     } else {
274         fFlags |= (EEF_HAS_EXIT_POINT | EEF_IS_CURSIVE_GLYPH);
275     }
276 
277     fExitPoint  = newExitPoint;
278 }
279 
setCursiveGlyph(le_bool baselineIsLogicalEnd)280 inline void GlyphPositionAdjustments::EntryExitPoint::setCursiveGlyph(le_bool baselineIsLogicalEnd)
281 {
282     if (baselineIsLogicalEnd) {
283         fFlags |= (EEF_IS_CURSIVE_GLYPH | EEF_BASELINE_IS_LOGICAL_END);
284     } else {
285         fFlags |= EEF_IS_CURSIVE_GLYPH;
286     }
287 }
288 
isCursiveGlyph(le_int32 index)289 inline le_bool GlyphPositionAdjustments::isCursiveGlyph(le_int32 index) const
290 {
291     return fEntryExitPoints != NULL && fEntryExitPoints[index].isCursiveGlyph();
292 }
293 
baselineIsLogicalEnd(le_int32 index)294 inline le_bool GlyphPositionAdjustments::baselineIsLogicalEnd(le_int32 index) const
295 {
296     return fEntryExitPoints != NULL && fEntryExitPoints[index].baselineIsLogicalEnd();
297 }
298 
getXPlacement(le_int32 index)299 inline float GlyphPositionAdjustments::getXPlacement(le_int32 index) const
300 {
301     return fAdjustments[index].getXPlacement();
302 }
303 
getYPlacement(le_int32 index)304 inline float GlyphPositionAdjustments::getYPlacement(le_int32 index) const
305 {
306     return fAdjustments[index].getYPlacement();
307 }
308 
getXAdvance(le_int32 index)309 inline float GlyphPositionAdjustments::getXAdvance(le_int32 index) const
310 {
311     return fAdjustments[index].getXAdvance();
312 }
313 
getYAdvance(le_int32 index)314 inline float GlyphPositionAdjustments::getYAdvance(le_int32 index) const
315 {
316     return fAdjustments[index].getYAdvance();
317 }
318 
319 
getBaseOffset(le_int32 index)320 inline le_int32 GlyphPositionAdjustments::getBaseOffset(le_int32 index) const
321 {
322     return fAdjustments[index].getBaseOffset();
323 }
324 
setXPlacement(le_int32 index,float newXPlacement)325 inline void GlyphPositionAdjustments::setXPlacement(le_int32 index, float newXPlacement)
326 {
327     fAdjustments[index].setXPlacement(newXPlacement);
328 }
329 
setYPlacement(le_int32 index,float newYPlacement)330 inline void GlyphPositionAdjustments::setYPlacement(le_int32 index, float newYPlacement)
331 {
332     fAdjustments[index].setYPlacement(newYPlacement);
333 }
334 
setXAdvance(le_int32 index,float newXAdvance)335 inline void GlyphPositionAdjustments::setXAdvance(le_int32 index, float newXAdvance)
336 {
337     fAdjustments[index].setXAdvance(newXAdvance);
338 }
339 
setYAdvance(le_int32 index,float newYAdvance)340 inline void GlyphPositionAdjustments::setYAdvance(le_int32 index, float newYAdvance)
341 {
342     fAdjustments[index].setYAdvance(newYAdvance);
343 }
344 
setBaseOffset(le_int32 index,le_int32 newBaseOffset)345 inline void GlyphPositionAdjustments::setBaseOffset(le_int32 index, le_int32 newBaseOffset)
346 {
347     fAdjustments[index].setBaseOffset(newBaseOffset);
348 }
349 
adjustXPlacement(le_int32 index,float xAdjustment)350 inline void GlyphPositionAdjustments::adjustXPlacement(le_int32 index, float xAdjustment)
351 {
352     fAdjustments[index].adjustXPlacement(xAdjustment);
353 }
354 
adjustYPlacement(le_int32 index,float yAdjustment)355 inline void GlyphPositionAdjustments::adjustYPlacement(le_int32 index, float yAdjustment)
356 {
357     fAdjustments[index].adjustYPlacement(yAdjustment);
358 }
359 
adjustXAdvance(le_int32 index,float xAdjustment)360 inline void GlyphPositionAdjustments::adjustXAdvance(le_int32 index, float xAdjustment)
361 {
362     fAdjustments[index].adjustXAdvance(xAdjustment);
363 }
364 
adjustYAdvance(le_int32 index,float yAdjustment)365 inline void GlyphPositionAdjustments::adjustYAdvance(le_int32 index, float yAdjustment)
366 {
367     fAdjustments[index].adjustYAdvance(yAdjustment);
368 }
369 
hasCursiveGlyphs()370 inline le_bool GlyphPositionAdjustments::hasCursiveGlyphs() const
371 {
372     return fEntryExitPoints != NULL;
373 }
374 
375 U_NAMESPACE_END
376 #endif
377