using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using Data;

namespace SimpleRadar
{
    public partial class UserControlRadarView : UserControl
    {
        #region Attributes



        // public FormRadar formRadar;
        public PointF AnotoPenDown = new PointF(-1, -1);

        public Label clockLabel;
        public Label alidadeLabel;

        public float PanX = 0f;
        public float PanY = 0f;
        public float Zoom = Config.initialZoom;

        public Point PMouseDown;
        public Boolean BMouseDown = false;

        public ContextMenu ctxtMenu;

        public Sector selectedSector = null;

        private Data.AppDatabase data;

        private Timer selectedAircraftTimer;
        private double selectedAircraftRadius = Config.aircraftSelectedTimerRadius;
        private string selectedAircraft = "";
        private double xSelectedAircraftPosition = (double)0;
        private double ySelectedAircraftPosition = (double)0;
        private float xCircleCenterPosition = 0f;
        private float yCircleCenterPosition = 0f;
        /*private bool selectedAircraftFound = false;
        private int iterationsToFocus = 5;
        private float xShift = (float)0;
        private float yShift = (float)0;*/

        private Timer aircraftModsTimer;
        private Timer aircraftAlarmsTimer;
        private ListBox alarmListBox;

        private int currentHour = 0;
        private int currentMinute = 0;
        private int currentSecond = 0;

        public List<string> warningAircraftList = new List<string>();

        public List<string> partAircraftList = new List<string>();

        public List<int> aflFilterList = new List<int>();
        public List<string> aflFilterAircraftList = new List<string>();
        public int aflSup = 0;
        public int aflInf = 0;

        public Dictionary<string, Dictionary<string, Object>> aircraftModSDictionary = new Dictionary<string, Dictionary<string, Object>>();
        public Dictionary<string, Dictionary<string, Object>> aircraftInformationMessagesDictionary = new Dictionary<string, Dictionary<string, Object>>();
        public Dictionary<string, Dictionary<string, Object>> aircraftAlarmsDictionary = new Dictionary<string, Dictionary<string, Object>>();
        public Dictionary<string, PictureBox> aircraftFollowedDictionary = new Dictionary<string, PictureBox>();
        public Dictionary<string, Dictionary<string, Object>> aircraftTagMessagesDictionary = new Dictionary<string, Dictionary<string, Object>>();

        public string aircraftCheckedContextualMenu = "";
        public string aircraftSelectedContextualMenu = "";

        public bool alidadeActivate = false;
        public bool alidadeFirstPointSet = false;
        private PointF alidadeFirstPoint = new PointF();
        public bool alidadeSecondPointSet = false;
        private PointF alidadeSecondPoint = new PointF();
        private PointF alidadeCurrentPoint = new PointF();

        public Dictionary<string, string> aircraftBeaconSeparationDictionary = new Dictionary<string, string>();

        public float separationAcOneX = 0f;
        public float separationAcOneY = 0f;
        public float separationAcTwoX = 0f;
        public float separationAcTwoY = 0f;
        public bool separationAcOneFound = false;
        public bool separationAcTwoFound = false;

        #endregion

        #region Constructor


        public UserControlRadarView()
        {
            InitializeComponent();

            //    this.formRadar = frmRadar;

            this.SetStyle(ControlStyles.UserPaint | ControlStyles.AllPaintingInWmPaint | ControlStyles.OptimizedDoubleBuffer, true);
            this.MouseWheel += new MouseEventHandler(Form1_MouseWheel);

            aircraftModsTimer = new Timer();
            aircraftModsTimer.Interval = Config.aircraftModsTimerInterval;
            aircraftModsTimer.Tick += new EventHandler(aircraftModsTimer_Tick);
            aircraftModsTimer.Enabled = true;
            aircraftModsTimer.Start();

            aircraftAlarmsTimer = new Timer();
            aircraftAlarmsTimer.Interval = Config.aircraftAlarmsTimerInterval;
            aircraftAlarmsTimer.Tick += new EventHandler(aircraftAlarmsTimer_Tick);
            aircraftAlarmsTimer.Enabled = true;
            aircraftAlarmsTimer.Start();

            alarmListBox = new ListBox();
            alarmListBox.Name = "alarmListBox";
            alarmListBox.Location = new Point(80, 10);
            alarmListBox.Size = new Size(200, 70);
            alarmListBox.Font = new Font("Tahoma", 10F, FontStyle.Bold);
            alarmListBox.BackColor = Color.White;
            alarmListBox.ForeColor = Color.Orange;
            alarmListBox.Visible = false;
            this.Controls.Add(alarmListBox);

            clockLabel = new Label();
            clockLabel.Size = new Size(Config.clockLabelWidth, Config.clockLabelHeight);
            clockLabel.Location = new Point(this.ClientRectangle.Right - Config.clockLabelWidth - 10, this.ClientRectangle.Bottom - Config.clockLabelHeight - 10);
            clockLabel.BackColor = Config.clockLabelBackColor;
            clockLabel.ForeColor = Config.clockLabelForeColor;
            clockLabel.Font = Config.clockLabelFont;
            clockLabel.Anchor = AnchorStyles.Bottom | AnchorStyles.Right;
            clockLabel.Visible = true;
            clockLabel.TextAlign = ContentAlignment.BottomRight;
            this.Controls.Add(clockLabel);

            alidadeLabel = new Label();
            alidadeLabel.Size = new Size(Config.alidadeLabelWidth, Config.alidadeLabelHeight);
            alidadeLabel.Location = new Point(10, this.ClientRectangle.Bottom - Config.alidadeLabelHeight - 10);
            alidadeLabel.BackColor = Config.alidadeLabelUnselectedBackColor;
            alidadeLabel.ForeColor = Config.alidadeLabelUnselectedForeColor;
            alidadeLabel.Font = Config.alidadeLabelFont;
            alidadeLabel.Anchor = AnchorStyles.Bottom | AnchorStyles.Left;
            alidadeLabel.Text = Config.alidadeLabelUnselectedText;
            alidadeLabel.TextAlign = ContentAlignment.BottomLeft;
            alidadeLabel.Click += new EventHandler(alidadeLabel_Click);
            alidadeLabel.Visible = true;
            this.Controls.Add(alidadeLabel);

            this.aircraftTagMessagesDictionary.Add("1677", new Dictionary<string, Object>());
            this.aircraftTagMessagesDictionary.Add("1711", new Dictionary<string, Object>());
            this.aircraftTagMessagesDictionary.Add("1315", new Dictionary<string, Object>());
            this.aircraftTagMessagesDictionary.Add("1947", new Dictionary<string, Object>());

            ////FOR TESTS

            ////Aircraft 1 => CallSign : EZY915B & Flight : 1203
            ////Aircraft 2 => CallSign : DAL86 & Flight : 1025
            ////Aircraft 3 => CallSign : N525AJ & Flight : 1254

            ////select an aircraft
            //manageSelectedAircraftTimer("add", "1203");

            ////part an aircraft
            //managePartAircraftList("add", "1203");

            ////warn an aircraft
            //manageWarningAircraftList("add", "1203");

            ////add a flight level filter
            //manageFlightLevelFilter("add", 300, 40);
            //manageAircraftFlightLevelFilterList("add", "1254");

            ////add a ModS on an aircraft
            //manageAircraftModSDictionary("1203", "320", "BQ", "True");
            //manageAircraftModSDictionary("1203", "320", "BQ", "False");
            //manageAircraftModSDictionary("1025", "320", "BQ", "False");

            ////follow an aircraft
            //manageFollowedAircraftList("add", "1203");
            //manageFollowedAircraftList("add", "1025");
            //manageFollowedAircraftList("add", "1254");

            ////add an alarm for an aircraft
            //manageAircraftAlarmsDictionary("add", "1203", 6, 50, 5);
            //manageAircraftAlarmsDictionary("add", "1025", 6, 50, 15);

            ////draw the separation and the distance between two aircraft and a beacon
            //manageAircraftSeparationList("add", "1203", "CFA SOMTI", "10", "1025", "ADATU SOMTI", "10", "5", "104,61 -80,09 118,63 -74,02");
            /*manageAircraftSeparationList("add", "1199", "ABUSO ADATU", "236", "598,367500670139 -550,142785577549 613,301363364121 -555,885584985269 627,301859639728 -561,269459430006 642,23572233371 -567,012258837726 657,169585027692 -572,755058245445 671,1700813033 -578,138932690182 686,103943997281 -583,881732097901 700,104440272889 -589,265606542638 715,038302966871 -595,008405950358 729,972165660852 -600,751205358077 743,97266193646 -606,135079802814 758,906524630442 -611,877879210534 772,90702090605 -617,261753655271 787,840883600031 -623,00455306299 802,774746294013 -628,74735247071",
                                         "1225", "ETAMO VALKU ADATU", "248", "771,081851944354 -82,2489994224776 777,106513947302 -95,9859367722013 783,131175950251 -109,722874121925 789,557482086728 -124,375607294964 795,582144089676 -138,112544644687 801,606806092625 -151,849481994411 807,631468095573 -165,586419344135 814,057774232051 -180,239152517173 820,082436234999 -193,976089866897 826,107098237947 -207,713027216621 832,131760240895 -221,449964566344 838,558066377373 -236,102697739383 844,582728380321 -249,839635089107 850,607390383269 -263,57657243883 857,033696519747 -278,229305611869",
                                         "12");*/
            /*manageAircraftSeparationList("add", "1199", "ABUSO ADATU", "244", "700,104440272889 -589,265606542638 815,841876151247 -633,772301952464 931,579312029605 -678,27899736229",
                                         "1225", "ETAMO VALKU ADATU", "256", "814,057774232051 -180,239152517173 863,058358522695 -291,966242961593 912,058942813339 -403,693333406012 941,368654432785 -520,178403186158",
                                         "12");*/

            ////add an information message to an aircraft
            /*string firstWord, secondWord, thirdWord, fourthWord, fifthWord, sixthWord, seventhWord;
            manageAircraftInformationMessagesDictionary("add", "1203", 3);
            firstWord = "0 3669 518 3643 504 3627 504 3612 509 3598 518 3584 526 3573 536 3566 547 3562 556 3561 564 3563 569 3566 571 3575 575 " +
                               "3589 582 3605 590 3617 603 3627 615 3634 631 3635 643 3632 656 3623 666 3607 673 3592 676 3581 674 3573 671 3569 671 " +
                               "3569 671 3572 672 3575 672 3580 674 3588 676 3597 678 3608 677 3620 676 3634 675 3650 673 3665 669 3677 657 3687 644 " +
                               "3691 630 3690 617 3685 606 3676 601 3667 601 3659 607 3651 621 3647 637 3648 652 3651 660 3657 666 3662 667 3670 662 " +
                               "3681 650 3688 635 3690 624 3690 623 3691 626 3692 633 3694 640 3700 649 3707 653 3716 655";
            secondWord = "1 3714 572 3733 581 3744 580 3757 577 3771 569 3781 556 3787 542 3788 529 3784 517 3776 505 3765 502 3754 505 3744 514 " +
                                "3733 527 3729 546 3725 570 3724 593 3725 617 3728 636 3733 653 3738 666 3745 676 3754 681 3762 681 3773 676 3784 664 " +
                                "3793 649 3794 638 3792 633 3792 633 3791 634 3791 639 3790 648 3792 659 3796 666 3804 674 3813 678 3822 677 3833 670 " +
                                "3839 660 3839 646 3835 634 3832 630 3831 631 3832 637 3834 647 3838 663 3841 671 3846 677 3853 679 3861 678 3869 675";
            thirdWord = "2 3854 524 3866 582 3870 614 3874 645 3876 667 3878 683 3878 687 3878 685 3877 677 3875 661 3873 639 3871 621 3870 610 " +
                               "3872 606 3874 605 3878 605 3888 604 3902 603 3918 603 3932 601 3942 600 3949 599 3949 597";            
            updateAircraftInformationMessage("1203", true, firstWord);
            updateAircraftInformationMessage("1203", true, secondWord);
            updateAircraftInformationMessage("1203", true, thirdWord);
            updateAircraftInformationMessage("1203", false, "");*/

            //manageSelectedAircraftTimer("add", "1203");

            /*manageAircraftInformationMessagesDictionary("add", "1025", 7);
            firstWord = "0 3581 1251 3558 1476 3559 1479 3562 1481 3567 1482 3579 1482 3596 1482 3616 1481 3637 1478 3652 1476 3659 1474 3660 1474 3660 1472 " +
                        "3659 1471 3657 1471";
            secondWord = "1 3665 1439 3662 1480 3660 1480";
            thirdWord = "2 3730 1409 3727 1399 3722 1397 3715 1398 3707 1402 3701 1406 3698 1413 3697 1419 3700 1424 3707 1432 3716 1441 3724 1449 3727 1459 " +
                        "3725 1466 3718 1473 3709 1479 3700 1478";
            fourthWord = "3 3906 1374 3883 1385 3873 1396 3864 1414 3859 1432 3859 1448 3864 1460 3873 1469 3888 1474 3909 1474 3930 1466 3944 1456 3948 1445 " +
                         "3946 1435 3937 1430 3925 1430 3915 1439 3909 1451 3908 1467 3914 1480 3923 1487 3935 1489 3950 1488 3965 1486 3978 1480";
            fifthWord = "4 4075 1416 4074 1461 4075 1473 4076 1481 4077 1483 4077 1482 4079 1475 4083 1461 4086 1442 4089 1428 4094 1421 4097 1421 4101 1428 " +
                        "4108 1444 4112 1462 4114 1479 4114 1489 4111 1494 4111 1493 4109 1489 4108 1471 4107 1444 4106 1419 4112 1405 4117 1405 4122 1410 " +
                        "4129 1424 4135 1444 4139 1463 4141 1475 4142 1480 4142 1480 4142 1477 4141 1464 4140 1443 4141 1419 4142 1409 4145 1409 4147 1412 " +
                        "4152 1425 4161 1440 4171 1455 4183 1469 4194 1476 4205 1478 4216 1470 4228 1461 4230 1446 4225 1434 4217 1431 4207 1434 4198 1447 " +
                        "4192 1464 4193 1479 4199 1492 4206 1497 4217 1501 4233 1500 4251 1496";
            sixthWord = "5 4292 1440 4300 1422 4302 1414 4302 1407 4299 1400 4295 1397 4289 1396 4281 1398 4273 1405 4269 1417 4269 1428 4272 1440 4280 1453 " +
                        "4288 1466 4291 1481 4289 1491 4281 1499 4274 1502 4270 1499 4267 1491 4271 1479 4281 1462 4294 1450 4307 1436 4321 1425 4333 1414 " +
                        "4339 1407 4339 1400 4336 1397 4331 1394 4325 1392 4320 1397 4318 1404 4319 1417 4324 1433 4330 1452 4335 1469 4336 1482 4334 1491 " +
                        "4328 1498 4321 1500 4316 1498 4311 1492 4312 1484 4317 1476 4327 1467 4342 1462 4356 1458 4373 1455 4387 1452 4399 1448 4404 1443 " +
                        "4403 1437 4398 1430 4387 1428 4374 1430 4364 1435 4356 1445 4353 1460 4355 1468 4359 1475 4366 1479 4374 1477 4387 1471 4399 1459 " +
                        "4404 1447 4405 1440 4406 1443 4406 1449 4408 1462 4411 1473 4417 1485 4422 1489";
            seventhWord = "6 4455 1447 4467 1449 4477 1449 4489 1444 4497 1437 4498 1430 4494 1421 4485 1414 4469 1409 4451 1414 4438 1427 4430 1443 4431 1457 " +
                          "4438 1467 4451 1471 4465 1469 4480 1459 4492 1444 4496 1435 4496 1430 4495 1432 4494 1438 4493 1450 4494 1471 4497 1502 4501 1534 " +
                          "4504 1558 4501 1576 4496 1589 4490 1591 4485 1586 4476 1577 4468 1557 4464 1534 4476 1505 4518 1474 4536 1456 4551 1438 4556 1424 " +
                          "4554 1416 4548 1411 4538 1412 4525 1423 4519 1441 4522 1462 4530 1476 4542 1489 4558 1494 4576 1488 4589 1477";
            updateAircraftInformationMessage("1025", true, firstWord);
            updateAircraftInformationMessage("1025", true, secondWord);
            updateAircraftInformationMessage("1025", true, thirdWord);
            updateAircraftInformationMessage("1025", true, fourthWord);
            updateAircraftInformationMessage("1025", true, fifthWord);
            updateAircraftInformationMessage("1025", true, sixthWord);
            updateAircraftInformationMessage("1025", true, seventhWord);
            updateAircraftInformationMessage("1025", false, "");*/

            ////add a tag to an empty tag aircraft
            /*string firstTagWord, secondTagWord, thirdTagWord;
            manageAircraftTagMessageDictionary("add", "1677", 1986, 0);
            manageAircraftTagMessageDictionary("update", "1677", 0, 3);
            firstTagWord = "0 3669 518 3643 504 3627 504 3612 509 3598 518 3584 526 3573 536 3566 547 3562 556 3561 564 3563 569 3566 571 3575 575 " +
                               "3589 582 3605 590 3617 603 3627 615 3634 631 3635 643 3632 656 3623 666 3607 673 3592 676 3581 674 3573 671 3569 671 " +
                               "3569 671 3572 672 3575 672 3580 674 3588 676 3597 678 3608 677 3620 676 3634 675 3650 673 3665 669 3677 657 3687 644 " +
                               "3691 630 3690 617 3685 606 3676 601 3667 601 3659 607 3651 621 3647 637 3648 652 3651 660 3657 666 3662 667 3670 662 " +
                               "3681 650 3688 635 3690 624 3690 623 3691 626 3692 633 3694 640 3700 649 3707 653 3716 655";
            secondTagWord = "1 3714 572 3733 581 3744 580 3757 577 3771 569 3781 556 3787 542 3788 529 3784 517 3776 505 3765 502 3754 505 3744 514 " +
                                "3733 527 3729 546 3725 570 3724 593 3725 617 3728 636 3733 653 3738 666 3745 676 3754 681 3762 681 3773 676 3784 664 " +
                                "3793 649 3794 638 3792 633 3792 633 3791 634 3791 639 3790 648 3792 659 3796 666 3804 674 3813 678 3822 677 3833 670 " +
                                "3839 660 3839 646 3835 634 3832 630 3831 631 3832 637 3834 647 3838 663 3841 671 3846 677 3853 679 3861 678 3869 675";
            thirdTagWord = "2 3854 524 3866 582 3870 614 3874 645 3876 667 3878 683 3878 687 3878 685 3877 677 3875 661 3873 639 3871 621 3870 610 " +
                               "3872 606 3874 605 3878 605 3888 604 3902 603 3918 603 3932 601 3942 600 3949 599 3949 597";
            updateAircraftTagMessage("1677", true, firstTagWord);
            updateAircraftTagMessage("1677", true, secondTagWord);
            updateAircraftTagMessage("1677", true, thirdTagWord);
            updateAircraftTagMessage("1677", false, "");*/

            /*manageAircraftTagMessageDictionary("add", "1711", 1986, 0);
            manageAircraftTagMessageDictionary("update", "1711", 0, 3);
            firstTagWord = "0 3669 518 3643 504 3627 504 3612 509 3598 518 3584 526 3573 536 3566 547 3562 556 3561 564 3563 569 3566 571 3575 575 " +
                               "3589 582 3605 590 3617 603 3627 615 3634 631 3635 643 3632 656 3623 666 3607 673 3592 676 3581 674 3573 671 3569 671 " +
                               "3569 671 3572 672 3575 672 3580 674 3588 676 3597 678 3608 677 3620 676 3634 675 3650 673 3665 669 3677 657 3687 644 " +
                               "3691 630 3690 617 3685 606 3676 601 3667 601 3659 607 3651 621 3647 637 3648 652 3651 660 3657 666 3662 667 3670 662 " +
                               "3681 650 3688 635 3690 624 3690 623 3691 626 3692 633 3694 640 3700 649 3707 653 3716 655";
            secondTagWord = "1 3714 572 3733 581 3744 580 3757 577 3771 569 3781 556 3787 542 3788 529 3784 517 3776 505 3765 502 3754 505 3744 514 " +
                                "3733 527 3729 546 3725 570 3724 593 3725 617 3728 636 3733 653 3738 666 3745 676 3754 681 3762 681 3773 676 3784 664 " +
                                "3793 649 3794 638 3792 633 3792 633 3791 634 3791 639 3790 648 3792 659 3796 666 3804 674 3813 678 3822 677 3833 670 " +
                                "3839 660 3839 646 3835 634 3832 630 3831 631 3832 637 3834 647 3838 663 3841 671 3846 677 3853 679 3861 678 3869 675";
            thirdTagWord = "2 3854 524 3866 582 3870 614 3874 645 3876 667 3878 683 3878 687 3878 685 3877 677 3875 661 3873 639 3871 621 3870 610 " +
                               "3872 606 3874 605 3878 605 3888 604 3902 603 3918 603 3932 601 3942 600 3949 599 3949 597";
            updateAircraftTagMessage("1711", true, firstTagWord);
            updateAircraftTagMessage("1711", true, secondTagWord);
            updateAircraftTagMessage("1711", true, thirdTagWord);
            updateAircraftTagMessage("1711", false, "");*/
        }

