Newsgroup: it.comp.programmare.win32
Titolo: Hook Procedure

In una HookProcedure anziche' restituire CallNextHook devo restituire
un valore maggiore di zero .
Ora mi domando :
dato che e' sempre auspicabile richiamare la CallNextHook e' corretto
scrivere un codice di ritorno di questo tipo :
CallNextHook(....)  ;
return 1 ;
grazie.

 return 1 ;
mi sembra un controsenso... quali sono le tue intenzioni? il messaggio
deve o non deve arrivare alla finestra di destinazione? puoi anche
scriverlo un codice del genere ma così entri nell'undefined behavior...
anzi in certi casi quella mi sembra proprio la maniera giusta per entrare
nel behavior well documented only for Microsoft partners :PPP
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

ombra ha scritto:

richiamare CallNextHook() e poi tornare 1 non ha molto senso.
Ormai tutto il lavoro e' stato fatto.
Puoi tornare 1, senza richiamare la CallNextHook(), se non vuoi
propagare il messaggio.
Es. in una mia applicazione uso il tasto F10 per cose mie. Il tasto
pero' e' abbinato al menu' standard. Quando mi serve usarlo non
permetto la propagazione tornando 1 senza chiamare la CallNextHook().
Ciao

Ormai tutto il lavoro e' stato fatto.
Quello che non mi e' chiaro e' cosa fa CallNextHook .
Ho creato una dialog in cui anziche passare il focus fra i vari
controlli con il TAB uso il  tasto INVIO .
Ho pensato di usare un HOOK  che tramuta la pressione del tasto INVIO
in un TAB .
Funziona con un problema :
su alcuni controlli di tipo button anziche' passare il focus li preme
come se usassi la "barra spazio" .
Per evitare cio ' devo restituire un valore maggiore di 1 ,allora il
focus passa regolarmente .
Ora dato che mi sembra di aver capito che il non richiamare la
CallNextHook impedisce ad un altro prg che ha installato un stesso
tipo di Hook di poterlo gestire come faccio a non compromettere il
funzionamento di quel programma ?
Da qui l'idea di chiamare prima la CallNextHook per non spezzare la
"catena" e quindi restituire 1 per permettere un corretto
funzionamento del mio programma .
Qui la HOOK procedure :
 LRESULT CALLBACK HookProc(int code,WPARAM wparam,LPARAM lparam)
{
 if ( code < 0  || code != MSGF_DIALOGBOX ) return
CallNextHookEx(Hook,code,wparam,lparam) ;
 MSG *msg = (MSG*) lparam ;
 switch(msg->message) {
       case WM_KEYDOWN :
       switch( msg->wParam ) {
              case VK_RETURN :
              PostMessage(msg->hwnd,WM_KEYDOWN,9,0x000F0001) ;
              PostMessage(msg->hwnd,WM_CHAR,9,0x000F0001) ;
              PostMessage(msg->hwnd,WM_KEYUP,9,0xC00F0001) ;
             return CallNextHookEx(Hook,code,wparam,lparam) +1 ;
          }
       break;
       }
 return CallNextHookEx(Hook,code,wparam,lparam)  ;
}

 return 1 ;
Dipende da che tipo di hook stai usando.
Ciao, Enrico

Ciao, Enrico
Saluti .

 funzionamento di quel programma ?
Nel tuo caso non compormetti nulla. Tu catturi la pressione del tasto e non
chiamando CallNextHook non passi avanti il tasto ma lo blocchi. Un altro
eventuale hook installato dopo il tuo non vede il tasto arrivare e quindi
non fa nulla. (in realtà conosco almeno un software che avrebbe bisogno
comunque del tasto per dirti cosa hai premuto)
Nel tuo caso non lo passerei mai (a parte la condizione code < 0) perché
l'help di win32 dice che lo passa lui o meno a seconda del valore di
ritorno. Se lo gestisci torni 1, altrimenti 0.
Ciao, Enrico

 in un TAB .
<snip>
per fare quello che hai detto non e' necessario scomodare le Hook().
Ti posto qui un metodo del mio framework che forse ti puo' chiarire
come fare quello che tiserve.
<code>
//-----------------------------------------------------------
LRESULT PControl::windowProc(HWND hwnd, UINT message, WPARAM wParam,
LPARAM lParam)
{
  int key;
  switch(message) {
    case WM_GETDLGCODE:
/*    // esempio di verifica tasto premuto
      if(GetKeyState(VK_RETURN)& 0x8000)
        key = VK_RETURN;
      else if(GetKeyState(VK_DOWN)& 0x8000)
        key = VK_DOWN;
      else if(GetKeyState(VK_UP)& 0x8000)
        key = VK_UP;
      else
*/
      key = verifyKey();
      if(key) {
       // simula il rilascio del pulsante affinche' nel prossimo
ingresso,
       // trovando ancora il tasto premuto, non torni ancora
DLGC_WANTALLKEYS
        up_click(key);
        return DLGC_WANTALLKEYS;
        }
      break;
    case WM_KEYDOWN:
      if(evKeyDown(wParam))
        return 0;
      break;
    case WM_KEYUP:
      if(evKeyUp(wParam))
        return 0;
      break;
    case WM_CHAR:
      if(evChar(wParam))
        return 0;
      break;
    }
  return baseClass::windowProc(hwnd, message, wParam, lParam);
}
</code>
naturalmente i vari metodi sono virtuali e demandati alle classi eredi.
Nel mio codice, per esempio, la classe PEdit trasforma il tasto invio e
la freccia in basso in TAB e la freccia in alto in SHIFT+TAB.
Ciao