//#define jurgen
using System;
using System.Collections.Generic;
using System.Collections;
using System.ComponentModel;
using System.Drawing;
using System.Windows.Forms;
using System.Threading;
using System.Linq;
using MapGoogle;
using Telerik.WinControls.UI;
using Telerik.WinControls;
using Telerik.WinControls.UI.Docking;
using SafeMobileLib;
using Telerik.WinControls.Data;
using Dispatcher;
using Dispatcher.maptab.UIClasses;
using Safedispatch_4_0.Radio;
using Dispatcher.maptab;
using SafeMobileLib.Attributes;
using Dispatcher.Helpers;
using System.Device.Location;
using System.Threading.Tasks;
using System.Windows.Input;
using Telerik.WinControls.Enumerations;
using System.Timers;

namespace Safedispatch_4_0
{
    /// <summary>
    /// This class implements the live tab.</summary>
    /// <remarks>
    /// The live tab contains two areas, left and right. On the left side
    /// the vehicle selection is made, and on the right side information
    /// is displayed according to the criteria from the left</remarks>

    public partial class LiveTab : UserControl
    {
        /// <summary>
        /// The class constructor. </summary>
        ///     

        private MapHandler mapHandler;
        private DBalarmManager dbalm;
        public bool KillTimerActive = false;
        private String latname = "";
        private String lngname = "";
        private String altname = "";
        private String zonename = "";
        private String milesh, kmh, msg2, s18;
        public Boolean docLoad = false;
        private Int32 loadcnt = 0;
        public Int32 nrNavigatecnt = 0;
        public String updatecomand = "";
        public String getADDRcomand;
        public String deleteDsetcomand = "";
        public Boolean setdatasetBool = false;
        public volatile Boolean TableViewDataComplete = true;
        public volatile Boolean TableViewSortComplete = true;
        public volatile Boolean TableViewFinish = true;
        public volatile Boolean StreetViewOpened = false;
        public Boolean isFilterLoaded = false;
        public bool mapLoaded = false;
        public bool parseLiveGridEvents = true;
        public delegate void ProcessResponseFromMapInvokeCallBack(String url);

        private bool isFirstTime = true;

        private Thread threadForPeriodicThings;
        private DateTime lastMapRestart = DateTime.Now;

        public System.Timers.Timer changeCheckboxState = new System.Timers.Timer();

        public LiveTab(MainForm2 parentParam, String tabNameParam)
        {
            parent = parentParam;
            tabName = tabNameParam;
            this.Name = tabName;

            try
            {
                InitializeComponent();
            }
            catch (Exception ex)
            {
                SM.Debug("Error on Generate Live tab:" + ex.ToString());
                if (ex.ToString().Contains("0x800736B1"))
                {
                    ErrWithLink tmp = new ErrWithLink();
                    tmp.ShowDialog();
                }
            }

            // create the toolTip that will be displayed when the user sets a pattern
            // over the hint pictureBox
            toolTipHelp = new ToolTip();
            toolTipHelp.ToolTipTitle = "Live";
            toolTipHelp.AutoPopDelay = 0;
            toolTipHelp.InitialDelay = 0;
            toolTipHelp.ReshowDelay = 0;
            toolTipHelp.IsBalloon = false;
            toolTipHelp.ShowAlways = true;



            LiveGridColumn ctc = new LiveGridColumn("live");
            ctc.AllowResize = true;
            ctc.AllowGroup = true;
            ctc.Name = "live";
            ctc.FieldName = "live";
            ctc.HeaderText = "live";
            //ctc.AutoSizeMode = BestFitColumnMode.AllCells;
            ctc.HeaderTextAlignment = ContentAlignment.MiddleLeft;
            ctc.SortOrder = RadSortOrder.Ascending;

            this.gridVehicles.TableElement.GroupIndent = 15;
            this.gridVehicles.TableElement.RowHeight = 55;
            this.gridVehicles.TableElement.AutoSizeMode = RadAutoSizeMode.Auto;
            this.gridVehicles.AutoSizeRows = true;
            //this.gridVehicles.TableElement.RowHeight = 55;
            this.gridVehicles.Columns.Add(ctc);
            this.gridVehicles.Columns.Move(ctc.Index, 0);



            this.gridVehicles.GridViewElement.DrawBorder = false;
            this.gridVehicles.GridViewElement.GroupPanelElement.DrawBorder = false;


            LiveAddressGridColumn positionCell = new LiveAddressGridColumn("history");
            positionCell.AllowResize = true;
            positionCell.Name = "history";
            positionCell.FieldName = "history";
            //positionCell.MinWidth = 249;
            //positionCell.MaxWidth = 249;
            //positionCell.Width = 249;
            positionCell.HeaderText = "history";
            positionCell.AutoSizeMode = BestFitColumnMode.AllCells;
            positionCell.HeaderTextAlignment = ContentAlignment.MiddleLeft;
            positionCell.SortOrder = RadSortOrder.Ascending;

            this.tableVehiclesList.TableElement.RowHeight = 75;
            this.tableVehiclesList.Columns.Add(positionCell);
            this.tableVehiclesList.Columns.Move(positionCell.Index, 0);


            this.tableVehiclesList.GridViewElement.DrawBorder = false;
            this.tableVehiclesList.GridViewElement.GroupPanelElement.DrawBorder = false;


            // set the group comparer in order to display the custom groups in
            // desired order
            CustomGroupComparer gc = new CustomGroupComparer();
            this.gridVehicles.MasterTemplate.GroupComparer = gc;


            // change the icons for grouping and add them to the hashtable

            // add image to the dictionary if not exists
            if (!MainForm2.imagesDictionary.ContainsKey("l_filter_group"))
                MainForm2.imagesDictionary.Add("l_filter_group",
                    Utils.ChangeColor(global::Dispatcher.Properties.Resources.l_user_n, MainForm2.ButtonColor));

            // return the desired image
            pbGroup.Image = MainForm2.imagesDictionary["l_filter_group"];

            // add image to the dictionary if not exists
            if (!MainForm2.imagesDictionary.ContainsKey("l_filter_time"))
                MainForm2.imagesDictionary.Add("l_filter_time",
                    Utils.ChangeColor(global::Dispatcher.Properties.Resources.l_history_b, MainForm2.ButtonColor));

            // return the desired image
            pbGroupTime.Image = MainForm2.imagesDictionary["l_filter_time"];


            // add image to the dictionary if not exists
            if (!MainForm2.imagesDictionary.ContainsKey("l_filter_status"))
                MainForm2.imagesDictionary.Add("l_filter_status",
                    Utils.ChangeColor(global::Dispatcher.Properties.Resources.l_bullet_bl, MainForm2.ButtonColor));

            // return the desired image
            pbGroupStatusType.Image = MainForm2.imagesDictionary["l_filter_status"];


            pbFilter_Click(pbGroup, null);





            #region THEMING
            rlUnits.ForeColor = MainForm2.LabelColor;
            rbDisplay.ButtonElement.ButtonFillElement.BackColor = MainForm2.ButtonColor;
            pbFilter.Image = Utils.ChangeColor(global::Dispatcher.Properties.Resources.i_search, MainForm2.ButtonColor);
            #endregion

            #region LANGUAGE
            string s1 = MainForm2.returnLNGString("displayButton"),
            s2 = MainForm2.returnLNGString("cbselAll").ToUpper(),
            s3 = MainForm2.returnLNGString("selectionExpando"),
            s4 = MainForm2.returnLNGString("tabPage1"),
            s5 = MainForm2.returnLNGString("tabPage2"),
            s6 = MainForm2.returnLNGString("htableVehiclesListColumns1"),
            s7 = MainForm2.returnLNGString("htableVehiclesListColumns1"),
            s8 = MainForm2.returnLNGString("alarmsListColumns1"),
            s9 = MainForm2.returnLNGString("tableVehiclesListColumns2"),
            s10 = MainForm2.returnLNGString("tablevehiclesListColumns3"),
            s11 = MainForm2.returnLNGString("tableVehiclesListColumns4"),
            s12 = MainForm2.returnLNGString("lbGroup"),
            s13 = MainForm2.returnLNGString("btGetAddress"),
            s15 = MainForm2.returnLNGString("SMScomp"),
            s16 = MainForm2.returnLNGString("DI"),
            s17 = MainForm2.returnLNGString("DO"),
            s19 = MainForm2.returnLNGString("quickhist"),
            s20 = MainForm2.returnLNGString("snd"),
            s21 = MainForm2.returnLNGString("changeDO"),
            s22 = MainForm2.returnLNGString("radcheck");
            s18 = MainForm2.returnLNGString("allunits");
            langProgStat = MainForm2.returnLNGString("txProgStatLive");
            latname = MainForm2.returnLNGString("colum2");
            lngname = MainForm2.returnLNGString("colum3");
            altname = MainForm2.returnLNGString("altname");
            zonename = MainForm2.returnLNGString("zone");
            msg2 = MainForm2.returnLNGString("toomany");
            ckShowLand.Text = MainForm2.returnLNGString("prevland");
            ckShowZone.Text = MainForm2.returnLNGString("prevzone");
            txProgStatus.Text = MainForm2.returnLNGString("waitfor");

            kmh = MainForm2.returnLNGString("kmh");
            milesh = MainForm2.returnLNGString("milesh");

            rbDisplay.Text = s1;
            sel_desel.Text = s2;
            windowUnits.Text = s3;
            toolWindow2.Text = s4;
            rlUnits.Text = MainForm2.returnLNGString("GrpUnits");
            windowPositions.Text = MainForm2.returnLNGString("positions");
            gridVehicles.Columns["unitName"].HeaderText = s6;
            gridVehicles.Columns["status"].HeaderText = MainForm2.returnLNGString("SMSStatus");
            tableVehiclesList.Columns["VehName"].HeaderText = s7;
            tableVehiclesList.Columns["datetime"].HeaderText = s8;
            tableVehiclesList.Columns["address"].HeaderText = s9;
            if (MainForm2.isInMile) tableVehiclesList.Columns["speed"].HeaderText = s10 + " (" + milesh + ")";
            else tableVehiclesList.Columns["speed"].HeaderText = s10 + " (" + kmh + ")";
            tableVehiclesList.Columns["head"].HeaderText = s11;
            tableVehiclesList.Columns["di"].HeaderText = s16;
            tableVehiclesList.Columns["do"].HeaderText = s17;
            sendSMSToolStripMenuItem1.Text = s15;
            sendSMSToolStripMenuItem.Text = s15;
            basicHistoryToolStripMenuItem.Text = s19;
            sendPOLLToolStripMenuItem.Text = s20;
            changeDOStatusToolStripMenuItem.Text = s21;
            tableVehiclesList.Columns["lat"].HeaderText = latname;
            tableVehiclesList.Columns["lng"].HeaderText = lngname;
            tableVehiclesList.Columns["zone"].HeaderText = "";
            tableVehiclesList.Columns["Altitude"].HeaderText = altname;
            searchTextBox.NullText = MainForm2.returnLNGString("Typetosearchunit");
            rcbAutoRefresh.Text = MainForm2.returnLNGString("enableAutoRefresh");
            tableVehiclesList.Refresh();


            rcbMarkersLables.Text = MainForm2.returnLNGString("showMarkersLabels");
            ckShowZone.Text = MainForm2.returnLNGString("showGeofences");
            ckShowLand.Text = MainForm2.returnLNGString("showLandmarks");
            lbReportingInterval.Text = MainForm2.returnLNGString("maxNumberOfDisplayedUnits");
            #endregion

            /*
            // set disabled images for time and status group

            // add image to the dictionary if not exists
            if (!MainForm2.imagesDictionary.ContainsKey("l_filter_time_g"))
                MainForm2.imagesDictionary.Add("l_filter_time_g", Utils.MakeGrayscale3(global::Dispatcher.Properties.Resources.l_history_b, 0.5f));

            // return the desired image
            pbGroupTime.Image = MainForm2.imagesDictionary["l_filter_time_g"];


            // add image to the dictionary if not exists
            if (!MainForm2.imagesDictionary.ContainsKey("l_filter_status_g"))
                MainForm2.imagesDictionary.Add("l_filter_status_g", Utils.MakeGrayscale3(global::Dispatcher.Properties.Resources.l_bullet_bl, 0.5f));

            // return the desired image
            pbGroupStatusType.Image = MainForm2.imagesDictionary["l_filter_status_g"];

            */



            /*
            Font f = new Font("Segae UI", 11f, FontStyle.Regular);
            gridVehicles.TableElement.RowHeight = 32;
            gridVehicles.Font = f;
            //vehiclesList.*/

            threadForPeriodicThings = new Thread(delegate ()
            {
                int count = 0;
                while (MainForm2.isRunning)
                {
                    Thread.Sleep(100);
                    // check if a minute had passed
                    if (count++ > 60 * 10)
                    {
                        count = 0;
                        this.Invoke((MethodInvoker)delegate ()
                        {
                            // refresh the grid each minute
                            RefreshUnitTimerExpired();
                        });


                        // check at each minute if the map needs to be restarted due to long running 
                        if (MainForm2.cfg.MapRestart && (DateTime.Now - lastMapRestart).Minutes >= MainForm2.cfg.MapRestartMinutes)
                        {
                            this.Invoke((MethodInvoker)delegate ()
                            {
                                Utils.WriteLine($"Map Handler will restart because last restart was @ {lastMapRestart.ToString()}", ConsoleColor.Yellow);
                                lastMapRestart = DateTime.Now;
                                mapHandler?.RestartMap();
                            });
                        }
                    }
                }

            });
            threadForPeriodicThings.Start();

            // show landmarks and geofences is needed
            foreach (Control x in this.windowUnits.Controls)
            {
                if (x is PictureBox)
                {
                    string key = this.Name + "_" + "PictureBox_Filter";
                    if (MainForm2.HashVal.Contains(key) && ((PictureBox)x).Name == MainForm2.HashVal[key].ToString())
                        pbFilter_Click(((PictureBox)x), null);
                }
            }
            VisualSettings.loadUserVisualSettings(tabName, this.windowUnits, MainForm2.HashVal);
            isFilterLoaded = true;




            if (MainForm2.HashVal.ContainsKey("showMarkersLables"))
                MainForm2.Displaywithname = Convert.ToBoolean(MainForm2.HashVal["showMarkersLables"]);

            String safemobileDirPath = System.Windows.Forms.Application.StartupPath.Replace('\\', '/').Replace(" ", "%20");
            safemobileDirPath = safemobileDirPath.Replace("#", "%23");
            String mapUrl = "file:///" + safemobileDirPath + "/resource/" + MainForm2.MapHtmlName;

            LatLngZoom centerPosition = new LatLngZoom() { Lat = MainForm2.LatStart, Lng = MainForm2.LngStart, ZoomLevel = MainForm2.ZoomStart };
            
            mapHandler = new MapHandler(mapUrl)
            {
                MapHashName = tabName,
                HasLabels = rcbMarkersLables.Checked,
                IsMetric = !MainForm2.isInMile,
                ConsoleVisible = MainForm2.MapDebugConsole,
                IconTheme = MainForm2.iconThemeType,
                IconType = MainForm2.iconType,
                CenterPosition = centerPosition,
                HideTimeInactiveUnits = MainForm2.HideInactiveUnitsCheck,
                HideNonEmergUnits = MainForm2.emergOnlyCheck,
                InactiveTimeoutMinutes = MainForm2.Livelastmin,
                IsNeverReportedWarning = false,
                MaxDisplayedNrOfUnits = 2000
            };

            mapHandler.Dock = DockStyle.Fill;

            // register for event 
            ckShowZone.ToggleStateChanged += ckShowZone_ToggleStateChanged;
            ckShowLand.ToggleStateChanged += ckShowLand_ToggleStateChanged;



            #region MAP HANDLERS
            mapHandler.OnMapLoaded += delegate ()
            {

                docLoad = true; 

                // set 
                if (isFirstTime)
                {

                    List<Vehicle> vehicles = (MainForm2.vehicleHT.Values.Cast<Vehicle>().ToList());
                    foreach (Vehicle veh in vehicles)
                    {
                        try
                        {
                            String imei = veh.IMEI;
                            bool isDisplayed = VisualSettings.IsDisplayedInLiveTab(veh.sipID, tabName);

                            if (!MainForm2.VehIMEIHash.ContainsKey(imei))
                                continue;


                            ((MapElement)((Vehicle)MainForm2.vehicleHT[(String)MainForm2.VehIMEIHash[imei + ""]]).MapsHT[tabName]).itemCheck = isDisplayed;

                            // check and create emergency icon if in emergency
                            if (veh.is_emergency)
                                IconHelper.CheckCreateEmergencyIcon(veh.IconID);

                            if (isDisplayed)
                            {
                                ((MapElement)((Vehicle)MainForm2.vehicleHT[(String)MainForm2.VehIMEIHash[imei + ""]]).MapsHT[tabName]).ActivatePushPin();
                            }
                            else
                                ((MapElement)((Vehicle)MainForm2.vehicleHT[(String)MainForm2.VehIMEIHash[imei + ""]]).MapsHT[tabName]).DeactivatePushpin();

                            (((Vehicle)MainForm2.vehicleHT[(String)MainForm2.VehIMEIHash[imei + ""]])).is_displayed = isDisplayed;
                        }
                        catch (Exception ex)
                        {
                            Utils.WriteLine("Exception ex: " + ex.ToString(), ConsoleColor.Red);
                        }
                    }

                    isFirstTime = false;
                }


                // detect which units needs to be added on the map from last session
                List<Vehicle> toDisplayVehicles = new List<Vehicle>();

                List<Vehicle> htList = (MainForm2.vehicleHT.Values.Cast<Vehicle>().ToList());
                IEnumerable<IGrouping<int, Vehicle>> query = htList.GroupBy(d => d.group.Id, d => d);



                // Iterate over each IGrouping in the collection.
                foreach (IGrouping<int, Vehicle> group in query)
                {

                    String groupName = group.FirstOrDefault(d => d.sipID > 0).group.Name;
                    int groupUnits = group.ToList().Count;
                    int groupDisplayedUnits = group.Count(d => ((MapElement)d.MapsHT[tabName]).itemCheck);

                    // see if all the units are checked and raise the event for updating the group checked event
                    if (groupUnits == groupDisplayedUnits)
                    {
                        // Print the key value of the IGrouping.
                        Utils.WriteLine($"{groupName} has {groupUnits} units [{groupDisplayedUnits} displayed]");

                        for (int i = 0; i < gridVehicles.Groups.Count; i++)
                        {
                            if (gridVehicles.Groups[i].Key.Equals(groupName))
                            {
                                // update the grid units on left map
                                IEnumerable<DataforVehList> resLiveGrid = ListforVehList.Select(d => d).Where(d => (group.Select(w => w.IMEI)).Contains(d.RadioId));
                                foreach (DataforVehList ve in resLiveGrid)
                                {
                                    ve.OnMap = true;
                                    ve.NrOfUpdates += 1;
                                }

                                if (groupsHeadersByString.ContainsKey(groupName))
                                    groupsHeadersByString[groupName].checkbox.Checked = true;

                                mapHandler.AddGroup(groupName, group.ToList(), false);
                                //groupsHeadersByString[groupName].checkbox.PerformClick();
                                //GridViewInfo v = gridVehicles.Groups[i].GroupRow.ViewInfo.CurrentRow.ViewInfo; // as CustomGroupHeaderCell;
                                // GridGroupContentCellElement
                                //GroupCheckBox_StateChanged(mapHandler, new GRPEventArgs(i, true));
                            }
                        }
                    }
                    else if (groupUnits - groupDisplayedUnits > 0)
                        toDisplayVehicles.AddRange(group.Select(d => d).Where(d => ((MapElement)d.MapsHT[tabName]).itemCheck).ToList());
                }

                // display the units that are checked and not a part of a group
                mapHandler.AddVehicles(toDisplayVehicles, true);


                // update the grid units on left map
                IEnumerable<DataforVehList> result = ListforVehList.Select(d => d).Where(d => (toDisplayVehicles.Select(w => w.IMEI)).Contains(d.RadioId));
                foreach (DataforVehList ve in result)
                {
                    ve.OnMap = true;
                    ve.NrOfUpdates += 1;
                }

                // flag that the map had finished loading
                mapLoaded = true;


                this.Invoke((MethodInvoker)delegate ()
                {

                    if (WaitWindow != null)
                        WaitWindow.Close();

                    // show or hide geofences
                    if (ckShowZone.Checked)
                        ckShowZone_ToggleStateChanged(ckShowZone, new StateChangedEventArgs(ckShowLand.Checked
                            ? Telerik.WinControls.Enumerations.ToggleState.On : Telerik.WinControls.Enumerations.ToggleState.Off));


                    // !!!!!!!!!!!!!!!!! THIS MUST BE THE LAST METHOD IN THE LOADED EVENT !!!!!!!!!!!!!!!! 
                    // show or hide landmarks
                    if (ckShowLand.Checked)
                        ckShowLand_ToggleStateChanged(ckShowZone, new StateChangedEventArgs(ckShowZone.Checked
                        ? Telerik.WinControls.Enumerations.ToggleState.On : Telerik.WinControls.Enumerations.ToggleState.Off));

                    // Iterate over each IGrouping in the collection.
                    foreach (IGrouping<int, Vehicle> group in query)
                        // update the group header
                        onGroupDisplayedUnitsChangedHandler(group.FirstOrDefault(d => d.sipID > 0).group.Name);
                });


            };

            mapHandler.OnNearestRequest += delegate (int x, int y, double lat, double lng)
            {
                OnNearestMapRequest(x, y, lat, lng);
            };

            mapHandler.OnUnitDisplayReq += delegate (String unitName)
            {
                // update the grid units on left map
                IEnumerable<DataforVehList> result = ListforVehList.Where(d => d.UnitName.Equals(unitName));
                foreach (DataforVehList ve in result)
                {
                    if (!ve.OnMap)
                    {
                        ve.OnMap = true;
                        ve.NrOfUpdates += 1;
                        ((MapElement)((Vehicle)MainForm2.vehicleHT[ve.UnitName]).MapsHT[tabName]).itemCheck = true;
                        ((MapElement)((Vehicle)MainForm2.vehicleHT[ve.UnitName]).MapsHT[tabName]).ActivatePushPin();

                        VisualSettings.SetDisplayedInLiveTab(ve.SipId, true, tabName);

                        List<Vehicle> vehs = (MainForm2.vehicleHT.Values.Cast<Vehicle>().ToList()).Where(d => d.busName.Equals(unitName)).ToList();

                        if (vehs.Count > 0)
                            mapHandler.AddVehicles(new List<Vehicle>() { vehs[0] }, false);
                    }
                }


            };


            mapHandler.OnNeverReportedWarning += delegate (int numberOfUnits)
            {
                this.Invoke((MethodInvoker)delegate ()
                {
                    //displayNeverReportedWarning(numberOfUnits);
                });
            };


            mapHandler.OnInactiveUnitsWarning += delegate (int numberOfUnits)
            {
                this.Invoke((MethodInvoker)delegate ()
                {
                    //displayInactiveMinutesWarning(numberOfUnits);
                });
            };

            mapHandler.OnGeofencesDisplayed += delegate (int geofencesCount)
            {
                this.Invoke((MethodInvoker)delegate ()
                {
                    parent.DisplayToast(MainForm2.returnLNGString("geofenceDisplayed"),
                    "<html><b>" + geofencesCount + "  " + MainForm2.returnLNGString("geofences") + "  </b> " + MainForm2.returnLNGString("mapdisp") + " </html>");
                });
            };

            mapHandler.OnLandmarksDisplayed += delegate (int landmarksCount)
            {
                this.Invoke((MethodInvoker)delegate ()
                {
                    parent.DisplayToast(MainForm2.returnLNGString("landDisp"),
                     string.Format(MainForm2.returnLNGString("landHTML"), landmarksCount));
                });
            };


            mapHandler.OnMapDead += delegate ()
            {
                this.Invoke((MethodInvoker)delegate ()
                {
                    // parent.DisplayToast("MAP DEAD !!!!!!!!!!!", "It's dead JIM");
                    // restart the map
                    //mapHandler.RestartMap();
                });
            };

            mapHandler.OnMapProgressChanged += delegate (int currentStep, int totalSteps, String message)
            {
                this.Invoke((MethodInvoker)delegate ()
               {
                   try
                   {
                       mapLoadingPanel.Visible = !message.Equals("done");
                       mapLoadingBar.Maximum = totalSteps;
                       mapLoadingBar.Value1 = message.Equals("done") ? totalSteps : currentStep;
                       mapLoadingBar.Text = currentStep + " out of " + totalSteps;
                       mapLoadingMessage.Text = message;
                   }
                   catch (Exception ex)
                   {
                       Utils.WriteLine("Exception  " + ex.ToString(), ConsoleColor.Red);
                   }
               });
            };

            mapHandler.OnTextMessageRequest += delegate (String unitName, String message)
            {
                string imei = ((Vehicle)MainForm2.vehicleHT[unitName]).IMEI;
                ((Vehicle)MainForm2.vehicleHT[unitName]).CheckPositionInSystem();
                string GatewayAndRadioID = ((Vehicle)MainForm2.vehicleHT[unitName]).GwandRadioID;


                // store if the text message was trimmed or not
                bool isTrimmed = false;

                // check if the message is larger than the maximum number of characters accepted 
                // by the radio system
                int gwType = (int)GatewayType.Unknown;
                if (MainForm2.radioGwHT[GatewayAndRadioID] != null)
                {

                    gwType = ((RadioGateway)MainForm2.radioGwHT[GatewayAndRadioID]).Type;
                }

                if (message.Length > SmsUtils.GetMaxNumberOfCharacters(gwType))
                {
                    isTrimmed = true;
                    message = message.Substring(0, SmsUtils.GetMaxNumberOfCharacters(gwType));
                }

                int sc_id = ((Vehicle)MainForm2.vehicleHT[unitName]).sc_id;
                int sched_time = (int)DateTime.Now.ToUniversalTime().DateTo70Format();

                //((Vehicle)MainForm2.vehicleHT[unitName]).CheckPositionInSystem();
                ////String Totrans = "#142#" + ((Vehicle)MainForm2.vehicleHT[unitName]).GwandRadioID + "." + imei + "#" + textMessage + "#" + sched_time + "#";
                //String Totrans = "#142#" + ((Vehicle)MainForm2.vehicleHT[unitName]).GwandRadioID + "." + imei + "#" + textMessage + "#" + sched_time + "#" + MainForm2.userIDX + "#";

                //parent.DisplayToast(MainForm2.returnLNGString("txtMsgTo") + " " + unitName, 
                //    (isTrimmed ? (MainForm2.returnLNGString("trimmed") + " ") : "") +
                //    string.Format(MainForm2.returnLNGString("MsHTML"), textMessage));
                //parent.Send_UDP_cmd(Totrans, 0, 0);
                parent.SendSmsOnMBus(message, sc_id, sched_time);
            };


            mapHandler.OnPTTButtonPressChanged += delegate (String unitName, bool isPressed)
            {
                string imei = ((Vehicle)MainForm2.vehicleHT[unitName]).IMEI;

                bool canMakeSipCalls = ((Vehicle)MainForm2.vehicleHT[unitName]).canMakeSipCalls;
                int sipID = ((Vehicle)MainForm2.vehicleHT[unitName]).sipID;

                if (MainForm2.VoiceTabStarted)
                {
                    if (isPressed)
                    {
                        parent.RadioTabControl.sendPTT(
                             new Subscriber()
                             {
                                 DispatcherName = unitName,
                                 SubscriberType = SubscriberType.SUBSCRIBER,
                                 ImageKey = "i_classic_bus_02",
                                 IconFilePath = IconHelper.GetIconPathForUnit(unitName),
                                 Sc_id = 0,
                                 Imei = imei,
                                 Gw_and_radioID = parent.RadioTabControl.Valid_GwID_and_RadioID,
                                 IP = String.Format("224.10.{0}", parent.RadioTabControl.Valid_GwID_and_RadioID),
                                 Favorite = false,
                                 canMakeSipCalls = canMakeSipCalls,
                                 SipID = sipID
                             }, true
                            );
                    }
                    else
                    {
                        parent.RadioTabControl.StopPTT(
                                        new Subscriber()
                                        {
                                            DispatcherName = unitName,
                                            SubscriberType = SubscriberType.SUBSCRIBER,
                                            ImageKey = "i_classic_bus_02",
                                            IconFilePath = IconHelper.GetIconPathForUnit(unitName),
                                            Sc_id = 0,
                                            Imei = imei,
                                            Gw_and_radioID = parent.RadioTabControl.Valid_GwID_and_RadioID,
                                            IP = String.Format("224.10.{0}", parent.RadioTabControl.Valid_GwID_and_RadioID),
                                            Favorite = false,
                                            canMakeSipCalls = canMakeSipCalls,
                                            SipID = sipID
                                        }
                                       );
                    }
                }
                else
                {
                    // Initializez vocea
                    parent.CheckTabs(track_type.RADIO, parent.GetTabNewRadio);
                    parent_OnCallStatusChanged(unitName, false, false);

                }
            };


            mapHandler.OnStreetViewStateChanged += delegate (bool isOpened)
            {
                StreetViewOpened = isOpened;
            };
            #endregion


            mapGoogles = new CefSharpChromiumWebBrowser(mapUrl);

            LiveMapPanel.Controls.Add(mapHandler);


            if (MainForm2.NOAddress)
                tableVehiclesList.Columns["address"].IsVisible = false;
            //mapGoogles.AllowFileAccessFromFileURLs = true;

            try
            {
                if (MainForm2.is24hours)
                {
                    if (MainForm2.DayFirst)
                        ((GridViewDateTimeColumn)tableVehiclesList.Columns["datetime"]).FormatString = "{0:dd/MM/yyyy HH:mm:ss}";
                    else
                        ((GridViewDateTimeColumn)tableVehiclesList.Columns["datetime"]).FormatString = "{0:MM/dd/yyyy HH:mm:ss}";
                }
                else
                {
                    if (MainForm2.DayFirst)
                        ((GridViewDateTimeColumn)tableVehiclesList.Columns["datetime"]).FormatString = "{0:dd/MM/yyyy hh:mm:ss tt}";
                    else
                        ((GridViewDateTimeColumn)tableVehiclesList.Columns["datetime"]).FormatString = "{0:MM/dd/yyyy hh:mm:ss tt}";
                }
            }
            catch (Exception ex)
            {
                SM.Debug("Error on gridview DateFormat:" + ex.ToString());
            }

            //this.SelectionLive.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(191)))), ((int)(((byte)(219)))), ((int)(((byte)(255)))));

            LiveWaitingBar.ThemeClassName = "Telerik.WinControls.UI.RadWaitingBar";
            LiveWaitingBar.ThemeName = "Telerik";
            LiveWaitingBar.Visible = false;
            txProgStatus.Visible = false;
            LivePanel.Visible = false;
            Console.WriteLine("Panel visibil false 2");

            this.DrawMap();

            SM.Debug("Start timer");
            TimerLoad3Sec.Enabled = true;
            TimerLoad3Sec.Start();
            SM.Debug("Da e pornit timer");

            populateVehiclesList(vehicleListNames);
            //ChangeIcons(vehicleListNames);


            GetPositionForPlace = false;
            GetPositionForStart = false;
            GetPositionForZones = false;


            if (MainForm2.MotoTURBO)
            {
                sendPOLLToolStripMenuItem.Visibility = Telerik.WinControls.ElementVisibility.Hidden;
                changeDOStatusToolStripMenuItem.Visibility = Telerik.WinControls.ElementVisibility.Hidden;
            }
            else sendSMSToolStripMenuItem1.Visibility = Telerik.WinControls.ElementVisibility.Hidden;

            windowUnits.ToolCaptionButtons = Telerik.WinControls.UI.Docking.ToolStripCaptionButtons.AutoHide | Telerik.WinControls.UI.Docking.ToolStripCaptionButtons.SystemMenu;
            //toolWindow1.ToolCaptionButtons = Telerik.WinControls.UI.Docking.ToolStripCaptionButtons.SystemMenu;
            windowUnits.DocumentButtons &= ~Telerik.WinControls.UI.Docking.DocumentStripButtons.Close;
            windowUnits.AllowedDockState = AllowedDockState.Docked | AllowedDockState.AutoHide;
            toolWindow2.ToolCaptionButtons = Telerik.WinControls.UI.Docking.ToolStripCaptionButtons.AutoHide | Telerik.WinControls.UI.Docking.ToolStripCaptionButtons.SystemMenu;
            toolWindow2.DocumentButtons &= ~Telerik.WinControls.UI.Docking.DocumentStripButtons.Close;
            //toolWindow3.ToolCaptionButtons = Telerik.WinControls.UI.Docking.ToolStripCaptionButtons.AutoHide | Telerik.WinControls.UI.Docking.ToolStripCaptionButtons.SystemMenu;
            //toolWindow3.DocumentButtons &= ~Telerik.WinControls.UI.Docking.DocumentStripButtons.Close;
            //toolWindow3.AllowedDockState = AllowedDockState.Docked | AllowedDockState.AutoHide;
            ContextMenuService menuService = this.radDock1.GetService<ContextMenuService>();
            menuService.ContextMenuDisplaying += menuService_ContextMenuDisplaying;
            //this disables the context menu
            menuService.AllowActiveWindowListContextMenu = false;
            menuService.AllowDocumentContextMenu = false;
            menuService.AllowToolContextMenu = false;

            switch (MainForm2.radioType)
            {
                case RADIOTYPE.HYT:
                    radDock1.BackColor = MainForm2.HyteraColor;
                    LivePanel.BackColor = MainForm2.HyteraColor;
                    //radSplitContainer1.BackColor = MainForm2.HyteraColor;
                    documentTabStrip1.BackColor = MainForm2.HyteraColor;
                    break;
                case RADIOTYPE.HARRIS:
                    radDock1.BackColor = MainForm2.HarrisColor;
                    LivePanel.BackColor = MainForm2.HarrisColor;
                    //radSplitContainer1.BackColor = MainForm2.HarrisColor;
                    documentTabStrip1.BackColor = MainForm2.HarrisColor;
                    break;
                case RADIOTYPE.ATLAS:
                    radDock1.BackColor = MainForm2.HarrisColor;
                    LivePanel.BackColor = MainForm2.HarrisColor;
                    //radSplitContainer1.BackColor = MainForm2.HarrisColor;
                    documentTabStrip1.BackColor = MainForm2.HarrisColor;
                    break;
                case RADIOTYPE.SIMOCO:
                    //we don't need this
                    break;
                case RADIOTYPE.EXCERA:
                    //we don't need this
                    break;
            }

            dbalm = new DBalarmManager(MainForm2.cfg.DB_IP, MainForm2.cfg.DB_schema, MainForm2.cfg.DB_user, MainForm2.cfg.DB_passwd, MainForm2.cfg.DB_port);
            //vehiclesList.TableElement.RowHeight = 32;
#if jurgen
            ((GridViewCheckBoxColumn)vehiclesList.Columns[3]).ReadOnly = true;
#endif
            //RadMessageBox.Show("Please wait for map loading... \n This window will disapper after 10 seconds", "Wait for loading", MessageBoxButtons.OK);



            rddlGroupingType.Items.Clear();
            //RadListDataItem item = new RadListDataItem(MainForm2.returnLNGString("")) { Tag = "categories" };
            rddlGroupingType.Items.Add(new RadListDataItem(MainForm2.returnLNGString("liveGroupingCategories")) { Tag = "categories" });

            if (MainForm2.HasVoice)
                rddlGroupingType.Items.Add(new RadListDataItem(MainForm2.returnLNGString("liveGroupingRadioGateway")) { Tag = "radiogateway" });


            String currentGroupingType = VisualSettings.GetGroupingTypeInLiveTab(tabName);
            bool found = false;
            foreach (RadListDataItem item in rddlGroupingType.Items)
            {
                if (currentGroupingType == null)
                {
                    item.Selected = true;
                    VisualSettings.SetGroupingTypeInLiveTab(item.Tag + "", tabName);
                    break;
                }
                else if (item.Tag.ToString().Equals(currentGroupingType))
                {
                    item.Selected = true;
                    found = true;
                }
            }

            rddlGroupingType.SelectedIndexChanged += GroupingType_SelectedIndexChanged;

            if (!found)
                rddlGroupingType.SelectedIndex = 0;

            GroupLiveGrid(rddlGroupingType.SelectedItem.Tag.ToString().Equals("categories") ? GroupType.GROUPNAME : GroupType.RADIOGATEWAY, false);

            chkWebsocketConnected.Visible = false;
            if (MainForm2.hasDBAccess)
            {
                chkWebsocketConnected.Visible = true;
                OnWebSocketStatusChanged(ToggleState.Indeterminate);
                changeCheckboxState.Elapsed += new ElapsedEventHandler(ChangeCheckboxState);
                changeCheckboxState.Interval = 10000;
                changeCheckboxState.Enabled = true;
            }
        }

