Code Conversion Guide/es

From Free Pascal wiki
Jump to: navigation, search

Deutsch (de) English (en) español (es) français (fr) Bahasa Indonesia (id) 日本語 (ja) português (pt) русский (ru) slovenčina (sk)

Contents

Guía de conversión de código

   Esta página trata sobre cómo trasladar o convertir código existente en Delphi o Kylix para que trabaje con el compilador Free Pascal (FPC) y el IDE Lazarus. Aunque Lazarus y el Free Pascal Compiler tienen aspectos en común con Delphi y Kylix, no son clones. Hay numerosas diferencias en las llamadas a librerías y en las convenciones utilizadas... y en muchas otras áreas, FPC es más rico y puede ser más exigente sobre la corrección de la sintaxis. Por favor lee Lazarus para usuarios de Delphi una guía descriptiva de muchas de las diferencias de funcionamiento.

   El propósito de esta guía es documentar algunas diferencias específicas que son frecuentes encontrar en el proceso de conversión de código al trasladar código existente desde Delphi a FPF/Lazarus.

   Este documento se ha ubicado en la zona de 'wiki base de conocimientos' por lo que puede ser fácilmente ampliado por cualquiera que se haya tropezado con un problema singular y quiera poner su experiencia en común con otras personas.

Seleccionar un componente o librería para convertir

Dónde encontrar código para convertir

   Existe una gran cantidad de código disponible en la red que puede ser convertido para el uso con FPC y Lazarus. Esta página Page Of Code Sites es sólo un comienzo. Por favor, añada cualquier ubicación buena que conozca. TurboPower Software ha publicado recientemente la totalidad de su oferta comercial bajo la licencia MPL. Una lista de los paquetes disponibles se encuentra aquí.

   Para evitar duplicar esfuerzos, los paquetes que ya han sido convertidos están listados en la página Componentes y código de ejemplo. Si has convertido un paquete o estás trabajando en ello, haz una reseña en la página Proyecto actualmente en conversión.

Licencias

   Las licencias del código existente varían desde libre/dominio público hasta versiones restrictivas que prohiben modificar, redistribuir y el uso comercial. Antes de convertir un un paquete, es conveniente examinar los téminos de su licencia y asegurarse de que es compatible con Lazarus y FPC. La selección de la licencia es especialmente importante con componentes, cuya mera ubicación en un formulario puede imponer una licencia no deseada o incompatible para toda la aplicación.

   Cuando conviertas componentes, respeta los términos del autor original y mantén todos los derechos de autor y los encabezados de licencia con sus direcciones de correo y url. Es cortés y a veces muy útil informar al autor de que sus componente va a ser convertido... especialmente si el componente está bajo una licencia restrictiva. Un interés renovado sobre un componente antiguo u olvidado a menudo incita al autor a revisar las restricciones de la licencia original.

   En general, Dominio Público (software libre), y LGPL/MPL son las más flexibles para distribuir componentes. Para más información, Definición de Fuentas Abiertas (Open Source) es un buen sitio para empezar. Asimismo hay varias comparaciones disponibles para ayudar a clarificar el impacto que los diversos tipos de licencias de obra pueden tener sobre el código que está relacionado con el mismo. Busca sobre los términos "licencia de fuente abierta comparación"

Dependencias

   Otro punto previo al comienzo del trabajo de conversión, es verificar que el código no tiene una profunda dependencia de otros paquetes que podrían no estar disponibles o representan un reto considerable de conversión. Algunos desarrollos de código libre son extensiones de paquetes propietarios/cerrados, que a menudo ya no están disponibles o lo están bajo licencias inapropiadas.

Acerca del compilador

   Ver:

Acerca de Sistemas Operativos y Plataformas

   Lazarus y el Compilador Libre de Pascal son herramientas multiplataforma y multiarquitectura de desarrollo cruzado, es decir lo escrito en una plataforma puede compilarse ¡y funcionar! en otra. Por contra mucho código Delphi existente ha sido diseñado específicamente para correr sobre la plataforma Intel+Win32. Si el componente candidato tiene mucho código específico win32, tal vez sea más conveniente buscar otra alternativa menos dependiente de la plataforma. Pero no te detengas por ello... ¡es verdaderamente sorprendente lo que el LCL soporta!

