mathtype 0.0.8 → 0.1.0

data/lib/records3/embell.rb

@@ -0,0 +1,109 @@
+require_relative "snapshot"
+
+# EMBELL record (6):
+# Consists of:
+# record type (6)
+# options
+# [nudge] if mtefOPT_NUDGE is set
+# [embell] embellishment type
+# The embellishment types are:
+
+# value symbol  description
+# 2 emb1DOT over single dot
+# 3 emb2DOT over double dot
+# 4 emb3DOT over triple dot
+# 5 emb1PRIME single prime
+# 6 emb2PRIME double prime
+# 7 embBPRIME backwards prime (left of character)
+# 8 embTILDE  tilde
+# 9 embHAT  hat (circumflex)
+# 10  embNOT  diagonal slash through character
+# 11  embRARROW over right arrow
+# 12  embLARROW over left arrow
+# 13  embBARROW over both arrow (left and right)
+# 14  embR1ARROW  over right single-barbed arrow
+# 15  embL1ARROW  over left single-barbed arrow
+# 16  embMBAR mid-height horizontal bar
+# 17  embOBAR over-bar
+# 18  emb3PRIME triple prime
+# 19  embFROWN  over-arc, concave downward
+# 20  embSMILE  over-arc, concave upward
+# 21  embX_BARS double diagonal bars
+# 22  embUP_BAR bottom-left to top-right diagonal bar
+# 23  embDOWN_BAR top-left to bottom-right diagonal bar
+# 24  emb4DOT over quad dot
+# 25  embU_1DOT under single dot
+# 26  embU_2DOT under double dot
+# 27  embU_3DOT under triple dot
+# 28  embU_4DOT under quad dot
+# 29  embU_BAR  under bar
+# 30  embU_TILDE  under tilde (~)
+# 31  embU_FROWN  under arc (ends point down)
+# 32  embU_SMILE  under arc (ends point up)
+# 33  embU_RARROW under right arrow
+# 34  embU_LARROW under left arrow
+# 35  embU_BARROW under both arrow (left and right)
+# 36  embU_R1ARROW  under right arrow (1 barb)
+# 37  embU_L1ARROW  under left arrow (1 barb)
+
+module Mathtype3
+  class RecordEmbell < BinData::Record
+    include Snapshot
+    EXPOSED_IN_SNAPSHOT = %i(options nudge embell)
+
+    EMBELL = {
+      2 => "emb1DOT", # over single dot
+      3 => "emb2DOT", # over double dot
+      4 => "emb3DOT", # over triple dot
+      5 => "emb1PRIME", # single prime
+      6 => "emb2PRIME", # double prime
+      7 => "embBPRIME", # backwards prime (left of character)
+      8 => "embTILDE", #  tilde
+      9 => "embHAT", #  hat (circumflex)
+      10 => "embNOT", #  diagonal slash through character
+      11 => "embRARROW", # over right arrow
+      12 => "embLARROW", # over left arrow
+      13 => "embBARROW", # over both arrow (left and right)
+      14 => "embR1ARROW", #  over right single-barbed arrow
+      15 => "embL1ARROW", #  over left single-barbed arrow
+      16 => "embMBAR", # mid-height horizontal bar
+      17 => "embOBAR", # over-bar
+      18 => "emb3PRIME", # triple prime
+      19 => "embFROWN", #  over-arc, concave downward
+      20 => "embSMILE", #  over-arc, concave upward
+      21 => "embX_BARS", # double diagonal bars
+      22 => "embUP_BAR", # bottom-left to top-right diagonal bar
+      23 => "embDOWN_BAR", # top-left to bottom-right diagonal bar
+      24 => "emb4DOT", # over quad dot
+      25 => "embU_1DOT", # under single dot
+      26 => "embU_2DOT", # under double dot
+      27 => "embU_3DOT", # under triple dot
+      28 => "embU_4DOT", # under quad dot
+      29 => "embU_BAR", #  under bar
+      30 => "embU_TILDE", #  under tilde (~)
+      31 => "embU_FROWN", #  under arc (ends point down)
+      32 => "embU_SMILE", #  under arc (ends point up)
+      33 => "embU_RARROW", # under right arrow
+      34 => "embU_LARROW", # under left arrow
+      35 => "embU_BARROW", # under both arrow (left and right)
+      36 => "embU_R1ARROW", #  under right arrow (1 barb)
+      37 => "embU_L1ARROW", #  under left arrow (1 barb)
+    }
+    mandatory_parameter :_options
+
+    virtual :_tag_options, :value => lambda{ _options }
+
+    record_nudge :nudge, onlyif: lambda { _options & OPTIONS["xfLMOVE"] > 0 }
+
+    int8 :_embell
+    int8 :_none
+
+    def embell
+      EMBELL[_embell]
+    end
+
+    def options
+      _tag_options
+    end
+  end
+end

