Newsgroup: it.comp.lang.delphi
Titolo: Property

Ciao a tutti,
dovrei inserire in un mio componente una property che possa assumere solo
determinati
valori : Es. 'A','B','C' etc.etc.;
Nell' Object Inspector vorrei che questa proprietŕ sia impostabile tramite
una
combo con i suddetti valori, tipo come si fa per i valori : True/False;
Ragazzi vi prego č urgente!
Grazie in anticipo.
RLB
--------------------------------
Inviato via 
http://usenet.libero.it

 combo con i suddetti valori, tipo come si fa per i valori : True/False;
property DummyProperty: DummyVal read FDummyVal write FDummyVal;

 DummyVal = (A, B, C)
Ma poi A,B,C non sono Char, ma cosa sono?
Come uso poi questa property da un'applicazione?
Ciao e grazie per l'interessamento.


 Come uso poi questa property da un'applicazione?
type
  DummyVal = (A, B, C);
const
  DummyConst: array[Low(DummyVal)..High(DummyVal)] of Char = ('A', 'B', 
'C');
property DummyProperty: DummyVal read FDummyVal write FDummyVal;
function DummyFunction(Value: DummyVal): Char;
begin
  Result := DummyConst[Value];
end;

Scusami, ma forse non sono stato molto chiaro.
Il problema è che dall'applicazione dove uso il componente vorrei fare:
   if myComponent1.DummyProperty = 'A' then .......
Nel mio componente ho una funzione per leggere GETDummyProperty ed
una per scrivere SETDummyProperty.
procedure TmyComponent.SetDummyProperty(NewDummy : DummyVal);
begin
   myDummyValue := DummyConst[NewDummy];
end;
function TmyComponent.GetTypeField: DummyVal;
begin
   result := myDummyValue;
end;
Ciao RLB


Il metodo suggerito da P.Lemis e' il piu' veloce, solo che le "opzioni" sono
di tipo Enumerated, il che in generale e' una cosa positiva (i tipi
enumerated servono a questo).
Per convertire i tipi enumerated in altri tipi, puoi usare diverse tecniche,
quella suggerita nel secondo post di P.Lemis e' la piu' semplice: crea un
array di valori del tipo che ti interessa, il cui indice e' il tipo
enumerated usato nel controllo.
la sua procedura:
function DummyFunction(Value: DummyVal): Char;
begin
  Result := DummyConst[Value];
end;
Ritorna il tipo che ti interessa (char) dando l'indice enumerated.
Solo che e' un po' scomodo quando tenti di accedere direttamente alla
property, perche' tocca fare:
mychar := DummyFunction( mycomponent.dummyproperty );
Cmq ti consiglio di aggiustare il codice in modo da usare gli enumerated
dappertutto e trasformare solo alla fine nel tipo char.
Ricorda che gli enumerated sono tipi ordinali, con tutti i vantaggi che ne
conseguono: sono veloci, li puoi usare come indice di un array, di un ciclo
for, di un'istruzione case ecc ecc..
Spero di aver chiarito un po' le idee :)

Tutto chiarissimo,
grazie ad entrambi.
Ma ora, solo a titolo informativo : come si fà per le proprietà Boolean?
Mi spiego meglio.
Quasi tutti gli oggetti hanno la proprietà visible.
Nell'Object Inspector si vede la combo con i due valori : True, False;
Ma quando gli assegno un valore a tale proprietà uso un booleano:
   myComponent.Visible := true;
e non un enumeration.
Come si fà?
Ah, dimenticavo, anche in lettura : if myComponent.Visible = true then .....
Ciao RLB


Eheheh in pressoche' tutti i linguaggi il tipo boolean e' visto come un tipo
enumerated, concettualmente:
type boolean: (False, True);
Percio' e' naturale che venga trattato cosi'.. Ad ogni modo essendo un tipo
base ha un comportamento personalizzato..
Ad ogni modo, se proprio non puoi fare a meno di usare il tipo char
direttamente, puoi pensare di usare un ProperityEditor. E' un sistema con il
quale puoi tu stesso definire come un certo tipo deve essere editato
sull'OI.
E' un sistema potente ma abbastanza macchinoso. Inoltre (se non mi sbaglio,
in caso correggetemi) se definisci un propertyEditor per un certo tipo X,
allora tutte le proprieta' di tipo X avranno quell'editor.
Inoltre ci sono delle incompatibilita' proprio sui properity editor tra le
varie versioni di delphi.
Io ti sconsiglio di usarlo..
Ciao!

 enumerated:
Infatti Delphi accetta questo tipo di codice:
type TBoolArray=array[false..true] of string;  <-- boolean usato come indice
di un array
procedure Scema;
var b:boolean;
begin
b:=false;
case b of     //  <--- un booleano usato come indice di un case
 true:beep;
 false:beep;
end;
for b:=false to true do //  <--- un booleano usato come indice di un for
 beep;
end;

 Come si fà?
RegisterPropertyEditor(TypeInfo(DummyVal), TYourComponentClass, 
'DummyProperty', TYourComponentEditorClass);
omo, non vedo alcun problema nell' applicazaione né compatibilità
PL

 type TBoolArray=array[false..true] of string;  <-- boolean usato come indice
omho,
BooleanIdents: array [Boolean] of string = ('False', 'True');
PL


    Via De Gasperi, 14 - 42019
    Scandiano (Reggio Emilia)