<?PHP  // $Id$

/// Library of function for module quiz

/// CONSTANTS ///////////////////////////////////////////////////////////////////

define("GRADEHIGHEST", "1");
define("GRADEAVERAGE", "2");
define("ATTEMPTFIRST", "3");
define("ATTEMPTLAST",  "4");
$QUIZ_GRADE_METHOD = array ( GRADEHIGHEST => get_string("gradehighest", "quiz"),
                             GRADEAVERAGE => get_string("gradeaverage", "quiz"),
                             ATTEMPTFIRST => get_string("attemptfirst", "quiz"),
                             ATTEMPTLAST  => get_string("attemptlast", "quiz"));

define("SHORTANSWER",   "1");
define("TRUEFALSE",     "2");
define("MULTICHOICE",   "3");
define("RANDOM",        "4");
define("MATCH",         "5");
define("RANDOMSAMATCH", "6");
define("DESCRIPTION",   "7");
define("NUMERICAL",     "8");
define("MULTIANSWER",   "9");

$QUIZ_QUESTION_TYPE = array ( MULTICHOICE   => get_string("multichoice", "quiz"),
                              TRUEFALSE     => get_string("truefalse", "quiz"),
                              SHORTANSWER   => get_string("shortanswer", "quiz"),
                              NUMERICAL     => get_string("numerical", "quiz"),
                              MATCH         => get_string("match", "quiz"),
                              DESCRIPTION   => get_string("description", "quiz"),
                              RANDOM        => get_string("random", "quiz"),
                              RANDOMSAMATCH => get_string("randomsamatch", "quiz"),
                              MULTIANSWER   => get_string("multianswer", "quiz")
                              );


define("QUIZ_PICTURE_MAX_HEIGHT", "600");   // Not currently implemented
define("QUIZ_PICTURE_MAX_WIDTH",  "600");   // Not currently implemented

define("QUIZ_MAX_NUMBER_ANSWERS", "10");

define("QUIZ_MAX_EVENT_LENGTH", "432000");   // 5 days maximum

/// FUNCTIONS ///////////////////////////////////////////////////////////////////

function quiz_add_instance($quiz) {
/// Given an object containing all the necessary data,
/// (defined by the form in mod.html) this function
/// will create a new instance and return the id number
/// of the new instance.

    global $SESSION;

    unset($SESSION->modform);

    $quiz->created      = time();
    $quiz->timemodified = time();
    $quiz->timeopen = make_timestamp($quiz->openyear, $quiz->openmonth, $quiz->openday,
                                     $quiz->openhour, $quiz->openminute, 0);
    $quiz->timeclose = make_timestamp($quiz->closeyear, $quiz->closemonth, $quiz->closeday,
                                      $quiz->closehour, $quiz->closeminute, 0);

    if (!$quiz->id = insert_record("quiz", $quiz)) {
        return false;  // some error occurred
    }

    // The grades for every question in this quiz are stored in an array
    if ($quiz->grades) {
        foreach ($quiz->grades as $question => $grade) {
            if ($question) {
                unset($questiongrade);
                $questiongrade->quiz = $quiz->id;
                $questiongrade->question = $question;
                $questiongrade->grade = $grade;
                if (!insert_record("quiz_question_grades", $questiongrade)) {
                    return false;
                }
            }
        }
    }

    delete_records('event', 'modulename', 'quiz', 'instance', $quiz->id);  // Just in case

    $event = NULL;
    $event->name        = $quiz->name;
    $event->description = $quiz->intro;
    $event->courseid    = $quiz->course;
    $event->groupid     = 0;
    $event->userid      = 0;
    $event->modulename  = 'quiz';
    $event->instance    = $quiz->id;
    $event->eventtype   = 'open';
    $event->timestart   = $quiz->timeopen;
    $event->visible     = instance_is_visible('quiz', $quiz->id);
    $event->timeduration = ($quiz->timeclose - $quiz->timeopen);

    if ($event->timeduration > QUIZ_MAX_EVENT_LENGTH) {  /// Long durations create two events
        $event2 = $event;

        $event->name         .= ' ('.get_string('quizopens', 'quiz').')';
        $event->timeduration  = 0;

        $event2->timestart    = $quiz->timeclose;
        $event2->eventtype    = 'close';
        $event2->timeduration = 0;
        $event2->name        .= ' ('.get_string('quizcloses', 'quiz').')';

        add_event($event2);
    }

    add_event($event);

    return $quiz->id;
}


function quiz_update_instance($quiz) {
/// Given an object containing all the necessary data,
/// (defined by the form in mod.html) this function
/// will update an existing instance with new data.

    global $SESSION;

    unset($SESSION->modform);

    $quiz->timemodified = time();
    $quiz->timeopen = make_timestamp($quiz->openyear, $quiz->openmonth, $quiz->openday,
                                     $quiz->openhour, $quiz->openminute, 0);
    $quiz->timeclose = make_timestamp($quiz->closeyear, $quiz->closemonth, $quiz->closeday,
                                      $quiz->closehour, $quiz->closeminute, 0);
    $quiz->id = $quiz->instance;

    if (!update_record("quiz", $quiz)) {
        return false;  // some error occurred
    }


    // The grades for every question in this quiz are stored in an array
    // Insert or update records as appropriate

    $existing = get_records("quiz_question_grades", "quiz", $quiz->id, "", "question,grade,id");

    if ($quiz->grades) {
        foreach ($quiz->grades as $question => $grade) {
            if ($question) {
                unset($questiongrade);
                $questiongrade->quiz = $quiz->id;
                $questiongrade->question = $question;
                $questiongrade->grade = $grade;
                if (isset($existing[$question])) {
                    if ($existing[$question]->grade != $grade) {
                        $questiongrade->id = $existing[$question]->id;
                        if (!update_record("quiz_question_grades", $questiongrade)) {
                            return false;
                        }
                    }
                } else {
                    if (!insert_record("quiz_question_grades", $questiongrade)) {
                        return false;
                    }
                }
            }
        }
    }

    delete_records('event', 'modulename', 'quiz', 'instance', $quiz->id);  // Delete old and add new

    $event = NULL;
    $event->name        = $quiz->name;
    $event->description = $quiz->intro;
    $event->courseid    = $quiz->course;
    $event->groupid     = 0;
    $event->userid      = 0;
    $event->modulename  = 'quiz';
    $event->instance    = $quiz->id;
    $event->eventtype   = 'open';
    $event->timestart   = $quiz->timeopen;
    $event->visible     = instance_is_visible('quiz', $quiz->id);
    $event->timeduration = ($quiz->timeclose - $quiz->timeopen);

    if ($event->timeduration > QUIZ_MAX_EVENT_LENGTH) {  /// Long durations create two events
        $event2 = $event;

        $event->name         .= ' ('.get_string('quizopens', 'quiz').')';
        $event->timeduration  = 0;

        $event2->timestart    = $quiz->timeclose;
        $event2->eventtype    = 'close';
        $event2->timeduration = 0;
        $event2->name        .= ' ('.get_string('quizcloses', 'quiz').')';

        add_event($event2);
    }

    add_event($event);

    return true;
}


function quiz_delete_instance($id) {
/// Given an ID of an instance of this module,
/// this function will permanently delete the instance
/// and any data that depends on it.

    if (! $quiz = get_record("quiz", "id", "$id")) {
        return false;
    }

    $result = true;

    if ($attempts = get_records("quiz_attempts", "quiz", "$quiz->id")) {
        foreach ($attempts as $attempt) {
            if (! delete_records("quiz_responses", "attempt", "$attempt->id")) {
                $result = false;
            }
        }
    }

    if (! delete_records("quiz_attempts", "quiz", "$quiz->id")) {
        $result = false;
    }

    if (! delete_records("quiz_grades", "quiz", "$quiz->id")) {
        $result = false;
    }

    if (! delete_records("quiz_question_grades", "quiz", "$quiz->id")) {
        $result = false;
    }

    if (! delete_records("quiz", "id", "$quiz->id")) {
        $result = false;
    }

    if (! delete_records('event', 'modulename', 'quiz', 'instance', $quiz->id)) {
        $result = false;
    }

    return $result;
}

function quiz_delete_course($course) {
/// Given a course object, this function will clean up anything that
/// would be leftover after all the instances were deleted
/// In this case, all non-publish quiz categories and questions

    if ($categories = get_records_select("quiz_categories", "course = '$course->id' AND publish = '0'")) {
        foreach ($categories as $category) {
            if ($questions = get_records("quiz_questions", "category", $category->id)) {
                foreach ($questions as $question) {
                    delete_records("quiz_answers", "question", $question->id);
                    delete_records("quiz_match", "question", $question->id);
                    delete_records("quiz_match_sub", "question", $question->id);
                    delete_records("quiz_multianswers", "question", $question->id);
                    delete_records("quiz_multichoice", "question", $question->id);
                    delete_records("quiz_numerical", "question", $question->id);
                    delete_records("quiz_randommatch", "question", $question->id);
                    delete_records("quiz_responses", "question", $question->id);
                    delete_records("quiz_shortanswer", "question", $question->id);
                    delete_records("quiz_truefalse", "question", $question->id);
                }
                delete_records("quiz_questions", "category", $category->id);
            }
        }
        return delete_records("quiz_categories", "course", $course->id);
    }
    return true;
}


function quiz_user_outline($course, $user, $mod, $quiz) {
/// Return a small object with summary information about what a
/// user has done with a given particular instance of this module
/// Used for user activity reports.
/// $return->time = the time they did it
/// $return->info = a short text description
    if ($grade = get_record("quiz_grades", "userid", $user->id, "quiz", $quiz->id)) {

        if ($grade->grade) {
            $result->info = get_string("grade").": $grade->grade";
        }
        $result->time = $grade->timemodified;
        return $result;
    }
    return NULL;

    return $return;
}

function quiz_user_complete($course, $user, $mod, $quiz) {
/// Print a detailed representation of what a  user has done with
/// a given particular instance of this module, for user activity reports.

    return true;
}

function quiz_cron () {
/// Function to be run periodically according to the moodle cron
/// This function searches for things that need to be done, such
/// as sending out mail, toggling flags etc ...

    global $CFG;

    return true;
}

function quiz_grades($quizid) {
/// Must return an array of grades, indexed by user, and a max grade.

    $quiz = get_record("quiz", "id", $quizid);
    if (empty($quiz) or empty($quiz->grade)) {
        return NULL;
    }

    $return->grades = get_records_menu("quiz_grades", "quiz", $quizid, "", "userid,grade");
    $return->maxgrade = get_field("quiz", "grade", "id", "$quizid");
    return $return;
}

