core/org.eclipse.stem.ui.ge/src/org/eclipse/stem/ui/ge/views/GEPreferencePage.java

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