home *** CD-ROM | disk | FTP | other *** search
/ PC World 1997 November / PCWorld_1997-11_cd.bin / software / programy / komix / DATA.Z / sysvdbobj.tcl < prev    next >
Encoding:
Text File  |  1996-11-18  |  22.2 KB  |  827 lines
  1. #---------------------------------------------------------------------------
  2. #
  3. #      (c)     Cayenne Software Inc.    1996
  4. #
  5. #      File:           @(#)sysvdbobj.tcl    /main/hindenburg/12
  6. #      Author:         <generated>
  7. #      Description:
  8. #---------------------------------------------------------------------------
  9. # SccsId = @(#)sysvdbobj.tcl    /main/hindenburg/12   18 Nov 1996 Copyright 1996 Cayenne Software Inc.
  10.  
  11. # Start user added include file section
  12. require "clistuiobj.tcl"
  13. require "custfvuiob.tcl"
  14. require "witemuiobj.tcl"
  15. # End user added include file section
  16.  
  17. require "browsdbobj.tcl"
  18. require "versionobj.tcl"
  19.  
  20. Class SysVDbObj : {BrowsDbObj SystemVersion VersionObj} {
  21.     method destructor
  22.     constructor
  23.     method promoter
  24.     method activateObject
  25.     method browserType
  26.     method changeLinks
  27.     method changeObjects
  28.     method copy
  29.     method copyGroupVersion
  30.     method copyVersion
  31.     method deactivateObject
  32.     method deselectObjects
  33.     method groupVersions
  34.     method importObject
  35.     method initializeInfo
  36.     method linkStatus
  37.     method localFileVersions
  38.     method name
  39.     method newObjects
  40.     method removeObjects
  41.     method removeVersion
  42.     method reuse
  43.     method selectObject
  44.     method system
  45.     attribute workItemSet
  46. }
  47.  
  48. method SysVDbObj::destructor {this} {
  49.     # Start destructor user section
  50.  
  51.     [$this customFileVersionSet] delete
  52.     [$this workItemSet] delete
  53.     [$this controlledListSet] delete
  54.  
  55.     # End destructor user section
  56.     $this BrowsDbObj::destructor
  57.     $this VersionObj::destructor
  58. }
  59.  
  60. constructor SysVDbObj {class this name} {
  61.     set this [SystemVersion::constructor $class $this $name]
  62.     set this [BrowsDbObj::constructor $class $this $name]
  63.     set this [VersionObj::constructor $class $this $name]
  64.     return $this
  65. }
  66.  
  67. selfPromoter SystemVersion {this} {
  68.     if {"[[$this system] type]" == "document"} {
  69.     DSysVDbObj promote $this
  70.     } elseif {"[[$this phase] type]" == "Implementation"} {
  71.     PSysVDbObj promote $this
  72.     } else {
  73.     SSysVDbObj promote $this
  74.     }
  75. }
  76.  
  77. method SysVDbObj::promoter {this} {
  78.     $this BrowsDbObj::promoter
  79.  
  80.     set customFileVersionSet $this.${CustFVUiObj::uiClass}:0
  81.     if {! [isCommand $customFileVersionSet]} {
  82.     CustFVUiObj new $customFileVersionSet -parent $this
  83.     }
  84.     $this customFileVersionSet $customFileVersionSet
  85.     set controlledListSet $this.${CListUiObj::uiClass}:0
  86.     if {! [isCommand $controlledListSet]} {
  87.     CListUiObj new $controlledListSet -parent $this
  88.     }
  89.     $this controlledListSet $controlledListSet
  90.     set workItemSet $this.${WItemUiObj::uiClass}:0
  91.     if {! [isCommand $workItemSet]} {
  92.     WItemUiObj new $workItemSet -parent $this
  93.     }
  94.     $this workItemSet $workItemSet
  95. }
  96.  
  97. method SysVDbObj::activateObject {this} {
  98.     set typeSpec [getObjectSpec [$wmttoolObj objectHdlr] \
  99.     CorporateGroupVersion "" \
  100.     ]
  101.     if {"$typeSpec" != ""} {
  102.     set icon [$typeSpec smallIcon]
  103.     } else {
  104.     set icon ""
  105.     }
  106.  
  107.     set headerSpecList {
  108.     {Name 25 ascii {increasing 1}}
  109.     {Version 8 ascii {increasing 2}}
  110.     {Created 30 ascii {none}}
  111.     {Comments 50 ascii {none}}
  112.     }
  113.     foreach corpGV [$this reused] {
  114.     set reusedList($corpGV) 1
  115.     }
  116.     set corpGVList ""
  117.     set objectSpecList ""
  118.     set corpGVSet [[$wmttoolObj corporateObj] corporateGroupVersionSet]
  119.     set srcType [[$this parent] getInfo Type]
  120.     foreach corpGV [$corpGVSet corporateGroupVersions] {
  121.     if [info exists reusedList($corpGV)] continue
  122.     set dstType [[[[$corpGV savedGroupVersion] system] phase] type]
  123.     if {"$srcType" != "$dstType" &&
  124.         ("$srcType" == "Implementation" ||
  125.          "$dstType" == "Implementation")} continue
  126.  
  127.     lappend corpGVList $corpGV
  128.     lappend objectSpecList [list $icon \
  129.         [[$corpGV corporateGroup] name] \
  130.         [$corpGV versionNumber] \
  131.         [$corpGV createTime2String] \
  132.         [$corpGV comments] \
  133.     ]
  134.     }
  135.  
  136.     if [lempty $corpGVList] {
  137.     wmtkinfo \
  138.         "There are no unused CoporateGroups that can be activated\
  139.          within this SystemVersion"
  140.     return
  141.     }
  142.  
  143.     require "browsviewd.tcl"
  144.     set box $wmttoolObj.activate
  145.     ClassMaker::extend BrowsViewDialog ActivateBrowsViewDialog dbObj
  146.     ActivateBrowsViewDialog new $box \
  147.     -title "Activate Corporate Group" \
  148.     -headerSpecList $headerSpecList \
  149.     -objectSpecList $objectSpecList \
  150.     -objectList $corpGVList \
  151.     -dbObj $this \
  152.     -cancelPressed {%this delete} \
  153.     -okPressed {
  154.         set dbObj [%this dbObj]
  155.         set confV [$dbObj getParent ConfigVersion]
  156.         set script ""
  157.         foreach object [[%this view] selectedSet] {
  158.         set corpGV [$object object]
  159.         if {"$script" != ""} {
  160.             append script " ;"
  161.         }
  162.         append script " $dbObj reuse $corpGV $confV"
  163.         }
  164.         $wmttoolObj startCommand tcl \
  165.         "$script" "" \
  166.         "Activating CorporateGroupVersion(s)..." \
  167.         {1 0} 1
  168.         %this delete
  169.     }
  170.     $box popUp
  171. }
  172.  
  173. method SysVDbObj::browserType {this} {
  174.     set systemType [[$this system] type]
  175.     set firstChar [string toupper [string range $systemType 0 0]]
  176.     set type "${firstChar}[string range $systemType 1 end]"
  177.     return "${type}Version"
  178. }
  179.  
  180. method SysVDbObj::changeLinks {this} {
  181.     ClassMaker::extend TemplateDialog ChangeLinksTemplateDialog dbObj
  182.     ChangeLinksTemplateDialog new $wmttoolObj.changeLink \
  183.     -modal yes \
  184.     -title "Change Link Status" \
  185.     -dbObj $this \
  186.     -helpPressed {.main helpOnName changeLink} \
  187.     -cancelPressed {%this delete} \
  188.     -okPressed {
  189.         set status [%this.top.status selected]
  190.         set script ""
  191.         foreach obj [$wmttoolObj selectedObjSet] {
  192.         if [$obj isA PropertySection] {
  193.             wmtkerror "Can not set the link status of a PropertySection"
  194.             continue
  195.         }
  196.         set found 0
  197.         foreach link [$obj systemVersionLinks] {
  198.             if {"[$link systemVersion]" == "[%this dbObj]"} {
  199.             set found 1
  200.             break
  201.             }
  202.         }
  203.         if {! $found} {
  204.             wmtkerror "link to [$obj getInfo Type] \
  205.                 '[$obj getInfo Name]' not found"
  206.             continue
  207.         }
  208.         if {"$script" != ""} {
  209.             append script " ;"
  210.         }
  211.         append script " $link status $status"
  212.         }
  213.         if {"$script" != ""} {
  214.         $wmttoolObj startCommand tcl "$script" "" "" {1 0} 1
  215.         }
  216.         %this delete
  217.     }
  218.     interface DlgColumn $wmttoolObj.changeLink.top {
  219.     Label messageLab {
  220.         text "Link Status:"
  221.     }
  222.     VerRadioGroup status {
  223.         entrySet {fixed dynamicFrozen}
  224.     }
  225.     }
  226.     if {[llength [$wmttoolObj selectedObjSet]] == 1} {
  227.     $wmttoolObj.changeLink.top.status selected \
  228.         [[lindex [$wmttoolObj selectedObjSet] 0] getInfo Link]
  229.     } else {
  230.     $wmttoolObj.changeLink.top.status selected fixed
  231.     }
  232.     $wmttoolObj.changeLink popUp
  233. }
  234.  
  235. method SysVDbObj::changeObjects {this status} {
  236.     case "$status" in {
  237.     {fixed} {
  238.         set operation "makeFixed"
  239.     }
  240.     {selected} {
  241.         set operation "makeSelected"
  242.     }
  243.     {snapshot} {
  244.         set operation "makeSnapshot"
  245.     }
  246.     {current} {
  247.         set operation "makeCurrent"
  248.     }
  249.     {default} {
  250.         return
  251.     }
  252.     }
  253.     set objectList [$wmttoolObj selectedObjSet]
  254.     set script ""
  255.     set sections ""
  256.     foreach obj $objectList {
  257.     if {"$script" != ""} {
  258.         append script " ;"
  259.     }
  260.     append script " $obj $operation"
  261.     if [$obj isA DocSection] {
  262.         lappend sections [$obj identity]
  263.     }
  264.     }
  265.  
  266.     if [lempty $sections] {
  267.     set cmd ""
  268.     } else {
  269.     case "$status" in {
  270.         {selected current} {
  271.         set confVId [[$this getParent ConfigVersion] identity]
  272.         set sysVId [$this identity]
  273.         set argsfile [args_file $sections]
  274.         set args "updateDocDir $confVId $sysVId [list $argsfile]"
  275.         set cmd \
  276.             "$wmttoolObj startDocbatch mtool [list $args] \"\" {0 0} 0"
  277.         }
  278.         {default} {
  279.         set cmd ""
  280.         }
  281.     }
  282.     }
  283.  
  284.     $wmttoolObj startCommand tcl "$script" "$cmd" "" {1 0} 1
  285. }
  286.  
  287. proc SysVDbObj::childTypes {assoc} {
  288.     set childTypes [BrowserProcs::childTypes $assoc]
  289.     case "$childTypes" in {
  290.     {ExternalLink} {
  291.         return "${BrowserProcs::externalFileTypes}"
  292.     }
  293.     {FileVersionReference LocalFileVersion} {
  294.         return [concat \
  295.         ${BrowserProcs::diagramFileTypes} \
  296.         ${BrowserProcs::programmerFileTypes}]
  297.     }
  298.     {Section} {
  299.         return [concat \
  300.         {None Fileprop Itemprop} \
  301.         ${BrowserProcs::diagramFileTypes} \
  302.         ${BrowserProcs::programmerFileTypes}]
  303.     }
  304.     {default} {
  305.         return "$childTypes"
  306.     }
  307.     }
  308. }
  309.  
  310. proc SysVDbObj::controlledLists {} {
  311.     return {
  312.     "[[$this system] customFileList]"
  313.     "[$this customFileVersionLinkList]"
  314.     "[[$this system] fileList]"
  315.     "[$this fileVersionLinkList]"
  316.     "[[$this system] systemVersionList]"
  317.     }
  318. }
  319.  
  320. method SysVDbObj::copy {this args} {
  321.  
  322.     set argc [llength $args]
  323.     set flag [lindex $args 0]
  324.     case "$flag" in {
  325.     {-fileVersion} {
  326.         if {$argc <= 3} {
  327.         eval $this SystemVersion::copy $args
  328.         break
  329.         }
  330.         set fileV [lindex $args 1]
  331.         set editPasteCmdBusy [lindex $args [expr $argc -1]]
  332.  
  333.         set fileName [$fileV name "/"]
  334.         set fileType [[$fileV file] type]
  335.         set oldFileV [$this findFileVersion $fileName $fileType]
  336.         if {! [$oldFileV isNil]} {
  337.         $this deselectVersion $oldFileV
  338.         if $editPasteCmdBusy {
  339.             [.main undoCommand] addDeselected $oldFileV
  340.         }
  341.         }
  342.         set newFileV [eval \
  343.         $this SystemVersion::copy [lrange $args 0 [expr $argc -2]]]
  344.         if {$editPasteCmdBusy && (! [$newFileV isNil])} {
  345.         [.main undoCommand] addObject $newFileV
  346.         }
  347.     }
  348.     {-groupVersion} {
  349.         if {$argc <= 6} {
  350.         eval $this SystemVersion::copy $args
  351.         break
  352.         }
  353.         set groupV [lindex $args 1]
  354.         set mode [lindex $args 5]
  355.         set editPasteCmdBusy [lindex $args [expr $argc -1]]
  356.  
  357.         if {"$mode" == "definition" || "$mode" == "all"} {
  358.         set groupName [$groupV name]
  359.         set oldGroupV [$this findGroupVersion $groupName]
  360.         if {! [$oldGroupV isNil]} {
  361.             $this deselectVersion $oldGroupV
  362.             if $editPasteCmdBusy {
  363.             [.main undoCommand] addDeselected $oldGroupV
  364.             }
  365.         }
  366.         }
  367.         if {"$mode" == "contents" || "$mode" == "all"} {
  368.         set fromSysV [lindex $args 2]
  369.         set fromConfV [lindex $args 3]
  370.         set contents [$groupV selectorEngine $fromSysV $fromConfV]
  371.         set fileVList ""
  372.         foreach fileV $contents {
  373.             if [$fileV isA FileVersion] {
  374.             lappend fileVList $fileV
  375.             set file [$fileV file]
  376.             set fileName [$fileV name "/"]
  377.             set fileType [$file type]
  378.             set oldFileV [$this findFileVersion $fileName $fileType]
  379.             if {! [$oldFileV isNil]} {
  380.                 $this deselectVersion $oldFileV
  381.                 if $editPasteCmdBusy {
  382.                 [.main undoCommand] addDeselected $oldFileV
  383.                 }
  384.             }
  385.             }
  386.         }
  387.         }
  388.         eval $this SystemVersion::copy [lrange $args 0 [expr $argc -2]]
  389.         if $editPasteCmdBusy {
  390.         if {"$mode" == "definition" || "$mode" == "all"} {
  391.             set newGroupV [$this findGroupVersion $groupName]
  392.             if {! [$newGroupV isNil]} {
  393.             [.main undoCommand] addObject $newGroupV
  394.             }
  395.         }
  396.         if {"$mode" == "contents" || "$mode" == "all"} {
  397.             foreach fileV $fileVList {
  398.             set file [$fileV file]
  399.             set fileName [$fileV name "/"]
  400.             set fileType [$file type]
  401.             set newFileV [$this findFileVersion $fileName $fileType]
  402.             if {! [$newFileV isNil]} {
  403.                 [.main undoCommand] addObject $newFileV
  404.             }
  405.             }
  406.         }
  407.         }
  408.     }
  409.     {default} {
  410.         eval $this SystemVersion::copy $args
  411.     }
  412.     }
  413. }
  414.  
  415. method SysVDbObj::copyGroupVersion {this groupV fromSysV fromConfV toConfV} {
  416.     require "copygroupv.tcl"
  417.  
  418.     global classCount
  419.     incr classCount
  420.     set box $wmttoolObj.copyGroupVersion$classCount
  421.     CopyGroupVDlg new $box \
  422.     -dbObj $this \
  423.     -groupV $groupV \
  424.     -fromSysV $fromSysV \
  425.     -fromConfV $fromConfV \
  426.     -toConfV $toConfV
  427.     $box popUp
  428. }
  429.  
  430. method SysVDbObj::copyVersion {this} {
  431.     set myType "[[$this system] type]"
  432.     set versionList ""
  433.     foreach system [[$this phase] systems] {
  434.     if {"[$system type]" != "$myType"} continue
  435.     foreach version [$system systemVersions] {
  436.         if {"$version" == "$this"} continue
  437.         lappend versionList [list $version "[$system name]"]
  438.     }
  439.     }
  440.     BrowserProcs::copyVersion $this $versionList
  441. }
  442.  
  443. method SysVDbObj::deactivateObject {this} {
  444.     set corpGVList [$this reused]
  445.     if [lempty $corpGVList] {
  446.     wmtkinfo \
  447.         "There are no CorporateGroups activated within this SystemVersion"
  448.     return
  449.     }
  450.  
  451.     set typeSpec [getObjectSpec [$wmttoolObj objectHdlr] \
  452.     CorporateGroupVersion "" \
  453.     ]
  454.     if {"$typeSpec" != ""} {
  455.     set icon [$typeSpec smallIcon]
  456.     } else {
  457.     set icon ""
  458.     }
  459.     set headerSpecList {
  460.     {Name 25 ascii {increasing 1}}
  461.     {Version 8 ascii {increasing 2}}
  462.     {Created 30 ascii {none}}
  463.     {Comments 50 ascii {none}}
  464.     }
  465.     set objectSpecList ""
  466.     foreach corpGV $corpGVList {
  467.     lappend objectSpecList [list $icon \
  468.         [[$corpGV corporateGroup] name] \
  469.         [$corpGV versionNumber] \
  470.         [$corpGV createTime2String] \
  471.         [$corpGV comments] \
  472.     ]
  473.     }
  474.  
  475.     require "browsviewd.tcl"
  476.     set box $wmttoolObj.deactivate
  477.     ClassMaker::extend BrowsViewDialog DeactivateBrowsViewDialog dbObj
  478.     DeactivateBrowsViewDialog new $box \
  479.     -title "Deactivate Corporate Group" \
  480.     -headerSpecList $headerSpecList \
  481.     -objectSpecList $objectSpecList \
  482.     -objectList $corpGVList \
  483.     -dbObj $this \
  484.     -cancelPressed {%this delete} \
  485.     -okPressed {
  486.         set dbObj [%this dbObj]
  487.         set script ""
  488.         foreach object [[%this view] selectedSet] {
  489.         set corpGV [$object object]
  490.         if {"$script" != ""} {
  491.             append script " ;"
  492.         }
  493.         append script " $dbObj unuse $corpGV"
  494.         }
  495.         $wmttoolObj startCommand tcl \
  496.         "$script" "" \
  497.         "Deactivating CorporateGroupVersion(s)..." \
  498.         {1 0} 1
  499.         %this delete
  500.     }
  501.     $box popUp
  502. }
  503.  
  504. method SysVDbObj::deselectObjects {this} {
  505.     set script ""
  506.     foreach obj [$wmttoolObj selectedObjSet] {
  507.     if {"$script" != ""} {
  508.         append script " ;"
  509.     }
  510.     append script " $this deselectVersion $obj"
  511.     }
  512.     $wmttoolObj startCommand tcl "$script" "" "" {1 0} 1
  513. }
  514.  
  515. method SysVDbObj::groupVersions {this} {
  516.     set groupVersions ""
  517.     foreach link [$this groupVersionLinks] {
  518.     set groupV [$link groupVersion]
  519.     $groupV setInfo SystemGroupLink $link
  520.     lappend groupVersions $groupV
  521.     }
  522.     return $groupVersions
  523. }
  524.  
  525. method SysVDbObj::importObject {this context node} {
  526.     set len [llength $context]
  527.     set type [lindex $context [expr $len - 2]]
  528.  
  529.     if {$this == [[.main currentObj] browsUiObj]} {
  530.     set update 1
  531.     } else {
  532.     set update 0
  533.     }
  534.  
  535.     # Import CorporateGroupVersion
  536.     if {$len == 3} {
  537.     set corpGVId [lindex $context 0]
  538.     set corpGV [BrowserProcs::id2obj $corpGVId CorporateGroupVersion $node]
  539.  
  540.     # Make sure CorporateGroupVersion exists
  541.     if [catch {$corpGV corporateGroup}] {
  542.         wmtkinfo "Can not import [lindex $context 1] because it is removed"
  543.         if [isCommand [.main undoCommand]] {
  544.         [.main undoCommand] delete
  545.         }
  546.         return
  547.     }
  548.  
  549.     set dstType [[$this phase] type]
  550.     set srcType [[[[$corpGV savedGroupVersion] system] phase] type]
  551.     if {"$srcType" != "$dstType" &&
  552.         ("$srcType" == "Implementation" ||
  553.          "$dstType" == "Implementation")} {
  554.         wmtkmessage "Can not import '$type' from '$srcType' to '$dstType'"
  555.         if [isCommand [.main undoCommand]] {
  556.         [.main undoCommand] delete
  557.         }
  558.     } else {
  559.         set myConfV [$node getParent ConfigVersion]
  560.         set editPasteCmdBusy [.main undoCommandBusy EditPasteCmd]
  561.         set script "$this reuse $corpGV $myConfV $editPasteCmdBusy"
  562.         $wmttoolObj startCommand tcl \
  563.         "$script" "" \
  564.         "Reusing [$corpGV getInfo Text]" \
  565.         [list $update 0] 1
  566.     }
  567.     return
  568.     }
  569.  
  570.     set sysVId [lindex $context 3]
  571.     if {$sysVId == [$this getInfo Identity]} {
  572.     wmtkmessage "Can not import object into its own parent"
  573.     if [isCommand [.main undoCommand]] {
  574.         [.main undoCommand] delete
  575.     }
  576.     return
  577.     }
  578.     set sysV [BrowserProcs::id2obj $sysVId SystemVersion $node]
  579.  
  580.     # Import GroupVersion
  581.     set myConfV [$node getParent ConfigVersion]
  582.     set confVId [lindex $context 1]
  583.     set confV [BrowserProcs::id2obj $confVId ConfigVersion $node]
  584.     if {"$type" == "GroupVersion"} {
  585.     set dstType [[$this phase] type]
  586.     set srcType [[$sysV phase] type]
  587.     if {"$srcType" != "$dstType" &&
  588.         ("$srcType" == "Implementation" ||
  589.          "$dstType" == "Implementation")} {
  590.         wmtkmessage "Can not import '$type' from '$srcType' to '$dstType'"
  591.         if [isCommand [.main undoCommand]] {
  592.         [.main undoCommand] delete
  593.         }
  594.     } else {
  595.         set groupVId [lindex $context 4]
  596.         set groupV [BrowserProcs::id2obj $groupVId GroupVersion $node]
  597.  
  598.         # Make sure GroupVersion exists
  599.         if [catch {$groupV group}] {
  600.         wmtkinfo \
  601.             "Can not import [lindex $context 5] because it is removed"
  602.         if [isCommand [.main undoCommand]] {
  603.             [.main undoCommand] delete
  604.         }
  605.         return
  606.         }
  607.         $this copyGroupVersion $groupV $sysV $confV $myConfV
  608.     }
  609.     return
  610.     }
  611.  
  612.  
  613.     # Import FileVersion
  614.     set fileVId [lindex $context 4]
  615.     set fileV [BrowserProcs::id2obj $fileVId FileVersion $node]
  616.  
  617.     # Make sure FileVersion exists
  618.     if [catch {$fileV file}] {
  619.     wmtkinfo "Can not import [lindex $context 5] because it is removed"
  620.     if [isCommand [.main undoCommand]] {
  621.         [.main undoCommand] delete
  622.     }
  623.     return
  624.     }
  625.  
  626.     # Remove imported object in case of a cut operation
  627.     set editPasteCmdBusy [.main undoCommandBusy EditPasteCmd]
  628.     if {$editPasteCmdBusy &&
  629.     "[[.main undoCommand] operation]" == "cut"} {
  630.     $sysV cutVersion $fileV
  631.     }
  632.  
  633.     set script "$this copy -fileVersion $fileV $myConfV $editPasteCmdBusy"
  634.     $wmttoolObj startCommand tcl \
  635.     "$script" "" \
  636.     "Copying [$fileV getInfo Text]" \
  637.     [list $update 0] 1
  638. }
  639.  
  640. proc SysVDbObj::infoProperties {} {
  641.     return [concat \
  642.     [BrowserProcs::infoProperties] \
  643.     {Status Link Version Comments Created Updated Frozen \
  644.      "Controlled Actions" "Created By"} \
  645.     ]
  646. }
  647.  
  648. method SysVDbObj::initializeInfo {this dummy} {
  649.     set oldLink [[$this info] set PhaseSystemLink]
  650.     [$this info] contents ""
  651.     $this setInfo PhaseSystemLink $oldLink
  652. }
  653.  
  654. method SysVDbObj::linkStatus {this} {
  655.     return [[[$this info] set PhaseSystemLink] status]
  656. }
  657.  
  658. method SysVDbObj::localFileVersions {this} {
  659.     global SysVDbObj::this
  660.     set SysVDbObj::this $this
  661.     set localFileVersions ""
  662.     foreach link [$this fileVersionLinks] {
  663.     set fileV [$link fileVersion]
  664.     $fileV setInfo SystemFileLink $link
  665.     lappend localFileVersions $fileV
  666.     }
  667.     unset SysVDbObj::this
  668.     return $localFileVersions
  669. }
  670.  
  671. method SysVDbObj::name {this} {
  672.     return "[[$this system] name]"
  673. }
  674.  
  675. method SysVDbObj::newObjects {this} {
  676.     set script ""
  677.     foreach obj [$wmttoolObj selectedObjSet] {
  678.     if {"$script" != ""} {
  679.         append script " ;"
  680.     }
  681.     if [$obj isA FileVersion] {
  682.         set flag "-fileVersion"
  683.     } elseif [$obj isA GroupVersion] {
  684.         set flag "-groupVersion"
  685.     } else {
  686.         set flag ""
  687.     }
  688.     append script " \
  689.         set configV \[$obj getParent ConfigVersion\];\
  690.         $this derive $flag $obj \$configV"
  691.     }
  692.     $wmttoolObj startCommand tcl "$script" "" "" {1 0} 1
  693. }
  694.  
  695. method SysVDbObj::removeObjects {this} {
  696.     set box $wmttoolObj.removeWarning
  697.     ClassMaker::extend WarningDialog RemoveObjectsWarningDialog dbObj
  698.     RemoveObjectsWarningDialog new $box \
  699.     -title "Delete Warning" \
  700.     -message [BrowserProcs::removeMessage] \
  701.     -dbObj $this \
  702.     -helpPressed {.main helpOnName removeWarning} \
  703.     -cancelPressed {%this delete} \
  704.     -okPressed {
  705.         set dbObj [%this dbObj]
  706.         set script ""
  707.         foreach obj [$wmttoolObj selectedObjSet] {
  708.         if {"$script" != ""} {
  709.             append script " ;"
  710.         }
  711.         append script " $dbObj removeObject $obj"
  712.         if {[$obj isA FileRefSection] || [$obj isA PropertySection]} {
  713.             append script " ;"
  714.             append script " catch [list \
  715.             [list BasicFS::removeFile [$obj docLocation]]]"
  716.         }
  717.         }
  718.         $wmttoolObj startCommand tcl "$script" "" "" {1 0} 1
  719.         %this delete
  720.     }
  721.     $box popUp
  722. }
  723.  
  724. method SysVDbObj::removeVersion {this} {
  725.     set versionList ""
  726.     foreach version [[$this system] systemVersions] {
  727.     if [$version isLeaf] {
  728.         lappend versionList $version
  729.     }
  730.     }
  731.     BrowserProcs::removeVersion \
  732.     "[$this getParent PhaseVersion]" "[$this system]" $versionList
  733. }
  734.  
  735. method SysVDbObj::reuse {this args} {
  736.     set argc [llength $args]
  737.     if {$argc <= 2} {
  738.     eval $this SystemVersion::reuse $args
  739.     return
  740.     }
  741.  
  742.     set corpGV [lindex $args 0]
  743.     set editPasteCmdBusy [lindex $args [expr $argc -1]]
  744.     eval $this SystemVersion::reuse [lrange $args 0 [expr $argc -2]]
  745.     if $editPasteCmdBusy {
  746.     [.main undoCommand] addObject $corpGV
  747.     }
  748. }
  749.  
  750. method SysVDbObj::selectObject {this mode} {
  751.     set versionList ""
  752.     foreach fileV [$this localFileVersions] {
  753.     set workingList([$fileV file]) $fileV
  754.     }
  755.     foreach groupV [$this groupVersions] {
  756.     set workingList([$groupV group]) $groupV
  757.     }
  758.     case "$mode" in {
  759.     {new} {
  760.         set fileList ""
  761.         foreach file [[$this system] files] {
  762.         if [info exists workingList($file)] continue
  763.         lappend fileList $file
  764.         }
  765.         set groupList ""
  766.         foreach group [[$this system] groups] {
  767.         if [info exists workingList($group)] continue
  768.         lappend groupList $group
  769.         }
  770.     }
  771.     {default} {
  772.         set fileList ""
  773.         set groupList ""
  774.         foreach obj [$wmttoolObj selectedObjSet] {
  775.         if [$obj isA FileVersion] {
  776.             lappend fileList [$obj file]
  777.         } elseif [$obj isA GroupVersion] {
  778.             lappend groupList [$obj group]
  779.         }
  780.         }
  781.     }
  782.     }
  783.     foreach file $fileList {
  784.     set fileName [$file qualifiedName :]
  785.     if [info exists workingList($file)] {
  786.         set working $workingList($file)
  787.     } else {
  788.         set working [ORB::nil]
  789.     }
  790.     foreach version [$file fileVersions] {
  791.         if [$version isSame $working] continue
  792.         set status [$version status]
  793.         if {"$status" == "working" || "$status" == "reused"} continue
  794.         lappend versionList [list $version "$fileName"]
  795.     }
  796.     }
  797.     foreach group $groupList {
  798.     set groupName [$group name]
  799.     if [info exists workingList($group)] {
  800.         set working $workingList($group)
  801.     } else {
  802.         set working [ORB::nil]
  803.     }
  804.     foreach version [$group groupVersions] {
  805.         if [$version isSame $working] continue
  806.         if {"[$version status]" == "working"} continue
  807.         lappend versionList [list $version "$groupName"]
  808.     }
  809.     }
  810.     BrowserProcs::selectObject $this $versionList $mode
  811. }
  812.  
  813. method SysVDbObj::system {this} {
  814.     if {[catch {set system [[[$this info] set PhaseSystemLink] system]}] ||
  815.     [$system isNil]} {
  816.     global errorInfo
  817.     set errorInfo ""
  818.     global errorCode
  819.     set errorCode ""
  820.     return [$this SystemVersion::system]
  821.     }
  822.     return $system
  823. }
  824.  
  825. # Do not delete this line -- regeneration end marker
  826.  
  827.