home *** CD-ROM | disk | FTP | other *** search
/ PC World 1998 October / PCWorld_1998-10_cd.bin / software / prehled / komix / DATA.Z / doctool.tcl < prev    next >
Text File  |  1997-11-21  |  10KB  |  373 lines
  1. #---------------------------------------------------------------------------
  2. #
  3. #      (c)     Cayenne Software Inc.    1997
  4. #
  5. #      File:           @(#)doctool.tcl    /main/titanic/12
  6. #      Author:         <generated>
  7. #      Description:
  8. #---------------------------------------------------------------------------
  9. # SccsId = @(#)doctool.tcl    /main/titanic/12   21 Nov 1997 Copyright 1997 Cayenne Software Inc.
  10.  
  11. # Start user added include file section
  12. require_module_file "document.tcl" docwriter
  13. require "browserobj.tcl"
  14. # End user added include file section
  15.  
  16.  
  17. Class DocTool : {Object} {
  18.     constructor
  19.     method destructor
  20.     method startCommand
  21.     method generateDocument
  22.     method generateStructure
  23.     method generateStructureAndContents
  24.     method generateContents
  25.     method print
  26.     method updateDocDir
  27.     method updateRepository
  28.     method updateSections
  29.     method setSection
  30.     method removeSection
  31.     method findSection
  32.     method fileToList
  33.     method editDsm
  34.     method getSectionByName
  35.     method getSectionById
  36.     attribute structure
  37.     attribute document
  38.     attribute sectionByName
  39.     attribute sectionById
  40. }
  41.  
  42. constructor DocTool {class this name document} {
  43.     set this [Object::constructor $class $this $name]
  44.     $this document $document
  45.     $this sectionByName [Dictionary new]
  46.     $this sectionById [Dictionary new]
  47.     # Start constructor user section
  48.  
  49.     # check the document directory
  50.     set docDir [[$this document] directory]
  51.     if {$docDir != ""} {
  52.         if ![file exists $docDir] {
  53.             wmtkfatal "Document directory '$docDir' does not \
  54.                     exists or permission denied"
  55.         }
  56.     } else {
  57.         wmtkfatal "Document directory not specified"
  58.     }
  59.  
  60.     # check the clientContext
  61.     set cc [ClientContext::global]
  62.     if [[$cc currentProject] isNil] {
  63.         $cc downLevel [[$document project] name]
  64.     }
  65.     if [[$cc currentConfig] isNil] {
  66.         set confV [$document configVersion]
  67.         set conf [$confV ConfigVersion::config]
  68.         $cc downLevel [$conf name]:[$confV versionName]
  69.     }
  70.     if [[$cc currentPhase] isNil] {
  71.         set phase [$document phase]
  72.         $cc downLevel [$phase name].[$phase type]
  73.     }
  74.     if [[$cc currentSystem] isNil] {
  75.         $cc downLevel [[$document system] name].document
  76.     }
  77.  
  78.     # check if documented system exists
  79.     if [[$document documentedSystem] isNil] {
  80.         wmtkfatal "Invalid documented system."
  81.     }
  82.  
  83.     # get the DSM
  84.     set dsm [[$this document] findFileVersion ${DSysVDbObj::dsmName} dsm]
  85.     if [$dsm isNil] {
  86.         set dsm [[$this document] createFileVersion \
  87.                 ${DSysVDbObj::dsmName} doc 0 dsm matrix \
  88.                 [[$this document] configVersion]]
  89.     }
  90.  
  91.     # make the fileinfo and load the dsm in the fileInfo structure
  92.     $this structure [DocStructure new documentStructure]
  93.     if [catch {[$this structure] load $dsm}] {
  94.         wmtkerror "Load document structure failed"
  95.     }
  96.  
  97.      set localSections [[$this document] localFileVersions]
  98.     # register all currently available sections
  99.     foreach repObj [[$this document] localFileVersions] {
  100.         $this setSection "[[$repObj file] name]" $repObj
  101.     }
  102.      set fileSections [[$this document] fileVersionReferences]
  103.     foreach repObj [[$this document] fileVersionReferences] {
  104.         $this setSection "[$repObj name]" $repObj
  105.     }
  106.     set propertySections [[$this document] propertyReferences]
  107.     foreach repObj [[$this document] propertyReferences] {
  108.         $this setSection "[rmWhiteSpace [$repObj name]]" $repObj
  109.     }
  110.  
  111.     # update the section with the structure info
  112.     $this updateSections
  113.  
  114.     # End constructor user section
  115.     return $this
  116. }
  117.  
  118. method DocTool::destructor {this} {
  119.     # Start destructor user section
  120.     # End destructor user section
  121. }
  122.  
  123. method DocTool::startCommand {this args} {
  124.  
  125.     # return values:
  126.     #    -1: invalid number of args or invalid command
  127.     #    0 : the specified command returned error(s)
  128.     #    1 : the specified command did NOT return error(s)
  129.  
  130.     if {[llength $args] != 2 } {
  131.         wmtkerror "invalid number of params"
  132.         return -1
  133.     }
  134.  
  135.     set editor [[$this document] editor]
  136.     if [catch {$editor connect} reason] {
  137.         wmtkerror "Connect editor failed: $reason"
  138.         return -1
  139.     }
  140.  
  141.     set result -1
  142.  
  143.     # first arg is the command
  144.     # second arg is the objectid file  document structure file
  145.     case "[lindex $args 0]" in {
  146.         {generateDocument} {
  147.             set result [$this generateDocument [lindex $args 1]]
  148.         }
  149.         {generateStructure} {
  150.             set ids [$this fileToList [lindex $args 1]]
  151.             set result [$this generateStructure $ids]
  152.         }
  153.         {generateContents} {
  154.             set ids [$this fileToList [lindex $args 1]]
  155.             set result [$this generateContents $ids]
  156.         }
  157.         {generateStructureAndContents} {
  158.             set ids [$this fileToList [lindex $args 1]]
  159.             set result [$this generateStructureAndContents $ids]
  160.         }
  161.         {print} {
  162.             set ids [$this fileToList [lindex $args 1]]
  163.             set result [$this print $ids]
  164.         }
  165.         {updateDocDir} {
  166.             set ids [$this fileToList [lindex $args 1]]
  167.             set result [$this updateDocDir $ids 0]
  168.         }
  169.         {updateRepository} {
  170.             set ids [$this fileToList [lindex $args 1]]
  171.             set result [$this updateRepository $ids]
  172.         }
  173.         {default} {
  174.             wmtkerror "Unknown command '[lindex $args 0]'"
  175.             set result -1
  176.         }
  177.     }
  178.     catch {$editor disconnect}
  179.  
  180.     return $result
  181. }
  182.  
  183. method DocTool::generateDocument {this structureFile} {
  184.  
  185.     # the structure file is possibly a customization file
  186.     # find it if that's the case
  187.  
  188.     set custFile [DocGenerator::getCustPath $structureFile]
  189.     if {$custFile != ""} {
  190.         set structureFile $custFile
  191.     }
  192.  
  193.     # make sure the dsm version is working
  194.     # create new version if this one is frozen
  195.     set result [generator generateDocument $structureFile]
  196.     if {$custFile != ""} {
  197.         unlink $custFile
  198.     }
  199.     return $result
  200. }
  201.  
  202. method DocTool::generateStructure {this objects} {
  203.  
  204.     # make sure the dsm version is working
  205.     # create new version if this one is frozen
  206.     foreach repId $objects {
  207.         set section [$this getSectionById $repId]
  208.         wmtkmessage "Generate structure for section '[$section uiName]'"
  209.         $section generateStructure 0
  210.     }
  211.     return 1
  212. }
  213.  
  214. method DocTool::generateStructureAndContents {this objects} {
  215.  
  216.     # first generate the structure of all the 'objects'
  217.     $this generateStructure $objects
  218.     # then generate the contents
  219.     $this generateContents $objects
  220.     return 1
  221. }
  222.  
  223. method DocTool::generateContents {this objects} {
  224.  
  225.     foreach repId $objects {
  226.         set section [$this getSectionById $repId]
  227.         $section generateContents
  228.     }
  229.     return 1
  230. }
  231.  
  232. method DocTool::print {this objects} {
  233.  
  234.     if {![$this updateDocDir $objects 1]} {
  235.         return 0
  236.     }
  237.  
  238.     foreach repId $objects {
  239.         set section [$this getSectionById $repId]
  240.         wmtkmessage "Print section '[$section uiName]'"
  241.         $section print
  242.     }
  243.     return 1
  244. }
  245.  
  246. method DocTool::updateDocDir {this objects ifNeeded} {
  247.  
  248.     foreach repId $objects {
  249.     set section [$this getSectionById $repId]
  250.     set uiName [$section uiName]
  251.  
  252.     if {$ifNeeded && [$section isDocDirUpToDate]} {
  253.         wmtkmessage "Document directory for section '$uiName' is up to date"
  254.     } else {
  255.         wmtkmessage "Update document directory for section '$uiName'"
  256.         $section updateDocDir
  257.     }
  258.     }
  259.  
  260.     return 1
  261. }
  262.  
  263. method DocTool::updateRepository {this objects} {
  264.  
  265.     set result 1
  266.  
  267.     foreach repId $objects {
  268.         set section [$this getSectionById $repId]
  269.         wmtkmessage "Update repository for section '[$section uiName]'"
  270.         if {![$section updateRepository]} {
  271.             set result 0
  272.             break
  273.         }
  274.     }
  275.  
  276.     if {$result == 0} {
  277.         wmtkerror "Update repository failed"
  278.     }
  279.  
  280.     return $result
  281. }
  282.  
  283. method DocTool::updateSections {this} {
  284.  
  285.  
  286.     # first remove all the structure info from the sections
  287.     foreach section [[$this sectionByName] values] {
  288.         if {![$section isA DocSection]} {
  289.             # it is not a docsection , no reset needed
  290.             continue
  291.         }
  292.         $section indentation 0
  293.         [$section _childSectionSet] contents {}
  294.         $section _parentSection ""
  295.     }
  296.  
  297.     for {set comp [[$this structure] firstComponent]} \
  298.         {$comp != ""} \
  299.         {set comp [$comp next]} {
  300.         set section [$this findSection [$comp uiName]]
  301.         if {$section == ""} {
  302.             wmtkmessage "[$comp uiName]: section not found"
  303.             continue
  304.         }
  305.         $section indentation [$comp indentation]
  306.         set parSet([$comp indentation]) $section
  307.  
  308.         set parentIndent [$comp indentation]
  309.         incr parentIndent -1
  310.         if {![catch {set parent $parSet($parentIndent)} reason]} {
  311.             $parent addChildSection $section
  312.         }
  313.     }
  314. }
  315.  
  316. method DocTool::setSection {this name section} {
  317.     [$this sectionByName] set $name $section
  318.     [$this sectionById] set [$section identity] $section
  319. }
  320.  
  321. method DocTool::removeSection {this name} {
  322.     set section [[$this sectionByName] set $name]
  323.     [$this sectionByName] unset $name
  324.     [$this sectionById] unset [$section identity]
  325. }
  326.  
  327. method DocTool::findSection {this name} {
  328.     #find the corresponding section
  329.     return [$this getSectionByName [rmWhiteSpace $name]]
  330. }
  331.  
  332. method DocTool::fileToList {this fileName} {
  333.     set fid [open [lindex $fileName 0]]
  334.     set ids [read -nonewline $fid]
  335.     close $fid
  336.     unlink [lindex $fileName 0]
  337.     return $ids
  338. }
  339.  
  340. method DocTool::editDsm {this} {
  341.     set struct [$this structure]
  342.     set dsm [$struct diagram]
  343.     if {"[$dsm getInfo Status]" == "frozen"} {
  344.         set sv [$this document]
  345.         set cv [$sv configVersion]
  346.         set dsm [$sv derive -fileVersion $dsm $cv]
  347.  
  348.         # make the fileinfo and load the dsm in the fileInfo structure
  349.         $struct delete
  350.         $this structure [DocStructure new documentStructure]
  351.         if [catch {[$this structure] load $dsm}] {
  352.             wmtkerror "Load document structure failed"
  353.             return 0
  354.         }
  355.     }
  356.     if [catch {$struct edit $dsm}] {
  357.         wmtkerror "Edit of document structure failed."
  358.         return 0
  359.     }
  360.     return 1
  361. }
  362.  
  363. # Do not delete this line -- regeneration end marker
  364.  
  365. method DocTool::getSectionByName {this name} {
  366.     return [[$this sectionByName] set $name]
  367. }
  368.  
  369. method DocTool::getSectionById {this id} {
  370.     return [[$this sectionById] set $id]
  371. }
  372.  
  373.