Acceder a propiedades componentes de un form
 

Hola compañeros me gustaria saber si es posible acceder a las diferentes propiedades de componentes un form, o sea los que sean dbedit, edit, sbmemo, memo, combobox, editbutton, lo que me gustaria es poder soltar en el form el componente y cuando en uno de estos componentes se entre se active las propiedades dentro del componente que quiero diseñar, cambiando el color de entrada y salida, la fuente de entrada y salida y la posibilidad de hacer un zomm al entrar.

Hola Jose Luis.

Hasta aquí puedo contestar que sí.
El problema es que a partir de aquí hay cosas que no me quedan claras.

Supongo que todo esto quieres hacerlo en diseño, pero no me acaba de quedar claro el tema de las fuentes, del zoom,...
Estoy espeso y no acabo de ver a dónde quieres ir a parar... :o

Gracias como siempre por tu rapida respuesta Neftali, aclaro lo que quiero hacer

el tema es que en vez de crear cada componente con las propiedades de color entrada y salida, zoom entrada y salida y fuentes para cuando entra y sales, pense sería mucho más practico colocar un componente en el form que al pasar de un componente a otro compuebe si esta entre los componentes anteriormente descritos y si se ha aproducido el evento OnEnter ó OnExit, si es adí podemos definir en un solo componente un color de entrada o Salida, Fuentes al estar en foco o no, zoom, o lo que se nos pueda ocurrir, por tanto menos código y mas facil de personalizar el tratamiento de los componentes del formulario. Claro esá es mi opinión. La elección de estos componentes es por que tiene estas propiedades y eventos.

No es que tenga olvidado mis otros componentes, pero por ejemplo mi grid, esta parado con un aspecto increible (según mi opinón), pero he solicitado permiso al señro David Reed para el uso de parte de su código y aún no he recibido respuesta. Lo malo esque tengo como un par de agendas apuntadas con ideas y componentes, pero no tengo la capacidad suficiente como para aplicarlo, por eso tantas preguntas y el ir tan despacio.

Ahora creo que me queda más claro.
Quieres "centralizar" el tratamiento de determinadas propiedades de los componentes del formulario en uno sólo. ¿Es eso?

Creo que puede ser una buena idea.

Yo añadiría que, de alguna manera pudieras definir qué componentes del formulario quieres controlar o cuales quieres ignorar, por si hay alguno al que no quieres cambiarle las propiedades.

Puedes recorrer los componentes del formulario sin problemas con la propiedad Components.
Para acceder a consultar y modificar las propiedades de los componentes que desees puedes utilizar RTTI. En mi página hay alguns ejemplos:

Acceder a las propiedades de un componente vía RTTI

Modificar propiedades de controles en ejecución utilizando RTTI

echare un vistazo en cuanto pueda, e intentare, en cuanto a

que te parece el tag de cada componente??

Es la primera opción que he pensado. Es la más sencilla.

Lo siguiente que se me ha oocurrido es una lista de Clases ignoradas (TEdit, TComboBox) y una lista de componentes ignorados (TEdit1, TCombobox5,...)

Y por último ya se me ha ido la olla y se me ha ocurrido que se podría hacer (afinando mucho) un editor para esta propiedad donde se puedieran seleccionar visualmente los componentes que se quieren y los que no...:D:D

Perdona pero yo soy un simple mortal :D:D:D, con poco tiempo para programar y perdona pero me ACOJONAS (y pido perdón por la palabra y su significado .

Yo también José Luis, yo también,... :D:D
La opción del TAG es la más sencilla y la más simple y para comenzar debe funcionar. Yo mismo es la que uso en el componente TSelectOnRuntime.

Si necesitas ayuda con el componente, coméntamelo, el tema de RTTI me gusta e intentar estas cosas siempre es un buen reto. ;)

tan pronto tenga un poco de tiempo empecare y publicare, de todas maneras buscando en el club me encontre con este tema y pienso que podiamos partir de aqui con el tema delas RTTI.

Ni me acordaba de ese hilo y mira que participé y todo.... :o (memoria de pez que tiene uno...) Parece que es un buen punto de partida.

