delphi - used - maps embed api inhabilitar learn

Use Googlemap desde mi aplicación Delphi?

Question

Soy miembro de un equipo que mantiene una aplicación interna de Delphi bastante grande. Ahora hemos comenzado a ver el soporte de mapas. Y creemos que Googlemap parece ser el mejor valor para el dinero en comparación con algunos componentes del mapa. La solución actual (que es realmente mala) funciona al iniciar Internet Explorer desde ShellExecute, cargar algunas coordenadas en la URL de Googlemap. Luego, el mapa de Google muestra la mejor dirección para conducir a través de las coordenadas.

Funciona, pero puede ser lento si la cantidad de coordenadas es mayor que, por ejemplo, 10. Además, parece que hay grandes memleaks en IE ...

Otra opción es usar el componente TWebBrowser en su lugar y cargar un archivo html de Googlemap para mostrar lo mismo. Sí, conozco la política de licencias de Googlemaps y estamos dispuestos a pagarle a Google el precio cuando la solución se utilice en la realidad.

En este momento, he registrado una clave API para mi propio sitio solo para prueba. También encontré que funciona para cargar un archivo html local. Desde Javascript puedo llamar a GUnload para eliminar las memleaks según la documentación de Googlemap. Como la clave API está ligada a un dominio o un archivo local, supongo que tengo que guardar un archivo javascript con coordenadas y luego cargarlo en TWebBrowser para cada llamada al mapa. Lo encontré torpe, pero no veo otra manera ...

¿Hay otras opciones para usar Googlemaps? No conozco otros componentes html para Delphi que TWebBrowser debido a un mal rendimiento y administración de memoria. Me gustaría usar un componente de Mozilla, pero parece ser solo para C ++.

Comentarios y consejos sobre esto?

Answer 1

Cuidado con las concecuencias legales. Probamos algo así, pero lo eliminamos porque no encontramos la posibilidad de resolverlo legalmente. Parece que Googlemaps no está diseñado para escritorio. Lo cual no es extremadamente sorprendente.

Por cierto, puedes obtener buenos resultados con kml y google earth.

Answer 2

Tiene razón, no hay otra forma [legal] de insertar un mapa de Google en una aplicación de escritorio: debe usar un tipo de control WeBrowser. Varía según el idioma, por supuesto (como notó con el componente Mozilla C ++), pero de lo contrario sus opciones son muy limitadas.

Answer 3

Una búsqueda rápida de Google en "Google Maps delphi" arrojó más de 10 páginas de resultados. Entre los 3 primeros estaba usando Google Maps desde una aplicación de ejemplo VCL

Answer 4

El único servicio que he podido localizar que ofrece soporte decente para una aplicación de escritorio fue MapQuest. Escribí un artículo introductorio en agosto sobre cómo usar MapQuest con Delphi aquí para extraer los valores Lat / Lng. Básicamente, es todo el formato de mensajes XML para interactuar con su servidor.

Answer 5

El trabajo de Incrustar Mozilla en Delphi parece haberse estancado hace algunos años, pero todavía hay un artículo de Irongut sobre cómo incrustarlo. Nunca fue una solución totalmente satisfactoria, como yo lo entiendo, porque requería una distribución adicional considerable de los archivos de Mozilla (incluso si el usuario ya tenía Mozilla / FF instalado).

Como Gamecat sugirió, Google Earth puede lograr algunos buenos resultados. Encontré un proyecto de muestra simple de Incrustar Google Earth dentro de una Aplicación de Delphi en el " sitio de Google Earth Airlines ". Esto podría ser suficiente para mostrarle si esta solución se ajusta a sus necesidades.

Answer 6

Si busca instrucciones y está preparado para escribir algún javascript, puede usar GDirections, que es parte de la API de GoogleMaps.

Tengo un ejemplo del programa Delphi en Google Maps en un TWebBrowser de Delphi: Direcciones que pueden ser útiles. (Zip del proyecto) .

