Examples with IDiagramModel com.archimatetool.model.IDiagramModel used on opensource projects

Example 26 with IDiagramModel

use of com.archimatetool.model.IDiagramModel in project archi by archimatetool.

the class CopySnapshotTests method testCanPasteToDiagram.

@Test
public void testCanPasteToDiagram() throws IOException {
    loadTestModel1();
    List<IDiagramModelComponent> selected = new ArrayList<IDiagramModelComponent>();
    // Empty selection
    CopySnapshot snapshot = new CopySnapshot(selected);
    assertFalse(snapshot.canPasteToDiagram(targetDiagramModel));
    // Select some
    selected.addAll(sourceDiagramModel.getChildren());
    snapshot = new CopySnapshot(selected);
    assertTrue(snapshot.canPasteToDiagram(targetDiagramModel));
    // Different diagram model types
    IDiagramModel sketchModel = IArchimateFactory.eINSTANCE.createSketchModel();
    assertFalse(snapshot.canPasteToDiagram(sketchModel));
}

Example 27 with IDiagramModel

use of com.archimatetool.model.IDiagramModel in project archi by archimatetool.

the class ArchimateDNDEditPolicy method getDropCommand.

@Override
protected Command getDropCommand(DiagramDropRequest request) {
    if (!(request.getData() instanceof IStructuredSelection)) {
        return null;
    }
    // XY drop point
    Point pt = getDropLocation(request);
    int origin = pt.x;
    int x = pt.x;
    int y = pt.y;
    fElementsToAdd = new ArrayList<IArchimateElement>();
    fRelationsToAdd = new ArrayList<IArchimateRelationship>();
    fDiagramRefsToAdd = new ArrayList<IDiagramModel>();
    // Gather an actual list of elements dragged onto the container, omitting duplicates and anything already on the diagram
    Object[] objects = ((IStructuredSelection) request.getData()).toArray();
    getElementsToAdd(objects);
    // Store the Diagram Model Components that will be added in this list
    List<IDiagramModelArchimateComponent> diagramComponentsThatWereAdded = new ArrayList<IDiagramModelArchimateComponent>();
    // Create a Compound Command - it has to be Non-Notifying or it's too slow (tested with Bill's UoB model!)
    CompoundCommand result = new NonNotifyingCompoundCommand(Messages.ArchimateDNDEditPolicy_0);
    // Add the Commands adding the Elements first
    for (IArchimateElement element : fElementsToAdd) {
        // Add Diagram object
        IDiagramModelArchimateObject dmo = ArchimateDiagramModelFactory.createDiagramModelArchimateObject(element);
        // Set location
        dmo.getBounds().setLocation(x, y);
        // Store it
        diagramComponentsThatWereAdded.add(dmo);
        // Add Command
        result.add(new AddDiagramObjectCommand(getTargetContainer(), dmo));
        // Increase x,y
        x += 150;
        if (x > origin + 400) {
            x = origin;
            y += 100;
        }
    }
    // Then any Diagram Model Ref Commands
    for (IDiagramModel diagramModel : fDiagramRefsToAdd) {
        result.add(new AddDiagramModelReferenceCommand(getTargetContainer(), diagramModel, x, y));
        x += 150;
        if (x > origin + 400) {
            x = origin;
            y += 100;
        }
    }
    // Add selected Relations to create connections to those elements on the diagram that don't already have them
    for (IArchimateRelationship relation : fRelationsToAdd) {
        // Find existing source & target components on the diagram that the new connection will link to
        List<IDiagramModelArchimateComponent> sources = DiagramModelUtils.findDiagramModelComponentsForArchimateConcept(getTargetDiagramModel(), relation.getSource());
        List<IDiagramModelArchimateComponent> targets = DiagramModelUtils.findDiagramModelComponentsForArchimateConcept(getTargetDiagramModel(), relation.getTarget());
        for (IDiagramModelComponent dcSource : sources) {
            for (IDiagramModelComponent dcTarget : targets) {
                if (dcSource instanceof IConnectable && dcTarget instanceof IConnectable) {
                    // Add a new connection between dcSource & dcTarget if there isn't already one on the diagram
                    if (dcTarget != dcSource && !DiagramModelUtils.hasDiagramModelArchimateConnection((IConnectable) dcSource, (IConnectable) dcTarget, relation)) {
                        // Check that source or target is not a hiden connection
                        if (!((dcSource instanceof IDiagramModelArchimateConnection && DiagramModelUtils.shouldBeHiddenConnection((IDiagramModelArchimateConnection) dcSource)) || (dcTarget instanceof IDiagramModelArchimateConnection && DiagramModelUtils.shouldBeHiddenConnection((IDiagramModelArchimateConnection) dcTarget)))) {
                            AddDiagramArchimateConnectionCommand cmd = new AddDiagramArchimateConnectionCommand((IConnectable) dcSource, (IConnectable) dcTarget, relation);
                            result.add(cmd);
                            // Store it
                            diagramComponentsThatWereAdded.add(cmd.getConnection());
                        }
                    }
                }
            }
        }
    }
    // Whether to add connections to elements
    Boolean value = (Boolean) request.getExtendedData().get(ArchimateDiagramTransferDropTargetListener.ADD_ELEMENT_CONNECTIONS);
    boolean addConnectionsToElements = value != null && value.booleanValue();
    // Newly added concepts will need new connections to both existing and newly added concepts
    for (IDiagramModelArchimateComponent dmComponent : diagramComponentsThatWereAdded) {
        IArchimateConcept archimateConcept = dmComponent.getArchimateConcept();
        for (IArchimateRelationship relation : ArchimateModelUtils.getAllRelationshipsForConcept(archimateConcept)) {
            /*
                 * If the user holds down the Copy key (Ctrl on win/lnx, Alt on Mac) then linked connections
                 * are not added on drag and drop. However, any selected relations' linked objects are added.
                 */
            if (!addConnectionsToElements && !fRelationsToAdd.contains(relation)) {
                continue;
            }
            // Find existing objects
            List<IDiagramModelArchimateComponent> sources = DiagramModelUtils.findDiagramModelComponentsForArchimateConcept(getTargetDiagramModel(), relation.getSource());
            List<IDiagramModelArchimateComponent> targets = DiagramModelUtils.findDiagramModelComponentsForArchimateConcept(getTargetDiagramModel(), relation.getTarget());
            // Add new ones too
            for (IDiagramModelArchimateComponent dmComponent2 : diagramComponentsThatWereAdded) {
                if (dmComponent != dmComponent2) {
                    IArchimateConcept archimateConcept2 = dmComponent2.getArchimateConcept();
                    if (archimateConcept2 == relation.getSource()) {
                        // Only need to add sources, not targets
                        sources.add(dmComponent2);
                    }
                }
            }
            // Make the Commands...
            for (IDiagramModelComponent dcSource : sources) {
                if (dcSource instanceof IConnectable && archimateConcept == relation.getTarget()) {
                    result.add(new AddDiagramArchimateConnectionCommand((IConnectable) dcSource, (IConnectable) dmComponent, relation));
                }
            }
            for (IDiagramModelComponent dcTarget : targets) {
                if (dcTarget instanceof IConnectable && archimateConcept == relation.getSource()) {
                    result.add(new AddDiagramArchimateConnectionCommand((IConnectable) dmComponent, (IConnectable) dcTarget, relation));
                }
            }
        }
    }
    // Then, if adding to an Archimate container type to create nesting, ask whether to add new relations if none exist...
    if (ConnectionPreferences.createRelationWhenAddingModelTreeElement() && getTargetContainer() instanceof IDiagramModelArchimateObject) {
        List<IDiagramModelArchimateObject> diagramObjectsThatWereAdded = new ArrayList<IDiagramModelArchimateObject>();
        for (IDiagramModelArchimateComponent dmc : diagramComponentsThatWereAdded) {
            if (dmc instanceof IDiagramModelArchimateObject) {
                diagramObjectsThatWereAdded.add((IDiagramModelArchimateObject) dmc);
            }
        }
        Command cmd = new CreateNestedArchimateConnectionsWithDialogCommand((IDiagramModelArchimateObject) getTargetContainer(), diagramObjectsThatWereAdded);
        result.add(cmd);
    }
    // return the full compound command
    return result;
}

