besoin d'aide pour interception clavier

Voici un code où je ne comprends pas le comportement des codes des touches.

Pourquoi Scancode, key_up_code et key_down_code me renvoie systématiquement les valeurs par rapport à la majuscule, alors que j'ai tapé une minuscule.

Exemple: asc("a")=97: ce n'est pas le rendu du code ci dessous, qui renvoie toujours 65

Charger le code et tapez a en minuscule.

Code:: dim scan$,up$,dow$,as1%
label af
memo 1 : height 1,height(0)
on_key_up 1,af
on_key_down 1,af
set_focus 1
END
' ===================
af:
scan$=chr$(scancode)
up$=chr$(key_up_code)
dow$=chr$(key_down_code)
as1%=asc(scan$)
' clear 1
wait 100
item_add 1,"chr$(scancode)="+scan$
item_add 1,"chr$(key_up_code)="+up$
item_add 1,"chr$(key_down_code)="+dow$
item_add 1,"Scancode="+str$(scancode)
item_add 1,"ASC(scancode)="+str$(as1%)
item_add 1,"----------------------------"
item_add 1,"asc(''a'')="+str$(asc("a"))
item_add 1,"asc(''A'')="+str$(asc("A"))
item_add 1,"============================"

RETURN

A+

C'est un problème de majuscules/minuscules:

Code:: dim scan$,up$,dow$,as1%, scan1$, spec%, scan%, scan1%
label af
memo 1 : height 1,height(0)
on_key_up 1,af
on_key_down 1,af
set_focus 1
END
' ===================
af:
scan%=scancode
scan1%=scan%
scan$=chr$(scan%)
spec%=key_down_special
if (scan%>64) and (scan%<91)
if spec%=0 then scan1% = scan% + 32 : ' <===== ajuster si Maj pas enfoncé
end_if
scan1$=chr$(scan1%)
up$=chr$(key_up_code)
dow$=chr$(key_down_code)
as1%=asc(scan$)
' clear 1
wait 100
item_add 1,"chr$(scancode)="+scan$
item_add 1,"key_down_special="+str$(spec%)
item_add 1,"chr$(scan1%)="+scan1$
item_add 1,"chr$(key_up_code)="+up$
item_add 1,"chr$(key_down_code)="+dow$
item_add 1,"Scancode="+str$(scancode)
item_add 1,"ASC(scancode)="+str$(as1%)
item_add 1,"----------------------------"
item_add 1,"asc(''a'')="+str$(asc("a"))
item_add 1,"asc(''A'')="+str$(asc("A"))
item_add 1,"============================"

RETURN

Ceci est valable sir "Verr. MAJ" n'est pas enfoncé. Sinon, c'est l'inverse.

En fait, SCANCODE retourne le code associé à la touche seule. Et la "casse" du caractère dépend de l'état concommittant des touches 'Maj" et "Verr. MAJ". Mais la lettre elle-même génère toujours un code unique.

Invité

Bonjour Jean Claude.

J'ai essayé ton programme, et ça ne marche pas. J'ai voulu ajouter inkey$, mais cela ne donne rien, et je pense que c'est l'événement qui prend en compte, et inkey$ n'est plus accessible.

J'ai eu une autre approche, car pour mon programme j'ai du faire des séries de testes à part, pour comprendre, ou régler certaines choses. Mais j'interdis dans mon programme tout ce qui est événement, ce qui complique les choses lors de la saisie.

J'y ai vu un autre problème: il est impossible de faire une sélection classique par [shift] + touche de direction avant ou arrière. Scancode est unique pour shift, et on ne peut pas avoir la situation de ces touches en même temps, il m'a fallu trouvé autre chose. Ensuite, avec Inkey$ et Scancode, je ne lis que les minuscules (évidemment la touche caplock en minuscule). Pour lire en majuscule, il faut appuyer sur shift et une touche, puis appuyer je crois sur l'autre shift, ou peut-être réappuyer sur shift de nouveau.

C'est un vrai problème, et j'ai préféré ne pas poser de question, car je sais que je n'aurai pas eu de réponse satisfaisante. Seul Jack peut faire quelque chose. Mais on est tout le temps en train de le titiller, autant moi que les autres, et je doute fort qu'il veule bien intervenir.

Mon programme de teste:

Code:: ' clavier picture

width 0,700: height 0,500

