Difference between revisions of "Lazarus For Delphi Users/es"

From Lazarus wiki
Jump to navigationJump to search
Line 263: Line 263:
 
   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 los redimensiona 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.
 
   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 los redimensiona 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.
  
    En la LCL, por su parte, un TPairSplitter es un tipo especial de control con dos paneles, y es útil únicamente si los controles que se reparten el espacio están en ellos,
+
    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.
 
 
pero todavía realizará una fractura entre ésos el panel independientemente de si cualquier cosa está en ellos. Tan siguiente el ejemplo anterior, usted tendría una forma con un cliente alineado TPairSplitter, y un panel alineó al cliente en su lado izquierdo, y un panel alineó al cliente en su derecho.
 
 
 
On the LCL hand however,  a TPairSplitter is a special kind of control, with two panels, and it can only be usefull if the controls to split are on these panels, but it will still perform a split between those panel whether or not anything is on them. So following the prior example, you would have a form with a TPairSplitter aligned client, and a panel aligned client on its left side, and a panel aligned client on its right side.
 
  
 
The other important difference is that in the VCl, since the TSplitter is its own TControl, then the position is kept relative to the other controls on resize, so for instance a client panel will grow while the other panels will not, thus the split position is relative to the alignment of the split controls,
 
The other important difference is that in the VCl, since the TSplitter is its own TControl, then the position is kept relative to the other controls on resize, so for instance a client panel will grow while the other panels will not, thus the split position is relative to the alignment of the split controls,

Revision as of 01:01, 14 February 2009

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

Este escrito está dirigido a usuarios interesados en Lazarus que conocen Delphi, ya que describe las diferencias entre ambos.

Delphi -> Lazarus

   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. So don't expect 100% compatibility.

La mayor diferencia

   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).

   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, ...

Lo primero que hay que hacer al convertir un proyecto de Delphi

   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.

Delphi IDE -> Lazarus IDE

Proyectos

   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 arcivo 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 lamacena en el .lpi. Por lo tanto el .lpi es el archivo más importante del proyecto.

   Por ejemplo:

   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.

   Delphi guarda las opciones del compilador en el archivo .dpr, como {$APPTYPE CONSOLE}, que son ignoradas por Lazarus. No lo utilices, en su lugar usa las opciones del compilador.

Una cuestión importante: Siempre hay un proyecto.

   La única forma de "cerrar" un proyecto es cerrando Lazarus o abriendo otro proyecto. ESto es así, porque un proyecto Lazarus es así mimso 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 cursosres, hisoria de saltos, y demás, serán restaurados.

Editor de Código

   Casi todas las funciones asignadas a teclas y los accesos directos se puede definir en Entorno -> Opciones del editor -> Accesos rápidos.

   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:

   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: <delphi> letra: char; // comentario</delphi>

   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.

Ejemplo de Completar variable local

   Supongamos que acabas de crear un nuevo método y escribes la sentencia "i:=3;" <delphi> procedure TForm1.HacerAlgo;

 begin
  i := 3;
 end; </delphi>

   Coloca el cursor justo de delante del identificador "i" y presiona Ctrl+Shift+C para obtener la declaración de la variable:

<delphi> procedure TForm1.HacerAlgo;

 var i: Integer;
 begin
  i := 3;
 end; </delphi>

Ejemplo Completar asignación de evento

   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.
   Por ejemplo:

<delphi> btnCancelar.OnClick:=</delphi>

   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.

<delphi>//...

 btnCancelar.OnClick:=@btnCancelarClick;

//...

procedure Form1.btnCancelarClick(Sender : TObject);
 begin
 end;    </delphi>

Ejemplo de Completar llamada a Procedimiento

   Supongamos que acabamos de escribir la sentencia "HacerAlgo(Ancho);" en este código <delphi> procedure UnProcedimiento;

 var
  Ancho: integer;
 begin
  Ancho:=3;
  HacerAlgo(Ancho);
 end;</delphi>

   Sitúa el cursor sobre el identificador "HacerAlgo" y presiona las teclas Ctrl+Shift+C para obtener:

<delphi> procedure HacerAlgo(aAncho: LongInt);

 begin
 end;

//...

procedure UnProcedimiento;
 var
  Ancho: integer;
 begin
  Ancho:=3;
  HacerAlgo(Ancho);
 end;</delphi>

   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: <delphi> type

   UnaClase = Class(TObject)
   end;

