Newsgroup: it.comp.programmare.win32
Titolo: Controllare se un programma e' in esecuzione...

Ciao a tutti!
Sto facendo un programma in una finestra dialogo e voglio controllare che ne
venga eseguita una sola istanza alla volta nel sistema... se fosse una
normale finestra saprei come fare ma con una finestra dialogo no.
GetClassName mi ritorna #32770 per tutte le finestre dialogo e quindi non
posso usare questa funzione...
Qualcuno sa dirmi come fare...?

 wrote in
news:sBzk9.144607$
ub2.3...@news1.tin.it
: 

Crea un mutex con un nome univoco e prova ad acquisirne il controllo 
(questo metodo è sempre e comunque più affidabile rispetto alla 
FindWindow).
-- 
Valter Minute
vmi...@inwind.it
 (the reply address of this message is invalid)


////////////////////////////////////////////////////////////////////////////
////////////////
BOOL CBubbaApp::InitInstance()
{
    CreateMutex(NULL, TRUE, "Bubba pelosa");
    if(GetLastError() == ERROR_ALREADY_EXISTS)
    {
         return FALSE;
    }
    //    bla bla
}
////////////////////////////////////////////////////////////////////////////
////////////////
Per portare la finestra in primo piano ci sono molti metodi, ma non lo avevi
richiesto...
ma ciao!

 FindWindow).
Grazie, sara' fatto :)

 richiesto...
Immagino sia sufficente la procedura che uso per le finestre standard:
SetForegroundWindow( hWndOther );
if( IsIconic( hWndOther ) )
    ShowWindow( hWndOther, SW_RESTORE );

     ShowWindow( hWndOther, SW_RESTORE );
Ehm... dimenticavo che non ho l'handle della finestra dialogo :)
Sono ritornato al problema originario... ottenere l'hande della finestra
dialogo in esecuzione :)

 dialogo in esecuzione :)
Purtroppo usare semplicemente SetForegroundWindow non porta al risultato che
ti aspetti sotto Windows 2000 e sotto l'XP...la fa semplicemente
lampeggiare... : o
1) "SetForegroundWindow"
 ma allora? ecco il barbatrucco :
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////
AttachThreadInput(GetWindowThreadProcessId(::GetForegroundWindow(),NULL),
GetCurrentThreadId(),TRUE);
SetForegroundWindow();    //    Bella li !
SetFocus();
AttachThreadInput(GetWindowThreadProcessId(::GetForegroundWindow(),NULL),Get
CurrentThreadId(),FALSE);
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////
2) "handle della finestra"
come ti dicevo ci sono molti modi...ne vuoi uno semplice semplice?
ecco:
BOOL CBubbaApp::InitInstance()
{
    CreateMutex(NULL, TRUE, "Bubba pelosa");
    if(GetLastError() == ERROR_ALREADY_EXISTS)
    {
          CWnd *pPrevBubba  = CWnd::FromHandle((HWND) GetProfileInt(
.... ));
           // bla bla col barbatrucco
           return FALSE;
    }
    //    bla bla
    WriteProfileInt(..., ..., (int) m_pMainWnd->m_hWnd);
}
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////
se puoi vuoi fare le cose pulite nella ExitInstance() azzera l'handle della
finestra, ma non ti è indispensabile...
ma riciao

 FindWindow).
Oppure GlobalAddAtom e GlobalFindAtom.
Kiuhnm

 finestra, ma non ti è indispensabile...
Beh si... semplice e' semplice pero' nn lo definirei elegante :)
Andare a scrivere nel Win.ini non mi ispira per un prog come il mio... forse
potrei fare la stessa cosa scrivendo nel registro di sistema, pero' neppure
questa soluazione mi ispira molto :)
In poche parole copi il wrapper dell'handle... mmm
Non so, pero' forse tramite la strada il processo generatore funzia
meglio... ci deve essere un modo
vediam se riesco a fare qualcosa

 ma riciao
Oppure potrei scrivere nella variabile Mutex l'handle della finestra aperta
appena invoco la prima istanza del programma... ora ci provo, speriam bene

 appena invoco la prima istanza del programma... ora ci provo, speriam bene
Ops dimenticavo che permette di condividere un paramentro stringa
niente da fare per sta strada

 Andare a scrivere nel Win.ini non mi ispira per un prog come il mio...
Io ti ho dato l'idea, tu mettila in pratica con la fantasia...
ma riririciao

 Io ti ho dato l'idea, tu mettila in pratica con la fantasia...
Speravo tirassi fuori qualche strana idea :)
non si sa mai

Scusami davvero ma io ci rinuncio, ci provi qualcun altro...
Ne avessi azzeccata una...dalla "bella variabile globale con l'handle" al
VisualCiccio che misticamente "si procura l'handle".
Sono rimasto senza parole...

 ha scritto nel messaggio
news:0aCk9.13618$e31.2...@twister2.libero.it...

Scherzavo :)
Cmq grazie lo stesso per l'aiuto, in qualche modo faro'

