home *** CD-ROM | disk | FTP | other *** search
/ PC World 1997 November / PCWorld_1997-11_cd.bin / software / programy / komix / DATA.Z / vsobjnamec.tcl < prev    next >
Text File  |  1997-06-06  |  11KB  |  394 lines
  1. #---------------------------------------------------------------------------
  2. #
  3. #      (c)     Cayenne Software Inc.    1997
  4. #
  5. #      File:           @(#)vsobjnamec.tcl    /main/hindenburg/7
  6. #      Author:         <generated>
  7. #      Description:    VCM integration file
  8. #---------------------------------------------------------------------------
  9. # SccsId = @(#)vsobjnamec.tcl    /main/hindenburg/7   6 Jun 1997 Copyright 1997 Cayenne Software Inc.
  10.  
  11. # Start user added include file section
  12. # End user added include file section
  13.  
  14. require "objnamecha.tcl"
  15.  
  16. # Redefinition of ObjNameChangeDialog
  17. # to add rename functionality in VCM
  18. # system.
  19.  
  20. Class VSObjNameChangeDialog : {ObjNameChangeDialog} {
  21.     constructor
  22.     method destructor
  23.     method changeName
  24.     method changeObjectName
  25.     method isPathError
  26.     method getParent
  27.     method updateObjectPath
  28.     method updateVSFilePath
  29.     method updateFileSystemPath
  30.     method getOldPath
  31.     method readPathCustomization
  32.     method renameDirectoryWithConfirm
  33.         method initialize
  34.  
  35.     # Set by subclass: CCSystem, RazorSystem or
  36.     # ContSystem. Used to access static methods
  37.     # of these classes.
  38.     #
  39.     attribute vsSystem
  40. }
  41.  
  42. constructor VSObjNameChangeDialog {class this name tool} {
  43.     set this [ObjNameChangeDialog::constructor $class $this $name $tool]
  44.     # Start constructor user section
  45.     # End constructor user section
  46.     return $this
  47. }
  48.  
  49. method VSObjNameChangeDialog::destructor {this} {
  50.     # Start destructor user section
  51.     # End destructor user section
  52.     $this ObjNameChangeDialog::destructor
  53. }
  54.  
  55.  
  56. method VSObjNameChangeDialog::initialize {this newObj} {
  57.     # sport7: check integration type of object and promote if necessary
  58.     # call upper level if no VCM integration is installed here
  59.     set project $newObj
  60.     if { ![$newObj isA Project] } {
  61.     set project [[ClientContext::global] currentProject]
  62.     }
  63.  
  64.     set vcmIntegration [$project getPropertyValue vcmIntegration]
  65.     if { ($vcmIntegration == "") || ($vcmIntegration == "razor") } {
  66.     return 0
  67.     }
  68.  
  69.     set cc [ClientContext::global]
  70.     set level [$cc currentLevel]
  71.     if { ($level == "System") || ($level == "Phase") } {
  72.     set phase [[[$cc currentPhase] phase] type]
  73.     if { $phase != "Implementation" } {
  74.        return 0
  75.     }
  76.     }
  77.  
  78.     case $vcmIntegration in {
  79.     {cc} {
  80.         CCObjNameChangeDialog promote $this
  81.     }
  82.     {cont} {
  83.         ContObjNameChangeDialog promote $this
  84.     }
  85.     }
  86.     return 1
  87. }
  88.  
  89. # Redefinition that catches path name errors
  90. # in the repository.
  91. #
  92. method VSObjNameChangeDialog::changeName {this useOld} {
  93.     set keeper [$this keeper]
  94.     set configV [$this configV]
  95.     set newName [$this text]
  96.     set oldName [[$this item] name]
  97.  
  98.     # Store info about the selected object
  99.     # which will possibly be deselected by the ItemKeeper
  100.     set selectedObj [lindex [[$this tool] selectedObjSet] 0]
  101.     if { ![$this initialize $selectedObj] } {
  102.     $this ObjNameChangeDialog::changeName $useOld
  103.     return
  104.     }
  105.  
  106.     if [$selectedObj isA SystemVersion] {
  107.     set parentObj [$selectedObj getParent PhaseVersion]
  108.     set objType [[$selectedObj system] type]
  109.     set level system
  110.     } elseif [$selectedObj isA FileVersion] {
  111.     set phaseObj [$selectedObj getParent PhaseVersion]
  112.     set parentObj [$selectedObj getParent SystemVersion]
  113.     set objType [[$selectedObj file] type]
  114.     set sysType [[$parentObj system] type]
  115.     set level file
  116.     } else {
  117.     set level other
  118.     }
  119.  
  120.     # Do the actual name change
  121.     if [ catch { $keeper renameRefs [$this item] $newName $useOld $configV } message] {
  122.     if { ![$this isPathError $message] } {
  123.         error $message
  124.     }
  125.     }
  126.     
  127.  
  128.     # Retrieve the name-changed object
  129.     # which is possibly just created by the ItemKeeper
  130.     set closeFlag 0
  131.     case $level in {
  132.     {system} {
  133.         set newObj [$parentObj findSystemVersion "$newName" "$objType"]
  134.     }
  135.     {file} {
  136.         if [catch {set newObj \
  137.             [$parentObj findFileVersion "$newName" "$objType"]}] {
  138.         set parentObj \
  139.             [$phaseObj findSystemVersion "$newName" "$sysType"]
  140.         set newObj \
  141.             [$parentObj findFileVersion "$newName" "$objType"]
  142.         set closeFlag 1
  143.         global errorInfo
  144.         set errorInfo ""
  145.         global errorCode
  146.         set errorCode ""
  147.         }
  148.     }
  149.     {default} {
  150.         set newObj [ORB::nil]
  151.     }
  152.     }
  153.  
  154.     $this updateObjectPath $oldName $newObj
  155.  
  156.     # Close the current view if the parent is deselected
  157.     if $closeFlag {
  158.     wmtkmessage "Deselected [$parentObj browserType] '$oldName':\
  159.         Closing View ..."
  160.     [[[$this tool] currentObj] parent] open
  161.     wmtkmessage "Done"
  162.     }
  163.  
  164.     [$this tool] updateView
  165.     $this delete
  166. }
  167.  
  168.  
  169. # Redefinition that catches path name errors
  170. # in the repository.
  171. #
  172. method VSObjNameChangeDialog::changeObjectName {this} {
  173.     set newName [$this text]
  174.     set selectedObj [lindex [[$this tool] selectedObjSet] 0]
  175.     set oldName [$selectedObj name]
  176.     if { ![$this initialize $selectedObj] } {
  177.     $this ObjNameChangeDialog::changeObjectName
  178.     return
  179.     }
  180.  
  181.     # do the rename
  182.     set renameObject $selectedObj
  183.     # for configversions the config must be renamed
  184.     if [$renameObject isA ConfigVersion] {
  185.     set renameObject [$selectedObj ConfigVersion::config]
  186.     }
  187.     if [catch { $renameObject name $newName } message] {
  188.     if { ![$this isPathError $message] } {
  189.         error $message
  190.     }
  191.     }
  192.  
  193.     $this updateObjectPath $oldName $selectedObj
  194.     [$this tool] updateView
  195.     wmtkmessage ""
  196.     $this delete
  197. }
  198.  
  199.  
  200. # Return whether given error message is a 
  201. # path error or not. Path error: some error
  202. # that occurred during change name because
  203. # a directory could not be moved.
  204. #
  205. method VSObjNameChangeDialog::isPathError {this message} {
  206.     return [regexp {able to rename directory} $message]
  207. }
  208.  
  209.  
  210. # Return parent object of object in which object is
  211. # a SystemVersion, ConfigVersion or Project.
  212. #
  213. method VSObjNameChangeDialog::getParent {this object} {
  214.     set cc [ClientContext::global]
  215.     if [$object isA SystemVersion] {
  216.     return [$cc currentPhase]
  217.     }
  218.     if [$object isA ConfigVersion] {
  219.     return [$cc currentProject]
  220.     }
  221.     return [$cc currentCorporate]
  222. }
  223.  
  224.  
  225. # Update the path of newObj in the VCM system
  226. # if there is a correspondance. For VSFiles there
  227. # always is, for Project, ConfigVersion and SystemVersion
  228. # check presence of name in path through vsObject
  229. # UserPath and rename if so.
  230. #
  231. method VSObjNameChangeDialog::updateObjectPath {this oldName newObj} {
  232.     # if this dialog is not VCM specific initialization failed;
  233.     # delegate to super class in this case
  234.     # another sport7 hack
  235.     if { [$this objType] == "VSObjNameChangeDialog" } {
  236.     $this ObjNameChangeDialog::updateObjectPath $oldName $newObj
  237.     return
  238.     }
  239.  
  240.     if [$newObj isNil] {
  241.     return
  242.     }
  243.  
  244.     # This action may be called at a level above system level in which
  245.     # case the VCM vars must still be initialized.
  246.     if { ![$this initializeVCMVars] } {
  247.     return
  248.     }
  249.  
  250.     # real external links: do nothing
  251.     if [$newObj isA ExternalLink] {
  252.     return
  253.     }
  254.  
  255.     if [$newObj isA VSFile] {
  256.     $this updateVSFilePath $oldName $newObj
  257.     return
  258.     }
  259.  
  260.     # make sure that path redefinitions are available
  261.     $this readPathCustomization $newObj
  262.  
  263.     set oldPath [[$this vsSystem]::vsObjectUserPath $newObj]
  264.     $this updateFileSystemPath $oldName $newObj
  265.     set newPath [[$this vsSystem]::vsObjectUserPath $newObj]
  266.  
  267.     # if path did not change because of change in the fileSystemPath property
  268.     # retrieve old path
  269.     if { "$newPath" == "$oldPath" } {
  270.     set oldPath [$this getOldPath $oldName $newObj]
  271.     }
  272.  
  273.     # if path changed: action
  274.     if { "$newPath" != "$oldPath" } {
  275.     # find changed part
  276.     set newPathParts [file_split $newPath]
  277.     set oldPathParts [file_split $oldPath]
  278.     set index 0
  279.     while { $index < [llength $newPathParts] } {
  280.         if { [lindex $newPathParts $index] != [lindex $oldPathParts $index] } {
  281.         set oldPath [file_join [lrange $oldPathParts 0 $index]]
  282.         set newPath [file_join [lrange $newPathParts 0 $index]]
  283.         $this renameDirectoryWithConfirm $oldPath $newPath
  284.         }
  285.         incr index 1
  286.     }
  287.     }
  288. }
  289.  
  290.  
  291. # Update fileSystemPath property of newObj
  292. # and move file in the VCM system.
  293. #
  294. method VSObjNameChangeDialog::updateVSFilePath {this oldName newObj} {
  295.     $newObj updatePath
  296.  
  297.     # if name change in VCM fails reset name
  298.     if { ![$newObj renameInVS $oldName] } {
  299.     $newObj name $oldName
  300.     } else {
  301.     # force update by deleting object; updateView will take care
  302.     # of the rest
  303.     $newObj delete
  304.     }
  305. }
  306.  
  307.  
  308. # Update file System Path property if
  309. # oldName occurred in it.
  310. #
  311. method VSObjNameChangeDialog::updateFileSystemPath {this oldName newObj} {
  312.     set filePathProperty [$newObj findProperty fileSystemPath]
  313.     if { ![$filePathProperty isNil] } {
  314.     set newName [$newObj name]
  315.     set oldValue [$filePathProperty value]
  316.     if [regsub $oldName $oldValue $newName newValue] {
  317.         $filePathProperty change "$newValue"
  318.     }
  319.     }
  320. }
  321.  
  322.  
  323. # Get old path of object: find relative part and replace
  324. # newName with oldName in this part.
  325. #
  326. method VSObjNameChangeDialog::getOldPath {this oldName newObj} {
  327.     set newPath [[$this vsSystem]::vsObjectUserPath $newObj]
  328.     set newName [$newObj name]
  329.     set parentObj [$this getParent $newObj]
  330.     set parentPath [[$this vsSystem]::vsObjectUserPath $parentObj]
  331.  
  332.     # if parent path occurs in new path we can determine the relative path
  333.     if { [string first $parentPath $newPath] == 0 } {
  334.     set relativePathIndex [expr [string length $parentPath]+1]
  335.     set relativePath [string range $newPath $relativePathIndex end]
  336.     regsub -all $newName $relativePath $oldName oldRelativePath
  337.     return [path_name concat $parentPath $oldRelativePath]
  338.     }
  339.  
  340.     return $newPath
  341. }
  342.  
  343.  
  344. # Read u_vcm.tcl at the correct level.
  345. #
  346. method VSObjNameChangeDialog::readPathCustomization {this {levelID ""}} {
  347.     set cc [ClientContext::global]
  348.     set levelChanged 0
  349.  
  350.     # if level does not occur in level string we are one level too high
  351.     # go down in this case.
  352.     if { $levelID != "" } {
  353.     if { ![regexp [$levelID identity] [$cc currentLevelIdString]] } {
  354.         $cc downLevelId $levelID
  355.         set levelChanged 1
  356.     }
  357.     }
  358.  
  359.     # source the customization file
  360.     eval [$cc getCustomFileContents u_vcm tcl etc]
  361.  
  362.     # reset level if needed
  363.     if $levelChanged {
  364.     $cc upLevel
  365.     }
  366. }
  367.  
  368.  
  369. # Issue warning that a directory is about te be renamed
  370. # and ask confirmation.
  371. #
  372. method VSObjNameChangeDialog::renameDirectoryWithConfirm {this oldPath newPath} {
  373.     if { ![[$this vsSystem]::directoryExists $oldPath] } {
  374.     return
  375.     }
  376.  
  377.     set message "Directory $oldPath will be renamed to $newPath"
  378.     WarningDialog new .main.renameWarning \
  379.         -title "Change Name Warning" \
  380.         -message $message
  381.  
  382.     .main.renameWarning okPressed \
  383.         ".main busy 1;\
  384.         [$this vsSystem]::renameVSDirectory [list $oldPath] [list $newPath];\
  385.         .main busy 0;\
  386.         .main.renameWarning delete"
  387.  
  388.     .main.renameWarning delHelpButton
  389.     .main.renameWarning popUp
  390. }
  391.  
  392. # Do not delete this line -- regeneration end marker
  393.  
  394.