        private void GroupingType_SelectedIndexChanged(object sender, Telerik.WinControls.UI.Data.PositionChangedEventArgs e)
        {
            // skip the case when the position is out of bounds
            if (!(e.Position >= 0 && e.Position < rddlGroupingType.Items.Count))
                return;

            RadListDataItem selectedItem = rddlGroupingType.Items[e.Position];
            GroupLiveGrid(selectedItem.Tag.ToString().Equals("categories") ? GroupType.GROUPNAME : GroupType.RADIOGATEWAY, false);

            VisualSettings.SetGroupingTypeInLiveTab(selectedItem.Tag + "", tabName);

        }



        public void updateGwAndRagioGatewayForSubscriber(String radioID, String gwId, String radioGwId)
        {
            //Utils.WriteLine("updateGwAndRagioGatewayForSubscriber " + radioID, ConsoleColor.DarkMagenta);
            gridVehicles.BeginEdit();
            foreach (DataforVehList item in ListforVehList)
            {
                if (item == null)
                    continue;

                if (item.RadioId.Equals(radioID))
                {

                    RadioGateway rg = MainForm2.myGatewaylist.Find(d => (gwId + "." + radioGwId).Equals(d.Gw_id + "." + d.Id));
                    item.RadioGateway = rg != null ? rg.Name : MainForm2.returnLNGString("Unassigned");
                    item.NrOfUpdates++;
                }
            }

            gridVehicles.EndEdit();
        }


        private void rlUnits_Click(object sender, EventArgs e)
        {
            if (mapHandler == null)
                return;

            ;// OnNearestMapRequest(6, 8, 44.4335723, 26.1119778);
            if (Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl))
                mapHandler.ConsoleVisible = !mapHandler.ConsoleVisible;
        }


        private void OnNearestMapRequest(int x, int y, double lat, double lng)
        {
            int numberOfNearestResponse = 10;
            List<Vehicle> allVehicles = (MainForm2.vehicleHT.Values.Cast<Vehicle>().ToList());

            var coord = new GeoCoordinate(lat, lng);

            // get nearest vehicles coordinates 
            var nearestCoordinatesForUnitsWithGpsOn = (allVehicles.Where(d => d.actual_status == Status_for_tab.GPS_ON))
                .Select(w => new GeoCoordinate(w.LAT, w.LNG, w.sipID))
                                   .OrderBy(w => w.GetDistanceTo(coord)).Take(numberOfNearestResponse).ToList();

            // get more units if the required number is not filled by those with gps on
            if(nearestCoordinatesForUnitsWithGpsOn.Count < numberOfNearestResponse)
            {
                var nearestCoordinatesForUnitsWithGpsNotOn = (allVehicles.Where(d => d.actual_status != Status_for_tab.GPS_ON))
                .Select(w => new GeoCoordinate(w.LAT, w.LNG, w.sipID))
                                   .OrderBy(w => w.GetDistanceTo(coord)).Take(numberOfNearestResponse).ToList();


                // add number of units from those with GPS not on so it will provide with the required number
                nearestCoordinatesForUnitsWithGpsOn.AddRange(nearestCoordinatesForUnitsWithGpsNotOn
                    .Take(numberOfNearestResponse - nearestCoordinatesForUnitsWithGpsOn.Count));
            }

            // get only the sip Ids for the nearest vehicles by coordinates (ordered by distance)
            var nearestCoordinatesSipIds = nearestCoordinatesForUnitsWithGpsOn.Select(d => d.Altitude).ToList();

            // get the vehicles associated with those sip Ids
            var nearestVehicles = allVehicles.Where(w => (nearestCoordinatesForUnitsWithGpsOn.Select(d => d.Altitude).Contains(w.sipID)))
                .OrderBy(w => (nearestCoordinatesSipIds.IndexOf(w.sipID))).ToList();

            //TODO get transparent icons for those that are not displayed
            foreach(Vehicle veh in nearestVehicles)
            {
                if (!((MapElement)veh.MapsHT[tabName]).itemCheck)
                    IconHelper.CheckCreateTransparentIcon(veh.IconID);
            }
            // #######################################

            // #######################################

            // send response to the map
            mapHandler.NearestUnitResponse(x, y, lat, lng, nearestVehicles);
        }


        private void onGroupDisplayedUnitsChangedHandler(String groupName)
        {
            List<Vehicle> groupVehicles = (MainForm2.vehicleHT.Values.Cast<Vehicle>().ToList()).Where(x => x.group.Name.Equals(groupName)).ToList();

            // count the number of displayed units
            int displayVehiclesCount = groupVehicles.Select(d => d).Where(d => ((MapElement)d.MapsHT[tabName]).itemCheck).Count();

            // change the header name
            ChangeGroupHeaderDisplayedUnits(groupName, displayVehiclesCount, groupVehicles.Count);

            // display abote the live grid the number of displayed units
            UpdateUnitsDisplayedNumberLabel();
        }



        private void ChangeGroupHeaderDisplayedUnits(String groupName, int displayedNumberInGroup, int totalNumberInGroup)
        {

            for(int i=0; i < gridVehicles.Groups.Count; i++)
            {
                if (gridVehicles.Groups[i].Key.Equals(groupName))
                {
                    gridVehicles.Groups[i].Header = groupName + " [" + displayedNumberInGroup + MainForm2.returnLNGString("of") + totalNumberInGroup + "]";
                    gridVehicles.Groups[i].GroupRow.HeaderText = gridVehicles.Groups[i].Header;
                    
                    /*
                    vehiclesList_GroupSummaryEvaluate(gridVehicles, new GroupSummaryEvaluationEventArgs(gridVehicles.Groups[i], gridVehicles.Groups[i],
                        gridVehicles.Groups[i].Header, null, null, null));
                   */
                }

            }
            /*
            for (int contor = 0; contor < gridVehicles.ChildRows.Count; contor++)
            {
                GridViewGroupRowInfo row = gridVehicles.ChildRows[contor] as GridViewGroupRowInfo;
                if (row != null && row.Group.Key.Equals(groupName))
                {
                    row.Group.Header = groupName + " [" + displayedNumberInGroup + " of " + totalNumberInGroup + "]";
                    

                }
            }*/
            
        }

        private String getGroupHeaderCount(String groupName)
        {
            List<Vehicle> groupVehicles = (MainForm2.vehicleHT.Values.Cast<Vehicle>().ToList()).Where(x => x.group.Name.Equals(groupName)).ToList();

            // count the number of displayed units
            int displayVehiclesCount = groupVehicles.Select(d => d).Where(d => !((MapElement)d.MapsHT[tabName]).itemCheck).Count();

            return " [" + displayVehiclesCount + " of " + groupVehicles.Count + "]";
        }



        private void displayInactiveMinutesWarning(int numberOfUnits)
        {
            parent.DisplayToast(MainForm2.returnLNGString("inactiveMinutes"), 
                String.Format(MainForm2.returnLNGString("HTMLinactiveMinutesUnits"), numberOfUnits, MainForm2.Livelastmin));
        }

        private void displayNeverReportedWarning(int numberOfUnits)
        {
            parent.DisplayToast(MainForm2.returnLNGString("noGPS"), 
                String.Format(MainForm2.returnLNGString("HTMLNoGPSMap"), numberOfUnits));
        }

        private int getNumberOfDisplayedUsers()
        {
            return (MainForm2.vehicleHT.Values.Cast<Vehicle>().ToList()).Where(d => ((MapElement)d.MapsHT[tabName]).itemCheck).Count();
        }

        private void UpdateUnitsDisplayedNumberLabel()
        {
            rlUnits.Text = String.Format(MainForm2.returnLNGString("unitsDisplayed"), getNumberOfDisplayedUsers());
        }


