DefenseSolutions

' Helper method.

Private Function MakeMoleElement(ByVal SymbolID As String, ByVal lat As Double, ByVal lon As Double) As IElement
    ' Create the point.
    Dim lox As IPoint = New PointClass()
    lox.PutCoords(lon, lat)
    
    ' Create the symbol.
    Dim ms As IMoleSymbol = New MoleMarkerSymbolClass()
    ms.SymbolID = SymbolID
    
    ' Create the MarkerElement and attach the symbol.
    Dim [Me] As IMarkerElement = New MarkerElementClass()
    [Me].Symbol = TryCast(ms, IMarkerSymbol)
    
    ' Attach the geometry.
    Dim em As IElement = TryCast([Me], IElement)
    em.Geometry = TryCast(loki, IGeometry)
    Return em
End Function

' Application code.
Private mme As IElement = MakeMoleElement("SFGPUCAWW------", 45, -90)
m_ActiveView.GraphicsContainer.AddElement(mme, 0)

// Helper method.
private IElement MakeMoleElement(string SymbolID, double lat, double lon)
{
    // Create the point.
    IPoint lox = new PointClass();
    lox.PutCoords(lon, lat);

    // Create the symbol.
    IMoleSymbol ms = new MoleMarkerSymbolClass();
    ms.SymbolID = SymbolID;

    // Create the MarkerElement and attach the symbol.
    IMarkerElement me = new MarkerElementClass();
    me.Symbol = ms as IMarkerSymbol;

    // Attach the geometry.
    IElement em = me as IElement;
    em.Geometry = loki as IGeometry;

    return em;
}

// Application code.
IElement mme = MakeMoleElement("SFGPUCAWW------", 45,  - 90);
m_ActiveView.GraphicsContainer.AddElement(mme, 0);

// Creates a MoleMarkerSymbol and attaches it to a MarkerElement.
IElementPtr MakeMoleElement(CComBSTR SymbolID, double lat, double lon)
{
  // create the point
  IPointPtr lox(CLSID_Point);
  lox->PutCoords(lon, lat);

  // create the symbol
  IMoleSymbolPtr ms(CLSID_MoleMarkerSymbol);
  ms->put_SymbolID(SymbolID);

  // create the MarkerElement & attach the symbol
  IMarkerElementPtr me(CLSID_MarkerElement);
  IMarkerSymbolPtr markerSymbol(ms);
  me->put_Symbol(markerSymbol);

  // now attach the geometry
  IElementPtr elem(me); // as IElement;
  elem->put_Geometry(lox);
  return elem;
}

// Client code
IElementPtr mme = MakeMoleElement(L "SFGPUCAWW------", 45,  - 90);
m_ipActiveView->get_GraphicsContainer()->AddElement(mme, 0);

Private Sub DrawMoleLineElement(ByVal Line As IPolyline)
    ' Create the symbol (use a sample SIC).
    Dim ms As IMoleSymbol = New MoleLineSymbolClass()
    ms.SymbolID = "GUTPF---------X"
    ms.TextSize = 2.0
    
    ' Create the LineElement and attach the symbol.
    Dim lem As ILineElement = New LineElementClass()
    lem.Symbol = TryCast(ms, ILineSymbol)
    
    ' Attach the geometry.
    Dim em As IElement = TryCast(lem, IElement)
    em.Geometry = TryCast(Line, IGeometry)
    
    ' Add it to the active view.
    m_ActiveView.GraphicsContainer.AddElement(em, 0)
End Sub

private void DrawMoleLineElement(IPolyline line)
{
    // Create the symbol (use a sample SIC).
    IMoleSymbol ms = new MoleLineSymbolClass();
    ms.SymbolID = "GUTPF---------X";
    ms.TextSize = 2.0;

    // Create the LineElement and attach the symbol.
    ILineElement lem = new LineElementClass();
    lem.Symbol = ms as ILineSymbol;

    // Attach the geometry.
    IElement em = lem as IElement;
    em.Geometry = line as IGeometry;

    // Add it to the map.
    m_ActiveView.GraphicsContainer.AddElement(em, 0);
}

void DrawMoleLineElement(IPolylinePtr line)
{
  // create the symbol
  IMoleSymbolPtr ms(CLSID_MoleLineSymbol);
  ms->put_SymbolID(L "GUTPF---------X");
  ms->put_TextSize(2.0);

  // create the LineElement & attach the symbol
  ILineElementPtr lem(CLSID_LineElement);
  ILineSymbolPtr lineSym = ms;
  lem->put_Symbol(lineSym);

  // now attach the geometry
  IElementPtr em = lem;
  em->put_Geometry(line);

  // add to the map
  m_ipActiveView()->get_GraphicsContainer()->AddElement(em, 0);
}

Private Sub AddMoleGroupElement()
    ' Create the group element.
    Dim gem As IMoleGroupElement = New MoleGroupElementClass()
    
    ' Add a few symbols to it.
    Dim group As IGroupElement = TryCast(gem, IGroupElement)
    group.AddElement(MakeMoleElement("SFGPUCAWW------", 45, -90))
    group.AddElement(MakeMoleElement("SFGP-----------", 46, -91))
    
    ' Enable decluttering and select the option.
    gem.DeclutterOption = moleDeclutterOptionEnum.moleDeclutterNone
    gem.EnableDeclutter = True
    
    ' Add the group element to the map.
    m_ActiveView.GraphicsContainer.AddElement(TryCast(gem, IElement), 0)
End Sub

' Helper method.

Private Function MakeMoleElement(ByVal SymbolID As String, ByVal lat As Double, ByVal lon As Double) As IElement
    ' Create the point.
    Dim lox As IPoint = New PointClass()
    lox.PutCoords(lon, lat)
    
    ' Create the symbol.
    Dim ms As IMoleSymbol = New MoleMarkerSymbolClass()
    ms.SymbolID = SymbolID
    
    ' Create the MarkerElement and attach the symbol.
    Dim [Me] As IMarkerElement = New MarkerElementClass()
    [Me].Symbol = TryCast(ms, IMarkerSymbol)
    
    ' Attach the geometry.
    Dim em As IElement = TryCast([Me], IElement)
    em.Geometry = TryCast(loki, IGeometry)
    Return em
End Function

private void AddMoleGroupElement()
{
    // Create the group element.
    IMoleGroupElement gem = new MoleGroupElementClass();

    // Add a few symbols to it.
    IGroupElement group = gem as IGroupElement;
    group.AddElement(MakeMoleElement("SFGPUCAWW------", 45,  - 90));
    group.AddElement(MakeMoleElement("SFGP-----------", 46,  - 91));

    // Enable decluttering and select the option.
    gem.DeclutterOption = moleDeclutterOptionEnum.moleDeclutterNone;
    gem.EnableDeclutter = true;

    // Add the group element to the map.
    m_ActiveView.GraphicsContainer.AddElement(gem as IElement, 0);
}

