Du bist nicht angemeldet.

Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!

ButtonHandler für Tastatur- und Maustasten-Verhalten

Werbeanzeige

Snorky

Frischling

  • »Snorky« ist der Autor dieses Themas

Beiträge: 34

Wohnort: Berlin

Beruf: Student

  • Private Nachricht senden

1

20.08.2003, 00:37

ButtonHandler für Tastatur- und Maustasten-Verhalten

Hallo,
es ist wieder soweit ;p

Diesmal hab ich die Engine um einen ButtonHandler erweitert. Etwas ähnliches habe ich auch bei Galactica gesehen, nur wollte ich das als Klasse in die Engine integrieren. Demnach heißt die Klasse tbButtonHandler, bekommt das Bool-Array, das man von tbDirectInput::GetState() erhält und ermöglicht damit zu dem KeyPressed() auch einen KeyReleased()-Aufruf. Denn bis jetzt konnte man nur abfragen, ob eine Taste gedrückt ist (soweit ich weiß). Nun kann man auch abfragen, ob eine Taste losgelassen wurde, oder ob sie gerade im Moment des Frames gedrückt wird.
Ich finde so etwas ist vorallem für ein Menü recht wichtig, denn wer kann garantieren, dass die Taste im nächsten Untermenü nicht mehr gedrückt ist? Das würde z.B. dazu führen, dass man mit einem ESC-druck durch 5 Menüs rasselt und womöglich aus dem Spiel fliegt. :rolleyes:

Nun gut, wer also Interesse an diese kleine Engine-Erweiterung hat befolge folgende Bastelanleitung:
Man copy diese Header und paste sie in tbButtonHandler.h

Quellcode

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

/********************************************************************
     _________        __    _____
    /\___  ___\      /\_\  /\  __\
    \/__/\ \__/ _  __\/_/_ \ \ \_\\   ____    _____      __
        \ \ \  /\`´__\ /\ \ \ \  __\ /\ __\_ /\  __\   /´__`\
         \ \ \ \ \ \/  \ \ \ \ \ \_\\\ \\_\ \\ \____\ /\  __/
          \ \_\ \ \_\   \ \_\ \ \____\\ \___\ \ \____\\ \____\
           \/_/  \/_/    \/_/  \/____/ \/__/   \/____/ \/____/

    tbButtonHandler.h
    =================
    Diese Datei ist Teil der TriBase-Engine.

    Zweck:
    Umgang Tasten und Knöpfen

    Autor:
    Snorky
    [20.8.2003]

********************************************************************/

#ifndef __TBBUTTONHANDLER__
#define __TBBUTTONHANDLER__


// Klasse für das Keyboard-Verhalten
class TRIBASE_API tbButtonHandler
{
private:
    // Variablen
    BOOL* m_pbButtonsCurrent;               // aktueller Knöpfe Status
    BOOL* m_pbButtonsPast;                  // alter Knöpfe Status
    DWORD m_dwNumButtons;                   // Anzahl der Knöpfe

public:
    // Konstruktor und Destruktor
    tbButtonHandler();
    ~tbButtonHandler();
    
    // Methoden
    tbResult Exit();                        // alles freigeben und zurücksetzen
    tbResult Init(DWORD dwButtons);         // festlegen wieviele Knöpfe es geben soll
    tbResult GetState(BOOL* pbKeys);        // aktualisieren der Buttons

    BOOL AnyKeyPressed();                   // ist irgendeine Taste gedrückt?
    BOOL AnyKeyGetPressed();                // wird irgendeine Taste gedrückt?
    BOOL AnyKeyReleased();                  // wird irgendeine Taste losgelassen?

    // Inline-Methoden
    // ist die Taste gedrückt?
    BOOL KeyPressed(DWORD dwKey)    {return (m_pbButtonsCurrent[dwKey]);}
    // wird die Taste gerade gedrückt?
    BOOL KeyGetPressed(DWORD dwKey) {return (!(m_pbButtonsPast[dwKey]) && (m_pbButtonsCurrent[dwKey]));}
    // wird die Taste gerade losgelassen?
    BOOL KeyReleased(DWORD dwKey)   {return ((m_pbButtonsPast[dwKey]) && !(m_pbButtonsCurrent[dwKey]));}