function quiz_get_participants($quizid) {
/// Returns an array of users who have data in a given quiz
/// (users with records in quiz_attempts, students)

    global $CFG;

    return get_records_sql("SELECT DISTINCT u.*
                            FROM {$CFG->prefix}user u,
                                 {$CFG->prefix}quiz_attempts a
                            WHERE a.quiz = '$quizid' and
                                  u.id = a.userid");
}

function quiz_refresh_events($courseid = 0) {
// This standard function will check all instances of this module
// and make sure there are up-to-date events created for each of them.
// If courseid = 0, then every quiz event in the site is checked, else
// only quiz events belonging to the course specified are checked.
// This function is used, in its new format, by restore_refresh_events()

    if ($courseid == 0) {
        if (! $quizzes = get_records("quiz")) {
            return true;
        }
    } else {
        if (! $quizzes = get_records("quiz", "course", $courseid)) {
            return true;
        }
    }
    $moduleid = get_field('modules', 'id', 'name', 'quiz');

    foreach ($quizzes as $quiz) {
        $event = NULL;
        $event2 = NULL;
        $event2old = NULL;

        if ($events = get_records_select('event', "modulename = 'quiz' AND instance = '$quiz->id' ORDER BY timestart")) {
            $event = array_shift($events);
            if (!empty($events)) {
                $event2old = array_shift($events);
                if (!empty($events)) {
                    foreach ($events as $badevent) {
                        delete_records('event', 'id', $badevent->id);
                    }
                }
            }
        }

        $event->name        = addslashes($quiz->name);
        $event->description = addslashes($quiz->intro);
        $event->courseid    = $quiz->course;
        $event->groupid     = 0;
        $event->userid      = 0;
        $event->modulename  = 'quiz';
        $event->instance    = $quiz->id;
        $event->visible     = instance_is_visible('quiz', $quiz->id);
        $event->timestart   = $quiz->timeopen;
        $event->eventtype   = 'open';
        $event->timeduration = ($quiz->timeclose - $quiz->timeopen);

        if ($event->timeduration > QUIZ_MAX_EVENT_LENGTH) {  /// Set up two events

            $event2 = $event;

            $event->name         = addslashes($quiz->name).' ('.get_string('quizopens', 'quiz').')';
            $event->timeduration = 0;

            $event2->name        = addslashes($quiz->name).' ('.get_string('quizcloses', 'quiz').')';
            $event2->timestart   = $quiz->timeclose;
            $event2->eventtype   = 'close';
            $event2->timeduration = 0;

            if (empty($event2old->id)) {
                unset($event2->id);
                add_event($event2);
            } else {
                $event2->id = $event2old->id;
                update_event($event2);
            }
        } else if (!empty($event2->id)) {
            delete_event($event2->id);
        }

        if (empty($event->id)) {
            add_event($event);
        } else {
            update_event($event);
        }

    }
    return true;
}

/// SQL FUNCTIONS ////////////////////////////////////////////////////////////////////

function quiz_move_questions($category1, $category2) {
    global $CFG;
    return execute_sql("UPDATE {$CFG->prefix}quiz_questions
                           SET category = '$category2'
                         WHERE category = '$category1'",
                       false);
}

function quiz_get_question_grades($quizid, $questionlist) {
    global $CFG;

    return get_records_sql("SELECT question,grade
                            FROM {$CFG->prefix}quiz_question_grades
                            WHERE quiz = '$quizid'
                            AND question IN ($questionlist)");
}

function quiz_get_random_categories($questionlist) {
/// Given an array of questions, this function looks for random
/// questions among them and returns a list of categories with
/// an associated count of random questions for each.

    global $CFG;

    return get_records_sql_menu("SELECT category,count(*)
                            FROM {$CFG->prefix}quiz_questions
                            WHERE id IN ($questionlist)
                              AND qtype = '".RANDOM."'
                              GROUP BY category ");
}

function quiz_get_grade_records($quiz) {
/// Gets all info required to display the table of quiz results
/// for report.php
    global $CFG;

    return get_records_sql("SELECT qg.*, u.firstname, u.lastname, u.picture
                            FROM {$CFG->prefix}quiz_grades qg,
                                 {$CFG->prefix}user u
                            WHERE qg.quiz = '$quiz->id'
                              AND qg.userid = u.id");
}

function quiz_get_answers($question, $answerids=NULL) {
// Given a question, returns the correct answers for a given question
    global $CFG;

    if (empty($answerids)) {
        $answeridconstraint = '';
    } else {
        $answeridconstraint = " AND a.id IN ($answerids) ";
    }

    switch ($question->qtype) {
        case SHORTANSWER:       // Could be multiple answers
            return get_records_sql("SELECT a.*, sa.usecase
                                      FROM {$CFG->prefix}quiz_shortanswer sa,
                                           {$CFG->prefix}quiz_answers a
                                     WHERE sa.question = '$question->id'
                                       AND sa.question = a.question "
                                  . $answeridconstraint);

        case TRUEFALSE:         // Should be always two answers
            return get_records("quiz_answers", "question", $question->id);

        case MULTICHOICE:       // Should be multiple answers
            return get_records_sql("SELECT a.*, mc.single
                                      FROM {$CFG->prefix}quiz_multichoice mc,
                                           {$CFG->prefix}quiz_answers a
                                     WHERE mc.question = '$question->id'
                                       AND mc.question = a.question "
                                  . $answeridconstraint);

        case MATCH:
            return get_records("quiz_match_sub", "question", $question->id);

        case RANDOMSAMATCH:       // Could be any of many answers, return them all
            return get_records_sql("SELECT a.*
                                      FROM {$CFG->prefix}quiz_questions q,
                                           {$CFG->prefix}quiz_answers a
                                     WHERE q.category = '$question->category'
                                       AND q.qtype = ".SHORTANSWER."
                                       AND q.id = a.question ");

        case NUMERICAL:         // Logical support for multiple answers
            return get_records_sql("SELECT a.*, n.min, n.max
                                      FROM {$CFG->prefix}quiz_numerical n,
                                           {$CFG->prefix}quiz_answers a
                                     WHERE a.question = '$question->id'
                                       AND n.answer = a.id "
                                  . $answeridconstraint);

        case DESCRIPTION:
            return true; // there are no answers for description

        case RANDOM:
            return quiz_get_answers
                    (get_record('quiz_questions', 'id', $question->random));

        case MULTIANSWER:       // Includes subanswers
            $answers = array();

            $virtualquestion->id = $question->id;

            if ($multianswers = get_records('quiz_multianswers', 'question', $question->id)) {
                foreach ($multianswers as $multianswer) {
                    $virtualquestion->qtype = $multianswer->answertype;
                    // Recursive call for subanswers
                    $multianswer->subanswers = quiz_get_answers($virtualquestion, $multianswer->answers);
                    $answers[] = $multianswer;
                }
            }
            return $answers;

        default:
            return false;
    }
}


function quiz_get_attempt_responses($attempt) {
// Given an attempt object, this function gets all the
// stored responses and returns them in a format suitable
// for regrading using quiz_grade_attempt_results()
    global $CFG;

    if (!$responses = get_records_sql("SELECT q.id, q.qtype, q.category, q.questiontext,
                                              q.defaultgrade, q.image, r.answer
                                        FROM {$CFG->prefix}quiz_responses r,
                                             {$CFG->prefix}quiz_questions q
                                       WHERE r.attempt = '$attempt->id'
                                         AND q.id = r.question")) {
        notify("Could not find any responses for that attempt!");
        return false;
    }


    foreach ($responses as $key => $response) {
        if ($response->qtype == RANDOM) {
            $responses[$key]->random = $response->answer;
            $responses[$response->answer]->delete = true;

            $realanswer = $responses[$response->answer]->answer;

            if (is_array($realanswer)) {
                $responses[$key]->answer = $realanswer;
            } else {
                $responses[$key]->answer = explode(",", $realanswer);
            }

        } else if ($response->qtype == NUMERICAL or $response->qtype == SHORTANSWER) {
            $responses[$key]->answer = array($response->answer);
        } else {
            $responses[$key]->answer = explode(",",$response->answer);
        }
    }
    foreach ($responses as $key => $response) {
        if (!empty($response->delete)) {
            unset($responses[$key]);
        }
    }

    return $responses;
}


function get_list_of_questions($questionlist) {
/// Returns an ordered list of questions, including course for each

    global $CFG;

    return get_records_sql("SELECT q.*,c.course
                              FROM {$CFG->prefix}quiz_questions q,
                                   {$CFG->prefix}quiz_categories c
                             WHERE q.id in ($questionlist)
                               AND q.category = c.id");
}

//////////////////////////////////////////////////////////////////////////////////////
/// Any other quiz functions go here.  Each of them must have a name that
/// starts with quiz_

function quiz_print_comment($text) {
    global $THEME;

    echo "<span class=\"feedbacktext\">".format_text($text, true, false)."</span>";
}

function quiz_print_correctanswer($text) {
    global $THEME;

    echo "<p align=\"right\"><span class=\"highlight\">$text</span></p>";
}

function quiz_print_question_icon($question, $editlink=true) {
// Prints a question icon

    global $QUIZ_QUESTION_TYPE;

    if ($editlink) {
        echo "<a href=\"question.php?id=$question->id\" title=\"".$QUIZ_QUESTION_TYPE[$question->qtype]."\">";
    }
    switch ($question->qtype) {
        case SHORTANSWER:
            echo '<img border="0" height="16" width="16" src="pix/sa.gif">';
            break;
        case TRUEFALSE:
            echo '<img border="0" height="16" width="16" src="pix/tf.gif">';
            break;
        case MULTICHOICE:
            echo '<img border="0" height="16" width="16" src="pix/mc.gif">';
            break;
        case RANDOM:
            echo '<img border="0" height="16" width="16" src="pix/rs.gif">';
            break;
        case MATCH:
            echo '<img border="0" height="16" width="16" src="pix/ma.gif">';
            break;
        case RANDOMSAMATCH:
            echo '<img border="0" height="16" width="16" src="pix/rm.gif">';
            break;
        case DESCRIPTION:
            echo '<img border="0" height="16" width="16" src="pix/de.gif">';
            break;
        case NUMERICAL:
            echo '<img border="0" height="16" width="16" src="pix/nu.gif">';
            break;
        case MULTIANSWER:
            echo '<img border="0" height="16" width="16" src="pix/mu.gif">';
            break;
    }
    if ($editlink) {
        echo "</a>\n";
    }
}

function quiz_print_possible_question_image($quizid, $question) {
// Includes the question image is there is one

    global $CFG;

    if ($question->image) {
        echo '<img border="0" src="';

        if (substr(strtolower($question->image), 0, 7) == 'http://') {
            echo $question->image;

        } else if ($CFG->slasharguments) {        // Use this method if possible for better caching
            echo "$CFG->wwwroot/mod/quiz/quizfile.php/$quizid/$question->id/$question->image";

        } else {
            echo "$CFG->wwwroot/mod/quiz/quizfile.php?file=/$quizid/$question->id/$question->image";
        }
        echo '" />';

    }
}

function quiz_print_question($number, $question, $grade, $quizid,
                             $feedback=NULL, $response=NULL, $actualgrade=NULL, $correct=NULL,
                             $realquestion=NULL, $shuffleanswers=false, $showgrades=true, $courseid=0) {

/// Prints a quiz question, any format
/// $question is provided as an object

    global $CFG, $THEME;

    $question->questiontextformat = isset($question->questiontextformat) ? $question->questiontextformat : NULL;

    if ($question->qtype == DESCRIPTION) {  // Special case question - has no answers etc
        echo '<p align="center">';
        echo format_text($question->questiontext, $question->questiontextformat, NULL, $courseid);
        quiz_print_possible_question_image($quizid, $question);
        echo '</p>';
        return true;
    }

    if (empty($actualgrade)) {
        $actualgrade = 0;
    }

    $stranswer = get_string("answer", "quiz");
    $strmarks  = get_string("marks", "quiz");

    echo '<table width="100%" cellspacing="10">';
    echo '<tr><td nowrap="nowrap" width="100" valign="top">';
    echo '<p align="center"><b>' . $number . '</b></p>';
    if ($showgrades) {
        if ($feedback or $response) {
            echo "<p align=\"center\"><font size=\"1\">$strmarks: $actualgrade/$grade</font></p>";
        } else {
            echo "<p align=\"center\"><font size=\"1\">$grade $strmarks</font></p>";
        }
    }
    print_spacer(1,100);

    if (isset($question->recentlyadded) and $question->recentlyadded) {
        echo '</td><td valign="top" align="right">';
        // Notify the user of this recently added question
        echo '<font color="red">';
        echo get_string('recentlyaddedquestion', 'quiz');
        echo '</font>';
        echo '</td></tr><tr><td></td><td valign="top">';

    } else { // The normal case
        echo '</td><td valign="top">';
    }


    if (empty($realquestion)) {
        $realquestion->id = $question->id;
    } else {    // Add a marker to connect this question to the actual random parent
        echo "<input type=\"hidden\" name=\"q{$realquestion->id}rq$question->id\" value=\"x\" />\n";
    }

    switch ($question->qtype) {

       case SHORTANSWER:
       case NUMERICAL:
           echo format_text($question->questiontext, $question->questiontextformat, NULL, $courseid);
           quiz_print_possible_question_image($quizid, $question);
           if ($response) {
               $value = 'value="'.s($response[0]).'"';
           } else {
               $value = '';
           }
           echo "<p align=\"right\">$stranswer: <input type=\"text\" name=\"q$realquestion->id\" size=\"80\" $value /></p>";
           if ($feedback) {
               quiz_print_comment("<p align=\"right\">$feedback[0]</p>");
           }
           if ($correct) {
               $correctanswers = implode(", ", $correct);
               quiz_print_correctanswer($correctanswers);
           }
           break;

       case TRUEFALSE:
           if (!$options = get_record("quiz_truefalse", "question", $question->id)) {
               notify("Error: Missing question options!");
           }
           if (!$true = get_record("quiz_answers", "id", $options->trueanswer)) {
               notify("Error: Missing question answers!");
           }
           if (!$false = get_record("quiz_answers", "id", $options->falseanswer)) {
               notify("Error: Missing question answers!");
           }
           if (!$true->answer) {
               $true->answer = get_string("true", "quiz");
           }
           if (!$false->answer) {
               $false->answer = get_string("false", "quiz");
           }
           echo format_text($question->questiontext, $question->questiontextformat, NULL, $courseid);
           quiz_print_possible_question_image($quizid, $question);

           $truechecked = "";
           $falsechecked = "";

           if (!empty($response[$true->id])) {
               $truechecked = 'checked="checked"';
               $feedbackid = $true->id;
           } else if (!empty($response[$false->id])) {
               $falsechecked = 'checked="checked"';
               $feedbackid = $false->id;
           }

           $truecorrect = "";
           $falsecorrect = "";
           if ($correct) {
               if (!empty($correct[$true->id])) {
                   $truecorrect = 'class="highlight"';
               }
               if (!empty($correct[$false->id])) {
                   $falsecorrect = 'class="highlight"';
               }
           }
           echo "<table align=\"right\" cellpadding=\"5\"><tr><td align=\"right\">$stranswer:&nbsp;&nbsp;";
           echo "<td $truecorrect>";
           echo "<input $truechecked type=\"radio\" name=\"q$realquestion->id\" value=\"$true->id\" />$true->answer";
           echo "</td><td $falsecorrect>";
           echo "<input $falsechecked type=\"radio\" name=\"q$realquestion->id\" value=\"$false->id\" />$false->answer";
           echo "</td></tr></table><br clear=\"all\">";// changed from CLEAR=ALL jm
           if ($feedback) {
               quiz_print_comment("<p align=\"right\">$feedback[$feedbackid]</p>");
           }

           break;

       case MULTICHOICE:
           if (!$options = get_record("quiz_multichoice", "question", $question->id)) {
               notify("Error: Missing question options!");
           }
           if (!$answers = get_records_list("quiz_answers", "id", $options->answers)) {
               notify("Error: Missing question answers!");
           }
           echo format_text($question->questiontext, $question->questiontextformat, NULL, $courseid);
           quiz_print_possible_question_image($quizid, $question);
           echo "<table align=\"right\">";
           echo "<tr><td valign=\"top\">$stranswer:&nbsp;&nbsp;</td><td>";
           echo "<table>";
           $answerids = explode(",", $options->answers);

           if ($shuffleanswers) {
               $answerids = swapshuffle($answerids);
           }

           foreach ($answerids as $key => $answerid) {
               $answer = $answers[$answerid];
               $qnumchar = chr(ord('a') + $key);

               if (empty($response[$answerid])) {
                   $checked = "";
               } else {
                   $checked = 'checked="checked"';
               }
               echo '<tr><td valign="top">';
               if ($options->single) {
                   echo "<input $checked type=\"radio\" name=\"q$realquestion->id\" value=\"$answer->id\" />";
               } else {
                   echo "<input $checked type=\"checkbox\" name=\"q$realquestion->id"."a$answer->id\" value=\"$answer->id\" />";
               }
               echo "</td>";
               if (empty($feedback) or empty($correct[$answer->id])) {
                   echo '<td valign="top">'.format_text("$qnumchar. $answer->answer").'</td>';
               } else {
                   echo '<td valign="top" class="highlight">'.format_text("$qnumchar. $answer->answer").'</td>';
               }
               if (!empty($feedback)) {
                   echo "<td valign=\"top\">&nbsp;";
                   if (!empty($response[$answerid])) {
                       quiz_print_comment($feedback[$answerid]);
                   }
                   echo "</td>";
               }
               echo "</tr>";
           }
           echo "</table>";
           echo "</td></tr></table>";
           break;

       case MATCH:
           if (!$options = get_record("quiz_match", "question", $question->id)) {
               notify("Error: Missing question options!");
           }
           if (!$subquestions = get_records_list("quiz_match_sub", "id", $options->subquestions)) {
               notify("Error: Missing subquestions for this question!");
           }
           if (!empty($question->questiontext)) {
               echo format_text($question->questiontext, $question->questiontextformat, NULL, $courseid);
           }
           quiz_print_possible_question_image($quizid, $question);

           if ($shuffleanswers) {
               $subquestions = draw_rand_array($subquestions, count($subquestions));
           }
           foreach ($subquestions as $subquestion) {
               $answers[$subquestion->id] = $subquestion->answertext;
           }

           $answers = draw_rand_array($answers, count($answers));

           echo '<table border="0" cellpadding="10" align="right">';
           foreach ($subquestions as $key => $subquestion) {
               echo '<tr><td align="left" valign="top">';
               echo $subquestion->questiontext;
               echo '</td>';
               if (empty($response)) {
                   echo '<td align="right" valign="top">';
                   choose_from_menu($answers, "q$realquestion->id"."r$subquestion->id");
               } else {
                   if (empty($response[$key])) {
                       echo '<td align="right" valign="top">';
                       choose_from_menu($answers, "q$realquestion->id"."r$subquestion->id");
                   } else {
                       if ($response[$key] == $correct[$key]) {
                           echo '<td align="right" valign="top" class="highlight">';
                           choose_from_menu($answers, "q$realquestion->id"."r$subquestion->id", $response[$key]);
                       } else {
                           echo '<td align="right" valign="top">';
                           choose_from_menu($answers, "q$realquestion->id"."r$subquestion->id", $response[$key]);
                       }
                   }

                   if (!empty($feedback[$key])) {
                       quiz_print_comment($feedback[$key]);
                   }
               }
               echo '</td></tr>';
           }
           echo '</table>';

           break;

       case RANDOMSAMATCH:
           if (!$options = get_record("quiz_randomsamatch", "question", $question->id)) {
               notify("Error: Missing question options!");
           }
           echo format_text($question->questiontext, $question->questiontextformat, NULL, $courseid);
           quiz_print_possible_question_image($quizid, $question);

           /// First, get all the questions available

           $allquestions = get_records_select("quiz_questions",
                                              "category = $question->category AND qtype = ".SHORTANSWER);
           if (count($allquestions) < $options->choose) {
               notify("Error: could not find enough Short Answer questions in the database!");
               notify("Found ".count($allquestions).", need $options->choose.");
               break;
           }

           if (empty($response)) {  // Randomly pick the questions
               if (!$randomquestions = draw_rand_array($allquestions, $options->choose)) {
                   notify("Error choosing $options->choose random questions");
                   break;
               }
           } else {                 // Use existing questions
               $randomquestions = array();
               foreach ($response as $key => $rrr) {
                   $rrr = explode("-", $rrr);
                   $randomquestions[$key] = $allquestions[$key];
                   $responseanswer[$key] = $rrr[1];
               }
           }

           /// For each selected, find the best matching answers

           foreach ($randomquestions as $randomquestion) {
               $shortanswerquestion = get_record("quiz_shortanswer", "question", $randomquestion->id);
               $questionanswers = get_records_list("quiz_answers", "id", $shortanswerquestion->answers);
               $bestfraction = 0;
               $bestanswer = NULL;
               foreach ($questionanswers as $questionanswer) {
                   if ($questionanswer->fraction > $bestfraction) {
                       $bestanswer = $questionanswer;
                       $bestfraction = $questionanswer->fraction;
                   }
               }
               if (empty($bestanswer)) {
                   notify("Error: Could not find the best answer for question: ".$randomquestions->name);
                   break;
               }
               $randomanswers[$bestanswer->id] = trim($bestanswer->answer);
           }

           if (!$randomanswers = draw_rand_array($randomanswers, $options->choose)) {  // Mix them up
               notify("Error randomising answers!");
               break;
           }

           echo '<table border="0" cellpadding="10">';
           foreach ($randomquestions as $key => $randomquestion) {
               echo '<tr><td align="left" valign="top">';
               echo $randomquestion->questiontext;
               echo '</td>';
               echo '<td align="right" valign="top">';
               if (empty($response)) {
                   choose_from_menu($randomanswers, "q$realquestion->id"."r$randomquestion->id");
               } else {
                   if (!empty($correct[$key])) {
                       if ($randomanswers[$responseanswer[$key]] == $correct[$key]) {
                           echo '<span="highlight">';
                           choose_from_menu($randomanswers, "q$realquestion->id"."r$randomquestion->id", $responseanswer[$key]);
                           echo '</span><br />';
                       } else {
                           choose_from_menu($randomanswers, "q$realquestion->id"."r$randomquestion->id", $responseanswer[$key]);
                           quiz_print_correctanswer($correct[$key]);
                       }
                   } else {
                       choose_from_menu($randomanswers, "q$realquestion->id"."r$randomquestion->id", $responseanswer[$key]);
                   }
                   if (!empty($feedback[$key])) {
                       quiz_print_comment($feedback[$key]);
                   }
               }
               echo '</td></tr>';
           }
           echo '</table>';
           break;

       case MULTIANSWER:
           // For this question type, we better print the image on top:
           quiz_print_possible_question_image($quizid, $question);

           $qtextremaining = format_text($question->questiontext, $question->questiontextformat, NULL, $courseid);

           // The regex will recognize text snippets of type {#X}
           // where the X can be any text not containg } or white-space characters.

           $strfeedback = get_string('feedback', 'quiz');

           while (ereg('\{#([^[:space:]}]*)}', $qtextremaining, $regs)) {
               $qtextsplits = explode($regs[0], $qtextremaining, 2);
               echo $qtextsplits[0];
               $qtextremaining = $qtextsplits[1];

               $multianswer = get_record('quiz_multianswers', 'question', $question->id, 'positionkey', $regs[1]);

               $inputname= " name=\"q{$realquestion->id}ma$multianswer->id\" ";

               if (!empty($response) && ereg('(.[^-]*)-(.+)', array_shift($response), $responseitems)) {
                   $responsefractiongrade = (float)$responseitems[1];
                   $actualresponse = $responseitems[2];

                   if (1.0 == $responsefractiongrade) {
                       $style = 'style="background-color:lime"';
                   } else if (0.0 < $responsefractiongrade) {
                       $style = 'style="background-color:yellow"';
                   } else if ('' != $actualresponse) {
                       // The response must have been totally wrong:
                       $style = 'style="background-color:red"';
                   } else {
                       // There was no response given
                       $style = '';
                   }
               } else {
                   $responsefractiongrade = 0.0;
                   $actualresponse = '';
                   $style = '';
               }

               $feedbackitem = '';
               switch ($multianswer->answertype) {
                   case SHORTANSWER:
                   case NUMERICAL:
                       if (isset($feedback[$regs[1]-1])) {
                           $title = str_replace("'", "\\'", $feedback[$regs[1]-1] );
                           $popup = " onmouseover=\"return overlib('$title', CAPTION, '$strfeedback', FGCOLOR, '$THEME->cellcontent');\" ".
                                    " onmouseout=\"return nd();\" ";
                       } else {
                           $popup = '';
                       }
                       echo " <input $style $popup $inputname value=\"$actualresponse\" type=\"text\" size=\"12\" /> ";
                       break;
                   case MULTICHOICE:
                       $outputoptions = '';
                       $answers = get_records_list("quiz_answers", "id", $multianswer->answers);
                       $outputoptions .= '<option></option>'; // Default empty option
                       foreach ($answers as $answer) {
                           if ($answer->id == $actualresponse) {
                               $selected = 'selected';
                               $feedbackitem = $answer->feedback;
                           } else {
                               $selected = '';
                           }
                           $outputoptions .= "<option value=\"$answer->id\" $selected>$answer->answer</option>";
                       }
                       if ($feedbackitem) {
                           $title = str_replace("'", "\\'", $feedbackitem);
                           $popup = " onmouseover=\"return overlib('$title', CAPTION, '$strfeedback', FGCOLOR, '$THEME->cellcontent');\" ".
                                    " onmouseout=\"return nd();\" ";
                       } else {
                           $popup = '';
                       }
                       echo "<select $popup $style $inputname>";
                       echo $outputoptions;
                       echo '</select>';
                       break;
                   default:
                       error("Unable to recognized answertype $answer->answertype");
                       break;
               }
           }

           // Print the final piece of question text:
           echo $qtextremaining;
           break;

       case RANDOM:
           // This can only happen if it is a recently added question

           echo '<p>' . get_string('random', 'quiz') . '</p>';
           break;

       default:
           notify("Error: Unknown question type!");
    }

    echo "</td></tr></table>";
}


function quiz_print_quiz_questions($quiz, $results=NULL, $questions=NULL, $shuffleorder=NULL) {
// Prints a whole quiz on one page.

    /// Get the questions

    if (!$questions) {
        if (empty($quiz->questions)) {
            notify("No questions have been defined!");
            return false;
        }

        if (!$questions = get_records_list("quiz_questions", "id", $quiz->questions, "")) {
            notify("Error when reading questions from the database!");
            return false;
        }
    }

    if (!$shuffleorder) {
        if (!empty($quiz->shufflequestions)) {              // Mix everything up
            $questions = swapshuffle_assoc($questions);
        } else {
            $shuffleorder = explode(",", $quiz->questions);  // Use originally defined order
        }
    }

    if ($shuffleorder) {                             // Order has been defined, so reorder questions
        $oldquestions = $questions;
        $questions = array();
        foreach ($shuffleorder as $key) {
            if (empty($oldquestions[$key])) { // Check for recently added questions
                if ($recentlyaddedquestion =
                        get_record("quiz_questions", "id", $key)) {
                    $recentlyaddedquestion->recentlyadded = true;
                    $questions[] = $recentlyaddedquestion;
                }
            } else {
                $questions[] = $oldquestions[$key];      // This loses the index key, but doesn't matter
            }
        }
    }

    if (!$grades = get_records_list("quiz_question_grades", "question", $quiz->questions, "", "question,grade")) {
        notify("No grades were found for these questions!");
        return false;
    }


    /// Examine the set of questions for random questions, and retrieve them

    if (empty($results)) {   // Choose some new random questions
        if ($randomcats = quiz_get_random_categories($quiz->questions)) {
            foreach ($randomcats as $randomcat => $randomdraw) {
                /// Get the appropriate amount of random questions from this category
                if (!$catquestions[$randomcat] = quiz_choose_random_questions($randomcat, $randomdraw, $quiz->questions)) {
                    notify(get_string("toomanyrandom", "quiz", $randomcat));
                    return false;
                }
            }
        }
    } else {                 // Get the previously chosen questions
        $chosen = array();
        foreach ($questions as $question) {
            if (isset($question->random)) {
                $chosen[] = $question->random;
            }
        }
        if ($chosen) {
            $chosenlist = implode(",", $chosen);
            if (!$chosen = get_records_list("quiz_questions", "id", $chosenlist, "")) {
                notify("Error when reading questions from the database!");
                return false;
            }
        }
    }

    $strconfirmattempt = addslashes(get_string("readytosend", "quiz"));

    if (empty($quiz->grade)) {
        $onsubmit = "";
    } else {
        $onsubmit = "onsubmit=\"return confirm('$strconfirmattempt');\"";
    }
    // BEGIN EDIT
    if($quiz->timelimit > 0) {
        ?>
        <script language="javascript" type="text/javascript">
        <!--
            document.write("<form method=\"post\" action=\"attempt.php\" <?php print(addslashes($onsubmit));?>>\n");
        // -->
        </script>
        <noscript>
        <center><p><strong><?php print_string("noscript","quiz"); ?></strong></p></center>
        </noscript>
        <?php
    } else {
    echo "<form method=\"post\" action=\"attempt.php\" $onsubmit>\n";
    }
    // END EDIT
    echo "<input type=\"hidden\" name=\"q\" value=\"$quiz->id\" />\n";

    $count = 0;
    $questionorder = array();

    foreach ($questions as $question) {

        if ($question->qtype != DESCRIPTION) {    // Description questions are not counted
            $count++;
        }

        $questionorder[] = $question->id;

        $feedback       = NULL;
        $response       = NULL;
        $actualgrades   = NULL;
        $correct        = NULL;
        $randomquestion = NULL;

        if (empty($results)) {
            if ($question->qtype == RANDOM ) {   // Set up random questions
                $randomquestion = $question;
                $question = array_pop($catquestions[$randomquestion->category]);
                $grades[$question->id]->grade = $grades[$randomquestion->id]->grade;
            }
        } else {
            if (!empty($results->feedback[$question->id])) {
                $feedback      = $results->feedback[$question->id];
            }
            if (!empty($results->response[$question->id])) {
                $response      = $results->response[$question->id];
            }
            if (!empty($results->grades[$question->id])) {
                $actualgrades  = $results->grades[$question->id];
            }
            if ($quiz->correctanswers) {
                if (!empty($results->correct[$question->id])) {
                    $correct   = $results->correct[$question->id];
                }
            }
            if (!empty($question->random)) {
                $randomquestion = $question;
                $question = $chosen[$question->random];
                $grades[$question->id]->grade = $grades[$randomquestion->id]->grade;
            }
        }

        print_simple_box_start("center", "90%");
        quiz_print_question($count, $question, $grades[$question->id]->grade, $quiz->id,
                            $feedback, $response, $actualgrades, $correct,
                            $randomquestion, $quiz->shuffleanswers, $quiz->grade, $quiz->course);
        print_simple_box_end();
        echo "<br />";
    }

    $attemptbuildsonthelast = isset($results->attemptbuildsonthelast) ? $results->attemptbuildsonthelast : NULL;

    if (empty($results) || $attemptbuildsonthelast) {
        if (!empty($quiz->shufflequestions)) {  // Things have been mixed up, so pass the question order
            $shuffleorder = implode(',', $questionorder);
            echo "<input type=\"hidden\" name=\"shuffleorder\" value=\"$shuffleorder\" />\n";
        }
        if($quiz->timelimit > 0) {
            echo "<script language=\"javascript\" type=\"text/javascript\">\n";
            echo "<!--\n";
            echo "document.write('<center><input type=\"button\" value=\"".get_string("savemyanswers", "quiz")."\" onclick=\"return send_data();\" /></center>');\n";
            echo "// -->\n";
            echo "</script>\n";
            echo "<noscript>\n";
            echo "<center><strong>".get_string("noscript","quiz")."</strong></center>\n";
            echo "</noscript>\n";
        } else {
        echo "<center>\n<input type=\"submit\" value=\"".get_string("savemyanswers", "quiz")."\" />\n</center>";
    }
    }
    echo "</form>";

    return true;
}


function quiz_get_default_category($courseid) {
/// Returns the current category

    if ($categories = get_records("quiz_categories", "course", $courseid, "id")) {
        foreach ($categories as $category) {
            return $category;   // Return the first one (lowest id)
        }
    }

    // Otherwise, we need to make one
    $category->name = get_string("default", "quiz");
    $category->info = get_string("defaultinfo", "quiz");
    $category->course = $courseid;
    $category->publish = 0;
    $category->stamp = make_unique_id_code();

    if (!$category->id = insert_record("quiz_categories", $category)) {
        notify("Error creating a default category!");
        return false;
    }
    return $category;
}

function quiz_get_category_menu($courseid, $published=false) {
/// Returns the list of categories
    $publish = "";
    if ($published) {
        $publish = "OR publish = '1'";
    }
    return get_records_select_menu("quiz_categories", "course='$courseid' $publish", "name ASC", "id,name");
}

function quiz_print_category_form($course, $current) {
// Prints a form to choose categories

    if (!$categories = get_records_select("quiz_categories", "course = '$course->id' OR publish = '1'", "name ASC")) {
        if (!$category = quiz_get_default_category($course->id)) {
            notify("Error creating a default category!");
            return false;
        }
        $categories[$category->id] = $category;
    }
    foreach ($categories as $key => $category) {
       if ($catcourse = get_record("course", "id", $category->course)) {
           if ($category->publish) {
               $category->name .= " ($catcourse->shortname)";
           }
           $catmenu[$category->id] = $category->name;
       }
    }
    $strcategory = get_string("category", "quiz");
    $strshow = get_string("show", "quiz");
    $streditcats = get_string("editcategories", "quiz");

    echo "<table width=\"100%\"><tr><td width=\"20\" nowrap=\"nowrap\">";
    echo "<b>$strcategory:</b>&nbsp;";
    echo "</td><td>";
    popup_form ("edit.php?cat=", $catmenu, "catmenu", $current, "choose", "", "", false, "self");
    echo "</td><td align=\"right\">";
    echo "<form method=\"get\" action=\"category.php\">";
    echo "<input type=\"hidden\" name=\"id\" value=\"$course->id\" />";
    echo "<input type=\"submit\" value=\"$streditcats\" />";
    echo "</form>";
    echo "</td></tr></table>";
}

function quiz_category_select_menu($courseid,$published=false,$only_editable=false,$selected="") {
/// displays a select menu of categories with appended coursenames
/// optionaly non editable categories may be excluded
/// added Howard Miller June '04
    // get sql fragment for published
    $publishsql="";
    if ($published) {
        $publishsql = "or publish=1";
    }
    $categories = get_records_select("quiz_categories","course=$courseid $publishsql");
    echo "<select name=\"category\">\n";
    foreach ($categories as $category) {
        $cid = $category->id;
        $cname = quiz_get_category_coursename( $category );
        $seltxt = "";
        if ($cid==$selected) {
            $seltxt = "selected=\"true\"";
        }
        if ((!$only_editable) || isteacheredit($category->course)) {
            echo "    <option value=\"$cid\" $seltxt>$cname</option>\n";
        }
    }
    echo "</select>\n";
}

function quiz_get_category_coursename($category) {
/// if the category is published, adds on the course
/// name
    $cname=$category->name;
    if ($category->publish) {
        if ($catcourse=get_record("course","id",$category->id)) {
            $cname .= " ($catcourse->shortname) ";
        }
    }
    return $cname;
}

function quiz_choose_random_questions($category, $draws, $excluded=0) {
/// Given a question category and a number of draws, this function
/// creates a random subset of that size - returned as an array of questions

    if (!$pool = get_records_select_menu("quiz_questions",
                "category = '$category' AND id NOT IN ($excluded)
                                        AND qtype <> ".RANDOM."
                                        AND qtype <> ".DESCRIPTION,
                                        "", "id,qtype")) {
        return false;
    }

    $countpool = count($pool);

    if ($countpool == $draws) {
        $chosen = $pool;
    } else if ($countpool < $draws) {
        return false;
    } else {
        $chosen = draw_rand_array($pool, $draws);
    }

    $chosenlist = implode(",", array_keys($chosen));
    return get_records_list("quiz_questions", "id", $chosenlist);
}


function quiz_get_all_question_grades($questionlist, $quizid) {
// Given a list of question IDs, finds grades or invents them to
// create an array of matching grades

    if (empty($questionlist)) {
        return array();
    }

    $questions = quiz_get_question_grades($quizid, $questionlist);

    $list = explode(",", $questionlist);
    $grades = array();

    foreach ($list as $qid) {
        if (isset($questions[$qid])) {
            $grades[$qid] = $questions[$qid]->grade;
        } else {
            $grades[$qid] = 1;
        }
    }
    return $grades;
}

function quiz_gradesmenu_options($defaultgrade) {
// Especially for multianswer questions it is often
// desirable to have the grade of the question in a quiz
// larger than the earlier maximum of 10 points.
// This function makes quiz question list grade selector drop-down
// have the maximum grade option set to the highest value between 10
// and the defaultgrade of the question.

    if ($defaultgrade && $defaultgrade>10) {
        $maxgrade = $defaultgrade;
    } else {
        $maxgrade = 10;
    }

    unset($gradesmenu);
    for ($i=$maxgrade ; $i>=0 ; --$i) {
        $gradesmenu[$i] = $i;
    }
    return $gradesmenu;
}

function quiz_print_question_list($questionlist, $grades) {
// Prints a list of quiz questions in a small layout form with knobs
// $questionlist is comma-separated list
// $grades is an array of corresponding grades

    global $THEME;

    if (!$questionlist) {
        echo "<p align=\"center\">";
        print_string("noquestions", "quiz");
        echo "</p>";
        return;
    }

    $order = explode(",", $questionlist);

    if (!$questions = get_list_of_questions($questionlist)) {
        echo "<p align=\"center\">";
        print_string("noquestions", "quiz");
        echo "</p>";
        return;

    }

    $strorder = get_string("order");
    $strquestionname = get_string("questionname", "quiz");
    $strgrade = get_string("grade");
    $strdelete = get_string("delete");
    $stredit = get_string("edit");
    $strmoveup = get_string("moveup");
    $strmovedown = get_string("movedown");
    $strsavegrades = get_string("savegrades", "quiz");
    $strtype = get_string("type", "quiz");

    $count = 0;
    $sumgrade = 0;
    $total = count($order);
    echo "<form method=\"post\" action=\"edit.php\">";
    echo "<table border=\"0\" cellpadding=\"5\" cellspacing=\"2\" width=\"100%\">\n";
    echo "<tr><th width=\"*\" colspan=\"3\" nowrap=\"nowrap\">$strorder</th><th align=\"left\" width=\"100%\" nowrap=\"nowrap\">$strquestionname</th><th width=\"*\" nowrap=\"nowrap\">$strtype</th><th width=\"*\" nowrap=\"nowrap\">$strgrade</th><th width=\"*\" nowrap=\"nowrap\">$stredit</th></tr>\n";
    foreach ($order as $qnum) {
        if (empty($questions[$qnum])) {
            continue;
        }
        $question = $questions[$qnum];
        $canedit = isteacheredit($question->course);
        $count++;
        echo "<tr bgcolor=\"$THEME->cellcontent\">";
        echo "<td>$count</td>";
        echo "<td>";
        if ($count != 1) {
            echo "<a title=\"$strmoveup\" href=\"edit.php?up=$qnum\"><img
                 src=\"../../pix/t/up.gif\" border=\"0\"></a>";
        }
        echo "</td>";
        echo "<td>";
        if ($count != $total) {
            echo "<a title=\"$strmovedown\" href=\"edit.php?down=$qnum\"><img
                 src=\"../../pix/t/down.gif\" border=\"0\"></a>";
        }
        echo "</td>";
        echo "<td>$question->name</td>";
        echo "<td align=\"center\">";
        quiz_print_question_icon($question, $canedit);
        echo "</td>";
        echo "<td>";
        if ($question->qtype == DESCRIPTION) {
            echo "<input type=\"hidden\" name=\"q$qnum\" value=\"0\" /> \n";
        } else {
            choose_from_menu(quiz_gradesmenu_options($question->defaultgrade),
                             "q$qnum", (string)$grades[$qnum], "");
        }
        echo "<td>";
            echo "<a title=\"$strdelete\" href=\"edit.php?delete=$qnum\"><img
                 src=\"../../pix/t/delete.gif\" border=\"0\"></a>&nbsp;";
            if ($canedit) {
                echo "<a title=\"$stredit\" href=\"question.php?id=$qnum\"><img
                     src=\"../../pix/t/edit.gif\" border=\"0\"></a>\n";
            }
        echo "</td>";

        $sumgrade += $grades[$qnum];
    }
    echo "<tr><td colspan=5 align=\"right\">\n";
    echo "<input type=\"submit\" value=\"$strsavegrades:\" />\n";
    echo "<input type=\"hidden\" name=\"setgrades\" value=\"save\" />\n";
    echo "<td align=\"left\" bgcolor=\"$THEME->cellcontent\">\n";
    echo "<b>$sumgrade</b>";
    echo "</td><td>\n</td></tr>\n";
    echo "</table>\n";
    echo "</form>\n";

    return $sumgrade;
}


function quiz_print_cat_question_list($categoryid, $quizselected=true) {
// Prints a form to choose categories

    global $THEME, $QUIZ_QUESTION_TYPE;

    $strcategory = get_string("category", "quiz");
    $strquestion = get_string("question", "quiz");
    $straddquestions = get_string("addquestions", "quiz");
    $strimportquestions = get_string("importquestions", "quiz");
    $strexportquestions = get_string("exportquestions", "quiz");
    $strnoquestions = get_string("noquestions", "quiz");
    $strselect = get_string("select", "quiz");
    $strselectall = get_string("selectall", "quiz");
    $strcreatenewquestion = get_string("createnewquestion", "quiz");
    $strquestionname = get_string("questionname", "quiz");
    $strdelete = get_string("delete");
    $stredit = get_string("edit");
    $straddselectedtoquiz = get_string("addselectedtoquiz", "quiz");
    $strtype = get_string("type", "quiz");
    $strcreatemultiple = get_string("createmultiple", "quiz");

    if (!$categoryid) {
        echo "<p align=\"center\"><b>";
        print_string("selectcategoryabove", "quiz");
        echo "</b></p>";
        if ($quizselected) {
            echo "<p>";
            print_string("addingquestions", "quiz");
            echo "</p>";
        }
        return;
    }

    if (!$category = get_record("quiz_categories", "id", "$categoryid")) {
        notify("Category not found!");
        return;
    }
    echo "<center>";
    echo format_text($category->info, FORMAT_MOODLE);

    echo '<table><tr>';

    // check if editing of this category is allowed
    if (isteacheredit($category->course)) {
        echo "<td valign=\"top\"><b>$strcreatenewquestion:</b></td>";
        echo '<td valign="top" align="right">';
        popup_form ("question.php?category=$category->id&qtype=", $QUIZ_QUESTION_TYPE, "addquestion",
                    "", "choose", "", "", false, "self");
        echo '<td width="10" valign="top" align="right">';
        helpbutton("questiontypes", $strcreatenewquestion, "quiz");
        echo '</td></tr>';

        echo '<tr><td colspan="3" align="right">';
        echo '<form method="get" action="import.php">';
        echo "<input type=\"hidden\" name=\"category\" value=\"$category->id\" />";
        echo "<input type=\"submit\" value=\"$strimportquestions\" />";
        helpbutton("import", $strimportquestions, "quiz");
        echo '</form>';
        echo '</td></tr>';
    }
    else {
        echo '<tr><td>';
        print_string("publishedit","quiz");
        echo '</td></tr>';
    }

    echo '<tr><td colspan="3" align="right">';
    echo '<form method="get" action="export.php">';
    echo "<input type=\"hidden\" name=\"category\" value=\"$category->id\" />";
    echo "<input type=\"submit\" value=\"$strexportquestions\" />";
    helpbutton("export", $strexportquestions, "quiz");
    echo '</form>';
    echo '</td></tr>';

    if (isteacheredit($category->course)) {
        echo '<tr><td colspan="3" align="right">';
        echo '<form method="get" action="multiple.php">';
        echo "<input type=\"hidden\" name=\"category\" value=\"$category->id\" />";
        echo "<input type=\"submit\" value=\"$strcreatemultiple\" />";
        helpbutton("createmultiple", $strcreatemultiple, "quiz");
        echo '</form>';
        echo '</td></tr>';
    }

    echo '</table>';

    echo '</center>';

    if (!$questions = get_records("quiz_questions", "category", $category->id, "qtype ASC")) {
        echo "<p align=\"center\">";
        print_string("noquestions", "quiz");
        echo "</p>";
        return;
    }

    $canedit = isteacheredit($category->course);

    echo "<form method=\"post\" action=\"edit.php\">";
    echo "<table border=\"0\" cellpadding=\"5\" cellspacing=\"2\" width=\"100%\">";
    echo "<tr>";
    if ($quizselected) {
        echo "<th width=\"*\" nowrap=\"nowrap\">$strselect</th>";
    }
    echo "<th width=\"100%\" align=\"left\" nowrap=\"nowrap\">$strquestionname</th><th width=\"*\" nowrap=\"nowrap\">$strtype</th>";
    if ($canedit) {
        echo "<th width=\"*\" nowrap=\"nowrap\">$stredit</th>";
    }
    echo "</tr>\n";
    foreach ($questions as $question) {
        echo "<tr bgcolor=\"$THEME->cellcontent\">\n";
        if ($quizselected) {
            echo "<td align=\"center\">";
            echo "<input type=\"checkbox\" name=\"q$question->id\" value=\"1\" />\n";
            echo "</td>";
        }
        echo "<td>".$question->name."</td>\n";
        echo "<td align=\"center\">\n";
        quiz_print_question_icon($question, $canedit);
        echo "</td>\n";
        if ($canedit) {
            echo "<td>\n";
                echo "<a title=\"$strdelete\" href=\"question.php?id=$question->id&delete=$question->id\">\n<img
                     src=\"../../pix/t/delete.gif\" border=0></a>&nbsp;";
                echo "<a title=\"$stredit\" href=\"question.php?id=$question->id\"><img
                     src=\"../../pix/t/edit.gif\" border=0></a>";
            echo "</td>\n";// deleted </tr> jm
        }
        echo "</tr>\n";
    }
    if ($quizselected) {
        echo "<tr>\n<td colspan=\"3\">";
        echo "<input type=\"submit\" name=\"add\" value=\"<< $straddselectedtoquiz\" />\n";
        //echo "<input type=submit name=\"delete\" value=\"XX Delete selected\">";
        echo "<input type=\"button\" onclick=\"checkall()\" value=\"$strselectall\" />\n";
        echo "</td></tr>";
    }
    echo "</table>\n";
    echo "</form>\n";
}


function quiz_start_attempt($quizid, $userid, $numattempt) {
    $attempt->quiz = $quizid;
    $attempt->userid = $userid;
    $attempt->attempt = $numattempt;
    $attempt->timestart = time();
    $attempt->timefinish = 0;
    $attempt->timemodified = time();

    return insert_record("quiz_attempts", $attempt);
}

function quiz_get_user_attempt_unfinished($quizid, $userid) {
// Returns an object containing an unfinished attempt (if there is one)
    return get_record("quiz_attempts", "quiz", $quizid, "userid", $userid, "timefinish", 0);
}

function quiz_get_user_attempts($quizid, $userid) {
// Returns a list of all attempts by a user
    return get_records_select("quiz_attempts", "quiz = '$quizid' AND userid = '$userid' AND timefinish > 0",
                              "attempt ASC");
}


function quiz_get_user_attempts_string($quiz, $attempts, $bestgrade) {
/// Returns a simple little comma-separated list of all attempts,
/// with each grade linked to the feedback report and with the best grade highlighted

    $bestgrade = format_float($bestgrade);
    foreach ($attempts as $attempt) {
        $attemptgrade = format_float(($attempt->sumgrades / $quiz->sumgrades) * $quiz->grade);
        if ($attemptgrade == $bestgrade) {
            $userattempts[] = "<span class=\"highlight\"><a href=\"review.php?q=$quiz->id&attempt=$attempt->id\">$attemptgrade</a></span>";
        } else {
            $userattempts[] = "<a href=\"review.php?q=$quiz->id&attempt=$attempt->id\">$attemptgrade</a>";
        }
    }
    return implode(",", $userattempts);
}

function quiz_get_best_grade($quizid, $userid) {
/// Get the best current grade for a particular user in a quiz
    if (!$grade = get_record("quiz_grades", "quiz", $quizid, "userid", $userid)) {
        return "";
    }

    return (round($grade->grade,0));
}

function quiz_save_best_grade($quiz, $userid) {
/// Calculates the best grade out of all attempts at a quiz for a user,
/// and then saves that grade in the quiz_grades table.

    if (!$attempts = quiz_get_user_attempts($quiz->id, $userid)) {
        notify("Could not find any user attempts");
        return false;
    }

    $bestgrade = quiz_calculate_best_grade($quiz, $attempts);
    $bestgrade = (($bestgrade / $quiz->sumgrades) * $quiz->grade);

    if ($grade = get_record("quiz_grades", "quiz", $quiz->id, "userid", $userid)) {
        $grade->grade = round($bestgrade, 2);
        $grade->timemodified = time();
        if (!update_record("quiz_grades", $grade)) {
            notify("Could not update best grade");
            return false;
        }
    } else {
        $grade->quiz = $quiz->id;
        $grade->userid = $userid;
        $grade->grade = round($bestgrade, 2);
        $grade->timemodified = time();
        if (!insert_record("quiz_grades", $grade)) {
            notify("Could not insert new best grade");
            return false;
        }
    }
    return true;
}


function quiz_calculate_best_grade($quiz, $attempts) {
/// Calculate the best grade for a quiz given a number of attempts by a particular user.

    switch ($quiz->grademethod) {

        case ATTEMPTFIRST:
            foreach ($attempts as $attempt) {
                return $attempt->sumgrades;
            }
            break;

        case ATTEMPTLAST:
            foreach ($attempts as $attempt) {
                $final = $attempt->sumgrades;
            }
            return $final;

        case GRADEAVERAGE:
            $sum = 0;
            $count = 0;
            foreach ($attempts as $attempt) {
                $sum += $attempt->sumgrades;
                $count++;
            }
            return (float)$sum/$count;

        default:
        case GRADEHIGHEST:
            $max = 0;
            foreach ($attempts as $attempt) {
                if ($attempt->sumgrades > $max) {
                    $max = $attempt->sumgrades;
                }
            }
            return $max;
    }
}


function quiz_calculate_best_attempt($quiz, $attempts) {
/// Return the attempt with the best grade for a quiz

    switch ($quiz->grademethod) {

        case ATTEMPTFIRST:
            foreach ($attempts as $attempt) {
                return $attempt;
            }
            break;

        case GRADEAVERAGE: // need to do something with it :-)
        case ATTEMPTLAST:
            foreach ($attempts as $attempt) {
                $final = $attempt;
            }
            return $final;

        default:
        case GRADEHIGHEST:
            $max = -1;
            foreach ($attempts as $attempt) {
                if ($attempt->sumgrades > $max) {
                    $max = $attempt->sumgrades;
                    $maxattempt = $attempt;
                }
            }
            return $maxattempt;
    }
}


function quiz_save_attempt($quiz, $questions, $result, $attemptnum) {
/// Given a quiz, a list of attempted questions and a total grade
/// this function saves EVERYTHING so it can be reconstructed later
/// if necessary.

    global $USER;

    // First find the attempt in the database (start of attempt)

    if (!$attempt = quiz_get_user_attempt_unfinished($quiz->id, $USER->id)) {
        notify("Trying to save an attempt that was not started!");
        return false;
    }

    if ($attempt->attempt != $attemptnum) {  // Double check.
        notify("Number of this attempt is different to the unfinished one!");
        return false;
    }

    // Now let's complete this record and save it

    $attempt->sumgrades = $result->sumgrades;
    $attempt->timefinish = time();
    $attempt->timemodified = time();

    if (! update_record("quiz_attempts", $attempt)) {
        notify("Error while saving attempt");
        return false;
    }

    // Now let's save all the questions for this attempt

    foreach ($questions as $question) {
        $response->attempt = $attempt->id;
        $response->question = $question->id;
        $response->grade = $result->grades[$question->id];

        if (!empty($question->random)) {
            // First save the response of the random question
            // the answer is the id of the REAL response
            $response->answer = $question->random;
            if (!insert_record("quiz_responses", $response)) {
                notify("Error while saving response");
                return false;
            }
            $response->question = $question->random;
        }

        if (!empty($question->answer)) {
            $response->answer = implode(",",$question->answer);
        } else {
            $response->answer = "";
        }
        if (!insert_record("quiz_responses", $response)) {
            notify("Error while saving response");
            return false;
        }
    }
    return $attempt;
}

function quiz_grade_attempt_question_result($question,
                                            $answers,
                                            $gradecanbenegative= false)
{
    $grade    = 0;   // default
    $correct  = array();
    $feedback = array();
    $response = array();

    switch ($question->qtype) {
        case SHORTANSWER:
            if ($question->answer) {
                $question->answer = trim(stripslashes($question->answer[0]));
            } else {
                $question->answer = "";
            }
            $response[0] = $question->answer;
            $feedback[0] = '';  // Default
            foreach ($answers as $answer) {  // There might be multiple right answers

                $answer->answer = trim($answer->answer);  // Just in case

                if ($answer->fraction >= 1.0) {
                    $correct[] = $answer->answer;
                }
                if (!$answer->usecase) {       // Don't compare case
                    $answer->answer = strtolower($answer->answer);
                    $question->answer = strtolower($question->answer);
                }

                $potentialgrade = (float)$answer->fraction * $question->grade;

                if ($potentialgrade >= $grade and (strpos(' '.$answer->answer, '*'))) {
                    $answer->answer = str_replace('\*','@@@@@@',$answer->answer);
                    $answer->answer = str_replace('*','.*',$answer->answer);
                    $answer->answer = str_replace('@@@@@@', '\*',$answer->answer);
                    $answer->answer = str_replace('+', '\+',$answer->answer);
                    if (eregi('^'.$answer->answer.'$', $question->answer)) {
                        $feedback[0] = $answer->feedback;
                        $grade = $potentialgrade;
                    }

                } else if ($answer->answer == $question->answer) {
                    $feedback[0] = $answer->feedback;
                    $grade = $potentialgrade;
                }
            }

            break;

        case NUMERICAL:
            if ($question->answer) {
                $question->answer = trim(stripslashes($question->answer[0]));
            } else {
                $question->answer = "";
            }
            $response[0] = $question->answer;
            $bestshortanswer = 0;
            foreach ($answers as $answer) {  // There might be multiple right answers
                if ($answer->fraction > $bestshortanswer) {
                    $correct[$answer->id] = $answer->answer;
                    $bestshortanswer = $answer->fraction;
                    $feedback[0] = $answer->feedback;  // Show feedback for best answer
                }
                if ('' != $question->answer           // Must not be mixed up with zero!
                    && (float)$answer->fraction > (float)$grade // Do we need to bother?
                    and                      // and has lower procedence than && and ||.
                    strtolower($question->answer) == strtolower($answer->answer)
                    || '' != trim($answer->min)
                    && ((float)$question->answer >= (float)$answer->min)
                    && ((float)$question->answer <= (float)$answer->max))
                {
                    //$feedback[0] = $answer->feedback;  No feedback was shown for wrong answers
                    $grade = (float)$answer->fraction;
                }
            }
            $grade *= $question->grade; // Normalize to correct weight
            break;

        case TRUEFALSE:
            if ($question->answer) {
                $question->answer = $question->answer[0];
            } else {
                $question->answer = NULL;
            }
            foreach($answers as $answer) {  // There should be two answers (true and false)
                $feedback[$answer->id] = $answer->feedback;
                if ($answer->fraction > 0) {
                    $correct[$answer->id]  = true;
                }
                if ($question->answer == $answer->id) {
                    $grade = (float)$answer->fraction * $question->grade;
                    $response[$answer->id] = true;
                }
            }
            break;


        case MULTICHOICE:
            foreach($answers as $answer) {  // There will be multiple answers, perhaps more than one is right
                $feedback[$answer->id] = $answer->feedback;
                if ($answer->fraction > 0) {
                    $correct[$answer->id] = true;
                }
                if (!empty($question->answer)) {
                    foreach ($question->answer as $questionanswer) {
                        if ($questionanswer == $answer->id) {
                            $response[$answer->id] = true;
                            if ($answer->single) {
                                $grade = (float)$answer->fraction * $question->grade;
                                continue;
                            } else {
                                $grade += (float)$answer->fraction * $question->grade;
                            }
                        }
                    }
                }
            }
            break;

        case MATCH:
            $matchcount = $totalcount = 0;

            foreach ($question->answer as $questionanswer) {  // Each answer is "subquestionid-answerid"
                $totalcount++;
                $qarr = explode('-', $questionanswer);        // Extract subquestion/answer.
                $subquestionid = $qarr[0];
                $subanswerid = $qarr[1];
                if ($subquestionid and $subanswerid and (($subquestionid == $subanswerid) or
                    ($answers[$subquestionid]->answertext == $answers[$subanswerid]->answertext))) {
                    // Either the ids match exactly, or the answertexts match exactly
                    // (in case two subquestions had the same answer)
                    $matchcount++;
                    $correct[$subquestionid] = true;
                } else {
                    $correct[$subquestionid] = false;
                }
                $response[$subquestionid] = $subanswerid;
            }

            $grade = $question->grade * $matchcount / $totalcount;

            break;

        case RANDOMSAMATCH:
            $bestanswer = array();
            foreach ($answers as $answer) {  // Loop through them all looking for correct answers
                if (empty($bestanswer[$answer->question])) {
                    $bestanswer[$answer->question] = 0;
                    $correct[$answer->question] = "";
                }
                if ($answer->fraction > $bestanswer[$answer->question]) {
                    $bestanswer[$answer->question] = $answer->fraction;
                    $correct[$answer->question] = $answer->answer;
                }
            }
            $answerfraction = 1.0 / (float) count($question->answer);
            foreach ($question->answer as $questionanswer) {  // For each random answered question
                $rqarr = explode('-', $questionanswer);   // Extract question/answer.
                $rquestion = $rqarr[0];
                $ranswer = $rqarr[1];
                $response[$rquestion] = $questionanswer;
                if (isset($answers[$ranswer])) {         // If the answer exists in the list
                    $answer = $answers[$ranswer];
                    $feedback[$rquestion] = $answer->feedback;
                    if ($answer->question == $rquestion) {    // Check that this answer matches the question
                        $grade += (float)$answer->fraction * $question->grade * $answerfraction;
                    }
                }
            }
            break;

        case MULTIANSWER:
            // Default setting that avoids a possible divide by zero:
            $subquestion->grade = 1.0;

            foreach ($question->answer as $questionanswer) {

                // Resetting default values for subresult:
                $subresult->grade = 0.0;
                $subresult->correct = array();
                $subresult->feedback = array();

                // Resetting subquestion responses:
                $subquestion->answer = array();

                $qarr = explode('-', $questionanswer, 2);
                $subquestion->answer[] = $qarr[1];  // Always single answer for subquestions
                foreach ($answers as $multianswer) {
                    if ($multianswer->id == $qarr[0]) {
                        $subquestion->qtype = $multianswer->answertype;
                        $subquestion->grade = $multianswer->norm;
                        $subresult = quiz_grade_attempt_question_result($subquestion, $multianswer->subanswers, true);
                        break;
                    }
                }


                // Summarize subquestion results:
                $grade += $subresult->grade;
                $feedback[] = $subresult->feedback[0];
                $correct[]  = $subresult->correct[0];

                // Each response instance also contains the partial
                // fraction grade for the response:
                $response[] = $subresult->grade/$subquestion->grade
                              . '-' . $subquestion->answer[0];
            }
            // Normalize grade:
            $grade *= $question->grade/($question->defaultgrade);
            break;

        case DESCRIPTION:  // Descriptions are not graded.
            break;

        case RANDOM:   // Returns a recursive call with the real question
            $realquestion = get_record
                    ('quiz_questions', 'id', $question->random);
            $realquestion->answer = $question->answer;
            $realquestion->grade = $question->grade;
            return quiz_grade_attempt_question_result($realquestion, $answers);
    }

    $result->grade =
            $gradecanbenegative ? $grade            // Grade can be negative
                                : max(0.0, $grade); // Grade must not be negative
    $result->correct = $correct;
    $result->feedback = $feedback;
    $result->response = $response;
    return $result;
}

function quiz_grade_attempt_results($quiz, $questions) {
/// Given a list of questions (including answers for each one)
/// this function does all the hard work of calculating the
/// grades for each question, as well as a total grade for
/// for the whole quiz.  It returns everything in a structure
/// that looks like:
/// $result->sumgrades    (sum of all grades for all questions)
/// $result->percentage   (Percentage of grades that were correct)
/// $result->grade        (final grade result for the whole quiz)
/// $result->grades[]     (array of grades, indexed by question id)
/// $result->response[]   (array of response arrays, indexed by question id)
/// $result->feedback[]   (array of feedback arrays, indexed by question id)
/// $result->correct[]    (array of feedback arrays, indexed by question id)

    if (!$questions) {
        error("No questions!");
    }

    if (!$grades = get_records_menu("quiz_question_grades", "quiz", $quiz->id, "", "question,grade")) {
        error("No grades defined for these quiz questions!");
    }

    $result->sumgrades = 0;

    foreach ($questions as $question) {

        $question->grade = $grades[$question->id];

        if (!$answers = quiz_get_answers($question)) {
            error("No answers defined for question id $question->id!");
        }

        $questionresult = quiz_grade_attempt_question_result($question,
                                                             $answers);
        // if time limit is enabled and exceeded, return zero grades
        if($quiz->timelimit > 0) {
            if(($quiz->timelimit + 60) <= $quiz->timesincestart) {
                $questionresult->grade = 0;
            }
        }

        $result->grades[$question->id] = round($questionresult->grade, 2);
        $result->sumgrades += $questionresult->grade;
        $result->feedback[$question->id] = $questionresult->feedback;
        $result->response[$question->id] = $questionresult->response;
        $result->correct[$question->id] = $questionresult->correct;
    }

    $fraction = (float)($result->sumgrades / $quiz->sumgrades);
    $result->percentage = format_float($fraction * 100.0);
    $result->grade      = format_float($fraction * $quiz->grade);
    $result->sumgrades = round($result->sumgrades, 2);

    return $result;
}


function quiz_save_question_options($question) {
/// Given some question info and some data about the the answers
/// this function parses, organises and saves the question
/// It is used by question.php when saving new data from a
/// form, and also by import.php when importing questions
///
/// If this is an update, and old answers already exist, then
/// these are overwritten using an update().  To do this, it
/// it is assumed that the IDs in quiz_answers are in the same
/// sort order as the new answers being saved.  This should always
/// be true, but it's something to keep in mind if fiddling with
/// question.php
///
/// Returns $result->error or $result->noticeyesno or $result->notice

    switch ($question->qtype) {
        case SHORTANSWER:

            if (!$oldanswers = get_records("quiz_answers", "question", $question->id, "id ASC")) {
                $oldanswers = array();
            }

            $answers = array();
            $maxfraction = -1;

            // Insert all the new answers
            foreach ($question->answer as $key => $dataanswer) {
                if ($dataanswer != "") {
                    if ($oldanswer = array_shift($oldanswers)) {  // Existing answer, so reuse it
                        $answer = $oldanswer;
                        $answer->answer   = trim($dataanswer);
                        $answer->fraction = $question->fraction[$key];
                        $answer->feedback = $question->feedback[$key];
                        if (!update_record("quiz_answers", $answer)) {
                            $result->error = "Could not update quiz answer! (id=$answer->id)";
                            return $result;
                        }
                    } else {    // This is a completely new answer
                        unset($answer);
                        $answer->answer   = trim($dataanswer);
                        $answer->question = $question->id;
                        $answer->fraction = $question->fraction[$key];
                        $answer->feedback = $question->feedback[$key];
                        if (!$answer->id = insert_record("quiz_answers", $answer)) {
                            $result->error = "Could not insert quiz answer!";
                            return $result;
                        }
                    }
                    $answers[] = $answer->id;
                    if ($question->fraction[$key] > $maxfraction) {
                        $maxfraction = $question->fraction[$key];
                    }
                }
            }

            if ($options = get_record("quiz_shortanswer", "question", $question->id)) {
                $options->answers = implode(",",$answers);
                $options->usecase = $question->usecase;
                if (!update_record("quiz_shortanswer", $options)) {
                    $result->error = "Could not update quiz shortanswer options! (id=$options->id)";
                    return $result;
                }
            } else {
                unset($options);
                $options->question = $question->id;
                $options->answers = implode(",",$answers);
                $options->usecase = $question->usecase;
                if (!insert_record("quiz_shortanswer", $options)) {
                    $result->error = "Could not insert quiz shortanswer options!";
                    return $result;
                }
            }

            /// Perform sanity checks on fractional grades
            if ($maxfraction != 1) {
                $maxfraction = $maxfraction * 100;
                $result->noticeyesno = get_string("fractionsnomax", "quiz", $maxfraction);
                return $result;
            }
        break;

        case NUMERICAL:   // Note similarities to SHORTANSWER

            if (!$oldanswers = get_records("quiz_answers", "question", $question->id, "id ASC")) {
                $oldanswers = array();
            }

            $answers = array();
            $maxfraction = -1;

            // Insert all the new answers
            foreach ($question->answer as $key => $dataanswer) {
                if ($dataanswer != "") {
                    if ($oldanswer = array_shift($oldanswers)) {  // Existing answer, so reuse it
                        $answer = $oldanswer;
                        $answer->answer   = $dataanswer;
                        $answer->fraction = $question->fraction[$key];
                        $answer->feedback = $question->feedback[$key];
                        if (!update_record("quiz_answers", $answer)) {
                            $result->error = "Could not update quiz answer! (id=$answer->id)";
                            return $result;
                        }
                    } else {    // This is a completely new answer
                        unset($answer);
                        $answer->answer   = $dataanswer;
                        $answer->question = $question->id;
                        $answer->fraction = $question->fraction[$key];
                        $answer->feedback = $question->feedback[$key];
                        if (!$answer->id = insert_record("quiz_answers", $answer)) {
                            $result->error = "Could not insert quiz answer!";
                            return $result;
                        }
                    }
                    $answers[] = $answer->id;
                    if ($question->fraction[$key] > $maxfraction) {
                        $maxfraction = $question->fraction[$key];
                    }

                    if ($options = get_record("quiz_numerical", "answer", $answer->id)) {
                        $options->min= $question->min[$key];
                        $options->max= $question->max[$key];
                        if (!update_record("quiz_numerical", $options)) {
                            $result->error = "Could not update quiz numerical options! (id=$options->id)";
                            return $result;
                        }
                    } else { // completely new answer
                        unset($options);
                        $options->question = $question->id;
                        $options->answer = $answer->id;
                        $options->min = $question->min[$key];
                        $options->max = $question->max[$key];
                        if (!insert_record("quiz_numerical", $options)) {
                            $result->error = "Could not insert quiz numerical options!";
                            return $result;
                        }
                    }
                }
            }

            /// Perform sanity checks on fractional grades
            if ($maxfraction != 1) {
                $maxfraction = $maxfraction * 100;
                $result->noticeyesno = get_string("fractionsnomax", "quiz", $maxfraction);
                return $result;
            }
        break;


        case TRUEFALSE:

            if (!$oldanswers = get_records("quiz_answers", "question", $question->id, "id ASC")) {
                $oldanswers = array();
            }

            if ($true = array_shift($oldanswers)) {  // Existing answer, so reuse it
                $true->answer   = get_string("true", "quiz");
                $true->fraction = $question->answer;
                $true->feedback = $question->feedbacktrue;
                if (!update_record("quiz_answers", $true)) {
                    $result->error = "Could not update quiz answer \"true\")!";
                    return $result;
                }
            } else {
                unset($true);
                $true->answer   = get_string("true", "quiz");
                $true->question = $question->id;
                $true->fraction = $question->answer;
                $true->feedback = $question->feedbacktrue;
                if (!$true->id = insert_record("quiz_answers", $true)) {
                    $result->error = "Could not insert quiz answer \"true\")!";
                    return $result;
                }
            }

            if ($false = array_shift($oldanswers)) {  // Existing answer, so reuse it
                $false->answer   = get_string("false", "quiz");
                $false->fraction = 1 - (int)$question->answer;
                $false->feedback = $question->feedbackfalse;
                if (!update_record("quiz_answers", $false)) {
                    $result->error = "Could not insert quiz answer \"false\")!";
                    return $result;
                }
            } else {
                unset($false);
                $false->answer   = get_string("false", "quiz");
                $false->question = $question->id;
                $false->fraction = 1 - (int)$question->answer;
                $false->feedback = $question->feedbackfalse;
                if (!$false->id = insert_record("quiz_answers", $false)) {
                    $result->error = "Could not insert quiz answer \"false\")!";
                    return $result;
                }
            }

            if ($options = get_record("quiz_truefalse", "question", $question->id)) {
                // No need to do anything, since the answer IDs won't have changed
                // But we'll do it anyway, just for robustness
                $options->trueanswer  = $true->id;
                $options->falseanswer = $false->id;
                if (!update_record("quiz_truefalse", $options)) {
                    $result->error = "Could not update quiz truefalse options! (id=$options->id)";
                    return $result;
                }
            } else {
                unset($options);
                $options->question    = $question->id;
                $options->trueanswer  = $true->id;
                $options->falseanswer = $false->id;
                if (!insert_record("quiz_truefalse", $options)) {
                    $result->error = "Could not insert quiz truefalse options!";
                    return $result;
                }
            }
        break;


        case MULTICHOICE:

            if (!$oldanswers = get_records("quiz_answers", "question", $question->id, "id ASC")) {
                $oldanswers = array();
            }


            // following hack to check at least two answers exist
            $answercount = 0;
            foreach ($question->answer as $key=>$dataanswer) {
                if ($dataanswer != "") {
                    $answercount++;
                }
            }
            $answercount += count($oldanswers);
            if ($answercount < 2) { // check there are at lest 2 answers for multiple choice
                $result->notice = get_string("notenoughanswers", "quiz", "2");
                return $result;
            }


            // Insert all the new answers

            $totalfraction = 0;
            $maxfraction = -1;

            $answers = array();

            foreach ($question->answer as $key => $dataanswer) {
                if ($dataanswer != "") {
                    if ($answer = array_shift($oldanswers)) {  // Existing answer, so reuse it
                        $answer->answer   = $dataanswer;
                        $answer->fraction = $question->fraction[$key];
                        $answer->feedback = $question->feedback[$key];
                        if (!update_record("quiz_answers", $answer)) {
                            $result->error = "Could not update quiz answer! (id=$answer->id)";
                            return $result;
                        }
                    } else {
                        unset($answer);
                        $answer->answer   = $dataanswer;
                        $answer->question = $question->id;
                        $answer->fraction = $question->fraction[$key];
                        $answer->feedback = $question->feedback[$key];
                        if (!$answer->id = insert_record("quiz_answers", $answer)) {
                            $result->error = "Could not insert quiz answer! ";
                            return $result;
                        }
                    }
                    $answers[] = $answer->id;

                    if ($question->fraction[$key] > 0) {                 // Sanity checks
                        $totalfraction += $question->fraction[$key];
                    }
                    if ($question->fraction[$key] > $maxfraction) {
                        $maxfraction = $question->fraction[$key];
                    }
                }
            }

            if ($options = get_record("quiz_multichoice", "question", $question->id)) {
                $options->answers = implode(",",$answers);
                $options->single = $question->single;
                if (!update_record("quiz_multichoice", $options)) {
                    $result->error = "Could not update quiz multichoice options! (id=$options->id)";
                    return $result;
                }
            } else {
                unset($options);
                $options->question = $question->id;
                $options->answers = implode(",",$answers);
                $options->single = $question->single;
                if (!insert_record("quiz_multichoice", $options)) {
                    $result->error = "Could not insert quiz multichoice options!";
                    return $result;
                }
            }

            /// Perform sanity checks on fractional grades
            if ($options->single) {
                if ($maxfraction != 1) {
                    $maxfraction = $maxfraction * 100;
                    $result->noticeyesno = get_string("fractionsnomax", "quiz", $maxfraction);
                    return $result;
                }
            } else {
                $totalfraction = round($totalfraction,2);
                if ($totalfraction != 1) {
                    $totalfraction = $totalfraction * 100;
                    $result->noticeyesno = get_string("fractionsaddwrong", "quiz", $totalfraction);
                    return $result;
                }
            }
        break;

        case MATCH:

            if (!$oldsubquestions = get_records("quiz_match_sub", "question", $question->id, "id ASC")) {
                $oldsubquestions = array();
            }


            // following hack to check at least three answers exist
            $answercount = 0;
            foreach ($question->subquestions as $key=>$questiontext) {
                $answertext = $question->subanswers[$key];
                if (!empty($questiontext) and !empty($answertext)) {
                    $answercount++;
                }
            }
            $answercount += count($oldsubquestions);
            if ($answercount < 3) { // check there are at lest 3 answers for matching type questions
                $result->notice = get_string("notenoughanswers", "quiz", "3");
                return $result;
            }


            $subquestions = array();

            // Insert all the new question+answer pairs
            foreach ($question->subquestions as $key => $questiontext) {
                $answertext = $question->subanswers[$key];
                if (!empty($questiontext) and !empty($answertext)) {
                    if ($subquestion = array_shift($oldsubquestions)) {  // Existing answer, so reuse it
                        $subquestion->questiontext = $questiontext;
                        $subquestion->answertext   = $answertext;
                        if (!update_record("quiz_match_sub", $subquestion)) {
                            $result->error = "Could not insert quiz match subquestion! (id=$subquestion->id)";
                            return $result;
                        }
                    } else {
                        unset($subquestion);
                        $subquestion->question = $question->id;
                        $subquestion->questiontext = $questiontext;
                        $subquestion->answertext   = $answertext;
                        if (!$subquestion->id = insert_record("quiz_match_sub", $subquestion)) {
                            $result->error = "Could not insert quiz match subquestion!";
                            return $result;
                        }
                    }
                    $subquestions[] = $subquestion->id;
                }
            }

            if (count($subquestions) < 3) {
                $result->noticeyesno = get_string("notenoughsubquestions", "quiz");
                return $result;
            }

            if ($options = get_record("quiz_match", "question", $question->id)) {
                $options->subquestions = implode(",",$subquestions);
                if (!update_record("quiz_match", $options)) {
                    $result->error = "Could not update quiz match options! (id=$options->id)";
                    return $result;
                }
            } else {
                unset($options);
                $options->question = $question->id;
                $options->subquestions = implode(",",$subquestions);
                if (!insert_record("quiz_match", $options)) {
                    $result->error = "Could not insert quiz match options!";
                    return $result;
                }
            }

            break;


        case RANDOMSAMATCH:
            $options->question = $question->id;
            $options->choose = $question->choose;
            if ($existing = get_record("quiz_randomsamatch", "question", $options->question)) {
                $options->id = $existing->id;
                if (!update_record("quiz_randomsamatch", $options)) {
                    $result->error = "Could not update quiz randomsamatch options!";
                    return $result;
                }
            } else {
                if (!insert_record("quiz_randomsamatch", $options)) {
                    $result->error = "Could not insert quiz randomsamatch options!";
                    return $result;
                }
            }
        break;

        case MULTIANSWER:
            if (!$oldmultianswers = get_records("quiz_multianswers", "question", $question->id, "id ASC")) {
                $oldmultianswers = array();
            }

            // Insert all the new multi answers
            foreach ($question->answers as $dataanswer) {
                if ($oldmultianswer = array_shift($oldmultianswers)) {  // Existing answer, so reuse it
                    $multianswer = $oldmultianswer;
                    $multianswer->positionkey = $dataanswer->positionkey;
                    $multianswer->norm = $dataanswer->norm;
                    $multianswer->answertype = $dataanswer->answertype;

                    if (! $multianswer->answers = quiz_save_multianswer_alternatives
                            ($question->id, $dataanswer->answertype,
                             $dataanswer->alternatives, $oldmultianswer->answers))
                    {
                        $result->error = "Could not update multianswer alternatives! (id=$multianswer->id)";
                        return $result;
                    }
                    if (!update_record("quiz_multianswers", $multianswer)) {
                        $result->error = "Could not update quiz multianswer! (id=$multianswer->id)";
                        return $result;
                    }
                } else {    // This is a completely new answer
                    unset($multianswer);
                    $multianswer->question = $question->id;
                    $multianswer->positionkey = $dataanswer->positionkey;
                    $multianswer->norm = $dataanswer->norm;
                    $multianswer->answertype = $dataanswer->answertype;

                    if (! $multianswer->answers = quiz_save_multianswer_alternatives
                            ($question->id, $dataanswer->answertype,
                             $dataanswer->alternatives))
                    {
                        $result->error = "Could not insert multianswer alternatives! (questionid=$question->id)";
                        return $result;
                    }
                    if (!insert_record("quiz_multianswers", $multianswer)) {
                        $result->error = "Could not insert quiz multianswer!";
                        return $result;
                    }
                }
            }
        break;

        case RANDOM:
        break;

        case DESCRIPTION:
        break;

        default:
            $result->error = "Unsupported question type ($question->qtype)!";
            return $result;
        break;
    }
    return true;
}


function quiz_remove_unwanted_questions(&$questions, $quiz) {
/// Given an array of questions, and a list of question IDs,
/// this function removes unwanted questions from the array
/// Used by review.php and attempt.php to counter changing quizzes

    $quizquestions = array();
    $quizids = explode(",", $quiz->questions);
    foreach ($quizids as $quizid) {
        $quizquestions[$quizid] = true;
    }
    foreach ($questions as $key => $question) {
        if (!isset($quizquestions[$question->id])) {
            unset($questions[$key]);
        }
    }
}

function quiz_save_multianswer_alternatives
        ($questionid, $answertype, $alternatives, $oldalternativeids= NULL)
{
// Returns false if something goes wrong,
// otherwise the ids of the answers.

    if (empty($oldalternativeids)
        or !($oldalternatives =
                get_records_list('quiz_answers', 'id', $oldalternativeids)))
    {
        $oldalternatives = array();
    }

    $alternativeids = array();

    foreach ($alternatives as $altdata) {

        if ($altold = array_shift($oldalternatives)) { // Use existing one...
            $alt = $altold;
            $alt->answer = $altdata->answer;
            $alt->fraction = $altdata->fraction;
            $alt->feedback = $altdata->feedback;
            if (!update_record("quiz_answers", $alt)) {
                return false;
            }

        } else { // Completely new one
            unset($alt);
            $alt->question= $questionid;
            $alt->answer = $altdata->answer;
            $alt->fraction = $altdata->fraction;
            $alt->feedback = $altdata->feedback;
            if (!($alt->id = insert_record("quiz_answers", $alt))) {
                return false;
            }
        }

        // For the answer type numerical, each alternative has individual options:
        if ($answertype == NUMERICAL) {
            if ($numericaloptions =
                    get_record('quiz_numerical', 'answer', $alt->id))
            {
                // Reuse existing numerical options
                $numericaloptions->min = $altdata->min;
                $numericaloptions->max = $altdata->max;
                if (!update_record('quiz_numerical', $numericaloptions)) {
                    return false;
                }
            } else {
                // New numerical options
                $numericaloptions->answer = $alt->id;
                $numericaloptions->question = $questionid;
                $numericaloptions->min = $altdata->min;
                $numericaloptions->max = $altdata->max;
                if (!insert_record("quiz_numerical", $numericaloptions)) {
                    return false;
                }
            }
        } else { // Delete obsolete numerical options
            delete_records('quiz_numerical', 'answer', $alt->id);
        } // end if NUMERICAL

        $alternativeids[] = $alt->id;
    } // end foreach $alternatives
    $answers = implode(',', $alternativeids);

    // Removal of obsolete alternatives from answers and quiz_numerical:
    while ($altobsolete = array_shift($oldalternatives)) {
        delete_records("quiz_answers", "id", $altobsolete->id);

        // Possibly obsolute numerical options are also to be deleted:
        delete_records("quiz_numerical", 'answer', $altobsolete->id);
    }

    // Common alternative options and removal of obsolete options
    switch ($answertype) {
        case NUMERICAL:
            if (!empty($oldalternativeids)) {
                delete_records('quiz_shortanswer', 'answers',
$oldalternativeids);
                delete_records('quiz_multichoice', 'answers',
$oldalternativeids);
            }
            break;
        case SHORTANSWER:
            if (!empty($oldalternativeids)) {
                delete_records('quiz_multichoice', 'answers',
$oldalternativeids);
                $options = get_record('quiz_shortanswer',
                                      'answers', $oldalternativeids);
            } else {
                unset($options);
            }
            if (empty($options)) {
                // Create new shortanswer options
                $options->question = $questionid;
                $options->usecase = 0;
                $options->answers = $answers;
                if (!insert_record('quiz_shortanswer', $options)) {
                    return false;
                }
            } else if ($answers != $oldalternativeids) {
                // Shortanswer options needs update:
                $options->answers = $answers;
                if (!update_record('quiz_shortanswer', $options)) {
                    return false;
                }
            }
            break;
        case MULTICHOICE:
            if (!empty($oldalternativeids)) {
                delete_records('quiz_shortanswer', 'answers',
$oldalternativeids);
                $options = get_record('quiz_multichoice',
                                      'answers', $oldalternativeids);
            } else {
                unset($options);
            }
            if (empty($options)) {
                // Create new multichoice options
                $options->question = $questionid;
                $options->layout = 0;
                $options->single = 1;
                $options->answers = $answers;
                if (!insert_record('quiz_multichoice', $options)) {
                    return false;
                }
            } else if ($answers != $oldalternativeids) {
                // Multichoice options needs update:
                $options->answers = $answers;
                if (!update_record('quiz_multichoice', $options)) {
                    return false;
                }
            }
            break;
        default:
            return false;
    }
    return $answers;
}

function quiz_get_recent_mod_activity(&$activities, &$index, $sincetime, $courseid, $quiz="0", $user="", $groupid="") {
// Returns all quizzes since a given time.  If quiz is specified then
// this restricts the results

    global $CFG;

    if ($quiz) {
        $quizselect = " AND cm.id = '$quiz'";
    } else {
        $quizselect = "";
    }
    if ($user) {
        $userselect = " AND u.id = '$user'";
    } else {
        $userselect = "";
    }

    $quizzes = get_records_sql("SELECT qa.*, q.name, u.firstname, u.lastname, u.picture,
                                       q.course, q.sumgrades as maxgrade, cm.instance, cm.section
                                  FROM {$CFG->prefix}quiz_attempts qa,
                                       {$CFG->prefix}quiz q,
                                       {$CFG->prefix}user u,
                                       {$CFG->prefix}course_modules cm
                                 WHERE qa.timefinish > '$sincetime'
                                   AND qa.userid = u.id $userselect
                                   AND qa.quiz = q.id $quizselect
                                   AND cm.instance = q.id
                                   AND cm.course = '$courseid'
                                   AND q.course = cm.course
                                 ORDER BY qa.timefinish ASC");

    if (empty($quizzes))
      return;

    foreach ($quizzes as $quiz) {
        if (empty($groupid) || ismember($groupid, $quiz->userid)) {

          $tmpactivity->type = "quiz";
          $tmpactivity->defaultindex = $index;
          $tmpactivity->instance = $quiz->quiz;

          $tmpactivity->name = $quiz->name;
          $tmpactivity->section = $quiz->section;

          $tmpactivity->content->attemptid = $quiz->id;
          $tmpactivity->content->sumgrades = $quiz->sumgrades;
          $tmpactivity->content->maxgrade = $quiz->maxgrade;
          $tmpactivity->content->attempt = $quiz->attempt;

          $tmpactivity->user->userid = $quiz->userid;
          $tmpactivity->user->fullname = fullname($quiz);
          $tmpactivity->user->picture = $quiz->picture;

          $tmpactivity->timestamp = $quiz->timefinish;

          $activities[] = $tmpactivity;

          $index++;
        }
    }

  return;
}


function quiz_print_recent_mod_activity($activity, $course, $detail=false) {
    global $CFG, $THEME;

    echo '<table border="0" cellpadding="3" cellspacing="0">';

    echo "<tr><td bgcolor=\"$THEME->cellcontent2\" class=\"forumpostpicture\" width=\"35\" valign=\"top\">";
    print_user_picture($activity->user->userid, $course, $activity->user->picture);
    echo "</td><td width=\"100%\"><font size=2>";

    if ($detail) {
        echo "<img src=\"$CFG->modpixpath/$activity->type/icon.gif\" ".
             "height=16 width=16 alt=\"$activity->type\">  ";
        echo "<a href=\"$CFG->wwwroot/mod/quiz/view.php?id=" . $activity->instance . "\">"
             . $activity->name . "</a> - ";

    }

    if (isteacher($USER)) {
        $grades = "(" .  $activity->content->sumgrades . " / " . $activity->content->maxgrade . ") ";
        echo "<a href=\"$CFG->wwwroot/mod/quiz/review.php?q="
             . $activity->instance . "&attempt="
             . $activity->content->attemptid . "\">" . $grades . "</a> ";

        echo  get_string("attempt", "quiz") . " - " . $activity->content->attempt . "<br>";
    }
    echo "<a href=\"$CFG->wwwroot/user/view.php?id="
         . $activity->user->userid . "&course=$course\">"
         . $activity->user->fullname . "</a> ";

    echo " - " . userdate($activity->timestamp);

    echo "</font></td></tr>";
    echo "</table>";

    return;
}

    // this function creates default export filename
    function default_export_filename($course,$category) {
        //Take off some characters in the filename !!
        $takeoff = array(" ", ":", "/", "\\", "|");
        $export_word = str_replace($takeoff,"_",strtolower(get_string("exportfilename","quiz")));
        //If non-translated, use "export"
        if (substr($export_word,0,1) == "[") {
            $export_word= "export";
        }

        //Calculate the date format string
        $export_date_format = str_replace(" ","_",get_string("exportnameformat","quiz"));
        //If non-translated, use "%Y%m%d-%H%M"
        if (substr($export_date_format,0,1) == "[") {
            $export_date_format = "%%Y%%m%%d-%%H%%M";
        }

        //Calculate the shortname
        $export_shortname = clean_filename($course->shortname);
        if (empty($export_shortname) or $export_shortname == '_' ) {
            $export_shortname = $course->id;
        }

        //Calculate the category name
        $export_categoryname = clean_filename($category->name);

        //Calculate the final export filename
        //The export word
        $export_name = $export_word."-";
        //The shortname
        $export_name .= strtolower($export_shortname)."-";
        //The category name
        $export_name .= strtolower($export_categoryname)."-";
        //The date format
        $export_name .= userdate(time(),$export_date_format,99,false);
        //The extension
        $export_name .= ".txt";

        return $export_name;
    }

// function to read all questions for category into big array
// added by Howard Miller June 2004
function get_questions_category( $category ) {

    // questions will be added to an array
    $qresults = array();

    // get the list of questions for the category
    $questions = get_records("quiz_questions","category",$category->id);

    // iterate through questions, getting stuff we need
    foreach($questions as $question) {
        $new_question = get_question_data( $question );
        $qresults[] = $new_question;
    }

    return $qresults;
}

// function to read single question, parameter is object view of
// quiz_categories record, results is a combined object
// defined as follows...
// ->id     quiz_questions id
// ->category   category
// ->name   q name
// ->questiontext
// ->image
// ->qtype  see defines at the top of this file
// ->stamp  not too sure
// ->version    not sure
// ----SHORTANSWER
// ->usecase
// ->answers    array of answers
// ----TRUEFALSE
// ->trueanswer truefalse answer
// ->falseanswer truefalse answer
// ----MULTICHOICE
// ->layout
// ->single many or just one correct answer
// ->answers    array of answer objects
function get_question_data( $question ) {
    // what to do next depends of question type (qtype)
    switch ($question->qtype)  {
    case SHORTANSWER:
        $shortanswer = get_record("quiz_shortanswer","question",$question->id);
        $question->usecase = $shortanswer->usecase;
        $question->answers = array();
        break;
    case TRUEFALSE:
        if (!$truefalse = get_record("quiz_truefalse","question",$question->id)) {
            error( "quiz_truefalse record $question->id not found" );
            }
        $question->trueanswer = get_exp_answer( $truefalse->trueanswer );
        $question->falseanswer = get_exp_answer( $truefalse->falseanswer );
        break;
    case MULTICHOICE:
        if (!$multichoice = get_record("quiz_multichoice","question",$question->id)) {
        error( "quiz_multichoice $question->id not found" );
            }
        $question->layout = $multichoice->layout;
        $question->single = $multichoice->single;
        $question->answers = get_exp_answers( $multichoice->question );
        break;
    default:
        error("No handler for question type $question->qtype in get_question");
    }
    return $question;
}

// function to return single answer
// ->id     answer id
// ->question   question number
// ->answer
// ->fraction
// ->feedback
function get_exp_answer( $id ) {
    if (!$answer = get_record("quiz_answers","id",$id )) {
        error( "quiz_answers record $id not found" );
        }
    return $answer;
}

// function to return array of answers for export
function get_exp_answers( $question_num ) {
    if (!$answers = get_records("quiz_answers","question",$question_num)) {
        error( "quiz_answers question $question_num not found" );
        }
    return $answers;
}
?>