[apple/icu.git] / icuSources / layout / GlyphPositionAdjustments.h

/*
 *
 * (C) Copyright IBM Corp. 1998-2007 - All Rights Reserved
 *
 */

#ifndef __GLYPHPOSITIONADJUSTMENTS_H
#define __GLYPHPOSITIONADJUSTMENTS_H

/**
 * \file
 * \internal
 */

#include "LETypes.h"
#include "OpenTypeTables.h"

U_NAMESPACE_BEGIN

class LEGlyphStorage;
class LEFontInstance;

class GlyphPositionAdjustments : public UMemory
{
private:
    class Adjustment : public UMemory {
    public:

        inline Adjustment();
        inline Adjustment(float xPlace, float yPlace, float xAdv, float yAdv, le_int32 baseOff = -1);
        inline ~Adjustment();

        inline float    getXPlacement() const;
        inline float    getYPlacement() const;
        inline float    getXAdvance() const;
        inline float    getYAdvance() const;

        inline le_int32 getBaseOffset() const;

        inline void     setXPlacement(float newXPlacement);
        inline void     setYPlacement(float newYPlacement);
        inline void     setXAdvance(float newXAdvance);
        inline void     setYAdvance(float newYAdvance);

        inline void     setBaseOffset(le_int32 newBaseOffset);

        inline void    adjustXPlacement(float xAdjustment);
        inline void    adjustYPlacement(float yAdjustment);
        inline void    adjustXAdvance(float xAdjustment);
        inline void    adjustYAdvance(float yAdjustment);

    private:
        float xPlacement;
        float yPlacement;
        float xAdvance;
        float yAdvance;

        le_int32 baseOffset;

        // allow copying of this class because all of its fields are simple types
    };

    class EntryExitPoint : public UMemory
    {
    public:
        inline EntryExitPoint();
        inline ~EntryExitPoint();

        inline le_bool isCursiveGlyph() const;
        inline le_bool baselineIsLogicalEnd() const;

        LEPoint *getEntryPoint(LEPoint &entryPoint) const;
        LEPoint *getExitPoint(LEPoint &exitPoint) const;

        inline void clearEntryPoint();
        inline void clearExitPoint();
        inline void setEntryPoint(LEPoint &newEntryPoint, le_bool baselineIsLogicalEnd);
        inline void setExitPoint(LEPoint &newExitPoint, le_bool baselineIsLogicalEnd);
        inline void setCursiveGlyph(le_bool baselineIsLogicalEnd);

    private:
        enum EntryExitFlags
        {
            EEF_HAS_ENTRY_POINT         = 0x80000000L,
            EEF_HAS_EXIT_POINT          = 0x40000000L,
            EEF_IS_CURSIVE_GLYPH        = 0x20000000L,
            EEF_BASELINE_IS_LOGICAL_END = 0x10000000L
        };

        le_uint32 fFlags;
        LEPoint fEntryPoint;
        LEPoint fExitPoint;
    };

    le_int32 fGlyphCount;
    EntryExitPoint *fEntryExitPoints;
    Adjustment *fAdjustments;

    GlyphPositionAdjustments();

public:
    GlyphPositionAdjustments(le_int32 glyphCount);
    ~GlyphPositionAdjustments();

    inline le_bool hasCursiveGlyphs() const;
    inline le_bool isCursiveGlyph(le_int32 index) const;
    inline le_bool baselineIsLogicalEnd(le_int32 index) const;

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

    inline float getXPlacement(le_int32 index) const;
    inline float getYPlacement(le_int32 index) const;
    inline float getXAdvance(le_int32 index) const;
    inline float getYAdvance(le_int32 index) const;

    inline le_int32 getBaseOffset(le_int32 index) const;

    inline void setXPlacement(le_int32 index, float newXPlacement);
    inline void setYPlacement(le_int32 index, float newYPlacement);
    inline void setXAdvance(le_int32 index, float newXAdvance);
    inline void setYAdvance(le_int32 index, float newYAdvance);

    inline void setBaseOffset(le_int32 index, le_int32 newBaseOffset);

    inline void adjustXPlacement(le_int32 index, float xAdjustment);
    inline void adjustYPlacement(le_int32 index, float yAdjustment);
    inline void adjustXAdvance(le_int32 index, float xAdjustment);
    inline void adjustYAdvance(le_int32 index, float yAdjustment);
   
