private IFeatureClass method_2(IFeatureWorkspaceAnno ifeatureWorkspaceAnno_0, IFeatureDataset ifeatureDataset_0,
IFeatureClass ifeatureClass_0, double double_1, esriUnits esriUnits_0,
IAnnotateLayerPropertiesCollection iannotateLayerPropertiesCollection_0,
ISymbolCollection isymbolCollection_0, string string_0)
{
IObjectClassDescription description = new AnnotationFeatureClassDescriptionClass();
IFields requiredFields = description.RequiredFields;
int index = requiredFields.FindField((description as IFeatureClassDescription).ShapeFieldName);
if (index != -1)
{
IField field = requiredFields.get_Field(index);
IGeometryDef geometryDef = field.GeometryDef;
ISpatialReference spatialReference = geometryDef.SpatialReference;
SpatialReferenctOperator.ChangeCoordinateSystem(ifeatureWorkspaceAnno_0 as IGeodatabaseRelease,
spatialReference, false);
(geometryDef as IGeometryDefEdit).SpatialReference_2 = spatialReference;
(field as IFieldEdit).GeometryDef_2 = geometryDef;
}
IFeatureClassDescription description2 = description as IFeatureClassDescription;
IGraphicsLayerScale referenceScale = new GraphicsLayerScaleClass
{
ReferenceScale = double_1,
Units = esriUnits_0
};
UID instanceCLSID = description.InstanceCLSID;
UID classExtensionCLSID = description.ClassExtensionCLSID;
return(ifeatureWorkspaceAnno_0.CreateAnnotationClass(string_0, requiredFields, instanceCLSID,
classExtensionCLSID, description2.ShapeFieldName, "", ifeatureDataset_0, ifeatureClass_0,
iannotateLayerPropertiesCollection_0, referenceScale, isymbolCollection_0, true));
}
public void Simplify()
{
if (_renderers == null || _renderers.Count == 0)
{
return;
}
foreach (IFeatureRenderer renderer in _renderers)
{
if (renderer is ISimplify)
{
((ISimplify)renderer).Simplify();
}
}
#region SimpleRenderer zusammenfassen
bool allSimpleRenderers = true;
foreach (IRenderer renderer in _renderers)
{
if (!(renderer is SimpleRenderer))
{
allSimpleRenderers = false;
break;
}
}
if (allSimpleRenderers)
{
IFeatureRenderer renderer = _renderers[0];
if (_renderers.Count > 1)
{
ISymbolCollection symCol = PlugInManager.Create(new Guid("062AD1EA-A93C-4c3c-8690-830E65DC6D91")) as ISymbolCollection;
foreach (IRenderer sRenderer in _renderers)
{
if (((SimpleRenderer)renderer).Symbol != null)
{
symCol.AddSymbol(((SimpleRenderer)renderer).Symbol);
}
}
((SimpleRenderer)renderer).Symbol = (ISymbol)symCol;
_renderers.Clear();
_renderers.Add(renderer);
}
}
#endregion
#region Combine Renderers
for (int i = 0; i < _renderers.Count; i++)
{
for (int j = i + 1; j < _renderers.Count; j++)
{
if (_renderers[i].Combine(_renderers[j]))
{
_renderers.RemoveAt(j);
j--;
}
}
}
#endregion
}
public void WriteSymbol(ISymbol symbol)
{
if (symbol == null)
{
return;
}
if (symbol is IFillSymbol)
{
WriteSimpleFillSymbol(symbol as IFillSymbol);
}
else if (symbol is ILineSymbol)
{
WriteSimpleLineSymbol(symbol as ILineSymbol);
}
else if (symbol is IPointSymbol)
{
WritePointSymbol(symbol as IPointSymbol);
}
else if (symbol is ISymbolCollection)
{
ISymbolCollection symCol = (ISymbolCollection)symbol;
foreach (ISymbolCollectionItem symItem in symCol.Symbols)
{
if (symItem == null || symItem.Visible == false)
{
continue;
}
WriteSymbol(symItem.Symbol);
}
}
}
public void LoadSymbols()
{
try
{
using (var adsClient = new AdsClient())
{
// connection
adsClient.Connect(new AmsAddress(_appOptions.Value.AMSNetId, _appOptions.Value.Port));
// get the symbol loader, FLAT mode
var symbolLoader = SymbolLoaderFactory.Create(adsClient, new SymbolLoaderSettings(SymbolsLoadMode.Flat));
if (symbolLoader != null)
{
_symbolCollection = symbolLoader.Symbols;
SymbolInfos = new BindableCollection <ISymbol>(_symbolCollection);
NotifyOfPropertyChange(() => SymbolInfos);
}
}
}
catch (ObjectDisposedException exDisposed)
{
Console.WriteLine("exception\n" + exDisposed.Message);
}
catch (InvalidOperationException exInvalid)
{
Console.WriteLine("exception\n" + exInvalid.Message);
}
catch (Exception ex)
{
Console.WriteLine("Undentified exception\n" + ex.Message);
}
}
private Task <List <GatewayVariable> > GetS7Variables(ISymbolCollection <ISymbol> symbols)
{
var iterator = new SymbolIterator(symbols,
s => s.InstancePath.Split('.').Length == 2 && s.Attributes.Any(attribute => attribute.Name.StartsWith("S7")));
return(Task.FromResult(iterator.Select(ConvertToGatewayVariale).Where(variable => variable.IsValid).ToList()));
}
public void FinishDrawing(IDisplay disp, ICancelTracker cancelTracker)
{
if (cancelTracker == null)
{
cancelTracker = new CancelTracker();
}
if (_actualCartoMethod == CartographicMethod.SymbolOrder && cancelTracker.Continue)
{
ISymbolCollection sColl = (ISymbolCollection)_symbol;
foreach (ISymbolCollectionItem symbolItem in sColl.Symbols)
{
if (symbolItem.Visible == false || symbolItem.Symbol == null)
{
continue;
}
ISymbol symbol = symbolItem.Symbol;
bool isRotatable = symbol is ISymbolRotation;
int counter = 0;
if (!cancelTracker.Continue)
{
break;
}
foreach (IFeature feature in _features)
{
if (_rotate && isRotatable)
{
object rot = feature[_symbolRotation.RotationFieldName];
if (rot != null && rot != DBNull.Value)
{
((ISymbolRotation)symbol).Rotation = (float)_symbolRotation.Convert2DEGAritmetic(Convert.ToDouble(rot));
}
else
{
((ISymbolRotation)symbol).Rotation = 0;
}
}
disp.Draw(symbol, feature.Shape);
counter++;
if (counter % 100 == 0 && !cancelTracker.Continue)
{
break;
}
}
}
}
if (_features != null)
{
_features.Clear();
}
_features = null;
}
private static void PrintSymbols(ISymbolCollection <ISymbol> symbols)
{
foreach (Symbol symbol in symbols)
{
object value = symbol.HasValue ? symbol.ReadValue() : "Has no value";
Console.WriteLine($"{symbol.InstancePath}, {symbol.IndexGroup}, {symbol.IndexOffset} {value}, {symbol.TypeName}");
if (symbol.SubSymbolCount > 0)
{
PrintSymbols(symbol.SubSymbols);
}
}
}
private void UpdateSymbols(ConnectionState state)
{
if (state == TwinCAT.ConnectionState.Connected)
{
var loader = SymbolLoaderFactory.Create(Client, new SymbolLoaderSettings(SymbolsLoadMode.VirtualTree));
TreeViewSymbols = loader.Symbols;
var loader2 = SymbolLoaderFactory.Create(Client, new SymbolLoaderSettings(SymbolsLoadMode.Flat));
FlatViewSymbols = loader2.Symbols;
}
else
{
TreeViewSymbols = null;
}
}
internal override ISymbolCollection OnCreateSubSymbols(ISymbol parentInstance)
{
ISymbolCollection symbols = null;
try
{
StructType dataType = (StructType)base.DataType;
symbols = (dataType == null) ? new SymbolCollection(InstanceCollectionMode.Names) : this.FactoryServices.SymbolFactory.CreateFieldInstances(this, dataType);
}
catch (Exception exception)
{
Module.Trace.TraceError(exception);
}
return(symbols);
}
public void Simplify()
{
if (_renderers == null)
{
return;
}
foreach (IFeatureRenderer renderer in _renderers)
{
if (renderer is ISimplify)
{
((ISimplify)renderer).Simplify();
}
}
#region SimpleRenderer zusammenfassen
bool allSimpleRenderers = true;
foreach (IRenderer renderer in _renderers)
{
if (!(renderer is ScaleRenderer) && (((ScaleRenderer)renderer).Renderer is SimpleRenderer))
{
allSimpleRenderers = false;
break;
}
}
if (allSimpleRenderers && _renderers.Count > 1)
{
ScaleRenderer renderer = (ScaleRenderer)_renderers[0];
if (_renderers.Count > 1)
{
ISymbolCollection symCol = PlugInManager.Create(new Guid("062AD1EA-A93C-4c3c-8690-830E65DC6D91")) as ISymbolCollection;
foreach (IRenderer sRenderer in _renderers)
{
if (((SimpleRenderer)((ScaleRenderer)sRenderer).Renderer).Symbol != null)
{
symCol.AddSymbol(((SimpleRenderer)((ScaleRenderer)sRenderer).Renderer).Symbol);
}
}
((SimpleRenderer)((ScaleRenderer)renderer).Renderer).Symbol = (ISymbol)symCol;
_renderers.Clear();
_renderers.Add(renderer);
}
}
#endregion
ShrinkScaleRenderes();
}
public ISymbolCollection CreateSubSymbols(ISymbol parent)
{
ISymbolCollection target = null;
if (this.subSymbols == null)
{
this.subSymbols = new WeakReference(this.OnCreateSubSymbols(parent));
}
target = (ISymbolCollection)this.subSymbols.Target;
if (target == null)
{
target = this.OnCreateSubSymbols(parent);
this.subSymbols.Target = target;
}
return(target);
}
internal override ISymbolCollection OnCreateSubSymbols(ISymbol parentInstance)
{
ISymbolCollection symbols = null;
try
{
UnionType dataType = (UnionType)base.DataType;
symbols = (dataType == null) ? new SymbolCollection(InstanceCollectionMode.Names) : this.FactoryServices.SymbolFactory.CreateFieldInstances(this, dataType);
}
catch (Exception exception1)
{
Console.WriteLine(exception1);
throw;
}
return(symbols);
}
internal override ISymbolCollection OnCreateSubSymbols(ISymbol parentInstance)
{
ISymbolCollection symbols = base.OnCreateSubSymbols(parentInstance);
try
{
DataType type2 = (DataType)((ReferenceType)base.DataType).ResolveType(DataTypeResolveStrategy.AliasReference);
if (type2 == null)
{
object[] args = new object[] { parentInstance.InstancePath };
Module.Trace.TraceWarning("Cannot resolve reference type '{0}'!", args);
}
else if (type2.Size > 0)
{
if (type2.Category == DataTypeCategory.Struct)
{
StructType parentType = (StructType)type2;
symbols = (parentType == null) ? new SymbolCollection(InstanceCollectionMode.Names) : this.FactoryServices.SymbolFactory.CreateFieldInstances(this, parentType);
}
else if (type2.Category == DataTypeCategory.Array)
{
ArrayType arrayType = (ArrayType)type2;
symbols = this.FactoryServices.SymbolFactory.CreateArrayElementInstances(parentInstance, arrayType);
}
else if (type2.Category == DataTypeCategory.Union)
{
UnionType parentType = (UnionType)type2;
symbols = (parentType == null) ? new SymbolCollection(InstanceCollectionMode.Names) : this.FactoryServices.SymbolFactory.CreateFieldInstances(this, parentType);
}
else if (type2.Category == DataTypeCategory.Pointer)
{
PointerType type = (PointerType)type2;
ISymbol item = this.FactoryServices.SymbolFactory.CreateReferenceInstance(type, this);
if ((item != null) && (type2.Size > 0))
{
symbols.Add(item);
}
}
}
}
catch (Exception exception)
{
Module.Trace.TraceError(exception);
}
return(symbols);
}
internal override ISymbolCollection OnCreateSubSymbols(ISymbol parentInstance)
{
ISymbolCollection symbols = null;
ArrayType dataType = (ArrayType)base.DataType;
ISymbolFactory symbolFactory = this.FactoryServices.SymbolFactory;
try
{
symbols = symbolFactory.CreateArrayElementInstances(parentInstance, dataType);
}
catch (Exception exception)
{
TwinCAT.Ads.Module.Trace.TraceError(exception);
throw;
}
return(symbols);
}
internal override ISymbolCollection OnCreateSubSymbols(ISymbol parentInstance)
{
IDataType type = ((DataType)base.DataType).ResolveType(DataTypeResolveStrategy.AliasReference);
ISymbolCollection symbols = base.OnCreateSubSymbols(parentInstance);
try
{
ISymbolFactory symbolFactory = this.FactoryServices.SymbolFactory;
if (type != null)
{
DataTypeCategory category = type.Category;
if (category <= DataTypeCategory.Struct)
{
if (category == DataTypeCategory.Array)
{
symbols = symbolFactory.CreateArrayElementInstances(parentInstance, (IArrayType)type);
}
else if (category == DataTypeCategory.Struct)
{
symbols = symbolFactory.CreateFieldInstances(parentInstance, (IStructType)type);
}
}
else if (category != DataTypeCategory.Pointer)
{
if (category == DataTypeCategory.Union)
{
symbols = symbolFactory.CreateFieldInstances(parentInstance, (IUnionType)type);
}
}
else
{
ISymbol item = symbolFactory.CreateReferenceInstance((IPointerType)type, parentInstance);
if (item != null)
{
symbols.Add(item);
}
}
}
}
catch (Exception exception)
{
Module.Trace.TraceError(exception);
}
return(symbols);
}
internal override ISymbolCollection OnCreateSubSymbols(ISymbol parentInstance)
{
ISymbolCollection symbols = null;
ISymbolFactory symbolFactory = this.FactoryServices.SymbolFactory;
IArrayType arrayType = this.UpdateDynamicType();
base.size = arrayType.Size;
try
{
symbols = symbolFactory.CreateArrayElementInstances(parentInstance, arrayType);
}
catch (Exception exception)
{
Module.Trace.TraceError(exception);
throw;
}
return(symbols);
}
internal override ISymbolCollection OnCreateSubSymbols(ISymbol parentInstance)
{
ISymbolCollection symbols = base.OnCreateSubSymbols(parentInstance);
try
{
ISymbol item = this.FactoryServices.SymbolFactory.CreateReferenceInstance((IPointerType)base.DataType, parentInstance);
if ((item != null) && (this.IsAnySizeArray || (item.Size > 0)))
{
symbols.Add(item);
}
}
catch (Exception exception)
{
Module.Trace.TraceError(exception);
}
return(symbols);
}
protected virtual ISymbolCollection OnCreateArrayElementInstances(ISymbol parentInstance, IArrayType arrayType)
{
ISymbolCollection symbols = null;
if (this.nonCachedArrayElements)
{
symbols = new ArrayElementSymbolCollection(parentInstance, arrayType, this);
}
else
{
symbols = new SymbolCollection(InstanceCollectionMode.Names);
foreach (int[] numArray in new ArrayIndexIterator(arrayType))
{
ISymbol item = this.CreateArrayElement(numArray, parentInstance, arrayType);
symbols.Add(item);
}
}
return(symbols);
}
/// <summary>
/// 根据参考注记层新建注记层
/// </summary>
/// <param name="targetName">创建注记图层的名称</param>
/// <param name="pTargetWrksps">目标工作空间</param>
/// <param name="pTargetDs">所属目标数据集</param>
/// <param name="pRefAnnoFtCls">参考图层</param>
/// <returns></returns>
private static IFeatureClass CreateAnnotationClass(string targetName, IFeatureWorkspace pTargetWrksps, IFeatureDataset pTargetDs, IFeatureClass pRefAnnoFtCls, out string msg)
{
msg = "";
try
{
IFeatureWorkspaceAnno pAnnoWrksps = pTargetWrksps as IFeatureWorkspaceAnno;
if (pAnnoWrksps == null || pRefAnnoFtCls == null)
{
return(null);
}
if (pRefAnnoFtCls.Extension is IAnnotationClassExtension pAnnoExten)
{
IClone pClone = pAnnoExten.AnnoProperties as IClone;
IAnnotateLayerPropertiesCollection pAnnoProCol = (IAnnotateLayerPropertiesCollection)pClone.Clone();
esriUnits eUnits = pAnnoExten.ReferenceScaleUnits;
double dbScale = pAnnoExten.ReferenceScale;
IGraphicsLayerScale pGraScale = new GraphicsLayerScaleClass
{
ReferenceScale = dbScale,
Units = eUnits
};
pClone = pAnnoExten.SymbolCollection as IClone;
ISymbolCollection pSymbolCol = (ISymbolCollection)pClone.Clone();
pClone = pRefAnnoFtCls.Fields as IClone;
IFields pFields = (IFields)pClone.Clone();
IObjectClassDescription pOCDesc = new AnnotationFeatureClassDescriptionClass();
IDataset pDs = (IDataset)pRefAnnoFtCls;
return(pAnnoWrksps.CreateAnnotationClass(targetName, pFields, pOCDesc.InstanceCLSID, pOCDesc.ClassExtensionCLSID, pRefAnnoFtCls.ShapeFieldName,
null, pTargetDs, null, pAnnoProCol, pGraScale, pSymbolCol, false));
}
return(null);
}
catch (Exception ex)
{
msg = ex.Message;
return(null);
}
}
//注记复制
private void CopyAnnoPropertyToFC(IFeatureClass pSourceFeatureClass, IFeatureClass pToFeatureClass)
{
IAnnoClass pSourceAnnoClass = (IAnnoClass)pSourceFeatureClass.Extension;
IAnnoClass pTargerAnnoClass = (IAnnoClass)pToFeatureClass.Extension;
IAnnotateLayerPropertiesCollection pSourceAnnoProperCollection = pSourceAnnoClass.AnnoProperties;
IClone pAnnoCollection = (IClone)pSourceAnnoProperCollection;
ISymbolCollection pSourceSymbolCollection = pSourceAnnoClass.SymbolCollection;
IClone pAnnoSymbol = (IClone)pSourceSymbolCollection;
IAnnoClassAdmin2 pAnnoClassAdmin = (IAnnoClassAdmin2)pTargerAnnoClass;
pAnnoClassAdmin.ReferenceScale = pSourceAnnoClass.ReferenceScale;
pAnnoClassAdmin.ReferenceScaleUnits = pSourceAnnoClass.ReferenceScaleUnits;
pAnnoClassAdmin.AnnoProperties = (IAnnotateLayerPropertiesCollection)pAnnoCollection;
pAnnoClassAdmin.SymbolCollection = (ISymbolCollection)pAnnoSymbol;
pAnnoClassAdmin.UpdateProperties();
pAnnoClassAdmin.UpdateOnShapeChange = true;
}
public bool Combine(IRenderer renderer)
{
if (renderer is SimpleRenderer && renderer != this)
{
if (_symbol is ISymbolCollection)
{
((ISymbolCollection)_symbol).AddSymbol(
((SimpleRenderer)renderer).Symbol);
}
else
{
ISymbolCollection symCol = PlugInManager.Create(new Guid("062AD1EA-A93C-4c3c-8690-830E65DC6D91")) as ISymbolCollection;
symCol.AddSymbol(_symbol);
symCol.AddSymbol(((SimpleRenderer)renderer).Symbol);
_symbol = (ISymbol)symCol;
}
return(true);
}
return(false);
}
public static IFeatureClass CreateAnnoFeatureClass(IFeatureWorkspaceAnno ifeatureWorkspaceAnno_0,
IFeatureDataset ifeatureDataset_0, IFeatureClass ifeatureClass_0, double double_0, esriUnits esriUnits_0,
IAnnotateLayerPropertiesCollection iannotateLayerPropertiesCollection_0,
ISymbolCollection isymbolCollection_0, string string_0)
{
IObjectClassDescription annotationFeatureClassDescriptionClass = new AnnotationFeatureClassDescription();
IFields requiredFields = annotationFeatureClassDescriptionClass.RequiredFields;
int num =
requiredFields.FindField(
(annotationFeatureClassDescriptionClass as IFeatureClassDescription).ShapeFieldName);
if (num != -1)
{
IField field = requiredFields.Field[num];
IGeometryDef geometryDef = field.GeometryDef;
ISpatialReference spatialReference = geometryDef.SpatialReference;
LayerOp.ChangeCoordinateSystem(ifeatureWorkspaceAnno_0 as IGeodatabaseRelease, spatialReference, false);
(geometryDef as IGeometryDefEdit).SpatialReference_2 = spatialReference;
(field as IFieldEdit).GeometryDef_2 = geometryDef;
}
IFeatureClassDescription featureClassDescription =
annotationFeatureClassDescriptionClass as IFeatureClassDescription;
IGraphicsLayerScale graphicsLayerScaleClass = new GraphicsLayerScale()
{
ReferenceScale = double_0,
Units = esriUnits_0
};
UID instanceCLSID = annotationFeatureClassDescriptionClass.InstanceCLSID;
UID classExtensionCLSID = annotationFeatureClassDescriptionClass.ClassExtensionCLSID;
IFeatureClass featureClass = ifeatureWorkspaceAnno_0.CreateAnnotationClass(string_0, requiredFields,
instanceCLSID, classExtensionCLSID, featureClassDescription.ShapeFieldName, "", ifeatureDataset_0,
ifeatureClass_0, iannotateLayerPropertiesCollection_0, graphicsLayerScaleClass, isymbolCollection_0,
true);
return(featureClass);
}
public void CopyAnnotationFeatures()
{
try
{
IMxDocument pMxDoc = (IMxDocument)ArcMap.Application.Document;
IMap pMap = pMxDoc.FocusMap;
ILayer SourceLayer = pMap.Layer[0];
ILayer TargetLayer = pMap.Layer[1];
IFeatureLayer SourceFLayer = (IFeatureLayer)SourceLayer;
IFeatureLayer TargetFLayer = (IFeatureLayer)TargetLayer;
IFeatureClass SourceFeatureClass = SourceFLayer.FeatureClass;
IFeatureClass TargetFeatureClass = TargetFLayer.FeatureClass;
IFields TargetFields = TargetFeatureClass.Fields;
IFields SourceFields = SourceFeatureClass.Fields;
IDictionary <int, int> symbSourceTargIdXref = new Dictionary <int, int>();
symbSourceTargIdXref.Add(4, 17);
symbSourceTargIdXref.Add(5, 22);
symbSourceTargIdXref.Add(43, 45);
symbSourceTargIdXref.Add(45, 45);
ISymbolCollection targetSymbolsColl = (TargetFeatureClass.Extension as IAnnoClass).SymbolCollection;
IField pFld;
int[] lSrcFlds;
int[] lTarFlds;
int lFld, lExFld, i;
lExFld = 0;
for (lFld = 0; lFld <= (SourceFields.FieldCount - 1); lFld++)
{
pFld = SourceFields.Field[lFld];
if (pFld.Type != esriFieldType.esriFieldTypeOID && pFld.Type != esriFieldType.esriFieldTypeGeometry && pFld.Name.ToUpper() != "ELEMENT" && pFld.Name.ToUpper() != "ZORDER" && pFld.Editable == true)
{
lExFld = lExFld + 1;
}
}
lSrcFlds = new int[lExFld];
lTarFlds = new int[lExFld];
i = 0;
for (lFld = 0; lFld <= (SourceFields.FieldCount - 1); lFld++)
{
pFld = SourceFields.Field[lFld];
if (pFld.Type != esriFieldType.esriFieldTypeOID && pFld.Type != esriFieldType.esriFieldTypeGeometry && pFld.Name.ToUpper() != "ELEMENT" && pFld.Name.ToUpper() != "ZORDER" && pFld.Editable == true)
{
lSrcFlds[i] = lFld;
lTarFlds[i] = TargetFields.FindField(pFld.Name);
i = i + 1;
}
}
IFeatureCursor pICursor;
pICursor = SourceFeatureClass.Search(null, true);
IFeature pIFeat;
pIFeat = pICursor.NextFeature();
IFDOGraphicsLayerFactory pGLF;
pGLF = new FDOGraphicsLayerFactory();
IDataset pDataset;
pDataset = (IDataset)TargetFeatureClass;
IAnnotationFeature pAnnoFeature;
IClone pAClone;
IElement pElement;
IAnnoClass pTargetAnnoClass = (IAnnoClass)TargetFeatureClass.Extension;
while (pIFeat != null)
{
pAnnoFeature = (IAnnotationFeature)pIFeat;
if (pAnnoFeature.Annotation != null)
{
ITextElement sourceTextElement = pAnnoFeature.Annotation as ITextElement;
pAClone = (IClone)sourceTextElement;
pElement = (IElement)pAClone.Clone();
ITextElement ptempTxt = (ITextElement)pAClone.Clone();
//set id
IFeature pTempFeat = TargetFeatureClass.CreateFeature();
ISymbolCollectionElement TargetSymbCollElem = (ISymbolCollectionElement)ptempTxt;
ISymbolCollectionElement sourceSymbCollElem = sourceTextElement as ISymbolCollectionElement;
int sourceSymbID = sourceSymbCollElem.SymbolID;
int symbolID = symbSourceTargIdXref[sourceSymbID];
ISymbolIdentifier2 pSymbI;
ISymbolCollection2 pSymbolColl2 = ( ISymbolCollection2 )pTargetAnnoClass.SymbolCollection;
pSymbolColl2.GetSymbolIdentifier(symbolID, out pSymbI);
//reset the desired symbol id
TargetSymbCollElem.set_SharedSymbol(pSymbI.ID, pSymbI.Symbol);
//save the annotation feature
IAnnotationFeature pAnnoFeat = (IAnnotationFeature)pTempFeat;
pAnnoFeat.Annotation = ptempTxt as IElement;
pTempFeat.Store();
//reset the over rided property by analysing the override code
if ((sourceSymbCollElem.OverriddenProperties ^ (int)esriSymbolOverrideEnum.esriSymbolOverrideXOffset) <= sourceSymbCollElem.OverriddenProperties)
{
TargetSymbCollElem.XOffset = sourceSymbCollElem.XOffset;
}
if ((sourceSymbCollElem.OverriddenProperties ^ (int)esriSymbolOverrideEnum.esriSymbolOverrideYOffset) <= sourceSymbCollElem.OverriddenProperties)
{
TargetSymbCollElem.YOffset = sourceSymbCollElem.YOffset;
}
if ((sourceSymbCollElem.OverriddenProperties ^ (int)esriSymbolOverrideEnum.esriSymbolOverrideHorzAlignment) <= sourceSymbCollElem.OverriddenProperties)
{
TargetSymbCollElem.HorizontalAlignment = sourceSymbCollElem.HorizontalAlignment;
}
if ((sourceSymbCollElem.OverriddenProperties ^ (int)esriSymbolOverrideEnum.esriSymbolOverrideVertAlignment) <= sourceSymbCollElem.OverriddenProperties)
{
TargetSymbCollElem.VerticalAlignment = sourceSymbCollElem.VerticalAlignment;
}
if ((sourceSymbCollElem.OverriddenProperties ^ (int)esriSymbolOverrideEnum.esriSymbolOverrideFlipAngle) <= sourceSymbCollElem.OverriddenProperties)
{
TargetSymbCollElem.FlipAngle = TargetSymbCollElem.FlipAngle;
}
if ((sourceSymbCollElem.OverriddenProperties ^ (int)esriSymbolOverrideEnum.esriSymbolOverrideSize) <= sourceSymbCollElem.OverriddenProperties)
{
TargetSymbCollElem.Size = sourceSymbCollElem.Size;
}
if ((sourceSymbCollElem.OverriddenProperties ^ (int)esriSymbolOverrideEnum.esriSymbolOverrideColor) <= sourceSymbCollElem.OverriddenProperties)
{
TargetSymbCollElem.Color = sourceSymbCollElem.Color;
}
if ((sourceSymbCollElem.OverriddenProperties ^ (int)esriSymbolOverrideEnum.esriSymbolOverrideCharSpacing) <= sourceSymbCollElem.OverriddenProperties)
{
TargetSymbCollElem.CharacterSpacing = sourceSymbCollElem.CharacterSpacing;
}
if ((sourceSymbCollElem.OverriddenProperties ^ (int)esriSymbolOverrideEnum.esriSymbolOverrideCharWidth) <= sourceSymbCollElem.OverriddenProperties)
{
TargetSymbCollElem.CharacterWidth = sourceSymbCollElem.CharacterWidth;
}
if ((sourceSymbCollElem.OverriddenProperties ^ (int)esriSymbolOverrideEnum.esriSymbolOverrideWordSpacing) <= sourceSymbCollElem.OverriddenProperties)
{
TargetSymbCollElem.WordSpacing = sourceSymbCollElem.WordSpacing;
}
if ((sourceSymbCollElem.OverriddenProperties ^ (int)esriSymbolOverrideEnum.esriSymbolOverrideLeading) <= sourceSymbCollElem.OverriddenProperties)
{
TargetSymbCollElem.Leading = sourceSymbCollElem.Leading;
}
if ((sourceSymbCollElem.OverriddenProperties ^ (int)esriSymbolOverrideEnum.esriSymbolOverrideBold) <= sourceSymbCollElem.OverriddenProperties)
{
TargetSymbCollElem.Bold = sourceSymbCollElem.Bold;
}
if ((sourceSymbCollElem.OverriddenProperties ^ (int)esriSymbolOverrideEnum.esriSymbolOverrideItalic) <= sourceSymbCollElem.OverriddenProperties)
{
TargetSymbCollElem.Italic = sourceSymbCollElem.Italic;
}
if ((sourceSymbCollElem.OverriddenProperties ^ (int)esriSymbolOverrideEnum.esriSymbolOverrideUnderline) <= sourceSymbCollElem.OverriddenProperties)
{
TargetSymbCollElem.Underline = sourceSymbCollElem.Underline;
}
if ((sourceSymbCollElem.OverriddenProperties ^ (int)esriSymbolOverrideEnum.esriSymbolOverrideBackground) <= sourceSymbCollElem.OverriddenProperties)
{
TargetSymbCollElem.Background = sourceSymbCollElem.Background;
}
if ((sourceSymbCollElem.OverriddenProperties ^ (int)esriSymbolOverrideEnum.esriSymbolOverrideFontName) <= sourceSymbCollElem.OverriddenProperties)
{
TargetSymbCollElem.FontName = sourceSymbCollElem.FontName;
}
//save the feature again
pAnnoFeat.Annotation = ptempTxt as IElement;
pTempFeat.Store();
}
pIFeat = pICursor.NextFeature();
}
pMxDoc.UpdateContents();
pMxDoc.ActiveView.Refresh();
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
public Computation(ISymbolCollection symbols)
{
Symbols = symbols;
}
internal static bool TryGetSubItem(IInstanceCollection <T> coll, string[] pathSplit, int splitIndex, out T symbol)
{
SymbolParser.ArrayIndexType type;
T local = default(T);
symbol = default(T);
string nameWithIndices = pathSplit[splitIndex];
string instanceName = null;
IList <int[]> jaggedIndices = null;
string indicesStr = null;
bool flag = SymbolParser.TryParseArrayElement(nameWithIndices, out instanceName, out indicesStr, out jaggedIndices, out type);
if (flag)
{
nameWithIndices = instanceName;
}
bool flag2 = nameWithIndices[nameWithIndices.Length - 1] == '^';
if (flag2)
{
nameWithIndices = nameWithIndices.Substring(0, nameWithIndices.Length - 1);
}
IList <T> list2 = null;
if (coll.TryGetInstanceByName(nameWithIndices, out list2))
{
local = list2[0];
if (flag)
{
ISymbol symbol2 = null;
IArrayInstance instance = local as IArrayInstance;
IReferenceInstanceAccess access = local as IReferenceInstanceAccess;
if (instance != null)
{
instance.TryGetElement(jaggedIndices, out symbol2);
}
else if (access != null)
{
access.TryGetElement(jaggedIndices, out symbol2);
}
local = (T)symbol2;
}
if ((local == null) || (splitIndex >= (pathSplit.Length - 1)))
{
symbol = !((splitIndex == (pathSplit.Length - 1)) & flag2) ? local : ((ISymbolInternal)local).SubSymbolsInternal[0];
}
else
{
ISymbol symbol3 = local as ISymbol;
if (symbol3.IsContainerType)
{
ISymbolCollection subSymbolsInternal = ((ISymbolInternal)symbol3).SubSymbolsInternal;
if (flag2)
{
subSymbolsInternal = ((ISymbolInternal)subSymbolsInternal[0]).SubSymbolsInternal;
}
if ((subSymbolsInternal != null) && (subSymbolsInternal.Count > 0))
{
T local2 = default(T);
splitIndex++;
if (InstanceCollection <T> .TryGetSubItem((IInstanceCollection <T>)subSymbolsInternal, pathSplit, splitIndex, out local2))
{
symbol = local2;
}
else
{
symbol = default(T);
}
}
}
}
}
return(((T)symbol) != null);
}
public static List <YTEditTemplate> Create(IFeatureLayer ifeatureLayer_0)
{
YTEditTemplate jLKEditTemplate;
int i;
string field;
List <YTEditTemplate> jLKEditTemplates;
List <YTEditTemplate> jLKEditTemplates1 = new List <YTEditTemplate>();
if (ifeatureLayer_0 is IGeoFeatureLayer)
{
IGeoFeatureLayer ifeatureLayer0 = ifeatureLayer_0 as IGeoFeatureLayer;
if (ifeatureLayer0.Renderer is ISimpleRenderer)
{
ISimpleRenderer renderer = ifeatureLayer0.Renderer as ISimpleRenderer;
jLKEditTemplate = new YTEditTemplate();
jLKEditTemplate.Init(ifeatureLayer_0);
jLKEditTemplate.Symbol = (renderer.Symbol as IClone).Clone() as ISymbol;
jLKEditTemplate.InitBitmap();
jLKEditTemplates1.Add(jLKEditTemplate);
}
else if (!(ifeatureLayer0.Renderer is IUniqueValueRenderer))
{
jLKEditTemplate = new YTEditTemplate();
jLKEditTemplate.Init(ifeatureLayer_0);
jLKEditTemplate.InitBitmap();
jLKEditTemplates1.Add(jLKEditTemplate);
}
else
{
EditTemplateSchems editTemplateSchem = new EditTemplateSchems();
IUniqueValueRenderer uniqueValueRenderer = ifeatureLayer0.Renderer as IUniqueValueRenderer;
for (i = 0; i < uniqueValueRenderer.FieldCount; i++)
{
field = uniqueValueRenderer.Field[i];
editTemplateSchem.AddField(field);
}
EditTemplateSchem symbol = new EditTemplateSchem();
for (int j = 0; j < uniqueValueRenderer.ValueCount; j++)
{
symbol = new EditTemplateSchem();
string value = uniqueValueRenderer.Value[j];
jLKEditTemplate = new YTEditTemplate();
jLKEditTemplate.Init(ifeatureLayer_0);
jLKEditTemplate.Symbol = (uniqueValueRenderer.Symbol[value] as IClone).Clone() as ISymbol;
jLKEditTemplate.Name = uniqueValueRenderer.Heading[value];
symbol.Symbol = jLKEditTemplate.Symbol;
symbol.Value = value;
symbol.Label = uniqueValueRenderer.Label[value];
symbol.Description = uniqueValueRenderer.Description[value];
if (uniqueValueRenderer.FieldCount != 1)
{
string[] strArrays = value.Split(uniqueValueRenderer.FieldDelimiter.ToCharArray());
for (i = 0; i < uniqueValueRenderer.FieldCount; i++)
{
field = uniqueValueRenderer.Field[i];
string str = strArrays[i].Trim();
if (str.Length > 0)
{
jLKEditTemplate.SetFieldValue(field, str);
}
symbol.Add(field, str);
}
}
else
{
string field1 = uniqueValueRenderer.Value[0];
jLKEditTemplate.SetFieldValue(field1, value);
symbol.Add(field1, value);
}
editTemplateSchem.Add(symbol);
jLKEditTemplate.InitBitmap();
jLKEditTemplate.EditTemplateSchems = editTemplateSchem;
jLKEditTemplates1.Add(jLKEditTemplate);
}
}
}
else if (ifeatureLayer_0.FeatureClass.FeatureType == esriFeatureType.esriFTAnnotation)
{
IAnnoClass extension = ifeatureLayer_0.FeatureClass.Extension as IAnnoClass;
ISymbolCollection symbolCollection = extension.SymbolCollection;
IAnnotateLayerPropertiesCollection2 annoProperties =
extension.AnnoProperties as IAnnotateLayerPropertiesCollection2;
symbolCollection.Reset();
for (ISymbolIdentifier k = symbolCollection.Next(); k != null; k = symbolCollection.Next())
{
jLKEditTemplate = new YTEditTemplate();
jLKEditTemplate.Init(ifeatureLayer_0);
jLKEditTemplate.Symbol = (k.Symbol as IClone).Clone() as ISymbol;
jLKEditTemplate.Name = annoProperties.Properties[k.ID].Class;
jLKEditTemplate.SetFieldValue("SymbolID", k.ID.ToString());
jLKEditTemplate.InitBitmap();
jLKEditTemplates1.Add(jLKEditTemplate);
}
}
if (jLKEditTemplates1.Count <= 0)
{
jLKEditTemplates = null;
}
else
{
jLKEditTemplates = jLKEditTemplates1;
}
return(jLKEditTemplates);
}
public void FinishDrawing(IDisplay disp, ICancelTracker cancelTracker)
{
if (cancelTracker == null)
{
cancelTracker = new CancelTracker();
}
if (_cartoMethod == LegendGroupCartographicMethod.LegendAndSymbolOrdering && cancelTracker.Continue)
{
int symbolIndex = 0;
List <string> keys = new List <string>();
foreach (string key in _symbolTable.Keys)
{
keys.Insert(0, key);
}
if (_features != null)
{
while (true)
{
bool loop = false;
foreach (string key in keys)
{
if (!_features.ContainsKey(key) || _features[key] == null)
{
continue;
}
if (!cancelTracker.Continue)
{
break;
}
ISymbol symbol = _symbolTable.ContainsKey(key) ? (ISymbol)_symbolTable[key] : null;
if (symbol == null)
{
continue;
}
if (symbol is ISymbolCollection)
{
ISymbolCollection symbolCol = (ISymbolCollection)symbol;
if (symbolIndex >= symbolCol.Symbols.Count)
{
continue;
}
if (symbolCol.Symbols.Count > symbolIndex + 1)
{
loop = true;
}
ISymbolCollectionItem symbolItem = symbolCol.Symbols[symbolIndex];
if (symbolItem.Visible == false || symbolItem.Symbol == null)
{
continue;
}
symbol = symbolItem.Symbol;
}
else if (symbolIndex > 0)
{
continue;
}
List <IFeature> features = _features[key];
bool isRotatable = symbol is ISymbolRotation;
if (!cancelTracker.Continue)
{
break;
}
int counter = 0;
foreach (IFeature feature in features)
{
if (isRotatable && !String.IsNullOrEmpty(_symbolRotation.RotationFieldName))
{
object rot = feature[_symbolRotation.RotationFieldName];
if (rot != null && rot != DBNull.Value)
{
((ISymbolRotation)symbol).Rotation = (float)_symbolRotation.Convert2DEGAritmetic(Convert.ToDouble(rot));
}
else
{
((ISymbolRotation)symbol).Rotation = 0;
}
}
symbol.Draw(disp, feature.Shape);
counter++;
if (counter % 100 == 0 && !cancelTracker.Continue)
{
break;
}
}
}
if (!loop)
{
break;
}
symbolIndex++;
}
}
}
else if (_cartoMethod == LegendGroupCartographicMethod.LegendOrdering && cancelTracker.Continue)
{
List <string> keys = new List <string>();
foreach (string key in _symbolTable.Keys)
{
keys.Insert(0, key);
}
foreach (string key in keys)
{
if (!_features.ContainsKey(key) || _features[key] == null)
{
continue;
}
if (!cancelTracker.Continue)
{
break;
}
ISymbol symbol = _symbolTable.ContainsKey(key) ? (ISymbol)_symbolTable[key] : null;
if (symbol == null)
{
continue;
}
List <IFeature> features = _features[key];
bool isRotatable = symbol is ISymbolRotation;
int counter = 0;
foreach (IFeature feature in features)
{
if (isRotatable && !String.IsNullOrEmpty(_symbolRotation.RotationFieldName))
{
object rot = feature[_symbolRotation.RotationFieldName];
if (rot != null && rot != DBNull.Value)
{
((ISymbolRotation)symbol).Rotation = (float)_symbolRotation.Convert2DEGAritmetic(Convert.ToDouble(rot));
}
else
{
((ISymbolRotation)symbol).Rotation = 0;
}
}
symbol.Draw(disp, feature.Shape);
counter++;
if (counter % 100 == 0 && !cancelTracker.Continue)
{
break;
}
}
}
}
if (_features != null)
{
_features.Clear();
_features = null;
}
}
public static IObservable <SymbolNotification> WhenNotification(this IAdsConnection client, ISymbolCollection symbols) => client.WhenNotification(symbols, NotificationSettings.Default);
public static IObservable <SymbolNotification> WhenNotification(this IAdsConnection client, ISymbolCollection symbols, NotificationSettings settings)
{
if (symbols == null)
{
throw new ArgumentNullException("symbols");
}
ISymbol local1 = Enumerable.FirstOrDefault <ISymbol>(symbols);
if (local1 == null)
{
throw new ArgumentOutOfRangeException("Symbols list is empty!", "symbols");
}
IValueSymbol symbol = local1 as IValueSymbol;
if (symbol == null)
{
throw new ArgumentOutOfRangeException("Symbols in list are not IValueSymbol", "symbols");
}
IAccessorValueFactory valueFactory = symbol.ValueAccessor.ValueFactory;
IDisposableSymbolHandleBag bag = null;
object userData = new object();
return(Observable.Where <SymbolNotification>(Observable.Select <EventPattern <AdsNotificationEventArgs>, SymbolNotification>(Observable.Where <EventPattern <AdsNotificationEventArgs> >(Observable.FromEventPattern <AdsNotificationEventHandler, AdsNotificationEventArgs>(delegate(AdsNotificationEventHandler h) {
client.AdsNotification += h;
bag = new DisposableNotificationHandleBag(client, symbols, settings, userData);
}, delegate(AdsNotificationEventHandler h) {
bag.Dispose();
bag = null;
client.AdsNotification -= h;
}), ev => bag.Contains((uint)ev.get_EventArgs().NotificationHandle)), ev => new SymbolNotification(ev.get_EventArgs(), bag.GetSymbol((uint)ev.get_EventArgs().NotificationHandle), valueFactory)), s => symbols.Contains(s.Symbol)));
}
public void FinishDrawing(IDisplay disp, ICancelTracker cancelTracker)
{
if (cancelTracker == null)
{
cancelTracker = new CancelTracker();
}
try
{
if (cancelTracker.Continue)
{
// also draw empty aggregates (a MUST for PoygonMask!!)
if (_aggregateGeometry == null)
{
_aggregateGeometry = new AggregateGeometry();
}
if (_symbol is ISymbolCollection)
{
ISymbolCollection sColl = (ISymbolCollection)_symbol;
foreach (ISymbolCollectionItem symbolItem in sColl.Symbols)
{
if (symbolItem.Visible == false || symbolItem.Symbol == null)
{
continue;
}
ISymbol symbol = symbolItem.Symbol;
if (symbol.SupportsGeometryType(geometryType.Aggregate))
{
disp.Draw(symbol, _aggregateGeometry);
}
else
{
for (int g = 0; g < _aggregateGeometry.GeometryCount; g++)
{
disp.Draw(symbol, _aggregateGeometry[g]);
}
}
}
}
else
{
if (_symbol.SupportsGeometryType(geometryType.Aggregate))
{
disp.Draw(_symbol, _aggregateGeometry);
}
else
{
for (int g = 0; g < _aggregateGeometry.GeometryCount; g++)
{
disp.Draw(_symbol, _aggregateGeometry[g]);
}
}
}
}
}
finally
{
_aggregateGeometry = null;
}
}