Examples with Node ini.trakem2.display.Node used on opensource projects

Example 31 with Node

use of ini.trakem2.display.Node in project TrakEM2 by trakem2.

the class LayerTree method getPopupMenu.

/**
 * Get a custom, context-sensitive popup menu for the selected node.
 */
private JPopupMenu getPopupMenu(DefaultMutableTreeNode node) {
    Object ob = node.getUserObject();
    LayerThing thing = null;
    if (ob instanceof LayerThing) {
        thing = (LayerThing) ob;
    } else {
        return null;
    }
    // context-sensitive popup
    JMenuItem[] item = thing.getPopupItems(this);
    if (0 == item.length)
        return null;
    JPopupMenu popup = new JPopupMenu();
    for (int i = 0; i < item.length; i++) {
        if (null == item[i] || "" == item[i].getText())
            popup.addSeparator();
        else
            popup.add(item[i]);
    }
    return popup;
}

Example 32 with Node

use of ini.trakem2.display.Node in project TrakEM2 by trakem2.

the class LayerTree method addLayer.

/**
 * Used by the Loader.importStack and the "many new layers" command.
 */
public void addLayer(LayerSet layer_set, Layer layer) {
    if (null == layer_set || null == layer)
        return;
    try {
        // find the node that contains the LayerSet
        DefaultMutableTreeNode root_node = (DefaultMutableTreeNode) this.getModel().getRoot();
        LayerThing root_lt = (LayerThing) root_node.getUserObject();
        Thing thing = null;
        if (root_lt.getObject().equals(layer_set))
            thing = root_lt;
        else
            thing = root_lt.findChild(layer_set);
        DefaultMutableTreeNode parent_node = DNDTree.findNode(thing, this);
        if (null == parent_node) {
            Utils.log("LayerTree: LayerSet not found.");
            return;
        }
        LayerThing parent_thing = (LayerThing) parent_node.getUserObject();
        double z = layer.getZ();
        // find the node whose 'z' is larger than z, and add the Layer before that.
        int n = parent_node.getChildCount();
        int i = 0;
        for (; i < n; i++) {
            DefaultMutableTreeNode child_node = (DefaultMutableTreeNode) parent_node.getChildAt(i);
            LayerThing child_thing = (LayerThing) child_node.getUserObject();
            if (!child_thing.getType().equals("layer")) {
                continue;
            }
            double iz = ((Layer) child_thing.getObject()).getZ();
            if (iz < z) {
                continue;
            }
            // else, add the layer here, after the 'i' layer which has a larger z
            break;
        }
        TemplateThing tt = parent_thing.getChildTemplate("layer");
        if (null == tt) {
            Utils.log("LayerTree: Null template Thing!");
            return;
        }
        LayerThing new_thing = new LayerThing(tt, layer.getProject(), layer);
        // Add the new_thing to the tree
        if (null != new_thing) {
            parent_thing.addChild(new_thing);
            DefaultMutableTreeNode new_node = new DefaultMutableTreeNode(new_thing);
            // TODO when changing the Z of a layer, the insertion is proper but an empty space is left //Utils.log("LayerTree: inserting at: " + i);
            ((DefaultTreeModel) this.getModel()).insertNodeInto(new_node, parent_node, i);
            TreePath treePath = new TreePath(new_node.getPath());
            this.scrollPathToVisible(treePath);
            this.setSelectionPath(treePath);
        }
    } catch (Exception e) {
        IJError.print(e);
    }
}

Example 33 with Node

use of ini.trakem2.display.Node in project TrakEM2 by trakem2.

the class LayerTree method mousePressed.