//...

procedure UnaClase.UnProcedimiento;
 begin
 //...
 end;</delphi>

   Al pulsar Ctrl+Shift+C obtendremos la definición de UnProcedimiento como miembro de la clase "UnaClase". <delphi> type

   UnaClase = Class(TObject)
    private
     procedure  UnProcedimiento;
    end;

//...

procedure UnaClase.UnProcedimiento;</delphi>

"Completar palabras" Ctrl+W

   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.

Borrar hasta el final de la línea: Ctrl+T

Borrar la línea completa: Ctrl+Y

Acceder a las plantillas de código: Ctrl+J

Permite archivos de inclusión (include)

    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.

   Hay otras muchas opciones para trabajar con el código.

Diseñador

  • Directrices

Inspector de Objetos

   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:

  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 .
  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.
  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.
  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.

Paquetes

   ¿Se pueden instalar y usar paquetes Delphi en Lazarus?

   No de forma directa, porque necesitan la magia del compilador de Delphi.

   ¿Necesitamos entonces paquetes específicos para Lazarus ?

   Sí, para ello:

   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 pauete 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.

   Ver tambien la Guía de conversión de código entre Delphi y Lazarus

VCL -> LCL

   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.

   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.

   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.

TControl.Font/TControl.ParentFont

   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.

   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.

   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.

Arrastre y colocación de controles

   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.

   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.

   Esto significa actualmente que ningún control hereda/utiliza las funciones, procedimientos, propiedades o eventos de TControl siguientes: <delphi> Protected

   function GetDockEdge(MousePos: TPoint): TAlign;
   function GetDragImages: TDragImageList;
   function GetFloating: Boolean;
   function GetFloatingDockSiteClass: TWinControlClass;
   procedure DoEndDrag(Target:TObject); X, Y: Integer);
   procedure DockTrackNoTarget(Source: TDragDockObject; X, Y: Integer);
   procedure DoEndDock(Target: TObject; X, Y: Integer);
   procedure DoDock(NewDockSite: TWinControl; var ARect: TRect);
   procedure DoStartDock(var DragObject: TDragObject);
   procedure DragCanceled;
   procedure DragOver(Source: TObject; X, Y: Integer; State: TDragState;
                   var Accept: Boolean);
   procedure DoEndDrag(Target: TObject; X, Y: Integer);
   procedure DoStartDrag(var DragObject: TDragObject);
   procedure DrawDragDockImage(DragDockObject: TDragDockObject);
   procedure EraseDragDockImage(DragDockObject: TDragDockObject);
   procedure PositionDockRect(DragDockObject: TDragDockObject);
   procedure SetDragMode(Value: TDragMode);
   property DragKind: TDragKind;
   property DragCursor: TCursor;
   property DragMode: TDragMode;
   property OnDragDrop: TDragDropEvent;
   property OnDragOver: TDragOverEvent;
   property OnEndDock: TEndDragEvent;
   property OnEndDrag: TEndDragEvent;
   property OnStartDock: TStartDockEvent;
   property OnStartDrag: TStartDragEvent;
public
   function Dragging: Boolean;
   function ManualDock(NewDockSite: TWinControl; DropControl: TControl;
                    ControlSide: TAlign): Boolean;
   function ManualFloat(ScreenPos: TRect): Boolean;
   function ReplaceDockedControl(Control: TControl; NewDockSite: TWinControl;
                     DropControl: TControl; ControlSide: TAlign): Boolean;
   procedure BeginDrag(Immediate: Boolean; Threshold: Integer);
   procedure Dock(NewDockSite: TWinControl; ARect: TRect);
   procedure DragDrop(Source: TObject; X, Y: Integer);
   procedure EndDrag(Drop: Boolean);
   property DockOrientation: TDockOrientation;
   property Floating: Boolean;
   property FloatingDockSiteClass: TWinControlClass;
   property HostDockSite: TWinControl;
   property LRDockWidth: Integer;
   property TBDockHeight: Integer;
   property UndockHeight: Integer;
   property UndockWidth: Integer; </delphi>

   que las clases siguientes no existen/o no son utilizables

<delphi> TDragImageList = class(TCustomImageList)