Convirtiendo

Configurando el entorno de Lazarus para un proyecto de conversión

Crear un proyecto de prueba

  • Poner el código a convertir en un subdirectorio (convertdir, por ejemplo)
  • Desde Lazarus crear un proyecto nuevo.
  • Guardar (Archivo->Guardar Todo) en el subdirectorio convertdir. Poner nombres significativos a este proyecto y a su unidad principal es optativo.
  • Abrir la unidad principal del proyecto a convertir.
  • Añadirla al proyecto: Proyecto->Añadir archivo del Editor al Proyecto
  • Utilice Herramientas->Chequeo Rápido de la sintaxis o bien Ejecutar->Construir todo para empezar.

Cuestiones iniciales a tener en cuenta

  • Las series 1.0.x del compilador distinguen en los nombres de fichero mayúsculas y minúsculas. Si se trabaja con esta versión, es conveniente poner todos los nombres en minúsculas. En caso contrario se producirá el error "Archivo no encontrado"

Código fuente Delphi VCL y Kylix CLX en Lazarus

   Al convertir código fuente Delphi / Kylix, a menudo es útil mirar la declaración para comprobar lo que hace una función concreta. El IDE de Lazarus puede analizar el código Delphi / Kylix. Para ello es necesario configurar las opciones del compilador y las rutas de búqueda. Esto hace más fácilmente utilizando plantillas de proyecto: Entorno->Definir editor de CodeTools->Insertar plantilla.

Problemas de conversión y soluciones

Equivalencia de archivos entre Delphi / Kylix y Lazarus

Delphi / Kylix Descripción Lazarus Descripción
.pas

.dfm/.xfm,

.dcu/.dpu,

.dpr(main project file),

.res,

.dof/.kof

---

---

---

Delphi Source File,

Delphi Form,

Delphi Compiled Unit,

Delphi Project,

Windows Resource File,

Delphi Option File

.pas, .pp

.lfm,

.o,

.lpr

---

---

.lrs,

.lpi(main project file),

.ppu

Pascal unit file,

Form data file,

Compiled unit file,

Project file,

Resource file,

Project options file,

Lazarus resource file,

Lazarus project information file,

FPC unit description file


   Así pués un archivo .dcu de Delphi contiene, más o menos, la información de los archivos .o y .ppu de FPC. Un .ppu es principalmente la cabecera (interfaz), y el .o la parte de la implementación. Las funciones "en línea" (inline) que residen en el .ppu, son la principal excepción a esta regla.

Convirtiendo proyectos/formularios/unidades de Delphi a Lazarus

   Utiliza la herramienta de conversión de las nuevas versiones de Lazarus para la conversión automática. La mayoría de las funciones se explican más adelante en esta página. Más información aquí:

 http://wiki.lazarus.freepascal.org/Delphi_Converter_in_Lazarus

   El siguiente texto explica las diferencias entre Delphi y Lazarus y cómo convertir manualmente.

   Cambia el nombre o copia el archivo .dpr a un .lpr. Comenta o elimina la directiva
{$R *.res}
y añade la directiva
{$mode delphi}{$H+}
o bien esta otra
{$mode objfpc}{$H+}
en el .lpr. El IDE de Lazarus ayuda en esta cuestión en la opción del menú Herramientas "Convertir proyecto de DElphi a proyecto de Lazarus...". En ella se pide un .dpr (proyecto Delphi) y lo convierte en un .lpr; además, crea el archivo. lpi archivo y convierte todas las demás unidades.

   Muchos formularios de Delphi se pueden convertir para trabajar en Lazarus utilizando el asistente del IDE, que se encuentra en el menú Herramientas como tema "Convertir archivo DFM a LFM". Utilice el diálogo, seleccione el dfm y el convertidor hará el resto.

   Si necesitas convertir una unidad (con o sin formulario), Lazarus incluye una opción "Convertir unidad de Delphi a unidada de Lazarus" que haá por tí lo siguiente:

  1. poner en minúsculas los nombre de archivo de inclusiones y de la sección uses.
  2. convierte el .dfm a .lfm (normalmente sin comprobar el contenido, únicamente el formato)
  3. crea un .lrs vacío (el contenido se creará después)
  4. añade la directiva
    {$mode delphi}
  5. sustituye la referencia a la unidad windows por LCLIntf
  6. añade la unidad LResources si es preciso (si se usa .lrs se pondrá
    uses LResources
    en la sección de implementación)
  7. elimina las unidades variants
  8. elimina la directiva
    {$R *.dfm}
  9. crea la sección de iniciación y añade en ella la directiva
    {$i unit.lrs}

   Esto permite una rápida y fácil conversión de la mayoría de las unidades de Delphi a Lazarus. No se realiza ninguna validación ni cambios automáticos de sintaxis, por lo que cualquier cambio en la sintaxis se hará manualmente, así como de unidades referenciadas, sustitución de algunos componentes,..., aunque hay asistentes de ayuda disponibles para facilitar esta tarea, especialmente en el caso de la reparación de formularios (.lfm)

