Archivo

Entradas Etiquetadas ‘Google Maps’

Versión v.1.2b de la aplicación TrackInfo

martes, 19 de abril de 2011 4 comentarios
Share Button

Acabo de publicar la versión 1.2 de TrackInfo.

TrackInfo es una aplicación que permite obtener información y visualizar sobre un mapa, rutas en formato GPX (GPS eXchange Format). Está pensado (o enfocado) a la carga de archivos que provienen desde un dispositivo GPS. Permite la conversión de rutas entre diferentes formatos.

NEW:

  • Actualizados los formatos de conversión;  KML (Google Earth), TCX (Garmin training center), GTM (GPS TrackMaker), PLT (Ozi explorer), GDB (Mapsource), TRK (CompeGPS), XOL (Swiss Map), …
  • Animación de recorrido de la ruta
  • Gráficos de Alturas y velocidad sincronizados con la animación.
  • Información extendida para los puntos que forma la ruta (Velocidad puntual, distancia acumulada, ascenso acunulado, descenso acumulado,…)
  • Corrección de errores y bugs respecto a la versión anterior.
  • Mayor rapidez en la carga de rutas y en la conversión.
  • Mejoras menores.

Descripción completa de la aplicación y Descargas.

Share Button

Visualizar un fichero KML en Delphi II

lunes, 14 de marzo de 2011 4 comentarios
Share Button

Esta entrada se podría considerar como una “ampliación” de la última publicada relacionada con los ficheros KML, Generar ficheros KML de rutas; Tracks en Google Maps. A partir de un tema surgido en los foros del Clubdelphi de cómo visualizar estos ficheros directamente sobre Google Maps dentro de una aplicación Delphi, he modificado el programa anterior (que incluía la conversión desde GPX) para poder visualizarlos directamente.

En un ejemplo más simplificado, y enfocado a los ficheros KML. Como ya dije anteriormente, este tipo de ficheros pueden almacenar otros tipos de información y en este ejemplo se leen los datos directamente desde este tipo de ficheros (en este caso sólo la ruta).

Además el mapa está optimizado para visualizarse a tamaño completo, y no según el tamaño de la ventana como estaba anteriormente (esto implica la optimización de que no se recarga la página al cambiar el tamaño).

También se ha modificado el recurso de la página Web, para que automáticamente se calcule en “centrado” y el “zoom” del mapa a partir del Track que se va a visualizar. Para ello se utiliza el siguiente código:

0
1
2
var polylineBounds = polyline.getBounds();
var ZoomLevel = map.getBoundsZoomLevel(polylineBounds) - 1;
map.setCenter(polylineBounds.getCenter(), ZoomLevel);

Se puede descargar el ejemplo desde aquí (incluye los fuentes).

<Descargar fuentes>

AÑADO: compilación en Delphi XE2.

Debido a un cambio en la definición de la función EnumResourceModules, que pasa de usar LongInt a NativeInt, hay que realizar un cambio en el procedimiento que se le pasa como parámetro, modificando este dato.
La definición del procedimiento, ahora queda así:

0
1
2
function _MyEnumResourceModules (
Instance:{$IFDEF VER230}NativeInt{$ELSE}Pointer{$ENDIF};
Data:Pointer):Boolean;
Share Button

Generar ficheros KML de rutas; Tracks en Google Maps

miércoles, 2 de marzo de 2011 10 comentarios
Share Button

En esta entrada mostraré el código nesario para generar ficheros KML (Keyhole Markup Language) a partir de datos que provienen de un DataSet o de un fichero GPX (GPX eXchage Format).
Los ficheros KML se utilizan para representar datos geográficos en 3 dimensiones (además de la longitud y la Latitud incluyen también la altura) y fue desarrollado para ser utilizado por un programa que a posteriori se convertiría en Google Earth.

En una entrada anterior ya vimos como importar un fichero GPX, con posiciones geográficas a un Dataset para posteriormente poder tratar y manejar estas posiciones (Cargar fichero GPX (XML) y acceder a los datos). Partiendo de lo visto en esa entrada como base, debe ser sencillo generar un fichero KML con los puntos que forma la ruta.

Hay que decir que los ficheros KML permiten muchas más cosas de las vistas en esta entrada, y para ver todas las posibilidades podemos revisar los ejemplos que se muestran aquí (Tutorial KML en Google); En este entrada me voy a centrar en la creación de rutas (lista de puntos) aunque las posibilidades van mucho más allá.

