public LegendDataSource(GeoView geoview)
{
if (geoview != null)
{
SetGeoView(geoview);
}
}
private static GraphicsOverlay CreateSketchLayer(GeoView geoView)
{
GraphicsOverlay go = new GraphicsOverlay();
geoView.GraphicsOverlays.Add(go);
return(go);
}
public void Register(GeoView geoView)
{
geoView.GeoViewTapped += (o, e) =>
{
Messenger.Default.Send <GeoViewInputEventArgs>(e);
};
}
private async void Is3DCheckBox_Toggled(object sender, RoutedEventArgs e)
{
if (sceneView != null && mapView != null)
{
bool isOn = ((ToggleSwitch)sender).IsOn;
if (isOn == vm.Is3D)
{
return; //this happens the first time it loads
}
HighlightFeature(null);
if (vm.Is3D)
{
var c = sceneView.Camera;
//If there's tilt or heading, reset before switching to 2D
if (c.Pitch > 1 || Math.Abs(c.Heading) > 1)
{
var center = await sceneView.ScreenToLocationAsync(new Point(sceneView.ActualWidth * .5, sceneView.ActualHeight * .5));
c = c.RotateAround(center, c.Heading, -c.Pitch, 0).RotateTo(0, 0, c.Roll);
await sceneView.SetViewpointCameraAsync(c);
}
}
GeoView from = vm.Is3D ? (GeoView)sceneView : (GeoView)mapView;
GeoView to = !vm.Is3D ? (GeoView)sceneView : (GeoView)mapView;
var vp = from.GetCurrentViewpoint(ViewpointType.BoundingGeometry);
if (vp != null)
{
await to.SetViewpointAsync(vp, TimeSpan.Zero);
}
vm.Is3D = !vm.Is3D;
}
}
private void OnViewpointChanged(object sender, EventArgs e)
{
// Get the MapView or SceneView that sent the event.
GeoView sendingView = (GeoView)sender;
// Only take action if this GeoView is the one that the user is navigating.
// Viewpoint changed events are fired when SetViewpoint is called; This check prevents a feedback loop.
if (sendingView.IsNavigating)
{
// If the MapView sent the event, update the SceneView's viewpoint.
if (sender is MapView)
{
// Get the viewpoint.
Viewpoint updateViewpoint = _myMapView.GetCurrentViewpoint(ViewpointType.CenterAndScale);
// Set the viewpoint.
_mySceneView.SetViewpoint(updateViewpoint);
}
else // Else, update the MapView's viewpoint.
{
// Get the viewpoint.
Viewpoint updateViewpoint = _mySceneView.GetCurrentViewpoint(ViewpointType.CenterAndScale);
// Set the viewpoint.
_myMapView.SetViewpoint(updateViewpoint);
}
}
}
public static async Task <Polyline> DrawPolylineAsync(GeoView view, System.Threading.CancellationToken cancellationToken)
{
var tcs = new TaskCompletionSource <Polyline>();
PolylineBuilder polylineBuilder = new PolylineBuilder(view.SpatialReference);
var sketchlayer = CreateSketchLayer(view);
Graphic lineGraphic = new Graphic()
{
Symbol = DefaultLineSymbol
};
Graphic lineMoveGraphic = new Graphic()
{
Symbol = DefaultLineMoveSymbol
};
sketchlayer.Graphics.Add(lineGraphic);
sketchlayer.Graphics.Add(lineMoveGraphic);
Action cleanupEvents = SetUpHandlers(view,
(p) => //On mouse move, move completion line around
{
if (p != null && polylineBuilder.Parts.Count > 0 && polylineBuilder.Parts[0].Count > 0)
{
lineMoveGraphic.Geometry = new Polyline(new MapPoint[] { polylineBuilder.Parts[0].Last().EndPoint, p });
}
},
(p) => //On tap add a vertex
{
if (p != null)
{
polylineBuilder.AddPoint(p);
if (polylineBuilder.Parts.Count > 0 && polylineBuilder.Parts[0].Count >= 1)
{
lineGraphic.Geometry = polylineBuilder.ToGeometry();
}
}
},
(p) => //View tapped - completes task and returns point
{
tcs.SetResult(polylineBuilder.ToGeometry());
});
Action cleanup = () =>
{
cleanupEvents();
view.GraphicsOverlays.Remove(sketchlayer);
};
cancellationToken.Register(() => tcs.SetCanceled());
Polyline result = null;
try
{
result = await tcs.Task;
}
finally
{
cleanup();
}
return(result);
}
private async void Map_OnGeoViewTapped(object sender, GeoViewInputEventArgs e)
{
if (!(sender is MapView map))
{
return;
}
if (!(DataContext is NetworkViewModel networkViewModel))
{
return;
}
var overlayGrid = (System.Windows.Controls.Border)map.Overlays.Items[0];
var tolerance = 10d; // Use larger tolerance for touch
var maximumResults = 5; // Only return one graphic
var onlyReturnPopups = false; // Don't return only popups
// Use the following method to identify graphics in a specific graphics overlay
var identifyResults = await map.IdentifyGraphicsOverlayAsync(
map.GraphicsOverlays[networkViewModel.RiverBasinOverlay],
e.Position,
tolerance,
onlyReturnPopups,
maximumResults);
// Check if we got results
if (identifyResults.Graphics.Count > 0)
{
map.GraphicsOverlays[networkViewModel.RiverBasinOverlay].ClearSelection();
mapTip.Visibility = Visibility.Collapsed;
foreach (var gr in identifyResults.Graphics)
{
if (gr.Attributes.ContainsKey("Id"))
{
gr.IsSelected = !gr.IsSelected;
}
if (gr.IsSelected)
{
if (gr.Attributes.ContainsKey("Id"))
{
networkViewModel.NetworkObjectSelected((String)gr.Attributes["Id"]);
}
mapTip.Visibility = Visibility.Visible;
tipLine1.Text = networkViewModel.SelectedNetworkObject.ToString();
switch (gr.Geometry)
{
case Polyline line:
GeoView.SetViewOverlayAnchor(overlayGrid, line.Parts[0].StartPoint);
break;
case MapPoint point:
GeoView.SetViewOverlayAnchor(overlayGrid, point);
break;
}
}
}
}
}
/// <summary>
/// Register given handler to given event as a weak reference.
/// </summary>
/// <param name="sender">Object to register.</param>
/// <param name="handler">Handler to register.</param>
public static void RegisterGeoViewHolding(GeoView sender, EventHandler <GeoViewInputEventArgs> handler)
{
var listener = new WeakEventListener <GeoView, object, GeoViewInputEventArgs>(sender)
{
OnEventAction = (instance, source, eventArgs) => { handler.Invoke(source, eventArgs); },
OnDetachAction = (instance, weakEventListener) => instance.GeoViewHolding -= weakEventListener.OnEvent
};
sender.GeoViewHolding += listener.OnEvent;
}
/// <summary>
/// Register given handler to given event as a weak reference.
/// </summary>
/// <param name="sender">Object to register.</param>
/// <param name="handler">Handler to register.</param>
public static void RegisterSpatialReferenceChanged(GeoView sender, EventHandler <EventArgs> handler)
{
var listener = new WeakEventListener <GeoView, object, EventArgs>(sender)
{
OnEventAction = (instance, source, eventArgs) => { handler.Invoke(source, eventArgs); },
OnDetachAction = (instance, weakEventListener) => instance.SpatialReferenceChanged -= weakEventListener.OnEvent
};
sender.SpatialReferenceChanged += listener.OnEvent;
}
private void Refresh()
{
if (_listView == null)
{
return;
}
if ((GeoView as MapView)?.Map == null && (GeoView as SceneView)?.Scene == null)
{
_listView.Adapter = null;
return;
}
ObservableLayerContentList layers = null;
if (GeoView is MapView)
{
layers = new ObservableLayerContentList(GeoView as MapView, ShowLegendInternal)
{
ReverseOrder = !ReverseLayerOrder,
};
}
else if (GeoView is SceneView)
{
layers = new ObservableLayerContentList(GeoView as SceneView, ShowLegendInternal)
{
ReverseOrder = !ReverseLayerOrder,
};
}
if (layers == null)
{
_listView.Adapter = null;
return;
}
foreach (var l in layers)
{
if (!(l.LayerContent is Layer))
{
continue;
}
var layer = l.LayerContent as Layer;
if (layer.LoadStatus == LoadStatus.Loaded)
{
l.UpdateLayerViewState(GeoView.GetLayerViewState(layer));
}
}
ScaleChanged();
SetLayerContentList(layers);
_listView.Adapter = new LegendAdapter(Context, layers);
_listView.SetHeightBasedOnChildren();
}
private void LoadSampleButton_Click(object sender, RoutedEventArgs e)
{
var sample = (KmlSample)((FrameworkElement)sender).DataContext;
AddKmlLayer(sample.Path);
if (sample.InitialViewpoint != null)
{
GeoView view = vm.Is3D ? (GeoView)sceneView : (GeoView)mapView;
var _ = view.SetViewpointAsync(sample.InitialViewpoint);
}
}
/// <summary>
/// Helper for adding mouse events
/// </summary>
/// <param name="view">The view to listen for events on.</param>
/// <param name="onMove">Action when the mouse moves.</param>
/// <param name="onTapped">Action when the view is tapped.</param>
/// <param name="onDoubleTapped">Action when the view is double tapped.</param>
/// <returns>An Action that cleans up all the event handlers.</returns>
private static Action SetUpHandlers(GeoView view, Action <MapPoint> onMove, Action <MapPoint> onTapped, Action <MapPoint> onDoubleTapped)
{
#if NETFX_CORE
Windows.UI.Xaml.Input.PointerEventHandler movehandler = null;
#else
System.Windows.Input.MouseEventHandler movehandler = null;
#endif
if (onMove != null)
{
#if NETFX_CORE
movehandler = (s, e) => onMove(((MapView)view).ScreenToLocation(e.GetCurrentPoint(view).Position));
view.PointerMoved += movehandler;
#else
movehandler = (s, e) => onMove(((MapView)view).ScreenToLocation(e.GetPosition(view)));
view.MouseMove += movehandler;
#endif
}
EventHandler <GeoViewInputEventArgs> tappedHandler = null;
if (onTapped != null)
{
tappedHandler = (s, e) => onTapped(e.Location);
view.GeoViewTapped += tappedHandler;
}
EventHandler <GeoViewInputEventArgs> doubletappedHandler = null;
if (onDoubleTapped != null)
{
doubletappedHandler = (s, e) => { e.Handled = true; onDoubleTapped(e.Location); };
view.GeoViewDoubleTapped += doubletappedHandler;
}
Action cleanup = () =>
{
if (movehandler != null)
#if NETFX_CORE
{ view.PointerMoved -= movehandler; }
#else
{ view.MouseMove -= movehandler; }
#endif
if (tappedHandler != null)
{
view.GeoViewTapped -= tappedHandler;
}
if (doubletappedHandler != null)
{
view.GeoViewDoubleTapped -= doubletappedHandler;
}
};
return(cleanup);
}
public static async Task <MapPoint> DrawPointAsync(GeoView view, CancellationToken cancellationToken)
{
var tcs = new TaskCompletionSource <MapPoint>();
var sketchlayer = CreateSketchLayer(view);
sketchlayer.Opacity = .5;
Graphic pointGraphic = null;
Action cleanupEvents = SetUpHandlers(view,
(p) => //On mouse move move graphic around
{
if (p != null)
{
if (pointGraphic == null)
{
pointGraphic = new Graphic(p, DefaultMarkerSymbol);
sketchlayer.Graphics.Add(pointGraphic);
}
else
{
pointGraphic.Geometry = p;
}
}
},
(p) => //View tapped - completes task and returns point
{
tcs.SetResult(p);
}
, null);
Action cleanup = () =>
{
cleanupEvents();
view.GraphicsOverlays.Remove(sketchlayer);
};
cancellationToken.Register(() => tcs.SetCanceled());
MapPoint result = null;
try
{
result = await tcs.Task;
}
finally
{
cleanup();
}
return(result);
}
private void OnViewChanged(GeoView oldView, GeoView newView)
{
if (oldView != null)
{
(oldView as INotifyPropertyChanged).PropertyChanged -= GeoView_PropertyChanged;
oldView.LayerViewStateChanged -= GeoView_LayerViewStateChanged;
}
if (newView != null)
{
(newView as INotifyPropertyChanged).PropertyChanged += GeoView_PropertyChanged;
newView.LayerViewStateChanged += GeoView_LayerViewStateChanged;
newView.NavigationCompleted += GeoView_NavigationCompleted;
_scaleChanged = true;
_isScaleSet = false;
}
RebuildList();
}
private void OnNavigationComplete(object sender, EventArgs eventArgs)
{
// Get a reference to the MapView or SceneView that raised the event.
GeoView sendingView = (GeoView)sender;
// Get a reference to the other view.
GeoView otherView;
if (sendingView is MapView)
{
otherView = _mySceneView;
}
else
{
otherView = _myMapView;
}
// Update the viewpoint on the other view.
otherView.SetViewpoint(sendingView.GetCurrentViewpoint(ViewpointType.CenterAndScale));
}
private void ShowMapTip(KmlNode feature, MapPoint location = null)
{
GeoView view = vm.Is3D ? (GeoView)sceneView : (GeoView)mapView;
var placemark = feature as KmlPlacemark;
var border = (Border)view.Overlays.Items.First();
if (feature == null || string.IsNullOrWhiteSpace(feature.BalloonContent) ||
placemark?.Geometry == null)
{
border.Visibility = Windows.UI.Xaml.Visibility.Collapsed;
currentMaptip = null;
return;
}
var grid = (Windows.UI.Xaml.Controls.Grid)border.Child;
var webview = grid.Children.OfType <WebView>().First();
webview.NavigateToString(feature.BalloonContent);
GeoView.SetViewOverlayAnchor(border, location ?? placemark.Geometry.Extent.GetCenter());
border.Visibility = Windows.UI.Xaml.Visibility.Visible;
currentMaptip = border;
}
private async void ViewTapped(object sender, GeoViewInputEventArgs e)
{
GeoView view = (GeoView)sender;
KmlLayer kmlLayer = null;
if (view is SceneView)
{
kmlLayer = ((SceneView)sender).Scene.OperationalLayers.OfType <KmlLayer>().FirstOrDefault();
}
else if (view is MapView)
{
kmlLayer = ((MapView)sender).Map.OperationalLayers.OfType <KmlLayer>().FirstOrDefault();
}
if (kmlLayer == null)
{
return;
}
var result = await view.IdentifyLayerAsync(kmlLayer, e.Position, 2, false);
var feature = result.GeoElements?.OfType <KmlGeoElement>().FirstOrDefault()?.KmlNode;
HighlightFeature(feature);
ShowMapTip(feature, e.Location);
}
/// <summary>
/// Generates layer list for a set of <see cref="Layer"/>s in a <see cref="Map"/> or <see cref="Scene"/>
/// contained in a <see cref="GeoView"/>
/// </summary>
internal void Refresh()
{
var list = GetTemplateChild("List") as ItemsControl;
if (list == null)
{
return;
}
#if !NETFX_CORE
ContextMenuService.AddContextMenuOpeningHandler(list, ContextMenuEventHandler);
#endif
if ((GeoView as MapView)?.Map == null && (GeoView as SceneView)?.Scene == null)
{
list.ItemsSource = null;
return;
}
ObservableLayerContentList layers = null;
if (GeoView is MapView)
{
layers = new ObservableLayerContentList(GeoView as MapView, ShowLegendInternal)
{
ReverseOrder = !ReverseLayerOrder,
};
Binding b = new Binding();
b.Source = GeoView;
b.Path = new PropertyPath(nameof(MapView.Map));
b.Mode = BindingMode.OneWay;
SetBinding(DocumentProperty, b);
}
else if (GeoView is SceneView)
{
layers = new ObservableLayerContentList(GeoView as SceneView, ShowLegendInternal)
{
ReverseOrder = !ReverseLayerOrder,
};
Binding b = new Binding();
b.Source = GeoView;
b.Path = new PropertyPath(nameof(SceneView.Scene));
b.Mode = BindingMode.OneWay;
SetBinding(DocumentProperty, b);
}
if (layers == null)
{
list.ItemsSource = null;
return;
}
foreach (var l in layers)
{
if (!(l.LayerContent is Layer))
{
continue;
}
var layer = l.LayerContent as Layer;
if (layer.LoadStatus == LoadStatus.Loaded)
{
l.UpdateLayerViewState(GeoView.GetLayerViewState(layer));
}
}
ScaleChanged();
SetLayerContentList(layers);
list.ItemsSource = layers;
}
/// <summary>
/// GeoView setter
/// </summary>
internal void SetGeoView(GeoView geoView)
{
GeoView = geoView;
}
private void Refresh()
{
if (_listView == null)
{
return;
}
if ((GeoView as MapView)?.Map == null && (GeoView as SceneView)?.Scene == null)
{
_listView.Source = null;
_listView.ReloadData();
InvalidateIntrinsicContentSize();
return;
}
ObservableLayerContentList layers = null;
if (GeoView is MapView)
{
layers = new ObservableLayerContentList(GeoView as MapView, ShowLegendInternal)
{
ReverseOrder = !ReverseLayerOrder,
};
}
else if (GeoView is SceneView)
{
layers = new ObservableLayerContentList(GeoView as SceneView, ShowLegendInternal)
{
ReverseOrder = !ReverseLayerOrder,
};
}
if (layers == null)
{
_listView.Source = null;
return;
}
foreach (var l in layers)
{
if (!(l.LayerContent is Layer))
{
continue;
}
var layer = l.LayerContent as Layer;
if (layer.LoadStatus == LoadStatus.Loaded)
{
l.UpdateLayerViewState(GeoView.GetLayerViewState(layer));
}
}
ScaleChanged();
SetLayerContentList(layers);
var source = new LegendTableSource(layers);
_listView.Source = source;
source.CollectionChanged += (a, b) => InvokeOnMainThread(() =>
{
_listView.ReloadData();
InvalidateIntrinsicContentSize();
});
_listView.ReloadData();
InvalidateIntrinsicContentSize();
Hidden = false;
}
protected virtual void OnGeoViewPropertyChanged(GeoView geoView, string?propertyName)
{
}
internal void SetGeoView(GeoView geoview)
{
if (geoview == _geoview)
{
return;
}
if (_geoview != null)
{
_geoview.LayerViewStateChanged -= GeoView_LayerViewStateChanged;
(_geoview as INotifyPropertyChanged).PropertyChanged += GeoView_PropertyChanged;
#if XAMARIN || XAMARIN_FORMS
(_geoview as INotifyPropertyChanged).PropertyChanged -= GeoView_PropertyChanged;
#else
if (_geoview is MapView mapview)
{
#if NETFX_CORE
mapview.UnregisterPropertyChangedCallback(MapView.MapProperty, _propertyChangedCallbackToken);
#else
DependencyPropertyDescriptor.FromProperty(MapView.MapProperty, typeof(MapView)).RemoveValueChanged(mapview, GeoViewDocumentChanged);
#endif
}
else if (_geoview is SceneView sceneview)
{
#if NETFX_CORE
sceneview.UnregisterPropertyChangedCallback(SceneView.SceneProperty, _propertyChangedCallbackToken);
#else
DependencyPropertyDescriptor.FromProperty(SceneView.SceneProperty, typeof(SceneView)).RemoveValueChanged(sceneview, GeoViewDocumentChanged);
#endif
}
#endif
}
var oldGeoview = _geoview;
_geoview = geoview;
if (_geoview != null)
{
_geoview.LayerViewStateChanged += GeoView_LayerViewStateChanged;
(_geoview as INotifyPropertyChanged).PropertyChanged += GeoView_PropertyChanged;
#if XAMARIN || XAMARIN_FORMS
#else
if (_geoview is MapView mapview)
{
#if NETFX_CORE
_propertyChangedCallbackToken = mapview.RegisterPropertyChangedCallback(MapView.MapProperty, GeoViewDocumentChanged);
#else
DependencyPropertyDescriptor.FromProperty(MapView.MapProperty, typeof(MapView)).AddValueChanged(mapview, GeoViewDocumentChanged);
#endif
}
else if (_geoview is SceneView sceneview)
{
#if NETFX_CORE
_propertyChangedCallbackToken = sceneview.RegisterPropertyChangedCallback(SceneView.SceneProperty, GeoViewDocumentChanged);
#else
DependencyPropertyDescriptor.FromProperty(SceneView.SceneProperty, typeof(SceneView)).AddValueChanged(sceneview, GeoViewDocumentChanged);
#endif
}
#endif
}
OnGeoViewChanged(oldGeoview, geoview);
OnDocumentChanged();
}
protected virtual void OnGeoViewChanged(GeoView oldGeoview, GeoView newGeoview)
{
}
private void ShowCallout(GeoView sender, Controls.CalloutDefinition definition)
{
_originMapView.ShowCalloutAt(ArgumentsConverter.ConvertFrom(definition.Location),
ArgumentsConverter.ConvertFrom(definition));
}
private void VM_RequestViewpoint(object sender, Esri.ArcGISRuntime.Mapping.Viewpoint viewpoint)
{
GeoView campusView = FindViewById <GeoView>(Resource.Id.CampusView);
campusView.SetViewpointAsync(viewpoint, TimeSpan.FromSeconds(3));
}
protected async override void OnCreate(Bundle bundle)
{
base.OnCreate(bundle);
// Set our view from the "main" layout resource
SetContentView(Resource.Layout.Main);
var autocompleteTextView1 = FindViewById <AutoCompleteTextView>(Resource.Id.FromInput);
autocompleteTextView1.TextChanged += AutocompleteTextView_TextChanged;
autocompleteTextView1.ItemClick += AutocompleteTextViewFrom_ItemClick;
autocompleteTextView1.Threshold = 0;
autocompleteTextView1.Enabled = false;
var autoCompleteAdapter = new SuggestGeocodeCompleteAdapter(this, Android.Resource.Layout.SimpleDropDownItem1Line);
autocompleteTextView1.Adapter = autoCompleteAdapter;
var autocompleteTextView2 = FindViewById <AutoCompleteTextView>(Resource.Id.ToInput);
autocompleteTextView2.TextChanged += AutocompleteTextView_TextChanged;
autocompleteTextView2.ItemClick += AutocompleteTextViewTo_ItemClick;
autocompleteTextView2.Threshold = 0;
autocompleteTextView2.Enabled = false;
autoCompleteAdapter = new SuggestGeocodeCompleteAdapter(this, Android.Resource.Layout.SimpleDropDownItem1Line);
autocompleteTextView2.Adapter = autoCompleteAdapter;
RunOnUiThread(() =>
{
GridLayout panel = FindViewById <GridLayout>(Resource.Id.WalkTimePanel);
panel.Visibility = ViewStates.Invisible;
});
GeoView campusView = FindViewById <GeoView>(Resource.Id.CampusView);
// Cast to 2D and 3D versions of GeoView so we can handle either
// Try going to Resources\layout\Main.axml and change the MapView to a SceneView to enable a 3D view of the campus
MapView mapView = campusView as MapView;
SceneView sceneView = campusView as SceneView;
VM = new MapViewModel();
VM.RequestViewpoint += VM_RequestViewpoint;
VM.RouteUpdated += VM_RouteUpdated;
VM.PropertyChanged += VM_PropertyChanged;
await VM.LoadAsync();
RunOnUiThread(() =>
{
autocompleteTextView1.Enabled = true;
autocompleteTextView2.Enabled = true;
TextView statusView = FindViewById <TextView>(Resource.Id.downloadDataStatus);
statusView.Visibility = ViewStates.Gone;
if (mapView != null)
{
mapView.BackgroundGrid.Color = System.Drawing.Color.FromArgb(255, 255, 255);
mapView.BackgroundGrid.GridLineWidth = 0;
mapView.Map = VM.Map;
}
else if (sceneView != null)
{
sceneView.Scene = VM.Scene;
}
campusView.GraphicsOverlays = VM.Overlays;
});
}
private void UpdateCompassFromGeoView(GeoView view)
{
_headingSetByGeoView = true;
Heading = (view is MapView) ? ((MapView)view).MapRotation : (view is SceneView ? ((SceneView)view).Camera.Heading : 0);
_headingSetByGeoView = false;
}
