I just wanted to understand which programming language is used to develop the ArcGIS Desktop application, through my initial research I got to know that ArcGIS Desktop was created by using C++.
I just wanted to confirm if that is the case.
[GIS] Which programming language is used to develop ArcGIS Desktop application
arcgis-desktoparcobjectsc
Related Solutions
The code below works for me. If you load a new map, you'll need to re-wire your events. Maybe try start animating when IDisplayEvents.Start fires (and IViewRefresh.Drawing is true). Then stop animating when IActiveViewEvents.AfterDraw fires with drawPhase == esriViewDrawPhase.esriViewForeground.
private IDisplayEvents_Event m_dispevt;
private IActiveViewEvents_Event m_avEvt;
private int m_lastTick;
private void WireEvents(IMap map)
{
Debug.Print("wiring");
m_dispevt = ((IActiveView)map).ScreenDisplay as IDisplayEvents_Event;
m_dispevt.DisplayStarted += new IDisplayEvents_DisplayStartedEventHandler(MainForm_DisplayStarted);
m_dispevt.DisplayFinished += new IDisplayEvents_DisplayFinishedEventHandler(MainForm_DisplayFinished);
m_dispevt.DisplayInvalidated += new IDisplayEvents_DisplayInvalidatedEventHandler(MainForm_DisplayInvalidated);
m_dispevt.DisplayScrolled += new IDisplayEvents_DisplayScrolledEventHandler(MainForm_DisplayScrolled);
m_avEvt = (IActiveViewEvents_Event)map;
m_avEvt.AfterDraw += new IActiveViewEvents_AfterDrawEventHandler(m_avEvt_AfterDraw);
m_avEvt.AfterItemDraw += new IActiveViewEvents_AfterItemDrawEventHandler(m_avEvt_AfterItemDraw);
}
void m_avEvt_AfterItemDraw(short Index, IDisplay Display, esriDrawPhase phase)
{
Debug.Print("afteritemdraw {0} {1}", Index, phase);
}
void m_avEvt_AfterDraw(IDisplay Display, esriViewDrawPhase phase)
{
if(phase == esriViewDrawPhase.esriViewForeground)
Debug.Print("foreground finished afterdraw {0} {1} msecs", phase, Environment.TickCount - m_lastTick);
if (phase == esriViewDrawPhase.esriViewBackground)
m_lastTick = Environment.TickCount;
}
void MainForm_DisplayScrolled(IDisplay Display, int deltaX, int deltaY)
{
Debug.Print("scrolled");
}
void MainForm_DisplayInvalidated(IDisplay Display, ESRI.ArcGIS.Geometry.IEnvelope rect, bool erase, short cacheID)
{
Debug.Print("invalidated");
}
void MainForm_DisplayFinished(IDisplay Display)
{
Debug.Print("finished");
}
void MainForm_DisplayStarted(IDisplay Display)
{
Debug.Print("started {0}", ((IViewRefresh)axMapControl1.Map).Drawing);
}
The answer to this question is yes and no. It is possible with some effort to do everything in Python that you could do in .Net, but easy and possible are two very different things. Following that, the simplest interpretation is no, Python Add-Ins cannot do as much as .Net Add-Ins. However, the tasks Python Add-Ins can accomplish are much easier and faster to implement and test.
From a purely technical point of view, the ArcGIS Desktop Add-In Framework offers the following functionality:
- A well-defined, XML-based schema for describing a series of common desktop integration points and components: Buttons, Toolbars, Menus, Tools, Multi-Item Menus and Extensions, as well as a way to easily connect these in a declarative way from your code to ArcGIS desktop
- A file format and file structure (
.esriaddin) for distributing desktop customization code. - A mechanism for installing, verifying and caching installed
.esriaddins, so if the injstalled Add-In's source file has changed, it will reload the changed file into the local desktop Add-In cache. - A set of security and authentication mechanisms for the code in Add-Ins: digital signing of
.esriaddinfiles, administrative control over what level of authentication is required to permit installation of an Add-In.
What the Add-In framework here lacks is any formal contract of the behavior or functionality behind buttons, etc. When you install the .Net SDK for ArcGIS, you get Visual Studio integration in the form of Add-In Wizards in your project management dialogs, documentation, code snippets, ArcObjects bindings, etc. So once you're past the entry points the Add-In framework provides, a .Net Add-In lets you go the rest of the way with the ArcObjects APIs it also comes bundled with, as well as containing a library of code snippets of common tasks already there to use. There is no such Python Developer SDK in ArcGIS: all of Python's functionality with exposed through arcgisscripting/arcpy and is already bundled in the product. So, where the .Net SDK comes as a large download, the closest thing in Python is the relatively small Add-In Wizard download.
On the other hand, Python is capable of consuming/implementing COM interfaces, but using COM from Python is not bundled with any ArcGIS SDK or documented in the ArcGIS help system. If you're new to developing in ArcGIS, this should be enough of a barrier to entry to push you away unless you really know what you're doing. You can do COM in Python here, but it's close enough to a Turing Tarpit that it's be hard to justify the time spent unless you're an expert-level user already familiar with the ins and outs of COM and ArcObjects.
I'd recommend you look at what you can do with arcpy. You can automate a lot of tasks such as calling Geoprocessing tools and doing batch manipulation of map documents, and Python Add-Ins let you use certain well-defined event sinks and some dialog controls in addition to arcpy's base capabilities. If you can't think of a way to accomplish your task in Python based on what the documentation says (you need some complex user interface interaction or hook into events not exposed in the Python Add-In Wizard or use something only available in ArcObjects), then do your development in a .Net Add-In.
Sorry this is more nuanced than a hard-and-fast yes or no answer, but it should give you some bearing as to whether you should go the Python or the .Net route in your Add-In.
I suppose I should add this disclosure: I designed and developed much of the Python specific functionality to Add-Ins in ArcGIS.
Best Answer
From an older version (9.2) of the ArcGIS architecture documentation (you can do a quick search for some of the following text to find the relevant resources - I don't want to link a PDF download):
The 'thick and thin clients' (ArcMap, ArcGIS Server) were also created using C++, although I can't find any authoritative documentation to back this up aside from a mention in the Wikipedia article.