Boletín Pascal #51 - 02-FEB-2005
Índice
1. Unas palabras del editor
2. Cómo correr una sola instancia de una aplicación (y II)
3. Dentro de las clases e interfaces de Delphi (y II)
4. Enumerando todos los recursos de una red LAN
5. Foros / listas de correo
6. Delphi en la Red
- Componentes, librerías y aplicaciones
· Shareware / Comercial
· Freeware
· Actualizaciones de productos Borland
- Artículos, trucos y consejos
- Tutoriales y capacitación
- Noticias
________________________________________________________________________
Tecno Soft Solutions. Reseller Autorizado de Symbol Technologies, líder
mundial en captura de códigos de barras. >>> http://www.tecno-symbol.com
________________________________________________________________________
1. Unas palabras del editor
Ha pasado un largo tiempo sin que se publique el boletín, no por falta
de voluntad, sino por falta de tiempo. Aunque muchos no lo crean, lleva
varias horas armar un número y publicarlo, y en el pasado 2004 la verdad
que me ha sido difícil encontrar esas horas, que siempre son robadas al
necesario descanso y a la familia... Bien, pues ahora que dispongo de un
poco más de tiempo (al menos temporalmente), quiero decirles que no me
he olvidado de ustedes y que en estos días estaré traduciendo las dos
ediciones que me quedan pendientes de publicación, y ojalá que durante
el 2005 podamos publicar una edición cada dos meses como nos hemos
propuesto con Dave, pero no prometo nada, ¿OK?
Si no fuera por los autores que colaboran sus artículos, este boletín no
existiría, así que vaya nuestro agradecimiento en esta ocasión a Furious
Logic, Peter Johnson y Ezra Hoch, este último acreedor del premio
disponible para este número:
* Ezra Hoch - "Dentro de las clases e interfaces de Delphi"
Delphi SWF SDK (Standard) v1.4 - por FeatherySoft ($170)
Librería Object Pascal para crear ficheros SWF sin usar librerías
dinámicas externas. Características: objetos visuales (forma, botón,
texto, forma cambiante, sprite); todos los tipos de relleno (sólido,
gradiente, imagen); fuentes incrustadas; comandos de acciones; sonidos
(eventos, streaming); video; cualquier transición y transformación.
http://www.delphiflash.com/
Los premios para la próxima edición, que dicho sea de paso ya está casi
lista y se publicará próximamente, son:
* KylixDriver v1.1 - por ET Kimberliteware Ltd ($39 / $69 con fuentes)
Conjunto de herramientas para el desarrollo de drivers Linux que
accedan al hardware de la PC, permitiendo desarrollar con Kylix
controladores de dispositivo ISA/PCI para hardware específico.
http://etsoftware.tripod.com/products.html
* InstallAWARE 3.0 Express Edition - por MimarSinan Int. ($69.95)
Desarrolle instaladores para Windows Installer sin necesidad de
conocimiento previo de MSI. InstallAWARE automáticamente convierte en
tiempo de construcción un script de flujo condicional en una base de
datos MSI que cumple con ICE, certificable mediante logo. El IDE
ofrece una interfaz visual que automáticamente genera un script de
instalación por usted, el cual puede ser completamente adaptado.
http://www.installaware.com/landingea.html
* KnowedgeBASE Vortex 2.9 por Delphinium Software ($49.35)
El corazón de KnowledgeBASE es un árbol de información altamente
expandible y con gran capacidad de búsqueda, que puede verse como
esquema o auditado dentro de un procesador de textos incorporado.
Incluye una base de datos para referencias guardadas.
http://www.programurl.com/knowledgebase-vortex.htm
Estamos orgullosos de ofrecer a los lectores del boletín un descuento
especial para InstallAWARE 3 (30% en cualquier edición), gracias a la
colaboración de MimarSinan International. InstallAWARE 3 ha sido
desarrollado enteramente en Delphi y sirve para crear instaladores MSI
sin necesidad de conocimiento previo sobre Windows Installer. En vez de
limitarse a proveer una interfaz visual (como Wise o InstallShield),
InstallAWARE tiene su propio RAD y lenguaje de programación/scripting,
el que en tiempo de construcción es automáticamente convertido a base
de datos MSI, certificable mediante con logo. Las características
únicas incluyen distribución Web parcial, programación genuina para
Windows Installer, un poderoso editor de diálogos con controles únicos
(como contenedores Flash y HTML) y compresión 7ZIP avanzada (¡el
runtime para .NET es de 11MB en vez de 23MB!). Por un tiempo limitado,
los lectores pueden obtener un descuento de 30% en cualquier edición de
InstallAWARE 3 siguiendo los enlaces que se publican en este número del
boletín.
¿Alguien ha tenido oportunidad de usar el nuevo Delphi 2005? Recibimos
sus comentarios en <eds2008 @ latiumsoftware.com>.
Para más información sobre Delphi 2005: http://www.borland.com/delphi
Saludos,
Ernesto De Spirito y Dave Murray
boletin-pascal-owner@gruposyahoo.com
__________________
Colaboraron en esta edición: Furious Logic, Peter Johnson y Ezra Hoch
________________________________________________________________________
Help & Manual 3.50 por EC Software · Shareware ($ 279) - Una herramienta
visual de autoría de ayuda para generar archivos WinHelp (.HLP), Adobe
PDF, páginas HTML y los nuevos archivos HTML HELP (.CHM) introducidos
en Windows 98, así como otros formatos de archivo y documentación
impresa, todo desde una misma fuente. Una herramienta imprescindible
para cualquier desarrollador de software. http://www.helpandmanual.com/
________________________________________________________________________
2. Cómo correr una sola instancia de una aplicación (y II)
Parte 2: Una solución reutilizable
Por Peter Johnson, Copyright (c) 2003
<delphidabbler at tiscali dot co dot uk>
http://www.delphidabbler.com/
Visión general de una solución orientada a objetos
--------------------------------------------------
Esta sección presenta una solución al problema de correr una sola
instancia de una aplicación, solución que es orientada a objetos y
extensible.
El código principal está centralizado en una sola unidad
(USingleInst.pas) que implementa y crea un objeto singleton
(TSingleInst) que maneja la instancia única de la aplicación y se
encarga de enviar y recibir datos de parámetros. Mientras que
TSingleInst provee un nombre para la clase de ventana del formulario
principal, el método de nombre de clase de ventana puede (y debe) ser
redefinido (overridden) para proveer un nombre de clase único. También
puede proveerse una marca de agua al redefinir el método.
Se requiere alguna alteración al archivo de proyecto y al formulario
principal, pero los cambios no son tan significativos como en el
ejemplo anterior (presentado en la primera parte del artículo, publicada
en el Boletín Pascal #50) y la funcionalidad principal está aislada en
USingleInst.pas.
El procedimiento para habilitar el soporte de una sola instancia de la
aplicación en un proyecto es como sigue:
* Añadir USingleInst.pas al proyecto.
* Crear una nueva clase derivada de TSingleInst y redefinir los métodos
que devuelven el nombre de clase de ventana y (opcionalmente) la marca
de agua.
* Registrar la nueva clase como la clase a usar al crear un objeto
singleton SingleInst.
* Modificar los fuentes del formulario principal y del proyecto para
llamar al punto de entrada requerido del objeto SingleInst.
En el resto de esta sección repasaremos la unidad USingleInst, luego
daremos un vistazo a cómo derivar y registrar una nueva clase a partir
de ella y finalmente describiremos los cambios a realizar a los archivos
de código fuente del proyecto y del formulario principal.
La unidad USingleInst
---------------------
Repasaremos las partes de la unidad en orden. El código fuente de la
unidad acompaña este artículo. Esta es la sección de Interfaz de la
unidad que declara la clase y las funciones de apoyo:
unit USingleInst;
interface
uses
Windows, Controls, Messages;
type
TSingleInstParamHandler = procedure(const Param: string) of object;
TSingleInstClass = class of TSingleInst;
TSingleInst = class(TObject)
private
fOnProcessParam: TSingleInstParamHandler; // manejador de evento
fEnsureRestoreMsg: UINT; // mensaje único para pedir restauración
protected
function WdwClassName: string; virtual:
function WaterMark: DWORD; virtual;
function FindDuplicateMainWdw: HWND; virtual;
function SendParamsToPrevInst(Wdw: HWND): Boolean; virtual;
function SwitchToPrevInst(Wdw: HWND): Boolean;
procedure EnsureRestore(var Msg: TMessage); dynamic;
procedure WMCopyData(var Msg: TMessage); dynamic;
public
constructor Create;
procedure CreateParams(var Params: TCreateParams);
function HandleMessages(var Msg: TMessage): Boolean;
function CanStartApp: Boolean;
property OnProcessParam: TSingleInstParamHandler
read fOnProcessParam write fOnProcessParam;
end;
function SingleInst: TSingleInst;
procedure RegisterSingleInstClass(Cls: TSingleInstClass);
Repasemos primero las declaraciones de tipo. TSingleInstParamHandler es
el tipo del manejador de evento OnProcessParam que es invocado por cada
parámetro pasado a la aplicación en un mensaje WM_COPYDATA, mientras que
TSingleInstClass es el tipo de clase ("class of") de la clase
TSingleInst y clases derivadas.
Cubriremos los métodos de la clase en la sección de Implementación. El
otro único elemento que merece ser mencionado ahora es el campo
fEnsureRestoreMsg. El mismo se usa para almacenar el Id del mensaje
usado para solicitar a una aplicación que restaure y muestre su ventana.
El Id de mensaje es provisto por Windows y está garantizando que es
único. Desafortunadamente, el uso de ese mensaje significa que no
podemos usar el manejador de mensajes de Delphi para manejar el mensaje
y debemos recurrir a interceptar mensajes en el bucle de mensajes (ver
más abajo).
Finalmente la función SingleInst se usa para devolver una instancia del
objeto singleton TSingleInst (o descendiente) mientras que el
procedimiento RegisterSingleInstClass se usa para registrar el tipo de
la clase a ser usada para crear el objeto singleton.
Examinaremos la sección de Implementación en segmentos. He aquí el
primero:
implementation
uses
SysUtils, Forms;
var
// Globales almacenando singleton SingleInst y la clase de SingleInst
gSingleInst: TSingleInst = nil;
gSingleInstClass: TSingleInstClass = nil;
function SingleInst: TSingleInst;
begin
if not Assigned(gSingleInst) then
begin
if Assigned(gSingleInstClass) then
gSingleInst := gSingleInstClass.Create
else
gSingleInst := TSingleInst.Create;
end;
Result := gSingleInst;
end;
procedure RegisterSingleInstClass(Cls: TSingleInstClass);
begin
gSingleInstClass := Cls;
end;
Las variables globales privadas gSingleInst y gSingleInstClass almacenan
una referencia al objeto singleton y al tipo del objeto singleton (tal
como se registra en RegisterSingleInstClass) respectivamente.
De la implementación de SingleInst se puede ver que el objeto singleton
es creado la primera vez que el objeto se referencia. Si se registró una
clase derivada, ésta se usa para crear el singleton, de lo contrario se
usa la clase base. Esto significa que cualquier clase derivada de
TSingleInst debe ser registrada antes que el objeto sea accedido por
primera vez - se recomienda que RegisterSingleInstClass sea llamada en
la sección de Initialización de la unidad donde se define la clase
derivada. Esto también explica por qué el objeto singleton no se crea en
la sección de Inicialización de esta unidad, puesto que esta sección
sería llamada antes que las de las unidades de las clases derivadas.
Yendo a la definición de la clase, primero observemos el constructor de
la clase que simplemente registra a Windows el mensaje definido por el
usuario:
constructor TSingleInst.Create;
begin
inherited;
fEnsureRestoreMsg :=
RegisterWindowMessage('USINGLEINST_ENSURERESTORE');
end;
Hay varios "puntos de entrada" en la clase que deben ser llamados desde
la unidad principal o desde el archivo de proyecto. Los veremos a
continuación:
function TSingleInst.CanStartApp: Boolean;
var
Wdw: HWND;
begin
Wdw := FindDuplicateMainWdw;
if Wdw = 0 then
Result := True
else
Result := not SwitchToPrevInst(Wdw);
end;
procedure TSingleInst.CreateParams(var Params: TCreateParams);
begin
inherited;
StrPLCopy(Params.WinClassName, WdwClassName,
SizeOf(Params.WinClassName) - 1);
end;
function TSingleInst.HandleMessages(var Msg: TMessage): Boolean;
begin
if Msg.Msg = WM_COPYDATA then
begin
WMCopyData(Msg);
Result := True;
end
else if Msg.Msg = fEnsureRestoreMsg then
begin
EnsureRestore(Msg);
Result := True;
end
else
Result := False;
end;
El primero de estos "puntos de entrada" es CanStartApp, el que se llama
desde el archivo de proyecto e indica si la aplicación debe ser iniciada
o no. Funciona de modo similar a la función CanStart de la primera parte
de este artículo (publicada en el Boletín Pascal #50).
El método CreateParams establece el nombre de clase de ventana del
formulario principal actualizando los parámetros de creación del
formulario. El formulario principal debe redefinir su
TForm.CreateParamsSingleInst.CreateParams desde dentro de ese método.
El "puntos de entrada" más complejo es el método HandleMessages, que
intercepta el mensaje WM_COPYDATA y el campo fEnsureRestoreMsg del
formulario principal y maneja el procesamiento delegándolo a WMCopyData
y EnsureRestore respectivamente (ver más abajo). Esto método devuelve
verdadero si maneja el mensaje y falso en caso contrario. El formulario
principal debe redefinir el método TForm.WndProc y desde allí llamar a
SingleInst.HandleMessages, llamando su método TForm.WndProc heredado si
el método HandleMessages devuelve falso.
Examinemos ahora los métodos de soporte protegidos. Primero tenemos dos
métodos que deben ser redefinidos en clases descendientes:
function TSingleInst.WdwClassName: string;
begin
Result := 'SingleInst.MainWdw';
end;
function TSingleInst.WaterMark: DWORD;
begin
Result := 0;
end;
WdwClassName simplemente devuelve el nombre a usar como el nombre de
de ventana del formulario principal. Este debería ser redefinido para
devolver algo único a la aplicación. Similarmente, Watermark devuelve
0 como el valor de marca de agua (las marcas de agua se trataron en la
primera parte de este artículo -publicada en el Boletín Pascal #50-).
Este método debería ser redefinido para devolver algún valor inusual si
se emplearán marcas de agua.
Ahora siguen los dos métodos de soporte que manejan mensajes:
procedure TSingleInst.EnsureRestore(var Msg: TMessage);
begin
if IsIconic(Application.Handle) then
Application.Restore;
if Assigned(Application.MainForm) and not Application.MainForm.Visible
then Application.MainForm.Visible := True;
Application.BringToFront;
end;
procedure TSingleInst.WMCopyData(var Msg: TMessage);
var
PData: PChar;
Param: string;
begin
if TWMCopyData(Msg).CopyDataStruct.dwData = WaterMark then
begin
PData := TWMCopyData(Msg).CopyDataStruct.lpData;
while PData^ <> #0 do
begin
Param := StrPas(PData);
if Assigned(fOnProcessParam) then
fOnProcessParam(Param);
Inc(PData, Length(Param) + 1);
end;
Msg.Result := 1;
end
else
Msg.Result := 0;
end;
Nótese que estos métodos se basan bastante en los métodos de manejo de
mensajes tratados en la primera parte de este artículo, excepto que ya
no se implementan directamente en la unidad del formulario. El único
cambio significativo es que WMCopyData ahora invoca al evento
OnProcessParam en vez de llamar a un método fijo para procesar los
parámetros directamente.
Finalmente examinaremos los tres métodos protegidos restantes:
function TSingleInst.FindDuplicateMainWdw: HWND;
begin
Result := FindWindow(PChar(WdwClassName), nil);
end;
function TSingleInst.SendParamsToPrevInst(Wdw: HWND): Boolean;
var
CopyData: TCopyDataStruct;
I: Integer;
DataSize: Integer;
Data: PChar;
PData: PChar;
begin
DataSize := 0;
for I := 1 to ParamCount do
Inc(DataSize, Length(ParamStr(I)) + 1);
Inc(DataSize);
Data := StrAlloc(DataSize);
try
PData := Data;
for I := 1 to ParamCount do
begin
StrPCopy(PData, ParamStr(I));
Inc(PData, Length(ParamStr(I)) + 1);
end;
PData^ := #0;
CopyData.lpData := Data;
CopyData.cbData := DataSize;
CopyData.dwData := WaterMark;
Result := SendMessage(Wdw, WM_COPYDATA, 0, LPARAM(@CopyData)) = 1;
finally
StrDispose(Data);
end;
end;
function TSingleInst.SwitchToPrevInst(Wdw: HWND): Boolean;
begin
Assert(Wdw <> 0);
if ParamCount > 0 then
Result := SendParamsToPrevInst(Wdw)
else
Result := True;
if Result then
SendMessage(Wdw, fEnsureRestoreMsg, 0, 0);
end;
Estos métodos son análogos a las rutinas equivalentes en la primera
parte de este artículo y no serán descritos nuevamente aquí.
Modificaciones al archivo de proyecto
-------------------------------------
El archivo de proyecto debe pasar por un simple cambio para usar el
objeto SingleInst a fin de determinar si iniciar o no la aplicación.
Primero debe añadirse la unidad USingleInst al proyecto y luego se debe
modificar el archivo de proyecto para envolver la creación del
formulario y el código de ejecución de la aplicación en una sentencia
condicional, como sigue:
...
begin
if SingleInst.CanStartApp then
begin
Application.Initialize;
Application.CreateForm(TForm1, Form1);
Application.Run;
end;
end.
Modificación al formulario principal
------------------------------------
Se necesita más trabajo en la unidad del formulario principal. Primero,
agregue las siguientes declaraciones en la sección protegida de la clase
del formulario:
protected
procedure WndProc(var Msg: TMessage); override;
procedure HandleParam(const Param: string);
procedure CreateParams(var Params: TCreateParams); override;
Ahora implemente estos métodos para llamar a SingleInst como sigue:
procedure TForm1.CreateParams(var Params: TCreateParams);
begin
inherited;
SingleInst.CreateParams(Params);
end;
procedure TForm1.WndProc(var Msg: TMessage);
begin
if not SingleInst.HandleMessages(Msg) then
inherited;
end;
El método CreateParams llama al método heredado (inherited) y luego
llama a SingleInst.CreateParams para establecer el nombre de clase de
ventana. El método redefinido WndProc llama a SingleInst.HandleMessages
para determinar si el mensaje es uno de los manejados por SingleInst (la
función devuelve verdadero si maneja el mensaje). Si el mensaje no es
manejado por SingleInst.CreateParams se llama al método WndProc heredado
para manejarlo.
También queremos manejar el evento TSingleInst.OnProcessParam para que la
aplicación sea notificada cuando se pasen parámetros con un mensaje
WM_COPYDATA. En este ejemplo agregaremos los parámetros a un cuadro de
lista. Asignamos el manejador de evento en FormCreate, donde también
procesaremos los parámetros pasados al programa la primera vez que se
inicia:
procedure TForm1.FormCreate(Sender: TObject);
var
I: Integer;
begin
SingleInst.OnProcessParam := HandleParam;
for I := 1 to ParamCount do
HandleParam(ParamStr(I));
end;
procedure TForm1.HandleParam(const Param: string);
begin
ListBox1.Items.Add(Param);
end;
Redefiniendo TSingleInst
------------------------
Ahora veremos un ejemplo de como redefinir TSingleInst. Simplemente
proveemos una nueva marca de agua y un nuevo nombre de clase de ventana.
La unidad entera (UMySingleInst.pas) se lista abajo. El único punto a
notar es cómo se registra la nueva clase como la clase a usar para el
objeto singleton SingleInst.
unit UMySingleInst;
interface
uses
Windows,
USingleInst;
type
TMySingleInst = class(TSingleInst)
protected
function WdwClassName: string; override;
function WaterMark: DWORD; override;
end;
implementation
{ TMySingleInst }
function TMySingleInst.WaterMark: DWORD;
begin
Result := $DE1F1DAB;
end;
function TMySingleInst.WdwClassName: string;
begin
Result := 'DelphiDabbler.SingleInst.1';
end;
initialization
RegisterSingleInstClass(TMySingleInst);
end.
Conclusión
----------
Este artículo ha demostrado como asegurar que sólo una instancia de una
aplicación se ejecute. También demuestra cómo pasar los parámetros de
línea de órdenes a la instancia que ya está en ejecución, asegurando que
su ventana se muestre prominentemente.
El método usado es detectar la presencia de la clase de ventana de la
ventana principal de la aplicación entre las ventanas del nivel más
alto. La comunicación con la instancia previa se hace por medio de
mensajes enviados a la ventana principal de la instancia. En particular,
se usa una un mensaje definido por el usuario para asegurar que la
ventana se restaure y se haga visible, y se usa el mensaje WM_COPYDATA
para enviar los parámetros de línea de órdenes cruzando las fronteras de
los procesos.
Se provee el esqueleto de algo de código fuente para una aplicación que
corre como una única instancia.
Finalmente se presentó una clase reutilizable que puede ser usada
en el desarrollo de un programa que corra una única instancia de la
aplicación.
Se incluye también una aplicación demostrativa junto con el código
fuente que acompaña esta edición.
__________________
Peter Johnson es un programador hobbyista que vive en West Wales (Reino
Unido) y que "chapotea" en Delphi. Mantiene el sitio web DelphiDabbler
(http://www.delphidabbler.com/) donde publica sus artículos y sus
aplicaciones y componentes Delphi gratuitos. Una versión completa de
este artículo se encuentra disponible en:
http://www.delphidabbler.com/articles.php?article=13
________________________________________________________________________
JfControls Lib. Multilenguaje. Multiapariencia. Skins. Privilegios. Más
de 40 componentes integrados y personalizables. Múltiples problemas de
programación resueltos. Administración centralizada de recursos. Para
Delphi 3-2006 y C++ Builder 3-6. http://www.jfactivesoft.com/spindex.htm
________________________________________________________________________
3. Dentro de las clases e interfaces de Delphi (y II)
Por Ezra Hoch
La primera parte de "Dentro de las clases e interfaces de Delphi" se
publicó en el Boletín Pascal #49. Debería leerse antes de este artículo:
http://www.latiumsoftware.com/es/pascal/0049.php#4
En esta parte finalizaremos cubriendo la implementación de interfaces en
Delphi, y repasaremos unas conclusiones útiles.
Comencemos con un ejemplo en profundidad:
type
IInterface1 = interface
procedure ActA;
procedure ActB;
end;
IInterface2 = interface(IInterface1)
procedure ActC;
procedure ActD; stdcall;
end;
TSampleClass = Class(TInterfacedObject, IInterface1, IInterface2)
procedure ActA;
procedure ActB;
procedure ActC;
procedure ActD; stdcall;
end;
var
Interface1 : IInterface1;
Interface2 : IInterface2;
Sample : TSampleClass;
begin
Sample := TSampleClass.Create;
Interface1 := Sample;
Interface2 := Sample;
Interface1.ActA;
Interface1.ActB;
Interface2.ActA;
Interface2.ActB;
Interface2.ActC;
Interface2.ActD;
end;
En vez de ver el código compilado de este ejemplo, simplemente notaré
sus aspectos interesantes. Primero, al asignar un valor a Interface1,
esperaríamos que Delphi lo tome como la dirección apuntada por 'Sample',
más una cantidad específica ($10) y que eso sea todo. Al asignar un
valor a Interface2, esperaríamos que Delphi haga lo mismo, sólo que
sumaría ($0C) porque las interfaces se almacenan en memoria de la última
a la primera.
Pero Delphi no hace esto. Asigna tanto a Interface1 como a Interface2
la dirección apuntada por 'Sample' más $0C. Esto es porque IInterface2
hereda de IInterface1. Por lo tanto IInterface2 incluye Interface1, de
modo que cualquier llamada a Interface1 en realidad será ejecutada a
través de la lista de métodos de IInterface2.
Segundo, cuando llamamos a Interface1.ActA, se llama al cuarto método
de la lista de métodos de IInterface2 (porque IInterface2 hereda de
IInterface1 y a su vez hereda de IUnknown). Llamando a Interface1.ActB
se llama al quinto método de la lista de métodos de IInterface2.
Cuando llamamos a Interface2.ActA se llama al cuarto método de la lista
de métodos de IInterface2, al igual que Interface1.ActA. Esto es porque
IInterface2 hereda de IInterface1.
Tercero, cuando llamamos a Interface2.ActD, Delphi añade una
instrucción adicional antes de llamar al séptimo método de IInterface2.
Esto es porque hemos declarado el método con una convención diferente de
llamada (stdcall). Nótese que todos los métodos de IUnknown se definen
con la directiva stdcall.
La estructura del código de los métodos de la lista de métodos de una
interfaz siempre sigue la siguiente regla:
Primer método
.
.
Último método
Lista de métodos de la interfaz madre
En nuestro caso, el código de los métodos de la lista de métodos de
IInterface2 es como sigue:
ActC
ActD
// Lista de métodos de IInterface1
ActA
ActB
// Lista de métodos de IUnknown
QueryInterface
_AddRef
_Release
NOTA: La estructura de arriba es cómo se organiza el código de los
métodos en memoria, pero la primera entrada en una lista de métodos
pertenece a QueryInterface (el primer método de IUnknown), aunque
apuntará a un lugar en memoria (la implementación de ese método
QueryInterface específico de la interfaz) que está más arriba que la
implementación de los métodos propios de la interfaz. En nuestro caso,
la implementación del método QueryInterface de IInterface2 está más
arriba en memoria que la implementación del método ActB de
IInterface2, que a su vez está más arriba en memoria que la
implementación del método ActD, aunque ActD sea la séptima entrada en
la lista de métodos de IInterface2, ActB la quinta y QueryInterface la
primera.
Para entender acabadamente lo que sucede cuando Delphi llama a un
método de una interfaz, démosle un vistazo al código ensamblador de
las llamadas a los métodos de la lista de métodos de IInterface2 en el
ejemplo de arriba. El siguiente código es una copia exacta del código
compilado (excepto por los comentarios):
// ActC
add eax, -$0C
call TSampleClass.ActC
// ActD
add dword ptr [esp + $04], -$0C
call TSampleClass.ActD
// ActA
add eax, -$0C
call TSampleClass.ActA
// ActB
add eax, -$0C
call TSampleClass.ActB
// QueryInterface
add dword ptr [esp + $04], -$0C
call TInterfacedObject.QueryInterface
// _AddRef
add dword ptr [esp + $04], -$0C
call TInterfacedObject._AddRef
// _Release
add dword ptr [esp + $04], -$0C
call TInterfacedObject._Release
Como se recordará, un método de un objeto es una función o procedimiento
ordinario que acepta como primer parámetro una instancia de la clase del
método. Como puede notar, antes de cada llamada al método real (por ej.
"TSampleClass.ActD") hay una línea de código que cambia el valor de
"eax" o de "dword ptr [esp + $04]", dependiendo de la convención de
llamada. Como puede notarse, en todos los casos se resta $0C de una
variable. Pero, ¿por qué 12 ($0C = 12)? Porque resulta que esta interfaz
(IInterface2) está en el tercer lugar después del puntero a la VMT de la
clase TSampleClass (FRefcount e IUnknown están antes). Por consiguiente,
el valor de cualquier instancia de IInterface2 de TSampleClass
(Interface2 por ejemplo) es en realidad el valor del puntero a la
instancia de la clase más 12.
Aquí hay otro ejemplo que ayudará a entender la sección de arriba. El
siguiente código continúa las definiciones del código de arriba:
type
IAnotherInterface = interface
procedure ActE;
end;
TAnotherSample = class(TInterfacedObject, IInterface2,
IAnotherInterface)
procedure ActA;
procedure ActB;
procedure ActC;
procedure ActD; stdcall;
procedure ActE;
end;
var
Interface2: IInterface2;
begin
Interface2:= TAnotherSample.Create;
Interface2.ActC;
end;
Ahora comparemos la entrada para este ejemplo de IInterface2 y el
anterior:
// IInterface2 de TAnotherSample:
add eax, -$10
call TAnotherSample.ActC
// IInterface2 de TSampleClass:
add eax, -$0C
call TSampleClass.ActC
Hay dos cambios obvios:
a) La función real que es llamada (TAnotherSample.ActC o
TSampleClass.ActC)
b) La cantidad por la que se modifica EAX. Nótese que al cambiar
IInterface2 de TAnotherSample, EAX se desplaza en 16 ($10 = 16), en
vez de ser desplazado en 12. Esto es porque en TAnotherSample,
IInterface2 es la segunda interfaz en la estructura de la instancia
en memoria, y por consiguiente está "más lejos" que la instancia
misma y debe desplazarse 4 bytes adicionales.
Ahora veamos algunas cosas útiles.
Primero, si quiere chequear si dos (o más) variables de interfaz son de
la misma instancia, no puede simplemente compararlas, incluso si son del
mismo tipo. Debe "QueryInterfacearlas" (convertirlas) a un mismo tipo de
interfaz, y luego comparar. Como regla general, si desea comparar
interfaces, conviértalas a IUnknown y luego compare.
Ejemplo:
type
IBooA = interface
end;
IBooB = interface
end;
TBoo = class(TInterfacedObject, IBooA, IBooB)
end;
var
Boo : TBoo;
BooA : IBooA;
BooB : IBooB;
begin
Boo := TBoo.create;
BooA := Boo;
BooB := Boo;
// Esto no compilará
if BooA = BooB then
begin
Beep;
end;
if Integer(BooA) = Integer(BooB) then
begin
// Nunca llegará aquí
Beep;
end;
if IUnknown(BooA) = IUnknown(BooB) then
begin
// Nunca llegará aquí
Beep;
end;
// La palabra "as" es la mismo que QueryInterface al actuar con
// interfaces
if (BooA as IUnknown) = (BooB as IUnknown) then
begin
// Siempre llegará aquí
Beep;
end;
end;
Explicación: La primera comparación no compilará porque BooA y BooB son
de dos tipos diferentes. La segunda y la tercera comparación compilarán,
pero nunca devolverán verdadero. Esto es porque la conversión de tipos
(typecasting) no cambiará el valor de la variable que está siendo
convertida. Sólo permite al compilador compilar el código aunque haya
dos tipos diferentes involucrados. He aquí que, si BooA es diferente de
BooB, la comparación nunca devolverá verdadero, sin importar qué
conversión de tipos se les hagan.
Pero, ¿por qué BooA y BooB tienen diferentes valores si ambas fueron
asignadas con la sentencia ":= Boo;". La respuesta es simple. Recuerde
cuando dije que el valor de una variable de interfaz es en realidad el
valor de la instancia misma (en realidad es el valor del puntero a la
instancia) más un número por cada interfaz- En nuestro caso, BooA es
lo mismo a lo que apunta Boo, más 16. Y BooB es lo mismo a lo que Boo
apunta, más 12. Por eso es que BooA y BooB no son lo mismo.
La cuarta comparación sí funciona. Esto es porque si una interfaz es
del mismo tipo, entonces compararla con otra interfaz del mismo tipo
devolverá el resultado esperado (si ambas interfaces fueron adquiridas
a través de QueryInterface, no por conversión de tipos). Es así porque
si son del mismo tipo, entonces la diferencia entre ambas y la instancia
es la misma. Y si son de la misma instancia, entonces deberían ser
iguales.
Esto es, cada interfaz es igual a su instancia más un desplazamiento
Delta específico (el Delta depende de la interfaz). En otras palabras,
Interfaz = Instancia + Delta. Si Instancia es la misma para ambas
interfaces, y el Delta es el mismo (porque son del mismo tipo de
interfaz), entonces ambas interfaces serán iguales.
Nota: Esta es la forma en que Delphi trabaja, para bien o para mal.
Debería tomar esto en cuenta al escribir código para propiedades de
tipo interfaz. El siguiente código no funcionará apropiadamente:
TSample = class
private
FData : IUnknown;
procedure SetData(Value : IUnknown);
protected
procedure Changed; virtual; abstract;
public
property Data : IUnknown read FData write SetData;
end;
procedure TSample.SetData(Value : IUnknown);
begin
// Esto es incorrecto.
if Value <> FData then
begin
FData := Value;
Changed;
end;
end;
Puede parecer que ese código debería funcionar, pero no funcionará
cuando alguien asigna la propiedad Data con un IUnknown obtenido por
simple conversión de tipos. El código correcto debería ser:
procedure TSample.SetData(Value : IUnknown);
begin
if (Value as IUnknown) <> (FData as IUnknown) then
begin
FData := Value;
Changed;
end;
end;
Segundo, una interfaz declarada como implementada por una clase (con
excepción de las interfaces que herede de otras interfaces) significa
que cada instancia de aquella clase tomará 4 bytes más de memoria. Puede
parecer poco (y probablemente lo es) excepto en un caso. Considere el
siguiente código:
IInterfaceA = interface
end;
IInterfaceB = interface
end;
TSampleClass1 = class(TInterfacedObject, IInterfaceA)
end;
TSampleClass2 = class(TSampleClass1, IInterfaceA, IInterfaceB)
end;
Podría parecer que cada instancia de TSampleClass1 debería ocupar 16
bytes, y que cada instancia de TSampleClass2 debería ocupar 20 bytes
(4 bytes más, porque soporta una interfaz más). Este no es el caso.
Cada instancia de TSampleClass1 sí ocupa 16 bytes, pero cada instancia
de TSampleClass2 ocupa 24 bytes. Esto es porque Delphi crea una entrada
de interfaz incluso para interfaces que ya están implementadas en la
clase madre.
La solución a esto es simple. Sólo remueva la declaración de
IInterfaceA en TSampleClass2. Esto no cambiará el hecho de que
TSampleClass2 implementa IInterfaceA, porque TSampleClass2 hereda de
TSampleClass1, la que implementa IInterface1. Esto no habría sucedido
si IInterfaceB fuera un descendiente de IInterfaceA.
Esto podría sumar mucho si realiza su herencia inapropiadamente. Por
ejemplo:
TSampleClass1 = class(TInterfacedObject, IUnknown)
end;
TSampleClass2 = class(TSampleClass1, IUnknown)
end;
TSampleClass3 = class(TSampleClass2, IUnknown)
end;
TSampleClass4 = class(TSampleClass3, IUnknown)
end;
TSampleClass5 = class(TSampleClass4, IUnknown)
end;
Cada instancia de TSampleClass5 ocupará 32 bytes de memoria, a pesar que
no tiene datos reales (excepto por FRefCount de TInterfacedObject).
________________________________________________________________________
Ayúdanos a conseguir más suscriptores votando por el Boletín Pascal
(Pascal Newsletter) en estos rankings:
http://www.programmingpages.com/?r=latiumsoftwarecomenpascal
http://top100borland.com/in.php?who=20
________________________________________________________________________
4. Enumerando todos los recursos de una red LAN
Desde Lima, Perú, Furious Logic nos envía un programa que enumera todos
los recursos de una LAN.
Como puede observarse en el código fuente del programa, que se adjunta
a esta edición, el núcleo del programa es un procedimiento (MostrarRed)
que hace uso de la API WNetEnumResource para enumerar los recursos de
la red. Antes de llamar a WNetEnumResource es necesario obtener un
handle llamando a la API WNetOpenEnum, y al final debemos liberarlo con
una llamada a la API WNetCloseEnum.
El proceso obtiene la dirección IP de un recurso con la función
GetHostByName, la que se pasa como parámetro a la función inet_ntoa
para convertirla en una cadena en formato www.xxx.yyy.zzz, que es lo
que finalmente se muestra.
En caso que un recurso sea a su vez un contenedor de recursos, el
procedimiento se llama recursivamente a sí mismo para enumerar los
recursos del contenedor, y así hasta el máximo nivel de anidamiento.
Otro aspecto a destacar es que el procedimiento corre en un hilo de
ejecución (thread) diferente del programa principal, una sana práctica
para no congelar el programa mientras dura el proceso de detección.
En el Boletín Pascal #53 presentaremos otro aporte de Furious Logic.
________________________________________________________________________
5. Foros / listas de correo
Recordamos a los suscriptores las direcciones de nuestros foros. Para
unirse a algún foro, lo más recomendable es hacerlo desde la web para
así tener acceso a todas las áreas del foro y la configuración de las
opciones de suscripción, pero también es posible suscribirse por email.
Para suscribirse desde la web es necesario poseer un ID de Yahoo! (si
no tienes el tuyo, puedes conseguirlo gratis registrándote como usuario
de Yahoo!).
* Delphi-abierto. Programación en Delphi (todos los niveles). Si estás
en la etapa de aprendizaje o si no te agradan los foros discriminados
por niveles, este foro es para ti.
http://espanol.groups.yahoo.com/group/delphi-abierto
Suscripción:
http://espanol.groups.yahoo.com/group/delphi-abierto/join
delphi-abierto-subscribe@gruposyahoo.com
* Delphi-intermedio. Programación en Delphi (nivel intermedio). Si ya
sabes mucho de Delphi, pero todavía te falta un largo trecho para ser
un gurú (o no tanto), este foro es para ti.
http://espanol.groups.yahoo.com/group/delphi-intermedio
Suscripción:
http://espanol.groups.yahoo.com/group/delphi-intermedio/join
delphi-intermedio-subscribe@gruposyahoo.com
* Delphi-avanzado. Programación en Delphi. Sólo para gurús.
http://espanol.groups.yahoo.com/group/delphi-avanzado
Suscripción:
http://espanol.groups.yahoo.com/group/delphi-avanzado/join
delphi-avanzado-subscribe@yahoogroups.com
* GrupoKylix. Programación en Kylix.
http://espanol.groups.yahoo.com/group/GrupoKylix
Suscripción:
http://espanol.groups.yahoo.com/group/GrupoKylix/join
GrupoKylix-subscribe@yahoogroups.com
* FreePascal-es. Programación en Free Pascal (freepascal.org).
http://espanol.groups.yahoo.com/group/freepascal-es
Suscripción:
http://espanol.groups.yahoo.com/group/freepascal-es/join
freepascal-es-subscribe@yahoogroups.com
* Desarrolladores-Software. Un lugar para tratar todos aquellos temas
relacionados con el desarrollo de software y su comercialización, y
para compartir experiencias en el ámbito laboral, profesional o
comercial con otros.
http://es.groups.yahoo.com/group/desarrolladores-software
Suscripción:
http://es.groups.yahoo.com/group/desarrolladores-software/join
desarrolladores-software-subscribe@yahoogroups.com
* Componentes. Un foro para buscar/recomendar componentes de software
(componentes VCL y CLX, objetos ActiveX, librerías DLL, etc.), así
como utilidades, tutoriales, información, etc.
http://espanol.groups.yahoo.com/group/componentes
Suscripción:
http://espanol.groups.yahoo.com/group/componentes/join
componentes-subscribe@yahoogroups.com
________________________________________________________________________
Delphi BUGS?
Catch & Log every BUG showing Unit, Class, Method, Line #.
Now with support for IntraWeb applications and Anti-Freeze feature.
http://www.eurekalog.com/bannerclick.php?id=15
________________________________________________________________________
6. Delphi en la Red
Por Dave Murray <irongut at vodafone dot net>
Componentes, librerías y aplicaciones
=====================================
Shareware / Comercial
---------------------
* KylixDriver v1.1 - by ET Kimberliteware Ltd ($39 / $69 with source)
KylixDriver is a RAD Kylix-oriented and integrated toolkit for PC
hardware access. This toolkit can be efficiently used for writing
Linux device drivers for ISA and PCI hardware.
http://etsoftware.tripod.com/products.html
* Delphi SWF SDK (Standard) v1.4 - by FeatherySoft ($170)
Object Pascal library for creating SWF files, without using of any
external dynamic libraries. Released features: visual objects (shape,
button, text, morphing shape, sprite); all types of filling (solid,
gradient, image); device and embedding fonts; action commands;
sound (events, streaming); video; any transition and transformation.
http://www.delphiflash.com/
Freeware
--------
* PGP Components for Delphi v4.0 - Michael in der Wiesche (with source)
These sources provide a Delphi (2-7) direct interface to PGP requiring
a preceding full installation of PGP 6.5.x, 7.x or 8.x. Features
include: Encoding and decoding (encrypt/decrypt/sign/verify); Creating
and verifying file detached signatures; Key management; Key generation
(DH/DSS, RSA); X509 Certificate support; Keyserver functions.
http://home.t-online.de/home/idw.doc/PGPcomp.htm
* Synapse TCP/IP Library v.34 - by Lukas Gebauer (with source)
TCP/IP library for Delphi, Kylix and FreePascal using blocking
sockets. Contains simple non-visual objects for easy programming of
command line utilities, visual projects, NT services, etc. New:
FreePascal 1.9.4 support; Experimental Delphi 8 support; Optional
support for ICONV library; New flexible FTP directory listing parser.
http://synapse.ararat.cz/
* TPJDropFiles + TPJFormDropFiles v4.1 - by Peter Johnson (with source)
Two components that catch files dragged and dropped from Explorer.
TPJFormDropFiles provides a window that can contain other controls and
catch any files dropped anywhere on it or child controls. TPJDropFiles
is a non-visual component that subclasses a form to catch files that
are dropped anywhere on the form.
http://www.delphidabbler.com/software.php?id=dropfiles
* Merkes' Tiny Hex Editor v1.5.0.10 - by Merkes Pages
A free hex editor for binary files. Allows you to edit multiple files
(mdi), disk sectors and virtual memory of other processes. Tiny Hex
Editor is scriptable, lets you view data structures and has a plugin
interface for third party extensions.
http://www.sourcecodeonline.com/details/merkes__tiny_hex_editor.html
Actualizaciones de productos Borland
------------------------------------
* Public Beta: Delphi 7.1 Update - Database Supplemental
This is a public beta of database runtime files that address defects
introduced in the Delphi 7.1 update.
http://community.borland.com/article/0,1410,32492,00.html
Artículos, trucos y consejos
============================
* Interview with Danny Thorpe about Diamondback
Danny Thorpe talks about the next Delphi release.
http://community.borland.com/article/0,1410,32708,00.html
* Interview with Corbin Dunn about the Diamondback IDE
Corbin Dunn, Software Engineer, Research and Development at Borland,
talks about the Delphi IDE.
http://community.borland.com/article/0,1410,32719,00.html
* Borland "Diamondback" Data Services over .NET Remoting
Details on data remoting with the BorCon preview edition of
"Diamondback", the next version of Delphi.
http://community.borland.com/article/0,1410,32718,00.html
* Diamondback Preview License Update
A license update that does not require an NDA or Beta Agreement.
http://community.borland.com/article/0,1410,32717,00.html
* BDNtv: Diamondback Preview of Data Remoting
Demonstrates the ease of remoting data in a heterogeneous database
environment with Diamondback. Includes setting up a local DataHub for
SQL Server and InterBase then making it a remote server. And, creating
a client that updates tables in both databases simply by calling one
method of the DataHub component. Flash
http://dn.codegear.com/article/32714
* BDNtv: Diamondback Sneak Peek
A sneak peek at Diamondback's new IDE features and the new Delphi
language feature for enumeration. The multiple personality IDE,
refactoring for both .NET and Win32, Error Insight, Help Insight, the
History View and more are shown. The for .. in .. do (foreach)
enumerator syntax is also revealed. Flash
http://dn.codegear.com/article/32715
* Delphi 8 and Microsoft .NET version 1.1 Service Pack 1
Delphi 8 has trouble compiling projects after .NET 1.1 Service Pack 1
has been installed. This article explains why and offers a workaround.
Also affects the BorCon Diamondback preview release.
http://community.borland.com/article/0,1410,32713,00.html
* Borland CEO Touts Software Process Management
InfoWorld Editor-at-Large Paul Krill spoke with Dale Fuller, president
and CEO of Borland, at the BorCon conference last week about Borland's
tools and ALM strategies and issues such as Java vs. .Net, Web
services, and outsourcing.
http://www.computerworld.com.au/index.php/id;954592276;fp;16;fpid;0
* Interview: Borland Aims for Better Code
Better collaboration tools are the only route to superior software,
argues Borland's David Intersimone.
http://www.computing.co.uk/analysis/1157073
* DB2 Web Service Engines on Linux with Kylix 3: Part 1 - by Bob Swart
Demonstrates how to build a SOAP Web service engine with Kylix 3,
exposing the data from DB2 UDB database tables to the outside world.
www-106.ibm.com/developerworks/db2/library/techarticle/dm-0406swart/
* DB2 Web Service Engines on Linux with Kylix 3: Part 2 - by Bob Swart
Demonstrates how to build the user interface for a SOAP Web service
engine with Kylix 3 on Linux, exposing the data from DB2 UDB database
tables to the outside world.
www-106.ibm.com/developerworks/db2/library/techarticle/dm-0407swart/
* Producing Dynamic Data-Entry Forms from DB2 Tables on Linux - B. Swart
Uses Kylix 3 and dbExpress to analyze DB2 UDB database tables, fields
(names and types) to allow the user to select a specific table, toggle
which fields are shown, and dynamically view the output in both a
datagrid and individual data-aware controls.
www-106.ibm.com/developerworks/db2/library/techarticle/dm-0407swart2/
* Use Delphi Code to Create/Drop DB2 UDB Database Tables - by Bob Swart
Examines the design and implementation of a Delphi application you can
use to create or delete / drop tables inside IBM DB2 databases. It
provides several examples of sending SQL DDL to the DB2 DBMS using
Delphi and the cross-platform dbExpress data access technologies.
www-106.ibm.com/developerworks/db2/library/techarticle/dm-0409swart/
* Work with IBM DB2 databases and SQL in Delphi for .NET - by Bob Swart
Using Delphi code to create/drop DB2 database tables, focuses on the
use of SQL queries to build simple and more complex SQL SELECT queries
to end up with master-detail relations. Also examines SQL joins in
detail, covering examples of inner joins, left/right outer joins, and
the differences between them.
www-106.ibm.com/developerworks/db2/library/techarticle/dm-0409swart1/
Tutoriales y capacitación
=========================
* Free Web Seminars
More than 10 on-demand Web seminars from Borland to help you optimize
your software delivery.
http://community.borland.com/article/0,1410,32698,00.html
Noticias
========
* Borland Delphi 2005 Boosts Microsoft Windows Productivity
Borland today announced Delphi 2005, previously codenamed Diamondback.
Delphi 2005 combines Win32, .NET, Delphi and C# support all within one
environment, significantly advances developer and team productivity
and integrates with Borland's leading ALM solutions.
http://www.tmcnet.com/usubmit/2004/Oct/1081925.htm
* Software Delivery Strategy Gets Under Way at Borland
Kicking off its Software Delivery Optimization campaign, Borland
announced upgrades to CaliberRM requirements management and StarTeam
configuration management software at BorCon. Also at the conference,
the company demonstrated the next version of its Delphi IDE for
Windows application development.
http://sdtimes.com/news/111/story7.htm
* Borland Scheme Aims to Maximise Business Value of Software Work
Borland aims to turn software development into a simple business
process with its Software Delivery Optimisation programme, announced
at the BorCon 2004 earlier this month.
http://www.computerweekly.com/articles/article.asp?liArticleID=133397
* Borland Moving Forward with SDO
Borland took a new direction this week, with the announcement of
Software Delivery Optimization. SDO will see three technology concepts
delivered around Borland's ALM tools, as the company tries to lure
C-level executives and vice presidents of application development with
a message that software and the business should - and can - function
as one.
http://www.computerwire.com/industries/research/?
pid=339DBE5D-36C4-4893-9BFF-0CA01C3EEC0B
* (Turn and Face the Strain) Software Changes
Borland this week stood atop its soapbox preaching the evils of
software projects gone awry, with projects beset by issues such as
last-minute changes and differing perspectives on the potential
success of development efforts. To stem the tide of botched projects,
Borland pitched its Software Delivery Optimization strategy.
http://weblog.infoworld.com/techwatch/archives/000712.html
* Borland Adds Project-Management Features To CaliberRM
Borland announced CaliberRM 2005 this week, a product designed to help
software project managers take some of the guesswork out of software
development. New features include tools for estimating the cost,
scheduling and staffing of a project before any code gets written.
http://informationweek.com/story/showArticle.jhtml?articleID=47208433
* Business Management for Software Projects
End users will be able to manage software projects like a business
with Borland's Software Delivery Optimisation. It aims to enable users
to manage software projects like a business, according to Boz Elloy,
senior vice-president of software products.
http://www.borland.com/us/company/software_delivery.html
* Borland challenges Visual Studio with Diamondback
With the Diamondback release of its Delphi tool for Windows
applications, Borland will challenge Microsoft while accommodating
.Net, Win32 and Delphi development. Michael Swindell, Borland director
of product management for developer tools, said with Diamondback
Borland will compete with Microsoft's Visual Studio.
http://www.infoworld.com/article/04/09/13/Hndelphidiamondback_1.html
* Borland Touts Software Delivery Optimization
At BorCon, Borland will reveal its software delivery optimization
strategy, which leverages the company's ALM and developer products to
ease software development and maintenance. The strategy ultimately
will feature a bundle of the company's products code-named Themis, due
out in the first half of 2005, which purports to provide a platform
for integrated, repeatable development processes.
http://www.javaworld.com/javaworld/jw-09-2004/jw-0913-iw-borland.html
* Borland Outlines Vision for Transforming Software Development
Today at BorCon 2004, Dale Fuller, President and CEO of Borland,
presented Borland's vision and product strategy for transforming
software development from an unpredictable art form into a more
manageable and repeatable business process. Borland's vision for
Software Delivery Optimization builds on the technical efficiencies of
ALM, and incorporates the business processes and management
capabilities companies seek to ensure business-to-IT alignment, and
the delivery of quality software, on time, within budget, for maximum
business value.
http://home.businesswire.com/portal/site/google/index.jsp?
ndmViewId=news_view&newsId=20040913005322&newsLang=en
* Borland and NEC Team on Online Communications
Borland and NEC will partner to develop adaptor software in order to
rapidly integrate web-based applications with voice and video. This
will target communications over IP telephony, IP video and
conferencing over online applications.
http://www.cbronline.com/article_news.asp?
guid=2FE9728E-9350-49C4-BC59-2C25C62987BE
* Borland Acquires Software Project Planning Tool
Borland has acquired of Estimate Professional, a software project
planning and estimation tool from Software Productivity Center. This
newly acquired tool will be embedded within the next version of the
Borland CaliberRM requirements management solution.
http://www.infoworld.com/article/04/08/25/HNborlestimate_1.html
* Borland Joins ECMA to Help Shape Standards for the .NET Framework
Borland has been elected as a member of ECMA International. As a
member of ECMA, Borland will help shape standards for the .NET
Framework and the C# and C++ programming languages.
http://home.businesswire.com/portal/site/google/index.jsp?
ndmViewId=news_view&newsId=20040812005195&newsLang=en
* Borland Developer News - .NET Edition, August 2004
Your source for Delphi and C# related news. Covering mostly .NET with
some Win32 development.
http://community.borland.com/article/0,1410,32491,00.html
________________________________________________________________________
Irongut's Delphi Pages
Dedicada a la programación con Borland Delphi y Kylix. Tenemos artículos
sobre programación, noticias Borland y Delphi, código fuente y componen-
tes para usar en sus aplicaciones y más. http://www.paranoia.clara.net/
________________________________________________________________________
¡Tú puedes ayudarnos!
Por favor danos una mano y ayúdanos a llegar a los 20.000 suscriptores
en los próximos meses. Una forma en que puedes ayudarnos es enviando
este enlace a tus amigos:
http://www.latiumsoftware.com/es/pascal/index.php
boletin-pascal-subscribe@gruposyahoo.com
Otra forma es votándonos en alguno de estos rankings para darle más
visibilidad a nuestro sitio web y aumentar así el número de suscrip-
ciones al boletín:
http://www.programmingpages.com/?r=latiumsoftwarecomenpascal
http://top100borland.com/in.php?who=20
Por favor vota. Son sólo unos segundos para ti que REALMENTE pueden
hacer la diferencia. Necesitamos tu ayuda para poder continuar.
________________________________________________________________________
Si no has recibido el archivo con el código fuente completo de los
ejemplos que se presentan en este boletín, puedes descargarlo de la
siguiente dirección: http://www.latiumsoftware.com/es/file.php?id=p51
________________________________________________________________________
Página principal: http://www.latiumsoftware.com/es/pascal/index.php
Página del grupo: http://espanol.groups.yahoo.com/group/boletin-pascal/
Para suscribirse / apuntarse: boletin-pascal-subscribe@gruposyahoo.com
Para cancelar / removerse: boletin-pascal-unsubscribe@gruposyahoo.com
Para reportar problemas con la suscripción: eds2008 @ latiumsoftware.com
________________________________________________________________________
Este boletín se provee "TAL Y COMO ESTA", sin garantía de ninguna clase.
Su uso implica la aceptación de nuestros términos de licencia y de la
ausencia de garantía que puedes leer en nuestro sitio web. Allí también
encontrarás una nota sobre marcas registradas. Te animamos a que redis-
tribuyas este boletín, siempre y cuando lo hagas en forma completa
(incluyendo la información de copyright), sin modificaciones y de manera
gratuita. Los artículos son copyright de sus respectivos autores y se
reproducen aquí con el permiso de los mismos.
________________________________________________________________________
Latium Software http://www.latiumsoftware.com/es/index.php
Irongut's Delphi Pages http://www.paranoia.clara.net/
Copyright 2004 by Ernesto De Spirito + Dave Murray. All rights reserved.
________________________________________________________________________
|