Answer 7

Vi la demostración de Marco Cantù de esto en Delphi Developer Days a principios de este mes. Fue muy impresionante. Seguro que usó a Indy para todo.

Answer 8

Envolví la API de Google Maps hace algún tiempo. Es un componente que contiene un TWebBrowser que carga un archivo html local que contiene algunas funciones de ayuda de JavaScript y configura una página básica de Google Maps. El archivo HTML está incrustado en el exe como un recurso para una fácil implementación.

Puede usar algo de trabajo, pero ya me ha hecho algunos buenos trabajos. Se amplía la idea que se planteó aquí: http://www.stevetrefethen.com/blog/UsingGoogleMapsFromVCLSampleApplication.aspx

He puesto un ejecutable de demostración y el código fuente en línea aquí: http://www.xs4all.nl/~niff/GoogleMaps.zip

En esta captura de pantalla, cambié a la vista de Google Earth:

Aquí hay algunos ejemplos de cómo puede usarlo:

• Centre el mapa a algunos shithole en los Países Bajos, con coordenadas muy redondeadas:

  GoogleMaps1.SetCenter(52,5,True);

• Cargue un archivo KML o KMZ:

  GeoXML := TGGeoXML.Create(''http://mywebsite.com/mykml.kmz'');
  GeoXML.GoogleMaps := GoogleMaps1;
  GoogleMaps1.AddOverlay( GeoXML );

• Cambie a la versión integrada de Google Earth, para una acción 3D rápida y sin problemas:

  GoogleMaps1.MapType := MT_SATELLITE_3D;

• Mantenga una lista de superposiciones y adminístrelo a través de las estructuras Delphi:

  GoogleMaps1.Overlays[2].hide; // hide overlay 2
  GoogleMaps1.RemoveOverlayByIndex(3); // delete overlay 3

• Te permite crear polígonos usando matrices rápidas Delphi y luego trazar eso en GMaps;

MyPolygon := TGPolygon.Create(MyPointArray);
MyPolygon.Color := clBlue; 
MyPolygon.Name := ''Awesome Polygon 1'';
GoogleMaps1.AddPolygon( MyPolygon );

No tiene la intención de ajustar la API completa; es solo para hacer la vida más fácil cuando se trata de mapas de Google. La unidad DouglasPeuckers no es realmente necesaria. Se usa para simplificar un polígono cuando te quedas sin recursos.

Buena suerte, y avíseme si ha creado algo útil con él.

{—————————————————————————————————————————————————————————————————————————}
{ Project : uGoogleMaps.pas                                               }
{ Comment : Google Maps API wrapper                                       }
{                                                                         }
{    Date : 14 mrt 2008                                                   }
{  Author : Wouter van Nifterick                                          }
{—————————————————————————————————————————————————————————————————————————}
{ The aim of this unit is to wrap the Google Maps API in such a way that  }
{ users don''t need to know that map operations end up being rendered by   }
{ a browser component and JavaScript.                                     }
{                                                                         }
{ JavaScript classes have a Delphi counterpart, and each Delphi class     }
{ takes care of proper JavaScript rendering and execution.                }
{                                                                         }
{ For many things, like constructing detailed polygons, this provides a   }
{ major performance boost and adds compile-time type checking.            }
{                                                                         }
{ A big limitation so far is that I didn''t find a way to directly pass    }
{ complex types from and to the JavaScript engine in IE via COM, so for   }
{ now, everything needs to be (de)serialized to and from strings. :(      }
{—————————————————————————————————————————————————————————————————————————}
{ Last modified                                                           }
{    Date :                                                               }
{  Author :                                                               }
{—————————————————————————————————————————————————————————————————————————}

{$M+}

unit uGoogleMaps;

interface

uses
  Controls,
  Dialogs,
  ActiveX,
  StdCtrls,
  ExtCtrls,
  SysUtils,
  Classes,
  Contnrs,
  Forms,
  SHDocVw,
  MSHTML,
  StrUtils,
  DouglasPeuckers
//  ,  uGoogleEarth_intf
  ;

const
  GoogleMapsFileName = ''GoogleMaps.html'';
  WGS84_MULT_FACT    = 100000; // multiply lat/lon values by this value in order to fit them into integers
  DEFAULT_SIMPLIFY_TOLERANCE = 0.5;

{$R GoogleMaps_html.res}


type


  TGoogleMapControl = (MC_NONE=1,MC_SMALL,MC_LARGE);
  TGoogleMapType    = (MT_NORMAL=1,MT_SATELLITE,MT_HYBRID,MT_PHYSICAL,MT_SATELLITE_3D);

  TGoogleMaps       = class; // forward declaration

  GIcon             = class end; // to be implemented

  IJsClassWrapper=interface(IInterface)
    function JsClassName:String;

    function GetJsVarName:String;
    procedure SetJsVarName(const aVarName:String);
    property JsVarName:String read GetJsVarName write SetJsVarName;

    function ToJavaScript:String;
  end;

  IHidable=interface(IInterface)
    procedure hide;                         // Hides the object if the overlay is both currently visible and the overlay''s supportsHide() method returns true. Note that this method will trigger the respective visibilitychanged event for each child overlay that fires that event (e.g. GMarker.visibilitychanged, GGroundOverlay.visibilitychanged, etc.). If no overlays are currently visible that return supportsHide() as true, this method has no effect. (Since 2.87)
    function  isHidden           : Boolean; // Returns true if the GGeoXml object is currently hidden, as changed by the GGeoXml.hide() method. Otherwise returns false. (Since 2.87)
    procedure show;                         // Shows the child overlays created by the GGeoXml object, if they are currently hidden. Note that this method will trigger the respective visibilitychanged event for each child overlay that fires that event (e.g. GMarker.visibilitychanged, GGroundOverlay.visibilitychanged). (Since 2.87)
    function  supportsHide       : Boolean; // 
  end;


  // marker class
  GMarkerOptions=record
    icon          : GIcon;    // Chooses the Icon for this class. If not specified, G_DEFAULT_ICON is used. (Since 2.50)
    dragCrossMove : Boolean;  // When dragging markers normally, the marker floats up and away from the cursor. Setting this value to true keeps the marker underneath the cursor, and moves the cross downwards instead. The default value for this option is false. (Since 2.63)
    title         : String;   // This string will appear as tooltip on the marker, i.e. it will work just as the title attribute on HTML elements. (Since 2.50)
    clickable     : Boolean;  // Toggles whether or not the marker is clickable. Markers that are not clickable or draggable are inert, consume less resources and do not respond to any events. The default value for this option is true, i.e. if the option is not specified, the marker will be clickable. (Since 2.50)
    draggable     : Boolean;  // Toggles whether or not the marker will be draggable by users. Markers set up to be dragged require more resources to set up than markers that are clickable. Any marker that is draggable is also clickable, bouncy and auto-pan enabled by default. The default value for this option is false. (Since 2.61)
    bouncy        : Boolean;  // Toggles whether or not the marker should bounce up and down after it finishes dragging. The default value for this option is false. (Since 2.61)
    bounceGravity : Integer;   // When finishing dragging, this number is used to define the acceleration rate of the marker during the bounce down to earth. The default value for this option is 1. (Since 2.61)
    autoPan       : Boolean;  // Auto-pan the map as you drag the marker near the edge. If the marker is draggable the default value for this option is true. (Since 2.87)

    // to implement:
    //    zIndexProcess : Function; // This function is used for changing the z-Index order of the markers when they are overlaid on the map and is also called when their infowindow is opened. The default order is that the more southerly markers are placed higher than more northerly markers. This function is passed in the GMarker object and returns a number indicating the new z-index. (Since 2.98)
  end;

  TGPoint=class

  end;

  TGLatLng=class(TInterfacedObject,IJsClassWrapper)
  private
    FLat,
    FLng:Double;
    FJsVarName: String;
    function GetJsVarName: String;
    procedure SetJsVarName(const Value: String);
  published
    constructor Create(aLat,aLng:Double);
    property Lat:Double read FLat write FLat;
    property Lng:Double read FLng write FLng;
    function ToJavaScript:String;
    function Equals(const AGLatLng:TGLatLng):Boolean;
    function ToString:String;
    function JsClassName:String;virtual;
    property JsVarName:String read GetJsVarName write SetJsVarName;
  end;


  TGBounds=class(TInterfacedObject,IJsClassWrapper)
  private
    FJsVarName: String;
    FMinX, FMinY, FMaxX, FMaxY:Double;
    FMin,FMax,FMid:TGLatLng;
    function GetMax: TGLatLng;
    function GetMid: TGLatLng;
    function GetMin: TGLatLng;
    procedure SetJsVarName(const Value: String);
    function GetJsVarName: String;
  published
    destructor Destroy;override;
    property minX : Double read FMinX write FMinX;
    property minY : Double read FMinY write FMinY;
    property maxX : Double read FMaxX write FMaxX;
    property maxY : Double read FMaxY write FMaxY;
    function ToString:String;
    function Equals(aGBounds:TGBounds):Boolean;
    property Min:TGLatLng read GetMin;
    property Mid:TGLatLng read GetMid;
    property Max:TGLatLng read GetMax;
    function JsClassName:String;virtual;
    property JsVarName:String read GetJsVarName write SetJsVarName;
    function ToJavaScript:String;
  end;

  TGLatLngBounds=class
  private
    procedure setNorthEast(const Value: TGLatLng);
    procedure setSouthWest(const Value: TGLatLng);
  published
    constructor Create(sw,ne:TGLatLng);
    destructor Destroy;override;
    function contains(aLatLng:TGLatLng):Boolean; deprecated; // Returns true iff the geographical coordinates of the point lie within this rectangle. (Deprecated since 2.88)
    function containsLatLng(aLatLng:TGLatLng):Boolean; // Returns true iff the geographical coordinates of the point lie within this rectangle. (Since 2.88)
    function intersects(aGLatLngBounds:TGLatLngBounds):Boolean;
    function containsBounds(aGLatLngBounds:TGLatLngBounds):Boolean;
    procedure extend(aLatLng:TGLatLng); // Enlarges this rectangle such that it contains the given point. In longitude direction, it is enlarged in the smaller of the two possible ways. If both are equal, it is enlarged at the eastern boundary.

    function toSpan()       :   TGLatLng; //    Returns a GLatLng whose coordinates represent the size of this rectangle.
    function isFullLat()    :   Boolean ; //    Returns true if this rectangle extends from the south pole to the north pole.
    function isFullLng()    :   Boolean ; //    Returns true if this rectangle extends fully around the earth in the longitude direction.
    function isEmpty()      :   Boolean ; //    Returns true if this rectangle is empty.
    function getCenter()    :   TGLatLng; //    Returns the point at the center of the rectangle. (Since 2.52)

    function getSouthWest() :   TGLatLng; //    Returns the point at the south-west corner of the rectangle.
    function getNorthEast() :   TGLatLng; //    Returns the point at the north-east corner of the rectangle.
    property SouthWest : TGLatLng read getSouthWest write setSouthWest;
    property NorthEast : TGLatLng read getNorthEast write setNorthEast;

    function ToString:String;
    function Equals(aGLatLngBounds:TGLatLngBounds):Boolean;
  end;

  TColor = integer;

  // abstract class.. subclassed by TGMarker and TGPolygon and TGPolyLine..

  TGOverlay=class(TInterfacedObject,IJsClassWrapper,IHidable)
  private
    FID: Integer;
    FGoogleMaps: TGoogleMaps;
    FName: String;
    FJsVarName:String;
    procedure SetID(const Value: Integer);
    procedure SetGoogleMaps(const Value: TGoogleMaps);
    procedure SetName(const Value: String);
    function GetJsVarName: String;
    procedure SetJsVarName(const Value: String);
  public
    procedure hide;virtual;
    function isHidden: Boolean;virtual;
    procedure show;virtual;
    function supportsHide: Boolean;virtual;
  published
    property ID:Integer read FID write SetID;
    function ToJavaScript:String;virtual;abstract;
    property JsVarName:String read GetJsVarName write SetJsVarName;
    property GoogleMaps:TGoogleMaps read FGoogleMaps write SetGoogleMaps;
    property Name:String read FName write SetName;
    function JsClassName:string;virtual;
  end;

  TOverlayList=class(TObjectList)
  private
    AutoIncrementID:Integer;
    function GetItems(Index: Integer): TGOverlay;
    procedure SetItems(Index: Integer; const Value: TGOverlay);
  public
    property Items[Index:Integer]:TGOverlay read GetItems write SetItems; default;
  published
    constructor Create;
    destructor Destroy;override;
    function Add(aGOverlay:TGOverlay):Integer;
    procedure Clear;override;
    function ToString:String;
  end;



  TGInfoWindow=class(TGOverlay,IJsClassWrapper,IHidable)
    procedure Maximize;
    procedure Restore;
  private
    FHTML: String;
    procedure SetHTML(const Value: String);
  public
    property HTML:String read FHTML write SetHTML;
    function JsClassName:String;override;
    constructor Create(const aCenter:TGLatLng);
    destructor Destroy;override;
    function ToJavaScript:String;override;
    function supportsHide: Boolean;override;
  end;


  // used to show a location on a map
  // can be dragged, can show a popup, can have custom colors and icon
  TGMarker=class(TGOverlay,IJsClassWrapper,IHidable)
  private
    FCenter: TGLatLng;
    FDraggingEnabled: Boolean;
    procedure setLatLng(const Value: TGLatLng);
    procedure SetDraggingEnabled(const Value: Boolean);
  public
    function supportsHide: Boolean;override;
  published
    function JsClassName:String;override;
    constructor Create(const aCenter:TGLatLng);
    destructor Destroy;override;
    property Center:TGLatLng read FCenter write setLatLng;
    property DraggingEnabled:Boolean read FDraggingEnabled write SetDraggingEnabled;
    function ToJavaScript:String;override;
   { TODO 3 -oWouter : implement all marker methods and events }

    procedure openInfoWindow(aContent:String); // Opens the map info window over the icon of the marker. The content of the info window is given as a DOM node. Only option GInfoWindowOptions.maxWidth is applicable.
    procedure openInfoWindowHtml(aContent:String); // Opens the map info window over the icon of the marker. The content of the info window is given as a string that contains HTML text. Only option GInfoWindowOptions.maxWidth is applicable.
{    procedure openInfoWindowTabs(tabs, opts?) : none; // Opens the tabbed map info window over the icon of the marker. The content of the info window is given as an array of tabs that contain the tab content as DOM nodes. Only options GInfoWindowOptions.maxWidth and InfoWindowOptions.selectedTab are applicable.
    procedure openInfoWindowTabsHtml(tabs, opts?) : none; // Opens the tabbed map info window over the icon of the marker. The content of the info window is given as an array of tabs that contain the tab content as Strings that contain HTML text. Only options InfoWindowOptions.maxWidth and InfoWindowOptions.selectedTab are applicable.
    procedure bindInfoWindow(content, opts?) : none; // Binds the given DOM node to this marker. The content within this node will be automatically displayed in the info window when the marker is clicked. Pass content as null to unbind. (Since 2.85)
    procedure bindInfoWindowHtml(content, opts?) : none; // Binds the given HTML to this marker. The HTML content will be automatically displayed in the info window when the marker is clicked. Pass content as null to unbind. (Since 2.85)
    procedure bindInfoWindowTabs(tabs, opts?) : none; // Binds the given GInfoWindowTabs (provided as DOM nodes) to this marker. The content within these tabs'' nodes will be automatically displayed in the info window when the marker is clicked. Pass tabs as null to unbind. (Since 2.85)
    procedure bindInfoWindowTabsHtml(tabs, opts?) : none; // Binds the given GInfoWindowTabs (provided as strings of HTML) to this marker. The HTML content within these tabs will be automatically displayed in the info window when the marker is clicked. Pass tabs as null to unbind. (Since 2.85)
    procedure closeInfoWindow() : none; // Closes the info window only if it belongs to this marker. (Since 2.85)
    procedure showMapBlowup(opts?) : none; // Opens the map info window over the icon of the marker. The content of the info window is a closeup map around the marker position. Only options InfoWindowOptions.zoomLevel and InfoWindowOptions.mapType are applicable.
    procedure getIcon() : GIcon; // Returns the icon of this marker, as set by the constructor.
    procedure getTitle() : String; // Returns the title of this marker, as set by the constructor via the GMarkerOptions.title property. Returns undefined if no title is passed in. (Since 2.85)
    procedure getPoint() : GLatLng; // Returns the geographical coordinates at which this marker is anchored, as set by the constructor or by setPoint(). (Deprecated since 2.88)
    procedure getLatLng() : GLatLng; // Returns the geographical coordinates at which this marker is anchored, as set by the constructor or by setLatLng(). (Since 2.88)
    procedure setPoint(latlng) : none; // Sets the geographical coordinates of the point at which this marker is anchored. (Deprecated since 2.88)
    procedure setLatLng(latlng) : none; // Sets the geographical coordinates of the point at which this marker is anchored. (Since 2.88)
    procedure enableDragging() : none; // Enables the marker to be dragged and dropped around the map. To function, the marker must have been initialized with GMarkerOptions.draggable = true.
    procedure disableDragging() : none; // Disables the marker from being dragged and dropped around the map.
    procedure draggable() : Boolean; // Returns true if the marker has been initialized via the constructor using GMarkerOptions.draggable = true. Otherwise, returns false.
    procedure draggingEnabled() : Boolean; // Returns true if the marker is currently enabled for the user to drag on the map.
    procedure setImage(url) : none; // Requests the image specified by the url to be set as the foreground image for this marker. Note that neither the print image nor the shadow image are adjusted. Therefore this method is primarily intended to implement highlighting or dimming effects, rather than drastic changes in marker''s appearances. (Since 2.75)
}

  end;


  TGGeoXml=class(TGOverlay,IJsClassWrapper,IHidable)
  private
    FUrlOfXml: String;
    procedure SetUrlOfXml(const Value: String);
  published

//    function  getTileLayerOverlay: GTileLayerOverlay; // GGeoXml objects may create a tile overlay for optimization purposes in certain cases. This method returns this tile layer overlay (if available). Note that the tile overlay may be null if not needed, or if the GGeoXml file has not yet finished loading. (Since 2.84)
//    function  getDefaultCenter   : GLatLng;           // Returns the center of the default viewport as a lat/lng. This function should only be called after the file has been loaded. (Since 2.84)
//    function  getDefaultSpan     : GLatLng;           // Returns the span of the default viewport as a lat/lng. This function should only be called after the file has been loaded. (Since 2.84)
//    function  getDefaultBounds   : GLatLngBounds;     // Returns the bounding box of the default viewport. This function should only be called after the file has been loaded. (Since 2.84)
    procedure gotoDefaultViewport(Map:TGoogleMaps);     // Sets the map''s viewport to the default viewport of the XML file. (Since 2.84)
//    function  hasLoaded          : Boolean; // Checks to see if the XML file has finished loading, in which case it returns true. If the XML file has not finished loading, this method returns false. (Since 2.84)
//    function  loadedCorrectly    : Boolean; // Checks to see if the XML file has loaded correctly, in which case it returns true. If the XML file has not loaded correctly, this method returns false. If the XML file has not finished loading, this method''s return value is undefined. (Since 2.84)
    function  supportsHide       : Boolean; override; // Always returns true. (Since 2.87)

    function JsClassName:String;override;
    constructor Create(const aUrlOfXml:String);
    destructor Destroy;override;
    property UrlOfXml:String read FUrlOfXml write SetUrlOfXml;
    function ToJavaScript:String;override;
  end;


  // polygon class
  TGPolygon=class(TGOverlay,IJsClassWrapper,IHidable)
  private
    FCoordinates:Array of TGLatLng;
    FOpacity: double;
    FWeightPx: integer;
    FColor: TColor;
    FSimplified: TGPolygon;
    FIsDirty: Boolean;
    procedure SetColor(const Value: TColor);
    procedure SetOpacity(const Value: double);
    procedure SetWeightPx(const Value: integer);
    function GetCount: Integer;
    procedure SetSimplified(const Value: TGPolygon);
    function GetSimplified: TGPolygon;
  public
    constructor Create(const aCoordinates: array of TGLatLng);overload;
    constructor Create(const aPoints:Array of TPointFloat2D);overload;
    function supportsHide: Boolean;override;
  published
    function JsClassName:String;override;
    procedure Clear;
    function ToJavaScript:String;override;
    function AddPoint(const aGLatLng:TGLatLng):integer;
    property Color:TColor read FColor write SetColor;
    property WeightPx:integer read FWeightPx write SetWeightPx;
    property Opacity:double read FOpacity write SetOpacity;// number between 0 and 1
    property Count:Integer read GetCount;
    destructor Destroy;override;
    property IsDirty:Boolean read FIsDirty write FIsDirty;
    property Simplified:TGPolygon read GetSimplified write SetSimplified;
    function getSimplifiedVersion(Tolerance:Double=DEFAULT_SIMPLIFY_TOLERANCE):TGPolygon;
    class function PolyTypeStr: String;virtual;
  end;

  TGPolyLine=class(TGPolygon,IJsClassWrapper,IHidable)
  published
    class function PolyTypeStr:String;override;
    function JsClassName:String;override;
  end;

  TGCopyright=class(TGOverlay,IJsClassWrapper,IHidable)
  private
    FminZoom: Integer;
    Fid: Integer;
    Fbounds: TGLatLngBounds;
    Ftext: String;
    procedure Setbounds(const Value: TGLatLngBounds);
    procedure Setid(const Value: Integer);
    procedure SetminZoom(const Value: Integer);
    procedure Settext(const Value: String);
  published
    property id         : Integer        read Fid write Setid; // A unique identifier for this copyright information.
    property minZoom    : Integer        read FminZoom write SetminZoom; // The lowest zoom level at which this information applies.
    property bounds     : TGLatLngBounds read Fbounds write Setbounds; // The region to which this information applies.
    property text     : String         read Ftext write Settext; // The text of the copyright message.
    constructor Create (aId : Integer; aBounds:TGLatLngBounds;aMinZoom:Integer;aText:String);
  end;

  TGoogleMaps=class(TPanel)
  private
    FWebBrowser:TWebBrowser;
    FhasEnd: Boolean;
    FhasStart: Boolean;
    FLogLines: TStrings;
    FOverlays: TOverlayList;
    FMapType: TGoogleMapType;
    FLatLngCenter: TGLatLng;
    FEnableDoubleClickZoom: Boolean;
    FEnableContinuousZoom: Boolean;
    FStatusPanel: TPanel;
    FJsVarName: String;
    procedure LoadHTML(URL:String);
    procedure SetLogLines(const Value: TStrings);
    procedure SetOverlays(const Value: TOverlayList);
    procedure Init;
    procedure SaveGoogleMapsHtml(const aFileName:String);
    procedure SetLatLngCenter(const Value: TGLatLng);
    procedure SetEnableContinuousZoom(const Value: Boolean);
    procedure SetEnableDoubleClickZoom(const Value: Boolean);
    function GetLatLngCenter: TGLatLng;
    property WebBrowser : TWebBrowser read FWebBrowser write FWebBrowser;
    procedure SetMapType(AMapType:TGoogleMapType);
    procedure SaveHTML(const FileName:String);
    function GetHTML: String;
    property hasStart     : Boolean read FhasStart write FhasStart;
    property hasEnd       : Boolean read FhasEnd write FhasEnd;
    procedure SetStatusPanel(const Value: TPanel);
    procedure SetJsVarName(const Value: String);
    property DragKind;
    property DragMode;
    property DockSite;
    property Ctl3D;
    property BiDiMode;
    property AutoSize;
    property HelpContext;
    property HelpKeyword;
    property HelpType;
    property Owner;
    property ParentBackground;
    property ParentBiDiMode;
    property ParentCtl3D;
    property Showing;
    property UseDockManager;
    property VerticalAlignment;
    property WheelAccumulator;



  public
    constructor Create(AOwner: TComponent);override;
    destructor Destroy;override;
    procedure SetCenter(Lat,Lng,Alt:Double;doPan:Boolean=false);overload;
    procedure SetCenter(Lat,Lng:Double;doPan:Boolean=false);overload;
    procedure SetCenter(LatLng:TGLatLng;doPan:Boolean=false);overload;
    procedure HandleOnResize(Sender:TObject);
    function GetJsValue(aJavaScript:String):OleVariant;
    property HTML: String read GetHTML;
    procedure CheckResize;
  published
    property StatusPanel  : TPanel read FStatusPanel write SetStatusPanel;
    property LogLines     : TStrings read FLogLines write SetLogLines;
    property Overlays     : TOverlayList read FOverlays write SetOverlays;
    property LatLngCenter : TGLatLng read GetLatLngCenter write SetLatLngCenter;
    property EnableContinuousZoom:Boolean read FEnableContinuousZoom write SetEnableContinuousZoom default true;
    property EnableDoubleClickZoom:Boolean read FEnableDoubleClickZoom write SetEnableDoubleClickZoom default true;
    property MapType:TGoogleMapType read FMapType write SetMapType;
    property JsVarName:String read FJsVarName write SetJsVarName;
    procedure AddControl(ControlType:TGoogleMapControl);
    procedure AddStartMarker;
    procedure AddEndMarker;
    procedure AddMarker(Lat,Lon:Double);
    procedure AddPolygon(GPolygon:TGPolygon);
    procedure AddOverlay(aOverlay:TGOverlay);
    procedure RemoveOverlay(aOverlay:TGOverlay);
    procedure RemoveOverlayByIndex(Index:Integer);
    procedure ClearOverlays;
    procedure SwapBeginEndMarkers;
    procedure GetDirections;
    procedure ShowAddress(const Street,City,State,Country:String);
    procedure openInfoWindow(aLatlng : TGLatLng; aHTML:String);
    procedure closeInfoWindow;
    procedure ExecJavaScript(const aScript:String);
    procedure WebBrowserDocumentComplete(ASender: TObject; const pDisp: IDispatch; var URL: OleVariant);
    procedure OnMouseOver;

    property Align;
    property OnClick;
    property OnCanResize;
    property OnResize;
    property OnEnter;
    property OnExit;
    property OnKeyDown;
    property OnKeyPress;
    property OnKeyUp;
    property OnDblClick;
    property OnMouseWheel;
    property OnMouseWheelDown;
    property OnMouseWheelUp;
    property OnConstrainedResize;