Aquí esta recien salido del horno, pongo el código completo, espero os guste y quedo a la espera de las correciones que hagais:D

Código Delphi [-]
//////////////////////////////////////////////////////////////
//Este componente parte de uno del compañero PBorges36 y  Grandel
//Que gentilmente compartienron con nuestra comunidad en nuestro
//Valiosicimo ClubDelphi
//
//Fundamental es tambien la participacion en la idea y el
//planteameiento del compañero Neftali
//
// 21/03/2009   JLGT  Verdion 1.0
//Este componente es Freeware y se puede modificar y alterar
//Siempre y cuando se distribuya libremente las modificaciones
//Se ue se puede acortar el código, pero prefiero
//dejarlo de esta manera para poder comprenderlo mejor
///////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////
//Para su uso se recomienda activar  en el primer active de la aplicación
//y desactivarlo al cerrarse la aplicación para evitar errores
//tener en cuenta que el componente afecta a windows, y por lo tanto a
//otras aplicaciones
///////////////////////////////////////////////////////////////


unit ScreenColorFontZoomCenter;

interface

uses
  Windows, ExtCtrls, Messages,SysUtils, Classes, Graphics,
  StdCtrls, ComCtrls, Controls, Forms, TypInfo, Dialogs ;

type
  TVZoomVal = 1..4;
  TCenterScreenColorFontZoom = class(TComponent)
  private
    { Private declarations }
    FActive: Boolean;                          //Activa el uso del componente  NO OLVIDAR DESACTIVAR AL CERRA EL FORM
    FTag: integer;                             //Da una proiedad tag al componente
    FColorActive: Boolean;                     //Activa el uso del color altener/perder el foco
    FColorConFoco: TColor;                     //Color de entrada en el foco
    FColorSinFoco: TColor;                     //Color de Salida del Foco
    FPierdeFoco, FTieneFoco: TWinControl;      // a partir de WinControl pueden recibir el foco
    FForm: Boolean;                            //Para usar el proceso en el form o no
    FColorForm: TColor;                        //Establecer el color de fondo del Fom si se activa FFForm al perder el foco
    FTagValorAdmit: Integer;                   //Leera el valor del Tag permitido para apñllicar los efectos por defecto 0 si
                                               //se establece en un componente el tag <> 0 (o valor establecido) no afectaria este componente
    FZoomActive: Boolean;                      //Activa el uso de Zoom en el componente
    FZoomVal: TVZoomVal;                       //Desactiva el Uso de Zoom en el compoenete
    FFontActive :boolean;                      //Aciva el uso de fuentes
    FFontProg: Boolean;                        //USar fuente por defecto en el componente al salir
    FFontFocus: Tfont;                         //Fuente cuando se tiene el foco
    FFontNoFocus: Tfont;                       //Fuente cuando se pierde el foco
    FPanel: Boolean;                           //Afectar a PAneles o no
    FOnFocusChange: TNotifyEvent;              //Evento al Cambiarse el foco
    procedure ScreenActiveControlChange(Sender: TObject);
 //   procedure SetColorActive(value: boolean);
//    procedure SetTagValorAdmit(value: integer);
  protected
    { Protected declarations }
  public
    { Public declarations }
    //Cambiar propiedad color y añadir Zoom, zoomval y font
    //{ORIGINAL}  Procedure AplicarColor(Color: TColor; Componente: TWinControl);
    Procedure AplicarColor(Color: string; Componente: TWinControl);
    constructor Create(AOwner : TComponent); override;
    destructor Destroy; override;

  published
    { Published declarations }
    property Active: boolean             read FActive          write FActive         default False;
    property Tag: integer                read FTag             write FTag;
    property ColorConFoco: TColor        read FColorConFoco    write FColorConFoco;
    property ColorSinFoco: TColor        read FColorSinFoco    write FColorSinFoco;
    property ColorActive: boolean        read FColorActive     write FColorActive    default True;
    property Form: boolean               read FForm            write FForm           default False;
    property TagValorAdmit: integer      read FTagValorAdmit   write FTagValorAdmit  default 0;
    property ZoomActive: Boolean         read FZoomActive      write FZoomActive     default False;
    property ZoomVal: TVZoomVal          read FZoomVal         write FZoomVal        default 1;
    property FontActive: Boolean         read FFontActive      write FFontActive     default False;
    property FontProg: Boolean           read FFontProg        write FFontProg       default False;
    property PAnel: Boolean              read FPanel           write FPanel          default False;
    property FontFocus: TFont            read FFontFocus       write FFontFocus;
    property FontNoFocus: TFont          read FFontNoFocus     write FFontNoFocus;
    property OnFocusChange: TNotifyEvent read FOnFocusChange   write FOnFocusChange;
  end;

