home *** CD-ROM | disk | FTP | other *** search
/ PC World 1997 November / PCWorld_1997-11_cd.bin / software / programy / komix / DATA.Z / wmttool.tcl < prev    next >
Text File  |  1996-11-21  |  14KB  |  520 lines
  1. #---------------------------------------------------------------------------
  2. #
  3. #      (c)     Cayenne Software Inc.    1996
  4. #
  5. #      File:           @(#)wmttool.tcl    /main/hindenburg/9
  6. #      Author:         <generated>
  7. #      Description:
  8. #---------------------------------------------------------------------------
  9. # SccsId = @(#)wmttool.tcl    /main/hindenburg/9   21 Nov 1996 Copyright 1996 Cayenne Software Inc.
  10.  
  11. # Start user added include file section
  12.  
  13. require command.tcl
  14. require classmaker.tcl
  15. require wmt_util.tcl
  16.  
  17. # End user added include file section
  18.  
  19. require "communicat.tcl"
  20.  
  21. # Definition of class WmtTool which is a base class
  22. # for tools that are able to start exetools.
  23.  
  24. Class WmtTool : {Communicator} {
  25.     method destructor
  26.     constructor
  27.     method watchdogBusy
  28.     method ready
  29.     method selectedIdSet
  30.     method selectedNameTypeSet
  31.     method startDispatcher
  32.     method startCommand
  33.     method startCommandWithOptions
  34.     method startM4Command
  35.     method startDocbatch
  36.     method startExetool
  37.     method toolBarPresent
  38.     method contextAreaPresent
  39.     method messageAreaPresent
  40.     method addToolBar
  41.     method addContextArea
  42.     method addMessageArea
  43.     method updateToolBar
  44.     method updateWmtArea
  45.     method setToolBarPresence
  46.     method saveToolBarPresence
  47.     method setContextAreaPresence
  48.     method saveContextAreaPresence
  49.     method setMessageAreaPresence
  50.     method saveMessageAreaPresence
  51.     method setWindowGeometry
  52.     method saveWindowGeometry
  53.     method addActiveCmd
  54.     method removeActiveCmd
  55.     method addMtoolPending
  56.     method removeMtoolPending
  57.     method addXtoolPending
  58.     method removeXtoolPending
  59.     attribute dispatcher
  60.     attribute _watchdogBusy
  61.     attribute exitButton
  62.     attribute exitStatusList
  63.     attribute caller
  64.     attribute notSavedM4Vars
  65.     attribute _selectedIdSet
  66.     attribute _selectedNameTypeSet
  67.     attribute activeCmdSet
  68.     attribute mtoolPendingSet
  69.     attribute xtoolPendingSet
  70. }
  71.  
  72. method WmtTool::destructor {this} {
  73.     # Start destructor user section
  74.  
  75.     set dispatcher [$this dispatcher]
  76.     if {$dispatcher != ""} {
  77.         send -async $dispatcher \
  78.         ClDispatcher::unregisterClient [list [get_comm_name]]
  79.     }
  80.     set notSaved [$this notSavedM4Vars]
  81.     m4_var foreach m4var {
  82.         foreach varSpec $notSaved {
  83.             if [string match $varSpec $m4var] {
  84.                 m4_var saveStatus $m4var 0
  85.             }
  86.         }
  87.     }
  88.     m4_var save
  89.     # End destructor user section
  90.     $this Communicator::destructor
  91. }
  92.  
  93. constructor WmtTool {class this name} {
  94.     set this [Communicator::constructor $class $this $name]
  95.  
  96.     $this config \
  97.     -activeCmdSet [List new] \
  98.     -mtoolPendingSet [List new] \
  99.     -xtoolPendingSet [List new] \
  100.     -_watchdogBusy 0 \
  101.     -notSavedM4Vars {
  102.         M4_corproles__*
  103.         M4_projroles__*
  104.         M4_levelpath*
  105.     }
  106.     global wmttoolObj
  107.     set wmttoolObj $this
  108.  
  109.     $this startDispatcher
  110.  
  111.     return $this
  112. }
  113.  
  114. proc WmtTool::dispatcherStarted {dispatcher} {
  115.     $wmttoolObj dispatcher $dispatcher
  116. }
  117.  
  118. proc WmtTool::externCmdFailed {cmd obj} {
  119.     foreach exitStatus [$wmttoolObj exitStatusList] {
  120.     if $exitStatus {
  121.         wmtkmessage "Executing '$cmd' for '$obj' failed"
  122.         break
  123.     }
  124.     }
  125. }
  126.  
  127. proc WmtTool::mtoolAvailable {mtool cmd {dir ""}} {
  128.     set this $wmttoolObj
  129.     set list [$this mtoolPendingSet]
  130.     $list removeValue $cmd
  131.     $this addActiveCmd $cmd
  132.     $cmd execute $mtool $dir
  133. }
  134.  
  135. proc WmtTool::xtoolAvailable {xtool cmd {dir ""}} {
  136.     set this $wmttoolObj
  137.     set list [$this xtoolPendingSet]
  138.     $list removeValue $cmd
  139.     $this addActiveCmd $cmd
  140.     $cmd execute $xtool $dir
  141. }
  142.  
  143.  
  144. # This callback function is called when an exetool
  145. # has been started.
  146. #
  147. proc WmtTool::exetoolStarted {clientId} {
  148.     wmtkmessage ""
  149. }
  150.  
  151.  
  152. # This callback function is called when an exetool
  153. # is finished with the execution of command(s).
  154. #
  155. proc WmtTool::exetoolFinished {clientId exitStatusList} {
  156.     set this $wmttoolObj
  157.     $this exitStatusList $exitStatusList
  158.     $this removeActiveCmd $clientId
  159.     $clientId delete
  160. }
  161.  
  162. method WmtTool::watchdogBusy {this {flag ""}} {
  163.     if {"$flag" != ""} {
  164.     set watchdogBusy [$this _watchdogBusy]
  165.     if $flag {
  166.         incr watchdogBusy 1
  167.     } else {
  168.         incr watchdogBusy -1
  169.     }
  170.     $this _watchdogBusy $watchdogBusy
  171.     if {"[$this exitButton]" != ""} {
  172.         if {$watchdogBusy > 0} {
  173.         [$this exitButton] sensitive 0
  174.         wmtkmessage ""
  175.         } else {
  176.         [$this exitButton] sensitive 1
  177.         }
  178.     }
  179.     }
  180.     return [$this _watchdogBusy]
  181. }
  182.  
  183. method WmtTool::ready {this} {
  184.     set caller [$this caller]
  185.     if {"$caller" != "" && [isRunning $caller]} {
  186.     send -async $caller {wmtkmessage ""}
  187.     }
  188. }
  189.  
  190. method WmtTool::selectedIdSet {this} {
  191.     set selectedIdSet [$this _selectedIdSet]
  192.     if {"$selectedIdSet" == "undefined"} {
  193.     set selectedIdSet ""
  194.     foreach obj [[$this flatView] selectedSet] {
  195.         lappend selectedIdSet [[$obj browsUiObj] getInfo Identity]
  196.     }
  197.     $this _selectedIdSet $selectedIdSet
  198.     }
  199.     return $selectedIdSet
  200. }
  201.  
  202. method WmtTool::selectedNameTypeSet {this} {
  203.     set selectedNameTypeSet [$this _selectedNameTypeSet]
  204.     if {"$selectedNameTypeSet" == "undefined"} {
  205.     set selectedNameTypeSet ""
  206.     foreach obj [[$this flatView] selectedSet] {
  207.         set browsUiObj [$obj browsUiObj]
  208.         if [$browsUiObj isA ExternalFileVersion] {
  209.         lappend selectedNameTypeSet "[$browsUiObj getInfo Path]"
  210.         } elseif [$browsUiObj isA DocSection] {
  211.         lappend selectedNameTypeSet "[$browsUiObj getInfo Path]"
  212.         } else {
  213.         lappend selectedNameTypeSet \
  214.             "[$browsUiObj getInfo Name].[$browsUiObj getInfo Type]"
  215.         }
  216.     }
  217.     $this _selectedNameTypeSet $selectedNameTypeSet
  218.     }
  219.     return $selectedNameTypeSet
  220. }
  221.  
  222. method WmtTool::startDispatcher {this} {
  223.     # Start dispatcher if not running. We really need to lock the
  224.     # interpreter registry some how, since this is full of raise conditions.
  225.     wmtkmessage "Starting dispatcher..."
  226.     set disp ""
  227.     set dispInterp [lrange [lreplace [get_comm_name] 0 0 dispatcher] 0 2]
  228.     foreach tool [interps] {
  229.     if {$dispInterp == [lrange $tool 0 2] && [isRunning $tool]} {
  230.         set disp $tool
  231.         send -async $tool \
  232.             ClDispatcher::registerClient [list [get_comm_name]]
  233.         break
  234.     }
  235.     }
  236.     if {$disp == ""} {
  237.     SystemUtilities::fork otk dispatcher "[get_comm_name]"
  238.     }
  239.     $this dispatcher $disp
  240.     wmtkmessage "Done"
  241. }
  242.  
  243. method WmtTool::startCommand {this type cmd endCmd msg upd busy {dir ""}} {
  244.     case $type in {
  245.     {mtool xtool} {
  246.         set dispatcher [$this dispatcher]
  247.         if {"$dispatcher" == ""} {
  248.         wmtkerror "Dispatcher can not be started or is not running yet"
  249.         return
  250.         }
  251.         if {! [isRunning $dispatcher]} {
  252.         wmtkerror "Dispatcher is not running: starting new one"
  253.         $this startDispatcher
  254.         return
  255.         }
  256.     }
  257.     }
  258.  
  259.     set command [Command new $this \
  260.     -type $type \
  261.     -script $cmd \
  262.     -finishScript $endCmd \
  263.     -message $msg \
  264.     -updateState $upd \
  265.     -viewUpdate $this \
  266.     -workCursor $busy]
  267.     case $type in {
  268.     mtool {
  269.         wmtkmessage "Starting Monitoring Window..."
  270.         $this addMtoolPending $command
  271.         send -async [$this dispatcher] \
  272.         ClDispatcher::getFreeMtool [list [get_comm_name]] $command $dir
  273.     }
  274.     xtool {
  275.         wmtkmessage "Starting Execution Window..."
  276.         $this addXtoolPending $command
  277.         send -async [$this dispatcher] \
  278.         ClDispatcher::getFreeXtool [list [get_comm_name]] $command $dir
  279.     }
  280.     default {
  281.         $command execute $dir
  282.     }
  283.     }
  284. }
  285.  
  286. method WmtTool::startCommandWithOptions {this type cmd endCmd msg upd busy {dir ""}} {
  287.     # Ask options first before starting command
  288.     set box $this.startCommandWithOptions
  289.     ClassMaker::extend EntryDialog OptionsEntryDialog \
  290.     {type cmdBefore cmdAfter endCmd msg upd busy dir}
  291.     # find the $OPTIONS string to determine the place of the options
  292.     set index [string first \$OPTIONS "$cmd"]
  293.     set cmdBefore "$cmd"
  294.     set cmdAfter ""
  295.     if {$index != -1} {
  296.     set cmdBefore [string range "$cmd" 0 [expr {$index -1}]]
  297.     set index [expr { $index + 9}]
  298.     set cmdAfter [string range "$cmd" $index end]
  299.     }
  300.     OptionsEntryDialog new $box \
  301.     -modal yes \
  302.     -title "Options for '$cmdBefore <options> $cmdAfter'" \
  303.     -type $type \
  304.     -cmdBefore $cmdBefore \
  305.     -cmdAfter $cmdAfter \
  306.     -endCmd $endCmd \
  307.     -msg $msg \
  308.     -upd $upd \
  309.     -busy $busy \
  310.     -dir $dir \
  311.     -cancelPressed {%this delete} \
  312.     -okPressed {
  313.         $wmttoolObj startCommand "[%this type]" \
  314.         "[%this cmdBefore] [%this entry] [%this cmdAfter]" "[%this endCmd]"\
  315.         "[%this msg]" "[%this upd]" "[%this busy]" "[%this dir]"
  316.         %this delete
  317.     }
  318.     $box delHelpButton
  319.     $box popUp
  320. }
  321.  
  322. method WmtTool::startM4Command {this m4Cmd m4CmdArgs endCmd obj {dir ""}} {
  323.     set command [m4_var get M4_[lindex $m4Cmd 0] -context [lindex $m4Cmd 1]]
  324.     set wincommand \
  325.     [m4_var get M4_win_[lindex $m4Cmd 0] -context [lindex $m4Cmd 1]]
  326.     if {"$wincommand" == "" || (! $wincommand)} {
  327.     set kind xtool
  328.     } else {
  329.     set kind extern
  330.     set endCmd \
  331.         "WmtTool::externCmdFailed [list $command] [list $obj] ; $endCmd"
  332.     }
  333.     if {$win95 && "$kind" == "extern"} {
  334.     set script "$command $m4CmdArgs"
  335.     } else {
  336.     set script "$command \"$m4CmdArgs\""
  337.     }
  338.     $this startCommand $kind \
  339.     "$script" "$endCmd" "Starting '$command' for '$obj'" \
  340.     {0 0} 0 $dir
  341. }
  342.  
  343. method WmtTool::startDocbatch {this type args endCmd upd busy {dir ""}} {
  344.     set exe [m4_path_name bin otprint$EXE_EXT]
  345.     set cmd [m4_path_name tcl docbatch.tcl]
  346.     set script "[quoteIf $exe] [quoteIf $cmd] -- $args"
  347.     set msg "Starting docbatch"
  348.     $this startCommand $type $script $endCmd $msg $upd $busy $dir
  349. }
  350.  
  351.  
  352. # Start an exetool (xtool or mtool).
  353. #
  354. method WmtTool::startExetool {this kind {dir ""}} {
  355.     if {! [$this isA MainWindow]} {
  356.     wmtkerror "Cannot start an exetool"
  357.     return
  358.     }
  359.     set box [format "%s.%s%s" "$this" "$kind" "Options"]
  360.     if {! [isCommand $box]} {
  361.     require "browseentr.tcl"
  362.     ClassMaker::extend BrowseEntryDlg ExetoolEntryDialog {kind dir}
  363.     case "$kind" in {
  364.         mtool {
  365.         set title "Monitoring Window Command(s)"
  366.         }
  367.         xtool {
  368.         set title "Execution Window Command(s)"
  369.         }
  370.     }
  371.     ExetoolEntryDialog new $box \
  372.         -modal yes \
  373.         -title $title \
  374.         -kind $kind \
  375.         -message "Command(s):" \
  376.         -okPressed {
  377.         $wmttoolObj startCommand [%this kind] \
  378.             "[%this entry]" "" "Starting '[%this entry]'..." \
  379.             {0 0} 0 [%this dir]
  380.         }
  381.     }
  382.     $box dir $dir
  383.     $box popUp
  384. }
  385.  
  386. method WmtTool::toolBarPresent {this show} {
  387.     if {$show} {
  388.         $this addToolBar
  389.         $this updateToolBar
  390.     } else {
  391.         [$this toolBar] delete
  392.     }
  393. }
  394.  
  395. method WmtTool::contextAreaPresent {this show} {
  396.     if {$show} {
  397.         $this addContextArea
  398.         [$this wmtArea] index 0
  399.         $this updateWmtArea
  400.     } else {
  401.         [$this wmtArea] delete
  402.         $this wmtArea ""
  403.     }
  404. }
  405.  
  406. method WmtTool::messageAreaPresent {this show} {
  407.     if {$show} {
  408.         $this addMessageArea
  409.     } else {
  410.         [$this messageArea] delete
  411.     }
  412. }
  413.  
  414. method WmtTool::addToolBar {this} {
  415.     ToolBar new $this.toolBar -justification FILLED
  416. }
  417.  
  418. method WmtTool::addContextArea {this} {
  419.     # empty
  420. }
  421.  
  422. method WmtTool::addMessageArea {this} {
  423.     MessageArea new $this.messageArea
  424. }
  425.  
  426. method WmtTool::updateToolBar {this} {
  427.     # empty
  428. }
  429.  
  430. method WmtTool::updateWmtArea {this} {
  431.     # empty
  432. }
  433.  
  434. method WmtTool::setToolBarPresence {this context} {
  435.     if [m4_var get M4_toolbar -context $context] {
  436.         $this addToolBar
  437.     } else {
  438.         [$this menuBar].view.menu.toolbar state 0
  439.     }
  440. }
  441.  
  442. method WmtTool::saveToolBarPresence {this context} {
  443.     set barPresent [expr {[$this toolBar] != ""}]
  444.     if {$barPresent != [m4_var get M4_toolbar -context $context]} {
  445.         m4_var set M4_toolbar $barPresent -context $context
  446.     }
  447. }
  448.  
  449. method WmtTool::setContextAreaPresence {this context} {
  450.     if [m4_var get M4_contextarea -context $context] {
  451.         $this addContextArea
  452.     } else {
  453.         [$this menuBar].view.menu.contextarea state 0
  454.     }
  455. }
  456.  
  457. method WmtTool::saveContextAreaPresence {this context} {
  458.     set areaPresent [expr {[$this wmtArea] != ""}]
  459.     if {$areaPresent != [m4_var get M4_contextarea -context $context]} {
  460.         m4_var set M4_contextarea $areaPresent -context $context
  461.     }
  462. }
  463.  
  464. method WmtTool::setMessageAreaPresence {this context} {
  465.     if [m4_var get M4_messagearea -context $context] {
  466.         $this addMessageArea
  467.     } else {
  468.         [$this menuBar].view.menu.messagearea state 0
  469.     }
  470. }
  471.  
  472. method WmtTool::saveMessageAreaPresence {this context} {
  473.     set areaPresent [expr {[$this messageArea] != ""}]
  474.     if {$areaPresent != [m4_var get M4_messagearea -context $context]} {
  475.         m4_var set M4_messagearea $areaPresent -context $context
  476.     }
  477. }
  478.  
  479. method WmtTool::setWindowGeometry {this context} {
  480.     .main geometry [m4_var get M4_geometry -context $context]
  481. }
  482.  
  483. method WmtTool::saveWindowGeometry {this context} {
  484.     set geom [.main geometry]
  485.     if {$geom != [m4_var get M4_geometry -context $context]} {
  486.         m4_var set M4_geometry $geom -context $context
  487.     }
  488.  
  489. }
  490.  
  491. # Do not delete this line -- regeneration end marker
  492.  
  493. method WmtTool::addActiveCmd {this newActiveCmd} {
  494.     [$this activeCmdSet] append $newActiveCmd
  495.  
  496. }
  497.  
  498. method WmtTool::removeActiveCmd {this oldActiveCmd} {
  499.     [$this activeCmdSet] removeValue $oldActiveCmd
  500. }
  501.  
  502. method WmtTool::addMtoolPending {this newMtoolPending} {
  503.     [$this mtoolPendingSet] append $newMtoolPending
  504.  
  505. }
  506.  
  507. method WmtTool::removeMtoolPending {this oldMtoolPending} {
  508.     [$this mtoolPendingSet] removeValue $oldMtoolPending
  509. }
  510.  
  511. method WmtTool::addXtoolPending {this newXtoolPending} {
  512.     [$this xtoolPendingSet] append $newXtoolPending
  513.  
  514. }
  515.  
  516. method WmtTool::removeXtoolPending {this oldXtoolPending} {
  517.     [$this xtoolPendingSet] removeValue $oldXtoolPending
  518. }
  519.  
  520.