Seleccionar el modo correcto de compilación

   El compilador FPC soporta 5 modos diferentes de pascal. Por ejemplo, TP para turbo pascal, que permite compilar unidades turbo pascal. Está también el modo de compatibilidad DELPHI, cuya utilización permite una fácil conversión del código existente. El modo preferido en Lazarus es OBJFPC, muy parecido a DELPHI pero menos ambiguo en la sintaxis. Estos son puntos importantes:

   El modo se puede seleccionar en la línea de ordenes o al principio del código fuente. Utillizar la línea de ordenes tien la ventaja de que no hay que cambiar el código fuente, pero la desventaja de que hay que documentarlo para los demás.

   Muchas unidades DELPHI compilan con FPC añadiendo a las mismas

{$IFDEF FPC}
  {$MODE DELPHI}
{$ENDIF}

inmediatamente a continuación del nombre de la unidad.

   Para más detalles acerca de los modos de Free Pascal FPC ver Documentación de Free Pascal

Consideraciones sobre codificación para Multiplataforma

  • El código Ensamblador en línea (inline assembler) es problemático, dado que es específico para la arquitectura Intel. Muchos desarrolladores hacen el prototipo en Pascal y después utilizan su equivalente ensamblador optimizado. Por suerte TurboPower hizo esta operación dejando también el código Pascal. Si este es el caso del paquete que estás convirtiendo, repón el código pascal.
  • No hagas referencias a direcciones concretas de memoria, como el área de BIOS. Averigua lo que el código necesita y busca una alternativa portable entre plataformas.
  • No utilices trucos específicos de procesador (por ejemplo, Intel TSC) sin encerrar ese código en un selector (IFDEF) para esa plataforma... y provee una alternativa para entornos que no tienen esa máquina concreta.
  • Si es necesario código específico para un SO, haz uso de bloques selectores (IFDEF). Ver más abajo una lista de macros.

Variables, "defines" y macros útiles del compilador

   Para escribir código que se adapte, y se comporte de forma distinta según el sistema, se utiliza la directiva
{$IFDEF identificador}.
  • {$IFDEF FPC}

   Esta se define cuando se utiliza el compilador FPC. Es útil para escribir código válido tanto para Delphi como para FPC. Por razones de compatibilidad en FPC se define la macro DELPHI en modo Delphi, por lo tanto no se puede usar {$IFNDEF DELPHI}.

  • {$IFDEF LCL}

   Esta se define para utilizar el paquete LCL. Es útil para escribir código que funcione con LCL y Delphi.

  • {$IFDEF LCLGtk}
    ,
    {$IFDEF LCLWin32}
    ,
    {$IFDEF LCLQt}
    , ...

   Esta varible se define para utilizar el LCL en una determinada plataforma, usando los componentes visuales (widgetset).

  • {$IFDEF Unix} // para Linux, BSD, Mac OS X, Solaris
    ,
    {$IFDEF Win32}
    ,
    {$IFDEF Linux}
    // para Linux,
    {$IFDEF Darwin}
    // para OS X,
    {$IFDEF WinCE}
    // para WinCE,...

   Determina la utilización de FPC para un deteminado SO como destino. Delphi define "Linux", "Win32" y "MSWindows". Free Pascal funciona en muchas más plataformas y por tanto se recomienda utilizar especificaciones más generales. Por ejemplo "Unix" está definido para Linux, FreeBSD, NetBSD y OpenBSD, en los que Lazarus ya funciona. Para código que corra tanto en FPC cómo en Delphi utilice:

 {$IFDEF Linux}
   {$DEFINES Unix}
 {$ENDIF}

