Creación de componentes

[roman]

Empezado por jmariano

(Aunque, asegúrate siempre de no volver a crear los panels si ya existen en el propietario).

¿Cómo?

Quizá es fácil pero hasta el momento no veo como lograr esto. Cuando se usa "View as text" y luego "View as form" el constructor Create se ejecuta antes de leer el dfm creando una instancia de los paneles interiores que nunca serán las que contengan componentes insertadas en diseño.

Posiblemente redefiniendo DefineProperties, no lo sé. Creo que es demasiada complicación para algo que se resuelve con Frames (hasta ahora no he visto la razón para no usarlos).

// Saludos

[CAOS]

La verdad es que un compañero mío ha intentado crear el componente a partir de Frames y el problema es el mismo.

[jmariano]

Empezado por roman

¿Cómo?

Quizá es fácil pero hasta el momento no veo como lograr esto. Cuando se usa "View as text" y luego "View as form" el constructor Create se ejecuta antes de leer el dfm creando una instancia de los paneles interiores que nunca serán las que contengan componentes insertadas en diseño.

Posiblemente redefiniendo DefineProperties, no lo sé. Creo que es demasiada complicación para algo que se resuelve con Frames (hasta ahora no he visto la razón para no usarlos).

// Saludos

Una forma de hacerlo sería buscando dos paneles en el propietario cuyo padre sea nuestro componente (ya que nuestro componente ha de poseer dos paneles). Para realizar esta operación habría que sobrecargar el método "CreateWnd", ya que si realizamos dicha operación en el constructor Create fallaría (creo que esto es debido a que "CreateWnd" debe de ejecutarse despues del constructor de la clase y despues de que fue leído el archivo de recursos .dfm, al igual que el método "Loaded" pero con la diferencia de que "CreateWnd" es llamado siempre que el control necesita "recrearse").

Pongo un ejemplo que construí para la ocasión:

Código Delphi [-]
type
  TMiPanel = class(TPanel)
  private
    FPanelSup: TPanel;
    FPanelInf: TPanel;
  protected
    procedure Loaded; override;
    procedure CreateWnd; override;
  public
    constructor Create(AOwner: TComponent); override;
    procedure CrearPanels;
  end;

procedure TMiPanel.CrearPanels;
var
  I: Integer;
begin
  { Recorremos los componentes del propietario para encontrar dos panels que
    tengan como padre nuestro componente. }
  for I := 0 to Owner.ComponentCount - 1 do
    if (Owner.Components[i] is TPanel) and (TPanel(Owner.Components[i]).Parent = Self) then
      if not Assigned(FPanelSup) then
        FPanelSup := TPanel(Owner.Components[i])
      else if not Assigned(FPanelInf) then
        FPanelInf := TPanel(Owner.Components[i])
      else Break; // Si no encontramos ningún panel salimos del bucle

  // Creamos el panel superior si no existe
  if not Assigned(FPanelSup) then
    FPanelSup := TPanel.Create(Owner);

  with FPanelSup do // Configuramos algunas propiedades
  begin
    Parent := Self;
    Align := alTop;
  end;

  // Creamos el panel inferior si no existe
  if not Assigned(FPanelInf) then
    FPanelInf := TPanel.Create(Owner);

  with FPanelInf do // Configuramos algunas propiedades
  begin
    Parent := Self;
    Align := alClient;
  end;
end;

constructor TMiPanel.Create(AOwner: TComponent);
begin
  inherited;
  Height := 100;
  Width := 250;
end;

procedure TMiPanel.CreateWnd;
begin
  inherited;
  CrearPanels; // Creamos los paneles
end;

procedure TMiPanel.Loaded;
begin
  inherited;
  CrearPanels; // Creamos los paneles
end;

Si lo probáis veréis que se crea un panel con dos paneles en su interior y que se pueden añadir controles en ambos paneles sin que se pierdan en ejecución. Tambien vereis, si visualizais el formulario como texto, que los controles añadidos forman parte del formulario (gracias a esto se mantiene la persistencia) y que, al volver a la vista de formulario normal, no ocurre el error de que tal panel ya existe (gracias a la comprobación que hacemos en el metodo "CrearPanels").

La desventaja, como ya dije, es que se pueden modificar los paneles en diseño y eliminar ( aunque siempre que la aplicación se ejecute los paneles aparecerán).

Empezado por dec

