archive/padkey_linux
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add Control and Alt

Browse Source
This commit is contained in:
Aki Goto
2013-03-31 21:52:09 +09:00
parent bfbd521f4a
commit 04d2993fc2
8 changed files with 173 additions and 81 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
Makefile
View File

@@ -1,3 +1,6 @@
# Released into the public domain
# by Aki Goto <tyatsumi@gmail.com>
all: padkey
clean:

31
gamepad.c
View File

@@ -1,3 +1,8 @@
/*
* Released into the public domain
* by Aki Goto <tyatsumi@gmail.com>
*/
#include <stdlib.h>
#include "gamepad.h"
@@ -115,10 +120,28 @@ void Gamepad_initialize(struct Gamepad *this)
this->buttons[ButtonId_X].shift = &this->buttons[ButtonId_DOWN];
this->buttons[ButtonId_Y].shift = &this->buttons[ButtonId_DOWN];
Button_setDevice(&this->buttons[ButtonId_UP], ButtonType_NEGATIVE_AXIS, 1);
Button_setDevice(&this->buttons[ButtonId_DOWN], ButtonType_POSITIVE_AXIS, 1);
Button_setDevice(&this->buttons[ButtonId_LEFT], ButtonType_NEGATIVE_AXIS, 0);
Button_setDevice(&this->buttons[ButtonId_RIGHT], ButtonType_POSITIVE_AXIS, 0);
this->buttons[ButtonId_UP].control = &this->buttons[ButtonId_Y];
this->buttons[ButtonId_DOWN].control = &this->buttons[ButtonId_Y];
this->buttons[ButtonId_LEFT].control = &this->buttons[ButtonId_Y];
this->buttons[ButtonId_RIGHT].control = &this->buttons[ButtonId_Y];
this->buttons[ButtonId_A].control = &this->buttons[ButtonId_LEFT];
this->buttons[ButtonId_B].control = &this->buttons[ButtonId_LEFT];
this->buttons[ButtonId_X].control = &this->buttons[ButtonId_LEFT];
this->buttons[ButtonId_Y].control = &this->buttons[ButtonId_LEFT];
this->buttons[ButtonId_UP].alt = &this->buttons[ButtonId_A];
this->buttons[ButtonId_DOWN].alt = &this->buttons[ButtonId_A];
this->buttons[ButtonId_LEFT].alt = &this->buttons[ButtonId_A];
this->buttons[ButtonId_RIGHT].alt = &this->buttons[ButtonId_A];
this->buttons[ButtonId_A].alt = &this->buttons[ButtonId_RIGHT];
this->buttons[ButtonId_B].alt = &this->buttons[ButtonId_RIGHT];
this->buttons[ButtonId_X].alt = &this->buttons[ButtonId_RIGHT];
this->buttons[ButtonId_Y].alt = &this->buttons[ButtonId_RIGHT];
Button_setDevice(&this->buttons[ButtonId_UP], ButtonType_NEGATIVE_AXIS, 5);
Button_setDevice(&this->buttons[ButtonId_DOWN], ButtonType_POSITIVE_AXIS, 5);
Button_setDevice(&this->buttons[ButtonId_LEFT], ButtonType_NEGATIVE_AXIS, 4);
Button_setDevice(&this->buttons[ButtonId_RIGHT], ButtonType_POSITIVE_AXIS, 4);
Button_setDevice(&this->buttons[ButtonId_A], ButtonType_BUTTON, 0);
Button_setDevice(&this->buttons[ButtonId_B], ButtonType_BUTTON, 1);
Button_setDevice(&this->buttons[ButtonId_X], ButtonType_BUTTON, 2);

7
gamepad.h
View File

@@ -1,3 +1,8 @@
/*
* Released into the public domain
* by Aki Goto <tyatsumi@gmail.com>
*/
#ifndef GAMEPAD_H
#define GAMEPAD_H
@@ -29,6 +34,8 @@ struct Button {
int type;
int number;
struct Button *shift;
struct Button *control;
struct Button *alt;
int prev;
int current;
};

148
keymap.c
View File

