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

Diff for /loncom/xml/lontexconvert.pm between versions 1.39 and 1.98.2.1

version 1.39, 2004/07/27 14:17:39 version 1.98.2.1, 2011/02/10 20:07:00
Line 36 Line 36
 # The C source of the Code may not be distributed by the Licensee  # The C source of the Code may not be distributed by the Licensee
 # to any other parties under any circumstances.  # to any other parties under any circumstances.
 #  #
 # 05/29/00,05/30,10/11,10/20 Gerd Kortemeyer  
 # 5/4 Gerd Kortemeyer  
   
 package Apache::lontexconvert;  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 lib '/home/httpd/lib/perl/';
   use LONCAPA;
   use URI::Escape;
   use IO::Socket::INET;
   
 # ====================================================================== 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 ($ENV{'browser.mathml'}) {      if ($options =~ /\S/) {
    $options = ' '.$options;
       } else {
    undef($options);
       }
       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().  
  &Apache::lonxml::fontsettings().  
  "\n<head>\n".  
  &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 100  sub convert_real { Line 91  sub convert_real {
  $Apache::lontexconvert::messedup=1;   $Apache::lontexconvert::messedup=1;
  die &mt("TeX unconverted due to errors");   die &mt("TeX unconverted due to errors");
     };      };
     alarm($Apache::lonnet::perlvar{'lonScriptTimeout'});      &Apache::lonxml::start_alarm();
     if ($ENV{'browser.mathml'}) {      if ($env{'browser.mathml'}) {
  $xmlstring=&tth::ttm($$texstring);   $xmlstring=&tth::ttm($$texstring);
  $xmlstring=~s/\<math\>/\<math xmlns=\"\&mathns\;\"\>/g;   $xmlstring=~s/\<math\>/\<math xmlns=\"\&mathns\;\"\>/g;
  $xmlstring=~s/\<br\>/\<br\/\>/g;   $xmlstring=~s/\<br\>/\<br\/\>/g;
Line 112  sub convert_real { Line 103  sub convert_real {
  $errorstring.=&tth::ttherror();   $errorstring.=&tth::ttherror();
  $xmlstring=~s-</font(\s*)>-</font>-g;   $xmlstring=~s-</font(\s*)>-</font>-g;
     }      }
       $xmlstring=~s/^\s*\<br clear\=\"all\"/\<br/s;
     $xmlstring=~s/^\s*//;      $xmlstring=~s/^\s*//;
     $xmlstring=~s/\s*$//;      $xmlstring=~s/\s*$//;
     alarm(0);      #
       # \rightleftharpoons is not converted by tth but maps
       # reasonably well to &#8660;.  If we get many more of these,
       # we're going to need to have a translation sub.
       #
       my $lrharpoon = pack("U", 0x21cc);
       $xmlstring=~s/\\rightleftharpoons/$lrharpoon/g;
   
       &Apache::lonxml::end_alarm();
     return ($xmlstring,$errorstring);      return ($xmlstring,$errorstring);
 }  }
   
 sub converted {  sub tth_converted {
     my $texstring=shift;      my $texstring=shift;
     my $xmlstring='['.&mt('UNDISPLAYABLE').']';      my $xmlstring='['.&mt('UNDISPLAYABLE').']';
     if ($Apache::lontexconvert::messedup) {      if ($Apache::lontexconvert::messedup) {
  return '['.&mt('TeX unconverted due to previous errors').']';   return '['.&mt('TeX unconverted due to previous errors').']';
     }      }
       $$texstring ='\\documentstyle{article}'.$$texstring;
   
     eval(<<'ENDCONV');      eval(<<'ENDCONV');
     ($xmlstring,$errorstring)=&convert_real($texstring)      ($xmlstring,$errorstring)=&convert_real($texstring)
 ENDCONV  ENDCONV
Line 135  ENDCONV Line 137  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;
 }  }
   
 # ====================================================================== Footer  sub clean_out_math_mode {
       my ($texstring)=@_;
       $$texstring=~s/(?<!\\)\$//g;
       $$texstring=~s/\\[\)\(\]\[]//g;
       $$texstring=~s/\\ensuremath//g;
       return '';
   }
   
   sub displaystyle {
       my ($texstring)=@_;
       #has a $$ or \[ or \displaystyle in it, guessinng it's display mode
       if ($$texstring=~/[^\\]\$\$/ ||
    $$texstring=~/\\\[/ ||
    $$texstring=~/\\displaystyle/) { return 1; }
       return 0;
   }
   
   sub jsMath_converted {
       my $texstring=shift;
       my $tag='span';
       if (&displaystyle($texstring)) { $tag='div'; }
       &clean_out_math_mode($texstring);
       return &jsMath_header().
    '<'.$tag.' class="math">'.$$texstring.'</'.$tag.'>';
   }
   
   {
       my @jsMath_sent_header;
       sub jsMath_reset {
    undef(@jsMath_sent_header);
       }
       sub jsMath_push {
    push(@jsMath_sent_header,0);
       }
       sub jsMath_header {
    if (!@jsMath_sent_header) {
       &Apache::lonnet::logthis("mismatched calls of jsMath_header and jsMath_process");
       return '';
    }
    return '' if $jsMath_sent_header[-1];
    $jsMath_sent_header[-1]=1;
    return
               '<script type="text/javascript">
                        function NoFontMessage () {}
                        jsMath = {Parser: {prototype: {environments: {\'eqnarray*\' :[\'Array\',null,null,\'rcl\',[5/18,5/18],3,\'D\']}}}};
                      </script>'."\n".
       '<script type="text/javascript" src="/adm/jsMath/jsMath.js"></script>'."\n";
       }
       sub jsMath_process {
    my $state = pop(@jsMath_sent_header);
    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();
       }
       return;
   }
   
   sub mimetex_valign {
       my ($esc_texstring)=@_;
       my $valign = 0;
       my $lonhost = $Apache::lonnet::perlvar{'lonHostID'};
       my $hostname = &Apache::lonnet::hostname($lonhost);
       my $path = '/cgi-bin/mimetex.cgi?'.$esc_texstring;
       my $socket;
       &Apache::lonxml::start_alarm();
       my $socket = IO::Socket::INET->new(PeerAddr => $hostname,
                                          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 {
       my $texstring=shift;
   
   # Alt-Argument for screen readers
       my $alt_string=$$texstring;
       $alt_string=~s/\"/\'\'/g;
   
 sub footer {  # Is this displaystyle?
   my $xmlstring='';  
   if ($ENV{'request.state'} eq 'construct') {      my $displaystyle=&displaystyle($texstring);
       $xmlstring.='<address>'.$errorstring.'</address>';  
   } else {  # Remove math environment delimiters
       &Apache::lonmsg::author_res_msg($ENV{'request.filename'},$errorstring);  
   }      &clean_out_math_mode($texstring);
 # -------------------------------------------------------------------- End Body  
   $xmlstring.=&Apache::lonxml::xmlend();      if ($displaystyle) {
   return $xmlstring;   $$texstring='\\displaystyle \\Large '.$$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) {
    $result='<center>'.$result.'</center>';
       }
       return $result;
   }
   
   sub converted {
       my ($string,$mode)=@_;
       if ($mode eq '') { $mode = &tex_engine(); }
       if ($mode =~ /tth/i) {
    return &tth_converted($string);
       } elsif ($mode =~ /jsmath/i) {
    return &jsMath_converted($string);
       } elsif ($mode =~ /mimetex/i) {
    return &mimetex_converted($string);
       } elsif ($mode =~ /raw/i) {
           return $$string;
       }
       return &tth_converted($string);
 }  }
   
 # ------------------------------------------------------------ Message display  # ------------------------------------------------------------ Message display
Line 167  sub to_convert { Line 321  sub to_convert {
   
 sub smiley {  sub smiley {
     my $expression=shift;      my $expression=shift;
     if ($ENV{'browser.imagesuppress'} eq 'on') { return $expression; }      if ($env{'browser.imagesuppress'} eq 'on') { return $expression; }
     my %smileys=('\:\-\)' => 'smiley',      my %smileys=('\:\-\)' => 'smiley',
  '8\-\)'  => 'coolsmile',   '8\-\)'  => 'coolsmile',
  '8\-(I|\|)'   => 'coolindiff',   '8\-(I|\|)'   => 'coolindiff',
Line 183  sub smiley { Line 337  sub smiley {
  '\:\-(X|\#)' => 'lipsrsealed',   '\:\-(X|\#)' => 'lipsrsealed',
  '\:\-S' => 'huh');   '\:\-S' => 'huh');
     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}.gif" \/\>/gs; 
     }      }
     return $expression;      return $expression;
 }  }
Line 195  sub msgtexconverted { Line 349  sub msgtexconverted {
     &init_tth();      &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;
       foreach my $fragment (split(/(?:\&lt\;|\<)\/*algebra\s*(?:\&gt\;|\>)/i,
    $message)) {
    if ($tex) {
       if ($email) {
    $outmessage.='</pre><tt>'.&algebra($fragment,'web').'</tt><pre>';
    $tex=0;
       } else {
    $outmessage.=&algebra($fragment,'web');
    $tex=0;
       }
    } else {
               $outmessage.=$fragment;
       $tex=1;
  }   }
     }      }
     if (wantarray) {      if (wantarray) {
Line 213  sub msgtexconverted { Line 386  sub msgtexconverted {
     }      }
 }  }
   
   sub algebra {
       use AlgParser;
   
       my ($string,$target,$style,$parstack,$safeeval)=@_;
       my $parser = new AlgParserWithImplicitExpand;
       $string=&prepare_algebra($string);
       my $ret = $parser->parse($string);
       my $result='['.&mt('Algebra unconverted due to previous errors').']';
       if ( ref($ret) ) {
    #$parser->tostring();
    $parser->normalize();
    my $latex=$parser->tolatex();
    $latex=&postprocess_algebra($latex);
    if ($style eq 'display') {
       $latex='$$'.$latex.'$$x';
    } else {
       # style is 'inline'
       $latex='\\ensuremath{'.$latex.'}';
    }
    if ($target eq 'web' || $target eq 'analyze') {
               my $display=&Apache::lonxml::get_param('display',$parstack,$safeeval);
               $result = &converted(\$latex,$display);
   #    $result = &converted(\$latex);
    } else {
       $result = $latex;
    }
       } else {
    &Apache::lonxml::error($parser->{'htmlerror'});
       }
   }
   
   sub prepare_algebra {
       my ($string)=@_;
   
       # makes the decision about what is a minus sign easier supposedly
       $string =~ s/(\<\>|\<\=|\>\=[\=\>\<] *)-/$1 zeroplace -/g;
   
       return $string;
   }
   
   sub postprocess_algebra {
       my ($string)=@_;
       
       # moodle had these and I don't know why, ignoring them for now
       # $string =~s/\\fun/ /g;
   
       # sqrt(3,4) means the 4 root of 3
       $string =~s/\\sqrt{([^,]+),([^\}]+)}/\\sqrt[$2]{$1}/gs;
   
       # log(3,4) means the log base 4 of 3
       $string =~s/\\log\\left\((.+?),(.+?)\\right\)/\\log_{$2}\\left($1\\right)/gs;
   
       # log(3,4) means the log base 4 of 3
       $string =~s/\\((?:sin|cos|tan|sec|csc|cot)(?:h)?)\\left\((.+?),(.+?)\\right\)/\\$1^{$3}\\left($2\\right)/gs;
   
       # int(3,a,b) integral from a to b of 3
       $string =~s/\\int\\left\((.+?),(.+?),(.+?)\\right\)/\\int_{$2}^{$3}\\left($1\\right)/gs;
   
       # int( ... dx) -> ...
       $string =~s/\\int\\left\((.+?)d[a-z]\\right\)/$1/gs;
   
       # 
       $string =~s/\\lim\\left\((.+?),(.+?),(.+?)\\right\)/\\lim_{$2\\to $3}$1/gs;
       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 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.39  
changed lines
  Added in v.1.98.2.1

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