TDockZone = class
TDockTree = class(TInterfacedObject, IDockManager)
TDragObject = class(TObject)
TBaseDragControlObject = class(TDragObject)
TDragControlObject = class(TBaseDragControlObject)
TDragDockObject = class(TBaseDragControlObject) </delphi>

   y que las siguientes funciones no son utilizables o son incompablibles

<delphi> function FindDragTarget(const Pos: TPoint;

                        AllowDisabled: Boolean) : TControl;
procedure CancelDrag;
function IsDragObject(sender: TObject): Boolean; </delphi>

   El inicio del controlador de ajuste se describe aquí: Anchor Docking

TEdit/TCustomEdit

   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.

  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.
  2. Los eventos Drag/Dock no están implementados. Para más información ver la sección Arrastre y colocación de controles.
  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

(optional) TSplitter -> TPairSplitter

Mejórame, por favor

   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:

   Lo que sigue se basa libremente en preguntas de Vincent Snijders en la lista de correo, y en las respuestas de Andrew Johnson:

   En la VCL el control "divisores", que es como un tirador que se coloca entre dos componentes para distrbuir 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.

   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.

   ¿Cúales son exactamente las direfencias?

   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 los redimensiona 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.

    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.

The other important difference is that in the VCl, since the TSplitter is its own TControl, then the position is kept relative to the other controls on resize, so for instance a client panel will grow while the other panels will not, thus the split position is relative to the alignment of the split controls,

In the LCL since the side panels are separate then the TPairSplitter has a Position property which is absolute relative to top or left. so on resize the actual position does not change according to contents, so a callback must be set to ensure the ratio is kept on resize if this is important.

For example if the Right side of a vertical split needs to have alClient like behaviour, you need to add a form resize callback which does something like :

PairSplitter.Position := PairSplitter.Width - PairSplitter.Position; 
So how can I convert existing code using TSplitter to the TPairSplitter?

If the splitter and controls are created within an actual function(like form oncreate), conversion shouldn't be too difficult, primarily reorganize the code to create the controls in order of new hierarchy and set the parents of the child controls to split to the left/top and right/bottom portions of the PairSplitter. An example of the changes being -

VCL LCL

<delphi> var

 BottomPanel: TPanel;
 VerticalSplitter: TSplitter;
 LeftPanel: TPanel;
 HorizontalSplitter: TSplitter;
 MainPanel: TPanel;

begin

 BottomPanel:= TPanel.Create(Self);
 with (BottomPanel) do
 begin
   Parent:= Self;
   Height:= 75;
   Align:= alBottom;
 end;
 VerticalSplitter:= TSplitter.Create(Self);
 with (VerticalSplitter) do
 begin
   Parent:= Self;
   Align:= alBottom;
 end;
 HorizontalSplitter:= TSplitter.Create(Self);
 with (HorizontalSplitter) do
 begin
   Parent:= Self;
   align:= alLeft;
 end;
 LeftPanel:= TPanel.Create(Self);
 with (LeftPanel) do
 begin
   Parent:= Self;
   Width:= 125;
   Align:= alLeft;
 end;
 MainPanel:= TPanel.Create(Self);
 with (MainPanel) do
 begin
   Parent:= Self;
   Align:= alClient;
   Caption:= 'Hello';
 end;

end; </delphi>

<delphi> var

 BottomPanel: TPanel;
 VerticalSplitter: TPairSplitter;
 LeftPanel: TPanel;
 HorizontalSplitter: TPairSplitter;
 MainPanel: TPanel;

begin

 VerticalSplitter:= TPairSplitter.Create(Self);
 with (VerticalSplitter) do
 begin
   Parent:= Self;
   Align:= alClient;
   Width:= Self.Width;
   Height:= Self.Height;
   SplitterType:= pstVertical;
   Position:= Height - 75;
   Sides[0].Width:= Width;
   Sides[0].Height:= Position;
 end;
 HorizontalSplitter:= TPairSplitter.Create(Self);
 with (HorizontalSplitter) do
 begin
   Parent:= VerticalSplitter.Sides[0];
   Width:= Self.Width;
   Height:= VerticalSplitter.Position;
   align:= alClient;
   SplitterType:= pstHorizontal;
   Position:= 125;
 end;
 LeftPanel:= TPanel.Create(Self);
 with (LeftPanel) do
 begin
   Parent:= HorizontalSplitter.Sides[0];
   Align:= alClient;
 end;
 MainPanel:= TPanel.Create(Self);
 with (MainPanel) do
 begin
   Parent:= HorizontalSplitter.Sides[1];
   Align:= alClient;
   Caption:= 'Hello';
 end;
 BottomPanel:= TPanel.Create(Self);
 with (BottomPanel) do
 begin
   Parent:= VerticalSplitter.Sides[1];
   Align:= alClient;
 end;