data/lib/records3/font.rb

@@ -0,0 +1,27 @@
+require_relative "snapshot"
+
+module Mathtype3
+  class RecordFont < BinData::Record
+    include Snapshot
+    EXPOSED_IN_SNAPSHOT = %i(options name typeface style)
+
+    endian :little
+
+    mandatory_parameter :_options
+
+    virtual :_tag_options, :value => lambda{ _options }
+
+    int8 :_typeface
+
+    int8 :style
+
+    stringz :name
+    def typeface
+      _typeface + 128
+    end
+
+    def options
+      _tag_options
+    end
+  end
+end

data/lib/records3/line.rb

@@ -0,0 +1,47 @@
+# LINE record (1):
+# Consists of:
+# record type (1)
+# options
+# [nudge] if mtefOPT_NUDGE is set
+# [line spacing] if mtefOPT_LINE_LSPACE is set (16-bit integer)
+# [RULER record] if mtefOPT_LP_RULER is set
+# object list of line (single pile, characters and templates, or nothing)
+# The line spacing value, if present, is the distance between the baseline of
+# this line and the line above it.
+
+require_relative "snapshot"
+
+module Mathtype3
+  class NamedRecord < BinData::Record; end
+  class RecordLine < BinData::Record
+    include Snapshot
+    EXPOSED_IN_SNAPSHOT = %i(options nudge line_spacing ruler object_list)
+    endian :little
+
+    mandatory_parameter :_options
+
+    virtual :_tag_options, :value => lambda{ _options }
+
+    record_nudge :nudge, onlyif: lambda { _options & OPTIONS["xfLMOVE"] > 0 }
+
+    mtef16 :line_spacing, onlyif: (lambda do
+      _options & OPTIONS["xfLSPACE"] > 0
+    end)
+
+    record_ruler :ruler, onlyif: (lambda do
+      _options & OPTIONS["xfRULER"] > 0
+    end)
+
+    array :object_list,
+        onlyif: lambda { _options & OPTIONS["xfNULL"] == 0 },
+        read_until: lambda { element.record_type == 0 } do
+      named_record
+    end
+
+    def to_formatted_s(indent = 0); to_s; end
+
+    def options
+      _tag_options
+    end
+  end
+end

data/lib/records3/matrix.rb

