Newsgroup: it.comp.programmare.win32
Titolo: Windows vs dialogs... dubbi atavici

Salve a tutti, vi pongo una domanda che forse è più sottile di quanto sembri
in apparenza...
Quale differenza "vera" (nel senso di differenza logica,strutturale e
funzionale) c'è tra la finestra principale di un programma che sia stata
creata da codice con le classiche CreateWindowClass e CreateWindow e le
dialog create tramite gli editor di risorse e piazzate nell'applicazione ?
Non intendo la differenza da parte del programmatore (ovviamente le dialog
sono costruibili "visivamente" e quindi più comode) ma la differenza proprio
"funzionale" ! Per esempio mi sono sempre chiesto: negli ambienti di
sviluppo RAD come il VB, Delphi o C++ Builder, quelle che loro chiamano
"form", e che si costruiscono mettendoci dentro i vari controlli, sono, a
livello di API, programmate come delle "dialog" oppure come finestre
"normali" ?? Nel caso esse siano dialog, ciò confermerebbe la reale
equivalenza logica dei due tipi di finestre, e l'inutilità di crearle da
codice,e si vedrebbe che in quegli ambienti di sviluppo le finestre create
con CreateWindow non sono proprio usate!
Un saluto. Ribadisco che mi piacerebbe tanto sapere a quale tipo di finestre
corrispondono le "form" di VB,Delphi e BCB ! Ciao!

Imho ha scritto:

Dubbi "atavici"? lol :D !
Effettivamente non credo che ci sia poi tutta questa gran differenza fra
dialogs e finestre normali; io penso che i programmatori del team di
microsoft windows hanno voluto creare la classe delle finestre di dialogo
(che si dovrebbe chiamare "#32770" se non erro) per comodità del
programmatore, che usando dei tools non RAD come VC++ può, attarverso un
editor visuale, creare dei template da schiaffare nell'exe come risorse, e
da far caricare al sistema operativo, che con un parsing dello script che
definisce il template, crea tutte le finestre che il programmatore ha
creato in modo visuale; per il resto non ci sono grandi differenze, perché
la WindowProc predefinita della class #32770 chiama la DialogProc definita
dall'utente (cioè dal programmatore) nella chiamata DialogBox o
CreateDialog, perciò la vera WindowProc delle dialog sarebbe proprio la
DialogProc del programmatore (scusa le ripetizioni).
Per quanto riguarda la questione degli strumenti RAD, come Delphi, essi
nella maggior parte dei casi non usano affatto le dialog, perché quando il
programmatore disegna le sue form, contemporaneamente il tool crea codice
automatico che disegna le finestre e i controlli nella form; parlando del
caso specifico di delphi, col quale ho lavorato parecchi anni (capito
Andrea ?!?) diciamo che il codice automatico non è del tutto visibile: il
form designer aggiunge le classi dei pulsanti, menu, ecc. all'interno
dell'oggetto form su cui si sta lavorando, ma la parte di codice non
visibile, cioè quella generata implicitamente, è quella che in runtime
setta le proprietà dei controlli come le ha settate l'utente, in modo tale
che la form in runtime abbia lo stesso aspetto che ha in designtime.
p.s.: che vuol dire "atavico"? :D
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 in apparenza...
Io vedo due domande che sintetizzerei cosí:
1. Che differenza c'è tra la finestra principale e una dialog?
2. Che differenza c'è tra una dialog creata con un RAD e una creata con un
editor di risorse?
Non so se ho azzeccato le domande :-)
La risposta alla prima non è breve e per questo ti rimando a msdn, cerca
DialogBox. In pratica la differenza sostanziale è la gestione dei messaggi
(e infatti usi una DialogProc) e il fatto che una dialog è 'figlia' di una
finestra principale.
Per la seconda ti posso rispondere solo per Delphi e BCB. In realtà se
andiamo a guardare il codice sorgente delle VCL, gli oggetti che usano per
costruire finestre, bottoni, dialog etc.., si vede che viene sempre chiamata
una CreateWindow e poi viene costruito dinamicamente l'oggetto. Cosa
fattibile anche da codice senza bisogno di un tool RAD, senza usare un file
.rc, ma non molto agevole.
Guardando poi bene si vede che Delphi e BCB non usano mai la CreateDialog ma
sempre la CreateWindow. In pratica creano sempre finestre di dialogo che non
sono tali per Windows, ma sono semplici finestre principali. Cosa comporta
questo per l'uso normale non lo so, nel mio caso ho avuto parecchi problemi
(per una applicazione particolare) tali da dover usare Delphi per la
finestra principale e un file rc per quelle di dialogo (e caricarle a manina
con CreateDialog).
Spero di aver risposto almeno in parte.
Ciao,
Enrico

 p.s.: che vuol dire "atavico"? :D
