Mercurial > molko
changeset 19:bc1fdff76775
core: implement most useful events, closes #2445
| author | David Demelier <markand@malikania.fr> |
|---|---|
| date | Wed, 08 Jan 2020 13:33:41 +0100 |
| parents | 3ddd3acfe0e9 |
| children | 2fb93d57c098 |
| files | Makefile src/event.c src/event.h src/key.h src/main.c src/mouse.h |
| diffstat | 6 files changed, 583 insertions(+), 43 deletions(-) [+] |
line wrap: on
line diff
--- a/Makefile Wed Jan 08 13:25:17 2020 +0100 +++ b/Makefile Wed Jan 08 13:33:41 2020 +0100 @@ -24,6 +24,7 @@ LIB= libmolko.a SRCS= src/animation.c \ src/clock.c \ + src/event.c \ src/font.c \ src/image.c \ src/sprite.c \
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/event.c Wed Jan 08 13:33:41 2020 +0100 @@ -0,0 +1,255 @@ +/* + * event.c -- event management + * + * Copyright (c) 2020 David Demelier <markand@malikania.fr> + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include <SDL.h> + +#include "event.h" + +/* Maintain with enum key constants in key.h */ +static const struct { + SDL_Keycode key; + enum key value; +} keymap[] = { + { SDLK_RETURN, KEY_ENTER }, + { SDLK_ESCAPE, KEY_ESCAPE }, + { SDLK_BACKSPACE, KEY_BACKSPACE }, + { SDLK_TAB, KEY_TAB }, + { SDLK_SPACE, KEY_SPACE }, + { SDLK_EXCLAIM, KEY_EXCLAIM }, + { SDLK_QUOTEDBL, KEY_DOUBLE_QUOTE }, + { SDLK_HASH, KEY_HASH }, + { SDLK_PERCENT, KEY_PERCENT }, + { SDLK_DOLLAR, KEY_DOLLAR }, + { SDLK_AMPERSAND, KEY_AMPERSAND }, + { SDLK_QUOTE, KEY_QUOTE }, + { SDLK_LEFTPAREN, KEY_LEFT_PAREN }, + { SDLK_RIGHTPAREN, KEY_RIGHT_PAREN }, + { SDLK_ASTERISK, KEY_ASTERISK }, + { SDLK_PLUS, KEY_PLUS }, + { SDLK_COMMA, KEY_COMMA }, + { SDLK_MINUS, KEY_MINUS }, + { SDLK_PERIOD, KEY_PERIOD }, + { SDLK_SLASH, KEY_SLASH }, + { SDLK_0, KEY_0 }, + { SDLK_1, KEY_1 }, + { SDLK_2, KEY_2 }, + { SDLK_3, KEY_3 }, + { SDLK_4, KEY_4 }, + { SDLK_5, KEY_5 }, + { SDLK_6, KEY_6 }, + { SDLK_7, KEY_7 }, + { SDLK_8, KEY_8 }, + { SDLK_9, KEY_9 }, + { SDLK_COLON, KEY_COLON }, + { SDLK_SEMICOLON, KEY_SEMICOLON }, + { SDLK_LESS, KEY_LESS }, + { SDLK_EQUALS, KEY_EQUALS }, + { SDLK_GREATER, KEY_GREATER }, + { SDLK_QUESTION, KEY_QUESTION }, + { SDLK_AT, KEY_AT }, + { SDLK_LEFTBRACKET, KEY_LEFT_BRACKET }, + { SDLK_BACKSLASH, KEY_BACKSLASH }, + { SDLK_RIGHTBRACKET, KEY_RIGHT_BRACKET }, + { SDLK_CARET, KEY_CARET }, + { SDLK_UNDERSCORE, KEY_UNDERSCORE }, + { SDLK_BACKQUOTE, KEY_BACKQUOTE }, + { SDLK_a, KEY_a }, + { SDLK_b, KEY_b }, + { SDLK_c, KEY_c }, + { SDLK_d, KEY_d }, + { SDLK_e, KEY_e }, + { SDLK_f, KEY_f }, + { SDLK_g, KEY_g }, + { SDLK_h, KEY_h }, + { SDLK_i, KEY_i }, + { SDLK_j, KEY_j }, + { SDLK_k, KEY_k }, + { SDLK_l, KEY_l }, + { SDLK_m, KEY_m }, + { SDLK_n, KEY_n }, + { SDLK_o, KEY_o }, + { SDLK_p, KEY_p }, + { SDLK_q, KEY_q }, + { SDLK_r, KEY_r }, + { SDLK_s, KEY_s }, + { SDLK_t, KEY_t }, + { SDLK_u, KEY_u }, + { SDLK_v, KEY_v }, + { SDLK_w, KEY_w }, + { SDLK_x, KEY_x }, + { SDLK_y, KEY_y }, + { SDLK_z, KEY_z }, + { SDLK_CAPSLOCK, KEY_CAPSLOCK }, + { SDLK_F1, KEY_F1 }, + { SDLK_F2, KEY_F2 }, + { SDLK_F3, KEY_F3 }, + { SDLK_F4, KEY_F4 }, + { SDLK_F5, KEY_F5 }, + { SDLK_F6, KEY_F6 }, + { SDLK_F7, KEY_F7 }, + { SDLK_F8, KEY_F8 }, + { SDLK_F9, KEY_F9 }, + { SDLK_F10, KEY_F10 }, + { SDLK_F11, KEY_F11 }, + { SDLK_F12, KEY_F12 }, + { SDLK_F13, KEY_F13 }, + { SDLK_F14, KEY_F14 }, + { SDLK_F15, KEY_F15 }, + { SDLK_F16, KEY_F16 }, + { SDLK_F17, KEY_F17 }, + { SDLK_F18, KEY_F18 }, + { SDLK_F19, KEY_F19 }, + { SDLK_F20, KEY_F20 }, + { SDLK_F21, KEY_F21 }, + { SDLK_F22, KEY_F22 }, + { SDLK_F23, KEY_F23 }, + { SDLK_F24, KEY_F24 }, + { SDLK_PRINTSCREEN, KEY_PRINTSCREEN }, + { SDLK_SCROLLLOCK, KEY_SCROLLLOCK }, + { SDLK_PAUSE, KEY_PAUSE }, + { SDLK_INSERT, KEY_INSERT }, + { SDLK_HOME, KEY_HOME }, + { SDLK_PAGEUP, KEY_PAGEUP }, + { SDLK_DELETE, KEY_DELETE }, + { SDLK_END, KEY_END }, + { SDLK_PAGEDOWN, KEY_PAGEDOWN }, + { SDLK_RIGHT, KEY_RIGHT }, + { SDLK_LEFT, KEY_LEFT }, + { SDLK_DOWN, KEY_DOWN }, + { SDLK_UP, KEY_UP }, + { SDLK_KP_DIVIDE, KEY_KP_DIVIDE }, + { SDLK_KP_MULTIPLY, KEY_KP_MULTIPLY }, + { SDLK_KP_MINUS, KEY_KP_MINUS }, + { SDLK_KP_PLUS, KEY_KP_PLUS }, + { SDLK_KP_ENTER, KEY_KP_ENTER }, + { SDLK_KP_1, KEY_KP_1 }, + { SDLK_KP_2, KEY_KP_2 }, + { SDLK_KP_3, KEY_KP_3 }, + { SDLK_KP_4, KEY_KP_4 }, + { SDLK_KP_5, KEY_KP_5 }, + { SDLK_KP_6, KEY_KP_6 }, + { SDLK_KP_7, KEY_KP_7 }, + { SDLK_KP_8, KEY_KP_8 }, + { SDLK_KP_9, KEY_KP_9 }, + { SDLK_KP_0, KEY_KP_0 }, + { SDLK_KP_PERIOD, KEY_KP_PERIOD }, + { SDLK_KP_COMMA, KEY_KP_COMMA }, + { SDLK_MENU, KEY_MENU }, + { SDLK_MUTE, KEY_MUTE }, + { SDLK_VOLUMEUP, KEY_VOLUME_UP }, + { SDLK_VOLUMEDOWN, KEY_VOLUME_DOWN }, + { SDLK_LCTRL, KEY_LCTRL }, + { SDLK_LSHIFT, KEY_LSHIFT }, + { SDLK_LALT, KEY_LALT }, + { SDLK_LGUI, KEY_LSUPER }, + { SDLK_RCTRL, KEY_RCTRL }, + { SDLK_RSHIFT, KEY_RSHIFT }, + { SDLK_RALT, KEY_RALT }, + { SDLK_RGUI, KEY_RSUPER }, + { 0, -1 } +}; + +/* Maintain with enum mouse_button constants in mouse.h */ +static const struct { + int key; + enum mouse_button value; +} buttons[] = { + { SDL_BUTTON_LEFT, MOUSE_BUTTON_LEFT }, + { SDL_BUTTON_MIDDLE, MOUSE_BUTTON_MIDDLE }, + { SDL_BUTTON_RIGHT, MOUSE_BUTTON_RIGHT }, + { -1, MOUSE_BUTTON_UNKNOWN } +}; + +static void +convert_key(const SDL_Event *event, union event *ev) +{ + ev->type = event->type == SDL_KEYDOWN ? EVENT_KEYDOWN : EVENT_KEYUP; + ev->key.key = KEY_UNKNOWN; + + for (size_t i = 0; keymap[i].key != 0; ++i) { + if (keymap[i].key == event->key.keysym.sym) { + ev->key.key = keymap[i].value; + break; + } + } +} + +static void +convert_mouse(const SDL_Event *event, union event *ev) +{ + ev->type = EVENT_MOUSE; + ev->mouse.buttons = 0; + ev->mouse.x = event->motion.x; + ev->mouse.y = event->motion.y; + + if (event->motion.state & SDL_BUTTON_LMASK) + ev->mouse.buttons |= MOUSE_BUTTON_LEFT; + if (event->motion.state & SDL_BUTTON_MMASK) + ev->mouse.buttons |= MOUSE_BUTTON_MIDDLE; + if (event->motion.state & SDL_BUTTON_RMASK) + ev->mouse.buttons |= MOUSE_BUTTON_RIGHT; +} + +static void +convert_click(const SDL_Event *event, union event *ev) +{ + ev->type = event->type == SDL_MOUSEBUTTONDOWN ? EVENT_CLICKDOWN : EVENT_CLICKUP; + ev->click.button = MOUSE_BUTTON_UNKNOWN; + ev->click.x = event->button.x; + ev->click.y = event->button.y; + + for (size_t i = 0; buttons[i].value != MOUSE_BUTTON_UNKNOWN; ++i) { + if (buttons[i].key == event->button.button) { + ev->click.button = buttons[i].value; + break; + } + } +} + +bool +event_poll(union event *ev) +{ + SDL_Event event; + + /* + * Loop until we find an event we want to report, we skip unneeded + * ones. + */ + while (SDL_PollEvent(&event)) { + switch (event.type) { + case SDL_QUIT: + ev->type = EVENT_QUIT; + return true; + case SDL_KEYDOWN: + case SDL_KEYUP: + convert_key(&event, ev); + return true; + case SDL_MOUSEMOTION: + convert_mouse(&event, ev); + return true; + case SDL_MOUSEBUTTONDOWN: + case SDL_MOUSEBUTTONUP: + convert_click(&event, ev); + return true; + default: + continue; + } + } + + return false; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/event.h Wed Jan 08 13:33:41 2020 +0100 @@ -0,0 +1,80 @@ +/* + * event.h -- event management + * + * Copyright (c) 2020 David Demelier <markand@malikania.fr> + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef MOLKO_EVENT_H +#define MOLKO_EVENT_H + +/** + * \file event.h + * \brief Event management. + */ + +#include <stdbool.h> +#include <stdint.h> + +#include "key.h" +#include "mouse.h" + +/** + * \brief Kind of event. + */ +enum event_type { + EVENT_CLICKDOWN, /*!< Mouse click down */ + EVENT_CLICKUP, /*!< Mouse click released */ + EVENT_KEYDOWN, /*!< Single key down */ + EVENT_KEYUP, /*!< Single key released */ + EVENT_MOUSE, /*!< Mouse moved */ + EVENT_QUIT, /*!< Quit request */ +}; + +/** + * \brief Store events. + */ +union event { + enum event_type type; /*!< Which kind of event */ + + struct { + enum event_type type; /*!< EVENT_KEYDOWN or EVENT_KEYUP */ + enum key key; /*!< Which key */ + } key; + + struct { + enum event_type type; /*!< EVENT_MOUSE */ + enum mouse_button buttons; /*!< OR'ed buttons that are pressed */ + int32_t x; /*!< Mouse position in x */ + int32_t y; /*!< Mouse position in y */ + } mouse; + + struct { + enum event_type type; /*!< EVENT_CLICKDOWN or EVENT_CLICKUP */ + enum mouse_button button; /*!< Unique button that was pressed */ + int32_t x; /*!< Mouse position in x */ + int32_t y; /*!< Mouse position in y */ + } click; +}; + +/** + * Fetch the next event or return false if there are not. + * + * \param ev the event + * \return true if the event was filled or false otherwise + */ +bool +event_poll(union event *ev); + +#endif /* !MOLKO_EVENT_H */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/key.h Wed Jan 08 13:33:41 2020 +0100 @@ -0,0 +1,190 @@ +/* + * key.h -- keyboard definitions + * + * Copyright (c) 2020 David Demelier <markand@malikania.fr> + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef MOLKO_KEY_H +#define MOLKO_KEY_H + +/** + * \file key.h + * \brief Keyboard definitions. + */ + +/** + * \brief Key codes. + */ +enum key { + KEY_UNKNOWN, + KEY_ENTER, + KEY_ESCAPE, + KEY_BACKSPACE, + KEY_TAB, + KEY_SPACE, + KEY_EXCLAIM, + KEY_DOUBLE_QUOTE, + KEY_HASH, + KEY_PERCENT, + KEY_DOLLAR, + KEY_AMPERSAND, + KEY_QUOTE, + KEY_LEFT_PAREN, + KEY_RIGHT_PAREN, + KEY_ASTERISK, + KEY_PLUS, + KEY_COMMA, + KEY_MINUS, + KEY_PERIOD, + KEY_SLASH, + KEY_0, + KEY_1, + KEY_2, + KEY_3, + KEY_4, + KEY_5, + KEY_6, + KEY_7, + KEY_8, + KEY_9, + KEY_COLON, + KEY_SEMICOLON, + KEY_LESS, + KEY_EQUALS, + KEY_GREATER, + KEY_QUESTION, + KEY_AT, + KEY_LEFT_BRACKET, + KEY_BACKSLASH, + KEY_RIGHT_BRACKET, + KEY_CARET, + KEY_UNDERSCORE, + KEY_BACKQUOTE, + KEY_a, + KEY_b, + KEY_c, + KEY_d, + KEY_e, + KEY_f, + KEY_g, + KEY_h, + KEY_i, + KEY_j, + KEY_k, + KEY_l, + KEY_m, + KEY_n, + KEY_o, + KEY_p, + KEY_q, + KEY_r, + KEY_s, + KEY_t, + KEY_u, + KEY_v, + KEY_w, + KEY_x, + KEY_y, + KEY_z, + KEY_CAPSLOCK, + KEY_F1, + KEY_F2, + KEY_F3, + KEY_F4, + KEY_F5, + KEY_F6, + KEY_F7, + KEY_F8, + KEY_F9, + KEY_F10, + KEY_F11, + KEY_F12, + KEY_F13, + KEY_F14, + KEY_F15, + KEY_F16, + KEY_F17, + KEY_F18, + KEY_F19, + KEY_F20, + KEY_F21, + KEY_F22, + KEY_F23, + KEY_F24, + KEY_PRINTSCREEN, + KEY_SCROLLLOCK, + KEY_PAUSE, + KEY_INSERT, + KEY_HOME, + KEY_PAGEUP, + KEY_DELETE, + KEY_END, + KEY_PAGEDOWN, + KEY_RIGHT, + KEY_LEFT, + KEY_DOWN, + KEY_UP, + KEY_NUMLOCKCLEAR, + KEY_KP_DIVIDE, + KEY_KP_MULTIPLY, + KEY_KP_MINUS, + KEY_KP_PLUS, + KEY_KP_ENTER, + KEY_KP_00, + KEY_KP_000, + KEY_KP_1, + KEY_KP_2, + KEY_KP_3, + KEY_KP_4, + KEY_KP_5, + KEY_KP_6, + KEY_KP_7, + KEY_KP_8, + KEY_KP_9, + KEY_KP_0, + KEY_KP_PERIOD, + KEY_KP_COMMA, + KEY_MENU, + KEY_MUTE, + KEY_VOLUME_UP, + KEY_VOLUME_DOWN, + KEY_LCTRL, + KEY_LSHIFT, + KEY_LALT, + KEY_LSUPER, + KEY_RCTRL, + KEY_RSHIFT, + KEY_RALT, + KEY_RSUPER, +}; + +/** + * \brief Keybord modifiers. + * + * This enumeration is usually stored as OR'ed flags as several modifiers can + * be pressed at a time. + */ +enum keymod { + KEYMOD_LSHIFT = 1 << 0, /*!< Left shift */ + KEYMOD_LCTRL = 1 << 1, /*!< Left control */ + KEYMOD_LALT = 1 << 2, /*!< Left alt */ + KEYMOD_LSUPER = 1 << 3, /*!< Left super (logo) */ + KEYMOD_RSHIFT = 1 << 4, /*!< Right shift */ + KEYMOD_RCTRL = 1 << 5, /*!< Right control */ + KEYMOD_RALT = 1 << 6, /*!< Right alt */ + KEYMOD_RSUPER = 1 << 7 /*!< Right super (logo) */ +}; + +#endif /* !MOLKO_KEY_H */
--- a/src/main.c Wed Jan 08 13:25:17 2020 +0100 +++ b/src/main.c Wed Jan 08 13:33:41 2020 +0100 @@ -19,8 +19,9 @@ #include <stdio.h> #include "animation.h" +#include "clock.h" +#include "event.h" #include "font.h" -#include "clock.h" #include "image.h" #include "sprite.h" #include "texture.h" @@ -35,65 +36,36 @@ { (void)argc; (void)argv; + SDL_Init(SDL_INIT_VIDEO); TTF_Init(); IMG_Init(IMG_INIT_PNG); - struct texture *logo, *label; - struct sprite sprite; - struct clock clock; - struct font *font; - struct animation animation; - window_init("Molko's Adventure", 640, 480); window_set_color(0x667788ff); - clock_start(&clock); - - logo = image_openf("E:\\dev\\molko\\explosion.png"); - font = font_openf("E:\\dev\\molko\\DejaVuSans.ttf", 10); - - if (!logo || !font) { - printf("%s\n", SDL_GetError()); - exit(1); - } + for (;;) { + union event ev; - label = font_render(font, "Hello World", 0xffffffff); - sprite_init(&sprite, logo, 256, 256); - animation_init(&animation, &sprite, 20); - - setvbuf(stdout, NULL, _IONBF, 0); - - while (!animation_is_complete(&animation)) { - uint64_t ticks = clock_elapsed(&clock); - - clock_start(&clock); - - SDL_Event ev; - while (SDL_PollEvent(&ev)) { + while (event_poll(&ev)) { switch (ev.type) { - case SDL_QUIT: + case EVENT_QUIT: return 0; + case EVENT_MOUSE: + printf("mouse moved to %d, %d, state: %d\n", ev.mouse.x, ev.mouse.y, ev.mouse.buttons); + break; + case EVENT_CLICKDOWN: + printf("mouse click on %d, %d, which: %d\n", ev.click.x, ev.click.y, ev.click.button); + break; + default: + break; } } - animation_update(&animation, ticks); window_clear(); - texture_draw(label, 30, 30); - animation_draw(&animation, 10, 10); window_present(); SDL_Delay(50); } -#if 0 - window_set_color(0xffffffff); - window_draw_line(50, 50, 100, 100); - window_draw_point(60, 60); - window_draw_rectangle(true, 20, 20, 70, 10); - logo = image_openf("E:\\Charactervector.png"); - sprite_init(&sprite, logo, 65, 100); - sprite_draw(&sprite, 1, 2, 400, 400); -#endif - return 0; }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/mouse.h Wed Jan 08 13:33:41 2020 +0100 @@ -0,0 +1,42 @@ +/* + * mouse.h -- mouse definitions + * + * Copyright (c) 2020 David Demelier <markand@malikania.fr> + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef MOLKO_MOUSE_H +#define MOLKO_MOUSE_H + +/** + * \file mouse.h + * \brief Mouse definitions. + */ + +/** + * \brief Buttons from mouse. + * + * This enumeration is used as both flags or constants. For example when the + * user press one button on the mouse it generates one constant event. On the + * other hand, while moving the mouse the user may have one or more buttons + * pressed, thus the OR'ed combination. + */ +enum mouse_button { + MOUSE_BUTTON_UNKNOWN = 0, /*!< No buttons pressed */ + MOUSE_BUTTON_LEFT = (1 << 0), /*!< Left button pressed */ + MOUSE_BUTTON_MIDDLE = (1 << 1), /*!< Middle button pressed */ + MOUSE_BUTTON_RIGHT = (1 << 2) /*!< Right button pressed */ +}; + +#endif /* !MOLKO_MOUSE_H */