/*----------------------------------------------------------------------
| Air traffic control demo where a map is displayed suing GLG Map Server.
*/

import java.applet.*;
import java.awt.*;
import java.awt.event.*;
import java.lang.*;
import java.lang.reflect.*;
import java.text.*;

import javax.swing.*;

import com.genlogic.*;

//////////////////////////////////////////////////////////////////////////

public class GlgAirTrafficDemo extends GlgJBean implements ActionListener

{
   //////////////////////////////////////////////////////////////////////////
   // The main demo class
   //////////////////////////////////////////////////////////////////////////
   String drawing_name = "airtraffic.g";

   // If supplied, overrides the URL of the GIS object in the drawing
   static String SuppliedMapServerURL = null; 

   static boolean StandAlone = false;
   boolean IsReady = false;
   double PlaneSpeed = 0.005;    // Relative units   

   // Define constants
   final int 
      MAX_NUM_PLANES = 10000,
      NUM_NODE_TYPES = 2,
      NUM_PLANE_TYPES = 3;

   final double
      SMALL_SIZE = 0.5,
      MEDIUM_SIZE = 0.7,
      BIG_SIZE = 0.9;

   final int
      NORMAL = 0,
      WARNING = 1,
      ALARM = 2,
      SELECTED = 3;

   int 
      MaxNumPlanes = 10000,
      NumNodeTypes = 2,
      NumPlaneTypes = 3;

   GlgObject
      Drawing,     
      NodeTemplate[] = new GlgObject[ NumNodeTypes ],
      PlaneTemplate[] = new GlgObject[ NumPlaneTypes ],
      TrajectoryTemplate,
      NodePool[] = new GlgObject[ NumNodeTypes ],
      PlanePool[] = new GlgObject[ NumPlaneTypes ],
      TrajectoryPool,
      Map,
      GISObject,
      NodeGroup,
      PlaneGroup,
      TrajectoryGroup,
      DistancePolygon;

   // Store initial extent and center, used to reset.
   GlgPoint 
      InitExtent = new GlgPoint(),
      InitCenter = new GlgPoint();

   double
      PlaneSize = SMALL_SIZE,
      // Dimensions of the map viewport windows.
      window_width,
      window_height;

   int
      UpdateInterval = 100,  // Update interval in msec.
      NumPlanes = 100,
      NumNodes,
      NumTrajectoryPoints,
      InitialMapProjection,
      MapProjection,
      PlaneType = 0,
      NodeType = 0,
      SelectedPlaneIndex = -1,
      NumDistancePoints;

   boolean
      OrthoOnly = false,
      NoFill = false,
      DoUpdate = true,
      PanMode = false,
      DistanceMode = false,
      RedoIcons = true,
      HasAngle = false,
      HasElevation = false;
      
   PlaneData PlaneArray[];

   // Array of icons to place on the map as GLG objects in addition to the icons
   // defined in GIS server's data. The icons that use GLG objects may be selected
   // with the mouse and their attributes can be changed dynamically, based on 
   // data. When the mouse moves over an icon, it may be highlighted with a 
   // different color or a tooltip may be displayed. 
   NodeData NodeArray[] =
   {
      new NodeData( "Boston",        -71.01789,  42.33602 ),
      new NodeData( "New York",      -73.97213,  40.77436 ),
      new NodeData( "San Francisco", -122.55478, 37.79325 ),
      new NodeData( "Miami",         -80.21084,  25.77566 ),
      new NodeData( "Seattle",       -122.35032, 47.62180 ),
      new NodeData( "Houston",       -95.38672,  29.76870 ),
      new NodeData( "Denver",        -104.87265, 39.76803 ),
      new NodeData( "Minneapolis",   -93.26684,  44.96185 ),
      new NodeData( "Chicago",       -87.68496,  41.83705 ),
      new NodeData( "Dallas",        -96.76524,  32.79415 )
   };

   // Temporary variables: allocate once
   GlgPoint
      lat_lon = new GlgPoint(),
      point = new GlgPoint(),
      world_point = new GlgPoint();


   Timer timer = null;


   //////////////////////////////////////////////////////////////////////////
   public GlgAirTrafficDemo()
   {
      super();

      SetDResource( "$config/GlgMouseTooltipTimeout", 0.05 );

      // Activate Trace callback.
      AddListener( GlgObject.TRACE_CB, this );
   }

   //////////////////////////////////////////////////////////////////////////
   // For using as a stand-alone java demo
   //////////////////////////////////////////////////////////////////////////
   public static void main( final String arg[] )
   {

      SwingUtilities.
	invokeLater( new Runnable(){ public void run() { Main( arg ); } } );

   }

   //////////////////////////////////////////////////////////////////////////
   // Optional arguments.
   // -num_planes <number>  - specify the number of planes to be displayed;
   //                          default: 100
   // -speed <number>       - plane speed in relative units, default: 0.005
   // -ortho                - use Orthographic projection only
   // -map_server_url       - specify MapServerURL; it may be supplied as an
   //                         applet parameter when used as an applet;
   //                         default: use GIS object's MapServerURL property 
   //                         from the drawing file.
   //////////////////////////////////////////////////////////////////////////
   public static void Main( String arg[] )
   {
      class DemoQuit extends WindowAdapter
      {
         public void windowClosing( WindowEvent e ) { System.exit( 0 ); }
      } 


      JFrame frame = new JFrame();

      frame.setResizable( true );
      frame.setSize( 800, 700 );
      frame.setLocation( 100, 20 );

      GlgAirTrafficDemo air_traffic_demo = new GlgAirTrafficDemo();      

      frame.getContentPane().add( air_traffic_demo );


      frame.addWindowListener( new DemoQuit() );
      frame.show();

      // Process command line arguments.
      int num_arg = Array.getLength( arg );

      if( num_arg != 0 )
      {
	 for( int skip = 0; skip < num_arg; ++skip )
	 {
	    if( arg[ skip ].equals( "-num_planes" ) )
	    {
	       ++skip;
	       if( num_arg <= skip )
		  air_traffic_demo.error( "No plane number.", true );

	       try
	       {
		  air_traffic_demo.NumPlanes = new Integer( arg[ skip ] ).intValue();
	       }
	       catch( NumberFormatException e )
	       {
		  air_traffic_demo.error( "No plane number.", true );
	       }

	       if( air_traffic_demo.NumPlanes > air_traffic_demo.MAX_NUM_PLANES )
		 air_traffic_demo.error( "Increase plane array size and run again.", true );	   
	    }
	    else if( arg[ skip ].equals( "-speed" ) )
	    {
	       ++skip;
	       if( num_arg <= skip )
		  air_traffic_demo.error( "No plane speed.", true );

	       try
	       {
		  air_traffic_demo.PlaneSpeed =
		    new Double( arg[ skip ] ).doubleValue();
	       }
	       catch( NumberFormatException e )
	       {
		  air_traffic_demo.error( "No plane speed.", true );
	       }
	    }
	    else if( arg[ skip ].equals( "-ortho" ) )
	    {
	       air_traffic_demo.OrthoOnly = true;
	    }
	    else if( arg[ skip ].equals( "-map_server_url" ) )
	    {
	       ++skip;
	       if( num_arg <= skip )
		  air_traffic_demo.error( "No map server URL.", true );

	       air_traffic_demo.SuppliedMapServerURL = arg[ skip ];
	    }
	    else if( arg[ skip ].equals( "-help" ) )
	    {
	       System.out.println( 
		   "Options: -num_planes <number> -speed <number> -ortho -map_server_url" );
	       System.out.println( 
		   "Defaults: -num_planes 100 -speed 0.005" );
	       System.exit( 0 );
	    }
	    else
	    {
	       System.out.println ( 
		   "Invalid option. Use -help for the list of options." );
	       System.exit( 1 );
	    }
	 }
	 
      }

      air_traffic_demo.SetDrawingName( air_traffic_demo.drawing_name );
   }

