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);    }}