TNotifyEvent a Cadena?
 

Hola a todos los compañero del foro.

Estoy realizando un componente - en Delphi 5 - para unas labores de la empresa, pero estoy enredado en un pequeño detalle. Resulta que el componente que estoy creando requiere una lista de Acciones (Nombre, Formulario y Evento) que he creado con en un TCollection.

Código Delphi [-]
  TKPlAccionItem = class(TCollectionItem)
  private
    FNombre : String;
    FForma  : TForm;
    FEvento : TNotifyEvent;
    FNomEve : string;
    procedure SetNombre(const Value: String);
    procedure SetEvento(const Value: TNotifyEvent);
    procedure SetForma(const Value: TForm);
    function GetForma: TForm;
  protected
    function GetDisplayName : String; override;
  public
    procedure Assign(Source: TPersistent); override;
  published
    property Nombre : String read FNombre write SetNombre;
    property Forma  : TForm read GetForma write SetForma;
    property Evento : TNotifyEvent read FEvento write SetEvento;
  end;

Este componente tiene como objetivo crear un archivo XML con datos registrados en el, incluyendo las Acciones.

Pero el problema que hasta ahora he tenido es que no logro tomar, convertir, obtener el nombre del evento en una cadena para guardarla en FNomEve.

Código Delphi [-]
//Este es uno de los últimos ejercicios con los que he intentado pero no logro obtener el resultado que espero.
procedure TKPlAccionItem.SetEvento(const Value: TNotifyEvent);
begin
  FEvento := Value;
  FNomEve := MethodName(@Value);
end;

Agradezco si alguno pudiese colaborarme. he buscado en foros, referencias y aún no encuentro nada para resolver la situación.

No se me ocurre como puede hacerse de esa forma, es más, creo que debe hacerse al revés.

TNotifyEvent es en realidad un puntero a un método de otro objeto, a ver si lo aclaro, un "procedure (Sender:TObject) of object", así que, aunque puedas averiguar el nombre, puede que ni te sirva para nada, porque se te complicará todo.

Una cosa, es tener una lista de "procedure of objects" y que en "Evento:integer" en realidad guardes el índice de ese array (o lo que sea).

Lo más simple:

Código Delphi [-]
type Tprocs = procedure (Sender : TObject) of object;
var funciones : array [0..10] of Tprocs


begin

funciones[0] := objeto.metodo1;
funciones[1] := objeto.metodo2;
...

Obviamente funciones siempre se rellena en el mismo orden, por eso solo guardas el índice, que es un entero. Ni RTTI, ni traducciones, ni registerClass ni nada de nada.

Pienso que es lo más simple, pero al no ver el bosque, quizás no sea lo adecuado.

Saludos

Muchas gracias por tu respuesta.

Estoy haciendo pruebas para poder implementar en el componente lo que llegué a conseguir con los datos que me haz pasado.

Código Delphi [-]
..

//Agregué el tipo de dato a la unidad
TKplProc = procedure (Sender : TObject) of object; //Lo de KPL es solo por el estandar de la empresa

..

//En la unidad agregué una variable para el ejercicio
FStTonteria : String; //En el OnCreate asigné a esta variable el valor 'Tonteria'

..

//Agregué un botón que hace una tonteria
procedure TFrmTestPlanEjecD5.BtnTontoClick(Sender: TObject);
begin
  ShowMessage(FStTonteria);
end;

//Y por ultimo agregué este codigo en otro boton donde alfin obtuve el nombre del procedimiento.
procedure TFrmTestPlanEjecD5.BtnProcClick(Sender: TObject);
  var
    lProc : TKplProc;
begin  
  lProc := BtnTontoClick;
  FStTonteria := MethodName(@lProc);
  lProc(BtnTonto); //Esto me llama el otro procedimiento y el resultado es un mensaje diciendo BtnTontoClick
end;

..

Hasta ahora, en el programa de pruebas funciona. pero cuando aplico el mismo código en el componente no funciona.

