mathtype 0.0.2

data/lib/records/mtef.rb

@@ -0,0 +1,118 @@
+require_relative "end"
+require_relative "nudge"
+require_relative "ruler"
+require_relative "line"
+require_relative "embell"
+require_relative "char"
+require_relative "pile"
+require_relative "tmpl"
+require_relative "eqn_prefs"
+require_relative "font_def"
+require_relative "typesizes"
+require_relative "font_style_def"
+require_relative "matrix"
+require_relative "encoding_def"
+require_relative "embell"
+require_relative "size"
+require_relative "color"
+require_relative "color_def"
+require_relative "future"
+
+module Mathtype
+  RECORD_NAMES = {
+    0 => "end",
+    1 => "slot",
+    2 => "char",
+    3 => "tmpl",
+    4 => "pile",
+    5 => "matrix",
+    6 => "embell",
+    7 => "ruler",
+    8 => "font_style_def",
+    9 => "size",
+    10 => "full",
+    11 => "sub",
+    12 => "sub2",
+    13 => "sym",
+    14 => "subsym",
+    15 => "color",
+    16 => "color_def",
+    17 => "font_def",
+    18 => "eqn_prefs",
+    19 => "encoding_def",
+    100 => "future"
+  }
+
+  OPTIONS = {
+    # value => symbol                     # description
+    # Option flag values for all equation structure records:
+    "mtefOPT_NUDGE" => 0x08,              # nudge values follow tag
+    # Option flag values for CHAR records:
+    "mtefOPT_CHAR_EMBELL" => 0x01,        # character is followed by an embellishment list
+    "mtefOPT_CHAR_FUNC_START" => 0x02,    # character starts a function (sin, cos, etc.)
+    "mtefOPT_CHAR_ENC_CHAR_8" => 0x04,    # character is written with an 8-bit encoded value
+    "mtefOPT_CHAR_ENC_CHAR_16" => 0x10,   # character is written with an 16-bit encoded value
+    "mtefOPT_CHAR_ENC_NO_MTCODE" => 0x20, # character is written without an 16-bit MTCode value
+    # Option flag values for LINE records:
+    "mtefOPT_LINE_NULL" => 0x01,          # line is a placeholder only (i.e. not displayed)
+    "mtefOPT_LINE_LSPACE" => 0x04,        # line spacing value follows tag
+    # Option flag values for LINE and PILE records:
+    "mtefOPT_LP_RULER" => 0x02,           # RULER record follows LINE or PILE record
+    # Option flag values for COLOR_DEF records:
+    "mtefCOLOR_CMYK" => 0x01,             # color model is CMYK, else RGB
+    "mtefCOLOR_SPOT" => 0x02,             # color is a spot color, else a process color
+    "mtefCOLOR_NAME" => 0x04,             # color has a name, else no name
+  }
+
+  ## Payload is the most important class to understand.
+  ## This abstraction allows recursive formats.
+  ## eg. lists can contain lists can contain lists.
+
+  class Payload < BinData::Choice
+    record_end 0 # end is a reserved keyword
+    record_line 1
+    record_char 2
+    record_tmpl 3
+    record_pile 4
+    record_matrix 5
+    record_embell 6
+    record_ruler 7
+    record_font_style_def 8
+    record_size 9
+    record_full 10
+    record_sub 11
+    record_sub2 12
+    record_sym 13
+    record_subsym 14
+    record_color 15
+    record_color_def 16
+    record_font_def 17
+    record_eqn_prefs 18
+    record_encoding_def 19
+    record_future 100
+  end
+
+  class NamedRecord < BinData::Record
+    int8 :record_type
+    payload :payload, :onlyif => :not_end_tag?, :selection => :record_type
+
+    def not_end_tag?
+      record_type != 0
+    end
+  end
+
+  class Equation < BinData::Record
+    endian :little
+    uint8 :mtef_version
+    uint8 :platform
+    uint8 :product
+    uint8 :product_version
+    uint8 :product_subversion
+    stringz :application_key
+    uint8 :equation_options
+
+    array :equation, read_until: lambda { element.record_type == 0 } do
+      named_record
+    end
+  end
+end