        #endregion

        #region Events handlers

        private void UserControl1_Load(object sender, EventArgs e)
        {
            //Set the drawing deleagate for the Beacon drawing
            FranceMap.PanAndZoomX = new FranceMap.PanAndZoom(PanAndZoomX);
            FranceMap.PanAndZoomY = new FranceMap.PanAndZoom(PanAndZoomY);

            //Set the drawing deleagate for the Beacon drawing
            Sector.PanAndZoomX = new Sector.PanAndZoom(PanAndZoomX);
            Sector.PanAndZoomY = new Sector.PanAndZoom(PanAndZoomY);

            //Set the drawing deleagate for the Beacon drawing
            Beacon.PanAndZoomX = new Beacon.PanAndZoom(PanAndZoomX);
            Beacon.PanAndZoomY = new Beacon.PanAndZoom(PanAndZoomY);

            //Set the drawing deleagate for the Beacon drawing
            Route.PanAndZoomX = new Route.PanAndZoom(PanAndZoomX);
            Route.PanAndZoomY = new Route.PanAndZoom(PanAndZoomY);
        }

        void Form1_MouseWheel(object sender, MouseEventArgs e)
        {
            //Store the original position
            PointF orig = GetImageCoordinates(e.X, e.Y);
            //Console.WriteLine("orig x " + orig.X + " orig y " + orig.Y);
            if (e.Delta > 0) Zoom += 0.1f * Zoom;
            if (e.Delta < 0) Zoom -= 0.1f * Zoom;

            if (Zoom < 0.1) Zoom = 0.1f;
            if (Zoom > 20) Zoom = 20.0f;

            PointF newPos = GetScreenCoordinates(orig.X, orig.Y);
            //Console.WriteLine("newPos x " + newPos.X + " newPos y " + newPos.Y);

            //Correct the pan
            PanX -= (newPos.X - e.X) / Zoom;
            PanY += (newPos.Y - e.Y) / Zoom;

            PointF Corrected = GetScreenCoordinates(e.X, e.Y);
            //Console.WriteLine("Corrected x " + newPos.X + " Corrected y " + newPos.Y);

            this.Invalidate();
        }

        private void Form1_MouseDown(object sender, MouseEventArgs e)
        {
            this.PMouseDown = new Point(e.X, e.Y);
            this.BMouseDown = true;
            PointF orig = GetImageCoordinates(e.X, e.Y);
            //Console.WriteLine("orig x " + orig.X + " orig y " + orig.Y);

            if (e.Button == System.Windows.Forms.MouseButtons.Right)
                showAircraftContextualMenu(e.X, e.Y);

            if (this.alidadeActivate)
            {
                if (!this.alidadeFirstPointSet)
                {
                    this.alidadeFirstPoint = GetImageCoordinates(e.X, e.Y);
                    this.alidadeFirstPointSet = true;
                }
                else if (this.alidadeSecondPointSet)
                {
                    this.alidadeFirstPoint = GetImageCoordinates(e.X, e.Y);
                    this.alidadeSecondPointSet = false;
                }
                else
                {
                    this.alidadeSecondPoint = GetImageCoordinates(e.X, e.Y);
                    this.alidadeSecondPointSet = true;
                }
            }
        }

        private void Form1_MouseUp(object sender, MouseEventArgs e)
        {
            this.BMouseDown = false;
            if (this.alidadeActivate && this.alidadeFirstPointSet)
            {
                this.alidadeSecondPoint = GetImageCoordinates(e.X, e.Y);
                this.alidadeSecondPointSet = true;
            }
        }

        private void Form1_MouseMove(object sender, MouseEventArgs e)
        {
            if (this.alidadeActivate)
            {
                this.alidadeCurrentPoint = GetImageCoordinates(e.X, e.Y);
            }
            else if (this.BMouseDown)
            {
                PanX += (e.X - PMouseDown.X) / Zoom;
                PanY -= (e.Y - PMouseDown.Y) / Zoom;
                PMouseDown = new Point(e.X, e.Y);
                this.Invalidate();
            }
        }

        private void alidadeLabel_Click(object sender, EventArgs e)
        {
            this.alidadeFirstPointSet = false;
            this.alidadeSecondPointSet = false;
            if (this.alidadeActivate)
            {
                alidadeLabel.Text = Config.alidadeLabelUnselectedText;
                alidadeLabel.ForeColor = Config.alidadeLabelUnselectedForeColor;
                alidadeLabel.BackColor = Config.alidadeLabelUnselectedBackColor;
                this.Cursor = Cursors.Arrow;
                this.alidadeActivate = false;
            }
            else
            {
                alidadeLabel.Text = Config.alidadeLabelSelectedText;
                alidadeLabel.ForeColor = Config.alidadeLabelSelectedForeColor;
                alidadeLabel.BackColor = Config.alidadeLabelSelectedBackColor;
                this.Cursor = Cursors.Cross;
                this.alidadeActivate = true;
            }
        }

        private void partMenuItem_Click(Object sender, EventArgs e)
        {
            if (this.partAircraftList.Contains(aircraftSelectedContextualMenu))
                managePartAircraftList("remove", aircraftSelectedContextualMenu);
            else
                managePartAircraftList("add", aircraftSelectedContextualMenu);
        }

        private void warningMenuItem_Click(Object sender, EventArgs e)
        {
            if (this.warningAircraftList.Contains(aircraftSelectedContextualMenu))
                manageWarningAircraftList("remove", aircraftSelectedContextualMenu);
            else
                manageWarningAircraftList("add", aircraftSelectedContextualMenu);
        }

