home *** CD-ROM | disk | FTP | other *** search
/ PC World 1998 October / PCWorld_1998-10_cd.bin / software / prehled / komix / DATA.Z / docgenerat.tcl < prev    next >
Text File  |  1997-10-14  |  13KB  |  530 lines
  1. #---------------------------------------------------------------------------
  2. #
  3. #      (c)     Cayenne Software Inc.    1997
  4. #
  5. #      File:           @(#)docgenerat.tcl    /main/titanic/12
  6. #      Author:         <generated>
  7. #      Description:
  8. #---------------------------------------------------------------------------
  9. # SccsId = @(#)docgenerat.tcl    /main/titanic/12   14 Oct 1997 Copyright 1997 Cayenne Software Inc.
  10.  
  11. # Start user added include file section
  12. # End user added include file section
  13.  
  14.  
  15. Class DocGenerator : {Object} {
  16.     method destructor
  17.     constructor
  18.     method generateDocument
  19.     method generateSection
  20.     method generateStructure
  21.     method createComponent
  22.     method delta2Indentation
  23.     attribute indentation
  24.     attribute editing
  25. }
  26.  
  27. global DocGenerator::double
  28. set DocGenerator::double "_no"
  29.  
  30. global DocGenerator::msg
  31. set DocGenerator::msg ""
  32.  
  33.  
  34. method DocGenerator::destructor {this} {
  35.     # Start destructor user section
  36.     # End destructor user section
  37. }
  38.  
  39. constructor DocGenerator {class this name} {
  40.  
  41.     set this [Object::constructor $class $this $name]
  42.     $this editing 0
  43.     $this indentation 0
  44.     return $this
  45. }
  46.  
  47. method DocGenerator::generateDocument {this specFile} {
  48.  
  49.     wmtkmessage "Generating document"
  50.     wmtkmessage ""
  51.  
  52.     if {! [docTool editDsm]} {
  53.         return 0
  54.     }
  55.  
  56.     # Clear the dsm
  57.     set components ""
  58.     set struct [docTool structure]
  59.     for {set component [$struct firstComponent]} \
  60.         {"$component" != ""} \
  61.         {set component [$component next]} {
  62.         lappend components $component
  63.     }
  64.     foreach component $components {
  65.         $component delete
  66.     }
  67.  
  68.     set result 1
  69.  
  70.     $this editing 1
  71.  
  72.     # read the structure file
  73.     if ![file exists $specFile] {
  74.         wmtkerror "File '$specFile' does not exist"
  75.     }
  76.  
  77.     set specList [readConfigurationFile $specFile]
  78.  
  79.     $this indentation 0
  80.     $this generateStructure $specList "" 1
  81.  
  82.     if [catch {$struct save}] {
  83.         wmtkerror "Save of document structure failed"
  84.         set result 0
  85.     }
  86.  
  87.     set diagram [$struct diagram]
  88.     $struct quit
  89.     if [catch {$struct load $diagram}] {
  90.         wmtkerror "Load of document structure failed"
  91.     }
  92.  
  93.     $this editing 0
  94.  
  95.     wmtkmessage ""
  96.     wmtkmessage "Generating document finished"
  97.  
  98.     return $result
  99. }
  100.  
  101. method DocGenerator::generateSection {this section specFile withContents} {
  102.  
  103.     set quit 0
  104.     # check if the document structure is locked for edit
  105.     # save it when it is being edited
  106.     if {! [$this editing]} {
  107.         if {! [docTool editDsm]} {
  108.             return 0
  109.         }
  110.         $this editing 1
  111.         set quit 1
  112.     }
  113.  
  114.     # read the structure file
  115.  
  116.     if ![file exists $specFile] {
  117.         wmtkerror "file $specFile does not exists"
  118.         return 0
  119.     }
  120.  
  121.     set specList [readConfigurationFile $specFile]
  122.  
  123.     # can not just take '$this indentation [$section indentation]'
  124.     # because section is not updated yet
  125.     $this indentation 0
  126.  
  127.     # find the corresponding component in the DSM
  128.     set struct [docTool structure]
  129.     set comp [$struct findComponent [$section uiName]]
  130.     if { $comp != ""} {
  131.         $this indentation [$comp indentation]
  132.     }
  133.  
  134.     $this generateStructure $specList $comp $withContents
  135.  
  136.     set result 1
  137.     if $quit {
  138.         if [catch {$struct save}] {
  139.             set result 0
  140.             wmtkerror "Save of document structure failed"
  141.         }
  142.  
  143.         set diagram [$struct diagram]
  144.         $struct quit
  145.         if [catch {$struct load $diagram}] {
  146.             wmtkerror "Load of document structure failed"
  147.         }
  148.  
  149.         $this editing 0
  150.     }
  151.  
  152.     return $result
  153. }
  154.  
  155. method DocGenerator::generateStructure {this specList startComp withContents} {
  156.  
  157.     require_module_file "docstructp.tcl" docwriter
  158.  
  159.     # lock the dsm
  160.     # ...
  161.  
  162.     set prevComp $startComp
  163.     set sectionSet {}
  164.  
  165.     foreach structLine $specList {
  166.         set docStructPart [DocStructPart new $structLine]
  167.  
  168.         # skip the ones with double names and the same parent (error)
  169.         # ...
  170.  
  171.         set comp [$this createComponent $docStructPart $prevComp]
  172.         set indent ""
  173.         for { set j [$comp indentation] } { $j > 0} { incr j -1} {
  174.             set indent "   $indent"
  175.         }
  176.         global DocGenerator::msg
  177.         set DocGenerator::msg "$indent"
  178.         set section [DocGenerator::createSection $docStructPart 0]
  179.  
  180.         if {"$section" == ""} {
  181.             $comp delete
  182.             continue
  183.         }
  184.  
  185.         if [$section isA LocalSection] {
  186.             set orgIndent [$this indentation]
  187.             $section generateStructure $withContents
  188.             # set the prevComp to the last component
  189.             set prevComp [documentStructure lastComponent]
  190.             $this indentation $orgIndent
  191.             lappend sectionSet $section
  192.         } else {
  193.             set prevComp $comp
  194.         }
  195.     }
  196.  
  197.     # Be sure the structure-info in the section is up-to-date
  198.     # before generating the contents
  199.     docTool updateSections
  200.  
  201.     # now generate the contents of the created sections
  202.     if { $withContents == 1} {
  203.         foreach section $sectionSet {
  204.             $section generateContents
  205.         }
  206.     }
  207. }
  208.  
  209. method DocGenerator::createComponent {this docStructPart prevComp} {
  210.  
  211.     set struct [docTool structure]
  212.     set component [$struct findComponent [$docStructPart sectionName]]
  213.     set compChildren {}
  214.  
  215.     if {$component == ""} {
  216.         global classCount
  217.         set component [DocComponent new DocComponent$classCount $struct]
  218.         incr classCount
  219.         $component uiName [$docStructPart sectionName]
  220.     } else {
  221.         set section [docTool findSection [$docStructPart sectionName]]
  222.         if {$section != ""} {
  223.             set tree [$section getTree]
  224.             foreach leaf $tree {
  225.                 set comp [$struct findComponent [$leaf uiName]]
  226.                 if {$comp != ""} {
  227.                     lappend compChildren $comp
  228.                 }
  229.             }
  230.         }
  231.     }
  232.  
  233.     $this indentation [expr {
  234.         [$this indentation] +
  235.         [$this delta2Indentation [$docStructPart levelDelta]]
  236.     }]
  237.     $component indentation [$this indentation]
  238.  
  239.     if {$prevComp != ""} {
  240.         $component moveBehind $prevComp
  241.     }
  242.  
  243.     foreach comp $compChildren {
  244.         $comp delete
  245.     }
  246.  
  247.     return $component
  248. }
  249.  
  250. proc DocGenerator::createSection {docStructPart {uniqueName 1}} {
  251.     set itemType section
  252.  
  253.     set sv [$docStructPart documentVersion]
  254.     if {![isCommand $sv]} {
  255.         set sv [docTool document]
  256.     }
  257.     set cv [$sv configVersion]
  258.     set editor [[$sv editor] name]
  259.     set version [[$sv editor] version]
  260.     set name [$docStructPart sectionName]
  261.     set type [$docStructPart sectionType]
  262.     set class [$docStructPart sectionClass]
  263.     if {$class == ""} {
  264.         set class $type
  265.     }
  266.     set class [Document::getClass $editor $version $class]
  267.  
  268.  
  269.     if {$class == ""} {
  270.         set fileV [$docStructPart fileVersion]
  271.         if {[isCommand $fileV]} {
  272.             if {![$fileV isNil]} {
  273.                 if {[$fileV isA ExternalFileVersion]} {
  274.                     # for text file references without 
  275.                     # a section class
  276.                     set class TextRefSection
  277.                 }
  278.             }
  279.         }
  280.         if {$class == ""} {
  281.             return ""
  282.         }
  283.     }
  284.  
  285.     if {[lsearch [Document::getSuperClasses $class] \
  286.         "SystemFileReference"] != -1} {
  287.         set fv [$docStructPart fileVersion]
  288.         set section [DocGenerator::updateSection \
  289.             $docStructPart \
  290.             [$sv findFileReference $name $type] \
  291.             $uniqueName]
  292.         if [$section isNil] {
  293.             set section [$sv createFixedFileReference \
  294.                 $name $type $fv $cv]
  295.             DocGenerator::setLongName $section $name
  296.         } elseif $uniqueName {
  297.             return $section
  298.         }
  299.     } elseif {[lsearch [Document::getSuperClasses $class] \
  300.         "ExternalFileVersion"] != -1} {
  301.         # it's a ExternalFileVersion
  302.         set section [DocGenerator::updateSection \
  303.             $docStructPart \
  304.             [$sv findFileVersion $name $type] \
  305.             $uniqueName]
  306.         if [$section isNil] {
  307.             set fileClass [Document::getFileClass \
  308.                 $editor $version $type]
  309.             set section [$sv createFileVersion \
  310.                 $name $itemType 0 $type $fileClass $cv]
  311.             DocGenerator::setLongName $section $name
  312.         } elseif {"[$section getInfo Status]" == "frozen"} {
  313.             set section [$sv derive -fileVersion $section $cv]
  314.         } elseif $uniqueName {
  315.             return $section
  316.         }
  317.     } elseif {[lsearch [Document::getSuperClasses $class] \
  318.         "ItemPropertyReference"] != -1} {
  319.         set section [DocGenerator::updateSection \
  320.             $docStructPart \
  321.             [$sv findPropertyReference $name $type] \
  322.             $uniqueName]
  323.         if [$section isNil] {
  324.             set workItem [$docStructPart workItem]
  325.             set itemKeeper [$workItem owner]
  326.             if [$itemKeeper isA SystemVersion] {
  327.                 set object [$itemKeeper system]
  328.             } else {
  329.                 set object [$itemKeeper file]
  330.             }
  331.             set item [$workItem item]
  332.             if [catch {set section [$sv createItemPropRef \
  333.                         $name $type $object $item]} msg] {
  334.                 wmtkerror $msg
  335.                 return ""
  336.             }
  337.             DocGenerator::setLongName $section $name
  338.         } elseif $uniqueName {
  339.             return $section
  340.         }
  341.     } elseif {[lsearch [Document::getSuperClasses $class] \
  342.         "FilePropertyReference"] != -1} {
  343.         set section [DocGenerator::updateSection \
  344.             $docStructPart \
  345.             [$sv findPropertyReference $name $type] \
  346.             $uniqueName]
  347.         if [$section isNil] {
  348.             set file [[$docStructPart fileVersion] file]
  349.             if [catch {set section [$sv createFilePropRef \
  350.                             $name $type $file]} msg] {
  351.                 wmtkerror $msg
  352.                 return ""
  353.             }
  354.             DocGenerator::setLongName $section $name
  355.         } elseif $uniqueName {
  356.             return $section
  357.         }
  358.     } else { # no match
  359.         wmtkerror "Invalid class '$class' for section '$name'."
  360.         return ""
  361.     }
  362.  
  363.     if [isCommand docTool] {
  364.         docTool setSection [rmWhiteSpace $name] $section
  365.     }
  366.  
  367.     if {[$section isA FilepropSection]} {
  368.         # set the item of the property and the property name
  369.         $section setProperty refProperties \
  370.             "[$docStructPart propertyNames]"
  371.         # the default status is selected, make is fixed
  372.         $section status fixed $cv
  373.         # update the document directory
  374.         $section updateDocDir
  375.     } elseif {[$section isA ItempropSection]} {
  376.         # set the diagram of the property and the property name
  377.         $section setProperty refProperties \
  378.             "[$docStructPart propertyNames]"
  379.         # the default status is current, make is snapshot
  380.         $section status snapshot $cv
  381.         # update the document directory
  382.         $section updateDocDir
  383.     } elseif {![$section isA LocalSection]} {
  384.         # update the document directory
  385.         $section updateDocDir
  386.     } else {
  387.         set structGen [$docStructPart structureGenerator]
  388.         if {$structGen != ""} {
  389.             $section setProperty structureGen $structGen
  390.         }
  391.         set contGen [$docStructPart contentsGenerator]
  392.         if {$contGen != ""} {
  393.             $section setProperty contentsGen $contGen
  394.         }
  395.  
  396.         # create the local section
  397.         #section synchWithFileSystem
  398.  
  399.         # fill the LocalSection with the initial contents
  400.         set fr ""
  401.         if { [$docStructPart initContents] != "" } {
  402.             set fr [$docStructPart initContents]
  403.         } elseif { [$section initContents] != "" } {
  404.             set fr [$section initContents]
  405.         }
  406.  
  407.         if {$fr != ""} {
  408.             set to [$section docLocation]
  409.             # is it an absolute path, don't look in M4_dir
  410.             if {![file exists $fr]} {
  411.                 set mfr [DocGenerator::getCustPath $fr]
  412.                 if {$mfr != ""} {
  413.                     file copy -force $mfr $to
  414.                     BasicFS::removeFile $mfr
  415.                 } else {
  416.                     set msg "Initial contents '$fr' not found"
  417.                     wmtkmessage $msg
  418.                     if [isCommand docTool] {
  419.                     wmtkmessage "$msg
  420.                     } else {
  421.                     wmtkerror $msg
  422.                     }
  423.                 }
  424.             } else {
  425.                 file copy -force $fr $to
  426.             }
  427.         } else {
  428.             set file [$section docLocation]
  429.             # touch this one
  430.             if {![catch {set fid [open $file w]} reason]} {
  431.                 puts $fid " "
  432.                 close $fid
  433.             }
  434.         }
  435.     }
  436.  
  437.     return $section
  438. }
  439.  
  440. proc DocGenerator::updateSection {docStructPart section uniqueName} {
  441.     global DocGenerator::msg
  442.  
  443.     if {[$section isNil] || "[$section getInfo Status]" == "frozen"} {
  444.         append DocGenerator::msg \
  445.             "Create section '[$docStructPart sectionName]'"
  446.         wmtkmessage ${DocGenerator::msg}
  447.         set DocGenerator::msg ""
  448.         return $section
  449.     }
  450.  
  451.     if $uniqueName {
  452.         $docStructPart sectionName [DocGenerator::uniqueName \
  453.             [$docStructPart sectionName]]
  454.         return [DocGenerator::createSection $docStructPart]
  455.     }
  456.  
  457.     append DocGenerator::msg \
  458.         "Update section '[$docStructPart sectionName]'"
  459.     wmtkmessage ${DocGenerator::msg}
  460.     set DocGenerator::msg ""
  461.     return $section
  462. }
  463.  
  464. method DocGenerator::delta2Indentation {this levelDelta} {
  465.  
  466.     if [lempty $levelDelta] {
  467.         return 0
  468.     }
  469.  
  470.     set delta [string index $levelDelta 0]
  471.  
  472.     if { $delta == "=" } {
  473.         return 0
  474.     } elseif { $delta == "+" } {
  475.         return 1
  476.     } elseif { $delta == "-" } {
  477.         set offset [string range $levelDelta 1 end]
  478.         if {$offset == ""} {
  479.             return -1
  480.         } else {
  481.             return $levelDelta
  482.         }
  483.     }
  484.  
  485.     return 0
  486. }
  487.  
  488. proc DocGenerator::uniqueName {name} {
  489.     set id [string last ${DocGenerator::double} $name]
  490.     if {$id < 0} {
  491.         return "${name}${DocGenerator::double}2"
  492.     }
  493.     incr id [string length ${DocGenerator::double}]
  494.     set nr [string range $name $id end]
  495.     incr nr
  496.     incr id -1
  497.     return "[string range $name 0 $id]$nr"
  498. }
  499.  
  500. proc DocGenerator::getCustPath {custFile} {
  501.  
  502.     set name [path_name base $custFile]
  503.     set type [path_name type $custFile]
  504.     set tmpFile [args_file {}]
  505.  
  506.     # user
  507.     require custfileut.tcl
  508.     set path [CustFileUtilities::find "" $name $type]
  509.     if {$path != ""} {
  510.         file copy -force $path $tmpFile
  511.         return $tmpFile
  512.     }
  513.  
  514.     # levels, modules, corporate
  515.     set cc [ClientContext::global]
  516.     if {[$cc downLoadCustomFile $name $type etc $tmpFile] == 0} {
  517.         return $tmpFile
  518.     }
  519.  
  520.     unlink $tmpFile
  521.     return ""
  522. }
  523.  
  524. proc DocGenerator::setLongName {section longName} {
  525.     $section setProperty longName "$longName"
  526. }
  527.  
  528. # Do not delete this line -- regeneration end marker
  529.  
  530.