Example 28 with IDiagramModel

use of com.archimatetool.model.IDiagramModel in project archi by archimatetool.

the class ArchimateDiagramConnectionPolicy method getReconnectCommand.

/**
 * Create a ReconnectCommand
 */
protected Command getReconnectCommand(ReconnectRequest request, boolean isSourceCommand) {
    IDiagramModelConnection connection = (IDiagramModelConnection) request.getConnectionEditPart().getModel();
    // The re-connected object
    IConnectable newObject = (IConnectable) getHost().getModel();
    // Get the type of connection (plain) or relationship (if archimate connection) and check if it is valid
    EClass type = connection.eClass();
    if (connection instanceof IDiagramModelArchimateConnection) {
        type = ((IDiagramModelArchimateConnection) connection).getArchimateRelationship().eClass();
    }
    if (isSourceCommand) {
        if (!isValidConnection(newObject, connection.getTarget(), type)) {
            return null;
        }
    } else {
        if (!isValidConnection(connection.getSource(), newObject, type)) {
            return null;
        }
    }
    /*
         * Re-connect ArchiMate Connection to Archimate Component
         * In this case we have to check for matching occurences on all diagrams
         */
    if (connection instanceof IDiagramModelArchimateConnection && newObject instanceof IDiagramModelArchimateComponent) {
        IArchimateRelationship relationship = ((IDiagramModelArchimateConnection) connection).getArchimateRelationship();
        IArchimateConcept newConcept = ((IDiagramModelArchimateComponent) newObject).getArchimateConcept();
        // Compound Command
        CompoundCommand result = new CompoundCommand();
        // Check for matching connections in this and other diagrams
        for (IDiagramModel diagramModel : newConcept.getArchimateModel().getDiagramModels()) {
            for (IDiagramModelArchimateConnection matchingConnection : DiagramModelUtils.findDiagramModelConnectionsForRelation(diagramModel, relationship)) {
                IDiagramModelArchimateComponent matchingComponent = null;
                // Same Diagram so use the new target
                if (newObject.getDiagramModel() == diagramModel) {
                    matchingComponent = (IDiagramModelArchimateComponent) newObject;
                } else // Different Diagram so find a match
                {
                    List<IDiagramModelArchimateComponent> list = DiagramModelUtils.findDiagramModelComponentsForArchimateConcept(diagramModel, newConcept);
                    if (!list.isEmpty()) {
                        matchingComponent = list.get(0);
                    }
                }
                // Does the new object exist on the diagram? Yes, reconnect
                if (matchingComponent != null) {
                    ReconnectDiagramConnectionCommand cmd = new ReconnectDiagramConnectionCommand(matchingConnection);
                    if (isSourceCommand) {
                        cmd.setNewSource(matchingComponent);
                    } else {
                        cmd.setNewTarget(matchingComponent);
                    }
                    result.add(cmd);
                } else // No, so delete the matching connection
                {
                    result.add(DiagramCommandFactory.createDeleteDiagramConnectionCommand(matchingConnection));
                }
            }
        }
        return result.unwrap();
    } else // Re-connect other cases
    {
        ReconnectDiagramConnectionCommand cmd = new ReconnectDiagramConnectionCommand(connection);
        if (isSourceCommand) {
            cmd.setNewSource(newObject);
        } else {
            cmd.setNewTarget(newObject);
        }
        return cmd;
    }
}