public void mousePressed(MouseEvent me) {
    Object source = me.getSource();
    if (!source.equals(this) || !project.isInputEnabled()) {
        return;
    }
    // ignore if doing multiple selection
    if (!Utils.isPopupTrigger(me) && (me.isShiftDown() || (!ij.IJ.isMacOSX() && me.isControlDown()))) {
        return;
    }
    int x = me.getX();
    int y = me.getY();
    // check if there is a multiple selection
    TreePath[] paths = this.getSelectionPaths();
    if (null != paths && paths.length > 1) {
        if (Utils.isPopupTrigger(me)) {
            // check that all items are of the same type
            String type_first = ((LayerThing) ((DefaultMutableTreeNode) paths[0].getLastPathComponent()).getUserObject()).getType();
            for (int i = 1; i < paths.length; i++) {
                String type = ((LayerThing) ((DefaultMutableTreeNode) paths[i].getLastPathComponent()).getUserObject()).getType();
                if (!type.equals(type_first)) {
                    Utils.showMessage("All selected items must be of the same type for operations on multiple items.");
                    return;
                }
            }
            // prepare popup menu
            JPopupMenu popup = new JPopupMenu();
            JMenuItem item = null;
            if (type_first.equals("layer")) {
                item = new JMenuItem("Reverse layer Z coords");
                item.addActionListener(this);
                popup.add(item);
                item = new JMenuItem("Translate layers in Z...");
                item.addActionListener(this);
                popup.add(item);
                item = new JMenuItem("Scale Z and thickness...");
                item.addActionListener(this);
                popup.add(item);
                item = new JMenuItem("Delete...");
                item.addActionListener(this);
                popup.add(item);
            }
            if (popup.getSubElements().length > 0) {
                popup.show(this, x, y);
            }
        }
        // disable commands depending upon a single node being selected
        selected_node = null;
        return;
    }
    // find the node and set it selected
    TreePath path = getPathForLocation(x, y);
    if (null == path) {
        return;
    }
    setSelectionPath(path);
    selected_node = (DefaultMutableTreeNode) path.getLastPathComponent();
    if (2 == me.getClickCount() && !Utils.isPopupTrigger(me) && MouseEvent.BUTTON1 == me.getButton()) {
        // create a new Display
        LayerThing thing = (LayerThing) selected_node.getUserObject();
        DBObject ob = (DBObject) thing.getObject();
        if (thing.getType().toLowerCase().replace('_', ' ').equals("layer set") && null == ((LayerSet) ob).getParent()) {
            // the top level LayerSet
            return;
        }
        // new Display(ob.getProject(), thing.getType().toLowerCase().equals("layer") ? (Layer)ob : ((LayerSet)ob).getParent());
        Display.createDisplay(ob.getProject(), thing.getType().toLowerCase().equals("layer") ? (Layer) ob : ((LayerSet) ob).getParent());
        return;
    } else if (Utils.isPopupTrigger(me)) {
        JPopupMenu popup = getPopupMenu(selected_node);
        if (null == popup)
            return;
        popup.show(this, x, y);
        return;
    }
}

Example 34 with Node

use of ini.trakem2.display.Node in project TrakEM2 by trakem2.

the class LayerTree method actionPerformed.