// Helper method.
private IElement MakeMoleElement(string SymbolID, double lat, double lon)
{
    // Create the point.
    IPoint lox = new PointClass();
    lox.PutCoords(lon, lat);

    // Create the symbol.
    IMoleSymbol ms = new MoleMarkerSymbolClass();
    ms.SymbolID = SymbolID;

    // Create the MarkerElement and attach the symbol.
    IMarkerElement me = new MarkerElementClass();
    me.Symbol = ms as IMarkerSymbol;

    // Attach the geometry.
    IElement em = me as IElement;
    em.Geometry = loki as IGeometry;

    return em;
}

void AddMoleGroupElement()
{
  // create the group element
  IMoleGroupElementPtr gem(CLSID_MoleGroupElement);

  // add a few symbols to it
  IGroupElementPtr gElem(gem);
  IGroupElementPtr group = gElem;
  CComBSTR x("");
  group->AddElement(MakeMoleElement(L "SFGPUCAWW------", 45,  - 90));
  group->AddElement(MakeMoleElement(L "SFGP-----------", 46,  - 91));

  // enable decluttering and select the option
  gem->put_DeclutterOption(moleDeclutterNone);
  gem->put_EnableDeclutter(VARIANT_TRUE);

  // add the group element to the map
  m_ActiveView.GraphicsContainer.AddElement(gem, 0);
}

Private Sub LeaderGroupElement(ByVal mge As IMoleGroupElement)
    ' Switch to leadering.
    mge.DeclutterOption = moleDeclutterOptionEnum.moleDeclutterLeader
    
    ' Set the leadering properties (use default black AnchorSymbol and LineSymbol).
    Dim mle As IMoleLeaderElement = TryCast(mge, IMoleLeaderElement)
    mle.LeaderQuadrant = moleQuadrantEnum.moleQuadrantUR
    
    ' Create the anchor and base points.
    Dim anchor As IPoint = New PointClass()
    anchor.PutCoords(0, 0)
    Dim basep As IPoint = New PointClass()
    basep.PutCoords(0.05, 0.05)
    
    ' Set the anchor and base locations.
    mle.Anchor = anchor
    mle.Base = basep
    
    ' Set the leader visibility.
    mle.LeaderVisible = True
End Sub

Private Sub StackGroupElement(ByVal mge As IMoleGroupElement)
    ' Switch to stacking.
    mge.DeclutterOption = moleDeclutterOptionEnum.moleDeclutterStack
    
    ' Set the stacking property.
    Dim mse As IMoleStackElement = TryCast(mge, IMoleStackElement)
    mse.StackQuadrant = moleQuadrantEnum.moleQuadrantLR
End Sub

private void LeaderGroupElement(IMoleGroupElement mge)
{
    // Switch to leadering.
    mge.DeclutterOption = moleDeclutterOptionEnum.moleDeclutterLeader;

    // Set the leadering properties (use default black AnchorSymbol and LineSymbol).
    IMoleLeaderElement mle = mge as IMoleLeaderElement;
    mle.LeaderQuadrant = moleQuadrantEnum.moleQuadrantUR;

    // Create the anchor and base points.
    IPoint anchor = new PointClass();
    anchor.PutCoords(0, 0);
    IPoint basep = new PointClass();
    basep.PutCoords(0.05, 0.05);

    // Set the anchor and base locations.
    mle.Anchor = anchor;
    mle.Base = basep;

    // Set the leader visibility.
    mle.LeaderVisible = true;
}

private void StackGroupElement(IMoleGroupElement mge)
{
    // Switch to stacking.
    mge.DeclutterOption = moleDeclutterOptionEnum.moleDeclutterStack;

    // Set the stacking property.
    IMoleStackElement mse = mge as IMoleStackElement;
    mse.StackQuadrant = moleQuadrantEnum.moleQuadrantLR;
}

// Leadering
void LeaderGroupElement(IMoleGroupElementPtr mge)
{
  // switch to leadering
  mge->put_DeclutterOption(moleDeclutterLeader);

  // set leadering properties (use default black AnchorSymbol & LineSymbol)
  IMoleLeaderElementPtr mle(mge);
  mle->put_LeaderQuadrant(moleQuadrantUR);

  // create the anchor and base points
  IPointPtr anchor(CLSID_Point);
  anchor->PutCoords(0, 0);
  IPointPtr basep(CLSID_Point);
  basep->PutCoords(0.05, 0.05);

  // set the anchor & base locations
  mle->put_Anchor(anchor);
  mle->put_Base(basep);

  // set the leader visibility
  mle->put_LeaderVisible(VARIANT_TRUE);
}

// Stacking
void StackGroupElement(IMoleGroupElementPtr mge)
{
  // switch to stacking
  mge->put_DeclutterOption(moleDeclutterStack);

  // set stacking property
  IMoleStackElementPtr mse(mge);
  mse->put_StackQuadrant(moleQuadrantLR);
}

Private Sub btnLoadFE_Click(ByVal sender As Object, ByVal e As EventArgs)
    ' Open the geodatabase and get a workspace.
    Dim dbPath As String = "..\..\data\MilitaryOverlayEditor\mole_data.mdb"
    Dim wsf As IWorkspaceFactory = New AccessWorkspaceFactoryClass()
    Dim ws As IWorkspace = wsf.OpenFromFile(dbPath, 0)
    
    ' Get a feature workspace and open the feature class.
    Dim fcName As String = "force_element"
    Dim featWorkspace As IFeatureWorkspace = TryCast(ws, IFeatureWorkspace)
    Dim fc As IFeatureClass = featWorkspace.OpenFeatureClass(fcName)
    
    ' Load the feature class onto the map.
    Dim basicMap As IBasicMap = TryCast(m_ActiveView.FocusMap, IBasicMap)
    LoadMOLEForceElementLayer(fc, basicMap, "MOLE Force Element", .05, True)
    ' Size is ratio of display height.
End Sub


' Load a MOLE feature class as a MOLE Force Element layer into the current IBasicMap (Map, Globe, or Scene).

Public Sub LoadMOLEForceElementLayer(ByVal featureClass As IFeatureClass, ByVal basicMap As IBasicMap, ByVal layerName As String, ByVal Size As Double, ByVal sizeIsRatio As Boolean)
    ' True if size is ratio of the display height.
    
    ' Get a geo feature layer interface from the input Feature Class.
    Dim geoFeatureLayer As IGeoFeatureLayer = New TryCast(FeatureLayer(), IGeoFeatureLayer)
    geoFeatureLayer.FeatureClass = featureClass
    
    ' Get a MOLE cached graphic feature layer interface from the geo feature layer.
    Dim cachedGraphicFeatureLayer As ICachedGraphicFeatureLayer = New TryCast(ForceElementLayerClass(), ICachedGraphicFeatureLayer)
    cachedGraphicFeatureLayer.FeatureLayer = geoFeatureLayer
    
    ' Set the symbol size and SizeIsRatio properties of the layer.
    Dim forceElementLayer As IForceElementLayer = TryCast(cachedGraphicFeatureLayer, IForceElementLayer)
    forceElementLayer.Size = Size
    forceElementLayer.SizeIsRatio = sizeIsRatio
    
    ' Add the Force Element layer to the map.
    Dim layer As ILayer = TryCast(cachedGraphicFeatureLayer, ILayer)
    layer.Name = layerName
    basicMap.AddLayer(layer)
