Ayuda sobre Interrupción de Propiedades de Componentes Heredados

[Sapiem]

Saludos:

Estoy creando un Componente simple que emplea como base un TCheckBoxList. Todo funciona ok, excepto cuando quiero analizar todo lo que se haga sobre los Items que responden a TStrings class, y no a los TCheckBox.

Por ejemplo, con mi componente yo agrego nuevas opciones para agregar nuevos items de esta forma:

Código Delphi [-]
type
  TNewCheckBoxList = class (TCheckBoxList)
  propiedades, funciones, etc como es normal
  end;
  
procedure TNewCheckBoxList.AddNewItem(const S: string):
begin
  Items.Add(S+"  - "+DateToStr(Now));
end;

ok, pero yo deseo vigilar e interceptar también cuando el cliente usa la opción Items.Add(S) nativa del control, por ejemplo, pudiera usar indistintamente en su código:

Código Delphi [-]
procedure TForm1.Agrega(S: string);
begin
  //propio del nuevo componente
  NewCheckBoxList1.AddNewItem(S);

  // o usar este, que es el que no logro controlar
  NewCheckBoxList1.Add(S);

end;

Ojalá me haya explicado bien para que me puedan ayudar. No logro redefinir el Add cuando es del Item original de la base del nuevo componente.

Muchas gracias

[[maeyanes]]

Hola...

Primero, me imagino que te confundiste al momento de teclear tu mensaje, ya que la clase a la que te refieres es TCheckListBox. Esta clase desciende de TCustomListBox y tiene un método AddItem que puede ser redefinido. En tu caso esto quedaría como:

Código Delphi [-]
type
  TNewCheckListBox = class(TCheckListBox)
  public
    procedure AddItem(Item: string; AObject: TObject); override;
  end;

implementation

procedure TNewCheckListBox.AddItem(Item: string; AObject: TObject);
var
  Str: string;

begin
  Str := Format('%s - %s', [Item, DateToStr(Now)]);
  inherited AddItem(Str, AObject)
end;

Espero te sirva.


Saludos...

[Sapiem]

Es cierto y pido disculpas por el error al teclear. Es efectivamente el TCheckListBox el control que quiero tener como base. Mi deseo no es emplear el AddItem, puesto que solo cité un ejemplo, el AddItem que yo emplearé tendrá más parámetros. Lo que pasa es que AddItem desciende directamente del TCheckListBox, mientras que los Add(), Delete(), Exchange(), Insert(), todos corresponden a los Items.* y descienden de los TStrings. Que pasa, que en mi nuevo control pienso redeclarar estas mismas funciones con más parámetros, pero directamente desde el TNewCheckListBox y no desde Items.*

Todo está ok, pero cuando el usuario emplee estos parámetros nativos correspondientes a Items, pierdo el control de esos Items.

Por ejemplo, necesito usar en mi Control lo siguiente:

Código Delphi [-]
var
   grupo: integer;
begin
  grupo:= 1;
  NewCheckListBox1.AddItemGroup('Nombre 1',grupo);
end;

De esta forma yo logro controlar cada Item con su respectivo grupo supongamos. Sin embargo, si el cliente usa:

Código Delphi [-]
var
   grupo: integer;
begin
  grupo:= 1;
  NewCheckListBox1.Items.Add('Nombre 1');  //forma nativa
end;

Ahí pierdo el control de ese registro porque no se que grupo es, y por eso lo que deseo es cuando un registro o item sea agregado de esa forma, yo pueda por ejemplo definir el grupo = 99, para saber que no fue definido.

Otra situación similar o peor es cuando usan el Exchange o Insert porque me cambiaría de posición todos los Items y se me pierdo el control de su respectivo grupo.

En fin, deseo lograr estas dos variantes:

1. Lograr una interrupción de esas funciones Add(), etc nativas del CheckLisBox para autocontrolar esto de los grupos

2. Esconder esas funciones y crear las mías nuevas.

De las 2 preferiría la 1ra porque de lo contrario con la 2da tendría que reescribir mucho código ya en el objeto del que desciende.

Ojalá pueda entenderme, porque creo que está un poco enredado, jaja

[[maeyanes]]

Hola...

El detalle con lo que deseas hacer, es que la propiedad Items es en si un TStringList, y para poder redefinir sus métodos, tendrías que crear una clase que descienda de esa clase.

Algo que tal vez pudieras intentar es agregar manejadores de eventos para los eventos OnChange y OnChanging de la clase TStringList:

Código Delphi [-]
TNewCheckListBox = class(TCheckListBox)
private
  procedure ItemsChanging(Sender: TObject); // Antes del cambio
  procedure ItemsChange(Sender: TObject); // Despues del cambio
public
  constructor Create(AOwner: TComponent); override;
end;

implementation

constructor TNewCheckListBox(AOwner: TComponent);
begin
  inherited;
  Items.OnChanging := ItemsChanging;
  Items.OnChange := ItemsChange
end;

procedure TNewCheckListBox.ItemsChanging(Sender: TObject);
begin
  // Código a ejecutarse antes de que cambien los strings
end;

procedure TNewCheckListBox.ItemsChange(Sender: TObject);
begin
  // Código a ejecutarse luego de que cambien los strings
end;

Lo único es que tendrías que buscar una forma para poder llevar el control de que elementos se modifican de la lista para actuar en consecuencia.


Saludos...

[Sapiem]

No funciona esa variante que me planteas. Lo único que he podido resolver es agregar un objeto a los items que agrego yo directamente de forma tal que aunque los mueva, esa información vaya con ellos, y los demás items que el usuario ingrese por la vía Items.Add, no tienen objeto relacionado y por lo tanto lo ignoro en el análisis.

Que ocurre, que si el usuario decide usar también por su cuenta AddObject entonces se me complica la cosa igual.

Seguiremos intentando.