   //////////////////////////////////////////////////////////////////////////
   // Invoked before the hierarchy setup.
   //////////////////////////////////////////////////////////////////////////
   public void HCallback( GlgObject viewport )
   {
      Drawing = viewport;
      Map = Drawing.GetResourceObject( "Map" );   
      GISObject = Map.GetResourceObject( "GISObject" );

      if( !StandAlone )
      {
	 String param = getParameter( "MapServerURL" );
	 if( param != null )
	   SuppliedMapServerURL = param;
      }

      Init();
   }

   //////////////////////////////////////////////////////////////////////////
   // Initializes icons in the drawing
   //////////////////////////////////////////////////////////////////////////
   void Init()
   {
      String icon_name;
      int i;


      	 
      if( SuppliedMapServerURL != null )   // Override URL in the drawing
	 GISObject.SetSResource( "GISMapServerURL", SuppliedMapServerURL );

      // Set GIS Zoom mode for the drawing.
      Map.SetGISZoom( null, GISObject, null );

      // Query and store the GIS projection (ORTHOGRAPHIC or RECTANGULAR)
      int projection = GISObject.GetDResource( "GISProjection" ).intValue();
      InitialMapProjection = projection;
      MapProjection = projection;

      // Query and store GIS object's Extent and Center.
      InitExtent = GISObject.GetGResource( "GISExtent" );
      InitCenter = GISObject.GetGResource( "GISCenter" );

      // Make popup dialog and distance popup invisible.
      Drawing.SetDResource( "FlightInfoPopup/Visibility", 0. );
      Map.SetDResource( "DistancePopup/Visibility", 0. );

      // Disable color button: this functionality is not supported with
	// the remote map sever setup.
      Drawing.SetDResource( "ToggleColor/HandlerDisabled", 1. );	  

      // Get the palette containing templates for plane and node icons.
      GlgObject palette = Drawing.GetResourceObject( "Palette" );

       // Delete it from the drawing
      Drawing.DeleteObject( palette );

      // Get node and plane templates from the palette. A few sets of templates
      // with different level of details are used, depending on the zoom level.
      // Palette aproach is used to implement icon types instead of 
      // subdrawings, since icons are dynamically added/deleted from the 
      // drawing any way to show only the icons visible in the zoomed area.
	//
      for( i=0; i < NUM_PLANE_TYPES; ++i )
      {
	 icon_name = "Plane" + i;
	 PlaneTemplate[ i ] = palette.GetResourceObject( icon_name );

	 // Turn labels on initially.
	 if( i != 0 )
	    PlaneTemplate[ i ].SetDResource( "Label/Visibility", 1. );
      }

      TrajectoryTemplate = palette.GetResourceObject( "Trajectory" );
      NumTrajectoryPoints = 
	TrajectoryTemplate.GetDResource( "Factor" ).intValue();

      for( i=0; i < NUM_NODE_TYPES; ++i )
      {
	 icon_name = "Node" + i;
	 NodeTemplate[ i ] = palette.GetResourceObject( icon_name );
      }

      NumNodes = Array.getLength( NodeArray );

      // Create and initialize plane structures used for simulation.
      PlaneArray = new PlaneData[ NumPlanes ];
      for( i =0; i < NumPlanes; ++i )
      {
	 PlaneArray[ i ] = new PlaneData();
	 PlaneArray[ i ].name = Integer.toString( i );
	 PlaneArray[ i ].tooltip = null;
	 PlaneArray[ i ].color_index = NORMAL;
	 PlaneArray[ i ].graphics = null;
	 PlaneArray[ i ].trajectory = null;
	 PlaneArray[ i ].iteration = 0;
	 StartPlane( PlaneArray[ i ], true );
      }

      // Create groups to hold nodes and planes.
      NodeGroup = new GlgDynArray( GlgObject.GLG_OBJECT, 0, 0 );
      NodeGroup.SetSResource( "Name", "NodeGroup" );

      TrajectoryGroup = new GlgDynArray( GlgObject.GLG_OBJECT, 0, 0 );
      TrajectoryGroup.SetSResource( "Name", "TrajectoryGroup" );

      PlaneGroup = new GlgDynArray( GlgObject.GLG_OBJECT, 0, 0 );
      PlaneGroup.SetSResource( "Name", "PlaneGroup" );

      Map.AddObjectToBottom( NodeGroup );
      Map.AddObjectToBottom( PlaneGroup );
      Map.AddObjectToBottom( TrajectoryGroup );

      // Create groups to keep pooled objects.
      for( i=0; i<NumNodeTypes; ++i )
	 NodePool[i] = new GlgDynArray( GlgObject.GLG_OBJECT, 0, 0 );

      for( i=0; i<NumPlaneTypes; ++i )
	 PlanePool[i] = new GlgDynArray( GlgObject.GLG_OBJECT, 0, 0 );

      TrajectoryPool = new GlgDynArray( GlgObject.GLG_OBJECT, 0, 0 );

      SetPlaneSize();
   }

   //////////////////////////////////////////////////////////////////////////
   // Invoked after the hierarchy setup.
   //////////////////////////////////////////////////////////////////////////
   public void VCallback( GlgObject viewport )
   {
      String message = "Loading map, please wait....";

      // Position icons before showing them.
      UpdateObjectsOnMap( message );
   }
   
   //////////////////////////////////////////////////////////////////////////
   // Starts updates
   //////////////////////////////////////////////////////////////////////////
   public void ReadyCallback( GlgObject viewport )
   {
      super.ReadyCallback();

      StartUpdates();
      IsReady = true;      
   }
   

   //////////////////////////////////////////////////////////////////////////
   // Reposition icons when a new map is displayed. 
   //////////////////////////////////////////////////////////////////////////
   public void UpdateObjectsOnMap( String message )
   {
      int i;

      // SetupHierarchy causes the new map to be generated if necessary, 
      // so display the wait message while the map is being generated.
      SetStatus( message );

      if( RedoIcons )      // Zoom or pan.
      {
	 DeleteNodes();
	 DeletePlanes();

	 HandleZoomLevel();
      }

      // Update the GIS object with new extent but don't draw it yet:
      // we want to update objects on the map first.
      Map.SetupHierarchy();

      for( i = 0; i < NumNodes; ++i )      // Position nodes
	 PositionNode( NodeArray[ i ], i );

      // Add before positioning planes to setup trajectories' history
      if( RedoIcons )
	 Map.AddObjectToBottom( TrajectoryGroup );

      for( i = 0; i < NumPlanes; ++i )     // Position planes
	 PositionPlane( PlaneArray[ i ], i );

      if( RedoIcons )
      {
	 Map.AddObjectToBottom( NodeGroup );
	 Map.AddObjectToBottom( PlaneGroup );
	 RedoIcons = false;
      }

      SetStatus( "" );
   }