End Sub

private void btnLoadFE_Click(object sender, EventArgs e)
{
    // Open the geodatabase and get a workspace. 
    string dbPath = @"..\..\data\MilitaryOverlayEditor\mole_data.mdb";
    IWorkspaceFactory wsf = new AccessWorkspaceFactoryClass();
    IWorkspace ws = wsf.OpenFromFile(dbPath, 0);

    // Get a feature workspace and open the feature class. 
    string fcName = "force_element";
    IFeatureWorkspace featWorkspace = ws as IFeatureWorkspace;
    IFeatureClass fc = featWorkspace.OpenFeatureClass(fcName);

    // Load the feature class onto the map. 
    IBasicMap basicMap = m_ActiveView.FocusMap as IBasicMap;
    LoadMOLEForceElementLayer(fc, basicMap, "MOLE Force Element",  // Layer name. 
    .05,  // Size of graphics. 
    true); // Size is ratio of display height. 
}


// Load a MOLE feature class as a MOLE Force Element layer into the current IBasicMap (Map, Globe, or Scene). 
public void LoadMOLEForceElementLayer(IFeatureClass featureClass,  
    // The Feature Class to load. 
IBasicMap basicMap,  // The map, scene, or globe. 
String layerName,  // The name to assign to the layer. 
Double size,  // The size of graphics in map units. 
Boolean sizeIsRatio) // True if size is ratio of the display height.
{
    // Get a geo feature layer interface from the input Feature Class.
    IGeoFeatureLayer geoFeatureLayer = new FeatureLayer()as IGeoFeatureLayer;
    geoFeatureLayer.FeatureClass = featureClass;

    // Get a MOLE cached graphic feature layer interface from the geo feature layer.
    ICachedGraphicFeatureLayer cachedGraphicFeatureLayer = new
        ForceElementLayerClass()as ICachedGraphicFeatureLayer;
    cachedGraphicFeatureLayer.FeatureLayer = geoFeatureLayer;

    // Set the symbol size and SizeIsRatio properties of the layer. 
    IForceElementLayer forceElementLayer = cachedGraphicFeatureLayer as
        IForceElementLayer;
    forceElementLayer.Size = size;
    forceElementLayer.SizeIsRatio = sizeIsRatio;

    // Add the Force Element layer to the map.
    ILayer layer = cachedGraphicFeatureLayer as ILayer;
    layer.Name = layerName;
    basicMap.AddLayer(layer);
}

// Load a Force Element layer onto a map
void LoadFELayer(IFeatureClassPtr ipFC, IBasicMapPtr ipBasicMap)
{
  IGeoFeatureLayerPtr ipFeatureLayer(CLSID_FeatureLayer);
  HRESULT hr = ipFeatureLayer->putref_FeatureClass(ipFC);

  //Create a MOLE layer and attach the feature layer to it.
  ICachedGraphicFeatureLayerPtr ipLayer(CLSID_ForceElementLayer);
  ipLayer->put_FeatureLayer(ipFeatureLayer);

  //Set the size for symbols in the layer.
  IForceElementLayerPtr pForceElementLayer = ipLayer;
  hr = ipForceElementLayer->put_Size(0.05);

  ILayerPtr ipL = ipLayer;
  ipL->put_Name(CComBSTR("My MOLE Layer"));

  ipBasicMap->AddLayer(ipL);
}

Private Sub btnCreateDisplayList_Click(ByVal sender As Object, ByVal e As EventArgs) Handles btnCreateDisplayList.Click
    ' Create the display list.
    m_MoleDisplayList = New ForceElementDisplayListClass()
    Dim fedl As IForceElementDisplayList = TryCast(m_MoleDisplayList, IForceElementDisplayList)
    
    ' Create and add an FE graphic to the display list.
    m_MoleDisplayList.Add(BuildFEG(Nothing, -97.83, 31, DEFAULT_SIC, DEFAULT_NAME, DEFAULT_PARENT))
    
    ' Set the size based on the map extent.
    Dim Size As Double = m_ActiveView.Extent.Height * 0.075
    fedl.Size = Size
    
    ' Partially refresh the map view.
    m_ActiveView.PartialRefresh(esriViewDrawPhase.esriViewForeground, Type.Missing, m_ActiveView.Extent)
End Sub

private void btnCreateDisplayList_Click(object sender, EventArgs e)
{
    // Create the display list.
    m_MoleDisplayList = new ForceElementDisplayListClass();
    IForceElementDisplayList fedl = m_MoleDisplayList as IForceElementDisplayList;

    // Create and add an FE graphic to the display list.
    m_MoleDisplayList.Add(BuildFEG(null,  - 97.83, 31, DEFAULT_SIC, DEFAULT_NAME,
        DEFAULT_PARENT));

    // Set the size based on the map extent.
    double size = m_ActiveView.Extent.Height * 0.075;
    fedl.Size = size;

    // Partially refresh the map view.
    m_ActiveView.PartialRefresh(esriViewDrawPhase.esriViewForeground, Type.Missing,
        m_ActiveView.Extent);
}

' Create a graphic leader and set up its style.
Dim leader As IGraphicLeader = New GraphicLeaderClass()
Dim cached As ICachedGraphic = TryCast(leader, ICachedGraphic)
Dim style As IGraphicLeaderStyle = New BracketLeaderStyleClass()
leader.Style = style

' Use a default size for the leader.
Sizify(cached)

' Build and immediately refresh two FE graphics.
Dim fe1 As ICachedGraphic = BuildFEG(Nothing, -97.5, 31.31, DEFAULT_SIC, DEFAULT_NAME, DEFAULT_PARENT)
Dim fe2 As ICachedGraphic = BuildFEG(Nothing, -97.5, 31.31, DEFAULT_SIC, DEFAULT_NAME, DEFAULT_PARENT)
fe1.Refresh(m_ActiveView.ScreenDisplay)
fe2.Refresh(m_ActiveView.ScreenDisplay)

' Add the graphics to the stack.
leader.Add(TryCast(fe1, ILeaderable))
leader.Add(TryCast(fe2, ILeaderable))

' Add the leader to the map.
AddToMap(cached)

// Create a graphic leader and set up its style.
IGraphicLeader leader = new GraphicLeaderClass();
ICachedGraphic cached = leader as ICachedGraphic;
IGraphicLeaderStyle style = new BracketLeaderStyleClass();
leader.Style = style;

// Use a default size for the leader.
Sizify(cached);

// Build and immediately refresh two FE graphics.
ICachedGraphic fe1 = BuildFEG(null,  - 97.5, 31.31, DEFAULT_SIC, DEFAULT_NAME,
    DEFAULT_PARENT);
ICachedGraphic fe2 = BuildFEG(null,  - 97.5, 31.31, DEFAULT_SIC, DEFAULT_NAME,
    DEFAULT_PARENT);
fe1.Refresh(m_ActiveView.ScreenDisplay);
fe2.Refresh(m_ActiveView.ScreenDisplay);