    BOOL* GetButtonsCurrent()   {return m_pbButtonsCurrent;}
    BOOL* GetButtonsPast()      {return m_pbButtonsPast;}
    DWORD GetNumButtons()       {return m_dwNumButtons;}
};

// ******************************************************************

#endif  __TBBUTTONHANDLER__

Nun tue man das Gleiche mit der tbButtonHandler.cpp

Quellcode

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171

/********************************************************************
     _________        __    _____
    /\___  ___\      /\_\  /\  __\
    \/__/\ \__/ _  __\/_/_ \ \ \_\\   ____    _____      __
        \ \ \  /\`´__\ /\ \ \ \  __\ /\ __\_ /\  __\   /´__`\
         \ \ \ \ \ \/  \ \ \ \ \ \_\\\ \\_\ \\ \____\ /\  __/
          \ \_\ \ \_\   \ \_\ \ \____\\ \___\ \ \____\\ \____\
           \/_/  \/_/    \/_/  \/____/ \/__/   \/____/ \/____/

    tbButtonHandler.cpp
    ===================
    Diese Datei ist Teil der TriBase-Engine.

    Zweck:
    Umgang Tasten und Knöpfen

    Autor:
    Snorky
    [20.8.2003]

********************************************************************/

#include <TriBase.h>

// ******************************************************************
// Konsturktor
tbButtonHandler::tbButtonHandler()
{
    // Alles zurücksetzen
    ZeroMemory(this, sizeof(tbButtonHandler));
}

// ******************************************************************
// Destruktor
tbButtonHandler::~tbButtonHandler()
{
    Exit();
}

// ******************************************************************
// alles freigeben und zurücksetzen
tbResult tbButtonHandler::Exit()
{
    // Arrays freigeben
    TB_SAFE_DELETE_ARRAY(m_pbButtonsCurrent);
    TB_SAFE_DELETE_ARRAY(m_pbButtonsPast);

    // Alles zurücksetzen
    ZeroMemory(this, sizeof(tbButtonHandler));

    return TB_OK;
}

// ******************************************************************
// festlegen wieviele Knöpfe es geben soll
tbResult tbButtonHandler::Init(DWORD dwButtons)
{
    // sicherheitshalber alles vorher freigeben
    Exit();

    // Knopfanzahl setzen
    m_dwNumButtons = dwButtons;

    // Speicher für Knöpfe belegen
    m_pbButtonsCurrent = new BOOL [m_dwNumButtons];
    if(m_pbButtonsCurrent == NULL)
    {
        // Fehler!
        TB_ERROR_OUT_OF_MEMORY(TB_ERROR);
    }

    m_pbButtonsPast = new BOOL [m_dwNumButtons];
    if(m_pbButtonsPast == NULL)
    {
        // Fehler!
        TB_ERROR_OUT_OF_MEMORY(TB_ERROR);
    }

    // Tasten mit FALSE vorbelegen
    ZeroMemory((void*)m_pbButtonsCurrent, m_dwNumButtons * sizeof(BOOL));
    ZeroMemory((void*)m_pbButtonsPast, m_dwNumButtons * sizeof(BOOL));

    return TB_OK;
}

// ******************************************************************
// aktualisieren der Buttons
tbResult tbButtonHandler::GetState(BOOL* pbKeys)
{
    // aktuellen Stand zum alten machen
    memcpy(m_pbButtonsPast, m_pbButtonsCurrent, m_dwNumButtons*sizeof(BOOL));

    // aktuellen Stand durch neuen ersetzen
    memcpy(m_pbButtonsCurrent, pbKeys, m_dwNumButtons*sizeof(BOOL));

    return TB_OK;
}

// ******************************************************************
// ist irgendeine Taste gedrückt?
BOOL tbButtonHandler::AnyKeyPressed()
{
    DWORD dw;

    // Alle Tastaturtasten durchgehen
    for(dw = 0; dw <= 107; dw++)
    {
        if(m_pbButtonsCurrent[dw])
            return TRUE;
    }

    // Maustasten auch checken
    for(dw = 114; dw <= 121; dw++)
    {
        if(m_pbButtonsCurrent[dw])
            return TRUE;
    }

    // nichts gefunden
    return FALSE;
}