   //////////////////////////////////////////////////////////////////////////
   // Set the node type depending on zoom level. Also change to rectangular
   // projection for high zooms.
   //////////////////////////////////////////////////////////////////////////
   void HandleZoomLevel()
   {
      GlgPoint extent = GetExtentDegrees();

      if( extent.x < 20. && extent.y < 20. )
      {
	 // High Zoom: use the most detailed icon.
	 NodeType = 1;
	 PlaneType = 2;         // Most detailed icon
	 HasAngle = true;       // Most detailed plane icons show angle
	 HasElevation = true;   // Most detailed plane icons show elevation
      }
      else if( extent.x < 70. && extent.y < 70. )
      {
	 // Zoom: use detailed icon 1 
	 NodeType = 1;
	 PlaneType = 1;         // Detailed icon 
	 HasAngle = true;       // Detailed plane icons show angle 
	 HasElevation = false;  
      }
      else
      {
	 // Whole world view 
	 NodeType = 1;          // City icons are always visible 
	 PlaneType = 0;         // Simple icon 
	 HasAngle = false;
	 HasElevation = false;
      }

      if( !OrthoOnly )
	 ChangeProjection( extent );
   }

   //////////////////////////////////////////////////////////////////////////
   // Change projection to rectangular for zoomed views, and back to 
   // orthographics for high-level views.
   //////////////////////////////////////////////////////////////////////////
   void ChangeProjection( GlgPoint extent )
   {
      GlgPoint new_extent;

      if( extent.x < 30. && extent.y < 30. )
      {
	 if( MapProjection == GlgObject.RECTANGULAR_PROJECTION )
	    return;    // Already rect, no change.

	 // Change to the rectangular projection
	 MapProjection = GlgObject.RECTANGULAR_PROJECTION;

	 GISObject.SetDResource( "GISProjection", 
				GlgObject.RECTANGULAR_PROJECTION );
	 // Set extent in degrees
	 GISObject.SetGResource( "GISExtent", extent );
      }
      else
      {
	 if( MapProjection == GlgObject.ORTHOGRAPHIC_PROJECTION )
	    return;    // Already ortho, no change

	 // Change to the orthographic projection
	 MapProjection = GlgObject.ORTHOGRAPHIC_PROJECTION;

	 GISObject.SetDResource( "GISProjection", 
				GlgObject.ORTHOGRAPHIC_PROJECTION );
      
	 // Set extent in meters
	 GISObject.SetGResource( "GISExtent", 
		      extent.x / 90. * GlgObject.EQUATOR_RADIUS,
		      extent.y / 90. * GlgObject.POLAR_RADIUS, 0. );
      }
   }

   //////////////////////////////////////////////////////////////////////////
   // Handle user interaction.
   //////////////////////////////////////////////////////////////////////////
   public void InputCallback( GlgObject viewport, GlgObject message_obj )
   {
      String
	origin,
	format,
	action,
	subaction;

      super.InputCallback( viewport, message_obj );

      origin = message_obj.GetSResource( "Origin" );
      format = message_obj.GetSResource( "Format" );
      action = message_obj.GetSResource( "Action" );
      subaction = message_obj.GetSResource( "SubAction" );

      // Handle window closing if run stand-alone
      if( format.equals( "Window" ) && action.equals( "DeleteWindow" ) )
      {
	 // Closing main window: exit.
	 System.exit( 0 );
      }

      if( format.equals( "Button" ) )
      {
	 if( !action.equals( "Activate" ) )
	    return;

	 PanMode = false;
	 AbortDistanceMode();
	 if( origin.equals( "CloseDialog" ) )
	 {
	    Drawing.SetDResource( "SelectionDialog/Visibility", 0. );
	    Drawing.Update();	 
	 }

	 else if( origin.equals( "ZoomIn" ) )
	    Zoom( 'i', 2. );
	 else if( origin.equals( "ZoomOut" ) )
	    Zoom( 'o', 2. );
	 else if( origin.equals( "ZoomReset" ) )
	 {	
	    Zoom( 'n', 0. );
	 }
	 else if( origin.equals( "ZoomTo" ) )
	 {
	    PanMode = false;       // Abort Pan mode
	    AbortDistanceMode();

	    Map.SetZoom( null, 't', 0. );  // Start Zoom op
	    SetStatus( "Define a rectangular area to zoom to." );
	 }
	 else if( origin.equals( "Pan" ) )
	 {	    
	    Map.SetZoom( null, 'e', 0. );  // Abort ZoomTo mode

	    PanMode = true;
	    SetStatus( "Click to define a new center." );
	 }
	 else if( origin.equals( "Nodes" ) )
	 {
	    ToggleResource( Map, "NodeGroup/Visibility" );
	 }
	 else if( origin.equals( "Planes" ) )
	 {
	    ToggleResource( Map, "PlaneGroup/Visibility" );
	 }
	 else if( origin.equals( "ValueDisplay" ) )
	 {
	    if( PlaneType == 0 )
	    {
	       viewport.Bell();
	       SetStatus( "Zoom in to see plane labels." );
	    }
	    else
	    {
	       // Visibility of all labels is constrained, set just one.
	       for( int i=1; i<NUM_PLANE_TYPES; ++i )
		  ToggleResource( PlaneTemplate[ i ], "Label/Visibility" );
	    }
	 }
	 else if( origin.equals( "ToggleMap" ) )
	 {
	    ToggleResource( GISObject, "Visibility" );	 
	 }
	 else if( origin.equals( "Update" ) )
	 {
	    DoUpdate = !DoUpdate;
	    if( DoUpdate )
	       StartUpdates();
	 }	
	 else if( origin.equals( "PlaneSize" ) )
	 {
	    if( PlaneType == 0 )
	    {
	       viewport.Bell();
	       SetStatus( "Zoom in to change plane size." );
	    }
	    else
	    {
	       // Change plane icon's size.
	       if( PlaneSize == SMALL_SIZE )
		  PlaneSize = MEDIUM_SIZE;
	       else if( PlaneSize == MEDIUM_SIZE )
		  PlaneSize = BIG_SIZE;
	       else // BIG_SIZE
		  PlaneSize = SMALL_SIZE;	 
	       
	       SetPlaneSize();
	    }	
	 }
	 else if( origin.equals( "CloseFlightInfo" ) )
	 {
	    SelectPlane( -1 ); // Unselect the plane and erase popup display.
	 }	
	 else if( origin.equals("Distance") )
	 {
	    AbortDistanceMode();  // Abort prev. distance mode if any

	    DistanceMode = true;
	    SetStatus( "Click on the map to define distance to measure, right click to finish." );
	 }	
      }
      else if( action.equals( "Zoom" ) && subaction.equals( "End" ) )
      {
	 // Update icon positions after zooming. 
	 RedoIcons = true;
	 UpdateObjectsOnMap( "Zooming, please wait..." );
	 Map.Update();
      }
      else if( format.equals( "CustomEvent" ) &&
	       action.equals( "MouseClick" ) )   // Mouse click on an icon
      {	
	 int zoom_mode, button_index;
	 String custom_event;

	 if( DistanceMode )
	    return;  // Ignore selection in the DistanceMode

	 zoom_mode = Map.GetDResource( "ZoomToMode" ).intValue();
	 if( zoom_mode != 0 )
	    return;  // Don't handle selection in ZoomTo mode. 

	 button_index =  message_obj.GetDResource( "ButtonIndex" ).intValue();
	 if( button_index != 1 )
	    return;    // Ignore middle and right mouse button clicks

	 custom_event = message_obj.GetSResource( "EventLabel" );
	 
	 if( custom_event.equals( "Plane" ) )  // Plane icon was selected
	 {
	    int plane_index;

	    // Get plane index 
	    plane_index = 
	      message_obj.GetDResource( "Object/DataIndex" ).intValue();
	    SelectPlane( plane_index );
	    
	    // Show message in the bottom
	    SetStatus( PlaneArray[ SelectedPlaneIndex ].tooltip );
	    
	    DisplayPlaneInfo();   // Display popup
	 }
      }
      Drawing.Update();
   }