public void actionPerformed(ActionEvent ae) {
    try {
        String command = ae.getActionCommand();
        // commands for multiple selections:
        TreePath[] paths = this.getSelectionPaths();
        if (null != paths && paths.length > 1) {
            if (command.equals("Reverse layer Z coords")) {
                // check that all layers belong to the same layer set
                // just do it
                Layer[] layer = new Layer[paths.length];
                LayerSet ls = null;
                for (int i = 0; i < paths.length; i++) {
                    layer[i] = (Layer) ((LayerThing) ((DefaultMutableTreeNode) paths[i].getLastPathComponent()).getUserObject()).getObject();
                    if (null == ls)
                        ls = layer[i].getParent();
                    else if (!ls.equals(layer[i].getParent())) {
                        Utils.showMessage("To reverse, all layers must belong to the same layer set");
                        return;
                    }
                }
                final ArrayList<Layer> al = new ArrayList<Layer>();
                for (int i = 0; i < layer.length; i++) al.add(layer[i]);
                ls.addLayerEditedStep(al);
                // ASSSUMING layers are already Z ordered! CHECK
                for (int i = 0, j = layer.length - 1; i < layer.length / 2; i++, j--) {
                    double z = layer[i].getZ();
                    layer[i].setZ(layer[j].getZ());
                    layer[j].setZ(z);
                }
                updateList(ls);
                ls.addLayerEditedStep(al);
                Display.updateLayerScroller(ls);
            } else if (command.equals("Translate layers in Z...")) {
                GenericDialog gd = ControlWindow.makeGenericDialog("Range");
                gd.addMessage("Translate selected range in the Z axis:");
                gd.addNumericField("by: ", 0, 4);
                gd.showDialog();
                if (gd.wasCanceled())
                    return;
                // else, displace
                double dz = gd.getNextNumber();
                if (Double.isNaN(dz)) {
                    Utils.showMessage("Invalid number");
                    return;
                }
                HashSet<LayerSet> hs_parents = new HashSet<LayerSet>();
                for (int i = 0; i < paths.length; i++) {
                    Layer layer = (Layer) ((LayerThing) ((DefaultMutableTreeNode) paths[i].getLastPathComponent()).getUserObject()).getObject();
                    layer.setZ(layer.getZ() + dz);
                    hs_parents.add(layer.getParent());
                }
                for (LayerSet ls : hs_parents) {
                    updateList(ls);
                }
                // now update all profile's Z ordering in the ProjectTree
                ProjectThing root_pt = project.getRootProjectThing();
                for (final ProjectThing pt : root_pt.findChildrenOfType("profile_list")) {
                    pt.fixZOrdering();
                    project.getProjectTree().updateList(pt);
                }
                project.getProjectTree().updateUILater();
            // Display.updateLayerScroller((LayerSet)((DefaultMutableTreeNode)getModel().getRoot()).getUserObject());
            } else if (command.equals("Delete...")) {
                if (!Utils.check("Really remove all selected layers?"))
                    return;
                for (int i = 0; i < paths.length; i++) {
                    DefaultMutableTreeNode lnode = (DefaultMutableTreeNode) paths[i].getLastPathComponent();
                    LayerThing lt = (LayerThing) lnode.getUserObject();
                    Layer layer = (Layer) lt.getObject();
                    if (!layer.remove(false)) {
                        Utils.showMessage("Could not delete layer " + layer);
                        this.updateUILater();
                        return;
                    }
                    if (lt.remove(false)) {
                        ((DefaultTreeModel) this.getModel()).removeNodeFromParent(lnode);
                    }
                }
                this.updateUILater();
            } else if (command.equals("Scale Z and thickness...")) {
                GenericDialog gd = new GenericDialog("Scale Z");
                gd.addNumericField("scale: ", 1.0, 2);
                gd.showDialog();
                double scale = gd.getNextNumber();
                if (Double.isNaN(scale) || 0 == scale) {
                    Utils.showMessage("Imvalid scaling factor: " + scale);
                    return;
                }
                for (int i = 0; i < paths.length; i++) {
                    DefaultMutableTreeNode lnode = (DefaultMutableTreeNode) paths[i].getLastPathComponent();
                    LayerThing lt = (LayerThing) lnode.getUserObject();
                    Layer layer = (Layer) lt.getObject();
                    layer.setZ(layer.getZ() * scale);
                    layer.setThickness(layer.getThickness() * scale);
                }
                this.updateUILater();
            } else {
                Utils.showMessage("Don't know what to do with command " + command + " for multiple selected nodes");
            }
            return;
        }
        // commands for single selection:
        if (null == selected_node)
            return;
        LayerThing thing = (LayerThing) selected_node.getUserObject();
        LayerThing new_thing = null;
        TemplateThing tt = null;
        Object ob = null;
        int i_position = -1;
        if (command.startsWith("new ")) {
            String name = command.substring(4).toLowerCase();
            if (name.equals("layer")) {
                // Create new Layer and add it to the selected node
                LayerSet set = (LayerSet) thing.getObject();
                Layer new_layer = Layer.create(thing.getProject(), set);
                if (null == new_layer)
                    return;
                tt = thing.getChildTemplate("layer");
                ob = new_layer;
                Display.updateTitle(set);
            } else if (name.equals("layer set")) {
                // with space in the middle
                // Create a new LayerSet and add it in the middle
                Layer layer = (Layer) thing.getObject();
                LayerSet new_set = layer.getParent().create(layer);
                if (null == new_set)
                    return;
                layer.add(new_set);
                // add it at the end of the list
                // with space, not underscore
                tt = thing.getChildTemplate("layer set");
                ob = new_set;
                i_position = selected_node.getChildCount();
                Display.update(layer);
            } else {
                Utils.log("LayerTree.actionPerformed: don't know what to do with the command: " + command);
                return;
            }
        } else if (command.equals("many new layers...")) {
            LayerSet set = (LayerSet) thing.getObject();
            List<Layer> layers = Layer.createMany(set.getProject(), set);
            // add them to the tree as LayerThing
            if (null == layers)
                return;
            for (Layer la : layers) {
                // null layers will be skipped
                addLayer(set, la);
            }
            Display.updateTitle(set);
            return;
        } else if (command.equals("Show")) {
            // create a new Display
            DBObject dbo = (DBObject) thing.getObject();
            // the top level LayerSet
            if (thing.getType().equals("layer_set") && null == ((LayerSet) dbo).getParent())
                return;
            Display.createDisplay(dbo.getProject(), thing.getType().equals("layer") ? (Layer) dbo : ((LayerSet) dbo).getParent());
            return;
        } else if (command.equals("Show centered in Display")) {
            LayerSet ls = (LayerSet) thing.getObject();
            Display.showCentered(ls.getParent(), ls, false, false);
        } else if (command.equals("Delete...")) {
            remove(true, thing, selected_node);
            return;
        } else if (command.equals("Import stack...")) {
            if (thing.getObject() instanceof LayerSet) {
                LayerSet set = (LayerSet) thing.getObject();
                Layer layer = null;
                if (0 == set.getLayers().size()) {
                    layer = Layer.create(set.getProject(), set);
                    if (null == layer)
                        return;
                    tt = thing.getChildTemplate("Layer");
                    ob = layer;
                } else
                    // click on a desired, existing layer.
                    return;
                layer.getProject().getLoader().importStack(layer, null, true);
            } else if (thing.getObject() instanceof Layer) {
                Layer layer = (Layer) thing.getObject();
                layer.getProject().getLoader().importStack(layer, null, true);
                return;
            }
        } else if (command.equals("Import grid...")) {
            if (thing.getObject() instanceof Layer) {
                Layer layer = (Layer) thing.getObject();
                layer.getProject().getLoader().importGrid(layer);
            }
        } else if (command.equals("Import sequence as grid...")) {
            if (thing.getObject() instanceof Layer) {
                Layer layer = (Layer) thing.getObject();
                layer.getProject().getLoader().importSequenceAsGrid(layer);
            }
        } else if (command.equals("Import from text file...")) {
            if (thing.getObject() instanceof Layer) {
                Layer layer = (Layer) thing.getObject();
                layer.getProject().getLoader().importImages(layer);
            }
        } else if (command.equals("Resize LayerSet...")) {
            if (thing.getObject() instanceof LayerSet) {
                LayerSet ls = (LayerSet) thing.getObject();
                ij.gui.GenericDialog gd = ControlWindow.makeGenericDialog("Resize LayerSet");
                gd.addNumericField("new width: ", ls.getLayerWidth(), 3);
                gd.addNumericField("new height: ", ls.getLayerHeight(), 3);
                gd.addChoice("Anchor: ", LayerSet.ANCHORS, LayerSet.ANCHORS[0]);
                gd.showDialog();
                if (gd.wasCanceled())
                    return;
                float new_width = (float) gd.getNextNumber(), new_height = (float) gd.getNextNumber();
                // will complain and prevent cropping existing Displayable objects
                ls.setDimensions(new_width, new_height, gd.getNextChoiceIndex());
            }
        } else if (command.equals("Autoresize LayerSet")) {
            if (thing.getObject() instanceof LayerSet) {
                LayerSet ls = (LayerSet) thing.getObject();
                ls.setMinimumDimensions();
            }
        } else if (command.equals("Adjust...")) {
            if (thing.getObject() instanceof Layer) {
                Layer layer = (Layer) thing.getObject();
                ij.gui.GenericDialog gd = ControlWindow.makeGenericDialog("Adjust Layer");
                gd.addNumericField("new z: ", layer.getZ(), 4);
                gd.addNumericField("new thickness: ", layer.getThickness(), 4);
                gd.showDialog();
                if (gd.wasCanceled())
                    return;
                double new_z = gd.getNextNumber();
                layer.setThickness(gd.getNextNumber());
                if (new_z != layer.getZ()) {
                    layer.setZ(new_z);
                    // move in the tree
                    /*
						DefaultMutableTreeNode child = findNode(thing, this);
						DefaultMutableTreeNode parent = (DefaultMutableTreeNode)child.getParent();
						parent.remove(child);
						// reinsert
						int n = parent.getChildCount();
						int i = 0;
						for (; i < n; i++) {
							DefaultMutableTreeNode child_node = (DefaultMutableTreeNode)parent.getChildAt(i);
							LayerThing child_thing = (LayerThing)child_node.getUserObject();
							if (!child_thing.getType().equals("Layer")) continue;
							double iz = ((Layer)child_thing.getObject()).getZ();
							if (iz < new_z) continue;
							// else, add the layer here, after this one
							break;
						}
						((DefaultTreeModel)this.getModel()).insertNodeInto(child, parent, i);
						*/
                    // fix tree crappiness (empty slot ?!?)
                    /* // the fix doesn't work. ARGH TODO
						Enumeration e = parent.children();
						parent.removeAllChildren();
						i = 0;
						while (e.hasMoreElements()) {
							//parent.add((DefaultMutableTreeNode)e.nextElement());
							((DefaultTreeModel)this.getModel()).insertNodeInto(child, parent, i);
							i++;
						}*/
                    // easier and correct: overkill
                    updateList(layer.getParent());
                    // set selected
                    DefaultMutableTreeNode child = findNode(thing, this);
                    TreePath treePath = new TreePath(child.getPath());
                    this.scrollPathToVisible(treePath);
                    this.setSelectionPath(treePath);
                }
            }
            return;
        } else if (command.equals("Rename...")) {
            GenericDialog gd = ControlWindow.makeGenericDialog("Rename");
            gd.addStringField("new name: ", thing.getTitle());
            gd.showDialog();
            if (gd.wasCanceled())
                return;
            project.getRootLayerSet().addUndoStep(new RenameThingStep(thing));
            thing.setTitle(gd.getNextString());
            project.getRootLayerSet().addUndoStep(new RenameThingStep(thing));
        } else if (command.equals("Translate layers in Z...")) {
            // / TODO: this method should use multiple selections directly on the tree
            if (thing.getObject() instanceof LayerSet) {
                LayerSet ls = (LayerSet) thing.getObject();
                ArrayList<Layer> al_layers = ls.getLayers();
                String[] layer_names = new String[al_layers.size()];
                for (int i = 0; i < layer_names.length; i++) {
                    layer_names[i] = ls.getProject().findLayerThing(al_layers.get(i)).toString();
                }
                GenericDialog gd = ControlWindow.makeGenericDialog("Range");
                gd.addMessage("Translate selected range in the Z axis:");
                gd.addChoice("from: ", layer_names, layer_names[0]);
                gd.addChoice("to: ", layer_names, layer_names[layer_names.length - 1]);
                gd.addNumericField("by: ", 0, 4);
                gd.showDialog();
                if (gd.wasCanceled())
                    return;
                // else, displace
                double dz = gd.getNextNumber();
                if (Double.isNaN(dz)) {
                    Utils.showMessage("Invalid number");
                    return;
                }
                int i_start = gd.getNextChoiceIndex();
                int i_end = gd.getNextChoiceIndex();
                for (int i = i_start; i <= i_end; i++) {
                    Layer layer = (Layer) al_layers.get(i);
                    layer.setZ(layer.getZ() + dz);
                }
                // update node labels and position
                updateList(ls);
            }
        } else if (command.equals("Reverse layer Z coords...")) {
            // / TODO: this method should use multiple selections directly on the tree
            if (thing.getObject() instanceof LayerSet) {
                LayerSet ls = (LayerSet) thing.getObject();
                ArrayList<Layer> al_layers = ls.getLayers();
                String[] layer_names = new String[al_layers.size()];
                for (int i = 0; i < layer_names.length; i++) {
                    layer_names[i] = ls.getProject().findLayerThing(al_layers.get(i)).toString();
                }
                GenericDialog gd = ControlWindow.makeGenericDialog("Range");
                gd.addMessage("Reverse Z coordinates of selected range:");
                gd.addChoice("from: ", layer_names, layer_names[0]);
                gd.addChoice("to: ", layer_names, layer_names[layer_names.length - 1]);
                gd.showDialog();
                if (gd.wasCanceled())
                    return;
                int i_start = gd.getNextChoiceIndex();
                int i_end = gd.getNextChoiceIndex();
                for (int i = i_start, j = i_end; i < i_end / 2; i++, j--) {
                    Layer layer1 = (Layer) al_layers.get(i);
                    double z1 = layer1.getZ();
                    Layer layer2 = (Layer) al_layers.get(j);
                    layer1.setZ(layer2.getZ());
                    layer2.setZ(z1);
                }
                // update node labels and position
                updateList(ls);
            }
        } else if (command.equals("Search...")) {
            Search.showWindow();
        } else if (command.equals("Reset layer Z and thickness")) {
            LayerSet ls = ((LayerSet) thing.getObject());
            List<Layer> layers = ls.getLayers();
            ls.addLayerEditedStep(layers);
            int i = 0;
            for (final Layer la : ls.getLayers()) {
                la.setZ(i++);
                la.setThickness(1);
            }
            ls.addLayerEditedStep(layers);
        } else {
            Utils.log("LayerTree.actionPerformed: don't know what to do with the command: " + command);
            return;
        }
        if (null == tt)
            return;
        new_thing = new LayerThing(tt, thing.getProject(), ob);
        if (-1 == i_position && new_thing.getType().equals("layer")) {
            // find the node whose 'z' is larger than z, and add the Layer before that.
            // (just because there could be objects other than LayerThing with a Layer in it in the future, so set.getLayers().indexOf(layer) may not be useful)
            double z = ((Layer) ob).getZ();
            int n = selected_node.getChildCount();
            int i = 0;
            for (; i < n; i++) {
                DefaultMutableTreeNode child_node = (DefaultMutableTreeNode) selected_node.getChildAt(i);
                LayerThing child_thing = (LayerThing) child_node.getUserObject();
                if (!child_thing.getType().equals("layer")) {
                    continue;
                }
                double iz = ((Layer) child_thing.getObject()).getZ();
                if (iz < z) {
                    continue;
                }
                // else, add the layer here, after this one
                break;
            }
            i_position = i;
        }
        thing.addChild(new_thing);
        DefaultMutableTreeNode new_node = new DefaultMutableTreeNode(new_thing);
        ((DefaultTreeModel) this.getModel()).insertNodeInto(new_node, selected_node, i_position);
        TreePath treePath = new TreePath(new_node.getPath());
        this.scrollPathToVisible(treePath);
        this.setSelectionPath(treePath);
        if (new_thing.getType().equals("layer set")) {
            // add the first layer to it, and open it in a Display
            LayerSet newls = (LayerSet) new_thing.getObject();
            Layer la = new Layer(newls.getProject(), 0, 1, newls);
            addLayer(newls, la);
            new Display(newls.getProject(), la);
        }
    } catch (Exception e) {
        IJError.print(e);
    }
}

