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