        private void selectedAircraftTimer_Tick(object source, EventArgs e)
        {
            if ((this.xSelectedAircraftPosition != 0) && (this.ySelectedAircraftPosition != 0))
            {
                /*PointF selectedAircraftScreenCoord = GetScreenCoordinates((float)this.xSelectedAircraftPosition, (float)this.ySelectedAircraftPosition);

                if (this.selectedAircraftFound == false)
                {
                    int xCenterScreenCoord = this.ClientRectangle.Right / 2;
                    int yCenterScreenCoord = this.ClientRectangle.Bottom / 2;
                    this.xShift = (selectedAircraftScreenCoord.X - xCenterScreenCoord) / iterationsToFocus;
                    this.yShift = (selectedAircraftScreenCoord.Y - yCenterScreenCoord) / iterationsToFocus;
                    this.xCircleCenterPosition = xCenterScreenCoord;
                    this.yCircleCenterPosition = yCenterScreenCoord;
                    this.selectedAircraftFound = true;
                }
                else
                {
                    if (this.iterationsToFocus == 0)
                    {
                        this.xCircleCenterPosition = selectedAircraftScreenCoord.X;
                        this.yCircleCenterPosition = selectedAircraftScreenCoord.Y;
                    }
                    else
                    {
                        this.xCircleCenterPosition += xShift;
                        this.yCircleCenterPosition += yShift;
                        this.iterationsToFocus--;
                    }
                }

                this.xCircleCenterPosition = selectedAircraftScreenCoord.X;
                this.yCircleCenterPosition = selectedAircraftScreenCoord.Y;*/

                int firstRadiusIncrease = -(Config.firstSelectedAircraftCircleRadiusDecrease);
                int secondRadiusIncrease = -(Config.secondSelectedAircraftCircleRadiusDecrease);
                int margin = 40;
                int circleBorderX = 0;
                int circleBorderY = 0;
                int newRadiusX = 0;
                int newRadiusY = 0;
                PointF coord = GetScreenCoordinates((float)this.xSelectedAircraftPosition, (float)this.ySelectedAircraftPosition);
                string screenPosition = getAircraftScreenLocation((float)this.xSelectedAircraftPosition, (float)this.ySelectedAircraftPosition);
                int acX = (int)coord.X;
                int acY = (int)coord.Y;
                int top = this.ClientRectangle.Top;
                int right = this.ClientRectangle.Right;
                int bottom = this.ClientRectangle.Bottom;
                int left = this.ClientRectangle.Left;

                switch (screenPosition)
                {
                    case "C":
                        break;
                    case "N":
                        circleBorderY = acY + (int)this.selectedAircraftRadius / 2;
                        if (circleBorderY <= margin)
                        {
                            firstRadiusIncrease = 0;
                            secondRadiusIncrease = 0;
                            this.selectedAircraftRadius = (-acY + margin) * 2;
                        }
                        break;
                    case "NE":
                        circleBorderX = acX - (int)this.selectedAircraftRadius / 2;
                        circleBorderY = acY + (int)this.selectedAircraftRadius / 2;
                        if ((circleBorderX >= (right - margin)) || (circleBorderY <= margin))
                        {
                            firstRadiusIncrease = 0;
                            secondRadiusIncrease = 0;
                            newRadiusX = (acX - (right - margin)) * 2;
                            newRadiusY = (-acY + margin) * 2;
                            this.selectedAircraftRadius = Math.Max(newRadiusX, newRadiusY);
                        }
                        break;
                    case "E":
                        circleBorderX = acX - (int)this.selectedAircraftRadius / 2;
                        if (circleBorderX >= (right - margin))
                        {
                            firstRadiusIncrease = 0;
                            secondRadiusIncrease = 0;
                            this.selectedAircraftRadius = (acX - (right - margin)) * 2;
                        }
                        break;
                    case "SE":
                        circleBorderX = acX - (int)this.selectedAircraftRadius / 2;
                        circleBorderY = acY - (int)this.selectedAircraftRadius / 2;
                        if ((circleBorderX >= (right - margin)) || (circleBorderY >= (bottom - margin)))
                        {
                            firstRadiusIncrease = 0;
                            secondRadiusIncrease = 0;
                            newRadiusX = (acX - (right - margin)) * 2;
                            newRadiusY = (acY - (bottom - margin)) * 2;
                            this.selectedAircraftRadius = Math.Max(newRadiusX, newRadiusY);
                        }
                        break;
                    case "S":
                        circleBorderY = acY - (int)this.selectedAircraftRadius / 2;
                        if (circleBorderY >= (bottom - margin))
                        {
                            firstRadiusIncrease = 0;
                            secondRadiusIncrease = 0;
                            this.selectedAircraftRadius = (acY - (bottom - margin)) * 2;
                        }
                        break;
                    case "SW":
                        circleBorderX = acX + (int)this.selectedAircraftRadius / 2;
                        circleBorderY = acY - (int)this.selectedAircraftRadius / 2;
                        if ((circleBorderX <= margin) || (circleBorderY >= (bottom - margin)))
                        {
                            firstRadiusIncrease = 0;
                            secondRadiusIncrease = 0;
                            newRadiusX = (-acX + margin) * 2;
                            newRadiusY = (acY - (bottom - margin)) * 2;
                            this.selectedAircraftRadius = Math.Max(newRadiusX, newRadiusY);
                        }
                        break;
                    case "W":
                        circleBorderX = acX + (int)this.selectedAircraftRadius / 2;
                        if (circleBorderX <= margin)
                        {
                            firstRadiusIncrease = 0;
                            secondRadiusIncrease = 0;
                            this.selectedAircraftRadius = (-acX + margin) * 2;
                        }
                        break;
                    case "NW":
                        circleBorderX = acX + (int)this.selectedAircraftRadius / 2;
                        circleBorderY = acY + (int)this.selectedAircraftRadius / 2;
                        if ((circleBorderX <= margin) || (circleBorderY <= margin))
                        {
                            firstRadiusIncrease = 0;
                            secondRadiusIncrease = 0;
                            newRadiusX = (-acX + margin) * 2;
                            newRadiusY = (-acY + margin) * 2;
                            this.selectedAircraftRadius = Math.Max(newRadiusX, newRadiusY);
                        }
                        break;
                    default:
                        break;
                }

                if ((this.selectedAircraftRadius + firstRadiusIncrease) >= (double)Config.aircraftSelectedCircleRadiusMinimumSize)
                    this.selectedAircraftRadius += (double)firstRadiusIncrease;
                else if ((this.selectedAircraftRadius + secondRadiusIncrease) >= (double)Config.aircraftSelectedCircleRadiusMinimumSize)
                    this.selectedAircraftRadius += (double)secondRadiusIncrease;

                this.Invalidate();
            }
        }

        private void aircraftModsTimer_Tick(object source, EventArgs e)
        {
            List<string> aircraftToDeleteList = new List<string>();

            foreach (string aircraft in this.aircraftModSDictionary.Keys)
            {
                float xPos = (float)this.aircraftModSDictionary[aircraft]["xPos"];
                float yPos = (float)this.aircraftModSDictionary[aircraft]["yPos"];
                int timerLifetime = (int)this.aircraftModSDictionary[aircraft]["timeRemaining"];

                if ((xPos != (float)0) && (yPos != (float)0) && (timerLifetime > 0))
                {
                    /*PointF aircraftScreenCoord = GetScreenCoordinates(xPos, yPos);
                    bool aircraftFound = (bool)this.aircraftModSDictionary[aircraft]["aircraftFound"];
                    int iterations = (int)this.aircraftModSDictionary[aircraft]["iterationsToFocus"];

                    if (aircraftFound == false)
                    {
                        int xCenterScreenCoord = this.ClientRectangle.Right / 2;
                        int yCenterScreenCoord = this.ClientRectangle.Bottom / 2;
                        this.aircraftModSDictionary[aircraft]["xShift"] = (float)((aircraftScreenCoord.X - xCenterScreenCoord) / iterations);
                        this.aircraftModSDictionary[aircraft]["yShift"] = (float)((aircraftScreenCoord.Y - yCenterScreenCoord) / iterations);
                        this.aircraftModSDictionary[aircraft]["xCirclePosition"] = (float)xCenterScreenCoord;
                        this.aircraftModSDictionary[aircraft]["yCirclePosition"] = (float)yCenterScreenCoord;
                        this.aircraftModSDictionary[aircraft]["aircraftFound"] = true;
                    }
                    else
                    {
                        if (iterations == 0)
                        {
                            this.aircraftModSDictionary[aircraft]["xCirclePosition"] = (float)aircraftScreenCoord.X;
                            this.aircraftModSDictionary[aircraft]["yCirclePosition"] = (float)aircraftScreenCoord.Y;
                        }
                        else
                        {
                            this.aircraftModSDictionary[aircraft]["xCirclePosition"] = (float)((float)this.aircraftModSDictionary[aircraft]["xCirclePosition"] + (float)this.aircraftModSDictionary[aircraft]["xShift"]);
                            this.aircraftModSDictionary[aircraft]["yCirclePosition"] = (float)((float)this.aircraftModSDictionary[aircraft]["yCirclePosition"] + (float)this.aircraftModSDictionary[aircraft]["yShift"]);
                            iterations--;
                            this.aircraftModSDictionary[aircraft]["iterationsToFocus"] = (int)iterations;
                        }
                    }*/

                    int iterations = (int)this.aircraftModSDictionary[aircraft]["iterationsToFocus"];
                    if (iterations > 0)
                        iterations--;
                    this.aircraftModSDictionary[aircraft]["iterationsToFocus"] = (int)iterations;

                    timerLifetime -= this.aircraftModsTimer.Interval;
                    this.aircraftModSDictionary[aircraft]["timeRemaining"] = timerLifetime;

                    /*double radius = (double)this.aircraftModSDictionary[aircraft]["radius"];
                    if (radius > (double)60)
                        radius -= (double)40;
                    this.aircraftModSDictionary[aircraft]["radius"] = radius;*/
                }

                if (timerLifetime <= 0)
                    aircraftToDeleteList.Add(aircraft);
            }

            foreach (string aircraft in aircraftToDeleteList)
                this.aircraftModSDictionary.Remove(aircraft);
            aircraftToDeleteList = null;

            this.Invalidate();
        }

        private void aircraftAlarmsTimer_Tick(object source, EventArgs e)
        {
            List<string> aircraftToDeleteList = new List<string>();
            //bool refresh = false;
            this.alarmListBox.Items.Clear();

            foreach (string aircraft in this.aircraftAlarmsDictionary.Keys)
            {
                float xPos = (float)this.aircraftAlarmsDictionary[aircraft]["xPos"];
                float yPos = (float)this.aircraftAlarmsDictionary[aircraft]["yPos"];
                int timerLifetime = (int)this.aircraftAlarmsDictionary[aircraft]["timeRemaining"];
                bool alarmLaunched = (bool)this.aircraftAlarmsDictionary[aircraft]["alarmLaunched"];

                if ((xPos != (float)0) && (yPos != (float)0) && (timerLifetime > 0))
                {
                    if (alarmLaunched)
                    {

                        /*refresh = true;

                        PointF aircraftScreenCoord = GetScreenCoordinates(xPos, yPos);
                        bool aircraftFound = (bool)this.aircraftAlarmsDictionary[aircraft]["aircraftFound"];
                        int iterations = (int)this.aircraftAlarmsDictionary[aircraft]["iterationsToFocus"];

                        if (aircraftFound == false)
                        {
                            int xCenterScreenCoord = this.ClientRectangle.Right / 2;
                            int yCenterScreenCoord = this.ClientRectangle.Bottom / 2;
                            this.aircraftAlarmsDictionary[aircraft]["xShift"] = (float)((aircraftScreenCoord.X - xCenterScreenCoord) / iterations);
                            this.aircraftAlarmsDictionary[aircraft]["yShift"] = (float)((aircraftScreenCoord.Y - yCenterScreenCoord) / iterations);
                            this.aircraftAlarmsDictionary[aircraft]["xCirclePosition"] = (float)xCenterScreenCoord;
                            this.aircraftAlarmsDictionary[aircraft]["yCirclePosition"] = (float)yCenterScreenCoord;
                            this.aircraftAlarmsDictionary[aircraft]["aircraftFound"] = true;
                        }
                        else
                        {
                            if (iterations == 0)
                            {
                                this.aircraftAlarmsDictionary[aircraft]["xCirclePosition"] = (float)aircraftScreenCoord.X;
                                this.aircraftAlarmsDictionary[aircraft]["yCirclePosition"] = (float)aircraftScreenCoord.Y;
                            }
                            else
                            {
                                this.aircraftAlarmsDictionary[aircraft]["xCirclePosition"] = (float)((float)this.aircraftAlarmsDictionary[aircraft]["xCirclePosition"] + (float)this.aircraftAlarmsDictionary[aircraft]["xShift"]);
                                this.aircraftAlarmsDictionary[aircraft]["yCirclePosition"] = (float)((float)this.aircraftAlarmsDictionary[aircraft]["yCirclePosition"] + (float)this.aircraftAlarmsDictionary[aircraft]["yShift"]);
                                iterations--;
                                this.aircraftAlarmsDictionary[aircraft]["iterationsToFocus"] = (int)iterations;
                            }
                        }*/

                        int iterations = (int)this.aircraftAlarmsDictionary[aircraft]["iterationsToFocus"];
                        if (iterations > 0)
                            iterations--;
                        this.aircraftAlarmsDictionary[aircraft]["iterationsToFocus"] = (int)iterations;

                        timerLifetime -= this.aircraftAlarmsTimer.Interval;
                        this.aircraftAlarmsDictionary[aircraft]["timeRemaining"] = timerLifetime;

                        /*double radius = (double)this.aircraftAlarmsDictionary[aircraft]["radius"];
                        if (radius > (double)60)
                            radius -= (double)40;
                        this.aircraftAlarmsDictionary[aircraft]["radius"] = radius;*/
                    }
                    else
                    {
                        int feedbackLifetime = (int)this.aircraftAlarmsDictionary[aircraft]["feedbackTimeRemaining"];
                        feedbackLifetime -= this.aircraftAlarmsTimer.Interval;
                        this.aircraftAlarmsDictionary[aircraft]["feedbackTimeRemaining"] = (int)feedbackLifetime;
                    }
                }

                if (timerLifetime <= 0)
                    aircraftToDeleteList.Add(aircraft);
                else if (alarmLaunched)
                    this.alarmListBox.Items.Add(this.aircraftAlarmsDictionary[aircraft]["hour"] + "h" + this.aircraftAlarmsDictionary[aircraft]["minute"] + "m" + this.aircraftAlarmsDictionary[aircraft]["second"] + "s --> Flight n°" + aircraft);
            }

            foreach (string aircraft in aircraftToDeleteList)
                this.aircraftAlarmsDictionary.Remove(aircraft);
            aircraftToDeleteList = null;

            /*if (refresh)
            {
                alarmPictureBox.Visible = true;
                alarmListBox.Visible = true;
            }
            else
            {
                alarmPictureBox.Visible = false;
                alarmListBox.Visible = false;
            }*/

            this.Invalidate();
        }

        private void informationMessageLabel_Click(object sender, EventArgs e)
        {
            Label lbl = (sender as Label);
            if (lbl != null)
            {
                lbl.Visible = false;
                PictureBox pBox = (PictureBox)this.aircraftInformationMessagesDictionary[lbl.Name]["picturebox"];
                pBox.Visible = true;
                this.Invalidate();
            }
        }

        private void informationMessagePictureBox_Click(object sender, EventArgs e)
        {
            PictureBox pBox = (sender as PictureBox);
            if (pBox != null)
            {
                if (!(this.selectedAircraft == pBox.Name))
                {
                    pBox.Visible = false;
                    Label lbl = (Label)this.aircraftInformationMessagesDictionary[pBox.Name]["label"];
                    lbl.Visible = true;
                    this.Invalidate();
                }
            }
        }

        #endregion

        #region Drawing methods

