[WiP] Leavehorizontal

lib/LaTeXML/Common/Font.pm

@@ -646,6 +646,7 @@ sub computeBoxesSize {
       || $STATE->lookupDefinition(T_CS('\hsize'));
     $wrapwidth = $wrapwidth->valueOf if ref $wrapwidth;      # Register or Dimension
     $wrapwidth = $wrapwidth->valueOf if ref $wrapwidth; }    # still Dimension (Register)
+  my $maxwidth = $wrapwidth || 0;
   no warnings 'recursion';
   my @boxes = grep { !(ref $_) || !$_->getProperty('isEmpty') }
     grep { !(ref $_) || $_->can('getSize'); } $boxes->unlist;
@@ -659,24 +660,38 @@ sub computeBoxesSize {
         && (($box->getProperty('mode') || '') eq 'horizontal')) {
         my $width = $box->getProperty('width') || $wrapwidth;
         $width = $width->valueOf if ref $width;
+        $maxwidth = $width if $width && $width > $maxwidth;
         push(@lines, $self->computeBoxesSize_lines($width,
             $self->computeBoxesSize_words($box->unlist))); }
       else {
         my ($w, $h, $d) = $self->computeBoxesSize_box($box);
         push(@lines, [$w, $h, $d]) if $w || $h || $d; } } }
   else {
     # Scan all boxes, collecting into "words", then (possibly) break into lines.
+    # Should get single line, if no $wrapwidth
     my @words = $self->computeBoxesSize_words(@boxes);
     @lines = $self->computeBoxesSize_lines($wrapwidth, @words); }
   # ----------------------------------------------------------------------
   # Now, stack up the multiple lines
   my ($wd, $ht, $dp) = $self->computeBoxesSize_stack($vattach, @lines);
-
+  $wd = $maxwidth if $wd && $maxwidth; # Set to wrapwidth, unless empty.
+  if (my $th = $options{totalheight}) { # divie up totalheight, if requested
+    $th = $th->valueOf;
+    my $diff = $th - $ht - $dp;
+    if ($diff > 0) {
+      if ($vattach eq 'bottom') { $ht += $diff; }
+      elsif ($vattach eq 'middle') { $ht += $diff/2; $dp += $diff/2; }
+      else { $dp += $diff; } } }
   Debug("Size boxes " . join(',', map { $_ . '=' . ToString($options{$_}); } sort keys %options) . "\n"
       . "  Boxes: " . ToString($boxes) . "\n"
       . "  Boxes: " . Stringify($boxes) . "\n"
+      . " Options:" . join(',',map { $_."=".ToString($options{$_}); } sort keys %options)
       . "  Sizes: " . join("\n", map { _showsize(@$_); } @lines) . "\n"
       . "  => " . _showsize($wd, $ht, $dp)) if $LaTeXML::DEBUG{'size-detailed'};
+  $wd += $options{padleft}->valueOf   if $options{padleft};
+  $wd += $options{padright}->valueOf  if $options{padright};
+  $ht += $options{padtop}->valueOf    if $options{padtop};
+  $dp += $options{padbottom}->valueOf if $options{padbottom};
   return (Dimension($wd), Dimension($ht), Dimension($dp)); }
 
 # Compute (w/guards) the size of a single box