   //////////////////////////////////////////////////////////////////////////
   // Used to obtain coordinates of the mouse click. 
   //////////////////////////////////////////////////////////////////////////
   public void TraceCallback( GlgObject viewport, GlgTraceData trace_info )
   {      
        GlgObject point_obj;
	int
	   width, height;
	
	if( trace_info.viewport != Map )
	   return;

	int event_type = trace_info.event.getID();
	switch( event_type )
	{
	    case MouseEvent.MOUSE_PRESSED:
	       if( GetButton( trace_info.event ) != 1 )
	       {
		  AbortDistanceMode();	 
		  return;  // Use the left button clicks only.
	       }

	       point.x = (double) ((MouseEvent)trace_info.event).getX();
	       point.y = (double) ((MouseEvent)trace_info.event).getY();

	       // Handle paning: set the new map center to the location of 
		 // the click.
	       if( PanMode )
	       {      
		  PanMode = false;
	 
		  // Converts X/Y to lat/lon using GIS object's current 
		    // projection.
		  GISObject.GISConvert( null, GlgObject.SCREEN_COORD,
					/* X/Y to Lat/Lon */ true,
					point, lat_lon );

		  // Pan the map
		  GISObject.SetGResource( "GISCenter", lat_lon );
		  RedoIcons = true;
		  UpdateObjectsOnMap( "Paning the map..." );
		  Map.Update();
	       }
	       else if( DistanceMode )
	       {	 
		  if( DistancePolygon == null )
		  {
		     DistancePolygon = new GlgPolygon( 2, null );
		     DistancePolygon.SetGResource( "EdgeColor", 1., 1., 0. );
		     NumDistancePoints = 1;

		     Map.ScreenToWorld( true, point, world_point );
		     
		     point_obj = (GlgObject) DistancePolygon.GetElement( 0 );
		     point_obj.SetGResource( null, world_point );

		     point_obj = (GlgObject) DistancePolygon.GetElement( 1 );
		     point_obj.SetGResource( null, world_point );

		     Map.AddObjectToBottom( DistancePolygon );
		     Map.Update();	    
		  }
		  else // Not the first point
		  {
		     // Set current point to the coord. of the click.
		     point_obj = (GlgObject)
		       DistancePolygon.GetElement( NumDistancePoints );
		     Map.ScreenToWorld( true, point, world_point );
		     point_obj.SetGResource( null, world_point );
		     ++NumDistancePoints;
		     
		     DisplayDistance( DistancePolygon );

		     // Add next point, same coords.
		     point_obj = point_obj.CopyObject();
		     DistancePolygon.AddObjectToBottom( point_obj );

		     Map.Update();
		  }
	       }
	       break;

	    case MouseEvent.MOUSE_MOVED:
	       if( DistanceMode && DistancePolygon != null )
	       {
		  point.x = (double) ((MouseEvent)trace_info.event).getX();
		  point.y = (double) ((MouseEvent)trace_info.event).getY();
		  point.z = 0;
		  	 
		  Map.ScreenToWorld( true, point, world_point );
		  point_obj = (GlgObject)
		    DistancePolygon.GetElement( NumDistancePoints );
		  point_obj.SetGResource( null, world_point );
		  DisplayDistance( DistancePolygon );
		  Map.Update();
	       }
	       break;

	     case ComponentEvent.COMPONENT_RESIZED:
		Component widget = (Component) Drawing.GetResource( "Widget" );
		width = widget.getSize().width;
		height = widget.getSize().height;

		if( width == window_width && height == window_height )
		   return;
		
		window_width = width;
		window_height = height;

		// Adjust icons to maintain X/Y ratio when the window is 
		  // resized.
		AdjustPlane(); 

		// No need to adjust icon positions if the GIS object has
		  // Stretch=YES
		break;

	    default:
	       return;
	}
   }

   //////////////////////////////////////////////////////////////////////////
   void AbortDistanceMode()
   {
      if( DistanceMode )
      {
	 if( DistancePolygon != null )   // Delete distance polygon
	 {
	    if( Map.ContainsObject( DistancePolygon ) )
	       Map.DeleteObject( DistancePolygon );
	    
	    DistancePolygon = null;
	 }
	 Map.SetDResource( "DistancePopup/Visibility", 0. );
	 SetStatus( "" );
	 DistanceMode = false;
      }
   }

   //////////////////////////////////////////////////////////////////////////
   void DisplayDistance( GlgObject polygon )
   {
      // Popup distance display
      Map.SetDResource( "DistancePopup/Visibility", 1. );
      
      // Last point is for dragging, not set yet - don't include.
      int size = polygon.GetSize();
      if( size < 2 )
	 return;
      
      double distance = 0.;
      GlgObject point = null;
      for( int i=0; i<size; ++i )
      {
	 GlgObject last_point = point;
	 point = (GlgObject) polygon.GetElement( i );
	    
	 if( last_point != null )
	    // Nautical mile = 1842m 
	    distance += GetGlobeDistance( point, last_point ) / 1842.;
      }
      
      Map.SetDResource( "DistancePopup/Distance", distance );
   }
   
   //////////////////////////////////////////////////////////////////////////
   // Returns ength (in meters) of a direct line connecting the two
   // points in 3D. Use more complex math for curves around the Earth.
   //////////////////////////////////////////////////////////////////////////
   double GetGlobeDistance( GlgObject point1_obj, GlgObject point2_obj )
   {
      GlgPoint point1, point2, lat_lon1, lat_lon2, globe_point1, globe_point2;
      
      point1 = point1_obj.GetGResource( null );
      point2 = point2_obj.GetGResource( null );
      
      lat_lon1 = GetLatLon( point1 );
      lat_lon2 = GetLatLon( point2 );
      
      /* XYZ of the first point, in meters */
      globe_point1 = GetPointXYZ( lat_lon1 );
      
      /* XYZ of the second point, in meters */
      globe_point2 = GetPointXYZ( lat_lon2 );
      
      double dx = globe_point1.x - globe_point2.x;
      double dy = globe_point1.y - globe_point2.y;
      double dz = globe_point1.z - globe_point2.z;

      return Math.sqrt( dx * dx + dy * dy + dz * dz );
   }

   //////////////////////////////////////////////////////////////////////////
   GlgPoint GetPointXYZ( GlgPoint lat_lon )
   {
      double
	 angle_x,
	 angle_y;
   
      GlgPoint xyz = new GlgPoint();

      // Place [0,0] at the math's x axis for simplicity. 
      
      angle_x = DegToRad( lat_lon.x );
      angle_y = DegToRad( lat_lon.y );
      
      xyz.x = 
	GlgObject.EQUATOR_RADIUS * Math.cos( angle_x ) * Math.cos( angle_y );
      xyz.y = GlgObject.EQUATOR_RADIUS * Math.sin( angle_y );
      xyz.z =
	GlgObject.EQUATOR_RADIUS * Math.sin( angle_x ) * Math.cos( angle_y );

      return xyz;
   }

