← Back to branch summary

~ubuntu-branches/ubuntu/feisty/fonttools/feisty

« back to all changes in this revision

Viewing changes to Lib/fontTools/ttLib/tables/_h_m_t_x.py

  • Committer: Bazaar Package Importer
  • Author(s): Anthony Fok
  • Date: 2003-11-18 00:53:59 UTC
  • Revision ID: james.westby@ubuntu.com-20031118005359-pqirsxbgdz0f0xmx
Tags: upstream-1.99+2.0b1+cvs20031014
Import upstream version 1.99+2.0b1+cvs20031014

Show diffs side-by-side

added added

removed removed

Lines of Context:
Lib/fontTools/ttLib/tables/_h_m_t_x.py
 
1
import DefaultTable
 
2
import Numeric
 
3
from fontTools import ttLib
 
4
from fontTools.misc.textTools import safeEval
 
5
 
 
6
 
 
7
class table__h_m_t_x(DefaultTable.DefaultTable):
 
8
        
 
9
        headerTag = 'hhea'
 
10
        advanceName = 'width'
 
11
        sideBearingName = 'lsb'
 
12
        numberOfMetricsName = 'numberOfHMetrics'
 
13
        
 
14
        def decompile(self, data, ttFont):
 
15
                numberOfMetrics = int(getattr(ttFont[self.headerTag], self.numberOfMetricsName))
 
16
                metrics = Numeric.fromstring(data[:4 * numberOfMetrics], 
 
17
                                Numeric.Int16)
 
18
                if ttLib.endian <> "big":
 
19
                        metrics = metrics.byteswapped()
 
20
                metrics.shape = (numberOfMetrics, 2)
 
21
                data = data[4 * numberOfMetrics:]
 
22
                numberOfSideBearings = ttFont['maxp'].numGlyphs - numberOfMetrics
 
23
                numberOfSideBearings = int(numberOfSideBearings)
 
24
                if numberOfSideBearings:
 
25
                        assert numberOfSideBearings > 0, "bad hmtx/vmtx table"
 
26
                        lastAdvance = metrics[-1][0]
 
27
                        advances = Numeric.array([lastAdvance] * numberOfSideBearings, 
 
28
                                        Numeric.Int16)
 
29
                        sideBearings = Numeric.fromstring(data[:2 * numberOfSideBearings], 
 
30
                                        Numeric.Int16)
 
31
                        if ttLib.endian <> "big":
 
32
                                sideBearings = sideBearings.byteswapped()
 
33
                        data = data[2 * numberOfSideBearings:]
 
34
                        additionalMetrics = Numeric.array([advances, sideBearings], 
 
35
                                        Numeric.Int16)
 
36
                        metrics = Numeric.concatenate((metrics, 
 
37
                                        Numeric.transpose(additionalMetrics)))
 
38
                if data:
 
39
                        import sys
 
40
                        sys.stderr.write("too much data for hmtx/vmtx table\n")
 
41
                metrics = metrics.tolist()
 
42
                self.metrics = {}
 
43
                for i in range(len(metrics)):
 
44
                        glyphName = ttFont.getGlyphName(i)
 
45
                        self.metrics[glyphName] = metrics[i]
 
46
        
 
47
        def compile(self, ttFont):
 
48
                metrics = []
 
49
                for glyphName in ttFont.getGlyphOrder():
 
50
                        metrics.append(self.metrics[glyphName])
 
51
                lastAdvance = metrics[-1][0]
 
52
                lastIndex = len(metrics)
 
53
                while metrics[lastIndex-2][0] == lastAdvance:
 
54
                        lastIndex = lastIndex - 1
 
55
                        if lastIndex <= 1:
 
56
                                # all advances are equal
 
57
                                lastIndex = 1
 
58
                                break
 
59
                additionalMetrics = metrics[lastIndex:]
 
60
                additionalMetrics = map(lambda (advance, sb): sb, additionalMetrics)
 
61
                metrics = metrics[:lastIndex]
 
62
                setattr(ttFont[self.headerTag], self.numberOfMetricsName, len(metrics))
 
63
                
 
64
                metrics = Numeric.array(metrics, Numeric.Int16)
 
65
                if ttLib.endian <> "big":
 
66
                        metrics = metrics.byteswapped()
 
67
                data = metrics.tostring()
 
68
                
 
69
                additionalMetrics = Numeric.array(additionalMetrics, Numeric.Int16)
 
70
                if ttLib.endian <> "big":
 
71
                        additionalMetrics = additionalMetrics.byteswapped()
 
72
                data = data + additionalMetrics.tostring()
 
73
                return data
 
74
        
 
75
        def toXML(self, writer, ttFont):
 
76
                names = self.metrics.keys()
 
77
                names.sort()
 
78
                for glyphName in names:
 
79
                        advance, sb = self.metrics[glyphName]
 
80
                        writer.simpletag("mtx", [
 
81
                                        ("name", glyphName), 
 
82
                                        (self.advanceName, advance), 
 
83
                                        (self.sideBearingName, sb),
 
84
                                        ])
 
85
                        writer.newline()
 
86
        
 
87
        def fromXML(self, (name, attrs, content), ttFont):
 
88
                if not hasattr(self, "metrics"):
 
89
                        self.metrics = {}
 
90
                if name == "mtx":
 
91
                        self.metrics[attrs["name"]] = [safeEval(attrs[self.advanceName]), 
 
92
                                        safeEval(attrs[self.sideBearingName])]
 
93
        
 
94
        def __getitem__(self, glyphName):
 
95
                return self.metrics[glyphName]
 
96
        
 
97
        def __setitem__(self, glyphName, (advance, sb)):
 
98
                self.metrics[glyphName] = advance, sb
 
99