protected void CopyProperties(ESRI.ArcGIS.Mapping.Core.Symbols.MarkerSymbol orig, ESRI.ArcGIS.Mapping.Core.Symbols.MarkerSymbol copy)
        {
            copy.DisplayName = orig.DisplayName;
            copy.Offset      = new Point(orig.Offset.X, orig.Offset.Y);
            copy.Color       = orig.Color != null?orig.Color.CloneBrush() : null;

            copy.ControlTemplate = orig.ControlTemplate;
            copy.OffsetX         = orig.OffsetX;
            copy.OffsetY         = orig.OffsetY;
            copy.OriginX         = orig.OriginX;
            copy.OriginY         = orig.OriginY;
            copy.Opacity         = orig.Opacity;
            copy.Size            = orig.Size;
        }
Exemple #2
0
        private static MarkerSymbol cloneMarkerSymbol(MarkerSymbol symbol)
        {
            if (symbol == null)
            {
                return(null);
            }

            ESRI.ArcGIS.Mapping.Core.Symbols.ImageFillSymbol imageFillSymbol = symbol as ESRI.ArcGIS.Mapping.Core.Symbols.ImageFillSymbol;
            if (imageFillSymbol != null)
            {
                ESRI.ArcGIS.Mapping.Core.Symbols.ImageFillSymbol ifs = new ESRI.ArcGIS.Mapping.Core.Symbols.ImageFillSymbol()
                {
                    Color           = CloneBrush(imageFillSymbol.Color),
                    ControlTemplate = imageFillSymbol.ControlTemplate,
                    OffsetX         = imageFillSymbol.OffsetX,
                    OffsetY         = imageFillSymbol.OffsetY,
                    OriginX         = imageFillSymbol.OriginX,
                    OriginY         = imageFillSymbol.OriginY,
                    Opacity         = imageFillSymbol.Opacity,
                    Size            = imageFillSymbol.Size,
                    ImageData       = imageFillSymbol.ImageData,
                    Source          = imageFillSymbol.Source,
                    Fill            = CloneBrush(imageFillSymbol.Fill),
                    CursorName      = imageFillSymbol.CursorName,
                };
                return(ifs);
            }

            ESRI.ArcGIS.Mapping.Core.Symbols.MarkerSymbol ms = symbol as ESRI.ArcGIS.Mapping.Core.Symbols.MarkerSymbol;
            if (ms != null)
            {
                ESRI.ArcGIS.Mapping.Core.Symbols.MarkerSymbol marSymb = new ESRI.ArcGIS.Mapping.Core.Symbols.MarkerSymbol()
                {
                    DisplayName     = ms.DisplayName,
                    Offset          = new Point(ms.Offset.X, ms.Offset.Y),
                    Color           = CloneBrush(ms.Color),
                    ControlTemplate = ms.ControlTemplate,
                    OffsetX         = ms.OffsetX,
                    OffsetY         = ms.OffsetY,
                    OriginX         = ms.OriginX,
                    OriginY         = ms.OriginY,
                    Opacity         = ms.Opacity,
                    Size            = ms.Size,
                };
                return(marSymb);
            }

            ESRI.ArcGIS.Client.Symbols.SimpleMarkerSymbol simpleMarkerSymbol = symbol as ESRI.ArcGIS.Client.Symbols.SimpleMarkerSymbol;
            if (simpleMarkerSymbol != null)
            {
                ESRI.ArcGIS.Client.Symbols.SimpleMarkerSymbol sms = new ESRI.ArcGIS.Client.Symbols.SimpleMarkerSymbol()
                {
                    Color           = CloneBrush(simpleMarkerSymbol.Color),
                    ControlTemplate = simpleMarkerSymbol.ControlTemplate,
                    Size            = simpleMarkerSymbol.Size,
                    // Simple marker symbol doesn't allow setting OffsetX, OffsetY
                };
                return(sms);
            }

            TextSymbol textSymbol = symbol as TextSymbol;

            if (textSymbol != null)
            {
                TextSymbol ts = new TextSymbol()
                {
                    ControlTemplate = textSymbol.ControlTemplate,
                    FontFamily      = textSymbol.FontFamily,
                    FontSize        = textSymbol.FontSize,
                    Foreground      = CloneBrush(textSymbol.Foreground),
                    OffsetX         = textSymbol.OffsetX,
                    OffsetY         = textSymbol.OffsetY,
                    Text            = textSymbol.Text,
                };
                return(ts);
            }

            PictureMarkerSymbol pictureMarkerSymbol = symbol as PictureMarkerSymbol;

            if (pictureMarkerSymbol != null)
            {
                PictureMarkerSymbol pictMs = new PictureMarkerSymbol()
                {
                    ControlTemplate = pictureMarkerSymbol.ControlTemplate,
                    Height          = pictureMarkerSymbol.Height,
                    OffsetX         = pictureMarkerSymbol.OffsetX,
                    OffsetY         = pictureMarkerSymbol.OffsetY,
                    Opacity         = pictureMarkerSymbol.Opacity,
                    Source          = pictureMarkerSymbol.Source,
                    Width           = pictureMarkerSymbol.Width,
                };
                return(pictMs);
            }

            MarkerSymbol markerS = new MarkerSymbol()
            {
                ControlTemplate = symbol.ControlTemplate,
                OffsetX         = symbol.OffsetX,
                OffsetY         = symbol.OffsetY,
            };

            return(markerS);
        }