@@ -0,0 +1,80 @@
+require_relative "snapshot"
+
+# MATRIX record (5):
+# record type (5)
+# options
+# [nudge] if mtefOPT_NUDGE is set
+# [valign] vertical alignment of matrix within container
+# [h_just] horizontal alignment within columns
+# [v_just] vertical alignment within columns
+# [rows] number of rows
+# [cols] number of columns
+# [row_parts] row partition line types (see below)
+# [col_parts] column partition line types (see below)
+# [object list] list of lines, one for each element of the matrix, in order from
+# left-to-right and top-to-bottom
+# The values for valign, h_just, and v_just are described in PILE above.
+
+# The row partition line type list consists of two-bit values for each possible
+# partition line (one more than the number of rows), rounded out to the nearest
+# byte. Each value determines the line style of the corresponding partition line
+# (0 for none, 1 for solid, 2 for dashed, or 3 for dotted). Similarly for the
+# column partition lines.
+
+module Mathtype3
+  class RecordMatrix < BinData::Record
+    include Snapshot
+    EXPOSED_IN_SNAPSHOT = %i(options nudge valign h_just v_just rows cols
+      row_parts col_parts object_list)
+
+
+    mandatory_parameter :_options
+
+    virtual :_tag_options, :value => lambda{ _options }
+
+    record_nudge :nudge, onlyif: lambda { _options & OPTIONS["xfLMOVE"] > 0 }
+
+    int8 :_valign
+    int8 :_h_just
+    int8 :_v_just
+    int8 :rows
+    int8 :cols
+
+    array :row_parts, initial_length: lambda { rows + 1 } do
+      bit nbits: 2
+    end
+
+    bit :_realign_rows, nbits: lambda { realign(rows) }
+
+    array :col_parts, initial_length: lambda { cols + 1 } do
+      bit nbits: 2
+    end
+
+    bit :_realign_cols, nbits: lambda { realign(cols) }
+
+    array :object_list, read_until: lambda { element.record_type == 0 } do
+      named_record
+    end
+
+    def valign
+      VALIGN[_valign]
+    end
+
+    def h_just
+      HALIGN[_h_just]
+    end
+
+    def v_just
+      VALIGN[_v_just]
+    end
+
+    def options
+      _tag_options
+    end
+
+    def realign (nparts)
+      offset = (((nparts +  1) * 2) % 8)
+      return offset == 0 ? 0 : (8 - offset)
+    end
+  end
+end

data/lib/records3/mtef.rb

@@ -0,0 +1,97 @@
+require_relative "line"
+require_relative "embell"
+require_relative "char"
+require_relative "pile"
+require_relative "tmpl"
+require_relative "font"
+require_relative "matrix"
+require_relative "size"
+
+module Mathtype3
+  class RecordEnd < Mathtype::RecordEnd; end
+  class RecordNudge < Mathtype::RecordNudge; end
+  class RecordRuler < Mathtype::RecordRuler; end
+  class RecordNudge < Mathtype::RecordNudge; end
+  class RecordFull < Mathtype::RecordFull; end
+  class RecordSub < Mathtype::RecordSub; end
+  class RecordSub2 < Mathtype::RecordSub2; end
+  class RecordSym < Mathtype::RecordSym; end
+  class RecordSubsym < Mathtype::RecordSubsym; end
+
+  HALIGN = Mathtype::HALIGN
+  VALIGN = Mathtype::VALIGN
+
+  RECORD_NAMES = {
+    0 => "end",
+    1 => "slot",
+    2 => "char",
+    3 => "tmpl",
+    4 => "pile",
+    5 => "matrix",
+    6 => "embell",
+    7 => "ruler",
+    8 => "font",
+    9 => "size",
+    10 => "full",
+    11 => "sub",
+    12 => "sub2",
+    13 => "sym",
+    14 => "subsym",
+  }
+
+  OPTIONS = {
+    # value => symbol                     # description
+    # Option flag values for all equation structure records:
+    "xfLMOVE" => 0x08,              # nudge values follow tag
+    # Option flag values for CHAR records:
+    "xfLAUTO" => 0x01,        # character is followed by an embellishment list
+    "xfEMBELL" => 0x02,    # character starts a function (sin, cos, etc.)
+    # Option flag values for LINE records:
+    "xfNULL" => 0x01,          # line is a placeholder only (i.e. not displayed)
+    "xfLSPACE" => 0x04,        # line spacing value follows tag
+    # Option flag values for LINE and PILE records:
+    "xfRULER" => 0x02,           # RULER record follows LINE or PILE record
+  }
+
+  class Payload < BinData::Choice
+    opt = {:_options => :options}
+    record_end 0 # end is a reserved keyword
+    record_line 1, opt
+    record_char 2, opt
+    record_tmpl 3, opt
+    record_pile 4, opt
+    record_matrix 5, opt
+    record_embell 6, opt
+    record_ruler 7, opt
+    record_font 8, opt
+    record_size 9, opt
+    record_full 10, opt
+    record_sub 11, opt
+    record_sub2 12, opt
+    record_sym 13, opt
+    record_subsym 14, opt
+  end
+
+  ## Payload is the most important class to understand.
+  ## This abstraction allows recursive formats.
+  ## eg. lists can contain lists can contain lists.
+
+  class NamedRecord < BinData::Record
+    bit4 :record_options
+    bit4 :record_type
+    payload :payload, :onlyif => :not_end_tag?, :selection => :record_type, :options => :record_options
+
+    def not_end_tag?
+      record_type != 0
+    end
+  end
+
+  class Equation < Mathtype::Equation
+    EXPOSED_IN_SNAPSHOT = %i(mtef_version platform product product_version
+      product_subversion equation)
+
+    array :equation, read_until: lambda { element.record_type == 0 } do
+      named_record
+    end
+  end
+end