// Add the graphics to the stack.
leader.Add(fe1 as ILeaderable);
leader.Add(fe2 as ILeaderable);

// Add the leader to the map.
AddToMap(cached);

' Create a graphic stack.
Dim stack As IGraphicStack = New GraphicStackClass()
Dim cached As ICachedGraphic = TryCast(stack, ICachedGraphic)

' Use a default size for the stack.
Sizify(cached)

' Build and immediately refresh two FE graphics.
Dim fe1 As ICachedGraphic = BuildFEG(Nothing, -97.5, 31, DEFAULT_SIC, DEFAULT_NAME, DEFAULT_PARENT)
Dim fe2 As ICachedGraphic = BuildFEG(Nothing, -97.5, 31, DEFAULT_SIC, DEFAULT_NAME, DEFAULT_PARENT)
fe1.Refresh(m_ActiveView.ScreenDisplay)
fe2.Refresh(m_ActiveView.ScreenDisplay)

' Add the graphics to the stack.
stack.Add(TryCast(fe1, IStackable))
stack.Add(TryCast(fe2, IStackable))

' Add the stack to the map.
AddToMap(cached)

// Create a graphic stack.
IGraphicStack stack = new GraphicStackClass();
ICachedGraphic cached = stack as ICachedGraphic;

// Use a default size for the stack.
Sizify(cached);

// Build and immediately refresh two FE graphics.
ICachedGraphic fe1 = BuildFEG(null,  - 97.5, 31, DEFAULT_SIC, DEFAULT_NAME,
    DEFAULT_PARENT);
ICachedGraphic fe2 = BuildFEG(null,  - 97.5, 31, DEFAULT_SIC, DEFAULT_NAME,
    DEFAULT_PARENT);
fe1.Refresh(m_ActiveView.ScreenDisplay);
fe2.Refresh(m_ActiveView.ScreenDisplay);

// Add the graphics to the stack.
stack.Add(fe1 as IStackable);
stack.Add(fe2 as IStackable);

// Add the stack to the map.
AddToMap(cached);

Private Function BuildFEG(ByVal style As IFEGraphicStyle, ByVal x As Double, ByVal y As Double, ByVal SIC As String, ByVal Name As String, ByVal parent As String) As ICachedGraphic
    ' Verify SIC length.
    If SIC.Length <> 15 Then
        SIC = "SFGP-----------"
    End If
    
    ' Create the point.
    Dim pint As IPoint = New PointClass()
    pint.PutCoords(x, y)
    
    ' Create a force element.
    Dim felement As IForceElement = New ForceElementClass()
    felement.MessageString = SIC
    felement.PropertySet.SetProperty("Name", Name)
    felement.PropertySet.SetProperty("Parent", parent)
    felement.Shape = pint
    
    ' Get a force element renderer.
    Dim helper As IMoleCoreHelper = New MoleCoreHelperClass()
    m_FERenderer = helper.ForceElementRenderer
    
    ' Create an FE graphic.
    Dim fegraphic As IFEGraphic = TryCast((TryCast(m_FERenderer, IForceElement2525BRenderer)).GraphicByForceElement(felement), IFEGraphic)
    
    ' Attach the force element to the graphic.
    fegraphic.ForceElement = felement
    
    ' Attach the style if nonnull.
    If Not style Is Nothing Then
        fegraphic.Style = style
    End If
    
    Return TryCast(fegraphic, ICachedGraphic)
End Function

private ICachedGraphic BuildFEG(IFEGraphicStyle style, double x, double y, string
    SIC, string name, string parent)
{
    // Verify SIC length.
    if (SIC.Length != 15)
        SIC = "SFGP-----------";

    // Create the point.
    IPoint pint = new PointClass();
    pint.PutCoords(x, y);

    // Create a force element.
    IForceElement felement = new ForceElementClass();
    felement.MessageString = SIC;
    felement.PropertySet.SetProperty("Name", name);
    felement.PropertySet.SetProperty("Parent", parent);
    felement.Shape = pint;

    // Get a force element renderer.
    IMoleCoreHelper helper = new MoleCoreHelperClass();
    m_FERenderer = helper.ForceElementRenderer;

    // Create an FE graphic.
    IFEGraphic fegraphic = (m_FERenderer as IForceElement2525BRenderer)
        .GraphicByForceElement(felement)as IFEGraphic;

    // Attach the force element to the graphic.
    fegraphic.ForceElement = felement;

    // Attach the style if nonnull.
    if (style != null)
        fegraphic.Style = style;
    return fegraphic as ICachedGraphic;
}

// Illustrates use of the ICacheRenderer and ForceElement2525BRenderer in creating a force element cached graphic object
ICacheRendererPtr m_ipRenderer;
void TestAppDlg::RenderForceElementFeature(IFeaturePtr ipFeature,
  IActiveViewPtr ipActiveView)
{
  if (m_ipRenderer == NULL)
    m_ipRenderer.CreateInstance(CLSID_ForceElement2525BRenderer);
  VARIANT_BOOL canRender;
  m_ipRenderer->CanRenderFeature(ipFeature, &canRender);
  if (canRender == VARIANT_TRUE)
  {
    // get the active view's display
    IScreenDisplayPtr ipScreenDisplay;
    ipActiveView->get_ScreenDisplay(&ipScreenDisplay);

    // get the active view’s extent height
    IEnvelopePtr ipExtent;
    ipActiveView->get_Extent(&ipExtent);
    double height;
    ipExtent->get_Height(&height);

    // get the graphic for the feature
    ICachedGraphicPtr ipGraphic;
    m_ipRenderer->GraphicByFeature(ipScreenDisplay, ipFeature, &ipGraphic);

    // set the graphic size
    ipGraphic->put_Size(0.05 *height);

    // draw the graphic
    long hDC;
    ipScreenDisplay->get_hDC(&hDC);
    ipScreenDisplay->StartDrawing(hDC, 0);
    ipGraphic->Draw(ipScreenDisplay, NULL);
    ipScreenDisplay->FinishDrawing();
  }
}

' Create a color.
Dim RGB As IRgbColor = New RgbColorClass()
RGB.Blue = 200

' Create a fill symbol.
Dim sfs As ISimpleFillSymbol = New SimpleFillSymbolClass()
sfs.Color = RGB

' Create a font.
Dim font As IFontDisp = ESRI.ArcGIS.ADF.Converter.ToStdFont(New System.Drawing.Font("Courier New", 20, System.Drawing.FontStyle.Bold))

' Create the text symbol.
Dim textsymbol As ITextSymbol = New TextSymbolClass()
textsymbol.Font = font

' Create an FE graphic style.
Dim style As IFEGraphicStyle = New FEGraphicStyleClass()
style.Name = "My New Style"
style.UseFonts = True
style.TextSymbol = textsymbol
style.FriendlyPresentFrameFill = TryCast(sfs, IFillSymbol)

// Create a color.
IRgbColor rgb = new RgbColorClass();
rgb.Blue = 200;

// Create a fill symbol.
ISimpleFillSymbol sfs = new SimpleFillSymbolClass();
sfs.Color = rgb;