Exemple #3
0
        private void WriteMarkerSymbol(MarkerSymbol markerSymbol)
        {
            ICustomSymbol symbol = markerSymbol as ICustomSymbol;
            if (symbol != null)
            {
                symbol.Serialize(writer, Namespaces);
                return;
            }

            string prefix = Constants.esriPrefix;
            if (markerSymbol is ESRI.ArcGIS.Mapping.Core.Symbols.MarkerSymbol)
                prefix = Constants.esriMappingPrefix;
            else if (markerSymbol is ESRI.ArcGIS.Client.FeatureService.Symbols.SimpleMarkerSymbol ||
                    markerSymbol is ESRI.ArcGIS.Client.FeatureService.Symbols.PictureMarkerSymbol)
                prefix = Constants.esriFSSymbolsPrefix;
            StartType(markerSymbol, prefix);

            if (markerSymbol is SimpleMarkerSymbol)
            {
                #region Size,Style,Color
                SimpleMarkerSymbol sms = markerSymbol as SimpleMarkerSymbol;
                WriteAttribute("Size", sms.Size);
                if (sms.Style != SimpleMarkerSymbol.SimpleMarkerStyle.Circle)
                {
                    WriteAttribute("Style", sms.Style.ToString());
                }
                if (sms.Color is SolidColorBrush && sms.Color.Opacity == 1)
                {
                    WriteAttribute("Color", (sms.Color as SolidColorBrush).Color);
                }
                else
                {                    
                    writer.WriteStartElement("SimpleMarkerSymbol.Color", Namespaces[Constants.esriPrefix]);
                    new BrushXamlWriter(writer, Namespaces).WriteBrush(sms.Color);
                    writer.WriteEndElement();
                }
                #endregion
            }
            else if (markerSymbol is ESRI.ArcGIS.Client.FeatureService.Symbols.PictureMarkerSymbol || markerSymbol is ESRI.ArcGIS.Client.FeatureService.Symbols.SimpleMarkerSymbol)
            {
                WriteJsonAttribute(markerSymbol as IJsonSerializable);
            }
            else
            {
                if (markerSymbol is ESRI.ArcGIS.Mapping.Core.Symbols.MarkerSymbol)
                {
                    #region Size,OriginX, OriginY, Opacity
                    ESRI.ArcGIS.Mapping.Core.Symbols.MarkerSymbol marker = markerSymbol as ESRI.ArcGIS.Mapping.Core.Symbols.MarkerSymbol;
                    if (marker != null)
                    {
                        WriteAttribute("Size", marker.Size);
                        WriteAttribute("OriginX", marker.OriginX);
                        WriteAttribute("OriginY", marker.OriginY);
                        if (marker.Opacity < 1)
                            WriteAttribute("Opacity", marker.Opacity);
                    }
                    #endregion
                }
                else if (!(markerSymbol is ESRI.ArcGIS.Client.FeatureService.Symbols.PictureMarkerSymbol || markerSymbol is ESRI.ArcGIS.Client.FeatureService.Symbols.SimpleMarkerSymbol))
                {
                    #region OffsetX, OffsetY
                    if (markerSymbol.OffsetX != 0)
                        WriteAttribute("OffsetX", markerSymbol.OffsetX);
                    if (markerSymbol.OffsetY != 0)
                        WriteAttribute("OffsetY", markerSymbol.OffsetY);
                    #endregion
                }

                PictureMarkerSymbol pms = markerSymbol as PictureMarkerSymbol;
                if (pms != null)
                {
                    #region PMS
                    WriteAttribute("Width", pms.Width);
                    WriteAttribute("Height", pms.Height);
                    if (pms.Opacity < 1)
                        WriteAttribute("Opacity", pms.Opacity);
                    string imageSource = SymbolExtensions.GetOriginalSource(pms);
                    if (!string.IsNullOrEmpty(imageSource))
                        writer.WriteElementString(Constants.esriMappingPrefix, "SymbolExtensions.OriginalSource", Constants.esriMappingNamespace, imageSource);
                    else
                    {
                        BitmapImage bmp = pms.Source as BitmapImage;
                        if (bmp != null && bmp.UriSource != null)
                        {
                            WriteAttribute("Source", bmp.UriSource.OriginalString);
                        }
                    }
                    #endregion
                }
                else if (markerSymbol is TextSymbol)
                {
                    #region TS
                    TextSymbol ts = markerSymbol as TextSymbol;
                    WriteAttribute("FontSize", ts.FontSize);
                    WriteAttribute("FontFamily", ts.FontFamily.Source);
                    WriteAttribute("Text", ts.Text);
                    if (ts.Foreground != null)
                    {
                        writer.WriteStartElement("TextSymbol.Foreground", Namespaces[Constants.esriPrefix]);
                        new BrushXamlWriter(writer, Namespaces).WriteBrush(ts.Foreground);
                        writer.WriteEndElement();
                    }
                    #endregion
                }
                else if (markerSymbol is ESRI.ArcGIS.Mapping.Core.Symbols.ImageFillSymbol)
                {
                    #region IFS: Source
                    ESRI.ArcGIS.Mapping.Core.Symbols.ImageFillSymbol fillSymbol = markerSymbol as ESRI.ArcGIS.Mapping.Core.Symbols.ImageFillSymbol;
                    if (!string.IsNullOrEmpty(fillSymbol.ImageData))
                        writer.WriteAttributeString("ImageData", fillSymbol.ImageData); 
                    else if (!string.IsNullOrEmpty(fillSymbol.Source))
                        writer.WriteAttributeString("Source", fillSymbol.Source);
                    #endregion
                }
                else if (markerSymbol is ESRI.ArcGIS.Mapping.Core.Symbols.MarkerSymbol)
                {
                    #region Color
                    ESRI.ArcGIS.Mapping.Core.Symbols.MarkerSymbol marker = markerSymbol as ESRI.ArcGIS.Mapping.Core.Symbols.MarkerSymbol;
                    if (marker != null)
                    {
                        if (marker.Color != null)
                        {
                            writer.WriteStartElement("MarkerSymbol.Color", Namespaces[Constants.esriMappingPrefix]);
                            new BrushXamlWriter(writer, Namespaces).WriteBrush(marker.Color);
                            writer.WriteEndElement();
                        }
                    }
                    #endregion
                }
                #region Feature Service Symbols - Not used
                //else if (markerSymbol is ESRI.ArcGIS.Client.FeatureService.Symbols.PictureMarkerSymbol)
                //{
                //    #region pms
                //    ESRI.ArcGIS.Client.FeatureService.Symbols.PictureMarkerSymbol pmsfs = markerSymbol as ESRI.ArcGIS.Client.FeatureService.Symbols.PictureMarkerSymbol;
                //    WriteAttribute("Width", pmsfs.Width);
                //    WriteAttribute("Height", pmsfs.Height);
                //    WriteAttribute("Opacity", pmsfs.Opacity);
                //    WriteFeatureServiceMarkerSymbolProperties("PictureMarkerSymbol", pmsfs.Angle, pmsfs.XOffsetFromCenter,
                //         pmsfs.YOffsetFromCenter, pmsfs.Color, pmsfs.SelectionColor, pmsfs.RenderTransformPoint);
                //    #region Set ContentType,Url and ImageData to set Source
                //    SetImageSourceRelatedProperties(pmsfs, pmsfs.ToJson());
                //    #endregion
                //    #endregion
                //}
                //else if (markerSymbol is ESRI.ArcGIS.Client.FeatureService.Symbols.SimpleMarkerSymbol)
                //{
                //    #region smsfs
                //    ESRI.ArcGIS.Client.FeatureService.Symbols.SimpleMarkerSymbol smsfs = markerSymbol as ESRI.ArcGIS.Client.FeatureService.Symbols.SimpleMarkerSymbol;
                //    WriteAttribute("OutlineThickness", smsfs.OutlineThickness);
                //    WriteAttribute("Size", smsfs.Size);
                //    WriteAttribute("Style", smsfs.Style.ToString());
                //    WriteAttribute("OutlineStyle", smsfs.OutlineStyle.ToString());
                //    WriteFeatureServiceMarkerSymbolProperties("SimpleMarkerSymbol", smsfs.Angle, smsfs.XOffsetFromCenter,
                //       smsfs.YOffsetFromCenter, smsfs.Color, smsfs.SelectionColor, smsfs.RenderTransformPoint);
                //    if (smsfs.OutlineColor != null)
                //    {
                //        writer.WriteStartElement("SimpleMarkerSymbol.OutlineColor", Namespaces[Constants.esriFSSymbolsPrefix]);
                //        new BrushXamlWriter(writer, Namespaces).WriteBrush(smsfs.OutlineColor);
                //        writer.WriteEndElement();
                //    }
                //    #endregion
                //}
                #endregion
                else
                    throw new NotSupportedException(markerSymbol.GetType().FullName);
            }
            writer.WriteEndElement();
        }
