using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Security.Cryptography;

using System.Text;

using System.Threading;

using System.Threading.Tasks;

using System.Windows.Forms;

using Common.Logging;

using GeoAPI.Geometries;

using SharpMap;

using SharpMap.Data;

using SharpMap.Forms;

using SharpMap.Forms.Tools;

using SharpMap.Layers;

namespace WinFormSamples

{

public class SampleTool : MapTool, IDisposable

{

private ILog Logger = LogManager.GetLogger(typeof(SampleTool));

public SampleTool() : base("Sample", "A sample tool that does nothing really useful")

{

Logger.Debug(fmh => fmh("Created \"{0}\"-Tool, {1}", Name,Description));

Enabled = true;

}

void IDisposable.Dispose()

{

HandleCancel();

}

private ToolTip _toolTip;

public SampleTool(MapBox mapBox1) : this()

{

MapControl = mapBox1;

MapControl.MapChanged += (sender, args) => { HandleCancel(); };

_cts.Token.Register(HandleCancel);

}

public override bool DoKeyDown(Coordinate mapPosition, KeyEventArgs keyEventArgs)

{

Logger.Debug(fmh => fmh("KeyDown {1} at {0}", mapPosition, keyEventArgs.KeyCode));

return base.DoKeyDown(mapPosition, keyEventArgs);

}

public override bool DoKeyUp(Coordinate mapPosition, KeyEventArgs keyEventArgs)

{

Logger.Debug(fmh => fmh("KeyUp {1} at {0}", mapPosition, keyEventArgs.KeyCode));

return base.DoKeyUp(mapPosition, keyEventArgs);

}

public override bool DoMouseDoubleClick(Coordinate mapPosition, MouseEventArgs mouseEventArgs)

{

Logger.Debug(fmh => fmh("MouseDoubleClick {1} at {0}", mapPosition, mouseEventArgs.Button));

return base.DoMouseDoubleClick(mapPosition, mouseEventArgs);

}

public override bool DoMouseDown(Coordinate mapPosition, MouseEventArgs mouseEventArgs)

{

Logger.Debug(fmh => fmh("MouseDown {1} at {0}", mapPosition, mouseEventArgs.Button));

return base.DoMouseDown(mapPosition, mouseEventArgs);

}

public override bool DoMouseEnter()

{

Logger.Debug(fmh => fmh("MouseEnter"));

return base.DoMouseEnter();

}

protected override void OnEnabledChanged(EventArgs e)

{

base.OnEnabledChanged(e);

if (!Enabled)

{

if (_toolTip != null) _toolTip.RemoveAll();

}

}

private CancellationTokenSource _cts = new CancellationTokenSource();

public override bool DoMouseHover(Coordinate mapPosition)

{

Logger.Debug(fmh => fmh("MouseHover at {0}", mapPosition));

_cts.Cancel();

_cts.Token.WaitHandle.WaitOne();

_cts.Dispose();

_cts = new CancellationTokenSource();

_cts.Token.Register(HandleCancel);

var t = new Task<FeatureDataRow>(FindGeoNearPoint, mapPosition, _cts.Token);

t.Start();

t.ContinueWith(res => ShowToolTip(res.Result));

return base.DoMouseHover(mapPosition);

}

BackgroundWorker _bw = new BackgroundWorker();

void HandleCancel()

{

if (_toolTip != null)

{

MapControl.Invoke(new MethodInvoker(() =>

{

_toolTip.Hide(MapControl);

_toolTip.Dispose();

}));

_toolTip = null;

}

}

private void ShowToolTip(FeatureDataRow fdr)

{

if (fdr != null)

{

MapControl.BeginInvoke(new Action(() =>

{

var _t = new ToolTip();

_toolTip = _t;

_t/*oolTip*/.ToolTipTitle = fdr.Table.TableName;

_t/*oolTip*/.Show(ToText(fdr), MapControl);

}));

}

else

{

//MapControl.BeginInvoke(new MethodInvoker( () => _toolTip.Hide(MapControl)));

}

}

private string ToText(FeatureDataRow fdr)

{

var sb = new StringBuilder();

if (fdr.Geometry != null)

{

sb.AppendFormat("Geometry:\n Type: {0}\n SRID: {1}\n",

fdr.Geometry.GeometryType, fdr.Geometry.SRID);

switch (fdr.Geometry.Dimension)

{

case Dimension.Surface:

sb.AppendFormat(" Area: {0}\n", fdr.Geometry.Area);

break;

case Dimension.Curve:

sb.AppendFormat(" Length: {0}\n", fdr.Geometry.Length);

break;

case Dimension.Point:

sb.AppendFormat(" Position: {0}\n", fdr.Geometry.AsText());

break;

}

}

sb.Append("Data:\n");

foreach (DataColumn col in fdr.Table.Columns)

sb.AppendFormat(" {0}: {1}\n", col.Caption, fdr[col] == DBNull.Value ? "NULL" : fdr[col]);

Logger.Debug(fmh => fmh("\n{0}\n{1}", fdr.Table.TableName, sb.ToString(0, sb.Length-1)));

return sb.ToString(0, sb.Length - 1);

}

private FeatureDataRow FindGeoNearPoint(object/*Coordinate*/ coord)

{

var mapPosition = (Coordinate) coord;

var env = new Envelope(mapPosition);

env.ExpandBy(5 * Map.PixelWidth);

var g = NetTopologySuite.Geometries.Prepared.PreparedGeometryFactory.Prepare(Map.Factory.ToGeometry(env));

var fdrs = new List<Tuple<double, FeatureDataRow>>();

var fds = new FeatureDataSet();

var tableCount = 0;

var layersToQuery = GetLayersToQuery(Map);

for (var i = layersToQuery.Count - 1; i >= 0; i--)

{

if (_cts.Token.IsCancellationRequested)

{

Logger.Debug("Cancellation requested");

return null;

}

var l = layersToQuery[i];

if (l.Enabled && l.MinVisible < Map.Zoom &&

l.MaxVisible >= Map.Zoom)

{

if (!l.IsQueryEnabled) continue;

l.ExecuteIntersectionQuery(env, fds);

for (var j = tableCount; j < fds.Tables.Count; j++)

{

var fdt = fds.Tables[j];

for (var k = 0; k < fdt.Rows.Count; k++)

{

var fdr = (FeatureDataRow) fdt.Rows[k];

if (g.Intersects(fdr.Geometry))

{

var distance = g.Geometry.InteriorPoint.Distance(fdr.Geometry);

if (fdr.Geometry.Dimension == Dimension.Surface)

distance += 5* Map.PixelWidth;

fdrs.Add(Tuple.Create(distance, fdr));

}

}

}

tableCount = fds.Tables.Count;

}

}

if (fdrs.Count > 0)

{

fdrs.Sort((t1, t2) => t1.Item1.CompareTo(t2.Item1));

return fdrs[0].Item2;

}

return null;

}

private static List<ICanQueryLayer> GetLayersToQuery(Map map)

{

var res = new List<ICanQueryLayer>();

for (var i = 0; i < map.BackgroundLayer.Count; i++)

{

if (map.BackgroundLayer[i] is ICanQueryLayer)

{

if (((ICanQueryLayer)map.BackgroundLayer[i]).IsQueryEnabled)

res.Add((ICanQueryLayer)map.BackgroundLayer[i]);

}

}

for (var i = 0; i < map.Layers.Count; i++)

{

if (map.Layers[i] is ICanQueryLayer)

{

if (((ICanQueryLayer)map.Layers[i]).IsQueryEnabled)

res.Add((ICanQueryLayer)map.Layers[i]);

}

}

return res;

}

public MapBox MapControl { get; private set; }

public override bool DoMouseLeave()

{

Logger.Debug(fmh => fmh("MouseLeave"));

//_toolTip.RemoveAll();

return base.DoMouseLeave();

}

public override bool DoMouseMove(Coordinate mapPosition, MouseEventArgs mouseEventArgs)

{

Logger.Debug(fmh => fmh("MouseMove {1} at {0}", mapPosition, mouseEventArgs.Button));

//_toolTip.RemoveAll();

return base.DoMouseMove(mapPosition, mouseEventArgs);

}

public override bool DoMouseUp(Coordinate mapPosition, MouseEventArgs mouseEventArgs)

{

Logger.Debug(fmh => fmh("MouseUp {1} at {0}", mapPosition, mouseEventArgs.Button));

return base.DoMouseUp(mapPosition, mouseEventArgs);

}

public override bool DoMouseWheel(Coordinate mapPosition, MouseEventArgs mouseEventArgs)

{

Logger.Debug(fmh => fmh("MouseWheel {1} at {0}", mapPosition, mouseEventArgs.Button));

return base.DoMouseWheel(mapPosition, mouseEventArgs);

}

public override void Cancel()

{

Logger.Debug(fmh => fmh("Cancel"));

base.Cancel();

}

public override void DoPaint(PaintEventArgs e)

{

Logger.Debug(fmh => fmh("Paint"));

base.DoPaint(e);

}

}

}