Return to grader.tcl CVS log

Up to [LON-CAPA] / capa / capa51 / GUITools

- fixed license notices the reference the GNU GPL rather than the GNU LGPL

#  GUI to changing student's grades
#  Copyright (C) 1992-2000 Michigan State University
#
#  The CAPA system is free software; you can redistribute it and/or
#  modify it under the terms of the GNU General Public License as
#  published by the Free Software Foundation; either version 2 of the
#  License, or (at your option) any later version.
#
#  The CAPA system is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
#  General Public License for more details.
#
#  You should have received a copy of the GNU General Public
#  License along with the CAPA system; see the file COPYING.  If not,
#  write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
#  Boston, MA 02111-1307, USA.
#
#  As a special exception, you have permission to link this program
#  with the TtH/TtM library and distribute executables, as long as you
#  follow the requirements of the GNU GPL in regard to all of the
#  software in the executable aside from TtH/TtM.

###########################################################
# grader.tcl - 
# Created Guy Albertelli II 1996
###########################################################
set gTclVer 2.0

###########################################################
# createControlWindow
###########################################################
# Creates the menu window 
###########################################################
# Arguments: none
# Returns: nothing
# Globals: gWindowMenu - set to the name of Menu for the windows
#                        menu
###########################################################
proc createControlWindow {} {
    global gWindowMenu gParseMode gParseModeButton gLprCommand gCapaConfig 

    after 500 { dateUpdate }
    after 1000 { cleanWindowList }

    set gCapaConfig(Printer_selected) "0"
    set gCapaConfig(lprOneSided_command) "lpr "
    set gCapaConfig(lprTwoSided_command) ""
    set gCapaConfig(printer_option) ""
    
    wm withdraw .

    set menuFrame [menu .main -tearoff 0 -type tearoff -font 8x13bold \
	    -disabledforeground grey85 ]

    wm title $menuFrame "Grader"

    $menuFrame post 0 0

    wm geometry $menuFrame "+0+20"
    $menuFrame add command -label "Grader" -foreground grey85 -background \
	    black -state disabled 
    $menuFrame add command -label "Info..." -command { createInfoWindow }
    $menuFrame add command -label "Specify Class" -command { specifyClass }
    $menuFrame add command -label "Create Class Report" -command { \
	    createSummaryWindow }
    $menuFrame add command -label "Grade Subjective" -command { gradeSubjective }

#    $menuFrame add cascade -label "File" -menu $menuFrame.file
    $menuFrame add command -label "Excuse Problem" -command { \
	    createExcuseWindow }
    $menuFrame add cascade -label "Windows" -menu $menuFrame.windows
    $menuFrame add cascade -label "Print" -menu $menuFrame.print
    $menuFrame add command -label "Remap..." -command { createRemapWindow }
    $menuFrame add command -label "Quit" -command { quit }

#    set file  [menu $menuFrame.file -tearoff 1 -font 8x13bold ]
    set windows [menu $menuFrame.windows -tearoff 1 -font 8x13bold]
    set print    [menu $menuFrame.print -tearoff 1  -font 8x13bold]
    set gWindowMenu $windows
    
    $print add command -label "Set Summary" -command { printSetSummary }
    $print add command -label "Term Summary" -command { printTermSummary }

    set gParseMode 2
    set gParseModeButton "Both, Questions Answers"    
}

###########################################################
# createInfoWindow
###########################################################
# creates the Information window
###########################################################
# Arguments: None
# Returns: Nothing
# Globals: gDate - the variable containg the current date 
#          gWindowMenu - used to register the new window in the
#                        windows menu
#          gVer - Stores the current version of Grader (set in 
#                 C init code
###########################################################
proc createInfoWindow {} {
    global gDate gWindowMenu gVer gTclVer gCmd gCompileDate

    if { [winfo exists .about] } {
	capaRaise .about
	return 
    }

    set about [toplevel .about]

    $gWindowMenu add command -label "About" -command "capaRaise $about"

    wm title $about "About" 
    
    label $about.l1 -font 12x24 -text "Grader $gVer" -pady 20
    label $about.l4 -font 8x13 -text "Grader.tcl Version $gTclVer" -pady 20
    label $about.l6  -font 8x13 -text "$gCompileDate" 
    message $about.l2 -font 8x13 -text "Code by: Y. Tsai, G. Albertelli II Copyright Michigan State University Board of Trustees, 1992-2000, CAPA is released under to GNU GPL v2, and comes WITHOUT ANY WARRENTY, see COPYING for details." \
       -pady 20 -aspect 300
    label $about.l3 -font 8x13 -textvariable gDate 
    label $about.l5  -font 8x13 -textvariable gCmd

    button $about.close -text "Close" -command "destroy $about
                                                removeWindowEntry About"
    
    pack $about.l1 $about.l4 $about.l6 $about.l2 $about.l3 $about.l5 \
	    $about.close -side top 

    Centre_Dialog $about default
}

###########################################################
# quit
###########################################################
# called when the quit option is selected on the menu, unmaps
# all keys.
###########################################################
# Arguments: None
# Returns: Nothing
# Globals: None
###########################################################
proc quit {} {
    if { [makeSure "Are you sure you wish to quit?"] == "Cancel" } {
	return 
    }
    
    if { [winfo exists .gradesubjective] } { subjDone }
    catch { rm -f [file join / tmp gkc[pid]]}
    catch { rm -f [file join / tmp g[pid]]}

    unmapAllKeys
    exit
}