// ******************************************************************
// wird irgendeine Taste gedrückt?
BOOL tbButtonHandler::AnyKeyGetPressed()
{
    DWORD dw;

    // Alle Tastaturtasten durchgehen
    for(dw = 0; dw <= 107; dw++)
    {
        if(!(m_pbButtonsPast[dw]) && m_pbButtonsCurrent[dw])
            return TRUE;
    }

    // Maustasten auch checken
    for(dw = 114; dw <= 121; dw++)
    {
        if(!(m_pbButtonsPast[dw]) && m_pbButtonsCurrent[dw])
            return TRUE;
    }

    // nichts gefunden
    return FALSE;
}

// ******************************************************************
// wird irgendeine Taste losgelassen?
BOOL tbButtonHandler::AnyKeyReleased()
{
    DWORD dw;

    // Alle Tastaturtasten durchgehen
    for(dw = 0; dw <= 107; dw++)
    {
        if(m_pbButtonsPast[dw] && !(m_pbButtonsCurrent[dw]))
            return TRUE;
    }

    // Maustasten auch checken
    for(dw = 114; dw <= 121; dw++)
    {
        if(m_pbButtonsPast[dw] && !(m_pbButtonsCurrent[dw]))
            return TRUE;
    }

    // nichts gefunden
    return FALSE;
}

// ******************************************************************

Zum Schluß füge noch den Include in die TriBase.h ein und es kann folgendermaßen verwendet werden:

Quellcode

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// Variablendefinition
float*      g_pfButtons = NULL;     // Analoges Verhalten der Knöpfe
BOOL*       g_pbButtons = NULL;     // Digitales Verhalten der Knöpfe
tbButtonHandler*    g_pButtons = NULL;      // Inputverhalten der Knöpfe

// Nach tbDirectInput::Init()
// Speicher für die Knöpfe reservieren
g_pfButtons = new float[tbDirectInput::GetNumButtons()];
g_pbButtons = new BOOL[tbDirectInput::GetNumButtons()];
g_pButtons = new tbButtonHandler;
g_pButtons->Init(tbDirectInput::GetNumButtons());

// In der Move-Methode
// Eingabegeräte abfragen
tbDirectInput::GetState(g_pfButtons, g_pbButtons);
g_pButtons->GetState(g_pbButtons);

// Und der eigentlich Sinn des Ganzen
// An gegebener Stelle z.B. das Programm beenden,
// wenn die ESC-Taste losgelassen wird. Nicht vorher!
if(g_pButtons->KeyReleased(TB_KEY_ESCAPE)) PostQuitMessage(0);

// Speicher natürlich an der richtigen Stelle wieder freigeben
TB_SAFE_DELETE(g_pButtons);
TB_SAFE_DELETE_ARRAY(g_pfButtons);
TB_SAFE_DELETE_ARRAY(g_pbButtons);


Das wäre eigentlich auch schon alles. Für Titelbilder würde sich auch die AnyKeyReleased() hervorragend anbieten, aber probiert selber.
Viel Spaß :)

David Scherfgen

Administrator

Beiträge: 10 382

Wohnort: Hildesheim

Beruf: Wissenschaftlicher Mitarbeiter

  • Private Nachricht senden

2

20.08.2003, 10:53

Klasse! :)
Das kann ich praktisch 1:1 übernehmen, da Du den Stil sehr schön beibehältst! Weiter so! :)
Übrigens: es gibt auch tbDirectInput::GetPressedButton! Das liefert Dir auch den ersten gedrückten Knopf - oder gar keinen. Dann ist AnyButtonPressed eigentlich überflüssig.
David Scherfgens Website | Konzentrationstest Polizei

David Scherfgen

Administrator

Beiträge: 10 382

Wohnort: Hildesheim

Beruf: Wissenschaftlicher Mitarbeiter

  • Private Nachricht senden

3

20.08.2003, 11:33

Man könnte auch noch eine Rückruffunktion angeben, für jeden Knopf. Dieser Rückruffunktion wird dann nochmal die ID des Knopfes übergeben und ob er gerade gedrückt oder losgelassen wurde.
David Scherfgens Website | Konzentrationstest Polizei

Snorky

Frischling

  • »Snorky« ist der Autor dieses Themas