Código Delphi [-]
  TKPlAccionProc = procedure(Sender : TObject) of object;
  TKPlAccionItem = class(TCollectionItem)
  private
    FNombre : String;
    FForma  : TForm;
    FEvento : TKPlAccionProc;
    FNomEve : string;
    procedure SetNombre(const Value: String);
    procedure SetEvento(const Value: TKPlAccionProc);
    procedure SetForma(const Value: TForm);
    function GetForma: TForm;
  protected
    function GetDisplayName : String; override;
  public
    procedure Assign(Source: TPersistent); override;
  published
    property Nombre : String read FNombre write SetNombre;
    property Forma  : TForm read GetForma write SetForma;
    property Evento : TKPlAccionProc read FEvento write SetEvento;
    property NomEve : string read FNomEve write FNomEve; //Esto lo publique solo para hacer pruebas en el aplicativo
  end;

  ..

  procedure TKPlAccionItem.SetEvento(const Value: TKPlAccionProc);
  begin
    FEvento := Value;
    FNomEve := MethodName(@Value); //Aquí el codigo tal cual lo hago en el programa de pruebas
  end;

  ..

Y en el programa de pruebas tengo

Código Delphi [-]
procedure TFrmTestPlanEjecD5.BtnAddAccionClick(Sender: TObject);
  var
    lAccion : TKplAccionItem;
    lNomEve : string;
begin
  lAccion := KPlGenDefi.Acciones.Add;
  lAccion.Nombre := 'AccionTonta';
  lAccion.Evento := BtnTontoClick; //Aquí efectivamente llama al SetEvento del componente y aunque ejecuta el MethodName no devuelve el nombre
  lNomEve := MethodName(@lAccion.Evento); //En cambio este MethodName si obtiene el nombre del procedure
  ShowMessage(Format('lAccion.NomEve : %s -- lNomEve : %s',
                     [QuotedStr(lAccion.NomEve),
                      QuotedStr(lNomEve)]));
end;

La verdad no se que estoy pasando por alto al implementar en el componente pero no logro obtener el resultado desde la variable del componente pero la variable local lNomEve si muestra el nombre correspondiente "BtnTontoClick".

Es más... haciendo esta modificación para manejar el TNotifyEvent en lugar del objeto, consigo obtener el nombre a partir del TNotifyEvent (cosa que no me funcionaba en el componente).

Código Delphi [-]
procedure TFrmTestPlanEjecD5.BtnAddAccionClick(Sender: TObject);
  var
    lEvento : TNotifyEvent;
    lAccion : TKplAccionItem;
    lNomEve : string;
    lNomNot : string;
begin
  lAccion := KPlGenDefi.Acciones.Add;
  lAccion.Nombre := 'Accion1';
  lAccion.Evento := BtnTontoClick;
  lEvento := BtnTontoClick;
  lNomEve := MethodName(@lAccion.Evento);
  lNomNot := MethodName(@lEvento);
  ShowMessage(Format('lAccion.NomEve : %s -- lNomEve : %s -- lNomNot : %s',
                     [QuotedStr(lAccion.NomEve),
                      QuotedStr(lNomEve),
                      QuotedStr(lNomNot)
                      ]));
end;

Edito: Acabo de ver en Classes.pas que TNotifyEvent = procedure(Sender: TObject) of object... he estado dando vueltas en circulo.

Bueno... a la final no encontré una forma de obtener el nombre dentro del componente y pues agregué al componente un procedimiento para procesar los nombres de las acciones dentro del formulario. Que ahí si funcionaba el obtener el nombre a partir del TNotifyEvent.

En el componente:

Código Delphi [-]
type
  ..
  TKplOnGetNomAcciones = procedure(Sender : TObject; var Acciones : TKPlAccionList) of object;
  ..
  
  TKPlGenDefi = class(TComponent)
  private
    ..
    FAcciones: TKPlAccionList;
    FOnGetNomAcciones: TKplOnGetNomAcciones;
    procedure SetOnGetNomAcciones(const Value: TKplOnGetNomAcciones);
    ..
  published
    ..
    property OnGetNomAcciones : TKplOnGetNomAcciones read FOnGetNomAcciones write SetOnGetNomAcciones;
    ..
  end;

..
Implementation
..

procedure TKPlGenDefi.GenerarDefinicion;
begin
  ..
  //Para obtener el nombre de la acción se debe estar en la unidad
  //donde se encuentra definido ya que desde el componente no
  //se obtiene el nombre.
  if Assigned(FOnGetNomAcciones) then
    FOnGetNomAcciones(Self, FAcciones);
  ..
end;

y en el programa de pruebas:

Código Delphi [-]
procedure TFrmTestPlanEjecD5.KPlGenDefiGetNomAcciones(Sender: TObject; var Acciones: TKPlAccionList);
  var
    i : Integer;
