VOID_HUD: HUD elements can now be repositioned, with configurables for
VOID_HUD: HUD elements can now be repositioned, with configurables for
position reset and locking.

--- a/VOID_DataValue.cs
+++ b/VOID_DataValue.cs
@@ -278,6 +278,7 @@
 	{
 		public VOID_DoubleValue(string Label, Func<double> ValueFunc, string Units) : base(Label, ValueFunc, Units) {}
 	}
+
 	public class VOID_FloatValue : VOID_NumValue<float>
 	{
 		public VOID_FloatValue(string Label, Func<float> ValueFunc, string Units) : base(Label, ValueFunc, Units) {}

--- a/VOID_HUD.cs
+++ b/VOID_HUD.cs
@@ -24,6 +24,7 @@
 using UnityEngine;
 using System;
 using System.Collections.Generic;
+using System.Text;
 
 namespace VOID
 {
@@ -33,9 +34,20 @@
 		 * Fields
 		 * */
 		[AVOID_SaveValue("colorIndex")]
-		protected VOID_SaveValue<int> _colorIndex = 0;
-
-		protected List<Color> textColors = new List<Color>();
+		protected VOID_SaveValue<int> _colorIndex;
+
+		protected List<Color> textColors;
+
+		protected Rect leftHUDdefaultPos;
+		protected Rect rightHUDdefaultPos;
+
+		[AVOID_SaveValue("leftHUDPos")]
+		protected VOID_SaveValue<Rect> leftHUDPos;
+		[AVOID_SaveValue("rightHUDPos")]
+		protected VOID_SaveValue<Rect> rightHUDPos;
+
+		[AVOID_SaveValue("positionsLocked")]
+		protected VOID_SaveValue<bool> positionsLocked;
 
 		/*
 		 * Properties
@@ -66,6 +78,10 @@
 			this._Name = "Heads-Up Display";
 
 			this._Active.value = true;
+
+			this._colorIndex = 0;
+
+			this.textColors = new List<Color>();
 
 			this.textColors.Add(Color.green);
 			this.textColors.Add(Color.black);
@@ -80,49 +96,114 @@
 			VOID_Core.Instance.LabelStyles["hud"] = new GUIStyle();
 			VOID_Core.Instance.LabelStyles["hud"].normal.textColor = this.textColors [this.ColorIndex];
 
+			this.leftHUDdefaultPos = new Rect(Screen.width * .2083f, 0f, 300f, 90f);
+			this.leftHUDPos = new Rect(this.leftHUDdefaultPos);
+
+			this.rightHUDdefaultPos = new Rect(Screen.width * .625f, 0f, 300f, 90f);
+			this.rightHUDPos = new Rect(this.rightHUDdefaultPos);
+
+			this.positionsLocked = true;
+
 			Tools.PostDebugMessage ("VOID_HUD: Constructed.");
 		}
 
+		protected void leftHUDWindow(int id)
+		{
+			StringBuilder leftHUD;
+
+			leftHUD = new StringBuilder();
+
+			if (VOID_Core.Instance.powerAvailable)
+			{
+				leftHUD.AppendFormat("Obt Alt: {0} Obt Vel: {1}",
+					VOID_Data.orbitAltitude.ToSIString(),
+					VOID_Data.orbitVelocity.ToSIString()
+				);
+				leftHUD.AppendFormat("\nAp: {0} ETA {1}",
+					VOID_Data.orbitApoAlt.ToSIString(),
+					VOID_Data.timeToApo.ValueUnitString()
+				);
+				leftHUD.AppendFormat("\nPe: {0} ETA {1}",
+					VOID_Data.oribtPeriAlt.ToSIString(),
+					VOID_Data.timeToPeri.ValueUnitString()
+				);
+				leftHUD.AppendFormat("\nInc: {0}", VOID_Data.orbitInclination.ValueUnitString("F3"));
+				leftHUD.AppendFormat("\nPrimary: {0}", VOID_Data.primaryName.ValueUnitString());
+
+				GUILayout.Label(leftHUD.ToString(), VOID_Core.Instance.LabelStyles["hud"], GUILayout.ExpandWidth(true));
+			}
+			else
+			{
+				leftHUD.Append(string.Intern("-- POWER LOST --"));
+			}
+
+			if (!this.positionsLocked)
+			{
+				GUI.DragWindow();
+			}
+		}
+
+		protected void rightHUDWindow(int id)
+		{
+			StringBuilder rightHUD;
+
+			rightHUD = new StringBuilder();
+
+			if (VOID_Core.Instance.powerAvailable)
+			{
+				rightHUD.AppendFormat("Srf Alt: {0} Srf Vel: {1}",
+					VOID_Data.trueAltitude.ToSIString(),
+					VOID_Data.surfVelocity.ToSIString()
+				);
+				rightHUD.AppendFormat("\nVer: {0} Hor: {1}",
+					VOID_Data.vertVelocity.ToSIString(),
+					VOID_Data.horzVelocity.ToSIString()
+				);
+				rightHUD.AppendFormat("\nLat: {0} Lon: {1}",
+					VOID_Data.surfLatitude.ValueUnitString(),
+					VOID_Data.surfLongitude.ValueUnitString()
+				);
+				rightHUD.AppendFormat("\nHdg: {0}", VOID_Data.vesselHeading.ValueUnitString());
+				rightHUD.AppendFormat("\nBiome: {0} Sit: {1}",
+					VOID_Data.currBiome.ValueUnitString(),
+					VOID_Data.expSituation.ValueUnitString()
+				);
+			}
+			else
+			{
+				rightHUD.Append(string.Intern("-- POWER LOST --"));
+			}
+
+
+			GUILayout.Label(rightHUD.ToString(), VOID_Core.Instance.LabelStyles["hud"], GUILayout.ExpandWidth(true));
+
+			if (!this.positionsLocked)
+			{
+				GUI.DragWindow();
+			}
+		}
+
 		public override void DrawGUI()
 		{
-			GUI.skin = VOID_Core.Instance.Skin;
-
-			if (VOID_Core.Instance.powerAvailable)
-			{
-				VOID_Core.Instance.LabelStyles["hud"].normal.textColor = textColors [ColorIndex];
-
-				GUI.Label (
-					new Rect ((Screen.width * .2083f), 0, 300f, 70f),
-					"Obt Alt: " + Tools.MuMech_ToSI (vessel.orbit.altitude) + "m" +
-					" Obt Vel: " + Tools.MuMech_ToSI (vessel.orbit.vel.magnitude) + "m/s" +
-					"\nAp: " + Tools.MuMech_ToSI (vessel.orbit.ApA) + "m" +
-					" ETA " + Tools.ConvertInterval (vessel.orbit.timeToAp) +
-					"\nPe: " + Tools.MuMech_ToSI (vessel.orbit.PeA) + "m" +
-					" ETA " + Tools.ConvertInterval (vessel.orbit.timeToPe) +
-					"\nInc: " + vessel.orbit.inclination.ToString ("F3") + "°" +
-					"\nPrimary: " + vessel.mainBody.bodyName,
-					VOID_Core.Instance.LabelStyles["hud"]);
-				// Toadicus edit: Added "Biome: " line to surf/atmo HUD
-				GUI.Label (
-					new Rect ((Screen.width * .625f), 0, 300f, 90f),
-					"Srf Alt: " + Tools.MuMech_ToSI (Tools.TrueAltitude (vessel)) + "m" +
-					" Srf Vel: " + Tools.MuMech_ToSI (vessel.srf_velocity.magnitude) + "m/s" +
-					"\nVer: " + Tools.MuMech_ToSI (vessel.verticalSpeed) + "m/s" +
-					" Hor: " + Tools.MuMech_ToSI (vessel.horizontalSrfSpeed) + "m/s" +
-					"\nLat: " + Tools.GetLatitudeString (vessel, "F3") +
-					" Lon: " + Tools.GetLongitudeString (vessel, "F3") +
-					"\nHdg: " + Tools.MuMech_get_heading (vessel).ToString ("F2") + "° " +
-					Tools.get_heading_text (Tools.MuMech_get_heading (vessel)) +
-					"\nBiome: " + Tools.Toadicus_GetAtt (vessel).name +
-					" Sit: " + vessel.GetExperimentSituation().HumanString(),
-					VOID_Core.Instance.LabelStyles["hud"]);
-			}
-			else
-			{
-				VOID_Core.Instance.LabelStyles["hud"].normal.textColor = Color.red;
-				GUI.Label (new Rect ((Screen.width * .2083f), 0, 300f, 70f), "-- POWER LOST --", VOID_Core.Instance.LabelStyles["hud"]);
-				GUI.Label (new Rect ((Screen.width * .625f), 0, 300f, 70f), "-- POWER LOST --", VOID_Core.Instance.LabelStyles["hud"]);
-			}
+			VOID_Core.Instance.LabelStyles["hud"].normal.textColor = textColors [ColorIndex];
+
+			// GUI.skin = VOID_Core.Instance.Skin;
+
+			this.leftHUDPos = GUI.Window(
+				VOID_Core.Instance.windowID,
+				this.leftHUDPos,
+				this.leftHUDWindow,
+				GUIContent.none,
+				GUIStyle.none
+			);
+
+			this.rightHUDPos = GUI.Window(
+				VOID_Core.Instance.windowID,
+				this.rightHUDPos,
+				this.leftHUDWindow,
+				GUIContent.none,
+				GUIStyle.none
+			);
 		}
 
 		public override void DrawConfigurables()
@@ -131,7 +212,25 @@
 			{
 				++this.ColorIndex;
 			}
-		}
+
+			if (GUILayout.Button("Reset HUD Positions", GUILayout.ExpandWidth(false)))
+			{
+				this.leftHUDPos = new Rect(this.leftHUDdefaultPos);
+				this.rightHUDPos = new Rect(this.rightHUDdefaultPos);
+			}
+
+			this.positionsLocked = GUILayout.Toggle(this.positionsLocked,
+				string.Intern("Lock HUD Positions"),
+				GUILayout.ExpandWidth(false));
+		}
+	}
+
+	public static partial class VOID_Data
+	{
+		public static VOID_StrValue expSituation = new VOID_StrValue(
+			"Situation",
+			new Func<string> (() => VOID_Core.Instance.vessel.GetExperimentSituation().HumanString())
+		);
 	}
 }
 

--- a/VOID_Module.cs
+++ b/VOID_Module.cs
@@ -199,39 +199,39 @@
 
 		public virtual void ModuleWindow(int _)
 		{
-			if (VOID_Core.Instance.updateTimer - this.lastUpdate > VOID_Core.Instance.updatePeriod) {
-				foreach (var fieldinfo in this.GetType().GetFields(
-					BindingFlags.Instance |
-					BindingFlags.NonPublic |
-					BindingFlags.Public |
-					BindingFlags.FlattenHierarchy
-				))
-				{
-					object field = null;
-
-					try
-					{
-						field = fieldinfo.GetValue (this);
-					}
-					catch (NullReferenceException) {
-						Tools.PostDebugMessage(string.Format(
-							"{0}: caught NullReferenceException, could not get value for field {1}.",
-							this.GetType().Name,
-							fieldinfo.Name
-						));
-					}
-
-					if (field == null) {
-						continue;
-					}
-
-					if (typeof(IVOID_DataValue).IsAssignableFrom (field.GetType ())) {
-						(field as IVOID_DataValue).Refresh ();
-					}
-				}
-
-				this.lastUpdate = VOID_Core.Instance.updateTimer;
-			}
+//			if (VOID_Core.Instance.updateTimer - this.lastUpdate > VOID_Core.Instance.updatePeriod) {
+//				foreach (var fieldinfo in this.GetType().GetFields(
+//					BindingFlags.Instance |
+//					BindingFlags.NonPublic |
+//					BindingFlags.Public |
+//					BindingFlags.FlattenHierarchy
+//				))
+//				{
+//					object field = null;
+//
+//					try
+//					{
+//						field = fieldinfo.GetValue (this);
+//					}
+//					catch (NullReferenceException) {
+//						Tools.PostDebugMessage(string.Format(
+//							"{0}: caught NullReferenceException, could not get value for field {1}.",
+//							this.GetType().Name,
+//							fieldinfo.Name
+//						));
+//					}
+//
+//					if (field == null) {
+//						continue;
+//					}
+//
+//					if (typeof(IVOID_DataValue).IsAssignableFrom (field.GetType ())) {
+//						(field as IVOID_DataValue).Refresh ();
+//					}
+//				}
+//
+//				this.lastUpdate = VOID_Core.Instance.updateTimer;
+//			}
 		}
 
 		public override void DrawGUI()

--- a/VOID_Orbital.cs
+++ b/VOID_Orbital.cs
@@ -33,197 +33,201 @@
 		protected long _precisionValues = 230584300921369395;
 		protected IntCollection precisionValues;
 
-		protected VOID_StrValue primaryName = new VOID_StrValue (
+		public VOID_Orbital()
+		{
+			this._Name = "Orbital Information";
+
+			this.WindowPos.x = Screen.width - 520f;
+			this.WindowPos.y = 250f;
+		}
+
+		public override void ModuleWindow(int _)
+		{
+			base.ModuleWindow (_);
+
+			int idx = 0;
+
+            GUILayout.BeginVertical();
+
+			VOID_Data.primaryName.DoGUIHorizontal ();
+
+			this.precisionValues [idx]= (ushort)VOID_Data.orbitAltitude.DoGUIHorizontal (this.precisionValues [idx]);
+			idx++;
+
+			this.precisionValues [idx]= (ushort)VOID_Data.orbitVelocity.DoGUIHorizontal (this.precisionValues [idx]);
+			idx++;
+
+			this.precisionValues [idx]= (ushort)VOID_Data.orbitApoAlt.DoGUIHorizontal (this.precisionValues [idx]);
+			idx++;
+
+			VOID_Data.timeToApo.DoGUIHorizontal();
+
+			this.precisionValues [idx]= (ushort)VOID_Data.oribtPeriAlt.DoGUIHorizontal (this.precisionValues [idx]);
+			idx++;
+
+			VOID_Data.timeToPeri.DoGUIHorizontal();
+
+			VOID_Data.orbitInclination.DoGUIHorizontal("F3");
+
+			this.precisionValues [idx]= (ushort)VOID_Data.gravityAccel.DoGUIHorizontal (this.precisionValues [idx]);
+			idx++;
+
+			this.toggleExtended.value = GUILayout.Toggle(this.toggleExtended, "Extended info");
+
+			if (this.toggleExtended)
+            {
+				VOID_Data.orbitPeriod.DoGUIHorizontal();
+
+				this.precisionValues [idx]= (ushort)VOID_Data.semiMajorAxis.DoGUIHorizontal (this.precisionValues [idx]);
+				idx++;
+
+				VOID_Data.eccentricity.DoGUIHorizontal("F4");
+
+				VOID_Data.meanAnomaly.DoGUIHorizontal("F3");
+
+				VOID_Data.trueAnomaly.DoGUIHorizontal("F3");
+
+				VOID_Data.eccAnomaly.DoGUIHorizontal("F3");
+
+				VOID_Data.longitudeAscNode.DoGUIHorizontal("F3");
+
+				VOID_Data.argumentPeriapsis.DoGUIHorizontal("F3");
+
+				VOID_Data.localSiderealLongitude.DoGUIHorizontal("F3");
+            }
+
+            GUILayout.EndVertical();
+            GUI.DragWindow();
+		}
+
+		public override void LoadConfig ()
+		{
+			base.LoadConfig ();
+
+			this.precisionValues = new IntCollection (4, this._precisionValues);
+		}
+
+		public override void _SaveToConfig (KSP.IO.PluginConfiguration config)
+		{
+			this._precisionValues = this.precisionValues.collection;
+
+			base._SaveToConfig (config);
+		}
+	}
+
+
+	public static partial class VOID_Data
+	{
+		public static VOID_StrValue primaryName = new VOID_StrValue (
 			VOIDLabels.void_primary,
 			new Func<string> (() => VOID_Core.Instance.vessel.mainBody.name)
 		);
 
-		protected VOID_DoubleValue orbitAltitude = new VOID_DoubleValue (
+		public static VOID_DoubleValue orbitAltitude = new VOID_DoubleValue (
 			"Altitude (ASL)",
 			new Func<double> (() => VOID_Core.Instance.vessel.orbit.altitude),
 			"m"
 		);
 
-		protected VOID_DoubleValue orbitVelocity = new VOID_DoubleValue (
+		public static VOID_DoubleValue orbitVelocity = new VOID_DoubleValue (
 			VOIDLabels.void_velocity,
 			new Func<double> (() => VOID_Core.Instance.vessel.orbit.vel.magnitude),
 			"m/s"
 		);
 
-		protected VOID_DoubleValue orbitApoAlt = new VOID_DoubleValue(
+		public static VOID_DoubleValue orbitApoAlt = new VOID_DoubleValue(
 			VOIDLabels.void_apoapsis,
 			new Func<double>(() => VOID_Core.Instance.vessel.orbit.ApA),
 			"m"
 		);
 
-		protected VOID_DoubleValue oribtPeriAlt = new VOID_DoubleValue(
+		public static VOID_DoubleValue oribtPeriAlt = new VOID_DoubleValue(
 			VOIDLabels.void_periapsis,
 			new Func<double>(() => VOID_Core.Instance.vessel.orbit.PeA),
 			"m"
 		);
 
-		protected VOID_StrValue timeToApo = new VOID_StrValue(
-		"Time to Apoapsis",
+		public static VOID_StrValue timeToApo = new VOID_StrValue(
+			"Time to Apoapsis",
 			new Func<string>(() => Tools.ConvertInterval(VOID_Core.Instance.vessel.orbit.timeToAp))
 		);
 
-		protected VOID_StrValue timeToPeri = new VOID_StrValue(
+		public static VOID_StrValue timeToPeri = new VOID_StrValue(
 			"Time to Periapsis",
 			new Func<string>(() => Tools.ConvertInterval(VOID_Core.Instance.vessel.orbit.timeToPe))
 		);
 
-		protected VOID_DoubleValue orbitInclination = new VOID_DoubleValue(
+		public static VOID_DoubleValue orbitInclination = new VOID_DoubleValue(
 			"Inclination",
 			new Func<double>(() => VOID_Core.Instance.vessel.orbit.inclination),
 			"°"
 		);
 
-		protected VOID_DoubleValue gravityAccel = new VOID_DoubleValue(
+		public static VOID_DoubleValue gravityAccel = new VOID_DoubleValue(
 			"Gravity",
 			delegate()
-			{
-				double orbitRadius = VOID_Core.Instance.vessel.mainBody.Radius +
+		{
+			double orbitRadius = VOID_Core.Instance.vessel.mainBody.Radius +
 				VOID_Core.Instance.vessel.mainBody.GetAltitude(VOID_Core.Instance.vessel.findWorldCenterOfMass());
-				return (VOID_Core.Constant_G * VOID_Core.Instance.vessel.mainBody.Mass) /
+			return (VOID_Core.Constant_G * VOID_Core.Instance.vessel.mainBody.Mass) /
 				Math.Pow(orbitRadius, 2);
-			},
+		},
 			"m/s²"
 		);
 
-		protected VOID_StrValue orbitPeriod = new VOID_StrValue(
+		public static VOID_StrValue orbitPeriod = new VOID_StrValue(
 			"Period",
-			 new Func<string>(() => Tools.ConvertInterval(VOID_Core.Instance.vessel.orbit.period))
-		);
-
-		protected VOID_DoubleValue semiMajorAxis = new VOID_DoubleValue(
+			new Func<string>(() => Tools.ConvertInterval(VOID_Core.Instance.vessel.orbit.period))
+		);
+
+		public static VOID_DoubleValue semiMajorAxis = new VOID_DoubleValue(
 			"Semi-Major Axis",
 			new Func<double>(() => VOID_Core.Instance.vessel.orbit.semiMajorAxis),
 			"m"
 		);
 
-		protected VOID_DoubleValue eccentricity = new VOID_DoubleValue(
+		public static VOID_DoubleValue eccentricity = new VOID_DoubleValue(
 			"Eccentricity",
 			new Func<double>(() => VOID_Core.Instance.vessel.orbit.eccentricity),
 			""
 		);
 
-		protected VOID_DoubleValue meanAnomaly = new VOID_DoubleValue(
+		public static VOID_DoubleValue meanAnomaly = new VOID_DoubleValue(
 			"Mean Anomaly",
 			new Func<double>(() => VOID_Core.Instance.vessel.orbit.meanAnomaly * 180d / Math.PI),
 			"°"
 		);
 
-		protected VOID_DoubleValue trueAnomaly = new VOID_DoubleValue(
+		public static VOID_DoubleValue trueAnomaly = new VOID_DoubleValue(
 			"True Anomaly",
 			new Func<double>(() => VOID_Core.Instance.vessel.orbit.trueAnomaly),
 			"°"
 		);
 
-		protected VOID_DoubleValue eccAnomaly = new VOID_DoubleValue(
-		"Eccentric Anomaly",
+		public static VOID_DoubleValue eccAnomaly = new VOID_DoubleValue(
+			"Eccentric Anomaly",
 			new Func<double>(() => VOID_Core.Instance.vessel.orbit.eccentricAnomaly * 180d / Math.PI),
 			"°"
 		);
 
-		protected VOID_DoubleValue longitudeAscNode = new VOID_DoubleValue(
+		public static VOID_DoubleValue longitudeAscNode = new VOID_DoubleValue(
 			"Long. Ascending Node",
 			new Func<double>(() => VOID_Core.Instance.vessel.orbit.LAN),
 			"°"
 		);
 
-		protected VOID_DoubleValue argumentPeriapsis = new VOID_DoubleValue(
+		public static VOID_DoubleValue argumentPeriapsis = new VOID_DoubleValue(
 			"Argument of Periapsis",
 			new Func<double>(() => VOID_Core.Instance.vessel.orbit.argumentOfPeriapsis),
 			"°"
-	    );
-
-		protected VOID_DoubleValue localSiderealLongitude = new VOID_DoubleValue(
+		);
+
+		public static VOID_DoubleValue localSiderealLongitude = new VOID_DoubleValue(
 			"Local Sidereal Longitude",
 			new Func<double>(() => Tools.FixDegreeDomain(
 				VOID_Core.Instance.vessel.longitude + VOID_Core.Instance.vessel.orbit.referenceBody.rotationAngle)),
 			"°"
 		);
-
-		public VOID_Orbital()
-		{
-			this._Name = "Orbital Information";
-
-			this.WindowPos.x = Screen.width - 520f;
-			this.WindowPos.y = 250f;
-		}
-
-		public override void ModuleWindow(int _)
-		{
-			base.ModuleWindow (_);
-
-			int idx = 0;
-
-            GUILayout.BeginVertical();
-
-			this.primaryName.DoGUIHorizontal ();
-
-			this.precisionValues [idx]= (ushort)this.orbitAltitude.DoGUIHorizontal (this.precisionValues [idx]);
-			idx++;
-
-			this.precisionValues [idx]= (ushort)this.orbitVelocity.DoGUIHorizontal (this.precisionValues [idx]);
-			idx++;
-
-			this.precisionValues [idx]= (ushort)this.orbitApoAlt.DoGUIHorizontal (this.precisionValues [idx]);
-			idx++;
-
-			this.timeToApo.DoGUIHorizontal();
-
-			this.precisionValues [idx]= (ushort)this.oribtPeriAlt.DoGUIHorizontal (this.precisionValues [idx]);
-			idx++;
-
-			this.timeToPeri.DoGUIHorizontal();
-
-			this.orbitInclination.DoGUIHorizontal("F3");
-
-			this.precisionValues [idx]= (ushort)this.gravityAccel.DoGUIHorizontal (this.precisionValues [idx]);
-			idx++;
-
-			this.toggleExtended.value = GUILayout.Toggle(this.toggleExtended, "Extended info");
-
-			if (this.toggleExtended)
-            {
-				this.orbitPeriod.DoGUIHorizontal();
-
-				this.precisionValues [idx]= (ushort)this.semiMajorAxis.DoGUIHorizontal (this.precisionValues [idx]);
-				idx++;
-
-				this.eccentricity.DoGUIHorizontal("F4");
-
-				this.meanAnomaly.DoGUIHorizontal("F3");
-
-				this.trueAnomaly.DoGUIHorizontal("F3");
-
-				this.eccAnomaly.DoGUIHorizontal("F3");
-
-				this.longitudeAscNode.DoGUIHorizontal("F3");
-
-				this.argumentPeriapsis.DoGUIHorizontal("F3");
-
-				this.localSiderealLongitude.DoGUIHorizontal("F3");
-            }
-
-            GUILayout.EndVertical();
-            GUI.DragWindow();
-		}
-
-		public override void LoadConfig ()
-		{
-			base.LoadConfig ();
-
-			this.precisionValues = new IntCollection (4, this._precisionValues);
-		}
-
-		public override void _SaveToConfig (KSP.IO.PluginConfiguration config)
-		{
-			this._precisionValues = this.precisionValues.collection;
-
-			base._SaveToConfig (config);
-		}
 	}
 }
 

--- a/VOID_SurfAtmo.cs
+++ b/VOID_SurfAtmo.cs
@@ -30,98 +30,6 @@
 		protected long _precisionValues = 230584300921369395;
 		protected IntCollection precisionValues;
 
-		protected VOID_DoubleValue trueAltitude = new VOID_DoubleValue(
-			"Altitude (true)",
-			delegate()
-			{
-				double alt_true = VOID_Core.Instance.vessel.orbit.altitude - VOID_Core.Instance.vessel.terrainAltitude;
-				// HACK: This assumes that on worlds with oceans, all water is fixed at 0 m,
-				// and water covers the whole surface at 0 m.
-				if (VOID_Core.Instance.vessel.terrainAltitude < 0 && VOID_Core.Instance.vessel.mainBody.ocean )
-					alt_true = VOID_Core.Instance.vessel.orbit.altitude;
-				return alt_true;
-			},
-			"m"
-		);
-
-		protected VOID_StrValue surfLatitude = new VOID_StrValue(
-			"Latitude",
-			new Func<string> (() => Tools.GetLatitudeString(VOID_Core.Instance.vessel))
-		);
-
-		protected VOID_StrValue surfLongitude = new VOID_StrValue(
-			"Longitude",
-			new Func<string> (() => Tools.GetLongitudeString(VOID_Core.Instance.vessel))
-		);
-
-		protected VOID_StrValue vesselHeading = new VOID_StrValue(
-			"Heading",
-			delegate()
-			{
-				double heading = Tools.MuMech_get_heading(VOID_Core.Instance.vessel);
-				string cardinal = Tools.get_heading_text(heading);
-
-				return string.Format(
-					"{0}° {1}",
-					heading.ToString("F2"),
-					cardinal
-				);
-			}
-		);
-
-		protected VOID_DoubleValue terrainElevation = new VOID_DoubleValue(
-			"Terrain elevation",
-			new Func<double> (() => VOID_Core.Instance.vessel.terrainAltitude),
-			"m"
-		);
-
-		protected VOID_DoubleValue surfVelocity = new VOID_DoubleValue(
-			"Surface velocity",
-			new Func<double> (() => VOID_Core.Instance.vessel.srf_velocity.magnitude),
-			"m/s"
-		);
-
-		protected VOID_DoubleValue vertVelocity = new VOID_DoubleValue(
-			"Vertical speed",
-			new Func<double> (() => VOID_Core.Instance.vessel.verticalSpeed),
-			"m/s"
-		);
-
-		protected VOID_DoubleValue horzVelocity = new VOID_DoubleValue(
-			"Horizontal speed",
-			new Func<double> (() => VOID_Core.Instance.vessel.horizontalSrfSpeed),
-			"m/s"
-		);
-
-		protected VOID_FloatValue temperature = new VOID_FloatValue(
-			"Temperature",
-			new Func<float> (() => VOID_Core.Instance.vessel.flightIntegrator.getExternalTemperature()),
-			"°C"
-		);
-
-		protected VOID_DoubleValue atmDensity = new VOID_DoubleValue (
-			"Atmosphere Density",
-			new Func<double> (() => VOID_Core.Instance.vessel.atmDensity * 1000f),
-			"g/m³"
-		);
-
-		protected VOID_DoubleValue atmPressure = new VOID_DoubleValue (
-			"Pressure",
-			new Func<double> (() => VOID_Core.Instance.vessel.staticPressure),
-			"atm"
-		);
-
-		protected VOID_FloatValue atmLimit = new VOID_FloatValue(
-			"Atmosphere Limit",
-			new Func<float> (() => VOID_Core.Instance.vessel.mainBody.maxAtmosphereAltitude),
-			"m"
-		);
-
-		protected VOID_StrValue currBiome = new VOID_StrValue(
-			"Biome",
-			new Func<string> (() => Tools.Toadicus_GetAtt(VOID_Core.Instance.vessel).name)
-		);
-
 		public VOID_SurfAtmo()
 		{
 			this._Name = "Surface & Atmospheric Information";
@@ -138,38 +46,38 @@
 
 			GUILayout.BeginVertical();
 
-			this.precisionValues [idx]= (ushort)this.trueAltitude.DoGUIHorizontal (this.precisionValues [idx]);
+			this.precisionValues [idx]= (ushort)VOID_Data.trueAltitude.DoGUIHorizontal (this.precisionValues [idx]);
 			idx++;
 
-			this.surfLatitude.DoGUIHorizontal ();
+			VOID_Data.surfLatitude.DoGUIHorizontal ();
 
-			this.surfLongitude.DoGUIHorizontal ();
+			VOID_Data.surfLongitude.DoGUIHorizontal ();
 
-			this.vesselHeading.DoGUIHorizontal ();
+			VOID_Data.vesselHeading.DoGUIHorizontal ();
 
-			this.precisionValues [idx]= (ushort)this.terrainElevation.DoGUIHorizontal (this.precisionValues [idx]);
+			this.precisionValues [idx]= (ushort)VOID_Data.terrainElevation.DoGUIHorizontal (this.precisionValues [idx]);
 			idx++;
 
-			this.precisionValues [idx]= (ushort)this.surfVelocity.DoGUIHorizontal (this.precisionValues [idx]);
+			this.precisionValues [idx]= (ushort)VOID_Data.surfVelocity.DoGUIHorizontal (this.precisionValues [idx]);
 			idx++;
 
-			this.precisionValues [idx]= (ushort)this.vertVelocity.DoGUIHorizontal (this.precisionValues [idx]);
+			this.precisionValues [idx]= (ushort)VOID_Data.vertVelocity.DoGUIHorizontal (this.precisionValues [idx]);
 			idx++;
 
-			this.precisionValues [idx]= (ushort)this.horzVelocity.DoGUIHorizontal (this.precisionValues [idx]);
+			this.precisionValues [idx]= (ushort)VOID_Data.horzVelocity.DoGUIHorizontal (this.precisionValues [idx]);
 			idx++;
 
-			this.temperature.DoGUIHorizontal ("F2");
+			VOID_Data.temperature.DoGUIHorizontal ("F2");
 
-			this.atmDensity.DoGUIHorizontal (3);
+			VOID_Data.atmDensity.DoGUIHorizontal (3);
 
-			this.atmPressure.DoGUIHorizontal ("F2");
+			VOID_Data.atmPressure.DoGUIHorizontal ("F2");
 
-			this.precisionValues [idx]= (ushort)this.atmLimit.DoGUIHorizontal (this.precisionValues [idx]);
+			this.precisionValues [idx]= (ushort)VOID_Data.atmLimit.DoGUIHorizontal (this.precisionValues [idx]);
 			idx++;
 
 			// Toadicus edit: added Biome
-			this.currBiome.DoGUIHorizontal ();
+			VOID_Data.currBiome.DoGUIHorizontal ();
 
 			GUILayout.EndVertical();
 			GUI.DragWindow();
@@ -189,4 +97,100 @@
 			base._SaveToConfig (config);
 		}
 	}
+
+	public static partial class VOID_Data
+	{
+		public static VOID_DoubleValue trueAltitude = new VOID_DoubleValue(
+			"Altitude (true)",
+			delegate()
+			{
+				double alt_true = VOID_Core.Instance.vessel.orbit.altitude - VOID_Core.Instance.vessel.terrainAltitude;
+				// HACK: This assumes that on worlds with oceans, all water is fixed at 0 m,
+				// and water covers the whole surface at 0 m.
+				if (VOID_Core.Instance.vessel.terrainAltitude < 0 && VOID_Core.Instance.vessel.mainBody.ocean )
+					alt_true = VOID_Core.Instance.vessel.orbit.altitude;
+				return alt_true;
+			},
+			"m"
+		);
+
+		public static VOID_StrValue surfLatitude = new VOID_StrValue(
+			"Latitude",
+			new Func<string> (() => Tools.GetLatitudeString(VOID_Core.Instance.vessel))
+		);
+
+		public static VOID_StrValue surfLongitude = new VOID_StrValue(
+			"Longitude",
+			new Func<string> (() => Tools.GetLongitudeString(VOID_Core.Instance.vessel))
+		);
+
+		public static VOID_StrValue vesselHeading = new VOID_StrValue(
+			"Heading",
+			delegate()
+		{
+			double heading = Tools.MuMech_get_heading(VOID_Core.Instance.vessel);
+			string cardinal = Tools.get_heading_text(heading);
+
+			return string.Format(
+				"{0}° {1}",
+				heading.ToString("F2"),
+				cardinal
+			);
+		}
+		);
+
+		public static VOID_DoubleValue terrainElevation = new VOID_DoubleValue(
+			"Terrain elevation",
+			new Func<double> (() => VOID_Core.Instance.vessel.terrainAltitude),
+			"m"
+		);
+
+		public static VOID_DoubleValue surfVelocity = new VOID_DoubleValue(
+			"Surface velocity",
+			new Func<double> (() => VOID_Core.Instance.vessel.srf_velocity.magnitude),
+			"m/s"
+		);
+
+		public static VOID_DoubleValue vertVelocity = new VOID_DoubleValue(
+			"Vertical speed",
+			new Func<double> (() => VOID_Core.Instance.vessel.verticalSpeed),
+			"m/s"
+		);
+
+		public static VOID_DoubleValue horzVelocity = new VOID_DoubleValue(
+			"Horizontal speed",
+			new Func<double> (() => VOID_Core.Instance.vessel.horizontalSrfSpeed),
+			"m/s"
+		);
+
+		public static VOID_FloatValue temperature = new VOID_FloatValue(
+			"Temperature",
+			new Func<float> (() => VOID_Core.Instance.vessel.flightIntegrator.getExternalTemperature()),
+			"°C"
+		);
+
+		public static VOID_DoubleValue atmDensity = new VOID_DoubleValue (
+			"Atmosphere Density",
+			new Func<double> (() => VOID_Core.Instance.vessel.atmDensity * 1000f),
+			"g/m³"
+		);
+
+		public static VOID_DoubleValue atmPressure = new VOID_DoubleValue (
+			"Pressure",
+			new Func<double> (() => VOID_Core.Instance.vessel.staticPressure),
+			"atm"
+		);
+
+		public static VOID_FloatValue atmLimit = new VOID_FloatValue(
+			"Atmosphere Limit",
+			new Func<float> (() => VOID_Core.Instance.vessel.mainBody.maxAtmosphereAltitude),
+			"m"
+		);
+
+		public static VOID_StrValue currBiome = new VOID_StrValue(
+			"Biome",
+			new Func<string> (() => Tools.Toadicus_GetAtt(VOID_Core.Instance.vessel).name)
+		);
+
+	}
 }

--- a/VOID_VesselInfo.cs
+++ b/VOID_VesselInfo.cs
@@ -29,25 +29,105 @@
 {
 	public class VOID_VesselInfo : VOID_WindowModule
 	{
-		protected VOID_DoubleValue geeForce = new VOID_DoubleValue(
+		public VOID_VesselInfo() : base()
+		{
+			this._Name = "Vessel Information";
+
+			this.WindowPos.x = Screen.width - 260;
+			this.WindowPos.y = 450;
+		}
+
+		public override void ModuleWindow(int _)
+		{
+			base.ModuleWindow (_);
+
+			if ((TimeWarp.WarpMode == TimeWarp.Modes.LOW) || (TimeWarp.CurrentRate <= TimeWarp.MaxPhysicsRate))
+			{
+				SimManager.Instance.RequestSimulation();
+			}
+
+			GUILayout.BeginVertical();
+
+			GUILayout.Label(
+				vessel.vesselName,
+				VOID_Core.Instance.LabelStyles["center_bold"],
+				GUILayout.ExpandWidth(true));
+
+			Tools.PostDebugMessage("Starting VesselInfo window.");
+
+			VOID_Data.geeForce.DoGUIHorizontal ("F2");
+
+			Tools.PostDebugMessage("GeeForce done.");
+
+			VOID_Data.partCount.DoGUIHorizontal ();
+
+			Tools.PostDebugMessage("PartCount done.");
+
+			VOID_Data.totalMass.DoGUIHorizontal ("F1");
+
+			Tools.PostDebugMessage("TotalMass done.");
+
+			VOID_Data.resourceMass.DoGUIHorizontal ("F1");
+
+			Tools.PostDebugMessage("ResourceMass done.");
+
+			VOID_Data.stageDeltaV.DoGUIHorizontal (3, false);
+
+			Tools.PostDebugMessage("Stage deltaV done.");
+
+			VOID_Data.totalDeltaV.DoGUIHorizontal (3, false);
+
+			Tools.PostDebugMessage("Total deltaV done.");
+
+			VOID_Data.mainThrottle.DoGUIHorizontal ("F0");
+
+			Tools.PostDebugMessage("MainThrottle done.");
+
+			VOID_Data.currmaxThrust.DoGUIHorizontal ();
+
+			Tools.PostDebugMessage("CurrMaxThrust done.");
+
+			VOID_Data.currmaxThrustWeight.DoGUIHorizontal ();
+
+			Tools.PostDebugMessage("CurrMaxTWR done.");
+
+			VOID_Data.surfaceThrustWeight.DoGUIHorizontal ("F2");
+
+			Tools.PostDebugMessage("surfaceTWR done.");
+
+			VOID_Data.intakeAirStatus.DoGUIHorizontal();
+
+			Tools.PostDebugMessage("intakeAirStatus done.");
+
+			GUILayout.EndVertical();
+
+			Tools.PostDebugMessage("VesselInfo window done.");
+
+			GUI.DragWindow();
+		}
+	}
+
+	public static partial class VOID_Data
+	{
+		public static VOID_DoubleValue geeForce = new VOID_DoubleValue(
 			"G-force",
 			new Func<double>(() => VOID_Core.Instance.vessel.geeForce),
 			"gees"
 		);
 
-		protected VOID_IntValue partCount = new VOID_IntValue(
+		public static VOID_IntValue partCount = new VOID_IntValue(
 			"Parts",
 			new Func<int>(() => VOID_Core.Instance.vessel.Parts.Count),
 			""
 		);
 
-		protected VOID_DoubleValue totalMass = new VOID_DoubleValue(
+		public static VOID_DoubleValue totalMass = new VOID_DoubleValue(
 			"Total Mass",
 			new Func<double> (() => SimManager.Instance.TryGetLastMass()),
 			"tons"
 		);
 
-		protected VOID_DoubleValue resourceMass = new VOID_DoubleValue(
+		public static VOID_DoubleValue resourceMass = new VOID_DoubleValue(
 			"Resource Mass",
 			delegate()
 			{
@@ -61,20 +141,20 @@
 			"tons"
 		);
 
-		protected VOID_DoubleValue stageDeltaV = new VOID_DoubleValue(
+		public static VOID_DoubleValue stageDeltaV = new VOID_DoubleValue(
 			"DeltaV (Current Stage)",
 			delegate()
 			{
 				if (SimManager.Instance.Stages == null ||
-			    	SimManager.Instance.Stages.Length <= Staging.lastStage
-			    )
+					SimManager.Instance.Stages.Length <= Staging.lastStage
+				)
 					return double.NaN;
 				return SimManager.Instance.Stages[Staging.lastStage].deltaV;
 			},
 			"m/s"
 		);
 
-		protected VOID_DoubleValue totalDeltaV = new VOID_DoubleValue(
+		public static VOID_DoubleValue totalDeltaV = new VOID_DoubleValue(
 			"DeltaV (Total)",
 			delegate()
 			{
@@ -85,13 +165,13 @@
 			"m/s"
 		);
 
-		protected VOID_FloatValue mainThrottle = new VOID_FloatValue(
+		public static VOID_FloatValue mainThrottle = new VOID_FloatValue(
 			"Throttle",
 			new Func<float>(() => VOID_Core.Instance.vessel.ctrlState.mainThrottle * 100f),
 			"%"
 		);
 
-		protected VOID_StrValue currmaxThrust = new VOID_StrValue(
+		public static VOID_StrValue currmaxThrust = new VOID_StrValue(
 			"Thrust (curr/max)",
 			delegate()
 			{
@@ -109,7 +189,7 @@
 			}
 		);
 
-		protected VOID_StrValue currmaxThrustWeight = new VOID_StrValue(
+		public static VOID_StrValue currmaxThrustWeight = new VOID_StrValue(
 			"T:W (curr/max)",
 			delegate()
 			{
@@ -120,10 +200,10 @@
 				double maxThrust = SimManager.Instance.LastStage.thrust;
 				double mass = SimManager.Instance.TryGetLastMass();
 				double gravity = VOID_Core.Instance.vessel.mainBody.gravParameter /
-				                 Math.Pow(
-					                 VOID_Core.Instance.vessel.mainBody.Radius + VOID_Core.Instance.vessel.altitude,
-					                 2
-					                );
+					Math.Pow(
+						VOID_Core.Instance.vessel.mainBody.Radius + VOID_Core.Instance.vessel.altitude,
+						2
+					);
 				double weight = mass * gravity;
 
 				return string.Format(
@@ -134,7 +214,7 @@
 			}
 		);
 
-		protected VOID_DoubleValue surfaceThrustWeight = new VOID_DoubleValue(
+		public static VOID_DoubleValue surfaceThrustWeight = new VOID_DoubleValue(
 			"Max T:W @ surface",
 			delegate()
 			{
@@ -144,7 +224,7 @@
 				double maxThrust = SimManager.Instance.LastStage.thrust;
 				double mass = SimManager.Instance.TryGetLastMass();
 				double gravity = (VOID_Core.Constant_G * VOID_Core.Instance.vessel.mainBody.Mass) /
-				                 Math.Pow(VOID_Core.Instance.vessel.mainBody.Radius, 2);
+					Math.Pow(VOID_Core.Instance.vessel.mainBody.Radius, 2);
 				double weight = mass * gravity;
 
 				return maxThrust / weight;
@@ -152,7 +232,7 @@
 			""
 		);
 
-		protected VOID_StrValue intakeAirStatus = new VOID_StrValue(
+		public static VOID_StrValue intakeAirStatus = new VOID_StrValue(
 			"Intake Air (Curr / Req)",
 			delegate()
 			{
@@ -196,57 +276,6 @@
 				return string.Format("{0:F3} / {1:F3}", currentAmount, currentRequirement);
 			}
 		);
-
-		public VOID_VesselInfo() : base()
-		{
-			this._Name = "Vessel Information";
-
-			this.WindowPos.x = Screen.width - 260;
-			this.WindowPos.y = 450;
-		}
-
-		public override void ModuleWindow(int _)
-		{
-			base.ModuleWindow (_);
-
-			if ((TimeWarp.WarpMode == TimeWarp.Modes.LOW) || (TimeWarp.CurrentRate <= TimeWarp.MaxPhysicsRate))
-			{
-				SimManager.Instance.RequestSimulation();
-			}
-
-			GUILayout.BeginVertical();
-
-			GUILayout.Label(
-				vessel.vesselName,
-				VOID_Core.Instance.LabelStyles["center_bold"],
-				GUILayout.ExpandWidth(true));
-
-			this.geeForce.DoGUIHorizontal ("F2");
-
-			this.partCount.DoGUIHorizontal ();
-
-			this.totalMass.DoGUIHorizontal ("F1");
-
-			this.resourceMass.DoGUIHorizontal ("F1");
-
-			this.stageDeltaV.DoGUIHorizontal (3, false);
-
-			this.totalDeltaV.DoGUIHorizontal (3, false);
-
-			this.mainThrottle.DoGUIHorizontal ("F0");
-
-			this.currmaxThrust.DoGUIHorizontal ();
-
-			this.currmaxThrustWeight.DoGUIHorizontal ();
-
-			this.surfaceThrustWeight.DoGUIHorizontal ("F2");
-
-			this.intakeAirStatus.DoGUIHorizontal();
-
-			GUILayout.EndVertical();
-			GUI.DragWindow();
-		}
 	}
 }
 
-