Beiträge: 34

Wohnort: Berlin

Beruf: Student

  • Private Nachricht senden

4

21.08.2003, 14:16

Erweiterung

Gesagt, getan! ;D
Hiermit ist die ButtonHandlerKlasse um eine Callbackfunktion für jeden Knopf reicher.
Die Methode AnyKeyPressed mag zwar doppelt sein, ich hab sie aber vollständigkeitshalber mit eingeführt. Dann kann man die wahren DirectInput-Buttons verstecken und nur noch den ButtonHandler verwenden. Dann braucht man nicht immer hin und her zu springen.

Ok, auf zur Erweiterung!
Damit ich nichts vergesse und auch keine Missverständnisse entstehen können gibts hier die beiden Dateien noch mal komplett. Ist ja nicht viel und David kann wieder alles 1:1 kopieren ;)
tbButtonHandler.h

Quellcode

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

/********************************************************************
     _________        __    _____
    /\___  ___\      /\_\  /\  __\
    \/__/\ \__/ _  __\/_/_ \ \ \_\\   ____    _____      __
        \ \ \  /\`´__\ /\ \ \ \  __\ /\ __\_ /\  __\   /´__`\
         \ \ \ \ \ \/  \ \ \ \ \ \_\\\ \\_\ \\ \____\ /\  __/
          \ \_\ \ \_\   \ \_\ \ \____\\ \___\ \ \____\\ \____\
           \/_/  \/_/    \/_/  \/____/ \/__/   \/____/ \/____/

    tbButtonHandler.h
    =================
    Diese Datei ist Teil der TriBase-Engine.

    Zweck:
    Umgang Tasten und Knöpfen

    Autor:
    Snorky
    [21.8.2003]

********************************************************************/

#ifndef __TBBUTTONHANDLER__
#define __TBBUTTONHANDLER__


// ******************************************************************
// Statusflags für die Rückruffunktionen
#define TB_BH_NOTPRESSED    (0)
#define TB_BH_PRESSED       (1)
#define TB_BH_GETPRESSED    (2)
#define TB_BH_RELEASED      (4)

// ******************************************************************
// Klasse für das Keyboard-Verhalten
class TRIBASE_API tbButtonHandler
{
private:
    // Variablen
    BOOL* m_pbButtonsCurrent;               // aktueller Knöpfe Status
    BOOL* m_pbButtonsPast;                  // alter Knöpfe Status
    DWORD m_dwNumButtons;                   // Anzahl der Knöpfe
    tbResult (**m_pCallback)(DWORD dwKey, DWORD dwFlags);   // Array von Rückruffunktionen

public:
    // Konstruktor und Destruktor
    tbButtonHandler();
    ~tbButtonHandler();
    
    // Methoden
    tbResult Exit();                        // alles freigeben und zurücksetzen
    tbResult Init(DWORD dwButtons);         // festlegen wieviele Knöpfe es geben soll
    tbResult GetState(BOOL* pbKeys);        // aktualisieren der Buttons

    BOOL AnyKeyPressed();                   // ist irgendeine Taste gedrückt?
    BOOL AnyKeyGetPressed();                // wird irgendeine Taste gedrückt?
    BOOL AnyKeyReleased();                  // wird irgendeine Taste losgelassen?

    tbResult SetCallback(DWORD dwKey, tbResult (*pFunc)(DWORD, DWORD)); // Setzen einer Rückruffunktion
    tbResult Process();                     // Alle Rückruffunktionen ausführen

    // Inline-Methoden
    // ist die Taste gedrückt?
    BOOL KeyPressed(DWORD dwKey)    {return (m_pbButtonsCurrent[dwKey]);}
    // wird die Taste gerade gedrückt?
    BOOL KeyGetPressed(DWORD dwKey) {return (!(m_pbButtonsPast[dwKey]) && (m_pbButtonsCurrent[dwKey]));}
    // wird die Taste gerade losgelassen?
    BOOL KeyReleased(DWORD dwKey)   {return ((m_pbButtonsPast[dwKey]) && !(m_pbButtonsCurrent[dwKey]));}

    BOOL* GetButtonsCurrent()   {return m_pbButtonsCurrent;}
    BOOL* GetButtonsPast()      {return m_pbButtonsPast;}
    DWORD GetNumButtons()       {return m_dwNumButtons;}

};

