La potencia de los ClientDataSet (III)

Después de crear la base de datos y la capa de acceso a datos dentro del DataModule vamos a crear la lógica de negocio.

Antes de seguir tenemos que hacer doble clic en los componente IBQuery de la capa de acceso a datos y pulsar la combinación de teclas CTRL + A para introducir todos los campos en el módulo de datos. Y en cada una de ellas hay que seleccionar el campo ID y quitar la propiedad Required ya que el propio motor de bases de datos va a meter el campo ID con un disparador.

Pero tenemos un problema, y es que no hemos seleccionado donde esta la base de datos. Para ello hacemos doble clic en el objeto BaseDatos situado módulo de datos AccesoDatos. Seleccionamos una base de datos Remota (Remote) con IP 127.0.0.1. Y la base de datos donde la tengamos, por ejemplo:

D:\Desarrollo\Delphi7\ClientDataSet\BaseDatos.fdb

De este modo, al hacer CTRL + A sobre las tablas conectará automáticamente sobre la base de datos para traerse los campos. No se os olvide luego desconectarla.

CREANDO LA LOGICA DE NEGOCIO

La capa de lógica de negocio también la vamos a implementar dentro de un objeto DataModule y va a constar de los siguientes componentes:


- Un DataModule llamado LogicaNegocio.

- Dos componentes DataSetProvider llamados DSPLstClientes y DSPClientes.

- Dos componentes ClientDataSet llamados TLstClientes y TClientes.

Ahora vamos a configurar cada uno de estos componentes:

- Enlazamos el DataModule LogicaNegocio con el DataModule AccesoDatos en la sección uses.

- Al componente DSPLstClientes le asignamos en su propiedad DataSet el componente AccesoDatos.LstClientes.

- Al componente DSPClientes le asignamos en su propiedad DataSet el componente AccesoDatos.Clientes.

- El componente TLstClientes lo vamos a vincular con DSPLstClientes mediante su propiedad ProviderName.

- El componente TClientes lo vamos a vincular con DSPClientes mediante su propiedad ProviderName.

- Debemos hacer doble clic en ambos ClientDataSets y pulsar la combinación de teclas CTRL + A para meter todos los campos.

CONTROLANDO EL NUMERO DE REGISTROS CARGADOS EN MEMORIA

Los componentes ClientDataSet tienen una propiedad llamada PacketRecord la cual determina cuandos registros se van a almacenar en memoria. Por defecto tiene configurado -1 lo que significa que se van a cargar todos los registros en la tabla. Como eso no me interesa en el listado general del formulario principal lo que vamos a hacer es poner esta propiedad a 100.

Por eso he ordenado la lista por el campo ID descendentemente para que se vean sólo los últimos 100 registros insertados. Una de las cosas que más me gustan de los componentes ClientDataSet es que se trae los 100 últimos registros y desconecta la tabla y la transacción quitándole trabajo al motor de bases de datos. Si el usuario que maneja el programa llega hasta el registro número 100 el propio componente conecta automáticamente con el servidor, se trae otros 100 registros y vuelve desconectar.

Lo único en lo que hay que tener cuidado es no acumular demasiados registros en memoria ya que puede relentizar el programa e incluso el sistema operativo si el PC no tiene mucha potencia.

El componente ClientDataSet llamado TClientes lo dejamos como está en -1 ya que sólo lo vamos a utilizar para dar de alta un registro o modificarlo.

ENVIANDO LAS TRANSACCIONES AL SERVIDOR

Cuando se utilizan los clásicos métodos Insert, Append, Post y Delete con los objetos de la clase TClientDataSet el resultado de las operaciones con registros no tiene lugar en la base de datos hasta que envíamos la transacción al servidor con el método ApplyUpdates.

Por ello vamos a utilizar el evento OnAfterPost para enviar la transacción al servidor en el caso que haya sucedido alguna modificación en el registro:

procedure TLogicaNegocio.TClientesAfterPost( DataSet: TDataSet );
begin
  if TClientes.ChangeCount > 0 then
  begin
    TClientes.ApplyUpdates( 0 );
    TClientes.Refresh;

    if TLstClientes.Active then
      TLstClientes.Refresh;
  end;
end;

Después de enviar la transacción hemos refrescado la tabla TClientes y también la tabla TLstClientes para que se actualicen los cambios en la rejilla. Por último, cuando en el listado de clientes se elimine un registro también hay que enviar la trasacción al servidor en su evento OnAfterDelete:

procedure TLogicaNegocio.TLstClientesAfterDelete( DataSet: TDataSet );
begin
  TLstClientes.ApplyUpdates( 0 );
end;

Con esto ya tenemos controlada la inserción, modificación y eliminación de registros hacia el motor de bases de datos.

ESTABLECIENDO REGLAS DE NEGOCIO EN NUESTRAS TABLAS

Las reglas de negocio definidas en el módulo de datos le quitan mucho trabajo al formulario que esté vinculado con la tabla. En un primer ejemplo vamos a hacer que cuando se demos de alta un cliente su importe pendiente sea cero. Esto se hace en el evento OnNewRecord del componente TClientes:

procedure TLogicaNegocio.TClientesNewRecord( DataSet: TDataSet );
begin
  TClientesIMPORTEPTE.AsFloat := 0;
end;

Otra de las malas costumbres que solemos cometer en los programas es controlar los datos que introduce o no el usuario en el registro, cuya lógica la hacemos en el formulario. Esto tiene el inconveniente en que si en otro formulario hay que acceder a la misma tabla hay que volver a controlar las acciones del usuario.

Para evitar esto, tenemos que definir también en la capa de lógica de negocio las reglas sobre las tablas y los campos, lo que se llama comunmente validación de campos. El componente ClientDataSet dispone de la propiedad Constraints donde pueden definirse tantas reglas como queramos. Para verlo con un ejemplo, vamos a hacer que el usuario no pueda guardar el cliente si no ha introducido su nombre.

Para definir una regla en un ClientDataSet hay que hacer lo siguiente (con TClientes):

- Pulsamos el botón [...] en la propiedad Constraints.

- Pulsamos el botón Add New.

- En la propiedad CustomConstraint definimos la condición de error mediante SQL:

NOMBRE IS NOT NULL

- En el campo ErrorMessage del mismo Constraint ponemos el mensaje de error:

No ha introducido el nombre del cliente

Con esta regla definida, si en cualquier parte de nuestro programa hacemos un Post de la tabla clientes y esta vacío el campo NOMBRE el programa lanzará un mensaje de error sin tener que programar nada. Antes teníamos que hacer esto en el botón Aceptar del formulario para validar los campos. Con los Constraints las validadiones las hacemos en sin tener que programar.

Ahora vamos a definir otra regla la cual establece que un cliene no puede tener un importe pendiente superior a 2000 €. Creamos un nuevo Constraint con la propiedad CustomConstrait definida con:

IMPORTEPTE <= 2000

y con la propiedad ErrorMessage que tenga:

El importe pendiente no puede ser superior a 2000 €

Se pueden definir tantas reglas como deseemos. En el próximo artículo vamos a hacer los formularios de mantenimiento de clientes.

Pruebas realizadas en Firebird 2.0 y Delphi 7.

La potencia de los ClientDataSet (II)

Después de haber creado la base de datos en Firebird 2.0 ya podemos comenzar a crear un nuevo proyecto que maneje dicha información. El objetivo del proyecto es hacer el siguiente mantenimiento de clientes:


CREANDO LA CAPA DE ACCESO A DATOS

La capa de acceso a datos encargada de conectar con Firebird va a incorporar los siguientes componentes:


- Un contenedor DataModule llamado AccesoDatos.

- Un compomente IBDatabase (pestaña Interbase) llamado BaseDatos.

- Un componente IBTransaction (pestaña Interbase) llamado Transaccion.

- Dos componentes IBQuery (pestaña Interbase) llamados LstClientes y Clientes.

Se sopone que la base de datos BASEDATOS.FDB esta al lado de nuestro ejecutable. Vamos a comenzar a configurar cada uno de estos componentes.

Hacemos doble clic sobre el componente IBDatabase y en el campo User Name le ponemos SYSDBA. En en password le ponemos masterkey:


Pulsamos OK, y después en la propiedad DefaultTransaction del componente IBDatabase seleccionamos Transaccion, desactivamos la propiedad LoginPrompt y nos aseguramos que en SQLDialect ponga un 3.

Para el componente IBTransaction llamado Transaccion seleccionaremos en su propiedad DefaultDatabase la base de datos BaseDatos.

Como nuestra intención es tener una rejilla que muestre el listado general de clientes y un formulario para dar de alta clientes, lo que vamos a hacer es crear una tabla IBQuery para la rejilla llamada LstClientes y otra tabla para el formulario del cliente llamada Clientes. Sería absurdo utilizar un mismo mantenimiento para ambos casos ya que si tenemos miles de clientes en la rejilla, el tener cargados en memoria todos los campos del cliente podría relentizar el programa.

En los componentes LstClientes y Clientes vamos a configurar también:

Database: BaseDatos
Transaction: Transaccion
UniDirectional: True

El motivo de activar el campo UniDirectional es para que el cursor SQL trabaje más rápido en el servidor ya que los componentes ClientDataSet gestionan en memoria los registros leidos anteriormente.