    void clearEntryPoint(le_int32 index);
    void clearExitPoint(le_int32 index);
    void setEntryPoint(le_int32 index, LEPoint &newEntryPoint, le_bool baselineIsLogicalEnd);
    void setExitPoint(le_int32 index, LEPoint &newExitPoint, le_bool baselineIsLogicalEnd);
    void setCursiveGlyph(le_int32 index, le_bool baselineIsLogicalEnd);

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

inline GlyphPositionAdjustments::Adjustment::Adjustment()
  : xPlacement(0), yPlacement(0), xAdvance(0), yAdvance(0), baseOffset(-1)
{
    // nothing else to do!
}

inline GlyphPositionAdjustments::Adjustment::Adjustment(float xPlace, float yPlace, float xAdv, float yAdv, le_int32 baseOff)
  : xPlacement(xPlace), yPlacement(yPlace), xAdvance(xAdv), yAdvance(yAdv), baseOffset(baseOff)
{
    // nothing else to do!
}

inline GlyphPositionAdjustments::Adjustment::~Adjustment()
{
    // nothing to do!
}

inline float GlyphPositionAdjustments::Adjustment::getXPlacement() const
{
    return xPlacement;
}

inline float GlyphPositionAdjustments::Adjustment::getYPlacement() const
{
    return yPlacement;
}

inline float GlyphPositionAdjustments::Adjustment::getXAdvance() const
{
    return xAdvance;
}

inline float GlyphPositionAdjustments::Adjustment::getYAdvance() const
{
    return yAdvance;
}

inline le_int32 GlyphPositionAdjustments::Adjustment::getBaseOffset() const
{
    return baseOffset;
}

inline void GlyphPositionAdjustments::Adjustment::setXPlacement(float newXPlacement)
{
    xPlacement = newXPlacement;
}

inline void GlyphPositionAdjustments::Adjustment::setYPlacement(float newYPlacement)
{
    yPlacement = newYPlacement;
}

inline void GlyphPositionAdjustments::Adjustment::setXAdvance(float newXAdvance)
{
    xAdvance = newXAdvance;
}

inline void GlyphPositionAdjustments::Adjustment::setYAdvance(float newYAdvance)
{
    yAdvance = newYAdvance;
}

inline void GlyphPositionAdjustments::Adjustment::setBaseOffset(le_int32 newBaseOffset)
{
    baseOffset = newBaseOffset;
}

inline void GlyphPositionAdjustments::Adjustment::adjustXPlacement(float xAdjustment)
{
    xPlacement += xAdjustment;
}

inline void GlyphPositionAdjustments::Adjustment::adjustYPlacement(float yAdjustment)
{
    yPlacement += yAdjustment;
}

inline void GlyphPositionAdjustments::Adjustment::adjustXAdvance(float xAdjustment)
{
    xAdvance += xAdjustment;
}

inline void GlyphPositionAdjustments::Adjustment::adjustYAdvance(float yAdjustment)
{
    yAdvance += yAdjustment;
}

inline GlyphPositionAdjustments::EntryExitPoint::EntryExitPoint()
    : fFlags(0)
{
    fEntryPoint.fX = fEntryPoint.fY = fExitPoint.fX = fExitPoint.fY = 0;
}

inline GlyphPositionAdjustments::EntryExitPoint::~EntryExitPoint()
{
    // nothing special to do
}

inline le_bool GlyphPositionAdjustments::EntryExitPoint::isCursiveGlyph() const
{
    return (fFlags & EEF_IS_CURSIVE_GLYPH) != 0;
}

inline le_bool GlyphPositionAdjustments::EntryExitPoint::baselineIsLogicalEnd() const
{
    return (fFlags & EEF_BASELINE_IS_LOGICAL_END) != 0;
}

inline void GlyphPositionAdjustments::EntryExitPoint::clearEntryPoint()
{
    fFlags &= ~EEF_HAS_ENTRY_POINT;
}

inline void GlyphPositionAdjustments::EntryExitPoint::clearExitPoint()
{
    fFlags &= ~EEF_HAS_EXIT_POINT;
}

inline void GlyphPositionAdjustments::EntryExitPoint::setEntryPoint(LEPoint &newEntryPoint, le_bool baselineIsLogicalEnd)
{
    if (baselineIsLogicalEnd) {
        fFlags |= (EEF_HAS_ENTRY_POINT | EEF_IS_CURSIVE_GLYPH | EEF_BASELINE_IS_LOGICAL_END);
    } else {
        fFlags |= (EEF_HAS_ENTRY_POINT | EEF_IS_CURSIVE_GLYPH);
    }

    fEntryPoint = newEntryPoint;
}

inline void GlyphPositionAdjustments::EntryExitPoint::setExitPoint(LEPoint &newExitPoint, le_bool baselineIsLogicalEnd)
{
    if (baselineIsLogicalEnd) {
        fFlags |= (EEF_HAS_EXIT_POINT | EEF_IS_CURSIVE_GLYPH | EEF_BASELINE_IS_LOGICAL_END);
    } else {
        fFlags |= (EEF_HAS_EXIT_POINT | EEF_IS_CURSIVE_GLYPH);
    }

    fExitPoint  = newExitPoint;
}

inline void GlyphPositionAdjustments::EntryExitPoint::setCursiveGlyph(le_bool baselineIsLogicalEnd)
{
    if (baselineIsLogicalEnd) {
        fFlags |= (EEF_IS_CURSIVE_GLYPH | EEF_BASELINE_IS_LOGICAL_END);
    } else {
        fFlags |= EEF_IS_CURSIVE_GLYPH;
    }
}

inline le_bool GlyphPositionAdjustments::isCursiveGlyph(le_int32 index) const
{
    return fEntryExitPoints != NULL && fEntryExitPoints[index].isCursiveGlyph();
}

inline le_bool GlyphPositionAdjustments::baselineIsLogicalEnd(le_int32 index) const
{
    return fEntryExitPoints != NULL && fEntryExitPoints[index].baselineIsLogicalEnd();
}

inline float GlyphPositionAdjustments::getXPlacement(le_int32 index) const
{
    return fAdjustments[index].getXPlacement();
}

inline float GlyphPositionAdjustments::getYPlacement(le_int32 index) const
{
    return fAdjustments[index].getYPlacement();
}

inline float GlyphPositionAdjustments::getXAdvance(le_int32 index) const
{
    return fAdjustments[index].getXAdvance();
}

inline float GlyphPositionAdjustments::getYAdvance(le_int32 index) const
{
    return fAdjustments[index].getYAdvance();
}


inline le_int32 GlyphPositionAdjustments::getBaseOffset(le_int32 index) const
{
    return fAdjustments[index].getBaseOffset();
}

inline void GlyphPositionAdjustments::setXPlacement(le_int32 index, float newXPlacement)
{
    fAdjustments[index].setXPlacement(newXPlacement);
}

inline void GlyphPositionAdjustments::setYPlacement(le_int32 index, float newYPlacement)
{
    fAdjustments[index].setYPlacement(newYPlacement);
}

inline void GlyphPositionAdjustments::setXAdvance(le_int32 index, float newXAdvance)
{
    fAdjustments[index].setXAdvance(newXAdvance);
}

inline void GlyphPositionAdjustments::setYAdvance(le_int32 index, float newYAdvance)
{
    fAdjustments[index].setYAdvance(newYAdvance);
}

inline void GlyphPositionAdjustments::setBaseOffset(le_int32 index, le_int32 newBaseOffset)
{
    fAdjustments[index].setBaseOffset(newBaseOffset);
}

inline void GlyphPositionAdjustments::adjustXPlacement(le_int32 index, float xAdjustment)
{
    fAdjustments[index].adjustXPlacement(xAdjustment);
}

inline void GlyphPositionAdjustments::adjustYPlacement(le_int32 index, float yAdjustment)
{
    fAdjustments[index].adjustYPlacement(yAdjustment);
}

inline void GlyphPositionAdjustments::adjustXAdvance(le_int32 index, float xAdjustment)
{
    fAdjustments[index].adjustXAdvance(xAdjustment);
}

inline void GlyphPositionAdjustments::adjustYAdvance(le_int32 index, float yAdjustment)
{
    fAdjustments[index].adjustYAdvance(yAdjustment);
}

inline le_bool GlyphPositionAdjustments::hasCursiveGlyphs() const
{
    return fEntryExitPoints != NULL;
}

U_NAMESPACE_END
#endif
Commit	Line	Data
b75a7d8f	1	/*
b75a7d8f	2	*
46f4442e	3	* (C) Copyright IBM Corp. 1998-2007 - All Rights Reserved
b75a7d8f A	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
73c04bcf A	20	class LEGlyphStorage;
73c04bcf A	21	class LEFontInstance;
b75a7d8f	22
73c04bcf A	23	class GlyphPositionAdjustments : public UMemory
	24	{
	25	private:
	26	class Adjustment : public UMemory {
	27	public:
b75a7d8f	28
73c04bcf A	29	inline Adjustment();
	30	inline Adjustment(float xPlace, float yPlace, float xAdv, float yAdv, le_int32 baseOff = -1);
	31	inline ~Adjustment();
b75a7d8f	32
73c04bcf A	33	inline float getXPlacement() const;
	34	inline float getYPlacement() const;
	35	inline float getXAdvance() const;
	36	inline float getYAdvance() const;
b75a7d8f	37
73c04bcf	38	inline le_int32 getBaseOffset() const;
b75a7d8f	39
73c04bcf A	40	inline void setXPlacement(float newXPlacement);
	41	inline void setYPlacement(float newYPlacement);
	42	inline void setXAdvance(float newXAdvance);
	43	inline void setYAdvance(float newYAdvance);
b75a7d8f	44
73c04bcf	45	inline void setBaseOffset(le_int32 newBaseOffset);
b75a7d8f	46
73c04bcf A	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
46f4442e A	75	inline void clearEntryPoint();
46f4442e A	76	inline void clearExitPoint();
73c04bcf A	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	};
b75a7d8f	94
73c04bcf A	95	le_int32 fGlyphCount;
	96	EntryExitPoint *fEntryExitPoints;
	97	Adjustment *fAdjustments;
b75a7d8f	98
73c04bcf A	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
46f4442e A	131	void clearEntryPoint(le_int32 index);
46f4442e A	132	void clearExitPoint(le_int32 index);
73c04bcf A	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);
b75a7d8f A	138	};
b75a7d8f A	139
73c04bcf	140	inline GlyphPositionAdjustments::Adjustment::Adjustment()
b75a7d8f A	141	: xPlacement(0), yPlacement(0), xAdvance(0), yAdvance(0), baseOffset(-1)
	142	{
	143	// nothing else to do!
	144	}
	145
73c04bcf	146	inline GlyphPositionAdjustments::Adjustment::Adjustment(float xPlace, float yPlace, float xAdv, float yAdv, le_int32 baseOff)
b75a7d8f A	147	: xPlacement(xPlace), yPlacement(yPlace), xAdvance(xAdv), yAdvance(yAdv), baseOffset(baseOff)
	148	{
	149	// nothing else to do!
	150	}
	151
73c04bcf	152	inline GlyphPositionAdjustments::Adjustment::~Adjustment()
b75a7d8f A	153	{
	154	// nothing to do!
	155	}
	156
73c04bcf	157	inline float GlyphPositionAdjustments::Adjustment::getXPlacement() const
b75a7d8f A	158	{
	159	return xPlacement;
	160	}
	161
73c04bcf	162	inline float GlyphPositionAdjustments::Adjustment::getYPlacement() const
b75a7d8f A	163	{
	164	return yPlacement;
	165	}
	166
73c04bcf	167	inline float GlyphPositionAdjustments::Adjustment::getXAdvance() const
b75a7d8f A	168	{
	169	return xAdvance;
	170	}
	171
73c04bcf	172	inline float GlyphPositionAdjustments::Adjustment::getYAdvance() const
b75a7d8f A	173	{
	174	return yAdvance;
	175	}
	176
73c04bcf	177	inline le_int32 GlyphPositionAdjustments::Adjustment::getBaseOffset() const
b75a7d8f A	178	{
	179	return baseOffset;
	180	}
	181
73c04bcf	182	inline void GlyphPositionAdjustments::Adjustment::setXPlacement(float newXPlacement)
b75a7d8f A	183	{
	184	xPlacement = newXPlacement;
	185	}
	186
73c04bcf	187	inline void GlyphPositionAdjustments::Adjustment::setYPlacement(float newYPlacement)
b75a7d8f A	188	{
	189	yPlacement = newYPlacement;
	190	}
	191
73c04bcf	192	inline void GlyphPositionAdjustments::Adjustment::setXAdvance(float newXAdvance)
b75a7d8f A	193	{
	194	xAdvance = newXAdvance;
	195	}
	196
73c04bcf	197	inline void GlyphPositionAdjustments::Adjustment::setYAdvance(float newYAdvance)
b75a7d8f A	198	{
	199	yAdvance = newYAdvance;
	200	}
	201
73c04bcf	202	inline void GlyphPositionAdjustments::Adjustment::setBaseOffset(le_int32 newBaseOffset)
b75a7d8f A	203	{
	204	baseOffset = newBaseOffset;
	205	}
	206
73c04bcf	207	inline void GlyphPositionAdjustments::Adjustment::adjustXPlacement(float xAdjustment)
b75a7d8f A	208	{
	209	xPlacement += xAdjustment;
	210	}
	211
73c04bcf	212	inline void GlyphPositionAdjustments::Adjustment::adjustYPlacement(float yAdjustment)
b75a7d8f A	213	{
	214	yPlacement += yAdjustment;
	215	}
	216
73c04bcf	217	inline void GlyphPositionAdjustments::Adjustment::adjustXAdvance(float xAdjustment)
b75a7d8f A	218	{
	219	xAdvance += xAdjustment;
	220	}
	221
73c04bcf	222	inline void GlyphPositionAdjustments::Adjustment::adjustYAdvance(float yAdjustment)
b75a7d8f A	223	{
	224	yAdvance += yAdjustment;
	225	}
	226
73c04bcf A	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
46f4442e A	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
73c04bcf A	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
b75a7d8f A	375	U_NAMESPACE_END
b75a7d8f A	376	#endif