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

Diff for /loncom/homework/radiobuttonresponse.pm between versions 1.124 and 1.157.2.1

version 1.124, 2007/07/17 20:44:07 version 1.157.2.1, 2015/04/07 15:26:24
Line 18 Line 18
 # GNU General Public License for more details.  # GNU General Public License for more details.
 #  #
 # You should have received a copy of the GNU General Public License  # You should have received a copy of the GNU General Public License
 # along with LON-CAPA; if not, write to the Free Software  # along with LON-CAPA; if not, write to the Free Software# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA  
 #  #
 # /home/httpd/html/adm/gpl.txt  # /home/httpd/html/adm/gpl.txt
 #  #
 # http://www.lon-capa.org/  # http://www.lon-capa.org/
 #  #
   
   
   
 package Apache::radiobuttonresponse;  package Apache::radiobuttonresponse;
 use strict;  use strict;
 use HTML::Entities();  use HTML::Entities();
 use Apache::lonlocal;  use Apache::lonlocal;
 use Apache::lonnet;  use Apache::lonnet;
 use Apache::response;  use Apache::response;
   use Apache::caparesponse;
   
 my $default_bubbles_per_line = 10;  my $default_bubbles_per_line = 10;
   my @alphabet      = ( 'A' .. 'Z' ); # Foil labels.
   
   
   
   
 BEGIN {  BEGIN {
     &Apache::lonxml::register('Apache::radiobuttonresponse',('radiobuttonresponse'));      &Apache::lonxml::register('Apache::radiobuttonresponse',('radiobuttonresponse'));
 }  }
   
   #---------------------------------------------------------------------------
   #
   #  Generic utility subs.
   
 sub bubble_line_count {  sub bubble_line_count {
     my ($numfoils, $bubbles_per_line) = @_;      my ($numfoils, $bubbles_per_line) = @_;
     my $bubble_lines;      my $bubble_lines;
Line 52  sub bubble_line_count { Line 61  sub bubble_line_count {
 }  }
   
   
   
   #------------------------------------------------------------------------------
   #
   #  XML handlers.
 sub start_radiobuttonresponse {  sub start_radiobuttonresponse {
     my ($target,$token,$tagstack,$parstack,$parser,$safeeval,$style)=@_;      my ($target,$token,$tagstack,$parstack,$parser,$safeeval,$style)=@_;
     my $result;      my $result;
   
   
   
     #when in a radiobutton response use these      #when in a radiobutton response use these
     &Apache::lonxml::register('Apache::radiobuttonresponse',('foilgroup','foil','conceptgroup'));      &Apache::lonxml::register('Apache::radiobuttonresponse',('foilgroup','foil','conceptgroup'));
     push (@Apache::lonxml::namespace,'radiobuttonresponse');      push (@Apache::lonxml::namespace,'radiobuttonresponse');
Line 68  sub start_radiobuttonresponse { Line 79  sub start_radiobuttonresponse {
     if ($target eq 'meta') {      if ($target eq 'meta') {
  $result=&Apache::response::meta_package_write('radiobuttonresponse');   $result=&Apache::response::meta_package_write('radiobuttonresponse');
     } elsif ($target eq 'edit' ) {      } elsif ($target eq 'edit' ) {
  $result.=&Apache::edit::start_table($token).   $result.=&Apache::edit::start_table($token)
     '<tr><td>'.&Apache::lonxml::description($token).             .'<tr><td>'.&Apache::lonxml::description($token)
     &Apache::loncommon::help_open_topic('Radio_Response_Problems').             .&Apache::loncommon::help_open_topic('Radio_Response_Problems')
     "</td><td>Delete:".             .'</td>'
     &Apache::edit::deletelist($target,$token)             .'<td><span class="LC_nobreak">'.&mt('Delete?').' '
     ."</td><td>&nbsp".&Apache::edit::end_row()             .&Apache::edit::deletelist($target,$token)
     .&Apache::edit::start_spanning_row();             .'</span></td>'
              .'<td>&nbsp;'.&Apache::edit::end_row()
              .&Apache::edit::start_spanning_row();
  $result.=   $result.=
     &Apache::edit::text_arg('Max Number Of Shown Foils:','max',      &Apache::edit::text_arg('Max Number Of Shown Foils:','max',
     $token,'4').      $token,'4').
     &Apache::edit::select_arg('Randomize Foil Order','randomize',      &Apache::edit::select_arg('Randomize Foil Order:','randomize',
       ['yes','no'],$token).        ['yes','no'],$token).
     &Apache::edit::select_arg('Display Direction','direction',      &Apache::edit::select_arg('Display Direction:','direction',
       ['vertical','horizontal'],$token).        ['vertical','horizontal'],$token).
       &Apache::edit::end_row().        &Apache::edit::end_row().
       &Apache::edit::start_spanning_row()."\n";        &Apache::edit::start_spanning_row()."\n";
Line 89  sub start_radiobuttonresponse { Line 102  sub start_radiobuttonresponse {
      $safeeval,'max',       $safeeval,'max',
      'randomize','direction');       'randomize','direction');
  if ($constructtag) { $result = &Apache::edit::rebuild_tag($token); }   if ($constructtag) { $result = &Apache::edit::rebuild_tag($token); }
     } elsif ($target eq 'tex') {  
  my $type=&Apache::lonxml::get_param('TeXtype',$parstack,$safeeval,     } elsif ( $target eq 'tex' ) {
     undef,0);          my $type =
  if ($type eq '1') {            &Apache::lonxml::get_param( 'TeXtype', $parstack, $safeeval, undef,
     $result .= ' \renewcommand{\labelenumi}{\arabic{enumi}.}';              0 );
  } elsif ($type eq 'A') {          if ( $type eq '1' ) {
     $result .= ' \renewcommand{\labelenumi}{\Alph{enumi}.}';              $result .= ' \renewcommand{\labelenumi}{\arabic{enumi}.}';
  } elsif ($type eq 'a') {          }
     $result .= ' \renewcommand{\labelenumi}{\alph{enumi}.}';          elsif ( $type eq 'A' ) {
  } elsif ($type eq 'i') {              $result .= ' \renewcommand{\labelenumi}{\Alph{enumi}.}';
     $result .= ' \renewcommand{\labelenumi}{\roman{enumi}.}';          }
  } else {          elsif ( $type eq 'a' ) {
     $result .= ' \renewcommand{\labelenumi}{\Alph{enumi}.}';              $result .= ' \renewcommand{\labelenumi}{\alph{enumi}.}';
  }          }
  $result .= '\begin{enumerate}';          elsif ( $type eq 'i' ) {
     } elsif ($target eq 'analyze') {              $result .= ' \renewcommand{\labelenumi}{\roman{enumi}.}';
  my $part_id="$Apache::inputtags::part.$id";          }
           else {
               $result .= ' \renewcommand{\labelenumi}{\Alph{enumi}.}';
           }
   
       }
       elsif ( $target eq 'analyze' ) {
           my $part_id = "$Apache::inputtags::part.$id";
           $Apache::lonhomework::analyze{"$part_id.type"} = 'radiobuttonresponse';
  push (@{ $Apache::lonhomework::analyze{"parts"} },$part_id);   push (@{ $Apache::lonhomework::analyze{"parts"} },$part_id);
     }      }
     return $result;      return $result;
Line 114  sub start_radiobuttonresponse { Line 135  sub start_radiobuttonresponse {
 sub end_radiobuttonresponse {  sub end_radiobuttonresponse {
     my ($target,$token,$tagstack,$parstack,$parser,$safeeval,$style)=@_;      my ($target,$token,$tagstack,$parstack,$parser,$safeeval,$style)=@_;
     my $result;      my $result;
     if ($target eq 'edit') { $result=&Apache::edit::end_table(); }      if ( $target eq 'edit' ) { 
     if ($target eq 'tex') { $result .= '\end{enumerate}'; }   $result = &Apache::edit::end_table(); 
       }
     &Apache::response::end_response;      &Apache::response::end_response;
     pop @Apache::lonxml::namespace;      pop @Apache::lonxml::namespace;
     &Apache::lonxml::deregister('Apache::radiobuttonresponse',('foilgroup','foil','conceptgroup'));      &Apache::lonxml::deregister('Apache::radiobuttonresponse',('foilgroup','foil','conceptgroup'));
Line 126  sub end_radiobuttonresponse { Line 148  sub end_radiobuttonresponse {
 %Apache::response::foilgroup=();  %Apache::response::foilgroup=();
 sub start_foilgroup {  sub start_foilgroup {
     my ($target,$token,$tagstack,$parstack,$parser,$safeeval,$style)=@_;      my ($target,$token,$tagstack,$parstack,$parser,$safeeval,$style)=@_;
     my $result;  
     %Apache::response::foilgroup=();      %Apache::response::foilgroup=();
     $Apache::radiobuttonresponse::conceptgroup=0;      $Apache::radiobuttonresponse::conceptgroup=0;
     &Apache::response::pushrandomnumber();      &Apache::response::pushrandomnumber(undef,$target);
     if ($target eq 'tex' && $Apache::lonhomework::type eq 'exam') {      return;
  $result.='\item[\textbf{'.$Apache::lonxml::counter.'}.]';  
     }  
     return $result;  
 }  }
   
 sub storesurvey {  sub storesurvey {
       my ($style) = @_;
     if ( !&Apache::response::submitted() ) { return ''; }      if ( !&Apache::response::submitted() ) { return ''; }
     my $response = $env{'form.HWVAL_'.$Apache::inputtags::response['-1']};      my $response = $env{'form.HWVAL_'.$Apache::inputtags::response['-1']};
     &Apache::lonxml::debug("Here I am!:$response:");      &Apache::lonxml::debug("Here I am!:$response:");
Line 150  sub storesurvey { Line 169  sub storesurvey {
     $Apache::lonhomework::results{"resource.$part.$id.submission"}=      $Apache::lonhomework::results{"resource.$part.$id.submission"}=
  $responsestr;   $responsestr;
     my %previous=&Apache::response::check_for_previous($responsestr,$part,$id);      my %previous=&Apache::response::check_for_previous($responsestr,$part,$id);
     my $ad=$Apache::lonhomework::results{"resource.$part.$id.awarddetail"}='SUBMITTED';      my $ad;
       if ($style eq 'anonsurvey') {
           $ad=$Apache::lonhomework::results{"resource.$part.$id.awarddetail"}='ANONYMOUS';
       } elsif ($style eq 'anonsurveycred') {
           $ad=$Apache::lonhomework::results{"resource.$part.$id.awarddetail"}='ANONYMOUS_CREDIT';
       } elsif ($style eq 'surveycred') {
           $ad=$Apache::lonhomework::results{"resource.$part.$id.awarddetail"}='SUBMITTED_CREDIT';
       } else {
           $ad=$Apache::lonhomework::results{"resource.$part.$id.awarddetail"}='SUBMITTED';
       }
     &Apache::response::handle_previous(\%previous,$ad);      &Apache::response::handle_previous(\%previous,$ad);
     &Apache::lonxml::debug("submitted a $response<br />\n");      &Apache::lonxml::debug("submitted a $response<br />\n");
     return '';      return '';
Line 200  sub end_foilgroup { Line 228  sub end_foilgroup {
   
     my $result;      my $result;
     my $bubble_lines;      my $bubble_lines;
     my $bubbles_per_line;  
     my $answer_count;      my $answer_count;
     my $id = $Apache::inputtags::response['-1'];      my $id   = $Apache::inputtags::response['-1'];
     $bubbles_per_line =       my $part = $Apache::inputtags::part;
  &Apache::response::get_response_param($Apache::inputtags::part."_$id",      my $bubbles_per_line = &getbubblesnum($part,$id);
       'numbubbles',  
       $default_bubbles_per_line);  
   
   
     if ($target eq 'grade' || $target eq 'web' || $target eq 'answer' ||      if ($target eq 'grade' || $target eq 'web' || $target eq 'answer' ||
Line 214  sub end_foilgroup { Line 239  sub end_foilgroup {
  my $style = $Apache::lonhomework::type;   my $style = $Apache::lonhomework::type;
  my $direction = &Apache::lonxml::get_param('direction',$parstack,   my $direction = &Apache::lonxml::get_param('direction',$parstack,
    $safeeval,'-2');     $safeeval,'-2');
  if ( $style eq 'survey'  && $target ne 'analyze') {   if ( (($style eq 'survey') || ($style eq 'surveycred') || 
                 ($style eq 'anonsurvey') || ($style eq 'anonsurveycred')) 
                && ($target ne 'analyze')) {
     if ($target eq 'web' || $target eq 'tex') {      if ($target eq 'web' || $target eq 'tex') {
  $result=&displayallfoils($direction, $target);   $result=&displayallfoils($direction, $target);
     } elsif ( $target eq 'answer' ) {      } elsif ( $target eq 'answer' ) {
  $result=&displayallanswers();   $result=&displayallanswers();
     } elsif ( $target eq 'grade' ) {      } elsif ( $target eq 'grade' ) {
  $result=&storesurvey();   $result=&storesurvey($style);
     }      }
     $answer_count = scalar(@{$Apache::response::foilgroup{'names'}});      $answer_count = scalar(@{$Apache::response::foilgroup{'names'}});
   
Line 235  sub end_foilgroup { Line 262  sub end_foilgroup {
     $answer_count = scalar(@shown);      $answer_count = scalar(@shown);
   
     if ($target eq 'web' || $target eq 'tex') {      if ($target eq 'web' || $target eq 'tex') {
  $result=&displayfoils($target,                  $result=&displayfoils($target,
       $answer, \@shown,        $answer, \@shown,
       $direction,        $direction,
       $bubbles_per_line);        $bubbles_per_line);
Line 244  sub end_foilgroup { Line 271  sub end_foilgroup {
     } elsif ( $target eq 'grade') {      } elsif ( $target eq 'grade') {
  &grade_response($answer, \@shown, $bubbles_per_line);   &grade_response($answer, \@shown, $bubbles_per_line);
     }  elsif ( $target eq 'analyze') {      }  elsif ( $target eq 'analyze') {
    my $bubble_lines = &bubble_line_count($answer_count, 
         $bubbles_per_line);
  &Apache::response::analyze_store_foilgroup(\@shown,   &Apache::response::analyze_store_foilgroup(\@shown,
    ['text','value','location']);     ['text','value','location']);
  my $part_id="$Apache::inputtags::part.$Apache::inputtags::response[-1]";   my $part_id="$part.$id";
  push (@{ $Apache::lonhomework::analyze{"$part_id.options"} },   push (@{ $Apache::lonhomework::analyze{"$part_id.options"} },
       ('true','false'));        ('true','false'));
   
     }      }
  }   }
  $Apache::lonxml::post_evaluate=0;   $Apache::lonxml::post_evaluate=0;
Line 257  sub end_foilgroup { Line 287  sub end_foilgroup {
  &Apache::response::setup_prior_tries_hash(\&format_prior_answer,   &Apache::response::setup_prior_tries_hash(\&format_prior_answer,
   [\%Apache::response::foilgroup]);    [\%Apache::response::foilgroup]);
     }      }
     $bubble_lines = &bubble_line_count($answer_count, $bubbles_per_line);  
     &Apache::response::poprandomnumber();      &Apache::response::poprandomnumber();
     &Apache::lonxml::increment_counter($bubble_lines);      $bubble_lines = &bubble_line_count($answer_count, $bubbles_per_line);
       &Apache::lonxml::increment_counter($bubble_lines,
          "$part.$id");
       if ($target eq 'analyze') {
    &Apache::lonhomework::set_bubble_lines();
       }
     return $result;      return $result;
 }  }
   sub getbubblesnum {
       my ($part,$id) = @_;
       my $bubbles_per_line;
       my $default_numbubbles = $default_bubbles_per_line;
       if (($env{'form.bubbles_per_row'} =~ /^\d+$/) &&
           ($env{'form.bubbles_per_row'} > 0)) {
           $default_numbubbles = $env{'form.bubbles_per_row'};
       }
       $bubbles_per_line =
           &Apache::response::get_response_param($part."_$id",'numbubbles',
                                                 $default_numbubbles);
       return $bubbles_per_line;
   }
   
 sub getfoilcounts {  sub getfoilcounts {
     my @names;      my @names;
Line 291  sub format_prior_answer { Line 338  sub format_prior_answer {
   
 }  }
   
 sub displayallfoils {  
     my ($direction, $target)=@_;  ## 
     my $result;  # Return the last survey response.  The logic is slightly different than that of 
     &Apache::lonxml::debug("survey style display");  # get_last_responses.  TODO: See if there are chunks of code betweenthis and
     my @names;  # get_last_reponses that are common and can be factored.
     &Apache::lonnet::loghthis("Display all foils");  #
     if ( $Apache::response::foilgroup{'names'} ) {  # @param $part - Problem part under consideration.
  @names= @{ $Apache::response::foilgroup{'names'} };  # @param $showanswer - True if answers should be shown.
   # @param $id         - Problem id.
   #
   # @return hash reference.
   # @retval reference to the has indexed by answer selection that 
   #         indicates the most recent answer.
   #
   sub get_last_survey_response {
       my ($part, $showanswer, $id) = @_;
   
       my $newvariation;
       my $lastresponse; # stringified last response.
   
       if (
           (
               (
                   $Apache::lonhomework::history{"resource.$part.type"} eq
                   'randomizetry'
               )
               || ( $Apache::lonhomework::type eq 'randomizetry' )
           )
           && ( $Apache::inputtags::status[-1] eq 'CAN_ANSWER' )
         )
       {
           if ( $env{ 'form.' . $part . '.rndseed' } ne
               $Apache::lonhomework::history{"resource.$part.rndseed"} )
           {
               $newvariation = 1;
           }
       }
       $showanswer = &Apache::response::show_answer();
       unless ($newvariation && !$showanswer) {
           if ((($env{'form.grade_username'} eq '') && ($env{'form.grade_domain'} eq '')) ||
               (($env{'form.grade_username'} eq $env{'user.name'}) &&
                ($env{'form.grade_domain'} eq $env{'user.domain'}))) {
               $lastresponse = $Apache::lonhomework::history{"resource.$part.$id.submission"};
           } else {
               unless (($Apache::lonhomework::history{"resource.$part.type"} eq 'anonsurvey') ||
                       ($Apache::lonhomework::history{"resource.$part.type"} eq 'anonsurveycred')) {
                   $lastresponse = $Apache::lonhomework::history{"resource.$part.$id.submission"};
               }
           }
     }      }
       my %lastresponse = &Apache::lonnet::str2hash($lastresponse);
   
     my $temp=0;      return \%lastresponse;
     my $i   =0;  
     my $id=$Apache::inputtags::response['-1'];  }
     my $part=$Apache::inputtags::part;  ##
     my $lastresponse=  # Removes the names from a foil group that are marked as unused.
  $Apache::lonhomework::history{"resource.$part.$id.submission"};  #
     if ($direction eq 'horizontal') { $result.='<table><tr>'; }  # @param $names - reference to the array of names to filter.
     my %lastresponse=&Apache::lonnet::str2hash($lastresponse);  #
     if (&Apache::response::show_answer() ) {  # @return arrayref
  foreach my $name (@names) {  # @retval reference to the filtered array.
     if ($Apache::response::foilgroup{$name.'.value'} ne 'unused') {  #
  if (($direction eq 'horizontal') && ($target ne 'tex')) {  sub remove_unused {
     $result.="<td>";      my ($names) = @_;
  } else {      my @result;
     if ($target eq 'tex') {  
  $result .= '\item \vskip -2mm ';      foreach my $name (@{$names}) {
     } else {   if ($Apache::response::foilgroup{$name . '.value'} ne 'unused') {
  $result.="<br />";      push(@result, $name);
     }   }
  }      }
  if (defined($lastresponse{$name})) {      return \@result;
     if ($target eq 'tex') {  }
  $result .= '}';  ## 
     } else {  # Displays all foils in a survey type problem for HTML rendition.
  $result.='<b>';  # TODO: See if there is any logic in this sub that can be shared
     }  #      with display_foils_html
  }  #
  $result .= $Apache::response::foilgroup{$name.'.text'};  # @param $names        - ref to array of names of the foils to display.
  if (defined($lastresponse{$name}) && ($target ne 'tex')) {  # @param $part         - Problem part number.
     $result.='</b>';  # @param $showanswer   - If true, show the answers.
  }  # @param $lastresponse - Ref to the last response hash.
  if (($direction eq 'horizontal') && ($target ne 'tex')) { $result.="</td>"; }  # @param $direction    - Display direction of the radiobuttons.
   #
   # @return string
   # @retval HTML required to display the resource in a browser.
   #
   sub display_survey_html {
       my ($names, $part, $showanswer, $lastresponse, $direction) = @_;
       my $result;
   
       # Figure out a few fragments of html that depend onthe 
       # orientation of the radiobuttons:
       # closing_html - HTML to emit at the end of the resource.
       # pre_foil     - HTML to emit prior to each foil.
       # post_foil    - HTML to emit following each foil.
       #
       #  The opening HTML is just added to the $result now
       #
       #  Figuring these outin advance compresses the loop over foils into something
       #  pretty simple:
       #
       # NOTE: There's probably a really cool way to do this with style sheets
       #       and picking the selector based on the orientation, if someone wants to puzzle
       #       that out.  In that case, probably the whole thing lives in a <div> and each
       #       foil lives in a <p>
       #
   
   
       my ($opening_html, $closing_html, $pre_foil, $post_foil) = 
    &html_direction_fragments($direction);
   
       $result = $opening_html;
   
       # Different rendering depending on whether answers are shown:
       # I played with different factorings but this seems the most concise/clear...
       # although I don't like the $showanswer conditino inside the loop.  Other things I tried
       #  - two loops..much longer code..no gain in clarity.
       #  - Using a visitor patttern passing it the rendering code chunklets and
       #    an anonymous hash reference for state data etc. Very cool but
       #    quite a bit more code and quite a bit less clear.
       
       my $temp = 0;
       foreach my $name (@{$names}) {
    $result .= $pre_foil;
   
    if ($showanswer) {
       my $foiltext =  $Apache::response::foilgroup{$name . '.text'};
   
       # Bold the prior  response:
   
       if (defined($lastresponse->{$name})) {
    $result .= '<b>' . $foiltext . '</b>';
       } else {
    $result .= $foiltext;
     }      }
    } else {
       $result .= &html_radiobutton(
    $part, $Apache::inputtags::response['-1'], $name, $lastresponse, $temp
        );
  }   }
   
    $result .= $post_foil;
    $temp++;
       }
   
   
       $result .= $closing_html;
       return $result;
   
   }
   
   ##
   #  Generate LaTeX for surveys.
   #  
   #   @param $names - names of the foils to display.
   #   @param $showanswer - flag that is true to display answers.
   #   @param $lastresponse - Reference to a hash the indicates the last response.
   #   @param $direction    - Orientation of foils ('horiztonal' or otherwise).
   #   @param $venv         - LaTeX name for vertical env.
   #
   #   @return string
   #   @retval LaTeX rendering of the survey question.
   
   sub latex_survey {
       my ($names, $showanswer, $lastresponse, $direction, $venv) = @_;
   
       my $result;
       if ($showanswer) {
    $result .= "\\begin{$venv}";
    foreach my $name (@{$names}) {
       
       
       $result .= '\item \vskip -2mm ';
       
       if ( defined( $lastresponse->{$name} ) ) {
    $result .= '}';
       }
       $result .= $Apache::response::foilgroup{ $name . '.text' } . ' ';
    }
    $result .= "\\end{$venv}";
   
       } elsif ( $env{'form.pdfFormFields'} eq 'yes'
         && $Apache::inputtags::status[-1] eq 'CAN_ANSWER') {
    $result .= &display_pdf_form($names, $direction, $venv);
     } else {      } else {
  foreach my $name (@names) {   if ($direction eq 'horizontal') {
     if ($Apache::response::foilgroup{$name.'.value'} ne 'unused') {      my @foil_texts = &get_foil_texts($names);
  if ($direction eq 'horizontal') {      $result .=  &Apache::caparesponse::make_horizontal_latex_bubbles(
     $result.="<td>";      $names, \@foil_texts, '$\bigcirc$');
  } else {   } else {
     if ($target eq 'tex') {      $result .= "\\begin{$venv}";
  $result .= '\item \vskip -2mm ';  
     } else {      my $temp = 0;
  $result.="<br />";      my $i    = 0;
     }      foreach my $name (@{$names}) {
  }  
  if ($target eq 'tex') {   $result .= '\item \vskip -2mm ';
     $result .= '$\bigcirc$'.$Apache::response::foilgroup{$name.'.text'}.'\\\\';  #' stupid emacs  
     $i++;   if ($env{'form.pdfFormFields'} ne 'yes'
  } else {      or $Apache::inputtags::status[-1] ne 'CAN_ANSWER' )
     $result .= '<label>';   {
     $result.="<input      $result .=
                        onchange=\"javascript:setSubmittedPart('$part');\"   '$\bigcirc$'
                        type=\"radio\"   . $Apache::response::foilgroup{ $name . '.text' }
                        name=\"HWVAL_$Apache::inputtags::response['-1']\"      . '\\\\';    #' stupid emacs
                        value=\"$temp\" ";  
     if (defined($lastresponse{$name})) { $result .= 'checked="on"'; }  
     $result .= ' />'.$Apache::response::foilgroup{$name.'.text'}.  
  '</label>';  
  }   }
   
    $i++;    
  $temp++;   $temp++;
  if ($target ne 'tex') {  
     if (($direction eq 'horizontal') && ($target ne 'tex')) { $result.="</td>"; }   $result .= '\vskip 0 mm ';
  } else {  
     $result.='\vskip 0 mm ';  
  }  
     }      }
  }      $result .= "\\end{$venv}";
    }
     }      }
       
     if (($direction eq 'horizontal') && ($target ne 'tex')) { $result.='</tr></table>'; }  
     return $result;      return $result;
 }  }
   ##
   #  Figure out the LaTeX environment in which to wrap the LaTeX vertical output.
   #
   # @return string
   # @retval the environment name.  The LaTeX should be wrapped a 
   #    \begin{retval} \end{retval} pair.
   #
   sub latex_vertical_environment {
       if ($env{'form.pdfFormFields'} eq 'yes'
    && $Apache::inputtags::status[-1] eq 'CAN_ANSWER') {
    return 'itemize';
       } else {
    return 'enumerate';
       }
   }
   
 =pod  ##
   # Figure out the key html fragments that depend on the rendering direction:
   #
   # @param $direction - 'horizontal' for horizontal direction.
   #
   # @return list
   # @retval (part_start, part_end, foil_start, foil_end)
   # Where:
   #   - part_start is the HTML to emit at the start of the part.
   #   - part_end   is the HTML to emit at the end of the part.
   #   - foil_start is the HTML to emit prior to each foil.
   #   - foil_end is the HTML to emit after each foil
   #
   sub html_direction_fragments {
       my $direction = shift;
       if ($direction eq 'horizontal') {
    return ('<table><tr>', '</tr></table>', '<td>', '</td>');
       } else {
    return ('', '<br />', '<br />', '');
       }
   }
   
 =item &whichfoils($max,$randomize)  ##
   #
   #  Displays all the foils of a problem in a format suitable for
   #   surveys, surveys for credit, anonymous surveys and anonymous surveys for credit.
   #
   #  @param $direction - Display direction of the choices ('horiztonal' or not).
   #  @param $target    - Rendering target.
   #
   #  @return string
   #  @retval Text that renders for the selected target.
   # 
   sub displayallfoils{
       my ( $direction, $target ) = @_;
       my $result;
       &Apache::lonxml::debug("survey style display");
   
 Randomizes the list of foils.      my @names;
 Respects  
   - each foils desire to be randomized  
   - the existance of Concept groups of foils (select 1 foil from each)  
   - and selects a single correct statement from all possilble true statments  
   - and limits it to a toal of $max foils  
   
 WARNING: this routine uses the random number generator, it should only      if ( $Apache::response::foilgroup{'names'} ) {
 be called once per target, otherwise it can cause randomness changes in          @names = @{ $Apache::response::foilgroup{'names'} };
 homework problems.      }
   
 Arguments  
   $max - maximum number of foils to select (including the true one)  
          (so a max of 5 is: 1 true, 4 false)  
   
   $randomize - whether to randomize the listing of foils, by default      my $id   = $Apache::inputtags::response['-1'];
                will randomize, only if randomize is 'no' will it not      my $part = $Apache::inputtags::part;
       
       my $showanswer = &Apache::response::show_answer();
       my $lastresponse = &get_last_survey_response($part, $showanswer, $id);
       my $used_names = &remove_unused(\@names);
   
 Returns  
   $answer - location in the array of the correct answer  
   @foils  - array of foil names in to display order  
   
 =cut      if ($target ne 'tex') {
    $result .= &display_survey_html(
       $used_names, $part, $showanswer, $lastresponse, $direction
    );
       } else {
   
    my $vertical_env = &latex_vertical_environment();
    $result .= &latex_survey(
       $used_names, $showanswer, $lastresponse, $direction, $vertical_env
    );
   
       }
       return $result;
   }
   
 sub whichfoils {  sub whichfoils {
     my ($max,$randomize)=@_;      my ($max,$randomize)=@_;
Line 436  sub whichfoils { Line 674  sub whichfoils {
  &Apache::lonxml::error(&HTML::Entities::encode("No valid value assigned ($Apache::response::foilgroup{$name.'.value'}) for foil $name in <foilgroup>",'<>&"'));   &Apache::lonxml::error(&HTML::Entities::encode("No valid value assigned ($Apache::response::foilgroup{$name.'.value'}) for foil $name in <foilgroup>",'<>&"'));
     }      }
  }   }
  if (!$havetrue && $Apache::lonhomework::type ne 'survey') {   if ((!$havetrue) && 
     &Apache::lonxml::error("There are no true statements available.<br />");              ($Apache::lonhomework::type ne 'survey') && 
               ($Apache::lonhomework::type ne 'surveycred') &&
               ($Apache::lonhomework::type ne 'anonsurvey') &&
               ($Apache::lonhomework::type ne 'anonsurveycred')) {
       &Apache::lonxml::error(&mt('There are no true statements available.').'<br />');
  }   }
     } else {      } else {
  my $current=0;   my $current=0;
Line 496  sub whichfoils { Line 738  sub whichfoils {
  &Apache::lonxml::debug("Answer wants $answer");   &Apache::lonxml::debug("Answer wants $answer");
  my $truename=$truelist[$whichtrue];   my $truename=$truelist[$whichtrue];
  my $dosplice=1;   my $dosplice=1;
  if ($notrue && $Apache::lonhomework::type ne 'survey') {   if (($notrue) && 
               ($Apache::lonhomework::type ne 'survey') &&
               ($Apache::lonhomework::type ne 'surveycred') &&
               ($Apache::lonhomework::type ne 'anonsurvey') &&
               ($Apache::lonhomework::type ne 'anonsurveycred')) {
     $dosplice=0;      $dosplice=0;
     &Apache::lonxml::error("There are no true statements available.<br />");      &Apache::lonxml::error(&mt('There are no true statements available.').'<br />');
  }   }
  #insert the true statement, keeping track of where it wants to be   #insert the true statement, keeping track of where it wants to be
  if ($Apache::response::foilgroup{$truename.'.location'} eq 'top' && $dosplice) {   if ($Apache::response::foilgroup{$truename.'.location'} eq 'top' && $dosplice) {
Line 520  sub whichfoils { Line 766  sub whichfoils {
     $dosplice=0;      $dosplice=0;
  } else {   } else {
     if ($topcount>0 || $bottomcount>0) {      if ($topcount>0 || $bottomcount>0) {
  $answer = int(&Math::Random::random_uniform() * ($#whichfalse+1))                  my $inc = 1;
     + $topcount;                  if (($bottomcount > 0) && ($Apache::lonhomework::type ne 'exam')) {
                       $inc = 2;
                   }
                   $answer=int(&Math::Random::random_uniform() * ($#whichfalse+$inc))
                           + $topcount;
     }      }
  }   }
  &Apache::lonxml::debug("Answer now wants $answer");   &Apache::lonxml::debug("Answer now wants $answer");
Line 539  sub whichfoils { Line 789  sub whichfoils {
     return ($answer,@whichfalse);      return ($answer,@whichfalse);
 }  }
   
 sub displayfoils {  ## 
     my ($target,$answer,$whichfoils,$direction, $bubbles_per_line)=@_;  #  Return a list  of foil texts given foil names.
   #  
   # @param $whichfoils - Reference to a list of foil names.
   #
   # @return array
   # @retval foil texts
   #
   sub get_foil_texts {
       my ($whichfoils) = @_;
       my @foil_texts;
   
       foreach my $name (@{$whichfoils}) {
    push(@foil_texts, $Apache::response::foilgroup{$name . '.text'});
       }
       return @foil_texts;
   }
   
   ##
   # Generate the HTML for a single html foil.
   # @param $part           - The part for which the response is being generated.
   # @param $fieldname      - The basename of the radiobutton field
   # @param $name           - The foilname.
   # @param $last_responses - Reference to a hash that holds the most recent
   #                          responses.
   # @param $value          - radiobutton value.
   # 
   # @return text
   # @retval The generated html.
   #
   sub html_radiobutton {
       my ($part, $fieldname, $name, $last_responses, $value) = @_;
   
       my $result='<label>';
       
       $result .= '<input type="radio" '
    . 'onchange="javascript:setSubmittedPart(' . "'$part');\" "
    . 'name="HWVAL_' . $fieldname . '" '
    . 'value="'.$value.'"';
   
       if (defined($last_responses->{$name})) {
    $result .= '  checked="checked" ';
       }
       $result .= ' />';
       $result .= $Apache::response::foilgroup{$name . '.text'};
       $result .= '</label>';
   
       return $result;
   
   }
   ##
   # Return a reference to the last response hash. This hash has exactly
   # one or zero entries.  The one entry is keyed by the foil 'name' of
   # the prior response
   #
   # @param $part - Number of the problem part.
   # 
   # @return reference to a hash.
   # @retval see above.
   #
   sub get_last_response {
       my ($part) = @_;
   
       my $id = $Apache::inputtags::response['-1'];
       my ( $lastresponse, $newvariation );
       
       if ((( $Apache::lonhomework::history{"resource.$part.type"} eq  'randomizetry')
    || ( $Apache::lonhomework::type eq 'randomizetry' )
    )
    && ( $Apache::inputtags::status[-1] eq 'CAN_ANSWER' )
    )
       {
   
    if ( $env{ 'form.' . $part . '.rndseed' } ne
        $Apache::lonhomework::history{"resource.$part.rndseed"} )
    {
       $newvariation = 1;
    }
       }
       unless ($newvariation) {
           if ((($env{'form.grade_username'} eq '') && ($env{'form.grade_domain'} eq '')) ||
               (($env{'form.grade_username'} eq $env{'user.name'}) &&
                ($env{'form.grade_domain'} eq $env{'user.domain'}))) {
               $lastresponse =
                   $Apache::lonhomework::history{"resource.$part.$id.submission"};
           } else {
               unless (($Apache::lonhomework::history{"resource.$part.type"} eq 'anonsurvey') ||
                       ($Apache::lonhomework::history{"resource.$part.type"} eq 'anonsurveycred')) {
                   $lastresponse =
                       $Apache::lonhomework::history{"resource.$part.$id.submission"};
   
               }
           }
       }
   
       my %lastresponse = &Apache::lonnet::str2hash($lastresponse);
   
       return \%lastresponse;
   }
   
   ##
   # Display foils in html rendition.:
   #
   # @param $whichfoils - Set of foils to display.
   # @param $target     - Rendition target...there are several html targets.
   # @param $direction  - 'horizontal' if layout is horizontal.
   # @param $part       - Part of the problem that's being displayed.
   # @param $show_answer- True if answers should be shown.
   #
   # @return string
   # @retval generated html.
   #
   sub display_foils_html {
       my ($whichfoils, $target, $direction, $part, $show_answer) = @_;
     my $result;      my $result;
   
     my $part=$Apache::inputtags::part;  
     my $solved=$Apache::lonhomework::history{"resource.$part.solved"};      # if the answers get shown, we need to label each item as correct or
     if ( ($target ne 'tex') &&      # incorrect.
  &Apache::response::show_answer() ) {  
  if ($direction eq 'horizontal') {      my ($opening_html, $finalclose, $item_pretext, $item_posttext) = 
     if ($target ne 'tex') {   &html_direction_fragments($direction);
  $result.='<table><tr>';  
     }      $result .= $opening_html;
  }  
  foreach my $name (@{ $whichfoils }) {  
     if ($direction eq 'horizontal') {      if ($show_answer) {
  if ($target ne 'tex') { $result.='<td>'; }  
     }   foreach my $name (@{$whichfoils}) {
     if ($target ne 'tex') {  
  $result.="<br />";      # If the item gets further surrounded by tags, this 
     } else {      # holds the closures for those tages.
  $result.='\item \vskip -2 mm  ';  
     }      my $item_closetag = '';
     if ($Apache::response::foilgroup{$name.'.value'} eq 'true') {   
  if ($target ne 'tex') { $result.='Correct:<b>'; } else { $result.='Correct: \textbf{';}      $result .= $item_pretext;
   
       # Label each foil as correct or incorrect:
   
       if ($Apache::response::foilgroup{$name . '.value'} eq 'true') {
    $result .= &mt('Correct:') . '<b>';
    $item_closetag .= '</b>';
   
     } else {      } else {
  $result.='Incorrect:';   $result .= &mt('Incorrect');
     }  
     if ($target eq 'web') { $result.="<label>"; }  
     $result.=$Apache::response::foilgroup{$name.'.text'};  
     if ($target eq 'web') { $result.="</label>"; }  
     if ($Apache::response::foilgroup{$name.'.value'} eq 'true') {  
  if ($target ne 'tex') { $result.='</b>';} else {$result.='}';}  
     }      }
     if ($direction eq 'horizontal') {  
  if ($target ne 'tex') { $result.='</td>'; }      # Web rendition encloses the 
       # item text in a label tag as well:
   
       if ($target eq 'web') {
    $result .= '<label>';
    $item_closetag = '</label>' . $item_closetag;
     }      }
       $result .= $Apache::response::foilgroup{$name . '.text'};
       $result .= $item_closetag;
       $result .= $item_posttext;
       $result .= "\n"; # make the html a bit more readable.
  }   }
  if ($direction eq 'horizontal') {  
     if ($target ne 'tex') {  
  $result.='</tr></table>';      } else {
     }   my $lastresponse = &get_last_response($part);
   
    my $item_no = 0;
    foreach my $name (@{$whichfoils}) {
       $result .= $item_pretext;
       $result .= &html_radiobutton(
    $part, $Apache::inputtags::response[-1],
    $name, $lastresponse, $item_no
    );
       $result .= $item_posttext;
       $item_no++;
  }   }
   
       }
       $result .= $finalclose;
   
       return $result;
   }
   ##
   #  Display foils in exam mode for latex
   #
   # @param $whichfoils       - Reference to an array that contains the foil names to display
   # @param $bubbles_per_line - Number of bubbles on a line.
   # @param $direction        - Rendering direction 'horizontal' is what we're looking for.
   # @param $venv             - Name of LaTeX environment to use for vertical rendering.
   #
   # @return string
   # @return the latex rendering of the exam problem.
   #
   #
   sub display_latex_exam {
       my ($whichfoils, $bubbles_per_line, $direction, $venv) = @_;
       my $result;
       my $numlines;
       my $bubble_number = 0;
       my $line          = 0;
       my $i             = 0;
   
       
       if ($direction eq  'horizontal') {
   
    # Marshall the display text for each foil and turn things over to
    # Apache::response::make_horizontal_bubbles:
   
    my @foil_texts = &get_foil_texts($whichfoils);
    $result .= &Apache::caparesponse::make_horizontal_latex_bubbles(
       $whichfoils, \@foil_texts, '$\bigcirc$');
   
     } else {      } else {
  my @alphabet = ('A'..'Z');  
  my $i = 0;   $result .= '\vskip 2mm \noindent';
  my $bubble_number = 0;  
  my $line = 0;   # This section puts out the prefix that tells the user
  my $temp=0;     # (if necessary) to only choose one bubble in the next n lines
  my $id=$Apache::inputtags::response['-1'];   # for problems with more than one line worth of bubbles in the grid sheet:
  my $part=$Apache::inputtags::part;  
  my $lastresponse=$Apache::lonhomework::history{"resource.$part.$id.submission"};   my $numitems = scalar( @{$whichfoils} );
  my %lastresponse=&Apache::lonnet::str2hash($lastresponse);   $numlines = int( $numitems / $bubbles_per_line );
  if ($target ne 'tex' && $direction eq 'horizontal') {   if ( ( $numitems % $bubbles_per_line ) != 0 ) {
     $result.="<table><tr>";      $numlines++;
  }   }
  foreach my $name (@{ $whichfoils }) {   if ( $numlines < 1 ) {
     if ($target ne 'tex') {      $numlines = 1;
  if ($direction eq 'horizontal') {   }
     $result.="<td>";    if ( $numlines > 1 ) {
  } else {       my $linetext;
     $result.="<br />";      for ( my $i = 0 ; $i < $numlines ; $i++ ) {
  }    $linetext .= $Apache::lonxml::counter + $i . ', ';
     }      }
     if ($target ne 'tex') {       $linetext =~ s/,\s$//;
                 $result.= '<label>';      $result .=
  $result.=   '\small {\textbf{'
     "<input type=\"radio\"   . $linetext . '}} '
                             onchange=\"javascript:setSubmittedPart('$part');\"   . ' {\footnotesize '
                             name=\"HWVAL_$Apache::inputtags::response['-1']\"   . &mt( '(Bubble once in [_1] lines)', $numlines )
                             value=\"$temp\" ";   . '} \hspace*{\fill} \\\\';
  if (defined($lastresponse{$name})) { $result .= 'checked="on"'; }   }
  $result .= ' />'.$Apache::response::foilgroup{$name.'.text'}."</label>";   else {
       $result .= '\textbf{' . $Apache::lonxml::counter . '}.';
    }
   
    # Now output the bubbles themselves:
   
    foreach my $name (@{$whichfoils}) {
       if ( $bubble_number >= $bubbles_per_line ) {
    $line++;
    $i             = 0;
    $bubble_number = 0;
       }
       my $identifier;
       if ( $numlines > 1 ) {
    $identifier = $Apache::lonxml::counter + $line;
       }
       my $preindent;
       if ($bubble_number > 0) {
    $preindent = '\hspace*{3 mm}';
       }
       my $foiltext = $Apache::response::foilgroup{$name . '.text'};
       $foiltext =~ s/\\noindent//; # forgive me for I have sinned..
       $result .= '{\small \textbf{'
    . $identifier  .$preindent
    . $alphabet[$i]
    . '}}$\bigcirc$'
    . $foiltext
       . '\\\\';    #' stupid emacs -- it thinks it needs that apostrophe to close the quote
       
       $i++;
       $bubble_number++;
    }
   
       }
   
       return $result;
       
   }
   
   ##
   #  Display latex when exam mode is not on.
   #
   #  @param $whichfoils - The foils to display
   #  @param $direction  - Display direction ('horizontal' is what matters to us).
   #  @param $venv       - Vertical env. to use for vertical rendering.
   #  @param  $vend      - End the vertical environment being used.
   #
   #  @return string
   #  @retval - The LaTeX rendering of the resource.'
   #
   sub display_latex {
       my ($whichfoils, $direction, $venv) = @_;
       my $result;
   
       # how we render depends on the direction.
       # Vertical is some kind of list environment determined by vbegin/vend.
       # Horizontal is a table that is generated by 
       # Apache::caparesponse::make_horizontal_latex_bubbles with an empty string
       # for the actual bubble text.
   
       if ($direction eq 'horizontal') {
    my @foil_texts = &get_foil_texts($whichfoils);
    $result .= &Apache::caparesponse::make_horizontal_latex_bubbles(
       $whichfoils, \@foil_texts, '');
       } else {
    $result .= "\\begin{$venv}";
    foreach my $name (@{$whichfoils}) {
       $result .=  '\vspace*{-2 mm}\item '
    . $Apache::response::foilgroup{ $name . '.text' };
    }
   
    $result .= "\\end{$venv}";
       }
       return $result;
   }
   
   
   ##
   #  Render foils for a PDF form. This is a variant of tex rednering that provides
   #  sufficient markup that the final PDF is a form that can be filled in online,
   #  or offline.
   #
   # @param $whichfoils - References an array of foils to display in the order in which
   #                     they should be displayed.
   # @param $direction  - Rendering direction.  'horiztonal' means inputs are laid out
   #                      horizontally otherwise they are stacked vertically.
   # @param $venv       - Vertical environment in which to wrap the foils.
   #
   # @return string
   # @retval String containing the rendering of the resource.
   #
   # TODO: Take into account direction!!!
   #
   sub display_pdf_form {
       my ($whichfoils, $direction, $venv) = @_;
       my $temp = 0;
       my $result;
   
       $result .= "\\begin{$venv}";
       foreach my $name ( @{$whichfoils} ) {
   
    my $fieldname =
       $env{'request.symb'} 
    . '&part_'
       . $Apache::inputtags::part
       . '&radiobuttonresponse'
       . '&HWVAL_'
       . $Apache::inputtags::response['-1'];
    $result .= '\item[{'
       . &Apache::lonxml::print_pdf_radiobutton( $fieldname,
         $temp )
       . '}]'
       . $Apache::response::foilgroup{ $name . '.text' }
    . "\n";
   
    $temp++;
       }
       $result .= "\\end{$venv}";
   
       return $result;
   }
   
   
   ##
   # Display selected foils:  This is really just a dispatchter to appropriate renderers
   #  
   # @param $target   - Target (e.g. 'tex'...).
   # @param $answer   - True if answers should be shown.
   # @param $whichfoils - Array of foil selectors that indicate which foils shouild be
   #                      rendered, in rendering order.
   # @param $direction- Rendering direction ('horizontal' is the one we look for,
   #                    otherwise foils are rendered one per line vertically.
   # @param $bubbles_per_line - number of exam bubbles per line.
   #
   # @return string
   # @retval The rendered problem.
   
   sub displayfoils {
       my ($target,$answer,$whichfoils,$direction, $bubbles_per_line)=@_;
       my $result;
   
   
       my $part   = $Apache::inputtags::part;
       my $solved = $Apache::lonhomework::history{"resource.$part.solved"};
   
       # Show answers html.
   
       if ( ( $target ne 'tex' )
           && &Apache::response::show_answer() )
       {
   
    $result = &display_foils_html(
       $whichfoils, $target, $direction, $part,  1);
   
    # other html
       }  elsif ($target ne 'tex') {
       $result = &display_foils_html($whichfoils, $target, $direction, $part,
     0, 0);
   
          # LaTeX rendering:
       } else {
   
   
           my $id            = $Apache::inputtags::response['-1'];
           my $part          = $Apache::inputtags::part;
    my $numlines;
   
    # Decide how to bracket the list of foils:
   
    my $vertical_env = &latex_vertical_environment();
   
    # Rendering for latex exams.
   
    if ( ( $Apache::lonhomework::type eq 'exam' ) )
    {
       $result .= &display_latex_exam(
    $whichfoils, $bubbles_per_line, $direction, $vertical_env);
   
       $result .= '\vskip 0mm ';
       
    } else {    
   
       # Different rendering for PDF form than for a
       # 'regular' answer direction is honored in both of those
       #
   
       if ( ($env{'form.pdfFormFields'} eq 'yes')
       && ($Apache::inputtags::status[-1] eq 'CAN_ANSWER'))
       {
    $result .= &display_pdf_form($whichfoils, $direction, $vertical_env);
     } else {      } else {
  if ($Apache::lonhomework::type eq 'exam') {   $result .= &display_latex($whichfoils,  $direction, $vertical_env );
     if($bubble_number >= $bubbles_per_line) {  
  $line++;  
  $i = 0;  
  $bubble_number = 0;  
  $result.='\item[\textbf{'.($Apache::lonxml::counter+$line).'}.]';  
     }  
     $result .= '{\small \textbf{'.$alphabet[$i].'}}$\bigcirc$'.$Apache::response::foilgroup{$name.'.text'}.'\\\\';  #' stupid emacs  
     $i++;  
     $bubble_number++;  
  } else {  
     $result .= '\vspace*{-2 mm}\item '.$Apache::response::foilgroup{$name.'.text'};  
  }  
     }  
     if ($target ne 'tex' && $direction eq 'horizontal') {  
  $result.="</td>";   
     }      }
     $temp++;      $result .= '\vskip 0 mm '; 
  }         
  if ($target ne 'tex' && $direction eq 'horizontal') {  
     $result.="</tr></table>";  
  }   }
     }      }
     if ($target ne 'tex') { if ($direction ne 'horizontal') { $result.="<br />";} } else { $result.='\vskip 0 mm '; }  
     return $result;      return $result;
 }  }
   
Line 755  sub end_foil { Line 1344  sub end_foil {
  if ($value ne 'unused') {   if ($value ne 'unused') {
     my $name = &Apache::lonxml::get_param('name',$parstack,$safeeval);      my $name = &Apache::lonxml::get_param('name',$parstack,$safeeval);
     if ($name eq "") {      if ($name eq "") {
  &Apache::lonxml::warning("Foils without names exist. This can cause problems to malfunction.");   &Apache::lonxml::warning(&mt('Foils without names exist. This can cause problems to malfunction.'));
  $name=$Apache::lonxml::curdepth;   $name=$Apache::lonxml::curdepth;
     }      }
     if (defined($Apache::response::foilnames{$name})) {      if (defined($Apache::response::foilnames{$name})) {
  &Apache::lonxml::error(&mt("Foil name <b><tt>[_1]</tt></b> appears more than once. Foil names need to be unique.",$name));   &Apache::lonxml::error(&mt('Foil name [_1] appears more than once. Foil names need to be unique.','<b><tt>'.$name.'</tt></b>'));
     }      }
     $Apache::response::foilnames{$name}++;      $Apache::response::foilnames{$name}++;
     my $location =&Apache::lonxml::get_param('location',$parstack,      my $location =&Apache::lonxml::get_param('location',$parstack,
Line 788  sub insert_foil { Line 1377  sub insert_foil {
 <endouttext />  <endouttext />
 </foil>';  </foil>';
 }  }
   
 1;  1;
 __END__  __END__
   
   
   
   =head1 NAME
   
   Apache::radiobuttonresponse
   
   =head1 SYNOPSIS
   
   Handles multiple-choice style responses.
   
   This is part of the LearningOnline Network with CAPA project
   described at http://www.lon-capa.org.
   
   =head1 SUBROUTINES
   
   =over
   
   =item start_radiobuttonresponse()
   
   =item bubble_line_count()
   
   =item end_radiobuttonresponse()
   
   =item start_foilgroup()
   
   =item storesurvey()
   
   =item grade_response()
   
   =item end_foilgroup()
   
   =item getfoilcounts()
   
   =item format_prior_answer()
   
   =item displayallfoils()
   
   =item &whichfoils($max,$randomize)
   
   Randomizes the list of foils.
   Respects
     - each foils desire to be randomized
     - the existance of Concept groups of foils (select 1 foil from each)
     - and selects a single correct statement from all possilble true statments
     - and limits it to a toal of $max foils
   
   WARNING: this routine uses the random number generator, it should only
   be called once per target, otherwise it can cause randomness changes in
   homework problems.
   
   Arguments
     $max - maximum number of foils to select (including the true one)
            (so a max of 5 is: 1 true, 4 false)
   
     $randomize - whether to randomize the listing of foils, by default
                  will randomize, only if randomize is 'no' will it not
   
   Returns
     $answer - location in the array of the correct answer
     @foils  - array of foil names in to display order
   
   =item displayfoils()
   
   =item displayallanswers()
   
   =item displayanswers()
   
   =item start_conceptgroup()
   
   =item end_conceptgroup()
   
   =item insert_conceptgroup()
   
   =item start_foil()
   
   =item end_foil()
   
   =item insert_foil()
   
   =back
   
   =cut
     
Removed from v.1.124  
changed lines
  Added in v.1.157.2.1

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