###########################################################
# createExcuseWindow
###########################################################
# runs capa_excuse for a set and section, creates a window to
# get the information from, requires that the user has already
# selected a class.
###########################################################
# Arguments: None
# Returns: Nothing
# Globals: gPrompt - used to detect when to take the modal dialog away
#          gSetLoad - global var containg the current set being graded
#          gSectionLoad - global var containg the current section
#                         being graded
#          gExcuseSet - Contains the number of the set to be excused
#          gExcuseProblem - number of the problem to be excused
#          gExcuseSection - Section number to excuse the problem for
#          gExcuseWho - contains either : Section or All, and is
#                       whether to excuse an entire class or a specific
#                       section
###########################################################
proc createExcuseWindow { } {
    global gPrompt gSetLoad gSectionLoad gExcuseSet gExcuseProblem \
	    gExcuseSection gExcuseWho
    
    if {![winfo exists .grader]} {
	displayError "You must first specify a class"
	return 
    }

    if { $gSetLoad == "" } {
	set gExcuseSet 1
    } else {
	set gExcuseSet $gSetLoad
    }

    if { $gSectionLoad == "" } {
	set gExcuseSection 1
    } else {
	set gExcuseSection $gSectionLoad
    }

    set excuse [toplevel .excuse -borderwidth 10]

    set whichFrame [frame $excuse.whichFrame -borderwidth 4 -relief groove]
    set whoFrame [frame $excuse.whoFrame -borderwidth 10]
    set buttonFrame [frame $excuse.buttonFrame]
    pack $whichFrame $whoFrame $buttonFrame -side top -anchor w

    set setFrame [frame $whichFrame.setFrame]
    set problemFrame [frame $whichFrame.problemFrame]
    pack $setFrame $problemFrame -side top -anchor e

    label $setFrame.label -text Set
    entry $setFrame.entry -textvariable gExcuseSet -width 3
    pack $setFrame.label $setFrame.entry -side left

    set gExcuseProblem 1
    label $problemFrame.label -text "Problem Number"
    entry $problemFrame.entry -textvariable gExcuseProblem -width 3
    pack $problemFrame.label $problemFrame.entry -side left

    set sectionFrame [frame $whoFrame.sectionFrame]
    set allFrame [frame $whoFrame.allFrame]
    pack $sectionFrame $allFrame -side top -anchor w

    set gExcuseWho Section
    radiobutton $sectionFrame.radio -text "For students in section:" \
	    -variable gExcuseWho -value Section    
    entry $sectionFrame.entry -textvariable gExcuseSection -width 3
    pack $sectionFrame.radio $sectionFrame.entry -side left

    radiobutton $allFrame.radio -text "For all students in the class." \
	    -variable gExcuseWho -value All
    pack $allFrame.radio

    set gPrompt(result) ""
    button $buttonFrame.excuse -text Excuse -command { set gPrompt(yes) 1 } \
	    -underline 0
    button $buttonFrame.cancel -text Cancel -command { set gPrompt(yes) 0 } \
	    -underline 0
    pack $buttonFrame.excuse $buttonFrame.cancel -side left
    
    bind $excuse <Alt-Key> break
    
    Centre_Dialog $excuse default
    update
    
    focus $excuse
    raise $excuse
    capaGrab $excuse
    vwait gPrompt(yes)
    capaGrab release $excuse
    destroy $excuse
    if {$gPrompt(yes)} {
	switch $gExcuseWho {
	    All
	    {
		capaExcuse $gExcuseSet $gExcuseProblem 0
	    }
	    Section
	    {
		capaExcuse $gExcuseSet $gExcuseProblem $gExcuseSection
	    }
	}
	loadScores
    } else {
	return
    }
}    

###########################################################
# createSummaryWindow
###########################################################
# creates a dialog to craft a summary report with
###########################################################
# Arguments: None
# Returns: Nothing
# Globals: gWindowMenu - name of the window menu widget, used to
#                        register the dialog box
#          gSetLoad - current set being graded
#          gSectionLoad - current section being graded
#          gSummaryFile - filename to save report to
#          gSummary - array with fields
#              (section) - section to create the summary for
#              (set) - set to creat the summary for
#              (who) - two possible values: section (create a section
#                       summary), all (create a class summary)
#              (which) - 2 possible values: specific (summary report
#                        for a specific set), upto (summary report upto
#                        and including a specific set)
#              (first) - first field to sort by, four values:name
#                        (student name), number (student number), 
#                        section (section), grade (grade on the sets)
#              (second) - second field to sort by, same four values as
#                         above
#              (filename) - either default, grader picks it or specified,
#                           user specified a name to be found in gSummaryFile
###########################################################
proc createSummaryWindow {} {
    global gWindowMenu gSetLoad gSectionLoad gSummary gSummaryFile
    
    if { [winfo exists .summary] } {
	raise .summary
	return
    }

    if {![winfo exists .grader]} {
	displayError "You must first specify a class"
	return 
    }

    if { $gSetLoad == "" } {
	set gSummary(set) 1
    } else {
	set gSummary(set) $gSetLoad
    }

    if { $gSectionLoad == "" } {
	set gSummary(section) 1
    } else {
	set gSummary(section) $gSectionLoad
    }

    set summary [toplevel .summary]
    $gWindowMenu add command -label "Summary" -command "capaRaise $summary"

    set whoFrame [frame $summary.whoFrame -borderwidth 4 -relief groove]
    set whichFrame [frame $summary.whichFrame -borderwidth 4 -relief groove]
    set sortFrame [frame $summary.sortFrame]
    set file2Frame [frame $summary.file2Frame]
    set buttonFrame [frame $summary.buttonFrame]
    pack $whoFrame $whichFrame $sortFrame $file2Frame $buttonFrame -side top
    pack configure $whoFrame $whichFrame -padx 10 -pady 10

    set sectionFrame [frame $whoFrame.section]
    set allFrame [frame $whoFrame.all]
    pack $sectionFrame $allFrame -side top

    set gSummary(who) section

    radiobutton $sectionFrame.section -text \
	    "For students in default section:" -variable gSummary(who) \
	    -value section 
    entry $sectionFrame.entry -textvariable gSummary(section) -width 3 
    pack $sectionFrame.section $sectionFrame.entry -side left

    radiobutton $allFrame.all -text "For all students in the class" \
	    -variable gSummary(who) -value all 
    pack $allFrame.all

    set sectionFrame [frame $whichFrame.section]
    set allFrame [frame $whichFrame.all]
    pack $sectionFrame $allFrame -side top

    set gSummary(which) specific

    radiobutton $sectionFrame.section -text "For set:" \
	    -variable gSummary(which) -value specific 
    entry $sectionFrame.entry -textvariable gSummary(set) -width 3 
    pack $sectionFrame.section $sectionFrame.entry -side left

    radiobutton $allFrame.all -text "For all sets up to:" -variable \
	    gSummary(which) -value upto 
    entry $allFrame.entry -textvariable gSummary(set) -width 3 
    pack $allFrame.all $allFrame.entry -side left

    set firstFrame [frame $sortFrame.firstFrame -borderwidth 4 -relief groove]
    set secondFrame [frame $sortFrame.secondFrame -borderwidth 4 \
	    -relief groove]
    pack $firstFrame $secondFrame -side left

    set gSummary(first) name

    label $firstFrame.label -text "Sorting Order - Primary"
    radiobutton $firstFrame.name -text "Student Name" -variable \
	    gSummary(first) -value name
    radiobutton $firstFrame.number -text "Student Number" -variable \
	    gSummary(first) -value number
    radiobutton $firstFrame.section -text "Section" -variable \
	    gSummary(first) -value section
    radiobutton $firstFrame.grade -text "Grade" -variable gSummary(first) \
	    -value grade
    pack $firstFrame.label $firstFrame.name $firstFrame.number \
	    $firstFrame.section $firstFrame.grade -side top -anchor w

    set gSummary(second) number

    label $secondFrame.label -text "Sorting Order - Secondary"
    radiobutton $secondFrame.name -text "Student Name" -variable \
	    gSummary(second) -value name
    radiobutton $secondFrame.number -text "Student Number" -variable \
	    gSummary(second) -value number
    radiobutton $secondFrame.section -text "Section" -variable \
	    gSummary(second) -value section
    radiobutton $secondFrame.grade -text "Grade" -variable gSummary(second) \
	    -value grade
    pack $secondFrame.label $secondFrame.name $secondFrame.number \
	    $secondFrame.section $secondFrame.grade -side top -anchor w

    set defaultFrame [frame $file2Frame.defaultFrame]
    set fileFrame [frame $file2Frame.fileFrame]
    pack $defaultFrame $fileFrame -side top

    if {[catch {set gSummary(filename)}]} { set gSummary(filename) default }

    radiobutton $defaultFrame.default -text "Grader Chooses File Name" \
	-variable gSummary(filename) -value default
    pack $defaultFrame.default

    radiobutton $fileFrame.label -text "Specified Output File:" \
	-variable gSummary(filename) -value specified
    set entryFrame [frame $fileFrame.entryFrame]
    button $fileFrame.select -text "Select File" \
	    -command "selectOutputFile"
    pack $fileFrame.label $entryFrame $fileFrame.select -side left
    entry $entryFrame.entry -textvariable gSummaryFile \
	-xscrollcommand "$entryFrame.scroll set"
    scrollbar $entryFrame.scroll -orient h -command \
	    "$entryFrame.entry xview"
    pack $entryFrame.entry $entryFrame.scroll
    pack configure $entryFrame.scroll -fill x

    button $buttonFrame.create -text "Create" -command \
	    "removeWindowEntry Summary
             destroy $summary
             createSummaryReport"
    button $buttonFrame.cancel -text "Cancel" -command \
	    "removeWindowEntry Summary
             destroy $summary"
    pack $buttonFrame.create $buttonFrame.cancel -side left

    Centre_Dialog $summary default
}

