{

/// <summary>

/// A tolerance value

/// </summary>

private const double PrecisionTolerance = 0.00000001;

/// <summary>

/// The map image generation function to use when creating new <see cref="MapBox"/> instances

/// </summary>

private static Func<MapBox, ProgressBar, IMapBoxImageRenderer> _mapImageGeneratorFunction;

/// <summary>

/// Gets or sets the map image generation function to assign when creating new MapBox instances.

/// </summary>

public static Func<MapBox, ProgressBar, IMapBoxImageRenderer> MapImageGeneratorFunction

{

get => _mapImageGeneratorFunction ?? LegacyMapImageGenerator;

set => _mapImageGeneratorFunction = value;

}

/// <summary>

/// Creates a <see cref="IMapBoxImageRenderer"/> that mimics legacy image generation for <see cref="MapBox"/> control.

/// </summary>

/// <param name="mapBox">The map control</param>

/// <param name="progressBar">The progress bar</param>

/// <returns>An image generator for <see cref="MapBox"/> control</returns>

public static IMapBoxImageRenderer LegacyMapImageGenerator(MapBox mapBox, ProgressBar progressBar)

{

return new LegacyMapBoxImageGenerator(mapBox, progressBar);

}

/// <summary>

/// Creates a <see cref="IMapBoxImageRenderer"/> for <see cref="MapBox"/> control that works on a list of layers.

/// </summary>

/// <param name="mapBox">The map control</param>

/// <param name="progressBar">The progress bar</param>

/// <returns>An image generator for <see cref="MapBox"/> control</returns>

public static IMapBoxImageRenderer LayerListImageGenerator(MapBox mapBox, ProgressBar progressBar)

{

return new LayerListImageRenderer(mapBox, progressBar);

}

private static readonly ILog _logger = LogManager.GetLogger(typeof (MapBox));

static MapBox() { Map.Configure(); }

#region PreviewModes enumerator

// ReSharper disable UnusedMember.Local

/// <summary>

/// Preview modes

/// </summary>

[Obsolete("Not used anywhere")]

public enum PreviewModes

{

/// <summary>

/// Best preview mode

/// </summary>

Best,

/// <summary>

/// Fast preview mode

/// </summary>

Fast

}

#endregion

#region Position enumerators

/// <summary>

/// Horizontal alignment enumeration

/// </summary>

private enum XPosition

{

Center = 0,

Right = 1,

Left = -1

}

/// <summary>

/// Vertical alignment enumeration

/// </summary>

private enum YPosition

{

Center = 0,

Top = -1,

Bottom = 1

}

// ReSharper restore UnusedMember.Local

#endregion

#region Tools enumerator

/// <summary>

/// Map tools enumeration

/// </summary>

public enum Tools

{

/// <summary>

/// Pan

/// </summary>

Pan,

/// <summary>

/// Zoom in

/// </summary>

ZoomIn,

/// <summary>

/// Zoom out

/// </summary>

ZoomOut,

/// <summary>

/// Query bounding boxes for intersection

/// </summary>

QueryBox,

/// <summary>

/// Query tool

/// </summary>

[Obsolete ("Use QueryBox")]

Query = QueryBox,

/// <summary>

/// Attempt true intersection query on geometry

/// </summary>

QueryPoint,

/// <summary>

/// Attempt true intersection query on geometry

/// </summary>

[Obsolete ("Use QueryPoint")]

QueryGeometry = QueryPoint,

///// <summary>

///// Attempt true intersection query on polygonal geometry

///// </summary>

//QueryPolygon,

/// <summary>

/// Zoom window tool

/// </summary>

ZoomWindow,

/// <summary>

/// Define Point on Map

/// </summary>

DrawPoint,

/// <summary>

/// Define Line on Map

/// </summary>

DrawLine,

/// <summary>

/// Define Polygon on Map

/// </summary>

DrawPolygon,

/// <summary>

/// No active tool

/// </summary>

None,

/// <summary>

/// Custom tool, implementing <see cref="IMapTool"/>

/// </summary>

Custom

}

/// <summary>

/// Enumeration of map query types

/// </summary>

public enum MapQueryType

{

/// <summary>

/// Layer set in QueryLayerIndex is the only layers Queried (Default)

/// </summary>

LayerByIndex,

/// <summary>

/// All layers are queried

/// </summary>

AllLayers,

/// <summary>

/// All visible layers are queried

/// </summary>

VisibleLayers,

/// <summary>

/// Visible layers are queried from Top and down until a layer with an intersecting feature is found

/// </summary>

TopMostLayer

};

#endregion

#region Events

/// <summary>

/// MouseEventtype fired from the MapImage control

/// </summary>

/// <param name="worldPos"></param>

/// <param name="imagePos"></param>

public delegate void MouseEventHandler(Coordinate worldPos, MouseEventArgs imagePos);

/// <summary>

/// Fires when mouse moves over the map

/// </summary>

public new event MouseEventHandler MouseMove;

/// <summary>

/// Fires when map received a mouseclick

/// </summary>

public new event MouseEventHandler MouseDown;

/// <summary>

/// Fires when mouse is released

/// </summary>

public new event MouseEventHandler MouseUp;

/// <summary>

/// Fired when mouse is dragging

/// </summary>

public event MouseEventHandler MouseDrag;

/// <summary>

/// Fired when the map has been refreshed

/// </summary>

public event EventHandler MapRefreshed;

/// <summary>

/// Fired when the map is about to change

/// </summary>

public event CancelEventHandler MapChanging;

/// <summary>

/// Fired when the map has been changed

/// </summary>

public event EventHandler MapChanged;

/// <summary>

/// Eventtype fired when the zoom was or are being changed

/// </summary>

/// <param name="zoom"></param>

public delegate void MapZoomHandler(double zoom);

/// <summary>

/// Fired when the zoom value has changed

/// </summary>

public event MapZoomHandler MapZoomChanged;

/// <summary>

/// Fired when the map is being zoomed

/// </summary>

public event MapZoomHandler MapZooming;

/// <summary>

/// Eventtype fired when the map is queried

/// </summary>

/// <param name="data"></param>

public delegate void MapQueryHandler(Data.FeatureDataTable data);

/// <summary>

/// Fired when the map is queried

///

/// Will be fired one time for each layer selected for query depending on QueryLayerIndex and QuerySettings

/// </summary>

public event MapQueryHandler MapQueried;

/// <summary>

/// Fired when Map is Queried before the first MapQueried event is fired for that query

/// </summary>

public event EventHandler MapQueryStarted;

/// <summary>

/// Fired when Map is Queried after the last MapQueried event is fired for that query

/// </summary>

public event EventHandler MapQueryDone;

/// <summary>

/// Eventtype fired when the center has changed

/// </summary>

/// <param name="center"></param>

public delegate void MapCenterChangedHandler(Coordinate center);

/// <summary>

/// Fired when the center of the map has changed

/// </summary>

public event MapCenterChangedHandler MapCenterChanged;

/// <summary>

/// Eventtype fired befor the active map tool change

/// </summary>

/// <param name="toolPre">pre-tool</param>

/// <param name="toolNew">new tool</param>

/// <param name="cea">a cancel indicator</param>

public delegate void ActiveToolChangingHandler(Tools toolPre, Tools toolNew, CancelEventArgs cea);

/// <summary>

/// Fired befor the active map tool change

/// </summary>

public event ActiveToolChangingHandler ActiveToolChanging;

/// <summary>

/// Eventtype fired when the map tool is changed

/// </summary>

/// <param name="tool"></param>

public delegate void ActiveToolChangedHandler(Tools tool);

/// <summary>

/// Fired when the active map tool has changed

/// </summary>

public event ActiveToolChangedHandler ActiveToolChanged;

/// <summary>

/// Eventtype fired when a new geometry has been defined

/// </summary>

/// <param name="geometry">New Geometry</param>

public delegate void GeometryDefinedHandler(IGeometry geometry);

/// <summary>

/// Fired when a new polygon has been defined

/// </summary>

public event GeometryDefinedHandler GeometryDefined;

#endregion

private readonly IMapBoxImageRenderer _miRenderer;

private static int m_defaultColorIndex;

private static readonly Color[] _defaultColors ={

Color.DarkRed,

Color.DarkGreen,

Color.DarkBlue,

Color.Orange,

Color.Cyan,

Color.Black,

Color.Purple,

Color.Yellow,

Color.LightBlue,

Color.Fuchsia

};

/*

private readonly ProgressBar _progressBar;

#if DEBUG

private readonly Stopwatch _watch = new Stopwatch();

#endif

//private bool m_IsCtrlPressed;

private IMapTool _currentTool;

private double _wheelZoomMagnitude = -2;

private Tools _activeTool;

private double _fineZoomFactor = 10;

private Map _map;

private int _queryLayerIndex;

private Point _dragStartPoint;

private Point _dragEndPoint;

//private Bitmap _dragImage;

private Rectangle _rectangle = Rectangle.Empty;

private bool _dragging;

private readonly SolidBrush _rectangleBrush = new SolidBrush(Color.FromArgb(210, 244, 244, 244));

private readonly Pen _rectanglePen = new Pen(Color.FromArgb(244, 244, 244), 1);

private float _scaling;

//private Image _image = new Bitmap(1, 1);

//private Image _imageBackground = new Bitmap(1, 1);

//private Image _imageStatic = new Bitmap(1, 1);

//private Image _imageVariable = new Bitmap(1, 1);

//private Envelope _imageEnvelope = new Envelope(0, 1, 0, 1);

//private int _imageGeneration;

private readonly object _mapLocker = new object();

private int _needToRefreshAfterWheel;

[Obsolete]

private PreviewModes _previewMode;

//private bool _isRefreshing;

private List<Coordinate> _pointArray = new List<Coordinate>();

private bool _showProgress;

private bool _zoomToPointer = true;

private bool _setActiveToolNoneDuringRedraw;

private bool _shiftButtonDragRectangleZoom = true;

private bool _focusOnHover;

private bool _panOnClick = true;

private float _queryGrowFactor = 5f;

private MapQueryType _mapQueryMode = MapQueryType.LayerByIndex;

private readonly IMessageFilter _mousePreviewFilter;

/// <summary>

/// Assigns a random color to a vector layers style

/// </summary>

/// <param name="layer"></param>

public static void RandomizeLayerColors(VectorLayer layer)

{

layer.Style.EnableOutline = true;

layer.Style.Fill = new SolidBrush(Color.FromArgb(80, _defaultColors[m_defaultColorIndex%_defaultColors.Length]));

layer.Style.Outline =

new Pen(

Color.FromArgb(100,

_defaultColors[

(m_defaultColorIndex + ((int) (_defaultColors.Length*0.5)))%_defaultColors.Length]),

1f);

m_defaultColorIndex++;

}

/// <summary>

/// Gets a value indicating the name of the Image generator

/// </summary>

[Description("The name of the image renderer used")]

[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

public string ImageRendererName

{

get => MapImageGeneratorFunction.GetType().Name;

}

/// <summary>

/// Gets a value indicating the image renderer for this MapBox

/// </summary>

[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

public IMapBoxImageRenderer ImageRenderer { get => _miRenderer; }

/// <summary>

/// Gets or sets a value on whether to report progress of map generation

/// </summary>

[Description("Define if the progress Bar is shown")]

[Category("Appearance")]

public bool ShowProgressUpdate

{

get { return _showProgress; }

set

{

_showProgress = value;

_progressBar.Visible = _showProgress;

}

}

/// <summary>

/// Gets or sets whether the "go-to-cursor-on-click" feature is enabled or not (even if enabled it works only if the active tool is Pan)

/// </summary>

[Description(

"Sets whether the \"go-to-cursor-on-click\" feature is enabled or not (even if enabled it works only if the active tool is Pan)"

)]

[DefaultValue(true)]

[Category("Behavior")]

public bool PanOnClick

{

get { return _panOnClick; }

set

{

ActiveTool = Tools.Pan;

_panOnClick = value;

}

}

/// <summary>

/// Sets whether the mapcontrol should automatically grab focus when mouse is hovering the control

/// </summary>

[Description("Sets whether the mapcontrol should automatically grab focus when mouse is hovering the control")]

[DefaultValue(false)]

[Category("Behavior")]

public bool TakeFocusOnHover

{

get { return _focusOnHover; }

set { _focusOnHover = value; }

}

/// <summary>

/// Sets whether the mouse wheel should zoom to the pointer location

/// </summary>

[Description("Sets whether the mouse wheel should zoom to the pointer location")]

[DefaultValue(true)]

[Category("Behavior")]

public bool ZoomToPointer

{

get { return _zoomToPointer; }

set { _zoomToPointer = value; }

}

/// <summary>

/// Sets ActiveTool to None (and changing cursor) while redrawing the map

/// </summary>

[Description("Sets ActiveTool to None (and changing cursor) while redrawing the map")]

[DefaultValue(false)]

[Category("Behavior")]

public bool SetToolsNoneWhileRedrawing

{

get { return _setActiveToolNoneDuringRedraw; }

set { _setActiveToolNoneDuringRedraw = value; }

}

/// <summary>

/// Gets or sets the number of pixels by which a bounding box around the query point should be "grown" prior to perform the query

/// </summary>

/// <remarks>Does not apply when querying against boxes.</remarks>

[Description(

"Gets or sets the number of pixels by which a bounding box around the query point should be \"grown\" prior to perform the query"

)]

[DefaultValue(5)]

[Category("Behavior")]

public float QueryGrowFactor

{

get { return _queryGrowFactor; }

set

{

if (value < 0) value = 0;

//if (value > 10)

_queryGrowFactor = value;

}

}

/// <summary>

/// Gets or sets the value of the back color for the selection rectangle

/// </summary>

[Description("The color of selecting rectangle.")]

[Category("Appearance")]

public Color SelectionBackColor

{

get { return _rectangleBrush.Color; }

set

{

//if (value != m_RectangleBrush.Color)

_rectangleBrush.Color = value;

}

}

/// <summary>

/// Gets or sets the value of the border color for the selection rectangle

/// </summary>

[Description("The color of selectiong rectangle frame.")]

[Category("Appearance")]

public Color SelectionForeColor

{

get { return _rectanglePen.Color; }

set

{

//if (value != m_RectanglePen.Color)

_rectanglePen.Color = value;

}

}

/// <summary>

/// Gets the current map image

/// </summary>

[Description("The map image currently visualized.")]

[Category("Appearance")]

public Image Image

{

get

{

return _miRenderer.Image;

//GetImagesAsyncEnd(null);

//return _image;

}

}

/// <summary>

/// Gets or sets the amount which a single movement of the mouse wheel zooms by.

/// </summary>

[Description(

"The amount which a single movement of the mouse wheel zooms by. (Negative values are similar as OpenLayers/Google, positive are like ArcMap"

)]

[DefaultValue(-2)]

[Category("Behavior")]

public double WheelZoomMagnitude

{

get { return _wheelZoomMagnitude; }

set { _wheelZoomMagnitude = value; }

}

/// <summary>

/// Gets or sets the mode used to create preview image while panning or zooming.

/// </summary>

[Description("Mode used to create preview image while panning or zooming.")]

#pragma warning disable

[DefaultValue(PreviewModes.Best)]

#pragma warning restore

[Category("Behavior")]

[Obsolete("Not used anywhere")]

public PreviewModes PreviewMode

{

get { return _previewMode; }

set

{

if (!_dragging)

_previewMode = value;

}

}

/// <summary>

/// Gets or sets a value indicating the amount which the WheelZoomMagnitude is divided by

/// when the Control key is pressed. A number greater than 1 decreases

/// the zoom, and less than 1 increases it. A negative number reverses it.

/// </summary>

[Description("The amount which the WheelZoomMagnitude is divided by " +

"when the Control key is pressed. A number greater than 1 decreases " +

"the zoom, and less than 1 increases it. A negative number reverses it.")]

[DefaultValue(10)]

[Category("Behavior")]

public double FineZoomFactor

{

get { return _fineZoomFactor; }

set { _fineZoomFactor = value; }

}

/// <summary>

/// Gets or sets a value that enables shortcut to rectangle-zoom by holding down shift-button and drag rectangle

/// </summary>

[Description("Enables shortcut to rectangle-zoom by holding down shift-button and drag rectangle")]

[DefaultValue(true)]

[Category("Behavior")]

public bool EnableShiftButtonDragRectangleZoom

{

get { return _shiftButtonDragRectangleZoom; }

set { _shiftButtonDragRectangleZoom = value; }

}

/// <summary>

/// Gets or sets the map reference

/// </summary>

[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

public Map Map

{

get { return _map; }

set

{

if (value != _map)

{

var cea = new CancelEventArgs(false);

OnMapChanging(cea);

if (cea.Cancel) return;

_map = value;

using(var g = Graphics.FromImage(Image))

g.Clear(_map?.BackColor ?? SystemColors.Control);

OnMapChanged(EventArgs.Empty);

}

}

}

/// <summary>

/// Gets or sets the index of the active query layer

/// </summary>

public int QueryLayerIndex

{

get { return _queryLayerIndex; }

set { _queryLayerIndex = value; }

}

/// <summary>

/// Gets or sets the mapquerying mode

/// </summary>

public MapQueryType MapQueryMode

{

get { return _mapQueryMode; }

set { _mapQueryMode = value; }

}

/// <summary>

/// Sets the active map tool

/// </summary>

public Tools ActiveTool

{

get { return _activeTool; }

set

{

var cea = new CancelEventArgs(false);

OnActiveToolChanging(ActiveTool, value, cea);

if (cea.Cancel)

{

if (CustomTool != null)

CustomTool.Enabled = true;

return;

}

_activeTool = value;

SetCursor();

_pointArray = null;

OnActiveToolChanged(value);

}

}

/// <summary>

/// Event invoker for the <see cref="ActiveToolChanging"/>

/// </summary>

/// <param name="toolPre">pre-tool</param>

/// <param name="toolNew">new tool</param>

/// <param name="cea">a cancel indicator</param>

protected virtual void OnActiveToolChanging(Tools toolPre, Tools toolNew, CancelEventArgs cea)

{

if (CustomTool != null)

CustomTool.Enabled = false;

var handler = ActiveToolChanging;

if (handler != null)

handler(toolPre, toolNew, cea);

}

/// <summary>

/// Event invoker for the <see cref="ActiveToolChanged"/> event

/// </summary>

/// <param name="activeTool">The tool</param>

protected virtual void OnActiveToolChanged(Tools activeTool)

{

if (CustomTool != null)

CustomTool.Enabled = true;

var handler = ActiveToolChanged;

if (handler != null)

handler(activeTool);

}

/// <summary>

/// Gets or sets a value indicating the currently active custom tool

/// </summary>

public IMapTool CustomTool

{

get { return _currentTool; }

set

{

if (value == _currentTool)

return;

var raiseActiveToolChanged = ActiveTool == Tools.Custom && value != null;

_currentTool = value;

ActiveTool = _currentTool != null

? Tools.Custom

: Tools.None;

if (_currentTool != null)

_currentTool.Map = _map;

if (raiseActiveToolChanged)

OnActiveToolChanged(ActiveTool);

}

}

#pragma warning disable 1587

#if DEBUG

/// <summary>

/// TimeSpan for refreshing maps

/// </summary>

[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

public TimeSpan LastRefreshTime { get; set; }

#endif

/// <summary>

/// Initializes a new map

/// </summary>

public MapBox()

#pragma warning restore 1587

{

SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.OptimizedDoubleBuffer | ControlStyles.UserPaint, true);

base.DoubleBuffered = true;

_map = new Map(ClientSize);

//_map.VariableLayers.VariableLayerCollectionRequery += HandleVariableLayersRequery;

//_map.RefreshNeeded += HandleRefreshNeeded;

//_map.MapNewTileAvaliable += HandleMapNewTileAvaliable;

_progressBar = new ProgressBar

{

Style = ProgressBarStyle.Marquee,

Location = new Point(2, 2),

Size = new Size(50, 10)

};

Controls.Add(_progressBar);

_miRenderer = MapImageGeneratorFunction(this, _progressBar); // new LayerListImageGenerator(this, _progressBar);

_activeTool = Tools.None;

LostFocus += HandleMapBoxLostFocus;

_progressBar.Visible = ShowProgressUpdate;

_mousePreviewFilter = new MouseWheelGrabber(this);

Application.AddMessageFilter(_mousePreviewFilter);

}

/// <inheritdoc/>

protected override void OnSizeChanged(EventArgs e)

{

if (Map != null)

{

if (Size != Map.Size)

{

Map.Size = Size;

Refresh();

}

}

base.OnSizeChanged(e);

}

/// <summary>

/// Dispose method

/// </summary>

/// <param name="disposing">A parameter indicating that this method is called from either a call to <see cref="IDisposable.Dispose()"/> (<c>true</c>)

/// or the finalizer (<c>false</c>)</param>

protected override void Dispose(bool disposing)

{

if (_miRenderer.IsDisposed || IsDisposed)

return;

LostFocus -= HandleMapBoxLostFocus;

if (_mousePreviewFilter != null)

Application.RemoveMessageFilter(_mousePreviewFilter);

if (_map != null)

{

// special handling to prevent spurious VariableLayers events

_map.VariableLayers.Interval = 0;

//_map.VariableLayers.VariableLayerCollectionRequery -= HandleVariableLayersRequery;

//_map.MapNewTileAvaliable -= HandleMapNewTileAvaliable;

//_map.RefreshNeeded -= HandleRefreshNeeded;

}

lock (_mapLocker)

{

_map.VariableLayers.Pause = true;

_miRenderer.Dispose();

_map = null;

//if (_imageStatic != null)

//{

// _imageStatic.Dispose();

// _imageStatic = null;

//}

//if (_imageBackground != null)

//{

// _imageBackground.Dispose();

// _imageBackground = null;

//}

//if (_imageVariable != null)

//{

// _imageVariable.Dispose();

// _imageVariable = null;

//}

//if (_image != null)

//{

// _image.Dispose();

// _image = null;

//}

//if (_dragImage != null)

//{

// _dragImage.Dispose();

// _dragImage = null;

//}

if (_rectanglePen != null)

{

_rectanglePen.Dispose();

}

if (_rectangleBrush != null)

{

_rectangleBrush.Dispose();

}

base.Dispose(disposing);

}

}

#region event handling

/// <summary>

/// Handles LostFocus event

/// </summary>

/// <param name="sender"></param>

/// <param name="e"></param>

private void HandleMapBoxLostFocus(object sender, EventArgs e)

{

if (!_dragging) return;

_dragging = false;

Invalidate(ClientRectangle);

}

///// <summary>

///// Handles need to requery of variable layers

///// </summary>

///// <param name="sender"></param>

///// <param name="e"></param>

//private void HandleVariableLayersRequery(object sender, EventArgs e)

//{

// if (IsDisposed || _isDisposed)

// return;

// Image oldRef;

// lock (_mapLocker)

// {

// if (_dragging) return;

// oldRef = _imageVariable;

// _imageVariable = GetMap(_map, _map.VariableLayers, LayerCollectionType.Variable, _map.Envelope);

// }

// UpdateImage(false);

// if (oldRef != null)

// oldRef.Dispose();

// Invalidate();

// Application.DoEvents();

//}