Hola,


Esa fue una de las formas en que probé a hacerlo, y, obtenía un bonito error tal que este:

Project Project1.exe raised exception class EClassNotFound with message 'Class TPanel not found'.

Sin embargo, ahora que lo has dicho he probado de nuevo a hacerlo y he conseguido que el error no se de, añadiendo a la cláusula "initialization" de la unidad en que está el componente (que vengo probando) la instrución "RegisterClass(TPanel);". Creo que no queda sino impedir que se puedan eliminar los paneles en tiempo de diseño...

Para que esto no ocurra es necesario darle un nombre a los paneles (verás que, por defecto, Delphi los nombra como "Components[n]"), pero es mejor dárselos en tiempo de diseño (desde el mismo formulario) y no en el mismo componente a la hora de crearlos, porque puede haber problemas si se eliminan paneles y se vuelven a crear (es por eso que no les dí nombre en el método "CrearPanels"). (en verdad, podemos dejar vacía la propiedad "Name" de todos los componentes que soltamos en un formulario, pero despues será necesario registrar las diferentes clases de nuestros componentes manualmente).

Empezado por CAOS

La verdad es que un compañero mío ha intentado crear el componente a partir de Frames y el problema es el mismo.

Eso ocurre porque, seguramente, está registrando el Frame en el IDE como un componente normal (utilizando el método "RegisterComponent"), lo que es un error porque el frame pierde, entonces, la capacidad de poder manejar el archivo de recursos .dfm relacioando.

Ten encuenta que un frame casi se comporta como si fuera un componente más. Fíjate que, incluso, cuando lo añadimos a un formulario pareciera que añadimos un control normal.

Si tu problema para usar los frames es porque necesitas propiedades en tiempo de diseño (es decir, propiedades que aparezcan en el inspector de objetos) te comento que puedes crearlas, aunque tendrás que realizar alguna operación especial (comentame si es por esto y te digo como hacerlo).

Saludos!

[roman]

Hola,

Escribí mi anterior mensaje y me fui a dormir y me quedé pensando en el método Loaded y ahora mismo iba a hacer las pruebas pero visto que ya las hiciste y te han funcionado veo que es posible.

Lo de evitar que se destruyan los paneles en el diseño pienso que podría hacerse en el método Notification.

Aún así, ya CAOS decidirá si posiblemente use finalmente frames. Como ya le comentas, si lo que quiere es añadir propiedades publicadas al mismo frame, puede hacerse.

// Saludos

[jmariano]

Empezado por roman

Lo de evitar que se destruyan los paneles en el diseño pienso que podría hacerse en el método Notification.

El problema es que el propietario (en este caso, el formulario) tambien recibe la notificación de la destrucción del componente, por lo que se complica mucho evitarlo (de hecho, intenté forzar la creación del panel desde el componente al recibir la notificación y obtuve un error de excepción, por lo que creo que la operacion es casi imposible). En realidad, el componente no debería recibir la notificación, ya que no es el propietario, por lo que creo que es el mismo formulario quien lo notifica a todos los subcomponentes que sean padres de los componentes o, mejor dicho, controles que posea.

(Sigo pensando que la mejor solución para CAOS está en utilizar los frames)

Saludos!

[CAOS]

La verdad es que al final voy a poder evitar el problema, no solucionarlo sólo evitarlo.

De todas maneras, probaré vuestras últimas ideas, ya más por curiosidad que por ir a utilizarlo en este caso concreto.

Muchas gracias por vuestra ayuda, la verdad es que ideas no os han faltado. Otra vez gracias y un saludo.

[roman]

Hola, les tengo buenas noticias. El código que muestro es prácticamente lo que originalmente se quería: un panel con dos subpaneles en los cuales se pueden insertar componentes pero que no son modificables durante el diseño. Claro está que las componentes se quedan donde deben estar al ejecutar la aplicación y/o reabrir el formulario.

Quisiera decir que esto se me ha ocurrido a mi pero no es así. Esto no evita que me de gusto descubrir, una vez más, que Delphi es mucho más potente de lo que imaginamos.

Como ahora ya me voy a dormir les dejaré en suspenso hasta más tarde en cuanto a la procedencia del código. Sólo diré ahora que lo he adaptado para nuestro caso y si algo falla seguramente será culpa mía y no desde luego del autor original.

