Neues Problem; wieder mit der Tastatur

[Diogenes]

Hallo liebe Leute,

ich muss schon wieder etwas nachfragen.
in meinem ersten Thread => "Anfängerprobleme beim ersten Programm"
habe ich ja schon Probleme mit der Tastatursteuerung gehabt.
Mit Eurer Hilfe konnte ich dann einenSteuerung entwickeln, die zumindest die normalen
Tasten korrekt wiedergibt.
Ich habe das jetzt noch einmal vertieft, und meine, einen Fehler in PureBasic
gefunden zu haben. Ich will mich da aber nicht zu weit aus dem Fenster lehnen,
schließlich bin ich noch Anfänger in PB.

Trotzdem muss es doch irgendeine Lösung geben.
Ich habe alle 128 Threads die es im Forum zu Thema Tastatur gibt zumindest überflogen,
bin aber noch nicht auf eine wirklich gültige Lösung gestossen.

Das Problem liegt meine ich darin, dass PB nicht die genormten Scancodes der Tastatur für seine Key-Konstanten benutzt, sondern selbt gewählte Zahlen.

Unten findet Ihr ein Testprogramm, welches man wahlweise mit Waitstring() aktiv
oder waitstring2() aktiv kompilieren kann.
Bei beiden ergeben sich Fehler in der Tastaturabfrage.

In waitstring wird die PB-tastennummer und der Modifier ausgelesen.
Da eine Prozedur nur einen einzigen Wert zurückliefern kann, habe ich den
Modifier mit 1000 multipliziert und zum Tastenwert addiert.

Ausgabe:
Taste (alleine) (+shift) (+ctrl) (+shift+ctrl) Numlock-Status
i 73 1073 4073 5073 1 ok
i 73 1073 4073 5073 0 ok
l 76 1076 4076 5076 1 ok
l 76 1076 4076 5076 0 ok
k 75 1075 4075 5075 1 ok
k 75 1075 4075 5075 0 ok
j 74 1074 4074 5074 1 ok
j 74 1074 4074 5074 0 ok
cursor up 38 1038 4038 5038 1 ok
cursor up 38 1038 4038 5038 0 ok
cursor re 39 1039 4039 5039 1 ok
cursor re 39 1039 4039 5039 0 ok
cursor dn 40 1040 4040 5040 1 ok
cursor dn 40 1040 4040 5040 0 ok

Numpad 5 101 12 4101 4016 (shift) 1 nicht ok
+4012
+4016 (shift)
+17 (ctrl)
Numpad 5 12 1012 4012 5012 0 ok

Numpad 3 99 34 4099 mehrere+4034 1 nicht ok
Numpad 3 34 1034 4034 5034 0 ok

Numpad 2 98 40 4098 mehrere+4040 1 nicht ok
Numpad 2 35 1035 4035 5035 0 ok