        private void menuService_ContextMenuDisplaying(object sender, ContextMenuDisplayingEventArgs e)
        {
            try
            {
                if (e.MenuType == ContextMenuType.DockWindow &&
                    e.DockWindow.DockTabStrip is DocumentTabStrip)
                {
                    for (int i = 0; i < e.MenuItems.Count; i++)
                    {
                        RadMenuItemBase menuItem = e.MenuItems[i];
                        if (menuItem.Name == "CloseWindow" ||
                            menuItem.Name == "CloseAllButThis" ||
                            menuItem.Name == "CloseAll" ||
                            menuItem.Name == "Floating" ||
                            menuItem.Name == "Docked" ||
                            menuItem.Name == "Hidden" ||
                            menuItem is RadMenuSeparatorItem)
                        {
                            menuItem.Visibility = Telerik.WinControls.ElementVisibility.Collapsed;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                SM.Debug("ExLive1:" + ex.ToString());
            }
        }

        /// <summary>
        /// Handler for when a GPS Position was received for a particular unit
        /// </summary>
        /// <param name="unitName">Unit name for which the GPS position was received</param>
        /// <param name="isFirstPositionForUnit">Flag if this is the first position for that unit</param>
        public void onGPSPositionReceivedHandler(String unitName, bool isFirstPositionForUnit)
        {
            try
            {
                
                //Utils.WriteLine("Sending GPS to the mapHandler for " + unitName);
                mapHandler.GPSUpdate((Vehicle)MainForm2.vehicleHT[unitName]);

                this.Invoke((MethodInvoker)delegate ()
                {
                    onPositionListUnitChanged(unitName);

                    onUnitPositionOrStateChanged(unitName);

                    // if this is the first position in history for this unit  perform an update to display the unit on map
                    if (isFirstPositionForUnit)
                    {
                        ComputeCheckedVehicles(false);
                    }
                });
            }
            catch (Exception ex)
            {
                SM.Debug("Unable to move unit on tab " + tabName + " ex:" + ex.ToString());
            }
        }

      
        private Hashtable CheckedGroup = new Hashtable();
        private volatile Hashtable CheckedGroupTmp = new Hashtable();
        /// <summary>
        ///populates the list of vehicles from the left part of the tab </summary>
        /// <param name="listOfVehicles">an array of strings containing the vehicles names</param>
        public volatile List<DataforVehList> ListforVehList = new List<DataforVehList>();
        volatile String GroupNameforgrid = "";
        volatile Image Imageforgrid = null;
        volatile String Statusforgrid = "";
        volatile Int32 EmergStat = 0;





        private List<DataforVehList> getVehiclesGridList()
        {
            List<DataforVehList> list = new List<DataforVehList>();

            List<Vehicle> vehicles = (MainForm2.vehicleHT.Values.Cast<Vehicle>().ToList());

            foreach (Vehicle veh in vehicles)
            {
                String iconFilePath = IconHelper.GetIconPathForUnit(veh.busName);

                // add image to the dictionary if not exists
                if (!MainForm2.imagesDictionary.ContainsKey(iconFilePath))
                {
                    Image img = IconHelper.GetIconForUnit(veh);
                    MainForm2.imagesDictionary.Add(iconFilePath, img == null ? imageList1.Images[2] : img);
                }

                ///new emergency status
                EmergStat = 0;
                if (veh.is_emergency)
                    EmergStat = 1;

                Statusforgrid = Vehicle.GetString_Status(veh.actual_status);


                // add vehicle with position to the list
                list.Add(new DataforVehList()
                {
                    RadioId = veh.IMEI,
                    SipId = veh.sipID,
                    GrpName = veh.group.Name,
                    Pict = MainForm2.imagesDictionary[iconFilePath],
                    UnitName = veh.busName,
                    OnMap = VisualSettings.IsDisplayedInLiveTab(veh.sipID, tabName),
                    UnitStatus = veh.actual_status,
                    Status = Statusforgrid,
                    Emerg0off1on = EmergStat,
                    IsEmergency = veh.is_emergency,
                    Latitude = veh.LAT,
                    Longitude = veh.LNG,
                    Address = veh.GetLastAddress(),
                    PositionTime = veh.lastActivityTime.ConvertGMTToLocal().GetDTFromSeconds(), //lastValidPositionTime)),
                    Speed = veh.GetSpeed(),
                    IsMPH = MainForm2.isInMile,
                    HasAlerts = false,
                    HasVoice = veh.has_voice,
                    HasText = veh.has_text,
                    Stolen = veh.is_stolen
                });
            }

            return list;
        }



        private void SetGroupExpandedStates()
        {
            GridExpandAnimationType temp = gridVehicles.GroupExpandAnimationType;
            gridVehicles.GroupExpandAnimationType = GridExpandAnimationType.None;
            for (int i = 0; i < gridVehicles.Groups.Count; i++)
            {
                bool? isGroupExpanded = VisualSettings.IsGroupExpandedInLiveTab((gridVehicles.Groups[i]).Key + "", tabName);
                if (isGroupExpanded == null || isGroupExpanded == true)
                    gridVehicles.Groups[i].Expand();
                else
                    gridVehicles.Groups[i].Collapse();
            }
            gridVehicles.GroupExpandAnimationType = temp;
            gridVehicles.TableElement.ScrollToRow(0);
        }




        private void populateVehiclesList(ArrayList listOfVehicles)
        {

            SM.Debug("Before populate VehicleList");
            try
            {
                ListforVehList.Clear();
                gridVehicles.Columns["unitName"].SortOrder = RadSortOrder.None;
                int cont = 0;                

                foreach (String obj in MainForm2.vehicleHT.Keys)
                {
                    GroupNameforgrid = ((Vehicle)MainForm2.vehicleHT[obj]).group.Name;
                    /*MainForm2.returnLNGString("otherunit");
                    if (MainForm2.GrpIdforScId[((Vehicle)MainForm2.vehicleHT[obj]).sc_id] != null)
                        GroupNameforgrid = ((GroupClass)MainForm2.GrpIdforScId[((Vehicle)MainForm2.vehicleHT[obj]).sc_id]).name;
                        */
                    Car crtCar = ((Car)MainForm2.carlist[((Vehicle)MainForm2.vehicleHT[obj]).IconID]);
                    if (crtCar == null)
                    {
                        Utils.WriteLine("nullllll", ConsoleColor.Cyan);
                        continue;
                    }
                    String iconPath = crtCar.listFilePath;

                    try
                    {
                        Bitmap bmp = new Bitmap(iconPath);
                        Image tmp2 = Utils.ScaleImage(bmp, 64, 64); //tmp.ToBitmap();
                        tmp2.Tag = crtCar.listFilePath;

                        // add image to the dictionary if not exists
                        if (!MainForm2.imagesDictionary.ContainsKey(crtCar.listFilePath))
                            MainForm2.imagesDictionary.Add(crtCar.listFilePath, tmp2);

                        // set the icon for the unit
                        Imageforgrid = MainForm2.imagesDictionary[crtCar.listFilePath];
                    }
                    catch (Exception)
                    {
                        SM.Debug("Grid icon could not be found [" + iconPath + "]");
                        Imageforgrid = imageList1.Images[2];
                    }

                    ///new emergency status
                    EmergStat = 0;
                    if (((Vehicle)MainForm2.vehicleHT[obj]).is_emergency)
                        EmergStat = 1;

                    // get the 
                    Vehicle veh = ((Vehicle)MainForm2.vehicleHT[obj]);

                    Statusforgrid = Vehicle.GetString_Status(veh.actual_status);

                    cont++;

                    
                    RadioGateway rg = MainForm2.myGatewaylist.Find(d => (veh.GwandRadioID).Equals(d.Gw_id + "." + d.Id));
                    String gatewayName = rg == null ? MainForm2.returnLNGString("Unassigned") : rg.Name;

                    // add vehicle with position to the list
                    ListforVehList.Add(new DataforVehList()
                        {
                            RadioId = veh.IMEI,
                            SipId = veh.sipID,
                            GrpName = GroupNameforgrid,
                            Pict = Imageforgrid,
                            UnitName = obj,
                            OnMap = ((MapElement)veh.MapsHT[tabName]).itemCheck,
                            UnitStatus = veh.actual_status,
                            Status = Statusforgrid,
                            Emerg0off1on = EmergStat,
                            IsEmergency = veh.is_emergency,
                            Latitude = veh.LAT,
                            Longitude = veh.LNG,
                            Address = veh.GetLastAddress(),
                            PositionTime = veh.lastActivityTime.ConvertGMTToLocal().GetDTFromSeconds(), //lastValidPositionTime)),
                            Speed = veh.GetSpeed(),
                            IsMPH = MainForm2.isInMile,
                            HasAlerts = false, 
                            HasVoice = veh.has_voice, 
                            HasText = veh.has_text,
                            Stolen = veh.is_stolen,
                            RadioGateway = gatewayName
                        });
                }

                try
                {
                    // set data source and refresh it
                    gridVehicles.DataSource = null;
                    gridVehicles.DataSource = ListforVehList;
                }
                catch (Exception ex)
                {
                    SM.Debug("Error on populate grid" + ex.ToString());
                }

                gridVehicles.Columns["unitName"].SortOrder = RadSortOrder.Ascending;

                gridVehicles.MasterTemplate.GroupDescriptors.Clear();
                GroupDescriptor groupDescriptor = new GroupDescriptor();
                groupDescriptor.GroupNames.Add(gridVehicles.Columns["GroupName"].Name, ListSortDirection.Ascending);
                gridVehicles.GroupDescriptors.Add(groupDescriptor);

                CheckedGroup.Clear();
                GridExpandAnimationType temp = gridVehicles.GroupExpandAnimationType;
                gridVehicles.GroupExpandAnimationType = GridExpandAnimationType.None;
                for (int i = 0; i < gridVehicles.Groups.Count; i++)
                {
                    string key = this.tabName + "_" + "ExpandGroupingHT_" + (gridVehicles.Groups[i]).Key;
                    if (MainForm2.HashVal.ContainsKey(key))
                    {
                        if(Boolean.Parse(MainForm2.HashVal[key] +"") )
                        this.Expand(gridVehicles.Groups[i]);
                    }
                    else
                    {
                        this.Expand(gridVehicles.Groups[i]);
                    }
                    //vehiclesList.Groups[i].HeaderRow
                    CheckedGroup.Add(i, false);
                }
                gridVehicles.GroupExpandAnimationType = temp;
                gridVehicles.TableElement.ScrollToRow(0);
            }
            catch (Exception ex)
            {
                SM.Debug("ExLive4:" + ex.ToString());
            }
            SM.Debug("Finish populate VehicleList");
        }


        private void Expand(DataGroup group)
        {
            try
            {
                group.Expand();

                if (group.Groups.Count > 0)
                {
                    for (int i = 0; i < group.Groups.Count; i++)
                    {
                        this.Expand(group.Groups[i]);
                    }
                }
            }
            catch (Exception ex)
            {
                SM.Debug("EXLive5:" + ex.ToString());
            }
        }



        public void RefreshUnitTimerExpired()
        {
            Utils.WriteLine("RefreshUnitTimerExpired", ConsoleColor.Yellow);

            // go thourgh eatch unit from the grid
            for (int contor = 0; contor < gridVehicles.Rows.Count; contor++)
            {
                // get current vehicle which is updated
                Vehicle vehicleTemp = (Vehicle)MainForm2.vehicleHT[(String)gridVehicles.Rows[contor].Cells["UnitName"].Value];

                // get the Data bound item for each grid row
                DataforVehList gridData = gridVehicles.Rows[contor].DataBoundItem as DataforVehList;

                // verify if the unit is valid or not 
                if (gridData != null)
                {
                    // check if the position had changed the ago time which needs to be displayed
                    if (!Utils.GetDateTimeAgo(gridData.PositionTime.AddSeconds(-30)).Equals(Utils.GetDateTimeAgo(gridData.PositionTime)))
                    {
                        //Utils.WriteLine("REFRESH TIMER : CHANGE TIME", ConsoleColor.Cyan);
                        // notify that an update must be made
                        gridData.NrOfUpdates = gridData.NrOfUpdates + 1;

                        // refresh the grid only if the group is POSITION TIME
                        if (groupType == GroupType.POSITIONTIMEAGO)
                            gridVehicles_SetGrouping(groupType, false);
                    }
                    // if the position didn't change, I can test if the status has changed
                    else if (gridData.PreviousStatus != null && gridData.PreviousStatus != gridData.Status)
                    {
                        //Utils.WriteLine("REFRESH TIMER : CHANGE STATE" + " [" + gridData.PreviousStatus + " -> " + gridData.Status + "]", ConsoleColor.Cyan);
                        // update the status of the unit
                        gridData.UnitStatus = Utils.GetStatusFromDisplayString(gridData.Status);
                        // notify that an update must be made
                        gridData.NrOfUpdates = gridData.NrOfUpdates + 1;

                        // refresh the grid only if the group is STATUS
                        if (groupType == GroupType.STATUS)
                            gridVehicles_SetGrouping(groupType, false);
                    }
                }
            }

            // refresh the grid if positions window is active
            if (positionsWindowIsActive)
                RefreshPositionsGrid();
        }


        /// <summary>
        /// Refresh the grid only for one unit used when a position is received or when a unit
        /// changes it's state
        /// </summary>
        /// <param name="unitName">Unit name which needs to be updated</param>
        public void onUnitPositionOrStateChanged(String unitName)
        {
            //populateTableVehiclesList2(true, unitName);
            UpdateDataGridUnit(unitName, false);


            // refresh the grid if positions window is active
            if (positionsWindowIsActive)
                RefreshPositionsGrid(unitName);
        }


        public void OnUnitStolenChanged(String unitName, Boolean isStolen)
        {
            UpdateDataGridUnit(unitName, true);
        }


        
        private void UpdateDataGridUnit(String unitName, Boolean shouldUpdateGrid)
        {
            // find the subscriber in the datasource 
            DataforVehList result = ListforVehList.Find(d => d.UnitName.Equals(unitName));
            // get current vehicle which is updated
            Vehicle vehicleTemp = (Vehicle)MainForm2.vehicleHT[unitName];

            // update the favorite if found
            if (result != null)
            {
                lock (thisLock)
                {
                    if(shouldUpdateGrid)
                        gridVehicles.BeginUpdate();
                    else 
                        gridVehicles.BeginEdit();

                    // save previous values
                    int prevSpeed = result.Speed;
                    string prevStatus = result.PreviousStatus;
                    string prevTimeAgo = result.PositionTimeAgo;

                    // remove null values to empty ones
                    if (prevStatus == null)
                        prevStatus = "";
                    if (prevTimeAgo == null)
                        prevTimeAgo = "";
                    // update all the new fields and values
                    result.Address = vehicleTemp.lastAddress;
                    result.PositionTime = vehicleTemp.lastActivityTime.ConvertGMTToLocal().GetDTFromSeconds();  // lastValidPositionTime));
                    result.Latitude = vehicleTemp.LAT;
                    result.Longitude = vehicleTemp.LNG;
                    result.Speed = vehicleTemp.GetSpeed();
                    result.UnitStatus = vehicleTemp.actual_status;
                    result.Status = Vehicle.GetString_Status(vehicleTemp.actual_status);
                    result.IsEmergency = vehicleTemp.is_emergency;
                    result.Stolen = vehicleTemp.is_stolen;

                    // check to see if the status has changed
                    if (!prevStatus.Equals(result.Status) || prevSpeed != result.Speed)
                    {
                        //Utils.WriteLine("REFRESH GROUPS BY STATUS " + " [" + prevStatus + " -> " + gridData.Status + "]", ConsoleColor.Yellow);
                        // notify that an update must be made
                        result.NrOfUpdates = result.NrOfUpdates + 1;
                    }

                    // check if the position had changed the ago time which needs to be displayed
                    if (!prevTimeAgo.Equals(Utils.GetDateTimeAgo(result.PositionTime)))
                    {
                        //Utils.WriteLine("REFRESH GROUPS BY TIME", ConsoleColor.Yellow);
                        // notify that an update must be made
                        result.NrOfUpdates = result.NrOfUpdates + 1;
                    }

                    if (shouldUpdateGrid)
                        gridVehicles.EndUpdate();
                    else
                        gridVehicles.EndEdit();


                    // check to see if the status has changed
                    if (!prevStatus.Equals(result.Status))
                    {
                        // refresh the grid only if the group is STATUS
                        if (groupType == GroupType.STATUS)
                        {
                            gridVehicles.BeginUpdate();
                            gridVehicles_SetGrouping(groupType, false);
                            gridVehicles.EndUpdate();
                        }

                    }

                    // check if the position had changed the ago time which needs to be displayed
                    if (!prevTimeAgo.Equals(Utils.GetDateTimeAgo(result.PositionTime)))
                    {
                        // refresh the grid only if the group is POSITION TIME
                        if (groupType == GroupType.POSITIONTIMEAGO)
                        {
                            gridVehicles.BeginUpdate();
                            gridVehicles_SetGrouping(groupType, false);
                            gridVehicles.EndUpdate();
                        }
                    }
                }
            }

        }


        /// <summary>
        /// Event handler for when a unit changed it status to emergency of back to normal 
        /// </summary>
        /// <param name="veh">Vehicle which changed it's status </param>
        /// <param name="isEmergency">Flag telling if the unit is in emergency or not</param>
        public void onEmergencyStateChangedHandler(Vehicle veh, bool isEmergency)
        {
            // update status for unit
            veh.actual_status = isEmergency ? Status_for_tab.EMERG : Status_for_tab.MADEON;
            veh.is_emergency = isEmergency;

            if (isEmergency)
            {
                // update the grid units on left map
                IEnumerable<DataforVehList> result = ListforVehList.Where(d => d.RadioId == veh.IMEI);
                foreach (DataforVehList ve in result)
                {
                    ve.OnMap = true;
                    ve.NrOfUpdates += 1;
                    ((MapElement)((Vehicle)MainForm2.vehicleHT[ve.UnitName]).MapsHT[tabName]).itemCheck = true;
                    ((MapElement)((Vehicle)MainForm2.vehicleHT[ve.UnitName]).MapsHT[tabName]).ActivatePushPin();

                    VisualSettings.SetDisplayedInLiveTab(ve.SipId, true, tabName);
                }

                // check and create emergency icon
                IconHelper.CheckCreateEmergencyIcon(veh.IconID);
            }

            // send emergency status update to the map
            mapHandler.EmergencyStateUpdate(veh);

            if (isEmergency)
            {
                // put vehicles on map
                mapHandler.AddVehicles(new List<Vehicle> { veh }, false);
                Thread.Sleep(100);
                // center map and open info bubble
                mapHandler.CenterMapToPosition(new LatLngZoom() { Lat = veh.GetLat(), Lng = veh.GetLng(), ZoomLevel = -1 });
                mapHandler.OpenInfoBubble(veh.busName);
                
                // update the header name
                onGroupDisplayedUnitsChangedHandler(veh.group.Name);
            }
        }



        /// <summary>
        /// Handler for when a poll response is received from a field radio
        /// </summary>
        /// <param name="veh">Vehicle which responded to the poll request</param>
        public void onPollResponseReceivedHandler(Vehicle veh)
        {
            // put vehicles on map
            mapHandler.AddVehicles(new List<Vehicle> { veh }, false);
            Thread.Sleep(100);

            // center map and open info bubble
            mapHandler.CenterMapToPosition(new LatLngZoom() { Lat = veh.GetLat(), Lng = veh.GetLng(), ZoomLevel = -1 });
            mapHandler.OpenInfoBubble(veh.busName);
        }


        public void CenterAndOpenBubble(String unitName)
        {
            //ListforGrid.Clear();
            for (int contor = 0; contor < gridVehicles.Rows.Count; contor++)
            {
                // get the Data bound item for each grid row
                DataforVehList gridData = gridVehicles.Rows[contor].DataBoundItem as DataforVehList;

                // verify if the unit is valid or not 
                if (gridData != null)
                {

                    // skip this unit if it doesn't need to be updated
                    if (!gridData.UnitName.Equals(unitName))
                        ;
                    else
                    {

                        // display the car on the map and then notify the change
                        if (docLoad && !gridData.OnMap)
                        {
                            gridData.OnMap = true;
                            gridData.NrOfUpdates += 1;
                            rbDisplay.PerformClick();
                        }

                        // open info buble
                        if (docLoad && gridData.OnMap)
                        {
                            if ((gridData.Latitude != 0 && gridData.Latitude != 0.1) ||
                                (gridData.Longitude != 0 && gridData.Longitude != 0.1))
                            {
                                SM.Debug("Send open info");
                                mapGoogles.ExecuteScript("window.GWTcallback('centerzoom," + MainForm2.FixDoubleLAT(gridData.Latitude + "") + ","
                                    + MainForm2.FixDoubleLNG(gridData.Longitude + "") + ",-1');");
                                Thread.Sleep(351);
                                mapGoogles.ExecuteScript("window.GWTcallback('" + "openInfo," + gridData.UnitName + "');");
                                Thread.Sleep(50);

                                mapHandler.CenterMapToPosition(new LatLngZoom() { Lat = gridData.Latitude, Lng = gridData.Longitude, ZoomLevel = -1 });
                                mapHandler.OpenInfoBubble(gridData.UnitName);
                            }
                            else
                            {
                                parent.DisplayToast(MainForm2.returnLNGString("noGPS"), MainForm2.returnLNGString("HTMLnoGPS"));
                            }

                        }
                    }
                }
            }
        }



        volatile List<DataforGRID> ListforGrid = new List<DataforGRID>();

        /// <summary>
        /// Update Position Grid for that particular unit
        /// </summary>
        /// <param name="unitName">Unit name that needs to be updated</param>
        private void onPositionListUnitChanged(String unitName)
        {
            tableVehiclesList.BeginEdit();
            DataforGRID gridUnit = ListforGrid.Find(d => d.VehName.Equals(unitName));
            // get current vehicle which is updated
            Vehicle vehicleTemp = (Vehicle)MainForm2.vehicleHT[unitName];


            if (gridUnit != null && vehicleTemp != null)
            {
                gridUnit.Lat = vehicleTemp.GetLat() + "";
                gridUnit.Lng = vehicleTemp.GetLng() + "";
                gridUnit.Address = vehicleTemp.GetLastAddress();
                gridUnit.Datatime = vehicleTemp.lastValidPositionTime.ConvertGMTToLocal().GetDTFromSeconds();
                gridUnit.Speed = Convert.ToString(vehicleTemp.GetSpeed());
                gridUnit.Head = Utils.GetDirection(vehicleTemp.GetHeading()).ToString();
                gridUnit.DI = Convert.ToString(vehicleTemp.GetDI());
                gridUnit.DO = Convert.ToString(vehicleTemp.GetDO());;
            }


            tableVehiclesList.EndEdit();
        }


        public void populateTableVehiclesList2(Boolean Refresh, String unitName)
        {
            Int32 oldColomnSort = 0;
            RadSortOrder oldSortType = RadSortOrder.Ascending;
            try
            {
                Vehicle vehicleTemp;
                if (Refresh)
                {
                    //ListforGrid.Clear(); //aici e combinatia fatala

                    try
                    {

                        for (int i = 0; i < tableVehiclesList.Columns.Count; i++)
                        {
                            if (tableVehiclesList.Columns[i].SortOrder != RadSortOrder.None)
                            {
                                oldColomnSort = i;
                                oldSortType = tableVehiclesList.Columns[i].SortOrder;
                                break;
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        SM.Debug("Error on finding the sort column:" + ex.ToString());
                    }
                    tableVehiclesList.Columns["VehName"].SortOrder = RadSortOrder.None;
                    tableVehiclesList.Columns["datetime"].SortOrder = RadSortOrder.None;
                    tableVehiclesList.Columns["address"].SortOrder = RadSortOrder.None;
                    tableVehiclesList.Columns["speed"].SortOrder = RadSortOrder.None;
                    tableVehiclesList.Columns["head"].SortOrder = RadSortOrder.None;
                    tableVehiclesList.Columns["di"].SortOrder = RadSortOrder.None;
                    tableVehiclesList.Columns["do"].SortOrder = RadSortOrder.None;
                    tableVehiclesList.Columns["lat"].SortOrder = RadSortOrder.None;
                    tableVehiclesList.Columns["lng"].SortOrder = RadSortOrder.None;
                    tableVehiclesList.Columns["zone"].SortOrder = RadSortOrder.None;
                    tableVehiclesList.Columns["Altitude"].SortOrder = RadSortOrder.None;
                    Thread.Sleep(100);
                }
                int countlist = -1;
                String LatStr = "";
                String LngStr = "";
                String AltStr = "";
                String Zone;
                Double LatDou, LngDou;
                if (MainForm2.LatLngUTM.CompareTo("Lat/Lng No.") == 0)
                {
                    tableVehiclesList.Columns["lat"].HeaderText = latname;
                    tableVehiclesList.Columns["lng"].HeaderText = lngname;
                    tableVehiclesList.Columns["zone"].HeaderText = "";
                    tableVehiclesList.Columns["Altitude"].HeaderText = altname;
                }
                else if (MainForm2.LatLngUTM.CompareTo("Lat/Lng Deg.") == 0)
                {
                    tableVehiclesList.Columns["lat"].HeaderText = latname;
                    tableVehiclesList.Columns["lng"].HeaderText = lngname;
                    tableVehiclesList.Columns["zone"].HeaderText = "";
                    tableVehiclesList.Columns["Altitude"].HeaderText = altname;
                }
                else if (MainForm2.LatLngUTM.CompareTo("UTM") == 0)
                {
                    tableVehiclesList.Columns["lat"].HeaderText = "X";
                    tableVehiclesList.Columns["lng"].HeaderText = "Y";
                    tableVehiclesList.Columns["zone"].HeaderText = zonename;
                    tableVehiclesList.Columns["Altitude"].HeaderText = altname;
                }



                // refresh the grid if positions window is active
                if (positionsWindowIsActive)
                    RefreshPositionsGrid();


                // flag that an update will be made
                //gridVehicles.TableElement.BeginUpdate();

                //ListforGrid.Clear();
                for (int contor = 0; contor < gridVehicles.Rows.Count; contor++)
                {
                    string un = (String)gridVehicles.Rows[contor].Cells["UnitName"].Value;
                    if (un == null)
                        continue;

                    // get current vehicle which is updated
                    vehicleTemp = (Vehicle)MainForm2.vehicleHT[un];

                    // get the Data bound item for each grid row
                    DataforVehList gridData = gridVehicles.Rows[contor].DataBoundItem as DataforVehList;

                    // verify if the unit is valid or not 
                    if (gridData != null)
                    {

                        // skip this unit if it doesn't need to be updated
                        if (unitName != null && !gridData.UnitName.Equals(unitName))
                            ;
                        else
                        {


                            // save previous values
                            string prevStatus = gridData.PreviousStatus;
                            string prevTimeAgo = gridData.PositionTimeAgo;

                            // remove null values to empty ones
                            if (prevStatus == null)
                                prevStatus = "";
                            if (prevTimeAgo == null)
                                prevTimeAgo = "";
                            // update all the new fields and values
                            gridData.Address = vehicleTemp.lastAddress;
                            gridData.PositionTime = vehicleTemp.lastActivityTime.ConvertGMTToLocal().GetDTFromSeconds(); // lastValidPositionTime));
                            gridData.Latitude = vehicleTemp.LAT;
                            gridData.Longitude = vehicleTemp.LNG;
                            gridData.Speed = vehicleTemp.GetSpeed();
                            gridData.UnitStatus = vehicleTemp.actual_status;
                            gridData.Status = Vehicle.GetString_Status(vehicleTemp.actual_status);
                            gridData.IsEmergency = vehicleTemp.is_emergency;

                            // check to see if the status has changed
                            if (!prevStatus.Equals(gridData.Status))
                            {
                                //Utils.WriteLine("REFRESH GROUPS BY STATUS " + " [" + prevStatus + " -> " + gridData.Status + "]", ConsoleColor.Yellow);

                                // refresh the grid only if the group is STATUS
                                if (groupType == GroupType.STATUS)
                                    gridVehicles_SetGrouping(groupType, false);
                            }

                            // check if the position had changed the ago time which needs to be displayed
                            if (!prevTimeAgo.Equals(Utils.GetDateTimeAgo(gridData.PositionTime)))
                            {
                                //Utils.WriteLine("REFRESH GROUPS BY TIME", ConsoleColor.Yellow);
                                // notify that an update must be made
                                gridData.NrOfUpdates = gridData.NrOfUpdates + 1;

                                // refresh the grid only if the group is POSITION TIME
                                if (groupType == GroupType.POSITIONTIMEAGO)
                                    gridVehicles_SetGrouping(groupType, false);
                            }

                        }
                    }

                    // if the update was as a result of a position received
                    if (unitName != null && gridData.UnitName.Equals(unitName))
                        // notify that an update must be made
                        gridData.NrOfUpdates = gridData.NrOfUpdates + 1;
                }

            }
            catch (Exception ex)
            {
                SM.Debug("EXLive6:" + ex.ToString());
            }
        }

        volatile String volLatStr = "";
        volatile String volLngStr = "";
        volatile String volAltStr = "";
        volatile String volZone = "";
        public Double volLatDou, volLngDou;
        volatile LatLngUTM voltmpLatLng = new LatLngUTM();
      
        /// <summary>
        ///Deletes all used resources
        ///</summary>
        public void Delete()
        {
            try
            {
                timerAddPlace.Stop();
                timerAddPlace.Enabled = false;
                try
                {
                    parent.isCanceled[tabName] = false;
                    vehiclesDataSet.Delete();
                    this.mapControl.ActiveMap.Saved = true;
                    if (this.app != null)
                    {
                        app.Quit();
                        app = null;
                    }
                    Thread.Sleep(100);

                    Killtimer.Enabled = true;
                    Killtimer.Start();
                    this.mapControl.ActiveMap.Saved = true;

                    Killtimer.Stop();
                    this.mapControl = null;
                    this.Dispose();
                    GC.Collect();
                }

                catch (Exception ex)
                {
                    SM.Debug("Exception on close map LIVETab " + ex.ToString());
                }

                if ((MainForm2.ClosingApp) || (!KillTimerActive))
                {
                    SM.Debug("Worker Live " + tabName + " FINISHED");
                    SM.Debug("RELEASE SEMAFOR TAB LIVE: " + tabName);
                }
            }
            catch (Exception ex)
            {
                SM.Debug("Error on delete live :" + ex.ToString());
            }
        }
        

        /// <summary>
        ///treats the click on Display Telerik.WinControls.UI.RadButton - centers map on selected vehicles </summary>
        private void displayButton_Click(object sender, EventArgs e)
        {
            rbDisplay.Enabled = false;
            try
            {
                centeredState = false;

                // need to find what this is doing
                ComputeCheckedVehicles(true);

                // save how many units are selected
                ////if (nrofunitsChecked == 1)
                ////    MainForm2.onlyOneUnitSelected = true;
                ////else
                ////    MainForm2.onlyOneUnitSelected = false;


                if (vehiclesDataSet.RecordCount > 0)
                {
                    vehiclesDataSet.zoomin = true;
                    vehiclesDataSet.ZoomTo();

                    MapMarkersLables(MainForm2.HashVal.ContainsKey("showMarkersLables") && Convert.ToBoolean(MainForm2.HashVal["showMarkersLables"]));
                }

                bool areAllGroupsChecked = true;
                foreach (GridViewRowInfo groupRow in gridVehicles.ChildRows)
                {
                    // the group has items
                    if (groupRow.ChildRows.Count > 0)
                    {
                        // group name is groupRow.Group.Header
                        bool areAllChecked = true;

                        foreach (GridViewRowInfo gridRow in groupRow.ChildRows)
                        {
                            // get the Data bound item for each grid row
                            DataforVehList gridData = gridRow.DataBoundItem as DataforVehList;

                            // verify if the unit is valid or not 
                            if (gridData != null)
                            {
                                if (!gridData.OnMap)
                                {
                                    areAllChecked = false;
                                    areAllGroupsChecked = false;
                                }
                            }

                        }

                        if (groupRow != null && areAllChecked)
                            groupRow.Tag = true;
                        else
                            groupRow.Tag = false;
                    }
                }
            }
            catch (Exception ex)
            {
                SM.Debug("Error on display Telerik.WinControls.UI.RadButton click" + ex.ToString());
            }         
            rbDisplay.Enabled = true;
        }


        private void MapMarkersLables(bool isDisplayed)
        {
          
            MainForm2.Displaywithname = isDisplayed;
            if (docLoad)
                vehiclesDataSet.ZoomTo();
            if (isDisplayed)
            {
                if (docLoad)
                {
                    System.Threading.Thread.Sleep(100);
                    mapGoogles.ExecuteScript("window.GWTcallback('" + "putLabels," + vehiclesDataSet.Name + "');");
                }
                Thread.Sleep(1);
                HideALLName = true;
            }
            else
            {
                if (HideALLName)
                {
                    HideALLName = false;
                    if (docLoad)
                    {
                        System.Threading.Thread.Sleep(100);
                        mapGoogles.ExecuteScript("window.GWTcallback('" + "removeLabels," + vehiclesDataSet.Name + "');");
                    }
                    Thread.Sleep(1);
                }
            }
        }
        
        private volatile Int32 nrofunitsChecked = 0;
        /// <summary>
        ///only displays on the map the selected vehicles </summary>
        public void ComputeCheckedVehicles(bool displayButtonCase)
        {
            try
            {
                nrofunitsChecked = 0;
                Int32 timenowsec = (int)DateTime.Now.GetSecondsLocalFromDT();
                if (displayButtonCase)
                {
                    //for (cont = 0; cont < vehiclesList.Rows.Count; cont++)
                    foreach (DataforVehList obj2 in (List<DataforVehList>)gridVehicles.DataSource)
                    {
                        VisualSettings.SetDisplayedInLiveTab(obj2.SipId, obj2.OnMap, tabName);

                        if ((bool)obj2.OnMap)
                        {
                            try
                            {

                                if (!((MapElement)((Vehicle)MainForm2.vehicleHT[obj2.UnitName]).MapsHT[tabName]).itemCheck)
                                {
                                    ((MapElement)((Vehicle)MainForm2.vehicleHT[obj2.UnitName]).MapsHT[tabName]).itemCheck = true;
                                    if ((parent.NoteAddr[obj2.UnitName] == null))
                                        parent.NoteAddr.Add(obj2.UnitName, "none");
                                    else
                                        parent.NoteAddr[obj2.UnitName] = "none";
                                    
                                    ((MapElement)((Vehicle)MainForm2.vehicleHT[obj2.UnitName]).MapsHT[tabName]).ActivatePushPin();
                                }

                                nrofunitsChecked++;
                                if (MainForm2.HideInactiveUnitsCheck)
                                    if (((Vehicle)MainForm2.vehicleHT[obj2.UnitName]).lastActivityTime < (timenowsec - (MainForm2.Livelastmin * 60)))
                                    {
                                        ((MapElement)((Vehicle)MainForm2.vehicleHT[obj2.UnitName]).MapsHT[tabName]).DeactivatePushpin();
                                        nrofunitsChecked--;
                                    }
                            }
                            catch (Exception ex)
                            {
                                SM.Debug("Error in compute display not click: " + ex.ToString());
                            }
                        }
                        else
                        {
                            ((MapElement)((Vehicle)MainForm2.vehicleHT[obj2.UnitName]).MapsHT[tabName]).itemCheck = false;
                            if (((MapElement)((Vehicle)MainForm2.vehicleHT[obj2.UnitName]).MapsHT[tabName]).pp != null)
                            {
                                ((MapElement)((Vehicle)MainForm2.vehicleHT[obj2.UnitName]).MapsHT[tabName]).pp.Highlight = false;
                                ((MapElement)((Vehicle)MainForm2.vehicleHT[obj2.UnitName]).MapsHT[tabName]).DeactivatePushpin();
                                if (((Vehicle)MainForm2.vehicleHT[obj2.UnitName]).selectCenter)
                                {
                                    ((Vehicle)MainForm2.vehicleHT[obj2.UnitName]).selectCenter = false;
                                    centeredState = false;
                                }
                            }
                        }
                        if (((MapElement)((Vehicle)MainForm2.vehicleHT[obj2.UnitName]).MapsHT[tabName]).pp != null)
                        {
                            ((MapElement)((Vehicle)MainForm2.vehicleHT[obj2.UnitName]).MapsHT[tabName]).pp.Highlight = false;
                            ((Vehicle)MainForm2.vehicleHT[obj2.UnitName]).selectCenter = false;
                        }
                    }
                }
                else
                {
                    if (deleteDsetcomand.IndexOf(',') != deleteDsetcomand.LastIndexOf(','))
                    {
                        if (docLoad)
                        {
                            mapControl.mapGoogles.ExecuteScript("window.GWTcallback('" + "clearFromMap,vehicles_positions');");
                            Thread.Sleep(1);
                            ComputeCheckedVehicles(true);
                            if (vehiclesDataSet.RecordCount > 0)
                            {
                                if (vehiclesDataSet.RecordCount == 1) vehiclesDataSet.zoomin = true;
                                else vehiclesDataSet.zoomin = false;
                                vehiclesDataSet.ZoomTo();
                                
                                if (MainForm2.Displaywithname)
                                {
                                    if (docLoad)
                                    {
                                        System.Threading.Thread.Sleep(100);
                                        mapGoogles.ExecuteScript("window.GWTcallback('" + "putLabels," + vehiclesDataSet.Name + "');");
                                    }
                                    Thread.Sleep(1);
                                    HideALLName = true;
                                }
                                else
                                {
                                    if (HideALLName)
                                    {
                                        HideALLName = false;
                                        if (docLoad)
                                        {
                                            mapGoogles.ExecuteScript("window.GWTcallback('" + "removeLabels," + vehiclesDataSet.Name + "');");
                                        }
                                        Thread.Sleep(1);
                                    }
                                }

                            }
                        }
                        deleteDsetcomand = "";
                    }
                    if (updatecomand.IndexOf(',') != updatecomand.LastIndexOf(','))
                    {
                        if (docLoad)
                        {
                            mapControl.mapGoogles.ExecuteScript("window.GWTcallback('" + updatecomand + "');");
                        }
                        // Console.WriteLine("Update cmd:" + updatecomand);
                        Thread.Sleep(1);
                        String[] tmp = updatecomand.Split(',');
                        if (docLoad)
                        {
                            //SM.Debug("Oneunit"+MainForm2.oneunit);
                            //if (MainForm2.onlyOneUnitSelected) 
                            //    mapControl.mapGoogles.ExecuteScript("window.GWTcallback('" + "putOnMap,false," + tmp[1] + "');");
                            //else 
                            mapControl.mapGoogles.ExecuteScript("window.GWTcallback('" + "putOnMap,false," + tmp[1] + "');");
                        }
                        Thread.Sleep(1);
                        //SM.Debug("Value of displayname:" + MainForm2.Displaywithname);
                        if (((MainForm2.Displaywithname) && (updatecomand.Contains("setDataset,"))) || (MainForm2.ForcePutLabelsONGoogle))
                        {
                            String[] datas = updatecomand.Split(',');
                            if (datas.Length > 1)
                            {
                                //System.Threading.Thread.Sleep(100);
                                //mapGoogles.ExecuteScript("window.GWTcallback('" + "putLabels," + datas[1] + "');");
                            }
                            Thread.Sleep(1);
                            if (MainForm2.ForcePutLabelsONGoogle) MainForm2.ForcePutLabelsONGoogle = false;
                        }
                        updatecomand = "";
                        //Console.WriteLine("Second cmd:" + "putOnMap,false," + tmp[1]);
                    }
                    if (getADDRcomand != "")
                    {
                        if (docLoad)
                            mapControl.mapGoogles.ExecuteScript("window.GWTcallback('" + getADDRcomand + "');");
                        Thread.Sleep(1);
                    }
                }
            }
            catch (Exception x)
            {
                SM.Debug("Erorr compute checked vehicle " + x.ToString());
            }
        }

        public void ForceUnitState(String Name, Boolean check)
        {
            //gridVehicles.TableElement.BeginUpdate();
            foreach (DataforVehList obj2 in (List<DataforVehList>)gridVehicles.DataSource)
            {
                if (obj2.UnitName.CompareTo(Name) == 0)
                {
                    obj2.OnMap = check;
                    if (obj2.UnitName.CompareTo("test960") == 0)
                        Console.WriteLine("Value1  for ONMAP:" + obj2.OnMap);
                    break;
                }
            }
            // gridVehicles.TableElement.EndUpdate(false);            
            //gridVehicles.TableElement.Update(GridUINotifyAction.DataChanged);
            //gridVehicles.Refresh();
        }



        /// <summary>
        /// Filter the vehicles grid based on a string patter
        /// </summary>
        /// <param name="vehicleName">Filter for vehicle name</param>
        private void FilterGridVehicles(string vehicleName)
        {
            try
            {
                for (int i = 0; i < gridVehicles.Rows.Count; i++)
                {
                    // get the Data bound item for each grid row
                    DataforVehList gridData = gridVehicles.Rows[i].DataBoundItem as DataforVehList;

                    // verify if the unit is valid or not
                    if (gridData != null && gridData.UnitName.ToUpper().Contains(vehicleName.ToUpper()))
                        gridVehicles.Rows[i].IsVisible = true;
                    else
                        gridVehicles.Rows[i].IsVisible = false;
                }
            }
            catch (Exception ex)
            {
                SM.Debug("ExLive8:" + ex.ToString());
            }
        }


        /// <summary>
        /// Catches the event when
        /// the user inputs/deletes a character in/from the search box,
        /// and the vehicles list is refreshed accordingly </summary>
        /// </summary>
        private void searchTextBox_TextChanged(object sender, EventArgs e)
        {
            FilterGridVehicles(searchTextBox.Text);
        }


        /// <summary>
        ///  timer for refresing status in vehicle list
        /// </summary>
        /// <param name="sender"></param>     
        private void Killtimer_Tick(object sender, EventArgs e)
        {
            try
            {
                if (MainForm2.ClosingApp)
                {
                    SM.Debug("Worker Live: " + tabName + " FINISHED from timer");
                    SM.Debug("RELEASE SEMAFOR TAB LIVE: " + tabName);
                    KillTimerActive = true;
                }
            }
            catch (Exception ex)
            {
                SM.Debug("EXLive9:" + ex.ToString());
            }
        }


        private void sendPOLLToolStripMenuItem_Click(object sender, EventArgs e)
        {
            try
            {
                smdbObj.Send_cmd_to_val(false, ((Vehicle)MainForm2.vehicleHT[(String)gridVehicles.SelectedRows[0].Cells[2].Value]).IMEI, "");

            }
            catch (Exception ex)
            {
                SM.Debug("Cann't send POLL cmd" + ex.ToString());
            }
        }

        private Object thisLock = new Object();
        [ChangesAtrribute("4 Nov 2016", "Removed unnecessary if/else clause")]
        private void sel_desel_ToggleStateChanged(object sender, StateChangedEventArgs args)
        {
            lock (thisLock)
            {
                gridVehicles.BeginUpdate();

                try
                {
                    for (int i = 0; i < gridVehicles.Groups.Count; i++)
                    {
                        //GridViewRowInfo groupHeaderRow = gridVehicles.Groups[i].GroupRow;
                        GroupCheckBox_StateChanged(sender, new GRPEventArgs(i, sel_desel.Checked));
                        //gridVehicles.Groups[i].GroupRow.ViewInfo.ChildRows
                        DataGroup dg = (gridVehicles.Groups[i]) as DataGroup;
                        //dg.GroupRow.
                    }

                    for (int i = 0; i < gridVehicles.Groups.Count; i++)
                        CheckedGroup[i] = sel_desel.Checked;

                    foreach (GridViewRowInfo row in this.gridVehicles.ChildRows)
                    {
                        GridViewGroupRowInfo groupRow = row as GridViewGroupRowInfo;
                        if (groupRow != null)
                            groupRow.Tag = sel_desel.Checked;
                    }
                }
                catch (Exception ex)
                {
                    Utils.WriteLine("gridVehicles exception: " + ex.ToString(), ConsoleColor.DarkRed);
                }
                gridVehicles.EndUpdate();
            }
        }

        public volatile Int32 maxloadcnt = 1;



        
        private void vehiclesList_ContextMenuOpening(object sender, ContextMenuOpeningEventArgs e)
        {
            try
            {
                if (e.ContextMenuProvider is GridHeaderCellElement)
                {
                    // e.ContextMenu = columnHeaderMenu;
                }

                else if (e.ContextMenuProvider is GridDataCellElement || e.ContextMenuProvider is LiveGridCellElement)
                {
                    GridViewRowInfo row =
                        (e.ContextMenuProvider is LiveGridCellElement ?
                        ((LiveGridCellElement)e.ContextMenuProvider).RowInfo as GridViewDataRowInfo :
                            ((GridDataCellElement)e.ContextMenuProvider).RowInfo);
                    
                    RadDropDownMenu TelemMenu = new RadDropDownMenu();
                    if ((!MainForm2.LimitedUser) && (MainForm2.radioType != RADIOTYPE.ATLAS) && (MainForm2.radioType != RADIOTYPE.TETRA) && (MainForm2.radioType != RADIOTYPE.CONECTPLUS) 
                        && (MainForm2.radioType != RADIOTYPE.SIMOCO) && (MainForm2.radioType != RADIOTYPE.EXCERA))
                    {
                        if (!((Vehicle)MainForm2.vehicleHT[(String)row.Cells["UnitName"].Value]).canMakeSipCalls)
                            {
                            RadMenuItem tmpItem2 = new RadMenuItem(MainForm2.returnLNGString("enRadio"));
                            tmpItem2.Image = Dispatcher.Properties.Resources.l_menu_enable;
                            tmpItem2.Click += new EventHandler(SendRadioEnable_Click);
                            TelemMenu.Items.Add(tmpItem2);
                            RadMenuItem tmpItem3 = new RadMenuItem(MainForm2.returnLNGString("disRadio"));
                            tmpItem3.Image = Dispatcher.Properties.Resources.l_menu_disable;
                            tmpItem3.Click += new EventHandler(SendRadioDisable_Click);
                            TelemMenu.Items.Add(tmpItem3);
                        }
                    }
                    if (docLoad)
                    {
                        if ((MainForm2.radioType != RADIOTYPE.EXCERA))
                        {
                            RadMenuItem tmpItem4 = new RadMenuItem(MainForm2.returnLNGString("poll"));
                            tmpItem4.Image = Dispatcher.Properties.Resources.l_menu_poll;
                            tmpItem4.Click += new EventHandler(SendPOLL_Click);
                            TelemMenu.Items.Add(tmpItem4);
                        }
                    }

                    if ((MainForm2.radioType == RADIOTYPE.HYT) || (MainForm2.radioType == RADIOTYPE.HARRIS) || 
                        (MainForm2.radioType == RADIOTYPE.SIMOCO) ||   (MainForm2.radioType == RADIOTYPE.EXCERA))
                    {
                        RadMenuItem tmpItem6 = new RadMenuItem(MainForm2.returnLNGString("radcheck"));
                        tmpItem6.Click += new EventHandler(SendPOLLARS_Click);
                        TelemMenu.Items.Add(tmpItem6);
                    }

                    RadMenuItem tmpItem5 = null;
                    //markasstolen
                    if ((!MainForm2.LimitedUser) && (MainForm2.radioType != RADIOTYPE.ATLAS) && (MainForm2.radioType != RADIOTYPE.TETRA) 
                        && (MainForm2.radioType != RADIOTYPE.CONECTPLUS) 
                        && (MainForm2.radioType != RADIOTYPE.SIMOCO) && (MainForm2.radioType != RADIOTYPE.EXCERA))
                    {
                        if (!((Vehicle)MainForm2.vehicleHT[(String)row.Cells["UnitName"].Value]).is_stolen)
                        {
                            tmpItem5 = new RadMenuItem(MainForm2.returnLNGString("markasstolen"));
                            tmpItem5.Image = Dispatcher.Properties.Resources.l_menu_stolen;
                            tmpItem5.Click += new EventHandler(SendStolen_Click);
                            TelemMenu.Items.Add(tmpItem5);
                            
                        }
                        else
                        {
                            tmpItem5 = new RadMenuItem(MainForm2.returnLNGString("unmarkasstolen"));
                            tmpItem5.Image = Dispatcher.Properties.Resources.l_menu_unstolen;
                            tmpItem5.Click += new EventHandler(SendUNStolen_Click);
                            TelemMenu.Items.Add(tmpItem5);
                        }
                        
                    }
                    RadMenuItem tmpItem7 = null;
                    int sc_id = (((Vehicle)MainForm2.vehicleHT[(String)row.Cells["UnitName"].Value])).sc_id;

                    Int64 alarmsCounter = dbalm.GetNumberOfNonAckAllarmsForRadioId(sc_id);
                    if (alarmsCounter > 0)
                    {
                        tmpItem7 = new RadMenuItem(MainForm2.returnLNGString("alarmALLACK"));
                        tmpItem7.Click += new EventHandler(AckAlarmForUnit_Click);
                        TelemMenu.Items.Add(tmpItem7);
                    }

                    TelemMenu.Items.Add(new RadMenuSeparatorItem() { BackColor = MainForm2.ButtonColor, Padding = new Padding(0, 8, 0, 0) });

                    string unitName = (String)gridVehicles.SelectedRows[0].Cells["UnitName"].Value;
                    string groupName = (((Vehicle)MainForm2.vehicleHT[unitName])).group.Name;
                   

                    RadMenuItem tmpItemDisplay = new RadMenuItem(String.Format(MainForm2.returnLNGString("displayGroup"), groupName));
                    tmpItemDisplay.Tag = groupName;
                    tmpItemDisplay.Image = Dispatcher.Properties.Resources.l_menu_display;
                    tmpItemDisplay.Click += new EventHandler(delegate(object s, EventArgs e2)
                    {
                        String group_name = ((RadMenuItem)s).Tag.ToString();

                        ShowGroup(group_name);
                    });
                    TelemMenu.Items.Add(tmpItemDisplay);

                    RadMenuItem tmpItemHide = new RadMenuItem(String.Format(MainForm2.returnLNGString("hideGroup"), groupName));
                    tmpItemHide.Tag = groupName;
                    tmpItemHide.Image = Dispatcher.Properties.Resources.l_menu_hide;
                    tmpItemHide.Click += new EventHandler(delegate (object s, EventArgs e2)
                    {
                        String group_name = ((RadMenuItem)s).Tag.ToString();

                        HideGroup(group_name, false);
                    });
                    TelemMenu.Items.Add(tmpItemHide);

                    if (MainForm2.GroupHash.Count > 0)
                    {
                        TelemMenu.Items.Add(new RadMenuSeparatorItem() { BackColor = MainForm2.ButtonColor, Padding = new Padding(0, 8, 0, 0) });
                        RadMenuItem tmpShowAll = new RadMenuItem(String.Format(MainForm2.returnLNGString("displayAllUnits"), groupName));
                        tmpShowAll.Image = Dispatcher.Properties.Resources.l_menu_display_all;
                        tmpShowAll.Click += new EventHandler(delegate (object s, EventArgs e2)
                        {
                            DisplayAllUnits();
                        });
                        TelemMenu.Items.Add(tmpShowAll);

                        RadMenuItem tmpHideAll = new RadMenuItem(String.Format(MainForm2.returnLNGString("hideAllUnits"), groupName));
                        tmpHideAll.Tag = groupName;
                        tmpHideAll.Image = Dispatcher.Properties.Resources.l_menu_hide_all;
                        tmpHideAll.Click += new EventHandler(delegate (object s, EventArgs e2)
                        {
                            HideAllUnits();
                        });
                        TelemMenu.Items.Add(tmpHideAll);
                    }

                    e.ContextMenu = TelemMenu;
                }


            }
            catch (Exception ex)
            {
                SM.Debug("EXLive10:" + ex.ToString());
            }
        }



        private void DisplayAllUnits()
        {
            List<Vehicle> htList = (MainForm2.vehicleHT.Values.Cast<Vehicle>().ToList());
            IEnumerable<IGrouping<int, Vehicle>> query = htList.GroupBy(d => d.group.Id, d => d);

            List<Vehicle> toDisplayVehicles = htList.Select(d => d).Where(d => !((MapElement)d.MapsHT[tabName]).itemCheck)
                .Where(d => VisualSettings.IsGroupDisplayedInLiveTab(d.group.Name, tabName) == null ||
                VisualSettings.IsGroupDisplayedInLiveTab(d.group.Name, tabName) == true).ToList();

            if (rseUnitsOnMap.Value < getNumberOfDisplayedUsers() + toDisplayVehicles.Count)
            {
                if (getMaxUnitsWarningDialogResult(toDisplayVehicles.Count, getNumberOfDisplayedUsers() + toDisplayVehicles.Count, (Int64)rseUnitsOnMap.Value) != DialogResult.Yes)
                {
                    return;
                }
                else
                    rseUnitsOnMap.Value = getNumberOfDisplayedUsers() + toDisplayVehicles.Count;
            }

            // Iterate over each IGrouping in the collection.
            foreach (IGrouping<int, Vehicle> group in query)
            {
                String group_name = group.FirstOrDefault(d => d.sipID > 0).group.Name;

                // skip groups that are not displayed in the grid
                bool? isGroupDisplayed = VisualSettings.IsGroupDisplayedInLiveTab(group_name, tabName);
                if (isGroupDisplayed == false)
                    continue;

                List<Vehicle> vehicles = new List<Vehicle>();

                vehicles = (MainForm2.vehicleHT.Values.Cast<Vehicle>().ToList()).Where(x => x.group.Name.Equals(group_name)).ToList();

                List<Vehicle> toDisplayVehiclesFromGroup = vehicles.Select(d => d).Where(d => !((MapElement)d.MapsHT[tabName]).itemCheck).ToList();


                if (toDisplayVehiclesFromGroup.Count > 0)
                {
                    // prevent updates in the livegrid to raise event
                    parseLiveGridEvents = false;

                    mapHandler.AddVehicles(toDisplayVehiclesFromGroup, false);

                    // update the grid units on left map
                    IEnumerable<DataforVehList> result = ListforVehList.Select(d => d).Where(d => (toDisplayVehiclesFromGroup.Select(w => w.IMEI)).Contains(d.RadioId));
                    foreach (DataforVehList ve in result)
                    {
                        ve.OnMap = true;
                        ve.NrOfUpdates += 1;
                        ((MapElement)((Vehicle)MainForm2.vehicleHT[ve.UnitName]).MapsHT[tabName]).itemCheck = true;
                        ((MapElement)((Vehicle)MainForm2.vehicleHT[ve.UnitName]).MapsHT[tabName]).ActivatePushPin();

                        VisualSettings.SetDisplayedInLiveTab(ve.SipId, true, tabName);
                    }

                    if (groupsHeadersByString.ContainsKey(group_name))
                        groupsHeadersByString[group_name].checkbox.Checked = true;

                    // enable the event raising
                    parseLiveGridEvents = true;
                }

                // update the group header
                onGroupDisplayedUnitsChangedHandler(group_name);
            }
        }

        private void HideAllUnits()
        {
            // prevent updates in the livegrid to raise event
            parseLiveGridEvents = false;

            List<Vehicle> htList = (MainForm2.vehicleHT.Values.Cast<Vehicle>().ToList());
            IEnumerable<IGrouping<int, Vehicle>> query = htList.GroupBy(d => d.group.Id, d => d);

            List<String> groupNames = new List<string>();

            // Iterate over each IGrouping in the collection.
            foreach (IGrouping<int, Vehicle> group in query)
            {
                String group_name = group.FirstOrDefault(d => d.sipID > 0).group.Name;

                bool? isGroupDisplayed = VisualSettings.IsGroupDisplayedInLiveTab(group_name, tabName);
                // skip groups that are not displayed
                if (isGroupDisplayed != null && isGroupDisplayed == false)
                    continue;

                // skip groups that are not having any unit displayed
                int displayedUnitsCount = ListforVehList.Select(d => d).Where(d => (htList.Select(w => w.IMEI)).Contains(d.RadioId))
                    .Where(d => d.OnMap && d.GrpName.Equals(group_name)).Count();

                if (displayedUnitsCount == 0)
                    continue;

                // add group name to the list
                groupNames.Add(group_name);

                // update the header name
                onGroupDisplayedUnitsChangedHandler(group_name);
            }

            // update the live grid
            foreach (DataforVehList ve in ListforVehList)
            {
                ve.OnMap = false;
                ve.NrOfUpdates += 1;

                ((MapElement)((Vehicle)MainForm2.vehicleHT[ve.UnitName]).MapsHT[tabName]).itemCheck = false;
                ((MapElement)((Vehicle)MainForm2.vehicleHT[ve.UnitName]).MapsHT[tabName]).DeactivatePushpin();

                VisualSettings.SetDisplayedInLiveTab(ve.SipId, false, tabName);
            }


            /*
            // Iterate over each IGrouping in the collection.
            foreach (IGrouping<int, Vehicle> group in query)
            {
                String group_name = group.FirstOrDefault(d => d.sipID > 0).group.Name;

                bool? isGroupDisplayed = VisualSettings.IsGroupDisplayedInLiveTab(group_name, tabName);
                // skip groups that are not displayed
                if (isGroupDisplayed != null && isGroupDisplayed == false)
                    continue;

                // skip groups that are not having any unit displayed
                IEnumerable<DataforVehList> result = gridVehicleList.Select(d => d).Where(d => (htList.Select(w => w.IMEI)).Contains(d.RadioId) && d.OnMap == true);
                if (result.Count() == 0)
                    continue;


            }*/

            // enable the event raising
            parseLiveGridEvents = true;

            // remove all groups
            mapHandler.RemoveGroups(groupNames);
        }

        private void ShowDisplayedUnitsFromGroup(String groupName)
        {
            ShowGroup(groupName, false);
        }

        private void ShowGroup(String groupName)
        {
            ShowGroup(groupName, true);
        }

        private void ShowGroup(String groupName, bool forceDisplayAll)
        {
            List<Vehicle> vehicles = new List<Vehicle>();

            vehicles = (MainForm2.vehicleHT.Values.Cast<Vehicle>().ToList()).Where(x => x.group.Name.Equals(groupName)).ToList();

            List<Vehicle> toDisplayVehicles = vehicles.Select(d => d).Where(d =>
                        forceDisplayAll ? !((MapElement)d.MapsHT[tabName]).itemCheck : VisualSettings.IsDisplayedInLiveTab(d.sipID, tabName)).ToList();

            if (rseUnitsOnMap.Value < getNumberOfDisplayedUsers() + toDisplayVehicles.Count)
            {
                if (getMaxUnitsWarningDialogResult(toDisplayVehicles.Count, getNumberOfDisplayedUsers() + toDisplayVehicles.Count, (Int64)rseUnitsOnMap.Value) != DialogResult.Yes)
                {
                    return;
                }
                else
                    rseUnitsOnMap.Value = getNumberOfDisplayedUsers() + toDisplayVehicles.Count;
            }

            if (toDisplayVehicles.Count > 0)
            {
                // prevent updates in the livegrid to raise event
                parseLiveGridEvents = false;

                mapHandler.AddVehicles(toDisplayVehicles, false);


                // update the grid units on left map
                IEnumerable<DataforVehList> result = ListforVehList.Select(d => d).Where(d => (toDisplayVehicles.Select(w => w.IMEI)).Contains(d.RadioId));
                foreach (DataforVehList ve in result)
                {
                    ve.OnMap = true;
                    ve.NrOfUpdates += 1;
                    ((MapElement)((Vehicle)MainForm2.vehicleHT[ve.UnitName]).MapsHT[tabName]).itemCheck = true;
                    ((MapElement)((Vehicle)MainForm2.vehicleHT[ve.UnitName]).MapsHT[tabName]).ActivatePushPin();

                    if (forceDisplayAll)
                        VisualSettings.SetDisplayedInLiveTab(ve.SipId, true, tabName); ;
                }

                if (groupsHeadersByString.ContainsKey(groupName))
                    groupsHeadersByString[groupName].checkbox.Checked = true;

                // enable the event raising
                parseLiveGridEvents = true;
            }

            // update the group header
            onGroupDisplayedUnitsChangedHandler(groupName);
        }

        private void HideGroup(String groupName, bool isGroupHiddenFromGrid)
        {
            // prevent updates in the livegrid to raise event
            parseLiveGridEvents = false;

            List<Vehicle> vehicles = new List<Vehicle>();
            vehicles = (MainForm2.vehicleHT.Values.Cast<Vehicle>().ToList()).Where(x => x.group.Name.Equals(groupName)).ToList();

            // update the grid units on left map
            IEnumerable<DataforVehList> result = ListforVehList.Select(d => d).Where(d => (vehicles.Select(w => w.IMEI)).Contains(d.RadioId));
            foreach (DataforVehList ve in result)
            {
                ve.OnMap = false;
                ve.NrOfUpdates += 1;

                ((MapElement)((Vehicle)MainForm2.vehicleHT[ve.UnitName]).MapsHT[tabName]).itemCheck = false;
                ((MapElement)((Vehicle)MainForm2.vehicleHT[ve.UnitName]).MapsHT[tabName]).DeactivatePushpin();

                // change the value only if the group wasn't hidden from the grid
                if (!isGroupHiddenFromGrid)
                    VisualSettings.SetDisplayedInLiveTab(ve.SipId, false, tabName);
            }

            mapHandler.RemoveGroup(groupName);

            if (groupsHeadersByString.ContainsKey(groupName))
                groupsHeadersByString[groupName].checkbox.Checked = false;

            // update the header name
            onGroupDisplayedUnitsChangedHandler(groupName);

            // enable the event raising
            parseLiveGridEvents = true;
        }




        void SetTelem_Click(object sender, EventArgs e)
        {
            parent.Send_telem((String)gridVehicles.SelectedRows[0].Cells["UnitName"].Value, ((RadMenuItem)((RadMenuItem)sender).HierarchyParent).Text, 0);
        }

        async void AckAlarmForUnit_Click(object sender, EventArgs e)
        {

            try
            {
                //AlarmTypes type = (((Vehicle)MainForm2.vehicleHT[(String)gridVehicles.SelectedRows[0].Cells["UnitName"].Value])).EventLists.Contains;
                //AlarmTypes type = AlarmTypes.emergency;
                string unitName = (String)gridVehicles.SelectedRows[0].Cells["UnitName"].Value;
                int sc_id = (((Vehicle)MainForm2.vehicleHT[(String)gridVehicles.SelectedRows[0].Cells["UnitName"].Value])).sc_id;

                //dbalm = new DBalarmManager(MainForm2.cfg.DB_IP, MainForm2.cfg.DB_schema, MainForm2.cfg.DB_user, MainForm2.cfg.DB_passwd, MainForm2.cfg.DB_port);
                bool hasEmergencyActivated = dbalm.hasEmergencyActivated(sc_id);

                // ack async the alarms 
                await Task.Factory.StartNew(() => dbalm.ACKALLalarms(sc_id, MainForm2.userIDX));
                
                /*
                Thread t = new Thread(() =>
                    dbalm.ACKALLalarms(sc_id, MainForm2.userIDX));
                t.Start();
                */

                if (hasEmergencyActivated)
                {
                    ((Vehicle)MainForm2.vehicleHT[unitName]).is_emergency = false;
                    String Totrans = "#153#" + ((Vehicle)MainForm2.vehicleHT[unitName]).IMEI + "#" + (Int32)Status_for_tab.ON + "#";
                    parent.Send_UDP_cmd(Totrans, 0, 0);
                    Utils.WriteLine("Sending ALARM ACK to " + unitName);
                    //update GwandRadioID for current vehicle if is 0.0
                    ((Vehicle)MainForm2.vehicleHT[unitName]).CheckPositionInSystem();
                    Totrans = "#238#" + ((Vehicle)MainForm2.vehicleHT[unitName]).GwandRadioID + "."
                        + ((Vehicle)MainForm2.vehicleHT[unitName]).IMEI + "#";
                    parent.Send_UDP_cmd(Totrans, 0, 0);
                    Thread.Sleep(100);
                    MainForm2.UpdateStatusLive(unitName);

                    

                }

                String Totrans2 = "#238#" + ((Vehicle)MainForm2.vehicleHT[unitName]).GwandRadioID + "."
                        + ((Vehicle)MainForm2.vehicleHT[unitName]).IMEI + "#" + (int)AlarmTypes.unknown;
                parent.Send_UDP_cmd(Totrans2, 0, 0);

                //NEED TO DO SAME STUFF FROM PUT EMERGENCY IN RED
                foreach (String name in ((Vehicle)MainForm2.vehicleHT[unitName]).MapsHT.Keys)
                {
                    ((Vehicle)MainForm2.vehicleHT[unitName]).is_emergency = false;
                    ((MapElement)((Vehicle)MainForm2.vehicleHT[unitName]).MapsHT[name]).UpdateSymbol();
                    MainForm2.RemoveIconsFromMap();
                    
                    ((Vehicle)MainForm2.vehicleHT[unitName]).actual_status = Status_for_tab.ON;

                    onEmergencyStateChangedHandler((Vehicle)MainForm2.vehicleHT[unitName], false);
                }
                Thread.Sleep(100);
                MainForm2.UpdateStatusLive(unitName);
            }
            catch (Exception ex)
            {
                SM.Debug("EX:" + ex.ToString());
            }
            try
            {
                this.parent.AlarmTracking_Click(null, null);
                ((Vehicle)MainForm2.vehicleHT[(String)gridVehicles.SelectedRows[0].Cells["UnitName"].Value]).EventLists = new ArrayList();
            }
            catch (Exception ex)
            {
                SM.Debug("EX:" + ex.ToString());
            }
        }

        void ClearTelem_Click(object sender, EventArgs e)
        {
            parent.Send_telem((String)gridVehicles.SelectedRows[0].Cells["UnitName"].Value, ((RadMenuItem)((RadMenuItem)sender).HierarchyParent).Text, 1);
        }

        void TogTelem_Click(object sender, EventArgs e)
        {
            parent.Send_telem((String)gridVehicles.SelectedRows[0].Cells["UnitName"].Value, ((RadMenuItem)((RadMenuItem)sender).HierarchyParent).Text, 2);
        }

        void PulsTelem_Click(object sender, EventArgs e)
        {
            parent.Send_telem((String)gridVehicles.SelectedRows[0].Cells["UnitName"].Value, ((RadMenuItem)((RadMenuItem)sender).HierarchyParent).Text, 3);
        }

        void SendRadioEnable_Click(object sender, EventArgs e)
        {
            String unitName = (String)gridVehicles.SelectedRows[0].Cells["UnitName"].Value;
            parent.Send_EnableOrDisable(unitName, CMDTYPE.EnableCMD);
            parent.DisplayToast(unitName + MainForm2.returnLNGString("enableReq"),
                       string.Format(MainForm2.returnLNGString("enableReqHTML"), unitName));
        }

        void SendRadioDisable_Click(object sender, EventArgs e)
        {
            String unitName = (String)gridVehicles.SelectedRows[0].Cells["UnitName"].Value;
            parent.Send_EnableOrDisable((String)gridVehicles.SelectedRows[0].Cells["UnitName"].Value, CMDTYPE.DisableCMD);
            parent.DisplayToast(unitName + MainForm2.returnLNGString("disableReq"),
                       string.Format(MainForm2.returnLNGString("disableReqHTML"), unitName));
        }

        void SendStolen_Click(object sender, EventArgs e)
        {
            String unitName = (String)gridVehicles.SelectedRows[0].Cells["UnitName"].Value;
            parent.Send_EnableOrDisable((String)gridVehicles.SelectedRows[0].Cells["UnitName"].Value, CMDTYPE.StolenONCMD);
            parent.DisplayToast(unitName + MainForm2.returnLNGString("stolen"),
                      string.Format(MainForm2.returnLNGString("stolenHTML"), unitName));

            DataforVehList veh = (gridVehicles.SelectedRows[0].DataBoundItem as DataforVehList);
            if (veh != null)
            {
                gridVehicles.BeginEdit();
                veh.Stolen = true;
                veh.NrOfUpdates++;
                gridVehicles.EndEdit();
            }

        }

        void SendUNStolen_Click(object sender, EventArgs e)
        {
            String unitName = (String)gridVehicles.SelectedRows[0].Cells["UnitName"].Value;
            parent.Send_EnableOrDisable((String)gridVehicles.SelectedRows[0].Cells["UnitName"].Value, CMDTYPE.StolenOFFCMD);
            parent.DisplayToast(unitName + MainForm2.returnLNGString("unstolen"),
                       string.Format(MainForm2.returnLNGString("unstolenHTML"), unitName));

            DataforVehList veh = (gridVehicles.SelectedRows[0].DataBoundItem as DataforVehList);
            if (veh != null)
            {
                gridVehicles.BeginEdit();
                veh.Stolen = false;
                veh.NrOfUpdates++;
                gridVehicles.EndEdit();
            }

            parent.Send_EnableOrDisable(unitName, CMDTYPE.EnableCMD);
            parent.DisplayToast(unitName + MainForm2.returnLNGString("enableReq"),
                       string.Format(MainForm2.returnLNGString("enableReqHTML"), unitName));
        }

        void SendPOLLARS_Click(object sender, EventArgs e)
        {
            String unitName = (String)gridVehicles.SelectedRows[0].Cells["UnitName"].Value;
            parent.Send_EnableOrDisable((String)gridVehicles.SelectedRows[0].Cells["UnitName"].Value, CMDTYPE.POLLARSCMD);
            if (((RadMenuItem)sender).AccessibleName != MainForm2.returnLNGString("radcheck"))
                parent.DisplayToast(unitName + MainForm2.returnLNGString("pollReq"),
                           string.Format(MainForm2.returnLNGString("pollReqHTML"), unitName));

            else
                parent.DisplayToast(unitName + MainForm2.returnLNGString("radioOnlineCheckReq"),
               string.Format(MainForm2.returnLNGString("radioOnlineCheckReqHTML"), unitName));
        }


        /// <summary>
        /// Send the poll command on the message bus for the selected unit
        /// and then display it on the map 
        /// </summary>
        void SendPOLL_Click(object sender, EventArgs e)
        {
            try
            {
                // 2 -- POLL UNIT
                parent.Send_EnableOrDisable((String)gridVehicles.SelectedRows[0].Cells["UnitName"].Value, CMDTYPE.POLLGPSCMD);
                MainForm2.POLLunit = (String)gridVehicles.SelectedRows[0].Cells["UnitName"].Value;
                if ((Math.Round(((Vehicle)MainForm2.vehicleHT[MainForm2.POLLunit]).LAT) != 0) && (Math.Round(((Vehicle)MainForm2.vehicleHT[MainForm2.POLLunit]).LNG) != 0))
                {
                    if (((MapElement)(((Vehicle)MainForm2.vehicleHT[MainForm2.POLLunit]).MapsHT[tabName])).isActive) ;
                    else
                    {
                        gridVehicles.SelectedRows[0].Cells["onMap"].Value = true;
                        rbDisplay.PerformClick();
                    }
                }
                Thread.Sleep(1);
            }
            catch (Exception ex)
            {
                SM.Debug("EXLive11:" + ex.ToString());
            }
        }


        private System.Threading.Timer timerCheck = null;



        private void vehiclesList_CellClick(object sender, GridViewCellEventArgs e)
        {
            if (e.Column != null && e.Column.Name.Equals("onMap"))// e.ColumnIndex == 3)
            {
                SM.Debug("Fire the timer");
                if (timerCheck != null) timerCheck.Dispose();
                timerCheck = new System.Threading.Timer(VerifyChecks, null, 2000, 2000);
            }
        }



        //timer de verificat checkuri
        private void VerifyChecks(object state)
        {
            try
            {
                this.Invoke(new CheckOnInvokeCallBack(CheckOnInvoke2));
            }
            catch (Exception ex)
            {
                SM.Debug("ExLive15:" + ex.ToString());
            }
        }

        private void CheckOnInvoke2()
        {
            try
            {
                Boolean someCheck = false;
                gridVehicles.TableElement.BeginUpdate();
                gridVehicles.TableElement.EndUpdate(false);
                gridVehicles.TableElement.Update(GridUINotifyAction.DataChanged);
                gridVehicles.Refresh();
                String selectedValue = "";
                try
                {
                    selectedValue = (String)gridVehicles.SelectedRows[0].Cells["UnitName"].Value;
                }
                catch
                {
                    selectedValue = " ";
                }

                SM.Debug("Verify Check");
                CheckedGroupTmp.Clear();
                foreach (DataforVehList obj2 in (List<DataforVehList>)gridVehicles.DataSource)
                {
                    if ((obj2.OnMap) && (obj2.UnitName.CompareTo(selectedValue) != 0))
                    {
                        someCheck = true;
                        if (CheckedGroupTmp[obj2.GrpName] == null) CheckedGroupTmp.Add(obj2.GrpName, true);
                    }
                }

                for (int i = 0; i < gridVehicles.Groups.Count; i++)
                    if ((Boolean)CheckedGroup[i])
                    {
                        if (CheckedGroupTmp[gridVehicles.Groups[i].Header] == null)
                        {
                            int j = -1;
                            foreach (GridViewRowInfo row in this.gridVehicles.ChildRows)
                            {
                                j++;
                                GridViewGroupRowInfo groupRow = row as GridViewGroupRowInfo;
                                if ((groupRow != null) && (j == i))
                                {
                                    groupRow.Tag = false;
                                    CheckedGroup[i] = false;
                                    break;
                                }
                            }
                        }
                    }

                if ((sel_desel.Checked) && (!someCheck))
                {
                    SM.Debug("Select all false");
                    sel_desel.Checked = false;
                }
                if (timerCheck != null) timerCheck.Dispose();
            }
            catch (Exception ex)
            {
                SM.Debug("Error backtop play" + ex.ToString());
            }
        }

        public delegate void CheckOnInvokeCallBack();



        /// <summary>
        /// Show or hide Landmarks on the map
        /// </summary>
        private void ckShowLand_ToggleStateChanged(object sender, StateChangedEventArgs args)
        {
            Utils.WriteLine("ckShowLand_ToggleStateChanged " + (ckShowLand.Checked ? "checked" : "not checked"));

            if (ckShowLand.Checked)
            {
                // Process the list of files found in the directory. 
                if (LandZoneCfg.landmarkTypesList == null)
                    LandZoneCfg.landmarkTypesList = smdbObj.GetAllLandmarkTypes();

                List<LandmarkUI> landmarks = smdbObj.GetAllLandmarks();
                mapHandler.ShowLandmarks(landmarks);
                
            }
            //DisplayAllLandmarksOnMap();
            else
            {
                mapHandler.RemoveLandmarks();
            }
            //HideAllLandmarksOnMap();

            if (isFilterLoaded)
                VisualSettings.InsertUpdateHTforVisualItems(tabName, ((RadCheckBox)sender).Name, ((RadCheckBox)sender).Checked.ToString());
        }


        /// <summary>
        /// Show or hide geofences on the map
        /// </summary>
        private void ckShowZone_ToggleStateChanged(object sender, StateChangedEventArgs args)
        {
            try
            {
                Utils.WriteLine("ckShowZone_ToggleStateChanged " + (ckShowZone.Checked ? "checked" : "not checked"));

                //mapGoogles.ExecuteScript("window.GWTcallback('showconsole,true');");
                if (ckShowZone.Checked)
                {
                    List<GeofenceUI> allGeofences = smdbObj.GetAllGeofences();
                    mapHandler.ShowGeofences(allGeofences);
                  
                }
                //ForceShowZone();
                else
                {
                    mapHandler.RemoveGeofences();
                }
                //ForceHideZone();
                if (isFilterLoaded)
                {
                    VisualSettings.InsertUpdateHTforVisualItems(tabName, ((RadCheckBox)sender).Name, ((RadCheckBox)sender).Checked.ToString());
                }
            }
            catch (Exception ex)
            {
                Utils.WriteLine("ExLive13:" + ex.ToString());
            }
        }


        /// <summary>
        /// Display the geofences on the map
        /// </summary>
        public void ForceShowZone()
        {
            try
            {
                Boolean First = true;
                Int32 pas = -1;
                if (MainForm2.ZoneIDHash.Count > 1)
                {
                    pas = 0;
                    ZoneGoogle = MainForm2.ZoneIDHash.Count;
                }
                Double LatMN = 0, LatMX = 0, LngMN = 0, LngMX = 0;

                if (MainForm2.ZoneIDHash.Count > 0)
                {
                    if (cornersDataSet != null)
                    {
                        cornersDataSet.Delete();
                        cornersDataSet = null;
                    }
                    //cornersDataSet = mapControl.ActiveMap.DataSets.AddPushpinSet("colturiSafe");
                }
                First = true;

                Boolean first = true;
                Double latfirst = 0, lngfirst = 0;
                int cont = 0;
                Boolean retur = false;
                if (docLoad)
                {
                    mapGoogles.ExecuteScript("window.GWTcallback('" + "deletePolygon,ALL');");
                }

                List<GeofenceUI> allGeofences = smdbObj.GetAllGeofences();

                foreach(GeofenceUI geofence in allGeofences)
                {
                    String datasetCMD = "";
                    foreach (GeofencePoint point in geofence.points)
                    {
                        datasetCMD = datasetCMD
                            + MainForm2.FixDoubleLAT(point.Latitude + "") + ","
                            + MainForm2.FixDoubleLNG(point.Longitude + "") + ",";
                    }

                    // get geofence fill color
                    String hexFillColor = "#" + geofence.FillColor.R.ToString("X2") + geofence.FillColor.G.ToString("X2") + geofence.FillColor.B.ToString("X2");
                    String hexBorderColor = "#" + geofence.BorderColor.R.ToString("X2") + geofence.BorderColor.G.ToString("X2") + geofence.BorderColor.B.ToString("X2");
                    try
                    {
                        datasetCMD = datasetCMD.Remove(datasetCMD.Length - 1);
                    }
                    catch (Exception ex) { SM.Debug("Ex:" + ex.ToString()); }

                    if (docLoad)
                    {
                        mapGoogles.ExecuteScript("window.GWTcallback('" + "setPolygon,"
                              + geofence.Name + ","
                              + hexFillColor + ","
                              + MainForm2.FixDoubleLAT(geofence.FillOpacity.ToString()) + ","
                              + hexBorderColor + ","
                              + MainForm2.FixDoubleLAT(geofence.BorderOpacity.ToString()) + ","
                              + MainForm2.FixDoubleLAT(geofence.BorderWidth.ToString()) + ","
                              + datasetCMD + "');");
                        //mapGoogles.ExecuteScript("window.GWTcallback('" + "removelabels,"+datasetCMD + "');");  
                    }
                    System.Threading.Thread.Sleep(10);
                }

                parent.DisplayToast(MainForm2.returnLNGString("geofenceDisplayed"),
                       "<html><b>" + allGeofences.Count + "  " + MainForm2.returnLNGString("geofences") + "  </b> " + MainForm2.returnLNGString("mapdisp") + " </html>");

            }
            catch (Exception ex)
            {
                SM.Debug("Error zone preview:" + ex.ToString());
            }
        }



        private Int32 ZoneGoogle = 0;
        /// <summary>
        /// Hide all the geofences on the map
        /// </summary>
        public void ForceHideZone()
        {
            try
            {
                if (docLoad)
                {
                    mapGoogles.ExecuteScript("window.GWTcallback('" + "deletePolygon,ALL');");
                }
            }
            catch (Exception ex)
            {
                SM.Debug("Unable to remove zones from map " + ex.ToString());
            }
        }
        private MapGoogle.DataSetx cornersDataSet;



        /// <summary>
        /// Format the unit number which is displayed on the groups header
        /// </summary>
        private void vehiclesList_GroupSummaryEvaluate(object sender, GroupSummaryEvaluationEventArgs e)
        {
            try
            {
                string suff = String.Concat(" (", e.Group.ItemCount.ToString(), ")");
                e.Group.Header = e.Group.Key + "" + getGroupHeaderCount(e.Group.Key.ToString());
                
                e.FormatString = e.Group.Header;
            }
            catch (Exception ex)
            {
                SM.Debug("Erorr on GroupSummaryEvaluate" + ex.ToString());
            }
        }



        private void toolWindow2_Resize(object sender, EventArgs e)
        {
            int diffHeight, diffWidth;
            Control control = (Control)sender;
            diffHeight = control.Size.Height / 2;
            diffWidth = control.Size.Width / 2;
            diffHeight = diffHeight - 50;
            diffWidth = diffWidth - 120;
            if ((diffHeight > 0) && (diffWidth > 0))
                LivePanel.Location = new System.Drawing.Point(diffWidth, diffHeight);
        }

        volatile Boolean PingFinish = false;
        volatile Boolean PingGoogle = false;

        private Boolean firstLoad = true;
        DimensionsGoogle GoogleSize = null;

        private void sendPOLLARSToolStripMenuItem_Click(object sender, EventArgs e)
        {
            try
            {
                smdbObj.Send_cmd_to_val(false, ((Vehicle)MainForm2.vehicleHT[(String)gridVehicles.SelectedRows[0].Cells[2].Value]).IMEI, "");
            }
            catch (Exception ex)
            {
                SM.Debug("Cann't send POLL cmd" + ex.ToString());
            }
        }
        
        private Font normalFont = new Font(new FontFamily("Segoe UI"), 10.0F, FontStyle.Regular);
        private Font boldFont = new Font(new FontFamily("Segoe UI"), 10.0F, FontStyle.Bold);
        private void vehiclesList_ViewCellFormatting(object sender, CellFormattingEventArgs e)
        {
            if ((MainForm2.radioType == RADIOTYPE.HARRIS) || (MainForm2.radioType == RADIOTYPE.ATLAS))
            {
                if (e.CellElement is GridGroupContentCellElement)
                {
                    e.CellElement.ForeColor = MainForm2.HarTextColor;
                }
                else
                {
                    e.CellElement.ResetValue(LightVisualElement.ForeColorProperty, ValueResetFlags.Local);
                }
            }

            if (e.CellElement.RowInfo.Group == null && (e.CellElement is GridSummaryCellElement || e.CellElement is GridGroupContentCellElement))
            {
                e.CellElement.ForeColor = Color.Red;
                e.CellElement.TextAlignment = ContentAlignment.MiddleCenter;
                e.CellElement.Font = new Font("Microsoft Sans Serif", 13,
               FontStyle.Bold,
               GraphicsUnit.Pixel);
            }

            if (e.CellElement.RowIndex >= 0)
            {
                //SM.Debug("VALUE OF THE BOX" + Convert.ToInt32(vehiclesList.Rows[e.CellElement.RowIndex].Cells[5].Value));
                //if (Convert.ToInt32(vehiclesList.Rows[e.CellElement.RowIndex].Cells[5].Value) == 1)
                if (Convert.ToInt32(e.Row.Cells["Emerg0off1on"].Value) == 1)
                {
                    e.CellElement.ForeColor = Color.Red;
                    e.CellElement.Font = boldFont;
                }
                else
                {
                    e.CellElement.ForeColor = Color.Black;
                    e.CellElement.Font = normalFont;
                }
            }
        }


        /// <summary>
        /// Event handler for when the groupBox checkbox changes its state
        /// </summary>
        [ChangesAtrribute("4 Nov 2016", "Fix Select/Deselect all not triggering for all groups [Group.Headers -> Group.Key]")]
        private void GroupCheckBox_StateChanged(object sender, GRPEventArgs e)
        {
            List<String> unitsThatAreInTheGroup = new List<string>();
            List<Vehicle> toDisplayVehicles = new List<Vehicle>();

            bool actionCancelled = false;
            try
            {
                String groupName = gridVehicles.Groups[e.idx].Key.ToString();
                int nrstartPerf = 0;
                bool StartPerf = false;
                centeredState = false;
                //Utils.WriteLine("GroupCheckBox_StateChanged idx " + e.idx + "  |   " + gridVehicles.Groups[e.idx].Header + "   |  " + (e.stat ? "checked " : "uncheked"));
                //if (e.stat != (Boolean)CheckedGroup[e.idx])
                {
                    CheckedGroup[e.idx] = e.stat;

                    if (e.stat == true)
                    {
                        List<Vehicle> vehicles = new List<Vehicle>();
                        vehicles = (MainForm2.vehicleHT.Values.Cast<Vehicle>().ToList()).Where(x => x.group.Name.Equals(groupName)).ToList();

                        // detect how many vehicles are displayed
                        List<Vehicle> displayedVehicles = vehicles.Select(d => d).Where(d => ((MapElement)d.MapsHT[tabName]).itemCheck).ToList();

                        toDisplayVehicles = vehicles.Where(w => !((MapElement)w.MapsHT[tabName]).itemCheck).ToList();

                        // number of units from this group that are not displayed
                        int toDisplayUnitsFromThisGroup = vehicles.Count - displayedVehicles.Count;

                        if (rseUnitsOnMap.Value < getNumberOfDisplayedUsers() + toDisplayUnitsFromThisGroup)
                        {
                            if (getMaxUnitsWarningDialogResult(toDisplayUnitsFromThisGroup, getNumberOfDisplayedUsers() + toDisplayUnitsFromThisGroup, (Int64)rseUnitsOnMap.Value) != DialogResult.Yes)
                            {
                                CustomGroupHeaderCell.CheckBoxClicked = false;
                                if (groupsHeadersByString.ContainsKey(groupName))
                                    groupsHeadersByString[groupName].checkbox.Checked = false;
                                actionCancelled = true;
                            }
                            else
                                rseUnitsOnMap.Value = getNumberOfDisplayedUsers() + toDisplayUnitsFromThisGroup;
                        }
                    }

                    if (!actionCancelled)
                    {

                        //SM.Debug("Send command to google");

                        //gridVehicles.TableElement.BeginUpdate();
                        //timerBegin = new System.Threading.Timer(MakeUpdateToListBegin, null, 300, System.Threading.Timeout.Infinite);

                        for (int contor = 0; contor < gridVehicles.Rows.Count; contor++)
                        {
                            // get current vehicle which is updated
                            Vehicle vehicleTemp = (Vehicle)MainForm2.vehicleHT[(String)gridVehicles.Rows[contor].Cells["UnitName"].Value];

                            // get the Data bound item for each grid row
                            DataforVehList gridData = gridVehicles.Rows[contor].DataBoundItem as DataforVehList;

                            // verify if the unit is valid or not 
                            if (gridData != null)
                            {
                                bool isInThisGroup = false;

                                if (groupType == GroupType.STATUS && gridData.Status.Equals(groupName))
                                {
                                    //Utils.WriteLine("THIS UNIT " + gridData.UnitName + " IS IN THIS GROUP " + gridVehicles.Groups[e.idx].Header, ConsoleColor.Red);
                                    isInThisGroup = true;
                                }
                                else if (groupType == GroupType.GROUPNAME && gridData.GrpName.Equals(groupName))
                                {
                                    //Utils.WriteLine("THIS UNIT " + gridData.UnitName + " IS IN THIS GROUP " + gridVehicles.Groups[e.idx].Key, ConsoleColor.Yellow);
                                    isInThisGroup = true;
                                }
                                else if (groupType == GroupType.POSITIONTIMEAGO && gridData.PositionTimeAgo.Equals(groupName))
                                {
                                    //Utils.WriteLine("THIS UNIT " + gridData.UnitName + " IS IN THIS GROUP " + gridVehicles.Groups[e.idx].Header, ConsoleColor.Cyan);
                                    isInThisGroup = true;
                                }


                                // make modifications only if the unit is in the group
                                if (isInThisGroup)
                                {
                                    VisualSettings.SetDisplayedInLiveTab(gridData.SipId, e.stat, tabName);

                                    if (!gridData.OnMap && e.stat)
                                    {
                                        nrstartPerf++;
                                        gridData.OnMap = true;
                                        // notify that an update must be made
                                        gridData.NrOfUpdates = gridData.NrOfUpdates + 1;
                                        ((MapElement)((Vehicle)MainForm2.vehicleHT[gridData.UnitName]).MapsHT[tabName]).itemCheck = true;
                                        ((MapElement)((Vehicle)MainForm2.vehicleHT[gridData.UnitName]).MapsHT[tabName]).ActivatePushPin();

                                        unitsThatAreInTheGroup.Add(gridData.UnitName);
                                    }
                                    else if (!e.stat && gridData.OnMap)
                                    {
                                        gridData.OnMap = false;
                                        ((MapElement)((Vehicle)MainForm2.vehicleHT[gridData.UnitName]).MapsHT[tabName]).itemCheck = false;
                                        // notify that an update must be made
                                        gridData.NrOfUpdates = gridData.NrOfUpdates + 1;

                                        if (((MapElement)((Vehicle)MainForm2.vehicleHT[gridData.UnitName]).MapsHT[tabName]).pp != null)
                                        {
                                            ((MapElement)((Vehicle)MainForm2.vehicleHT[gridData.UnitName]).MapsHT[tabName]).pp.Highlight = false;
                                            ((MapElement)((Vehicle)MainForm2.vehicleHT[gridData.UnitName]).MapsHT[tabName]).pp.BalloonState = GeoBalloonStatex.geoDisplayNone;
                                            ((MapElement)((Vehicle)MainForm2.vehicleHT[gridData.UnitName]).MapsHT[tabName]).DeactivatePushpin();
                                            if (((Vehicle)MainForm2.vehicleHT[gridData.UnitName]).selectCenter)
                                            {
                                                ((Vehicle)MainForm2.vehicleHT[gridData.UnitName]).selectCenter = false;
                                                centeredState = false;
                                            }
                                        }

                                        unitsThatAreInTheGroup.Add(gridData.UnitName);
                                    }
                                }

                            }
                        }

                        // if group is selected
                        if (e.stat)
                        {
                            if (StartPerf)
                            {
                                txProgStatus.Clear();
                                Console.WriteLine("Panel visibil false 3");
                                LivePanel.Visible = false;
                                //LiveWaitingBar.Visible = false;
                                txProgStatus.Visible = false;
                                Cursor = System.Windows.Forms.Cursors.Arrow;
                                mapControl.MousePointer = GeoPointerx.geoPointerDefault;
                            }
                        }

                        //gridVehicles.TableElement.EndUpdate(false);
                        //gridVehicles.TableElement.Update(GridUINotifyAction.DataChanged);


                        if (e.stat)
                        {
                            mapHandler.AddGroup(groupName, toDisplayVehicles, false);
                        }
                        else
                            mapHandler.RemoveGroup(groupName);
                        
                        // update the header name
                        onGroupDisplayedUnitsChangedHandler(groupName);
                    }

                }
            }
            catch (Exception ex)
            {
                SM.Debug("Error on select ALL: " + ex.ToString());
            }
        }



        private void vehiclesList_DataBindingComplete(object sender, GridViewBindingCompleteEventArgs e)
        {
            gridVehicles.TableElement.ScrollToRow(0);
        }


        volatile Boolean newrowUpdated = false;
        volatile RadSortOrder oldSortType = RadSortOrder.Ascending;
        volatile Int32 oldColomnSort = 0;
        /// <summary>
        /// Event handler for when a position row needs to be updated
        /// or the timmer expired
        /// </summary>
        private void NewRowUpdated_Tick(object sender, EventArgs e)
        {
            try
            {
                if (newrowUpdated)
                {
                    for (int i = 0; i < 10; i++)
                    {
                        if (tableVehiclesList.Columns[i].SortOrder != RadSortOrder.None)
                        {
                            oldColomnSort = i;
                            oldSortType = tableVehiclesList.Columns[i].SortOrder;
                            tableVehiclesList.Columns[i].SortOrder = RadSortOrder.None;
                            break;
                        }
                    }
                    tableVehiclesList.TableElement.Update(GridUINotifyAction.DataChanged);
                    tableVehiclesList.Refresh();
                    //refresh pe order after
                    tableVehiclesList.Columns[oldColomnSort].SortOrder = oldSortType;
                }
                newrowUpdated = false;
            }
            catch (Exception ex)
            {
                Console.WriteLine("Error on update rows:" + ex.ToString());
            }
        }



        private void tableVehiclesList_DataBindingComplete(object sender, GridViewBindingCompleteEventArgs e)
        {
            TableViewDataComplete = true;
        }

        private void tableVehiclesList_SortChanged(object sender, GridViewCollectionChangedEventArgs e)
        {
            TableViewSortComplete = true;
        }


        
        /// <summary>
        /// Event handler to check if the map has loaded after five seconds
        /// </summary>
        private void TimerLoad5Sec_Tick(object sender, EventArgs e)
        {
            if (WaitWindow!= null && WaitWindow.Visible)
            {
                try
                {
                    SM.Debug("Timer started for Load5Seconds");
                    mapControl.RefreshMap(LiveMapPanel.Height, LiveMapPanel.Width);
                    PingGoogle = true;
                    PingFinish = true;
                    GoogleSize = new DimensionsGoogle(LiveMapPanel.Width, LiveMapPanel.Height);
                    TimerToLoadMap.Enabled = true;
                    TimerToLoadMap.Start();
                    docLoad = true;
                    firstLoad = false;
                }

                catch (Exception ex)
                {
                    SM.Debug("Error to lateresize:" + ex.ToString());
                }
            }

            TimerLoad3Sec.Stop();
            
        }


        Int32 nrtrys = 0;
        private void ForceRefreshTimer_Tick(object sender, EventArgs e)
        {
            nrtrys++;
            if (nrtrys > 3)
            {
                ForceRefreshTimer.Stop();
                ForceRefreshTimer.Enabled = false;
            }
        }
        private WaitToLoad WaitWindow = null;
        private void MessageScreen_Tick(object sender, EventArgs e)
        {
            try
            {
                MessageScreen.Stop();
                MessageScreen.Enabled = false;
                WaitWindow = new WaitToLoad(false);
                WaitWindow.ShowDialog();
            }
            catch (Exception ex)
            {
                SM.Debug("Ex10:" + ex.ToString());
            }
        }



        private void ForceLogin_Tick(object sender, EventArgs e)
        {
            if (MainForm2.forceLogin)
            {
                sel_desel.Checked = true;
                rbDisplay.PerformClick();
            }

            ForceLogin.Stop();
            ForceLogin.Enabled = false;
        }



        /// <summary>
        /// Open a popup window which will desplay the desired info 
        /// </summary>
        /// <param name="unitName"></param>
        /// <param name="popupType"></param>
        private void openPopupWindow(string unitName, EventType popupType)
        {
            try
            {
                if (MainForm2.PopupOpen[((Vehicle)MainForm2.vehicleHT[unitName]).IMEI] == null)
                {
                    ((Vehicle)MainForm2.vehicleHT[unitName]).CheckPositionInSystem();
                    FastCommandWindow frmPop = new FastCommandWindow(unitName, ((Vehicle)MainForm2.vehicleHT[unitName]).IMEI, parent, popupType, smdbObj.get_all_DefSMS()) 
                    {
                        has_text = ((Vehicle)MainForm2.vehicleHT[unitName]).has_text,
                        has_voice = ((Vehicle)MainForm2.vehicleHT[unitName]).has_voice
                    };
                    if (MainForm2.HasVoice)
                    {
                        if (parent.VoiceFirstTime)
                            parent.First_time_start_radio();
                        frmPop.gwandradID = ((Vehicle)MainForm2.vehicleHT[unitName]).GwandRadioID;
                        frmPop.checkStatus();
                    }
                    else frmPop.DisablePTT();
                    frmPop.Show();
                    MainForm2.PopupOpen.Add(((Vehicle)MainForm2.vehicleHT[unitName]).IMEI, frmPop);
                }
                else 
                {
                    // the tab is already opened so it needs to change the tab
                    FastCommandWindow frmPop = (FastCommandWindow)MainForm2.PopupOpen[((Vehicle)MainForm2.vehicleHT[unitName]).IMEI];
                    frmPop.SelectTab(popupType);
                    frmPop.Activate();
                }

            }
            catch (Exception ex)
            {
                SM.Debug("Cann't show new PopupWindow form" + ex.ToString());
            }
        }

        private DialogResult getMaxUnitsWarningDialogResult(Int64 toDisplayVehiclesCount, Int64 totalDisplayed, Int64 displayedLimit )
        {
            RadMessageBox.Instance.Dispose();
            RadMessageBox.SetThemeName("TelerikMetroBlue");
            return RadMessageBox.Show(String.Format(MainForm2.returnLNGString("warningMaxNumberOfUnits"), toDisplayVehiclesCount,
                totalDisplayed, displayedLimit), MainForm2.returnLNGString("war"), MessageBoxButtons.YesNo);
        }

        private Dictionary<string, CustomGroupHeaderCell> groupsHeadersByString = new Dictionary<string, CustomGroupHeaderCell>();
        /// <summary>
        /// Set the type of data which will be displayed inside the grid 
        /// </summary>
        private void gridVehicles_CreateCell(object sender, GridViewCreateCellEventArgs e)
        {

            // format live column
            if (e.Row is GridDataRowElement)
            {
                // increase row height
                //e.Row.RowInfo.Height = 53;

                if (e.Column.Name.Equals("live"))
                {
                    e.CellType = typeof(LiveGridColumn);
                    e.CellElement = new LiveGridCellElement(e.Column, e.Row);

                    /*
                    // set the value for the cell
                    if (e.Row.Data != null && e.Row.Data.DataBoundItem != null &&
                        e.Row.Data.DataBoundItem is DataforVehList)
                        e.CellElement.Value = e.Row.Data.DataBoundItem as DataforVehList;*/
                }

                if (e.Column is GridViewIndentColumn)
                {
                    //e.Column.IsVisible = false;

                    /*
                    e.Column.MaxWidth = 7;
                    e.Column.MinWidth = 7;
                    e.Column.Width = 7;*/
                    //e.CellElement.Visibility = ElementVisibility.Hidden;
                }
            }
        }


        /// <summary>
        /// Format the cells of live units to the custom format, including padding
        /// </summary>
        private void gridVehicles_CellFormatting(object sender, CellFormattingEventArgs e)
        {
            GridCellElement cellElement = e.CellElement;
            GridViewDataColumn columnInfo = e.CellElement.ColumnInfo as GridViewDataColumn;

            // set padding and force the content adding
            if (cellElement is LiveGridCellElement && columnInfo.Name == "live")
            {
                cellElement.Padding = new Padding(0, 0, 0, 0);
                //cellElement.SetContent();

                // add click listener only if not added before
                if ((cellElement.Tag != null && !cellElement.Tag.Equals("done")) || cellElement.Tag == null)
                {
                    ((LiveGridCellElement)cellElement).OnLiveCell_Click += delegate(object s, LiveGridCellElement.LiveCellClickEventArgs ea)
                    {
                        //Utils.WriteLine("CLICKED " + ea.gridData.UnitName + " | " + ea.eventType, ConsoleColor.Red);
                        /*
                        Vehicle veh = (Vehicle)MainForm2.vehicleHT[ea.gridData.UnitName];
                        ea.gridData.Latitude = veh.LAT;
                        ea.gridData.Longitude = veh.LNG;
                        ea.gridData.Speed = veh.GetSpeed();
                        ea.gridData.PositionTime = new DateTime(veh.lastValidPositionTime);
                        */

                        // skip the wvent while the map isn't loaded
                        if (!mapLoaded)
                            return;
                        

                        switch (ea.eventType)
                        {
                            // update the units which are displayed on the map
                            case EventType.DISPLAY:
                                {
                                    VisualSettings.SetDisplayedInLiveTab(ea.gridData.SipId, ea.gridData.OnMap, tabName);
                                    // display the car on the map and then notify the change
                                    if (docLoad && ea.gridData.OnMap)
                                    {
                                        ((MapElement)((Vehicle)MainForm2.vehicleHT[ea.gridData.UnitName]).MapsHT[tabName]).itemCheck = true;
                                        ((MapElement)((Vehicle)MainForm2.vehicleHT[ea.gridData.UnitName]).MapsHT[tabName]).ActivatePushPin();

                                        MainForm2.SendDataToMapQUE.PostItem(ea.gridData.UnitName);
                                        try
                                        {
                                            if (MainForm2.SendDataToMapHASH[ea.gridData.UnitName] == null)
                                                MainForm2.SendDataToMapHASH.Add(ea.gridData.UnitName, 0);
                                        }
                                        catch(Exception ex) { Utils.WriteLine(ex.ToString(), ConsoleColor.Red); }

                                        // TODO check if the entire group is checked or not and update the group checkbox
                                        List<Vehicle> vehicles = new List<Vehicle>();
                                        vehicles = (MainForm2.vehicleHT.Values.Cast<Vehicle>().ToList()).Where(x => x.group.Name.Equals(ea.gridData.GrpName)).ToList();

                                        // detect how many vehicles are displayed
                                        List<Vehicle> notDisplayedVehicles = vehicles.Where(w => ((MapElement)w.MapsHT[tabName]).itemCheck == false).ToList();

                                        // check the checkbox for the group if all the units are checked
                                        if(notDisplayedVehicles.Count == 0 && groupsHeadersByString.ContainsKey(ea.gridData.GrpName))
                                            groupsHeadersByString[ea.gridData.GrpName].checkbox.Checked = true;


                                        if (parseLiveGridEvents)
                                        {
                                            Vehicle veh = ((Vehicle)MainForm2.vehicleHT[ea.gridData.UnitName]);
                                            mapHandler.AddVehicles(new List<Vehicle>() { veh }, false);
                                        }
                                    }
                                    else
                                    {
                                        ((MapElement)((Vehicle)MainForm2.vehicleHT[ea.gridData.UnitName]).MapsHT[tabName]).itemCheck = false;
                                        ((MapElement)((Vehicle)MainForm2.vehicleHT[ea.gridData.UnitName]).MapsHT[tabName]).DeactivatePushpin();

                                        List<Vehicle> vehicles = new List<Vehicle>();
                                        vehicles = (MainForm2.vehicleHT.Values.Cast<Vehicle>().ToList()).Where(x => x.group.Name.Equals(ea.gridData.GrpName)).ToList();

                                        // detect how many vehicles are displayed
                                        List<Vehicle> displayedVehicles = vehicles.Select(d => d).Where(d => ((MapElement)d.MapsHT[tabName]).itemCheck).ToList();

                                        // uncheck the checkbox for the group
                                        if(groupsHeadersByString.ContainsKey(ea.gridData.GrpName))
                                            groupsHeadersByString[ea.gridData.GrpName].checkbox.Checked = false;

                                        if (parseLiveGridEvents && displayedVehicles.Count > 0)
                                            mapHandler.RemoveVehicles(new List<Vehicle>() { ((Vehicle)MainForm2.vehicleHT[ea.gridData.UnitName]) });
                                        else
                                            mapHandler.RemoveGroup(ea.gridData.GrpName);
                                        
                                    }
                                    // update the header name
                                    onGroupDisplayedUnitsChangedHandler(ea.gridData.GrpName);
                                }
                                //rbDisplay.PerformClick();
                                break;
                            case EventType.CENTER:
                                {
                                    

                                    // display the car on the map and then notify the change
                                    if (docLoad && !ea.gridData.OnMap)
                                    {

                                        ea.gridData.OnMap = true;
                                        ea.gridData.NrOfUpdates += 1;

                                        ((MapElement)((Vehicle)MainForm2.vehicleHT[ea.gridData.UnitName]).MapsHT[tabName]).itemCheck = true;
                                        ((MapElement)((Vehicle)MainForm2.vehicleHT[ea.gridData.UnitName]).MapsHT[tabName]).ActivatePushPin();

                                        MainForm2.SendDataToMapQUE.PostItem(ea.gridData.UnitName);
                                        try
                                        {
                                            if (MainForm2.SendDataToMapHASH[ea.gridData.UnitName] == null)
                                                MainForm2.SendDataToMapHASH.Add(ea.gridData.UnitName, 0);
                                        }
                                        catch(Exception ex) { Utils.WriteLine(ex.ToString(), ConsoleColor.Red); }

                                        Vehicle veh = ((Vehicle)MainForm2.vehicleHT[ea.gridData.UnitName]);
                                        // TODO check if the entire group is checked or not and update the group checkbox
                                        mapHandler.AddVehicles(new List<Vehicle>() { veh }, true);
                                      
                                        // update the header name
                                        onGroupDisplayedUnitsChangedHandler(ea.gridData.GrpName);
                                    }

                                    VisualSettings.SetDisplayedInLiveTab(ea.gridData.SipId, ea.gridData.OnMap, tabName);

                                    // open info buble
                                    if (docLoad && ea.gridData.OnMap)
                                    {
                                        if ((ea.gridData.Latitude != 0 && ea.gridData.Latitude != 0.1) ||
                                            (ea.gridData.Longitude != 0 && ea.gridData.Longitude != 0.1))
                                        {
                                            /*
                                            SM.Debug("Send open info");
                                            mapGoogles.ExecuteScript("window.GWTcallback('" + "openInfo," + ea.gridData.UnitName + "');");
                                            Thread.Sleep(50);
                                            mapGoogles.ExecuteScript("window.GWTcallback('centerzoom," + MainForm2.FixDoubleLAT(ea.gridData.Latitude + "") + ","
                                                + MainForm2.FixDoubleLNG(ea.gridData.Longitude + "") + ",-1');");
                                            Thread.Sleep(1);
                                            */
                                            if (mapHandler.IsUnitDisplaydOnMap(ea.gridData.UnitName))
                                            {
                                                mapHandler.OpenInfoBubble(ea.gridData.UnitName);
                                                Thread.Sleep(50);
                                                mapHandler.CenterMapToPosition(new LatLngZoom()
                                                {
                                                    Lat = ea.gridData.Latitude,
                                                    Lng = ea.gridData.Longitude,
                                                    ZoomLevel = -1
                                                });
                                            }
                                            else
                                                parent.DisplayToast(MainForm2.returnLNGString("noGPS"), MainForm2.returnLNGString("HTMLnoGPS"));
                                        }
                                        else
                                        {
                                            parent.DisplayToast(MainForm2.returnLNGString("noGPS"), MainForm2.returnLNGString("HTMLnoGPS"));
                                        }

                                    }
                                    break;
                                }

                            case EventType.ALERT:
                                {
                                    /*
                                    // trigger the event up one level
                                    if (OnAlertRequiredReceived != null)
                                        OnAlertRequiredReceived(new AlertRequiredEventArgs() { gridData = ea.gridData });
                                    break;
                                     * */
                                    openPopupWindow(ea.gridData.UnitName, EventType.ALERT); 
                                    break;
                                }
                            case EventType.TEXT:
                                {
                                    openPopupWindow(ea.gridData.UnitName, EventType.TEXT);
                                    break;
                                }
                            case EventType.VOICE:
                                {
                                    openPopupWindow(ea.gridData.UnitName, EventType.VOICE);
                                    break;
                                }
                        }
                    };
                }

                cellElement.Tag = "done";
            }
        }



        private bool positionsWindowIsActive = false;
        /// <summary>
        /// Refresh the positions list only when the Window is entered
        /// </summary>
        private void windowPositions_Enter(object sender, EventArgs e)
        {
            positionsWindowIsActive = true;
            
            // get the address based on the positionss
            rbDisplay.PerformClick();

            RefreshPositionsGrid();
        }

        /// <summary>
        /// Flag when the positions windows doesn't need to be refreshed anymore
        /// </summary>
        private void windowPositions_Leave(object sender, EventArgs e)
        {
            // flag that the windows was left
            positionsWindowIsActive = false;
        }

        /// <summary>
        /// Refresh the grid of positions 
        /// </summary>
        public void RefreshPositionsGrid()
        {
            // invoke the method in UI Thread if needed
            if (this.InvokeRequired)
            {
                this.Invoke((MethodInvoker)delegate ()
                    {
                        RefreshPositionsGrid();
                    });
            }


            Int32 oldColomnSort = 0;
            RadSortOrder oldSortType = RadSortOrder.Ascending;
            Vehicle vehicleTemp;
            tableVehiclesList.BeginUpdate();
            ListforGrid.Clear(); //aici e combinatia fatala
            try
            {
                for (int i = 0; i < tableVehiclesList.Columns.Count; i++)
                {
                    if (tableVehiclesList.Columns[i].SortOrder != RadSortOrder.None)
                    {
                        oldColomnSort = i;
                        oldSortType = tableVehiclesList.Columns[i].SortOrder;
                        break;
                    }
                }
            }
            catch (Exception ex)
            {
                SM.Debug("Error on finding the sort column:" + ex.ToString());
            }
            tableVehiclesList.Columns["VehName"].SortOrder = RadSortOrder.None;
            tableVehiclesList.Columns["datetime"].SortOrder = RadSortOrder.None;
            tableVehiclesList.Columns["address"].SortOrder = RadSortOrder.None;
            tableVehiclesList.Columns["speed"].SortOrder = RadSortOrder.None;
            tableVehiclesList.Columns["head"].SortOrder = RadSortOrder.None;
            tableVehiclesList.Columns["di"].SortOrder = RadSortOrder.None;
            tableVehiclesList.Columns["do"].SortOrder = RadSortOrder.None;
            tableVehiclesList.Columns["lat"].SortOrder = RadSortOrder.None;
            tableVehiclesList.Columns["lng"].SortOrder = RadSortOrder.None;
            tableVehiclesList.Columns["zone"].SortOrder = RadSortOrder.None;
            tableVehiclesList.Columns["Altitude"].SortOrder = RadSortOrder.None;
            Thread.Sleep(100);

            int countlist = -1;
            String LatStr = "";
            String LngStr = "";
            String AltStr = "";
            String Zone;
            Double LatDou, LngDou;

            // flag that an update will be made
            //gridVehicles.TableElement.BeginUpdate();

            //ListforGrid.Clear();
            for (int contor = 0; contor < gridVehicles.Rows.Count; contor++)
            {
                // get current vehicle which is updated
                vehicleTemp = (Vehicle)MainForm2.vehicleHT[(String)gridVehicles.Rows[contor].Cells["UnitName"].Value];

                // get the Data bound item for each grid row
                DataforVehList gridData = gridVehicles.Rows[contor].DataBoundItem as DataforVehList;

                // verify if the unit is valid or not 
                if (gridData != null)
                {
                    // skip this unit if it doesn't need to be updated
                    if (gridData.OnMap)
                    {

                        LatLngUTM tmpLatLng = new LatLngUTM();
                        Zone = "";
                        AltStr = Math.Round(vehicleTemp.GetAlt(), 5).ToString();

                        if (MainForm2.LatLngUTM.CompareTo("Lat/Lng No.") == 0)
                        {
                            LatStr = Math.Round(vehicleTemp.GetLat(), 5).ToString();
                            LngStr = Math.Round(vehicleTemp.GetLng(), 5).ToString();
                        }
                        else if (MainForm2.LatLngUTM.CompareTo("Lat/Lng Deg.") == 0)
                            tmpLatLng.LatLongtoDeg(vehicleTemp.GetLat(), vehicleTemp.GetLng(), out LatStr, out LngStr);
                        else if (MainForm2.LatLngUTM.CompareTo("UTM") == 0)
                        {
                            tmpLatLng.LatLongtoUTM(vehicleTemp.GetLat(), vehicleTemp.GetLng(), out LatDou, out LngDou, out Zone);
                            LatStr = LatDou.ToString("###,###,###");
                            LngStr = LngDou.ToString("###,###,###");
                        }


                        // update all the new fields and values
                        if (!((Math.Round(vehicleTemp.GetLat()) == 0) && (Math.Round(vehicleTemp.GetLng()) == 0)))
                            ListforGrid.Add(new DataforGRID(countlist.ToString(), vehicleTemp.busName,
                                vehicleTemp.lastActivityTime.ConvertGMTToLocal().GetDTFromSeconds(),
                                vehicleTemp.GetLastAddress(), Convert.ToString(vehicleTemp.GetSpeed()),
                                Utils.GetDirection(vehicleTemp.GetHeading()).ToString(), Convert.ToString(vehicleTemp.GetDI()),
                                Convert.ToString(vehicleTemp.GetDO()), Convert.ToString(LatStr),
                                Convert.ToString(LngStr), Zone, Convert.ToString(AltStr)));
                        else
                            ListforGrid.Add(new DataforGRID(countlist.ToString(), vehicleTemp.busName,
                            vehicleTemp.lastActivityTime.ConvertGMTToLocal().GetDTFromSeconds(), "N/A",
                            Convert.ToString(vehicleTemp.GetSpeed()), "N/A", Convert.ToString(vehicleTemp.GetDI()),
                            Convert.ToString(vehicleTemp.GetDO()), "N/A", "N/A", "", "N/A"));
                    }
                }
            }

            TableViewSortComplete = false;
            TableViewDataComplete = false;
            
            try
            {
                tableVehiclesList.DataSource = null;
                tableVehiclesList.DataSource = ListforGrid;
            }
            catch (Exception ex)
            {
                SM.Debug("Error on populate grid" + ex.ToString());
            }


            tableVehiclesList.Columns[oldColomnSort].SortOrder = oldSortType;
            tableVehiclesList.TableElement.ScrollToRow(0);
            tableVehiclesList.EndUpdate();
            //tableVehiclesList.Refresh();
        }



        /// <summary>
        /// Refresh the grid of positions for one unit
        /// <param name="unitName">Unit name for which the position should be updated</param>
        /// <param name="address">Current address at which the unit is placed</param>
        /// </summary>
        public void RefreshPositionsGrid(string unitName)
        {
            for (int contor = 0; contor < tableVehiclesList.Rows.Count; contor++)
            {               
                // get the Data bound item for each grid row
                DataforGRID gridData = tableVehiclesList.Rows[contor].DataBoundItem as DataforGRID;

                // verify if the unit is valid or not 
                if (gridData != null)
                {
                    if (!unitName.Equals(gridData.VehName))
                        continue;

                    // get current vehicle which is updated
                    Vehicle vehicleTemp = (Vehicle)MainForm2.vehicleHT[gridData.VehName];


                    int countlist = -1;
                    String LatStr = "";
                    String LngStr = "";
                    String AltStr = "";
                    String Zone;
                    Double LatDou, LngDou;
                    LatLngUTM tmpLatLng = new LatLngUTM();
                    Zone = "";
                    AltStr = Math.Round(vehicleTemp.GetAlt(), 5).ToString();

                    if (MainForm2.LatLngUTM.CompareTo("Lat/Lng No.") == 0)
                    {
                        LatStr = Math.Round(vehicleTemp.GetLat(), 5).ToString();
                        LngStr = Math.Round(vehicleTemp.GetLng(), 5).ToString();
                    }
                    else if (MainForm2.LatLngUTM.CompareTo("Lat/Lng Deg.") == 0)
                        tmpLatLng.LatLongtoDeg(vehicleTemp.GetLat(), vehicleTemp.GetLng(), out LatStr, out LngStr);
                    else if (MainForm2.LatLngUTM.CompareTo("UTM") == 0)
                    {
                        tmpLatLng.LatLongtoUTM(vehicleTemp.GetLat(), vehicleTemp.GetLng(), out LatDou, out LngDou, out Zone);
                        LatStr = LatDou.ToString("###,###,###");
                        LngStr = LngDou.ToString("###,###,###");
                    }
                    /*
                    if (!((Math.Round(vehicleTemp.GetLat()) == 0) && (Math.Round(vehicleTemp.GetLng()) == 0)))
                        ListforGrid.Add(new DataforGRID(countlist.ToString(), vehicleTemp.busName,
                            convDT.GetDTFromSeconds(convDT.ConvertGMTToLocal(vehicleTemp.lastActivityTime)),
                            vehicleTemp.GetLastAddress(), Convert.ToString(vehicleTemp.GetSpeed()),
                            Utils.GetDirection(vehicleTemp.GetHeading()).ToString(), Convert.ToString(vehicleTemp.GetDI()),
                            Convert.ToString(vehicleTemp.GetDO()), Convert.ToString(LatStr),
                            Convert.ToString(LngStr), Zone, Convert.ToString(AltStr)));
                    else
                        ListforGrid.Add(new DataforGRID(countlist.ToString(), vehicleTemp.busName,
                        convDT.GetDTFromSeconds(convDT.ConvertGMTToLocal(vehicleTemp.lastActivityTime)), "N/A",
                        Convert.ToString(vehicleTemp.GetSpeed()), "N/A", Convert.ToString(vehicleTemp.GetDI()),
                        Convert.ToString(vehicleTemp.GetDO()), "N/A", "N/A", "", "N/A"));
                    */

                    gridData.Address = vehicleTemp.GetLastAddress();
                    gridData.Datatime = (vehicleTemp.lastActivityTime).ConvertGMTToLocal().GetDTFromSeconds();
                    gridData.Speed = Convert.ToString(vehicleTemp.GetSpeed());
                    gridData.DI = Convert.ToString(vehicleTemp.GetDI());
                    gridData.DO = Convert.ToString(vehicleTemp.GetDO());

                    if (!((Math.Round(vehicleTemp.GetLat()) == 0) && (Math.Round(vehicleTemp.GetLng()) == 0)))
                    {
                        gridData.Alt = Convert.ToString(AltStr);
                        gridData.Lat = Convert.ToString(LatStr);
                        gridData.Lng = Convert.ToString(LngStr);
                        gridData.Zone = zonename;
                        gridData.Head = Utils.GetDirection(vehicleTemp.GetHeading()).ToString();
                    }
                    else
                    {
                        gridData.Alt = gridData.Lat = gridData.Lng = "N/A";
                        gridData.Zone = "";
                        gridData.Head = "N/A";
                    }

                    gridData.NrOfUpdates = gridData.NrOfUpdates + 1;
                }
            }
            //foreach()
            
        }




        public static GroupType groupType = GroupType.GROUPNAME;
        public static ListSortDirection sortDirection = ListSortDirection.Ascending;
        
        /// <summary>
        /// Event Handler for when a filter picture box is clicked
        /// This should group the grid based on its status
        /// </summary>
        private void pbFilter_Click(object sender, EventArgs e)
        {
            // add image to the dictionary if not exists
            if (!MainForm2.imagesDictionary.ContainsKey("l_filter_status_g"))
                MainForm2.imagesDictionary.Add("l_filter_status_g", Utils.MakeGrayscale3(global::Dispatcher.Properties.Resources.l_bullet_bl, 0.5f));
            if (!MainForm2.imagesDictionary.ContainsKey("l_filter_time_g"))
                MainForm2.imagesDictionary.Add("l_filter_time_g", Utils.MakeGrayscale3(global::Dispatcher.Properties.Resources.l_history_b, 0.5f));
            if (!MainForm2.imagesDictionary.ContainsKey("l_filter_group_g"))
                MainForm2.imagesDictionary.Add("l_filter_group_g", Utils.MakeGrayscale3(global::Dispatcher.Properties.Resources.l_user_n, 0.5f));


            pbGroupTime.Image = MainForm2.imagesDictionary["l_filter_time_g"];
            pbGroupStatusType.Image = MainForm2.imagesDictionary["l_filter_status_g"];
            pbGroup.Image = MainForm2.imagesDictionary["l_filter_group_g"];


            pbGroupTime.Tag = pbGroupStatusType.Tag = pbGroup.Tag = "disabled";
            if ((PictureBox)sender == pbGroupTime)
            {
                if (!MainForm2.imagesDictionary.ContainsKey("l_filter_time"))
                    MainForm2.imagesDictionary.Add("l_filter_time", 
                        Utils.ChangeColor(global::Dispatcher.Properties.Resources.l_history_b, MainForm2.ButtonColor));

                pbGroupTime.Image = MainForm2.imagesDictionary["l_filter_time"];
                pbGroupTime.Tag = "enabled";
                groupType = GroupType.POSITIONTIMEAGO;
            }
            else if ((PictureBox)sender == pbGroupStatusType)
            {
                if (!MainForm2.imagesDictionary.ContainsKey("l_filter_status"))
                    MainForm2.imagesDictionary.Add("l_filter_status", 
                        Utils.ChangeColor(global::Dispatcher.Properties.Resources.l_bullet_bl, MainForm2.ButtonColor));

                pbGroupStatusType.Image = MainForm2.imagesDictionary["l_filter_status"];
                pbGroupStatusType.Tag = "enabled";
                groupType = GroupType.STATUS;
            }
            else if ((PictureBox)sender == pbGroup)
            {
                if (!MainForm2.imagesDictionary.ContainsKey("l_filter_group"))
                    MainForm2.imagesDictionary.Add("l_filter_group", 
                        Utils.ChangeColor(global::Dispatcher.Properties.Resources.l_user_n, MainForm2.ButtonColor));

                pbGroup.Image = MainForm2.imagesDictionary["l_filter_group"];
                pbGroup.Tag = "enabled";
                groupType = GroupType.GROUPNAME;
            }

            // group the vehicles
            gridVehicles_SetGrouping(groupType, true);
            if (isFilterLoaded) VisualSettings.InsertUpdateHTforVisualItems(tabName, "PictureBox_Filter", ((PictureBox)sender).Name);
        }


        private void pbFilter_MouseEnter(object sender, EventArgs e)
        {
            PictureBox pbSender = (PictureBox)sender;
            String toolTipTitle = "";
            String toolTipText = "";

            if (pbSender == pbGroup)
            {
                toolTipTitle = MainForm2.returnLNGString("live_filter_group_title");
                toolTipText = MainForm2.returnLNGString("live_filter_group");
            }
            else if (pbSender == pbGroupStatusType)
            {
                toolTipTitle = MainForm2.returnLNGString("live_filter_status_title");
                toolTipText = MainForm2.returnLNGString("live_filter_status"); ;
            }
            else if (pbSender == pbGroupTime)
            {
                toolTipTitle = MainForm2.returnLNGString("live_filter_time_title"); ;
                toolTipText = MainForm2.returnLNGString("live_filter_time"); ;
            }
            
            toolTipHelp.ToolTipTitle = toolTipTitle + ": " + (pbSender.Tag.Equals("enabled") ? MainForm2.returnLNGString("active") : MainForm2.returnLNGString("inactive"));
            if (pbSender == pbCollapseAll)
            {
                toolTipHelp.ToolTipTitle = "";
                toolTipText = MainForm2.returnLNGString("collapseAll");
            }
            else if (pbSender == pbExpandAll)
            {
                toolTipHelp.ToolTipTitle = "";
                toolTipText = MainForm2.returnLNGString("expandAll");
            }
            toolTipHelp.Show(
                String.Format(toolTipText), pbSender, 150000);
        }

        private void pbFilter_MouseLeave(object sender, EventArgs e)
        {
            toolTipHelp.Hide((PictureBox)sender);
        }

        /// <summary>
        /// Change the group type of the grid and mention if the reordering should be
        /// made or not
        /// </summary>
        /// <param name="type">Sorting type which corresponds to the column</param>
        /// <param name="changeOrder"></param>
        private void gridVehicles_SetGrouping(GroupType type, bool changeOrder)
        {
            // do not refresh the grid if not desired
            if (!rcbAutoRefresh.Checked)
                return;

            GroupLiveGrid(type, changeOrder);


            //Utils.WriteLine("gridVehicles_SetGrouping");
        }

       
        /// <summary>
        /// Change the group type of the grid and mention if the reordering should be
        /// made or not
        /// </summary>
        /// <param name="type">Sorting type which corresponds to the column</param>
        /// <param name="changeOrder"></param>
        private void GroupLiveGrid(GroupType type, bool changeOrder)
        {

            //type = GroupType.GROUPNAME;
            //changeOrder = false;
            //sortDirection = ListSortDirection.Ascending;

            try
            {
                // set data source and refresh it
                gridVehicles.DataSource = null;
                gridVehicles.DataSource = ListforVehList;
            }
            catch (Exception ex)
            {
                SM.Debug("Error on populate grid" + ex.ToString());
            }


            string filterName = "GroupName";
            if (type == GroupType.GROUPNAME)
                filterName = "GroupName";
            else if (type == GroupType.POSITIONTIMEAGO)
                filterName = "PositionTimeAgo";
            else if (type == GroupType.STATUS)
                filterName = "Status";
            else if (type == GroupType.RADIOGATEWAY)
                filterName = "RadioGateway";

            if (changeOrder)
            {
                // reverse the sorting order
                if (gridVehicles.GroupDescriptors.Count > 0 &&
                        gridVehicles.GroupDescriptors[0].Expression.Contains(filterName))
                {
                    GroupDescriptor gd = gridVehicles.GroupDescriptors[0];
                    sortDirection = gd.Expression.Contains("ASC") ? ListSortDirection.Descending : ListSortDirection.Ascending;
                }
                else if (type == GroupType.POSITIONTIMEAGO)
                {
                    // time ago should start as descending
                    sortDirection = ListSortDirection.Descending;
                }


                if (sortDirection == ListSortDirection.Ascending)
                    gridVehicles.Columns["unitName"].SortOrder = RadSortOrder.Ascending;
                else
                    gridVehicles.Columns["unitName"].SortOrder = RadSortOrder.Descending;

            }


            // clear previous filters and add the new one
            gridVehicles.GroupDescriptors.Clear();
            GroupDescriptor groupDescriptor = new GroupDescriptor(new SortDescriptor[] { new SortDescriptor(filterName, sortDirection) });
            gridVehicles.GroupDescriptors.Add(groupDescriptor);

            
            int i = 0;
            CheckedGroup.Clear();
            foreach (GridViewRowInfo groupRow in gridVehicles.ChildRows)
            {
                // the group has items
                if (groupRow.ChildRows.Count > 0)
                {
                    // group name is groupRow.Group.Header


                    bool areAllChecked = true;

                    foreach (GridViewRowInfo gridRow in groupRow.ChildRows)
                    {
                        // get the Data bound item for each grid row
                        DataforVehList gridData = gridRow.DataBoundItem as DataforVehList;

                        // verify if the unit is valid or not 
                        if (gridData != null)
                        {
                            if (!gridData.OnMap)
                                areAllChecked = false;
                        }

                    }

                    CheckedGroup.Add(i++, areAllChecked);
                    if (ExpandGroupingHT.Contains(groupRow.Group.Key.ToString()))
                        groupRow.IsExpanded = (bool)ExpandGroupingHT[groupRow.Group.Key.ToString()];
                    else

                        groupRow.IsExpanded = true;

                  
                    if (groupRow != null && areAllChecked) 
                        groupRow.Tag = true;
                }
            }
        }


        private void rbRefreshGroups_Click(object sender, EventArgs e)
        {
            Utils.WriteLine("rbRefreshGroups_Click", ConsoleColor.Yellow);

            GroupLiveGrid(groupType, false);
        }




        private void gridVehicles_CustomGrouping(object sender, GridViewCustomGroupingEventArgs e)
        {
            string colName = gridVehicles.GroupDescriptors[e.Level].GroupNames[0].PropertyName;

            if (colName == "PositionTimeAgo")
            {
                // get the Data bound item for each grid row
                if (e.Row.DataBoundItem != null && e.Row.DataBoundItem is DataforVehList)
                {
                    DataforVehList gridData = e.Row.DataBoundItem as DataforVehList;

                    // verify if the unit is valid or not 
                    if (gridData != null)
                        e.GroupKey = gridData.PositionTimeAgo; //new DateTime(gridData.PositionTime.Year, gridData.PositionTime.Month, gridData.PositionTime.Day);
                }
            }
            else if (colName == "Status")
            {
                // get the Data bound item for each grid row
                if (e.Row.DataBoundItem != null && e.Row.DataBoundItem is DataforVehList)
                {
                    DataforVehList gridData = e.Row.DataBoundItem as DataforVehList;

                    // verify if the unit is valid or not 
                    if (gridData != null)
                        e.GroupKey = gridData.Status;
                }
            }
            else if (colName == "GroupName")
            {
                // get the Data bound item for each grid row
                if (e.Row.DataBoundItem != null && e.Row.DataBoundItem is DataforVehList)
                {
                    DataforVehList gridData = e.Row.DataBoundItem as DataforVehList;

                    // verify if the unit is valid or not 
                    if (gridData != null)
                        e.GroupKey = gridData.GrpName;
                }
            }
            else if (colName == "RadioGateway")
            {
                // get the Data bound item for each grid row
                if (e.Row.DataBoundItem != null && e.Row.DataBoundItem is DataforVehList)
                {
                    DataforVehList gridData = e.Row.DataBoundItem as DataforVehList;

                    // verify if the unit is valid or not 
                    if (gridData != null)
                        e.GroupKey = gridData.RadioGateway;
                }
            }
            /*
        else if (colName == "Name")
        {
            e.GroupKey = e.Row.Cells[colName].Value.ToString().Length;
        }*/
        }



        /// <summary>
        /// Event handler for when the left tab panel needs to be docked/transfor in floating state.
        /// This will cancel this event in order to prevent the stupid case with hiding the dock window
        /// </summary>
        private void radDock1_DockStateChanging(object sender, DockStateChangingEventArgs e)
        {
            e.Cancel = true;
        }

        
        private void LiveTab_Load(object sender, EventArgs e)
        {
            // register for when the unit call status is changed
            //this.parent.OnCallStatusChanged += delegate(string unitname, bool inCall)
            //{
            //    Utils.WriteLine("SET CALL " + unitname + "  " + inCall);
            //    mapGoogles.ExecuteScript(String.Format("window.GWTcallback('setCall,{0},{1}')", unitname, inCall));
            //};

            gridVehicles.DataSource = ListforVehList;
            GridExpandAnimationType temp = gridVehicles.GroupExpandAnimationType;
            gridVehicles.GroupExpandAnimationType = GridExpandAnimationType.None;
            for (int i = 0; i < gridVehicles.Groups.Count; i++)
            {
                bool? isGroupExpanded = VisualSettings.IsGroupExpandedInLiveTab((gridVehicles.Groups[i]).Key + "", tabName);
                if (isGroupExpanded == null || isGroupExpanded == true)
                    gridVehicles.Groups[i].Expand();
            }

            gridVehicles.GroupExpandAnimationType = temp;
            gridVehicles.TableElement.ScrollToRow(0);


            tableVehiclesList.DataSource = ListforGrid;
            

            this.parent.OnCallStatusChanged += parent_OnCallStatusChanged;

            if(MainForm2.vehicleHT.Count > 1)
                rseUnitsOnMap.Maximum = MainForm2.vehicleHT.Count;

            if (MainForm2.HashVal.ContainsKey(tabName + "_" + "setdatasetlimit"))
            {
                int limit = Convert.ToInt32(MainForm2.HashVal[tabName + "_" + "setdatasetlimit"]);
                rseUnitsOnMap.Value = limit < rseUnitsOnMap.Maximum ? limit : rseUnitsOnMap.Maximum;
            }

            if (MainForm2.HashVal.ContainsKey("showMarkersLables"))
                rcbMarkersLables.Checked = Convert.ToBoolean(MainForm2.HashVal["showMarkersLables"]);
           

        }

        void parent_OnCallStatusChanged(string unitname, bool inCall, Boolean fromField)
        {
            Utils.WriteLine($"UpdateMapCall status for {unitname} - {(inCall ? "in call" : "not in a call")}");
            mapGoogles.ExecuteScript(String.Format("window.GWTcallback('setCall,{0},{1}')", unitname, inCall));
        }


        /// <summary>
        /// Change background color for the row according to its state and theme
        /// </summary>
        private void gridVehicles_RowFormatting(object sender, RowFormattingEventArgs e)
        {
            if (e.RowElement.IsSelected)
            {
                e.RowElement.DrawFill = true;
                e.RowElement.BackColor = MainForm2.GridSelectedRow;
                e.RowElement.NumberOfColors = 1;
            }
            else
            {
                e.RowElement.DrawFill = false;
            }
        }


        /// <summary>
        /// Change background color for the row according to its state and theme
        /// </summary>
        private void tableVehiclesList_RowFormatting(object sender, RowFormattingEventArgs e)
        {
            if (e.RowElement.IsSelected)
            {
                e.RowElement.DrawFill = true;
                e.RowElement.BackColor = MainForm2.GridSelectedRow;
                e.RowElement.NumberOfColors = 1;
            }
            else
                e.RowElement.DrawFill = false;
        }



        #region CHANGE TABS BACKGROUND
        private DockWindow oldDockWindow = null;
        private void radDock1_ActiveWindowChanging(object sender, DockWindowCancelEventArgs e)
        {
            // reset the background icon for the previous tab
            e.OldWindow.TabStripItem.BackColor = Color.White;
            e.OldWindow.TabStripItem.DrawFill = true;
            e.OldWindow.TabStripItem.NumberOfColors = 1;

            // reset the background for the new window
            e.NewWindow.TabStripItem.DrawFill = true;
            e.NewWindow.TabStripItem.NumberOfColors = 1;
            e.NewWindow.TabStripItem.BackColor = MainForm2.TabSelectedColor;

            // save old dock window
            oldDockWindow = e.OldWindow;
        }

        private void radDock1_ActiveWindowChanged(object sender, DockWindowEventArgs e)
        {

            // reset the background icon for the previous tab
            oldDockWindow.TabStripItem.BackColor = Color.White;
            oldDockWindow.TabStripItem.DrawFill = true;
            oldDockWindow.TabStripItem.NumberOfColors = 1;

            e.DockWindow.TabStripItem.DrawFill = true;
            e.DockWindow.TabStripItem.NumberOfColors = 1;
            e.DockWindow.TabStripItem.BackColor = MainForm2.TabSelectedColor;
        }
        #endregion

        private void CollapseExpandGrid(object sender, EventArgs e)
        {
            bool status = ((PictureBox)sender).Name == "pbExpandAll" ? true : false;
            foreach (GridViewRowInfo groupRow in gridVehicles.ChildRows)
            {
                groupRow.IsExpanded = status;
                collapseExpand(groupRow.Group.Header, status);
            }
        }

        private void rcbAutoRefresh_ToggleStateChanged(object sender, StateChangedEventArgs args)
        {
            if (isFilterLoaded) VisualSettings.InsertUpdateHTforVisualItems(tabName, ((RadCheckBox)sender).Name, ((RadCheckBox)sender).Checked.ToString());
        }

        private void rseUnitsOnMap_ValueChanged(object sender, EventArgs e)
        {
            if (docLoad)
            {
                System.Threading.Thread.Sleep(100);
                VisualSettings.InsertUpdateHTforVisualItems(tabName + "_" + "setdatasetlimit", "", rseUnitsOnMap.Value.ToString());
                mapGoogles.ExecuteScript("window.GWTcallback('" + "setdatasetlimit," + rseUnitsOnMap.Value.ToString() + "');");
                
            }
            if(mapLoaded)
                mapHandler.SetDataSetLimit((int)rseUnitsOnMap.Value);

            //sel_desel.Visible = (int)rseUnitsOnMap.Value > MainForm2.vehicleHT.Count;
        }

        private void rcbMarkersLables_ToggleStateChanged(object sender, StateChangedEventArgs args)
        {
            // add to hash the new value for lables
            if (isFilterLoaded)
                VisualSettings.InsertUpdateHTforVisualItems(tabName, ((RadCheckBox)sender).Name, ((RadCheckBox)sender).Checked.ToString());

            MapMarkersLables(rcbMarkersLables.Checked);

            List<Vehicle> htList = (MainForm2.vehicleHT.Values.Cast<Vehicle>().ToList());
            IEnumerable<IGrouping<int, Vehicle>> query = htList.GroupBy(d => d.group.Id, d => d);

            if (mapLoaded)
                // Iterate over each IGrouping in the collection.
                foreach (IGrouping<int, Vehicle> group in query)
                {
                    String groupName = group.FirstOrDefault(d => d.sipID > 0).group.Name;
                    mapHandler.HasLabels = rcbMarkersLables.Checked;
                    mapHandler.SetLabelVisibility(rcbMarkersLables.Checked, groupName);
                }

           
        }

        /// <summary>
        /// Prevent the context menu to be shown for this grid
        /// </summary>
        private void tableVehiclesList_ContextMenuOpening(object sender, ContextMenuOpeningEventArgs e)
        {
            // do not display the context menu
            e.Cancel = true;
        }

        private bool shouldIgnoreExpandedEvent = false;
        private Hashtable ExpandGroupingHT = new Hashtable();
        //SD-102 prevent live grid collapse expands by itself
        private void gridVehicles_GroupExpanded(object sender, GroupExpandedEventArgs e)
        {
            collapseExpand(e.DataGroup.Key.ToString(), e.DataGroup.IsExpanded);
        }

        private void collapseExpand(string groupName, bool status)
        {
            if (shouldIgnoreExpandedEvent)
                return;

            if (!ExpandGroupingHT.Contains(groupName))
                ExpandGroupingHT.Add(groupName, status);
            else
                ExpandGroupingHT[groupName] = status;
            // add to hash
            if (groupName != "")
                VisualSettings.SetGroupExpandedInLiveTab(groupName, status, tabName);
            //VisualSettings.InsertUpdateHTforVisualItems(tabName + "_" + "ExpandGroupingHT", groupName + "", status + "");
        }


        public void OnWebSocketStatusChanged(ToggleState isCheckboxChecked)
        {
            CheckboxSetToggleState(chkWebsocketConnected, isCheckboxChecked);
        }

        private void CheckboxSetToggleState(RadCheckBox checkBox, ToggleState toggleState)
        {
            checkBox.ToggleState = toggleState;
            checkBox.ForeColor = (toggleState == ToggleState.On) ? Color.LightGreen : Color.Red;

            if (checkBox.Name.Equals("chkWebsocketConnected") && toggleState == ToggleState.On)
            {
                chkWebsocketConnected.ToggleState = toggleState;
                chkWebsocketConnected.ForeColor = Color.Green;
                chkWebsocketConnected.ButtonElement.CheckMarkPrimitive.CheckElement.BackColor = Color.LightGreen;
                chkWebsocketConnected.ButtonElement.CheckMarkPrimitive.CheckElement.BackColor2 = Color.LightGreen;
                chkWebsocketConnected.ButtonElement.CheckMarkPrimitive.CheckElement.ForeColor = Color.LightGreen;
                changeCheckboxState.Stop();
                changeCheckboxState.Start();
            }
            else if (checkBox.Name.Equals("chkWebsocketConnected") && toggleState == ToggleState.Off)
            {
                chkWebsocketConnected.ToggleState = ToggleState.On;
                chkWebsocketConnected.ForeColor = Color.Red;
                chkWebsocketConnected.ButtonElement.CheckMarkPrimitive.CheckElement.BackColor = Color.Red;
                chkWebsocketConnected.ButtonElement.CheckMarkPrimitive.CheckElement.BackColor2 = Color.Red;
                chkWebsocketConnected.ButtonElement.CheckMarkPrimitive.CheckElement.ForeColor = Color.Red;
                changeCheckboxState.Stop();
                changeCheckboxState.Start();
            }
            else if (checkBox.Name.Equals("chkWebsocketConnected") && toggleState == ToggleState.Indeterminate)
            {
                chkWebsocketConnected.ToggleState = toggleState;
                chkWebsocketConnected.ForeColor = Color.Gray;
                chkWebsocketConnected.ButtonElement.CheckMarkPrimitive.CheckElement.BackColor = Color.Gray;
                chkWebsocketConnected.ButtonElement.CheckMarkPrimitive.CheckElement.BackColor2 = Color.Gray;
                chkWebsocketConnected.ButtonElement.CheckMarkPrimitive.CheckElement.ForeColor = Color.Gray;
                changeCheckboxState.Stop();
                changeCheckboxState.Start();
            }
        }

        private void ChangeCheckboxState(object source, ElapsedEventArgs e)
        {
            chkWebsocketConnected.ToggleState = ToggleState.Indeterminate;
            chkWebsocketConnected.ForeColor = Color.Gray;

            chkWebsocketConnected.ButtonElement.CheckMarkPrimitive.CheckElement.BackColor = Color.Gray;
            chkWebsocketConnected.ButtonElement.CheckMarkPrimitive.CheckElement.BackColor2 = Color.Gray;
            chkWebsocketConnected.ButtonElement.CheckMarkPrimitive.CheckElement.ForeColor = Color.Gray;
        }
        
        #region EVENTS
        public class AlertRequiredEventArgs : EventArgs
        {
            public DataforVehList gridData { get; set; }
        }
        public delegate void AlertRequired(AlertRequiredEventArgs e);
        public event AlertRequired OnAlertRequiredReceived;

        #endregion
    }


    /// <summary>
    /// Comparer class in order to sort the units list based on custom filters.
    /// For time interval, the 'never reported' group will remain at the bottom
    /// </summary>
    public class CustomGroupComparer : IComparer<Group<GridViewRowInfo>>
    {
        //public GroupType groupType;
        //public ListSortDirection sortDirection;
        /*
        public GroupComparer(GroupType type, ListSortDirection direction)
        {
            this.groupType = type;
            this.sortDirection = direction;
        }*/

        public int Compare(Group<GridViewRowInfo> x, Group<GridViewRowInfo> y)
        {
            try
            {
                if (x == null || x.Key == null || y == null || y.Key == null)
                    return 0;

                if (LiveTab.groupType == GroupType.GROUPNAME)
                {
                    if (LiveTab.sortDirection == ListSortDirection.Ascending)
                        return x.Key.ToString().CompareTo(y.Key.ToString());
                    else
                        return (-1) * x.Key.ToString().CompareTo(y.Key.ToString());
                }
                else if (LiveTab.groupType == GroupType.STATUS)
                {
                    if (LiveTab.sortDirection == ListSortDirection.Ascending)
                        return x.Key.ToString().CompareTo(y.Key.ToString());
                    else
                        return (-1) * x.Key.ToString().CompareTo(y.Key.ToString());
                }
                else if (LiveTab.groupType == GroupType.POSITIONTIMEAGO)
                {
                    string xKey = "";
                    string yKey = "";

                    // get date for first group an second
                    if (x.Key != null)
                        xKey = x.Key.ToString();

                    if (y.Key != null)
                        yKey = y.Key.ToString();

                    DateTime dx = GetDateTimeFromAgo(xKey.ToString(), LiveTab.sortDirection);
                    DateTime dy = GetDateTimeFromAgo(yKey.ToString(), LiveTab.sortDirection);


                    if (LiveTab.sortDirection == ListSortDirection.Ascending)
                        return dx.CompareTo(dy);
                    else
                        return (-1) * dx.CompareTo(dy);
                }

                return x.Key.ToString().CompareTo(y.Key.ToString());
            }
            catch (Exception ex)
            {
                Utils.WriteLine("Grouping exception: " + ex.ToString());

                if (LiveTab.sortDirection == ListSortDirection.Ascending)
                    return 1;
                else
                    return -1;
            }
        }


        /// <summary>
        /// Try to recover the day that the ago time indicates. Only thing that needs
        /// to be keep in mind is that the never reported will be way in past or in future
        /// depending on the sorting direction
        /// </summary>
        /// <param name="agoTime">String which is a string representation of the day
        /// with ago function</param>
        /// <returns></returns>
        private DateTime GetDateTimeFromAgo(string agoTime, ListSortDirection sortDirection)
        {
            if (agoTime.ToUpper().Equals(MainForm2.returnLNGString("neverReported").ToUpper()))
            {
                if (sortDirection == ListSortDirection.Descending)
                    return new DateTime(1970, 1, 1);
                else
                    return new DateTime(2970, 1, 1);
            }
            else if (agoTime.ToUpper().Equals("scheduled") ||
                agoTime.ToUpper().Equals("future_position"))
            {
                return new DateTime(2970, 1, 1);
            }
            else if (agoTime.ToUpper().Equals(MainForm2.returnLNGString("lessThan1Min").ToUpper()))
                return DateTime.Now;
            else
            {
                try
                {
                    // split by space to find the day
                    string[] agoSplit = agoTime.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
                    int timeUnit = 0;
                    // try and parse the days count which are located at the begining
                    // eg. 54 days ago
                    int.TryParse(agoSplit[0], out timeUnit);

                    if (agoSplit.Length == 1)
                        return DateTime.Now.AddDays(timeUnit * (-1));
                    else
                    {
                        if (agoSplit[1].ToUpper().StartsWith(MainForm2.returnLNGString("minute").ToUpper()))
                            return DateTime.Now.AddMinutes(timeUnit * (-1));
                        else if (agoSplit[1].ToUpper().StartsWith(MainForm2.returnLNGString("hour").ToUpper()))
                            return DateTime.Now.AddHours(timeUnit * (-1));
                        else
                            return DateTime.Now.AddDays(timeUnit * (-1));
                    }
                }
                catch (Exception ex)
                {
                    if (sortDirection == ListSortDirection.Descending)
                        return new DateTime(1970, 1, 1);
                    else
                        return new DateTime(2970, 1, 1);
                }
            }
        }
    }

    public sealed class GroupType
    {

        private readonly String name;
        private readonly int value;

        public static readonly GroupType POSITIONTIMEAGO = new GroupType(1, "PositionTimeAgo");
        public static readonly GroupType STATUS = new GroupType(2, "Status");
        public static readonly GroupType GROUPNAME = new GroupType(3, "GroupName");
        public static readonly GroupType RADIOGATEWAY = new GroupType(4, "RadioGateway");

        private GroupType(int value, String name)
        {
            this.name = name;
            this.value = value;
        }

        public override String ToString()
        {
            return name;
        }
    }
}