para que funcione en Kilix.

  • {$IFDEF ENDIAN_BIG}

   Esta variable se definirá para procesadores como el powerpc (ordenadores Apple, hasta el MacOSX 10.2, por ejemplo) que tienen la disposisicón del byte invertida respecto de los procesadores compatibles intel.

  • {$IFDEF ENDIAN_BIG}

   Para más detalles ver Documentación de FPC.

Soporte para 32bit / 64 bit

   Los punteros para 64bit requieren 8 octetos en vez de los 4 de 32bit. El tipo entero (integer) permanece de 32bit por compatibilidad. Esto supone que ya no es posible transformar enteros en punteros y viceversa mediante "typecast". FPC define dos nuevos tipos: PtrInt y PtrUInt. PtrInt es un entero con signo de 32bit en plataformas 32 bit y de 64 bit en plataformas 64bit. PtrUInt funciona igual, excepto que es un entero sin signo. Por tanto, para código que funcione tanto en FPC cómo en Delphi hay que escribir esto:

  {$IFNDEF FPC}
  type
    PtrInt = integer;
    PtrUInt = cardinal;
  {$ENDIF}

   Sustituya todas las ocurrencias de integer(SomePointerOrObject) por PtrInt(SomePointerOrObject).

   Para más información ver Guía de programación para multiples plataformas Multiplatform Programming Guide