        protected override void OnPaint(PaintEventArgs e)
        {
            Graphics g = e.Graphics;
            g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;

            Pen drawPlotsPen = Config.defaultDrawPlotsPen;
            SolidBrush fillPartRectangleBrush = new SolidBrush(Config.defaultFillPartRectangleColor);
            Pen drawLinePen = Config.defaultDrawLinePen;
            SolidBrush drawStringBrush = new SolidBrush(Config.defaultDrawStringColor);
            Font aircraftTagFont = Config.defaultAircraftTagFont;

            alarmListBox.Location = new Point((this.Width - alarmListBox.Width - 10), 10);

            //Clear the view
            g.FillRectangle(new SolidBrush(Color.FromArgb(255, ColorTranslator.FromHtml("#7a797c"))), 0, 0, Width, Height);


            #region Sectors drawing

            //Draw the sectors
            if (data != null)
            {
                //Console.WriteLine("Nombre de secteurs : " + Sectors.Length);
                foreach (Sector s in data.getSectors())
                {
                    //Console.WriteLine("Nom du secteur : " + s.Name);
                    if (s.Name == Config.selectedSectorName)
                    {
                        s.isSectorSelected = true;
                        selectedSector = s;
                    }
                    s.Draw(g, false);
                }
            }

            #endregion

            #region Routes drawing

            //Draw the routes
            if (data != null)
            {
                int existingRoutesNumber = 0;
                foreach (Route r in data.getRoutes())
                {
                    if ((IsBeaconInBeaconsArray(data.getBeacons(), r.B1)) && (IsBeaconInBeaconsArray(data.getBeacons(), r.B2)))
                    {
                        r.Draw(g);
                        existingRoutesNumber++;
                    }
                }
                //Console.WriteLine("Correct routes number : " + existingRoutesNumber + " on " + Routes.Length);
            }

            #endregion

            #region Aircraft drawing

            AircraftPosition selectedAircraft = null;
            Rectangle selectedHotBox = Rectangle.Empty;
            //Draw the aircraft
            if (data != null)
            {
                foreach (var track in data.getAircraftList())
                {
                    drawPlotsPen = Config.defaultDrawPlotsPen;
                    fillPartRectangleBrush = new SolidBrush(Config.defaultFillPartRectangleColor);
                    drawLinePen = Config.defaultDrawLinePen;
                    drawStringBrush = new SolidBrush(Config.defaultDrawStringColor);
                    aircraftTagFont = Config.defaultAircraftTagFont;

                    if (track.Value.Count > 0)
                    {
                        int dx = (int)(10 * Zoom) / 2;
                        AircraftPosition aircraft = track.Value[track.Value.Count - 1];

                        string aflTendancy = aircraft.AFL + "  ";

                        if (aircraft.Tendency == -1)
                            aflTendancy += Config.descentTendency;
                        else if (aircraft.Tendency == 0)
                            aflTendancy += Config.stableTendency;
                        else if (aircraft.Tendency == 1)
                            aflTendancy += Config.climbTendency;

                        //for the followed aircraft
                        if (this.aircraftFollowedDictionary.ContainsKey(aircraft.Flight))
                        {
                            PictureBox aircraftFollowedPictureBox = this.aircraftFollowedDictionary[aircraft.Flight];
                            PointF coord = GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y);
                            string screenPosition = getAircraftScreenLocation((float)aircraft.X, (float)aircraft.Y);
                            int margin = 10;
                            int acX = (int)coord.X;
                            int acY = (int)coord.Y;
                            int pbWidth = aircraftFollowedPictureBox.Width;
                            int pbHeight = aircraftFollowedPictureBox.Height;
                            int top = this.ClientRectangle.Top;
                            int right = this.ClientRectangle.Right;
                            int bottom = this.ClientRectangle.Bottom;
                            int left = this.ClientRectangle.Left;

                            try
                            {
                                aircraftFollowedPictureBox.Image = Image.FromFile(Config.picturesFolderName + "/" + screenPosition + Config.picturesUsedArrowsNamesSuffix);
                            }
                            catch { }

                            switch (screenPosition)
                            {
                                case "C":
                                    aircraftFollowedPictureBox.Visible = false;
                                    break;
                                case "N":
                                    aircraftFollowedPictureBox.Location = new Point(acX - pbWidth / 2, top + margin);
                                    g.DrawString(aircraft.CallSign, Config.followedAircraftFont, new SolidBrush(Config.followedAircraftColor), acX - 40, top + margin + pbHeight + 10);
                                    g.DrawString(aflTendancy, Config.followedAircraftFont, new SolidBrush(Config.followedAircraftColor), acX - 20, top + margin + pbHeight + 30);
                                    aircraftFollowedPictureBox.Visible = true;
                                    break;
                                case "NE":
                                    aircraftFollowedPictureBox.Location = new Point(right - pbWidth - margin, top + margin);
                                    g.DrawString(aircraft.CallSign, Config.followedAircraftFont, new SolidBrush(Config.followedAircraftColor), right - pbWidth - margin - 20, top + margin + pbHeight);
                                    g.DrawString(aflTendancy, Config.followedAircraftFont, new SolidBrush(Config.followedAircraftColor), right - pbWidth - margin, top + margin + pbHeight + 20);
                                    aircraftFollowedPictureBox.Visible = true;
                                    break;
                                case "E":
                                    aircraftFollowedPictureBox.Location = new Point(right - pbWidth - margin, acY - pbHeight / 2);
                                    g.DrawString(aircraft.CallSign, Config.followedAircraftFont, new SolidBrush(Config.followedAircraftColor), right - pbWidth - margin - 80, acY - 20);
                                    g.DrawString(aflTendancy, Config.followedAircraftFont, new SolidBrush(Config.followedAircraftColor), right - pbWidth - margin - 60, acY);
                                    aircraftFollowedPictureBox.Visible = true;
                                    break;
                                case "SE":
                                    aircraftFollowedPictureBox.Location = new Point(right - pbWidth - margin, bottom - pbHeight - margin);
                                    g.DrawString(aircraft.CallSign, Config.followedAircraftFont, new SolidBrush(Config.followedAircraftColor), right - pbWidth - margin - 20, bottom - pbHeight - margin - 40);
                                    g.DrawString(aflTendancy, Config.followedAircraftFont, new SolidBrush(Config.followedAircraftColor), right - pbWidth - margin, bottom - pbHeight - margin - 20);
                                    aircraftFollowedPictureBox.Visible = true;
                                    break;
                                case "S":
                                    aircraftFollowedPictureBox.Location = new Point(acX - pbWidth / 2, bottom - pbHeight - margin);
                                    g.DrawString(aircraft.CallSign, Config.followedAircraftFont, new SolidBrush(Config.followedAircraftColor), acX - 40, bottom - pbHeight - margin - 40);
                                    g.DrawString(aflTendancy, Config.followedAircraftFont, new SolidBrush(Config.followedAircraftColor), acX - 20, bottom - pbHeight - margin - 20);
                                    aircraftFollowedPictureBox.Visible = true;
                                    break;
                                case "SW":
                                    aircraftFollowedPictureBox.Location = new Point(left + margin, bottom - pbHeight - margin);
                                    g.DrawString(aircraft.CallSign, Config.followedAircraftFont, new SolidBrush(Config.followedAircraftColor), left + margin + pbWidth - 20, bottom - pbHeight - margin - 40);
                                    g.DrawString(aflTendancy, Config.followedAircraftFont, new SolidBrush(Config.followedAircraftColor), left + margin + pbWidth, bottom - pbHeight - margin - 20);
                                    aircraftFollowedPictureBox.Visible = true;
                                    break;
                                case "W":
                                    aircraftFollowedPictureBox.Location = new Point(left + margin, acY - pbHeight / 2);
                                    g.DrawString(aircraft.CallSign, Config.followedAircraftFont, new SolidBrush(Config.followedAircraftColor), left + margin + pbWidth + 10, acY - 20);
                                    g.DrawString(aflTendancy, Config.followedAircraftFont, new SolidBrush(Config.followedAircraftColor), left + margin + pbWidth + 30, acY);
                                    aircraftFollowedPictureBox.Visible = true;
                                    break;
                                case "NW":
                                    aircraftFollowedPictureBox.Location = new Point(left + margin, top + margin);
                                    g.DrawString(aircraft.CallSign, Config.followedAircraftFont, new SolidBrush(Config.followedAircraftColor), left + margin + pbWidth - 20, top + margin + pbHeight);
                                    g.DrawString(aflTendancy, Config.followedAircraftFont, new SolidBrush(Config.followedAircraftColor), left + margin + pbWidth, top + margin + pbHeight + 20);
                                    aircraftFollowedPictureBox.Visible = true;
                                    break;
                                default:
                                    break;
                            }

                            if (!(this.Controls.Contains(aircraftFollowedPictureBox)))
                                this.Controls.Add(aircraftFollowedPictureBox);
                        }

                        //Set coordinates of the separation concerned aircraft
                        if (this.aircraftBeaconSeparationDictionary.Count > 0)
                        {
                            if (aircraft.Flight == this.aircraftBeaconSeparationDictionary["aircraft1"])
                            {
                                separationAcOneX = (float)aircraft.X;
                                separationAcOneY = (float)aircraft.Y;
                                separationAcOneFound = true;
                            }
                            if (aircraft.Flight == this.aircraftBeaconSeparationDictionary["aircraft2"])
                            {
                                separationAcTwoX = (float)aircraft.X;
                                separationAcTwoY = (float)aircraft.Y;
                                separationAcTwoFound = true;
                            }
                        }

                        //Determine pens and brush depending on flight level filter, if active
                        if (this.aflFilterList.Count == 2)
                        {
                            if (this.aflFilterList[1] < 0)
                            {
                                aflInf = this.aflFilterList[0] + this.aflFilterList[1];
                                aflSup = this.aflFilterList[0];
                            }
                            else
                            {
                                aflInf = this.aflFilterList[0];
                                aflSup = this.aflFilterList[0] + this.aflFilterList[1];
                            }

                            if (this.aflFilterAircraftList.Contains(aircraft.Flight))
                            {
                                aircraftTagFont = Config.filteredAircraftTagFont;
                                drawStringBrush = new SolidBrush(Config.defaultDrawStringColor);
                                drawLinePen = Config.filteredDrawLinePen;
                                drawPlotsPen = Config.defaultDrawPlotsPen;
                            }
                            else
                            {
                                if ((aircraft.AFL < aflInf) || (aircraft.AFL > aflSup))
                                {
                                    aircraftTagFont = Config.defaultAircraftTagFont;
                                    drawStringBrush = new SolidBrush(Config.unfilteredDrawStringColor);
                                    drawLinePen = Config.unfilteredDrawLinePen;
                                    drawPlotsPen = Config.unfilteredDrawPlotsPen;
                                    fillPartRectangleBrush = new SolidBrush(Config.unfilteredFillPartRectangleColor);
                                }
                                else
                                {
                                    aircraftTagFont = Config.filteredAircraftTagFont;
                                    drawStringBrush = new SolidBrush(Config.defaultDrawStringColor);
                                    drawLinePen = Config.filteredDrawLinePen;
                                    drawPlotsPen = Config.defaultDrawPlotsPen;
                                }
                            }
                        }

                        SizeF s = g.MeasureString(aircraft.CallSign, Font);

                        //Set selected aircraft coordinates, if one
                        if (this.SelectedAircraft == aircraft.Flight)
                        {
                            this.xSelectedAircraftPosition = aircraft.X;
                            this.ySelectedAircraftPosition = aircraft.Y;
                            PointF selectedAircraftScreenCoord = GetScreenCoordinates((float)this.xSelectedAircraftPosition, (float)this.ySelectedAircraftPosition);
                            this.xCircleCenterPosition = selectedAircraftScreenCoord.X;
                            this.yCircleCenterPosition = selectedAircraftScreenCoord.Y;
                        }

                        //Highlight part aircraft
                        if (partAircraftList.Contains(aircraft.Flight))
                        {
                            drawPlotsPen = Config.partDrawPlotsPen;
                            g.FillRectangle(fillPartRectangleBrush,
                                            GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).X + dx,
                                            GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).Y - dx,
                                            s.Width,
                                            s.Height);
                        }

                        //Highlight warning aircraft
                        if (warningAircraftList.Contains(aircraft.Flight))
                        {
                            drawPlotsPen = Config.warningDrawPlotsPen;
                            PointF p1 = new PointF(GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).X + dx + s.Width + 8, GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).Y - dx);
                            PointF p2 = new PointF(GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).X + dx + s.Width + 13, GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).Y - dx + s.Height / 2);
                            PointF p3 = new PointF(GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).X + dx + s.Width + 8, GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).Y - dx + s.Height);
                            PointF p4 = new PointF(GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).X + dx + s.Width + 3, GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).Y - dx + s.Height / 2);
                            PointF[] warningLosangeArray = { p1, p2, p3, p4 };
                            g.FillPolygon(new SolidBrush(Config.warningFillPolygonColor),
                                          warningLosangeArray);
                        }

                        //Draw aircraft tag if not anonymous : call sign + flight level + tendancy + ground speed + tag line
                        if (!(this.aircraftTagMessagesDictionary.ContainsKey(aircraft.Flight)))
                        {
                            g.DrawString(aircraft.CallSign,
                                         aircraftTagFont,
                                         drawStringBrush,
                                         GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).X + dx,
                                         GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).Y - dx);

                            /*g.DrawString(aircraft.Sector,
                                     aircraftTagFont,
                                     drawStringBrush,
                                     GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).X + dx,
                                     GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).Y - dx + 2 * s.Height);*/
                        }
                        else
                        {
                            /*string stripNbr = "";
                            if (this.aircraftTagMessagesDictionary[aircraft.Flight].ContainsKey("strip"))
                                stripNbr = " / Strip " + (int)this.aircraftTagMessagesDictionary[aircraft.Flight]["strip"];*/

                            g.DrawString(aircraft.Ssr,
                                             aircraftTagFont,
                                             drawStringBrush,
                                             GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).X + dx,
                                             GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).Y - dx);

                            if (this.aircraftTagMessagesDictionary[aircraft.Flight].ContainsKey("picturebox"))
                            {
                                //bool buildingMessage = (bool)this.aircraftTagMessagesDictionary[aircraft.Flight]["buildingmessage"];
                                //if (!buildingMessage)
                                //{
                                PictureBox pBox = (PictureBox)this.aircraftTagMessagesDictionary[aircraft.Flight]["picturebox"];
                                pBox.Location = new Point((int)GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).X + dx,
                                                          (int)GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).Y - dx + (int)(s.Height * 2.2));
                                pBox.Visible = true;
                                if (!(this.Controls.Contains(pBox)))
                                    this.Controls.Add(pBox);
                                //}
                            }
                        }

                        g.DrawString("" + (int)(aircraft.GroundSpeed / 10),
                                     aircraftTagFont,
                                     drawStringBrush,
                                     GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).X + dx,
                                     GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).Y - dx - s.Height);

                        g.DrawString(aflTendancy,
                                     aircraftTagFont,
                                     drawStringBrush,
                                     GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).X + dx,
                                     GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).Y - dx + s.Height);

                        g.DrawLine(drawLinePen,
                                   GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).X + dx,
                                   GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).Y - dx + Font.Height / 2,
                                   GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).X,
                                   GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).Y);

                        //Draw the ModS for the aircraft, if one
                        if (this.aircraftModSDictionary.ContainsKey(aircraft.Flight))
                        {
                            this.aircraftModSDictionary[aircraft.Flight]["xPos"] = (float)aircraft.X;
                            this.aircraftModSDictionary[aircraft.Flight]["yPos"] = (float)aircraft.Y;
                            string modsPrefix = "";
                            string modsSuffix = "";
                            string succeed = (string)this.aircraftModSDictionary[aircraft.Flight]["succeed"];
                            int iterations = (int)this.aircraftModSDictionary[aircraft.Flight]["iterationsToFocus"];

                            Color color = Config.modsNormalColor;

                            if (iterations == 0)
                            {
                                if (succeed.ToLower() == "true")
                                {
                                    color = Config.modsSucceedColor;
                                    modsPrefix = Config.modsPrefix;
                                    modsSuffix = Config.modsSuffix;
                                }
                                else
                                    color = Config.modsUnsucceedColor;
                            }

                            g.DrawString(modsPrefix + (string)this.aircraftModSDictionary[aircraft.Flight]["level"] + "M" + modsSuffix + " " + (string)this.aircraftModSDictionary[aircraft.Flight]["nextSector"],
                                         Config.modsFont,
                                         new SolidBrush(Color.FromArgb(255, color)),
                                         GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).X + dx,
                                         GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).Y - dx + 2 * s.Height);
                        }

                        //Launch the alarm for the aircraft, if one
                        if (this.aircraftAlarmsDictionary.ContainsKey(aircraft.Flight))
                        {
                            int hour = (int)this.aircraftAlarmsDictionary[aircraft.Flight]["hour"];
                            int minute = (int)this.aircraftAlarmsDictionary[aircraft.Flight]["minute"];
                            int second = (int)this.aircraftAlarmsDictionary[aircraft.Flight]["second"];

                            this.aircraftAlarmsDictionary[aircraft.Flight]["xPos"] = (float)aircraft.X;
                            this.aircraftAlarmsDictionary[aircraft.Flight]["yPos"] = (float)aircraft.Y;

                            PictureBox pBox = (PictureBox)this.aircraftAlarmsDictionary[aircraft.Flight]["picturebox"];

                            if ((this.CurrentHour >= hour) && (this.CurrentMinute >= minute) && (this.CurrentSecond >= second))
                            {
                                this.aircraftAlarmsDictionary[aircraft.Flight]["alarmLaunched"] = true;
                                pBox.Visible = false;
                                if (this.Controls.Contains(pBox))
                                    this.Controls.Remove(pBox);
                            }
                            else
                            {
                                pBox.Location = new Point((int)(GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).X + dx), (int)(GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).Y - dx - 2 * s.Height));
                                pBox.Visible = true;

                                if (!(this.Controls.Contains(pBox)))
                                    this.Controls.Add(pBox);

                                int feedbackLifetime = (int)this.aircraftAlarmsDictionary[aircraft.Flight]["feedbackTimeRemaining"];
                                if (feedbackLifetime > 0)
                                {
                                    g.DrawString((int)this.aircraftAlarmsDictionary[aircraft.Flight]["hour"] + "h" + (int)this.aircraftAlarmsDictionary[aircraft.Flight]["minute"] + "m",
                                                 Config.alarmFont,
                                                 new SolidBrush(Config.alarmColor),
                                                 GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).X + dx + 16,
                                                 GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).Y - dx - 2 * s.Height);
                                }
                                /*else
                                {
                                    pBox.Visible = false;
                                    if (this.Controls.Contains(pBox))
                                        this.Controls.Remove(pBox);
                                }*/
                            }
                        }

                        //Check if an information message is associated
                        if (this.aircraftInformationMessagesDictionary.ContainsKey(aircraft.Flight))
                        {
                            bool buildingMessage = (bool)this.aircraftInformationMessagesDictionary[aircraft.Flight]["buildingmessage"];

                            if (!buildingMessage)
                            {
                                Label lbl = (Label)this.aircraftInformationMessagesDictionary[aircraft.Flight]["label"];
                                PictureBox pBox = (PictureBox)this.aircraftInformationMessagesDictionary[aircraft.Flight]["picturebox"];

                                if (!(this.Controls.Contains(lbl)))
                                {
                                    lbl.Click += new EventHandler(informationMessageLabel_Click);
                                    this.Controls.Add(lbl);
                                }

                                if (!(this.Controls.Contains(pBox)))
                                {
                                    pBox.Click += new EventHandler(informationMessagePictureBox_Click);
                                    this.Controls.Add(pBox);
                                }

                                lbl.Font = new Font(Config.iInformationMessageLabelFontFamily, (float)(Config.iInformationMessageLabelFontSizeCoefficient * dx), FontStyle.Bold);
                                lbl.Size = new Size(dx, dx);
                                lbl.Location = new Point((int)GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).X + dx + (int)(s.Width / 1.6), (int)GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).Y - dx + (int)(s.Height * 1.2));

                                pBox.Location = new Point((int)GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).X + dx + (int)(s.Width / 1.6), (int)GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).Y - dx + (int)(s.Height * 1.2));

                                if (pBox.Visible == false)
                                    lbl.Visible = true;
                            }
                        }

                        //Get the bounding Hot Box  : only the label
                        SizeF maxTextSize = g.MeasureString(aircraft.CallSign, Font);
                        PointF pt = GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y);

                        Rectangle HotBoxRect = new Rectangle( (int)(pt.X) + dx,
                                                              (int)(pt.Y - dx - s.Height),
                                                              (int)(s.Width + 10),
                                                              (int)(s.Height * 3)  );

                        if (HotBoxRect.Contains(new Point((int)AnotoPenDown.X, (int)AnotoPenDown.Y)))
                        {
                            selectedAircraft = aircraft;
                            selectedHotBox = HotBoxRect;
                        }

                    }                    

                    //Draw the aircraft plots
                    int pos = 0;
                    foreach (var plot in track.Value)
                    {
                        float dx = (pos * Zoom) / 5;
                        float x = GetScreenCoordinates((float)plot.X, (float)plot.Y).X - dx / 2;
                        float y = GetScreenCoordinates((float)plot.X, (float)plot.Y).Y - dx / 2;
                        g.DrawRectangle(drawPlotsPen, x, y, dx, dx);
                        pos++;
                    }

                    //Draw the hot box area
                }
            }

            #endregion

            #region Magaged selected aircraft

            if (selectedAircraft != null)
            {
                SeleteAircraftFromRadarScreen(selectedAircraft.CallSign);
                g.FillRectangle(new SolidBrush(Color.FromArgb(100, 100, 20, 20)), selectedHotBox);
            }

            #endregion

            #region Beacons drawing

            //Draw the beacons
            if (data != null)
            {
                foreach (Beacon b in data.getBeacons())
                {
                    if (selectedSector != null)
                    {
                        //Highlight the beacons in the selected sector
                        if (Sector.PointInPolygon(b.toPointF(), selectedSector))
                        {
                            b.isBeaconSelected = true;
                            b.Draw(g);
                        }
                        else
                        {
                            b.isBeaconSelected = false;
                            if ((b.Code == "OTKOL") || (b.Code == "OBUBA"))
                                b.Draw(g);
                        }
                    }
                    else
                    {
                        b.isBeaconSelected = false;
                        //b.Draw(g);
                    }
                }
            }

            #endregion

            #region Separation drawing

            float previousBeacon1X = (float)0;
            float previousBeacon1Y = (float)0;
            float currentBeacon1X = (float)0;
            float currentBeacon1Y = (float)0;

            float previousBeacon2X = (float)0;
            float previousBeacon2Y = (float)0;
            float currentBeacon2X = (float)0;
            float currentBeacon2Y = (float)0;

            //Draw the separation between two aircraft and a beacon + the distance
            if (this.aircraftBeaconSeparationDictionary.Count > 0)
            {
                if (separationAcOneFound && separationAcTwoFound && (data != null))
                {
                    char[] separationCharsArray = { ' ' };
                    string[] beacons1Array = this.aircraftBeaconSeparationDictionary["route1"].Split(separationCharsArray);
                    string[] beacons2Array = this.aircraftBeaconSeparationDictionary["route2"].Split(separationCharsArray);

                    previousBeacon1X = separationAcOneX;
                    previousBeacon1Y = separationAcOneY;
                    g.DrawString(this.aircraftBeaconSeparationDictionary["distance1"] + " NM",
                                 Config.separationBeaconDistancesFont,
                                 new SolidBrush(Config.separationBeaconDistanceOneColor),
                                 GetScreenCoordinates(previousBeacon1X, previousBeacon1Y).X - 50,
                                 GetScreenCoordinates(previousBeacon1X, previousBeacon1Y).Y);
                    for (int i = 0; i < beacons1Array.Length; i++)
                    {
                        foreach (Beacon b in data.getBeacons())
                        {
                            if (b.Code == beacons1Array[i])
                            {
                                currentBeacon1X = (float)(b.toPointF().X / 8);
                                currentBeacon1Y = (float)(b.toPointF().Y / 8);
                                g.DrawLine(Config.separationBeaconDistanceOnePen,
                                           GetScreenCoordinates(previousBeacon1X, previousBeacon1Y).X,
                                           GetScreenCoordinates(previousBeacon1X, previousBeacon1Y).Y,
                                           GetScreenCoordinates(currentBeacon1X, currentBeacon1Y).X,
                                           GetScreenCoordinates(currentBeacon1X, currentBeacon1Y).Y);
                                previousBeacon1X = currentBeacon1X;
                                previousBeacon1Y = currentBeacon1Y;
                            }
                        }
                    }

                    previousBeacon2X = separationAcTwoX;
                    previousBeacon2Y = separationAcTwoY;
                    g.DrawString(this.aircraftBeaconSeparationDictionary["distance2"] + " NM",
                                 Config.separationBeaconDistancesFont,
                                 new SolidBrush(Config.separationBeaconDistanceTwoColor),
                                 GetScreenCoordinates(previousBeacon2X, previousBeacon2Y).X - 50,
                                 GetScreenCoordinates(previousBeacon2X, previousBeacon2Y).Y);
                    for (int i = 0; i < beacons2Array.Length; i++)
                    {
                        foreach (Beacon b in data.getBeacons())
                        {
                            if (b.Code == beacons2Array[i])
                            {
                                currentBeacon2X = (float)(b.toPointF().X / 8);
                                currentBeacon2Y = (float)(b.toPointF().Y / 8);
                                g.DrawLine(Config.separationBeaconDistanceTwoPen,
                                           GetScreenCoordinates(previousBeacon2X, previousBeacon2Y).X,
                                           GetScreenCoordinates(previousBeacon2X, previousBeacon2Y).Y,
                                           GetScreenCoordinates(currentBeacon2X, currentBeacon2Y).X,
                                           GetScreenCoordinates(currentBeacon2X, currentBeacon2Y).Y);
                                previousBeacon2X = currentBeacon2X;
                                previousBeacon2Y = currentBeacon2Y;
                            }
                        }
                    }

                    char[] separationArray = { ' ' };

                    float x1CurrentThick = (float)0;
                    float y1CurrentThick = (float)0;
                    PointF location1PointF;
                    string thicks1 = (string)this.aircraftBeaconSeparationDictionary["thicks1"];
                    string[] thicks1Array = thicks1.Split(separationArray);
                    for (int i = 0; i < (thicks1Array.Length - 1); i += 2)
                    {
                        try
                        {
                            x1CurrentThick = float.Parse(thicks1Array[i]);
                            y1CurrentThick = float.Parse(thicks1Array[i + 1]);

                            location1PointF = new PointF(x1CurrentThick, y1CurrentThick);

                            g.FillEllipse(new SolidBrush(Config.separationBeaconDistanceOneColor),
                                          (float)PanAndZoomX(location1PointF.X / (float)8) - (Config.thicksOneEllipseSize / 2),
                                          (float)PanAndZoomY(location1PointF.Y / (float)8) - (Config.thicksOneEllipseSize / 2),
                                          Config.thicksOneEllipseSize,
                                          Config.thicksOneEllipseSize);
                        }
                        catch { }
                    }

                    float x2CurrentThick = (float)0;
                    float y2CurrentThick = (float)0;
                    PointF location2PointF;
                    string thicks2 = (string)this.aircraftBeaconSeparationDictionary["thicks2"];
                    string[] thicks2Array = thicks2.Split(separationArray);
                    for (int i = 0; i < (thicks2Array.Length - 1); i += 2)
                    {
                        try
                        {
                            x2CurrentThick = float.Parse(thicks2Array[i]);
                            y2CurrentThick = float.Parse(thicks2Array[i + 1]);

                            location2PointF = new PointF(x2CurrentThick, y2CurrentThick);

                            g.FillEllipse(new SolidBrush(Config.separationBeaconDistanceTwoColor),
                                          (float)PanAndZoomX(location2PointF.X / (float)8) - (Config.thicksTwoEllipseSize / 2),
                                          (float)PanAndZoomY(location2PointF.Y / (float)8) - (Config.thicksTwoEllipseSize / 2),
                                          Config.thicksTwoEllipseSize,
                                          Config.thicksTwoEllipseSize);
                        }
                        catch { }
                    }

                    int length = Math.Min(thicks1Array.Length, thicks2Array.Length);
                    for (int i = 0; i < (length - 1); i += 2)
                    {
                        try
                        {
                            x1CurrentThick = float.Parse(thicks1Array[i]);
                            y1CurrentThick = float.Parse(thicks1Array[i + 1]);
                            location1PointF = new PointF(x1CurrentThick, y1CurrentThick);

                            x2CurrentThick = float.Parse(thicks2Array[i]);
                            y2CurrentThick = float.Parse(thicks2Array[i + 1]);
                            location2PointF = new PointF(x2CurrentThick, y2CurrentThick);

                            Pen thicksJointPen = Config.thicksJointLinesPen;
                            thicksJointPen.DashStyle = Config.thicksJointLinesPenDashStyle;

                            g.DrawLine(thicksJointPen,
                                       (float)PanAndZoomX(location1PointF.X / (float)8),
                                       (float)PanAndZoomY(location1PointF.Y / (float)8),
                                       (float)PanAndZoomX(location2PointF.X / (float)8),
                                       (float)PanAndZoomY(location2PointF.Y / (float)8));
                        }
                        catch { }
                    }

                    int distance = int.Parse(this.aircraftBeaconSeparationDictionary["distance"]);

                    Color distColor = Config.goodSeparationDistanceColor;
                    if (distance <= Config.minimumAvailableDistance)
                        distColor = Config.wrongSeparationDistanceColor;

                    g.DrawString(distance + " NM",
                                 Config.separationBeaconDistancesFont,
                                 new SolidBrush(distColor),
                                 GetScreenCoordinates(currentBeacon2X, currentBeacon2Y).X - 50,
                                 GetScreenCoordinates(currentBeacon2X, currentBeacon2Y).Y);
                }
            }

            #endregion

            #region Downing circles drawing

            //if an aircraft is selected
            if ((this.xSelectedAircraftPosition != 0) && (this.ySelectedAircraftPosition != 0))
            {
                Pen pen = Config.aircraftSelectedPen;
                //SolidBrush brush = new SolidBrush(Color.FromArgb(50, Color.Blue));

                g.DrawEllipse(pen,
                    //g.FillEllipse(brush,
                    //GetScreenCoordinates(xPos, yPos).X - radius / 2,
                              xCircleCenterPosition - (float)this.selectedAircraftRadius / 2,
                    //GetScreenCoordinates(xPos, yPos).Y - radius / 2,
                              yCircleCenterPosition - (float)this.selectedAircraftRadius / 2,
                              (float)this.selectedAircraftRadius,
                              (float)this.selectedAircraftRadius);
            }

            /*foreach (string aircraft in this.aircraftModSDictionary.Keys)
            {
                float xPos = (float)this.aircraftModSDictionary[aircraft]["xPos"];
                float yPos = (float)this.aircraftModSDictionary[aircraft]["yPos"];
                int timerLifetime = (int)this.aircraftModSDictionary[aircraft]["timeRemaining"];
                bool aircraftFound = (bool)this.aircraftModSDictionary[aircraft]["aircraftFound"];
                int iterationsNbr = (int)this.aircraftModSDictionary[aircraft]["iterationsToFocus"];

                PointF aircraftScreenCoord = GetScreenCoordinates(xPos, yPos);
                this.aircraftModSDictionary[aircraft]["xCirclePosition"] = (float)aircraftScreenCoord.X;
                this.aircraftModSDictionary[aircraft]["yCirclePosition"] = (float)aircraftScreenCoord.Y;

                if ((xPos != (float)0) && (yPos != (float)0) && (timerLifetime > 0))
                {
                    //float xCCPos = (float)this.aircraftModSDictionary[aircraft]["xCirclePosition"];
                    //float yCCPos = (float)this.aircraftModSDictionary[aircraft]["yCirclePosition"];
                    float xCCPos = (float)aircraftScreenCoord.X;
                    float yCCPos = (float)aircraftScreenCoord.Y;
                    double radius = (double)this.aircraftModSDictionary[aircraft]["radius"];
                    string succeed = (string)this.aircraftModSDictionary[aircraft]["succeed"];
                    Color color = Config.modsNormalColor;

                    if (iterationsNbr == 0)
                    {
                        if (succeed.ToLower() == "true")
                            color = Config.modsSucceedColor;
                        else
                            color = Config.modsUnsucceedColor;
                    }

                    //Pen pen = new Pen(Color.FromArgb(50, color), 2.5f);
                    SolidBrush brush = new SolidBrush(Color.FromArgb(50, color));

                    //g.DrawEllipse(pen,
                    g.FillEllipse(brush,
                                  xCCPos - (float)radius / 2,
                                  yCCPos - (float)radius / 2,
                                  (float)radius,
                                  (float)radius);
                }
            }*/

            foreach (string aircraft in this.aircraftAlarmsDictionary.Keys)
            {
                float xPos = (float)this.aircraftAlarmsDictionary[aircraft]["xPos"];
                float yPos = (float)this.aircraftAlarmsDictionary[aircraft]["yPos"];
                int timerLifetime = (int)this.aircraftAlarmsDictionary[aircraft]["timeRemaining"];
                bool alarmLaunched = (bool)this.aircraftAlarmsDictionary[aircraft]["alarmLaunched"];
                bool aircraftFound = (bool)this.aircraftAlarmsDictionary[aircraft]["aircraftFound"];

                PointF aircraftScreenCoord = GetScreenCoordinates(xPos, yPos);
                this.aircraftAlarmsDictionary[aircraft]["xCirclePosition"] = (float)aircraftScreenCoord.X;
                this.aircraftAlarmsDictionary[aircraft]["yCirclePosition"] = (float)aircraftScreenCoord.Y;

                if (alarmLaunched && (xPos != (float)0) && (yPos != (float)0) && (timerLifetime > 0))
                {
                    //float xCCPos = (float)this.aircraftAlarmsDictionary[aircraft]["xCirclePosition"];
                    //float yCCPos = (float)this.aircraftAlarmsDictionary[aircraft]["yCirclePosition"];
                    float xCCPos = (float)aircraftScreenCoord.X;
                    float yCCPos = (float)aircraftScreenCoord.Y;

                    double radius = (double)this.aircraftAlarmsDictionary[aircraft]["radius"];

                    //Pen pen = new Pen(Color.FromArgb(50, Config.alarmColor), 2.5f);
                    SolidBrush brush = new SolidBrush(Color.FromArgb(50, Config.alarmCircleColor));

                    //g.DrawEllipse(pen,
                    g.FillEllipse(brush,
                                  xCCPos - (float)radius / 2,
                                  yCCPos - (float)radius / 2,
                                  (float)radius,
                                  (float)radius);
                }
            }

            #endregion

            #region CFL filter feedback drawing

            //Draw feedback with afl filter values
            if (this.aflFilterList.Count == 2)
            {
                string aflSupStr = "" + aflSup;
                string sepOne = "^";
                string sepTwo = "^";
                string aflInfStr = "" + aflInf;

                SolidBrush brush = new SolidBrush(Config.filterActiveColor);
                Font font = Config.filterActiveFont;

                SizeF sizeAflSup = g.MeasureString(aflSupStr, font);
                SizeF sizeSepOne = g.MeasureString(sepOne, font);
                SizeF sizeSepTwo = g.MeasureString(sepTwo, font);
                SizeF sizeAflInf = g.MeasureString(aflInfStr, font);

                int screenWidth = this.ClientRectangle.Right - this.ClientRectangle.Left;
                int screenHeight = this.ClientRectangle.Bottom - this.ClientRectangle.Top;

                g.DrawString(aflSupStr, font, brush, ((screenWidth - sizeAflSup.Width) / 2), ((screenHeight - sizeAflSup.Height) / 2) - 80);
                g.DrawString(sepOne, font, brush, ((screenWidth - sizeSepOne.Width) / 2), ((screenHeight - sizeSepOne.Height) / 2));
                g.DrawString(sepTwo, font, brush, ((screenWidth - sizeSepTwo.Width) / 2), ((screenHeight - sizeSepTwo.Height) / 2) + 40);
                g.DrawString(aflInfStr, font, brush, ((screenWidth - sizeAflInf.Width) / 2), ((screenHeight - sizeAflInf.Height) / 2) + 100);
            }

            #endregion

            #region France map drawing

            //Draw the map
            FranceMap.Draw(g, Config.franceDrawingPen);

            #endregion

            #region Alidade drawing

            if (this.alidadeActivate && this.alidadeFirstPointSet)
            {
                PointF finalPoint = new PointF();

                if (this.alidadeSecondPointSet)
                    finalPoint = alidadeSecondPoint;
                else
                    finalPoint = alidadeCurrentPoint;

                g.DrawLine(Config.alidadePen,
                           GetScreenCoordinates((float)alidadeFirstPoint.X, (float)alidadeFirstPoint.Y).X,
                           GetScreenCoordinates((float)alidadeFirstPoint.X, (float)alidadeFirstPoint.Y).Y,
                           GetScreenCoordinates((float)finalPoint.X, (float)finalPoint.Y).X,
                           GetScreenCoordinates((float)finalPoint.X, (float)finalPoint.Y).Y);

                float dx = ((float)finalPoint.X - (float)alidadeFirstPoint.X);
                float dy = ((float)finalPoint.Y - (float)alidadeFirstPoint.Y);
                float dist = (float)Math.Round(Math.Sqrt(dx * dx + dy * dy), Config.alidadeDistancePrecision);
                dist = dist * Config.alidadeDistanceCoefficient;

                if (dist > 0f)
                    g.DrawString(dist + Config.alidadeDistanceSuffix,
                                 Config.alidadeDistanceFont,
                                 new SolidBrush(Config.alidadeDistanceColor),
                                 GetScreenCoordinates((float)finalPoint.X, (float)finalPoint.Y).X + Config.alidadeDistanceXShift,
                                 GetScreenCoordinates((float)finalPoint.X, (float)finalPoint.Y).Y + Config.alidadeDistanceYShift);
            }

            #endregion

            //Draw the pen down
            g.FillEllipse(new SolidBrush(Color.FromArgb(150, 0, 100, 255)), AnotoPenDown.X - 12, AnotoPenDown.Y - 12, 24, 24);

            /*            Point CalibrationTopLeft = new Point(100,100);
                 Point CalibrationBottomRight = new Point(this.Width-100, this.Height-100);

                    //Draw Calibration
                 g.FillEllipse(Brushes.Yellow, CalibrationTopLeft.X-5, CalibrationTopLeft.Y-5, 10, 10);
                 g.FillEllipse(Brushes.Yellow, CalibrationBottomRight.X-5, CalibrationTopLeft.Y-5, 10, 10);
                 g.FillEllipse(Brushes.Yellow, CalibrationTopLeft.X-5, CalibrationBottomRight.Y-5, 10, 10);
               g.FillEllipse(Brushes.Yellow, CalibrationBottomRight.X-5, CalibrationBottomRight.Y-5, 10, 10);
        */

        }



        #endregion

        string LastSelectedAircraftID = "";
        //Send the message that an aircraft as been selected form the radar screen
        private void SeleteAircraftFromRadarScreen(string aircraftId)
        {
            if (LastSelectedAircraftID != aircraftId)
            {
                FormSimpleRadar.TheIvyBus.SendMsg("SeleteAircraftFromRadarScreen " + "AircraftId=" + aircraftId);
                // IvyBus.ivy.BindMsg(@"SeleteAircraftFromRadarScreen AircraftId=(.*) ", SeleteAircraftFromRadarScreen, null);
                LastSelectedAircraftID = aircraftId;
            }
        }


        #region Other methods

        public void updateClock(int hour, int minute, int second)
        {
            if ((this.CurrentHour != hour) || (this.CurrentMinute != minute) || (this.CurrentSecond != second))
            {
                this.CurrentHour = hour;
                this.CurrentMinute = minute;
                this.CurrentSecond = second;
                string h = "" + this.CurrentHour;
                if (h.Length == 1)
                    h = "0" + h;
                string m = "" + this.CurrentMinute;
                if (m.Length == 1)
                    m = "0" + m;
                this.clockLabel.Text = h + ":" + m;
            }
            //Console.WriteLine(this.CurrentHour + "h " + this.CurrentMinute + "m " + this.CurrentSecond + "s");
        }

        public void setData(Data.AppDatabase data)
        {
            this.data = data;
        }


        public void showAircraftContextualMenu(int x, int y)
        {
            if (data != null)
            {
                foreach (var track in data.getAircraftList())
                {
                    if (track.Value.Count > 0)
                    {
                        int dx = (int)(10 * Zoom) / 2;
                        AircraftPosition aircraft = track.Value[track.Value.Count - 1];
                        PointF acScreenCoord = GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y);
                        int xScreenCoord = (int)acScreenCoord.X;
                        int yScreenCoord = (int)acScreenCoord.Y;
                        if ((xScreenCoord >= (x - 5)) && (xScreenCoord <= (x + 5)))
                        {
                            if ((yScreenCoord >= (y - 5)) && (yScreenCoord <= (y + 5)))
                            {
                                aircraftCheckedContextualMenu = aircraft.Flight;
                            }
                        }
                    }
                }
            }

            ctxtMenu = new ContextMenu();

            MenuItem visuPisteMenuItem = new MenuItem();
            visuPisteMenuItem.Index = 0;
            visuPisteMenuItem.Text = Config.visuPisteMenuItemCaption;
            MenuItem montrerMenuItem = new MenuItem();
            montrerMenuItem.Index = 1;
            montrerMenuItem.Text = Config.montrerMenuItemCaption;
            MenuItem shootRequestMenuItem = new MenuItem();
            shootRequestMenuItem.Index = 2;
            shootRequestMenuItem.Text = Config.shootRequestMenuItemCaption;
            MenuItem flMenuItem = new MenuItem();
            flMenuItem.Index = 3;
            flMenuItem.Text = Config.flMenuItemCaption;
            MenuItem ripMenuItem = new MenuItem();
            ripMenuItem.Index = 4;
            ripMenuItem.Text = Config.ripMenuItemCaption;
            MenuItem mvtMenuItem = new MenuItem();
            mvtMenuItem.Index = 5;
            mvtMenuItem.Text = Config.mvtMenuItemCaption;
            MenuItem modMenuItem = new MenuItem();
            modMenuItem.Index = 6;
            modMenuItem.Text = Config.modMenuItemCaption;
            MenuItem partMenuItem = new MenuItem();
            partMenuItem.Index = 7;
            partMenuItem.Text = Config.partMenuItemCaption;
            partMenuItem.DefaultItem = true;
            partMenuItem.Click += new EventHandler(partMenuItem_Click);
            MenuItem warningMenuItem = new MenuItem();
            warningMenuItem.Index = 8;
            warningMenuItem.Text = Config.warningMenuItemCaption;
            warningMenuItem.Click += new EventHandler(warningMenuItem_Click);
            MenuItem accesPlnMenuItem = new MenuItem();
            accesPlnMenuItem.Index = 9;
            accesPlnMenuItem.Text = Config.accesPlnMenuItemCaption;
            MenuItem cnlMenuItem = new MenuItem();
            cnlMenuItem.Index = 10;
            cnlMenuItem.Text = Config.cnlMenuItemCaption;
            MenuItem decorMenuItem = new MenuItem();
            decorMenuItem.Index = 11;
            decorMenuItem.Text = Config.decorMenuItemCaption;
            MenuItem lvolMenuItem = new MenuItem();
            lvolMenuItem.Index = 12;
            lvolMenuItem.Text = Config.lvolMenuItemCaption;

            ctxtMenu.MenuItems.AddRange(new MenuItem[] { visuPisteMenuItem, montrerMenuItem, shootRequestMenuItem, flMenuItem, ripMenuItem, mvtMenuItem, modMenuItem,
                                                         partMenuItem, warningMenuItem, accesPlnMenuItem, cnlMenuItem, decorMenuItem, lvolMenuItem });

            if (aircraftCheckedContextualMenu == "")
                this.ContextMenu = null;
            else
            {
                this.ContextMenu = ctxtMenu;
                aircraftSelectedContextualMenu = aircraftCheckedContextualMenu;
                aircraftCheckedContextualMenu = "";
            }
        }

        public void manageSelectedAircraftTimer(string actionType, string aircraftFlight)
        {
            if (actionType == "add")
            {
                this.selectedAircraftRadius = Config.aircraftSelectedTimerRadius;
                this.xSelectedAircraftPosition = 0;
                this.ySelectedAircraftPosition = 0;
                this.SelectedAircraft = aircraftFlight;
                this.selectedAircraftTimer = new Timer();
                this.selectedAircraftTimer.Interval = Config.aircraftSelectedTimerInterval;
                this.selectedAircraftTimer.Tick += new EventHandler(selectedAircraftTimer_Tick);
                this.selectedAircraftTimer.Enabled = true;
                this.selectedAircraftTimer.Start();
                if (this.aircraftInformationMessagesDictionary.ContainsKey(this.SelectedAircraft))
                {
                    PictureBox pBox = (PictureBox)this.aircraftInformationMessagesDictionary[aircraftFlight]["picturebox"];
                    pBox.Visible = true;
                    Label lbl = (Label)this.aircraftInformationMessagesDictionary[aircraftFlight]["label"];
                    lbl.Visible = false;
                }
            }
            else if (actionType == "clear")
            {
                if (this.selectedAircraftTimer != null)
                    this.selectedAircraftTimer.Stop();
                this.Invalidate();
                this.selectedAircraftRadius = Config.aircraftSelectedTimerRadius;
                this.SelectedAircraft = "";
                this.xSelectedAircraftPosition = 0;
                this.ySelectedAircraftPosition = 0;
                if (this.aircraftInformationMessagesDictionary.ContainsKey(aircraftFlight))
                {
                    PictureBox pBox = (PictureBox)this.aircraftInformationMessagesDictionary[aircraftFlight]["picturebox"];
                    pBox.Visible = false;
                    Label lbl = (Label)this.aircraftInformationMessagesDictionary[aircraftFlight]["label"];
                    lbl.Visible = true;
                }
            }
        }

        public void manageAircraftModSDictionary(string aircraftFlight, string modsLevel, string nextSectorName, string modsSucceed)
        {
            if (this.aircraftModSDictionary.ContainsKey(aircraftFlight))
                this.aircraftModSDictionary.Remove(aircraftFlight);
            Dictionary<string, Object> modSDictionary = new Dictionary<string, Object>();
            modSDictionary.Add("level", modsLevel);
            modSDictionary.Add("succeed", modsSucceed);
            modSDictionary.Add("radius", (double)Config.aircraftModsTimerRadius);
            modSDictionary.Add("xPos", 0f);
            modSDictionary.Add("yPos", 0f);
            modSDictionary.Add("xCirclePosition", 0f);
            modSDictionary.Add("yCirclePosition", 0f);
            modSDictionary.Add("aircraftFound", false);
            modSDictionary.Add("iterationsToFocus", Config.aircraftModsTimerIterationsToFocus);
            modSDictionary.Add("xShift", 0f);
            modSDictionary.Add("yShift", 0f);
            modSDictionary.Add("nextSector", nextSectorName);
            modSDictionary.Add("timeRemaining", (int)(Config.aircraftModsTimerSecondsLifeTime * 1000));
            this.aircraftModSDictionary.Add(aircraftFlight, modSDictionary);
        }

        public void manageAircraftAlarmsDictionary(string actionType, string aircraftFlight, int hour, int minute, int second)
        {
            if (actionType == "add")
            {
                if (this.aircraftAlarmsDictionary.ContainsKey(aircraftFlight))
                {
                    PictureBox pBox = (PictureBox)this.aircraftAlarmsDictionary[aircraftFlight]["picturebox"];
                    if (this.Controls.Contains(pBox))
                        this.Controls.Remove(pBox);
                    this.aircraftAlarmsDictionary.Remove(aircraftFlight);
                }

                PictureBox aircraftAlarmPictureBox = new PictureBox();
                aircraftAlarmPictureBox.Size = new Size(16, 16);
                aircraftAlarmPictureBox.SizeMode = PictureBoxSizeMode.CenterImage;
                aircraftAlarmPictureBox.BackColor = Color.Transparent;
                aircraftAlarmPictureBox.Visible = false;
                try
                {
                    aircraftAlarmPictureBox.Image = Image.FromFile(Config.picturesFolderName + "/" + Config.clockPictureName);
                }
                catch { }

                Dictionary<string, Object> alarmDictionary = new Dictionary<string, Object>();
                alarmDictionary.Add("hour", hour);
                alarmDictionary.Add("minute", minute);
                alarmDictionary.Add("second", second);
                alarmDictionary.Add("radius", (double)Config.aircraftAlarmsTimerRadius);
                alarmDictionary.Add("xPos", 0f);
                alarmDictionary.Add("yPos", 0f);
                alarmDictionary.Add("xCirclePosition", 0f);
                alarmDictionary.Add("yCirclePosition", 0f);
                alarmDictionary.Add("aircraftFound", false);
                alarmDictionary.Add("iterationsToFocus", Config.aircraftAlarmsTimerIterationsToFocus);
                alarmDictionary.Add("xShift", 0f);
                alarmDictionary.Add("yShift", 0f);
                alarmDictionary.Add("alarmLaunched", false);
                alarmDictionary.Add("feedbackTimeRemaining", (int)(Config.aircraftAlarmsTimerFeedbackSecondsLifeTime * 1000));
                alarmDictionary.Add("timeRemaining", (int)(Config.aircraftAlarmsTimerSecondsLifeTime * 1000));
                alarmDictionary.Add("picturebox", aircraftAlarmPictureBox);
                this.aircraftAlarmsDictionary.Add(aircraftFlight, alarmDictionary);
            }
            else if (actionType == "remove")
            {
                if (this.aircraftAlarmsDictionary.ContainsKey(aircraftFlight))
                {
                    PictureBox pBox = (PictureBox)this.aircraftAlarmsDictionary[aircraftFlight]["picturebox"];
                    if (this.Controls.Contains(pBox))
                        this.Controls.Remove(pBox);
                    this.aircraftAlarmsDictionary.Remove(aircraftFlight);
                }
            }
            else if (actionType == "clear")
            {
                foreach (Dictionary<string, Object> dico in this.aircraftAlarmsDictionary.Values)
                {
                    PictureBox pBox = (PictureBox)dico["picturebox"];
                    if (this.Controls.Contains(pBox))
                        this.Controls.Remove(pBox);
                }
                this.aircraftAlarmsDictionary.Clear();
            }
        }

        public void manageFollowedAircraftList(string actionType, string aircraftFlight)
        {
            if (actionType == "add")
            {
                if (!(this.aircraftFollowedDictionary.ContainsKey(aircraftFlight)))
                {
                    PictureBox aircraftFollowedPictureBox = new PictureBox();
                    aircraftFollowedPictureBox.Name = aircraftFlight;
                    aircraftFollowedPictureBox.Size = new Size(80, 80);
                    aircraftFollowedPictureBox.SizeMode = PictureBoxSizeMode.CenterImage;
                    aircraftFollowedPictureBox.Location = new Point(10, 10);
                    aircraftFollowedPictureBox.BackColor = Color.Transparent;
                    aircraftFollowedPictureBox.Visible = false;
                    this.aircraftFollowedDictionary.Add(aircraftFlight, aircraftFollowedPictureBox);
                }
            }
            else if (actionType == "remove")
            {
                if (this.aircraftFollowedDictionary.ContainsKey(aircraftFlight))
                {
                    PictureBox pBox = (PictureBox)this.aircraftFollowedDictionary[aircraftFlight];
                    if (this.Controls.Contains(pBox))
                        this.Controls.Remove(pBox);
                    this.aircraftFollowedDictionary.Remove(aircraftFlight);
                }
            }
            else if (actionType == "clear")
            {
                foreach (PictureBox pBox in this.aircraftFollowedDictionary.Values)
                {
                    if (this.Controls.Contains(pBox))
                        this.Controls.Remove(pBox);
                }
                this.aircraftFollowedDictionary.Clear();
            }
        }

        public string getAircraftScreenLocation(float aircraftXPosition, float aircraftYPosition)
        {
            string location = "N";
            PointF coord = GetScreenCoordinates(aircraftXPosition, aircraftYPosition);
            int acX = (int)coord.X;
            int acY = (int)coord.Y;
            int top = this.ClientRectangle.Top;
            int right = this.ClientRectangle.Right;
            int bottom = this.ClientRectangle.Bottom;
            int left = this.ClientRectangle.Left;

            if (acX < left)
            {
                if (acY < top)
                {
                    location = "NW";
                }
                else if ((acY >= top) && (acY <= bottom))
                {
                    location = "W";
                }
                else if (acY > bottom)
                {
                    location = "SW";
                }
            }
            else if ((acX >= left) && (acX <= right))
            {
                if (acY < top)
                {
                    location = "N";
                }
                else if ((acY >= top) && (acY <= bottom))
                {
                    location = "C";
                }
                else if (acY > bottom)
                {
                    location = "S";
                }
            }
            else if (acX > right)
            {
                if (acY < top)
                {
                    location = "NE";
                }
                else if ((acY >= top) && (acY <= bottom))
                {
                    location = "E";
                }
                else if (acY > bottom)
                {
                    location = "SE";
                }
            }

            return location;
        }

        public void manageAircraftInformationMessagesDictionary(string actionType, string aircraftFlight, int wordsNumber)
        {
            if (actionType == "add")
            {
                if (this.aircraftInformationMessagesDictionary.ContainsKey(aircraftFlight))
                {
                    if (this.aircraftInformationMessagesDictionary[aircraftFlight].ContainsKey("label"))
                    {
                        Label lbl = (Label)this.aircraftInformationMessagesDictionary[aircraftFlight]["label"];
                        if (this.Controls.Contains(lbl))
                            this.Controls.Remove(lbl);
                    }
                    if (this.aircraftInformationMessagesDictionary[aircraftFlight].ContainsKey("picturebox"))
                    {
                        PictureBox pBox = (PictureBox)this.aircraftInformationMessagesDictionary[aircraftFlight]["picturebox"];
                        if (this.Controls.Contains(pBox))
                            this.Controls.Remove(pBox);
                    }
                    this.aircraftInformationMessagesDictionary.Remove(aircraftFlight);
                }

                Dictionary<string, Object> informationMessageDictionary = new Dictionary<string, Object>();
                informationMessageDictionary.Add("wordsNumber", wordsNumber);
                informationMessageDictionary.Add("buildingmessage", true);

                Dictionary<int, List<int>> messagePointsDictionary = new Dictionary<int, List<int>>();
                for (int i = 0; i < wordsNumber; i++)
                    messagePointsDictionary[i] = new List<int>();
                informationMessageDictionary.Add("messagepointsdictionary", messagePointsDictionary);

                Label informationMessageLabel = new Label();
                informationMessageLabel.Name = aircraftFlight;
                informationMessageLabel.BackColor = Config.iInformationMessageLabelBackColor;
                informationMessageLabel.ForeColor = Config.iInformationMessageLabelForeColor;
                informationMessageLabel.Text = Config.iInformationMessageLabelText;
                informationMessageLabel.TextAlign = ContentAlignment.TopLeft;
                informationMessageLabel.Visible = false;
                informationMessageDictionary.Add("label", informationMessageLabel);

                this.aircraftInformationMessagesDictionary.Add(aircraftFlight, informationMessageDictionary);
            }
            else if (actionType == "remove")
            {
                if (this.aircraftInformationMessagesDictionary.ContainsKey(aircraftFlight))
                {
                    if (this.aircraftInformationMessagesDictionary[aircraftFlight].ContainsKey("label"))
                    {
                        Label lbl = (Label)this.aircraftInformationMessagesDictionary[aircraftFlight]["label"];
                        if (this.Controls.Contains(lbl))
                            this.Controls.Remove(lbl);
                    }
                    if (this.aircraftInformationMessagesDictionary[aircraftFlight].ContainsKey("picturebox"))
                    {
                        PictureBox pBox = (PictureBox)this.aircraftInformationMessagesDictionary[aircraftFlight]["picturebox"];
                        if (this.Controls.Contains(pBox))
                            this.Controls.Remove(pBox);
                    }
                    this.aircraftInformationMessagesDictionary.Remove(aircraftFlight);
                }
            }
            else if (actionType == "clear")
            {
                foreach (Dictionary<string, Object> dico in this.aircraftInformationMessagesDictionary.Values)
                {
                    if (dico.ContainsKey("label"))
                    {
                        Label lbl = (Label)dico["label"];
                        if (this.Controls.Contains(lbl))
                            this.Controls.Remove(lbl);
                    }
                    if (dico.ContainsKey("picturebox"))
                    {
                        PictureBox pBox = (PictureBox)dico["picturebox"];
                        if (this.Controls.Contains(pBox))
                            this.Controls.Remove(pBox);
                    }
                }
                this.aircraftInformationMessagesDictionary.Clear();
            }
        }

        public void updateAircraftInformationMessage(string aircraftFlight, bool buildingMessage, string word)
        {
            if (this.aircraftInformationMessagesDictionary.ContainsKey(aircraftFlight))
            {
                this.aircraftInformationMessagesDictionary[aircraftFlight]["buildingmessage"] = buildingMessage;
                if (buildingMessage)
                {
                    char[] separationCharsArray = { ' ' };
                    string[] wordArray = word.Split(separationCharsArray);
                    int wordNumber = int.Parse(wordArray[0]);
                    Dictionary<int, List<int>> messagePointsDictionary = (Dictionary<int, List<int>>)this.aircraftInformationMessagesDictionary[aircraftFlight]["messagepointsdictionary"];
                    for (int i = 1; i < wordArray.Length; i++)
                        messagePointsDictionary[wordNumber].Add(int.Parse(wordArray[i]));
                    this.aircraftInformationMessagesDictionary[aircraftFlight]["messagepointsdictionary"] = messagePointsDictionary;
                }
                else
                {
                    PictureBox informationMessagePictureBox = createBitmapInformationMessage(aircraftFlight, Config.informationMessageForeColor, Config.informationMessageBackColor, Config.informationMessageCompression);
                    informationMessagePictureBox.Name = aircraftFlight;
                    informationMessagePictureBox.Visible = false;
                    if (this.aircraftInformationMessagesDictionary[aircraftFlight].ContainsKey("picturebox"))
                        this.aircraftInformationMessagesDictionary[aircraftFlight].Remove("picturebox");
                    this.aircraftInformationMessagesDictionary[aircraftFlight].Add("picturebox", informationMessagePictureBox);
                }
            }
        }

        public PictureBox createBitmapInformationMessage(string aircraftFlight, Color foreColor, Color backColor, int compression)
        {
            Dictionary<int, List<int>> dico = (Dictionary<int, List<int>>)this.aircraftInformationMessagesDictionary[aircraftFlight]["messagepointsdictionary"];
            int xMin, xMax, yMin, yMax;
            int genXMin = 1000000, genXMax = 0, genYMin = 1000000, genYMax = 0;

            foreach (List<int> list in dico.Values)
            {
                xMin = getMinList(list, 0, 2);
                xMax = getMaxList(list, 0, 2);
                yMin = getMinList(list, 1, 2);
                yMax = getMaxList(list, 1, 2);
                if (xMin < genXMin)
                    genXMin = xMin;
                if (xMax > genXMax)
                    genXMax = xMax;
                if (yMin < genYMin)
                    genYMin = yMin;
                if (yMax > genYMax)
                    genYMax = yMax;
            }

            int ceilValue = Config.informationMessageLocationCeilValue;
            genXMin = genXMin - (genXMin % ceilValue);
            genXMax = genXMax - (genXMax % ceilValue) + ceilValue;
            genYMin = genYMin - (genYMin % ceilValue);
            genYMax = genYMax - (genYMax % ceilValue) + ceilValue;

            int maxWidth = genXMax - genXMin;
            int maxHeight = genYMax - genYMin;

            Bitmap flag = new Bitmap(maxWidth / compression, maxHeight / compression);
            for (int x = 0; x < flag.Width; ++x)
                for (int y = 0; y < flag.Height; ++y)
                    flag.SetPixel(x, y, backColor);

            foreach (List<int> list in dico.Values)
            {
                for (int i = 0; i < (list.Count - 1); i += 2)
                {
                    int x1 = (list[i] - genXMin) / compression;
                    int y1 = (list[i + 1] - genYMin) / compression;
                    if (i < (list.Count - 3))
                    {
                        int x2 = (list[i + 2] - genXMin) / compression;
                        int y2 = (list[i + 3] - genYMin) / compression;
                        flag.SetPixel(x2, y2, foreColor);
                        using (Graphics g = Graphics.FromImage(flag))
                        {
                            g.DrawLine(new Pen(foreColor), new Point(x1, y1), new Point(x2, y2));
                        }
                    }
                }
            }

            PictureBox pBox = new PictureBox();
            pBox.Size = new Size(maxWidth / compression, maxHeight / compression);
            pBox.Image = flag;

            return pBox;
        }

        public int getMinList(List<int> list, int start, int incr)
        {
            int min = list[start];
            for (int i = (start + incr); i < list.Count; i += incr)
            {
                if (list[i] < min)
                    min = list[i];
            }
            return min;
        }

        public int getMaxList(List<int> list, int start, int incr)
        {
            int max = list[start];
            for (int i = (start + incr); i < list.Count; i += incr)
            {
                if (list[i] > max)
                    max = list[i];
            }
            return max;
        }

        public void manageAircraftTagMessageDictionary(string actionType, string aircraftFlight, int stripNumber, int wordsNumber)
        {
            if (actionType == "add")
            {
                if (this.aircraftTagMessagesDictionary.ContainsKey(aircraftFlight))
                {
                    Dictionary<string, Object> tagMessageDictionary = new Dictionary<string, Object>();
                    tagMessageDictionary.Add("strip", stripNumber);

                    PictureBox emptyTagMessagePictureBox = createBitmapTagMessage(aircraftFlight, Config.tagMessageForeColor, Config.tagMessageBackColor, Config.tagMessageEmptyCompression, true);
                    emptyTagMessagePictureBox.Name = aircraftFlight;
                    emptyTagMessagePictureBox.BackColor = Config.emptyTagMessageBackColor;
                    emptyTagMessagePictureBox.Visible = false;
                    tagMessageDictionary.Add("picturebox", emptyTagMessagePictureBox);

                    this.aircraftTagMessagesDictionary[aircraftFlight] = tagMessageDictionary;

                    try
                    {
                        FormSimpleRadar.FormRadarInstance.sendIvyMessage("SetTag Flight=" + aircraftFlight + " Strip=" + stripNumber + " Confirmed");
                    }
                    catch { }
                }
            }
            else if (actionType == "update")
            {
                if (this.aircraftTagMessagesDictionary.ContainsKey(aircraftFlight))
                {
                    Dictionary<string, Object> tagMessageDictionary = this.aircraftTagMessagesDictionary[aircraftFlight];
                    if (tagMessageDictionary.ContainsKey("wordsNumber"))
                        tagMessageDictionary.Remove("wordsNumber");
                    tagMessageDictionary.Add("wordsNumber", wordsNumber);
                    if (tagMessageDictionary.ContainsKey("buildingmessage"))
                        tagMessageDictionary.Remove("buildingmessage");
                    tagMessageDictionary.Add("buildingmessage", true);

                    Dictionary<int, List<int>> messagePointsDictionary = new Dictionary<int, List<int>>();
                    for (int i = 0; i < wordsNumber; i++)
                        messagePointsDictionary[i] = new List<int>();
                    if (tagMessageDictionary.ContainsKey("messagepointsdictionary"))
                        tagMessageDictionary.Remove("messagepointsdictionary");
                    tagMessageDictionary.Add("messagepointsdictionary", messagePointsDictionary);

                    this.aircraftTagMessagesDictionary[aircraftFlight] = tagMessageDictionary;
                }
            }
            else if (actionType == "remove")
            {
                if (this.aircraftTagMessagesDictionary.ContainsKey(aircraftFlight))
                {
                    if (this.aircraftTagMessagesDictionary[aircraftFlight].ContainsKey("picturebox"))
                    {
                        PictureBox pBox = (PictureBox)this.aircraftTagMessagesDictionary[aircraftFlight]["picturebox"];
                        if (this.Controls.Contains(pBox))
                            this.Controls.Remove(pBox);
                    }
                    //this.aircraftTagMessagesDictionary.Remove(aircraftFlight);
                    this.aircraftTagMessagesDictionary[aircraftFlight] = new Dictionary<string, Object>();
                }
            }
            else if (actionType == "clear")
            {
                foreach (Dictionary<string, Object> dico in this.aircraftTagMessagesDictionary.Values)
                {
                    if (dico.ContainsKey("picturebox"))
                    {
                        PictureBox pBox = (PictureBox)dico["picturebox"];
                        if (this.Controls.Contains(pBox))
                            this.Controls.Remove(pBox);
                    }
                }
                //this.aircraftTagMessagesDictionary.Clear();
                foreach (string key in this.aircraftTagMessagesDictionary.Keys)
                {
                    Dictionary<string, Object> dico = new Dictionary<string, Object>();
                    this.aircraftTagMessagesDictionary[key] = dico;
                }
            }
        }

        public void updateAircraftTagMessage(string aircraftFlight, bool buildingMessage, string word)
        {
            if (this.aircraftTagMessagesDictionary.ContainsKey(aircraftFlight))
            {
                if (this.aircraftTagMessagesDictionary[aircraftFlight].ContainsKey("buildingmessage"))
                {
                    this.aircraftTagMessagesDictionary[aircraftFlight]["buildingmessage"] = buildingMessage;
                    if (buildingMessage)
                    {
                        char[] separationCharsArray = { ' ' };
                        string[] wordArray = word.Split(separationCharsArray);
                        int wordNumber = int.Parse(wordArray[0]);
                        Dictionary<int, List<int>> messagePointsDictionary = (Dictionary<int, List<int>>)this.aircraftTagMessagesDictionary[aircraftFlight]["messagepointsdictionary"];
                        for (int i = 1; i < wordArray.Length; i++)
                            messagePointsDictionary[wordNumber].Add(int.Parse(wordArray[i]));
                        if (this.aircraftTagMessagesDictionary[aircraftFlight].ContainsKey("messagepointsdictionary"))
                            this.aircraftTagMessagesDictionary[aircraftFlight]["messagepointsdictionary"] = messagePointsDictionary;
                        else
                            this.aircraftTagMessagesDictionary[aircraftFlight].Add("messagepointsdictionary", messagePointsDictionary);
                    }
                    else
                    {
                        PictureBox tagMessagePictureBox = createBitmapTagMessage(aircraftFlight, Config.tagMessageForeColor, Config.tagMessageBackColor, Config.tagMessageCompression, false);
                        tagMessagePictureBox.Name = aircraftFlight;
                        tagMessagePictureBox.Visible = false;
                        if (this.aircraftTagMessagesDictionary[aircraftFlight].ContainsKey("picturebox"))
                        {
                            PictureBox pBox = (PictureBox)this.aircraftTagMessagesDictionary[aircraftFlight]["picturebox"];
                            if (this.Controls.Contains(pBox))
                                this.Controls.Remove(pBox);
                            this.aircraftTagMessagesDictionary[aircraftFlight]["picturebox"] = tagMessagePictureBox;
                        }
                        else
                            this.aircraftTagMessagesDictionary[aircraftFlight].Add("picturebox", tagMessagePictureBox);
                    }
                }
            }
        }

        public PictureBox createBitmapTagMessage(string aircraftFlight, Color foreColor, Color backColor, int compression, bool emptyBitmap)
        {
            Bitmap flag;
            int maxWidth = 0;
            int maxHeight = 0;

            if (!emptyBitmap)
            {
                Dictionary<int, List<int>> dico = (Dictionary<int, List<int>>)this.aircraftTagMessagesDictionary[aircraftFlight]["messagepointsdictionary"];
                int xMin, xMax, yMin, yMax;
                int genXMin = 1000000, genXMax = 0, genYMin = 1000000, genYMax = 0;

                foreach (List<int> list in dico.Values)
                {
                    xMin = getMinList(list, 0, 2);
                    xMax = getMaxList(list, 0, 2);
                    yMin = getMinList(list, 1, 2);
                    yMax = getMaxList(list, 1, 2);
                    if (xMin < genXMin)
                        genXMin = xMin;
                    if (xMax > genXMax)
                        genXMax = xMax;
                    if (yMin < genYMin)
                        genYMin = yMin;
                    if (yMax > genYMax)
                        genYMax = yMax;
                }

                int ceilValue = Config.tagMessageLocationCeilValue;
                genXMin = genXMin - (genXMin % ceilValue);
                genXMax = genXMax - (genXMax % ceilValue) + ceilValue;
                genYMin = genYMin - (genYMin % ceilValue);
                genYMax = genYMax - (genYMax % ceilValue) + ceilValue;

                maxWidth = genXMax - genXMin;
                maxHeight = genYMax - genYMin;

                flag = new Bitmap(maxWidth / compression, maxHeight / compression);
                for (int x = 0; x < flag.Width; ++x)
                    for (int y = 0; y < flag.Height; ++y)
                        flag.SetPixel(x, y, backColor);

                foreach (List<int> list in dico.Values)
                {
                    for (int i = 0; i < (list.Count - 1); i += 2)
                    {
                        int x1 = (list[i] - genXMin) / compression;
                        int y1 = (list[i + 1] - genYMin) / compression;
                        if (i < (list.Count - 3))
                        {
                            int x2 = (list[i + 2] - genXMin) / compression;
                            int y2 = (list[i + 3] - genYMin) / compression;
                            flag.SetPixel(x2, y2, foreColor);
                            using (Graphics g = Graphics.FromImage(flag))
                            {
                                g.DrawLine(new Pen(foreColor), new Point(x1, y1), new Point(x2, y2));
                            }
                        }
                    }
                }
            }
            else
            {
                maxWidth = 100;
                maxHeight = 50;

                flag = new Bitmap(maxWidth / compression, maxHeight / compression);
                for (int x = 0; x < flag.Width; ++x)
                    for (int y = 0; y < flag.Height; ++y)
                        flag.SetPixel(x, y, backColor);
            }

            PictureBox pBox = new PictureBox();
            pBox.Size = new Size(maxWidth / compression, maxHeight / compression);
            pBox.Image = flag;

            return pBox;
        }

        public void manageAircraftFlightLevelFilterList(string actionType, string aircraftFlight)
        {
            if (actionType == "add")
            {
                if (!(this.aflFilterAircraftList.Contains(aircraftFlight)))
                    this.aflFilterAircraftList.Add(aircraftFlight);
            }
            else if (actionType == "remove")
            {
                if (this.aflFilterAircraftList.Contains(aircraftFlight))
                    this.aflFilterAircraftList.Remove(aircraftFlight);
            }
            else if (actionType == "clear")
            {
                this.aflFilterAircraftList.Clear();
            }
        }

        public void manageFlightLevelFilter(string actionType, int aflValue, int aflRange)
        {
            if (actionType == "add")
            {
                this.aflFilterList.Clear();
                this.aflFilterList.Add(aflValue);
                this.aflFilterList.Add(aflRange);
            }
            else if (actionType == "clear")
            {
                this.aflFilterList.Clear();
            }
        }

        public void manageAircraftSeparationList(string actionType, string ac1FlightName, string ac1Route, string ac1Distance, string thicks1, string ac2FlightName, string ac2Route, string ac2Distance, string thicks2, string distance)
        {
            if (actionType == "add")
            {
                this.aircraftBeaconSeparationDictionary.Clear();
                this.aircraftBeaconSeparationDictionary.Add("aircraft1", ac1FlightName);
                this.aircraftBeaconSeparationDictionary.Add("route1", ac1Route);
                this.aircraftBeaconSeparationDictionary.Add("distance1", ac1Distance);
                this.aircraftBeaconSeparationDictionary.Add("thicks1", thicks1);
                this.aircraftBeaconSeparationDictionary.Add("aircraft2", ac2FlightName);
                this.aircraftBeaconSeparationDictionary.Add("route2", ac2Route);
                this.aircraftBeaconSeparationDictionary.Add("distance2", ac2Distance);
                this.aircraftBeaconSeparationDictionary.Add("thicks2", thicks2);
                this.aircraftBeaconSeparationDictionary.Add("distance", distance);
            }
            else if (actionType == "clear")
            {
                this.aircraftBeaconSeparationDictionary.Clear();
            }
        }

        public void manageWarningAircraftList(string actionType, string acFlightName)
        {
            if (actionType == "add")
            {
                if (!(this.warningAircraftList.Contains(acFlightName)))
                    this.warningAircraftList.Add(acFlightName);
            }
            else if (actionType == "remove")
            {
                if (this.warningAircraftList.Contains(acFlightName))
                    this.warningAircraftList.Remove(acFlightName);
            }
            else if (actionType == "change")
            {
                if (!(this.warningAircraftList.Contains(acFlightName)))
                    //L'avion n'a pas de Warning associé : on l'ajoute à la liste:
                    this.warningAircraftList.Add(acFlightName);
                else
                    //L'avion est en warning : on le retire de la liste : 
                    this.warningAircraftList.Remove(acFlightName);
            }
            else if (actionType == "clear")
            {
                this.warningAircraftList.Clear();
            }
        }

        public void managePartAircraftList(string actionType, string acFlightName)
        {
            if (actionType == "add")
            {
                if (!(this.partAircraftList.Contains(acFlightName)))
                    this.partAircraftList.Add(acFlightName);
            }
            else if (actionType == "remove")
            {
                if (this.partAircraftList.Contains(acFlightName))
                    this.partAircraftList.Remove(acFlightName);
            }
            else if (actionType == "change")
            {
                if (!(this.partAircraftList.Contains(acFlightName)))
                    //L'avion n'est pas particularisé : on le particularise : 
                    this.partAircraftList.Add(acFlightName);
                else
                    //L'avion est particularisé : on le départicularise
                    this.partAircraftList.Remove(acFlightName);
            }
            else if (actionType == "clear")
            {
                this.partAircraftList.Clear();
            }
        }

        public Boolean IsBeaconInBeaconsArray(Beacon[] array, string value)
        {
            Boolean result = false;
            for (int i = 0; i < array.Length; i++)
            {
                if (array[i].Code == value)
                {
                    result = true;
                    break;
                }
            }
            return result;
        }

        private double PanAndZoomX(double x)
        {
            //return GetImageCoordinates((float)x, 0).X;
            return GetScreenCoordinates((float)x, 0).X;
        }

        private double PanAndZoomY(double y)
        {
            //return GetImageCoordinates(0, (float)y).Y;
            return GetScreenCoordinates(0, (float)y).Y;
        }

        PointF GetScreenCoordinates(float Xi, float Yi)
        {
            //return new PointF(Zoom * (Xi + PanX), Zoom * (Yi + PanY));
            return new PointF(Zoom * (Xi + PanX), -Zoom * (Yi + PanY));
        }

        PointF GetImageCoordinates(float Xs, float Ys)
        {
            //return new PointF(Xs / Zoom - PanX, (Ys) / Zoom - PanY);
            return new PointF(Xs / Zoom - PanX, -Ys / Zoom - PanY);
        }

        #endregion

        #region Getters and Setters

        public string SelectedAircraft
        {
            get { return selectedAircraft; }
            set { selectedAircraft = value; }
        }

        public int CurrentHour
        {
            get { return currentHour; }
            set { currentHour = value; }
        }

        public int CurrentMinute
        {
            get { return currentMinute; }
            set { currentMinute = value; }
        }

        public int CurrentSecond
        {
            get { return currentSecond; }
            set { currentSecond = value; }
        }

        #endregion

        public void updateView(System.Collections.Generic.Dictionary<string, System.Collections.Generic.List<AircraftPosition>> listOfAircrafts)
        {
            this.Invalidate();
        }

        internal void AddNewPenDown(PointF pointF)
        {

            PointF calibratedTopLeft = new PointF(0.090f, 0.1f);
            PointF calibratedBottomRight = new PointF(0.865f, 0.91f);


            //Scale the value the the corrected scale
            float correctedX = MathTools.GenericScaleF(pointF.X, calibratedTopLeft.X, 100, calibratedBottomRight.X, this.Width - 100);
            float correctedY = MathTools.GenericScaleF(pointF.Y, calibratedTopLeft.Y, 100, calibratedBottomRight.Y, this.Height - 100);

            AnotoPenDown = new PointF(correctedX, correctedY);

        }
    }
}