private static async Task <Document> GetDocument(string code, bool withAnnotations)
{
var ws = new AdhocWorkspace();
var emptyProject = ws.AddProject(
ProjectInfo.Create(
ProjectId.CreateNewId(),
VersionStamp.Default,
"test",
"test.dll",
LanguageNames.CSharp,
metadataReferences: new[] { TestMetadata.Net451.mscorlib }));
var doc = emptyProject.AddDocument("test.cs", code);
if (withAnnotations)
{
var root = await doc.GetSyntaxRootAsync();
var model = await doc.GetSemanticModelAsync();
root = root.ReplaceNodes(root.DescendantNodesAndSelf().OfType <TypeSyntax>(),
(o, c) =>
{
var symbol = model.GetSymbolInfo(o).Symbol;
return(symbol != null
? c.WithAdditionalAnnotations(SymbolAnnotation.Create(symbol), Simplifier.Annotation)
: c);
});
doc = doc.WithSyntaxRoot(root);
}
return(doc);
}
public void AddCast(
ISyntaxFacts syntaxFacts,
SemanticModel semanticModel,
SyntaxEditor editor,
TForEachStatementSyntax forEachStatement,
CancellationToken cancellationToken)
{
var expression = syntaxFacts.GetExpressionOfForeachStatement(forEachStatement);
var loopOperation = (IForEachLoopOperation)semanticModel.GetRequiredOperation(forEachStatement, cancellationToken);
var variableDeclarator = (IVariableDeclaratorOperation)loopOperation.LoopControlVariable;
var enumerableType = semanticModel.Compilation.GetBestTypeByMetadataName(typeof(Enumerable).FullName !);
// These were already verified to be non-null in the analyzer.
Contract.ThrowIfNull(variableDeclarator.Symbol.Type);
Contract.ThrowIfNull(enumerableType);
var elementType = GetForEachElementType(semanticModel, forEachStatement);
var conversion = semanticModel.Compilation.ClassifyCommonConversion(elementType, variableDeclarator.Symbol.Type);
var rewritten = GetRewrittenCollection(editor.Generator, expression, variableDeclarator.Symbol.Type, conversion);
// Add an annotation for System.Linq.Enumerable so that we add a `using System.Linq;` if not present.
rewritten = rewritten.WithAdditionalAnnotations(
Simplifier.Annotation, Simplifier.AddImportsAnnotation, SymbolAnnotation.Create(enumerableType));
editor.ReplaceNode(expression, rewritten);
}
private void TestSymbolSerialization(Document document, string symbolName)
{
var model = document.GetSemanticModelAsync().Result;
var name = CS.SyntaxFactory.ParseName(symbolName);
var symbol = model.GetSpeculativeSymbolInfo(0, name, SpeculativeBindingOption.BindAsExpression).Symbol;
var root = (CS.Syntax.CompilationUnitSyntax)model.SyntaxTree.GetRoot();
var annotation = SymbolAnnotation.Create(symbol);
var rootWithAnnotation = root.WithAdditionalAnnotations(annotation);
Assert.Equal(true, rootWithAnnotation.ContainsAnnotations);
Assert.Equal(true, rootWithAnnotation.HasAnnotation(annotation));
var stream = new MemoryStream();
rootWithAnnotation.SerializeTo(stream);
stream.Position = 0;
var droot = CS.CSharpSyntaxNode.DeserializeFrom(stream);
Assert.Equal(true, droot.ContainsAnnotations);
Assert.Equal(true, droot.HasAnnotation(annotation));
var dannotation = droot.GetAnnotations(SymbolAnnotation.Kind).SingleOrDefault();
Assert.NotNull(dannotation);
Assert.NotSame(annotation, dannotation);
Assert.Equal(annotation, dannotation);
var id = SymbolAnnotation.GetSymbol(annotation, model.Compilation);
var did = SymbolAnnotation.GetSymbol(dannotation, model.Compilation);
Assert.Equal(true, id.Equals(did));
}
public MGLAnnotationView MapView_ViewForAnnotation(MGLMapView mapView, IMGLAnnotation annotation)
{
var fannotation = Element.Annotations.FirstOrDefault(x => x.NativeHandle == annotation.Handle);
switch (fannotation)
{
case SymbolAnnotation symbol:
if (symbol.IconImage?.Source != null)
{
return null;
}
break;
}
var annotationView = mapView.DequeueReusableAnnotationViewWithIdentifier("draggablePoint");
if (annotationView != null) return annotationView;
var view = new DraggableAnnotationView(reuseIdentifier: "draggablePoint", size: 24);
view.DragFinished += (sender, e) =>
{
var point = new SymbolAnnotation();
point.NativeHandle = annotation.Handle;
point.Coordinates = annotation.Coordinate.ToLatLng();
Element.DragFinishedCommand?.Execute(point);
};
view.AddGestureRecognizer(new UITapGestureRecognizer(tap =>
{
Element.DidTapOnMarkerCommand?.Execute(fannotation.Id);
}));
//mapView.SelectAnnotation(annotation, true, null);
return view;
}
public MGLAnnotationView MapView_ViewForAnnotation(MGLMapView mapView, IMGLAnnotation annotation)
{
var fannotation = Element.Annotations.FirstOrDefault(x => x.NativeHandle == annotation.Handle);
switch (fannotation)
{
case SymbolAnnotation symbol:
if (symbol.IconImage?.Source != null)
{
return(null);
}
break;
}
var annotationView = mapView.DequeueReusableAnnotationViewWithIdentifier("draggablePoint");
if (annotationView != null)
{
return(annotationView);
}
var view = new DraggableAnnotationView(reuseIdentifier: "draggablePoint", size: 24);
view.DragFinished += (sender, e) =>
{
var point = new SymbolAnnotation();
point.NativeHandle = annotation.Handle;
point.Coordinates = annotation.Coordinate.ToLatLng();
Element.DragFinishedCommand?.Execute(point);
};
return(view);
}
private TTypeSyntax AddInformationTo <TTypeSyntax>(TTypeSyntax syntax, ISymbol symbol)
where TTypeSyntax : TypeSyntax
{
syntax = syntax.WithPrependedLeadingTrivia(SyntaxFactory.ElasticMarker).WithAppendedTrailingTrivia(SyntaxFactory.ElasticMarker);
syntax = syntax.WithAdditionalAnnotations(SymbolAnnotation.Create(symbol));
return(syntax);
}
private void HandleStyleLoaded(MapStyle obj)
{
var symbol = new SymbolAnnotation {
Coordinates = new LatLng(60.169091, 24.939876),
IconImage = MAKI_ICON_HARBOR,
IconSize = 2.0f,
IsDraggable = true,
Id = Guid.NewGuid().ToString()
};
map.Annotations = new[] { symbol };
}
void HandleStyleLoaded(MapStyle obj)
{
IconImageSource iconImageSource = ImageSource.FromFile("red_marker.png");
/*map.Functions.AddStyleImage(iconImageSource);
*
* var symbolLayerIconFeatureList = new List<Feature>();
* symbolLayerIconFeatureList.Add(
* new Feature(new GeoJSON.Net.Geometry.Point(
* new GeoJSON.Net.Geometry.Position(-33.213144, -57.225365))));
* symbolLayerIconFeatureList.Add(
* new Feature(new GeoJSON.Net.Geometry.Point(
* new GeoJSON.Net.Geometry.Position(-33.981818, -54.14164))));
* symbolLayerIconFeatureList.Add(
* new Feature(new GeoJSON.Net.Geometry.Point(
* new GeoJSON.Net.Geometry.Position(-30.583266, -56.990533))));
*
* var featureCollection = new FeatureCollection(symbolLayerIconFeatureList);
*
* var source = new GeoJsonSource
* {
* Id = "feature.memory.src",
* Data = featureCollection
* };
* map.Functions.AddSource(source);
*
* var symbolLayer = new SymbolLayer("feature.symbol.layer", source.Id)
* {
* IconAllowOverlap = Expression.Literal(true),
* IconImage = Expression.Literal(iconImageSource.Id),
* IconOffset = Expression.Literal(new[] { 0.0, -9.0 })
* };
* map.Functions.AddLayer(symbolLayer);*/
var symbol = new SymbolAnnotation
{
Coordinates = new LatLng(60.169091, 24.939876),
IconImage = iconImageSource,
IconSize = 2.0f,
IsDraggable = true,
Id = Guid.NewGuid().ToString()
};
map.Annotations = new[] { symbol };
}
protected async Task <IDictionary <SyntaxNode, ISet <INamedTypeSymbol> > > GetAllReferencedDefinitionsAsync(
Compilation compilation,
IEnumerable <ISymbol> members,
CancellationToken cancellationToken)
{
var namespaceScopeToReferencedDefinitions = new Dictionary <SyntaxNode, ISet <INamedTypeSymbol> >();
var root = await Document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
Func <SyntaxNode, ISet <INamedTypeSymbol> > createSet = _ => new HashSet <INamedTypeSymbol>();
var annotatedNodes = root.GetAnnotatedNodesAndTokens(SymbolAnnotation.Kind);
foreach (var annotatedNode in annotatedNodes)
{
cancellationToken.ThrowIfCancellationRequested();
if (annotatedNode.GetAnnotations(DoNotAddImportsAnnotation.Kind).Any())
{
continue;
}
SyntaxNode namespaceScope = null;
var annotations = annotatedNode.GetAnnotations(SymbolAnnotation.Kind);
foreach (var annotation in annotations)
{
cancellationToken.ThrowIfCancellationRequested();
foreach (var namedType in SymbolAnnotation.GetSymbols(annotation, compilation).OfType <INamedTypeSymbol>())
{
cancellationToken.ThrowIfCancellationRequested();
if (!IsBuiltIn(namedType))
{
namespaceScope = namespaceScope ?? this.GetInnermostNamespaceScope(annotatedNode);
var referencedDefinitions = namespaceScopeToReferencedDefinitions.GetOrAdd(
namespaceScope, createSet);
referencedDefinitions.Add(namedType);
}
}
}
}
return(namespaceScopeToReferencedDefinitions);
}
private void AddMapMarker(object sender, EventArgs args)
{
try
{
var symbolAnnotation = new SymbolAnnotation
{
Coordinates = new LatLng(location.Latitude, location.Longitude),
IconImage = (ImageSource)MARKER_ICON,
IconSize = 1.0f,
IsDraggable = false,
Id = Guid.NewGuid().ToString()
};
symbolAnnotations.Add(symbolAnnotation);
Refresh();
}
catch (Exception ex)
{
}
}
private (ImmutableArray <SyntaxNode> imports, IEnumerable <INamespaceSymbol> namespaceSymbols, SyntaxNode?context) GetImportDirectivesFromAnnotatedNodes(
IEnumerable <SyntaxNode> syntaxNodes,
SyntaxNode root,
SemanticModel model,
IAddImportsService addImportsService,
SyntaxGenerator generator,
CancellationToken cancellationToken)
{
(SyntaxNode first, SyntaxNode last)? nodes = null;
var importsToAdd = ArrayBuilder <SyntaxNode> .GetInstance();
var annotatedNodes = syntaxNodes.Where(x => x.HasAnnotations(SymbolAnnotation.Kind));
var addedSymbols = new HashSet <INamespaceSymbol>();
foreach (var annotatedNode in annotatedNodes)
{
cancellationToken.ThrowIfCancellationRequested();
if (annotatedNode.GetAnnotations(DoNotAddImportsAnnotation.Kind).Any())
{
continue;
}
var annotations = annotatedNode.GetAnnotations(SymbolAnnotation.Kind);
foreach (var annotation in annotations)
{
cancellationToken.ThrowIfCancellationRequested();
foreach (var namedType in SymbolAnnotation.GetSymbols(annotation, model.Compilation).OfType <INamedTypeSymbol>())
{
cancellationToken.ThrowIfCancellationRequested();
if (namedType.OriginalDefinition.IsSpecialType() || namedType.IsNullable() || namedType.IsTupleType)
{
continue;
}
var namespaceSymbol = namedType.ContainingNamespace;
if (namespaceSymbol is null || namespaceSymbol.IsGlobalNamespace)
{
continue;
}
nodes = (first : nodes?.first ?? annotatedNode, last : annotatedNode);
if (addedSymbols.Contains(namespaceSymbol))
{
continue;
}
var namespaceSyntax = GenerateNamespaceImportDeclaration(namespaceSymbol, generator);
if (addImportsService.HasExistingImport(model.Compilation, root, annotatedNode, namespaceSyntax, generator))
{
continue;
}
if (IsInsideNamespace(annotatedNode, namespaceSymbol, model, cancellationToken))
{
continue;
}
addedSymbols.Add(namespaceSymbol);
importsToAdd.Add(namespaceSyntax);
}
}
}
// we don't add simplifier annotations here,
// since whatever added the symbol annotation probably also added simplifier annotations,
// and if not they probably didn't for a reason
return(importsToAdd.ToImmutableAndFree(), addedSymbols, nodes is var(first, last) ? first.GetCommonRoot(last) : null);
}
private async Task <Document> AddImportDirectivesFromSymbolAnnotationsAsync(
Document document,
IEnumerable <SyntaxNode> syntaxNodes,
IAddImportsService addImportsService,
SyntaxGenerator generator,
bool placeSystemNamespaceFirst,
bool allowInHiddenRegions,
CancellationToken cancellationToken)
{
using var _ = PooledDictionary <INamespaceSymbol, SyntaxNode> .GetInstance(out var importToSyntax);
var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
var model = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
SyntaxNode?first = null, last = null;
var annotatedNodes = syntaxNodes.Where(x => x.HasAnnotations(SymbolAnnotation.Kind));
foreach (var annotatedNode in annotatedNodes)
{
cancellationToken.ThrowIfCancellationRequested();
if (annotatedNode.GetAnnotations(DoNotAddImportsAnnotation.Kind).Any())
{
continue;
}
var annotations = annotatedNode.GetAnnotations(SymbolAnnotation.Kind);
foreach (var annotation in annotations)
{
cancellationToken.ThrowIfCancellationRequested();
foreach (var namedType in SymbolAnnotation.GetSymbols(annotation, model.Compilation).OfType <INamedTypeSymbol>())
{
cancellationToken.ThrowIfCancellationRequested();
if (namedType.OriginalDefinition.IsSpecialType() || namedType.IsNullable() || namedType.IsTupleType)
{
continue;
}
var namespaceSymbol = namedType.ContainingNamespace;
if (namespaceSymbol is null || namespaceSymbol.IsGlobalNamespace)
{
continue;
}
first ??= annotatedNode;
last = annotatedNode;
if (importToSyntax.ContainsKey(namespaceSymbol))
{
continue;
}
var namespaceSyntax = GenerateNamespaceImportDeclaration(namespaceSymbol, generator);
if (addImportsService.HasExistingImport(model.Compilation, root, annotatedNode, namespaceSyntax, generator))
{
continue;
}
if (IsInsideNamespace(annotatedNode, namespaceSymbol, model, cancellationToken))
{
continue;
}
importToSyntax[namespaceSymbol] = namespaceSyntax;
}
}
}
if (first == null || last == null || importToSyntax.Count == 0)
{
return(document);
}
var context = first.GetCommonRoot(last);
// Find the namespace/compilation-unit we'll be adding all these imports to.
var importContainer = addImportsService.GetImportContainer(root, context, importToSyntax.First().Value);
// Now remove any imports we think can cause conflicts in that container.
var safeImportsToAdd = GetSafeToAddImports(importToSyntax.Keys.ToImmutableArray(), importContainer, model, cancellationToken);
var importsToAdd = importToSyntax.Where(kvp => safeImportsToAdd.Contains(kvp.Key)).Select(kvp => kvp.Value).ToImmutableArray();
if (importsToAdd.Length == 0)
{
return(document);
}
root = addImportsService.AddImports(
model.Compilation, root, context, importsToAdd, generator,
placeSystemNamespaceFirst, allowInHiddenRegions, cancellationToken);
return(document.WithSyntaxRoot(root));
}
public static SymbolOptions ToSymbolOptions(this SymbolAnnotation symbolAnnotation)
{
var symbolOptions = new SymbolOptions()
.WithLatLng(symbolAnnotation.Coordinates.ToLatLng());
if (!string.IsNullOrWhiteSpace(symbolAnnotation.IconAnchor))
{
symbolOptions.WithIconImage(symbolAnnotation.IconAnchor);
}
if (symbolAnnotation.IconColor.HasValue)
{
symbolOptions.WithIconColor(symbolAnnotation.IconColor.Value.ToRGBAString());
}
if (symbolAnnotation.IconHaloBlur.HasValue)
{
symbolOptions.WithIconHaloBlur(new Float(symbolAnnotation.IconHaloBlur.Value));
}
if (symbolAnnotation.IconHaloColor.HasValue)
{
symbolOptions.WithIconHaloColor(symbolAnnotation.IconHaloColor.Value.ToRGBAString());
}
if (symbolAnnotation.IconHaloWidth.HasValue)
{
symbolOptions.WithIconHaloWidth(new Float(symbolAnnotation.IconHaloWidth.Value));
}
if (symbolAnnotation.IconImage != null)
{
symbolOptions.WithIconImage(symbolAnnotation.IconImage.Id);
}
if (symbolAnnotation.IconOffset?.Length > 0)
{
symbolOptions.WithIconOffset(symbolAnnotation.IconOffset.Select(x => new Float(x)).ToArray());
}
if (symbolAnnotation.IconOpacity.HasValue)
{
symbolOptions.WithIconOpacity(new Float(symbolAnnotation.IconOpacity.Value));
}
if (symbolAnnotation.IconRotate.HasValue)
{
symbolOptions.WithIconRotate(new Float(symbolAnnotation.IconRotate.Value));
}
if (symbolAnnotation.IconSize.HasValue)
{
symbolOptions.WithIconSize(new Float(symbolAnnotation.IconSize.Value));
}
if (symbolAnnotation.IsDraggable.HasValue)
{
symbolOptions.WithDraggable(symbolAnnotation.IsDraggable.Value);
}
if (symbolAnnotation.SymbolSortKey.HasValue)
{
symbolOptions.WithSymbolSortKey(new Float(symbolAnnotation.SymbolSortKey.Value));
}
if (!string.IsNullOrWhiteSpace(symbolAnnotation.TextAnchor))
{
symbolOptions.WithTextAnchor(symbolAnnotation.TextAnchor);
}
if (symbolAnnotation.TextColor.HasValue)
{
symbolOptions.WithTextColor(symbolAnnotation.TextColor.Value.ToRGBAString());
}
if (!string.IsNullOrWhiteSpace(symbolAnnotation.TextField))
{
symbolOptions.WithTextField(symbolAnnotation.TextField);
}
if (symbolAnnotation.TextFont?.Length > 0)
{
symbolOptions.WithTextFont(symbolAnnotation.TextFont);
}
if (symbolAnnotation.TextHaloBlur.HasValue)
{
symbolOptions.WithTextHaloBlur(new Float(symbolAnnotation.TextHaloBlur.Value));
}
if (symbolAnnotation.TextHaloColor.HasValue)
{
symbolOptions.WithTextHaloColor(symbolAnnotation.TextHaloColor.Value.ToRGBAString());
}
if (symbolAnnotation.TextHaloWidth.HasValue)
{
symbolOptions.WithTextHaloWidth(new Float(symbolAnnotation.TextHaloWidth.Value));
}
if (!string.IsNullOrWhiteSpace(symbolAnnotation.TextJustify))
{
symbolOptions.WithTextJustify(symbolAnnotation.TextJustify);
}
if (symbolAnnotation.TextLetterSpacing.HasValue)
{
symbolOptions.WithTextLetterSpacing(new Float(symbolAnnotation.TextLetterSpacing.Value));
}
if (symbolAnnotation.TextMaxWidth.HasValue)
{
symbolOptions.WithTextMaxWidth(new Float(symbolAnnotation.TextMaxWidth.Value));
}
if (symbolAnnotation.TextOffset?.Length > 0)
{
symbolOptions.WithTextOffset(symbolAnnotation.TextOffset.Select(x => new Float(x)).ToArray());
}
if (symbolAnnotation.TextOpacity.HasValue)
{
symbolOptions.WithTextOpacity(new Float(symbolAnnotation.TextOpacity.Value));
}
if (symbolAnnotation.TextRadialOffset.HasValue)
{
symbolOptions.WithTextRadialOffset(new Float(symbolAnnotation.TextRadialOffset.Value));
}
if (symbolAnnotation.TextRotate.HasValue)
{
symbolOptions.WithTextRotate(new Float(symbolAnnotation.TextRotate.Value));
}
if (symbolAnnotation.TextSize.HasValue)
{
symbolOptions.WithTextSize(new Float(symbolAnnotation.TextSize.Value));
}
if (!string.IsNullOrWhiteSpace(symbolAnnotation.TextTransform))
{
symbolOptions.WithTextTransform(symbolAnnotation.TextTransform);
}
return(symbolOptions);
}
public static void Update(this Symbol symbol, SymbolAnnotation symbolAnnotation)
{
if (!string.IsNullOrWhiteSpace(symbolAnnotation.IconAnchor))
{
symbol.IconImage = symbolAnnotation.IconAnchor;
}
if (symbolAnnotation.IconColor.HasValue)
{
symbol.IconColor = symbolAnnotation.IconColor.Value.ToRGBAString();
}
if (symbolAnnotation.IconHaloBlur.HasValue)
{
symbol.IconHaloBlur = new Float(symbolAnnotation.IconHaloBlur.Value);
}
if (symbolAnnotation.IconHaloColor.HasValue)
{
symbol.IconHaloColor = symbolAnnotation.IconHaloColor.Value.ToRGBAString();
}
if (symbolAnnotation.IconHaloWidth.HasValue)
{
symbol.IconHaloWidth = new Float(symbolAnnotation.IconHaloWidth.Value);
}
if (symbolAnnotation.IconImage != null)
{
symbol.IconImage = (symbolAnnotation.IconImage.Id);
}
if (symbolAnnotation.IconOffset?.Length > 0)
{
symbol.IconOffset = new Android.Graphics.PointF(
symbolAnnotation.IconOffset[0],
symbolAnnotation.IconOffset[1]);
}
if (symbolAnnotation.IconOpacity.HasValue)
{
symbol.IconOpacity = (new Float(symbolAnnotation.IconOpacity.Value));
}
if (symbolAnnotation.IconRotate.HasValue)
{
symbol.IconRotate = (new Float(symbolAnnotation.IconRotate.Value));
}
if (symbolAnnotation.IconSize.HasValue)
{
symbol.IconSize = (new Float(symbolAnnotation.IconSize.Value));
}
if (symbolAnnotation.IsDraggable.HasValue)
{
symbol.Draggable = (symbolAnnotation.IsDraggable.Value);
}
if (symbolAnnotation.SymbolSortKey.HasValue)
{
symbol.SymbolSortKey = (new Float(symbolAnnotation.SymbolSortKey.Value));
}
if (!string.IsNullOrWhiteSpace(symbolAnnotation.TextAnchor))
{
symbol.TextAnchor = (symbolAnnotation.TextAnchor);
}
if (symbolAnnotation.TextColor.HasValue)
{
symbol.TextColor = (symbolAnnotation.TextColor.Value.ToRGBAString());
}
if (!string.IsNullOrWhiteSpace(symbolAnnotation.TextField))
{
symbol.TextField = (symbolAnnotation.TextField);
}
if (symbolAnnotation.TextFont?.Length > 0)
{
symbol.SetTextFont(symbolAnnotation.TextFont);
}
if (symbolAnnotation.TextHaloBlur.HasValue)
{
symbol.TextHaloBlur = (new Float(symbolAnnotation.TextHaloBlur.Value));
}
if (symbolAnnotation.TextHaloColor.HasValue)
{
symbol.TextHaloColor = (symbolAnnotation.TextHaloColor.Value.ToRGBAString());
}
if (symbolAnnotation.TextHaloWidth.HasValue)
{
symbol.TextHaloWidth = (new Float(symbolAnnotation.TextHaloWidth.Value));
}
if (!string.IsNullOrWhiteSpace(symbolAnnotation.TextJustify))
{
symbol.TextJustify = (symbolAnnotation.TextJustify);
}
if (symbolAnnotation.TextLetterSpacing.HasValue)
{
symbol.TextLetterSpacing = (new Float(symbolAnnotation.TextLetterSpacing.Value));
}
if (symbolAnnotation.TextMaxWidth.HasValue)
{
symbol.TextMaxWidth = (new Float(symbolAnnotation.TextMaxWidth.Value));
}
if (symbolAnnotation.TextOffset?.Length > 0)
{
symbol.TextOffset = new Android.Graphics.PointF(
symbolAnnotation.TextOffset[0],
symbolAnnotation.TextOffset[1]);
}
if (symbolAnnotation.TextOpacity.HasValue)
{
symbol.TextOpacity = (new Float(symbolAnnotation.TextOpacity.Value));
}
if (symbolAnnotation.TextRadialOffset.HasValue)
{
symbol.TextRadialOffset = (new Float(symbolAnnotation.TextRadialOffset.Value));
}
if (symbolAnnotation.TextRotate.HasValue)
{
symbol.TextRotate = (new Float(symbolAnnotation.TextRotate.Value));
}
if (symbolAnnotation.TextSize.HasValue)
{
symbol.TextSize = new Float(symbolAnnotation.TextSize.Value);
}
if (!string.IsNullOrWhiteSpace(symbolAnnotation.TextTransform))
{
symbol.TextTransform = (symbolAnnotation.TextTransform);
}
}
