prs/prs.desktop/Panels/Maps/MapsPanel.xaml.cs

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Linq.Expressions;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using Comal.Classes;
using Comal.Stores;
using InABox.Clients;
using InABox.Configuration;
using InABox.Core;
using InABox.Wpf;
using Syncfusion.UI.Xaml.Maps;
using System.ComponentModel;
using System.Drawing;
using Point = System.Windows.Point;

namespace PRSDesktop
{
    public class ImageryLayerExt : ImageryLayer
    {
        protected override string GetUri(int X, int Y, int Scale)
        {
            var link = "http://mt1.google.com/vt/lyrs=y&x=" + X + "&y=" + Y + "&z=" + Scale;
            return link;
        }
    }

    public class GPSHistory
    {
        public DateTime Date { get; set; }
        public string Description { get; set; }
        public double Latitude { get; set; }
        public double Longitude { get; set; }
    }

    /// <summary>
    ///     Interaction logic for MapsPanel.xaml
    /// </summary>
    public partial class MapsPanel : UserControl, IPanel<GPSTracker>
    {
        private LiveMapsSettings _settings;

        private bool bFirst = true;

        private readonly int ZOOMEDIN = 16;

        public MapsPanel()
        {
            InitializeComponent();
            //ausgov.Uri = "c:\\development\\maps\\MB_2011_WA.shp";
        }

        public bool IsReady { get; set; }

        public void CreateToolbarButtons(IPanelHost host)
        {
        }

        public string SectionName => "Maps";

        public DataModel DataModel(Selection selection)
        {
            return new MapsDataModel();
        }

        public void Heartbeat(TimeSpan time)
        {
        }

