PageRenderTime 74ms CodeModel.GetById 21ms RepoModel.GetById 0ms app.codeStats 0ms

/src/3rdparty/harfbuzz/src/harfbuzz-shaper.cpp

https://bitbucket.org/ultra_iter/qt-vtl
C++ | 1387 lines | 1050 code | 140 blank | 197 comment | 308 complexity | 3d0118d60cae177c6fd4ee94b036eb59 MD5 | raw file
Possible License(s): LGPL-2.0, LGPL-3.0, BSD-3-Clause, CC0-1.0, CC-BY-SA-4.0, LGPL-2.1, GPL-3.0, Apache-2.0

Large files files are truncated, but you can click here to view the full file

    

  1. /*
    2. 

  2.  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
    3. 

  3.  *
    4. 

  4.  * This is part of HarfBuzz, an OpenType Layout engine library.
    5. 

  5.  *
    6. 

  6.  * Permission is hereby granted, without written agreement and without
    7. 

  7.  * license or royalty fees, to use, copy, modify, and distribute this
    8. 

  8.  * software and its documentation for any purpose, provided that the
    9. 

  9.  * above copyright notice and the following two paragraphs appear in
    10. 

  10.  * all copies of this software.
    11. 

  11.  *
    12. 

  12.  * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
    13. 

  13.  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
    14. 

  14.  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
    15. 

  15.  * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
    16. 

  16.  * DAMAGE.
    17. 

  17.  *
    18. 

  18.  * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
    19. 

  19.  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
    20. 

  20.  * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
    21. 

  21.  * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
    22. 

  22.  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
    23. 

  23.  */
    24. 

  24. 

  25. #include "harfbuzz-shaper.h"
    26. 

  26. #include "harfbuzz-shaper-private.h"
    27. 

  27. 

  28. #include "harfbuzz-stream-private.h"
    29. 

  29. #include <assert.h>
    30. 

  30. #include <stdio.h>
    31. 

  31. 

  32. #define HB_MIN(a, b) ((a) < (b) ? (a) : (b))
    33. 

  33. #define HB_MAX(a, b) ((a) > (b) ? (a) : (b))
    34. 

  34. 

  35. // -----------------------------------------------------------------------------------------------------
    36. 

  36. //
    37. 

  37. // The line break algorithm. See http://www.unicode.org/reports/tr14/tr14-13.html
    38. 

  38. //
    39. 

  39. // -----------------------------------------------------------------------------------------------------
    40. 

  40. 

  41. /* The Unicode algorithm does in our opinion allow line breaks at some
    42. 

  42.    places they shouldn't be allowed. The following changes were thus
    43. 

  43.    made in comparison to the Unicode reference:
    44. 

    45. 

  45.    EX->AL from DB to IB
    46. 

  46.    SY->AL from DB to IB
    47. 

  47.    SY->PO from DB to IB
    48. 

  48.    SY->PR from DB to IB
    49. 

  49.    SY->OP from DB to IB
    50. 

  50.    AL->PR from DB to IB
    51. 

  51.    AL->PO from DB to IB
    52. 

  52.    PR->PR from DB to IB
    53. 

  53.    PO->PO from DB to IB
    54. 

  54.    PR->PO from DB to IB
    55. 

  55.    PO->PR from DB to IB
    56. 

  56.    HY->PO from DB to IB
    57. 

  57.    HY->PR from DB to IB
    58. 

  58.    HY->OP from DB to IB
    59. 

  59.    NU->EX from PB to IB
    60. 

  60.    EX->PO from DB to IB
    61. 

  61. */
    62. 

  62. 

  63. // The following line break classes are not treated by the table:
    64. 

  64. //  AI, BK, CB, CR, LF, NL, SA, SG, SP, XX
    65. 

  65. 

  66. enum break_class {
    67. 

  67.     // the first 4 values have to agree with the enum in QCharAttributes
    68. 

  68.     ProhibitedBreak,            // PB in table
    69. 

  69.     DirectBreak,                // DB in table
    70. 

  70.     IndirectBreak,              // IB in table
    71. 

  71.     CombiningIndirectBreak,     // CI in table
    72. 

  72.     CombiningProhibitedBreak    // CP in table
    73. 

  73. };
    74. 

  74. #define DB DirectBreak
    75. 

  75. #define IB IndirectBreak
    76. 

  76. #define CI CombiningIndirectBreak
    77. 

  77. #define CP CombiningProhibitedBreak
    78. 

  78. #define PB ProhibitedBreak
    79. 

  79. 

  80. static const hb_uint8 breakTable[HB_LineBreak_JT+1][HB_LineBreak_JT+1] =
    81. 

  81. {
    82. 

  82. /*          OP  CL  QU  GL  NS  EX  SY  IS  PR  PO  NU  AL  ID  IN  HY  BA  BB  B2  ZW  CM  WJ  H2  H3  JL  JV  JT */
    83. 

  83. /* OP */ { PB, PB, PB, PB, PB, PB, PB, PB, PB, PB, PB, PB, PB, PB, PB, PB, PB, PB, PB, CP, PB, PB, PB, PB, PB, PB },
    84. 

  84. /* CL */ { DB, PB, IB, IB, PB, PB, PB, PB, IB, IB, IB, IB, DB, DB, IB, IB, DB, DB, PB, CI, PB, DB, DB, DB, DB, DB },
    85. 

  85. /* QU */ { PB, PB, IB, IB, IB, PB, PB, PB, IB, IB, IB, IB, IB, IB, IB, IB, IB, IB, PB, CI, PB, IB, IB, IB, IB, IB },
    86. 

  86. /* GL */ { IB, PB, IB, IB, IB, PB, PB, PB, IB, IB, IB, IB, IB, IB, IB, IB, IB, IB, PB, CI, PB, IB, IB, IB, IB, IB },
    87. 

  87. /* NS */ { DB, PB, IB, IB, IB, PB, PB, PB, DB, DB, DB, DB, DB, DB, IB, IB, DB, DB, PB, CI, PB, DB, DB, DB, DB, DB },
    88. 

  88. /* EX */ { DB, PB, IB, IB, IB, PB, PB, PB, DB, IB, DB, IB, DB, DB, IB, IB, DB, DB, PB, CI, PB, DB, DB, DB, DB, DB },
    89. 

  89. /* SY */ { IB, PB, IB, IB, IB, PB, PB, PB, IB, IB, IB, IB, DB, DB, IB, IB, DB, DB, PB, CI, PB, DB, DB, DB, DB, DB },
    90. 

  90. /* IS */ { DB, PB, IB, IB, IB, PB, PB, PB, DB, DB, IB, IB, DB, DB, IB, IB, DB, DB, PB, CI, PB, DB, DB, DB, DB, DB },
    91. 

  91. /* PR */ { IB, PB, IB, IB, IB, PB, PB, PB, IB, IB, IB, IB, IB, DB, IB, IB, DB, DB, PB, CI, PB, IB, IB, IB, IB, IB },
    92. 

  92. /* PO */ { IB, PB, IB, IB, IB, PB, PB, PB, IB, IB, IB, IB, DB, DB, IB, IB, DB, DB, PB, CI, PB, DB, DB, DB, DB, DB },
    93. 

  93. /* NU */ { IB, PB, IB, IB, IB, IB, PB, PB, IB, IB, IB, IB, DB, IB, IB, IB, DB, DB, PB, CI, PB, DB, DB, DB, DB, DB },
    94. 

  94. /* AL */ { IB, PB, IB, IB, IB, PB, PB, PB, IB, IB, IB, IB, DB, IB, IB, IB, DB, DB, PB, CI, PB, DB, DB, DB, DB, DB },
    95. 

  95. /* ID */ { DB, PB, IB, IB, IB, PB, PB, PB, DB, IB, DB, DB, DB, IB, IB, IB, DB, DB, PB, CI, PB, DB, DB, DB, DB, DB },
    96. 

  96. /* IN */ { DB, PB, IB, IB, IB, PB, PB, PB, DB, DB, DB, DB, DB, IB, IB, IB, DB, DB, PB, CI, PB, DB, DB, DB, DB, DB },
    97. 

  97. /* HY */ { IB, PB, IB, IB, IB, PB, PB, PB, IB, IB, IB, DB, DB, DB, IB, IB, DB, DB, PB, CI, PB, DB, DB, DB, DB, DB },
    98. 

  98. /* BA */ { DB, PB, IB, IB, IB, PB, PB, PB, DB, DB, DB, DB, DB, DB, IB, IB, DB, DB, PB, CI, PB, DB, DB, DB, DB, DB },
    99. 

  99. /* BB */ { IB, PB, IB, IB, IB, PB, PB, PB, IB, IB, IB, IB, IB, IB, IB, IB, IB, IB, PB, CI, PB, IB, IB, IB, IB, IB },
    100. 

  100. /* B2 */ { DB, PB, IB, IB, IB, PB, PB, PB, DB, DB, DB, DB, DB, DB, IB, IB, DB, PB, PB, CI, PB, DB, DB, DB, DB, DB },
    101. 

  101. /* ZW */ { DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, PB, DB, DB, DB, DB, DB, DB, DB },
    102. 

  102. /* CM */ { DB, PB, IB, IB, IB, PB, PB, PB, DB, DB, IB, IB, DB, IB, IB, IB, DB, DB, PB, CI, PB, DB, DB, DB, DB, DB },
    103. 

  103. /* WJ */ { IB, PB, IB, IB, IB, PB, PB, PB, IB, IB, IB, IB, IB, IB, IB, IB, IB, IB, PB, CI, PB, IB, IB, IB, IB, IB },
    104. 

  104. /* H2 */ { DB, PB, IB, IB, IB, PB, PB, PB, DB, IB, DB, DB, DB, IB, IB, IB, DB, DB, PB, CI, PB, DB, DB, DB, IB, IB },
    105. 

  105. /* H3 */ { DB, PB, IB, IB, IB, PB, PB, PB, DB, IB, DB, DB, DB, IB, IB, IB, DB, DB, PB, CI, PB, DB, DB, DB, DB, IB },
    106. 

  106. /* JL */ { DB, PB, IB, IB, IB, PB, PB, PB, DB, IB, DB, DB, DB, IB, IB, IB, DB, DB, PB, CI, PB, IB, IB, IB, IB, DB },
    107. 

  107. /* JV */ { DB, PB, IB, IB, IB, PB, PB, PB, DB, IB, DB, DB, DB, IB, IB, IB, DB, DB, PB, CI, PB, DB, DB, DB, IB, IB },
    108. 

  108. /* JT */ { DB, PB, IB, IB, IB, PB, PB, PB, DB, IB, DB, DB, DB, IB, IB, IB, DB, DB, PB, CI, PB, DB, DB, DB, DB, IB }
    109. 

  109. };
    110. 

  110. #undef DB
    111. 

  111. #undef IB
    112. 

  112. #undef CI
    113. 

  113. #undef CP
    114. 

  114. #undef PB
    115. 

  115. 

  116. static const hb_uint8 graphemeTable[HB_Grapheme_LVT + 1][HB_Grapheme_LVT + 1] =
    117. 

  117. {
    118. 

  118. //      Other, CR,    LF,    Control,Extend,L,    V,     T,     LV,    LVT
    119. 

  119.     { true , true , true , true , true , true , true , true , true , true  }, // Other, 
    120. 

  120.     { true , true , true , true , true , true , true , true , true , true  }, // CR,
    121. 

  121.     { true , false, true , true , true , true , true , true , true , true  }, // LF,
    122. 

  122.     { true , true , true , true , true , true , true , true , true , true  }, // Control,
    123. 

  123.     { false, true , true , true , false, false, false, false, false, false }, // Extend,
    124. 

  124.     { true , true , true , true , true , false, true , true , true , true  }, // L, 
    125. 

  125.     { true , true , true , true , true , false, false, true , false, true  }, // V, 
    126. 

  126.     { true , true , true , true , true , true , false, false, false, false }, // T, 
    127. 

  127.     { true , true , true , true , true , false, true , true , true , true  }, // LV, 
    128. 

  128.     { true , true , true , true , true , false, true , true , true , true  }, // LVT
    129. 

  129. };
    130. 

  130.     
    131. 

  131. static void calcLineBreaks(const HB_UChar16 *uc, hb_uint32 len, HB_CharAttributes *charAttributes)
    132. 

  132. {
    133. 

  133.     if (!len)
    134. 

  134.         return;
    135. 

  135. 

  136.     // ##### can this fail if the first char is a surrogate?
    137. 

  137.     HB_LineBreakClass cls;
    138. 

  138.     HB_GraphemeClass grapheme;
    139. 

  139.     HB_GetGraphemeAndLineBreakClass(*uc, &grapheme, &cls);
    140. 

  140.     // handle case where input starts with an LF
    141. 

  141.     if (cls == HB_LineBreak_LF)
    142. 

  142.         cls = HB_LineBreak_BK;
    143. 

  143. 

  144.     charAttributes[0].whiteSpace = (cls == HB_LineBreak_SP || cls == HB_LineBreak_BK);
    145. 

  145.     charAttributes[0].charStop = true;
    146. 

  146. 

  147.     int lcls = cls;
    148. 

  148.     for (hb_uint32 i = 1; i < len; ++i) {
    149. 

  149.         charAttributes[i].whiteSpace = false;
    150. 

  150.         charAttributes[i].charStop = true;
    151. 

  151. 

  152.         HB_UChar32 code = uc[i];
    153. 

  153.         HB_GraphemeClass ngrapheme;
    154. 

  154.         HB_LineBreakClass ncls;
    155. 

  155.         HB_GetGraphemeAndLineBreakClass(code, &ngrapheme, &ncls);
    156. 

  156.         charAttributes[i].charStop = graphemeTable[ngrapheme][grapheme];
    157. 

  157.         // handle surrogates
    158. 

  158.         if (ncls == HB_LineBreak_SG) {
    159. 

  159.             if (HB_IsHighSurrogate(uc[i]) && i < len - 1 && HB_IsLowSurrogate(uc[i+1])) {
    160. 

  160.                 continue;
    161. 

  161.             } else if (HB_IsLowSurrogate(uc[i]) && HB_IsHighSurrogate(uc[i-1])) {
    162. 

  162.                 code = HB_SurrogateToUcs4(uc[i-1], uc[i]);
    163. 

  163.                 HB_GetGraphemeAndLineBreakClass(code, &ngrapheme, &ncls);
    164. 

  164.                 charAttributes[i].charStop = false;
    165. 

  165.             } else {
    166. 

  166.                 ncls = HB_LineBreak_AL;
    167. 

  167.             }
    168. 

  168.         }
    169. 

  169. 

  170.         // set white space and char stop flag
    171. 

  171.         if (ncls >= HB_LineBreak_SP)
    172. 

  172.             charAttributes[i].whiteSpace = true;
    173. 

  173. 

  174.         HB_LineBreakType lineBreakType = HB_NoBreak;
    175. 

  175.         if (cls >= HB_LineBreak_LF) {
    176. 

  176.             lineBreakType = HB_ForcedBreak;
    177. 

  177.         } else if(cls == HB_LineBreak_CR) {
    178. 

  178.             lineBreakType = (ncls == HB_LineBreak_LF) ? HB_NoBreak : HB_ForcedBreak;
    179. 

  179.         }
    180. 

  180. 

  181.         if (ncls == HB_LineBreak_SP)
    182. 

  182.             goto next_no_cls_update;
    183. 

  183.         if (ncls >= HB_LineBreak_CR)
    184. 

  184.             goto next;
    185. 

  185. 

  186.         {
    187. 

  187.             int tcls = ncls;
    188. 

  188.             // for south east asian chars that require a complex (dictionary analysis), the unicode
    189. 

  189.             // standard recommends to treat them as AL. thai_attributes and other attribute methods that
    190. 

  190.             // do dictionary analysis can override
    191. 

  191.             if (tcls >= HB_LineBreak_SA)
    192. 

  192.                 tcls = HB_LineBreak_AL;
    193. 

  193.             if (cls >= HB_LineBreak_SA)
    194. 

  194.                 cls = HB_LineBreak_AL;
    195. 

  195. 

  196.             int brk = breakTable[cls][tcls];
    197. 

  197.             switch (brk) {
    198. 

  198.             case DirectBreak:
    199. 

  199.                 lineBreakType = HB_Break;
    200. 

  200.                 if (uc[i-1] == 0xad) // soft hyphen
    201. 

  201.                     lineBreakType = HB_SoftHyphen;
    202. 

  202.                 break;
    203. 

  203.             case IndirectBreak:
    204. 

  204.                 lineBreakType = (lcls == HB_LineBreak_SP) ? HB_Break : HB_NoBreak;
    205. 

  205.                 break;
    206. 

  206.             case CombiningIndirectBreak:
    207. 

  207.                 lineBreakType = HB_NoBreak;
    208. 

  208.                 if (lcls == HB_LineBreak_SP){
    209. 

  209.                     if (i > 1)
    210. 

  210.                         charAttributes[i-2].lineBreakType = HB_Break;
    211. 

  211.                 } else {
    212. 

  212.                     goto next_no_cls_update;
    213. 

  213.                 }
    214. 

  214.                 break;
    215. 

  215.             case CombiningProhibitedBreak:
    216. 

  216.                 lineBreakType = HB_NoBreak;
    217. 

  217.                 if (lcls != HB_LineBreak_SP)
    218. 

  218.                     goto next_no_cls_update;
    219. 

  219.             case ProhibitedBreak:
    220. 

  220.             default:
    221. 

  221.                 break;
    222. 

  222.             }
    223. 

  223.         }
    224. 

  224.     next:
    225. 

  225.         cls = ncls;
    226. 

  226.     next_no_cls_update:
    227. 

  227.         lcls = ncls;
    228. 

  228.         grapheme = ngrapheme;
    229. 

  229.         charAttributes[i-1].lineBreakType = lineBreakType;
    230. 

  230.     }
    231. 

  231.     charAttributes[len-1].lineBreakType = HB_ForcedBreak;
    232. 

  232. }
    233. 

  233. 

  234. // --------------------------------------------------------------------------------------------------------------------------------------------
    235. 

  235. //
    236. 

  236. // Basic processing
    237. 

  237. //
    238. 

  238. // --------------------------------------------------------------------------------------------------------------------------------------------
    239. 

  239. 

  240. static inline void positionCluster(HB_ShaperItem *item, int gfrom,  int glast)
    241. 

  241. {
    242. 

  242.     int nmarks = glast - gfrom;
    243. 

  243.     assert(nmarks > 0);
    244. 

  244. 

  245.     HB_Glyph *glyphs = item->glyphs;
    246. 

  246.     HB_GlyphAttributes *attributes = item->attributes;
    247. 

  247. 

  248.     HB_GlyphMetrics baseMetrics;
    249. 

  249.     item->font->klass->getGlyphMetrics(item->font, glyphs[gfrom], &baseMetrics);
    250. 

  250. 

  251.     if (item->item.script == HB_Script_Hebrew
    252. 

  252.         && (-baseMetrics.y) > baseMetrics.height)
    253. 

  253.         // we need to attach below the baseline, because of the hebrew iud.
    254. 

  254.         baseMetrics.height = -baseMetrics.y;
    255. 

  255. 

  256. //     qDebug("---> positionCluster: cluster from %d to %d", gfrom, glast);
    257. 

  257. //     qDebug("baseInfo: %f/%f (%f/%f) off=%f/%f", baseInfo.x, baseInfo.y, baseInfo.width, baseInfo.height, baseInfo.xoff, baseInfo.yoff);
    258. 

  258. 

  259.     HB_Fixed size = item->font->klass->getFontMetric(item->font, HB_FontAscent) / 10;
    260. 

  260.     HB_Fixed offsetBase = HB_FIXED_CONSTANT(1) + (size - HB_FIXED_CONSTANT(4)) / 4;
    261. 

  261.     if (size > HB_FIXED_CONSTANT(4))
    262. 

  262.         offsetBase += HB_FIXED_CONSTANT(4);
    263. 

  263.     else
    264. 

  264.         offsetBase += size;
    265. 

  265.     //qreal offsetBase = (size - 4) / 4 + qMin<qreal>(size, 4) + 1;
    266. 

  266. //     qDebug("offset = %f", offsetBase);
    267. 

  267. 

  268.     bool rightToLeft = item->item.bidiLevel % 2;
    269. 

  269. 

  270.     int i;
    271. 

  271.     unsigned char lastCmb = 0;
    272. 

  272.     HB_GlyphMetrics attachmentRect;
    273. 

  273.     memset(&attachmentRect, 0, sizeof(attachmentRect));
    274. 

  274. 

  275.     for(i = 1; i <= nmarks; i++) {
    276. 

  276.         HB_Glyph mark = glyphs[gfrom+i];
    277. 

  277.         HB_GlyphMetrics markMetrics;
    278. 

  278.         item->font->klass->getGlyphMetrics(item->font, mark, &markMetrics);
    279. 

  279.         HB_FixedPoint p;
    280. 

  280.         p.x = p.y = 0;
    281. 

  281. //          qDebug("markInfo: %f/%f (%f/%f) off=%f/%f", markInfo.x, markInfo.y, markInfo.width, markInfo.height, markInfo.xoff, markInfo.yoff);
    282. 

  282. 

  283.         HB_Fixed offset = offsetBase;
    284. 

  284.         unsigned char cmb = attributes[gfrom+i].combiningClass;
    285. 

  285. 

  286.         // ### maybe the whole position determination should move down to heuristicSetGlyphAttributes. Would save some
    287. 

  287.         // bits  in the glyphAttributes structure.
    288. 

  288.         if (cmb < 200) {
    289. 

  289.             // fixed position classes. We approximate by mapping to one of the others.
    290. 

  290.             // currently I added only the ones for arabic, hebrew, lao and thai.
    291. 

  291. 

  292.             // for Lao and Thai marks with class 0, see below (heuristicSetGlyphAttributes)
    293. 

  293. 

  294.             // add a bit more offset to arabic, a bit hacky
    295. 

  295.             if (cmb >= 27 && cmb <= 36 && offset < 3)
    296. 

  296.                 offset +=1;
    297. 

  297.             // below
    298. 

  298.             if ((cmb >= 10 && cmb <= 18) ||
    299. 

  299.                  cmb == 20 || cmb == 22 ||
    300. 

  300.                  cmb == 29 || cmb == 32)
    301. 

  301.                 cmb = HB_Combining_Below;
    302. 

  302.             // above
    303. 

  303.             else if (cmb == 23 || cmb == 27 || cmb == 28 ||
    304. 

  304.                       cmb == 30 || cmb == 31 || (cmb >= 33 && cmb <= 36))
    305. 

  305.                 cmb = HB_Combining_Above;
    306. 

  306.             //below-right
    307. 

  307.             else if (cmb == 9 || cmb == 103 || cmb == 118)
    308. 

  308.                 cmb = HB_Combining_BelowRight;
    309. 

  309.             // above-right
    310. 

  310.             else if (cmb == 24 || cmb == 107 || cmb == 122)
    311. 

  311.                 cmb = HB_Combining_AboveRight;
    312. 

  312.             else if (cmb == 25)
    313. 

  313.                 cmb = HB_Combining_AboveLeft;
    314. 

  314.             // fixed:
    315. 

  315.             //  19 21
    316. 

  316. 

  317.         }
    318. 

  318. 

  319.         // combining marks of different class don't interact. Reset the rectangle.
    320. 

  320.         if (cmb != lastCmb) {
    321. 

  321.             //qDebug("resetting rect");
    322. 

  322.             attachmentRect = baseMetrics;
    323. 

  323.         }
    324. 

  324. 

  325.         switch(cmb) {
    326. 

  326.         case HB_Combining_DoubleBelow:
    327. 

  327.                 // ### wrong in rtl context!
    328. 

  328.         case HB_Combining_BelowLeft:
    329. 

  329.             p.y += offset;
    330. 

  330.         case HB_Combining_BelowLeftAttached:
    331. 

  331.             p.x += attachmentRect.x - markMetrics.x;
    332. 

  332.             p.y += (attachmentRect.y + attachmentRect.height) - markMetrics.y;
    333. 

  333.             break;
    334. 

  334.         case HB_Combining_Below:
    335. 

  335.             p.y += offset;
    336. 

  336.         case HB_Combining_BelowAttached:
    337. 

  337.             p.x += attachmentRect.x - markMetrics.x;
    338. 

  338.             p.y += (attachmentRect.y + attachmentRect.height) - markMetrics.y;
    339. 

  339. 

  340.             p.x += (attachmentRect.width - markMetrics.width) / 2;
    341. 

  341.             break;
    342. 

  342.         case HB_Combining_BelowRight:
    343. 

  343.             p.y += offset;
    344. 

  344.         case HB_Combining_BelowRightAttached:
    345. 

  345.             p.x += attachmentRect.x + attachmentRect.width - markMetrics.width - markMetrics.x;
    346. 

  346.             p.y += attachmentRect.y + attachmentRect.height - markMetrics.y;
    347. 

  347.             break;
    348. 

  348.         case HB_Combining_Left:
    349. 

  349.             p.x -= offset;
    350. 

  350.         case HB_Combining_LeftAttached:
    351. 

  351.             break;
    352. 

  352.         case HB_Combining_Right:
    353. 

  353.             p.x += offset;
    354. 

  354.         case HB_Combining_RightAttached:
    355. 

  355.             break;
    356. 

  356.         case HB_Combining_DoubleAbove:
    357. 

  357.             // ### wrong in RTL context!
    358. 

  358.         case HB_Combining_AboveLeft:
    359. 

  359.             p.y -= offset;
    360. 

  360.         case HB_Combining_AboveLeftAttached:
    361. 

  361.             p.x += attachmentRect.x - markMetrics.x;
    362. 

  362.             p.y += attachmentRect.y - markMetrics.y - markMetrics.height;
    363. 

  363.             break;
    364. 

  364.         case HB_Combining_Above:
    365. 

  365.             p.y -= offset;
    366. 

  366.         case HB_Combining_AboveAttached:
    367. 

  367.             p.x += attachmentRect.x - markMetrics.x;
    368. 

  368.             p.y += attachmentRect.y - markMetrics.y - markMetrics.height;
    369. 

  369. 

  370.             p.x += (attachmentRect.width - markMetrics.width) / 2;
    371. 

  371.             break;
    372. 

  372.         case HB_Combining_AboveRight:
    373. 

  373.             p.y -= offset;
    374. 

  374.         case HB_Combining_AboveRightAttached:
    375. 

  375.             p.x += attachmentRect.x + attachmentRect.width - markMetrics.x - markMetrics.width;
    376. 

  376.             p.y += attachmentRect.y - markMetrics.y - markMetrics.height;
    377. 

  377.             break;
    378. 

  378. 

  379.         case HB_Combining_IotaSubscript:
    380. 

  380.             default:
    381. 

  381.                 break;
    382. 

  382.         }
    383. 

  383. //          qDebug("char=%x combiningClass = %d offset=%f/%f", mark, cmb, p.x(), p.y());
    384. 

  384.         markMetrics.x += p.x;
    385. 

  385.         markMetrics.y += p.y;
    386. 

  386. 

  387.         HB_GlyphMetrics unitedAttachmentRect = attachmentRect;
    388. 

  388.         unitedAttachmentRect.x = HB_MIN(attachmentRect.x, markMetrics.x);
    389. 

  389.         unitedAttachmentRect.y = HB_MIN(attachmentRect.y, markMetrics.y);
    390. 

  390.         unitedAttachmentRect.width = HB_MAX(attachmentRect.x + attachmentRect.width, markMetrics.x + markMetrics.width) - unitedAttachmentRect.x;
    391. 

  391.         unitedAttachmentRect.height = HB_MAX(attachmentRect.y + attachmentRect.height, markMetrics.y + markMetrics.height) - unitedAttachmentRect.y;
    392. 

  392.         attachmentRect = unitedAttachmentRect;
    393. 

  393. 

  394.         lastCmb = cmb;
    395. 

  395.         if (rightToLeft) {
    396. 

  396.             item->offsets[gfrom+i].x = p.x;
    397. 

  397.             item->offsets[gfrom+i].y = p.y;
    398. 

  398.         } else {
    399. 

  399.             item->offsets[gfrom+i].x = p.x - baseMetrics.xOffset;
    400. 

  400.             item->offsets[gfrom+i].y = p.y - baseMetrics.yOffset;
    401. 

  401.         }
    402. 

  402.         item->advances[gfrom+i] = 0;
    403. 

  403.     }
    404. 

  404. }
    405. 

  405. 

  406. void HB_HeuristicPosition(HB_ShaperItem *item)
    407. 

  407. {
    408. 

  408.     HB_GetGlyphAdvances(item);
    409. 

  409.     HB_GlyphAttributes *attributes = item->attributes;
    410. 

  410. 

  411.     int cEnd = -1;
    412. 

  412.     int i = item->num_glyphs;
    413. 

  413.     while (i--) {
    414. 

  414.         if (cEnd == -1 && attributes[i].mark) {
    415. 

  415.             cEnd = i;
    416. 

  416.         } else if (cEnd != -1 && !attributes[i].mark) {
    417. 

  417.             positionCluster(item, i, cEnd);
    418. 

  418.             cEnd = -1;
    419. 

  419.         }
    420. 

  420.     }
    421. 

  421. }
    422. 

  422. 

  423. // set the glyph attributes heuristically. Assumes a 1 to 1 relationship between chars and glyphs
    424. 

  424. // and no reordering.
    425. 

  425. // also computes logClusters heuristically
    426. 

  426. void HB_HeuristicSetGlyphAttributes(HB_ShaperItem *item)
    427. 

  427. {
    428. 

  428.     const HB_UChar16 *uc = item->string + item->item.pos;
    429. 

  429.     hb_uint32 length = item->item.length;
    430. 

  430. 

  431.     // ### zeroWidth and justification are missing here!!!!!
    432. 

  432. 

  433.     assert(item->num_glyphs <= length);
    434. 

  434. 

  435. //     qDebug("QScriptEngine::heuristicSetGlyphAttributes, num_glyphs=%d", item->num_glyphs);
    436. 

  436.     HB_GlyphAttributes *attributes = item->attributes;
    437. 

  437.     unsigned short *logClusters = item->log_clusters;
    438. 

  438. 

  439.     hb_uint32 glyph_pos = 0;
    440. 

  440.     hb_uint32 i;
    441. 

  441.     for (i = 0; i < length; i++) {
    442. 

  442.         if (HB_IsHighSurrogate(uc[i]) && i < length - 1
    443. 

  443.             && HB_IsLowSurrogate(uc[i + 1])) {
    444. 

  444.             logClusters[i] = glyph_pos;
    445. 

  445.             logClusters[++i] = glyph_pos;
    446. 

  446.         } else {
    447. 

  447.             logClusters[i] = glyph_pos;
    448. 

  448.         }
    449. 

  449.         ++glyph_pos;
    450. 

  450.     }
    451. 

  451.     assert(glyph_pos == item->num_glyphs);
    452. 

  452. 

  453.     // first char in a run is never (treated as) a mark
    454. 

  454.     int cStart = 0;
    455. 

  455.     const bool symbolFont = item->face->isSymbolFont;
    456. 

  456.     attributes[0].mark = false;
    457. 

  457.     attributes[0].clusterStart = true;
    458. 

  458.     attributes[0].dontPrint = (!symbolFont && uc[0] == 0x00ad) || HB_IsControlChar(uc[0]);
    459. 

  459. 

  460.     int pos = 0;
    461. 

  461.     HB_CharCategory lastCat;
    462. 

  462.     int dummy;
    463. 

  463.     HB_GetUnicodeCharProperties(uc[0], &lastCat, &dummy);
    464. 

  464.     for (i = 1; i < length; ++i) {
    465. 

  465.         if (logClusters[i] == pos)
    466. 

  466.             // same glyph
    467. 

  467.             continue;
    468. 

  468.         ++pos;
    469. 

  469.         while (pos < logClusters[i]) {
    470. 

  470.             attributes[pos] = attributes[pos-1];
    471. 

  471.             ++pos;
    472. 

  472.         }
    473. 

  473.         // hide soft-hyphens by default
    474. 

  474.         if ((!symbolFont && uc[i] == 0x00ad) || HB_IsControlChar(uc[i]))
    475. 

  475.             attributes[pos].dontPrint = true;
    476. 

  476.         HB_CharCategory cat;
    477. 

  477.         int cmb;
    478. 

  478.         HB_GetUnicodeCharProperties(uc[i], &cat, &cmb);
    479. 

  479.         if (cat != HB_Mark_NonSpacing) {
    480. 

  480.             attributes[pos].mark = false;
    481. 

  481.             attributes[pos].clusterStart = true;
    482. 

  482.             attributes[pos].combiningClass = 0;
    483. 

  483.             cStart = logClusters[i];
    484. 

  484.         } else {
    485. 

  485.             if (cmb == 0) {
    486. 

  486.                 // Fix 0 combining classes
    487. 

  487.                 if ((uc[pos] & 0xff00) == 0x0e00) {
    488. 

  488.                     // thai or lao
    489. 

  489.                     if (uc[pos] == 0xe31 ||
    490. 

  490.                          uc[pos] == 0xe34 ||
    491. 

  491.                          uc[pos] == 0xe35 ||
    492. 

  492.                          uc[pos] == 0xe36 ||
    493. 

  493.                          uc[pos] == 0xe37 ||
    494. 

  494.                          uc[pos] == 0xe47 ||
    495. 

  495.                          uc[pos] == 0xe4c ||
    496. 

  496.                          uc[pos] == 0xe4d ||
    497. 

  497.                          uc[pos] == 0xe4e) {
    498. 

  498.                         cmb = HB_Combining_AboveRight;
    499. 

  499.                     } else if (uc[pos] == 0xeb1 ||
    500. 

  500.                                 uc[pos] == 0xeb4 ||
    501. 

  501.                                 uc[pos] == 0xeb5 ||
    502. 

  502.                                 uc[pos] == 0xeb6 ||
    503. 

  503.                                 uc[pos] == 0xeb7 ||
    504. 

  504.                                 uc[pos] == 0xebb ||
    505. 

  505.                                 uc[pos] == 0xecc ||
    506. 

  506.                                 uc[pos] == 0xecd) {
    507. 

  507.                         cmb = HB_Combining_Above;
    508. 

  508.                     } else if (uc[pos] == 0xebc) {
    509. 

  509.                         cmb = HB_Combining_Below;
    510. 

  510.                     }
    511. 

  511.                 }
    512. 

  512.             }
    513. 

  513. 

  514.             attributes[pos].mark = true;
    515. 

  515.             attributes[pos].clusterStart = false;
    516. 

  516.             attributes[pos].combiningClass = cmb;
    517. 

  517.             logClusters[i] = cStart;
    518. 

  518.         }
    519. 

  519.         // one gets an inter character justification point if the current char is not a non spacing mark.
    520. 

  520.         // as then the current char belongs to the last one and one gets a space justification point
    521. 

  521.         // after the space char.
    522. 

  522.         if (lastCat == HB_Separator_Space)
    523. 

  523.             attributes[pos-1].justification = HB_Space;
    524. 

  524.         else if (cat != HB_Mark_NonSpacing)
    525. 

  525.             attributes[pos-1].justification = HB_Character;
    526. 

  526.         else
    527. 

  527.             attributes[pos-1].justification = HB_NoJustification;
    528. 

  528. 

  529.         lastCat = cat;
    530. 

  530.     }
    531. 

  531.     pos = logClusters[length-1];
    532. 

  532.     if (lastCat == HB_Separator_Space)
    533. 

  533.         attributes[pos].justification = HB_Space;
    534. 

  534.     else
    535. 

  535.         attributes[pos].justification = HB_Character;
    536. 

  536. }
    537. 

  537. 

  538. #ifndef NO_OPENTYPE
    539. 

  539. static const HB_OpenTypeFeature basic_features[] = {
    540. 

  540.     { HB_MAKE_TAG('c', 'c', 'm', 'p'), CcmpProperty },
    541. 

  541.     { HB_MAKE_TAG('l', 'i', 'g', 'a'), LigaProperty },
    542. 

  542.     { HB_MAKE_TAG('c', 'l', 'i', 'g'), CligProperty },
    543. 

  543.     {0, 0}
    544. 

  544. };
    545. 

  545. 

  546. static const HB_OpenTypeFeature disabled_features[] = {
    547. 

  547.     { HB_MAKE_TAG('c', 'p', 'c', 't'), PositioningProperties },
    548. 

  548.     { HB_MAKE_TAG('h', 'a', 'l', 't'), PositioningProperties },
    549. 

  549.     // TODO: we need to add certain HB_ShaperFlag for vertical
    550. 

  550.     // writing mode to enable these vertical writing features:
    551. 

  551.     { HB_MAKE_TAG('v', 'a', 'l', 't'), PositioningProperties },
    552. 

  552.     // { HB_MAKE_TAG('v', 'h', 'a', 'l'), PositioningProperties },
    553. 

  553.     { HB_MAKE_TAG('v', 'k', 'r', 'n'), PositioningProperties },
    554. 

  554.     { HB_MAKE_TAG('v', 'p', 'a', 'l'), PositioningProperties },
    555. 

  555.     {0, 0}
    556. 

  556. };
    557. 

  557. #endif
    558. 

  558. 

  559. HB_Bool HB_ConvertStringToGlyphIndices(HB_ShaperItem *shaper_item)
    560. 

  560. {
    561. 

  561.     if (shaper_item->glyphIndicesPresent) {
    562. 

  562.         shaper_item->num_glyphs = shaper_item->initialGlyphCount;
    563. 

  563.         shaper_item->glyphIndicesPresent = false;
    564. 

  564.         return true;
    565. 

  565.     }
    566. 

  566.     return shaper_item->font->klass
    567. 

  567.            ->convertStringToGlyphIndices(shaper_item->font,
    568. 

  568.                                          shaper_item->string + shaper_item->item.pos, shaper_item->item.length,
    569. 

  569.                                          shaper_item->glyphs, &shaper_item->num_glyphs,
    570. 

  570.                                          shaper_item->item.bidiLevel % 2);
    571. 

  571. }
    572. 

  572. 

  573. HB_Bool HB_BasicShape(HB_ShaperItem *shaper_item)
    574. 

  574. {
    575. 

  575. #ifndef NO_OPENTYPE
    576. 

  576.     const int availableGlyphs = shaper_item->num_glyphs;
    577. 

  577. #endif
    578. 

  578. 

  579.     if (!HB_ConvertStringToGlyphIndices(shaper_item))
    580. 

  580.         return false;
    581. 

  581. 

  582.     HB_HeuristicSetGlyphAttributes(shaper_item);
    583. 

  583. 

  584. #ifndef NO_OPENTYPE
    585. 

  585.     if (HB_SelectScript(shaper_item, basic_features)) {
    586. 

  586.         HB_OpenTypeShape(shaper_item, /*properties*/0);
    587. 

  587.         return HB_OpenTypePosition(shaper_item, availableGlyphs, /*doLogClusters*/true);
    588. 

  588.     }
    589. 

  589. #endif
    590. 

  590. 

  591.     HB_HeuristicPosition(shaper_item);
    592. 

  592.     return true;
    593. 

  593. }
    594. 

  594. 

  595. const HB_ScriptEngine HB_ScriptEngines[] = {
    596. 

  596.     // Common
    597. 

  597.     { HB_BasicShape, 0},
    598. 

  598.     // Greek
    599. 

  599.     { HB_GreekShape, 0},
    600. 

  600.     // Cyrillic
    601. 

  601.     { HB_BasicShape, 0},
    602. 

  602.     // Armenian
    603. 

  603.     { HB_BasicShape, 0},
    604. 

  604.     // Hebrew
    605. 

  605.     { HB_HebrewShape, 0 },
    606. 

  606.     // Arabic
    607. 

  607.     { HB_ArabicShape, 0},
    608. 

  608.     // Syriac
    609. 

  609.     { HB_ArabicShape, 0},
    610. 

  610.     // Thaana
    611. 

  611.     { HB_BasicShape, 0 },
    612. 

  612.     // Devanagari
    613. 

  613.     { HB_IndicShape, HB_IndicAttributes },
    614. 

  614.     // Bengali
    615. 

  615.     { HB_IndicShape, HB_IndicAttributes },
    616. 

  616.     // Gurmukhi
    617. 

  617.     { HB_IndicShape, HB_IndicAttributes },
    618. 

  618.     // Gujarati
    619. 

  619.     { HB_IndicShape, HB_IndicAttributes },
    620. 

  620.     // Oriya
    621. 

  621.     { HB_IndicShape, HB_IndicAttributes },
    622. 

  622.     // Tamil
    623. 

  623.     { HB_IndicShape, HB_IndicAttributes },
    624. 

  624.     // Telugu
    625. 

  625.     { HB_IndicShape, HB_IndicAttributes },
    626. 

  626.     // Kannada
    627. 

  627.     { HB_IndicShape, HB_IndicAttributes },
    628. 

  628.     // Malayalam
    629. 

  629.     { HB_IndicShape, HB_IndicAttributes },
    630. 

  630.     // Sinhala
    631. 

  631.     { HB_IndicShape, HB_IndicAttributes },
    632. 

  632.     // Thai
    633. 

  633.     { HB_ThaiShape, HB_ThaiAttributes },
    634. 

  634.     // Lao
    635. 

  635.     { HB_BasicShape, 0 },
    636. 

  636.     // Tibetan
    637. 

  637.     { HB_TibetanShape, HB_TibetanAttributes },
    638. 

  638.     // Myanmar
    639. 

  639.     { HB_MyanmarShape, HB_MyanmarAttributes },
    640. 

  640.     // Georgian
    641. 

  641.     { HB_BasicShape, 0 },
    642. 

  642.     // Hangul
    643. 

  643.     { HB_HangulShape, 0 },
    644. 

  644.     // Ogham
    645. 

  645.     { HB_BasicShape, 0 },
    646. 

  646.     // Runic
    647. 

  647.     { HB_BasicShape, 0 },
    648. 

  648.     // Khmer
    649. 

  649.     { HB_KhmerShape, HB_KhmerAttributes },
    650. 

  650.     // N'Ko
    651. 

  651.     { HB_ArabicShape, 0}
    652. 

  652. };
    653. 

  653. 

  654. void HB_GetCharAttributes(const HB_UChar16 *string, hb_uint32 stringLength,
    655. 

  655.                           const HB_ScriptItem *items, hb_uint32 numItems,
    656. 

  656.                           HB_CharAttributes *attributes)
    657. 

  657. {
    658. 

  658.     memset(attributes, 0, stringLength * sizeof(HB_CharAttributes));
    659. 

  659.     calcLineBreaks(string, stringLength, attributes);
    660. 

  660. 

  661.     for (hb_uint32 i = 0; i < numItems; ++i) {
    662. 

  662.         HB_Script script = items[i].script;
    663. 

  663.         if (script == HB_Script_Inherited)
    664. 

  664.             script = HB_Script_Common;
    665. 

  665.         HB_AttributeFunction attributeFunction = HB_ScriptEngines[script].charAttributes;
    666. 

  666.         if (!attributeFunction)
    667. 

  667.             continue;
    668. 

  668.         attributeFunction(script, string, items[i].pos, items[i].length, attributes);
    669. 

  669.     }
    670. 

  670. }
    671. 

  671. 

  672. 

  673. enum BreakRule { NoBreak = 0, Break = 1, Middle = 2 };
    674. 

  674. 

  675. static const hb_uint8 wordbreakTable[HB_Word_ExtendNumLet + 1][HB_Word_ExtendNumLet + 1] = {
    676. 

  676. //        Other    Format   Katakana ALetter  MidLetter MidNum  Numeric  ExtendNumLet
    677. 

  677.     {   Break,   Break,   Break,   Break,   Break,   Break,   Break,   Break }, // Other
    678. 

  678.     {   Break,   Break,   Break,   Break,   Break,   Break,   Break,   Break }, // Format 
    679. 

  679.     {   Break,   Break, NoBreak,   Break,   Break,   Break,   Break, NoBreak }, // Katakana
    680. 

  680.     {   Break,   Break,   Break, NoBreak,  Middle,   Break, NoBreak, NoBreak }, // ALetter
    681. 

  681.     {   Break,   Break,   Break,   Break,   Break,   Break,   Break,   Break }, // MidLetter
    682. 

  682.     {   Break,   Break,   Break,   Break,   Break,   Break,   Break,   Break }, // MidNum
    683. 

  683.     {   Break,   Break,   Break, NoBreak,   Break,  Middle, NoBreak, NoBreak }, // Numeric
    684. 

  684.     {   Break,   Break, NoBreak, NoBreak,   Break,   Break, NoBreak, NoBreak }, // ExtendNumLet
    685. 

  685. };
    686. 

  686. 

  687. void HB_GetWordBoundaries(const HB_UChar16 *string, hb_uint32 stringLength,
    688. 

  688.                           const HB_ScriptItem * /*items*/, hb_uint32 /*numItems*/,
    689. 

  689.                           HB_CharAttributes *attributes)
    690. 

  690. {
    691. 

  691.     if (stringLength == 0)
    692. 

  692.         return;
    693. 

  693.     unsigned int brk = HB_GetWordClass(string[0]);
    694. 

  694.     attributes[0].wordBoundary = true;
    695. 

  695.     for (hb_uint32 i = 1; i < stringLength; ++i) {
    696. 

  696.         if (!attributes[i].charStop) {
    697. 

  697.             attributes[i].wordBoundary = false;
    698. 

  698.             continue;
    699. 

  699.         }
    700. 

  700.         hb_uint32 nbrk = HB_GetWordClass(string[i]);
    701. 

  701.         if (nbrk == HB_Word_Format) {
    702. 

  702.             attributes[i].wordBoundary = (HB_GetSentenceClass(string[i-1]) == HB_Sentence_Sep);
    703. 

  703.             continue;
    704. 

  704.         }
    705. 

  705.         BreakRule rule = (BreakRule)wordbreakTable[brk][nbrk];
    706. 

  706.         if (rule == Middle) {
    707. 

  707.             rule = Break;
    708. 

  708.             hb_uint32 lookahead = i + 1;
    709. 

  709.             while (lookahead < stringLength) {
    710. 

  710.                 hb_uint32 testbrk = HB_GetWordClass(string[lookahead]);
    711. 

  711.                 if (testbrk == HB_Word_Format && HB_GetSentenceClass(string[lookahead]) != HB_Sentence_Sep) {
    712. 

  712.                     ++lookahead;
    713. 

  713.                     continue;
    714. 

  714.                 }
    715. 

  715.                 if (testbrk == brk) {
    716. 

  716.                     rule = NoBreak;
    717. 

  717.                     while (i < lookahead)
    718. 

  718.                         attributes[i++].wordBoundary = false;
    719. 

  719.                     nbrk = testbrk;
    720. 

  720.                 }
    721. 

  721.                 break;
    722. 

  722.             }
    723. 

  723.         }
    724. 

  724.         attributes[i].wordBoundary = (rule == Break);
    725. 

  725.         brk = nbrk;
    726. 

  726.     }
    727. 

  727. }
    728. 

  728. 

  729. 

  730. enum SentenceBreakStates {
    731. 

  731.     SB_Initial,
    732. 

  732.     SB_Upper,
    733. 

  733.     SB_UpATerm, 
    734. 

  734.     SB_ATerm,
    735. 

  735.     SB_ATermC, 
    736. 

  736.     SB_ACS, 
    737. 

  737.     SB_STerm, 
    738. 

  738.     SB_STermC, 
    739. 

  739.     SB_SCS,
    740. 

  740.     SB_BAfter, 
    741. 

  741.     SB_Break,
    742. 

  742.     SB_Look
    743. 

  743. };
    744. 

  744. 

  745. static const hb_uint8 sentenceBreakTable[HB_Sentence_Close + 1][HB_Sentence_Close + 1] = {
    746. 

  746. //        Other       Sep         Format      Sp          Lower       Upper       OLetter     Numeric     ATerm       STerm       Close
    747. 

  747.       { SB_Initial, SB_BAfter , SB_Initial, SB_Initial, SB_Initial, SB_Upper  , SB_Initial, SB_Initial, SB_ATerm  , SB_STerm  , SB_Initial }, // SB_Initial,
    748. 

  748.       { SB_Initial, SB_BAfter , SB_Upper  , SB_Initial, SB_Initial, SB_Upper  , SB_Initial, SB_Initial, SB_UpATerm, SB_STerm  , SB_Initial }, // SB_Upper
    749. 

  749.       
    750. 

  750.       { SB_Look   , SB_BAfter , SB_UpATerm, SB_ACS    , SB_Initial, SB_Upper  , SB_Break  , SB_Initial, SB_ATerm  , SB_STerm  , SB_ATermC  }, // SB_UpATerm
    751. 

  751.       { SB_Look   , SB_BAfter , SB_ATerm  , SB_ACS    , SB_Initial, SB_Break  , SB_Break  , SB_Initial, SB_ATerm  , SB_STerm  , SB_ATermC  }, // SB_ATerm
    752. 

  752.       { SB_Look   , SB_BAfter , SB_ATermC , SB_ACS    , SB_Initial, SB_Break  , SB_Break  , SB_Look   , SB_ATerm  , SB_STerm  , SB_ATermC  }, // SB_ATermC,
    753. 

  753.       { SB_Look   , SB_BAfter , SB_ACS    , SB_ACS    , SB_Initial, SB_Break  , SB_Break  , SB_Look   , SB_ATerm  , SB_STerm  , SB_Look    }, // SB_ACS,
    754. 

  754.       
    755. 

  755.       { SB_Break  , SB_BAfter , SB_STerm  , SB_SCS    , SB_Break  , SB_Break  , SB_Break  , SB_Break  , SB_ATerm  , SB_STerm  , SB_STermC  }, // SB_STerm,
    756. 

  756.       { SB_Break  , SB_BAfter , SB_STermC , SB_SCS    , SB_Break  , SB_Break  , SB_Break  , SB_Break  , SB_ATerm  , SB_STerm  , SB_STermC  }, // SB_STermC,
    757. 

  757.       { SB_Break  , SB_BAfter , SB_SCS    , SB_SCS    , SB_Break  , SB_Break  , SB_Break  , SB_Break  , SB_ATerm  , SB_STerm  , SB_Break   }, // SB_SCS,
    758. 

  758.       { SB_Break  , SB_Break  , SB_Break  , SB_Break  , SB_Break  , SB_Break  , SB_Break  , SB_Break  , SB_Break  , SB_Break  , SB_Break   }, // SB_BAfter,
    759. 

  759. };
    760. 

  760. 

  761. void HB_GetSentenceBoundaries(const HB_UChar16 *string, hb_uint32 stringLength,
    762. 

  762.                               const HB_ScriptItem * /*items*/, hb_uint32 /*numItems*/,
    763. 

  763.                               HB_CharAttributes *attributes)
    764. 

  764. {
    765. 

  765.     if (stringLength == 0)
    766. 

  766.         return;
    767. 

  767.     hb_uint32 brk = sentenceBreakTable[SB_Initial][HB_GetSentenceClass(string[0])];
    768. 

  768.     attributes[0].sentenceBoundary = true;
    769. 

  769.     for (hb_uint32 i = 1; i < stringLength; ++i) {
    770. 

  770.         if (!attributes[i].charStop) {
    771. 

  771.             attributes[i].sentenceBoundary = false;
    772. 

  772.             continue;
    773. 

  773.         }
    774. 

  774.         brk = sentenceBreakTable[brk][HB_GetSentenceClass(string[i])];
    775. 

  775.         if (brk == SB_Look) {
    776. 

  776.             brk = SB_Break;
    777. 

  777.             hb_uint32 lookahead = i + 1;
    778. 

  778.             while (lookahead < stringLength) {
    779. 

  779.                 hb_uint32 sbrk = HB_GetSentenceClass(string[lookahead]);
    780. 

  780.                 if (sbrk != HB_Sentence_Other && sbrk != HB_Sentence_Numeric && sbrk != HB_Sentence_Close) {
    781. 

  781.                     break;
    782. 

  782.                 } else if (sbrk == HB_Sentence_Lower) {
    783. 

  783.                     brk = SB_Initial;
    784. 

  784.                     break;
    785. 

  785.                 }
    786. 

  786.                 ++lookahead;
    787. 

  787.             }
    788. 

  788.             if (brk == SB_Initial) {
    789. 

  789.                 while (i < lookahead)
    790. 

  790.                     attributes[i++].sentenceBoundary = false;
    791. 

  791.             }
    792. 

  792.         }
    793. 

  793.         if (brk == SB_Break) {
    794. 

  794.             attributes[i].sentenceBoundary = true;
    795. 

  795.             brk = sentenceBreakTable[SB_Initial][HB_GetSentenceClass(string[i])];
    796. 

  796.         } else {
    797. 

  797.             attributes[i].sentenceBoundary = false;
    798. 

  798.         }
    799. 

  799.     }
    800. 

  800. }
    801. 

  801. 

  802. 

  803. static inline char *tag_to_string(HB_UInt tag)
    804. 

  804. {
    805. 

  805.     static char string[5];
    806. 

  806.     string[0] = (tag >> 24)&0xff;
    807. 

  807.     string[1] = (tag >> 16)&0xff;
    808. 

  808.     string[2] = (tag >> 8)&0xff;
    809. 

  809.     string[3] = tag&0xff;
    810. 

  810.     string[4] = 0;
    811. 

  811.     return string;
    812. 

  812. }
    813. 

  813. 

  814. #ifdef OT_DEBUG
    815. 

  815. static void dump_string(HB_Buffer buffer)
    816. 

  816. {
    817. 

  817.     for (uint i = 0; i < buffer->in_length; ++i) {
    818. 

  818.         qDebug("    %x: cluster=%d", buffer->in_string[i].gindex, buffer->in_string[i].cluster);
    819. 

  819.     }
    820. 

  820. }
    821. 

  821. #define DEBUG printf
    822. 

  822. #else
    823. 

  823. #define DEBUG if (1) ; else printf
    824. 

  824. #endif
    825. 

  825. 

  826. #define DefaultLangSys 0xffff
    827. 

  827. #define DefaultScript HB_MAKE_TAG('D', 'F', 'L', 'T')
    828. 

  828. 

  829. enum {
    830. 

  830.     RequiresGsub = 1,
    831. 

  831.     RequiresGpos = 2
    832. 

  832. };
    833. 

  833. 

  834. struct OTScripts {
    835. 

  835.     unsigned int tag;
    836. 

  836.     int flags;
    837. 

  837. };
    838. 

  838. static const OTScripts ot_scripts [] = {
    839. 

  839.     // Common
    840. 

  840.     { HB_MAKE_TAG('l', 'a', 't', 'n'), 0 },
    841. 

  841.     // Greek
    842. 

  842.     { HB_MAKE_TAG('g', 'r', 'e', 'k'), 0 },
    843. 

  843.     // Cyrillic
    844. 

  844.     { HB_MAKE_TAG('c', 'y', 'r', 'l'), 0 },
    845. 

  845.     // Armenian
    846. 

  846.     { HB_MAKE_TAG('a', 'r', 'm', 'n'), 0 },
    847. 

  847.     // Hebrew
    848. 

  848.     { HB_MAKE_TAG('h', 'e', 'b', 'r'), 1 },
    849. 

  849.     // Arabic
    850. 

  850.     { HB_MAKE_TAG('a', 'r', 'a', 'b'), 1 },
    851. 

  851.     // Syriac
    852. 

  852.     { HB_MAKE_TAG('s', 'y', 'r', 'c'), 1 },
    853. 

  853.     // Thaana
    854. 

  854.     { HB_MAKE_TAG('t', 'h', 'a', 'a'), 1 },
    855. 

  855.     // Devanagari
    856. 

  856.     { HB_MAKE_TAG('d', 'e', 'v', 'a'), 1 },
    857. 

  857.     // Bengali
    858. 

  858.     { HB_MAKE_TAG('b', 'e', 'n', 'g'), 1 },
    859. 

  859.     // Gurmukhi
    860. 

  860.     { HB_MAKE_TAG('g', 'u', 'r', 'u'), 1 },
    861. 

  861.     // Gujarati
    862. 

  862.     { HB_MAKE_TAG('g', 'u', 'j', 'r'), 1 },
    863. 

  863.     // Oriya
    864. 

  864.     { HB_MAKE_TAG('o', 'r', 'y', 'a'), 1 },
    865. 

  865.     // Tamil
    866. 

  866.     { HB_MAKE_TAG('t', 'a', 'm', 'l'), 1 },
    867. 

  867.     // Telugu
    868. 

  868.     { HB_MAKE_TAG('t', 'e', 'l', 'u'), 1 },
    869. 

  869.     // Kannada
    870. 

  870.     { HB_MAKE_TAG('k', 'n', 'd', 'a'), 1 },
    871. 

  871.     // Malayalam
    872. 

  872.     { HB_MAKE_TAG('m', 'l', 'y', 'm'), 1 },
    873. 

  873.     // Sinhala
    874. 

  874.     { HB_MAKE_TAG('s', 'i', 'n', 'h'), 1 },
    875. 

  875.     // Thai
    876. 

  876.     { HB_MAKE_TAG('t', 'h', 'a', 'i'), 1 },
    877. 

  877.     // Lao
    878. 

  878.     { HB_MAKE_TAG('l', 'a', 'o', ' '), 1 },
    879. 

  879.     // Tibetan
    880. 

  880.     { HB_MAKE_TAG('t', 'i', 'b', 't'), 1 },
    881. 

  881.     // Myanmar
    882. 

  882.     { HB_MAKE_TAG('m', 'y', 'm', 'r'), 1 },
    883. 

  883.     // Georgian
    884. 

  884.     { HB_MAKE_TAG('g', 'e', 'o', 'r'), 0 },
    885. 

  885.     // Hangul
    886. 

  886.     { HB_MAKE_TAG('h', 'a', 'n', 'g'), 1 },
    887. 

  887.     // Ogham
    888. 

  888.     { HB_MAKE_TAG('o', 'g', 'a', 'm'), 0 },
    889. 

  889.     // Runic
    890. 

  890.     { HB_MAKE_TAG('r', 'u', 'n', 'r'), 0 },
    891. 

  891.     // Khmer
    892. 

  892.     { HB_MAKE_TAG('k', 'h', 'm', 'r'), 1 },
    893. 

  893.     // N'Ko
    894. 

  894.     { HB_MAKE_TAG('n', 'k', 'o', ' '), 1 }
    895. 

  895. };
    896. 

  896. enum { NumOTScripts = sizeof(ot_scripts)/sizeof(OTScripts) };
    897. 

  897. 

  898. static HB_Bool checkScript(HB_Face face, int script)
    899. 

  899. {
    900. 

  900.     assert(script < HB_ScriptCount);
    901. 

  901. 

  902.     if (!face->gsub && !face->gpos)
    903. 

  903.         return false;
    904. 

  904. 

  905.     unsigned int tag = ot_scripts[script].tag;
    906. 

  906.     int requirements = ot_scripts[script].flags;
    907. 

  907. 

  908.     if (requirements & RequiresGsub) {
    909. 

  909.         if (!face->gsub)
    910. 

  910.             return false;
    911. 

  911. 

  912.         HB_UShort script_index;
    913. 

  913.         HB_Error error = HB_GSUB_Select_Script(face->gsub, tag, &script_index);
    914. 

  914.         if (error) {
    915. 

  915.             DEBUG("could not select script %d in GSub table: %d", (int)script, error);
    916. 

  916.             error = HB_GSUB_Select_Script(face->gsub, HB_MAKE_TAG('D', 'F', 'L', 'T'), &script_index);
    917. 

  917.             if (error)
    918. 

  918.                 return false;
    919. 

  919.         }
    920. 

  920.     }
    921. 

  921. 

  922.     if (requirements & RequiresGpos) {
    923. 

  923.         if (!face->gpos)
    924. 

  924.             return false;
    925. 

  925. 

  926.         HB_UShort script_index;
    927. 

  927.         HB_Error error = HB_GPOS_Select_Script(face->gpos, script, &script_index);
    928. 

  928.         if (error) {
    929. 

  929.             DEBUG("could not select script in gpos table: %d", error);
    930. 

  930.             error = HB_GPOS_Select_Script(face->gpos, HB_MAKE_TAG('D', 'F', 'L', 'T'), &script_index);
    931. 

  931.             if (error)
    932. 

  932.                 return false;
    933. 

  933.         }
    934. 

  934. 

  935.     }
    936. 

  936.     return true;
    937. 

  937. }
    938. 

  938. 

  939. static HB_Stream getTableStream(void *font, HB_GetFontTableFunc tableFunc, HB_Tag tag)
    940. 

  940. {
    941. 

  941.     HB_Error error;
    942. 

  942.     HB_UInt length = 0;
    943. 

  943.     HB_Stream stream = 0;
    944. 

  944. 

  945.     if (!font)
    946. 

  946.         return 0;
    947. 

  947. 

  948.     error = tableFunc(font, tag, 0, &length);
    949. 

  949.     if (error)
    950. 

  950.         return 0;
    951. 

  951.     stream = (HB_Stream)malloc(sizeof(HB_StreamRec));
    952. 

  952.     if (!stream)
    953. 

  953.         return 0;
    954. 

  954.     stream->base = (HB_Byte*)malloc(length);
    955. 

  955.     if (!stream->base) {
    956. 

  956.         free(stream);
    957. 

  957.         return 0;
    958. 

  958.     }
    959. 

  959.     error = tableFunc(font, tag, stream->base, &length);
    960. 

  960.     if (error) {
    961. 

  961.         _hb_close_stream(stream);
    962. 

  962.         return 0;
    963. 

  963.     }
    964. 

  964.     stream->size = length;
    965. 

  965.     stream->pos = 0;
    966. 

  966.     stream->cursor = NULL;
    967. 

  967.     return stream;
    968. 

  968. }
    969. 

  969. 

  970. HB_Face HB_NewFace(void *font, HB_GetFontTableFunc tableFunc)
    971. 

  971. {
    972. 

  972.     HB_Face face = (HB_Face )malloc(sizeof(HB_FaceRec));
    973. 

  973.     if (!face)
    974. 

  974.         return 0;
    975. 

  975. 

  976.     face->isSymbolFont = false;
    977. 

  977.     face->gdef = 0;
    978. 

  978.     face->gpos = 0;
    979. 

  979.     face->gsub = 0;
    980. 

  980.     face->current_script = HB_ScriptCount;
    981. 

  981.     face->current_flags = HB_ShaperFlag_Default;
    982. 

  982.     face->has_opentype_kerning = false;
    983. 

  983.     face->tmpAttributes = 0;
    984. 

  984.     face->tmpLogClusters = 0;
    985. 

  985.     face->glyphs_substituted = false;
    986. 

  986.     face->buffer = 0;
    987. 

  987. 

  988.     HB_Error error = HB_Err_Ok;
    989. 

  989.     HB_Stream stream;
    990. 

  990.     HB_Stream gdefStream;
    991. 

  991. 

  992.     gdefStream = getTableStream(font, tableFunc, TTAG_GDEF);
    993. 

  993.     error = HB_Err_Not_Covered;
    994. 

  994.     if (!gdefStream || (error = HB_Load_GDEF_Table(gdefStream, &face->gdef))) {
    995. 

  995.         //DEBUG("error loading gdef table: %d", error);
    996. 

  996.         face->gdef = 0;
    997. 

  997.     }
    998. 

  998. 

  999.     //DEBUG() << "trying to load gsub table";
    1000. 

  1000.     stream = getTableStream(font, tableFunc, TTAG_GSUB);
    1001. 

  1001.     error = HB_Err_Not_Covered;
    1002. 

  1002.     if (!stream || (error = HB_Load_GSUB_Table(stream, &face->gsub, face->gdef, gdefStream))) {
    1003. 

  1003.         face->gsub = 0;
    1004. 

  1004.         if (error != HB_Err_Not_Covered) {
    1005. 

  1005.             //DEBUG("error loading gsub table: %d", error);
    1006. 

  1006.         } else {
    1007. 

  1007.             //DEBUG("face doesn't have a gsub table");
    1008. 

  1008.         }
    1009. 

  1009.     }
    1010. 

  1010.     _hb_close_stream(stream);
    1011. 

  1011. 

  1012.     stream = getTableStream(font, tableFunc, TTAG_GPOS);
    1013. 

  1013.     error = HB_Err_Not_Covered;
    1014. 

  1014.     if (!stream || (error = HB_Load_GPOS_Table(stream, &face->gpos, face->gdef, gdefStream))) {
    1015. 

  1015.         face->gpos = 0;
    1016. 

  1016.         DEBUG("error loading gpos table: %d", error);
    1017. 

  1017.     }
    1018. 

  1018.     _hb_close_stream(stream);
    1019. 

  1019. 

  1020.     _hb_close_stream(gdefStream);
    1021. 

  1021. 

  1022.     for (unsigned int i = 0; i < HB_ScriptCount; ++i)
    1023. 

  1023.         face->supported_scripts[i] = checkScript(face, i);
    1024. 

  1024. 

  1025.     if (hb_buffer_new(&face->buffer) != HB_Err_Ok) {
    1026. 

  1026.         HB_FreeFace(face);
    1027. 

  1027.         return 0;
    1028. 

  1028.     }
    1029. 

  1029. 

  1030.     return face;
    1031. 

  1031. }
    1032. 

  1032. 

  1033. void HB_FreeFace(HB_Face face)
    1034. 

  1034. {
    1035. 

  1035.     if (!face)
    1036. 

  1036.         return;
    1037. 

  1037.     if (face->gpos)
    1038. 

  1038.         HB_Done_GPOS_Table(face->gpos);
    1039. 

  1039.     if (face->gsub)
    1040. 

  1040.         HB_Done_GSUB_Table(face->gsub);
    1041. 

  1041.     if (face->gdef)
    1042. 

  1042.         HB_Done_GDEF_Table(face->gdef);
    1043. 

  1043.     if (face->buffer)
    1044. 

  1044.         hb_buffer_free(face->buffer);
    1045. 

  1045.     if (face->tmpAttributes)
    1046. 

  1046.         free(face->tmpAttributes);
    1047. 

  1047.     if (face->tmpLogClusters)
    1048. 

  1048.         free(face->tmpLogClusters);
    1049. 

  1049.     free(face);
    1050. 

  1050. }
    1051. 

  1051. 

  1052. HB_Bool HB_SelectScript(HB_ShaperItem *shaper_item, const HB_OpenTypeFeature *features)
    1053. 

  1053. {
    1054. 

  1054.     HB_Script script = shaper_item->item.script;
    1055. 

  1055. 

  1056.     HB_Face face = shaper_item->face;
    1057. 

  1057.     if (face->current_script == script && face->current_flags == shaper_item->shaperFlags)
    1058. 

  1058.         return shaper_item->face->supported_scripts[script] ? true : false;
    1059. 

  1059. 

  1060.     face->current_script = script;
    1061. 

  1061.     face->current_flags = shaper_item->shaperFlags;
    1062. 

  1062. 

  1063.     if (!shaper_item->face->supported_scripts[script])
    1064. 

  1064.         return false;
    1065. 

  1065. 

  1066.     assert(script < HB_ScriptCount);
    1067. 

  1067.     // find script in our list of supported scripts.
    1068. 

  1068.     unsigned int tag = ot_scripts[script].tag;
    1069. 

  1069. 

  1070.     if (face->gsub && features) {
    1071. 

  1071. #ifdef OT_DEBUG
    1072. 

  1072.         {
    1073. 

  1073.             HB_FeatureList featurelist = face->gsub->FeatureList;
    1074. 

  1074.             int numfeatures = featurelist.FeatureCount;
    1075. 

  1075.             DEBUG("gsub table has %d features", numfeatures);
    1076. 

  1076.             for (int i = 0; i < numfeatures; i++) {
    1077. 

  1077.                 HB_FeatureRecord *r = featurelist.FeatureRecord + i;
    1078. 

  1078.                 DEBUG("   feature '%s'", tag_to_string(r->FeatureTag));
    1079. 

  1079.             }
    1080. 

  1080.         }
    1081. 

  1081. #endif
    1082. 

  1082.         HB_GSUB_Clear_Features(face->gsub);
    1083. 

  1083.         HB_UShort script_index;
    1084. 

  1084.         HB_Error error = HB_GSUB_Select_Script(face->gsub, tag, &script_index);
    1085. 

  1085.         if (!error) {
    1086. 

  1086.             DEBUG("script %s has script index %d", tag_to_string(script), script_index);
    1087. 

  1087.             while (features->tag) {
    1088. 

  1088.                 HB_UShort feature_index;
    1089. 

  1089.                 error = HB_GSUB_Select_Feature(face->gsub, features->tag, script_index, 0xffff, &feature_index);
    1090. 

  1090.                 if (!error) {
    1091. 

  1091.                     DEBUG("  adding feature %s", tag_to_string(features->tag));
    1092. 

  1092.                     HB_GSUB_Add_Feature(face->gsub, feature_index, features->property);
    1093. 

  1093.                 }
    1094. 

  1094.                 ++features;
    1095. 

  1095.             }
    1096. 

  1096.             if (face->current_flags & HB_ShaperFlag_VerticalWriting) {
    1097. 

  1097.                 HB_UInt tag = HB_MAKE_TAG('v', 'r', 't', '2');
    1098. 

  1098.                 HB_UShort feature_index;
    1099. 

  1099.                 error = HB_GSUB_Select_Feature(face->gsub, tag,
    1100. 

  1100.                                                script_index, 0xffff, &feature_index);
    1101. 

  1101.                 if (!error) {
    1102. 

  1102.                     DEBUG("  adding vertical feature %s", tag_to_string(tag));
    1103. 

  1103.                     HB_GSUB_Add_Feature(face->gsub, feature_index, 1);
    1104. 

  1104.                 } else {
    1105. 

  1105.                     tag = HB_MAKE_TAG('v', 'e', 'r', 't');
    1106. 

  1106.                     error = HB_GSUB_Select_Feature(face->gsub, tag,
    1107. 

  1107.                                                    script_index, 0xffff, &feature_index);
    1108. 

  1108.                     if (!error) {
    1109. 

  1109.                         DEBUG("  adding vertical feature %s", tag_to_string(tag));
    1110. 

  1110.                         HB_GSUB_Add_Feature(face->gsub, feature_index, 1);
    1111. 

  1111.                     }
    1112. 

  1112.                 }
    1113. 

  1113.             }
    1114. 

  1114.         }
    1115. 

  1115.     }
    1116. 

  1116. 

  1117.     // reset
    1118. 

  1118.     face->has_opentype_kerning = false;
    1119. 

  1119. 

  1120.     if (face->gpos) {
    1121. 

  1121.         HB_GPOS_Clear_Features(face->gpos);
    1122. 

  1122.         HB_UShort script_index;
    1123. 

  1123.         HB_Error error = HB_GPOS_Select_Script(face->gpos, tag, &script_index);
    1124. 

  1124.         if (!error) {
    1125. 

  1125. #ifdef OT_DEBUG
    1126. 

  1126.             {
    1127. 

  1127.                 HB_FeatureList featurelist = face->gpos->FeatureList;
    1128. 

  1128.                 int numfeatures = featurelist.FeatureCount;
    1129. 

  1129.                 DEBUG("gpos table has %d features", numfeatures);
    1130. 

  1130.                 for(int i = 0; i < numfeatures; i++) {
    1131. 

  1131.                     HB_FeatureRecord *r = featurelist.FeatureRecord + i;
    1132. 

  1132.                     HB_UShort feature_index;
    1133. 

  1133.                     HB_GPOS_Select_Feature(face->gpos, r->FeatureTag, script_index, 0xffff, &feature_index);
    1134. 

  1134.                     DEBUG("   feature '%s'", tag_to_string(r->FeatureTag));
    1135. 

  1135.                 }
    1136. 

  1136.             }
    1137. 

  1137. #endif
    1138. 

  1138.             HB_UInt *feature_tag_list_buffer;
    1139. 

  1139.             error = HB_GPOS_Query_Features(face->gpos, script_index, 0xffff, &feature_tag_list_buffer);
    1140. 

  1140.             if (!error) {
    1141. 

  1141.                 HB_UInt *feature_tag_list = feature_tag_list_buffer;
    1142. 

  1142.                 while (*feature_tag_list) {
    1143. 

  1143.                     HB_UShort feature_index;
    1144. 

  1144.                     bool skip = false;
    1145. 

  1145.                     if (*feature_tag_list == HB_MAKE_TAG('k', 'e', 'r', 'n')) {
    1146. 

  1146.                         if (face->current_flags & HB_ShaperFlag_NoKerning)
    1147. 

  1147.                             skip = true;
    1148. 

  1148.                         else
    1149. 

  1149.                             face->has_opentype_kerning = true;
    1150. 

  1150.                     }
    1151. 

  1151.                     features = disabled_features;
    1152. 

  1152.                     while (features->tag) {
    1153. 

  1153.                         if (*feature_tag_list == features->tag) {
    1154. 

  1154.                             skip = true;
    1155. 

  1155.                             break;
    1156. 

  1156.                         }
    1157. 

  1157.                         ++features;
    1158. 

  1158.                     }
    1159. 

  1159.                     // 'palt' should be turned off by default unless 'kern' is on
    1160. 

  1160.                     if (!face->has_opentype_kerning &&
    1161. 

  1161.                         *feature_tag_list == HB_MAKE_TAG('p', 'a', 'l', 't'))
    1162. 

  1162.                         skip = true;
    1163. 

  1163. 

  1164.                     if (skip) {
    1165. 

  1165.                         ++feature_tag_list;
    1166. 

  1166.                         continue;
    1167. 

  1167.                     }
    1168. 

  1168.                     error = HB_GPOS_Select_Feature(face->gpos, *feature_tag_list, script_index, 0xffff, &feature_index);
    1169. 

  1169.                     if (!error)
    1170. 

  1170.                         HB_GPOS_Add_Feature(face->gpos, feature_index, PositioningProperties);
    1171. 

  1171.                     ++feature_tag_list;
    1172. 

  1172.                 }
    1173. 

  1173.                 FREE(feature_tag_list_buffer);
    1174. 

  1174.             }
    1175. 

  1175.         }
    1176. 

  1176.     }
    1177. 

  1177. 

  1178.     return true;
    1179. 

  1179. }
    1180. 

  1180. 

  1181. HB_Bool HB_OpenTypeShape(HB_ShaperItem *item, const hb_uint32 *properties)
    1182. 

  1182. {
    1183. 

  1183.     HB_GlyphAttributes *tmpAttributes;
    1184. 

  1184.     unsigned int *tmpLogClusters;
    1185. 

  1185. 

  1186.     HB_Face face = item->face;
    1187. 

  1187. 

  1188.     face->length = item->num_glyphs;
    1189. 

  1189. 

  1190.     hb_buffer_clear(face->buffer);
    1191. 

  1191. 

  1192.     tmpAttributes = (HB_GlyphAttributes *) realloc(face->tmpAttributes, face->length*sizeof(HB_GlyphAttributes));
    1193. 

  1193.     if (!tmpAttributes)
    1194. 

  1194.         return false;
    1195. 

  1195.     face->tmpAttributes = tmpAttributes;
    1196. 

  1196. 

  1197.     tmpLogClusters = (unsigned int *) realloc(face->tmpLogClusters, face->length*sizeof(unsigned int));
    1198. 

  1198.     if (!tmpLogClusters)
    1199. 

  1199.         return false;
    1200. 

  1200.     face->tmpLogClusters = tmpLogClusters;
    1201. 

  1201. 

  1202.     for (int i = 0; i < face->length; ++i) {
    1203. 

  1203.         hb_buffer_add_glyph(face->buffer, item->glyphs[i], properties ? properties[i] : 0, i);
    1204. 

  1204.         face->tmpAttributes[i] = item->attributes[i];
    1205. 

  1205.         face->tmpLogClusters[i] = item->log_clusters[i];
    1206. 

  1206.     }
    1207. 

  1207. 

  1208. #ifdef OT_DEBUG
    1209. 

  1209.     DEBUG("-----------------------------------------");
    1210. 

  1210. //     DEBUG("log clusters before shaping:");
    1211. 

  1211. //     for (int j = 0; j < length; j++)
    1212. 

  1212. //         DEBUG("    log[%d] = %d", j, item->log_clusters[j]);
    1213. 

  1213.     DEBUG("original glyphs: %p", item->glyphs);
    1214. 

  1214.     for (int i = 0; i < length; ++i)
    1215. 

  1215.         DEBUG("   glyph=%4x", hb_buffer->in_string[i].gindex);
    1216. 

  1216. //     dump_string(hb_buffer);
    1217. 

  1217. #endif
    1218. 

  1218. 

  1219.     face->glyphs_substituted = false;
    1220. 

  1220.     if (face->gsub) {
    1221. 

  1221.         unsigned int error = HB_GSUB_Apply_String(face->gsub, face->buffer);
    1222. 

  1222.         if (error && error != HB_Err_Not_Covered)
    1223. 

  1223.             return false;
    1224. 

  1224.         face->glyphs_substituted = (error != HB_Err_Not_Covered);
    1225. 

  1225.     }
    1226. 

  1226. 

  1227. #ifdef OT_DEBUG
    1228. 

  1228. //     DEBUG("log clusters before shaping:");
    1229. 

  1229. //     for (int j = 0; j < length; j++)
    1230. 

  1230. //         DEBUG("    log[%d] = %d", j, item->log_clusters[j]);
    1231. 

  1231.     DEBUG("shaped glyphs:");
    1232. 

  1232.     for (int i = 0; i < length; ++i)
    1233. 

  1233.         DEBUG("   glyph=%4x", hb_buffer->in_string[i].gindex);
    1234. 

  1234.     DEBUG("-----------------------------------------");
    1235. 

  1235. //     dump_string(hb_buffer);
    1236. 

  1236. #endif
    1237. 

  1237. 

  1238.     return true;
    1239. 

  1239. }
    1240. 

  1240. 

  1241. HB_Bool HB_OpenTypePosition(HB_ShaperItem *item, int availableGlyphs, HB_Bool doLogClusters)
    1242. 

  1242. {
    1243. 

  1243.     HB_Face face = item->face;
    1244. 

  1244. 

  1245.     bool glyphs_positioned = false;
    1246. 

  1246.     if (face->gpos) {
    1247. 

  1247.         if (face->buffer->positions)
    1248. 

  1248.             memset(face->buffer->positions, 0, face->buffer->in_length*sizeof(HB_PositionRec));
    1249. 

  1249.         // #### check that passing "false,false" is correct
    1250. 

  1250.         glyphs_positioned = HB_GPOS_Apply_String(item->font, face->gpos, face->current_flags, face->buffer, false, false) != HB_Err_Not_Covered;
    1251. 

  1251.     }
    1252. 

  1252. 

  1253.     if (!face->glyphs_substituted && !glyphs_positioned) {
    1254. 

  1254.         HB_HeuristicPosition(item);
    1255. 

  1255.         return true; // nothing to do for us
    1256. 

  1256.     }
    1257. 

  1257. 

  1258.     // make sure we have enough space to write everything back
    1259. 

  1259.     if (availableGlyphs < (int)face->buffer->in_length) {
    1260. 

  1260.         item->num_glyphs = face->buffer->in_length;
    1261. 

  1261.         return false;
    1262. 

  1262.     }
    1263. 

  1263. 

  1264.     HB_Glyph *glyphs = item->glyphs;
    1265. 

  1265.     HB_GlyphAttributes *attributes = item->attributes;
    1266. 

  1266. 

  1267.     for (unsigned int i = 0; i < face->buffer->in_length; ++i) {
    1268. 

  1268.         glyphs[i] = face->buffer->in_string[i].gindex;
    1269. 

  1269.         attributes[i] = face->tmpAttributes[face->buffer->in_string[i].cluster];
    1270. 

  1270.         if (i && face->buffer->in_string[i].cluster == face->buffer->in_string[i-1].cluster)
    1271. 

  1271.             attributes[i].clusterStart = false;
    1272. 

  1272.     }
    1273. 

  1273.     item->num_glyphs = face->buffer->in_length;
    1274. 

  1274. 

  1275.     if (doLogClusters && face->glyphs_substituted) {
    1276. 

  1276.         // we can't do this for indic, as we pass the stuf in syllables and it's easier to do it in the shaper.
    1277. 

  1277.         unsigned short *logClusters = item->log_clusters;
    1278. 

  1278.         int clusterStart = 0;
    1279. 

  1279.         int oldCi = 0;
    1280. 

  1280.         // #### the reconstruction of the logclusters currently does not work if the original string
    1281. 

  1281.         // contains surrogate pairs
    1282. 

  1282.         for (unsigned int i = 0; i < face->buffer->in_length; ++i) {
    1283. 

  1283.             int ci = face->buffer->in_string[i].cluster;
    1284. 

  1284.             //         DEBUG("   ci[%d] = %d mark=%d, cmb=%d, cs=%d",
    1285. 

  1285.             //                i, ci, glyphAttributes[i].mark, glyphAttributes[i].combiningClass, glyphAttributes[i].clusterStart);
    1286. 

  1286.             if (!attributes[i].mark && attributes[i].clusterStart && ci != oldCi) {
    1287. 

  1287.                 for (int j = oldCi; j < ci; j++)
    1288. 

  1288.                     logClusters[j] = clusterStart;
    1289. 

  1289.                 clusterStart = i;
    1290. 

  1290.                 oldCi = ci;
    1291. 

  1291.             }
    1292. 

  1292.         }
    1293. 

  1293.         for (int j = oldCi; j < face->length; j++)
    1294. 

  1294.             logClusters[j] = clusterStart;
    1295. 

  1295.     }
    1296. 

  1296. 

  1297.     // calulate the advances for the shaped glyphs
    1298. 

  1298. //     DEBUG("unpositioned: ");
    1299. 

  1299. 

  1300.     // positioning code:
    1301. 

  1301.     if (glyphs_positioned) {
    1302. 

  1302.         HB_GetGlyphAdvances(item);
    1303. 

  1303.         HB_Position pos…
    1304.

Large files files are truncated, but you can click here to view the full file