The Tor Browser / file comparison
comparison: gfx/graphite2/src/inc/Slot.h
gfx/graphite2/src/inc/Slot.h
- branch
- TOR_BUG_9701
- changeset 15
- b8a032363ba2
equal
deleted
inserted
replaced
| -1:000000000000 | 0:30be3efe9235 |
|---|---|
| 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 #include "inc/Position.h" | |
| 34 | |
| 35 | |
| 36 | |
| 37 namespace graphite2 { | |
| 38 | |
| 39 typedef gr_attrCode attrCode; | |
| 40 | |
| 41 class GlyphFace; | |
| 42 class Segment; | |
| 43 class SegCacheEntry; | |
| 44 | |
| 45 struct SlotJustify | |
| 46 { | |
| 47 static const int NUMJUSTPARAMS = 5; | |
| 48 | |
| 49 SlotJustify(const SlotJustify &); | |
| 50 SlotJustify & operator = (const SlotJustify &); | |
| 51 | |
| 52 public: | |
| 53 static size_t size_of(size_t levels) { return sizeof(SlotJustify) + ((levels > 1 ? levels : 1)*NUMJUSTPARAMS - 1)*sizeof(int16); } | |
| 54 | |
| 55 void LoadSlot(const Slot *s, const Segment *seg); | |
| 56 | |
| 57 SlotJustify *next; | |
| 58 int16 values[1]; | |
| 59 }; | |
| 60 | |
| 61 class Slot | |
| 62 { | |
| 63 enum Flag | |
| 64 { | |
| 65 DELETED = 1, | |
| 66 INSERTED = 2, | |
| 67 COPIED = 4, | |
| 68 POSITIONED = 8, | |
| 69 ATTACHED = 16 | |
| 70 }; | |
| 71 | |
| 72 public: | |
| 73 struct iterator; | |
| 74 | |
| 75 unsigned short gid() const { return m_glyphid; } | |
| 76 Position origin() const { return m_position; } | |
| 77 float advance() const { return m_advance.x; } | |
| 78 Position advancePos() const { return m_advance; } | |
| 79 int before() const { return m_before; } | |
| 80 int after() const { return m_after; } | |
| 81 uint32 index() const { return m_index; } | |
| 82 void index(uint32 val) { m_index = val; } | |
| 83 | |
| 84 Slot(); | |
| 85 void set(const Slot & slot, int charOffset, size_t numUserAttr, size_t justLevels, size_t numChars); | |
| 86 Slot *next() const { return m_next; } | |
| 87 void next(Slot *s) { m_next = s; } | |
| 88 Slot *prev() const { return m_prev; } | |
| 89 void prev(Slot *s) { m_prev = s; } | |
| 90 uint16 glyph() const { return m_realglyphid ? m_realglyphid : m_glyphid; } | |
| 91 void setGlyph(Segment *seg, uint16 glyphid, const GlyphFace * theGlyph = NULL); | |
| 92 void setRealGid(uint16 realGid) { m_realglyphid = realGid; } | |
| 93 void adjKern(const Position &pos) { m_shift = m_shift + pos; m_advance = m_advance + pos; } | |
| 94 void origin(const Position &pos) { m_position = pos + m_shift; } | |
| 95 void originate(int ind) { m_original = ind; } | |
| 96 int original() const { return m_original; } | |
| 97 void before(int ind) { m_before = ind; } | |
| 98 void after(int ind) { m_after = ind; } | |
| 99 bool isBase() const { return (!m_parent); } | |
| 100 void update(int numSlots, int numCharInfo, Position &relpos); | |
| 101 Position finalise(const Segment* seg, const Font* font, Position & base, Rect & bbox, uint8 attrLevel, float & clusterMin); | |
| 102 bool isDeleted() const { return (m_flags & DELETED) ? true : false; } | |
| 103 void markDeleted(bool state) { if (state) m_flags |= DELETED; else m_flags &= ~DELETED; } | |
| 104 bool isCopied() const { return (m_flags & COPIED) ? true : false; } | |
| 105 void markCopied(bool state) { if (state) m_flags |= COPIED; else m_flags &= ~COPIED; } | |
| 106 bool isPositioned() const { return (m_flags & POSITIONED) ? true : false; } | |
| 107 void markPositioned(bool state) { if (state) m_flags |= POSITIONED; else m_flags &= ~POSITIONED; } | |
| 108 bool isInsertBefore() const { return !(m_flags & INSERTED); } | |
| 109 uint8 getBidiLevel() const { return m_bidiLevel; } | |
| 110 void setBidiLevel(uint8 level) { m_bidiLevel = level; } | |
| 111 int8 getBidiClass() const { return m_bidiCls; } | |
| 112 void setBidiClass(int8 cls) { m_bidiCls = cls; } | |
| 113 int16 *userAttrs() const { return m_userAttr; } | |
| 114 void userAttrs(int16 *p) { m_userAttr = p; } | |
| 115 void markInsertBefore(bool state) { if (!state) m_flags |= INSERTED; else m_flags &= ~INSERTED; } | |
| 116 void setAttr(Segment* seg, attrCode ind, uint8 subindex, int16 val, const SlotMap & map); | |
| 117 int getAttr(const Segment *seg, attrCode ind, uint8 subindex) const; | |
| 118 int getJustify(const Segment *seg, uint8 level, uint8 subindex) const; | |
| 119 void setJustify(Segment *seg, uint8 level, uint8 subindex, int16 value); | |
| 120 bool isLocalJustify() const { return m_justs != NULL; }; | |
| 121 void attachTo(Slot *ap) { m_parent = ap; } | |
| 122 Slot *attachedTo() const { return m_parent; } | |
| 123 Position attachOffset() const { return m_attach - m_with; } | |
| 124 Slot* firstChild() const { return m_child; } | |
| 125 bool child(Slot *ap); | |
| 126 Slot* nextSibling() const { return m_sibling; } | |
| 127 bool sibling(Slot *ap); | |
| 128 bool removeChild(Slot *ap); | |
| 129 bool removeSibling(Slot *ap); | |
| 130 int32 clusterMetric(const Segment* seg, uint8 metric, uint8 attrLevel); | |
| 131 void positionShift(Position a) { m_position += a; } | |
| 132 void floodShift(Position adj); | |
| 133 float just() const { return m_just; } | |
| 134 void just(float j) { m_just = j; } | |
| 135 | |
| 136 CLASS_NEW_DELETE | |
| 137 | |
| 138 private: | |
| 139 Slot *m_next; // linked list of slots | |
| 140 Slot *m_prev; | |
| 141 unsigned short m_glyphid; // glyph id | |
| 142 uint16 m_realglyphid; | |
| 143 uint32 m_original; // charinfo that originated this slot (e.g. for feature values) | |
| 144 uint32 m_before; // charinfo index of before association | |
| 145 uint32 m_after; // charinfo index of after association | |
| 146 uint32 m_index; // slot index given to this slot during finalising | |
| 147 Slot *m_parent; // index to parent we are attached to | |
| 148 Slot *m_child; // index to first child slot that attaches to us | |
| 149 Slot *m_sibling; // index to next child that attaches to our parent | |
| 150 Position m_position; // absolute position of glyph | |
| 151 Position m_shift; // .shift slot attribute | |
| 152 Position m_advance; // .advance slot attribute | |
| 153 Position m_attach; // attachment point on us | |
| 154 Position m_with; // attachment point position on parent | |
| 155 float m_just; // Justification inserted space | |
| 156 uint8 m_flags; // holds bit flags | |
| 157 byte m_attLevel; // attachment level | |
| 158 int8 m_bidiCls; // bidirectional class | |
| 159 byte m_bidiLevel; // bidirectional level | |
| 160 int16 *m_userAttr; // pointer to user attributes | |
| 161 SlotJustify *m_justs; // pointer to justification parameters | |
| 162 | |
| 163 friend class SegCacheEntry; | |
| 164 friend class Segment; | |
| 165 }; | |
| 166 | |
| 167 } // namespace graphite2 | |
| 168 | |
| 169 struct gr_slot : public graphite2::Slot {}; |
