// Copyright (c) 2003-2010 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
//
/**
@file
@internalComponent
*/
//#include <textbase.h>
#include <gdi.h>
#include "FontThai.h"
//
// ThaiGlyph Namespace definition
//
/**
This namespace holds functions used to evaluate a glyph character code
against a given Thai related prediciate. The 'code' argument is a glyph
from the current output cluster and so may be a Thai glyph, Thai PUA glyph,
the dotted circle glyph or 0xffff. Therefore it was decided not to implement
these routines using a data driven table approach as it would be inefficient.
@internalComponent.
*/
namespace ThaiGlyph
{
const TText16 KYoYing = 0x0E0D;
const TText16 KYoYingPua = 0xF70F;
const TText16 KThoThan = 0x0E10;
const TText16 KThoThanPua = 0xF700;
const TText16 KNikhahit = 0x0E4D;
const TText16 KNikhahitPua = 0xF711;
const TText16 KSaraAa = 0x0E32;
const TText16 KSaraAm = 0x0E33;
TBool IsThaiGlyph(TUint code)
{
return ((code > 0x0E00 && code < 0x0E3B) ||
(code > 0x0E3E && code < 0x0E5C) ||
(code >= 0xF700 && code <= 0xF71A));
}
TBool IsThaiConsonant(TUint code)
{
return (code >= 0x0E01 && code <= 0x0E2E);
}
TBool IsThaiTallConsonant(TUint code)
{
return (//code == 0x0E0A || // CHO CHANG not tall at all
//code == 0x0E0B || // SO SO not tall at all
code == 0x0E1B || // PO PLA
code == 0x0E1D || // FO FA
code == 0x0E1F || // FO FAN
code == 0x0E2C); // LO CHULA in some fonts, Unicode tables show it as tall
}
TBool IsThaiShortConsonant(TUint code)
{
return (((code >= 0x0E01 && code <= 0x0E2E) || (code == KUnicodeDottedCircle)) &&
code != 0x0E1B && // PO PLA
code != 0x0E1D && // FO FA
code != 0x0E1F && // FO FAN
code != 0x0E2C); // LO CHULA in some fonts, Unicode tables show it as tall
}
TBool IsThaiConsonantWithDisjointDescender(TUint code)
{
return (code == ThaiGlyph::KYoYing || code == ThaiGlyph::KThoThan);
}
TBool IsThaiConsonantWithJointDescender(TUint code)
{
return (code == 0x0E0E || // DO CHADA
code == 0x0E0F || // PO PATAK
code == 0x0E24 || // RU
code == 0x0E26); // LU
}
TBool IsThaiVowel(TUint code)
{
return ((code >= 0x0E30 && code <= 0x0E3A) ||
(code >= 0x0E40 && code <= 0x0E44) ||
code == 0x0E47); // MAITAIKHU
}
TBool IsThaiDepVowel(TUint code)
{
return (code == 0x0E31 || // MAI HAN-AKAT
(code >= 0x0E34 && code <= 0x0E3A) ||
code == 0x0E47); // MAITAIKHU
}
TBool IsThaiDepVowelAbove(TUint code)
{
return (code == 0x0E31 || // MAI HAN-AKAT
(code >= 0x0E34 && code <= 0x0E37) ||
code == 0x0E47); // MAITAIKHU
}
TBool IsThaiDepVowelAbovePUA(TUint code)
{
return (code == 0xF710 || // MAI HAN-AKAT
(code >= 0xF701 && code <= 0xF704) ||
code == 0xF712); // MAITAIKHU
}
TBool IsThaiDepVowelBelow(TUint code)
{
return (code >= 0x0E38 && code <= 0x0E3A);
}
TBool IsThaiIndepVowel(TUint code)
{
return (code == 0x0E30 || // SARA A
code == 0x0E32 || // SARA AA
code == 0x0E33 || // SARA AM
(code >= 0x0E40 && code <= 0x0E44));
}
TBool IsThaiToneMark(TUint code)
{
return (code >= 0x0E48 && code <= 0x0E4B);
}
}
//
//
// ThaiCharRules Namespace definition
//
//
/**
ThaiCharRules namespace holds the data and lookup methods
implementing the WTT 2.0 input/output validation matrix.
@internalComponent
*/
namespace ThaiCharRules
{
const TUint KThaiCodePageStart = 0x0E00;
const TUint KThaiCodePageEnd = 0x0E5C;
const TUint KNumThaiCharacters = KThaiCodePageEnd-KThaiCodePageStart;
enum Wtt2Rule
{
EUndefined,
EAccept,
EComposite,
EReject,
ERejectStrict,
};
/**
This enumeration holds the set of classification values a Thai
character can be categorised as in the WTT2.0 specification.
*/
enum CharClassification
{
ENull,
EControl,
ENonPrintable,
EConsonant,
ELeadingVowel,
EOrdinaryFollowingVowel,
EDependentFollowingVowel,
ESpecialFollowingVowel,
EShortBelowVowel,
ELongBelowVowel,
EBelowDiacritic,
EToneMark,
EAboveDiacritic0,
EAboveDiacritic1,
EAboveDiacritic2,
EAboveDiacritic3,
EAboveVowel1,
EAboveVowel2,
EAboveVowel3,
// marker for end
EMaxClassification
};
/**
Data table holding the classification of each character.
*/
static const TUint8 iCharClassifications[KNumThaiCharacters] =
{
ENull, // No entry in code page
EConsonant, // 0x0E01
EConsonant, // 0x0E02
EConsonant, // 0x0E03
EConsonant, // 0x0E04
EConsonant, // 0x0E05
EConsonant, // 0x0E06
EConsonant, // 0x0E07
EConsonant, // 0x0E08
EConsonant, // 0x0E09
EConsonant, // 0x0E0A
EConsonant, // 0x0E0B
EConsonant, // 0x0E0C
EConsonant, // 0x0E0D
EConsonant, // 0x0E0E
EConsonant, // 0x0E0F
EConsonant, // 0x0E10
EConsonant, // 0x0E11
EConsonant, // 0x0E12
EConsonant, // 0x0E13
EConsonant, // 0x0E14
EConsonant, // 0x0E15
EConsonant, // 0x0E16
EConsonant, // 0x0E17
EConsonant, // 0x0E18
EConsonant, // 0x0E19
EConsonant, // 0x0E1A
EConsonant, // 0x0E1B
EConsonant, // 0x0E1C
EConsonant, // 0x0E1D
EConsonant, // 0x0E1E
EConsonant, // 0x0E1F
EConsonant, // 0x0E20
EConsonant, // 0x0E21
EConsonant, // 0x0E22
EConsonant, // 0x0E23
EConsonant, // 0x0E24
EConsonant, // 0x0E25
EConsonant, // 0x0E26
EConsonant, // 0x0E27
EConsonant, // 0x0E28
EConsonant, // 0x0E29
EConsonant, // 0x0E2A
EConsonant, // 0x0E2B
EConsonant, // 0x0E2C
EConsonant, // 0x0E2D
EConsonant, // 0x0E2E
ENonPrintable, // 0x0E2F
EOrdinaryFollowingVowel,// 0x0E30
EAboveVowel2, // 0x0E31
EOrdinaryFollowingVowel,// 0x0E32
EOrdinaryFollowingVowel,// 0x0E33
EAboveVowel1, // 0x0E34
EAboveVowel3, // 0x0E35
EAboveVowel2, // 0x0E36
EAboveVowel3, // 0x0E37
EShortBelowVowel, // 0x0E38
ELongBelowVowel, // 0x0E39
EBelowDiacritic, // 0x0E3A
ENull, // 0x0E3B
ENull, // 0x0E3C
ENull, // 0x0E3D
ENull, // 0x0E3E
ENonPrintable, // 0x0E3F
ELeadingVowel, // 0x0E40
ELeadingVowel, // 0x0E41
ELeadingVowel, // 0x0E42
ELeadingVowel, // 0x0E43
ELeadingVowel, // 0x0E44
EDependentFollowingVowel,//0x0E45
ENonPrintable, // 0x0E46
EAboveDiacritic2, // 0x0E47
EToneMark, // 0x0E48
EToneMark, // 0x0E49
EToneMark, // 0x0E4A
EToneMark, // 0x0E4B
EAboveDiacritic1, // 0x0E4C
EAboveDiacritic0, // 0x0E4D
EAboveDiacritic3, // 0x0E4E
ENonPrintable, // 0x0E4F
ENonPrintable, // 0x0E50
ENonPrintable, // 0x0E51
ENonPrintable, // 0x0E52
ENonPrintable, // 0x0E53
ENonPrintable, // 0x0E54
ENonPrintable, // 0x0E55
ENonPrintable, // 0x0E56
ENonPrintable, // 0x0E57
ENonPrintable, // 0x0E58
ENonPrintable, // 0x0E59
ENonPrintable, // 0x0E5A
ENonPrintable, // 0x0E5B
// Value at last measurement was 92 bytes. 27/6/2003
};
/**
WTT 2.0 Rules data table of prev to next character
*/
static const TUint8 iInputRules[EMaxClassification][EMaxClassification] =
{
/* Previous character ENull */
{
EUndefined, EUndefined, EUndefined, EUndefined, EUndefined,
EUndefined, EUndefined, EUndefined, EUndefined, EUndefined,
EUndefined, EUndefined, EUndefined, EUndefined, EUndefined,
EUndefined, EUndefined, EUndefined, EUndefined
},
/* Previous character EControl */
{
EUndefined, EUndefined, EAccept, EAccept, EAccept,
EAccept, EAccept, EAccept, EReject, EReject,
EReject, EReject, EReject, EReject, EReject, EReject,
EReject, EReject, EReject,
},
/* Previous character ENonPrintable */
{
EUndefined, EUndefined, EAccept, EAccept, EAccept,
ERejectStrict, ERejectStrict, EAccept, EReject, EReject,
EReject, EReject, EReject, EReject, EReject, EReject,
EReject, EReject, EReject,
},
/* Previous character EConsonant */
{
EUndefined, EUndefined, EAccept, EAccept, EAccept,
EAccept, ERejectStrict, EAccept, EComposite, EComposite,
EComposite, EComposite, EComposite, EComposite, EComposite, EComposite,
EComposite, EComposite, EComposite,
},
/* Previous character ELeadingVowel */
{
EUndefined, EUndefined, ERejectStrict, EAccept, ERejectStrict,
ERejectStrict, ERejectStrict, ERejectStrict, EReject, EReject,
EReject, EReject, EReject, EReject, EReject, EReject,
EReject, EReject, EReject,
},
/* Previous character EOrdinaryFollowingVowel */
{
EUndefined, EUndefined, ERejectStrict, EAccept, ERejectStrict,
EAccept, ERejectStrict, EAccept, EReject, EReject,
EReject, EReject, EReject, EReject, EReject, EReject,
EReject, EReject, EReject,
},
/* Previous character EDependentFollowingVowel */
{
EUndefined, EUndefined, EAccept, EAccept, EAccept,
EAccept, ERejectStrict, EAccept, EReject, EReject,
EReject, EReject, EReject, EReject, EReject, EReject,
EReject, EReject, EReject,
},
/* Previous character ESpecialFollowingVowel */
{
EUndefined, EUndefined, EAccept, EAccept, EAccept,
ERejectStrict, EAccept, ERejectStrict, EReject, EReject,
EReject, EReject, EReject, EReject, EReject, EReject,
EReject, EReject, EReject,
},
/* Previous character EShortBelowVowel */
{
EUndefined, EUndefined, EAccept, EAccept, EAccept,
EAccept, ERejectStrict, EAccept, EReject, EReject,
EReject, EComposite, EComposite, EComposite, EReject, EReject,
EReject, EReject, EReject,
},
/* Previous character ELongBelowVowel */
{
EUndefined, EUndefined, EAccept, EAccept, EAccept,
ERejectStrict, ERejectStrict, EAccept, EReject, EReject,
EReject, EComposite, EReject, EReject, EReject, EReject,
EReject, EReject, EReject,
},
/* Previous character EBelowDiacritic */
{
EUndefined, EUndefined, EAccept, EAccept, EAccept,
ERejectStrict, ERejectStrict, EAccept, EReject, EReject,
EReject, EReject, EReject, EReject, EReject, EReject,
EReject, EReject, EReject,
},
/* Previous character EToneMark */
{
EUndefined, EUndefined, EAccept, EAccept, EAccept,
EAccept, EAccept, EAccept, EReject, EReject,
EReject, EReject, EReject, EReject, EReject, EReject,
EReject, EReject, EReject,
},
/* Previous character EAboveDiacritic0 */
{
EUndefined, EUndefined, EAccept, EAccept, EAccept,
ERejectStrict, ERejectStrict, EAccept, EReject, EReject,
EReject, EReject, EReject, EReject, EReject, EReject,
EReject, EReject, EReject,
},
/* Previous character EAboveDiacritic1 */
{
EUndefined, EUndefined, EAccept, EAccept, EAccept,
ERejectStrict, ERejectStrict, EAccept, EReject, EReject,
EReject, EReject, EReject, EReject, EReject, EReject,
EReject, EReject, EReject,
},
/* Previous character EAboveDiacritic2 */
{
EUndefined, EUndefined, EAccept, EAccept, EAccept,
ERejectStrict, ERejectStrict, EAccept, EReject, EReject,
EReject, EReject, EReject, EReject, EReject, EReject,
EReject, EReject, EReject,
},
/* Previous character EAboveDiacritic3 */
{
EUndefined, EUndefined, EAccept, EAccept, EAccept,
ERejectStrict, ERejectStrict, EAccept, EReject, EReject,
EReject, EReject, EReject, EReject, EReject, EReject,
EReject, EReject, EReject,
},
/* Previous character EAboveVowel1 */
{
EUndefined, EUndefined, EAccept, EAccept, EAccept,
ERejectStrict, ERejectStrict, EAccept, EReject, EReject,
EReject, EComposite, EReject, EComposite, EReject, EReject,
// EReject, EComposite, EComposite, EComposite, EReject, EReject,
EReject, EReject, EReject,
},
/* Previous character EAboveVowel2 */
{
EUndefined, EUndefined, EAccept, EAccept, EAccept,
ERejectStrict, ERejectStrict, EAccept, EReject, EReject,
EReject, EComposite, EReject, EReject, EReject, EReject,
EReject, EReject, EReject,
},
/* Previous character EAboveVowel3 */
{
EUndefined, EUndefined, EAccept, EAccept, EAccept,
ERejectStrict, ERejectStrict, EAccept, EReject, EReject,
EReject, EComposite, EReject, EReject, EReject, EReject,
// EReject, EComposite, EReject, EComposite, EReject,
EReject, EReject, EReject,
},
// Value at last measurement was 324 bytes. 27/6/2003
};
/**
This routine looks up the WTT 2.0 rule for the given
Thai character codes provided in the WTT 2.0 data table.
@param aPrevChar
Unicode character code preceding the assumed position.
@param aChar
Unicode character code proceeding the assumed position.
@return Wtt2Rule
The rule value found in data table.
*/
Wtt2Rule LookupWtt2Rule(TUint aPrevChar, TUint aChar)
{
const CharClassification prevCharClassification =
static_cast<CharClassification>(
(aPrevChar > KThaiCodePageStart && aPrevChar < KThaiCodePageEnd) ?
iCharClassifications[aPrevChar - KThaiCodePageStart] :
ENonPrintable);
const CharClassification charClassification =
static_cast<CharClassification>(
(aChar > KThaiCodePageStart && aChar < KThaiCodePageEnd) ?
iCharClassifications[aChar - KThaiCodePageStart] :
ENonPrintable);
return static_cast<Wtt2Rule>
(iInputRules[prevCharClassification][charClassification]);
}
}
using namespace ThaiCharRules;
//
//
// ThaiGlyphPUASubstitution Namespace definition
//
//
/**
This utility namespace holds the data and lookup mechanisms to support
the GlyphSelector_Thai glyph selection class in choosing Private User
Area (PUA) Thai character positional variant glyphs. Use of the PUA glyphs
results in a satisfactory rendition of Thai writing in Symbian OS.
@internalComponent
*/
namespace ThaiGlyphPUASubstitution
{
typedef TBool (*UnicodeCharValidator)(const TGlyphSelectionState& aGss);
struct PUASubstTableEntry
{
TUint iOrigGlyph;
TUint iPUAGlyph;
UnicodeCharValidator iRuleFunc;
};
/**
ThaiGlyphPUASubstitution rule method which checks the context for
short consonant preceding char OR
short consonant & dependent vowel below preceding char.
@param aGss
Container object holds the glyph selection context for the method.
@return TBool
ETrue when the rule context is satisfied, EFalse if not.
*/
TBool RuleShortConsonant(const TGlyphSelectionState& aGss)
{
if (aGss.iParam.iOutputGlyphs == 1) {
//check the context for short consonant preceding char
TUint consonantGss = aGss.iParam.iOutput[0].iCode;
if (ThaiGlyph::IsThaiShortConsonant(consonantGss) ||
consonantGss == ThaiGlyph::KYoYingPua ||
consonantGss == ThaiGlyph::KThoThanPua)
return ETrue;
else
return EFalse;
}
if (aGss.iParam.iOutputGlyphs == 2) {
//check the context for short consonant & dependent vowel below preceding char
TUint consonantGss = aGss.iParam.iOutput[0].iCode;
TUint depVowelGss = aGss.iParam.iOutput[1].iCode;
if ((ThaiGlyph::IsThaiShortConsonant(consonantGss) ||
consonantGss == ThaiGlyph::KYoYingPua ||
consonantGss == ThaiGlyph::KThoThanPua) &&
(ThaiGlyph::IsThaiDepVowelBelow(depVowelGss) ||
(depVowelGss >= 0xF718 &&
depVowelGss <= 0xF71A)))
return ETrue;
else
return EFalse;
}
return EFalse;
}
/**
ThaiGlyphPUASubstitution rule method which checks the context for
tall consonant preceding char.
@param aGss
Container object holds the glyph selection context for the method.
@return TBool
ETrue when the rule context is satisfied, EFalse if not.
*/
TBool RuleTallConsonant(const TGlyphSelectionState& aGss)
{
if ((aGss.iParam.iOutputGlyphs == 1) &&
ThaiGlyph::IsThaiTallConsonant(aGss.iParam.iOutput[0].iCode))
return ETrue;
else
return EFalse;
}
/**
ThaiGlyphPUASubstitution rule method which checks the context for a tall
consonant which does not have a dependent vowel above or a nikhahit or a
following sara am.
@param aGss
Container object holds the glyph selection context for the method.
@return TBool
ETrue when the rule context is satisfied, EFalse if not.
*/
TBool RuleTallConsonantNoVowelAbove(const TGlyphSelectionState& aGss)
{
if (aGss.iParam.iOutputGlyphs == 0)
return EFalse;
if (!ThaiGlyph::IsThaiTallConsonant(aGss.iParam.iOutput[0].iCode))
return EFalse;
if (aGss.iParam.iOutputGlyphs == 1)
return ETrue;
if (aGss.iParam.iOutputGlyphs != 2)
return EFalse;
TUint wantDepVowel = aGss.iParam.iOutput[1].iCode;
if (ThaiGlyph::IsThaiDepVowelAbove(wantDepVowel)
|| ThaiGlyph::IsThaiDepVowelAbovePUA(wantDepVowel)
|| wantDepVowel == ThaiGlyph::KNikhahit
|| wantDepVowel == ThaiGlyph::KNikhahitPua)
return EFalse;
return ETrue;
}
/**
ThaiGlyphPUASubstitution rule method which checks the context for tall
consonant with either a dependent vowel above or nikhahit.
@param aGss
Container object holds the glyph selection context for the method.
@return TBool
ETrue when the rule context is satisfied, EFalse if not.
*/
TBool RuleTallConsonantVowelAbove(const TGlyphSelectionState& aGss)
{
if ((aGss.iParam.iOutputGlyphs == 2) &&
ThaiGlyph::IsThaiTallConsonant(aGss.iParam.iOutput[0].iCode) &&
(ThaiGlyph::IsThaiDepVowelAbovePUA(aGss.iParam.iOutput[1].iCode))
|| aGss.iParam.iOutput[1].iCode == ThaiGlyph::KNikhahitPua)
return ETrue;
else
return EFalse;
}
/**
ThaiGlyphPUASubstitution rule method which checks the context for
consonant with joined descender preceding char.
@param aGss
Container object holds the glyph selection context for the method.
@return TBool
ETrue when the rule context is satisfied, EFalse if not.
*/
TBool RuleConsonantWithJointDescender(const TGlyphSelectionState& aGss)
{
if ((aGss.iParam.iOutputGlyphs == 1) &&
ThaiGlyph::IsThaiConsonantWithJointDescender(aGss.iParam.iOutput[0].iCode))
return ETrue;
else
return EFalse;
}
const PUASubstTableEntry RuleTable[] = {
/**
This data member of the ThaiGlyphPUASubstitution class holds rules
on when a given PUA glyph should be substituted for the original
0x0Exx glyph. Table lookup returns the first match found from the
start of the table, therefore duplicate match situations must be
avoided in the rule set logic.
*/
/* iOrigGlyph, iPUAGlyph, iRuleFunc */
// Substitutions for a tone or sign mark above a short consonant
{ 0x0E48, 0xF70A, RuleShortConsonant },
{ 0x0E49, 0xF70B, RuleShortConsonant },
{ 0x0E4A, 0xF70C, RuleShortConsonant },
{ 0x0E4B, 0xF70D, RuleShortConsonant },
{ 0x0E4C, 0xF70E, RuleShortConsonant },
// Substitutions for a vowel or sign mark above a tall consonant
{ 0x0E34, 0xF701, RuleTallConsonant },
{ 0x0E35, 0xF702, RuleTallConsonant },
{ 0x0E36, 0xF703, RuleTallConsonant },
{ 0x0E37, 0xF704, RuleTallConsonant },
{ 0x0E31, 0xF710, RuleTallConsonant },
{ 0x0E4D, 0xF711, RuleTallConsonant },
{ 0x0E47, 0xF712, RuleTallConsonant },
// Substitutions for a tone or sign mark above a tall consonant
{ 0x0E48, 0xF705, RuleTallConsonantNoVowelAbove },
{ 0x0E49, 0xF706, RuleTallConsonantNoVowelAbove },
{ 0x0E4A, 0xF707, RuleTallConsonantNoVowelAbove },
{ 0x0E4B, 0xF708, RuleTallConsonantNoVowelAbove },
{ 0x0E4C, 0xF709, RuleTallConsonantNoVowelAbove },
// Substitutions for a tone or sign mark above a vowel which is
// above a tall consonant
{ 0x0E48, 0xF713, RuleTallConsonantVowelAbove },
{ 0x0E49, 0xF714, RuleTallConsonantVowelAbove },
{ 0x0E4A, 0xF715, RuleTallConsonantVowelAbove },
{ 0x0E4B, 0xF716, RuleTallConsonantVowelAbove },
{ 0x0E4C, 0xF717, RuleTallConsonantVowelAbove },
// Substitutions for a vowel or sign mark below a consonant with a
// joined descender
{ 0x0E38, 0xF718, RuleConsonantWithJointDescender },
{ 0x0E39, 0xF719, RuleConsonantWithJointDescender },
{ 0x0E3A, 0xF71A, RuleConsonantWithJointDescender },
{ 0, 0, 0}
// Size of table at last measurement was 312 bytes. 27/6/2003
};
/**
This is the lookup method to determine if the current character being
processed needs to be substituted for a glyph in the PUA area given the
supplied context. It scans the rule table and returns when it finds it's
first match. Therefore duplicate match situations must be avoided in
the rule set logic.
@param aCode
On input it is the character to lookup, on exit it is either unchanged
or a code in the PUA 0xF700..0xF71A.
@param aGss
Container object holds the glyph selection context for the method.
@return TBool
ETrue when a match is found and aCode has changed, EFalse otherwise.
*/
TBool Lookup(TUint& aCode, const TGlyphSelectionState& aGss)
{
const PUASubstTableEntry* tablePtr = RuleTable;
while (tablePtr->iOrigGlyph)
{
if ((aCode == tablePtr->iOrigGlyph) && tablePtr->iRuleFunc(aGss))
{
aCode = tablePtr->iPUAGlyph;
return ETrue; // Rule match, substitute glyph code
}
tablePtr++;
}
return EFalse; // No match in table
}
}
//
//
// GlyphSelector_Thai Class definition
//
//
/**
This is the default glyph processing method for the Thai characters in the
range 0x0E00..0x0E7F and is invoked from the Glyph selection algorithm in
CFont::GetCharacterPosition() method. It is capable of processing base
Thai characters as well as Thai combining vowels, signs a tone marks.
@param aGss
Container object holds the input/output parameters of the method.
@return TBool
ETrue when glyph cluster updated successfully, EFalse on error condition.
@see
The method GlyphSelector_Thai::Process() also handles it for other cases.
*/
TBool GlyphSelector_Thai::Process(TGlyphSelectionState& aGss, RShapeInfo&)
{
// Get the Unicode character codes we need to process the current
// glyph and increment the iterator onto th next character.
TUint prevCode = (aGss.iText.LengthToStart() > 0) ? aGss.iText.Get(-1) : 0xFFFF;
TUint code = aGss.iText.GetThenNext(); // Inc to next char
TUint nextCode = !aGss.iText.AtEnd() ? aGss.iText.Get(0) : 0xFFFF;
// Is it a Thai base char or a mark (combining) char?
if ((aGss.iCats & 0xF0) == TChar::EMarkGroup)
{
// Thai character is combining mark but first check to see if it
// follows a Thai base character before processing it.
if ((aGss.iParam.iOutputGlyphs > 0) &&
!ThaiGlyph::IsThaiGlyph(prevCode))
{
(void) aGss.iText.Prev();
aGss.iClusterState = TGlyphSelectionState::EGClusterComplete;
return ETrue;
}
// Missing base glyph? Insert a dotted circle glyph if true.
if (aGss.iParam.iOutputGlyphs == 0)
{
if (!aGss.AppendGlyphToCluster(KUnicodeDottedCircle))
return EFalse;
aGss.iParam.iPen += aGss.iAdvance;
}
// Test if SARA AM follows this current Thai mark, since it is
// a SPECIAL CASE. If present we need NIKHAHIT glyph before this
// current Thai mark char.
if (nextCode == ThaiGlyph::KSaraAm &&
(aGss.iParam.iOutputGlyphs == 1) && ThaiGlyph::IsThaiToneMark(code))
{
TUint nikhahit = ThaiGlyph::KNikhahit;
// Check and do PUA glyph substitution on Nikhahit
ThaiGlyphPUASubstitution::Lookup(nikhahit, aGss);
if (!aGss.AppendGlyphToCluster(nikhahit))
return EFalse;
// Check and do PUA glyph substitution on combining mark
ThaiGlyphPUASubstitution::Lookup(code, aGss);
// Append the curernt Thai Mark to the output stack of glyphs.
if (!aGss.AppendGlyphToCluster(code))
return EFalse;
// We now need to add SARA AA glyph after the current Thai mark char.
aGss.iAdvance.iWidth = aGss.iAdvance.iHeight = 0;
if (!aGss.AppendGlyphToCluster(ThaiGlyph::KSaraAa))
return EFalse;
// Skip the following SARA AM character since we've added
// its glyphs to it's previous character's glyph cluster.
// As we've added a base char to the end of the glyph cluster
// make sure the pen is moved on by the caller.
(void) aGss.iText.Next();
aGss.iPen = TGlyphSelectionState::EPenAdvance_Yes;
}
else
{
// Check and do PUA glyph substitution on combining mark
ThaiGlyphPUASubstitution::Lookup(code, aGss);
// Append the curernt Thai Mark to the output stack of glyphs.
if (!aGss.AppendGlyphToCluster(code))
return EFalse;
aGss.iPen = TGlyphSelectionState::EPenAdvance_No;
}
}
else
{
// Thai character is an independent consonant, digit or sign
// Handle disjoint descender consonants followed by below vowel.
// In these two cases we substitute consonant with PUA
// consonant that the descender removed. Check code not last one.
if (code == ThaiGlyph::KYoYing && nextCode != 0xffff &&
ThaiGlyph::IsThaiDepVowelBelow(nextCode))
code = ThaiGlyph::KYoYingPua;
else if (code == ThaiGlyph::KThoThan && nextCode != 0xffff &&
ThaiGlyph::IsThaiDepVowelBelow(nextCode))
code = ThaiGlyph::KThoThanPua;
// Append the glyph details for the Thai character onto the output
// stack of glyphs.
if (!aGss.AppendGlyphToCluster(code))
return EFalse;
// Make sure the caller advances the pen for a base char!
aGss.iPen = TGlyphSelectionState::EPenAdvance_Yes;
}
// Lookup in rule table to determine if the current glyph and cluster is
// now complete?
if (ThaiCharRules::LookupWtt2Rule(aGss.iCodePt, nextCode) == ThaiCharRules::EComposite)
aGss.iClusterState = TGlyphSelectionState::EGClusterNotComplete;
else
aGss.iClusterState = TGlyphSelectionState::EGClusterComplete;
return ETrue;
}
//
//
// GlyphSelector_ThaiSaraAm Class definition
//
//
/**
This is the glyph processing method for the Thai SARA AM (U+0E33) character
which is handled as a special case since it is decomposed into two glyphs
- the combining NIKHAHIT mark & SARA AA following vowel in some cases.
It is invoked from the Glyph selection algorithm in
CFont::GetCharacterPosition() method for all cases where SARA AM is not
following a tone mark and thus be a glyph cluster of its own.
@param aGss
Container object holds the input/output parameters of the method.
@return TBool
ETrue when glyph cluster updated successfully, EFalse on error condition.
@see
The method GlyphSelector_Thai::Process() also handles it for other cases.
*/
TBool GlyphSelector_ThaiSaraAm::Process(TGlyphSelectionState& aGss, RShapeInfo&)
{
if (aGss.iCodePt != ThaiGlyph::KSaraAm) //could have got here via
{ //FindLocalisedProcessFunc in font.cpp
RShapeInfo dummy;
return GlyphSelector_Thai::Process(aGss, dummy);
}
// Pen advance accumulator local variable
TSize compoundAdvance;
if (aGss.iText.LengthToStart() == 0)
{
// If at the start of a line then render it with a preceding
// dotted circle as this is invalid positioning for SARA AM.
if (!aGss.AppendGlyphToCluster(KUnicodeDottedCircle))
return EFalse;
aGss.iParam.iPen += aGss.iAdvance;
aGss.iAdvance.iWidth = aGss.iAdvance.iHeight = 0;
if (!aGss.AppendGlyphToCluster(ThaiGlyph::KSaraAm))
return EFalse;
compoundAdvance += aGss.iAdvance;
}
else
{
// Normal condition - text iterator now some way into the text line
// being processed.
TUint prevChar = aGss.iText.Get(-1);
if (ThaiGlyph::IsThaiShortConsonant(prevChar))
{
// SARA AM is following normal height consonant so we can output
// non-decomposed SARA AM glyph.
if (!aGss.AppendGlyphToCluster(ThaiGlyph::KSaraAm))
return EFalse;
compoundAdvance = aGss.iAdvance;
}
else if (ThaiGlyph::IsThaiTallConsonant(prevChar))
{
// SARA AM is following tall consonant so we output decomposed
// version of SARA AM but with NIKHAHIT taken from the PUA.
if (!aGss.AppendGlyphToCluster(ThaiGlyph::KNikhahitPua))
return EFalse;
compoundAdvance = aGss.iAdvance;
aGss.iAdvance.iWidth = aGss.iAdvance.iHeight = 0;
if (!aGss.AppendGlyphToCluster(ThaiGlyph::KSaraAa))
return EFalse;
compoundAdvance += aGss.iAdvance;
}
else
{
// SARA AM is a following vowel but is not following a valid
// consonant char and so default is to render with dotted circle.
if (!aGss.AppendGlyphToCluster(KUnicodeDottedCircle))
return EFalse;
aGss.iParam.iPen += aGss.iAdvance;
aGss.iAdvance.iWidth = aGss.iAdvance.iHeight = 0;
if (!aGss.AppendGlyphToCluster(ThaiGlyph::KSaraAm))
return EFalse;
compoundAdvance += aGss.iAdvance;
}
}
// Update output parameters resulting from above processing.
// Move text iterator onto next character to process.
aGss.iText.Next();
// Advance pen just for the SARA AA char as advance for dotted
// circle is done above.
aGss.iAdvance = compoundAdvance;
aGss.iPen = TGlyphSelectionState::EPenAdvance_Yes;
if (!aGss.iText.AtEnd() &&
(ThaiCharRules::LookupWtt2Rule(aGss.iCodePt, aGss.iText.Get()) ==
ThaiCharRules::EComposite))
aGss.iClusterState = TGlyphSelectionState::EGClusterNotComplete;
else
aGss.iClusterState = TGlyphSelectionState::EGClusterComplete;
return ETrue;
}