Example 29 with IDiagramModel

use of com.archimatetool.model.IDiagramModel in project archi by archimatetool.

the class MyImporter method doImport.

@Override
public void doImport() throws IOException {
    File file = askOpenFile();
    if (file == null) {
        return;
    }
    // Load in the file and get its information here.
    // Assuming you load in the data in some way, perhaps with JDOM, or a SAX Parser ot text reader then you will
    // have a representation of it in memory that you need to map to Archi elements.
    // Here is some example raw data in String format. This is a very simple example so the data
    // is not in the best format. There is no error checking either.
    // Elements
    String[] elements = { // Type, Name, ID
    "BusinessActor", "Actor", "elementID1", "BusinessRole", "Client", "elementID2", "BusinessFunction", "My Function", "elementID3" };
    // Relationships
    String[] relations = { // Type, Name, ID, sourceID, targetID
    "AssignmentRelationship", "Assigned to", "relID1", "elementID1", "elementID2", "UsedByRelationship", "", "relID2", "elementID1", "elementID3", "AssociationRelationship", "", "relID3", "elementID2", "elementID3" };
    // Views
    String[] views = { // Name, ID
    "A View", "view1", "Another View", "view2" };
    // View elements
    String[] viewElements = { // ID of parent View, ID of referenced element, x, y, width, height
    "view1", "elementID1", "10", "10", "-1", "-1", "view1", "elementID2", "310", "10", "-1", "-1", "view1", "elementID3", "310", "110", "-1", "-1", "view2", "elementID2", "10", "10", "-1", "-1", "view2", "elementID3", "10", "110", "-1", "-1" };
    // View connections
    String[] viewConnections = { // ID of parent View, ID of relationship
    "view1", "relID1", "view1", "relID2", "view2", "relID3" };
    // Create the model...
    // Create a new Archimate Model and set its defaults
    IArchimateModel model = IArchimateFactory.eINSTANCE.createArchimateModel();
    model.setDefaults();
    model.setName("My Model");
    // Create and add elements matching imported data
    // If an ID is not provided for an element then a unique ID will be generated when the model element is added to a parent
    // model element, otherwise you can use your own IDs provided in the input data.
    // Let's use an ID -> EObject mapping table for convenience
    idLookup = new HashMap<String, EObject>();
    // Create and add model elements
    for (int i = 0; i < elements.length; ) {
        String type = elements[i++];
        String name = elements[i++];
        String id = elements[i++];
        createAndAddArchimateElement(model, (EClass) IArchimatePackage.eINSTANCE.getEClassifier(type), name, id);
    }
    // Create and add model relationships and set source and target elements
    for (int i = 0; i < relations.length; ) {
        String type = relations[i++];
        String name = relations[i++];
        String id = relations[i++];
        String sourceID = relations[i++];
        String targetID = relations[i++];
        IArchimateRelationship relationship = createAndAddArchimateRelationship(model, (EClass) IArchimatePackage.eINSTANCE.getEClassifier(type), name, id);
        // Find source and target elements from their IDs in the lookup table
        IArchimateElement source = (IArchimateElement) idLookup.get(sourceID);
        IArchimateElement target = (IArchimateElement) idLookup.get(targetID);
        relationship.setSource(source);
        relationship.setTarget(target);
    }
    // Create and add diagram views
    for (int i = 0; i < views.length; ) {
        String name = views[i++];
        String id = views[i++];
        createAndAddView(model, name, id);
    }
    // Add diagram elements to views
    for (int i = 0; i < viewElements.length; ) {
        String viewID = viewElements[i++];
        String refID = viewElements[i++];
        int x = Integer.parseInt(viewElements[i++]);
        int y = Integer.parseInt(viewElements[i++]);
        int width = Integer.parseInt(viewElements[i++]);
        int height = Integer.parseInt(viewElements[i++]);
        IDiagramModel diagramModel = (IDiagramModel) idLookup.get(viewID);
        IArchimateElement element = (IArchimateElement) idLookup.get(refID);
        createAndAddElementToView(diagramModel, element, x, y, width, height);
    }
    // Add diagram connections to views
    for (int i = 0; i < viewConnections.length; ) {
        String viewID = viewConnections[i++];
        String relationshipID = viewConnections[i++];
        IDiagramModel diagramModel = (IDiagramModel) idLookup.get(viewID);
        IArchimateRelationship relationship = (IArchimateRelationship) idLookup.get(relationshipID);
        createAndAddConnectionsToView(diagramModel, relationship);
    }
    // And open the Model in the Editor
    IEditorModelManager.INSTANCE.openModel(model);
}