// ******************************************************************

#endif  __TBBUTTONHANDLER__


tbButtonHandler.cpp

Quellcode

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223

/********************************************************************
     _________        __    _____
    /\___  ___\      /\_\  /\  __\
    \/__/\ \__/ _  __\/_/_ \ \ \_\\   ____    _____      __
        \ \ \  /\`´__\ /\ \ \ \  __\ /\ __\_ /\  __\   /´__`\
         \ \ \ \ \ \/  \ \ \ \ \ \_\\\ \\_\ \\ \____\ /\  __/
          \ \_\ \ \_\   \ \_\ \ \____\\ \___\ \ \____\\ \____\
           \/_/  \/_/    \/_/  \/____/ \/__/   \/____/ \/____/

    tbButtonHandler.cpp
    ===================
    Diese Datei ist Teil der TriBase-Engine.

    Zweck:
    Umgang Tasten und Knöpfen

    Autor:
    Snorky
    [21.8.2003]

********************************************************************/

#include <TriBase.h>

// ******************************************************************
// Konsturktor
tbButtonHandler::tbButtonHandler()
{
    // Alles zurücksetzen
    ZeroMemory(this, sizeof(tbButtonHandler));
}

// ******************************************************************
// Destruktor
tbButtonHandler::~tbButtonHandler()
{
    Exit();
}

// ******************************************************************
// alles freigeben und zurücksetzen
tbResult tbButtonHandler::Exit()
{
    // Arrays freigeben
    TB_SAFE_DELETE_ARRAY(m_pbButtonsCurrent);
    TB_SAFE_DELETE_ARRAY(m_pbButtonsPast);
    TB_SAFE_DELETE_ARRAY(m_pCallback);

    // Alles zurücksetzen
    ZeroMemory(this, sizeof(tbButtonHandler));

    return TB_OK;
}

// ******************************************************************
// festlegen wieviele Knöpfe es geben soll
tbResult tbButtonHandler::Init(DWORD dwButtons)
{
    // sicherheitshalber alles vorher freigeben
    Exit();

    // Knopfanzahl setzen
    m_dwNumButtons = dwButtons;

    // Speicher für aktuelle Knöpfe belegen
    m_pbButtonsCurrent = new BOOL [m_dwNumButtons];
    if(m_pbButtonsCurrent == NULL)
    {
        // Fehler!
        TB_ERROR_OUT_OF_MEMORY(TB_ERROR);
    }

    // Speicher für vergangene Knöpfe belegen
    m_pbButtonsPast = new BOOL [m_dwNumButtons];
    if(m_pbButtonsPast == NULL)
    {
        // Fehler!
        TB_ERROR_OUT_OF_MEMORY(TB_ERROR);
    }

    // Speicher für Rückruffunktionen der Knöpfe belegen
    m_pCallback = new (tbResult (*[m_dwNumButtons])(DWORD, DWORD));
    if(m_pCallback == NULL)
    {
        // Fehler!
        TB_ERROR_OUT_OF_MEMORY(TB_ERROR);
    }

    // Tasten mit FALSE vorbelegen
    ZeroMemory((void*)m_pbButtonsCurrent, m_dwNumButtons * sizeof(BOOL));
    ZeroMemory((void*)m_pbButtonsPast, m_dwNumButtons * sizeof(BOOL));
    ZeroMemory((void*)m_pCallback, m_dwNumButtons * sizeof(tbResult (*)(DWORD, DWORD)));

    return TB_OK;
}

// ******************************************************************
// aktualisieren der Buttons
tbResult tbButtonHandler::GetState(BOOL* pbKeys)
{
    // aktuellen Stand zum alten machen
    memcpy(m_pbButtonsPast, m_pbButtonsCurrent, m_dwNumButtons*sizeof(BOOL));

    // aktuellen Stand durch neuen ersetzen
    memcpy(m_pbButtonsCurrent, pbKeys, m_dwNumButtons*sizeof(BOOL));

    return TB_OK;
}