Example 35 with Node

use of ini.trakem2.display.Node in project TrakEM2 by trakem2.

the class ProjectTree method insertSegmentations.

/* // makes no sense, because there may be multiple projects open and thus the viewport and position may interfere with each other across multiple projects. Saving the collapsed node state suffices.
	public void exportXML(final StringBuffer sb_body, String indent, JScrollPane jsp) {
		Point p = jsp.getViewport().getViewPosition();
		Dimension d = jsp.getSize(null);
		sb_body.append(indent).append("<t2_tree")
		       .append(" width=\"").append(d.width).append('\"')
		       .append(" height=\"").append(d.height).append('\"')
		       .append(" viewport_x=\"").append(p.e).append('\"')
		       .append(" viewport_y=\"").append(p.y).append('\"')
		;
		sb_body.append("\n").append(indent).append("</t2_tree>\n");
	}
	*/
/**
 * Creates a new node of basic type for each AreaList, Ball, Pipe or Polyline present in the ArrayList. Other elements are ignored.
 */
public void insertSegmentations(final Collection<? extends Displayable> al) {
    final TemplateThing tt_root = (TemplateThing) project.getTemplateTree().getRoot().getUserObject();
    // create a new abstract node called "imported_segmentations", if not there
    final String imported_labels = "imported_labels";
    if (!project.typeExists(imported_labels)) {
        // create it
        // yes I know I should check for the project of each Displayable in the ArrayList
        TemplateThing tet = new TemplateThing(imported_labels, project);
        project.addUniqueType(tet);
        DefaultMutableTreeNode root = project.getTemplateTree().getRoot();
        tt_root.addChild(tet);
        DefaultMutableTreeNode child_node = addChild(tet, root);
        DNDTree.expandNode(project.getTemplateTree(), child_node);
    // JTree is serious pain
    }
    // it's the same as 'tet' above, unless it existed
    TemplateThing tt_is = project.getTemplateThing(imported_labels);
    // create a project node from "imported_segmentations" template under a new top node
    final DefaultMutableTreeNode project_node = project.getProjectTree().getRoot();
    ProjectThing project_pt = (ProjectThing) project_node.getUserObject();
    final ProjectThing ct = project_pt.createChild(tt_root.getType());
    ProjectThing pt_is = ct.createChild(imported_labels);
    // addChild(pt_is, ctn);
    final DefaultMutableTreeNode node_pt_is = new DefaultMutableTreeNode(pt_is);
    final HashMap<Class<?>, String> types = new HashMap<Class<?>, String>();
    types.put(AreaList.class, "area_list");
    types.put(Pipe.class, "pipe");
    types.put(Polyline.class, "polyline");
    types.put(Ball.class, "ball");
    types.put(Treeline.class, "treeline");
    types.put(AreaTree.class, "areatree");
    types.put(Connector.class, "connector");
    // now, insert a new ProjectThing if of type AreaList, Ball and/or Pipe under node_child
    for (final Displayable d : al) {
        final String type = types.get(d.getClass());
        if (null == type) {
            Utils.log("insertSegmentations: ignoring " + d);
            continue;
        }
        try {
            final TemplateThing tt = getOrCreateChildTemplateThing(tt_is, type);
            ProjectThing one = new ProjectThing(tt, project, d);
            pt_is.addChild(one);
            // addChild(one, node_pt_is);
            // at the end
            node_pt_is.add(new DefaultMutableTreeNode(one));
        // Utils.log2("one parent : " + one.getParent());
        } catch (Exception e) {
            IJError.print(e);
        }
    }
    javax.swing.SwingUtilities.invokeLater(new Runnable() {

        public void run() {
            DefaultMutableTreeNode ctn = addChild(ct, project_node);
            ctn.add(node_pt_is);
            try {
                ProjectTree.this.scrollPathToVisible(new TreePath(node_pt_is.getPath()));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    });
    DNDTree.expandNode(this, node_pt_is);
}