Acceder a una propiedad
 

Neftalí, vi el truco que pusiste en este enlace de este mismo foro http://clubdelphi.com/foros/showthread.php?t=80803 y te queria consultar algo.

Como se puede hacer para identificar mediante RTTI todos los componentes que sean de un tipo sin importar si son propios de Delphi o son los creados por terceros. Lo que intento es hacer algo como identificar a todos los componentes que sean del tipo ingreso de datos y cuando se ingresa a uno de ellos que se le cambie el color del fondo y cuando se salga se le ponga el color original.

Creo que no hace falta explicar porque se quiere hacer algo de esta forma y no uno por uno en cada pantalla.

Saludos,
El Rayo

Hola elrayo.

De este modo, cambiará el color del control que posee el foco y lo restaurará al perderlo siempre que el mismo posea la propiedad Color:

Código Delphi [-]
...
const
  WM_AFTER_CREATE = WM_USER + 300;

type
  TForm1 = class(TForm)
     .... 
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
  private
    FPrevFocusedCtrl : TWinControl;
    FPrevFocusedColor: TColor;
    FFocusedColor    : TColor;
    procedure WmAfterCreate(var Msg: TMessage); message WM_AFTER_CREATE;
    procedure ActiveCtrlChange(Sender: TObject) ;
  public
  end;

var
  Form1: TForm1;

implementation 

uses TypInfo;

procedure TForm1.WmAfterCreate(var Msg: TMessage);
begin
  Screen.OnActiveControlChange := ActiveCtrlChange;
  FPrevFocusedCtrl := Screen.ActiveControl;
  if Assigned(GetPropInfo(FPrevFocusedCtrl.ClassInfo,'Color')) then
  begin
    FPrevFocusedColor := TColor(GetOrdProp(Screen.ActiveControl,'Color'));
    SetOrdProp(Screen.ActiveControl, 'Color', FFocusedColor);
  end;
end;

procedure TForm1.ActiveCtrlChange(Sender: TObject);
begin
  if Assigned(GetPropInfo(FPrevFocusedCtrl.ClassInfo, 'Color')) then
    SetOrdProp(FPrevFocusedCtrl, 'Color', FPrevFocusedColor);
  if Assigned(GetPropInfo(Screen.ActiveControl.ClassInfo,'Color')) then
  begin
    FPrevFocusedColor:= TColor(GetOrdProp(Screen.ActiveControl,'Color'));
    SetOrdProp(Screen.ActiveControl, 'Color', FFocusedColor);
  end;
  FPrevFocusedCtrl:= Screen.ActiveControl;
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  ...
  FFocusedColor := clLime;
  PostMessage(Handle, WM_AFTER_CREATE, 0, 0);
end;

...

procedure TForm1.FormDestroy(Sender: TObject);
begin
  Screen.OnActiveControlChange := nil;
end;

Saludos :)

Gracias por responder amigo, pero en realidad la solución es incompleta para lo que yo quiero hacer.

Lo que pretendo y que a lo mejor no me explique del todo bien es lo siguiente: Necesito mediante RTTI poder identificar que clase es el componente, o sea que me diga si es un TEdit, TLabel, TMemo, etc. Luego con esto se que componentes cambiar el color y a cuales no, porque no ha todos se lo tengo que hacer.

Además si hago lo que pretendo ¿esto funcionará con los componentes de terceros?. Lo que me interesa es que esto sea algo genérico que pueda usar en cualquier pantalla y no hacerlo en cada una y por cada tipo de componente.

Desde ya muchas gracias,
El Rayo

Hola elrayo76.

Creo que realmente no logro interpretar lo que buscas, pero en cuanto a obtener la información que mencionas,
dispones de los métodos:

• ClasInfo
• ClassType
• ClassName
• ClassNameIs

Así como también la función RealGetWindowClass de la API de Windows.

Saludos. :)

Amigo ecfisa,

A lo que me refiero es que no quiero tener que hacer algo que yo compare si el componente al que le quiero cambiar el color es del tipo TEdit, TDBEdit, TRxEdit u otro. En lengua española seria como decir simplemente lo siguiente: todos los componentes que son editables cambiale el color cuando ingresas o cuando salis del mismo.

Si tengo que decir el compoente editable de las Jedi o el compoente editable de las RXlib o de cual fuere no tiene sentido que pregunte porque eso lo se hacer. Además si el día de mañana cambio un componente de esos por otro de otro desarrollador quiero que lo que tengo diseñado siga funcionando y en lo posible sin tocar nada

Saludos

Yo tampoco entiendo muy bien lo que quieres hacer exactamente. Y supongo que el hecho de que sea por RTTI o no es indiferente siempre y cuando lo puedas hacer.

Me da la sensación que quieres saber cuando es "una caja de texto" o algo así. Cuando dices componentes de un mismo tipo, haces una tipificación personal, que nada tiene que ver con que exista ese tipo en Delphi, por lo tanto, sólo se me ocurre que casi todos los componentes de ese tipo acaban heredando de TCustomEdit, por lo tanto se podría preguntar

Código Delphi [-]
if Objeto is TCustomEdit then

Ya sé que esto no es usando RTTI, pero es que no sé de que forma te puede ayudar el RTTI a saber algo así, y mucho menos controlarlo en un componente de un tercero.

Lo mismo no es esto lo que quieres saber puesto que el título del hilo, "Acceder a una propiedad", no tiene nada que ver.

Un saludo.

Y si te he entendido bien, más que "Editable" diría "Caja de texto". Componentes editables hay muchos.

Bueno si me exprese mal cuando dije editable. Es como dices 'caja de texto'.

