path: root/thirdparty/graphite/src/Slot.cpp

// SPDX-License-Identifier: MIT OR MPL-2.0 OR LGPL-2.1-or-later OR GPL-2.0-or-later
// Copyright 2010, SIL International, All rights reserved.

#include "inc/Segment.h"
#include "inc/Slot.h"
#include "inc/Silf.h"
#include "inc/CharInfo.h"
#include "inc/Rule.h"
#include "inc/Collider.h"


using namespace graphite2;

Slot::Slot(int16 *user_attrs) :
    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_userAttr(user_attrs), m_justs(NULL)
{
}

// take care, this does not copy any of the GrSlot pointer fields
void Slot::set(const Slot & orig, int charOffset, size_t sizeAttr, 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 = int(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, sizeAttr * 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, bool rtl, bool isFinal, int depth)
{
    SlotCollision *coll = NULL;
    if (depth > 100 || (attrLevel && m_attLevel > attrLevel)) return Position(0, 0);
    float scale = font ? font->scale() : 1.0f;
    Position shift(m_shift.x * (rtl * -2 + 1) + m_just, m_shift.y);
    float tAdvance = m_advance.x + m_just;
    if (isFinal && (coll = seg->collisionInfo(this)))
    {
        const Position &collshift = coll->offset();
        if (!(coll->flags() & SlotCollision::COLL_KERN) || rtl)
            shift = shift + collshift;
    }
    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(glyph());
        else
            tAdvance *= scale;
    }
    Position res;

    m_position = base + shift;
    if (!m_parent)
    {
        res = base + Position(tAdvance, m_advance.y * scale);
        clusterMin = m_position.x;
    }
    else
    {
        float tAdv;
        m_position += (m_attach - m_with) * scale;
        tAdv = m_advance.x >= 0.5f ? m_position.x + tAdvance - shift.x : 0.f;
        res = Position(tAdv, 0);
        if ((m_advance.x >= 0.5f || 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, rtl, isFinal, depth + 1);
        if ((!m_parent || m_advance.x >= 0.5f) && 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, rtl, isFinal, depth + 1);
        if (tRes.x > res.x) res = tRes;
    }

    if (!m_parent && clusterMin < base.x)
    {
        Position adj = Position(m_position.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, bool rtl)
{
    Position base;
    if (glyph() >= seg->getFace()->glyphs().numGlyphs())
        return 0;
    Rect bbox = seg->theGlyphBBoxTemporary(glyph());
    float clusterMin = 0.;
    Position res = finalise(seg, NULL, base, bbox, attrLevel, clusterMin, rtl, false);

    switch (metrics(metric))
    {
    case kgmetLsb :
        return int32(bbox.bl.x);
    case kgmetRsb :
        return int32(res.x - bbox.tr.x);
    case kgmetBbTop :
        return int32(bbox.tr.y);
    case kgmetBbBottom :
        return int32(bbox.bl.y);
    case kgmetBbLeft :
        return int32(bbox.bl.x);
    case kgmetBbRight :
        return int32(bbox.tr.x);
    case kgmetBbWidth :
        return int32(bbox.tr.x - bbox.bl.x);
    case kgmetBbHeight :
        return int32(bbox.tr.y - bbox.bl.y);
    case kgmetAdvWidth :
        return int32(res.x);
    case kgmetAdvHeight :
        return int32(res.y);
    default :
        return 0;
    }
}

#define SLOTGETCOLATTR(x) { SlotCollision *c = seg->collisionInfo(this); return c ? int(c-> x) : 0; }

int Slot::getAttr(const Segment *seg, attrCode ind, uint8 subindex) const
{
    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 :       return seg->dir() & 1;
    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_slatUserDefnV1: subindex = 0; GR_FALLTHROUGH;
      // no break
    case gr_slatUserDefn :  return subindex < seg->numAttrs() ?  m_userAttr[subindex] : 0;
    case gr_slatSegSplit :  return seg->charinfo(m_original)->flags() & 3;
    case gr_slatBidiLevel:  return m_bidiLevel;
    case gr_slatColFlags :		{ SlotCollision *c = seg->collisionInfo(this); return c ? c->flags() : 0; }
    case gr_slatColLimitblx:SLOTGETCOLATTR(limit().bl.x)
    case gr_slatColLimitbly:SLOTGETCOLATTR(limit().bl.y)
    case gr_slatColLimittrx:SLOTGETCOLATTR(limit().tr.x)
    case gr_slatColLimittry:SLOTGETCOLATTR(limit().tr.y)
    case gr_slatColShiftx :	SLOTGETCOLATTR(offset().x)
    case gr_slatColShifty :	SLOTGETCOLATTR(offset().y)
    case gr_slatColMargin :	SLOTGETCOLATTR(margin())
    case gr_slatColMarginWt:SLOTGETCOLATTR(marginWt())
    case gr_slatColExclGlyph:SLOTGETCOLATTR(exclGlyph())
    case gr_slatColExclOffx:SLOTGETCOLATTR(exclOffset().x)
    case gr_slatColExclOffy:SLOTGETCOLATTR(exclOffset().y)
    case gr_slatSeqClass :	SLOTGETCOLATTR(seqClass())
    case gr_slatSeqProxClass:SLOTGETCOLATTR(seqProxClass())
    case gr_slatSeqOrder :	SLOTGETCOLATTR(seqOrder())
    case gr_slatSeqAboveXoff:SLOTGETCOLATTR(seqAboveXoff())
    case gr_slatSeqAboveWt: SLOTGETCOLATTR(seqAboveWt())
    case gr_slatSeqBelowXlim:SLOTGETCOLATTR(seqBelowXlim())
    case gr_slatSeqBelowWt:	SLOTGETCOLATTR(seqBelowWt())
    case gr_slatSeqValignHt:SLOTGETCOLATTR(seqValignHt())
    case gr_slatSeqValignWt:SLOTGETCOLATTR(seqValignWt())
    default : return 0;
    }
}

#define SLOTCOLSETATTR(x) { \
        SlotCollision *c = seg->collisionInfo(this); \
        if (c) { c-> x ; c->setFlags(c->flags() & ~SlotCollision::COLL_KNOWN); } \
        break; }
#define SLOTCOLSETCOMPLEXATTR(t, y, x) { \
        SlotCollision *c = seg->collisionInfo(this); \
        if (c) { \
        const t &s = c-> y; \
        c-> x ; c->setFlags(c->flags() & ~SlotCollision::COLL_KNOWN); } \
        break; }