// Create a font.
IFontDisp font = new StdFontClass()as IFontDisp;
font.Name = "Courier New";
font.Bold = true;

// Create the text symbol.
ITextSymbol textsymbol = new TextSymbolClass();
textsymbol.Font = font;

// Create an FE graphic style.
IFEGraphicStyle style = new FEGraphicStyleClass();
style.Name = "My New Style";
style.UseFonts = true;
style.TextSymbol = textsymbol;
style.FriendlyPresentFrameFill = sfs as IFillSymbol;

' Get the first renderer.
Dim renderer As ICacheRenderer = TryCast(m_TGRenderers.Element(0), ICacheRenderer)

' Create a point.
Dim pint As IPoint = New PointClass()
pint.PutCoords( -97.83, 31.12)

' Get the TG renderer's graphic definition.
Dim graphdefs As IGraphicDefSet = TryCast(renderer, IGraphicDefSet)
Dim defset As ISet = graphdefs.GraphicDefSet
defset.Reset()
Dim def As IGraphicDef = TryCast(defset.Next(), IGraphicDef)

' Construct a tactical element.
Dim constructor As IConstructTacticalElement = TryCast(renderer, IConstructTacticalElement)
Dim tacelement As ITacticalElement = constructor.ReturnSampleElement(mole2525BAffiliationsEnum.moleAffiliationFriend, mole2525BEchelonsEnum.moleEchelonDivision, def, m_ActiveView.Extent, pint, False)

' Determine if the returned element can be rendered.
Dim tgr As ITacticalGraphicRenderer = TryCast(renderer, ITacticalGraphicRenderer)
If tgr.CanRenderTacticalElement(tacelement) Then
    
    ' Set the renderer's size and text size based on the map extent.
    Dim Size As Double = m_ActiveView.Extent.Height * 0.01
    Dim tacticalGraphicsRenderer As ITacticalGraphicRenderer2 = TryCast(tgr, ITacticalGraphicRenderer2)
    tacticalGraphicsRenderer.Size = Size
    Dim textsize As Double = m_ActiveView.Extent.Height * 0.01
    tgr.TextSize = textsize
    
    ' Create the graphic.
    Dim cached As ICachedGraphic = tgr.GraphicByTacticalElement(m_ActiveView.ScreenDisplay, tacelement)
    
    ' Add the graphic to the map.
    AddToMap(cached)
End If

// Get the first renderer.
ICacheRenderer renderer = m_TGRenderers.get_Element(0)as ICacheRenderer;

// Create a point.
IPoint pint = new PointClass();
pint.PutCoords( - 97.83, 31.12);

// Get the TG renderer's graphic definition.
IGraphicDefSet graphdefs = renderer as IGraphicDefSet;
ISet defset = graphdefs.GraphicDefSet;
defset.Reset();
IGraphicDef def = defset.Next()as IGraphicDef;

// Construct a tactical element.
IConstructTacticalElement constructor = renderer as IConstructTacticalElement;
ITacticalElement tacelement = constructor.ReturnSampleElement
    (mole2525BAffiliationsEnum.moleAffiliationFriend,
    mole2525BEchelonsEnum.moleEchelonDivision, def, m_Extent, pint, false);

// Determine if the returned element can be rendered.
ITacticalGraphicRenderer tgr = renderer as ITacticalGraphicRenderer;
if (tgr.CanRenderTacticalElement(tacelement))
{
    // Set the renderer's size and text size based on the map extent.
    double size = m_ActiveView.Extent.Height * 0.01;
    (tgr as ITacticalGraphicRenderer2).Size = size;
    double textsize = m_ActiveView.Extent.Height * 0.01;
    tgr.TextSize = textsize;

    // Create the graphic.
    ICachedGraphic cached = tgr.GraphicByTacticalElement(m_ActiveView.ScreenDisplay,
        tacelement);

    // Add the graphic to the map.   
    AddToMap(cached);
}

// Illustrates using a TacticalElement to retrieve a representative graphic, and then drawing it
// NOTE: m_ipTGRenderer is an ICacheRenderer member variable
LRESULT TestAppDlg::OnGenerateTGClicked(WORD wNotifyCode, WORD wID, HWND
  hWndCtl, BOOL &bHandled)
{
  // m_ipActiveView set prior to here
  if (m_ipActiveView == NULL)
    return 0;

  IScreenDisplayPtr ipScreenDisplay;
  m_ipActiveView->get_ScreenDisplay(&ipScreenDisplay);
  IEnvelopePtr ipExtent;
  m_ipActiveView->get_Extent(&ipExtent);
  double height;
  ipExtent->get_Height(&height);

  // get the graphic definition
  IGraphicDefSetPtr ipGraphicDefinitions(m_ipTGRenderer);
  ISetPtr ipDefinitionSet;
  ipGraphicDefinitions->get_GraphicDefSet(&ipDefinitionSet);
  ipDefinitionSet->Reset();
  IUnknownPtr ipUnk;
  ipDefinitionSet->Next(&ipUnk);
  IGraphicDefPtr ipGraphicDef(ipUnk);

  // create a point
  IPointPtr ipPoint(CLSID_Point);
  ipPoint->PutCoords(0, 0);

  // contruct a sample tactical element
  IConstructTacticalElementPtr ipConstructElement(m_ipTGRenderer);
  ITacticalElementPtr ipTacticalElement;
  ipConstructElement->ReturnSampleElement(moleAffiliationFriend,
    moleEchelonDivision, ipGraphicDef, ipPoint, VARIANT_FALSE,
    &ipTacticalElement);

  // if possible, build a tactical graphic
  ITacticalGraphicRendererPtr ipTGR(m_ipTGRenderer);
  VARIANT_BOOL candoit;
  ipTGR->CanRenderTacticalElement(ipTacticalElement, &candoit);
  if (candoit == VARIANT_TRUE)
  {

    // set the text size
    ipTGR->put_TextSize(0.05 *height);

    // generate the graphic
    ICachedGraphicPtr ipGraphic;
    ipTGR->GraphicByTacticalElement(ipScreenDisplay, ipTacticalElement,
      &ipGraphic);

    // draw the graphic
    long hDC;
    ipScreenDisplay->get_hDC(&hDC);
    ipScreenDisplay->StartDrawing(hDC, 0);
    ipGraphic->Draw(ipScreenDisplay, NULL);
    ipScreenDisplay->FinishDrawing();
  }
  return 0;
}

' Create the exportable sample graphic.
Dim exporter As IExportGraphic = TryCast(BuildFEG(Nothing, 1, 1, DEFAULT_SIC, DEFAULT_NAME, DEFAULT_PARENT), IExportGraphic)

' Refresh the graphic (to set its correct bounds).
Dim cachedGraphic As ICachedGraphic = TryCast(exporter, ICachedGraphic)
cachedGraphic.Refresh(m_ActiveView.ScreenDisplay)

' Get the graphic's extent.
Dim ext As IEnvelope = New EnvelopeClass()
Dim cachedGraphics As ICachedGraphic = TryCast(exporter, ICachedGraphic)
cachedGraphics.QueryBounds(m_ActiveView.ScreenDisplay, ext)

