/// <summary>
/// Adds the specified vector tile package as a base layer.
/// </summary>
/// <param name="vtpkFile">the vector tile package</param>
/// <returns>a boolean indicating whether or not things went well</returns>
public async Task <bool> AddVectorTileLayerAsync(string vtpkFile)
{
bool allGood = true;
if (!this.HasLayerFileSource(vtpkFile))
{
LayerFileSource lfs = new LayerFileSource();
lfs.SourceFile = vtpkFile;
this.LayerFileSources.Add(lfs);
TesterLayer testLayer = new TesterLayer();
try
{
ArcGISVectorTiledLayer vtpk = new ArcGISVectorTiledLayer(new Uri(vtpkFile));
testLayer.VTPK = vtpk;
lfs.Children.Add(testLayer);
vtpk.PropertyChanged += Vtpk_PropertyChanged;
await vtpk.LoadAsync();
this.Map.Basemap.BaseLayers.Add(vtpk);
}
catch (Exception e)
{
allGood = false;
testLayer.LayerLoadException = e;
this.LogLayerLoadException(testLayer);
}
}
return(allGood);
}
/// <summary>
/// Adds a MMPK map source.
/// </summary>
/// <param name="fileName">the MMPK file</param>
/// <returns>the opened MMPK</returns>
public async Task <MobileMapPackage> AddMMPKAsync(string fileName)
{
List <Map> maps = new List <Map>();
MobileMapPackage mmpk = null;
if (!this.HasLayerFileSource(fileName))
{
LayerFileSource lfs = new LayerFileSource();
lfs.SourceFile = fileName;
this.LayerFileSources.Add(lfs);
mmpk = await MobileMapPackage.OpenAsync(fileName);
await mmpk.LoadAsync();
foreach (Map aMap in mmpk.Maps)
{
maps.Add(aMap);
var layerCollection = aMap.OperationalLayers.Reverse();
await aMap.LoadAsync();
Trace.WriteLine("Map = " + aMap.ToString());
foreach (var layer in layerCollection)
{
Layer lyr = layer.Clone();
lyr.IsVisible = layer.IsVisible;
//if (layer.Opacity == 1)
// layer.Opacity = .55;
lyr.Opacity = layer.Opacity;
await lyr.LoadAsync();
if (lyr is FeatureLayer)
{
TesterLayer testLayer = new TesterLayer();
FeatureLayer featLyr = lyr as FeatureLayer;
GeodatabaseFeatureTable featureTable = featLyr.FeatureTable as GeodatabaseFeatureTable;
testLayer.FeatureTable = featureTable;
testLayer.FeatureLayer = featLyr;
lfs.Children.Add(testLayer);
((FeatureLayer)lyr).LabelsEnabled = true;
((FeatureLayer)lyr).DefinitionExpression = ((FeatureLayer)layer).DefinitionExpression;
}
else if (lyr is GroupLayer)
{
SetupLayersUnderGroupLayer((GroupLayer)lyr, (GroupLayer)layer, lfs);
}
this.Map.OperationalLayers.Add(lyr);
}
}
}
return(mmpk);
}
/// <summary>
/// Adds a SQLite geodatabase to the list of layers.
/// </summary>
/// <param name="pathToGeodatabase">the file to be loaded</param>
/// <returns>simply a marker indicating that things completed (true all good, false not all good)</returns>
public async Task <bool> AddSQLiteGeodatabaseAsync(string pathToGeodatabase)
{
bool allGood = true;
if (!this.HasLayerFileSource(pathToGeodatabase))
{
LayerFileSource lfs = new LayerFileSource();
lfs.SourceFile = pathToGeodatabase;
this.LayerFileSources.Add(lfs);
Geodatabase gdb = await Geodatabase.OpenAsync(pathToGeodatabase);
//
// Store the test layers.
//
foreach (GeodatabaseFeatureTable gft in gdb.GeodatabaseFeatureTables)
{
TesterLayer testLayer = new TesterLayer();
testLayer.FeatureTable = gft;
gft.PropertyChanged += GeodbFeatTab_PropertyChanged;
lfs.Children.Add(testLayer);
}
//
// Now load them all.
//
foreach (TesterLayer tl in lfs.Children)
{
GeodatabaseFeatureTable gtab = tl.FeatureTable;
try
{
await gtab.LoadAsync();
FeatureLayer fLayer = new FeatureLayer(gtab);
fLayer.PropertyChanged += FeatureLayer_PropertyChanged;
await fLayer.LoadAsync();
fLayer.LabelsEnabled = true;
this.Map.OperationalLayers.Add(fLayer);
tl.FeatureLayer = fLayer;
}
catch (Exception exc)
{
tl.LayerLoadException = exc;
allGood = false;
tl.LoadDone = true;
}
}
}
return(allGood);
}
/// <summary>
/// Copies the definition expressions from any feature layers under the source layer to the matching feature layers under the target layer.
/// </summary>
/// <param name="targetLayer">the target group layer</param>
/// <param name="sourceLayer">the source group layer</param>
private static void SetupLayersUnderGroupLayer(GroupLayer targetLayer, GroupLayer sourceLayer, LayerFileSource lfs)
{
Dictionary <string, string> defExprs = new Dictionary <string, string>();
//
// Collect all definition expressions.
//
foreach (Layer srcChildLayer in sourceLayer.Layers)
{
if (srcChildLayer is FeatureLayer)
{
TesterLayer testLayer = new TesterLayer();
testLayer.FeatureLayer = srcChildLayer as FeatureLayer;
GeodatabaseFeatureTable featureTable = testLayer.FeatureLayer.FeatureTable as GeodatabaseFeatureTable;
testLayer.FeatureTable = featureTable;
lfs.Children.Add(testLayer);
FeatureLayer srcLayer = (FeatureLayer)srcChildLayer;
string defExpr = srcLayer.DefinitionExpression;
if (!string.IsNullOrEmpty(defExpr))
{
defExprs[srcLayer.Name] = defExpr;
}
}
}
//
// Apply all definition expressions. Cache them as derived.
//
foreach (Layer tgtChildLayer in targetLayer.Layers)
{
if (tgtChildLayer is FeatureLayer)
{
TesterLayer testLayer = new TesterLayer();
testLayer.FeatureLayer = tgtChildLayer as FeatureLayer;
GeodatabaseFeatureTable featureTable = testLayer.FeatureLayer.FeatureTable as GeodatabaseFeatureTable;
testLayer.FeatureTable = featureTable;
lfs.Children.Add(testLayer);
FeatureLayer tgtLayer = (FeatureLayer)tgtChildLayer;
tgtLayer.LabelsEnabled = true;
// This will apply the mapservice name to the feature layer under the group layers so that
// the results from this layer will be under the same map service or else it will be in a different set
// under a system generated hashcode for this layer.
tgtLayer.Id = targetLayer.Id;
if (defExprs.ContainsKey(tgtLayer.Name))
{
tgtLayer.DefinitionExpression = defExprs[tgtLayer.Name];
}
}
}
}
