Showing posts with label Open Source. Show all posts
Showing posts with label Open Source. Show all posts

Sunday, 6 September 2015

jqplot integration with ASP.NET MVC

I haven't been writing for a while and it's not always easy to find time to write about interesting stuff. I must say that I wish I had enough time to post all what I have been learning for the last past years, but I will try to keep it up. Today I'm bringing you an interesting post about jqplot integration with ASP.net MVC. I have been using ASP.NET for quite a while now (more than 5 years) and I hope this post could help you with the integration of jqplot as I faced some challenges that I'm resolving here.

jqplot is a plotting and charting plugin for the jQuery Javascript framework. It's very pluggable and really easy to use.

jqplot can be easily installed using Nuget package from VS:

Here is a simple example from the website:




As you could see, integration is quite simple and to plot the data, this one needs to be formatted in the format of a set [Date, value] to be displayed correctly. So here is the first challenge as we need to find a way to populate this list from our controller and then pass the correct formatted list to our jqplot function.

I'm working on an application called Flickr Photo Analytics. This application is able to connect to your Flickr stream and retrieve some useful stats that you can keep track overtime. The base application is written in Delphi and now I'm developing the web interface that goes with it using ASP.net MVC. For this article I will use the examples from my source repository.

The best way to approach this problem is by creating a new ActionResult in the controller that will build the relevant data (data that we want to display and in the correct format -> [Date and Value]). Then via javascript, I will use an AJAX (Asynchronous JavaScript and XML) call to call the action method from the controller and retrieve the data in JSON format. One the data is back, I will generate the list in the correct format so jqplot can plot the data.

Here is the code from my controller:



This code loads an xml file containing some relevant data from my application and according to an id that can be passed as an argument in the url, it will return a different JSON list.


The view only needs a div with an id, in this case, chart1 that will be automatically populated with a graph by jqplot once the following javascript is loaded:


The javascript will receive the results from the JSON call in a stats variable. Once we get the whole content of the variable, we need to build the correct array that will go into jqplot. This will be done using: arr.push([new Date(date), value]):



The html is as follows (view):

Loaded units required for jqplot and the div required to display the chart.


And the final result can be seen here:

Check out the properties that I have enabled for jqplot as I've use it for quite a while and I like the way I can configure it.

Any questions, please ask!.

Jordi.

Saturday, 14 March 2015

Projects moved to Github

As you might be aware, Google Code Project Hosting is about to shut down so I have decided to move all my projects to GitHub as it was one of the options Google was offering. So here you have all my Delphi Open source projects for your entertainment. Most of them are already finished and not much is going on, but they are good for reference. Some of my active projects are already on GitHub and I do really like the platform:

Open Source Projects:
Projects that were already in Github:

I need to add the documentation, but I will be doing it over these weeks.
Jordi

Friday, 30 April 2010

Improving your monitoring applications with Gnuplot

Why bother about building a plotting component when you could use a very good one from a third-party? That's what I thought while I was trying to build a plotting component for monitoring my applications. Then I remembered when I was doing some practices with Octave at college and when I was playing with it I thought that it was a very good application.
Afterwards I modified my log and monitoring files for adapting them to gnuplot, a portable command-line driven graphing utility for linux, OS/2, MS Windows, OSX, VMS, and many other platforms. With this, you only need to focus on writing the log files, and let gnuplot draw your files in nice plotting windows with a lot of powerful features like moving axes, changing the view, etc.
With simple commands like these:

C:\>gnuplot         G N U P L O T         Version 4.4 patchlevel 0         last modified March 2010         System: MS-Windows 32 bit         Copyright (C) 1986-1993, 1998, 2004, 2007-2010         Thomas Williams, Colin Kelley and many others         gnuplot home:     http://www.gnuplot.info         faq, bugs, etc:   type "help seeking-assistance"         immediate help:   type "help"         plot window:      hit 'h' Terminal type set to 'wxt' gnuplot> set isosample 40 gnuplot> set ticslevel 0 gnuplot> splot (x**2)*(y**2)
we can draw amazing plots like this:

