Java tutorial
package org.eclipse.stem.ui.ge.views; /******************************************************************************* * Copyright (c) 2006 IBM Corporation and others. * All rights reserved. This program and the accompanying materials * are made available under the terms of the Eclipse Public License v1.0 * which accompanies this distribution, and is available at * http://www.eclipse.org/legal/epl-v10.html * * Contributors: * IBM Corporation - initial API and implementation *******************************************************************************/ import java.io.IOException; import java.util.Map; import org.eclipse.core.runtime.Preferences; import org.eclipse.core.runtime.Preferences.IPropertyChangeListener; import org.eclipse.core.runtime.Preferences.PropertyChangeEvent; import org.eclipse.jface.preference.BooleanFieldEditor; import org.eclipse.jface.preference.DirectoryFieldEditor; import org.eclipse.jface.preference.FieldEditorPreferencePage; import org.eclipse.jface.preference.IPreferenceStore; import org.eclipse.jface.preference.IntegerFieldEditor; import org.eclipse.jface.preference.RadioGroupFieldEditor; import org.eclipse.jface.preference.StringFieldEditor; import org.eclipse.stem.ui.ge.Activator; import org.eclipse.stem.ui.ge.Aspect; import org.eclipse.stem.ui.ge.GELog; import org.eclipse.stem.ui.preferences.PreferenceConstants; import org.eclipse.ui.IWorkbench; import org.eclipse.ui.IWorkbenchPreferencePage; import org.eclipse.ui.preferences.ScopedPreferenceStore; /** * Handle Preferences for the STEM - GoogleEarth interface. * <pre> * This class contains the following: * - code to present the setting of the preferences * by the user. The gui for some preferences are * handled by GEAdvancedPreferencePage * * - getter/setter code for all of the preferences. * mostly getter. * * - code to pick up the aspect preference from the * visualization page. * * This class was initialy generated by the PreferencePage wizard and * then modified as described in * "Building Comercial-Quality Plugins" * * This class represents a preference page that * is contributed to the Preferences dialog. By * subclassing <samp>FieldEditorPreferencePage</samp>, we * can use the field support built into JFace that allows * us to create a page that is small and knows how to * save, restore and apply itself. * <p> * This page is used to modify preferences only. They * are stored in the preference store that belongs to * the main plug-in class. That way, preferences can * be accessed directly via the preference store. * * This uses the jface Preferences API rather than * the new SWT Preferences API because it is simpler * to implement. * </pre> */ public class GEPreferencePage extends FieldEditorPreferencePage implements IWorkbenchPreferencePage { /** * Folder used to store KML files */ static final String P_FOLDER = "folderPreference"; /** * Server:port used for Web server that will feed the * KML files to GoogleEarth. */ static final String P_SERVER_HOST = "ServerHostPreference"; /** * Launch GoogleEarth at startup flag. * If true then automatically launch an empty file * to GE at startup * */ static final String P_AUTO_LAUNCH = "AutoLaunchPreference"; /** * Use InternalServer flag * if true then start the Eclpse built in web server */ static final String P_INTERNAL_SERVER = "InternalServer"; /** * Automatically launch NetworkLink.KML file * */ //static final String P_AUTO_NETLINK = "AutoNetLink"; /** * Write KML files every Nth cycle. * * For example 1 would write every cycle and * 3 would write every 3rd cycle. * This is useful when there is not much change * between cycles and saves the overhead of both * writing the file and more importantly having * GoogleEarth read and process it. * Note <- 0 would only write the first and last. */ static final String P_WHICH_CYCLE = "whichCycle"; /** * Debug display option */ static final String P_DEBUG = "DebugPreference"; /** * Use GoogleEarth BBox info to filter KML * Access via the isBBOX() method */ static final String P_BBOX = "BBOXPreference"; /** * Aspect (SEIR) to be displayed (or Logged) * */ static final String P_ASPECT = "AspectPreference"; /** * if true then this will do autologging of every simulation * assuming that the GoogleEarth interface is active. */ static final String P_AUTO_LOGGING = "AutoLoggingPreference"; /** * Test option * The Test option is used arbitrarily to * test newly implemented features or setup * a temporary test environment. It is a tool * for the developer and would not normaly be * specified by the user except on request of * a developer. * An example of use would be to turn on some * additional debug code to help find a bug. */ static final String P_TEST = "TestPreference"; /** * Option to control the display of borders on the map */ static final String P_SHOW_BORDER = "ShowBorderPreference"; /** * Method used to display STEM results on GoogleEarth * <pre> * * 1=LogOnly - KML files will be logged for later display via Servlet * * 2=Log+Servlet - KML files logged and Netlink file launched to cause * GE to request logged files via Servlet. * * 3=ASynch-Servlet - KML written to Control.kml every Nth cycle * and Netlink file launched to cause GE to reread * control.kml every N seconds * 4=AutoLaunch - At each Nth cycle, directly launch the file to GE */ static final String P_METHOD = "MethodPreference"; /** * Only Log KML for later display */ public static final int M_LOG_ONLY = 1; /** * Log the KML files and * start the networkLink process */ public static final int M_LOG_SERVLET = 2; /** * always write the control.kml file and * start a servlet to read the latest version. * Advantage is that GoogleEarth is always reading * the latest version and will not fall behind. */ public static final int M_ASYNC_SERVLET = 3; /** * Build a KML file and launch it directly * to GoogleEarth */ public static final int M_AUTO_LAUNCH = 4; /** * Do not do anything automatically. * Only generate a KML file at request of user. * */ public static final int M_MANUAL_DISPLAY = 5; /** * */ public static final IPreferenceStore preferences = Activator.getDefault().getPreferenceStore(); /** * construct the Preference page for GoogleEarth interface. * */ public GEPreferencePage() { super(GRID); //super(FLAT); // To use GELog In preferences you have to manually // turn it on before the preference is used to set it. // obviously! :-) Uncomment the following //GELog.DEBUG = true; //preferences = Activator.getDefault().getPreferenceStore(); setPreferenceStore(preferences); setDescription("Preferences for the STEM - GoogleEarth interface\n "); //getVisualizationPreferences(); } /* (non-Javadoc) * @see org.eclipse.ui.IWorkbenchPreferencePage#init(org.eclipse.ui.IWorkbench) */ public void init(IWorkbench workbench) { } /** * Creates the field editors. Field editors are abstractions of * the common GUI blocks needed to manipulate various types * of preferences. Each field editor knows how to save and * restore itself. */ public void createFieldEditors() { addField(new RadioGroupFieldEditor(P_METHOD, "&Choose the method used to display STEM results.", 1, new String[][] { { "LogOnly - KML files will be logged for later display", "1" }, { "Log+Servlet - KML files logged and displayed by GoogleEarth", "2" }, { "AsyncServlet - KML written to Control.kml and Async read by Servlet ", "3" }, { "DirectLaunch - At each Nth cycle, directly launch the file to GE ", "4" }, { "ManualDisplay - Use DisplayMap command to display", "5" } }, getFieldEditorParent())); addField(new DirectoryFieldEditor(P_FOLDER, "&Folder for KML logging:", getFieldEditorParent())); addField(new BooleanFieldEditor(P_INTERNAL_SERVER, "&Use internal webserver", getFieldEditorParent())); addField(new StringFieldEditor(P_SERVER_HOST, "Hostname:port for external webserver:", getFieldEditorParent())); addField(new BooleanFieldEditor(P_AUTO_LAUNCH, "&Automatically startup GoogleEarth", getFieldEditorParent())); addField(new BooleanFieldEditor(P_AUTO_LOGGING, "&Automatically process every simulation", getFieldEditorParent())); addField(new IntegerFieldEditor(P_WHICH_CYCLE, "Write KML files only every N th cycle", getFieldEditorParent(), 2)); // if aspect uninitialized, then get from Visualization page String a = preferences.getString(P_ASPECT); if ("".equals(a)) { getVisualizationPreferences(); //a = preferences.getString(P_ASPECT); } //GELog.debug(this,"Initial visualizationAspect="+a); // if we have initialized the aspects - show selection String[][] aspectList = aspects(); if (aspectList != null) { addField(new RadioGroupFieldEditor(P_ASPECT, "&Choose the STEM Aspect to be Logged.", 2, aspects(), getFieldEditorParent())); } } /** * Get the list of supported Aspects * * @return Array of Aspects. Each entry in array * consists of the Aspect Name and Code */ private String[][] aspects() { Map<String, Aspect> aspectMap = Aspect.getMap(); if (aspectMap == null || aspectMap.size() == 0) { return null; } int n = aspectMap.size(); String[][] result = new String[n][2]; int i = 0; for (Map.Entry entry : aspectMap.entrySet()) { String code = (String) entry.getKey(); Aspect aspect = (Aspect) entry.getValue(); result[i][0] = aspect.getName(); result[i][1] = code; i++; } return result; } public boolean performOk() { update(); try { if (preferences instanceof ScopedPreferenceStore) { ScopedPreferenceStore p = (ScopedPreferenceStore) preferences; p.save(); } } catch (IOException e) { GELog.error("Failure saving Preferences", e); } GELog.debug(this, "saved preferences"); return super.performOk(); } /** * Make any needed application updates * */ private void update() { if (isDebug() != GELog.DEBUG) { GELog.DEBUG = isDebug(); if (isDebug()) { GELog.debug("Set DEBUG to " + isDebug()); } } } /** * Get the aspect to display from the Visualization * preference page. * We only use the visualization value if we don't * have any value specifified so that we can specify * a different value from the internal map if we want. * * */ private void getVisualizationPreferences() { org.eclipse.stem.ui.Activator uiPlugin = null; try { // IPreferenceStore uiPlugin = org.eclipse.stem.ui.Activator.getDefault(); final Preferences preferences = uiPlugin.getPluginPreferences(); String visualizationAspect = preferences .getString(PreferenceConstants.INITIAL_ATTRIBUTE_NAME_STRING_PREFERENCE); if (preferences.getString(P_ASPECT) == "") { // TODO temp fix for bad visualization default GELog.debug(this, "Use visualizationAspect=" + visualizationAspect); if (visualizationAspect.equals("S")) visualizationAspect = "I"; setAspect(visualizationAspect); } else { GELog.debug(this, "Ignore visualizationAspect=" + visualizationAspect); } } catch (Exception e) { GELog.error("Failure getting Visualization preferences", e); } // listen for changes in the Visualization preferences try { // Listen for changes to the preferences and change the value we // use if the user changes the value on the preference page. uiPlugin.getPluginPreferences().addPropertyChangeListener(new IPropertyChangeListener() { public void propertyChange(PropertyChangeEvent event) { setVisulizationPreferences(event); } // propertyChange } // IPropertyChangeListener ); } catch (Exception e) { // Ignore } // catch Exception } /** * Check if the aspect was changed on the visualization preferences * and if so then use it for us also. * @param event */ private void setVisulizationPreferences(PropertyChangeEvent event) { String property = event.getProperty(); if (PreferenceConstants.INITIAL_ATTRIBUTE_NAME_STRING_PREFERENCE == property) { String visualizationAspect = (String) event.getNewValue(); GELog.debug(this, "Changed visualizationAspect=" + visualizationAspect); setAspect(visualizationAspect); performOk(); } } /** * @return the logFolder */ public static String getFolder() { return preferences.getString(P_FOLDER); } /** * @param logFolder the logFolder to set */ public static void setFolder(String logFolder) { preferences.setValue(P_FOLDER, logFolder); } /** * @return the serverHost */ public static String getServerHost() { return preferences.getString(P_SERVER_HOST); } /** * This will return a code 1 to 5 indicating the * method used to display KML. * * M_LOG_ONLY = 1; * M_LOG_SERVLET = 2; * M_ASYNC_SERVLET = 3; * M_AUTO_LAUNCH = 4; * M_MANUAL_DISPLAY = 5; * * If there is no Servlet support, it will modify what * is returned to avoid being dependent on a servlet. * * @return the method code to be used to display KML * */ public static int getMethod() { String s = preferences.getString(P_METHOD); int type = Integer.parseInt(s); // The test is now made in StemKML // if (StemKml.getServerUrl() == null) { // if (type == M_LOG_SERVLET) // type = M_LOG_ONLY; // else if (type == M_ASYNC_SERVLET) // type = M_AUTO_LAUNCH; // } return type; } /** * Set the Method that STEM coummicates with GE * * @param newMethod New method to set */ public static void setMethod(int newMethod) { String m = "" + newMethod; preferences.setValue(P_METHOD, m); } /** * @return the internalServer flag * * If true then the info about the status of * the server is handled by the StemKML code. */ public static boolean isInternalServer() { return preferences.getBoolean(P_INTERNAL_SERVER); } /** * @return the autoLaunch flag */ public static boolean isAutoLaunch() { return preferences.getBoolean(P_AUTO_LAUNCH); } /** * @return the autoLogging */ public static boolean isAutoLogging() { return preferences.getBoolean(P_AUTO_LOGGING); } /** * @return the whichCycle */ public static int getWhichCycle() { return preferences.getInt(P_WHICH_CYCLE); } /** * get the specified Aspect that will be logged or displayed * @return Aspect instance or null */ public static Aspect getAspect() { Aspect aspect = null; String a = preferences.getString(P_ASPECT); if (a.length() == 0) aspect = Aspect.getDefault(); else aspect = Aspect.getAspect(a); if (aspect == null) { GELog.debug("GEPreferencePage.getAspect: ", a + " returned null, use default aspect"); aspect = Aspect.getDefault(); } return aspect; } /** * set the Aspect that will be displayed * @param aspectStr Name of the desired Aspect. */ public static void setAspect(String aspectStr) { Map<String, Aspect> aspectMap = Aspect.getMap(); if (aspectMap != null && aspectMap.size() > 0) { Aspect aspect = null; aspect = Aspect.getAspect(aspectStr); if (aspect == null) { GELog.debug(GEPreferencePage.class, "Invalid aspect ignored: " + aspectStr); return; } } preferences.setValue(P_ASPECT, aspectStr); GELog.debug(GEPreferencePage.class, "Aspect set: " + aspectStr); return; } /** * @return the BBox filter flag */ public static boolean isBBOX() { if (preferences != null) return preferences.getBoolean(P_BBOX); else return false; } /** * @return the Debug flag */ public static boolean isDebug() { if (preferences != null) return preferences.getBoolean(P_DEBUG); else return true; } /** * @return the Test flag * <pre> * Uses: * - Enhanced Debug output (time and thread) * - Filter out nodes * - KmlDisplay - if not BBox filter then not US or Mexico * - KmlDisplayCustom - not US * To see where else this is used ask to see call hierarchy */ public static boolean isTest() { if (preferences != null) return preferences.getBoolean(P_TEST); else return true; } /** * @return the ShowBorder flag * <pre> * With KML you can either show the polygon borders or not. * This flag will control whether they are shown or not. * The default is to not show them */ public static boolean isShowBorder() { if (preferences != null) return preferences.getBoolean(P_SHOW_BORDER); else return true; } // TODO keep this up to date /** * To display all of the Preferences. * * Please keep this up to date. * * @return string describing the current preferences. */ public static String display() { StringBuffer sb = new StringBuffer(200); sb.append("STEM-GoogleEarth Preferences:\n"); sb.append("P_METHOD: "); switch (getMethod()) { case M_LOG_ONLY: sb.append("M_LOG_ONLY "); break; case M_LOG_SERVLET: sb.append("M_LOG_SERVLET "); break; case M_ASYNC_SERVLET: sb.append("M_ASYNC_SERVLET "); break; case M_AUTO_LAUNCH: sb.append("M_AUTO_LAUNCH "); break; case M_MANUAL_DISPLAY: sb.append("M_MANUAL_DISPLAY "); break; default: sb.append("Unknown "); } sb.append("\n"); sb.append("P_FOLDER: "); sb.append(getFolder() + "\n"); sb.append("P_SERVER_HOST: "); sb.append(getServerHost() + "\n"); sb.append("P_INTERNAL_SERVER: "); sb.append(isInternalServer() + "\n"); sb.append("P_AUTO_LAUNCH: "); sb.append(isAutoLaunch() + "\n"); sb.append("P_AUTO_LOGGING: "); sb.append(isAutoLogging() + "\n"); sb.append("P_WHICH_CYCLE: "); sb.append(getWhichCycle() + "\n"); sb.append("P_ASPECT: "); sb.append(getAspect().toString() + "\n"); sb.append("P_BBOX: "); sb.append(isBBOX() + "\n"); sb.append("P_DEBUG: "); sb.append(isDebug() + "\n"); // // The following are found in GEAdvancedPreferencePage // sb.append("P_TEST: "); sb.append(isTest() + "\n"); sb.append("P_SHOW_BORDER: "); sb.append(isShowBorder() + "\n"); return sb.toString(); } }