Namespaces
	tk

	tk::mac

Functions
	setFname name

	value.value args

	attachTraceProc namesp

	traceProc args

	tcl_exit args

	setCursor cur

	setBackgroundColour bgc

	tk_focusPrev win

	tk_focusNext win

	deiconify widget

	showPreferences

	generateBookmarkMenu

	addBookMark

	invokeButton button

	autoRepeatButton button

	setSimulationDelay delay

	imageFileTypes

	setExportResolutionFactor setter

	renderImage filename type surf

	exportCanvas

	getLogVars

	logVarsOK

	getClipboard

	togglePaste

	undo delta

	cut

	dimensionsDialog

	rewriteTimeComboBox comboBox

	dimFormatPopdown comboBox type onSelect

	pasteAt

	buttonBar window okProc

	okAction okProc window

	cancelWin window

	ensureWindowVisible window

	textEntryPopup win init okproc

	addTab window label surface

	hoverMouseTab tabId

	wrapHoverMouseTab tabId op x y

	tabContext x y X Y

	setScrollBars

	panCanvas offsx offsy

	scrollCanvases xyview args

	runstop

	step

	simulate

	reset

	populateRecentFiles

	openFile

	autoBackupName

	openNamedFile ofname

	insertFile

	importMDL

	recentreCanvas

	fileTypes defaultExtension

	save

	saveAs

	newSystem

	toggleImplicitSolver

	invokeOKorCancel window

	deiconifyRKDataForm

	closeRKDataForm

	setRKparms

	closePreferencesForm

	setPreferenceParms

	topLevelHelp

	helpContext x y

	helpFor x y

	canvasHelp

	openURL URL

	help topic

	aboutMinsky

	deleteSubsidiaryTopLevels

	exit

	bgerror x

	unknown procname args

	ifDef var

	addEvent event window button height state width x y delta keysym subwindow

	startRecording filename

	stopRecording

	toggleRecording

	checkRecordingVersion ver

	replay

	tk::SetFocusGrab grab focus

	tk::mac::OpenDocument args

	tk::mac::ShowPreferences

	tk::mac::ShowHelp

Function Documentation

◆ aboutMinsky()

aboutMinsky