// ******************************************************************
// ist irgendeine Taste gedrückt?
BOOL tbButtonHandler::AnyKeyPressed()
{
    DWORD dw;

    // Alle Tastaturtasten durchgehen
    for(dw = 0; dw <= 107; dw++)
    {
        if(m_pbButtonsCurrent[dw])
            return TRUE;
    }

    // Maustasten auch checken
    for(dw = 114; dw <= 121; dw++)
    {
        if(m_pbButtonsCurrent[dw])
            return TRUE;
    }

    // nichts gefunden
    return FALSE;
}

// ******************************************************************
// wird irgendeine Taste gedrückt?
BOOL tbButtonHandler::AnyKeyGetPressed()
{
    DWORD dw;

    // Alle Tastaturtasten durchgehen
    for(dw = 0; dw <= 107; dw++)
    {
        if(!(m_pbButtonsPast[dw]) && m_pbButtonsCurrent[dw])
            return TRUE;
    }

    // Maustasten auch checken
    for(dw = 114; dw <= 121; dw++)
    {
        if(!(m_pbButtonsPast[dw]) && m_pbButtonsCurrent[dw])
            return TRUE;
    }

    // nichts gefunden
    return FALSE;
}

// ******************************************************************
// wird irgendeine Taste losgelassen?
BOOL tbButtonHandler::AnyKeyReleased()
{
    DWORD dw;

    // Alle Tastaturtasten durchgehen
    for(dw = 0; dw <= 107; dw++)
    {
        if(m_pbButtonsPast[dw] && !(m_pbButtonsCurrent[dw]))
            return TRUE;
    }

    // Maustasten auch checken
    for(dw = 114; dw <= 121; dw++)
    {
        if(m_pbButtonsPast[dw] && !(m_pbButtonsCurrent[dw]))
            return TRUE;
    }

    // nichts gefunden
    return FALSE;
}

// ******************************************************************
// Setzen einer Rückruffunktion
tbResult tbButtonHandler::SetCallback(DWORD dwKey, tbResult (*pFunc)(DWORD, DWORD))
{
    if(dwKey < 0 || dwKey >= m_dwNumButtons) return TB_ERROR;

    m_pCallback[dwKey] = pFunc;

    return TB_OK;
}

// ******************************************************************
// Alle Rückruffunktionen ausführen
tbResult tbButtonHandler::Process()
{
    tbResult r;
    DWORD dwFlags;

    // Alle Knöpfe durchgehen
    for(DWORD dw = 0; dw < m_dwNumButtons; dw++)
    {
        // Hat der Knopf eine Rückruffunktion?
        if(m_pCallback[dw] != NULL)
        {
            // Flags setzen
            dwFlags = TB_BH_NOTPRESSED;
            if(KeyPressed(dw)) dwFlags |= TB_BH_PRESSED;
            if(KeyGetPressed(dw)) dwFlags |= TB_BH_GETPRESSED;
            if(KeyReleased(dw)) dwFlags |= TB_BH_RELEASED;
            
            // Rückruffunktion ausführen
            r = m_pCallback[dw](dw, dwFlags);

            // Auf Fehler prüfen
            if(r != TB_OK) TB_ERROR("Fehler bei einer ButtonHandler-Rückruffunktion!",TB_ERROR);
        }
    }

    return TB_OK;
}

// ******************************************************************


Wie zum bisherigen gebrauch kommt jetzt noch die Process(), die in jedem Frame nach GetState() aufgerufen werden muss. Vorausgesetzt man möchte die Rückruffunktionen der Knöpfe auch aufrufen lassen, denn das wird dort gemacht.
Vorher, sprich in einer Init(), muss diese Rückruffunktion auch einem Knopf zugewiesen werden. Das geschieht mit SetCallback(). Der erste Parameter ist der Button, dem die Funktion im zweiten Parameter zugewiesen werden soll. Gibt man statt einer Funktion NULL an, so wird die Rückruffunktion auch wieder vom Button gelöscht.
Das wäre eigentlich auch schon alles zu den Neuerungen.
:-D

David Scherfgen

Administrator

Beiträge: 10 382

Wohnort: Hildesheim

Beruf: Wissenschaftlicher Mitarbeiter

  • Private Nachricht senden

5

21.08.2003, 15:05

Gut gemacht, genauso hatte ich mir das vorgestellt :)
David Scherfgens Website | Konzentrationstest Polizei

Werbeanzeige