picture 2 : full_space 2:font_size 2,12 : print_target_is 2 : 2d_target_is 2 : font_name 2,"Consolas"
image 4
' tracage de la zone clavier
tracage_clavier(20,20,600,100)

end
sub tracage_clavier(x,y,x1,y1)
   dim_local curseur,ga,larg , clavier$ , clav$, top_clavier
   ga = x+10 : top_clavier = y+20
   2d_pen_color 0,0,255:2d_pen_width 2 : 2d_fill_color 240,240,240 :2d_fill_on
   2d_rectangle x,y,x1,y1 : font_size 2,12 : font_name 2,"Consolas" : font_bold 2
   2d_image_copy 4,x,y,x1,y1
   2d_pen_color 255,0,0 : 2d_pen_width 1 :' 2d_fill_off

   repeat
   2d_pen_color 255,255,255 : trace_curseur(ga,top_clavier,curseur)
   if clavier$ = "" then curseur =0
   clav$ = inkey$
   if scancode = 8 :' retour arrière
   if curseur > 1
   clavier$ = left$(clavier$,curseur-1) + right_pos$(clavier$,curseur+1)
   curseur = curseur-1
   else
   clavier$ = right_pos$(clavier$,2): curseur = 0
   end_if
   end_if

   if clav$ = ""
   if scancode = 37 and clav$ = "":' and curseur>0
   curseur = curseur - 1
   else
   if scancode = 39 and curseur < len(clavier$)
   curseur = curseur + 1
   else
   if scancode = 46 :' del
   clavier$ = left$(clavier$,curseur) + right_pos$(clavier$,curseur+2)
   else
   if scancode =38 or scancode = 36:' origine
   curseur = 0
   else
   if scancode = 40 or scancode = 35 then curseur = len(clavier$): ' fin
   end_if
   end_if
   end_if
   end_if
   end_if

   if clav$ <> ""
   if asc(clav$) > 31
   if curseur = len(clavier$)
   clavier$ = clavier$ + clav$ : curseur = curseur + 1
   else
   if curseur > 1
   clavier$ = left$(clavier$,curseur) + clav$ + right_pos$(clavier$,curseur +1)
   curseur = curseur +1
   else
   if curseur = 1
   2d_pen_color 0,0,255 : trace_curseur(ga,top_clavier,0)
   clavier$ = left$(clavier$,1) + clav$+right_pos$(clavier$,2) : curseur = 2
   else
   clavier$ = clav$ + clavier$ : curseur = 1
   end_if
   end_if
   end_if
   end_if
   end_if

   print_locate ga,top_clavier : print clavier$+" "
   2d_pen_color 255,0,0 : 2d_pen_width 1 : trace_curseur(ga,top_clavier,curseur)
   repeat: wait 1 :until scancode = 0 or scancode = 27 : wait 1:repeat:until scancode <> 0
   until scancode = 13 or scancode = 27
   terminate
end_sub
========================
sub trace_curseur(ga,top_clavier,curseur)
   2d_line ga + curseur * 11 , top_clavier, ga + curseur * 11 , top_clavier+23
   2d_line ga + curseur * 11 , top_clavier, ga + curseur * 11 +10 , top_clavier
   2d_line ga + curseur * 11 , top_clavier+22, ga + curseur * 11 +10 , top_clavier+22
   2d_line ga + curseur * 11+10 , top_clavier, ga + curseur * 11+10 , top_clavier+22
end_sub

Dépassé par Klaus, mais il y a complémentarité.

Merci à vous deux pour vos réponses.

C'est bien ce que je craignais, SCANCODE ne retourne que le code de la touche en majuscule, sans tenir compte de de la touche "VerrMaj" ou "Maj"

C'est franchement pas pratique du tout, et de plus inkey$ ne retourne jamais de valeur.

Je me demande à quoi sert inkey$ ?

J'ai une idée de contournement, comme l'a fait Cosmos ou Klaus, je teste et je vous tiens au courant.

A+

PS: je revois ma copie pour inkey$, car l'exemple fourni dans la doc marche bien.

Bonjour à tous,

@jean claude
j'avais posté cette démo pour minibug, mais il peut servir dans ton cas à mon avis.

Code:: ' Panoramic 0.9.25

' ==============================================================
' = Title : LEDs clavier
' =
' = Author : Silverman
' =
' = Date : Juin 2015
' =
' = Version: 1.0
' ==============================================================
' Comments : Controler les LEDs du clacier
' ==============================================================