' Export the image.
Exporter.ExportToFile(m_ActiveView.ScreenDisplay, filepath, ext, 128, 128, 128, 1.0, 128, False)
End If

// Create the exportable sample graphic.
IExportGraphic exporter = BuildFEG(null, 1, 1, DEFAULT_SIC, DEFAULT_NAME,
    DEFAULT_PARENT)as IExportGraphic;

// Refresh the graphic (to set its correct bounds).
(exporter as ICachedGraphic).Refresh(m_ActiveView.ScreenDisplay);

// Get the graphic's extent.
IEnvelope ext = new EnvelopeClass();
(exporter as ICachedGraphic).QueryBounds(m_ActiveView.ScreenDisplay, ref ext);

// Export the image.
Exporter.ExportToFile(m_ActiveView.ScreenDisplay, filepath, ext, 128, 128, 128, 1.0,
    128, false);

// Exporting a MOLE graphic to a file
LRESULT TestApplication::OnBitmapClicked(WORD wNotifyCode, WORD wID, HWND
  hWndCtl, BOOL &bHandled)
{
  // create a background color (white)
  IRgbColorPtr ipColor(CLSID_RgbColor);
  ipColor->put_Red(255);
  ipColor->put_Green(255);
  ipColor->put_Blue(255);

  // create a sample force element graphic
  ICachedGraphicPtr ipGraphic = BuildFE(NULL);

  // get the map’s screen display
  // IActiveViewPtr m_ipActiveView set prior to here
  IScreenDisplayPtr ipScreenDisplay;
  m_ipActiveView->get_ScreenDisplay(&ipScreenDisplay);

  // export the bitmap
  ICreateBitmapPtr ipBitmapper(ipGraphic);
  IPictureDispPtr ipPicture;
  ipBitmapper->DrawToPicture(ipScreenDisplay, 64, 64, 1.5, ipColor, &ipPicture);

  // get the image handle
  IPicturePtr ipPict(ipPicture);
  OLE_HANDLE handle;
  ipPict->get_Handle(&handle);

  // NOTE: IDC_BITMAP_BUTTON is the resource ID for the button
  // put the image on the button
  HBITMAP hBMP = (HBITMAP)CopyImage((HBITMAP)handle, IMAGE_BITMAP, 0, 0,
    LR_COPYRETURNORG);
  CButton *pButton = (CButton*)GetDlgItem(IDC_BITMAP_BUTTON);
  pButton->SetBitmap((HBITMAP)hBMP);
  return 0;
}

' Create a sample graphic.
Dim createbmp As ICreateBitmap = TryCast(BuildFEG(Nothing, 1, 1, DEFAULT_SIC, DEFAULT_NAME, DEFAULT_PARENT), ICreateBitmap)

' Create a background color.
Dim RGB As IRgbColor = New RgbColorClass()
RGB.Red = 254
RGB.Green = 254
RGB.Blue = 254

' Export the bitmap.
Dim bmpHandle As Integer = createbmp.DrawToDIB(Nothing, 128, 128, 2.0, RGB)

' Create the bitmap from the handle.
Dim bmp As Bitmap = Bitmap.FromHbitmap(New IntPtr(bmpHandle))

' Stamp it on the picture box.
picBitmap.Image = bmp
picBitmap.SizeMode = PictureBoxSizeMode.StretchImage

' Create a sample graphic.ICreateBitmap createbmp = BuildFEG(null, 1, 1, DEFAULT_SIC,
    DEFAULT_NAME, DEFAULT_PARENT)as ICreateBitmap;

// Create a background color.
IRgbColor rgb = new RgbColorClass();
rgb.Red = 254;
rgb.Green = 254;
rgb.Blue = 254;

// Export the bitmap.
int bmpHandle = createbmp.DrawToDIB(null, 128, 128, 2.0, rgb);

// Create the bitmap from the handle.
Bitmap bmp = Bitmap.FromHbitmap(new IntPtr(bmpHandle));

// Stamp it on the picture box.
picBitmap.Image = bmp;
picBitmap.SizeMode = PictureBoxSizeMode.StretchImage;

// Exporting a MOLE graphic to memory
LRESULT TestApplication::OnExportClicked(WORD wNotifyCode, WORD wID, HWND
  hWndCtl, BOOL &bHandled)
{
  // get the visible bounds of the map’s display transformation
  // IActiveViewPtr m_ipActiveView set prior to here
  IScreenDisplayPtr ipScreenDisplay;
  m_ipActiveView->get_ScreenDisplay(&ipScreenDisplay);
  IDisplayTransformationPtr ipDT;
  ipScreenDisplay->get_DisplayTransformation(&ipDT);

  IEnvelopePtr ipVisibleBounds;
  ipDT->get_VisibleBounds(&ipVisibleBounds);

  // build a sample force element graphic
  ICachedGraphicPtr ipGrahic = BuildFE(NULL);

  // QI for export interface & export the graphic
  IExportGraphicPtr ipExport(ipGraphic);
  if (ipExport != NULL)
  {
    VARIANT_BOOL success;
    ipExport->ExportToFile(ipScreenDisplay, CComBSTR(� � �c:  / temp /
      graphic.gif � � �), ipVisibleBounds, 100, 150, 200, 1.2, VARIANT_FALSE,
      &success);
  }

  return 0;
}

' Set the angle.
cached.Angle = 45

// Set the angle.
cached.Angle = 45;

' Set the size based on the active view extent
Dim Size As Double = m_ActiveView.Extent.Height * 0.075
cached.Size = Size

// Set the size based on the active view extent
double size = m_ActiveView.Extent.Height * 0.075;
cached.Size = size;

' Modifying a graphic's attribute text after the graphic has been built and refreshed.
' Create a font.
Dim font As IFontDisp = ESRI.ArcGIS.ADF.Converter.ToStdFont(New System.Drawing.Font("Courier New", 20, System.Drawing.FontStyle.Bold))

' Create the text symbol.
Dim textsymbol As ITextSymbol = New TextSymbolClass()
textsymbol.Font = font

' Create an FE graphic style.
Dim style As IFEGraphicStyle = New FEGraphicStyleClass()
style.Name = "My New Style"
style.UseFonts = True
style.TextSymbol = textsymbol

' Create a new graphic.
Dim cached As ICachedGraphic = BuildFEG(style, -97.75, 30.85, DEFAULT_SIC, DEFAULT_NAME, DEFAULT_PARENT)

' Set the size based on the map extent.
Dim Size As Double = m_ActiveView.Extent.Height * 0.075
cached.Size = Size

' Get the display.
Dim screendis As IDisplay = m_ActiveView.ScreenDisplay

' Refresh the graphic.
cached.Refresh(screendis)

' Tweak the labels.
Dim labeled As ILabeledGraphic = TryCast(cached, ILabeledGraphic)
Dim [Set] As ISet = labeled.AttributeText