###########################################################
# selectOutputFile
###########################################################
###########################################################
###########################################################
proc selectOutputFile {} {
    global gSummaryFile gSummary
    set gSummary(filename) specified
    if { "" != [ set temp [tk_getSaveFile] ] } {set gSummaryFile $temp}
}    

###########################################################
# createSummaryReport
###########################################################
# creates the summary report
###########################################################
# Argumnets: None
# Returns: Nothing
# Globals: gSummary - the report generation information is in here
#          gClassDir - the directory the class is in
# Files: gClassDir/ClassSet.rpt - summary report created if for the
#                                 entire class (created)
#       gClassDir/SecSet.rpt - summarry report created if for only a
#                              section (created)
###########################################################
proc createSummaryReport {} {
    global gSummary gClassDir gUniqueNumber gSummaryFile

    displayStatus "Opening File" both

    switch $gSummary(who) {
	all
	{
	    set file [file join $gClassDir ClassSet$gSummary(set).rpt ]
	}
	section
	{
	    set file [file join $gClassDir \
		    Sec$gSummary(section)Set$gSummary(set).rpt ]
	}
	default
	{
	    displayError "An error has occurred while creating a summary \
		    report $gSummary(section)"
	    return
	}
    }

    if { $gSummary(filename) == "specified" } { set file $gSummaryFile }
    if { $file == "" } { 
	removeStatus
	displayError "Must specify a valid filename"
	return
    }
    updateStatusMessage "Creating Summary"

    set error [ catch {createSummary $file} ]

    removeStatus

    if {!$error && "Yes" == [makeSure "Created summary file $file, would you like to see it?"]} {
	set fileId [open $file r]
	set num [incr gUniqueNumber] 
	set num2 [incr gUniqueNumber] 
	winputs $num [read $fileId]
	winoutput $num2 $num {}
    }
}

###########################################################
# specifyClass
###########################################################
# runs tk_getOpenFile and creates the class window if a directory is chosen
###########################################################
# Arguments: None
# Returns: Nothing
# Globals: gClassDir - remembers the directory the class is in
###########################################################
proc specifyClass {} {
    global gClassDir

    if { [winfo exists .grader] } { return }
    set var [tk_getOpenFile -title "Please select a capa.config file" -filetypes \
		 { { {Capa Config} {capa.config} } }]

    if { $var != "" } {
	set gClassDir [file dirname $var]
	cd $gClassDir
    } else {
	return
    }
    
    createClassWindow
}

###########################################################
# changeClass
###########################################################
# called when the change class button is pressed, if another class
# is chosen the class window is updated
###########################################################
# Arguments: None
# Returns: Nothing
# Globals: gClassDir - remembers the directory the class is in
#          gClass - just the name of the directory, and therefore 
#                   the class
#          gLoaded - reset to zero since we are unloading the class
###########################################################
proc changeClass {} {
    global gClassDir gClass gLoaded

    set var [tk_getOpenFile -title "Please select a capa.config file" -filetypes \
		 { { {Capa Config} {capa.config} } }]    

    if { $var != "" } {
	removeWindowEntry $gClassDir
	set gClassDir [file dirname $var]
	cd $gClassDir
	set gClass  [file tail $gClassDir]
    } else {
	return
    }
    
    set gLoaded 0
    clearClassWindow
    parseCapaConfig
}