data/lib/records/nudge.rb

@@ -0,0 +1,34 @@
+# Nudge values:
+# LINE, CHAR, TMPL, PILE, MATRIX, and EMBELL records may store the result of
+# nudging (small offsets applied by the user). A nudged record has the
+# mtefOPT_NUDGE option (0x8) and the option byte is followed immediately by
+# the nudge offset. The nudge offset consists of either two bytes or six,
+# depending on the amount of offset. If -128 <= dx < +128 and
+# -128 <= dy < +128, then the offsets are stored as two bytes, dx followed
+# by dy, where each value has 128 added to it before it is written. Otherwise,
+# two bytes of 128 are stored, followed by the offsets, dx and dy, stored as
+# 16-bit values, low byte followed by high byte.
+
+require_relative "snapshot"
+
+module Mathtype
+  class Nudge < BinData::Record
+    include Snapshot
+    EXPOSED_IN_SNAPSHOT = %i(dx dy)
+
+    endian :little
+
+    int8 :_small_dx
+    int8 :_small_dy
+    int16 :_large_dx, :onlyif => lambda { _small_dx == 128 }
+    int16 :_large_dy, :onlyif => lambda { _small_dy == 128 }
+
+    def dx
+      _small_dx == 128 ? _large_dx : (_small_dx - 128)
+    end
+
+    def dy
+      _small_dy == 128 ? _large_dy : (_small_dy - 128)
+    end
+  end
+end

data/lib/records/pile.rb

@@ -0,0 +1,28 @@
+# 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 Mathtype
+  class RecordPile < BinData::Record
+    int8 :options
+
+    nudge :nudge, onlyif: lambda { options & OPTIONS["mtefOPT_NUDGE"] > 0 }
+
+    int8 :halign
+    int8 :valign
+
+    record_ruler :ruler, onlyif: lambda { options & OPTIONS["mtefOPT_LP_RULER"] > 0 }
+
+    array :object_list, read_until: lambda { element.record_type == 0 } do
+      named_record
+    end
+  end
+end

data/lib/records/ruler.rb

@@ -0,0 +1,22 @@
+# RULER record (7):
+# Consists of:
+# record type (7)
+# [n_stops] number of tab-stops
+# [tab-stop list] tab-stops in order from left-to-right
+# Each tab stop is described by a tab-stop type
+# (0 for left, 1 for center, 2 for right, 3 for equal, 4 for decimal),
+# followed by a 16-bit integer offset from the left end of the slot or pile
+# with which it is associated.
+
+module Mathtype
+  class RecordRuler < BinData::Record
+    endian :little
+
+    int8 :n_stops
+
+    array :tab_stops, initial_length: :n_stops do
+      int8 :tab_stop_type
+      int16 :tab_stop
+    end
+  end
+end

data/lib/records/size.rb

@@ -0,0 +1,44 @@
+# 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 Mathtype
+  class RecordSize < BinData::Record
+    endian :little
+    int8 :lsize
+
+    uint16 :point_size, onlyif: lambda { lsize == 101 }
+
+    dsize_choice = lambda do
+      if lsize == 100
+        100
+      elsif lsize != 100 && lsize != 101
+        0
+      end
+    end
+
+    choice :dsize, selection: dsize_choice do
+      uint16 100
+      uint16 0
+    end
+  end
+end

data/lib/records/snapshot.rb

@@ -0,0 +1,19 @@
+require "bindata"
+
+module Mathtype
+  module Snapshot
+    def snapshot
+      snapshot = BinData::Record::Snapshot.new
+      exposed = self.class.const_get(:EXPOSED_IN_SNAPSHOT)
+      exposed.each do |name|
+        obj = find_obj_for_name(name)
+        if obj
+          snapshot[name] = obj.snapshot if include_obj?(obj)
+        else
+          snapshot[name] = self.send(name)
+        end
+      end
+      snapshot
+    end
+  end
+end