La estructura de nuestro fichero se compone por una cabecera, donde se almacenan datos genéricos de la ruta, y el bloque central donde añadimos los diferentes puntos geográficos que la componen.
Un ejemplo sencillo de fichero KML podría ser este:

<?xml version=”1.0″ encoding=”UTF-8″?>
<Placemark>
<name>Camino de ejemplo</name>
<description>Puntos de ejemplo sobre Collserola.</description>
<Style><LineStyle><color>ff0000FF</color><width>3</width></LineStyle></Style>
<LineString>
<coordinates>
2.12578324,41.4157072,275.5550537109375
2.12559993,41.4156055,275.074462890625
2.12537404,41.4152729,275.074462890625
2.12531452,41.4151532,274.59375
2.12518930,41.4149554,275.074462890625
2.12525032,41.4145536,274.113037109375
2.12553421,41.4141423,275.5550537109375
2.12541938,41.4139779,275.5550537109375
2.12537412,41.4139778,275.5550537109375
2.12492954,41.4139116,274.59375
2.12441666,41.4137039,273.6324462890625
2.12425304,41.4136318,274.113037109375
2.12396864,41.4136072,273.6324462890625
2.12380528,41.4136296,273.15185546875
2.12357947,41.4136973,273.15185546875
2.12343120,41.4137774,273.15185546875
2.12328091,41.4139091,272.671142578125
2.12321687,41.4140272,273.15185546875
2.12320983,41.4141903,273.15185546875
</coordinates>
</LineString>
</Placemark>

Como vemos en la parte superior añadimos datos de la ruta y algunas opciones de visualización. En este caso un nombre y una descripción y porteriormente se definen opciones de estilo para el track (LineStyle); Definimos que usaremos una línea para representar esos puntos con color Rojo y un a anchura de 3.

Este archivo podemos abrirlo directamente con Google Earth o importarlo a “Mis Mapas” desde Google Maps y la visualización ser algo así;

En Google Maps al importar la ruta tendríamos esto:

Y al Abrir el fichero con Google Earth obtendríamos esto:

Podemos ver que como la ruta está definida como <LineString>, esta se pinta como una línea siguiendo los parámetros definidos en el fichero (color rojo y ancho 3).

Para generar el fichero con una ruta, partiremos de que los datos han sido imprtados a un Dataset y que ya disponemos de ellos en ese formato.

Primero generaremos la cabecera del fichero con los datos genéricos de la ruta; Nombre, Descripción, y las características de estilo para la línea:

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
const
  CAB_XML         = '<!--?xml version="1.0" encoding="UTF-8"?-->';
  CAB_KLM         = '';
  CAB_PLACEMARK   = '';
  CAB_NAME        = '%s';
  STR_STYLE       = '<!--
<LineStyle>
<color>%s</color>' +
                    '<width>%d</width></LineStyle>
-->';
  CAB_LINE        = '';
begin
  // Limpiar
  TSTrack.Clear;
  // Añadir cabeceras
  TSTrack.Add(CAB_XML);
  TSTrack.Add(CAB_KLM);
  TSTrack.Add(CAB_PLACEMARK);
  // Datos de la ruta
  TSTrack.Add(Format(CAB_NAME,[AtrackName]));
  // color
  {$IFDEF VER220}
  // transparencia + color
  Str := 'ff' + RGBToWebColorStr(ATrackColor);
  {$ELSE}
  Str := 'ff' + uProcedures.RGBToWebColorStr(ATrackColor);
  {$ENDIF}
  Str := AnsiReplaceText(Str, '#', '');
  // TrackColor en HEXA
  TSTrack.Add(Format(STR_STYLE,[Str, ATrackWidth]));
  TSTrack.Add(CAB_LINE);

Con este código generamos la cabecera del fichero. En mi caso he usado una directiva condicional, para la función RGBToWebColorStr, que no está definida en versiones antiguas de la VCL.

Lo siguiente es realizar el recorrido por los puntos, añadiendo información de cada uno de ellos.

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
dsPoints.First;
// recorrido
while not (dsPoints.Eof) do begin
  // Info. de punto
  StrLine :=
     Copy(dsPoints.FieldByName(lonFName).AsString,1,10) + ',';
  StrLine := StrLine +
      Copy(dsPoints.FieldByName(latFName).AsString, 1,10) +  ',';
  StrLine := StrLine +
      dsPoints.FieldByName(eleFName).AsString + ' ';
  // Añadir la linea
  TSTrack.Add(StrLine);
  // Next
  dsPoints.Next;