###########################################################
# createClassWindow
###########################################################
# creates the rather complicated class window
###########################################################
# Arguments: None
# Returns: Nothing
# Globals: gClassDir - remembers the directory the class is in
#          gWindowMenu - the name of the window menu widget
#          gOpenDate - the label linked var the date the set opens is in
#          gOpenTime - the label linked var the time the set opens is in
#          gDueDate - the label linked var the due date for the set is in
#          gDueTime - the label linked var the due time for the set is in
#          gAnswerDate - the label linked var the date the set answer
#                        open date is in
#          gAnswerTime - the label linked var the time the set answer
#                        open time is in
#          gSectionLoad - the current section being graded
#          gSetLoad - the current set being graded
#          gFindNumber - linked var that stores the string to search
#                        through student numbers for
#          gFindName - linked var that stores the string to search
#                      through student names for
#          gButtonFrame - stores the widget name of the button frame, so 
#                         the buttons' state can be changed elsewhere
#          gNameFrame - stores the widget name of the name entry frame, so 
#                       the entry widget's state can be changed elsewhere
#          gNumberFrame - stores the widget name of the number entry 
#                         frame, so the entry widget' state can be 
#                         changed elsewhere
#          gStudentList - the widget name of the listbox containing the 
#                         list of students
#          gClass - the name of the class currently being graded
#          gLoaded - keeps track of whether a class has been loaded yet
#                    set to zero here
###########################################################
proc createClassWindow {} {
    global gClassDir gWindowMenu gOpenDate gOpenTime gDueDate gDueTime \
	    gAnswerDate gAnswerTime gSectionLoad gSetLoad gFindNumber \
	    gFindName gButtonFrame gNameFrame gNumberFrame gStudentList \
	    gClass gLoaded

    set gLoaded 0
    
    set grader [toplevel .grader]
    $gWindowMenu add command -label "$gClassDir" -command "capaRaise $grader"

    set labelFrame [frame $grader.labelFrame]
    set dataFrame [frame $grader.dataFrame]
    set columnFrame [frame $grader.columnFrame]
    set infoFrame [frame $grader.infoFrame]
    pack $labelFrame $dataFrame $columnFrame $infoFrame -side top -anchor w
    pack configure $infoFrame -expand 1 -fill both

    set gClass [file tail $gClassDir] 
    label $labelFrame.label -background black -foreground grey85 \
	    -textvariable gClass -width 51
    button $labelFrame.button -text "Change Class" -command { changeClass }
    pack $labelFrame.label $labelFrame.button -side left

    set dateFrame [frame $dataFrame.date -relief sunken -borderwidth 2]
    set actionsFrame [frame $dataFrame.actions ]
    pack $dateFrame $actionsFrame -side left

    set openDateFrame [frame $dateFrame.openDate]
    set openTimeFrame [frame $dateFrame.openTime]
    set dueDateFrame [frame $dateFrame.dueDate]
    set dueTimeFrame [frame $dateFrame.dueTime]
    set answerDateFrame [frame $dateFrame.answerDate]
    set answerTimeFrame [frame $dateFrame.answerTime]
    pack $openDateFrame $openTimeFrame $dueDateFrame $dueTimeFrame \
	    $answerDateFrame $answerTimeFrame -side top

    label $openDateFrame.text -text "Open Date:" -width 13
    label $openDateFrame.date -textvariable gOpenDate -width 10 -relief sunken \
	    -background white 
    pack $openDateFrame.text $openDateFrame.date -side left

    label $openTimeFrame.text -text "Open Time:" -width 13
    label $openTimeFrame.time -textvariable gOpenTime -width 10 -relief sunken \
	    -background white 
    pack $openTimeFrame.text $openTimeFrame.time -side left

    label $dueDateFrame.text -text "Due Date:" -width 13
    label $dueDateFrame.date -textvariable gDueDate -width 10 -relief sunken \
	    -background white 
    pack $dueDateFrame.text $dueDateFrame.date -side left

    label $dueTimeFrame.text -text "Due Time:" -width 13
    label $dueTimeFrame.time -textvariable gDueTime -width 10 -relief sunken \
	    -background white 
    pack $dueTimeFrame.text $dueTimeFrame.time -side left

    label $answerDateFrame.text -text "Answer Date:" -width 13
    label $answerDateFrame.date -textvariable gAnswerDate -width 10 -relief \
	    sunken -background white 
    pack $answerDateFrame.text $answerDateFrame.date -side left

    label $answerTimeFrame.text -text "Answer Time:" -width 13
    label $answerTimeFrame.time -textvariable gAnswerTime -width 10 -relief \
	    sunken -background white 
    pack $answerTimeFrame.text $answerTimeFrame.time -side left

    set loadFrame [frame $actionsFrame.load]
    set findFrame [frame $actionsFrame.find]
    set buttonFrame [frame $actionsFrame.buttons]
    set gButtonFrame $buttonFrame
    pack $loadFrame $findFrame $buttonFrame -side top
    pack configure $loadFrame -anchor e

    set sectionFrame [frame $loadFrame.section]
    set setFrame [frame $loadFrame.set]
    pack $sectionFrame $setFrame -side top -anchor w

    label $sectionFrame.label -text "    Section:"
    entry $sectionFrame.entry -textvariable gSectionLoad -width 3
    pack $sectionFrame.label $sectionFrame.entry -side left

    label $setFrame.label -text     "Problem Set:"
    entry $setFrame.entry -textvariable gSetLoad -width 3
    bind $setFrame.entry <KeyPress-Return> loadScores
    button $setFrame.button -text "Load Scores" -command loadScores
    pack $setFrame.label $setFrame.entry $setFrame.button -side left
    
    set nameFrame [frame $findFrame.name]
    set gNameFrame $nameFrame
    set numberFrame [frame $findFrame.number]
    set gNumberFrame $numberFrame
    pack $nameFrame $numberFrame -side top

    entry $nameFrame.name -textvariable gFindName
    button $nameFrame.button -text   "Find By Name         " -command findByName
    bind $nameFrame.name <KeyPress-Return> findByName
    pack $nameFrame.name $nameFrame.button -side left

    entry $numberFrame.name -textvariable gFindNumber
    button $numberFrame.button -text "Find By StudentNumber" -command findByNumber
    bind $numberFrame.name <KeyPress-Return> findByNumber
    pack $numberFrame.name $numberFrame.button -side left

    button $buttonFrame.report -text "Student Report" -command studentReport \
	    -state disabled
    button $buttonFrame.grading -text "Grading" -command createGradingWindow \
	    -state disabled
    pack $buttonFrame.report $buttonFrame.grading  -side left

    label $columnFrame.space -text "  "
    label $columnFrame.name -text "Student Name" -width 30
    label $columnFrame.number -text "Number" -width 11
    message $columnFrame.score -text "Current Set Score" -aspect 250
    message $columnFrame.pin -text "Current Pin" -aspect 200
    pack $columnFrame.space $columnFrame.name $columnFrame.number \
	    $columnFrame.score $columnFrame.pin -side left

    scrollbar $infoFrame.scroll -orient vertical -command \
	    "$infoFrame.listbox yview"
    set gStudentList [listbox $infoFrame.listbox -yscrollcommand \
	    "$infoFrame.scroll set" -height 30]
    pack $infoFrame.scroll $infoFrame.listbox -side left
    pack configure $infoFrame.scroll -expand false -fill y
    pack configure $infoFrame.listbox -expand true -fill both

    Centre_Dialog $grader default
    parseCapaConfig
}

