gfx/graphite2/src/Segment.cpp

   1 /*  GRAPHITE2 LICENSING
   2
   3     Copyright 2010, SIL International
   4     All rights reserved.
   5
   6     This library is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU Lesser General Public License as published
   8     by the Free Software Foundation; either version 2.1 of License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14     Lesser General Public License for more details.
  15
  16     You should also have received a copy of the GNU Lesser General Public
  17     License along with this library in the file named "LICENSE".
  18     If not, write to the Free Software Foundation, 51 Franklin Street,
  19     Suite 500, Boston, MA 02110-1335, USA or visit their web page on the
  20     internet at http://www.fsf.org/licenses/lgpl.html.
  21
  22 Alternatively, the contents of this file may be used under the terms of the
  23 Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public
  24 License, as published by the Free Software Foundation, either version 2
  25 of the License or (at your option) any later version.
  26 */
  27 #include "inc/UtfCodec.h"
  28 #include <cstring>
  29 #include <cstdlib>
  30
  31 #include "inc/bits.h"
  32 #include "inc/Segment.h"
  33 #include "graphite2/Font.h"
  34 #include "inc/CharInfo.h"
  35 #include "inc/debug.h"
  36 #include "inc/Slot.h"
  37 #include "inc/Main.h"
  38 #include "inc/CmapCache.h"
  39 #include "inc/Collider.h"
  40 #include "graphite2/Segment.h"
  41
  42
  43 using namespace graphite2;
  44
  45 Segment::Segment(size_t numchars, const Face* face, uint32 script, int textDir)
  46 : m_freeSlots(NULL),
  47   m_freeJustifies(NULL),
  48   m_charinfo(new CharInfo[numchars]),
  49   m_collisions(NULL),
  50   m_face(face),
  51   m_silf(face->chooseSilf(script)),
  52   m_first(NULL),
  53   m_last(NULL),
  54   m_bufSize(numchars + 10),
  55   m_numGlyphs(numchars),
  56   m_numCharinfo(numchars),
  57   m_defaultOriginal(0),
  58   m_dir(textDir),
  59   m_flags(((m_silf->flags() & 0x20) != 0) << 1),
  60   m_passBits(m_silf->aPassBits() ? -1 : 0)
  61 {
  62     freeSlot(newSlot());
  63     m_bufSize = log_binary(numchars)+1;
  64 }
  65
  66 Segment::~Segment()
  67 {
  68     for (SlotRope::iterator i = m_slots.begin(); i != m_slots.end(); ++i)
  69         free(*i);
  70     for (AttributeRope::iterator i = m_userAttrs.begin(); i != m_userAttrs.end(); ++i)
  71         free(*i);
  72     for (JustifyRope::iterator i = m_justifies.begin(); i != m_justifies.end(); ++i)
  73         free(*i);
  74     delete[] m_charinfo;
  75     free(m_collisions);
  76 }
  77
  78 void Segment::appendSlot(int id, int cid, int gid, int iFeats, size_t coffset)
  79 {
  80     Slot *aSlot = newSlot();
  81
  82     if (!aSlot) return;
  83     m_charinfo[id].init(cid);
  84     m_charinfo[id].feats(iFeats);
  85     m_charinfo[id].base(coffset);
  86     const GlyphFace * theGlyph = m_face->glyphs().glyphSafe(gid);
  87     m_charinfo[id].breakWeight(theGlyph ? theGlyph->attrs()[m_silf->aBreak()] : 0);
  88
  89     aSlot->child(NULL);
  90     aSlot->setGlyph(this, gid, theGlyph);
  91     aSlot->originate(id);
  92     aSlot->before(id);
  93     aSlot->after(id);
  94     if (m_last) m_last->next(aSlot);
  95     aSlot->prev(m_last);
  96     m_last = aSlot;
  97     if (!m_first) m_first = aSlot;
  98     if (theGlyph && m_silf->aPassBits())
  99         m_passBits &= theGlyph->attrs()[m_silf->aPassBits()]
 100                     | (m_silf->numPasses() > 16 ? (theGlyph->attrs()[m_silf->aPassBits() + 1] << 16) : 0);
 101 }
 102
 103 Slot *Segment::newSlot()
 104 {
 105     if (!m_freeSlots)
 106     {
 107         // check that the segment doesn't grow indefinintely
 108         if (m_numGlyphs > m_numCharinfo * MAX_SEG_GROWTH_FACTOR)
 109             return NULL;
 110         int numUser = m_silf->numUser();
 111 #if !defined GRAPHITE2_NTRACING
 112         if (m_face->logger()) ++numUser;
 113 #endif
 114         Slot *newSlots = grzeroalloc<Slot>(m_bufSize);
 115         int16 *newAttrs = grzeroalloc<int16>(m_bufSize * numUser);
 116         if (!newSlots || !newAttrs)
 117         {
 118             free(newSlots);
 119             free(newAttrs);
 120             return NULL;
 121         }
 122         for (size_t i = 0; i < m_bufSize; i++)
 123         {
 124             ::new (newSlots + i) Slot(newAttrs + i * numUser);
 125             newSlots[i].next(newSlots + i + 1);
 126         }
 127         newSlots[m_bufSize - 1].next(NULL);
 128         newSlots[0].next(NULL);
 129         m_slots.push_back(newSlots);
 130         m_userAttrs.push_back(newAttrs);
 131         m_freeSlots = (m_bufSize > 1)? newSlots + 1 : NULL;
 132         return newSlots;
 133     }
 134     Slot *res = m_freeSlots;
 135     m_freeSlots = m_freeSlots->next();
 136     res->next(NULL);
 137     return res;
 138 }
 139
 140 void Segment::freeSlot(Slot *aSlot)
 141 {
 142     if (aSlot == nullptr) return;
 143     if (m_last == aSlot) m_last = aSlot->prev();
 144     if (m_first == aSlot) m_first = aSlot->next();
 145     if (aSlot->attachedTo())
 146         aSlot->attachedTo()->removeChild(aSlot);
 147     while (aSlot->firstChild())
 148     {
 149         if (aSlot->firstChild()->attachedTo() == aSlot)
 150         {
 151             aSlot->firstChild()->attachTo(nullptr);
 152             aSlot->removeChild(aSlot->firstChild());
 153         }
 154         else
 155             aSlot->firstChild(nullptr);
 156     }
 157     // reset the slot incase it is reused
 158     ::new (aSlot) Slot(aSlot->userAttrs());
 159     memset(aSlot->userAttrs(), 0, m_silf->numUser() * sizeof(int16));
 160     // Update generation counter for debug
 161 #if !defined GRAPHITE2_NTRACING
 162     if (m_face->logger())
 163         ++aSlot->userAttrs()[m_silf->numUser()];
 164 #endif
 165     // update next pointer
 166     if (!m_freeSlots)
 167         aSlot->next(nullptr);
 168     else
 169         aSlot->next(m_freeSlots);
 170     m_freeSlots = aSlot;
 171 }
 172
 173 SlotJustify *Segment::newJustify()
 174 {
 175     if (!m_freeJustifies)
 176     {
 177         const size_t justSize = SlotJustify::size_of(m_silf->numJustLevels());
 178         byte *justs = grzeroalloc<byte>(justSize * m_bufSize);
 179         if (!justs) return NULL;
 180         for (ptrdiff_t i = m_bufSize - 2; i >= 0; --i)
 181         {
 182             SlotJustify *p = reinterpret_cast<SlotJustify *>(justs + justSize * i);
 183             SlotJustify *next = reinterpret_cast<SlotJustify *>(justs + justSize * (i + 1));
 184             p->next = next;
 185         }
 186         m_freeJustifies = (SlotJustify *)justs;
 187         m_justifies.push_back(m_freeJustifies);
 188     }
 189     SlotJustify *res = m_freeJustifies;
 190     m_freeJustifies = m_freeJustifies->next;
 191     res->next = NULL;
 192     return res;
 193 }
 194
 195 void Segment::freeJustify(SlotJustify *aJustify)
 196 {
 197     int numJust = m_silf->numJustLevels();
 198     if (m_silf->numJustLevels() <= 0) numJust = 1;
 199     aJustify->next = m_freeJustifies;
 200     memset(aJustify->values, 0, numJust*SlotJustify::NUMJUSTPARAMS*sizeof(int16));
 201     m_freeJustifies = aJustify;
 202 }
 203
 204 // reverse the slots but keep diacritics in their same position after their bases
 205 void Segment::reverseSlots()
 206 {
 207     m_dir = m_dir ^ 64;                 // invert the reverse flag
 208     if (m_first == m_last) return;      // skip 0 or 1 glyph runs
 209
 210     Slot *t = 0;
 211     Slot *curr = m_first;
 212     Slot *tlast;
 213     Slot *tfirst;
 214     Slot *out = 0;
 215
 216     while (curr && getSlotBidiClass(curr) == 16)
 217         curr = curr->next();
 218     if (!curr) return;
 219     tfirst = curr->prev();
 220     tlast = curr;
 221
 222     while (curr)
 223     {
 224         if (getSlotBidiClass(curr) == 16)
 225         {
 226             Slot *d = curr->next();
 227             while (d && getSlotBidiClass(d) == 16)
 228                 d = d->next();
 229
 230             d = d ? d->prev() : m_last;
 231             Slot *p = out->next();    // one after the diacritics. out can't be null
 232             if (p)
 233                 p->prev(d);
 234             else
 235                 tlast = d;
 236             t = d->next();
 237             d->next(p);
 238             curr->prev(out);
 239             out->next(curr);
 240         }
 241         else    // will always fire first time round the loop
 242         {
 243             if (out)
 244                 out->prev(curr);
 245             t = curr->next();
 246             curr->next(out);
 247             out = curr;
 248         }
 249         curr = t;
 250     }
 251     out->prev(tfirst);
 252     if (tfirst)
 253         tfirst->next(out);
 254     else
 255         m_first = out;
 256     m_last = tlast;
 257 }
 258
 259 void Segment::linkClusters(Slot *s, Slot * end)
 260 {
 261     end = end->next();
 262
 263     for (; s != end && !s->isBase(); s = s->next());
 264     Slot * ls = s;
 265
 266     if (m_dir & 1)
 267     {
 268         for (; s != end; s = s->next())
 269         {
 270             if (!s->isBase())   continue;
 271
 272             s->sibling(ls);
 273             ls = s;
 274         }
 275     }
 276     else
 277     {
 278         for (; s != end; s = s->next())
 279         {
 280             if (!s->isBase())   continue;
 281
 282             ls->sibling(s);
 283             ls = s;
 284         }
 285     }
 286 }
 287
 288 Position Segment::positionSlots(const Font *font, Slot * iStart, Slot * iEnd, bool isRtl, bool isFinal)
 289 {
 290     Position currpos(0., 0.);
 291     float clusterMin = 0.;
 292     Rect bbox;
 293     bool reorder = (currdir() != isRtl);
 294
 295     if (reorder)
 296     {
 297         Slot *temp;
 298         reverseSlots();
 299         temp = iStart;
 300         iStart = iEnd;
 301         iEnd = temp;
 302     }
 303     if (!iStart)    iStart = m_first;
 304     if (!iEnd)      iEnd   = m_last;
 305
 306     if (!iStart || !iEnd)   // only true for empty segments
 307         return currpos;
 308
 309     if (isRtl)
 310     {
 311         for (Slot * s = iEnd, * const end = iStart->prev(); s && s != end; s = s->prev())
 312         {
 313             if (s->isBase())
 314                 currpos = s->finalise(this, font, currpos, bbox, 0, clusterMin = currpos.x, isRtl, isFinal);
 315         }
 316     }
 317     else
 318     {
 319         for (Slot * s = iStart, * const end = iEnd->next(); s && s != end; s = s->next())
 320         {
 321             if (s->isBase())
 322                 currpos = s->finalise(this, font, currpos, bbox, 0, clusterMin = currpos.x, isRtl, isFinal);
 323         }
 324     }
 325     if (reorder)
 326         reverseSlots();
 327     return currpos;
 328 }
 329
 330
 331 void Segment::associateChars(int offset, size_t numChars)
 332 {
 333     int i = 0, j = 0;
 334     CharInfo *c, *cend;
 335     for (c = m_charinfo + offset, cend = m_charinfo + offset + numChars; c != cend; ++c)
 336     {
 337         c->before(-1);
 338         c->after(-1);
 339     }
 340     for (Slot * s = m_first; s; s->index(i++), s = s->next())
 341     {
 342         j = s->before();
 343         if (j < 0)  continue;
 344
 345         for (const int after = s->after(); j <= after; ++j)
 346         {
 347             c = charinfo(j);
 348             if (c->before() == -1 || i < c->before())   c->before(i);
 349             if (c->after() < i)                         c->after(i);
 350         }
 351     }
 352     for (Slot *s = m_first; s; s = s->next())
 353     {
 354         int a;
 355         for (a = s->after() + 1; a < offset + int(numChars) && charinfo(a)->after() < 0; ++a)
 356         { charinfo(a)->after(s->index()); }
 357         --a;
 358         s->after(a);
 359
 360         for (a = s->before() - 1; a >= offset && charinfo(a)->before() < 0; --a)
 361         { charinfo(a)->before(s->index()); }
 362         ++a;
 363         s->before(a);
 364     }
 365 }
 366
 367
 368 template <typename utf_iter>
 369 inline void process_utf_data(Segment & seg, const Face & face, const int fid, utf_iter c, size_t n_chars)
 370 {
 371     const Cmap    & cmap = face.cmap();
 372     int slotid = 0;
 373
 374     const typename utf_iter::codeunit_type * const base = c;
 375     for (; n_chars; --n_chars, ++c, ++slotid)
 376     {
 377         const uint32 usv = *c;
 378         uint16 gid = cmap[usv];
 379         if (!gid)   gid = face.findPseudo(usv);
 380         seg.appendSlot(slotid, usv, gid, fid, c - base);
 381     }
 382 }
 383
 384
 385 bool Segment::read_text(const Face *face, const Features* pFeats/*must not be NULL*/, gr_encform enc, const void* pStart, size_t nChars)
 386 {
 387     assert(face);
 388     assert(pFeats);
 389     if (!m_charinfo) return false;
 390
 391     // utf iterator is self recovering so we don't care about the error state of the iterator.
 392     switch (enc)
 393     {
 394     case gr_utf8:   process_utf_data(*this, *face, addFeatures(*pFeats), utf8::const_iterator(pStart), nChars); break;
 395     case gr_utf16:  process_utf_data(*this, *face, addFeatures(*pFeats), utf16::const_iterator(pStart), nChars); break;
 396     case gr_utf32:  process_utf_data(*this, *face, addFeatures(*pFeats), utf32::const_iterator(pStart), nChars); break;
 397     }
 398     return true;
 399 }
 400
 401 void Segment::doMirror(uint16 aMirror)
 402 {
 403     Slot * s;
 404     for (s = m_first; s; s = s->next())
 405     {
 406         unsigned short g = glyphAttr(s->gid(), aMirror);
 407         if (g && (!(dir() & 4) || !glyphAttr(s->gid(), aMirror + 1)))
 408             s->setGlyph(this, g);
 409     }
 410 }
 411
 412 bool Segment::initCollisions()
 413 {
 414     m_collisions = grzeroalloc<SlotCollision>(slotCount());
 415     if (!m_collisions) return false;
 416
 417     for (Slot *p = m_first; p; p = p->next())
 418         if (p->index() < slotCount())
 419             ::new (collisionInfo(p)) SlotCollision(this, p);
 420         else
 421             return false;
 422     return true;
 423 }