Por otro lado eso que comentas puede que me funcione y es justamente similar a lo que hice alguna vez. Tendría que probarlo y ver si funciona con los componentes de terceros.

Tu dices que lo que pregunt en el titulo nada que ver con esto, si tienes razon pero esta todo anidado y en su momento crei que mediante RTTI se podría ahacer algo bastante genérico como para no tocarlo si se cambian los componentes.

Cualquir cosa los comento como me fue.

Saludos,

Mi estimado elrayo76, me temo que eso es mas simple de decir que de implementar... :)

La cuestión es: ¿ Que factor común se debería tomaría para identificar a un control como editable ?

A primera vista se podría pensar que todos aquellos que posean la propiedad Text, aunque no todos los que la poseen permiten ingresar datos...

Hasta Delphi 2010, mediante RTTI , sólo son accesibles las propiedades publicadas. (creo que luego existe la unit RTTI.PAS que permite acceder a las públicas)

Pero mi Delphi 7 no puede :(; dejaría inmerecidamente fuera de la lista por ejemplo al TDateTimePicker, al TMemo y al TRichEdit que no publican la propiedad Text y sin embargo tan generosamente nos permiten escribir en ellos.


Entonces, si tuviera que darle una solución con la herramienta con que dispongo haría:

Código Delphi [-]
unit PaintEditCtrl;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, ExtCtrls, Mask, Grids, ComCtrls, DBCtrls,DBGrids;

const
  WM_AFTER_CREATE = WM_USER + 300;

type
  TForm = class(Forms.TForm)
  private
    FPrevFocusedCtrl : TWinControl;
    FPrevFocusedColor: TColor;
    FFocusedColor    : TColor;
    function IsEditable(WC: TWinControl): Boolean;
    procedure WmAfterCreate(var Msg: TMessage); message WM_AFTER_CREATE;
    procedure ActiveCtrlChange(Sender: TObject);
  public
    constructor Create(AOWner: TComponent); override;
    destructor Destroy; override;
    property FocusedColor : TColor read FFocusedColor write FFocusedColor;
  end;

implementation

uses TypInfo;

var
 WCArray : array of TWinControlClass;

// Create
constructor TForm.Create(AOWner: TComponent);
begin
  inherited;
  FFocusedColor := clActiveCaption;

  // Componentes sobre los que se puede editar
  SetLength(WCArray, 9);
  WCArray[0] := TEdit;
  WCArray[1] := TMemo;
  WCArray[2] := TComboBox;
  WCArray[3] := TMaskEdit;
  WCArray[4] := TStringGrid;
  WCArray[5] := TLabeledEdit;
  WCArray[6] := TRichEdit;
  WCArray[7] := TDateTimePicker;
  WCArray[8] := TDBEdit;
  //...

  PostMessage(Handle, WM_AFTER_CREATE, 0, 0);
end;

// Devuelve True si la clase debe pintarse
function TForm.IsEditable(WC: TWinControl): Boolean;
var
  i: Integer;
begin
  Result := False;
  for i := Low(WCArray) to High(WCArray) do
    if (WC is WCArray[i]) and  Assigned(GetPropInfo(WC.ClassInfo,'Color')) then
      Result := True;
end;

// After Create
procedure TForm.WmAfterCreate(var Msg: TMessage);
begin
  Screen.OnActiveControlChange := ActiveCtrlChange;
  FPrevFocusedCtrl := Screen.ActiveControl;
  if IsEditable(FPrevFocusedCtrl) then
  begin
    FPrevFocusedColor := TColor(GetOrdProp(Screen.ActiveControl,'Color'));
    if IsEditable(FPrevFocusedCtrl) then
      SetOrdProp(FPrevFocusedCtrl,'Color',FFocusedColor);
  end;
end;

// Cambia control activo
procedure TForm.ActiveCtrlChange(Sender: TObject);
begin
  if IsEditable(FPrevFocusedCtrl) then
    SetOrdProp(FPrevFocusedCtrl, 'Color', FPrevFocusedColor);
  if IsEditable(Screen.ActiveControl) then
  begin
    FPrevFocusedColor := TColor(GetOrdProp(Screen.ActiveControl, 'Color'));
    SetOrdProp(Screen.ActiveControl, 'Color', FFocusedColor);
  end;
  FPrevFocusedCtrl := Screen.ActiveControl;
end;

// Destroy
destructor TForm.Destroy;
begin
  Screen.OnActiveControlChange := nil;
  Finalize(WCArray);
  inherited;
end;

end.

Uso:

Código Delphi [-]
unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs,  StdCtrls, ExtCtrls, Grids, Mask, Buttons, ComCtrls, DBCtrls,DBGrids,
  PaintEditCtrl; (* Importante: Inclusión de PaintEditCtrl en la sección de interface *)

type
  TForm1 = class(TForm)
  private
    ...
  public
  end;

var
  Form1: TForm1;

implementation {$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
begin
  FocusedColor := clActiveCaption;
end;

end.

De ese modo mi trabajo sería: Incluir la unidad, declarar el color del foco y de vez en cuando, agregar al arreglo los nuevos componentes que vaya incorporando.... Todo esto sin salirme de los que están basados en la VCL.

Saludos :)

ecfisa,

Excelente ^\||/ :)

Nelson.

+1 a ecfisa. Me gusta la solución.

Si bien es cierto que uno debe de acordarse de agregar cada nuevo componente del supuesto tipo "editable", pero es solo eso.

Aunque lo dicho, puesto que muchos de ellos (incluidos TMemo y TEdit), haría menos vueltas en el loop poniendo lo de TCustomEdit. Además, todos los que hereden de TCustomEdit, de TEdit, o de TMemo, no haría falta ponerlos.