var VarCompUsage: Integer;
procedure Register;


implementation

//Bajado de http://www.chami.com/tips/delphi/112596D.html  ---------------------[1]

//El Codigo bajo las siguientes lineas no se termino usando en el componenete, pero me parecio
//Interesante mantenerlo para posibles futuros usos.
const
  csfsBold      = '|Bold';
  csfsItalic    = '|Italic';
  csfsUnderline = '|Underline';
  csfsStrikeout = '|Strikeout';
//
// Expected format:
//   "Arial", 9, [Bold], [clRed]
//

//Pasamos de String a font
procedure StringToFont(   sFont : string; Font : TFont );
var
  p      : integer;
  sStyle : string;
begin
  with Font do
  begin
    // get font name
    p    := Pos( ',', sFont );
    Name := Copy( sFont, 2, p-3 );
    Delete( sFont, 1, p );
        // get font size
    p    := Pos( ',', sFont );
    Size := StrToInt( Copy( sFont, 2, p-2 ) );
    Delete( sFont, 1, p );
        // get font style
    p      := Pos( ',', sFont );
    sStyle :=  '|' + Copy( sFont, 3, p-4 );
    Delete( sFont, 1, p );
        // get font color
    Color :=  StringToColor( Copy( sFont, 3, Length( sFont ) - 3 ) );
        // convert str font style to
    // font style
    Style := [];
    if( Pos( csfsBold, sStyle ) > 0 )then Style := Style + [ fsBold ];
    if( Pos( csfsItalic, sStyle ) > 0 )then  Style := Style + [ fsItalic ];
    if( Pos( csfsUnderline, sStyle ) > 0 )then  Style := Style + [ fsUnderline ];
    if( Pos( csfsStrikeout,  sStyle ) > 0 )then  Style := Style + [ fsStrikeout ];
  end;
end;

//
// Output format:
//   "Aril", 9, [Bold|Italic], [clAqua]
//

//PAsamos de font a String
function FontToString( Font : TFont ) : string;
var
  sStyle : string;
begin
  with Font do
  begin
    // convert font style to string
    sStyle := '';
    if( fsBold in Style )then  sStyle := sStyle + csfsBold;
    if( fsItalic in Style )then sStyle := sStyle + csfsItalic;
    if( fsUnderline in Style )then sStyle := sStyle + csfsUnderline;
    if( fsStrikeout in Style )then  sStyle := sStyle + csfsStrikeout;
    if( ( Length( sStyle ) > 0 ) and ( '|' = sStyle[ 1 ] ) )then
    begin
      sStyle := Copy( sStyle, 2, Length( sStyle ) - 1 );
    end;
    Result := Format( '"%s", %d, [%s], [%s]',  [ Name,  Size,  sStyle, ColorToString( Color ) ] );
  end;