And even better, if for example we are monitoring our cpu, then we can plot the results:


Now, you only need to know how the command line works and use it in your applications. I'm sure you'll enjoy it, and the best part is that you can save time.

Related Articles:

Wednesday, 9 December 2009

Force Directed Graphs part II

AquĂ­ os dejo un enlace muy interesante sobre un motor creado en javascript que permite ordenar los diagramas utilizando Force-Directed. El trabajo realizado por Kyle Scholz es increĂ­ble. Mucha gente estĂ¡ utilizando su algoritmo para crear diversas estructuras dinĂ¡micas vĂ­a Web.

La utilizaciĂ³n de su motor es bastante sencillo y con solo importar sus librerĂ­as ya podemos empezar a crear los diagramas a travĂ©s de cĂ³digo javascript.

En el siguiente enlace podemos encontrar la informaciĂ³n necesaria para crear los diagramas. AdemĂ¡s os dejo un enlace para que podĂ¡is ver un ejemplo online.

Os recomiendo mirar su proyecto WordNet que implementa su motor Force-Directed. No tiene desperdicio:


Processing 1.0

Continuando con el tema del dĂ­a, he encontrado una aplicaciĂ³n muy interesante para el procesado de imĂ¡genes. Ésta aplicaciĂ³n Open Source llamada Processing 1.0 permite a travĂ©s de cĂ³digo similar al java crear diversas aplicaciones donde la parte grĂ¡fica ya estĂ¡ implementada y solo nos tenemos que preocupar del cĂ³digo. Creo que es bastante interesante para estudios cientĂ­ficos ya que permite a la persona que estĂ¡ al otro lado centrarse en la parte importante del algoritmo sin tener que preocuparse de los diferentes eventos que pueden aparecer en una aplicaciĂ³n grĂ¡fica. Aunque la aplicaciĂ³n pesa unos 70 Mb (la versiĂ³n para windows), dispone de muchos ejemplos y documentaciĂ³n para empezar a generar diagramas y tratar imĂ¡genes fĂ¡cilmente.

AdemĂ¡s el IDE es bastante amigable con una codificaciĂ³n como la de java y un cĂ³digo exportable.

En la misma web del autor (Ben Fry y Casey Reas) encontraremos mucha informaciĂ³n sobre Ă©ste lenguaje de programaciĂ³n para un contexto visual.

DOT Language

Investigando un poco por la red (haciendo trabajo de campo) he encontrado varias librerĂ­as relacionadas con el tema de grafos. Ya que estoy desarrollando una herramienta que generarĂ¡ grafos (dirigidos - no dirigidos) y que ademĂ¡s implementarĂ¡ un algoritmo para la bĂºsqueda de caminos, pues no estĂ¡ nada mal lo que ya hay por la red y que me resulta tan interesante. Ahora que ya tengo bastante avanzado el proyecto VLO (a ver si en un par de semanas lo avanzo un poco mĂ¡s y os muestro en lo que he estado trabajando recientemente) ahora estoy intentando reordenar los grafos aplicando algoritmos de dibujado Force-Directed. Éstos permiten posicionar los nodos de una manera mĂ¡s elegante asignado propiedades fĂ­sicas a cada uno de Ă©stos.

Utilizando éstos Algoritmos llamados Force-based o Force-Directed podremos generar diagramas tan espectaculares como los siguientes:



Éstos diagramas los he sacado de aiSee graph Visualization, donde podemos encontrar muchos ejemplos sobre diferentes diagramas.

Como indica el tĂ­tulo del artĂ­culo, aquĂ­ os comentarĂ© un poco el lenguaje DOT. Éste lenguaje es del tipo plano donde aplicando un pequeño trozo de cĂ³digo, podemos llegar a crear diagramas sin tener que preocuparnos de su dibujado.

Por ejemplo el siguiente script:


digraph if {
graph [rankdir=LR];
node [label="\N"];
graph [bb="0,0,218,108"];
{
graph [rank=same,
bb=""];
b [pos="119,18", width="0.75", height="0.5"];
c [pos="119,90", width="0.75", height="0.5"];
}
a [pos="27,18", width="0.75", height="0.5"];
a -> b [pos="e,91.77,18 54.105,18 62.732,18 72.431,18 81.65,18"];
c -> b [label="long long long", pos="s,119,71.831 119,36.413 119,44.059 119,53.108 119,61.573", lp="168.5,54"];
}


crea el siguiente grafo en un servicio online utilizando el lenguaje DOT.

Es bastante interesante ya que podemos tener herramientas que generen éstos pequeños scripts y luego instalar un servicio de renderizado de grafos y ver el resultado en una imagen.

Podemos encontrar librerĂ­as para diferentes SO que utilizan Ă©ste lenguaje. Una de Ă©stas es Graphviz (Graphic visualization Software) un paquete Open Source que contiene una serie de librerĂ­as para la visualizaciĂ³n y generaciĂ³n de grafos. He encontrado varias aplicaciones por la red que utilizan Ă©sta librerĂ­a y querĂ­a indagar un poco mĂ¡s sobre Ă©ste tema.

En la web de Graphviz podrĂ©is encontrar la Ăºltima versiĂ³n estable del paquete e incluso el cĂ³digo fuente para ver los diferentes algoritmos que utilizan.

Si miramos en la galerĂ­a de imĂ¡genes podemos encontrar grafos con una estĂ©tica muy buena:

AdemĂ¡s recomiendo la lectura de los diferentes documentos de ayuda que contienen referĂ©ncias muy buenas a diferente bibliografĂ­a relacionada con el tema de los grafos. Uno de los libros que yo recomiendo es el siguiente:
Thomas M. J. Fruchterman and Edward M. Reingold. Graph Drawing by Force- directed Placement. Software– Practice and Experience, 21(11):1129–1164, November 1991
Dentro de la propia arquitectura del Graphviz, podemos encontrar las diferentes aplicaciones que modelan los grafos y los posicionan en funciĂ³n del algoritmo seleccionado. En su caso, dispone de los programas NEATO, TWOPI, CIRCO, FDP, DOTTY y LEFTY. Cada uno de Ă©stos tiene un tipo de posicionamiento diferente, ordenando los diagramas en formas circulares, de redes, etc. Todo para que el dibujo final sea mucho mĂ¡s inteligible.

AdemĂ¡s desde la pĂ¡gina principal de Graphviz, encontramos WebDot, un servicio web que nos permite generar diagramas utilizando el lenguaje DOT y que nos devuelve el resultado en HTML.

Es increĂ­ble el trabajo realizado por todas las personas involucradas en el proyecto, la verdad es que me ha gustado mucho y sobretodo por la informaciĂ³n y documentaciĂ³n que hay. Podemos aprender mucho de ellos y sobretodo consultar la bibliografĂ­a recomendada para poder introducirnos un poco mĂ¡s sobre la teorĂ­a de grafos. TambiĂ©n os recomiendo ver el siguiente vĂ­deo que muestra grĂ¡ficamente como funciona un algoritmo de Ă©ste tipo.

PodrĂ­a hacer el artĂ­culo mucho mĂ¡s extenso, pero prefiero dejarlo aquĂ­ y si querĂ©is indagar un poco mĂ¡s, os dejo una serie de enlaces de interĂ©s muy interesantes desde donde poder continuar con la investigaciĂ³n.

Espero que os hay entretenido la lectura, y espero vuestros comentarios!.

  • Enlaces de interĂ©s:
OmniGraffle.
vizierfx a Flex Library for GraphViz rendering.
aiSee graph visualization.
force-directed node interface.
Webdot demo graphs.
DOT Tutorial.
Force directed layouts.
Force directed Algorithm (Spring Algorithm).
aiSee graph gallery.
Visual Complexity.
more Force Directed in google.

Wednesday, 11 November 2009

Editor de Ecuaciones LaTeX

LaTex es un sistema Open Source de composiciĂ³n de texto especĂ­ficamente para documentos con ecuaciones matemĂ¡ticas. Con Ă©sta herramienta del tipo WYSIWYM (What You See Is What You Mean) podremos crear ecuaciones grĂ¡ficamente utilizando un lenguaje de macros. Para que nos entendamos, en el siguiente enlace aparece una aplicaciĂ³n Online donde probar nuestras macros y obtener la imagen de la fĂ³rmula:

AdemĂ¡s existen bastantes plataformas que utilizan LaTeX para crear editores ya sea para Windows como para Linux. Una de las aplicaciones que utilizo yo para crear documentaciĂ³n tĂ©cnica es Lyx, un editor para windows muy potente que utiliza LaTeX.

Aunque la aplicaciĂ³n ocupa mĂ¡s de 100 Mb, podemos encontrar descargar la Ăºltima versiĂ³n de la aplicaciĂ³n para windows desde aquĂ­. TambiĂ©n podemos encontrarla para diferentes plataformas en la pĂ¡gina de las descargas.

Monday, 9 November 2009

Plataforma de desarrollo : VLO Framework parte III

Ahora que tengo un poco mĂ¡s avanzada la parte del cĂ¡lculo de rutas ya puedo entretenerme un poco mĂ¡s con el diseño del canvas para mejorar un poco el comportamiento del dibujado de los diferentes elementos que forman VLO Framework. En Ă©sta Ăºltima versiĂ³n he incorporado cosas importantes como:
  • una grid de fondo
  • la acciĂ³n snap to grid
  • la ediciĂ³n de lĂ­neas por 3 puntos
  • la mĂºltiple selecciĂ³n de cajas
  • el movimiento global de las cajas con la mĂºlti selecciĂ³n
  • el Conexionado de boxes de origen a destino y viceversa (en versiones anteriores, solo se permitĂ­a una conexiĂ³n)
De Ă©sta manera la aplicaciĂ³n se muestra de la siguiente forma:


Ahora, importando imĂ¡genes, podemos realizar diagramas tĂ­picos como los siguientes:

Utilizando la herramienta de selecciĂ³n, podemos seleccionar todos los componentes Tbox y moverlos utilizando el mouse:


Lo interesante de la plataforma es que la podemos utilizar para dibujar aquello que queramos (imĂ¡genes enlazadas) y luego utilizar Ă©stos componentes visuales para modelar aquello que queremos programar. Por ejemplo el siguiente paso serĂ¡ crear un comprobador de DFA (Deterministic finite machine), y a partir de ahĂ­ cualquier cosa que se nos ocurra grĂ¡ficamente. De Ă©sta manera podemos llegar a mejorar bastante la ilustraciĂ³n de nuestros modelos, por ejemplo en uno de mis anteriores diagramas sobre el cĂ¡lculo de rutas, ahora tendrĂ­amos Ă©sto:


Aquí os dejo una muestra del test del framework para que comprobéis su comportamiento:

Friday, 6 November 2009

VLO framework on SourceForge

Ya podĂ©is encontrar la Ăºltima versiĂ³n de mi framework (VLO) en SourceForge. AĂºn estoy ultimando detalles, pero podrĂ©is encontrar el Ăºltimo ejecutable en descarga libre desde el siguiente enlace: vloframework.sourceforge.net.

Desde la misma web podrĂ©is descargar la aplicaciĂ³n, informar sobre errores y contactar conmigo sobre cualquier cosa referente a la aplicaciĂ³n. AĂºn estoy acabando de configurar el repositorio para poder subir el cĂ³digo fuente de la plataforma, pero en un par de dĂ­as lo tendrĂ© listo. Estoy trabajando sobre la configuraciĂ³n bĂ¡sica de la plataforma mejorando el comportamiento de los diferentes objetos visuales y pensando en las diferentes posibilidades que tiene la plataforma sobre diferentes ideas que me han expuesto y algunas otras que se me han ocurrido a mi.

Wednesday, 2 September 2009

Corrector ortogrĂ¡fico con Delphi

