Code Conversion Guide/es: what changed
Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.
| Old | New | Line | |
|---|---|---|---|
| 1 | 1 | ### Guía de conversión de código | |
| 2 | 2 | ||
| 3 | 3 | 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 For Delphi Users|Lazarus para usuarios de Delphi]] una guía descriptiva de muchas de las diferencias de funcionamiento. | |
| 4 | 4 | ||
| 5 | 5 | 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. | |
| 6 | 6 | ||
| 7 | 7 | 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. | |
| 8 | 8 | ||
| 9 | 9 | ## Seleccionar un componente o librería para convertir | |
| 10 | 10 | ||
| 11 | 11 | ### Dónde encontrar código para convertir | |
| 12 | 12 | ||
| 13 | 13 | 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í](http://sourceforge.net/users/tpsfadmin/). | |
| 14 | 14 | ||
| 15 | 15 | Para evitar duplicar esfuerzos, los paquetes que ya han sido convertidos están listados en la página [[Components and Code examples|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 [[Current conversion projects|Proyecto actualmente en conversión]]. | |
| 16 | 16 | ||
| 17 | 17 | ### Licencias | |
| 18 | 18 | ||
| 19 | 19 | 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. | |
| 20 | 20 | ||
| 21 | 21 | 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. | |
| 22 | 22 | ||
| 23 | 23 | En general, Dominio Público ([software](http://buscon.rae.es/draeI/SrvltGUIBusUsual?TIPO_HTML=2&TIPO_BUS=3&LEMA=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)](http://www.opensource.org/docs/definition.php) 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" | |
| 24 | 24 | ||
| 25 | 25 | ### Dependencias | |
| 26 | 26 | ||
| 27 | 27 | 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. | |
| 28 | 28 | ||
| 29 | 29 | ### Acerca del compilador | |
| 30 | 30 | ||
| 31 | 31 | Ver: | |
| 32 | 32 | ||
| 33 | 33 | - [Problemas conocidos](http://www.freepascal.org/probs.html) | |
| 34 | - | ||
| 34 | + | - [Fallos no corregidos](http://www.freepascal.org/bugs/db.php3?statusfield=Unfixed) (parece que no funciona) | |
| 35 | 35 | ||
| 36 | 36 | ### Acerca de Sistemas Operativos y Plataformas | |
| 37 | 37 | ||
| 38 | 38 | 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! | |
| 39 | 39 | ||
| 40 | 40 | ## Convirtiendo | |
| 41 | 41 | ||
| 42 | 42 | ### Configurando el entorno de Lazarus para un proyecto de conversión | |
| 43 | 43 | ||
| 44 | 44 | #### Crear un proyecto de prueba | |
| 45 | 45 | ||
| 46 | 46 | - Poner el código a convertir en un subdirectorio (convertdir, por ejemplo) | |
| 47 | 47 | - Desde Lazarus crear un proyecto nuevo. | |
| 48 | 48 | - Guardar (Archivo-\>Guardar Todo) en el subdirectorio convertdir. Poner nombres significativos a este proyecto y a su unidad principal es optativo. | |
| 49 | 49 | - Abrir la unidad principal del proyecto a convertir. | |
| 50 | 50 | - Añadirla al proyecto: Proyecto-\>Añadir archivo del Editor al Proyecto | |
| 51 | 51 | - Utilice Herramientas-\>Chequeo Rápido de la sintaxis o bien Ejecutar-\>Construir todo para empezar. | |
| 52 | 52 | ||
| 53 | 53 | #### Cuestiones iniciales a tener en cuenta | |
| 54 | 54 | ||
| 55 | 55 | - 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" | |
| 56 | 56 | ||
| 57 | 57 | #### Código fuente Delphi VCL y Kylix CLX en Lazarus | |
| 58 | 58 | ||
| 59 | 59 | 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. | |
| 60 | 60 | ||
| 61 | 61 | ### Problemas de conversión y soluciones | |
| 62 | 62 | ||
| 63 | 63 | #### Equivalencia de archivos entre Delphi / Kylix y Lazarus | |
| 64 | 64 | ||
| 65 | - | ||
| 66 | - | ||
| 67 | - | ||
| 68 | - | ||
| 69 | - | ||
| 70 | - | ||
| 71 | - | ||
| 72 | - | ||
| 73 | - | ||
| 74 | - | ||
| 75 | - | ||
| 76 | - | ||
| 77 | - | ||
| 78 | - | ||
| 79 | - | ||
| 80 | - | ||
| 81 | - | ||
| 82 | - | ||
| 83 | - | ||
| 84 | - | ||
| 85 | - | ||
| 86 | - | ||
| 87 | - | ||
| 88 | - | ||
| 89 | - | ||
| 90 | - | ||
| 91 | - | ||
| 92 | - | ||
| 93 | - | ||
| 94 | - | ||
| 95 | - | ||
| 96 | - | ||
| 97 | - | ||
| 98 | - | ||
| 99 | - | ||
| 100 | - | ||
| 101 | - | ||
| 102 | - | ||
| 103 | - | ||
| 104 | - | ||
| 105 | - | ||
| 106 | - | ||
| 107 | - | ||
| 108 | - | ||
| 109 | - | ||
| 65 | + | **Delphi / Kylix** | |
| 110 | 66 | ||
| 67 | + | **Descripción** | |
| 68 | + | ||
| 69 | + | **Lazarus** | |
| 70 | + | ||
| 71 | + | **Descripción** | |
| 72 | + | ||
| 73 | + | .pas | |
| 74 | + | ||
| 75 | + | .dfm/.xfm, | |
| 76 | + | ||
| 77 | + | .dcu/.dpu, | |
| 78 | + | ||
| 79 | + | .dpr(main project file), | |
| 80 | + | ||
| 81 | + | .res, | |
| 82 | + | ||
| 83 | + | .dof/.kof | |
| 84 | + | ||
| 85 | + | --- | |
| 86 | + | ||
| 87 | + | --- | |
| 88 | + | ||
| 89 | + | --- | |
| 90 | + | ||
| 91 | + | Delphi Source File, Delphi Form, | |
| 92 | + | ||
| 93 | + | Delphi Compiled Unit, | |
| 94 | + | ||
| 95 | + | Delphi Project, | |
| 96 | + | ||
| 97 | + | Windows Resource File, | |
| 98 | + | ||
| 99 | + | Delphi Option File | |
| 100 | + | ||
| 101 | + | .pas, .pp .lfm, | |
| 102 | + | ||
| 103 | + | .o, | |
| 104 | + | ||
| 105 | + | .lpr | |
| 106 | + | ||
| 107 | + | --- | |
| 108 | + | ||
| 109 | + | --- | |
| 110 | + | ||
| 111 | + | .lrs, | |
| 112 | + | ||
| 113 | + | .lpi(main project file), | |
| 114 | + | ||
| 115 | + | .ppu | |
| 116 | + | ||
| 117 | + | Pascal unit file, | |
| 118 | + | ||
| 119 | + | Form data file, | |
| 120 | + | ||
| 121 | + | Compiled unit file, | |
| 122 | + | ||
| 123 | + | Project file, | |
| 124 | + | ||
| 125 | + | Resource file, | |
| 126 | + | ||
| 127 | + | Project options file, | |
| 128 | + | ||
| 129 | + | Lazarus resource file, | |
| 130 | + | ||
| 131 | + | Lazarus project information file, | |
| 132 | + | ||
| 133 | + | FPC unit description file | |
| 134 | + | ||
| 111 | 135 | 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. | |
| 112 | 136 | ||
| 113 | 137 | #### Convirtiendo proyectos/formularios/unidades de Delphi a Lazarus | |
| 114 | 138 | ||
| 115 | 139 | 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í: | |
| 116 | 140 | ||
| 117 | 141 | ` `[`http://wiki.lazarus.freepascal.org/Delphi_Converter_in_Lazarus`](http://wiki.lazarus.freepascal.org/Delphi_Converter_in_Lazarus) | |
| 118 | 142 | ||
| 119 | 143 | El siguiente texto explica las diferencias entre Delphi y Lazarus y cómo convertir manualmente. | |
| 120 | 144 | ||
| 121 | 145 | Cambia el nombre o copia el archivo .dpr a un .lpr. Comenta o elimina la directiva | |
| 122 | 146 | ||
| 123 | - | ||
| 124 | - | ||
| 125 | 147 | {\$R *.res} | |
| 126 | 148 | ||
| 127 | - | ||
| 128 | - | ||
| 129 | 149 | y añade la directiva | |
| 130 | 150 | ||
| 131 | - | ||
| 132 | - | ||
| 133 | 151 | {\$mode delphi}{\$H+} | |
| 134 | 152 | ||
| 135 | - | ||
| 136 | - | ||
| 137 | 153 | o bien esta otra | |
| 138 | 154 | ||
| 139 | - | ||
| 140 | - | ||
| 141 | 155 | {\$mode objfpc}{\$H+} | |
| 142 | 156 | ||
| 143 | - | ||
| 144 | - | ||
| 145 | 157 | 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. | |
| 146 | 158 | ||
| 147 | 159 | 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. | |
| 148 | 160 | ||
| 149 | 161 | 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: | |
| 150 | 162 | ||
| 151 | 163 | 1. poner en minúsculas los nombre de archivo de inclusiones y de la sección uses. | |
| 152 | 164 | 2. convierte el .dfm a .lfm (normalmente sin comprobar el contenido, únicamente el formato) | |
| 153 | 165 | 3. crea un .lrs vacío (el contenido se creará después) | |
| 154 | 166 | 4. añade la directiva | |
| 155 | - | ||
| 156 | - | ||
| 157 | 167 | {\$mode delphi} | |
| 158 | - | ||
| 159 | - | ||
| 160 | 168 | 5. sustituye la referencia a la unidad windows por LCLIntf | |
| 161 | 169 | 6. añade la unidad LResources si es preciso (si se usa .lrs se pondrá | |
| 162 | - | ||
| 163 | - | ||
| 164 | 170 | uses LResources | |
| 165 | 171 | ||
| 166 | - | ||
| 167 | - | ||
| 168 | 172 | en la sección de implementación) | |
| 169 | 173 | 7. elimina las unidades variants | |
| 170 | 174 | 8. elimina la directiva | |
| 171 | - | ||
| 172 | - | ||
| 173 | 175 | {\$R *.dfm} | |
| 174 | - | ||
| 175 | - | ||
| 176 | 176 | 9. crea la sección de iniciación y añade en ella la directiva | |
| 177 | - | ||
| 178 | - | ||
| 179 | 177 | {\$i unit.lrs} | |
| 180 | 178 | ||
| 181 | - | ||
| 182 | - | ||
| 183 | 179 | 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) | |
| 184 | 180 | ||
| 185 | 181 | #### Seleccionar el modo correcto de compilación | |
| 186 | 182 | ||
| 187 | 183 | 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: | |
| 188 | 184 | ||
| 189 | 185 | 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. | |
| 190 | 186 | ||
| 191 | 187 | Muchas unidades DELPHI compilan con FPC añadiendo a las mismas | |
| 192 | 188 | ||
| 193 | 189 | `{$IFDEF FPC}`\ | |
| 194 | 190 | ` {$MODE DELPHI}`\ | |
| 195 | 191 | `{$ENDIF}` | |
| 196 | 192 | ||
| 197 | 193 | inmediatamente a continuación del nombre de la unidad. | |
| 198 | 194 | ||
| 199 | 195 | Para más detalles acerca de los modos de [[Free Pascal]] FPC ver [Documentación de Free Pascal](http://www.freepascal.org/docs-html/prog/progap4.html#progse62.html) | |
| 200 | 196 | ||
| 201 | 197 | #### Consideraciones sobre codificación para Multiplataforma | |
| 202 | 198 | ||
| 203 | 199 | - 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. | |
| 204 | 200 | - 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. | |
| 205 | 201 | - 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. | |
| 206 | 202 | - Si es necesario código específico para un SO, haz uso de bloques selectores (IFDEF). Ver más abajo una lista de macros. | |
| 207 | 203 | ||
| 208 | 204 | #### Variables, "defines" y macros útiles del compilador | |
| 209 | 205 | ||
| 210 | 206 | Para escribir código que se adapte, y se comporte de forma distinta según el sistema, se utiliza la directiva | |
| 211 | 207 | ||
| 212 | - | ||
| 213 | - | ||
| 214 | 208 | {\$IFDEF identificador}. | |
| 215 | 209 | ||
| 216 | - | ||
| 217 | - | ||
| 218 | - | ||
| 219 | - | ||
| 220 | - | ||
| 221 | - | ||
| 222 | - | ||
| 210 | + | - {\$IFDEF FPC} | |
| 223 | 211 | ||
| 224 | 212 | 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}**. | |
| 225 | 213 | ||
| 226 | - | ||
| 227 | - | ||
| 228 | - | ||
| 229 | - | ||
| 230 | - | ||
| 214 | + | - {\$IFDEF LCL} | |
| 231 | 215 | ||
| 232 | 216 | Esta se define para utilizar el paquete LCL. Es útil para escribir código que funcione con LCL y Delphi. | |
| 233 | 217 | ||
| 234 | - | ||
| 235 | - | ||
| 236 | - | ||
| 237 | - | ||
| 238 | - | ||
| 218 | + | - {\$IFDEF LCLGtk} | |
| 239 | 219 | ||
| 240 | 220 | , | |
| 241 | 221 | ||
| 242 | - | ||
| 243 | - | ||
| 244 | 222 | {\$IFDEF LCLWin32} | |
| 245 | 223 | ||
| 246 | - | ||
| 247 | - | ||
| 248 | 224 | , | |
| 249 | 225 | ||
| 250 | - | ||
| 251 | - | ||
| 252 | 226 | {\$IFDEF LCLQt} | |
| 253 | 227 | ||
| 254 | - | ||
| 255 | - | ||
| 256 | 228 | , ... | |
| 257 | 229 | ||
| 258 | 230 | Esta varible se define para utilizar el LCL en una determinada plataforma, usando los componentes visuales (widgetset). | |
| 259 | 231 | ||
| 260 | - | ||
| 261 | - | ||
| 262 | - | ||
| 263 | - | ||
| 264 | - | ||
| 232 | + | - {\$IFDEF Unix} // para Linux, BSD, Mac OS X, Solaris | |
| 265 | 233 | ||
| 266 | 234 | , | |
| 267 | 235 | ||
| 268 | - | ||
| 269 | - | ||
| 270 | 236 | {\$IFDEF Win32} | |
| 271 | 237 | ||
| 272 | - | ||
| 273 | - | ||
| 274 | 238 | , | |
| 275 | 239 | ||
| 276 | - | ||
| 277 | - | ||
| 278 | 240 | {\$IFDEF Linux} | |
| 279 | 241 | ||
| 280 | - | ||
| 281 | - | ||
| 282 | 242 | // para Linux, | |
| 283 | 243 | ||
| 284 | - | ||
| 285 | - | ||
| 286 | 244 | {\$IFDEF Darwin} | |
| 287 | 245 | ||
| 288 | - | ||
| 289 | - | ||
| 290 | 246 | // para OS X, | |
| 291 | 247 | ||
| 292 | - | ||
| 293 | - | ||
| 294 | 248 | {\$IFDEF WinCE} | |
| 295 | 249 | ||
| 296 | - | ||
| 297 | - | ||
| 298 | 250 | // para WinCE,... | |
| 299 | 251 | ||
| 300 | 252 | 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: | |
| 301 | 253 | ||
| 302 | 254 | ``` pascal | |
| 303 | 255 | {$IFDEF Linux} | |
| 304 | 256 | {$DEFINES Unix} | |
| 305 | 257 | {$ENDIF} | |
| 306 | 258 | ``` | |
| 307 | 259 | ||
| 308 | 260 | para que funcione en Kilix. | |
| 309 | 261 | ||
| 310 | - | ||
| 311 | - | ||
| 312 | - | ||
| 313 | - | ||
| 314 | - | ||
| 262 | + | - {\$IFDEF ENDIAN_BIG} | |
| 315 | 263 | ||
| 316 | 264 | 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. | |
| 317 | 265 | ||
| 318 | - | ||
| 319 | - | ||
| 320 | - | ||
| 321 | - | ||
| 322 | - | ||
| 266 | + | - {\$IFDEF ENDIAN_BIG} | |
| 323 | 267 | ||
| 324 | 268 | Para más detalles ver [Documentación de FPC](http://www.freepascal.org/docs-html/prog/prog.html#QQ2-23-21). | |
| 325 | 269 | ||
| 326 | 270 | #### Soporte para 32bit / 64 bit | |
| 327 | 271 | ||
| 328 | 272 | 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: | |
| 329 | 273 | ||
| 330 | 274 | ``` pascal | |
| 331 | 275 | {$IFNDEF FPC} | |
| 332 | 276 | type | |
| 333 | 277 | PtrInt = integer; | |
| 334 | 278 | PtrUInt = cardinal; | |
| 335 | 279 | {$ENDIF} | |
| 336 | 280 | ``` | |
| 337 | 281 | ||
| 338 | 282 | Sustituya todas las ocurrencias de **integer(SomePointerOrObject)** por **PtrInt(SomePointerOrObject)**. | |
| 339 | 283 | ||
| 340 | 284 | Para más información ver Guía de programación para multiples plataformas [[Multiplatform Programming Guide]] | |
| 341 | 285 | ||
| 342 | 286 | #### Buscando un identificador *perdido* | |
| 343 | 287 | ||
| 344 | 288 | 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. | |
| 345 | 289 | ||
| 346 | 290 | 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): | |
| 347 | 291 | ||
| 348 | 292 | ``` bash | |
| 349 | 293 | grep -in ' tbutton =' lcl/* | |
| 350 | 294 | ``` | |
| 351 | 295 | ||
| 352 | 296 | (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) | |
| 353 | 297 | ||
| 354 | 298 | #### Diferencias mayores entre las unidades de Lazarus y las de Delphi | |
| 355 | 299 | ||
| 356 | 300 | **¡Por favor, añada lo que sepa sobre este tema!** | |
| 357 | 301 | ||
| 358 | 302 | - Windows -\> Interfaces, LCLIntf, LCLType, LCLProc, VCLGlobals, ...) | |
| 359 | 303 | ||
| 360 | 304 | 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). | |
| 361 | 305 | ||
| 362 | 306 | - Messages -\> LMessages | |
| 363 | 307 | ||
| 364 | 308 | 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*. | |
| 365 | 309 | ||
| 366 | 310 | - Graphics, Controls -\> GraphType, GraphMath, Graphics, Controls | |
| 367 | 311 | ||
| 368 | 312 | 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 ... | |
| 369 | 313 | ||
| 370 | 314 | - Mask -\> MaskEdit | |
| 371 | 315 | ||
| 372 | 316 | Para racionalizar las convenciones sobre nombres, la unidad para la clase *TMaskEdit* se llama *MaskEdit* y no el confuso *Mask* de muchas versiones Delphi. | |
| 373 | 317 | ||
| 374 | 318 | - StdCtrls-\>StdCtrls,Buttons | |
| 375 | 319 | ||
| 376 | 320 | 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. | |
| 377 | 321 | ||
| 378 | 322 | #### Diferencias entre Delphi y FPC/LCL sobre propiedades y métodos | |
| 379 | 323 | ||
| 380 | 324 | - EL *TBitmap* de la LCL tiene una propiedad lienzo (*canvas*) | |
| 381 | 325 | - 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: [[Lazarus Faq|Preguntas sobre Lazarus]] | |
| 382 | 326 | ||
| 383 | 327 | #### Diferencias semánticas | |
| 384 | 328 | ||
| 385 | 329 | ##### Orden de evaluación de los parámetros | |
| 386 | 330 | ||
| 387 | 331 | ||
| 388 | 332 | 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. | |
| 389 | 333 | ||
| 390 | 334 | ##### Procedimientos y funciones anidadas como variables de procedimiento | |
| 391 | 335 | ||
| 392 | 336 | ||
| 393 | 337 | 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. | |
| 394 | 338 | ||
| 395 | 339 | ||
| 396 | 340 | 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. | |
| 397 | 341 | ||
| 398 | 342 | ||
| 399 | 343 | En resumen, no llames a procedimientos anidados a través de variables de procedimiento. | |
| 400 | 344 | ||
| 401 | 345 | #### Diferencias de sintaxis | |
| 402 | 346 | ||
| 403 | 347 | ##### **¡Por favor, añada lo que sepa sobre este tema!** | |
| 404 | 348 | ||
| 405 | 349 | ||
| 406 | 350 | 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: | |
| 407 | 351 | ||
| 408 | 352 | ##### Al asignar una función de manejo de un evento, antepon un "@" a su nombre | |
| 409 | 353 | ||
| 410 | 354 | ||
| 411 | 355 | Por ejemplo, se puede asignar la llamada a un botón manualmente | |
| 412 | 356 | ||
| 413 | - | ||
| 414 | - | ||
| 415 | - | ||
| 416 | - | ||
| 417 | - | ||
| 418 | - | ||
| 419 | - | ||
| 420 | - | ||
| 421 | - | ||
| 422 | - | ||
| 423 | - | ||
| 424 | - | ||
| 425 | - | ||
| 426 | - | ||
| 427 | - | ||
| 428 | - | ||
| 429 | - | ||
| 430 | - | ||
| 431 | - | ||
| 432 | - | ||
| 433 | - | ||
| 434 | - | ||
| 435 | - | ||
| 436 | - | ||
| 437 | - | ||
| 438 | - | ||
| 439 | - | ||
| 440 | - | ||
| 357 | + | **Delphi** | |
| 441 | 358 | ||
| 359 | + | **OBJFPC** | |
| 360 | + | ||
| 361 | + | ``` pascal | |
| 362 | + | begin | |
| 363 | + | if not Assigned(MiBoton.OnClick) then | |
| 364 | + | MiBoton.OnClick:= UnaFuncion; | |
| 365 | + | //@ no necesario | |
| 366 | + | //más código... | |
| 367 | + | end; | |
| 368 | + | ``` | |
| 369 | + | ||
| 370 | + | ``` pascal | |
| 371 | + | begin | |
| 372 | + | if not Assigned(MiBoton.OnClick) then | |
| 373 | + | MiBoton.OnClick:= @UnaFuncion; | |
| 374 | + | //@ Es necesario | |
| 375 | + | //más código... | |
| 376 | + | end; | |
| 377 | + | ``` | |
| 378 | + | ||
| 442 | 379 | ##### Al llamar a una variable procedural usar esta sintaxis: ProcNombre() | |
| 443 | 380 | ||
| 444 | 381 | ||
| 445 | 382 | 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: | |
| 446 | 383 | ||
| 447 | - | ||
| 448 | - | ||
| 449 | - | ||
| 450 | - | ||
| 451 | - | ||
| 452 | - | ||
| 453 | - | ||
| 454 | - | ||
| 455 | - | ||
| 456 | - | ||
| 457 | - | ||
| 458 | - | ||
| 459 | - | ||
| 460 | - | ||
| 461 | - | ||
| 462 | - | ||
| 463 | - | ||
| 464 | - | ||
| 465 | - | ||
| 466 | - | ||
| 467 | - | ||
| 468 | - | ||
| 469 | - | ||
| 470 | - | ||
| 471 | - | ||
| 472 | - | ||
| 473 | - | ||
| 474 | - | ||
| 384 | + | **Delphi** | |
| 475 | 385 | ||
| 386 | + | **OBJFPC** | |
| 387 | + | ||
| 388 | + | ``` pascal | |
| 389 | + | With (UnObjeto) do | |
| 390 | + | begin | |
| 391 | + | If Assigned(OnMiLlamada) then | |
| 392 | + | OnMiLlamada; | |
| 393 | + | //paréntesis no necesarios | |
| 394 | + | end; | |
| 395 | + | ``` | |
| 396 | + | ||
| 397 | + | ``` pascal | |
| 398 | + | With (UnObjeto) do | |
| 399 | + | begin | |
| 400 | + | If Assigned(OnMiLlamada) then | |
| 401 | + | OnMiLlamada(); | |
| 402 | + | //los paréntesis son necesarios | |
| 403 | + | end; | |
| 404 | + | ``` | |
| 405 | + | ||
| 476 | 406 | ##### Al obtener los valores de un puntero a registro hay que deshacer antes la referencia | |
| 477 | 407 | ||
| 478 | 408 | ||
| 479 | 409 | 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, | |
| 480 | 410 | ||
| 481 | - | ||
| 482 | - | ||
| 483 | - | ||
| 484 | - | ||
| 485 | - | ||
| 486 | - | ||
| 487 | - | ||
| 488 | - | ||
| 489 | - | ||
| 490 | - | ||
| 491 | - | ||
| 492 | - | ||
| 493 | - | ||
| 494 | - | ||
| 495 | - | ||
| 496 | - | ||
| 497 | - | ||
| 498 | - | ||
| 499 | - | ||
| 500 | - | ||
| 501 | - | ||
| 502 | - | ||
| 503 | - | ||
| 504 | - | ||
| 505 | - | ||
| 506 | - | ||
| 507 | - | ||
| 508 | - | ||
| 509 | - | ||
| 510 | - | ||
| 411 | + | **Delphi** | |
| 511 | 412 | ||
| 512 | - | ||
| 413 | + | **OBJFPC** | |
| 513 | 414 | ||
| 514 | - | ||
| 515 | - | ||
| 415 | + | ``` pascal | |
| 416 | + | Function DameValores(UnRegistro: PMiRegistro):Integer; | |
| 417 | + | begin | |
| 418 | + | If Assigned(UnRegistro) then | |
| 419 | + | Result:=UnRegistro.UnValor | |
| 420 | + | else | |
| 421 | + | Result:=0; | |
| 422 | + | end; | |
| 423 | + | ``` | |
| 516 | 424 | ||
| 517 | - | ||
| 518 | - | ||
| 519 | - | ||
| 520 | - | ||
| 521 | - | ||
| 522 | - | ||
| 523 | - | ||
| 524 | - | ||
| 525 | - | ||
| 526 | - | ||
| 527 | - | ||
| 528 | - | ||
| 529 | - | ||
| 530 | - | ||
| 531 | - | ||
| 532 | - | ||
| 533 | - | ||
| 534 | - | ||
| 535 | - | ||
| 536 | - | ||
| 537 | - | ||
| 538 | - | ||
| 539 | - | ||
| 540 | - | ||
| 541 | - | ||
| 542 | - | ||
| 543 | - | ||
| 544 | - | ||
| 545 | - | ||
| 546 | - | ||
| 547 | - | ||
| 548 | - | ||
| 549 | - | ||
| 550 | - | ||
| 551 | - | ||
| 552 | - | ||
| 553 | - | ||
| 554 | - | ||
| 555 | - | ||
| 556 | - | ||
| 557 | - | ||
| 558 | - | ||
| 559 | - | ||
| 560 | - | ||
| 561 | - | ||
| 562 | - | ||
| 425 | + | ``` pascal | |
| 426 | + | Function DameValores(UnRegistro: PMiRegistro):Integer; | |
| 427 | + | begin | |
| 428 | + | If Assigned(UnRegistro) then | |
| 429 | + | Result:=UnRegistro^.UnValor | |
| 430 | + | else | |
| 431 | + | Result:=0; | |
| 432 | + | end; | |
| 433 | + | ``` | |
| 563 | 434 | ||
| 564 | - | ||
| 435 | + | ##### Para acceder a caracteres de la cadena que es una propiedad de un objeto, esta debe ser encerrada entre paréntesis | |
| 565 | 436 | ||
| 566 | 437 | ||
| 567 | - | ||
| 438 | + | 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, | |
| 568 | 439 | ||
| 569 | - | ||
| 570 | - | ||
| 440 | + | **Delphi** | |
| 571 | 441 | ||
| 572 | - | ||
| 442 | + | **OBJFPC** | |
| 573 | 443 | ||
| 574 | - | ||
| 444 | + | ``` pascal | |
| 445 | + | Type TUnComponente=class(TComponent) | |
| 446 | + | //Más código...... | |
| 447 | + | Published | |
| 448 | + | Property MiCadena:String index 3 read GetMiCadena; | |
| 449 | + | //Más código.... | |
| 450 | + | End; | |
| 575 | 451 | ||
| 576 | - | ||
| 452 | + | var | |
| 453 | + | MiLetra:char; | |
| 454 | + | begin | |
| 455 | + | If Length(MiCadena)>2 then | |
| 456 | + | //paréntesis no necesarios | |
| 457 | + | MiLetra:= MiCadena[3]; | |
| 458 | + | //Más código...... | |
| 459 | + | end; | |
| 460 | + | ``` | |
| 577 | 461 | ||
| 578 | - | ||
| 462 | + | ``` pascal | |
| 463 | + | Type TUnComponente=class(TComponent) | |
| 464 | + | //Más código... | |
| 465 | + | Published | |
| 466 | + | Property MiCadena:String index 3 read GetMiCadena; | |
| 467 | + | //Más código... | |
| 468 | + | End; | |
| 579 | 469 | ||
| 580 | - | ||
| 470 | + | var | |
| 471 | + | MiLetra:char; | |
| 472 | + | begin | |
| 473 | + | If Length(MiCadena)>2 then | |
| 474 | + | //paréntesis necesarios | |
| 475 | + | MiLetra:= (MiCadena)[3]; | |
| 476 | + | //Más código...... | |
| 477 | + | end; | |
| 478 | + | ``` | |
| 581 | 479 | ||
| 582 | - | ||
| 480 | + | ##### Hay que convertir los punteros al tipo real que espera la función con que se utiliza | |
| 583 | 481 | ||
| 584 | - | ||
| 482 | + | ||
| 483 | + | 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: | |
| 585 | 484 | ||
| 485 | + | Delphi / ObjFPC | |
| 486 | + | ||
| 586 | 487 | ``` pascal | |
| 587 | 488 | Unit Unidad1 | |
| 588 | 489 | Type TUnObjeto=class(TComponent) | |
| 589 | 490 | //Más código... | |
| 590 | 491 | End; | |
| 591 | 492 | Procedure HacerAlgo(Value: TSomeObject); | |
| 592 | 493 | Function GetUnObjeto: TUnObjeto; | |
| 593 | 494 | ||
| 594 | 495 | Unit Unidad2 | |
| 595 | 496 | Type TUnComponente=class(TComponent) | |
| 596 | 497 | //Más código... | |
| 597 | 498 | Published UnObjeto: Pointer; | |
| 598 | 499 | //Más código... | |
| 599 | 500 | End; | |
| 600 | 501 | ``` | |
| 601 | 502 | ||
| 602 | - | ||
| 503 | + | **Delphi** | |
| 603 | 504 | ||
| 604 | - | ||
| 505 | + | **OBJFPC** | |
| 605 | 506 | ||
| 606 | - | ||
| 507 | + | -- Aplicación ---------- | |
| 607 | 508 | ||
| 608 | - | ||
| 609 | - | ||
| 610 | - | ||
| 611 | - | ||
| 612 | - | ||
| 613 | - | ||
| 614 | - | ||
| 615 | - | ||
| 616 | - | ||
| 617 | - | ||
| 618 | - | ||
| 619 | - | ||
| 620 | - | ||
| 621 | - | ||
| 622 | - | ||
| 623 | - | ||
| 624 | - | ||
| 625 | - | ||
| 626 | - | ||
| 627 | - | ||
| 628 | - | ||
| 629 | - | ||
| 630 | - | ||
| 631 | - | ||
| 632 | - | ||
| 633 | - | ||
| 634 | - | ||
| 635 | - | ||
| 636 | - | ||
| 637 | - | ||
| 638 | - | ||
| 639 | - | ||
| 509 | + | ``` pascal | |
| 510 | + | var | |
| 511 | + | MiComponente: TUnComponente; | |
| 512 | + | begin | |
| 513 | + | MiComponente.UnObjeto:=GetUnObjeto | |
| 514 | + | //Más código... | |
| 515 | + | HacerAlgo(MiComponente.UnObjeto); | |
| 516 | + | end; | |
| 517 | + | ``` | |
| 640 | 518 | ||
| 519 | + | -- Aplicación ---------- | |
| 520 | + | ||
| 521 | + | ``` pascal | |
| 522 | + | var | |
| 523 | + | MiComponente: TUnComponente; | |
| 524 | + | begin | |
| 525 | + | MiComponente.UnObjeto:=Pointer(GetUnObjeto); | |
| 526 | + | //Más código... | |
| 527 | + | HacerAlgo(TUnObjeto(MiComponente.UnObjeto)); | |
| 528 | + | end; | |
| 529 | + | ``` | |
| 530 | + | ||
| 641 | 531 | #### Recursos | |
| 642 | 532 | ||
| 643 | 533 | ||
| 644 | 534 | 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. | |
| 645 | 535 | ||
| 646 | 536 | :*linux y *nix | |
| 647 | 537 | ||
| 648 | 538 | ` cd dir_de_lazarus/lazarus/tools`\ | |
| 649 | 539 | ` make install` | |
| 650 | 540 | ||
| 651 | 541 | :*windows | |
| 652 | 542 | ||
| 653 | 543 | :** Abrir una consola con CMD y escribir lo siguiente: | |
| 654 | 544 | ||
| 655 | 545 | ` cd dir_de_lazarus\tools`\ | |
| 656 | 546 | ` dir_de_lazarus\fpc\2.2.0\bin\i386-win32\make install` | |
| 657 | 547 | ||
| 658 | 548 | ||
| 659 | 549 | (nota del traductor: esto en realidad construye todas las utilidades que hay en *tools*) | |
| 660 | 550 | ||
| 661 | 551 | ||
| 662 | 552 | Para añadir rucursos a tu aplicación: | |
| 663 | 553 | ||
| 664 | 554 | - lazres mirecurso.lrs mi_dibujo.xpm otro_dibujo.xpm. | |
| 665 | 555 | - Añade la unidad *LResources* en ls cláusula *Uses* de la unidad. | |
| 666 | 556 | - Incluye la referencia al archivo .lrs creado dentro de bloque de iniciación. | |
| 667 | 557 | ||
| 668 | 558 | Ejemplo: | |
| 669 | 559 | ||
| 670 | 560 | ``` pascal | |
| 671 | 561 | Unit Unidad1 | |
| 672 | 562 | function TForm1.LoadGlyph(const NombreGrafico: String): TBitMap; | |
| 673 | 563 | begin | |
| 674 | 564 | Result:= TPixmap.Create; //¿no debería ser Result:= TBitMap.Create;? | |
| 675 | 565 | Result.LoadFromLazarusResource(NombreGrafico); | |
| 676 | 566 | end; | |
| 677 | 567 | //Más código... | |
| 678 | 568 | begin | |
| 679 | 569 | BotonRapido.glyph:= LoadGlyph('mi_dibujo'); | |
| 680 | 570 | //Más código... | |
| 681 | 571 | end; | |
| 682 | 572 | ||
| 683 | 573 | initialization | |
| 684 | 574 | {$I Unidad1.lrs} | |
| 685 | 575 | {$I mirecurso.lrs} | |
| 686 | 576 | end. | |
| 687 | 577 | ``` | |
| 688 | 578 | ||
| 689 | 579 | ||
| 690 | 580 | 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 | |
| 691 | 581 | ||
| 692 | 582 | Ejemplo: | |
| 693 | 583 | ||
| 694 | 584 | ``` pascal | |
| 695 | 585 | //hasta aquí todo igual | |
| 696 | 586 | ||
| 697 | 587 | initialization | |
| 698 | 588 | {$I Unidad1.lrs} | |
| 699 | 589 | {$R mirecurso.res} | |
| 700 | 590 | end. | |
| 701 | 591 | ``` | |
| 702 | 592 | ||
| 703 | 593 | ### Otro método para convertir proyectos Delphi o Kylix a Lazarus | |
| 704 | 594 | ||
| 705 | 595 | - 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...* | |
| 706 | 596 | - Renombra o copia el archivo *.dpr* como *.lpr*. | |
| 707 | 597 | - Haz los cambios necesarios al archivo *.lpr*: | |
| 708 | 598 | ||
| 709 | 599 | :# Añade las directivas *{\$mode delphi}{\$H+}* o *{\$mode objfpc}{H+}* | |
| 710 | 600 | ||
| 711 | 601 | :# Añade la unidad *Interfaces* a la clausula *uses* | |
| 712 | 602 | ||
| 713 | 603 | :# Comenta o borra la directiva *{\$R *.res}* (esto no es necesario a partir de la versión 2.2 del FPC) | |
| 714 | 604 | ||
| 715 | 605 | - Haz los cambios necesarios a todas la unidades *.pas*: | |
| 716 | 606 | ||
| 717 | 607 | :# Añade las directivas *{\$mode delphi}{\$H+}* o *{\$mode objfpc}{H+}* | |
| 718 | 608 | ||
| 719 | 609 | :# Añade la unidad *LResources*, y si el formulario tiene botones la unidad *Buttons* a la clausula *uses* | |
| 720 | 610 | ||
| 721 | 611 | :# Comenta o borra las directivas *{\$R *.dfm}* o *{\$R *.xfm}* | |
| 722 | 612 | ||
| 723 | 613 | :# Añade la sección *Initialization* al final de cada unidad, y añade una directiva *{\$I unitname.lrs}* en su interior. | |
| 724 | 614 | ||
| 725 | 615 | - Crea un nuevo proyecto: *Proyecto -\> Nuevo proyecto desde archivo...* | |
| 726 | 616 | - Selecciona el archivo *.lpr* que acabas de preparar | |
| 727 | 617 | - En la ventana *Crear un proyecto nuevo* selecciona *Aplicación* | |
| 728 | 618 | - 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* | |
| 729 | 619 | - Guárdalo todo, y ya tienes un proyecto Lazarus :-) | |
| 730 | 620 | ||
| 731 | 621 | ## Obtener ayuda | |
| 732 | 622 | ||
| 733 | 623 | Si encuentras un problema durante la conversión que no puedes resolver, hay una gran variedad de lugares donde obtener ayuda. | |
| 734 | 624 | ||
| 735 | - | ||
| 736 | - | ||
| 737 | - | ||
| 738 | - | ||
| 739 | - | ||
| 740 | - | ||
| 741 | - | ||
| 742 | - | ||
| 743 | - | ||
| 744 | - | ||
| 745 | - | ||
| 746 | - | ||
| 747 | - | ||
| 748 | - | ||
| 749 | - | ||
| 750 | - | ||
| 751 | - | ||
| 752 | - | ||
| 753 | - | ||
| 754 | - | ||
| 755 | - | ||
| 756 | - | ||
| 757 | - | ||
| 758 | - | ||
| 759 | - | ||
| 760 | - | ||
| 625 | + | ### Documentación | |
| 626 | + | ||
| 627 | + | Sobre Object Pascal y FPC | |
| 628 | + | ||
| 629 | + | El mejor sitio para empezar es [la Documentación de Free Pascal](http://www.freepascal.org/docs-html/) de Michaël Van Canneyt y Florian Klämpfl. | |
| 630 | + | ||
| 631 | + | Para cuestiones más enfocadas en Lazarus | |
| 632 | + | ||
| 633 | + | El proyecto de documentación de Lazarus [[Main Page|Base de conocimientos Lazarus-CCR]] es el siguiente sitio donde buscar. | |
| 634 | + | ||
| 635 | + | ### Soporte directo | |
| 636 | + | ||
| 637 | + | Lista de correo | |
| 638 | + | ||
| 639 | + | Puedes enviar cuestiones a la [lista de correo de *Free Pascal Compiler*](http://www.freepascal.org/maillist.html) o en los [FPC foros](http://community.freepascal.org:10000/bboard/), a los que un montón de espertos están suscritos. | |
| 640 | + | ||
| 641 | + | Si tienes acceso a IRC: | |
| 642 | + | ||
| 643 | + | On irc.freenode.net: [\#fpc](irc://irc.freenode.net/fpc) para FPC, o [\#lazarus-ide](irc://irc.freenode.net/lazarus-ide) para Lazarus | |
| 761 | 644 | ||
| 762 | 645 | ### Bases de conocimientos | |
| 763 | 646 | ||
| 764 | 647 | 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: | |
| 765 | 648 | ||
| 766 | 649 | - Tamarack Associates opera un rápido \[ <http://codenewsfast.com/> buscador\] específico para los archivos *usenet* de Borland. | |
| 767 | 650 | - Mer Systems Inc. provee un [motor de búsqueda](http://www.mers.com/searchsite.html) similar . | |
| 768 | 651 | - Otra fuente de información, junto con un amplio y [capaz buscador](http://www.efg2.com/Lab/search.htm) es Earl F. Glynn's Computer Lab y el [Archivo de referencia](http://www.efg2.com/). | |
| 769 | 652 | ||
| 770 | 653 | ## Empaquetando y distribuyendo componentes | |
| 771 | 654 | ||
| 772 | 655 | ### Creando un paquete Larazus para tu(s) componente(s) | |
| 773 | 656 | ||
| 774 | 657 | 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 [[Lazarus Packages|paquetes Lazarus]] que deben leerse antes de comenzar este proceso. | |
| 775 | 658 | ||
| 776 | 659 | ### Documentación | |
| 777 | 660 | ||
| 778 | 661 | 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. | |
| 779 | 662 | ||
| 780 | 663 | 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 [[Sand Box|área de práctica]]. | |
| 781 | 664 | ||
| 782 | 665 | ### Creando una página de lanzamiento de código | |
| 783 | 666 | ||
| 784 | 667 | 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. | |
| 785 | 668 | ||
| 786 | 669 | El siguiente procedimiento permite crear el código de una página de lanzamiento de código con su navegador: | |
| 787 | 670 | ||
| 788 | 671 | - Acceda a [[Release new component|lanzamiento de nuevos componentes]] | |
| 789 | 672 | - Escriba el nobre de su paquete o componente el la caja de texto y pulsa en *Create Article* | |
| 790 | 673 | - Cumplimenta la plantilla que aparecerá y guárdala. | |
| 791 | 674 | - Edita la página [[Components and Code examples|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. | |
| 792 | 675 | ||
| 793 | 676 | ### Envío del componente | |
| 794 | 677 | ||
| 795 | 678 | 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 [[Release new component|lanzamiento de nuevos componentes]], para comenzar a crear la página. | |
| 796 | 679 | ||
| 797 | 680 | 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 [[Using the Lazarus-ccr SVN repository|Usando el repositorio SVN de Lazarus-ccr]]. | |
| 798 | 681 | ||
| 799 | 682 | ## Contribuciones y cambios | |
| 800 | 683 | ||
| 801 | 684 | Esta página ha sido convertida desde la [versión *epikwiki*](http://lazarus-ccr.sourceforge.net/index.php?wiki=CodeConversionGuide). | |
| 802 | 685 | ||
| 803 | 686 | - Versión incial por Tom Lisjac y Mattias Gärtner - 9/22/2003 VlxAdmin | |
| 804 | 687 | - Movido *Cómo conseguir ayuda* de la página principal. T. Lisjac - 9/24/2003 VlxAdmin | |
| 805 | 688 | - Añadida platillas de documentos, procedimientos y enlaces. 9/25/2003 VlxAdmin | |
| 806 | 689 | - LCLLinux renombrada como LCLIntf, Jesus Reyes, 9/27/2003 | |
| 807 | 690 | - Añadida más información en los cambios de Unidad, [AndrewJohnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 9/27/2003 | |
| 808 | 691 | - Actualizadas las diferencias de sintaxis, incluyendo ejemplos, [AndrewJohnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 9/27/2003 | |
| 809 | 692 | - FPC 1.0.x no soporta interfaces, Vincent Snijders 9/28/2003 | |
| 810 | 693 | - Nuevos ejemplos para la nueva definición de WikiWord, 9/28/2003 VlxAdmin | |
| 811 | 694 | - Mayor consistencia del Código para eliminar definiciones accidentales WikiWord, [AndrewJohnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 9/27/2003 | |
| 812 | 695 | - 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](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 10/17/2003 | |
| 813 | 696 | - Utilización de estilo pascal para hacer los ejemplos más legibles, [AndrewJohnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 10/18/2003 | |
| 814 | 697 | - Adición de la sección 'Otro método para convertir proyectos Delphi o Kylix a Lazarus', George Lober, 2/17/2006 | |
| 815 | 698 | - Versión en castellano (español) iskraelectrica (jldc) / mayo de 2008. | |
| 816 | 699 | ||
| 817 | 700 | --- | |
| 818 | 701 | *From the Free Pascal wiki, page "Code Conversion Guide/es", as it stood on 2020-02-10 after a change by Trev, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).* |