Beh ho usato questo aggettivo a mo' di "iperbole" (ora non chiedermi cosa
significa "iperbole"! :) ).
Letteralmente lo si dice di una qualche caratteristica che una persona
eredita dai propri antenati, un po' come "ancestrale" !
--
imho

 Enrico
--
imho

 finestre corrispondono le "form" di VB,Delphi e BCB ! Ciao!
Per quel che riguarda VB la questione e' ormai accademica, visto che e'
prodotto sepolto da MS (nella versione non .net).
Per cio' che riguarda Delphi (e il BCB) hai a disposizione tutto il
codice della VCL (e della CLX). In particolare, un TForm e' un
discendente (attraverso TCustomForm, TScrollingWinControl) di
TWinControl.
La creazione di un TWinControl prevede, fra le altre cose, la chiamata a
RegisterClass e CreateWindowEx.
Se permetti, un altro consiglio che considero valido. Ignora quel che
scrive 71103 riguardo a Delphi: quasi ogni frase che scrive al riguardo
dimostra la sua ignoranza dello strumento.
Saluti
Paolo Arosio

 p.s.: che vuol dire "atavico"? :D
Esistono negozi, detti librerie, utili per la riduzione dell'ignoranza.
Un sottoinsieme vende dizionari di italiano, un altro manuali di
informatica. Cio' che ti potrebbe essere utile e' una libreria
nell'intersezione.
*plonk*
Saluti
Paolo Arosio

 comportato il fatto che Delphi e BCB non usino le dialog...
L'applicazione (particolare) doveva essere poi usata unitamente ad un
software (tecnicamente si chiama screenreader) che permette di individuare
menu, finestre, window etc.. Le dialog create da Delphi (quindi come
semplici Window) lo mandavano in palla per il fatto che non è un
comportamento standard di Windows (anche altri controlli non standard lo
impallavano). In pratica dopo un bel pó di hackeraggio ho scoperto che
chiamava spesso e volentieri funzioni del tipo GetDlgXXX. Questo tre anni
fa. Puó essere che ora sia cambiato. Fatto sta che questo mi ha portato a
studiarmi per bene il codice sorgente di Delphi!
Ciao,
Enrico

 *plonk*
in che senso, scusa?


 con CreateDialog).
tutto esatto, ma vallo a spiegare a quello là, Paolo Arosio, o come
diamine si chiama...


 dimostra la sua ignoranza dello strumento.
bah, a questo post non rispondo neanche... se però poi qualcun altro nel
ng mi da' ragione mi faccio 2, anzi 22 risate


 nell'intersezione.
ma parla come mangi


nell'intersezione.
Lui non ha detto nulla di male nei tuoi confronti, ha solo chiesto il
significato dell'aggettivo "atavico". Ti faccio notare inoltre che questa
parte del tuo post è priva di utilità, quindi spam insensato ed inutile a
scopo di flame. Non hai risposto direttamente a tutte le affermazioni
tecniche di 71103 che spiegavano la sua posizione (humm... fammi
pensare... forse non sei abbastanza esperto? forse lo sei e ti sei accorto
di avere torto?)
Ti prego di smetterla di comportarti in questo modo, che danneggia
l'opinione che si ha di te. La presunta erratezza delle affermazioni di
71103 può essere dimostrata senza cercare il flame. Se non sai che pesci
pigliare stai zitto, ci fai più bella figura. Sono convintissimo
dell'esperienza di 71103 in quanto lo conosco personalmente. Non nego però
che potrebbe sbagliarsi in qualcosa.
Quello che stai attuando non è il modo giusto di dimostrarlo.
Chiedo scusa per questo Off Topic, ma spero capiate che è necessario per
riportare l'attenzione sulla questione principale e richiamare ad una
discussione 'pulita' su di essa.
Saluti
Antares88


 di Delphi!
