Return to classl.tcl CVS log

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

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

# classl editor
#  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.

###########################################################
# createClasslEditor
###########################################################
###########################################################
###########################################################
proc createClasslEditor { classlFile } {
    global gUniqueNumber gWindowMenu gWindow gTitle gClassl gFile \
	    gClosed

    set error [ catch {set fileId [open $classlFile "r"]}]
    if { $error } { 
	displayError "Unable to open a $classlFile."
	return
    }
    close $fileId

    set num [incr gUniqueNumber]

    set gFile($num) $classlFile

    set classlWin [toplevel .classlwindow$num]
    $gWindowMenu add command -label "Classl $classlFile" \
	    -command "capaRaise $classlWin"
    wm title $classlWin  "Classl $classlFile"

    set menuFrame [frame $classlWin.menu -borderwidth 3 -relief raised]
    set infoFrame [frame $classlWin.infoFrame]
    set actionFrame [frame $classlWin.actionFrame]
    set windowFrame [frame $classlWin.windowFrame]
    pack $menuFrame $infoFrame $actionFrame $windowFrame
    pack configure $windowFrame -expand 1 -fill both
    pack configure $menuFrame -fill x -anchor w

#menu
    menubutton $menuFrame.file -text File -menu $menuFrame.file.m
    menubutton $menuFrame.edit -text Copy -menu $menuFrame.edit.m
    pack $menuFrame.file  $menuFrame.edit -side left
    
    set fileMenu [ menu $menuFrame.file.m ]
    set editMenu [ menu $menuFrame.edit.m ]

    $fileMenu add command -label Open -accelerator "Alt+o" \
	    -command "specifyClass createClasslEditor"
    bind $classlWin <Alt-o> "specifyClass createClasslEditor"
    $fileMenu add command -label Save -command "saveClassl $num 0" \
	    -accelerator "Alt+s"
    bind $classlWin <Alt-s> "saveClassl $num 0"
    $fileMenu add command -label "Save As" -command "saveClassl $num 1" \
	    -accelerator "Alt+S"
    bind $classlWin <Alt-Shift-s> "saveClassl $num 1" 
    $fileMenu add command -label Print -command "printClassl $num"
    $fileMenu add command -label Close -command "closeClassl $num" \
	    -accelerator "Alt+w"
    bind $classlWin <Alt-w> "closeClassl $num"
    
    $editMenu add command -label "Copy StudentNum" -command "classlCopy $num stunum" \
	-accelerator "Alt+c"
    bind $classlWin <Alt-c> "classlCopy $num stunum"
    $editMenu add command -label "Copy Name" -command "classlCopy $num name" \
	-accelerator "Alt+n"
    bind $classlWin <Alt-n> "classlCopy $num name"
    $editMenu add command -label "Copy Email" -command "classlCopy $num email" \
	-accelerator "Alt+e"
    bind $classlWin <Alt-e> "classlCopy $num email"

#info
#action
    button $actionFrame.add -text "Add" -command "classlAdd $num"
    button $actionFrame.edit -text "Edit" -command "classlEdit $num"
    button $actionFrame.save -text "Save" -command "saveClassl $num 1"
    button $actionFrame.delete -text "Delete" -command "classlDelete $num"
    button $actionFrame.section -text "Change Section" -command "classlSectionChange $num"
    button $actionFrame.sort -text "Sort" -command "classlSort $num"
    button $actionFrame.print -text "Print" -command "classlPrint $num"
    button $actionFrame.find -text "Find" -command "classlFind $num"
    button $actionFrame.merge -text "Merge" -command "classlMerge $num"
    pack $actionFrame.add $actionFrame.edit $actionFrame.save $actionFrame.delete \
	$actionFrame.section $actionFrame.sort $actionFrame.print $actionFrame.find \
	$actionFrame.merge -side left

#window
    set leftFrame [frame $windowFrame.left]
    set rightFrame [frame $windowFrame.right]
    pack $leftFrame $rightFrame -side left
    pack configure $leftFrame -expand 1 -fill both
    pack configure $rightFrame -fill y 

#FIXME need to set the title width based on the widest occuring element in
#the listbox
    scrollbar $rightFrame.scroll -orient v -command "$leftFrame.classl yview"
    pack $rightFrame.scroll -fill y -expand 1 -pady 20

    set gTitle($num) [format "%-100s" "Class  Section  StuNum  Name                                E-mail"]
    entry $leftFrame.title -textvariable gTitle($num) -width 80 \
	    -state disabled -xscrollcommand "$leftFrame.scroll set"
    set gClassl($num) [ listbox $leftFrame.classl -width 80 -height 30 \
	    -xscrollcommand "$leftFrame.scroll set" \
	    -yscrollcommand "$rightFrame.scroll set" \
            -exportselection 0]
    scrollbar $leftFrame.scroll -orient h -command \
	    "scrolltwo {$leftFrame.classl xview} {$leftFrame.title  xview}"
    pack $leftFrame.title $leftFrame.classl $leftFrame.scroll -side top
    pack configure $leftFrame.title $leftFrame.scroll -fill x
    pack configure $leftFrame.classl -fill both -expand 1

    set fileId [open $classlFile "r"]
    while { 1 } {
	set aline [gets $fileId]
	if { [eof $fileId ] } { break }
	$gClassl($num) insert end [format "%-100s" $aline]
    }
    set gClassl($num.changed) 0
    set gClassl($num.changedlast) 0
    set gClosed($num) 0
    Centre_Dialog $classlWin default
    trace variable gClassl($num.changed) w updateClasslStatus
}

