Skip to content

Instantly share code, notes, and snippets.

@tsutsui

tsutsui/mouse.c.diff

Created February 7, 2021 17:55
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save tsutsui/cd45cdbbf2991722875d405f87a0983e to your computer and use it in GitHub Desktop.
Save tsutsui/cd45cdbbf2991722875d405f87a0983e to your computer and use it in GitHub Desktop.
Download ZIP
pseudo diff for xf86-input-mouse to refactor Emulate3Buttons finate-state machine definitions
Raw
mouse.c.diff
diff --git a/mouse.c b/mouse.c
index ae219ce..02f70ff 100644
--- a/mouse.c
+++ b/mouse.c
@@ -76,7 +76,22 @@ static void MouseDoPostEvent(DeviceIntPtr device, int buttons, int dx, int dy);
* 8 repressed left - left pressed after released left
* 9 repressed right - right pressed after released right
* 10 pressed both - both pressed, not emulating middle
- *
+ */
+#define ST_INVALID -1
+#define ST_GROUND 0 /* initial state */
+#define ST_DELAYED_LEFT 1 /* left pressed and waiting timeout */
+#define ST_DELAYED_RIGHT 2 /* right pressed and waiting timeout */
+#define ST_PRESSED_MIDDLE 3 /* middle pressed deteremined */
+#define ST_PRESSED_LEFT 4 /* left pressed determined */
+#define ST_PRESSED_RIGHT 5 /* right pressed determined */
+#define ST_RELEASED_LEFT 6 /* left released after pressed both */
+#define ST_RELEASED_RIGHT 7 /* right released after pressed both */
+#define ST_REPRESSED_LEFT 8 /* left repressed after release */
+#define ST_REPRESSED_RIGHT 9 /* right repressed after release */
+#define ST_PRESSED_BOTH 10 /* both pressed (not as middle) */
+#define NSTATES 11
+
+/*
* At each state, we need handlers for the following events
* 0: no buttons down
* 1: left button down
@@ -92,11 +107,43 @@ static void MouseDoPostEvent(DeviceIntPtr device, int buttons, int dx, int dy);
* 0: action1
* 1: action2
* 2: new emulation state
- *
- * action > 0: ButtonPress
- * action = 0: nothing
- * action < 0: ButtonRelease
- *
+ */
+struct button_event {
+ int type; /* ButtonNone / ButtonPress / ButtonRelease */
+#define ButtonNone 0
+ int button;
+#define ButtonLeft Button1
+#define ButtonMiddle Button2
+#define ButtonRight Button3
+};
+
+struct button_action {
+ struct button_event event1;
+ struct button_event event2;
+ int new_state;
+};
+
+/* The set of buttons being pressed passed from DDX mouse events */
+#define BMASK_LEFT 0x01
+#define BMASK_MIDDLE 0x02
+#define BMASK_RIGHT 0x04
+
+/* Event index values per buttons being pressed */
+#define EMU_BUTTONS_NONE 0
+#define EMU_BUTTONS_LEFT 1
+#define EMU_BUTTONS_RIGHT 2
+#define EMU_BUTTONS_BOTH 3
+#define NEMU_BUTTONSTATE 4
+
+#define BMASKTOINDEX(bmask) \
+ ((((bmask) & BMASK_RIGHT) >> 1) | ((bmask) & BMASK_LEFT))
+
+struct button_state {
+ struct button_action buttons[NEMU_BUTTONSTATE];
+ struct button_action timeout;
+};
+
+/*
* The comment preceeding each section is the current emulation state.
* The comments to the right are of the form
* <button state> (<events>) -> <new emulation state>
@@ -104,94 +151,435 @@ static void MouseDoPostEvent(DeviceIntPtr device, int buttons, int dx, int dy);
* If the buttons are in <button state>, generate <events> then go to
* <new emulation state>.
*/
-static const signed char stateTab[11][5][3] = {
-/* 0 ground */
- {
- { 0, 0, 0 }, /* nothing -> ground (no change) */
- { 0, 0, 1 }, /* left -> delayed left */
- { 0, 0, 2 }, /* right -> delayed right */
- { 2, 0, 3 }, /* left & right (middle press) -> pressed middle */
- { 0, 0, -1 } /* timeout N/A */
+static const struct button_state stateTab[NSTATES] = {
+
+ /* 0 ground - initial state */
+ [ST_GROUND] = {
+
+ .buttons[EMU_BUTTONS_NONE] = {
+ /* nothing -> ground (no change) */
+ .event1 = { ButtonNone, 0 },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_GROUND,
+ },
+
+ .buttons[EMU_BUTTONS_LEFT] = {
+ /* left -> delayed left */
+ .event1 = { ButtonNone, 0 },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_DELAYED_LEFT,
+ },
+
+ .buttons[EMU_BUTTONS_RIGHT] = {
+ /* right -> delayed right */
+ .event1 = { ButtonNone, 0 },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_DELAYED_RIGHT,
+ },
+
+ .buttons[EMU_BUTTONS_BOTH] = {
+ /* left & right (middle press) -> pressed middle */
+ .event1 = { ButtonPress, ButtonMiddle },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_PRESSED_MIDDLE,
+ },
+
+ .timeout = {
+ /* timeout N/A */
+ .event1 = { ButtonNone, 0 },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_INVALID,
+ },
},
-/* 1 delayed left */
- {
- { 1, -1, 0 }, /* nothing (left event) -> ground */
- { 0, 0, 1 }, /* left -> delayed left (no change) */
- { 1, -1, 2 }, /* right (left event) -> delayed right */
- { 2, 0, 3 }, /* left & right (middle press) -> pressed middle */
- { 1, 0, 4 }, /* timeout (left press) -> pressed left */
+
+ /* 1 delayed left - left pressed, waiting for right */
+ [ST_DELAYED_LEFT] = {
+
+ .buttons[EMU_BUTTONS_NONE] = {
+ /* nothing (left event) -> ground */
+ .event1 = { ButtonPress, ButtonLeft },
+ .event2 = { ButtonRelease, ButtonLeft },
+ .new_state = ST_GROUND,
+ },
+
+ .buttons[EMU_BUTTONS_LEFT] = {
+ /* left -> delayed left (no change) */
+ .event1 = { ButtonNone, 0 },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_DELAYED_LEFT,
+ },
+
+ .buttons[EMU_BUTTONS_RIGHT] = {
+ /* right (left event) -> delayed right */
+ .event1 = { ButtonPress, ButtonLeft },
+ .event2 = { ButtonRelease, ButtonLeft },
+ .new_state = ST_DELAYED_RIGHT,
+ },
+
+ .buttons[EMU_BUTTONS_BOTH] = {
+ /* left & right (middle press) -> pressed middle */
+ .event1 = { ButtonPress, ButtonMiddle },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_PRESSED_MIDDLE,
+ },
+
+ .timeout = {
+ /* timeout (left press) -> pressed left */
+ .event1 = { ButtonPress, ButtonLeft },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_PRESSED_LEFT,
+ },
},
-/* 2 delayed right */
- {
- { 3, -3, 0 }, /* nothing (right event) -> ground */
- { 3, -3, 1 }, /* left (right event) -> delayed left (no change) */
- { 0, 0, 2 }, /* right -> delayed right (no change) */
- { 2, 0, 3 }, /* left & right (middle press) -> pressed middle */
- { 3, 0, 5 }, /* timeout (right press) -> pressed right */
+
+ /* 2 delayed right - right pressed, waiting for left */
+ [ST_DELAYED_RIGHT] = {
+
+ .buttons[EMU_BUTTONS_NONE] = {
+ /* nothing (right event) -> ground */
+ .event1 = { ButtonPress, ButtonRight },
+ .event2 = { ButtonRelease, ButtonRight },
+ .new_state = ST_GROUND,
+ },
+
+ .buttons[EMU_BUTTONS_LEFT] = {
+ /* left (right event) -> delayed left */
+ .event1 = { ButtonPress, ButtonRight },
+ .event2 = { ButtonRelease, ButtonRight },
+ .new_state = ST_DELAYED_LEFT,
+ },
+
+ .buttons[EMU_BUTTONS_RIGHT] = {
+ /* right -> delayed right (no change) */
+ .event1 = { ButtonNone, 0 },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_DELAYED_RIGHT,
+ },
+
+ .buttons[EMU_BUTTONS_BOTH] = {
+ /* left & right (middle press) -> pressed middle */
+ .event1 = { ButtonPress, ButtonMiddle },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_PRESSED_MIDDLE,
+ },
+
+ .timeout = {
+ /* timeout (right press) -> pressed right */
+ .event1 = { ButtonPress, ButtonRight },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_PRESSED_RIGHT,
+ },
},
-/* 3 pressed middle */
- {
- { -2, 0, 0 }, /* nothing (middle release) -> ground */
- { 0, 0, 7 }, /* left -> released right */
- { 0, 0, 6 }, /* right -> released left */
- { 0, 0, 3 }, /* left & right -> pressed middle (no change) */
- { 0, 0, -1 }, /* timeout N/A */
+
+ /* 3 pressed middle - right and left pressed, emulated middle sent */
+ [ST_PRESSED_MIDDLE] = {
+
+ .buttons[EMU_BUTTONS_NONE] = {
+ /* nothing (middle release) -> ground */
+ .event1 = { ButtonRelease, ButtonMiddle },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_GROUND,
+ },
+
+ .buttons[EMU_BUTTONS_LEFT] = {
+ /* left -> released right */
+ .event1 = { ButtonNone, 0 },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_RELEASED_RIGHT,
+ },
+
+ .buttons[EMU_BUTTONS_RIGHT] = {
+ /* right -> released left */
+ .event1 = { ButtonNone, 0 },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_RELEASED_LEFT,
+ },
+
+ .buttons[EMU_BUTTONS_BOTH] = {
+ /* left & right -> pressed middle (no change) */
+ .event1 = { ButtonNone, 0 },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_PRESSED_MIDDLE,
+ },
+
+ .timeout = {
+ /* timeout N/A */
+ .event1 = { ButtonNone, 0 },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_INVALID,
+ },
},
-/* 4 pressed left */
- {
- { -1, 0, 0 }, /* nothing (left release) -> ground */
- { 0, 0, 4 }, /* left -> pressed left (no change) */
- { -1, 0, 2 }, /* right (left release) -> delayed right */
- { 3, 0, 10 }, /* left & right (right press) -> pressed both */
- { 0, 0, -1 }, /* timeout N/A */
+
+ /* 4 pressed left - left pressed and sent */
+ [ST_PRESSED_LEFT] = {
+
+ .buttons[EMU_BUTTONS_NONE] = {
+ /* nothing (left release) -> ground */
+ .event1 = { ButtonRelease, ButtonLeft },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_GROUND,
+ },
+
+ .buttons[EMU_BUTTONS_LEFT] = {
+ /* left -> pressed left (no change) */
+ .event1 = { ButtonNone, 0 },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_PRESSED_LEFT,
+ },
+
+ .buttons[EMU_BUTTONS_RIGHT] = {
+ /* right (left release) -> delayed right */
+ .event1 = { ButtonRelease, ButtonLeft },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_DELAYED_RIGHT,
+ },
+
+ .buttons[EMU_BUTTONS_BOTH] = {
+ /* left & right (right press) -> pressed both */
+ .event1 = { ButtonPress, ButtonRight },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_PRESSED_BOTH,
+ },
+
+ .timeout = {
+ /* timeout N/A */
+ .event1 = { ButtonNone, 0 },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_INVALID,
+ },
},
-/* 5 pressed right */
- {
- { -3, 0, 0 }, /* nothing (right release) -> ground */
- { -3, 0, 1 }, /* left (right release) -> delayed left */
- { 0, 0, 5 }, /* right -> pressed right (no change) */
- { 1, 0, 10 }, /* left & right (left press) -> pressed both */
- { 0, 0, -1 }, /* timeout N/A */
+
+ /* 5 pressed right - right pressed and sent */
+ [ST_PRESSED_RIGHT] = {
+
+ .buttons[EMU_BUTTONS_NONE] = {
+ /* nothing (right release) -> ground */
+ .event1 = { ButtonRelease, ButtonRight },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_GROUND,
+ },
+
+ .buttons[EMU_BUTTONS_LEFT] = {
+ /* left (right release) -> delayed left */
+ .event1 = { ButtonRelease, ButtonRight },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_DELAYED_LEFT,
+ },
+
+ .buttons[EMU_BUTTONS_RIGHT] = {
+ /* right -> pressed right (no change) */
+ .event1 = { ButtonNone, 0 },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_PRESSED_RIGHT,
+ },
+
+ .buttons[EMU_BUTTONS_BOTH] = {
+ /* left & right (left press) -> pressed both */
+ .event1 = { ButtonPress, ButtonLeft },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_PRESSED_BOTH,
+ },
+
+ .timeout = {
+ /* timeout N/A */
+ .event1 = { ButtonNone, 0 },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_INVALID,
+ },
},
-/* 6 released left */
- {
- { -2, 0, 0 }, /* nothing (middle release) -> ground */
- { -2, 0, 1 }, /* left (middle release) -> delayed left */
- { 0, 0, 6 }, /* right -> released left (no change) */
- { 1, 0, 8 }, /* left & right (left press) -> repressed left */
- { 0, 0, -1 }, /* timeout N/A */
+
+ /* 6 released left - left released after emulated middle */
+ [ST_RELEASED_LEFT] = {
+
+ .buttons[EMU_BUTTONS_NONE] = {
+ /* nothing (middle release) -> ground */
+ .event1 = { ButtonRelease, ButtonMiddle },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_GROUND,
+ },
+
+ .buttons[EMU_BUTTONS_LEFT] = {
+ /* left (middle release) -> delayed left */
+ .event1 = { ButtonRelease, ButtonMiddle },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_DELAYED_LEFT,
+ },
+
+ .buttons[EMU_BUTTONS_RIGHT] = {
+ /* right -> released left (no change) */
+ .event1 = { ButtonNone, 0 },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_RELEASED_LEFT,
+ },
+
+ .buttons[EMU_BUTTONS_BOTH] = {
+ /* left & right (left press) -> repressed left */
+ .event1 = { ButtonPress, ButtonLeft },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_REPRESSED_LEFT,
+ },
+
+ .timeout = {
+ /* timeout N/A */
+ .event1 = { ButtonNone, 0 },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_INVALID,
+ },
},
-/* 7 released right */
- {
- { -2, 0, 0 }, /* nothing (middle release) -> ground */
- { 0, 0, 7 }, /* left -> released right (no change) */
- { -2, 0, 2 }, /* right (middle release) -> delayed right */
- { 3, 0, 9 }, /* left & right (right press) -> repressed right */
- { 0, 0, -1 }, /* timeout N/A */
+
+ /* 7 released right - right released after emulated middle */
+ [ST_RELEASED_RIGHT] = {
+
+ .buttons[EMU_BUTTONS_NONE] = {
+ /* nothing (middle release) -> ground */
+ .event1 = { ButtonRelease, ButtonMiddle },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_GROUND,
+ },
+
+ .buttons[EMU_BUTTONS_LEFT] = {
+ /* left -> released right (no change) */
+ .event1 = { ButtonNone, 0 },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_RELEASED_RIGHT,
+ },
+
+ .buttons[EMU_BUTTONS_RIGHT] = {
+ /* right (middle release) -> delayed right */
+ .event1 = { ButtonRelease, ButtonMiddle },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_DELAYED_RIGHT,
+ },
+
+ .buttons[EMU_BUTTONS_BOTH] = {
+ /* left & right (right press) -> repressed right */
+ .event1 = { ButtonPress, ButtonRight },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_REPRESSED_RIGHT,
+ },
+
+ .timeout = {
+ /* timeout N/A */
+ .event1 = { ButtonNone, 0 },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_INVALID,
+ },
},
-/* 8 repressed left */
- {
- { -2, -1, 0 }, /* nothing (middle release, left release) -> ground */
- { -2, 0, 4 }, /* left (middle release) -> pressed left */
- { -1, 0, 6 }, /* right (left release) -> released left */
- { 0, 0, 8 }, /* left & right -> repressed left (no change) */
- { 0, 0, -1 }, /* timeout N/A */
+
+ /* 8 repressed left - left pressed after released left */
+ [ST_REPRESSED_LEFT] = {
+
+ .buttons[EMU_BUTTONS_NONE] = {
+ /* nothing (middle release, left release) -> ground */
+ .event1 = { ButtonRelease, ButtonMiddle },
+ .event2 = { ButtonRelease, ButtonLeft },
+ .new_state = ST_GROUND,
+ },
+
+ .buttons[EMU_BUTTONS_LEFT] = {
+ /* left (middle release) -> pressed left */
+ .event1 = { ButtonRelease, ButtonMiddle },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_PRESSED_LEFT,
+ },
+
+ .buttons[EMU_BUTTONS_RIGHT] = {
+ /* right (left release) -> released left */
+ .event1 = { ButtonRelease, ButtonLeft },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_RELEASED_LEFT,
+ },
+
+ .buttons[EMU_BUTTONS_BOTH] = {
+ /* left & right -> repressed left (no change) */
+ .event1 = { ButtonNone, 0 },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_REPRESSED_LEFT,
+ },
+
+ .timeout = {
+ /* timeout N/A */
+ .event1 = { ButtonNone, 0 },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_INVALID,
+ },
},
-/* 9 repressed right */
- {
- { -2, -3, 0 }, /* nothing (middle release, right release) -> ground */
- { -3, 0, 7 }, /* left (right release) -> released right */
- { -2, 0, 5 }, /* right (middle release) -> pressed right */
- { 0, 0, 9 }, /* left & right -> repressed right (no change) */
- { 0, 0, -1 }, /* timeout N/A */
+
+ /* 9 repressed right - right pressed after released right */
+ [ST_REPRESSED_RIGHT] = {
+
+ .buttons[EMU_BUTTONS_NONE] = {
+ /* nothing (middle release, right release) -> ground */
+ .event1 = { ButtonRelease, ButtonMiddle },
+ .event2 = { ButtonRelease, ButtonRight },
+ .new_state = ST_GROUND,
+ },
+
+ .buttons[EMU_BUTTONS_LEFT] = {
+ /* left (right release) -> released right */
+ .event1 = { ButtonRelease, ButtonRight },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_RELEASED_RIGHT,
+ },
+
+ .buttons[EMU_BUTTONS_RIGHT] = {
+ /* right (middle release) -> pressed right */
+ .event1 = { ButtonRelease, ButtonMiddle },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_PRESSED_RIGHT,
+ },
+
+ .buttons[EMU_BUTTONS_BOTH] = {
+ /* left & right -> repressed right (no change) */
+ .event1 = { ButtonNone, 0 },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_REPRESSED_RIGHT,
+ },
+
+ .timeout = {
+ /* timeout N/A */
+ .event1 = { ButtonNone, 0 },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_INVALID,
+ },
},
-/* 10 pressed both */
- {
- { -1, -3, 0 }, /* nothing (left release, right release) -> ground */
- { -3, 0, 4 }, /* left (right release) -> pressed left */
- { -1, 0, 5 }, /* right (left release) -> pressed right */
- { 0, 0, 10 }, /* left & right -> pressed both (no change) */
- { 0, 0, -1 }, /* timeout N/A */
+
+ /* 10 pressed both - both pressed, not emulating middle */
+ [ST_PRESSED_BOTH] = {
+
+ .buttons[EMU_BUTTONS_NONE] = {
+ /* nothing (left release, right release) -> ground */
+ .event1 = { ButtonRelease, ButtonLeft },
+ .event2 = { ButtonRelease, ButtonRight },
+ .new_state = ST_GROUND,
+ },
+
+ .buttons[EMU_BUTTONS_LEFT] = {
+ /* left (right release) -> pressed left */
+ .event1 = { ButtonRelease, ButtonRight },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_PRESSED_LEFT,
+ },
+
+ .buttons[EMU_BUTTONS_RIGHT] = {
+ /* right (left release) -> pressed right */
+ .event1 = { ButtonRelease, ButtonLeft },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_PRESSED_RIGHT,
+ },
+
+ .buttons[EMU_BUTTONS_BOTH] = {
+ /* left & right -> pressed both (no change) */
+ .event1 = { ButtonNone, 0 },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_PRESSED_BOTH,
+ },
+
+ .timeout = {
+ /* timeout N/A */
+ .event1 = { ButtonNone, 0 },
+ .event2 = { ButtonNone, 0 },
+ .new_state = ST_INVALID,
+ },
},
};
@@ -200,9 +588,9 @@ buttonTimer(DeviceIntPtr device)
{
X68kMousePrivPtr pPriv;
sigset_t sigmask;
- int id;
int type, button, flag;
ValuatorMask mask;
+ const struct button_action *timeout_action;
pPriv = device->public.devicePrivate;
@@ -211,13 +599,13 @@ buttonTimer(DeviceIntPtr device)
(void)sigprocmask(SIG_BLOCK, &sigmask, NULL);
pPriv->emulate3Pending = FALSE;
- if ((id = stateTab[pPriv->emulateState][4][0]) != 0) {
- button = abs(id);
- type = (id >= 0) ? ButtonPress : ButtonRelease;
+ timeout_action = &stateTab[pPriv->emulateState].timeout;
+ if ((type = timeout_action->event1.type) != ButtonNone) {
+ button = timeout_action->event1.button;
flag = POINTER_RELATIVE;
valuator_mask_zero(&mask);
QueuePointerEvents(device, type, button, flag, &mask);
- pPriv->emulateState = stateTab[pPriv->emulateState][4][2];
+ pPriv->emulateState = timeout_action->new_state;
} else {
LogMessageVerbSigSafe(X_WARNING, -1,
"Got unexpected buttonTimer in state %d\n", pPriv->emulateState);
@@ -347,35 +735,36 @@ MouseDoPostEvent(DeviceIntPtr device, int buttons, int dx, int dy)
if (change) {
if (pPriv->emulate3Buttons
- && (!(buttons & 0x02) || Emulate3ButtonsSoft(device))) {
+ && ((buttons & BMASK_MIDDLE) == 0 || Emulate3ButtonsSoft(device))) {
+ const struct button_action *button_action, *timeout_action;
/* handle all but buttons 1 & 3 normally */
- change &= ~(0x01 | 0x04);
+ change &= ~(BMASK_LEFT | BMASK_RIGHT);
/* emulate the third button by the other two */
- emulateButtons = (buttons & 0x01) | ((buttons & 0x04) >> 1);
+ emulateButtons = BMASKTOINDEX(buttons);
+ button_action =
+ &stateTab[pPriv->emulateState].buttons[emulateButtons];
- if ((id = stateTab[pPriv->emulateState][emulateButtons][0]) != 0) {
- button = abs(id);
- type = (id >= 0) ? ButtonPress : ButtonRelease;
+ if ((type = button_action->event1.type) != ButtonNone) {
+ button = button_action->event1.button;
flag = POINTER_RELATIVE;
valuator_mask_zero(&mask);
QueuePointerEvents(device, type, button, flag, &mask);
}
- if ((id = stateTab[pPriv->emulateState][emulateButtons][1]) != 0) {
- button = abs(id);
- type = (id >= 0) ? ButtonPress : ButtonRelease;
+ if ((type = button_action->event2.type) != ButtonNone) {
+ button = button_action->event2.button;
flag = POINTER_RELATIVE;
valuator_mask_zero(&mask);
QueuePointerEvents(device, type, button, flag, &mask);
}
- pPriv->emulateState =
- stateTab[pPriv->emulateState][emulateButtons][2];
+ pPriv->emulateState = button_action->new_state;
- if (stateTab[pPriv->emulateState][4][0] != 0) {
+ timeout_action = &stateTab[pPriv->emulateState].timeout;
+ if (timeout_action->event1.type != ButtonNone) {
pPriv->emulate3Expires =
GetTimeInMillis() + pPriv->emulate3Timeout;
pPriv->emulate3Pending = TRUE;
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment