public MapAdapter(GMapControl mapControl)
        {
            _context = new WindowsFormsSynchronizationContext();

            _mapControl = mapControl;

            IObservable<Unit> positionChanged = Observable
                .FromEvent<PositionChanged, PointLatLng>(
                    action => point => action(point),
                    handler => _mapControl.OnPositionChanged += handler,
                    handler => _mapControl.OnPositionChanged -= handler)
                .Select(i => Unit.Default);


            IObservable<Unit> mapZoom = Observable
                .FromEvent<MapZoomChanged, Unit>(
                    action => () => action(Unit.Default),
                    handler => _mapControl.OnMapZoomChanged += handler,
                    handler => _mapControl.OnMapZoomChanged -= handler);


            MapChanged = positionChanged
                .Merge(mapZoom)
                .ObserveOn(ThreadPoolScheduler.Instance);

            mapControl.OnMapDrag += MapControl_OnMapDrag;
            mapControl.OnPolygonClick += Control_OnPolygonClick;
        }

 public GMapMarkerTarget(PointLatLng p, GMapControl map, Bitmap icon)
     : base(p)
 {
     Size = SizeSt;
     MainMap = map;
     this.icon = icon;
 }

 public FeedMarker(PointLatLng loc, Article art, GMapControl gmap)
 {
     location = loc;
     article = art;
     this.gmap = gmap;
     addPIN(location);
 }

 public PloyLineOverLay(GMapControl map, string layid)
     : base(map, layid) {
     control = map;
     map.OnMarkerEnter += new MarkerEnter(map_OnMarkerEnter);
     map.OnMarkerLeave += new MarkerLeave(map_OnMarkerLeave);
     map.OnMapZoomChanged += new MapZoomChanged(map_OnMapZoomChanged);
 }

 public LineOverlay(GMapControl map, string lineCode)
     : base(map, lineCode) {
     map.OnMarkerEnter += new MarkerEnter(map_OnMarkerEnter);
     map.OnMarkerLeave += new MarkerLeave(map_OnMarkerLeave);
     map.OnMapZoomChanged += new MapZoomChanged(map_OnMapZoomChanged);
     this.Markers.CollectionChanged += new GMap.NET.ObjectModel.NotifyCollectionChangedEventHandler(Markers_CollectionChanged);
     control = map;
 }

 public static void DrawPoint(GMapControl map, decimal latitude, decimal longitude)
 {
     GMapOverlay overlay = new GMapOverlay(map, "Stop");
     overlay.Markers.Add(new GMap.NET.WindowsForms.Markers.GMapMarkerGoogleGreen(new PointLatLng((double)latitude, (double)longitude)));
     map.Overlays.Add(overlay);
     map.ZoomAndCenterMarkers(overlay.Id);
     map.Zoom -= 2;
 }

 static void DoDebug()
 {
     polygons = new GMapOverlay("polygons");
     map = new GMapControl();
     var form = new Form() { Size = new Size(1024, 768), WindowState = FormWindowState.Maximized };
     map.Dock = DockStyle.Fill;
     map.MapProvider = GMapProviders.GoogleSatelliteMap;
     map.MaxZoom = 20;
     map.Overlays.Add(polygons);
     form.Controls.Add(map);
     form.Show();
 }

        private Main parent; // for SQL queries

        #endregion Fields

        #region Constructors

        /// <summary>
        /// Constructors GoogleMap and sets gmap and the parent.
        /// Initialises the first overlay of the map.
        /// </summary>
        public GoogleMap(GMapControl gmap, Main parent)
        {
            if (gmap == null) throw new ArgumentNullException();
            if (parent == null) throw new ArgumentNullException();

            this.parent = parent;
            this.gmap = gmap;

            // overlay layer to add markers on the map
            GMapOverlay overlay = new GMapOverlay("first_layer");
            gmap.Overlays.Add(overlay);
        }

      public GMapOverlay(GMapControl control, string id)
      {
         if(control == null)
         {
            throw new Exception("GMapControl in GMapOverlay can't be null");
         }

         Control = control;
         Id = id;
         Markers.CollectionChanged += new NotifyCollectionChangedEventHandler(Markers_CollectionChanged);
         Routes.CollectionChanged += new NotifyCollectionChangedEventHandler(Routes_CollectionChanged);
         Polygons.CollectionChanged += new NotifyCollectionChangedEventHandler(Polygons_CollectionChanged);
      }

        public override void OnLoad(GMapControl gMapControl)
        {
            _gMapControl = gMapControl;
            _gMapControl.Overlays.Add(_gMapOverlay);

            _points = new List<PointLatLng>();
            _gMapControl.Overlays.Add(_gMapOverlay);
            _gMapControl.Overlays.Add(_highLightOverlay);
            _start = false;
            _queryResultForm = new QueryResultForm();
            this._mapUrl = ((SuperMapProvider)gMapControl.MapProvider).ServiceUrl;
            this._mapName = ((SuperMapProvider)gMapControl.MapProvider).MapName;
            InitLayers();
            base.OnLoad(gMapControl);
        }

        public StaticImage(GMapControl main)
        {
            InitializeComponent();

             this.MainMap = main;

             numericUpDown1.Maximum = MainMap.MaxZoom;
             numericUpDown1.Minimum = MainMap.MinZoom;
             numericUpDown1.Value = MainMap.Zoom;

             bg.WorkerReportsProgress = true;
             bg.WorkerSupportsCancellation = true;
             bg.DoWork += new DoWorkEventHandler(bg_DoWork);
             bg.ProgressChanged += new ProgressChangedEventHandler(bg_ProgressChanged);
             bg.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bg_RunWorkerCompleted);
        }

        public MapPrintPreviewForm(GMapControl ctrlGMap)
            : this()
        {
            #region Create Map copied

            gMap.Manager.Mode = AccessMode.ServerOnly;
            gMap.MinZoom = ctrlGMap.MinZoom;
            gMap.MaxZoom = ctrlGMap.MaxZoom;
            gMap.Zoom = ctrlGMap.Zoom;
            gMap.Position = ctrlGMap.Position;
            gMap.MouseWheelZoomEnabled = ctrlGMap.MouseWheelZoomEnabled;
            gMap.MouseWheelZoomType = ctrlGMap.MouseWheelZoomType;
            gMap.EmptyTileColor = System.Drawing.Color.Aquamarine;
            gMap.GrayScaleMode = true;
            gMap.Manager.UsePlacemarkCache = false;
            gMap.ConnectionString = (ctrlGMap is CustomGMapControl)
                ? ((CustomGMapControl)ctrlGMap).ConnectionString
                : null;
            gMap.OnTileLoadComplete += GMap_OnTileLoadComplete;
            gMap.OnTileLoadStart += GMap_OnTileLoadStart;
            gMap.Manager.UseMemoryCache = true;

            //gMap.Manager.CancelTileCaching();

            foreach (GMapOverlay overlay in ctrlGMap.Overlays)
            {
                foreach (var marker in overlay.Markers)
                {
                    gMap.AddMarker(marker);
                }

                foreach (var route in overlay.Routes)
                {
                    var r = new GMapRoute(route.Name);
                    r.Points.AddRange(route.Points);
                    r.Stroke = route.Stroke;

                    gMap.AddRoute(r);
                }

                gMap.SetMapBound();
            }

            #endregion            
        }

        public static void DrawMap(GMapControl map, List<Point> points, Color color, bool includeMarkers)
        {
            Pen pen = new Pen(color, 3.0f);

            List<PointLatLng> allMapPoints = points.Select(point => new PointLatLng(point.Latitude, point.Longitude)).ToList();
            GMapRoute route = new GMapRoute(allMapPoints, "Route");
            route.Stroke = pen;
            map.ZoomAndCenterRoute(route);

            GMapOverlay overlay = new GMapOverlay(map, "Overlay");
            if (includeMarkers)
            {
                overlay.Markers.Add(new GMap.NET.WindowsForms.Markers.GMapMarkerGoogleGreen(new PointLatLng(allMapPoints.First().Lat, allMapPoints.First().Lng)));
                overlay.Markers.Add(new GMap.NET.WindowsForms.Markers.GMapMarkerGoogleRed(new PointLatLng(allMapPoints.Last().Lat, allMapPoints.Last().Lng)));
            }
            overlay.Routes.Add(route);
            map.Overlays.Add(overlay);
        }

        public GMapMarkerWind(PointLatLng p, GMapControl map, float bearing, float speed)
            : base(p)
        {
            Size = SizeSt;
            MainMap = map;

            this.bearing = bearing;
            this.speed = speed;

            if (speed > ORANGE_SPEED_LIMIT)
            {
                icon = global::SeaScanUAV.Properties.Resources.Orange_N;
            }
            else if (speed > RED_SPEED_LIMIT)
            {
                icon = global::SeaScanUAV.Properties.Resources.Red_N;
            }
        }

        public GMapRestImagery()
        {
            //_baseUri = baseUri;

            _levels = new RasterLevel[NumberOfLevels];
            _levelsCollection = new RasterLevelCollection(_levels);

            double deltaLongitude = LevelZeroDeltaLongitudeDegrees;
            double deltaLatitude = LevelZeroDeltaLatitudeDegrees;
            for (int i = 0; i < _levels.Length; ++i)
            {
                int longitudePosts = (int)Math.Round(360.0 / deltaLongitude) * TileLongitudePosts + 1;
                int latitudePosts = (int)Math.Round(180 / deltaLatitude) * TileLatitudePosts + 1;
                _levels[i] = new RasterLevel(this, i, _extent, longitudePosts, latitudePosts, TileLongitudePosts, TileLatitudePosts);
                deltaLongitude /= 2.0;
                deltaLatitude /= 2.0;
            }

            MainMap = new GMapControl();
            MainMap.MapType = GMap.NET.MapType.GoogleSatellite;

            MainMap.CacheLocation = Path.GetDirectoryName(Application.ExecutablePath) + "/gmapcache/";
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            MainMap = new GMapControl();
            MainMap.MapProvider = GMapProviders.OpenStreetMap;
            MainMap.Position = new PointLatLng(50.619900, 26.251617);
            MainMap.MinZoom = 3;
            MainMap.MaxZoom = 20;
            MainMap.Zoom = 9;
            MainMap.Dock = DockStyle.Fill;
            MainMap.MarkersEnabled = true;
            MainMap.PolygonsEnabled = true;
            MainMap.RoutesEnabled = true;
            MainMap.MouseClick += MainMap_MouseClick;
            MainMap.OnMarkerClick += MainMap_OnMarkerClick;
            //MainMap.OnPositionChanged += MainMap_OnPositionChanged;
            Controls.Add(MainMap);

            sl = new TrackBar();
            sl.Orientation = Orientation.Vertical;
            sl.TickStyle = TickStyle.Both;
            sl.TickFrequency = 10;
            sl.Maximum = 100;
            sl.Minimum = 1;
            sl.Value = (int)((MainMap.Zoom - MainMap.MinZoom)/ MainMap.MaxZoom * sl.Maximum);
            sl.Height = this.Height / 3;
            sl.Width = 50;
            sl.Location = new Point(MainMap.Width - sl.Width - 5, MainMap.Height - sl.Height -10);
            sl.ValueChanged += sl_ValueChanged;

            Controls.Add(sl);
            sl.BringToFront();

            markersOverlay = new GMapOverlay("markers");
            routeOverlay = new GMapOverlay("routes");
            isAddMarker = true;
        }

        static void DoDebug()
        {
            if (map != null)
            {
                if (map.Overlays.Count != 0)
                {
                    while (polygons.Markers.Count > 7)
                        polygons.Markers.RemoveAt(0);
                    //polygons.Markers.Clear();
                    return;
                }
            }

            polygons = new GMapOverlay("polygons");
            map = new GMapControl();
            var form = new Form() { Size = new Size(1024, 768), WindowState = FormWindowState.Maximized };
            map.Dock = DockStyle.Fill;
            map.MapProvider = GMapProviders.GoogleSatelliteMap;
            map.MaxZoom = 20;
            map.Overlays.Add(polygons);
            form.Controls.Add(map);
            form.Show();
        }

 public void assignMapToUpdate(GMapControl map)
 {
     _map = map;
 }

        private void BUT_geinjection_Click(object sender, EventArgs e)
        {
            GMapControl MainMap = new GMapControl();
            MainMap.MapType = GMap.NET.MapType.GoogleSatellite;

            MainMap.CacheLocation = Path.GetDirectoryName(Application.ExecutablePath) + "/gmapcache/";

            FolderBrowserDialog fbd = new FolderBrowserDialog();

            try
            {
                fbd.SelectedPath = @"C:\Users\hog\Documents\albany 2011\New folder";
            }
            catch { }

            fbd.ShowDialog();

            if (fbd.SelectedPath != "") {

                string[] files = Directory.GetFiles(fbd.SelectedPath,"*.jpg",SearchOption.AllDirectories);

                foreach (string file in files)
                {
                    log.Info(DateTime.Now.Millisecond +  " Doing "+ file);
                    Regex reg = new Regex(@"Z([0-9]+)\\([0-9]+)\\([0-9]+)");

                    Match mat = reg.Match(file);

                    int temp = 1 << int.Parse(mat.Groups[1].Value);

                    GMap.NET.GPoint pnt = new GMap.NET.GPoint(int.Parse(mat.Groups[3].Value), int.Parse(mat.Groups[2].Value));

                    BUT_geinjection.Text = file;
                    BUT_geinjection.Refresh();

                    //MainMap.Projection.

                    MemoryStream tile = new MemoryStream();

                    Image Img = Image.FromFile(file);
                    Img.Save(tile,System.Drawing.Imaging.ImageFormat.Jpeg);

                    tile.Seek(0, SeekOrigin.Begin);
                    log.Info(pnt.X + " " + pnt.Y);

                    Application.DoEvents();

                    MainMap.Manager.ImageCacheLocal.PutImageToCache(tile, GMap.NET.MapType.Custom, pnt, int.Parse(mat.Groups[1].Value));

                    Application.DoEvents();
                }
            }
        }

        private void BUT_clearcustommaps_Click(object sender, EventArgs e)
        {
            GMapControl MainMap = new GMapControl();
            MainMap.MapType = GMap.NET.MapType.GoogleSatellite;

            MainMap.CacheLocation = Path.GetDirectoryName(Application.ExecutablePath) + "/gmapcache/";

            int removed =  ((GMap.NET.CacheProviders.SQLitePureImageCache)MainMap.Manager.ImageCacheLocal).DeleteOlderThan(DateTime.Now, GMap.NET.MapType.Custom);

            CustomMessageBox.Show("Removed "+removed + " images\nshrinking file next");

            GMap.NET.CacheProviders.SQLitePureImageCache.VacuumDb(MainMap.CacheLocation + @"\TileDBv3\en\Data.gmdb");

            log.InfoFormat("Removed {0} images", removed);
        }