###########################################################
# closeClassl
###########################################################
###########################################################
###########################################################
proc closeClassl { num { mustClose 0 } } {
    global gWindowMenu gWindow gTitle gClassl gFile gClosed

    if { ![winfo exists $gClassl($num)] } { return }

    if { $gClosed($num) } { return }
    if { $gClassl($num.changed) == 1 } {
        if { [askToSave "Do you wish to save $gFile($num)?" "saveClassl $num" ] == "Cancel" && ( ! $mustClose ) } { return }
    }

    if { ( ! $mustClose ) && ( [makeSure "Are you sure you wish to stop editing
$gFile($num)?"] == "Cancel" ) } {
        return
    }
    set gClosed($num) 1
    destroy [winfo toplevel $gClassl($num)]
    removeWindowEntry "Classl $gFile($num)"
}

###########################################################
# saveClassl
###########################################################
###########################################################
###########################################################
proc saveClassl { num {saveAs 0}} {
    global gFile gClassl

    if { ![winfo exists $gClassl($num)] } { return }
    if { $saveAs } {
	set file [tk_getSaveFile -title "Enter name to Save As" \
		      -initialdir [file dirname "$gFile($num)"]]
	if {$file == "" } { return }
	set gFile($num) $file
    }
    set fileId [open "$gFile($num)" "w"]
    foreach line [$gClassl($num) get 0 end] { puts $fileId $line }
    close $fileId
    set gClassl($num.changed) 0
}

###########################################################
# classlSectionChange
###########################################################
###########################################################
###########################################################
proc classlSectionChange { num } {
    global gFile gClassl gWindowMenu
    
    if { [set which [$gClassl($num) curselection]] == "" } {
	displayMessage "Select a student first"
	return
    }
    if { [winfo exists .classlsection$num] } {
	capaRaise .classlsection$num
	return
    }
    set sectionChange [toplevel .classlsection$num]
    $gWindowMenu add command -label "Section Change" \
	    -command "capaRaise $sectionChange"
    wm title $sectionChange [file dirname $sectionChange]

    set infoFrame [frame $sectionChange.info]
    set entryFrame [frame $sectionChange.entry]
    set buttonFrame [frame $sectionChange.button]
    pack $infoFrame $entryFrame $buttonFrame -side top
    
    label $infoFrame.label -text "Enter New Section Number"
    pack $infoFrame.label

    label $entryFrame.label -text "Section:"
    entry $entryFrame.section -textvariable gClassl($num.section) -width 3 \
	-validate key -validatecommand "limitEntry %W 3 number %P"
    pack $entryFrame.label $entryFrame.section -side left

    set gClassl($num.done) 0
    button $buttonFrame.change -text "Change" -command "set gClassl($num.done) 1"
    button $buttonFrame.cancel -text "Cancel" -command "set gClassl($num.done) 0"
    pack $buttonFrame.change $buttonFrame.cancel -side left

    Centre_Dialog $sectionChange default
    update

    focus $sectionChange
    capaGrab $sectionChange
    vwait gClassl($num.done)
    capaGrab release $sectionChange
    
    if { $gClassl($num.done) } {
	set record [$gClassl($num) get $which]
	set record "[string range $record 0 9][format %03d $gClassl($num.section)][string range $record 13 end]"
	$gClassl($num) delete $which
	$gClassl($num) insert $which $record
	set gClassl($num.changed) 1
    }

    destroy $sectionChange
}

###########################################################
# classlSort
###########################################################
###########################################################
###########################################################
proc classlSort { num } {
    global gFile gClassl gWindowMenu
    if { [winfo exists .classlsort$num] } {
	capaRaise .classlsort$num
	return
    }

    set sortClassl [toplevel .classlsort$num]
    $gWindowMenu add command -label "Sort Classl" \
	    -command "capaRaise $sortClassl"
    wm title $sortClassl [file dirname $sortClassl]

    set infoFrame [frame $sortClassl.info]
    set buttonFrame [frame $sortClassl.button]
    pack $infoFrame $buttonFrame -side top
    
    label $infoFrame.label -text "How would you like the classl sorted?"
    pack $infoFrame.label
    
    set gClassl($num.done) 0
    button $buttonFrame.section -text "Sort By Section" \
	-command "set gClassl($num.done) Section"
    button $buttonFrame.name    -text "Sort By Name" \
	-command "set gClassl($num.done) Name"
    button $buttonFrame.cancel  -text "Cancel" -command "set gClassl($num.done) 0"
    pack $buttonFrame.section $buttonFrame.name $buttonFrame.cancel -side left

    Centre_Dialog $sortClassl default
    update

    focus $sortClassl
    capaGrab $sortClassl
    vwait gClassl($num.done)
    capaGrab release $sortClassl
    
    if { $gClassl($num.done) != 0 } {
	sortClassl$gClassl($num.done) $num
	set gClassl($num.changed) 1
    }
    destroy $sortClassl
}

###########################################################
# classlCompare
###########################################################
###########################################################
###########################################################
proc classlCompare { field1 field2 val1 val2 } {
    switch $field1 {
	section {
	    set a [string range $val1 10 12]
	    set b [string range $val2 10 12]
	}
	name {
	    set a " [string range $val1 24 55]"
	    set b " [string range $val2 24 55]"
	}
    }
    switch $field2 {
	name {
	    append a " [string range $val1 24 55]"
	    append b " [string range $val2 24 55]"
	}
	default {}
    }
    return [string compare $a $b]
}

###########################################################
# sortClasslSection
###########################################################
###########################################################
###########################################################
proc sortClasslSection { num } {
    global gClassl
    set allitems [$gClassl($num) get 0 end]
    set newitems [lsort -command "classlCompare section name" $allitems]
    $gClassl($num) delete 0 end
    eval "$gClassl($num) insert end $newitems"
}

###########################################################
# sortClasslName
###########################################################
###########################################################
###########################################################
proc sortClasslName { num } {
    global gClassl
    set allitems [$gClassl($num) get 0 end]
    set newitems [lsort -command "classlCompare name {}" $allitems]
    $gClassl($num) delete 0 end
    eval "$gClassl($num) insert end $newitems"
}
 
###########################################################
# makeClasslEntryEditor 
###########################################################
###########################################################
###########################################################
proc makeClasslEntryEditor { num window title buttonname } {
    global gClassl gWindowMenu

    if { [winfo exists $window] } {
	capaRaise $window
	return 1
    }

    set add [toplevel $window]
    $gWindowMenu add command -label "$title" -command "capaRaise $add"
    wm title $add "$title"

    set infoFrame [frame $add.info]
    set buttonFrame [frame $add.button]
    pack $infoFrame $buttonFrame -side top -anchor w

    set classFrame [frame $infoFrame.class]
    set sectionFrame [frame $infoFrame.section]
    set stuFrame [frame $infoFrame.stu]
    set nameFrame [frame $infoFrame.name]
    set emailFrame [frame $infoFrame.email]
    pack $classFrame $sectionFrame $stuFrame $nameFrame $emailFrame -side top -anchor w

    label $classFrame.label -text "Class Name" -width 20
    entry $classFrame.entry -textvariable gClassl($num.editclass) -width 9 \
	-validate key -validatecommand "limitEntry %W 9 any %P"
    pack $classFrame.label $classFrame.entry -side left

    label $sectionFrame.label -text "Section" -width 20
    entry $sectionFrame.entry -textvariable gClassl($num.editsection) -width 3 \
	-validate key -validatecommand "limitEntry %W 3 number %P"
    pack $sectionFrame.label $sectionFrame.entry -side left

    label $stuFrame.label -text "Student Number" -width 20
    entry $stuFrame.entry -textvariable gClassl($num.editstu) -width 9 \
	-validate key -validatecommand "limitEntry %W 9 any %P"
    pack $stuFrame.label $stuFrame.entry -side left

    label $nameFrame.label -text "Name(Last, First MI)" -width 20
    entry $nameFrame.entry -textvariable gClassl($num.editname) -width 30 \
	-validate key -validatecommand "limitEntry %W 30 any %P"
    pack $nameFrame.label $nameFrame.entry -side left

    label $emailFrame.label -text "Email" -width 20
    entry $emailFrame.entry -textvariable gClassl($num.editemail) -width 40 \
	-validate key -validatecommand "limitEntry %W 40 any %P"
    pack $emailFrame.label $emailFrame.entry -side left

    button $buttonFrame.add -text $buttonname -command "set gClassl($num.done) 1"
    button $buttonFrame.cancel -text Cancel -command "set gClassl($num.done) 0"
    pack $buttonFrame.add $buttonFrame.cancel -side left

    bind $add <Return> "set gClassl($num.done) 1"

    Centre_Dialog $add default
    update

    focus $add
    capaGrab $add
    return 0
}

###########################################################
# classlDelete
###########################################################
###########################################################
###########################################################
proc classlDelete { num } {
    global gClassl gWindowMenu

    if { [set which [$gClassl($num) curselection]] == "" } {
	displayMessage "Select a student first"
	return
    } 
    $gClassl($num) delete $which
    set gClassl($num.changed) 1
}

###########################################################
# classlEdit
###########################################################
###########################################################
###########################################################
proc classlEdit { num } {
    global gClassl gWindowMenu

    if { [set which [$gClassl($num) curselection]] == "" } {
	displayMessage "Select a student first"
	return
    } 
    set record [$gClassl($num) get $which]
    
    set gClassl($num.editclass) [string trimright [string range $record 0 8]]
    set gClassl($num.editsection) [string trimright [string range $record 10 12]]
    set gClassl($num.editstu) [string trimright [string range $record 14 22]]
    set gClassl($num.editname) [string trimright [string range $record 24 53]]
    set gClassl($num.editemail) [string trimright [string range $record 60 99]]

    if { [makeClasslEntryEditor $num ".classledit$num" "Editing Student" "Done"] } { return }

    vwait gClassl($num.done)
    capaGrab release .classledit$num
    destroy .classledit$num
    if { $gClassl($num.done) } {
	set gClassl($num.editsection) [string trimleft $gClassl($num.editsection) "0"]
	set record [format "%-9s %03d %-9s %-30s      %-40s" $gClassl($num.editclass) \
		   $gClassl($num.editsection) $gClassl($num.editstu) \
		   $gClassl($num.editname) $gClassl($num.editemail)]
	$gClassl($num) delete $which
	$gClassl($num) insert $which $record
	set gClassl($num.changed) 1
    }
}

###########################################################
# findStuNumClassl 
###########################################################
###########################################################
###########################################################
proc findStuNumClassl { num newstunum } {
    global gClassl 
    
    set max [$gClassl($num) index end]
    for {set i 0} {$i < $max} {incr i} {
	set teststunum [string range [$gClassl($num) get $i] 14 22]
	if { [regexp -nocase $newstunum $teststunum] } { return $i }
    }
    return -1
}

###########################################################
# classlAdd
###########################################################
###########################################################
###########################################################
proc classlAdd { num } {
    global gClassl gWindowMenu

    set gClassl($num.editclass) ""
    set gClassl($num.editsection) ""
    set gClassl($num.editstu) ""
    set gClassl($num.editname) ""
    set gClassl($num.editemail) ""

    if { [makeClasslEntryEditor $num ".classladd$num" "Adding a Student" "Add"] } { 
	return 
    }
    vwait gClassl($num.done)
    capaGrab release .classladd$num
    destroy .classladd$num
    
    if { $gClassl($num.done) } {
	if { [set which [findStuNumClassl $num $gClassl($num.editstu)]] > -1 } {
	    if { "Cancel" == [makeSure "Found a duplicate student \n [$gClassl($num) get $which] \n Replace this one?"] } {
		set gClassl($num.done) 0
		displayMessage "Student was not added."
	    } else {
		$gClassl($num) delete $which
	    }
	}
    }
    if { $gClassl($num.done) } {
	set gClassl($num.editsection) [string trimleft $gClassl($num.editsection) "0"]
	set a [format "%-9s %03d %-9s %-30s      %-40s" $gClassl($num.editclass) \
		   $gClassl($num.editsection) $gClassl($num.editstu) \
		   $gClassl($num.editname) $gClassl($num.editemail)]
	$gClassl($num) insert 0 $a
	set gClassl($num.changed) 1
    }
}

###########################################################
# classlPrint
###########################################################
###########################################################
###########################################################
proc classlPrint { num } {
    global gClassl gWindowMenu gFile

    if { [set which [$gClassl($num) curselection]] == "" } {
	displayMessage "Select a student first"
	return
    } 
    if { $gClassl($num.changed) == 1 } {
        if {[askToSave "Do you wish to save $gFile($num)?" "saveClassl $num"]=="Yes"} { 
	    saveClassl $num
	}
    }
    set record [$gClassl($num) get $which]
    set stunum [string range $record 14 22]

    if { [winfo exists .capaprint$num] } {
	capaRaise .capaprint$num
	return 1
    }

    set print [toplevel .capaprint$num]
    $gWindowMenu add command -label "Printing a Student" -command "capaRaise $print"
    wm title $print "Printing a Student"

    set infoFrame [frame $print.info]
    set dataFrame [frame $print.data]
    set buttonFrame [frame $print.button]
    pack $infoFrame $dataFrame $buttonFrame -side top -anchor w

    label $infoFrame.label -text "Print For Student $stunum"
    pack $infoFrame.label

    set setFrame [frame $dataFrame.set]
    set printerFrame [frame $dataFrame.printer]
    pack $setFrame $printerFrame -side top -anchor w

    label $setFrame.label -text "Set" -width 13
    entry $setFrame.set -textvariable gClassl($num.printset) -width 2 \
		-validate key -validatecommand "limitEntry %W 9 any %P"
    pack $setFrame.label $setFrame.set -side left

    label $printerFrame.label -text "Printer Name" -width 13
    entry $printerFrame.printer -textvariable gClassl($num.printername) -width 20 
    pack $printerFrame.label $printerFrame.printer -side left

    button $buttonFrame.print -text "Print" -command "set gClassl($num.done) 1"
    button $buttonFrame.cancel -text "Cancel" -command "set gClassl($num.done) 0"
    pack $buttonFrame.print $buttonFrame.cancel -side left

    bind $print <Return> "set gClassl($num.done) 1"

    Centre_Dialog $print default
    update

    focus $print
    capaGrab $print
    vwait gClassl($num.done)
    capaGrab release $print

    if { $gClassl($num.done) } {
	global gCapaConfig
	parseCapaConfig $num [file dirname $gFile($num)]
	if {[catch {printStudent $num $stunum $gClassl($num.printset) $gClassl($num.printername)} error ]} {
	    displayError "Unable to print  $stunum"
	}
	foreach name [array names gCapaConfig "$num.*"] {
	    unset gCapaConfig($name)
	}
    }
    destroy $print
}

###########################################################
# printStudent
###########################################################
###########################################################
###########################################################
proc printStudent { num stunum printset printername } {
    global gCapaConfig gFile
    set command "$gCapaConfig($num.qzparse_command) -c [file dirname $gFile($num)] \
                     -set $printset -stu $stunum"
    eval "exec $command"
    set tex_file [file join [file dirname $gFile($num)] TeX $stunum.tex]
    set command "$gCapaConfig($num.latex_command) $tex_file"
    removeStatus $num
    #if { "Yes" != [makeSure "Planning on running LaTeX, Continue?"] } { return }
    displayStatus "Running LaTeX" message $num
    set directory [pwd]
    cd [file join [file dirname $gFile($num)] TeX]
    eval "exec $command"
    cd $directory
    set dvi_file [file join [file dirname $gFile($num)] TeX $stunum.dvi]
    set ps_file [file join [file dirname $gFile($num)] TeX $stunum.ps]
    set command "$gCapaConfig($num.dvips_command) $dvi_file -o $ps_file >& /dev/null"
    removeStatus $num
    #if { "Yes" != [makeSure "Planning on running dvips, Continue?"] } { return }
    displayStatus "Running dvips" message $num
    eval "exec $command"
    removeStatus $num
    #if { "Cancel" == [set lprcmd [getLprCommand $ps_file $num]] } { return }
    if { [catch { eval "exec lpr -P$printername $ps_file" } errors ] } {
	displayError "An error occurred while printing: $errors"
    }
}

###########################################################
# updateClasslStatus
###########################################################
###########################################################
###########################################################
proc updateClasslStatus { name1 name2 op } {
    global gClassl gWindowMenu

    set num [lindex [split $name2 .] 0]
    if { $gClassl($num.changed) != $gClassl($num.changedlast)} {
	set gClassl($num.changedlast) $gClassl($num.changed)
	global gFile
	if { ![winfo exists $gClassl($num)] } { return }
	if { $gClassl($num.changed) } {
	    catch {removeWindowEntry "Classl $gFile($num)*"}
	    wm title [winfo toplevel $gClassl($num)] "Classl $gFile($num) (Modified)"
	    $gWindowMenu add command -label "Classl $gFile($num) (Modified)" -command \
		"capaRaise $gClassl($num)"
	} else {
	    catch {removeWindowEntry "Classl $gFile($num)*"}
	    wm title [winfo toplevel $gClassl($num)] "Classl $gFile($num)"
	    $gWindowMenu add command -label "Classl $gFile($num)" -command \
		"capaRaise $gClassl($num)"
	}
    }
}

###########################################################
# classlCopy
###########################################################
###########################################################
###########################################################
proc classlCopy { num field } {
    global gClassl
    
    if { ![winfo exists $gClassl($num)] } { return }
    if { [set which [$gClassl($num) curselection]] == "" } {
	displayMessage "Select a student first"
	return
    }
    set entry [$gClassl($num) get $which]
    set text ""
    switch $field {
	stunum { set text [string trimright [string range $entry 14 22]] }
	name { set text [string trimright [string range $entry 24 53]] }
	email { set text [string trimright [string range $entry 60 99]] }
    }
    if { $text != "" } {
	set gClassl($num.selection) $text
	selection own $gClassl($num)
	selection handle $gClassl($num) "classlPaste $num"
	selection handle -selection CLIPBOARD $gClassl($num) "classlPaste $num"
	clipboard clear -displayof $gClassl($num)
	clipboard append -displayof $gClassl($num) -- $text
    }
}

###########################################################
# classlPaste
###########################################################
###########################################################
###########################################################
proc classlPaste { num start length } {
    global gClassl
    return [string range $gClassl($num.selection) $start [expr $start + $length]]
}

###########################################################
# classlFind
###########################################################
###########################################################
###########################################################
proc classlFind { num } {
    global gClassl gWindowMenu

    if { [winfo exists .classlfind$num] } {
	capaRaise .classlfind$num
	return
    }
    set classlFind [toplevel .classlfind$num]
    $gWindowMenu add command -label "Find in Classl" \
	    -command "capaRaise $classlFind"
    wm title $classlFind "Find"

    set infoFrame [frame $classlFind.info]
    set entryFrame [frame $classlFind.entry]
    set buttonFrame [frame $classlFind.button]
    pack $infoFrame $entryFrame $buttonFrame -side top -anchor w

    set nameFrame [frame $entryFrame.name]
    set stunumFrame [frame $entryFrame.stunum]
    set emailFrame [frame $entryFrame.email]
    pack $nameFrame $stunumFrame $emailFrame -side top -anchor w

    label $nameFrame.label -text "Name" -width 14 -anchor w
    entry $nameFrame.name -textvariable gClassl($num.findname) -width 30 \
	-validate key -validatecommand "limitEntry %W 30 any %P"
    frame $nameFrame.spacer -width 80
    button $nameFrame.go -text "Find" -command "classlDoFind $num name"
    pack $nameFrame.label $nameFrame.name $nameFrame.spacer $nameFrame.go \
	-side left -anchor w

    label $stunumFrame.label -text "Student Number" -width 14 -anchor w
    entry $stunumFrame.stunum -textvariable gClassl($num.findstunum) -width 9 \
	-validate key -validatecommand "limitEntry %W 9 any %P"
    frame $stunumFrame.spacer -width 248
    button $stunumFrame.go -text "Find" -command "classlDoFind $num stunum"
    pack $stunumFrame.label $stunumFrame.stunum $stunumFrame.spacer \
	$stunumFrame.go -side left -anchor w

    label $emailFrame.label -text "Email" -width 14 -anchor w
    entry $emailFrame.email -textvariable gClassl($num.findemail) -width 40 \
	-validate key -validatecommand "limitEntry %W 40 any %P"
    button $emailFrame.go -text "Find" -command "classlDoFind $num email"
    pack $emailFrame.label $emailFrame.email $emailFrame.go -side left -anchor w

    button $buttonFrame.close -text "Close" -command "destroy $classlFind"
    pack $buttonFrame.close

    Centre_Dialog $classlFind default
}

###########################################################
# classlDoFind
###########################################################
###########################################################
###########################################################
proc classlDoFind { num type } {
    global gClassl 

    if {![winfo exists $gClassl($num)]} {return}
    if { [set which [$gClassl($num) curselection]] == "" } { 
	set which 0 
    } else {
	incr which
    }
    set max [$gClassl($num) index end]
    for {set i 0} { $i < ($max)} {incr i} {
	set current [expr ($i+$which)%$max]
	set entry [$gClassl($num) get $current]
	switch $type {
	    name { set tmp [string range [$gClassl($num) get $current] 24 53] }
	    stunum { set tmp [string range [$gClassl($num) get $current] 14 22] }
	    email { set tmp [string range [$gClassl($num) get $current] 60 99] }
	}
	if { [regexp -nocase $gClassl($num.find$type) $tmp] } {
	    $gClassl($num) selection clear 0 end
	    $gClassl($num) selection set $current
	    $gClassl($num) see $current
	    return
	}
    }
    displayMessage "Not Found"
}

###########################################################
# classlMerge
###########################################################
###########################################################
###########################################################
proc classlMerge { num } {
    global gClassl 

    set filename [tk_getOpenFile -title "Select a File to merge in"]

    if { $filename == "" } { return }
    set fileId [open $filename "r"]
    set maxlines [lindex [exec wc -l $filename] 0]
    set linenum 0
    set newentries 0
    displayStatus "Merging $filename" both $num
    set aline [gets $fileId]
    while {![eof $fileId]} {
	incr linenum
	set found 0
	set stunum [string range $aline 14 22]
	set max [$gClassl($num) index end]
	for {set i 0} { $i < ($max)} {incr i} {
	    set tmp [string range [$gClassl($num) get $i] 14 22]
	    if { [regexp -nocase $stunum $tmp] } { 
		set found 1
		break 
	    }
	}
	if { !$found } { 
	    incr newentries
	    $gClassl($num) insert end $aline 
	}
	updateStatusBar [expr $linenum/double($maxlines)] $num
	set aline [gets $fileId]
    }    
    removeStatus $num
    if { $newentries != 0 } { 
	$gClassl($num) see $max 
	$gClassl($num) selection set $max
    }
    displayMessage "Added $newentries students."
}

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.