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

Diff for /loncom/xml/lontexconvert.pm between versions 1.97 and 1.118

version 1.97, 2009/08/12 20:31:08 version 1.118, 2016/02/20 00:12:45
Line 49  use lib '/home/httpd/lib/perl/'; Line 49  use lib '/home/httpd/lib/perl/';
 use LONCAPA;  use LONCAPA;
 use URI::Escape;  use URI::Escape;
 use IO::Socket::INET;  use IO::Socket::INET;
 use IO::Socket::SSL;  
   
   #
   # 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
   
Line 107  sub convert_real { Line 178  sub convert_real {
     $xmlstring=~s/^\s*\<br clear\=\"all\"/\<br/s;      $xmlstring=~s/^\s*\<br clear\=\"all\"/\<br/s;
     $xmlstring=~s/^\s*//;      $xmlstring=~s/^\s*//;
     $xmlstring=~s/\s*$//;      $xmlstring=~s/\s*$//;
       $xmlstring=~s/^<br \/><table/<table/;
       &Apache::lonxml::end_alarm();
   
     #      #
     # \rightleftharpoons is not converted by tth but maps      # Several strings produced by tth require
     # reasonably well to &#8660;.  If we get many more of these,      # transliteration -> unicode equivalents to render reliably
     # we're going to need to have a translation sub.      # in browsers. %unicode_translations and %unicode_harpoons are tables of
     #      # string->substitution which we now apply. (%ascii_8bit_translations used
     my $lrharpoon = pack("U", 0x21cc);      # instead for Windows XP and mobile devices.
     $xmlstring=~s/\\rightleftharpoons/$lrharpoon/g;  
       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});
       }
   
     &Apache::lonxml::end_alarm();  
     return ($xmlstring,$errorstring);      return ($xmlstring,$errorstring);
 }  }
   
