Example #1
0
        //private void ApplyLayerTransperancyBasedOfGeometryType(GraphicsLayer glayer, GeometryType geometryType)
        //{
        //    if (glayer != null)
        //    {
        //        switch (geometryType)
        //        {
        //            case GeometryType.Point:
        //                glayer.Opacity = 1.0;
        //                break;
        //            case GeometryType.Polyline:
        //                glayer.Opacity = 1.0;
        //                break;
        //            case GeometryType.Polygon:
        //                glayer.Opacity = 0.5; // for polygons, we make it semi-transparent
        //                break;
        //        }
        //    }
        //}
        private void ApplyDefaultRenderer(GraphicsLayer gLayer, GeometryType geometryType)
        {
            if (gLayer == null && Symbology == null)
            {
                return;
            }

            SymbolDescription desc = null;

            if (geometryType == GeometryType.MultiPoint) // Treat MultiPoint as point for looking up default symbol
            {
                geometryType = GeometryType.Point;
            }
            if (Symbology.DefaultSymbols.TryGetValue(geometryType, out desc))
            {
                if (desc != null && desc.Symbol != null)
                {
                    Symbol symbol = desc.Symbol.CloneSymbol();
                    if (symbol != null)
                    {
                        gLayer.ChangeRenderer(symbol);
                    }
                }
            }
        }
 internal static void ChangeRenderer(this GraphicsLayer layer, Symbol symbol)
 {
     if (layer != null)
     {
         layer.ChangeRenderer(new SimpleRenderer()
         {
             Symbol = symbol
         });
     }
 }
Example #3
0
        private static void assignNewRendererToLayer(GraphicsLayer graphicsLayer, IRenderer newRenderer)
        {
            if (graphicsLayer == null)
            {
                return;
            }

            if (newRenderer == null)
            {
                newRenderer = graphicsLayer.CreateDefaultRenderer();
            }

            // Assign the renderer to the layer (potentially need to clear out FeatureSymbol)
            graphicsLayer.ChangeRenderer(newRenderer);
        }
        void defaultSymbolConfig_DefaultSymbolModified(object sender, SymbolSelectedEventArgs e)
        {
            GraphicsLayer graphicsLayer = Layer as GraphicsLayer;

            if (graphicsLayer == null)
            {
                return;
            }

            graphicsLayer.ChangeRenderer(e.Symbol);
            refreshLayer();
            if (SymbolConfigControl != null)
            {
                SymbolConfigControl.Symbol = e.Symbol;
            }
        }
        public static void ChangeSymbolOnDefaultRenderer(this GraphicsLayer layer, string symbolJson)
        {
            if (layer == null)
            {
                return;
            }

            if (!string.IsNullOrEmpty(symbolJson))
            {
                Symbol symbol = null;
                try
                {
                    symbol = SymbolJsonHelper.SymbolFromJson(symbolJson);
                }
                catch (Exception ex)
                {
                    Logger.Instance.LogError(ex);
                }
                if (symbol != null)
                {
                    layer.ChangeRenderer(symbol);
                }
            }
        }
        //private void ApplyLayerTransperancyBasedOfGeometryType(GraphicsLayer glayer, GeometryType geometryType)
        //{
        //    if (glayer != null)
        //    {
        //        switch (geometryType)
        //        {
        //            case GeometryType.Point:
        //                glayer.Opacity = 1.0;
        //                break;
        //            case GeometryType.Polyline:
        //                glayer.Opacity = 1.0;
        //                break;
        //            case GeometryType.Polygon:
        //                glayer.Opacity = 0.5; // for polygons, we make it semi-transparent
        //                break;
        //        }
        //    }
        //}
        private void ApplyDefaultRenderer(GraphicsLayer gLayer, GeometryType geometryType)
        {
            if (gLayer == null && Symbology == null)
                return;

            SymbolDescription desc = null;
            if (geometryType == GeometryType.MultiPoint) // Treat MultiPoint as point for looking up default symbol
                geometryType = GeometryType.Point;
            if (Symbology.DefaultSymbols.TryGetValue(geometryType, out desc))
            {                
                if (desc != null && desc.Symbol != null)
                {
                    Symbol symbol = desc.Symbol.CloneSymbol();
                    if (symbol != null)
                        gLayer.ChangeRenderer(symbol);
                }
            }
        }
        private static void assignNewRendererToLayer(GraphicsLayer graphicsLayer, IRenderer newRenderer)
        {
            if (graphicsLayer == null)
                return;

            if (newRenderer == null)
            {
                newRenderer = graphicsLayer.CreateDefaultRenderer();
            }

            // Assign the renderer to the layer (potentially need to clear out FeatureSymbol)
            graphicsLayer.ChangeRenderer(newRenderer);
        }
        void RendererType_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (_ignoreRendererTypeChangedEvent)
            {
                return;
            }

            GraphicsLayer graphicsLayer = Layer as GraphicsLayer;

            if (graphicsLayer == null)
            {
                return;
            }

            string rendererType = RendererType.SelectedItem.ToString();

            if (rendererType == LocalizableStrings.SingleSymbol)
            {
                rendererType = Constants.SimpleRenderer;
            }
            else if (rendererType == LocalizableStrings.ClassBreaks)
            {
                rendererType = Constants.ClassBreaksRenderer;
            }
            else if (rendererType == LocalizableStrings.UniqueValues)
            {
                rendererType = Constants.UniqueValueRenderer;
            }

            if (AttributeName != null)
            {
                AttributeName.Visibility = Constants.ClassBreaksRenderer.Equals(rendererType) || Constants.UniqueValueRenderer.Equals(rendererType)
                    ? Visibility.Visible : Visibility.Collapsed;
                buildAttributeNamesList(graphicsLayer, rendererType);
            }

            // 1. Find the attribute field to use as renderer
            FieldInfo attributeField = null;

            // 2. Check if the dropdown had a selected one
            if (AttributeName.SelectedItem != null)
            {
                attributeField = AttributeName.SelectedItem as FieldInfo;
            }

            // 3. If none selected, Use first one in list
            if (attributeField == null || string.IsNullOrEmpty(attributeField.Name))
            {
                // No attribute selected
                if (AttributeName.Items.Count > 0)
                {
                    _ignoreAttributeChangedEvent = true;
                    AttributeName.SelectedIndex  = 0; // Select the first one
                    _ignoreAttributeChangedEvent = false;
                    attributeField = AttributeName.Items[0] as FieldInfo;
                }
            }

            FieldInfo newAttributeField = graphicsLayer.ChangeRenderer(rendererType, attributeField);

            OnLayerRendererChanged(new LayerRendererChangedEventArgs()
            {
                RendererAttributeField = newAttributeField,
                RendererType           = rendererType,
            });
        }