← Back to branch summary

~ubuntu-branches/ubuntu/quantal/vice/quantal

« back to all changes in this revision

Viewing changes to src/arch/os2/kbd/proc.c

  • Committer: Bazaar Package Importer
  • Author(s): Laszlo Boszormenyi (GCS)
  • Date: 2010-02-11 18:30:16 UTC
  • mfrom: (1.1.8 upstream) (9.2.2 sid)
  • Revision ID: james.westby@ubuntu.com-20100211183016-f6n8usn3tzp0u6dp
Tags: 2.2.dfsg-1
* New upstream release, C64 DTV is included so update package description
  and add it to the menu.
* Drop patch fixing build failure with gcc-4.4 , applied upstream.
* Fix some lintian problems and clean up debian/rules .

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/arch/os2/kbd/proc.c
37
37
#include "resources.h"    // resource_value_t
38
38
 
39
39
#ifdef __X128__
 
40
 
40
41
/* 40/80 column key.  */
41
42
static key_ctrl_column4080_func_t key_ctrl_column4080_func = NULL;
 
43
 
42
44
/* CAPS key.  */
43
45
static key_ctrl_caps_func_t key_ctrl_caps_func = NULL;
44
46
#endif
45
47
 
46
48
// -----------------------------------------------------------------
47
49
 
48
 
inline void kbd_set_key(const CHAR code1, const CHAR code2,
49
 
                        const USHORT release, const USHORT shift)
 