Buscando un identificador perdido

   La organización de la LCL y de la VCL son diferentes. Cuándo tenemos un error de compilación "no encontrado" sobre una clase o un identificador, lo más probable es que la definición de los mismos se encuentre en una unidad distinta de la esperada. Una completa referencia cruzada se puede encontrar buscando en lazarus/docs/xml o en el directorio lcl.

   Por ejemplo, el común tbutton, dará error en Delphi, ya que se encuentra en una unidad llamada buttons.pp. El siguiente mandato encuentra la unidad correcta rápidamente (en el directorio fuente lazarus):

 grep -in ' tbutton =' lcl/*

   (Nota del traductor: esta sintaxis de grep no da resultados en windows. Yo en windows utilizo el 'buscar' del SO en el ámbito del directorio en que está instalado lazarus, para archivos .pas o .pp que contienen referencias al término deseado. Incluso funciona, a veces, la utilidad del IDE de buscar la declaración)

Diferencias mayores entre las unidades de Lazarus y las de Delphi

   ¡Por favor, añada lo que sepa sobre este tema!

  • Windows -> Interfaces, LCLIntf, LCLType, LCLProc, VCLGlobals, ...)

   Dado que la LCL no es específica de windows, el código para acceder la API win32 está condensada en interfaces separadas que son accedidas desde la unidad LCLIntf. Hay que tener en cuenta que Lazarus no intenta emular win32, por lo que muchas funciones no están incluidas y otras no funcionan exactamente como sus homólogas win32. Estas funciones existen únicamente para dar compatibilidad con Delphi y deben ser utilizadas únicamente para una migración rápida y "sucia". Las definiciones tipos están fragmentadas, por lo que es necesaria la unidad LCLType, y a veces también VCLGlobals. La unidad LCLProc también contiene algunas funciones que pueden ser útiles para manipulaciones a bajo nivel como "FreeThenNil" tal como se hace en Delphi 5 y superiores o "DeleteAmpersands" para eliminar los "&" sobrantes de una cadena de control (vs & & & etc). Hay que incluir la unidad Interfaces en la cláusula uses del archivo .lpr para iniciar adecuadamente el conjunto de controles apropiado (widgetset).

  • Messages -> LMessages

   Los mensajes de control (TControl Messages) para los eventos de retrollamada de win32 en el formato WM_CALLBACK y sus estructuras asociadas se encuentran en la unidad Delphi Messages. En la LCL estos tipos de mensajes y sus estructuras están usualmente en LMessages, normalmente con un cambio en el nombre, de WM a LM, así, por ejemplo, WM_MOUSEENTER se transforma en LM_MOUSEENTER, y TWMMouse en TLMMouse.

  • Graphics, Controls -> GraphType, GraphMath, Graphics, Controls

   Para simplificar las cosas y romper la complejidad de las referencias entre unidades, muchos tipos han sido abstraidos en una unidad común llamada GraphType, que incluye lo que en Deplhi se encuentra en las unidades Graphics o Controls. Así que tendrá que ser incluida. Otra unidad igualmente incompatible con Delphi es GraphMath, que añade el tipo TFloatPoint para precisión, rutinas para trabajar con curvas de Bézier, líneas y arcos, sobrecarga de algunos operadores para trabajar con TPoints y TRect, como, por ejemplo, punto1: = punto2 + punto3, y comparar dos Trect así if (rect1 = rect2) then ...such as for instance Point1 := Point2 + Point3, and comparing two rects like if (rect1 = rect2) then ...

  • Mask -> MaskEdit

   Para racionalizar las convenciones sobre nombres, la unidad para la clase TMaskEdit se llama MaskEdit y no el confuso Mask de muchas versiones Delphi.

  • StdCtrls->StdCtrls,Buttons

   En muchas versiones de Delphi TButton se encuentra en StdCtrls, mientras que TSpeedButton y TBitBtn están en Buttons. Por consistencia y simplicidad la LCL ubica todos los tipos de botones en la unidad Buttons, es por tanto una buena idea incluirla para evitar problemas de conversión.

Diferencias entre Delphi y FPC/LCL sobre propiedades y métodos

  • EL TBitmap de la LCL tiene una propiedad lienzo (canvas)
  • En la LCL las propiedades de las dimensiones de la ventana (TForm.ClientWidth/ClientHeight) y las proiedades de las dimensiones de su área cliente (TForm.Width/Height)tienen el mismo valor. Esto es así porque los valores de las dimensiones de la ventana no incluyen las dimensiones de su marco. Ver: Preguntas sobre Lazarus

Diferencias semánticas

Orden de evaluación de los parámetros
Delphi garantiza que los parámetros se evalúan siempre de izquierda a derecha. FPC no garantiza esto, y evaluará los parámetros en el orden que produzca un código más optimo.
Procedimientos y funciones anidadas como variables de procedimiento
Delphi pasa el puntero al marco (framepointer) del procedimiento padre siempre en la pila, y es quién llama el que debe quitarlo. Esto significa que no puede acceder a las variables del padre, y sin embargo puede pasar la dirección de una función anidada a otra función que podrá usarla como cualquier variable de procedimiento.
FPC, por otro lado pasa el puntero al marco del procedimiento padre cómo el primer parámetro oculto de acuerdo a las convenciones actuales de llamada, esto significa que si se llama a un procedimiento anidado como si fuese una variable de procedimiento ordinaria todos los parámetros pasados se moverán una posición.
En resumen, no llames a procedimientos anidados a través de variables de procedimiento.

Diferencias de sintaxis

¡Por favor, añada lo que sepa sobre este tema!
Debido al rigor inherente a FPC, algunos cambios en la sintaxis son necesarios, aunque con la directiva {$Mode Delphi} podemos relajarnos al estilo Delphi. No obstante lo cual, es recomendable cumplir con las reglas de sintaxis del modo {$Mode ObjFPC}, incluso cuando el código va a ser compartido entre Delphi y la LCL. Algunos son simples buenas prácticas de escritura de código, y otras porque el modo Delphi no es completamente exacto, o porque el código aceptable en Delphi no funciona como debe con FPC, incluso aunque compila. Para ello, aunque no todo es estrictamente necesario, los siguientes cambios deben considerarse obligatorios:
Al asignar una función de manejo de un evento, antepon un "@" a su nombre
Por ejemplo, se puede asignar la llamada a un botón manualmente
Delphi
OBJFPC
 begin
   if not Assigned(MiBoton.OnClick) then 
     MiBoton.OnClick:= UnaFuncion;
     //@ no necesario
     //más código...
 end;
 begin
   if not Assigned(MiBoton.OnClick) then
      MiBoton.OnClick:= @UnaFuncion;
     //@ Es necesario
     //más código...
 end;


Al llamar a una variable procedural usar esta sintaxis: ProcNombre()
En Delphi no existen diferencias entre el resultado de una función y una variable, en cambio en FPC, la llamada a una función debe llevar los paréntesis, incluso si no hay argumentos. Por ejemplo:
Delphi
OBJFPC
 With (UnObjeto) do 
  begin
   If Assigned(OnMiLlamada) then
     OnMiLlamada;
     //paréntesis no necesarios
  end;
 With (UnObjeto) do 
  begin
   If Assigned(OnMiLlamada) then
     OnMiLlamada();
     //los paréntesis son necesarios
  end;


Al obtener los valores de un puntero a registro hay que deshacer antes la referencia
En Delphi no es necesario deshacer la referencia a un puntero de registro para acceder a sus valores, se trata, de hecho, cómo si fuese un registro, o culaquier otro objeto. En FPC es necesario deshacer la referencia antes. Un ejemplo,
Delphi
OBJFPC
 Function DameValores(UnRegistro: PMiRegistro):Integer;
  begin
   If Assigned(UnRegistro) then
     Result:=UnRegistro.UnValor
   else
     Result:=0;
  end;
 Function DameValores(UnRegistro: PMiRegistro):Integer;
  begin
   If Assigned(UnRegistro) then
     Result:=UnRegistro^.UnValor
   else
     Result:=0;
  end;


Para acceder a caracteres de la cadena que es una propiedad de un objeto, esta debe ser encerrada entre paréntesis
Con Delphi las porpiedades de los objetos se tratan como cualquier otra constante o variable, incluso para acceder directamente a los caracteres individuales de una cadena, pero esto no es posible en FPC, específicamente para propiedades indexadas. PAra hacerlo hay que encerrar la propiedad etnre paréntesis, para diferenciar. Aunque no es necesario en todos los casos, es buena práctica hacerlo así siempre. Por ejemplo,
Delphi
OBJFPC
Type TUnComponente=class(TComponent)
  //Más código......
Published
Property MiCadena:String index 3 read GetMiCadena;
  //Más código....
End;
 
var
  MiLetra:char;
begin
  If Length(MiCadena)>2 then
    //paréntesis no necesarios
    MiLetra:= MiCadena[3];
    //Más código......
end;
 Type TUnComponente=class(TComponent)
  //Más código...
Published
Property MiCadena:String index 3 read GetMiCadena;
  //Más código...
End;
 
var
  MiLetra:char;
begin
  If Length(MiCadena)>2 then
    //paréntesis necesarios
    MiLetra:= (MiCadena)[3];
    //Más código......
end;


Hay que convertir los punteros al tipo real que espera la función con que se utiliza
En Delphi se puede tener un puntero nulo representando a un objeto. Aunque puede parecer extraño, es corriente que se de especialmente en paquetes de muchos componentes, cómo forma de evitar referencias circulares entre objetos de unidades distintas. En Delphi es posible pasar el puntero nulo a una función que espera un objeto de ese tipo, sin realizar la conversión al tipo real, en FPC hay que realizar la conversión de forma explícita. Por ejemplo:
Delphi / ObjFPC
 Unit Unidad1
  Type TUnObjeto=class(TComponent)
    //Más código...
  End;
 Procedure HacerAlgo(Value: TSomeObject);
 Function GetUnObjeto: TUnObjeto;
 
 Unit Unidad2
  Type TUnComponente=class(TComponent)
   //Más código...
  Published UnObjeto: Pointer;
  //Más código...
  End;


Delphi
OBJFPC

   -- Aplicación ----------

 var 
   MiComponente: TUnComponente;
 begin
   MiComponente.UnObjeto:=GetUnObjeto
   //Más código...
   HacerAlgo(MiComponente.UnObjeto);
 end;

   -- Aplicación ----------

 var 
   MiComponente: TUnComponente;
 begin
   MiComponente.UnObjeto:=Pointer(GetUnObjeto);
   //Más código...
   HacerAlgo(TUnObjeto(MiComponente.UnObjeto));
 end;

Recursos

Los recursos (iconos, imágenes, cursores, etc.) Delphi son específicos de win32 y no son compatibles con Lazarus, hay que rehacerlos y compilarlos con la utilidad lazres, que se puede encontrar en el directorio dir_de_lazarus/tools. Deberás compilar tú mismo esta utilidad.
  • linux y *nix
  cd dir_de_lazarus/lazarus/tools
  make install
  • windows
    • Abrir una consola con CMD y escribir lo siguiente:
  cd dir_de_lazarus\tools
  dir_de_lazarus\fpc\2.2.0\bin\i386-win32\make install
(nota del traductor: esto en realidad construye todas las utilidades que hay en tools)
Para añadir rucursos a tu aplicación:
  • lazres mirecurso.lrs mi_dibujo.xpm otro_dibujo.xpm.
  • Añade la unidad LResources en ls cláusula Uses de la unidad.
  • Incluye la referencia al archivo .lrs creado dentro de bloque de iniciación.
Ejemplo:
 Unit Unidad1
  function TForm1.LoadGlyph(const NombreGrafico: String): TBitMap;
   begin
     Result:= TPixmap.Create; //¿no debería ser Result:= TBitMap.Create;?
     Result.LoadFromLazarusResource(NombreGrafico);
   end;
 //Más código...
 begin
   BotonRapido.glyph:= LoadGlyph('mi_dibujo');
   //Más código...
 end;
 
 initialization
  {$I Unidad1.lrs}
  {$I mirecurso.lrs}
 end.
Desde la versión 2.2 del FPC, incluso los ejecutables ELF de Linux admiten recursos binarios, por lo que lo que se pueden utilizar los típicos recursos .res que se utilizan en Delphi
Ejemplo:
 //hasta aquí todo igual
 
 initialization
  {$I Unidad1.lrs}
  {$R mirecurso.res}
 end.

Otro método para convertir proyectos Delphi o Kylix a Lazarus

  • Renombra o copia todos los archivos .dfm o .xfm como .lfm. Las primeras versiones (hasta la 3 por lo menos) de Delphi no generaban los archivos .dfm como texto. Si este es el caso habrá que usar previamente la utilidad de conversión del IDE del menú Herramientas->Convertir archivo DFM a LFM...
  • Renombra o copia el archivo .dpr como .lpr.
  • Haz los cambios necesarios al archivo .lpr:
  1. Añade las directivas {$mode delphi}{$H+} o {$mode objfpc}{H+}
  2. Añade la unidad Interfaces a la clausula uses
  3. Comenta o borra la directiva {$R *.res} (esto no es necesario a partir de la versión 2.2 del FPC)
  • Haz los cambios necesarios a todas la unidades .pas:
  1. Añade las directivas {$mode delphi}{$H+} o {$mode objfpc}{H+}
  2. Añade la unidad LResources, y si el formulario tiene botones la unidad Buttons a la clausula uses
  3. Comenta o borra las directivas {$R *.dfm} o {$R *.xfm}
  4. Añade la sección Initialization al final de cada unidad, y añade una directiva {$I unitname.lrs} en su interior.
  • Crea un nuevo proyecto: Proyecto -> Nuevo proyecto desde archivo...
  • Selecciona el archivo .lpr que acabas de preparar
  • En la ventana Crear un proyecto nuevo selecciona Aplicación
  • Construye el proyecto y efectúa las correcciones necesarias para que compile correctamente, en este punto el archivo .lpi se crea automáticamente. Si aparecen errores de Error leyendo formulario dale al botón Continuar cargando
  • Guárdalo todo, y ya tienes un proyecto Lazarus :-)

Obtener ayuda

   Si encuentras un problema durante la conversión que no puedes resolver, hay una gran variedad de lugares donde obtener ayuda.

Documentación

Sobre Object Pascal y FPC El mejor sitio para empezar es la Documentación de Free Pascal de Michaël Van Canneyt y Florian Klämpfl.
Para cuestiones más enfocadas en Lazarus El proyecto de documentación de Lazarus Base de conocimientos Lazarus-CCR es el siguiente sitio donde buscar.

Soporte directo

Lista de correo Puedes enviar cuestiones a la lista de correo de Free Pascal Compiler o en los FPC foros, a los que un montón de espertos están suscritos.
Si tienes acceso a IRC: On irc.freenode.net: #fpc para FPC, o #lazarus-ide para Lazarus

Bases de conocimientos

   Hay algunas bases de conocimientos y buscadores en línea que también pueden ser de gran ayuda para aprender nuevas técnicas y encontrar soluciones a problemas:

Empaquetando y distribuyendo componentes

Creando un paquete Larazus para tu(s) componente(s)

   Crear un paquete hace que instalar el código convertido sea un proceso más fácil... especialmente si se está facilitando más de un componente. Mattias Gärtner ha escrito una descripción general sobre paquetes Lazarus que deben leerse antes de comenzar este proceso.

Documentación

   El propósito de este sitio y el formato wiki es hacer de la generación de documentación profesional un proceso fácil y rápido. El wiki también permite ver inmediatamente los resultados de lo publicación y hacer modificaciones al instante.

   Usar el Lazarus-CCR wiki para crear documentación bien presentada es muy fácil. Si nunca has utilizado antes las marcas wiki, puede familiarizarse con ellas en el área de práctica.

Creando una página de lanzamiento de código

   La página de lanzamiento de código contiene la información importante sobre sus componentes que un potencial usuario debe conocer, cómo la licencia, plataformas de destino, estado (alfa, beta, estable...), dónde está para descargarlo, quién lo ha escrito, si hay soporte... etc.

   El siguiente procedimiento permite crear el código de una página de lanzamiento de código con su navegador:

  • Acceda a lanzamiento de nuevos componentes
  • Escriba el nobre de su paquete o componente el la caja de texto y pulsa en Create Article
  • Cumplimenta la plantilla que aparecerá y guárdala.
  • Edita la página Componentes y código de ejemplo y añade el enlace a la nueva página creada en la sección de Componentes liberados (Released Components). Guarda la página modificada.

Envío del componente

   Si eres el responsable de lanzamiento de tu proyecto, pon el proyecto en el sistema de liberación de archivos de SourceForge y añádelo a la lista de paquetes liberados. En otro caso envíalo a uno de los administradores del proyecto (Tom Lisjac o Vincent Snijders) para que lo añadan al repositorio. Antes de subir a SourceForge, hay que crear la Página de lanzamiento de código para describir el componente. Se puede utilizar la página lanzamiento de nuevos componentes, para comenzar a crear la página.

   Si crees que será necesario para continuar desarrollando el componente, también puedes poner el código en SVN para seguir teniendo acceso al mismo. Si te cansas de enviar sus parches, le daremos acceso de escritura al CVS, para que puedas hacer las modificaciones tú mismo. Para detalles ver Usando el repositorio SVN de Lazarus-ccr.

Contribuciones y cambios

   Esta página ha sido convertida desde la versión epikwiki.

  • Versión incial por Tom Lisjac y Mattias Gärtner - 9/22/2003 VlxAdmin
  • Movido Cómo conseguir ayuda de la página principal. T. Lisjac - 9/24/2003 VlxAdmin
  • Añadida platillas de documentos, procedimientos y enlaces. 9/25/2003 VlxAdmin
  • LCLLinux renombrada como LCLIntf, Jesus Reyes, 9/27/2003
  • Añadida más información en los cambios de Unidad, AndrewJohnson 9/27/2003
  • Actualizadas las diferencias de sintaxis, incluyendo ejemplos, AndrewJohnson 9/27/2003
  • FPC 1.0.x no soporta interfaces, Vincent Snijders 9/28/2003
  • Nuevos ejemplos para la nueva definición de WikiWord, 9/28/2003 VlxAdmin
  • Mayor consistencia del Código para eliminar definiciones accidentales WikiWord, AndrewJohnson 9/27/2003
  • Utilización de tablas para los ejemplos de código y así mejorar la visualización al confrontar las diferencias entre Delphi y FPC, AndrewJohnson 10/17/2003
  • Utilización de estilo pascal para hacer los ejemplos más legibles, AndrewJohnson 10/18/2003
  • Adición de la sección 'Otro método para convertir proyectos Delphi o Kylix a Lazarus', George Lober, 2/17/2006
  • Versión en castellano (español) iskraelectrica (jldc) / mayo de 2008.