' Fonction "keybd_event":
' https://msdn.microsoft.com/en-us/library/windows/desktop/ms646304%28v=vs.85%29.aspx

' Virtual-Key Codes:
' https://msdn.microsoft.com/en-us/library/windows/desktop/dd375731%28v=vs.85%29.aspx

dim null,result%
dim OldScroll%,OldNum%,OldCaps%,key%,c
dim memblock1%,memblock1$
dim memblock2%,memblock2$

' récupère l'état des LEDs
GetNumLock()
OldNum% = result%

GetCapsLock()
OldCaps% = result%

GetScrollLock()
OldScroll% = result%

' éteindre les LEDs
for key%=1 to 255
   SetkeyState(key%,0)
next key%

' mais On aurais pu les éteindre aussi comme ça: SetScrollLock(0):SetNumLock(0):SetCapsLock(0)

c = 0
repeat
   cls
   Print "Regardez les LEDs du clavier."
   print "Appuyez la barre d'espace pour terminer."
   print

   Select c
   case 0
   SetNumLock(0)
   SetCapsLock(0)
   setScrollLock(0)

   case 1
   SetNumLock(1)

   case 2
   SetCapsLock(1)

   case 3
   SetScrollLock(1)
   end_select

   ' on affiche une info
   for key%=1 to 255
   GetKeyState(key%)
   if result%>0
   print "Virtual-Key Codes = "+"0x"+hex$(key%)
   end_if
   next key%

   c = c + 1
   if c > 3 then c = 0
   wait 500

until scancode=32

' remettre les LEDs dans leur état initial
SetScrollLock(OldScroll%)
SetNumLock(OldNum%)
SetCapsLock(OldCaps%)

print
print "Fini!"

END
' ******************************************************************************
sub GetPlatform()
   result% = 0
   dll_on "kernel32.dll"
   result% = dll_call0("GetVersion")
   dll_off
end_sub

sub GetKeyState(key%)
   result% = 0
   memblock2$=string$(256,chr$(0))
   GET_BUFFER_PTR(adr(memblock2%) , adr(memblock2$))
   dll_on "user32"
   null=dll_call1("GetKeyboardState",memblock2%)
   READ_BUFFER_BYTE(adr(result%),memblock2%,key%)
   dll_off
end_sub

sub SetKeyState(key%,turnon%)
dim_local null

   ' Windows 2000 / XP
   GetPlatform()
   if result% > 0
   GetKeyState(key%)
   if result% <> turnon%
   dll_on "user32.dll"
   null=dll_call4("keybd_event",key%,0,1,0)
   null=dll_call4("keybd_event",key%,0,3,0)
   dll_off
   end_if
   else
   ' Windows 98,ME
   dll_on "user32.dll"
   memblock1$=string$(256,chr$(0))
   GET_BUFFER_PTR(adr(memblock1%) , adr(memblock1$))
   null=dll_call1("GetKeyboardState",memblock1%)
   WRITE_BUFFER_BYTE(memblock1%,key%,turnon%)
   null=dll_call1("SetKeyboardState",memblock1%)
   dll_off
   end_if
end_sub

sub SetScrollLock(turnon%)
   SetKeyState(145,turnon%)
end_sub

sub GetScrollLock()
   result% = 0
   GetKeyState(145)
end_sub

sub SetCapsLock(turnon%)
   SetKEyState(20,turnon%)
end_sub

sub GetCapsLock()
   result% = 0
   GetKeyState(20)
end_sub

sub SetNumLock(turnon%)
   SetKeyState(144,turnon%)
end_sub

sub GetNumLock()
   result% = 0
   GetKeyState(144)
end_sub

'
' ##############################################################################
' # #
' # Bibliothèque de SUBs pour gérer des mémoires tampons V1.0 #
' # #
' ##############################################################################
sub READ_BUFFER_BYTE(adr_destination%,adr_source%,buffer_position%)
' BYTE = OCTET(en français)
' adr_destination% = adresse destination
' adr_source% = adresse adr_source
' copie un BYTE, 0 < BYTE < 255
   poke adr_destination%,peek(adr_source% + buffer_position%)
end_sub

sub READ_BUFFER_WORD(adr_destination%,adr_source%,buffer_position%)
' WORD = 2 BYTEs
' adr_destination% = adresse destination
' adr_source% = adresse adr_source
' copie un WORD, 0 < WORD < 65535
   poke adr_destination%,peek(adr_source%+buffer_position%)
   poke adr_destination%+1,peek(adr_source%+1+buffer_position%)