###########################################################
# clearClassWindow
###########################################################
# empties the class window of all data
###########################################################
# Arguments: none
# Returns: Nothing
# Globals: gClassDir - remembers the directory the class is in
#          gWindowMenu - the name of the window menu widget
#          gOpenDate - the label linked var the date the set opens is in
#          gOpenTime - the label linked var the time the set opens is in
#          gDueDate - the label linked var the due date for the set is in
#          gDueTime - the label linked var the due time for the set is in
#          gAnswerDate - the label linked var the date the set answer
#                        open date is in
#          gAnswerTime - the label linked var the time the set answer
#                        open time is in
#          gSectionLoad - the current section being graded
#          gSetLoad - the current set being graded
#          gStudentList - the widget name of the listbox containing the 
#                         list of students
#          gClass - the name of the class currently being graded
###########################################################
proc clearClassWindow {} {
    global gWindowMenu gOpenDate gOpenTime gDueDate gDueTime gAnswerDate \
	    gAnswerTime gStudentList gSectionLoad gSetLoad gClassDir

    $gWindowMenu add command -label "$gClassDir" -command "capaRaise .grader"

    set gOpenDate ""
    set gOpenTime ""
    set gDueDate ""
    set gDueTime ""
    set gAnswerDate ""
    set gAnswerTime ""
    set gSectionLoad ""
    set gSetLoad ""

    $gStudentList delete 0 end
}

