diff options
Diffstat (limited to 'SimpleRadar_etudiants/UserControlRadarView.cs')
| -rw-r--r-- | SimpleRadar_etudiants/UserControlRadarView.cs | 2470 |
1 files changed, 2470 insertions, 0 deletions
diff --git a/SimpleRadar_etudiants/UserControlRadarView.cs b/SimpleRadar_etudiants/UserControlRadarView.cs new file mode 100644 index 0000000..48a5e9c --- /dev/null +++ b/SimpleRadar_etudiants/UserControlRadarView.cs @@ -0,0 +1,2470 @@ +using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Drawing;
+using System.Data;
+using System.Text;
+using System.Windows.Forms;
+using System.Xml.Serialization;
+using System.IO;
+using Data;
+
+namespace SimpleRadar
+{
+ public partial class UserControlRadarView : UserControl
+ {
+ #region Attributes
+
+ // public FormRadar formRadar;
+
+ 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.HighQuality;
+
+ 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);
+
+
+ #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
+
+ //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;
+ }
+ }
+ }
+
+ //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++;
+ }
+ }
+ }
+
+ #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
+
+ }
+
+ #endregion
+
+ #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")
+ {
+ 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
+ {
+ FormRadar.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
+ }
+}
|