Como en la rejilla sólo quiero mostrar los campos ID, NOMBRE y NIF entonces en el componente LstClientes en su propiedad SQL vamos a definir:

SELECT ID,NOMBRE,NIF FROM CLIENTES
ORDER BY ID DESC

y para el componente Clientes:

SELECT * FROM CLIENTES
WHERE ID=:ID

En la condición WHERE de la SQL hemos añadido el parámetro :ID para que se pueda más adelante acceder directamente a un registro en concreto a partir de su campo ID.

Una vez definida nuestra capa de acceso a datos en el siguiente artículo nos encargaremos de definir nuestra lógica de negocio.

Pruebas realizadas en Firebird 2.0 y Delphi 7.

La potencia de los ClientDataSet (I)

El mundo de la programación de bases de datos cambia tan rápidamente que casi no nos da tiempo a asimilar los nuevos protocolos. Comenzamos con DBase, Clipper, FoxPro, .., hasta hoy en día que tenemos Microsoft SQL Server, Interbase, Firebird, etc.

Luego tenemos el maremagnum de lenguajes de programación donde cada cual se come el acceso a datos a su manera: Java con sus infinitos frameswork tales como hibernate, struts, etc., Ruby con el archiconocido Ruby On Rails que utiliza el paradigma MVC (Modelo, Vista, Controlador), Microsoft a su rollo con ADO y su plataforma Microsoft.NET. Todo eso sin contar con los potentes lenguajes script que no tienen la atención que merecen como son PHP, Ruby, Python, TCL/TK, Groovy, etc. Hasta la mismísima CodeGear nos ha sorprendido con su IDE 3rdRails para programación en Ruby On Rails.

Pero si hay algo que hace que Delphi destaque sobre el resto de entornos de programación es su acceso a múltiples motores de bases de datos utilizando una misma lógica de negocio que abstrae al programador de las rutinas a bajo nivel. En la conocida tecnología de acceso a datos llamada MIDAS.

Las primeras versiones de Delphi contaban con el veterano controlador de bases de datos BDE (Borland Database Engine) que permitía acceder a las clásicas bases de datos DBASE, PARADOX, etc. En la versión 5 de Delphi se incluyeron los componentes IBExpres (IBX) que permitían tener un acceso directo a bases de datos Interbase y Firebird. Fue a partir de Delphi 6 cuando Borland apostó por la tecnología DBExpress, un sistema rápido mediante drivers que utilizando un mismo protocolo permitía conectividad con múltiples motores de bases de datos tales como Interbase, Firebird, Oracle, MySQL, Informix, Microsoft SQL Server, etc. Incluso en su última versión (DBX4) permite acceder a su nuevo motor de bases de datos multiplataforma llamado BlackFish programado integramente en .NET y Java (anteriormente se llamaba JDataStore y estaba programado en Java).

Luego tenemos también otros componentes muy buenos de acceso a datos tales como Zeos, Interbase Objects (IBO), FIBPlus, etc. Y por supuesto el conocido protocolo de acceso a datos de Microsoft llamado ADO, siendo su última versión ADO.NET la que tiene bastantes posibilidades de convertirse en un estandar para todos los entornos Windows.

Pero si hay un componente de acceso a bases de datos en Delphi que destaque sobre todos los demás ese es el ClientDataSet. Combina la facilidad de acceso a datos a través de la clase TDataSet y la potencia de controlar automáticamente las transacciones al motor de bases de datos, las SQL de consulta, actualización y eliminación así como la conexión y desconexión de las tablas con el servidor haciendo que el programador no tenga que preocuparse de las particularidades del motor de bases de datos.

El componente de la clase TClientDataSet no conecta directamente sobre una base de datos en concreto, si no que utiliza el componente DataSetProvider que actua de intermediario haciendo de puente entre los componentes de bases de datos (IBX,IBO,etc) y nuestra tabla ClientDataSet. El componente ClientDataSet es algo así como una tabla de memoria (como la que tienen los componentes RX) que se trae y lleva datos a las tablas de la base de datos encargándose automáticamente de las transacciones.

LA ESTRUCTURA CORRECTA DE UN PROGRAMA

Para crear una buena aplicación con acceso a bases de datos hay que dividir nuestro programa en tres partes principales:

Capa de acceso a datos: se encarga de conectar con un motor de bases de datos en concreto ya sea con componentes IBX, ADO, BDE, etc.

Lógica de negocio: aquí se definen como son nuestras tablas (CLIENTES, ARTICULOS,etc), los campos que contienen así como el comportamiento al dar de alta registros, modificarlos, realización de cálculos internos, etc. Todo esto lo haremos con componentes de la clase TClientDataSet y TDataSetProvider.

Interfaz de usuario: se compone de los formularios, informes y menús de opciones que va a visualizar el usuario y que estarán internamente conectados con los ClientDataSet.

La interfaz de usuario sólo podrá acceder a la lógica de negocio y esta última sólo a la capa de acceso a datos. Así, si en un futuro queremos cambiar la interfaz de usuario (por ejemplo para Windows Vista) o el motor de base de datos no afectaría al resto de las capas del programa.

Para ello vamos a utilizar los componentes contenedores de la clase TDataModule para alojar la lógica de negocio y el acceso a datos. En nuestro ejemplo crearemos una base de datos de clientes definiendo las tres capas.

CREANDO LA BASE DE DATOS