void Slot::setAttr(Segment *seg, attrCode ind, uint8 subindex, int16 value, const SlotMap & map)
{
    if (ind == gr_slatUserDefnV1)
    {
        ind = gr_slatUserDefn;
        subindex = 0;
        if (seg->numAttrs() == 0)
            return;
    }
    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 || other == m_parent || other->isCopied()) break;
            if (m_parent) { m_parent->removeChild(this); attachTo(NULL); }
            Slot *pOther = other;
            int count = 0;
            bool foundOther = false;
            while (pOther)
            {
                ++count;
                if (pOther == this) foundOther = true;
                pOther = pOther->attachedTo();
            }
            for (pOther = m_child; pOther; pOther = pOther->m_child)
                ++count;
            for (pOther = m_sibling; pOther; pOther = pOther->m_sibling)
                ++count;
            if (count < 100 && !foundOther && other->child(this))
            {
                attachTo(other);
                if ((map.dir() != 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 : 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;
    case gr_slatColFlags :  {
        SlotCollision *c = seg->collisionInfo(this);
        if (c)
            c->setFlags(value);
        break; }
    case gr_slatColLimitblx :	SLOTCOLSETCOMPLEXATTR(Rect, limit(), setLimit(Rect(Position(value, s.bl.y), s.tr)))
    case gr_slatColLimitbly :	SLOTCOLSETCOMPLEXATTR(Rect, limit(), setLimit(Rect(Position(s.bl.x, value), s.tr)))
    case gr_slatColLimittrx :	SLOTCOLSETCOMPLEXATTR(Rect, limit(), setLimit(Rect(s.bl, Position(value, s.tr.y))))
    case gr_slatColLimittry :	SLOTCOLSETCOMPLEXATTR(Rect, limit(), setLimit(Rect(s.bl, Position(s.tr.x, value))))
    case gr_slatColMargin :		SLOTCOLSETATTR(setMargin(value))
    case gr_slatColMarginWt :	SLOTCOLSETATTR(setMarginWt(value))
    case gr_slatColExclGlyph :	SLOTCOLSETATTR(setExclGlyph(value))
    case gr_slatColExclOffx :	SLOTCOLSETCOMPLEXATTR(Position, exclOffset(), setExclOffset(Position(value, s.y)))
    case gr_slatColExclOffy :	SLOTCOLSETCOMPLEXATTR(Position, exclOffset(), setExclOffset(Position(s.x, value)))
    case gr_slatSeqClass :		SLOTCOLSETATTR(setSeqClass(value))
	case gr_slatSeqProxClass :	SLOTCOLSETATTR(setSeqProxClass(value))
    case gr_slatSeqOrder :		SLOTCOLSETATTR(setSeqOrder(value))
    case gr_slatSeqAboveXoff :	SLOTCOLSETATTR(setSeqAboveXoff(value))
    case gr_slatSeqAboveWt :	SLOTCOLSETATTR(setSeqAboveWt(value))
    case gr_slatSeqBelowXlim :	SLOTCOLSETATTR(setSeqBelowXlim(value))
    case gr_slatSeqBelowWt :	SLOTCOLSETATTR(setSeqBelowWt(value))
    case gr_slatSeqValignHt :	SLOTCOLSETATTR(setSeqValignHt(value))
    case gr_slatSeqValignWt :	SLOTCOLSETATTR(setSeqValignWt(value))
    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 || !ap) return false;
    else if (ap == m_child)
    {
        Slot *nSibling = m_child->nextSibling();
        m_child->nextSibling(NULL);
        m_child = nSibling;
        return true;
    }
    for (Slot *p = m_child; p; p = p->m_sibling)
    {
        if (p->m_sibling && p->m_sibling == ap)
        {
            p->m_sibling = p->m_sibling->m_sibling;
            ap->nextSibling(NULL);
            return true;
        }
    }
    return false;
}

void Slot::setGlyph(Segment *seg, uint16 glyphid, const GlyphFace * theGlyph)
{
    m_glyphid = glyphid;
    m_bidiCls = -1;
    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()];
    if (m_realglyphid > seg->getFace()->glyphs().numGlyphs())
        m_realglyphid = 0;
    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(uint8(theGlyph->attrs()[seg->silf()->aPassBits()]));
        if (seg->silf()->numPasses() > 16)
            seg->mergePassBits(theGlyph->attrs()[seg->silf()->aPassBits()+1] << 16);
    }
}

void Slot::floodShift(Position adj, int depth)
{
    if (depth > 100)
        return;
    m_position += adj;
    if (m_child) m_child->floodShift(adj, depth + 1);
    if (m_sibling) m_sibling->floodShift(adj, depth + 1);
}

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());
    }
}

Slot * Slot::nextInCluster(const Slot *s) const
{
    Slot *base;
    if (s->firstChild())
        return s->firstChild();
    else if (s->nextSibling())
        return s->nextSibling();
    while ((base = s->attachedTo()))
    {
        // if (base->firstChild() == s && base->nextSibling())
        if (base->nextSibling())
            return base->nextSibling();
        s = base;
    }
    return NULL;
}

bool Slot::isChildOf(const Slot *base) const
{
    for (Slot *p = m_parent; p; p = p->m_parent)
        if (p == base)
            return true;
    return false;
}