Changeset 681


Ignore:
Timestamp:
Mar 23, 2006, 7:36:59 PM (14 years ago)
Author:
Sam Hocevar
Message:
  • Massive rework of the event handling code, as per the TODO list.
Location:
libcaca/trunk
Files:
26 edited

Legend:

Unmodified
Added
Removed
  • libcaca/trunk/caca/caca.c

    r672 r681  
    7575    kk->events.last_key_ticks = 0;
    7676    kk->events.autorepeat_ticks = 0;
    77     kk->events.last_key = 0;
    78 #endif
    79 #if defined(USE_SLANG) || defined(USE_NCURSES) || defined(USE_CONIO)
     77    kk->events.last_key_event.type = CACA_EVENT_NONE;
     78#endif
     79#if defined(USE_SLANG) || defined(USE_NCURSES) || defined(USE_CONIO) || defined(USE_GL)
    8080    kk->events.queue = 0;
    8181#endif
  • libcaca/trunk/caca/caca.h

    r672 r681  
    114114 *  Event types returned by caca_get_event().
    115115 */
    116 enum caca_event
    117 {
    118     CACA_EVENT_NONE =          0x00000000, /**< No event. */
    119     CACA_EVENT_KEY_PRESS =     0x01000000, /**< A key was pressed. */
    120     CACA_EVENT_KEY_RELEASE =   0x02000000, /**< A key was released. */
    121     CACA_EVENT_MOUSE_PRESS =   0x04000000, /**< A mouse button was pressed. */
    122     CACA_EVENT_MOUSE_RELEASE = 0x08000000, /**< A mouse button was released. */
    123     CACA_EVENT_MOUSE_MOTION =  0x10000000, /**< The mouse was moved. */
    124     CACA_EVENT_RESIZE =        0x20000000, /**< The window was resized. */
    125     CACA_EVENT_ANY =           0xff000000  /**< Bitmask for any event. */
     116enum caca_event_type
     117{
     118    CACA_EVENT_NONE =          0x0000, /**< No event. */
     119
     120    CACA_EVENT_KEY_PRESS =     0x0001, /**< A key was pressed. */
     121    CACA_EVENT_KEY_RELEASE =   0x0002, /**< A key was released. */
     122    CACA_EVENT_MOUSE_PRESS =   0x0004, /**< A mouse button was pressed. */
     123    CACA_EVENT_MOUSE_RELEASE = 0x0008, /**< A mouse button was released. */
     124    CACA_EVENT_MOUSE_MOTION =  0x0010, /**< The mouse was moved. */
     125    CACA_EVENT_RESIZE =        0x0020, /**< The window was resized. */
     126
     127    CACA_EVENT_ANY =           0xffff  /**< Bitmask for any event. */
     128};
     129
     130struct caca_event
     131{
     132    enum caca_event_type type;
     133    union
     134    {
     135        struct { unsigned int x, y, button; } mouse;
     136        struct { unsigned int w, h; } resize;
     137        struct { unsigned int c; unsigned long int ucs4; char utf8[8]; } key;
     138    } data;
    126139};
    127140
     
    197210 *
    198211 *  @{ */
    199 unsigned int caca_get_event(caca_t *kk, unsigned int);
    200 unsigned int caca_wait_event(caca_t *kk, unsigned int);
     212int caca_get_event(caca_t *kk, unsigned int, struct caca_event *);
     213int caca_wait_event(caca_t *kk, unsigned int, struct caca_event *);
    201214unsigned int caca_get_mouse_x(caca_t *kk);
    202215unsigned int caca_get_mouse_y(caca_t *kk);
  • libcaca/trunk/caca/caca_internals.h

    r672 r681  
    116116        void (* display) (caca_t *);
    117117        void (* handle_resize) (caca_t *);
    118         unsigned int (* get_event) (caca_t *);
     118        int (* get_event) (caca_t *, struct caca_event *);
    119119    } drv;
    120120
     
    140140    struct events
    141141    {
    142 #if defined(USE_SLANG) || defined(USE_NCURSES) || defined(USE_CONIO)
    143         unsigned int buf[EVENTBUF_LEN];
     142#if defined(USE_SLANG) || defined(USE_NCURSES) || defined(USE_CONIO) || defined(USE_GL)
     143        struct caca_event buf[EVENTBUF_LEN];
    144144        int queue;
    145145#endif
     
    148148        unsigned int last_key_ticks;
    149149        unsigned int autorepeat_ticks;
    150         unsigned int last_key;
     150        struct caca_event last_key_event;
    151151#endif
    152152    } events;
     
    159159/* Internal event functions */
    160160extern void _caca_handle_resize(caca_t *);
    161 #if defined(USE_SLANG) || defined(USE_NCURSES) || defined(USE_CONIO)
    162 extern void _push_event(caca_t *, unsigned int);
    163 extern unsigned int _pop_event(caca_t *);
     161#if defined(USE_SLANG) || defined(USE_NCURSES) || defined(USE_CONIO) || defined(USE_GL)
     162extern void _push_event(caca_t *, struct caca_event *);
     163extern int _pop_event(caca_t *, struct caca_event *);
    164164#endif
    165165
  • libcaca/trunk/caca/driver_conio.c

    r672 r681  
    122122}
    123123
    124 static unsigned int conio_get_event(caca_t *kk)
     124static int conio_get_event(caca_t *kk, struct caca_event *ev)
    125125{
    126     unsigned int event;
     126    unsigned char ch;
     127    struct caca_event release;
    127128
    128129    if(!_conio_kbhit())
    129         return CACA_EVENT_NONE;
     130    {
     131        ev->type = CACA_EVENT_NONE;
     132        return 0;
     133    }
    130134
    131     event = getch();
    132     _push_event(kk, CACA_EVENT_KEY_RELEASE | event);
    133     return CACA_EVENT_KEY_PRESS | event;
     135    ch = getch();
     136
     137    ev->type = CACA_EVENT_KEY_PRESS;
     138    ev->data.key.c = ch;
     139    ev->data.key.ucs4 = (uint32_t)ch;
     140    ev->data.key.utf8[0] = ch;
     141    ev->data.key.utf8[1] = '\0';
     142
     143    release = *ev;
     144    release.type = CACA_EVENT_KEY_RELEASE;
     145    _push_event(kk, &release);
     146
     147    return 1;
    134148}
    135149
  • libcaca/trunk/caca/driver_gl.c

    r672 r681  
    309309}
    310310
    311 static unsigned int gl_get_event(caca_t *kk)
    312 {
    313     unsigned int event = 0;
    314 
     311static int gl_get_event(caca_t *kk, struct caca_event *ev)
     312{
    315313    glutMainLoopEvent();
    316314
    317315    if(kk->resize.resized)
    318         return CACA_EVENT_RESIZE;
     316    {
     317        ev->type = CACA_EVENT_RESIZE;
     318        ev->data.resize.w = kk->qq->width;
     319        ev->data.resize.h = kk->qq->height;
     320        return 1;
     321    }
    319322
    320323    if(kk->drv.p->mouse_changed)
    321324    {
     325        ev->type = CACA_EVENT_MOUSE_MOTION;
     326        ev->data.mouse.x = kk->mouse.x;
     327        ev->data.mouse.y = kk->mouse.y;
     328        kk->drv.p->mouse_changed = 0;
     329
    322330        if(kk->drv.p->mouse_clicked)
    323331        {
    324             event |= CACA_EVENT_MOUSE_PRESS | kk->drv.p->mouse_button;
     332            _push_event(kk, ev);
     333            ev->type = CACA_EVENT_MOUSE_PRESS;
     334            ev->data.mouse.button = kk->drv.p->mouse_button;
    325335            kk->drv.p->mouse_clicked = 0;
    326336        }
    327         kk->mouse.x = kk->drv.p->mouse_x;
    328         kk->mouse.y = kk->drv.p->mouse_y;
    329         event |= CACA_EVENT_MOUSE_MOTION | (kk->mouse.x << 12) | kk->mouse.y;
    330         kk->drv.p->mouse_changed = 0;
     337
     338        return 1;
    331339    }
    332340
    333341    if(kk->drv.p->key != 0)
    334342    {
    335         event |= CACA_EVENT_KEY_PRESS;
    336         event |= kk->drv.p->key;
     343        ev->type = CACA_EVENT_KEY_PRESS;
     344        ev->data.key.c = kk->drv.p->key;
     345        ev->data.key.ucs4 = (uint32_t)kk->drv.p->key;
     346        ev->data.key.utf8[0] = kk->drv.p->key;
     347        ev->data.key.utf8[1] = '\0';
    337348        kk->drv.p->key = 0;
    338         return event;
     349        return 1;
    339350    }
    340351
    341352    if(kk->drv.p->special_key != 0)
    342353    {
    343         event |= CACA_EVENT_KEY_PRESS;
    344 
    345354        switch(kk->drv.p->special_key)
    346355        {
    347             case GLUT_KEY_F1 : kk->drv.p->special_key = 0; return event | CACA_KEY_F1;
    348             case GLUT_KEY_F2 : kk->drv.p->special_key = 0; return event | CACA_KEY_F2;
    349             case GLUT_KEY_F3 : kk->drv.p->special_key = 0; return event | CACA_KEY_F3;
    350             case GLUT_KEY_F4 : kk->drv.p->special_key = 0; return event | CACA_KEY_F4;
    351             case GLUT_KEY_F5 : kk->drv.p->special_key = 0; return event | CACA_KEY_F5;
    352             case GLUT_KEY_F6 : kk->drv.p->special_key = 0; return event | CACA_KEY_F6;
    353             case GLUT_KEY_F7 : kk->drv.p->special_key = 0; return event | CACA_KEY_F7;
    354             case GLUT_KEY_F8 : kk->drv.p->special_key = 0; return event | CACA_KEY_F8;
    355             case GLUT_KEY_F9 : kk->drv.p->special_key = 0; return event | CACA_KEY_F9;
    356             case GLUT_KEY_F10: kk->drv.p->special_key = 0; return event | CACA_KEY_F10;
    357             case GLUT_KEY_F11: kk->drv.p->special_key = 0; return event | CACA_KEY_F11;
    358             case GLUT_KEY_F12: kk->drv.p->special_key = 0; return event | CACA_KEY_F12;
    359             case GLUT_KEY_LEFT : kk->drv.p->special_key = 0; return event | CACA_KEY_LEFT;
    360             case GLUT_KEY_RIGHT: kk->drv.p->special_key = 0; return event | CACA_KEY_RIGHT;
    361             case GLUT_KEY_UP   : kk->drv.p->special_key = 0; return event | CACA_KEY_UP;
    362             case GLUT_KEY_DOWN : kk->drv.p->special_key = 0; return event | CACA_KEY_DOWN;
    363             default: return CACA_EVENT_NONE;
     356            case GLUT_KEY_F1 : ev->data.key.c = CACA_KEY_F1; break;
     357            case GLUT_KEY_F2 : ev->data.key.c = CACA_KEY_F2; break;
     358            case GLUT_KEY_F3 : ev->data.key.c = CACA_KEY_F3; break;
     359            case GLUT_KEY_F4 : ev->data.key.c = CACA_KEY_F4; break;
     360            case GLUT_KEY_F5 : ev->data.key.c = CACA_KEY_F5; break;
     361            case GLUT_KEY_F6 : ev->data.key.c = CACA_KEY_F6; break;
     362            case GLUT_KEY_F7 : ev->data.key.c = CACA_KEY_F7; break;
     363            case GLUT_KEY_F8 : ev->data.key.c = CACA_KEY_F8; break;
     364            case GLUT_KEY_F9 : ev->data.key.c = CACA_KEY_F9; break;
     365            case GLUT_KEY_F10: ev->data.key.c = CACA_KEY_F10; break;
     366            case GLUT_KEY_F11: ev->data.key.c = CACA_KEY_F11; break;
     367            case GLUT_KEY_F12: ev->data.key.c = CACA_KEY_F12; break;
     368            case GLUT_KEY_LEFT : ev->data.key.c = CACA_KEY_LEFT; break;
     369            case GLUT_KEY_RIGHT: ev->data.key.c = CACA_KEY_RIGHT; break;
     370            case GLUT_KEY_UP   : ev->data.key.c = CACA_KEY_UP; break;
     371            case GLUT_KEY_DOWN : ev->data.key.c = CACA_KEY_DOWN; break;
     372            default: ev->type = CACA_EVENT_NONE; return 0;
    364373        }
    365     }
    366     return CACA_EVENT_NONE;
     374
     375        ev->type = CACA_EVENT_KEY_PRESS;
     376        ev->data.key.ucs4 = 0;
     377        ev->data.key.utf8[0] = '\0';
     378
     379        kk->drv.p->special_key = 0;
     380        return 1;
     381    }
     382
     383    ev->type = CACA_EVENT_NONE;
     384    return 0;
    367385}
    368386
  • libcaca/trunk/caca/driver_ncurses.c

    r672 r681  
    227227}
    228228
    229 static unsigned int ncurses_get_event(caca_t *kk)
    230 {
    231     unsigned int event;
     229static int ncurses_get_event(caca_t *kk, struct caca_event *ev)
     230{
    232231    int intkey;
    233232
    234233    intkey = getch();
    235234    if(intkey == ERR)
    236         return CACA_EVENT_NONE;
     235    {
     236        ev->type = CACA_EVENT_NONE;
     237        return 0;
     238    }
    237239
    238240    if(intkey < 0x100)
    239241    {
    240         return CACA_EVENT_KEY_PRESS | intkey;
     242        ev->type = CACA_EVENT_KEY_PRESS;
     243        ev->data.key.c = intkey;
     244        return 1;
    241245    }
    242246
     
    249253        {
    250254            case BUTTON1_PRESSED:
    251                 _push_event(kk, CACA_EVENT_MOUSE_PRESS | 1);
     255                ev->data.mouse.button = 1;
     256                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
    252257                break;
    253258            case BUTTON1_RELEASED:
    254                 _push_event(kk, CACA_EVENT_MOUSE_RELEASE | 1);
     259                ev->data.mouse.button = 1;
     260                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
    255261                break;
    256262            case BUTTON1_CLICKED:
    257                 _push_event(kk, CACA_EVENT_MOUSE_PRESS | 1);
    258                 _push_event(kk, CACA_EVENT_MOUSE_RELEASE | 1);
     263                ev->data.mouse.button = 1;
     264                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
     265                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
    259266                break;
    260267            case BUTTON1_DOUBLE_CLICKED:
    261                 _push_event(kk, CACA_EVENT_MOUSE_PRESS | 1);
    262                 _push_event(kk, CACA_EVENT_MOUSE_RELEASE | 1);
    263                 _push_event(kk, CACA_EVENT_MOUSE_PRESS | 1);
    264                 _push_event(kk, CACA_EVENT_MOUSE_RELEASE | 1);
     268                ev->data.mouse.button = 1;
     269                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
     270                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
     271                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
     272                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
    265273                break;
    266274            case BUTTON1_TRIPLE_CLICKED:
    267                 _push_event(kk, CACA_EVENT_MOUSE_PRESS | 1);
    268                 _push_event(kk, CACA_EVENT_MOUSE_RELEASE | 1);
    269                 _push_event(kk, CACA_EVENT_MOUSE_PRESS | 1);
    270                 _push_event(kk, CACA_EVENT_MOUSE_RELEASE | 1);
    271                 _push_event(kk, CACA_EVENT_MOUSE_PRESS | 1);
    272                 _push_event(kk, CACA_EVENT_MOUSE_RELEASE | 1);
     275                ev->data.mouse.button = 1;
     276                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
     277                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
     278                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
     279                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
     280                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
     281                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
    273282                break;
    274283            case BUTTON1_RESERVED_EVENT:
     
    276285
    277286            case BUTTON2_PRESSED:
    278                 _push_event(kk, CACA_EVENT_MOUSE_PRESS | 2);
     287                ev->data.mouse.button = 2;
     288                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
    279289                break;
    280290            case BUTTON2_RELEASED:
    281                 _push_event(kk, CACA_EVENT_MOUSE_RELEASE | 2);
     291                ev->data.mouse.button = 2;
     292                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
    282293                break;
    283294            case BUTTON2_CLICKED:
    284                 _push_event(kk, CACA_EVENT_MOUSE_PRESS | 2);
    285                 _push_event(kk, CACA_EVENT_MOUSE_RELEASE | 2);
     295                ev->data.mouse.button = 2;
     296                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
     297                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
    286298                break;
    287299            case BUTTON2_DOUBLE_CLICKED:
    288                 _push_event(kk, CACA_EVENT_MOUSE_PRESS | 2);
    289                 _push_event(kk, CACA_EVENT_MOUSE_RELEASE | 2);
    290                 _push_event(kk, CACA_EVENT_MOUSE_PRESS | 2);
    291                 _push_event(kk, CACA_EVENT_MOUSE_RELEASE | 2);
     300                ev->data.mouse.button = 2;
     301                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
     302                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
     303                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
     304                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
    292305                break;
    293306            case BUTTON2_TRIPLE_CLICKED:
    294                 _push_event(kk, CACA_EVENT_MOUSE_PRESS | 2);
    295                 _push_event(kk, CACA_EVENT_MOUSE_RELEASE | 2);
    296                 _push_event(kk, CACA_EVENT_MOUSE_PRESS | 2);
    297                 _push_event(kk, CACA_EVENT_MOUSE_RELEASE | 2);
    298                 _push_event(kk, CACA_EVENT_MOUSE_PRESS | 2);
    299                 _push_event(kk, CACA_EVENT_MOUSE_RELEASE | 2);
     307                ev->data.mouse.button = 2;
     308                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
     309                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
     310                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
     311                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
     312                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
     313                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
    300314                break;
    301315            case BUTTON2_RESERVED_EVENT:
     
    303317
    304318            case BUTTON3_PRESSED:
    305                 _push_event(kk, CACA_EVENT_MOUSE_PRESS | 3);
     319                ev->data.mouse.button = 3;
     320                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
    306321                break;
    307322            case BUTTON3_RELEASED:
    308                 _push_event(kk, CACA_EVENT_MOUSE_RELEASE | 3);
     323                ev->data.mouse.button = 3;
     324                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
    309325                break;
    310326            case BUTTON3_CLICKED:
    311                 _push_event(kk, CACA_EVENT_MOUSE_PRESS | 3);
    312                 _push_event(kk, CACA_EVENT_MOUSE_RELEASE | 3);
     327                ev->data.mouse.button = 3;
     328                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
     329                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
    313330                break;
    314331            case BUTTON3_DOUBLE_CLICKED:
    315                 _push_event(kk, CACA_EVENT_MOUSE_PRESS | 3);
    316                 _push_event(kk, CACA_EVENT_MOUSE_RELEASE | 3);
    317                 _push_event(kk, CACA_EVENT_MOUSE_PRESS | 3);
    318                 _push_event(kk, CACA_EVENT_MOUSE_RELEASE | 3);
     332                ev->data.mouse.button = 3;
     333                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
     334                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
     335                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
     336                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
    319337                break;
    320338            case BUTTON3_TRIPLE_CLICKED:
    321                 _push_event(kk, CACA_EVENT_MOUSE_PRESS | 3);
    322                 _push_event(kk, CACA_EVENT_MOUSE_RELEASE | 3);
    323                 _push_event(kk, CACA_EVENT_MOUSE_PRESS | 3);
    324                 _push_event(kk, CACA_EVENT_MOUSE_RELEASE | 3);
    325                 _push_event(kk, CACA_EVENT_MOUSE_PRESS | 3);
    326                 _push_event(kk, CACA_EVENT_MOUSE_RELEASE | 3);
     339                ev->data.mouse.button = 3;
     340                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
     341                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
     342                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
     343                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
     344                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
     345                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
    327346                break;
    328347            case BUTTON3_RESERVED_EVENT:
     
    330349
    331350            case BUTTON4_PRESSED:
    332                 _push_event(kk, CACA_EVENT_MOUSE_PRESS | 4);
     351                ev->data.mouse.button = 4;
     352                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
    333353                break;
    334354            case BUTTON4_RELEASED:
    335                 _push_event(kk, CACA_EVENT_MOUSE_RELEASE | 4);
     355                ev->data.mouse.button = 4;
     356                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
    336357                break;
    337358            case BUTTON4_CLICKED:
    338                 _push_event(kk, CACA_EVENT_MOUSE_PRESS | 4);
    339                 _push_event(kk, CACA_EVENT_MOUSE_RELEASE | 4);
     359                ev->data.mouse.button = 4;
     360                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
     361                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
    340362                break;
    341363            case BUTTON4_DOUBLE_CLICKED:
    342                 _push_event(kk, CACA_EVENT_MOUSE_PRESS | 4);
    343                 _push_event(kk, CACA_EVENT_MOUSE_RELEASE | 4);
    344                 _push_event(kk, CACA_EVENT_MOUSE_PRESS | 4);
    345                 _push_event(kk, CACA_EVENT_MOUSE_RELEASE | 4);
     364                ev->data.mouse.button = 4;
     365                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
     366                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
     367                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
     368                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
    346369                break;
    347370            case BUTTON4_TRIPLE_CLICKED:
    348                 _push_event(kk, CACA_EVENT_MOUSE_PRESS | 4);
    349                 _push_event(kk, CACA_EVENT_MOUSE_RELEASE | 4);
    350                 _push_event(kk, CACA_EVENT_MOUSE_PRESS | 4);
    351                 _push_event(kk, CACA_EVENT_MOUSE_RELEASE | 4);
    352                 _push_event(kk, CACA_EVENT_MOUSE_PRESS | 4);
    353                 _push_event(kk, CACA_EVENT_MOUSE_RELEASE | 4);
     371                ev->data.mouse.button = 4;
     372                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
     373                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
     374                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
     375                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
     376                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
     377                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
    354378                break;
    355379            case BUTTON4_RESERVED_EVENT:
     
    362386        if(kk->mouse.x == (unsigned int)mevent.x &&
    363387           kk->mouse.y == (unsigned int)mevent.y)
    364             return _pop_event(kk);
     388            return _pop_event(kk, ev);
    365389
    366390        kk->mouse.x = mevent.x;
    367391        kk->mouse.y = mevent.y;
    368392
    369         return CACA_EVENT_MOUSE_MOTION | (kk->mouse.x << 12) | kk->mouse.y;
    370     }
    371 
    372     event = CACA_EVENT_KEY_PRESS;
     393        ev->type = CACA_EVENT_MOUSE_MOTION;
     394        ev->data.mouse.x = kk->mouse.x;
     395        ev->data.mouse.y = kk->mouse.y;
     396        return 1;
     397    }
    373398
    374399    switch(intkey)
    375400    {
    376         case KEY_UP: return event | CACA_KEY_UP;
    377         case KEY_DOWN: return event | CACA_KEY_DOWN;
    378         case KEY_LEFT: return event | CACA_KEY_LEFT;
    379         case KEY_RIGHT: return event | CACA_KEY_RIGHT;
    380 
    381         case KEY_IC: return event | CACA_KEY_INSERT;
    382         case KEY_DC: return event | CACA_KEY_DELETE;
    383         case KEY_HOME: return event | CACA_KEY_HOME;
    384         case KEY_END: return event | CACA_KEY_END;
    385         case KEY_PPAGE: return event | CACA_KEY_PAGEUP;
    386         case KEY_NPAGE: return event | CACA_KEY_PAGEDOWN;
    387 
    388         case KEY_F(1): return event | CACA_KEY_F1;
    389         case KEY_F(2): return event | CACA_KEY_F2;
    390         case KEY_F(3): return event | CACA_KEY_F3;
    391         case KEY_F(4): return event | CACA_KEY_F4;
    392         case KEY_F(5): return event | CACA_KEY_F5;
    393         case KEY_F(6): return event | CACA_KEY_F6;
    394         case KEY_F(7): return event | CACA_KEY_F7;
    395         case KEY_F(8): return event | CACA_KEY_F8;
    396         case KEY_F(9): return event | CACA_KEY_F9;
    397         case KEY_F(10): return event | CACA_KEY_F10;
    398         case KEY_F(11): return event | CACA_KEY_F11;
    399         case KEY_F(12): return event | CACA_KEY_F12;
    400     }
    401 
    402     return CACA_EVENT_NONE;
     401        case KEY_UP: ev->data.key.c = CACA_KEY_UP; break;
     402        case KEY_DOWN: ev->data.key.c = CACA_KEY_DOWN; break;
     403        case KEY_LEFT: ev->data.key.c = CACA_KEY_LEFT; break;
     404        case KEY_RIGHT: ev->data.key.c = CACA_KEY_RIGHT; break;
     405
     406        case KEY_IC: ev->data.key.c = CACA_KEY_INSERT; break;
     407        case KEY_DC: ev->data.key.c = CACA_KEY_DELETE; break;
     408        case KEY_HOME: ev->data.key.c = CACA_KEY_HOME; break;
     409        case KEY_END: ev->data.key.c = CACA_KEY_END; break;
     410        case KEY_PPAGE: ev->data.key.c = CACA_KEY_PAGEUP; break;
     411        case KEY_NPAGE: ev->data.key.c = CACA_KEY_PAGEDOWN; break;
     412
     413        case KEY_F(1): ev->data.key.c = CACA_KEY_F1; break;
     414        case KEY_F(2): ev->data.key.c = CACA_KEY_F2; break;
     415        case KEY_F(3): ev->data.key.c = CACA_KEY_F3; break;
     416        case KEY_F(4): ev->data.key.c = CACA_KEY_F4; break;
     417        case KEY_F(5): ev->data.key.c = CACA_KEY_F5; break;
     418        case KEY_F(6): ev->data.key.c = CACA_KEY_F6; break;
     419        case KEY_F(7): ev->data.key.c = CACA_KEY_F7; break;
     420        case KEY_F(8): ev->data.key.c = CACA_KEY_F8; break;
     421        case KEY_F(9): ev->data.key.c = CACA_KEY_F9; break;
     422        case KEY_F(10): ev->data.key.c = CACA_KEY_F10; break;
     423        case KEY_F(11): ev->data.key.c = CACA_KEY_F11; break;
     424        case KEY_F(12): ev->data.key.c = CACA_KEY_F12; break;
     425
     426        default: ev->type = CACA_EVENT_NONE; return 0;
     427    }
     428
     429    ev->type = CACA_EVENT_KEY_PRESS;
     430    ev->data.key.ucs4 = 0;
     431    ev->data.key.utf8[0] = '\0';
     432    return 1;
    403433}
    404434
  • libcaca/trunk/caca/driver_network.c

    r672 r681  
    284284}
    285285
    286 static unsigned int network_get_event(caca_t *kk)
     286static int network_get_event(caca_t *kk, struct caca_event *ev)
    287287{
    288288    /* Manage new connections as this function will be called sometimes
  • libcaca/trunk/caca/driver_slang.c

    r672 r681  
    255255}
    256256
    257 static unsigned int slang_get_event(caca_t *kk)
    258 {
    259     unsigned int event;
     257static int slang_get_event(caca_t *kk, struct caca_event *ev)
     258{
    260259    int intkey;
    261260
    262261    if(!SLang_input_pending(0))
    263         return CACA_EVENT_NONE;
     262    {
     263        ev->type = CACA_EVENT_NONE;
     264        return 0;
     265    }
    264266
    265267    /* We first use SLang_getkey() to see whether Esc was pressed
     
    277279    if(intkey < 0x100)
    278280    {
    279         return CACA_EVENT_KEY_PRESS | intkey;
     281        ev->type = CACA_EVENT_KEY_PRESS;
     282        ev->data.key.c = intkey;
     283        return 1;
    280284    }
    281285
     
    285289        unsigned int x = SLang_getkey() - '!';
    286290        unsigned int y = SLang_getkey() - '!';
    287         _push_event(kk, CACA_EVENT_MOUSE_PRESS | button);
    288         _push_event(kk, CACA_EVENT_MOUSE_RELEASE | button);
     291
     292        ev->data.mouse.button = button;
     293        ev->type = CACA_EVENT_MOUSE_PRESS;
     294        _push_event(kk, ev);
     295        ev->type = CACA_EVENT_MOUSE_RELEASE;
     296        _push_event(kk, ev);
    289297
    290298        if(kk->mouse.x == x && kk->mouse.y == y)
    291             return _pop_event(kk);
     299            return _pop_event(kk, ev);
    292300
    293301        kk->mouse.x = x;
    294302        kk->mouse.y = y;
    295303
    296         return CACA_EVENT_MOUSE_MOTION | (kk->mouse.x << 12) | kk->mouse.y;
    297     }
    298 
    299     event = CACA_EVENT_KEY_PRESS;
     304        ev->type = CACA_EVENT_MOUSE_MOTION;
     305        ev->data.mouse.x = kk->mouse.x;
     306        ev->data.mouse.y = kk->mouse.y;
     307        return 1;
     308    }
    300309
    301310    switch(intkey)
    302311    {
    303         case SL_KEY_UP: return event | CACA_KEY_UP;
    304         case SL_KEY_DOWN: return event | CACA_KEY_DOWN;
    305         case SL_KEY_LEFT: return event | CACA_KEY_LEFT;
    306         case SL_KEY_RIGHT: return event | CACA_KEY_RIGHT;
    307 
    308         case SL_KEY_IC: return event | CACA_KEY_INSERT;
    309         case SL_KEY_DELETE: return event | CACA_KEY_DELETE;
    310         case SL_KEY_HOME: return event | CACA_KEY_HOME;
    311         case SL_KEY_END: return event | CACA_KEY_END;
    312         case SL_KEY_PPAGE: return event | CACA_KEY_PAGEUP;
    313         case SL_KEY_NPAGE: return event | CACA_KEY_PAGEDOWN;
    314 
    315         case SL_KEY_F(1): return event | CACA_KEY_F1;
    316         case SL_KEY_F(2): return event | CACA_KEY_F2;
    317         case SL_KEY_F(3): return event | CACA_KEY_F3;
    318         case SL_KEY_F(4): return event | CACA_KEY_F4;
    319         case SL_KEY_F(5): return event | CACA_KEY_F5;
    320         case SL_KEY_F(6): return event | CACA_KEY_F6;
    321         case SL_KEY_F(7): return event | CACA_KEY_F7;
    322         case SL_KEY_F(8): return event | CACA_KEY_F8;
    323         case SL_KEY_F(9): return event | CACA_KEY_F9;
    324         case SL_KEY_F(10): return event | CACA_KEY_F10;
    325         case SL_KEY_F(11): return event | CACA_KEY_F11;
    326         case SL_KEY_F(12): return event | CACA_KEY_F12;
    327     }
    328 
    329     return CACA_EVENT_NONE;
     312        case SL_KEY_UP: ev->data.key.c = CACA_KEY_UP; break;
     313        case SL_KEY_DOWN: ev->data.key.c = CACA_KEY_DOWN; break;
     314        case SL_KEY_LEFT: ev->data.key.c = CACA_KEY_LEFT; break;
     315        case SL_KEY_RIGHT: ev->data.key.c = CACA_KEY_RIGHT; break;
     316
     317        case SL_KEY_IC: ev->data.key.c = CACA_KEY_INSERT; break;
     318        case SL_KEY_DELETE: ev->data.key.c = CACA_KEY_DELETE; break;
     319        case SL_KEY_HOME: ev->data.key.c = CACA_KEY_HOME; break;
     320        case SL_KEY_END: ev->data.key.c = CACA_KEY_END; break;
     321        case SL_KEY_PPAGE: ev->data.key.c = CACA_KEY_PAGEUP; break;
     322        case SL_KEY_NPAGE: ev->data.key.c = CACA_KEY_PAGEDOWN; break;
     323
     324        case SL_KEY_F(1): ev->data.key.c = CACA_KEY_F1; break;
     325        case SL_KEY_F(2): ev->data.key.c = CACA_KEY_F2; break;
     326        case SL_KEY_F(3): ev->data.key.c = CACA_KEY_F3; break;
     327        case SL_KEY_F(4): ev->data.key.c = CACA_KEY_F4; break;
     328        case SL_KEY_F(5): ev->data.key.c = CACA_KEY_F5; break;
     329        case SL_KEY_F(6): ev->data.key.c = CACA_KEY_F6; break;
     330        case SL_KEY_F(7): ev->data.key.c = CACA_KEY_F7; break;
     331        case SL_KEY_F(8): ev->data.key.c = CACA_KEY_F8; break;
     332        case SL_KEY_F(9): ev->data.key.c = CACA_KEY_F9; break;
     333        case SL_KEY_F(10): ev->data.key.c = CACA_KEY_F10; break;
     334        case SL_KEY_F(11): ev->data.key.c = CACA_KEY_F11; break;
     335        case SL_KEY_F(12): ev->data.key.c = CACA_KEY_F12; break;
     336
     337        default: ev->type = CACA_EVENT_NONE; return 0;
     338    }
     339
     340    ev->type = CACA_EVENT_KEY_PRESS;
     341    ev->data.key.ucs4 = 0;
     342    ev->data.key.utf8[0] = '\0';
     343    return 1;
    330344}
    331345
  • libcaca/trunk/caca/driver_vga.c

    r672 r681  
    135135}
    136136
    137 static unsigned int vga_get_event(caca_t *kk)
     137static int vga_get_event(caca_t *kk, struct caca_event *ev)
    138138{
    139139    /* FIXME */
    140     return CACA_EVENT_NONE;
     140    ev->type = CACA_EVENT_NONE;
     141    return 0;
    141142}
    142143
  • libcaca/trunk/caca/driver_win32.c

    r672 r681  
    236236}
    237237
    238 static unsigned int win32_get_event(caca_t *kk)
     238static int win32_get_event(caca_t *kk, struct caca_event *ev)
    239239{
    240240    INPUT_RECORD rec;
     
    253253
    254254            if(rec.Event.KeyEvent.bKeyDown)
    255                 event = CACA_EVENT_KEY_PRESS;
     255                ev->type = CACA_EVENT_KEY_PRESS;
    256256            else
    257                 event = CACA_EVENT_KEY_RELEASE;
     257                ev->type = CACA_EVENT_KEY_RELEASE;
    258258
    259259            if(rec.Event.KeyEvent.uChar.AsciiChar)
    260                 return event | rec.Event.KeyEvent.uChar.AsciiChar;
     260            {
     261                ev->data.key.c = rec.Event.KeyEvent.uChar.AsciiChar;
     262                ev->data.key.ucs4 = (uint32_t)ev->data.key.c;
     263                ev->data.key.utf8[0] = ev->data.key.c;
     264                ev->data.key.utf8[1] = '\0';
     265
     266                return 1;
     267            }
    261268        }
    262269
     
    266273            {
    267274                if(rec.Event.MouseEvent.dwButtonState & 0x01)
    268                     return CACA_EVENT_MOUSE_PRESS | 0x000001;
     275                {
     276                    ev->type = CACA_EVENT_MOUSE_PRESS;
     277                    ev->data.mouse.button = 1;
     278                    return 1;
     279                }
    269280
    270281                if(rec.Event.MouseEvent.dwButtonState & 0x02)
    271                     return CACA_EVENT_MOUSE_PRESS | 0x000002;
     282                {
     283                    ev->type = CACA_EVENT_MOUSE_PRESS;
     284                    ev->data.mouse.button = 2;
     285                    return 1;
     286                }
    272287            }
    273288            else if(rec.Event.MouseEvent.dwEventFlags == MOUSE_MOVED)
     
    282297                kk->mouse.y = pos.Y;
    283298
    284                 return CACA_EVENT_MOUSE_MOTION
    285                         | (kk->mouse.x << 12) | kk->mouse.y;
     299                ev->type = CACA_EVENT_MOUSE_MOTION;
     300                ev->data.mouse.x = kk->mouse.x;
     301                ev->data.mouse.y = kk->mouse.y;
     302                return 1;
    286303            }
    287304#if 0
     
    304321
    305322        /* Unknown event */
    306         return CACA_EVENT_NONE;
     323        ev->type = CACA_EVENT_NONE;
     324        return 0;
    307325    }
    308326
    309327    /* No event */
    310     return CACA_EVENT_NONE;
     328    ev->type = CACA_EVENT_NONE;
     329    return 0;
    311330}
    312331
  • libcaca/trunk/caca/driver_x11.c

    r672 r681  
    400400}
    401401
    402 static unsigned int x11_get_event(caca_t *kk)
    403 {
    404     unsigned int event = 0;
     402static int x11_get_event(caca_t *kk, struct caca_event *ev)
     403{
    405404    XEvent xevent;
    406405    char key;
     
    458457            kk->mouse.y = newy;
    459458
    460             return CACA_EVENT_MOUSE_MOTION | (kk->mouse.x << 12) | kk->mouse.y;
     459            ev->type = CACA_EVENT_MOUSE_MOTION;
     460            ev->data.mouse.x = kk->mouse.x;
     461            ev->data.mouse.y = kk->mouse.y;
     462            return 1;
    461463        }
    462464
    463465        /* Check for mouse press and release events */
    464466        if(xevent.type == ButtonPress)
    465             return CACA_EVENT_MOUSE_PRESS
    466                     | ((XButtonEvent *)&xevent)->button;
     467        {
     468            ev->type = CACA_EVENT_MOUSE_PRESS;
     469            ev->data.mouse.button = ((XButtonEvent *)&xevent)->button;
     470            return 1;
     471        }
    467472
    468473        if(xevent.type == ButtonRelease)
    469             return CACA_EVENT_MOUSE_RELEASE
    470                     | ((XButtonEvent *)&xevent)->button;
     474        {
     475            ev->type = CACA_EVENT_MOUSE_RELEASE;
     476            ev->data.mouse.button = ((XButtonEvent *)&xevent)->button;
     477            return 1;
     478        }
    471479
    472480        /* Check for key press and release events */
    473481        if(xevent.type == KeyPress)
    474             event |= CACA_EVENT_KEY_PRESS;
     482            ev->type = CACA_EVENT_KEY_PRESS;
    475483        else if(xevent.type == KeyRelease)
    476             event |= CACA_EVENT_KEY_RELEASE;
     484            ev->type = CACA_EVENT_KEY_RELEASE;
    477485        else
    478486            continue;
    479487
    480488        if(XLookupString(&xevent.xkey, &key, 1, NULL, NULL))
    481             return event | key;
     489        {
     490            ev->data.key.c = key;
     491            ev->data.key.ucs4 = key;
     492            ev->data.key.utf8[0] = key;
     493            ev->data.key.utf8[1] = '\0';
     494            return 1;
     495        }
    482496
    483497        keysym = XKeycodeToKeysym(kk->drv.p->dpy, xevent.xkey.keycode, 0);
    484498        switch(keysym)
    485499        {
    486         case XK_F1:    return event | CACA_KEY_F1;
    487         case XK_F2:    return event | CACA_KEY_F2;
    488         case XK_F3:    return event | CACA_KEY_F3;
    489         case XK_F4:    return event | CACA_KEY_F4;
    490         case XK_F5:    return event | CACA_KEY_F5;
    491         case XK_F6:    return event | CACA_KEY_F6;
    492         case XK_F7:    return event | CACA_KEY_F7;
    493         case XK_F8:    return event | CACA_KEY_F8;
    494         case XK_F9:    return event | CACA_KEY_F9;
    495         case XK_F10:   return event | CACA_KEY_F10;
    496         case XK_F11:   return event | CACA_KEY_F11;
    497         case XK_F12:   return event | CACA_KEY_F12;
    498         case XK_F13:   return event | CACA_KEY_F13;
    499         case XK_F14:   return event | CACA_KEY_F14;
    500         case XK_F15:   return event | CACA_KEY_F15;
    501         case XK_Left:  return event | CACA_KEY_LEFT;
    502         case XK_Right: return event | CACA_KEY_RIGHT;
    503         case XK_Up:    return event | CACA_KEY_UP;
    504         case XK_Down:  return event | CACA_KEY_DOWN;
    505         default:       return CACA_EVENT_NONE;
    506         }
     500            case XK_F1:    ev->data.key.c = CACA_KEY_F1;    break;
     501            case XK_F2:    ev->data.key.c = CACA_KEY_F2;    break;
     502            case XK_F3:    ev->data.key.c = CACA_KEY_F3;    break;
     503            case XK_F4:    ev->data.key.c = CACA_KEY_F4;    break;
     504            case XK_F5:    ev->data.key.c = CACA_KEY_F5;    break;
     505            case XK_F6:    ev->data.key.c = CACA_KEY_F6;    break;
     506            case XK_F7:    ev->data.key.c = CACA_KEY_F7;    break;
     507            case XK_F8:    ev->data.key.c = CACA_KEY_F8;    break;
     508            case XK_F9:    ev->data.key.c = CACA_KEY_F9;    break;
     509            case XK_F10:   ev->data.key.c = CACA_KEY_F10;   break;
     510            case XK_F11:   ev->data.key.c = CACA_KEY_F11;   break;
     511            case XK_F12:   ev->data.key.c = CACA_KEY_F12;   break;
     512            case XK_F13:   ev->data.key.c = CACA_KEY_F13;   break;
     513            case XK_F14:   ev->data.key.c = CACA_KEY_F14;   break;
     514            case XK_F15:   ev->data.key.c = CACA_KEY_F15;   break;
     515            case XK_Left:  ev->data.key.c = CACA_KEY_LEFT;  break;
     516            case XK_Right: ev->data.key.c = CACA_KEY_RIGHT; break;
     517            case XK_Up:    ev->data.key.c = CACA_KEY_UP;    break;
     518            case XK_Down:  ev->data.key.c = CACA_KEY_DOWN;  break;
     519
     520            default: ev->type = CACA_EVENT_NONE; return 0;
     521        }
     522
     523        ev->data.key.ucs4 = 0;
     524        ev->data.key.utf8[0] = '\0';
     525        return 1;
    507526    }
    508527
    509     return CACA_EVENT_NONE;
     528    ev->type = CACA_EVENT_NONE;
     529    return 0;
    510530}
    511531
  • libcaca/trunk/caca/event.c

    r672 r681  
    2020#include "config.h"
    2121
     22#if !defined(__KERNEL__)
     23#   include <stdio.h>
     24#endif
     25
    2226#include "cucul.h"
    2327#include "cucul_internals.h"
     
    2529#include "caca_internals.h"
    2630
    27 static unsigned int _get_next_event(caca_t *);
    28 static unsigned int _lowlevel_event(caca_t *);
     31static int _get_next_event(caca_t *, struct caca_event *);
     32static int _lowlevel_event(caca_t *, struct caca_event *);
    2933
    3034#if !defined(_DOXYGEN_SKIP_ME)
     
    4953 * \return The next matching event in the queue, or 0 if no event is pending.
    5054 */
    51 unsigned int caca_get_event(caca_t *kk, unsigned int event_mask)
     55int caca_get_event(caca_t *kk, unsigned int event_mask, struct caca_event *ev)
    5256{
    5357    if(!event_mask)
    54         return CACA_EVENT_NONE;
     58        return 0;
    5559
    5660    for( ; ; )
    5761    {
    58         unsigned int event = _get_next_event(kk);
    59 
    60         if(!event || event & event_mask)
    61             return event;
     62        int ret = _get_next_event(kk, ev);
     63
     64        if(!ret || ev->type & event_mask)
     65            return ret;
    6266    }
    6367}
     
    7377 *  \return The next event in the queue.
    7478 */
    75 unsigned int caca_wait_event(caca_t *kk, unsigned int event_mask)
     79int caca_wait_event(caca_t *kk, unsigned int event_mask, struct caca_event *ev)
    7680{
    7781    if(!event_mask)
    78         return CACA_EVENT_NONE;
     82        return 0;
    7983
    8084    for( ; ; )
    8185    {
    82         unsigned int event = _get_next_event(kk);
    83 
    84         if(event & event_mask)
    85             return event;
     86        int ret = _get_next_event(kk, ev);
     87
     88        if(ret && (ev->type & event_mask))
     89            return ret;
    8690
    8791        _caca_sleep(10000);
     
    127131 */
    128132
    129 static unsigned int _get_next_event(caca_t *kk)
     133static int _get_next_event(caca_t *kk, struct caca_event *ev)
    130134{
    131135#if defined(USE_SLANG) || defined(USE_NCURSES)
    132136    unsigned int ticks;
    133137#endif
    134     unsigned int event;
     138    int ret;
    135139
    136140    /* If we are about to return a resize event, acknowledge it */
     
    139143        kk->resize.resized = 0;
    140144        _caca_handle_resize(kk);
    141         return CACA_EVENT_RESIZE;
    142     }
    143 
    144     event = _lowlevel_event(kk);
     145        ev->type = CACA_EVENT_RESIZE;
     146        ev->data.resize.w = kk->qq->width;
     147        ev->data.resize.h = kk->qq->height;
     148        return 1;
     149    }
     150
     151    ret = _lowlevel_event(kk, ev);
    145152
    146153#if defined(USE_SLANG)
     
    150157    if(kk->drv.driver != CACA_DRIVER_NCURSES)
    151158#endif
    152     return event;
     159    return ret;
    153160
    154161#if defined(USE_SLANG) || defined(USE_NCURSES)
     
    159166
    160167    /* Handle autorepeat */
    161     if(kk->events.last_key
     168    if(kk->events.last_key_event.type
    162169           && kk->events.autorepeat_ticks > AUTOREPEAT_TRIGGER
    163170           && kk->events.autorepeat_ticks > AUTOREPEAT_THRESHOLD
    164171           && kk->events.autorepeat_ticks > AUTOREPEAT_RATE)
    165172    {
    166         _push_event(kk, event);
     173        _push_event(kk, ev);
    167174        kk->events.autorepeat_ticks -= AUTOREPEAT_RATE;
    168         return CACA_EVENT_KEY_PRESS | kk->events.last_key;
     175        *ev = kk->events.last_key_event;
     176        return 1;
    169177    }
    170178
    171179    /* We are in autorepeat mode and the same key was just pressed, ignore
    172180     * this event and return the next one by calling ourselves. */
    173     if(event == (CACA_EVENT_KEY_PRESS | kk->events.last_key))
     181    if(ev->type == CACA_EVENT_KEY_PRESS
     182        && kk->events.last_key_event.type
     183        && ev->data.key.c == kk->events.last_key_event.data.key.c
     184        && ev->data.key.ucs4 == kk->events.last_key_event.data.key.ucs4)
    174185    {
    175186        kk->events.last_key_ticks = 0;
    176         return _get_next_event(kk);
     187        return _get_next_event(kk, ev);
    177188    }
    178189
    179190    /* We are in autorepeat mode, but key has expired or a new key was
    180191     * pressed - store our event and return a key release event first */
    181     if(kk->events.last_key
     192    if(kk->events.last_key_event.type
    182193          && (kk->events.last_key_ticks > AUTOREPEAT_THRESHOLD
    183                || (event & CACA_EVENT_KEY_PRESS)))
    184     {
    185         _push_event(kk, event);
    186         event = CACA_EVENT_KEY_RELEASE | kk->events.last_key;
    187         kk->events.last_key = 0;
    188         return event;
     194               || (ev->type & CACA_EVENT_KEY_PRESS)))
     195    {
     196        _push_event(kk, ev);
     197        *ev = kk->events.last_key_event;
     198        ev->type = CACA_EVENT_KEY_RELEASE;
     199        kk->events.last_key_event.type = CACA_EVENT_NONE;
     200        return 1;
    189201    }
    190202
    191203    /* A new key was pressed, enter autorepeat mode */
    192     if(event & CACA_EVENT_KEY_PRESS)
     204    if(ev->type & CACA_EVENT_KEY_PRESS)
    193205    {
    194206        kk->events.last_key_ticks = 0;
    195207        kk->events.autorepeat_ticks = 0;
    196         kk->events.last_key = event & 0x00ffffff;
    197     }
    198 
    199     return event;
    200 #endif
    201 }
    202 
    203 static unsigned int _lowlevel_event(caca_t *kk)
     208        kk->events.last_key_event = *ev;
     209    }
     210
     211    return ev->type ? 1 : 0;
     212#endif
     213}
     214
     215static int _lowlevel_event(caca_t *kk, struct caca_event *ev)
    204216{
    205217#if defined(USE_SLANG) || defined(USE_NCURSES) || defined(USE_CONIO)
    206     unsigned int event = _pop_event(kk);
    207 
    208     if(event)
    209         return event;
    210 #endif
    211 
    212     return kk->drv.get_event(kk);
    213 }
    214 
    215 #if defined(USE_SLANG) || defined(USE_NCURSES) || defined(USE_CONIO)
    216 void _push_event(caca_t *kk, unsigned int event)
    217 {
    218     if(!event || kk->events.queue == EVENTBUF_LEN)
     218    int ret = _pop_event(kk, ev);
     219
     220    if(ret)
     221        return ret;
     222#endif
     223
     224    return kk->drv.get_event(kk, ev);
     225}
     226
     227#if defined(USE_SLANG) || defined(USE_NCURSES) || defined(USE_CONIO) || defined(USE_GL)
     228void _push_event(caca_t *kk, struct caca_event *ev)
     229{
     230    if(!ev->type || kk->events.queue == EVENTBUF_LEN)
    219231        return;
    220     kk->events.buf[kk->events.queue] = event;
     232    kk->events.buf[kk->events.queue] = *ev;
    221233    kk->events.queue++;
    222234}
    223235
    224 unsigned int _pop_event(caca_t *kk)
     236int _pop_event(caca_t *kk, struct caca_event *ev)
    225237{
    226238    int i;
    227     unsigned int event;
    228239
    229240    if(kk->events.queue == 0)
    230         return CACA_EVENT_NONE;
    231 
    232     event = kk->events.buf[0];
     241        return 0;
     242
     243    *ev = kk->events.buf[0];
    233244    for(i = 1; i < kk->events.queue; i++)
    234245        kk->events.buf[i - 1] = kk->events.buf[i];
    235246    kk->events.queue--;
    236247
    237     return event;
    238 }
    239 #endif
    240 
     248    return 1;
     249}
     250#endif
     251
  • libcaca/trunk/src/aafire.c

    r677 r681  
    262262    {
    263263#ifdef LIBCACA
    264       switch (caca_get_event(kk, CACA_EVENT_KEY_PRESS))
     264      struct caca_event ev;
     265      if(caca_get_event(kk, CACA_EVENT_KEY_PRESS, &ev))
    265266        {
    266           case CACA_EVENT_KEY_PRESS | CACA_KEY_ESCAPE: return;
    267           case CACA_EVENT_KEY_PRESS | ' ': pause = !pause;
     267          switch(ev.data.key.c)
     268            {
     269                case CACA_KEY_ESCAPE: return;
     270                case ' ': pause = !pause;
     271            }
    268272        }
    269 
    270273#endif
    271274      drawfire ();
  • libcaca/trunk/src/cacaball.c

    r677 r681  
    9393    for(;;)
    9494    {
    95         switch(caca_get_event(kk, CACA_EVENT_KEY_PRESS))
    96         {
    97             case CACA_EVENT_KEY_PRESS | CACA_KEY_ESCAPE: goto end;
    98             case CACA_EVENT_KEY_PRESS | ' ': pause = !pause;
     95        struct caca_event ev;
     96        if(caca_get_event(kk, CACA_EVENT_KEY_PRESS, &ev))
     97        {
     98            switch(ev.data.key.c)
     99            {
     100                case CACA_KEY_ESCAPE: goto end;
     101                case ' ': pause = !pause;
     102            }
    99103        }
    100104
  • libcaca/trunk/src/cacamoir.c

    r677 r681  
    6969    for(;;)
    7070    {
    71         switch(caca_get_event(kk, CACA_EVENT_KEY_PRESS))
     71        struct caca_event ev;
     72        if(caca_get_event(kk, CACA_EVENT_KEY_PRESS, &ev))
    7273        {
    73             case CACA_EVENT_KEY_PRESS | CACA_KEY_ESCAPE: goto end;
    74             case CACA_EVENT_KEY_PRESS | ' ': pause = !pause;
     74            switch(ev.data.key.c)
     75            {
     76                case CACA_KEY_ESCAPE: goto end;
     77                case ' ': pause = !pause;
     78            }
    7579        }
    7680
  • libcaca/trunk/src/cacaplas.c

    r677 r681  
    8181    for(;;)
    8282    {
    83         switch(caca_get_event(kk, CACA_EVENT_KEY_PRESS))
     83        struct caca_event ev;
     84        if(caca_get_event(kk, CACA_EVENT_KEY_PRESS, &ev))
    8485        {
    85             case CACA_EVENT_KEY_PRESS | CACA_KEY_ESCAPE: goto end;
    86             case CACA_EVENT_KEY_PRESS | ' ': pause = !pause;
     86            switch(ev.data.key.c)
     87            {
     88                case CACA_KEY_ESCAPE: goto end;
     89                case ' ': pause = !pause;
     90            }
    8791        }
    8892
  • libcaca/trunk/src/cacaview.c

    r678 r681  
    144144    while(!quit)
    145145    {
     146        struct caca_event ev;
    146147        unsigned int const event_mask = CACA_EVENT_KEY_PRESS
    147148                                      | CACA_EVENT_RESIZE
    148149                                      | CACA_EVENT_MOUSE_PRESS;
    149         unsigned int event, new_status = 0, new_help = 0;
     150        unsigned int new_status = 0, new_help = 0;
     151        int event;
    150152
    151153        if(update)
    152             event = caca_get_event(kk, event_mask);
     154            event = caca_get_event(kk, event_mask, &ev);
    153155        else
    154             event = caca_wait_event(kk, event_mask);
     156            event = caca_wait_event(kk, event_mask, &ev);
    155157
    156158        while(event)
    157159        {
    158             if(event & CACA_EVENT_MOUSE_PRESS)
     160            if(ev.type & CACA_EVENT_MOUSE_PRESS)
    159161            {
    160                 if((event & 0x00ffffff) == 1)
     162                if(ev.data.mouse.button == 1)
    161163                {
    162164                    if(items) current = (current + 1) % items;
    163165                    reload = 1;
    164166                }
    165                 else if((event & 0x00ffffff) == 2)
     167                else if(ev.data.mouse.button == 2)
    166168                {
    167169                    if(items) current = (items + current - 1) % items;
     
    169171                }
    170172            }
    171             else if(event & CACA_EVENT_KEY_PRESS) switch(event & 0x00ffffff)
     173            else if(ev.type & CACA_EVENT_KEY_PRESS) switch(ev.data.key.c)
    172174            {
    173175            case 'n':
     
    288290                break;
    289291            }
    290             else if(event == CACA_EVENT_RESIZE)
     292            else if(ev.type == CACA_EVENT_RESIZE)
    291293            {
    292294                caca_display(kk);
    293                 ww = cucul_get_width(qq);
    294                 wh = cucul_get_height(qq);
     295                ww = ev.data.resize.w;
     296                wh = ev.data.resize.h;
    295297                update = 1;
    296298                set_zoom(zoom);
     
    303305                help = new_help;
    304306
    305             event = caca_get_event(kk, CACA_EVENT_KEY_PRESS);
     307            event = caca_get_event(kk, CACA_EVENT_KEY_PRESS, &ev);
    306308        }
    307309
  • libcaca/trunk/test/colors.c

    r677 r681  
    2525    cucul_t *qq;
    2626    caca_t *kk;
     27    struct caca_event ev;
    2728    int i, j;
    2829
     
    5051
    5152    caca_display(kk);
    52     caca_wait_event(kk, CACA_EVENT_KEY_PRESS);
     53    caca_wait_event(kk, CACA_EVENT_KEY_PRESS, &ev);
    5354
    5455    caca_detach(kk);
  • libcaca/trunk/test/demo.c

    r678 r681  
    6969    while(!quit)
    7070    {
     71        struct caca_event ev;
    7172        int menu = 0, mouse = 0, xmouse = 0, ymouse = 0;
    72         int event;
    73 
    74         while((event = caca_get_event(kk, CACA_EVENT_ANY)))
     73
     74        while(caca_get_event(kk, CACA_EVENT_ANY, &ev))
    7575        {
    76             if(demo && (event & CACA_EVENT_KEY_PRESS))
     76            if(demo && (ev.type & CACA_EVENT_KEY_PRESS))
    7777            {
    7878                menu = 1;
    7979                demo = NULL;
    8080            }
    81             else if(event & CACA_EVENT_KEY_PRESS)
     81            else if(ev.type & CACA_EVENT_KEY_PRESS)
    8282            {
    83                 switch(event & 0xffff)
     83                switch(ev.data.key.c)
    8484                {
    8585                case 'q':
     
    140140                    cucul_clear(qq);
    141141            }
    142             else if(event & CACA_EVENT_MOUSE_MOTION)
     142            else if(ev.type & CACA_EVENT_MOUSE_MOTION)
    143143            {
    144144                mouse = 1;
    145                 xmouse = (event & 0xfff000) >> 12;
    146                 ymouse = event & 0xfff;
     145                xmouse = ev.data.mouse.x;
     146                ymouse = ev.data.mouse.y;
    147147            }
    148148        }
  • libcaca/trunk/test/dithering.c

    r677 r681  
    3535int main(void)
    3636{
     37    struct caca_event ev;
    3738    cucul_t *qq;
    3839    caca_t *kk;
     
    124125    caca_display(kk);
    125126
    126     while(!caca_get_event(kk, CACA_EVENT_KEY_PRESS));
     127    caca_wait_event(kk, CACA_EVENT_KEY_PRESS, &ev);
    127128
    128129    caca_detach(kk);
  • libcaca/trunk/test/event.c

    r678 r681  
    2424static caca_t *kk;
    2525
    26 static void print_event(int, int, unsigned int);
     26static void print_event(int, int, struct caca_event *);
    2727
    2828int main(int argc, char **argv)
    2929{
    30     int *events;
     30    struct caca_event *events;
    3131    int i, h, quit;
    3232
     
    4848    caca_display(kk);
    4949
    50     events = malloc(h * sizeof(int));
    51     memset(events, 0, h * sizeof(int));
     50    events = malloc(h * sizeof(struct caca_event));
     51    memset(events, 0, h * sizeof(struct caca_event));
    5252
    5353    for(quit = 0; quit < 4; )
    5454    {
     55        struct caca_event ev;
    5556        static char const * quit_string[] = { "", "q", "qu", "qui", "quit" };
    56         unsigned int event = caca_wait_event(kk, CACA_EVENT_ANY);
     57        int ret = caca_wait_event(kk, CACA_EVENT_ANY, &ev);
    5758
    58         if(!event)
     59        if(!ret)
    5960            continue;
    6061
     
    6263        {
    6364            /* "quit" quits */
    64             if(event & CACA_EVENT_KEY_PRESS)
     65            if(ev.type & CACA_EVENT_KEY_PRESS)
    6566            {
    66                 int key = event & ~CACA_EVENT_KEY_PRESS;
     67                int key = ev.data.key.c;
    6768                if((key == 'q' && quit == 0) || (key == 'u' && quit == 1)
    6869                    || (key == 'i' && quit == 2) || (key == 't' && quit == 3))
     
    7475            }
    7576
    76             memmove(events + 1, events, (h - 1) * sizeof(int));
    77             events[0] = event;
     77            memmove(events + 1, events, (h - 1) * sizeof(struct caca_event));
     78            events[0] = ev;
    7879
    79             event = caca_get_event(kk, CACA_EVENT_ANY);
     80            ret = caca_get_event(kk, CACA_EVENT_ANY, &ev);
    8081        }
    81         while(event);
     82        while(ret);
    8283
    8384        cucul_clear(qq);
     
    8687        cucul_set_color(qq, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
    8788        cucul_draw_line(qq, 0, 0, cucul_get_width(qq) - 1, 0, " ");
    88         print_event(0, 0, events[0]);
     89        print_event(0, 0, events);
    8990
    9091        cucul_draw_line(qq, 0, h, cucul_get_width(qq) - 1, h, " ");
     
    9394        /* Print previous events */
    9495        cucul_set_color(qq, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLACK);
    95         for(i = 1; i < h && events[i]; i++)
    96             print_event(0, i, events[i]);
     96        for(i = 1; i < h && events[i].type; i++)
     97            print_event(0, i, events + i);
    9798
    9899        caca_display(kk);
     
    106107}
    107108
    108 static void print_event(int x, int y, unsigned int event)
     109static void print_event(int x, int y, struct caca_event *ev)
    109110{
    110111    int character;
    111112
    112     switch(event & 0xff000000)
     113    switch(ev->type)
    113114    {
    114115    case CACA_EVENT_NONE:
     
    116117        break;
    117118    case CACA_EVENT_KEY_PRESS:
    118         character = event & 0x00ffffff;
     119        character = ev->data.key.c;
    119120        cucul_printf(qq, x, y, "CACA_EVENT_KEY_PRESS 0x%02x (%c)", character,
    120121                     (character > 0x20 && character < 0x80) ? character : '?');
    121122        break;
    122123    case CACA_EVENT_KEY_RELEASE:
    123         character = event & 0x00ffffff;
     124        character = ev->data.key.c;
    124125        cucul_printf(qq, x, y, "CACA_EVENT_KEY_RELEASE 0x%02x (%c)", character,
    125126                     (character > 0x20 && character < 0x80) ? character : '?');
     
    127128    case CACA_EVENT_MOUSE_MOTION:
    128129        cucul_printf(qq, x, y, "CACA_EVENT_MOUSE_MOTION %u %u",
    129                      (event & 0x00fff000) >> 12, event & 0x00000fff);
     130                     ev->data.mouse.x, ev->data.mouse.y);
    130131        break;
    131132    case CACA_EVENT_MOUSE_PRESS:
    132133        cucul_printf(qq, x, y, "CACA_EVENT_MOUSE_PRESS %u",
    133                      event & 0x00ffffff);
     134                     ev->data.mouse.button);
    134135        break;
    135136    case CACA_EVENT_MOUSE_RELEASE:
    136137        cucul_printf(qq, x, y, "CACA_EVENT_MOUSE_RELEASE %u",
    137                      event & 0x00ffffff);
     138                     ev->data.mouse.button);
    138139        break;
    139140    case CACA_EVENT_RESIZE:
    140         cucul_printf(qq, x, y, "CACA_EVENT_RESIZE");
     141        cucul_printf(qq, x, y, "CACA_EVENT_RESIZE %u %u",
     142                     ev->data.resize.w, ev->data.resize.h);
    141143        break;
    142144    default:
  • libcaca/trunk/test/gamma.c

    r680 r681  
    3434int main(void)
    3535{
     36    struct caca_event ev;
    3637    cucul_t *qq, *gg, *mask;
    3738    caca_t *kk;
     
    6263    for(x = 0; ; x++)
    6364    {
    64         int ev = caca_get_event(kk, CACA_EVENT_KEY_PRESS);
     65        int ret = caca_get_event(kk, CACA_EVENT_KEY_PRESS, &ev);
    6566
    66         if(ev == (CACA_EVENT_KEY_PRESS | CACA_KEY_LEFT))
    67             gam /= 1.03;
    68         else if(ev == (CACA_EVENT_KEY_PRESS | CACA_KEY_RIGHT))
    69             gam *= 1.03;
    70         else if(ev == (CACA_EVENT_KEY_PRESS | CACA_KEY_DOWN))
    71             gam = 1.0;
    72         else if(ev == (CACA_EVENT_KEY_PRESS | CACA_KEY_ESCAPE))
    73             break;
     67        if(ret)
     68        {
     69            if(ev.data.key.c == CACA_KEY_LEFT)
     70                gam /= 1.03;
     71            else if(ev.data.key.c == CACA_KEY_RIGHT)
     72                gam *= 1.03;
     73            else if(ev.data.key.c == CACA_KEY_DOWN)
     74                gam = 1.0;
     75            else if(ev.data.key.c == CACA_KEY_ESCAPE)
     76                break;
     77        }
    7478
    7579        /* Resize the spare canvas, just in case the main one changed */
  • libcaca/trunk/test/hsv.c

    r677 r681  
    2929int main(void)
    3030{
     31    struct caca_event ev;
    3132    cucul_t *qq;
    3233    caca_t *kk;
     
    5354    caca_display(kk);
    5455
    55     while(!caca_get_event(kk, CACA_EVENT_KEY_PRESS));
     56    caca_wait_event(kk, CACA_EVENT_KEY_PRESS, &ev);
    5657
    5758    caca_detach(kk);
  • libcaca/trunk/test/spritedit.c

    r678 r681  
    5454    while(!quit)
    5555    {
     56        struct caca_event ev;
    5657        int xa, ya, xb, yb;
    5758        char buf[BUFSIZ];
    58         int event;
    5959
    60         while((event = caca_get_event(kk, CACA_EVENT_KEY_PRESS)))
     60        while(caca_get_event(kk, CACA_EVENT_KEY_PRESS, &ev))
    6161        {
    62             switch(event & 0x00ffffff)
     62            switch(ev.data.key.c)
    6363            {
    6464            case 0:
  • libcaca/trunk/test/transform.c

    r677 r681  
    5050int main(void)
    5151{
     52    struct caca_event ev;
    5253    cucul_t *qq, *normal, *flip, *flop, *rotate;
    5354    caca_t *kk;
     
    108109    caca_display(kk);
    109110
    110     while(!caca_get_event(kk, CACA_EVENT_KEY_PRESS));
     111    caca_wait_event(kk, CACA_EVENT_KEY_PRESS, &ev);
    111112
    112113    caca_detach(kk);
  • libcaca/trunk/test/unicode.c

    r677 r681  
    2727int main(void)
    2828{
     29    struct caca_event ev;
    2930    cucul_t *qq;
    3031    caca_t *kk;
     
    8788    caca_display(kk);
    8889
    89     while(!caca_get_event(kk, CACA_EVENT_KEY_PRESS));
     90    caca_wait_event(kk, CACA_EVENT_KEY_PRESS, &ev);
    9091
    9192    caca_detach(kk);
Note: See TracChangeset for help on using the changeset viewer.