   //////////////////////////////////////////////////////////////////////////
   // Convenience wrapper
   //////////////////////////////////////////////////////////////////////////
   GlgPoint GetLatLon( GlgPoint point_xy )
   {
 
      GlgPoint lat_lon = new GlgPoint();
      GISObject.GISConvert( null, GlgObject.OBJECT_COORD,
		     /* X/Y to Lat/Lon */ true,
		     point_xy, lat_lon );
      return lat_lon;
   }

   //////////////////////////////////////////////////////////////////////////
   void Zoom( char type, double value )
   {
      GlgPoint center, globe_center;

      switch( type )
      {
         default:
	    Map.SetZoom( null, type, value );
	    RedoIcons = true;
	    UpdateObjectsOnMap( "Zooming, please wait..." );
	    
	    break;

         case 'n':
	    // Reset map to the initial extent.
	    GISObject.SetDResource( "GISProjection",
			     (double) GlgObject.ORTHOGRAPHIC_PROJECTION );
	    GISObject.SetGResource( "GISCenter", InitCenter );
	    GISObject.SetGResource( "GISExtent", InitExtent );
	    MapProjection = GlgObject.ORTHOGRAPHIC_PROJECTION;
	    
	    RedoIcons = true;
	    UpdateObjectsOnMap( "Reloading map, please wait..." );

	    break;
      }
   }
  
   ////////////////////////////////////////////////////////////////////////
   // Changes plane color to indicate selection and displayes or erases the 
   // flight info popup dialog.
   ////////////////////////////////////////////////////////////////////////
   void SelectPlane( int selected_plane_index )
   {
      PlaneData plane;
      double popup_visibility;
      
      if( SelectedPlaneIndex != -1 )   // Unselect previously selected plane
      {
	 plane = PlaneArray[ SelectedPlaneIndex ];
	 if( plane.graphics != null )    // Restore color if plane is visible 
	    plane.graphics.SetDResource( "ColorIndex",
			     (double) plane.color_index );
      }
      
      if( selected_plane_index != -1 )   // Select new plane
      {
	 plane = PlaneArray[ selected_plane_index ];
	 if( plane.graphics != null ) // Set selected color if plane is visible
	    plane.graphics.SetDResource( "ColorIndex", (double) SELECTED );
      }
   
      // Display or erase the flight info popup.
      if( selected_plane_index == -1 )    // Unselected
	 popup_visibility = 0.;
      else   // Selected
	 popup_visibility = 1.;
      Drawing.SetDResource( "FlightInfoPopup/Visibility", popup_visibility );
      
      SelectedPlaneIndex = selected_plane_index;
   }

   ////////////////////////////////////////////////////////////////////////
   void DisplayPlaneInfo()
   {
      PlaneData plane = PlaneArray[ SelectedPlaneIndex ];
      Drawing.SetSResource( "FlightInfoPopup/FlightInfo", plane.tooltip );
      Drawing.SetDResource( "FlightInfoPopup/Elevation",
			    GetPlaneElevation( plane ) );
      Drawing.SetDResource( "FlightInfoPopup/StatusIndex", 
			   (double) plane.color_index );
      
      // Format numbers.
      NumberFormat nf = NumberFormat.getInstance();
      nf.setGroupingUsed( false );
      nf.setMinimumFractionDigits( 2 );
      nf.setMaximumFractionDigits( 4 );
      String lon_str = nf.format( Math.abs(plane.lat_lon.x) );
      String lat_str = nf.format( Math.abs(plane.lat_lon.y) );
      
      String buffer =  lon_str + (plane.lat_lon.x >= 0 ? "E" : "W") + 
	 " " + lat_str + (plane.lat_lon.x >= 0 ? "N" : "S");
      
      Drawing.SetSResource( "FlightInfoPopup/Location", buffer );
   }
   
   ////////////////////////////////////////////////////////////////////////
   // Delete node icons and place them into the object pool. 
   ////////////////////////////////////////////////////////////////////////
   void DeleteNodes()
   {
      GlgObject icon;
      int i;

      // Move node icons into the object pull 
      int size = NodeGroup.GetSize();
      for( i=0; i<size; ++i )
      {
	 icon = (GlgObject) NodeGroup.GetElement( i );
	 NodePool[ NodeType ].AddObjectToBottom( icon );
      }

      // Delete node icons from the drawing and node group 
      Map.DeleteObject( NodeGroup );
      for( i=0; i<size; ++i )
	 NodeGroup.DeleteBottomObject();
      
      // Set nodes' graphics to null 
      if( size > 0 )
	 for( i=0; i<NumNodes; ++i )
	    NodeArray[i].graphics = null;
   }

   ////////////////////////////////////////////////////////////////////////
   // Delete plane icons and place them into the object pool. 
   ////////////////////////////////////////////////////////////////////////
   void DeletePlanes()
   {
      GlgObject icon;
      int i;
          
      /* Move plane icons into the object pull */
      int size = PlaneGroup.GetSize();
      for( i=0; i<size; ++i )
      {
	 icon = (GlgObject) PlaneGroup.GetElement( i );
	 PlanePool[ PlaneType ].AddObjectToBottom( icon );
      }
      
      // Delete plane icons from the drawing and plane group 
      Map.DeleteObject( PlaneGroup );
      for( i=0; i<size; ++i )
	 PlaneGroup.DeleteBottomObject();
      
      // Set planes' graphics to null 
      if( size > 0 )
	 for( i=0; i<NumPlanes; ++i )
	    PlaneArray[i].graphics = null;
      
      DeleteTrajectories();
   }

   ////////////////////////////////////////////////////////////////////////
   // Delete trajectory objects and place them into the object pool. 
   ////////////////////////////////////////////////////////////////////////
   void DeleteTrajectories()
   {
      GlgObject icon;
      int i;

      // Move plane icons into the object pull
      int size = TrajectoryGroup.GetSize();
      for( i=0; i<size; ++i )
      {	
	 icon = (GlgObject) TrajectoryGroup.GetElement( i );
	 TrajectoryPool.AddObjectToBottom( icon );
      }
      
      // Delete trajectory icons from the drawing and trajectory group
      Map.DeleteObject( TrajectoryGroup );
      for( i=0; i<size; ++i )
	 TrajectoryGroup.DeleteBottomObject();
      
      // Set trajectorys' graphics to null
      if( size > 0 )
	 for( i=0; i<NumPlanes; ++i )
	    PlaneArray[i].trajectory = null;
   }

   ////////////////////////////////////////////////////////////////////////
   void PositionNode( NodeData node, int index )
   {
      // Converts node position from lat/lon to GLG coordinates.
      GetNodePosition( node );
      
      if( !IconVisible( node.xyz ) )
	 return;
      
      if( node.graphics == null )
	 AddNodeGraphics( node, NodeType, index );
      
      // Update node's icon in the drawing
      node.graphics.SetGResource( "Position", node.xyz );
   }

   ////////////////////////////////////////////////////////////////////////
   GlgObject CreateNodeIcon( int node_type )
   {
      GlgObject icon;
      
      int size = NodePool[ node_type ].GetSize();
      if( size > 0 )   // Return an icon from the pool
      {
	 icon = (GlgObject) NodePool[ node_type ].GetElement( size - 1 );
	 NodePool[ node_type ].DeleteBottomObject();
      }
      else   // Create a new icon
      {
	 icon = 
	   NodeTemplate[ node_type ].CloneObject( GlgObject.STRONG_CLONE );
      }
      return icon;
   }
   