@@ -1,98 +1,112 @@
/*
* Released into the public domain
* by Aki Goto <tyatsumi@gmail.com>
*/
#include <X11/keysym.h>
#include "keymap.h"
#define UP ButtonId_UP
#define DOWN ButtonId_DOWN
#define LEFT ButtonId_LEFT
#define RIGHT ButtonId_RIGHT
#define A ButtonId_A
#define B ButtonId_B
#define X ButtonId_X
#define Y ButtonId_Y
static void set(struct Keymap *this, int first, int second, int keyCode) {
int index;
index = first * 8 + second;
this->keyCode[index].keyCode = keyCode;
this->keyCode[index] = keyCode;
}
void Keymap_initialize(struct Keymap *this)
{
set(this, ButtonId_UP, ButtonId_UP, XK_Escape);
set(this, ButtonId_UP, ButtonId_DOWN, XK_grave);
set(this, ButtonId_UP, ButtonId_LEFT, 0);
set(this, ButtonId_UP, ButtonId_RIGHT, 0);
set(this, UP, UP, XK_Escape);
set(this, UP, DOWN, XK_grave);
set(this, UP, LEFT, 0);
set(this, UP, RIGHT, 0);
set(this, ButtonId_DOWN, ButtonId_UP, 0);
set(this, ButtonId_DOWN, ButtonId_DOWN, XK_space);
set(this, ButtonId_DOWN, ButtonId_LEFT, 0);
set(this, ButtonId_DOWN, ButtonId_RIGHT, 0);
set(this, DOWN, UP, 0);
set(this, DOWN, DOWN, XK_space);
set(this, DOWN, LEFT, 0);
set(this, DOWN, RIGHT, 0);
set(this, ButtonId_LEFT, ButtonId_UP, 0);
set(this, ButtonId_LEFT, ButtonId_DOWN, 0);
set(this, ButtonId_LEFT, ButtonId_LEFT, XK_Tab);
set(this, ButtonId_LEFT, ButtonId_RIGHT, 0);
set(this, LEFT, UP, 0);
set(this, LEFT, DOWN, 0);
set(this, LEFT, LEFT, XK_Tab);
set(this, LEFT, RIGHT, 0);
set(this, ButtonId_B, ButtonId_A, XK_minus);
set(this, ButtonId_B, ButtonId_B, XK_BackSpace);
set(this, ButtonId_B, ButtonId_X, XK_equal);
set(this, ButtonId_B, ButtonId_Y, XK_apostrophe);
set(this, B, A, XK_minus);
set(this, B, B, XK_BackSpace);
set(this, B, X, XK_equal);
set(this, B, Y, XK_apostrophe);
set(this, ButtonId_X, ButtonId_A, 0);
set(this, ButtonId_X, ButtonId_B, 0);
set(this, ButtonId_X, ButtonId_X, XK_space);
set(this, ButtonId_X, ButtonId_Y, 0);
set(this, X, A, 0);
set(this, X, B, 0);
set(this, X, X, XK_space);
set(this, X, Y, 0);
set(this, ButtonId_Y, ButtonId_A, XK_backslash);
set(this, ButtonId_Y, ButtonId_B, XK_bracketleft);
set(this, ButtonId_Y, ButtonId_X, XK_bracketright);
set(this, ButtonId_Y, ButtonId_Y, XK_Return);
set(this, Y, A, XK_backslash);
set(this, Y, B, XK_bracketleft);
set(this, Y, X, XK_bracketright);
set(this, Y, Y, XK_Return);
set(this, ButtonId_LEFT, ButtonId_Y, XK_1);
set(this, ButtonId_DOWN, ButtonId_Y, XK_2);
set(this, ButtonId_UP, ButtonId_Y, XK_3);
set(this, ButtonId_RIGHT, ButtonId_Y, XK_4);
set(this, ButtonId_RIGHT, ButtonId_LEFT, XK_5);
set(this, LEFT, Y, XK_1);
set(this, DOWN, Y, XK_2);
set(this, UP, Y, XK_3);
set(this, RIGHT, Y, XK_4);
set(this, RIGHT, LEFT, XK_5);
set(this, ButtonId_A, ButtonId_Y, XK_6);
set(this, ButtonId_A, ButtonId_LEFT, XK_7);
set(this, ButtonId_B, ButtonId_LEFT, XK_8);
set(this, ButtonId_X, ButtonId_LEFT, XK_9);
set(this, ButtonId_Y, ButtonId_LEFT, XK_0);
set(this, A, Y, XK_6);
set(this, A, LEFT, XK_7);
set(this, B, LEFT, XK_8);
set(this, X, LEFT, XK_9);
set(this, Y, LEFT, XK_0);
set(this, ButtonId_LEFT, ButtonId_B, XK_q);
set(this, ButtonId_DOWN, ButtonId_B, XK_w);
set(this, ButtonId_UP, ButtonId_B, XK_e);
set(this, ButtonId_RIGHT, ButtonId_B, XK_r);
set(this, ButtonId_RIGHT, ButtonId_UP, XK_t);
set(this, LEFT, B, XK_q);
set(this, DOWN, B, XK_w);
set(this, UP, B, XK_e);
set(this, RIGHT, B, XK_r);
set(this, RIGHT, UP, XK_t);
set(this, ButtonId_A, ButtonId_B, XK_y);
set(this, ButtonId_A, ButtonId_UP, XK_u);
set(this, ButtonId_B, ButtonId_UP, XK_i);
set(this, ButtonId_X, ButtonId_UP, XK_o);
set(this, ButtonId_Y, ButtonId_UP, XK_p);
set(this, A, B, XK_y);
set(this, A, UP, XK_u);
set(this, B, UP, XK_i);
set(this, X, UP, XK_o);
set(this, Y, UP, XK_p);
set(this, ButtonId_LEFT, ButtonId_A, XK_a);
set(this, ButtonId_DOWN, ButtonId_A, XK_s);
set(this, ButtonId_UP, ButtonId_A, XK_d);
set(this, ButtonId_RIGHT, ButtonId_A, XK_f);
set(this, ButtonId_RIGHT, ButtonId_RIGHT, XK_g);
set(this, LEFT, A, XK_a);
set(this, DOWN, A, XK_s);
set(this, UP, A, XK_d);
set(this, RIGHT, A, XK_f);
set(this, RIGHT, RIGHT, XK_g);
set(this, ButtonId_A, ButtonId_A, XK_h);
set(this, ButtonId_A, ButtonId_RIGHT, XK_j);
set(this, ButtonId_B, ButtonId_RIGHT, XK_k);
set(this, ButtonId_X, ButtonId_RIGHT, XK_l);
set(this, ButtonId_Y, ButtonId_RIGHT, XK_semicolon);
set(this, A, A, XK_h);
set(this, A, RIGHT, XK_j);
set(this, B, RIGHT, XK_k);
set(this, X, RIGHT, XK_l);
set(this, Y, RIGHT, XK_semicolon);
set(this, ButtonId_LEFT, ButtonId_X, XK_z);
set(this, ButtonId_DOWN, ButtonId_X, XK_x);
set(this, ButtonId_UP, ButtonId_X, XK_c);
set(this, ButtonId_RIGHT, ButtonId_X, XK_v);
set(this, ButtonId_RIGHT, ButtonId_DOWN, XK_b);
set(this, LEFT, X, XK_z);
set(this, DOWN, X, XK_x);
set(this, UP, X, XK_c);
set(this, RIGHT, X, XK_v);
set(this, RIGHT, DOWN, XK_b);
set(this, ButtonId_A, ButtonId_X, XK_n);
set(this, ButtonId_A, ButtonId_DOWN, XK_m);
set(this, ButtonId_B, ButtonId_DOWN, XK_comma);
set(this, ButtonId_X, ButtonId_DOWN, XK_period);
set(this, ButtonId_Y, ButtonId_DOWN, XK_slash);
set(this, A, X, XK_n);
set(this, A, DOWN, XK_m);
set(this, B, DOWN, XK_comma);
set(this, X, DOWN, XK_period);
set(this, Y, DOWN, XK_slash);
}
struct KeyCode *Keymap_get(struct Keymap *this, struct Code *code)
int Keymap_get(struct Keymap *this, struct Code *code)
{
int index;
index = code->first * 8 + code->second;
return &this->keyCode[index];
return this->keyCode[index];
}