La componente tiene aún un pequeño problema pero estoy seguro que jmariano lo podrá arreglar. Los demás también pero él fue quien tomó en cuenta dicho problema.

Confieso además que no he terminado de entender cabalmente el código pero ya entre todos hallaremos la explicación.

Por hoy sólo me resta comentarles que lo he probado con Delphi 7 pero supongo que con algunos cambios funcionará en otras versiones (lo supongo porque para simplificar quité algunas condicionales de compilación ).

Código Delphi [-]
unit DoublePanel;

interface

uses
  Classes, Controls, ExtCtrls, Forms;

type
  TSubPanel = class(TPanel)
  private
    FDropList: TStringList;

  protected
    property DropList: TStringList read FDropList;

    procedure ReadControls(Reader: TReader);
    procedure SetControls(Root: TComponent);

    procedure WriteControls(Writer: TWriter);
    procedure GetControls(Proc: TGetChildProc; Root: TComponent);

  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
  end;

  TDoublePanel = class(TPanel)
  private
    TopPanel: TSubPanel;
    ClientPanel: TSubPanel;

  protected
    procedure CreateWnd; override;

    procedure DefineProperties(Filer: TFiler); override;
    procedure GetChildren(Proc: TGetChildProc; Root: TComponent); override;
    procedure Loaded; override;

  public
    constructor Create(AOwner: TComponent); override;
  end;

procedure Register;

implementation

{ TSubPanel }

constructor TSubPanel.Create(AOwner: TComponent);
begin
  inherited;

  TabStop := false;
  FDropList := TStringList.Create;
end;

destructor TSubPanel.Destroy;
begin
  FDropList.Free;
  inherited;
end;

procedure TSubPanel.ReadControls(Reader: TReader);
begin
  FDropList.Clear;
  Reader.ReadListBegin;

  while not Reader.EndOfList do
    DropList.Add(Reader.ReadIdent);

  Reader.ReadListEnd;
end;

procedure TSubPanel.SetControls(Root: TComponent);
var
  Component: TComponent;
  I: Integer;

begin
  inherited;

  for I := 0 to DropList.Count - 1 do
  begin
    Component := Root.FindComponent(DropList[i]);

    if Assigned(Component) then
      TControl(Component).Parent := Self;
  end;
end;

procedure TSubPanel.WriteControls(Writer: TWriter);
var
  I: Integer;

begin
  Writer.WriteListBegin;

  for I := 0 to ControlCount - 1 do
    Writer.WriteIdent(Controls[i].Name);

  Writer.WriteListEnd;
end;

procedure TSubPanel.GetControls(Proc: TGetChildProc; Root: TComponent);
var
  Control: TControl;
  I: Integer;

begin
  inherited;

  for I := 0 to ControlCount - 1 do
  begin
    Control := Controls[i];

    if Control.Owner = Root then
      Proc(Control);
  end;
end;

{ TDoublePanel }

constructor TDoublePanel.Create(AOwner: TComponent);
begin
  inherited;

  ControlStyle := ControlStyle - [csAcceptsControls];

  Width := 377;
  Height := 249;
  BevelOuter := bvLowered;

  TopPanel := TSubPanel.Create(Self);
  TopPanel.Align := alTop;
  TopPanel.Parent := Self;

  ClientPanel := TSubPanel.Create(Self);
  ClientPanel.Align := alClient;
  ClientPanel.Parent := Self;
end;

procedure TDoublePanel.CreateWnd;
begin
  inherited;
end;

procedure TDoublePanel.DefineProperties(Filer: TFiler);
begin
  inherited;

  Filer.DefineProperty('TopPanel', TopPanel.ReadControls, TopPanel.WriteControls, true);
  Filer.DefineProperty('ClientPanel', ClientPanel.ReadControls, ClientPanel.WriteControls, true);
end;

procedure TDoublePanel.GetChildren(Proc: TGetChildProc; Root: TComponent);
begin
  inherited;

  TopPanel.GetControls(Proc, Root);
  ClientPanel.GetControls(Proc, Root);
end;

procedure TDoublePanel.Loaded;
var
  Root: TComponent;

begin
  inherited;

  Root := GetParentForm(Self);

  TopPanel.SetControls(Root);
  ClientPanel.SetControls(Root);
end;

{ Unit methods }

procedure Register;
begin
  RegisterComponents('Samples', [TDoublePanel]);
end;

end.

// Saludos