Newsgroup: it.comp.lang.delphi
Titolo: Problemi con creazione componente ...

Sto cercando di scrivere il mio primo componente derivato. Purtroppo non 
  riesco proprio a proseguire. vi mando il codice se qualcuno mi dice 
dove sbaglio. In sintesi il componente compila ma quando cerco di 
leggere o scrivere sulla proprietà stato si blocca completamente. 
Qualche idea.
Ciao a tutti. Gazza.
interface
uses
   SysUtils, Classes, QControls, QStdCtrls;
type
   Prestazione = class(TButton)
   private
     function getStato: string;
     procedure setStato(const Value: string);
     { Private declarations }
   protected
     { Protected declarations }
   public
     Constructor Create(AOwner : TComponent); override;
     property stato:string read getStato write setStato;
     { Public declarations }
   published
     { Published declarations }
   end;
procedure Register;
implementation
procedure Register;
begin
   RegisterComponents('Standard', [Prestazione]);
end;
{ Prestazione }
constructor Prestazione.Create(AOwner: TComponent);
begin
   inherited;
caption:='test';
width:=80;
end;
function Prestazione.getStato: string;
begin
result:=stato;
end;
procedure Prestazione.setStato(const Value: string);
begin
stato:=Value;
end;
end.

Ciao,
devi definire una variabile "vStato" nella definizione private e
modificare le funzioni così:
private
     vstato: string;
     function getStato: string;
     procedure setStato(const Value: string);
     { Private declarations }
function Prestazione.getStato: string;
begin
    result:=   vstato;
end;
procedure Prestazione.setStato(const Value: string);
begin
    vstato := Value;
end;

 
Ma a questo punto non accedo più ad una proprietà ma ad una normale 
variabile, o sbaglio?
Ciao e grazie.
Ivan

Sì, ma questo è il metodo. Devi appoggiarti (al minimo)ad  una
variabile per gestire una proprietà.
Di dico di più; volendo potresti evitare di creare le procedure Get...
e Set... per una proprietà semplice come quella.
Potresti fare così:
type
   Prestazione = class(TButton)
   private
     { Private declarations }
        vstato: string;
   protected
     { Protected declarations }
   public
     Constructor Create(AOwner : TComponent); override;
     property stato:string read vstato write vstato;
     { Public declarations }
   published
     { Published declarations }
In questo modo gestisci una proprietà che legge e scrive in una
variabile.
Le procedure collegate alla proprietà ti servono quando devi eseguire
qualche operazione.
bye
Lorenzo

Solid Snake IT ha scritto:

Ovviamente l'esempio che ho portato era semplificato al massimo per 
capire dov'era il mio errore. Io devo svolgere modificare altre 
proprietà dell'oggetto al variare della proprietà impostata e per questo 
  ho pensato alla proprietà. In particolare devo modificare il colore ed 
il testo del pulsante al variare di due prorietà.
Ciao
Ivan

la proprietà stato e' dichiarata cosi':
property stato:string read getStato write setStato;
quindi quando la leggi devi chiamare la funzione "getstato" che e' questa.
function Prestazione.getStato: string;
begin
result:=stato;
end;
all'interno della funzione tu leggi il valore della proprieta stato, 
leggendo questo valore lui devi richiamare ancora la funzione get stato 
al cui interno contiene una lettura della proprietà, diventa ricorsivo.
ciao
-- 
-------------------------------
per scrivere in privato
togliere "1975nosp"
to reply remove "1975nosp"

 
Ok, ora è chiaro. Quindi è per forza necessario usare una variabile per 
utilizzare le proprietà come voglio . Grazie.
Ciao.
Ivan


