vpfconfig.java

openmap java写的开源数字地图程序. 用applet实现,可以像google map 那样放大缩小地图.

        outergridbag.setConstraints(configPanel, outerc);
        add(configPanel);
    }

    public void actionPerformed(ActionEvent ae) {
        String command = ae.getActionCommand();

        if (command == AddFeatureCmd) {

            if (currentFeature != null) {
                FeatureInfo feature = (FeatureInfo) currentFeature.getUserObject();
                // Save the current DrawingAttributes
                // settings for the feature.
                feature.drawingAttributes = (DrawingAttributes) drawingAttributes.clone();
                featureList.add(currentFeature);

                String cfl = currentFeatureList.getText();
                if (featureList.size() == 1) {
                    cfl = feature.toString();
                } else {
                    cfl += "\n" + feature.toString();
                }

                currentFeatureList.setText(cfl);

                currentFeature = null;
                createLayerButton.setEnabled(true);
                addFeatureButton.setEnabled(false);
                clearFeaturesButton.setEnabled(true);
            } else {
                Debug.error("No feature selected");
            }
        } else if (command == ClearFeaturesCmd) {
            featureList.clear();
            layerFeatures.clear();

            createLayerButton.setEnabled(false);
            addFeatureButton.setEnabled(false);
            clearFeaturesButton.setEnabled(false);
            currentFeatureList.setText(EMPTY_FEATURE_LIST);
        } else if (command == CreateLayerCmd) {
            if (featureList.size() == 0) {
                Debug.error("No features selected for new VPFLayer");
                createLayerButton.setEnabled(false);
                clearFeaturesButton.setEnabled(false);
                return;
            }

            String name = nameField.getText();
            if (name == null) {
                name = "VPFLayer";
            }

            String propertyPrefix;
            if (layer != null) {
                propertyPrefix = PropUtils.getScopedPropertyPrefix(layer);
            } else {
                propertyPrefix = PropUtils.getScopedPropertyPrefix(name.replace(' ',
                        '_')
                        .toLowerCase());
            }

            if (layer != null) {
                layerProperties = layer.getProperties(null);
            } else {
                layerProperties = new Properties();
            }

            layerCoverageTypes.clear();
            layerFeatureTypes.clear();
            layerFeatures.clear();

            if (standAlone) {
                layerProperties.put(propertyPrefix + "class",
                        "com.bbn.openmap.layer.vpf.VPFLayer");
            }

            layerProperties.put(propertyPrefix + Layer.PrettyNameProperty, name);
            layerProperties.put(propertyPrefix + VPFLayer.pathProperty, paths);
            layerProperties.put(propertyPrefix
                    + VPFLayer.searchByFeatureProperty,
                    new Boolean(searchByFeature).toString());

            // Now, build up coverageTypeProperty and
            // featureTypesProperty
            // from the linked list of featureNodes...
            Iterator it = featureList.iterator();
            while (it.hasNext()) {
                addPropertiesForFeature((DefaultMutableTreeNode) it.next(),
                        propertyPrefix,
                        layerProperties);
            }

            // coverageTypeProperty and featureTypesProperty should
            // be built from above iteration, should push them into
            // properties...
            // List the coverages
            layerProperties.put(propertyPrefix + VPFLayer.coverageTypeProperty,
                    stringTogether(layerCoverageTypes.iterator()));
            // List area/edge/point/text, whatever has been set up
            // with the chosen features.
            layerProperties.put(propertyPrefix + VPFLayer.featureTypesProperty,
                    stringTogether(layerFeatureTypes.iterator()));

            // OK, now go through the layerFeature lists for
            // area/edge/text/point and add the property listing the
            // features associated with each type.
            Enumeration keys = layerFeatures.keys();
            while (keys.hasMoreElements()) {
                String key = (String) keys.nextElement();
                HashSet featureSet = (HashSet) layerFeatures.get(key);
                layerProperties.put(propertyPrefix + key,
                        stringTogether(featureSet.iterator()));
            }

            if (layer != null) {
                layer.setConfigSettings(layer.getPropertyPrefix(),
                        layerProperties);
            } else if (layerHandler != null) {
                VPFLayer layer = new VPFLayer();
                layer.setProperties(propertyPrefix, layerProperties);
                layerHandler.addLayer(layer);
            } else {
                printProperties(layerProperties);
            }

            featureList.clear();

            currentFeatureList.setText(EMPTY_FEATURE_LIST);
            createLayerButton.setEnabled(false);
            addFeatureButton.setEnabled(false);
            clearFeaturesButton.setEnabled(false);
        }
    }

    private void addPropertiesForFeature(DefaultMutableTreeNode featureNode,
                                         String propertyPrefix,
                                         Properties layerProperties) {
        FeatureInfo feature = (FeatureInfo) featureNode.getUserObject();
        CoverageInfo coverage = (CoverageInfo) ((DefaultMutableTreeNode) featureNode.getParent()).getUserObject();

        // Adding to coverage list
        layerCoverageTypes.add(coverage.coverageName);
        // Adding area, edge, text, point to list if it doesn't exist.
        layerFeatureTypes.add(feature.featureTypeString);

        // adding feature name to appropriate edge/area/text/point
        // list
        HashSet featureSet = ((HashSet) layerFeatures.get(feature.featureTypeString));

        if (featureSet == null) {
            // If it's the first category type for the feature
            featureSet = new HashSet();
            layerFeatures.put(feature.featureTypeString, featureSet);
        }
        // Add feature to feature type list for edge/area/text/point
        featureSet.add(feature.featureName);
        feature.drawingAttributes.setPropertyPrefix(propertyPrefix
                + feature.featureName);
        feature.drawingAttributes.getProperties(layerProperties);
    }

    private void printProperties(Properties props) {
        Enumeration keys = props.propertyNames();
        System.out.println("######## START Properties ########");
        while (keys.hasMoreElements()) {
            String key = (String) keys.nextElement();
            System.out.println(key + "=" + props.getProperty(key));
        }
        System.out.println("######## END Properties ########");
    }

    private String stringTogether(Iterator it) {
        StringBuffer buf = null;

        while (it.hasNext()) {
            String val = (String) it.next();

            if (buf == null) {
                buf = new StringBuffer(val);
            } else {
                buf.append(" " + val);
            }
        }

        if (buf == null) {
            return "";
        } else {
            return buf.toString();
        }
    }

    private class FeatureInfo {
        public String featureName;
        public String featureDescription;
        public String featureTypeString;
        public int featureType;
        public CoverageTable.FeatureClassRec record;
        public DrawingAttributes drawingAttributes;

        public FeatureInfo(CoverageTable ct, CoverageTable.FeatureClassRec fcr) {
            record = fcr;

            featureTypeString = UNKNOWN;
            if (fcr.type == CoverageTable.TEXT_FEATURETYPE) {
                featureTypeString = TEXT;
            } else if (fcr.type == CoverageTable.EDGE_FEATURETYPE) {
                featureTypeString = EDGE;
            } else if (fcr.type == CoverageTable.AREA_FEATURETYPE) {
                featureTypeString = AREA;
            } else if (fcr.type == CoverageTable.UPOINT_FEATURETYPE) {
                FeatureClassInfo fci = ct.getFeatureClassInfo(fcr.feature_class);
                if (fci == null) {
                    featureTypeString = POINT;
                } else if (fci.getFeatureType() == CoverageTable.EPOINT_FEATURETYPE) {
                    featureTypeString = EPOINT;
                } else if (fci.getFeatureType() == CoverageTable.CPOINT_FEATURETYPE) {
                    featureTypeString = CPOINT;
                } else {
                    featureTypeString = POINT;
                }
            } else if (fcr.type == CoverageTable.COMPLEX_FEATURETYPE) {
                featureTypeString = COMPLEX;
            }

            featureType = fcr.type;
            featureName = fcr.feature_class;
            featureDescription = fcr.description;
        }

        public String toString() {
            return featureDescription + " (" + featureTypeString + ")";
        }
    }

    private class CoverageInfo {
        public String coverageName;
        public String coverageDescription;

        public CoverageInfo(CoverageAttributeTable cat, String covName) {
            coverageName = covName;
            coverageDescription = cat.getCoverageDescription(covName);
        }

        public String toString() {
            return coverageDescription;
        }
    }

    private boolean addFeatureNodes(DefaultMutableTreeNode coverageNode,
                                    CoverageTable ct) {
        int numFeatures = 0;
        Hashtable info = ct.getFeatureTypeInfo();
        for (Enumeration enumeration = info.elements(); enumeration.hasMoreElements();) {
            CoverageTable.FeatureClassRec fcr = (CoverageTable.FeatureClassRec) enumeration.nextElement();

            if (fcr.type == CoverageTable.SKIP_FEATURETYPE) {
                continue;
            }

            coverageNode.add(new DefaultMutableTreeNode(new FeatureInfo(ct, fcr)));
            numFeatures++;
        }
        return numFeatures > 0;
    }

    private void addCoverageNodes(DefaultMutableTreeNode libraryNode,
                                  CoverageAttributeTable cat) {
        String[] coverages = cat.getCoverageNames();
        for (int covi = 0; covi < coverages.length; covi++) {
            String coverage = coverages[covi];
            CoverageInfo covInfo = new CoverageInfo(cat, coverage);
            DefaultMutableTreeNode covNode = new DefaultMutableTreeNode(covInfo);
            if (showAll
                    || addFeatureNodes(covNode, cat.getCoverageTable(coverage))
                    || !cat.isTiledData()) {
                libraryNode.add(covNode);
            }
        }
    }

    private void createNodes(DefaultMutableTreeNode top,
                             LibrarySelectionTable lst) throws FormatException {

        DefaultMutableTreeNode category = null;

        String[] libraries = lst.getLibraryNames();
        for (int libi = 0; libi < libraries.length; libi++) {
            String library = libraries[libi];
            category = new DefaultMutableTreeNode(library);
            CoverageAttributeTable cat = lst.getCAT(library);
            top.add(category);
            addCoverageNodes(category, cat);
        }
    }

    private void createNodes(DefaultMutableTreeNode top, String[] dataPaths)
            throws FormatException {

        for (int i = 0; i < dataPaths.length; i++) {
            String rootpath = dataPaths[i];
            LibrarySelectionTable lst = new LibrarySelectionTable(rootpath);
            createNodes(top, lst);
        }
    }

    public static void createLayer(String[] vpfPaths,
                                   LayerHandler layerHandler, String layerName) {
        launchFrame(new VPFConfig(vpfPaths, layerHandler, layerName), false);
    }

    public static void createLayer(LibraryBean libraryBean,
                                   LayerHandler layerHandler, String layerName) {
        launchFrame(new VPFConfig(libraryBean, layerHandler, layerName), false);
    }

    protected static void launchFrame(JComponent content, boolean exitOnClose) {
        JFrame frame = new JFrame("Create VPF Data Layer");

        frame.getContentPane().add(content);
        if (exitOnClose) {
            frame.addWindowListener(new WindowAdapter() {
                public void windowClosing(WindowEvent e) {
                    System.exit(0);
                }
            });
        }

        frame.pack();
        frame.setVisible(true);
    }

    public static void main(String[] args) {
        if (args.length == 0) {
            System.out.println("Usage:  java com.bbn.openmap.layer.vpf.VPFConfig <path to VPF directory> <path to VPF directory> ...");
            System.exit(0);
        }

        VPFConfig vpfc = new VPFConfig(args, null, "VPF Layer", true);
        launchFrame(vpfc, true);
    }
}