50
inline void kbd_set_key(const CHAR code1, const CHAR code2, const USHORT release, const USHORT shift)
50
51
{
51
52
    //
52
53
    // Serach for the key in the list
53
54
    //
54
55
    int nr;
55
 
    for (nr=0; nr<keyconvmap.entries; nr++)
56
 
    {
57
 
        if (keyconvmap.map[shift][nr].code==(code1 | code2<<8))
 
56
 
 
57
    for (nr = 0; nr < keyconvmap.entries; nr++) {
 
58
        if (keyconvmap.map[shift][nr].code == (code1 | code2 << 8)) {
58
59
            break;
 
60
        }
59
61
    }
60
62
 
61
63
    //
62
64
    // if the key wasn't found in the list don't do any action
63
65
    //
64
 
    if (nr==keyconvmap.entries)
65
 
    {
66
 
        if (!release)
 
66
    if (nr == keyconvmap.entries) {
 
67
        if (!release) {
67
68
            log_message(LOG_DEFAULT, "proc.c: Unknown key %d %d pressed by user.", code1, code2);
 
69
        }
68
70
        return;
69
71
    }
70
72
 
71
73
    //
72
74
    // Pass pressed and mapped key to Vice
73
75
    //
74
 
    keyboard_set_keyarr(keyconvmap.map[shift][nr].row,
75
 
                        keyconvmap.map[shift][nr].column,
76
 
                        release);
77
 
    /*
78
 
     if (!release)
79
 
     log_debug("key  %3i %3i  -%d->  %3i %3i %i",
80
 
     code1, code2, fsFlags&KC_CHAR,
81
 
     keyconvmap.map[shift][nr].row,
82
 
     keyconvmap.map[shift][nr].column,
83
 
     keyconvmap.map[shift][nr].vshift);
84
 
     */
 
76
    keyboard_set_keyarr(keyconvmap.map[shift][nr].row, keyconvmap.map[shift][nr].column, release);
85
77
 
86
78
    //
87
79
    // process virtual shift key
88
80
    //
89
 
    switch (keyconvmap.map[shift][nr].vshift)
90
 
    {
91
 
    case 0x1: // left shifted, press/release left shift
92
 
        keyboard_set_keyarr(keyconvmap.lshift_row,
93
 
                            keyconvmap.lshift_col,
94
 
                            release);
95
 
        break;
96
 
    case 0x2: // right shifted, press/release right shift
97
 
        keyboard_set_keyarr(keyconvmap.rshift_row,
98
 
                            keyconvmap.rshift_col,
99
 
                            release);
100
 
        break;
101
 
    case 0x3: // unshifted, release virtual shift keys
102
 
        keyboard_set_keyarr(keyconvmap.lshift_row,
103
 
                            keyconvmap.lshift_col,
104
 
                            0);
105
 
        keyboard_set_keyarr(keyconvmap.rshift_row,
106
 
                            keyconvmap.rshift_col,
107
 
                            0);
108
 
        break;
 
81
    switch (keyconvmap.map[shift][nr].vshift) {
 
82
        case 0x1: // left shifted, press/release left shift
 
83
            keyboard_set_keyarr(keyconvmap.lshift_row, keyconvmap.lshift_col, release);
 
84
            break;
 
85
        case 0x2: // right shifted, press/release right shift
 
86
            keyboard_set_keyarr(keyconvmap.rshift_row, keyconvmap.rshift_col, release);
 
87
            break;
 
88
        case 0x3: // unshifted, release virtual shift keys
 
89
            keyboard_set_keyarr(keyconvmap.lshift_row, keyconvmap.lshift_col, 0);
 
90
            keyboard_set_keyarr(keyconvmap.rshift_row, keyconvmap.rshift_col, 0);
 
91
            break;
109
92
    }
110
93
}
111
94
 
112
95
void kbd_proc(HWND hwnd, MPARAM mp1, MPARAM mp2)
113
96
{
114
 
    USHORT fsFlags    = SHORT1FROMMP(mp1);
115
 
    CHAR   usScancode = CHAR4FROMMP(mp1);   //fsFlags&KC_SCANCODE
116
 
    CHAR   usKeycode  = SHORT1FROMMP(mp2);  //fsFlags&KC_CHAR
117
 
    CHAR   usVK       = SHORT2FROMMP(mp2);  //fsFlags&KC_VIRTUALKEY VK_TAB/LEFT/RIGHT/UP/DOWN
118
 
    USHORT release    = !(fsFlags&KC_KEYUP);
 
97
    USHORT fsFlags = SHORT1FROMMP(mp1);
 
98
    CHAR usScancode = CHAR4FROMMP(mp1);
 
99
    CHAR usKeycode = SHORT1FROMMP(mp2);
 
100
    CHAR usVK = SHORT2FROMMP(mp2);
 
101
    USHORT release = !(fsFlags & KC_KEYUP);
119
102
 
120
103
    //
121
104
    // ----- Process virtual keys -----
122
105
    //
123
 
    if (fsFlags&KC_VIRTUALKEY)
124
 
    {
125
 
        switch (usVK)
126
 
        {
 
106
    if (fsFlags & KC_VIRTUALKEY) {
 
107
        switch (usVK) {
127
108
#ifdef __X128__
128
 
        case VK_F10: // press/release caps key
129
 
            if (key_ctrl_caps_func)
130
 
                key_ctrl_caps_func();
131
 
            return;
132
 
        case VK_F11: // press/release 40/80-key
133
 
            if (key_ctrl_column4080_func)
134
 
                key_ctrl_column4080_func();
135
 
            return;
 
109
            case VK_F10: // press/release caps key
 
110
                if (key_ctrl_caps_func) {
 
111
                    key_ctrl_caps_func();
 
112
                }
 
113
                return;
 
114
            case VK_F11: // press/release 40/80-key
 
115
                if (key_ctrl_column4080_func) {
 
116
                    key_ctrl_column4080_func();
 
117
                }
 
118
                return;
136
119
#endif
137
 
        case VK_F12:      // restore key pressed
138
 
            machine_set_restore_key(release);
139
 
            return;
140
 
        case VK_SCRLLOCK: // toggle warp mode if ScrlLock is pressed
141
 
            resources_set_int("WarpMode",
142
 
                              (int)(fsFlags&KC_TOGGLE));
143
 
            return;
144
 
        case VK_CAPSLOCK:  // turn capslock led off if capslock is pressed
145
 
            {
146
 
                /* This is not a beautiful way, but the one I know :-) */
147
 
                BYTE keyState[256];
148
 
                WinSetKeyboardStateTable(HWND_DESKTOP, keyState, FALSE);
149
 
                keyState[VK_CAPSLOCK] &= ~1;
150
 
                WinSetKeyboardStateTable(HWND_DESKTOP, keyState, TRUE);
151
 
            }
152
 
            break;
 
120
            case VK_F12:      // restore key pressed
 
121
                machine_set_restore_key(release);
 
122
                return;
 
123
            case VK_SCRLLOCK: // toggle warp mode if ScrlLock is pressed
 
124
                resources_set_int("WarpMode", (int)(fsFlags & KC_TOGGLE));
 
125
                return;
 
126
            case VK_CAPSLOCK:  // turn capslock led off if capslock is pressed
 
127
                {
 
128
                    /* This is not a beautiful way, but the one I know :-) */
 
129
                    BYTE keyState[256];
 
130
 
 
131
                    WinSetKeyboardStateTable(HWND_DESKTOP, keyState, FALSE);
 
132
                    keyState[VK_CAPSLOCK] &= ~1;
 
133
                    WinSetKeyboardStateTable(HWND_DESKTOP, keyState, TRUE);
 
134
                }
 
135
                break;
153
136
        }
154
137
    }
155
138
 
156
139
    //
157
140
    // ----- give all keypresses without Alt to Vice -----
158
141
    //
159
 
    if (!(fsFlags&KC_ALT))
160
 
    {
 
142
    if (!(fsFlags & KC_ALT)) {
161
143
        //
162
144
        // repeats are handled by vice itself
163
145
        //
164
 
        if (fsFlags&KC_PREVDOWN)
 
146
        if (fsFlags & KC_PREVDOWN) {
165
147
            return;
 
148
        }
166
149
 
167
150
        //
168
151
        // check if the key is defined as joystick action
169
152
        //
170
 
        if (joystick_handle_key((kbd_code_t)usScancode, release))
 
153
        if (joystick_handle_key((kbd_code_t)usScancode, release)) {
171
154
            return;
 
155
        }
172
156
 
173
157
        //
174
158
        // this is a good canidate to be passed to vice
175
159
        //
176
 
        kbd_set_key(keyconvmap.symbolic?usKeycode:usScancode,
177
 
                    keyconvmap.symbolic?usVK:0,
178
 
                    release, fsFlags&KC_SHIFT?1:0);
 
160
        kbd_set_key(keyconvmap.symbolic ? usKeycode : usScancode, keyconvmap.symbolic ? usVK : 0, release, fsFlags & KC_SHIFT ? 1 : 0);
179
161
        return;
180
162
    }
181
163
 
182
164
    //
183
165
    // if key is released: return
184
166
    //
185
 
    if (release)
 
167
    if (release) {
186
168
        return;
187
 
 
188
 
    // Process all keys whichs are pressed together with Alt.
189
 
#if 0
190
 
    if (usScancode==K_V && key_ctrl_column4080_func)
191
 
        key_ctrl_column4080_func(); // press/release 40/80-key
192
 
    if (usScancode==K_V && key_ctrl_caps_func)
193
 
        key_ctrl_caps_func(); // press/release caps key
194
 
#endif
 
169
    }
195
170
}
196
171
 
197
172
// ------------------------------------------------------------------
207
182
    key_ctrl_caps_func = func;
208
183
}
209
184
#endif
210