' Cycle through the set.
[Set].Reset()
Dim text As IAttributeText = TryCast([Set].Next(), IAttributeText)
Do While Not text Is Nothing
    If text.Name = "Name" Then
        ' Increase the size of just one label.
        text.Height = text.Height * 2
        Exit Do
    End If
    
    ' Go on to the next one.
    text = TryCast([Set].Next(), IAttributeText)
Loop

' Add it to the map.
Sizify(cached)
AddToMap(cached)

//Modifying a graphic's attribute text after the graphic has been built and refreshed.
private void btnModifyGraphicLabels_Click(object sender, EventArgs e)
{
    // Create a font.
    IFontDisp font = new StdFontClass()as IFontDisp;
    font.Name = "Courier New";
    font.Bold = true;

    // Create the text symbol.
    ITextSymbol textsymbol = new TextSymbolClass();
    textsymbol.Font = font;

    // Create an FE graphic style.
    IFEGraphicStyle style = new FEGraphicStyleClass();
    style.Name = "My New Style";
    style.UseFonts = true;
    style.TextSymbol = textsymbol;

    // Create a new graphic.
    ICachedGraphic cached = BuildFEG(style,  - 97.75, 30.85, DEFAULT_SIC,
        DEFAULT_NAME, DEFAULT_PARENT);

    // Set the size based on the map extent.
    double size = m_ActiveView.Extent.Height * 0.075;
    cached.Size = size;

    // Get the display.
    IDisplay screendis = m_ActiveView.ScreenDisplay;

    // Refresh the graphic.
    cached.Refresh(screendis);

    // Tweak the labels.
    ILabeledGraphic labeled = cached as ILabeledGraphic;
    ISet set = labeled.AttributeText;

    // Cycle through the set.
    set.Reset();
    IAttributeText text = set.Next()as IAttributeText;
    while (text != null)
    {
        if (text.Name == "Name")
        {
            // Increase the size of just one label.
            text.Height = text.Height * 2;
            break;
        }

        // Go on to the next one.
        text = set.Next()as IAttributeText;
    }
    // Add it to the map.
    Sizify(cached);
    AddToMap(cached);
}

// Modifying a graphics attribute text after the graphic has been built and refreshed
LRESULT TestApplication::OnLabelsClicked(WORD wNotifyCode, WORD wID, HWND
  hWndCtl, BOOL &bHandled)
{
  // create the font
  IFontPtr ipStdFont(CLSID_StdFont);
  ipStdFont->put_Name(CComBSTR("Courier New"));
  ipStdFont->put_Bold(TRUE);
  IFontDispPtr ipFont(ipStdFont);

  // create the text symbol
  ITextSymbolPtr ipTextSymbol(CLSID_TextSymbol);
  ipTextSymbol->put_Font(ipFont);

  // create the graphic style
  IFEGraphicStylePtr ipNewStyle(CLSID_FEGraphicStyle);
  ipNewStyle->put_Name(CComBSTR(� � �My New Style � � �));
  ipNewStyle->put_UseFonts(VARIANT_TRUE);
  ipNewStyle->putref_TextSymbol(ipTextSymbol);

  // use a helper function to create the force element graphic
  ICachedGraphicPtr ipGraphic = BuildFE(ipNewStyle);

  // get the map’s active view & display
  // IActiveViewPtr m_ipActiveView set prior to here
  IScreenDisplayPtr ipScreenDisplay;
  m_ipActiveView->get_ScreenDisplay(&ipScreenDisplay);

  // get the active view’s extent height
  IEnvelopePtr ipExtent;
  ipAV->get_Extent(&ipExtent);
  double height;
  ipExtent->get_Height(&height);

  // set the graphic size
  ipGraphic->put_Size(0.075 *height);
  ipGraphic->Refresh(ipScreenDisplay);

  // get the graphic’s set of text attributes
  ILabeledGraphicPtr ipLabeledGraphic(ipGraphic);
  ISetPtr ipTextSet;
  ipLabeledGraphic->get_AttributeText(&ipTextSet);

  // set the text attributes’ sizes
  ipTextSet->Reset();
  IUnknownPtr ipUnk;
  ipTextSet->Next(&ipUnk);
  while (ipUnk != NULL)
  {
    IAttributeTextPtr ipAttributeText(ipUnk);

    CComBSTR name;
    ipAttributeText->get_Name(&name);
    if (name == CComBSTR(� � �Name � � �))
    {
      double attHeight;
      ipAttributeText->get_Height(&attHeight);
      ipAttributeText->put_Height(2 *attHeight);
    }
    ipTextSet->Next(&ipUnk);
  }

  // draw the graphic
  long hDC;
  ipScreenDisplay->get_hDC(&hDC);
  ipScreenDisplay->StartDrawing(hDC, 0);
  ipGraphic->Draw(ipScreenDisplay, NULL);
  ipScreenDisplay->FinishDrawing();

  return 0;
}

' Load shapefile points into array.
Dim workspaceFactory As IWorkspaceFactory
workspaceFactory = New ShapefileWorkspaceFactory
Dim workspace As IWorkspace
workspace = workspaceFactory.OpenFromFile("path to shapefile directory", 0)

'Cast to IFeatureWorkspace.
Dim featureWorkspace As IFeatureWorkspace
featureWorkspace = workspace
Dim featureClass As IFeatureClass
featureClass = featureWorkspace.OpenFeatureClass("name of shape file")

Dim Count As Integer
Count = featureClass.FeatureCount(Nothing)
Dim pointArray As IArray
pointArray = New Array

If (Count > 20) Then
    Count = 20
End If

Dim f As IFeature
Dim g As IGeometry
Dim p As IPoint
Dim x As Double
Dim y As Double

For i As Integer = 0 To Count
    f = featureClass.GetFeature(i)
    g = f.Shape
    p = g
    p.QueryCoords(x, y)
    pointArray.Add(p)
Next i

' Set up the SRs.
Dim SREnv As SpatialReferenceEnvironment
SREnv = New SpatialReferenceEnvironment
Dim WGS1972_SR As ISpatialReference
WGS1972_SR = SREnv.CreateGeographicCoordinateSystem(esriSRGeoCSType.esriSRGeoCS_WGS1972)
Dim mgrsCoord As MGRSCoordinate
mgrsCoord = New MGRSCoordinate
mgrsCoord.Precision = esriCoordinatePrecision.esriCPOneCentimeter
' Seven coordinate digits per axis.
Dim dmsCoord As DMSCoordinate
dmsCoord = New DMSCoordinate
dmsCoord.Precision = esriCoordinatePrecision.esriCPOneTenThousandthSecond
dmsCoord.OutputSpatialReference = WGS1972_SR
Dim ddCoord As DDCoordinate
ddCoord = New DDCoordinate
ddCoord.Precision = esriCoordinatePrecision.esriCPOneTenthThousandthDegree
ddCoord.OutputSpatialReference = WGS1972_SR
' Forwarded coordinates get their InputSR from the calling coordinate.

' Forward the output.
mgrsCoord.AddOutputCoordinate(dmsCoord)
mgrsCoord.AddOutputCoordinate(ddCoord)

' Perform the input.
mgrsCoord.PointArray = pointArray