data/lib/records3/options.rb

@@ -0,0 +1,5 @@
+module Mathtype3
+  class mtef_options < BinData::Record
+    
+  end
+end

data/lib/records3/pile.rb

@@ -0,0 +1,43 @@
+require_relative "snapshot"
+
+# PILE record (4):
+
+# Consists of:
+
+# record type (4)
+# options
+# [nudge] if mtefOPT_NUDGE is set
+# [halign] horizontal alignment
+# [valign] vertical alignment
+# [[RULER record]] if mtefOPT_LP_RULER is set
+# [object list] list of lines contained by the pile
+
+module Mathtype3
+  class RecordPile < BinData::Record
+    include Snapshot
+    EXPOSED_IN_SNAPSHOT = %i(options halign valign object_list)
+
+    mandatory_parameter :_options
+
+    virtual :options, :value => lambda{ _options }
+
+    record_nudge :nudge, onlyif: lambda { _options & OPTIONS["xfLMOVE"] > 0 }
+
+    int8 :_halign
+    int8 :_valign
+
+    record_ruler :ruler, onlyif: lambda { _options & OPTIONS["xfRULER"] > 0 }
+
+    array :object_list, read_until: lambda { element.record_type == 0 } do
+      named_record
+    end
+
+    def halign
+      HALIGN[_halign]
+    end
+
+    def valign
+      VALIGN[_valign]
+    end
+  end
+end

data/lib/records3/size.rb

@@ -0,0 +1,75 @@
+require_relative "snapshot"
+
+# SIZE record (9):
+# Consists of one of the following cases:
+
+# if lsize < 0 (explicit point size):
+# record type (9)
+# 101
+# -point size (16 bit integer)
+# else if -128 < dsize < +128:
+# record type (9)
+# lsize (typesize)
+# dsize + 128
+# else: (large delta)
+# record type (9)
+# 100
+# lsize (typesize)
+# dsize (16 bit integer)
+# Sizes in MathType are represented as a pair of values, lsize and dsize. Lsize
+# stands for "logical size", dsize for "delta size". If it is negative, it is an
+# explicit point size (in 32nds of a point) negated and dsize is ignored.
+# Otherwise, lsize is a typesize value and dsize is a delta from that size:
+# Simple typesizes, without a delta value, are written using the records
+# described in the next section.
+
+module Mathtype3
+  class RecordSize < BinData::Record
+    include Snapshot
+    EXPOSED_IN_SNAPSHOT = %i(options lsize dsize point_size)
+
+    endian :little
+
+    mandatory_parameter :_options
+
+    virtual :_tag_options, :value => lambda{ _options }
+
+    int8 :_size_select
+
+    mtef16 :_point_size, onlyif: lambda { _size_select == 101 }
+    uint8 :_lsize_large_delta, onlyif: lambda { _size_select == 100 }
+
+    uint8 :_dsize, onlyif: lambda { _size_select != 100 && _size_select != 101 }
+    mtef16 :_dsize_large, onlyif: lambda { _size_select == 100 }
+
+    def dsize
+      case _size_select
+      when 100
+        _dsize_large / 32
+      when 101
+        nil
+      else
+        (_dsize - 128) / 32 # in 32nds of a point
+      end
+    end
+
+    def lsize
+      case _size_select
+      when 100
+        _lsize_large_delta
+      when 101
+        nil
+      else
+        _size_select
+      end
+    end
+
+    def point_size
+      -_point_size if _point_size != 0
+    end
+
+    def options
+      _tag_options
+    end
+  end
+end