En este ejemplo voy a crear una base de datos de clientes utilizando el motor de bases de datos Firebird 2.0 y con los componentes IBX. Las tablas las voy a crear con el programa IBExpert (http://www.ibexpert.com) cuya versión personal es gratis y muy potente. La base de datos se va a llamar BASEDATOS.FDB, pero si haceis las pruebas con Interbase entonces sería BASEDATOS.GDB. No voy a explicar aquí como funciona el programa IBExpert o IBConsole ya que hay en la red información abundate sobre ambos programas.

Creamos la tabla de clientes:

CREATE TABLE CLIENTES (
    ID          INTEGER NOT NULL,
    NOMBRE      VARCHAR(100),
    NIF         VARCHAR(15),
    DIRECCION   VARCHAR(100),
    POBLACION   VARCHAR(50),
    CP          VARCHAR(5),
    PROVINCIA   VARCHAR(50),
    IMPORTEPTE  DOUBLE PRECISION,
    PRIMARY KEY (ID)
)

Como quiero que el ID sea autonumérico voy a crear un generador:

CREATE GENERATOR IDCLIENTE

Y un disparador para que cuando demos de alta el registro rellene automáticamente el ID y autoincremente el contador del generador:

CREATE TRIGGER CONTADOR_CLIENTES FOR CLIENTES
ACTIVE BEFORE INSERT POSITION 0
AS
BEGIN
  NEW.ID = GEN_ID( IDCLIENTE, 1 );
END

NOTA IMPORTANTE: Hay algunas versiones de Delphi 7 que tienen un error en los componentes IBExpress (IBX) que hacen que los componentes ClientDataSet no funcionen correctamente. Recomiendo actualizar los componentes IBX a la versión 7.04 que podeis encontrarla en:

http://codecentral.borland.com/Item.aspx?id=18893

En el siguiente artículo comenzaremos a realizar el programa utilizando esta base de datos.

Pruebas realizadas en Firebird 2.0 y Delphi 7.

La barra de estado

Es raro encontrar una aplicación que no lleve en alguno de sus formularios la barra de estado. Hasta ahora he utilizado ejemplos sencillos de meter texto en la barra de estado de manera normal, pero el componente StatusBar permite meter múltiples paneles dentro de la barra de estado e incluso podemos cambiar el formato de la fuente en cada uno de ellos.

ESCRIBIENDO TEXTO SIMPLE

El componente de la clase TStatusBar tiene dos estados: uno para escribir texto simple en un sólo panel y otro para escribir en múltiples paneles. Supongamos que el componente de la barra de estado dentro de nuestro formulario de llama BarraEstado. Para escribir en un sólo panel se hace de la siguiente manera:

BarraEstado.SimplePanel := True;
BarraEstado.SimpleText := 'Texto de prueba';

Se puede escribir tanto texto como longitud tenga la barra de estado, o mejor dicho, tanto como sea la longitud del formulario.

ESCRIBIENDO TEXTO EN MULTIPLES PANELES

Para escribir en múltiples paneles dentro de la misma barra de estado hay que crear un panel por cada apartado. En este ejemplo voy a crear en la barra de estado tres paneles y en cada uno de ellos voy a poner un formato diferente.

begin
  BarraEstado.SimplePanel := False;
  BarraEstado.Panels.Clear;

  with BarraEstado.Panels.Add do
  begin
    Text := 'x=10';
    Width := 50;
    Style := psOwnerDraw;
    Alignment := taRightJustify;
  end;

  with BarraEstado.Panels.Add do
  begin
    Text := 'y=50';
    Width := 50;
    Style := psOwnerDraw;
    Alignment := taRightJustify;
  end;

  with BarraEstado.Panels.Add do
  begin
    Text := 'Texto seleccionado';
    Style := psText;
    Width := 50;
  end;
end;

La propiedad Style de cada panel determina si es psText o psOwnerDraw. Por defecto todos los paneles que se crean tiene el estilo psText (texto normal). Si elegimos el estilo psOwnerDraw significa que vamos a ser nosotros los encargados de dibujar el contenido del mismo. Ello se hace en el evento OnDrawPanel de la barra de estado:

procedure TFormulario.BarraEstadoDrawPanel( StatusBar: TStatusBar; Panel: TStatusPanel; const Rect: TRect );
begin
  case Panel.ID of
    0: with BarraEstado.Canvas do
       begin
         Font.Name := 'Tahoma';
         Font.Size := 10;
         Font.Style := [fsBold];
         Font.Color := clNavy;
         TextOut( Rect.Left + 2, Rect.Top, Panel.Text );
       end;

    1: with BarraEstado.Canvas do
       begin
         Font.Name := 'Tahoma';
         Font.Size := 10;
         Font.Style := [fsBold];
         Font.Color := clRed;
         TextOut( Rect.Left + 2, Rect.Top, Panel.Text );
       end;
  end;
end;

Cuando se van creando paneles dentro de una barra de estado, a cada uno de ellos se le va asignado la propiedad ID a 0, 1, 2, etc, la cual es de sólo lectura. Como puede verse en el evento OnDrawPanel si el ID es 0 lo pinto de azul y si es 1 de rojo. Pero sólo funcionará en aquellos paneles cuyo estilo sea psOwnerDraw. Quedaría de la siguiente manera:


También puede cambiarse en cada panel propiedades tales como el marco (bevel), la alineación del texto (alignment) y el ancho (width).

Esto nos permitirá informar mejor al usuario sobre el comportamiento de nuestra aplicación en tiempo real y de una manera elegante que no interfiere con el contenido del resto del formulario.

Pruebas realizadas en Delphi 7.

Creando un navegador con el componente WebBrowser

Delphi incorpora dentro de la pestaña Internet el componente de la clase TWebBrowser el cual utiliza el motor de Internet Explorer para añadir un navegador en nuestras aplicaciones.


Seguro que os preguntareis, ¿que utilidad puede tener esto si ya tengo Internet Explorer, Firefox, Opera, etc.? Pues hay ocasiones en que un cliente nos pide que ciertos usuarios sólo puedan entrar a ciertas páginas web. Por ejemplo, si un usuario está en el departamento de compras, es lógico que a donde sólo tiene que entrar es a las páginas de sus proveedores y no a otras para bajarse música MP3 a todo trapo (no os podeis imaginar la pasta que pierden las empresas por este motivo).

Entonces vamos a ver como crear un pequeño navegador con las funcionalidades mínimas.

CREANDO LA VENTANA DE NAVEGACION

Vamos a crear la siguiente ventana:


Incorpora los siguientes componentes:

- Un panel en la parte superior con su propiedad Align fijada a alTop (pegado arriba).

- Dentro del panel tenemos una etiqueta para la dirección.

- Un componente ComboBox llamado URL para la barra de direcciones.

- Tres botones para ir atrás, adelante y para detener.

- Una barra de progreso para mostrar la carga de la página web.

- Un componente WebBrower ocupando el resto del formulario mediante su propiedad Align en alClient, de tal manera que si maximizamos la ventana se respete el posicionamiento de todos los componentes.

CREANDO LAS FUNCIONES DE NAVEGACION

Una vez hecha la ventana pasemos a crear cada uno de los eventos relacionados con la navegación. Comencemos con el evento de pulsar Intro dentro de la barra de direcciones llamada URL:

procedure TFormulario.URLKeyDown( Sender: TObject; var Key: Word; Shift: TShiftState );
begin
  if key = VK_RETURN then
  begin
    WebBrowser.Navigate( URL.Text );
    URL.Items.Add( URL.Text );
  end;
end;

Si se pulsa la tecla Intro hacemos el objeto WebBrowser navegue a esa dirección. Además añadimos esa dirección a la lista de direcciones URL por la que hemos navegado para guardar un historial de las mismas.

Cuando se pulse el botón atrás en la barra de navegación hacemos lo siguiente:

procedure TFormulario.BAtrasClick( Sender: TObject );
begin
  WebBrowser.GoBack;
end;

Lo mismo cuando se pulse el botón adelante:

procedure TFormulario.BAdelanteClick( Sender: TObject );
begin
  WebBrowser.GoForward;
end;

Y también si queremos detener la navegación:

procedure TFormulario.BDetenerClick( Sender: TObject );
begin
  WebBrowser.Stop;
end;

Hasta aquí tenemos la parte básica de la navegación. Pasemos ahora a controlar el progreso de la navegación así como que el usuario sólo pueda entrar a una página en concreto.

A la barra de progreso situada a la derecha del botón BDetener la llamaremos Progreso y por defecto estará invisible. Sólo la vamos a hacer aparecer cuando comience la navegación. Eso se hace en el evento OnBeforeNavigate2:

procedure TFormulario.WebBrowserBeforeNavigate2( Sender: TObject;
  const pDisp: IDispatch; var URL, Flags, TargetFrameName, PostData,
  Headers: OleVariant; var Cancel: WordBool );
begin
  if Pos( 'terra', URL ) = 0 then
    Cancel := True;

  Progreso.Show;
end;

Aquí le hemos dicho al evento que antes de navegar si la URL de la página web no contiene la palabra terra que cancele la navegación. Así evitamos que el usuario se distraiga en otras páginas web.

En el caso de que si pueda navegar entonces mostramos la barra de progreso de la carga de la página web. Para controlar el progreso de la navegación se utiliza el evento OnProgressChange:

procedure TFormulario.WebBrowserProgressChange( Sender: TObject; Progress, ProgressMax: Integer );
begin
  Progreso.Max := ProgressMax;
  Progreso.Position := Progress;
end;

Cuando termine la navegación debemos ocultar de nuevo la barra de progreso. Eso lo hará en el evento OnDocumentComplete:

procedure TFormulario.WebBrowserDocumentComplete( Sender: TObject;
  const pDisp: IDispatch; var URL: OleVariant );
begin
  Progreso.Hide;
end;

Con esto ya tenemos un sencillo navegador que sólo accede a donde nosotros le digamos. A partir de aquí podemos ampliarle muchas más características tales como memorizar las URL favoritas, permitir visualizar a pantalla completa (FullScreen) e incluso permitir múltiples ventanas de navegación a través de pestañas (con el componente PageControl).

También se pueden bloquear ventanas emergentes utilizando el evento OnNewWindow2 evitando así las asquerosas ventanas de publicidad:

procedure TFormulario.WebBrowserNewWindow2(Sender: TObject;
  var ppDisp: IDispatch; var Cancel: WordBool);
begin
  Cancel := True;
end;

Aunque últimamente los publicistas muestran la publicidad en capas mediante hojas de estilo en cascada, teniendo que utilizar otros programas más avanzados para eliminar publicidad.

Pruebas realizadas en Delphi 7.

Mostrando datos en el componente StringGrid

Anteriormente vimos como mostrar información en un componente ListView llegando incluso a cambiar el color de filas y columnas a nuestro antojo. El único inconveniente estaba en que no se podían cambiar los títulos de las columnas, ya que venían predeterminadas por los colores de Windows.

Pues bien, el componente de la clase TStringGrid es algo más cutre que el ListView, pero permite cambiar al 100% el formato de todas las celdas. Veamos primero como meter información en el mismo. Al igual que ocurría con el ListView, todos las celdas de un componente StringGrid son de tipo string, siendo nosotros los que le tenemos que dar formato a mano.

AÑADIENDO DATOS A LA REJILLA

Vamos a crear una rejilla de datos con las siguiente columnas:

NOMBRE, APELLIDO1, APELLIDO2, NIF, IMPORTE PTE.

Cuando insertamos un componente StringGrid en el formulario nos va a poner por defecto la primera columna con celdas fijas (fixed). Vamos a fijar las siguientes propiedades:

Propiedad          Valor     Descripción
---------          -----     -----------
ColCount           5         5 columnas
RowCount           4         4 filas
FixedCols          0         0 columnas fijas
FixedRows          1         1 fila fija
DefaultRowHeight   20        altura de las filas a 20 pixels

Ahora creamos un procedimiento para completar de datos la rejilla:

procedure TFormulario.RellenarTabla;
begin
  with StringGrid do
  begin
    // Título de las columnas
    Cells[0, 0] := 'NOMBRE';
    Cells[1, 0] := 'APELLIDO1';
    Cells[2, 0] := 'APELLIDO2';
    Cells[3, 0] := 'NIF';
    Cells[4, 0] := 'IMPORTE PTE.';

    // Datos
    Cells[0, 1] := 'PABLO';
    Cells[1, 1] := 'GARCIA';
    Cells[2, 1] := 'MARTINEZ';
    Cells[3, 1] := '67348321D';
    Cells[4, 1] := '1500,36';

    // Datos
    Cells[0, 2] := 'MARIA';
    Cells[1, 2] := 'SANCHEZ';
    Cells[2, 2] := 'PALAZON';
    Cells[3, 2] := '44878234A';
    Cells[4, 2] := '635,21';

    // Datos
    Cells[0, 3] := 'CARMEN';
    Cells[1, 3] := 'PEREZ';
    Cells[2, 3] := 'GUILLEN';
    Cells[3, 3] := '76892693L';
    Cells[4, 3] := '211,66';
  end;
end;

Al ejecutar el programa puede apreciarse lo mal que quedan los datos en pantalla, sobre todo la columna del importe pendiente:


DANDO FORMATO A LAS CELDAS DE UN COMPONENTE STRINGGRIND

Lo que vamos a hacer a continuación es lo siguiente:

- La primera fila fija va a ser de color de fondo azul oscuro con fuente blanca y además el texto va a ir centrado.

- La columna del importe pendiente va a tener la fuente de color verde y va a ir alineada a la derecha.

- El resto de columnas tendrán el color de fondo blanco y el texto en negro.

Todo esto hay que hacerlo en el evento OnDrawCell del componente StringGrid:

procedure TFormulario.StringGridDrawCell( Sender: TObject; ACol,
  ARow: Integer; Rect: TRect; State: TGridDrawState );
var
  sTexto: String;           // Texto que va a imprimir en la celda actual
  Alineacion: TAlignment;   // Alineación que le vamos a dar al texto
  iAnchoTexto: Integer;     // Ancho del texto a imprimir en pixels
begin
  with StringGrid.Canvas do
  begin
    // Lo primero es coger la fuente por defecto que le hemos asignado al componente
    Font.Name := StringGrid.Font.Name;
    Font.Size := StringGrid.Font.Size;

    if ARow = 0 then
      Alineacion := taCenter
    else
      // Si es la columna del importe pendiente alineamos el texto a la derecha
      if ACol = 4 then
        Alineacion := taRightJustify
      else
        Alineacion := taLeftJustify;

    // ¿Es una celda fija de sólo lectura?
    if gdFixed in State then
    begin
      Brush.Color := clNavy;      // le ponemos azul de fondo
      Font.Color := clWhite;      // fuente blanca
      Font.Style := [fsBold];     // y negrita
    end
    else
    begin
      // ¿Esta enfocada la celda?
      if gdFocused in State then
      begin
        Brush.Color := clRed;     // fondo rojo
        Font.Color := clWhite;    // fuente blanca
        Font.Style := [fsBold];   // y negrita
      end
      else
      begin
        // Para el resto de celdas el fondo lo ponemos blanco
        Brush.Color := clWindow;

        // ¿Es la columna del importe pendiente?
        if ACol = 4 then
        begin
          Font.Color := clGreen;   // la pintamos de azul
          Font.Style := [fsBold];  // y negrita
          Alineacion := taRightJustify;
        end
        else
        begin
          Font.Color := clBlack;
          Font.Style := [];
        end;
      end;
    end;

    sTexto := StringGrid.Cells[ACol,ARow];
    FillRect( Rect );
    iAnchoTexto := TextWidth( sTexto );

    case Alineacion of
      taLeftJustify: TextOut( Rect.Left + 5, Rect.Top + 2, sTexto );
      taCenter: TextOut( Rect.Left + ( ( Rect.Right - Rect.Left ) - iAnchoTexto ) div 2, Rect.Top + 2, sTexto );
      taRightJustify: TextOut( Rect.Right - iAnchoTexto - 2, Rect.Top + 2, sTexto );
    end;
  end;
end;

Así quedaría al ejecutarlo:


Sólo hay un pequeño inconveniente y es que la rejilla primero se pinta de manera normal y luego nosotros volvemos a pintarla encima con el evento OnDrawCell con lo cual hace el proceso dos veces. Si queremos que sólo se haga una vez hay que poner a False la propiedad DefaultDrawing. Quedaría de la siguiente manera:


Por lo demás creo que este componente que puede sernos muy útil para mostrar datos por pantalla en formato de sólo lectura. En formato de escritura es algo flojo porque habría que controlar que tipos de datos puede escribir el usuario según en que columnas esté.

Pruebas realizadas en Delphi 7.

Creando aplicaciones MDI

Una aplicación MDI en Windows es aquella que contiene una ventana principal la cual que contiene a su vez ventanas hijas (al estilo Word o Excel). Cada ventana hija no puede salirse del marco de trabajo de la ventana padre aunque si puede minimizarse, maximizarse, etc.


A su vez no todas las ventanas creadas tienen que ser hijas de la ventana padre. Pueden crearse ventanas independientes ya sean normales o modales (una ventana modal es aquella que no permite acceder a ninguna otra hasta que se cierre, como los típicas ventanas de diálogo).

COMO CREAR UNA APLICACION MDI

Aunque el asistente de creación de proyectos de Delphi permite crear aplicaciones MDI, realmente no tiene mucha ciencia. Sólo hay que coger el formulario principal de la aplicación y cambiar su propiedad FormStyle a fsMDIForm. Con sólo hacer eso ya tenemos la ventana padre contenedora.

Para crear una ventana hija hay que hacer lo siguiente:

procedure TFormulario.MDIChildClick( Sender: TObject );
var
  Form: TForm;
begin
  Form := TForm.Create( Self );
  Form.FormStyle := fsMDIChild;
  Form.Caption := 'Ventana hija MDI';
  Form.OnClose := AlCerrar;
  Form.Show;
end;

Como puede apreciarse hemos creado una ventana y le hemos dicho que su estilo es fsMDIChild. También hemos asignado el evento OnClose para cerrar la ventana:

procedure TFormulario.AlCerrar( Sender: TObject; var Action: TCloseAction );
begin
  Action := caFree;
end;

Hay que hacer esto porque por defecto cuando se crea una ventana hija y se cierra, realmente no se cierra si no que se minimiza. Por ello he creado el evento AlCerrar en la ventana padre para asignarlo a todas las ventanas hijas.

Si queremos hacer un formulario normal que no esté relacionado con el formulario padre MDI, entonces el procedimiento sería el siguiente:

procedure TFormulario.NormalClick( Sender: TObject );
var
  Form: TForm;
begin
  Form := TForm.Create( Self );
  Form.Caption := 'Ventana normal';
  Form.Show;
end;

Cuando se crea un formulario nuevo su propiedad FormStyle es por defecto fsNormal. El crear una ventana modal es prácticamente lo mismo:

procedure TFormulario.ModalClick( Sender: TObject );
var
  Form: TForm;
begin
  Form := TForm.Create( Self );
  Form.Caption := 'Ventana modal';
  Form.ShowModal;
end;

Cuando se crea una ventana hija MDI hay que tener presentes un par de cosas:

- Nunca pueden ser invisibles, con lo cual si utilizamos los métodos Show o Hide provocará un error. Igual para la propiedad Visible.

- Tampoco pueden ser modales, para ello utiliza una ventana modal como hemos visto anteriormente.

ORGANIZANDO LAS VENTANAS HIJAS

Una vez creadas las ventanas hijas, la ventana padre puede organizarlas en cascada, mostrarlas todas a la vez, colocarlas horizontalmente, verticalmente e incluso cerrarlas todas.

Por ejemplo, para poner todas las ventanas hijas en cascada hacemos lo siguiente:

procedure TFormulario.CascadaClick( Sender: TObject );
begin
  VentanasNormales;
  Cascade;
end;

El procedimiento VentanasNormales se encarga de dejar cada una de las ventanas hijas de manera normal por si acaso estaban minimizadas:

procedure TFormulario.VentanasNormales;
var i: Integer;
begin
  for i := 0 to MDIChildCount - 1 do
    MDIChildren[i].WindowState := wsNormal;
end;

La clase TForm dispone de las propiedades MDIChildCount y MDIChildren para controlar el número de ventanas hijas abiertas así como cada una de ellas.

Aparte de ponerlas en cascada podemos hacer que todas se repartan en pantalla horizontamente:

procedure TFormulario.HorizontalClick( Sender: TObject );
begin
  VentanasNormales;
  TileMode := tbHorizontal;
  Tile;
end;

Y también verticalmente:

procedure TFormulario.VerticalClick( Sender: TObject );
begin
  VentanasNormales;
  TileMode := tbVertical;
  Tile;
end;

Si queremos minimizarlas todas hay que decírselo a cada una de ellas:

procedure TFormulario.MinimizarClick( Sender: TObject );
var i: Integer;
begin
  for i := MDIChildCount - 1 downto 0 do
    MDIChildren[i].WindowState := wsMinimized;
end;

También ocurre lo mismo si queremos cerrarlas todas:

procedure TFormulario.CerrarClick( Sender: TObject );
var i: Integer;
begin
  for i := 0 to MDIChildCount - 1 do
    MDIChildren[i].Close;
end;

Las aplicaciones MDI son muy útiles para realizar programas de gestión, procesadores de texto, visualizadores de imágenes, etc.

Pruebas realizadas en Delphi 7.

Creando un cliente de chat IRC con Indy (y III)

Después de haber visto la parte básica del componente IdIRC pasemos a ver algunas cosas que hay que controlar en un cliente de chat.

QUIEN SALE Y QUIEN ENTRA A UN CANAL

Mientras permanezcamos en un canal entrarán y saldrán usuarios constantemente, lo cual nos obliga a refrescar la lista de usuarios y notificar los cambios en la misma ventana del canal:

Ha entrado el usuario lola33
Ha salido el usuario carlos21

Para controlar los usuarios que entran a un canal utilizaremos el evento OnJoin:

procedure TFormulario.IRCJoin( Sender: TObject; AUser: TIdIRCUser; AChannel: TIdIRCChannel );
begin
  if Assigned( AChannel ) and Assigned( AUser ) then
    if AChannel.Name = CanalActual.Text then
    begin
      Canal.Lines.Add( 'Ha entrado el usuario ' + AUser.Nick );

      if Usuarios.Items.IndexOf( AUser.Nick ) = -1 then
        Usuarios.Items.Add( AUser.Nick );
    end;
end;

Después de informar en el canal actual que ha aparecido un nuevo usuario también lo hemos dado de alta en la lista de usuarios, controlando que no se repitan, ya que a veces suele coincidir que se ejecuta el comando NAMES del servidor y a la vez entra un usuario nuevo.

Y cuando un usuario abandona el canal entonces utilizamos el evento OnPart:

procedure TFormulario.IRCPart( Sender: TObject; AUser: TIdIRCUser; AChannel: TIdIRCChannel );
var iUsuario: Integer;
begin
  if Assigned( AChannel ) and Assigned( AUser ) then
    if AChannel.Name = CanalActual.Text then
    begin
      Canal.Lines.Add( 'Ha salido el usuario ' + AUser.Nick );
      iUsuario := Usuarios.Items.IndexOf( AUser.Nick );

      if iUsuario > -1 then
        Usuarios.Items.Delete( iUsuario );
    end;
end;

La única dificultad que hay que controlar es que si tenemos varias ventanas (una por canal) hay que llevar las notificaciones a la ventana correspondiente.

Los canales de chat tienen dos clases de usuarios: operadores y usuarios normales. Los operadores son usuarios que tienen permisos especiales: pueden hacer operadores a usuarios normales o echar a un usuario de un canal si esta incumpliendo las normas del mismo.

Cuando un operador echa fuera a un usuario entonces nuestro componente IdIRC provoca el evento OnKick:

procedure TFormulario.IRCKick( Sender: TObject; AUser, AVictim: TIdIRCUser; AChannel: TIdIRCChannel );
var iUsuario: Integer;
begin
  if Assigned( AChannel ) and Assigned( AUser ) then
    if AChannel.Name = CanalActual.Text then
    begin
      Canal.Lines.Add( 'El usuario ' + Auser.Nick + ' ha expulsado a usuario ' + AVictim.Nick );
      iUsuario := Usuarios.Items.IndexOf( AUser.Nick );

      if iUsuario > -1 then
        Usuarios.Items.Delete( iUsuario );
    end;
end;

Este evento nos informa del nombre del operador, el de la victima y del canal de donde ha sido expulsado.

Y por último tenemos el problema de que un usuario puede cambiarse el apodo (nick) en cualquier momento. Para ello utilizaremos el evento OnNickChange para notificarlo:

procedure TFormulario.IRCNickChange( Sender: TObject; AUser: TIdIRCUser; ANewNick: String );
var iUsuario: Integer;
begin
  Canal.Lines.Add( 'El usuario ' + AUser.Nick + ' ahora se llama ' + ANewNick );
  iUsuario := Usuarios.Items.IndexOf( AUser.Nick );

  if iUsuario > -1 then
    Usuarios.Items[iUsuario] := ANewNick;
end;

Aparte de notificarlo le hemos cambiado el nombre en nuestra lista de usuarios.

INTERCEPTANDO LOS MENSAJES DEL SISTEMA

A pesar de todos los eventos de los que dispone el componente de la clase TIdIRC también podemos interceptar a pelo los mensajes del sistema a través del evento OnSystem, el cual nos dice el usuario, el código de comando y el contenido del mensaje del sistema. Por ejemplo estos son algunos códigos de comando del servidor:

353 -> Comienzo del comando NAMES
366 -> Fin del comando NAMES
376 -> Mensaje del día
etc.

Para más información hay que ver el documento RFC perteneciente al protocolo IRC que mencione en el artículo anterior. Por ejemplo, para averiguar los datos sobre un usuario en concreto hay que mandarle al servidor el comando:

WHOIS maria

Y el servidor devolverá lo siguiente:

319 - WHOIS - maria is on #amistades
312 - WHOIS - maria is using jupiter2.irc-hispano.org Servidor IRC de LLeida Networks
318 - WHOIS - maria :End of /WHOIS list

Nos esta diciendo que maria está en el canal #amistades y que está conectada utilizando el servidor jupiter2. Si estuviera conectada a más canales también lo diría (así sabemos también sus otras aficiones).

¿Cómo nos comemos todo eso? Pues supongamos que si yo hago doble clic sobre un usario quiero que me devuelva información sobre el mismo en un campo Memo cuyo nombre es DatosUsuario. Lo primero sería procesar el evento OnDblClick en la lista de usuarios:

procedure TFormulario.UsuariosDblClick( Sender: TObject );
begin
  if Usuarios.ItemIndex > -1 then
    IRC.Raw( 'WHOIS ' + Usuarios.Items[Usuarios.ItemIndex] );
end;

Y ahora en el evento OnSystem del componente IdIRC esperamos a que nos llegue la información:

procedure TFormulario.IRCSystem( Sender: TObject; AUser: TIdIRCUser; ACmdCode:  Integer; ACommand, AContent: string );
begin
  case ACmdCode of
    312, 318, 319: DatosUsuario.Lines.Add( AContent );
  end;
end;

Así, estudiando un poco el protocolo IRC y sabiendo algunos comandos podemos hacer más cosas de las que permite el componente IdIRC.

ENVIO Y RECEPCION DE ARCHIVOS POR ACCESO DIRECTO

El protocolo IRC permite establecer el envío y recepción de archivos con conexión punto a punto entre la IP del remitente y la IP del receptor. Esto ya no se suele utilizar hoy en día por las siguiente razones:

- Debido a que casi todas las redes locales están detrás de un router se hace necesario abrir y redireccionar puertos en el mismo, cosa que no todo el mundo sabe hacer.

- En cuanto intentemos establecer conexión por puertos que no sean los estandar los cortafuegos saltarán como liebres pidiendo permiso para conectar. Los novatos siempre dirán NO por si acaso.

- Hay robots automáticos programados en MIRC mediante scripts que no paran de realizar ataques continuamente a conexiones DCC.

Por ello no voy a comentar aquí como utilizarlo (para ello tenemos rapidshare, megaupload y demás hierbas que superan con creces este tipo de conexiones y además son más seguros).

Con esto finalizamos lo más importante del componente IdIRC de la paleta de componentes Indy.

Pruebas realizadas en Delphi 7.

Creando un cliente de chat IRC con Indy (II)

Una vez establecida la conexión con el servidor y sabiendo de que salas de chat dispone, vamos a entrar a un canal a chatear.

ENTRANDO A UN CANAL

Para entrar a un canal se utiliza el método Join:

IRC.Join( '#amistades' );

Esto viene a ser lo mismo que hacer:

IRC.Raw( 'join #amistades' );

Podemos entrar a tantos canales como deseemos pero para hacer un buen cliente de chat hay que crear un formulario por canal, ya que el protocolo IRC nos permite chatear en múltiples canales simultaneamente.

Una vez se ha enviado el comando JOIN el servidor nos devuelve la lista de usuarios que hay en ese canal. Para recoger dicha lista hay que utilizar el evento OnNames del componente IdIRC, donde volcaremos el contenido de la misma en un ListBox que vamos a llamar Usuarios:

procedure TFormulario.IRCNames( Sender: TObject; AUsers: TIdIRCUsers; AChannel: TIdIRCChannel );
var i: Integer;
begin
  if Assigned( AUsers ) then
  begin
    Usuarios.Clear;

    for i := 0 to AUsers.Count - 1 do
      Usuarios.Items.Add( AUsers.Items[i].Nick );
  end;
end;

Es conveniente que el ListBox este ordenado alfabéticamente activando la propiedad Sorted para no volvernos locos buscando los usuarios por su nombre.

LEYENDO LOS MENSAJES DEL SERVIDOR

Una vez conectados a un canal, el servidor nos mandará dos tipos de mensajes: lo que hablan todos los usuarios en el canal y lo que un usuario en concreto nos esta diciendo. ¿Cómo distinguimos cada cual? Pues para ello el evento OnMessaje nos dice el usuario y canal que nos manda el mensaje:

procedure TFormulario.IRCMessage( Sender: TObject; AUser: TIdIRCUser;
                                  AChannel: TIdIRCChannel; Content: string );
begin
  if Assigned( AUser ) then
  begin
    if Assigned( AChannel ) then
      Canal.Lines.Add( AUser.Nick + '> ' + Content )
    else
      Privado.Lines.Add( AUser.Nick + '> ' + Content );
  end;
end;

Como se puede apreciar primero comprobamos si existe el usuario (por si acaso es un mensaje del sistema) y luego si tiene canal metemos el mensaje por el mismo (poniendo el nick delante como MIRC) y si no es asi lo mandamos a una conversación privada. En este caso he enviado el texto de la conversación a un componente RichEdit.

Sería interesante que nuestro cliente de chat dispusiera de un formulario por cada conversación privada. Por ello, sería recomendable que nuestro programa de chat utilizara ventanas MDI para permitir el control absoluto cada una de las salas en las que estamos así como cada una de las conversaciones privadas. En otro artículo escribiré como crear aplicaciones MDI.

Otra característica que lo haría más profesional sería dibujar el nick y el mensaje del usuario con colores distintos como vimos anteriormente en el artículo dedicado al componente RichEdit. Y si además damos al usuario la posibilidad de seleccionar los colores de fondo, texto, nicks y tipo de fuente, el programa se aproximaría al famoso cliente MIRC.

ENVIANDO MENSAJES AL SERVIDOR

Se pueden enviar dos tipos de mensajes: a un canal donde estamos (para el público en general ) o a un usuario en concreto. El método say del componente IdIRC cumple dicho cometido.

Si quiero enviar un mensaje al canal amistades:

IRC.Say( '#amistades', 'hola a todos' );

Y si es para un usuario con el que estamos chateando:

IRC.Say( '#maria', 'hola guapa, que tal?' );

Al fin y al cabo para el servidor todo son canales, tanto canales públicos como usuarios particulares. Tenemos que ser nosotros los que debemos procesar de donde viene el mensaje y a donde deseamos enviarlo. De ahí la necesidad de crear un formulario por canal y otro por conversación privada.

ABANDONANDO UN CANAL Y UN SERVIDOR

Para abandonar un canal se utiliza el método Part:

IRC.Part( '#amistades' );

Si se nos olvida hacer esto y seguimos abriendo canales al final gastaremos mucho ancho de banda, ya que el servidor nos manda todos los mensajes publicos de cada uno de los canales abiertos.

Si queremos desconectar del servidor se utiliza el comando:

IRC.Disconnect;

Esto cancelará la conexión con el servidor cerrando todos los mensajes públicos y privados del mismo. En nuestro programa deberemos cerrar todas las ventanas de conversación abiertas.

Todavía quedan algunos puntos importantes para terminar de crear un cliente de chat, tales como saber si un usuario entra o abandona el canal donde estamos.

Pruebas realizadas en Delphi 7.

Creando un cliente de chat IRC con Indy (I)

Aunque MSN es el rey de la comunicación instantánea aún siguen muy vivos los servidores de chat IRC tales como irc-hispano.

IRC define un protocolo de comunicaciones entre clientes y servidores permitiendo incluso el envío de archivos por conexión directa. De todos es conocido el potente programa para Windows llamado MIRC creado hace años y que aún sigue siendo el cliente más utilizado para el IRC debido a sus múltiples extensiones.

En nuestro caso vamos a ver como utilizar el componente de la clase TIdIRC el cual esta situado en la pestaña de componentes Indy.

CONECTANDO CON EL SERVIDOR

Antes de comenzar a chatear con el servidor hay que establecer una conexión con el mismo utilizando un apodo (nick) y una contraseña en el caso de que sea necesaria (la mayoría de los servidores IRC son públicos).

Supongamos que tenemos en el formulario principal de nuestra aplicación un componente IdIRC que vamos a llamar IRC. Para conectar con el servidor hay que hacer lo siguiente:

IRC.Nick := 'juanito33487';
IRC.AltNick := 'juanito33488';
IRC.Username := 'juanito33487';
IRC.RealName := 'juan';
IRC.Password := '';
IRC.Host := 'irc.irc-hispano.org';

try
  IRC.Connect;
except
  Application.MessageBox( 'No se ha podido conectar con el servidor.',
                          'Error de conexión', MB_ICONSTOP );
end;

Estos son los parámetros para conectar:

Nick     -> apodo por el que nos conocerán los demás usuarios
AltNick  -> si el nick que hemos utilizado está ocupado por otro usuario cogerá este otro nick
Username -> Nombre del usuario para el servidor (da lo mismo si no estamos registrados)
Realname -> Nombre real del usuario
Password -> Clave de acceso para usuarios registrados
Host     -> Dirección IP del servidor

Cualquier persona puede conectarse a un servidor de chat dando sólo el nombre del usuario sin contraseña. Pero si queremos que nadie utilice nuestro nick nos podemos registrar gratuitamente (en la mayoría de los casos) en el servidor con un usuario y password obteniendo además algunas características adicionales como entrar a salas de chat restringidas o tener nuestro propio servidor de mensajes y correo online 24 horas al día.

Una vez conectados al servidor toca entrar en una sala de chat. Pero, ¿de que salas de chat dispone el servidor? Para ello utilizamos el comando:

IRC.Raw( 'LIST' );

El método Raw permite mandar cualquier tipo de comando al servidor. Se suele utilizar cuando el componente IRC no contiene métodos para realizar tareas específicas. Los servidores IRC trabajan enviando y recibiendo mensajes de texto continuamente. Para los que les interese saber como funciona por dentro el protocolo IRC disponen de este documento RFC:

http://www.rfc-es.org/rfc/rfc1459-es.txt

Pese a los comandos del IRC estándar algunos servidores disponen de comandos propios para tareas específicas. Para esos casos utilizaremos el método Raw.

Hay que tener mucho cuidado cuando se llama al comando LIST ya que hay servidores como los irc-hispano que disponen de miles de canales lo cual puede hacer que el tiempo en sacar el listado llegue a ser desesperante. Por ello sería deseable que tanto la función de conectar a un servidor IRC como la de listar los canales estuviera dentro de un hilo de ejecución, ya que hasta que no conecta da la sensación de que nuestro programa esta colgado.

Después de ejecutar dicho comando tenemos que programar el evento OnList para recoger la información del listado de canales. En este caso para volcar los canales en un componente ListBox llamado Canales hacemos lo siguiente:

procedure TFormulario.IRCList( Sender: TObject; AChans: TStringList;
                               APosition: Integer; ALast: Boolean );
begin
  Canales.Items := AChans;
end;

Con esto ya tenemos la lista de canales que dispone el servidor así como el número de usuarios que hay conectados por canal y su descripción. Por ejemplo:

#amistades 20 Busca nuevos amig@s
#amor 50 Conoce a tu media naranja
#sexo 80 No te cortes un pelo
#musica 34 Comparte la pasión por tus artistas preferidos
....

En un servidor de IRC los canales comienzan con el carácter # seguido de su nombre sin espacios.

En el próximo artículo veremos como entrar a los canales de chat y hablar con otros usuarios.

Pruebas realizadas en Delphi 7.

Creando un procesador de textos con RichEdit (y II)

Sigamos añadiendo características a nuestro pequeño editor de textos:


NEGRITA, CURSIVA Y SUBRAYADO

Vamos a definir la función de los típicos botones de negrita, cursiva y subrayado que llevan los procesadores de texto. Comencemos con el botón de negrita:

procedure TFormulario.BNegritaClick( Sender: TObject );
begin
 with RichEdit.SelAttributes do
   if not ( fsBold in Style ) then
     Style := Style + [fsBold]
   else
     Style := Style - [fsBold];

 RichEdit.SetFocus;
end;

Hay que tener en cuenta que si el usuario pulsa una vez negrita y el texto no estaba en negrita entonces se aplica dicho estilo, pero si ya lo estaba entonces hay que quitarlo.

Lo mismo sería para el botón de cursiva:

procedure TFormulario.BCursivaClick( Sender: TObject );
begin
 with RichEdit.SelAttributes do
   if not ( fsItalic in Style ) then
     Style := Style + [fsItalic]
   else
     Style := Style - [fsItalic];

 RichEdit.SetFocus;
end;

Y para el botón de subrayado:

procedure TFormulario.BSubrayadoClick( Sender: TObject );
begin
 with RichEdit.SelAttributes do
   if not ( fsUnderline in Style ) then
     Style := Style + [fsUnderline]
   else
     Style := Style - [fsUnderline];

 RichEdit.SetFocus;
end;

MOSTRANDO LA POSICION ACTUAL DEL CURSOR

Una de las cosas que se agradece en todo procesador de textos es que muestre en que fila y columna estoy situado. Para ello vamos a insertar en la parte inferior del formulario una barra de estado. El componente se llama StatusBar y se encuentra en la pestaña Win32. Le vamos a poner el nombre de Estado y ponemos a True su propiedad SimplePanel.

Lo que haremos a continuación es un procedimiento que muestre la posición actual del cursor dentro del RichEdit en la barra de estado:

procedure TFormulario.MostrarPosicion;
begin
 Estado.SimpleText := Format( 'Fila: %d Columna %d',
   [RichEdit.CaretPos.y+1, RichEdit.CaretPos.x+1] );
end;

Este procedimiento hay que llamarlo cuando creamos el formulario:

procedure TFormulario.FormCreate( Sender: TObject );
begin
 MostrarPosicion;
end;

y en el evento OnSelectionChange del RichEdit:

procedure TFormulario.RichEditSelectionChange( Sender: TObject );
begin
 MostrarPosicion;
end;

Al ejecutar el programa veremos que el resultado queda más profesional (ya podían los de Microsoft ponerle esto al cutre Bloc de Notas).

DANDO FORMATO A LOS PARRAFOS DEL DOCUMENTO

Otra característica que vamos a implementar es la de alinear el párrafo actual a la izquierda, al centro y a la derecha. Para ello vamos a poner arriba tres botones llamados BIzquierda, BDerecha y BCentro, cuyos eventos serían:

procedure TFormulario.BIzquierdaClick( Sender: TObject );
begin
 RichEdit.Paragraph.Alignment := taLeftJustify;
end;

procedure TFormulario.BCentroClick( Sender: TObject );
begin
 RichEdit.Paragraph.Alignment := taCenter;
end;

procedure TFormulario.BDerechaClick( Sender: TObject );
begin
 RichEdit.Paragraph.Alignment := taRightJustify;
end;

Otra característica que se le puede añadir a un párrafo es la de añadir un punto por la izquierda como hace Microsoft Word. Para ello vamos a añadir el botón de nombre BPunto cuyo procedimiento es:

procedure TFormulario.BPuntoClick( Sender: TObject );
begin
 with RichEdit.Paragraph do
   if Numbering = nsNone then
     Numbering := nsBullet
   else
     Numbering := nsNone;

 RichEdit.SetFocus;
end;

Si se pulsa una vez este botón añade un punto al párrafo y si se pulsa de nuevo lo quita.

Al párrafo actual se le pueden modificar también las propiedades:

FirstIndent -> Es el espacio en pixels por la izquierda que se le da a la primera línea
LeftIndent  -> Es el espacio en pixels por la izquierda que se le da a todas las líneas
RightIndent -> Es el espacio en pixels por la derecha que se le da a todas las líneas

LAS OTRAS PROPIEDADES DEL COMPONENTE RICHEDIT

Hay otras propiedades que nos permiten personalizar nuestro editor de texto como son:

PlainTex: Si se activa esta propiedad al guardar el archivo de texto a disco no almacena las propiedades de color, fuente, etc. Se comporta como el Bloc de Notas.

SelLength: Es el número de caracteres seleccionados por el usuario.

SelStart: Es la posición en el texto donde comienza la selección.

SelText: Es el texto seleccionado.

Con esto finalizamos las características más importantes del componente RichEdit.

Pruebas realizadas en Delphi 7.

Creando un procesador de textos con RichEdit (I)

Para crear un procesador de textos vamos a utilizar el componente RichEdit que se encuentra en la pestaña Win32. Este componente tiene la particularidad de poder definir distintos estilos de texto al contrario de un componente Memo cuya fuente es estática para todo el documento.

El componente de la clase TRichEdit hereda de TCustomMemo añadiendo características tan interesantes como la de modificar el estilo de la fuente, colorear palabras o frases, etc.

Veamos como se podría crear un mini procesador de textos utilizando este componente. Como procesador de textos lo primero que debemos definir son las funciones para la creación, carga y grabación de documentos en disco.

La programación la voy a realizar sobre este formulario:


Las opciones del menú son:

Archivo -> Nuevo, Abrir, Guardar, Guardar como y Salir.
Edición -> Cortar, Copiar y Pegar.
Formato -> Fuente
Ayuda   -> Acerca de...

GUARDANDO EL TEXTO EN UN ARCHIVO

Lo primero que vamos a contemplar es la grabación en un archivo de texto. Para ello vamos a insertar en el formulario un componente de clase TSaveDialog que se encuentra en la pestaña Dialogs y lo vamos a llamar GuadarTexto.

Entonces al pulsar la opción Archivo -> Guardar como del ménu ejecutamos lo siguiente:

procedure TFormulario.GuardarComoClick( Sender: TObject );
begin
  if GuardarTexto.Execute then
  begin
    RichEdit.Lines.SaveToFile( GuardarTexto.FileName );
    sArchivo := GuardarTexto.FileName;
  end;
end;

La variable sArchivo se va a encargar de guardar la ruta y el nombre archivo que se guardó por primera vez, para que cuando seleccionemos la opción guardar no haya que volver a decirle de nuevo el nombre. Esta variable la vamos a declarar en la sección privada de nuestro formulario:

  private
    { Private declarations }
    sArchivo: String;

Ahora tenemos que hacer que si el usuario pulsa la opción Guardar se guarde el archivo sin preguntarnos el nombre si ya lo tiene:

procedure TFormulario.GuardarClick( Sender: TObject );
begin
  // ¿No tiene nombre?
  if sArchivo = '' then
    GuardarComoClick( Self )
  else
    RichEdit.Lines.SaveToFile( sArchivo );
end;

Si no tuviera nombre es que es un archivo nuevo, con lo cual lo desviamos a la opción Guardar como.

CARGADO EL TEXTO DESDE UN ARCHIVO

Para cargar el texto tenemos que añadir al formulario el componente TOpenDialog y lo llamamos CargarTexto. Y al pulsar en el menú la opción Archivo -> Abrir se ejecutaría:

procedure TFormulario.AbrirClick( Sender: TObject );
begin
  if CargarTexto.Execute then
  begin
    RichEdit.Lines.LoadFromFile( CargarTexto.FileName );
    sArchivo := CargarTexto.FileName;
  end;
end;

También guardamos en la variable sArchivo el nombre del archivo cargado para su posterior utilización en la opción Guardar.

CREANDO UN NUEVO TEXTO

En nuestro programa vamos a hacer que si el usuario selecciona la opción del menú Archivo -> Nuevo se elimine el texto del componente RichEdit. Lo que si hay que controlar es que si había un texto anterior le pregunte al usuario si desea guardarlo.

procedure TFormulario.NuevoClick( Sender: TObject );
begin
  // ¿Hay algo introducido?
  if RichEdit.Text <> '' then
    if Application.MessageBox( '¿Desea guardar el texto actual?', 'Atención',
                               MB_ICONQUESTION OR MB_YESNO ) = ID_YES then
      GuardarClick( Self );

  RichEdit.Clear;
end;

CONTROLANDO LA EDICION DEL TEXTO

Otra de las cosas básicas que debe llevar todo editor de texto son las funciones de cortar, copiar y pegar. Para ello vamos a implemantar primero la opción del menú Edición -> Cortar:

procedure TFormulario.CortarClick( Sender: TObject );
begin
  RichEdit.CutToClipboard;
end;

Después hacemos la opción de Edición -> Copiar:

procedure TFormulario.CopiarClick( Sender: TObject );
begin
  RichEdit.CopyToClipboard;
end;

Y por último la opción de Edición -> Pegar:

procedure TFormulario.PegarClick( Sender: TObject );
begin
  RichEdit.PasteFromClipboard;
end;

CAMBIANDO EL ESTILO DEL TEXTO

Una vez tenemos implementada la parte básica del editor de texto vamos a darle la posibilidad al usuario de que pueda cambiar la fuente, el estilo, el color, etc.

Para que el usuario pueda elegir la fuente tenemos que introducir en el formulario el componente de la clase TFontDialog situado en la pestaña Dialogs. Le vamos a dar el nombre de ElegirFuente.

Ahora en la opción del menú Formato -> Fuente ejecutamos:

procedure TFormulario.FuenteClick( Sender: TObject );
begin
  if ElegirFuente.Execute then
    with RichEdit, ElegirFuente do
    begin
      SelAttributes.Name := Font.Name;
      SelAttributes.Size := Font.Size;
      SelAttributes.Color := Font.Color;
      SelAttributes.Pitch := Font.Pitch;
      SelAttributes.Style := Font.Style;
      SelAttributes.Height := Font.Height;
    end;
end;

¿Por qué no hemos hecho lo siguiente?

RichEdit.Font := ElegirFuente.Font;

Si hago esto me cambia la fuente de todo el texto, incluso la que he escrito anteriormente y a mi lo que me interesa es modificar la fuente de lo que se vaya a escribir a partir de ahora. Para ello se utilizan las propiedades de SelAttributes las cuales se encargan de establecer el estilo del texto seleccionado, y en el caso de que no haya texto seleccionado se aplica a donde esté el cursor.

En el próximo artículo seguiremos ampliando nuestro pequeño procesador de textos.

Pruebas realizadas en Delphi 7.

El componente TTreeView (y II)

Después de ver el manejo básico de un árbol TreeView pasemos a ver otras características menos conocidas pero también de suma importancia.

OBTENIENDO EL NIVEL DE CADA NODO

Cuando se van insertando elementos dentro de un árbol tenemos la dificultad de saber en que nivel de profundidad se encuentra cada uno de los nodos. Cada uno de los Items del componente TTreeView es de la clase TTreeNode.

Esta clase dispone de la propiedad Level la cual nos da el nivel de profundidad dentro del árbol. Veamos como obtener el nivel de cada uno de los nodos del árbol. Este procedimiento recorre todos los nodos del árbol y les añade a su nombre el nivel:

procedure TFTreeView.BNivelClick( Sender: TObject );
var i: Integer;
begin
  // Averiguamos el nivel de cada nodo
  for i := 0 to TreeView.Items.Count - 1 do
    TreeView.Items[i].Text := TreeView.Items[i].Text + '_' +
      IntToStr( ( TreeView.Items[i] as TTreeNode ).Level );
end.

Los elementos situados en la raiz tienen un nivel 0, los hijos un nivel 1, los nietos un 2...

LEYENDO LOS NODOS SELECCIONADOS

El nodo actualmente seleccionado se obtiene mediante:

TreeView.Selected

donde valdrá nil si no hay ninguno seleccionado. Pero si activamos la propiedad MultiSelect la forma de leer aquellos nodos seleccionados sería la siguiente:

procedure TFTreeView.BSeleccionadosClick( Sender: TObject );
var
  i: Integer;
  Seleccionados: TStringList;
begin
  Seleccionados := TStringList.Create;

  for i := 0 to TreeView.Items.Count - 1 do
    if TreeView.Items[i].Selected then
      Seleccionados.Add( TreeView.Items[i].Text );

  ShowMessage( Seleccionados.Text );

  Seleccionados.Free;
end;

Al igual que hicimos con el componente ListView volcamos el nombre de los nodos seleccionados en un StringList y lo sacamos por pantalla.

ASOCIANDO UNA IMAGEN A CADA NODO

Si añadimos a nuestro formulario el componente TImageList se pueden asocionar iconos distintos a cada uno de los elementos del árbol TTreeView. Para ello asociamos este componente a la propiedad Images del TTreeView. Una vez hecho esto todos los nodos tendrán a su izquierda la primera imagen de la lista de imágenes TImageList.

Ya será cuestión de cada cual asociar la imagen correspondiente cada nodo. Vamos a ver un ejemplo que recorre los elementos del árbol y va a poner la segunda imagen de la lista de imágenes a aquellos nodos hijos (de nivel 1):

procedure TFTreeView.CambiarNodosHijos;
var
  i: Integer;
begin
  for i := 0 to TreeView.Items.Count - 1 do
    if ( TreeView.Items[i] as TTreeNode ).Level = 1 then
      ( TreeView.Items[i] as TTreeNode ).ImageIndex := 1;
end;

CAMBIANDO LA FORMA EN QUE SE MUESTRAN LOS NODOS

El componente TreeView dispone la propiedad Ident la cual determina la identación de entre los nodos padres y sus hijos que por defecto es de 19 pixels. Se puede cambiar en cualquier momento, pero afectará a todos los nodos del árbol.

Otra cosa que se puede hacer al cargar un árbol desde un archivo de texto es expandir todos sus nodos, ya que cuando se carga el árbol esta compactado. Para solucionarlo se hace:

TreeView.FullExpand;

Equivale a pulsar el botón + de cada uno de los nodos padres.

CAMBIANDO LA FORMA DE DIBUJAR LOS NODOS

Al igual que vimos con el componente ListView también se puede modificar en tiempo real la forma de dibujar cada nodo. Para ello lo que hacemos es reprogramar el evento OnCustomDrawItem. Veamos un ejemplo de como hacer que los nodos hijos aparenzan de color de fuente azul y negrita:

procedure TFTreeView.TreeViewCustomDrawItem( Sender: TCustomTreeView;
  Node: TTreeNode; State: TCustomDrawState; var DefaultDraw: Boolean );
begin
  if Node.Level = 1 then
  begin
    Sender.Canvas.Font.Color := clBlue;
    Sender.Canvas.Font.Style := [fsBold];
  end
  else
  begin
    Sender.Canvas.Font.Color := clBlack;
    Sender.Canvas.Font.Style := [];
  end;

  if cdsFocused in State then
    Sender.Canvas.Font.Color := clWhite;
end;

En las dos últimas líneas del procedimiento también nos hemos asegurado de que si un elemento esta seleccionado la fuente salga de color blanca. Hemos utilizado para ello el parámetro State del evento. Los posibles valores de esta variable son:

cdsSelected       -> La columna o fila ha sido seleccionada
cdsGrayed         -> La columna o fila esta grisacea
cdsDisabled       -> La columna o fila esta deshabilitada
cdsChecked        -> La fila aparece con el CheckBox activado
cdsFocused        -> La columna o fila esta enfocada
cdsDefault        -> Por defecto
cdsHot            -> Se ha activado el HotTrack y esta enfocado
cdsMarked         -> La fila esta marcada
cdsIndeterminate  -> La fila no esta seleccionada ni deseleccionada

Con esto se resumen las propiedades más importantes del componente TreeView.

Pruebas realizadas en Delphi 7.

El componente TTreeView (I)

Cuando queremos representar una información en forma de árbol incluyendo nodos padres e hijos el componente ideal para ello es el TreeView, el cual funciona exactamente igual que la parte izquierda del Explorador de Windows.

Veamos las peculiaridades que aporta este componente. Todas las funciones las voy a aplicar sobre esta pantalla:


AÑADIENDO ELEMENTOS AL ARBOL

Cuando se añaden elementos a un árbol pueden pertenecer al elemento raiz del mismo (sin padre) o pertenecer a un elemento ya creado. Los elementos del árbol se llaman nodos (Node) pudiendose crear tantos niveles de nodos como se deseen.

Vamos a crear un procedimiento asociado al botón Nuevo que va a añadir un nuevo nodo al árbol. El elemento insertado será un nodo raiz, a menos que el usuario seleccione un nodo antes de ello, que hará que sea su hijo:

procedure TFTreeView.BNuevoClick( Sender: TObject );
var
  sNombre: string;
begin
  sNombre := InputBox( 'Crear un nodo', 'Nombre:', '' );

  if sNombre <> '' then
  begin
    // ¿Hay un nodo seleccionado?
    if TreeView.Selected <> nil then
    begin
      TreeView.Items.AddChild( TreeView.Selected, sNombre );
      TreeView.Selected.Expanded := True;
    end
    else
      TreeView.Items.Add( nil, sNombre );
  end;
end;

Lo que hace este procedimiento es preguntarnos el nombre del nodo y si el usuario ha seleccionado uno anteriormente lo mete como hijo (AddChild) expandiendo además el nodo padre (Expanded) como si el usuario hubiese pulsado el botón + del elemento padre.

MODIFICANDO LOS ELEMENTOS DEL ARBOL

Una vez creado un árbol de elementos se puede modificar el texto de cada uno de ellos mediante la propiedad Text. Vamos a hacer que si el usuario pulsa el botón Modificar y hay un nodo seleccionado el programa nos pregunte el nuevo nombre del nodo y lo cambie:

procedure TFTreeView.BModificarClick( Sender: TObject );
var
  sNombre: string;
begin
  if TreeView.Selected <> nil then
  begin
    sNombre := InputBox( 'Crear un nodo', 'Nombre:', TreeView.Selected.Text );

    if sNombre <> '' then
      TreeView.Selected.Text := sNombre;
  end;
end;

Cuando se van a hacer operaciones con los nodos hay que asegurarse siempre que el nodo al que vayamos a acceder no sea nil, para evitar Access Violations.

ELIMINANDO LOS ELEMENTOS DEL ARBOL

Para eliminar un nodo del árbol se utiliza el método Delete:

procedure TFTreeView.BEliminarClick( Sender: TObject );
begin
  if TreeView.Selected <> nil then
    TreeView.Selected.Delete;
end;

Y si queremos eliminar todos los nodos se utiliza el método Clear de la propiedad Items:

procedure TFTreeView.BBorrarTodosClick( Sender: TObject );
begin
  TreeView.Items.Clear;
end;

ORDENANDO LOS NODOS ALFABETICAMENTE

El modo de ordenar los elementos de un componente TreeView es igual al de ordenar los elementos de un componente ListView. Hay dos métodos: CustomSort y AlphaSort. El método CustomSort no voy a explicarlo ya que lo mencioné anteriormente en el artículo dedicado al componente ListView y es un poco más primitivo que utilizar AlphaSort.

Para ordenar todos los elementos de un árbol TreeView se utiliza el método:

procedure TFTreeView.BOrdenarClick( Sender: TObject );
begin
  TreeView.AlphaSort( True );
end;

El parámetro booleano especifica si queremos que ordene tanto los elementos padres como los hijos (True) o sólo los elementos padres. Si no se especifica nada se asume que ordene todos los elementos.

Ahora hay que programar el evento OnCompare del TreeView para que ordene alfabéticamente los elementos:

procedure TFTreeView.TreeViewCompare( Sender: TObject; Node1,
  Node2: TTreeNode; Data: Integer; var Compare: Integer );
begin
  Compare := CompareText( Node1.Text, Node2.Text );
end;

Si queremos que la ordenación sea descendente entonces sólo hay que cambiar el signo:

Compare := -CompareText( Node1.Text, Node2.Text );

GUARDANDO LA INFORMACION DEL ARBOL EN UN ARCHIVO DE TEXTO

La clase TTreeView dispone del método SaveToFile para volcar todos los nodos en un archivo de texto para su posterior utilización. Voy a hacer un procedimiento que pregunte al usuario que nombre deseamos dar al archivo y lo guardará en el mismo directorio del programa con la extensión .TXT:

procedure TFTreeView.BGuardarClick( Sender: TObject );
var sNombre: string;
begin
  sNombre := InputBox( 'Crear un nodo', 'Nombre:', '' );

  if sNombre <> '' then
    TreeView.SaveToFile( ExtractFilePath( Application.ExeName ) + sNombre + '.txt' );
end;

La información la guarda por líneas donde cada elemento hijo va separado por tabuladores:

documentos
    ventas
contactos
    Pablo
    Ana
    Maria
claves
    Terra
    Hotmail
    GMail

CARGANDO LA INFORMACION DEL ARBOL GUARDADA ANTERIORMENTE

Para cargar el archivo de texto vamos a crear en tiempo real el componente TOpenDialog para que le pregunte al usuario el archivo de texto a cargar:

procedure TFTreeView.BCargarClick( Sender: TObject );
var
  Abrir: TOpenDialog;
begin
  Abrir := TOpenDialog.Create( Self );
  Abrir.InitialDir := ExtractFilePath( Application.ExeName );
  Abrir.Filter := 'TreeView|*.txt';

  if Abrir.Execute then
    TreeView.LoadFromFile( Abrir.FileName );

  Abrir.Free;
end;

Hemos modificado el filtro de la carga para que sólo se vean archivos TXT.

En el próximo artículo seguiremos viendo más propiedades interesantes del componente TreeView.

Pruebas realizadas en Delphi 7.