MapWinGIS:SampleCode-C Sharp Net:Selection

This is a back-up of the WIKI.
Not all links might work
We're working on a new wiki.

Main Page | Recent changes | View source | Page history | Log in / create account |

Printable version | Disclaimers | Privacy policy

Selection

The purpose of this code is to give some ideas about how to handle selections via the ocx.

 using System;
 using System.Collections.Generic;
 using System.Text;
 using System.Collections;
 
 namespace ToolboxTester
 {
     /// <summary>
     /// This is a useful object that keeps track of the current selection
     /// and allows shapes and layers to be "highlighted" and then reverted
     /// to their original colors.
     /// </summary>
     public class Selection
     {
         #region Variables
         AxMapWinGIS.AxMap m_Map;
         bool m_IsSelecting;
         // Appearance
         System.Drawing.Color m_SelectionColor; // Default Cyan
         int m_SelectionLineThickness; // Default = 3
         bool m_ShowSelection; // Defualt = true
         // Layer information
         int m_CurrentLayer;
         Hashtable m_SelectedShapes; // One list for each layer;
         Hashtable m_OriginalThickness; // Stores the original line thicknesses
         Hashtable m_OriginalLineColor; // Stores the original line color
         Hashtable m_OriginalFillColor; // Stores the original color
         Hashtable m_OriginalPointColor; // Stores the original point color
        
         // Mouse Handling 
         System.Drawing.Point m_MouseDownLoc;
         bool m_ShiftPressed;
         MapWinGIS.SelectMode m_SelectionMode;
 
 
         #endregion
         
         #region Constructor
 
         /// <summary>
         /// Creates a new instance of the selection object tuned to a specific map
         /// </summary>
         /// <param name="Map"></param>
         public Selection(AxMapWinGIS.AxMap Map)
         {
             m_Map = Map;
 
             // Appearance
             m_SelectionColor = System.Drawing.Color.Cyan;
             m_SelectionLineThickness = 3;
             m_ShowSelection = true;
             m_SelectionMode = MapWinGIS.SelectMode.INTERSECTION;
             // No current layer assumes that we should select shapes from all layers
             m_CurrentLayer = -1;
             m_Map.MouseDownEvent += new AxMapWinGIS._DMapEvents_MouseDownEventHandler(m_Map_MouseDownEvent);
             m_Map.MouseUpEvent += new AxMapWinGIS._DMapEvents_MouseUpEventHandler(m_Map_MouseUpEvent);
             m_Map.SelectBoxFinal += new AxMapWinGIS._DMapEvents_SelectBoxFinalEventHandler(m_Map_SelectBoxFinal);
             m_SelectedShapes = new Hashtable();
             m_OriginalThickness = new Hashtable(); // Stores the original line thicknesses
             m_OriginalLineColor = new Hashtable(); // Stores the original line color
             m_OriginalFillColor = new Hashtable(); // Stores the original color
             m_OriginalPointColor = new Hashtable(); // Stores the original point color
         }
         #endregion
 
         #region Properties
 
         /// <summary>
         /// Gets or sets whether this object is activly tracking mouse activities on the map
         /// in order to obtain a selection
         /// </summary>
         public bool IsSelecting
         {
             get
             {
                 return m_IsSelecting;
             }
             set
             {
                 if(m_IsSelecting == value)return;
                 if (value == true)
                 {
                     StartSelectingShapes();
                 }
                 else
                 {
                     StopSelectingShapes();
                 }
                 m_IsSelecting = value;
             }
         }
 
 
         /// <summary>
         /// Gets or sets the color to draw the selection with.  The default is cyan.
         /// </summary>
         public System.Drawing.Color SelectionColor
         {
             get
             {
                 return m_SelectionColor;
             }
             set
             {
                 m_SelectionColor = value;
             }
         }
         /// <summary>
         /// Gets or sets the thickness of selected lines
         /// </summary>
         public int SelectionLineThickness
         {
             get
             {
                 return m_SelectionLineThickness;
             }
             set
             {
                 m_SelectionLineThickness = value;
             }
         }
         /// <summary>
         /// Gets or Sets whether the selection should be indicated by changes in color or line thickness.
         /// </summary>
         public bool ShowSelection
         {
             get
             {
                 return m_ShowSelection;
             }
             set
             {
                 m_ShowSelection = value;
             }
         }
         /// <summary>
         /// Gets or sets the selection mode.  Options are Intersection and Inclusion
         /// </summary>
         public MapWinGIS.SelectMode SelectionMode
         {
             get
             {
                 return m_SelectionMode;
             }
             set
             {
                 m_SelectionMode = value;
             }
         }
 
         /// <summary>
         /// Gets or Sets a separate list of selected shape indecies for each layer in the map.
         /// </summary>
         public Hashtable SelectedShapes
         {
             get
             {
                 return m_SelectedShapes;
             }
             set
             {
                 if (value.Count >= m_Map.NumLayers)
                 {
                     throw new ArgumentException("There were more layers specified in the selection than exist in the map.");
                 }
                 m_SelectedShapes = value;
                 IDictionaryEnumerator Layer = m_SelectedShapes.GetEnumerator();
                 while (Layer.MoveNext())
                 {
                     List<int> Shapes = Layer.Value as List<int>;
                     MapWinGIS.Shapefile sf;
                     if (Shapes == null)
                     {
                         // the cast was probably invalid.  Prevent future problems by simply removing it.
                         value.Remove(Layer.Key);
                         continue;
                     }
                     try
                     {
                         int lyr = (int)Layer.Key;
                         sf = m_Map.get_GetObject(lyr) as MapWinGIS.Shapefile;
                     }
                     catch
                     {
                         // The layer doesn't exist
                         m_SelectedShapes.Remove(Layer.Key);
                         continue;
                     }
                     if (sf == null)
                     {
                         // the layer was probably a non-vector layer and so the cast failed
                         m_SelectedShapes.Remove(Layer.Key);
                         continue;
                     }
                     if (Shapes.Count > sf.NumShapes)
                     {
                         throw new ArgumentException("There were more selected shapes specified for layer " + Layer.Key + " than there are shapes in the layer.");
                     }
 
                 }
                 m_SelectedShapes = value;
                
             }
         }
 
         #endregion
 
         /// <summary>
         /// Restores all layers and removes them from the selection
         /// </summary>
         public void ClearSelectedShapes()
         {
             IDictionaryEnumerator Layer = m_SelectedShapes.GetEnumerator();
             while (Layer.MoveNext())
             {
                 Restore_Layer((int)Layer.Key);
             }
             m_SelectedShapes.Clear();
         }
 
         /// <summary>
         /// Restores the specified layer and removes it from the selection
         /// </summary>
         /// <param name="Layer"></param>
         public void ClearSelectedShapes(int Layer)
         {
             m_SelectedShapes.Remove(Layer);
         }
 
         /// <summary>
         /// Returns the selected shapes for a specific layer
         /// </summary>
         /// <param name="Layer"></param>
         /// <returns></returns>
         public List<int> GetSelectedShapes(int Layer)
         {
             return m_SelectedShapes[Layer] as List<int>;
         }
 
         /// <summary>
         /// Sets the selection for a specific layer.
         /// </summary>
         /// <param name="Layer">The Layer index to set the selection for</param>
         /// <param name="selShapes">An array of integer shape values</param>
         void SetSelectedShapes(int Layer, int[] selShapes)
         {
             // the reason for passing an integer is to match with the "SelectShapes" function on axMap
             List<int> Shapes = new List<int>();
             for (int i = 0; i <= selShapes.GetUpperBound(0); i++)
             {
                 Shapes.Add(selShapes[i]);
             }
             if (m_SelectedShapes.ContainsKey(Layer))
             {
                 m_SelectedShapes[Layer] = Shapes;
             }
             else
             {
                 m_SelectedShapes.Add(Layer, Shapes);
             }
         }
 
         /// <summary>
         /// Only starts selecting shapes for a single layer
         /// </summary>
         /// <param name="Layer">The layer index for the map</param>
         public void StartSelectingShapes(int Layer)
         {
             m_Map.CursorMode = MapWinGIS.tkCursorMode.cmSelection;
             m_Map.SendMouseDown = true;
             m_Map.SendMouseUp = true;
             m_Map.SendSelectBoxFinal = true;
             m_CurrentLayer = Layer;
         }
 
         /// <summary>
         /// Selects shapes for all layers
         /// </summary>
         public void StartSelectingShapes()
         {
             m_Map.CursorMode = MapWinGIS.tkCursorMode.cmSelection;
             m_Map.SendMouseDown = true;   
             m_Map.SendMouseUp = true;
             m_Map.SendSelectBoxFinal = true;
         }
 
         /// <summary>
         /// This does not restore anything, but simply deactivates the mouse responsiveness
         /// </summary>
         public void StopSelectingShapes()
         {
             m_Map.SendMouseDown = false;
             m_Map.SendMouseUp = false;
             m_Map.SendSelectBoxFinal = false;
         }
 
         #region Event handlers
         
         /// <summary>
         /// Designed to handle the mouse down event
         /// </summary>
         /// <param name="sender"></param>
         /// <param name="e"></param>
         public void m_Map_MouseDownEvent(object sender, AxMapWinGIS._DMapEvents_MouseDownEvent e)
         {
             m_MouseDownLoc = new System.Drawing.Point(e.x, e.y);
             if (e.shift == 1)
             {
                 m_ShiftPressed = true;
             }
             else
             {
                 m_ShiftPressed = false;
             }
         }
 
         /// <summary>
         /// This is the full blown select for a drag style extent
         /// </summary>
         /// <param name="sender"></param>
         /// <param name="e"></param>
         public void m_Map_SelectBoxFinal(object sender, AxMapWinGIS._DMapEvents_SelectBoxFinalEvent e)
         {
             // First get the projected coordinates
             double top = 0;
             double left = 0;
             double bottom = 0;
             double right = 0;
             m_Map.PixelToProj(e.left, e.top, ref left, ref top);
             m_Map.PixelToProj(e.right, e.bottom, ref right, ref bottom);
 
             MapWinGIS.Extents ext = new MapWinGIS.Extents();
             ext.SetBounds(left, bottom, 0, right, top, 0);
             SelectExtents(ext);
         }
         /// <summary>
         /// For regular click-style selections
         /// </summary>
         /// <param name="sender"></param>
         /// <param name="e"></param>
         public void m_Map_MouseUpEvent(object sender, AxMapWinGIS._DMapEvents_MouseUpEvent e)
         {
             // Select using an approximation of 5 pixels about e
             double top = 0;
             double left = 0;
             double bottom = 0;
             double right = 0;
             m_Map.PixelToProj(e.x - 5, e.y - 5, ref left, ref top);
             m_Map.PixelToProj(e.x + 5, e.y + 5, ref right, ref bottom);
 
             MapWinGIS.Extents ext = new MapWinGIS.Extents();
             ext.SetBounds(left, bottom, 0, right, top, 0);
             SelectExtents(ext);
         }
 
         private void SelectExtents(MapWinGIS.Extents ext)
         {
             object[] selShapes = new object[m_Map.NumLayers];
             if (m_CurrentLayer == -1 || m_CurrentLayer >= m_Map.NumLayers)
             {
                 for (int lyr = 0; lyr < m_Map.NumLayers; lyr++)
                 {
                     object ob = m_Map.get_GetObject(lyr);
                     if (ob.GetType() != typeof(MapWinGIS.ShapefileClass)) return;
                     MapWinGIS.Shapefile sf = ob as MapWinGIS.Shapefile;
                     sf.SelectShapes(ext, 0, MapWinGIS.SelectMode.INTERSECTION, ref selShapes[lyr]);
 
                 }
             }
             else
             {
                 object ob = m_Map.get_GetObject(m_CurrentLayer);
                 if (ob.GetType() != typeof(MapWinGIS.Shapefile)) return;
                 MapWinGIS.Shapefile sf = ob as MapWinGIS.Shapefile;
                 sf.SelectShapes(ext, 0, MapWinGIS.SelectMode.INTERSECTION, ref selShapes[m_CurrentLayer]);
             }
 
             m_Map.SuspendLayout();
             // If shift is down then we append to the selection
             if (m_ShiftPressed == false)
             {
                 // Clear the selection first
 
                 ClearSelectedShapes();
 
             }
 
             //Append selected shapes
             for (int lyr = 0; lyr < m_Map.NumLayers; lyr++)
             {
                 int[] myShapes = selShapes[lyr] as int[];
                 List<int> Shapes;
                 if (m_SelectedShapes.ContainsKey(lyr))
                 {
                     Shapes = (List<int>)m_SelectedShapes[lyr];
                 }
                 else
                 {
                     Shapes = new List<int>();
                 }
                 for (int shp = 0; shp <= myShapes.GetUpperBound(0); shp++)
                 {
                     if (Shapes.Contains(myShapes[shp])) continue;
                     Shapes.Add(myShapes[shp]);
                 }
                 if (m_SelectedShapes.ContainsKey(lyr))
                 {
                     m_SelectedShapes[lyr] = Shapes;
                 }
                 else
                 {
                     m_SelectedShapes.Add(lyr, Shapes);
                 }
             }
 
             for (int lyr = 0; lyr < m_SelectedShapes.Count; lyr++)
             {
                 Highlight_Layer(lyr);
             }
 
             m_Map.ResumeLayout();
         }
 
         
 
        
 
         #endregion
 
         #region Coloration
 
 
         /// <summary>
         /// Use this function to update the entire map to be consistent with the current selection.
         /// </summary>
         public void Highlight_Selection()
         {
             m_Map.SuspendLayout(); // Don't actually draw the changes until we are done
             // Revert everything back to the original color so that we can start over
             IDictionaryEnumerator eLayer = m_SelectedShapes.GetEnumerator();
             while (eLayer.MoveNext())
             {
                 Restore_Layer((int)eLayer.Key);
 
                 Highlight_Layer((int)eLayer.Key);
             }
           
             m_Map.ResumeLayout();
         }
 
         /// <summary>
         /// This handles the coloring aspects of un-selecting all the shapes in a layer
         /// </summary>
         public void Restore_Layer(int Layer)
         {
             IDictionaryEnumerator eShape;
             object ob = m_Map.get_GetObject(Layer);
             if (ob.GetType() != typeof(MapWinGIS.ShapefileClass))return;
             
             MapWinGIS.Shapefile sf = ob as MapWinGIS.Shapefile;
             if (sf.ShapefileType == MapWinGIS.ShpfileType.SHP_POLYGON ||
                 sf.ShapefileType == MapWinGIS.ShpfileType.SHP_POLYGONM ||
                 sf.ShapefileType == MapWinGIS.ShpfileType.SHP_POLYGONZ)
             {
 
                 Hashtable OriginalLineColor = (Hashtable)m_OriginalLineColor[Layer];
                 if (OriginalLineColor != null)
                 {
                     eShape = OriginalLineColor.GetEnumerator();
                     while (eShape.MoveNext())
                     {
                         m_Map.set_ShapeLineColor(Layer, (int)eShape.Key, (uint)eShape.Value);
                     }
                 }
 
                 Hashtable OriginalWidth = (Hashtable)m_OriginalThickness[Layer];
                 if (OriginalWidth != null)
                 {
                     eShape = OriginalWidth.GetEnumerator();
                     while (eShape.MoveNext())
                     {
                         m_Map.set_ShapeLineWidth(Layer, (int)eShape.Key, (float)eShape.Value);
                     }
                 }
             }
             else if (sf.ShapefileType == MapWinGIS.ShpfileType.SHP_POLYLINE ||
                      sf.ShapefileType == MapWinGIS.ShpfileType.SHP_POLYLINEM ||
                      sf.ShapefileType == MapWinGIS.ShpfileType.SHP_POLYLINEZ)
             {
                 Hashtable OriginalLineColor = (Hashtable)m_OriginalLineColor[Layer];
                 if (OriginalLineColor != null)
                 {
                     eShape = OriginalLineColor.GetEnumerator();
                     while (eShape.MoveNext())
                     {
                         m_Map.set_ShapeLineColor(Layer, (int)eShape.Key, (uint)eShape.Value);
                     }
                 }
 
                 Hashtable OriginalWidth = (Hashtable)m_OriginalThickness[Layer];
                 if (OriginalWidth != null)
                 {
                     eShape = OriginalWidth.GetEnumerator();
                     while (eShape.MoveNext())
                     {
                         m_Map.set_ShapeLineWidth(Layer, (int)eShape.Key, (float)eShape.Value);
                     }
                 }
                
             }
             else if (sf.ShapefileType == MapWinGIS.ShpfileType.SHP_POINT ||
                sf.ShapefileType == MapWinGIS.ShpfileType.SHP_POINTM ||
                sf.ShapefileType == MapWinGIS.ShpfileType.SHP_POINTZ ||
                sf.ShapefileType == MapWinGIS.ShpfileType.SHP_MULTIPOINT ||
                sf.ShapefileType == MapWinGIS.ShpfileType.SHP_MULTIPOINTM ||
                sf.ShapefileType == MapWinGIS.ShpfileType.SHP_MULTIPOINTZ)
             {
                 Hashtable OriginalPointColor = (Hashtable)m_OriginalPointColor[Layer];
                 if (OriginalPointColor != null)
                 {
                     eShape = OriginalPointColor.GetEnumerator();
                     while (eShape.MoveNext())
                     {
                         m_Map.set_ShapePointColor(Layer, (int)eShape.Key, (uint)eShape.Value);
                     }
                 }
 
                 Hashtable OriginalWidth = (Hashtable)m_OriginalThickness[Layer];
                 if (OriginalWidth != null)
                 {
                     eShape = OriginalWidth.GetEnumerator();
                     while (eShape.MoveNext())
                     {
                         m_Map.set_ShapePointSize(Layer, (int)eShape.Key, (float)eShape.Value);
                     }
                 }
             }
             
         }
 
         /// <summary>
         /// This handles the coloring aspects of selecting all the shapes in a shapefile layer
         /// </summary>
         public void Highlight_Layer(int Layer)
         {
             object ob = m_Map.get_GetObject(Layer);
             if (ob.GetType() != typeof(MapWinGIS.ShapefileClass)) return; // Don't bother selecting images
 
             int numLayers = m_Map.NumLayers;
             if(m_OriginalThickness == null)m_OriginalThickness = new Hashtable();
             if(m_OriginalLineColor == null)m_OriginalLineColor = new Hashtable();
             if(m_OriginalPointColor == null)m_OriginalPointColor = new Hashtable();
             if(m_OriginalFillColor == null)m_OriginalFillColor = new Hashtable();
             
             uint SelCol = Convert.ToUInt32(m_SelectionColor.B) * 256*256 + 
                             Convert.ToUInt32(m_SelectionColor.G) * 256 +
                             Convert.ToUInt32(m_SelectionColor.R);
 
             MapWinGIS.Shapefile sf = ob as MapWinGIS.Shapefile;
             List<int> SelectedShapes = (List<int>)m_SelectedShapes[Layer];
             if (sf.ShapefileType == MapWinGIS.ShpfileType.SHP_POLYGON ||
                 sf.ShapefileType == MapWinGIS.ShpfileType.SHP_POLYGONM ||
                 sf.ShapefileType == MapWinGIS.ShpfileType.SHP_POLYGONZ)
             {
                 for (int shp = 0; shp < SelectedShapes.Count; shp++)
                 {
                     int Shape = SelectedShapes[shp];
                     // Line Width
                     float Width = m_Map.get_ShapeLineWidth(Layer, Shape);
                     Hashtable OriginalWidth = new Hashtable();
                     if (m_OriginalThickness.ContainsKey(Layer))
                     {
                         OriginalWidth = (Hashtable)m_OriginalThickness[Layer];
                     }
                     if (!OriginalWidth.ContainsKey(Shape))
                     {
                         OriginalWidth.Add(Shape, Width);
                         m_OriginalThickness[Layer] = OriginalWidth;
 
                     }
                     m_Map.set_ShapeLineWidth(Layer, Shape, 3);
 
                     // Line Color
                     System.Drawing.Color OldCol = m_Map.get_ShapeLineColor(Layer, Shape);
                     uint Col = Convert.ToUInt32(OldCol.B) * 256 * 256 +
                            Convert.ToUInt32(OldCol.G) * 256 +
                            Convert.ToUInt32(OldCol.R);
 
                     Hashtable OriginalCol = new Hashtable();
                     if (m_OriginalLineColor.ContainsKey(Layer))
                     {
                         OriginalCol = (Hashtable)m_OriginalLineColor[Layer];
                     }
                     if (!OriginalCol.ContainsKey(Shape))
                     {
                         OriginalCol.Add(Shape, Col);
                         m_OriginalLineColor[Layer] = OriginalCol;
 
                     }
                     m_Map.set_ShapeLineColor(Layer, Shape, SelCol);
 
 
                 }
             }
 
 
             #region POLYLINES
 
 
             else if (sf.ShapefileType == MapWinGIS.ShpfileType.SHP_POLYLINE ||
                      sf.ShapefileType == MapWinGIS.ShpfileType.SHP_POLYLINEM ||
                      sf.ShapefileType == MapWinGIS.ShpfileType.SHP_POLYLINEZ)
             {
                 for (int shp = 0; shp < SelectedShapes.Count; shp++)
                 {
                     int Shape = SelectedShapes[shp];
 
                     // Line Width
                     float Width = m_Map.get_ShapeLineWidth(Layer, Shape);
                     Hashtable OriginalWidth = new Hashtable();
                     if (m_OriginalThickness.ContainsKey(Layer))
                     {
                         OriginalWidth = (Hashtable)m_OriginalThickness[Layer];
                     }
                     if (!OriginalWidth.ContainsKey(Shape))
                     {
                         OriginalWidth.Add(Shape, Width);
                         m_OriginalThickness[Layer] = OriginalWidth;
                        
                     }
                     m_Map.set_ShapeLineWidth(Layer, Shape, 3);
 
                     // Line Color
                     System.Drawing.Color OldCol = m_Map.get_ShapeLineColor(Layer, Shape);
                     uint Col = Convert.ToUInt32(OldCol.B) * 256 * 256 +
                            Convert.ToUInt32(OldCol.G) * 256 +
                            Convert.ToUInt32(OldCol.R);
 
                     Hashtable OriginalCol = new Hashtable();
                     if (m_OriginalLineColor.ContainsKey(Layer))
                     {
                         OriginalCol = (Hashtable)m_OriginalLineColor[Layer];
                     }
                     if(!OriginalCol.ContainsKey(Shape))
                     {
                         OriginalCol.Add(Shape, Col);
                         m_OriginalLineColor[Layer] = OriginalCol;
                         
                     }
                     m_Map.set_ShapeLineColor(Layer, Shape, SelCol);
                 }
             }
 
             #endregion
 
             #region POINTS
 
             else if (sf.ShapefileType == MapWinGIS.ShpfileType.SHP_POINT ||
                sf.ShapefileType == MapWinGIS.ShpfileType.SHP_POINTM ||
                sf.ShapefileType == MapWinGIS.ShpfileType.SHP_POINTZ ||
                sf.ShapefileType == MapWinGIS.ShpfileType.SHP_MULTIPOINT ||
                sf.ShapefileType == MapWinGIS.ShpfileType.SHP_MULTIPOINTM ||
                sf.ShapefileType == MapWinGIS.ShpfileType.SHP_MULTIPOINTZ)
             {
                 for (int shp = 0; shp < SelectedShapes.Count; shp++)
                 {
                     int Shape = SelectedShapes[shp];
                     // Point Size
                     float Size = m_Map.get_ShapePointSize(Layer, Shape);
                     Hashtable OriginalWidth = new Hashtable();
                     if (m_OriginalThickness.ContainsKey(Layer))
                     {
                         OriginalWidth = (Hashtable)m_OriginalThickness[Layer];
                     }
                     if (!OriginalWidth.ContainsKey(Shape))
                     {
                         OriginalWidth.Add(Shape, Size);
                         m_OriginalThickness[Layer] = OriginalWidth;
                         m_Map.set_ShapePointSize(Layer, Shape, Size + 3);
                     }
                    
 
                     // Point Color
                     System.Drawing.Color OldCol = m_Map.get_ShapePointColor(Layer, Shape);
                     uint Col = Convert.ToUInt32(OldCol.B) * 256 * 256 +
                            Convert.ToUInt32(OldCol.G) * 256 +
                            Convert.ToUInt32(OldCol.R);
 
                     Hashtable OriginalCol = new Hashtable();
                     if (m_OriginalPointColor.ContainsKey(Layer))
                     {
                         OriginalCol = (Hashtable)m_OriginalPointColor[Layer];
                     }
                     if (!OriginalCol.ContainsKey(Shape))
                     {
                         OriginalCol.Add(Shape, Col);
                         m_OriginalPointColor[Layer] = OriginalCol;
 
                     }
                     m_Map.set_ShapePointColor(Layer, Shape, SelCol);
                 }
             }
 
             #endregion
 
 
         }
 
         #endregion
     }
 }

Retrieved from "http://mapwindow.org/wiki/index.php/MapWinGIS:SampleCode-C_Sharp_Net:Selection"

This page has been accessed 5,260 times. This page was last modified on 26 February 2010, at 23:34.