public void SaveToXml(IO.XmlEditor xml, string node)
 {
     xml.SaveNode("Forecolor", node, GetXmlFromColor(ForeColor));
     xml.SaveNode("Backcolor", node, GetXmlFromColor(BackColor));
     xml.SaveNode("Bordercolor", node, GetXmlFromColor(BorderColor));
     xml.SaveNode("Hovercolor", node, GetXmlFromColor(HoverColor));
 }

			public override void Write(IO.EndianWriter stream)
			{
				Compiler comp = stream.Owner as Compiler;

				uint elementsAddress = 0;
				int flags = (
						(tagRef.IsNonResolving ? 1<<1 : 0)
					);

				if (tagRef.Elements.Count > 1)
				{
					elementsAddress = stream.PositionUnsigned;
					foreach (string i in tagRef.Elements)
						stream.WriteTag(i);

					comp.MarkLocationFixup(tagRef.Name, stream, true);
					stream.Write(flags);
					stream.Write((int)-1);
					stream.WritePointer(elementsAddress);
				}
				else
				{
					comp.MarkLocationFixup(tagRef.Name, stream, true);
					stream.Write(flags);
					stream.WriteTag(tagRef.Elements[0]);
					stream.Write((int)0);
				}
			}

		public VT100(IO.Net.Telnet.Server server) :
			this(server as IO.IByteDevice)
		{
			this.server = server;
			this.Echo = true;
			this.Out.Write('\x1b', '[', 'c'); // Request Identification string
		}

			public void Write(IO.EndianWriter stream)
			{
				int orgPos = stream.Position;

				if (address != 0)
				{
					if (offsets.Count == 0)
					{
						string name = (stream.Owner as Compiler).GetLocationName(this);
						Debug.LogFile.WriteLine("LocationWriteback: unused address! There are no references to '{0}'", name);
					}
					else foreach (uint tempPos in offsets)
					{
						stream.PositionUnsigned = tempPos;
						stream.WritePointer(address);
					}
				}
				else
				{
					string name = (stream.Owner as Compiler).GetLocationName(this);
					Debug.LogFile.WriteLine("LocationWriteback: failed to writeback! '{0}'s address was not set, {1} memory locations will be null!",
						name, offsets.Count.ToString());
				}

				stream.Position = orgPos;
			}

        ////------------------------------------------------------------------------------------------------------------------------------
        /// <summary>
        /// Initializes a new instance of the <see cref="FlacFrame"/> class. 
        /// </summary>
        /// <param name="stream">
        /// The stream.
        /// </param>
        /// <exception cref="System.ArgumentNullException">
        /// Thrown if stream is null.
        /// </exception>
        private FlacFrame(IO.FlacStream stream)
        {
            if (stream == null)
                throw new ArgumentNullException("stream");

            FlacStream = stream;
        }

		protected Terminal(IO.ICharacterInDevice inDevice, IO.ICharacterOutDevice outDevice)
		{
			this.In = IO.CharacterReader.Open(IO.Filter.CharacterInDevice.Open(inDevice, this.FilterInput));
			this.Out = IO.CharacterWriter.Open(outDevice) ?? new IO.Null.CharacterWriter();
			if (this.Out.NotNull())
				this.Out.AutoFlush = true;
		}

        private Oscillograph(IO.IStringStream stream)
            : base(stream)
        {
            IList<string> initCommands = new List<string>()
            {
                {"Hdr Off"},
                {"Measurement:Meas1:State OFF"},
                {"Measurement:Meas2:State OFF"},
                {"Measurement:Meas3:State OFF"},
                {"Measurement:Meas4:State OFF"},
                {"Measurement:Meas1:Type Delay"},
                {"Measurement:Meas1:Delay:Direction Forwards"},
                {"Measurement:Meas1:Delay:Edge1 Rise"},
                {"Measurement:Meas1:Delay:Edge2 Rise"},
                {"Measurement:Meas1:Source CH1"},
                {"Measurement:Meas1:Source2 CH2"},
                {"Measurement:Meas1:State ON"},
                {"Measurement:Meas2:Type Delay"},
                {"Measurement:Meas2:Delay:Direction Forwards"},
                {"Measurement:Meas2:Delay:Edge1 Fall"},
                {"Measurement:Meas2:Delay:Edge2 Fall"},
                {"Measurement:Meas2:Source CH1"},
                {"Measurement:Meas2:Source2 CH2"},
                {"Measurement:Meas2:State ON"}
            };

            this.InitCommands = initCommands;
        }

			protected void InitializeForExport(ProjectState state, IO.XmlStream s)
			{
				s.ReadAttributeOpt("export", ref mIsExported);

//				if (IsExported)
//					state.Compiler.AddExport(this);
			}

 protected void exportRevenueDataDump_Click(object sender, EventArgs e)
 {
     try
     {
         List<System.Data.SqlClient.SqlParameter> spParams = new List<System.Data.SqlClient.SqlParameter>();
         spParams.Add(Param.CreateParam("STARTDATE", System.Data.SqlDbType.Date, DateTime.Now));
         spParams.Add(Param.CreateParam("ENTRYDATESTART", System.Data.SqlDbType.Date, "1/1/2002"));
         spParams.Add(Param.CreateParam("ENTRYDATEEND", System.Data.SqlDbType.Date, DateTime.Now));
         spParams.Add(Param.CreateParam("COMPANYID", System.Data.SqlDbType.Int, Convert.ToInt32(dropDownCompany.SelectedValue)));
         spParams.Add(Param.CreateParam("TRANSITY", System.Data.SqlDbType.VarChar, "Y"));
         spParams.Add(Param.CreateParam("TRANSITN", System.Data.SqlDbType.VarChar, "N"));
         spParams.Add(Param.CreateParam("REVENUETYPE", System.Data.SqlDbType.VarChar, "M"));
         spParams.Add(Param.CreateParam("ORDERBY", System.Data.SqlDbType.VarChar, "CONTRACT_NUMBER"));
         spParams.Add(Param.CreateParam("SHOWCONSOLIDATED", System.Data.SqlDbType.Int, 1));
         spParams.Add(Param.CreateParam("EXCLUDEMTA", System.Data.SqlDbType.Int, 1));
         spParams.Add(Param.CreateParam("STARTYEAR", System.Data.SqlDbType.Int, Convert.ToInt32(dropDownStartYear.SelectedValue)));
         using (IO io = new IO(WebCommon.ConnectionString))
         {
             WebCommon.ExportHtmlToExcel("RevenueFlashDataDump", WebCommon.DataTableToHtmlTable(io.ExecuteDataSetQuery(IO.CreateCommandFromStoredProc("OnlineFlash_GetRevFlashDataDump", spParams)).Tables[0], "RevenueFlashDataDump"));
         }
     }
     catch (Exception ex)
     {
         WebCommon.LogExceptionInfo(ex);
     }
 }

		public Base Build(IO.TextSection section, String prefix)
		{
			if (section == null) throw new ArgumentNullException("section");
			if (prefix == null) throw new ArgumentNullException("prefix");

			return Build(prefix, section, prefix);
		}

        public override void UpdateWithIOEvent(IO.IOEvent ioEvent)
        {
            if (ioEvent.Equals(rightMousePress))
            {
                Vector2 sceenPosition = IOState.MouseScreenPosition();
                Company rightClickCompany = this.PlayerObject.ClickCompany(sceenPosition);

                if (rightClickCompany != null)
                {

                    new AddTransportVehicleToCompany(this.LocalPlayer, rightClickCompany, vehicle);
                    this.LocalPlayer.PopUIContext();
                    new CompanySelected(this.NextInStack, rightClickCompany);
                }
            }
            else if (ioEvent.Equals(leftMousePress))
            {
                this.LocalPlayer.PopUIContext();
                this.UpdateNextInStackIO(ioEvent);
            }
            else
            {
                this.UpdateNextInStackIO(ioEvent);
            }
        }

        public bool DoSkill(Network.WorldClient client, IO.InteractiveObject io)
        {
            if (!this.IsCraftSkill)
            {
                if (io.State == IO.InteractiveObjectState.FULL)
                {
                    client.Action.RefreshDirection(3);//TODO: From player direction

                    var packet = "GA" + this.ID + ";501;" + client.Character.ID + ";" + io.CellID + "," + this.GetJobTime();
                    client.Character.Map.Engine.Send(packet);
                    return true;
                }
                else
                {
                    return false;
                }
            }
            else
            {
                if (client.Action.CurrentJobCraftSkill == null)
                {
                    client.Action.CurrentJobCraftSkill = new JobCraftSkill(this, client);
                    var packet = "ECK3|" + this.GetJobCraftMax() + ";" + this.ID;
                    client.Send(packet);
                    return false;
                }
                else
                {
                    return false;
                }
            }
        }

 /// <summary>
 /// Creates a new restore index
 /// </summary>
 /// <param name="path">
 /// The path to the restore index file to create
 /// </param>
 /// <param name="header">
 /// The restore index header to insert
 /// </param>
 /// <returns>
 /// A new restore index implementation
 /// </returns>
 public static IRestoreIndex Create(IO.Path path, Header header)
 {
     // create the restore index file and schema
      Database.Create(path, "SkyFloe.Sqlite.Resources.RestoreIndex.sql");
      var index = (RestoreIndex)null;
      try
      {
     // connect to the database and add the header row
     index = new RestoreIndex(path);
     index.Execute(
        "INSERT INTO Header (" +
           "Version) " +
        "VALUES (@p0);",
        header.Version = CurrentVersion
     );
     return index;
      }
      catch
      {
     if (index != null)
        index.Dispose();
     try { Database.Delete(path); } catch { }
     throw;
      }
 }

        public XvdFile(string path)
        {
            _filePath = path;
            _io = new IO(path);

            LoadKeysFromDisk();
        }

 public unsafe PdbInfo(IO.FileStream inputStream, Metadata.Reader reader)
 {
   this.reader = reader;
   this.pdbFunctionMap = PdbFile.LoadFunctionMap(inputStream, out tokenToSourceMapping, out sourceServerData, reader);
   //inputStream.Seek(0L, IO.SeekOrigin.Begin);
   //this.remapTable = PdbFile.LoadRemapTable(inputStream);
 }

 /// <summary>
 /// Creates a new AGIConnectionHandler to handle the given socket connection.
 /// </summary>
 /// <param name="socket">the socket connection to handle.</param>
 /// <param name="mappingStrategy">the strategy to use to determine which script to run.</param>
 public AGIConnectionHandler(IO.SocketConnection socket, IMappingStrategy mappingStrategy, bool SC511_CAUSES_EXCEPTION, bool SCHANGUP_CAUSES_EXCEPTION)
 {
     this.socket = socket;
     this.mappingStrategy = mappingStrategy;
     this._SC511_CAUSES_EXCEPTION = SC511_CAUSES_EXCEPTION;
     this._SCHANGUP_CAUSES_EXCEPTION = SCHANGUP_CAUSES_EXCEPTION;
 }

			public InvalidVersion(IO.ITagStream tag, string msg)
			{
				Debug.LogFile.WriteLine("Invalid versioning ({0})" + Program.NewLine +
					"\tIn {1}",
					msg,
					tag.GetExceptionDescription());
			}

		public Boolean Load(IO.File file, Int32 pcxsize, out Point size, out Texture2D pixels, out Texture2D palette)
		{
			if (file == null) throw new ArgumentNullException("file");

			size = new Point(Int32.MinValue, Int32.MinValue);
			pixels = null;
			palette = null;

			Byte[] filedata = file.ReadBytes(pcxsize);
			if (filedata.Length != pcxsize) return false;

			IO.FileHeaders.PcxFileHeader header = new IO.FileHeaders.PcxFileHeader(filedata);
			Point tempsize = new Point(header.XMax - header.XMin + 1, header.YMax - header.YMin + 1);

			if (header.Manufacturer != 10 || header.Encoding != 1 || header.Version > 5 || header.BitsPerPixel != 8) return false;
			if (header.ColorPlanes != 1) return false;
			if (tempsize.X <= 0 || tempsize.Y <= 0) return false;

			size = tempsize;

			Int32 readoffset = 0;
			pixels = LoadPixels(filedata, size, header.BytesPerLine, ref readoffset);
			palette = LoadPalette(filedata, ref readoffset);
			return true;
		}

 /// <summary>
 /// Creates a new backup index
 /// </summary>
 /// <param name="path">
 /// The path to the backup index file to create
 /// </param>
 /// <param name="header">
 /// The backup index header to insert
 /// </param>
 /// <returns>
 /// A new backup index implementation
 /// </returns>
 public static IBackupIndex Create(IO.Path path, Header header)
 {
     // create the backup index file and schema
      Database.Create(path, "SkyFloe.Sqlite.Resources.BackupIndex.sql");
      var index = (BackupIndex)null;
      try
      {
     // connect to the database and add the header row
     index = new BackupIndex(path);
     index.Execute(
        "INSERT INTO Header (" +
        "   Version, " +
        "   CryptoIterations, " +
        "   ArchiveSalt, " +
        "   PasswordHash, " +
        "   PasswordSalt) " +
        "VALUES (@p0, @p1, @p2, @p3, @p4);",
        header.Version = CurrentVersion,
        header.CryptoIterations,
        header.ArchiveSalt,
        header.PasswordHash,
        header.PasswordSalt
     );
     return index;
      }
      catch
      {
     if (index != null)
        index.Dispose();
     try { Database.Delete(path); } catch { }
     throw;
      }
 }

			public void Write(IO.EndianWriter stream)
			{
				Compiler comp = stream.Owner as Compiler;
				Import import = comp.OwnerState.Importer as Import;

				int real_count = import.Groups.Count;
				stream.Write("dynamic tag groups", false);
				stream.Write((short)DataArray.MaxValue);
				stream.Write((short)Item.Size);
				stream.Write(true);
				stream.Write(true);
				stream.Write((short)0);
				MiscGroups.data.Write(stream);
				stream.Write((short)real_count);//stream.Write((short)Datums.Count);
				stream.Write((short)real_count);//stream.Write((short)Datums.Count);
				stream.Write(real_count);
				stream.WritePointer(stream.PositionUnsigned + 4);

				#region Write tag group datums
				foreach (Import.TagGroup tg in import.Groups.Values)
				{
					stream.Write((short)0); // Header
					stream.Write((short)0); // Flags
					comp.AddLocationFixup(tg.Name, stream, false);
					stream.Write((int)0);
				}
				#endregion

				#region Write null datums
				Item i = new Item();
				int count = DataArray.MaxValue - real_count;
				for (int x = 0; x < count; x++)
					i.Write(stream);
				#endregion
			}