xgsetup.tcl

xgrafix 是PTSG模拟程序中的图形截面库 改版本是最新版本

		$WinData($Window,yLinLog) $WinData($Window,zMin) \
		$WinData($Window,zMax) $WinData($Window,zAuto) \
		$WinData($Window,zLinLog)
}

proc RestoreWinParams { Window } {
	global WinData

	set WinData($Window,xAuto) 1
	set WinData($Window,yAuto) 1

	C_Rescale $WinData($Window,index) $WinData($Window,origxMin) \
		$WinData($Window,origxMax) $WinData($Window,origxAuto) \
		$WinData($Window,origxLinLog) $WinData($Window,origyMin) \
		$WinData($Window,origyMax) $WinData($Window,origyAuto) \
		$WinData($Window,origyLinLog) $WinData($Window,origzMin) \
		$WinData($Window,origzMax) $WinData($Window,origzAuto) \
		$WinData($Window,origzLinLog)

	if {$WinData($Window,origxAuto)==1 || $WinData($Window,origyAuto)==1} {
		$Window.bframe.trace configure -state disabled
	}
}

proc Update3dCrosshair { Window x } \
{
	global WinData
	
	#C_printf "calling C_3dCross from Update3dCrosshair"
        C_RefreshGraphics $WinData($Window,index)
        C_3dCross $WinData($Window,index) [$Window.middle.x.scale get] \
		[$Window.middle.y.scale get]
}

proc Update3dCrosshairValues { WinName x y z } \
{
	global WinData

	append Window . [string tolower $WinName]

	set WinData($Window,xCoord) $x
	set WinData($Window,yCoord) $y
	set WinData($Window,zCoord) $z
        update
}
	

proc PopupCrosshair { Window } \
{
	global WinData
	global WasRunning
	global ThreeD

	if { $WinData($Window,type) == $ThreeD } {
	    if {[lindex [$Window.bframe.crosshair configure -relief] 4] == "raised"} {
		$Window.bframe.crosshair configure -relief sunken
		pack $Window.middle.x $Window.middle.y -fill both -expand true
		pack $Window.bottom -fill x
		C_3dCrossOn $WinData($Window,index)
		update
		Update3dCrosshair $Window 0
	    } else {
		$Window.bframe.crosshair configure -relief raised
		C_3dCrossOff $WinData($Window,index)
		pack forget $Window.middle.x $Window.middle.y $Window.bottom 
	    }
	} else {
	    if {[lindex [$Window.bframe.crosshair configure -relief] 4] == "raised"} {
		$Window.bframe.crosshair configure -relief sunken
		pack $Window.bottom -fill x
		update
	    } else {
		$Window.bframe.crosshair configure -relief raised
		pack forget $Window.bottom 
	    }
	}
	update idletasks
}
    
########################################################################
# Calls a C Procedure to refresh the graphics for each open diagnostic
		
proc DoGraphics {} \
{
	global WinData
	global windowsList
	global theCurrentStep
	global WasRunning

	incr theCurrentStep

        foreach Window $windowsList {
		if [ expr \
		{ $WinData($Window,open) && [wm state $Window]=="normal" } || \
		{ [ShouldRefresh $Window]=="1" } ] {
			#C_printf "c_refreshing Window"
	               C_RefreshGraphics $WinData($Window,index)
		}

		if { $WinData($Window,printLimit) != 0 && \
		[expr [expr $theCurrentStep - $WinData($Window,printSetStep)] \
		% $WinData($Window,printPeriod)] == 0 } {
				Print $Window
			incr WinData($Window,printLimit) -1
		}
	}
}	

proc ShouldRefresh { Window } \
{
	global WinData

	if { $WinData($Window,xAuto)==0 && $WinData($Window,yAuto)==0 \
	&& $WinData($Window,trace)==1 && $WinData($Window,printLimit) > 0 \
	&& $WinData($Window,printType)=="xpm" } {
		return 1
	} else {
		return 0
	}
}

############################
# Updates the time counter  

proc UpdateTime { newTime } \
{
	global time
	set time $newTime
}

############################################
# Calls a C procedure to turn on/off trace

proc Trace { Window } \
{
	global WinData

	if { $WinData($Window,trace)==0 } {
		$Window.bframe.trace configure -relief sunken
		set WinData($Window,trace) 1
	} else {
		$Window.bframe.trace configure -relief raised
		set WinData($Window,trace) 0
	}

	C_Trace $WinData($Window,index)
}

################################################
# Procedures to find the crosshair coordinates 

proc UpdateCrosshair { Window x y } \
{
	global WinData

	C_SetCrosshairParameters $WinData($Window,index)
	set coords [ C_UpdateCrosshair $WinData($Window,index) $x $y ]
	if { $coords != "" } {
		set WinData($Window,xCoord) [lindex $coords 0]
		set WinData($Window,yCoord) [lindex $coords 1]
	}
}

###############################
# Closes all open diagnostics  

proc CloseAllDiags { } \
{
	global openWindowsList

	foreach Window $openWindowsList {
		Close $Window
	}
}

################################################
# Sets up data structure for Special variables 

proc SetUpNewVar { index varName type } \
{
	global SpecialData
	global numberOfSpecials

	set SpecialData($index,varName) $varName
	set SpecialData($index,type) $type
	set SpecialData($index,varValue) 0
	incr numberOfSpecials
}

#######################################
# Opens or closes diagnostics listbox  

