Changeset 647


Ignore:
Timestamp:
May 13, 2011, 1:53:10 PM (9 years ago)
Author:
Sam Hocevar
Message:

sdlport: mouse handling refactoring.

File:
1 edited

Legend:

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

    r645 r647  
    4040short mouse_buttons[5] = { 0, 0, 0, 0, 0 };
    4141
    42 // Pre-declarations
    43 static void handle_mouse(Event &ev);
    44 
    4542//
    4643// Constructor
     
    119116    ev.mouse_button = mouse->button();
    120117
    121     // Gather events
     118    // Gather next event
    122119    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)
    130         {
    131             case SDL_QUIT:
    132             {
    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)
    230                         {
    231                             // Toggle fullscreen
    232                             SDL_WM_ToggleFullScreen(SDL_GetVideoSurface());
    233                         }
    234                         ev.key = EV_SPURIOUS;
    235                         break;
    236                     }
    237                     case SDLK_F12:
    238                     {
    239                         // Only handle key down
    240                         if(ev.type == EV_KEY)
    241                         {
    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                             }
    253                         }
    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)
    261                         {
    262                             // Grab a screenshot
    263                             SDL_SaveBMP(SDL_GetVideoSurface(), "screenshot.bmp");
    264                             the_game->show_help("Screenshot saved to: screenshot.bmp.\n");
    265                         }
    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)
    275                         {
    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                             }
    316                         }
    317                     }
    318                 }
    319                 break;
    320             }
    321         }
    322     }
    323 }
    324 
    325 //
    326 // Handle mouse motion and button presses
    327 // We don't handle the mousewheel here as
    328 // SDL_GetMouseState doesn't seem to be
    329 // able to detect that.
    330 //
    331 static void handle_mouse(Event &ev)
    332 {
    333     Uint8 buttons;
     120    if (!SDL_PollEvent(&sdlev))
     121        return; // This should not happen
     122
     123    // Sort the mouse out
    334124    int x, y;
    335 
    336     // always sort the mouse out
    337     buttons = SDL_GetMouseState(&x, &y);
     125    uint8_t buttons = SDL_GetMouseState(&x, &y);
    338126    x = Min((x << 16) / mouse_xscale, main_screen->Size().x - 1);
    339127    y = Min((y << 16) / mouse_yscale, main_screen->Size().y - 1);
     
    385173        ev.mouse_button &= (0xff - RIGHT_BUTTON);
    386174    }
     175    mouse->update(ev.mouse_move.x, ev.mouse_move.y, ev.mouse_button);
     176
     177    // Sort out other kinds of events
     178    switch(sdlev.type)
     179    {
     180    case SDL_QUIT:
     181        exit(0);
     182        break;
     183    case SDL_MOUSEBUTTONUP:
     184        switch(sdlev.button.button)
     185        {
     186        case 4:        // Mouse wheel goes up...
     187            ev.key = get_key_binding("b4", 0);
     188            ev.type = EV_KEYRELEASE;
     189            break;
     190        case 5:        // Mouse wheel goes down...
     191            ev.key = get_key_binding("b3", 0);
     192            ev.type = EV_KEYRELEASE;
     193            break;
     194        }
     195        break;
     196    case SDL_MOUSEBUTTONDOWN:
     197        switch(sdlev.button.button)
     198        {
     199        case 4:        // Mouse wheel goes up...
     200            ev.key = get_key_binding("b4", 0);
     201            ev.type = EV_KEY;
     202            break;
     203        case 5:        // Mouse wheel goes down...
     204            ev.key = get_key_binding("b3", 0);
     205            ev.type = EV_KEY;
     206            break;
     207        }
     208        break;
     209    case SDL_KEYDOWN:
     210    case SDL_KEYUP:
     211        // Default to EV_SPURIOUS
     212        ev.key = EV_SPURIOUS;
     213        if(sdlev.type == SDL_KEYDOWN)
     214        {
     215            ev.type = EV_KEY;
     216        }
     217        else
     218        {
     219            ev.type = EV_KEYRELEASE;
     220        }
     221        switch(sdlev.key.keysym.sym)
     222        {
     223        case SDLK_DOWN:         ev.key = JK_DOWN; break;
     224        case SDLK_UP:           ev.key = JK_UP; break;
     225        case SDLK_LEFT:         ev.key = JK_LEFT; break;
     226        case SDLK_RIGHT:        ev.key = JK_RIGHT; break;
     227        case SDLK_LCTRL:        ev.key = JK_CTRL_L; break;
     228        case SDLK_RCTRL:        ev.key = JK_CTRL_R; break;
     229        case SDLK_LALT:         ev.key = JK_ALT_L; break;
     230        case SDLK_RALT:         ev.key = JK_ALT_R; break;
     231        case SDLK_LSHIFT:       ev.key = JK_SHIFT_L; break;
     232        case SDLK_RSHIFT:       ev.key = JK_SHIFT_R; break;
     233        case SDLK_NUMLOCK:      ev.key = JK_NUM_LOCK; break;
     234        case SDLK_HOME:         ev.key = JK_HOME; break;
     235        case SDLK_END:          ev.key = JK_END; break;
     236        case SDLK_BACKSPACE:    ev.key = JK_BACKSPACE; break;
     237        case SDLK_TAB:          ev.key = JK_TAB; break;
     238        case SDLK_RETURN:       ev.key = JK_ENTER; break;
     239        case SDLK_SPACE:        ev.key = JK_SPACE; break;
     240        case SDLK_CAPSLOCK:     ev.key = JK_CAPS; break;
     241        case SDLK_ESCAPE:       ev.key = JK_ESC; break;
     242        case SDLK_F1:           ev.key = JK_F1; break;
     243        case SDLK_F2:           ev.key = JK_F2; break;
     244        case SDLK_F3:           ev.key = JK_F3; break;
     245        case SDLK_F4:           ev.key = JK_F4; break;
     246        case SDLK_F5:           ev.key = JK_F5; break;
     247        case SDLK_F6:           ev.key = JK_F6; break;
     248        case SDLK_F7:           ev.key = JK_F7; break;
     249        case SDLK_F8:           ev.key = JK_F8; break;
     250        case SDLK_F9:           ev.key = JK_F9; break;
     251        case SDLK_F10:          ev.key = JK_F10; break;
     252        case SDLK_INSERT:       ev.key = JK_INSERT; break;
     253        case SDLK_KP0:          ev.key = JK_INSERT; break;
     254        case SDLK_PAGEUP:       ev.key = JK_PAGEUP; break;
     255        case SDLK_PAGEDOWN:     ev.key = JK_PAGEDOWN; break;
     256        case SDLK_KP8:          ev.key = JK_UP; break;
     257        case SDLK_KP2:          ev.key = JK_DOWN; break;
     258        case SDLK_KP4:          ev.key = JK_LEFT; break;
     259        case SDLK_KP6:          ev.key = JK_RIGHT; break;
     260        case SDLK_F11:
     261            // Only handle key down
     262            if(ev.type == EV_KEY)
     263            {
     264                // Toggle fullscreen
     265                SDL_WM_ToggleFullScreen(SDL_GetVideoSurface());
     266            }
     267            ev.key = EV_SPURIOUS;
     268            break;
     269        case SDLK_F12:
     270            // Only handle key down
     271            if(ev.type == EV_KEY)
     272            {
     273                // Toggle grab mouse
     274                if(SDL_WM_GrabInput(SDL_GRAB_QUERY) == SDL_GRAB_ON)
     275                {
     276                    the_game->show_help("Grab Mouse: OFF\n");
     277                    SDL_WM_GrabInput(SDL_GRAB_OFF);
     278                }
     279                else
     280                {
     281                    the_game->show_help("Grab Mouse: ON\n");
     282                    SDL_WM_GrabInput(SDL_GRAB_ON);
     283                }
     284            }
     285            ev.key = EV_SPURIOUS;
     286            break;
     287        case SDLK_PRINT:    // print-screen key
     288            // Only handle key down
     289            if(ev.type == EV_KEY)
     290            {
     291                // Grab a screenshot
     292                SDL_SaveBMP(SDL_GetVideoSurface(), "screenshot.bmp");
     293                the_game->show_help("Screenshot saved to: screenshot.bmp.\n");
     294            }
     295            ev.key = EV_SPURIOUS;
     296            break;
     297        default:
     298            ev.key = (int)sdlev.key.keysym.sym;
     299            // Need to handle the case of shift being pressed
     300            // There has to be a better way
     301            if((sdlev.key.keysym.mod & KMOD_SHIFT) != 0)
     302            {
     303                if(sdlev.key.keysym.sym >= SDLK_a &&
     304                    sdlev.key.keysym.sym <= SDLK_z)
     305                {
     306                    ev.key -= 32;
     307                }
     308                else if(sdlev.key.keysym.sym >= SDLK_1 &&
     309                         sdlev.key.keysym.sym <= SDLK_5)
     310                {
     311                    ev.key -= 16;
     312                }
     313                else
     314                {
     315                    switch(sdlev.key.keysym.sym)
     316                    {
     317                    case SDLK_6:
     318                        ev.key = SDLK_CARET; break;
     319                    case SDLK_7:
     320                    case SDLK_9:
     321                    case SDLK_0:
     322                        ev.key -= 17; break;
     323                    case SDLK_8:
     324                        ev.key = SDLK_ASTERISK; break;
     325                    case SDLK_MINUS:
     326                        ev.key = SDLK_UNDERSCORE; break;
     327                    case SDLK_EQUALS:
     328                        ev.key = SDLK_PLUS; break;
     329                    case SDLK_COMMA:
     330                        ev.key = SDLK_LESS; break;
     331                    case SDLK_PERIOD:
     332                        ev.key = SDLK_GREATER; break;
     333                    case SDLK_SLASH:
     334                        ev.key = SDLK_QUESTION; break;
     335                    case SDLK_SEMICOLON:
     336                        ev.key = SDLK_COLON; break;
     337                    case SDLK_QUOTE:
     338                        ev.key = SDLK_QUOTEDBL; break;
     339                    default:
     340                        break;
     341                    }
     342                }
     343            }
     344            break;
     345        }
     346    }
    387347}
     348
Note: See TracChangeset for help on using the changeset viewer.