Line 166  sub clean_out_math_mode { Line 260  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 jsMath_converted {  sub MathJax_converted {
     my $texstring=shift;      my $texstring=shift;
     my $tag='span';      my $tag='math/tex;';
     if (&displaystyle($texstring)) { $tag='div'; }      if (&displaystyle($texstring)) { $tag='math/tex; mode=display'; }
     &clean_out_math_mode($texstring);      &clean_out_math_mode($texstring);
     return &jsMath_header().      return &MathJax_header().
  '<'.$tag.' class="math">'.$$texstring.'</'.$tag.'>';        '<script type="'.$tag.'">'.$$texstring.'</script>';
 }  }
   
 {  {
     my @jsMath_sent_header;      #Relies heavily on the previous jsMath installation
     sub jsMath_reset {      my @MathJax_sent_header;
  undef(@jsMath_sent_header);      sub MathJax_reset {
     }          undef(@MathJax_sent_header);
     sub jsMath_push {      }
  push(@jsMath_sent_header,0);      sub MathJax_push {
     }          push(@MathJax_sent_header,0);
     sub jsMath_header {      }
  if (!@jsMath_sent_header) {      sub MathJax_header {
     &Apache::lonnet::logthis("mismatched calls of jsMath_header and jsMath_process");          if (!@MathJax_sent_header) {
     return '';              &Apache::lonnet::logthis("mismatched calls of MathJax_header and MathJax_process");
  }              return '';
  return '' if $jsMath_sent_header[-1];          }
  $jsMath_sent_header[-1]=1;          return '' if $MathJax_sent_header[-1];
  return          $MathJax_sent_header[-1]=1;
             '<script type="text/javascript">          return
                      function NoFontMessage () {}            '<script type="text/javascript" src="/adm/MathJax/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>'."\n";
                      jsMath = {Parser: {prototype: {environments: {\'eqnarray*\' :[\'Array\',null,null,\'rcl\',[5/18,5/18],3,\'D\']}}}};      }
                    </script>'."\n".      #sub MathJax_process {
     '<script type="text/javascript" src="/adm/jsMath/jsMath.js"></script>'."\n";      #    my $state = pop(@MathJax_sent_header);
     }      #    return '' if !$state;
     sub jsMath_process {      #    return "\n".
  my $state = pop(@jsMath_sent_header);      #        '<script type="text/javascript">MathJax.Process()</script>'."\n";
  return '' if !$state;      #}
  return "\n".      #sub MathJax_state {
     '<script type="text/javascript">jsMath.Process()</script>'."\n";      #    my ($level) = @_;
     }      #    return $MathJax_sent_header[$level];
     sub jsMath_state {      #}
  my ($level) = @_;  
  return $jsMath_sent_header[$level];  
     }  
 }  }
   
 sub tex_engine {  sub tex_engine {
     if (exists($env{'form.texengine'})) {      if (exists($env{'form.texengine'})) {
  if ($env{'form.texengine'} ne '') {   if ($env{'form.texengine'} ne '') {
               if (lc($env{'form.texengine'}) eq 'jsmath') {
                   return 'MathJax'; 
               }
             return $env{'form.texengine'};              return $env{'form.texengine'};
         }          }
     }          }    
     if ($env{'request.course.id'}      if ($env{'request.course.id'}
  && exists($env{'course.'.$env{'request.course.id'}.'.texengine'})) {   && exists($env{'course.'.$env{'request.course.id'}.'.texengine'})) {
           if (lc($env{'course.'.$env{'request.course.id'}.'.texengine'}) eq 'jsmath') {
               return 'MathJax';
           }
  return $env{'course.'.$env{'request.course.id'}.'.texengine'};   return $env{'course.'.$env{'request.course.id'}.'.texengine'};
     }      }
     if (exists($env{'environment.texengine'})) {      if (exists($env{'environment.texengine'})) {
           if (lc($env{'environment.texengine'}) eq 'jsmath') {
               return 'MathJax';
           }
  return $env{'environment.texengine'};   return $env{'environment.texengine'};
     }      }
     return 'tth';      return 'tth';
 }  }
   
 sub init_math_support {  sub init_math_support {
     my ($inherit_jsmath) = @_;  
     &init_tth();      &init_tth();
     &Apache::lontexconvert::jsMath_push();      &Apache::lontexconvert::MathJax_push();
     if (lc(&tex_engine()) eq 'jsmath' ||      if (lc(&tex_engine()) eq 'mathjax') {
  ($inherit_jsmath && &jsMath_state(-2))) {          return &Apache::lontexconvert::MathJax_header();
  return &Apache::lontexconvert::jsMath_header();  
     }      }
     return;      return;
 }  }
Line 246  sub init_math_support { Line 346  sub init_math_support {
 sub mimetex_valign {  sub mimetex_valign {
     my ($esc_texstring)=@_;      my ($esc_texstring)=@_;
     my $valign = 0;      my $valign = 0;
     my $lonhost = $Apache::lonnet::perlvar{'lonHostID'};  
     my $hostname = &Apache::lonnet::hostname($lonhost);  
     my $protocol = $Apache::lonnet::protocol{$lonhost};  
     my $path = '/cgi-bin/mimetex.cgi?'.$esc_texstring;      my $path = '/cgi-bin/mimetex.cgi?'.$esc_texstring;
     my $socket;      my $socket;
     &Apache::lonxml::start_alarm();      &Apache::lonxml::start_alarm();
     if ($protocol eq 'https') {      $socket = IO::Socket::INET->new(PeerAddr => 'localhost',
         $socket = IO::Socket::SSL->new(PeerAddr => $hostname,                                      PeerPort => 'http(80)',
                                        PeerPort => 'https(443)',                                      Proto    => 'tcp');
                                        Proto    => 'tcp');  
     } else {  
         $socket = IO::Socket::INET->new(PeerAddr => $hostname,  
                                         PeerPort => 'http(80)',  
                                         Proto    => 'tcp');  
     }  
     if ($socket) {      if ($socket) {
         my $headreq = "HEAD $path HTTP/1.0\r\n\r\n";          my $headreq = "HEAD $path HTTP/1.0\r\n\r\n";
         print $socket $headreq;          print $socket $headreq;
Line 269  sub mimetex_valign { Line 360  sub mimetex_valign {
                 $valign = $1;                  $valign = $1;
             }              }
         }          }
         if ($protocol eq 'https') {          $socket->close();
             $socket->close(SSL_no_shutdown => 1,  
                            SSL_ctx_free => 1);  
         } else {  
             $socket->close();  
         }  
     }      }
     &Apache::lonxml::end_alarm();      &Apache::lonxml::end_alarm();
     return $valign;      return $valign;
Line 302  sub mimetex_converted { Line 388  sub mimetex_converted {
     my $valign = &mimetex_valign($esc_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.'" />';      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;
 }  }
Line 313  sub converted { Line 399  sub converted {
     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 &MathJax_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);
 }  }
Line 324  sub converted { Line 414  sub converted {
   
 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 332  sub to_convert { Line 423  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 my $smiley (keys(%smileys)) {      foreach my $smiley (keys(%smileys)) {
  $expression=~s/$smiley/\<img src="$iconpath\/$smileys{$smiley}.gif" \/\>/gs;    $expression=~s/$smiley/\<img src="$iconpath\/$smileys{$smiley}" \/\>/gs; 
     }      }
     return $expression;      return $expression;
 }  }
Line 357  sub smiley { Line 461  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 my $fragment (split(/(?:\&lt\;|\<)\/*m\s*(?:\&gt\;|\>)/i,$message)) {      foreach my $fragment (split(/(?:\&lt\;|\<)\/*m\s*(?:\&gt\;|\>)/i,$message)) {
Line 378  sub msgtexconverted { Line 481  sub msgtexconverted {
     foreach my $fragment (split(/(?:\&lt\;|\<)\/*algebra\s*(?:\&gt\;|\>)/i,      foreach my $fragment (split(/(?:\&lt\;|\<)\/*algebra\s*(?:\&gt\;|\>)/i,
  $message)) {   $message)) {
  if ($tex) {   if ($tex) {
           my $algebra = &algebra($fragment, 'web', undef, undef, undef, 'tth');
     if ($email) {      if ($email) {
  $outmessage.='</pre><tt>'.&algebra($fragment,'web').'</tt><pre>';   $outmessage.='</pre><tt>'.$algebra.'</tt><pre>';
  $tex=0;   $tex=0;
     } else {      } else {
  $outmessage.=&algebra($fragment,'web');   $outmessage.=$algebra;
  $tex=0;   $tex=0;
     }      }
  } else {   } else {
             $outmessage.=$fragment;          $outmessage.=$fragment;
     $tex=1;      $tex=1;
  }   }
     }      }
Line 399  sub msgtexconverted { Line 503  sub msgtexconverted {
   
 sub algebra {  sub algebra {
     use AlgParser;      use AlgParser;
       my ($string,$target,$style,$parstack,$safeeval,$tth)=@_;
     my ($string,$target,$style,$parstack,$safeeval)=@_;  
     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 462  sub postprocess_algebra { Line 566  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__
   
Line 504  Header Line 610  Header
 =item displaystyle()  =item displaystyle()
   
   
 =item jsMath_converted()  =item MathJax_converted()
   
   
 =item tex_engine()  =item tex_engine()
   
   
 =item init_math_support()  =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 mimetex_converted()
   
Removed from v.1.97  
changed lines
  Added in v.1.118

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