File:  [LON-CAPA] / loncom / homework / response.pm
Revision 1.228: download - view: text, annotated - select for diffs
Tue Nov 29 13:24:38 2011 UTC (12 years, 5 months ago) by raeburn
Branches: MAIN
CVS tags: HEAD
- Bug 2802.
  - optionresponse::is_nonlenient() moved to inputtags::grading_is_nonlenient()
    to facilitate re-use.
  - where solved is "correct", awarded value < 1 permits new submission,
    only if lenient grading applies.
  - add lenient parameter to custompartial.problem template.

    1: # The LearningOnline Network with CAPA
    2: # various response type definitons response definition
    3: #
    4: # $Id: response.pm,v 1.228 2011/11/29 13:24:38 raeburn Exp $
    5: #
    6: # Copyright Michigan State University Board of Trustees
    7: #
    8: # This file is part of the LearningOnline Network with CAPA (LON-CAPA).
    9: #
   10: # LON-CAPA is free software; you can redistribute it and/or modify
   11: # it under the terms of the GNU General Public License as published by
   12: # the Free Software Foundation; either version 2 of the License, or
   13: # (at your option) any later version.
   14: #
   15: # LON-CAPA is distributed in the hope that it will be useful,
   16: # but WITHOUT ANY WARRANTY; without even the implied warranty of
   17: # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   18: # GNU General Public License for more details.
   19: #
   20: # You should have received a copy of the GNU General Public License
   21: # along with LON-CAPA; if not, write to the Free Software
   22: # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   23: #
   24: # /home/httpd/html/adm/gpl.txt
   25: #
   26: # http://www.lon-capa.org/
   27: #
   28: 
   29: =pod
   30: 
   31: =head1 NAME
   32: 
   33: Apache::response.pm
   34: 
   35: =head1 SYNOPSIS
   36: 
   37: This is part of the LearningOnline Network with CAPA project
   38: described at http://www.lon-capa.org.
   39: 
   40: 
   41: =head1 NOTABLE SUBROUTINES
   42: 
   43: =over
   44: 
   45: =item 
   46: 
   47: =back
   48: 
   49: =cut
   50: 
   51: 
   52: package Apache::response;
   53: use strict;
   54: use Apache::lonlocal;
   55: use Apache::lonnet;
   56: use Apache::inputtags();
   57: use Apache::lonmaxima();
   58: use Apache::lonr();
   59: 
   60: BEGIN {
   61:     &Apache::lonxml::register('Apache::response',('responseparam','parameter','dataresponse','customresponse','mathresponse'));
   62: }
   63: 
   64: sub start_response {
   65:     my ($parstack,$safeeval)=@_;
   66:     my $id = &Apache::lonxml::get_id($parstack,$safeeval);
   67:     if ($#Apache::inputtags::import > -1) {
   68: 	&Apache::lonxml::debug("Turning :$id: into");
   69: 	$id = join('_',@Apache::inputtags::import).'_'.$id;
   70: 	&Apache::lonxml::debug("New  :$id:");
   71:     }
   72:     push (@Apache::inputtags::response,$id);
   73:     push (@Apache::inputtags::responselist,$id);
   74:     @Apache::inputtags::inputlist=();
   75:     if ($Apache::inputtags::part eq '' && 
   76: 	!$Apache::lonhomework::ignore_response_errors) {
   77: 	&Apache::lonxml::error(&HTML::Entities::encode(&mt("Found a <*response> outside of a <part> in a <part>ed problem"),'<>&"'));
   78:     }
   79:     if ($Apache::inputtags::response_with_no_part &&
   80: 	$Apache::inputtags::part ne '0') {
   81: 	&Apache::lonxml::error(&HTML::Entities::encode(&mt("<*response>s are both inside of <part> and outside of <part>, this is not a valid problem, errors in grading may occur."),'<>&"').'<br />');
   82:     }
   83:     if ($Apache::inputtags::part eq '0') {
   84: 	$Apache::inputtags::response_with_no_part=1;
   85:     }
   86:     return $id;
   87: }
   88: 
   89: sub end_response {
   90:     #pop @Apache::inputtags::response;
   91:     @Apache::inputtags::inputlist=();
   92:     return '';
   93: }
   94: 
   95: sub start_hintresponse {
   96:     my ($parstack,$safeeval)=@_;
   97:     my $id = &Apache::lonxml::get_id($parstack,$safeeval);
   98:     push (@Apache::inputtags::hint,$id);
   99:     push (@Apache::inputtags::hintlist,$id);
  100:     push (@Apache::inputtags::paramstack,[%Apache::inputtags::params]);
  101:     return $id;
  102: }
  103: 
  104: sub end_hintresponse {
  105:     pop @Apache::inputtags::hint;
  106:     if (defined($Apache::inputtags::paramstack[-1])) {
  107: 	%Apache::inputtags::params=
  108: 	    @{ pop(@Apache::inputtags::paramstack) };
  109:     }
  110:     return '';
  111: }
  112: 
  113: my @randomseeds;
  114: sub pushrandomnumber {
  115:     my $rand_alg=&Apache::lonnet::get_rand_alg();
  116:     if (!$rand_alg || $rand_alg eq '32bit' || $rand_alg eq '64bit' ||
  117: 	$rand_alg eq '64bit2') {
  118: 	# do nothing
  119:     } else {
  120: 	my @seed=&Math::Random::random_get_seed();
  121: 	push(@randomseeds,\@seed);
  122:     }
  123:     &Apache::response::setrandomnumber(@_);
  124: }
  125: sub poprandomnumber {
  126:     my $rand_alg=&Apache::lonnet::get_rand_alg();
  127:     if (!$rand_alg || $rand_alg eq '32bit' || $rand_alg eq '64bit' ||
  128: 	$rand_alg eq '64bit2') {
  129: 	return;
  130:     }
  131:     my $seed=pop(@randomseeds);
  132:     if ($seed) {
  133: 	&Math::Random::random_set_seed(@$seed);
  134:     } else {
  135: 	&Apache::lonxml::error("Unable to restore random algorithm.");
  136:     }
  137: }
  138: 
  139: sub setrandomnumber {
  140:     my ($ignore_id2,$target,$rndseed) = @_;
  141:     if (!defined($rndseed)) {
  142:         $rndseed=&Apache::structuretags::setup_rndseed(undef,$target);
  143:     } 
  144:     if (!defined($rndseed)) { $rndseed=&Apache::lonnet::rndseed(); }
  145:     &Apache::lonxml::debug("randseed $rndseed");
  146:     #  $rndseed=unpack("%32i",$rndseed);
  147:     my $rand_alg=&Apache::lonnet::get_rand_alg();
  148:     my ($rndmod,$rndmod2);
  149: 
  150:     my ($id1,$id2,$shift_amt);
  151:     if ($Apache::lonhomework::parsing_a_problem) {
  152: 	$id1=$Apache::inputtags::part;
  153: 	if (defined($Apache::inputtags::response[-1])) {
  154: 	    $id2=$Apache::inputtags::response[-1];
  155: 	}
  156: 	$shift_amt=scalar(@Apache::inputtags::responselist);
  157:     } elsif ($Apache::lonhomework::parsing_a_task) {
  158: 	$id1=&Apache::bridgetask::get_dim_id();
  159: 	if (!$ignore_id2 && ref($Apache::bridgetask::instance{$id1})) {
  160: 	    $id2=$Apache::bridgetask::instance{$id1}[-1];
  161: 	    $shift_amt=scalar(@{$Apache::bridgetask::instance{$id1}});
  162: 	} else {
  163: 	    $shift_amt=0;
  164: 	}
  165:     } 
  166:     &Apache::lonxml::debug("id1: $id1, id2: $id2, shift_amt: $shift_amt");
  167:     if (!$rand_alg || $rand_alg eq '32bit' || $rand_alg eq '64bit' ||
  168: 	$rand_alg eq '64bit2') {
  169: 	$rndmod=(&Apache::lonnet::numval($id1) << 10);
  170: 	if (defined($id2)) { $rndmod+=&Apache::lonnet::numval($id2); }
  171:     } elsif ($rand_alg eq '64bit3') {
  172: 	$rndmod=(&Apache::lonnet::numval2($id1) << 10);
  173: 	if (defined($id2)) { $rndmod+=&Apache::lonnet::numval2($id2); }
  174:     } elsif ($rand_alg eq '64bit4') {
  175: 	my $shift=(4*$shift_amt)%30;
  176: 	$rndmod=(&Apache::lonnet::numval3($id1) << (($shift+15)%30));
  177: 	if (defined($id2)) {
  178: 	    $rndmod+=(&Apache::lonnet::numval3($id2) << $shift );
  179: 	}
  180:     } else {
  181: 	($rndmod,$rndmod2)=&Apache::lonnet::digest("$id1,$id2");
  182:     }
  183:     $Apache::lonhomework::results{'resource.'.$id1.'.rawrndseed'}=$rndseed;
  184:     if ($rndseed =~/([,:])/) {
  185: 	my $char=$1;
  186: 	use integer;
  187: 	my ($num1,$num2)=split(/\Q$char\E/,$rndseed);
  188: 	$num1+=$rndmod;
  189: 	$num2+= ((defined($rndmod2)) ? $rndmod2 : $rndmod);
  190: 	if($Apache::lonnet::_64bit) { $num1=(($num1<<32)>>32); $num2=(($num2<<32)>>32); }
  191: 	$rndseed=$num1.$char.$num2;
  192:     } else {
  193: 	$rndseed+=$rndmod;
  194: 	if($Apache::lonnet::_64bit) {
  195: 	    use integer;
  196: 	    $rndseed=(($rndseed<<32)>>32);
  197: 	}
  198:     }
  199:     &Apache::lonxml::debug("randseed $rndmod $rndseed");
  200:     $Apache::lonhomework::results{'resource.'.$id1.'.rndseed'}=$rndseed;
  201:     &Apache::lonnet::setup_random_from_rndseed($rndseed);
  202:     return '';
  203: }
  204: 
  205: sub meta_parameter_write {
  206:     my ($name,$type,$default,$display)=@_;
  207:     my $partref=$Apache::inputtags::part;
  208:     my $result='<parameter part="'.$Apache::inputtags::part.'"';
  209:     if (defined($Apache::inputtags::response[-1])) {
  210: 	$result.=            ' id="'.$Apache::inputtags::response[-1].'"';
  211: 	$partref.='_'.$Apache::inputtags::response[-1];
  212:     }
  213:     $result.=            ' name="'.$name.'"'.
  214:                          ' type="'.$type.'"'.
  215: (defined($default)?' default="'.$default.'"':'').
  216: (defined($display)?' display="'.$display.' [Part: '.$partref.']"':'')
  217:              .'></parameter>'
  218:              ."\n";
  219:     return $result;
  220: }
  221: 
  222: sub meta_package_write {
  223:     my $name=shift;
  224:     my $result = '<parameter part="'.$Apache::inputtags::part.'"';
  225:     if(defined($Apache::inputtags::response[-1])) {
  226: 	$result.= ' id="'.$Apache::inputtags::response[-1].'"';
  227:     }
  228:     $result.=' package="'.$name.'"></parameter>'."\n";
  229:     return $result;
  230: }
  231: 
  232: sub meta_stores_write {
  233:     my ($name,$type,$display)=@_;
  234:     my $partref=$Apache::inputtags::part;
  235:     my $result = '<stores part="'.$Apache::inputtags::part.'"';
  236:     if (defined($Apache::inputtags::response[-1])) {
  237: 	$result.=           ' id="'.$Apache::inputtags::response[-1].'"';
  238: 	$partref.='_'.$Apache::inputtags::response[-1];
  239:     }	
  240:     $result.=          ' name="'.$name.'"'.
  241:                        ' type="'.$type.'"'.
  242: 	            ' display="'.$display.' [Part: '.$partref.']"'.
  243: 		      "></stores>\n";
  244: }
  245: 
  246: =pod
  247: 
  248: =item mandatory_part_meta()
  249: 
  250: Autogenerate metadata for mandatory
  251: input (from RAT or lonparmset) and
  252: output (to lonspreadsheet)
  253: of each part
  254: 
  255: Note: responseid-specific data 'submission' and 'awarddetail'
  256: not available to spreadsheet -> skip here
  257: 
  258: =cut
  259: 
  260: 
  261: sub mandatory_part_meta {
  262:     return &meta_package_write('part').
  263:            &meta_stores_write('solved','string','Problem Status').
  264:            &meta_stores_write('tries','int_zeropos','Number of Attempts').
  265:            &meta_stores_write('awarded','float','Partial Credit Factor');
  266: }
  267: 
  268: sub meta_part_order {
  269:     if (@Apache::inputtags::partlist) {
  270: 	my @parts=@Apache::inputtags::partlist;
  271: 	shift(@parts);
  272: 	return '<partorder>'.join(',',@parts).'</partorder>'."\n";
  273:     } else {
  274: 	return '<partorder>0</partorder>'."\n";
  275:     }
  276: }
  277: 
  278: sub meta_response_order {
  279:     if (@Apache::inputtags::responselist) {
  280: 	return '<responseorder>'.join(',',@Apache::inputtags::responselist).
  281: 	    '</responseorder>'."\n";
  282:     }
  283: }
  284: 
  285: sub check_for_previous {
  286:     my ($curresponse,$partid,$id,$last,$type) = @_;
  287:     my %previous;
  288:     $previous{'used'} = 0;
  289:     my $questiontype = $Apache::lonhomework::type;
  290:     my $curr_rndseed = $env{'form.'.$partid.'.rndseed'};
  291:     foreach my $key (sort(keys(%Apache::lonhomework::history))) {
  292: 	if ($key =~ /resource\.\Q$partid\E\.\Q$id\E\.submission$/) {
  293: 	    if ( $last && $key =~ /^(\d+):/ ) {
  294: 		next if ($1 >= $last);
  295: 	    }
  296: 	    &Apache::lonxml::debug("Trying $key");
  297: 	    my $pastresponse=$Apache::lonhomework::history{$key};
  298: 	    if ($pastresponse eq $curresponse) {
  299: 		my $history;
  300: 		if ( $key =~ /^(\d+):/ ) {
  301:                     $history=$1;
  302:                     next if ((($questiontype eq 'randomizetry') ||
  303:                              ($Apache::lonhomework::history{"$history:resource.$partid.type"} eq 'randomizetry')) &&
  304:                              ($curr_rndseed ne $Apache::lonhomework::history{"$history:resource.$partid.rndseed"}));
  305: 		    $previous{'award'} = $Apache::lonhomework::history{"$history:resource.$partid.$id.awarddetail"};
  306: 		    $previous{'last'}='0';
  307: 		    push(@{ $previous{'version'} },$history);
  308: 		} else {
  309:                     next if ((($questiontype eq 'randomizetry') ||
  310:                              ($Apache::lonhomework::history{"resource.$partid.type"} eq 'randomizetry')) &&
  311:                              ($curr_rndseed ne $Apache::lonhomework::history{"resource.$partid.rndseed"}));
  312: 		    $previous{'award'} = $Apache::lonhomework::history{"resource.$partid.$id.awarddetail"};
  313: 		    $previous{'last'}='1';
  314: 		}
  315:                 $previous{'used'} = 1;
  316: 		if (! $previous{'award'} ) { $previous{'award'} = 'UNKNOWN';	}
  317:                 if ($previous{'award'} eq 'INTERNAL_ERROR') { $previous{'used'}=0; }
  318: 		&Apache::lonxml::debug("got a match :$previous{'award'}:$previous{'used'}:");
  319:             } elsif ($type eq 'ci') {
  320:                 if (lc($pastresponse) eq lc($curresponse)) {
  321:                     if ($key =~ /^(\d+):/) {
  322:                         my $history = $1;
  323:                         next if (($questiontype eq 'randomizetry') &&
  324:                              ($curr_rndseed ne $Apache::lonhomework::history{"$history:resource.$partid.rndseed"}));
  325:                         push (@{$previous{'versionci'}},$history);
  326:                         $previous{'awardci'} = $Apache::lonhomework::history{"$history:resource.$partid.$id.awarddetail"};
  327:                         $previous{'usedci'} = 1;
  328:                     }
  329:                 }
  330:             }
  331: 	}
  332:     }
  333:     &Apache::lonhomework::showhash(%previous);
  334:     return %previous;
  335: }
  336: 
  337: sub handle_previous {
  338:     my ($previous,$ad)=@_;
  339:     if ($$previous{'used'} && ($$previous{'award'} eq $ad) ) {
  340: 	if ($$previous{'last'}) {
  341: 	    push(@Apache::inputtags::previous,'PREVIOUSLY_LAST');
  342: 	    push(@Apache::inputtags::previous_version,$$previous{'version'});
  343: 	} elsif (($Apache::lonhomework::type ne 'survey') &&
  344:                  ($Apache::lonhomework::type ne 'surveycred') &&
  345:                  ($Apache::lonhomework::type ne 'anonsurvey') &&
  346:                  ($Apache::lonhomework::type ne 'anonsurveycred')) {
  347: 	    push(@Apache::inputtags::previous,'PREVIOUSLY_USED');
  348: 	    push(@Apache::inputtags::previous_version,$$previous{'version'});
  349: 	}
  350:     }
  351: }
  352: 
  353: sub view_or_modify {
  354:     my ($symb,$courseid,$domain,$name) = &Apache::lonnet::whichuser();
  355:     my $myself=0;
  356:     if ( ($name eq $env{'user.name'}) && ($domain eq $env{'user.domain'}) ) {
  357: 	$myself=1;
  358:     }
  359:     my $vgr=&Apache::lonnet::allowed('vgr',$courseid);
  360:     my $mgr=&Apache::lonnet::allowed('vgr',$courseid);
  361:     if ($mgr) { return "M"; }
  362:     if ($vgr) { return "V"; }
  363:     if ($myself) { return "V"; }
  364:     return '';
  365: }
  366: 
  367: sub start_dataresponse {
  368:     my ($target,$token,$tagstack,$parstack,$parser,$safeeval)=@_;
  369:     my $id = &Apache::response::start_response($parstack,$safeeval);
  370:     my $result;
  371:     if ($target eq 'web') {
  372: 	$result = $token->[2]->{'display'}.':';
  373:     } elsif ($target eq 'meta') {
  374: 	$result = &Apache::response::meta_stores_write($token->[2]->{'name'},
  375: 						       $token->[2]->{'type'},
  376: 						       $token->[2]->{'display'});
  377: 	$result .= &Apache::response::meta_package_write('dataresponse');
  378:     }
  379:     return $result;
  380: }
  381: 
  382: sub end_dataresponse {
  383:     my ($target,$token,$tagstack,$parstack,$parser,$safeeval)=@_;
  384:     my $result;
  385:     if ( $target eq 'web' ) {
  386:     } elsif ($target eq 'grade' ) {
  387: 	if ( defined $env{'form.submitted'}) {
  388: 	    my ($symb,$courseid,$domain,$name)=&Apache::lonnet::whichuser();
  389: 	    my $allowed=&Apache::lonnet::allowed('mgr',$courseid);
  390: 	    if ($allowed) {
  391: 		&Apache::response::setup_params('dataresponse',$safeeval);
  392: 		my $partid = $Apache::inputtags::part;
  393: 		my $id = $Apache::inputtags::response['-1'];
  394: 		my $response = $env{'form.HWVAL_'.$id};
  395: 		my $name = &Apache::lonxml::get_param('name',$parstack,$safeeval);
  396: 		if ( $response =~ /[^\s]/) {
  397: 		    $Apache::lonhomework::results{"resource.$partid.$id.$name"}=$response;
  398: 		    $Apache::lonhomework::results{"resource.$partid.$id.submission"}=$response;
  399: 		    $Apache::lonhomework::results{"resource.$partid.$id.awarddetail"}='SUBMITTED';
  400: 		}
  401: 	    } else {
  402: 		$result='Not Permitted to change values.'
  403: 	    }
  404: 	}
  405:     }
  406:     &Apache::response::end_response;
  407:     return $result;
  408: }
  409: 
  410: sub start_customresponse {
  411:     my ($target,$token,$tagstack,$parstack,$parser,$safeeval)=@_;
  412:     my $id = &Apache::response::start_response($parstack,$safeeval);
  413:     push(@Apache::lonxml::namespace,'customresponse');
  414:     my $result;
  415:     @Apache::response::custom_answer=();
  416:     @Apache::response::custom_answer_type=();
  417:     &Apache::lonxml::register('Apache::response',('answer'));
  418:     if ($target eq 'web') {
  419:   	if (  &Apache::response::show_answer() ) {
  420: 	    my $answer = &Apache::lonxml::get_param('answerdisplay',$parstack,
  421: 						   $safeeval);
  422: 	    $Apache::inputtags::answertxt{$id}=[$answer];
  423: 	}
  424:     } elsif ($target eq 'edit') {
  425: 	$result.=&Apache::edit::tag_start($target,$token);
  426: 	$result.=&Apache::edit::text_arg('String to display for answer:',
  427: 					 'answerdisplay',$token,'50');
  428: 	$result.=&Apache::edit::end_row().&Apache::edit::start_spanning_row();
  429:     } elsif ($target eq 'modified') {
  430: 	my $constructtag;
  431: 	$constructtag=&Apache::edit::get_new_args($token,$parstack,
  432: 						  $safeeval,'answerdisplay');
  433: 	if ($constructtag) {
  434: 	    $result = &Apache::edit::rebuild_tag($token);
  435: 	}
  436:     } elsif ($target eq 'answer' || $target eq 'grade') {
  437: 	&Apache::response::reset_params();
  438:     } elsif ($target eq 'meta') {
  439: 	$result .= &Apache::response::meta_package_write('customresponse');
  440:     }
  441:     return $result;
  442: }
  443: 
  444: sub end_customresponse {
  445:     my ($target,$token,$tagstack,$parstack,$parser,$safeeval)=@_;
  446:     my $result;
  447:     my $part=$Apache::inputtags::part;
  448:     my $id=$Apache::inputtags::response[-1];
  449:     if ( $target eq 'grade' && &Apache::response::submitted() ) {
  450: 	my $response = &Apache::response::getresponse();
  451: 	if ($Apache::lonhomework::type eq 'exam' ||
  452: 	    &Apache::response::submitted('scantron')) {
  453: 	    &Apache::response::scored_response($part,$id);
  454: 	} elsif ( $response =~ /[^\s]/ && 
  455: 		  $Apache::response::custom_answer_type[-1] eq 'loncapa/perl') {
  456: 	    if (!$Apache::lonxml::default_homework_loaded) {
  457: 		&Apache::lonxml::default_homework_load($safeeval);
  458: 	    }
  459: 	    my %previous = &Apache::response::check_for_previous($response,
  460: 								 $part,$id);
  461: 	    $Apache::lonhomework::results{"resource.$part.$id.submission"}=
  462: 		$response;
  463: 	    my $error;
  464: 	    ${$safeeval->varglob('LONCAPA::customresponse_submission')}=
  465: 		$response;
  466: 	    
  467: 	    my ($award,$score) = &Apache::run::run('{ my $submission=$LONCAPA::customresponse_submission;'.$Apache::response::custom_answer[-1].'}',$safeeval);
  468: 	    if (!&Apache::inputtags::valid_award($award)) {
  469: 		$error = $award;
  470: 		$award = 'ERROR';
  471: 	    }
  472: 	    &Apache::response::handle_previous(\%previous,$award);
  473: 	    $Apache::lonhomework::results{"resource.$part.$id.awarddetail"}=
  474: 		$award;
  475:             if ($award eq 'ASSIGNED_SCORE') {
  476:                 $Apache::lonhomework::results{"resource.$part.$id.awarded"}=1.0*$score;
  477:             }
  478: 	    if ($error) {
  479: 		$Apache::lonhomework::results{"resource.$part.$id.awardmsg"}=
  480: 		    $error;
  481: 	    }
  482: 	}
  483:     } elsif ( $target eq 'answer') {
  484: 	$result  = &Apache::response::answer_header('customresponse');
  485: 	my $answer = &Apache::lonxml::get_param('answerdisplay',$parstack,
  486: 						$safeeval);
  487: 	if ($env{'form.answer_output_mode'} ne 'tex') {
  488: 	    $answer = '<b>'.$answer.'</b>';
  489: 	}
  490: 	$result .= &Apache::response::answer_part('customresponse',$answer);
  491: 	$result .= &Apache::response::answer_footer('customresponse');
  492:     }
  493:     if ($target eq 'web') {
  494: 	&setup_prior_tries_hash(\&format_prior_response_math);
  495:     }
  496:     if ($target eq 'grade' || $target eq 'web' || $target eq 'answer' || 
  497: 	$target eq 'tex' || $target eq 'analyze') {
  498:         my $repetition = &repetition();
  499: 	&Apache::lonxml::increment_counter($repetition,"$part.$id");
  500: 	if ($target eq 'analyze') {
  501:             $Apache::lonhomework::analyze{"$part.$id.type"} = 'customresponse';
  502: 	    &Apache::lonhomework::set_bubble_lines();
  503: 	}
  504:     }
  505:     pop(@Apache::lonxml::namespace);
  506:     pop(@Apache::response::custom_answer);
  507:     pop(@Apache::response::custom_answer_type);
  508:     &Apache::lonxml::deregister('Apache::response',('answer'));
  509:     &Apache::response::end_response();
  510:     return $result;
  511: }
  512: 
  513: sub format_prior_response_custom {
  514:     my ($mode,$answer) =@_;
  515:     return '<span class="LC_prior_custom">'.
  516: 	    &HTML::Entities::encode($answer,'"<>&').'</span>';
  517: }
  518: 
  519: sub start_mathresponse {
  520:     my ($target,$token,$tagstack,$parstack,$parser,$safeeval)=@_;
  521:     my $id = &Apache::response::start_response($parstack,$safeeval);
  522:     push(@Apache::lonxml::namespace,'mathresponse');
  523:     my $result;
  524:     @Apache::response::custom_answer=();
  525:     @Apache::response::custom_answer_type=();
  526:     &Apache::lonxml::register('Apache::response',('answer'));
  527:     if ($target eq 'web') {
  528:   	if (  &Apache::response::show_answer() ) {
  529: 	    my $answer = &Apache::lonxml::get_param('answerdisplay',$parstack,
  530: 						   $safeeval);
  531: 	    $Apache::inputtags::answertxt{$id}=[$answer];
  532: 	}
  533: 
  534:     } elsif ($target eq 'edit') {
  535: 	$result.=&Apache::edit::tag_start($target,$token);
  536: 	$result.=&Apache::edit::text_arg('String to display for answer:',
  537: 					 'answerdisplay',$token,'50');
  538: 	$result.=&Apache::edit::select_arg('Algebra System:',
  539: 					   'cas',
  540: 					   ['maxima','R'],
  541: 					   $token);
  542: 	$result.=&Apache::edit::text_arg('Argument Array:',
  543: 					 'args',$token).
  544:                  &Apache::loncommon::help_open_topic('Maxima_Argument_Array');
  545:         $result.=&Apache::edit::text_arg('Libraries:',
  546:                                          'libraries',$token).
  547:                  &Apache::loncommon::help_open_topic('Maxima_Libraries');
  548: 	$result.=&Apache::edit::end_row().&Apache::edit::start_spanning_row();
  549:     } elsif ($target eq 'modified') {
  550: 	my $constructtag;
  551: 	$constructtag=&Apache::edit::get_new_args($token,$parstack,
  552: 						  $safeeval,'answerdisplay','cas','args','libraries');
  553: 	if ($constructtag) {
  554: 	    $result = &Apache::edit::rebuild_tag($token);
  555: 	}
  556:     } elsif ($target eq 'answer' || $target eq 'grade') {
  557: 	&Apache::response::reset_params();
  558:     } elsif ($target eq 'meta') {
  559: 	$result .= &Apache::response::meta_package_write('mathresponse');
  560:     }
  561:     return $result;
  562: }
  563: 
  564: sub edit_mathresponse_button {
  565:     my ($id,$field)=@_;
  566:     my $button=&mt('Edit Answer');
  567: #    my $helplink=&Apache::loncommon::help_open_topic('Formula_Editor');
  568:     my $iconpath=$Apache::lonnet::perlvar{'lonIconsURL'};
  569:     return(<<ENDFORMULABUTTON);
  570: <script type="text/javascript" language="JavaScript">
  571: function edit_${id}_${field} (textarea) {
  572:     thenumber = textarea;
  573:     thedata = document.forms['lonhomework'].elements[textarea].value;
  574:     newwin = window.open("/adm/dragmath/applet/MaximaPopup.html","","width=565,height=400,resizable");
  575: }
  576: </script>
  577: <a href="javascript:edit_${id}_${field}('${field}');void(0);"><img class="stift" src="$iconpath/stift.gif" alt="$button" title="$button" /></a>
  578: ENDFORMULABUTTON
  579: }
  580: 
  581: sub end_mathresponse {
  582:     my ($target,$token,$tagstack,$parstack,$parser,$safeeval)=@_;
  583:     my $result;
  584:     my $part=$Apache::inputtags::part;
  585:     my $id=$Apache::inputtags::response[-1];
  586:     if ( $target eq 'grade' && &Apache::response::submitted() ) {
  587: 	my $response = &Apache::response::getresponse();
  588: 	if ( $response =~ /[^\s]/ ) {
  589: 	    if (!$Apache::lonxml::default_homework_loaded) {
  590: 		&Apache::lonxml::default_homework_load($safeeval);
  591: 	    }
  592: 	    my %previous = &Apache::response::check_for_previous($response,
  593: 								 $part,$id);
  594: 	    $Apache::lonhomework::results{"resource.$part.$id.submission"}=
  595: 		$response;
  596: 	    my $error;
  597: 	    my $award;
  598: 	    my $cas = &Apache::lonxml::get_param('cas',$parstack,$safeeval);
  599:             if ($cas eq 'maxima') {
  600:                 my $args = [&Apache::lonxml::get_param_var('args',$parstack,$safeeval)];
  601:                 $award=&Apache::lonmaxima::maxima_run($Apache::response::custom_answer[-1],$response,$args,
  602:                                                       &Apache::lonxml::get_param('libraries',$parstack,$safeeval));
  603:             }
  604:             if ($cas eq 'R') {
  605:                 my $args = [&Apache::lonxml::get_param_var('args',$parstack,$safeeval)];
  606:                 $award=&Apache::lonr::r_run($Apache::response::custom_answer[-1],$response,$args,
  607:                                             &Apache::lonxml::get_param('libraries',$parstack,$safeeval));
  608:             }
  609: 
  610: 	    if (!&Apache::inputtags::valid_award($award)) {
  611: 		$error = $award;
  612: 		$award = 'ERROR';
  613: 	    }
  614: 	    &Apache::response::handle_previous(\%previous,$award);
  615: 	    $Apache::lonhomework::results{"resource.$part.$id.awarddetail"}=
  616: 		$award;
  617: 	    if ($error) {
  618: 		$Apache::lonhomework::results{"resource.$part.$id.awardmsg"}=
  619: 		    $error;
  620: 	    }
  621: 	}
  622:     }
  623:     if ($target eq 'web') {
  624: 	&setup_prior_tries_hash(\&format_prior_response_math);
  625:         my $partid = $Apache::inputtags::part;
  626:         my $id = $Apache::inputtags::response[-1];
  627:         if (($Apache::inputtags::status['-1'] eq 'CAN_ANSWER')
  628:            && (&Apache::lonnet::EXT('resource.'.$partid.'_'.$id.'.turnoffeditor') ne 'yes')) {
  629:             $result.=&edit_mathresponse_button($id,"HWVAL_$id");
  630:         }
  631:     }
  632: 
  633:     pop(@Apache::lonxml::namespace);
  634:     pop(@Apache::response::custom_answer);
  635:     pop(@Apache::response::custom_answer_type);
  636:     &Apache::lonxml::deregister('Apache::response',('answer'));
  637:     &Apache::response::end_response();
  638:     return $result;
  639: }
  640: 
  641: sub format_prior_response_math {
  642:     my ($mode,$answer) =@_;
  643:     return '<span class="LC_prior_math">'.
  644: 	    &HTML::Entities::encode($answer,'"<>&').'</span>';
  645: }
  646: 
  647: sub implicit_multiplication {
  648:     my ($expression)=@_;
  649: # Escape scientific notation, so 3e8 does not become 3*e*8
  650: # 3e8 -> 3&8; 3e-8 -> 3&-8; 3E+8 -> e&+8
  651:     $expression=~s/(\d+)e([\+\-]*\d+)/$1\&\($2\)/gsi;
  652: # 3x10^8 -> 3&8; 3*10^-8 -> 3&-8
  653:     $expression=~s/(\d+)(?:x|\*)10(?:\^|\*\*)([\+\-]*\d+)/$1\&\($2\)/gsi;
  654: # Fill in multiplication signs
  655: # a b -> a*b;3 b -> 3*b;3 4 -> 3*4
  656:     $expression=~s/([A-Za-z0-9])\s+(?=[A-Za-z0-9])/$1\*/gs;
  657: # )( -> )*(; ) ( -> )*(
  658:     $expression=~s/\)\s*\(/\)\*\(/gs;
  659: # 3a -> 3*a; 3( -> 3*(; 3 ( -> 3*(; 3A -> 3*A
  660:     $expression=~s/(\d)\s*([a-zA-Z\(])/$1\*$2/gs;
  661: # a ( -> a*(
  662:     $expression=~s/([A-Za-z0-9])\s+\(/$1\*\(/gs;
  663: # )a -> )*a; )3 -> )*3; ) 3 -> )*3
  664:     $expression=~s/\)\s*([A-Za-z0-9])/\)\*$1/gs;
  665: # 3&8 -> 3e8; 3&-4 -> 3e-4
  666:     $expression=~s/(\d+)\&\(([\+\-]*\d+)\)/$1e$2/gs;
  667:     return $expression;
  668: }
  669: 
  670: sub start_answer {
  671:     my ($target,$token,$tagstack,$parstack,$parser,$safeeval)=@_;
  672:     my $result;
  673:     push(@Apache::response::custom_answer,
  674: 	&Apache::lonxml::get_all_text_unbalanced("/answer",$parser));
  675:     push(@Apache::response::custom_answer_type,
  676: 	lc(&Apache::lonxml::get_param('type',$parstack,$safeeval)));
  677:     $Apache::response::custom_answer_type[-1] =~ s/\s+//g;
  678:     if ($target eq "edit" ) {
  679: 	$result=&Apache::edit::tag_start($target,$token,'Answer algorithm');
  680: 	$result.=&Apache::edit::editfield($token->[1],
  681: 					  $Apache::response::custom_answer[-1],
  682: 					  '',80,4);
  683:     } elsif ( $target eq "modified" ) {
  684: 	$result=$token->[4].&Apache::edit::modifiedfield('/answer',$parser);
  685:     }
  686:     return $result;
  687: }
  688: 
  689: sub end_answer {
  690:     my ($target,$token,$tagstack,$parstack,$parser,$safeeval)=@_;
  691:     if ($target eq 'edit' ) {
  692: 	return &Apache::edit::end_table();
  693:     }
  694: }
  695: 
  696: sub decide_package {
  697:     my ($tagstack)=@_;
  698:     my $package;
  699:     if ($$tagstack[-1] eq 'parameter') {
  700: 	$package='part';
  701:     } else {
  702: 	my $i=-1;
  703: 	while (defined($$tagstack[$i])) {
  704: 	    if ($$tagstack[$i] =~ /(response|hint)$/) {
  705: 		$package=$$tagstack[$i];
  706: 		last;
  707: 	    }
  708: 	    $i--;
  709: 	}
  710:     }
  711:     return $package;
  712: }
  713: 
  714: sub start_responseparam {
  715:     my ($target,$token,$tagstack,$parstack,$parser,$safeeval)=@_;
  716:     my $result='';
  717:     if ($target eq 'meta') {
  718: 	$result = &meta_parameter_write($token->[2]->{'name'},
  719: 					$token->[2]->{'type'},
  720: 					$token->[2]->{'default'},
  721: 					$token->[2]->{'description'});
  722:     } elsif ($target eq 'edit') {
  723: 	$result.=&Apache::edit::tag_start($target,$token);
  724: 	my $optionlist;
  725: 	my $package=&decide_package($tagstack);
  726: 	foreach my $key (sort(keys(%Apache::lonnet::packagetab))) {
  727: 	    if ($key =~ /^\Q$package\E&(.*)&display$/) {
  728: 		$optionlist.='<option value="'.$1.'">'.
  729: 		    $Apache::lonnet::packagetab{$key}.'</option>';
  730: 	    }
  731: 	}
  732: 	if (defined($optionlist)) {
  733: 	    $result.=&mt('Use template:').' <select name="'.
  734: 		&Apache::edit::html_element_name('parameter_package').'">'.
  735: 		    '<option value=""></option>'.$optionlist.'</select><br />';
  736: 	}
  737: 	$result.=&Apache::edit::text_arg('Name:','name',$token).
  738: 	    &Apache::edit::text_arg('Type:','type',$token).
  739: 		&Apache::edit::text_arg('Description:','description',$token).
  740: 		    &Apache::edit::text_arg('Default:','default',$token).
  741: 			"</td></tr>";
  742: 	$result.=&Apache::edit::end_table;
  743:     } elsif ($target eq 'modified') {
  744: 	my $constructtag=&Apache::edit::get_new_args($token,$parstack,
  745: 						     $safeeval,'name','type',
  746: 						     'description','default');
  747: 	my $element=&Apache::edit::html_element_name('parameter_package');
  748: 	if (defined($env{"form.$element"}) && $env{"form.$element"} ne '') {
  749: 	    my $name=$env{"form.$element"};
  750: 	    my $tag=&decide_package($tagstack);
  751: 	    $token->[2]->{'name'}=$name;
  752: 	    $token->[2]->{'type'}=
  753: 		$Apache::lonnet::packagetab{"$tag&$name&type"};
  754: 	    $token->[2]->{'description'}=
  755: 		$Apache::lonnet::packagetab{"$tag&$name&display"};
  756: 	    $token->[2]->{'default'}=
  757: 		$Apache::lonnet::packagetab{"$tag&$name&default"};
  758:             $token->[3] = ['name','type','description','default'];
  759: 	    $constructtag=1;
  760: 	}
  761: 	if ($constructtag) {
  762: 	    $result = &Apache::edit::rebuild_tag($token);
  763: 	}
  764:     } elsif ($target eq 'grade' || $target eq 'answer' || $target eq 'web' ||
  765: 	     $target eq 'tex' || $target eq 'analyze' ) {
  766: 	if ($env{'request.state'} eq 'construct') {
  767: 	    my $name   =&Apache::lonxml::get_param('name',$parstack,$safeeval);
  768: 	    my $default=&Apache::lonxml::get_param('default',$parstack,
  769: 						     $safeeval);
  770: 	    if ($name) {$Apache::inputtags::params{$name}=$default;}
  771: 	}
  772:     }
  773:     return $result;
  774: }
  775: 
  776: sub end_responseparam {
  777:     my ($target,$token,$tagstack,$parstack,$parser,$safeeval)=@_;
  778:     if ($target eq 'edit') { return ('','no'); }
  779:     return '';
  780: }
  781: 
  782: sub start_parameter {
  783:     return &start_responseparam(@_);
  784: }
  785: 
  786: sub end_parameter {
  787:     return &end_responseparam(@_);
  788: }
  789: 
  790: sub reset_params {
  791:     %Apache::inputtags::params=();
  792: }
  793: 
  794: sub setup_params {
  795:     my ($tag,$safeeval) = @_;
  796: 
  797:     if ($env{'request.state'} eq 'construct') { return; }
  798:     my %paramlist=();
  799:     foreach my $key (keys(%Apache::lonnet::packagetab)) {
  800: 	if ($key =~ /^\Q$tag\E/) {
  801: 	    my ($package,$name) = split(/&/,$key);
  802: 	    $paramlist{$name}=1;
  803: 	}
  804:     }
  805:     foreach my $key (keys(%paramlist)) {
  806: 	my $entry= 'resource.'.$Apache::inputtags::part;
  807: 	if (defined($Apache::inputtags::response[-1])) {
  808: 	    $entry.='_'.$Apache::inputtags::response[-1];
  809: 	}
  810: 	$entry.='.'.$key;
  811: 	&Apache::lonxml::debug("looking for $entry");
  812: 	my $value = &Apache::lonnet::EXT("$entry");
  813: 	&Apache::lonxml::debug("$key has value :$value:");
  814: 	if ($value eq 'con_lost' || $value =~ /^error:/) {
  815: 	    &Apache::lonxml::debug("using nothing");
  816: 	    $Apache::inputtags::params{$key}='';
  817: 	} else {
  818: 	    my $string="{return qq\0".$value."\0}";
  819: 	    my $newvalue=&Apache::run::run($string,$safeeval,1);
  820: 	    if (defined($newvalue)) { $value=$newvalue; }
  821: 	    $Apache::inputtags::params{$key}=$value;
  822: 	}
  823:     }
  824: }
  825: 
  826: {
  827:     my @answer_bits;
  828:     my $need_row_start;
  829: 
  830: sub answer_header {
  831:     my ($type,$increment,$rows) = @_;
  832:     my $result;
  833:     if ($env{'form.answer_output_mode'} eq 'tex') {
  834: 	undef(@answer_bits);
  835: 	my $bit;
  836: 	if ($Apache::lonhomework::type eq 'exam') {
  837: 	    $bit = ($Apache::lonxml::counter+$increment).') ';
  838: 	} else {
  839: 	    $bit .= ' Answer for Part: \verb|'.
  840: 		$Apache::inputtags::part.'| ';
  841: 	}
  842: 	push(@answer_bits,$bit);
  843:     } else {
  844: 	my $td = '<td '.(defined($rows)?'rowspan="'.$rows.'"':'').'>';
  845: 	$result  = '<table border="1"><tr>';
  846: 	if ($Apache::lonhomework::type eq 'exam') {
  847: 	    $result .= $td.($Apache::lonxml::counter+$increment). ')</td>';
  848: 	} else {
  849: 	    $result .= $td.&mt('Answer for Part: [_1]',
  850: 			       $Apache::inputtags::part).'</td>';
  851: 	}
  852: 	$result .= "\n";
  853: 	$need_row_start = 0;
  854:     }
  855:     return $result;
  856: }
  857: 
  858: sub next_answer {
  859:     my ($type) = @_;
  860:     my $result;
  861:     if ($env{'form.answer_output_mode'} eq 'tex') {
  862: 	# FIXME ... need to do something with tex mode
  863:     } else {
  864: 	$result .= "</tr>";
  865: 	$need_row_start = 1;
  866:     }
  867:     return $result;
  868: }
  869: 
  870: sub answer_part {
  871:     my ($type,$answer,$args) = @_;
  872:     my $result;
  873:     if ($env{'form.answer_output_mode'} eq 'tex') {
  874: 	if (!$args->{'no_verbatim'}) {
  875: 	    my $to_use='|';
  876: 	    foreach my $value (32..126) {
  877: 		my $char=pack('c',$value);
  878: 		if ($answer !~ /\Q$char\E/) {
  879: 		    $to_use=$char;
  880: 		    last;
  881: 		}
  882: 	    }
  883:             my $fullanswer=$answer;
  884:             $answer='';
  885:             foreach my $element (split(/[\;]/,$fullanswer)) {
  886: 	       if ($element ne '') {
  887: 	 	  $answer.= '\verb'.$to_use.$element.$to_use.' \newline';
  888: 	       }
  889:             }
  890: 	}
  891: 	if ($answer ne '') {
  892: 	    push(@answer_bits,$answer);
  893: 	}
  894:     } else {
  895: 	if ($need_row_start) {
  896: 	    $result .= '<tr>';
  897: 	    $need_row_start = 0;
  898: 	}
  899: 	$result .= '<td>'.$answer.'</td>';
  900:     }
  901:     return $result;
  902: }
  903: 
  904: sub answer_footer {
  905:     my ($type) = @_;
  906:     my $result;
  907:     if ($env{'form.answer_output_mode'} eq 'tex') {
  908: 	$result  = ' \vskip 0 mm \noindent \begin{tabular}{|p{1.5cm}|p{6.8cm}|}\hline ';
  909: 	$result .= $answer_bits[0].'&\vspace*{-4mm}\begin{itemize}';
  910:         for (my $i=1;$i<=$#answer_bits;$i++) {
  911:             $result.='\item '.$answer_bits[$i].'\vspace*{-7mm}';
  912:         }
  913: 	$result .= ' \end{itemize} \\\\ \hline \end{tabular} \vskip 0 mm ';
  914:     } else {
  915: 	if (!$need_row_start) {
  916: 	    $result .= '</tr>';
  917: 	}
  918: 	$result .= '</table>';
  919:     }
  920:     return $result;
  921: }
  922: 
  923: }
  924: 
  925: sub showallfoils {
  926:     if (defined($env{'form.showallfoils'})) {
  927: 	my ($symb)=&Apache::lonnet::whichuser();
  928: 	if (($env{'request.state'} eq 'construct') || 
  929: 	    ($env{'user.adv'} && $symb eq '')      ||
  930:             ($Apache::lonhomework::viewgrades) ) {
  931: 	    return 1;
  932: 	}
  933:     }
  934:     if ($Apache::lonhomework::type eq 'survey') { return 1; }
  935:     if ($Apache::lonhomework::type eq 'surveycred') { return 1; }
  936:     if ($Apache::lonhomework::type eq 'anonsurvey') { return 1; }
  937:     if ($Apache::lonhomework::type eq 'anonsurveycred') { return 1; }
  938: 
  939:     return 0;
  940: }
  941: 
  942: =pod
  943: 
  944: =item &getresponse();
  945: 
  946: Retreives the current submitted response, helps out in the case of
  947: scantron mode.
  948: 
  949: Returns either the exact text of the submission, or a bubbled response
  950: converted to something usable.
  951: 
  952: Optional Arguments:
  953:   $offset - (defaults to 1) if a problem has more than one bubble
  954:             response, pass in the number of the bubble wanted, (the
  955:             first bubble associated with a problem has an offset of 1,
  956:             the second bubble is 2
  957: 
  958:   $resulttype - undef    -> a number between 0 and 25
  959:                 'A is 1' -> a number between 1 and 26
  960:                 'letter' -> a letter between 'A' and 'Z'
  961:   $lines  - undef problem only needs a single line of bubbles.
  962:             nonzero  Problem wants the first nonempty response in 
  963:                       $lines lines of bubbles.
  964:   $bubbles_per_line - Must be provided if lines is defined.. number of
  965:                       bubbles on a line.
  966: 
  967: =cut
  968: 
  969: sub getresponse {
  970:     my ($offset,$resulttype, $lines, $bubbles_per_line)=@_;
  971:     my $formparm='form.HWVAL_'.$Apache::inputtags::response['-1'];
  972:     my $response;
  973:     if (!defined($offset)) {
  974: 	$offset=1;
  975:     } else {
  976: 	$formparm.=":$offset";
  977:     }
  978:     if (!defined($lines)) {
  979: 	$lines = 1;
  980:     }
  981:     my %let_to_num=('A'=>0,'B'=>1,'C'=>2,'D'=>3,'E'=>4,'F'=>5,'G'=>6,'H'=>7,
  982: 		    'I'=>8,'J'=>9,'K'=>10,'L'=>11,'M'=>12,'N'=>13,'O'=>14,
  983: 		    'P'=>15,'Q'=>16,'R'=>17,'S'=>18,'T'=>19,'U'=>20,'V'=>21,
  984: 		    'W'=>22,'X'=>23,'Y'=>24,'Z'=>25);
  985:     if ($env{'form.submitted'} eq 'scantron') {
  986: 	my $part  = $Apache::inputtags::part;
  987: 	my $id    = $Apache::inputtags::response[-1];
  988: 	
  989: 	my $line;
  990: 	my $startline = $env{'form.scantron_questnum_start.'.$part.'.'.$id};
  991:         if (!$startline) {
  992:             $startline = $Apache::lonxml::counter;
  993:         }
  994: 	for ($line = 0; $line < $lines; $line++) {
  995:             my $theline = $startline+$offset-1+$line;
  996: 	    $response = $env{"scantron.$theline.answer"};
  997: 	    if ((defined($response)) && ($response ne "") && ($response ne " ")) {
  998: 		last;
  999: 	    }
 1000:  
 1001: 	}
 1002: 
 1003: 	# save bubbled letter for later
 1004: 	$Apache::lonhomework::results{"resource.$part.$id.scantron"}.=
 1005: 	    $response;
 1006: 	if ($resulttype ne 'letter') {
 1007:             $response = $let_to_num{$response};
 1008:             if ($resulttype eq 'A is 1') {
 1009:                 if ($response ne "") {
 1010:                     $response = $response+1;
 1011:                 }
 1012: 	    }
 1013: 	    if ($response ne "") {
 1014: 		$response += $line * $bubbles_per_line;
 1015: 	    }
 1016: 	} else {
 1017: 	    if ($response ne "") {
 1018:                 my $raw = $response;
 1019: 		$response = chr(ord($response) + $line * $bubbles_per_line);
 1020: 	    }
 1021: 	}
 1022: 
 1023:     } else {
 1024: 	$response = $env{$formparm};
 1025:     }
 1026:     # 
 1027:     #  If we have a nonempty answer, correct the numeric value
 1028:     #  of the answer for the line on which it was found.
 1029:     #
 1030: 
 1031:     return $response;
 1032: }
 1033: 
 1034: =pod
 1035: 
 1036: =item &repetition();
 1037: 
 1038: In scalar context:
 1039: 
 1040: returns: the number of lines that are required to encode the weight.
 1041: (Default is for 10 bubbles per bubblesheet item; other (integer) 
 1042: values can be specified by using a custom Bubblesheet format file 
 1043: with an eighteenth entry (BubblesPerRow) set to the integer 
 1044: appropriate for the bubblesheets which will be used to assign weights.
 1045: 
 1046: In array context:
 1047:  
 1048: returns: number of lines required to encode weight, and bubbles/line.
 1049: 
 1050: =cut
 1051: 
 1052: sub repetition {
 1053:     my $id = $Apache::inputtags::part;
 1054:     my $weight = &Apache::lonnet::EXT("resource.$id.weight");
 1055:     if (!defined($weight) || ($weight eq '')) { $weight=1; }
 1056:     my $bubbles_per_row;
 1057:     if (($env{'form.bubbles_per_row'} =~ /^\d+$/) && 
 1058:         ($env{'form.bubbles_per_row'} > 0)) {
 1059:         $bubbles_per_row = $env{'form.bubbles_per_row'};
 1060:     } else {
 1061:         $bubbles_per_row = 10;
 1062:     }
 1063:     my $denominator = $bubbles_per_row;
 1064:     if (($env{'form.scantron_lastbubblepoints'} == 0) && 
 1065:         ($bubbles_per_row > 1)) {
 1066:         $denominator = $bubbles_per_row - 1;
 1067:     } 
 1068:     my $repetition = int($weight/$denominator);
 1069:     if ($weight % $denominator != 0) { $repetition++; } 
 1070:     if (wantarray) {
 1071:         return ($repetition,$bubbles_per_row);
 1072:     }
 1073:     return $repetition;
 1074: 
 1075: }
 1076: 
 1077: =pod
 1078: 
 1079: =item &scored_response();
 1080: 
 1081: Sets the results hash elements
 1082: 
 1083:    resource.$part_id.$response_id.awarded - to the floating point
 1084:      number between 0 and 1 that was awarded on the bubbled input
 1085: 
 1086:    resource.$part_id.$response_id.awarddetail - to 'ASSIGNED_SCORE'
 1087: 
 1088: Returns
 1089: 
 1090:    the number of bubble sheet lines that were used (and likely need to
 1091:      be passed to &Apache::lonxml::increment_counter()
 1092: 
 1093: Arguments
 1094: 
 1095:    $part_id - id of the part to grade
 1096:    $response_id - id of the response to grade
 1097:   
 1098: 
 1099: =cut
 1100: 
 1101: sub scored_response {
 1102:     my ($part,$id)=@_;
 1103:     my $repetition=&repetition();
 1104:     my $bubbles_per_row;
 1105:     if (($env{'form.bubbles_per_row'} =~ /^\d+$/) &&
 1106:         ($env{'form.bubbles_per_row'} > 0)) {
 1107:         $bubbles_per_row = $env{'form.bubbles_per_row'};
 1108:     } else {
 1109:         $bubbles_per_row = 10;
 1110:     }
 1111:     my $score=0;
 1112:     for (my $i=0;$i<$repetition;$i++) {
 1113: 	# A is 1, B is 2, etc.
 1114: 	my $increase=&Apache::response::getresponse($i+1);
 1115:         unless (($increase == $bubbles_per_row-1) &&
 1116:                 ($env{'form.scantron_lastbubblepoints'} == 0)) {
 1117:             # (get response return 0-9 and then we add 1)
 1118:             if ($increase ne '') {
 1119:                 $score+=$increase+1;
 1120:             }
 1121:         }
 1122:     }
 1123:     my $weight = &Apache::lonnet::EXT("resource.$part.weight");
 1124:     if (!defined($weight) || $weight eq '' || $weight eq 0) { $weight = 1; }
 1125:     my $pcr=$score/$weight;
 1126:     $Apache::lonhomework::results{"resource.$part.$id.awarded"}=$pcr;
 1127:     $Apache::lonhomework::results{"resource.$part.$id.awarddetail"}=
 1128: 	'ASSIGNED_SCORE';
 1129:     return $repetition;
 1130: }
 1131: 
 1132: sub whichorder {
 1133:     my ($max,$randomize,$showall,$hash,$rndseed)=@_;
 1134:     #&Apache::lonxml::debug("man $max randomize $randomize");
 1135:     if (!defined(@{ $$hash{'names'} })) { return; }
 1136:     my @names = @{ $$hash{'names'} };
 1137:     my @whichopt =();
 1138:     my (%top,@toplist,%bottom,@bottomlist);
 1139:     if (!($showall || ($randomize eq 'no'))) {
 1140: 	my $current=0;
 1141: 	foreach my $name (@names) {
 1142: 	    $current++;
 1143: 	    if ($$hash{"$name.location"} eq 'top') {
 1144: 		$top{$name}=$current;
 1145: 	    } elsif ($$hash{"$name.location"} eq 'bottom') {
 1146: 		$bottom{$name}=$current;
 1147: 	    }
 1148: 	}
 1149:     }
 1150:     my $topcount=0;
 1151:     my $bottomcount=0;
 1152:     while (((scalar(@whichopt)+$topcount+$bottomcount) < $max || $showall)
 1153: 	   && ($#names > -1)) {
 1154: 	#&Apache::lonxml::debug("Have $#whichopt max is $max");
 1155: 	my $aopt;
 1156: 	if ($showall || ($randomize eq 'no')) {
 1157: 	    $aopt=0;
 1158: 	} else {
 1159: 	    $aopt=int(&Math::Random::random_uniform() * ($#names+1));
 1160: 	}
 1161: 	#&Apache::lonxml::debug("From $#whichopt $max $#names elms, picking $aopt");
 1162: 	$aopt=splice(@names,$aopt,1);
 1163: 	#&Apache::lonxml::debug("Picked $aopt");
 1164: 	if ($top{$aopt}) {
 1165: 	    $toplist[$top{$aopt}]=$aopt;
 1166: 	    $topcount++;
 1167: 	} elsif ($bottom{$aopt}) {
 1168: 	    $bottomlist[$bottom{$aopt}]=$aopt;
 1169: 	    $bottomcount++;
 1170: 	} else {
 1171: 	    push (@whichopt,$aopt);
 1172: 	}
 1173:     }
 1174:     for (my $i=0;$i<=$#toplist;$i++) {
 1175: 	if ($toplist[$i]) { unshift(@whichopt,$toplist[$i]) }
 1176:     }
 1177:     for (my $i=0;$i<=$#bottomlist;$i++) {
 1178: 	if ($bottomlist[$i]) { push(@whichopt,$bottomlist[$i]) }
 1179:     }
 1180:     return @whichopt;
 1181: }
 1182: 
 1183: sub show_answer {
 1184:     my $part   = $Apache::inputtags::part;
 1185:     my $award  = $Apache::lonhomework::history{"resource.$part.solved"};
 1186:     my $status = $Apache::inputtags::status[-1];
 1187:     my $canshow = 0;
 1188:     if ($award =~ /^correct/) {
 1189:         if ((&Apache::inputtags::grading_is_nonlenient($part)) ||
 1190:             ($Apache::lonhomework::history{"resource.$part.awarded"} == 1)) {
 1191:             $canshow = 1;
 1192:         }   
 1193:     }
 1194:     return  (($canshow && &Apache::lonhomework::show_problem_status()) 
 1195: 	     || $status eq "SHOW_ANSWER");
 1196: }
 1197: 
 1198: sub analyze_store_foilgroup {
 1199:     my ($shown,$attrs)=@_;
 1200:     my $part_id="$Apache::inputtags::part.$Apache::inputtags::response[-1]";
 1201:     foreach my $name (@{ $Apache::response::foilgroup{'names'} }) {
 1202: 	if (defined($Apache::lonhomework::analyze{"$part_id.foil.value.$name"})) { next; }
 1203: 	push (@{ $Apache::lonhomework::analyze{"$part_id.foils"} },$name);
 1204: 	foreach my $attr (@$attrs) {
 1205: 	    $Apache::lonhomework::analyze{"$part_id.foil.".$attr.".$name"} =
 1206: 		$Apache::response::foilgroup{"$name.".$attr};
 1207: 	}
 1208:     }
 1209:     push (@{ $Apache::lonhomework::analyze{"$part_id.shown"} }, @{ $shown });
 1210: }
 1211: 
 1212: sub check_if_computed {
 1213:     my ($token,$parstack,$safeeval,$name)=@_;
 1214:     my $value = &Apache::lonxml::get_param($name,$parstack,$safeeval);
 1215:     if (ref($token->[2]) eq 'HASH' && $value ne $token->[2]{$name}) {
 1216: 	my $part_id="$Apache::inputtags::part.$Apache::inputtags::response[-1]";
 1217: 	$Apache::lonhomework::analyze{"$part_id.answercomputed"} = 1;
 1218:     }
 1219: }
 1220: 
 1221: sub pick_foil_for_concept {
 1222:     my ($target,$attrs,$hinthash,$parstack,$safeeval)=@_;
 1223:     if (not defined(@{ $Apache::response::conceptgroup{'names'} })) { return; }
 1224:     my @names = @{ $Apache::response::conceptgroup{'names'} };
 1225:     my $pick=int(&Math::Random::random_uniform() * ($#names+1));
 1226:     my $name=$names[$pick];
 1227:     push @{ $Apache::response::foilgroup{'names'} }, $name;
 1228:     foreach my $attr (@$attrs) {
 1229: 	$Apache::response::foilgroup{"$name.".$attr} =
 1230: 	    $Apache::response::conceptgroup{"$name.".$attr};
 1231:     }
 1232:     my $concept = &Apache::lonxml::get_param('concept',$parstack,$safeeval);
 1233:     $Apache::response::foilgroup{"$name.concept"} = $concept;
 1234:     &Apache::lonxml::debug("Selecting $name in $concept");
 1235:     my $part_id="$Apache::inputtags::part.$Apache::inputtags::response[-1]";
 1236:     if ($target eq 'analyze') {
 1237: 	push (@{ $Apache::lonhomework::analyze{"$part_id.concepts"} },
 1238: 	      $concept);
 1239: 	$Apache::lonhomework::analyze{"$part_id.concept.$concept"}=
 1240: 	    $Apache::response::conceptgroup{'names'};
 1241: 	foreach my $name (@{ $Apache::response::conceptgroup{'names'} }) {
 1242: 	    push (@{ $Apache::lonhomework::analyze{"$part_id.foils"} },
 1243: 		  $name);
 1244: 	    foreach my $attr (@$attrs) {
 1245: 		$Apache::lonhomework::analyze{"$part_id.foil.$attr.$name"}=
 1246: 		    $Apache::response::conceptgroup{"$name.$attr"};
 1247: 	    }
 1248: 	}
 1249:     }
 1250:     push(@{ $hinthash->{"$part_id.concepts"} },$concept);
 1251:     $hinthash->{"$part_id.concept.$concept"}=
 1252: 	$Apache::response::conceptgroup{'names'};
 1253: 
 1254: }
 1255: 
 1256: =pod
 1257: 
 1258: =item get_response_param()
 1259: 
 1260: Get a parameter associated with a problem.
 1261: Parameters:
 1262: 	$id        - the id of the paramater, either a part id, 
 1263:               or a partid and responspe id joined by _
 1264: 	$name      - Name of the parameter to fetch
 1265: 	$default   - Default value for the paramter.
 1266: 
 1267: =cut
 1268: 
 1269: sub get_response_param {
 1270:     my ($id,$name,$default)=@_;
 1271:     my $parameter;
 1272:     if ($env{'request.state'} eq 'construct' &&
 1273: 	defined($Apache::inputtags::params{$name})) {
 1274: 	$parameter=$Apache::inputtags::params{$name};
 1275:     } else {
 1276: 	$parameter=&Apache::lonnet::EXT("resource.$id.$name");
 1277:     }
 1278:     if (!defined($parameter) ||	$parameter eq '') {
 1279: 	$parameter = $default;
 1280:     }
 1281:     return $parameter;
 1282: }
 1283: 
 1284: sub submitted {
 1285:     my ($who)=@_;
 1286:     
 1287:     # when scatron grading any submission is a submission
 1288:     if ($env{'form.submitted'} eq 'scantron') { return 1; }
 1289:     # if the caller only cared if this was a scantron submission
 1290:     if ($who eq 'scantron') { return 0; }
 1291:     # if the Submit Answer button for this particular part was pressed
 1292:     my $partid=$Apache::inputtags::part;
 1293:     if ($env{'form.submitted'} eq "part_$partid") {
 1294: 	return 1;
 1295:     }
 1296:     if ($env{'form.submitted'} eq "yes"
 1297: 	&& defined($env{'form.submit_'.$partid})) {
 1298: 	return 1;
 1299:     }
 1300:     # Submit All button on a .page was pressed
 1301:     if (defined($env{'form.all_submit'})) { return 1; }
 1302:     # otherwise no submission occurred
 1303:     return 0;
 1304: }
 1305: 
 1306: sub add_to_gradingqueue {
 1307:     my ($symb,$courseid,$domain,$name) = &Apache::lonnet::whichuser();
 1308:     if (   $courseid eq ''
 1309: 	|| $symb eq ''
 1310: 	|| $env{'request.state'} eq 'construct'
 1311: 	|| $Apache::lonhomework::type ne 'problem') {
 1312: 	return;
 1313:     }
 1314: 
 1315:     my %queue_info = ( 'type' => 'problem',
 1316: 		       'time' => time);
 1317: 
 1318:     if (exists($Apache::lonhomework::history{"resource.0.checkedin.slot"})) {
 1319: 	$queue_info{'slot'}=
 1320: 	     $Apache::lonhomework::history{"resource.0.checkedin.slot"};
 1321:     }
 1322: 
 1323:     my $result=&Apache::bridgetask::add_to_queue('gradingqueue',\%queue_info);
 1324:     if ($result ne 'ok') {
 1325: 	&Apache::lonxml::error("add_to_queue said $result");
 1326:     }
 1327: }
 1328: 
 1329: =pod 
 1330: 
 1331: =item check_status()
 1332: 
 1333: basically undef and 0 (both false) mean that they still have work to do
 1334: and all true values mean that they can't do any more work
 1335: 
 1336: 	a return of undef means it is unattempted
 1337: 	a return of 0 means it is attmpted and wrong but still has tries
 1338: 	a return of 1 means it is marked correct
 1339: 	a return of 2 means they have exceed maximum number of tries
 1340: 	a return of 3 means it after the answer date
 1341: 
 1342: =cut
 1343: 
 1344: sub check_status {
 1345:     my ($id)=@_;
 1346:     if (!defined($id)) { $id=$Apache::inputtags::part; }
 1347:     my $curtime=&Apache::lonnet::EXT('system.time');
 1348:     my $opendate=&Apache::lonnet::EXT("resource.$id.opendate");
 1349:     my $duedate=&Apache::lonnet::EXT("resource.$id.duedate");
 1350:     my $answerdate=&Apache::lonnet::EXT("resource.$id.answerdate");
 1351:     if ( $opendate && $curtime > $opendate &&
 1352:          $duedate && $curtime > $duedate &&
 1353:          $answerdate && $curtime > $answerdate) {
 1354:         return 3;
 1355:     }
 1356:     my $status=&Apache::lonnet::EXT("user.resource.resource.$id.solved");
 1357:     if ($status =~ /^correct/) { return 1; }
 1358:     if (!$status) { return undef; }
 1359:     my $maxtries=&Apache::lonnet::EXT("resource.$id.maxtries");
 1360:     if ($maxtries eq '') { $maxtries=2; }
 1361:     my $curtries=&Apache::lonnet::EXT("user.resource.resource.$id.tries");
 1362:     if ($curtries < $maxtries) { return 0; }
 1363:     return 2;
 1364: }
 1365: 
 1366: =pod
 1367: 
 1368: =item setup_prior_tries_hash()
 1369: 
 1370:   Foreach each past .submission $func is called with 3 arguments
 1371:      - the mode to set things up for (currently always 'grade')
 1372:      - the stored .submission string
 1373:      - The expansion of $data
 1374: 
 1375:   $data is an array ref containing elements that are either
 1376:     - scalars that are other elements of the history hash to pass to $func
 1377:     - ref to data to be passed untouched to $func
 1378: 
 1379:   $questiontype is the questiontype (currently only passed in if
 1380:       randomizebytry.
 1381: 
 1382: =cut
 1383: 
 1384: sub setup_prior_tries_hash {
 1385:     my ($func,$data,$questiontype) = @_;
 1386:     my $part = $Apache::inputtags::part;
 1387:     my $id   = $Apache::inputtags::response[-1];
 1388:     foreach my $i (1..$Apache::lonhomework::history{'version'}) {
 1389:         my $partprefix = "$i:resource.$part";
 1390: 	my $sub_key   = "$partprefix.$id.submission";
 1391: 	next if (!exists($Apache::lonhomework::history{$sub_key}));
 1392:         my $type_key = "$partprefix.type";
 1393:         my $type = $Apache::lonhomework::history{$type_key};
 1394: 	my @other_data;
 1395:         if (ref($data) eq 'ARRAY') {
 1396: 	    foreach my $datum (@{ $data }) {
 1397: 	        if (ref($datum)) {
 1398: 		    push(@other_data,$datum);
 1399: 	        } else {
 1400: 		    my $info_key = "$i:resource.$part.$id.$datum";
 1401: 		    push(@other_data,$Apache::lonhomework::history{$info_key});
 1402: 	        }
 1403: 	    }
 1404:         }
 1405:         if ($questiontype eq 'randomizetry') { 
 1406:             my $order_key = "$partprefix.$id.foilorder";
 1407:             my @whichopts = &Apache::lonnet::str2array($Apache::lonhomework::history{$order_key});
 1408:             if (@whichopts > 0) {
 1409:                 shift(@other_data);
 1410:                 unshift(@other_data,\@whichopts);
 1411:             }
 1412:         }
 1413: 	my $output =
 1414: 	    &$func('grade',
 1415: 		   $Apache::lonhomework::history{$sub_key},
 1416: 		   \@other_data);
 1417: 	if (defined($output)) {
 1418: 	    $Apache::inputtags::submission_display{$sub_key} = $output;
 1419: 	}
 1420:     }
 1421: }
 1422: 
 1423: 1;
 1424: __END__
 1425:  
 1426: =pod
 1427: 
 1428: =cut

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