end_sub

sub READ_BUFFER_DWORD(adr_destination%,adr_source%,buffer_position%)
' DWORD = 4 BYTEs
' adr_destination% = adresse destination
' adr_source% = adresse adr_source
' copie un DWORD, 0 < DWORD < 4294967295
   poke adr_destination%,peek(adr_source%+buffer_position%)
   poke adr_destination%+1,peek(adr_source%+1+buffer_position%)
   poke adr_destination%+2,peek(adr_source%+2+buffer_position%)
   poke adr_destination%+3,peek(adr_source%+3+buffer_position%)
end_sub

sub READ_BUFFER_LONG(adr_destination%,adr_source%,buffer_position%)
' LONG = 4 BYTEs
' adr_destination% = adresse destination
' adr_source% = adresse adr_source
' copie un LONG, –2147483648 < LONG < 2147483647
   poke adr_destination%,peek(adr_source%+buffer_position%)
   poke adr_destination%+1,peek(adr_source%+1+buffer_position%)
   poke adr_destination%+2,peek(adr_source%+2+buffer_position%)
   poke adr_destination%+3,peek(adr_source%+3+buffer_position%)
end_sub

sub READ_BUFFER_INT(adr_destination%,adr_source%,buffer_position%)
' INT = 4 BYTEs
' adr_destination% = adresse destination
' adr_source% = adresse adr_source
' copie un INTeger, –2147483648 < INT < 2147483647
   poke adr_destination%,peek(adr_source%+buffer_position%)
   poke adr_destination%+1,peek(adr_source%+1+buffer_position%)
   poke adr_destination%+2,peek(adr_source%+2+buffer_position%)
   poke adr_destination%+3,peek(adr_source%+3+buffer_position%)
end_sub

sub READ_BUFFER_FLOAT(adr_destination%,adr_source%,buffer_position%)
' FLOAT = 8 BYTEs
' adr_destination% = adresse destination
' adr_source% = adresse adr_source
' copie un FLOAT, -1,7976931348623157×10^308 < FLOAT < 1,7976931348623157×10^308
   poke adr_destination%,peek(adr_source%+buffer_position%)
   poke adr_destination%+1,peek(adr_source%+1+buffer_position%)
   poke adr_destination%+2,peek(adr_source%+2+buffer_position%)
   poke adr_destination%+3,peek(adr_source%+3+buffer_position%)
   poke adr_destination%+4,peek(adr_source%+4+buffer_position%)
   poke adr_destination%+5,peek(adr_source%+5+buffer_position%)
   poke adr_destination%+6,peek(adr_source%+6+buffer_position%)
   poke adr_destination%+7,peek(adr_source%+7+buffer_position%)
end_sub

'###############################################################################
sub WRITE_BUFFER_BYTE(adr_destination%,buffer_position%,byte%)
' BYTE = OCTET(en français)
' adr_destination% = adresse destination
' byte% = 0 < BYTE < 255
   poke adr_destination%+buffer_position%,peek(adr(byte%))
end_sub

sub WRITE_BUFFER_WORD(adr_destination%,buffer_position%,word%)
' WORD = 2 BYTEs
' adr_destination% = adresse destination
' word% = 0 < WORD < 65535
   poke adr_destination%+buffer_position%,peek(adr(word%))
   poke adr_destination%+1+buffer_position%,peek(adr(word%)+1)
end_sub

sub WRITE_BUFFER_DWORD(adr_destination%,buffer_position%,dword%)
' DWORD = 4 BYTEs
' adr_destination% = adresse destination
' dword% = 0 < DWORD < 4294967295
   poke adr_destination%+buffer_position%,peek(adr(dword%))
   poke adr_destination%+1+buffer_position%,peek(adr(dword%)+1)
   poke adr_destination%+2+buffer_position%,peek(adr(dword%)+2)
   poke adr_destination%+3+buffer_position%,peek(adr(dword%)+3)
end_sub

sub WRITE_BUFFER_LONG(adr_destination%,buffer_position%,long%)
' LONG = 4 BYTEs
' adr_destination% = adresse destination
' long% = –2147483648 < LONG < 2147483647
   poke adr_destination%+buffer_position%,peek(adr(long%))
   poke adr_destination%+1+buffer_position%,peek(adr(long%)+1)
   poke adr_destination%+2+buffer_position%,peek(adr(long%)+2)
   poke adr_destination%+3+buffer_position%,peek(adr(long%)+3)