Buscando aplicaciones por la red, he encontrado una aplicaciĂ³n bastante interesante de la mano de Lucius Schneider llamada Speller : Spell Checker. La aplicaciĂ³n es bastante entretenida ya que el autor ha dejado todo el cĂ³digo fuente y podemos instalarnos sus componentes para utilizar el corrector ortogrĂ¡fico de Microsoft Office. En la pĂ¡gina web oficial, podremos encontrar mucha mĂ¡s informaciĂ³n sobre Ă©stos componentes. AdemĂ¡s os recomiendo pasar por sus otras aplicaciones ya que no tienen ningĂºn desperdicio. He probado de compilar la aplicaciĂ³n con Delphi 2007 y 2009 y no ha dado ningĂºn problema. Una vez instalados los componentes TSpellChecker y TSpellLanguageComboBox, ya los podemos utilizar para corregir el texto que nosotros queramos.

La instalaciĂ³n como siempre es bastante sencilla, y en muchos de mis artĂ­culos lo he comentado con detalle. Solo tenemos que abrir los .bpl (Borland Package Library), compilar, Buildear e Instalar. Luego cargamos el path donde se encuentran los .dcu dentro de tools -> Options-> Library - win32.

Una vez tenemos los componentes, iniciamos la aplicaciĂ³n y le damos a corregir un texto de los nuestros:


Ahora podemos crear aplicaciones que dispongan de corrector ortogrĂ¡fico y que ademĂ¡s utilicen el corrector instalado en nuestro Office o crear el nuestro propio.

Tuesday, 18 August 2009

Formateando cĂ³digo Delphi.

Mientras espero la Ăºltima versiĂ³n de Delphi 2010 suelo utilizar el componente Delphi Formatter de DelForExp para el IDE de Delphi. Aunque es de pago funciona bastante bien, porquĂ© estĂ¡ integrado dentro del mismo IDE y con un par de teclas se formatea el cĂ³digo para que quede mĂ¡s bonito y entendible. Muchas veces si no tengo el IDE a mano, utilizo una aplicaciĂ³n Open Source llamada Jedi Code Format, que permite coger los ficheros .pas y formatearlos. AdemĂ¡s podemos configurar todas las opciones que queramos para que el formato se ajuste a lo que nosotros queremos.


Con Ă©sta aplicaciĂ³n podremos formatear nuestro cĂ³digo rĂ¡pidamente simplemente configurando unos cuĂ¡ntos parĂ¡metros. AquĂ­ os dejo mi fichero de configuraciĂ³n: JCFSettings.cfg, por si querĂ©is probarlo, ya que de serie viene sin configurar y es un rollo tener que configurar todos los parĂ¡metros uno por uno.

Thursday, 13 August 2009

Delphi Code to Doc

En Ă©ste post, os muestro la Ăºltima versiĂ³n de DelphiCodeToDoc que nos permite generar documentaciĂ³n tĂ©cnica de nuestro proyecto en formato .html o .chm al igual que hace JavaDoc. Mediante unas etiquetas, podemos crear diferentes descripciones para nuestros mĂ©todos y nuestras clases para que sean mucho mĂ¡s entendedoras. Una vez nos hemos decargado la Ăºltima versiĂ³n estable de la aplicaciĂ³n DelphiCodeToDoc_exe_v0.23b.zip. Una vez tenemos la Ăºltima versiĂ³n, la descomprimimos y solo consiste en ejecutar la aplicaciĂ³n y cargar nuestro proyecto. Si observĂ¡is la documentaciĂ³n de DelphiCodeToDoc, comprobarĂ©is los diferentes tags que podemos utilizar en nuestro proyecto para que luego aparezcan en la ayuda.
Para Ă©ste ejemplo, utilizarĂ© una de mis aplicaciones para generar la documentaciĂ³n. Aunque no he preparado ningĂºn tag de descripciĂ³n, podrĂ©is ver el formato final de la documentaciĂ³n, que no tiene desperdĂ­cio.

Ahora, solo tenemos que ejecutar la aplicaciĂ³n DelphiCodeToDoc.exe y llamar al wizard project, desde File -> New Quick Wizard Project. Ahora cargamos los ficheros que nos pide:

Ahora continuamos con la carga de nuestro proyecto, configurando una serie de opciones antes de generar la documentaciĂ³n:

Ahora nos dirigimos a project -> check and build y voilĂ !, ya tenemos generada la documentaciĂ³n de nuestro proyecto.

AquĂ­ os dejo el documento para que lo podĂ¡is descargar y visualizar, para ver el resultado final Thundax Geometry Link.chm.


Wednesday, 12 August 2009

R2build - Herramienta para la automatizaciĂ³n de ensamblados diarios

R2build es un framework o herramienta Open Source para crear ensamblados diarios o builds de una manera muy sencilla. Permite enviar notificaciones por email, FTP, y dispone de varias herramientas de empaquetado de instalaciones, ademĂ¡s funciona para Java, C++, Ant, Nant,.Net, Delphi, C++ Builder, y varias herramientas de control de cĂ³digo fuente. Es muy parecido al sistema CruiseControl para java, que permite automatizar el ensamblado de aplicaciones. El proyecto CruiseControl, tambiĂ©n Open Source, mediante una serie de scripts permite que el montaje de la aplicaciĂ³n sea automĂ¡tico.

R2build, dispone de un panel de control para monitorizar los proyectos, y ademĂ¡s soporta la planificaciĂ³n de Ă©stos. En las siguientes imĂ¡genes de la web del proyecto, se pueden ver los diagramas de flujo que se generan, y ademĂ¡s permite una interacciĂ³n muy buena con Subversion. Permite la integraciĂ³n con una gran variedad de Softs de programaciĂ³n y soporta herramientas para la creaciĂ³n de los instalables como por ejemplo Inno Setup que es el que yo hago servir.

En el siguiente enlace, podrĂ©is descargaros la Ăºltima versiĂ³n estable de la aplicaciĂ³n R2build v2.1. Probadla, no tiene desperdicio!. En la web de Developpez, encontrarĂ©is un tutorial muy interesante de como hacer funcionar el R2build con Delphi para la automatizaciĂ³n de builds del proyecto.

Thursday, 6 August 2009

Manejador de excepciones avanzadas con Delphi

El otro dĂ­a comentaba con uno de los compañeros de trabajo que serĂ­a interesante poder disponer de la informaciĂ³n de la pila (Call Stack) en tiempo de ejecuciĂ³n, y poder visualizar la informaciĂ³n del error con mĂ¡s informaciĂ³n, es decir con la informaciĂ³n de la pila para saber de dĂ³nde procedĂ­a el error y asĂ­ seguirlo con facilidad. Hay que ser pragmĂ¡ticos con Ă©ste tema y evitar hacer logs inmensos de seguimiento simplemente porquĂ© no encontramos el error. De Ă©sta manera podrĂ­amos encontrar el error rĂ¡pidamente, analizando la Call Stack. Si os fijĂ¡is en la Call Stack de delphi, cuando ejecutamos una aplicaciĂ³n, y ponemos un punto de interrupciĂ³n, podemos ver por dĂ³nde va pasando el programa y los mĂ©todos que va ejecutando para llegar hasta nuestro punto de interrupciĂ³n. En la siguiente imĂ¡gen podĂ©is ver una ejecuciĂ³n simple de una aplicaciĂ³n y su paro en un break point.


Para mi ejemplo harĂ© reposting, y utilizarĂ© el ejemplo que escribiĂ³ Sergey Shirokov y Alex P en Advanced Exception Handler. En su artĂ­culo comentan concretamente lo que yo quiero obtener de la pila. Para la obtenciĂ³n de los datos avanzados, necesitarĂ© el siguiente componente: ExWatcher de la mano de Tomek Guz (Solo la versiĂ³n para Delphi 5). AdemĂ¡s utilizaremos el proyecto demo, llamado ExWatcherDemo.
  • Instalando el componente ExWatcher
Primero, lo que haremos serĂ¡ instalar el componente ExWatcher. Lo he probado con Delphi 2007 y 2009 y funciona perfectamente, sin ningĂºn problema. Descomprimimos los ficheros de ExWatcher y los ponemos en una ubicaciĂ³n tĂ­pica (dĂ³nde tengamos los diferentes componentes).

