Hace tiempo me topé con un tema similar a este, aunque con un enfoque diferente; En aquel caso se trataba de que el usuario pudiera crear su propio menú personalizado dentro de una aplicación. Es decir, que además de las opciones propias de la aplicación, el usuario pudiera configurarse un menú con las opciones que más deseara utilizar o tener más «a mano». En este caso, y a partir de este hilo en los foros del Clubdelphi, se ha planteado la posibilidad de que un usuario pueda crearse sus propios «accesos directos» a opciones del menú.
La solución en aquel momento pasó por «volcar» el contenido del menú a otro componente (en ese caso un TreeView, de forma similar a cómo se ve en este ejemplo) y desde ese, generar la estructura del nuevo punto de menú arrastrando elementos.
Para el problema de generar accesos directos, se me antoja que se pueda usar un sistema similar.
(1) «Volcar» el contenido del menú hasta otro componente que nos permita trabajar con los elementos del menú (ya que ni el menú ni los ítems poseen opciones para arrastrar -Drag & Drop-). Este esta caso vamos a utilizar un componente (TListBox) donde almacenaremos los elementos y los apuntadores a los ítems del menú (propiedad Objects).
procedure TFormMain.Button1Click(Sender:TObject);var
i:integer;
str:string;// Recursiva para obtener los subItemsprocedure GetItems(mi:TMenuItem);var
i:Integer;beginfor i :=0to(mi.Count-1)dobegin
Str := mi.Items[i].Caption;
ListBox1.Items.AddObject(Str, mi.Items[i]);// SubItems de este
GetItems(mi.Items[i]);end;end;begin// Recorerr menu principalfor i :=0to(MainMenu1.Items.Count-1)dobegin
Str := MainMenu1.Items[i].Caption;
ListBox1.Items.AddObject(Str, MainMenu1.Items[i]);// SubItems de este
GetItems(MainMenu1.Items[i]);end;end;
procedure TFormMain.Button1Click(Sender: TObject);
var
i:integer;
str:string;
// Recursiva para obtener los subItems
procedure GetItems(mi:TMenuItem);
var
i:Integer;
begin
for i := 0 to (mi.Count - 1) do begin
Str := mi.Items[i].Caption;
ListBox1.Items.AddObject(Str, mi.Items[i]);
// SubItems de este
GetItems(mi.Items[i]);
end;
end;
begin
// Recorerr menu principal
for i := 0 to (MainMenu1.Items.Count - 1) do begin
Str := MainMenu1.Items[i].Caption;
ListBox1.Items.AddObject(Str, MainMenu1.Items[i]);
// SubItems de este
GetItems(MainMenu1.Items[i]);
end;
end;
Con este código poblamos el ListBox con los Caption(Text) de los elementos del menú, y lo que es más importante, los apuntadores a cada elementos que se guardar al utilizar AddObject.
(2) ¿Cómo crear un acceso directo que permita ejecutar una opción de menú? Para ello podemos utilizar un TImage que sobre el cual programaremos el evento OnDblClick/OnClick.
Crear el componente es sencillo, y se puede ver código de ejemplo de cómo hacerlo en estas entradas:
La idea es que cada «acceso directo» posea un apuntador al elemento de menú correspondiente para poder ejecutar el código programado en el OnClick o en la TAction asociada a ese elemento del menú. Lo lógico sería utilizar una propiedad del propio componente (Data, Object,….) que nos permitiera enlazar directamente. No es el caso del TImage, así que en el ejemplo utilizaremos el propio ListBox como el «contenedor» de los apuntadores (como una lista intermedia), aunque como he dicho, la solución ideal, sería que cada «acceso directo» tuviera un puntero «directo» al TMenItem asociado.
El código paras crear el componente y gestionar esa asociación podría ser similar a este:
procedure TFormMain.Button2Click(Sender:TObject);var
img:TImage;
mi:TMenuItem;beginIf ListBox1.ItemIndex=-1thenbegin
MessageDlg('Selecciona un elemento de la llista', mtWarning,[mbOK],0);
Exit;end;// Item del menu
mi := TMenuItem(ListBox1.Items.Objects[ListBox1.ItemIndex]);// Tiene asignado el OnClick?ifAssigned(mi.OnClick)thenbegin// Nadaendelsebegin// Tiene asignada la action?ifAssigned(mi.Action)thenbegin//signado OnExecuteifAssigned(mi.Action.OnExecute)thenbegin// Nadaendelsebegin
MessageDlg('Ese elemento no tiene nada que hacer asignado',
mtWarning,[mbOK],0);
Exit;end;endelsebegin
MessageDlg('Ese elemento no tiene nada que hacer asignado',
mtWarning,[mbOK],0);
Exit;end;end;
Randomize;// Elemento seleccionado
img := TImage.Create(nil);
img.Parent:= Panel1;
img.Height:=32;
img.Width:=32;
img.Left:=Random(panel1.Width- img.Width);
img.Top:=Random(panel1.Height- img.Height);
img.Stretch:=True;
img.Transparent:=True;// El TAG es la posicion en la lista
img.Tag:= ListBox1.ItemIndex;// Item del menu
mi := TMenuItem(ListBox1.Items.Objects[ListBox1.ItemIndex]);// Asignar la imagen
ImageList1.GetBitmap(mi.ImageIndex, img.Picture.Bitmap);// Asignar el evento
img.OnClick:= MyImgClick;end;
procedure TFormMain.Button2Click(Sender: TObject);
var
img:TImage;
mi:TMenuItem;
begin
If ListBox1.ItemIndex = -1 then begin
MessageDlg('Selecciona un elemento de la llista', mtWarning, [mbOK], 0);
Exit;
end;
// Item del menu
mi := TMenuItem(ListBox1.Items.Objects[ListBox1.ItemIndex]);
// Tiene asignado el OnClick?
if Assigned(mi.OnClick) then begin
// Nada
end
else begin
// Tiene asignada la action?
if Assigned(mi.Action) then begin
//signado OnExecute
if Assigned(mi.Action.OnExecute) then begin
// Nada
end
else begin
MessageDlg('Ese elemento no tiene nada que hacer asignado',
mtWarning, [mbOK], 0);
Exit;
end;
end
else begin
MessageDlg('Ese elemento no tiene nada que hacer asignado',
mtWarning, [mbOK], 0);
Exit;
end;
end;
Randomize;
// Elemento seleccionado
img := TImage.Create(nil);
img.Parent := Panel1;
img.Height := 32;
img.Width := 32;
img.Left := Random(panel1.Width - img.Width);
img.Top := Random(panel1.Height - img.Height);
img.Stretch := True;
img.Transparent := True;
// El TAG es la posicion en la lista
img.Tag := ListBox1.ItemIndex;
// Item del menu
mi := TMenuItem(ListBox1.Items.Objects[ListBox1.ItemIndex]);
// Asignar la imagen
ImageList1.GetBitmap(mi.ImageIndex, img.Picture.Bitmap);
// Asignar el evento
img.OnClick := MyImgClick;
end;
Primero se realizan unas comprobaciones para detectar si posee alguna acción asignada (sea OnClick o TAction) y posteriormente se crea el TImage, se configura y se asigna como TAG el ItemIndex del ListBox (que es este caso estamos utilizando como estructura intermedia para guardar el apuntador al TMenuItem).
Finalmente sólo quedar crear el procedimiento MyImgClick, que ejecutará el código asignado al elemento del menú cuando se presione sobre la imagen asociada. Se incluyen comprobaciones similares a las anteriores, por si el elemento no tiene nada asignado y se tiene en cuenta también que haya código en el OnClick del TMenuItem o exista una TAction asociada.
var
i:integer;
str:string;
mi:TMenuItem;begin// Test del senderifnot(sender is TImage)thenbegin
Exit;endelsebegin
i := TImage(Sender).Tag;
Str := ListBox1.Items[i];end;// Acceder a la opción de menú
mi := TMenuItem(ListBox1.Items.Objects[i]);// Asignado código?ifAssigned(mi.OnClick)thenbegin
mi.OnClick(nil);
Exit;endelsebegin// Tiene asignada la action?ifAssigned(mi.Action)thenbegin// Asignado OnExecuteifAssigned(mi.Action.OnExecute)thenbegin
mi.Action.OnExecute(nil);
Exit;end;endend;
MessageDlg('No hay nada asignado a esa opción...', mtInformation,[mbOK],0);end;
var
i:integer;
str:string;
mi:TMenuItem;
begin
// Test del sender
if not (sender is TImage) then begin
Exit;
end
else begin
i := TImage(Sender).Tag;
Str := ListBox1.Items[i];
end;
// Acceder a la opción de menú
mi := TMenuItem(ListBox1.Items.Objects[i]);
// Asignado código?
if Assigned(mi.OnClick) then begin
mi.OnClick(nil);
Exit;
end
else begin
// Tiene asignada la action?
if Assigned(mi.Action) then begin
// Asignado OnExecute
if Assigned(mi.Action.OnExecute) then begin
mi.Action.OnExecute(nil);
Exit;
end;
end
end;
MessageDlg('No hay nada asignado a esa opción...', mtInformation, [mbOK], 0);
end;
Se puede mejorar y «refinar» bastante más, pero creo que la idea queda clara. A partir de aquí cada uno que «añada» lo que quiera. Cualquier sugerencia será bien recibida.
Los threads (o hilos de ejecución), en general, se ven como un tema peliaudo; Son unas «cosas» que están ahí, son buenas (eso dice todo el mundo), pero cuando más se tarde en tener que tacarlos, mejor… ;-D
Recuerdo que cuando empecé en esto de la programación, los threads o la «programación con múltiples hilos de ejecución» sonaba algo así como «muy difícil». A medida que va pasando el tiempo, uno se da cuenta que que no es así, y cuando has hecho unos cuantos ejemplos te das cuenta de la potencia que aportan y de que realmente sólo hay que tener algunas «precauciones» a la hora de utilizarlos.
En este misma página podéis encontrar algunos ejemplos («ping usando threads», Ejemplo visual y Ejemplo visual ampliado) de programación de hilos de ejecución con Delphi. Ejemplos bastantes sencillos y bastante inútiles, porqué no decirlo, exceptuando la utilidad de aprender cómo funcionan y poder ver un código simple de utilización.
La idea de esta entrada es ir un poco más allá. A veces nos encontramos en una aplicación, con determinadas consultas que tardan mucho tiempo y que no es imprescindible esperar a su finalización para poder continuar con la ejecución normal del programa. Las más comunes serías típicas consultas de Listados, estadísticas o determinadas operaciones que podríamos hacer en 2º plano. Esas consultas serían las candidatas ideales para poder lanzarlas en un Thread independiente del hilo principal del programa.
Para los ejemplos voy a utilizar los componentes ADO y accederemos a la Base de Datos dbdemos.mdb que viene con Delphi.
Para trabajar con ADO utilizando threads, o para lanzar consultas dentro de threads, la única condición es que la conexión (TADOConnection) se cree dentro del mismo thread. Utilizaremos para ello una «cadena de conexión» como propiedad del Thread.
Para lanzar desde una aplicación una consulta utilizando nuestra clase TADOSQLThread , debería bastar con asignar la conexión, la cadena SQL, lanzar nuestro thread y esperar a que acabe. El código podría ser este:
//crear el Thread; Pasamos los parámetros de conexión y SQL
th := TADOSQLThread.Create(True, AConnection, ASQL);// Evento finalizacion; Al finalizar el control me llegará hasta este evento.
th.OnTerminate:= TerminateThread;// Ejecutarlo (ponerlo en marcha)
th.Resume;
//crear el Thread; Pasamos los parámetros de conexión y SQL
th := TADOSQLThread.Create(True, AConnection, ASQL);
// Evento finalizacion; Al finalizar el control me llegará hasta este evento.
th.OnTerminate := TerminateThread;
// Ejecutarlo (ponerlo en marcha)
th.Resume;
El código operativo del thread es sencillo, se encuentra en el método Execute y lo único que hace es ejecutar la consulta; En el constructor cremos la nueva Query (con una nueva conexión) y asignamos la SQL.
constructor TADOSQLThread.Create(CreateSuspended:Boolean;
AConnString:String; ASQL:string);begin// Creamos el thread inicialmente suspendido (para asignarle las props.)inherited Create(CreateSuspended);// No liberar automáticamenteSelf.FreeOnTerminate:=False;//crea el query
FADOQ := TAdoquery.Create(nil);
FADOQ.ConnectionString:= AConnString;
FADOQ.SQL.Add(ASQL);Self.FSQL:= ASQL;end;procedure TADOSQLThread.Execute();begininherited;// Ejecutar la consultaSelf.FADOQ.Open;end;
constructor TADOSQLThread.Create(CreateSuspended:Boolean;
AConnString:String; ASQL:string);
begin
// Creamos el thread inicialmente suspendido (para asignarle las props.)
inherited Create(CreateSuspended);
// No liberar automáticamente
Self.FreeOnTerminate := False;
//crea el query
FADOQ := TAdoquery.Create(nil);
FADOQ.ConnectionString := AConnString;
FADOQ.SQL.Add(ASQL);
Self.FSQL:= ASQL;
end;
procedure TADOSQLThread.Execute();
begin
inherited;
// Ejecutar la consulta
Self.FADOQ.Open;
end;
Ahora haría falta probar si en la ejecución de una serie de sentencia SQL con y sin threads se aprecian diferencias visibles. Hay que tener en cuenta que el utilizar o no threads también implica otras cosas.
No todo en este escenario son ventajas, hay que tenerlo en cuenta y entender el funcionamiento para sopesar si en cada caso concreto es beneficioso utilizar threads. Hay 2 grandes inconvenientes que a priori se detectan fácilmente cuando se ejecuta y se prueba un ejemplo como el que vamos a realizar.
Gasto de conexiones: En una ejecución normal, las consultas que se lanzan utilizan todas la misma conexión (ADOConnection); Una premisa que hemos marcado para trabajar con threads, es que cada thread debe funcionar con su conexión propia. Esto implica que en un caso estamos utilizando una única conexión y en el otro X conexiones concurrentes. Esto puede ser un problema en segun qué sistemas.
Sobrecarga de tiempo: El segundo problema (derivado en cierta manera del primero) es la sobrecarga de tiempo que la creación y activación de las nuevas conexiones provoca. Crear, activar (sobre todo este) y liberar las conexiones de cada thread es un tiempo añadido que hay que tener en cuenta.
Estos 2 problemas no se puede solucionar (del todo), pero sí mitigar utilizando un «pool de conexiones«; No es un tema para desarrollar ahora (tal vez más adelante), pero la idea explicada de forma sencilla, es que podemos utilizar un número máximo de conexiones (no tantas como threads). De esta forma, se asigna una conexión libre a un thread cuando la necesita, mientras haya conexiones libres; Cuando ya no quedan libres, el thread debe esperar a que una finalice para que le sea asignada. De esta forma podemos fijar el número máximo de conexiones que se utilizan y además optimizar tiempo, ya que esas conexiones se pueden «reaprovechar» de forma que no exista la necesidad de crear/activar/destruir cada una de ellas.
¿Cuando usar threads y cuando no?
La regla sencilla sería: «Cuanto más grandes y pesadas sean las consultas, más a cuenta sale utilizar threads».
Si lanzamos 20 consultas que tardan muy poco tiempo, el retraso en crear/activar las conexiones de cada una de ellas puede hacer que el tiempo de preparación sea mayor que el de la propia consulta; En ese caso estaremos «gastando» mas tiempo en «preparar» que en «consultar. Por el contrario si esas 20 consultas tardan 30 segundos cada una, el tiempo de extra de conectar para cada una de ellas puede pasar desapercibido (cuando mayor sea el tiempo de consulta, más eficiente este sistema).
Resultado de las pruebas
En las pruebas he lanzado una serie de consultas de forma secuencial. Hay que notar que el tiempo total (para consultas grandes) es sensiblemente menos cuando utilizamos threads; Pero no sólo hay que tener en cuenta el tiempo total, sino el intervalo en que tenemos acceso al resultado de cada consulta.
De forma secuencial, si la primera consulta tarda 10, la segunda 5 y la tercera 7; El tiempo total es de 22, pero los tiempos de acceso a los resultados son 10, 15 y 22 segundos respectívamente; En cambio si esto se hiciera con threads, aun suponiendo que el tiempo total fuera el mismo, los tiempo de acceso a los resultados serían 10, 5 y 7 segundos.
Select * from CustomerSelect * from Employee
Select * from CountrySelect * from items
Select * from Parts
Select * from VendorsSELECT employee.* FROM employee ORDER BY Salary,
LastName DESC , FirstName DESC , HireDate DESC
SELECT employee.* FROM employee ORDER BY Salary DESC
SELECT customer.*, orders.*, items.*, parts.*, vendors.*,
vendors.State, items.Discount, orders.SaleDate, *
FROM vendors INNER JOIN (parts INNER JOIN ((customer INNER JOIN orders
ON customer.CustNo = orders.CustNo)
INNER JOIN items ON orders.OrderNo = items.OrderNo)
ON parts.PartNo = items.PartNo)
ON vendors.VendorNo = parts.VendorNo
ORDER BY vendors.State, items.Discount DESC , orders.SaleDate
La primera prueba consta de una serie de consultas que tardan muy poco tiempo, con la Base de Datos de Access DBDEMOS.MDB (que se adjunta con Delphi). En este caso se puede ver que los tiempos de las consultas individuales son sensíblemente más bajos sin threads que con threads, debido a que las consultas con threads incluyen el tiempo de conexión. Finalmente aunque los tiempos individuales son mayores (con threads) el tiempo total queda bastante igualado (se compensa la ejecución con threads con la pérdida en las conexiones).
DATOS SIN THREADS.
DATOS CON THREADS
¿Qué pasaría si lanzáramos algunas consultas que tarden más tiempo?
Para el ejemplo he utilizado datos propios conectando a SQL Server, ya que los de la Base de Datos DBDEMOS sólo nos sirven para realizar pequeñas pruebas. Os animo a que cambieis la conexión ADO que viene en el ejemplo y configuréis vuestra propia conexión y vuestras propias consultas para realizar las pruebas.
Para la conexión basta con pulsar el botón que aparece en la parte derecha de la conexión:
Y para las consultas, basta con tener la precaución de colocar el caracter @ al inicio de cada una de las SQL (sólo cuando empieza la consulta, no en el salto de línea).
En este caso, vemos que los resultados sí cambian sensiblemente; Lo primero que nos llama la atención, es la diferencia de tiempo total de la serie de consultas (con y sin threads); He realizado unas cuantas ejecuciones, alternando primero unas y luegos las otras y los resultados de tiempos son estos; Los primeros son las consultas normales y los segundos con threads:
Sin threads:
·············································
Tiempo total(todo): 01:19:359
Tiempo total(todo): 01:18:516
Tiempo total(todo): 01:04:500
Tiempo total(todo): 01:08:969
Tiempo total(todo): 01:09:718
·············································
Con threads:
·············································
Tiempo total con threads(todo): 01:00:000
Tiempo total con threads(todo): 00:46:800
Tiempo total con threads(todo): 00:45:484
Tiempo total con threads(todo): 00:53:078
·············································
Posteriormente he lanzado, para variar, 4 ejecuciones concurrentes de ejemplo; 2 con threads y 2 sin threads y el resultado ha sido similar (en cuanto a la diferencia):
·············································
Tiempo total(todo): 01:48:984
Tiempo total(todo): 01:50:860
·············································
·············································
Tiempo total con threads(todo): 01:27:593
Tiempo total con threads(todo): 01:32:860
·············································
CONCLUSIÓN: Aunque el ejemplo es bastante sencillo, y la clase que implementa los threads tiene poca «chicha» yo creo que se ven las posibilidades de utilizar esta opción. También debe quedar claro que no es algo para usar «siempre»; Hemos visto que dependiendo del escenario donde se utiliza puede resultar inútil e incluso contraproducente, ya que gasta más recursos que la técnica sin threads. Como ventaja tenemos que la utilización de threads, en general, nos aporta paralelismo y mayor control en la ejecución del programa (ya que evitamos el «bloqueo» en el caso de una consulta muy costosa).
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.
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) .
Otras ventanas de la aplicación (principal de Datos, Gráfico, Google Maps, Perfil, IBPIndex,…)
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 deseas añadir y cooperar en el desarrollo de la aplicación con nuevos idiomas, puedes hacerlo con unos sencillos pasos:
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,…).
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 (& *|* ).
Envíamelo a la dirección <german_ral[ARROBA]hotmail.com> con tus datos.
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).
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.