@@ -706,6 +721,7 @@ sub computeBoxesSize_words {
   no warnings 'recursion';
   my ($self, @boxes) = @_;
   my @words = ();
+  my @word  = ();
   my $prevbox;
   my $prevspace = 0;
   my $size      = int($self->getSize || DEFSIZE() || 10);
@@ -715,21 +731,22 @@ sub computeBoxesSize_words {
     # Check for possible line-break points
     if ((ref $box) && $box->getProperty('isBreak')) {
       if ($wd || $ht || $dp || ($prevspace > 0)) {
-        push(@words, [$prevspace, $wd, $ht, $dp]);
-        $wd = $ht = $dp = 0; $prevspace = -1; }
+        push(@words, [$prevspace, $wd, $ht, $dp, @word]);
+        $wd = $ht = $dp = 0; $prevspace = -1; @word = (); }
       else {
         $prevspace = -1; } }
     # Pernaps not "isSpace", but excluding struts, neg space, etc ???
     elsif ((ref $box) && $box->getProperty('isSpace') && !$box->getProperty('isVerticalSpace')) {
       if ($wd || $ht || $dp || ($prevspace < 0)) {
-        push(@words, [$prevspace, $wd, $ht, $dp]);
-        $wd = $ht = $dp = 0; $prevspace = $w; }
+        push(@words, [$prevspace, $wd, $ht, $dp, @word]);
+        $wd = $ht = $dp = 0; $prevspace = $w; @word = (); }
       else {
         $prevspace += $w; } }
     else {    # Else accumulate into "word"
       $wd += $w;
       $ht = max($ht, $h);
       $dp = max($dp, $d);
+      push(@word, $box);
       # Kern HACK for lists of individual Box's
       if ($prevbox && (ref $prevbox eq 'LaTeXML::Core::Box') && (ref $box eq 'LaTeXML::Core::Box')) {
         my $prevchar = substr($prevbox->getString || '', -1, 1);
@@ -741,28 +758,32 @@ sub computeBoxesSize_words {
           $wd += $size * $kern; } }
     }
     $prevbox = $box; }
-  if ($wd || $ht || $dp || $prevspace) {    # be sure to get last bit
-    push(@words, [$prevspace, $wd, $ht, $dp]); }
+  if ($wd || $ht || $dp || $prevspace || @word) {    # be sure to get last bit
+    push(@words, [$prevspace, $wd, $ht, $dp, @word]); }
   return @words; }
 
 # do line breaking of words into lines, according to $wrapwidth (if), or explicit breaks.
 sub computeBoxesSize_lines {
   my ($self, $wrapwidth, @words) = @_;
   my @lines = ();
+  my @line  = ();
+  my $fuzz  = Dimension('1pt')->valueOf;
+  my $squeeze = ($wrapwidth ? 0.6 : 1.0); # Let spaces shrink in paragraph mode
   my ($wd, $ht, $dp) = (0, 0, 0);
   foreach my $item (@words) {
-    my ($space, $w, $h, $d) = @$item;
+    my ($space, $w, $h, $d, @word) = @$item;
     if ($space == -1) {
-      push(@lines, [$wd, $ht, $dp]) if $wd;
-      $wd = $w; $ht = $h; $dp = $d; }
-    elsif ((defined $wrapwidth) && ($wd + $space * 0.5 + $w > $wrapwidth)) {
-      push(@lines, [$wrapwidth || $wd, $ht, $dp]) if $wd;
-      $wd = $w; $ht = $h; $dp = $d; }
+      push(@lines, [$wd, $ht, $dp, @line]) if $wd;
+      $wd = $w; $ht = $h; $dp = $d; @line = @word; }
+    elsif ((defined $wrapwidth) && ($wd + $space * 0.5 + $w > $wrapwidth + $fuzz)) {
+      push(@lines, [$wd, $ht, $dp, @line]) if $wd;
+      $wd = $w; $ht = $h; $dp = $d; @line = @word; }
     else {
-      $wd += $space + $w;
+      $wd += $space*$squeeze + $w;
       $ht = max($ht, $h);
-      $dp = max($dp, $d); } }
-  push(@lines, [$wrapwidth || $wd, $ht, $dp]) if $wd || $ht || $dp;
+      $dp = max($dp, $d);
+      push(@line, @word); } }
+  push(@lines, [$wd, $ht, $dp, @line]) if $wd || $ht || $dp;
   return @lines; }
 
 # Sum up a stack of lines, determining w as max, and h & d according to $vattach.