' Get the output.
Dim mgrsStringArray As IStringArray
Dim dmsStringArray As IStringArray
Dim ddStringArray As IStringArray
mgrsStringArray = New StrArray
dmsStringArray = New StrArray
ddStringArray = New StrArray
mgrsStringArray = mgrsCoord.StringArray
dmsStringArray = dmsCoord.StringArray
ddStringArray = ddCoord.StringArray

For i As Integer = 0 To Count
    p = pointArray.Element(i)
    p.QueryCoords(x, y)
    Console.WriteLine("Point[x, y] = " & x & " " & y)
    Console.WriteLine("dd = " & ddStringArray.Element(i))
    Console.WriteLine("mgrs =" & mgrsStringArray.Element(i))
    Console.WriteLine("dms = " & dmsStringArray.Element(i))
    Console.WriteLine()
Next

// Load shapefile points into array.
IWorkspaceFactory workspaceFactory = new
    ESRI.ArcGIS.DataSourcesFile.ShapefileWorkspaceFactoryClass();
IWorkspace workspace = workspaceFactory.OpenFromFile(@"path_of_shapefile", 0);

//Cast to IFeatureWorkspace.
IFeatureWorkspace featureWorkspace = (IFeatureWorkspace)workspace;
IFeatureClass featureClass = featureWorkspace.OpenFeatureClass("name_of_shapfile");
int count = featureClass.FeatureCount(null);
IArray pointArray = new ArrayClass();
if (count > 20)
    count = 20;

for (int i = 0; i < count; i++)
{
    IFeature f = featureClass.GetFeature(i);
    IGeometry g = f.Shape as IGeometry;
    IPoint p = g as IPoint;
    double x, y;
    p.QueryCoords(out x, out y);
    pointArray.Add(p);
}

// Set up the SRs.
SpatialReferenceEnvironment SREnv = new SpatialReferenceEnvironment();
ISpatialReference WGS1972_SR = SREnv.CreateGeographicCoordinateSystem((int)
    esriSRGeoCSType.esriSRGeoCS_WGS1972);
dmsCoord.OutputSpatialReference = WGS1972_SR;
// Forwarded coordinates get their InputSR from the calling coordinate
ddCoord.OutputSpatialReference = WGS1972_SR;
// but need to have their OutputSR specified (it would be WGS84 otherwise).

MGRSCoordinate mgrsCoord = new MGRSCoordinate();
mgrsCoord.Precision = esriCoordinatePrecision.esriCPOneCentimeter;
// Seven coordinate digits per axis.
DMSCoordinate dmsCoord = new DMSCoordinate();
dmsCoord.Precision = esriCoordinatePrecision.esriCPOneTenThousandthSecond;
DDCoordinate ddCoord = new DDCoordinate();
ddCoord.Precision = esriCoordinatePrecision.esriCPOneTenthThousandthDegree;

// Forward the output.
mgrsCoord.AddOutputCoordinate(dmsCoord);
mgrsCoord.AddOutputCoordinate(ddCoord);

// Perform the input.
mgrsCoord.PointArray = pointArray;

// Get the output.
IStringArray mgrsStringArray = new StrArrayClass();
IStringArray dmsStringArray = new StrArrayClass();
IStringArray ddStringArray = new StrArrayClass();
mgrsStringArray = mgrsCoord.StringArray;
dmsStringArray = dmsCoord.StringArray;
ddStringArray = ddCoord.StringArray;

Console.WriteLine("Input (point DD x, y WGS84) = dd(WGS1972), mgrs, dms(WGS1972)");

for (int i = 0; i < count; i++)
{
    double x, y;
    IPoint p = pointArray.get_Element(i);
    p.QueryCoords(out x, out y);
    Console.WriteLine("Point[x, y] = " + x + " " + y);
    Console.WriteLine("dd = " + ddStringArray.Element(i));
    Console.WriteLine("mgrs =" + mgrsStringArray.Element(i));
    Console.WriteLine("dms = " + dmsStringArray.Element(i));
    Console.WriteLine();
}

' Get a raster workspace.
Dim rasterWorkspace As IRasterWorkspaceEx = TryCast(m_workSpace, IRasterWorkspaceEx)
Dim catalogName As String = "HawaiiDted"

' Open the raster catalog.
Dim rasterCatalog As IRasterCatalog = rasterWorkspaceEx.OpenRasterCatalog(catalogName)

' Create the MADtedLayer.
Dim dtedLayer As IMADtedLayer = New MADtedLayerClass()
If dtedLayer.Setup(TryCast(rasterCatalog, ITable)) <> True Then
    Return
End If

' Set the layer properties.
dtedLayer.DisplayElevation = True
dtedLayer.UseUniformRenderer = True

' Load the DTED layer onto the map.
Dim layer As ILayer = TryCast(dtedLayer, ILayer)
m_map.AddLayer(layer)

// Get a raster workspace.
IRasterWorkspaceEx rasterWorkspace = m_workSpace as IRasterWorkspaceEx;
string catalogName = "HawaiiDted";

// Open the raster catalog.
IRasterCatalog rasterCatalog = rasterWorkspaceEx.OpenRasterCatalog(catalogName);

// Create the MADtedLayer.
IMADtedLayer dtedLayer = new MADtedLayerClass();
if (dtedLayer.Setup(rasterCatalog as ITable) != true)
    return ;

// Set the layer properties.
dtedLayer.DisplayElevation = true;
dtedLayer.UseUniformRenderer = true;

// Load the DTED layer onto the map.
ILayer layer = dtedLayer as ILayer;
m_map.AddLayer(layer);

' Get a raster workspace.
Dim rasterWorkspace As IRasterWorkspaceEx
rasterWorkspace = TryCast(m_workSpace, IRasterWorkspaceEx)
Dim catalogName As String = "HawaiiRaster"

' Open the raster catalog.
Dim rasterCatalog As IRasterCatalog = rasterWorkspaceEx.OpenRasterCatalog(catalogName)

' Create the raster layer.
Dim rasterLayer As IMARasterLayer = New MARasterLayerClass()
If maRasterLayer.Setup(TryCast(rasterCatalog, ITable)) <> True Then
    Return
End If

' Set the layer properties.
rasterLayer.DisplayRasters = True
rasterLayer.UseBestMap = True

' Load the raster layer onto the map.
Dim layer As ILayer = TryCast(rasterLayer, ILayer)
m_map.AddLayer(layer)

// Get a raster workspace.
IRasterWorkspaceEx rasterWorkspace;
rasterWorkspace = m_workSpace as IRasterWorkspaceEx;
string catalogName = "HawaiiRaster";

// Open the raster catalog.
IRasterCatalog rasterCatalog = rasterWorkspaceEx.OpenRasterCatalog(catalogName);

// Create the raster layer.
IMARasterLayer rasterLayer = new MARasterLayerClass();
if (maRasterLayer.Setup(rasterCatalog as ITable) != true)
    return ;

// Set the layer properties.
rasterLayer.DisplayRasters = true;
rasterLayer.UseBestMap = true;

// Load the raster layer onto the map.
ILayer layer = rasterLayer as ILayer;
m_map.AddLayer(layer);