Java PropertyHandler类代码示例

import com.bbn.openmap.PropertyHandler; //导入依赖的package包/类
/**
 * Called when an object is added to the MapHandler.
 */
public void findAndInit(Object someObj) {

    considerForContent(someObj);

    // We shouldn't find this if we've already defined one
    // in the MapPanel, but we have this for backward
    // compatibility.
    if (someObj instanceof JMenuBar) {
        logger.fine("OpenMapFrame: Found a MenuBar");
        getRootPane().setJMenuBar((JMenuBar) someObj);
        invalidate();
    }

    // Only do this if the properties haven't been set on the frame, yet.
    if (someObj instanceof PropertyHandler && !propsInitialized) {
        setProperties(((PropertyHandler) someObj).getProperties());
    }
}
 

import com.bbn.openmap.PropertyHandler; //导入依赖的package包/类
/**
 * Create a new OpenMap framework object - creates a MapPanel, OpenMapFrame,
 * and brings up the layer palettes that are being told to be open at
 * startup. The properties in the PropertyHandler will be used to configure
 * the application. PropertyHandler may be null.
 */
public OpenMap(PropertyHandler propertyHandler) {
    configureMapPanel(propertyHandler);

    // Schedule a job for the event-dispatching thread:
    // creating and showing this application's GUI.
    javax.swing.SwingUtilities.invokeLater(new Runnable() {
        public void run() {
            // TODO There's something going on here with the progress
            // reporter and the swing thread that is causing the app to hang
            // in Leopard.
            showInFrame();
        }
    });
}
 

import com.bbn.openmap.PropertyHandler; //导入依赖的package包/类
protected void configureMapPanel(PropertyHandler propertyHandler) {
    BasicMapPanel basicMapPanel = new BasicMapPanel(propertyHandler, true);
    // Creates the components in the main application thread. If any of
    // these components need to update their GUI, they should hand a
    // Runnable object to the SwingUtilities.invokeLater(Runnable) method,
    // and it will be updated accordingly.
    basicMapPanel.create();
    mapPanel = basicMapPanel;
}
 

import com.bbn.openmap.PropertyHandler; //导入依赖的package包/类
protected void configureMapPanel(PropertyHandler propertyHandler) {
    OverlayMapPanel mapPanel = new OverlayMapPanel(propertyHandler, true);
    // Creates the components in the main application thread. If any of
    // these components need to update their GUI, they should hand a
    // Runnable object to the SwingUtilities.invokeLater(Runnable) method,
    // and it will be updated accordingly.
    mapPanel.create();
    this.mapPanel = mapPanel;
}
 

import com.bbn.openmap.PropertyHandler; //导入依赖的package包/类
/**
 * A method that lets you control what gets added to the application
 * programmatically. These components are required for handling an
 * OMEventHandler, which would be added to the MapHandler. If you wanted to
 * use the standard OpenMap application, you could add these components to
 * the MapHandler, instead.
 */
protected void configureMapPanel(PropertyHandler propertyHandler) {
    super.configureMapPanel(propertyHandler);
    MapHandler mapHandler = mapPanel.getMapHandler();

    HotwashPanel hotwashPanel = new HotwashPanel();
    String hotwash = "hotwash";
    // This is important - the property prefix is checked against parent
    // names of MapPanelChildren, so the HotwashPanel can figure out what
    // goes to itself vs. the BasicMapPanel holding the map.
    hotwashPanel.setPropertyPrefix(hotwash);
    mapHandler.add(hotwashPanel);

    mapHandler.add(new OMEventSelectionCoordinator());

    TimePanel timePanel = new TimePanel();
    timePanel.setParentName(hotwash);
    mapHandler.add(timePanel);

    EventPanel eventPanel = new EventPanel();
    eventPanel.setParentName(hotwash);
    mapHandler.add(eventPanel);

    EventListPresenter eventListPresenter = new EventListPresenter();
    mapHandler.add(eventListPresenter);

    mapHandler.add(new Clock());
}
 

import com.bbn.openmap.PropertyHandler; //导入依赖的package包/类
/**
 * Looks for PropertyHandler and LayerHandler.
 */
public void findAndInit(Object someObj) {
    if (someObj instanceof PropertyHandler) {
        // do the initializing that need to be done here
        Debug.message("layerspanel", "LayerAddPanel found a LayerHandler");
        propertyHandler = (PropertyHandler) someObj;
    }
    if (someObj instanceof LayerHandler) {
        layerHandler = (LayerHandler) someObj;
    }
}
 

import com.bbn.openmap.PropertyHandler; //导入依赖的package包/类
/**
 * Disconnect from any objects that are removed from MapHandler.
 */
public void findAndUndo(Object someObj) {
    if (someObj instanceof PropertyHandler && propertyHandler == someObj) {
        // do the initializing that need to be done here
        Debug.message("addable", "LayerAddPanel removing PropertyHandler");
        propertyHandler = null;
    }
    if (someObj instanceof LayerHandler && someObj == layerHandler) {
        Debug.message("addable", "LayerAddPanel removing LayerHandler");
        layerHandler = null;
    }
}
 