@@ -835,8 +856,9 @@ sub math_bearing {
   return $STATE->lookupDefinition($$mathbearingreg[abs($bearing)])->valueOf->spValue; }
 
 sub _showsize {
-  my ($wd, $ht, $dp) = @_;
-  return ($wd / $UNITY) . " x " . ($ht / $UNITY) . " + " . ($dp / $UNITY); }
+  my ($wd, $ht, $dp, @stuff) = @_;
+  return ($wd / $UNITY) . " x " . ($ht / $UNITY) . " + " . ($dp / $UNITY)
+    . (@stuff ? ' '.join('', map { ToString($_); } @stuff) : ''); }
 
 sub isSticky {
   my ($self) = @_;

lib/LaTeXML/Core/Alignment.pm

@@ -21,8 +21,8 @@ use LaTeXML::Common::XML;
 use LaTeXML::Common::Dimension;
 use LaTeXML::Core::Alignment::Template;
 use List::Util qw(max sum);
-use base       qw(LaTeXML::Core::Whatsit);
-use base       qw(Exporter);
+use base qw(LaTeXML::Core::Whatsit);
+use base qw(Exporter);
 our @EXPORT = (qw(
     &ReadAlignmentTemplate &MatrixTemplate));
 
@@ -165,6 +165,14 @@ sub currentColumn {
   my ($self) = @_;
   return $$self{current_row} && $$self{current_row}->column($$self{current_column}); }
 
+# Used by \multicolumn to replace the current column spec with a new one
+# (the row has been cloned from the overall spec)
+sub replaceColumn {
+  my ($self, $colspec) = @_;
+  $$self{current_row}->replaceColumn($$self{current_column}, $colspec)
+    if $$self{current_row};
+  return; }
+
 sub getColumn {
   my ($self, $n) = @_;
   return $$self{current_row} && $$self{current_row}->column($n); }

lib/LaTeXML/Core/Alignment/Template.pm

@@ -150,6 +150,15 @@ sub column {
         push(@{ $$self{columns} }, {%dup}); } } }
   return ($n > 0 ? $$self{columns}->[$n - 1] : undef); }
 
+# Used by \multicolumn to replace column $n spec with a new one
+# (the row has been cloned from the overall spec)
+sub replaceColumn {
+  my ($self, $n, $colspec) = @_;
+  my $N = scalar(@{ $$self{columns} });
+  if ($n <= $N) {
+    $$self{columns}->[$n] = $colspec; }
+  return; }
+
 sub columns {
   my ($self) = @_;
   return @{ $$self{columns} }; }

lib/LaTeXML/Core/Box.pm

@@ -38,7 +38,7 @@ sub Box {
     $properties{height} = Dimension(0) unless defined $properties{height};
     $properties{depth}  = Dimension(0) unless defined $properties{depth}; }
   my $state = $STATE;
-  my $mode = $properties{mode} || $state->lookupValue('MODE') || 'restricted_horizontal';
+  my $mode  = $properties{mode} || $state->lookupValue('MODE') || 'restricted_horizontal';
   if ($state->lookupValue('IN_MATH')) {
     my $attr      = (defined $string) && $state->lookupValue('math_token_attributes_' . $string);
     my $usestring = ($attr && $$attr{replace}) || $string;
@@ -47,7 +47,7 @@ sub Box {
       mode => $mode, ($attr ? %$attr : ()), %properties); }
   else {
     return LaTeXML::Core::Box->new($string, $font, $locator, $tokens,
-                                   mode => $mode, %properties); } }
+      mode => $mode, %properties); } }
 
 #======================================================================
 # Box Object
