MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/textandloc/fontservices/textshaperplugin/IcuSource/layout/GlyphPositionAdjustments.h
author sl@SLION-WIN7.fritz.box
Fri, 15 Jun 2012 03:10:57 +0200
changeset 0 bde4ae8d615e
permissions -rw-r--r--
First public contribution. 
     1 /*

     2  *

     3  * (C) Copyright IBM Corp. 1998-2005 - 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 setEntryPoint(LEPoint &newEntryPoint, le_bool baselineIsLogicalEnd);

    76         inline void setExitPoint(LEPoint &newExitPoint, le_bool baselineIsLogicalEnd);

    77         inline void setCursiveGlyph(le_bool baselineIsLogicalEnd);

    78 

    79     private:

    80         enum EntryExitFlags

    81         {

    82             EEF_HAS_ENTRY_POINT         = 0x80000000L,

    83             EEF_HAS_EXIT_POINT          = 0x40000000L,

    84             EEF_IS_CURSIVE_GLYPH        = 0x20000000L,

    85             EEF_BASELINE_IS_LOGICAL_END = 0x10000000L

    86         };

    87 

    88         le_uint32 fFlags;

    89         LEPoint fEntryPoint;

    90         LEPoint fExitPoint;

    91     };

    92 

    93     le_int32 fGlyphCount;

    94     EntryExitPoint *fEntryExitPoints;

    95     Adjustment *fAdjustments;

    96 

    97     GlyphPositionAdjustments();

    98 

    99 public:

   100     GlyphPositionAdjustments(le_int32 glyphCount);

   101     ~GlyphPositionAdjustments();

   102 

   103     inline le_bool hasCursiveGlyphs() const;

   104     inline le_bool isCursiveGlyph(le_int32 index) const;

   105     inline le_bool baselineIsLogicalEnd(le_int32 index) const;

   106 

   107     const LEPoint *getEntryPoint(le_int32 index, LEPoint &entryPoint) const;

   108     const LEPoint *getExitPoint(le_int32 index, LEPoint &exitPoint) const;

   109 

   110     inline float getXPlacement(le_int32 index) const;

   111     inline float getYPlacement(le_int32 index) const;

   112     inline float getXAdvance(le_int32 index) const;

   113     inline float getYAdvance(le_int32 index) const;

   114 

   115     inline le_int32 getBaseOffset(le_int32 index) const;

   116 

   117     inline void setXPlacement(le_int32 index, float newXPlacement);

   118     inline void setYPlacement(le_int32 index, float newYPlacement);

   119     inline void setXAdvance(le_int32 index, float newXAdvance);

   120     inline void setYAdvance(le_int32 index, float newYAdvance);

   121 

   122     inline void setBaseOffset(le_int32 index, le_int32 newBaseOffset);

   123 

   124     inline void adjustXPlacement(le_int32 index, float xAdjustment);

   125     inline void adjustYPlacement(le_int32 index, float yAdjustment);

   126     inline void adjustXAdvance(le_int32 index, float xAdjustment);

   127     inline void adjustYAdvance(le_int32 index, float yAdjustment);

   128    

   129     void setEntryPoint(le_int32 index, LEPoint &newEntryPoint, le_bool baselineIsLogicalEnd);

   130     void setExitPoint(le_int32 index, LEPoint &newExitPoint, le_bool baselineIsLogicalEnd);

   131     void setCursiveGlyph(le_int32 index, le_bool baselineIsLogicalEnd);

   132 

   133     void applyCursiveAdjustments(LEGlyphStorage &glyphStorage, le_bool rightToLeft, const LEFontInstance *fontInstance);

   134 };

   135 

   136 inline GlyphPositionAdjustments::Adjustment::Adjustment()

   137   : xPlacement(0), yPlacement(0), xAdvance(0), yAdvance(0), baseOffset(-1)

   138 {

   139     // nothing else to do!

   140 }

   141 

   142 inline GlyphPositionAdjustments::Adjustment::Adjustment(float xPlace, float yPlace, float xAdv, float yAdv, le_int32 baseOff)

   143   : xPlacement(xPlace), yPlacement(yPlace), xAdvance(xAdv), yAdvance(yAdv), baseOffset(baseOff)

   144 {

   145     // nothing else to do!

   146 }

   147 

   148 inline GlyphPositionAdjustments::Adjustment::~Adjustment()

   149 {

   150     // nothing to do!

   151 }

   152 

   153 inline float GlyphPositionAdjustments::Adjustment::getXPlacement() const

   154 {

   155     return xPlacement;

   156 }

   157 

   158 inline float GlyphPositionAdjustments::Adjustment::getYPlacement() const

   159 {

   160     return yPlacement;

   161 }

   162 

   163 inline float GlyphPositionAdjustments::Adjustment::getXAdvance() const

   164 {

   165     return xAdvance;

   166 }

   167 

   168 inline float GlyphPositionAdjustments::Adjustment::getYAdvance() const

   169 {

   170     return yAdvance;

   171 }

   172 

   173 inline le_int32 GlyphPositionAdjustments::Adjustment::getBaseOffset() const

   174 {

   175     return baseOffset;

   176 }

   177 

   178 inline void GlyphPositionAdjustments::Adjustment::setXPlacement(float newXPlacement)

   179 {

   180     xPlacement = newXPlacement;

   181 }

   182 

   183 inline void GlyphPositionAdjustments::Adjustment::setYPlacement(float newYPlacement)

   184 {

   185     yPlacement = newYPlacement;

   186 }

   187 

   188 inline void GlyphPositionAdjustments::Adjustment::setXAdvance(float newXAdvance)

   189 {

   190     xAdvance = newXAdvance;

   191 }

   192 

   193 inline void GlyphPositionAdjustments::Adjustment::setYAdvance(float newYAdvance)

   194 {

   195     yAdvance = newYAdvance;

   196 }

   197 

   198 inline void GlyphPositionAdjustments::Adjustment::setBaseOffset(le_int32 newBaseOffset)

   199 {

   200     baseOffset = newBaseOffset;

   201 }

   202 

   203 inline void GlyphPositionAdjustments::Adjustment::adjustXPlacement(float xAdjustment)

   204 {

   205     xPlacement += xAdjustment;

   206 }

   207 

   208 inline void GlyphPositionAdjustments::Adjustment::adjustYPlacement(float yAdjustment)

   209 {

   210     yPlacement += yAdjustment;

   211 }

   212 

   213 inline void GlyphPositionAdjustments::Adjustment::adjustXAdvance(float xAdjustment)

   214 {

   215     xAdvance += xAdjustment;

   216 }

   217 

   218 inline void GlyphPositionAdjustments::Adjustment::adjustYAdvance(float yAdjustment)

   219 {

   220     yAdvance += yAdjustment;

   221 }

   222 

   223 inline GlyphPositionAdjustments::EntryExitPoint::EntryExitPoint()

   224     : fFlags(0)

   225 {

   226     fEntryPoint.fX = fEntryPoint.fY = fExitPoint.fX = fEntryPoint.fY = 0;

   227 }

   228 

   229 inline GlyphPositionAdjustments::EntryExitPoint::~EntryExitPoint()

   230 {

   231     // nothing special to do

   232 }

   233 

   234 inline le_bool GlyphPositionAdjustments::EntryExitPoint::isCursiveGlyph() const

   235 {

   236     return (fFlags & EEF_IS_CURSIVE_GLYPH) != 0;

   237 }

   238 

   239 inline le_bool GlyphPositionAdjustments::EntryExitPoint::baselineIsLogicalEnd() const

   240 {

   241     return (fFlags & EEF_BASELINE_IS_LOGICAL_END) != 0;

   242 }

   243 

   244 inline void GlyphPositionAdjustments::EntryExitPoint::setEntryPoint(LEPoint &newEntryPoint, le_bool baselineIsLogicalEnd)

   245 {

   246     if (baselineIsLogicalEnd) {

   247         fFlags |= (EEF_HAS_ENTRY_POINT | EEF_IS_CURSIVE_GLYPH | EEF_BASELINE_IS_LOGICAL_END);

   248     } else {

   249         fFlags |= (EEF_HAS_ENTRY_POINT | EEF_IS_CURSIVE_GLYPH);

   250     }

   251 

   252     fEntryPoint = newEntryPoint;

   253 }

   254 

   255 inline void GlyphPositionAdjustments::EntryExitPoint::setExitPoint(LEPoint &newExitPoint, le_bool baselineIsLogicalEnd)

   256 {

   257     if (baselineIsLogicalEnd) {

   258         fFlags |= (EEF_HAS_EXIT_POINT | EEF_IS_CURSIVE_GLYPH | EEF_BASELINE_IS_LOGICAL_END);

   259     } else {

   260         fFlags |= (EEF_HAS_EXIT_POINT | EEF_IS_CURSIVE_GLYPH);

   261     }

   262 

   263     fExitPoint  = newExitPoint;

   264 }

   265 

   266 inline void GlyphPositionAdjustments::EntryExitPoint::setCursiveGlyph(le_bool baselineIsLogicalEnd)

   267 {

   268     if (baselineIsLogicalEnd) {

   269         fFlags |= (EEF_IS_CURSIVE_GLYPH | EEF_BASELINE_IS_LOGICAL_END);

   270     } else {

   271         fFlags |= EEF_IS_CURSIVE_GLYPH;

   272     }

   273 }

   274 

   275 inline le_bool GlyphPositionAdjustments::isCursiveGlyph(le_int32 index) const

   276 {

   277     return fEntryExitPoints != NULL && fEntryExitPoints[index].isCursiveGlyph();

   278 }

   279 

   280 inline le_bool GlyphPositionAdjustments::baselineIsLogicalEnd(le_int32 index) const

   281 {

   282     return fEntryExitPoints != NULL && fEntryExitPoints[index].baselineIsLogicalEnd();

   283 }

   284 

   285 inline float GlyphPositionAdjustments::getXPlacement(le_int32 index) const

   286 {

   287     return fAdjustments[index].getXPlacement();

   288 }

   289 

   290 inline float GlyphPositionAdjustments::getYPlacement(le_int32 index) const

   291 {

   292     return fAdjustments[index].getYPlacement();

   293 }

   294 

   295 inline float GlyphPositionAdjustments::getXAdvance(le_int32 index) const

   296 {

   297     return fAdjustments[index].getXAdvance();

   298 }

   299 

   300 inline float GlyphPositionAdjustments::getYAdvance(le_int32 index) const

   301 {

   302     return fAdjustments[index].getYAdvance();

   303 }

   304 

   305 

   306 inline le_int32 GlyphPositionAdjustments::getBaseOffset(le_int32 index) const

   307 {

   308     return fAdjustments[index].getBaseOffset();

   309 }

   310 

   311 inline void GlyphPositionAdjustments::setXPlacement(le_int32 index, float newXPlacement)

   312 {

   313     fAdjustments[index].setXPlacement(newXPlacement);

   314 }

   315 

   316 inline void GlyphPositionAdjustments::setYPlacement(le_int32 index, float newYPlacement)

   317 {

   318     fAdjustments[index].setYPlacement(newYPlacement);

   319 }

   320 

   321 inline void GlyphPositionAdjustments::setXAdvance(le_int32 index, float newXAdvance)

   322 {

   323     fAdjustments[index].setXAdvance(newXAdvance);

   324 }

   325 

   326 inline void GlyphPositionAdjustments::setYAdvance(le_int32 index, float newYAdvance)

   327 {

   328     fAdjustments[index].setYAdvance(newYAdvance);

   329 }

   330 

   331 inline void GlyphPositionAdjustments::setBaseOffset(le_int32 index, le_int32 newBaseOffset)

   332 {

   333     fAdjustments[index].setBaseOffset(newBaseOffset);

   334 }

   335 

   336 inline void GlyphPositionAdjustments::adjustXPlacement(le_int32 index, float xAdjustment)

   337 {

   338     fAdjustments[index].adjustXPlacement(xAdjustment);

   339 }

   340 

   341 inline void GlyphPositionAdjustments::adjustYPlacement(le_int32 index, float yAdjustment)

   342 {

   343     fAdjustments[index].adjustYPlacement(yAdjustment);

   344 }

   345 

   346 inline void GlyphPositionAdjustments::adjustXAdvance(le_int32 index, float xAdjustment)

   347 {

   348     fAdjustments[index].adjustXAdvance(xAdjustment);

   349 }

   350 

   351 inline void GlyphPositionAdjustments::adjustYAdvance(le_int32 index, float yAdjustment)

   352 {

   353     fAdjustments[index].adjustYAdvance(yAdjustment);

   354 }

   355 

   356 inline le_bool GlyphPositionAdjustments::hasCursiveGlyphs() const

   357 {

   358     return fEntryExitPoints != NULL;

   359 }

   360 

   361 U_NAMESPACE_END

   362 #endif
Symaptic