Ti ringrazio, sei stato molto chiaro ed esauriente.
--
imho

 Paolo Arosio
Ciao, Diego.
--
imho

 La presunta erratezza
"Erratezza"? E` un sinonimo di atavico?
-- 
Lorenzo

Sono convintissimo dell'esperienza di 71103 in quanto lo conosco personalmente. 
...ma guarda un pò... e dire che io sono convinto che siate la stessa
persona... che pena...
*plonk*
-- 
Andrea Laforgia
Open Delphi Manual
http://groups.yahoo.com/group/delphi_open_manual/

 versione 6 di Delphi).
Questo non mi è per nulla chiaro. Se segui il percorso nel sorgente delle
VCL trovi tutto quello che fa Delphi e se non ti va lo cambi. Funzioni
misteriose non ne ho mai viste. Semmai ce ne sono molte, quelle a livello
piú basso, scritte in ASM e poco o nulla commentate quindi difficili da
capire.
Comunque Delphi non è un generatore di codice: semplicemente fa il link con
alcune librerie di cui ti da il codice (come fanno molti altri compilatori).
Se tu chiami una funzione delle API di Windows stai facendo lo stesso,
chiami una funzione in una libreria. Se hai il codice puoi capire cosa fa,
altrimenti ti accontenti (ti fidi che funzioni).
Per le proprietà che tu imposti in fase di disegno il meccanismo è dal punto
di vista teorico semplice (non dico dal punto di vista realizzativo). Tutte
le impostazioni vanno in un file .dfm che viene compilato e linkato assieme
al suo codice .pas. Quando viene chiamato un costruttore di un oggetto,
questo non fa altro che andare  a prendersi i valori delle proprietà in un
segmento dati preciso (gli offset dove trovare questi valori saranno salvati
in un altro punto).
Le risorse di Windows funzionano allo stesso modo dal punto di vista
concettuale.
Ciao

 Se non sai che pesci pigliare stai zitto, ci fai più bella figura.
Da qual pulpito vien la predica (dizionario, lettera p -- cerca pulpito)
Infine ti dico che da anni frequento i gruppi e la ho conosciuto Paolo
Arosio (non personalmente) ma è sufficiente per affermare che:
1 - Ha una ottima preparazione, soprattutto per quanto concerne Delphi
2 - Hai detto una marea di cazzate su Delphi; quindi ha fatto bene a
zittirti e ribadisco il tuo concetto ... se non sai che pesci pigliare stai
zitto, ci fai più bella figura.
*plonk*
--
- Carlo -

Sono il cugino di 71103. Qualche giorno fa mi ha detto che aveva trovato
un forum ben strutturato sulla programmazione e successivamente che aveva
avuto qualche diverbio con gli utenti di tale forum.Dopo un po,
incuriosito, sono venuto a vedere e ho notato parecchi insulti gratuiti e
quindi ho deciso di mettermi in mezzo (giacché anche lui è stato in certi
casi incapace di gestire la situazione mettendosi dalla parte del giusto).
 
non frequento gruppi di google, yahoo o robe simili. Ho 15 anni e se
volete informazioni su di me potete trovarmi su questo forum (vi linko un
messaggio)
http://forums.multiplayer.it/showthread.php?s=&threadid=156894
e su questo
http://www.destructioncarriers.com/forum/board.php?boardid=1&sid
e ho dato solo 2 esempi.
Nei vostri messaggi ho riscontrato una grossa ricerca dell'errore per fare
critiche (succede di incartarsi parlando e non tutti sono dei buoni
oratori) e, se i moderatori mi passano il termine, una grande
bastardaggine. 
E' molto comodo mettersi in 10 a confermare le proprie posizoni (lui è
bravo, lui è competente, etc) ma non ho ancora visto dimostrazioni
pratiche dell'incompetenza di 71103. 
Conoscendolo da vicino posso dirvi che a volte ha delle convinzioni
stupide e mi trovo a discuterci per fargli capire che ha torto. Ma quando
lo faccio non lo insulto, non gli dico che io sono competente e lui no, ma
abbatto la sua tesi argomento per argomento finché non gli resta alcun
dubbio. 
Voi state facendo l'esatto contrario e non capisco perché visto che vi
circondate da un aura di cultura e competenza. Sapete discutere come
persone civili ? 
se lo sapete fare fatelo, e dimostrategli con argomenti seri che si
sbaglia, non dicendo "ha sbagliato a coniugare un verbo e quindi è
coglione e ignorante e non sa usare Delphi". Quanti anni avete ? 3 ? penso
di no. dimostratelo.
Quello che ho visto io dalla mia ignoranza in materia (il massimo che ho
programmato è stato un editor di testo in stile wordpad rotfl) è che nel
corso degli anni 71103 ha realizzato programmi di una complessità notevole
ma ad un certo punto si è bloccato per una serie di problemi di delpi ed è
passato al c++ x vari pacchetti fino ad arrivare a quello microsoft. 
Dimostrategli che si sbaglia, espertoni. Fatelo. Se continuerete ad
insultare lui o me in maniera gratuita come avete fatto finora sarà mia
premura segnalare i vostri messaggi all'amministratore di questo forum per
un richiamo all'ordine(anche se in altri posti bannano per cose simili). 
Scusate se sono stato un po prolisso


 - Carlo -
1 - non lo metto in dubbio, ma mi spieghi perché insulta anziché
dimostrare la sua preparazione?
2 - è possibile che 71103 lo abbia fatto ma prenderlo per il culo non
serve a dimostrarlo
3 - so che pesci prendere e vi sto solo richiamando ad una discussione
normale. mio cugino non è un ameba rincoglionito, se gli spiegate dove e
perché ha torto lui lo capisce. Mi linkate un messaggio dove l'avete fatto
? nei 2-3 che ho visto vi limitavate a dargli dell'incompetente senza
avvalorare la vostra tesi. 
ciao


 > La presunta erratezza

posto da newsland xche è la pagina linkatami da 71103 
x quanto riguarda l'uso sbagliato della parola erratezza direi che nessuno
è perfetto.
x quanto riguarda le parole accentate ho 2 domande 
1) ma te dormi la notte o passi il tempo ad analizzare i post?
2) come si fanno gli accenti separati ? io qua ho solo l'apostrofo ' non
vedo accenti... e cmq la maggior parte delle persone che postano usano le
lettere accentate


bah! tu stai zitto che sennň 'sto giro mi bannano proprio...


:D
per l'ultima volta, 71103.


stronzi figli di puttana 
finito di rosicare, incivile incompetente?
oltre a cambiare nick cambia anche cervello.
sbirish.

 Ciao
D'accordo, va benissimo; e perché qualcun altro non me lo poteva dire
civilmente, in questo modo? Io credevo che delphi usasse i DFM per
generare una piccola parte di codice invisibile che chiamava i setters
dopo il costruttore, e adesso, CIVILMENTE, ti spiego il perché: anni fa,
lavoraravo con delphi 2, ho sviluppato un componente derivato da
TPaintBox, e nel debug mi succedeva proprio quello che ho detto circa i
setters; consultando la finestra del callstack quelle chiamate provenivano
"dal nulla", cioè erano la prima ed unica entrata nel call stack, ma dato
che si trattava di delphi 2, c'erano sicuramente delle differenze; ieri
poi ho provato a debuggare il componente TButton e con il callstack ho
visto quelle routines assembly di cui tu parlavi, e così ho visto di
essermi semplicemente sbagliato, come tutti gli umani fanno...
Adesso mi è tutto chiaro, senza nessuna volgarità, e mi verrebbe la
tentazione di chiedere a Paolo Arosio come mai secondo lui tutto il resto
di quello che ho detto su delphi sono "fantasie", ma ormai non mi
interessa più, piuttosto che discutere con lui preferisco l'ignoranza
(sempre che io abbia torto, perché finché non ci sono chiarimenti non si
può dire).
Ciao.


 >:D

si ma allora sei mallah (per non dire altro, ce ne so già troppe di
parolacce in questo topic)... cioé io ho sfasciato le palle in giro xche
si tornasse all'ordine e ad una discussione civile e poi sei il primo ke
skazza.... vabbé...
p.s il mio compito qui è finito saluti a tutti (inclusi i signori citati
sopra).
cya


finito di rosicare, incivile incompetente?
Lascia perdere sbirish, plonka e vivi felice ;-)


 essermi semplicemente sbagliato, come tutti gli umani fanno...
La spiegazione è semplice. Da una certa versione (sicuramente non fino alla
4) puoi impostare un parametro per utilizzare le DCU di debug (Use Debug
DCUs). Con questa opzione vai a debuggare (brutto termine, ma si capisce)
fin dentro alle VCL senza problemi. Almeno nella 4 non sono mai riuscito a
fare questo se non cambiando un path di compilazione.
Nel resto della polemica non entro e non mi interessa.
Se qualcuno invece spiegasse come fa VB mi interesserebbe, per cultura
personale. Grazie.
Ciao,
Enrico

 sbirish.
e vattene affanculo co 'sto cazzo de nome


 con un editor di risorse?
se il RAD è furbo, nessuna. Altrimenti, che dio t'aiuti
-- 
  < 
http://www.reactos.com/
 >  Open source clone of Windows NT. Current
      Don't stand, REACT!      version 0.1.2. C, C++ and ASM developers
                               and beta testers are welcome!

 e' visibile, ispezionabile, modificabile fino alle chiamate alle API.
sě, sogna. Com'č il mondo visto da lassů, Paolo?


 CreateWindow non sono proprio usate!
se è una dialog che vuoi, non usare CreateWindow. Mi sembra ovvio


 abbia comportato il fatto che Delphi e BCB non usino le dialog...
problemi di ogni tipo a non finire. Problemi di focus, di gerarchia, di 
interazione con dialog vere. La VCL, sotto questo punto di vista, è una 
catastrofe


 finestre "da codice" e non le dialog con annesse risorse.
MFC usa le dialog. Visual Basic usa le dialog. Mi pare anche wxWindows. 
La VCL, in vero stile Borland, no


 e' prodotto sepolto da MS (nella versione non .net).
modo molto diplomatico per dire "non ne capisco un cazzo"


 CTRL-ALT-C. Ora dimmi cos'è quello, genio. Anzi, gienio
il codice di break non viene inserito dal linker o dal loader ??? non e'
prettamente di linguaggio no ???
ciao

 catastrofe
Potrei saperne un po' di più?
-- 
Marco Barisione
http://spazioinwind.libero.it/marcobari/

 La VCL, in vero stile Borland, no
E cosa usa allora e in che modo? Non riesco a capire cosa vuoi dire.


 vedo accenti...
Questo perche` sei un mangiatore di quiche [*], quindi usi la tastiera
italiana. Gli uomini veri usano la tastiera US, che ha la tilda,
l'accento, le parentesi quadre in prima battuta e le graffe in seconda.
[*] Giusto per non riscaldare ulteriormente gli animi, preciso che
questa non e` un'offesa, e` un joke che gira su Internet. Cerca "quiche
eater" o qualcosa del genere su Google e capirai. :)
-- 
Lorenzo

