home *** CD-ROM | disk | FTP | other *** search
/ PC World 1998 October / PCWorld_1998-10_cd.bin / software / prehled / komix / DATA.Z / opendiagra.tcl < prev    next >
Text File  |  1997-11-27  |  13KB  |  472 lines
  1. #---------------------------------------------------------------------------
  2. #
  3. #      (c)     Cayenne Software Inc.    1997
  4. #
  5. #      File:           @(#)opendiagra.tcl    /main/titanic/12
  6. #      Author:         <generated>
  7. #      Description:
  8. #---------------------------------------------------------------------------
  9. # SccsId = @(#)opendiagra.tcl    /main/titanic/12   27 Nov 1997 Copyright 1997 Cayenne Software Inc.
  10.  
  11. # Start user added include file section
  12. require "opdatatype.tcl"
  13. require "openaction.tcl"
  14. # End user added include file section
  15.  
  16.  
  17. Class OpenDiagram : {TemplateDialog} {
  18.     constructor
  19.     method destructor
  20.     method popUp
  21.     method handleOk
  22.     method handleCancel
  23.     method handleSelectionChanged
  24.     method addSearch
  25.     method addCreate
  26.     method addCreateAct
  27.     method addUserDef
  28.     method makeDecompIn
  29.     method createSystem
  30.     method selectedProp
  31.     method evalMacsIn
  32.     attribute selectedItem
  33.     attribute selDataType
  34.     attribute diagramItem
  35.     attribute diagramType
  36.     attribute selItemSys
  37.     attribute editor
  38. }
  39.  
  40. constructor OpenDiagram {class this name} {
  41.     set this [TemplateDialog::constructor $class $this $name]
  42.     # Start constructor user section
  43.     interface BrowsView $this.bv {
  44.         rowCount 10
  45.         mode DETAIL
  46.         columnCount 80
  47.         selectionPolicy BROWSE
  48.         BrowsHeader operation {
  49.             label Operation
  50.             width 24
  51.         }
  52.         BrowsHeader diagram {
  53.             label Diagram
  54.             width 24
  55.         }
  56.         BrowsHeader type {
  57.             label Type
  58.             width 7
  59.         }
  60.         BrowsHeader def {
  61.             label ""
  62.             width 2
  63.         }
  64.         BrowsHeader system {
  65.             label System
  66.             width 24
  67.         }
  68.     }
  69.     $this config \
  70.         -modal yes \
  71.         -title "Select Operation" \
  72.         -okPressed "$this handleOk" \
  73.         -cancelPressed "$this handleCancel" \
  74.         -helpPressed {.main helpOnName openDiagram}
  75.     $this.bv selectionChanged "$this handleSelectionChanged"
  76.     # End constructor user section
  77.     return $this
  78. }
  79.  
  80. method OpenDiagram::destructor {this} {
  81.     # Start destructor user section
  82.     # End destructor user section
  83. }
  84.  
  85. method OpenDiagram::popUp {this} {
  86.     set ed [$this editor]
  87.     set cc [ClientContext::global]
  88.  
  89.     busy {
  90.         # check if objtypes handler is already created
  91.         if {![isCommand [$ed objHdlr]]} {
  92.             $ed objHdlr [CustObjHandler new [$ed moduleHdlr]]
  93.             [$ed objHdlr] setCurrentContext
  94.         }
  95.         set confV [$cc currentConfig]
  96.         set fileV [$cc currentFile]
  97.         set file [$fileV file]
  98.         set fileType [$file type]
  99.         set selItemRec [$ed selectedItem]
  100.         set selItem [lindex $selItemRec 0]
  101.         $this selectedItem [$selItem item]
  102.         $this selDataType [[$this selectedProp data_type] name]
  103.         $this diagramItem [$file item]
  104.         $this diagramType $fileType
  105.         $this selItemSys [ORB::nil]
  106.         set selWorkItem [$fileV findDefinition [$selItem item] $confV]
  107.         if {![$selWorkItem isNil]} {
  108.             set selItemOwner [$selWorkItem owner]
  109.             if [$selItemOwner isA SystemVersion] {
  110.                 $this selItemSys [$selItemOwner system]
  111.             }
  112.         }
  113.         OpenLocation new .openLocation \
  114.             -itemType "[$selItem type]" \
  115.             -phaseType "[[[$cc currentPhase] phase] type]" \
  116.             -diagramType "$fileType" \
  117.             -componentType "[lindex $selItemRec 1]" \
  118.             -labelType "[lindex $selItemRec 2]" \
  119.             -condition "[lindex $selItemRec 3]"
  120.         set openKnowlDB [$ed openKnowledgeDB]
  121.         foreach stg [$openKnowlDB definitions .openLocation] {
  122.             if [$stg isA SearchStrategy] {
  123.                 $this addSearch $stg
  124.             } elseif [$stg isA CrFileStrategy] {
  125.                 $this addCreate $stg
  126.             } else {
  127.                 $this addUserDef $stg
  128.             }
  129.         }
  130.         set objSet [$this.bv objectSet]
  131.         set objSetSize [llength $objSet]
  132.         if {$objSetSize == 0} {
  133.             wmtkerror "No Open operations available for selected item"
  134.             $this delete
  135.             return
  136.         }
  137.         if {$objSetSize == 1} {
  138.             # no automatic navigation
  139.             # just select the one and only
  140.             [lindex $objSet 0] selectState true
  141.         }
  142.  
  143.         $this.bv sort -command OpenDiagram::cmpOpenAct
  144.         $this handleSelectionChanged
  145.         $this TemplateDialog::popUp
  146.     }
  147. }
  148.  
  149. method OpenDiagram::handleOk {this} {
  150.     foreach action [$this.bv selectedSet] {
  151.         eval [$action script]
  152.     }
  153.     $this delete
  154. }
  155.  
  156. method OpenDiagram::handleCancel {this} {
  157.     $this delete
  158. }
  159.  
  160. method OpenDiagram::handleSelectionChanged {this} {
  161.     set selected [llength [$this.bv selectedSet]]
  162.     $this okSensitive $selected
  163.     $this okDefault $selected
  164.     $this cancelDefault [expr 1 - $selected]
  165. }
  166.  
  167. method OpenDiagram::addSearch {this stg} {
  168.     set ed [$this editor]
  169.     set cc [ClientContext::global]
  170.     set configV [$cc currentConfig]
  171.     set systemV [$cc currentSystem]
  172.     set system [$systemV system]
  173.     set selItem [$this selectedItem]
  174.     $systemV getDecompositions $selItem $configV \
  175.         [$stg decompFlags] [$stg fileTypes] decompSystems decompFiles
  176.     foreach decFileV $decompFiles {
  177.         if {$decFileV == [$cc currentFile]} continue
  178.         set decSys [$decFileV system]
  179.         set dfl [$decFileV file]
  180.         set decType [$dfl type]
  181.         set opId ${decType}File[$dfl qualifiedName :]InSys[$decSys name]
  182.         regsub -all "\\." "$opId" "DOT" opId
  183.         set opAct $this.bv.$opId
  184.         if [isCommand $opAct] continue
  185.         set objSpec [getObjectSpec [$ed objHdlr] Graph $decType]
  186.         if {"$objSpec" == ""} continue
  187.  
  188.         if {$decSys == $system && $decType == [$this diagramType]} {
  189.             set action "load diagram"
  190.             set actionId 1
  191.             set script "$ed push [$cc createPath $decFileV]"
  192.         } else {
  193.             set action "start editor"
  194.             set actionId 2
  195.             set phaseV [$cc currentPhase]
  196.             set decSysV [$phaseV findSystemVersion \
  197.                             -bySystem $decSys]
  198.             set script \
  199.                  "$ed newEditor [$cc createPath $decSysV $decFileV]"
  200.         }
  201.         set details [list [$dfl qualifiedName :]]
  202.         lappend details    $decType
  203.         if {$decSys == [$this selItemSys]} {
  204.             lappend details *
  205.         } else {
  206.             lappend details ""
  207.         }
  208.         lappend details [$decSys name]
  209.         OpenAction new $opAct \
  210.             -activated "$this popDown; $this handleOk" \
  211.             -smallIcon [$objSpec smallIcon] \
  212.             -label "$action" \
  213.             -details "$details" \
  214.             -operationId $actionId \
  215.             -script "$script"
  216.         lappend [$this.bv objectSet] $opAct
  217.     }
  218. }
  219.  
  220. method OpenDiagram::addCreate {this stg} {
  221.     set cc [ClientContext::global]
  222.     set configV [$cc currentConfig]
  223.     set systemV [$cc currentSystem]
  224.     set decQual [$this evalMacsIn [$stg qualItemSpec]]
  225.     if {"$decQual" != "" && [$decQual isNil]} return
  226.     set decName [$this evalMacsIn [$stg fileNameSpec]]
  227.     set decType [$this evalMacsIn [$stg fileTypeSpec]]
  228.     set itemType [file2itemtype $decType]
  229.     if {"$decQual" == ""} {
  230.         set wItm [$systemV findDefinition $decName $itemType $configV]
  231.     } else {
  232.         set wItm [$systemV findDefinition $decQual $configV]
  233.     }
  234.     set decSysV [ORB::nil]
  235.     if {![$wItm isNil]} {
  236.         set decSysV [$wItm owner]
  237.     }
  238.     if [$decSysV isNil] {
  239.         if [$stg isA CrSysStrategy] {
  240.             set phaseV [$cc currentPhase]
  241.             set decSysName [$this evalMacsIn [$stg sysNameSpec]]
  242.             set decSysV [$phaseV findSystemVersion \
  243.                             $decSysName system]
  244.         } else {
  245.             set decSysV $systemV
  246.             set decSysName [[$decSysV system] name]
  247.         }
  248.     } else {
  249.         set decSysName [[$decSysV system] name]
  250.     }
  251.     $this addCreateAct $stg $decSysName $decSysV [ORB::nil]
  252.     if {"$decName" == ""} {
  253.         if {![$wItm isNil]} {
  254.             foreach qItm [$wItm qualifiedDeclarations] {
  255.                 set decFileV [$decSysV findFileVersion \
  256.                     -byItemAndType [$qItm item] $decType]
  257.                 if {![$decFileV isNil]} {
  258.                     $this addCreateAct $stg $decSysName \
  259.                             $decSysV $decFileV
  260.                 }
  261.             }
  262.         }
  263.     }
  264. }
  265.  
  266. method OpenDiagram::addCreateAct {this stg decSysName decSysV decFileV} {
  267.     set cc [ClientContext::global]
  268.     set ed [$this editor]
  269.     set systemV [$cc currentSystem]
  270.     set fileType [$this diagramType]
  271.     set decQual [$this evalMacsIn [$stg qualItemSpec]]
  272.     set decName [$this evalMacsIn [$stg fileNameSpec]]
  273.     set decType [$this evalMacsIn [$stg fileTypeSpec]]
  274.     set itemType [file2itemtype $decType]
  275.     if {"$decQual" == ""} {
  276.         set decQualName $decName
  277.     } elseif {"$decName" == ""} {
  278.         set decQualName [$decQual name]
  279.         if {![$decFileV isNil]} {
  280.             set decQualName [[$decFileV file] qualifiedName :]
  281.         }
  282.     } else {
  283.         set decQualName "[$decQual name]:$decName"
  284.     }
  285.  
  286.     set opId ${decType}File${decQualName}InSys$decSysName
  287.     regsub -all "\\." "$opId" "DOT" opId
  288.     set opAct $this.bv.$opId
  289.     if [isCommand $opAct] return
  290.     set objSpec [getObjectSpec [$ed objHdlr] Graph $decType]
  291.     if {"$objSpec" == ""} return
  292.  
  293.     if [$decSysV isNil] {
  294.         set action "create system"
  295.         set actionId 5
  296.         set script "$this createSystem $decSysName"
  297.         append script " \"$decQual\" \"$decName\" $decType"
  298.     } else {
  299.         if {"$decQual" == ""} {
  300.             set decFileV [$decSysV findFileVersion \
  301.                             $decName $decType]
  302.         } elseif [$decFileV isNil] {
  303.             set fItm [ORB::nil]
  304.             if {$decName != ""} {
  305.                 set fItm [$decQual findItem $decName $itemType]
  306.             }
  307.             if {![$fItm isNil]} {
  308.                 set decFileV [$decSysV findFileVersion \
  309.                         -byItemAndType $fItm $decType]
  310.             }
  311.         }
  312.         if [$decFileV isNil] {
  313.             if {$decType == $fileType} {
  314.                 set action "make decomposition"
  315.                 set actionId 3
  316.             } else {
  317.                 set action "create diagram"
  318.                 set actionId 4
  319.             }
  320.             set script "$this makeDecompIn $decSysV"
  321.             append script " \"$decQual\" \"$decName\" $decType"
  322.         } elseif {$decFileV == [$cc currentFile]} {
  323.             return
  324.         } elseif {$decSysV == $systemV} {
  325.             if {$decType == $fileType} {
  326.                 set action "load diagram"
  327.                 set actionId 1
  328.                 set script "$ed push [$cc createPath $decFileV]"
  329.             } else {
  330.                 set action "start editor"
  331.                 set actionId 2
  332.                 set script "$ed newEditor [$cc createPath $decSysV $decFileV]"
  333.             }
  334.         } else {
  335.             set action "start editor"
  336.             set actionId 2
  337.             set script \
  338.                  "$ed newEditor [$cc createPath $decSysV $decFileV]"
  339.         }
  340.     }
  341.     set details [list "$decQualName"]
  342.     lappend details $decType
  343.     if {[$decSysV system] == [$this selItemSys]} {
  344.         lappend details *
  345.     } else {
  346.         lappend details ""
  347.     }
  348.     lappend details $decSysName
  349.     OpenAction new $opAct \
  350.         -activated "$this popDown; $this handleOk" \
  351.         -smallIcon [$objSpec smallIcon] \
  352.         -label "$action" \
  353.         -details "$details" \
  354.         -operationId $actionId \
  355.         -script "$script"
  356.     lappend [$this.bv objectSet] $opAct
  357. }
  358.  
  359. method OpenDiagram::addUserDef {this stg} {
  360.     [$stg procedure] $this
  361. }
  362.  
  363. method OpenDiagram::makeDecompIn {this sv qualItem fileName fileType} {
  364.     set ed [$this editor]
  365.     if {"$fileName" == ""} {
  366.         $ed askDecName $sv $qualItem $fileType
  367.         return
  368.     }
  369.     $ed decompose $sv $qualItem $fileName $fileType
  370. }
  371.  
  372. method OpenDiagram::createSystem {this sysName qualItem fileName fileType} {
  373.     set cc [ClientContext::global]
  374.     set configV [$cc currentConfig]
  375.     set phaseV [$cc currentPhase]
  376.     wmtkmessage "Creating system '$sysName'"
  377.     busy {
  378.         if [catch {
  379.             set decSysV [$phaseV createSystemVersion \
  380.                 $sysName cl system $configV]
  381.         } msg] {
  382.             wmtkerror $msg
  383.             return
  384.         }
  385.     }
  386.     $this makeDecompIn $decSysV $qualItem $fileName $fileType
  387. }
  388.  
  389. method OpenDiagram::selectedProp {this prop} {
  390.     set cc [ClientContext::global]
  391.     set ed [$this editor]
  392.     set configV [$cc currentConfig]
  393.     set selItem [lindex [$ed selectedItem] 0]
  394.     set selWorkProps [[$selItem workItem $configV] properties]
  395.     if {![$selWorkProps isNil]} {
  396.         set propSpec [$selWorkProps findProperty $prop]
  397.         if {![$propSpec isNil]} {
  398.             set propItemRef [lindex [$propSpec itemRefs] 0]
  399.             if {![$propItemRef isNil]} {
  400.                 set propItem [$propItemRef item]
  401.                 if {![$propItem isNil]} {
  402.                     return $propItem
  403.                 }
  404.             }
  405.         }
  406.     }
  407.     return [$this selectedItem]
  408. }
  409.  
  410. method OpenDiagram::evalMacsIn {this spec} {
  411.     set item [$this selectedItem]
  412.     set itemName [$item name]
  413.     set itemQual [$item qualifier]
  414.     if [$itemQual isNil] {
  415.         set itemQualName ""
  416.     } else {
  417.         set itemQualName [$itemQual name]
  418.     }
  419.     set dataType [$this selDataType]
  420.     set diagItem [$this diagramItem]
  421.     set diagName [$diagItem name]
  422.     set diagQual [$diagItem qualifier]
  423.     if [$diagQual isNil] {
  424.         set diagQualName ""
  425.     } else {
  426.         set diagQualName [$diagQual name]
  427.     }
  428.     set diagType [$this diagramType]
  429.     return [expr \"$spec\"]
  430. }
  431.  
  432. proc OpenDiagram::cmpOpenAct {actA actB} {
  433.     set oIdA [$actA operationId]
  434.     set oIdB [$actB operationId]
  435.     if {$oIdA > $oIdB} {
  436.         return 1
  437.     }
  438.     if {$oIdB > $oIdA} {
  439.         return -1
  440.     }
  441.     set detA [$actA details]
  442.     set detB [$actB details]
  443.     set sysA [lindex $detA 3]
  444.     set sysB [lindex $detB 3]
  445.     if {$sysA > $sysB} {
  446.         return 1
  447.     }
  448.     if {$sysB > $sysA} {
  449.         return -1
  450.     }
  451.     set typA [lindex $detA 1]
  452.     set typB [lindex $detB 1]
  453.     if {$typA > $typB} {
  454.         return 1
  455.     }
  456.     if {$typB > $typA} {
  457.         return -1
  458.     }
  459.     set namA [lindex $detA 0]
  460.     set namB [lindex $detB 0]
  461.     if {$namA > $namB} {
  462.         return 1
  463.     }
  464.     if {$namB > $namA} {
  465.         return -1
  466.     }
  467.     return 0
  468. }
  469.  
  470. # Do not delete this line -- regeneration end marker
  471.  
  472.