<mode Marco Breveglieri ON>
Facciamo un piccolo tutorial, descrivendo i passaggi per creare nella
maniera più semplice un componente derivato da un'altro?
(Premessa: io mi riferirò a D4, non so tu che versione
usi, ma sicuramente qualcuna superiore visto le unit che dichiari.
Inoltre, do per scontato tutta la progettazione che sta a monte dello
sviluppo di un nuovo componente. Un'ultima
cosa: il nostro testo di riferimento sarà l'help di Delphi).
1 -  File - New - New Component: qui compili tutti i campi come ti
aggrada e Delphi genera lo scheletro del tuo componente (vedi anche
"Using the Component wizard" nell'help).
type
  TPrestazione = class(TButton)
  private
    { Private declarations }
  protected
    { Protected declarations }
  public
    { Public declarations }
  published
    { Published declarations }
  end
2 - Lo "scheletro" dell'oggetto è composto da quattro sezioni, ognuna
con una "visibilità" diversa dalle altre: i metodi, gli eventi e le 
variabili
dichiarate in queste sezioni sono rispettivamente:
_PRIVATE_: accessibili solo all'interno della unit nella quale si sta
scrivendo;
_PROTECTED_: accessibili anche ai componenti derivati da questo posti
in altre unit;
_PUBLIC_: accessibili ovunque;
La sezione _PUBLISHED_ ti permette di dichiarare proprietà o eventi
visibili a Design Time e selezionabili nel Object Inspector.
3 - Nella sezione _Private_ aggiungo una variabile in questa maniera:
  private
    { Private declarations }
    FStato: String;
E' la stessa cosa consigliata nell'altro post. Perchè? Perchè le
_Properties_ non sono semplici campi dell'oggetto, ma controllano
l'accesso agli  attributi di un oggetto attraverso specifiche azioni 
di
lettura o di modifica degli attributi stessi.
Sono quindi qualcosa di più di un semplice campo (in casi estremi,
possono anche non esistere in memoria: vedi l'help per un esempio)
e devo avere degli  "attribuiti" sui quali agire. Questo semplifica 
l'uso
dell'oggetto: chi lo userà non dovrà preoccuparsi di come
sono implementati le azioni di lettura e modifica della proprietà,
limitandosi soltanto ad utilizzarla nel modo migliore.
NOTA: per convenzione, è bene usare una _F_ davanti al nome della
variabile privata.
4 - Nella sezione _Private_ dichiaro anche i metodi di accesso e di
lettura a questo attributo (in questo caso, per una semplice stringa,
basta solo quello di modifica):
  private
    { Private declarations }
    FStato: String;
    procedure FSetStato(strValore: String);
5 - Definiamo ora la proprietà:
  published
    { Published declarations }
    property Stato: string read FStato write FSetStato;
6 - Con queste dichiarazioni esprimiamo quanto segue:
<lo stato interno dell'oggetto TPrestazione è dato dalla variabile
privata FStato. Tale variabile è gestibile attraverso l'interfaccia
offerta dalla proprietà Stato>
7 - Dobbiamo ora implementare i metodi di scrittura/modifica della
variabile;
ci posizioniamo con il cursore sulla dichiarazione della procedura
FSetStato e premiamo Shift+CTRL+C. Noi completeremo quello
che Delphi ci propone in questa maniera:
procedure TPrestazione.FSetStato(strValore: String);
begin
 FStato := strValore;
end;
8 - Un oggetto deve essere sempre creato e distrutto, quindi
  public
    { Public declarations }
    constructor Create(AOwner : TComponent); override;
    destructor Destroy; override;
constructor TPrestazione.Create(AOwner: TComponent);
begin
 inherited;
 FStato := 'Nessuno Stato'; // inizializzo la varibaile interna
 Caption := 'test';
 Width := 80;
end;
destructor TPrestazione.Destroy;
begin
 inherited;
end;
9 - Inserisco il tutto in un package e compilo. Nella Palette
"Sample" trovo il mio nuovo bottone. Lo trascino su un
progetto ed ecco che tutto funziona (nota nell'OI la nuova
proprietà Stato, inizializzata come volevamo).
<mode Marco Breveglieri OFF>
Spero di non aver dimenticato nulla.
Ciao
-- 
ACSH
[D4]
Chi fa da se', fatica il doppio 

Ivan
	Ciao
	MassimoB
 
---------------------------------
http://www.massimobeschi.it/
---------------------------------
Se tu pagare come dici tu ...
Io lavorare come dico io ...
Se tu pagare come dico io ...
Io lavorare come dici tu ...
---------------------------------