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

Example 11 with Display

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

the class TMLHandler method getProjectData.

/**
 * returns 4 objects packed in an array:
 *	 <pre>
 *	 [0] = root TemplateThing
 *	 [1] = root ProjectThing (contains Project instance)
 *	 [2] = root LayerThing (contains the top-level LayerSet)
 *	 [3] = expanded states of all ProjectThing objects
 *	 </pre>
 * <p>
 * Also, triggers the reconstruction of links and assignment of Displayable objects to their layer.
 * </p>
 */
public Object[] getProjectData(final boolean open_displays) {
    if (null == project)
        return null;
    this.open_displays = open_displays;
    // Links exist between Displayable objects.
    for (final Displayable d : ht_displayables.values()) {
        String olinks = ht_links.get(d);
        // not linked
        if (null == olinks)
            continue;
        String[] links = olinks.split(",");
        Long lid = null;
        for (int i = 0; i < links.length; i++) {
            try {
                lid = new Long(links[i]);
            } catch (NumberFormatException nfe) {
                Utils.log2("Ignoring incorrectly formated link '" + links[i] + "' for ob " + d);
                continue;
            }
            Displayable partner = ht_displayables.get(lid);
            if (null != partner)
                d.link(partner, false);
            else
                Utils.log("TMLHandler: can't find partner with id=" + links[i] + " for Displayable with id=" + d.getId());
        }
    }
    // 1.2 - Reconstruct linked properties
    for (final Map.Entry<Displayable, Map<Long, Map<String, String>>> lpe : all_linked_props.entrySet()) {
        final Displayable origin = lpe.getKey();
        for (final Map.Entry<Long, Map<String, String>> e : lpe.getValue().entrySet()) {
            final Displayable target = ht_displayables.get(e.getKey());
            if (null == target) {
                Utils.log("Setting linked properties for origin " + origin.getId() + ":\n\t* Could not find target displayable #" + e.getKey());
                continue;
            }
            origin.setLinkedProperties(target, e.getValue());
        }
    }
    // 2 - Add Displayable objects to ProjectThing that can contain them
    for (final Map.Entry<Long, ProjectThing> entry : ht_oid_pt.entrySet()) {
        ProjectThing pt = entry.getValue();
        Object od = ht_displayables.remove(entry.getKey());
        // Utils.log("==== processing: Displayable [" + od + "]  vs. ProjectThing [" + pt + "]");
        if (null != od) {
            pt.setObject(od);
        } else {
            Utils.log("#### Failed to find a Displayable for ProjectThing " + pt + " #####");
        }
    }
    // 3 - Assign a layer pointer to ZDisplayable objects
    for (final ZDisplayable zd : ht_zdispl.values()) {
        // zd.setLayer((Layer)zd.getLayerSet().getLayers().get(0));
        zd.setLayer(zd.getLayerSet().getLayer(0));
    }
    // 4 - Assign layers to Treeline nodes
    for (final Layer la : al_layers) {
        final List<Node<?>> list = node_layer_table.remove(la.getId());
        if (null == list)
            continue;
        for (final Node<?> nd : list) nd.setLayer(la);
    }
    if (!node_layer_table.isEmpty()) {
        Utils.log("ERROR: node_layer_table is not empty!");
    }
    // 5 - Assign root nodes to Treelines, now that all nodes have a layer
    for (final Map.Entry<Tree<?>, Node<?>> e : tree_root_nodes.entrySet()) {
        if (null == e.getValue()) {
            // Utils.log2("Ignoring, applies to new Treeline format only.");
            continue;
        }
        // Can't compile with <?>
        // will generate node caches of each Treeline
        e.getKey().setRoot((Node) e.getValue());
    }
    tree_root_nodes.clear();
    // Assign colors to nodes
    for (final Map.Entry<Color, Collection<Node<?>>> e : node_colors.entrySet()) {
        for (final Node<?> nd : e.getValue()) {
            nd.setColor(e.getKey());
        }
    }
    node_colors.clear();
    // 6 - Run legacy operations
    for (final Runnable r : legacy) {
        r.run();
    }
    try {
        // Create a table with all layer ids vs layer instances:
        final HashMap<Long, Layer> ht_lids = new HashMap<Long, Layer>();
        for (final Layer layer : al_layers) {
            ht_lids.put(new Long(layer.getId()), layer);
        }
        // Spawn threads to recreate buckets, starting from the subset of displays to open
        int n = Runtime.getRuntime().availableProcessors();
        switch(n) {
            case 1:
                break;
            case 2:
            case 3:
            case 4:
                n--;
                break;
            default:
                n -= 2;
                break;
        }
        final ExecutorService exec = Utils.newFixedThreadPool(n, "TMLHandler-recreateBuckets");
        final Set<Long> dlids = new HashSet<Long>();
        final LayerSet layer_set = (LayerSet) root_lt.getObject();
        final List<Future<?>> fus = new ArrayList<Future<?>>();
        final List<Future<?>> fus2 = new ArrayList<Future<?>>();
        for (final HashMap<String, String> ht_attributes : al_displays) {
            String ob = ht_attributes.get("layer_id");
            if (null == ob)
                continue;
            final Long lid = new Long(ob);
            dlids.add(lid);
            final Layer la = ht_lids.get(lid);
            if (null == la) {
                ht_lids.remove(lid);
                continue;
            }
            // to open later:
            new Display(project, Long.parseLong(ht_attributes.get("id")), la, ht_attributes);
            fus.add(exec.submit(new Runnable() {

                public void run() {
                    la.recreateBuckets();
                }
            }));
        }
        fus.add(exec.submit(new Runnable() {

            public void run() {
                // only for ZDisplayable
                layer_set.recreateBuckets(false);
            }
        }));
        // Ensure launching:
        if (dlids.isEmpty() && layer_set.size() > 0) {
            dlids.add(layer_set.getLayer(0).getId());
        }
        final List<Layer> layers = layer_set.getLayers();
        for (final Long lid : new HashSet<Long>(dlids)) {
            fus.add(exec.submit(new Runnable() {

                public void run() {
                    int start = layer_set.indexOf(layer_set.getLayer(lid.longValue()));
                    int next = start + 1;
                    int prev = start - 1;
                    while (next < layer_set.size() || prev > -1) {
                        if (prev > -1) {
                            final Layer lprev = layers.get(prev);
                            synchronized (dlids) {
                                if (dlids.add(lprev.getId())) {
                                    // returns true if not there already
                                    fus2.add(exec.submit(new Runnable() {

                                        public void run() {
                                            lprev.recreateBuckets();
                                        }
                                    }));
                                }
                            }
                            prev--;
                        }
                        if (next < layers.size()) {
                            final Layer lnext = layers.get(next);
                            synchronized (dlids) {
                                if (dlids.add(lnext.getId())) {
                                    // returns true if not there already
                                    fus2.add(exec.submit(new Runnable() {

                                        public void run() {
                                            lnext.recreateBuckets();
                                        }
                                    }));
                                }
                            }
                            next++;
                        }
                    }
                    Utils.log2("done recreateBuckets chunk");
                }
            }));
        }
        Utils.wait(fus);
        exec.submit(new Runnable() {

            public void run() {
                Utils.log2("waiting for TMLHandler fus...");
                Utils.wait(fus2);
                Utils.log2("done waiting TMLHandler fus.");
                exec.shutdown();
            }
        });
    } catch (Throwable t) {
        IJError.print(t);
    }
    return new Object[] { root_tt, root_pt, root_lt, ht_pt_expanded };
}