   ////////////////////////////////////////////////////////////////////////
   GlgObject CreatePlaneIcon( int plane_type )
   {
      GlgObject icon;

      int size = PlanePool[ plane_type ].GetSize();
      if( size > 0 )   // Return an icon from the pool
      {
	 icon = (GlgObject) PlanePool[ plane_type ].GetElement( size - 1 );
	 PlanePool[ plane_type ].DeleteBottomObject();
      }
      else   // Create a new icon 
      {
	 icon = 
	   PlaneTemplate[ plane_type ].CloneObject( GlgObject.STRONG_CLONE );
      }
      return icon;
   }

   ////////////////////////////////////////////////////////////////////////
   GlgObject CreateTrajectoryIcon()
   {
      GlgObject icon;
      
      int size = TrajectoryPool.GetSize();
      if( size > 0 )   // Return an icon from the pool
      {
	 icon = (GlgObject) TrajectoryPool.GetElement( size - 1 );
	 TrajectoryPool.DeleteBottomObject();
      }
      else   // Create a new icon 
      {
	 icon = TrajectoryTemplate.CloneObject( GlgObject.STRONG_CLONE );
      }
      return icon;
   }

  ////////////////////////////////////////////////////////////////////////
   void PositionPlane( PlaneData plane, int index )
   {
      // Converts plane position (simulated or real data) from lat/lon to 
      // GLG coordinates.
      GetPlanePosition( plane );
      
      if( !IconVisible( plane.xyz ) )
      {
	 // Delete graphics and place into the pool
	 if( plane.graphics != null )
	 {
	    PlanePool[ PlaneType ].AddObjectToBottom( plane.graphics );
	    PlaneGroup.DeleteObject( plane.graphics );
	    plane.graphics = null;
	 }

	 // Delete trajectory and place into the pool
	 if( plane.trajectory != null )
	 {
	    TrajectoryPool.AddObjectToBottom( plane.trajectory );
	    TrajectoryGroup.DeleteObject( plane.trajectory );
	    plane.trajectory = null;
	 }
	 return;
      }

      if( plane.graphics == null  )
	 AddPlaneGraphics( plane, PlaneType, index );

      // Update plane's icon in the drawing
      plane.graphics.SetGResource( "Position", plane.xyz );
      
      // Update icon's direction angle is necessary
      if( HasAngle )
      {
	 plane.angle = GetPlaneAngle( plane );      
	 plane.graphics.SetDResource( "Angle", plane.angle );
      }

      if( HasElevation )
      {
	 plane.elevation = GetPlaneElevation( plane );      
	 plane.graphics.SetDResource( "Height", plane.elevation );
      }

      if( plane.trajectory != null )
      {
	 // For small speeds, skip a few iterations to increase the 
	 // trajectory's length
	 if( PlaneSpeed < 0.005 )  
	 {
	    Double n_d = new Double( 0.005 / PlaneSpeed );
	    int n = n_d.intValue();

	    if( n != 0 )
	    {
	       ++plane.iteration;
	       if( ( plane.iteration % n ) != 0 )
		  return;   // Skip n iterations, update every n'th
	    }
	 }      
      
	 plane.trajectory.SetDResource( "VisEntryPoint", 1. );
	 plane.trajectory.SetGResource( "XYEntryPoint", plane.xyz );
      }
   }
   
   ////////////////////////////////////////////////////////////////////////
   // Adds an airport icon, fills labels, tooltips, etc.
   ////////////////////////////////////////////////////////////////////////
   void AddNodeGraphics( NodeData node, int node_type, int index )
   {      
      GlgObject icon = CreateNodeIcon( node_type );
      
      // Index for direct access 
      icon.SetDResource( "DataIndex", (double)index );
      
      if( node_type > 0 )   // More detailed icon
	 icon.SetSResource( "LabelString", node.name );
      
      // Format numbers.
      NumberFormat nf = NumberFormat.getInstance();
      nf.setGroupingUsed( false );
      nf.setMinimumFractionDigits( 2 );
      nf.setMaximumFractionDigits( 4 );
      String lon_str = nf.format( Math.abs(node.lat_lon.x) );
      String lat_str = nf.format( Math.abs(node.lat_lon.y) );
      
      String tooltip = node.name + " lon= " + lon_str +
	              (node.lat_lon.x >= 0 ? "E" : "W") +
	              " lat= " + lat_str +
	              (node.lat_lon.y >= 0 ? "N" : "S");

      icon.SetSResource( "TooltipString", tooltip );
      
      node.graphics = icon;
      
      // The node will be positioned after the GIS object is setup.
      
      NodeGroup.AddObjectToBottom( icon );
   }

   ////////////////////////////////////////////////////////////////////////
   // Adds a plane icon, fills labels, tooltips, etc.
   ////////////////////////////////////////////////////////////////////////
   void AddPlaneGraphics( PlaneData plane, int plane_type, int index )
   {
      GlgObject icon = CreatePlaneIcon( plane_type );
      
      // Index for direct access
      icon.SetDResource( "DataIndex", (double)index );           
      
      // Icon color
      icon.SetDResource( "ColorIndex", (double) plane.color_index );
      
      if( plane_type > 0 )   // More detailed icon
      {
	 // Show the flight number as icon label
	 String label = "Flight " + plane.flight_number;
	 icon.SetSResource( "LabelString", label );
      }
      
      // Set the tooltip
      icon.SetSResource( "TooltipString", plane.tooltip );
      
      plane.graphics = icon;
      
      // The plane will be positioned after the GIS object is setup.
      // PositionPlane( plane, map );
      
      PlaneGroup.AddObjectToBottom( icon );
      
      if( plane_type == 2 )   // For detailed icon, create trajectory
      {
	 icon = CreateTrajectoryIcon();
	 plane.trajectory = icon;
	 
	 // Set entries invisible initially
	 icon.SetDResource( "Marker/Visibility", 0. );
	 
	 TrajectoryGroup.AddObjectToBottom( icon );
	 
	 for( int i=0; i<NumTrajectoryPoints; ++i )  // Set fading
	    icon.SetDResource( "BrightEntryPoint",
			     0.2 + 0.8 * i / (double) NumTrajectoryPoints );
      }
   }

   ////////////////////////////////////////////////////////////////////////
   // Check if the icon is visible in the current zoom region.
   ////////////////////////////////////////////////////////////////////////
   boolean IconVisible( GlgPoint position )
   {
      return position.z >= 0. &&
	 position.x > -1000. && position.x < 1000. &&
	 position.y > -1000. && position.y < 1000.;
   }

   ////////////////////////////////////////////////////////////////////////
   // Converts node's position from lat/lon to X/Y in GLG world coordinates.
   ////////////////////////////////////////////////////////////////////////
   void GetNodePosition( NodeData node )
   {
      // Converts lat/lon to X/Y using GIS object's current projection.
      GISObject.GISConvert( null, GlgObject.OBJECT_COORD,
			    /* Lat/Lon to XY */ false,
			    node.lat_lon, node.xyz );
   }

   ////////////////////////////////////////////////////////////////////////
   // Converts plane's position from lat/lon to X/Y in GLG world coordinates.
   ////////////////////////////////////////////////////////////////////////
   void GetPlanePosition( PlaneData plane )
   {
      // Gets the new plane position, simulated or from real data.
      GetPlaneLatLon( plane );    
      
      // Converts lat/lon to X/Y using GIS object's current projection.
      GISObject.GISConvert( null, GlgObject.OBJECT_COORD,
		     /* Lat/Lon to XY */ false,
		     plane.lat_lon, plane.xyz );
   }