Ahora compilamos, hacemos build e Install. Una vez instalado el componente nos aparecerĂ¡ el siguiente mensaje:

Ahora una vez instalado el componente, tenemos que añadir la ruta dĂ³nde estĂ¡n los .dcu en la library path de delphi. Ésto se hace iĂ©ndo a -> Tools -> Options y en el nodo Environment Options -> Delphi Options -> Library -Win32, añadimos la ruta de la carpeta del ExWatcher en Library Path.
  • Ejecutando la demo
Ahora que ya tenemos el componente instalado, abrimos el proyecto demo ExWatcherDemo.dpr y veremos que nos aparece el componente ExWatcher.

He modificado el TMemo y lo he hecho un poco mĂ¡s grande y he modificado tambiĂ©n los colores. Ahora una vez tenemos el proyecto OK, tenemos que modificar los siguientes parĂ¡metros para su compilaciĂ³n:

Marcamos las opciones de compilaciĂ³n : Stack Frames y de Linkado : Map File -> Publics. De Ă©sta manera creamos los ficheros necesarios que nos darĂ¡n la informaciĂ³n de los valores de la pila en tiempo de ejecuciĂ³n.
  • map2dbg
Ahora ya podemos realizar la ejecuciĂ³n de nuestra aplicaciĂ³n, pero antes, tenemos que realizar una pequeña modificaciĂ³n a nuestro proyecto para que las llamadas de la Call Stack se puedan visualizar. Para ello, tenemos que utilizar la aplicaciĂ³n map2dbg de la mano de Lucian Wischik, que permite convertir los ficheros .map en ficheros .dbg. De Ă©sta manera convertimos los ficheros de debug de Delphi a ficheros que entiende windows mediante su estĂ¡ndard .dbg. Para ello, descargaremos la Ăºltima versiĂ³n de la aplicaciĂ³n de map2dbg: map2dbg v1.3.

Una vez descargada la aplicaciĂ³n, la copiamos dentro de nuestra aplicaciĂ³n demo, y ejecutamos lo siguiente desde el intĂ©rprete de comandos:

map2dbg.exe exwatcherdemo.exe

y nos aparecerĂ¡ el siguiente resultado:

converted 4150 symbols

Ahora, si ejecutamos el ejemplo y lanzamos alguna excepciĂ³n obtendremos todas las llamadas de la Call Stack en nuestro TMemo:

Como podéis ver, no tiene desperdicio. Ahora ya podemos crear aplicaciones con mayor control sobre los errores. Espero que os haya servido de ayuda!.

AquĂ­ os dejo con el proyecto de prueba que he utilizado: ExWatcherDemo Project.rar. Y el cĂ³digo fuente de la unidad principal para que veĂ¡is lo fĂ¡cil que es utilizar el componente:

unit main;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, clExWatcher, ShowExcept;

type
  TMainForm = class(TForm)
    btnDelphiException: TButton;
    btnDelphiSafeCallException: TButton;
    btnSystemException: TButton;
    clExceptWatcher: TclExceptWatcher;
    btnSystemSafeCallException: TButton;
    btnTryExcept: TButton;
    memStackLog: TMemo;
    procedure clExceptWatcherDelphiException(Sender: TObject; E: Exception;
      EI: TclExceptionInformation; StackTracer: TclStackTracer);
    procedure clExceptWatcherDelphiSafeCallException(Sender,
      Target: TObject; E: Exception; EI: TclExceptionInformation;
      StackTracer: TclStackTracer);
    procedure clExceptWatcherSystemException(Sender: TObject;
      EI: TclExceptionInformation; StackTracer: TclStackTracer);
    procedure clExceptWatcherSystemSafeCallException(Sender,
      Target: TObject; EI: TclExceptionInformation;
      var NotifyTarget: Boolean; StackTracer: TclStackTracer);
    procedure btnDelphiExceptionClick(Sender: TObject);
    procedure btnDelphiSafeCallExceptionClick(Sender: TObject);
    procedure btnSystemExceptionClick(Sender: TObject);
    procedure btnSystemSafeCallExceptionClick(Sender: TObject);
    procedure btnTryExceptClick(Sender: TObject);
    procedure FormCreate(Sender: TObject);
  private
    procedure SimulateDelphiException();
    procedure SimulateSystemException();
    procedure SimulateDelphiSafeCallException(); safecall;
    procedure SimulateSystemSafeCallException(); safecall;
    procedure ShowStack(Frames: TclStackFrames);
    procedure ExceptionHandler(Sender: TObject; E: Exception);
  end;