14
keymap.h
View File

@@ -1,18 +1,18 @@
/*
* Released into the public domain
* by Aki Goto <tyatsumi@gmail.com>
*/
#ifndef KEYMAP_H
#define KEYMAP_H
#include "multibutton.h"
struct KeyCode {
int modifier;
int keyCode;
};
struct Keymap {
struct KeyCode keyCode[8 * 8];
int keyCode[8 * 8];
};
extern void Keymap_initialize(struct Keymap *this);
extern struct KeyCode *Keymap_get(struct Keymap *this, struct Code *code);
extern int Keymap_get(struct Keymap *this, struct Code *code);
#endif

15
main.c
View File

@@ -1,3 +1,8 @@
/*
* Released into the public domain
* by Aki Goto <tyatsumi@gmail.com>
*/
#include <X11/Xlib.h>
#include <X11/keysym.h>
#include <stdio.h>
@@ -86,7 +91,7 @@ int main(int argc, char **argv)
MultiButton_update(&multiButton, &event);
MultiButton_generate(&multiButton);
if (multiButton.available) {
struct KeyCode *keyCode;
int keyCode;
int state;
keyCode = Keymap_get(&keymap, &multiButton.code);
@@ -96,12 +101,16 @@ int main(int argc, char **argv)
state = 0;
} else if (multiButton.code.modifier == Modifier_SHIFT) {
state |= ShiftMask;
} else if (multiButton.code.modifier == Modifier_CONTROL) {
state |= ControlMask;
} else if (multiButton.code.modifier == Modifier_ALT) {
state |= Mod1Mask;
} else {
state = 0;
}
keyEvent = createKeyEvent(KeyPress, display, window, root, state, keyCode->keyCode);
keyEvent = createKeyEvent(KeyPress, display, window, root, state, keyCode);
XSendEvent(keyEvent.display, keyEvent.window, True, KeyPressMask, (XEvent *)&keyEvent);
keyEvent = createKeyEvent(KeyRelease, display, window, root, state, keyCode->keyCode);
keyEvent = createKeyEvent(KeyRelease, display, window, root, state, keyCode);
XSendEvent(keyEvent.display, keyEvent.window, True, KeyPressMask, (XEvent *)&keyEvent);
XFlush(display);
}

