icuSources/layout/MorphTables2.cpp

   1 /*
   2  * (C) Copyright IBM Corp. and others 1998 - 2013 - All Rights Reserved
   3  *
   4  */
   5
   6 #include "LETypes.h"
   7 #include "LayoutTables.h"
   8 #include "MorphTables.h"
   9 #include "SubtableProcessor2.h"
  10 #include "IndicRearrangementProcessor2.h"
  11 #include "ContextualGlyphSubstProc2.h"
  12 #include "LigatureSubstProc2.h"
  13 #include "NonContextualGlyphSubstProc2.h"
  14 #include "ContextualGlyphInsertionProc2.h"
  15 #include "LEGlyphStorage.h"
  16 #include "LESwaps.h"
  17
  18 U_NAMESPACE_BEGIN
  19
  20 void MorphTableHeader2::process(LEGlyphStorage &glyphStorage, le_int32 typoFlags) const
  21 {
  22     const ChainHeader2 *chainHeader = chains;
  23     le_uint32 chainCount = SWAPL(this->nChains);
  24         le_uint32 chain;
  25
  26     for (chain = 0; chain < chainCount; chain++) {
  27         FeatureFlags flag = SWAPL(chainHeader->defaultFlags);
  28         le_uint32 chainLength = SWAPL(chainHeader->chainLength);
  29         le_uint32 nFeatureEntries = SWAPL(chainHeader->nFeatureEntries);
  30         le_uint32 nSubtables = SWAPL(chainHeader->nSubtables);
  31         const MorphSubtableHeader2 *subtableHeader =
  32             (const MorphSubtableHeader2 *)&chainHeader->featureTable[nFeatureEntries];
  33         le_uint32 subtable;
  34
  35         if (typoFlags != 0) {
  36            le_uint32 featureEntry;
  37
  38             // Feature subtables
  39             for (featureEntry = 0; featureEntry < nFeatureEntries; featureEntry++) {
  40                 FeatureTableEntry featureTableEntry = chains->featureTable[featureEntry];
  41                 le_int16 featureType = SWAPW(featureTableEntry.featureType);
  42                 le_int16 featureSetting = SWAPW(featureTableEntry.featureSetting);
  43                 le_uint32 enableFlags = SWAPL(featureTableEntry.enableFlags);
  44                 le_uint32 disableFlags = SWAPL(featureTableEntry.disableFlags);
  45                 switch (featureType) {
  46                     case ligaturesType:
  47                         if ((typoFlags & LE_Ligatures_FEATURE_ENUM ) && (featureSetting ^ 0x1)){
  48                             flag &= disableFlags;
  49                             flag |= enableFlags;
  50                         } else {
  51                             if (((typoFlags & LE_RLIG_FEATURE_FLAG) && featureSetting == requiredLigaturesOnSelector) ||
  52                                 ((typoFlags & LE_CLIG_FEATURE_FLAG) && featureSetting == contextualLigaturesOnSelector) ||
  53                                 ((typoFlags & LE_HLIG_FEATURE_FLAG) && featureSetting == historicalLigaturesOnSelector) ||
  54                                 ((typoFlags & LE_LIGA_FEATURE_FLAG) && featureSetting == commonLigaturesOnSelector)) {
  55                                 flag &= disableFlags;
  56                                 flag |= enableFlags;
  57                             }
  58                         }
  59                         break;
  60                     case letterCaseType:
  61                         if ((typoFlags & LE_SMCP_FEATURE_FLAG) && featureSetting == smallCapsSelector) {
  62                             flag &= disableFlags;
  63                             flag |= enableFlags;
  64                         }
  65                         break;
  66                     case verticalSubstitutionType:
  67                         break;
  68                     case linguisticRearrangementType:
  69                         break;
  70                     case numberSpacingType:
  71                         break;
  72                     case smartSwashType:
  73                         if ((typoFlags & LE_SWSH_FEATURE_FLAG) && (featureSetting ^ 0x1)){
  74                             flag &= disableFlags;
  75                             flag |= enableFlags;
  76                         }
  77                         break;
  78                     case diacriticsType:
  79                         break;
  80                     case verticalPositionType:
  81                         break;
  82                     case fractionsType:
  83                         if (((typoFlags & LE_FRAC_FEATURE_FLAG) && featureSetting == diagonalFractionsSelector) ||
  84                             ((typoFlags & LE_AFRC_FEATURE_FLAG) && featureSetting == verticalFractionsSelector)) {
  85                             flag &= disableFlags;
  86                             flag |= enableFlags;
  87                         } else {
  88                             flag &= disableFlags;
  89                         }
  90                         break;
  91                     case typographicExtrasType:
  92                         if ((typoFlags & LE_ZERO_FEATURE_FLAG) && featureSetting == slashedZeroOnSelector) {
  93                             flag &= disableFlags;
  94                             flag |= enableFlags;
  95                         }
  96                         break;
  97                     case mathematicalExtrasType:
  98                         break;
  99                     case ornamentSetsType:
 100                         break;
 101                     case characterAlternativesType:
 102                         break;
 103                     case designComplexityType:
 104                         if (((typoFlags & LE_SS01_FEATURE_FLAG) && featureSetting == designLevel1Selector) ||
 105                             ((typoFlags & LE_SS02_FEATURE_FLAG) && featureSetting == designLevel2Selector) ||
 106                             ((typoFlags & LE_SS03_FEATURE_FLAG) && featureSetting == designLevel3Selector) ||
 107                             ((typoFlags & LE_SS04_FEATURE_FLAG) && featureSetting == designLevel4Selector) ||
 108                             ((typoFlags & LE_SS05_FEATURE_FLAG) && featureSetting == designLevel5Selector) ||
 109                             ((typoFlags & LE_SS06_FEATURE_FLAG) && featureSetting == designLevel6Selector) ||
 110                             ((typoFlags & LE_SS07_FEATURE_FLAG) && featureSetting == designLevel7Selector)) {
 111
 112                             flag &= disableFlags;
 113                             flag |= enableFlags;
 114                         }
 115                         break;
 116                     case styleOptionsType:
 117                         break;
 118                     case characterShapeType:
 119                         break;
 120                     case numberCaseType:
 121                         break;
 122                     case textSpacingType:
 123                         break;
 124                     case transliterationType:
 125                         break;
 126                     case annotationType:
 127                         if ((typoFlags & LE_NALT_FEATURE_FLAG) && featureSetting == circleAnnotationSelector) {
 128                             flag &= disableFlags;
 129                             flag |= enableFlags;
 130                         }
 131                         break;
 132                     case kanaSpacingType:
 133                         break;
 134                     case ideographicSpacingType:
 135                         break;
 136                     case rubyKanaType:
 137                         if ((typoFlags & LE_RUBY_FEATURE_FLAG) && featureSetting == rubyKanaOnSelector) {
 138                             flag &= disableFlags;
 139                             flag |= enableFlags;
 140                         }
 141                         break;
 142                     case cjkRomanSpacingType:
 143                         break;
 144                     default:
 145                         break;
 146                 }
 147             }
 148         }
 149
 150         for (subtable = 0; subtable < nSubtables; subtable++) {
 151             le_uint32 length = SWAPL(subtableHeader->length);
 152             le_uint32 coverage = SWAPL(subtableHeader->coverage);
 153             FeatureFlags subtableFeatures = SWAPL(subtableHeader->subtableFeatures);
 154             // should check coverage more carefully...
 155             if (((coverage & scfIgnoreVt2) || !(coverage & scfVertical2)) && (subtableFeatures & flag) != 0) {
 156                 subtableHeader->process(glyphStorage);
 157             }
 158             subtableHeader = (const MorphSubtableHeader2 *) ((char *)subtableHeader + length);
 159         }
 160         chainHeader = (const ChainHeader2 *)((char *)chainHeader + chainLength);
 161     }
 162 }
 163
 164 void MorphSubtableHeader2::process(LEGlyphStorage &glyphStorage) const
 165 {
 166     SubtableProcessor2 *processor = NULL;
 167
 168     switch (SWAPL(coverage) & scfTypeMask2)
 169     {
 170     case mstIndicRearrangement:
 171         processor = new IndicRearrangementProcessor2(this);
 172         break;
 173
 174     case mstContextualGlyphSubstitution:
 175         processor = new ContextualGlyphSubstitutionProcessor2(this);
 176         break;
 177
 178     case mstLigatureSubstitution:
 179         processor = new LigatureSubstitutionProcessor2(this);
 180         break;
 181
 182     case mstReservedUnused:
 183         break;
 184
 185     case mstNonContextualGlyphSubstitution:
 186         processor = NonContextualGlyphSubstitutionProcessor2::createInstance(this);
 187         break;
 188
 189
 190     case mstContextualGlyphInsertion:
 191         processor = new ContextualGlyphInsertionProcessor2(this);
 192         break;
 193
 194     default:
 195         break;
 196     }
 197
 198     if (processor != NULL) {
 199         processor->process(glyphStorage);
 200         delete processor;
 201     }
 202 }
 203
 204 U_NAMESPACE_END