begin
  for i := 0 to Acciones.Count - 1 do
  begin
    if Assigned(Acciones.Items[i].Evento) then
      Acciones.Items[i].NomEve := MethodName(@Acciones.Items[i].Evento);
  end;
end;

De esta manera, ya tengo el nombre de la acción y la podré llevar al XML como lo he intentado desde la semana pasada.

Muchas gracias Lepe por tu colaboración.

Me queda la duda porque desde el componente nunca pude obtener el nombre.

Hola Miguel.

Tal vez es un poco tarde, pero te puede servir.

Un método, como valor procedimental (cual es el caso de un TNotifyEvent), consiste de dos punteros o direcciones de memoria: Una es la dirección del método en sí (en qué byte de la memoria inicia su código máquina) y otra es la dirección de memoria del objeto con el que ha de ejecutarse dicho método.

Para facilitar las cosas, Delphi cuenta con el tipo genérico TMethod:

Código Delphi [-]
type
  TMethod = record
    Code, Data: Pointer;
  end;

El campo Code es la dirección de memoria del código ejecutable del método y Data es la dirección de la instancia de objeto con la cual ha de ejecutarse. Puedes hacer un molde de tipo con TMethod para obtener alguno de los dos valores.

Ahora, observa lo que dice la ayuda de Delphi sobre MethodName:
Como dice la ayuda, MethodName devuelve una cadena vacía si el parámetro dado no apunta a un método publicado del objeto. Publicado significa que se encuentre declarado bajo la visibilidad Published de una clase (sin olvidar que dicha visibilidad es la predeterminada en formularios y otras clases derivadas de TPersistent). Hasta aquí bien.

La parte que no se cumple está en "of the object", por lo que MethodName te funcionó solamente cuando lo llamaste con el formulario, ya que el manejador de eventos consultado pertenece a la misma clase del formulario. En pocas palabras no es lo mismo llamar a Formulario.MethodName que a Componente.MethodName.

Si tienes un valor método, es decir, Code + Data, y Code es un método publicado, tendrás que preguntarle al objeto Data por el nombre de ese método. Solamente la clase (o las clases) a la que pertenece Data podrá darte su nombre. Entonces, para obtener el nombre del método desde el interior del componente es necesario descomponerlo en su Code y Data, preguntándole a Data cuál es el nombre de Code:

Código Delphi [-]
Procedure TKPlAccionItem.SetEvento (Const Value :TNotifyEvent);
Begin
  FEvento := Value;

  If Assigned (Value) Then
    With TMethod (Value) Do
      FNomEve := TObject (Data).MethodName (Code);
End;

Cabe mencionar que MethodName es un método de clase, es decir, ejecutado por la clase a la que pertenece Data, como si la expresión fuera "TForm1.MethodName (ManejadorDeclaradoEnTForm1)".

Para finalizar, decir que a partir de Delphi 2010, gracias a la reflexión extendida (nueva RTTI), algunas de estas cosas pueden realizarse con mayor facilidad.

Espero no haberme "enrollado" demasiado.

Saludos.

Al González. :)

Bienvenido a clubdelphi, ¿ya leiste nuestra guía de estilo?, gracias por tu colaboración :)

:cool: Muy chevere que lo llamen a uno por su nombre de pila en la internet :D... Y no un rollo como este era el que necesitaba. Además que queda como referencia para muchas otras personas que puedan tener la misma duda.

Dejame decirte que ayer cuando ví la respuesta me gustó muchisimo leerla, ya era muy tarde y no hice las pruebas. Pero acabo de hacer la modificación al SetEvento y funciona muy bien. De verdad que gracias no solo por ayudarme a resolver el problema, sino a entender porque sucedia.

Ayer cuando ví el mensaje de la calculadora me quedé como :confused::confused::confused::confused::confused::confused::confused:

Muchas gracias.

En estos días, pocas cosas relacionadas con la programación me dan tanto gusto como saber que he escrito algo que le sirve a otras personas. A colegas Delphi que por ser diversas razones pueden acceder a la realización profesional que a otros se nos niega.

Por cierto, aun en Internet somos personas con nombre, apellido y sentimientos. Suelo nombrar a mis amigos como ellos prefieran, de la misma manera en Internet como presencial y telefónicamente. :)

Saludos y que bueno que ha servido de algo mi intervención.