   ////////////////////////////////////////////////////////////////////////
   // Compensate plane icons for X/Y stretch. Screen coord. extent may be 
   // used instead.
   ////////////////////////////////////////////////////////////////////////
   void AdjustPlane()
   {
      GlgObject
	 plane,
	 scale_x,
	 scale_y;
      double
	 wh_ratio,
	 ratio_half;
      
      for( int i=0; i<NUM_PLANE_TYPES; ++i )
      {
	 // Use template: all copies have scale factors constrained to it.
	 plane = PlaneTemplate[ i ];
	 scale_x = plane.GetResourceObject( "ScaleX" );
	 scale_y = plane.GetResourceObject( "ScaleY" );
	 
	 if( (scale_x != null) && (scale_y != null) )
	 {
	    wh_ratio = window_width / window_height;
	    if( wh_ratio > 1. )
	    {
	       ratio_half = Math.sqrt( wh_ratio );
	       
	       scale_y.SetDResource( null, ratio_half );
	       scale_x.SetDResource( null, 1. / ratio_half );
	    }
	    else
	    {
	       ratio_half = Math.sqrt( 1. / wh_ratio );
		  
	       scale_y.SetDResource( null, 1. / ratio_half );
	       scale_x.SetDResource( null, ratio_half );
	    }
	 }
      }
   }

   ////////////////////////////////////////////////////////////////////////
   // Displays a message in the status area.
   ////////////////////////////////////////////////////////////////////////
   void SetStatus( String message )
   {
      Drawing.SetSResource( "StatusLabel/String", message );
      Drawing.GetResourceObject("StatusArea").Update();
   }

   ////////////////////////////////////////////////////////////////////////
   void SetPlaneSize()
   {
      for( int i=0; i<NUM_PLANE_TYPES; ++i )
      {
	 GlgObject resource = PlaneTemplate[ i ].GetResourceObject( "Scale" );
	 if( resource != null )
	    resource.SetDResource( null, PlaneSize );
      }
   }

   ////////////////////////////////////////////////////////////////////////
   // Toggle resource between 0 and 1.
   ////////////////////////////////////////////////////////////////////////
   void ToggleResource( GlgObject object, String res_name )
   {
      GlgObject resource = object.GetResourceObject( res_name );
      if( resource == null )
	 return;
      
      double value = resource.GetDResource( null ).doubleValue();
      resource.SetDResource( null, value != 0. ? 0. : 1. );
   }

   ////////////////////////////////////////////////////////////////////////
   int GetButton( AWTEvent event )
   {
      if( ! ( event instanceof InputEvent ) )
	return 0;
      
      InputEvent input_event = (InputEvent) event;
      int modifiers = input_event.getModifiers();
      
      if( ( modifiers & InputEvent.BUTTON3_MASK ) != 0 )
	return 3;
      else if( ( modifiers & InputEvent.BUTTON2_MASK ) != 0 )
	return 2;
      else
	return 1;
   }

   ////////////////////////////////////////////////////////////////////////
   // Gets extent in lat/lon (converts from meters for ortho projection).
   ////////////////////////////////////////////////////////////////////////
   GlgPoint GetExtentDegrees()
   {   
      GlgPoint extent = GISObject.GetGResource( "GISExtent" );

      if( MapProjection == GlgObject.ORTHOGRAPHIC_PROJECTION )
      {
	 extent.x = extent.x / GlgObject.EQUATOR_RADIUS * 90.;
	 extent.y = extent.y / GlgObject.POLAR_RADIUS * 90.;
      }

      return extent;
   }

   //////////////////////////////////////////////////////////////////////////
   double Rand( double low, double high )
   {
      return low + ( high - low ) * Math.random();
   }

   //////////////////////////////////////////////////////////////////////////
   double RELATIVE_TO_NEW_RANGE( double low, double high, double rel_value )
   {
      return ( (low) + ((high) - (low)) * rel_value );
   }

   //////////////////////////////////////////////////////////////////////////
   double VALUE_TO_RELATIVE( double low, double high, double value )
   {
      return ( high - low != 0. ? ((value) - (low)) / ((high) - (low)) : 0. );
   }

   //////////////////////////////////////////////////////////////////////////
   double DegToRad( double angle )
   {
      return angle / 180. * Math.PI;
   }

   //////////////////////////////////////////////////////////////////////////
   double RadToDeg( double angle )
   {
      return angle / Math.PI * 180.;
   }

   //////////////////////////////////////////////////////////////////////////
   void error( String message_str, boolean quit )
   {
      System.out.println( message_str );
      if( quit )
	 System.exit( 0 );
   }

   //////////////////////////////////////////////////////////////////////////
   // UTILITY FUNCTION: Calculates an angle between the line defined by two 
   // points and the X axis.
   //////////////////////////////////////////////////////////////////////////
   double GetAngle( GlgPoint pt1, GlgPoint pt2 )
   {
      double length, angle;
      
      length = GetLength( pt1, pt2 );
      
      if( length == 0.  )
	 angle = 0.;
      else
      {
	 angle = Math.acos( ( pt2.x - pt1.x ) / length );
	 
	 if( pt2.y - pt1.y < 0. )  // ScreenSpace Z axis points to the user.
	    angle = - angle;
      }
        
      return RadToDeg( angle );
   }

   //////////////////////////////////////////////////////////////////////////
   // UTILITY FUNCTION: Calculates a distance between two points in 2D.
   //////////////////////////////////////////////////////////////////////////
   double GetLength( GlgPoint pt1, GlgPoint pt2 )
   {
      return Math.sqrt( ( pt2.x - pt1.x ) * ( pt2.x - pt1.x ) +
		   ( pt2.y - pt1.y ) * ( pt2.y - pt1.y ) );
   }

   //////////////////////////////////////////////////////////////////////////
   // SIMULATION ONLY: Calculates plane icon's directional angle.
   //////////////////////////////////////////////////////////////////////////
   double GetPlaneAngle( PlaneData plane )
   {
      GlgPoint last_lat_lon = new GlgPoint();
      double angle;
      
      if( MapProjection == GlgObject.RECTANGULAR_PROJECTION ||
	  plane.path_position == plane.path_position_last )   // Just started 
      {
	 // Rectangular projection preserves straight lines, we can use the 
	 // angle of the line connecting the start and end nodes. For the
	 // orthographic projection, use this case if the plane has just 
	 // started and there is no previous position stored.
	 angle =
	    GetAngle( plane.from_node.xyz, plane.to_node.xyz );
      }
      else  // In orthographic projection straight lines are drawn as curves.
	    // Use the angle of the line connecting the current and last 
	    // positions of the plane.
      {
	 double stored_position;
	    
	 stored_position = plane.path_position;    // Store current position.
	 
	 // Get the coordinates of the plane's previous position 
	 plane.path_position = plane.path_position_last;
	 GetPlaneLatLon( plane );
	 GISObject.GISConvert( null, GlgObject.OBJECT_COORD,
			/* Lat/Lon to XY */ false,
			plane.lat_lon, last_lat_lon );
      
	 // Get angle of a line connecting the previous and current position.
	 angle = GetAngle( last_lat_lon, plane.xyz );
	 
	 // Restore the plane's current position
	 plane.path_position = stored_position;
	 GetPlaneLatLon( plane );
      }   
      return angle;
   }

