/// <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>
/// Temporary method...throws the exception information into the log.
/// </summary>
/// <param name="layer"></param>
private void LogLayerLoadException(TesterLayer layer)
{
string excString = "=====================\n";
excString = excString + "Error loading layer: " + layer.Name + "\n";
excString = excString + layer.LayerLoadException.Message + "\n";
excString = excString + layer.LayerLoadException.StackTrace + "\n";
this.LoggingText = excString;
}
/// <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];
}
}
}
}
/// <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>
/// Used to toss a view of records from a selected table into the log.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void treeView_SelectedItemChanged(object sender, RoutedPropertyChangedEventArgs <object> e)
{
MainWindowViewModel viewModel = (MainWindowViewModel)this.FindResource("MainWindowViewModel");
TesterLayer selectedLayer = null;
try
{
selectedLayer = (TesterLayer)this.treeView.SelectedItem;
}
catch (InvalidCastException)
{ }
if (selectedLayer != null)
{
await viewModel.ShowSingleRecordAsync(selectedLayer);
}
}
/// <summary>
/// Assuming there's a selected SQLite layer, prompts the user for a CSV filename and spits out a frequency
/// analysis of the values in the specified table.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void freqAnalysisButton_Click(object sender, RoutedEventArgs e)
{
MainWindowViewModel viewModel = (MainWindowViewModel)this.FindResource("MainWindowViewModel");
TesterLayer selectedLayer = null;
try
{
selectedLayer = (TesterLayer)this.treeView.SelectedItem;
}
catch (InvalidCastException)
{ }
if ((selectedLayer != null) && (selectedLayer.FeatureTable != null))
{
if (this.FreqAnalysisDialog == null)
{
this.FreqAnalysisDialog = new SaveFileDialog();
this.FreqAnalysisDialog.AddExtension = true;
this.FreqAnalysisDialog.Filter = "Comma-Delimited(*.csv)|*.csv";
this.FreqAnalysisDialog.OverwritePrompt = true;
this.FreqAnalysisDialog.Title = "Save Frequency Analysis...";
}
this.FreqAnalysisDialog.FileName = Path.Combine(this.FreqAnalysisDialog.InitialDirectory, selectedLayer.FeatureTable.TableName + ".csv");
bool? result = this.FreqAnalysisDialog.ShowDialog();
string fileName = null;
if (result == true)
{
fileName = this.FreqAnalysisDialog.FileName;
result = await viewModel.RunFrequencyAnalysis(fileName, selectedLayer.FeatureTable);
if (result == true)
{
MessageBox.Show("Frequency analysis for " + selectedLayer.FeatureTable.TableName + " is complete.");
}
else
{
MessageBox.Show("Frequency analysis for " + selectedLayer.FeatureTable.TableName + " FAILED. See error log for details.");
}
}
}
}
/// <summary>
/// Temporary method. Just displays attributes and values from a single record in the passed table.
/// </summary>
/// <param name="testLayer">from which to get the single record</param>
/// <returns>marker indicating the task is complete</returns>
public async Task <bool> ShowSingleRecordAsync(TesterLayer testLayer)
{
if (testLayer.LayerLoadException != null)
{
this.LogLayerLoadException(testLayer);
}
else if (testLayer.FeatureTable != null)
{
FeatureTable aTable = testLayer.FeatureTable;
QueryParameters queryParams = new QueryParameters();
queryParams.MaxFeatures = 1;
queryParams.ReturnGeometry = true;
queryParams.WhereClause = "1=1";
FeatureQueryResult fqr = await aTable.QueryFeaturesAsync(queryParams);
IEnumerator <Feature> features = fqr.GetEnumerator();
this.LoggingText = "=============";
this.LoggingText = "TABLE: " + aTable.TableName;
Feature aFeature = null;
while (features.MoveNext())
{
aFeature = features.Current;
this.LoggingText = "\tShape = " + aFeature.Geometry;
foreach (string attName in aFeature.Attributes.Keys)
{
this.LoggingText = "\t" + attName + " = " + aFeature.Attributes[attName];
}
}
this.LoggingText = "=============";
}
return(true);
}
