Creacion componente

[dec]

Hola,

Pues yo voy a reconocer que he preparado un pequeño ejemplo basándome en mi primera idea, que había cogido de ver los componentes que implementan propiedades de la forma que estamos refiriendo en este Hilo. Pues bien, primero hize algo muy similar a lo que Aldo ha propuesto, pero, aunque podía ver el símbolo "+" en la propiedad correspondiente en el Inspector de Objetos... era como si no estuviera, porque no desplegaba la lista de propiedades tal como esperaba.

Luego me fijé en cómo se hace en la clase "TControl", concretamente en su propiedad "Constraints", de tipo "TSizeConstraints", que es una propiedad que puede verse también (heredada de "TControl") en los "TForm", sin ir más lejos... la forma en que se lleva a cabo en dicha propiedad es algo más elaborada que lo que intenté la vez primera, pero, aunque conseguir implementar algo parecido en el componente de pruebas que estaba llevando a cabo para lograr lo que CHiCoLiTa seguía teniendo el mismo inconveniente... La propiedad aparece en el Inspector de Objetos, pero la "+" a su izquierda no sirve de mucho, porque no funciona...

En fin, me declaro inútil, creo que habría que investigar un tanto más el asunto, o que en algo metí la pata y no sé ahora mismo en qué puede haber sido... así que si antes dije que la cosa no era "complicada", ahora retiro lo dicho, y pido disculpas, pues que creo que pequé de hablador, siendo que no es tan sencillo como parece, o que, no puedo decir yo que lo sea cuando no he podido llevarlo a cabo ni a la de tres...

[dec]

Hola,

Bueno. Pues ya parece que puedo decir que no era tan complicado. Al cabo faltaba la creación de la clase que se utiliza en el componente y que es la que contiene las propiedades que hay que mostrar bajo el símbolo "+" en el Inspector de Objetos. Esto y alguna otra cosa, porque he añadido algunas hasta dar con el secreto. Con el permiso de Aldo, observa, CHICoLiTa, el siguiente código, por si puede ayudarte en algo:

Código Delphi [-]
  {
    Corregido tendiendo en cuenta
    lo dicho por roman más abajo
  }
 
 unit UPruebas;
 
 interface
 
 uses
   Classes;
 
 type
   TPruebas = class(TPersistent)
   private
     FAlto: integer;
     FAncho: integer;
   public
     procedure Assign(Source: TPersistent); override;
   published
     property Alto: integer read FAlto write FAlto default 0;
     property Ancho: integer read FAncho write FAncho default 0;
   end;
 
 type
   TDePruebas = class(TComponent)
   private
     FPruebas: TPruebas;
     procedure SetPruebas(Value: TPruebas);
   public
     constructor Create(AOwner: TComponent); override;
     destructor Destroy; override;
   published
     property Pruebas: TPruebas read FPruebas write SetPruebas;
   end;
 
 procedure Register;
 
 implementation
 
 procedure Register;
 begin
   RegisterComponents('Samples', [TDePruebas]);
 end;
 
 { TDePruebas }
 
 constructor TDePruebas.Create(AOwner: TComponent);
 begin
   inherited Create(AOwner);
   FPruebas := TPruebas.Create;
   FPruebas.Alto := 0;
   FPruebas.Ancho := 0;
 end;
 
 destructor TDePruebas.Destroy;
 begin
   FPruebas.Free;
   inherited Destroy;
 end;
 
 procedure TDePruebas.SetPruebas(Value: TPruebas);
 begin
   if Value <> FPruebas then
     Value.Assign(FPruebas);
 end;
 
 { TPruebas }
 
 procedure TPruebas.Assign(Source: TPersistent);
 begin
   if Source is TPruebas then
   begin
     FAlto := TPruebas(Source).FAlto;
     FAncho := TPruebas(Source).FAncho;
   end;
   inherited Assign(Source);
 end;
 
 end.

[CHiCoLiTa]

Nos esta faltando el constructor del componenete para que en la clase TPersisten se puedan crear el 'desplegable'.
Voy a ver si me sale y comento la solucion final

[CHiCoLiTa]

Vaya, he llegado tarde por unos minutos
dec ha puesto justo lo que faltaba
Sobretodo muchisimas gracias a Aldo
Una cosita mas que se hacer

[roman]

Nada más un detalle respecto del ejemplo de dec. La clase contenedora se encarga de la construcción y destrucción del objeto Pruebas, es decir, le pertenece. Por tanto hay que proteger la propiedad contra cambios no deseados: si se asigna

DePruebas.Pruebas := ObjetoPruebas

estamos sustituyendo el objeto que originalmente pertenecía a DePruebas por otro y al hacer FPruebas.Free será este otro el que estemos destruyendo y el objeto original se habrá quedado atorado en memoria.

Normalmente, para este tipo de propiedades hay que definir un método set:

Código Delphi [-]
property Pruebas: TPruebas read FPruebas write SetPruebas

donde SetPruebas se encargará de copiar el contenido. Puede hacerlo campo por campo aunque lo usual es transferir ese copiado al método Assign de TPruebas:

Código Delphi [-]
type
  TPruebas
  public
    procedure Assingn(Source: TPersistent); override;
  end;

y dejar SetPruebas con:

FPruebas.Assign(Value);

// Saludos

[dec]

Hola,

roman, me queda una duda, ¿viste que edité el código fuente para añadir el método "SetPruebas" tal como decías? Ahora bien, en donde se lee el comentario "{ ¿Acaso falta algo que hacer aquí? }"... ¿hay, efectivamente, que hacer algo más?

Actualización: Me temo que sí que había que hacer algo... claro está... creo que con lo siguiente sería bastante, y si me equivoco aquí estoy para que se me diga en qué. Y en todo caso muchas gracias roman.

Código Delphi [-]
{ TPruebas }
 
 procedure TPruebas.Assign(Source: TPersistent);
 begin
   if Source is TPruebas then
   begin
     FAlto := TPruebas(Source).Alto;
     FAncho := TPruebas(Source).Alto
   end;
   inherited Assign(Source);
 end;