public GMapMarkerCross(PointLatLng p)
     : base(p)
 {
     #if !PocketPC
      Pen = new Pen(Brushes.Red, 1);
     #else
      Pen = new Pen(Color.Red, 1);
     #endif
 }

        public GMapMarkerRect(PointLatLng p)
            : base(p)
        {
            Pen = new Pen(Brushes.Transparent, 5);

            // do not forget set Size of the marker
            // if so, you shall have no event on it ;}
            Size = new System.Drawing.Size(20, 20);
            Offset = new System.Drawing.Point(-Size.Width / 2, -Size.Height / 2);
        }

      public GMarkerCross(PointLatLng p)
         : base(p)
      {
#if !PocketPC
         Pen = new Pen(Brushes.Red, 1);
#else
         Pen = new Pen(Color.Red, 1);
#endif
         IsHitTestVisible = false;
      }

      public GMarkerGoogle(PointLatLng p, GMarkerGoogleType type)
         : base(p)
      {
         this.Type = type;

         if(type != GMarkerGoogleType.none)
         {
            LoadBitmap();
         }
      }

       public GMarkerGoogle(PointLatLng p, GMarkerGoogleType type, bool showShadow = true)
         : base(p)
      {
         this.Type = type;
         this.ShowShadow = showShadow;

         if(type != GMarkerGoogleType.none)
         {
            LoadBitmap();
         }
      }

      public GMapMarkerTransparentGoogleGreen(PointLatLng p)
         : base(p)
      {
         System.Reflection.Assembly ass = System.Reflection.Assembly.GetExecutingAssembly();

         String resShadow = "GMap.NET.WindowsMobile.Resources.shadow50.png";
         String resMarker = "GMap.NET.WindowsMobile.Resources.bigMarkerGreen.png";

         IGMapTransparentBitmap shadow = GMapMarkerTransparent.LoadTransparentBitmap(ass.GetManifestResourceStream(resShadow));
         IGMapTransparentBitmap marker = GMapMarkerTransparent.LoadTransparentBitmap(ass.GetManifestResourceStream(resMarker));

         bitmaps = new IGMapTransparentBitmap[] { shadow, marker };

         Size = new System.Drawing.Size(marker.Width, marker.Height);
         Offset = new System.Drawing.Point(-10, -34);
      }

 public DirectionsStatusCode GetDirections(out GDirections direction, PointLatLng start, IEnumerable<PointLatLng> wayPoints, bool avoidHighways, bool avoidTolls, bool walkingMode, bool sensor, bool metric)
 {
     return GetDirectionsUrl(MakeDirectionsUrl(start, wayPoints, LanguageStr, avoidHighways, avoidTolls, walkingMode, sensor, metric), out direction);
 }

 public GMapMarkerCondominioLarge(PointLatLng p) : base(p)
 {
     Size = new System.Drawing.Size(global::Gipasoft.Stabili.UI.GeoLocation.Properties.Resources.stabile_large.Width, global::Gipasoft.Stabili.UI.GeoLocation.Properties.Resources.stabile_large.Height);
     Offset = new System.Drawing.Point(-10, -34);
 }

 /// <summary>
 /// return local coordinates from lat/lng
 /// </summary>
 /// <param name="latlng"></param>
 /// <returns></returns>
 public GPoint FromLatLngToLocal(PointLatLng latlng)
 {
    GPoint pLocal = Provider.Projection.FromLatLngToPixel(latlng, Zoom);
    pLocal.Offset(renderOffset);
    pLocal.OffsetNegative(compensationOffset);
    return pLocal;
 }

 string MakeRoutingUrl(PointLatLng start, PointLatLng end, string travelType, string language, string units)
 {
    // http://developers.cloudmade.com/projects/routing-http-api/examples/
    // http://routes.cloudmade.com/YOUR-API-KEY-GOES-HERE/api/0.3/start_point,[[transit_point1,...,transit_pointN]],end_point/route_type[/route_type_modifier].output_format[?lang=(en|de)][&units=(km|miles)]
    return string.Format(CultureInfo.InvariantCulture, UrlFormat, Key, Version, start.Lat, start.Lng, end.Lat, end.Lng, travelType, language, units);
 }

 public GeoCoderStatusCode GetPlacemarks(PointLatLng location, out List<Placemark> placemarkList)
 {
     return GetPlacemarkFromReverseGeocoderUrl(MakeReverseGeocoderUrl(location, LanguageStr), out placemarkList);
 }

 string MakeReverseGeocoderUrl(PointLatLng pt, string language)
 {
     return string.Format(CultureInfo.InvariantCulture, ReverseGeocoderUrlFormat, ServerAPIs, pt.Lat, pt.Lng, language);
 }

        // The Coogle Directions API: http://tinyurl.com/6vv4cac

        string MakeDirectionsUrl(PointLatLng start, PointLatLng end, string language, bool avoidHighways, bool avoidTolls, bool walkingMode, bool sensor, bool metric)
        {
            string av = (avoidHighways ? "&avoid=highways" : string.Empty) + (avoidTolls ? "&avoid=tolls" : string.Empty); // 6
            string mt = "&units=" + (metric ? "metric" : "imperial");     // 7
            string wk = "&mode=" + (walkingMode ? "walking" : "driving"); // 8

            return string.Format(CultureInfo.InvariantCulture, DirectionUrlFormatPoint, start.Lat, start.Lng, end.Lat, end.Lng, sensor.ToString().ToLower(), language, av, mt, wk, ServerAPIs);
        }

 public MapRoute GetRoute(PointLatLng start, PointLatLng end, bool avoidHighways, bool walkingMode, int Zoom)
 {
     string tooltip;
     int numLevels;
     int zoomFactor;
     MapRoute ret = null;
     List<PointLatLng> points = GetRoutePoints(MakeRouteUrl(start, end, LanguageStr, avoidHighways, walkingMode), Zoom, out tooltip, out numLevels, out zoomFactor);
     if (points != null)
     {
         ret = new MapRoute(points, tooltip);
     }
     return ret;
 }

 public GMapMarker(PointLatLng pos)
 {
    this.Position = pos;
 }

 /// <summary>
 /// NotImplemented
 /// </summary>
 /// <param name="direction"></param>
 /// <param name="start"></param>
 /// <param name="wayPoints"></param>
 /// <param name="avoidHighways"></param>
 /// <param name="avoidTolls"></param>
 /// <param name="walkingMode"></param>
 /// <param name="sensor"></param>
 /// <param name="metric"></param>
 /// <returns></returns>
 public DirectionsStatusCode GetDirections(out GDirections direction, PointLatLng start, IEnumerable<PointLatLng> wayPoints, PointLatLng end, bool avoidHighways, bool avoidTolls, bool walkingMode, bool sensor, bool metric)
 {
     throw new NotImplementedException();
 }

 public GMapMarkerGoogleRed(PointLatLng p)
    : base(p)
 {
    Size = SizeSt;
    Offset = new Point(-10, -34);
 }

 /// <summary>
 /// return local coordinates from lat/lng
 /// </summary>
 /// <param name="latlng"></param>
 /// <returns></returns>
 public Point FromLatLngToLocal(PointLatLng latlng)
 {
     Point pLocal = Projection.FromLatLngToPixel(latlng, Zoom);
     pLocal.Offset(renderOffset);
     return pLocal;
 }

 public Placemark? GetPlacemark(PointLatLng location, out GeoCoderStatusCode status)
 {
     // http://msdn.microsoft.com/en-us/library/ff701713.aspx
      throw new NotImplementedException();
 }

 string MakeRouteUrl(PointLatLng start, PointLatLng end, string language, bool avoidHighways, bool walkingMode)
 {
     string opt = walkingMode ? WalkingStr : (avoidHighways ? RouteWithoutHighwaysStr : RouteStr);
     return string.Format(CultureInfo.InvariantCulture, RouteUrlFormatPointLatLng, language, opt, start.Lat, start.Lng, end.Lat, end.Lng, Server);
 }