end_sub

sub WRITE_BUFFER_INT(adr_destination%,buffer_position%,long%)
' INT = 4 BYTEs
' adr_destination% = adresse destination
' int% = –2147483648 < INT < 2147483647
   poke adr_destination%+buffer_position%,peek(adr(long%))
   poke adr_destination%+1+buffer_position%,peek(adr(long%)+1)
   poke adr_destination%+2+buffer_position%,peek(adr(long%)+2)
   poke adr_destination%+3+buffer_position%,peek(adr(long%)+3)
end_sub

sub WRITE_BUFFER_FLOAT(adr_destination%,buffer_position%,float)
' FLOAT = 8 BYTEs
' adr_destination% = adresse destination
' float = -1,7976931348623157×10^308 < FLOAT < 1,7976931348623157×10^308
   poke adr_destination%+buffer_position%,peek(adr(float))
   poke adr_destination%+1+buffer_position%,peek(adr(float)+1)
   poke adr_destination%+2+buffer_position%,peek(adr(float)+2)
   poke adr_destination%+3+buffer_position%,peek(adr(float)+3)
   poke adr_destination%+4+buffer_position%,peek(adr(float)+4)
   poke adr_destination%+5+buffer_position%,peek(adr(float)+5)
   poke adr_destination%+6+buffer_position%,peek(adr(float)+6)
   poke adr_destination%+7+buffer_position%,peek(adr(float)+7)
end_sub

'###############################################################################
sub BUFFER_SIZE(adr_destination%,buffer_ptr%)
' retouve la taille du buffer
   poke adr_destination%,peek(buffer_ptr%-4)
   poke adr_destination%+1,peek(buffer_ptr%-3)
   poke adr_destination%+2,peek(buffer_ptr%-2)
   poke adr_destination%+3,peek(buffer_ptr%-1)
end_sub

sub FILL_BUFFER(buffer_ptr%,value%)
' uniquement des BYTEs
dim_local size%,i
   value%=bin_and(value%,255)
   BUFFER_SIZE(adr(size%),buffer_ptr%)
   size%=size%-1
   for i=0 to size%
   poke buffer_ptr%+i,value%
   next i
end_sub

sub CLEAR_BUFFER(buffer_ptr%)
' effacer un buffer revient à le remplir de 0
   FILL_BUFFER(buffer_ptr%,0)
end_sub

sub DISPLAY_BUFFER(buffer_ptr%,c$)
' affiche le contenu du buffer
dim_local buffer_position%,i,value,tmp%,tmp,j,k
   buffer_position%=0
   c$=upper$(c$)
   for i=1 to len(c$)
   value=asc(mid$(c$,i,1))
   select value
   case 66
   tmp%=0
   READ_BUFFER_BYTE(adr(tmp%),buffer_ptr%,buffer_position%)
   buffer_position%=buffer_position%+1
   print tmp%

   case 68
   tmp%=0
   READ_BUFFER_DWORD(adr(tmp%),buffer_ptr%,buffer_position%)
   buffer_position%=buffer_position%+4
   print tmp%

   case 70
   tmp=0
   READ_BUFFER_FLOAT(adr(tmp),buffer_ptr%,buffer_position%)
   buffer_position%=buffer_position%+8
   k=0 : for j=0 to 7 : k=k+peek(adr(tmp)+j) : next j
   if k=2040
   print "NaN"
   else
   print tmp
   end_if

   case 73
   tmp%=0
   READ_BUFFER_INT(adr(tmp%),buffer_ptr%,buffer_position%)
   buffer_position%=buffer_position%+4
   print tmp%

   case 76
   tmp%=0
   READ_BUFFER_LONG(adr(tmp%),buffer_ptr%,buffer_position%)
   buffer_position%=buffer_position%+4
   print tmp%

   case 87
   tmp%=0
   READ_BUFFER_WORD(adr(tmp%),buffer_ptr%,buffer_position%)
   buffer_position%=buffer_position%+2
   print tmp%
   end_select
   next i
end_sub

sub GET_BUFFER_PTR(adr_destination%,adr_source%)
' retrouve l'adresse du pointeur
   poke adr_destination%,peek(adr_source%)
   poke adr_destination%+1,peek(adr_source%+1)
   poke adr_destination%+2,peek(adr_source%+2)
   poke adr_destination%+3,peek(adr_source%+3)
