propertyhandler.java

来自「OpenMap是一个基于JavaBeansTM的开发工具包。利用OpenMap你」· Java 代码 · 共 1,648 行 · 第 1/5 页

        if (ps != null) {
            ps.println("\n### OpenMap Layers ###");
            ps.println(layerMarkerString.toString());
            ps.println(startUpLayerMarkerString.toString());
            ps.println(layerPropertiesString.toString());
        }

        if (createdProperties != null) {
            createdProperties.put(layerMarkerStringKey,
                    layerMarkerString.substring(layerMarkerStringKey.length() + 1));
            createdProperties.put(startUpLayerMarkerStringKey,
                    startUpLayerMarkerString.substring(startUpLayerMarkerStringKey.length() + 1));
        }
    }

    /**
     * Given a MapHandler and a Java Properties object, the LayerHandler will be
     * cleared of it's current layers, and reloaded with the layers in the
     * properties. The MapBean will be set to the projection settings listed in
     * the properties.
     */
    public void loadProjectionAndLayers(MapHandler mapHandler, Properties props) {

        MapBean mapBean = (MapBean) mapHandler.get("com.bbn.openmap.MapBean");
        LayerHandler layerHandler = (LayerHandler) mapHandler.get("com.bbn.openmap.LayerHandler");
        // InformationDelegator id = (InformationDelegator)
        // mapHandler.get("com.bbn.openmap.InformationDelegator");

        // if (id != null) {
        // id.requestCursor(new Cursor(Cursor.WAIT_CURSOR));
        // }

        if (layerHandler != null) {
            layerHandler.removeAll();
            layerHandler.init(Environment.OpenMapPrefix, props);
        } else {
            Debug.error("Can't load new layers - can't find LayerHandler");
        }

        if (mapBean != null) {
            mapBean.setProjection(ProjectionFactory.getDefaultProjectionFromEnvironment(mapBean.getWidth(),
                    mapBean.getHeight()));
        } else {
            Debug.error("Can't load new projection - can't find MapBean");
        }

        // if (id != null) {
        // id.requestCursor(null);
        // }
    }

    /**
     * If you are creating a new object, it's important to get a unique prefix
     * for its properties. This function takes a prefix string and checks it
     * against all others it knows about. If there is a conflict, it adds a
     * number to the end until it becomes unique. This prefix will be logged by
     * the PropertyHandler as a name given out, so duplicate instances of that
     * string will not be given out later. It doesn't, however, log that name in
     * the prefixLibrarian. That only occurs when the object is programmatically
     * registered with the prefixLibrarian or when the PropertyHandler finds
     * that object in the MapHandler (and even then that object must be a
     * PropertyConsumer to be registered this way).
     */
    public String getUniquePrefix(String prefix) {
        prefix = prefix.replace(' ', '_');

        if (!addUsedPrefix(prefix)) {
            int count = 2;
            String nextTry = prefix + (count);
            while (!addUsedPrefix(nextTry)) {
                nextTry = prefix + (++count);
            }
            return nextTry;
        } else {
            return prefix;
        }
    }

    /**
     * Changes ' ' characters to '_', and then tries to add it to the used
     * prefix list. Returns true if successful.
     */
    public boolean addUsedPrefix(String prefix) {
        prefix = prefix.replace(' ', '_');

        return usedPrefixes.add(prefix.intern());
    }

    /**
     * Changes ' ' characters to '_', and then tries to remove it to the used
     * prefix list. Returns true if successful.
     */
    public boolean removeUsedPrefix(String prefix) {
        prefix = prefix.replace(' ', '_');

        return usedPrefixes.remove(prefix.intern());
    }

    /**
     * Add a ProgressListener that will display build progress.
     */
    public void addProgressListener(ProgressListener list) {
        getProgressSupport().addProgressListener(list);
    }

    /**
     * Remove a ProgressListener that displayed build progress.
     */
    public void removeProgressListener(ProgressListener list) {
        getProgressSupport().removeProgressListener(list);
    }

    /**
     * Clear all progress listeners.
     */
    public void clearProgressListeners() {
        getProgressSupport().removeAll();
    }

    /**
     * Get progress support if needed.
     */
    protected ProgressSupport getProgressSupport() {
        if (progressSupport == null) {
            progressSupport = new ProgressSupport(this);
        }
        return progressSupport;
    }

    /**
     * Fire an build update to progress listeners.
     * 
     * @param frameNumber the current frame count
     * @param totalFrames the total number of frames.
     */
    protected void fireProgressUpdate(int type, String task, int frameNumber,
                                      int totalFrames) {
        if (updateProgress) {
            getProgressSupport().fireUpdate(type,
                    task,
                    totalFrames,
                    frameNumber);
        } else if (type == ProgressEvent.DONE) {
            // At least turn off progress listeners if they are up.
            getProgressSupport().fireUpdate(ProgressEvent.DONE,
                    task,
                    totalFrames,
                    frameNumber);
        }
    }

    /**
     * Set a flag that will trigger the PropertyHandler to fire progress events
     * when it is going through the creation process.
     */
    public void setUpdateProgress(boolean set) {
        updateProgress = set;
    }

    public boolean getUpdateProgress() {
        return updateProgress;
    }

    // Property Functions:
    // ///////////////////

    /**
     * Remove an existing property if it exists.
     * 
     * @return true if a property was actually removed.
     */
    public boolean removeProperty(String property) {
        return getProperties().remove(property) != null;
    }

    /**
     * Add (or overwrite) a property to the current properties
     */
    public void addProperty(String property, String value) {
        getProperties().setProperty(property, value);
    }

    /**
     * Add in the properties from the given URL. Any existing properties will be
     * overwritten except for openmap.components, openmap.layers and
     * openmap.startUpLayers which will be appended.
     */
    public void addProperties(URL urlToProperties) {
        addProperties(fetchProperties(urlToProperties));
    }

    /**
     * Add in the properties from the given source, which can be a resorce, file
     * or URL. Any existing properties will be overwritten except for
     * openmap.components, openmap.layers and openmap.startUpLayers which will
     * be appended.
     * 
     * @throws MalformedURLException if propFile doesn't resolve properly.
     */
    public void addProperties(String propFile) throws MalformedURLException {
        addProperties(fetchProperties(PropUtils.getResourceOrFileOrURL(propFile)));
    }

    /**
     * Add in the properties from the given Properties object. Any existing
     * properties will be overwritten except for openmap.components,
     * openmap.layers and openmap.startUpLayers where values will be prepended
     * to any existing lists.
     */
    public void addProperties(Properties p) {
        String[] specialProps = new String[] {
                Environment.OpenMapPrefix + "." + LayerHandler.layersProperty,
                Environment.OpenMapPrefix + "."
                        + LayerHandler.startUpLayersProperty, componentProperty };

        Properties tmp = new Properties();
        tmp.putAll(p);

        for (int i = 0; i < specialProps.length; i++) {
            prependProperty(specialProps[i], tmp);
            tmp.remove(specialProps[i]);
        }

        getProperties().putAll(tmp);
    }

    /**
     * remove a marker from a space delimated set of properties.
     */
    public void removeMarker(String property, String marker) {
        // Requires jdk 1.4
        // StringBuffer sb =
        // new StringBuffer(getProperties().getProperty(property,
        // ""));
        // int idx = sb.indexOf(marker);

        // jdk 1.3 version
        String propertyString = getProperties().getProperty(property, "");
        int idx = propertyString.indexOf(marker);
        if (idx != -1) {
            StringBuffer sb = new StringBuffer(propertyString);
            sb.delete(idx, idx + marker.length());
            getProperties().setProperty(property, sb.toString());
        }
    }

    /**
     * Append the given property into the current properties
     */
    public void appendProperty(String property, Properties src) {
        appendProperty(property, src.getProperty(property, ""));
    }

    /**
     * Append the given property into the current properties
     */
    public void appendProperty(String property, String value) {
        String curVal = getProperties().getProperty(property, "");
        getProperties().setProperty(property, curVal + " " + value);
    }

    /**
     * Prepend the given property into the current properties
     */
    public void prependProperty(String property, Properties src) {
        prependProperty(property, src.getProperty(property, ""));
    }

    /**
     * Prepend the given property into the current properties
     */
    public void prependProperty(String property, String value) {
        String curVal = getProperties().getProperty(property, "");
        getProperties().setProperty(property, value + " " + curVal);
    }

    /**
     * Load a Properties object from the classpath. The method always returns a
     * <code>Properties</code> object. If there was an error loading the
     * properties from <code>propsURL</code>, an empty
     * <code>Properties</code> object is returned.
     * 
     * @param propsURL the URL of the properties to be loaded
     * @return the loaded properties, or an empty Properties object if there was
     *         an error.
     */
    public static Properties fetchProperties(URL propsURL) {
        if (Debug.debugging("properties")) {
            Debug.output("PropertyHandler.getProperties(" + propsURL + ")");
        }
        Properties p = new Properties();
        if (propsURL != null) {
            try {
                InputStream is = propsURL.openStream();
                p.load(is);
                is.close();
            } catch (IOException e) {
                Debug.error("PropertyHandler.getProperties(): "
                        + "Exception reading map properties at " + propsURL
                        + ": " + e);
            }
        }
        return p;
    }

    /**
     * All the PropertyHandler does with the MapHandler is look for
     * PropertyConsumers and register their prefixes with the prefixLibarian.
     */
    public void findAndInit(Object obj) {
        if (obj instanceof PropertyConsumer) {
            String prefix = ((PropertyConsumer) obj).getPropertyPrefix();
            if (prefix != null) {
                getPrefixLibrarian().put(prefix, obj);
            }
        }
    }

    public void findAndUndo(Object obj) {
        if (obj instanceof PropertyConsumer) {
            String prefix = ((PropertyConsumer) obj).getPropertyPrefix();
            if (prefix != null) {
                getPrefixLibrarian().remove(prefix);
            }
        }
    }
}