        public void Refresh()
        {
            var type = ViewType.SelectedItem as string;
            if (!string.IsNullOrWhiteSpace(type))
            {
                var grpid = ((KeyValuePair<Guid, string>)ViewGroup.SelectedItem).Key;

                if (type.Equals("Equipment"))
                {
                    var filter = new Filter<Equipment>(x => x.TrackerLink.Location.Timestamp).IsNotEqualTo(DateTime.MinValue);
                    if (!Security.IsAllowed<CanViewPrivateEquipment>())
                        filter = filter.And(x => x.Private).IsEqualTo(false);
                    if (grpid != Guid.Empty)
                        filter = filter.And(x => x.GroupLink.ID).IsEqualTo(grpid);

                    LoadMarkers(
                        filter,
                        x => x.ID,
                        x => x.Code,
                        x => x.Description,
                        x => x.TrackerLink.DeviceID,
                        x => x.TrackerLink.Location.Latitude,
                        x => x.TrackerLink.Location.Longitude,
                        x => x.TrackerLink.Description,
                        x => x.TrackerLink.Location.Timestamp
                    );
                }

                else if (type.Equals("Jobs"))
                {
                    var filter = new Filter<Job>(x => x.SiteAddress.Location.Timestamp).IsNotEqualTo(DateTime.MinValue);
                    if (grpid != Guid.Empty)
                        filter = filter.And(x => x.JobStatus.ID).IsEqualTo(grpid);

                    LoadMarkers(
                        filter,
                        x => x.ID,
                        x => x.JobNumber,
                        x => x.Name,
                        null,
                        x => x.SiteAddress.Location.Latitude,
                        x => x.SiteAddress.Location.Longitude,
                        x => x.LastUpdateBy,
                        x => x.SiteAddress.Location.Timestamp
                    );
                }

                else if (type.Equals("TimeSheets"))
                {
                    if (grpid == Guid.Empty) // Starts
                        LoadMarkers(
                            new Filter<TimeSheet>(x => x.Date).IsEqualTo(DateTime.Today).And(x => x.StartLocation.Timestamp)
                                .IsNotEqualTo(new TimeSpan(0)),
                            x => x.EmployeeLink.ID,
                            x => x.EmployeeLink.Code,
                            x => x.EmployeeLink.Name,
                            null,
                            x => x.StartLocation.Latitude,
                            x => x.StartLocation.Longitude,
                            x => x.SoftwareVersion,
                            x => x.StartLocation.Timestamp
                        );
                    else if (grpid == CoreUtils.FullGuid) // Finishes
                        LoadMarkers(
                            new Filter<TimeSheet>(x => x.Date).IsEqualTo(DateTime.Today).And(x => x.Finish).IsNotEqualTo(new TimeSpan(0))
                                .And(x => x.FinishLocation.Timestamp).IsNotEqualTo(new TimeSpan(0)),
                            x => x.EmployeeLink.ID,
                            x => x.EmployeeLink.Code,
                            x => x.EmployeeLink.Name,
                            null,
                            x => x.FinishLocation.Latitude,
                            x => x.FinishLocation.Longitude,
                            x => x.SoftwareVersion,
                            x => x.FinishLocation.Timestamp
                        );
                    else // Open
                        LoadMarkers(
                            new Filter<TimeSheet>(x => x.Date).IsEqualTo(DateTime.Today).And(x => x.Finish).IsEqualTo(new TimeSpan(0))
                                .And(x => x.StartLocation.Timestamp).IsNotEqualTo(new TimeSpan(0)),
                            x => x.EmployeeLink.ID,
                            x => x.EmployeeLink.Code,
                            x => x.EmployeeLink.Name,
                            null,
                            x => x.StartLocation.Latitude,
                            x => x.StartLocation.Longitude,
                            x => x.SoftwareVersion,
                            x => x.StartLocation.Timestamp
                        );
                }

                else if (type.Equals("Trackers"))
                {
                    var filter = new Filter<GPSTracker>(x => x.Location.Timestamp).IsNotEqualTo(DateTime.MinValue);
                    if (grpid != Guid.Empty)
                        filter = filter.And(x => x.Type.ID).IsEqualTo(grpid);

                    LoadMarkers(
                        filter,
                        x => x.ID,
                        x => x.DeviceID,
                        x => x.Description,
                        x => x.DeviceID,
                        x => x.Location.Latitude,
                        x => x.Location.Longitude,
                        x => x.LastUpdateBy,
                        x => x.Location.Timestamp
                    );
                }
            }
        }

        public Dictionary<string, object[]> Selected()
        {
            return new Dictionary<string, object[]>();
        }

        public void Setup()
        {
            _settings = new UserConfiguration<LiveMapsSettings>().Load();

            if (ClientFactory.IsSupported<Equipment>())
                ViewType.Items.Add("Equipment");

            if (ClientFactory.IsSupported<Job>())
                ViewType.Items.Add("Jobs");

            if (ClientFactory.IsSupported<TimeSheet>())
                ViewType.Items.Add("TimeSheets");

            if (ClientFactory.IsSupported<GPSTracker>())
                ViewType.Items.Add("Trackers");

            ViewType.SelectedIndex = ViewType.Items.Count > _settings.ViewType ? _settings.ViewType : -1;
            ViewType.SelectionChanged += ViewTypeSelectionChanged;

            var groups = ViewType.SelectedIndex > -1 ? LoadGroups(ViewType.SelectedItem as string) : LoadGroups("");
            ViewGroup.ItemsSource = groups;
            ViewGroup.SelectedIndex = ViewGroup.Items.Count > _settings.ViewGroup ? _settings.ViewGroup : -1;
            ViewGroup.SelectionChanged += ViewGroupSelectionChanged;
        }

        public void Shutdown(CancelEventArgs? cancel)
        {
        }

        public event DataModelUpdateEvent? OnUpdateDataModel;


        public Dictionary<Type, CoreTable> DataEnvironment()
        {
            return new Dictionary<Type, CoreTable>();
        }

