gt: 		if (fConf.getInt("fixedTime") == 0) {
context: package com.ctreber.acearth;
  
  import java.io.IOException;
  import java.io.OutputStream;
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Random;
  
  import com.ctreber.acearth.gui.CanvasACearth;
  import com.ctreber.acearth.plugins.Plugin;
  import com.ctreber.acearth.plugins.markers.Marker;
  import com.ctreber.acearth.plugins.markers.PluginMarkers;
  import com.ctreber.acearth.projection.Projection;
  import com.ctreber.acearth.projection.ProjectionCyl;
  import com.ctreber.acearth.projection.ProjectionMerc;
  import com.ctreber.acearth.projection.ProjectionOrtho;
  import com.ctreber.acearth.renderer.Renderer;
  import com.ctreber.acearth.renderer.RowTypeRendererScanBit;
  import com.ctreber.acearth.renderer.RowTypeRendererScanDot;
  import com.ctreber.acearth.scanbit.BitGeneratorMap;
  import com.ctreber.acearth.scanbit.BitGeneratorMapDefault;
  import com.ctreber.acearth.scanbit.BitGeneratorMapOrtho;
  import com.ctreber.acearth.scandot.DotGeneratorLines;
  import com.ctreber.acearth.scandot.DotGeneratorStars;
  import com.ctreber.acearth.scandot.ScanDot;
  import com.ctreber.acearth.scandot.ScanDotGenerator;
  import com.ctreber.acearth.shader.Shader;
  import com.ctreber.acearth.shader.ShaderDefault;
  import com.ctreber.acearth.shader.ShaderFlat;
  import com.ctreber.acearth.shader.ShaderOrtho;
  import com.ctreber.acearth.util.Coordinate;
  import com.ctreber.acearth.util.SunPositionCalculator;
  import com.ctreber.acearth.util.Toolkit;
  import com.ctreber.aclib.sort.CTSort;
  import com.ctreber.aclib.sort.QuickSort;
  
  /**
   * <h1>AC.earth - XEarth for Java
   * <h1>
   * 
   * <p>
   * The original XEarth was written by Kirk Johnson in July 1993 - thank you for
   * writing this great little program and making it available for free!
   * 
   * <p>
   * I wanted to extend the program, but not in C. So I created this Java version,
   * and found the process quite <strike>painfull</strike> interesting. The
   * biggest effort went into resolving references between C files and
   * eliminatiing pointers.
   * 
   * <h1>License</h1>
   * 
   * <p>
   * AC.earth Copyright (c) 2002 Christian Treber, ct@ctreber.com
   * 
   * <p>
   * AC.earth is based on XEarth by Kirk Johnson
   * 
   * <p>
   * To comply with the XEarth license I include the following text:
   * 
   * <pre>
   * XEarth Copyright (C) 1989, 1990, 1993-1995, 1999 Kirk Lauritz Johnson
   * Parts of the source code are:
   *   Copyright (C) 1989, 1990, 1991 by Jim Frost
   *   Copyright (C) 1992 by Jamie Zawinski &lt;jwz@lucid.com&gt;
   * Permission to use, copy, modify and freely distribute xearth for
   * non-commercial and not-for-profit purposes is hereby granted
   * without fee, provided that both the above copyright notice and this
   * permission notice appear in all copies and in supporting
   * documentation.
   * [Section refering to GIF omitted because it doesn't apply to this version]
   * The author makes no representations about the suitability of this
   * software for any purpose. It is provided &quot;as is&quot; without express or
   * implied warranty.
   * THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
   * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,
   * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, INDIRECT
   * OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
   * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
   * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
   * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
   * </pre>
   * 
   * <p>
   * The license for this program (AC.earth) is the same as the quoted license
   * above, with one change: The "copyright notice and permission notice" shall
   * include the entire text of this section.
   * 
   * todo Phase 2: Make grid value stuff more meaningful ("every n degrees") todo
   * Phase 2: Enter fixed time as data and time, not seconds since epoch todo
   * Phase 2: Compact map data into binary file
   * 
   * <p>
   * &copy; 2002 Christian Treber, ct@ctreber.com
   * 
   * @author Christian Treber, ct@ctreber.com
   */
  public class ACearth {
  	public static final String VERSION = "1.1";
  	public static final String BUILD = "22.11.2002 004";
  
  	// private static long fsStartTime = 0;
  
  	private ConfigurationACearth fConf = new ConfigurationACearth();
  	private long fCurrentTime;
  
  	private CanvasACearth fCanvas;
  
  	private Coordinate fViewPos;
  	private double fViewRotation;
  
  	private List fPlugins;
  
  	/**
  	 * <p>
  	 * Well, the main class.
  	 * @param markers 
  	 */
  	public ACearth(List<Marker> markers) {
  		// fsStartTime = System.currentTimeMillis();
  
  		fPlugins = new ArrayList();
  		fPlugins.add(new PluginMarkers(markers));
  
  	}
  
  	public void exportPng(OutputStream os) throws IOException {
  		fCanvas = new CanvasACearth(this, fConf.getInt("imageWidth"), fConf.getInt("imageHeight"));
  		update();
  		fCanvas.saveToImage(os);
  	}
  
  	public void update() throws IOException {
  		Projection lProjection = null;
  		Shader lShader = null;
  		BitGeneratorMap lScanner = null;
  		if (fConf.is("projection", "Cylindrical")) {
  			lProjection = new ProjectionCyl();
  			lScanner = new BitGeneratorMapDefault(lProjection);
  			lShader = new ShaderDefault();
  		}
  
  		if (fConf.is("projection", "Mercator")) {
  			lProjection = new ProjectionMerc();
  			lScanner = new BitGeneratorMapDefault(lProjection);
  			lShader = new ShaderDefault();
  		}
  
  		if (fConf.is("projection", "Orthographic")) {
  			lProjection = new ProjectionOrtho();
  			lScanner = new BitGeneratorMapOrtho(lProjection);
  			lShader = new ShaderOrtho();
  		}
  
  		computePositions();
  		lProjection.setImageWidth(fConf.getInt("imageWidth"));
  		lProjection.setImageHeight(fConf.getInt("imageHeight"));
  		lProjection.setShiftX(fConf.getInt("shiftX"));
  		lProjection.setShiftY(fConf.getInt("shiftY"));
  		lProjection.setViewMagnification(fConf.getDouble("viewMagnification"));
  		lProjection.setViewPos(fViewPos);
  		lProjection.setViewRotation(fViewRotation);
  
  		lScanner.setImageWidth(fConf.getInt("imageWidth"));
  		lScanner.setImageHeight(fConf.getInt("imageHeight"));
  		lScanner.setMapData(MapDataReader.readMapData());
  		// Process the map (produces ScanBit-s).
  		lScanner.generateScanBits();
  
  		// Process stars and lines (produces ScanDots-s).
  		List lScanDots = new ArrayList();
  		if (fConf.getBoolean("starsP")) {
  			ScanDotGenerator lGenerator = new DotGeneratorStars(fConf.getInt("imageWidth"),
  					fConf.getInt("imageHeight"), fConf.getDouble("starFrequency"), fConf.getInt("bigStars"), new Random(fCurrentTime));
  			lGenerator.generateScanDots();
  			lScanDots.addAll(lGenerator.getScanDots());
  		}
  
  		if (fConf.getBoolean("gridP")) {
  			ScanDotGenerator lGenerator = new DotGeneratorLines(lProjection, fConf.getInt("gridDivision"), fConf
  					.getInt("gridPixelDivision"));
  			lGenerator.generateScanDots();
  			lScanDots.addAll(lGenerator.getScanDots());
  		}
  
  		final CTSort lSort = new QuickSort();
  		ScanDot[] lScanDotsArray = (ScanDot[]) lScanDots.toArray(new ScanDot[0]);
  		lSort.sort(lScanDotsArray);
  
  		if (!fConf.getBoolean("shadeP")) {
  			lShader = new ShaderFlat();
  		}
  		lShader.setProjection(lProjection);
  		lShader.setSunPos(fConf.getSunPos());
  		lShader.setDaySideBrightness(fConf.getInt("daySideBrightness"));
  		lShader.setTerminatorDiscontinuity(fConf.getInt("terminatorDiscontinuity"));
  		lShader.setNightSideBrightness(fConf.getInt("nightSideBrightness"));
  		lShader.init();
  
  		Renderer lRenderer = new Renderer(fCanvas);
  
  		RowTypeRendererScanBit lRowRendererScanBit = new RowTypeRendererScanBit();
  		lRowRendererScanBit.setScanBits(lScanner.getScanBits());
  		lRenderer.addRowTypeRenderer(lRowRendererScanBit);
  
  		RowTypeRendererScanDot lRowRendererScanDot = new RowTypeRendererScanDot();
  		lRowRendererScanDot.setScanDots(lScanDotsArray);
  		lRenderer.addRowTypeRenderer(lRowRendererScanDot);
  
  		lRenderer.setShader(lShader);
  		lRenderer.render();
  
  		// Apply plugins
  		Iterator lIt = fPlugins.iterator();
  		while (lIt.hasNext()) {
  			Plugin lPlugin = (Plugin) lIt.next();
  			lPlugin.setProjection(lProjection);
  			lPlugin.setRenderTarget(fCanvas);
  			lPlugin.setParent(this);
  			lPlugin.render();
  		}
  
  	}
  
  	/**
  	 * <p>
  	 * This is repeated when time changes since this influences the position of
  	 * Earth.
  	 */
  	private void computePositions() {
  		// Determine time for rendering
  