end;

Sólo queda finalmente completar el fichero añadiendo los TAG’s de las diferentes secciones que hemos ido creando.

Para facilitar el trabajo he encapsulado la conversión en el procedimiento siguiente:

0
1
2
3
4
5
6
7
8
9
procedure ConvertTrackToKLM(
   ATrackName:string;  // Nombre
   ATrackDesc:string;  //descripción
   dsPoints:TDataSet;   //  Dataset que contiene los datos de los puntos
   {Nombres de los campos en el Dataset que contienen
    Latitud, Longitud, Elevación y Time}
   latFieldName, lonFieldName, eleFieldName, timeFieldName:string;
   var TSTrack:TStrings;   // Estructura de salida con el track
   ATrackColor:TColor=clBlue;  // Color para la linea del track
   ATrackWidth:integer=2   // Anchura de la línea);

Y una llamada de ejemplo a este procedimiento podrías ser la siguiente:

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
  TS := TStringList.Create();
  try
    // convertir a KML
    ConvertTrackToKLM(
           FormData.cdsTrack.FieldByName('name').AsString,    // trackName
           'Descripción del track',      // descripción
           FormData.cdsPoints,        // Dataset con los puntos
           'lat', 'lon','ele','time',        // Nombre de los campos
           TS);
    // Fichero de salida
    newName := ChangeFileExt(Self.TrackPath, '.KML');
    TS.SaveToFile(newName);
  finally
    FreeAndNil(TS);
  end;

Partiendo de la aplicación que sirvió de ejemplo en la entrada <Google Maps en Delphi>, he generado otro ejemplo que nos permitirá integrar la carga de un fichero GPX (utilizando el XML Mapper de Delphi), la conversión del fichero GPX a formato KML y la visualización de la ruta creada utilizando Google Maps integrado en nuestra aplicación, como prometí en la última entrada sobre el tema.

He probado a generar un video del ejemplo para ver el funcionamiento.

[youtube DLoX_KVSJ7c nolink]

Para las pruebas podeís descargar las rutas de ejemplo de la última entrada o buscar por internet en la infinidad de páginas que hay que las publican

<Rutas de ejemplo (GPX)>

Podéis descargar tanto el ejecutable del proyecto (con alguna ruta de ejemplo) como los fuentes:

<Sources del proyecto>
<Ejecutable del proyecto>

CORRECCIÓN: He añadido un fichero que faltaba al ejecutable de ejemplo.

Un saludo.

Share Button

[APP] IBPIndex v.1.7b; Información sobre Tracks (GPS)

sábado, 1 de enero de 2011 33 comentarios
Share Button

ACTUALIZACIÓN:  Debido a cambios en la política de Google Maps hay una nueva actualización del programa IBPIndex.  

IBPIndex es una aplicación que permite obtener información y visualizar sobre un mapa, rutas en formato GPX (GPS eXchange Format), GTM (GPS Trackmaker), KML (Google Earth), PLT (OziExplorer), TCX (Garmin Training Center), GDB (Mapsource), TRK (CompeGPS), TRL (Alan Map500 TrackLog), MPS (Garmin Mapsource), UPT (Magellan File -eXplorist-) y XOL (Swiss Map 25/50/100).

Está pensado (o enfocado) a la carga de archivos que provienen desde un dispositivo GPS.

TrackInfo

INFORMACIÓN:

  • Funciona en todas las versiones de Windows.
  • NEW Versión 1.7 (beta)  del 15/12/2011
  • La aplicación se puede usar y distribuir de forma totalmente gratuíta.

 

CARACTERÍSTICAS:

  • Visualización de los puntos de ruta sobre un gráfico; Información de puntos. Zoom, impresión, exportación…
  • Permite abrir y convertir tracks en los siguientes formatos:

GPS Trackmaker (*.GTM)
Google Earth (*.KML)
OziExplorer (*.PLT)
Garmin Training Center (*.TCX)
Mapsource (*.GDB)
CompeGPS (*.TRK)
GPS Exchange Format (*.GPX)
Alan Map500 TrackLog (*.TRL)
Garmin Mapsource (*.MPS)
Magellan File -eXplorist- (*.UPT)
Swiss Map 25/50/100 (*.XOL)

  • Exportación con interface a GPSBabel a otros formatos
  • Configuración de múltiples idiomas y fácil creación de nuevos (aplicación).
  • Gráficos de altura y velocidad de la ruta.
  • Información puntual para los puntos de la ruta.
  • Animación de rutas/recorridos gráficamente.
  • Visualización de las rutas sobre Google Maps. Exportación e impresión de mapas.
  • Visualización de Perfil de altura de los datos el track. Exportación como imagen.
  • Interface Ribbon.
  • Información del IBPIndex de la ruta (www.ibpindex.com); Impresión y exportación a PDF.
  • Actualizaciones automáticas desde Internet.
  • Visualización en Google Maps en 3D utilizando pluging de Google Earth.

 

IMAGENES:

Click sobre las imagenes para agrandar.

Interface Ribbon de la aplicación (principal) .

Interface Ribbon

Otras ventanas de la aplicación (principal de Datos, Gráfico, Google Maps, Perfil, IBPIndex,…)

Ventana principal de DatosVentana de gráficoGoogle MapsPantalla IBPIndexConversión de rutas

INSTALACIÓN:

La aplicación se distribuye en un fichero instalable (setup_IBPIndex.exe). Basta con lanzar la instalación desde Windows y seguir las instrucciones del programa.

NOTA: En Vindows Vista y Windows 7 es necesario ejecutar la instalación con privilegios de administrador.

Si tiene problemas para instalar el programa, puede consultar aquí.

TRADUCCIONES

Si deseas añadir y cooperar en el desarrollo de la aplicación con nuevos idiomas, puedes hacerlo con unos sencillos pasos:

  1. Crea un nuevo fichero de idioma basándote en algunos de los ficheros de idioma presentes en la aplicación (es.lng, ca.lng, en.lng,…).
  2. Con un editor de texto (NOTEPAD, por ejemplo) traduce las constantes manteniendo la misma estructura que tienen; Especial atención a los símbolos especiales (&  *|* ).
  3. Envíamelo a la dirección <german_ral[ARROBA]hotmail.com> con tus datos.
  4. Una vez revisada y comprobada, la añadiré al programa con tus datos como traductor.

 

DESCARGA:

La aplicación se puede descargar desde esta misma web, o desde la web de IBPIndex (sección Aplicaciones).

Descarga desde aquí.  

Descarga desde IBP Index.

 

APORTA…

Esta aplicación es gratuíta y está realizada para utilizarla a nivel personal y por puro ocio. Me gusta la programación y me gusta la actividad de BTT, así que el resultado ha sido este.

Espero que a otras personas les pueda ser útil y aceptaré/agradeceré propuestas, ideas, correcciones, sugerencias,… para mejorarla y ampliarla.

 

HISTORIAL

Versión 1.7b (15/12/2001)

* Corregidos varios errores.
* mejoras en la visualización de mapas (Google Maps).

Versión 1.4b (12/05/2011)

ERRORES CORREGIDOS
* Corregidos errores de multiidioma. Se utiliza un sistema nuevo más abierto que permite añadir y traducir a nuevos idiomas mçás fácilmente
* Corregidos problemas al cargar ficheros con caracteres extraños en el nombre.
* Corregido error al mostrar elevación de ruta.
* Corregido error en el comando de conversión.
* Corregidos bugs menosres.

MEJORAS AÑADIDAS:
* Mejoras en el multiidioma (Cambio a un sistema más abierto).
* Admite rutas el multiples formatos a la hora de cargar.
* Carga e importa rutas más rápido (optimizado)
* Índice de carga de ruta
* Ajuste de columnas.
* Añadida traducción al Inglés y catalán.

 

Versión 1.2 (20/04/2011)

ERRORES CORREGIDOS:
* Error en el cuadro de arrastrar ruta; No admite arrastre.
* Corregido error en algunos equipos, que se quejan de que no exiaste MIDAS.DLL
* Corrección a la hora de actualizar la aplicación. En algunos casos no se descargaba
correctamente el fichero.
* Errores varios en la consulta del IBPIndex.
* Errores en los datos de rutas.

MEJORAS AÑADIDAS:
* Añadidos gráficos de velocidad y altura
* Sincronización de los puntos de cada gráfico
* Animación de la ruta visualmente.
* Información extendida de los puntos de la ruta.
* Título completo para la aplicación (incluyendo versión)
* Añadida información al gráfico referente a los puntos (Hora, distancia, acumulados,…).
* Ampliados los formatos de conversión de rutas.

Versión 1.1  (01/04/2011)

Versión inicial.

 

Un saludo.

 

 

Share Button

Google Maps en Delphi – II

lunes, 29 de junio de 2009 35 comentarios
Share Button

En la última entrada acerca de la API de Google Maps, vimos cómo mostrar un Mapa utilizando la API en un programa Delphi, cómo centrarlo en una posición predefinida y utilizando un Zoom predeterminado.

Además como seleccionar entre los diferentes controles que podemos añadir al mapa (Zoom, Vista general, tipo de mapa…).

También cómo colocar una marca en una ubicación y cómo generar una ventana con información asociada a esa marca (NOTA1).

NOTA1: De forma similar se pueden colocar otros elementos sobre el mapa, como:

  • Líneas, polilíneas y polígonos.
  • Marcas con iconos personalizados.
  • Rutas

Una vez visto cómo mostrar el mapa, lo que nos queda es ver cómo podemos, desde nuestro programa Delphi, interactuar con él; Es decir, que el usuario pueda modificar determinadas características del mapa que tiene en pantalla, y nosotros podamos recuperar esos cambios, para utilizarlos en nuestro programa.

Vamos a continuar con el ejemplo visto en las entradas anteriores; Mostraremos al usuario un Mapa ubicado en una determinada posición. El usuario debe poder “reubicar” la vista del mapa y modificar el Zoom con que está visualizando el mapa, y esos son los valores que obtendremos para posteriormente almacenarlos y actualizarlos en nuestro programa.

  • Coordenada de Longitud
  • Coordenada de Latitud
  • Zoom actual del mapa

La forma de conseguirlo, es añadir a la página web el código necesario para capturar eventos que se produzcan en el mapa. Incluiremos controles de edición, donde se almacenan la longitud/latuitud y Zoom, que después recuperaremos desde el programa Delphi.

0
1
2
GEvent.addListener(map, "click", function (overlay,point)
GEvent.addListener(map, "zoomend", function (oldLevel, newLevel)
GEvent.addListener(map, "mousemove", function(latlng)

Aunque uno no esté muy familiarizado con el tema (yo mismo no lo estoy mucho  ;-D ), no hacen falta muchas explicaciones para comprender los eventos; “Capturaremos” en OnClick, OnZoomEnd y OnMouseMove sobre el mapa. Aquí se puede acceder a la lista de eventos, métodos y propiedades de la clase Gmap.

En el caso del evento OnClick, por ejemplo, utilizaremos un código como este:

0
1
2
3
4
5
6
7
GEvent.addListener(map, "click", function (overlay,point){
if (point){
document.posicion.x.value=point.x
document.posicion.y.value=point.y
document.posicion.z.value=map.getZoom()
TipoMapa = map.getCurrentMapType().getName()
document.posicion.t.value=TipoMapa
}

Obtenemos información del punto actual (utilizando un parámetro) y el Zoom actual y el tipo de Mapa utilizando métodos de la clase GMap. Todos ellos se almacenan (como hemos comentado antes) en componentes de tipo Text, que nos sirven como “paso intermedio” para luego capturar esos valores de la página Web desde nuestro programa.

Como resultado final, os dejo el ejemplo que se adjunta con esta entrada. En él he incluído/integrado la parte de Geocodificación (visto en las entradas I y II), y el código y modificaciones necesarias para recuperar posición, Zoom y tipo de Mapa (este incluído a última hora) que el usuario selecciona en un Mapa.

Información capturada

La información de los lugares puede ser guardada y recuperada de un fichero de texto; La estructura es bastante simple y no hace falta mayor explicación. Se almacena en el mismo directorio de la aplicación y recibe el nombre de “Lugares.txt”.

Recuperar y Guardar ubicaciones

La información que podemos capturar del Mapa (utilizando la clase GMap) y de otros elementos que estén incluíds en el mapa (imágenes, líneas, marcas,…) es muy extensa y está detallada en las referencias de la API de Google Maps.

Personalmente, creo que las posibilidades de ampliación son muy grandes y bastantes más sencillas de lo que a priori puede parecer.

Se puede descargar el ejemplo completo desde aquí.
<DESCARGAR EJEMPLO>

Espero que estas entradas hayan sido de utilidad. Como siempre cualquier comentario, corrección, sugerencia,… es bienvenida. ;-D

Un saludo.

ACTUALIZACIÓN (10 Febrero 2012): Dado el cambio de política de Google, ahora es necesario (obligatorio) colocar la key que se proporciona desde Google para poder utilizar la API. Es necesario modificar el fichero _mapa.txt del recurso y  recompilarlo utilizando RC.CMD.

 

Share Button

Google Maps en Delphi – I

jueves, 14 de mayo de 2009 6 comentarios
Share Button

Después de las dos entradas sobre Codificacióin Geográfica (*), toca entrar de lleno en la Visualización e Integración de Google Maps en nuestro programa, que por otra parte era el objetivo inicial de esta serie de entradas. La Codificación Geográfica (obtención de Latitud y Loingitud a partir de una dirección postal) era un “escollo” a salvar en nuestro camino, hasta nuestro verdadero objetivo.

(*) Lo normal es tener en nuestros programas/aplicaciones una serie de direcciones postales o direcciones de correo que deseamos mostrar o señalar en un Mapa. Para utilizar esas direccones con la API de Google Maps necesitamos obtener las coordenadas de Latitud y Longitud apropiadas. Para ello ya vimos  aquí (Codificación Geográfica – I) y aquí (Codificación Geográfica – II) cómo Google provee métodos para obtener las coordenadas de posicionamiento a partir de direcciones postales.

La idea para conseguir la integración es sencilla. Utilizar un componente TWebBrowser para mostrar una página HTML. Desde Delphi debemos “modificar” esa página para que muestre lo que nosotros deseemos.

Utilizando una sencilla página HTML con un Script, podemos visualizar el mapa correspondiente a coordenadas de Latitud y Longitud.  Con un componente TWebBrowser podemos visualizar esa página dentro de una aplicación delphi.

La página en sí sólo contiene el Script para Visualizar un Mapa.
Dentro del Script vemos cómo se crea un elemento de tipo “map”:

0
map = new GMap2(document.getElementById("map"));

Se añaden los controles que queremos visualizar en el mapa; En este caso, la selección para el tipo de mapa y control de zoom y posición grande.

0
1
2
        // Controles del mapa
        map.addControl(new GMapTypeControl());
        map.addControl(new GLargeMapControl());

El tipo de mapa que queremos que inicialmente aparezca (Mapa, visión por satélite o lo que Google llama híbrido).

0
1
        // Tipo de mapa
        map.setMapType(G_NORMAL_MAP);

Y por último colocamos la posición (latitud y longitud) donde queremos que el mapa salga centrado.

Pero no acaban aquí (ni mucho menos) las posibilidades de Google Maps. Una de las opciones, que dentro de lo sencillo, es muy interesante, es la inclusión de marcas señalando puntos del mapa o incluso ventanas de información no es mucho más complejo.

Para añadir una nueva marca, basta con conocer el punto exacto donde queremos situarla y utilizar un objeto GMarker para mostrarla en el mapa. En cuanto a la ventana, de información, sólo necesitamos el código HTML necesario para crearla.
En este ejemplo la ventana tiene un código sencillo (texto, imagen y link) que se almacena en una variable.

0
1
2
3
4
5
6
7
8
// VENTANA (HTML)
 var html="<img src="http://neftali.clubdelphi.com/images/imagen_neftali_60x54.jpg" alt="" width="60" height="54" />
" + "by Neftalí -Germán Estévez-  2009 <strong>
<a href="http://neftali.clubdelphi.com"
 target="_blank">http://neftali.clubdelphi.com</a>
</strong>
<a href="http://neftali.clubdelphi.com" target="_blank">
    </a>
";

Para mostrarla basta con que utilicemos en método OpenInfoWindowHtml (cuyo nombre es bastante descriptivo, por cierto ;-D ) de la siguiente forma:

0
1
2
3
    // Visualización de la mrca
    var point = new GLatLng(41.381655,2.122829);
    var marker = new GMarker(point);
    marker.openInfoWindowHtml(html);

Hay más opciones y basta con echarle una vistazo a la API de Google Maps para conocerlas. Además hay muchos ejemplos de utilización que pueden servir para aclarar los conceptos y para ver más cláramente cómo se utilizan los diferentes elementos.

Todo lo visto hasta aquí, está puesto en práctica en un ejemplo Delphi.

Podéis descargar el código completo (incluye EXE -comprimido UPX-) desde aquí:
<Descargar Ejemplo>

Y aquí acabamos esta entrada, que no será la última. Me dejo para una segunda parte, algunos detalles finales, como interactuar con el mapa y obtener datos de él y fusionar los dos conceptos vistos hasta ahora.

Nos vemos.

Share Button