Directions Magazine - Top Stories
Directions Magazine - Press Releases
geoinformatics.com
GISCafe.com CorpNews
GISCafe.com Weekly Reviews
Geospatial Solutions
Mapping Hacks
International Journal of Health Geographics - Latest articles
Information Technology News at iCivilEngineer.com
ESRI News Feed
Geo: International UK News Articles
GIS Lounge - Geographic Information Systems
News
Geobranchen.de
CeGi GEOcatalog - News (deutsche Version)
Geobranchen.de EVENTS - RSS/RDF Feed
AECWEB.de-News
Geography 2.0: Virtual Globes
Ogle Earth
Geo Coding
GIS CAD Interoperability
GIS Matters
All Points Blog
AnyGeo - Anything Geospatial
Mapperz - The Mapping News Blog
Sebastian Pache | Blog for Spatial Technology
Directions Magazine GIS & Spatial Jobs Board
Geographic information systems jobs | SimplyHired
Gigajob: neue Stellenangebote: GIS
GeoJobs Network Jobs Feed
ICjobs.de Geoinformatik
Careerjet
Careerjet - keywords:GIS jobs in USA
Careerjet - keywords:GIS jobs in Europe
ArcGlobe does not support layer labeling. As a workaround, users can use ArcMap to convert labels to a new or existing annotation feature class. Annotation feature class can be displayed in ArcGlobe as flat billboarded text.
The Globe Text Tool for ArcGIS Desktop 9.2 is a developer sample available on ArcScripts to generate true 3D layer labels. The ArcScripts download includes full source code. Below is a screenshot and a short demonstration video from YouTube..
ArcGIS Explorer is a free 3D viewer by ESRI. Time Navigator extends ArcGIS Explorer by allow users to playback of historic data.
Time Navigator can animate any ESRI Shapefile with point geometry and a timestamp field. The timestamp fields can be date, numeric or textual. Time Navigator is developed as a custom task for ArcGIS Explorer build 410 and can be downloaded from downloaded from ArcScripts (source code is included).
Below is a brief video demonstrating showing Time Navigator animating and comparing Atlantic hurricanes from 1971 and 1981.
Technorati tags: ArcGIS Explorer, Time Navigator
The ESRI products ArcGIS Explorer, ArcGIS Desktop and ArcGIS Engine ship with an extremely useful C DLL called the projection engine Library. The projection engine is used by these products to perform geodetic (or ellipsoidal) computations.
The projection engine is fully documented in the SDE C API and there is a sample VB6 wrapper for two functions on the EDN web site.
The VB6 sample be easily ported to C# using DLLImportAttribute. However there are two disadvantages of using DLLImport.
However with .NET 2.0 a new method called GetDelegateForFunctionPointer was added to the Marshal class to allow late binding. This meant that external DLLs could be discovered and loaded at runtime.
Below is a C# wrapper to the ESRI Projection Engine. The wrapper is developed as a singleton so that the DLL is only loaded once per application instance. Additionally, the location of the projection engine library is discovered at runtime from the registry.
Here is a example using the projection engine singleton for ArcGIS Explorer to calculate the geodetic distance between London and Paris. The geodetic distance is the shortest distance between two points on the surface of an ellipsoid.
public class ProjectionEngineTest{
public void Main() {
double distance = 0d;
double azimuthForward = 0d;
double azimuthBack = 0d;
ProjectionEngine projectionEngine = ProjectionEngineExplorer.GetInstance();
projectionEngine.GetGeodesicDistance(
ProjectionEngine.GLOBERADIUS,
0,
ProjectionEngine.ToRadians(51.50d),
ProjectionEngine.ToRadians(-0.12d),
ProjectionEngine.ToRadians(48.86d),
ProjectionEngine.ToRadians(2.35d),
out distance,
out azimuthForward,
out azimuthBack);
MessageBox.Show(string.Format("London to Paris is {0} meters", distance.ToString()));
}
}
Here is the source code to the wrappers.
Please note that the code and methodology used in this post is not endorsed or supported by ESRI. Use this code at your own risk.
using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.InteropServices;
using System.Text;
using System.Windows.Forms;
using Microsoft.Win32;
namespace ESRI.ArcGIS.Sample {
/// <summary>
/// Projection Engine Abstract Class
/// </summary>
public abstract class ProjectionEngine {
public const double GLOBERADIUS = 6367444.65712259d;
private GeodesicDistance m_gd = null;
private GeodesicCoordinate m_gc = null;
[DllImport("kernel32.dll")]
private static extern IntPtr LoadLibrary(String dllname);
[DllImport("kernel32.dll")]
private static extern IntPtr GetProcAddress(IntPtr hModule, String procname);
private delegate void GeodesicDistance(
[In] double semiMajorAxis,
[In] double eccentricity,
[In] double longitude1,
[In] double latitude1,
[In] double longitude2,
[In] double latitude2,
[Out] out double distance,
[Out] out double azimuthForward,
[Out] out double azimuthBack);
private delegate void GeodesicCoordinate(
[In] double semiMajorAxis,
[In] double eccentricity,
[In] double longitude1,
[In] double latitude1,
[In] double distance,
[In] double azimuth,
[Out] out double longitude2,
[Out] out double latitude2);
//
// CONSTRUCTOR
//
protected ProjectionEngine() {
IntPtr pe = ProjectionEngine.LoadLibrary(this.DLLPath);
IntPtr gd = ProjectionEngine.GetProcAddress(pe, "pe_geodesic_distance");
IntPtr gc = ProjectionEngine.GetProcAddress(pe, "pe_geodesic_coordinate");
this.m_gd = (GeodesicDistance)Marshal.GetDelegateForFunctionPointer(
gd, typeof(GeodesicDistance));
this.m_gc = (GeodesicCoordinate)Marshal.GetDelegateForFunctionPointer(
gc, typeof(GeodesicCoordinate));
}
//
// PUBLIC METHODS
//
public abstract string DLLPath { get;}
//
// PUBLIC METHODS
//
/// <summary>
/// Returns the geodestic azimuth and distance between two geographic locations.
/// </summary>
/// <param name="semiMajorAxis">Semi Major Axis</param>
/// <param name="eccentricity">Globe Eccentricity</param>
/// <param name="longitude1">From Longitude (radians)</param>
/// <param name="latitude1">From Latitude (radians)</param>
/// <param name="longitude2">To Longitude (radians)</param>
/// <param name="latitude2">To Latitude (radians)</param>
/// <param name="distance">Returned Geodetic Distance</param>
/// <param name="azimuthForward">Returned Forward Azimuth (radians)</param>
/// <param name="azimuthBack">Returned Reverse Azimuth (radians)</param>
public void GetGeodesicDistance(
double semiMajorAxis,
double eccentricity,
double longitude1,
double latitude1,
double longitude2,
double latitude2,
out double distance,
out double azimuthForward,
out double azimuthBack) {
this.m_gd(
semiMajorAxis,
eccentricity,
longitude1,
latitude1,
longitude2,
latitude2,
out distance,
out azimuthForward,
out azimuthBack);
}
/// <summary>
/// Returns the geographic location based on the azimuth and distance from another geographic location
/// </summary>
/// <param name="semiMajorAxis">Semi Major Axis</param>
/// <param name="eccentricity">Globe Eccentricity</param>
/// <param name="longitude1">From Longitude (radians)</param>
/// <param name="latitude1">From Latitude (radians)</param>
/// <param name="distance">Distance from "From Location"</param>
/// <param name="azimuth">Azimuth from "From Location"</param>
/// <param name="longitude2">Out Logitude (in radians)</param>
/// <param name="latitude2">Out Latitude (in radians)</param>
public void GetGeodesicCoordinate(
double semiMajorAxis,
double eccentricity,
double longitude1,
double latitude1,
double distance,
double azimuth,
out double longitude2,
out double latitude2) {
this.m_gc(
semiMajorAxis,
eccentricity,
longitude1,
latitude1,
distance,
azimuth,
out longitude2,
out latitude2);
}
/// <summary>
/// Converts Radians to Decimal Degrees.
/// </summary>
/// <param name="degrees">In angle in decimal degrees.</param>
/// <returns>Returns angle in radians.</returns>
public static double ToRadians(double degrees) { return degrees * (Math.PI / 180d); }
/// <summary>
/// Converts Radians to Decimal Degrees.
/// </summary>
/// <param name="radians">In angle in radians.</param>
/// <returns>Returns angle in decimal degrees.</returns>
public static double ToDegrees(double radians) { return radians * (180d / Math.PI); }
}
/// <summary>
/// Projection Engine Singleton for ArcGIS Explorer
/// </summary>
public sealed class ProjectionEngineExplorer : ProjectionEngine {
private static ProjectionEngineExplorer projectionEngine;
//
// PUBLIC METHODS
//
public static ProjectionEngineExplorer GetInstance() {
if (projectionEngine == null) {
projectionEngine = new ProjectionEngineExplorer();
}
return projectionEngine;
}
public override string DLLPath {
get {
RegistryKey coreRuntime = Registry.LocalMachine.OpenSubKey(
@"SOFTWARE\ESRI\E2\CoreRuntime", false);
object installDir = coreRuntime.GetValue("InstallDir", null);
coreRuntime.Close();
string folder = installDir.ToString();
string bin = Path.Combine(folder, "bin");
string pedll = Path.Combine(bin, "pe.dll");
return pedll;
}
}
}
/// <summary>
/// Projection Engine Singleton for ArcGIS Desktop
/// </summary>
public sealed class ProjectionEngineDesktop : ProjectionEngine {
private static ProjectionEngineDesktop projectionEngine;
//
// PUBLIC METHODS
//
public static ProjectionEngineDesktop GetInstance() {
if (projectionEngine == null) {
projectionEngine = new ProjectionEngineDesktop();
}
return projectionEngine;
}
public override string DLLPath {
get {
RegistryKey coreRuntime = Registry.LocalMachine.OpenSubKey(
@"SOFTWARE\ESRI\CoreRuntime", false);
object installDir = coreRuntime.GetValue("InstallDir", null);
coreRuntime.Close();
string folder = installDir.ToString();
string bin = Path.Combine(folder, "bin");
string pedll = Path.Combine(bin, "pe.dll");
return pedll;
}
}
}
}
ArcGIS Diagrammer has the capability to view and edit metadata.
When exporting geodatabase schema to an XML workspace document using ArcCatalog, ensure that you have the Export Metadata option checked. This option is enabled by default.
To view metadata for a geodatabase object in ArcGIS Diagrammer, simply right click and select View Metadata as shown below. Please note that not all geodatabase objects support metadata, for example, domains and subtypes do not have metadata.
After clicking View Metadata, a new tab is added to ArcGIS Diagrammer. By default the raw metadata XML is displayed.
In the Properties Window, you can select one of the ArcGIS Desktop metadata stylesheets as shown below. These stylesheets translate raw metadata XML into readable HTML.
This is what the Parcels feature class metadata looks like with the ISO metadata stylesheet.
To edit metadata of a geodatabase object select the object in the diagram and click the ellipse button next to the Metadata property in the Properties Window.
The ellipse button will launch the ESRI ISO Metadata Wizard.
Technorati tags: ArcGIS Diagrammer, ArcGIS Desktop, ESRI, Geodatabase
This post will describe how to create a ready-to-print diagram of your geodatabase in four easy steps.
This exercise will use ArcGIS Diagrammer (free) which is available from ArcScripts. Prerequisites for ArcGIS Diagrammer include ArcGIS Desktop 9.2 and Microsoft .NET Framework 2.0.
Step 1: Export an existing geodatabase to an ESRI XML Workspace Document
Right click on a personal geodatabase, file geodatabase or an SDE connection. Select Export > XML Workspace Document...
Select Schema Only and enter an output file name. For example C:\Temp\Montgomery.xml. Click Next.
Click Finish to start the export.
Step 2: Load the XML Workspace Document into ArcGIS Diagrammer
Start ArcGIS Diagrammer by clicking:
START > All Programs > ArcGIS > ArcGIS Diagrammer > ArcGIS Diagrammer
Drag and drop the XML file created by ArcCatalog into the ArcGIS Diagrammer canvas.
ArcGIS Diagrammer will render all the geodatabase objects and associations. You may want to change the diagram scale, for example, to change the zooming scale to 25% click View > Zoom > 25%.
Step 3: Arrange geodatabase objects
All geodatabase objects can be re-arranged to suit your needs. Also, some objects like subtypes, domains and feature classes can be expanded to reveal additional details.
Step 4: Print the Diagram
Before printing or plotting the diagram you may want to specify a printer/plotter and paper size. Click File > Print Setup...
In the Printer Setup dialog select a printer and paper size.
Finally, click File > Print to send the diagram for printing/plotting.
Technorati tags: ArcGIS Diagrammer, ArcGIS Desktop, ESRI, Geodatabase
ArcGIS Diagrammer is a productivity tool for GIS professionals to create, edit and analyze geodatabase schema. Schema is presented as an editable diagram in an environment familiar to users of Microsoft Visual Studio.
Essentially ArcGIS Diagrammer is a visual editor for ESRI’s xml workspace document. These xml documents can be created by exporting the schema from an existing geodatabase to xml using ArcCatalog. ArcCatalog can also create geodatabase schema by importing an xml workspace document.
Here is a brief video demonstration of ArcGIS Diagrammer:
Technorati tags: ArcGIS Diagrammer, ArcGIS Desktop, ESRI, Geodatabase
ESRI's ArcGIS Desktop product includes the applications ArcCatalog, ArcMap, ArcScene and ArcGlobe. The user interfaces for all four applications can be heavily customized, for example, developers can deploy custom toolbars and buttons.
Below is an example of a custom toolbar for ArcMap. The toolbar is developed as a series of COM classes (or .NET classes with interop). The classes must use interfaces defined in the ArcGIS Desktop SDK such as IToolbarDef, IMenuDef, ICommand and IToolControl. For more information on this or other interfaces please visit EDN.
Before (standard implementation)
With ArcGIS Desktop 9.2, development of toolbars was made much easier with the inclusion of base classes in the ArcGIS .NET SDK. However, the basic look and feel of the ArcGIS Desktop user interface has not changed since it was first released in 2000.
In this article, I will describe how to implement a modern UI in an ArcGIS Desktop application using .NET 2.0. This is achieved by hosting a .NET 2.0 ToolStrip inside a traditional ESRI Toolbar. This is the result:
After (using hosted .NET ToolStrip)
With minimal effort it is possible to create an attractive, functional and efficient toolbar. To summarize the benefits of a hosted ToolStrip:
But there is always a catch! :-) The only disadvantage that I have found is that toolbars cannot be resized at runtime.
The code below will create the ArcMap toolbar shown above. To use the code, create a new C# Class Library in Microsoft Visual Studio 2005. In the project properties, tick Register for COM interop.
Please note that the code and methodology used in this post is not endorsed or supported by ESRI. Use this code at your own risk.
using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Text;
using System.Windows.Forms;
using Microsoft.Win32;
using ESRI.ArcGIS.Framework;
using ESRI.ArcGIS.SystemUI;
namespace ESRI.ArcGIS.DeveloperSamples.ToolbarNet {
// .NET UserControl that hosts a ToolStrip
[ComVisible(false)]
public class UserControlTest : UserControl{
private enum Action { None, Cut, Copy, Paste, Delete, Zoom25, Zoom50, Zoom100 }
private IApplication m_application = null;
public UserControlTest() {
// Get .NET Bitmaps
Assembly assembly = Assembly.GetAssembly(typeof(Form));
Bitmap bitmap1 = new Bitmap(assembly.GetManifestResourceStream("System.Windows.Forms.cut.bmp"));
Bitmap bitmap2 = new Bitmap(assembly.GetManifestResourceStream("System.Windows.Forms.copy.bmp"));
Bitmap bitmap3 = new Bitmap(assembly.GetManifestResourceStream("System.Windows.Forms.paste.bmp"));
Bitmap bitmap4 = new Bitmap(assembly.GetManifestResourceStream("System.Windows.Forms.delete.bmp"));
bitmap1.MakeTransparent(Color.Fuchsia);
bitmap2.MakeTransparent(Color.Fuchsia);
bitmap3.MakeTransparent(Color.Fuchsia);
bitmap4.MakeTransparent(Color.Fuchsia);
// Create Dropdown Button
ToolStripDropDownButton toolStripDropDownButton = new ToolStripDropDownButton();
toolStripDropDownButton.Text = "Zoom";
toolStripDropDownButton.DropDownItems.Add(new ToolStripMenuItemAction("25%", Action.Zoom25));
toolStripDropDownButton.DropDownItems.Add(new ToolStripMenuItemAction("50%", Action.Zoom50));
toolStripDropDownButton.DropDownItems.Add(new ToolStripMenuItemAction("100%", Action.Zoom100));
toolStripDropDownButton.DropDownItemClicked += new ToolStripItemClickedEventHandler(
this.ToolStrip_DropDownItemClicked);
// Create Toolstrip
ToolStrip toolstrip = new ToolStrip();
toolstrip.GripStyle = ToolStripGripStyle.Hidden;
toolstrip.Items.Add(new ToolStripButtonAction(bitmap1, Action.Cut));
toolstrip.Items.Add(new ToolStripButtonAction(bitmap2, Action.Copy));
toolstrip.Items.Add(new ToolStripButtonAction(bitmap3, Action.Paste));
toolstrip.Items.Add(new ToolStripSeparator());
toolstrip.Items.Add(new ToolStripButtonAction(bitmap4, Action.Delete));
toolstrip.Items.Add(new ToolStripSeparator());
toolstrip.Items.Add(toolStripDropDownButton);
toolstrip.Stretch = true;
toolstrip.MouseEnter += new EventHandler(this.Toolstrip_MouseEnter);
toolstrip.ItemClicked += new ToolStripItemClickedEventHandler(this.Toolstrip_ItemClicked);
// Add Toolbar. Set Size.
this.Controls.Add(toolstrip);
this.Width = 160;
}
public IApplication Application {
set { this.m_application = value; }
}
private void Toolstrip_MouseEnter(object sender, EventArgs e) {
ToolStrip toolStrip = sender as ToolStrip;
if (toolStrip == null) { return; }
toolStrip.Focus();
}
private void ToolStrip_DropDownItemClicked(object sender, ToolStripItemClickedEventArgs e) {
ToolStripMenuItemAction toolStripMenuItemAction = e.ClickedItem as ToolStripMenuItemAction;
if (toolStripMenuItemAction == null) { return; }
this.ExecuteAction(toolStripMenuItemAction.Action);
}
private void Toolstrip_ItemClicked(object sender, ToolStripItemClickedEventArgs e) {
ToolStripButtonAction toolStripButtonAction = e.ClickedItem as ToolStripButtonAction;
if (toolStripButtonAction == null) { return; }
this.ExecuteAction(toolStripButtonAction.Action);
}
private void ExecuteAction(Action action) {
switch (action) {
case Action.Cut:
case Action.Copy:
case Action.Paste:
case Action.Delete:
case Action.Zoom25:
case Action.Zoom50:
case Action.Zoom100:
MessageBox.Show(action.ToString());
break;
default:
break;
}
}
// Subclassed ToolStripButton
private class ToolStripButtonAction : ToolStripButton {
private readonly Action m_action = Action.None;
public ToolStripButtonAction(Image image, Action action) : base(image) {
this.m_action = action;
}
public Action Action {
get { return this.m_action; }
}
}
private class ToolStripMenuItemAction : ToolStripMenuItem {
private readonly Action m_action = Action.None;
public ToolStripMenuItemAction(string text, Action action) : base(text) {
this.m_action = action;
}
public Action Action {
get { return this.m_action; }
}
}
}
// The ESRI ArcMap Command that hosts the User Control
[ComVisible(true)]
[ClassInterface(ClassInterfaceType.None)]
[Guid(ApplicationGuid.GUID_COMMAND_TEST)]
public sealed class CommandHost : EsriCommandControlMx {
public CommandHost() : base() {
this.m_control = new UserControlTest();
}
public override void OnCreate(object hook) {
base.OnCreate(hook);
if (hook != null) {
((UserControlTest)this.m_control).Application = (IApplication)hook;
}
}
}
// The ESRI ArcMap Toolbar
[ComVisible(true)]
[ClassInterface(ClassInterfaceType.None)]
[Guid(ApplicationGuid.GUID_TOOLBAR_TEST)]
public sealed class ToolbarTest : EsriToolbarMx {
public ToolbarTest() : base() {
this.m_caption = "Test";
this.m_commands.Add(new EsriToolbarCommand(new Guid(ApplicationGuid.GUID_COMMAND_TEST), false));
}
}
// The Abstract ESRI ArcMap Toolbar
[ComVisible(false)]
public abstract class EsriToolbarMx : EsriToolbar {
private const string IMPLEMENT_CATEGORIES = "\\Implemented Categories\\";
[ComVisible(false)]
[ComRegisterFunction()]
private static void RegisterFunction(string regKey) {
Registry.ClassesRoot.CreateSubKey(regKey.Substring(18) + IMPLEMENT_CATEGORIES +
EsriRegistry.COMPONENT_MX_TOOLBAR);
}
[ComVisible(false)]
[ComUnregisterFunction()]
private static void UnregisterFunction(string regKey) {
Registry.ClassesRoot.DeleteSubKey(regKey.Substring(18) + IMPLEMENT_CATEGORIES +
EsriRegistry.COMPONENT_MX_TOOLBAR);
}
}
// Abstract ESRI Toolbar
[ComVisible(false)]
public abstract class EsriToolbar : IToolBarDef {
private const string SUFFIX = "_TOOLBAR";
protected List<EsriToolbarCommand> m_commands = new List<EsriToolbarCommand>();
protected string m_caption = null;
public void GetItemInfo(int pos, IItemDef itemDef) {
itemDef.ID = this.m_commands[pos].Guid.ToString("B");
itemDef.Group = this.m_commands[pos].Group;
}
public string Caption {
get { return this.m_caption; }
}
public string Name {
get { return this.m_caption.ToUpper().Replace(" ", "") + SUFFIX; }
}
public int ItemCount {
get { return this.m_commands.Count; }
}
}
// Abstract ESRI Toolbar Item
[ComVisible(false)]
public class EsriToolbarCommand {
private readonly Guid m_guid = Guid.Empty;
private readonly bool m_group = false;
public EsriToolbarCommand(Guid guid, bool group) {
this.m_guid = guid;
this.m_group = group;
}
public Guid Guid {
get { return this.m_guid; }
}
public bool Group {
get { return this.m_group; }
}
}
// Abstract ESRI ArcMap Command Tool Control
[ComVisible(false)]
public abstract class EsriCommandControlMx : EsriCommandControl {
private const string IMPLEMENT_CATEGORIES = "\\Implemented Categories\\";
[ComVisible(false)]
[ComRegisterFunction()]
private static void RegisterFunction(string regKey) {
Registry.ClassesRoot.CreateSubKey(regKey.Substring(18) + IMPLEMENT_CATEGORIES +
EsriRegistry.COMPONENT_MX_COMMAND);
}
[ComVisible(false)]
[ComUnregisterFunction()]
private static void UnregisterFunction(string regKey) {
Registry.ClassesRoot.DeleteSubKey(regKey.Substring(18) + IMPLEMENT_CATEGORIES +
EsriRegistry.COMPONENT_MX_COMMAND);
}
}
// Abstract ESRI Command Tool Control
[ComVisible(false)]
public abstract class EsriCommandControl : EsriCommand, IToolControl {
protected ICompletionNotify m_completionNotify = null;
protected UserControl m_control = null;
public virtual bool OnDrop(esriCmdBarType barType) {
return true;
}
public virtual void OnFocus(ICompletionNotify complete) {
this.m_completionNotify = complete;
// Can add UI update here
}
public int hWnd {
get { return this.m_control.Handle.ToInt32(); }
}
}
// Abstract ESRI Command
[ComVisible(false)]
public abstract class EsriCommand : ICommand {
protected string m_category = null;
protected string m_message = null;
protected string m_caption = null;
protected string m_tooltip = null;
protected IApplication m_application = null;
protected Bitmap m_bitmap = null;
private IntPtr m_hBitmap = IntPtr.Zero;
[DllImport("gdi32.dll")]
protected static extern bool DeleteObject([In] IntPtr hObject);
protected EsriCommand() { }
~EsriCommand() {
if (this.m_hBitmap != IntPtr.Zero) {
DeleteObject(this.m_hBitmap);
}
this.m_bitmap = null;
this.m_application = null;
}
public virtual void OnClick() { }
public string Message {
get { return this.m_message; }
}
public int Bitmap {
get {
if (this.m_hBitmap == IntPtr.Zero) {
if (this.m_bitmap != null) {
this.m_hBitmap = this.m_bitmap.GetHbitmap();
}
}
return this.m_hBitmap.ToInt32();
}
}
public virtual void OnCreate(object hook) {
if (hook != null) {
this.m_application = (IApplication)hook;
}
}
public string Caption {
get { return this.m_caption; }
}
public string Tooltip {
get { return this.m_tooltip; }
}
public int HelpContextID {
get { return 0; }
}
public string Name {
get { return this.m_category.Replace(" ", "") + "_" + this.m_caption.Replace(" ", ""); }
}
public virtual bool Checked {
get { return false; }
}
public virtual bool Enabled {
get { return true; }
}
public string HelpFile {
get { return null; }
}
public string Category {
get { return this.m_category; }
}
}
// List of ESRI Guids
[ComVisible(false)]
public static class EsriRegistry {
public const string COMPONENT_MX_COMMAND = "{B56A7C42-83D4-11D2-A2E9-080009B6F22B}";
public const string COMPONENT_MX_TOOLBAR = "{B56A7C4A-83D4-11D2-A2E9-080009B6F22B}";
}
// List of hardcoded application guids
[ComVisible(false)]
public static class ApplicationGuid {
public const string GUID_COMMAND_TEST = "D4E1C9EB-F2E4-4BD1-AF13-3868E555D322";
public const string GUID_TOOLBAR_TEST = "2B8966B6-C623-4F83-A376-53042F667B13";
}
}
+toolbar+for+ArcGIS+Desktop&referrer=)
GIS Blog List
ESRI's products ArcGIS Engine, ArcGIS Desktop and ArcGIS Server use style files to store and manage collections of symbols. A symbol is a graphic used to represent a geographic feature or class of features. Styles contains named and categorized symbols for various geographic entities like points, lines and polygons.
ArcGIS Engine and ArcGIS Desktop style files are Microsoft Access databases with a style file extension.
ArcGIS Server style files use a proprietary file type and have a serverstyle file extension. Developers can only use the ArcObjects API to access this file.
ArcGIS Engine developers can use the SymbologyControl to browse symbols contained in a server style. Whereas ArcGIS Desktop developers can re-use the desktop dialogs like the StyleManagerDialog, SymbolEditor and the SymbolPickerDialog.
In this post I will present a sample that demonstrates how to access ESRI style files using ADO.NET. The sample will also show how to convert an ESRI symbol into a .NET bitmap. This sample may be useful to developers that want to:
1) access styles without using ArcObjects, or
2) store custom information in an ESRI style file, or
3) convert ESRI symbols to bitmaps, or
4) create a custom symbol browser.
Please note that the code and methodology used in this post is not endorsed or supported by ESRI. Use this code at your own risk.
This sample was developed in C# using Microsoft Visual Studio 2005. The windows application consists of four controls and one component, these are:
1) textBox1: Path name to the style file,
2) button1: Opens the style file and adds entries to the ListView,
3) listView1: Display symbol icon and descriptions,
4) axLicenseControl1: Checks out an ArcGIS Engine or ArcGIS Desktop at runtime,
5) imageList1: Store a collection of images for the ListView items.
When the form loads:
1) A default path name is added to the style TextBox,
2) Four columns are added to the ListView,
3) The ListView is view style is set to details,
4) The ImageList is assigned to the SmallImageList property of the ListView.
The application, when loaded, looks like this.
If you run this application in debug mode, Microsoft Visual Studio 2005 may throw a PInvokeStackImbalance exception. This can be overcome by running the application normally from the executable or by disabling this exception. This and other debug exceptions can be ignored using the Exception window (Debug > Exceptions...).
To load the point, line and polygon symbols from the style to the ListView click GO!
Here is the source code for the sample:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Data.OleDb;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using stdole;
using ESRI.ArcGIS.Display;
using ESRI.ArcGIS.Geometry;
using ESRI.ArcGIS.Framework;
namespace BrowseEsriSymbols {
public partial class Form1 : Form {
private const string GDB_TABLE_MARKER = "MARKER SYMBOLS";
private const string GDB_TABLE_LINE = "LINE SYMBOLS";
private const string GDB_TABLE_AREA = "FILL SYMBOLS";
private const string JET_SCHEMA_TABLE = "TABLE_NAME";
private const string JET_SCHEMA_COLUMN = "COLUMN_NAME";
private const string FIELD_ID = "ID";
private const string FIELD_CATEGORY = "CATEGORY";
private const string FIELD_NAME = "NAME";
public Form1() {
// Initialize Components
InitializeComponent();
}
private void Form1_Load(object sender, EventArgs e) {
// Set Button Name from Resource
this.textBox1.Text = "C:\\Program Files\\ArcGIS\\Styles\\Conservation.style";
this.listView1.SmallImageList = this.imageList1;
this.listView1.View = View.Details;
this.listView1.Columns.Add("Table");
this.listView1.Columns.Add("Id");
this.listView1.Columns.Add("Category");
this.listView1.Columns.Add("Name");
}
private void button1_Click(object sender, EventArgs e) {
// Get Drawing Context
Graphics graphics = this.CreateGraphics();
// Display Hourglass Cursor
this.Cursor = Cursors.WaitCursor;
// Remove all rows (if any)
this.listView1.Items.Clear();
// Stop ListView Redraws
this.listView1.BeginUpdate();
// Connect to Style (using ADO.NET)
string connection = "Provider=Microsoft.Jet.OleDb.4.0;Data Source=" + this.textBox1.Text + ";";
OleDbConnection oleConnection = new OleDbConnection(connection);
oleConnection.Open();
// Style Hardcode Table Names and Fields
string[] tables = new string[] { GDB_TABLE_MARKER, GDB_TABLE_LINE, GDB_TABLE_AREA };
// Loop For Each Symbol Table in Style
foreach (string table in tables) {
// Construct SQL statement
string query = "SELECT * FROM [" + table + "] ";
// Connect to the Access File and create reader
OleDbCommand command = new OleDbCommand(query, oleConnection);
OleDbDataReader dataReader = command.ExecuteReader();
if (!dataReader.HasRows) { continue; }
// Find column indexes
int indexId = dataReader.GetOrdinal(FIELD_ID);
int indexCategory = dataReader.GetOrdinal(FIELD_CATEGORY);
int indexName = dataReader.GetOrdinal(FIELD_NAME);
// Read each row in table
while (dataReader.Read()) {
// Get row values
int id = dataReader.GetInt32(indexId);
string category = dataReader.GetString(indexCategory);
string name = dataReader.GetString(indexName);
// Get ESRI Symbol
ISymbol symbol = WindowsAPI.GetSymbol(this.textBox1.Text, table, id);
// Convert ESRI Symbol to Bitmap
Bitmap bitmap = WindowsAPI.SymbolToBitmap(
symbol,
new Size(16, 16),
graphics,
ColorTranslator.ToWin32(this.listView1.BackColor));
// Add Image to the listview's image list
int index = this.listView1.SmallImageList.Images.Add(bitmap, Color.Transparent);
// Add ListViewItem to ListView
string[] cells = new string[] { table, id.ToString(), category, name };
ListViewItem item = new ListViewItem(cells);
this.listView1.Items.Add(item);
item.ImageIndex = index;
}
// Close Reader
dataReader.Close();
}
// Close Connection
oleConnection.Close();
// Resume ListView Drawing
this.listView1.EndUpdate();
// Display Default Cursor
this.Cursor = Cursors.Default;
}
}
public static class WindowsAPI {
private const int COLORONCOLOR = 3;
private const int HORZSIZE = 4;
private const int VERTSIZE = 6;
private const int HORZRES = 8;
private const int VERTRES = 10;
private const int ASPECTX = 40;
private const int ASPECTY = 42;
private const int LOGPIXELSX = 88;
private const int LOGPIXELSY = 90;
private enum PictureTypeConstants {
picTypeNone = 0,
picTypeBitmap = 1,
picTypeMetafile = 2,
picTypeIcon = 3,
picTypeEMetafile = 4
}
private struct PICTDESC {
public int cbSizeOfStruct;
public int picType;
public IntPtr hPic;
public IntPtr hpal;
public int _pad;
}
private struct RECT {
public int Left;
public int Top;
public int Right;
public int Bottom;
}
[DllImport("olepro32.dll", EntryPoint = "OleCreatePictureIndirect", PreserveSig = false)]
private static extern int OleCreatePictureIndirect(
ref PICTDESC pPictDesc, ref Guid riid, bool fOwn, out IPictureDisp ppvObj);
[DllImport("gdi32.dll", EntryPoint = "CreateCompatibleDC", ExactSpelling = true, SetLastError = true)]
private static extern IntPtr CreateCompatibleDC(IntPtr hDC);
[DllImport("gdi32.dll", EntryPoint = "DeleteDC", ExactSpelling = true, SetLastError = true)]
private static extern bool DeleteDC(IntPtr hdc);
[DllImport("gdi32.dll", EntryPoint = "SelectObject", ExactSpelling = true, SetLastError = true)]
private static extern IntPtr SelectObject(IntPtr hDC, IntPtr hObject);
[DllImport("gdi32.dll", EntryPoint = "DeleteObject", ExactSpelling = true, SetLastError = true)]
private static extern bool DeleteObject(IntPtr hObject);
[DllImport("gdi32.dll", EntryPoint = "CreateCompatibleBitmap", ExactSpelling = true,
SetLastError = true)]
private static extern IntPtr CreateCompatibleBitmap(IntPtr hObject, int width, int height);
[DllImport("user32.dll", EntryPoint = "GetDC", ExactSpelling = true, SetLastError = true)]
private static extern IntPtr GetDC(IntPtr ptr);
[DllImport("user32.dll", EntryPoint = "ReleaseDC", ExactSpelling = true, SetLastError = true)]
private static extern IntPtr ReleaseDC(IntPtr hWnd, IntPtr hDc);
[DllImport("gdi32", EntryPoint = "CreateSolidBrush", ExactSpelling = true, SetLastError = true)]
private static extern IntPtr CreateSolidBrush(int crColor);
[DllImport("user32", EntryPoint = "FillRect", ExactSpelling = true, SetLastError = true)]
private static extern int FillRect(IntPtr hdc, ref RECT lpRect, IntPtr hBrush);
[DllImport("GDI32.dll", EntryPoint = "GetDeviceCaps", ExactSpelling = true, SetLastError = true)]
private static extern int GetDeviceCaps(IntPtr hdc, int nIndex);
[DllImport("user32", EntryPoint = "GetClientRect", ExactSpelling = true, SetLastError = true)]
private static extern int GetClientRect(IntPtr hwnd, ref RECT lpRect);
public static ISymbol GetSymbol(string style, string classname, int id) {
ISymbol symbol = null;
IStyleGallery styleGallery = new StyleGalleryClass();
IStyleGalleryStorage styleGalleryStorage = (IStyleGalleryStorage)styleGallery;
styleGalleryStorage.TargetFile = style;
IEnumStyleGalleryItem styleGalleryItems = styleGallery.get_Items(classname, style, "");
styleGalleryItems.Reset();
IStyleGalleryItem styleGalleryItem = styleGalleryItems.Next();
while (styleGalleryItem != null) {
if (styleGalleryItem.ID == id) {
symbol = (ISymbol)styleGalleryItem.Item;
break;
}
styleGalleryItem = styleGalleryItems.Next();
}
styleGalleryItem = null;
styleGalleryStorage = null;
styleGallery = null;
return symbol;
}
private static IPictureDisp CreatePictureFromSymbol(IntPtr hDCOld, ref IntPtr hBmpNew,
ISymbol pSymbol, Size size, int lGap, int backColor) {
IntPtr hDCNew = IntPtr.Zero;
IntPtr hBmpOld = IntPtr.Zero;
try {
hDCNew = CreateCompatibleDC(hDCOld);
hBmpNew = CreateCompatibleBitmap(hDCOld, size.Width, size.Height);
hBmpOld = SelectObject(hDCNew, hBmpNew);
// Draw the symbol to the new device context.
bool lResult = DrawToDC(hDCNew, size, pSymbol, lGap, backColor);
hBmpNew = SelectObject(hDCNew, hBmpOld);
DeleteDC(hDCNew);
// Return the Bitmap as an OLE Picture.
return CreatePictureFromBitmap(hBmpNew);
}
catch (Exception error) {
if (pSymbol != null) {
pSymbol.ResetDC();
if ((hBmpNew != IntPtr.Zero) && (hDCNew != IntPtr.Zero) && (hBmpOld != IntPtr.Zero)) {
hBmpNew = SelectObject(hDCNew, hBmpOld);
DeleteDC(hDCNew);
}
}
throw error;
}
}
private static IPictureDisp CreatePictureFromBitmap(IntPtr hBmpNew) {
try {
Guid iidIPicture = new Guid("7BF80980-BF32-101A-8BBB-00AA00300CAB");
PICTDESC picDesc = new PICTDESC();
picDesc.cbSizeOfStruct = Marshal.SizeOf(picDesc);
picDesc.picType = (int)PictureTypeConstants.picTypeBitmap;
picDesc.hPic = (IntPtr)hBmpNew;
picDesc.hpal = IntPtr.Zero;
// Create Picture object.
IPictureDisp newPic;
OleCreatePictureIndirect(ref picDesc, ref iidIPicture, true, out newPic);
// Return the new Picture object.
return newPic;
}
catch (Exception error) {
throw error;
}
}
private static bool DrawToWnd(IntPtr hWnd, ISymbol pSymbol, int lGap, int backColor) {
IntPtr hDC = IntPtr.Zero;
try {
if (hWnd != IntPtr.Zero) {
// Calculate size of window.
RECT udtRect = new RECT();
int lResult = GetClientRect(hWnd, ref udtRect);
if (lResult != 0) {
int lWidth = (udtRect.Right - udtRect.Left);
int lHeight = (udtRect.Bottom - udtRect.Top);
hDC = GetDC(hWnd);
// Must release the DC afterwards.
if (hDC != IntPtr.Zero) {
bool ok = DrawToDC(hDC, new Size(lWidth, lHeight), pSymbol, lGap, backColor);
// Release cached DC obtained with GetDC.
ReleaseDC(hWnd, hDC);
return ok;
}
}
}
}
catch {
if (pSymbol != null) {
// Try resetting DC, in case we have already called SetupDC for this symbol.
pSymbol.ResetDC();
if ((hWnd != IntPtr.Zero) && (hDC != IntPtr.Zero)) {
ReleaseDC(hWnd, hDC); // Try to release cached DC obtained with GetDC.
}
}
return false;
}
return true;
}
private static bool DrawToDC(IntPtr hDC, Size size, ISymbol pSymbol, int lGap, int backColor) {
try {
if (hDC != IntPtr.Zero) {
// First clear the existing device context.
if (!Clear(hDC, backColor, 0, 0, size.Width, size.Height)) {
throw new Exception("Could not clear the Device Context.");
}
// Create the Transformation and Geometry required by ISymbol::Draw.
ITransformation pTransformation = CreateTransFromDC(hDC, size.Width, size.Height);
IEnvelope pEnvelope = new EnvelopeClass();
pEnvelope.PutCoords(lGap, lGap, size.Width - lGap, size.Height - lGap);
IGeometry pGeom = CreateSymShape(pSymbol, pEnvelope);
// Perform the Draw operation.
if ((pTransformation != null) && (pGeom != null)) {
pSymbol.SetupDC(hDC.ToInt32(), pTransformation);
pSymbol.Draw(pGeom);
pSymbol.ResetDC();
}
else {
throw new Exception("Could not create required Transformation or Geometry.");
}
}
}
catch {
if (pSymbol != null) {
pSymbol.ResetDC();
}
return false;
}
return true;
}
private static bool Clear(IntPtr hDC, int backgroundColor, int xmin, int ymin, int xmax, int ymax) {
// This function fill the passed in device context with a solid brush,
// based on the OLE color passed in.
IntPtr hBrushBackground = IntPtr.Zero;
int lResult;
bool ok;
try {
RECT udtBounds;
udtBounds.Left = xmin;
udtBounds.Top = ymin;
udtBounds.Right = xmax;
udtBounds.Bottom = ymax;
hBrushBackground = CreateSolidBrush(backgroundColor);
if (hBrushBackground == IntPtr.Zero) {
throw new Exception("Could not create GDI Brush.");
}
lResult = FillRect(hDC, ref udtBounds, hBrushBackground);
if (hBrushBackground == IntPtr.Zero) {
throw new Exception("Could not fill Device Context.");
}
ok = DeleteObject(hBrushBackground);
if (hBrushBackground == IntPtr.Zero) {
throw new Exception("Could not delete GDI Brush.");
}
}
catch {
if (hBrushBackground != IntPtr.Zero) {
ok = DeleteObject(hBrushBackground);
}
return false;
}
return true;
}
private static ITransformation CreateTransFromDC(IntPtr hDC, int lWidth, int lHeight) {
// Calculate the parameters for the new transformation,
// based on the dimensions passed to this function.
try {
IEnvelope pBoundsEnvelope = new EnvelopeClass();
pBoundsEnvelope.PutCoords(0.0, 0.0, (double)lWidth, (double)lHeight);
tagRECT deviceRect;
deviceRect.left = 0;
deviceRect.top = 0;
deviceRect.right = lWidth;
deviceRect.bottom = lHeight;
int dpi = GetDeviceCaps(hDC, LOGPIXELSY);
if (dpi == 0) {
throw new Exception("Could not retrieve Resolution from device context.");
}
// Create a new display transformation and set its properties.
IDisplayTransformation newTrans = new DisplayTransformationClass();
newTrans.VisibleBounds = pBoundsEnvelope;
newTrans.Bounds = pBoundsEnvelope;
newTrans.set_DeviceFrame(ref deviceRect);
newTrans.Resolution = dpi;
return newTrans;
}
catch {
return null;
}
}
private static IGeometry CreateSymShape(ISymbol pSymbol, IEnvelope pEnvelope) {
// This function returns an appropriate Geometry type depending on the
// Symbol type passed in.
try {
if (pSymbol is IMarkerSymbol) {
// For a MarkerSymbol return a Point.
IArea pArea = (IArea)pEnvelope;
return pArea.Centroid;
}
else if ((pSymbol is ILineSymbol) || (pSymbol is ITextSymbol)) {
// For a LineSymbol or TextSymbol return a Polyline.
IPolyline pPolyline = new PolylineClass();
pPolyline.FromPoint = pEnvelope.LowerLeft;
pPolyline.ToPoint = pEnvelope.UpperRight;
return pPolyline;
}
else {
// For any FillSymbol return an Envelope.
return pEnvelope;
}
}
catch {
return null;
}
}
public static Bitmap SymbolToBitmap(ISymbol userSymbol, Size size, Graphics gr, int backColor) {
IntPtr graphicsHdc = gr.GetHdc();
IntPtr hBitmap = IntPtr.Zero;
IPictureDisp newPic = CreatePictureFromSymbol(
graphicsHdc, ref hBitmap, userSymbol, size, 1, backColor);
Bitmap newBitmap = Bitmap.FromHbitmap(hBitmap);
gr.ReleaseHdc(graphicsHdc);
return newBitmap;
}
}
}
ESRI's ArcGIS Desktop product includes the applications ArcCatalog, ArcMap, ArcScene and ArcGlobe. The user interfaces of all four applications can be heavily customized by developers, for example, a developer can deploy custom toolbars and buttons.
A button (or command in ESRI terminology) is a COM class that implements the ICommand interface. Some commands require geographic interaction, for example, clicking on a country in a world map. These commands must implement the ITool interface.
Normally, developers create sets of commands that are specific to each project. In this article I will discuss an out-of-the-box command called Generic Get Point Tool that can be used for map/globe interaction. Using this command in future projects may reduce your development time.
To demonstrate this command I have created an ArcGIS Engine-based windows application sample using Microsoft .Net Framework 2.0. The application consists of a map, an invisible toolbar and a button that will activate the Generic Get Point Tool. After the map is clicked, a message box will display the map coordinates of the clicked location and then deactivate the tool.
The sample windows application (C#) was created using Microsoft Visual Studio 2005. It consists of a map control, toolbar control, license control and a button. The map control is assigned to the toolbar control's buddy property and the map control's is assigned a map document to load at runtime.
When the form loads, the Generic Get Point Tool is added to the toolbar and then by casting the command to the IToolPositionInitializer the form is assigned as the callback (because it supports IToolPositionCallback).
When the button is clicked the Generic Get Point Tool is located on the toolbar and then assigned as the current tool. This essentially activates the tool and deactivates the previously active tool (if any).
When the user clicks on the map display with the Generic Get Point Tool activated, the command will called the MouseClicked method on the IToolPositionCallback interface. In the sample, the form implements this interface and displays a message box displaying the map coordinates. Rather than leaving the tool active, setting IToolbarControl::CurrentTool (or IMapControl::CurrentTool) to null effectively deactivate the tool.
The sample code follows:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using ESRI.ArcGIS.Controls;
using ESRI.ArcGIS.esriSystem;
using ESRI.ArcGIS.SystemUI;
using ESRI.ArcGIS.Geometry;
namespace WindowsApplication1 {
public partial class Form1 : Form, IToolPositionCallback{
public Form1() {
InitializeComponent();
}
private void Form1_Load(object sender, EventArgs e) {
// Hide ESRI Toolbar
this.axToolbarControl1.Hide();
// Add Generic Get Point Tool
UID uid = new UIDClass();
uid.Value = "{30DBCBEF-951E-4904-89DE-5A5F1AF571EE}";
IToolbarControl toolbarControl = (IToolbarControl)this.axToolbarControl1.Object;
toolbarControl.AddItem(uid, -1, -1, false, -1, esriCommandStyles.esriCommandStyleIconOnly);
// Find Generic Get Point Tool on Toolbar
int index = toolbarControl.Find(uid);
IToolbarItem toolbarItem = toolbarControl.GetItem(index);
ICommand command = toolbarItem.Command;
// Assign Callback to Generic Get Point Tool
IToolPositionInitializer toolPositionInitializer = (IToolPositionInitializer)command;
toolPositionInitializer.Initialize(this, -1);
}
private void Button_Click(object sender, EventArgs e) {
if (sender == this.buttonGetPoint) {
// Find Generic Get Point Tool
UID uid = new UIDClass();
uid.Value = "{30DBCBEF-951E-4904-89DE-5A5F1AF571EE}";
IToolbarControl toolbarControl = (IToolbarControl)this.axToolbarControl1.Object;
int index = toolbarControl.Find(uid);
IToolbarItem toolbarItem = toolbarControl.GetItem(index);
ICommand command = toolbarItem.Command;
ITool tool = (ITool)command;
// Set Generic Get Point Tool as the current tool
toolbarControl.CurrentTool = tool;
}
}
#region IToolPositionCallback Members
public void Deactivated() { }
public void MouseClicked(int lCookie, int button, int shift, int X, int Y, double mapX, double mapY,
ISpatialReference pSpace) {
// Display Message
string message = string.Format(
"Map location" + Environment.NewLine +
"X: {0}" + Environment.NewLine +
"Y: {1}",
mapX.ToString(),
mapY.ToString());
MessageBox.Show(message, "Test", MessageBoxButtons.OK, MessageBoxIcon.Information);
// Deactivate Generic Get Point Tool
IToolbarControl toolbarControl = (IToolbarControl)this.axToolbarControl1.Object;
toolbarControl.CurrentTool = null;
}
#endregion
}
} 
ESRI's ArcGIS Desktop product is comprised of a number of applications. These include ArcCatalog, ArcMap, ArcScene and ArcGlobe. All of which can be heavily customized by developers using any COM or .NET language.
For developers using a COM compatible language like C++ or VB6 deployment is fairly easy. Deployment would consist of running regsvr32.exe against compiled DLLs on target machines.
To register a COM DLL:
regsvr32.exe /s .\MyCommand.dll
To unregister a COM DLL:
regsvr32.exe /u /s .\MyCommand.dll
For more information on Packing and deployment ArcGIS Desktop components please visit EDN.
But now most of us have embraced C# (or VB.NET) and consider VB6 a distant memory. The hardships endured using VB6 are long forgotten. However, whilst .NET development is a joy to use it can be a nightmare to deployment. In this article I will describe the dangers of creating an install (msi) using installer classes and document a robust alternative.
The EDN article How to create a custom install program has step by step instructions on how to create a Setup Project for .NET assemblies that contain custom components. This method involves the addition of an installer class in the .NET assembly to correctly register the .NET assembly for COM interop. The installer class is called by the Windows Installer application (at install time) on target computers. Problems arise if:
If the Windows Installer application fails to install you may get an error message like:
"Unable to get installer types in the C:\program files\application_name\app.dll assembly. --> One or more of the types in the assembly unable to load."
This problem can be easily resolved by the user on the target computer by install one or more of the missing components listed above.
However, once installed correctly a user may experience problems uninstalling the custom component if one or more of the dependencies is missing. This may arise if the user has uninstalled ArcGIS Desktop or upgraded (or downgraded) to another version. The only workaround is for the user to restore the same environment as during install time.
Below are XXX easy steps to create a Setup Project for a .NET assembly that is independent of ArcGIS Desktop environment, that is, easy on and easy off.
Step 1: Create a New Project
Start Microsoft Visual Studio 2005 and select File > New > Project...
In the New Project dialog, select Class Library (ArcMap) and enter the name of the project (and assembly). In the example, the name of the project is DeveloperSample. Click OK.
Next, the ArcGIS Project Wizard will appear. You can use this dialog to select ESRI references that may be used in your project. Click Finished to accept the default settings.
The template document automatically created a class called Class1. Select the class in the Solution Explorer and delete it (right click and select Delete).
Step 2: Add an ArcMap Command
Select the newly created project in the Solution Explorer and from the Project dropdown menu select Add New Item....
Select the Base Command item in the ArcGIS category. Enter the name of the new item and click Add. In this example, the name of the new command class is SampleCommand.cs.
Next, the ArcGIS New Item Wizard Option will appear prompting for the type of command that you would like to create. Select Desktop ArcMap Command and then click OK.
Step 3: Edit the Command Class
Your solution should now include a new class, command bitmap and new references to the ESRI assemblies.
Double click on the command class, SampleCommand.cs, to open it in the Visual Studio code editor. Your class should look very similar to the code displayed below. I have made a few minor edits for clarify and edited values of the protected properties like base.m_category. Also, in the overloaded method OnClick I have added a "Hello World" message box. You can do the same in your code, but don't forget to add a reference to the "System.Windows.Forms" assembly in your project.
using System;
using System.Drawing;
using System.Runtime.InteropServices;
using System.Windows.Forms;
using ESRI.ArcGIS.ADF.BaseClasses;
using ESRI.ArcGIS.ADF.CATIDs;
using ESRI.ArcGIS.Framework;
using ESRI.ArcGIS.ArcMapUI;
namespace DeveloperSample {
[Guid("5C0CC07D-A04F-4FE3-BF8E-16645DCBDC1D")]
[ClassInterface(ClassInterfaceType.None)]
[ProgId("DeveloperSample.SampleCommand")]
public sealed class SampleCommand : BaseCommand {
[ComRegisterFunction()]
[ComVisible(false)]
private static void RegisterFunction(Type registerType) {
string regKey = string.Format("HKEY_CLASSES_ROOT\\CLSID\\{{{0}}}", registerType.GUID);
MxCommands.Register(regKey);
}
[ComUnregisterFunction()]
[ComVisible(false)]
private static void UnregisterFunction(Type registerType) {
string regKey = string.Format("HKEY_CLASSES_ROOT\\CLSID\\{{{0}}}", registerType.GUID);
MxCommands.Unregister(regKey);
}
private IApplication m_application = null;
public SampleCommand() {
base.m_category = "DeveloperSample";
base.m_caption = "Sample";
base.m_message = "Sample";
base.m_toolTip = "Sample";
base.m_name = "DeveloperSample_SampleCommand";
try {
string bitmapResourceName = GetType().Name + ".bmp";
base.m_bitmap = new Bitmap(GetType(), bitmapResourceName);
}
catch (Exception ex) {
System.Diagnostics.Trace.WriteLine(ex.Message, "Invalid Bitmap");
}
}
public override void OnCreate(object hook) {
if (hook == null) {
return;
}
this.m_application = hook as IApplication;
base.m_enabled = (hook is IMxApplication);
}
public override void OnClick() {
MessageBox.Show("Hello World");
}
}
}
Step 4: Test the Command in ArcMap
Start ArcMap from the Windows Start menu (Start > All Programs > ArcGIS > ArcMap). Display the Customize dialog by clicking Tools > Customize...
When the Customize dialog appear click the Commands tab and click on the category name (base.m_category) used by you command. When clicked, all commands that use that category will be listed in the box on the right hand side. Click on the command that you created above, the name of the command comes from the base.m_caption value.
Drag the command from the Customize dialog to the any existing toolbar. Click close on the Customize dialog.
Click the command to display the "Hello World" message box.
Step 5: Export Interop Registry Information from the Assembly.
The ArcGIS Desktop product was first release in 2000. The desktop applications are written in C++ and reference a large collection of ESRI developed COM components called ArcObjects.
Because ArcMap only recognizes COM components we need to make our .NET assembly look like COM DLL with COM classes. This is easier than it sounds!
Start Windows Explorer and navigate to your project folder. In my case the project folder is C:\TEST\DeveloperSample. Inside this folder you should see your Visual Studio Project (.csprj) and Solution (.sln).
From the Window Explorer main menu select File > New > Text Document. This will create a new empty text document in your project folder. Right click on the text file and select Rename. Type "MAKE.BAT" and then press ENTER. You may be prompted to confirm the renaming, if so click Yes.
Open the BAT file using a text editor like Microsoft Notepad and enter the following text as a single line.
C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\regasm.exe C:\TEST\DeveloperSample\bin\Debug\DeveloperSample.dll /codebase /regfile:DeveloperSample.reg
Where:
Save the changes to the MAKE.BAT in the text editor. Close the text editor.
Return to the Windows Explorer, double click on MAKE.BAT.
Running the BAT file will launch a DOS command window as shown below. Briefly you will see messages from the REGASM command displayed. When the REGASM command is complete the DOS command window will disappear.
In the project folder you will see a new file called DeveloperSample.reg.
Step 6: Edit the Interop Registry Information
Open the registry file DeveloperSample.reg in a text editor like Microsoft Notepad. You will see hard-coded references to the location of the .NET assembly. We need to change this pathname so that it reflects the pathname of the installed assembly on target computers.
Search and replace the text in the text editor so that the codebase entry reads:
"CodeBase"="[TARGETDIR]DeveloperSample.dll"
The [TARGETDIR] flag will be substituted by the Windows Installer application at install time for the correct pathname.
The registry information created by REGASM exposes the .NET class to COM. That is, to an application like ArcMap, your command looks, tastes and feels like a COM class.
Before we are done we need to add one more piece of information. When ArcMap starts up it scans through the registry looking for COM classes that are commands. The registry contains literally thousands of COM classes but only a new few hundred are ArcMap commands. To identify our class SampleCommand as an ArcMap command we need to add a category component to the registry.
The category component for an ArcMap command is:
{B56A7C42-83D4-11D2-A2E9-080009B6F22B}
At the end of the registry file, DeveloperSample.reg, add the following line:
[HKEY_CLASSES_ROOT\CLSID\\Implemented Categories\{B56A7C42-83D4-11D2-A2E9-080009B6F22B}]
(Microsoft Notepad with Word Wrap enabled)
Save changes in the text editor and then close the application.
In future, you may develop other types of ArcGIS application customizations. Here are a few commonly used category component guids:
[ComVisible(false)]
public sealed class EsriRegistry {
// General
public const string COMPONENT_LAYER_PROPERTY_PAGE = "{1476C782-6F57-11D2-A2C6-080009B6F22B}";
public const string COMPONENT_LAYER_FACTORY = "{34C20001-4D3C-11D0-92D8-00805F7C28B0}";
public const string COMPONENT_RENDERER_PROPERTY_PAGE = "{962BD9A9-1EC8-11D3-9F4D-00C04F6BC709}";
// ArcMap
public const string COMPONENT_MX_COMMAND = "{B56A7C42-83D4-11D2-A2E9-080009B6F22B}";
public const string COMPONENT_MX_TOOLBAR = "{B56A7C4A-83D4-11D2-A2E9-080009B6F22B}";
public const string COMPONENT_MX_DOCKABLEWINDOW = &quo