{

/// <summary>

/// occurs when clicked on map.

/// </summary>

public event MapClick OnMapClick;

/// <summary>

/// occurs when double clicked on map.

/// </summary>

public event MapDoubleClick OnMapDoubleClick;

/// <summary>

/// occurs when clicked on marker

/// </summary>

public event MarkerClick OnMarkerClick;

/// <summary>

/// occurs when double clicked on marker

/// </summary>

public event MarkerDoubleClick OnMarkerDoubleClick;

/// <summary>

/// occurs when clicked on polygon

/// </summary>

public event PolygonClick OnPolygonClick;

/// <summary>

/// occurs when double clicked on polygon

/// </summary>

public event PolygonDoubleClick OnPolygonDoubleClick;

/// <summary>

/// occurs when clicked on route

/// </summary>

public event RouteClick OnRouteClick;

/// <summary>

/// occurs when double clicked on route

/// </summary>

public event RouteDoubleClick OnRouteDoubleClick;

/// <summary>

/// occurs on mouse enters route area

/// </summary>

public event RouteEnter OnRouteEnter;

/// <summary>

/// occurs on mouse leaves route area

/// </summary>

public event RouteLeave OnRouteLeave;

/// <summary>

/// occurs when mouse selection is changed

/// </summary>

public event SelectionChange OnSelectionChange;

/// <summary>

/// occurs on mouse enters marker area

/// </summary>

public event MarkerEnter OnMarkerEnter;

/// <summary>

/// occurs on mouse leaves marker area

/// </summary>

public event MarkerLeave OnMarkerLeave;

/// <summary>

/// occurs on mouse enters Polygon area

/// </summary>

public event PolygonEnter OnPolygonEnter;

/// <summary>

/// occurs on mouse leaves Polygon area

/// </summary>

public event PolygonLeave OnPolygonLeave;

/// <summary>

/// occurs when an exception is thrown inside the map control

/// </summary>

public event ExceptionThrown OnExceptionThrown;

/// <summary>

/// list of overlays, should be thread safe

/// </summary>

public readonly ObservableCollectionThreadSafe<GMapOverlay> Overlays =

new ObservableCollectionThreadSafe<GMapOverlay>();

/// <summary>

/// max zoom

/// </summary>

[Category("GMap.NET")]

[Description("maximum zoom level of map")]

public int MaxZoom

{

get

{

return Core.MaxZoom;

}

set

{

Core.MaxZoom = value;

}

}

/// <summary>

/// min zoom

/// </summary>

[Category("GMap.NET")]

[Description("minimum zoom level of map")]

public int MinZoom

{

get

{

return Core.MinZoom;

}

set

{

Core.MinZoom = value;

}

}

/// <summary>

/// map zooming type for mouse wheel

/// </summary>

[Category("GMap.NET")]

[Description("map zooming type for mouse wheel")]

public MouseWheelZoomType MouseWheelZoomType

{

get

{

return Core.MouseWheelZoomType;

}

set

{

Core.MouseWheelZoomType = value;

}

}

/// <summary>

/// Import From Kmz

/// </summary>

/// <param name="file"></param>

/// <returns></returns>

[Category("GMap.NET")]

[Description("Import From Kmz")]

public bool ImportFromKmz(string file)

{

try

{

return true;

}

catch (Exception)

{

return false;

}

}

/// <summary>

/// Export From Kmz

/// </summary>

/// <param name="file"></param>

/// <returns></returns>

[Category("GMap.NET")]

[Description("Export From Kmz")]

public bool ExportFromKmz(string file)

{

try

{

return true;

}

catch (Exception)

{

return false;

}

}

/// <summary>

/// enable map zoom on mouse wheel

/// </summary>

[Category("GMap.NET")]

[Description("enable map zoom on mouse wheel")]

public bool MouseWheelZoomEnabled

{

get

{

return Core.MouseWheelZoomEnabled;

}

set

{

Core.MouseWheelZoomEnabled = value;

}

}

/// <summary>

/// text on empty tiles

/// </summary>

public string EmptyTileText = "We are sorry, but we don't\nhave imagery at this zoom\nlevel for this region.";

/// <summary>

/// pen for empty tile borders

/// </summary>

public Pen EmptyTileBorders = new Pen(Brushes.White, 1);

public bool ShowCenter = true;

/// <summary>

/// pen for scale info

/// </summary>

public Pen ScalePen = new Pen(Color.Black, 3);

public Pen ScalePenBorder = new Pen(Color.WhiteSmoke, 6);

public Pen CenterPen = new Pen(Brushes.Red, 1);

/// <summary>

/// area selection pen

/// </summary>

public Pen SelectionPen = new Pen(Brushes.Blue, 2);

Brush _selectedAreaFill = new SolidBrush(Color.FromArgb(33, Color.RoyalBlue));

Color _selectedAreaFillColor = Color.FromArgb(33, Color.RoyalBlue);

/// <summary>

/// background of selected area

/// </summary>

[Category("GMap.NET")]

[Description("background color od the selected area")]

public Color SelectedAreaFillColor

{

get

{

return _selectedAreaFillColor;

}

set

{

if (_selectedAreaFillColor != value)

{

_selectedAreaFillColor = value;

if (_selectedAreaFill != null)

{

_selectedAreaFill.Dispose();

_selectedAreaFill = null;

}

_selectedAreaFill = new SolidBrush(_selectedAreaFillColor);

}

}

}

HelperLineOptions _helperLineOption = HelperLineOptions.DontShow;

/// <summary>

/// draw lines at the mouse pointer position

/// </summary>

[Browsable(false)]

public HelperLineOptions HelperLineOption

{

get

{

return _helperLineOption;

}

set

{

_helperLineOption = value;

_renderHelperLine = _helperLineOption == HelperLineOptions.ShowAlways;

if (Core.IsStarted)

{

Invalidate();

}

}

}

public Pen HelperLinePen = new Pen(Color.Blue, 1);

bool _renderHelperLine;

protected override void OnKeyDown(KeyEventArgs e)

{

base.OnKeyDown(e);

if (HelperLineOption == HelperLineOptions.ShowOnModifierKey)

{

_renderHelperLine = e.Modifiers == Keys.Shift || e.Modifiers == Keys.Alt;

if (_renderHelperLine)

{

Invalidate();

}

}

}

protected override void OnKeyUp(KeyEventArgs e)

{

base.OnKeyUp(e);

if (HelperLineOption == HelperLineOptions.ShowOnModifierKey)

{

_renderHelperLine = e.Modifiers == Keys.Shift || e.Modifiers == Keys.Alt;

if (!_renderHelperLine)

{

Invalidate();

}

}

}

Brush _emptyTileBrush = new SolidBrush(Color.Navy);

Color _emptyTileColor = Color.Navy;

/// <summary>

/// color of empty tile background

/// </summary>

[Category("GMap.NET")]

[Description("background color of the empty tile")]

public Color EmptyTileColor

{

get

{

return _emptyTileColor;

}

set

{

if (_emptyTileColor != value)

{

_emptyTileColor = value;

if (_emptyTileBrush != null)

{

_emptyTileBrush.Dispose();

_emptyTileBrush = null;

}

_emptyTileBrush = new SolidBrush(_emptyTileColor);

}

}

}

/// <summary>

/// show map scale info

/// </summary>

public bool MapScaleInfoEnabled = false;

/// <summary>

/// Position of the map scale info

/// </summary>

public MapScaleInfoPosition MapScaleInfoPosition;

/// <summary>

/// enables filling empty tiles using lower level images

/// </summary>

public bool FillEmptyTiles = true;

/// <summary>

/// if true, selects area just by holding mouse and moving

/// </summary>

public bool DisableAltForSelection = false;

/// <summary>

/// retry count to get tile

/// </summary>

[Browsable(false)]

public int RetryLoadTile

{

get

{

return Core.RetryLoadTile;

}

set

{

Core.RetryLoadTile = value;

}

}

/// <summary>

/// how many levels of tiles are staying decompresed in memory

/// </summary>

[Browsable(false)]

public int LevelsKeepInMemory

{

get

{

return Core.LevelsKeepInMemory;

}

set

{

Core.LevelsKeepInMemory = value;

}

}

/// <summary>

/// map dragg button

/// </summary>

[Category("GMap.NET")] public MouseButtons DragButton = MouseButtons.Right;

private bool _showTileGridLines;

/// <summary>

/// shows tile gridlines

/// </summary>

[Category("GMap.NET")]

[Description("shows tile gridlines")]

public bool ShowTileGridLines

{

get

{

return _showTileGridLines;

}

set

{

_showTileGridLines = value;

Invalidate();

}

}

/// <summary>

/// current selected area in map

/// </summary>

private RectLatLng _selectedArea;

[Browsable(false)]

public RectLatLng SelectedArea

{

get

{

return _selectedArea;

}

set

{

_selectedArea = value;

if (Core.IsStarted)

{

Invalidate();

}

}

}

/// <summary>

/// map boundaries

/// </summary>

public RectLatLng? BoundsOfMap = null;

/// <summary>

/// enables integrated DoubleBuffer for running on windows mobile

/// </summary>

public bool ForceDoubleBuffer;

readonly bool MobileMode = false;

/// <summary>

/// stops immediate marker/route/polygon invalidations;

/// call Refresh to perform single refresh and reset invalidation state

/// </summary>

public bool HoldInvalidation;

/// <summary>

/// call this to stop HoldInvalidation and perform single forced instant refresh

/// </summary>

public override void Refresh()

{

HoldInvalidation = false;

lock (Core.InvalidationLock)

{

Core.LastInvalidation = DateTime.Now;

}

base.Refresh();

}

#if !DESIGN

/// <summary>

/// enque built-in thread safe invalidation

/// </summary>

public new void Invalidate()

{

if (Core.Refresh != null)

{

Core.Refresh.Set();

}

}

#endif

private bool _grayScale;

[Category("GMap.NET")]

public bool GrayScaleMode

{

get

{

return _grayScale;

}

set

{

_grayScale = value;

ColorMatrix = value ? ColorMatrixs.GrayScale : null;

}

}

private bool _negative;

[Category("GMap.NET")]

public bool NegativeMode

{

get

{

return _negative;

}

set

{

_negative = value;

ColorMatrix = value ? ColorMatrixs.Negative : null;

}

}

ColorMatrix _colorMatrix;

[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

[Browsable(false)]

public ColorMatrix ColorMatrix

{

get

{

return _colorMatrix;

}

set

{

_colorMatrix = value;

if (GMapProvider.TileImageProxy != null && GMapProvider.TileImageProxy is GMapImageProxy)

{

(GMapProvider.TileImageProxy as GMapImageProxy).ColorMatrix = value;

if (Core.IsStarted)

{

ReloadMap();

}

}

}

}

// internal stuff

internal readonly Core Core = new Core();

internal readonly Font CopyrightFont = new Font(FontFamily.GenericSansSerif, 7, FontStyle.Regular);

internal readonly Font MissingDataFont = new Font(FontFamily.GenericSansSerif, 11, FontStyle.Bold);

Font ScaleFont = new Font(FontFamily.GenericSansSerif, 7, FontStyle.Regular);

internal readonly StringFormat CenterFormat = new StringFormat();

internal readonly StringFormat BottomFormat = new StringFormat();

readonly ImageAttributes _tileFlipXYAttributes = new ImageAttributes();

double _zoomReal;

Bitmap _backBuffer;

Graphics _gxOff;

#if !DESIGN

/// <summary>

/// construct

/// </summary>

public GMapControl()

{

if (!IsDesignerHosted)

{

SetStyle(ControlStyles.OptimizedDoubleBuffer, true);

SetStyle(ControlStyles.AllPaintingInWmPaint, true);

SetStyle(ControlStyles.UserPaint, true);

SetStyle(ControlStyles.Opaque, true);

ResizeRedraw = true;

_tileFlipXYAttributes.SetWrapMode(WrapMode.TileFlipXY);

// only one mode will be active, to get mixed mode create new ColorMatrix

GrayScaleMode = GrayScaleMode;

NegativeMode = NegativeMode;

Core.SystemType = "WindowsForms";

RenderMode = RenderMode.GDI_PLUS;

CenterFormat.Alignment = StringAlignment.Center;

CenterFormat.LineAlignment = StringAlignment.Center;

BottomFormat.Alignment = StringAlignment.Center;

BottomFormat.LineAlignment = StringAlignment.Far;

if (GMaps.Instance.IsRunningOnMono)

{

// no imports to move pointer

MouseWheelZoomType = MouseWheelZoomType.MousePositionWithoutCenter;

}

Overlays.CollectionChanged += Overlays_CollectionChanged;

}

}

#endif

static GMapControl()

{

if (!IsDesignerHosted)

{

GMapImageProxy.Enable();

GMaps.Instance.SQLitePing();

}

}

void Overlays_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)

{

if (e.NewItems != null)

{

foreach (GMapOverlay obj in e.NewItems)

{

if (obj != null)

{

obj.Control = this;

}

}

if (Core.IsStarted && !HoldInvalidation)

{

Invalidate();

}

}

}

void InvalidatorEngage(object sender, ProgressChangedEventArgs e)

{

base.Invalidate();

}

/// <summary>

/// update objects when map is draged/zoomed

/// </summary>

internal void ForceUpdateOverlays()

{

try

{

HoldInvalidation = true;

foreach (var o in Overlays)

{

if (o.IsVisibile)

{

o.ForceUpdate();

}

}

}

finally

{

Refresh();

}

}

/// <summary>

/// updates markers local position

/// </summary>

/// <param name="marker"></param>

public void UpdateMarkerLocalPosition(GMapMarker marker)

{

var p = FromLatLngToLocal(marker.Position);

{

if (!MobileMode)

{

p.OffsetNegative(Core.RenderOffset);

}

marker.LocalPosition = new Point((int)(p.X + marker.Offset.X), (int)(p.Y + marker.Offset.Y));

}

}

/// <summary>

/// updates routes local position

/// </summary>

/// <param name="route"></param>

public void UpdateRouteLocalPosition(GMapRoute route)

{

route.LocalPoints.Clear();

for (int i = 0; i < route.Points.Count; i++)

{

var p = FromLatLngToLocal(route.Points[i]);

if (!MobileMode)

{

p.OffsetNegative(Core.RenderOffset);

}

route.LocalPoints.Add(p);

}

route.UpdateGraphicsPath();

}

/// <summary>

/// updates polygons local position

/// </summary>

/// <param name="polygon"></param>

public void UpdatePolygonLocalPosition(GMapPolygon polygon)

{

polygon.LocalPoints.Clear();

for (int i = 0; i < polygon.Points.Count; i++)

{

var p = FromLatLngToLocal(polygon.Points[i]);

if (!MobileMode)

{

p.OffsetNegative(Core.RenderOffset);

}

polygon.LocalPoints.Add(p);

}

polygon.UpdateGraphicsPath();

}

/// <summary>

/// sets zoom to max to fit rect

/// </summary>

/// <param name="rect"></param>

/// <returns></returns>

public bool SetZoomToFitRect(RectLatLng rect)

{

if (_lazyEvents)

{

_lazySetZoomToFitRect = rect;

}

else

{

int maxZoom = Core.GetMaxZoomToFitRect(rect);

if (maxZoom > 0)

{

var center = new PointLatLng(rect.Lat - rect.HeightLat / 2, rect.Lng + rect.WidthLng / 2);

Position = center;

if (maxZoom > MaxZoom)

{

maxZoom = MaxZoom;

}

if ((int)Zoom != maxZoom)

{

Zoom = maxZoom;

}

return true;

}

}

return false;

}

RectLatLng? _lazySetZoomToFitRect;

bool _lazyEvents = true;

/// <summary>

/// sets to max zoom to fit all markers and centers them in map

/// </summary>

/// <param name="overlayId">overlay id or null to check all</param>

/// <returns></returns>

public bool ZoomAndCenterMarkers(string overlayId)

{

var rect = GetRectOfAllMarkers(overlayId);

if (rect.HasValue)

{

return SetZoomToFitRect(rect.Value);

}

return false;

}

/// <summary>

/// zooms and centers all route

/// </summary>

/// <param name="overlayId">overlay id or null to check all</param>

/// <returns></returns>

public bool ZoomAndCenterRoutes(string overlayId)

{

var rect = GetRectOfAllRoutes(overlayId);

if (rect.HasValue)

{

return SetZoomToFitRect(rect.Value);

}

return false;

}

/// <summary>

/// zooms and centers route

/// </summary>

/// <param name="route"></param>

/// <returns></returns>

public bool ZoomAndCenterRoute(MapRoute route)

{

var rect = GetRectOfRoute(route);

if (rect.HasValue)

{

return SetZoomToFitRect(rect.Value);

}

return false;

}

/// <summary>

/// gets rectangle with all objects inside

/// </summary>

/// <param name="overlayId">overlay id or null to check all except zoomInsignificant</param>

/// <returns></returns>

public RectLatLng? GetRectOfAllMarkers(string overlayId)

{

RectLatLng? ret = null;

double left = double.MaxValue;

double top = double.MinValue;

double right = double.MinValue;

double bottom = double.MaxValue;

foreach (var o in Overlays)

{

if (overlayId == null && o.IsZoomSignificant || o.Id == overlayId)

{

if (o.IsVisibile && o.Markers.Count > 0)

{

foreach (var m in o.Markers)

{

if (m.IsVisible)

{

// left

if (m.Position.Lng < left)

{

left = m.Position.Lng;

}

// top

if (m.Position.Lat > top)

{

top = m.Position.Lat;

}

// right

if (m.Position.Lng > right)

{

right = m.Position.Lng;

}

// bottom

if (m.Position.Lat < bottom)

{

bottom = m.Position.Lat;

}

}

}

}

}

}

if (left != double.MaxValue && right != double.MinValue && top != double.MinValue &&

bottom != double.MaxValue)

{

ret = RectLatLng.FromLTRB(left, top, right, bottom);

}

return ret;

}

/// <summary>

/// gets rectangle with all objects inside

/// </summary>

/// <param name="overlayId">overlay id or null to check all except zoomInsignificant</param>

/// <returns></returns>

public RectLatLng? GetRectOfAllRoutes(string overlayId)

{

RectLatLng? ret = null;

double left = double.MaxValue;

double top = double.MinValue;

double right = double.MinValue;

double bottom = double.MaxValue;

foreach (var o in Overlays)

{

if (overlayId == null && o.IsZoomSignificant || o.Id == overlayId)

{

if (o.IsVisibile && o.Routes.Count > 0)

{

foreach (var route in o.Routes)

{

if (route.IsVisible && route.From.HasValue && route.To.HasValue)

{

foreach (var p in route.Points)

{

// left

if (p.Lng < left)

{

left = p.Lng;

}

// top

if (p.Lat > top)

{

top = p.Lat;

}

// right

if (p.Lng > right)

{

right = p.Lng;

}

// bottom

if (p.Lat < bottom)

{

bottom = p.Lat;

}

}

}

}

}

}

}

if (left != double.MaxValue && right != double.MinValue && top != double.MinValue &&

bottom != double.MaxValue)

{

ret = RectLatLng.FromLTRB(left, top, right, bottom);

}

return ret;

}

/// <summary>

/// gets rect of route

/// </summary>

/// <param name="route"></param>

/// <returns></returns>

public RectLatLng? GetRectOfRoute(MapRoute route)

{

RectLatLng? ret = null;

double left = double.MaxValue;

double top = double.MinValue;

double right = double.MinValue;

double bottom = double.MaxValue;

if (route.From.HasValue && route.To.HasValue)

{

foreach (var p in route.Points)

{

// left

if (p.Lng < left)

{

left = p.Lng;

}

// top

if (p.Lat > top)

{

top = p.Lat;

}

// right

if (p.Lng > right)

{

right = p.Lng;

}

// bottom

if (p.Lat < bottom)

{

bottom = p.Lat;

}

}

ret = RectLatLng.FromLTRB(left, top, right, bottom);

}

return ret;

}

/// <summary>

/// gets image of the current view

/// </summary>