1 /* 2 * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies) 3 * 4 * This is part of HarfBuzz, an OpenType Layout engine library. 5 * 6 * Permission is hereby granted, without written agreement and without 7 * license or royalty fees, to use, copy, modify, and distribute this 8 * software and its documentation for any purpose, provided that the 9 * above copyright notice and the following two paragraphs appear in 10 * all copies of this software. 11 * 12 * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR 13 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES 14 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN 15 * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH 16 * DAMAGE. 17 * 18 * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, 19 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND 20 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS 21 * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO 22 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. 23 */ 24 25 #include "harfbuzz-shaper.h" 26 #include "harfbuzz-shaper-private.h" 27 #include <assert.h> 28 29 #ifndef NO_OPENTYPE 30 static const HB_OpenTypeFeature greek_features[] = { 31 { HB_MAKE_TAG('c', 'c', 'm', 'p'), CcmpProperty }, 32 { HB_MAKE_TAG('l', 'i', 'g', 'a'), CcmpProperty }, 33 { HB_MAKE_TAG('c', 'l', 'i', 'g'), CcmpProperty }, 34 {0, 0} 35 }; 36 #endif 37 38 /* 39 Greek decompositions 40 */ 41 42 43 typedef struct _hb_greek_decomposition { 44 HB_UChar16 composed; 45 HB_UChar16 base; 46 } hb_greek_decomposition; 47 48 static const hb_greek_decomposition decompose_0x300[] = { 49 { 0x1FBA, 0x0391 }, 50 { 0x1FC8, 0x0395 }, 51 { 0x1FCA, 0x0397 }, 52 { 0x1FDA, 0x0399 }, 53 { 0x1FF8, 0x039F }, 54 { 0x1FEA, 0x03A5 }, 55 { 0x1FFA, 0x03A9 }, 56 { 0x1F70, 0x03B1 }, 57 { 0x1F72, 0x03B5 }, 58 { 0x1F74, 0x03B7 }, 59 { 0x1F76, 0x03B9 }, 60 { 0x1F78, 0x03BF }, 61 { 0x1F7A, 0x03C5 }, 62 { 0x1F7C, 0x03C9 }, 63 { 0x1FD2, 0x03CA }, 64 { 0x1FE2, 0x03CB }, 65 { 0x1F02, 0x1F00 }, 66 { 0, 0 } 67 }; 68 69 static HB_UChar16 compose_0x300(HB_UChar16 base) 70 { 71 if ((base ^ 0x1f00) < 0x100) { 72 if (base <= 0x1f69 && !(base & 0x6)) 73 return base + 2; 74 if (base == 0x1fbf) 75 return 0x1fcd; 76 if (base == 0x1ffe) 77 return 0x1fdd; 78 return 0; 79 } 80 { 81 const hb_greek_decomposition *d = decompose_0x300; 82 while (d->base && d->base != base) 83 ++d; 84 return d->composed; 85 } 86 } 87 88 static const hb_greek_decomposition decompose_0x301[] = { 89 { 0x0386, 0x0391 }, 90 { 0x0388, 0x0395 }, 91 { 0x0389, 0x0397 }, 92 { 0x038A, 0x0399 }, 93 { 0x038C, 0x039F }, 94 { 0x038E, 0x03A5 }, 95 { 0x038F, 0x03A9 }, 96 { 0x03AC, 0x03B1 }, 97 { 0x03AD, 0x03B5 }, 98 { 0x03AE, 0x03B7 }, 99 { 0x03AF, 0x03B9 }, 100 { 0x03CC, 0x03BF }, 101 { 0x03CD, 0x03C5 }, 102 { 0x03CE, 0x03C9 }, 103 { 0x0390, 0x03CA }, 104 { 0x03B0, 0x03CB }, 105 { 0x03D3, 0x03D2 }, 106 { 0, 0 } 107 }; 108 109 110 static HB_UChar16 compose_0x301(HB_UChar16 base) 111 { 112 if ((base ^ 0x1f00) < 0x100) { 113 if (base <= 0x1f69 && !(base & 0x6)) 114 return base + 4; 115 if (base == 0x1fbf) 116 return 0x1fce; 117 if (base == 0x1ffe) 118 return 0x1fde; 119 } 120 { 121 const hb_greek_decomposition *d = decompose_0x301; 122 while (d->base && d->base != base) 123 ++d; 124 return d->composed; 125 } 126 } 127 128 static const hb_greek_decomposition decompose_0x304[] = { 129 { 0x1FB9, 0x0391 }, 130 { 0x1FD9, 0x0399 }, 131 { 0x1FE9, 0x03A5 }, 132 { 0x1FB1, 0x03B1 }, 133 { 0x1FD1, 0x03B9 }, 134 { 0x1FE1, 0x03C5 }, 135 { 0, 0 } 136 }; 137 138 static HB_UChar16 compose_0x304(HB_UChar16 base) 139 { 140 const hb_greek_decomposition *d = decompose_0x304; 141 while (d->base && d->base != base) 142 ++d; 143 return d->composed; 144 } 145 146 static const hb_greek_decomposition decompose_0x306[] = { 147 { 0x1FB8, 0x0391 }, 148 { 0x1FD8, 0x0399 }, 149 { 0x1FE8, 0x03A5 }, 150 { 0x1FB0, 0x03B1 }, 151 { 0x1FD0, 0x03B9 }, 152 { 0x1FE0, 0x03C5 }, 153 { 0, 0 } 154 }; 155 156 static HB_UChar16 compose_0x306(HB_UChar16 base) 157 { 158 const hb_greek_decomposition *d = decompose_0x306; 159 while (d->base && d->base != base) 160 ++d; 161 return d->composed; 162 } 163 164 static const hb_greek_decomposition decompose_0x308[] = { 165 { 0x03AA, 0x0399 }, 166 { 0x03AB, 0x03A5 }, 167 { 0x03CA, 0x03B9 }, 168 { 0x03CB, 0x03C5 }, 169 { 0x03D4, 0x03D2 }, 170 { 0, 0 } 171 }; 172 173 static HB_UChar16 compose_0x308(HB_UChar16 base) 174 { 175 const hb_greek_decomposition *d = decompose_0x308; 176 while (d->base && d->base != base) 177 ++d; 178 return d->composed; 179 } 180 181 182 static const hb_greek_decomposition decompose_0x313[] = { 183 { 0x1F08, 0x0391 }, 184 { 0x1F18, 0x0395 }, 185 { 0x1F28, 0x0397 }, 186 { 0x1F38, 0x0399 }, 187 { 0x1F48, 0x039F }, 188 { 0x1F68, 0x03A9 }, 189 { 0x1F00, 0x03B1 }, 190 { 0x1F10, 0x03B5 }, 191 { 0x1F20, 0x03B7 }, 192 { 0x1F30, 0x03B9 }, 193 { 0x1F40, 0x03BF }, 194 { 0x1FE4, 0x03C1 }, 195 { 0x1F50, 0x03C5 }, 196 { 0x1F60, 0x03C9 }, 197 { 0, 0 } 198 }; 199 200 static HB_UChar16 compose_0x313(HB_UChar16 base) 201 { 202 const hb_greek_decomposition *d = decompose_0x313; 203 while (d->base && d->base != base) 204 ++d; 205 return d->composed; 206 } 207 208 static const hb_greek_decomposition decompose_0x314[] = { 209 { 0x1F09, 0x0391 }, 210 { 0x1F19, 0x0395 }, 211 { 0x1F29, 0x0397 }, 212 { 0x1F39, 0x0399 }, 213 { 0x1F49, 0x039F }, 214 { 0x1FEC, 0x03A1 }, 215 { 0x1F59, 0x03A5 }, 216 { 0x1F69, 0x03A9 }, 217 { 0x1F01, 0x03B1 }, 218 { 0x1F11, 0x03B5 }, 219 { 0x1F21, 0x03B7 }, 220 { 0x1F31, 0x03B9 }, 221 { 0x1F41, 0x03BF }, 222 { 0x1FE5, 0x03C1 }, 223 { 0x1F51, 0x03C5 }, 224 { 0x1F61, 0x03C9 }, 225 { 0, 0 } 226 }; 227 228 static HB_UChar16 compose_0x314(HB_UChar16 base) 229 { 230 const hb_greek_decomposition *d = decompose_0x314; 231 while (d->base && d->base != base) 232 ++d; 233 return d->composed; 234 } 235 236 static const hb_greek_decomposition decompose_0x342[] = { 237 { 0x1FB6, 0x03B1 }, 238 { 0x1FC6, 0x03B7 }, 239 { 0x1FD6, 0x03B9 }, 240 { 0x1FE6, 0x03C5 }, 241 { 0x1FF6, 0x03C9 }, 242 { 0x1FD7, 0x03CA }, 243 { 0x1FE7, 0x03CB }, 244 { 0x1F06, 0x1F00 }, 245 { 0x1F07, 0x1F01 }, 246 { 0x1F0E, 0x1F08 }, 247 { 0x1F0F, 0x1F09 }, 248 { 0x1F26, 0x1F20 }, 249 { 0x1F27, 0x1F21 }, 250 { 0x1F2E, 0x1F28 }, 251 { 0x1F2F, 0x1F29 }, 252 { 0x1F36, 0x1F30 }, 253 { 0x1F37, 0x1F31 }, 254 { 0x1F3E, 0x1F38 }, 255 { 0x1F3F, 0x1F39 }, 256 { 0x1F56, 0x1F50 }, 257 { 0x1F57, 0x1F51 }, 258 { 0x1F5F, 0x1F59 }, 259 { 0x1F66, 0x1F60 }, 260 { 0x1F67, 0x1F61 }, 261 { 0x1F6E, 0x1F68 }, 262 { 0x1F6F, 0x1F69 }, 263 { 0x1FCF, 0x1FBF }, 264 { 0x1FDF, 0x1FFE }, 265 { 0, 0 } 266 }; 267 268 static HB_UChar16 compose_0x342(HB_UChar16 base) 269 { 270 const hb_greek_decomposition *d = decompose_0x342; 271 while (d->base && d->base != base) 272 ++d; 273 return d->composed; 274 } 275 276 static const hb_greek_decomposition decompose_0x345[] = { 277 { 0x1FBC, 0x0391 }, 278 { 0x1FCC, 0x0397 }, 279 { 0x1FFC, 0x03A9 }, 280 { 0x1FB4, 0x03AC }, 281 { 0x1FC4, 0x03AE }, 282 { 0x1FB3, 0x03B1 }, 283 { 0x1FC3, 0x03B7 }, 284 { 0x1FF3, 0x03C9 }, 285 { 0x1FF4, 0x03CE }, 286 { 0x1F80, 0x1F00 }, 287 { 0x1F81, 0x1F01 }, 288 { 0x1F82, 0x1F02 }, 289 { 0x1F83, 0x1F03 }, 290 { 0x1F84, 0x1F04 }, 291 { 0x1F85, 0x1F05 }, 292 { 0x1F86, 0x1F06 }, 293 { 0x1F87, 0x1F07 }, 294 { 0x1F88, 0x1F08 }, 295 { 0x1F89, 0x1F09 }, 296 { 0x1F8A, 0x1F0A }, 297 { 0x1F8B, 0x1F0B }, 298 { 0x1F8C, 0x1F0C }, 299 { 0x1F8D, 0x1F0D }, 300 { 0x1F8E, 0x1F0E }, 301 { 0x1F8F, 0x1F0F }, 302 { 0x1F90, 0x1F20 }, 303 { 0x1F91, 0x1F21 }, 304 { 0x1F92, 0x1F22 }, 305 { 0x1F93, 0x1F23 }, 306 { 0x1F94, 0x1F24 }, 307 { 0x1F95, 0x1F25 }, 308 { 0x1F96, 0x1F26 }, 309 { 0x1F97, 0x1F27 }, 310 { 0x1F98, 0x1F28 }, 311 { 0x1F99, 0x1F29 }, 312 { 0x1F9A, 0x1F2A }, 313 { 0x1F9B, 0x1F2B }, 314 { 0x1F9C, 0x1F2C }, 315 { 0x1F9D, 0x1F2D }, 316 { 0x1F9E, 0x1F2E }, 317 { 0x1F9F, 0x1F2F }, 318 { 0x1FA0, 0x1F60 }, 319 { 0x1FA1, 0x1F61 }, 320 { 0x1FA2, 0x1F62 }, 321 { 0x1FA3, 0x1F63 }, 322 { 0x1FA4, 0x1F64 }, 323 { 0x1FA5, 0x1F65 }, 324 { 0x1FA6, 0x1F66 }, 325 { 0x1FA7, 0x1F67 }, 326 { 0x1FA8, 0x1F68 }, 327 { 0x1FA9, 0x1F69 }, 328 { 0x1FAA, 0x1F6A }, 329 { 0x1FAB, 0x1F6B }, 330 { 0x1FAC, 0x1F6C }, 331 { 0x1FAD, 0x1F6D }, 332 { 0x1FAE, 0x1F6E }, 333 { 0x1FAF, 0x1F6F }, 334 { 0x1FB2, 0x1F70 }, 335 { 0x1FC2, 0x1F74 }, 336 { 0x1FF2, 0x1F7C }, 337 { 0x1FB7, 0x1FB6 }, 338 { 0x1FC7, 0x1FC6 }, 339 { 0x1FF7, 0x1FF6 }, 340 { 0, 0 } 341 }; 342 343 static HB_UChar16 compose_0x345(HB_UChar16 base) 344 { 345 const hb_greek_decomposition *d = decompose_0x345; 346 while (d->base && d->base != base) 347 ++d; 348 return d->composed; 349 } 350 351 /* 352 Greek shaping. Heuristic positioning can't render polytonic greek correctly. We're a lot 353 better off mapping greek chars with diacritics to the characters in the extended greek 354 region in Unicode if possible. 355 */ 356 HB_Bool HB_GreekShape(HB_ShaperItem *shaper_item) 357 { 358 const int availableGlyphs = shaper_item->num_glyphs; 359 const HB_UChar16 *uc = shaper_item->string + shaper_item->item.pos; 360 unsigned short *logClusters = shaper_item->log_clusters; 361 HB_GlyphAttributes *attributes = shaper_item->attributes; 362 363 HB_Bool haveGlyphs; 364 int slen = 1; 365 int cluster_start = 0; 366 hb_uint32 i; 367 368 HB_STACKARRAY(HB_UChar16, shapedChars, 2 * shaper_item->item.length); 369 370 assert(shaper_item->item.script == HB_Script_Greek); 371 372 *shapedChars = *uc; 373 logClusters[0] = 0; 374 375 for (i = 1; i < shaper_item->item.length; ++i) { 376 hb_uint16 base = shapedChars[slen-1]; 377 hb_uint16 shaped = 0; 378 if (uc[i] == 0x300) 379 shaped = compose_0x300(base); 380 else if (uc[i] == 0x301) 381 shaped = compose_0x301(base); 382 else if (uc[i] == 0x304) 383 shaped = compose_0x304(base); 384 else if (uc[i] == 0x306) 385 shaped = compose_0x306(base); 386 else if (uc[i] == 0x308) 387 shaped = compose_0x308(base); 388 else if (uc[i] == 0x313) 389 shaped = compose_0x313(base); 390 else if (uc[i] == 0x314) 391 shaped = compose_0x314(base); 392 else if (uc[i] == 0x342) 393 shaped = compose_0x342(base); 394 else if (uc[i] == 0x345) 395 shaped = compose_0x345(base); 396 397 if (shaped) { 398 if (shaper_item->font->klass->canRender(shaper_item->font, (HB_UChar16 *)&shaped, 1)) { 399 shapedChars[slen-1] = shaped; 400 } else { 401 shaped = 0; 402 } 403 } 404 405 if (!shaped) { 406 HB_CharCategory category; 407 int cmb; 408 shapedChars[slen] = uc[i]; 409 HB_GetUnicodeCharProperties(uc[i], &category, &cmb); 410 if (category != HB_Mark_NonSpacing) { 411 attributes[slen].clusterStart = TRUE; 412 attributes[slen].mark = FALSE; 413 attributes[slen].combiningClass = 0; 414 attributes[slen].dontPrint = HB_IsControlChar(uc[i]); 415 cluster_start = slen; 416 } else { 417 attributes[slen].clusterStart = FALSE; 418 attributes[slen].mark = TRUE; 419 attributes[slen].combiningClass = cmb; 420 } 421 ++slen; 422 } 423 logClusters[i] = cluster_start; 424 } 425 426 haveGlyphs = shaper_item->font->klass 427 ->convertStringToGlyphIndices(shaper_item->font, 428 shapedChars, slen, 429 shaper_item->glyphs, &shaper_item->num_glyphs, 430 shaper_item->item.bidiLevel % 2); 431 432 HB_FREE_STACKARRAY(shapedChars); 433 434 if (!haveGlyphs) 435 return FALSE; 436 437 #ifndef NO_OPENTYPE 438 if (HB_SelectScript(shaper_item, greek_features)) { 439 HB_OpenTypeShape(shaper_item, /*properties*/0); 440 return HB_OpenTypePosition(shaper_item, availableGlyphs, /*doLogClusters*/TRUE); 441 } 442 #endif 443 HB_HeuristicPosition(shaper_item); 444 445 return TRUE; 446 } 447 448
