/// <summary>
        /// Constructor
        /// </summary>
        public TrafficVolumeForm(VerkehrSteuerung steuerung, MainForm mainForm, NodeSteuerung nodeController)
        {
            this.m_steuerung      = steuerung;
            this.m_mainForm       = mainForm;
            this.m_nodeController = nodeController;

            InitializeComponent();
            this.splitContainer1.Panel2MinSize = 260;

            UpdateListboxLayout();
            GetTrafficVolume();

            this.m_steuerung.StartPointsChanged             += new VerkehrSteuerung.StartPointsChangedEventHandler(m_steuerung_StartPointsChanged);
            this.m_steuerung.DestinationPointsChanged       += new VerkehrSteuerung.DestinationPointsChangedEventHandler(m_steuerung_DestinationPointsChanged);
            this.m_steuerung.GlobalTrafficMultiplierChanged += new VerkehrSteuerung.GlobalTrafficMultiplierChangedEventHandler(m_steuerung_GlobalTrafficMultiplierChanged);
            this.m_steuerung.CarTargetVelocityChanged       += new VerkehrSteuerung.CarTargetVelocityChangedEventHandler(m_steuerung_CarTargetVelocityChanged);
            this.m_steuerung.TruckTargetVelocityChanged     += new VerkehrSteuerung.TruckTargetVelocityChangedEventHandler(m_steuerung_TruckTargetVelocityChanged);
            this.m_steuerung.BusTargetVelocityChanged       += new VerkehrSteuerung.BusTargetVelocityChangedEventHandler(m_steuerung_BusTargetVelocityChanged);
            this.m_steuerung.TramTargetVelocityChanged      += new VerkehrSteuerung.TramTargetVelocityChangedEventHandler(m_steuerung_TramTargetVelocityChanged);

            renderOptions.renderLineNodes               = false;
            renderOptions.renderNodeConnections         = true;
            renderOptions.renderVehicles                = false;
            renderOptions.performClipping               = false;
            renderOptions.clippingRect                  = new Rectangle(0, 0, 10000, 10000);
            renderOptions.renderIntersections           = false;
            renderOptions.renderLineChangePoints        = false;
            renderOptions.renderLineNodeDebugData       = false;
            renderOptions.renderNodeConnectionDebugData = false;
            renderOptions.renderVehicleDebugData        = false;
        }
        /// <summary>
        /// Constructor
        /// </summary>
        public TrafficVolumeForm(VerkehrSteuerung steuerung, MainForm mainForm, NodeSteuerung nodeController)
        {
            this.m_steuerung = steuerung;
            this.m_mainForm = mainForm;
            this.m_nodeController = nodeController;

            InitializeComponent();
            this.splitContainer1.Panel2MinSize = 260;

            UpdateListboxLayout();
            GetTrafficVolume();

            this.m_steuerung.StartPointsChanged += new VerkehrSteuerung.StartPointsChangedEventHandler(m_steuerung_StartPointsChanged);
            this.m_steuerung.DestinationPointsChanged += new VerkehrSteuerung.DestinationPointsChangedEventHandler(m_steuerung_DestinationPointsChanged);
            this.m_steuerung.GlobalTrafficMultiplierChanged += new VerkehrSteuerung.GlobalTrafficMultiplierChangedEventHandler(m_steuerung_GlobalTrafficMultiplierChanged);
            this.m_steuerung.CarTargetVelocityChanged += new VerkehrSteuerung.CarTargetVelocityChangedEventHandler(m_steuerung_CarTargetVelocityChanged);
            this.m_steuerung.TruckTargetVelocityChanged += new VerkehrSteuerung.TruckTargetVelocityChangedEventHandler(m_steuerung_TruckTargetVelocityChanged);
            this.m_steuerung.BusTargetVelocityChanged += new VerkehrSteuerung.BusTargetVelocityChangedEventHandler(m_steuerung_BusTargetVelocityChanged);
            this.m_steuerung.TramTargetVelocityChanged += new VerkehrSteuerung.TramTargetVelocityChangedEventHandler(m_steuerung_TramTargetVelocityChanged);

            renderOptions.renderLineNodes = false;
            renderOptions.renderNodeConnections = true;
            renderOptions.renderVehicles = false;
            renderOptions.performClipping = false;
            renderOptions.clippingRect = new Rectangle(0, 0, 10000, 10000);
            renderOptions.renderIntersections = false;
            renderOptions.renderLineChangePoints = false;
            renderOptions.renderLineNodeDebugData = false;
            renderOptions.renderNodeConnectionDebugData = false;
            renderOptions.renderVehicleDebugData = false;
        }
 private void m_steuerung_TruckTargetVelocityChanged(object sender, VerkehrSteuerung.TruckTargetVelocityChangedEventArgs e)
 {
     if (!ignoreUpdateEvent)
         spinTrucksTargetVelocity.Value = (decimal)m_steuerung.truckTargetVelocity;
 }
 private void m_steuerung_StartPointsChanged(object sender, VerkehrSteuerung.StartPointsChangedEventArgs e)
 {
     lbStartNodes.Items.Clear();
     lbStartNodes.Items.AddRange(m_steuerung.startPoints.ToArray());
     GetTrafficVolume();
 }
 private void m_steuerung_GlobalTrafficMultiplierChanged(object sender, VerkehrSteuerung.GlobalTrafficMultiplierChangedEventArgs e)
 {
     if (!ignoreUpdateEvent)
         spinGlobalTrafficVolumeMultiplier.Value = (decimal)m_steuerung.globalTrafficMultiplier;
 }
 private void m_steuerung_DestinationPointsChanged(object sender, VerkehrSteuerung.DestinationPointsChangedEventArgs e)
 {
     lbDestinationNodes.Items.Clear();
     lbDestinationNodes.Items.AddRange(m_steuerung.destinationPoints.ToArray());
     GetTrafficVolume();
 }
 private void m_steuerung_BusTargetVelocityChanged(object sender, VerkehrSteuerung.BusTargetVelocityChangedEventArgs e)
 {
     if (!ignoreUpdateEvent)
         spinBussesTargetVelocity.Value = (decimal)m_steuerung.busTargetVelocity;
 }
        /// <summary>
        /// Läd eine XML Datei und versucht daraus den gespeicherten Zustand wiederherzustellen
        /// </summary>
        /// <param name="filename">Dateiname der zu ladenden Datei</param>
        /// <param name="nodeSteuerung">NodeSteuerung in das Layout eingelesen werden soll</param>
        /// <param name="timelineSteuerung">TimelineSteuerung in die die LSA eingelesen werden soll</param>
        /// <param name="trafficVolumeSteuerung">VerkehrSteurung to load into</param>
        public static ProgramSettings LoadFromFile(String filename, NodeSteuerung nodeSteuerung, TimelineSteuerung timelineSteuerung, Verkehr.VerkehrSteuerung trafficVolumeSteuerung)
        {
            LoadingForm.LoadingForm lf = new LoadingForm.LoadingForm();
            lf.Text = "Loading file '" + filename + "'...";
            lf.Show();

            lf.SetupUpperProgress("Loading Document...", 8);

            // Dokument laden
            XmlDocument xd = new XmlDocument();

            xd.Load(filename);

            // parse save file version
            int     saveVersion     = 0;
            XmlNode mainNode        = xd.SelectSingleNode("//CityTrafficSimulator");
            XmlNode saveVersionNode = mainNode.Attributes.GetNamedItem("saveVersion");

            if (saveVersionNode != null)
            {
                saveVersion = Int32.Parse(saveVersionNode.Value);
            }
            else
            {
                saveVersion = 0;
            }

            ProgramSettings ps;

            if (saveVersion >= 8)
            {
                XmlNode       xnlLineNode = xd.SelectSingleNode("//CityTrafficSimulator/ProgramSettings");
                TextReader    tr          = new StringReader(xnlLineNode.OuterXml);
                XmlSerializer xsPS        = new XmlSerializer(typeof(ProgramSettings));
                ps = (ProgramSettings)xsPS.Deserialize(tr);
            }
            else
            {
                // set some okay default settings
                ps = new ProgramSettings();

                ps._simSpeed      = 1;
                ps._simSteps      = 15;
                ps._simDuration   = 300;
                ps._simRandomSeed = 42;

                ps._zoomLevel     = 7;
                ps._renderQuality = 0;

                ps._renderStatistics      = false;
                ps._renderVelocityMapping = false;
                ps._showFPS = false;

                ps._renderOptions = new NodeSteuerung.RenderOptions();
                ps._renderOptions.renderLineNodes               = true;
                ps._renderOptions.renderNodeConnections         = true;
                ps._renderOptions.renderVehicles                = true;
                ps._renderOptions.performClipping               = true;
                ps._renderOptions.clippingRect                  = new Rectangle(0, 0, 10000, 10000);
                ps._renderOptions.renderIntersections           = false;
                ps._renderOptions.renderLineChangePoints        = false;
                ps._renderOptions.renderLineNodeDebugData       = false;
                ps._renderOptions.renderNodeConnectionDebugData = false;
                ps._renderOptions.renderVehicleDebugData        = false;

                List <Color> tmp = new List <Color>();
                tmp.Add(Color.DarkRed);
                tmp.Add(Color.Yellow);
                tmp.Add(Color.DarkGreen);
                ps._velocityMappingColorMap = new Tools.ColorMap(tmp);
            }

            lf.StepUpperProgress("Parsing Network Layout...");
            List <Auftrag> toReturn = nodeSteuerung.LoadFromFile(xd, lf);

            lf.StepUpperProgress("Parsing Singnals...");
            timelineSteuerung.LoadFromFile(xd, nodeSteuerung.nodes, lf);

            lf.StepUpperProgress("Parsing Traffic Volume...");
            trafficVolumeSteuerung.LoadFromFile(xd, nodeSteuerung.nodes, lf);
            if (saveVersion < 5)
            {
                trafficVolumeSteuerung.ImportOldTrafficVolumeData(toReturn);
            }

            lf.StepUpperProgress("Done");
            lf.ShowLog();

            lf.Close();
            lf = null;

            return(ps);
        }
        /// <summary>
        /// Speichert den aktuellen Zustand der nodeSteuerung und timelineSteuerung in die XML-Datei filename
        /// </summary>
        /// <param name="filename">Dateiname der zu speichernden Datei</param>
        /// <param name="nodeSteuerung">NodeSteuerung</param>
        /// <param name="timelineSteuerung">TimelineSteuerung</param>
        /// <param name="trafficVolumeSteuerung">VerkehrSteuerung</param>
        /// <param name="ps">ProgramSettings</param>
        public static void SaveToFile(string filename, NodeSteuerung nodeSteuerung, TimelineSteuerung timelineSteuerung, Verkehr.VerkehrSteuerung trafficVolumeSteuerung, ProgramSettings ps)
        {
            try
            {
                // erstma nen XMLWriter machen
                XmlWriterSettings xws = new XmlWriterSettings();
                xws.Indent          = true;
                xws.NewLineHandling = NewLineHandling.Entitize;

                XmlWriter xw = XmlWriter.Create(filename, xws);

                // leeren XmlSerializerNamespaces Namespace erstellen
                XmlSerializerNamespaces xsn = new XmlSerializerNamespaces();
                xsn.Add("", "");

                xw.WriteStartElement("CityTrafficSimulator");

                // write saveVersion
                xw.WriteStartAttribute("saveVersion");
                xw.WriteString("8");
                xw.WriteEndAttribute();

                // serialize program settings
                XmlSerializer xsPS = new XmlSerializer(typeof(ProgramSettings));
                xsPS.Serialize(xw, ps, xsn);

                nodeSteuerung.SaveToFile(xw, xsn);
                timelineSteuerung.SaveToFile(xw, xsn);
                trafficVolumeSteuerung.SaveToFile(xw, xsn);

                xw.WriteEndElement();

                xw.Close();
            }
            catch (IOException e)
            {
                MessageBox.Show(e.Message);
                throw;
            }
        }