Ignore:
Timestamp:
May 13, 2011, 1:36:00 PM (12 years ago)
Author:
Sam Hocevar
Message:

imlib: clean up EventHandler? and JCMouse.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • abuse/trunk/src/sdlport/event.cpp

    r643 r645  
    4141
    4242// Pre-declarations
    43 void handle_mouse(Event &ev);
     43static void handle_mouse(Event &ev);
    4444
    4545//
     
    5252    mhere = mouse->exists();
    5353    last_keystat = get_key_flags();
    54     ewaiting = 0;
     54    m_pending = 0;
    5555
    5656    // Ignore activate events
     
    6464int EventHandler::get_key_flags()
    6565{
    66     SDLMod key_flag;
    67 
    68     key_flag = SDL_GetModState();
     66    SDLMod key_flag = SDL_GetModState();
    6967
    7068    return ((key_flag & KMOD_SHIFT) != 0) << 3 |
     
    7472
    7573//
    76 // event_waiting()
     74// IsPending()
    7775// Are there any events in the queue?
    7876//
    79 int EventHandler::event_waiting()
    80 {
    81     if(ewaiting)
    82     {
    83         return 1;
    84     }
    85     if(SDL_PollEvent(NULL))
    86     {
    87         ewaiting = 1;
    88     }
    89     return ewaiting;
     77int EventHandler::IsPending()
     78{
     79    if (!m_pending && SDL_PollEvent(NULL))
     80        m_pending = 1;
     81
     82    return m_pending;
    9083}
    9184
     
    9689void EventHandler::Get(Event &ev)
    9790{
    98     Event *ep;
    99     while(!ewaiting)
    100     {
    101         event_waiting();
    102 
    103         if (!ewaiting)
     91    while(!m_pending)
     92    {
     93        IsPending();
     94
     95        if (!m_pending)
    10496        {
    10597            // Sleep for 1 millisecond if there are no events
     
    108100    }
    109101
    110     ep = (Event *)m_events.first();
     102    Event *ep = (Event *)m_events.first();
    111103    if(ep)
    112104    {
     
    114106        m_events.unlink(ep);
    115107        delete ep;
    116         ewaiting = m_events.first() != NULL;
    117     }
    118     else
    119     {
    120         // NOTE : that the mouse status should be known
    121         // even if another event has occurred.
    122         ev.mouse_move.x = mouse->x();
    123         ev.mouse_move.y = mouse->y();
    124         ev.mouse_button = mouse->button();
    125 
    126         // Gather events
    127         SDL_Event Event;
    128         if(SDL_PollEvent(&Event))
     108        m_pending = m_events.first() != NULL;
     109        return;
     110    }
     111
     112    // No more events
     113    m_pending = 0;
     114
     115    // NOTE : that the mouse status should be known
     116    // even if another event has occurred.
     117    ev.mouse_move.x = mouse->x();
     118    ev.mouse_move.y = mouse->y();
     119    ev.mouse_button = mouse->button();
     120
     121    // Gather events
     122    SDL_Event sdlev;
     123    if (SDL_PollEvent(&sdlev))
     124    {
     125        // always sort the mouse out
     126        handle_mouse(ev);
     127        mouse->update(ev.mouse_move.x, ev.mouse_move.y, ev.mouse_button);
     128
     129        switch(sdlev.type)
    129130        {
    130             // always sort the mouse out
    131             handle_mouse(ev);
    132             mouse->update(ev.mouse_move.x, ev.mouse_move.y, ev.mouse_button);
    133 
    134             switch(Event.type)
     131            case SDL_QUIT:
    135132            {
    136                 case SDL_QUIT:
    137                 {
    138                     exit(0);
    139                     break;
    140                 }
    141                 case SDL_MOUSEBUTTONUP:
    142                 {
    143                     switch(Event.button.button)
    144                     {
    145                         case 4:        // Mouse wheel goes up...
     133                exit(0);
     134                break;
     135            }
     136            case SDL_MOUSEBUTTONUP:
     137            {
     138                switch(sdlev.button.button)
     139                {
     140                    case 4:        // Mouse wheel goes up...
     141                    {
     142                        ev.key = get_key_binding("b4", 0);
     143                        ev.type = EV_KEYRELEASE;
     144                        break;
     145                    }
     146                    case 5:        // Mouse wheel goes down...
     147                    {
     148                        ev.key = get_key_binding("b3", 0);
     149                        ev.type = EV_KEYRELEASE;
     150                        break;
     151                    }
     152                }
     153                break;
     154            }
     155            case SDL_MOUSEBUTTONDOWN:
     156            {
     157                switch(sdlev.button.button)
     158                {
     159                    case 4:        // Mouse wheel goes up...
     160                    {
     161                        ev.key = get_key_binding("b4", 0);
     162                        ev.type = EV_KEY;
     163                        break;
     164                    }
     165                    case 5:        // Mouse wheel goes down...
     166                    {
     167                        ev.key = get_key_binding("b3", 0);
     168                        ev.type = EV_KEY;
     169                        break;
     170                    }
     171                }
     172                break;
     173            }
     174            case SDL_KEYDOWN:
     175            case SDL_KEYUP:
     176            {
     177                // Default to EV_SPURIOUS
     178                ev.key = EV_SPURIOUS;
     179                if(sdlev.type == SDL_KEYDOWN)
     180                {
     181                    ev.type = EV_KEY;
     182                }
     183                else
     184                {
     185                    ev.type = EV_KEYRELEASE;
     186                }
     187                switch(sdlev.key.keysym.sym)
     188                {
     189                    case SDLK_DOWN:         ev.key = JK_DOWN; break;
     190                    case SDLK_UP:           ev.key = JK_UP; break;
     191                    case SDLK_LEFT:         ev.key = JK_LEFT; break;
     192                    case SDLK_RIGHT:        ev.key = JK_RIGHT; break;
     193                    case SDLK_LCTRL:        ev.key = JK_CTRL_L; break;
     194                    case SDLK_RCTRL:        ev.key = JK_CTRL_R; break;
     195                    case SDLK_LALT:         ev.key = JK_ALT_L; break;
     196                    case SDLK_RALT:         ev.key = JK_ALT_R; break;
     197                    case SDLK_LSHIFT:       ev.key = JK_SHIFT_L; break;
     198                    case SDLK_RSHIFT:       ev.key = JK_SHIFT_R; break;
     199                    case SDLK_NUMLOCK:      ev.key = JK_NUM_LOCK; break;
     200                    case SDLK_HOME:         ev.key = JK_HOME; break;
     201                    case SDLK_END:          ev.key = JK_END; break;
     202                    case SDLK_BACKSPACE:    ev.key = JK_BACKSPACE; break;
     203                    case SDLK_TAB:          ev.key = JK_TAB; break;
     204                    case SDLK_RETURN:       ev.key = JK_ENTER; break;
     205                    case SDLK_SPACE:        ev.key = JK_SPACE; break;
     206                    case SDLK_CAPSLOCK:     ev.key = JK_CAPS; break;
     207                    case SDLK_ESCAPE:       ev.key = JK_ESC; break;
     208                    case SDLK_F1:           ev.key = JK_F1; break;
     209                    case SDLK_F2:           ev.key = JK_F2; break;
     210                    case SDLK_F3:           ev.key = JK_F3; break;
     211                    case SDLK_F4:           ev.key = JK_F4; break;
     212                    case SDLK_F5:           ev.key = JK_F5; break;
     213                    case SDLK_F6:           ev.key = JK_F6; break;
     214                    case SDLK_F7:           ev.key = JK_F7; break;
     215                    case SDLK_F8:           ev.key = JK_F8; break;
     216                    case SDLK_F9:           ev.key = JK_F9; break;
     217                    case SDLK_F10:          ev.key = JK_F10; break;
     218                    case SDLK_INSERT:       ev.key = JK_INSERT; break;
     219                    case SDLK_KP0:          ev.key = JK_INSERT; break;
     220                    case SDLK_PAGEUP:       ev.key = JK_PAGEUP; break;
     221                    case SDLK_PAGEDOWN:     ev.key = JK_PAGEDOWN; break;
     222                    case SDLK_KP8:          ev.key = JK_UP; break;
     223                    case SDLK_KP2:          ev.key = JK_DOWN; break;
     224                    case SDLK_KP4:          ev.key = JK_LEFT; break;
     225                    case SDLK_KP6:          ev.key = JK_RIGHT; break;
     226                    case SDLK_F11:
     227                    {
     228                        // Only handle key down
     229                        if(ev.type == EV_KEY)
    146230                        {
    147                             ev.key = get_key_binding("b4", 0);
    148                             ev.type = EV_KEYRELEASE;
    149                             break;
     231                            // Toggle fullscreen
     232                            SDL_WM_ToggleFullScreen(SDL_GetVideoSurface());
    150233                        }
    151                         case 5:        // Mouse wheel goes down...
     234                        ev.key = EV_SPURIOUS;
     235                        break;
     236                    }
     237                    case SDLK_F12:
     238                    {
     239                        // Only handle key down
     240                        if(ev.type == EV_KEY)
    152241                        {
    153                             ev.key = get_key_binding("b3", 0);
    154                             ev.type = EV_KEYRELEASE;
    155                             break;
     242                            // Toggle grab mouse
     243                            if(SDL_WM_GrabInput(SDL_GRAB_QUERY) == SDL_GRAB_ON)
     244                            {
     245                                the_game->show_help("Grab Mouse: OFF\n");
     246                                SDL_WM_GrabInput(SDL_GRAB_OFF);
     247                            }
     248                            else
     249                            {
     250                                the_game->show_help("Grab Mouse: ON\n");
     251                                SDL_WM_GrabInput(SDL_GRAB_ON);
     252                            }
    156253                        }
    157                     }
    158                     break;
    159                 }
    160                 case SDL_MOUSEBUTTONDOWN:
    161                 {
    162                     switch(Event.button.button)
    163                     {
    164                         case 4:        // Mouse wheel goes up...
     254                        ev.key = EV_SPURIOUS;
     255                        break;
     256                    }
     257                    case SDLK_PRINT:    // print-screen key
     258                    {
     259                        // Only handle key down
     260                        if(ev.type == EV_KEY)
    165261                        {
    166                             ev.key = get_key_binding("b4", 0);
    167                             ev.type = EV_KEY;
    168                             break;
     262                            // Grab a screenshot
     263                            SDL_SaveBMP(SDL_GetVideoSurface(), "screenshot.bmp");
     264                            the_game->show_help("Screenshot saved to: screenshot.bmp.\n");
    169265                        }
    170                         case 5:        // Mouse wheel goes down...
     266                        ev.key = EV_SPURIOUS;
     267                        break;
     268                    }
     269                    default:
     270                    {
     271                        ev.key = (int)sdlev.key.keysym.sym;
     272                        // Need to handle the case of shift being pressed
     273                        // There has to be a better way
     274                        if((sdlev.key.keysym.mod & KMOD_SHIFT) != 0)
    171275                        {
    172                             ev.key = get_key_binding("b3", 0);
    173                             ev.type = EV_KEY;
    174                             break;
     276                            if(sdlev.key.keysym.sym >= SDLK_a &&
     277                                sdlev.key.keysym.sym <= SDLK_z)
     278                            {
     279                                ev.key -= 32;
     280                            }
     281                            else if(sdlev.key.keysym.sym >= SDLK_1 &&
     282                                     sdlev.key.keysym.sym <= SDLK_5)
     283                            {
     284                                ev.key -= 16;
     285                            }
     286                            else
     287                            {
     288                                switch(sdlev.key.keysym.sym)
     289                                {
     290                                    case SDLK_6:
     291                                        ev.key = SDLK_CARET; break;
     292                                    case SDLK_7:
     293                                    case SDLK_9:
     294                                    case SDLK_0:
     295                                        ev.key -= 17; break;
     296                                    case SDLK_8:
     297                                        ev.key = SDLK_ASTERISK; break;
     298                                    case SDLK_MINUS:
     299                                        ev.key = SDLK_UNDERSCORE; break;
     300                                    case SDLK_EQUALS:
     301                                        ev.key = SDLK_PLUS; break;
     302                                    case SDLK_COMMA:
     303                                        ev.key = SDLK_LESS; break;
     304                                    case SDLK_PERIOD:
     305                                        ev.key = SDLK_GREATER; break;
     306                                    case SDLK_SLASH:
     307                                        ev.key = SDLK_QUESTION; break;
     308                                    case SDLK_SEMICOLON:
     309                                        ev.key = SDLK_COLON; break;
     310                                    case SDLK_QUOTE:
     311                                        ev.key = SDLK_QUOTEDBL; break;
     312                                    default:
     313                                        break;
     314                                }
     315                            }
    175316                        }
    176317                    }
    177                     break;
    178                 }
    179                 case SDL_KEYDOWN:
    180                 case SDL_KEYUP:
    181                 {
    182                     // Default to EV_SPURIOUS
    183                     ev.key = EV_SPURIOUS;
    184                     if(Event.type == SDL_KEYDOWN)
    185                     {
    186                         ev.type = EV_KEY;
    187                     }
    188                     else
    189                     {
    190                         ev.type = EV_KEYRELEASE;
    191                     }
    192                     switch(Event.key.keysym.sym)
    193                     {
    194                         case SDLK_DOWN:            ev.key = JK_DOWN; break;
    195                         case SDLK_UP:            ev.key = JK_UP; break;
    196                         case SDLK_LEFT:            ev.key = JK_LEFT; break;
    197                         case SDLK_RIGHT:        ev.key = JK_RIGHT; break;
    198                         case SDLK_LCTRL:        ev.key = JK_CTRL_L; break;
    199                         case SDLK_RCTRL:        ev.key = JK_CTRL_R; break;
    200                         case SDLK_LALT:            ev.key = JK_ALT_L; break;
    201                         case SDLK_RALT:            ev.key = JK_ALT_R; break;
    202                         case SDLK_LSHIFT:        ev.key = JK_SHIFT_L; break;
    203                         case SDLK_RSHIFT:        ev.key = JK_SHIFT_R; break;
    204                         case SDLK_NUMLOCK:        ev.key = JK_NUM_LOCK; break;
    205                         case SDLK_HOME:            ev.key = JK_HOME; break;
    206                         case SDLK_END:            ev.key = JK_END; break;
    207                         case SDLK_BACKSPACE:    ev.key = JK_BACKSPACE; break;
    208                         case SDLK_TAB:            ev.key = JK_TAB; break;
    209                         case SDLK_RETURN:        ev.key = JK_ENTER; break;
    210                         case SDLK_SPACE:        ev.key = JK_SPACE; break;
    211                         case SDLK_CAPSLOCK:        ev.key = JK_CAPS; break;
    212                         case SDLK_ESCAPE:        ev.key = JK_ESC; break;
    213                         case SDLK_F1:            ev.key = JK_F1; break;
    214                         case SDLK_F2:            ev.key = JK_F2; break;
    215                         case SDLK_F3:            ev.key = JK_F3; break;
    216                         case SDLK_F4:            ev.key = JK_F4; break;
    217                         case SDLK_F5:            ev.key = JK_F5; break;
    218                         case SDLK_F6:            ev.key = JK_F6; break;
    219                         case SDLK_F7:            ev.key = JK_F7; break;
    220                         case SDLK_F8:            ev.key = JK_F8; break;
    221                         case SDLK_F9:            ev.key = JK_F9; break;
    222                         case SDLK_F10:            ev.key = JK_F10; break;
    223                         case SDLK_INSERT:        ev.key = JK_INSERT; break;
    224                         case SDLK_KP0:            ev.key = JK_INSERT; break;
    225                         case SDLK_PAGEUP:        ev.key = JK_PAGEUP; break;
    226                         case SDLK_PAGEDOWN:        ev.key = JK_PAGEDOWN; break;
    227                         case SDLK_KP8:            ev.key = JK_UP; break;
    228                         case SDLK_KP2:            ev.key = JK_DOWN; break;
    229                         case SDLK_KP4:            ev.key = JK_LEFT; break;
    230                         case SDLK_KP6:            ev.key = JK_RIGHT; break;
    231                         case SDLK_F11:
    232                         {
    233                             // Only handle key down
    234                             if(ev.type == EV_KEY)
    235                             {
    236                                 // Toggle fullscreen
    237                                 SDL_WM_ToggleFullScreen(SDL_GetVideoSurface());
    238                             }
    239                             ev.key = EV_SPURIOUS;
    240                             break;
    241                         }
    242                         case SDLK_F12:
    243                         {
    244                             // Only handle key down
    245                             if(ev.type == EV_KEY)
    246                             {
    247                                 // Toggle grab mouse
    248                                 if(SDL_WM_GrabInput(SDL_GRAB_QUERY) == SDL_GRAB_ON)
    249                                 {
    250                                     the_game->show_help("Grab Mouse: OFF\n");
    251                                     SDL_WM_GrabInput(SDL_GRAB_OFF);
    252                                 }
    253                                 else
    254                                 {
    255                                     the_game->show_help("Grab Mouse: ON\n");
    256                                     SDL_WM_GrabInput(SDL_GRAB_ON);
    257                                 }
    258                             }
    259                             ev.key = EV_SPURIOUS;
    260                             break;
    261                         }
    262                         case SDLK_PRINT:    // print-screen key
    263                         {
    264                             // Only handle key down
    265                             if(ev.type == EV_KEY)
    266                             {
    267                                 // Grab a screenshot
    268                                 SDL_SaveBMP(SDL_GetVideoSurface(), "screenshot.bmp");
    269                                 the_game->show_help("Screenshot saved to: screenshot.bmp.\n");
    270                             }
    271                             ev.key = EV_SPURIOUS;
    272                             break;
    273                         }
    274                         default:
    275                         {
    276                             ev.key = (int)Event.key.keysym.sym;
    277                             // Need to handle the case of shift being pressed
    278                             // There has to be a better way
    279                             if((Event.key.keysym.mod & KMOD_SHIFT) != 0)
    280                             {
    281                                 if(Event.key.keysym.sym >= SDLK_a &&
    282                                     Event.key.keysym.sym <= SDLK_z)
    283                                 {
    284                                     ev.key -= 32;
    285                                 }
    286                                 else if(Event.key.keysym.sym >= SDLK_1 &&
    287                                          Event.key.keysym.sym <= SDLK_5)
    288                                 {
    289                                     ev.key -= 16;
    290                                 }
    291                                 else
    292                                 {
    293                                     switch(Event.key.keysym.sym)
    294                                     {
    295                                         case SDLK_6:
    296                                             ev.key = SDLK_CARET; break;
    297                                         case SDLK_7:
    298                                         case SDLK_9:
    299                                         case SDLK_0:
    300                                             ev.key -= 17; break;
    301                                         case SDLK_8:
    302                                             ev.key = SDLK_ASTERISK; break;
    303                                         case SDLK_MINUS:
    304                                             ev.key = SDLK_UNDERSCORE; break;
    305                                         case SDLK_EQUALS:
    306                                             ev.key = SDLK_PLUS; break;
    307                                         case SDLK_COMMA:
    308                                             ev.key = SDLK_LESS; break;
    309                                         case SDLK_PERIOD:
    310                                             ev.key = SDLK_GREATER; break;
    311                                         case SDLK_SLASH:
    312                                             ev.key = SDLK_QUESTION; break;
    313                                         case SDLK_SEMICOLON:
    314                                             ev.key = SDLK_COLON; break;
    315                                         case SDLK_QUOTE:
    316                                             ev.key = SDLK_QUOTEDBL; break;
    317                                         default:
    318                                             break;
    319                                     }
    320                                 }
    321                             }
    322                         }
    323                     }
    324                     break;
    325                 }
     318                }
     319                break;
    326320            }
    327321        }
    328         // No more events
    329         ewaiting = 0;
    330322    }
    331323}
     
    337329// able to detect that.
    338330//
    339 void handle_mouse(Event &ev)
     331static void handle_mouse(Event &ev)
    340332{
    341333    Uint8 buttons;
Note: See TracChangeset for help on using the changeset viewer.