Class: Fontisan::Type1::ConversionOptions

Inherits:
Object
  • Object
show all
Defined in:
lib/fontisan/type1/conversion_options.rb

Overview

Conversion options for Type 1 font generation

[‘ConversionOptions`](lib/fontisan/type1/conversion_options.rb) provides a unified configuration interface for converting outline fonts (TTF, OTF, TTC, etc.) to Type 1 formats (PFA, PFB, AFM, PFM, INF).

Examples:

Create Windows Type 1 options

options = Fontisan::Type1::ConversionOptions.windows_type1
options.upm_scale        # => 1000
options.encoding         # => Fontisan::Type1::Encodings::AdobeStandard
options.format           # => :pfb

Create custom options

options = Fontisan::Type1::ConversionOptions.new(
  upm_scale: 1000,
  encoding: Fontisan::Type1::Encodings::Unicode,
  format: :pfa
)

See Also:

Constant Summary collapse

DEFAULTS =

Default values based on TypeTool 3 and Adobe Type 1 specifications

{
  upm_scale: 1000,
  encoding: Encodings::AdobeStandard,
  decompose_composites: false,
  convert_curves: true,
  autohint: false,
  preserve_hinting: false,
  format: :pfb,
}.freeze

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(options = {}) ⇒ ConversionOptions

Initialize conversion options

Parameters:

  • options (Hash) (defaults to: {}) —

    Option values

Options Hash (options):

  • :upm_scale (Integer, :native) —

    Target UPM (default: 1000)

  • :encoding (Class) —

    Encoding class (default: AdobeStandard)

  • :decompose_composites (Boolean) —

    Decompose composites (default: false)

  • :convert_curves (Boolean) —

    Convert curves (default: true)

  • :autohint (Boolean) —

    Apply autohinting (default: false)

  • :preserve_hinting (Boolean) —

    Preserve hinting (default: false)

  • :format (Symbol) —

    Output format :pfb or :pfa (default: :pfb)



70
71
72
73
74
75
76
77
78
79
80
81
 
# File 'lib/fontisan/type1/conversion_options.rb', line 70

def initialize(options = {})
  @upm_scale = options[:upm_scale] || DEFAULTS[:upm_scale]
  @encoding = options[:encoding] || DEFAULTS[:encoding]
  @decompose_composites = options[:decompose_composites] || DEFAULTS[:decompose_composites]
  @convert_curves = options.fetch(:convert_curves,
                                  DEFAULTS[:convert_curves])
  @autohint = options[:autohint] || DEFAULTS[:autohint]
  @preserve_hinting = options[:preserve_hinting] || DEFAULTS[:preserve_hinting]
  @format = options[:format] || DEFAULTS[:format]

  validate!
end

Instance Attribute Details

#autohint ⇒ Boolean

Returns Apply autohinting to generated Type 1.

Returns:

  • (Boolean) —

    Apply autohinting to generated Type 1



41
42
43
 
# File 'lib/fontisan/type1/conversion_options.rb', line 41

def autohint
  @autohint
end

#convert_curves ⇒ Boolean

Returns Convert quadratic curves to cubic.

Returns:

  • (Boolean) —

    Convert quadratic curves to cubic



38
39
40
 
# File 'lib/fontisan/type1/conversion_options.rb', line 38

def convert_curves
  @convert_curves
end

#decompose_composites ⇒ Boolean

Returns Decompose composite glyphs into base glyphs.

Returns:

  • (Boolean) —

    Decompose composite glyphs into base glyphs



35
36
37
 
# File 'lib/fontisan/type1/conversion_options.rb', line 35

def decompose_composites
  @decompose_composites
end

#encoding ⇒ Class

Returns Encoding class (AdobeStandard, ISOLatin1, Unicode).

Returns:

  • (Class) —

    Encoding class (AdobeStandard, ISOLatin1, Unicode)



32
33
34
 
# File 'lib/fontisan/type1/conversion_options.rb', line 32

def encoding
  @encoding
end

#format ⇒ Symbol

Returns Output format (:pfb or :pfa).

Returns:

  • (Symbol) —

    Output format (:pfb or :pfa)



47
48
49
 
# File 'lib/fontisan/type1/conversion_options.rb', line 47

def format
  @format
end

#preserve_hinting ⇒ Boolean

Returns Preserve native hinting from source font.

Returns:

  • (Boolean) —

    Preserve native hinting from source font



44
45
46
 
# File 'lib/fontisan/type1/conversion_options.rb', line 44

def preserve_hinting
  @preserve_hinting
end

#upm_scale ⇒ Integer, :native

Returns Target UPM (1000 for Type 1, :native to keep source UPM).

Returns:

  • (Integer, :native) —

    Target UPM (1000 for Type 1, :native to keep source UPM)



29
30
31
 
# File 'lib/fontisan/type1/conversion_options.rb', line 29

def upm_scale
  @upm_scale
end

Class Method Details

.high_quality ⇒ ConversionOptions

Create options for high-quality output (with curve conversion)

Returns:



177
178
179
180
181
182
183
184
185
 
# File 'lib/fontisan/type1/conversion_options.rb', line 177

def self.high_quality
  new(
    upm_scale: 1000,
    encoding: Encodings::AdobeStandard,
    convert_curves: true,
    decompose_composites: true,
    format: :pfb,
  )
end

.iso_latin1 ⇒ ConversionOptions

Create options for ISO-8859-1 encoding

Returns:



155
156
157
158
159
160
161
 
# File 'lib/fontisan/type1/conversion_options.rb', line 155

def self.iso_latin1
  new(
    upm_scale: 1000,
    encoding: Encodings::ISOLatin1,
    format: :pfb,
  )
end

.minimal_size ⇒ ConversionOptions

Create options for minimal file size

Returns:



190
191
192
193
194
195
196
197
198
 
# File 'lib/fontisan/type1/conversion_options.rb', line 190

def self.minimal_size
  new(
    upm_scale: 1000,
    encoding: Encodings::AdobeStandard,
    convert_curves: false,
    decompose_composites: false,
    format: :pfa,
  )
end

.native_upm ⇒ ConversionOptions

Create options with native UPM (no scaling)

Returns:



144
145
146
147
148
149
150
 
# File 'lib/fontisan/type1/conversion_options.rb', line 144

def self.native_upm
  new(
    upm_scale: :native,
    encoding: Encodings::Unicode,
    format: :pfb,
  )
end

.unicode_encoding ⇒ ConversionOptions

Create options with Unicode encoding

Returns:



166
167
168
169
170
171
172
 
# File 'lib/fontisan/type1/conversion_options.rb', line 166

def self.unicode_encoding
  new(
    upm_scale: 1000,
    encoding: Encodings::Unicode,
    format: :pfb,
  )
end

.unix_type1 ⇒ ConversionOptions

Create options for Unix Type 1 output

Returns:



133
134
135
136
137
138
139
 
# File 'lib/fontisan/type1/conversion_options.rb', line 133

def self.unix_type1
  new(
    upm_scale: 1000,
    encoding: Encodings::AdobeStandard,
    format: :pfa,
  )
end

.windows_type1 ⇒ ConversionOptions

Create options for Windows Type 1 output

Returns:



122
123
124
125
126
127
128
 
# File 'lib/fontisan/type1/conversion_options.rb', line 122

def self.windows_type1
  new(
    upm_scale: 1000,
    encoding: Encodings::AdobeStandard,
    format: :pfb,
  )
end

Instance Method Details

#needs_autohinting? ⇒ Boolean

Check if autohinting is requested

Returns:

  • (Boolean) —

    True if autohint is true



100
101
102
 
# File 'lib/fontisan/type1/conversion_options.rb', line 100

def needs_autohinting?
  @autohint
end

#needs_curve_conversion? ⇒ Boolean

Check if curve conversion is needed

Returns:

  • (Boolean) —

    True if convert_curves is true



93
94
95
 
# File 'lib/fontisan/type1/conversion_options.rb', line 93

def needs_curve_conversion?
  @convert_curves
end

#needs_scaling? ⇒ Boolean

Check if UPM scaling is needed

Returns:

  • (Boolean) —

    True if upm_scale is not :native



86
87
88
 
# File 'lib/fontisan/type1/conversion_options.rb', line 86

def needs_scaling?
  @upm_scale != :native
end

#to_hash ⇒ Hash

Convert to hash

Returns:

  • (Hash) —

    Options as hash



107
108
109
110
111
112
113
114
115
116
117
 
# File 'lib/fontisan/type1/conversion_options.rb', line 107

def to_hash
  {
    upm_scale: @upm_scale,
    encoding: @encoding,
    decompose_composites: @decompose_composites,
    convert_curves: @convert_curves,
    autohint: @autohint,
    preserve_hinting: @preserve_hinting,
    format: @format,
  }
end