end;
//------------------------------------------------------------------------------[1]
//USO DEL RTTI------------------------------------------------------------------[2]
  //·······················································································
  // Comprueba si existe una propiedad con ese nombre
  function ExistProp(Instance: TObject; const PropName: string):Boolean;
  var
    PropInfo: PPropInfo;
  begin
    // Busca la propiedad y deviuelve la estructura nil
    PropInfo := GetPropInfo(Instance, PropName);
    Result := not (PropInfo = nil);
      end;

  //·······················································································
  // Cambia el valor de la propiedad
  function SetPropAsString(AObj: TObject; const PropName, Value: String):Boolean;
  var
    PInfo: PPropInfo;
  Begin
    // Intentamos acceder (con un puntero) a la info. de la propiedad
    PInfo := GetPropInfo(AObj.ClassInfo, PropName);
    Result := PInfo <> nil;

    // Se ha obtenido la información...
    if (Result) then
    begin
      // Se ha encontrado la propiedad con éste nombre; Chequear el tipo...
      if (PInfo^.Proptype^.Kind = tkString) or (PInfo^.Proptype^.Kind = tkLString) then
      begin
        // Asignar el valor de tipo String
        SetStrProp(AObj, PInfo, Value);
      end else
      if (PInfo^.Proptype^.Kind = tkInteger) then
      begin
         // Asignar el valor...
         if (PInfo^.PropType^.Name = 'TColor') then
         begin
               SetOrdProp(AObj, PInfo, StringToColor(Value));
         end else
         begin
            SetOrdProp(AObj, PInfo, StrToInt(Value));
         end;
      end else
      begin
               Result := False;
               MessageDlg('''La propiedad '' + PropName + '' no es de tipo String (o un tipo implementado)', mtWarning, [mbOK], 0);
       end;
    end  else
    begin
      // No se ha encontrado la propiedad con ese nombre
      Result := False;
    end;
  end;
//FIN USO DEL RTTI--------------------------------------------------------------[2]

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

constructor TCenterScreenColorFontZoom.Create(AOwner : TComponent);
begin
  inherited Create(AOwner);
  Screen.OnActiveControlChange := ScreenActiveControlChange;
  FColorConFoco := clSkyBlue;
  FColorSinFoco := clWindow;
  FColorActive:= True;
  FTagValorAdmit:=0;
  FForm :=False;
  FActive:=False;
  FZoomActive:= False;
  FZoomVal:=1;
  FFontActive:=False;
  FFontProg:=False;
  FFontFocus:=TFont.Create;
  FFontNoFocus:=TFont.Create;
  FPanel:=False;
  VarCompUsage:=0;
end;

destructor TCenterScreenColorFontZoom.Destroy;
begin
  Screen.OnActiveControlChange := nil;
  FFontNoFocus.Free();
  FFontFocus.Free();
  inherited;
end;

procedure TCenterScreenColorFontZoom.ScreenActiveControlChange(Sender: TObject);
begin
  FPierdeFoco := FTieneFoco;
  FTieneFoco  := Screen.ActiveControl;
  //Sólo si esta activo el componente
  if FActive=True then
  begin
    //Si el control activo no es un TFOM y ademas la propiedad FForm no sea false
    if not ((Screen.ActiveControl.ClassType = TForm) and (FForm=False)) then
    begin
      //Si el valor del tag del control es igual al de la propiedad FtagValoradmit
      if FPierdeFoco <> nil then   //PAra el Componente que pierde el Foco
      begin
           if FPierdeFoco.Tag=FTagValorAdmit then
           begin
            if not ((FPierdeFoco.ClassType=TPanel) and (FPanel=False)) then
            begin
               //Si esta activo el color
               if FColorActive=true then   Self.AplicarColor(ColorToString(FColorSinFoco), FPierdeFoco);
               if FZoomActive = true then
               begin      //Idea del compañero Jhonny en tema http://www.clubdelphi.com/foros/show...nt+twincontrol
                   TEdit(FPierdeFoco).Font.Size:=(Tedit(FPierdeFoco).Font.Size div Fzoomval);
                   FPierdeFoco.Width:=(FPierdeFoco.Width div FZoomVal);
                end;
               if FFontActive=true then TEdit(FPierdeFoco).font:=FFontNoFocus;
            end;
             VarCompUsage:=0; //Decimos que no hay un componente activado
           end;
      end;

      if FTieneFoco <> nil then   //Para el componente que adquiere el foco
      begin
           if FTieneFoco.Tag=FTagValorAdmit then
           begin
               if not ((FTieneFoco.ClassType=TPanel) and (FPanel=False)) then
               begin
                 if FColorActive=true then self.AplicarColor(ColorToString(FColorconFoco), FTieneFoco);
                 if FFontActive=true then
                 begin
                   //Si activamos FFontProg cuando pierda el fco volvera a la que estipulemos anteriormente
                   //En caso contrario devolvera el Font establecido en FontNoFocus
                   if FFontProg=true then FFontNoFocus:=TEdit(FTieneFoco).Font;
                   TEdit(FTieneFoco).Font:=FFontFocus;
                 end;
                if FZoomActive = true then
                begin   //Idea del compañero Jhonny en tema http://www.clubdelphi.com/foros/show...nt+twincontrol
                   TEdit(FTieneFoco).Font.Size:=(Tedit(FTieneFoco).Font.Size * Fzoomval);
                   FTieneFoco.Width:=(FTieneFoco.Width * FZoomVal);
                   FTieneFoco.BringToFront;
                end;
                FTag := self.Tag;
                VarCompUsage:=1; //Decimos que hay un componente activado
              end;
           end;
      end else   FTag := 0;
    end;
  end else
  begin
      if (VarCompUsage=1) then  //Comprobamos si hay algún componente activo con anterioridad
      begin
        if FPierdeFoco.Tag=FTagValorAdmit then
        begin
          if not ((FPierdeFoco.ClassType=TPanel) and (FPanel=False)) then
          begin
            if FColorActive=true then   Self.AplicarColor(ColorToString(FColorSinFoco), FPierdeFoco);
            if FZoomActive = true then
            begin      //Idea del compañero Jhonny en tema http://www.clubdelphi.com/foros/show...nt+twincontrol
                  TEdit(FPierdeFoco).Font.Size:=(Tedit(FPierdeFoco).Font.Size div Fzoomval);
                  FPierdeFoco.Width:=(FPierdeFoco.Width div FZoomVal);
            end;
            if FFontActive=true then TEdit(FPierdeFoco).font:=FFontNoFocus;
          end;
        end;
        VarCompUsage:=0;    //Decimos que no hay componentes activos
      end;
      FTag:=0;
  end;

  if Assigned(FOnFocusChange) then FOnFocusChange(Self);
end;

Procedure TCenterScreenColorFontZoom.AplicarColor(Color :String; Componente: TWinControl);
begin
  try
    if ExistProp(Componente,'Color') then SetPropAsString(Componente,'Color',Color);
// ORIGINAL -------------------------------------------------------------------------------
//    if (Componente is TCustomEdit)     then (Componente as TEdit).Color := Color;
//    if (Componente is TDateTimePicker) then (Componente as TDateTimePicker).Color:= Color;
//    if (Componente is TCustomMemo)     then (Componente as TMemo).Color:= Color;
//    if (Componente is TCustomComboBox) then (Componente as TComboBox).Color:= Color;
//
//    (Componente as TWinControl).Repaint;
//------------------------------------------------------------------------------------------
  except
  end;
end;
end.

Espero que este al nivel adecuado y este lo suficientemente dosumentado.

Vueno el componente funciona pero cuando pueda intentare mejorar cosas que no me gusta que haga, como darme un error si entro en el editor de propiedades del font, tener que poner a ciertos componentes que no queria que afectara un tag no valido, etc., así mismo intentare utilizar el agrupamiento de propiedades. etc, pero no se cuando me pondré con el.

Estaría bien que lo subieras al FTP José Luis, así será mças fácil encontrarlo (que no el hilo). Me alegro de que al final lo hayas terminado.

Precisamente estoy intentando corregir varios efectos que no me gustan, cuando termine ya lo subiré y publicare en el for.

Gracias Neftali.

Lamento comunicar que las partes de Font y zoom no son implementables en este componente, después de días intentando mejorarlo, me topo con los siguientes problemas insalvables, por lo menos par mi, Ocurre que si seleccionamos por ejemplo un botón, se pierde el foco, pero ese no es el problema, este ocurre cuando, ponemos enable en false, donde estaba activo anteriormente el componente, sin haber podido salir del foco, o cuando ejecutamos un SetFocus, el componente no logra registrar, este cambio. De Todas maneras, reescribiré el componente, para que quede completo, con el control de diferentes componentes, etc.

Pues nada aquí esta el código como queda

Código Delphi [-]
//////////////////////////////////////////////////////////////
//Este componente parte de uno del compañero PBorges36 y  Grandel
//Que gentilmente compartienron con nuestra comunidad en nuestro
//Valiosicimo ClubDelphi
//
//Fundamental es tambien la participacion en la idea y el
//planteameiento del compañero Neftali
//
// 21/03/2009   JLGT  Verdion 1.0
//Este componente es Freeware y se puede modificar y alterar
//Siempre y cuando se distribuya libremente las modificaciones
//Se ue se puede acortar el código, pero prefiero
//dejarlo de esta manera para poder comprenderlo mejor
///////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////
//Para su uso se recomienda activar  en el primer active de la aplicación
//y desactivarlo al cerrarse la aplicación para evitar errores
//tener en cuenta que el componente afecta a windows, y por lo tanto a
//otras aplicaciones
///////////////////////////////////////////////////////////////


unit ScreenColorCenter;

interface

uses
  Windows, ExtCtrls, Messages,SysUtils, Classes, Graphics,
  StdCtrls, ComCtrls, Controls, Forms, TypInfo, Dialogs ;
// Math, Forms;

type
  TCenterScreenColor = class(TComponent)
  private
    { Private declarations }
    FActive: Boolean;                          //Activa el uso del componente  NO OLVIDAR DESACTIVAR AL CERRA EL FORM
    FColorActive: Boolean;                     //Activa el uso del color altener/perder el foco
    FColorConFoco: TColor;                     //Color de entrada en el foco
    FColorSinFoco: TColor;                     //Color de Salida del Foco
    FTagValorAdmit: Integer;                   //Leera el valor del Tag permitido para apñllicar los efectos por defecto 0 si
                                               //se establece en un componente el tag <> 0 (o valor establecido) no afectaria este componente
    FForm: Boolean;                            //Para usar el proceso en el form o no
    FEdit_DBEdit:Boolean;                      //Afecta a edits y dbedits
    FMEmo_DbMEmo:Boolean;                      //Afecta a Memos y dbmemos
    FComboBox_DBCombobox: Boolean;             //Afecta a Combocbox y dbcombobox
    FOther: Boolean;                           //Afecta a l resto de los componentes
                                               //Ojo other puede darnos efectos no deseados
    FTag: integer;                             //Da una proiedad tag al componente
    FPierdeFoco, FTieneFoco: TWinControl;      // a partir de WinControl pueden recibir el foco
    FOnFocusChange: TNotifyEvent;              //Evento al Cambiarse el foco

    procedure ScreenActiveControlChange(Sender: TObject);
    procedure SetColorConFoco(const Value: TColor);
    procedure SetColorSinFoco(const Value: TColor);

  protected
    { Protected declarations }

  public
    { Public declarations }
    //Cambiar propiedad color y añadir Zoom, zoomval y font
    //{ORIGINAL}  Procedure AplicarColor(Color: TColor; Componente: TWinControl);
    Procedure AplicarColor(Color: string; Componente: TWinControl);
    procedure AdmitComponent(Component:TWinControl);
    constructor Create(AOwner : TComponent); override;
    destructor Destroy; override;

  published
    { Published declarations }
    property Active: boolean               read FActive              write FActive              default False;
    property ColorActive: boolean          read FColorActive         write FColorActive         default True;
    property ColorConFoco: TColor          read FColorConFoco        write SetColorConFoco;
    property ColorSinFoco: TColor          read FColorSinFoco        write SetColorSinFoco;
    property TagValorAdmit: integer        read FTagValorAdmit       write FTagValorAdmit       default 0;
    property Form: boolean                 read FForm                write FForm                default False;
    property Edit_DBEdit: boolean          read FEdit_DBEdit         write FEdit_DBEdit         default True;
    property MEmo_DbMEmo: boolean          read FMEmo_DbMEmo         write FMEmo_DbMEmo         default True;
    property ComboBox_DBCombobox: boolean  read FComboBox_DBCombobox write FComboBox_DBCombobox default True;
    property Other: Boolean                read FOther               write FOther               default False;
    property Tag: integer                  read FTag                 write FTag;
    property OnFocusChange: TNotifyEvent   read FOnFocusChange       write FOnFocusChange;
  end;

var VarCompUsage,VarCompAdm: Integer;
    VarPrivPassComponent: Boolean;             //Esta variable nos permitira saber si usar los efectos en el componente
procedure Register;

implementation

//USO DEL RTTI------------------------------------------------------------------[2]
  //·······················································································
  // Comprueba si existe una propiedad con ese nombre
  function ExistProp(Instance: TObject; const PropName: string):Boolean;
  var
    PropInfo: PPropInfo;
  begin
    // Busca la propiedad y deviuelve la estructura nil
    PropInfo := GetPropInfo(Instance, PropName);
    Result := not (PropInfo = nil);
  end;

  //·······················································································
  // Cambia el valor de la propiedad
  function SetPropAsString(AObj: TObject; const PropName, Value: String):Boolean;
  var
    PInfo: PPropInfo;
  Begin
    // Intentamos acceder (con un puntero) a la info. de la propiedad
    PInfo := GetPropInfo(AObj.ClassInfo, PropName);
    Result := PInfo <> nil;

    // Se ha obtenido la información...
    if (Result) then
    begin
      // Se ha encontrado la propiedad con éste nombre; Chequear el tipo...
      if (PInfo^.Proptype^.Kind = tkString) or (PInfo^.Proptype^.Kind = tkLString) then
      begin
        // Asignar el valor de tipo String
        SetStrProp(AObj, PInfo, Value);
      end
      else
      if (PInfo^.Proptype^.Kind = tkInteger) then
      begin
         // Asignar el valor...
         if (PInfo^.PropType^.Name = 'TColor') then
         begin
               SetOrdProp(AObj, PInfo, StringToColor(Value));
         end else
         begin
            SetOrdProp(AObj, PInfo, StrToInt(Value));
         end;
      end
      else
      begin
               Result := False;
               MessageDlg('''La propiedad '' + PropName + '' no es de tipo String (o un tipo implementado)', mtWarning, [mbOK], 0);
       end;
    end  else
    begin
      // No se ha encontrado la propiedad con ese nombre
      Result := False;
    end;
  end;
//FIN USO DEL RTTI--------------------------------------------------------------[2]

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

constructor TCenterScreenColor.Create(AOwner : TComponent);
begin
  inherited Create(AOwner);
  Screen.OnActiveControlChange := ScreenActiveControlChange;
  FColorConFoco := clSkyBlue;
  FColorSinFoco := clWindow;
  FColorActive:= True;
  FTagValorAdmit:=0;
  FForm :=False;
  FActive:=False;
  FEdit_DBEdit:=True;
  FMEmo_DbMEmo:=True;
  FComboBox_DBCombobox:=True;
  FOther:=False;
  VarCompUsage:=0;
end;

destructor TCenterScreenColor.Destroy;
begin
//  FActive:=False;     //Nueva linea que se desactive aútomaticamente es la idea
  Screen.OnActiveControlChange := nil;
  inherited;
end;


procedure TCenterScreenColor.ScreenActiveControlChange(Sender: TObject);
//-------------------------------------------------------------------------------
// Aquie es donde se desarrolla todo el proseso del componente
//-------------------------------------------------------------------------------
var FontNAme,FontColor:string;
begin
  FPierdeFoco := FTieneFoco;
  FTieneFoco  := Screen.ActiveControl;
  VarCompAdm:=1;         //Nos permite decir si activamos o no el componente comprobando previamente la case y su permiso
  VarPrivPassComponent:=True;
  //Sólo si esta activo el componente
  if FActive=True then
  begin
     //Si el valor del tag del control es igual al de la propiedad FtagValoradmit
      if FPierdeFoco <> nil then   //PAra el Componente que pierde el Foco
      begin
           if VarCompAdm=1 then
           begin
             if FPierdeFoco.Tag=FTagValorAdmit then
             begin
                Self.AdmitComponent(FPierdeFoco);
                if VarPrivPassComponent=true then
                begin
                   //Si esta activo el color
                   if FColorActive=true then   Self.AplicarColor(ColorToString(FColorSinFoco), FPierdeFoco);
                end;
               VarCompUsage:=0; //Decimos que no hay un componente activado
             end;
           end;
      end;

      if FTieneFoco <> nil then   //Para el componente que adquiere el foco
      begin
           if VarCompAdm=1 then
           begin
             if FTieneFoco.Tag=FTagValorAdmit then
             begin
                 Self.AdmitComponent(FTieneFoco);
                 if VarPrivPassComponent=true then
                 begin
                     if FColorActive=true then self.AplicarColor(ColorToString(FColorconFoco), FTieneFoco);
                    FTag := self.Tag;
                    VarCompUsage:=1; //Decimos que hay un componente activado
                 end;
             end;
           end;
      end else   FTag := 0;
  end else
  begin
      if (VarCompUsage=1) then  //Comprobamos si hay algún componente activo con anterioridad
      begin
        if VarCompAdm=1 then
        begin
          if FPierdeFoco.Tag=FTagValorAdmit then
          begin
            Self.AdmitComponent(FPierdeFoco);
            if VarPrivPassComponent=True then
            begin
              if FColorActive=true then   Self.AplicarColor(ColorToString(FColorSinFoco), FPierdeFoco);
            end;
          end;
        end;
        VarCompUsage:=0;    //Decimos que no hay componentes activos
      end;
      FTag:=0;
  end;
  if Assigned(FOnFocusChange) then FOnFocusChange(Self);       //Ejcuta el evento
end;

Procedure TCenterScreenColor.AplicarColor(Color :String; Componente: TWinControl);
begin
  try
    if ExistProp(Componente,'Color') then SetPropAsString(Componente,'Color',Color);
// ORIGINAL -------------------------------------------------------------------------------
//    if (Componente is TCustomEdit)     then (Componente as TEdit).Color := Color;
//    if (Componente is TDateTimePicker) then (Componente as TDateTimePicker).Color:= Color;
//    if (Componente is TCustomMemo)     then (Componente as TMemo).Color:= Color;
//    if (Componente is TCustomComboBox) then (Componente as TComboBox).Color:= Color;
//    (Componente as TWinControl).Repaint;
//------------------------------------------------------------------------------------------
  except
  end;
end;
procedure TCenterScreenColor.SetColorConFoco(const Value: TColor);
begin
  if (FColorConFoco <> value) then FColorConFoco:= value;
end;
procedure TCenterScreenColor.SetColorSinFoco(const Value: TColor);
begin
  if (FColorSinFoco <> value) then FColorSinFoco:= value;
end;
procedure TCenterScreenColor.AdmitComponent(Component:TWinControl);
begin
     if (Component is TCustomForm) then
     if Component.ClassType=Tform then
     begin
         if FForm=true then VarPrivPassComponent:=True
                       else VarPrivPassComponent:=False;
     end else
     begin
        if ((Component is TCustomEdit) or (Component is TDateTimePicker))then
        begin
           if FEdit_DBEdit=true then VarPrivPassComponent:=True
           else VarPrivPassComponent:=False;
        end else
        begin
           if (Component is TCustomMemo) then
           begin
              if FMEmo_DbMEmo=true then VarPrivPassComponent:=True
                                   else VarPrivPassComponent:=False;
           end else
           begin
              if (Component is TCustomComboBox) then
              begin
                  if FComboBox_DBCombobox=true then VarPrivPassComponent:=True
                                               else VarPrivPassComponent:=False;
              end else
              begin
                 if FOther=true then VarPrivPassComponent:=True
                                else VarPrivPassComponent:=False;
              end;
           end;
        end;
     end;
end;
end.

y el enlace del Ftp archivo ScreenColorCenter.zip