[BACK]Return to lontexconvert.pm CVS log [TXT] [DIR] Up to [LON-CAPA] / loncom / xml

Diff for /loncom/xml/lontexconvert.pm between versions 1.68 and 1.112.2.4

version 1.68, 2005/08/16 16:29:53 version 1.112.2.4, 2014/06/18 06:48:47
Line 42  package Apache::lontexconvert; Line 42  package Apache::lontexconvert;
 use strict;  use strict;
 use tth();  use tth();
 use vars qw($errorstring);  use vars qw($errorstring);
 use Apache();  #use Apache::lonxml();
 use Apache::lonmsg();  
 use Apache::lonxml();  
 use Apache::lonmenu();  
 use Apache::lonlocal;  use Apache::lonlocal;
 use Apache::lonnet;  use Apache::lonnet;
   use lib '/home/httpd/lib/perl/';
   use LONCAPA;
   use URI::Escape;
   use IO::Socket::INET;
   
   
   #
   # Table of substitutions to unicode characters.
   #
   
   my %unicode_harpoons = (
                           '\rightleftharpoons'  => 0x21cc,
                         );
   
   my %unicode_translations = (
   
   # Brackets - unicode for browsers/OS which support it.
   
       ''             => 0x23a1,
       ''             => 0x23a2,
       ''             => 0x23a3,
       ''             => 0x23a4,
       ''             => 0x23a5,
       ''             => 0x23a6,
   
   #  Parens - unicode for browsers/OS which support it
   
       ''              => 0x239b,
       ''              => 0x239c,
       ''              => 0x239d,
       ''              => 0x239e,
       ''              => 0x239f,
       ''              => 0x23a0,
   
   );
   
   my %ascii_8bit_translations = (
   
   # Brackets - pure 8-bit ascii ugliness for browsers/OS which can't handle unicode
   
       ''              => 0x5b,
       ''              => 0x5b,    # '['
       ''              => 0x5b,
       ''              => 0x5d,    # ']'
       ''              => 0x5d,
       ''              => 0x5d,
   
   # Parens - pure 8-bit ascii ugliness for browsers/OS which can't handle unicode
   
       ''              => 0x28,
       ''              => 0x28,      # '('
       ''              => 0x28,
       ''              => 0x29,
       ''              => 0x29,      # '('
       ''              => 0x29,
   
   );
   
   ##
   # Utility to convert elements of a string to unicode:
   #
   # @param input - Input string
   # @param pattern - Pattern to convert
   # @param unicode - Unicode to substitute for pattern.
   #
   # @return string - resulting string.
   # 
   sub unicode_subst {
       my ($input, $pattern, $unicode) = @_;
       
       my $char = pack('U', $unicode);
   
       $input =~ s/$pattern/$char/g;
   
       return $input;
   }
   
 # ====================================================================== Header  # ====================================================================== Header
   
 sub init_tth {  sub init_tth {
     my $options=$env{'course.'.$env{'request.course.id'}.'.tthoptions'};      my $options=$env{'course.'.$env{'request.course.id'}.'.tthoptions'};
       if ($options =~ /\S/) {
    $options = ' '.$options;
       } else {
    undef($options);
       }
     if ($env{'browser.mathml'}) {      if ($env{'browser.mathml'}) {
  &tth::ttminit();   &tth::ttminit();
  if ($env{'browser.unicode'}) {   if ($env{'browser.unicode'}) {
     &tth::ttmoptions('-L -u1 '.$options);      &tth::ttmoptions('-L -u1'.$options);
  } else {   } else {
     &tth::ttmoptions('-L -u0 '.$options);      &tth::ttmoptions('-L -u0'.$options);
  }   }
     } else {      } else {
  &tth::tthinit();   &tth::tthinit();
  if ($env{'browser.unicode'}) {   if ($env{'browser.unicode'}) {
     &tth::tthoptions('-L -u1 '.$options);      &tth::tthoptions('-L -u1'.$options);
  } else {   } else {
     &tth::tthoptions('-L -u0 '.$options);      &tth::tthoptions('-L -u0'.$options);
  }   }
     }      }
 }  }
   
 sub header {  
     $errorstring='';  
     my $time=time;  
     &init_tth();  
     return &Apache::lonxml::xmlbegin().  
  "\n<head>\n".  
  &Apache::lonxml::fontsettings().  
  &Apache::lonmenu::registerurl(undef,'tex').  
  "\n</head>\n";  
 }  
   
 # ================================================================== Conversion  # ================================================================== Conversion
   
 $Apache::lontexconvert::messedup=0;  $Apache::lontexconvert::messedup=0;
   
 # we need this routine because &converted can get called from inside  
 # of the safespace (through &xmlparse('<m>stuff</m>') which doesn't  
 # allow the opcode for alarm, so we need to compile this before we get  
 # into the safe space since opcode checks only occur at compile time  
 sub convert_real {  sub convert_real {
     my ($texstring)=@_;      my ($texstring)=@_;
     my ($xmlstring,$errorstring);      my ($xmlstring,$errorstring);
Line 115  sub convert_real { Line 179  sub convert_real {
     $xmlstring=~s/^\s*//;      $xmlstring=~s/^\s*//;
     $xmlstring=~s/\s*$//;      $xmlstring=~s/\s*$//;
     &Apache::lonxml::end_alarm();      &Apache::lonxml::end_alarm();
   
       #
       # Several strings produced by tth require
       # transliteration -> unicode equivalents to render reliably
       # in browsers. %unicode_translations and %unicode_harpoons are tables of
       # string->substitution which we now apply. (%ascii_8bit_translations used
       # instead for Windows XP and mobile devices.
   
       my $use_ascii;
       if ($env{'browser.os'} eq 'win') {
           if (($env{'browser.osversion'}) && ($env{'browser.osversion'} < 6.0)) {
               $use_ascii = 1;
           }
       }
       if ($env{'browser.mobile'}) {
           $use_ascii = 1;
       }
   
       foreach my $pattern (keys(%unicode_translations)) {
    my $unicode = $unicode_translations{$pattern};
    if ($use_ascii) {
       $unicode = $ascii_8bit_translations{$pattern};
    }
    $xmlstring = &unicode_subst($xmlstring, $pattern, $unicode);
       }
   
       foreach my $pattern (keys(%unicode_harpoons)) {
           $xmlstring = &unicode_subst($xmlstring, $pattern, $unicode_harpoons{$pattern});
       }
   
     return ($xmlstring,$errorstring);      return ($xmlstring,$errorstring);
 }  }
   
Line 137  ENDCONV Line 231  ENDCONV
  $errorstring) {   $errorstring) {
  &Apache::lonnet::logthis("Trying to kill myself");   &Apache::lonnet::logthis("Trying to kill myself");
  $Apache::lontexconvert::messedup=1;   $Apache::lontexconvert::messedup=1;
  my $request=Apache->request();   if (ref($Apache::lonxml::request)) {
  $request->child_terminate();      $Apache::lonxml::request->child_terminate();
    } else {
       my $request;
       eval { $request=Apache->request; };
       if (!$request) {
    eval { $request=Apache2::RequestUtil->request; };
       }
       if ($request) {
    $request->child_terminate();
       } else {
    &Apache::lonnet::logthis("Unable to find a request to do child_terminate on");
       }
    }
     }      }
     return $xmlstring;      return $xmlstring;
 }  }
   
 sub clean_out_math_mode {  sub clean_out_math_mode {
     my ($texstring)=@_;      my ($texstring)=@_;
     $$texstring=~s/(?!\\)\$//g;      $$texstring=~s/(?<!\\)\$//g;
     $$texstring=~s/\\[\)\(\]\[]//g;      $$texstring=~s/\\[\)\(\]\[]//g;
     $$texstring=~s/\\ensuremath//g;      $$texstring=~s/\\ensuremath//g;
     return '';      return '';
Line 153  sub clean_out_math_mode { Line 259  sub clean_out_math_mode {
   
 sub displaystyle {  sub displaystyle {
     my ($texstring)=@_;      my ($texstring)=@_;
     #has a $$ or \[ or \displaystyle in it, guessinng it's display mode      #has a $$ or \[ or \displaystyle or eqnarray in it, guessinng it's display mode
     if ($$texstring=~/[^\\]\$\$/ ||      if ($$texstring=~/[^\\]\$\$/ ||
  $$texstring=~/\\\[/ ||          $$texstring=~/\\\[/ ||
  $$texstring=~/\\displaystyle/) { return 1; }          $$texstring=~/\\displaystyle/ ||
           $$texstring=~/eqnarray/
          ) { return 1; }
     return 0;      return 0;
 }  }
   
   sub MathJax_converted {
       my $texstring=shift;
       my $tag='math/tex;';
       if (&displaystyle($texstring)) { $tag='math/tex; mode=display'; }
       &clean_out_math_mode($texstring);
       return &MathJax_header().
         '<script type="'.$tag.'">'.$$texstring.'</script>';
   }
   
   {
       #Relies heavily on the previous jsMath installation
       my @MathJax_sent_header;
       sub MathJax_reset {
           undef(@MathJax_sent_header);
       }
       sub MathJax_push {
           push(@MathJax_sent_header,0);
       }
       sub MathJax_header {
           if (!@MathJax_sent_header) {
               &Apache::lonnet::logthis("mismatched calls of MathJax_header and MathJax_process");
               return '';
           }
           return '' if $MathJax_sent_header[-1];
           $MathJax_sent_header[-1]=1;
           return
             '<script type="text/javascript" src="/adm/MathJax/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>'."\n";
       }
   }
   
   
 sub jsMath_converted {  sub jsMath_converted {
     my $texstring=shift;      my $texstring=shift;
     my $tag='span';      my $tag='span';
Line 170  sub jsMath_converted { Line 309  sub jsMath_converted {
 }  }
   
 {  {
     my $jsMath_sent_header;      my @jsMath_sent_header;
     sub jsMath_reset {      sub jsMath_reset {
  $jsMath_sent_header=0;   undef(@jsMath_sent_header);
       }
       sub jsMath_push {
    push(@jsMath_sent_header,0);
     }      }
     sub jsMath_header {      sub jsMath_header {
  return '' if $jsMath_sent_header;   if (!@jsMath_sent_header) {
  $jsMath_sent_header=1;      &Apache::lonnet::logthis("mismatched calls of jsMath_header and jsMath_process");
       return '';
    }
    return '' if $jsMath_sent_header[-1];
    $jsMath_sent_header[-1]=1;
  return   return
             '<script type="text/javascript">              '<script type="text/javascript">
                      function NoFontMessage () {}                       function NoFontMessage () {}
                        jsMath = {Parser: {prototype: {environments: {\'eqnarray*\' :[\'Array\',null,null,\'rcl\',[5/18,5/18],3,\'D\']}}}};
                    </script>'."\n".                     </script>'."\n".
     '<script src="/adm/jsMath/jsMath.js"></script>'."\n";      '<script type="text/javascript" src="/adm/jsMath/jsMath.js"></script>'."\n";
     }      }
     sub jsMath_process {      sub jsMath_process {
  return '' if !$jsMath_sent_header;   my $state = pop(@jsMath_sent_header);
  return '<script type="text/javascript">jsMath.Process()</script>';   return '' if !$state;
    return "\n".
       '<script type="text/javascript">jsMath.Process()</script>'."\n";
       }
       sub jsMath_state {
    my ($level) = @_;
    return $jsMath_sent_header[$level];
       }
   }
   
   sub tex_engine {
       if (exists($env{'form.texengine'})) {
    if ($env{'form.texengine'} ne '') {
               return $env{'form.texengine'};
           }
       }    
       if ($env{'request.course.id'}
    && exists($env{'course.'.$env{'request.course.id'}.'.texengine'})) {
    return $env{'course.'.$env{'request.course.id'}.'.texengine'};
       }
       if (exists($env{'environment.texengine'})) {
    return $env{'environment.texengine'};
     }      }
       return 'tth';
   }
   
   sub init_math_support {
       my ($inherit_jsmath) = @_;
       &init_tth();
       &Apache::lontexconvert::jsMath_push();
       if (lc(&tex_engine()) eq 'jsmath' ||
    ($inherit_jsmath && &jsMath_state(-2))) {
    return &Apache::lontexconvert::jsMath_header();
       }
       &Apache::lontexconvert::MathJax_push();
       if (lc(&tex_engine()) eq 'mathjax') { # ||
           #($inherit_jsmath && &jsMath_state(-2))) {
           return &Apache::lontexconvert::MathJax_header();
       }
       return;
   }
   
   sub mimetex_valign {
       my ($esc_texstring)=@_;
       my $valign = 0;
       my $path = '/cgi-bin/mimetex.cgi?'.$esc_texstring;
       my $socket;
       &Apache::lonxml::start_alarm();
       $socket = IO::Socket::INET->new(PeerAddr => 'localhost',
                                       PeerPort => 'http(80)',
                                       Proto    => 'tcp');
       if ($socket) {
           my $headreq = "HEAD $path HTTP/1.0\r\n\r\n";
           print $socket $headreq;
           while (<$socket>) {
               if (/Vertical\-Align\:\s*?([\-\d]+)/) {
                   $valign = $1;
               }
           }
           $socket->close();
       }
       &Apache::lonxml::end_alarm();
       return $valign;
 }  }
   
 sub mimetex_converted {  sub mimetex_converted {
     my $texstring=shift;      my $texstring=shift;
   
   # Alt-Argument for screen readers
       my $alt_string=$$texstring;
       $alt_string=~s/\"/\'\'/g;
   
   # Is this displaystyle?
   
     my $displaystyle=&displaystyle($texstring);      my $displaystyle=&displaystyle($texstring);
   
   # Remove math environment delimiters
   
     &clean_out_math_mode($texstring);      &clean_out_math_mode($texstring);
   
     if ($displaystyle) {      if ($displaystyle) {
  $$texstring='\\displaystyle \\Large '.$$texstring;   $$texstring='\\displaystyle \\Large '.$$texstring;
     }      }
     my $result='<img src="/cgi-bin/mimetex.cgi?'.&Apache::lonnet::escape($$texstring).'" />';      my $esc_texstring = &uri_escape($$texstring);
       my $valign = &mimetex_valign($esc_texstring);
       my $result='<img src="/cgi-bin/mimetex.cgi?'.$esc_texstring.'" style="vertical-align:'.$valign.'px" alt="'.$alt_string.'" />';
     if ($displaystyle) {      if ($displaystyle) {
  $result='<center>'.$result.'</center>';   $result='<div style="text-align:center">'.$result.'</div>';
     }      }
     return $result;      return $result;
 }  }
   
 sub converted {  sub converted {
     my ($string,$mode)=@_;      my ($string,$mode)=@_;
     if ($mode eq '') { $mode=$env{'environment.texengine'}; }      if ($mode eq '') { $mode = &tex_engine(); }
     if ($mode =~ /tth/i) {      if ($mode =~ /tth/i) {
  return &tth_converted($string);   return &tth_converted($string);
     } elsif ($mode =~ /jsmath/i) {      } elsif ($mode =~ /jsmath/i) {
  return &jsMath_converted($string);   return &jsMath_converted($string);
       } elsif ($mode =~ /mathjax/i) {
           return &MathJax_converted($string);
     } elsif ($mode =~ /mimetex/i) {      } elsif ($mode =~ /mimetex/i) {
  return &mimetex_converted($string);   return &mimetex_converted($string);
       } elsif ($mode =~ /raw/i) {
           return $$string;
     }      }
     return &tth_converted($string);      return &tth_converted($string);
 }  }
   
 # ====================================================================== Footer  
   
 sub footer {  
   my $xmlstring='';  
   if ($env{'request.state'} eq 'construct') {  
       $xmlstring.='<address>'.$errorstring.'</address>';  
   } else {  
       &Apache::lonmsg::author_res_msg($env{'request.filename'},$errorstring);  
   }  
 # -------------------------------------------------------------------- End Body  
   $xmlstring.=&Apache::lonxml::xmlend();  
   return $xmlstring;  
 }  
   
 # ------------------------------------------------------------ Message display  # ------------------------------------------------------------ Message display
   
 sub to_convert {  sub to_convert {
     my ($string) = @_;      my ($string) = @_;
       &init_tth();
     $string=~s/\<br\s*\/?\>/ /gs;      $string=~s/\<br\s*\/?\>/ /gs;
 #    $string=~s/\s/ /gs;  #    $string=~s/\s/ /gs;
     $string=&HTML::Entities::decode($string);      $string=&HTML::Entities::decode($string);
Line 244  sub to_convert { Line 454  sub to_convert {
   
 sub smiley {  sub smiley {
     my $expression=shift;      my $expression=shift;
     if ($env{'browser.imagesuppress'} eq 'on') { return $expression; }      my %smileys=(
     my %smileys=('\:\-\)' => 'smiley',      '\:\-*\)' => 'face-smile.png',
  '8\-\)'  => 'coolsmile',   '8\-\)'  => 'face-cool.png',
  '8\-(I|\|)'   => 'coolindiff',   '8\-(I|\|)'   => 'face-glasses.png',
  ':\-(I|\|)'   => 'neutral',   '\:\-(I|\|)'   => 'face-plain.png',
  '\:\-(o|O|\(\))' => 'shocked',   '\:\-(o|O|\(\))' => 'face-surprise.png',
  ':\-\('  => 'frowny',   ':\-\('  => 'face-sad.png',
  '\;\-\)' => 'wink',   '\;\-\)' => 'face-wink.png',
  '\:\-P'  => 'baeh',   '\:\-(P|p)'  => 'face-raspberry.png',
  '\:\-(\\\|\\/)' => 'hrrm',   '\:\-(\\\|\\/)' => 'face-uncertain.png',
  '\:\-D'  => 'bigsmile',   '\:\-D'  => 'face-smile-big.png',
  '\:\-C'  => 'angry',   '\:\-(C|\@)'  => 'face-angry.png',
  '\:(\'|\`)\-\(' => 'cry',   '\:(\'|\`)\-*\(' => 'face-crying.png',
  '\:\-(X|\#)' => 'lipsrsealed',   '\:\-(X|x|\#)' => 'face-quiet.png',
  '\:\-S' => 'huh');   '\:\-(s|S)' => 'face-uncertain.png',
    '\:\-\$' => 'face-embarrassed.png',
    '\:\-\*' => 'face-kiss.png',
    '\+O\(' => 'face-sick.png',
    '(\&lt\;3|\(heart\))' => 'heart.png',
    '\(rose\)' => 'rose.png',
    '\(pizza\)' => 'food-pizza.png',
    '\(cake\)' => 'food-cake.png',
    '\(ninja\)' => 'face-ninja.png',
    '\(pirate\)' => 'face-pirate.png',
    '\((agree|yes)\)' => 'opinion-agree.png',
    '\((disagree|nay)\)' => 'opinion-disagree.png',
    '(o|O)\-\)' => 'face-angel.png',
    );
     my $iconpath=$Apache::lonnet::perlvar{'lonIconsURL'};      my $iconpath=$Apache::lonnet::perlvar{'lonIconsURL'};
     foreach (keys %smileys) {      foreach my $smiley (keys(%smileys)) {
  $expression=~s/$_/\<img src="$iconpath\/$smileys{$_}.gif" \/\>/gs;    $expression=~s/$smiley/\<img src="$iconpath\/$smileys{$smiley}" \/\>/gs; 
     }      }
     return $expression;      return $expression;
 }  }
Line 269  sub smiley { Line 492  sub smiley {
 sub msgtexconverted {  sub msgtexconverted {
     my ($message,$email) = @_;      my ($message,$email) = @_;
     $errorstring='';      $errorstring='';
     &init_tth();  
     my $outmessage='';      my $outmessage='';
     my $tex=0;      my $tex=0;
     foreach (split(/(?:\&lt\;|\<)\/*m\s*(?:\&gt\;|\>)/i,$message)) {      foreach my $fragment (split(/(?:\&lt\;|\<)\/*m\s*(?:\&gt\;|\>)/i,$message)) {
  if ($tex) {   if ($tex) {
     if ($email) {      if ($email) {
  $outmessage.='</pre><tt>'.&to_convert($_).'</tt><pre>'; $tex=0;   $outmessage.='</pre><tt>'.&to_convert($fragment).'</tt><pre>';
    $tex=0;
     } else {      } else {
  $outmessage.=&to_convert($_); $tex=0;   $outmessage.=&to_convert($fragment);
    $tex=0;
     }      }
  } else {   } else {
             $outmessage.=&smiley($_); $tex=1;              $outmessage.=&smiley($fragment);
       $tex=1;
  }   }
     }      }
     $message=$outmessage; $outmessage=''; $tex=0;      $message=$outmessage; $outmessage=''; $tex=0;
     foreach (split(/(?:\&lt\;|\<)\/*algebra\s*(?:\&gt\;|\>)/i,$message)) {      foreach my $fragment (split(/(?:\&lt\;|\<)\/*algebra\s*(?:\&gt\;|\>)/i,
    $message)) {
  if ($tex) {   if ($tex) {
           my $algebra = &algebra($fragment, 'web', undef, undef, undef, 'tth');
     if ($email) {      if ($email) {
  $outmessage.='</pre><tt>'.&algebra($_,'web').'</tt><pre>'; $tex=0;   $outmessage.='</pre><tt>'.$algebra.'</tt><pre>';
    $tex=0;
     } else {      } else {
  $outmessage.=&algebra($_,'web'); $tex=0;   $outmessage.=$algebra;
    $tex=0;
     }      }
  } else {   } else {
             $outmessage.=$_; $tex=1;          $outmessage.=$fragment;
       $tex=1;
  }   }
     }      }
     if (wantarray) {      if (wantarray) {
Line 304  sub msgtexconverted { Line 534  sub msgtexconverted {
   
 sub algebra {  sub algebra {
     use AlgParser;      use AlgParser;
       my ($string,$target,$style,$parstack,$safeeval,$tth)=@_;
     my ($string,$target,$style)=@_;  
     my $parser = new AlgParserWithImplicitExpand;      my $parser = new AlgParserWithImplicitExpand;
       if ($tth eq 'tth') {&init_tth();}
     $string=&prepare_algebra($string);      $string=&prepare_algebra($string);
     my $ret = $parser->parse($string);      my $ret = $parser->parse($string);
     my $result='['.&mt('Algebra unconverted due to previous errors').']';      my $result='['.&mt('Algebra unconverted due to previous errors').']';
Line 322  sub algebra { Line 552  sub algebra {
     $latex='\\ensuremath{'.$latex.'}';      $latex='\\ensuremath{'.$latex.'}';
  }   }
  if ($target eq 'web' || $target eq 'analyze') {   if ($target eq 'web' || $target eq 'analyze') {
     $result = &converted(\$latex);              my $display=&Apache::lonxml::get_param('display',$parstack,$safeeval);
               $result = &converted(\$latex,$display);
   #    $result = &converted(\$latex);
  } else {   } else {
     $result = $latex;      $result = $latex;
  }   }
Line 346  sub postprocess_algebra { Line 578  sub postprocess_algebra {
     # moodle had these and I don't know why, ignoring them for now      # moodle had these and I don't know why, ignoring them for now
     # $string =~s/\\fun/ /g;      # $string =~s/\\fun/ /g;
   
     # remove the extra () in the denominator of a \frac  
     $string =~s/\\frac{(.+?)}{\\left\((.+?)\\right\)}/\\frac{$1}{$2}/gs;  
       
     # sqrt(3,4) means the 4 root of 3      # sqrt(3,4) means the 4 root of 3
     $string =~s/\\sqrt{([^,]+),([^\}]+)}/\\sqrt[$2]{$1}/gs;      $string =~s/\\sqrt{([^,]+),([^\}]+)}/\\sqrt[$2]{$1}/gs;
   
Line 368  sub postprocess_algebra { Line 597  sub postprocess_algebra {
     $string =~s/\\lim\\left\((.+?),(.+?),(.+?)\\right\)/\\lim_{$2\\to $3}$1/gs;      $string =~s/\\lim\\left\((.+?),(.+?),(.+?)\\right\)/\\lim_{$2\\to $3}$1/gs;
     return $string;      return $string;
 }  }
   
   
 1;  1;
 __END__  __END__
   
   
   =pod
   
   =head1 NAME
   
   Apache::lontexconvert;
   
   =head1 SYNOPSIS
   
   Access to tth/ttm
   
   This is part of the LearningOnline Network with CAPA project
   described at http://www.lon-capa.org.
   
   
   =head1 SUBROUTINES
   
   =over
   
   =item init_tth()
   
   Header
   
   =item convert_real()
   
    we need this routine because &converted can get called from inside
    of the safespace (through &xmlparse('<m>stuff</m>') which doesn't
    allow the opcode for alarm, so we need to compile this before we get
    into the safe space since opcode checks only occur at compile time
   
   =item tth_converted()
   
   
   =item clean_out_math_mode()
   
   
   =item displaystyle()
   
   
   =item jsMath_converted()
   
   =item MathJax_converted()
           - Mimics the jsMath functionality
   
   =item tex_engine()
   
   
   =item init_math_support()
   
   =item mimetex_valign()
   
    Makes a HEAD call to /cgi-bin/mimetex.cgi via IO:: to retrieve the 
    vertical alignment, before the subsequent call to mimetex_converted()
    which generates the <img> tag and the corresponding image.
   
    Input: 1.  $esc_texstring (escaped TeX to be rendered by mimetex).
    Output: 1. $valign - number of pixels: positive or negative integer 
               which will be included in <img> tag for mimetex image to
               support vertical alignment of image within a line of text.
   
    If a server is running SSL, and Apache rewrite rules are in place 
    to rewrite requests for http to https, modification will most likely 
    be needed for pass through for HEAD requests for /cgi-bin/mimetex.cgi. 
   
    Example rewrite rules which rewrite all http traffic to https, 
    except HEAD requests for /cgi-bin/mimetex.cgi are:
   
    <IfModule mod_rewrite.c>
        RewriteEngine On
        RewriteLogLevel 0
   
        RewriteCond %{HTTPS} off
        RewriteCond %{HTTP:Host} (.*)
        RewriteCond %{REQUEST_METHOD} !HEAD 
        RewriteRule ^/(.*) https://%1/$1 [R=301,L]
   
        RewriteCond %{HTTPS} off
        RewriteCond %{HTTP:Host} (.*)
        RewriteCond %{REQUEST_METHOD} HEAD
        RewriteCond %{REQUEST_URI} !^/cgi-bin/mimetex.cgi
        RewriteRule ^/(.*) https://%1/$1 [R=301,L]
    </IfModule>
   
   =item mimetex_converted()
   
   
   =item converted()
   
   
   =item to_convert()
   
   message display
   
   =item smiley()
   
   ???
   
   =item msgtexconverted()
   
   =item algebra()
   
   =item prepare_algebra()
   
   =item postprocess_algebra()
   
   =back
   
   =cut
   
   
   
Removed from v.1.68  
changed lines
  Added in v.1.112.2.4

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>