newclassdiagram.java

UML设计测试工具

        if ( assoc.associationEnds().size() == 2 ) {
            // associationclass
            if ( assoc instanceof MAssociationClass ) {
                NodeEdge e = 
                    new NodeEdge( label, fClassToNodeMap.get( cls1 ),
                                  fClassToNodeMap.get( cls2),
                                  assocEnd1, assocEnd2, assoc,
                                  (NodeBase) fClassToNodeMap.get( assoc ),
                                  this, assoc );
                synchronized (fLock) {
                    fGraph.addEdge(e);
                    fAssocClassToEdgeMap.put( assoc, e );
                    fLayouter = null;
                }
            } else {
                // binary association
                BinaryEdge e = 
                    new BinaryEdge( label, fClassToNodeMap.get(cls1), 
                                    fClassToNodeMap.get(cls2), 
                                    assocEnd1, assocEnd2, 
                                    this, assoc );
                synchronized ( fLock ) {
                    fGraph.addEdge(e);
                    fBinaryAssocToEdgeMap.put(assoc, e);
                    fLayouter = null;
                }
            }

        } else
            synchronized (fLock) {
                // Find a random new position. getWidth and getheight return 0
                // if we are called on a new diagram.
                double fNextNodeX = Math.random() * Math.max(100, getWidth());
                double fNextNodeY = Math.random() * Math.max(100, getHeight());
                
                // n-ary association: create a diamond node and n edges to classes
                DiamondNode node = new DiamondNode( assoc, fOpt );
                node.setPosition( fNextNodeX, fNextNodeY );
                fGraph.add(node);
                // connected to an associationclass
                if ( assoc instanceof MAssociationClass ) {
                    NodeEdge e = 
                        new NodeEdge( label, fClassToNodeMap.get( cls1 ), 
                                      fClassToNodeMap.get( cls2 ),
                                      assocEnd1, assocEnd2, node, 
                                      (NodeBase) fClassToNodeMap.get( assoc ),
                                      this, assoc );
                    synchronized (fLock) {
                        fGraph.addEdge(e);
                        fAssocClassToEdgeMap.put( assoc, e );
                        fLayouter = null;
                    }
                }
                // connected to a "normal" class
                fNaryAssocToDiamondNodeMap.put( assoc, node );
                List halfEdges = new ArrayList();
                assocEndIter = assoc.associationEnds().iterator();
                while ( assocEndIter.hasNext() ) {
                    MAssociationEnd assocEnd = (MAssociationEnd) assocEndIter.next();
                    MClass cls = assocEnd.cls();
                    HalfEdge e = 
                        new HalfEdge(node, (NodeBase) fClassToNodeMap.get( cls ),
                                     assocEnd.name(), 
                                     assocEnd.multiplicity().toString(), 
                                     this, assoc );
                    fGraph.addEdge(e);
                    halfEdges.add( e );
                }
                node.setHalfEdges( halfEdges );
                fNaryAssocToHalfEdgeMap.put( assoc, halfEdges );
                fLayouter = null;
            }
    }
    
    /**
     * Removes an association from the diagram.
     */
    public void deleteAssociation( MAssociation assoc ) {
        if ( assoc.associationEnds().size() == 2 ) {
            EdgeBase e = null;
            if ( assoc instanceof MAssociationClass ) { 
                e = (NodeEdge) fAssocClassToEdgeMap.get( assoc );
                if (e == null) {
                    return;
                }
            } else {
                e = (BinaryEdge) fBinaryAssocToEdgeMap.get( assoc );
            }

            if ( e != null && !( assoc instanceof MAssociationClass )
                 && fHiddenEdges.contains( assoc ) ) {
                fHiddenEdges.remove( assoc );
                fLog.println("Deleted association `" + assoc.name() 
                             + "' from hidden associations.");
            }
            if (e == null) {
                throw new RuntimeException( "no edge for association `" 
                                            + assoc.name()
                                            + "' in current state." );
            }

            synchronized (fLock) {
                fGraph.removeEdge( e );
                if ( assoc instanceof MAssociationClass ) {
                    fAssocClassToEdgeMap.remove( assoc );
                } else {
                    fBinaryAssocToEdgeMap.remove( assoc );
                }
                fLayouter = null;
            }
        } else {
            DiamondNode n = (DiamondNode) fNaryAssocToDiamondNodeMap.get( assoc );
            if ( n == null ) {
                if ( fHiddenEdges.contains( assoc ) ) {
                    fHiddenEdges.remove( assoc );
                    fLog.println( "Deleted association `" + assoc.name()
                                  + "' from hidden associations." );
                } else {
                    throw new RuntimeException(
                            "no diamond node for n-ary association `" 
                            + assoc.name() + "' in current state.");
                }
            }

            synchronized ( fLock ) {
                // all dangling HalfLinkEdges are removed by the graph
                fGraph.remove( n );
                fNaryAssocToDiamondNodeMap.remove( assoc );
                fNaryAssocToHalfEdgeMap.remove( assoc );
                fLayouter = null;
            }

            synchronized ( fLock ) {
                if ( assoc instanceof MAssociationClass ) {
                    NodeEdge edge = 
                        (NodeEdge) fAssocClassToEdgeMap.get( assoc );
                    if ( edge != null ) {
                        fGraph.removeEdge( edge );
                        fAssocClassToEdgeMap.remove( assoc );
                    }
                }
            }
        }
    }
    
    /**
     * Adds a generalization to the diagram.
     */
    public void addGeneralization( MGeneralization gen ) {
        MClass parent = gen.parent();
        MClass child = gen.child();
        GeneralizationEdge e = 
            new GeneralizationEdge( fClassToNodeMap.get( child ),
                                    fClassToNodeMap.get( parent ), this );
        synchronized ( fLock ) {
            fGraph.addEdge( e );
            fGenToGeneralizationEdge.put( gen, e );
            fLayouter = null;
        }
    }

    /**
     * Deletes a generalization from the diagram.
     */
    public void deleteGeneralization( MGeneralization gen ) {
        EdgeBase e = (GeneralizationEdge) fGenToGeneralizationEdge.get( gen );
        if ( e == null ) {
            if ( fHiddenEdges.contains( gen ) ) {
                fHiddenEdges.remove( gen );
                fLog.println("Deleted generalization `" + gen.name()
                             + "' from the hidden associaitons.");
            } else {
                throw new RuntimeException("no edge for generalization `" 
                                           + gen.name() + "' in current state.");
            }
        }

        synchronized ( fLock ) {
            fGraph.remove( e );
            fGenToGeneralizationEdge.remove( gen );
            fLayouter = null;
        }
    }
    
    /**
     * Creates and shows popup menu if mouse event is the trigger for popups.
     */
    public boolean maybeShowPopup( MouseEvent e ) {
        boolean separatorNeeded = false;
        
        if ( !e.isPopupTrigger() )
            return false;

        // create the popup menu
        JPopupMenu popupMenu = unionOfPopUpMenu();
        
        // position for the popupMenu items 
        int pos = 0;
        
        if ( !fNodeSelection.isEmpty() ) {
            HashSet selectedClasses = new HashSet();
            Iterator nodeIterator = fNodeSelection.iterator();
            while ( nodeIterator.hasNext() ) {
                PlaceableNode node = (PlaceableNode) nodeIterator.next();
                if ( node instanceof ClassNode && node.isDeletable() ) {
                    selectedClasses.add( ((ClassNode) node).cls() );
                } else if ( node instanceof EnumNode && node.isDeletable() ) {
                    selectedClasses.add( ((EnumNode) node).getEnum() );
                }
            }
            
            String txt = null;
            if ( selectedClasses.size() == 1 ) {
                if ( selectedClasses.iterator().next() instanceof MClass ) {
                    txt = "'" + ((MClass) selectedClasses.iterator().next()).name() + "'";
                } else if ( selectedClasses.iterator().next() instanceof EnumType ) {
                    txt = "'" + ((EnumType) selectedClasses.iterator().next()).name() + "'";
                }
            } else if ( selectedClasses.size() > 1 ) {
                txt = selectedClasses.size() + " classes";
            }
            if ( txt != null && txt.length() > 0 ) {
                popupMenu.insert( fHideAdmin.setValues( "Hide " + txt,
                                                        selectedClasses ),
                                                        pos++ );
                popupMenu.insert( fHideAdmin.setValues( "Crop " + txt,
                                                        getNoneSelectedNodes( selectedClasses ) ),
                                                        pos++ );
                separatorNeeded = true;
            }
        }
        
        if ( !fHiddenNodes.isEmpty() ) {
            final JMenuItem showAllClasses = new JMenuItem( "Show hidden classes" );
            showAllClasses.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent ev) {
                    fHideAdmin.showAllHiddenElements();
                    repaint();
                }
            });

            popupMenu.insert( showAllClasses, pos++ );
            separatorNeeded = true;
        }

        if ( separatorNeeded ) {
            popupMenu.insert( new JSeparator(), pos++ );
            separatorNeeded = false;
        }
        
        // setting the right position for the popupMenu items 
        // from this point on.
        pos = pos + 3;
        
        final JCheckBoxMenuItem cbMultiplicities = 
            new JCheckBoxMenuItem( "Show multiplicities" );
        cbMultiplicities.setState( fOpt.isShowMutliplicities() );
        cbMultiplicities.addItemListener( new ItemListener() {
            public void itemStateChanged( ItemEvent ev ) {
                fOpt.setShowMutliplicities( ev.getStateChange() 
                                            == ItemEvent.SELECTED );
                repaint();
            }
        } );