Definition at line 1717 of file minsky.tcl.

 proc aboutMinsky {} {
   tk_messageBox -message "
    Minsky [minskyVersion]\n
    Version used to save file [fileVersion]\n
    Tcl/Tk [info tclversion]\n
    Ravel [ravelVersion]
 " -detail "
    Minsky is FREE software, distributed under the 
    GNU General Public License. It comes with ABSOLUTELY NO WARRANTY. 
    See http://www.gnu.org/licenses/ for details
 
    Some icons from the Antü Plasma Suita are licensed under Creative
    Commons Attribution-Share Alike 3.0 Unported license
    (https://creativecommons.org/licenses/by-sa/3.0/deed.en).
 
    Ravel is copyright Ravelation Pty Ltd. A separate license needs to
    be purchased to use Ravel. See https://ravelation.hpcoders.com.au
 
 Thanks to following Minsky Unicorn sponsors:
      Edward McDaniel
      Travis Kimmel
    " 
 }

◆ addBookMark()

addBookMark

Definition at line 508 of file minsky.tcl.

References buttonBar(), ensureWindowVisible(), and pack().

 proc addBookMark {} {
     toplevel .bookMarkDialog
     frame .bookMarkDialog.name
     label .bookMarkDialog.name.text -text "Bookmark name"
     entry .bookMarkDialog.name.val
     pack .bookMarkDialog.name.text .bookMarkDialog.name.val -side left
     pack .bookMarkDialog.name
     buttonBar .bookMarkDialog {
         minsky.canvas.model.addBookmark [.bookMarkDialog.name.val get]
     }
     ensureWindowVisible .bookMarkDialog
     wm transient .bookMarkDialog
     focus .bookMarkDialog.name.val
     grab set .bookMarkDialog
 }

Here is the call graph for this function:

◆ addEvent()

addEvent			event window button height state width x y delta keysym subwindow

Definition at line 1854 of file minsky.tcl.

References ifDef().

 proc addEvent {event window button height state width x y delta keysym subwindow} {
     global eventRecord eventRecording
     if {$eventRecording && [info exists eventRecord] && [llength [file channels $eventRecord]]} {
         set rec "event generate $window $event "
         foreach option {button height state width x y delta keysym} {
             # for some reason, the logic misses this one
             if {($event=="<Key>" || $event=="<KeyRelease>") && $option=="delta"} continue
             append rec [ifDef $option]
         }
         puts $eventRecord $rec
     }
 }

Here is the call graph for this function:

◆ addTab()

addTab			window label surface

Definition at line 973 of file minsky.tcl.

 proc addTab {window label surface} {
     image create cairoSurface rendered$window -surface $surface
     ttk::frame .$window
     global canvasHeight canvasWidth tabSurface helpTopics
     label .$window.canvas -image rendered$window -height $canvasHeight -width $canvasWidth
     .tabs add .$window -text $label -padding 0
     set tabSurface($label) $surface
     set helpTopics(.$window) tabs:$label
 }

◆ attachTraceProc()

attachTraceProc			namesp

Definition at line 112 of file minsky.tcl.

References attachTraceProc().

Referenced by attachTraceProc().

 proc attachTraceProc {namesp} {
     foreach p [info commands $namesp*] {
         if {$p ne "::traceProc"} {
             trace remove execution $p enterstep traceProc
             trace add execution $p enterstep traceProc
         }
     }
     # recursively process child namespaces
     foreach n [namespace children $namesp] {
         attachTraceProc ${n}::
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ autoBackupName()

autoBackupName

Definition at line 1375 of file minsky.tcl.

Referenced by exit(), newSystem(), openNamedFile(), and save().

 proc autoBackupName {} {
     global fname
     return "$fname#"
 }

Here is the caller graph for this function:

◆ autoRepeatButton()

autoRepeatButton			button

Definition at line 534 of file minsky.tcl.

Referenced by invokeButton().

 proc autoRepeatButton button {
     after 500 invokeButton $button
 }

Here is the caller graph for this function:

◆ bgerror()

bgerror			x

Definition at line 1785 of file minsky.tcl.

1785 proc bgerror x {}

◆ buttonBar()

buttonBar			window okProc

Definition at line 910 of file minsky.tcl.

References pack().

Referenced by addBookMark(), bookmarkAt(), CSVImportDialog(), csvImportDialogOK(), lockSpecificHandles(), penStyles(), setDimension(), setExportResolutionFactor(), setupPickDimMenu(), setupPickMenu(), and textEntryPopup().

 proc buttonBar {window okProc} {
     frame $window.buttonBar
     button $window.buttonBar.ok -text "OK" -command "okAction \{$okProc\} $window"
     button $window.buttonBar.cancel -text "Cancel" -command "cancelWin $window"
     pack $window.buttonBar.cancel $window.buttonBar.ok -side left
     pack $window.buttonBar -side top
     bind $window <Key-Return> "$window.buttonBar.ok invoke"
     bind $window <Key-Escape> "$window.buttonBar.cancel invoke"
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cancelWin()

cancelWin			window

Definition at line 929 of file minsky.tcl.

Referenced by csvImportDialogOK(), and okAction().

 proc cancelWin window {
     grab release $window
     destroy $window
 }

Here is the caller graph for this function:

◆ canvasHelp()

canvasHelp

Definition at line 1676 of file minsky.tcl.

References get_pointer_x(), get_pointer_y(), and help().

Referenced by helpFor().

 proc canvasHelp {} {
     set x [get_pointer_x .wiring.canvas]
     set y [get_pointer_y .wiring.canvas]
     if [getItemAt $x $y] {
         help [minsky.canvas.item.classType]
     } elseif [getWireAt $x $y] {
         help wire
     } else {help DesignCanvas}
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ checkRecordingVersion()

checkRecordingVersion			ver

Definition at line 1888 of file minsky.tcl.

 proc checkRecordingVersion ver {
     if {$ver!=[minskyVersion]} {
         tk_messageBox -icon warning -message "Recording version $ver differs from current Minsky version [minskyVersion]" -detail "Recording may not replay correctly"
     }
 }

◆ closePreferencesForm()

closePreferencesForm

Definition at line 1591 of file minsky.tcl.

 proc closePreferencesForm {} {
     destroy .preferencesForm
 }

◆ closeRKDataForm()

closeRKDataForm

Definition at line 1580 of file minsky.tcl.

 proc closeRKDataForm {} {
     grab release .rkDataForm
     wm withdraw .rkDataForm
 }

◆ cut()

cut

Definition at line 756 of file minsky.tcl.

Referenced by deleteKey(), and minsky::GodleyTableEditor::keyPress().

 proc cut {} {
     minsky.cut
 }

Here is the caller graph for this function:

◆ deiconify()

deiconify			widget

Definition at line 265 of file minsky.tcl.

Referenced by deiconifyRKDataForm(), initRandom(), setDimension(), setupPickDimMenu(), setupPickMenu(), and showPreferences().

 proc deiconify {widget} {
     wm deiconify $widget
     after idle "wm deiconify $widget; raise $widget; focus -force $widget"
 }

Here is the caller graph for this function:

◆ deiconifyRKDataForm()

deiconifyRKDataForm

Definition at line 1540 of file minsky.tcl.

References deiconify(), and pack().

 proc deiconifyRKDataForm {} {
     if {![winfo exists .rkDataForm]} {
         global rkVarInput rkVars
         toplevel .rkDataForm
         wm resizable .rkDataForm 0 0
 
         set row 0
 
         grid [label .rkDataForm.label$row -text "Simulation parameters"] -column 1 -columnspan 999 -pady 10
         incr row 10
 
         foreach {var text} $rkVars {
             set rowdict($text) $row
             grid [label .rkDataForm.label$row -text $text] -column 10 -row $row -sticky e
             grid [entry  .rkDataForm.text$row -width 20 -textvariable rkVarInput($var)] -column 20 -row $row -sticky ew
             incr row 10
         }
         grid [label .rkDataForm.implicitlabel -text "Implicit solver"] -column 10 -row $row -sticky e
         grid [checkbutton  .rkDataForm.implicitcheck -variable implicitSolver -command toggleImplicitSolver] -column 20 -row $row -sticky ew
 
         set rkVarInput(initial_focus) ".rkDataForm.text$rowdict(Min Step Size)"
         frame .rkDataForm.buttonBar
         button .rkDataForm.buttonBar.ok -text OK -command {setRKparms; closeRKDataForm}
         button .rkDataForm.buttonBar.cancel -text cancel -command {closeRKDataForm}
         pack .rkDataForm.buttonBar.ok [label .rkDataForm.buttonBar.spacer -width 2] .rkDataForm.buttonBar.cancel -side left -pady 10
         grid .rkDataForm.buttonBar -column 1 -row 999 -columnspan 999
         
         bind .rkDataForm <Key-Return> {invokeOKorCancel .rkDataForm.buttonBar}
 
         wm title .rkDataForm "Simulation parameters"
         # help bindings
         bind .rkDataForm  <F1>  {help RungeKutta}
         global helpTopics
         set helpTopics(.rkDataForm) RungeKutta
         bind .rkDataForm  <<contextMenu>> {helpContext %X %Y}
     } else {
         deiconify .rkDataForm
     }
 }

Here is the call graph for this function:

◆ deleteSubsidiaryTopLevels()

deleteSubsidiaryTopLevels

Definition at line 1742 of file minsky.tcl.

Referenced by newSystem(), and undo().

 proc deleteSubsidiaryTopLevels {} {
     global globals
 
     canvas.defaultRotation 0
     set globals(godley_tables) {}
 
     foreach w [info commands .godley*] {destroy $w}
     foreach w [info commands .plot*] {destroy $w}
     foreach image [image names] {
         if [regexp ".plot.*|godleyImage.*|groupImage.*|varImage.*|opImage.*|plot_image.*" $image] {
                 image delete $image
             }
     }
 }

Here is the caller graph for this function:

◆ dimensionsDialog()

dimensionsDialog

Definition at line 760 of file minsky.tcl.

References dimFormatPopdown().

 proc dimensionsDialog {} {
     populateMissingDimensions
     toplevel .dimensions
     grid [button .dimensions.cancel -text Cancel -command "destroy .dimensions"] \
         [button .dimensions.ok -text OK -command {
             set colRows [grid size .dimensions]
             for {set i 2} {$i<[lindex $colRows 1]} {incr i} {
                 set dim [.dimensions.g${i}_dim get]
                 if {$dim!=""} {
                     set d [dimensions.@elem $dim]
                             $d.type [.dimensions.g${i}_type get]
                             if [info exists timeFormatStrings([.dimensions.g${i}_units get])] {
                                 $d.units $timeFormatStrings([.dimensions.g${i}_units get])
                             } else {
                                 $d.units [.dimensions.g${i}_units get]
                             }
                         }
                     }
             imposeDimensions
             destroy .dimensions
             reset
         }]
     grid [label .dimensions.g1_dim -text Dimension] \
         [label .dimensions.g1_type -text Type]\
         [label .dimensions.g1_units -text "Units/Format"]
     tooltip .dimensions.g1_units "Value type: enter a unit string, eg m/s; time type: enter a strftime format string, eg %Y-%m-%d %H:%M:%S, or %Y-Q%Q"
 
     set colRows [grid size .dimensions]
     for {set i [lindex $colRows 1]} {$i<[dimensions.size]+3} {incr i} {
         grid [entry .dimensions.g${i}_dim] \
             [ttk::combobox .dimensions.g${i}_type -state readonly \
                  -values {string value time}] \
             [ttk::combobox .dimensions.g${i}_units \
                  -postcommand "dimFormatPopdown .dimensions.g${i}_units \[.dimensions.g${i}_type get\] {}"
             ]
     }
     set i 2
     foreach dim [dimensions.#keys] {
         set d [dimensions.@elem $dim]
         .dimensions.g${i}_dim delete 0 end
         .dimensions.g${i}_dim insert 0 $dim
         .dimensions.g${i}_type set [$d.type]
         .dimensions.g${i}_units delete 0 end
         .dimensions.g${i}_units insert 0 [$d.units]
         dimFormatPopdown .dimensions.g${i}_units [$d.type] {}
         incr i
     }
 }

Here is the call graph for this function:

◆ dimFormatPopdown()

dimFormatPopdown			comboBox type onSelect

Definition at line 850 of file minsky.tcl.

Referenced by csvImportButton1Up(), dimensionsDialog(), and setDimension().

 proc dimFormatPopdown {comboBox type onSelect} {
     global timeFormatStrings
     switch  $type {
         string {
             $comboBox configure -values {}
             $comboBox set {}
             bind $comboBox <<ComboboxSelected>> $onSelect
         }
         value {
             $comboBox configure -values {}
             bind $comboBox <<ComboboxSelected>> $onSelect
         }
         time {
             $comboBox configure -values [lsort [array names timeFormatStrings]]
             bind $comboBox <<ComboboxSelected>> "rewriteTimeComboBox $comboBox; $onSelect"
         }
     }
 }

Here is the caller graph for this function:

◆ ensureWindowVisible()

ensureWindowVisible			window

Definition at line 934 of file minsky.tcl.

Referenced by addBookMark(), addConstantOrVariable(), editItem(), editVar(), getLogVars(), initRandom(), lockSpecificHandles(), postNote(), setDimension(), setupPickDimMenu(), setupPickMenu(), showPreferences(), and textEntryPopup().

 proc ensureWindowVisible window {
     if {![winfo ismapped $window]} {
         tkwait visibility $window
     }
 }

Here is the caller graph for this function:

◆ exit()

exit

Definition at line 1757 of file minsky.tcl.

References autoBackupName(), save(), and tcl_exit().

Referenced by handleSignal().

 proc exit {} {
     # check if the model has been saved yet
     if {[edited]} {
         switch  [tk_messageBox -message "Save before exiting?" -type yesnocancel] {
             yes save
             no {file delete -- [autoBackupName]}
             cancel {return -level [info level]}
         }
     }
 
 
     # if we have a valid rc file location, write out the directory of
     # the last file loaded
     global rcfile workDir backgroundColour preferences recentFiles
     if {$rcfile!=""} {
         set rc [open $rcfile w]
         puts $rc "set workDir $workDir"
         puts $rc "set canvasWidth [winfo width .wiring.canvas]"
         puts $rc "set canvasHeight [winfo height .wiring.canvas]"
         puts $rc "set backgroundColour $backgroundColour"
         foreach p [array names preferences] {
             puts $rc "set preferences($p) \{$preferences($p)\}"
         }
         puts $rc {minsky.defaultFont $preferences(defaultFont)}
         puts $rc "set recentFiles \{$recentFiles\}"
         close $rc
     }
     # why is this needed?
     proc bgerror x {} 
     tcl_exit
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ exportCanvas()

exportCanvas

Definition at line 646 of file minsky.tcl.

References imageFileTypes(), and renderImage().

 proc exportCanvas {} {
     global workDir type fname preferences tabSurface
 
     set fileTypes [imageFileTypes]
     lappend fileTypes {"LaTeX" .tex TEXT} {"Matlab" .m TEXT}
     set f [tk_getSaveFile -filetypes $fileTypes \
                -initialdir $workDir -typevariable type -initialfile [file rootname [file tail $fname]]]  
     if {$f==""} return
     set workDir [file dirname $f]
     # extract the surface name from the current tab, for #912
     set surf [lindex [.tabs tabs] [.tabs index current]].canvas
     if [renderImage $f $type $tabSurface([.tabs tab current -text])] return
     if {[string match -nocase *.tex "$f"]} {
         latex "$f" $preferences(wrapLaTeXLines)
     } elseif {[string match -nocase *.m "$f"]} {
         matlab "$f"
     } else {
         switch  $type {
             "LaTeX" {latex "$f.tex" $preferences(wrapLaTeXLines)}
             "Matlab" {matlab "$f.m"}
         }
     }
 }

Here is the call graph for this function:

◆ fileTypes()

fileTypes			defaultExtension

Definition at line 1461 of file minsky.tcl.

Referenced by group::save(), save(), saveAs(), and saveSelection().

 proc fileTypes {defaultExtension} {
     if {$defaultExtension==".rvl"} {
         return {{"Ravel" .rvl TEXT} {"Minsky" .mky TEXT} {"All Files" * TEXT}}
     } else {
         return {{"Minsky" .mky TEXT} {"Ravel" .rvl TEXT} {"All Files" * TEXT}}
     }
 }

Here is the caller graph for this function:

◆ generateBookmarkMenu()

generateBookmarkMenu

Definition at line 494 of file minsky.tcl.

 proc generateBookmarkMenu {} {
     .menubar.bookmarks delete 0 end
     .menubar.bookmarks add command -label "Bookmark this position" -command addBookMark
     .menubar.bookmarks.deleteMenu delete 0 end
     .menubar.bookmarks add cascade -label "Delete ..." -menu .menubar.bookmarks.deleteMenu
     .menubar.bookmarks add separator
     set p 0
     foreach i [minsky.canvas.model.bookmarkList] {
         .menubar.bookmarks add command -label $i -command "canvas.model.gotoBookmark $p; canvas.requestRedraw"
         .menubar.bookmarks.deleteMenu add command -label $i -command "canvas.model.deleteBookmark $p"
         incr p
     }
 }

◆ getClipboard()

getClipboard

Definition at line 727 of file minsky.tcl.

Referenced by canvasContext(), godleyContext(), toggleGodleyPaste(), and togglePaste().

 proc getClipboard {} {
     set contents ""
     catch {clipboard get -type UTF8_STRING} contents
     return contents
 }

Here is the caller graph for this function:

◆ getLogVars()

getLogVars

Definition at line 671 of file minsky.tcl.

References ensureWindowVisible(), and pack().

 proc getLogVars {} {
     global varNames allLogVars varIds
     set varNames {}
     set varIds {}
     set allLogVars 0
     toplevel .logVars
     frame .logVars.buttons
     button .logVars.buttons.ok -text OK -command logVarsOK
     checkbutton .logVars.buttons.all -text All -variable allLogVars -command {
         .logVars.selection.selection selection [expr $allLogVars?"set":"clear"] 0 end
     }            
     pack .logVars.buttons.ok .logVars.buttons.all -side left
 
     foreach v [variableValues.#keys] {
         if {![regexp "^constant:" $v]} {
             getValue $v
             lappend varNames [minsky.value.name]
             lappend varIds $v
         }
     }
     frame .logVars.selection
     listbox .logVars.selection.selection -listvariable varNames -selectmode extended -height 30 -yscrollcommand ".logVars.selection.vscroll set" -selectforeground blue
     scrollbar .logVars.selection.vscroll -orient vertical -command ".logVars.selection.selection yview"
     pack .logVars.selection.selection -fill both -side left -expand y
     pack .logVars.selection.vscroll -fill y -side left -expand y
     pack .logVars.buttons .logVars.selection
     
     ensureWindowVisible .logVars
     grab set .logVars
     wm transient .logVars
 }

Here is the call graph for this function:

◆ help()

help			topic

Definition at line 1705 of file minsky.tcl.

References openURL().

Referenced by canvasHelp(), helpFor(), and tk::mac::ShowHelp().

 proc help {topic} {
     global minskyHome externalLabel
     # replace "Introduction" to framed toplevel document
     # TODO - see if it is possible to wrap the deep links with a framed service
     if {$topic=="Introduction"} {
         set URL  "file://$minskyHome/library/help/minsky.html"
     } else {
         set URL  "file://$minskyHome/library/help/minsky$externalLabel($topic)"
     }
     openURL $URL
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ helpContext()

helpContext			x y

Definition at line 1657 of file minsky.tcl.

 proc helpContext {x y} {
     .contextHelp delete 0 end
     .contextHelp add command -label Help -command "helpFor $x $y"
     tk_popup .contextHelp $x $y
 }

◆ helpFor()

helpFor			x y

Definition at line 1664 of file minsky.tcl.

References canvasHelp(), and help().

Referenced by topLevelHelp().

 proc helpFor {x y} {
     global helpTopics
     set win [winfo containing $x $y]
     if {$win==".wiring.canvas"} {
         canvasHelp
     } elseif [info exists helpTopics($win)] {
         help $helpTopics($win)
     } else {
         help Introduction
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ hoverMouseTab()

hoverMouseTab			tabId

Definition at line 990 of file minsky.tcl.

References get_pointer_x(), and get_pointer_y().

 proc hoverMouseTab {tabId} {
     set tab [lindex [.tabs tabs] [.tabs index current]]
     $tabId.displayDelayedTooltip [get_pointer_x $tab.canvas] [get_pointer_y $tab.canvas]
 }

Here is the call graph for this function:

◆ ifDef()

ifDef			var

Definition at line 1845 of file minsky.tcl.

Referenced by addEvent().

 proc ifDef {var} {
     upvar $var v
     if {$v!="??"} {
         return "-$var $v "
     } else {
         return ""
     }
 }

Here is the caller graph for this function:

◆ imageFileTypes()

imageFileTypes

Definition at line 604 of file minsky.tcl.

Referenced by exportCanvas(), exportGodley(), and exportItemAsImg().

 proc imageFileTypes {} {
     global tcl_platform
     set fileTypes {{"SVG" .svg TEXT} {"PDF" .pdf TEXT} {"Postscript" .eps TEXT} {"Portable Network Graphics" .png TEXT}}
     if {$tcl_platform(platform)=="windows"} {lappend fileTypes {"EMF" .emf TEXT}}
     return $fileTypes
 }

Here is the caller graph for this function:

◆ importMDL()

importMDL

Definition at line 1420 of file minsky.tcl.

References newSystem().

 proc importMDL {} {
     global workDir
     newSystem
     set fname [tk_getOpenFile -multiple 1 -filetypes {
         {Vensim {.mdl}} {All {.*}}} -initialdir $workDir]
     eval importVensim $fname
     minsky.model.autoLayout
 }

Here is the call graph for this function:

◆ insertFile()

insertFile

Definition at line 1413 of file minsky.tcl.

 proc insertFile {} {
     global workDir
     set fname [tk_getOpenFile -multiple 1 -filetypes {
         {Minsky {.mky}} {Ravel {.rvl}} {XML {.xml}} {All {.*}}} -initialdir $workDir]
     eval insertGroupFromFile $fname
 }

◆ invokeButton()

invokeButton			button

Definition at line 525 of file minsky.tcl.

References autoRepeatButton().

 proc invokeButton button {
     global buttonPressed
     if {$buttonPressed} {
         $button invoke
         update
         autoRepeatButton $button
     }
 }

Here is the call graph for this function:

◆ invokeOKorCancel()

invokeOKorCancel			window

Definition at line 1520 of file minsky.tcl.

 proc invokeOKorCancel {window} {
     if [string equal [focus] "$window.cancel"] {
             $window.cancel invoke
         } else {
             $window.ok invoke
         }
 }

◆ logVarsOK()

logVarsOK

Definition at line 703 of file minsky.tcl.

 proc logVarsOK {} {
     global workDir varIds
     set indices [.logVars.selection.selection curselection]
     
     foreach i $indices {lappend vars [lindex $varIds $i]}
     logVarList $vars
     destroy .logVars
     openLogFile [tk_getSaveFile -defaultextension .dat -initialdir $workDir]
 }

◆ newSystem()

newSystem

Definition at line 1490 of file minsky.tcl.

References autoBackupName(), deleteSubsidiaryTopLevels(), recentreCanvas(), reset(), and save().

Referenced by importMDL(), openNamedFile(), and replay().

 proc newSystem {} {
     doPushHistory 0
     if {[edited]} {
         switch  [tk_messageBox -message "Save?" -type yesnocancel] {
             yes save
             no {}
             cancel {return -level [info level]}
         }
     }    
     catch {reset}
     clearAllMapsTCL
     pushFlags
     deleteSubsidiaryTopLevels
     clearHistory
     model.setZoom 1
     recentreCanvas
     global fname progName
     set fname ""
     file delete [autoBackupName]
     wm title . "$progName: New System"
     popFlags
     doPushHistory 1
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ okAction()

okAction			okProc window

Definition at line 920 of file minsky.tcl.

References cancelWin().

 proc okAction {okProc window} {
     if [catch $okProc msg] {
         tk_messageBox  -icon error -parent $window -message $msg
         raise $window
         return
     }
     cancelWin $window
 }

Here is the call graph for this function:

◆ openFile()

openFile

Definition at line 1368 of file minsky.tcl.

References openNamedFile().

 proc openFile {} {
     global fname workDir preferences
     set ofname [tk_getOpenFile -multiple 1 -filetypes {
         {Minsky {.mky}} {Ravel {.rvl}} {XML {.xml}} {All {.*}}} -initialdir $workDir]
     if [string length $ofname] {eval openNamedFile $ofname}
 }

Here is the call graph for this function:

◆ openNamedFile()

openNamedFile			ofname

Definition at line 1379 of file minsky.tcl.

References autoBackupName(), newSystem(), recentreCanvas(), and setFname().

Referenced by tk::mac::OpenDocument(), and openFile().

 proc openNamedFile {ofname} {
     global fname workDir preferences
     newSystem
     setFname $ofname
     
     if {[file exists [autoBackupName]] && [tk_messageBox -message "Auto save file exists, do you wish to load it" -type yesno]=="yes"} {
         eval minsky.load {[autoBackupName]}
     } else {
         eval minsky.load {$ofname}
         file delete -- [autoBackupName]
     }
     # setting simulationDelay causes the edited (dirty) flag to be set, amongst other things
     pushFlags
     doPushHistory 0
     setAutoSaveFile [autoBackupName]
 
     # minsky.load resets minsky.multipleEquities and other preference, so restore preferences
     minsky.multipleEquities $preferences(multipleEquities)
     setGodleyDisplayValue $preferences(godleyDisplay) $preferences(godleyDisplayStyle)
 
     recentreCanvas
 
    .controls.simSpeed set [simulationDelay]
     # force update canvas size to ensure model is displayed correctly
     update
     canvas.requestRedraw
     # not sure why this is needed, but initial draw doesn't happen without it
     event generate .wiring.canvas <Expose>
     update
     doPushHistory 1
     pushHistory
     popFlags
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ openURL()

openURL			URL

Definition at line 1686 of file minsky.tcl.

Referenced by help().

 proc openURL {URL} {
     global tcl_platform
     if {[tk windowingsystem]=="win32"} {
         shellOpen $URL
     } elseif {$tcl_platform(os)=="Darwin"} {
         exec open $URL
     } elseif [catch {exec xdg-open $URL &}] {
         # try a few likely suspects
         foreach browser {firefox konqueror seamonkey opera} {
             set browserNotFound [catch {exec $browser $URL &}]
             if {!$browserNotFound} break
         }
         if $browserNotFound {
             tk_messageBox -detail "Unable to find a working web browser, 
 please consult $URL" -type ok -icon warning
         }
     }
 }

Here is the caller graph for this function:

◆ panCanvas()

panCanvas			offsx offsy

Definition at line 1084 of file minsky.tcl.

References setScrollBars().

Referenced by findDefinition(), and scrollCanvases().

 proc panCanvas {offsx offsy} {
     global preferences
     switch  [lindex [.tabs tabs] [.tabs index current]] {
         .wiring {
             minsky.canvas.model.moveTo $offsx $offsy
             canvas.requestRedraw
         }
         .equations {
             equationDisplay.offsx $offsx
             equationDisplay.offsy $offsy
             equationDisplay.requestRedraw
         }
         .parameters {
             parameterTab.offsx $offsx
             parameterTab.offsy $offsy                      
             parameterTab.requestRedraw
         }        
         .variables {
             variableTab.offsx $offsx
             variableTab.offsy $offsy                                               
             variableTab.requestRedraw
         }           
         .plts {
             plotTab.offsx $offsx
             plotTab.offsy $offsy   
             plotTab.requestRedraw
         }         
         .gdlys {
             godleyTab.offsx $offsx
             godleyTab.offsy $offsy 
             godleyTab.requestRedraw
         }             
     }
     setScrollBars
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pasteAt()

pasteAt

Definition at line 869 of file minsky.tcl.

References get_pointer_x(), and get_pointer_y().

 proc pasteAt {} {
     minsky.paste
     canvas.mouseMove [get_pointer_x .wiring.canvas] [get_pointer_y .wiring.canvas]
 }

Here is the call graph for this function:

◆ populateRecentFiles()

populateRecentFiles

Definition at line 1353 of file minsky.tcl.

Referenced by setFname().

 proc populateRecentFiles {} {
     global recentFiles preferences
     .menubar.file.recent delete 0 end
     if {[llength $recentFiles]>$preferences(nRecentFiles)} {
         set recentFiles [lreplace $recentFiles $preferences(nRecentFiles) end]
     }
     foreach f $recentFiles {
         .menubar.file.recent insert 0 command -label "[file tail $f]" \
             -command "openNamedFile \"[regsub -all {\\} $f /]\""
     }
 }

Here is the caller graph for this function:

◆ recentreCanvas()

recentreCanvas

Definition at line 1430 of file minsky.tcl.

Referenced by newSystem(), openNamedFile(), and startRecording().

 proc recentreCanvas {} {
     switch  [lindex [.tabs tabs] [.tabs index current]] {
         .wiring {canvas.recentre}
         .equations {
             equationDisplay.offsx 0
             equationDisplay.offsy 0
             equationDisplay.requestRedraw
         }
         .parameters {
             parameterTab.offsx 0
             parameterTab.offsy 0
             parameterTab.requestRedraw
         }
         .variables {
             variableTab.offsx 0
             variableTab.offsy 0
             variableTab.requestRedraw
         }       
         .plts {
             plotTab.offsx 0
             plotTab.offsy 0
             plotTab.requestRedraw
         }               
         .gdlys {
             godleyTab.offsx 0
             godleyTab.offsy 0
             godleyTab.requestRedraw
         }                    
     }
 }

Here is the caller graph for this function:

◆ renderImage()

renderImage			filename type surf

Definition at line 621 of file minsky.tcl.

Referenced by exportCanvas(), exportGodley(), and exportItemAsImg().

 proc renderImage {filename type surf} {
     global tcl_platform
     if [string match -nocase *.svg "$filename"] {
         $surf.renderToSVG "$filename"
     } elseif [string match -nocase *.pdf "$filename"] {
         $surf.renderToPDF "$filename"
     } elseif {[string match -nocase *.ps "$filename"] || [string match -nocase *.eps "$filename"]} {
         $surf.renderToPS "$filename"
     } elseif {[string match -nocase *.png "$filename"]} {
         $surf.renderToPNG "$filename"
     } elseif {$tcl_platform(platform)=="windows" && [string match -nocase *.emf "$filename"]} {
         $surf.renderToEMF "$filename"
     } else {
         switch  $type {
             "SVG" {$surf.renderToSVG  "$filename.svg"}
             "PDF" {$surf.renderToPDF "$filename.pdf"}
             "PNG" {$surf.renderToPNG "$filename.png"}
             "EMF" {$surf.renderToEMF "$filename.emf"}
             "Postscript" {$surf.renderToPS "$filename.eps"}
             default {return false}
         }
     }
     return true
 }

Here is the caller graph for this function:

◆ replay()

replay

Definition at line 1897 of file minsky.tcl.

References newSystem(), runstop(), and stopRecording().

 proc replay {} {
     global recordingReplay eventRecordR workDir eventRecording
     if $eventRecording {stopRecording; set eventRecording 0}
     if {$recordingReplay} {
         # ensures consistent IDs are allocated
         set fname [tk_getOpenFile -filetypes {{"TCL scripts" .tcl TEXT} {"All Files" * }} \
                        -defaultextension .tcl -initialdir $workDir]
         if {[string length $fname]>0} {
             set eventRecordR [eval open {$fname} r]
             newSystem
             if {![running]} runstop
         } else {
             if [running] {runstop}
             set recordingReplay 0
         }
     } 
 }

Here is the call graph for this function:

◆ reset()

reset

Definition at line 1325 of file minsky.tcl.

References stopRecording().

Referenced by minsky::Optional< minsky::ShowSlice >::assign(), csvImportDialogOK(), doubleButton(), minsky::EvalOpPtr::EvalOpPtr(), minsky::Minsky::load(), newSystem(), minsky::Optional< minsky::ShowSlice >::operator*(), minsky::Minsky::requestReset(), minsky::Minsky::resetIfFlagged(), minsky::VariablePtr::retype(), and minsky::anonymous_namespace{addon.cc}::AddOnMinsky::run().

 proc reset {} {
     global recordingReplay eventRecordR simLogging eventRecording
     if {$eventRecording} {
         set eventRecording 0
         stopRecording
         return
     }
     running 0
     if {$recordingReplay} {
         seek $eventRecordR 0 start
         model.clear
         canvas.requestRedraw
     } else {
         set tstep 0
         set simLogging 0
         closeLogFile
         # delay throwing exception to allow display to be updated
         set err [catch minsky.reset result]
         .controls.statusbar configure -text "t: 0 Δt: 0"
         .controls.run configure -image runButton
 
         redrawAllGodleyTables
         return -code $err $result
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rewriteTimeComboBox()

rewriteTimeComboBox			comboBox

Definition at line 842 of file minsky.tcl.

 proc rewriteTimeComboBox {comboBox} {
     global timeFormatStrings
     if [info exists timeFormatStrings([$comboBox get])] {
         $comboBox set $timeFormatStrings([$comboBox get])
     }
 }

◆ runstop()

runstop

Definition at line 1266 of file minsky.tcl.

References simulate(), and step().

Referenced by replay(), and step().

 proc runstop {} {
     global classicMode
     if [running] {
         running 0
         doPushHistory 1
         if {$classicMode} {
             .controls.run configure -text run
         } else {
             .controls.run configure -image runButton
         }
     } else {
         running 1
         doPushHistory 0
         if {$classicMode} {
             .controls.run configure -text stop
         } else {
             .controls.run configure -image stopButton
         }
         step
         simulate
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ save()

save

Definition at line 1469 of file minsky.tcl.

References autoBackupName(), fileTypes(), and setFname().

Referenced by exit(), newSystem(), minsky::anonymous_namespace{addon.cc}::AddOnMinsky::outOfMemoryHandler(), and saveAs().

 proc save {} {
     global fname workDir
     set ext [minsky.model.defaultExtension]
     if {![string length $fname]} {
         setFname [tk_getSaveFile -defaultextension $ext  -initialdir $workDir \
                       -filetypes [fileTypes $ext]]}            
     if [string length $fname] {
         set workDir [file dirname $fname]
         eval minsky.save {$fname}
         file delete -- [autoBackupName]
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ saveAs()

saveAs

Definition at line 1482 of file minsky.tcl.

References fileTypes(), save(), and setFname().

 proc saveAs {} {
     global fname workDir
     set ext [minsky.model.defaultExtension]
     setFname [tk_getSaveFile -defaultextension $ext  -initialdir $workDir \
                   -filetypes [fileTypes $ext]]            
     if [string length $fname] save
 }

Here is the call graph for this function:

◆ scrollCanvases()

scrollCanvases			xyview args

Definition at line 1122 of file minsky.tcl.

References panCanvas().

 proc scrollCanvases {xyview args} {
     set win [lindex [.tabs tabs] [.tabs index current]]
     set ww [winfo width $win]
     set wh [winfo height $win]
     switch  $win {
         .wiring {
             set x [minsky.canvas.model.x]
             set y [minsky.canvas.model.y]
             set w [expr 10*$ww]
             set h [expr 10*$wh]
             set x1 [expr 0.5*$w]
             set y1 [expr 0.5*$h]
         }
         .equations {
             set x [equationDisplay.offsx]
             set y [equationDisplay.offsy]
             set x1 0
             set y1 0
             set w [equationDisplay.width]
             set h [equationDisplay.height]
         }
         .parameters {
             set x [parameterTab.offsx]
             set y [parameterTab.offsy]
             set w [expr 10*$ww]
             set h [expr 10*$wh]
             set x1 [expr 0.5*$w]
             set y1 [expr 0.5*$h]       
         }
         .variables {
             set x [variableTab.offsx]
             set y [variableTab.offsy]
             set w [expr 10*$ww]
             set h [expr 10*$wh]
             set x1 [expr 0.5*$w]
             set y1 [expr 0.5*$h]
         }                
         .plts {
             set x [plotTab.offsx]
             set y [plotTab.offsy]
             set w [expr 10*$ww]
             set h [expr 10*$wh]
             set x1 [expr 0.5*$w]
             set y1 [expr 0.5*$h]
         }
         .gdlys {
             set x [godleyTab.offsx]
             set y [godleyTab.offsy]
             set w [expr 10*$ww]
             set h [expr 10*$wh]
             set x1 [expr 0.5*$w]
             set y1 [expr 0.5*$h]
         }                      
     }
     switch  [lindex $args 0] {
         moveto {
             switch  $xyview {
                 xview {panCanvas [expr $x1-$w*[lindex $args 1]] $y}
                 yview {panCanvas $x [expr $y1-$h*[lindex $args 1]]}
             }
         }
         scroll {
             switch  [lindex $args 2] {
                 units {set incr [expr [lindex $args 1]*0.01]}
                 # page corresponds to one full screens worth
                 pages {set incr [expr [lindex $args 1]*0.1]}
             }
             switch  $xyview {
                 xview {panCanvas [expr $x-$incr*$w] $y}
                 yview {panCanvas $x [expr $y-$incr*$h]}
             }
         }
     }
 }

Here is the call graph for this function:

◆ setBackgroundColour()

setBackgroundColour			bgc

Definition at line 189 of file minsky.tcl.

 proc setBackgroundColour bgc {
     global backgroundColour
     set backgroundColour $bgc
     tk_setPalette $bgc
     # tk_setPalette doesn't understand ttk widgets
     ttk::style configure TNotebook -background $backgroundColour
     ttk::style configure TNotebook.Tab -background $backgroundColour
     ttk::style map TNotebook.Tab -background "selected $bgc active $bgc"
     if [winfo exists .controls.runmode] {.controls.runmode configure -selectcolor $bgc}
 }

◆ setCursor()

setCursor			cur

Definition at line 151 of file minsky.tcl.

151 proc setCursor {cur} {}

◆ setExportResolutionFactor()

setExportResolutionFactor			setter

Definition at line 611 of file minsky.tcl.

References buttonBar(), and pack().

 proc setExportResolutionFactor {setter} {
     toplevel .resolutionFactor
     wm title .resolutionFactor "Export resolution scale factor"
     ttk::spinbox .resolutionFactor.value -from 1 -to 1000 -increment 1
     pack .resolutionFactor.value
     .resolutionFactor.value set [$setter.resolutionScaleFactor]
     buttonBar .resolutionFactor "$setter.resolutionScaleFactor \[.resolutionFactor.value get\]"
 }

Here is the call graph for this function:

◆ setFname()

setFname			name

Definition at line 92 of file minsky.tcl.

References populateRecentFiles().

Referenced by openNamedFile(), save(), and saveAs().

 proc setFname {name} {
     global fname workDir progName
     if [string length $name] {
         set fname $name
         set workDir [file dirname $name]
         catch {wm title . "$progName: $fname"}
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setPreferenceParms()

setPreferenceParms

Definition at line 1595 of file minsky.tcl.

References setGodleyDisplay().

 proc setPreferenceParms {} {
     global preferencesVars preferences preferences_input
 
     foreach var [array names preferences_input] {
    set preferences($var) $preferences_input($var)
     }
     defaultFont $preferences(defaultFont)
     multipleEquities $preferences(multipleEquities)
     setGodleyDisplay
     if {$preferences(focusFollowsMouse)} {
         tk_focusFollowsMouse
    # Make tab traversal possible within a window that is given focus by only clicking on it (no focusFollowsMouse). For ticket 901.
     } else {
        set old [bind all <Enter>]
        set script {
       if {"%d" eq "NotifyAncestor" || "%d" eq "NotifyNonlinear" \
            || "%d" eq "NotifyInferior"} {
              tk::FocusOK %W        
           }
        }
        if {$old ne ""} {
       bind all <Enter> "$old; $script"
        } else {
       bind all <Enter> $script
        }
     }
 }

Here is the call graph for this function:

◆ setRKparms()

setRKparms

Definition at line 1585 of file minsky.tcl.

 proc setRKparms {} {
     global rkVars rkVarInput
     foreach {var text} $rkVars { $var $rkVarInput($var)}
 }

◆ setScrollBars()

setScrollBars

Definition at line 1037 of file minsky.tcl.

Referenced by panCanvas().

 proc setScrollBars {} {
     switch  [lindex [.tabs tabs] [.tabs index current]] {
         .wiring {
             set x0 [expr (10000-[minsky.canvas.model.x])/20000.0]
             set y0 [expr (10000-[minsky.canvas.model.y])/20000.0]
             .hscroll set $x0 [expr $x0+[winfo width .wiring.canvas]/20000.0]
             .vscroll set $y0 [expr $y0+[winfo height .wiring.canvas]/20000.0]
         }
         .equations {
             if {[equationDisplay.width]>0} {
                 set x0 [expr [equationDisplay.offsx]/[equationDisplay.width]]
                 .hscroll set $x0 [expr $x0+[winfo width .wiring.canvas]/[equationDisplay.width]]
             } else {.hscroll set 0 1}
             if {[equationDisplay.height]>0} {
                 set y0 [expr [equationDisplay.offsx]/[equationDisplay.height]]
                 .vscroll set $y0 [expr $y0+[winfo height .wiring.canvas]/[equationDisplay.height]]
             } else {.vscroll set  0 1}
         }
         .parameters {
             set x0 [expr (10000-[parameterTab.offsx])/20000.0]
             set y0 [expr (10000-[parameterTab.offsy])/20000.0]       
             .hscroll set $x0 [expr $x0+[winfo width .parameters.canvas]/20000.0]
             .vscroll set $y0 [expr $y0+[winfo height .parameters.canvas]/20000.0]           
            }      
         .variables {
             set x0 [expr (10000-[variableTab.offsx])/20000.0]
             set y0 [expr (10000-[variableTab.offsy])/20000.0]
             .hscroll set $x0 [expr $x0+[winfo width .variables.canvas]/20000.0]
             .vscroll set $y0 [expr $y0+[winfo height .variables.canvas]/20000.0]                 
         }
         .plts {
             set x0 [expr (10000-[plotTab.offsx])/20000.0]
             set y0 [expr (10000-[plotTab.offsy])/20000.0]
             .hscroll set $x0 [expr $x0+[winfo width .plts.canvas]/20000.0]
             .vscroll set $y0 [expr $y0+[winfo height .plts.canvas]/20000.0]           
         }  
         .gdlys {
             set x0 [expr (10000-[godleyTab.offsx])/20000.0]
             set y0 [expr (10000-[godleyTab.offsy])/20000.0]
             .hscroll set $x0 [expr $x0+[winfo width .gdlys.canvas]/20000.0]
             .vscroll set $y0 [expr $y0+[winfo height .gdlys.canvas]/20000.0]           
         }                         
     }
 }

Here is the caller graph for this function:

◆ setSimulationDelay()

setSimulationDelay			delay

Definition at line 538 of file minsky.tcl.

 proc setSimulationDelay {delay} {
     # on loading a model, slider is adjusted, which causes
     # simulationDelay to be set unnecessarily, marking the model
     # dirty
     if {$delay != [simulationDelay]} {
         pushFlags
         simulationDelay $delay
         popFlags
     }
 }

◆ showPreferences()

showPreferences

Definition at line 333 of file minsky.tcl.

References deiconify(), ensureWindowVisible(), and pack().

Referenced by tk::mac::ShowPreferences().

 proc showPreferences {} {
     if [winfo exists .preferencesForm] return
     global preferences_input preferences preferencesVars
     foreach var [array names preferences] {
    set preferences_input($var) $preferences($var)
     }
 
     toplevel .preferencesForm
     wm resizable .preferencesForm 0 0
     
     set row 0
     
     grid [label .preferencesForm.label$row -text "Preferences"] -column 1 -columnspan 999 -pady 10
     incr row 10
 
     # pad the left and right
     grid [frame .preferencesForm.f1] -column 1 -row 1 -rowspan 999 -padx 10
     grid [frame .preferencesForm.f2] -column 999 -row 1 -rowspan 999 -padx 10
     
 
     foreach {var text default type} $preferencesVars {
         set rowdict($text) $row
 
         grid [label .preferencesForm.label$row -text $text] -column 10 -row $row -sticky e -pady 5
         
         switch  $type {
             text {
                 grid [entry  .preferencesForm.text$row -width 20 -textvariable preferences_input($var)] -column 20 -row $row -sticky ew -columnspan 999
             }
             bool {
                 grid [checkbutton .preferencesForm.cb$row -variable preferences_input($var)] -row $row -column 20 -sticky w
             }
             font {
                 grid [ttk::combobox .preferencesForm.font -textvariable preferences_input($var) -values [lsort [listFonts]] -state readonly] -row $row -column 20 -sticky w
                 image create cairoSurface fontSampler -surface minsky.fontSampler
                 grid [label .preferencesForm.fontSample -image fontSampler -width 150 -height 20] -row $row -column 30 -sticky w
                 bind .preferencesForm.font <<ComboboxSelected>> {
                     defaultFont [.preferencesForm.font get]
                     fontSampler.requestRedraw
                     canvas.requestRedraw
                 }
             }
             default {
                 if {[llength $type] > 1} {
                     switch  [lindex $type 0] {
                         enum {
                             set column 20
                             foreach {valtext val} [lrange $type 1 end] {
                                 grid [radiobutton .preferencesForm.rb${row}v$column  -text $valtext -variable preferences_input($var) -value $val] -row $row -column $column
                                 incr column 
                             }
                         }
                     }
                 } else { error "unknown preferences widget $type"}
             }
         }
         
         incr row 10
     }
     
     set preferences(initial_focus) ".preferencesForm.cb$rowdict(Godley Table Show Values)"
     
     frame .preferencesForm.buttonBar
     button .preferencesForm.buttonBar.ok -text OK -command {setPreferenceParms; closePreferencesForm; redrawAllGodleyTables}
     button .preferencesForm.buttonBar.cancel -text cancel -command {closePreferencesForm}
     pack .preferencesForm.buttonBar.ok [label .preferencesForm.buttonBar.spacer -width 2] .preferencesForm.buttonBar.cancel -side left -pady 10
     grid .preferencesForm.buttonBar -column 1 -row 999 -columnspan 999
     
     bind .preferencesForm <Key-Return> {invokeOKorCancel .preferencesForm.buttonBar}
 
     wm title .preferencesForm "Preferences"
 
     deiconify .preferencesForm
     update idletasks
     ::tk::TabToWindow $preferences(initial_focus)
     ensureWindowVisible .preferencesForm
     grab set .preferencesForm
     wm transient .preferencesForm .
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ simulate()

simulate

Definition at line 1311 of file minsky.tcl.

Referenced by runstop().

 proc simulate {} {
     uplevel #0 {
         if [running] {
               set d [expr int(pow(10,$delay/4.0))]
               after $d {
                   if [running] {
                       step
                       simulate
                   }
               }
         }
     }
 }

Here is the caller graph for this function:

◆ startRecording()

startRecording			filename

Definition at line 1867 of file minsky.tcl.

References recentreCanvas().

Referenced by toggleRecording().

 proc startRecording {filename} {
     if {[string length $filename]>0} {
         minsky.startRecording $filename
         recentreCanvas
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ step()

step

Definition at line 1289 of file minsky.tcl.

References runstop().

Referenced by minsky::VariableValue::incrSlider(), and runstop().

 proc step {} {
     global recordingReplay eventRecordR simTMax simTStart
     if {$recordingReplay} {
         if {[gets $eventRecordR cmd]>=0} {
             eval $cmd
             update
         } else {
             runstop
         }
     } else {
         # run simulation
         global preferences
         if {[catch minsky.step errMsg options] && [running]} {runstop}
         if {[minsky.t0]>[t] || [minsky.tmax]<[t]} {runstop}
         .controls.statusbar configure -text "t: [t] Δt: [format %g [deltaT]]"
         if $preferences(godleyDisplay) redrawAllGodleyTables
         update
         return -options $options $errMsg
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ stopRecording()

stopRecording

Definition at line 1874 of file minsky.tcl.

Referenced by replay(), reset(), and toggleRecording().

 proc stopRecording {} {
     minsky.stopRecording
 }

Here is the caller graph for this function:

◆ tabContext()

tabContext			x y X Y

Definition at line 1003 of file minsky.tcl.

 proc tabContext {x y X Y} {
        switch  [lindex [.tabs tabs] [.tabs index current]] {
            .variables {    
                .variables.context delete 0 end     
                set r [variableTab.rowY $y]         
                switch  [variableTab.clickType $x $y] {     
                    background {}   
                    internal {      
                            set varName [variableTab.getVarName $r] 
                            .variables.context add command -label "Remove $varName from tab" -command "variableTab.toggleVarDisplay $r;  variableTab.requestRedraw" 
                    }       
                }   
                tk_popup .variables.context $X $Y   
        }
        .plts {
                    .plts.context delete 0 end
                    if [getPlotTabItemAt $x $y] {
                            .plts.context add command -label "Remove plot from tab" -command "plotTab.togglePlotDisplay;  plotTab.requestRedraw"
                    }
             tk_popup .plts.context $X $Y
            }               
    }
 }

◆ tcl_exit()

tcl_exit			args

Definition at line 141 of file minsky.tcl.

Referenced by exit().

     proc tcl_exit {args} {
         # disable coverage testing
         proc traceProc {args} {}
         cov.close
         eval tcl_exit2 $args
     }

Here is the caller graph for this function:

◆ textEntryPopup()

textEntryPopup			win init okproc

Definition at line 944 of file minsky.tcl.

References buttonBar(), ensureWindowVisible(), and pack().

Referenced by renameIntegralInstances(), renameVariableInstances(), and textInput().

 proc textEntryPopup {win init okproc} {
     if {![winfo exists $win]} {
         toplevel $win
         entry $win.entry
         pack $win.entry -side top -ipadx 50
         buttonBar $win $okproc
     } else {
         wm deiconify $win
     }
     $win.entry delete 0 end
     $win.entry insert 0 $init
     wm transient $win
     focus $win.entry
     ensureWindowVisible $win
     grab set $win
     
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ tk_focusNext()

tk_focusNext			win

Definition at line 207 of file minsky.tcl.

207 proc tk_focusNext {win} {return $win}

◆ tk_focusPrev()

tk_focusPrev			win

Definition at line 206 of file minsky.tcl.

206 proc tk_focusPrev {win} {return $win}

◆ toggleImplicitSolver()

toggleImplicitSolver

Definition at line 1514 of file minsky.tcl.

 proc toggleImplicitSolver {} {
     global implicitSolver
     implicit $implicitSolver
 }

◆ togglePaste()

togglePaste

Definition at line 739 of file minsky.tcl.

References getClipboard().

 proc togglePaste {} {
     if {[getClipboard]==""} {
    .menubar.edit entryconfigure "Paste" -state disabled
     } else {
    .menubar.edit entryconfigure "Paste" -state normal
     }
 }

Here is the call graph for this function:

◆ toggleRecording()

toggleRecording

Definition at line 1878 of file minsky.tcl.

References startRecording(), and stopRecording().

 proc toggleRecording {} {
     global eventRecording workDir
     if $eventRecording {
         startRecording [tk_getSaveFile -filetypes {{"TCL scripts" .tcl TEXT} {"All Files" * }}\
                             -defaultextension .tcl -initialdir $workDir]
     } else {
         stopRecording
     }
 }

Here is the call graph for this function:

◆ topLevelHelp()

topLevelHelp

Definition at line 1652 of file minsky.tcl.

References helpFor().

 proc topLevelHelp {} {
     helpFor [winfo pointerx .] [winfo pointery .]
 }

Here is the call graph for this function:

◆ traceProc()

traceProc			args

Definition at line 125 of file minsky.tcl.

 proc traceProc {args} {
     array set frameInfo [info frame -2]
     if  {[info exists frameInfo(proc)]&&[info exists frameInfo(line)]} {
         cov.add $frameInfo(proc) $frameInfo(line)
     }
     if  {[info exists frameInfo(file)]&&[info exists frameInfo(line)]} {
         cov.add $frameInfo(file) $frameInfo(line)
     }
 }

◆ undo()

undo			delta

Definition at line 747 of file minsky.tcl.

References deleteSubsidiaryTopLevels().

 proc undo {delta} {
     # do not record changes to state from the undo command
     doPushHistory 0
     minsky.undo $delta
     minsky.canvas.requestRedraw
     deleteSubsidiaryTopLevels
     doPushHistory 1
 }

Here is the call graph for this function:

◆ unknown()

unknown			procname args

Definition at line 1818 of file minsky.tcl.

 proc unknown {procname args} {
     #delegate in case a getter hasn't correctly called its get
     global getters
     if [regexp ^wiringGroup\. $procname] {
         # delegate to minsky (ie global group)
         eval [regsub ^wiringGroup $procname minsky] $args
     } elseif [regexp ^([join $getters |])\. $procname] {
         eval wiringGroup.$procname $args
     } else {
         eval ecolab_unknown $procname $args
     }
 }

◆ value.value()

value.value			args

Definition at line 105 of file minsky.tcl.

Referenced by editVar().

 proc value.value {args} {
     if [llength $args] {
         return [minsky.value.value [lindex $args 0]]
     } else {
         return [minsky.value.value 0]
     }
 }

Here is the caller graph for this function:

◆ wrapHoverMouseTab()

wrapHoverMouseTab			tabId op x y

Definition at line 996 of file minsky.tcl.

 proc wrapHoverMouseTab {tabId op x y} {
     after cancel hoverMouseTab $tabId
     # ignore any exceptions
     catch {$tabId.$op $x $y}
     after 3000 hoverMouseTab $tabId
 }

Namespaces

Functions

Function Documentation

◆ aboutMinsky()

◆ addBookMark()

◆ addEvent()

◆ addTab()

◆ attachTraceProc()

◆ autoBackupName()

◆ autoRepeatButton()

◆ bgerror()

◆ buttonBar()

◆ cancelWin()

◆ canvasHelp()

◆ checkRecordingVersion()

◆ closePreferencesForm()

◆ closeRKDataForm()

◆ cut()

◆ deiconify()

◆ deiconifyRKDataForm()

◆ deleteSubsidiaryTopLevels()

◆ dimensionsDialog()

◆ dimFormatPopdown()

◆ ensureWindowVisible()

◆ exit()

◆ exportCanvas()

◆ fileTypes()

◆ generateBookmarkMenu()

◆ getClipboard()

◆ getLogVars()

◆ help()

◆ helpContext()

◆ helpFor()

◆ hoverMouseTab()

◆ ifDef()

◆ imageFileTypes()

◆ importMDL()

◆ insertFile()

◆ invokeButton()

◆ invokeOKorCancel()

◆ logVarsOK()

◆ newSystem()

◆ okAction()

◆ openFile()

◆ openNamedFile()

◆ openURL()

◆ panCanvas()

◆ pasteAt()

◆ populateRecentFiles()

◆ recentreCanvas()

◆ renderImage()

◆ replay()

◆ reset()

◆ rewriteTimeComboBox()

◆ runstop()

◆ save()

◆ saveAs()

◆ scrollCanvases()

◆ setBackgroundColour()

◆ setCursor()

◆ setExportResolutionFactor()

◆ setFname()

◆ setPreferenceParms()

◆ setRKparms()

◆ setScrollBars()

◆ setSimulationDelay()

◆ showPreferences()

◆ simulate()

◆ startRecording()

◆ step()

◆ stopRecording()

◆ tabContext()

◆ tcl_exit()

◆ textEntryPopup()

◆ tk_focusNext()

◆ tk_focusPrev()

◆ toggleImplicitSolver()

◆ togglePaste()

◆ toggleRecording()

◆ topLevelHelp()