        private void LoadGroups<TGroup>(string all, Dictionary<Guid, string> results, Expression<Func<TGroup, string>> description)
            where TGroup : Entity, IRemotable, IPersistent, new()
        {
            results.Clear();
            results.Add(Guid.Empty, all);
            var groups = new Client<TGroup>().Query(
                LookupFactory.DefineFilter<TGroup>(),
                LookupFactory.DefineColumns<TGroup>(),
                LookupFactory.DefineSort<TGroup>()
            );
            foreach (var row in groups.Rows)
                results[row.Get<TGroup, Guid>(x => x.ID)] = row.Get(description);
        }

        private void ViewTypeSelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            var sel = e.AddedItems.Count > 0 ? e.AddedItems[0] as string : null;
            if (string.IsNullOrWhiteSpace(sel))
                return;

            var groups = LoadGroups(sel);
            ViewGroup.SelectionChanged -= ViewGroupSelectionChanged;
            ViewGroup.ItemsSource = groups;
            ViewGroup.SelectionChanged += ViewGroupSelectionChanged;
            ViewGroup.SelectedIndex = groups.Any() ? 0 : -1;
        }

        private Dictionary<Guid, string> LoadGroups(string sel)
        {
            var result = new Dictionary<Guid, string>();

            if (sel.Equals("Equipment"))
            {
                LoadGroups<EquipmentGroup>("All Equipment", result, x => x.Description);
            }

            else if (sel.Equals("Jobs"))
            {
                LoadGroups<JobStatus>("All Jobs", result, x => x.Description);
            }

            else if (sel.Equals("TimeSheets"))
            {
                result[Guid.NewGuid()] = "Open TimeSheets";
                result[Guid.Empty] = "TimeSheet Starts";
                result[CoreUtils.FullGuid] = "TimeSheet Finishes";
            }

            else if (sel.Equals("Trackers"))
            {
                LoadGroups<GPSTrackerType>("All Trackers", result, x => x.Description);
            }

            return result;
        }

