home *** CD-ROM | disk | FTP | other *** search
/ Internet File Formats / InternetFileFormatsCD.bin / text / latex / mac / alpha60.hqx / Tcl / SystemCode / latexMacros.tcl < prev    next >
Encoding:
Text File  |  1995-07-09  |  85.1 KB  |  2,962 lines
  1. #############################################################################
  2. #############################################################################
  3. #
  4. # latexMacros.tcl (called from latex.tcl)
  5. #
  6. #############################################################################
  7. #
  8. # Author:  Tom Scavo (trscavo@syr.edu)
  9. #
  10. #############################################################################
  11. #############################################################################
  12.  
  13. #############################################################################
  14. # 
  15. # Basic Commands
  16. #
  17. #############################################################################
  18.  
  19. proc typeset {} {
  20.     global texPath PREFS TeXmodeVars
  21.     
  22.     # Initialization:
  23.     foreach flag {isOzTeX isTextures isCMacTeX isDirectTeX isDirectTeXPro} {
  24.         set $flag 0
  25.     }
  26.     set currentWin [lindex [winNames -f] 0]
  27.     set currentDir [file dirname $currentWin]
  28.     set currentDoc [file tail $currentWin]
  29.     set docBasename [file rootname $currentDoc]
  30.     set docExtension [file extension $currentDoc]
  31.     
  32.     # Is the window untitled or dirty?
  33.     if {[string match $currentWin $currentDoc]} {
  34.         case [askyesno -c "Save \"$currentDoc\"?"] in {
  35.             "yes" {
  36.                 if {[catch {set currentWin [saveAs "Untitled\.tex"]}]} then {return}
  37.             }
  38.             "no" {
  39.                 if {[regexp {<(.*)>} $currentDoc dummy num]} {
  40.                     set tmpFilename "Untitled$num\.tex"
  41.                 } else {
  42.                     set tmpFilename "Untitled\.tex"
  43.                 }
  44.                 set text [getText 0 [maxPos]]
  45.                 set newDoc "$PREFS:$tmpFilename"
  46.                 message "Saving $newDoc..."
  47.                 set fd [open $newDoc "w"]
  48.                 puts $fd $text
  49.                 close $fd
  50.                 set currentWin $newDoc
  51.             }
  52.             "cancel" {return}
  53.         }
  54.     } elseif {[winDirty]} {
  55.         case [askyesno -c "Save \"$currentDoc\"?"] in {
  56.             "yes" {save}
  57.             "no" {
  58.                 set text [getText 0 [maxPos]]
  59.                 set newDoc "$PREFS:temp-$currentDoc"
  60.                 message "Saving $newDoc..."
  61.                 set fd [open $newDoc "w"]
  62.                 puts $fd $text
  63.                 close $fd
  64.                 set currentWin $newDoc
  65.             }
  66.             "cancel" {return}
  67.         }
  68.     }
  69.     
  70.     # Check if a TeX app is running.  If not, open the app named in 
  71.     # $texPath (if defined) or have the user select an app via a
  72.     # standard file dialog.  Leave the TeX app in the background.
  73.     set appName [checkRunning TeX {OTEX *TEX *XeT MPS* TeX+} texPath 0]
  74.     
  75.     if {[string match {OzTeX*} $appName]} {
  76.         set isOzTeX 1
  77.     } elseif {[string match {Euro-OzTeX*} $appName]} {
  78.         set isOzTeX 1
  79.     } elseif {[string match {Textures*} $appName]} {
  80.         set isTextures 1
  81.     } elseif {[string match {DirectTeX*} $appName]} {
  82.         set isDirectTeXPro 1
  83.     } elseif {[string match {*tex} $appName]} {
  84.         set isCMacTeX 1
  85.     } elseif {[string match {MPW*} $appName]} {
  86.         set isDirectTeX 1
  87.     } else {
  88.         alertnote "Sorry, I don't know how to talk to \"$appName\"."
  89.         return
  90.     }
  91.     
  92.     # Conditionally bring the TeX app to the foreground:
  93.     if {$TeXmodeVars(runTeXInBackground) == 0} { switchTo $appName }
  94.     
  95.     # Typeset the document:
  96.     if {$isOzTeX} {
  97.         sendOpenEvent -n $appName $currentWin
  98.     } elseif {$isTextures} {
  99.         # Choose one of the following three options:
  100.         # dosc -c '*TEX' -s [getText 0 [maxPos]] -r
  101.         # sendOpenEvent -n $appName $currentWin
  102.         dosc -c '*TEX' -f [lindex [winNames -f] 0] -r
  103.     } elseif {$isDirectTeXPro} {
  104.         dosc -c 'TeX+' -s "ProjectMgr -t LaTeX \"$currentWin\"; SelectApp; MenuCommand 1 4"
  105.     } elseif {$isCMacTeX} {
  106.         dosc -n $appName -k 'aevt' -e 'odoc' -r -f $currentWin
  107.     } elseif {$isDirectTeX} {
  108.         set script "Begin; ChangeTeXProject '$currentWin' -check -confirm || Exit 0;\
  109.                       Execute \"{dt_TeXProject}\"; TeXMenu -tex -formats; End ╖ Dev:Null;\
  110.                       RunSession 1 ╖ Dev:Null"
  111.         dosc -r -n $appName -s $script
  112.     }
  113. }
  114.  
  115.  
  116. #--------------------------------------------------------------------------
  117. # Goto:
  118. #--------------------------------------------------------------------------
  119.  
  120. # Switch to (but don't execute) any of the following applications.
  121. proc latex {} {
  122.     global texPath
  123.     if {![catch {getFileSig $texPath} sig]} {
  124.         set appName [checkRunning TeX $sig texPath]
  125.     } else {
  126.         set appName [checkRunning TeX {OTEX *TEX *XeT MPS* TeX+} texPath]
  127.     }
  128.     if {[string length $appName] > 0} {
  129.         switchTo $appName
  130.     }
  131. }
  132. proc bibtex {} {
  133.     global bibtexPath
  134.     set appName [checkRunning BibTeX BIBt bibtexPath]
  135.     if {![string length $appName]} return
  136.     switchTo $appName
  137. }
  138. proc makeindex {} {
  139.     global makeindexPath
  140.     set appName [checkRunning MakeIndex Midx makeindexPath]
  141.     if {![string length $appName]} return
  142.     switchTo $appName
  143. }
  144.  
  145. # Find the next or previous environment.  Search forward (or backward, 
  146. # depending on $forward) for either \begin or \end.  If \begin is found, 
  147. # search forward for corresponding \end; otherwise, search backward for 
  148. # corresponding \begin.  Select the found environment, or display an 
  149. # error message if no environment is found.
  150. proc findEnvironment {forward} {
  151.     set searchString1 {^[ \t]*\\begin\{[^\{\}]*\}|\\end\{[^\{\}]*\}[ \t]*\r?}
  152.     set searchPos [getPos]
  153.     if { [isSelection] } then { 
  154.         if { $forward } then {
  155.             set searchPos [selEnd]
  156.         } else {
  157.             set searchPos [expr $searchPos - 1]
  158.         }
  159.     } else {
  160.         if { $forward } then {
  161.             set searchPos [expr $searchPos + 1]
  162.         } else {
  163.             set searchPos [expr $searchPos - 1]
  164.         }
  165.     }
  166.     set searchResult [search -s -f $forward -r 1 -n $searchString1 $searchPos]
  167.     if {[string length $searchResult]} then {
  168.         set begPos [lindex $searchResult 0]
  169.         set endPos [lindex $searchResult 1]
  170.         set searchText [getText $begPos $endPos]
  171.         regexp {\{(.*)\}} $searchText dummy envName
  172.         if {[string match {*begin*} $searchText]} {
  173.             set begEnv $begPos
  174.             append searchString2 {\\end\{} $envName {\}[ \t]*\r?}
  175.             set searchPos $endPos
  176.             set searchResult [search -s -f 1 -r 1 -n $searchString2 $searchPos]
  177.             if {[string length $searchResult]} {
  178.                 set endPos [lindex $searchResult 1]
  179.                 return [list $begPos $endPos]
  180.             } else {
  181.                 return "matching \\end not found"
  182.             }
  183.         } else {
  184.             set endEnv $endPos
  185.             append searchString2 {^[ \t]*\\begin\{} $envName {\}}
  186.             set searchPos $begPos
  187.             set searchResult [search -s -f 0 -r 1 -n $searchString2 $searchPos]
  188.             if {[string length $searchResult]} {
  189.                 set begPos [lindex $searchResult 0]
  190.                 return [list $begPos $endPos]
  191.             } else {
  192.                 return "matching \\begin not found"
  193.             }
  194.         }
  195.     } else {
  196.         if { $forward } then {
  197.             return "next environment not found"
  198.         } else {
  199.             return "previous environment not found"
  200.         }
  201.     }
  202. }
  203.  
  204. proc prevEnvironment {} {
  205.     global searchNoisily
  206.     set findResult [findEnvironment 0]
  207.     if {[llength $findResult] == 2} then {
  208.         goto [lindex $findResult 0]
  209.     } else {
  210.         if {$searchNoisily} {beep}
  211.         message $findResult
  212.     }
  213. }
  214. proc nextEnvironment {} {
  215.     global searchNoisily
  216.     set findResult [findEnvironment 1]
  217.     if {[llength $findResult] == 2} then {
  218.         goto [lindex $findResult 0]
  219.     } else {
  220.         if {$searchNoisily} {beep}
  221.         message $findResult
  222.     }
  223. }
  224. proc prevEnvironmentSelect {} {
  225.     global searchNoisily
  226.     set forward 0
  227.     set findResult [findEnvironment $forward]
  228.     if {[llength $findResult] == 2} then {
  229.         set endPos [lindex $findResult 1]
  230. #         if { [regexp {\r} [lookAt [expr $endPos + 1]]] } then {
  231. #             set endPos [expr $endPos + 1]
  232. #         }
  233.         select [lindex $findResult 0] $endPos
  234.     } else {
  235.         if { $searchNoisily } {beep}
  236.         message $findResult
  237.     }
  238. }
  239. proc nextEnvironmentSelect {} {
  240.     global searchNoisily
  241.     set forward 1
  242.     set findResult [findEnvironment $forward]
  243.     if {[llength $findResult] == 2} then {
  244.         set endPos [lindex $findResult 1]
  245. #         if { [regexp {\r} [lookAt [expr $endPos + 1]]] } then {
  246. #             set endPos [expr $endPos + 1]
  247. #         }
  248.         select [lindex $findResult 0] $endPos
  249.     } else {
  250.         if { $searchNoisily } {beep}
  251.         message $findResult
  252.     }
  253. }
  254.  
  255. # Find a LaTeX command in either direction.  It's up to the calling
  256. # procedure to pass the correct starting position of the search.
  257. proc findCommand {pos direction} {
  258. #    Handle "\ " and "\[" separately:
  259.     set searchString {(\\([^a-zA-Z\t\r* []|[a-zA-Z]+)\*?)|([^\\]\\\ )|([^\\]\\\[)}
  260.     set searchResult [search -s -f $direction -r 1 -n $searchString $pos]
  261.     if { [string length $searchResult] } {
  262.         set begPos [lindex $searchResult 0]
  263.         set endPos [lindex $searchResult 1]
  264.         set lastChar [lookAt [expr $endPos - 1]]
  265.         if {$lastChar == "\ " || $lastChar == "\["} then {
  266.             return [list [expr $begPos + 1] $endPos]
  267.         } else {}
  268.     }
  269.     return $searchResult
  270. # Handles everything but "\ " and "\[":
  271. #     set searchString {\\([^a-zA-Z\t\r* []|[a-zA-Z]+)\*?}
  272. #     return [search -s -f $direction -r 1 -n $searchString $pos]
  273. }
  274. # Find and goto the beginning of the previous LaTeX command.
  275. proc prevCommand {} {
  276.     global searchNoisily
  277.     set pos [getPos]
  278.     if {$pos > 0} then {
  279.         set searchResult [findCommand [expr $pos - 1] 0]
  280.         if { [string length $searchResult] } {
  281.             goto [lindex $searchResult 0]
  282.             return
  283.         } else {}
  284.     }
  285.     if { $searchNoisily } {beep}
  286.     message "previous command not found"
  287. }
  288. # Find and goto the beginning of the next LaTeX command.
  289. proc nextCommand {} {
  290.     global searchNoisily
  291.     set pos [getPos]
  292.     if {$pos < [maxPos]} then {
  293.         set searchResult [findCommand [expr $pos + 1] 1]
  294.         if { [string length $searchResult] } {
  295.             goto [lindex $searchResult 0]
  296.             return
  297.         } else {}
  298.     }
  299.     if { $searchNoisily } {beep}
  300.     message "next command not found"
  301. }
  302. # Select the previous LaTeX command, but do not attempt to select
  303. # any associated argument.
  304. proc prevCommandSelect {} {
  305.     global searchNoisily
  306.     set pos [getPos]
  307.     if {$pos > 0} then {
  308.         set searchResult [findCommand [expr $pos - 1] 0]
  309.         if { [string length $searchResult] } {
  310.             eval select $searchResult
  311.             return
  312.         } else {}
  313.     }
  314.     if { $searchNoisily } {beep}
  315.     message "previous command not found"
  316. }
  317. # Select the next LaTeX command, but do not attempt to select
  318. # any associated argument.
  319. proc nextCommandSelect {} {
  320.     global searchNoisily
  321.     set pos [getPos]
  322.     if {$pos < [maxPos]} then {
  323.         if { [isSelection] } then {
  324.             set pos [expr $pos + 1]
  325.         }
  326.         set searchResult [findCommand $pos 1]
  327.         if { [string length $searchResult] } {
  328.             eval select $searchResult
  329.             return
  330.         } else {}
  331.     }
  332.     if { $searchNoisily } {beep}
  333.     message "next command not found"
  334. }
  335.  
  336. # Find a LaTeX command with arguments in either direction.  It's up 
  337. # to the calling procedure to pass the starting position of the search.
  338. # (Handles everything but "\ " and commands whose arguments contain
  339. # embedded braces.)
  340. proc findCommandWithArgs {pos direction} {
  341.     set searchString {\\([^a-zA-Z\t\r]|[a-zA-Z]+\*?)(\[.*\])*({[^{}]*})*}
  342.     return [search -s -f $direction -r 1 -n $searchString $pos]
  343. }
  344. # Select the previous LaTeX command and any associated arguments.
  345. proc prevCommandSelectWithArgs {} {
  346.     global searchNoisily
  347.     set pos [getPos]
  348.     if {$pos > 0} then {
  349.         set searchResult [findCommandWithArgs [expr $pos - 1] 0]
  350.         if { [string length $searchResult] } {
  351.             eval select $searchResult
  352.             return
  353.         } else {}
  354.     }
  355.     if { $searchNoisily } {beep}
  356.     message "previous command not found"
  357. }
  358. # Select the next LaTeX command and any associated arguments.
  359. proc nextCommandSelectWithArgs {} {
  360.     global searchNoisily
  361.     set pos [getPos]
  362.     if {$pos < [maxPos]} then {
  363.         if { [isSelection] } then {
  364.             set pos [expr $pos + 1]
  365.         }
  366.         set searchResult [findCommandWithArgs $pos 1]
  367.         if { [string length $searchResult] } {
  368.             eval select $searchResult
  369.             return
  370.         } else {}
  371.     }
  372.     if { $searchNoisily } {beep}
  373.     message "next command not found"
  374. }
  375.  
  376. # Find a LaTeX sectioning command in either direction.  It's up to 
  377. # the calling procedure to pass the starting position of the search.
  378. proc findSection {pos direction} {
  379.     global funcExprAlt
  380.     return [search -s -f $direction -r 1 -n $funcExprAlt $pos]
  381. }
  382. # Select the previous LaTeX sectioning command.
  383. proc prevSection {} {
  384.     global searchNoisily
  385.     set pos [getPos]
  386.     if {$pos > 0} then {
  387.         set searchResult [findSection [expr $pos - 1] 0]
  388.         if { [string length $searchResult] } {
  389.             eval select $searchResult
  390.             return
  391.         } else {}
  392.     }
  393.     if { $searchNoisily } {beep}
  394.     message {previous section not found}
  395. }
  396. # Select the next LaTeX sectioning command.
  397. proc nextSection {} {
  398.     global searchNoisily
  399.     set pos [getPos]
  400.     if {$pos < [maxPos]} then {
  401.         if { [isSelection] } then {
  402.             set pos [expr $pos + 1]
  403.         }
  404.         set searchResult [findSection $pos 1]
  405.         if { [string length $searchResult] } {
  406.             eval select $searchResult
  407.             return
  408.         } else {}
  409.     }
  410.     if { $searchNoisily } {beep}
  411.     message {next section not found}
  412. }
  413. proc prevSectionSelect {} {
  414.     global searchNoisily
  415.     set pos [getPos]
  416.     if {$pos > 0} then {
  417.         set searchResult [findSection [expr $pos - 1] 0]
  418.         if { [string length $searchResult] } {
  419.             set begPos [lindex $searchResult 0]
  420.             set searchPos [expr [lindex $searchResult 1] + 1]
  421.             set searchResult [findSection $searchPos 1]
  422.             if { [string length $searchResult] } {
  423.                 set endPos [lindex $searchResult 0]
  424.             } else {
  425.                 set searchResult [search -s -f 1 -r 0 -n "\\end{document}" $searchPos]
  426.                 set endPos [lindex $searchResult 0]
  427.             }
  428.             select $begPos $endPos
  429.             return
  430.         } else {}
  431.     }
  432.     if { $searchNoisily } {beep}
  433.     message {previous section not found}
  434. }
  435. # Select the next LaTeX sectioning command.
  436. proc nextSectionSelect {} {
  437.     global searchNoisily
  438.     set pos [getPos]
  439.     if {$pos < [maxPos]} then {
  440.         if { [isSelection] } then {
  441.             set pos [expr $pos + 1]
  442.         }
  443.         set searchResult [findSection $pos 1]
  444.         if { [string length $searchResult] } {
  445.             set begPos [lindex $searchResult 0]
  446.             set searchPos [expr [lindex $searchResult 1] + 1]
  447.             set searchResult [findSection $searchPos 1]
  448.             if { [string length $searchResult] } {
  449.                 set endPos [lindex $searchResult 0]
  450.             } else {
  451.                 set searchResult [search -s -f 1 -r 0 -n "\\end{document}" $searchPos]
  452.                 set endPos [lindex $searchResult 0]
  453.             }
  454.             select $begPos $endPos
  455.             return
  456.         } else {}
  457.     }
  458.     if { $searchNoisily } {beep}
  459.     message {next section not found}
  460. }
  461.  
  462. # Find a LaTeX subsectioning command in either direction.  It's up to 
  463. # the calling procedure to pass the starting position of the search.
  464. proc findSubsection {pos direction} {
  465.     global funcExpr
  466.     return [search -s -f $direction -r 1 -n $funcExpr $pos]
  467. }
  468. proc prevSubsection {} {
  469.     global searchNoisily
  470.     set pos [getPos]
  471.     if {$pos > 0} then {
  472.         set searchResult [findSubsection [expr $pos - 1] 0]
  473.         if { [string length $searchResult] } {
  474.             eval select $searchResult
  475.             return
  476.         } else {}
  477.     }
  478.     if { $searchNoisily } {beep}
  479.     message {previous (sub)*section not found}
  480. }
  481. # Select the next LaTeX sectioning command.
  482. proc nextSubsection {} {
  483.     global searchNoisily
  484.     set pos [getPos]
  485.     if {$pos < [maxPos]} then {
  486.         if { [isSelection] } then {
  487.             set pos [expr $pos + 1]
  488.         }
  489.         set searchResult [findSubsection $pos 1]
  490.         if { [string length $searchResult] } {
  491.             eval select $searchResult
  492.             return
  493.         } else {}
  494.     }
  495.     if { $searchNoisily } {beep}
  496.     message {next (sub)*section not found}
  497. }
  498. proc prevSubsectionSelect {} {
  499.     global searchNoisily
  500.     set pos [getPos]
  501.     if {$pos > 0} then {
  502.         set searchResult [findSubsection [expr $pos - 1] 0]
  503.         if { [string length $searchResult] } {
  504.             set begPos [lindex $searchResult 0]
  505.             set endPos [lindex $searchResult 1]
  506.             set searchPos [expr $endPos + 1]
  507.             set commandName [extractCommandName [getText $begPos $endPos]]
  508.             if {[string match {section*} $commandName]} then {
  509.                 set searchResult [findSection $searchPos 1]
  510.             } else {
  511.                 set searchResult [findSubsection $searchPos 1]
  512.             }
  513.             if { [string length $searchResult] } {
  514.                 set endPos [lindex $searchResult 0]
  515.             } else {
  516.                 set searchResult [search -s -f 1 -r 0 -n "\\end{document}" $searchPos]
  517.                 set endPos [lindex $searchResult 0]
  518.             }
  519.             select $begPos $endPos
  520.             return
  521.         } else {}
  522.     }
  523.     if { $searchNoisily } {beep}
  524.     message {previous (sub)*section not found}
  525. }
  526. # Select the next LaTeX sectioning command.
  527. proc nextSubsectionSelect {} {
  528.     global searchNoisily
  529.     set pos [getPos]
  530.     if {$pos < [maxPos]} then {
  531.         if { [isSelection] } then {
  532.             set pos [expr $pos + 1]
  533.         }
  534.         set searchResult [findSubsection $pos 1]
  535.         if { [string length $searchResult] } {
  536.             set begPos [lindex $searchResult 0]
  537.             set endPos [lindex $searchResult 1]
  538.             set searchPos [expr $endPos + 1]
  539.             set commandName [extractCommandName [getText $begPos $endPos]]
  540.             if {[string match {section*} $commandName]} then {
  541.                 set searchResult [findSection $searchPos 1]
  542.             } else {
  543.                 set searchResult [findSubsection $searchPos 1]
  544.             }
  545.             if { [string length $searchResult] } {
  546.                 set endPos [lindex $searchResult 0]
  547.             } else {
  548.                 set searchResult [search -s -f 1 -r 0 -n "\\end{document}" $searchPos]
  549.                 set endPos [lindex $searchResult 0]
  550.             }
  551.             select $begPos $endPos
  552.             return
  553.         } else {}
  554.     }
  555.     if { $searchNoisily } {beep}
  556.     message {next (sub)*section not found}
  557. }
  558.  
  559. proc gotoTabStop {dirIndicator} {
  560.     set pos [getPos]
  561.     if {$dirIndicator} then {
  562.         if {$pos == [maxPos]} {return 0}
  563.     } else {
  564.         if {$pos == 0} {
  565.             set pos [expr $pos - 1]
  566.             return 0
  567.         }
  568.     }
  569.     set searchResult [search -s -n -f $dirIndicator -m 0 -i 1 -r 0 {Ñ} $pos]
  570.     if {[string length $searchResult]} then {
  571.         goto [lindex $searchResult 0]
  572.         return 1
  573.     } else {
  574.         return 0
  575.     }
  576. }
  577. proc nextTabStop {} {
  578.     global searchNoisily
  579.     set forward 1
  580.     if {[gotoTabStop $forward]} then {
  581.         deleteChar
  582.     } else {
  583.         if {$searchNoisily} {beep}
  584.         message "tab stop not found"
  585.     }
  586. }
  587. proc prevTabStop {} {
  588.     global searchNoisily
  589.     set forward 0
  590.     if {[gotoTabStop $forward]} then {
  591.         deleteChar
  592.     } else {
  593.         if {$searchNoisily} {beep}
  594.         message "tab stop not found"
  595.     }
  596. }
  597. # Goto the nth tab stop.  A nonzero argument is non-interactive
  598. # (for use in Tcl procs) and not validated.
  599. proc nthTabStop {{numTabStops 0}} {
  600.     global searchNoisily promptNoisily useStatusBar
  601.     if {$numTabStops == 0} then {
  602.         if {$promptNoisily && $useStatusBar} {beep}
  603.         catch {sPrompt "How many tab stops?" "3"} numTabStops
  604.         if {$numTabStops == "cancel" || $numTabStops == 0} then {
  605.             return
  606.         } elseif {![isInteger $numTabStops]} then {
  607.             beep
  608.             message "invalid input"
  609.             return
  610.         }
  611.     }
  612.     set currentPos [getPos]
  613.     if {$numTabStops > 0} {set forward 1} {set forward 0}
  614.     set maxits [expr abs($numTabStops)]
  615.     if {![gotoTabStop $forward]} then {
  616.         if {$searchNoisily} {beep}
  617.         message "tab stop not found"
  618.         goto $currentPos
  619.         return
  620.     }
  621.     for {set i 1} {$i < $maxits} {incr i} {
  622.         if {$forward} {forwardChar} {backwardChar}
  623.         if {![gotoTabStop $forward]} then {
  624.             if {$searchNoisily} {beep}
  625.             message "tab stop not found"
  626.             goto $currentPos
  627.             return
  628.         }
  629.     }
  630.     deleteChar
  631. }
  632.  
  633. #--------------------------------------------------------------------------
  634. # Utilities:
  635. #--------------------------------------------------------------------------
  636.  
  637. proc chooseCommand {{men {}} {prompt "LaTeX submenu:"}} {
  638.     watchCursor
  639.     if {![string length $men]} {
  640.         set men    [getTeXMenu]
  641.     }
  642.     foreach    item $men {
  643.         regsub -all {[<!/].} $item {} item
  644.         regsub -all {╔}    $item {} item
  645.         lappend    menOut $item
  646.         if {[string match "menu*" $item]} {
  647.             if {[set ind [lsearch $item {-n}]] >= 0} {
  648.                 lappend    top [lindex $item [incr    ind]]
  649.             }
  650.         } elseif {![string match "(*" $item]} {
  651.             lappend    top $item
  652.         }
  653.     }
  654.     set res    [listpick -p $prompt $top]
  655.     if {[lsearch $menOut $res] >= 0} {
  656.         interpretMenuItem dummy    $res
  657.     } else {
  658.         foreach    item $menOut {
  659.             if {[set ind [lsearch $item $res]] >= 0} {
  660.                 return [chooseCommand [lindex $item end] "LaTeX submenu command:"]
  661.             }
  662.         }
  663.     }
  664. }
  665.  
  666. proc insertLiteralTab {} {
  667.     if {[isSelection]} then {
  668.         deleteSelection
  669.     }
  670.     insertText "\t"
  671. }
  672.  
  673. proc insertTabStop {} {
  674.     if {[isSelection]} then {
  675.         deleteSelection
  676.     }
  677.     insertText "Ñ"
  678. }
  679.  
  680. proc insertReference {} {
  681.     set end [maxPos]
  682.     set pos 0
  683.     set labels {}
  684.     
  685.     set exp {\\label\{(.*)\}}
  686.     while {![catch {search -s -f 1 -r 1 -m 0 -i 0 $exp $pos} res]} {
  687.         set start [lindex $res 0]
  688.         set end [lindex $res 1]
  689.         set text [getText $start $end]
  690.         regexp {\{(.*)\}} $text dummy label
  691.         lappend labels $label
  692.         set pos [expr $end +1]
  693.     }
  694.  
  695.     set ref [listpick -p "Select a reference to insert" [lsort $labels]]
  696.     if {[string length $ref]} {
  697.         insertText "\\ref\{$ref\}"
  698.     }    
  699. }
  700.  
  701. # Removes all tab stops from the current selection (if there is one) 
  702. # or the current document, maintaining the cursor position in the 
  703. # latter case.
  704. proc deleteTabStops {} {
  705.     global searchNoisily
  706.     watchCursor
  707.     set subs1 0; set subs2 0; set subs3 0
  708.     set pos [getPos]
  709.     if {[set start $pos] == [set end [selEnd]]} {
  710.         set messageString "document"
  711.         set start 0
  712.         set end [maxPos]
  713.         set text1 [getText $start $pos]
  714.         set subs1 [regsub -all {Ñ} $text1 {} text1]
  715.         set text2 [getText $pos $end]
  716.         set subs2 [regsub -all {Ñ} $text2 {} text2]
  717.         append text $text1 $text2
  718.     } else {
  719.         set messageString "selection"
  720.         set text [getText $start $end]
  721.         set subs3 [regsub -all {Ñ} $text {} text]
  722.     }
  723.     if {$subs1 || $subs2 || $subs3} then {
  724.         replaceText $start $end $text
  725.         if {$messageString == "document"} then {
  726.             goto [expr $pos - $subs1]
  727.         } else {
  728.             set end [getPos]
  729.             select $start $end
  730.         }
  731.         set subs [expr $subs1 + $subs2 + $subs3]
  732.         message "$subs tab stops removed from $messageString"
  733.     } else {
  734.         if {$searchNoisily} {beep}
  735.         message "no tab stops found in $messageString"
  736.     }
  737. }
  738.  
  739. # Delete all unnecessary comments from the current document:
  740. proc deleteComments {} {
  741.     case [askyesno "Warning!  This operation can not be undone.  \
  742.                     Continue anyway?"] in {
  743.         "yes" {}
  744.         "no" { return }
  745.     }
  746.     replaceString {}
  747.     eval select [search -f 1 -r 1 -i 1 -m 0 -- {^[ \t]*%.*\r} 0]
  748.     replaceAll
  749.     
  750.     replaceString {}
  751.     eval select [search -f 1 -r 1 -i 1 -m 0 -- {[ \t]+%.*} 0]
  752.     replaceAll
  753.     
  754.     replaceString {\1%}
  755.     eval select [search -f 1 -r 1 -i 1 -m 0 -- {([^\\](\\\\)*)%.*} 0]
  756.     replaceAll
  757. }
  758.  
  759. # Converts all straight quotes to their TeX equivalents.
  760. proc convertQuotes {} {
  761.     global searchNoisily
  762.     message "working╔"
  763.     watchCursor
  764.     set messageString "selection"
  765.     if {[set start [getPos]] == [set end [selEnd]]} {
  766.         set messageString "document"
  767.         set start 0
  768.         set end [maxPos]
  769.     }
  770.     set text [getText $start $end]
  771.     # Convert all left double quotes:
  772.     set convert1 [regsub -all "\(\^\|\[\ \r\t\(\[\{\]\)\"" $text {\1``} text]
  773.     # Convert all right double quotes:
  774.     set convert2 [regsub -all "\(\[\^\\\\\]\)\"" $text {\1''} text]
  775.     # Convert all left single quotes:
  776.     set convert3 [regsub -all "\(\^\|\[\ \r\t\(\[\{\]\)\'" $text {\1`} text]
  777.     if {$convert1 || $convert2 || $convert3} then {
  778.         replaceText $start $end $text
  779.         message "all quotes in $messageString converted"
  780.     } else {
  781.         if {$searchNoisily} {beep}
  782.         message "no quotes found in $messageString"
  783.     }
  784. }
  785.  
  786. # Returns true if the argument contains non-literal double dollar
  787. # signs, and false otherwise.
  788. proc containsDoubleDollarSigns {text} {
  789.     return [regexp {(^|[^\\])\$\$} $text]
  790. }
  791.  
  792. # Converts all $$...$$ pairs to \[...\] and returns the number of such 
  793. # pairs converted.  If the dollar signs are unbalanced, does nothing 
  794. # and returns -1.
  795. proc convertDoubleDollarSigns {} {
  796.     watchCursor
  797.     set messageString "selection"
  798.     if {[set start [getPos]] == [set end [selEnd]]} {
  799.         set messageString "document"
  800.         set start 0
  801.         set end [maxPos]
  802.     }
  803.     set text [getText $start $end]
  804.     set subs [regsub -all {(^|[^\\])\$\$([^$]*)\$\$} $text {\1\\[\2\\]} text]
  805.     if {[containsDoubleDollarSigns $text]} then {return -1}
  806.     if {$subs} then {
  807.         replaceText $start $end $text
  808.     }
  809.     return [expr $subs]
  810. }
  811.  
  812. # Returns true if the argument contains a non-literal dollar sign,
  813. # and false otherwise.
  814. proc containsSingleDollarSign {text} {
  815.     return [regexp {(^|[^\\])\$} $text]
  816. }
  817.  
  818. # Converts all $...$ pairs to \(...\), maintains the cursor position, 
  819. # and returns the number of such pairs converted.  If the dollar signs 
  820. # are unbalanced, does nothing and returns -1.
  821. proc convertSingleDollarSigns {} {
  822.     watchCursor
  823.     set subs1 0; set subs2 0; set subs3 0
  824.     set pos [getPos]; set pos2 $pos
  825.     if {[set start $pos] == [set end [selEnd]]} {
  826.         set isSelection 0
  827.         set start 0
  828.         set end [maxPos]
  829.         set text1 [getText $start $pos]
  830.         set subs1 [regsub -all {(^|[^\\])\$([^$]*)\$} $text1 {\1\\(\2\\)} text1]
  831.         # Is there a dollar sign left over?  If so, search backward for this
  832.         # dollar sign and prepare to do a substitution on the text to the right
  833.         # of this dollar sign.
  834.         if {[containsSingleDollarSign $text1]} then {
  835.             set searchString {[^\\]\$}
  836.             set searchResult [search -s -n -f 0 -m 0 -i 1 -r 1 $searchString [expr $pos-1]]
  837.             set pos2 [lindex $searchResult 0]
  838.             set text1 [string range $text1 0 [expr $pos2 + (2 * $subs1)]]
  839.             set pos [expr $pos + 2]
  840.         }
  841.         set text2 [getText $pos2 $end]
  842.         set subs2 [regsub -all {(^|[^\\])\$([^$]*)\$} $text2 {\1\\(\2\\)} text2]
  843.         # Is there a dollar sign left over?  If so, it's unbalanced.
  844.         if {[containsSingleDollarSign $text2]} then {return -1}
  845.         append text $text1 $text2
  846.     } else {
  847.         set isSelection 1
  848.         set text [getText $start $end]
  849.         set subs3 [regsub -all {(^|[^\\])\$([^$]*)\$} $text {\1\\(\2\\)} text]
  850.         # Is there a dollar sign left over?  If so, it's unbalanced.
  851.         if {[containsSingleDollarSign $text]} then {return -1}
  852.     }
  853.     if {$subs1 || $subs2 || $subs3} then {
  854.         replaceText $start $end $text
  855.         # If there is a selection, just put it back.  Otherwise, adjust the
  856.         # cursor position based on the number of substitutions.
  857.         if {$isSelection} then {
  858.             set end [getPos]
  859.             select $start $end
  860.         } else {
  861.             goto [expr $pos + (2 * $subs1)]
  862.         }
  863.     }
  864.     return [expr $subs1 + $subs2 + $subs3]
  865. }
  866.  
  867. proc convertDollarSigns {} {
  868.     global searchNoisily
  869.     if {[isSelection]} then {
  870.         set messageString "selection"
  871.     } else {
  872.         set messageString "document"
  873.     }
  874.     set subs2 [convertDoubleDollarSigns]
  875.     if {$subs2 == -1} then {
  876.         beep
  877.         alertnote "unmatched double dollar signs in $messageString"
  878.     } else {
  879.         set subs1 [convertSingleDollarSigns]
  880.         if {$subs1 == -1} then {
  881.             beep
  882.             alertnote "unmatched single dollar sign in $messageString"
  883.         } elseif {$subs1 == 0 && $subs2 == 0} then {
  884.             if {$searchNoisily} {beep}
  885.             message "no dollar signs found in $messageString"
  886.         } else {
  887.             message "$subs1 pairs of \$...\$ and $subs2 pairs of \$\$...\$\$ removed from $messageString"
  888.         }
  889.     }
  890. }
  891.  
  892. proc removeAuxiliaryFiles {} {
  893.     set word ""
  894.     set currentWin [lindex [winNames -f] 0]
  895.     set currentDir [file dirname $currentWin]
  896.     set currentDoc [file tail $currentWin]
  897.     set docBasename [file rootname $currentDoc]
  898.     set docExtension [file extension $currentDoc]
  899.     set extensions {.aux .bbl .dvi .glo .idx .ind .lof .log .lot \
  900.               .toc .blg .clg .ilg .ps}
  901.     foreach ext $extensions {
  902.         if {[file exists "$currentDir:$docBasename$ext"]} then {
  903.             set word " more"
  904.             case [askyesno -c "Remove \"$docBasename$ext\"?"] in {
  905.                 "yes" {
  906.                     if {[catch {rm "$currentDir:$docBasename$ext"}]} then {
  907.                         alertnote "\"$docBasename$ext\" not deleted"
  908.                     }
  909.                 }
  910.                 "no" {}
  911.                 "cancel" {return}
  912.             }
  913.         }
  914.     }
  915.     message "no$word files found"
  916. }
  917.  
  918.  
  919. #############################################################################
  920. # 
  921. # Paragraph Mode Macros
  922. #
  923. #############################################################################
  924.  
  925. #--------------------------------------------------------------------------
  926. # Documents:
  927. #--------------------------------------------------------------------------
  928.  
  929. proc letter {} {
  930.     set    preamble "\r\\address\{%\r"
  931.     append preamble "    Ñ    \\\\    % insert your name here\r"
  932.     append preamble "    Ñ    \\\\    % insert your address here\r"
  933.     append preamble "    Ñ    \\\\    % insert more address here\r"
  934.     append preamble "    Ñ          % insert city-state-zip here\r"
  935.     append preamble "\}\r\r"
  936.     append preamble "\\date\{Ñ\}  % optional\r"
  937.     append preamble "\\signature\{Ñ\}\r\r"
  938.     set    body "\r\\begin\{letter\}\{%\r"
  939.     append body "    Ñ    \\\\    % insert addressee's name here\r"
  940.     append body "    Ñ    \\\\    % insert addressee's address here\r"
  941.     append body "    Ñ    \\\\    % insert more address here\r"
  942.     append body "    Ñ          % insert addressee's city-state-zip here\r"
  943.     append body "\}\r\r"
  944.     append body "\\opening\{Dear Ñ,\}\r\r"
  945.     if {[isEmptyFile]} then {
  946.         append body "% BODY OF LETTER\r"
  947.         append body "Ñ\r\r"
  948.     } else {
  949.         if {[isDocumentSelected]} then {
  950.             set text [getSelect]
  951. #             deleteText 0 [maxPos]
  952.             append body "$text\r"
  953.         } else {
  954.             alertnote "nonempty file:  delete text or \'Select All\'\
  955.                 from the Edit menu"
  956.             return
  957.         }
  958.     }
  959.     append body "\\closing\{Sincerely,\}\r\r"
  960.     append body "\\encl\{Ñ\}\r"
  961.     append body "\\cc\{Ñ\}\r\r"
  962.     append body "\\end\{letter\}\r\r"
  963.     insertDocument "letter" $preamble $body
  964.     nextTabStop
  965.     message "enter option (or leave blank)"
  966. }
  967. proc article {} {
  968.     wrapDocument "article"
  969. }
  970. proc report {} {
  971.     wrapDocument "report"
  972. }
  973. proc book {} {
  974.     wrapDocument "book"
  975. }
  976. proc slides {} {
  977.     wrapDocument "slides"
  978. }
  979. proc custom {} {
  980.     catch {prompt "What documentclass?" "article"} documentType
  981.     if {$documentType != "cancel"} then {
  982.         wrapDocument "$documentType" 
  983.     }
  984. }
  985.  
  986. proc getOption {} {
  987.     catch {prompt "Choose an option:" "11pt" "" "10pt" "11pt" "12pt" "(-" \
  988.             "letterpaper" "legalpaper" "executivepaper" "a4paper" "a5paper" \
  989.             "b5paper" "(-" "landscape" "(-" "final" "draft" "(-" \
  990.             "oneside" "twoside" "(-" "openright" "openany" "(-" \
  991.             "onecolumn" "twocolumn" "(-" "notitlepage" "titlepage" \
  992.                   "openbib" "(-" "leqno" "(-" "fleqn"} optionName
  993.     if {$optionName != "cancel"} then {
  994.         return $optionName
  995.     } else {
  996.         return ""
  997.     }
  998. }
  999. proc insertOption {option} {
  1000.     global searchNoisily
  1001.     set searchString {\\documentclass}
  1002.     set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 $searchString 0]
  1003.     if {[llength $searchResult] == 0} then {
  1004.         if {$searchNoisily} {beep}
  1005.         message "can\'t find \\documentclass"
  1006.     } else {
  1007.         set nextCharPos [lindex $searchResult 1]
  1008.         goto $nextCharPos
  1009.         set nextChar [lookAt $nextCharPos]
  1010.         if {$nextChar == "\["} then {
  1011.             forwardChar
  1012.             insertText $option
  1013.             if {[lookAt [getPos]] != "\]"} then {
  1014.                 insertText ","
  1015.             }
  1016.         } elseif {$nextChar == "\{"} then {
  1017.             insertText "\[$option\]"
  1018.         } else {
  1019.             alertnote "unrecognizable \\documentclass statement"
  1020.         }
  1021.     }
  1022. }
  1023. proc options {} {
  1024.     set option [getOption]
  1025.     if {$option != ""} then {
  1026.         insertOption $option
  1027.     }
  1028. }
  1029. proc getPackage {} {
  1030.     catch {prompt "Choose a package:" "latexsym" "" \
  1031.                   "alltt" "amstex" "babel" "color" \
  1032.                   "graphics" "graphpap" "ifthen" "latexsym" "makeidx" \
  1033.                   "pict2e" "showidx"} packageName
  1034.     if {$packageName != "cancel"} then {
  1035.         return $packageName
  1036.     } else {
  1037.         return ""
  1038.     }
  1039. }
  1040. proc insertPackage {package} {
  1041.     global searchNoisily
  1042.     set begPos [getPos]
  1043.     set endPos [selEnd]
  1044.     append searchString {\\usepackage\{.*} $package {.*\}}
  1045.     set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 $searchString 0]
  1046.     if {[llength $searchResult] == 0} then {
  1047.         set searchString {\\documentclass(\[.*\])?\{.*\}}
  1048.         set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 $searchString 0]
  1049.         if {[llength $searchResult] == 0} then {
  1050.             if {$searchNoisily} {beep}
  1051.             message "can't find \\documentclass"
  1052.         } else {
  1053.             goto [lindex $searchResult 1]
  1054.             set txt "\r\\usepackage\{$package\}"
  1055.             set offset [string length $txt]
  1056.             set begPos [expr $begPos + $offset]
  1057.             set endPos [expr $endPos + $offset]
  1058.             insertText $txt
  1059.             select $begPos $endPos
  1060.         }
  1061.     } else {
  1062.         if {$searchNoisily} {beep}
  1063.         message "$package package already loaded"
  1064.     }
  1065. }
  1066. proc packages {} {
  1067.     set package [getPackage]
  1068.     if {$package != ""} then {
  1069.         insertPackage $package
  1070.     }
  1071. }
  1072. proc filecontents {} {
  1073.     global searchNoisily
  1074.     set searchString {\\documentclass}
  1075.     set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 $searchString 0]
  1076.     if {[llength $searchResult] == 0} then {
  1077.         if {$searchNoisily} {beep}
  1078.         message "can\'t find \\documentclass"
  1079.         return
  1080.     } else {
  1081.         set prompt "File to be included:"
  1082.         if {[catch {getfile $prompt} path]} then {
  1083.             return
  1084.         } else {
  1085.             set fd [open $path]
  1086.             set text [read $fd]
  1087.             close $fd
  1088.             regsub -all "\xa" $text "\xd" text
  1089.             goto 0
  1090.             set envName "filecontents"
  1091.             set envArg "{[file tail $path]}"
  1092.             replaceText 0 0 [buildEnvironment $envName $envArg "$text\r" "\r\r"]
  1093.             goto 0
  1094.             message "file included"
  1095.         }
  1096.     }
  1097. }
  1098.  
  1099. #--------------------------------------------------------------------------
  1100. # Page Layout:
  1101. #--------------------------------------------------------------------------
  1102.  
  1103. proc maketitle {} {
  1104.     global searchNoisily
  1105.     set searchString {\\document(class|style)(\[.*\])?\{.*\}}
  1106.     set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 $searchString 0]
  1107.     if {[llength $searchResult] == 0} then {
  1108.         if {$searchNoisily} {beep}
  1109.         message "can\'t find \\documentclass or \\documentstyle"
  1110.     } else {
  1111.         set searchPos [lindex $searchResult 1]
  1112.         set searchString {\\begin\{document\}}
  1113.         set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 $searchString $searchPos]
  1114.         if {[llength $searchResult] == 0} then {
  1115.             if {$searchNoisily} {beep}
  1116.             message "can\'t find \\begin\{document\}"
  1117.         } else {
  1118.             goto [lindex $searchResult 1]
  1119.             set currentPos [getPos]
  1120.             set txt "\r\r% Definition of title page:"
  1121.             append txt "\r\\title\{"
  1122.             append txt "\r\tÑ\r\}"
  1123.             append txt "\r\\author\{"
  1124.             append txt "\r\tÑ\t% insert author(s) here"
  1125.             append txt "\r\}"
  1126.             append txt "\r\\date\{Ñ\}\t% optional"
  1127.             append txt "\r\r\\maketitle"
  1128.             insertText $txt
  1129.             goto $currentPos
  1130.             nextTabStop
  1131.             message "insert title"
  1132.         }
  1133.     }
  1134. }
  1135. proc abstract {} { doWrapEnvironment "abstract" }
  1136. proc titlepage {} { doWrapEnvironment "titlepage" }
  1137. proc getPagestyle {} {
  1138.     catch {prompt "Choose a pagestyle:" "plain" "" "plain" "empty" \
  1139.                   "headings" "myheadings"} pagestyleName
  1140.     if {$pagestyleName != "cancel"} then {
  1141.         return $pagestyleName
  1142.     } else {
  1143.         return ""
  1144.     }
  1145. }
  1146. proc pagestyle {} {
  1147.     set pagestyleName [getPagestyle]
  1148.     if {$pagestyleName != ""} then {
  1149.         openingCarriageReturn
  1150.         insertObject "\\pagestyle\{$pagestyleName\}"
  1151.         closingCarriageReturn
  1152.     }
  1153. }
  1154. proc thispagestyle {} {
  1155.     set pagestyleName [getPagestyle]
  1156.     if {$pagestyleName != ""} then {
  1157.         openingCarriageReturn
  1158.         insertObject "\\thispagestyle\{$pagestyleName\}"
  1159.         closingCarriageReturn
  1160.     }
  1161. }
  1162. proc getPagenumberingStyle {} {
  1163.     catch {prompt "Choose a pagenumbering style:" "arabic" "" "arabic" \
  1164.                   "roman" "Roman" "alph" "Alph"} pagenumberingStyle
  1165.     if {$pagenumberingStyle != "cancel"} then {
  1166.         return $pagenumberingStyle
  1167.     } else {
  1168.         return ""
  1169.     }
  1170. }
  1171. proc pagenumbering {} {
  1172.     set pagenumberingStyle [getPagenumberingStyle]
  1173.     if {$pagenumberingStyle != ""} then {
  1174.         openingCarriageReturn
  1175.         insertObject "\\pagenumbering\{$pagenumberingStyle\}"
  1176.         closingCarriageReturn
  1177.     }
  1178. }
  1179. proc twocolumn {} {
  1180.     openingCarriageReturn
  1181.     insertObject "\\twocolumn"
  1182.     closingCarriageReturn
  1183. }
  1184. proc onecolumn {} {
  1185.     openingCarriageReturn
  1186.     insertObject "\\onecolumn"
  1187.     closingCarriageReturn
  1188. }
  1189.  
  1190. #--------------------------------------------------------------------------
  1191. # Sectioning:
  1192. #--------------------------------------------------------------------------
  1193.  
  1194. proc part {} {
  1195.     if {[wrapObject "\\part{" "}Ñ"]} then {
  1196.         message "don't forget the label"
  1197.     } else {
  1198.         message "type the part name and don't forget the label"
  1199.     }
  1200. }
  1201. proc chapter {} {
  1202.     if {[wrapObject "\\chapter{" "}Ñ"]} then {
  1203.         message "don't forget the label"
  1204.     } else {
  1205.         message "type the chapter name and don't forget the label"
  1206.     }
  1207. }
  1208. proc section {} {
  1209.     if {[wrapObject "\\section{" "}Ñ"]} then {
  1210.         message "don't forget the label"
  1211.     } else {
  1212.         message "type the section name and don't forget the label"
  1213.     }
  1214. }
  1215. proc subsection {} {
  1216.     if {[wrapObject "\\subsection{" "}Ñ"]} then {
  1217.         message "don't forget the label"
  1218.     } else {
  1219.         message "type the subsection name and don't forget the label"
  1220.     }
  1221. }
  1222. proc subsubsection {} {
  1223.     if {[wrapObject "\\subsubsection{" "}Ñ"]} then {
  1224.         message "don't forget the label"
  1225.     } else {
  1226.         message "type the subsubsection name and don't forget the label"
  1227.     }
  1228. }
  1229. proc paragraph {} {
  1230.     if {[wrapObject "\\paragraph{" "}Ñ"]} then {
  1231.         message "don't forget the label"
  1232.     } else {
  1233.         message "type the paragraph name and don't forget the label"
  1234.     }
  1235. }
  1236. proc subparagraph {} {
  1237.     if {[wrapObject "\\subparagraph{" "}Ñ"]} then {
  1238.         message "don't forget the label"
  1239.     } else {
  1240.         message "type the subparagraph name and don't forget the label"
  1241.     }
  1242. }
  1243. proc appendix {} {insertObject "\\appendix"}
  1244.  
  1245. #--------------------------------------------------------------------------
  1246. # Text Style:
  1247. #--------------------------------------------------------------------------
  1248.  
  1249. proc emph {} {
  1250.     if {[wrapObject "\\emph{" "}Ñ"]} then {
  1251.         message "selected text has been emphasized"
  1252.     } else {
  1253.         message "enter text to be emphasized"
  1254.     }
  1255. }
  1256. proc textup {} {
  1257.     if {[wrapObject "\\textup{" "}Ñ"]} then {
  1258.         message "selected text has upright shape"
  1259.     } else {
  1260.         message "enter text to have upright shape"
  1261.     }
  1262. }
  1263. proc textit {} {
  1264.     if {[wrapObject "\\textit{" "}Ñ"]} then {
  1265.         message "selected text has italic shape"
  1266.     } else {
  1267.         message "enter text to have italic shape"
  1268.     }
  1269. }
  1270. proc textsl {} {
  1271.     if {[wrapObject "\\textsl{" "}Ñ"]} then {
  1272.         message "selected text has slanted shape"
  1273.     } else {
  1274.         message "enter text to have slanted shape"
  1275.     }
  1276. }
  1277. proc textsc {} {
  1278.     if {[wrapObject "\\textsc{" "}Ñ"]} then {
  1279.         message "selected text has small caps shape"
  1280.     } else {
  1281.         message "enter text to have small caps shape"
  1282.     }
  1283. }
  1284. proc textmd {} {
  1285.     if {[wrapObject "\\textmd{" "}Ñ"]} then {
  1286.         message "selected text has been set in medium series"
  1287.     } else {
  1288.         message "enter text to be set in medium series"
  1289.     }
  1290. }
  1291. proc textbf {} {
  1292.     if {[wrapObject "\\textbf{" "}Ñ"]} then {
  1293.         message "selected text has been set in bold series"
  1294.     } else {
  1295.         message "enter text to be set in bold series"
  1296.     }
  1297. }
  1298. proc textrm {} {
  1299.     if {[wrapObject "\\textrm{" "}Ñ"]} then {
  1300.         message "selected text has been set with roman family"
  1301.     } else {
  1302.         message "enter text to be set using roman family"
  1303.     }
  1304. }
  1305. proc textsf {} {
  1306.     if {[wrapObject "\\textsf{" "}Ñ"]} then {
  1307.         message "selected text has been set with sans serif family"
  1308.     } else {
  1309.         message "enter text to be set using sans serif family"
  1310.     }
  1311. }
  1312. proc texttt {} {
  1313.     if {[wrapObject "\\texttt{" "}Ñ"]} then {
  1314.         message "selected text has been set with typewriter family"
  1315.     } else {
  1316.         message "enter text to be set using typewriter family"
  1317.     }
  1318. }
  1319. proc textnormal {} {
  1320.     if {[wrapObject "\\textnormal{" "}Ñ"]} then {
  1321.         message "selected text has been set with normal style"
  1322.     } else {
  1323.         message "enter text to be set using normal style"
  1324.     }
  1325. }
  1326.  
  1327. #--------------------------------------------------------------------------
  1328. # Text Size:
  1329. #--------------------------------------------------------------------------
  1330.  
  1331. proc tiny {} {
  1332.     if {[wrapObject "{\\tiny " "}Ñ"]} then {
  1333.         message "tiny text set"
  1334.     } else {
  1335.         message "enter tiny text"
  1336.     }
  1337. }
  1338. proc scriptsize {} {
  1339.     if {[wrapObject "{\\scriptsize " "}Ñ"]} then {
  1340.         message "scriptsize text set"
  1341.     } else {
  1342.         message "enter scriptsize text"
  1343.     }
  1344. }
  1345. proc footnotesize {} {
  1346.     if {[wrapObject "{\\footnotesize " "}Ñ"]} then {
  1347.         message "footnotesize text set"
  1348.     } else {
  1349.         message "enter footnotesize text"
  1350.     }
  1351. }
  1352. proc small {} {
  1353.     if {[wrapObject "{\\small " "}Ñ"]} then {
  1354.         message "small text set"
  1355.     } else {
  1356.         message "enter small text"
  1357.     }
  1358. }
  1359. proc normalsize {} {
  1360.     if {[wrapObject "{\\normalsize " "}Ñ"]} then {
  1361.         message "normalsize text set"
  1362.     } else {
  1363.         message "enter normalsize text"
  1364.     }
  1365. }
  1366. proc large {} {
  1367.     if {[wrapObject "{\\large " "}Ñ"]} then {
  1368.         message "large text set"
  1369.     } else {
  1370.         message "enter large text"
  1371.     }
  1372. }
  1373. proc Large {} {
  1374.     if {[wrapObject "{\\Large " "}Ñ"]} then {
  1375.         message "Large text set"
  1376.     } else {
  1377.         message "enter Large text"
  1378.     }
  1379. }
  1380. proc LARGE {} {
  1381.     if {[wrapObject "{\\LARGE " "}Ñ"]} then {
  1382.         message "LARGE text set"
  1383.     } else {
  1384.         message "enter LARGE text"
  1385.     }
  1386. }
  1387. proc huge {} {
  1388.     if {[wrapObject "{\\huge " "}Ñ"]} then {
  1389.         message "huge text set"
  1390.     } else {
  1391.         message "enter huge text"
  1392.     }
  1393. }
  1394. proc Huge {} {
  1395.     if {[wrapObject "{\\Huge " "}Ñ"]} then {
  1396.         message "Huge text set"
  1397.     } else {
  1398.         message "enter Huge text"
  1399.     }
  1400. }
  1401.  
  1402. #--------------------------------------------------------------------------
  1403. # International:
  1404. #--------------------------------------------------------------------------
  1405.  
  1406. proc {ÿ} {} {
  1407.     if {[wrapObject "\\`{" "}Ñ"]} then {
  1408.         message "accent set"
  1409.     } else {
  1410.         message "enter single character"
  1411.     }
  1412. }
  1413. proc {ù} {} {
  1414.     if {[wrapObject "\\'{" "}Ñ"]} then {
  1415.         message "accent set"
  1416.     } else {
  1417.         message "enter single character"
  1418.     }
  1419. }
  1420. proc {Ö} {} {
  1421.     if {[wrapObject "\\^{" "}Ñ"]} then {
  1422.         message "accent set"
  1423.     } else {
  1424.         message "enter single character"
  1425.     }
  1426. }
  1427. proc {Ü} {} {
  1428.     if {[wrapObject "\\\"{" "}Ñ"]} then {
  1429.         message "accent set"
  1430.     } else {
  1431.         message "enter single character"
  1432.     }
  1433. }
  1434. proc {¢} {} {
  1435.     if {[wrapObject "\\~{" "}Ñ"]} then {
  1436.         message "accent set"
  1437.     } else {
  1438.         message "enter single character"
  1439.     }
  1440. }
  1441. proc {ì} {} {insertObject "\\c\{c\}"}
  1442. proc {é} {} {insertObject "\\c\{C\}"}
  1443. proc {╧} {} {insertObject "\\oe"}
  1444. proc {╬} {} {insertObject "\\OE"}
  1445. proc {╛} {} {insertObject "\\ae"}
  1446. proc {«} {} {insertObject "\\AE"}
  1447. proc {î} {} {insertObject "\\aa"}
  1448. proc {ü} {} {insertObject "\\AA"}
  1449. proc {┐} {} {insertObject "\\o"}
  1450. proc {»} {} {insertObject "\\O"}
  1451. proc {º} {} {insertObject "\\ss"}
  1452. proc {└} {} {insertObject "?`"}
  1453. proc {┴} {} {insertObject "!`"}
  1454.  
  1455. #--------------------------------------------------------------------------
  1456. # Environments:
  1457. #--------------------------------------------------------------------------
  1458.  
  1459. proc enumerate {} {
  1460.     global promptNoisily useStatusBar
  1461.     set envName "enumerate"
  1462.     if {$promptNoisily && $useStatusBar} {beep}
  1463.     catch {sPrompt "$envName:  how many items?" 3} numberItems
  1464.     if {$numberItems == "cancel"} then {
  1465.         return
  1466.     } elseif {![isUnsignedInteger $numberItems]} then {
  1467.         beep
  1468.         message "invalid input"
  1469.         return
  1470.     }
  1471.     if {$numberItems} then {
  1472.         set body "\t\\item  Ñ"
  1473.         for {set i 1} {$i < $numberItems} {incr i} {
  1474.             append body "\r\r\t\\item  Ñ"
  1475.         }
  1476.         append body "\r"
  1477.     } else {
  1478.         set body "\tÑ\r"
  1479.     }
  1480.     if {[insertEnvironment $envName "" $body]} then {
  1481.         nextTabStop
  1482.         message "type first item"
  1483.     }
  1484. }
  1485. proc itemize {} {
  1486.     global promptNoisily useStatusBar
  1487.     set envName "itemize"
  1488.     if {$promptNoisily && $useStatusBar} {beep}
  1489.     catch {sPrompt "$envName:  how many items?" 3} numberItems
  1490.     if {$numberItems == "cancel"} then {
  1491.         return
  1492.     } elseif {![isUnsignedInteger $numberItems]} then {
  1493.         beep
  1494.         message "invalid input"
  1495.         return
  1496.     }
  1497.     if {$numberItems} then {
  1498.         set body "\t\\item  Ñ"
  1499.         for {set i 1} {$i < $numberItems} {incr i} {
  1500.             append body "\r\r\t\\item  Ñ"
  1501.         }
  1502.         append body "\r"
  1503.     } else {
  1504.         set body "\tÑ\r"
  1505.     }
  1506.     if {[insertEnvironment $envName "" $body]} then {
  1507.         nextTabStop
  1508.         message "type first item"
  1509.     }
  1510. }
  1511. proc description {} {
  1512.     global promptNoisily useStatusBar
  1513.     set envName "description"
  1514.     if {$promptNoisily && $useStatusBar} {beep}
  1515.     catch {sPrompt "$envName:  how many items?" 3} numberItems
  1516.     if {$numberItems == "cancel"} then {
  1517.         return
  1518.     } elseif {![isUnsignedInteger $numberItems]} then {
  1519.         beep
  1520.         message "invalid input"
  1521.         return
  1522.     }
  1523.     if {$numberItems} then {
  1524.         set body "\t\\item\[Ñ\]  Ñ"
  1525.         for {set i 1} {$i < $numberItems} {incr i} {
  1526.             append body "\r\r\t\\item\[Ñ\]  Ñ"
  1527.         }
  1528.         append body "\r"
  1529.     } else {
  1530.         set body "\tÑ\r"
  1531.     }
  1532.     if {[insertEnvironment $envName "" $body]} then {
  1533.         nextTabStop
  1534.         message "type first item label"
  1535.     }
  1536. }
  1537. proc thebibliography {} {
  1538.     global promptNoisily useStatusBar
  1539.     set envName "thebibliography"
  1540.     if {$promptNoisily && $useStatusBar} {beep}
  1541.     catch {sPrompt "$envName:  how many items?" 3} numberItems
  1542.     if {$numberItems == "cancel"} then {
  1543.         return
  1544.     } elseif {![isUnsignedInteger $numberItems]} then {
  1545.         beep
  1546.         message "invalid input"
  1547.         return
  1548.     }
  1549.     set arg "{9}"
  1550.     if {$numberItems} then {
  1551.         if {$numberItems > 9} then {set arg "{99}"}
  1552.         set body "\t\\bibitem{Ñ}  Ñ"
  1553.         for {set i 1} {$i < $numberItems} {incr i} {
  1554.             append body "\r\r\t\\bibitem{Ñ}  Ñ"
  1555.         }
  1556.         append body "\r"
  1557.     } else {
  1558.         set body "\tÑ\r"
  1559.     }
  1560.     if {[insertEnvironment $envName $arg $body]} then {
  1561.         set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 {(9)+} [getPos]]
  1562.         eval select $searchResult
  1563.         message "Change the length of the key field?"
  1564.     }
  1565. }
  1566. proc slide {} { doWrapEnvironment "slide" }
  1567. proc overlay {} { doWrapEnvironment "overlay" }
  1568. proc note {} { doWrapEnvironment "note" }
  1569. proc figure {} {
  1570.     global useBoxMacro boxMacroName
  1571.     set envName "figure"
  1572.     set envArg "tbp"
  1573.     set arg "\[$envArg\]"
  1574.     set body ""
  1575.     if {$useBoxMacro} then {
  1576.         append body "\t\\centerline{\\$boxMacroName{Ñ}}\r"
  1577.     }
  1578.     append body "\t\\caption{Ñ}\r"
  1579.     append body "\t\\protect\\label{Ñ}\r"
  1580.     if {$useBoxMacro} then {
  1581.         if {![insertEnvironment $envName $arg $body]} then {return}
  1582.     } else {
  1583.         wrapEnvironment $envName $arg $body
  1584.     }
  1585.     set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 "$envArg" [getPos]]
  1586.     eval select $searchResult
  1587.     message "Modify this argument?  (t=top; b=bottom; p=page; h=here; !=try harder)"
  1588. }
  1589. proc table {} {
  1590.     set envName "table"
  1591.     set envArg "tbp"
  1592.     # The following statement puts the caption at the top:
  1593.     set arg "\[$envArg\]\r[getIndentation [getPos]]\t\\caption{Ñ}"
  1594.     # The following two statements put the caption at the bottom:
  1595. #     set arg "\[$envArg\]"
  1596. #     set body "\t\\caption{Ñ}\r"
  1597.     append body "\t\\protect\\label{Ñ}\r"
  1598.     wrapEnvironment $envName $arg $body
  1599.     set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 "$envArg" [getPos]]
  1600.     eval select $searchResult
  1601.     message "Modify this argument?  (t=top; b=bottom; p=page; h=here; !=try harder)"
  1602. }
  1603. proc buildRow {jmax} {
  1604.     set txt "Ñ"
  1605.     for {set j 1} {$j < $jmax} {incr j} {
  1606.         append txt " & Ñ"
  1607.     }
  1608.     return $txt
  1609. }
  1610. proc tabular {} {
  1611.     global promptNoisily useStatusBar
  1612.     set envName "tabular"
  1613.     if {$promptNoisily && $useStatusBar} {beep}
  1614.     catch {sPrompt "$envName:  how many rows?" 3} numberRows
  1615.     if {$numberRows == "cancel"} then {
  1616.         return
  1617.     } elseif {$numberRows == 0} then {
  1618.         beep
  1619.         message "positive number of rows required"
  1620.         return
  1621.     } elseif {![isUnsignedInteger $numberRows]} then {
  1622.         beep
  1623.         message "invalid input"
  1624.         return
  1625.     }
  1626.     if {$promptNoisily && $useStatusBar} {beep}
  1627.     catch {sPrompt "$envName:  how many columns?" 3} numberCols
  1628.     if {$numberCols == "cancel"} then {
  1629.         return
  1630.     } elseif {$numberCols == 0} then {
  1631.         beep
  1632.         message "positive number of columns required"
  1633.         return
  1634.     } elseif {![isUnsignedInteger $numberCols]} then {
  1635.         beep
  1636.         message "invalid input"
  1637.         return
  1638.     }
  1639.     set arg "{|"
  1640.     for {set j 1} {$j <= $numberCols} {incr j} {
  1641.         append arg "c|"
  1642.     }
  1643.     append arg "}"
  1644.     set body "\t\\hline\r"
  1645.     for {set i 1} {$i <= $numberRows} {incr i} {
  1646.         append body "\t[buildRow $numberCols]"
  1647.         append body "  \\\\\r\t\\hline\r"
  1648.     }
  1649.     if {[insertEnvironment $envName $arg $body]} then {
  1650.         set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 {(c|\|)+} [getPos]]
  1651.         select [lindex $searchResult 0] [lindex $searchResult 1]
  1652.         message "Modify this argument?"
  1653.     }
  1654. }
  1655. proc verbatim {} { doWrapEnvironment "verbatim" }
  1656. proc quote {} { doWrapEnvironment "quote" }
  1657. proc quotation {} { doWrapEnvironment "quotation" }
  1658. proc verse {} { doWrapEnvironment "verse" }
  1659. proc flushleft {} { doWrapEnvironment "flushleft" }
  1660. proc center {} { doWrapEnvironment "center" }
  1661. proc flushright {} { doWrapEnvironment "flushright" }
  1662. proc general {} {
  1663.     catch {prompt "What environment?" ""} environmentName
  1664.     if {$environmentName != "cancel"} {
  1665.         doWrapEnvironment "$environmentName"
  1666.     }
  1667. }
  1668.  
  1669. #--------------------------------------------------------------------------
  1670. # Boxes:
  1671. #--------------------------------------------------------------------------
  1672.  
  1673. proc mbox {} {
  1674.     if {[wrapObject "\\mbox{" "}Ñ"]} then {
  1675.         message "mbox set"
  1676.     } else {
  1677.         message "enter text"
  1678.     }
  1679. }
  1680. proc makebox {} {
  1681.     if {[wrapObject "\\makebox\[Ñ\]\[Ñ\]{" "}Ñ"]} then {
  1682.         message "makebox set; enter the width and position"
  1683.     } else {
  1684.         message "enter the width and position of the makebox, then the text"
  1685.     }
  1686. }
  1687. proc fbox {} {
  1688.     if {[wrapObject "\\fbox{" "}Ñ"]} then {
  1689.         message "fbox set"
  1690.     } else {
  1691.         message "enter text"
  1692.     }
  1693. }
  1694. proc framebox {} {
  1695.     if {[wrapObject "\\framebox\[Ñ\]\[Ñ\]{" "}Ñ"]} then {
  1696.         message "framebox set; enter the width and position"
  1697.     } else {
  1698.         message "enter the width and position of the framebox, then the text"
  1699.     }
  1700. }
  1701. proc newsavebox {} {
  1702.     if {[wrapObject "\\newsavebox{" "}Ñ"]} then {
  1703.         message "newsavebox defined"
  1704.     } else {
  1705.         message "enter the command name of the sbox or savebox"
  1706.     }
  1707. }
  1708. proc sbox {} {
  1709.     if {[wrapObject "\\sbox{Ñ}{" "}Ñ"]} then {
  1710.         message "sbox set; enter the command name"
  1711.     } else {
  1712.         message "enter the command name of the sbox, then the text"
  1713.     }
  1714. }
  1715. proc savebox {} {
  1716.     if {[wrapObject "\\savebox{Ñ}\[Ñ\]\[Ñ\]{" "}Ñ"]} then {
  1717.         message "savebox set; enter the command name"
  1718.     } else {
  1719.         message "enter the command name of the savebox"
  1720.     }
  1721. }
  1722. proc usebox {} {
  1723.     if {[wrapObject "\\usebox{" "}Ñ"]} then {
  1724.         message "usebox declared"
  1725.     } else {
  1726.         message "enter the command name of the sbox or savebox"
  1727.     }
  1728. }
  1729. proc raisebox {} {
  1730.     if {[wrapObject "\\raisebox{Ñ}\[Ñ\]\[Ñ\]{" "}Ñ"]} then {
  1731.         message "raisebox set; enter the displacement"
  1732.     } else {
  1733.         message "enter the displacement of the raisebox"
  1734.     }
  1735. }
  1736. proc parbox {} {
  1737.     if {[wrapObject "\\parbox\[Ñ\]\{Ñ\}{" "}Ñ"]} then {
  1738.         message "parbox set; enter the position and width"
  1739.     } else {
  1740.         message "enter the position \[b|c|t\] and width of the parbox, then the text"
  1741.     }
  1742. }
  1743. proc minipage {} {
  1744.     set arg "\[Ñ\]{Ñ}"
  1745.     wrapEnvironment "minipage" $arg ""
  1746.     nextTabStop
  1747.     message "enter the position \[b|c|t\] of the minipage, then the width"
  1748. }
  1749. proc rule {} {
  1750.     insertObject "\\rule\[Ñ\]\{Ñ\}{Ñ}Ñ"
  1751.     nthTabStop -4
  1752.     message "enter the displacement of the rule, then width and height"
  1753. }
  1754.  
  1755. #--------------------------------------------------------------------------
  1756. # Misc:
  1757. #--------------------------------------------------------------------------
  1758.  
  1759. proc ldots {} {insertObject "\\ldots"}
  1760. proc {en-dash} {} {insertObject "--"}
  1761. proc {em-dash} {} {insertObject "---"}
  1762. proc texLogo {} {insertObject "\\TeX"}
  1763. proc latexLogo {} {insertObject "\\LaTeX"}
  1764. proc latex2eLogo {} {insertObject "\\LaTeXe"}
  1765. proc today {} {insertObject "\\today"}
  1766. proc dag {} {insertObject "\\dag"}
  1767. proc ddag {} {insertObject "\\ddag"}
  1768. proc sectionMark {} {insertObject "\\S"}
  1769. proc paragraphMark {} {insertObject "\\P"}
  1770. proc copyright {} {insertObject "\\copyright"}
  1771. proc pounds {} {insertObject "\\pounds"}
  1772. proc quotes {} {
  1773.     if {[wrapObject "`" "'Ñ"]} then {
  1774.         message "text quoted"
  1775.     } else {
  1776.         message "enter text"
  1777.     }
  1778. }
  1779. proc dblQuotes {} {
  1780.     if {[wrapObject "``" "''Ñ"]} then {
  1781.         message "text double quoted"
  1782.     } else {
  1783.         message "enter text"
  1784.     }
  1785. }
  1786. proc marginalNote {} {
  1787.     if {[wrapObject "\\marginpar{" "}Ñ"]} then {
  1788.         message "marginal note set"
  1789.     } else {
  1790.         message "enter marginal note"
  1791.     }
  1792. }
  1793. proc footnote {} {
  1794.     if {[wrapObject "\\footnote{" "}Ñ"]} then {
  1795.         message "footnote set"
  1796.     } else {
  1797.         message "enter footnote"
  1798.     }
  1799. }
  1800. proc label {} {
  1801.     if {[wrapObject "\\label{" "}Ñ"]} then {
  1802.         message "label defined"
  1803.     } else {
  1804.         message "enter label"
  1805.     }
  1806. }
  1807. proc ref {} { 
  1808.     if {[wrapObject "\\ref{" "}Ñ"]} then {
  1809.         message "cross-reference made"
  1810.     } else {
  1811.         message "enter cross-reference"
  1812.     }
  1813. }
  1814. proc pageref {} { 
  1815.     if {[wrapObject "\\pageref{" "}Ñ"]} then {
  1816.         message "page reference made"
  1817.     } else {
  1818.         message "enter page reference"
  1819.     }
  1820. }
  1821. proc cite {} {
  1822.     if {[wrapObject "\\cite{" "}Ñ"]} then {
  1823.         message "citation made"
  1824.     } else {
  1825.         message "enter citation"
  1826.     }
  1827. }
  1828. # Insert an \item or a \bibitem, depending on the context.
  1829. proc insertItem {} {
  1830. #     global TeXmodeVars
  1831. #     if {$TeXmodeVars(expertMode) == 0} then {
  1832. #         if {![isInDocument]} then {
  1833. #             if {$TeXmodeVars(searchNoisily)} {beep}
  1834. #             case [askyesno "The cursor is not in the document environment.\
  1835. #                             \rContinue the operation?"] in {
  1836. #                 "yes" {}
  1837. #                 "no" {error "insertItem:  out of context"}
  1838. #             }
  1839. #         }
  1840. #     }
  1841.     set command [eval getText [searchEnvironment]]
  1842.     set environment [extractCommandArg $command]
  1843.     case $environment in {
  1844.         {itemize enumerate} {
  1845.             set text "\\item  Ñ"
  1846.         }
  1847.         "description" {
  1848.             set text "\\item\[Ñ\]  Ñ"
  1849.         }
  1850.         "thebibliography" {
  1851.             set text "\\bibitem{Ñ}  Ñ"
  1852.         }
  1853.         default {
  1854.             beep
  1855.             message "insertItem: cursor in $environment environment"
  1856.             return
  1857.         }
  1858.     }
  1859.     set pos [getPos]
  1860.     # Indentation should mirror that of an existing \item
  1861.     # (if it exists)
  1862.     insertText [openingCarriageReturn]$text
  1863.     goto $pos
  1864.     nextTabStop
  1865. }
  1866.  
  1867.  
  1868. #############################################################################
  1869. # 
  1870. # Math Mode Macros
  1871. #
  1872. #############################################################################
  1873.  
  1874. #--------------------------------------------------------------------------
  1875. # Math Modes:
  1876. #--------------------------------------------------------------------------
  1877.  
  1878. proc texMath {} {
  1879.     checkMathMode "texMath" 0
  1880.     if {[wrapObject "$" "$Ñ"]} then {
  1881.         message "formula set"
  1882.     } else {
  1883.         message "enter formula"
  1884.     }
  1885. }
  1886. proc texDisplaymath {} {
  1887.     checkMathMode "texDisplaymath" 0
  1888.     if {[wrapObject "$$" "$$Ñ"]} then {
  1889.         message "displayed formula set"
  1890.     } else {
  1891.         message "enter displayed formula"
  1892.     }
  1893. }
  1894. proc latexMath {} {
  1895.     checkMathMode "latexMath" 0
  1896.     if {[wrapObject "\\( " " \\)Ñ"]} then {
  1897.         message "formula set"
  1898.     } else {
  1899.         message "enter formula"
  1900.     }
  1901. }
  1902. proc latexDisplaymath {} {
  1903.     checkMathMode "latexDisplaymath" 0
  1904.     if {[wrapObject "\\\[ " " \\\]Ñ"]} then {
  1905.         message "displayed formula set"
  1906.     } else {
  1907.         message "enter displayed formula"
  1908.     }
  1909. }
  1910.  
  1911. #--------------------------------------------------------------------------
  1912. # Math Style:
  1913. #--------------------------------------------------------------------------
  1914.  
  1915. proc mathit {} {
  1916.     checkMathMode "mathit" 1
  1917.     if {[wrapObject "\\mathit{" "}Ñ"]} then {
  1918.         message "selected text is math italic"
  1919.     } else {
  1920.         message "enter text to be math italic"
  1921.     }
  1922. }
  1923. proc mathrm {} {
  1924.     checkMathMode "mathrm" 1
  1925.     if {[wrapObject "\\mathrm{" "}Ñ"]} then {
  1926.         message "selected text is math roman"
  1927.     } else {
  1928.         message "enter text to be math roman"
  1929.     }
  1930. }
  1931. proc mathbf {} {
  1932.     checkMathMode "mathbf" 1
  1933.     if {[wrapObject "\\mathbf{" "}Ñ"]} then {
  1934.         message "selected text is math bold"
  1935.     } else {
  1936.         message "enter text to be math bold"
  1937.     }
  1938. }
  1939. proc mathsf {} {
  1940.     checkMathMode "mathsf" 1
  1941.     if {[wrapObject "\\mathsf{" "}Ñ"]} then {
  1942.         message "selected text is math sans serif"
  1943.     } else {
  1944.         message "enter text to be math sans serif"
  1945.     }
  1946. }
  1947. proc mathtt {} {
  1948.     checkMathMode "mathtt" 1
  1949.     if {[wrapObject "\\mathtt{" "}Ñ"]} then {
  1950.         message "selected text is math typewriter"
  1951.     } else {
  1952.         message "enter text to be math typewriter"
  1953.     }
  1954. }
  1955. proc mathcal {} {
  1956.     checkMathMode "mathcal" 1
  1957.     # Allow upper-case arguments only:
  1958.     if {[isSelection] && ![isUppercase]} then {
  1959.         alertnote "argument to \\mathcal must be uppercase"
  1960.         return
  1961.     }
  1962.     if {[wrapObject "\\mathcal{" "}Ñ"]} then {
  1963.         message "selected text is calligraphic"
  1964.     } else {
  1965.         message "enter text to be calligraphic (UPPERCASE letters only)"
  1966.     }
  1967. }
  1968. proc displaystyle {} {
  1969.     checkMathMode "displaystyle" 1
  1970.     if {[wrapObject "{\\displaystyle " "}Ñ"]} then {
  1971.         message "displaystyle set"
  1972.     } else {
  1973.         message "enter displaystyle text"
  1974.     }
  1975. }
  1976. proc textstyle {} {
  1977.     checkMathMode "textstyle" 1
  1978.     if {[wrapObject "{\\textstyle " "}Ñ"]} then {
  1979.         message "textstyle set"
  1980.     } else {
  1981.         message "enter textstyle text"
  1982.     }
  1983. }
  1984. proc scriptstyle {} {
  1985.     checkMathMode "scriptstyle" 1
  1986.     if {[wrapObject "{\\scriptstyle " "}Ñ"]} then {
  1987.         message "scriptstyle set"
  1988.     } else {
  1989.         message "enter scriptstyle text"
  1990.     }
  1991. }
  1992. proc scriptscriptstyle {} {
  1993.     checkMathMode "scriptscriptstyle" 1
  1994.     if {[wrapObject "{\\scriptscriptstyle " "}Ñ"]} then {
  1995.         message "scriptscriptstyle set"
  1996.     } else {
  1997.         message "enter scriptscriptstyle text"
  1998.     }
  1999. }
  2000.  
  2001. #--------------------------------------------------------------------------
  2002. # Math Environments:
  2003. #--------------------------------------------------------------------------
  2004.  
  2005. proc math {} { checkMathMode "math" 0; doWrapEnvironment "math" }
  2006. proc displaymath {} {
  2007.     checkMathMode "displaymath" 0
  2008.     doWrapEnvironment "displaymath"
  2009. }
  2010. proc equation {} {
  2011.     checkMathMode "equation" 0
  2012.     set envName "equation"
  2013.     set body "\t\\label{Ñ}\r"
  2014.     if {[wrapEnvironment $envName "" $body]} then {
  2015.         set msgText "equation wrapped"
  2016.     } else {
  2017.         set msgText "enter equation"
  2018.     }
  2019.     nextTabStop
  2020.     message $msgText
  2021. }
  2022. proc eqnarrayStar {} {
  2023.     global promptNoisily useStatusBar
  2024.     checkMathMode "eqnarrayStar" 0
  2025.     set envName "eqnarray*"
  2026.     if {$promptNoisily && $useStatusBar} {beep}
  2027.     catch {sPrompt "$envName:  how many rows?" 3} numberRows
  2028.     if {$numberRows == "cancel"} then {
  2029.         return
  2030.     } elseif {$numberRows == 0} then {
  2031.         beep
  2032.         message "positive number of rows required"
  2033.         return
  2034.     } elseif {![isUnsignedInteger $numberRows]} then {
  2035.         beep
  2036.         message "invalid input"
  2037.         return
  2038.     }
  2039.     set row "\t[buildRow 3]"
  2040.     for {set i 1} {$i < $numberRows} {incr i} {
  2041.         append body $row
  2042.         append body "  \\\\\r"
  2043.     }
  2044.     append body $row
  2045.     append body "\r"
  2046.     if {[insertEnvironment $envName "" $body]} then {
  2047.         nextTabStop
  2048.         message "type first item"
  2049.     }
  2050. }
  2051. proc eqnarray {} {
  2052.     global promptNoisily useStatusBar
  2053.     checkMathMode "eqnarray" 0
  2054.     set envName "eqnarray"
  2055.     if {$promptNoisily && $useStatusBar} {beep}
  2056.     catch {sPrompt "$envName:  how many rows?" 3} numberRows
  2057.     if {$numberRows == "cancel"} then {
  2058.         return
  2059.     } elseif {$numberRows == 0} then {
  2060.         beep
  2061.         message "positive number of rows required"
  2062.         return
  2063.     } elseif {![isUnsignedInteger $numberRows]} then {
  2064.         beep
  2065.         message "invalid input"
  2066.         return
  2067.     }
  2068.     set row "\t[buildRow 3]\r\t\\label{Ñ}"
  2069.     for {set i 1} {$i < $numberRows} {incr i} {
  2070.         append body $row
  2071.         append body "  \\\\\r"
  2072.     }
  2073.     append body $row
  2074.     append body "\r"
  2075.     if {[insertEnvironment $envName "" $body]} then {
  2076.         nextTabStop
  2077.         message "type first item"
  2078.     }
  2079. }
  2080. proc myArray {} {
  2081.     global promptNoisily useStatusBar
  2082.     checkMathMode "myArray" 1
  2083.     set envName "array"
  2084.     if {$promptNoisily && $useStatusBar} {beep}
  2085.     catch {sPrompt "$envName:  how many rows?" 3} numberRows
  2086.     if {$numberRows == "cancel"} then {
  2087.         return
  2088.     } elseif {$numberRows == 0} then {
  2089.         beep
  2090.         message "positive number of rows required"
  2091.         return
  2092.     } elseif {![isUnsignedInteger $numberRows]} then {
  2093.         beep
  2094.         message "invalid input"
  2095.         return
  2096.     }
  2097.     if {$promptNoisily && $useStatusBar} {beep}
  2098.     catch {sPrompt "$envName:  how many columns?" 3} numberCols
  2099.     if {$numberCols == "cancel"} then {
  2100.         return
  2101.     } elseif {$numberCols == 0} then {
  2102.         beep
  2103.         message "positive number of columns required"
  2104.         return
  2105.     } elseif {![isUnsignedInteger $numberCols]} then {
  2106.         beep
  2107.         message "invalid input"
  2108.         return
  2109.     }
  2110.     set arg "{"
  2111.     for {set j 1} {$j <= $numberCols} {incr j} {
  2112.         append arg "c"
  2113.     }
  2114.     append arg "}"
  2115.     set row "\t[buildRow $numberCols]"
  2116.     for {set i 1} {$i < $numberRows} {incr i} {
  2117.         append body $row
  2118.         append body "  \\\\\r"
  2119.     }
  2120.     append body $row
  2121.     append body "\r"
  2122.     if {[insertEnvironment $envName $arg $body]} then {
  2123.         set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 {c+} [getPos]]
  2124.         select [lindex $searchResult 0] [lindex $searchResult 1]
  2125.         message "Modify this argument?"
  2126.     }
  2127. }
  2128.  
  2129. #--------------------------------------------------------------------------
  2130. # Formulas:
  2131. #--------------------------------------------------------------------------
  2132.  
  2133. proc subscript {} {
  2134.     checkMathMode "subscript" 1
  2135.     if {[wrapObject "_{" "}Ñ"]} then {
  2136.         message "subscript set"
  2137.     } else {
  2138.         message "enter subscript"
  2139.     }
  2140. }
  2141. proc superscript {} {
  2142.     checkMathMode "superscript" 1
  2143.     if {[wrapObject "^{" "}Ñ"]} then {
  2144.         message "superscript set"
  2145.     } else {
  2146.         message "enter superscript"
  2147.     }
  2148. }
  2149. proc fraction {} {
  2150.     checkMathMode "fraction" 1
  2151.     set currentPos [getPos]
  2152.     if {[isSelection]} then {
  2153.         set selection [getSelect]
  2154.         set args [split $selection /]
  2155.         set len [llength $args]
  2156.         deleteText $currentPos [selEnd]
  2157.         if {$len == 1} then {
  2158.             insertObject "\\frac{$selection}{Ñ}Ñ"
  2159.             goto $currentPos
  2160.             nextTabStop
  2161.             message "enter denominator"
  2162.         } else {
  2163.             set firstArg [lindex $args 0]
  2164.             set restArgs [lrange $args 1 [expr $len-1]]
  2165.             insertObject "\\frac{$firstArg}{[join $restArgs /]}"
  2166.             if {$len > 2} {message "beware of multiple /"}
  2167.         }
  2168.     } else {
  2169.         insertObject "\\frac{Ñ}{Ñ}Ñ"
  2170.         goto $currentPos
  2171.         nextTabStop
  2172.         message "enter numerator"
  2173.     }
  2174. }
  2175. proc squareRoot {} {
  2176.     checkMathMode "squareRoot" 1
  2177.     if {[wrapObject "\\sqrt{" "}Ñ"]} then {
  2178.         message "square root set"
  2179.     } else {
  2180.         message "enter formula"
  2181.     }
  2182. }
  2183. proc nthRoot {} {
  2184.     checkMathMode "nthRoot" 1
  2185.     if {[wrapObject "\\sqrt\[Ñ\]{" "}Ñ"]} then {
  2186.         message "enter root"
  2187.     } else {
  2188.         message "enter root, then formula"
  2189.     }
  2190. }
  2191. proc oneParameter {} {
  2192.     checkMathMode "oneParameter" 1
  2193.     catch {prompt "Command name?" "sqrt"} commandName
  2194.     if {$commandName != "cancel"} {wrapObject "\\$commandName{" "}Ñ"}
  2195. }
  2196. proc twoParameters {} {
  2197.     checkMathMode "twoParameters" 1
  2198.     catch {prompt "Command name?" "frac"} commandName
  2199.     if {$commandName != "cancel"} then {
  2200.         set currentPos [getPos]
  2201.         if {[insertObject "\\$commandName{Ñ}{Ñ}Ñ"]} then {
  2202.             goto $currentPos
  2203.             nextTabStop
  2204.         }
  2205.     }
  2206. }
  2207.  
  2208. #--------------------------------------------------------------------------
  2209. # Greek:
  2210. #--------------------------------------------------------------------------
  2211.  
  2212. proc alpha {} {checkMathMode "alpha" 1; insertObject "\\alpha"}
  2213. proc beta {} {checkMathMode "beta" 1; insertObject "\\beta"}
  2214. proc gamma {} {checkMathMode "gamma" 1; insertObject "\\gamma"}
  2215. proc delta {} {checkMathMode "delta" 1; insertObject "\\delta"}
  2216. proc epsilon {} {checkMathMode "epsilon" 1; insertObject "\\epsilon"}
  2217. proc zeta {} {checkMathMode "zeta" 1; insertObject "\\zeta"}
  2218. proc eta {} {checkMathMode "eta" 1; insertObject "\\eta"}
  2219. proc theta {} {checkMathMode "theta" 1; insertObject "\\theta"}
  2220. proc iota {} {checkMathMode "iota" 1; insertObject "\\iota"}
  2221. proc kappa {} {checkMathMode "kappa" 1; insertObject "\\kappa"}
  2222. proc lambda {} {checkMathMode "lambda" 1; insertObject "\\lambda"}
  2223. proc mu {} {checkMathMode "mu" 1; insertObject "\\mu"}
  2224. proc nu {} {checkMathMode "nu" 1; insertObject "\\nu"}
  2225. proc xi {} {checkMathMode "xi" 1; insertObject "\\xi"}
  2226. proc omicron {} {checkMathMode "omicron" 1; insertObject "o"}
  2227. proc pi {} {checkMathMode "pi" 1; insertObject "\\pi"}
  2228. proc rho {} {checkMathMode "rho" 1; insertObject "\\rho"}
  2229. proc sigma {} {checkMathMode "sigma" 1; insertObject "\\sigma"}
  2230. proc tau {} {checkMathMode "tau" 1; insertObject "\\tau"}
  2231. proc upsilon {} {checkMathMode "upsilon" 1; insertObject "\\upsilon"}
  2232. proc phi {} {checkMathMode "phi" 1; insertObject "\\phi"}
  2233. proc chi {} {checkMathMode "chi" 1; insertObject "\\chi"}
  2234. proc psi {} {checkMathMode "psi" 1; insertObject "\\psi"}
  2235. proc omega {} {checkMathMode "omega" 1; insertObject "\\omega"}
  2236.  
  2237. proc Gamma {} {checkMathMode "Gamma" 1; insertObject "\\Gamma"}
  2238. proc Delta {} {checkMathMode "Delta" 1; insertObject "\\Delta"}
  2239. proc Theta {} {checkMathMode "Theta" 1; insertObject "\\Theta"}
  2240. proc Lambda {} {checkMathMode "Lambda" 1; insertObject "\\Lambda"}
  2241. proc Xi {} {checkMathMode "Xi" 1; insertObject "\\Xi"}
  2242. proc Pi {} {checkMathMode "Pi" 1; insertObject "\\Pi"}
  2243. proc Sigma {} {checkMathMode "Sigma" 1; insertObject "\\Sigma"}
  2244. proc Upsilon {} {checkMathMode "Upsilon" 1; insertObject "\\Upsilon"}
  2245. proc Phi {} {checkMathMode "Phi" 1; insertObject "\\Phi"}
  2246. proc Psi {} {checkMathMode "Psi" 1; insertObject "\\Psi"}
  2247. proc Omega {} {checkMathMode "Omega" 1; insertObject "\\Omega"}
  2248.  
  2249. proc varepsilon {} {checkMathMode "varepsilon" 1; insertObject "\\varepsilon"}
  2250. proc vartheta {} {checkMathMode "vartheta" 1; insertObject "\\vartheta"}
  2251. proc varpi {} {checkMathMode "varpi" 1; insertObject "\\varpi"}
  2252. proc varrho {} {checkMathMode "varrho" 1; insertObject "\\varrho"}
  2253. proc varsigma {} {checkMathMode "varsigma" 1; insertObject "\\varsigma"}
  2254. proc varphi {} {checkMathMode "varphi" 1; insertObject "\\varphi"}
  2255.  
  2256. #--------------------------------------------------------------------------
  2257. # Binary Ops:
  2258. #--------------------------------------------------------------------------
  2259.  
  2260. proc pm {} {checkMathMode "pm" 1; insertObject "\\pm"}
  2261. proc mp {} {checkMathMode "mp" 1; insertObject "\\mp"}
  2262. proc times {} {checkMathMode "times" 1; insertObject "\\times"}
  2263. proc div {} {checkMathMode "div" 1; insertObject "\\div"}
  2264. proc ast {} {checkMathMode "ast" 1; insertObject "\\ast"}
  2265. proc star {} {checkMathMode "star" 1; insertObject "\\star"}
  2266. proc circ {} {checkMathMode "circ" 1; insertObject "\\circ"}
  2267. proc bullet {} {checkMathMode "bullet" 1; insertObject "\\bullet"}
  2268. proc cdot {} {checkMathMode "cdot" 1; insertObject "\\cdot"}
  2269. proc cap {} {checkMathMode "cap" 1; insertObject "\\cap"}
  2270. proc cup {} {checkMathMode "cup" 1; insertObject "\\cup"}
  2271. proc uplus {} {checkMathMode "uplus" 1; insertObject "\\uplus"}
  2272. proc sqcap {} {checkMathMode "sqcap" 1; insertObject "\\sqcap"}
  2273. proc sqcup {} {checkMathMode "sqcup" 1; insertObject "\\sqcup"}
  2274. proc vee {} {checkMathMode "vee" 1; insertObject "\\vee"}
  2275. proc wedge {} {checkMathMode "wedge" 1; insertObject "\\wedge"}
  2276. proc setminus {} {checkMathMode "setminus" 1; insertObject "\\setminus"}
  2277. proc wr {} {checkMathMode "wr" 1; insertObject "\\wr"}
  2278. proc diamond {} {checkMathMode "diamond" 1; insertObject "\\diamond"}
  2279. proc bigtriangleup {} {
  2280.     checkMathMode "bigtriangleup" 1; insertObject "\\bigtriangleup"
  2281. }
  2282. proc bigtriangledown {} {
  2283.     checkMathMode "bigtriangledown" 1; insertObject "\\bigtriangledown"
  2284. }
  2285. proc triangleleft {} {
  2286.     checkMathMode "triangleleft" 1; insertObject "\\triangleleft"
  2287. }
  2288. proc triangleright {} {
  2289.     checkMathMode "triangleright" 1; insertObject "\\triangleright"
  2290. }
  2291. proc lhd {} {
  2292.     if {[isSymbolPackageLoaded]} then {
  2293.         checkMathMode "lhd" 1; insertObject "\\lhd"
  2294.     }
  2295. }
  2296. proc rhd {} {
  2297.     if {[isSymbolPackageLoaded]} then {
  2298.         checkMathMode "rhd" 1; insertObject "\\rhd"
  2299.     }
  2300. }
  2301. proc unlhd {} {
  2302.     if {[isSymbolPackageLoaded]} then {
  2303.         checkMathMode "unlhd" 1; insertObject "\\unlhd"
  2304.     }
  2305. }
  2306. proc unrhd {} {
  2307.     if {[isSymbolPackageLoaded]} then {
  2308.         checkMathMode "unrhd" 1; insertObject "\\unrhd"
  2309.     }
  2310. }
  2311. proc oplus {} {checkMathMode "oplus" 1; insertObject "\\oplus"}
  2312. proc ominus {} {checkMathMode "ominus" 1; insertObject "\\ominus"}
  2313. proc otimes {} {checkMathMode "otimes" 1; insertObject "\\otimes"}
  2314. proc oslash {} {checkMathMode "oslash" 1; insertObject "\\oslash"}
  2315. proc odot {} {checkMathMode "odot" 1; insertObject "\\odot"}
  2316. proc bigcirc {} {checkMathMode "bigcirc" 1; insertObject "\\bigcirc"}
  2317. proc dagger {} {checkMathMode "dagger" 1; insertObject "\\dagger"}
  2318. proc ddagger {} {checkMathMode "ddagger" 1; insertObject "\\ddagger"}
  2319. proc amalg {} {checkMathMode "amalg" 1; insertObject "\\amalg"}
  2320.  
  2321. #--------------------------------------------------------------------------
  2322. # Relations:
  2323. #--------------------------------------------------------------------------
  2324.  
  2325. proc leq {} {checkMathMode "leq" 1; insertObject "\\leq"}
  2326. proc prec {} {checkMathMode "prec" 1; insertObject "\\prec"}
  2327. proc preceq {} {checkMathMode "preceq" 1; insertObject "\\preceq"}
  2328. proc myLl {} {checkMathMode "myLl" 1; insertObject "\\ll"}
  2329. proc subset {} {checkMathMode "subset" 1; insertObject "\\subset"}
  2330. proc subseteq {} {checkMathMode "subseteq" 1; insertObject "\\subseteq"}
  2331. proc sqsubset {} {
  2332.     if {[isSymbolPackageLoaded]} then {
  2333.         checkMathMode "sqsubset" 1; insertObject "\\sqsubset"
  2334.     }
  2335. }
  2336. proc sqsubseteq {} {checkMathMode "sqsubseteq" 1; insertObject "\\sqsubseteq"}
  2337. proc in {} {checkMathMode "in" 1; insertObject "\\in"}
  2338. proc vdash {} {checkMathMode "vdash" 1; insertObject "\\vdash"}
  2339.  
  2340. proc geq {} {checkMathMode "geq" 1; insertObject "\\geq"}
  2341. proc succ {} {checkMathMode "succ" 1; insertObject "\\succ"}
  2342. proc succeq {} {checkMathMode "succeq" 1; insertObject "\\succeq"}
  2343. proc gg {} {checkMathMode "gg" 1; insertObject "\\gg"}
  2344. proc supset {} {checkMathMode "supset" 1; insertObject "\\supset"}
  2345. proc supseteq {} {checkMathMode "supseteq" 1; insertObject "\\supseteq"}
  2346. proc sqsupset {} {
  2347.     if {[isSymbolPackageLoaded]} then {
  2348.         checkMathMode "sqsupset" 1; insertObject "\\sqsupset"
  2349.     }
  2350. }
  2351. proc sqsupseteq {} {checkMathMode "sqsupseteq" 1; insertObject "\\sqsupseteq"}
  2352. proc ni {} {checkMathMode "ni" 1; insertObject "\\ni"}
  2353. proc dashv {} {checkMathMode "dashv" 1; insertObject "\\dashv"}
  2354.  
  2355. proc equiv {} {checkMathMode "equiv" 1; insertObject "\\equiv"}
  2356. proc sim {} {checkMathMode "sim" 1; insertObject "\\sim"}
  2357. proc simeq {} {checkMathMode "simeq" 1; insertObject "\\simeq"}
  2358. proc asymp {} {checkMathMode "asymp" 1; insertObject "\\asymp"}
  2359. proc approx {} {checkMathMode "approx" 1; insertObject "\\approx"}
  2360. proc cong {} {checkMathMode "cong" 1; insertObject "\\cong"}
  2361. proc neq {} {checkMathMode "neq" 1; insertObject "\\neq"}
  2362. proc doteq {} {checkMathMode "doteq" 1; insertObject "\\doteq"}
  2363. proc propto {} {checkMathMode "propto" 1; insertObject "\\propto"}
  2364.  
  2365. proc models {} {checkMathMode "models" 1; insertObject "\\models"}
  2366. proc perp {} {checkMathMode "perp" 1; insertObject "\\perp"}
  2367. proc mid {} {checkMathMode "mid" 1; insertObject "\\mid"}
  2368. proc parallel {} {checkMathMode "parallel" 1; insertObject "\\parallel"}
  2369. proc bowtie {} {checkMathMode "bowtie" 1; insertObject "\\bowtie"}
  2370. proc myJoin {} {
  2371.     if {[isSymbolPackageLoaded]} then {
  2372.         checkMathMode "myJoin" 1; insertObject "\\join"
  2373.     }
  2374. }
  2375. proc smile {} {checkMathMode "smile" 1; insertObject "\\smile"}
  2376. proc frown {} {checkMathMode "frown" 1; insertObject "\\frown"}
  2377.  
  2378. #--------------------------------------------------------------------------
  2379. # Arrows:
  2380. #--------------------------------------------------------------------------
  2381.  
  2382. proc leftarrow {} {checkMathMode "leftarrow" 1; insertObject "\\leftarrow"}
  2383. proc Leftarrow {} {checkMathMode "Leftarrow" 1; insertObject "\\Leftarrow"}
  2384. proc rightarrow {} {checkMathMode "rightarrow" 1; insertObject "\\rightarrow"}
  2385. proc Rightarrow {} {checkMathMode "Rightarrow" 1; insertObject "\\Rightarrow"}
  2386. proc leftrightarrow {} {
  2387.     checkMathMode "leftrightarrow" 1; insertObject "\\leftrightarrow"
  2388. }
  2389. proc Leftrightarrow {} {
  2390.     checkMathMode "Leftrightarrow" 1; insertObject "\\Leftrightarrow"
  2391. }
  2392. proc mapsto {} {checkMathMode "mapsto" 1; insertObject "\\mapsto"}
  2393. proc hookleftarrow {} {
  2394.     checkMathMode "hookleftarrow" 1; insertObject "\\hookleftarrow"
  2395. }
  2396. proc leftharpoonup {} {
  2397.     checkMathMode "leftharpoonup" 1; insertObject "\\leftharpoonup"
  2398. }
  2399. proc leftharpoondown {} {
  2400.     checkMathMode "leftharpoondown" 1; insertObject "\\leftharpoondown"
  2401. }
  2402. proc rightleftharpoons {} {
  2403.     checkMathMode "rightleftharpoons" 1; insertObject "\\rightleftharpoons"
  2404. }
  2405.  
  2406. proc longleftarrow {} {
  2407.     checkMathMode "longleftarrow" 1; insertObject "\\longleftarrow"
  2408. }
  2409. proc Longleftarrow {} {
  2410.     checkMathMode "Longleftarrow" 1; insertObject "\\Longleftarrow"
  2411. }
  2412. proc longrightarrow {} {
  2413.     checkMathMode "longrightarrow" 1; insertObject "\\longrightarrow"
  2414. }
  2415. proc Longrightarrow {} {
  2416.     checkMathMode "Longrightarrow" 1; insertObject "\\Longrightarrow"
  2417. }
  2418. proc longleftrightarrow {} {
  2419.     checkMathMode "longleftrightarrow" 1; insertObject "\\longleftrightarrow"
  2420. }
  2421. proc Longleftrightarrow {} {
  2422.     checkMathMode "Longleftrightarrow" 1; insertObject "\\Longleftrightarrow"
  2423. }
  2424. proc longmapsto {} {checkMathMode "longmapsto" 1; insertObject "\\longmapsto"}
  2425. proc hookrightarrow {} {
  2426.     checkMathMode "hookrightarrow" 1; insertObject "\\hookrightarrow"
  2427. }
  2428. proc rightharpoonup {} {
  2429.     checkMathMode "rightharpoonup" 1; insertObject "\\rightharpoonup"
  2430. }
  2431. proc rightharpoondown {} {
  2432.     checkMathMode "rightharpoondown" 1; insertObject "\\rightharpoondown"
  2433. }
  2434. proc leadsto {} {
  2435.     if {[isSymbolPackageLoaded]} then {
  2436.         checkMathMode "leadsto" 1; insertObject "\\leadsto"
  2437.     }
  2438. }
  2439. proc uparrow {} {checkMathMode "uparrow" 1; insertObject "\\uparrow"}
  2440. proc Uparrow {} {checkMathMode "Uparrow" 1; insertObject "\\Uparrow"}
  2441. proc downarrow {} {checkMathMode "downarrow" 1; insertObject "\\downarrow"}
  2442. proc Downarrow {} {checkMathMode "Downarrow" 1; insertObject "\\Downarrow"}
  2443. proc updownarrow {} {checkMathMode "updownarrow" 1; insertObject "\\updownarrow"}
  2444. proc Updownarrow {} {checkMathMode "Updownarrow" 1; insertObject "\\Updownarrow"}
  2445. proc nearrow {} {checkMathMode "nearrow" 1; insertObject "\\nearrow"}
  2446. proc searrow {} {checkMathMode "searrow" 1; insertObject "\\searrow"}
  2447. proc swarrow {} {checkMathMode "swarrow" 1; insertObject "\\swarrow"}
  2448. proc nwarrow {} {checkMathMode "nwarrow" 1; insertObject "\\nwarrow"}
  2449.  
  2450. #--------------------------------------------------------------------------
  2451. # Dots:
  2452. #--------------------------------------------------------------------------
  2453.  
  2454. proc cdots {} {checkMathMode "cdots" 1; insertObject "\\cdots"}
  2455. proc vdots {} {checkMathMode "vdots" 1; insertObject "\\vdots"}
  2456. proc ddots {} {checkMathMode "ddots" 1; insertObject "\\ddots"}
  2457.  
  2458. #--------------------------------------------------------------------------
  2459. # Symbols:
  2460. #--------------------------------------------------------------------------
  2461.  
  2462. proc aleph {} {checkMathMode "aleph" 1; insertObject "\\aleph"}
  2463. proc hbar {} {checkMathMode "hbar" 1; insertObject "\\hbar"}
  2464. proc imath {} {checkMathMode "imath" 1; insertObject "\\imath"}
  2465. proc jmath {} {checkMathMode "jmath" 1; insertObject "\\jmath"}
  2466. proc ell {} {checkMathMode "ell" 1; insertObject "\\ell"}
  2467. proc wp {} {checkMathMode "wp" 1; insertObject "\\wp"}
  2468. proc Re {} {checkMathMode "Re" 1; insertObject "\\Re"}
  2469. proc Im {} {checkMathMode "Im" 1; insertObject "\\Im"}
  2470. proc mho {} {
  2471.     if {[isSymbolPackageLoaded]} then {
  2472.         checkMathMode "mho" 1; insertObject "\\mho"
  2473.     }
  2474. }
  2475. proc prime {} {checkMathMode "prime" 1; insertObject "\\prime"}
  2476. proc emptyset {} {checkMathMode "emptyset" 1; insertObject "\\emptyset"}
  2477. proc nabla {} {checkMathMode "nabla" 1; insertObject "\\nabla"}
  2478. proc surd {} {checkMathMode "surd" 1; insertObject "\\surd"}
  2479. proc top {} {checkMathMode "top" 1; insertObject "\\top"}
  2480. proc bot {} {checkMathMode "bot" 1; insertObject "\\bot"}
  2481. # proc | {} {checkMathMode "|" 1; insertObject "\\|"}
  2482. proc angle {} {checkMathMode "angle" 1; insertObject "\\angle"}
  2483. proc forall {} {checkMathMode "forall" 1; insertObject "\\forall"}
  2484. proc exists {} {checkMathMode "exists" 1; insertObject "\\exists"}
  2485. proc neg {} {checkMathMode "neg" 1; insertObject "\\neg"}
  2486. proc flat {} {checkMathMode "flat" 1; insertObject "\\flat"}
  2487. proc natural {} {checkMathMode "natural" 1; insertObject "\\natural"}
  2488. proc sharp {} {checkMathMode "sharp" 1; insertObject "\\sharp"}
  2489. proc backslash {} {checkMathMode "backslash" 1; insertObject "\\backslash"}
  2490. proc partial {} {checkMathMode "partial" 1; insertObject "\\partial"}
  2491. proc infty {} {checkMathMode "infty" 1; insertObject "\\infty"}
  2492. proc Box {} {
  2493.     if {[isSymbolPackageLoaded]} then {
  2494.         checkMathMode "Box" 1; insertObject "\\Box"
  2495.     }
  2496. }
  2497. proc Diamond {} {
  2498.     if {[isSymbolPackageLoaded]} then {
  2499.         checkMathMode "Diamond" 1; insertObject "\\Diamond"
  2500.     }
  2501. }
  2502. proc triangle {} {checkMathMode "triangle" 1; insertObject "\\triangle"}
  2503. proc clubsuit {} {checkMathMode "clubsuit" 1; insertObject "\\clubsuit"}
  2504. proc diamondsuit {} {checkMathMode "diamondsuit" 1; insertObject "\\diamondsuit"}
  2505. proc heartsuit {} {checkMathMode "heartsuit" 1; insertObject "\\heartsuit"}
  2506. proc spadesuit {} {checkMathMode "spadesuit" 1; insertObject "\\spadesuit"}
  2507.  
  2508. #--------------------------------------------------------------------------
  2509. # Functions:
  2510. #--------------------------------------------------------------------------
  2511.  
  2512. proc arccos {} {checkMathMode "arccos" 1; insertObject "\\arccos"}
  2513. proc arcsin {} {checkMathMode "arcsin" 1; insertObject "\\arcsin"}
  2514. proc arctan {} {checkMathMode "arctan" 1; insertObject "\\arctan"}
  2515. proc arg {} {checkMathMode "arg" 1; insertObject "\\arg"}
  2516. proc cos {} {checkMathMode "cos" 1; insertObject "\\cos"}
  2517. proc cosh {} {checkMathMode "cosh" 1; insertObject "\\cosh"}
  2518. proc cot {} {checkMathMode "cot" 1; insertObject "\\cot"}
  2519. proc coth {} {checkMathMode "coth" 1; insertObject "\\coth"}
  2520. proc csc {} {checkMathMode "csc" 1; insertObject "\\csc"}
  2521. proc deg {} {checkMathMode "deg" 1; insertObject "\\deg"}
  2522. proc det {} {checkMathMode "det" 1; insertObject "\\det"}
  2523. proc dim {} {checkMathMode "dim" 1; insertObject "\\dim"}
  2524. proc exp {} {checkMathMode "exp" 1; insertObject "\\exp"}
  2525. proc gcd {} {checkMathMode "gcd" 1; insertObject "\\gcd"}
  2526. proc hom {} {checkMathMode "hom" 1; insertObject "\\hom"}
  2527. proc inf {} {checkMathMode "inf" 1; insertObject "\\inf"}
  2528. proc ker {} {checkMathMode "ker" 1; insertObject "\\ker"}
  2529. proc lg {} {checkMathMode "lg" 1; insertObject "\\lg"}
  2530. proc lim {} {checkMathMode "lim" 1; insertObject "\\lim"}
  2531. proc liminf {} {checkMathMode "liminf" 1; insertObject "\\liminf"}
  2532. proc limsup {} {checkMathMode "limsup" 1; insertObject "\\limsup"}
  2533. proc ln {} {checkMathMode "ln" 1; insertObject "\\ln"}
  2534. proc log {} {checkMathMode "log" 1; insertObject "\\log"}
  2535. proc max {} {checkMathMode "max" 1; insertObject "\\max"}
  2536. proc min {} {checkMathMode "min" 1; insertObject "\\min"}
  2537. proc Pr {} {checkMathMode "Pr" 1; insertObject "\\Pr"}
  2538. proc sec {} {checkMathMode "sec" 1; insertObject "\\sec"}
  2539. proc sin {} {checkMathMode "sin" 1; insertObject "\\sin"}
  2540. proc sinh {} {checkMathMode "sinh" 1; insertObject "\\sinh"}
  2541. proc sup {} {checkMathMode "sup" 1; insertObject "\\sup"}
  2542. proc tan {} {checkMathMode "tan" 1; insertObject "\\tan"}
  2543. proc tanh {} {checkMathMode "tanh" 1; insertObject "\\tanh"}
  2544.  
  2545. proc bmod {} {checkMathMode "bmod" 1; insertObject "\\bmod"}
  2546. proc pmod {} {
  2547.     checkMathMode "pmod" 1
  2548.     if {[wrapObject "\\pmod{" "}Ñ"]} then {
  2549.         message "parenthesized mod set"
  2550.     } else {
  2551.         message "enter formula"
  2552.     }
  2553. }
  2554.  
  2555. #--------------------------------------------------------------------------
  2556. # Large Ops:
  2557. #--------------------------------------------------------------------------
  2558.  
  2559. proc insertLargeOp {commandName} {
  2560.     checkMathMode "$commandName" 1
  2561.     set currentPos [getPos]
  2562.     insertObject "\\$commandName\_{Ñ}^{Ñ}Ñ"
  2563.     goto $currentPos
  2564.     nextTabStop
  2565. }
  2566. proc sum {} {insertLargeOp "sum"}
  2567. proc prod {} {insertLargeOp "prod"}
  2568. proc coprod {} {insertLargeOp "coprod"}
  2569. proc int {} {insertLargeOp "int"}
  2570. proc oint {} {insertLargeOp "oint"}
  2571. proc bigcap {} {insertLargeOp "bigcap"}
  2572. proc bigcup {} {insertLargeOp "bigcup"}
  2573. proc bigsqcup {} {insertLargeOp "bigsqcup"}
  2574. proc bigvee {} {insertLargeOp "bigvee"}
  2575. proc bigwedge {} {insertLargeOp "bigwedge"}
  2576. proc bigodot {} {insertLargeOp "bigodot"}
  2577. proc bigotimes {} {insertLargeOp "bigotimes"}
  2578. proc bigoplus {} {insertLargeOp "bigoplus"}
  2579. proc biguplus {} {insertLargeOp "biguplus"}
  2580.  
  2581. #--------------------------------------------------------------------------
  2582. # Delimiters:
  2583. #--------------------------------------------------------------------------
  2584.  
  2585. proc delimitObject {leftDelim rightDelim} {
  2586.     if {[wrapObject $leftDelim $rightDelim]} then {
  2587.         message "formula delimited"
  2588.     } else {
  2589.         message "enter formula"
  2590.     }
  2591. }
  2592. proc parentheses {} { checkMathMode "parentheses" 1; delimitObject "(" ")Ñ" }
  2593. proc brackets {} { checkMathMode "brackets" 1; delimitObject "\[" "\]Ñ" }
  2594. proc braces {} { checkMathMode "braces" 1; delimitObject "\\\{" "\\\}Ñ" }
  2595. proc absoluteValue {} { checkMathMode "absoluteValue" 1; delimitObject "|" "|Ñ" }
  2596. proc getDelims {} {
  2597.     catch {prompt "Choose delimiters:" "parentheses" "" "parentheses" \
  2598.                   "brackets" "braces" "angle brackets" "vertical bars" \
  2599.                   "double bars" "ceiling" "floor"} delimType
  2600.     if {$delimType != "cancel"} then {
  2601.         case $delimType in {
  2602.             "parentheses" {
  2603.                 set leftDelim "("
  2604.                 set rightDelim ")"
  2605.             }
  2606.             "brackets" {
  2607.                 set leftDelim "\["
  2608.                 set rightDelim "\]"
  2609.             }
  2610.             "braces" {
  2611.                 set leftDelim "\\\{"
  2612.                 set rightDelim "\\\}"
  2613.             }
  2614.             "{vertical bars}" {
  2615.                 set leftDelim "|"
  2616.                 set rightDelim "|"
  2617.             }
  2618.             "{double bars}" {
  2619.                 set leftDelim "\\|"
  2620.                 set rightDelim "\\|"
  2621.             }
  2622.             "{angle brackets}" {
  2623.                 set leftDelim "\\langle"
  2624.                 set rightDelim "\\rangle"
  2625.             }
  2626.             "ceiling" {
  2627.                 set leftDelim "\\lceil"
  2628.                 set rightDelim "\\rceil"
  2629.             }
  2630.             "floor" {
  2631.                 set leftDelim "\\lfloor"
  2632.                 set rightDelim "\\rfloor"
  2633.             }
  2634.             default {
  2635.                 alertnote "\"$delimType\" not recognized"
  2636.                 return ""
  2637.             }
  2638.         }
  2639.         return [list $leftDelim $rightDelim]
  2640.     } else {return ""}
  2641. }
  2642. proc otherDelims {} {
  2643.     checkMathMode "otherDelims" 1
  2644.     set delims [getDelims]
  2645.     if {$delims != ""} then {
  2646.         set leftDelim [lindex $delims 0]
  2647.         set rightDelim [lindex $delims 1]
  2648.         delimitObject "$leftDelim" "$rightDelimÑ"
  2649.     }
  2650. }
  2651. proc {half-openInterval} {} {
  2652.     checkMathMode "half-openInterval" 1; delimitObject "(" "\]Ñ"
  2653. }
  2654. proc {half-closedInterval} {} {
  2655.     checkMathMode "half-closedInterval" 1; delimitObject "\[" ")Ñ"
  2656. }
  2657.  
  2658. proc insertBigDelims {leftDelim rightDelim isMultiline} {
  2659.     checkMathMode "insertBigDelims" 1
  2660.     if {$isMultiline} then {
  2661.         alertnote "Multi-line delimiters not yet implemented."
  2662.     } else {
  2663.         if {[wrapObject $leftDelim $rightDelim]} then {
  2664.             message "formula delimited"
  2665.         } else {
  2666.             message "enter formula"
  2667.         }
  2668.     }
  2669. }
  2670. proc bigParentheses {} {
  2671.     checkMathMode "bigParentheses" 1; insertBigDelims "\\left(" "\\right)Ñ" 0
  2672. }
  2673. proc bigBrackets {} {
  2674.     checkMathMode "bigBrackets" 1; insertBigDelims "\\left\[" "\\right\]Ñ" 0
  2675. }
  2676. proc bigBraces {} {
  2677.     checkMathMode "bigBraces" 1; insertBigDelims "\\left\\\{" "\\right\\\}Ñ" 0
  2678. }
  2679. proc bigAbsoluteValue {} {
  2680.     checkMathMode "bigAbsoluteValue" 1; insertBigDelims "\\left|" "\\right|Ñ" 0
  2681. }
  2682. proc otherBigDelims {} {
  2683.     checkMathMode "otherBigDelims" 1
  2684.     set delims [getDelims]
  2685.     if {$delims != ""} then {
  2686.         append leftDelim "\\left" [lindex $delims 0]
  2687.         append rightDelim "\\right" [lindex $delims 1]
  2688.         insertBigDelims "$leftDelim" "$rightDelimÑ" 0
  2689.     }
  2690. }
  2691. proc bigLeftBrace {} { checkMathMode "bigLeftBrace" 1; insertBigDelims "\\left\\\{" "\\right.Ñ" 0 }
  2692. proc otherMixedBigDelims {} {
  2693.     checkMathMode "otherMixedBigDelims" 1
  2694.     catch {prompt "Choose LEFT delimiter:" "parenthesis" "" "parenthesis" \
  2695.                   "bracket" "brace" "vertical bar" "double bar" \
  2696.                   "angle bracket" "ceiling" "floor" "slash" "backslash" \
  2697.                   "none"} delimType
  2698.     if {$delimType != "cancel"} then {
  2699.         case $delimType in {
  2700.             "parenthesis" {set leftDelim "("}
  2701.             "bracket" {set leftDelim "\["}
  2702.             "brace" {set leftDelim "\\\{"}
  2703.             "{vertical bar}" {set leftDelim "|"}
  2704.             "{double bar}" {set leftDelim "\\|"}
  2705.             "{angle bracket}" {set leftDelim "\\langle"}
  2706.             "ceiling" {set leftDelim "\\lceil"}
  2707.             "floor" {set leftDelim "\\lfloor"}
  2708.             "slash" {set leftDelim "/"}
  2709.             "backslash" {set leftDelim "\\backslash"}
  2710.             "none" {set leftDelim "."}
  2711.             default {
  2712.                 alertnote "\"$delimType\" not recognized"
  2713.                 return
  2714.             }
  2715.         }
  2716.         catch {prompt "Choose RIGHT delimiter:" "parenthesis" "" "parenthesis" \
  2717.                       "bracket" "brace" "vertical bar" "double bar" \
  2718.                       "angle bracket" "ceiling" "floor" "slash" "backslash" \
  2719.                       "none"} delimType
  2720.         if {$delimType != "cancel"} then {
  2721.             case $delimType in {
  2722.                 "parenthesis" {set rightDelim ")"}
  2723.                 "bracket" {set rightDelim "\]"}
  2724.                 "brace" {set rightDelim "\\\}"}
  2725.                 "{vertical bar}" {set rightDelim "|"}
  2726.                 "{double bar}" {set rightDelim "\\|"}
  2727.                 "{angle bracket}" {set rightDelim "\\rangle"}
  2728.                 "ceiling" {set rightDelim "\\rceil"}
  2729.                 "floor" {set rightDelim "\\rfloor"}
  2730.                 "slash" {set rightDelim "/"}
  2731.                 "backslash" {set rightDelim "\\backslash"}
  2732.                 "none" {set rightDelim "."}
  2733.                 default {
  2734.                     alertnote "\"$delimType\" not recognized"
  2735.                     return
  2736.                 }
  2737.             }
  2738.             insertBigDelims "\\left$leftDelim" "\\right$rightDelimÑ" 0
  2739.         }
  2740.     }
  2741. }
  2742.  
  2743. #--------------------------------------------------------------------------
  2744. # Accents:
  2745. #--------------------------------------------------------------------------
  2746.  
  2747. proc acute {} {
  2748.     checkMathMode "acute" 1
  2749.     if {[isSelection] > 1} then {
  2750.         alertnote "Warning: only a single character may be accented!"
  2751.     }
  2752.     if {[wrapObject "\\acute{" "}Ñ"]} then {
  2753.         message "accent set"
  2754.     } else {
  2755.         message "enter one character"
  2756.     }
  2757. }
  2758. proc bar {} {
  2759.     checkMathMode "bar" 1
  2760.     if {[isSelection] > 1} then {
  2761.         alertnote "Warning: only a single character may be accented!"
  2762.     }
  2763.     if {[wrapObject "\\bar{" "}Ñ"]} then {
  2764.         message "accent set"
  2765.     } else {
  2766.         message "enter one character"
  2767.     }
  2768. }
  2769. proc breve {} {
  2770.     checkMathMode "breve" 1
  2771.     if {[isSelection] > 1} then {
  2772.         alertnote "Warning: only a single character may be accented!"
  2773.     }
  2774.     if {[wrapObject "\\breve{" "}Ñ"]} then {
  2775.         message "accent set"
  2776.     } else {
  2777.         message "enter one character"
  2778.     }
  2779. }
  2780. proc check {} {
  2781.     checkMathMode "check" 1
  2782.     if {[isSelection] > 1} then {
  2783.         alertnote "Warning: only a single character may be accented!"
  2784.     }
  2785.     if {[wrapObject "\\check{" "}Ñ"]} then {
  2786.         message "accent set"
  2787.     } else {
  2788.         message "enter one character"
  2789.     }
  2790. }
  2791. proc dot {} {
  2792.     checkMathMode "dot" 1
  2793.     if {[isSelection] > 1} then {
  2794.         alertnote "Warning: only a single character may be accented!"
  2795.     }
  2796.     if {[wrapObject "\\dot{" "}Ñ"]} then {
  2797.         message "accent set"
  2798.     } else {
  2799.         message "enter one character"
  2800.     }
  2801. }
  2802. proc ddot {} {
  2803.     checkMathMode "ddot" 1
  2804.     if {[isSelection] > 1} then {
  2805.         alertnote "Warning: only a single character may be accented!"
  2806.     }
  2807.     if {[wrapObject "\\ddot{" "}Ñ"]} then {
  2808.         message "accent set"
  2809.     } else {
  2810.         message "enter one character"
  2811.     }
  2812. }
  2813. proc grave {} {
  2814.     checkMathMode "grave" 1
  2815.     if {[isSelection] > 1} then {
  2816.         alertnote "Warning: only a single character may be accented!"
  2817.     }
  2818.     if {[wrapObject "\\grave{" "}Ñ"]} then {
  2819.         message "accent set"
  2820.     } else {
  2821.         message "enter one character"
  2822.     }
  2823. }
  2824. proc hat {} {
  2825.     checkMathMode "hat" 1
  2826.     if {[isSelection] > 1} then {
  2827.         alertnote "Warning: only a single character may be accented!"
  2828.     }
  2829.     if {[wrapObject "\\hat{" "}Ñ"]} then {
  2830.         message "accent set"
  2831.     } else {
  2832.         message "enter one character"
  2833.     }
  2834. }
  2835. proc tilde {} {
  2836.     checkMathMode "tilde" 1
  2837.     if {[isSelection] > 1} then {
  2838.         alertnote "Warning: only a single character may be accented!"
  2839.     }
  2840.     if {[wrapObject "\\tilde{" "}Ñ"]} then {
  2841.         message "accent set"
  2842.     } else {
  2843.         message "enter one character"
  2844.     }
  2845. }
  2846. proc vec {} {
  2847.     checkMathMode "vec" 1
  2848.     if {[isSelection] > 1} then {
  2849.         alertnote "Warning: only a single character may be accented!"
  2850.     }
  2851.     if {[wrapObject "\\vec{" "}Ñ"]} then {
  2852.         message "accent set"
  2853.     } else {
  2854.         message "enter one character"
  2855.     }
  2856. }
  2857.  
  2858. proc widehat {} {
  2859.     checkMathMode "widehat" 1
  2860.     if {[isSelection] > 3} then {
  2861.         alertnote "Warning: only a few characters may be accented!"
  2862.     }
  2863.     if {[wrapObject "\\widehat{" "}Ñ"]} then {
  2864.         message "accent set"
  2865.     } else {
  2866.         message "enter a few characters"
  2867.     }
  2868. }
  2869. proc widetilde {} {
  2870.     checkMathMode "widetilde" 1
  2871.     if {[isSelection] > 3} then {
  2872.         alertnote "Warning: only a few characters may be accented!"
  2873.     }
  2874.     if {[wrapObject "\\widetilde{" "}Ñ"]} then {
  2875.         message "accent set"
  2876.     } else {
  2877.         message "enter a few characters"
  2878.     }
  2879. }
  2880.  
  2881. proc imath {} {checkMathMode "imath" 1; insertObject "\\imath"}
  2882. proc jmath {} {checkMathMode "jmath" 1; insertObject "\\jmath"}
  2883.  
  2884. #--------------------------------------------------------------------------
  2885. # Grouping:
  2886. #--------------------------------------------------------------------------
  2887.  
  2888. proc underline {} {
  2889.     checkMathMode "underline" 1
  2890.     if {[wrapObject "\\underline{" "}Ñ"]} then {
  2891.         message "selection underlined"
  2892.     } else {
  2893.         message "enter text"
  2894.     }
  2895. }
  2896. proc overline {} {
  2897.     checkMathMode "overline" 1
  2898.     if {[wrapObject "\\overline{" "}Ñ"]} then {
  2899.         message "selection overlined"
  2900.     } else {
  2901.         message "enter text"
  2902.     }
  2903. }
  2904. proc underbrace {} {
  2905.     checkMathMode "underbrace" 1
  2906.     if {[wrapObject "\\underbrace{" "}Ñ"]} then {
  2907.         message "selection underbraced"
  2908.     } else {
  2909.         message "enter text"
  2910.     }
  2911. }
  2912. proc overbrace {} {
  2913.     checkMathMode "overbrace" 1
  2914.     if {[wrapObject "\\overbrace{" "}Ñ"]} then {
  2915.         message "selection overbraced"
  2916.     } else {
  2917.         message "enter text"
  2918.     }
  2919. }
  2920. proc stackrel {} {
  2921.     checkMathMode "stackrel" 1
  2922.     set currentPos [getPos]
  2923.     if {[insertObject "\\stackrel{Ñ}{Ñ}Ñ"]} then {
  2924.         goto $currentPos
  2925.         nextTabStop
  2926.         message "1st arg scriptstyle"
  2927.     }
  2928. }
  2929.  
  2930. #--------------------------------------------------------------------------
  2931. # Spacing:
  2932. #--------------------------------------------------------------------------
  2933.  
  2934. proc negThin {} {checkMathMode "negThin" 1; insertObject "\\!"}
  2935. proc thin {} {checkMathMode "thin" 1; insertObject "\\,"}
  2936. proc medium {} {checkMathMode "medium" 1; insertObject "\\:"}
  2937. proc thick {} {checkMathMode "thick" 1; insertObject "\\;"}
  2938. proc quad {} {checkMathMode "quad" 1; insertObject "\\quad"}
  2939. proc qquad {} {checkMathMode "qquad" 1; insertObject "\\qquad"}
  2940. proc hspace {} {
  2941.     checkMathMode "hspace" 1
  2942.     if {[wrapObject "\\hspace{" "}Ñ"]} then {
  2943.         message "spacing set"
  2944.     } else {
  2945.         message "enter the desired horizontal spacing"
  2946.     }
  2947. }
  2948. proc vspace {} {
  2949.     checkMathMode "vspace" 1
  2950.     if {[wrapObject "\\vspace{" "}Ñ"]} then {
  2951.         message "spacing set"
  2952.     } else {
  2953.         message "enter the desired horizontal spacing"
  2954.     }
  2955. }
  2956. proc hfill {} {checkMathMode "hfill" 1; insertObject "\\hfill"}
  2957. proc vfill {} {checkMathMode "vfill" 1; insertObject "\\vfill"}
  2958. proc smallskip {} {checkMathMode "smallskip" 1; insertObject "\\smallskip"}
  2959. proc medskip {} {checkMathMode "medskip" 1; insertObject "\\medskip"}
  2960. proc bigskip {} {checkMathMode "bigskip" 1; insertObject "\\bigskip"}
  2961.  
  2962.