import com.bbn.openmap.PropertyHandler; //导入依赖的package包/类
/** Test cases. */
public static void main(String[] args) {
    LayerAddPanel lap = new LayerAddPanel(new PropertyHandler(), null);
    Layer[] layers = new Layer[1];
    layers[0] = new com.bbn.openmap.layer.shape.ShapeLayer();

    lap.createPanel(layers);
}
 

import com.bbn.openmap.PropertyHandler; //导入依赖的package包/类
/**
 * Create a MapPanel that configures itself with properties contained in the
 * PropertyHandler provided, and with the option of delaying the search for
 * properties until the <code>create()</code> call is made.
 * 
 * @param delayCreation true to let the MapPanel know that the artful
 *        programmer will call <code>create()</code>
 */
public BasicMapPanel(PropertyHandler propertyHandler, boolean delayCreation) {
    MapHandler mh = getMapHandler();
    mh.add(this);

    setPropertyHandler(propertyHandler);
    if (!delayCreation) {
        create();
    }
}
 

import com.bbn.openmap.PropertyHandler; //导入依赖的package包/类
/**
 * The constructor calls this method that creates the MapHandler and
 * MapBean, and then tells the PropertyHandler to create the components
 * described in its properties. This method calls getMapHandler() and
 * getMapBean(). If the PropertyHandler is not null, it will be called to
 * created components based on its properties, and those components will be
 * added to the MapHandler in this MapPanel.
 */
protected void createComponents() {
    // Make this call first to load the properties into
    // Environment, before the MapBean gets created.
    PropertyHandler ph = getPropertyHandler();
    // Make sure the MapBean is created and added to the
    // MapHandler.
    MapBean mb = getMapBean();
    MapHandler mh = getMapHandler();
    ph.createComponents(getMapHandler());

    // At this point, check the MapHandler to see if a
    // ProjectionFactory has been added. If it hasn't, create one
    // with the default ProjectionLoaders. We might want to
    // remove this at some point, but not having it here will
    // catch some people by surprise when 4.6.1 comes out.
    Object obj = mh.get(com.bbn.openmap.proj.ProjectionFactory.class);
    if (obj == null) {
        Debug.message("basic",
                      "BasicMapPanel adding ProjectionFactory and projections to MapHandler since there are none to be found.");
        mh.add(ProjectionFactory.loadDefaultProjections());
    }

    // Environment will only get loaded after the property file is
    // read.
    mb.setProjection(mb.getProjectionFactory().getDefaultProjectionFromEnvironment(Environment.getInstance()));
    mb.setBckgrnd(Environment.getCustomBackgroundColor());
}
 

import com.bbn.openmap.PropertyHandler; //导入依赖的package包/类
/**
 * Get the PropertyHandler containing properties used to configure the
 * panel, creating it if it doesn't exist.
 */
public PropertyHandler getPropertyHandler() {
    if (propertyHandler == null) {
        setPropertyHandler(new PropertyHandler());
    }
    return propertyHandler;
}
 

import com.bbn.openmap.PropertyHandler; //导入依赖的package包/类
/**
 * Set the PropertyHandler containing the properties used to configure this
 * panel. Adds the PropertyHandler to the MapHandler. If the MapHandler
 * isn't set at this point, it will be created via a getMapHandler() call.
 */
public void setPropertyHandler(PropertyHandler handler) {
    propertyHandler = handler;
    if (handler != null) {
        getMapHandler().add(handler);

        setProperties(handler.getPropertyPrefix(), handler.getProperties());
    }
}
 

import com.bbn.openmap.PropertyHandler; //导入依赖的package包/类
/** A main() method that just brings up a JFrame containing the MapPanel. */
public static void main(String argv[]) {
   SwingUtilities.invokeLater(new Runnable() {

      public void run() {
         JFrame f = new JFrame("Map");
         f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         OverlayMapPanel map = new OverlayMapPanel(new PropertyHandler(new Properties()), true);
         map.create();

         map.getMapBean().setBackgroundColor(new Color(0x99b3cc));
         map.addMapComponent(new LayerHandler());
         map.addMapComponent(new MouseDelegator());
         map.addMapComponent(new OMMouseMode());
         ShapeLayer shapeLayer = new ShapeLayer("share/data/shape/cntry02/cntry02.shp");
         // shapeLayer.setAddAsBackground(true);
         map.addMapComponent(shapeLayer);
         map.includeExitMenuItem();
         f.setJMenuBar(map.getMapMenuBar());
         f.getContentPane().add(map);
         f.setSize(800, 600);
         f.setVisible(true);
      }

   });

}
 

import com.bbn.openmap.PropertyHandler; //导入依赖的package包/类
public TimeFrameApp(PropertyHandler propertyHandler) {
    super(propertyHandler);
}
 

import com.bbn.openmap.PropertyHandler; //导入依赖的package包/类
/**
 * Creates the LayerPanel.
 * 
 * @param l the LayerHandler controlling the layers.
 */
public LayerAddPanel(PropertyHandler p, LayerHandler l) {
    this();
    propertyHandler = p;
    layerHandler = l;
}