//        final JCheckBoxMenuItem cbAttributes =
//            new JCheckBoxMenuItem("Show attributes" );
//        cbAttributes.setState( fOpt.isShowAttributes() );
//        cbAttributes.addItemListener( new ItemListener() {
//            public void itemStateChanged( ItemEvent ev ) {
//                fOpt
//                    .setShowAttributes( ev.getStateChange() == ItemEvent.SELECTED );
//                repaint();
//            }
//        } );
        final JCheckBoxMenuItem cbOperations =
            new JCheckBoxMenuItem("Show operations" );
        cbOperations.setState( fOpt.isShowOperations() );
        cbOperations.addItemListener( new ItemListener() {
            public void itemStateChanged( ItemEvent ev ) {
                fOpt
                    .setShowOperations( ev.getStateChange() == ItemEvent.SELECTED );
                repaint();
            }
        } );

        popupMenu.insert( cbMultiplicities, pos++-1 );
//        popupMenu.insert( cbAttributes, pos++ );
        popupMenu.insert( cbOperations, pos++ );
        
        popupMenu.show( e.getComponent(), e.getX(), e.getY() );
        return true;
    }

    /**
     * Finds all nodes which are not selected.
     * @param selectedNodes Nodes which are selected at this point in the diagram.
     * @return A HashSet of the none selected objects in the diagram.
     */
    private Set getNoneSelectedNodes( Set selectedNodes ) {
        Set noneSelectedNodes = new HashSet();
        
        Iterator it = fGraph.iterator();
        while ( it.hasNext() ) {
            Object o = it.next();
            if ( o instanceof ClassNode ) {
                MClass cls = ((ClassNode) o).cls();
                if ( !selectedNodes.contains( cls ) ) {
                    noneSelectedNodes.add( cls );
                }    
            }
        }
        return noneSelectedNodes;
    }

    /**
     * Deletes all hidden elements form this diagram.
     */
    public void deleteHiddenElementsFromDiagram( Set nodesToHide, 
                                                 Set edgesToHide ) {
        Iterator it = nodesToHide.iterator();
        while ( it.hasNext() ) {
            Object elem = it.next();
            if ( elem instanceof MClass ) {
                deleteClass( (MClass) elem );
            } else if ( elem instanceof EnumType ) {
                deleteEnum( (EnumType) elem );
            }
        }
        
        it = edgesToHide.iterator();
        while ( it.hasNext() ) {
            MModelElement edge = (MModelElement) it.next();
            if ( edge instanceof MAssociation ) {
                deleteAssociation( (MAssociation) edge );
            } else if ( edge instanceof MGeneralization ) {
                deleteGeneralization( (MGeneralization) edge );
            }
        }
        
        fHiddenNodes.addAll( nodesToHide );
        fHiddenEdges.addAll( edgesToHide );
    }
}