var
  MainForm: TMainForm;

implementation

{$R *.dfm}

procedure TMainForm.clExceptWatcherDelphiException(Sender: TObject;
  E: Exception; EI: TclExceptionInformation; StackTracer: TclStackTracer);
begin
  memStackLog.Clear();
  memStackLog.Lines.Add('Delphi Exception:');
  ShowStack(StackTracer.GetCallStack(EI));
end;

procedure TMainForm.clExceptWatcherSystemException(Sender: TObject;
  EI: TclExceptionInformation; StackTracer: TclStackTracer);
begin
  memStackLog.Clear();
  memStackLog.Lines.Add('System Exception:');
  ShowStack(StackTracer.GetCallStack(EI));
end;

procedure TMainForm.clExceptWatcherDelphiSafeCallException(Sender,
  Target: TObject; E: Exception; EI: TclExceptionInformation;
  StackTracer: TclStackTracer);
begin
  memStackLog.Clear();
  memStackLog.Lines.Add('Delphi SafeCall Exception:');
  ShowStack(StackTracer.GetCallStack(EI));
end;

procedure TMainForm.clExceptWatcherSystemSafeCallException(Sender,
  Target: TObject; EI: TclExceptionInformation; var NotifyTarget: Boolean;
  StackTracer: TclStackTracer);
begin
  memStackLog.Clear();
  memStackLog.Lines.Add('System SafeCall Exception:');
  ShowStack(StackTracer.GetCallStack(EI));
end;

procedure TMainForm.btnDelphiExceptionClick(Sender: TObject);
begin
  SimulateDelphiException();
end;

procedure TMainForm.btnSystemExceptionClick(Sender: TObject);
begin
  SimulateSystemException();
end;

procedure TMainForm.btnDelphiSafeCallExceptionClick(Sender: TObject);
begin
  SimulateDelphiSafeCallException();
end;

procedure TMainForm.btnSystemSafeCallExceptionClick(Sender: TObject);
begin
  SimulateSystemSafeCallException();
end;

procedure TMainForm.btnTryExceptClick(Sender: TObject);
begin
  try
    try
      SimulateSystemException();
    except
      raise;
    end;
  except
  end;
end;

procedure TMainForm.SimulateDelphiException;
begin
  raise Exception.Create('Test Delphi exception');
end;

procedure TMainForm.SimulateSystemException;
var
  p: PChar;
begin
  p := PChar(5);
  p^ := #9; //Access Violation here
end;

procedure TMainForm.SimulateDelphiSafeCallException;
begin
  raise Exception.Create('Test Delphi SafeCall exception');
end;

procedure TMainForm.SimulateSystemSafeCallException;
var
  p: PChar;
begin
  p := PChar(5);
  p^ := #9; //Access Violation here
end;

procedure TMainForm.ShowStack(Frames: TclStackFrames);
var
  i: Integer;
begin
  memStackLog.Lines.BeginUpdate();
  for i := 0 to Frames.Count - 1 do
  begin
    memStackLog.Lines.Add(Format('%x: %s - %s', [Integer(Frames[i].CallAddress),
      ExtractFileName(Frames[i].ModuleName), Frames[i].FunctionName]));
  end;
  memStackLog.Lines.EndUpdate();
end;

procedure TMainForm.FormCreate(Sender: TObject);
begin
  Application.OnException := ExceptionHandler;
end;

procedure TMainForm.ExceptionHandler(Sender: TObject; E: Exception);
begin
  ShowExceptionForm(E.Message);
end;

end.

  • Enlaces de interĂ©s:
Delphi Crash - Exception Handling with bug reporting.
Madshi.net.
EurekaLog.