proc PopupDiagWin {} \
{
	if { [ wm state .list ] == "withdrawn" } {
		wm deiconify .list
		raise .list
		.lbframe.diags configure -text "Close Diagnostics"
	} else {
		wm withdraw .list
		.lbframe.diags configure -text "Open Diagnostics"
	}
}

#########################################
# Calls C procedure to change variables

proc SetNewSpecials { } \
{
	global SpecialData
	global numberOfSpecials

	for { set index 0 } { $index < $numberOfSpecials } { incr index } {
		C_SetNewSpecials $index $SpecialData($index,varValue)
	}
}

proc lput { Window } \
{
	global openWindowsList

	if { [lsearch $openWindowsList $Window] == -1 } {
		lappend openWindowsList $Window
	}
}
	
proc lremove { Window } \
{
	global openWindowsList

	set index [lsearch $openWindowsList $Window] 
	if { $index >= 0 } {
		set openWindowsList [lreplace $openWindowsList $index $index]
	}
}

proc Open { Window } \
{
        global WinData
         global openWindowsList
        global WasRunning

         
	if { $WinData($Window,created) == 1 } {
		if { $WasRunning == 1 } {
		#C_printf "stopping"
	        C_Stop
		update idletasks
		    update idletasks
		}
		set WinData($Window,open) 1
		lput $Window
		wm deiconify $Window
		tkwait visibility $Window
		#raise $Window
		MarkOpen $Window
	    #update idletasks
		C_Open $WinData($Window,index) 
		update 
		if { $WasRunning == 1 } {
		#update idletasks
		C_Run
		#C_printf "running"
	    }
	} else {
	    if { $WasRunning == 1 } {
		#C_printf "stopping"
	        C_Stop
		update idletasks
	}
	CreateWindow $Window
	set WinData($Window,open) 1
	lput $Window
	C_CreateWindow $WinData($Window,index) $Window.middle.label
	#C_pause "C_CreatedWindow"
	#C_printf "C_CreatedWindow"
	set WinData($Window,created) 1
	MarkOpen $Window
	update
	#C_printf "marked window open"
	C_Open $WinData($Window,index) 
	#C_printf "C_opened window"
	    if { $WasRunning == 1 } {
		#update idletasks
		C_Run
		#C_printf "running"
	    }
    }
    
}

proc MarkOpen { Window } \
{
	global WinData

         set a [.list.lframe.openbox yview]
        .list.lframe.openbox delete $WinData($Window,index)
	.list.lframe.openbox insert $WinData($Window,index) "*"
        .list.lframe.openbox yview moveto [ lindex $a 0 ]
 }

proc Close { Window } \
{
	global WinData
	global WasRunning

	if { $WinData($Window,created) == 1 } {
		set WinData($Window,open) 0
		lremove $Window
		MarkClosed $Window
		C_Close $WinData($Window,index) 
		wm withdraw $Window
	    #tkwait visibility $Window
	}
}

proc MarkClosed { Window } \
{
	global WinData

	set a [.list.lframe.openbox yview]
        .list.lframe.openbox delete $WinData($Window,index)
	.list.lframe.openbox insert $WinData($Window,index) " "
        .list.lframe.openbox yview moveto [ lindex $a 0 ]
}

proc Tk_XGStart {} \
{
	global WinData
	global openWindowsList
# changed "from" to "anchor" below  --- djc for tk4
	.list.lframe.listbox select anchor 0
	foreach Window $openWindowsList {
	        C_CreateWindow $WinData($Window,index) $Window.middle.label
		MarkOpen $Window
	}
	update
}


# tkScrollDrag ********** to update listbox and openbox*******--
# This procedure is called for each mouse motion even when the slider
# is being dragged.  It notifies the associated widget if we're not
# jump scrolling, and it just updates the scrollbar if we are jump
# scrolling.
#
# Arguments:
# w -           The scrollbar widget.
# x, y -        The current mouse position.

proc tkScrollDragCuston {w x y} {
    global tkPriv

    if {$tkPriv(initPos) == ""} {
        return
    }
    set delta [$w delta [expr $x - $tkPriv(pressX)] [expr $y - $tkPriv(pressY)]]
    if [$w cget -jump] {
        if {[llength $tkPriv(initValues)] == 2} {
            $w set [expr [lindex $tkPriv(initValues) 0] + $delta] \
                    [expr [lindex $tkPriv(initValues) 1] + $delta]
        } else {
            set delta [expr round($delta * [lindex $tkPriv(initValues) 0])]
            eval $w set [lreplace $tkPriv(initValues) 2 3 \
                    [expr [lindex $tkPriv(initValues) 2] + $delta] \
                    [expr [lindex $tkPriv(initValues) 3] + $delta]]
        }
    } else {
        tkScrollToPosCustom $w [expr $tkPriv(initPos) + $delta]
    }
}
proc tkScrollToPosCustom {w pos} {
    set cmd ".list.lframe.listbox yview"
    set info [$w get]
    if {[llength $info] == 2} {
        uplevel #0 $cmd moveto $pos
    } else {
        uplevel #0 $cmd [expr round([lindex $info 0]*$pos)]
    }
    set cmd ".list.lframe.openbox yview"
    set info [$w get]
    if {[llength $info] == 2} {
        uplevel #0 $cmd moveto $pos
    } else {
        uplevel #0 $cmd [expr round([lindex $info 0]*$pos)]
    }
}