Example 12 with Display

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

the class ProjectThing method createChild.

public ProjectThing createChild(String type) {
    // create the Displayable
    TemplateThing tt = template.getChildTemplate(type);
    if (null == tt) {
        Utils.log2("Can't create a child of type " + type);
        return null;
    }
    Object ob = project.makeObject(tt);
    Layer layer = null;
    if (ob instanceof Displayable) {
        // which layer to add it to? Get it from the front Display
        layer = Display.getFrontLayer(this.project);
        if (null == layer) {
            Utils.showMessage("Open a display first!");
            ((DBObject) ob).removeFromDatabase();
            return null;
        }
    }
    // wrap it in a new ProjectThing
    ProjectThing pt = null;
    try {
        pt = new ProjectThing(tt, project, ob);
    } catch (Exception e) {
        IJError.print(e);
        return null;
    }
    // add it here as child
    addChild(pt);
    // finally, add it to the layer if appropriate
    if (null != layer) {
        if (ob instanceof ZDisplayable) {
            layer.getParent().add((ZDisplayable) ob);
        } else {
            layer.add((Displayable) ob);
        }
    }
    // finally, return it to be added to the ProjectTree as a new node
    return pt;
}

Example 13 with Display

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

the class ProjectThing method createClonedChild.

/**
 * At the moment only for basic types, which by definition have no children.
 */
public ProjectThing createClonedChild(final ProjectThing child) {
    // must be a child and a basic type
    if (null == child || null == child.object || null == al_children || !al_children.contains(child) || !Project.isBasicType(child.getType())) {
        return null;
    }
    final Displayable displ = (Displayable) ((Displayable) child.object).clone();
    ProjectThing pt = null;
    try {
        pt = new ProjectThing(child.template, project, displ);
        addChild(pt);
        // add to the proper container
        if (displ instanceof ZDisplayable) {
            ZDisplayable original = (ZDisplayable) child.object;
            original.getLayerSet().add((ZDisplayable) displ);
            Display.repaint(original.getLayerSet(), (ZDisplayable) displ, 5);
        } else {
            Displayable original = (Displayable) child.object;
            original.getLayer().add(displ);
            Display.repaint(original.getLayer(), displ, 5);
        }
        // user-friendly copy:
        displ.setLocked(false);
        displ.setVisible(true);
        // set the copy as selected in the front Display, if any
        if (null != Display.getFront())
            Display.getFront().select(displ);
    } catch (Exception e) {
        IJError.print(e);
        return null;
    }
    return pt;
}

