From 42dc1d36235292786322d28340a81c6cb3fd46c0 Mon Sep 17 00:00:00 2001 From: hurter Date: Wed, 31 Aug 2011 16:25:05 +0000 Subject: --- SimpleRadar/UserControlRadarView.cs | 2554 +++++++++++++++++++++++++++++++++++ 1 file changed, 2554 insertions(+) create mode 100644 SimpleRadar/UserControlRadarView.cs (limited to 'SimpleRadar/UserControlRadarView.cs') diff --git a/SimpleRadar/UserControlRadarView.cs b/SimpleRadar/UserControlRadarView.cs new file mode 100644 index 0000000..9f6674c --- /dev/null +++ b/SimpleRadar/UserControlRadarView.cs @@ -0,0 +1,2554 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Drawing; +using System.Data; +using System.Linq; +using System.Text; +using System.Windows.Forms; +using Data; + +namespace SimpleRadar +{ + public partial class UserControlRadarView : UserControl + { + #region Attributes + + + + // public FormRadar formRadar; + public PointF AnotoPenDown = new PointF(-1, -1); + + public Label clockLabel; + public Label alidadeLabel; + + public float PanX = 0f; + public float PanY = 0f; + public float Zoom = Config.initialZoom; + + public Point PMouseDown; + public Boolean BMouseDown = false; + + public ContextMenu ctxtMenu; + + public Sector selectedSector = null; + + private Data.AppDatabase data; + + private Timer selectedAircraftTimer; + private double selectedAircraftRadius = Config.aircraftSelectedTimerRadius; + private string selectedAircraft = ""; + private double xSelectedAircraftPosition = (double)0; + private double ySelectedAircraftPosition = (double)0; + private float xCircleCenterPosition = 0f; + private float yCircleCenterPosition = 0f; + /*private bool selectedAircraftFound = false; + private int iterationsToFocus = 5; + private float xShift = (float)0; + private float yShift = (float)0;*/ + + private Timer aircraftModsTimer; + private Timer aircraftAlarmsTimer; + private ListBox alarmListBox; + + private int currentHour = 0; + private int currentMinute = 0; + private int currentSecond = 0; + + public List warningAircraftList = new List(); + + public List partAircraftList = new List(); + + public List aflFilterList = new List(); + public List aflFilterAircraftList = new List(); + public int aflSup = 0; + public int aflInf = 0; + + public Dictionary> aircraftModSDictionary = new Dictionary>(); + public Dictionary> aircraftInformationMessagesDictionary = new Dictionary>(); + public Dictionary> aircraftAlarmsDictionary = new Dictionary>(); + public Dictionary aircraftFollowedDictionary = new Dictionary(); + public Dictionary> aircraftTagMessagesDictionary = new Dictionary>(); + + 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 aircraftBeaconSeparationDictionary = new Dictionary(); + + 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()); + this.aircraftTagMessagesDictionary.Add("1711", new Dictionary()); + this.aircraftTagMessagesDictionary.Add("1315", new Dictionary()); + this.aircraftTagMessagesDictionary.Add("1947", new Dictionary()); + + ////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 aircraftToDeleteList = new List(); + + 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 aircraftToDeleteList = new List(); + //bool refresh = false; + this.alarmListBox.Items.Clear(); + + foreach (string aircraft in this.aircraftAlarmsDictionary.Keys) + { + float xPos = (float)this.aircraftAlarmsDictionary[aircraft]["xPos"]; + float yPos = (float)this.aircraftAlarmsDictionary[aircraft]["yPos"]; + int timerLifetime = (int)this.aircraftAlarmsDictionary[aircraft]["timeRemaining"]; + bool alarmLaunched = (bool)this.aircraftAlarmsDictionary[aircraft]["alarmLaunched"]; + + if ((xPos != (float)0) && (yPos != (float)0) && (timerLifetime > 0)) + { + if (alarmLaunched) + { + + /*refresh = true; + + PointF aircraftScreenCoord = GetScreenCoordinates(xPos, yPos); + bool aircraftFound = (bool)this.aircraftAlarmsDictionary[aircraft]["aircraftFound"]; + int iterations = (int)this.aircraftAlarmsDictionary[aircraft]["iterationsToFocus"]; + + if (aircraftFound == false) + { + int xCenterScreenCoord = this.ClientRectangle.Right / 2; + int yCenterScreenCoord = this.ClientRectangle.Bottom / 2; + this.aircraftAlarmsDictionary[aircraft]["xShift"] = (float)((aircraftScreenCoord.X - xCenterScreenCoord) / iterations); + this.aircraftAlarmsDictionary[aircraft]["yShift"] = (float)((aircraftScreenCoord.Y - yCenterScreenCoord) / iterations); + this.aircraftAlarmsDictionary[aircraft]["xCirclePosition"] = (float)xCenterScreenCoord; + this.aircraftAlarmsDictionary[aircraft]["yCirclePosition"] = (float)yCenterScreenCoord; + this.aircraftAlarmsDictionary[aircraft]["aircraftFound"] = true; + } + else + { + if (iterations == 0) + { + this.aircraftAlarmsDictionary[aircraft]["xCirclePosition"] = (float)aircraftScreenCoord.X; + this.aircraftAlarmsDictionary[aircraft]["yCirclePosition"] = (float)aircraftScreenCoord.Y; + } + else + { + this.aircraftAlarmsDictionary[aircraft]["xCirclePosition"] = (float)((float)this.aircraftAlarmsDictionary[aircraft]["xCirclePosition"] + (float)this.aircraftAlarmsDictionary[aircraft]["xShift"]); + this.aircraftAlarmsDictionary[aircraft]["yCirclePosition"] = (float)((float)this.aircraftAlarmsDictionary[aircraft]["yCirclePosition"] + (float)this.aircraftAlarmsDictionary[aircraft]["yShift"]); + iterations--; + this.aircraftAlarmsDictionary[aircraft]["iterationsToFocus"] = (int)iterations; + } + }*/ + + int iterations = (int)this.aircraftAlarmsDictionary[aircraft]["iterationsToFocus"]; + if (iterations > 0) + iterations--; + this.aircraftAlarmsDictionary[aircraft]["iterationsToFocus"] = (int)iterations; + + timerLifetime -= this.aircraftAlarmsTimer.Interval; + this.aircraftAlarmsDictionary[aircraft]["timeRemaining"] = timerLifetime; + + /*double radius = (double)this.aircraftAlarmsDictionary[aircraft]["radius"]; + if (radius > (double)60) + radius -= (double)40; + this.aircraftAlarmsDictionary[aircraft]["radius"] = radius;*/ + } + else + { + int feedbackLifetime = (int)this.aircraftAlarmsDictionary[aircraft]["feedbackTimeRemaining"]; + feedbackLifetime -= this.aircraftAlarmsTimer.Interval; + this.aircraftAlarmsDictionary[aircraft]["feedbackTimeRemaining"] = (int)feedbackLifetime; + } + } + + if (timerLifetime <= 0) + aircraftToDeleteList.Add(aircraft); + else if (alarmLaunched) + this.alarmListBox.Items.Add(this.aircraftAlarmsDictionary[aircraft]["hour"] + "h" + this.aircraftAlarmsDictionary[aircraft]["minute"] + "m" + this.aircraftAlarmsDictionary[aircraft]["second"] + "s --> Flight n°" + aircraft); + } + + foreach (string aircraft in aircraftToDeleteList) + this.aircraftAlarmsDictionary.Remove(aircraft); + aircraftToDeleteList = null; + + /*if (refresh) + { + alarmPictureBox.Visible = true; + alarmListBox.Visible = true; + } + else + { + alarmPictureBox.Visible = false; + alarmListBox.Visible = false; + }*/ + + this.Invalidate(); + } + + private void informationMessageLabel_Click(object sender, EventArgs e) + { + Label lbl = (sender as Label); + if (lbl != null) + { + lbl.Visible = false; + PictureBox pBox = (PictureBox)this.aircraftInformationMessagesDictionary[lbl.Name]["picturebox"]; + pBox.Visible = true; + this.Invalidate(); + } + } + + private void informationMessagePictureBox_Click(object sender, EventArgs e) + { + PictureBox pBox = (sender as PictureBox); + if (pBox != null) + { + if (!(this.selectedAircraft == pBox.Name)) + { + pBox.Visible = false; + Label lbl = (Label)this.aircraftInformationMessagesDictionary[pBox.Name]["label"]; + lbl.Visible = true; + this.Invalidate(); + } + } + } + + #endregion + + #region Drawing methods + + protected override void OnPaint(PaintEventArgs e) + { + Graphics g = e.Graphics; + g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias; + + Pen drawPlotsPen = Config.defaultDrawPlotsPen; + SolidBrush fillPartRectangleBrush = new SolidBrush(Config.defaultFillPartRectangleColor); + Pen drawLinePen = Config.defaultDrawLinePen; + SolidBrush drawStringBrush = new SolidBrush(Config.defaultDrawStringColor); + Font aircraftTagFont = Config.defaultAircraftTagFont; + + alarmListBox.Location = new Point((this.Width - alarmListBox.Width - 10), 10); + + //Clear the view + g.FillRectangle(new SolidBrush(Color.FromArgb(255, ColorTranslator.FromHtml("#7a797c"))), 0, 0, Width, Height); + + + #region Sectors drawing + + //Draw the sectors + if (data != null) + { + //Console.WriteLine("Nombre de secteurs : " + Sectors.Length); + foreach (Sector s in data.getSectors()) + { + //Console.WriteLine("Nom du secteur : " + s.Name); + if (s.Name == Config.selectedSectorName) + { + s.isSectorSelected = true; + selectedSector = s; + } + s.Draw(g, false); + } + } + + #endregion + + #region Routes drawing + + //Draw the routes + if (data != null) + { + int existingRoutesNumber = 0; + foreach (Route r in data.getRoutes()) + { + if ((IsBeaconInBeaconsArray(data.getBeacons(), r.B1)) && (IsBeaconInBeaconsArray(data.getBeacons(), r.B2))) + { + r.Draw(g); + existingRoutesNumber++; + } + } + //Console.WriteLine("Correct routes number : " + existingRoutesNumber + " on " + Routes.Length); + } + + #endregion + + #region Aircraft drawing + + AircraftPosition selectedAircraft = null; + Rectangle selectedHotBox = Rectangle.Empty; + //Draw the aircraft + if (data != null) + { + foreach (var track in data.getAircraftList()) + { + drawPlotsPen = Config.defaultDrawPlotsPen; + fillPartRectangleBrush = new SolidBrush(Config.defaultFillPartRectangleColor); + drawLinePen = Config.defaultDrawLinePen; + drawStringBrush = new SolidBrush(Config.defaultDrawStringColor); + aircraftTagFont = Config.defaultAircraftTagFont; + + if (track.Value.Count > 0) + { + int dx = (int)(10 * Zoom) / 2; + AircraftPosition aircraft = track.Value[track.Value.Count - 1]; + + string aflTendancy = aircraft.AFL + " "; + + if (aircraft.Tendency == -1) + aflTendancy += Config.descentTendency; + else if (aircraft.Tendency == 0) + aflTendancy += Config.stableTendency; + else if (aircraft.Tendency == 1) + aflTendancy += Config.climbTendency; + + //for the followed aircraft + if (this.aircraftFollowedDictionary.ContainsKey(aircraft.Flight)) + { + PictureBox aircraftFollowedPictureBox = this.aircraftFollowedDictionary[aircraft.Flight]; + PointF coord = GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y); + string screenPosition = getAircraftScreenLocation((float)aircraft.X, (float)aircraft.Y); + int margin = 10; + int acX = (int)coord.X; + int acY = (int)coord.Y; + int pbWidth = aircraftFollowedPictureBox.Width; + int pbHeight = aircraftFollowedPictureBox.Height; + int top = this.ClientRectangle.Top; + int right = this.ClientRectangle.Right; + int bottom = this.ClientRectangle.Bottom; + int left = this.ClientRectangle.Left; + + try + { + aircraftFollowedPictureBox.Image = Image.FromFile(Config.picturesFolderName + "/" + screenPosition + Config.picturesUsedArrowsNamesSuffix); + } + catch { } + + switch (screenPosition) + { + case "C": + aircraftFollowedPictureBox.Visible = false; + break; + case "N": + aircraftFollowedPictureBox.Location = new Point(acX - pbWidth / 2, top + margin); + g.DrawString(aircraft.CallSign, Config.followedAircraftFont, new SolidBrush(Config.followedAircraftColor), acX - 40, top + margin + pbHeight + 10); + g.DrawString(aflTendancy, Config.followedAircraftFont, new SolidBrush(Config.followedAircraftColor), acX - 20, top + margin + pbHeight + 30); + aircraftFollowedPictureBox.Visible = true; + break; + case "NE": + aircraftFollowedPictureBox.Location = new Point(right - pbWidth - margin, top + margin); + g.DrawString(aircraft.CallSign, Config.followedAircraftFont, new SolidBrush(Config.followedAircraftColor), right - pbWidth - margin - 20, top + margin + pbHeight); + g.DrawString(aflTendancy, Config.followedAircraftFont, new SolidBrush(Config.followedAircraftColor), right - pbWidth - margin, top + margin + pbHeight + 20); + aircraftFollowedPictureBox.Visible = true; + break; + case "E": + aircraftFollowedPictureBox.Location = new Point(right - pbWidth - margin, acY - pbHeight / 2); + g.DrawString(aircraft.CallSign, Config.followedAircraftFont, new SolidBrush(Config.followedAircraftColor), right - pbWidth - margin - 80, acY - 20); + g.DrawString(aflTendancy, Config.followedAircraftFont, new SolidBrush(Config.followedAircraftColor), right - pbWidth - margin - 60, acY); + aircraftFollowedPictureBox.Visible = true; + break; + case "SE": + aircraftFollowedPictureBox.Location = new Point(right - pbWidth - margin, bottom - pbHeight - margin); + g.DrawString(aircraft.CallSign, Config.followedAircraftFont, new SolidBrush(Config.followedAircraftColor), right - pbWidth - margin - 20, bottom - pbHeight - margin - 40); + g.DrawString(aflTendancy, Config.followedAircraftFont, new SolidBrush(Config.followedAircraftColor), right - pbWidth - margin, bottom - pbHeight - margin - 20); + aircraftFollowedPictureBox.Visible = true; + break; + case "S": + aircraftFollowedPictureBox.Location = new Point(acX - pbWidth / 2, bottom - pbHeight - margin); + g.DrawString(aircraft.CallSign, Config.followedAircraftFont, new SolidBrush(Config.followedAircraftColor), acX - 40, bottom - pbHeight - margin - 40); + g.DrawString(aflTendancy, Config.followedAircraftFont, new SolidBrush(Config.followedAircraftColor), acX - 20, bottom - pbHeight - margin - 20); + aircraftFollowedPictureBox.Visible = true; + break; + case "SW": + aircraftFollowedPictureBox.Location = new Point(left + margin, bottom - pbHeight - margin); + g.DrawString(aircraft.CallSign, Config.followedAircraftFont, new SolidBrush(Config.followedAircraftColor), left + margin + pbWidth - 20, bottom - pbHeight - margin - 40); + g.DrawString(aflTendancy, Config.followedAircraftFont, new SolidBrush(Config.followedAircraftColor), left + margin + pbWidth, bottom - pbHeight - margin - 20); + aircraftFollowedPictureBox.Visible = true; + break; + case "W": + aircraftFollowedPictureBox.Location = new Point(left + margin, acY - pbHeight / 2); + g.DrawString(aircraft.CallSign, Config.followedAircraftFont, new SolidBrush(Config.followedAircraftColor), left + margin + pbWidth + 10, acY - 20); + g.DrawString(aflTendancy, Config.followedAircraftFont, new SolidBrush(Config.followedAircraftColor), left + margin + pbWidth + 30, acY); + aircraftFollowedPictureBox.Visible = true; + break; + case "NW": + aircraftFollowedPictureBox.Location = new Point(left + margin, top + margin); + g.DrawString(aircraft.CallSign, Config.followedAircraftFont, new SolidBrush(Config.followedAircraftColor), left + margin + pbWidth - 20, top + margin + pbHeight); + g.DrawString(aflTendancy, Config.followedAircraftFont, new SolidBrush(Config.followedAircraftColor), left + margin + pbWidth, top + margin + pbHeight + 20); + aircraftFollowedPictureBox.Visible = true; + break; + default: + break; + } + + if (!(this.Controls.Contains(aircraftFollowedPictureBox))) + this.Controls.Add(aircraftFollowedPictureBox); + } + + //Set coordinates of the separation concerned aircraft + if (this.aircraftBeaconSeparationDictionary.Count > 0) + { + if (aircraft.Flight == this.aircraftBeaconSeparationDictionary["aircraft1"]) + { + separationAcOneX = (float)aircraft.X; + separationAcOneY = (float)aircraft.Y; + separationAcOneFound = true; + } + if (aircraft.Flight == this.aircraftBeaconSeparationDictionary["aircraft2"]) + { + separationAcTwoX = (float)aircraft.X; + separationAcTwoY = (float)aircraft.Y; + separationAcTwoFound = true; + } + } + + //Determine pens and brush depending on flight level filter, if active + if (this.aflFilterList.Count == 2) + { + if (this.aflFilterList[1] < 0) + { + aflInf = this.aflFilterList[0] + this.aflFilterList[1]; + aflSup = this.aflFilterList[0]; + } + else + { + aflInf = this.aflFilterList[0]; + aflSup = this.aflFilterList[0] + this.aflFilterList[1]; + } + + if (this.aflFilterAircraftList.Contains(aircraft.Flight)) + { + aircraftTagFont = Config.filteredAircraftTagFont; + drawStringBrush = new SolidBrush(Config.defaultDrawStringColor); + drawLinePen = Config.filteredDrawLinePen; + drawPlotsPen = Config.defaultDrawPlotsPen; + } + else + { + if ((aircraft.AFL < aflInf) || (aircraft.AFL > aflSup)) + { + aircraftTagFont = Config.defaultAircraftTagFont; + drawStringBrush = new SolidBrush(Config.unfilteredDrawStringColor); + drawLinePen = Config.unfilteredDrawLinePen; + drawPlotsPen = Config.unfilteredDrawPlotsPen; + fillPartRectangleBrush = new SolidBrush(Config.unfilteredFillPartRectangleColor); + } + else + { + aircraftTagFont = Config.filteredAircraftTagFont; + drawStringBrush = new SolidBrush(Config.defaultDrawStringColor); + drawLinePen = Config.filteredDrawLinePen; + drawPlotsPen = Config.defaultDrawPlotsPen; + } + } + } + + SizeF s = g.MeasureString(aircraft.CallSign, Font); + + //Set selected aircraft coordinates, if one + if (this.SelectedAircraft == aircraft.Flight) + { + this.xSelectedAircraftPosition = aircraft.X; + this.ySelectedAircraftPosition = aircraft.Y; + PointF selectedAircraftScreenCoord = GetScreenCoordinates((float)this.xSelectedAircraftPosition, (float)this.ySelectedAircraftPosition); + this.xCircleCenterPosition = selectedAircraftScreenCoord.X; + this.yCircleCenterPosition = selectedAircraftScreenCoord.Y; + } + + //Highlight part aircraft + if (partAircraftList.Contains(aircraft.Flight)) + { + drawPlotsPen = Config.partDrawPlotsPen; + g.FillRectangle(fillPartRectangleBrush, + GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).X + dx, + GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).Y - dx, + s.Width, + s.Height); + } + + //Highlight warning aircraft + if (warningAircraftList.Contains(aircraft.Flight)) + { + drawPlotsPen = Config.warningDrawPlotsPen; + PointF p1 = new PointF(GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).X + dx + s.Width + 8, GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).Y - dx); + PointF p2 = new PointF(GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).X + dx + s.Width + 13, GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).Y - dx + s.Height / 2); + PointF p3 = new PointF(GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).X + dx + s.Width + 8, GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).Y - dx + s.Height); + PointF p4 = new PointF(GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).X + dx + s.Width + 3, GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).Y - dx + s.Height / 2); + PointF[] warningLosangeArray = { p1, p2, p3, p4 }; + g.FillPolygon(new SolidBrush(Config.warningFillPolygonColor), + warningLosangeArray); + } + + //Draw aircraft tag if not anonymous : call sign + flight level + tendancy + ground speed + tag line + if (!(this.aircraftTagMessagesDictionary.ContainsKey(aircraft.Flight))) + { + g.DrawString(aircraft.CallSign, + aircraftTagFont, + drawStringBrush, + GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).X + dx, + GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).Y - dx); + + /*g.DrawString(aircraft.Sector, + aircraftTagFont, + drawStringBrush, + GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).X + dx, + GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).Y - dx + 2 * s.Height);*/ + } + else + { + /*string stripNbr = ""; + if (this.aircraftTagMessagesDictionary[aircraft.Flight].ContainsKey("strip")) + stripNbr = " / Strip " + (int)this.aircraftTagMessagesDictionary[aircraft.Flight]["strip"];*/ + + g.DrawString(aircraft.Ssr, + aircraftTagFont, + drawStringBrush, + GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).X + dx, + GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).Y - dx); + + if (this.aircraftTagMessagesDictionary[aircraft.Flight].ContainsKey("picturebox")) + { + //bool buildingMessage = (bool)this.aircraftTagMessagesDictionary[aircraft.Flight]["buildingmessage"]; + //if (!buildingMessage) + //{ + PictureBox pBox = (PictureBox)this.aircraftTagMessagesDictionary[aircraft.Flight]["picturebox"]; + pBox.Location = new Point((int)GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).X + dx, + (int)GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).Y - dx + (int)(s.Height * 2.2)); + pBox.Visible = true; + if (!(this.Controls.Contains(pBox))) + this.Controls.Add(pBox); + //} + } + } + + g.DrawString("" + (int)(aircraft.GroundSpeed / 10), + aircraftTagFont, + drawStringBrush, + GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).X + dx, + GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).Y - dx - s.Height); + + g.DrawString(aflTendancy, + aircraftTagFont, + drawStringBrush, + GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).X + dx, + GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).Y - dx + s.Height); + + g.DrawLine(drawLinePen, + GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).X + dx, + GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).Y - dx + Font.Height / 2, + GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).X, + GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).Y); + + //Draw the ModS for the aircraft, if one + if (this.aircraftModSDictionary.ContainsKey(aircraft.Flight)) + { + this.aircraftModSDictionary[aircraft.Flight]["xPos"] = (float)aircraft.X; + this.aircraftModSDictionary[aircraft.Flight]["yPos"] = (float)aircraft.Y; + string modsPrefix = ""; + string modsSuffix = ""; + string succeed = (string)this.aircraftModSDictionary[aircraft.Flight]["succeed"]; + int iterations = (int)this.aircraftModSDictionary[aircraft.Flight]["iterationsToFocus"]; + + Color color = Config.modsNormalColor; + + if (iterations == 0) + { + if (succeed.ToLower() == "true") + { + color = Config.modsSucceedColor; + modsPrefix = Config.modsPrefix; + modsSuffix = Config.modsSuffix; + } + else + color = Config.modsUnsucceedColor; + } + + g.DrawString(modsPrefix + (string)this.aircraftModSDictionary[aircraft.Flight]["level"] + "M" + modsSuffix + " " + (string)this.aircraftModSDictionary[aircraft.Flight]["nextSector"], + Config.modsFont, + new SolidBrush(Color.FromArgb(255, color)), + GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).X + dx, + GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).Y - dx + 2 * s.Height); + } + + //Launch the alarm for the aircraft, if one + if (this.aircraftAlarmsDictionary.ContainsKey(aircraft.Flight)) + { + int hour = (int)this.aircraftAlarmsDictionary[aircraft.Flight]["hour"]; + int minute = (int)this.aircraftAlarmsDictionary[aircraft.Flight]["minute"]; + int second = (int)this.aircraftAlarmsDictionary[aircraft.Flight]["second"]; + + this.aircraftAlarmsDictionary[aircraft.Flight]["xPos"] = (float)aircraft.X; + this.aircraftAlarmsDictionary[aircraft.Flight]["yPos"] = (float)aircraft.Y; + + PictureBox pBox = (PictureBox)this.aircraftAlarmsDictionary[aircraft.Flight]["picturebox"]; + + if ((this.CurrentHour >= hour) && (this.CurrentMinute >= minute) && (this.CurrentSecond >= second)) + { + this.aircraftAlarmsDictionary[aircraft.Flight]["alarmLaunched"] = true; + pBox.Visible = false; + if (this.Controls.Contains(pBox)) + this.Controls.Remove(pBox); + } + else + { + pBox.Location = new Point((int)(GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).X + dx), (int)(GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).Y - dx - 2 * s.Height)); + pBox.Visible = true; + + if (!(this.Controls.Contains(pBox))) + this.Controls.Add(pBox); + + int feedbackLifetime = (int)this.aircraftAlarmsDictionary[aircraft.Flight]["feedbackTimeRemaining"]; + if (feedbackLifetime > 0) + { + g.DrawString((int)this.aircraftAlarmsDictionary[aircraft.Flight]["hour"] + "h" + (int)this.aircraftAlarmsDictionary[aircraft.Flight]["minute"] + "m", + Config.alarmFont, + new SolidBrush(Config.alarmColor), + GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).X + dx + 16, + GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).Y - dx - 2 * s.Height); + } + /*else + { + pBox.Visible = false; + if (this.Controls.Contains(pBox)) + this.Controls.Remove(pBox); + }*/ + } + } + + //Check if an information message is associated + if (this.aircraftInformationMessagesDictionary.ContainsKey(aircraft.Flight)) + { + bool buildingMessage = (bool)this.aircraftInformationMessagesDictionary[aircraft.Flight]["buildingmessage"]; + + if (!buildingMessage) + { + Label lbl = (Label)this.aircraftInformationMessagesDictionary[aircraft.Flight]["label"]; + PictureBox pBox = (PictureBox)this.aircraftInformationMessagesDictionary[aircraft.Flight]["picturebox"]; + + if (!(this.Controls.Contains(lbl))) + { + lbl.Click += new EventHandler(informationMessageLabel_Click); + this.Controls.Add(lbl); + } + + if (!(this.Controls.Contains(pBox))) + { + pBox.Click += new EventHandler(informationMessagePictureBox_Click); + this.Controls.Add(pBox); + } + + lbl.Font = new Font(Config.iInformationMessageLabelFontFamily, (float)(Config.iInformationMessageLabelFontSizeCoefficient * dx), FontStyle.Bold); + lbl.Size = new Size(dx, dx); + lbl.Location = new Point((int)GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).X + dx + (int)(s.Width / 1.6), (int)GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).Y - dx + (int)(s.Height * 1.2)); + + pBox.Location = new Point((int)GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).X + dx + (int)(s.Width / 1.6), (int)GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y).Y - dx + (int)(s.Height * 1.2)); + + if (pBox.Visible == false) + lbl.Visible = true; + } + } + + //Get the bounding Hot Box : only the label + SizeF maxTextSize = g.MeasureString(aircraft.CallSign, Font); + PointF pt = GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y); + + Rectangle HotBoxRect = new Rectangle( (int)(pt.X) + dx, + (int)(pt.Y - dx - s.Height), + (int)(s.Width + 10), + (int)(s.Height * 3) ); + + if (HotBoxRect.Contains(new Point((int)AnotoPenDown.X, (int)AnotoPenDown.Y))) + { + selectedAircraft = aircraft; + selectedHotBox = HotBoxRect; + } + + } + + //Draw the aircraft plots + int pos = 0; + foreach (var plot in track.Value) + { + float dx = (pos * Zoom) / 5; + float x = GetScreenCoordinates((float)plot.X, (float)plot.Y).X - dx / 2; + float y = GetScreenCoordinates((float)plot.X, (float)plot.Y).Y - dx / 2; + g.DrawRectangle(drawPlotsPen, x, y, dx, dx); + pos++; + } + + //Draw the hot box area + } + } + + #endregion + + #region Magaged selected aircraft + + if (selectedAircraft != null) + { + SeleteAircraftFromRadarScreen(selectedAircraft.CallSign); + g.FillRectangle(new SolidBrush(Color.FromArgb(100, 100, 20, 20)), selectedHotBox); + } + + #endregion + + #region Beacons drawing + + //Draw the beacons + if (data != null) + { + foreach (Beacon b in data.getBeacons()) + { + if (selectedSector != null) + { + //Highlight the beacons in the selected sector + if (Sector.PointInPolygon(b.toPointF(), selectedSector)) + { + b.isBeaconSelected = true; + b.Draw(g); + } + else + { + b.isBeaconSelected = false; + if ((b.Code == "OTKOL") || (b.Code == "OBUBA")) + b.Draw(g); + } + } + else + { + b.isBeaconSelected = false; + //b.Draw(g); + } + } + } + + #endregion + + #region Separation drawing + + float previousBeacon1X = (float)0; + float previousBeacon1Y = (float)0; + float currentBeacon1X = (float)0; + float currentBeacon1Y = (float)0; + + float previousBeacon2X = (float)0; + float previousBeacon2Y = (float)0; + float currentBeacon2X = (float)0; + float currentBeacon2Y = (float)0; + + //Draw the separation between two aircraft and a beacon + the distance + if (this.aircraftBeaconSeparationDictionary.Count > 0) + { + if (separationAcOneFound && separationAcTwoFound && (data != null)) + { + char[] separationCharsArray = { ' ' }; + string[] beacons1Array = this.aircraftBeaconSeparationDictionary["route1"].Split(separationCharsArray); + string[] beacons2Array = this.aircraftBeaconSeparationDictionary["route2"].Split(separationCharsArray); + + previousBeacon1X = separationAcOneX; + previousBeacon1Y = separationAcOneY; + g.DrawString(this.aircraftBeaconSeparationDictionary["distance1"] + " NM", + Config.separationBeaconDistancesFont, + new SolidBrush(Config.separationBeaconDistanceOneColor), + GetScreenCoordinates(previousBeacon1X, previousBeacon1Y).X - 50, + GetScreenCoordinates(previousBeacon1X, previousBeacon1Y).Y); + for (int i = 0; i < beacons1Array.Length; i++) + { + foreach (Beacon b in data.getBeacons()) + { + if (b.Code == beacons1Array[i]) + { + currentBeacon1X = (float)(b.toPointF().X / 8); + currentBeacon1Y = (float)(b.toPointF().Y / 8); + g.DrawLine(Config.separationBeaconDistanceOnePen, + GetScreenCoordinates(previousBeacon1X, previousBeacon1Y).X, + GetScreenCoordinates(previousBeacon1X, previousBeacon1Y).Y, + GetScreenCoordinates(currentBeacon1X, currentBeacon1Y).X, + GetScreenCoordinates(currentBeacon1X, currentBeacon1Y).Y); + previousBeacon1X = currentBeacon1X; + previousBeacon1Y = currentBeacon1Y; + } + } + } + + previousBeacon2X = separationAcTwoX; + previousBeacon2Y = separationAcTwoY; + g.DrawString(this.aircraftBeaconSeparationDictionary["distance2"] + " NM", + Config.separationBeaconDistancesFont, + new SolidBrush(Config.separationBeaconDistanceTwoColor), + GetScreenCoordinates(previousBeacon2X, previousBeacon2Y).X - 50, + GetScreenCoordinates(previousBeacon2X, previousBeacon2Y).Y); + for (int i = 0; i < beacons2Array.Length; i++) + { + foreach (Beacon b in data.getBeacons()) + { + if (b.Code == beacons2Array[i]) + { + currentBeacon2X = (float)(b.toPointF().X / 8); + currentBeacon2Y = (float)(b.toPointF().Y / 8); + g.DrawLine(Config.separationBeaconDistanceTwoPen, + GetScreenCoordinates(previousBeacon2X, previousBeacon2Y).X, + GetScreenCoordinates(previousBeacon2X, previousBeacon2Y).Y, + GetScreenCoordinates(currentBeacon2X, currentBeacon2Y).X, + GetScreenCoordinates(currentBeacon2X, currentBeacon2Y).Y); + previousBeacon2X = currentBeacon2X; + previousBeacon2Y = currentBeacon2Y; + } + } + } + + char[] separationArray = { ' ' }; + + float x1CurrentThick = (float)0; + float y1CurrentThick = (float)0; + PointF location1PointF; + string thicks1 = (string)this.aircraftBeaconSeparationDictionary["thicks1"]; + string[] thicks1Array = thicks1.Split(separationArray); + for (int i = 0; i < (thicks1Array.Length - 1); i += 2) + { + try + { + x1CurrentThick = float.Parse(thicks1Array[i]); + y1CurrentThick = float.Parse(thicks1Array[i + 1]); + + location1PointF = new PointF(x1CurrentThick, y1CurrentThick); + + g.FillEllipse(new SolidBrush(Config.separationBeaconDistanceOneColor), + (float)PanAndZoomX(location1PointF.X / (float)8) - (Config.thicksOneEllipseSize / 2), + (float)PanAndZoomY(location1PointF.Y / (float)8) - (Config.thicksOneEllipseSize / 2), + Config.thicksOneEllipseSize, + Config.thicksOneEllipseSize); + } + catch { } + } + + float x2CurrentThick = (float)0; + float y2CurrentThick = (float)0; + PointF location2PointF; + string thicks2 = (string)this.aircraftBeaconSeparationDictionary["thicks2"]; + string[] thicks2Array = thicks2.Split(separationArray); + for (int i = 0; i < (thicks2Array.Length - 1); i += 2) + { + try + { + x2CurrentThick = float.Parse(thicks2Array[i]); + y2CurrentThick = float.Parse(thicks2Array[i + 1]); + + location2PointF = new PointF(x2CurrentThick, y2CurrentThick); + + g.FillEllipse(new SolidBrush(Config.separationBeaconDistanceTwoColor), + (float)PanAndZoomX(location2PointF.X / (float)8) - (Config.thicksTwoEllipseSize / 2), + (float)PanAndZoomY(location2PointF.Y / (float)8) - (Config.thicksTwoEllipseSize / 2), + Config.thicksTwoEllipseSize, + Config.thicksTwoEllipseSize); + } + catch { } + } + + int length = Math.Min(thicks1Array.Length, thicks2Array.Length); + for (int i = 0; i < (length - 1); i += 2) + { + try + { + x1CurrentThick = float.Parse(thicks1Array[i]); + y1CurrentThick = float.Parse(thicks1Array[i + 1]); + location1PointF = new PointF(x1CurrentThick, y1CurrentThick); + + x2CurrentThick = float.Parse(thicks2Array[i]); + y2CurrentThick = float.Parse(thicks2Array[i + 1]); + location2PointF = new PointF(x2CurrentThick, y2CurrentThick); + + Pen thicksJointPen = Config.thicksJointLinesPen; + thicksJointPen.DashStyle = Config.thicksJointLinesPenDashStyle; + + g.DrawLine(thicksJointPen, + (float)PanAndZoomX(location1PointF.X / (float)8), + (float)PanAndZoomY(location1PointF.Y / (float)8), + (float)PanAndZoomX(location2PointF.X / (float)8), + (float)PanAndZoomY(location2PointF.Y / (float)8)); + } + catch { } + } + + int distance = int.Parse(this.aircraftBeaconSeparationDictionary["distance"]); + + Color distColor = Config.goodSeparationDistanceColor; + if (distance <= Config.minimumAvailableDistance) + distColor = Config.wrongSeparationDistanceColor; + + g.DrawString(distance + " NM", + Config.separationBeaconDistancesFont, + new SolidBrush(distColor), + GetScreenCoordinates(currentBeacon2X, currentBeacon2Y).X - 50, + GetScreenCoordinates(currentBeacon2X, currentBeacon2Y).Y); + } + } + + #endregion + + #region Downing circles drawing + + //if an aircraft is selected + if ((this.xSelectedAircraftPosition != 0) && (this.ySelectedAircraftPosition != 0)) + { + Pen pen = Config.aircraftSelectedPen; + //SolidBrush brush = new SolidBrush(Color.FromArgb(50, Color.Blue)); + + g.DrawEllipse(pen, + //g.FillEllipse(brush, + //GetScreenCoordinates(xPos, yPos).X - radius / 2, + xCircleCenterPosition - (float)this.selectedAircraftRadius / 2, + //GetScreenCoordinates(xPos, yPos).Y - radius / 2, + yCircleCenterPosition - (float)this.selectedAircraftRadius / 2, + (float)this.selectedAircraftRadius, + (float)this.selectedAircraftRadius); + } + + /*foreach (string aircraft in this.aircraftModSDictionary.Keys) + { + float xPos = (float)this.aircraftModSDictionary[aircraft]["xPos"]; + float yPos = (float)this.aircraftModSDictionary[aircraft]["yPos"]; + int timerLifetime = (int)this.aircraftModSDictionary[aircraft]["timeRemaining"]; + bool aircraftFound = (bool)this.aircraftModSDictionary[aircraft]["aircraftFound"]; + int iterationsNbr = (int)this.aircraftModSDictionary[aircraft]["iterationsToFocus"]; + + PointF aircraftScreenCoord = GetScreenCoordinates(xPos, yPos); + this.aircraftModSDictionary[aircraft]["xCirclePosition"] = (float)aircraftScreenCoord.X; + this.aircraftModSDictionary[aircraft]["yCirclePosition"] = (float)aircraftScreenCoord.Y; + + if ((xPos != (float)0) && (yPos != (float)0) && (timerLifetime > 0)) + { + //float xCCPos = (float)this.aircraftModSDictionary[aircraft]["xCirclePosition"]; + //float yCCPos = (float)this.aircraftModSDictionary[aircraft]["yCirclePosition"]; + float xCCPos = (float)aircraftScreenCoord.X; + float yCCPos = (float)aircraftScreenCoord.Y; + double radius = (double)this.aircraftModSDictionary[aircraft]["radius"]; + string succeed = (string)this.aircraftModSDictionary[aircraft]["succeed"]; + Color color = Config.modsNormalColor; + + if (iterationsNbr == 0) + { + if (succeed.ToLower() == "true") + color = Config.modsSucceedColor; + else + color = Config.modsUnsucceedColor; + } + + //Pen pen = new Pen(Color.FromArgb(50, color), 2.5f); + SolidBrush brush = new SolidBrush(Color.FromArgb(50, color)); + + //g.DrawEllipse(pen, + g.FillEllipse(brush, + xCCPos - (float)radius / 2, + yCCPos - (float)radius / 2, + (float)radius, + (float)radius); + } + }*/ + + foreach (string aircraft in this.aircraftAlarmsDictionary.Keys) + { + float xPos = (float)this.aircraftAlarmsDictionary[aircraft]["xPos"]; + float yPos = (float)this.aircraftAlarmsDictionary[aircraft]["yPos"]; + int timerLifetime = (int)this.aircraftAlarmsDictionary[aircraft]["timeRemaining"]; + bool alarmLaunched = (bool)this.aircraftAlarmsDictionary[aircraft]["alarmLaunched"]; + bool aircraftFound = (bool)this.aircraftAlarmsDictionary[aircraft]["aircraftFound"]; + + PointF aircraftScreenCoord = GetScreenCoordinates(xPos, yPos); + this.aircraftAlarmsDictionary[aircraft]["xCirclePosition"] = (float)aircraftScreenCoord.X; + this.aircraftAlarmsDictionary[aircraft]["yCirclePosition"] = (float)aircraftScreenCoord.Y; + + if (alarmLaunched && (xPos != (float)0) && (yPos != (float)0) && (timerLifetime > 0)) + { + //float xCCPos = (float)this.aircraftAlarmsDictionary[aircraft]["xCirclePosition"]; + //float yCCPos = (float)this.aircraftAlarmsDictionary[aircraft]["yCirclePosition"]; + float xCCPos = (float)aircraftScreenCoord.X; + float yCCPos = (float)aircraftScreenCoord.Y; + + double radius = (double)this.aircraftAlarmsDictionary[aircraft]["radius"]; + + //Pen pen = new Pen(Color.FromArgb(50, Config.alarmColor), 2.5f); + SolidBrush brush = new SolidBrush(Color.FromArgb(50, Config.alarmCircleColor)); + + //g.DrawEllipse(pen, + g.FillEllipse(brush, + xCCPos - (float)radius / 2, + yCCPos - (float)radius / 2, + (float)radius, + (float)radius); + } + } + + #endregion + + #region CFL filter feedback drawing + + //Draw feedback with afl filter values + if (this.aflFilterList.Count == 2) + { + string aflSupStr = "" + aflSup; + string sepOne = "^"; + string sepTwo = "^"; + string aflInfStr = "" + aflInf; + + SolidBrush brush = new SolidBrush(Config.filterActiveColor); + Font font = Config.filterActiveFont; + + SizeF sizeAflSup = g.MeasureString(aflSupStr, font); + SizeF sizeSepOne = g.MeasureString(sepOne, font); + SizeF sizeSepTwo = g.MeasureString(sepTwo, font); + SizeF sizeAflInf = g.MeasureString(aflInfStr, font); + + int screenWidth = this.ClientRectangle.Right - this.ClientRectangle.Left; + int screenHeight = this.ClientRectangle.Bottom - this.ClientRectangle.Top; + + g.DrawString(aflSupStr, font, brush, ((screenWidth - sizeAflSup.Width) / 2), ((screenHeight - sizeAflSup.Height) / 2) - 80); + g.DrawString(sepOne, font, brush, ((screenWidth - sizeSepOne.Width) / 2), ((screenHeight - sizeSepOne.Height) / 2)); + g.DrawString(sepTwo, font, brush, ((screenWidth - sizeSepTwo.Width) / 2), ((screenHeight - sizeSepTwo.Height) / 2) + 40); + g.DrawString(aflInfStr, font, brush, ((screenWidth - sizeAflInf.Width) / 2), ((screenHeight - sizeAflInf.Height) / 2) + 100); + } + + #endregion + + #region France map drawing + + //Draw the map + FranceMap.Draw(g, Config.franceDrawingPen); + + #endregion + + #region Alidade drawing + + if (this.alidadeActivate && this.alidadeFirstPointSet) + { + PointF finalPoint = new PointF(); + + if (this.alidadeSecondPointSet) + finalPoint = alidadeSecondPoint; + else + finalPoint = alidadeCurrentPoint; + + g.DrawLine(Config.alidadePen, + GetScreenCoordinates((float)alidadeFirstPoint.X, (float)alidadeFirstPoint.Y).X, + GetScreenCoordinates((float)alidadeFirstPoint.X, (float)alidadeFirstPoint.Y).Y, + GetScreenCoordinates((float)finalPoint.X, (float)finalPoint.Y).X, + GetScreenCoordinates((float)finalPoint.X, (float)finalPoint.Y).Y); + + float dx = ((float)finalPoint.X - (float)alidadeFirstPoint.X); + float dy = ((float)finalPoint.Y - (float)alidadeFirstPoint.Y); + float dist = (float)Math.Round(Math.Sqrt(dx * dx + dy * dy), Config.alidadeDistancePrecision); + dist = dist * Config.alidadeDistanceCoefficient; + + if (dist > 0f) + g.DrawString(dist + Config.alidadeDistanceSuffix, + Config.alidadeDistanceFont, + new SolidBrush(Config.alidadeDistanceColor), + GetScreenCoordinates((float)finalPoint.X, (float)finalPoint.Y).X + Config.alidadeDistanceXShift, + GetScreenCoordinates((float)finalPoint.X, (float)finalPoint.Y).Y + Config.alidadeDistanceYShift); + } + + #endregion + + //Draw the pen down + g.FillEllipse(new SolidBrush(Color.FromArgb(150, 0, 100, 255)), AnotoPenDown.X - 12, AnotoPenDown.Y - 12, 24, 24); + + /* Point CalibrationTopLeft = new Point(100,100); + Point CalibrationBottomRight = new Point(this.Width-100, this.Height-100); + + //Draw Calibration + g.FillEllipse(Brushes.Yellow, CalibrationTopLeft.X-5, CalibrationTopLeft.Y-5, 10, 10); + g.FillEllipse(Brushes.Yellow, CalibrationBottomRight.X-5, CalibrationTopLeft.Y-5, 10, 10); + g.FillEllipse(Brushes.Yellow, CalibrationTopLeft.X-5, CalibrationBottomRight.Y-5, 10, 10); + g.FillEllipse(Brushes.Yellow, CalibrationBottomRight.X-5, CalibrationBottomRight.Y-5, 10, 10); + */ + + } + + + + #endregion + + string LastSelectedAircraftID = ""; + //Send the message that an aircraft as been selected form the radar screen + private void SeleteAircraftFromRadarScreen(string aircraftId) + { + if (LastSelectedAircraftID != aircraftId) + { + FormSimpleRadar.TheIvyBus.SendMsg("SeleteAircraftFromRadarScreen " + "AircraftId=" + aircraftId); + // IvyBus.ivy.BindMsg(@"SeleteAircraftFromRadarScreen AircraftId=(.*) ", SeleteAircraftFromRadarScreen, null); + LastSelectedAircraftID = aircraftId; + } + } + + + #region Other methods + + public void updateClock(int hour, int minute, int second) + { + if ((this.CurrentHour != hour) || (this.CurrentMinute != minute) || (this.CurrentSecond != second)) + { + this.CurrentHour = hour; + this.CurrentMinute = minute; + this.CurrentSecond = second; + string h = "" + this.CurrentHour; + if (h.Length == 1) + h = "0" + h; + string m = "" + this.CurrentMinute; + if (m.Length == 1) + m = "0" + m; + this.clockLabel.Text = h + ":" + m; + } + //Console.WriteLine(this.CurrentHour + "h " + this.CurrentMinute + "m " + this.CurrentSecond + "s"); + } + + public void setData(Data.AppDatabase data) + { + this.data = data; + } + + + public void showAircraftContextualMenu(int x, int y) + { + if (data != null) + { + foreach (var track in data.getAircraftList()) + { + if (track.Value.Count > 0) + { + int dx = (int)(10 * Zoom) / 2; + AircraftPosition aircraft = track.Value[track.Value.Count - 1]; + PointF acScreenCoord = GetScreenCoordinates((float)aircraft.X, (float)aircraft.Y); + int xScreenCoord = (int)acScreenCoord.X; + int yScreenCoord = (int)acScreenCoord.Y; + if ((xScreenCoord >= (x - 5)) && (xScreenCoord <= (x + 5))) + { + if ((yScreenCoord >= (y - 5)) && (yScreenCoord <= (y + 5))) + { + aircraftCheckedContextualMenu = aircraft.Flight; + } + } + } + } + } + + ctxtMenu = new ContextMenu(); + + MenuItem visuPisteMenuItem = new MenuItem(); + visuPisteMenuItem.Index = 0; + visuPisteMenuItem.Text = Config.visuPisteMenuItemCaption; + MenuItem montrerMenuItem = new MenuItem(); + montrerMenuItem.Index = 1; + montrerMenuItem.Text = Config.montrerMenuItemCaption; + MenuItem shootRequestMenuItem = new MenuItem(); + shootRequestMenuItem.Index = 2; + shootRequestMenuItem.Text = Config.shootRequestMenuItemCaption; + MenuItem flMenuItem = new MenuItem(); + flMenuItem.Index = 3; + flMenuItem.Text = Config.flMenuItemCaption; + MenuItem ripMenuItem = new MenuItem(); + ripMenuItem.Index = 4; + ripMenuItem.Text = Config.ripMenuItemCaption; + MenuItem mvtMenuItem = new MenuItem(); + mvtMenuItem.Index = 5; + mvtMenuItem.Text = Config.mvtMenuItemCaption; + MenuItem modMenuItem = new MenuItem(); + modMenuItem.Index = 6; + modMenuItem.Text = Config.modMenuItemCaption; + MenuItem partMenuItem = new MenuItem(); + partMenuItem.Index = 7; + partMenuItem.Text = Config.partMenuItemCaption; + partMenuItem.DefaultItem = true; + partMenuItem.Click += new EventHandler(partMenuItem_Click); + MenuItem warningMenuItem = new MenuItem(); + warningMenuItem.Index = 8; + warningMenuItem.Text = Config.warningMenuItemCaption; + warningMenuItem.Click += new EventHandler(warningMenuItem_Click); + MenuItem accesPlnMenuItem = new MenuItem(); + accesPlnMenuItem.Index = 9; + accesPlnMenuItem.Text = Config.accesPlnMenuItemCaption; + MenuItem cnlMenuItem = new MenuItem(); + cnlMenuItem.Index = 10; + cnlMenuItem.Text = Config.cnlMenuItemCaption; + MenuItem decorMenuItem = new MenuItem(); + decorMenuItem.Index = 11; + decorMenuItem.Text = Config.decorMenuItemCaption; + MenuItem lvolMenuItem = new MenuItem(); + lvolMenuItem.Index = 12; + lvolMenuItem.Text = Config.lvolMenuItemCaption; + + ctxtMenu.MenuItems.AddRange(new MenuItem[] { visuPisteMenuItem, montrerMenuItem, shootRequestMenuItem, flMenuItem, ripMenuItem, mvtMenuItem, modMenuItem, + partMenuItem, warningMenuItem, accesPlnMenuItem, cnlMenuItem, decorMenuItem, lvolMenuItem }); + + if (aircraftCheckedContextualMenu == "") + this.ContextMenu = null; + else + { + this.ContextMenu = ctxtMenu; + aircraftSelectedContextualMenu = aircraftCheckedContextualMenu; + aircraftCheckedContextualMenu = ""; + } + } + + public void manageSelectedAircraftTimer(string actionType, string aircraftFlight) + { + if (actionType == "add") + { + this.selectedAircraftRadius = Config.aircraftSelectedTimerRadius; + this.xSelectedAircraftPosition = 0; + this.ySelectedAircraftPosition = 0; + this.SelectedAircraft = aircraftFlight; + this.selectedAircraftTimer = new Timer(); + this.selectedAircraftTimer.Interval = Config.aircraftSelectedTimerInterval; + this.selectedAircraftTimer.Tick += new EventHandler(selectedAircraftTimer_Tick); + this.selectedAircraftTimer.Enabled = true; + this.selectedAircraftTimer.Start(); + if (this.aircraftInformationMessagesDictionary.ContainsKey(this.SelectedAircraft)) + { + PictureBox pBox = (PictureBox)this.aircraftInformationMessagesDictionary[aircraftFlight]["picturebox"]; + pBox.Visible = true; + Label lbl = (Label)this.aircraftInformationMessagesDictionary[aircraftFlight]["label"]; + lbl.Visible = false; + } + } + else if (actionType == "clear") + { + if (this.selectedAircraftTimer != null) + this.selectedAircraftTimer.Stop(); + this.Invalidate(); + this.selectedAircraftRadius = Config.aircraftSelectedTimerRadius; + this.SelectedAircraft = ""; + this.xSelectedAircraftPosition = 0; + this.ySelectedAircraftPosition = 0; + if (this.aircraftInformationMessagesDictionary.ContainsKey(aircraftFlight)) + { + PictureBox pBox = (PictureBox)this.aircraftInformationMessagesDictionary[aircraftFlight]["picturebox"]; + pBox.Visible = false; + Label lbl = (Label)this.aircraftInformationMessagesDictionary[aircraftFlight]["label"]; + lbl.Visible = true; + } + } + } + + public void manageAircraftModSDictionary(string aircraftFlight, string modsLevel, string nextSectorName, string modsSucceed) + { + if (this.aircraftModSDictionary.ContainsKey(aircraftFlight)) + this.aircraftModSDictionary.Remove(aircraftFlight); + Dictionary modSDictionary = new Dictionary(); + 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 alarmDictionary = new Dictionary(); + 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 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 informationMessageDictionary = new Dictionary(); + informationMessageDictionary.Add("wordsNumber", wordsNumber); + informationMessageDictionary.Add("buildingmessage", true); + + Dictionary> messagePointsDictionary = new Dictionary>(); + for (int i = 0; i < wordsNumber; i++) + messagePointsDictionary[i] = new List(); + 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 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> messagePointsDictionary = (Dictionary>)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> dico = (Dictionary>)this.aircraftInformationMessagesDictionary[aircraftFlight]["messagepointsdictionary"]; + int xMin, xMax, yMin, yMax; + int genXMin = 1000000, genXMax = 0, genYMin = 1000000, genYMax = 0; + + foreach (List 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 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 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 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 tagMessageDictionary = new Dictionary(); + tagMessageDictionary.Add("strip", stripNumber); + + PictureBox emptyTagMessagePictureBox = createBitmapTagMessage(aircraftFlight, Config.tagMessageForeColor, Config.tagMessageBackColor, Config.tagMessageEmptyCompression, true); + emptyTagMessagePictureBox.Name = aircraftFlight; + emptyTagMessagePictureBox.BackColor = Config.emptyTagMessageBackColor; + emptyTagMessagePictureBox.Visible = false; + tagMessageDictionary.Add("picturebox", emptyTagMessagePictureBox); + + this.aircraftTagMessagesDictionary[aircraftFlight] = tagMessageDictionary; + + try + { + FormSimpleRadar.FormRadarInstance.sendIvyMessage("SetTag Flight=" + aircraftFlight + " Strip=" + stripNumber + " Confirmed"); + } + catch { } + } + } + else if (actionType == "update") + { + if (this.aircraftTagMessagesDictionary.ContainsKey(aircraftFlight)) + { + Dictionary 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> messagePointsDictionary = new Dictionary>(); + for (int i = 0; i < wordsNumber; i++) + messagePointsDictionary[i] = new List(); + 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(); + } + } + else if (actionType == "clear") + { + foreach (Dictionary 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 dico = new Dictionary(); + 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> messagePointsDictionary = (Dictionary>)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> dico = (Dictionary>)this.aircraftTagMessagesDictionary[aircraftFlight]["messagepointsdictionary"]; + int xMin, xMax, yMin, yMax; + int genXMin = 1000000, genXMax = 0, genYMin = 1000000, genYMax = 0; + + foreach (List 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 list in dico.Values) + { + for (int i = 0; i < (list.Count - 1); i += 2) + { + int x1 = (list[i] - genXMin) / compression; + int y1 = (list[i + 1] - genYMin) / compression; + if (i < (list.Count - 3)) + { + int x2 = (list[i + 2] - genXMin) / compression; + int y2 = (list[i + 3] - genYMin) / compression; + flag.SetPixel(x2, y2, foreColor); + using (Graphics g = Graphics.FromImage(flag)) + { + g.DrawLine(new Pen(foreColor), new Point(x1, y1), new Point(x2, y2)); + } + } + } + } + } + else + { + maxWidth = 100; + maxHeight = 50; + + flag = new Bitmap(maxWidth / compression, maxHeight / compression); + for (int x = 0; x < flag.Width; ++x) + for (int y = 0; y < flag.Height; ++y) + flag.SetPixel(x, y, backColor); + } + + PictureBox pBox = new PictureBox(); + pBox.Size = new Size(maxWidth / compression, maxHeight / compression); + pBox.Image = flag; + + return pBox; + } + + public void manageAircraftFlightLevelFilterList(string actionType, string aircraftFlight) + { + if (actionType == "add") + { + if (!(this.aflFilterAircraftList.Contains(aircraftFlight))) + this.aflFilterAircraftList.Add(aircraftFlight); + } + else if (actionType == "remove") + { + if (this.aflFilterAircraftList.Contains(aircraftFlight)) + this.aflFilterAircraftList.Remove(aircraftFlight); + } + else if (actionType == "clear") + { + this.aflFilterAircraftList.Clear(); + } + } + + public void manageFlightLevelFilter(string actionType, int aflValue, int aflRange) + { + if (actionType == "add") + { + this.aflFilterList.Clear(); + this.aflFilterList.Add(aflValue); + this.aflFilterList.Add(aflRange); + } + else if (actionType == "clear") + { + this.aflFilterList.Clear(); + } + } + + public void manageAircraftSeparationList(string actionType, string ac1FlightName, string ac1Route, string ac1Distance, string thicks1, string ac2FlightName, string ac2Route, string ac2Distance, string thicks2, string distance) + { + if (actionType == "add") + { + this.aircraftBeaconSeparationDictionary.Clear(); + this.aircraftBeaconSeparationDictionary.Add("aircraft1", ac1FlightName); + this.aircraftBeaconSeparationDictionary.Add("route1", ac1Route); + this.aircraftBeaconSeparationDictionary.Add("distance1", ac1Distance); + this.aircraftBeaconSeparationDictionary.Add("thicks1", thicks1); + this.aircraftBeaconSeparationDictionary.Add("aircraft2", ac2FlightName); + this.aircraftBeaconSeparationDictionary.Add("route2", ac2Route); + this.aircraftBeaconSeparationDictionary.Add("distance2", ac2Distance); + this.aircraftBeaconSeparationDictionary.Add("thicks2", thicks2); + this.aircraftBeaconSeparationDictionary.Add("distance", distance); + } + else if (actionType == "clear") + { + this.aircraftBeaconSeparationDictionary.Clear(); + } + } + + public void manageWarningAircraftList(string actionType, string acFlightName) + { + if (actionType == "add") + { + if (!(this.warningAircraftList.Contains(acFlightName))) + this.warningAircraftList.Add(acFlightName); + } + else if (actionType == "remove") + { + if (this.warningAircraftList.Contains(acFlightName)) + this.warningAircraftList.Remove(acFlightName); + } + else if (actionType == "change") + { + if (!(this.warningAircraftList.Contains(acFlightName))) + //L'avion n'a pas de Warning associé : on l'ajoute à la liste: + this.warningAircraftList.Add(acFlightName); + else + //L'avion est en warning : on le retire de la liste : + this.warningAircraftList.Remove(acFlightName); + } + else if (actionType == "clear") + { + this.warningAircraftList.Clear(); + } + } + + public void managePartAircraftList(string actionType, string acFlightName) + { + if (actionType == "add") + { + if (!(this.partAircraftList.Contains(acFlightName))) + this.partAircraftList.Add(acFlightName); + } + else if (actionType == "remove") + { + if (this.partAircraftList.Contains(acFlightName)) + this.partAircraftList.Remove(acFlightName); + } + else if (actionType == "change") + { + if (!(this.partAircraftList.Contains(acFlightName))) + //L'avion n'est pas particularisé : on le particularise : + this.partAircraftList.Add(acFlightName); + else + //L'avion est particularisé : on le départicularise + this.partAircraftList.Remove(acFlightName); + } + else if (actionType == "clear") + { + this.partAircraftList.Clear(); + } + } + + public Boolean IsBeaconInBeaconsArray(Beacon[] array, string value) + { + Boolean result = false; + for (int i = 0; i < array.Length; i++) + { + if (array[i].Code == value) + { + result = true; + break; + } + } + return result; + } + + private double PanAndZoomX(double x) + { + //return GetImageCoordinates((float)x, 0).X; + return GetScreenCoordinates((float)x, 0).X; + } + + private double PanAndZoomY(double y) + { + //return GetImageCoordinates(0, (float)y).Y; + return GetScreenCoordinates(0, (float)y).Y; + } + + PointF GetScreenCoordinates(float Xi, float Yi) + { + //return new PointF(Zoom * (Xi + PanX), Zoom * (Yi + PanY)); + return new PointF(Zoom * (Xi + PanX), -Zoom * (Yi + PanY)); + } + + PointF GetImageCoordinates(float Xs, float Ys) + { + //return new PointF(Xs / Zoom - PanX, (Ys) / Zoom - PanY); + return new PointF(Xs / Zoom - PanX, -Ys / Zoom - PanY); + } + + #endregion + + #region Getters and Setters + + public string SelectedAircraft + { + get { return selectedAircraft; } + set { selectedAircraft = value; } + } + + public int CurrentHour + { + get { return currentHour; } + set { currentHour = value; } + } + + public int CurrentMinute + { + get { return currentMinute; } + set { currentMinute = value; } + } + + public int CurrentSecond + { + get { return currentSecond; } + set { currentSecond = value; } + } + + #endregion + + public void updateView(System.Collections.Generic.Dictionary> listOfAircrafts) + { + this.Invalidate(); + } + + internal void AddNewPenDown(PointF pointF) + { + + PointF calibratedTopLeft = new PointF(0.090f, 0.1f); + PointF calibratedBottomRight = new PointF(0.865f, 0.91f); + + + //Scale the value the the corrected scale + float correctedX = MathTools.GenericScaleF(pointF.X, calibratedTopLeft.X, 100, calibratedBottomRight.X, this.Width - 100); + float correctedY = MathTools.GenericScaleF(pointF.Y, calibratedTopLeft.Y, 100, calibratedBottomRight.Y, this.Height - 100); + + AnotoPenDown = new PointF(correctedX, correctedY); + + } + } +} -- cgit v1.1