public void Render(DrawArgs drawArgs)
		{
			// Render from bottom and up
			const int screenMargin = 10;
			m_renderPosition = new Vector2(drawArgs.screenWidth - HalfWidth - screenMargin, drawArgs.screenHeight - screenMargin);

			ImageAccessor logoAccessor = null;

			// Render download progress and rectangles
			for(int i=0; i < DrawArgs.DownloadQueue.ActiveDownloads.Count; i++)
			{
				DownloadRequest request = (DownloadRequest)DrawArgs.DownloadQueue.ActiveDownloads[i];
				GeoSpatialDownloadRequest geoRequest = request as GeoSpatialDownloadRequest;
				if(geoRequest == null)
					continue;

				RenderProgress(drawArgs, geoRequest);
				RenderRectangle(drawArgs, geoRequest);

				ImageTileRequest imageRequest = geoRequest as ImageTileRequest;
				if(imageRequest == null)
					continue;

				QuadTile qt = imageRequest.QuadTile;
				if(qt.QuadTileArgs.ImageAccessor.ServerLogoPath != null)
					logoAccessor = qt.QuadTileArgs.ImageAccessor;
			}

			if(logoAccessor != null)
				RenderLogo( drawArgs, logoAccessor );
		}

        /// <summary>
        /// Draws the progress bar
        /// </summary>
        /// <param name="x">Center X position of progress.</param>
        /// <param name="y">Center Y position of progress.</param>
        /// <param name="progress">Progress vale, in the range 0..1</param>
        public void Draw(DrawArgs drawArgs, float x, float y, float progress, int color)
        {
            if(x!=this.x || y!=this.y)
                Initalize(x,y);
            int barlength = (int)(progress * 2 * halfWidth);

            progressBar[0].X = x - halfWidth;
            progressBar[0].Y = y - halfHeight;
            progressBar[0].Color = color;
            progressBar[1].X = x - halfWidth;
            progressBar[1].Y = y + halfHeight;
            progressBar[1].Color = color;
            progressBar[2].X = x - halfWidth + barlength;
            progressBar[2].Y = y - halfHeight;
            progressBar[2].Color = color;
            progressBar[3].Y = y + halfHeight;
            progressBar[3].X = x - halfWidth + barlength;
            progressBar[3].Color = color;

            progressRight[0].X = x - halfWidth +barlength;
            progressRight[0].Y = y - halfHeight;
            progressRight[1].X = x - halfWidth + barlength;
            progressRight[1].Y = y + halfHeight;
            progressRight[2].X = x + halfWidth;
            progressRight[2].Y = y - halfHeight;
            progressRight[3].X = x + halfWidth;
            progressRight[3].Y = y + halfHeight;

            drawArgs.device.VertexFormat = CustomVertex.TransformedColored.Format;
            drawArgs.device.TextureState[0].ColorOperation = TextureOperation.Disable;
            drawArgs.device.DrawUserPrimitives(PrimitiveType.TriangleStrip, 2, progressBar);
            drawArgs.device.DrawUserPrimitives(PrimitiveType.TriangleStrip, 2, progressRight);
            drawArgs.device.DrawUserPrimitives(PrimitiveType.LineStrip, 4, progressBarOutline);
        }

		public override void Render(DrawArgs drawArgs)
		{
			if(!this._control.Visible)
			{
				this.SetPushed(false);
			}
		}

		public override void Initialize(DrawArgs drawArgs)
		{
			FileInfo boundaryFileInfo = new FileInfo(this._boundaryFilePath);
			if(!boundaryFileInfo.Exists)
			{
				this.isInitialized = true;
				return;
			}

			using( FileStream boundaryFileStream = boundaryFileInfo.OpenRead() )
			using( BinaryReader boundaryFileReader = new BinaryReader(boundaryFileStream, System.Text.Encoding.ASCII) ) {
				int numBoundaries = boundaryFileReader.ReadInt32();
				int count = boundaryFileReader.ReadInt32();
				this.vertices = new CustomVertex.PositionColored[count];

				for(int i = 0; i < count; i++) {
					double lat = boundaryFileReader.ReadDouble();
					double lon = boundaryFileReader.ReadDouble();
					Vector3 v = MathEngine.SphericalToCartesian((float)lat, (float)lon, (float)(this._parentWorld.EquatorialRadius + this._distanceAboveSurface));
					this.vertices[i].X = v.X;
					this.vertices[i].Y = v.Y;
					this.vertices[i].Z = v.Z;
					this.vertices[i].Color = this._color;
				}

			}
			this.isInitialized = true;
		}

 public override void Render(DrawArgs drawArgs)
 {
     if (!m_widget.Visible)
     {
         SetPushed(false);
     }
 }

		/// <summary>
		/// Plugin entry point 
		/// </summary>
		public override void Load() 
		{
			drawArgs = ParentApplication.WorldWindow.DrawArgs;
			DeviceList dl = Manager.GetDevices(DeviceClass.GameControl, EnumDevicesFlags.AttachedOnly);
			dl.MoveNext();
			if(dl.Current==null)
			{
				throw new ApplicationException("No joystick detected.  Please check your connections and verify your device appears in Control panel -> Game Controllers.");
			}
			DeviceInstance di = (DeviceInstance) dl.Current;
			joystick = new Device( di.InstanceGuid );
			joystick.SetDataFormat(DeviceDataFormat.Joystick);
			joystick.SetCooperativeLevel(ParentApplication,  
				CooperativeLevelFlags.NonExclusive | CooperativeLevelFlags.Background);
			foreach(DeviceObjectInstance d in joystick.Objects) 
			{
				// For axes that are returned, set the DIPROP_RANGE property for the
				// enumerated axis in order to scale min/max values.
				if((d.ObjectId & (int)DeviceObjectTypeFlags.Axis)!=0) 
				{
					// Set the AxisRange for the axis.
					joystick.Properties.SetRange(ParameterHow.ById, d.ObjectId, new InputRange(-AxisRange, AxisRange));
					joystick.Properties.SetDeadZone(ParameterHow.ById, d.ObjectId, 1000); // 10%
				}
			}

			joystick.Acquire();

			// Start a new thread to poll the joystick
			// TODO: The Device supports events, use them
			joyThread = new Thread( new ThreadStart(JoystickLoop) );
			joyThread.IsBackground = true;
			joyThread.Start();
		}

		/// <summary>
		/// This is where we do our rendering 
		/// Called from UI thread = UI code safe in this function
		/// </summary>
		public override void Render(DrawArgs drawArgs)
		{
			// Draw the current time using default font in lower right corner
			string text = DateTime.Now.ToString();
			Rectangle bounds = drawArgs.defaultDrawingFont.MeasureString(null, text, DrawTextFormat.None, 0);
			drawArgs.defaultDrawingFont.DrawText(null, text, 
				drawArgs.screenWidth-bounds.Width-distanceFromCorner, drawArgs.screenHeight-bounds.Height-distanceFromCorner,
				color );
		}

		public void Render(DrawArgs drawArgs)
		{
			// if we aren't active do nothing.
			if ((!m_visible) || (!m_enabled))
				return;

			for(int index = m_ChildWidgets.Count - 1; index >= 0; index--)
			{
				WorldWind.NewWidgets.IWidget currentWidget = m_ChildWidgets[index] as WorldWind.NewWidgets.IWidget;
				if(currentWidget != null)
				{
					if(currentWidget.ParentWidget == null || currentWidget.ParentWidget != this)
						currentWidget.ParentWidget = this;

					currentWidget.Render(drawArgs);
				}
			}
		}

		/// <summary>
		/// Renders the server logo
		/// </summary>
		/// <param name="logoAccessor"></param>
		protected void RenderLogo( DrawArgs drawArgs, ImageAccessor logoAccessor )
		{
			if(logoAccessor.ServerLogoPath == null)
				return;

			if(logoAccessor.ServerLogo == null)
			{
				if(!File.Exists(logoAccessor.ServerLogoPath))
					return;

				logoAccessor.ServerLogo = ImageHelper.LoadTexture(drawArgs.device, logoAccessor.ServerLogoPath);

				using(Surface s = logoAccessor.ServerLogo.GetSurfaceLevel(0))
				{
					SurfaceDescription desc = s.Description;
					logoAccessor.ServerLogoSize = new Rectangle(0, 0, desc.Width, desc.Height);
				}
			}

			if(m_sprite == null)
				m_sprite = new Sprite(drawArgs.device);

			float xScale = 2f * HalfWidth / logoAccessor.ServerLogoSize.Width;
			float yScale = 2f * HalfWidth / logoAccessor.ServerLogoSize.Height;

			m_renderPosition.Y -= HalfWidth;
			m_sprite.Begin(SpriteFlags.AlphaBlend);

			m_sprite.Transform = Matrix.Scaling(xScale,yScale,0);
			m_sprite.Transform *= Matrix.Translation(m_renderPosition.X, m_renderPosition.Y, 0);
			m_sprite.Draw( logoAccessor.ServerLogo,
				new Vector3(logoAccessor.ServerLogoSize.Width>>1, logoAccessor.ServerLogoSize.Height>>1, 0),
				Vector3.Empty,
				World.Settings.downloadLogoColor );

			m_sprite.End();
		}

 /// <summary>
 /// RenderableObject abstract member (needed)
 /// OBS: Worker thread (don't update UI directly from this thread)
 /// </summary>
 public override void Update(DrawArgs drawArgs)
 {
         if(!isInitialized)
                 Initialize(drawArgs);
 }

 // Recenter world projection in WW 1.4
 public void Recenter(DrawArgs drawArgs) {
         drawArgs.device.Transform.World *= Matrix.Translation(
                 (float)-drawArgs.WorldCamera.ReferenceCenter.X,
                 (float)-drawArgs.WorldCamera.ReferenceCenter.Y,
                 (float)-drawArgs.WorldCamera.ReferenceCenter.Z
                 );
 }

               public string presetFileName;           // preset file (will overide defaults)

               /// <summary>
               /// Constructor
               /// </summary>
               public SkyGradientLayer(string LayerName, string pluginPath, WorldWindow worldWindow) : base(LayerName)
               {
                       this.pluginPath = pluginPath;
                       this.pluginName = LayerName;
                       this.world = worldWindow.CurrentWorld;
                       this.settingsFileName = this.world.Name + ".ini";
                       this.drawArgs = worldWindow.DrawArgs;
                       //this.RenderPriority = RenderPriority.AtmosphericImages;
                       this.RenderPriority = RenderPriority.SurfaceImages;
                       ReadSettings();
               }

		private void DrawTrack(DrawArgs drawArgs)
		{
			UpdateTrackPositions(drawArgs);

			drawArgs.device.Transform.World = Matrix.Translation(
				(float)-drawArgs.WorldCamera.ReferenceCenter.X,
				(float)-drawArgs.WorldCamera.ReferenceCenter.Y,
				(float)-drawArgs.WorldCamera.ReferenceCenter.Z
				);

			drawArgs.device.RenderState.ZBufferEnable = false;
			drawArgs.device.TextureState[0].ColorOperation = TextureOperation.Disable;
			drawArgs.device.VertexFormat = CustomVertex.PositionColored.Format;
			drawArgs.device.DrawUserPrimitives(PrimitiveType.LineStrip, track.Length-1, track);
			drawArgs.device.RenderState.ZBufferEnable = true;

			drawArgs.device.Transform.World = drawArgs.WorldCamera.WorldMatrix;
		}

		private bool LoadMesh(DrawArgs drawArgs)
		{
			string LayerMeshFile =Path.Combine( meshFilePath,this.Name +".x");
			//Get the mesh, if exists, else load default file
			if(System.IO.File.Exists(LayerMeshFile))
			{//There is a mesh file for the satellite, load it.
				GraphicsStream adj;
				try
				{
					mesh = Mesh.FromFile(LayerMeshFile, MeshFlags.Managed, drawArgs.device, out adj, out materials );
				}
				catch(Exception caught)
				{
					Utility.Log.Write( caught );
					string msg = "Failed to read mesh from " + meshFilePath;
					System.Windows.Forms.MessageBox.Show( msg, this.name +" failed to load.", MessageBoxButtons.OK, MessageBoxIcon.Error);
					this.ParentList.IsOn = false;
					return false;
				}
				string textureFilePath = "";
				try
				{
					// Extract the material properties and texture names.
					meshTextures  = new Texture[materials.Length];
					meshMaterials = new Material[materials.Length];
					string xFilePath = Path.GetDirectoryName(LayerMeshFile);
					for(int i = 0; i < materials.Length; i++)
					{
						meshMaterials[i] = materials[i].Material3D;
						// Set the ambient color for the material (D3DX does not do this)
						meshMaterials[i].Ambient = meshMaterials[i].Diffuse;

						// Create the texture.
						if(materials[i].TextureFilename!=null)
						{
							textureFilePath = Path.Combine(xFilePath, materials[i].TextureFilename);
							meshTextures[i] = TextureLoader.FromFile(drawArgs.device, textureFilePath);
						}
					}

					isInitialized = true;
					isFirstRun = true;
					// Compute bounding box for a mesh.
					GraphicsStream vertexData;
					VertexBufferDescription description =
						mesh.VertexBuffer.Description;
					vertexData = mesh.VertexBuffer.Lock
						(0, 0, LockFlags.ReadOnly);
					Geometry.ComputeBoundingBox(vertexData,
						mesh.NumberVertices,description.VertexFormat,
						out meshBoundingBoxMinValue,
						out meshBoundingBoxMaxValue);
					mesh.VertexBuffer.Unlock();
					//Compute Path
					localmeshloaded = true;
				}
				catch(Exception caught)
				{
					Utility.Log.Write( caught );
					string msg = "Failed to read Texture from " + textureFilePath;
					System.Windows.Forms.MessageBox.Show( msg, this.name +" failed to load.", MessageBoxButtons.OK, MessageBoxIcon.Error);
					return false;
				}
			}
			else
			{
				//There is not a mesh file for the satellite, use the layer's mesh file
				this.meshBoundingBoxMinValue = ((SatelliteTrackerOverlay)this.ParentList).meshBoundingBoxMinValue;
				this.meshBoundingBoxMaxValue  = ((SatelliteTrackerOverlay)this.ParentList).meshBoundingBoxMaxValue;
				this.meshTextures = ((SatelliteTrackerOverlay)this.ParentList).meshTextures;
				this.meshMaterials = ((SatelliteTrackerOverlay)this.ParentList).meshMaterials;
				this.mesh = ((SatelliteTrackerOverlay)this.ParentList).mesh;
				localmeshloaded = false;
			}
			return true;
		}

		public override void Initialize(DrawArgs drawArgs)
		{
			if (isInitialized)
				return;
			try
			{
				orbit = new Orbit(this.TwoLineElement);
				timer = new System.Timers.Timer(10000);
				UpdateTrackPositions(drawArgs);
				timer.Elapsed+=new System.Timers.ElapsedEventHandler(timer_Elapsed);
				timer.Start();

			}
			catch(Exception caught)
			{
				Utility.Log.Write( caught );
				string msg = "Failed to read TLE from " + this.TwoLineElement.Name;
				throw new Exception( msg);
			}
			this.IsOn = LoadMesh(drawArgs);
			isInitialized = true;
		}

		/// <summary>
		/// This is where we do our rendering
		/// Called from UI thread = UI code safe in this function
		/// </summary>
		public override void Render(DrawArgs drawArgs)
		{
			if(!IsOn)
				return;
			if(!isInitialized)
				return;
			base.Render(drawArgs);
		}

		public override void Update(DrawArgs drawArgs)
		{
			try
			{
				if(!this.IsOn)
					return;

				if(!this.isInitialized)
					this.Initialize(drawArgs);


				foreach(RenderableObject ro in this.m_children)
				{
					if(ro.IsOn)
					{
						ro.Update(drawArgs);
					}
				}
			}
			catch(Exception ex)
			{
				System.Windows.Forms.MessageBox.Show(ex.Message);
				//Critical error, turn off layer
				this.IsOn=false;
				throw ex;
			}
			base.Update (drawArgs);
		}

		public void Initialize(DrawArgs drawArgs)
		{
			if (m_autoSize)
				ComputeAutoSize (drawArgs);
			m_isInitialized = true;
		}

		public void Render(DrawArgs drawArgs)
		{
			// if we aren't active do nothing.
			if ((!m_visible) || (!m_enabled))
				return;			

			if (!m_isInitialized)
				Initialize(drawArgs);

			drawArgs.defaultDrawingFont.DrawText(
				null,
				m_Text,
				new System.Drawing.Rectangle(AbsoluteLocation.X, AbsoluteLocation.Y, m_size.Width, m_size.Height),
				m_Format,
				m_ForeColor);

			if (m_clearOnRender)
			{
				m_Text = "";
				m_isInitialized = false;
			}
		}

		/// <summary>
		/// Updates the array track with the future positions of the satellite.  Called initially and then when the timer fires.
		/// </summary>
		/// <param name="drawArgs"></param>
		private void UpdateTrackPositions(DrawArgs drawArgs)
		{
			//Do not update the track every render, very CPU intensive.  Update after the timer sets UpdateTrack
			//to true.
			if(UpdateTrack)
			{
				periodMin = (int) orbit.Period()/60;
				track = new CustomVertex.PositionColored[periodMin*m_trackorbits];
				for(int i=0;i<track.Length;i++)
				{
					try
					{
						Eci e = orbit.getPosition(i+m_elapsedMinutes);
						CoordGeo cg = e.toGeo();
						Vector3 s = MathEngine.SphericalToCartesian(Angle.FromRadians(cg.Latitude ), Angle.FromRadians(cg.Longitude ),
							drawArgs.WorldCamera.WorldRadius + cg.Altitude *1000 );
						track[i].X = s.X;
						track[i].Y = s.Y;
						track[i].Z = s.Z;
						track[i].Color = m_orbitColor;
					}
					catch(Exception ex)
					{
						//Do not throw decayed orbit erroes.
						if(!ex.Message.Equals("Satellite orbit may have decayed"))
							throw ex;
					}
				}
				UpdateTrack = false;
			}
		}