si nota, e può dare problemi anche seri
Sono curioso di sentire da questo genio (anzi genia) della
programmazione, che problemi *seri* la cosa possa dare...


La VCL, sotto questo punto di vista, è una catastrofe
E` facile dirlo senza dimostrarlo.


 Facci degli esempi.
Te ne faccio uno io: metti una combo box in una finestra con un bottone 'Ok'
di default, e poi tira giu' la lista della combo e seleziona un elemento
premendo 'Invio', ti uscira' l'infame "cannot focus disabled or invisible
window". Lo so che basta controllare tutte le combo da codice prima di
chiudere la finestra, ma non mi sembra il modo piu' elegante...

window". 
A me veramente seleziona l'elemento, poi premendo OK esce regolarmente
dal form.  Se poi mi spieghi che cosa c'entra questo con quanto stiamo
dicendo mi fai un grande favore.


 dicendo mi fai un grande favore.
A me ha sempre dato questo problema: se in una finestra modale c'e' un tasto
Ok, con la proprieta' Default settata a True, associato ad un ModalResult,
cioe' un tasto che reagisce alla pressione del tasto Invio e chiude la
finestra (come il tasto 'Ok' di una dialog box 'standard'), questo entra in
"conflitto" con le combo box presenti nella finestra. Premendo Invio,
l'elemento non viene selezionato, la finestra si chiude e spunta l'errore.
C'entra con i problemi di focus di cui si parlava, o almeno penso che Marco
si riferisse a questi comportamenti. Ce ne sono sicuramente altri... la VCL
non e' la perfezione...

l'elemento non viene selezionato, la finestra si chiude e spunta l'errore.
Ed io ti ripeto che a me non lo fa.  Crea una nuova applicazione,
aggiungici un form, rendilo "bsDialog", aggiungici una ComboBox e
riempila con "pluto" "pippo" e "paperino", piazza un bottone con
ModalResult = mrOK e Default = True, sul primo form mettici un bottone
che apre la seconda finestra: Form2.ShowModal.
Io ottengo che premendo "invio", durante la selezione degli elementi
nella seconda form, l'elemento viene selezionato.  Premendo nuovamente
"invio", il bottone agisce, facendo chiudere il form con risultato
mrOK.  
Tutto regolare.


 mrOK.
Boh, provero'...
Avranno corretto il problema, probabilmente, e io non me ne sono accorto
(sono ancora fermo a Delphi 6, e ho verificato che succede anche con la
versione Trial del 7).
-- 
Gabriele 'bigmouth', Sestri Levante (GE)
Su Honda Foresight 'fore-divanetto' 250, ---> х\т
ex Kymco Heroism 150
'L'utente piu' medio di IHMS' da sondaggio del 2002

 Com'č il mondo visto da lassů, Paolo?
Non c'e' male, grazie.
Saluti
Paolo Arosio

 Potrei saperne un po' di più?
certamente


 E cosa usa allora e in che modo? Non riesco a capire cosa vuoi dire. 
praticamente, han duplicato la funzionalità delle dialog di Windows: le 
dialog vengono salvate come risorse, che a runtime vengono interpretate 
da un apposito motore in chiamate a CreateWindowEx. Ma è tutto diverso: 
anzichè usare, come Visual Basic, le dialog ed un meccanismo aggiuntivo 
per la permanenza di proprietà non esprimibili tramite dialog (Property 
Bag, in Visual Basic), hanno fatto a modo loro. Inoltre, e suppongo per 
carenze del Delphi, hanno scelto di basare l'associazione window class-
classe su RTTI (cioè informazioni generate dal compilatore sulle classi 
definite nel codice), il che è ridondante rispetto al meccanismo stesso 
delle window class


 Boh, provero'...
Effettivamente hai ragione, ho fatto confusione con un altro problema, e mi
scuso.
Quello che ho descritto si verifica realmente, ma solo con una
DBLookupComboBox. Non so perche', ero convinto che lo facessero anche le
combo "standard".
-- 
Gabriele 'bigmouth', Sestri Levante (GE)
Su Honda Foresight 'fore-divanetto' 250, ---> ő\ň


Diventa inoltre difficile scrivere programmi che non siano applicazioni 
Per piacere.  Per programmi che non sono applicazioni, c'è un oggetto
Application apposta, il problema non si pone.
Ora, io ho dalla mia parte l'esperienza di scrittura di programmi
anche piuttosto complessi in Delphi, tu che tipo di software ci hai
realizzato ?


classe su RTTI 
????


DBLookupComboBox. 
Sulla mia macchina non accade, spiega esattamente cosa fai.


 Fammi un esempio, non ho presente, al momento.
Questo l'ho notato anch'io con un paio di programmi, non so però se sia
colpa delle VCL o dei programmatori. Cliccando su finestre completamente
separate ne compaiono anche altre.


colpa delle VCL o dei programmatori. 
Fammi un esempio cosě vediamo, anch'io tempo fa ho visto una scia
luminosa che sembrava un UFO.


 Sulla mia macchina non accade, spiega esattamente cosa fai.
Con Delphi 6 Enterprise: ho una finestra con un bottone OK, un bottone
Annulla, e un DBLookupComboBox (ora non ce l'ho sotto mano, comunque mi pare
fosse la selezione del codice fiscale partendo dal comune di nascita, o
qualcosa del genere).
Associato alla pressione del tasto Ok, che e' il bottone di Default, c'e' un
po' di codice (per verificare che la selezione sia compatibile con alcuni
parametri), l'ultima riga e':
ModalResult := mrOk;
Non ho messo il ModalResult direttamente tra le proprieta' del pulsante,
perche' non ero sicuro che funzionasse (ma adesso provero' anche cosi'...).
Se espando la combo box, e poi seleziono con i tasti un elemento, premendo
Invio per confermarlo, mi esce il messaggio di errore che ti ho detto.
Non so se questo si verifichi sotto particolari condizioni... per ora ho
semplicemente tolto l'attributo 'Default' al bottone, e funziona tutto (e al
cliente va bene cosi').

Invio per confermarlo, mi esce il messaggio di errore che ti ho detto.
Stessa configurazione (io perň ho l'update pack 2 di D6 Enterprise);
non mi succede nulla, nel senso che tutto funziona regolarmente.  


 luminosa che sembrava un UFO.
Appunto magari lo era magari no, io ho detto che non so se è colpa del
programmatore o no. Infatti allora non avevo minimamente dato la colpa alle
VCL (e neanche adesso visto che non posso saperlo).
Un programma con il quale mi ricordo perfettamente il problema era un gioco
del tetris, mostrando una finestra con informazioni sul origramma si aveva
questo effetto del focus. Cosa che direi normalissima se a finestra figlio
fosse modale, ma così non è.
Ho anche qualche problema di focus con il newsreader che sto usando adesso,
quando comprimo il database alla fine viene mostrata una finestra che mi
dice che l'operazione è stata portatta a termine.
Se quando succede la finestra è minimizzata e la ripristino la finestra con
il messaggio di fine non è visibile anche se è modale rispetto a quelle che
sono visualizzate.
Anche qui non so se la colpa è del programmatore o delle VCL.


Anche qui non so se la colpa è del programmatore o delle VCL.
Purtroppo neanch'io, non so come è scritto quel programma...


 Questo sì che è un guaio!....
che si risolve con sporchi trucchi che un framework onesto non dovrebbe 
costringerti ad usare - nella fattispecie, l'API SetParent() e lo stile 
di finestra WS_EX_APPWINDOW


 [...]
Andrea, ma che t'č successo? com'č che sei cosě ragionevole?


 ????
il motore delle form legge "TSaltinbocca" nella form che sta creando, e 
cerca nelle RTTI generate dal compilatore la classe "TSaltinbocca". Nel 
frattempo, registra una classe di finestra "TSaltinbocca" la cui window 
procedure predefinita si immette nella corrispondente classe. Tutto ciň 
non č necessario, con le dialog: basta registrare le classi di finestra 
in anticipo e creare istanze delle classi corrispondenti in risposta al 
messaggio WM_CREATE. L'uso delle dialog standard si incastra anche bene 
con quello delle risorse, altro punto debole della VCL


costringerti ad usare
Un framework onesto come quello di Delphi non ti costringe a fare un
bel nulla.  Sentirsi limitati non vuol dire esserlo davvero, specie se
non si conosce Delphi.


Andrea, ma che t'č successo? com'č che sei cosě ragionevole?
Tu spara un'altra puttanata e te lo do io il "ragionevole" ;-)


procedure predefinita si immette nella corrispondente classe. 
Ma che stai dicendo ??!! che cosa diavolo c'entrano le informazioni
RTTI ? Ti stai riferendo allo streaming dentro l'ambiente di sviluppo
o al run-time vero e proprio ??


 o al run-time vero e proprio ??
a runtime. L'eseguibile contiene tanto di nomi di classe, come potrebbe 
non contenerli? le risorse delle form contengono i nomi delle classi, e 
non, chesso', indici in una tabella di classi o cose del genere


 delle form non modali ? 
form non modali? mai parlato di niente del genere (se vuoi lo faccio)