end; </delphi>

So as you can see, farely consistant with most control hierarchy. And if you are familiar with DFM's, the changes needed for DFM->LFM conversion should be farely obvious from the above, as they are the same sort of changes in Parent/Owner etc.

So the above example would be something like -

Delphi DFM
(extraneous values removed)
Lazarus LFM
(most width, height, etc. removed)

<delphi> object VerticalSplitter: TSplitter

 Height = 3
 Cursor = crVSplit
 Align = alBottom

end object HorizontalSplitter: TSplitter

 Width = 3
 Align = alLeft

end object BottomPanel: TPanel

 Height = 75
 Align = alBottom

end object LeftPanel: TPanel

 Width = 125
 Align = alLeft

end object MainPanel: TPanel

 Align = alClient

end </delphi>

<delphi> object VerticalSplitter: TPairSplitter

 Align = alClient
 SplitterType = pstVertical
 Position = 225
 Height = 300
 Width = 400
 object Pairsplitterside1: TPairSplitterIde
   object HorizontalSplitter: TPairSplitter
     Align = alClient
     Position = 125
     object Pairsplitterside3: TPairSplitterIde
       Width = 125
       object LeftPanel: TPanel
         Align = alClient
         Width = 125
       end
     end
     object Pairsplitterside4: TPairSplitterIde
       object MainPanel: TPanel
         Align = alClient
       end
     end
   end
 end
 object Pairsplitterside2: TPairSplitterIde
   object BottomPanel: TPanel
     Align = alClient
     Height = 75
   end
 end

end </delphi>

TCustomTreeView/TTreeView

   Tanto la VCL como la LCL disponen de un componente TCustomTreeView/TTreeView, utilizados para mostrar listas en forma de árboles estrcuturados 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:

La lista no está completa, es necesario actualizar para incluir las funciones TCustomTreeView Mark y los métodos protegridos

  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:
    • tvoAllowMultiselect - habilita el modo de selección múltiple, equivalente a TCustomTreeView.MultiSelect en VCL de D6.
    • tvoAutoExpand - Expandir nodos automáticamente, equivalente a TCustomTreeView.AutoExpand.
    • tvoAutoInsertMark - Actualizar la vista de arrastre al mover el ratón.
    • tvoAutoItemHeight - Ajustar la altura de los elementos automáticamente.
    • tvoHideSelection - No marcar el elemento seleccionado.
    • tvoHotTrack - usar Hot Tracking, equivalente a TCustomTreeview.HotTrack
    • tvoKeepCollapsedNodes - Mantener los nodos hijos al cerrar o abrir.
    • tvoReadOnly - Poner el componente en modo sólo lectura, equivalente a TCustomTreeview.ReadOnly
    • tvoRightClickSelect - habilitar la selección de nodos con el botón derecho del ratón, equivalente a TCustomTreeView.RightClickSelect.
    • tvoRowSelect - habilitar la selección de columnas, equivalente a TCustomTreeView.RowSelect.
    • tvoShowButtons - mostrar botones, equivalente a TCustomTreeView.ShowButtons.
    • tvoShowLines - mostrar líneas de nodos, equivalente a TCustomTreeView.ShowLines.
    • tvoShowRoot - mostrar nodo raíz, equivalente a TCustomTreeView.ShowRoot.
    • tvoShowSeparators - mostrar separadores.
    • tvoToolTips - mostrar ayudas para nodos individuales.
  2. La LCL provee propiedades adicionales:
    • Evento TCustomTreeView.OnSelectionChange.
    • TCustomTreeView.DefaultItems, para el número de elementos predeterminados.
    • TCustomTreeView.ExpandSignType para elegir el signo utilizado para indicar los nodos expandibles o contraibles.
  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.

Mensajes y Eventos

   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.

   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 tcon 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).

Colaboradores originales y cambios

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

Ver también

Guía de conversión de código (desde Delphi y Kylix)

Compilar con Delphi