@@ -113,10 +113,10 @@ my %mode_abbrev = (
 
 sub _stringify {
   my ($self) = @_;
-  my $type = ref $self;
-  my $mode = $$self{properties}{mode};
+  my $type   = ref $self;
+  my $mode   = $$self{properties}{mode};
   $type =~ s/^LaTeXML::Core:://;
-  $type .= '!'. ($mode_abbrev{$mode} || $mode) if $mode;
+  $type .= '!' . ($mode_abbrev{$mode} || $mode) if $mode;
   return $type; }
 
 sub stringify {
@@ -235,12 +235,6 @@ sub getSize {
     unless (defined $$props{cwidth})
     && (defined $$props{cheight})
     && (defined $$props{cdepth});
-  Debug("SIZE of $self"
-      . "\n preassigned: " . _showsize($$props{width},  $$props{height},  $$props{depth})
-      . "\n calculated : " . _showsize($$props{cwidth}, $$props{cheight}, $$props{cdepth})
-      . "\n w/options " . join(',', map { $_ . "=" . ToString($options{$_}); } sort keys %options)
-      . "\n =>: " . _showsize($$props{width} || $$props{cwidth}, $$props{height} || $$props{cheight}, $$props{depth} || $$props{cdepth})
-      . "\n   Of " . ToString($self)) if $LaTeXML::DEBUG{size};
   return ($$props{width} || $$props{cwidth},
     $$props{height}  || $$props{cheight},
     $$props{depth}   || $$props{cdepth},
@@ -260,19 +254,25 @@ sub showSize {
 #omg
 # Fake computing the dimensions of strings (typically single chars).
 # Eventually, this needs to link into real font data
+our @sizing_properties = (qw(
+    width height depth totalheight vattach layout
+    padtop padbottom padleft padright));
+
 sub computeSizeStore {
   my ($self, %options) = @_;
   no warnings 'recursion';
   my $props = $self->getPropertiesRef;
-  $options{width}   = $$props{width}   if $$props{width};
-  $options{height}  = $$props{height}  if $$props{height};
-  $options{depth}   = $$props{depth}   if $$props{depth};
-  $options{vattach} = $$props{vattach} if $$props{vattach};
-  $options{layout}  = $$props{layout}  if $$props{layout};
+  map { $options{$_} = $$props{$_} if defined $$props{$_}; } @sizing_properties;
   my ($w, $h, $d) = $self->computeSize(%options);
   $$props{cwidth}  = $w unless defined $$props{cwidth};
   $$props{cheight} = $h unless defined $$props{cheight};
   $$props{cdepth}  = $d unless defined $$props{cdepth};
+  Debug("SIZE of $self"
+      . "\n preassigned: " . _showsize($$props{width},  $$props{height},  $$props{depth})
+      . "\n calculated : " . _showsize($$props{cwidth}, $$props{cheight}, $$props{cdepth})
+      . "\n w/options " . join(',', map { $_ . "=" . ToString($options{$_}); } sort keys %options)
+      . "\n =>: " . _showsize($$props{width} || $$props{cwidth}, $$props{height} || $$props{cheight}, $$props{depth} || $$props{cdepth})
+      . "\n   Of " . ToString($self)) if $LaTeXML::DEBUG{size};
   return; }
 
 sub computeSize {

lib/LaTeXML/Core/Definition/Constructor.pm

@@ -79,7 +79,7 @@ sub invoke {
 
   LaTeXML::Core::Definition::startProfiling($profiled, 'digest') if $profiled;
 
-  my @pre = $self->executeBeforeDigest($stomach);
+  $self->executeBeforeDigest($stomach);
 
   Debug('{' . $self->tracingCSName . '}') if $tracing;
   # Get some info before we process arguments...
@@ -116,7 +116,7 @@ sub invoke {
     $whatsit->setBody(@post, $stomach->digestNextBody((ref $cap ? $cap : undef))); @post = (); }
   my @postpost = $self->executeAfterDigestBody($stomach, $whatsit);
   LaTeXML::Core::Definition::stopProfiling($profiled, 'digest') if $profiled;
-  return (@pre, $whatsit, @post, @postpost); }
+  return ($whatsit, @post, @postpost); }
 
 # Similar to executeAfterDigest
 sub executeAfterDigestBody {

lib/LaTeXML/Core/Definition/Primitive.pm

@@ -36,11 +36,16 @@ sub isPrefix {
   my ($self) = @_;
   return $$self{isPrefix}; }
 
+# Execute the beforeDigest functions (on $stomach),
+# pushing the results (if any) directly on the the @LIST being accumulated.
+# returns nothing
 sub executeBeforeDigest {
   my ($self, $stomach) = @_;
   local $LaTeXML::Core::State::UNLOCKED = 1;
   my @pre = grep { defined } @{ $$self{beforeDigest} || [] };
-  return (map { &$_($stomach) } @pre); }
+  foreach my $f (@pre) {
+    push(@LaTeXML::LIST, &$f($stomach)); }
+  return; }
 
 sub executeAfterDigest {
   my ($self, $stomach, @whatever) = @_;
@@ -57,7 +62,8 @@ sub invoke {
 
   LaTeXML::Core::Definition::startProfiling($profiled, 'digest') if $profiled;
   Debug('{' . $self->tracingCSName . '}')                        if $tracing;
-  my @result = ($self->executeBeforeDigest($stomach));
+  $self->executeBeforeDigest($stomach);
+  my @result = ();
   my $parms  = $$self{parameters};
   my @args   = ($parms ? $parms->readArguments($stomach->getGullet, $self) : ());
   Debug($self->tracingArgs(@args)) if $tracing && @args;