public static FieldInfo ChangeRenderer(this GraphicsLayer graphicsLayer, string rendererType, FieldInfo attributeField) { IRenderer newRenderer = null; GeometryType geometryType = ESRI.ArcGIS.Mapping.Core.LayerExtensions.GetGeometryType(graphicsLayer); LinearGradientBrush gradientBrush = ESRI.ArcGIS.Mapping.Core.LayerExtensions.GetGradientBrush(graphicsLayer); FieldInfo changedRenderAttributeField = null; List<Symbol> existingSymbolSet = null; if (Constants.ClassBreaksRenderer.Equals(rendererType)) { int classBreakCount = 5; ClassBreaksRenderer currentRenderer = graphicsLayer.Renderer as ClassBreaksRenderer; if (currentRenderer != null) { classBreakCount = currentRenderer.Classes.Count; existingSymbolSet = new List<Symbol>(); foreach (ClassBreakInfo classBreak in currentRenderer.Classes) existingSymbolSet.Add(classBreak.Symbol); } newRenderer = createClassBreakRendererBasedOnSelectedAttribute(graphicsLayer, attributeField, gradientBrush, geometryType, classBreakCount, existingSymbolSet, out changedRenderAttributeField); } else if (Constants.UniqueValueRenderer.Equals(rendererType)) { UniqueValueRenderer currentRenderer = graphicsLayer.Renderer as UniqueValueRenderer; if (currentRenderer != null) { existingSymbolSet = new List<Symbol>(); foreach (UniqueValueInfo uniqueValue in currentRenderer.Infos) existingSymbolSet.Add(uniqueValue.Symbol); } newRenderer = createUniqueValueRendererBasedOnSelectedAttribute(graphicsLayer, attributeField, gradientBrush, geometryType, existingSymbolSet, out changedRenderAttributeField); } else if (Constants.SimpleRenderer.Equals(rendererType)) { newRenderer = createNewDefaultSimpleRenderer(graphicsLayer); } assignNewRendererToLayer(graphicsLayer, newRenderer); if (changedRenderAttributeField != null) ESRI.ArcGIS.Mapping.Core.LayerExtensions.SetRendererAttributeDisplayName(graphicsLayer, changedRenderAttributeField.DisplayName); else if (attributeField != null) ESRI.ArcGIS.Mapping.Core.LayerExtensions.SetRendererAttributeDisplayName(graphicsLayer, attributeField.DisplayName); else ESRI.ArcGIS.Mapping.Core.LayerExtensions.SetRendererAttributeDisplayName(graphicsLayer, null); return changedRenderAttributeField; }
internal void UpdateLayerRendererAttribute(FieldInfo attributeField) { if (AttributeName == null) return; _ignoreRendererTypeChangedEvent = true; _ignoreAttributeChangedEvent = true; buildDropDowns(); _ignoreAttributeChangedEvent = false; _ignoreRendererTypeChangedEvent = false; //FieldInfo selectedField = null; //foreach (FieldInfo fieldInfo in AttributeName.Items) //{ // if (string.Compare(fieldInfo.Name, attributeName) == 0) // { // selectedField = fieldInfo; // break; // } //} //if (selectedField != null) //{ // _ignoreAttributeChangedEvent = true; // AttributeName.SelectedItem = selectedField; // _ignoreAttributeChangedEvent = false; //} }
private void processLayerInfoResult(ArcGISWebClient.DownloadStringCompletedEventArgs e) { #region Parse layer info from json if (e.Cancelled) { return; } if (e.Error != null) { singleLayerRequestCompleted(null, e); return; } string json = null; try { json = e.Result; } catch (Exception exception) { if (exception != null) { singleLayerRequestCompleted(null, e); return; } } Exception ex = ESRI.ArcGIS.Mapping.DataSources.Utils.CheckJsonForException(json); if (ex != null) { singleLayerRequestCompleted(null, e); return; } json = "{\"layerDefinition\":" + json + "}"; FeatureLayer featureLayer = FeatureLayer.FromJson(json); FeatureLayerInfo featurelayerinfo = featureLayer.LayerInfo; if (featurelayerinfo == null) { singleLayerRequestCompleted(null, e); return; } LayerInformation info = new LayerInformation() { ID = featurelayerinfo.Id, DisplayField = featurelayerinfo.DisplayField, Name = featurelayerinfo.Name, PopUpsEnabled = false, LayerJson = json, FeatureLayer = featureLayer }; Collection <ESRI.ArcGIS.Mapping.Core.FieldInfo> fieldInfos = new Collection <ESRI.ArcGIS.Mapping.Core.FieldInfo>(); if (featurelayerinfo.Fields != null) { foreach (ESRI.ArcGIS.Client.Field field in featurelayerinfo.Fields) { if (FieldHelper.IsFieldFilteredOut(field.Type)) { continue; } ESRI.ArcGIS.Mapping.Core.FieldInfo fieldInfo = ESRI.ArcGIS.Mapping.Core.FieldInfo.FieldInfoFromField(featureLayer, field); fieldInfos.Add(fieldInfo); } } info.Fields = fieldInfos; if (fieldInfos.Count > 0) { singleLayerRequestCompleted(info, e); } else { singleLayerRequestCompleted(null, e); } #endregion }
private void sortFilterAndReBind(bool isSortAsc, FieldInfo sortField) { if (FeatureDataGrid == null) return; if (_graphicsLayer == null) return; NoAttributesLabelVisibility = Visibility.Collapsed; if (FilterFeaturesByMapExtent) { getFilterByMapExtentResultsWithRetry(isSortAsc, sortField); } else { _sortedGraphics = SortGraphics(_graphicsLayer.Graphics, isSortAsc, sortField); ApplyFilterBySelection(); CheckForAttributes(); } }
/// <summary> /// Refreshes the Attribute Display list for graphics within the map extent /// </summary> private bool refreshByMapExtentNow(Rect mapExtentInHostCoordinates, bool isSortAsc, FieldInfo sortField, bool resetCount= true) { if (resetCount) _refreshLastResultCount = -1; try { if (mapExtentInHostCoordinates != Rect.Empty && _graphicsLayer != null) { IEnumerable<Graphic> results = Core.Utility.FindGraphicsInHostCoordinates(_graphicsLayer, mapExtentInHostCoordinates); if (results != null) { // load the Attribute Display with these results int hitCount = results.Count(); // prevent the FDG from redundantly updating every time by checking the last results count if (FeatureDataGrid.FilterSource == null || hitCount != _refreshLastResultCount) { _refreshLastResultCount = hitCount; // update the feature data grid with the new results applyResultsByExtentFromTimer(results, isSortAsc, sortField); } } } } catch (Exception ex) { Logger.Instance.LogError(ex); } return false; }
/// <summary> /// Finds graphics within the Envelope map area, with timer to /// retry every 500ms for 10 seconds /// </summary> /// <remarks>>If the timer is already running, this call will /// return without starting the timer.</remarks> /// <param name="envelope">null = entire map extent, otherwise as set</param> private void getFilterByMapExtentResultsWithRetry(bool isSortAsc, FieldInfo sortField, Envelope envelope= null) { if (FeatureDataGrid == null || _graphicsLayer == null || Map == null) return; if (envelope == null) envelope = Map.Extent; Dispatcher.BeginInvoke((Action)delegate { GeneralTransform transform = Transform.GetTransformToRoot(Map); Point ul = transform.Transform(Map.MapToScreen(new MapPoint(envelope.XMin, envelope.YMax))); Point lr = transform.Transform(Map.MapToScreen(new MapPoint(envelope.XMax, envelope.YMin))); Rect mapCoOrdinatesRect = new Rect(ul, lr); try { refreshByMapExtentWithRetry(mapCoOrdinatesRect,isSortAsc,sortField); } catch (Exception ex) { Logger.Instance.LogError(ex); } }); }
internal void RaiseSortedEvent(FieldInfo fieldInfo) { bool isSortAsc = _lastSortedField == fieldInfo ? !_isLastSortAsc : true; sortFilterAndReBind(isSortAsc, fieldInfo); _isLastSortAsc = isSortAsc; _lastSortedField = fieldInfo; OnSorted(new DataGridSortedEventArgs() { SortedField = fieldInfo }); }
private void ShowHideAutoGeneratedColumn(FieldInfo info) { if (info == null || FeatureDataGrid == null || FeatureDataGrid.Columns == null) return; foreach (DataGridColumn column in FeatureDataGrid.Columns) { FieldInfo headerInfo = column.Header as FieldInfo; if (headerInfo == info) { column.Visibility = headerInfo.VisibleInAttributeDisplay ? Visibility.Visible : Visibility.Collapsed;//show/hide the column return; } } }
private static UniqueValueRenderer createUniqueValueRendererBasedOnSelectedAttribute(GraphicsLayer graphicsLayer, FieldInfo attributeField, LinearGradientBrush defaultColorRampGradientBrush, GeometryType geometryType, IEnumerable<Symbol> existingSymbolSet, out FieldInfo changedAttributeField) { changedAttributeField = attributeField; UniqueValueRenderer uniqueValueRenderer = graphicsLayer.Renderer as UniqueValueRenderer; if (uniqueValueRenderer != null) // already using unique value renderer { if (attributeField != null && attributeField.Name != uniqueValueRenderer.Field) // check if attribute has been changed { IEnumerable<object> uniqueValues = getAllUniqueValues(graphicsLayer, attributeField); uniqueValueRenderer = createNewDefaultUniqueValueRenderer(graphicsLayer, uniqueValues, attributeField, defaultColorRampGradientBrush, existingSymbolSet); } } else { string attributeFieldName = null; if (graphicsLayer.Renderer is ClassBreaksRenderer) { // Check if the class breaks renderer had an attribute set. If so, honor that attribute name ClassBreaksRenderer classBreakRenderer = graphicsLayer.Renderer as ClassBreaksRenderer; if (classBreakRenderer != null) attributeFieldName = classBreakRenderer.Field; } if (string.IsNullOrEmpty(attributeFieldName)) // No attribute known .. use the first non-attachment field { FieldInfo field = null; Collection<FieldInfo> layerFields = ESRI.ArcGIS.Mapping.Core.LayerExtensions.GetFields(graphicsLayer); if (layerFields != null) field = layerFields.FirstOrDefault<FieldInfo>(f => f.FieldType != FieldType.Attachment); if (field != null) { changedAttributeField = field; attributeField = field; attributeFieldName = field.Name; } } if (string.IsNullOrEmpty(attributeFieldName)) // An attribute name must be specified return null; IEnumerable<object> uniqueValues = getAllUniqueValues(graphicsLayer, attributeField); // Create a default unique value renderer uniqueValueRenderer = createNewDefaultUniqueValueRenderer(graphicsLayer, uniqueValues, attributeField, defaultColorRampGradientBrush, existingSymbolSet); } return uniqueValueRenderer; }
private static void getMinAndMaxForGraphicsLayer(GraphicsLayer graphicsLayer, FieldInfo attributeField, out double min, out double max) { min = double.NaN; max = double.NaN; if (graphicsLayer != null && attributeField != null && !string.IsNullOrEmpty(attributeField.Name)) { foreach (Graphic g in graphicsLayer.Graphics) { object o; if (g.Attributes.TryGetValue(attributeField.Name, out o)) { if (o == null) continue; double value; NumericFieldValue numericFieldValue = o as NumericFieldValue; if (numericFieldValue != null) { o = numericFieldValue.Value; } else { CurrencyFieldValue currencyFieldValue = o as CurrencyFieldValue; if (currencyFieldValue != null) { o = currencyFieldValue.Value; } } if (double.TryParse( string.Format(System.Globalization.CultureInfo.InvariantCulture, "{0}", o), System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out value)) { if (double.IsNaN(min)) // first value min = value; else min = Math.Min(min, value); if (double.IsNaN(max)) // first value max = value; else max = Math.Max(max, value); } } } } if (double.IsNaN(min)) min = 0d; if (double.IsNaN(max)) max = 0d; }
private static IEnumerable<object> getAllUniqueValues(GraphicsLayer graphicsLayer, FieldInfo attributeField) { if (graphicsLayer == null || attributeField == null || string.IsNullOrEmpty(attributeField.Name)) return null; List<object> uniqValues = new List<object>(); foreach (Graphic g in graphicsLayer.Graphics) { object o; if (g.Attributes.TryGetValue(attributeField.Name, out o)) { if (o == null) continue; // ignore blank values string objString = o.ToString(); if (string.IsNullOrEmpty(objString)) continue; if (!uniqValues.Contains(o)) uniqValues.Add(o); } } uniqValues.Sort(); return uniqValues; }
private static UniqueValueRenderer createNewDefaultUniqueValueRenderer(GraphicsLayer graphicsLayer, IEnumerable<object> uniqueValues, FieldInfo attributeField, LinearGradientBrush defaultColorRampGradientBrush, IEnumerable<Symbol> existingSymbolSet) { Symbol defaultSymbol = graphicsLayer.GetDefaultSymbol(); UniqueValueRenderer uniqueValueRenderer = new UniqueValueRenderer() { Field = attributeField != null ? attributeField.Name : null, DefaultSymbol = defaultSymbol, }; if (uniqueValues != null) { List<Symbol> symbols = new List<Symbol>(); int i = 0; foreach (object uniqueValue in uniqueValues) { Symbol symbol = null; if (existingSymbolSet != null) symbol = existingSymbolSet.ElementAtOrDefault(i); if (symbol == null) symbol = graphicsLayer.GetDefaultSymbolClone(); uniqueValueRenderer.Infos.Add(new UniqueValueInfoObj() { Symbol = symbol, SerializedValue = uniqueValue, FieldType = attributeField.FieldType, }); symbols.Add(symbol); i++; } if (defaultColorRampGradientBrush != null) { if (existingSymbolSet == null) // apply the gradient brush, only if symbols have not been pre-defined { applyLinearGradientBrushToSymbolSet(symbols, defaultColorRampGradientBrush, defaultSymbol); } } } return uniqueValueRenderer; }
private static IRenderer createNewDefaultClassBreaksRenderer(GraphicsLayer graphicsLayer, FieldInfo attributeField, double min, double max, int numOfClassBreaks, LinearGradientBrush defaultColorRampGradientBrush, IEnumerable<Symbol> existingSymbolSet) { Symbol defaultSymbol = graphicsLayer.GetDefaultSymbolClone(); ClassBreaksRenderer renderer = new ClassBreaksRenderer() { Field = attributeField != null ? attributeField.Name : null, DefaultSymbol = defaultSymbol, }; List<Symbol> symbols = new List<Symbol>(); if (numOfClassBreaks < 2) // classbreaks renderer must have atleast 2 classbreaks numOfClassBreaks = 2; double rangeSize = Math.Round((max - min) / numOfClassBreaks, 2); double rangeDelta = 1.0; // delta between 2 class ranges // we choose an integral size double lastRangeDeltaIncr = 1.0; // SL core api requires the last classbreak to be greater than max value of dataset bool fractionalIncrement = false; if (Math.Round(max, 0) != max)// we are dealing with a non-integeral values, so our delta's are in fractional increments { fractionalIncrement = true; rangeDelta = 0.01; lastRangeDeltaIncr = 0.01; } double startValue = min; for (int i = 0; i < numOfClassBreaks; i++) { Symbol symbol = null; if (existingSymbolSet != null) symbol = existingSymbolSet.ElementAtOrDefault(i); if (symbol == null) symbol = graphicsLayer.GetDefaultSymbolClone(); double endValue = (startValue + rangeSize) - rangeDelta; ClassBreakInfo classBreak = new ClassBreakInfo() { MinimumValue = fractionalIncrement ? startValue : Math.Floor(startValue), MaximumValue = fractionalIncrement ? endValue : Math.Floor(endValue), Symbol = symbol, }; if (i == numOfClassBreaks - 1) // last class break { classBreak.MaximumValue = max + lastRangeDeltaIncr; if (max > 1000000) // SL has a limitation on values greater than a million http://msdn.microsoft.com/en-us/library/bb412393.aspx classBreak.MaximumValue += 2.0;// the +2 is to workaround Silverlights limitation of single precision values } symbols.Add(symbol); renderer.Classes.Add(classBreak); startValue += rangeSize; } if (defaultColorRampGradientBrush != null) { if (existingSymbolSet == null) // apply the gradient brush, only if symbols have not been pre-defined { applyLinearGradientBrushToSymbolSet(symbols, defaultColorRampGradientBrush, defaultSymbol); } } return renderer; }
private static IRenderer createClassBreakRendererBasedOnSelectedAttribute(GraphicsLayer graphicsLayer, FieldInfo attributeField, LinearGradientBrush defaultColorRampGradientBrush, GeometryType geometryType, int classBreakCount, IEnumerable<Symbol> existingSymbolSet, out FieldInfo changedAttributeField) { changedAttributeField = attributeField; ClassBreaksRenderer classBreaksRenderer = graphicsLayer.Renderer as ClassBreaksRenderer; if (classBreaksRenderer != null) // Already using classBreaksRenderer { if (attributeField != null && attributeField.Name != classBreaksRenderer.Field) // Using different attribute for the renderer { classBreaksRenderer.Field = attributeField.Name; // Rebuild the class breaks double min, max; getMinAndMaxForGraphicsLayer(graphicsLayer, attributeField, out min, out max); return createNewDefaultClassBreaksRenderer(graphicsLayer, attributeField, min, max, classBreakCount, defaultColorRampGradientBrush, existingSymbolSet); } } else { string attributeFieldName = null; if (graphicsLayer.Renderer is UniqueValueRenderer) { // 1. Check if the renderer has an attribute set as UniqueValue Renderer UniqueValueRenderer uniqueValueRenderer = graphicsLayer.Renderer as UniqueValueRenderer; if (uniqueValueRenderer != null) attributeFieldName = uniqueValueRenderer.Field; } if (string.IsNullOrEmpty(attributeFieldName)) // No attribute known .. use the first numeric field { FieldInfo field = null; Collection<FieldInfo> layerFields = ESRI.ArcGIS.Mapping.Core.LayerExtensions.GetFields(graphicsLayer); if (layerFields != null) field = layerFields.FirstOrDefault<FieldInfo>(f => f.FieldType == FieldType.DecimalNumber || f.FieldType == FieldType.Integer || f.FieldType == FieldType.Currency); if (field != null) { attributeField = field; changedAttributeField = field; attributeFieldName = field.Name; } } else { FieldInfo field = null; Collection<FieldInfo> layerFields = ESRI.ArcGIS.Mapping.Core.LayerExtensions.GetFields(graphicsLayer); if (layerFields != null) field = layerFields.FirstOrDefault<FieldInfo>(f => f.Name == attributeFieldName); // find matching field if (field == null || (field.FieldType != FieldType.Integer && field.FieldType != FieldType.DecimalNumber && field.FieldType != FieldType.Currency)) { // if the previous field was not a number or currency, then automatically switch it to the first numeric one field = layerFields.FirstOrDefault<FieldInfo>(f => f.FieldType == FieldType.Integer || f.FieldType == FieldType.DecimalNumber || f.FieldType == FieldType.Currency); if (field != null) { attributeField = field; changedAttributeField = field; attributeFieldName = field.Name; } } } if (string.IsNullOrEmpty(attributeFieldName)) // An attribute name must be specified return null; // Loop through graphics and calculate max and min double min, max; getMinAndMaxForGraphicsLayer(graphicsLayer, attributeField, out min, out max); return createNewDefaultClassBreaksRenderer(graphicsLayer, attributeField, min, max, classBreakCount, defaultColorRampGradientBrush, existingSymbolSet); } return null; }
public static FieldInfo ChangeAttributeForRenderer(this GraphicsLayer graphicsLayer, FieldInfo newAttributeField) { IRenderer newRenderer = null; GeometryType geometryType = ESRI.ArcGIS.Mapping.Core.LayerExtensions.GetGeometryType(graphicsLayer); LinearGradientBrush gradientBrush = ESRI.ArcGIS.Mapping.Core.LayerExtensions.GetGradientBrush(graphicsLayer); FieldInfo changedAttribute = null; List<Symbol> existingSymbolSet; ClassBreaksRenderer classBreaksRenderer = graphicsLayer.Renderer as ClassBreaksRenderer; if (classBreaksRenderer != null) { existingSymbolSet = new List<Symbol>(); foreach (ClassBreakInfo classBreak in classBreaksRenderer.Classes) existingSymbolSet.Add(classBreak.Symbol); newRenderer = createClassBreakRendererBasedOnSelectedAttribute(graphicsLayer, newAttributeField, gradientBrush, geometryType, classBreaksRenderer.Classes.Count, existingSymbolSet, out changedAttribute); } else { UniqueValueRenderer uniqueValueRenderer = graphicsLayer.Renderer as UniqueValueRenderer; if (uniqueValueRenderer != null) { existingSymbolSet = new List<Symbol>(); foreach (UniqueValueInfo uniqueValue in uniqueValueRenderer.Infos) existingSymbolSet.Add(uniqueValue.Symbol); newRenderer = createUniqueValueRendererBasedOnSelectedAttribute(graphicsLayer, newAttributeField, gradientBrush, geometryType, existingSymbolSet, out changedAttribute); } } assignNewRendererToLayer(graphicsLayer, newRenderer); graphicsLayer.Refresh(); if (changedAttribute != null) ESRI.ArcGIS.Mapping.Core.LayerExtensions.SetRendererAttributeDisplayName(graphicsLayer, changedAttribute.DisplayName); else if (newAttributeField != null) ESRI.ArcGIS.Mapping.Core.LayerExtensions.SetRendererAttributeDisplayName(graphicsLayer, newAttributeField.DisplayName); else ESRI.ArcGIS.Mapping.Core.LayerExtensions.SetRendererAttributeDisplayName(graphicsLayer, null); return changedAttribute; }
private void determineFieldsFromGraphic(Collection<FieldInfo> layerFields, Graphic graphic) { if (graphic == null || layerFields == null) return; foreach (KeyValuePair<string, object> pair in graphic.Attributes) { FieldInfo field = new FieldInfo() { Name = pair.Key, DisplayName = pair.Key, VisibleInAttributeDisplay = true, VisibleOnMapTip = true }; if (pair.Value is DateTime) field.FieldType = FieldType.DateTime; else if (pair.Value is double || pair.Value is decimal) field.FieldType = FieldType.DecimalNumber; else if (pair.Value is int || pair.Value is byte) field.FieldType = FieldType.Integer; else field.FieldType = FieldType.Text; layerFields.Add(field); } }
private CustomDataGridColumn createDataGridColumnForField(FieldInfo field) { string fieldName = field.Name; if (doesfieldNeedNormalization(fieldName)) { fieldName = normalizeFieldName(fieldName); } CustomDataGridColumn col = new CustomDataGridColumn() { Header = field, IsReadOnly = true, Binding = new Binding() { // Use a converter to retrieve the field value. Otherwise, the binding // will blow up on field names that are numeric - and perhaps others Converter = new RowToFieldValueConverter(), ConverterParameter = fieldName }, FieldInfo = field, }; return col; }
private void bindUI() { if (LayerInfo == null) return; object fields = LayerInfo.Fields; if (fields != null) { if (MapTipsDataGrid != null) { MapTipsDataGrid.IsEnabled = true; MapTipsDataGrid.ItemsSource = fields as IEnumerable<FieldInfo>; } if (ToggleAllVisibilityButton != null) ToggleAllVisibilityButton.IsEnabled = true; if (fields is Collection<FieldInfo>) { CheckToggleButtonState(fields as IEnumerable<FieldInfo>); } if (HeaderCombo != null && fields is IEnumerable<FieldInfo>) { string displayField = LayerInfo.DisplayField; Collection<FieldInfo> filteredFields = new Collection<FieldInfo>(); // if not set for popup on click, add <none> FieldInfo selectedItem = null; if (Info != null && Info.PopUpsOnClick != null && !Info.PopUpsOnClick.Value && !Info.LayerSelectionVisibility) { FieldInfo noneField = new FieldInfo() { Name = ESRI.ArcGIS.Mapping.Core.LocalizableStrings.NoneInAngleBraces }; filteredFields.Add(noneField); selectedItem = noneField; } foreach (FieldInfo item in fields as IEnumerable<FieldInfo>) { if (FieldInfo.SupportedInHeader(item.FieldType)) { filteredFields.Add(item); if (!string.IsNullOrEmpty(displayField)) { if (item.Name.ToLower().Equals(displayField.ToLower())) selectedItem = item; } } } HeaderCombo.ItemsSource = filteredFields; HeaderCombo.IsEnabled = true; HeaderCombo.SelectedItem = selectedItem; } } else { if (MapTipsDataGrid != null) { MapTipsDataGrid.IsEnabled = false; MapTipsDataGrid.ItemsSource = null; } if (ToggleAllVisibilityButton != null) ToggleAllVisibilityButton.IsEnabled = false; if (HeaderCombo != null) { HeaderCombo.ItemsSource = null; HeaderCombo.IsEnabled = false; } } }
private int findInsertIndexOfField(FieldInfo field) { int pos = 0; Collection<FieldInfo> fields = LayerExtensions.GetFields(GraphicsLayer); if (fields != null) { foreach (FieldInfo f in fields) { if (f.Name == field.Name) break; if (!f.VisibleInAttributeDisplay) // skip non visible fields continue; pos++; } } return pos; }
internal void FieldInfo_MapTipVisiblityChecked(FieldInfo fieldInfo) { if (fieldInfo == null) return; GraphicsLayer graphicsLayer = Layer as GraphicsLayer; if (graphicsLayer != null) LayerExtensions.SetIsMapTipDirty(graphicsLayer, true); bool visible = !isClearAllState; IEnumerable<FieldInfo> fields = LayerInfo.Fields; if (fields == null) return; // For feature layers - add the name of the field to the OutFields collection FeatureLayer featureLayer = Layer as FeatureLayer; if (featureLayer != null) { if (featureLayer.OutFields.Count == 1 && featureLayer.OutFields[0] == "*") { reBuildOutFields(featureLayer, fields); } else { if (!featureLayer.OutFields.Contains(fieldInfo.Name)) featureLayer.OutFields.Add(fieldInfo.Name); } } CheckToggleButtonState(fields); }
internal void OnGraphicsLayerChanged(GraphicsLayer newGraphicsLayer) { detachHandlers(); _graphicsLayer = newGraphicsLayer; _isLastSortAsc = false; _lastSortedField = null; _sortedGraphics = null; attachHandlers(); bindGraphicsLayerToDataGrid(); }
internal void FieldInfo_MapTipVisibilityUnChecked(FieldInfo fieldInfo) { if (fieldInfo == null) return; GraphicsLayer graphicsLayer = Layer as GraphicsLayer; if (graphicsLayer != null) LayerExtensions.SetIsMapTipDirty(graphicsLayer, true); bool visible = !isClearAllState; IEnumerable<FieldInfo> fields = LayerInfo.Fields; if (fields == null) return; // For feature layers - remove the name of the field to the OutFields collection FeatureLayer featureLayer = Layer as FeatureLayer; if (featureLayer != null) { if (featureLayer.OutFields.Count == 1 && featureLayer.OutFields[0] == "*") { reBuildOutFields(featureLayer, fields); } else { // in not also visible in attribute display and not the renderer field = remove it if (!fieldInfo.VisibleInAttributeDisplay && !isRendererField(fieldInfo)) { featureLayer.OutFields.Remove(fieldInfo.Name); } } } CheckToggleButtonState(fields); }
/// <summary> /// Refreshes the Attribute Display and uses a retry mechanism if the initial attempts to refresh /// do not return any graphics (in case the layer is large and has not fully loaded yet) /// </summary> private void refreshByMapExtentWithRetry(Rect mapExtentInHostCoordinates, bool isSortAsc, FieldInfo sortField) { try { if (_refreshTimer != null) { _refreshTimer.Stop(); } else { _refreshTimer = new DispatcherTimer { Interval = new TimeSpan(0, 0, 0, 0, 500) }; _refreshTimerTicks = 0; #region Timer Tick handler _refreshTimer.Tick += (s, e) => { if (_isRefreshing) return; try { _refreshTimerTicks++; // Try another refresh checking 20 times (10 seconds after the layer was added) if (_refreshTimerTicks < 20) { _isRefreshing = true; try { refreshByMapExtentNow(mapExtentInHostCoordinates, isSortAsc, sortField, resetCount:false); } finally { _isRefreshing = false; } } else { _refreshTimer.Stop(); _refreshTimer = null; } } catch (Exception ex) { Console.WriteLine(ex); if (_refreshTimer != null) { _refreshTimer.Stop(); _refreshTimer = null; } } }; #endregion } // Attempt refresh using filter by map extent refreshByMapExtentNow (mapExtentInHostCoordinates, isSortAsc, sortField); // The refresh did not find any graphics. This may be due to a // layer with a lot of features that has not fully loaded yet. _refreshTimer.Start(); } catch (Exception ex2) { Console.WriteLine(ex2); if (_refreshTimer != null) { _refreshTimer.Stop(); _refreshTimer = null; } } }
private bool isRendererField(FieldInfo field) { if (field == null) return false; string rendererAttr = getRendererAttributeName(); if (rendererAttr == field.Name) return true; return false; }
private void applyResultsByExtentFromTimer(IEnumerable<Graphic> results, bool isSortAsc, FieldInfo sortField) { if (results == null) return; // load the attribute display with the graphics within the map extent _sortedGraphics = SortGraphics(results, isSortAsc, sortField); ApplyFilterBySelection(); CheckForAttributes(); }
// TODO: Support StringFieldOptions internal static FieldInfo FromDictionary(IDictionary<string, object> dictionary) { FieldInfo fi = new FieldInfo(); if (dictionary.ContainsKey("fieldName")) fi.FieldName = dictionary["fieldName"] as string; if (dictionary.ContainsKey("label")) fi.Label = dictionary["label"] as string; if (dictionary.ContainsKey("formatter")) fi.Formatter = dictionary["formatter"] as string; if (dictionary.ContainsKey("visible")) fi.Visible = Convert.ToBoolean(dictionary["visible"]); if (dictionary.ContainsKey("isEditable")) fi.IsEditable = Convert.ToBoolean(dictionary["isEditable"]); if (dictionary.ContainsKey("tooltip")) fi.Tooltip = dictionary["tooltip"] as string; // TODO: Add support for stringFieldOptions return fi; }
internal IEnumerable<Graphic> SortGraphics(IEnumerable<Graphic> graphics, bool isSortAsc, FieldInfo sortField) { if (sortField != null) { bool sortable = false; Type dataType = null; foreach (Graphic graphic in graphics) { if (graphic.Attributes[sortField.Name] != null) { sortable = graphic.Attributes[sortField.Name] is IComparable; dataType = graphic.Attributes[sortField.Name].GetType(); break; } } if (sortable && dataType != null) { if (isSortAsc) graphics = graphics.OrderBy(r => ( (r.Attributes[sortField.Name] != null && r.Attributes[sortField.Name].GetType() == dataType) ? r.Attributes[sortField.Name] : null)); else graphics = graphics.OrderByDescending(r => ( (r.Attributes[sortField.Name] != null && r.Attributes[sortField.Name].GetType() == dataType) ? r.Attributes[sortField.Name] : null)); } } return graphics; }
public static object GetDomainValue(FeatureLayer featureLayer, IDictionary<string, object> attibutes, FieldInfo field) { object originalValue = string.Empty; string fieldName = string.Empty; if (featureLayer == null) return originalValue; if (field != null) fieldName = field.Name; if (attibutes != null) { originalValue = attibutes[field.Name]; if (originalValue == null) { if (attibutes.ContainsKey(field.DisplayName)) { fieldName = field.DisplayName; originalValue = attibutes[field.DisplayName]; } else return originalValue; } } if (featureLayer == null) return originalValue; if (field.DomainSubtypeLookup == DomainSubtypeLookup.None || field.DomainSubtypeLookup == DomainSubtypeLookup.NotDefined) return originalValue; ESRI.ArcGIS.Client.FeatureService.FeatureLayerInfo featureLayerInfo = featureLayer.LayerInfo; if (featureLayerInfo == null) return originalValue; IDictionary<object, FeatureType> featureTypes = featureLayerInfo.FeatureTypes; if ((featureTypes == null) && (field.DomainSubtypeLookup != DomainSubtypeLookup.FieldDomain)) return originalValue; if (attibutes == null) return originalValue; string domainCodedValue = string.Empty; object typeIdValue = null; switch (field.DomainSubtypeLookup) { case DomainSubtypeLookup.NotDefined: case DomainSubtypeLookup.None: break; case DomainSubtypeLookup.FieldDomain: Client.Field f = GetField(field.Name, featureLayerInfo.Fields); if (f == null) return originalValue; return GetDomainValue(originalValue, f.Domain as CodedValueDomain); case DomainSubtypeLookup.TypeIdField: if (!attibutes.ContainsKey(featureLayerInfo.TypeIdField)) return originalValue; typeIdValue = attibutes[featureLayerInfo.TypeIdField]; foreach (KeyValuePair<object, FeatureType> item in featureLayerInfo.FeatureTypes) { if (item.Key.Equals(typeIdValue) && item.Value != null) return item.Value.Name; } break; case DomainSubtypeLookup.FeatureTypeDomain: if (!attibutes.ContainsKey(featureLayerInfo.TypeIdField)) return originalValue; typeIdValue = attibutes[featureLayerInfo.TypeIdField]; foreach (KeyValuePair<object, FeatureType> fTypePair in featureLayerInfo.FeatureTypes) { if (fTypePair.Key.Equals(typeIdValue) && fTypePair.Value != null && fTypePair.Value.Domains != null) { foreach (KeyValuePair<string, Domain> pair in fTypePair.Value.Domains) { if (pair.Key.Equals(field.Name) && pair.Value is CodedValueDomain) { return GetDomainValue(originalValue, pair.Value as CodedValueDomain); } } } } break; default: break; } return originalValue; }
private void PerformPostLayerInitializationActions(Layer layer, bool initializationSuccess) { GraphicsLayer gLayer = layer as GraphicsLayer; if (gLayer != null) { GeometryType geometryType = Core.LayerExtensions.GetGeometryType(gLayer); Collection <FieldInfo> layerFields = Core.LayerExtensions.GetFields(gLayer); FeatureLayer featureLayer = layer as FeatureLayer; if (layerFields.Count == 0 && featureLayer != null && featureLayer.LayerInfo != null && featureLayer.LayerInfo.Fields != null) { foreach (ESRI.ArcGIS.Client.Field field in featureLayer.LayerInfo.Fields) { if (FieldHelper.IsFieldFilteredOut(field.Type)) { continue; } ESRI.ArcGIS.Mapping.Core.FieldInfo fieldInfo = ESRI.ArcGIS.Mapping.Core.FieldInfo.FieldInfoFromField(featureLayer, field); layerFields.Add(fieldInfo); } } if (gLayer.Graphics != null) { #region Get geometry type, start getting symbology if (geometryType == GeometryType.Unknown && gLayer.Graphics.Count > 0) { geometryType = LayerUtils.GetGeometryTypeFromGraphic(gLayer.Graphics.ElementAtOrDefault(0)); Core.LayerExtensions.SetGeometryType(gLayer, geometryType); if ((gLayer.Renderer == null || gLayer.Renderer is HiddenRenderer) && !Symbology.DefaultSymbols.ContainsKey(geometryType)) { if (geometryType == GeometryType.Unknown) { gLayer.SetValue(ESRI.ArcGIS.Client.Extensibility.LayerExtensions.ErrorMessageProperty, "Layer has unspecified geometry type."); } else { Core.LayerExtensions.SetRunLayerPostInitializationActions(gLayer, true); SymbolConfigProvider.GetDefaultLinearGradientBrush(gLayer, ColorRampType.ClassBreaks); } return; } } #endregion #region Project graphics if necessary if (graphicsRequireReprojection(gLayer.Graphics)) { GeometryServiceOperationHelper helper = new GeometryServiceOperationHelper( new ConfigurationStoreHelper().GetGeometryServiceUrl(ConfigurationStore) ); helper.ProjectGraphicsCompleted += (sender, args) => { GraphicsLayer targetLayer = args.UserState as GraphicsLayer; if (targetLayer != null) { targetLayer.Graphics.Clear(); foreach (Graphic graphic in args.Graphics) { targetLayer.Graphics.Add(graphic); } } }; helper.ProjectGraphics(gLayer.Graphics, Map.SpatialReference, gLayer); } #endregion #region Get field information if (layerFields.Count == 0) // fields not determined yet { determineFieldsFromGraphic(layerFields, gLayer.Graphics.ElementAtOrDefault(0)); } #endregion } #region Get renderer from feature layer's layer info, if necessary if (gLayer.Renderer == null || gLayer.Renderer is HiddenRenderer) { FeatureLayer lay = gLayer as FeatureLayer; if (lay != null && lay.LayerInfo != null && lay.LayerInfo.Renderer != null) { lay.Renderer = lay.LayerInfo.Renderer; } } #endregion #region Change PictureMarkerSymbol to ImageFillSymbol if (gLayer.Renderer != null && (geometryType == GeometryType.Point || geometryType == GeometryType.MultiPoint)) { SimpleRenderer sr = gLayer.Renderer as SimpleRenderer; ESRI.ArcGIS.Client.FeatureService.Symbols.PictureMarkerSymbol pms = null; if (sr != null) { pms = sr.Symbol as ESRI.ArcGIS.Client.FeatureService.Symbols.PictureMarkerSymbol; if (pms != null) { sr.Symbol = SymbolJsonHelper.ToImageFillSymbol(pms); } } else { ClassBreaksRenderer cbr = gLayer.Renderer as ClassBreaksRenderer; if (cbr != null) { foreach (ClassBreakInfo info in cbr.Classes) { pms = info.Symbol as ESRI.ArcGIS.Client.FeatureService.Symbols.PictureMarkerSymbol; if (pms != null) { info.Symbol = SymbolJsonHelper.ToImageFillSymbol(pms); } } } else { UniqueValueRenderer uvr = gLayer.Renderer as UniqueValueRenderer; if (uvr != null) { foreach (UniqueValueInfo info in uvr.Infos) { pms = info.Symbol as ESRI.ArcGIS.Client.FeatureService.Symbols.PictureMarkerSymbol; if (pms != null) { info.Symbol = SymbolJsonHelper.ToImageFillSymbol(pms); } } } } } } #endregion if (gLayer.Renderer == null || gLayer.Renderer is HiddenRenderer) { ApplyDefaultRenderer(gLayer, geometryType); } ApplyDefaultGradientBrush(gLayer); } else if ((layer is ArcGISDynamicMapServiceLayer || layer is ArcGISTiledMapServiceLayer) && !((bool)layer.GetValue(ESRI.ArcGIS.Client.WebMap.Document.IsBaseMapProperty))) { //get layer infos - used later for figuring out domain/subtypes, etc if ((layer.GetValue(ESRI.ArcGIS.Mapping.Core.LayerExtensions.LayerInfosProperty) as Collection <LayerInformation>) == null) { getLayerInfos(layer); } } bool doSelect = false; layer.SetValue(ESRI.ArcGIS.Client.Extensibility.LayerExtensions.InitialUpdateCompletedProperty, true); if (!initializationSuccess) { layer.SetValue(ESRI.ArcGIS.Client.Extensibility.LayerExtensions.InitialUpdateFailedProperty, true); } else { bool hasId = !string.IsNullOrEmpty(layer.ID) || !string.IsNullOrEmpty(layer.GetValue(ESRI.ArcGIS.Client.Extensibility.MapApplication.LayerNameProperty) as string); // Certain layers get added when the map draw mode is changed (An empty graphics layer is added) // We don't want to auto-select this layer if (hasId || !(layer is GraphicsLayer)) { doSelect = true; } } if (doSelect) { SetSelectedLayer(new LayerEventArgs() { Layer = layer }); } SubscribeToLayerInitializationEvents(layer, false); }
private void parseLayerDetailsFromResponse(string jsonResponse) { using (MemoryStream memoryStream = new MemoryStream(Encoding.Unicode.GetBytes(jsonResponse))) { DataContractJsonSerializer dataContractJsonSerializer = new DataContractJsonSerializer(typeof(LayerDetails)); LayerDetails layerDetails = dataContractJsonSerializer.ReadObject(memoryStream) as LayerDetails; if (layerDetails != null) { foreach (Field field in layerDetails.Fields) { FieldInfo fieldInfo = new FieldInfo() { DisplayName = field.Alias, Name = field.Name, FieldType = field.Type, VisibleOnMapTip = true }; _fields.Add(fieldInfo); if (field.Type == "esriFieldTypeInteger" || field.Type == "esriFieldTypeSmallInteger" || field.Type == "esriFieldTypeDouble") { NumericFields.Add(fieldInfo); } } switch (layerDetails.GeometryType) { case "esriGeometryPoint": GeometryType = GeometryType.Point; break; case "esriGeometryPolyline": GeometryType = GeometryType.Polyline; break; case "esriGeometryPolygon": GeometryType = GeometryType.Polygon; break; } } } // Now that all Metadata has been retrieved .. call base.initialize base.Initialize(); }
public static DomainSubtypeLookup GetDomainSubTypeLookup(Layer layer, FieldInfo field) { if (field.DomainSubtypeLookup != DomainSubtypeLookup.NotDefined) return field.DomainSubtypeLookup; ESRI.ArcGIS.Client.FeatureLayer featureLayer = layer as ESRI.ArcGIS.Client.FeatureLayer; if (featureLayer == null) { field.DomainSubtypeLookup = DomainSubtypeLookup.None; return field.DomainSubtypeLookup; } ESRI.ArcGIS.Client.FeatureService.FeatureLayerInfo featureLayerInfo = featureLayer.LayerInfo; if (featureLayerInfo != null) { Client.Field f = GetField(field.Name, featureLayerInfo.Fields); field.DomainSubtypeLookup = GetDomainSubTypeLookup(featureLayerInfo, f); } return field.DomainSubtypeLookup; }
internal void FieldInfo_AttributeDisplayUnChecked(FieldInfo fieldInfo) { if (fieldInfo == null) return; // For feature layers - remove the name of the field to the OutFields collection FeatureLayer featureLayer = Layer as FeatureLayer; if (featureLayer == null) return; bool visible = !isClearAllState; IEnumerable<FieldInfo> fields = featureLayer.GetValue(LayerExtensions.FieldsProperty) as IEnumerable<FieldInfo>; if (fields == null) return; if (featureLayer.OutFields.Count == 1 && featureLayer.OutFields[0] == "*") { reBuildOutFields(featureLayer, fields); } else { // in not also visible in map tip display and not used as = remove it if (!fieldInfo.VisibleOnMapTip && !isRendererField(fieldInfo)) { featureLayer.OutFields.Remove(fieldInfo.Name); } } CheckToggleButtonState(fields); }