Newsgroup: it.comp.programmare.win32
Titolo: creare controlli?

Ho creato una applicazione SDI con visual C++ 6.0 ora vorrei inserire in un
menu una voce che mi apra una finestra di dialogo che permetta all'utente di
inserire dei dati, la mia idea è quella di associare un numero di controlli
di tipo edit box alla finestra di dialogo , e questo numero deve essere
variabile.
In pratica vorrei dare la possibilità di scegliere quanti controlli di edit
box l'utente vuole che appaiano nella finestra di dialogo.
Come posso fare?
Spero che qualcuno mi dia una mano, grazie mille.

Come posso fare?
Ti converrebbe usarne uno solo, sempre lo stesso, e quando l'utente l'ha
riempito sposti quello che ha digitato in una ListBox, azzeri il contenuto
dell'edit box e cosi' via.
Saluti,
    Mardy

 Spero che qualcuno mi dia una mano, grazie mille.
Come ti e` gia` stato indicato nella risposta di Mardy, questa non
appare una soluzione di UI particolarmente amichevole per l'utente,
comunque, se e` proprio quel che vuoi fare, e` sicuramente
possibile creare dinamicamente, ed aggiungere al tuo dialogo,
tutti i controlli (ad esempio edit box) che desideri.
Come farlo dipende dall'ambiente in cui scegli di lavorare.  Ci dici
che usi Visual C++ 6, ma questo compilatore supporta almeno tre
diversi ambienti (API Win32, MFC, ATL) -- "almeno" perche` vi
sono poi in rete tanti altri ambienti usabili con lo stesso compilatore.
Supponiamo che tu intenda programmare usando Win32, visto che
si tratta alla fin fine del tema fondamentale di questo gruppo.
Con le API di Win32, le finestre (ad esempio le Edit Box che tu
desideri creare) si creano con la funzione API CreateWindow (o
con CreateWindowEx se vuoi anche impostare dei bit di stile
esteso).  Il primo argomento e` la window class che vuoi usare;
in questo caso, EDIT.  Il secondo argomento sara` il testo che
inizialmente sara` contenuto nell'edit-box.  Il terzo argomento,
la bitmask di "stile", dovra` contenere WS_CHILD, immagino
poi anche WS_VISIBLE, piu` altri bit che tu desideri usare a
seconda dello stile che intendi avere per l'edit-box.
Seguono poi quattro parametri per le coordinate geometriche
che vuoi usare per la nuova finestra; questi, immagino, li
dovrai calcolare a seconda di quante altre finestre siano in
gioco, per disporre le tue edit-box in riga o colonna o schiera
a seconda delle tue esigenze.
Poi, l'HWND del dialogo all'interno del quale vuoi creare il
controllo.
Segue un parametro che userai per indicare l'ID della
nuova window; assicurati di usare un ID distinto per ogni
controllo all'interno del dialogo, visto che su quello potrai
poi basarti per identificare quale edit-box sia in gioco fra
le tante che potrai creare.
Per concludere, la HINSTANCE del tuo modulo, e infine
un LPARAM che nel tuo caso puo` anche essere 0.
La creazione di finestre segue strade un poco diverse in
ambienti come MFC o ATL, ma in entrambi i casi si tratta
di strati abbastanza sottili da permettere di riconoscere
facilmente gli elementi visti sinora.
Alla mia nuova homepage 
http://aleax.supereva.it
 ho
messo in linea i primi 13 capitoletti di un tutorial in italiano
che ho scritto relativamente all'uso delle API Win32 da
linguaggio C (una parte di questo mio "tutorial" lo ha in linea
anche il sito 
www.programmazione.it
, ma mi pare che abbiano
fatto un poco di errori nell'HTML, e non so perche`
sia in linea una parte cosi` piccola del materiale, per
cui ho pensato bene di mettere in linea una versione
un poco + ripulita/rivista/completa sulla mia pagina).
La parte posta in linea sino ad ora non arriva ancora a
coprire argomenti come la creazione dinamica di finestre
entro un dialogo, ma penso che alcuni degli argomenti
trattati possano in ogni caso avere una certa utilita` per
coloro a cui interessa la programmazione Win32.
Alex

Alex
Saluti,
    Mardy

Come posso fare con le MFC?
grazie

Come posso fare con le MFC?
I don't speak MFC :-)
Saluti,
    Mardy

 
Gli oggetti di classe CEdit hanno un metodo Create che puoi
chiamare per creare la relativa finestra.
Puoi generare un qualsiasi numero di oggetti di classe CEdit,
come per qualsiasi altra normale classe, usando l'operatore
new del linguaggio C++.  Ad esempio:
	CEdit* pTanti = new CEdit[99];
