loca_table.rar_Table

/* * Copyright 2011 Google Inc. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef SFNTLY_CPP_SRC_SFNTLY_TABLE_TRUETYPE_LOCA_TABLE_H_ #define SFNTLY_CPP_SRC_SFNTLY_TABLE_TRUETYPE_LOCA_TABLE_H_ #include "sfntly/port/java_iterator.h" #include "sfntly/table/table.h" #include "sfntly/table/core/font_header_table.h" namespace sfntly { // A Loca table - 'loca'. class LocaTable : public Table, public RefCounted<LocaTable> { public: class LocaIterator : public PODIterator<int32_t, LocaTable> { public: explicit LocaIterator(LocaTable* table); virtual ~LocaIterator() {} virtual bool HasNext(); virtual int32_t Next(); private: int32_t index_; }; class Builder : public Table::Builder, public RefCounted<Builder> { public: // Constructor scope altered to public for base class to instantiate. Builder(Header* header, WritableFontData* data); Builder(Header* header, ReadableFontData* data); virtual ~Builder(); static CALLER_ATTACH Builder* CreateBuilder(Header* header, WritableFontData* data); // Get the format version that will be used when the loca table is // generated. // @return the loca table format version int32_t format_version() { return format_version_; } void set_format_version(int32_t value) { format_version_ = value; } // Gets the List of locas for loca table builder. These may be manipulated // in any way by the caller and the changes will be reflected in the final // loca table produced as long as no subsequent call is made to the // SetLocaList(List) method. // If there is no current data for the loca table builder or the loca list // have not been previously set then this will return an empty List. IntegerList* LocaList(); // Set the list of locas to be used for building this table. If any existing // list was already retrieved with the LocaList() method then the // connection of that previous list to this builder will be broken. void SetLocaList(IntegerList* list); // Return the offset for the given glyph id. Valid glyph ids are from 0 to // one less than the number of glyphs. The zero entry is the special entry // for the notdef glyph. The final entry beyond the last glyph id is used to // calculate the size of the last glyph. // @param glyphId the glyph id to get the offset for; must be less than or // equal to one more than the number of glyph ids // @return the offset in the glyph table to the specified glyph id int32_t GlyphOffset(int32_t glyph_id); // Get the length of the data in the glyph table for the specified glyph id. int32_t GlyphLength(int32_t glyph_id); // Set the number of glyphs. // This method sets the number of glyphs that the builder will attempt to // parse location data for from the raw binary data. This method only needs // to be called (and <b>must</b> be) when the raw data for this builder has // been changed. It does not by itself reset the data or clear any set loca // list. void SetNumGlyphs(int32_t num_glyphs); // Get the number of glyphs that this builder has support for. int NumGlyphs(); // Revert the loca table builder to the state contained in the last raw data // set on the builder. That raw data may be that read from a font file when // the font builder was created, that set by a user of the loca table // builder, or null data if this builder was created as a new empty builder. void Revert(); // Get the number of locations or locas. This will be one more than the // number of glyphs for this table since the last loca position is used to // indicate the size of the final glyph. int32_t NumLocas(); // Get the value from the loca table for the index specified. These are the // raw values from the table that are used to compute the offset and size of // a glyph in the glyph table. Valid index values run from 0 to the number // of glyphs in the font. int32_t Loca(int32_t index); virtual CALLER_ATTACH FontDataTable* SubBuildTable(ReadableFontData* data); virtual void SubDataSet(); virtual int32_t SubDataSizeToSerialize(); virtual bool SubReadyToSerialize(); virtual int32_t SubSerialize(WritableFontData* new_data); private: // Initialize the internal state from the data. Done lazily since in many // cases the builder will be just creating a table object with no parsing // required. // @param data the data to initialize from void Initialize(ReadableFontData* data); // Checks that the glyph id is within the correct range. // @return glyph_id if correct, -1 otherwise. int32_t CheckGlyphRange(int32_t glyph_id); int32_t LastGlyphIndex(); // Internal method to get the loca list if already generated and if not to // initialize the state of the builder. // @return the loca list IntegerList* GetLocaList(); void ClearLoca(bool nullify); int32_t format_version_; // Note: IndexToLocFormat int32_t num_glyphs_; IntegerList loca_; }; virtual ~LocaTable(); int32_t format_version() { return format_version_; } int32_t num_glyphs() { return num_glyphs_; } // Return the offset for the given glyph id. Valid glyph ids are from 0 to the // one less than the number of glyphs. The zero entry is the special entry for // the notdef glyph. The final entry beyond the last glyph id is used to // calculate the size of the last glyph. // @param glyphId the glyph id to get the offset for; must be less than or // equal to one more than the number of glyph ids // @return the offset in the glyph table to the specified glyph id int32_t GlyphOffset(int32_t glyph_id); // Get the length of the data in the glyph table for the specified glyph id. int32_t GlyphLength(int32_t glyph_id); // Get the number of locations or locas. This will be one more than the number // of glyphs for this table since the last loca position is used to indicate // the size of the final glyph. int32_t NumLocas(); // Get the value from the loca table for the index specified. Valid index // values run from 0 to the number of glyphs in the font. int32_t Loca(int32_t index); private: LocaTable(Header* header, ReadableFontData* data, int32_t format_version, int32_t num_glyphs); int32_t format_version_; // Note: Java's version, renamed to format_version_ int32_t num_glyphs_; friend class LocaIterator; }; typedef Ptr<LocaTable> LocaTablePtr; typedef Ptr<LocaTable::Builder> LocaTableBuilderPtr; } // namespace sfntly #endif // SFNTLY_CPP_SRC_SFNTLY_TABLE_TRUETYPE_LOCA_TABLE_H_