Exemple #4
0
        private static void applyColorToSymbol(Symbol symbol, Color color)
        {
            if (symbol == null)
            {
                return;
            }

            FillSymbol fillSymbol = symbol as FillSymbol;

            if (fillSymbol != null)
            {
                byte currentAlpha = (byte)255;
                if (fillSymbol.Fill != null)
                {
                    currentAlpha = (byte)(255 * fillSymbol.Fill.Opacity); // Preserve current opacity of symbol color
                }
                string colorHex = Color.FromArgb(currentAlpha, color.R, color.G, color.B).ToString();
                Color  newColor = ColorPickerUtils.FromHex(colorHex);
                if (fillSymbol is ESRI.ArcGIS.Client.FeatureService.Symbols.SimpleFillSymbol)
                {
                    (fillSymbol as ESRI.ArcGIS.Client.FeatureService.Symbols.SimpleFillSymbol).Color = newColor;
                }
                else
                {
                    fillSymbol.Fill = new SolidColorBrush(newColor);
                }
            }
            else
            {
                LineSymbol lineSymbol = symbol as LineSymbol;
                if (lineSymbol != null)
                {
                    byte currentAlpha = (byte)255;
                    if (lineSymbol.Color != null)
                    {
                        currentAlpha = (byte)(255 * lineSymbol.Color.Opacity);// Preserve current opacity of symbol color
                    }
                    string colorHex = Color.FromArgb(currentAlpha, color.R, color.G, color.B).ToString();
                    Color  newColor = ColorPickerUtils.FromHex(colorHex);
                    lineSymbol.Color = new SolidColorBrush(newColor);
                }
                else
                {
                    ESRI.ArcGIS.Mapping.Core.Symbols.MarkerSymbol markerSymbol = symbol as ESRI.ArcGIS.Mapping.Core.Symbols.MarkerSymbol;
                    if (markerSymbol != null)
                    {
                        byte currentAlpha = (byte)255;
                        if (markerSymbol.Color != null)
                        {
                            currentAlpha = (byte)(255 * markerSymbol.Color.Opacity);// Preserve current opacity of symbol color
                        }
                        string colorHex = Color.FromArgb(currentAlpha, color.R, color.G, color.B).ToString();
                        Color  newColor = ColorPickerUtils.FromHex(colorHex);
                        markerSymbol.Color = new SolidColorBrush(newColor);
                    }
                    else
                    {
                        ESRI.ArcGIS.Client.Symbols.SimpleMarkerSymbol simpleMarkerSymbol = symbol as ESRI.ArcGIS.Client.Symbols.SimpleMarkerSymbol;
                        if (simpleMarkerSymbol != null)
                        {
                            byte currentAlpha = (byte)255;
                            if (simpleMarkerSymbol.Color != null)
                            {
                                currentAlpha = (byte)(255 * simpleMarkerSymbol.Color.Opacity);// Preserve current opacity of symbol color
                            }
                            string colorHex = Color.FromArgb(currentAlpha, color.R, color.G, color.B).ToString();
                            Color  newColor = ColorPickerUtils.FromHex(colorHex);
                            simpleMarkerSymbol.Color = new SolidColorBrush(newColor);
                        }
                        else
                        {
                            ESRI.ArcGIS.Client.FeatureService.Symbols.SimpleMarkerSymbol sms = symbol as ESRI.ArcGIS.Client.FeatureService.Symbols.SimpleMarkerSymbol;
                            if (sms != null)
                            {
                                byte currentAlpha = (byte)255;
                                if (sms.Color is SolidColorBrush)
                                {
                                    currentAlpha = (sms.Color as SolidColorBrush).Color.A;
                                }
                                else if (sms.Color != null)
                                {
                                    currentAlpha = (byte)(255 * sms.Color.Opacity);// Preserve current opacity of symbol color
                                }
                                string colorHex = Color.FromArgb(currentAlpha, color.R, color.G, color.B).ToString();
                                Color  newColor = ColorPickerUtils.FromHex(colorHex);
                                sms.Color = new SolidColorBrush(newColor);
                                if (sms.OutlineColor != null)
                                {
                                    sms.OutlineColor = new SolidColorBrush(newColor);
                                }
                            }
                        }
                    }
                }
            }
        }
        private static MarkerSymbol cloneMarkerSymbol(MarkerSymbol symbol)
        {
            if (symbol == null)
                return null;

            ESRI.ArcGIS.Mapping.Core.Symbols.ImageFillSymbol imageFillSymbol = symbol as ESRI.ArcGIS.Mapping.Core.Symbols.ImageFillSymbol;
            if (imageFillSymbol != null)
            {
                ESRI.ArcGIS.Mapping.Core.Symbols.ImageFillSymbol ifs = new ESRI.ArcGIS.Mapping.Core.Symbols.ImageFillSymbol()
                {
                    Color = CloneBrush(imageFillSymbol.Color),
                    ControlTemplate = imageFillSymbol.ControlTemplate,
                    OffsetX = imageFillSymbol.OffsetX,
                    OffsetY = imageFillSymbol.OffsetY,
                    OriginX = imageFillSymbol.OriginX,
                    OriginY = imageFillSymbol.OriginY,
                    Opacity = imageFillSymbol.Opacity,
                    Size = imageFillSymbol.Size,
                    ImageData = imageFillSymbol.ImageData,
                    Source = imageFillSymbol.Source,
                    Fill = CloneBrush(imageFillSymbol.Fill),
                    CursorName = imageFillSymbol.CursorName,
                };
                return ifs;
            }

            ESRI.ArcGIS.Mapping.Core.Symbols.MarkerSymbol ms = symbol as ESRI.ArcGIS.Mapping.Core.Symbols.MarkerSymbol;
            if (ms != null)
            {
                ESRI.ArcGIS.Mapping.Core.Symbols.MarkerSymbol marSymb = new ESRI.ArcGIS.Mapping.Core.Symbols.MarkerSymbol()
                {
                    DisplayName = ms.DisplayName,
                    Offset = new Point(ms.Offset.X, ms.Offset.Y),
                    Color = CloneBrush(ms.Color),
                    ControlTemplate = ms.ControlTemplate,
                    OffsetX = ms.OffsetX,
                    OffsetY = ms.OffsetY,
                    OriginX = ms.OriginX,
                    OriginY = ms.OriginY,
                    Opacity = ms.Opacity,
                    Size = ms.Size,
                };
                return marSymb;
            }

            ESRI.ArcGIS.Client.Symbols.SimpleMarkerSymbol simpleMarkerSymbol = symbol as ESRI.ArcGIS.Client.Symbols.SimpleMarkerSymbol;
            if (simpleMarkerSymbol != null)
            {
                ESRI.ArcGIS.Client.Symbols.SimpleMarkerSymbol sms = new ESRI.ArcGIS.Client.Symbols.SimpleMarkerSymbol()
                {
                    Color = CloneBrush(simpleMarkerSymbol.Color),
                    ControlTemplate = simpleMarkerSymbol.ControlTemplate,
                    Size = simpleMarkerSymbol.Size,
                    // Simple marker symbol doesn't allow setting OffsetX, OffsetY
                };
                return sms;
            }

            TextSymbol textSymbol = symbol as TextSymbol;
            if (textSymbol != null)
            {
                TextSymbol ts = new TextSymbol()
                {
                    ControlTemplate = textSymbol.ControlTemplate,
                    FontFamily = textSymbol.FontFamily,
                    FontSize = textSymbol.FontSize,
                    Foreground = CloneBrush(textSymbol.Foreground),
                    OffsetX = textSymbol.OffsetX,
                    OffsetY = textSymbol.OffsetY,
                    Text = textSymbol.Text,
                };
                return ts;
            }

            PictureMarkerSymbol pictureMarkerSymbol = symbol as PictureMarkerSymbol;
            if (pictureMarkerSymbol != null)
            {
                PictureMarkerSymbol pictMs = new PictureMarkerSymbol()
                {
                    ControlTemplate = pictureMarkerSymbol.ControlTemplate,
                    Height = pictureMarkerSymbol.Height,
                    OffsetX = pictureMarkerSymbol.OffsetX,
                    OffsetY = pictureMarkerSymbol.OffsetY,
                    Opacity = pictureMarkerSymbol.Opacity,
                    Source = pictureMarkerSymbol.Source,
                    Width = pictureMarkerSymbol.Width,
                };
                return pictMs;
            }

            MarkerSymbol markerS = new MarkerSymbol()
            {
                ControlTemplate = symbol.ControlTemplate,
                OffsetX = symbol.OffsetX,
                OffsetY = symbol.OffsetY,
            };
            return markerS;
        }