Example 30 with IDiagramModel

use of com.archimatetool.model.IDiagramModel in project archi by archimatetool.

the class SaveArchimateModelAsTemplateWizard method createZipFile.

private void createZipFile(File zipFile) throws IOException {
    ZipOutputStream zOut = null;
    try {
        // Delete any existing zip first
        zipFile.delete();
        // Start a zip stream
        BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(zipFile));
        zOut = new ZipOutputStream(out);
        // Add Manifest
        String manifest = createManifest();
        ZipUtils.addStringToZip(manifest, TemplateManager.ZIP_ENTRY_MANIFEST, zOut);
        // Add any thumbnails
        if (fIncludeThumbnails) {
            int i = 1;
            for (IDiagramModel dm : fModel.getDiagramModels()) {
                Image image = TemplateUtils.createThumbnailImage(dm);
                // $NON-NLS-1$
                ZipUtils.addImageToZip(image, TemplateManager.ZIP_ENTRY_THUMBNAILS + i++ + ".png", zOut, SWT.IMAGE_PNG, null);
                image.dispose();
            }
        }
        /*
             * Save model to xml temp file and add to Zip.
             * Do this last because we need to dispose the Archive Manager last because its images are re-used
             * several times to create thumbnails.
             */
        File tempFile = saveModelToTempFile();
        ZipUtils.addFileToZip(tempFile, TemplateManager.ZIP_ENTRY_MODEL, zOut);
        tempFile.delete();
    } finally {
        if (zOut != null) {
            try {
                zOut.flush();
                zOut.close();
            } catch (IOException ex) {
            }
        }
    }
}