29
multibutton.c
View File

@@ -1,3 +1,8 @@
/*
* Released into the public domain
* by Aki Goto <tyatsumi@gmail.com>
*/
#include "multibutton.h"
void MultiButton_initialize(struct MultiButton *this, struct Gamepad *gamepad)
@@ -77,6 +82,30 @@ void MultiButton_generate(struct MultiButton *this)
this->sequence[this->sequenceSize] = this->buttons[i];
this->sequenceSize++;
}
} else if (this->list[0] == this->buttons[i]->control && Button_isHolded(this->buttons[i]->control)) {
int k;
this->modifier = Modifier_CONTROL;
for (k = 1; k < this->size; k++) {
this->list[k - 1] = this->list[k];
}
this->size--;
if (this->sequenceSize < 8) {
this->sequence[this->sequenceSize] = this->buttons[i];
this->sequenceSize++;
}
} else if (this->list[0] == this->buttons[i]->alt && Button_isHolded(this->buttons[i]->alt)) {
int k;
this->modifier = Modifier_ALT;
for (k = 1; k < this->size; k++) {
this->list[k - 1] = this->list[k];
}
this->size--;
if (this->sequenceSize < 8) {
this->sequence[this->sequenceSize] = this->buttons[i];
this->sequenceSize++;
}
} else {
this->code.modifier = this->modifier;
this->code.first = this->list[0]->id;

7
multibutton.h
View File

@@ -1,3 +1,8 @@
/*
* Released into the public domain
* by Aki Goto <tyatsumi@gmail.com>
*/
#ifndef MULTIBUTTON_H
#define MULTIBUTTON_H
@@ -6,6 +11,8 @@
enum {
Modifier_NONE,
Modifier_SHIFT,
Modifier_CONTROL,
Modifier_ALT,
};
struct Code {