Alex

 Come posso fare con le MFC?
Hmmm, ho l'impressione che i messagi che scrivo
dal lavoro non stiano uscendo...
Puoi usare oggetti di classe CEdit.  Puoi farne tanti
quanti vuoi con una new, poi chiamare su ciascuno
il metodo Create con i parametri opportuni per
piazzarlo alle coordinate che preferisci entro il
tuo dialogo (che avrai dovuto, naturalmente, fare
abbastanza grande per contenerli tutti -- comunque,
puoi, se occorre, ingrandirlo al volo).
Se il dialogo e` modale puoi fare tutto questo
in risposta al messaggio WM_INITDIALOG (cioe`
se usi il wizard del VC++ nella funzione OnInitDialog)
perche` a quel punto il dialogo, e tutti i suoi controlli
normali, sono gia` stati creati.
Alex

Grazie ancora per la Vs disponibilità,
    il problema che mi si presenta è il fatto di associare ad ogni controllo
una variabile che mi permetta di scambiare i dati, quando utilizzo
classwizard l'operazione avviene in modo automatico, se non erro tramite DDV
ma come posso associare direttamente, scrivendo io il codice, avete qualche
esempio.

 wrote in message news:80uc5h$4s5$1...@fe1.cs.interbusiness.it...

Certamente, l'esempio e` nel codice sorgente che il classwizard
ti genera!-)  Leggendolo, puoi vedere cosa fare.  Comunque, non
e` secondo me l'approccio migliore per controlli generati al volo;
ti conviene invece prendere il contenuto (testo) di ciascuno di
essi direttamente.
D'altra parte, se ti guardi un attimo le MFC, vedi che e` cio` che
fanno esse stesse:
void AFXAPI DDX_Text(CDataExchange* pDX, int nIDC, CString& value)
{
 HWND hWndCtrl = pDX->PrepareEditCtrl(nIDC);
    ...
  int nLen = ::GetWindowTextLength(hWndCtrl);
  ::GetWindowText(hWndCtrl, value.GetBufferSetLength(nLen), nLen+1);
Se tu hai un array di CEdit, e, essendo "in uscita" dal dialogo
dove li hai dinamicamente ospitati (ad esempio nella DoDataExchange)
vuoi estrarre da ciascuno la stringa che esso contiene, puoi anche,
se vuoi, fare un loop in cui ad ogni CEdit chiedi il suo ID con
GetDlgCtrlID (d'altronde e` un ID unico che dovrai avergli
assegnato tu "alla nascita"...), poi, sempre a ogni passo del
loop, chiamare la DDX_Text passando questo ID, e il corrispondente
elemento del tuo array di stringhe -- ma *perche`*?!  La DDX_Text
come vedi da questo brano dei suoi sorgenti dovra` poi estrarre
l'HWND dato l'ID, e ottenere da essa il testo.
Perche` tutte queste complicazioni, visto che hai gia` l'oggetto
CEdit e basta chiamare il suo metodo GetWindowText passandogli
direttamente la reference al relativo elemento del tuo array di
stringhe...?  La DDX_Text puo` al massimo far comodo se NON
si ha la CWnd (per quanto, anche allora, io penso che chiamare
direttamente GetDlgItemText sull'oggetto dialogo passandogli
l'ID e, ancora, il riferimento a CString, sarebbe + semplice...!).
Tipico dei framework e` renderti piu` comodo quello che prevedono
(qui, ottenere i dati di quei controlli di un dialogo che con il
ClassWizard hai "agganciato" a variabili della tua classe), ma
spesso a prezzo di renderti piu` difficile quello che non prevedono
(qui, il fatto che tu voglia generare i controlli al volo) -- il vantaggio
di un framework "sottile", come MFC, e` che non appena incontri
qualcosa in cui esso non ti aiuta, non ci metti niente ad aggirarlo
e scendere direttamente alle API (o ragionevoli compromessi, come
l'uso di quei rivestimenti sottili, come i metodi GetWindowText e
GetDlgItemText della classe CWnd, rispetto a quelli "spessi" come
lo schema DDX).  Ma questo vantaggio puoi coglierlo solo con un
minimo di competenza nelle API -- che non sono poi tanto difficili
da capire, benche` spesso scomode da usare (ma non importa
*usarle*, se non in quei rari casi in cui sono piu` comode del tuo
framework -- l'importante e` *conoscerle* e *capirle*...!).
Alex