###########################################################
# loadScores
###########################################################
# load in a new set of scores
###########################################################
# Arguments: None
# Returns: Nothing
# Globals: gSectionLoad - the current section being graded
#          gSetLoad - the current set being graded
#          gButtonFrame - stores the widget name of the button frame, so 
#                         the buttons' state can be changed elsewhere
#          gNameFrame - stores the widget name of the name entry frame, so 
#                       the entry widget's state can be changed elsewhere
#          gNumberFrame - stores the widget name of the number entry 
#                         frame, so the entry widget' state can be 
#                         changed elsewhere
#          gStudentList - the widget name of the listbox containing the 
#                         list of students
#          gLoaded - 1 if a section has been loaded
###########################################################
proc loadScores {} {
    global gNumberFrame gNameFrame gButtonFrame gSectionLoad gSetLoad \
	    gStudentList gLoaded

    $gStudentList delete 0 end

    if { $gSectionLoad == "" } {
	displayError "The Section field must be completed before \
		continuing."
	return
    } elseif { $gSetLoad == "" } {
	displayError "The Set field must be completed before \
		continuing."
	return
    }    

    set result [getHeader]
    switch -- $result {
	0 { displayError "The Set and Section selected do not appear to exist"; return }
	-1 { #displayMessage "No date information is available for this set" }
	1 { #break } 
    }

    $gButtonFrame.report configure -state normal
    $gButtonFrame.grading configure -state normal

##    $gButtonFrame.log configure -state normal

    getStudents gStudentList

    set gLoaded 1
}

###########################################################
# findByName
###########################################################
# preforms a search for a student by name, findSection returns
# the section the student is in, then the correct element in the
# Student ListBox is highlighted.
###########################################################
# Arguments: None
# Returns: Nothing
# Globals: gSectionLoad - the current section being graded
#          gFindName - linked var that stores the string to search
#                      through student names for
#          gStudentList - the widget name of the listbox containing the 
#                         list of students
#          gLoaded - keeps track of whther scores have been loaded yet
###########################################################
proc findByName {} {
    global gFindName gFindNumber gStudentList gSectionLoad gLoaded

    fillInStudent gFindName gFindNumber 1
    if { $gFindNumber == "" } { return }
    set section [findSection name $gFindName]

    if { $section == "0" } { 
	displayError "Name not found in classl file"
	return 
    }

    if { !(($gSectionLoad == $section) && $gLoaded) } {
	set gSectionLoad $section
	loadScores
    }

    set size [$gStudentList size]
    set search [string tolower $gFindName]
    while { $size != 0 } {
	incr size -1
	set tempString [string tolower [$gStudentList get $size]]
	switch -- [string first $search $tempString] {
	    0
	    { 
		$gStudentList selection set $size 
		$gStudentList activate $size 
		$gStudentList see $size
	    }
	}
    }
}

###########################################################
# studentReport
###########################################################
# creates a window containg a report for the current student
###########################################################
# Arguments: None
# Returns: Nothing
# Globals: gSectionLoad - the current section being graded
#          gStudentList - the widget name of the listbox containing the 
#                         list of students
#          gWindoMenu - the name of the window menu widget
###########################################################
proc studentReport {} {
    global gStudentList gSectionLoad gWindowMenu

    set string [$gStudentList get active]

    set studentNumber [string range $string 31 39]
    
    set text [getReportInfo $studentNumber]

    if {![winfo exists .a$studentNumber]} {
	set report [toplevel .a$studentNumber]
	$gWindowMenu add command -label "$studentNumber" -command \
		"capaRaise $report"	
	set labelFrame [frame $report.labelFrame]
	set textFrame [frame $report.textFrame]
	set buttonFrame [frame $report.buttonFrame]
	pack $buttonFrame $labelFrame $textFrame -side top
	pack configure $buttonFrame -anchor e

	label $labelFrame.namel -text "Student Name: "
	label $labelFrame.namet -text [string range $string 0 30]
	label $labelFrame.numberl -text "Number: "
	label $labelFrame.numbert -text [string range $string 31 39]
	label $labelFrame.sectionl -text "Section: "
	label $labelFrame.sectiont -text $gSectionLoad
	pack $labelFrame.namel $labelFrame.namet $labelFrame.numberl \
		$labelFrame.numbert $labelFrame.sectionl $labelFrame.sectiont \
		-side left
	
	scrollbar $textFrame.scrollbar -orient vertical -command \
		"$textFrame.text yview"
	text $textFrame.text -yscrollcommand "$textFrame.scrollbar set" \
		-height 30 -width 80
	pack $textFrame.scrollbar $textFrame.text -side left
	pack configure $textFrame.scrollbar -expand false -fill y
	pack configure $textFrame.text -expand true -fill both
	
	button $buttonFrame.close -text "Close" -command \
		"destroy $report
	         removeWindowEntry $studentNumber"
	pack $buttonFrame.close
	Centre_Dialog $report default
    } else {
	.a$studentNumber.textFrame.text delete 0.0 end 
    }

    .a$studentNumber.textFrame.text insert end $text
    .a$studentNumber.textFrame.text configure -state disabled
    
}

###########################################################
# findByNumber
###########################################################
# finds a student based on a complete student number, once again
# findSection finds the correct section and then it searches through the
# list box looking for the correct student
###########################################################
# Arguments: None
# Returns: Nothing
# Globals: gSectionLoad - the current section being graded
#          gFindNumber - linked var that stores the string to search
#                        through student numbers for
#          gStudentList - the widget name of the listbox containing the 
#                         list of students
#          gLoaded - whether or not the data for the set/section has
#                    actually been loaded
###########################################################
proc findByNumber {} {
    global gFindName gFindNumber gStudentList gSectionLoad gLoaded

    fillInStudent gFindName gFindNumber 0
    if { $gFindNumber == "" } { return }
    set section [findSection number $gFindNumber]

    if { $section == "0" } { 
	displayError "Name not found in classl file"
	return 
    }

    if { ! (($gSectionLoad == $section ) && $gLoaded) } {
	set gSectionLoad $section
	loadScores
    }

    set size [$gStudentList size]
    set search [string tolower $gFindNumber]
    while { $size != 0 } {
	incr size -1
	set tempString [string range [string tolower \
		[$gStudentList get $size]] 31 39]
	switch -- [string first $search $tempString] {
	    0
	    { 
		$gStudentList selection set $size 
		$gStudentList activate $size 
		$gStudentList see $size
	    }
	}
    }
}

###########################################################
# printBody
###########################################################
# sends the file quiztemp.ps to the printer through lpr using
# the option foud in gLprCommand
###########################################################
# Arguments: none
# Returns: Nothing
# Files: /tmp/g[pid] - file containg info to print (removed)
###########################################################
proc printBody { lprCommand } {

    set errorMsg ""
    
    set error [catch {set returnMessage [eval "exec $lprCommand"] } errorMsg ]
    
    exec /bin/rm -f /tmp/g[pid]

    if { $error == 1 } {
        displayError "When attempting to print an error occurred : $errorMsg"
	return 1
    } else {
	displayMessage "Print job sent to the printer.\n $returnMessage"
    }
    
    return 0
}

###########################################################
# printSetSummary
###########################################################
# prints a set summary for the currently grading set and section
###########################################################
# Arguments: None
# Returns: Nothing
# Globals: gSetLoad - currently being graded set
#          gWindowMenu - the widget name of the window menu
#          gSectionLoad - currently being graded section
# Files: /tmp/g[pid] - file containg info to print (created)
###########################################################
proc printSetSummary {} {
    global gSetLoad gWindowMenu gSectionLoad 

    if { $gSetLoad == "" } { 
	displayError "Please enter a Set number."
	return
    }

    if { $gSectionLoad == "" } { 
	displayError "Please enter a Section number."
	return
    }

    set lprCommand [getLprCommand [file join / tmp g[pid] ] ]
    if { $lprCommand == "" } {
	displayError "Print command was empty, unable to print."
	return 1
    }
    if {$lprCommand == "Cancel" } {
	return 1
    }

    getSetSummary [file join / tmp g[pid]]

    printBody  $lprCommand
}

###########################################################
# printTermSummary
###########################################################
# creates a termsummary file and send it to the printer
###########################################################
# Arguments: None
# Returns: Nothing
# Globals: gSetLoad - currently being graded set
#          gWindowMenu - the widget name of the window menu
#          gSectionLoad - currently being graded section
# Files: /tmp/g[pid] - file containg info to print (created)
###########################################################
proc printTermSummary {} {
    global gSetLoad gWindowMenu gSectionLoad 

    if { $gSetLoad == "" } { 
	displayError "Please enter a Set number."
	return
    }

    if { $gSectionLoad == "" } { 
	displayError "Please enter a Section number."
	return
    }

    set lprCommand [getLprCommand [file join / tmp g[pid] ] ]
    if { $lprCommand == "" } {
	displayError "Print command was empty, unable to print."
	return 1
    }
    if {$lprCommand == "Cancel" } {
	return 1
    }

    displayStatus "Getting Term Summary" bar

    getTermSummary [file join / tmp g[pid] ]

    removeStatus 

    printBody $lprCommand
}

###########################################################
# createGradingWindow
###########################################################
# create the window in which the user can change the grades in
###########################################################
# Arguments: None
# Returns: Nothing
# Globals: gStudentList - the widget name of the list box the list
#                         of students is in.
#          gSectionLoad - currently being graded section
#          gWindowMenu - widget name of the window menu
#          gProblemText - stores the results of the parse of the set
#          gParseMode - stores either 1 (Both, Questions Answers) or
#                       2 (Answer Only)
#          gSetLoad - currently being graded set
#          gGrading - an array containg
#               (name) - Name of the student
#               (number) - student number 
#          gGradeCanvas - widget name of the canvas used to contain all
#                         of the radiobuttons when grading
#          gAnswer - an array containg the score for the student
#                ($i) - i contains the current problem number and the entry
#                       has one of Y, N, E, or -
#                (max$i) - i is the problem number, these entries exist only
#                          for handgraded questions, and is the maximum
#                          score for that question
#          gQuestionType - stores whether a quetion is handgraded or not
#                ($i) - i contains the current problem number and the entry
#                       has one of handGrade, or autoGrade
#          gParseModeButton - the text that will be displayed on
#                             the button that switches parse modes, 
#                             either "Answer Only" or 
#                             "Both, Questions Answers"
###########################################################
proc createGradingWindow {} {
    global gStudentList gSectionLoad gWindowMenu gProblemText gParseMode \
	    gSetLoad gGrading gGradeCanvas gAnswer gQuestionType \
	    gParseModeButton

    if { [winfo exists .grading] } { 
	capaRaise .grading
	return 
    }
    catch {unset gAnswer}
    set grading [toplevel .grading]
    $gWindowMenu add command -label "Grading" -command "capaRaise $grading"

    set labelFrame [frame $grading.labelFrame]
    set buttonFrame [frame $grading.buttonFrame]
    set winFrame [frame $grading.winFrame]
    pack $labelFrame $buttonFrame $winFrame -side top
    pack configure $buttonFrame -anchor e

    set string [$gStudentList get active]
    set gGrading(name) [string range $string 0 30]
    set gGrading(number) [string range $string 31 39]
    set gGrading(parsenum) $gGrading(number)
    label $labelFrame.namel -text "Student Name: "
    label $labelFrame.namet -text $gGrading(name)
    label $labelFrame.numberl -text "Number: "
    entry $labelFrame.numbert -width 9 -textvariable gGrading(parsenum)
    button $labelFrame.reparse -text "Parse" -command "updateGradingWindow 0"
    label $labelFrame.sectionl -text "Section: "
    label $labelFrame.sectiont -text $gSectionLoad
    pack $labelFrame.namel $labelFrame.namet $labelFrame.numberl \
	$labelFrame.numbert $labelFrame.reparse $labelFrame.sectionl \
	$labelFrame.sectiont -side left

    button $buttonFrame.button -textvariable gParseModeButton \
	    -command updateGradingWindow
    button $buttonFrame.save -text SAVE 
    button $buttonFrame.close -text Close -command "removeWindowEntry Grading
                                                   destroy $grading"
    pack $buttonFrame.button $buttonFrame.save $buttonFrame.close \
	    -side left

    set assignmentFrame [frame $winFrame.assignmentFrame]
    set gradingFrame [frame $winFrame.gradingFrame]
    pack $gradingFrame $assignmentFrame -side left

    scrollbar $assignmentFrame.scroll -orient vertical -command \
	    "$assignmentFrame.text yview"
    set gProblemText [text $assignmentFrame.text -yscrollcommand \
	    "$assignmentFrame.scroll set" -height 44 -width 80]
    pack $assignmentFrame.scroll $assignmentFrame.text -side left
    pack configure $assignmentFrame.scroll -expand false -fill y
    pack configure $assignmentFrame.text -expand true -fill both

    set numQuestions [enscriptParse $gParseMode $gSetLoad Specific 0 \
	    $gGrading(parsenum) $gGrading(name) gProblemText]
    
    $buttonFrame.save configure -command " saveGrading $numQuestions $grading "
    set setAllFrame [frame $gradingFrame.setallFrame ]
    set gradeFrame [frame $gradingFrame.gradeFrame ]
    pack $gradingFrame.setallFrame  $gradeFrame -side top

    frame $setAllFrame.space0 -width 55
    button $setAllFrame.dash -text "-" -padx -1 \
	    -command "gradeSetAll - $numQuestions"
    frame $setAllFrame.space1 -width 8
    button $setAllFrame.y -text "y" -padx -1 \
	    -command "gradeSetAll y $numQuestions"
    frame $setAllFrame.space2 -width 8
    button $setAllFrame.n -text "n" -padx -1 \
	    -command "gradeSetAll n $numQuestions"
    frame $setAllFrame.space3 -width 8
    button $setAllFrame.e -text "E" -padx -1 \
	    -command "gradeSetAll E $numQuestions"
    frame $setAllFrame.space4 -width 8
    label $setAllFrame.state -text "stat"
    label $setAllFrame.tries -text "tries"
    pack $setAllFrame.space0 $setAllFrame.dash \
	    $setAllFrame.space1 $setAllFrame.y \
	    $setAllFrame.space2 $setAllFrame.n \
	    $setAllFrame.space3 $setAllFrame.e \
	    $setAllFrame.space4 $setAllFrame.state \
	    $setAllFrame.tries -side left

    scrollbar $gradeFrame.scroll -orient vertical -command \
	    "$gradeFrame.canvas yview"
    set gGradeCanvas [canvas $gradeFrame.canvas -yscrollcommand \
	    "$gradeFrame.scroll set" -height 600 -width 200]
    pack $gradeFrame.scroll $gGradeCanvas -side left
    pack configure $gradeFrame.scroll -expand false -fill y
    pack configure $gGradeCanvas -expand true -fill both

    Centre_Dialog $grading default

    catch {unset gAnswer}
    catch {unset gQuestionType}

    getQuestionTypes $numQuestions 

    set vSize 26
    set offset 9
    set todo ""
    for { set i 1 } { $i <= $numQuestions } { incr i } {
	label $gGradeCanvas.prob$i -text "$i"
	$gGradeCanvas create window 10 [expr $offset + $vSize * ($i-1)] \
	    -window $gGradeCanvas.prob$i
	switch $gQuestionType($i) {
	    autoGrade
	    {
		radiobutton $gGradeCanvas.dash$i -variable gAnswer($i) \
			-value -
		$gGradeCanvas create window 40 [expr $offset+ $vSize * ($i-1)] -window \
			$gGradeCanvas.dash$i
		radiobutton $gGradeCanvas.y$i -variable gAnswer($i) -value y
		$gGradeCanvas create window 64 [expr $offset+ $vSize * ($i-1)] -window \
			$gGradeCanvas.y$i
		radiobutton $gGradeCanvas.n$i -variable gAnswer($i) -value n
		$gGradeCanvas create window 88 [expr $offset+ $vSize * ($i-1)] -window \
			$gGradeCanvas.n$i
		radiobutton $gGradeCanvas.e$i -variable gAnswer($i) -value E
		$gGradeCanvas create window 112 [expr $offset+ $vSize * ($i-1)] -window \
			$gGradeCanvas.e$i
		label $gGradeCanvas.state$i -textvariable gAnswer($i)
		$gGradeCanvas create window 136 [expr $offset+ $vSize * ($i-1)] -window \
			$gGradeCanvas.state$i
	    }
	    handGrade
	    {	
		radiobutton $gGradeCanvas.e$i -variable gAnswer($i) -value E
		$gGradeCanvas create window 112 [expr $offset+ $vSize * ($i-1)] -window \
			$gGradeCanvas.e$i
		scale $gGradeCanvas.hand$i -from 0 -to $gAnswer(max$i) -orient h \
		    -variable gAnswer(hand$i) -showvalue 0 -length 80
		$gGradeCanvas create window 60 [expr $offset+ $vSize * ($i-1)] -window \
			$gGradeCanvas.hand$i
		label $gGradeCanvas.current$i -textvariable gAnswer($i)
		$gGradeCanvas create window 136 [expr $offset+ $vSize * ($i-1)] -window \
			$gGradeCanvas.current$i
#		label $gGradeCanvas.max$i -textvariable gAnswer(max$i)
#		$gGradeCanvas create window 112 [expr $offset+ $vSize * ($i-1)] -window \
		    $gGradeCanvas.max$i
		trace variable gAnswer(hand$i) w handGradeExcuse
		lappend todo $i
	    }
	}
	entry $gGradeCanvas.tries$i -textvariable gAnswer($i.tries) -width 2
	$gGradeCanvas create window 170 [expr $offset+ $vSize * ($i - 1)] \
	    -window $gGradeCanvas.tries$i
    }
    $gGradeCanvas configure -scrollregion "0 0 150 \
                  [ expr ( $vSize * $numQuestions ) + $vSize ]"
    setupGAnswer $numQuestions

    foreach item $todo {
	if { $gAnswer($item) != "E" && $gAnswer($item) != "-" } { 
	    set gAnswer(hand$item) $gAnswer($item) 
	}
    }
}

###########################################################
# handGradeExcuse
###########################################################
###########################################################
###########################################################
proc handGradeExcuse { name1 name2 op } {
    global gAnswer
    scan $name2 "hand%d" num
    if { $gAnswer($name2) != "E" && $gAnswer($name2) != "-" } { 
	set gAnswer($num) $gAnswer($name2) 
    }
}
###########################################################
# gradeSetAll
###########################################################
###########################################################
###########################################################
proc gradeSetAll { type numQuestions } {
    global gAnswer gQuestionType
    
    for { set i 1 } { $i <= $numQuestions } { incr i } {
	switch $gQuestionType($i) {
	    autoGrade
	    {
		if { $gAnswer($i) != "Y" } { set gAnswer($i) $type }
	    }
	    handGrade
	    {
		switch -- $type {
		    y
		    { set gAnswer($i) $gAnswer(max$i) }
		    n
		    { set gAnswer($i) "0" }
		    E
		    -
		    -
		    { set gAnswer($i) $type }
		}
	    }
	}
    }
}

###########################################################
# saveGrading
###########################################################
# saves all changes, and updates the main window
###########################################################
# Arguments: the number of questions, and the name of the grading 
#            window
# Returns: None
# Globals: None
###########################################################
proc saveGrading { numQuestions grading } {
    if { [makeSure "You have pressed the SAVE button, Please confirm."] != \
	    "Cancel" } {
	saveGAnswer $numQuestions
	removeWindowEntry Grading
	destroy $grading
	loadScores
    }
}

###########################################################
# updateGradingWindow
###########################################################
# reparses the file and updates the parsemode button
###########################################################
# Arguments: None
# Returns: Nothing
# Globals: gProblemText - stores the results of the parse of the set
#          gParseMode - stores either 1 (Both, Questions Answers) or
#                       2 (Answer Only)
#          gSetLoad - currently being graded set
#          gGrading - an array containg
#               (name) - Name of the student
#               (number) - student number 
#          gParseModeButton - the text that will be displayed on
#                             the button that switches parse modes, 
#                             either "Answer Only" or 
#                             "Both, Questions Answers"
###########################################################
proc updateGradingWindow { { changeMode 1 } } {
    global gParseMode gSetLoad gGrading gProblemText gParseModeButton

    $gProblemText delete 0.0 end

    displayStatus "Updating Window . . ." message

    if { $changeMode } {
	switch $gParseMode {
	    1 { 
		set gParseModeButton "Both, Questions Answers" 
		set gParseMode 2
	    }
	    2 { 
		set gParseModeButton "Answer Only" 
		set gParseMode 1
	    }
	}
    }
    enscriptParse $gParseMode $gSetLoad Specific 0 $gGrading(parsenum) \
	    $gGrading(name) gProblemText
    removeStatus
}

###########################################################
# handGrade
###########################################################
# creates a dialog to get the new score for a problem from the
# user for a hand graded question
###########################################################
# Arguments: the number of the problem
# Returns: nothing
# Globals: gGradeCanvas - the name of the canvas widget that has all
#                         of the radio buttons for grading on
#          gNewHandGrade - the variable the new grade will be in
#          gAnswer - an array containg the score for the student
#                ($i) - i contains the current problem number and the entry
#                       has one of Y, N, E, or -
#                (max$i) - i is the problem number, these entries exist only
#                          for handgraded questions, and is the maximum
#                          score for that question
###########################################################
proc handGrade { problemNumber } {
    global gGradeCanvas gNewHandGrade gAnswer

    set handGrade [toplevel .handGrade]
    
    set gradeFrame [frame $handGrade.gradeFrame]
    set buttonFrame [frame $handGrade.buttonFrame]
    pack $gradeFrame $buttonFrame -side top
    
    label $gradeFrame.grade -text "Grade: "
    entry $gradeFrame.entry -textvariable gNewHandGrade
    # set gNewHandGrade $gAnswer($problemNumber)
    
    set gNewHandGrade $gAnswer(max$problemNumber)
    
    label $gradeFrame.maxGrade -textvariable gAnswer(max$problemNumber)
    pack $gradeFrame.grade $gradeFrame.entry $gradeFrame.maxGrade -side left

    button $buttonFrame.cancel -text Cancel -command "set gPrompt(ok) 0"
    button $buttonFrame.ok -text Ok -command \
	"setHandGrade $problemNumber;set gPrompt(ok) 1"
    pack $buttonFrame.cancel $buttonFrame.ok -side left
    
    Centre_Dialog $handGrade default
    capaRaise $handGrade
    capaGrab $handGrade
    vwait gPrompt(ok)
    capaGrab release $handGrade
    destroy $handGrade
    $gGradeCanvas.hand$problemNumber deselect
}

###########################################################
# main
###########################################################
# sets up the auto_path variable, some globals and adds some
# options then calls createControlWindow to give the user something
# to do
###########################################################
# Arguments: None
# Returns: Nothing
# Globals: None
###########################################################
if { [lindex $auto_path 0] == "./lib/tcl7.5" } {
    set auto_path ""
    lappend auto_path [pwd]/lib/tcl7.5
    lappend auto_path [pwd]/lib/tk4.1
}

lappend auto_path /usr/local/lib/CAPA45/Grader
lappend auto_path [pwd]
source gradesubjective.tcl
option add *font 8x13bold
set gUniqueNumber 1
createControlWindow

Internal Server Error

The server encountered an internal error or misconfiguration and was unable to complete your request.

Please contact the server administrator at root@localhost to inform them of the time this error occurred, and the actions you performed just before this error.

More information about this error may be available in the server error log.