end_sub

sub DEBUG(adr%, tai%)
dim_local i,k
   print
   for i=0 to tai%-1
   k=peek(adr%+i)
   if k<16
   print "0";hex$(k);" ";
   else
   print hex$(k);" ";
   end_if
   next i
   print
   for i=0 to tai%-1
   k=peek(adr%+i)
   print chr$(k);" ";
   next i
   print
end_sub

Merci Sylverman, je vais regarder ce code.
Je ne peux pas le tester, car il n'y a pas de LED sur mon clavier. Oui, je sais, c'est pas très pratique.
Mais je peux toujours voir comment tu as procédé pour détecter l'état du clavier.

A+

Tu as une fonction de la dll de Klaus pour connaitre l' état du clavier :
GetKeyboardState

Peut être y a t il une solution en ligne de commande mais là je ne sais pas.

Code:: dim kgf$ : kgf$= "C:\KGF\KGF.dll"
dim res%
dim no%
dim VerMaj% : no% = no%+1 : VerMaj% = no%
dim VerNum% : no% = no%+1 : VerNum% = no%

Height 0,100
width 0,150
caption 0,"Etat Clavier"
font_name 0,"Arial"
font_size 0,8

CHECK VerMaj%
caption VerMaj%,"VerMaj"
top VerMaj%,10
left VerMaj%,10

CHECK VerNum%
caption VerNum%,"VerNum"
top VerNum%,35
left VerNum%,10

dll_on kgf$
res% = dll_call1("GetKeyboardState",20)
if res%=2 : mark_on VerMaj% : res%=0 : end_if
res% = dll_call1("GetKeyboardState",144)
if res%=2 : mark_on VerNum% : res%=0 : end_if

end

Pour ma part j'ai gardé la DLL de Klaus. Je l'avais déjà intégré dans mon programme.

Cela dit la proposition de Silverman reste une très bonne alternative.

J' ai édité dans le message au-dessus avec un petit prog qui utilise
la dll de Klaus.
Suivant l' etat des verrouillages on agit... Rolling Eyes

Pour ma part, j' inclus d' office la dll de Klaus dans mes progs longs.
On finit toujours par en avoir besoin à un moment ou un autre, pour
une raison ou une autre.
Elle devient de plus en plus incontournable avec complexification
de nos programmes... Wink

La solution de Silverman est plus légère pour un petit programme.

Code:: dim result%

GetCapsLock()
print : print "1"
if result%=0 then print "Le clavier est en minuscule"
if result%=1 then print "Le clavier est vérouillé en MAJUSCULE"

GetNumLock()
print : print "2"
if result%=0 then print "Le Pavé Numérique est inactif"
if result%=1 then print "Le Pavé Numérique est actif"

GetScrollLock()
print : print "3"
if result%=0 then print "La touche [arrêt défil] est inactive "
if result%=1 then print "La touche [arrêt défil] est active"

END
REM ===================================================== SUB(s) ETAT du CLAVIER
sub GetScrollLock()
result% = 0
GetKeyState(145)
end_sub

sub GetNumLock()
result% = 0
GetKeyState(144)
end_sub

sub GetCapsLock()
result% = 0
GetKeyState(20)
end_sub

sub GetKeyState(key%)
dim_local memblock2%,null,memblock2$
result% = 0
memblock2$=string$(256,chr$(0))
GET_BUFFER_PTR(adr(memblock2%) , adr(memblock2$))
dll_on "user32"
null=dll_call1("GetKeyboardState",memblock2%)
READ_BUFFER_BYTE(adr(result%),memblock2%,key%)
dll_off
end_sub

sub READ_BUFFER_BYTE(adr_destination%,adr_source%,buffer_position%)
poke adr_destination%,peek(adr_source% + buffer_position%)
end_sub

sub GET_BUFFER_PTR(adr_destination%,adr_source%)
' retrouve l'adresse du pointeur
poke adr_destination%,peek(adr_source%)
poke adr_destination%+1,peek(adr_source%+1)
poke adr_destination%+2,peek(adr_source%+2)
poke adr_destination%+3,peek(adr_source%+3)
end_sub

Mais dans un programme qui utilise KGF.dll, évidement....

A+

» besoin daide pour code
» interception appui clavier sur touche de Fonction
» Pour les séniors : Apprendre à taper sur un clavier
» besoin d'aide pour ce code
» Besoin d'aide pour la Cryptographie en RSA svp