icuSources/layout/GlyphPositionAdjustments.h

   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
 140 inline GlyphPositionAdjustments::Adjustment::Adjustment()
 141   : xPlacement(0), yPlacement(0), xAdvance(0), yAdvance(0), baseOffset(-1)
 142 {
 143     // nothing else to do!
 144 }
 145
 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
 152 inline GlyphPositionAdjustments::Adjustment::~Adjustment()
 153 {
 154     // nothing to do!
 155 }
 156
 157 inline float GlyphPositionAdjustments::Adjustment::getXPlacement() const
 158 {
 159     return xPlacement;
 160 }
 161
 162 inline float GlyphPositionAdjustments::Adjustment::getYPlacement() const
 163 {
 164     return yPlacement;
 165 }
 166
 167 inline float GlyphPositionAdjustments::Adjustment::getXAdvance() const
 168 {
 169     return xAdvance;
 170 }
 171
 172 inline float GlyphPositionAdjustments::Adjustment::getYAdvance() const
 173 {
 174     return yAdvance;
 175 }
 176
 177 inline le_int32 GlyphPositionAdjustments::Adjustment::getBaseOffset() const
 178 {
 179     return baseOffset;
 180 }
 181
 182 inline void GlyphPositionAdjustments::Adjustment::setXPlacement(float newXPlacement)
 183 {
 184     xPlacement = newXPlacement;
 185 }
 186
 187 inline void GlyphPositionAdjustments::Adjustment::setYPlacement(float newYPlacement)
 188 {
 189     yPlacement = newYPlacement;
 190 }
 191
 192 inline void GlyphPositionAdjustments::Adjustment::setXAdvance(float newXAdvance)
 193 {
 194     xAdvance = newXAdvance;
 195 }
 196
 197 inline void GlyphPositionAdjustments::Adjustment::setYAdvance(float newYAdvance)
 198 {
 199     yAdvance = newYAdvance;
 200 }
 201
 202 inline void GlyphPositionAdjustments::Adjustment::setBaseOffset(le_int32 newBaseOffset)
 203 {
 204     baseOffset = newBaseOffset;
 205 }
 206
 207 inline void GlyphPositionAdjustments::Adjustment::adjustXPlacement(float xAdjustment)
 208 {
 209     xPlacement += xAdjustment;
 210 }
 211
 212 inline void GlyphPositionAdjustments::Adjustment::adjustYPlacement(float yAdjustment)
 213 {
 214     yPlacement += yAdjustment;
 215 }
 216
 217 inline void GlyphPositionAdjustments::Adjustment::adjustXAdvance(float xAdjustment)
 218 {
 219     xAdvance += xAdjustment;
 220 }
 221
 222 inline void GlyphPositionAdjustments::Adjustment::adjustYAdvance(float yAdjustment)
 223 {
 224     yAdvance += yAdjustment;
 225 }
 226
 227 inline GlyphPositionAdjustments::EntryExitPoint::EntryExitPoint()
 228     : fFlags(0)
 229 {
 230     fEntryPoint.fX = fEntryPoint.fY = fExitPoint.fX = fExitPoint.fY = 0;
 231 }
 232
 233 inline GlyphPositionAdjustments::EntryExitPoint::~EntryExitPoint()
 234 {
 235     // nothing special to do
 236 }
 237
 238 inline le_bool GlyphPositionAdjustments::EntryExitPoint::isCursiveGlyph() const
 239 {
 240     return (fFlags & EEF_IS_CURSIVE_GLYPH) != 0;
 241 }
 242
 243 inline le_bool GlyphPositionAdjustments::EntryExitPoint::baselineIsLogicalEnd() const
 244 {
 245     return (fFlags & EEF_BASELINE_IS_LOGICAL_END) != 0;
 246 }
 247
 248 inline void GlyphPositionAdjustments::EntryExitPoint::clearEntryPoint()
 249 {
 250     fFlags &= ~EEF_HAS_ENTRY_POINT;
 251 }
 252
 253 inline void GlyphPositionAdjustments::EntryExitPoint::clearExitPoint()
 254 {
 255     fFlags &= ~EEF_HAS_EXIT_POINT;
 256 }
 257
 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
 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
 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
 289 inline le_bool GlyphPositionAdjustments::isCursiveGlyph(le_int32 index) const
 290 {
 291     return fEntryExitPoints != NULL && fEntryExitPoints[index].isCursiveGlyph();
 292 }
 293
 294 inline le_bool GlyphPositionAdjustments::baselineIsLogicalEnd(le_int32 index) const
 295 {
 296     return fEntryExitPoints != NULL && fEntryExitPoints[index].baselineIsLogicalEnd();
 297 }
 298
 299 inline float GlyphPositionAdjustments::getXPlacement(le_int32 index) const
 300 {
 301     return fAdjustments[index].getXPlacement();
 302 }
 303
 304 inline float GlyphPositionAdjustments::getYPlacement(le_int32 index) const
 305 {
 306     return fAdjustments[index].getYPlacement();
 307 }
 308
 309 inline float GlyphPositionAdjustments::getXAdvance(le_int32 index) const
 310 {
 311     return fAdjustments[index].getXAdvance();
 312 }
 313
 314 inline float GlyphPositionAdjustments::getYAdvance(le_int32 index) const
 315 {
 316     return fAdjustments[index].getYAdvance();
 317 }
 318
 319
 320 inline le_int32 GlyphPositionAdjustments::getBaseOffset(le_int32 index) const
 321 {
 322     return fAdjustments[index].getBaseOffset();
 323 }
 324
 325 inline void GlyphPositionAdjustments::setXPlacement(le_int32 index, float newXPlacement)
 326 {
 327     fAdjustments[index].setXPlacement(newXPlacement);
 328 }
 329
 330 inline void GlyphPositionAdjustments::setYPlacement(le_int32 index, float newYPlacement)
 331 {
 332     fAdjustments[index].setYPlacement(newYPlacement);
 333 }
 334
 335 inline void GlyphPositionAdjustments::setXAdvance(le_int32 index, float newXAdvance)
 336 {
 337     fAdjustments[index].setXAdvance(newXAdvance);
 338 }
 339
 340 inline void GlyphPositionAdjustments::setYAdvance(le_int32 index, float newYAdvance)
 341 {
 342     fAdjustments[index].setYAdvance(newYAdvance);
 343 }
 344
 345 inline void GlyphPositionAdjustments::setBaseOffset(le_int32 index, le_int32 newBaseOffset)
 346 {
 347     fAdjustments[index].setBaseOffset(newBaseOffset);
 348 }
 349
 350 inline void GlyphPositionAdjustments::adjustXPlacement(le_int32 index, float xAdjustment)
 351 {
 352     fAdjustments[index].adjustXPlacement(xAdjustment);
 353 }
 354
 355 inline void GlyphPositionAdjustments::adjustYPlacement(le_int32 index, float yAdjustment)
 356 {
 357     fAdjustments[index].adjustYPlacement(yAdjustment);
 358 }
 359
 360 inline void GlyphPositionAdjustments::adjustXAdvance(le_int32 index, float xAdjustment)
 361 {
 362     fAdjustments[index].adjustXAdvance(xAdjustment);
 363 }
 364
 365 inline void GlyphPositionAdjustments::adjustYAdvance(le_int32 index, float yAdjustment)
 366 {
 367     fAdjustments[index].adjustYAdvance(yAdjustment);
 368 }
 369
 370 inline le_bool GlyphPositionAdjustments::hasCursiveGlyphs() const
 371 {
 372     return fEntryExitPoints != NULL;
 373 }
 374
 375 U_NAMESPACE_END
 376 #endif