The Tor Browser: gfx/graphite2/src/Slot.cpp@b8a032363ba2 (annotated)

gfx/graphite2/src/Slot.cpp@b8a032363ba2 (annotated)

gfx/graphite2/src/Slot.cpp

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /*  GRAPHITE2 LICENSING
     Copyright 2010, SIL International
     All rights reserved.
     This library is free software; you can redistribute it and/or modify
     it under the terms of the GNU Lesser General Public License as published
     by the Free Software Foundation; either version 2.1 of License, or
     (at your option) any later version.
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Lesser General Public License for more details.
     You should also have received a copy of the GNU Lesser General Public
     License along with this library in the file named "LICENSE".
     If not, write to the Free Software Foundation, 51 Franklin Street,
     Suite 500, Boston, MA 02110-1335, USA or visit their web page on the
     internet at http://www.fsf.org/licenses/lgpl.html.
 Alternatively, the contents of this file may be used under the terms of the
 Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public
 License, as published by the Free Software Foundation, either version 2
 of the License or (at your option) any later version.
 */
 #include "inc/Segment.h"
 #include "inc/Slot.h"
 #include "inc/Silf.h"
 #include "inc/CharInfo.h"
 #include "inc/Rule.h"
 using namespace graphite2;
 Slot::Slot() :
     m_next(NULL), m_prev(NULL),
     m_glyphid(0), m_realglyphid(0), m_original(0), m_before(0), m_after(0),
     m_index(0), m_parent(NULL), m_child(NULL), m_sibling(NULL),
     m_position(0, 0), m_shift(0, 0), m_advance(0, 0),
     m_attach(0, 0), m_with(0, 0), m_just(0.),
     m_flags(0), m_attLevel(0), m_bidiCls(-1), m_bidiLevel(0), m_justs(NULL)
     // Do not set m_userAttr since it is set *before* new is called since this
     // is used as a positional new to reset the GrSlot
 {
 }
 // take care, this does not copy any of the GrSlot pointer fields
 void Slot::set(const Slot & orig, int charOffset, size_t numUserAttr, size_t justLevels, size_t numChars)
 {
     // leave m_next and m_prev unchanged
     m_glyphid = orig.m_glyphid;
     m_realglyphid = orig.m_realglyphid;
     m_original = orig.m_original + charOffset;
     if (charOffset + int(orig.m_before) < 0)
         m_before = 0;
     else
         m_before = orig.m_before + charOffset;
     if (charOffset <= 0 && orig.m_after + charOffset >= numChars)
         m_after = numChars - 1;
     else
         m_after = orig.m_after + charOffset;
     m_parent = NULL;
     m_child = NULL;
     m_sibling = NULL;
     m_position = orig.m_position;
     m_shift = orig.m_shift;
     m_advance = orig.m_advance;
     m_attach = orig.m_attach;
     m_with = orig.m_with;
     m_flags = orig.m_flags;
     m_attLevel = orig.m_attLevel;
     m_bidiCls = orig.m_bidiCls;
     m_bidiLevel = orig.m_bidiLevel;
     if (m_userAttr && orig.m_userAttr)
         memcpy(m_userAttr, orig.m_userAttr, numUserAttr * sizeof(*m_userAttr));
     if (m_justs && orig.m_justs)
         memcpy(m_justs, orig.m_justs, SlotJustify::size_of(justLevels));
 }
 void Slot::update(int /*numGrSlots*/, int numCharInfo, Position &relpos)
 {
     m_before += numCharInfo;
     m_after += numCharInfo;
     m_position = m_position + relpos;
 }
 Position Slot::finalise(const Segment *seg, const Font *font, Position & base, Rect & bbox, uint8 attrLevel, float & clusterMin)
 {
     if (attrLevel && m_attLevel > attrLevel) return Position(0, 0);
     float scale = 1.0;
     Position shift(m_shift.x * ((seg->dir() & 1) * -2 + 1) + m_just, m_shift.y);
     float tAdvance = m_advance.x + m_just;
     const GlyphFace * glyphFace = seg->getFace()->glyphs().glyphSafe(glyph());
     if (font)
     {
         scale = font->scale();
         shift *= scale;
         if (font->isHinted() && glyphFace)
             tAdvance = (m_advance.x - glyphFace->theAdvance().x + m_just) * scale + font->advance(m_glyphid);
         else
             tAdvance *= scale;
     }
     Position res;
     m_position = base + shift;
     if (!m_parent)
     {
         res = base + Position(tAdvance, m_advance.y * scale);
         clusterMin = base.x;
     }
     else
     {
         float tAdv;
         m_position += (m_attach - m_with) * scale;
         tAdv = m_advance.x >= 0.5 ? m_position.x + tAdvance - shift.x : 0.f;
         res = Position(tAdv, 0);
         if ((m_advance.x >= 0.5 || m_position.x < 0) && m_position.x < clusterMin) clusterMin = m_position.x;
     }
     if (glyphFace)
     {
         Rect ourBbox = glyphFace->theBBox() * scale + m_position;
         bbox = bbox.widen(ourBbox);
     }
     if (m_child && m_child != this && m_child->attachedTo() == this)
     {
         Position tRes = m_child->finalise(seg, font, m_position, bbox, attrLevel, clusterMin);
         if ((!m_parent || m_advance.x >= 0.5) && tRes.x > res.x) res = tRes;
     }
     if (m_parent && m_sibling && m_sibling != this && m_sibling->attachedTo() == m_parent)
     {
         Position tRes = m_sibling->finalise(seg, font, base, bbox, attrLevel, clusterMin);
         if (tRes.x > res.x) res = tRes;
     }
     if (!m_parent && clusterMin < base.x)
     {
         Position adj = Position(base.x - clusterMin, 0.);
         res += adj;
         m_position += adj;
         if (m_child) m_child->floodShift(adj);
     }
     return res;
 }
 int32 Slot::clusterMetric(const Segment *seg, uint8 metric, uint8 attrLevel)
 {
     Position base;
     Rect bbox = seg->theGlyphBBoxTemporary(glyph());
     float clusterMin = 0.;
     Position res = finalise(seg, NULL, base, bbox, attrLevel, clusterMin);
     switch (metrics(metric))
     {
     case kgmetLsb :
         return static_cast<uint32>(bbox.bl.x);
     case kgmetRsb :
         return static_cast<uint32>(res.x - bbox.tr.x);
     case kgmetBbTop :
         return static_cast<uint32>(bbox.tr.y);
     case kgmetBbBottom :
         return static_cast<uint32>(bbox.bl.y);
     case kgmetBbLeft :
         return static_cast<uint32>(bbox.bl.x);
     case kgmetBbRight :
         return static_cast<uint32>(bbox.tr.x);
     case kgmetBbWidth :
         return static_cast<uint32>(bbox.tr.x - bbox.bl.x);
     case kgmetBbHeight :
         return static_cast<uint32>(bbox.tr.y - bbox.bl.y);
     case kgmetAdvWidth :
         return static_cast<uint32>(res.x);
     case kgmetAdvHeight :
         return static_cast<uint32>(res.y);
     default :
         return 0;
     }
 }
 int Slot::getAttr(const Segment *seg, attrCode ind, uint8 subindex) const
 {
     if (!this) return 0;
     if (ind == gr_slatUserDefnV1)
     {
         ind = gr_slatUserDefn;
         subindex = 0;
     }
     else if (ind >= gr_slatJStretch && ind < gr_slatJStretch + 20 && ind != gr_slatJWidth)
     {
         int indx = ind - gr_slatJStretch;
         return getJustify(seg, indx / 5, indx % 5);
     }
     switch (ind)
     {
     case gr_slatAdvX :      return int(m_advance.x);
     case gr_slatAdvY :      return int(m_advance.y);
     case gr_slatAttTo :     return m_parent ? 1 : 0;
     case gr_slatAttX :      return int(m_attach.x);
     case gr_slatAttY :      return int(m_attach.y);
     case gr_slatAttXOff :
     case gr_slatAttYOff :   return 0;
     case gr_slatAttWithX :  return int(m_with.x);
     case gr_slatAttWithY :  return int(m_with.y);
     case gr_slatAttWithXOff:
     case gr_slatAttWithYOff:return 0;
     case gr_slatAttLevel :  return m_attLevel;
     case gr_slatBreak :     return seg->charinfo(m_original)->breakWeight();
     case gr_slatCompRef :   return 0;
     case gr_slatDir :       if (m_bidiCls == -1)
                                 const_cast<Slot *>(this)->setBidiClass(seg->glyphAttr(gid(), seg->silf()->aBidi()));
                             return m_bidiCls;
     case gr_slatInsert :    return isInsertBefore();
     case gr_slatPosX :      return int(m_position.x); // but need to calculate it
     case gr_slatPosY :      return int(m_position.y);
     case gr_slatShiftX :    return int(m_shift.x);
     case gr_slatShiftY :    return int(m_shift.y);
     case gr_slatMeasureSol: return -1; // err what's this?
     case gr_slatMeasureEol: return -1;
     case gr_slatJWidth:     return int(m_just);
     case gr_slatUserDefn :  return m_userAttr[subindex];
     case gr_slatSegSplit :  return seg->charinfo(m_original)->flags() & 3;
     case gr_slatBidiLevel:  return m_bidiLevel;
     default :               return 0;
     }
 }
 void Slot::setAttr(Segment *seg, attrCode ind, uint8 subindex, int16 value, const SlotMap & map)
 {
     if (!this) return;
     if (ind == gr_slatUserDefnV1)
     {
         ind = gr_slatUserDefn;
         subindex = 0;
     }
     else if (ind >= gr_slatJStretch && ind < gr_slatJStretch + 20 && ind != gr_slatJWidth)
     {
         int indx = ind - gr_slatJStretch;
         return setJustify(seg, indx / 5, indx % 5, value);
     }
     switch (ind)
     {
     case gr_slatAdvX :  m_advance.x = value; break;
     case gr_slatAdvY :  m_advance.y = value; break;
     case gr_slatAttTo :
     {
         const uint16 idx = uint16(value);
         if (idx < map.size() && map[idx])
         {
             Slot *other = map[idx];
             if (other == this) break;
             if (m_parent) m_parent->removeChild(this);
             if (other->child(this))
             {
                 attachTo(other);
                 if (((seg->dir() & 1) != 0) ^ (idx > subindex))
                     m_with = Position(advance(), 0);
                 else        // normal match to previous root
                     m_attach = Position(other->advance(), 0);
             }
         }
         break;
     }
     case gr_slatAttX :          m_attach.x = value; break;
     case gr_slatAttY :          m_attach.y = value; break;
     case gr_slatAttXOff :
     case gr_slatAttYOff :       break;
     case gr_slatAttWithX :      m_with.x = value; break;
     case gr_slatAttWithY :      m_with.y = value; break;
     case gr_slatAttWithXOff :
     case gr_slatAttWithYOff :   break;
     case gr_slatAttLevel :
         m_attLevel = byte(value);
         break;
     case gr_slatBreak :
         seg->charinfo(m_original)->breakWeight(value);
         break;
     case gr_slatCompRef :   break;      // not sure what to do here
     case gr_slatDir :       m_bidiCls = value; break;
     case gr_slatInsert :
         markInsertBefore(value? true : false);
         break;
     case gr_slatPosX :      break; // can't set these here
     case gr_slatPosY :      break;
     case gr_slatShiftX :    m_shift.x = value; break;
     case gr_slatShiftY :    m_shift.y = value; break;
     case gr_slatMeasureSol :    break;
     case gr_slatMeasureEol :    break;
     case gr_slatJWidth :    just(value); break;
     case gr_slatSegSplit :  seg->charinfo(m_original)->addflags(value & 3); break;
     case gr_slatUserDefn :  m_userAttr[subindex] = value; break;
     default :
         break;
     }
 }
 int Slot::getJustify(const Segment *seg, uint8 level, uint8 subindex) const
 {
     if (level && level >= seg->silf()->numJustLevels()) return 0;
     if (m_justs)
         return m_justs->values[level * SlotJustify::NUMJUSTPARAMS + subindex];
     if (level >= seg->silf()->numJustLevels()) return 0;
     Justinfo *jAttrs = seg->silf()->justAttrs() + level;
     switch (subindex) {
         case 0 : return seg->glyphAttr(gid(), jAttrs->attrStretch());
         case 1 : return seg->glyphAttr(gid(), jAttrs->attrShrink());
         case 2 : return seg->glyphAttr(gid(), jAttrs->attrStep());
         case 3 : return seg->glyphAttr(gid(), jAttrs->attrWeight());
         case 4 : return 0;      // not been set yet, so clearly 0
         default: return 0;
     }
 }
 void Slot::setJustify(Segment *seg, uint8 level, uint8 subindex, int16 value)
 {
     if (level && level >= seg->silf()->numJustLevels()) return;
     if (!m_justs)
     {
         SlotJustify *j = seg->newJustify();
         if (!j) return;
         j->LoadSlot(this, seg);
         m_justs = j;
     }
     m_justs->values[level * SlotJustify::NUMJUSTPARAMS + subindex] = value;
 }
 bool Slot::child(Slot *ap)
 {
     if (this == ap) return false;
     else if (ap == m_child) return true;
     else if (!m_child)
         m_child = ap;
     else
         return m_child->sibling(ap);
     return true;
 }
 bool Slot::sibling(Slot *ap)
 {
     if (this == ap) return false;
     else if (ap == m_sibling) return true;
     else if (!m_sibling || !ap)
         m_sibling = ap;
     else
         return m_sibling->sibling(ap);
     return true;
 }
 bool Slot::removeChild(Slot *ap)
 {
     if (this == ap || !m_child) return false;
     else if (ap == m_child)
     {
         Slot *nSibling = m_child->nextSibling();
         m_child->sibling(NULL);
         m_child = nSibling;
         return true;
     }
     else
         return m_child->removeSibling(ap);
     return true;
 }
 bool Slot::removeSibling(Slot *ap)
 {
     if (this == ap || !m_sibling) return false;
     else if (ap == m_sibling)
     {
         m_sibling = m_sibling->nextSibling();
         return true;
     }
     else
         return m_sibling->removeSibling(ap);
     return true;
 }
 void Slot::setGlyph(Segment *seg, uint16 glyphid, const GlyphFace * theGlyph)
 {
     m_glyphid = glyphid;
     if (!theGlyph)
     {
         theGlyph = seg->getFace()->glyphs().glyphSafe(glyphid);
         if (!theGlyph)
         {
             m_realglyphid = 0;
             m_advance = Position(0.,0.);
             return;
         }
     }
     m_realglyphid = theGlyph->attrs()[seg->silf()->aPseudo()];
     const GlyphFace *aGlyph = theGlyph;
     if (m_realglyphid)
     {
         aGlyph = seg->getFace()->glyphs().glyphSafe(m_realglyphid);
         if (!aGlyph) aGlyph = theGlyph;
     }
     m_advance = Position(aGlyph->theAdvance().x, 0.);
     if (seg->silf()->aPassBits())
         seg->mergePassBits(theGlyph->attrs()[seg->silf()->aPassBits()]);
 }
 void Slot::floodShift(Position adj)
 {
     m_position += adj;
     if (m_child) m_child->floodShift(adj);
     if (m_sibling) m_sibling->floodShift(adj);
 }
 void SlotJustify::LoadSlot(const Slot *s, const Segment *seg)
 {
     for (int i = seg->silf()->numJustLevels() - 1; i >= 0; --i)
     {
         Justinfo *justs = seg->silf()->justAttrs() + i;
         int16 *v = values + i * NUMJUSTPARAMS;
         v[0] = seg->glyphAttr(s->gid(), justs->attrStretch());
         v[1] = seg->glyphAttr(s->gid(), justs->attrShrink());
         v[2] = seg->glyphAttr(s->gid(), justs->attrStep());
         v[3] = seg->glyphAttr(s->gid(), justs->attrWeight());
     }
 }

The Tor Browser / annotate

gfx/graphite2/src/Slot.cpp@b8a032363ba2 (annotated)

gfx/graphite2/src/Slot.cpp