Lazarus For Delphi Users/es: what changed
Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.
| Old | New | Line | |
|---|---|---|---|
| 1 | 1 | Este escrito está dirigido a usuarios interesados en Lazarus que conocen Delphi, ya que describe las diferencias entre ambos. | |
| 2 | 2 | ||
| 3 | 3 | ## Delphi -\> Lazarus | |
| 4 | 4 | ||
| 5 | 5 | Lazarus es una herramienta de desarrollo rápido de aplicaciones, al igual que Delphi. Esto significa que dispone de una biblioteca de componentes visuales y de un entorno de desarrollo integrado (IDE). La librería de componentes de Lazarus (LCL) es muy similar a la VCL de Delphi. Muchas unidades, clases y propiedades tienen el mismo nombre e idéntica funcionalidad. Esto hace que el paso de uno o otro sea fácil. Pero Lazarus **no** es un *clon Delphi* de fuentes libres. No esperes por tanto una compatibilidad total. | |
| 6 | 6 | ||
| 7 | 7 | ### La mayor diferencia | |
| 8 | 8 | ||
| 9 | 9 | Lazarus es completamente libre, está escrito para ser independiente de la plataforma y utiliza el potente compilador [[Free Pascal]] (FPC). FPC está disponible para más de 15 plataformas. No obstante lo anterior, no todas las librerías y paquetes están disponibles en todas ellas, Lazarus a día de hoy funciona en Linux (i386, x86_64), FreeBSD (i386), MacOSX (powerpc, i386) y Windows (i386, x86_64). | |
| 10 | 10 | ||
| 11 | 11 | ** Lazarus no está terminado del todo, y del mismo modo, tampoco este texto. Se buscan nuevos programadores, escritores de paquetes, traductores, escritores de documentación, ...** | |
| 12 | 12 | ||
| 13 | 13 | ### Lo primero que hay que hacer al convertir un proyecto de Delphi | |
| 14 | 14 | ||
| 15 | 15 | Teniendo Lazarus en ejecución, tienes que ir a **Herramientas** y después a **Convertir proyecto Delphi a proyecto Lazarus**. Esto no lo hace todo, pero te facilitará la conversión. Tenga en cuenta que las herramientas disponibles en el IDE son unidireccionales. Si se necesita conservar la compatibilidad, para poder compilar indistintamente en Delphi y en Lazarus, considera convertir tus archivos utilizando [XDev Toolkit](http://wiki.lazarus.freepascal.org/XDev_Toolkit). | |
| 16 | 16 | ||
| 17 | 17 | ### Soporte para Unicode | |
| 18 | 18 | ||
| 19 | 19 | Delphi, incluida la versión 2007, no da soporte para Unicode, utilizando la codificación ANSI de Windows. Delphi da soporte a Unicode utilizando codificación de cadenas en UTF-16 a partir de la versión 2009. | |
| 20 | 20 | ||
| 21 | 21 | Por su lado Lazarus ha comenzado a dar soporte a Unicode con anterioridad y utiliza codificación de cadenas UTF-8. Para más información ver [[LCL Unicode Support|Soporte LCL para Unicode]]. | |
| 22 | 22 | ||
| 23 | 23 | ## Delphi IDE -\> Lazarus IDE | |
| 24 | 24 | ||
| 25 | 25 | ### Proyectos | |
| 26 | 26 | ||
| 27 | 27 | El archivo de extensión .dpr es el principal de una aplicación Delphi. El archivo principal de un proyecto Lazarus es el de extensión *.lpi* (Información de proyecto Lazarus). El archivo *.dpr* es también el archivo principal de código y en el mismo el IDE almacena información sobre las opciones de compilación y las unidades que utiliza el proyecto. Una aplicación Lazarus también tiene un archivo *.lpr*, que es el archivo principal de código. El resto de la información se almacena en el *.lpi*. Por lo tanto el *.lpi* es el archivo más importante del proyecto. | |
| 28 | 28 | ||
| 29 | 29 | Por ejemplo: | |
| 30 | 30 | ||
| 31 | 31 | Delphi guarda las rutas a las unidades en el archivo *.dpr*. Como esta, *unidad1 in 'ruta/Unidad1.pas*'. El *in* es específico de Delphi y no es entendido por Lazarus. No lo utilices, en su lugar usa las opciones de unidades y rutas de configuración del compilador. | |
| 32 | 32 | ||
| 33 | 33 | Delphi guarda las opciones del compilador, como {\$APPTYPE CONSOLE}, en el archivo *.dpr*, que son ignoradas por Lazarus. No lo utilices, en su lugar usa las opciones del compilador. | |
| 34 | 34 | ||
| 35 | 35 | #### Una cuestión importante: *Siempre* hay un proyecto. | |
| 36 | 36 | ||
| 37 | 37 | La única forma de "cerrar" un proyecto es cerrando Lazarus o abriendo otro proyecto. Esto es así, porque un proyecto Lazarus es así mismo una "sesión". Esto significa que la configuración actual del IDE se guarda en el archivo *.lpi* y es restaurada al reabrir el proyecto. Por ejemplo: estás depurando una aplicación, pones una serie de puntos de parada y marcas. Puedes guardar el proyecto, cerrar Lazarus o abrir otro proyecto. Cuándo reabras el proyecto, incluso en otra máquina, todos los puntos de parada, marcadores, archivos abiertos en el editor, posición de los cursores, historia de saltos, y demás, serán restaurados. | |
| 38 | 38 | ||
| 39 | 39 | ### Editor de Código | |
| 40 | 40 | ||
| 41 | 41 | Casi todas las funciones asignadas a teclas y los accesos directos se puede definir en *Entorno -\> Opciones del editor -\> Accesos rápidos*. | |
| 42 | 42 | ||
| 43 | 43 | El IDE de Lazarus tiene una gran cantidad de herramientas para trabajar con el código fuente. Muchas son parecidas y trabajan de forma similar a las de Delphi. Pero hay una diferencia importante, Lazarus no utiliza el compilador para obtener información del código, analiza el código fuente directamente. Esto tiene un montón de ventajas importantes: | |
| 44 | 44 | ||
| 45 | 45 | El editor trabaja con "comentarios". Para Delphi los comentarios son simplemente espacios entre el código. Ninguna característica del código trabaja aquí y si se inserta automáticamente nuevo código, los comentarios se desplazan. Con Lazarus se puede encontrar una declaración de código incluso dentro de los comentarios. Aunque esto no es completamente fiable, normalmente funciona. Cuando se inserta nuevo código el IDE utiliza heurística para mantener los comentarios y el código juntos. Por ejemplo, no separará la línea: | |
| 46 | 46 | ||
| 47 | 47 | ``` pascal | |
| 48 | 48 | letra: char; // comentario | |
| 49 | 49 | ``` | |
| 50 | 50 | ||
| 51 | 51 | La función de *Completar código* de Delphi (Ctrl+Space) se denomina *Completar identificador* (*Identifier Completion*) en Lazarus. El término Lazarus *Completar código* (*Code Completion*) es una funcionalidad que combina *Completar Clase automáticamente* (*Automatic Class Completion* igual que en Delphi), *Completar variable local* (*Local Variable Completion*) y *Completar asignación de evento* (*Event Assignment Completion*. Todas ellas se activan mediante *Ctrl+Shift+C* y el IDE determina cuál ejecutaraá en función del código presente en la posición del cursor. | |
| 52 | 52 | ||
| 53 | 53 | #### Ejemplo de *Completar variable local* | |
| 54 | 54 | ||
| 55 | 55 | Supongamos que acabas de crear un nuevo método y escribes la sentencia "i:=3;" | |
| 56 | 56 | ||
| 57 | 57 | ``` pascal | |
| 58 | 58 | procedure TForm1.HacerAlgo; | |
| 59 | 59 | begin | |
| 60 | 60 | i := 3; | |
| 61 | 61 | end; | |
| 62 | 62 | ``` | |
| 63 | 63 | ||
| 64 | 64 | Coloca el cursor justo de delante del identificador "i" y presiona Ctrl+Shift+C para obtener la declaración de la variable: | |
| 65 | 65 | ||
| 66 | 66 | ``` pascal | |
| 67 | 67 | procedure TForm1.HacerAlgo; | |
| 68 | 68 | var i: Integer; | |
| 69 | 69 | begin | |
| 70 | 70 | i := 3; | |
| 71 | 71 | end; | |
| 72 | 72 | ``` | |
| 73 | 73 | ||
| 74 | 74 | #### Ejemplo *Completar asignación de evento* | |
| 75 | 75 | ||
| 76 | 76 | Una buena característica del inspector de objetos es crear métodos automáticamente. Se puede hacer lo mismo en el editor de código.\ | |
| 77 | 77 | Por ejemplo: | |
| 78 | 78 | ||
| 79 | 79 | ``` pascal | |
| 80 | 80 | btnCancelar.OnClick:= | |
| 81 | 81 | ``` | |
| 82 | 82 | ||
| 83 | 83 | Sitúa el cursor tras el operador de asignación ":=" y presiona Ctrl+Shift+C, y se generará el esqueleto de la función de respuesta al evento. | |
| 84 | 84 | ||
| 85 | 85 | ``` pascal | |
| 86 | 86 | //... | |
| 87 | 87 | btnCancelar.OnClick:=@btnCancelarClick; | |
| 88 | 88 | //... | |
| 89 | 89 | ||
| 90 | 90 | procedure Form1.btnCancelarClick(Sender : TObject); | |
| 91 | 91 | begin | |
| 92 | 92 | ||
| 93 | 93 | end; | |
| 94 | 94 | ``` | |
| 95 | 95 | ||
| 96 | 96 | #### Ejemplo de *Completar llamada a Procedimiento* | |
| 97 | 97 | ||
| 98 | 98 | Supongamos que acabamos de escribir la sentencia "HacerAlgo(Ancho);" en este código | |
| 99 | 99 | ||
| 100 | 100 | ``` pascal | |
| 101 | 101 | procedure UnProcedimiento; | |
| 102 | 102 | var | |
| 103 | 103 | Ancho: integer; | |
| 104 | 104 | begin | |
| 105 | 105 | Ancho:=3; | |
| 106 | 106 | HacerAlgo(Ancho); | |
| 107 | 107 | end; | |
| 108 | 108 | ``` | |
| 109 | 109 | ||
| 110 | 110 | Sitúa el cursor sobre el identificador "HacerAlgo" y presiona las teclas Ctrl+Shift+C para obtener: | |
| 111 | 111 | ||
| 112 | 112 | ``` pascal | |
| 113 | 113 | procedure HacerAlgo(aAncho: LongInt); | |
| 114 | 114 | begin | |
| 115 | 115 | ||
| 116 | 116 | end; | |
| 117 | 117 | ||
| 118 | 118 | //... | |
| 119 | 119 | ||
| 120 | 120 | procedure UnProcedimiento; | |
| 121 | 121 | var | |
| 122 | 122 | Ancho: integer; | |
| 123 | 123 | begin | |
| 124 | 124 | Ancho:=3; | |
| 125 | 125 | HacerAlgo(Ancho); | |
| 126 | 126 | end; | |
| 127 | 127 | ``` | |
| 128 | 128 | ||
| 129 | 129 | **Nota** del traductor: lo descrito más arriba no funciona (da un error: Ya fue definido el identificador UnProcedimiento); sin embargo si el cursor está dentro del código de "UnProcedimiento", cómo en el ejemplo: | |
| 130 | 130 | ||
| 131 | 131 | ``` pascal | |
| 132 | 132 | type | |
| 133 | 133 | UnaClase = Class(TObject) | |
| 134 | 134 | end; | |
| 135 | 135 | //... | |
| 136 | 136 | procedure UnaClase.UnProcedimiento; | |
| 137 | 137 | begin | |
| 138 | 138 | //... | |
| 139 | 139 | end; | |
| 140 | 140 | ``` | |
| 141 | 141 | ||
| 142 | 142 | Al pulsar Ctrl+Shift+C obtendremos la definición de UnProcedimiento como miembro de la clase "UnaClase". | |
| 143 | 143 | ||
| 144 | 144 | ``` pascal | |
| 145 | 145 | type | |
| 146 | 146 | UnaClase = Class(TObject) | |
| 147 | 147 | private | |
| 148 | 148 | procedure UnProcedimiento; | |
| 149 | 149 | end; | |
| 150 | 150 | //... | |
| 151 | 151 | procedure UnaClase.UnProcedimiento; | |
| 152 | 152 | ``` | |
| 153 | 153 | ||
| 154 | 154 | #### "Completar palabras" Ctrl+W | |
| 155 | 155 | ||
| 156 | 156 | Trabaja de forma parecida a *Completar identificador*, sólo que no trabaja con identificadores pascal, sino con cualquier palabra. Busca en los ficheros abiertos todas las palabras que comienzan con las letras precedentes. | |
| 157 | 157 | ||
| 158 | 158 | #### Borrar hasta el final de la línea: Ctrl+T | |
| 159 | 159 | ||
| 160 | 160 | #### Borrar la línea completa: Ctrl+Y | |
| 161 | 161 | ||
| 162 | 162 | #### [[IDE Window: Code Templates|Acceder a las plantillas de código: Ctrl+J]] | |
| 163 | 163 | ||
| 164 | 164 | #### Permite archivos de inclusión (*include*) | |
| 165 | 165 | ||
| 166 | 166 | Mediante la directiva *{\$i acrchivo.inc}*. Delphi también permite usarlos (comprobado en D3 y D7, en D/ además se utiliza), aunque que probablemente no has creado muchos archivos de inclusión. Estos archivos tienen una gran ventaja: permiten escribir código (in)dependiente de la plataforma sin llenar el código de directivas IFDEF. Por ejemplo: Saltar al procedimiento (*procedure jump*), Completar clase, buscar declaración, ... funcionan con los archivos de inclusión. | |
| 167 | 167 | ||
| 168 | 168 | Hay otras muchas opciones para trabajar con el código. | |
| 169 | 169 | ||
| 170 | 170 | ### Diseñador | |
| 171 | 171 | ||
| 172 | 172 | - Directrices | |
| 173 | 173 | ||
| 174 | 174 | #### Inspector de Objetos | |
| 175 | 175 | ||
| 176 | 176 | En Delphi y Lazarus el Inspector de Objetos se utiliza para editar las propiedades de los componentes y la asignación de los eventos. Estas son lagunas de las pequeñas diferencias que hay entre ambos: | |
| 177 | 177 | ||
| 178 | 178 | 1. Con Delphi 5 apareció una vista jerarquizada en árbol de los componentes (*Object Treeview*), que se podía usar para moverse por los objetos y seleccionarlos, además de la tradicional lista desplegable del Inspector. En Lazarus esta vista de árbol está integrada en el Inspector y se utiliza en sustitución de la lista desplegable. Se puede activar o desactivar su utilización mediante la opción *Mostrar Árbol de componentes* del [menú contextual del Inspector](http://wiki.lazarus.freepascal.org/images/1/1f/Lazarus_Arbol_Inspector_Objetos.png) . | |
| 179 | 179 | 2. En Delphi haciendo doble clic en un evento vacío se crea este y se abre el Editor con el cursos en el mismo, en Lazarus, además de lo anterior, existe un botón al lado de la lista desplegable que hace lo mismo. | |
| 180 | 180 | 3. En Delphi se puede borrar manualmente el nombre de un evento para deshacer el enlace, en Lazarus, además podemos seleccionar *(none)* en la lista desplegable. | |
| 181 | 181 | 4. De forma similar, con doble clic en propiedades corrientes, cómo un lógico cambia su valor, además podemos seleccionarlo con la lista desplegable. Si la propiedad requiere de editor especializado, aparecerá este, al igual que si usamos el botón con los puntos suspensivos. | |
| 182 | 182 | ||
| 183 | 183 | #### Paquetes | |
| 184 | 184 | ||
| 185 | 185 | ¿Se pueden instalar y usar paquetes Delphi en Lazarus? | |
| 186 | 186 | ||
| 187 | 187 | No de forma directa, porque necesitan *la magia* del compilador de Delphi. | |
| 188 | 188 | ||
| 189 | 189 | ¿Necesitamos entonces paquetes específicos para Lazarus ? | |
| 190 | 190 | ||
| 191 | 191 | Sí, para ello: | |
| 192 | 192 | ||
| 193 | 193 | Crea un nuevo paquete, guárdalo en el direcorio donde residen los archivos fuente (normalmente el mismo directorio del archivo *.dpk*), añade la LCL cómo paquete necesario y finalmente los archivos *.pas*. Ya puedes instalarlo o utilizarlo en tus proyectos. Hay algunas diferencias entre los paquetes de Lazarus y Delphi, leete el archivo docs/Packages.txt que se encuentra en el directorio de fuentes de Lazarus. | |
| 194 | 194 | ||
| 195 | 195 | Ver tambien la [[Code Conversion Guide/es|Guía de conversión de código entre Delphi y Lazarus]] | |
| 196 | 196 | ||
| 197 | 197 | ### VCL -\> LCL | |
| 198 | 198 | ||
| 199 | 199 | Aunque laVCL y la LCL sirven en gran parte para el mismo propósito, una jerarquía de componentes orientada a objetos enfocada especialmente hacia el desarrollo rápido de aplicaciones, no son idénticas. Por ejemplo mientras que la VCL proporciona muchos componentes no visuales, el LCL procura proveer solamente componentes visuales, mientras que la mayoría de los componentes no visuales (tales como el acceso a BD) son proporcionados por la FCL, incluida con [[Free Pascal]]. | |
| 200 | 200 | ||
| 201 | 201 | Así mismo la LCL no tiene de algunos controles disponibles en la VCL o al contrario, o cuándo tiene el mismo control estos no son idénticos, y por tanto hay que realizar cambios en aplicaciones, componentes y controles al migrar. | |
| 202 | 202 | ||
| 203 | 203 | Lo que sigue es una tentativa de proporcionar descripciones bastante completas de la diferencias principales o de incompatibilidades entre los dos para el usuario de Delphi. Se cubren las diferencias primordialmente con la VCL de D4, aunque ocasionalmente también con las de D5, D6, o D7 ; y con la LCL actual, tal como está en el CVS. No podemos asegurar la coincidencia con la LCL de que cada uno dispone, ni cuál es la versión de Delphi de la que cada uno viene, por lo que si se ven discrepancias se es libre de añadir o modificar lo que sea necesario con el fin de mantener este documento tan comprensible como sea posible para todo el mundo. | |
| 204 | 204 | ||
| 205 | 205 | #### TControl.Font/TControl.ParentFont | |
| 206 | 206 | ||
| 207 | 207 | En la VCL es muy común y normal utilizar un tipo de letra y propiedades de fuente, como negrita y cursiva para los controles y se espera que este valor sea usado siempre. Más adelante se proporciona la característica de TControl.ParentFont que se asegura de que un control siga siempre la fuente de *su padre*. Otra vez se asume que estos valores serán seguidos siempre, incluso ignorando los ajustes de en la apariencia de Windows. | |
| 208 | 208 | ||
| 209 | 209 | Esto no es siempre cierto en la LCL, ni lo puede ser. La LCL que es por naturaleza múltiplataforma-multiinterfaz prefiere hacer una acercamiento equilibrado, y en su lugar intentará siempre utilizar los ajustes nativos de la apariencia del escritorio y el tema utilizado en los controles. Por ejemplo si usa un interfaz de GTK, y el tema del gtk dispone una fuente específica para los botones, los botones de la LCL procurarán siempre utilizar esta fuente. | |
| 210 | 210 | ||
| 211 | 211 | Esto significa que la mayoría de los controles de LCL no tienen el mismo nivel de ajuste del diseño que se espera a menudo en el VCL, solamente los controles personalizados que sean dibujados en el lienzo (*canvas*) y no creados por la interfaz pueden modificar consistentemente este interfaz asignado, sin importar cual sea el interfaz usado. | |
| 212 | 212 | ||
| 213 | 213 | #### Arrastre y colocación de controles | |
| 214 | 214 | ||
| 215 | 215 | En la VCL muchos (win)controles tienen métodos y funciones de retrollamada para habilitar el arrastre y colocación de los mismos, v.g. arrastrar un control desde un panel y colocarlo en otro panel en tiempo de ejecución. | |
| 216 | 216 | ||
| 217 | 217 | Esta funcionalidad no está implementada y está inacabada normalmente en la LCL,aunque está actualmente en las etapas iniciales de estudio, y debe aportar un cierto nivel de compatibilidad para este tipo de comportamiento, aunque no exactamente de la misma manera. | |
| 218 | 218 | ||
| 219 | 219 | Esto significa actualmente que ningún control hereda/utiliza las funciones, procedimientos, propiedades o eventos de TControl siguientes: | |
| 220 | 220 | ||
| 221 | 221 | ``` pascal | |
| 222 | 222 | Protected | |
| 223 | 223 | function GetDockEdge(MousePos: TPoint): TAlign; | |
| 224 | 224 | function GetDragImages: TDragImageList; | |
| 225 | 225 | function GetFloating: Boolean; | |
| 226 | 226 | function GetFloatingDockSiteClass: TWinControlClass; | |
| 227 | 227 | procedure DoEndDrag(Target:TObject); X, Y: Integer); | |
| 228 | 228 | procedure DockTrackNoTarget(Source: TDragDockObject; X, Y: Integer); | |
| 229 | 229 | procedure DoEndDock(Target: TObject; X, Y: Integer); | |
| 230 | 230 | procedure DoDock(NewDockSite: TWinControl; var ARect: TRect); | |
| 231 | 231 | procedure DoStartDock(var DragObject: TDragObject); | |
| 232 | 232 | procedure DragCanceled; | |
| 233 | 233 | procedure DragOver(Source: TObject; X, Y: Integer; State: TDragState; | |
| 234 | 234 | var Accept: Boolean); | |
| 235 | 235 | procedure DoEndDrag(Target: TObject; X, Y: Integer); | |
| 236 | 236 | procedure DoStartDrag(var DragObject: TDragObject); | |
| 237 | 237 | procedure DrawDragDockImage(DragDockObject: TDragDockObject); | |
| 238 | 238 | procedure EraseDragDockImage(DragDockObject: TDragDockObject); | |
| 239 | 239 | procedure PositionDockRect(DragDockObject: TDragDockObject); | |
| 240 | 240 | procedure SetDragMode(Value: TDragMode); | |
| 241 | 241 | property DragKind: TDragKind; | |
| 242 | 242 | property DragCursor: TCursor; | |
| 243 | 243 | property DragMode: TDragMode; | |
| 244 | 244 | property OnDragDrop: TDragDropEvent; | |
| 245 | 245 | property OnDragOver: TDragOverEvent; | |
| 246 | 246 | property OnEndDock: TEndDragEvent; | |
| 247 | 247 | property OnEndDrag: TEndDragEvent; | |
| 248 | 248 | property OnStartDock: TStartDockEvent; | |
| 249 | 249 | property OnStartDrag: TStartDragEvent; | |
| 250 | 250 | public | |
| 251 | 251 | function Dragging: Boolean; | |
| 252 | 252 | function ManualDock(NewDockSite: TWinControl; DropControl: TControl; | |
| 253 | 253 | ControlSide: TAlign): Boolean; | |
| 254 | 254 | function ManualFloat(ScreenPos: TRect): Boolean; | |
| 255 | 255 | function ReplaceDockedControl(Control: TControl; NewDockSite: TWinControl; | |
| 256 | 256 | DropControl: TControl; ControlSide: TAlign): Boolean; | |
| 257 | 257 | procedure BeginDrag(Immediate: Boolean; Threshold: Integer); | |
| 258 | 258 | procedure Dock(NewDockSite: TWinControl; ARect: TRect); | |
| 259 | 259 | procedure DragDrop(Source: TObject; X, Y: Integer); | |
| 260 | 260 | procedure EndDrag(Drop: Boolean); | |
| 261 | 261 | property DockOrientation: TDockOrientation; | |
| 262 | 262 | property Floating: Boolean; | |
| 263 | 263 | property FloatingDockSiteClass: TWinControlClass; | |
| 264 | 264 | property HostDockSite: TWinControl; | |
| 265 | 265 | property LRDockWidth: Integer; | |
| 266 | 266 | property TBDockHeight: Integer; | |
| 267 | 267 | property UndockHeight: Integer; | |
| 268 | 268 | property UndockWidth: Integer; | |
| 269 | 269 | ``` | |
| 270 | 270 | ||
| 271 | 271 | que las clases siguientes no existen/o no son utilizables | |
| 272 | 272 | ||
| 273 | 273 | ``` pascal | |
| 274 | 274 | TDragImageList = class(TCustomImageList) | |
| 275 | 275 | TDockZone = class | |
| 276 | 276 | TDockTree = class(TInterfacedObject, IDockManager) | |
| 277 | 277 | TDragObject = class(TObject) | |
| 278 | 278 | TBaseDragControlObject = class(TDragObject) | |
| 279 | 279 | TDragControlObject = class(TBaseDragControlObject) | |
| 280 | 280 | TDragDockObject = class(TBaseDragControlObject) | |
| 281 | 281 | ``` | |
| 282 | 282 | ||
| 283 | 283 | y que las siguientes funciones no son utilizables o son incompablibles | |
| 284 | 284 | ||
| 285 | 285 | ``` pascal | |
| 286 | 286 | function FindDragTarget(const Pos: TPoint; | |
| 287 | 287 | AllowDisabled: Boolean) : TControl; | |
| 288 | 288 | procedure CancelDrag; | |
| 289 | 289 | function IsDragObject(sender: TObject): Boolean; | |
| 290 | 290 | ``` | |
| 291 | 291 | ||
| 292 | 292 | El inicio del controlador de ajuste se describe aquí: [[Anchor Docking]] | |
| 293 | 293 | ||
| 294 | 294 | #### TEdit/TCustomEdit | |
| 295 | 295 | ||
| 296 | 296 | Los controles *Edit*, funcionan esencialmente de la misma forma en la LCL y en la VCL, aunque tienen algunas cuestiones de las que ser conscientes a la hora de convertir. | |
| 297 | 297 | ||
| 298 | 298 | 1. Debido a restricciones en los interfaces, *TEdit.PasswordChar* no trabaja en todos los interfaces (con el tiempo puede que sí), en su lugar se puede utilizar emPassword de *TCustomEdit.EchoMode* para el texto que necesite ser ocultado. | |
| 299 | 299 | 2. Los eventos *Drag/Dock*no están implementados. Para más información ver la sección Arrastre y colocación de controles. | |
| 300 | 300 | 3. Las propiedades de Font son normalmente ignoradas para consistencia del interfaz, para una explicación detallada ver la sección TControl.Font/TControl.ParentFont | |
| 301 | 301 | ||
| 302 | 302 | ### (optional) TSplitter -\> TPairSplitter | |
| 303 | 303 | ||
| 304 | 304 | **Mejórame, por favor** | |
| 305 | 305 | ||
| 306 | 306 | Ya existe un control *TSplitter* en la LCL, por lo que no es necesaria la conversión. Sin embargo, si usted quiere hacerlo, aquí se explica cómo: | |
| 307 | 307 | ||
| 308 | 308 | Lo que sigue se basa libremente en preguntas de Vincent Snijders en la lista de correo, y en las respuestas de [Andrew Johnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson): | |
| 309 | 309 | ||
| 310 | 310 | En la VCL el control "repartidor", que es como un [tirador](http://buscon.rae.es/draeI/SrvltGUIBusUsual?TIPO_HTML=2&TIPO_BUS=3&LEMA=tirador) que se coloca entre dos componentes para distribuir el espacio entre ambos, está representado por *TSplitter*. Esto se ve a menudo, por ejemplo en el IDE de Delphi entre el explorador del código y el visor de código fuente. | |
| 311 | 311 | ||
| 312 | 312 | La LCL proporciona su propio control llamado *TPairSplitter*, que sirve para el mismo propósito, no obstante no es compatible, será necesario "reparar" el código de los DFM de Delphi convertidos, aunque gran parte es compartido entre los dos. | |
| 313 | 313 | ||
| 314 | 314 | **¿Cuales son exactamente las diferencias?** | |
| 315 | 315 | ||
| 316 | 316 | La mayor diferencia es que el *TSplitter* de la VCL no tiene *hijos*, en vez de ello se coloca entre los dos controles alineados apropiadamente y modifica sus dimensiones en tiempo de ejecución. Es necesario tener dos controles alineados para cualquier cosa. Un ejemplo sencillo es un formulario con un Panel alineado a la izquierda (*Aling := alLeft*), un *Splitter* alineado a la izquierda y un segundo panel alineado al área cliente (*Aling := alClient*). Durante la ejecución puede ajustar el espacio entre los dos paneles arrastrando el tirador que provee el control *Splitter*. | |
| 317 | 317 | ||
| 318 | 318 | En la LCL, por su parte, un *TPairSplitter* es un tipo especial de control con dos paneles, y aunque es útil únicamente si los controles que se reparten el espacio están en ellos, realiza su cometido estando vacios. Siguiendo con el ejemplo anterior, tendríamos un formulario con un TPairSplitter alineado al área cliente (Aling := alClient) y sendos paneles, igualmente alineados al área cliente (Aling := alClient) a los lados. | |
| 319 | 319 | ||
| 320 | 320 | La otra diferencia importante es que en la VCL, puesto que el *TSplitter* es su propio *TControl*, la posición se guarda relativa a los otros controles al hacer el reparto, así que en cierto momento un panel del cliente crecerá mientras que los otros paneles no, así la posición de la *frontera* es relativa a la alineación de los controles participantes. | |
| 321 | 321 | ||
| 322 | 322 | En la LCL puesto que los paneles laterales están separados el control *TPairSplitter* tiene su propiedad de posición es absoluta, y al realizar la redistribución no cambia su posición según el contenido, por lo que hay que hacer una *retrollamada* para asegurar que se mantiene el ratio, en caso de ser importante. | |
| 323 | 323 | ||
| 324 | 324 | Por ejemplo, si el lado derecho de una distribución vertical necesita comportase como si estuviera *alineado al cliente* será necesario añadir al evento *OnResize* del formulario código cómo este: | |
| 325 | 325 | ||
| 326 | 326 | ``` pascal | |
| 327 | 327 | PairSplitter.Position := PairSplitter.Width - PairSplitter.Position; | |
| 328 | 328 | ``` | |
| 329 | 329 | ||
| 330 | 330 | ¿Cómo puedo convertir código existente que utiliza TSplitter a TPairSplitter? | |
| 331 | 331 | ||
| 332 | 332 | Si el repartidor y los controles se crean dentro de una función (como *OnCreate* del formulario), la conversión será más difícil, se reorganiza primero el código para crear los controles en el orden adecuado según la nueva jerarquía y para fijar a los padres de los controles *hijo* a repartir de izquierda/arriba y a la derecha/abajo del *PairSplitter*. Un ejemplo de los cambios necesarios: | |
| 333 | 333 | ||
| 334 | - | ||
| 335 | - | ||
| 336 | - | ||
| 337 | - | ||
| 338 | - | ||
| 339 | - | ||
| 340 | - | ||
| 341 | - | ||
| 342 | - | ||
| 343 | - | ||
| 344 | - | ||
| 345 | - | ||
| 346 | - | ||
| 347 | - | ||
| 348 | - | ||
| 349 | - | ||
| 350 | - | ||
| 351 | - | ||
| 352 | - | ||
| 353 | - | ||
| 354 | - | ||
| 355 | - | ||
| 356 | - | ||
| 357 | - | ||
| 358 | - | ||
| 359 | - | ||
| 360 | - | ||
| 361 | - | ||
| 362 | - | ||
| 363 | - | ||
| 364 | - | ||
| 365 | - | ||
| 366 | - | ||
| 367 | - | ||
| 368 | - | ||
| 369 | - | ||
| 370 | - | ||
| 371 | - | ||
| 372 | - | ||
| 373 | - | ||
| 374 | - | ||
| 375 | - | ||
| 376 | - | ||
| 377 | - | ||
| 378 | - | ||
| 379 | - | ||
| 380 | - | ||
| 381 | - | ||
| 382 | - | ||
| 383 | - | ||
| 384 | - | ||
| 385 | - | ||
| 386 | - | ||
| 387 | - | ||
| 388 | - | ||
| 389 | - | ||
| 390 | - | ||
| 391 | - | ||
| 392 | - | ||
| 393 | - | ||
| 394 | - | ||
| 395 | - | ||
| 396 | - | ||
| 397 | - | ||
| 398 | - | ||
| 399 | - | ||
| 400 | - | ||
| 401 | - | ||
| 402 | - | ||
| 403 | - | ||
| 404 | - | ||
| 405 | - | ||
| 406 | - | ||
| 407 | - | ||
| 408 | - | ||
| 409 | - | ||
| 410 | - | ||
| 411 | - | ||
| 412 | - | ||
| 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 | - | ||
| 441 | - | ||
| 442 | - | ||
| 443 | - | ||
| 334 | + | **VCL** | |
| 444 | 335 | ||
| 336 | + | **LCL** | |
| 337 | + | ||
| 338 | + | ``` pascal | |
| 339 | + | var | |
| 340 | + | BottomPanel: TPanel; | |
| 341 | + | VerticalSplitter: TSplitter; | |
| 342 | + | LeftPanel: TPanel; | |
| 343 | + | HorizontalSplitter: TSplitter; | |
| 344 | + | MainPanel: TPanel; | |
| 345 | + | ||
| 346 | + | begin | |
| 347 | + | BottomPanel:= TPanel.Create(Self); | |
| 348 | + | with (BottomPanel) do | |
| 349 | + | begin | |
| 350 | + | Parent:= Self; | |
| 351 | + | Height:= 75; | |
| 352 | + | Align:= alBottom; | |
| 353 | + | end; | |
| 354 | + | ||
| 355 | + | VerticalSplitter:= TSplitter.Create(Self); | |
| 356 | + | with (VerticalSplitter) do | |
| 357 | + | begin | |
| 358 | + | Parent:= Self; | |
| 359 | + | Align:= alBottom; | |
| 360 | + | end; | |
| 361 | + | ||
| 362 | + | HorizontalSplitter:= TSplitter.Create(Self); | |
| 363 | + | with (HorizontalSplitter) do | |
| 364 | + | begin | |
| 365 | + | Parent:= Self; | |
| 366 | + | align:= alLeft; | |
| 367 | + | end; | |
| 368 | + | ||
| 369 | + | LeftPanel:= TPanel.Create(Self); | |
| 370 | + | with (LeftPanel) do | |
| 371 | + | begin | |
| 372 | + | Parent:= Self; | |
| 373 | + | Width:= 125; | |
| 374 | + | Align:= alLeft; | |
| 375 | + | end; | |
| 376 | + | ||
| 377 | + | MainPanel:= TPanel.Create(Self); | |
| 378 | + | with (MainPanel) do | |
| 379 | + | begin | |
| 380 | + | Parent:= Self; | |
| 381 | + | Align:= alClient; | |
| 382 | + | Caption:= 'Hello'; | |
| 383 | + | end; | |
| 384 | + | end; | |
| 385 | + | ``` | |
| 386 | + | ||
| 387 | + | ``` pascal | |
| 388 | + | var | |
| 389 | + | BottomPanel: TPanel; | |
| 390 | + | VerticalSplitter: TPairSplitter; | |
| 391 | + | LeftPanel: TPanel; | |
| 392 | + | HorizontalSplitter: TPairSplitter; | |
| 393 | + | MainPanel: TPanel; | |
| 394 | + | ||
| 395 | + | begin | |
| 396 | + | VerticalSplitter:= TPairSplitter.Create(Self); | |
| 397 | + | with (VerticalSplitter) do | |
| 398 | + | begin | |
| 399 | + | Parent:= Self; | |
| 400 | + | Align:= alClient; | |
| 401 | + | Width:= Self.Width; | |
| 402 | + | Height:= Self.Height; | |
| 403 | + | SplitterType:= pstVertical; | |
| 404 | + | Position:= Height - 75; | |
| 405 | + | Sides[0].Width:= Width; | |
| 406 | + | Sides[0].Height:= Position; | |
| 407 | + | end; | |
| 408 | + | ||
| 409 | + | HorizontalSplitter:= TPairSplitter.Create(Self); | |
| 410 | + | with (HorizontalSplitter) do | |
| 411 | + | begin | |
| 412 | + | Parent:= VerticalSplitter.Sides[0]; | |
| 413 | + | Width:= Self.Width; | |
| 414 | + | Height:= VerticalSplitter.Position; | |
| 415 | + | align:= alClient; | |
| 416 | + | SplitterType:= pstHorizontal; | |
| 417 | + | Position:= 125; | |
| 418 | + | end; | |
| 419 | + | ||
| 420 | + | LeftPanel:= TPanel.Create(Self); | |
| 421 | + | with (LeftPanel) do | |
| 422 | + | begin | |
| 423 | + | Parent:= HorizontalSplitter.Sides[0]; | |
| 424 | + | Align:= alClient; | |
| 425 | + | end; | |
| 426 | + | ||
| 427 | + | MainPanel:= TPanel.Create(Self); | |
| 428 | + | with (MainPanel) do | |
| 429 | + | begin | |
| 430 | + | Parent:= HorizontalSplitter.Sides[1]; | |
| 431 | + | Align:= alClient; | |
| 432 | + | Caption:= 'Hello'; | |
| 433 | + | end; | |
| 434 | + | ||
| 435 | + | BottomPanel:= TPanel.Create(Self); | |
| 436 | + | with (BottomPanel) do | |
| 437 | + | begin | |
| 438 | + | Parent:= VerticalSplitter.Sides[1]; | |
| 439 | + | Align:= alClient; | |
| 440 | + | end; | |
| 441 | + | end; | |
| 442 | + | ``` | |
| 443 | + | ||
| 445 | 444 | Hay que ser consistente con la jerarquía de los controles. Y si se está familiarizado con los DFM' s, los cambios necesarios para la conversión DFM-\>LFM serán obvios cómo los anteriores, pues son del mismo tipo para las propiedades P*arent/Owner*, etc. El ejemplo sería algo así: | |
| 446 | 445 | ||
| 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 | - | ||
| 475 | - | ||
| 476 | - | ||
| 477 | - | ||
| 478 | - | ||
| 479 | - | ||
| 480 | - | ||
| 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 | - | ||
| 446 | + | **Delphi DFM** | |
| 447 | + | ||
| 448 | + | **(valores ajenos elliminados)** | |
| 449 | + | ||
| 450 | + | **Lazarus LFM** | |
| 451 | + | ||
| 452 | + | **(algunos *width*, *height*, etc. eliminados)** | |
| 453 | + | ||
| 454 | + | ``` pascal | |
| 455 | + | object RepartidorVertical: TSplitter | |
| 456 | + | Height = 3 | |
| 457 | + | Cursor = crVSplit | |
| 458 | + | Align = alBottom | |
| 459 | + | end | |
| 460 | + | object RepartidorHorizontal: TSplitter | |
| 461 | + | Width = 3 | |
| 462 | + | Align = alLeft | |
| 463 | + | end | |
| 464 | + | object Panel_Inferior: TPanel | |
| 465 | + | Height = 75 | |
| 466 | + | Align = alBottom | |
| 467 | + | end | |
| 468 | + | object Panel_Izquierdo: TPanel | |
| 469 | + | Width = 125 | |
| 470 | + | Align = alLeft | |
| 471 | + | end | |
| 472 | + | object Panel_Principal: TPanel | |
| 473 | + | Align = alClient | |
| 474 | + | end | |
| 475 | + | ``` | |
| 476 | + | ||
| 477 | + | ``` pascal | |
| 478 | + | object RepartidorVertical: TPairSplitter | |
| 479 | + | Height = 154 | |
| 480 | + | Width = 362 | |
| 481 | + | Position = 45 | |
| 482 | + | SplitterType = pstVertical | |
| 483 | + | object Panel_Superior: TPairSplitterSide | |
| 484 | + | Height = 45 | |
| 485 | + | Width = 362 | |
| 486 | + | end | |
| 487 | + | object Panel_Inferior: TPairSplitterSide | |
| 488 | + | Height = 103 | |
| 489 | + | Width = 362 | |
| 490 | + | ClientWidth = 362 | |
| 491 | + | ClientHeight = 103 | |
| 492 | + | object PairSplitter1: TPairSplitter | |
| 493 | + | Height = 103 | |
| 494 | + | Width = 362 | |
| 495 | + | Align = alClient | |
| 496 | + | Position = 45 | |
| 497 | + | object Panel_Izquierdo: TPairSplitterSide | |
| 498 | + | Height = 103 | |
| 499 | + | Width = 45 | |
| 500 | + | end | |
| 501 | + | object Panel_Derecho: TPairSplitterSide | |
| 502 | + | Height = 103 | |
| 503 | + | Width = 311 | |
| 504 | + | end | |
| 505 | + | end | |
| 506 | + | end | |
| 507 | + | end | |
| 508 | + | ``` | |
| 511 | 509 | ||
| 512 | 510 | ### TCustomTreeView/TTreeView | |
| 513 | 511 | ||
| 514 | 512 | Tanto la VCL como la LCL disponen de un componente *TCustomTreeView/TTreeView*, utilizados para mostrar listas en forma de árboles estructurados con múltiples nodos, selección avanzada y lista de imágenes; y aunque las funcionalidades don comparables, no todas las propiedades son completamente compatibles. Las principales diferencias son estas: | |
| 515 | 513 | ||
| 516 | 514 | **La lista no está completa, es necesario actualizar para incluir las funciones *TCustomTreeView Mark*y los métodos protegridos** | |
| 517 | 515 | ||
| 518 | 516 | 1. La LCL provee *TCustomTreeView.Options*, un conjunto de opciones con cuyos valores podemos cambiar el comportamiento y la apariencia del control. Estas opciones son: | |
| 519 | 517 | - *tvoAllowMultiselect*- habilita el modo de selección múltiple, equivalente a *TCustomTreeView.MultiSelect*en VCL de D6. | |
| 520 | 518 | - *tvoAutoExpand* - Expandir nodos automáticamente, equivalente a *TCustomTreeView.AutoExpand*. | |
| 521 | 519 | - *tvoAutoInsertMark* - Actualizar la vista de arrastre al mover el ratón. | |
| 522 | 520 | - *tvoAutoItemHeight* - Ajustar la altura de los elementos automáticamente. | |
| 523 | 521 | - tvoHideSelection'' - No marcar el elemento seleccionado. | |
| 524 | 522 | - "tvoHotTrack*- usar*Hot Tracking*, equivalente a*TCustomTreeview.HotTrack'' | |
| 525 | 523 | - "tvoKeepCollapsedNodes'' - Mantener los nodos hijos al cerrar o abrir. | |
| 526 | 524 | - "tvoReadOnly*- Poner el componente en modo sólo lectura, equivalente a*TCustomTreeview.ReadOnly'' | |
| 527 | 525 | - "tvoRightClickSelect*- habilitar la selección de nodos con el botón derecho del ratón, equivalente a*TCustomTreeView.RightClickSelect''. | |
| 528 | 526 | - "tvoRowSelect *- habilitar la selección de columnas, equivalente a*TCustomTreeView.RowSelect.'' | |
| 529 | 527 | - "tvoShowButtons *- mostrar botones, equivalente a*TCustomTreeView.ShowButtons''. | |
| 530 | 528 | - "tvoShowLines*- mostrar líneas de nodos, equivalente a*TCustomTreeView.ShowLines''. | |
| 531 | 529 | - "tvoShowRoot *- mostrar nodo raíz, equivalente a*TCustomTreeView.ShowRoot''. | |
| 532 | 530 | - "tvoShowSeparators '' - mostrar separadores. | |
| 533 | 531 | - "tvoToolTips'' - mostrar ayudas para nodos individuales. | |
| 534 | 532 | 2. La LCL provee propiedades adicionales: | |
| 535 | 533 | - Evento *TCustomTreeView.OnSelectionChange*. | |
| 536 | 534 | - "tCustomTreeView.DefaultItems'', para el número de elementos predeterminados. | |
| 537 | 535 | - "tCustomTreeView.ExpandSignType'' para elegir el signo utilizado para indicar los nodos expandibles o contraibles. | |
| 538 | 536 | 3. La mayor parte de los eventos de Arrastrar y soltar (*Drag/Dock*) están disponibles en la LCL, aunque no funcionan. Para más información ver la sección precedente sobre Arrastre y colocación de controles. | |
| 539 | 537 | ||
| 540 | 538 | ### Mensajes y Eventos | |
| 541 | 539 | ||
| 542 | 540 | El orden y la frecuencia de los mensajes y eventos (*OnShow*, *OnActivate*, *OnEnter*, ...) de la LCL son diferentes de los de la VCL y dependen de la interfaz utilizada. | |
| 543 | 541 | ||
| 544 | 542 | La LCL dispone de un subconjunto de mensajes similares a los de winAPI para hacer la migración desde Delphi sencilla, pero muchos mensajes de la LCL operan de forma diferente a sus pares de la VCL/winAPI. La mayor parte del código de Delphi utiliza mensajes winAPI,porque el VCL carece de esa característica o por razones de velocidad. Este tipo de código ráramente funcionará igual con la LCL, así que debe ser comprobado manualmente. Esto es así, ya que los mensajes de LCL se llaman por ejemplo *LM_SIZE* en vez de *WM_SIZE* (unidad lmessages). | |
| 545 | 543 | ||
| 546 | 544 | ## Colaboradores originales y cambios | |
| 547 | 545 | ||
| 548 | 546 | Esta página a sido convertida desde la [versión de la epikwiki](http://lazarus-ccr.sourceforge.net/index.php?wiki=LazarusForDelphiUsers). | |
| 549 | 547 | ||
| 550 | 548 | - Versión incial de la adaptación por VlxAdmin 9/26/2003 | |
| 551 | 549 | - Begin VCL -\> LCL with a section on TSplitter -\> TPairSplitter - [Andrew Johnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 9/30/2003 | |
| 552 | 550 | - Add TControl.Font/TControl.ParentFont to VCL -\> LCL - [Andrew Johnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 9/30/2003 | |
| 553 | 551 | - Update TEdit/TCustomEdit section in VCL -\> LCL - [Andrew Johnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 10/1/2003 | |
| 554 | 552 | - Add Control Dragging/Docking to VCL -\> LCL - [Andrew Johnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 10/1/2003 | |
| 555 | 553 | - Added "Object Inspector" to Delphi IDE -\> Lazarus IDE - [Andrew Johnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 10/1/2003 | |
| 556 | 554 | - Added initial "TCustomTreeView/TTreeView" to VCL -\> LCL - [Andrew Johnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 10/1/2003 | |
| 557 | 555 | - Added introduction to VCL -\> LCL - [Andrew Johnson](http://lazarus-ccr.sourceforge.net/index.php?wiki=AndrewJohnson) 10/1/2003 | |
| 558 | 556 | - Fixed some typos - Vincent 10/2/2003 | |
| 559 | 557 | - Fixed Typo User:Kirkpatc 20 May 2004 | |
| 560 | 558 | - Versión en castellano (español) iskraelectrica (jldc) / junio de 2008. | |
| 561 | 559 | ||
| 562 | 560 | ## Ver también | |
| 563 | 561 | ||
| 564 | 562 | [[Code Conversion Guide/es|Guía de conversión de código (desde Delphi y Kylix)]] | |
| 565 | 563 | ||
| 566 | 564 | [[Compile With Delphi|Compilar con Delphi]] | |
| 567 | 565 | ||
| 568 | 566 | --- | |
| 569 | 567 | *From the Free Pascal wiki, page "Lazarus For Delphi Users/es", as it stood on 2020-02-18 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).* | |
| 570 | 568 | Category: Castellano | |
| 571 | 569 | Category: Español |