void Awake()
{
focusedTileOverlay = FindObjectOfType <TileOverlay>();
spriteRenderer = GetComponent <SpriteRenderer>();
menu = FindObjectOfType <MenuController>();
source = GetComponent <AudioSource>();
}
public MenuItem GetKeyColorsMenuItem(RasterLayer layer)
{
var menuItem = new MenuItem();
menuItem.Header = "Transparency Colors";
menuItem.Icon = new Image()
{
Source = new BitmapImage(new Uri("/GisEditorInfrastructure;component/Images/Transparent.png", UriKind.RelativeOrAbsolute)), Width = 16, Height = 16
};
menuItem.Click += (s, e) =>
{
if (layer != null)
{
MrSidKeyColorConfigureWindow window = new MrSidKeyColorConfigureWindow(layer.KeyColors);
if (window.ShowDialog().GetValueOrDefault())
{
MrSidKeyColorConfigureViewModel model = window.DataContext as MrSidKeyColorConfigureViewModel;
layer.KeyColors.Clear();
foreach (var color in model.Colors)
{
layer.KeyColors.Add(new GeoColor(color.Color.A, color.Color.R, color.Color.G, color.Color.B));
}
TileOverlay tileOverlay = LayerListHelper.FindMapElementInLayerList <TileOverlay>(GisEditor.LayerListManager.SelectedLayerListItem);
if (tileOverlay != null)
{
tileOverlay.Refresh();
}
}
}
};
return(menuItem);
}
private static void AddOverlayInGoogleProjection(TileOverlay baseOverlay, GisEditorWpfMap map)
{
var extendedMap = map;
string targetProj4 = Proj4Projection.GetGoogleMapParametersString();
string sourceProj4 = extendedMap.DisplayProjectionParameters;
var showConfirmationResult = System.Windows.Forms.DialogResult.Yes;
if (ManagedProj4ProjectionExtension.CanProject(targetProj4, sourceProj4) && map.Overlays.Count > 0)
{
showConfirmationResult = System.Windows.Forms.MessageBox.Show(GisEditor.LanguageManager.GetStringResource("DataRepositoryChangeProjectionWarningLabel"), GisEditor.LanguageManager.GetStringResource("DataRepositoryProjectionWarningCaption"), System.Windows.Forms.MessageBoxButtons.YesNo);
}
if (showConfirmationResult == System.Windows.Forms.DialogResult.Yes)
{
RemoveAllBaseOverlays(map);
extendedMap.Overlays.Insert(0, baseOverlay);
extendedMap.DisplayProjectionParameters = targetProj4;
//extendedMap.ReprojectMap(targetProj4);
SetExtent(map);
if (map.MapUnit != GeographyUnit.Meter)
{
map.MapUnit = GeographyUnit.Meter;
}
extendedMap.Refresh(new Overlay[] { baseOverlay, extendedMap.ExtentOverlay });
}
}
private void MakeOverlay(string keyword)
{
var points = new PointsKeywords(GetPoints(keyword), keyword);
if (points.points.Count != 0)
{
if (mOverlays.Count < MAX_CHECKBOXES)
{
MakeCheckBox(points.keyword);
HeatmapTileProvider provider = new HeatmapTileProvider.Builder().Data(points.points).Gradient(MakeGradiant(HEATMAP_COLORS[(HeatmapColors)mOverlaysRendered])).Build();
TileOverlay overlay = googleMap.AddTileOverlay(new TileOverlayOptions().InvokeTileProvider(provider));
mOverlays.Add(points.keyword, overlay);
}
mOverlaysRendered++;
if (mOverlaysRendered == mOverlaysInput)
{
ProgressBar progressBar = FindViewById <ProgressBar>(Resource.Id.progress_bar);
progressBar.Visibility = ViewStates.Gone;
}
}
else
{
ProgressBar progressBar = FindViewById <ProgressBar>(Resource.Id.progress_bar);
progressBar.Visibility = ViewStates.Gone;
Toast.MakeText(this, "No results for this query :(", ToastLength.Short).Show();
}
}
public static void RefreshCache(this TileOverlay overlay, bool enabled, string cacheId, string cacheDirectory)
{
BitmapTileCache tempTileCache = overlay.TileCache as BitmapTileCache;
FileBitmapTileCache newCache = null;
if (enabled)
{
newCache = new FileBitmapTileCache(cacheDirectory, cacheId);
if (overlay.MapArguments != null)
{
newCache.TileMatrix.BoundingBoxUnit = overlay.MapArguments.MapUnit;
}
}
if (newCache != null)
{
newCache.TileMatrix.TileHeight = overlay.TileHeight;
newCache.TileMatrix.TileWidth = overlay.TileWidth;
}
overlay.TileCache = newCache;
if (!overlay.IsBase && tempTileCache != null)
{
Task.Factory.StartNew(cache =>
{
BitmapTileCache removingCache = (BitmapTileCache)cache;
lock (removingCache)
{
try { removingCache.ClearCache(); }
catch { }
}
}, tempTileCache);
}
}
private void UserControl_Unloaded(object sender, System.Windows.RoutedEventArgs e)
{
if (thread != null && thread.IsAlive)
{
thread.Abort();
}
if (Tag != null)
{
var results = (from overlay in (Tag as GisEditorWpfMap).Overlays.OfType <LayerOverlay>()
from layer in overlay.Layers
where viewModel.ChangedLayers.Contains(layer)
select overlay).Distinct();
foreach (var tileOverlay in results)
{
TileOverlay overlay = tileOverlay as TileOverlay;
if (overlay != null)
{
tileOverlay.Invalidate();
}
}
}
viewModel.CloseFeatureLayer();
Messenger.Default.Unregister(this);
}
public void SetMbTilesAsBackground(string mbtilesFileName)
{
// Remove previous TileOverlay if created
if (TileOverlay != null)
{
//TileOverlay.Remove();
return;
}
// Make Db Context Options Builder to create sqlite db builder
DbContextOptionsBuilder <TileContext> myContextBuilder = new DbContextOptionsBuilder <TileContext>();
myContextBuilder.UseSqlite($"Filename={mbtilesFileName}");
// Initialize TileContext with this builder
TileContext tileContext = new TileContext(myContextBuilder.Options);
// Create TileService with this TileConext
ReadOnlyTileService readOnlyTileService = new ReadOnlyTileService(tileContext);
// Create CustomTileProvider with this TileService
CustomTileProvider customTileProvider = new CustomTileProvider(readOnlyTileService);
// And finally, create the TileOverlayOptions
TileOverlayOptions options = new TileOverlayOptions().InvokeZIndex(0f)
.InvokeTileProvider(customTileProvider);
// And TileOverlay
GoogleMap map = (GoogleMap)LayerService.CurrentMap;
TileOverlay = map.AddTileOverlay(options);
}
void AddHeatmap()
{
var policeStations = DemoUtils.DeserializeLocations(heatmapDataJsonPoliceStations.text);
_heatmap = _map.AddHeatmapWithDefaultLook(policeStations);
CenterCamera(DemoUtils.MelbourneLatLng);
}
private void ResetAllTiles()
{
RemoveAllTiles();
Device.BeginInvokeOnMainThread(() =>
{
TileOverlay.ClearTileCache();
});
}
private void RefreshAllTiles()
{
MarkAllTilesDirty();
Device.BeginInvokeOnMainThread(() =>
{
TileOverlay.ClearTileCache();
});
}
private void AddTrackerForOverlay(SKMapOverlay sharedOverlay)
{
OverlayTrackerTileProvider tracker = new OverlayTrackerTileProvider(Context, NativeMap, sharedOverlay);
TileOverlayOptions overlayOptions = new TileOverlayOptions().InvokeTileProvider(tracker);
TileOverlay overlay = NativeMap.AddTileOverlay(overlayOptions);
tracker.TileOverlay = overlay;
_TileTrackers.Add(tracker);
}
public void OverlayTiles_should_not_throw_When_array_is_zero_length()
{
var imageList = new List <byte[]>
{
Convert.FromBase64String("")
};
_ = TileOverlay.OverlayTiles(imageList);
}
private void RemoveTracker(OverlayTrackerTileProvider tracker)
{
TileOverlay overlay = tracker.TileOverlay;
tracker.RemoveAllTiles();
overlay.Remove();
_TileTrackers.Remove(tracker);
}
public static void RefreshCache()
{
TileOverlay tileOverlay = LayerListHelper.FindMapElementInLayerList <TileOverlay>(GisEditor.LayerListManager.SelectedLayerListItem);
if (tileOverlay != null && tileOverlay.TileCache != null)
{
tileOverlay.Invalidate();
}
}
public static void InvalidateTileOverlay()
{
TileOverlay tileOverlay = LayerListHelper.FindMapElementInTree <TileOverlay>(GisEditor.LayerListManager.SelectedLayerListItem);
if (tileOverlay != null)
{
tileOverlay.Invalidate();
}
}
private void AddTileOverlay(TileOverlay tileOverlay)
{
TileOverlayOptions options = new TileOverlayOptions();
if (tileOverlay is UrlTileOverlay)
{
options.InvokeTileProvider(new UrlTileOverlayProvider(tileOverlay as UrlTileOverlay));
}
tileOverlays.Add(tileOverlay, googleMap.AddTileOverlay(options));
}
void Checkbox_CheckedChange(object sender, CompoundButton.CheckedChangeEventArgs e)
{
CheckBox c = (CheckBox)sender;
// Text is the keyword
TileOverlay overlay = mOverlays[c.Tag.ToString()];
if (overlay != null)
{
overlay.Visible = c.Checked;
}
}
private void AddTileOverlay(TileOverlay tileOverlay)
{
if (tileOverlay is UrlTileOverlay)
{
MKTileOverlay overlay = new MKTileOverlay((tileOverlay as UrlTileOverlay).Url);
overlay.CanReplaceMapContent = true;
overlay.TileSize = new CoreGraphics.CGSize(tileOverlay.TileWidth, tileOverlay.TileHeight);
Control.InsertOverlay(overlay, 0);
TileOverlays.Add(tileOverlay, overlay);
}
}
public void OnClick(View v)
{
CheckBox c = (CheckBox)v;
// Text is the keyword
TileOverlay overlay = mOverlays.GetValueOrDefault(v.Tag.ToString());
if (overlay != null)
{
overlay.Visible = c.Checked;
}
}
public void OnRemoveHeatmapClick()
{
if (_heatmap == null)
{
return;
}
_heatmap.Remove();
_heatmap = null;
Debug.Log("Tile overlay was removed.");
}
private static void ClearCache(FeatureLayer layer)
{
TileOverlay cachedOverlay = (from overlay in GisEditor.ActiveMap.Overlays.OfType <LayerOverlay>()
where overlay.Layers.Contains(layer)
select(LayerOverlay) overlay).FirstOrDefault();
if (cachedOverlay != null && cachedOverlay.TileCache != null)
{
cachedOverlay.RefreshCache(RefreshCacheMode.ApplyNewCache);
}
}
public static void OpenCacheDirectory(this TileOverlay overlay)
{
FileBitmapTileCache tileCache = overlay.TileCache as FileBitmapTileCache;
if (tileCache != null)
{
if (Directory.Exists(tileCache.CacheDirectory))
{
ProcessUtils.OpenPath(tileCache.CacheDirectory);
}
}
}
private void UpdateTiles()
{
if (nativeMap != null)
{
if (tileOverlay != null)
{
this.tileOverlay.Remove();
this.nativeMap.MapType = GoogleMap.MapTypeNormal;
}
nativeMap.MapType = GoogleMap.MapTypeNone;
tileOverlay = nativeMap.AddTileOverlay(new TileOverlayOptions().InvokeTileProvider(new WebTileProvider(Host)));
}
}
private static void RefreshOverlay(TileOverlay tileOverlay)
{
if (Application.Current != null)
{
Application.Current.Dispatcher.BeginInvoke(new Action <TileOverlay>(tmpOverlay =>
{
tmpOverlay.RefreshWithBufferSettings();
}), tileOverlay);
}
else
{
tileOverlay.RefreshWithBufferSettings();
}
}
public static void InsertFromLibrary()
{
StyleLibraryWindow library = new StyleLibraryWindow();
if (library.ShowDialog().GetValueOrDefault())
{
var styleItem = GisEditor.LayerListManager.SelectedLayerListItem as StyleLayerListItem;
if (styleItem != null)
{
TileOverlay containingOverlay = null;
var compositeStyle = styleItem.ConcreteObject as CompositeStyle;
var compositeStyleItem = GisEditor.StyleManager.GetStyleLayerListItem(library.Result.CompositeStyle);
if (compositeStyle != null)
{
foreach (var item in compositeStyleItem.Children.Reverse())
{
styleItem.Children.Insert(0, item);
}
styleItem.UpdateConcreteObject();
containingOverlay = GisEditor.LayerListManager.SelectedLayerListItem.Parent.Parent.ConcreteObject as TileOverlay;
}
else if (styleItem.ConcreteObject is Styles.Style && styleItem.Parent.ConcreteObject is Styles.Style)
{
var index = styleItem.Parent.Children.IndexOf(styleItem);
foreach (var item in compositeStyleItem.Children)
{
index++;
styleItem.Parent.Children.Insert(index, item);
}
((StyleLayerListItem)styleItem.Parent).UpdateConcreteObject();
containingOverlay = LayerListHelper.FindMapElementInLayerList <TileOverlay>(GisEditor.LayerListManager.SelectedLayerListItem);
}
else
{
foreach (var item in compositeStyleItem.Children.Reverse())
{
styleItem.Children.Insert(0, item);
}
styleItem.UpdateConcreteObject();
containingOverlay = LayerListHelper.FindMapElementInLayerList <TileOverlay>(GisEditor.LayerListManager.SelectedLayerListItem);
}
if (containingOverlay != null)
{
containingOverlay.Invalidate();
GisEditor.UIManager.BeginRefreshPlugins(new RefreshArgs(containingOverlay, RefreshArgsDescription.InsertFromLibraryDescription));
}
}
}
}
public void OnClearMapClick()
{
if (_map == null)
{
return;
}
_map.Clear();
// All the elements are now removed, we cannot access them any more
_circle = null;
_marker = null;
_groundOverlay = null;
_polyline = null;
_coloradoPolygon = null;
_heatmap = null;
}
public static void ClearCaches(this TileOverlay overlay, RectangleShape extent)
{
BitmapTileCache tileCache = overlay.TileCache;
if (tileCache != null)
{
lock (tileCache)
{
try
{
tileCache.DeleteTiles(extent);
}
catch { }
}
}
}
public static void ClearCaches(this TileOverlay overlay)
{
BitmapTileCache tileCache = overlay.TileCache;
if (tileCache != null)
{
lock (tileCache)
{
try
{
tileCache.ClearCache();
}
catch { }
}
}
}
private static void AddSubItems(MenuItem menuItem)
{
MenuItem openCacheFolderMenuItem = new MenuItem();
openCacheFolderMenuItem.Header = GisEditor.LanguageManager.GetStringResource("LayerListMenuItemHelperWindowOpencachefolderContent");
openCacheFolderMenuItem.Icon = new Image()
{
Source = new BitmapImage(new Uri("/GisEditorPluginCore;component/Images/openfolder.png", UriKind.RelativeOrAbsolute)), Width = 16, Height = 16
};
openCacheFolderMenuItem.Click += (s, e) =>
{
if (GisEditor.LayerListManager.SelectedLayerListItem == null)
{
return;
}
TileOverlay overlay = GisEditor.LayerListManager.SelectedLayerListItem.ConcreteObject as TileOverlay;
if (overlay != null)
{
overlay.OpenCacheDirectory();
}
};
MenuItem clearCacheMenuItem = new MenuItem();
clearCacheMenuItem.Header = GisEditor.LanguageManager.GetStringResource("LayerListMenuItemHelperWindowClearcacheContent");
clearCacheMenuItem.Icon = new Image()
{
Source = new BitmapImage(new Uri("/GisEditorPluginCore;component/Images/clearcache.png", UriKind.RelativeOrAbsolute)), Width = 16, Height = 16
};
clearCacheMenuItem.Click += (s, e) =>
{
if (GisEditor.LayerListManager.SelectedLayerListItem == null)
{
return;
}
TileOverlay overlay = GisEditor.LayerListManager.SelectedLayerListItem.ConcreteObject as TileOverlay;
if (overlay != null)
{
overlay.ClearCaches();
}
};
menuItem.Items.Add(openCacheFolderMenuItem);
menuItem.Items.Add(clearCacheMenuItem);
}
private static FileBitmapTileCache GetTileCache(TileOverlay overlay, string cacheDirectory, string cacheId)
{
FileBitmapTileCache newCache = new FileBitmapTileCache(cacheDirectory, cacheId);
if (overlay.MapArguments != null)
{
newCache.TileMatrix.BoundingBoxUnit = overlay.MapArguments.MapUnit;
}
if (newCache != null)
{
newCache.TileMatrix.TileHeight = overlay.TileHeight;
newCache.TileMatrix.TileWidth = overlay.TileWidth;
}
return(newCache);
}
public PlayerReady(Actor actor)
{
_actor = actor;
var map = GameObject.FindObjectOfType<TileMap>();
_navGraph = new NavGraph(map, _actor.Row, _actor.Col, _actor.AP);
_highlighter = GameObject.FindObjectOfType<TileOverlay>();
_highlighter.HighlightTiles(_navGraph.TilesInRange, TileOverlay.HighlightType.Move);
}