The Tor Browser: gfx/graphite2/src/inc/FeatureMap.h@6474c204b198

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

     1 /*  GRAPHITE2 LICENSING

     3     Copyright 2010, SIL International

     4     All rights reserved.

     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.

    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.

    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.

    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 #include "inc/Main.h"

    29 #include "inc/FeatureVal.h"

    31 namespace graphite2 {

    33 // Forward declarations for implmentation types

    34 class FeatureMap;

    35 class Face;

    38 class FeatureSetting

    39 {

    40 public:

    41     FeatureSetting(int16 theValue, uint16 labelId) : m_label(labelId), m_value(theValue) {};

    42     uint16 label() const { return m_label; }

    43     int16 value() const { return m_value; }

    45     CLASS_NEW_DELETE;

    46 private:

    47     FeatureSetting(const FeatureSetting & fs) : m_label(fs.m_label), m_value(fs.m_value) {};

    49     uint16 m_label;

    50     int16 m_value;

    51 };

    53 class FeatureRef

    54 {

    55     typedef uint32      chunk_t;

    56     static const uint8  SIZEOF_CHUNK = sizeof(chunk_t)*8;

    58 public:

    59     FeatureRef() : m_nameValues(0) {}

    60     FeatureRef(const Face & face, unsigned short & bits_offset, uint32 max_val,

    61                uint32 name, uint16 uiName, uint16 flags,

    62                FeatureSetting *settings, uint16 num_set) throw();

    63     ~FeatureRef() throw();

    65     bool applyValToFeature(uint32 val, Features& pDest) const; //defined in GrFaceImp.h

    66     void maskFeature(Features & pDest) const {

    67     if (m_index < pDest.size())                 //defensive

    68         pDest[m_index] |= m_mask;

    69     }

    71     uint32 getFeatureVal(const Features& feats) const; //defined in GrFaceImp.h

    73     uint32 getId() const { return m_id; }

    74     uint16 getNameId() const { return m_nameid; }

    75     uint16 getNumSettings() const { return m_numSet; }

    76     uint16 getSettingName(uint16 index) const { return m_nameValues[index].label(); }

    77     int16  getSettingValue(uint16 index) const { return m_nameValues[index].value(); }

    78     uint32 maxVal() const { return m_max; }

    79     const Face* getFace() const { return m_pFace;}

    80     const FeatureMap* getFeatureMap() const;// { return m_pFace;}

    82     CLASS_NEW_DELETE;

    83 private:

    84     FeatureRef(const FeatureRef & rhs);

    86     const Face     * m_pFace;   //not NULL

    87     FeatureSetting * m_nameValues; // array of name table ids for feature values

    88     chunk_t m_mask,             // bit mask to get the value from the vector

    89             m_max;              // max value the value can take

    90     uint32  m_id;               // feature identifier/name

    91     uint16  m_nameid,            // Name table id for feature name

    92             m_flags,             // feature flags (unused at the moment but read from the font)

    93             m_numSet;            // number of values (number of entries in m_nameValues)

    94     byte    m_bits,             // how many bits to shift the value into place

    95             m_index;            // index into the array to find the ulong to mask

    97 private:        //unimplemented

    98     FeatureRef& operator=(const FeatureRef&);

    99 };

   102 class NameAndFeatureRef

   103 {

   104   public:

   105     NameAndFeatureRef(uint32 name = 0) : m_name(name) , m_pFRef(NULL){}

   106     NameAndFeatureRef(const FeatureRef* p/*not NULL*/) : m_name(p->getId()), m_pFRef(p) {}

   108     bool operator<(const NameAndFeatureRef& rhs) const //orders by m_name

   109         {   return m_name<rhs.m_name; }

   111     CLASS_NEW_DELETE

   113     uint32 m_name;

   114     const FeatureRef* m_pFRef;

   115 };

   117 class FeatureMap

   118 {

   119 public:

   120     FeatureMap() : m_numFeats(0), m_feats(NULL), m_pNamedFeats(NULL),

   121         m_defaultFeatures(NULL) {}

   122     ~FeatureMap() { delete [] m_feats; delete[] m_pNamedFeats; delete m_defaultFeatures; }

   124     bool readFeats(const Face & face);

   125     const FeatureRef *findFeatureRef(uint32 name) const;

   126     FeatureRef *feature(uint16 index) const { return m_feats + index; }

   127     //GrFeatureRef *featureRef(byte index) { return index < m_numFeats ? m_feats + index : NULL; }

   128     const FeatureRef *featureRef(byte index) const { return index < m_numFeats ? m_feats + index : NULL; }

   129     FeatureVal* cloneFeatures(uint32 langname/*0 means default*/) const;      //call destroy_Features when done.

   130     uint16 numFeats() const { return m_numFeats; };

   131     CLASS_NEW_DELETE

   132 private:

   133 friend class SillMap;

   134     uint16 m_numFeats;

   136     FeatureRef *m_feats;

   137     NameAndFeatureRef* m_pNamedFeats;   //owned

   138     FeatureVal* m_defaultFeatures;        //owned

   140 private:        //defensive on m_feats, m_pNamedFeats, and m_defaultFeatures

   141     FeatureMap(const FeatureMap&);

   142     FeatureMap& operator=(const FeatureMap&);

   143 };

   146 class SillMap

   147 {

   148 private:

   149     class LangFeaturePair

   150     {

   151         LangFeaturePair(const LangFeaturePair &);

   152         LangFeaturePair & operator = (const LangFeaturePair &);

   154     public:

   155         LangFeaturePair() :  m_lang(0), m_pFeatures(0) {}

   156         ~LangFeaturePair() { delete m_pFeatures; }

   158         uint32 m_lang;

   159         Features* m_pFeatures;      //owns

   160         CLASS_NEW_DELETE

   161     };

   162 public:

   163     SillMap() : m_langFeats(NULL), m_numLanguages(0) {}

   164     ~SillMap() { delete[] m_langFeats; }

   165     bool readFace(const Face & face);

   166     bool readSill(const Face & face);

   167     FeatureVal* cloneFeatures(uint32 langname/*0 means default*/) const;      //call destroy_Features when done.

   168     uint16 numLanguages() const { return m_numLanguages; };

   169     uint32 getLangName(uint16 index) const { return (index < m_numLanguages)? m_langFeats[index].m_lang : 0; };

   171     const FeatureMap & theFeatureMap() const { return m_FeatureMap; };

   172 private:

   173     FeatureMap m_FeatureMap;        //of face

   174     LangFeaturePair * m_langFeats;

   175     uint16 m_numLanguages;

   177 private:        //defensive on m_langFeats

   178     SillMap(const SillMap&);

   179     SillMap& operator=(const SillMap&);

   180 };

   182 } // namespace graphite2

   184 struct gr_feature_ref : public graphite2::FeatureRef {};

The Tor Browser / file revision