1 files changed, 183 insertions, 0 deletions
diff --git a/sfntly/table/truetype/loca_table.h b/sfntly/table/truetype/loca_table.h
new file mode 100644
index 0000000..67c5749
--- /dev/null
+++ b/sfntly/table/truetype/loca_table.h
@@ -0,0 +1,183 @@
+/*
+ * 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_