LCOV - app.info - gfx/graphite2/src/inc/Slot.h

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-07-07 | 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