Acceder a propiedades componentes de un form

[[José Luis Garcí]]

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

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.

que te parece el tag de cada componente??

[Neftali [Germán.Estévez]]

Empezado por José Luis Garcí

...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...

[[José Luis Garcí]]

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

[Neftali [Germán.Estévez]]

Yo también José Luis, yo también,...
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.

[[José Luis Garcí]]

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.

[Neftali [Germán.Estévez]]

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

[[José Luis Garcí]]

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

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.