        private void ViewGroupSelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            _settings.ViewType = ViewType.SelectedIndex;
            _settings.ViewGroup = ViewGroup.SelectedIndex;
            new UserConfiguration<LiveMapsSettings>().Save(_settings);
            Refresh();
        }

        private void LoadDayMarkers()
        {
            ViewModel.Markers.Clear();
        }

        private void LoadMarkers<T>(Filter<T> filter, Expression<Func<T, object>> guid, Expression<Func<T, object>> code,
            Expression<Func<T, object>> description, Expression<Func<T, object>> deviceid, Expression<Func<T, object>> latitude,
            Expression<Func<T, object>> longitude, Expression<Func<T, object>> updatedby, Expression<Func<T, object>> timestamp, bool first = true)
            where T : Entity, IRemotable, IPersistent, new()
        {
            ViewModel.Clear();
            var columns = Columns.None<T>().Add(guid, code, description, latitude, longitude, timestamp, updatedby);
            if (deviceid != null)
                columns.Add(deviceid);

            new Client<T>().Query(
                filter,
                columns,
                null,
                CoreRange.All,
                (table, error) =>
                {
                    Dispatcher.Invoke(() =>
                    {
                        ViewModel.Markers.Clear();
                        if (error != null)
                        {
                            MessageBox.Show(error.Message);
                        }
                        else
                        {
                            var values = new Dictionary<Guid, DbMarker>();
                            foreach (var row in table.Rows)
                            {
                                var id = (Guid)row.Get(guid);
                                var time = (DateTime)row.Get(timestamp);
                                if (!values.ContainsKey(id) || (first ? values[id].TimeStamp < time : values[id].TimeStamp > time))
                                    values[id] = new DbMarker(
                                        code != null ? (string)row.Get(code) : "",
                                        (string)row.Get(description),
                                        time,
                                        (double)row.Get(latitude),
                                        (double)row.Get(longitude),
                                        (string)row.Get(updatedby),
                                        deviceid != null ? (string)row.Get(deviceid) : ""
                                    );
                            }

                            foreach (var key in values.Keys)
                                ViewModel.AddMarker(
                                    new MapMarker
                                    {
                                        ID = key,
                                        Label = values[key].Code,
                                        Latitude = string.Format("{0:F6}", values[key].Latitude),
                                        Longitude = string.Format("{0:F6}", values[key].Longitude),
                                        Description = values[key].Description,
                                        Updated = values[key].TimeStamp,
                                        UpdatedBy = values[key].UpdatedBy,
                                        DeviceID = values[key].DeviceID
                                    }
                                );
                            ViewModel.Refresh();
                        }

                        //if (bFirst)
                        ResetZoom();
                        bFirst = false;

                        LoadMarkerList();
                    });
                }
            );
        }

        private void ResetZoom()
        {
            var nwLon = double.MaxValue;
            var nwLat = double.MinValue;
            var seLon = double.MinValue;
            var seLat = double.MaxValue;

            foreach (var marker in ViewModel.Markers)
            {
                var lat = double.Parse(marker.Latitude);
                var lon = double.Parse(marker.Longitude);
                if (lat != 0.0F && lon != 0.00)
                {
                    nwLat = lat > nwLat ? lat : nwLat;
                    seLat = lat < seLat ? lat : seLat;
                    nwLon = lon < nwLon ? lon : nwLon;
                    seLon = lon > seLon ? lon : seLon;
                }
            }

            var layer = Map.Layers[0] as ImageryLayer;
            var cLat = (nwLat + seLat) / 2.0F;
            var cLon = (nwLon + seLon) / 2.0F;
            layer.Center = new Point(cLat, cLon);
            layer.DistanceType = DistanceType.KiloMeter;
            var c = new Location { Latitude = cLat, Longitude = cLon };
            var nw = new Location { Latitude = nwLat, Longitude = nwLon };
            layer.Radius = c.DistanceTo(nw, UnitOfLength.Kilometers) / 2.0F;
        }

        private void ZoomIn_Click(object sender, RoutedEventArgs e)
        {
            CenterMap();
            if (Map.ZoomLevel < 20)
            {
                Map.ZoomLevel++;
                LoadMarkerList();
            }
        }

        private void ZoomOut_Click(object sender, RoutedEventArgs e)
        {
            CenterMap();
            if (Map.ZoomLevel > 1)
            {
                Map.ZoomLevel--;
                LoadMarkerList();
            }
        }

        private void Map_PreviewMouseWheel(object sender, MouseWheelEventArgs e)
        {
            //CenterMap();

            if (e.Delta > 0)
            {
                if (Zoom.Value < 20)
                    Zoom.Value++;
                e.Handled = true;
            }
            else if (e.Delta < 0)
            {
                if (Zoom.Value > 1)
                    Zoom.Value--;
                e.Handled = true;
            }
        }

        private void CenterMap()
        {
            var layer = Map.Layers[0] as ImageryLayer;
            var center = layer.GetLatLonFromPoint(new Point(Map.ActualWidth / 2.0F, Map.ActualHeight / 2.0F));
            layer.Center = new Point(center.Y, center.X);
        }

        private void Map_PreviewMouseDoubleClick(object sender, MouseButtonEventArgs e)
        {
            var layer = Map.Layers[0] as ImageryLayer;
            var center = layer.GetLatLonFromPoint(e.GetPosition(Map));
            layer.Center = new Point(center.Y, center.X);
            if (Map.ZoomLevel < 20)
            {
                Map.ZoomLevel++;
                LoadMarkerList();
            }

            e.Handled = true;
        }

        private void Image_PreviewMouseDown(object sender, MouseButtonEventArgs e)
        {
            var border = sender as Border;

            //Point pBorder = border.TransformToAncestor(Map).Transform(new Point(0, 0));

            //var left = pBorder.X - 2;
            //var top = pBorder.Y - 2;
            //var right = left + border.ActualWidth + 4;
            //var bottom = top + border.ActualHeight + 4;

            //ImageryLayer layer = Map.Layers[0] as ImageryLayer;
            //var nw = layer.GetLatLonFromPoint(new Point(left, top));
            //var se = layer.GetLatLonFromPoint(new Point(right, bottom));

            var found = border.DataContext as MapMarker;
            Markers.SelectedItem = found;

            if (e.ClickCount > 1 && e.ButtonState == MouseButtonState.Pressed && e.ChangedButton == MouseButton.Left)
                ZoomToMarker(found);
            //foreach (var marker in viewmodel.Markers)
            //{

            //    if (IsMarkerVisible(marker, nw, se))
            //    {
            //        found = marker;
            //        break;
            //    }
            //}
            //if (found != null)
            //{
            //    Description.Text = found.Description;
            //    LastUpdate.Text = String.Format("{0:dd MMM yy hh:mm:ss}", found.Updated);
            //    Device.Text = found.UpdatedBy;
            //    History.Visibility = String.IsNullOrWhiteSpace(found.DeviceID) ? Visibility.Collapsed : Visibility.Visible;
            //    LoadDeviceHistory(found.DeviceID);
            //    viewmodel.Selected = found;
            //}
            //else
            //{
            //    Description.Text = "";
            //    LastUpdate.Text = "";
            //    Device.Text = "";
            //    History.Visibility = Visibility.Collapsed;
            //}
        }

        private void Date_DateChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            var marker = Markers.SelectedItem as MapMarker;
            if (marker == null)
                return;
            LoadDeviceHistory(marker.DeviceID);
        }
        
        private class WayPoint
        {
            public PointF Location { get; set; }
            public DateTime From { get; set; }
            public DateTime To { get; set; }
        }

        private void LoadDeviceHistory(string deviceID)
        {
            
            new Client<GPSTrackerLocation>().Query(
                new Filter<GPSTrackerLocation>(x => x.DeviceID).IsEqualTo(deviceID)
                    .And(x => x.Location.Timestamp).IsGreaterThanOrEqualTo(Date.Date.Date)
                    .And(x => x.Location.Timestamp).IsLessThan(Date.Date.Date.AddDays(1)),
                null,
                new SortOrder<GPSTrackerLocation>(x => x.Location.Timestamp, SortDirection.Descending),
                CoreRange.All,
                (table, error) =>
                {
                    
                    var movements = new ObservableCollection<GPSHistory>();
                    if (table != null)
                    {
                        var updates = new List<GPSTrackerLocation>();
                        var last = new Location { Latitude = 0.0F, Longitude = 0.0F };

                        var q = new List<CoreRow>();
                        for (var i = 0; i < Math.Min(3, table.Rows.Count); i++)
                            q.Add(table.Rows[i]);

                        if (q.Count > 0)
                            AddHistory(movements, updates, q[0]);

                        for (var i = 3; i < table.Rows.Count; i++)
                        {
                            if (Moved(q, 0, 1) || Moved(q, 1, 2))
                                AddHistory(movements, updates, q[1]);

                            // Slide the window up
                            q.RemoveAt(0);
                            q.Add(table.Rows[i]);
                        }

                        // If there are only two records in the table,
                        // make sure we add the second
                        if (q.Count == 2)
                            AddHistory(movements, updates, q[1]);

                        // if there are three or more records,
                        // make sure we add the last
                        if (Moved(q, 2, 3))
                            AddHistory(movements, updates, q[2]);

                        //foreach (var row in table.Rows)
                        //{
                        //    InABox.Core.Location cur = new InABox.Core.Location() { Latitude = row.Get<GPSTrackerLocation, double>(x => x.Location.Latitude), Longitude = row.Get<GPSTrackerLocation, double>(x => x.Location.Longitude) };
                        //    if ((cur.Latitude != 0.0F) && (cur.Longitude != 0.0F)) // && (cur.DistanceTo(last, UnitOfLength.Kilometers) * 1000F > 500F))
                        //    {
                        //        AddHistory(movements, updates, row);
                        //        last = cur;
                        //    }
                        //}

                        if (updates.Any())
                            new Client<GPSTrackerLocation>().Save(updates, "", (o, e) => { });

                        if (!movements.Any())
                        {
                            var history = new GPSHistory
                            {
                                Date = DateTime.Today,
                                Description = "No Activity Recorded",
                                Latitude = 0.0F,
                                Longitude = 0.0F
                            };
                             movements.Add(history);
                        }
                    }
                    
                    List<WayPoint> waypoints = new List<WayPoint>();
                    WayPoint? previous = null;
                    foreach (var movement in movements.OrderBy(x=>x.Date))
                    {
                        var current = new PointF((float)movement.Longitude, (float)movement.Latitude);
                        
                        if (previous == null || Location.DistanceBetween(previous.Location, current, UnitOfLength.Kilometers) >= 0.05)
                        {
                            previous = new WayPoint()
                            {
                                Location = new PointF((float)movement.Longitude, (float)movement.Latitude),
                                From = movement.Date,
                                To = movement.Date
                            };
                            waypoints.Add(previous);
                        }
                        else
                            previous.To = movement.Date;
                    }

                    Dispatcher.BeginInvoke(() =>
                    {
                        foreach (var waypoint in waypoints.Where(x=>x.To - x.From >= TimeSpan.FromMinutes(15)))
                        {
                            ViewModel.AddWayPoint(new MapMarker()
                            {
                                Label = $"{waypoint.From:h:mm}-{waypoint.To:h:mm}",
                                Latitude = string.Format("{0:F6}", waypoint.Location.Y),
                                Longitude = string.Format("{0:F6}", waypoint.Location.X),
                            });
                        }
                        ViewModel.Refresh();
                        History.ItemsSource = null;
                        History.ItemsSource = movements;
                    });
                }
            );
            

        }

        private bool Moved(List<CoreRow> rows, int row1, int row2)
        {
            if (rows.Count <= row1)
                return false;

            if (rows.Count <= row2)
                return false;
            //InABox.Core.Location c0 = new InABox.Core.Location() { Latitude = rows[row1].Get<GPSTrackerLocation, double>(x => x.Location.Latitude), Longitude = rows[row1].Get<GPSTrackerLocation, double>(x => x.Location.Longitude) };
            //InABox.Core.Location c1 = new InABox.Core.Location() { Latitude = rows[row2].Get<GPSTrackerLocation, double>(x => x.Location.Latitude), Longitude = rows[row2].Get<GPSTrackerLocation, double>(x => x.Location.Longitude) };
            //return c1.DistanceTo(c0, UnitOfLength.Kilometers) * 1000F > 25F;
            var bDate = DateTime.Equals(
                rows[row1].Get<GPSTrackerLocation, DateTime>(x => x.Created).Date,
                rows[row2].Get<GPSTrackerLocation, DateTime>(x => x.Created).Date
            );

            var bAddress = string.Equals(
                rows[row1].Get<GPSTrackerLocation, string>(x => x.Location.Address),
                rows[row2].Get<GPSTrackerLocation, string>(x => x.Location.Address)
            );

            return /* !bDate || */ !bAddress;
        }

        private void AddHistory(ObservableCollection<GPSHistory> movements, List<GPSTrackerLocation> updates, CoreRow row)
        {
            var cur = new Location
            {
                Latitude = row.Get<GPSTrackerLocation, double>(x => x.Location.Latitude),
                Longitude = row.Get<GPSTrackerLocation, double>(x => x.Location.Longitude)
            };
            var address = row.Get<GPSTrackerLocation, string>(x => x.Location.Address);
            if (string.IsNullOrWhiteSpace(address))
            {
                address = StoreUtils.ReverseGeocode(cur.Latitude, cur.Longitude);
                var update = row.ToObject<GPSTrackerLocation>();
                update.Location.Address = address;
                updates.Add(update);
            }

            var history = new GPSHistory
            {
                Date = row.Get<GPSTrackerLocation, DateTime>(x => x.Location.Timestamp),
                Description = address,
                Latitude = cur.Latitude,
                Longitude = cur.Longitude
            };
            Dispatcher.Invoke(() => { movements.Add(history); });
        }

        private static bool IsMarkerVisible(MapMarker marker, Point northwest, Point southeast)
        {
            if (northwest.X == 0 && northwest.Y == 0)
                return true;

            var lat = double.Parse(marker.Latitude);
            var lon = double.Parse(marker.Longitude);

            var lat1 = northwest.Y < 0 ? lat <= northwest.Y : lat > northwest.Y;
            var lat2 = southeast.Y < 0 ? lat >= southeast.Y : lat <= southeast.Y;
            var lon1 = northwest.X < 0 ? lon <= northwest.X : lon > northwest.X;
            var lon2 = southeast.X < 0 ? lon >= southeast.X : lon <= southeast.X;

            return lat1 && lat2 && lon1 && lon2;
        }

        private void LoadMarkerList()
        {
            //var timer = new DispatcherTimer() { Interval = TimeSpan.FromMilliseconds(1) };
            //timer.Tick += ((t,e) => 
            //{
            //timer.IsEnabled = false;
            ViewModel.Refresh();

            var layer = Map.Layers[0] as ImageryLayer;
            var nw = layer.GetLatLonFromPoint(new Point(0F, 0F));
            var se = layer.GetLatLonFromPoint(new Point(Map.ActualWidth, Map.ActualHeight));
            var markers = ViewModel.Markers.Where(marker => ShowAll.IsChecked == true ? true : IsMarkerVisible(marker, nw, se))
                .OrderBy(x => x.Description);
            Markers.ItemsSource = markers.ToArray();
            //});
            //timer.IsEnabled = true;
        }

        private void Map_PreviewMouseUp(object sender, MouseButtonEventArgs e)
        {
            LoadMarkerList();
        }

        private void Markers_MouseDoubleClick(object sender, MouseButtonEventArgs e)
        {
            var marker = Markers.SelectedItem as MapMarker;
            ZoomToMarker(marker);
        }

        private void ZoomToMarker(MapMarker marker)
        {
            if (marker == null)
                return;
            
            if (double.Parse(marker.Latitude) != 0.0F && double.Parse(marker.Longitude) != 0.0F)
            {
                var layer = Map.Layers[0] as ImageryLayer;
                layer.Center = new Point(double.Parse(marker.Latitude), double.Parse(marker.Longitude));
                Map.ZoomLevel = ZOOMEDIN;
            }
        }

        private void Markers_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            var marker = Markers.SelectedItem as MapMarker;
            ViewModel.Selected = Markers.SelectedItem as MapMarker;

            if (marker != null)
            {
                Description.Text = marker.Description;
                LastUpdate.Text = string.Format("{0:dd MMM yy hh:mm:ss}", marker.Updated);
                Device.Text = marker.UpdatedBy;
                History.Visibility = string.IsNullOrWhiteSpace(marker.DeviceID) ? Visibility.Collapsed : Visibility.Visible;
                LoadDeviceHistory(marker.DeviceID);
            }
            else
            {
                Description.Text = "";
                LastUpdate.Text = "";
                Device.Text = "";
                History.Visibility = Visibility.Collapsed;
            }
        }

        private void Viewstyle_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            var layer = typeof(ImageryLayer);
            var type = LayerType.OSM;
            var style = BingMapStyle.Road;

            if (Viewstyle.SelectedItem == BingStandardViewStyle)
            {
                layer = typeof(ImageryLayer);
                type = LayerType.Bing;
                style = BingMapStyle.Road;
            }
            else if (Viewstyle.SelectedItem == BingTerrainViewStyle)
            {
                layer = typeof(ImageryLayer);
                type = LayerType.Bing;
                style = BingMapStyle.Aerial;
            }
            else if (Viewstyle.SelectedItem == BingTerrainLabelsViewStyle)
            {
                layer = typeof(ImageryLayer);
                type = LayerType.Bing;
                style = BingMapStyle.AerialWithLabels;
            }
            else if (Viewstyle.SelectedItem == GoogleMapsViewStyle)
            {
                layer = typeof(ImageryLayerExt);
            }
            else
            {
                layer = typeof(ImageryLayer);
                type = LayerType.OSM;
            }

            var cur = Map.Layers[0] as ImageryLayer;
            if (!cur.GetType().Equals(layer))
            {
                var center = cur.Center;
                var radius = cur.Radius;
                var template = cur.MarkerTemplate;
                Map.Layers.Clear();
                if (layer == typeof(ImageryLayer))
                    Map.Layers.Add(new ImageryLayer());
                else if (layer == typeof(ImageryLayerExt))
                    Map.Layers.Add(new ImageryLayerExt());
                cur = Map.Layers[0] as ImageryLayer;
                cur.Center = center;
                cur.Radius = radius;
                cur.MarkerTemplate = template;
                cur.Markers = ViewModel.Markers;
                cur.BingMapKey = "5kn7uPPBBGKdmWYiwHJL~LjUY7IIgFzGdXpkpWT7Fsw~AmlksNuYOBHNQ3cOa61Nz2ghvK5EbrBZ3aQqvTS4OjcPxTBGNGsj2hKc058CgtgJ";
            }

            if (cur.LayerType != type)
                cur.LayerType = type;
            if (cur.BingMapStyle != style)
                cur.BingMapStyle = style;
        }

        private void IncludeVisibleMarkers_Checked(object sender, RoutedEventArgs e)
        {
            LoadMarkerList();
        }

        private void ResetView_Click(object sender, RoutedEventArgs e)
        {
            ResetZoom();
        }

        private void History_MouseDoubleClick(object sender, MouseButtonEventArgs e)
        {
            var history = History.SelectedItem as GPSHistory;
            if (history == null)
                return;
            if (history.Latitude != 0.0F && history.Longitude != 0.0F)
            {
                var layer = Map.Layers[0] as ImageryLayer;
                layer.Center = new Point(history.Latitude, history.Longitude);
                Map.ZoomLevel = ZOOMEDIN;
            }
        }

        private void Zoom_ValueChanged(object sender, RoutedPropertyChangedEventArgs<double> e)
        {
            if (Map == null)
                return;
            Map.ZoomLevel = (int)e.NewValue;
            LoadMarkerList();
        }

        private class DbMarker
        {
            public DbMarker(string code, string description, DateTime timestamp, double latitude, double longitude, string updatedby, string deviceid)
            {
                Code = code;
                Description = description;
                TimeStamp = timestamp;
                Latitude = latitude;
                Longitude = longitude;
                UpdatedBy = updatedby;
                DeviceID = deviceid;
            }

            public string Code { get; }
            public string Description { get; }
            public DateTime TimeStamp { get; }
            public double Latitude { get; }
            public double Longitude { get; }
            public string UpdatedBy { get; }
            public string DeviceID { get; }
        }

        private void TabView_PageChanged(object sender, SelectionChangedEventArgs e)
        {
            ViewModel.View = TabView.SelectedIndex == 0
                ? MapViewType.Current
                : MapViewType.History;
            // ImageryLayer.MarkerTemplate = TabView.SelectedIndex == 0
            //     ? TryFindResource("MapMarkerTemplate") as DataTemplate
            //     : TryFindResource("MapWayPointTemplate") as DataTemplate;
        }
    }
}