LCOV - code coverage report
Current view: directory - gfx/graphite2/src/inc - Slot.h (source / functions) Found Hit Coverage
Test: app.info Lines: 36 0 0.0 %
Date: 2012-06-02 Functions: 36 0 0.0 %

       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                 : #pragma once
      28                 : 
      29                 : #include "graphite2/Types.h"
      30                 : #include "graphite2/Segment.h"
      31                 : #include "inc/Main.h"
      32                 : #include "inc/Font.h"
      33                 : 
      34                 : 
      35                 : 
      36                 : namespace graphite2 {
      37                 : 
      38                 : typedef gr_attrCode attrCode;
      39                 : 
      40                 : class Segment;
      41                 : 
      42                 : class Slot
      43                 : {
      44                 :         enum Flag
      45                 :         {
      46                 :                 DELETED         = 1,
      47                 :                 INSERTED        = 2,
      48                 :                 COPIED          = 4,
      49                 :                 POSITIONED      = 8,
      50                 :                 ATTACHED        = 16
      51                 :         };
      52                 : 
      53                 : public:
      54                 :         struct iterator;
      55                 : 
      56               0 :     unsigned short gid() const { return m_glyphid; }
      57               0 :     Position origin() const { return m_position; }
      58               0 :     float advance() const { return m_advance.x; }
      59               0 :     Position advancePos() const { return m_advance; }
      60               0 :     int before() const { return m_before; }
      61               0 :     int after() const { return m_after; }
      62               0 :     uint32 index() const { return m_index; }
      63               0 :     void index(uint32 val) { m_index = val; }
      64                 : 
      65                 :     Slot();
      66                 :     void set(const Slot & slot, int charOffset, uint8 numUserAttr);
      67               0 :     Slot *next() const { return m_next; }
      68               0 :     void next(Slot *s) { m_next = s; }
      69               0 :     Slot *prev() const { return m_prev; }
      70               0 :     void prev(Slot *s) { m_prev = s; }
      71               0 :     uint16 glyph() const { return m_realglyphid ? m_realglyphid : m_glyphid; }
      72                 :     void setGlyph(Segment *seg, uint16 glyphid, const GlyphFace * theGlyph = NULL);
      73                 :     void setRealGid(uint16 realGid) { m_realglyphid = realGid; }
      74                 :     void adjKern(const Position &pos) { m_shift = m_shift + pos; m_advance = m_advance + pos; }
      75                 :     void origin(const Position &pos) { m_position = pos + m_shift; }
      76               0 :     void originate(int ind) { m_original = ind; }
      77               0 :     int original() const { return m_original; }
      78               0 :     void before(int ind) { m_before = ind; }
      79               0 :     void after(int ind) { m_after = ind; }
      80               0 :     bool isBase() const { return (!m_parent); }
      81                 :     void update(int numSlots, int numCharInfo, Position &relpos);
      82                 :     Position finalise(const Segment* seg, const Font* font, Position & base, Rect & bbox, float & cMin, uint8 attrLevel, float & clusterMin);
      83               0 :     bool isDeleted() const { return (m_flags & DELETED) ? true : false; }
      84               0 :     void markDeleted(bool state) { if (state) m_flags |= DELETED; else m_flags &= ~DELETED; }
      85               0 :     bool isCopied() const { return (m_flags & COPIED) ? true : false; }
      86               0 :     void markCopied(bool state) { if (state) m_flags |= COPIED; else m_flags &= ~COPIED; }
      87                 :     bool isPositioned() const { return (m_flags & POSITIONED) ? true : false; }
      88                 :     void markPositioned(bool state) { if (state) m_flags |= POSITIONED; else m_flags &= ~POSITIONED; }
      89               0 :     bool isInsertBefore() const { return !(m_flags & INSERTED); }
      90               0 :     uint8 getBidiLevel() const { return m_bidiLevel; }
      91               0 :     void setBidiLevel(uint8 level) { m_bidiLevel = level; }
      92               0 :     uint8 getBidiClass() const { return m_bidiCls; }
      93               0 :     void setBidiClass(uint8 cls) { m_bidiCls = cls; }
      94               0 :     int16 *userAttrs() { return m_userAttr; }
      95               0 :     void userAttrs(int16 *p) { m_userAttr = p; }
      96               0 :     void markInsertBefore(bool state) { if (!state) m_flags |= INSERTED; else m_flags &= ~INSERTED; }
      97                 :     void setAttr(Segment* seg, attrCode ind, uint8 subindex, int16 val, const SlotMap & map);
      98                 :     int getAttr(const Segment *seg, attrCode ind, uint8 subindex) const;
      99               0 :     void attachTo(Slot *ap) { m_parent = ap; }
     100               0 :     Slot *attachedTo() const { return m_parent; }
     101                 :     Position attachOffset() const { return m_attach - m_with; }
     102               0 :     Slot* firstChild() const { return m_child; }
     103                 :     bool child(Slot *ap);
     104               0 :     Slot* nextSibling() const { return m_sibling; }
     105                 :     bool sibling(Slot *ap);
     106                 :     uint32 clusterMetric(const Segment* seg, uint8 metric, uint8 attrLevel);
     107                 :     void positionShift(Position a) { m_position += a; }
     108                 :     void floodShift(Position adj);
     109               0 :     float just() const { return m_just; }
     110               0 :     void just(float j) { m_just = j; }
     111                 : 
     112                 :     CLASS_NEW_DELETE
     113                 : 
     114                 : private:
     115                 :     Slot *m_next;           // linked list of slots
     116                 :     Slot *m_prev;
     117                 :     unsigned short m_glyphid;        // glyph id
     118                 :     uint16 m_realglyphid;
     119                 :     uint32 m_original;      // charinfo that originated this slot (e.g. for feature values)
     120                 :     uint32 m_before;        // charinfo index of before association
     121                 :     uint32 m_after;         // charinfo index of after association
     122                 :     uint32 m_index;         // slot index given to this slot during finalising
     123                 :     Slot *m_parent;         // index to parent we are attached to
     124                 :     Slot *m_child;          // index to first child slot that attaches to us
     125                 :     Slot *m_sibling;        // index to next child that attaches to our parent
     126                 :     Position m_position;    // absolute position of glyph
     127                 :     Position m_shift;       // .shift slot attribute
     128                 :     Position m_advance;     // .advance slot attribute
     129                 :     Position m_attach;      // attachment point on us
     130                 :     Position m_with;        // attachment point position on parent
     131                 :     float    m_just;        // justification adjustment
     132                 :     uint8    m_flags;       // holds bit flags
     133                 :     byte     m_attLevel;    // attachment level
     134                 :     byte     m_bidiCls;     // bidirectional class
     135                 :     byte     m_bidiLevel;   // bidirectional level
     136                 :     int16   *m_userAttr;     // pointer to user attributes
     137                 : };
     138                 : 
     139                 : } // namespace graphite2
     140                 : 
     141                 : struct gr_slot : public graphite2::Slot {};

Generated by: LCOV version 1.7