public static void CreatePaletteSchemesTest(Document doc, MSCDataset dataset)
{
ToolPaletteManager manager = ToolPaletteManager.Manager;
try
{
try
{
if (manager.Catalogs.Count > 0)
{
manager.SaveCatalogs();
}
}
catch
{
}
ToolPalette.InitializePaletteFolders();
ToolPalette.IncludeFolderLocation(ToolPalette.GroupFolder);
ToolPalette.CreatePaletteFile(doc, dataset);
if (!ToolPalette.GroupExists(doc))
{
ToolPalette.CreateGroup();
}
Scheme scheme = new Scheme("ArcGIS");
scheme.LoadCatalogs();
scheme.SaveCatalogs();
manager.Schemes.Add("ArcGIS");
}
catch
{
}
}
public void Refresh()
{
this.ClearActiveFeatureClass();
this.CurrentImageService = null;
this.CurrentMapService = null;
this.DocPRJ = null;
Document document = base.Document;
Database arg_28_0 = document.Database;
try
{
using (Transaction transaction = document.TransactionManager.StartTransaction())
{
this.DocPRJ = new MSCPrj();
this.DocPRJ.Initialize(this.NOD, transaction);
this.DocDataset.Initialize(document, transaction);
MSCDataset.SetDefaultActiveFeatureClass();
MSCDataset.SetDefaultActiveRasterServices();
document.TransactionManager.QueueForGraphicsFlush();
document.TransactionManager.FlushGraphics();
document.Editor.UpdateScreen();
transaction.Commit();
if (AfaDocData.ActiveDocData.DocDataset.HasFeatureServicesOpenedForEditing())
{
CmdLine.ExecuteQuietCommand("ESRI_UpdatePalette");
}
}
}
catch
{
ErrorReport.ShowErrorMessage(AfaStrings.ErrorInitializingGISDataset);
}
}
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 object ESRI_GetFeatureClassList(ResultBuffer rb)
{
object result;
try
{
MSCDataset docDataset = AfaDocData.ActiveDocData.DocDataset;
if (docDataset.FeatureClasses.Count > 0)
{
ResultBuffer resultBuffer = new ResultBuffer();
foreach (string current in docDataset.FeatureClasses.Keys)
{
resultBuffer.Add(new TypedValue(5005, current));
}
result = resultBuffer;
}
else
{
result = null;
}
}
catch
{
result = null;
}
return(result);
}
private MSCFeatureClass GetLocalFeatureClass(string name)
{
MSCFeatureClass result;
try
{
MSCDataset docDataset = AfaDocData.ActiveDocData.DocDataset;
if (docDataset.FeatureClasses.Count == 0)
{
result = null;
}
else
{
foreach (string current in docDataset.FeatureClasses.Keys)
{
if (string.Equals(current, name, StringComparison.CurrentCultureIgnoreCase))
{
result = docDataset.FeatureClasses[current];
return(result);
}
}
result = null;
}
}
catch
{
result = null;
}
return(result);
}
public static void GenerateBlockImages(Document doc, MSCDataset dataset)
{
try
{
ToolPalette.InitializePaletteFolders();
Database database = doc.Database;
using (doc.LockDocument())
{
using (Transaction transaction = database.TransactionManager.StartTransaction())
{
foreach (MSCFeatureService current in dataset.FeatureServices.Values)
{
if (!current.QueryOnly && current.GeometryType == MSCFeatureClass.fcTypeCode.fcTypePoint)
{
ObjectId blockDefinition = DocUtil.GetBlockDefinition(doc, current.LayerName);
if (!(blockDefinition == ObjectId.Null))
{
ToolPalette.CreateBlockImage(transaction, doc, ToolPalette.ImageFolder, blockDefinition);
}
}
}
transaction.Commit();
}
}
}
catch
{
}
}
private void OnRemoveAllFeatureServices_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;
if (current.DeleteService())
{
list.Add(name);
}
}
foreach (string current2 in list)
{
docDataset.FeatureServices.Remove(current2);
}
MSCDataset.SetDefaultActiveFeatureClass();
ArcGISRibbon.EnableFeatureServiceButtons(false);
}
}
catch
{
}
}
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 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();
}
}
public static void UpdatePalette(Document doc, MSCDataset dataset)
{
try
{
ToolPalette.CreatePalette(doc, dataset);
}
catch
{
}
}
public MSCMapService(Transaction t, MSCDataset parent, string name, ObjectId id)
{
base.ParentDataset = parent;
this.AcadDictionaryID = id;
base.Name = name;
this.Layers = new List <MSCMapLayer>();
this.Read(id, t);
this.UpdateForm = new HiddenUpdateForm(base.ParentDataset.ParentDocument);
base.CheckForUpdates();
base.StartReactors();
}
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 static void ShowPalette(Document doc, MSCDataset dataset)
{
try
{
ToolPalette.UpdatePalette(doc, dataset);
string cmdString = "(command \"tpnavigate\" \"ArcGIS Feature Services\")";
CmdLine.ExecuteQuietCommand(cmdString);
}
catch
{
}
}
public MSCFeatureClass GetFeatureClass(MSCDataset ds, FCTag parentTag)
{
MSCFeatureClass featureClass = parentTag.GetFeatureClass(ds);
foreach (MSCFeatureClass current in featureClass.SubTypes)
{
if (current.Name == this.fcName)
{
return(current);
}
}
return(null);
}
private void OnUpdateAllImageServices(object sender, RoutedEventArgs e)
{
try
{
MSCDataset docDataset = AfaDocData.ActiveDocData.DocDataset;
foreach (MSCImageService current in docDataset.ImageServices.Values)
{
current.RefreshService();
}
}
catch
{
}
}
private void OnRemoveAllImages_Click(object sender, RoutedEventArgs e)
{
try
{
MSCDataset docDataset = AfaDocData.ActiveDocData.DocDataset;
foreach (MSCImageService current in docDataset.ImageServices.Values)
{
current.DeleteService();
}
}
catch
{
}
}
public static void UpdatePalette(Document doc, MSCDataset dataset, bool generateIcons)
{
try
{
if (generateIcons)
{
ToolPalette.GenerateBlockImages(doc, dataset);
}
ToolPalette.CreatePalette(doc, dataset);
}
catch
{
}
}
private void OnClickNext(object sender, RoutedEventArgs e)
{
this.lblErrorMessage.Content = "";
if (string.IsNullOrEmpty(this.tbName.Text))
{
this.lblErrorMessage.Content = AfaStrings.NameCannotBeBlank;
return;
}
string text = this.tbName.Text;
if (!string.IsNullOrEmpty(text))
{
text = text.Trim();
}
if (string.IsNullOrEmpty(text))
{
this.lblErrorMessage.Content = AfaStrings.NameCannotBeBlank;
return;
}
text = NewFeatureClass.FixFeatureClassName(text);
MSCDataset docDataset = AfaDocData.ActiveDocData.DocDataset;
MSCFeatureClass mSCFeatureClass = new MSCFeatureClass(docDataset);
this.tbName.Text = text;
mSCFeatureClass.Name = text;
mSCFeatureClass.SetGeometryType(this.cbType.SelectedValue.ToString());
mSCFeatureClass.Query = new ResultBuffer(new TypedValue[]
{
new TypedValue(8, "*")
});
mSCFeatureClass.Write(AfaDocData.ActiveDocData.Document);
docDataset.FeatureClasses.Add(mSCFeatureClass.Name, mSCFeatureClass);
docDataset.FeatureClassViewList.Add(new FCView(mSCFeatureClass));
base.Close();
FeatureClassProperties featureClassProperties = new FeatureClassProperties(mSCFeatureClass);
try
{
Application.ShowModalWindow(featureClassProperties);
}
catch (Exception)
{
}
AfaDocData.ActiveDocData.SetActiveFeatureClass(mSCFeatureClass);
ArcGISRibbon.SetActiveFeatureClass(mSCFeatureClass);
}
public object ESRI_FeatureService_remove(ResultBuffer rb)
{
object result;
try
{
string argument = LspUtil.GetArgument(rb, 0, null);
MSCFeatureService mSCFeatureService;
if (!string.IsNullOrEmpty(argument))
{
mSCFeatureService = this.GetFeatureService(argument);
}
else
{
mSCFeatureService = this.GetCurrentFeatureService();
}
if (mSCFeatureService == null)
{
result = null;
}
else
{
bool queryOnly = mSCFeatureService.QueryOnly;
if (mSCFeatureService.DeleteService())
{
AfaDocData.ActiveDocData.DocDataset.FeatureServices.Remove(argument);
MSCDataset.SetDefaultActiveFeatureClass();
if (AfaDocData.ActiveDocData.DocDataset.FeatureServices.Count == 0)
{
ArcGISRibbon.EnableFeatureServiceButtons(false);
}
if (!queryOnly)
{
ToolPalette.UpdatePalette(AfaDocData.ActiveDocData.DocDataset.ParentDocument, AfaDocData.ActiveDocData.DocDataset, false);
}
}
result = true;
}
}
catch
{
result = null;
}
return(result);
}
public static FieldDomain ToDomain(Transaction t, MSCDataset parent, ObjectId id)
{
FieldDomain result;
try
{
FieldDomain fieldDomain = new FieldDomain(t, id);
if (parent != null)
{
fieldDomain.ParentDataset = parent;
}
fieldDomain.Read(id, t);
result = fieldDomain;
}
catch
{
result = null;
}
return(result);
}
public static void GenerateBlockIcons(Document doc, MSCDataset dataset)
{
try
{
Database database = doc.Database;
List <ObjectId> list = new List <ObjectId>();
using (doc.LockDocument())
{
using (Transaction transaction = database.TransactionManager.StartTransaction())
{
foreach (MSCFeatureService current in dataset.FeatureServices.Values)
{
if (!current.QueryOnly && current.GeometryType == MSCFeatureClass.fcTypeCode.fcTypePoint)
{
ObjectId blockDefinition = DocUtil.GetBlockDefinition(doc, current.LayerName);
if (!(blockDefinition == ObjectId.Null))
{
list.Add(blockDefinition);
foreach (MSCFeatureClassSubType current2 in current.SubTypes)
{
ObjectId blockDefinition2 = DocUtil.GetBlockDefinition(doc, current2.CadLayerName);
if (!(blockDefinition2 == ObjectId.Null))
{
list.Add(blockDefinition2);
}
}
}
}
}
if (list.Count > 0)
{
ToolPalette.CreateBlockIcons(transaction, doc, list.ToArray());
}
transaction.Commit();
}
}
}
catch
{
}
}
private void AddImageService(object sender, ExportedImageEventArgs e)
{
try
{
if (!string.IsNullOrEmpty(e.ErrorMessage))
{
ErrorReport.ShowErrorMessage(e.ErrorMessage);
}
else if (e.Points != null && !string.IsNullOrEmpty(e.ExportOptions.OutputFile))
{
Point3d point3d = new Point3d(e.Points[0].X, e.Points[0].Y, 0.0);
Point3d point3d2 = new Point3d(e.Points[1].X, e.Points[1].Y, 0.0);
Point3d point3d3 = new Point3d(e.Points[2].X, e.Points[2].Y, 0.0);
Point3d p = new Point3d(e.Points[1].X, e.Points[2].Y, 0.0);
Vector3d v = point3d2 - point3d;
Vector3d v2 = point3d3 - point3d;
ObjectId objectId = DocUtil.DefineRasterImage(AfaDocData.ActiveDocData.Document, e.ExportOptions.OutputFile, point3d, v, v2, "ESRI_" + e.MapName, e.ExportOptions.Transparency);
if (!objectId.IsNull)
{
DocUtil.SetEntityDisableUndo(AfaDocData.ActiveDocData.Document, objectId, true);
e.ExportOptions.BoundingBox = new Extent(point3d, p);
e.ExportOptions.BoundingBox.SpatialReference = e.ExportOptions.OutputWKT;
MSCImageService mSCImageService = MSCDataset.AddImageService((AGSImageService)e.MapService, objectId, e.ExportOptions);
if (mSCImageService != null)
{
DocUtil.AttachHyperlink(AfaDocData.ActiveDocData.Document, objectId, mSCImageService.Name, mSCImageService.RestEndpoint);
mSCImageService.UpdateToCurrentView();
mSCImageService.CheckForUpdates();
}
}
}
}
catch
{
if (string.IsNullOrEmpty(base.ErrorMessage))
{
base.ErrorMessage = AfaStrings.ErrorGeneratingImage;
}
throw;
}
}
private void CreateLocationsFeatureClass()
{
if (AfaDocData.ActiveDocData.DocDataset.FeatureClasses.ContainsKey("ESRI_Locations"))
{
ArcGISRibbon.SetActiveFeatureClass(AfaDocData.ActiveDocData.DocDataset.FeatureClasses["ESRI_Locations"]);
return;
}
try
{
MSCDataset.AddSimpleFeatureClass("ESRI_Locations", "esriGeometryPoint", new List <string>
{
"ESRI_Locations"
}, new List <CadField>
{
new CadField
{
Name = "Score",
Value = new TypedValue(90, 100),
ReadOnly = true
},
new CadField
{
Name = AfaStrings.SearchString,
Value = new TypedValue(1, ""),
Length = 254,
ReadOnly = true
},
new CadField
{
Name = "Address",
Value = new TypedValue(1, "Address"),
Length = 254,
ReadOnly = true
}
}, true, null);
ArcGISRibbon.SetActiveFeatureClass(AfaDocData.ActiveDocData.DocDataset.FeatureClasses["ESRI_Locations"]);
}
catch
{
}
}
public static void CreatePalette(Document doc, MSCDataset dataset)
{
ToolPaletteManager manager = ToolPaletteManager.Manager;
try
{
try
{
if (manager.Catalogs.Count > 0)
{
manager.SaveCatalogs();
}
}
catch
{
}
ToolPalette.InitializePaletteFolders();
ToolPalette.IncludeFolderLocation(ToolPalette.GroupFolder);
ToolPalette.CreatePaletteFile(doc, dataset);
if (!ToolPalette.GroupExists(doc))
{
ToolPalette.CreateGroup();
}
if (manager.Catalogs.Count > 0)
{
if (dataset.FeatureServices.Count != 0)
{
manager.LoadCatalogs();
}
else if (ToolPalette.PaletteVisible())
{
manager.LoadCatalogs();
}
}
}
catch
{
}
}
public static string FixFeatureClassName(string name)
{
name = name.Replace("<", "_lt_");
name = name.Replace(">", "_gt_");
name = name.Replace("/", ".");
name = name.Replace("\\", ".");
name = name.Replace(":", ".");
name = name.Replace("?", ".");
name = name.Replace("*", ".");
name = name.Replace("|", "-");
name = name.Replace("=", "-");
name = name.Replace(" ", "_");
if (!char.IsLetter(name[0]))
{
name = "a" + name;
}
if (name.Length > 160)
{
name = name.Substring(0, 159);
}
return(MSCDataset.GenerateUniqueName(name));
}
public bool CreateExportImage(string outputFileName)
{
bool result;
try
{
this.StopReactors();
if (!File.Exists(this.CurrentFileName))
{
this.RequestNewRasterNow(this.DrawnViewInfo);
}
File.Copy(this.CurrentFileName, outputFileName, true);
DocUtil.UpdateRasterImage(this.ParentDataset.ParentDocument, this.RasterObjectId, outputFileName);
this.RasterObjectId = ObjectId.Null;
if (base.GetType() == typeof(MSCMapService))
{
AfaDocData.ActiveDocData.DocDataset.MapServices.Remove(this.Name);
MSCMapService mSCMapService = (MSCMapService)this;
mSCMapService.RemoveDictionary();
this.ParentDataset.MapServices.Remove(this.Name);
MSCDataset.SetDefaultActiveRasterServices();
}
if (base.GetType() == typeof(MSCImageService))
{
AfaDocData.ActiveDocData.DocDataset.ImageServices.Remove(this.Name);
MSCImageService mSCImageService = (MSCImageService)this;
mSCImageService.RemoveDictionary();
this.ParentDataset.ImageServices.Remove(this.Name);
MSCDataset.SetDefaultActiveRasterServices();
}
result = true;
}
catch (SystemException)
{
result = false;
}
return(result);
}
public object ESRI_RemoveFeatureClass(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
{
MSCFeatureClass activeFeatureClassOrSubtype = AfaDocData.ActiveDocData.GetActiveFeatureClassOrSubtype();
bool flag = mSCFeatureClass == activeFeatureClassOrSubtype;
AfaDocData.ActiveDocData.DocDataset.RemoveFeatureClass(mSCFeatureClass);
if (flag)
{
MSCDataset.SetDefaultActiveFeatureClass();
}
result = LspUtil.LispTrue;
}
}
catch
{
result = null;
}
return(result);
}
private void OnDeleteMapService(object sender, RoutedEventArgs e)
{
try
{
MSCRasterService activeRasterService = ArcGISRibbon.GetActiveRasterService();
if (activeRasterService != null)
{
if (activeRasterService.GetType() == typeof(MSCMapService))
{
MSCMapService mSCMapService = (MSCMapService)activeRasterService;
mSCMapService.DeleteService();
}
else if (activeRasterService.GetType() == typeof(MSCImageService))
{
MSCImageService mSCImageService = (MSCImageService)activeRasterService;
mSCImageService.DeleteService();
}
MSCDataset.SetDefaultActiveRasterServices();
}
}
catch
{
}
}
public MSCImageService(MSCDataset parentDataset, AGSImageService parentMap, AGSExportOptions eo)
{
this.ParentService = (AGSImageService)Utility.CloneObject(parentMap);
base.ParentDataset = parentDataset;
try
{
base.ConnectionURL = this.ParentService.Parent.Soap_URL;
base.UserName = this.ParentService.Parent.UserName;
base.ExportOptions = eo;
this.ServiceFullName = this.ParentService.FullName;
base.ConnectionURL = this.ParentService.Parent.Soap_URL;
base.UserName = this.ParentService.Parent.UserName;
base.ConnectionName = this.ParentService.Parent.Name;
base.ExportOptions = eo;
base.CurrentFileName = eo.OutputFile;
this.UpdateForm = new HiddenUpdateForm(base.ParentDataset.ParentDocument);
base.StartReactors();
AfaDocData.ActiveDocData.CurrentImageService = this;
}
catch (SystemException ex)
{
this.ErrorMessage = ex.Message;
}
}
public bool DeleteService()
{
try
{
base.StopReactors();
base.StopReactors();
}
catch
{
}
Database database = base.ParentDataset.ParentDocument.Database;
Document parentDocument = base.ParentDataset.ParentDocument;
Editor editor = base.ParentDataset.ParentDocument.Editor;
bool result;
try
{
using (base.ParentDataset.ParentDocument.LockDocument((DocumentLockMode)20, null, null, false))
{
using (Transaction transaction = parentDocument.TransactionManager.StartTransaction())
{
RasterImage rasterImage = (RasterImage)transaction.GetObject(base.RasterObjectId, (OpenMode)1);
rasterImage.DisableUndoRecording(true);
ObjectId imageDefId = rasterImage.ImageDefId;
RasterImageDef rasterImageDef = (RasterImageDef)transaction.GetObject(imageDefId, (OpenMode)1);
rasterImageDef.DisableUndoRecording(true);
if (rasterImageDef.IsLoaded)
{
rasterImageDef.Unload(true);
}
try
{
File.Delete(rasterImageDef.SourceFileName);
if (App.TempFiles.Contains(rasterImageDef.SourceFileName))
{
App.TempFiles.Remove(rasterImageDef.SourceFileName);
}
}
catch
{
}
if (!rasterImageDef.IsErased)
{
rasterImageDef.Erase();
}
ObjectId imageDictionary = RasterImageDef.GetImageDictionary(database);
DBDictionary dBDictionary = (DBDictionary)transaction.GetObject(imageDictionary, (OpenMode)1);
dBDictionary.Remove(imageDefId);
dBDictionary.Contains(imageDefId);
if (!rasterImage.IsErased)
{
rasterImage.Erase(false);
}
this.RemoveDictionary(database, transaction);
parentDocument.TransactionManager.QueueForGraphicsFlush();
parentDocument.TransactionManager.FlushGraphics();
parentDocument.Editor.UpdateScreen();
transaction.Commit();
base.ParentDataset.ImageServices.Remove(base.Name);
editor.Regen();
MSCDataset.SetDefaultActiveRasterServices();
result = true;
}
}
}
catch
{
MessageBox.Show("DEBUG: Catch in MSCMapService.DeleteService");
result = false;
}
return(result);
}