Numpad 1 97 35 4097 mehrere+4035 1 nicht ok
Numpad 1 35 1035 4035 5035 0 ok
[/list]
Das heisst, dass GetGadgetAttribute(#cv001,#PB_Canvas_Modifiers) die
Modifier bei eingeschaltetem Numlock nicht korrekt übergibt.
Trotzdem könnt man diesen Fehler noch abfangen, wenn man zusätzlich den
Numlockstatus überprüft und berücksichtigt.

Nicht zu beheben ist aber der Fehler bei der Taste Numpad 2
Bei cursor down ohne shift wird 40 zurückgeliefert wenn Numlock eingeschaltet ist
Bei numpad 2 mit shift wird aber auch 40 zurückgeliefert wenn numlock eingeschaltet ist

Das heißt, es wird der gleiche wert bei 2 unterschiedlichen Tasten zurückgeliefert
und dann auch noch jeweils einmal bei gedrücktem Shift und einmal ohne


Daher habe ich mir die Mühe Gemacht und Waitstring 2 geschrieben.
Hier habe ich die addkeyshortcuts benutzt. Leider war das Ergebnis völlig unbrauchbar
ich habe die Tastaturshortcuts benannt #kb000 fortlaufend mit Enumeration beginnend bei 100

Taste (alleine) (+shift) (+ctrl) (+shift+ctrl) Numlock-Status
i 101 102 103 104 1 + 0 ok
l 105 106 107 108 1 + 0 ok
k 109 110 111 112 1 + 0 ok
j 113 114 115 116 1 + 0 ok
cursor up 117 118 119 120 1 + 0 ok
cursor re 121 122 123 124 1 + 0 ok
cursor dn 125 126 127 128 1 + 0 ok
cursor li 129 130 131 132 1 + 0 ok

numpad 5 133 - 135 - 1
numpad 5 - - - - 0
numpad 3 - - - - 1
numpad 3 137 - 139 - 0
numpad 2 141 125 143 127 1
numpad 2 125 126 127 128 0
numpad 1 145 - 147 - 1
numpad 1 - - - - 0

Hat denn hier im Forum noch niemand Tastatureingaben abfangen müssen ?
Oder hat niemand außer mir Probleme und ich bin nur zu blöd?

Außerdem: wenn ich die ganze Tastatur abfragen wollte mit den entsprechenden Modifiern -
und <alt> habe ich noch gar nicht eingebaut - dann müßte man ja 105 Tasten mal
mind. 4 Zustände =620 addkeys definieren und 620 cases abfangen.
Weiteres Problem, wenn ich einen Flipper schreiben will, der mit der rechten und
linken shift-taste gespielt wird, dann kann ich doch mit code 16 nichts anfangen,
dann benötige ich doch zwingend die Scancodes 42 linkes Shift und 54 rechtes shift
oder 56 für alt und 184 für altgr

Kann sich da bitte jemand meiner erbarmen ?
Ich entschuldige mich auch gleich für die Menge Text, aber ich wollte das Problem
exakt schildern.

Code: Alles auswählen

EnableExplicit
Declare meldunten(meldu$)
Declare melduloesch()
Declare WAITSTRING1()
Declare waitstring2()
Declare auswertung(taste,shift,alt,ctrl,tnum,tcap,tscr)
Define titel$="Keyboardtest"
Define quiT,taste,shift,alt,ctrl,ric,tnum,tcap,tscr
quit=0:taste=0:shift=0:alt=0:ctrl=0:ric=0:tnum=0:tcap=0:tscr=0

; -------------------------------------------------------------
Enumeration 100; Tasten
  #kb000
  #kb001
  #kb002
  #kb003
  #kb004
  #kb005
  #kb006
  #kb007
  #kb008
  #kb009
  #kb010
  #kb011
  #kb012
  #kb013
  #kb014
  #kb015
  #kb016
  #kb017
  #kb018
  #kb019
  #kb020
  #kb021
  #kb022
  #kb023
  #kb024
  #kb025
  #kb026
  #kb027
  #kb028
  #kb029
  #kb030
  #kb031
  #kb032
  #kb033
  #kb034
  #kb035
  #kb036
  #kb037
  #kb038
  #kb039
  #kb040
  #kb041
  #kb042
  #kb043
  #kb044
  #kb045
  #kb046
  #kb047
  #kb048
EndEnumeration
Enumeration   ; Canvas
  #cv001
EndEnumeration
; -------------------------------------------------------------
;hier werden die Schriften vorgeladen, damit sie im Programm zur Verfügung stehen                                                   
LoadFont(1,"Arial",32)
LoadFont(2,"Bookman Old Style",18,#PB_Font_Bold )
; -------------------------------------------------------------
;hier wird das Hauptfenster geöffnet
OpenWindow(0,300,100,1024,768,titel$,#PB_Window_SystemMenu |#PB_Window_MinimizeGadget)            
CanvasGadget(#cv001,0,0,1024,768,#PB_Canvas_ClipMouse|#PB_Canvas_Keyboard)
AddKeyboardShortcut(0,#PB_Shortcut_All,#kb000)
; --
AddKeyboardShortcut(0,#PB_Shortcut_I,#kb001)
AddKeyboardShortcut(0,#PB_Shortcut_I|#PB_Shortcut_Shift,#kb002)
AddKeyboardShortcut(0,#PB_Shortcut_I|#PB_Shortcut_Control,#kb003)
AddKeyboardShortcut(0,#PB_Shortcut_I|#PB_Shortcut_Shift|#PB_Shortcut_Control,#kb004)
AddKeyboardShortcut(0,#PB_Shortcut_L,#kb005)
AddKeyboardShortcut(0,#PB_Shortcut_L|#PB_Shortcut_Shift,#kb006)
AddKeyboardShortcut(0,#PB_Shortcut_L|#PB_Shortcut_Control,#kb007)
AddKeyboardShortcut(0,#PB_Shortcut_L|#PB_Shortcut_Shift|#PB_Shortcut_Control,#kb008)
AddKeyboardShortcut(0,#PB_Shortcut_K,#kb009)
AddKeyboardShortcut(0,#PB_Shortcut_K|#PB_Shortcut_Shift,#kb010)
AddKeyboardShortcut(0,#PB_Shortcut_K|#PB_Shortcut_Control,#kb011)
AddKeyboardShortcut(0,#PB_Shortcut_K|#PB_Shortcut_Shift|#PB_Shortcut_Control,#kb012)
AddKeyboardShortcut(0,#PB_Shortcut_J,#kb013)
AddKeyboardShortcut(0,#PB_Shortcut_J|#PB_Shortcut_Shift,#kb014)
AddKeyboardShortcut(0,#PB_Shortcut_J|#PB_Shortcut_Control,#kb015)
AddKeyboardShortcut(0,#PB_Shortcut_J|#PB_Shortcut_Shift|#PB_Shortcut_Control,#kb016)
; --
AddKeyboardShortcut(0,#PB_Shortcut_Up,#kb017)
AddKeyboardShortcut(0,#PB_Shortcut_Up|#PB_Shortcut_Shift,#kb018)
AddKeyboardShortcut(0,#PB_Shortcut_Up|#PB_Shortcut_Control,#kb019)
AddKeyboardShortcut(0,#PB_Shortcut_Up|#PB_Shortcut_Shift|#PB_Shortcut_Control,#kb020)
AddKeyboardShortcut(0,#PB_Shortcut_Right,#kb021)
AddKeyboardShortcut(0,#PB_Shortcut_Right|#PB_Shortcut_Shift,#kb022)
AddKeyboardShortcut(0,#PB_Shortcut_Right|#PB_Shortcut_Control,#kb023)
AddKeyboardShortcut(0,#PB_Shortcut_Right|#PB_Shortcut_Shift|#PB_Shortcut_Control,#kb024)
AddKeyboardShortcut(0,#PB_Shortcut_Down,#kb025)
AddKeyboardShortcut(0,#PB_Shortcut_Down|#PB_Shortcut_Shift,#kb026)
AddKeyboardShortcut(0,#PB_Shortcut_Down|#PB_Shortcut_Control,#kb027)
AddKeyboardShortcut(0,#PB_Shortcut_Down|#PB_Shortcut_Shift|#PB_Shortcut_Control,#kb028)
AddKeyboardShortcut(0,#PB_Shortcut_Left,#kb029)
AddKeyboardShortcut(0,#PB_Shortcut_Left|#PB_Shortcut_Shift,#kb030)
AddKeyboardShortcut(0,#PB_Shortcut_Left|#PB_Shortcut_Control,#kb031)
AddKeyboardShortcut(0,#PB_Shortcut_Left|#PB_Shortcut_Shift|#PB_Shortcut_Control,#kb032)
; --
AddKeyboardShortcut(0,#PB_Shortcut_Pad5,#kb033)
AddKeyboardShortcut(0,#PB_Shortcut_Pad5|#PB_Shortcut_Shift,#kb034)
AddKeyboardShortcut(0,#PB_Shortcut_Pad5|#PB_Shortcut_Control,#kb035)
AddKeyboardShortcut(0,#PB_Shortcut_Pad5|#PB_Shortcut_Shift|#PB_Shortcut_Control,#kb036)
AddKeyboardShortcut(0,#PB_Shortcut_Pad3,#kb037)
AddKeyboardShortcut(0,#PB_Shortcut_Pad3|#PB_Shortcut_Shift,#kb038)
AddKeyboardShortcut(0,#PB_Shortcut_Pad3|#PB_Shortcut_Control,#kb039)
AddKeyboardShortcut(0,#PB_Shortcut_Pad3|#PB_Shortcut_Shift|#PB_Shortcut_Control,#kb040)
AddKeyboardShortcut(0,#PB_Shortcut_Pad2,#kb041)
AddKeyboardShortcut(0,#PB_Shortcut_Pad2|#PB_Shortcut_Shift,#kb042)
AddKeyboardShortcut(0,#PB_Shortcut_Pad2|#PB_Shortcut_Control,#kb043)
AddKeyboardShortcut(0,#PB_Shortcut_Pad2|#PB_Shortcut_Shift|#PB_Shortcut_Control,#kb044)
AddKeyboardShortcut(0,#PB_Shortcut_Pad1,#kb045)
AddKeyboardShortcut(0,#PB_Shortcut_Pad1|#PB_Shortcut_Shift,#kb046)
AddKeyboardShortcut(0,#PB_Shortcut_Pad1|#PB_Shortcut_Control,#kb047)
AddKeyboardShortcut(0,#PB_Shortcut_Pad1|#PB_Shortcut_Shift|#PB_Shortcut_Control,#kb048)
; --
SetActiveGadget(#cv001)         ;wichtig: Tastatur funktioniert sonst nicht
; -------------------------------------------------------------
; ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
;Debug  GetKeyState_(#VK_NUMLOCK) & 1
;Debug  GetKeyState_(#VK_CAPITAL) & 1
;Debug  GetKeyState_(#VK_SCROLL) & 1
; ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
schleife:
quit=0
Repeat
  taste=0:shift=0:alt=0:ctrl=0:ric=0  

  ; hier entweder waitstring1() oder waitstring2 aktivieren und neu kompilieren	

  ; taste=waitstring1()
    taste=WAITstring2()  



  tnum=GetKeyState_(#VK_NUMLOCK) & 1
  tcap=GetKeyState_(#VK_CAPITAL) & 1
  tscr=GetKeyState_(#VK_SCROLL) & 1
  meldunten("NUM: "+Str(tnum)+"  CAPS: "+Str(tcap)+"  SCROLL: "+Str(tscr)+"  TAS: "+Str(taste))
  Delay (2000) 
  meldunten(".")
  
  
  ;auswertung(taste,shift,alt,ctrl,tnum,tcap,tscr)
  
  If taste=9999:quit=1:EndIf
  If taste=27:quit=1:EndIf
Until quit=1
Meldunten("Programmende"):Delay(1000)
End
; ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
; ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Procedure MELDUNTEN(meldu$)
Protected fa1,fa2,fa3  
fa1=RGB(  0,  0,  0)
fa2=RGB(185,015,  0)
fa3=RGB(255,255,  0)
If StartDrawing(CanvasOutput(#cv001))
 FrontColor(fa1):Box (0,704,1024, 32)
 FrontColor(fa2):Box (1,705,1022, 30)
 DrawingFont(FontID(2)):DrawingMode(1)
 DrawText(101,707,meldu$,fa1)
 DrawText(100,706,meldu$,fa3)
StopDrawing()
EndIf
EndProcedure
;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
; ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Procedure MELDULOESCH()
  Protected fa1,fa2,fa3 
  fa1=RGB(  0,  0,  0)
  fa2=RGB(200,200,200)
  StartDrawing(CanvasOutput(#cv001))
   FrontColor(fa1):Box (0,704,1024, 32)
  FrontColor(fa2):Box (1,705,1022, 30)
 StopDrawing()
 EndProcedure
; ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
; ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Procedure WAITSTRING1()
Protected quit,taste,modif,event  
quit=0:taste=0:modif=0:event=0  
Repeat
  taste=0
  Event = WaitWindowEvent()
  Select event
    Case #PB_Event_Gadget
      If EventGadget()=#cv001
        If EventType() = #PB_EventType_KeyUp       
          taste=((GetGadgetAttribute(#cv001,#PB_Canvas_Key)))  
          modif=((GetGadgetAttribute(#cv001,#PB_Canvas_Modifiers)))  
        EndIf
        modif=modif*1000  
        taste=taste+modif  
        EndIf
;         If EventType() = #PB_EventType_LeftButtonDown
;           tastex=GetGadgetAttribute(#cv001,#PB_Canvas_MouseX)
;           tastey=GetGadgetAttribute(#cv001,#PB_Canvas_MouseY)
;       EndIf 
;         If EventType() = #PB_EventType_RightButtonDown
;           tastex=GetGadgetAttribute(#cv001,#PB_Canvas_MouseX)
;           tastey=GetGadgetAttribute(#cv001,#PB_Canvas_MouseY)
;         EndIf 
    Case #PB_Event_CloseWindow
      quit=1:taste=9999
  EndSelect
If Taste>0 : quit=1 : EndIf
Until quit=1

; Meldunten("Waitstring: "+Str(taste)):Delay(1200)
ProcedureReturn taste 
EndProcedure
; ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
; ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Procedure WAITSTRING2()
Protected quit,taste,modif,event  
quit=0:taste=0:event=0  
Repeat
  taste=0
  Event = WaitWindowEvent()
  If event=#PB_Event_Menu
       Select EventMenu()
         Case #kb000
           taste=#kb000
         Case #kb001
           taste=#kb001
         Case #kb002
           taste=#kb002
         Case #kb003
           taste=#kb003
         Case #kb004
           taste=#kb004
         Case #kb005
           taste=#kb005
         Case #kb006
           taste=#kb006
         Case #kb007
           taste=#kb007
         Case #kb008
           taste=#kb008
         Case #kb009
           taste=#kb009
         Case #kb010
           taste=#kb010
         Case #kb011
           taste=#kb011
         Case #kb012
           taste=#kb012
         Case #kb013
           taste=#kb013
         Case #kb014
           taste=#kb014
         Case #kb015
           taste=#kb015
         Case #kb016
           taste=#kb016
         Case #kb017
           taste=#kb017
         Case #kb018
           taste=#kb018
         Case #kb019
           taste=#kb019
         Case #kb020
           taste=#kb020
         Case #kb021
           taste=#kb021
         Case #kb022
           taste=#kb022
         Case #kb023
           taste=#kb023
         Case #kb024
           taste=#kb024
         Case #kb025
           taste=#kb025
         Case #kb026
           taste=#kb026
         Case #kb027
           taste=#kb027
         Case #kb028
           taste=#kb028
         Case #kb029
           taste=#kb029
         Case #kb030
           taste=#kb030
         Case #kb031
           taste=#kb031
         Case #kb032
           taste=#kb032
         Case #kb033
           taste=#kb033
         Case #kb034
           taste=#kb034
         Case #kb035
           taste=#kb035
         Case #kb036
           taste=#kb036
         Case #kb037
           taste=#kb037
         Case #kb038
           taste=#kb038
         Case #kb039
           taste=#kb039
         Case #kb040
           taste=#kb040
         Case #kb041
           taste=#kb041
         Case #kb042
           taste=#kb042
         Case #kb043
           taste=#kb043
         Case #kb044
           taste=#kb044
         Case #kb045
           taste=#kb045
         Case #kb046
           taste=#kb046
         Case #kb047
           taste=#kb047
         Case #kb048
           taste=#kb048
       EndSelect
  EndIf  
  If event=#PB_Event_CloseWindow
      quit=1:taste=9999
  EndIf
If Taste>0 : quit=1 : EndIf
Until quit=1

; Meldunten("Waitsring: "+Str(taste)):Delay(1200)
ProcedureReturn taste 
EndProcedure
; ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

[Bisonte]

Ich weiss leider nicht was du da in dem riesigen Code machst... aber hier mal ein stark gekürztes Beispiel.
In diesem Fall die NumPad 2 Taste. Mit Shift, Ohne Shift mit Numlock, ohne Numlock... so wie ich es
erwarten würde....

Code: Alles auswählen

EnableExplicit

Define Event, Key
OpenWindow(0, 0, 0, 640, 480, "TestWin", #PB_Window_ScreenCentered|#PB_Window_SystemMenu)

CanvasGadget(0, 0, 0, 640, 480, #PB_Canvas_Keyboard)

If StartDrawing(CanvasOutput(0))
  DrawingMode(#PB_2DDrawing_Gradient)
  BackColor(0) : FrontColor(#Blue)
  LinearGradient(0, 0, 640, 480)
  Box(0, 0, 640, 480, 0)
  StopDrawing()
EndIf
SetActiveGadget(0)

Repeat
  Event = WaitWindowEvent()
  
  If Event = #PB_Event_Gadget
    
    If EventGadget() = 0
      
      If EventType() = #PB_EventType_KeyUp ; Ich nehme mal das Loslassen der Taste
        
        Key = GetGadgetAttribute(0, #PB_Canvas_Key)
        
        Select Key
          Case #PB_Shortcut_Down : Debug "Down" ; Die Tastatur sendet bei Numpad2 und Shift auch nur ein Down... (je nach Tastatur)
          Case #PB_Shortcut_Pad2 : Debug "NumPad 2"
        EndSelect

      EndIf
      
    EndIf
        
  EndIf
  
Until Event = #PB_Event_CloseWindow

Edit :
Nun hab ich mich mal getraut den Code anzusehen und die Aussage :

Das Problem liegt meine ich darin, dass PB nicht die genormten Scancodes der Tastatur für seine Key-Konstanten benutzt, sondern selbt gewählte Zahlen.

Ist insofern falsch, da Du eigene Werte benutzt, nicht PB

Das AddKeyboardShortcut() generiert ein MenuEvent, dass du auch später abfragst. Aber du weist der Variablen "taste", den MenuEvent()-Wert zu,
den Du selbst erstellt hast mit deinen #kb0... Konstanten.

[Diogenes]

Hallo Bisonte,

danke für Deine schnelle Antwort.
genau da liegt ja das Problem.
<cursor down> liefert down
<shift> <cursor down> liefert bei Dir auch down
<ctrl><cursor down> liefert => down muss aber liefern down + modifier,
tut er ja aber auch in meinem Beispiel.
in Deinem Beispiel werden die Modifier
<shift>; <ctrl>; <alt>; <shift ctrl>; <shift alt>; <ctrl alt>; <shift ctrl alt>
gar nicht abgefangen. Die Tastatur sendet diese Zeichen aber sehr wohl.
Siehe meine Tabelle vor dem eigentlichen Code.
Wenn Du mein Programm 'mal aufrufst wirst Du sehen, daß die Tastatur die
Tasten alle unterschiedlich behandelt.
Auch in PB lassen sich diese unterschiedlichen Codes ja abfangen, bis auf dieses
vermaledeite Numpad. Da haben -meine ich- die Entwickler von PB geschlampt und
einfach die gleiche PB-Konstante zugewiesen, anstatt der genormten Scancodes.
Die Tastatur liefert immer zurück den scancode der gedrückten Taste, d.h
für Cursor down 208 und für Numpad 2 scancode 80, sowie den jewiligen Modifier,
der durch Addition aufgeschlagen wird, das machen die PB-Konstanten ja auch.
#PB_Shortcut_Shift -> $10000
#PB_Shortcut_Control -> $20000
#PB_Shortcut_Alt -> $40000
PB liefert aber für beide tasten nur den wert 40 zurück
Und das der Code so riesig geworden ist liegt genau daran, daß ich versucht habe
diese Zeichen auszulesen. In Waitstring 1 klappt das ja auch sehr gut
mit taste=((GetGadgetAttribute(#cv001,#PB_Canvas_Key)))
modif=((GetGadgetAttribute(#cv001,#PB_Canvas_Modifiers)))
lediglich bei den Tasten des Numpads funktioniert das nicht richtig.

[ts-soft]

Ich kann es nicht mehr lesen
Scancodes sind selbstverständlich in PB integriert, aber natürlich nicht mit PB_ am Anfang sondern
mit VK... usw.
Diese sind mit entsprechenden API-Funktionen (im Callback) auszuwerten.

Ansonsten gibt es noch Codes für PB-Konstanten. Dieser ist in seinem Kontext mit den entsprechenden
Funktionen zu nutzen! AddKeyBoardShort hat nicht mit CanvasKey zu tun.

Du würfelst alles durcheinander und gibts dann PB die Schuld.

Gruß
Thomas (der noch immer nicht weiß, was Du eigentlich willst )

[Diogenes]

Hallo ts-soft,

daß ich alles durcheinanderschmeiße, kann gut sein. Ich versuche noch immer
in die Struktur von PB einzusteigen. Die Geschichte mit dem AddKeyBoardShort
habe ich aus dem Buch zu PB von Gary Willoughby S. 124 ff.
ich habe vorher versucht die Modifier auszulesen in Waitstring1, das war meine ich
ein Tip von Bisonte. Das klappt ja auch wunderbar, nur bei den Tasten des Numpads
funktioniert das nicht richtig
In diesem konkreten Beispiel geht es einfach nur darum drei verschiedene
Eingabemöglichkeiten für ein Spiel bereitzustellen.
Ich brauche eigentlich nur jeweils i,l,k,j mit und ohne shift als up,left,down right
sowie die cursor-Tasten mit und ohne shift für den gleichen Zweck
und numpad 5,3,2,1 mit und ohne shift. Hier ist aber auch zu beachten, dass
ja eventuell Numlock an oder aus ist. Die Sache mit alt und ctrl habe ich nur
zusätzlich eingebaut um die TASTaturabfrage unter PB zu verstehen.
Ich gebe auch nicht PB die Schuld; ich habe mehrfach geschrieben : "ich meine.. "
"ich glaube .. ", "ich will mich nicht zu weit aus dem Fenster lehnen" , "vielleicht bin ich
auch einfach nur zu blöd".
So wie Du es schilderst, scheint ja Letzteres zu gelten, da kann ich durchaus mit leben,
ich will ja lernen; vielleicht könntest Du mir ja einen Hinweis geben, wie ich die Tasten
ordentlich abgefangen bekomme - hilfreich wäre zum Beispiel eine Procedure, die mir
die gewünschten Codes zurückliefert, da könnte ich sicher 'ne Menge draus lernen.
Deswegen habe ich ja extra einen ausführbaren Code geschrieben, damit Ihr mir sagen
könnt -wenn Ihr wollt - niemand ist verpflichtet - wo ich wie welche Fehler gemacht habe.
Bisonte hat es ja versucht, dafür bin ich Ihm dankbar, auch wenn es in diesem Fall noch nicht
die Lösung meines Problemes war, er hat mir aber in den vorherigen Threads wirklich tolle
Tips gegeben, die mich sehr viel weiter gebracht haben.

[ts-soft]

Also, es gibt verschiedene Arten der Tastatur-Abfrage in PB. Immer seinem Zweck entsprechend.

1. AddKeyBoardShortcut - Allgemeine Tastaturberabeitung in einer GUI Anwendung.
2. CanvasGadget (sowie OpenGLGadget) - Tastaturberabeitung z. B. zum Zweck eines Editors.
3. Keyboard lib - Tastaturberabeitung mit DirectX, hauptsächlich zur Spiele-Bearbeitung.

Als erstes solltest Du Dich also entscheiden, welche Deinem Zwecke am allerehesten entspricht.
Danach kann ich Dir erstmal nicht weiterhelfen, da ich im allg. nur Anwendungen/Tools schreibe,
die dann mit, wenn überhaupt, Variante 1 auskommen.

Gruß
Thomas

[Sicro]

So wie es aussieht, möchte er nicht die verschiedenen Möglichkeiten der Tastaturabfrage mischen, sondern möchte zeigen, dass er mit beiden Varianten kein gewünschtes Ergebnis erhält. Er dachte also, wenn es mit der einen Variante nicht geht, geht es vielleicht mit der anderen Variante.

Bei cursor down ohne shift wird 40 zurückgeliefert [...]
Bei numpad 2 mit shift wird aber auch 40 zurückgeliefert [...]

Demzufolge kann er nicht genau zwischen "Cursor down" und "NumPad 2 mit Shift" unterscheiden, weil er in beiden Fällen den Wert "40" zurückgeliefert bekommt.

[Diogenes]

@Bisonte,

zu Deinem Edit.

das ich mit case 48 nur den Tastencode abfragen will ist ja auch ok,
ich will ja wissen was das Programm mir zurückliefert. Verarbeiten tue ich
das später.
In der ersten Tabelle oben, habe ich ja die Taste und die Modifier ausgelesen
und das funktioniert ja auch wirklich gut, mit Ausnahme der Tasten des Numpads,
wenn numlock eingeschaltet ist.
wenn das Programm zurückliefert taste=1040 weiss ich, daß (shift)(cursor dn)
gedrückt wurde bei taste=5075 wurde (shift ctrl k) gedrückt
bei den tasten des Numpads kommen aber fehlerhafte Ergenisse heraus
je nachdem, ob Numlock an oder aus ist. Das Problem hier liegt darin, dass speziell
Numpad 2 einen wert von 40 zurückliefert, wenn numlock an ist und (shift numpad 2)
gedrückt wurde. Aber auch (cursor dn) ohne shift liefert 40 zurück. Und genau das ist das
Problem. Bei shift springt die Spielfigur 2 Kästchen weiter, ohne shift nur eins.
Durch das Programm wird aber bei 2 Tasten der Wert 40 geliefert, einmal mit und einmal
ohne shift. Wie soll die Spielfigur also springen, nach unten ist klar, aber ein oder 2 Kästchen ??
Bei der Prozedur waitstring 2 habe ich ja alle Kombinationen vorgegeben.
Wenn ich also geliefert bekomme 110. dann weiß ich, dass ( shift k) gedrückt wurde,
da, AddKeyboardShortcut(0,#PB_Shortcut_K|#PB_Shortcut_Shift,#kb010) und die
#kb-Konstanten mit 100 anfangen zu laufen.
Bei den Tasten des Numpads werden aber keine vernünftigen Codes zurückgeliefert, obwohl
ich sie oben als addkeyboardshortcut definiert habe.

[mk-soft]

Mit Canvas geht das so. Es können aber nicht alle Kombinationen verwendet werden

Code: Alles auswählen

;-TOP

; ***************************************************************************************
;
; Comment       : 
; Author        : 
; Second Author : 
; File          : 
; Version       : 
; Create        : 
; Update        : 
; 
; Compilermode  : 
;
; ***************************************************************************************

EnableExplicit

;- Window Constants
;
Enumeration
  #Main
  ;#Dialog1
EndEnumeration

;- Menubar Constants
;
Enumeration
  #Main_Menu
EndEnumeration

;- MenuItem Constants
;
Enumeration
  #Main_MenuItem_Exit
EndEnumeration

;- Gadget Constants
;
Enumeration
  #Main_String
  #Main_Canvas
  #Main_Button_Ok
  ;#Dialog1_Button_Ok
EndEnumeration

;- StatusBar Constants
;
Enumeration
  #Main_Statusbar
EndEnumeration

;- Image Constants
;
Enumeration
  #Image1
  #Image2
EndEnumeration

;- Font Constants
;
Enumeration
  #Font1
  #Font2
EndEnumeration

;- Globale Variablen
;
Global ExitApplication

; ***************************************************************************************

Procedure Main()
  
  Protected event, style
  Protected Modifiers, Char
  
  style = #PB_Window_SystemMenu | #PB_Window_MinimizeGadget | #PB_Window_MaximizeGadget | #PB_Window_SizeGadget
  OpenWindow(#Main, #PB_Ignore, #PB_Ignore, 400, 300, "Basis", style)
  ; Menu
  CreateMenu(#Main_Menu, WindowID(#Main))
  MenuTitle("Datei")
  MenuItem(#Main_MenuItem_Exit, "Be&enden")
  ; Statusbar
  CreateStatusBar(#Main_Statusbar, WindowID(#Main))
  AddStatusBarField(100)
  AddStatusBarField(#PB_Ignore)
  StatusBarText(#Main_Statusbar, 0, "Version 1.0")
  StatusBarText(#Main_Statusbar, 1, "Hello World")
  ; Gadgets
  StringGadget(#Main_String, 10, 10, 300, 25, "Text")
  CanvasGadget(#Main_Canvas, 0, 0, 400, 200, #PB_Canvas_Keyboard)
  ;ButtonGadget(#Main_Button_Ok, 10, 45, 120, 30, "Ok")
  
  ;- Main Eventloop
  Repeat
    event = WaitWindowEvent()
    Select event
      Case #PB_Event_Menu
        Select EventMenu()
          Case #Main_MenuItem_Exit
            ExitApplication = 1
            
        EndSelect
            
      Case #PB_Event_Gadget
        Select EventGadget()
          Case #Main_Canvas
            Select EventType()
              Case #PB_EventType_KeyDown
                
              Case #PB_EventType_KeyUp
                
              Case #PB_EventType_Input
                Modifiers = GetGadgetAttribute(#Main_Canvas, #PB_Canvas_Modifiers)
                Char = GetGadgetAttribute(#Main_Canvas, #PB_Canvas_Key)
                If (Modifiers & #PB_Canvas_Shift) = #PB_Canvas_Shift
                  Debug "Shift + " + Chr(char)
                ElseIf (Modifiers & #PB_Canvas_Alt) = #PB_Canvas_Alt
                  Debug "Alt + " + Chr(char)
                ElseIf (Modifiers & #PB_Canvas_Control) = #PB_Canvas_Control
                  Debug "Ctrl + " + Chr(char)
                ElseIf Modifiers = 0
                  Debug Chr(Char)
                Else
                  Debug "Andere kombination + " + Chr(Char) 
                EndIf
                
            EndSelect
            
          Case #Main_String
            Select EventType()
              Case #PB_EventType_Change
                Debug "Change String: " + GetGadgetText(#Main_String)
              Case #PB_EventType_LostFocus
                Debug "Lostfocus String"
                
            EndSelect
           
          Case #Main_Button_Ok
            Debug "Button Ok pressed"
            
        EndSelect
        
      Case #PB_Event_SizeWindow
        Select EventWindow()
          Case #Main
            Debug "Main Window Resized"
            
        EndSelect
        
      Case #PB_Event_CloseWindow
        Select EventWindow()
          Case #Main
            ExitApplication = 1
            
        EndSelect
        
      Case #PB_Event_Repaint
        ;
      Case #PB_Event_MoveWindow
        ;
      Case #PB_Event_ActivateWindow
        ;
      Case #PB_Event_SysTray
        ;
    EndSelect
      
  Until ExitApplication = 1
  
EndProcedure : Main()

; ***************************************************************************************

[Diogenes]

@MK-Soft,

danke für Deinen Code.
Mit

Modifiers = GetGadgetAttribute(#Main_Canvas, #PB_Canvas_Modifiers)
Char = GetGadgetAttribute(#Main_Canvas, #PB_Canvas_Key)

habe ich es ja schon versucht. Das bringt ja auch gute Ergebnisse - außer bei den
Tasten des Numpads - das ist ja gerade mein Problem.