   ////////////////////////////////////////////////////////////////////////
   // SIMULATION ONLY: Calculates plane icon's elevation (zero at the start 
   // and end, max in the middle.
   ////////////////////////////////////////////////////////////////////////
   double GetPlaneElevation( PlaneData plane )
   {
      return ( 0.5 - Math.abs( plane.path_position - 0.5 ) ) * 2. * 10000.;   
   }
   
   ////////////////////////////////////////////////////////////////////////
   // SIMULATION ONLY: Performs one step of the simulation to move the planes.
   // Change this code to use real data.
   ////////////////////////////////////////////////////////////////////////
   void UpdatePlanes()
   {

      if( !DoUpdate )
	 return;
      
      for( int i = 0; i < NumPlanes; ++i )
	 UpdatePlane( PlaneArray[ i ], i );

      if( SelectedPlaneIndex != -1 )   // Update selected plane info if any 
	 DisplayPlaneInfo();

      Drawing.Update();
   }

   ////////////////////////////////////////////////////////////////////////
   // SIMULATION ONLY: Calculates new plane position.
   ////////////////////////////////////////////////////////////////////////
   void UpdatePlane( PlaneData plane, int index )
   {      

      if( (plane.from_node == null) || (plane.to_node == null) )
	 return;
            
      if( plane.path_position == 1. )  // Finished old path, start a new one.
      {
	 if( index == SelectedPlaneIndex )
	    SelectPlane( -1 );   // Unselect the plane: it reached destination

	 StartPlane( plane, false );
      }
      else
      {
	 double speed = PlaneSpeed;

	 // Store last position for calculating angle in ORTHO projection. 
	 plane.path_position_last = plane.path_position;

	 plane.path_position += plane.speed * speed;
	 if( plane.path_position > 1. )
	    plane.path_position = 1.;
      }

      SetPlaneColor( plane );

      PositionPlane( plane, index );   // Position plane on the map
   }

   ////////////////////////////////////////////////////////////////////////
   // SIMULATION ONLY: Simulate data to change plane color to show warnings 
   // and alarms.
   ////////////////////////////////////////////////////////////////////////
   void SetPlaneColor( PlaneData plane )
   {
      int new_color_index = NORMAL;
      
      // Set random color
      double random_value = Rand( 0., 1. );
      if( plane.color_index == NORMAL )
      {
	 if( random_value <= 0.999 )
	    new_color_index = NORMAL;
	 else if( random_value > 0.9999 )
	    new_color_index = ALARM;
	 else if( random_value > 0.999 )
	    new_color_index = WARNING;     
      }
      else if( plane.color_index == WARNING )
      {
	 if( random_value > 0.99 )
	    new_color_index = NORMAL;
	 else
	    new_color_index = plane.color_index;   // Keep alarm for a while
      }
      else if( plane.color_index == ALARM )
      {
	 if( random_value > 0.999 )
	    new_color_index = NORMAL;
	 else
	    new_color_index = plane.color_index;   // Keep alarm for a while
      }

      if( plane.graphics != null && 
	  new_color_index != plane.color_index )
	 plane.graphics.SetDResource( "ColorIndex", (double)new_color_index );
      
      plane.color_index = new_color_index;
   }

   ////////////////////////////////////////////////////////////////////////
   // SIMULATION ONLY: Starts simulation for a plane, selects its start 
   // and end nodes. 
   ////////////////////////////////////////////////////////////////////////
   void StartPlane( PlaneData plane, boolean init )
   {
      int
	 to_index,
	 from_index;
      
      if( NumNodes < 2 )
	 error( "Less then two nodes: can't start planes.", true );

      from_index = (int) Rand( 0., NumNodes - 0.001 );
      do
	 {
	    to_index = (int) Rand( 0., NumNodes - 0.001 );
	 } while( to_index == from_index );

      plane.from_node = NodeArray[ from_index ];
      plane.to_node = NodeArray[ to_index ];
      plane.flight_number = (int) Rand( 101., 1999. );
      plane.speed = Rand( 0.4, 1. );   // Vary plane speed 
      
      if( init )   // Init the demo: position randomly along the path 
      {
	 plane.path_position = Rand( 0.1, 0.9 );
	 plane.path_position_last = plane.path_position - 0.05;  // For angle
      }
      else         // Position at the beginning of the path 
      {
	 plane.path_position = 0.;
	 plane.path_position_last = 0.;
      }

      String flight_name = "Flight " + plane.flight_number;
      
      // Add from/to node info to the tooltip.
      plane.tooltip = flight_name + " from "  + 
	 plane.from_node.name + " to " +  plane.to_node.name;

      // Set all trajectory points invisible, if any 
      if( plane.trajectory != null )
	 plane.trajectory.SetDResource( "Marker%/Visibility", 0. );
   }

   ////////////////////////////////////////////////////////////////////////
   // SIMULATION ONLY: Calculates plane's lat/lon using simulated data. 
   //
   // The simulation moves the plane from the start to the end node/city
   // as controlled by the path_position parameter. The path_position changes
   // in the range from from 0 (start node) to 1 (end node).
   ////////////////////////////////////////////////////////////////////////
   void GetPlaneLatLon( PlaneData plane )
   {
      plane.lat_lon.x = 
	 RELATIVE_TO_NEW_RANGE( plane.from_node.lat_lon.x, 
			   plane.to_node.lat_lon.x, plane.path_position );
      plane.lat_lon.y = 
	 RELATIVE_TO_NEW_RANGE( plane.from_node.lat_lon.y, 
				plane.to_node.lat_lon.y, plane.path_position );
   }

   //////////////////////////////////////////////////////////////////////////
   // Stops updates
   //////////////////////////////////////////////////////////////////////////
   public void stop()
   {
      StopUpdates();

      IsReady = false;
      super.stop();
   }

   //////////////////////////////////////////////////////////////////////////
   void StopUpdates()
   {

      if( timer != null )
      {
	 timer.stop();
	 timer = null;
      }

   }

   //////////////////////////////////////////////////////////////////////////
   void StartUpdates()
   {

      if( timer == null )
      {
	 timer = new Timer( UpdateInterval, this );
	 timer.setRepeats( true );
	 timer.start();
      }

   }
      

   //////////////////////////////////////////////////////////////////////////
   // ActionListener method to use the bean as update timer's ActionListener.
   //////////////////////////////////////////////////////////////////////////
   public void actionPerformed( ActionEvent e )
   {
      if( timer != null )
	 UpdatePlanes();
   }




   class NodeData
   {
      String name;
      GlgPoint lat_lon;
      
      GlgObject graphics;
      GlgPoint xyz = new GlgPoint(); // Position in GLG world coords

      NodeData( String name_p, double lon, double lat )
      {
	 name = name_p;
	 lat_lon = new GlgPoint( lon, lat, 0. );
      }
   }
   
   class PlaneData
   {
      String name;
      GlgPoint lat_lon = new GlgPoint();
      int flight_number;
      String tooltip;
      GlgObject graphics;
      GlgObject trajectory;
      NodeData from_node;
      NodeData to_node;
      double path_position;
      double path_position_last;
      double speed;
      GlgPoint xyz = new GlgPoint();     // Position in GLG world coords  
      double angle;
      int has_angle;
      int color_index;
      double elevation;
      int iteration;

      PlaneData()
      {
      }
   }

}