home *** CD-ROM | disk | FTP | other *** search
/ PC World 1997 November / PCWorld_1997-11_cd.bin / software / programy / komix / DATA.Z / scopechang.tcl < prev    next >
Text File  |  1996-12-02  |  7KB  |  219 lines
  1. #---------------------------------------------------------------------------
  2. #
  3. #      (c)     Cadre Technologies Inc.    1996
  4. #
  5. #      File:           @(#)scopechang.tcl    /main/hindenburg/1
  6. #      Author:         <generated>
  7. #      Description:
  8. #---------------------------------------------------------------------------
  9. # SccsId = @(#)scopechang.tcl    /main/hindenburg/1   2 Dec 1996 Copyright 1996 Cadre Technologies Inc.
  10.  
  11. # Start user added include file section
  12.  
  13. require procs.tcl
  14.  
  15. # End user added include file section
  16.  
  17.  
  18. Class ScopeChangeDialog : {TemplateDialog} {
  19.     constructor
  20.     method destructor
  21.     method scopeFile_scopeSystem
  22.     method scopeFile_scopePhase
  23.     method scopeSystem_scopeFile
  24.     method scopeSystem_scopePhase
  25.     method scopePhase_scopeFile
  26.     method scopePhase_scopeSystem
  27.     method popUp
  28.     method handleOk
  29.     method addAction
  30.     method removeAction
  31.     method addOption
  32.     method removeOption
  33.     attribute configV
  34.     attribute systemV
  35.     attribute diagram
  36.     attribute workItem
  37.     attribute item
  38.     attribute allowedScopes
  39.     attribute editor
  40.     attribute actionSet
  41.     attribute optionSet
  42. }
  43.  
  44. constructor ScopeChangeDialog {class this name} {
  45.     set this [TemplateDialog::constructor $class $this $name]
  46.     $this actionSet [List new]
  47.     $this optionSet [List new]
  48.     # Start constructor user section
  49.  
  50.     interface DlgColumn $this.c {
  51.         Label message {
  52.             text "Select Scope"
  53.         }
  54.         VerRadioGroup group {}
  55.     }
  56.     $this config -okPressed "$this handleOk; $this delete" \
  57.              -helpPressed {.main helpOnName editScope} \
  58.              -cancelPressed "$this delete" \
  59.              -title "Edit Scope" \
  60.              -modal 1
  61.  
  62.     # End constructor user section
  63.     return $this
  64. }
  65.  
  66. method ScopeChangeDialog::destructor {this} {
  67.     # Start destructor user section
  68.     # End destructor user section
  69. }
  70.  
  71. method ScopeChangeDialog::scopeFile_scopeSystem {this} {
  72.     if {[[$this workItem] status] == "reused"} {
  73.         return
  74.     }
  75.     set existing \
  76.         [[$this systemV] findDeclaration [$this item] [$this configV]]
  77.     if [$existing isNil] {
  78.         $this addOption "Refer to (not yet existing) definition on System level"
  79.         $this addOption "Export definition to System level"
  80.     } elseif {[$existing scope] != "scopeSystem"} {
  81.         # Item exists with some scope phase variant. It is strange to
  82.         # lower the scope of that item via a scope change on a scope
  83.         # file item. A consistent set of allowed scopes will also
  84.         # provide the possibility to go to scope phase in this
  85.         # situation, so there is no need to do anything special here.
  86.         return
  87.     } else {
  88.         $this addOption "Refer to definition on System level"
  89.         $this addOption "Overwrite definition on System level"
  90.     }
  91.     $this addAction "[$this diagram] refer [$this item] 1"
  92.     $this addAction "[$this diagram] export [$this item] 1"
  93. }
  94.  
  95. method ScopeChangeDialog::scopeFile_scopePhase {this} {
  96.     if {[[$this workItem] status] == "reused"} {
  97.         return
  98.     }
  99.     set existing \
  100.         [[$this systemV] findDeclaration [$this item] [$this configV]]
  101.     if [$existing isNil] {
  102.         $this addOption "Refer to (not yet existing) definition on Phase level"
  103.         $this addOption "Export definition to Phase level"
  104.     } elseif {[$existing scope] == "scopeSystem"} {
  105.         # In order to implement this we need two scope changes:
  106.         # one of the item we are changing and one of the existing item.
  107.         # To prevent surprises we let the user take care of this.
  108.         return
  109.     } else {
  110.         $this addOption "Refer to definition on Phase level"
  111.         $this addOption "Overwrite definition on Phase level"
  112.     }
  113.     $this addAction "[$this diagram] refer [$this item] 0"
  114.     $this addAction "[$this diagram] export [$this item] 0"
  115. }
  116.  
  117. method ScopeChangeDialog::scopeSystem_scopeFile {this} {
  118.     if {[[$this diagram] status] != "working"} {
  119.         return
  120.     }
  121.     $this addOption "Create empty definition on File level"
  122.     $this addAction "[$this diagram] declareItem [$this item] scopeFile"
  123.     $this addOption "Copy definition to File level"
  124.     $this addAction "[$this diagram] import [$this item]"
  125. }
  126.  
  127. method ScopeChangeDialog::scopeSystem_scopePhase {this} {
  128.     if {[[$this workItem] status] == "reused"} {
  129.         return
  130.     }
  131.     $this addOption "Refer to definition on Phase level"
  132.     $this addAction "[$this systemV] refer [$this item] 0"
  133.     $this addOption "Make definition available on Phase level"
  134.     $this addAction "[$this systemV] export [$this item] 0"
  135. }
  136.  
  137. method ScopeChangeDialog::scopePhase_scopeFile {this} {
  138.     $this scopeSystem_scopeFile
  139. }
  140.  
  141. method ScopeChangeDialog::scopePhase_scopeSystem {this} {
  142.     if {[[$this workItem] status] == "reused"} {
  143.         return
  144.     }
  145.     if {[[$this workItem] scope] != "scopePhaseDef"} {
  146.         $this addOption "Create empty definition on System level"
  147.         $this addAction \
  148.             "[$this systemV] declareItem [$this item] scopeSystem"
  149.         $this addOption "Copy definition to System level"
  150.     } else {
  151.         $this addOption "Restrict definition to System level"
  152.     }
  153.     $this addAction "[$this systemV] import [$this item]"
  154. }
  155.  
  156. method ScopeChangeDialog::popUp {this} {
  157.     set itemRef [lindex [[$this editor] selectedItem] 0]
  158.     set workItem [$itemRef workItem [$this configV]]
  159.     if [$workItem isNil] {
  160.         wmtkerror "There is no work item for item '[$itemRef itemName]'\nScope Change is not possible."
  161.         $this delete
  162.         return
  163.     }
  164.     $this workItem $workItem
  165.     $this item [$workItem item]
  166.     set scope [$workItem scope]
  167.     if {$scope == "scopePhaseRef" || $scope == "scopePhaseDef"} {
  168.         set scope scopePhase
  169.     }
  170.     $this allowedScopes [$itemRef allowedScopes]
  171.     if {[$this allowedScopes] == ""} {
  172.         $this allowedScopes $scope
  173.     }
  174.     set selected ""
  175.     foreach newScope [$this allowedScopes] {
  176.         if {$newScope == $scope} {
  177.             set selected \
  178.                 "Current scope is [string range $scope 5 end]"
  179.             $this addOption $selected
  180.             $this addAction ""
  181.         } else {
  182.             $this ${scope}_${newScope}
  183.         }
  184.     }
  185.     $this.c.group entrySet [[$this optionSet] contents]
  186.     $this.c.group selected $selected
  187.     $this TemplateDialog::popUp
  188. }
  189.  
  190. method ScopeChangeDialog::handleOk {this} {
  191.     set option [$this.c.group selected]
  192.     set index [lsearch -exact [[$this optionSet] contents] $option]
  193.     set action [[$this actionSet] index $index]
  194.     if [catch {eval $action} msg] {
  195.         wmtkerror $msg
  196.     }
  197. }
  198.  
  199. # Do not delete this line -- regeneration end marker
  200.  
  201. method ScopeChangeDialog::addAction {this newAction} {
  202.     [$this actionSet] append $newAction
  203.  
  204. }
  205.  
  206. method ScopeChangeDialog::removeAction {this oldAction} {
  207.     [$this actionSet] removeValue $oldAction
  208. }
  209.  
  210. method ScopeChangeDialog::addOption {this newOption} {
  211.     [$this optionSet] append $newOption
  212.  
  213. }
  214.  
  215. method ScopeChangeDialog::removeOption {this oldOption} {
  216.     [$this optionSet] removeValue $oldOption
  217. }
  218.  
  219.