private void subclassCombo_CurrentChanged(object sender, RibbonPropertyChangedEventArgs e)
{
try
{
RibbonCombo ribbonCombo = sender as RibbonCombo;
RibbonLabel ribbonLabel = ribbonCombo.Current as RibbonLabel;
if (ribbonLabel != null)
{
FCTag fCTag = (FCTag)ribbonLabel.Tag;
if (fCTag != null)
{
AfaDocData.ActiveDocData.SetActiveFeatureClass(fCTag.GetFeatureClass(AfaDocData.ActiveDocData.DocDataset));
}
else
{
AfaDocData.ActiveDocData.ClearActiveSubtype();
}
}
}
catch
{
AfaDocData.ActiveDocData.ClearActiveSubtype();
MSCFeatureClass topActiveFeatureClass = AfaDocData.ActiveDocData.GetTopActiveFeatureClass();
ArcGISRibbon.SetFeatureClassButtonState(topActiveFeatureClass);
}
}
private void fcCombo_CurrentChanged(object sender, RibbonPropertyChangedEventArgs e)
{
try
{
RibbonCombo ribbonCombo = sender as RibbonCombo;
RibbonLabel ribbonLabel = ribbonCombo.Current as RibbonLabel;
if (ribbonLabel != null)
{
FCTag fCTag = (FCTag)ribbonLabel.Tag;
MSCFeatureClass featureClass = fCTag.GetFeatureClass(AfaDocData.ActiveDocData.DocDataset);
MSCFeatureClass topActiveFeatureClass = AfaDocData.ActiveDocData.GetTopActiveFeatureClass();
if (featureClass != topActiveFeatureClass)
{
AfaDocData.ActiveDocData.SetActiveFeatureClass(featureClass);
ArcGISRibbon.SetSubTypeComboToDefault(featureClass);
}
ArcGISRibbon.SetFeatureClassButtonState(AfaDocData.ActiveDocData.GetActiveFeatureClassOrSubtype());
}
}
catch
{
AfaDocData.ActiveDocData.ClearActiveFeatureClass();
ArcGISRibbon.ClearSubtypeCombo();
ArcGISRibbon.SetFeatureClassButtonState(AfaDocData.ActiveDocData.GetActiveFeatureClassOrSubtype());
}
}
public void TabView()
{
Editor editor = AfaDocData.ActiveDocData.DocDataset.ParentDocument.Editor;
try
{
try
{
int arg_25_0 = editor.SelectAll().Value.Count;
}
catch
{
editor.WriteMessage("\n" + AfaStrings.NoFeaturesFound);
return;
}
MSCFeatureClass activeFeatureClassOrSubtype = AfaDocData.ActiveDocData.GetActiveFeatureClassOrSubtype();
if (activeFeatureClassOrSubtype == null)
{
editor.WriteMessage("\n" + AfaStrings.NoCurrentFeatureClassFound);
}
else
{
TableView tableView = new TableView(activeFeatureClassOrSubtype);
Application.ShowModalDialog(Application.MainWindow.Handle, tableView, true);
tableView.Uninitialize();
tableView.Dispose();
}
}
catch
{
editor.WriteMessage("\nError");
}
}
private CadField CreateAttributeValue(MSCFeatureClass fc, string fieldName, object value)
{
CadField result;
try
{
CadField cadField = FeatureClassAPI.FindField(fc.Fields, fieldName);
if (cadField == null)
{
result = null;
}
else if (cadField.ReadOnly || !cadField.Visible)
{
result = null;
}
else
{
TypedValue value2 = CadField.CreateTypedValue(cadField.FieldType, value.ToString());
result = new CadField(cadField)
{
Value = value2
};
}
}
catch
{
result = null;
}
return(result);
}
private void OnRemoveAllFeatureClasses_Click(object sender, RoutedEventArgs e)
{
try
{
MSCDataset docDataset = AfaDocData.ActiveDocData.DocDataset;
if (docDataset.FeatureClasses.Count == 0)
{
AfaDocData.ActiveDocData.Document.Editor.WriteMessage(AfaStrings.NoFeatureClassesFound);
}
else
{
MSCFeatureClass[] array = docDataset.FeatureClasses.Values.ToArray <MSCFeatureClass>();
MSCFeatureClass[] array2 = array;
for (int i = 0; i < array2.Length; i++)
{
MSCFeatureClass fc = array2[i];
docDataset.RemoveFeatureClass(fc);
}
MSCDataset.SetDefaultActiveFeatureClass();
}
}
catch
{
MSCDataset.SetDefaultActiveFeatureClass();
}
}
private void FeatureClassCombo_DropDownOpened(object sender, EventArgs e)
{
RibbonCombo ribbonCombo = sender as RibbonCombo;
ribbonCombo.IsEditable = (false);
ribbonCombo.Items.Clear();
MSCFeatureClass topActiveFeatureClass = AfaDocData.ActiveDocData.GetTopActiveFeatureClass();
foreach (MSCFeatureClass current in AfaDocData.ActiveDocData.DocDataset.FeatureClasses.Values)
{
RibbonLabel ribbonLabel = new RibbonLabel();
ribbonLabel.Tag = (new FCTag(current));
ribbonLabel.Text = (current.Name);
ribbonCombo.Items.Add(ribbonLabel);
if (topActiveFeatureClass == current)
{
ribbonCombo.Current = (ribbonLabel);
}
}
foreach (MSCFeatureService current2 in AfaDocData.ActiveDocData.DocDataset.FeatureServices.Values)
{
RibbonLabel ribbonLabel2 = new RibbonLabel();
ribbonLabel2.Tag = (new FCTag(current2));
ribbonLabel2.Text = (current2.Name);
ribbonCombo.Items.Add(ribbonLabel2);
if (topActiveFeatureClass == current2)
{
ribbonCombo.Current = (ribbonLabel2);
}
}
}
private void subclassCombo_DropDownOpened(object sender, EventArgs e)
{
RibbonCombo ribbonCombo = sender as RibbonCombo;
ribbonCombo.IsEditable = (false);
ribbonCombo.Items.Clear();
MSCFeatureClass topActiveFeatureClass = AfaDocData.ActiveDocData.GetTopActiveFeatureClass();
MSCFeatureClass activeSubtype = AfaDocData.ActiveDocData.GetActiveSubtype();
if (topActiveFeatureClass != null)
{
if (topActiveFeatureClass.SubTypes != null && topActiveFeatureClass.SubTypes.Count > 0)
{
RibbonLabel ribbonLabel = new RibbonLabel();
ribbonLabel.Tag = (null);
ribbonLabel.Text = ("All Types");
ribbonCombo.Items.Add(ribbonLabel);
ribbonCombo.Current = (ribbonLabel);
}
foreach (MSCFeatureClass current in topActiveFeatureClass.SubTypes)
{
RibbonLabel ribbonLabel2 = new RibbonLabel();
ribbonLabel2.Tag = (new FCTag(current));
ribbonLabel2.Text = (current.Name);
ribbonCombo.Items.Add(ribbonLabel2);
if (activeSubtype == current)
{
ribbonCombo.Current = (ribbonLabel2);
}
}
}
}
public IdentifyFeatureClassItem(string name, MSCFeatureClass fc, ObjectIdCollection ids)
{
this.Name = name;
this.Tag = new FCTag(fc);
this.IDs = fc.GetFeatureIds(ids);
this.SubtypeItems = new List <Identify.IdentifyFeatureClassItem>();
}
private static List <Identify.IdentifyFeatureClassItem> BuildSubtypeItems(MSCFeatureClass fc, ObjectId[] ids)
{
List <Identify.IdentifyFeatureClassItem> list = new List <Identify.IdentifyFeatureClassItem>();
if (ids == null)
{
return(list);
}
if (ids.Length == 0)
{
return(list);
}
ObjectIdCollection ids2 = new ObjectIdCollection(ids);
if (fc.SubTypes.Count > 0)
{
list.Add(new Identify.IdentifyFeatureClassItem("<All Types>", fc, ids2)
{
IDs = ids
});
foreach (MSCFeatureClassSubType current in fc.SubTypes)
{
Identify.IdentifyFeatureClassItem identifyFeatureClassItem = new Identify.IdentifyFeatureClassItem(current, ids2);
if (identifyFeatureClassItem.IDs.Length > 0)
{
list.Add(identifyFeatureClassItem);
}
}
}
return(list);
}
private void PopulateFeatureClassPicker(MSCFeatureClass currentTopFC, MSCFeatureClass currentSubtype, ObjectIdCollection ids)
{
try
{
System.Windows.Forms.Application.UseWaitCursor = true;
Dictionary <string, Identify.IdentifyFeatureClassItem> featureClasses = Identify.GetFeatureClasses(ids);
this.FeatureClassComboBox.ItemsSource = featureClasses;
bool flag = false;
if (currentTopFC != null)
{
int num = 0;
foreach (KeyValuePair <string, Identify.IdentifyFeatureClassItem> current in featureClasses)
{
if (current.Value.Name == currentTopFC.Name)
{
this.FeatureClassComboBox.SelectedIndex = num;
flag = true;
break;
}
num++;
}
}
if (!flag)
{
this.FeatureClassComboBox.SelectedIndex = 0;
}
this.PopulateSubtypeClassPicker(((KeyValuePair <string, Identify.IdentifyFeatureClassItem>) this.FeatureClassComboBox.SelectedItem).Value, currentSubtype);
System.Windows.Forms.Application.UseWaitCursor = false;
}
catch (SystemException ex)
{
System.Windows.Forms.Application.UseWaitCursor = false;
string arg_BE_0 = ex.Message;
}
}
public object ESRI_GetCurrentFeatureClass(ResultBuffer rb)
{
object result;
try
{
MSCFeatureClass mSCFeatureClass = AfaDocData.ActiveDocData.GetActiveFeatureClassOrSubtype();
if (mSCFeatureClass.IsSubType)
{
mSCFeatureClass = mSCFeatureClass.ParentFC;
}
if (mSCFeatureClass.GetType() == typeof(MSCFeatureService))
{
result = null;
}
else
{
result = mSCFeatureClass.Name;
}
}
catch
{
result = null;
}
return(result);
}
private MSCFeatureClass GetFeatureClassOrService(string name, string subtypeName)
{
if (string.IsNullOrEmpty(name))
{
return(null);
}
MSCFeatureClass featureClassOrService = this.GetFeatureClassOrService(name);
if (featureClassOrService == null)
{
return(featureClassOrService);
}
if (string.IsNullOrEmpty(subtypeName))
{
return(featureClassOrService);
}
foreach (MSCFeatureClass current in featureClassOrService.SubTypes)
{
if (string.Equals(current.Name, subtypeName, StringComparison.CurrentCultureIgnoreCase))
{
return(current);
}
}
return(null);
}
public MSCFeatureClass GetFeatureClass(MSCDataset ds)
{
if (this.IsFeatureService)
{
MSCFeatureService result = null;
if (ds.FeatureServices.TryGetValue(this.fcName, out result))
{
return(result);
}
return(null);
}
else if (this.ParentTag == null)
{
MSCFeatureClass result2 = null;
if (ds.FeatureClasses.TryGetValue(this.fcName, out result2))
{
return(result2);
}
return(null);
}
else
{
if (this.ParentTag != null)
{
return(this.GetFeatureClass(ds, this.ParentTag));
}
return(null);
}
}
private void OnExtractAllFeatureServices_Click(object sender, RoutedEventArgs e)
{
try
{
MSCDataset docDataset = AfaDocData.ActiveDocData.DocDataset;
if (docDataset.FeatureServices.Count == 0)
{
AfaDocData.ActiveDocData.Document.Editor.WriteMessage(AfaStrings.NoFeatureServicesFound);
}
else
{
List <string> list = new List <string>();
foreach (MSCFeatureService current in docDataset.FeatureServices.Values)
{
string name = current.Name;
MSCFeatureClass mSCFeatureClass = current.Disconnect();
if (mSCFeatureClass != null)
{
list.Add(name);
}
}
foreach (string current2 in list)
{
docDataset.FeatureServices.Remove(current2);
}
MSCDataset.SetDefaultActiveFeatureClass();
ToolPalette.UpdatePalette(docDataset.ParentDocument, docDataset, false);
}
}
catch
{
}
}
public ObjectId[] featureClassChecker(MSCFeatureClass fc)
{
ObjectId[] result;
try
{
ResultBuffer fCQuery = fc.FCQuery;
SelectionFilter selectionFilter = new SelectionFilter(fCQuery.AsArray());
PromptSelectionResult promptSelectionResult = SingletonsList.ed.SelectAll(selectionFilter);
if (promptSelectionResult.Status == (PromptStatus)5100 && promptSelectionResult.Value.Count > 0)
{
ObjectId[] objectIds = promptSelectionResult.Value.GetObjectIds();
if (objectIds.Length != 0)
{
result = objectIds;
return(result);
}
}
result = null;
}
catch (Exception ex)
{
if (SingletonsList.ed != null)
{
SingletonsList.ed.WriteMessage("\n" + AfaStrings.Error + " " + ex.Message);
}
result = null;
}
return(result);
}
public object ESRI_GetSubtypeLayer(ResultBuffer rb)
{
object result;
try
{
string argument = LspUtil.GetArgument(rb, 0, null);
string argument2 = LspUtil.GetArgument(rb, 1, null);
if (string.IsNullOrEmpty(argument) || string.IsNullOrEmpty(argument2))
{
result = null;
}
else
{
MSCFeatureClass featureClassOrService = this.GetFeatureClassOrService(argument);
MSCFeatureClassSubType mSCFeatureClassSubType = featureClassOrService.FindSubtypeName(argument2);
result = mSCFeatureClassSubType.CadLayerName;
}
}
catch
{
result = null;
}
return(result);
}
public object ESRI_GetCurrentSubtypeName(ResultBuffer rb)
{
object result;
try
{
MSCFeatureClass activeFeatureClassOrSubtype = AfaDocData.ActiveDocData.GetActiveFeatureClassOrSubtype();
if (!activeFeatureClassOrSubtype.IsSubType)
{
result = null;
}
else if (activeFeatureClassOrSubtype.GetType() == typeof(MSCFeatureService))
{
result = null;
}
else
{
result = activeFeatureClassOrSubtype.Name;
}
}
catch
{
result = null;
}
return(result);
}
public IdentifyFeatureClassItem(MSCFeatureClass fc, ObjectIdCollection ids)
{
this.Name = fc.Name;
this.Tag = new FCTag(fc);
this.IDs = fc.GetFeatureIds(ids);
this.SubtypeItems = Identify.BuildSubtypeItems(fc, this.IDs);
}
public object ESRI_SetCurrentFeatureService(ResultBuffer rb)
{
object result;
try
{
TypedValue[] array = rb.AsArray();
if (array.Count <TypedValue>() < 1)
{
result = null;
}
else
{
TypedValue typedValue = array[0];
if (typedValue.TypeCode != 5005)
{
result = null;
}
else
{
string name = typedValue.Value.ToString();
MSCFeatureClass mSCFeatureClass = this.GetFeatureClassOrService(name);
if (mSCFeatureClass == null)
{
result = null;
}
else if (!(mSCFeatureClass is MSCFeatureService))
{
result = null;
}
else
{
if (array.Count <TypedValue>() > 1)
{
TypedValue typedValue2 = array[1];
if (typedValue2.TypeCode != 5005)
{
result = null;
return(result);
}
string stName = typedValue2.Value.ToString();
MSCFeatureClassSubType mSCFeatureClassSubType = mSCFeatureClass.FindSubtypeName(stName);
if (mSCFeatureClassSubType != null)
{
mSCFeatureClass = mSCFeatureClassSubType;
}
}
ArcGISRibbon.SetActiveFeatureClass(mSCFeatureClass);
result = mSCFeatureClass.Name;
}
}
}
}
catch
{
result = null;
}
return(result);
}
private void FillRows(ObjectIdCollection idCollection)
{
MSCFeatureClass activeFeatureClassOrSubtype = AfaDocData.ActiveDocData.GetActiveFeatureClassOrSubtype();
this.Table = activeFeatureClassOrSubtype.Identify(idCollection);
this.Table.Columns[this.name].ReadOnly = true;
this.dataGrid.ItemsSource = this.Table.DefaultView;
this.dataGrid.DataContext = this.Table;
}
public TempAttributeViewer(MSCFeatureClass fc)
{
this._FC = fc;
this._FieldData = fc.GetDataTable();
this.InitializeComponent();
this.dgTable.ItemsSource = this._FieldData.DefaultView;
this.dgTable.FrozenColumnCount = this._FieldData.Columns.Count;
this.dgTable.CanUserAddRows = false;
}
public FCView(MSCFeatureClass fc)
{
this.FC = new FCTag(fc);
this.SubTypes = new List <FCTag>();
foreach (MSCFeatureClass current in fc.SubTypes)
{
this.SubTypes.Add(new FCTag(current));
}
}
public object ESRI_FeatureClass_Get(ResultBuffer rb)
{
object result;
try
{
string argument = LspUtil.GetArgument(rb, 0, null);
MSCFeatureClass mSCFeatureClass;
if (!string.IsNullOrEmpty(argument))
{
mSCFeatureClass = this.GetFeatureClassOrService(argument);
}
else
{
mSCFeatureClass = this.GetCurrentFeatureClassOrService();
}
if (mSCFeatureClass == null)
{
result = null;
}
else
{
string argument2 = LspUtil.GetArgument(rb, 1, null);
if (argument2 != null)
{
mSCFeatureClass = mSCFeatureClass.FindSubtypeName(argument2);
}
if (mSCFeatureClass == null)
{
result = null;
}
else
{
List <TypedValue> list = new List <TypedValue>();
list.Add(new TypedValue(5016, null));
LspUtil.AppendDottedPair(ref list, "NAME", mSCFeatureClass.Name);
LspUtil.AppendDottedPair(ref list, "GEOMTYPE", MSCFeatureClass.GetGeomString(mSCFeatureClass.GeometryType));
if (!string.IsNullOrEmpty(mSCFeatureClass.TypeField))
{
LspUtil.AppendDottedPair(ref list, "TYPEFIELD", mSCFeatureClass.TypeField);
}
if (mSCFeatureClass.IsSingleLayerQuery())
{
LspUtil.AppendDottedPair(ref list, "CADLAYER", mSCFeatureClass.GetFirstLayerFromQuery());
}
list.Add(new TypedValue(5017, null));
ResultBuffer resultBuffer = new ResultBuffer(list.ToArray());
result = resultBuffer;
}
}
}
catch
{
result = null;
}
return(result);
}
public object ESRI_Attributes_Get(ResultBuffer rb)
{
object result;
try
{
ObjectId argument = LspUtil.GetArgument(rb, 0, ObjectId.Null);
if (argument == ObjectId.Null)
{
result = null;
}
else
{
string assocParam = LspUtil.GetAssocParam(rb, "FCNAME", null);
string assocParam2 = LspUtil.GetAssocParam(rb, "STNAME", null);
string fieldName = LspUtil.GetAssocParam(rb, "FIELDNAME", null);
MSCFeatureClass featureClass = this.GetFeatureClass(assocParam, assocParam2);
List <CadField> list;
if (featureClass == null)
{
list = CadField.EntityCadFields(argument);
}
else
{
list = featureClass.GetEntityFields(argument);
}
if (!string.IsNullOrEmpty(fieldName))
{
list = (from x in list
where x.Name == fieldName
select x).ToList <CadField>();
}
if (list.Count == 0)
{
result = null;
}
else
{
List <TypedValue> list2 = new List <TypedValue>();
list2.Add(new TypedValue(5016, null));
foreach (CadField current in list)
{
LspUtil.AppendDottedPair(ref list2, current.Name, current.Value.Value);
}
list2.Add(new TypedValue(5017, null));
ResultBuffer resultBuffer = new ResultBuffer(list2.ToArray());
result = resultBuffer;
}
}
}
catch
{
result = null;
}
return(result);
}
private MSCFeatureClass GetCurrentLocalFeatureClass()
{
MSCFeatureClass topActiveFeatureClass = AfaDocData.ActiveDocData.GetTopActiveFeatureClass();
if (topActiveFeatureClass is MSCFeatureService)
{
return(null);
}
return(topActiveFeatureClass);
}
protected override void Detach()
{
if (this.DocDataset != null)
{
this.DocDataset.Uninitialize();
this.CurrentFC = null;
this.NOD = ObjectId.Null;
this.DocPRJ = null;
}
}
private MSCFeatureClass GetSubtype(MSCFeatureClass fc, string subtypeName)
{
foreach (MSCFeatureClass current in fc.SubTypes)
{
if (current.Name == subtypeName)
{
return(current);
}
}
return(null);
}
private void SelectAndDelete()
{
MSCDataset docDataset = AfaDocData.ActiveDocData.DocDataset;
if (AfaDocData.ActiveDocData.DocDataset.FeatureClasses.ContainsKey("ESRI_Locations"))
{
MSCFeatureClass mSCFeatureClass = AfaDocData.ActiveDocData.DocDataset.FeatureClasses["ESRI_Locations"];
mSCFeatureClass.DeleteEntities();
docDataset.RemoveFeatureClass(mSCFeatureClass);
MSCDataset.SetDefaultActiveFeatureClass();
}
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
if (value is string)
{
return(value);
}
if (value is MSCFeatureClass.fcTypeCode || value is int)
{
return(MSCFeatureClass.GetTypeCodeString((MSCFeatureClass.fcTypeCode)value));
}
return(MSCFeatureClass.GetTypeCodeString(MSCFeatureClass.fcTypeCode.fcTypePoint));
}
public SelectByAttributesForm(bool launchedByTableViewer, MSCFeatureClass selectedFeatureClass)
{
if (selectedFeatureClass == null)
{
MessageBox.Show("Select a feature class first");
return;
}
this.InitializeComponent();
this.updateMethodsComboBox();
this.updateFeatureClassComboBox(selectedFeatureClass);
this.verifyButton.Enabled = false;
this.applyButton.Enabled = false;
}
