home *** CD-ROM | disk | FTP | other *** search
/ PC World 1998 October / PCWorld_1998-10_cd.bin / software / prehled / komix / DATA.Z / scopechang.tcl < prev    next >
Encoding:
Text File  |  1997-09-15  |  7.3 KB  |  250 lines
  1. #---------------------------------------------------------------------------
  2. #
  3. #      (c)     Cadre Technologies Inc.    1996
  4. #
  5. #      File:           @(#)scopechang.tcl    /main/titanic/3
  6. #      Author:         <generated>
  7. #      Description:
  8. #---------------------------------------------------------------------------
  9. # SccsId = @(#)scopechang.tcl    /main/titanic/3   15 Sep 1997 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.  
  132.     # check whether there is an item on phase level that can be 
  133.     # referred
  134.     set configV [$this configV]
  135.     set systemV [$this systemV]
  136.     set phaseV [$configV findPhaseVersion -byPhase [$systemV phase]]
  137.     set item [$this item]
  138.  
  139.     set existing [$phaseV findDefinition $item $configV]
  140.     set warningText ""
  141.     if [$existing isNil] {
  142.         set warningText " (not yet existing)"
  143.     }
  144.  
  145.     # do not add the refer option for a cl item with a cdm
  146.     set addRefer 1
  147.     if { [$item type] == "cl" } {
  148.         $systemV getDecompositions $item $configV decompFiles \
  149.                     "cdm" systemVersions fileVersions
  150.         if { $fileVersions != "" } {
  151.         set addRefer 0
  152.         }
  153.     }
  154.  
  155.     if $addRefer {
  156.         $this addOption "Refer to$warningText definition on Phase level"
  157.         $this addAction "[$this systemV] refer [$this item] 0"
  158.     }
  159.  
  160.     $this addOption "Make definition available on Phase level"
  161.     $this addAction "[$this systemV] export [$this item] 0"
  162. }
  163.  
  164. method ScopeChangeDialog::scopePhase_scopeFile {this} {
  165.     $this scopeSystem_scopeFile
  166. }
  167.  
  168. method ScopeChangeDialog::scopePhase_scopeSystem {this} {
  169.     if {[[$this workItem] status] == "reused"} {
  170.         return
  171.     }
  172.     if {[[$this workItem] scope] != "scopePhaseDef"} {
  173.         $this addOption "Create empty definition on System level"
  174.         $this addAction \
  175.             "[$this systemV] declareItem [$this item] scopeSystem"
  176.         $this addOption "Copy definition to System level"
  177.     } else {
  178.         $this addOption "Restrict definition to System level"
  179.     }
  180.     $this addAction "[$this systemV] import [$this item]"
  181. }
  182.  
  183. method ScopeChangeDialog::popUp {this} {
  184.     set itemRef [lindex [[$this editor] selectedItem] 0]
  185.     if [catch {set workItem [$itemRef workItem [$this configV]]} msg] {
  186.         wmtkerror $msg
  187.         $this delete
  188.         return
  189.     }
  190.     if [$workItem isNil] {
  191.         wmtkerror "There is no work item for item '[$itemRef itemName]'\nScope Change is not possible."
  192.         $this delete
  193.         return
  194.     }
  195.     $this workItem $workItem
  196.     $this item [$workItem item]
  197.     set scope [$workItem scope]
  198.     if {$scope == "scopePhaseRef" || $scope == "scopePhaseDef"} {
  199.         set scope scopePhase
  200.     }
  201.     $this allowedScopes [$itemRef allowedScopes]
  202.     if {[$this allowedScopes] == ""} {
  203.         $this allowedScopes $scope
  204.     }
  205.     set selected ""
  206.     foreach newScope [$this allowedScopes] {
  207.         if {$newScope == $scope} {
  208.             set selected \
  209.                 "Current scope is [string range $scope 5 end]"
  210.             $this addOption $selected
  211.             $this addAction ""
  212.         } else {
  213.             $this ${scope}_${newScope}
  214.         }
  215.     }
  216.     $this.c.group entrySet [[$this optionSet] contents]
  217.     $this.c.group selected $selected
  218.     $this TemplateDialog::popUp
  219. }
  220.  
  221. method ScopeChangeDialog::handleOk {this} {
  222.     set option [$this.c.group selected]
  223.     set index [lsearch -exact [[$this optionSet] contents] $option]
  224.     set action [[$this actionSet] index $index]
  225.     if [catch {eval $action} msg] {
  226.         wmtkerror $msg
  227.     }
  228. }
  229.  
  230. # Do not delete this line -- regeneration end marker
  231.  
  232. method ScopeChangeDialog::addAction {this newAction} {
  233.     [$this actionSet] append $newAction
  234.  
  235. }
  236.  
  237. method ScopeChangeDialog::removeAction {this oldAction} {
  238.     [$this actionSet] removeValue $oldAction
  239. }
  240.  
  241. method ScopeChangeDialog::addOption {this newOption} {
  242.     [$this optionSet] append $newOption
  243.  
  244. }
  245.  
  246. method ScopeChangeDialog::removeOption {this oldOption} {
  247.     [$this optionSet] removeValue $oldOption
  248. }
  249.  
  250.