PageRenderTime 63ms CodeModel.GetById 25ms RepoModel.GetById 1ms app.codeStats 0ms

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

https://bitbucket.org/gcubar/qt
C++ | 1423 lines | 1063 code | 145 blank | 215 comment | 328 complexity | ed4e37d6ca779a5ca1b0dca121ec3756 MD5 | raw file
Possible License(s): CC0-1.0, CC-BY-SA-4.0, LGPL-2.1, GPL-3.0, Apache-2.0, LGPL-2.0, LGPL-3.0, BSD-3-Clause

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.     // To fix some Thai character heights check for two above glyphs
    269. 

  269.     if (nmarks == 2 && (attributes[gfrom+1].combiningClass == HB_Combining_AboveRight ||
    270. 

  270.             attributes[gfrom+1].combiningClass  == HB_Combining_AboveLeft ||
    271. 

  271.             attributes[gfrom+1].combiningClass == HB_Combining_Above))
    272. 

  272.         if (attributes[gfrom+2].combiningClass == 23 ||
    273. 

  273.             attributes[gfrom+2].combiningClass == 24 ||
    274. 

  274.             attributes[gfrom+2].combiningClass == 25 ||
    275. 

  275.             attributes[gfrom+2].combiningClass == 27 ||
    276. 

  276.             attributes[gfrom+2].combiningClass == 28 ||
    277. 

  277.             attributes[gfrom+2].combiningClass == 30 ||
    278. 

  278.             attributes[gfrom+2].combiningClass == 31 ||
    279. 

  279.             attributes[gfrom+2].combiningClass == 33 ||
    280. 

  280.             attributes[gfrom+2].combiningClass == 34 ||
    281. 

  281.             attributes[gfrom+2].combiningClass == 35 ||
    282. 

  282.             attributes[gfrom+2].combiningClass == 36 ||
    283. 

  283.             attributes[gfrom+2].combiningClass == 107 ||
    284. 

  284.             attributes[gfrom+2].combiningClass == 122) {
    285. 

  285.             // Two above glyphs, check total height
    286. 

  286.             int markTotalHeight = baseMetrics.height;
    287. 

  287.             HB_GlyphMetrics markMetrics;
    288. 

  288.             item->font->klass->getGlyphMetrics(item->font, glyphs[gfrom+1], &markMetrics);
    289. 

  289.             markTotalHeight += markMetrics.height;
    290. 

  290.             item->font->klass->getGlyphMetrics(item->font, glyphs[gfrom+2], &markMetrics);
    291. 

  291.             markTotalHeight += markMetrics.height;
    292. 

  292.             if ((markTotalHeight + 2 * offsetBase) > (size * 10))
    293. 

  293.                 offsetBase = ((size * 10) - markTotalHeight) / 2; // Use offset that just fits
    294. 

  294.         }
    295. 

  295. 

  296.     bool rightToLeft = item->item.bidiLevel % 2;
    297. 

  297. 

  298.     int i;
    299. 

  299.     unsigned char lastCmb = 0;
    300. 

  300.     HB_GlyphMetrics attachmentRect;
    301. 

  301.     memset(&attachmentRect, 0, sizeof(attachmentRect));
    302. 

  302. 

  303.     for(i = 1; i <= nmarks; i++) {
    304. 

  304.         HB_Glyph mark = glyphs[gfrom+i];
    305. 

  305.         HB_GlyphMetrics markMetrics;
    306. 

  306.         item->font->klass->getGlyphMetrics(item->font, mark, &markMetrics);
    307. 

  307.         HB_FixedPoint p;
    308. 

  308.         p.x = p.y = 0;
    309. 

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

  310. 

  311.         HB_Fixed offset = offsetBase;
    312. 

  312.         unsigned char cmb = attributes[gfrom+i].combiningClass;
    313. 

  313. 

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

  315.         // bits  in the glyphAttributes structure.
    316. 

  316.         if (cmb < 200) {
    317. 

  317.             // fixed position classes. We approximate by mapping to one of the others.
    318. 

  318.             // currently I added only the ones for arabic, hebrew, lao and thai.
    319. 

  319. 

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

  321. 

  322.             // add a bit more offset to arabic, a bit hacky
    323. 

  323.             if (cmb >= 27 && cmb <= 36 && offset < 3)
    324. 

  324.                 offset +=1;
    325. 

  325.             // below
    326. 

  326.             if ((cmb >= 10 && cmb <= 18) ||
    327. 

  327.                  cmb == 20 || cmb == 22 ||
    328. 

  328.                  cmb == 29 || cmb == 32)
    329. 

  329.                 cmb = HB_Combining_Below;
    330. 

  330.             // above
    331. 

  331.             else if (cmb == 23 || cmb == 27 || cmb == 28 ||
    332. 

  332.                       cmb == 30 || cmb == 31 || (cmb >= 33 && cmb <= 36))
    333. 

  333.                 cmb = HB_Combining_Above;
    334. 

  334.             //below-right
    335. 

  335.             else if (cmb == 9 || cmb == 103 || cmb == 118)
    336. 

  336.                 cmb = HB_Combining_BelowRight;
    337. 

  337.             // above-right
    338. 

  338.             else if (cmb == 24 || cmb == 107 || cmb == 122)
    339. 

  339.                 cmb = HB_Combining_AboveRight;
    340. 

  340.             else if (cmb == 25)
    341. 

  341.                 cmb = HB_Combining_AboveLeft;
    342. 

  342.             // fixed:
    343. 

  343.             //  19 21
    344. 

  344. 

  345.         }
    346. 

  346. 

  347.         // Check drawing below fonts descent
    348. 

  348.         if (cmb == HB_Combining_Below || cmb == HB_Combining_BelowRight)
    349. 

  349.             if ((markMetrics.height + offset) > item->font->klass->getFontMetric(item->font, HB_FontDescent))
    350. 

  350.                 offset = markMetrics.y; // Use offset from mark metrics so it won't get drawn below descent
    351. 

  351. 

  352.         // combining marks of different class don't interact. Reset the rectangle.
    353. 

  353.         if (cmb != lastCmb) {
    354. 

  354.             //qDebug("resetting rect");
    355. 

  355.             attachmentRect = baseMetrics;
    356. 

  356.         }
    357. 

  357. 

  358.         switch(cmb) {
    359. 

  359.         case HB_Combining_DoubleBelow:
    360. 

  360.                 // ### wrong in rtl context!
    361. 

  361.         case HB_Combining_BelowLeft:
    362. 

  362.             p.y += offset;
    363. 

  363.         case HB_Combining_BelowLeftAttached:
    364. 

  364.             p.x += attachmentRect.x - markMetrics.x;
    365. 

  365.             p.y += (attachmentRect.y + attachmentRect.height) - markMetrics.y;
    366. 

  366.             break;
    367. 

  367.         case HB_Combining_Below:
    368. 

  368.             p.y += offset;
    369. 

  369.         case HB_Combining_BelowAttached:
    370. 

  370.             p.x += attachmentRect.x - markMetrics.x;
    371. 

  371.             p.y += (attachmentRect.y + attachmentRect.height) - markMetrics.y;
    372. 

  372. 

  373.             p.x += (attachmentRect.width - markMetrics.width) / 2;
    374. 

  374.             break;
    375. 

  375.         case HB_Combining_BelowRight:
    376. 

  376.             p.y += offset;
    377. 

  377.         case HB_Combining_BelowRightAttached:
    378. 

  378.             p.x += attachmentRect.x + attachmentRect.width - markMetrics.width - markMetrics.x;
    379. 

  379.             p.y += attachmentRect.y + attachmentRect.height - markMetrics.y;
    380. 

  380.             break;
    381. 

  381.         case HB_Combining_Left:
    382. 

  382.             p.x -= offset;
    383. 

  383.         case HB_Combining_LeftAttached:
    384. 

  384.             break;
    385. 

  385.         case HB_Combining_Right:
    386. 

  386.             p.x += offset;
    387. 

  387.         case HB_Combining_RightAttached:
    388. 

  388.             break;
    389. 

  389.         case HB_Combining_DoubleAbove:
    390. 

  390.             // ### wrong in RTL context!
    391. 

  391.         case HB_Combining_AboveLeft:
    392. 

  392.             p.y -= offset;
    393. 

  393.         case HB_Combining_AboveLeftAttached:
    394. 

  394.             p.x += attachmentRect.x - markMetrics.x;
    395. 

  395.             p.y += attachmentRect.y - markMetrics.y - markMetrics.height;
    396. 

  396.             break;
    397. 

  397.         case HB_Combining_Above:
    398. 

  398.             p.y -= offset;
    399. 

  399.         case HB_Combining_AboveAttached:
    400. 

  400.             p.x += attachmentRect.x - markMetrics.x;
    401. 

  401.             p.y += attachmentRect.y - markMetrics.y - markMetrics.height;
    402. 

  402. 

  403.             p.x += (attachmentRect.width - markMetrics.width) / 2;
    404. 

  404.             break;
    405. 

  405.         case HB_Combining_AboveRight:
    406. 

  406.             p.y -= offset;
    407. 

  407.         case HB_Combining_AboveRightAttached:
    408. 

  408.             p.x += attachmentRect.x + attachmentRect.width - markMetrics.x - markMetrics.width;
    409. 

  409.             p.y += attachmentRect.y - markMetrics.y - markMetrics.height;
    410. 

  410.             break;
    411. 

  411. 

  412.         case HB_Combining_IotaSubscript:
    413. 

  413.             default:
    414. 

  414.                 break;
    415. 

  415.         }
    416. 

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

  417.         markMetrics.x += p.x;
    418. 

  418.         markMetrics.y += p.y;
    419. 

  419. 

  420.         HB_GlyphMetrics unitedAttachmentRect = attachmentRect;
    421. 

  421.         unitedAttachmentRect.x = HB_MIN(attachmentRect.x, markMetrics.x);
    422. 

  422.         unitedAttachmentRect.y = HB_MIN(attachmentRect.y, markMetrics.y);
    423. 

  423.         unitedAttachmentRect.width = HB_MAX(attachmentRect.x + attachmentRect.width, markMetrics.x + markMetrics.width) - unitedAttachmentRect.x;
    424. 

  424.         unitedAttachmentRect.height = HB_MAX(attachmentRect.y + attachmentRect.height, markMetrics.y + markMetrics.height) - unitedAttachmentRect.y;
    425. 

  425.         attachmentRect = unitedAttachmentRect;
    426. 

  426. 

  427.         lastCmb = cmb;
    428. 

  428.         if (rightToLeft) {
    429. 

  429.             item->offsets[gfrom+i].x = p.x;
    430. 

  430.             item->offsets[gfrom+i].y = p.y;
    431. 

  431.         } else {
    432. 

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

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

  434.         }
    435. 

  435.         item->advances[gfrom+i] = 0;
    436. 

  436.     }
    437. 

  437. }
    438. 

  438. 

  439. void HB_HeuristicPosition(HB_ShaperItem *item)
    440. 

  440. {
    441. 

  441.     HB_GetGlyphAdvances(item);
    442. 

  442.     HB_GlyphAttributes *attributes = item->attributes;
    443. 

  443. 

  444.     int cEnd = -1;
    445. 

  445.     int i = item->num_glyphs;
    446. 

  446.     while (i--) {
    447. 

  447.         if (cEnd == -1 && attributes[i].mark) {
    448. 

  448.             cEnd = i;
    449. 

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

  450.             positionCluster(item, i, cEnd);
    451. 

  451.             cEnd = -1;
    452. 

  452.         }
    453. 

  453.     }
    454. 

  454. }
    455. 

  455. 

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

  457. // and no reordering.
    458. 

  458. // also computes logClusters heuristically
    459. 

  459. void HB_HeuristicSetGlyphAttributes(HB_ShaperItem *item)
    460. 

  460. {
    461. 

  461.     const HB_UChar16 *uc = item->string + item->item.pos;
    462. 

  462.     hb_uint32 length = item->item.length;
    463. 

  463. 

  464.     // ### zeroWidth and justification are missing here!!!!!
    465. 

  465. 

  466.     assert(item->num_glyphs <= length);
    467. 

  467. 

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

  469.     HB_GlyphAttributes *attributes = item->attributes;
    470. 

  470.     unsigned short *logClusters = item->log_clusters;
    471. 

  471. 

  472.     hb_uint32 glyph_pos = 0;
    473. 

  473.     hb_uint32 i;
    474. 

  474.     for (i = 0; i < length; i++) {
    475. 

  475.         if (HB_IsHighSurrogate(uc[i]) && i < length - 1
    476. 

  476.             && HB_IsLowSurrogate(uc[i + 1])) {
    477. 

  477.             logClusters[i] = glyph_pos;
    478. 

  478.             logClusters[++i] = glyph_pos;
    479. 

  479.         } else {
    480. 

  480.             logClusters[i] = glyph_pos;
    481. 

  481.         }
    482. 

  482.         ++glyph_pos;
    483. 

  483.     }
    484. 

  484.     assert(glyph_pos == item->num_glyphs);
    485. 

  485. 

  486.     // first char in a run is never (treated as) a mark
    487. 

  487.     int cStart = 0;
    488. 

  488.     const bool symbolFont = item->face->isSymbolFont;
    489. 

  489.     attributes[0].mark = false;
    490. 

  490.     attributes[0].clusterStart = true;
    491. 

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

  492. 

  493.     int pos = 0;
    494. 

  494.     HB_CharCategory lastCat;
    495. 

  495.     int dummy;
    496. 

  496.     HB_GetUnicodeCharProperties(uc[0], &lastCat, &dummy);
    497. 

  497.     for (i = 1; i < length; ++i) {
    498. 

  498.         if (logClusters[i] == pos)
    499. 

  499.             // same glyph
    500. 

  500.             continue;
    501. 

  501.         ++pos;
    502. 

  502.         while (pos < logClusters[i]) {
    503. 

  503.             attributes[pos] = attributes[pos-1];
    504. 

  504.             ++pos;
    505. 

  505.         }
    506. 

  506.         // hide soft-hyphens by default
    507. 

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

  508.             attributes[pos].dontPrint = true;
    509. 

  509.         HB_CharCategory cat;
    510. 

  510.         int cmb;
    511. 

  511.         HB_GetUnicodeCharProperties(uc[i], &cat, &cmb);
    512. 

  512.         if (cat != HB_Mark_NonSpacing) {
    513. 

  513.             attributes[pos].mark = false;
    514. 

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

  515.             attributes[pos].combiningClass = 0;
    516. 

  516.             cStart = logClusters[i];
    517. 

  517.         } else {
    518. 

  518.             if (cmb == 0) {
    519. 

  519.                 // Fix 0 combining classes
    520. 

  520.                 if ((uc[pos] & 0xff00) == 0x0e00) {
    521. 

  521.                     // thai or lao
    522. 

  522.                     if (uc[pos] == 0xe31 ||
    523. 

  523.                          uc[pos] == 0xe34 ||
    524. 

  524.                          uc[pos] == 0xe35 ||
    525. 

  525.                          uc[pos] == 0xe36 ||
    526. 

  526.                          uc[pos] == 0xe37 ||
    527. 

  527.                          uc[pos] == 0xe47 ||
    528. 

  528.                          uc[pos] == 0xe4c ||
    529. 

  529.                          uc[pos] == 0xe4d ||
    530. 

  530.                          uc[pos] == 0xe4e) {
    531. 

  531.                         cmb = HB_Combining_AboveRight;
    532. 

  532.                     } else if (uc[pos] == 0xeb1 ||
    533. 

  533.                                 uc[pos] == 0xeb4 ||
    534. 

  534.                                 uc[pos] == 0xeb5 ||
    535. 

  535.                                 uc[pos] == 0xeb6 ||
    536. 

  536.                                 uc[pos] == 0xeb7 ||
    537. 

  537.                                 uc[pos] == 0xebb ||
    538. 

  538.                                 uc[pos] == 0xecc ||
    539. 

  539.                                 uc[pos] == 0xecd) {
    540. 

  540.                         cmb = HB_Combining_Above;
    541. 

  541.                     } else if (uc[pos] == 0xebc) {
    542. 

  542.                         cmb = HB_Combining_Below;
    543. 

  543.                     }
    544. 

  544.                 }
    545. 

  545.             }
    546. 

  546. 

  547.             attributes[pos].mark = true;
    548. 

  548.             attributes[pos].clusterStart = false;
    549. 

  549.             attributes[pos].combiningClass = cmb;
    550. 

  550.             logClusters[i] = cStart;
    551. 

  551.         }
    552. 

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

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

  554.         // after the space char.
    555. 

  555.         if (lastCat == HB_Separator_Space)
    556. 

  556.             attributes[pos-1].justification = HB_Space;
    557. 

  557.         else if (cat != HB_Mark_NonSpacing)
    558. 

  558.             attributes[pos-1].justification = HB_Character;
    559. 

  559.         else
    560. 

  560.             attributes[pos-1].justification = HB_NoJustification;
    561. 

  561. 

  562.         lastCat = cat;
    563. 

  563.     }
    564. 

  564.     pos = logClusters[length-1];
    565. 

  565.     if (lastCat == HB_Separator_Space)
    566. 

  566.         attributes[pos].justification = HB_Space;
    567. 

  567.     else
    568. 

  568.         attributes[pos].justification = HB_Character;
    569. 

  569. }
    570. 

  570. 

  571. #ifndef NO_OPENTYPE
    572. 

  572. static const HB_OpenTypeFeature basic_features[] = {
    573. 

  573.     { HB_MAKE_TAG('c', 'c', 'm', 'p'), CcmpProperty },
    574. 

  574.     { HB_MAKE_TAG('l', 'i', 'g', 'a'), LigaProperty },
    575. 

  575.     { HB_MAKE_TAG('c', 'l', 'i', 'g'), CligProperty },
    576. 

  576.     {0, 0}
    577. 

  577. };
    578. 

  578. 

  579. static const HB_OpenTypeFeature disabled_features[] = {
    580. 

  580.     { HB_MAKE_TAG('c', 'p', 'c', 't'), PositioningProperties },
    581. 

  581.     { HB_MAKE_TAG('h', 'a', 'l', 't'), PositioningProperties },
    582. 

  582.     // TODO: we need to add certain HB_ShaperFlag for vertical
    583. 

  583.     // writing mode to enable these vertical writing features:
    584. 

  584.     { HB_MAKE_TAG('v', 'a', 'l', 't'), PositioningProperties },
    585. 

  585.     { HB_MAKE_TAG('v', 'h', 'a', 'l'), PositioningProperties },
    586. 

  586.     { HB_MAKE_TAG('v', 'k', 'r', 'n'), PositioningProperties },
    587. 

  587.     { HB_MAKE_TAG('v', 'p', 'a', 'l'), PositioningProperties },
    588. 

  588.     {0, 0}
    589. 

  589. };
    590. 

  590. #endif
    591. 

  591. 

  592. HB_Bool HB_ConvertStringToGlyphIndices(HB_ShaperItem *shaper_item)
    593. 

  593. {
    594. 

  594.     if (shaper_item->glyphIndicesPresent) {
    595. 

  595.         shaper_item->num_glyphs = shaper_item->initialGlyphCount;
    596. 

  596.         shaper_item->glyphIndicesPresent = false;
    597. 

  597.         return true;
    598. 

  598.     }
    599. 

  599.     return shaper_item->font->klass
    600. 

  600.            ->convertStringToGlyphIndices(shaper_item->font,
    601. 

  601.                                          shaper_item->string + shaper_item->item.pos, shaper_item->item.length,
    602. 

  602.                                          shaper_item->glyphs, &shaper_item->num_glyphs,
    603. 

  603.                                          shaper_item->item.bidiLevel % 2);
    604. 

  604. }
    605. 

  605. 

  606. HB_Bool HB_BasicShape(HB_ShaperItem *shaper_item)
    607. 

  607. {
    608. 

  608. #ifndef NO_OPENTYPE
    609. 

  609.     const int availableGlyphs = shaper_item->num_glyphs;
    610. 

  610. #endif
    611. 

  611. 

  612.     if (!HB_ConvertStringToGlyphIndices(shaper_item))
    613. 

  613.         return false;
    614. 

  614. 

  615.     HB_HeuristicSetGlyphAttributes(shaper_item);
    616. 

  616. 

  617. #ifndef NO_OPENTYPE
    618. 

  618.     if (HB_SelectScript(shaper_item, basic_features)) {
    619. 

  619.         HB_OpenTypeShape(shaper_item, /*properties*/0);
    620. 

  620.         return HB_OpenTypePosition(shaper_item, availableGlyphs, /*doLogClusters*/true);
    621. 

  621.     }
    622. 

  622. #endif
    623. 

  623. 

  624.     HB_HeuristicPosition(shaper_item);
    625. 

  625.     return true;
    626. 

  626. }
    627. 

  627. 

  628. const HB_ScriptEngine HB_ScriptEngines[] = {
    629. 

  629.     // Common
    630. 

  630.     { HB_BasicShape, 0},
    631. 

  631.     // Greek
    632. 

  632.     { HB_GreekShape, 0},
    633. 

  633.     // Cyrillic
    634. 

  634.     { HB_BasicShape, 0},
    635. 

  635.     // Armenian
    636. 

  636.     { HB_BasicShape, 0},
    637. 

  637.     // Hebrew
    638. 

  638.     { HB_HebrewShape, 0 },
    639. 

  639.     // Arabic
    640. 

  640.     { HB_ArabicShape, 0},
    641. 

  641.     // Syriac
    642. 

  642.     { HB_ArabicShape, 0},
    643. 

  643.     // Thaana
    644. 

  644.     { HB_BasicShape, 0 },
    645. 

  645.     // Devanagari
    646. 

  646.     { HB_IndicShape, HB_IndicAttributes },
    647. 

  647.     // Bengali
    648. 

  648.     { HB_IndicShape, HB_IndicAttributes },
    649. 

  649.     // Gurmukhi
    650. 

  650.     { HB_IndicShape, HB_IndicAttributes },
    651. 

  651.     // Gujarati
    652. 

  652.     { HB_IndicShape, HB_IndicAttributes },
    653. 

  653.     // Oriya
    654. 

  654.     { HB_IndicShape, HB_IndicAttributes },
    655. 

  655.     // Tamil
    656. 

  656.     { HB_IndicShape, HB_IndicAttributes },
    657. 

  657.     // Telugu
    658. 

  658.     { HB_IndicShape, HB_IndicAttributes },
    659. 

  659.     // Kannada
    660. 

  660.     { HB_IndicShape, HB_IndicAttributes },
    661. 

  661.     // Malayalam
    662. 

  662.     { HB_IndicShape, HB_IndicAttributes },
    663. 

  663.     // Sinhala
    664. 

  664.     { HB_IndicShape, HB_IndicAttributes },
    665. 

  665.     // Thai
    666. 

  666.     { HB_ThaiShape, HB_ThaiAttributes },
    667. 

  667.     // Lao
    668. 

  668.     { HB_BasicShape, 0 },
    669. 

  669.     // Tibetan
    670. 

  670.     { HB_TibetanShape, HB_TibetanAttributes },
    671. 

  671.     // Myanmar
    672. 

  672.     { HB_MyanmarShape, HB_MyanmarAttributes },
    673. 

  673.     // Georgian
    674. 

  674.     { HB_BasicShape, 0 },
    675. 

  675.     // Hangul
    676. 

  676.     { HB_HangulShape, 0 },
    677. 

  677.     // Ogham
    678. 

  678.     { HB_BasicShape, 0 },
    679. 

  679.     // Runic
    680. 

  680.     { HB_BasicShape, 0 },
    681. 

  681.     // Khmer
    682. 

  682.     { HB_KhmerShape, HB_KhmerAttributes },
    683. 

  683.     // N'Ko
    684. 

  684.     { HB_ArabicShape, 0}
    685. 

  685. };
    686. 

  686. 

  687. void HB_GetCharAttributes(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.     memset(attributes, 0, stringLength * sizeof(HB_CharAttributes));
    692. 

  692.     calcLineBreaks(string, stringLength, attributes);
    693. 

  693. 

  694.     for (hb_uint32 i = 0; i < numItems; ++i) {
    695. 

  695.         HB_Script script = items[i].script;
    696. 

  696.         if (script == HB_Script_Inherited)
    697. 

  697.             script = HB_Script_Common;
    698. 

  698.         HB_AttributeFunction attributeFunction = HB_ScriptEngines[script].charAttributes;
    699. 

  699.         if (!attributeFunction)
    700. 

  700.             continue;
    701. 

  701.         attributeFunction(script, string, items[i].pos, items[i].length, attributes);
    702. 

  702.     }
    703. 

  703. }
    704. 

  704. 

  705. 

  706. enum BreakRule { NoBreak = 0, Break = 1, Middle = 2 };
    707. 

  707. 

  708. static const hb_uint8 wordbreakTable[HB_Word_ExtendNumLet + 1][HB_Word_ExtendNumLet + 1] = {
    709. 

  709. //        Other    Format   Katakana ALetter  MidLetter MidNum  Numeric  ExtendNumLet
    710. 

  710.     {   Break,   Break,   Break,   Break,   Break,   Break,   Break,   Break }, // Other
    711. 

  711.     {   Break,   Break,   Break,   Break,   Break,   Break,   Break,   Break }, // Format 
    712. 

  712.     {   Break,   Break, NoBreak,   Break,   Break,   Break,   Break, NoBreak }, // Katakana
    713. 

  713.     {   Break,   Break,   Break, NoBreak,  Middle,   Break, NoBreak, NoBreak }, // ALetter
    714. 

  714.     {   Break,   Break,   Break,   Break,   Break,   Break,   Break,   Break }, // MidLetter
    715. 

  715.     {   Break,   Break,   Break,   Break,   Break,   Break,   Break,   Break }, // MidNum
    716. 

  716.     {   Break,   Break,   Break, NoBreak,   Break,  Middle, NoBreak, NoBreak }, // Numeric
    717. 

  717.     {   Break,   Break, NoBreak, NoBreak,   Break,   Break, NoBreak, NoBreak }, // ExtendNumLet
    718. 

  718. };
    719. 

  719. 

  720. void HB_GetWordBoundaries(const HB_UChar16 *string, hb_uint32 stringLength,
    721. 

  721.                           const HB_ScriptItem * /*items*/, hb_uint32 /*numItems*/,
    722. 

  722.                           HB_CharAttributes *attributes)
    723. 

  723. {
    724. 

  724.     if (stringLength == 0)
    725. 

  725.         return;
    726. 

  726.     unsigned int brk = HB_GetWordClass(string[0]);
    727. 

  727.     attributes[0].wordBoundary = true;
    728. 

  728.     for (hb_uint32 i = 1; i < stringLength; ++i) {
    729. 

  729.         if (!attributes[i].charStop) {
    730. 

  730.             attributes[i].wordBoundary = false;
    731. 

  731.             continue;
    732. 

  732.         }
    733. 

  733.         hb_uint32 nbrk = HB_GetWordClass(string[i]);
    734. 

  734.         if (nbrk == HB_Word_Format) {
    735. 

  735.             attributes[i].wordBoundary = (HB_GetSentenceClass(string[i-1]) == HB_Sentence_Sep);
    736. 

  736.             continue;
    737. 

  737.         }
    738. 

  738.         BreakRule rule = (BreakRule)wordbreakTable[brk][nbrk];
    739. 

  739.         if (rule == Middle) {
    740. 

  740.             rule = Break;
    741. 

  741.             hb_uint32 lookahead = i + 1;
    742. 

  742.             while (lookahead < stringLength) {
    743. 

  743.                 hb_uint32 testbrk = HB_GetWordClass(string[lookahead]);
    744. 

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

  745.                     ++lookahead;
    746. 

  746.                     continue;
    747. 

  747.                 }
    748. 

  748.                 if (testbrk == brk) {
    749. 

  749.                     rule = NoBreak;
    750. 

  750.                     while (i < lookahead)
    751. 

  751.                         attributes[i++].wordBoundary = false;
    752. 

  752.                     nbrk = testbrk;
    753. 

  753.                 }
    754. 

  754.                 break;
    755. 

  755.             }
    756. 

  756.         }
    757. 

  757.         attributes[i].wordBoundary = (rule == Break);
    758. 

  758.         brk = nbrk;
    759. 

  759.     }
    760. 

  760. }
    761. 

  761. 

  762. 

  763. enum SentenceBreakStates {
    764. 

  764.     SB_Initial,
    765. 

  765.     SB_Upper,
    766. 

  766.     SB_UpATerm, 
    767. 

  767.     SB_ATerm,
    768. 

  768.     SB_ATermC, 
    769. 

  769.     SB_ACS, 
    770. 

  770.     SB_STerm, 
    771. 

  771.     SB_STermC, 
    772. 

  772.     SB_SCS,
    773. 

  773.     SB_BAfter, 
    774. 

  774.     SB_Break,
    775. 

  775.     SB_Look
    776. 

  776. };
    777. 

  777. 

  778. static const hb_uint8 sentenceBreakTable[HB_Sentence_Close + 1][HB_Sentence_Close + 1] = {
    779. 

  779. //        Other       Sep         Format      Sp          Lower       Upper       OLetter     Numeric     ATerm       STerm       Close
    780. 

  780.       { SB_Initial, SB_BAfter , SB_Initial, SB_Initial, SB_Initial, SB_Upper  , SB_Initial, SB_Initial, SB_ATerm  , SB_STerm  , SB_Initial }, // SB_Initial,
    781. 

  781.       { SB_Initial, SB_BAfter , SB_Upper  , SB_Initial, SB_Initial, SB_Upper  , SB_Initial, SB_Initial, SB_UpATerm, SB_STerm  , SB_Initial }, // SB_Upper
    782. 

  782.       
    783. 

  783.       { SB_Look   , SB_BAfter , SB_UpATerm, SB_ACS    , SB_Initial, SB_Upper  , SB_Break  , SB_Initial, SB_ATerm  , SB_STerm  , SB_ATermC  }, // SB_UpATerm
    784. 

  784.       { SB_Look   , SB_BAfter , SB_ATerm  , SB_ACS    , SB_Initial, SB_Break  , SB_Break  , SB_Initial, SB_ATerm  , SB_STerm  , SB_ATermC  }, // SB_ATerm
    785. 

  785.       { SB_Look   , SB_BAfter , SB_ATermC , SB_ACS    , SB_Initial, SB_Break  , SB_Break  , SB_Look   , SB_ATerm  , SB_STerm  , SB_ATermC  }, // SB_ATermC,
    786. 

  786.       { SB_Look   , SB_BAfter , SB_ACS    , SB_ACS    , SB_Initial, SB_Break  , SB_Break  , SB_Look   , SB_ATerm  , SB_STerm  , SB_Look    }, // SB_ACS,
    787. 

  787.       
    788. 

  788.       { SB_Break  , SB_BAfter , SB_STerm  , SB_SCS    , SB_Break  , SB_Break  , SB_Break  , SB_Break  , SB_ATerm  , SB_STerm  , SB_STermC  }, // SB_STerm,
    789. 

  789.       { SB_Break  , SB_BAfter , SB_STermC , SB_SCS    , SB_Break  , SB_Break  , SB_Break  , SB_Break  , SB_ATerm  , SB_STerm  , SB_STermC  }, // SB_STermC,
    790. 

  790.       { SB_Break  , SB_BAfter , SB_SCS    , SB_SCS    , SB_Break  , SB_Break  , SB_Break  , SB_Break  , SB_ATerm  , SB_STerm  , SB_Break   }, // SB_SCS,
    791. 

  791.       { SB_Break  , SB_Break  , SB_Break  , SB_Break  , SB_Break  , SB_Break  , SB_Break  , SB_Break  , SB_Break  , SB_Break  , SB_Break   }, // SB_BAfter,
    792. 

  792. };
    793. 

  793. 

  794. void HB_GetSentenceBoundaries(const HB_UChar16 *string, hb_uint32 stringLength,
    795. 

  795.                               const HB_ScriptItem * /*items*/, hb_uint32 /*numItems*/,
    796. 

  796.                               HB_CharAttributes *attributes)
    797. 

  797. {
    798. 

  798.     if (stringLength == 0)
    799. 

  799.         return;
    800. 

  800.     hb_uint32 brk = sentenceBreakTable[SB_Initial][HB_GetSentenceClass(string[0])];
    801. 

  801.     attributes[0].sentenceBoundary = true;
    802. 

  802.     for (hb_uint32 i = 1; i < stringLength; ++i) {
    803. 

  803.         if (!attributes[i].charStop) {
    804. 

  804.             attributes[i].sentenceBoundary = false;
    805. 

  805.             continue;
    806. 

  806.         }
    807. 

  807.         brk = sentenceBreakTable[brk][HB_GetSentenceClass(string[i])];
    808. 

  808.         if (brk == SB_Look) {
    809. 

  809.             brk = SB_Break;
    810. 

  810.             hb_uint32 lookahead = i + 1;
    811. 

  811.             while (lookahead < stringLength) {
    812. 

  812.                 hb_uint32 sbrk = HB_GetSentenceClass(string[lookahead]);
    813. 

  813.                 if (sbrk != HB_Sentence_Other && sbrk != HB_Sentence_Numeric && sbrk != HB_Sentence_Close) {
    814. 

  814.                     break;
    815. 

  815.                 } else if (sbrk == HB_Sentence_Lower) {
    816. 

  816.                     brk = SB_Initial;
    817. 

  817.                     break;
    818. 

  818.                 }
    819. 

  819.                 ++lookahead;
    820. 

  820.             }
    821. 

  821.             if (brk == SB_Initial) {
    822. 

  822.                 while (i < lookahead)
    823. 

  823.                     attributes[i++].sentenceBoundary = false;
    824. 

  824.             }
    825. 

  825.         }
    826. 

  826.         if (brk == SB_Break) {
    827. 

  827.             attributes[i].sentenceBoundary = true;
    828. 

  828.             brk = sentenceBreakTable[SB_Initial][HB_GetSentenceClass(string[i])];
    829. 

  829.         } else {
    830. 

  830.             attributes[i].sentenceBoundary = false;
    831. 

  831.         }
    832. 

  832.     }
    833. 

  833. }
    834. 

  834. 

  835. 

  836. static inline char *tag_to_string(HB_UInt tag)
    837. 

  837. {
    838. 

  838.     static char string[5];
    839. 

  839.     string[0] = (tag >> 24)&0xff;
    840. 

  840.     string[1] = (tag >> 16)&0xff;
    841. 

  841.     string[2] = (tag >> 8)&0xff;
    842. 

  842.     string[3] = tag&0xff;
    843. 

  843.     string[4] = 0;
    844. 

  844.     return string;
    845. 

  845. }
    846. 

  846. 

  847. #ifdef OT_DEBUG
    848. 

  848. static void dump_string(HB_Buffer buffer)
    849. 

  849. {
    850. 

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

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

  852.     }
    853. 

  853. }
    854. 

  854. #define DEBUG printf
    855. 

  855. #else
    856. 

  856. #define DEBUG if (1) ; else printf
    857. 

  857. #endif
    858. 

  858. 

  859. #define DefaultLangSys 0xffff
    860. 

  860. #define DefaultScript HB_MAKE_TAG('D', 'F', 'L', 'T')
    861. 

  861. 

  862. enum {
    863. 

  863.     RequiresGsub = 1,
    864. 

  864.     RequiresGpos = 2
    865. 

  865. };
    866. 

  866. 

  867. struct OTScripts {
    868. 

  868.     unsigned int tag;
    869. 

  869.     int flags;
    870. 

  870. };
    871. 

  871. static const OTScripts ot_scripts [] = {
    872. 

  872.     // Common
    873. 

  873.     { HB_MAKE_TAG('l', 'a', 't', 'n'), 0 },
    874. 

  874.     // Greek
    875. 

  875.     { HB_MAKE_TAG('g', 'r', 'e', 'k'), 0 },
    876. 

  876.     // Cyrillic
    877. 

  877.     { HB_MAKE_TAG('c', 'y', 'r', 'l'), 0 },
    878. 

  878.     // Armenian
    879. 

  879.     { HB_MAKE_TAG('a', 'r', 'm', 'n'), 0 },
    880. 

  880.     // Hebrew
    881. 

  881.     { HB_MAKE_TAG('h', 'e', 'b', 'r'), 1 },
    882. 

  882.     // Arabic
    883. 

  883.     { HB_MAKE_TAG('a', 'r', 'a', 'b'), 1 },
    884. 

  884.     // Syriac
    885. 

  885.     { HB_MAKE_TAG('s', 'y', 'r', 'c'), 1 },
    886. 

  886.     // Thaana
    887. 

  887.     { HB_MAKE_TAG('t', 'h', 'a', 'a'), 1 },
    888. 

  888.     // Devanagari
    889. 

  889.     { HB_MAKE_TAG('d', 'e', 'v', 'a'), 1 },
    890. 

  890.     // Bengali
    891. 

  891.     { HB_MAKE_TAG('b', 'e', 'n', 'g'), 1 },
    892. 

  892.     // Gurmukhi
    893. 

  893.     { HB_MAKE_TAG('g', 'u', 'r', 'u'), 1 },
    894. 

  894.     // Gujarati
    895. 

  895.     { HB_MAKE_TAG('g', 'u', 'j', 'r'), 1 },
    896. 

  896.     // Oriya
    897. 

  897.     { HB_MAKE_TAG('o', 'r', 'y', 'a'), 1 },
    898. 

  898.     // Tamil
    899. 

  899.     { HB_MAKE_TAG('t', 'a', 'm', 'l'), 1 },
    900. 

  900.     // Telugu
    901. 

  901.     { HB_MAKE_TAG('t', 'e', 'l', 'u'), 1 },
    902. 

  902.     // Kannada
    903. 

  903.     { HB_MAKE_TAG('k', 'n', 'd', 'a'), 1 },
    904. 

  904.     // Malayalam
    905. 

  905.     { HB_MAKE_TAG('m', 'l', 'y', 'm'), 1 },
    906. 

  906.     // Sinhala
    907. 

  907.     { HB_MAKE_TAG('s', 'i', 'n', 'h'), 1 },
    908. 

  908.     // Thai
    909. 

  909.     { HB_MAKE_TAG('t', 'h', 'a', 'i'), 1 },
    910. 

  910.     // Lao
    911. 

  911.     { HB_MAKE_TAG('l', 'a', 'o', ' '), 1 },
    912. 

  912.     // Tibetan
    913. 

  913.     { HB_MAKE_TAG('t', 'i', 'b', 't'), 1 },
    914. 

  914.     // Myanmar
    915. 

  915.     { HB_MAKE_TAG('m', 'y', 'm', 'r'), 1 },
    916. 

  916.     // Georgian
    917. 

  917.     { HB_MAKE_TAG('g', 'e', 'o', 'r'), 0 },
    918. 

  918.     // Hangul
    919. 

  919.     { HB_MAKE_TAG('h', 'a', 'n', 'g'), 1 },
    920. 

  920.     // Ogham
    921. 

  921.     { HB_MAKE_TAG('o', 'g', 'a', 'm'), 0 },
    922. 

  922.     // Runic
    923. 

  923.     { HB_MAKE_TAG('r', 'u', 'n', 'r'), 0 },
    924. 

  924.     // Khmer
    925. 

  925.     { HB_MAKE_TAG('k', 'h', 'm', 'r'), 1 },
    926. 

  926.     // N'Ko
    927. 

  927.     { HB_MAKE_TAG('n', 'k', 'o', ' '), 1 }
    928. 

  928. };
    929. 

  929. enum { NumOTScripts = sizeof(ot_scripts)/sizeof(OTScripts) };
    930. 

  930. 

  931. static HB_Bool checkScript(HB_Face face, int script)
    932. 

  932. {
    933. 

  933.     assert(script < HB_ScriptCount);
    934. 

  934. 

  935.     if (!face->gsub && !face->gpos)
    936. 

  936.         return false;
    937. 

  937. 

  938.     unsigned int tag = ot_scripts[script].tag;
    939. 

  939.     int requirements = ot_scripts[script].flags;
    940. 

  940. 

  941.     if (requirements & RequiresGsub) {
    942. 

  942.         if (!face->gsub)
    943. 

  943.             return false;
    944. 

  944. 

  945.         HB_UShort script_index;
    946. 

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

  947.         if (error) {
    948. 

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

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

  950.             if (error)
    951. 

  951.                 return false;
    952. 

  952.         }
    953. 

  953.     }
    954. 

  954. 

  955.     if (requirements & RequiresGpos) {
    956. 

  956.         if (!face->gpos)
    957. 

  957.             return false;
    958. 

  958. 

  959.         HB_UShort script_index;
    960. 

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

  961.         if (error) {
    962. 

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

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

  964.             if (error)
    965. 

  965.                 return false;
    966. 

  966.         }
    967. 

  967. 

  968.     }
    969. 

  969.     return true;
    970. 

  970. }
    971. 

  971. 

  972. static HB_Stream getTableStream(void *font, HB_GetFontTableFunc tableFunc, HB_Tag tag)
    973. 

  973. {
    974. 

  974.     HB_Error error;
    975. 

  975.     HB_UInt length = 0;
    976. 

  976.     HB_Stream stream = 0;
    977. 

  977. 

  978.     if (!font)
    979. 

  979.         return 0;
    980. 

  980. 

  981.     error = tableFunc(font, tag, 0, &length);
    982. 

  982.     if (error)
    983. 

  983.         return 0;
    984. 

  984.     stream = (HB_Stream)malloc(sizeof(HB_StreamRec));
    985. 

  985.     if (!stream)
    986. 

  986.         return 0;
    987. 

  987.     stream->base = (HB_Byte*)malloc(length);
    988. 

  988.     if (!stream->base) {
    989. 

  989.         free(stream);
    990. 

  990.         return 0;
    991. 

  991.     }
    992. 

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

  993.     if (error) {
    994. 

  994.         _hb_close_stream(stream);
    995. 

  995.         return 0;
    996. 

  996.     }
    997. 

  997.     stream->size = length;
    998. 

  998.     stream->pos = 0;
    999. 

  999.     stream->cursor = NULL;
    1000. 

  1000.     return stream;
    1001. 

  1001. }
    1002. 

  1002. 

  1003. HB_Face HB_NewFace(void *font, HB_GetFontTableFunc tableFunc)
    1004. 

  1004. {
    1005. 

  1005.     HB_Face face = (HB_Face )malloc(sizeof(HB_FaceRec));
    1006. 

  1006.     if (!face)
    1007. 

  1007.         return 0;
    1008. 

  1008. 

  1009.     face->isSymbolFont = false;
    1010. 

  1010.     face->gdef = 0;
    1011. 

  1011.     face->gpos = 0;
    1012. 

  1012.     face->gsub = 0;
    1013. 

  1013.     face->current_script = HB_ScriptCount;
    1014. 

  1014.     face->current_flags = HB_ShaperFlag_Default;
    1015. 

  1015.     face->has_opentype_kerning = false;
    1016. 

  1016.     face->tmpAttributes = 0;
    1017. 

  1017.     face->tmpLogClusters = 0;
    1018. 

  1018.     face->glyphs_substituted = false;
    1019. 

  1019.     face->buffer = 0;
    1020. 

  1020. 

  1021.     HB_Error error = HB_Err_Ok;
    1022. 

  1022.     HB_Stream stream;
    1023. 

  1023.     HB_Stream gdefStream;
    1024. 

  1024. 

  1025.     gdefStream = getTableStream(font, tableFunc, TTAG_GDEF);
    1026. 

  1026.     error = HB_Err_Not_Covered;
    1027. 

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

  1028.         //DEBUG("error loading gdef table: %d", error);
    1029. 

  1029.         face->gdef = 0;
    1030. 

  1030.     }
    1031. 

  1031. 

  1032.     //DEBUG() << "trying to load gsub table";
    1033. 

  1033.     stream = getTableStream(font, tableFunc, TTAG_GSUB);
    1034. 

  1034.     error = HB_Err_Not_Covered;
    1035. 

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

  1036.         face->gsub = 0;
    1037. 

  1037.         if (error != HB_Err_Not_Covered) {
    1038. 

  1038.             //DEBUG("error loading gsub table: %d", error);
    1039. 

  1039.         } else {
    1040. 

  1040.             //DEBUG("face doesn't have a gsub table");
    1041. 

  1041.         }
    1042. 

  1042.     }
    1043. 

  1043.     _hb_close_stream(stream);
    1044. 

  1044. 

  1045.     stream = getTableStream(font, tableFunc, TTAG_GPOS);
    1046. 

  1046.     error = HB_Err_Not_Covered;
    1047. 

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

  1048.         face->gpos = 0;
    1049. 

  1049.         DEBUG("error loading gpos table: %d", error);
    1050. 

  1050.     }
    1051. 

  1051.     _hb_close_stream(stream);
    1052. 

  1052. 

  1053.     _hb_close_stream(gdefStream);
    1054. 

  1054. 

  1055.     for (unsigned int i = 0; i < HB_ScriptCount; ++i)
    1056. 

  1056.         face->supported_scripts[i] = checkScript(face, i);
    1057. 

  1057. 

  1058.     if (hb_buffer_new(&face->buffer) != HB_Err_Ok) {
    1059. 

  1059.         HB_FreeFace(face);
    1060. 

  1060.         return 0;
    1061. 

  1061.     }
    1062. 

  1062. 

  1063.     return face;
    1064. 

  1064. }
    1065. 

  1065. 

  1066. void HB_FreeFace(HB_Face face)
    1067. 

  1067. {
    1068. 

  1068.     if (!face)
    1069. 

  1069.         return;
    1070. 

  1070.     if (face->gpos)
    1071. 

  1071.         HB_Done_GPOS_Table(face->gpos);
    1072. 

  1072.     if (face->gsub)
    1073. 

  1073.         HB_Done_GSUB_Table(face->gsub);
    1074. 

  1074.     if (face->gdef)
    1075. 

  1075.         HB_Done_GDEF_Table(face->gdef);
    1076. 

  1076.     if (face->buffer)
    1077. 

  1077.         hb_buffer_free(face->buffer);
    1078. 

  1078.     if (face->tmpAttributes)
    1079. 

  1079.         free(face->tmpAttributes);
    1080. 

  1080.     if (face->tmpLogClusters)
    1081. 

  1081.         free(face->tmpLogClusters);
    1082. 

  1082.     free(face);
    1083. 

  1083. }
    1084. 

  1084. 

  1085. HB_Bool HB_SelectScript(HB_ShaperItem *shaper_item, const HB_OpenTypeFeature *features)
    1086. 

  1086. {
    1087. 

  1087.     HB_Script script = shaper_item->item.script;
    1088. 

  1088. 

  1089.     HB_Face face = shaper_item->face;
    1090. 

  1090.     if (face->current_script == script && face->current_flags == shaper_item->shaperFlags)
    1091. 

  1091.         return shaper_item->face->supported_scripts[script] ? true : false;
    1092. 

  1092. 

  1093.     face->current_script = script;
    1094. 

  1094.     face->current_flags = shaper_item->shaperFlags;
    1095. 

  1095. 

  1096.     if (!shaper_item->face->supported_scripts[script])
    1097. 

  1097.         return false;
    1098. 

  1098. 

  1099.     assert(script < HB_ScriptCount);
    1100. 

  1100.     // find script in our list of supported scripts.
    1101. 

  1101.     unsigned int tag = ot_scripts[script].tag;
    1102. 

  1102. 

  1103.     if (face->gsub && features) {
    1104. 

  1104. #ifdef OT_DEBUG
    1105. 

  1105.         {
    1106. 

  1106.             HB_FeatureList featurelist = face->gsub->FeatureList;
    1107. 

  1107.             int numfeatures = featurelist.FeatureCount;
    1108. 

  1108.             DEBUG("gsub table has %d features", numfeatures);
    1109. 

  1109.             for (int i = 0; i < numfeatures; i++) {
    1110. 

  1110.                 HB_FeatureRecord *r = featurelist.FeatureRecord + i;
    1111. 

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

  1112.             }
    1113. 

  1113.         }
    1114. 

  1114. #endif
    1115. 

  1115.         HB_GSUB_Clear_Features(face->gsub);
    1116. 

  1116.         HB_UShort script_index;
    1117. 

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

  1118.         if (!error) {
    1119. 

  1119.             DEBUG("script %s has script index %d", tag_to_string(script), script_index);
    1120. 

  1120.             while (features->tag) {
    1121. 

  1121.                 HB_UShort feature_index;
    1122. 

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

  1123.                 if (!error) {
    1124. 

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

  1125.                     HB_GSUB_Add_Feature(face->gsub, feature_index, features->property);
    1126. 

  1126.                 }
    1127. 

  1127.                 ++features;
    1128. 

  1128.             }
    1129. 

  1129.         }
    1130. 

  1130.     }
    1131. 

  1131. 

  1132.     // reset
    1133. 

  1133.     face->has_opentype_kerning = false;
    1134. 

  1134. 

  1135.     if (face->gpos) {
    1136. 

  1136.         HB_GPOS_Clear_Features(face->gpos);
    1137. 

  1137.         HB_UShort script_index;
    1138. 

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

  1139.         if (!error) {
    1140. 

  1140. #ifdef OT_DEBUG
    1141. 

  1141.             {
    1142. 

  1142.                 HB_FeatureList featurelist = face->gpos->FeatureList;
    1143. 

  1143.                 int numfeatures = featurelist.FeatureCount;
    1144. 

  1144.                 DEBUG("gpos table has %d features", numfeatures);
    1145. 

  1145.                 for(int i = 0; i < numfeatures; i++) {
    1146. 

  1146.                     HB_FeatureRecord *r = featurelist.FeatureRecord + i;
    1147. 

  1147.                     HB_UShort feature_index;
    1148. 

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

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

  1150.                 }
    1151. 

  1151.             }
    1152. 

  1152. #endif
    1153. 

  1153.             HB_UInt *feature_tag_list_buffer;
    1154. 

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

  1155.             if (!error) {
    1156. 

  1156.                 HB_UInt *feature_tag_list = feature_tag_list_buffer;
    1157. 

  1157.                 while (*feature_tag_list) {
    1158. 

  1158.                     HB_UShort feature_index;
    1159. 

  1159.                     bool skip = false;
    1160. 

  1160.                     if (*feature_tag_list == HB_MAKE_TAG('k', 'e', 'r', 'n')) {
    1161. 

  1161.                         if (face->current_flags & HB_ShaperFlag_NoKerning)
    1162. 

  1162.                             skip = true;
    1163. 

  1163.                         else
    1164. 

  1164.                             face->has_opentype_kerning = true;
    1165. 

  1165.                     }
    1166. 

  1166.                     features = disabled_features;
    1167. 

  1167.                     while (features->tag) {
    1168. 

  1168.                         if (*feature_tag_list == features->tag) {
    1169. 

  1169.                             skip = true;
    1170. 

  1170.                             break;
    1171. 

  1171.                         }
    1172. 

  1172.                         ++features;
    1173. 

  1173.                     }
    1174. 

  1174.                     // 'palt' should be turned off by default unless 'kern' is on
    1175. 

  1175.                     if (!face->has_opentype_kerning &&
    1176. 

  1176.                         *feature_tag_list == HB_MAKE_TAG('p', 'a', 'l', 't'))
    1177. 

  1177.                         skip = true;
    1178. 

  1178. 

  1179.                     if (skip) {
    1180. 

  1180.                         ++feature_tag_list;
    1181. 

  1181.                         continue;
    1182. 

  1182.                     }
    1183. 

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

  1184.                     if (!error)
    1185. 

  1185.                         HB_GPOS_Add_Feature(face->gpos, feature_index, PositioningProperties);
    1186. 

  1186.                     ++feature_tag_list;
    1187. 

  1187.                 }
    1188. 

  1188.                 FREE(feature_tag_list_buffer);
    1189. 

  1189.             }
    1190. 

  1190.         }
    1191. 

  1191.     }
    1192. 

  1192. 

  1193.     return true;
    1194. 

  1194. }
    1195. 

  1195. 

  1196. HB_Bool HB_OpenTypeShape(HB_ShaperItem *item, const hb_uint32 *properties)
    1197. 

  1197. {
    1198. 

  1198.     HB_GlyphAttributes *tmpAttributes;
    1199. 

  1199.     unsigned int *tmpLogClusters;
    1200. 

  1200. 

  1201.     HB_Face face = item->face;
    1202. 

  1202. 

  1203.     face->length = item->num_glyphs;
    1204. 

  1204. 

  1205.     hb_buffer_clear(face->buffer);
    1206. 

  1206. 

  1207.     tmpAttributes = (HB_GlyphAttributes *) realloc(face->tmpAttributes, face->length*sizeof(HB_GlyphAttributes));
    1208. 

  1208.     if (!tmpAttributes)
    1209. 

  1209.         return false;
    1210. 

  1210.     face->tmpAttributes = tmpAttributes;
    1211. 

  1211. 

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

  1213.     if (!tmpLogClusters)
    1214. 

  1214.         return false;
    1215. 

  1215.     face->tmpLogClusters = tmpLogClusters;
    1216. 

  1216. 

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

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

  1219.         face->tmpAttributes[i] = item->attributes[i];
    1220. 

  1220.         face->tmpLogClusters[i] = item->log_clusters[i];
    1221. 

  1221.     }
    1222. 

  1222. 

  1223. #ifdef OT_DEBUG
    1224. 

  1224.     DEBUG("-----------------------------------------");
    1225. 

  1225. //     DEBUG("log clusters before shaping:");
    1226. 

  1226. //     for (int j = 0; j < length; j++)
    1227. 

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

  1228.     DEBUG("original glyphs: %p", item->glyphs);
    1229. 

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

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

  1231. //     dump_string(hb_buffer);
    1232. 

  1232. #endif
    1233. 

  1233. 

  1234.     face->glyphs_substituted = false;
    1235. 

  1235.     if (face->gsub) {
    1236. 

  1236.         unsigned int error = HB_GSUB_Apply_String(face->gsub, face->buffer);
    1237. 

  1237.         if (error && error != HB_Err_Not_Covered)
    1238. 

  1238.             return false;
    1239. 

  1239.         face->glyphs_substituted = (error != HB_Err_Not_Covered);
    1240. 

  1240.     }
    1241. 

  1241. 

  1242. #ifdef OT_DEBUG
    1243. 

  1243. //     DEBUG("log clusters before shaping:");
    1244. 

  1244. //     for (int j = 0; j < length; j++)
    1245. 

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

  1246.     DEBUG("shaped glyphs:");
    1247. 

  1247.     for (int i = 0; i < length; ++i)
    1248. 

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

  1249.     DEBUG("-----------------------------------------");
    1250. 

  1250. //     dump_string(hb_buffer);
    1251. 

  1251. #endif
    1252. 

  1252. 

  1253.     return true;
    1254. 

  1254. }
    1255. 

  1255. 

  1256. HB_Bool HB_OpenTypePosition(HB_ShaperItem *item, int availableGlyphs, HB_Bool doLogClusters)
    1257. 

  1257. {
    1258. 

  1258.     HB_Face face = item->face;
    1259. 

  1259. 

  1260.     bool glyphs_positioned = false;
    1261. 

  1261.     if (face->gpos) {
    1262. 

  1262.         if (face->buffer->positions)
    1263. 

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

  1264.         // #### check that passing "false,false" is correct
    1265. 

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

  1266.     }
    1267. 

  1267. 

  1268.     if (!face->glyphs_substituted && !glyphs_positioned) {
    1269. 

  1269.         HB_HeuristicPosition(item);
    1270. 

  1270.         return true; // nothing to do for us
    1271. 

  1271.     }
    1272. 

  1272. 

  1273.     // make sure we have enough space to write everything back
    1274. 

  1274.     if (availableGlyphs < (int)face->buffer->in_length) {
    1275. 

  1275.         item->num_glyphs = face->buffer->in_length;
    1276. 

  1276.         return false;
    1277. 

  1277.     }
    1278. 

  1278. 

  1279.     HB_Glyph *glyphs = item->glyphs;
    1280. 

  1280.     HB_GlyphAttributes *attributes = item->attributes;
    1281. 

  1281. 

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

  1283.         glyphs[i] = face->buffer->in_string[i].gindex;
    1284. 

  1284.         attributes[i] = face->tmpAttributes[face->buffer->in_string[i].cluster];
    1285. 

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

  1286.             attributes[i].clusterStart = false; //FIXME - Shouldn't we otherwise set this to true, rather than leaving it?
    1287. 

  1287.     }
    1288. 

  1288.     item->num_glyphs = face->buffer->in_length;
    1289. 

  1289. 

  1290.     if (doLogClusters && face->glyphs_substituted) {
    1291. 

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

  1292.         // #### the reconstruction of the logclusters currently does not work if the or…
    1293.

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