1 /* 2 * Copyright (C) 2008 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 28 #include <assert.h> 29 30 static const HB_UChar16 ReplacementCharacter = 0xfffd; 31 32 typedef struct { 33 unsigned char shape; 34 unsigned char justification; 35 } HB_ArabicProperties; 36 37 typedef enum { 38 XIsolated, 39 XFinal, 40 XInitial, 41 XMedial, 42 /* intermediate state */ 43 XCausing 44 } ArabicShape; 45 46 /* 47 // these groups correspond to the groups defined in the Unicode standard. 48 // Some of these groups are equal with regards to both joining and line breaking behaviour, 49 // and thus have the same enum value 50 // 51 // I'm not sure the mapping of syriac to arabic enums is correct with regards to justification, but as 52 // I couldn't find any better document I'll hope for the best. 53 */ 54 typedef enum { 55 /* NonJoining */ 56 ArabicNone, 57 ArabicSpace, 58 /* Transparent */ 59 Transparent, 60 /* Causing */ 61 Center, 62 Kashida, 63 64 /* Arabic */ 65 /* Dual */ 66 Beh, 67 Noon, 68 Meem = Noon, 69 Heh = Noon, 70 KnottedHeh = Noon, 71 HehGoal = Noon, 72 SwashKaf = Noon, 73 Yeh, 74 Hah, 75 Seen, 76 Sad = Seen, 77 Tah, 78 Kaf = Tah, 79 Gaf = Tah, 80 Lam = Tah, 81 Ain, 82 Feh = Ain, 83 Qaf = Ain, 84 /* Right */ 85 Alef, 86 Waw, 87 Dal, 88 TehMarbuta = Dal, 89 Reh, 90 HamzaOnHehGoal, 91 YehWithTail = HamzaOnHehGoal, 92 YehBarre = HamzaOnHehGoal, 93 94 /* Syriac */ 95 /* Dual */ 96 Beth = Beh, 97 Gamal = Ain, 98 Heth = Noon, 99 Teth = Hah, 100 Yudh = Noon, 101 Kaph = Noon, 102 Lamadh = Lam, 103 Mim = Noon, 104 Nun = Noon, 105 Semakh = Noon, 106 FinalSemakh = Noon, 107 SyriacE = Ain, 108 Pe = Ain, 109 ReversedPe = Hah, 110 Qaph = Noon, 111 Shin = Noon, 112 Fe = Ain, 113 114 /* Right */ 115 Alaph = Alef, 116 Dalath = Dal, 117 He = Dal, 118 SyriacWaw = Waw, 119 Zain = Alef, 120 YudhHe = Waw, 121 Sadhe = HamzaOnHehGoal, 122 Taw = Dal, 123 124 /* Compiler bug? Otherwise ArabicGroupsEnd would be equal to Dal + 1. */ 125 Dummy = HamzaOnHehGoal, 126 ArabicGroupsEnd 127 } ArabicGroup; 128 129 static const unsigned char arabic_group[0x150] = { 130 ArabicNone, ArabicNone, ArabicNone, ArabicNone, 131 ArabicNone, ArabicNone, ArabicNone, ArabicNone, 132 ArabicNone, ArabicNone, ArabicNone, ArabicNone, 133 ArabicNone, ArabicNone, ArabicNone, ArabicNone, 134 135 Transparent, Transparent, Transparent, Transparent, 136 Transparent, Transparent, ArabicNone, ArabicNone, 137 ArabicNone, ArabicNone, ArabicNone, ArabicNone, 138 ArabicNone, ArabicNone, ArabicNone, ArabicNone, 139 140 ArabicNone, ArabicNone, Alef, Alef, 141 Waw, Alef, Yeh, Alef, 142 Beh, TehMarbuta, Beh, Beh, 143 Hah, Hah, Hah, Dal, 144 145 Dal, Reh, Reh, Seen, 146 Seen, Sad, Sad, Tah, 147 Tah, Ain, Ain, ArabicNone, 148 ArabicNone, ArabicNone, ArabicNone, ArabicNone, 149 150 /* 0x640 */ 151 Kashida, Feh, Qaf, Kaf, 152 Lam, Meem, Noon, Heh, 153 Waw, Yeh, Yeh, Transparent, 154 Transparent, Transparent, Transparent, Transparent, 155 156 Transparent, Transparent, Transparent, Transparent, 157 Transparent, Transparent, Transparent, Transparent, 158 Transparent, ArabicNone, ArabicNone, ArabicNone, 159 ArabicNone, ArabicNone, ArabicNone, ArabicNone, 160 161 ArabicNone, ArabicNone, ArabicNone, ArabicNone, 162 ArabicNone, ArabicNone, ArabicNone, ArabicNone, 163 ArabicNone, ArabicNone, ArabicNone, ArabicNone, 164 ArabicNone, ArabicNone, Beh, Qaf, 165 166 Transparent, Alef, Alef, Alef, 167 ArabicNone, Alef, Waw, Waw, 168 Yeh, Beh, Beh, Beh, 169 Beh, Beh, Beh, Beh, 170 171 /* 0x680 */ 172 Beh, Hah, Hah, Hah, 173 Hah, Hah, Hah, Hah, 174 Dal, Dal, Dal, Dal, 175 Dal, Dal, Dal, Dal, 176 177 Dal, Reh, Reh, Reh, 178 Reh, Reh, Reh, Reh, 179 Reh, Reh, Seen, Seen, 180 Seen, Sad, Sad, Tah, 181 182 Ain, Feh, Feh, Feh, 183 Feh, Feh, Feh, Qaf, 184 Qaf, Gaf, SwashKaf, Gaf, 185 Kaf, Kaf, Kaf, Gaf, 186 187 Gaf, Gaf, Gaf, Gaf, 188 Gaf, Lam, Lam, Lam, 189 Lam, Noon, Noon, Noon, 190 Noon, Noon, KnottedHeh, Hah, 191 192 /* 0x6c0 */ 193 TehMarbuta, HehGoal, HamzaOnHehGoal, HamzaOnHehGoal, 194 Waw, Waw, Waw, Waw, 195 Waw, Waw, Waw, Waw, 196 Yeh, YehWithTail, Yeh, Waw, 197 198 Yeh, Yeh, YehBarre, YehBarre, 199 ArabicNone, TehMarbuta, Transparent, Transparent, 200 Transparent, Transparent, Transparent, Transparent, 201 Transparent, ArabicNone, ArabicNone, Transparent, 202 203 Transparent, Transparent, Transparent, Transparent, 204 Transparent, ArabicNone, ArabicNone, Transparent, 205 Transparent, ArabicNone, Transparent, Transparent, 206 Transparent, Transparent, Dal, Reh, 207 208 ArabicNone, ArabicNone, ArabicNone, ArabicNone, 209 ArabicNone, ArabicNone, ArabicNone, ArabicNone, 210 ArabicNone, ArabicNone, Seen, Sad, 211 Ain, ArabicNone, ArabicNone, KnottedHeh, 212 213 /* 0x700 */ 214 ArabicNone, ArabicNone, ArabicNone, ArabicNone, 215 ArabicNone, ArabicNone, ArabicNone, ArabicNone, 216 ArabicNone, ArabicNone, ArabicNone, ArabicNone, 217 ArabicNone, ArabicNone, ArabicNone, ArabicNone, 218 219 Alaph, Transparent, Beth, Gamal, 220 Gamal, Dalath, Dalath, He, 221 SyriacWaw, Zain, Heth, Teth, 222 Teth, Yudh, YudhHe, Kaph, 223 224 Lamadh, Mim, Nun, Semakh, 225 FinalSemakh, SyriacE, Pe, ReversedPe, 226 Sadhe, Qaph, Dalath, Shin, 227 Taw, Beth, Gamal, Dalath, 228 229 Transparent, Transparent, Transparent, Transparent, 230 Transparent, Transparent, Transparent, Transparent, 231 Transparent, Transparent, Transparent, Transparent, 232 Transparent, Transparent, Transparent, Transparent, 233 234 Transparent, Transparent, Transparent, Transparent, 235 Transparent, Transparent, Transparent, Transparent, 236 Transparent, Transparent, Transparent, ArabicNone, 237 ArabicNone, Zain, Kaph, Fe, 238 }; 239 240 static ArabicGroup arabicGroup(unsigned short uc) 241 { 242 if (uc >= 0x0600 && uc < 0x750) 243 return (ArabicGroup) arabic_group[uc-0x600]; 244 else if (uc == 0x200d) 245 return Center; 246 else if (HB_GetUnicodeCharCategory(uc) == HB_Separator_Space) 247 return ArabicSpace; 248 else 249 return ArabicNone; 250 } 251 252 253 /* 254 Arabic shaping obeys a number of rules according to the joining classes (see Unicode book, section on 255 arabic). 256 257 Each unicode char has a joining class (right, dual (left&right), center (joincausing) or transparent). 258 transparent joining is not encoded in HB_UChar16::joining(), but applies to all combining marks and format marks. 259 260 Right join-causing: dual + center 261 Left join-causing: dual + right + center 262 263 Rules are as follows (for a string already in visual order, as we have it here): 264 265 R1 Transparent characters do not affect joining behaviour. 266 R2 A right joining character, that has a right join-causing char on the right will get form XRight 267 (R3 A left joining character, that has a left join-causing char on the left will get form XLeft) 268 Note: the above rule is meaningless, as there are no pure left joining characters defined in Unicode 269 R4 A dual joining character, that has a left join-causing char on the left and a right join-causing char on 270 the right will get form XMedial 271 R5 A dual joining character, that has a right join causing char on the right, and no left join causing char on the left 272 will get form XRight 273 R6 A dual joining character, that has a left join causing char on the left, and no right join causing char on the right 274 will get form XLeft 275 R7 Otherwise the character will get form XIsolated 276 277 Additionally we have to do the minimal ligature support for lam-alef ligatures: 278 279 L1 Transparent characters do not affect ligature behaviour. 280 L2 Any sequence of Alef(XRight) + Lam(XMedial) will form the ligature Alef.Lam(XLeft) 281 L3 Any sequence of Alef(XRight) + Lam(XLeft) will form the ligature Alef.Lam(XIsolated) 282 283 The state table below handles rules R1-R7. 284 */ 285 286 typedef enum { 287 JNone, 288 JCausing, 289 JDual, 290 JRight, 291 JTransparent 292 } Joining; 293 294 static const Joining joining_for_group[ArabicGroupsEnd] = { 295 /* NonJoining */ 296 JNone, /* ArabicNone */ 297 JNone, /* ArabicSpace */ 298 /* Transparent */ 299 JTransparent, /* Transparent */ 300 /* Causing */ 301 JCausing, /* Center */ 302 JCausing, /* Kashida */ 303 /* Dual */ 304 JDual, /* Beh */ 305 JDual, /* Noon */ 306 JDual, /* Yeh */ 307 JDual, /* Hah */ 308 JDual, /* Seen */ 309 JDual, /* Tah */ 310 JDual, /* Ain */ 311 /* Right */ 312 JRight, /* Alef */ 313 JRight, /* Waw */ 314 JRight, /* Dal */ 315 JRight, /* Reh */ 316 JRight /* HamzaOnHehGoal */ 317 }; 318 319 320 typedef struct { 321 ArabicShape form1; 322 ArabicShape form2; 323 } JoiningPair; 324 325 static const JoiningPair joining_table[5][4] = 326 /* None, Causing, Dual, Right */ 327 { 328 { { XIsolated, XIsolated }, { XIsolated, XCausing }, { XIsolated, XInitial }, { XIsolated, XIsolated } }, /* XIsolated */ 329 { { XFinal, XIsolated }, { XFinal, XCausing }, { XFinal, XInitial }, { XFinal, XIsolated } }, /* XFinal */ 330 { { XIsolated, XIsolated }, { XInitial, XCausing }, { XInitial, XMedial }, { XInitial, XFinal } }, /* XInitial */ 331 { { XFinal, XIsolated }, { XMedial, XCausing }, { XMedial, XMedial }, { XMedial, XFinal } }, /* XMedial */ 332 { { XIsolated, XIsolated }, { XIsolated, XCausing }, { XIsolated, XMedial }, { XIsolated, XFinal } }, /* XCausing */ 333 }; 334 335 336 /* 337 According to http://www.microsoft.com/middleeast/Arabicdev/IE6/KBase.asp 338 339 1. Find the priority of the connecting opportunities in each word 340 2. Add expansion at the highest priority connection opportunity 341 3. If more than one connection opportunity have the same highest value, 342 use the opportunity closest to the end of the word. 343 344 Following is a chart that provides the priority for connection 345 opportunities and where expansion occurs. The character group names 346 are those in table 6.6 of the UNICODE 2.0 book. 347 348 349 PrioritY Glyph Condition Kashida Location 350 351 Arabic_Kashida User inserted Kashida The user entered a Kashida in a position. After the user 352 (Shift+j or Shift+[E with hat]) Thus, it is the highest priority to insert an inserted kashida 353 automatic kashida. 354 355 Arabic_Seen Seen, Sad Connecting to the next character. After the character. 356 (Initial or medial form). 357 358 Arabic_HaaDal Teh Marbutah, Haa, Dal Connecting to previous character. Before the final form 359 of these characters. 360 361 Arabic_Alef Alef, Tah, Lam, Connecting to previous character. Before the final form 362 Kaf and Gaf of these characters. 363 364 Arabic_BaRa Reh, Yeh Connected to medial Beh Before preceding medial Baa 365 366 Arabic_Waw Waw, Ain, Qaf, Feh Connecting to previous character. Before the final form of 367 these characters. 368 369 Arabic_Normal Other connecting Connecting to previous character. Before the final form 370 characters of these characters. 371 372 373 374 This seems to imply that we have at most one kashida point per arabic word. 375 376 */ 377 378 static void getArabicProperties(const unsigned short *chars, int len, HB_ArabicProperties *properties) 379 { 380 /* qDebug("arabicSyriacOpenTypeShape: properties:"); */ 381 int lastPos = 0; 382 int lastGroup = ArabicNone; 383 int i = 0; 384 385 ArabicGroup group = arabicGroup(chars[0]); 386 Joining j = joining_for_group[group]; 387 ArabicShape shape = joining_table[XIsolated][j].form2; 388 properties[0].justification = HB_NoJustification; 389 390 for (i = 1; i < len; ++i) { 391 /* #### fix handling for spaces and punktuation */ 392 properties[i].justification = HB_NoJustification; 393 394 group = arabicGroup(chars[i]); 395 j = joining_for_group[group]; 396 397 if (j == JTransparent) { 398 properties[i].shape = XIsolated; 399 continue; 400 } 401 402 properties[lastPos].shape = joining_table[shape][j].form1; 403 shape = joining_table[shape][j].form2; 404 405 switch(lastGroup) { 406 case Seen: 407 if (properties[lastPos].shape == XInitial || properties[lastPos].shape == XMedial) 408 properties[i-1].justification = HB_Arabic_Seen; 409 break; 410 case Hah: 411 if (properties[lastPos].shape == XFinal) 412 properties[lastPos-1].justification = HB_Arabic_HaaDal; 413 break; 414 case Alef: 415 if (properties[lastPos].shape == XFinal) 416 properties[lastPos-1].justification = HB_Arabic_Alef; 417 break; 418 case Ain: 419 if (properties[lastPos].shape == XFinal) 420 properties[lastPos-1].justification = HB_Arabic_Waw; 421 break; 422 case Noon: 423 if (properties[lastPos].shape == XFinal) 424 properties[lastPos-1].justification = HB_Arabic_Normal; 425 break; 426 case ArabicNone: 427 break; 428 429 default: 430 assert(FALSE); 431 } 432 433 lastGroup = ArabicNone; 434 435 switch(group) { 436 case ArabicNone: 437 case Transparent: 438 /* ### Center should probably be treated as transparent when it comes to justification. */ 439 case Center: 440 break; 441 case ArabicSpace: 442 properties[i].justification = HB_Arabic_Space; 443 break; 444 case Kashida: 445 properties[i].justification = HB_Arabic_Kashida; 446 break; 447 case Seen: 448 lastGroup = Seen; 449 break; 450 451 case Hah: 452 case Dal: 453 lastGroup = Hah; 454 break; 455 456 case Alef: 457 case Tah: 458 lastGroup = Alef; 459 break; 460 461 case Yeh: 462 case Reh: 463 if (properties[lastPos].shape == XMedial && arabicGroup(chars[lastPos]) == Beh) 464 properties[lastPos-1].justification = HB_Arabic_BaRa; 465 break; 466 467 case Ain: 468 case Waw: 469 lastGroup = Ain; 470 break; 471 472 case Noon: 473 case Beh: 474 case HamzaOnHehGoal: 475 lastGroup = Noon; 476 break; 477 case ArabicGroupsEnd: 478 assert(FALSE); 479 } 480 481 lastPos = i; 482 } 483 properties[lastPos].shape = joining_table[shape][JNone].form1; 484 485 486 /* 487 for (int i = 0; i < len; ++i) 488 qDebug("arabic properties(%d): uc=%x shape=%d, justification=%d", i, chars[i], properties[i].shape, properties[i].justification); 489 */ 490 } 491 492 static Joining getNkoJoining(unsigned short uc) 493 { 494 if (uc < 0x7ca) 495 return JNone; 496 if (uc <= 0x7ea) 497 return JDual; 498 if (uc <= 0x7f3) 499 return JTransparent; 500 if (uc <= 0x7f9) 501 return JNone; 502 if (uc == 0x7fa) 503 return JCausing; 504 return JNone; 505 } 506 507 static void getNkoProperties(const unsigned short *chars, int len, HB_ArabicProperties *properties) 508 { 509 int lastPos = 0; 510 int i = 0; 511 512 Joining j = getNkoJoining(chars[0]); 513 ArabicShape shape = joining_table[XIsolated][j].form2; 514 properties[0].justification = HB_NoJustification; 515 516 for (i = 1; i < len; ++i) { 517 properties[i].justification = (HB_GetUnicodeCharCategory(chars[i]) == HB_Separator_Space) ? 518 ArabicSpace : ArabicNone; 519 520 j = getNkoJoining(chars[i]); 521 522 if (j == JTransparent) { 523 properties[i].shape = XIsolated; 524 continue; 525 } 526 527 properties[lastPos].shape = joining_table[shape][j].form1; 528 shape = joining_table[shape][j].form2; 529 530 531 lastPos = i; 532 } 533 properties[lastPos].shape = joining_table[shape][JNone].form1; 534 535 536 /* 537 for (int i = 0; i < len; ++i) 538 qDebug("nko properties(%d): uc=%x shape=%d, justification=%d", i, chars[i], properties[i].shape, properties[i].justification); 539 */ 540 } 541 542 /* 543 // The unicode to unicode shaping codec. 544 // does only presentation forms B at the moment, but that should be enough for 545 // simple display 546 */ 547 static const hb_uint16 arabicUnicodeMapping[256][2] = { 548 /* base of shaped forms, and number-1 of them (0 for non shaping, 549 1 for right binding and 3 for dual binding */ 550 551 /* These are just the glyphs available in Unicode, 552 some characters are in R class, but have no glyphs in Unicode. */ 553 554 { 0x0600, 0 }, /* 0x0600 */ 555 { 0x0601, 0 }, /* 0x0601 */ 556 { 0x0602, 0 }, /* 0x0602 */ 557 { 0x0603, 0 }, /* 0x0603 */ 558 { 0x0604, 0 }, /* 0x0604 */ 559 { 0x0605, 0 }, /* 0x0605 */ 560 { 0x0606, 0 }, /* 0x0606 */ 561 { 0x0607, 0 }, /* 0x0607 */ 562 { 0x0608, 0 }, /* 0x0608 */ 563 { 0x0609, 0 }, /* 0x0609 */ 564 { 0x060A, 0 }, /* 0x060A */ 565 { 0x060B, 0 }, /* 0x060B */ 566 { 0x060C, 0 }, /* 0x060C */ 567 { 0x060D, 0 }, /* 0x060D */ 568 { 0x060E, 0 }, /* 0x060E */ 569 { 0x060F, 0 }, /* 0x060F */ 570 571 { 0x0610, 0 }, /* 0x0610 */ 572 { 0x0611, 0 }, /* 0x0611 */ 573 { 0x0612, 0 }, /* 0x0612 */ 574 { 0x0613, 0 }, /* 0x0613 */ 575 { 0x0614, 0 }, /* 0x0614 */ 576 { 0x0615, 0 }, /* 0x0615 */ 577 { 0x0616, 0 }, /* 0x0616 */ 578 { 0x0617, 0 }, /* 0x0617 */ 579 { 0x0618, 0 }, /* 0x0618 */ 580 { 0x0619, 0 }, /* 0x0619 */ 581 { 0x061A, 0 }, /* 0x061A */ 582 { 0x061B, 0 }, /* 0x061B */ 583 { 0x061C, 0 }, /* 0x061C */ 584 { 0x061D, 0 }, /* 0x061D */ 585 { 0x061E, 0 }, /* 0x061E */ 586 { 0x061F, 0 }, /* 0x061F */ 587 588 { 0x0620, 0 }, /* 0x0620 */ 589 { 0xFE80, 0 }, /* 0x0621 HAMZA */ 590 { 0xFE81, 1 }, /* 0x0622 R ALEF WITH MADDA ABOVE */ 591 { 0xFE83, 1 }, /* 0x0623 R ALEF WITH HAMZA ABOVE */ 592 { 0xFE85, 1 }, /* 0x0624 R WAW WITH HAMZA ABOVE */ 593 { 0xFE87, 1 }, /* 0x0625 R ALEF WITH HAMZA BELOW */ 594 { 0xFE89, 3 }, /* 0x0626 D YEH WITH HAMZA ABOVE */ 595 { 0xFE8D, 1 }, /* 0x0627 R ALEF */ 596 { 0xFE8F, 3 }, /* 0x0628 D BEH */ 597 { 0xFE93, 1 }, /* 0x0629 R TEH MARBUTA */ 598 { 0xFE95, 3 }, /* 0x062A D TEH */ 599 { 0xFE99, 3 }, /* 0x062B D THEH */ 600 { 0xFE9D, 3 }, /* 0x062C D JEEM */ 601 { 0xFEA1, 3 }, /* 0x062D D HAH */ 602 { 0xFEA5, 3 }, /* 0x062E D KHAH */ 603 { 0xFEA9, 1 }, /* 0x062F R DAL */ 604 605 { 0xFEAB, 1 }, /* 0x0630 R THAL */ 606 { 0xFEAD, 1 }, /* 0x0631 R REH */ 607 { 0xFEAF, 1 }, /* 0x0632 R ZAIN */ 608 { 0xFEB1, 3 }, /* 0x0633 D SEEN */ 609 { 0xFEB5, 3 }, /* 0x0634 D SHEEN */ 610 { 0xFEB9, 3 }, /* 0x0635 D SAD */ 611 { 0xFEBD, 3 }, /* 0x0636 D DAD */ 612 { 0xFEC1, 3 }, /* 0x0637 D TAH */ 613 { 0xFEC5, 3 }, /* 0x0638 D ZAH */ 614 { 0xFEC9, 3 }, /* 0x0639 D AIN */ 615 { 0xFECD, 3 }, /* 0x063A D GHAIN */ 616 { 0x063B, 0 }, /* 0x063B */ 617 { 0x063C, 0 }, /* 0x063C */ 618 { 0x063D, 0 }, /* 0x063D */ 619 { 0x063E, 0 }, /* 0x063E */ 620 { 0x063F, 0 }, /* 0x063F */ 621 622 { 0x0640, 0 }, /* 0x0640 C TATWEEL // ### Join Causing, only one glyph */ 623 { 0xFED1, 3 }, /* 0x0641 D FEH */ 624 { 0xFED5, 3 }, /* 0x0642 D QAF */ 625 { 0xFED9, 3 }, /* 0x0643 D KAF */ 626 { 0xFEDD, 3 }, /* 0x0644 D LAM */ 627 { 0xFEE1, 3 }, /* 0x0645 D MEEM */ 628 { 0xFEE5, 3 }, /* 0x0646 D NOON */ 629 { 0xFEE9, 3 }, /* 0x0647 D HEH */ 630 { 0xFEED, 1 }, /* 0x0648 R WAW */ 631 { 0x0649, 3 }, /* 0x0649 ALEF MAKSURA // ### Dual, glyphs not consecutive, handle in code. */ 632 { 0xFEF1, 3 }, /* 0x064A D YEH */ 633 { 0x064B, 0 }, /* 0x064B */ 634 { 0x064C, 0 }, /* 0x064C */ 635 { 0x064D, 0 }, /* 0x064D */ 636 { 0x064E, 0 }, /* 0x064E */ 637 { 0x064F, 0 }, /* 0x064F */ 638 639 { 0x0650, 0 }, /* 0x0650 */ 640 { 0x0651, 0 }, /* 0x0651 */ 641 { 0x0652, 0 }, /* 0x0652 */ 642 { 0x0653, 0 }, /* 0x0653 */ 643 { 0x0654, 0 }, /* 0x0654 */ 644 { 0x0655, 0 }, /* 0x0655 */ 645 { 0x0656, 0 }, /* 0x0656 */ 646 { 0x0657, 0 }, /* 0x0657 */ 647 { 0x0658, 0 }, /* 0x0658 */ 648 { 0x0659, 0 }, /* 0x0659 */ 649 { 0x065A, 0 }, /* 0x065A */ 650 { 0x065B, 0 }, /* 0x065B */ 651 { 0x065C, 0 }, /* 0x065C */ 652 { 0x065D, 0 }, /* 0x065D */ 653 { 0x065E, 0 }, /* 0x065E */ 654 { 0x065F, 0 }, /* 0x065F */ 655 656 { 0x0660, 0 }, /* 0x0660 */ 657 { 0x0661, 0 }, /* 0x0661 */ 658 { 0x0662, 0 }, /* 0x0662 */ 659 { 0x0663, 0 }, /* 0x0663 */ 660 { 0x0664, 0 }, /* 0x0664 */ 661 { 0x0665, 0 }, /* 0x0665 */ 662 { 0x0666, 0 }, /* 0x0666 */ 663 { 0x0667, 0 }, /* 0x0667 */ 664 { 0x0668, 0 }, /* 0x0668 */ 665 { 0x0669, 0 }, /* 0x0669 */ 666 { 0x066A, 0 }, /* 0x066A */ 667 { 0x066B, 0 }, /* 0x066B */ 668 { 0x066C, 0 }, /* 0x066C */ 669 { 0x066D, 0 }, /* 0x066D */ 670 { 0x066E, 0 }, /* 0x066E */ 671 { 0x066F, 0 }, /* 0x066F */ 672 673 { 0x0670, 0 }, /* 0x0670 */ 674 { 0xFB50, 1 }, /* 0x0671 R ALEF WASLA */ 675 { 0x0672, 0 }, /* 0x0672 */ 676 { 0x0673, 0 }, /* 0x0673 */ 677 { 0x0674, 0 }, /* 0x0674 */ 678 { 0x0675, 0 }, /* 0x0675 */ 679 { 0x0676, 0 }, /* 0x0676 */ 680 { 0x0677, 0 }, /* 0x0677 */ 681 { 0x0678, 0 }, /* 0x0678 */ 682 { 0xFB66, 3 }, /* 0x0679 D TTEH */ 683 { 0xFB5E, 3 }, /* 0x067A D TTEHEH */ 684 { 0xFB52, 3 }, /* 0x067B D BEEH */ 685 { 0x067C, 0 }, /* 0x067C */ 686 { 0x067D, 0 }, /* 0x067D */ 687 { 0xFB56, 3 }, /* 0x067E D PEH */ 688 { 0xFB62, 3 }, /* 0x067F D TEHEH */ 689 690 { 0xFB5A, 3 }, /* 0x0680 D BEHEH */ 691 { 0x0681, 0 }, /* 0x0681 */ 692 { 0x0682, 0 }, /* 0x0682 */ 693 { 0xFB76, 3 }, /* 0x0683 D NYEH */ 694 { 0xFB72, 3 }, /* 0x0684 D DYEH */ 695 { 0x0685, 0 }, /* 0x0685 */ 696 { 0xFB7A, 3 }, /* 0x0686 D TCHEH */ 697 { 0xFB7E, 3 }, /* 0x0687 D TCHEHEH */ 698 { 0xFB88, 1 }, /* 0x0688 R DDAL */ 699 { 0x0689, 0 }, /* 0x0689 */ 700 { 0x068A, 0 }, /* 0x068A */ 701 { 0x068B, 0 }, /* 0x068B */ 702 { 0xFB84, 1 }, /* 0x068C R DAHAL */ 703 { 0xFB82, 1 }, /* 0x068D R DDAHAL */ 704 { 0xFB86, 1 }, /* 0x068E R DUL */ 705 { 0x068F, 0 }, /* 0x068F */ 706 707 { 0x0690, 0 }, /* 0x0690 */ 708 { 0xFB8C, 1 }, /* 0x0691 R RREH */ 709 { 0x0692, 0 }, /* 0x0692 */ 710 { 0x0693, 0 }, /* 0x0693 */ 711 { 0x0694, 0 }, /* 0x0694 */ 712 { 0x0695, 0 }, /* 0x0695 */ 713 { 0x0696, 0 }, /* 0x0696 */ 714 { 0x0697, 0 }, /* 0x0697 */ 715 { 0xFB8A, 1 }, /* 0x0698 R JEH */ 716 { 0x0699, 0 }, /* 0x0699 */ 717 { 0x069A, 0 }, /* 0x069A */ 718 { 0x069B, 0 }, /* 0x069B */ 719 { 0x069C, 0 }, /* 0x069C */ 720 { 0x069D, 0 }, /* 0x069D */ 721 { 0x069E, 0 }, /* 0x069E */ 722 { 0x069F, 0 }, /* 0x069F */ 723 724 { 0x06A0, 0 }, /* 0x06A0 */ 725 { 0x06A1, 0 }, /* 0x06A1 */ 726 { 0x06A2, 0 }, /* 0x06A2 */ 727 { 0x06A3, 0 }, /* 0x06A3 */ 728 { 0xFB6A, 3 }, /* 0x06A4 D VEH */ 729 { 0x06A5, 0 }, /* 0x06A5 */ 730 { 0xFB6E, 3 }, /* 0x06A6 D PEHEH */ 731 { 0x06A7, 0 }, /* 0x06A7 */ 732 { 0x06A8, 0 }, /* 0x06A8 */ 733 { 0xFB8E, 3 }, /* 0x06A9 D KEHEH */ 734 { 0x06AA, 0 }, /* 0x06AA */ 735 { 0x06AB, 0 }, /* 0x06AB */ 736 { 0x06AC, 0 }, /* 0x06AC */ 737 { 0xFBD3, 3 }, /* 0x06AD D NG */ 738 { 0x06AE, 0 }, /* 0x06AE */ 739 { 0xFB92, 3 }, /* 0x06AF D GAF */ 740 741 { 0x06B0, 0 }, /* 0x06B0 */ 742 { 0xFB9A, 3 }, /* 0x06B1 D NGOEH */ 743 { 0x06B2, 0 }, /* 0x06B2 */ 744 { 0xFB96, 3 }, /* 0x06B3 D GUEH */ 745 { 0x06B4, 0 }, /* 0x06B4 */ 746 { 0x06B5, 0 }, /* 0x06B5 */ 747 { 0x06B6, 0 }, /* 0x06B6 */ 748 { 0x06B7, 0 }, /* 0x06B7 */ 749 { 0x06B8, 0 }, /* 0x06B8 */ 750 { 0x06B9, 0 }, /* 0x06B9 */ 751 { 0xFB9E, 1 }, /* 0x06BA R NOON GHUNNA */ 752 { 0xFBA0, 3 }, /* 0x06BB D RNOON */ 753 { 0x06BC, 0 }, /* 0x06BC */ 754 { 0x06BD, 0 }, /* 0x06BD */ 755 { 0xFBAA, 3 }, /* 0x06BE D HEH DOACHASHMEE */ 756 { 0x06BF, 0 }, /* 0x06BF */ 757 758 { 0xFBA4, 1 }, /* 0x06C0 R HEH WITH YEH ABOVE */ 759 { 0xFBA6, 3 }, /* 0x06C1 D HEH GOAL */ 760 { 0x06C2, 0 }, /* 0x06C2 */ 761 { 0x06C3, 0 }, /* 0x06C3 */ 762 { 0x06C4, 0 }, /* 0x06C4 */ 763 { 0xFBE0, 1 }, /* 0x06C5 R KIRGHIZ OE */ 764 { 0xFBD9, 1 }, /* 0x06C6 R OE */ 765 { 0xFBD7, 1 }, /* 0x06C7 R U */ 766 { 0xFBDB, 1 }, /* 0x06C8 R YU */ 767 { 0xFBE2, 1 }, /* 0x06C9 R KIRGHIZ YU */ 768 { 0x06CA, 0 }, /* 0x06CA */ 769 { 0xFBDE, 1 }, /* 0x06CB R VE */ 770 { 0xFBFC, 3 }, /* 0x06CC D FARSI YEH */ 771 { 0x06CD, 0 }, /* 0x06CD */ 772 { 0x06CE, 0 }, /* 0x06CE */ 773 { 0x06CF, 0 }, /* 0x06CF */ 774 775 { 0xFBE4, 3 }, /* 0x06D0 D E */ 776 { 0x06D1, 0 }, /* 0x06D1 */ 777 { 0xFBAE, 1 }, /* 0x06D2 R YEH BARREE */ 778 { 0xFBB0, 1 }, /* 0x06D3 R YEH BARREE WITH HAMZA ABOVE */ 779 { 0x06D4, 0 }, /* 0x06D4 */ 780 { 0x06D5, 0 }, /* 0x06D5 */ 781 { 0x06D6, 0 }, /* 0x06D6 */ 782 { 0x06D7, 0 }, /* 0x06D7 */ 783 { 0x06D8, 0 }, /* 0x06D8 */ 784 { 0x06D9, 0 }, /* 0x06D9 */ 785 { 0x06DA, 0 }, /* 0x06DA */ 786 { 0x06DB, 0 }, /* 0x06DB */ 787 { 0x06DC, 0 }, /* 0x06DC */ 788 { 0x06DD, 0 }, /* 0x06DD */ 789 { 0x06DE, 0 }, /* 0x06DE */ 790 { 0x06DF, 0 }, /* 0x06DF */ 791 792 { 0x06E0, 0 }, /* 0x06E0 */ 793 { 0x06E1, 0 }, /* 0x06E1 */ 794 { 0x06E2, 0 }, /* 0x06E2 */ 795 { 0x06E3, 0 }, /* 0x06E3 */ 796 { 0x06E4, 0 }, /* 0x06E4 */ 797 { 0x06E5, 0 }, /* 0x06E5 */ 798 { 0x06E6, 0 }, /* 0x06E6 */ 799 { 0x06E7, 0 }, /* 0x06E7 */ 800 { 0x06E8, 0 }, /* 0x06E8 */ 801 { 0x06E9, 0 }, /* 0x06E9 */ 802 { 0x06EA, 0 }, /* 0x06EA */ 803 { 0x06EB, 0 }, /* 0x06EB */ 804 { 0x06EC, 0 }, /* 0x06EC */ 805 { 0x06ED, 0 }, /* 0x06ED */ 806 { 0x06EE, 0 }, /* 0x06EE */ 807 { 0x06EF, 0 }, /* 0x06EF */ 808 809 { 0x06F0, 0 }, /* 0x06F0 */ 810 { 0x06F1, 0 }, /* 0x06F1 */ 811 { 0x06F2, 0 }, /* 0x06F2 */ 812 { 0x06F3, 0 }, /* 0x06F3 */ 813 { 0x06F4, 0 }, /* 0x06F4 */ 814 { 0x06F5, 0 }, /* 0x06F5 */ 815 { 0x06F6, 0 }, /* 0x06F6 */ 816 { 0x06F7, 0 }, /* 0x06F7 */ 817 { 0x06F8, 0 }, /* 0x06F8 */ 818 { 0x06F9, 0 }, /* 0x06F9 */ 819 { 0x06FA, 0 }, /* 0x06FA */ 820 { 0x06FB, 0 }, /* 0x06FB */ 821 { 0x06FC, 0 }, /* 0x06FC */ 822 { 0x06FD, 0 }, /* 0x06FD */ 823 { 0x06FE, 0 }, /* 0x06FE */ 824 { 0x06FF, 0 } /* 0x06FF */ 825 }; 826 827 /* the arabicUnicodeMapping does not work for U+0649 ALEF MAKSURA, this table does */ 828 static const hb_uint16 alefMaksura[4] = {0xFEEF, 0xFEF0, 0xFBE8, 0xFBE9}; 829 830 /* 831 // this is a bit tricky. Alef always binds to the right, so the second parameter descibing the shape 832 // of the lam can be either initial of medial. So initial maps to the isolated form of the ligature, 833 // medial to the final form 834 */ 835 static const hb_uint16 arabicUnicodeLamAlefMapping[6][4] = { 836 { 0xfffd, 0xfffd, 0xfef5, 0xfef6 }, /* 0x622 R Alef with Madda above */ 837 { 0xfffd, 0xfffd, 0xfef7, 0xfef8 }, /* 0x623 R Alef with Hamza above */ 838 { 0xfffd, 0xfffd, 0xfffd, 0xfffd }, /* 0x624 // Just to fill the table ;-) */ 839 { 0xfffd, 0xfffd, 0xfef9, 0xfefa }, /* 0x625 R Alef with Hamza below */ 840 { 0xfffd, 0xfffd, 0xfffd, 0xfffd }, /* 0x626 // Just to fill the table ;-) */ 841 { 0xfffd, 0xfffd, 0xfefb, 0xfefc } /* 0x627 R Alef */ 842 }; 843 844 static int getShape(hb_uint8 cell, int shape) 845 { 846 /* the arabicUnicodeMapping does not work for U+0649 ALEF MAKSURA, handle this here */ 847 int ch = (cell != 0x49) 848 ? (shape ? arabicUnicodeMapping[cell][0] + shape : 0x600+cell) 849 : alefMaksura[shape] ; 850 return ch; 851 } 852 853 854 /* 855 Two small helper functions for arabic shaping. 856 */ 857 static HB_UChar16 prevChar(const HB_UChar16 *str, int pos) 858 { 859 /*qDebug("leftChar: pos=%d", pos); */ 860 const HB_UChar16 *ch = str + pos - 1; 861 pos--; 862 while(pos > -1) { 863 if(HB_GetUnicodeCharCategory(*ch) != HB_Mark_NonSpacing) 864 return *ch; 865 pos--; 866 ch--; 867 } 868 return ReplacementCharacter; 869 } 870 871 static HB_UChar16 nextChar(const HB_UChar16 *str, hb_uint32 len, hb_uint32 pos) 872 { 873 const HB_UChar16 *ch = str + pos + 1; 874 pos++; 875 while(pos < len) { 876 /*qDebug("rightChar: %d isLetter=%d, joining=%d", pos, ch.isLetter(), ch.joining()); */ 877 if(HB_GetUnicodeCharCategory(*ch) != HB_Mark_NonSpacing) 878 return *ch; 879 /* assume it's a transparent char, this might not be 100% correct */ 880 pos++; 881 ch++; 882 } 883 return ReplacementCharacter; 884 } 885 886 static void shapedString(const HB_UChar16 *uc, hb_uint32 stringLength, hb_uint32 from, hb_uint32 len, HB_UChar16 *shapeBuffer, int *shapedLength, 887 HB_Bool reverse, HB_GlyphAttributes *attributes, unsigned short *logClusters) 888 { 889 HB_ArabicProperties *properties; 890 hb_int32 f = from; 891 hb_uint32 l = len; 892 const HB_UChar16 *ch; 893 HB_UChar16 *data; 894 int clusterStart; 895 hb_uint32 i; 896 HB_STACKARRAY(HB_ArabicProperties, props, len + 2); 897 properties = props; 898 899 assert(stringLength >= from + len); 900 901 if(len == 0) { 902 *shapedLength = 0; 903 return; 904 } 905 906 if (from > 0) { 907 --f; 908 ++l; 909 ++properties; 910 } 911 if (f + l < stringLength) 912 ++l; 913 getArabicProperties(uc+f, l, props); 914 915 ch = uc + from; 916 data = shapeBuffer; 917 clusterStart = 0; 918 919 for (i = 0; i < len; i++) { 920 hb_uint8 r = *ch >> 8; 921 int gpos = data - shapeBuffer; 922 923 if (r != 0x06) { 924 if (r == 0x20) { 925 if (*ch == 0x200c || *ch == 0x200d) 926 /* remove ZWJ and ZWNJ */ 927 goto skip; 928 } 929 if (reverse) 930 *data = HB_GetMirroredChar(*ch); 931 else 932 *data = *ch; 933 } else { 934 hb_uint8 c = *ch & 0xff; 935 int pos = i + from; 936 int shape = properties[i].shape; 937 /* qDebug("mapping U+%x to shape %d glyph=0x%x", ch->unicode(), shape, getShape(c, shape)); */ 938 /* take care of lam-alef ligatures (lam right of alef) */ 939 hb_uint16 map; 940 switch (c) { 941 case 0x44: { /* lam */ 942 const HB_UChar16 pch = nextChar(uc, stringLength, pos); 943 if ((pch >> 8) == 0x06) { 944 switch (pch & 0xff) { 945 case 0x22: 946 case 0x23: 947 case 0x25: 948 case 0x27: 949 /* qDebug(" lam of lam-alef ligature"); */ 950 map = arabicUnicodeLamAlefMapping[(pch & 0xff) - 0x22][shape]; 951 goto next; 952 default: 953 break; 954 } 955 } 956 break; 957 } 958 case 0x22: /* alef with madda */ 959 case 0x23: /* alef with hamza above */ 960 case 0x25: /* alef with hamza below */ 961 case 0x27: /* alef */ 962 if (prevChar(uc, pos) == 0x0644) { 963 /* have a lam alef ligature */ 964 /*qDebug(" alef of lam-alef ligature"); */ 965 goto skip; 966 } 967 default: 968 break; 969 } 970 map = getShape(c, shape); 971 next: 972 *data = map; 973 } 974 /* ##### Fixme */ 975 /*glyphs[gpos].attributes.zeroWidth = zeroWidth; */ 976 if (HB_GetUnicodeCharCategory(*ch) == HB_Mark_NonSpacing) { 977 attributes[gpos].mark = TRUE; 978 /* qDebug("glyph %d (char %d) is mark!", gpos, i); */ 979 } else { 980 attributes[gpos].mark = FALSE; 981 clusterStart = data - shapeBuffer; 982 } 983 attributes[gpos].clusterStart = !attributes[gpos].mark; 984 attributes[gpos].combiningClass = HB_GetUnicodeCharCombiningClass(*ch); 985 attributes[gpos].justification = properties[i].justification; 986 /* qDebug("data[%d] = %x (from %x)", gpos, (uint)data->unicode(), ch->unicode());*/ 987 data++; 988 skip: 989 ch++; 990 logClusters[i] = clusterStart; 991 } 992 *shapedLength = data - shapeBuffer; 993 994 HB_FREE_STACKARRAY(props); 995 } 996 997 #ifndef NO_OPENTYPE 998 999 static const HB_OpenTypeFeature arabic_features[] = { 1000 { HB_MAKE_TAG('c', 'c', 'm', 'p'), CcmpProperty }, 1001 { HB_MAKE_TAG('i', 's', 'o', 'l'), IsolProperty }, 1002 { HB_MAKE_TAG('f', 'i', 'n', 'a'), FinaProperty }, 1003 { HB_MAKE_TAG('m', 'e', 'd', 'i'), MediProperty }, 1004 { HB_MAKE_TAG('i', 'n', 'i', 't'), InitProperty }, 1005 { HB_MAKE_TAG('r', 'l', 'i', 'g'), RligProperty }, 1006 { HB_MAKE_TAG('c', 'a', 'l', 't'), CaltProperty }, 1007 { HB_MAKE_TAG('l', 'i', 'g', 'a'), LigaProperty }, 1008 { HB_MAKE_TAG('d', 'l', 'i', 'g'), DligProperty }, 1009 { HB_MAKE_TAG('c', 's', 'w', 'h'), CswhProperty }, 1010 /* mset is used in old Win95 fonts that don't have a 'mark' positioning table. */ 1011 { HB_MAKE_TAG('m', 's', 'e', 't'), MsetProperty }, 1012 {0, 0} 1013 }; 1014 1015 static const HB_OpenTypeFeature syriac_features[] = { 1016 { HB_MAKE_TAG('c', 'c', 'm', 'p'), CcmpProperty }, 1017 { HB_MAKE_TAG('i', 's', 'o', 'l'), IsolProperty }, 1018 { HB_MAKE_TAG('f', 'i', 'n', 'a'), FinaProperty }, 1019 { HB_MAKE_TAG('f', 'i', 'n', '2'), FinaProperty }, 1020 { HB_MAKE_TAG('f', 'i', 'n', '3'), FinaProperty }, 1021 { HB_MAKE_TAG('m', 'e', 'd', 'i'), MediProperty }, 1022 { HB_MAKE_TAG('m', 'e', 'd', '2'), MediProperty }, 1023 { HB_MAKE_TAG('i', 'n', 'i', 't'), InitProperty }, 1024 { HB_MAKE_TAG('r', 'l', 'i', 'g'), RligProperty }, 1025 { HB_MAKE_TAG('c', 'a', 'l', 't'), CaltProperty }, 1026 { HB_MAKE_TAG('l', 'i', 'g', 'a'), LigaProperty }, 1027 { HB_MAKE_TAG('d', 'l', 'i', 'g'), DligProperty }, 1028 {0, 0} 1029 }; 1030 1031 static HB_Bool arabicSyriacOpenTypeShape(HB_ShaperItem *item, HB_Bool *ot_ok) 1032 { 1033 const HB_UChar16 *uc; 1034 const int nglyphs = item->num_glyphs; 1035 hb_int32 f; 1036 hb_uint32 l; 1037 HB_ArabicProperties *properties; 1038 HB_DECLARE_STACKARRAY(HB_ArabicProperties, props) 1039 HB_DECLARE_STACKARRAY(hb_uint32, apply) 1040 HB_Bool shaped; 1041 int i = 0; 1042 1043 *ot_ok = TRUE; 1044 1045 if (!HB_ConvertStringToGlyphIndices(item)) 1046 return FALSE; 1047 HB_HeuristicSetGlyphAttributes(item); 1048 1049 HB_INIT_STACKARRAY(HB_ArabicProperties, props, item->item.length + 2); 1050 HB_INIT_STACKARRAY(hb_uint32, apply, item->num_glyphs); 1051 1052 uc = item->string + item->item.pos; 1053 1054 properties = props; 1055 f = 0; 1056 l = item->item.length; 1057 if (item->item.pos > 0) { 1058 --f; 1059 ++l; 1060 ++properties; 1061 } 1062 if (f + l + item->item.pos < item->stringLength) { 1063 ++l; 1064 } 1065 if (item->item.script == HB_Script_Nko) 1066 getNkoProperties(uc+f, l, props); 1067 else 1068 getArabicProperties(uc+f, l, props); 1069 1070 for (i = 0; i < (int)item->num_glyphs; i++) { 1071 apply[i] = 0; 1072 1073 if (properties[i].shape == XIsolated) 1074 apply[i] |= MediProperty|FinaProperty|InitProperty; 1075 else if (properties[i].shape == XMedial) 1076 apply[i] |= IsolProperty|FinaProperty|InitProperty; 1077 else if (properties[i].shape == XFinal) 1078 apply[i] |= IsolProperty|MediProperty|InitProperty; 1079 else if (properties[i].shape == XInitial) 1080 apply[i] |= IsolProperty|MediProperty|FinaProperty; 1081 1082 item->attributes[i].justification = properties[i].justification; 1083 } 1084 1085 HB_FREE_STACKARRAY(props); 1086 1087 shaped = HB_OpenTypeShape(item, apply); 1088 1089 HB_FREE_STACKARRAY(apply); 1090 1091 if (!shaped) { 1092 *ot_ok = FALSE; 1093 return FALSE; 1094 } 1095 return HB_OpenTypePosition(item, nglyphs, /*doLogClusters*/TRUE); 1096 } 1097 1098 #endif 1099 1100 /* #### stil missing: identify invalid character combinations */ 1101 HB_Bool HB_ArabicShape(HB_ShaperItem *item) 1102 { 1103 int slen; 1104 HB_Bool haveGlyphs; 1105 HB_STACKARRAY(HB_UChar16, shapedChars, item->item.length); 1106 1107 assert(item->item.script == HB_Script_Arabic || item->item.script == HB_Script_Syriac 1108 || item->item.script == HB_Script_Nko); 1109 1110 #ifndef NO_OPENTYPE 1111 1112 if (HB_SelectScript(item, item->item.script == HB_Script_Arabic ? arabic_features : syriac_features)) { 1113 HB_Bool ot_ok; 1114 if (arabicSyriacOpenTypeShape(item, &ot_ok)) { 1115 HB_FREE_STACKARRAY(shapedChars); 1116 return TRUE; 1117 } 1118 if (ot_ok) { 1119 HB_FREE_STACKARRAY(shapedChars); 1120 return FALSE; 1121 /* fall through to the non OT code*/ 1122 } 1123 } 1124 #endif 1125 1126 if (item->item.script != HB_Script_Arabic) { 1127 HB_FREE_STACKARRAY(shapedChars); 1128 return HB_BasicShape(item); 1129 } 1130 1131 shapedString(item->string, item->stringLength, item->item.pos, item->item.length, shapedChars, &slen, 1132 item->item.bidiLevel % 2, 1133 item->attributes, item->log_clusters); 1134 1135 haveGlyphs = item->font->klass 1136 ->convertStringToGlyphIndices(item->font, 1137 shapedChars, slen, 1138 item->glyphs, &item->num_glyphs, 1139 item->item.bidiLevel % 2); 1140 1141 HB_FREE_STACKARRAY(shapedChars); 1142 1143 if (!haveGlyphs) 1144 return FALSE; 1145 1146 HB_HeuristicPosition(item); 1147 return TRUE; 1148 } 1149 1150 1151
