public static ILayer OpenAnnotationLayer(IFeatureClass pfc)
{
IFDOGraphicsLayerFactory pfdof = new FDOGraphicsLayerFactoryClass();
IFeatureDataset pFDS = pfc.FeatureDataset;
IWorkspace pWS = pFDS.Workspace;
IFeatureWorkspace pFWS = pWS as IFeatureWorkspace;
ILayer pLayer = pfdof.OpenGraphicsLayer(pFWS, pFDS, (pfc as IDataset).Name);
return(pLayer);
}
public static IAnnotationLayer GetAnnotationLayer(IFeatureWorkspace featWrk, IFeatureDataset featDS, string annolayerName)
{
IAnnotationLayer annoLayer = null;
try
{
IAnnotationLayerFactory annoLayerFact = new FDOGraphicsLayerFactoryClass();
annoLayer = annoLayerFact.OpenAnnotationLayer(featWrk, featDS, annolayerName);
}
catch (Exception ex)
{
LOG.Error(ex);
return(null);
}
return(annoLayer);
}
public IFeatureLayer AddFeatureClassToMap(string layerName)
{
IFeatureWorkspace feaWorkSpace = this.m_workSpace as IFeatureWorkspace;
IFeatureClass featClass = feaWorkSpace.OpenFeatureClass(layerName);
if (featClass.FeatureType == esriFeatureType.esriFTAnnotation)
{
IDataset dataSet = featClass as IDataset;
IFDOGraphicsLayerFactory pGLF = new FDOGraphicsLayerFactoryClass();
IFDOGraphicsLayer pFDOGLayer = pGLF.OpenGraphicsLayer((IFeatureWorkspace)dataSet.Workspace, featClass.FeatureDataset, dataSet.Name) as IFDOGraphicsLayer;
((IFeatureLayer)pFDOGLayer).Name = layerName;
return((IFeatureLayer)pFDOGLayer);
}
else
{
IFeatureLayer feaLyr = new FeatureLayerClass();
feaLyr.FeatureClass = featClass;
feaLyr.Name = layerName;
return(feaLyr);
}
}
public void AppendAnnoElementsSDE(IFeatureClass pSrcFClass, IFeatureClass pTargetFClass)
{
try
{
IFields pOFlds;
IFields pIFlds;
pOFlds = pTargetFClass.Fields;
pIFlds = pSrcFClass.Fields;
IField pFld;
int[] lSrcFlds;
int[] lTrgFlds;
IDataset pDataset;
int lFld, lExFld, i;
lExFld = 0;
for (lFld = 0; lFld < pIFlds.FieldCount; lFld++)
{
pFld = pIFlds.get_Field(lFld);
if (pFld.Type != esriFieldType.esriFieldTypeOID && pFld.Type != esriFieldType.esriFieldTypeGeometry && pFld.Name.ToUpper() != "ELEMENT"
&& pFld.Name.ToUpper() != "ANNOTATIONCLASSID" && pFld.Name.ToUpper() != "ZORDER" && pFld.Editable)
{
lExFld++;
}
}
lSrcFlds = new int[lExFld];
lTrgFlds = new int[lExFld];
i = 0;
for (lFld = 0; lFld < pIFlds.FieldCount; lFld++)
{
pFld = pIFlds.get_Field(lFld);
if (pFld.Type != esriFieldType.esriFieldTypeOID && pFld.Type != esriFieldType.esriFieldTypeGeometry && pFld.Name.ToUpper() != "ELEMENT"
&& pFld.Name.ToUpper() != "ANNOTATIONCLASSID" && pFld.Name.ToUpper() != "ZORDER" && pFld.Editable)
{
lSrcFlds[i] = lFld;
lTrgFlds[i] = pOFlds.FindField(pFld.Name);
i++;
}
}
IFeatureCursor pICursor;
pICursor = pSrcFClass.Search(null, false);
IFeature pIFeat;
pIFeat = pICursor.NextFeature();
IFDOGraphicsLayerFactory pGLF;
pGLF = new FDOGraphicsLayerFactoryClass();
pDataset = pTargetFClass as IDataset;
IFDOGraphicsLayer pFDOGLayer;
pFDOGLayer = pGLF.OpenGraphicsLayer((IFeatureWorkspace)pDataset.Workspace, pTargetFClass.FeatureDataset, pDataset.Name) as IFDOGraphicsLayer;
IFDOAttributeConversion pFDOACon;
pFDOACon = pFDOGLayer as IFDOAttributeConversion; ;
pFDOGLayer.BeginAddElements();
pFDOACon.SetupAttributeConversion2(lExFld, lSrcFlds, lTrgFlds);
IAnnotationFeature pAnnoFeature;
IClone pAClone;
IElement pGSElement;
while (pIFeat != null)
{
pAnnoFeature = pIFeat as IAnnotationFeature;
pAClone = pAnnoFeature.Annotation as IClone;
pGSElement = pAClone.Clone() as IElement;
pFDOGLayer.DoAddFeature(pIFeat, pGSElement, 0);
pIFeat = pICursor.NextFeature();
}
pFDOGLayer.EndAddElements();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public void AppendAnnoElements(ILayer pSrcLayer, IFeatureClass pTargetFC,IActiveView activeview)
{
//首先从cad的注记层得到一个注记，然后得到他的Annotation，再赋给新建的要素
//IQueryFilter queryfilter = new QueryFilterClass();
//queryfilter.WhereClause = "Layer = '" + filter + "'";
try
{
IFeatureLayer pSrcFLayer = pSrcLayer as IFeatureLayer;
IFeatureClass pSrcFC = pSrcFLayer.FeatureClass;
IFeature cadFeat;
IElement featElement;
IDataset pDataset;
pDataset = pTargetFC as IDataset;
IFDOGraphicsLayer pFDOGLayer;
IFDOGraphicsLayerFactory pGLF = new FDOGraphicsLayerFactoryClass();
ICoverageAnnotationLayer pCadAnnoLayer;
pCadAnnoLayer = pSrcLayer as ICoverageAnnotationLayer;
IWorkspace pWorkspace = pDataset.Workspace as IWorkspace;
IWorkspaceEdit pWorkspaceEdit = pWorkspace as IWorkspaceEdit;
IScreenDisplay screendis = activeview.ScreenDisplay;
pFDOGLayer = pGLF.OpenGraphicsLayer((IFeatureWorkspace)pDataset.Workspace, pTargetFC.FeatureDataset, pDataset.Name) as IFDOGraphicsLayer;
pCadAnnoLayer.StartGeneratingGraphics(null, screendis, false);
pCadAnnoLayer.NextFeatureAndGraphic(out cadFeat, out featElement);
//IFeature newFeature;
IFeature cadFeature;
IAnnotationFeature pAnnoFeature;
IPolygon poly = new PolygonClass();
//IEnvelope box;
pWorkspaceEdit.StartEditing(false);
pWorkspaceEdit.StartEditOperation();
//int index;
//pFDOGLayer.BeginAddElements();
int count = 0;
//pstepro.StepValue = 1;
IFeatureBuffer featbuffer = pTargetFC.CreateFeatureBuffer();
IFeatureCursor featCur = pTargetFC.Insert(true);
while (cadFeat != null && featElement != null)
{
//pFDOGLayer.DoAddFeature(cadFeat, featElement, 0);
//判断分在那一个层
count++;
//pstepro.Position = count;//进度条增加
cadFeature = pSrcFC.GetFeature(cadFeat.OID);
//if (cadFeature.get_Value(cadFeature.Fields.FindField("Layer")).ToString() != filter)
//{
// pCadAnnoLayer.NextFeatureAndGraphic(out cadFeat, out featElement);
// continue;
//}
//newFeature = pTargetFC.CreateFeature();
poly = cadFeat.ShapeCopy as IPolygon;
featbuffer.Shape = poly as IGeometry;
pAnnoFeature = featbuffer as IAnnotationFeature;
pAnnoFeature.Annotation = featElement;
int index1 = getLayerIndex(cadFeature.get_Value(cadFeature.Fields.FindField("Layer")).ToString());
featbuffer.set_Value(4, index1);
featCur.InsertFeature(featbuffer);
//newFeature.Store();
///////////////
pCadAnnoLayer.NextFeatureAndGraphic(out cadFeat, out featElement);
}
featCur.Flush();
//pFDOGLayer.EndAddElements();
pWorkspaceEdit.StopEditOperation();
pWorkspaceEdit.StopEditing(true);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public IFeatureLayer AddFeatureClassToMap(string layerName)
{
IFeatureWorkspace feaWorkSpace = this.m_workSpace as IFeatureWorkspace;
IFeatureClass featClass = feaWorkSpace.OpenFeatureClass(layerName);
if (featClass.FeatureType == esriFeatureType.esriFTAnnotation)
{
IDataset dataSet = featClass as IDataset;
IFDOGraphicsLayerFactory pGLF = new FDOGraphicsLayerFactoryClass();
IFDOGraphicsLayer pFDOGLayer = pGLF.OpenGraphicsLayer((IFeatureWorkspace)dataSet.Workspace, featClass.FeatureDataset, dataSet.Name) as IFDOGraphicsLayer;
((IFeatureLayer)pFDOGLayer).Name = layerName;
return (IFeatureLayer)pFDOGLayer;
}
else
{
IFeatureLayer feaLyr = new FeatureLayerClass();
feaLyr.FeatureClass = featClass;
feaLyr.Name = layerName;
return feaLyr;
}
}
public IFeatureClass CreateStandardAnnotationClass(
IFeatureWorkspace featureWorkspace,
IFeatureDataset featureDataset,
String className,
ISpatialReference spatialReference,
double referenceScale,
esriUnits referenceScaleUnits,
String configKeyword
)
{
// Create an annotation class and provide it with a name.
ILabelEngineLayerProperties labelEngineLayerProperties = new
LabelEngineLayerPropertiesClass();
IAnnotateLayerProperties annotateLayerProperties = (IAnnotateLayerProperties)
labelEngineLayerProperties;
annotateLayerProperties.Class = className;
// Get the symbol from the annotation class. Make any changes to its properties
// here.
ITextSymbol annotationTextSymbol = labelEngineLayerProperties.Symbol;
ISymbol annotationSymbol = (ISymbol)annotationTextSymbol;
// Create a symbol collection and add the default symbol from the
// annotation class to the collection. Assign the resulting symbol ID
// to the annotation class.
ISymbolCollection symbolCollection = new SymbolCollectionClass();
ISymbolCollection2 symbolCollection2 = (ISymbolCollection2)symbolCollection;
ISymbolIdentifier2 symbolIdentifier2 = null;
symbolCollection2.AddSymbol(annotationSymbol, className, out symbolIdentifier2);
labelEngineLayerProperties.SymbolID = symbolIdentifier2.ID;
// Add the annotation class to a collection.
IAnnotateLayerPropertiesCollection annotateLayerPropsCollection = new
AnnotateLayerPropertiesCollectionClass();
annotateLayerPropsCollection.Add(annotateLayerProperties);
// Create a graphics layer scale object.
IGraphicsLayerScale graphicsLayerScale = new GraphicsLayerScaleClass();
graphicsLayerScale.ReferenceScale = referenceScale;
graphicsLayerScale.Units = referenceScaleUnits;
// Create the overposter properties for the standard label engine.
IOverposterProperties overposterProperties = new BasicOverposterPropertiesClass()
;
// Instantiate a class description object.
//IObjectClassDescription ocDescription = new
// AnnotationFeatureClassDescriptionClass();
//IFeatureClassDescription fcDescription = (IFeatureClassDescription)ocDescription;
//// Get the shape field from the class description's required fields.
//IFields requiredFields = ocDescription.RequiredFields;
//int shapeFieldIndex = requiredFields.FindField(fcDescription.ShapeFieldName);
//IField shapeField = requiredFields.get_Field(shapeFieldIndex);
IFeatureLayer layer = (IFeatureLayer)mLayer;
IFields fields = layer.FeatureClass.Fields;
IField shapeField = fields.Field[fields.FindField(mField)];
IGeometryDef geometryDef = shapeField.GeometryDef;
IGeometryDefEdit geometryDefEdit = (IGeometryDefEdit)geometryDef;
geometryDefEdit.SpatialReference_2 = spatialReference;
// Create the annotation layer factory.
IAnnotationLayerFactory annotationLayerFactory = new
FDOGraphicsLayerFactoryClass();
// Create the annotation feature class and an annotation layer for it.
IAnnotationLayer annotationLayer = annotationLayerFactory.CreateAnnotationLayer
(featureWorkspace, featureDataset, className, geometryDef, null,
annotateLayerPropsCollection, graphicsLayerScale, symbolCollection, false,
false, false, true, overposterProperties, configKeyword);
// Get the feature class from the feature layer.
IFeatureLayer featureLayer = (IFeatureLayer)annotationLayer;
IFeatureClass featureClass = featureLayer.FeatureClass;
return(featureClass);
}
private void method_3(object object_0)
{
frmOpenFile file = new frmOpenFile
{
Text = "添加数据",
AllowMultiSelect = true
};
file.AddFilter(new MyGxFilterDatasets(), true);
if (file.DoModalOpen() == DialogResult.OK)
{
IFeatureClass featureClass;
IFeatureLayer layer;
System.Windows.Forms.Cursor.Current = Cursors.WaitCursor;
IArray array = new ArrayClass();
IArray items = file.Items;
int index = 0;
while (true)
{
if (index >= items.Count)
{
break;
}
IGxDataset dataset = items.get_Element(index) as IGxDataset;
if (dataset != null)
{
IDataset dataset2 = dataset.Dataset;
if (dataset2 != null)
{
if (dataset2.Type == esriDatasetType.esriDTFeatureClass)
{
featureClass = (IFeatureClass)dataset2;
if (featureClass.FeatureType == esriFeatureType.esriFTAnnotation)
{
layer = new FDOGraphicsLayerClass
{
FeatureClass = featureClass,
Name = featureClass.AliasName
};
}
else
{
layer = new FeatureLayerClass
{
FeatureClass = featureClass,
Name = featureClass.AliasName
};
}
array.Add(layer);
}
else
{
IFDOGraphicsLayerFactory factory;
if (dataset2.Type == esriDatasetType.esriDTCadDrawing)
{
IEnumGxObject children = (dataset as IGxObjectContainer).Children;
children.Reset();
for (IGxDataset dataset3 = children.Next() as IGxDataset;
dataset3 != null;
dataset3 = children.Next() as IGxDataset)
{
featureClass = dataset3.Dataset as IFeatureClass;
if (featureClass.FeatureType == esriFeatureType.esriFTAnnotation)
{
factory = new FDOGraphicsLayerFactoryClass();
layer =
(IFeatureLayer)
factory.OpenGraphicsLayer(
(IFeatureWorkspace)featureClass.FeatureDataset.Workspace,
featureClass.FeatureDataset, featureClass.AliasName);
}
else
{
layer = new FeatureLayerClass
{
FeatureClass = featureClass,
Name = featureClass.AliasName
};
}
array.Add(layer);
}
}
else if (dataset2.Type == esriDatasetType.esriDTFeatureDataset)
{
IFeatureClassContainer container = (IFeatureClassContainer)dataset2;
index = 0;
while (index < (container.ClassCount - 1))
{
featureClass = container.get_Class(index);
if (featureClass.FeatureType == esriFeatureType.esriFTAnnotation)
{
factory = new FDOGraphicsLayerFactoryClass();
layer =
(IFeatureLayer)
factory.OpenGraphicsLayer(
(IFeatureWorkspace)featureClass.FeatureDataset.Workspace,
featureClass.FeatureDataset, featureClass.AliasName);
}
else
{
layer = new FeatureLayerClass
{
FeatureClass = featureClass,
Name = featureClass.AliasName
};
}
array.Add(layer);
index++;
}
}
else if (dataset2.Type == esriDatasetType.esriDTTin)
{
ITinLayer unk = new TinLayerClass
{
Dataset = (ITin)dataset2,
Name = dataset2.Name
};
array.Add(unk);
}
else if ((dataset2.Type == esriDatasetType.esriDTRasterDataset) ||
(dataset2.Type == esriDatasetType.esriDTRasterBand))
{
bool flag = true;
if (!((IRasterPyramid)dataset2).Present)
{
if (ApplicationRef.PyramidPromptType == PyramidPromptType.AlwaysBuildNoPrompt)
{
((IRasterPyramid)dataset2).Create();
}
else if (ApplicationRef.PyramidPromptType == PyramidPromptType.AlwaysPrompt)
{
switch (BuildPyramidSet.Show())
{
case DialogResult.Yes:
((IRasterPyramid)dataset2).Create();
break;
case DialogResult.Cancel:
flag = false;
break;
}
}
}
if (flag)
{
RasterLayerClass class3 = new RasterLayerClass
{
Cached = true
};
IRasterLayer layer3 = class3;
layer3.CreateFromDataset((IRasterDataset)dataset2);
layer3.Name = dataset2.Name;
array.Add(layer3);
}
}
else if (dataset2.Type == esriDatasetType.esriDTTable)
{
try
{
IRasterCatalogTable pCatalog = new RasterCatalogTableClass
{
Table = (ITable)dataset2
};
pCatalog.Update();
IRasterCatalogLayer layer4 = new RasterCatalogLayerClass();
layer4.Create(pCatalog);
layer4.Name = dataset2.BrowseName;
array.Add(layer4);
}
catch
{
}
}
}
}
}
index++;
}
int count = array.Count;
ILayer layer5 = null;
for (index = count - 1; index >= 0; index--)
{
layer5 = array.get_Element(index) as ILayer;
if (layer5 is IRasterCatalogLayer)
{
if (object_0 is IMap)
{
(object_0 as IMap).AddLayer(layer5);
}
else if (object_0 is IGroupLayer)
{
(object_0 as IGroupLayer).Add(layer5);
}
array.Remove(index);
count--;
}
}
for (index = count - 1; index >= 0; index--)
{
layer5 = array.get_Element(index) as ILayer;
if (layer5 is IRasterLayer)
{
if (object_0 is IMap)
{
(object_0 as IMap).AddLayer(layer5);
}
else if (object_0 is IGroupLayer)
{
(object_0 as IGroupLayer).Add(layer5);
}
array.Remove(index);
count--;
}
}
for (index = count - 1; index >= 0; index--)
{
layer5 = array.get_Element(index) as ILayer;
if (layer5 is ITinLayer)
{
if (object_0 is IMap)
{
(object_0 as IMap).AddLayer(layer5);
}
else if (object_0 is IGroupLayer)
{
(object_0 as IGroupLayer).Add(layer5);
}
array.Remove(index);
count--;
}
}
for (index = count - 1; index >= 0; index--)
{
layer5 = array.get_Element(index) as ILayer;
if (layer5 is IFeatureLayer)
{
layer = layer5 as IFeatureLayer;
featureClass = layer.FeatureClass;
if ((featureClass.ShapeType == esriGeometryType.esriGeometryPolygon) ||
(featureClass.ShapeType == esriGeometryType.esriGeometryEnvelope))
{
if (object_0 is IMap)
{
(object_0 as IMap).AddLayer(layer5);
}
else if (object_0 is IGroupLayer)
{
(object_0 as IGroupLayer).Add(layer5);
}
array.Remove(index);
count--;
}
}
}
for (index = count - 1; index >= 0; index--)
{
layer5 = array.get_Element(index) as ILayer;
if (layer5 is IFeatureLayer)
{
layer = layer5 as IFeatureLayer;
featureClass = layer.FeatureClass;
if (((((featureClass.ShapeType == esriGeometryType.esriGeometryLine) ||
(featureClass.ShapeType == esriGeometryType.esriGeometryBezier3Curve)) ||
((featureClass.ShapeType == esriGeometryType.esriGeometryCircularArc) ||
(featureClass.ShapeType == esriGeometryType.esriGeometryEllipticArc))) ||
(featureClass.ShapeType == esriGeometryType.esriGeometryPath)) ||
(featureClass.ShapeType == esriGeometryType.esriGeometryPolyline))
{
if (object_0 is IMap)
{
(object_0 as IMap).AddLayer(layer5);
}
else if (object_0 is IGroupLayer)
{
(object_0 as IGroupLayer).Add(layer5);
}
array.Remove(index);
count--;
}
}
}
for (index = count - 1; index >= 0; index--)
{
layer5 = array.get_Element(index) as ILayer;
if (layer5 is IFeatureLayer)
{
layer = layer5 as IFeatureLayer;
featureClass = layer.FeatureClass;
if ((featureClass.ShapeType == esriGeometryType.esriGeometryMultipoint) ||
(featureClass.ShapeType == esriGeometryType.esriGeometryPoint))
{
if (object_0 is IMap)
{
(object_0 as IMap).AddLayer(layer5);
}
else if (object_0 is IGroupLayer)
{
(object_0 as IGroupLayer).Add(layer5);
}
array.Remove(index);
count--;
}
}
}
for (index = count - 1; index >= 0; index--)
{
layer5 = array.get_Element(index) as ILayer;
if (object_0 is IMap)
{
(object_0 as IMap).AddLayer(layer5);
}
else if (object_0 is IGroupLayer)
{
(object_0 as IGroupLayer).Add(layer5);
}
array.Remove(index);
}
System.Windows.Forms.Cursor.Current = Cursors.Default;
}
}
private void m_barManager1_ItemClick(object sender, ItemClickEventArgs e)
{
double mapScale = 0.0;
TOCTreeNode selectedNode = this.m_pTOCTreeView.SelectedNode;
if (selectedNode != null)
{
TOCTreeNode node2;
if ((selectedNode.TOCNodeType == NodeType.Map) || (selectedNode.TOCNodeType == NodeType.MapFrame))
{
node2 = selectedNode;
}
else
{
node2 = this.FindMapNodeByNode(selectedNode);
}
if (node2 != null)
{
IBasicMap tag = null;
if (node2.Tag is IBasicMap)
{
tag = node2.Tag as IBasicMap;
}
else
{
tag = (node2.Tag as IMapFrame).Map as IBasicMap;
}
try
{
if (tag is IMap)
{
mapScale = (tag as IMap).MapScale;
}
}
catch
{
}
switch (e.Item.Name)
{
case "SetMinimumScale":
(selectedNode.Tag as ILayer).MinimumScale = mapScale;
break;
case "SetMaximumScale":
(selectedNode.Tag as ILayer).MaximumScale = mapScale;
break;
case "ClearScaleRange":
(selectedNode.Tag as ILayer).MinimumScale = 0.0;
(selectedNode.Tag as ILayer).MaximumScale = 0.0;
(tag as IActiveView).Refresh();
break;
case "ZoomToLayer":
if ((selectedNode.Tag as ILayer).AreaOfInterest != null)
{
(tag as IActiveView).Extent = (selectedNode.Tag as ILayer).AreaOfInterest;
(tag as IActiveView).Refresh();
}
break;
case "LabelFeature":
{
IGeoFeatureLayer data = selectedNode.Tag as IGeoFeatureLayer;
if (data != null)
{
data.DisplayAnnotation = !data.DisplayAnnotation;
(tag as IActiveView).PartialRefresh(esriViewDrawPhase.esriViewGeography, data, null);
}
break;
}
case "LabelToAnno":
{
IFeatureLayer layer2 = selectedNode.Tag as IFeatureLayer;
if (layer2 != null)
{
IFeatureWorkspace workspace =
(layer2.FeatureClass as IDataset).Workspace as IFeatureWorkspace;
IFDOGraphicsLayerFactory factory = new FDOGraphicsLayerFactoryClass();
}
break;
}
case "OpenAttributeTable":
{
ITable table = selectedNode.Tag as ITable;
if (table != null)
{
new frmAttributeTable {
Table = table, Map = tag
}.Show();
}
break;
}
case "AddLayer":
if (selectedNode.TOCNodeType != NodeType.GroupLayer)
{
if (selectedNode.TOCNodeType == NodeType.Map)
{
this.m_pTOCTreeView.Invalidate();
}
else if (selectedNode.TOCNodeType == NodeType.MapFrame)
{
this.m_pTOCTreeView.Invalidate();
}
break;
}
this.m_pTOCTreeView.Invalidate();
break;
case "DeleteLayer":
this.DoDeleteLayer(selectedNode);
break;
case "LayerProperty":
this.DoLayerProperty(selectedNode);
break;
case "MapFrameProperty":
this.DoMapFrameProperty(selectedNode);
break;
case "ExportLayer":
{
frmExportMap map2 = new frmExportMap
{
ActiveView = tag as IActiveView,
Layer = selectedNode.Tag as ILayer
};
map2.ShowDialog();
break;
}
case "ExportMap":
new frmExportMap {
ActiveView = tag as IActiveView
}.ShowDialog();
break;
}
}
}
}
private void method_3(IMap imap_1, ILayer ilayer_0, string string_0, double double_1, IWorkspace iworkspace_1,
bool bool_0, bool bool_1, esriLabelWhichFeatures esriLabelWhichFeatures_1)
{
if ((iworkspace_1.Type != esriWorkspaceType.esriFileSystemWorkspace) && (ilayer_0 is IGeoFeatureLayer))
{
int num;
IAnnotateLayerProperties properties;
IElementCollection elements;
IElementCollection elements2;
ILabelEngineLayerProperties2 properties2;
IAnnotationLayer layer2;
IGeoFeatureLayer layer = ilayer_0 as IGeoFeatureLayer;
IFeatureClass featureClass = layer.FeatureClass;
IAnnotationLayerFactory factory = new FDOGraphicsLayerFactoryClass();
ISymbolCollection2 lcs = new SymbolCollectionClass();
IAnnotateLayerPropertiesCollection propertiess = new AnnotateLayerPropertiesCollectionClass();
IAnnotateLayerPropertiesCollection annotationProperties = layer.AnnotationProperties;
for (num = 0; num < annotationProperties.Count; num++)
{
annotationProperties.QueryItem(num, out properties, out elements, out elements2);
if (properties != null)
{
ISymbolIdentifier2 identifier;
propertiess.Add(properties);
properties2 = properties as ILabelEngineLayerProperties2;
IClone symbol = properties2.Symbol as IClone;
lcs.AddSymbol(symbol.Clone() as ISymbol, properties.Class + " " + num.ToString(), out identifier);
properties2.SymbolID = identifier.ID;
}
}
properties = null;
properties2 = null;
IGraphicsLayerScale scale = new GraphicsLayerScaleClass
{
ReferenceScale = double_1,
Units = imap_1.MapUnits
};
IFeatureClassDescription description = new AnnotationFeatureClassDescriptionClass();
IObjectClassDescription description2 = description as IObjectClassDescription;
IFields requiredFields = description2.RequiredFields;
IGeometryDefEdit geometryDef =
requiredFields.get_Field(requiredFields.FindField(description.ShapeFieldName)).GeometryDef as
IGeometryDefEdit;
IGeoDataset dataset = featureClass as IGeoDataset;
geometryDef.SpatialReference_2 = dataset.SpatialReference;
IMapOverposter overposter = imap_1 as IMapOverposter;
IOverposterProperties overposterProperties = overposter.OverposterProperties;
if (bool_1)
{
this.method_2(iworkspace_1 as IFeatureWorkspaceAnno, featureClass.FeatureDataset, featureClass,
scale.ReferenceScale, scale.Units, propertiess, lcs as ISymbolCollection, string_0);
layer2 = factory.OpenAnnotationLayer(iworkspace_1 as IFeatureWorkspace, featureClass.FeatureDataset,
string_0);
}
else
{
this.method_2(iworkspace_1 as IFeatureWorkspaceAnno, featureClass.FeatureDataset, null,
scale.ReferenceScale, scale.Units, propertiess, lcs as ISymbolCollection, string_0);
layer2 = factory.OpenAnnotationLayer(iworkspace_1 as IFeatureWorkspace, featureClass.FeatureDataset,
string_0);
}
IActiveView view = imap_1 as IActiveView;
IScreenDisplay screenDisplay = view.ScreenDisplay;
(layer2 as IGraphicsLayer).Activate(screenDisplay);
for (num = 0; num < propertiess.Count; num++)
{
propertiess.QueryItem(num, out properties, out elements, out elements2);
if (properties != null)
{
properties.FeatureLayer = layer;
properties.GraphicsContainer = layer2 as IGraphicsContainer;
properties.AddUnplacedToGraphicsContainer = bool_0;
properties.CreateUnplacedElements = true;
properties.DisplayAnnotation = true;
properties.FeatureLinked = bool_1;
properties.LabelWhichFeatures = esriLabelWhichFeatures_1;
properties.UseOutput = true;
properties2 = properties as ILabelEngineLayerProperties2;
properties2.SymbolID = num;
properties2.AnnotationClassID = num;
IOverposterLayerProperties2 overposterLayerProperties =
properties2.OverposterLayerProperties as IOverposterLayerProperties2;
overposterLayerProperties.TagUnplaced = true;
}
}
propertiess.Sort();
IAnnotateMapProperties annoMapCmdProps = new AnnotateMapPropertiesClass
{
AnnotateLayerPropertiesCollection = propertiess
};
ITrackCancel trackCancel = new CancelTrackerClass();
(imap_1.AnnotationEngine as IAnnotateMap2).Label(overposterProperties, annoMapCmdProps, imap_1,
trackCancel);
for (num = 0; num < propertiess.Count; num++)
{
propertiess.QueryItem(num, out properties, out elements, out elements2);
if (properties != null)
{
properties.FeatureLayer = null;
}
}
imap_1.AddLayer(layer2 as ILayer);
layer.DisplayAnnotation = false;
view.Refresh();
}
}
public static ILayer OpenAnnotationLayer(IFeatureClass pfc)
{
IFDOGraphicsLayerFactory pfdof = new FDOGraphicsLayerFactoryClass();
IFeatureDataset pFDS = pfc.FeatureDataset;
IWorkspace pWS = pFDS.Workspace;
IFeatureWorkspace pFWS = pWS as IFeatureWorkspace;
ILayer pLayer = pfdof.OpenGraphicsLayer(pFWS, pFDS, (pfc as IDataset).Name);
return pLayer;
}
public void AppendAnnoElementsSDE(IFeatureClass pSrcFClass, IFeatureClass pTargetFClass)
{
try
{
IFields pOFlds;
IFields pIFlds;
pOFlds = pTargetFClass.Fields;
pIFlds = pSrcFClass.Fields;
IField pFld;
int[] lSrcFlds;
int[] lTrgFlds;
IDataset pDataset;
int lFld, lExFld, i;
lExFld = 0;
for (lFld = 0; lFld < pIFlds.FieldCount; lFld++)
{
pFld = pIFlds.get_Field(lFld);
if (pFld.Type != esriFieldType.esriFieldTypeOID && pFld.Type != esriFieldType.esriFieldTypeGeometry && pFld.Name.ToUpper() != "ELEMENT" &&
pFld.Name.ToUpper() != "ANNOTATIONCLASSID" && pFld.Name.ToUpper() != "ZORDER" && pFld.Editable)
{
lExFld++;
}
}
lSrcFlds = new int[lExFld];
lTrgFlds = new int[lExFld];
i = 0;
for (lFld = 0; lFld < pIFlds.FieldCount; lFld++)
{
pFld = pIFlds.get_Field(lFld);
if (pFld.Type != esriFieldType.esriFieldTypeOID && pFld.Type != esriFieldType.esriFieldTypeGeometry && pFld.Name.ToUpper() != "ELEMENT" &&
pFld.Name.ToUpper() != "ANNOTATIONCLASSID" && pFld.Name.ToUpper() != "ZORDER" && pFld.Editable)
{
lSrcFlds[i] = lFld;
lTrgFlds[i] = pOFlds.FindField(pFld.Name);
i++;
}
}
IFeatureCursor pICursor;
pICursor = pSrcFClass.Search(null, false);
IFeature pIFeat;
pIFeat = pICursor.NextFeature();
IFDOGraphicsLayerFactory pGLF;
pGLF = new FDOGraphicsLayerFactoryClass();
pDataset = pTargetFClass as IDataset;
IFDOGraphicsLayer pFDOGLayer;
pFDOGLayer = pGLF.OpenGraphicsLayer((IFeatureWorkspace)pDataset.Workspace, pTargetFClass.FeatureDataset, pDataset.Name) as IFDOGraphicsLayer;
IFDOAttributeConversion pFDOACon;
pFDOACon = pFDOGLayer as IFDOAttributeConversion;;
pFDOGLayer.BeginAddElements();
pFDOACon.SetupAttributeConversion2(lExFld, lSrcFlds, lTrgFlds);
IAnnotationFeature pAnnoFeature;
IClone pAClone;
IElement pGSElement;
while (pIFeat != null)
{
pAnnoFeature = pIFeat as IAnnotationFeature;
pAClone = pAnnoFeature.Annotation as IClone;
pGSElement = pAClone.Clone() as IElement;
pFDOGLayer.DoAddFeature(pIFeat, pGSElement, 0);
pIFeat = pICursor.NextFeature();
}
pFDOGLayer.EndAddElements();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public void AppendAnnoElements(ILayer pSrcLayer, IFeatureClass pTargetFC, IActiveView activeview)
{
//首先从cad的注记层得到一个注记，然后得到他的Annotation，再赋给新建的要素
//IQueryFilter queryfilter = new QueryFilterClass();
//queryfilter.WhereClause = "Layer = '" + filter + "'";
try
{
IFeatureLayer pSrcFLayer = pSrcLayer as IFeatureLayer;
IFeatureClass pSrcFC = pSrcFLayer.FeatureClass;
IFeature cadFeat;
IElement featElement;
IDataset pDataset;
pDataset = pTargetFC as IDataset;
IFDOGraphicsLayer pFDOGLayer;
IFDOGraphicsLayerFactory pGLF = new FDOGraphicsLayerFactoryClass();
ICoverageAnnotationLayer pCadAnnoLayer;
pCadAnnoLayer = pSrcLayer as ICoverageAnnotationLayer;
IWorkspace pWorkspace = pDataset.Workspace as IWorkspace;
IWorkspaceEdit pWorkspaceEdit = pWorkspace as IWorkspaceEdit;
IScreenDisplay screendis = activeview.ScreenDisplay;
pFDOGLayer = pGLF.OpenGraphicsLayer((IFeatureWorkspace)pDataset.Workspace, pTargetFC.FeatureDataset, pDataset.Name) as IFDOGraphicsLayer;
pCadAnnoLayer.StartGeneratingGraphics(null, screendis, false);
pCadAnnoLayer.NextFeatureAndGraphic(out cadFeat, out featElement);
//IFeature newFeature;
IFeature cadFeature;
IAnnotationFeature pAnnoFeature;
IPolygon poly = new PolygonClass();
//IEnvelope box;
pWorkspaceEdit.StartEditing(false);
pWorkspaceEdit.StartEditOperation();
//int index;
//pFDOGLayer.BeginAddElements();
int count = 0;
//pstepro.StepValue = 1;
IFeatureBuffer featbuffer = pTargetFC.CreateFeatureBuffer();
IFeatureCursor featCur = pTargetFC.Insert(true);
while (cadFeat != null && featElement != null)
{
//pFDOGLayer.DoAddFeature(cadFeat, featElement, 0);
//判断分在那一个层
count++;
//pstepro.Position = count;//进度条增加
cadFeature = pSrcFC.GetFeature(cadFeat.OID);
//if (cadFeature.get_Value(cadFeature.Fields.FindField("Layer")).ToString() != filter)
//{
// pCadAnnoLayer.NextFeatureAndGraphic(out cadFeat, out featElement);
// continue;
//}
//newFeature = pTargetFC.CreateFeature();
poly = cadFeat.ShapeCopy as IPolygon;
featbuffer.Shape = poly as IGeometry;
pAnnoFeature = featbuffer as IAnnotationFeature;
pAnnoFeature.Annotation = featElement;
int index1 = getLayerIndex(cadFeature.get_Value(cadFeature.Fields.FindField("Layer")).ToString());
featbuffer.set_Value(4, index1);
featCur.InsertFeature(featbuffer);
//newFeature.Store();
///////////////
pCadAnnoLayer.NextFeatureAndGraphic(out cadFeat, out featElement);
}
featCur.Flush();
//pFDOGLayer.EndAddElements();
pWorkspaceEdit.StopEditOperation();
pWorkspaceEdit.StopEditing(true);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
