OpenMap Tutorial 5 – 3-tier GIS application

Finally, we need to create a new layer that will display our suppliers on the map, and declare it inside openmap.properties in order to add it to the map. If you followed the previous tutorials, it should be easy by now how to do it. Let’s build SupplierLayer.java step-by-step:

Listing 9 – SupplierLayer.java

package openmap.controller;
public class SupplierLayer extends OMGraphicHandlerLayer {

    private static final String LOOKUP_OBJECT = "Lookup Object";

    public SupplierLayer() {
        // This is how to set the ProjectionChangePolicy, which
        // dictates how the layer behaves when a new projection is
        // received.
        setProjectionChangePolicy(new StandardPCPolicy(this, true));
        setRenderPolicy(new BufferedImageRenderPolicy());
        // Making the setting so this layer receives events from the
        // SelectMouseMode, which has a modeID of "Gestures". Other
        // IDs can be added as needed.
        setMouseModeIDsForEvents(new String[]{"Gestures"});
    }

    /**
     * Called from the prepare() method if the layer discovers that its
     * OMGraphicList is {@code null}.
     *
     * @return new {@code OMGraphicList} with {@code OMGraphics{ that you always
     * want to display and reproject as necessary.
     */
    public OMGraphicList init() {
        final IDBManager dbManager = Lookup.getDefault().lookup(IDBManager.class);
        final List suppliers = dbManager.getSuppliers();
        // This layer keeps a pointer to an OMGraphicList that it uses
        // for painting. It's initially set to null, which is used as
        // a flag in prepare() to signal that the OMGraphcs need to be
        // created. The list returned from prepare() gets set in the
        // layer.
        // This layer uses the StandardPCPolicy for new
        // projections, which keeps the list intact and simply calls
        // generate() on it with the new projection, and repaint()
        // which calls paint().
        OMGraphicList omList = new OMGraphicList();

        // Add suppliers as OMPoints.
        for (Supplier supplier : suppliers) {
            OMPoint omSupplier = new OMPoint(supplier.getLatitude(),
                    supplier.getLongitude(), 3);  // radius
            omSupplier.putAttribute(OMGraphicConstants.LABEL,
                       new OMTextLabeler(supplier.getName(), OMText.JUSTIFY_LEFT));
            omSupplier.putAttribute(LOOKUP_OBJECT, supplier);
            omSupplier.setLinePaint(Color.BLUE);
            omSupplier.setSelectPaint(Color.ORANGE);
            omSupplier.setOval(true);
            omList.add(omSupplier);
        }

        return omList;
    }

    /**
     * This is an important Layer method to override. The prepare method gets
     * called when the layer is added to the map, or when the map projection
     * changes. We need to make sure the OMGraphicList returned from this method
     * is what we want painted on the map. The OMGraphics need to be generated
     * with the current projection. We test for a null OMGraphicList in the
     * layer to see if we need to create the OMGraphics. This layer doesn't
     * change it's OMGraphics for different projections, if your layer does, you
     * need to clear out the OMGraphicList and add the OMGraphics you want for
     * the current projection.
     *
     * @return
     */
    @Override
    public synchronized OMGraphicList prepare() {
        OMGraphicList list = getList();

        // Here's a test to see if it's the first time that the layer has been
        // added to the map. This list object will be whatever was returned from
        // this method the last time prepare() was called. In this
        // example, we always return an OMGraphicList object, so if it's null,
        // prepare() must not have been called yet.
        if (list == null) {
            list = init();
        }

        /*
         * This call to the list is critical! OMGraphics need to be told where
         * to paint themselves, and they figure that out when they are given the
         * current Projection in the generate(Projection) call. If an
         * OMGraphic's location is changed, it will need to be regenerated
         * before it is rendered, otherwise it won't draw itself. You generally
         * know you have a generate problem when OMGraphics show up with the
         * projection changes (zooms and pans), but not at any other time after
         * something about the OMGraphic changes.
         *
         * If you want to be more efficient, you can replace this call to the
         * list as an else clause to the (list == null) check above, and call
         * generate(Projection) on all the OMGraphics in the init() method below
         * as you create them. This will prevent the
         * OMGraphicList.generate(Projection) call from making an additional
         * loop through all of the OMGraphics before they are returned.
         */
        list.generate(getProjection());

        return list;
    }

    /**
     * Query that an OMGraphic can be highlighted when the mouse moves over it.
     * If the answer is true, then highlight with this OMGraphics will be
     * called.
     *
     * @param omg
     * @return
     */
    @Override
    public boolean isHighlightable(OMGraphic omg) {
        return true;
    }

    /**
     * Query that an OMGraphic is selectable. Examples of handing selection are
     * in the EditingLayer. The default OMGraphicHandlerLayer behavior is to add
     * the OMGraphic to an OMGraphicList called selectedList. If you aren't
     * going to be doing anything in particular with the selection, then return
     * false here to reduce the workload of the layer.
     *
     * @param omg
     * @return
     * @see com.bbn.openmap.layer.OMGraphicHandlerLayer#select
     * @see com.bbn.openmap.layer.OMGraphicHandlerLayer#deselect
     */
    @Override
    public boolean isSelectable(OMGraphic omg) {
        return true;
    }

    /**
     * Query for what tooltip to display for an OMGraphic
     * the mouse is over.
     *
     * @param omg
     * @return
     */
    @Override
    public String getToolTipTextFor(OMGraphic omg) {
        String ttText = null;
        if (omg instanceof OMPoint) {
            OMPoint point = ((OMPoint) omg);
            Object attribute = point.getAttribute(OMGraphicConstants.LABEL);
            if (attribute != null && attribute instanceof OMTextLabeler) {
                OMTextLabeler labeler = (OMTextLabeler) attribute;
                ttText = labeler.getData();
            }
        }
        return ttText;
    }

    @Override
    public Component getGUI() {
        JPanel panel = PaletteHelper.createPaletteJPanel("Suppliers Layer");
        JCheckBox chkShowLabels = new JCheckBox("Show/Hide Labels", true);
        chkShowLabels.addItemListener((ItemEvent e) -> {
            OMGraphicList omSuppliers = getList();
            for (OMGraphic omSupplier : omSuppliers) {
                if (chkShowLabels.isSelected()) {
                    omSupplier.putAttribute(OMGraphicConstants.LABEL,
                            new OMTextLabeler(
                            ((Supplier) omSupplier.getAttribute(LOOKUP_OBJECT)).getName(),
                                    OMText.JUSTIFY_LEFT));
                } else {
                    omSupplier.removeAttribute(OMGraphicConstants.LABEL);
                }
            }
            repaint();
        });
        panel.add(chkShowLabels);
        return panel;
    }
}