Example 14 with Display

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

the class ProjectTree method mousePressed.

public void mousePressed(final MouseEvent me) {
    super.dispatcher.execSwing(new Runnable() {

        public void run() {
            if (!me.getSource().equals(ProjectTree.this) || !project.isInputEnabled()) {
                return;
            }
            final int x = me.getX();
            final int y = me.getY();
            // find the node and set it selected
            final TreePath path = getPathForLocation(x, y);
            if (null == path) {
                return;
            }
            ProjectTree.this.setSelectionPath(path);
            selected_node = (DefaultMutableTreeNode) path.getLastPathComponent();
            if (2 == me.getClickCount() && !me.isPopupTrigger() && MouseEvent.BUTTON1 == me.getButton()) {
                // show in the front Display
                if (null == selected_node)
                    return;
                Object obt = selected_node.getUserObject();
                if (!(obt instanceof ProjectThing))
                    return;
                ProjectThing thing = (ProjectThing) obt;
                thing.setVisible(true);
                Object obd = thing.getObject();
                if (obd instanceof Displayable) {
                    // additionaly, get the front Display (or make a new one if none) and show in it the layer in which the Displayable object is contained.
                    Displayable displ = (Displayable) obd;
                    Display.showCentered(displ.getLayer(), displ, true, me.isShiftDown());
                }
                return;
            } else if (me.isPopupTrigger() || (ij.IJ.isMacOSX() && me.isControlDown()) || MouseEvent.BUTTON2 == me.getButton() || 0 != (me.getModifiers() & Event.META_MASK)) {
                // the last block is from ij.gui.ImageCanvas, aparently to make the right-click work on windows?
                JPopupMenu popup = getPopupMenu(selected_node);
                if (null == popup)
                    return;
                popup.show(ProjectTree.this, x, y);
                return;
            }
        }
    });
}

Example 15 with Display

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

the class Merger method createTable.

private static JTable createTable(final HashSet<ZDisplayable> hs, final String column_title, final Project p1, final Project p2) {
    final TwoColumnModel tcm = new TwoColumnModel(hs, column_title);
    final JTable table = new JTable(tcm);
    table.setDefaultRenderer(table.getColumnClass(0), new DefaultTableCellRenderer() {

        private static final long serialVersionUID = 1L;

        @Override
        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
            final Component c = super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
            if (1 == column && tcm.sent[row]) {
                c.setBackground(Color.green);
                c.setForeground(Color.white);
            } else if (isSelected) {
                c.setForeground(table.getSelectionForeground());
                c.setBackground(table.getSelectionBackground());
            } else {
                c.setBackground(Color.white);
                c.setForeground(Color.black);
            }
            return c;
        }
    });
    table.addMouseListener(new MouseAdapter() {

        @Override
        public void mousePressed(MouseEvent me) {
            final JTable src = (JTable) me.getSource();
            final TwoColumnModel model = (TwoColumnModel) src.getModel();
            final int row = src.rowAtPoint(me.getPoint()), col = src.columnAtPoint(me.getPoint());
            if (2 == me.getClickCount()) {
                Object ob = model.getValueAt(row, col);
                if (ob instanceof ZDisplayable) {
                    ZDisplayable zd = (ZDisplayable) ob;
                    Display df = Display.getOrCreateFront(zd.getProject());
                    // also select
                    df.show(zd.getFirstLayer(), zd, true, false);
                }
            } else if (me.isPopupTrigger()) {
                JPopupMenu popup = new JPopupMenu();
                final JMenuItem send = new JMenuItem("Send selection");
                popup.add(send);
                send.addActionListener(new ActionListener() {

                    @Override
                    public void actionPerformed(ActionEvent ae) {
                        ArrayList<ZDisplayable> col = new ArrayList<ZDisplayable>();
                        for (final int i : src.getSelectedRows()) {
                            col.add((ZDisplayable) model.getValueAt(i, 0));
                        }
                        if (col.isEmpty())
                            return;
                        // the other
                        Project target = col.get(0).getProject() == p1 ? p2 : p1;
                        LayerSet ls = target.getRootLayerSet();
                        ArrayList<ZDisplayable> copies = new ArrayList<ZDisplayable>();
                        for (ZDisplayable zd : col) {
                            copies.add((ZDisplayable) zd.clone(target, false));
                            model.sent[row] = true;
                        }
                        // 1. To the LayerSet:
                        ls.addAll(copies);
                        // 2. To the ProjectTree:
                        target.getProjectTree().insertSegmentations(copies);
                        // Update:
                        model.fireTableDataChanged();
                    }
                });
                popup.show(table, me.getX(), me.getY());
            }
        }
    });
    return table;
}