> Scherzavo :)
sarŕ...

 sarŕ...
Scherzavo nel senso che e' ottiene un valore dell'handle in modo trasparente
per il programmatore.
Cmq a parte questo. Tutto risolto:
============
HWND hWnd = FindWindow( NULL, "Net Server" );
SetForegroundWindow( hWnd );
if( IsIconic( hWnd ) )
    ShowWindow( hWnd, SW_RESTORE );
============
Funzia sotto Win2K, poi provo sotto Win98 e per XP tra un po'.
Bye bye, Mat


Bella soluzione...

> ottiene un valore dell'handle in modo trasparente per il programmatore.
Qualcuno me lo sa spiegare cosa vuol dire?

 Qualcuno me lo sa spiegare cosa vuol dire?
Riferendomi al discorso di prima per esempio... parlavi di
SetForegroundWindow() senza argomenti. Giustissimo, e' un metodo di CWnd che
e' un wrapper VC++ dell'handle della finestra... fin qui siam d'accordo mi
pare. Quello che intendevo prima in modi sbrigativo e' che il programmatore
non e' responsabile dell'assegnamento valore dell'handle. Capito?

 non e' responsabile dell'assegnamento valore dell'handle. Capito?
Ma il compilatore non c'entra niente poverino...già ha i suoi problemi...

 Ma il compilatore non c'entra niente poverino...gią ha i suoi problemi...
Ognuno ha i suoi problemi, che ci posso fare io :)
Mi dispiace per lui :))

 Ognuno ha i suoi problemi, che ci posso fare io :)
Ah, ma tu non usi il VisualCiccio, č vero...altrimenti potevi provare
questa, č troppo figa...
class Bubba
{
public:
    Bubba();
};
Bubba::Bubba
{
}
Qui VisualCiccio al posto di dire "Nando va che le parentesi non sono un
optional !", dice "ODDIO, INTERNAL BYLLO ERRORAZZO !"
troppo fico...

 troppo fico...
Comincio a non capirci nulla di quel che dici :)
Cmq e' da un bel po' che non uso VC++ e l'ho usato tempo fa' (e neppure
molto a dire il vero, non mi ispira particolarmente)
Riassumo e chiudo sta discussione cmq, giusto per essere chiari.
Quel che intendevo (come ti ho detto quando eravamo ancora dentro al topic
del thread :) e' che la funzione SetForegroundWindow di CWnd non ha bisogno
del passaggio dell'handle come argomento perche' se lo prende dal wrapper
CWnd. Non e' affarm mio di come VC++ si procuri il valore e francamente non
lo so, deve essere un meccanismo di MFC e non mi interessa particolarmente.
Tutto qui.
Ti saluto.
Mat

 lo so, deve essere un meccanismo di MFC e non mi interessa
particolarmente.
Grazie della spiegazione, sai sono solo un po' di anni che uso MFC...terrņ
conto della nuova ed incredibile teoria.
alla prossima

 alla prossima
Capisco. Pure io son anni che uso BCC. Capita :)
Una tua risposta sul modo corretto in cui MFC si procura il valore
dell'handle cmq non me l'hai data nonostante le incredibili ipotesi che ho
buttato li io. Cmq come ti ho scritto prima non mi interessa. Ho risolto il
problema che avevo riguardo al mio prog. Alla prossima

 semplicemente da wrapper


 SetForegroundWindow(m_hWnd)...
Ecco bravo.
Ce lo metti tu il valore dell'handle in  m_hWnd  per caso? :)
La mia osservazione era solo su questo punto, non capisco dove stia il
problema.

> Ce lo metti tu il valore dell'handle in  m_hWnd  per caso? :)
Ma dai...non c'č nessuno che ha da dire niente?
basta finiamola li...io non so proprio piů cosa dirti...
č come dire se io mi scrivo una classe cosě
class Bubba
{
public:
    void SetForegroudWindow() { ::SetForegroudWindow(m_hWnd); };
protected:
    HWND m_hWnd;
};
non č che MFC č qualcosa di strano che supera l'umana conoscenza...
comunque č chiusa li...e il valore di m_hWnd viene settato nella OnCreate(),
ma lasciamo perdere cosě che č meglio...

 ma lasciamo perdere cosě che č meglio...
Ecco appunto.
viene settato nella OnCreate
Non e' di competenza del programmatore, che e' cio che dicevo prima
Non mi pare ci sia altro da aggiugere

 ha scritto nel messaggio
news:3zBk9.145135$ub2.3...@news1.tin.it...

Se ti serve avere l'handle della finestra, potresti scomodare il
file-mapping per creare un'area di memoria condivisa, su cui memorizzare il
tuo handle.
E' piuttosto semplice da gestire, non mi ricordo bene le api prova a cercare
qualcosa come MapViewOfFile o CreateFileMapping o giů di lě.
Porlock
Ciao.

 qualcosa come MapViewOfFile o CreateFileMapping o giů di lě.
CreateFileMapping mi pare... cmq ora ho risolto. Grazie lo stesso.