uisimulator/sdl/button.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 by Felix Arends
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21
  22 #include "uisdl.h"
  23 #include "lcd-charcells.h"
  24 #include "lcd-remote.h"
  25 #include "config.h"
  26 #include "button.h"
  27 #include "kernel.h"
  28 #include "backlight.h"
  29 #include "misc.h"
  30
  31 #include "debug.h"
  32
  33 static intptr_t button_data; /* data value from last message dequeued */
  34
  35 #ifdef HAVE_TOUCHPAD
  36 static int mouse_coords = 0;
  37 static enum touchpad_mode touchpad_mode = TOUCHPAD_POINT;
  38 void touchpad_set_mode(enum touchpad_mode mode)
  39 {
  40     touchpad_mode = mode;
  41 }
  42 enum touchpad_mode touchpad_get_mode(void)
  43 {
  44     return touchpad_mode;
  45 }
  46 #endif
  47 /* how long until repeat kicks in */
  48 #define REPEAT_START      6
  49
  50 /* the speed repeat starts at */
  51 #define REPEAT_INTERVAL_START   4
  52
  53 /* speed repeat finishes at */
  54 #define REPEAT_INTERVAL_FINISH  2
  55
  56 #if defined(IRIVER_H100_SERIES) || defined (IRIVER_H300_SERIES)
  57 int _remote_type=REMOTETYPE_H100_LCD;
  58
  59 int remote_type(void)
  60 {
  61     return _remote_type;
  62 }
  63 #endif
  64
  65 struct event_queue button_queue;
  66
  67 static int btn = 0;    /* Hopefully keeps track of currently pressed keys... */
  68
  69 #ifdef HAVE_BACKLIGHT
  70 static bool filter_first_keypress;
  71
  72 void set_backlight_filter_keypress(bool value)
  73 {
  74     filter_first_keypress = value;
  75 }
  76 #ifdef HAVE_REMOTE_LCD
  77 static bool remote_filter_first_keypress;
  78
  79 void set_remote_backlight_filter_keypress(bool value)
  80 {
  81     remote_filter_first_keypress = value;
  82 }
  83 #endif
  84 #endif
  85
  86 #ifdef HAS_BUTTON_HOLD
  87 bool hold_button_state = false;
  88 bool button_hold(void) {
  89     return hold_button_state;
  90 }
  91 #endif
  92
  93 #ifdef HAS_REMOTE_BUTTON_HOLD
  94 bool remote_hold_button_state = false;
  95 bool remote_button_hold(void) {
  96     return remote_hold_button_state;
  97 }
  98 #endif
  99
 100 static int lastbtn;
 101 void button_event(int key, bool pressed)
 102 {
 103     int new_btn = 0;
 104     int diff = 0;
 105     int data = 0;
 106     static int count = 0;
 107     static int repeat_speed = REPEAT_INTERVAL_START;
 108     static int repeat_count = 0;
 109     static bool repeat = false;
 110     static bool post = false;
 111 #ifdef HAVE_BACKLIGHT
 112     static bool skip_release = false;
 113 #ifdef HAVE_REMOTE_LCD
 114     static bool skip_remote_release = false;
 115 #endif
 116 #endif
 117     static bool usb_connected = false;
 118     if (usb_connected && key != SDLK_u)
 119         return;
 120     switch (key)
 121     {
 122
 123 #ifdef HAVE_TOUCHPAD
 124     case BUTTON_TOUCHPAD:
 125         data = mouse_coords;
 126         switch (touchpad_mode)
 127         {
 128             case TOUCHPAD_POINT:
 129                 new_btn = BUTTON_TOUCHPAD;
 130                 break;
 131             case TOUCHPAD_BUTTON:
 132             {
 133                 static int touchpad_buttons[3][3] = {
 134                     {BUTTON_TOPLEFT, BUTTON_TOPMIDDLE, BUTTON_TOPRIGHT},
 135                     {BUTTON_MIDLEFT, BUTTON_CENTER, BUTTON_MIDRIGHT},
 136                     {BUTTON_BOTTOMLEFT, BUTTON_BOTTOMMIDDLE, BUTTON_BOTTOMRIGHT},
 137                 };
 138                 int px_x = ((data&0xffff0000)>>16), px_y = ((data&0x0000ffff));
 139                 new_btn = touchpad_buttons[px_y/(LCD_HEIGHT/3)][px_x/(LCD_WIDTH/3)];
 140                 break;
 141             }
 142         }
 143         break;
 144     case SDLK_KP7:
 145         new_btn = BUTTON_TOPLEFT;
 146         break;
 147     case SDLK_KP8:
 148         new_btn = BUTTON_TOPMIDDLE;
 149         break;
 150     case SDLK_KP9:
 151         new_btn = BUTTON_TOPRIGHT;
 152         break;
 153     case SDLK_KP4:
 154         new_btn = BUTTON_MIDLEFT;
 155         break;
 156     case SDLK_KP5:
 157         new_btn = BUTTON_CENTER;
 158         break;
 159     case SDLK_KP6:
 160         new_btn = BUTTON_MIDRIGHT;
 161         break;
 162     case SDLK_KP1:
 163         new_btn = BUTTON_BOTTOMLEFT;
 164         break;
 165     case SDLK_KP2:
 166         new_btn = BUTTON_BOTTOMMIDDLE;
 167         break;
 168     case SDLK_KP3:
 169         new_btn = BUTTON_BOTTOMRIGHT;
 170         break;
 171     case SDLK_F4:
 172         if(pressed)
 173         {
 174             touchpad_mode = (touchpad_mode == TOUCHPAD_POINT ? TOUCHPAD_BUTTON : TOUCHPAD_POINT);
 175             printf("Touchpad mode: %s\n", touchpad_mode == TOUCHPAD_POINT ? "TOUCHPAD_POINT" : "TOUCHPAD_BUTTON");
 176         }
 177         break;
 178
 179 #endif
 180     case SDLK_u:
 181         if (!pressed)
 182         {
 183             usb_connected = !usb_connected;
 184             if (usb_connected)
 185                 queue_post(&button_queue, SYS_USB_CONNECTED, 0);
 186             else
 187                 queue_post(&button_queue, SYS_USB_DISCONNECTED, 0);
 188         }
 189         return;
 190
 191 #ifdef HAS_BUTTON_HOLD
 192     case SDLK_h:
 193         if(pressed)
 194         {
 195             hold_button_state = !hold_button_state;
 196             DEBUGF("Hold button is %s\n", hold_button_state?"ON":"OFF");
 197         }
 198         return;
 199 #endif
 200
 201 #ifdef HAS_REMOTE_BUTTON_HOLD
 202     case SDLK_j:
 203         if(pressed)
 204         {
 205             remote_hold_button_state = !remote_hold_button_state;
 206             DEBUGF("Remote hold button is %s\n",
 207                    remote_hold_button_state?"ON":"OFF");
 208         }
 209         return;
 210 #endif
 211
 212 #if CONFIG_KEYPAD == GIGABEAT_PAD
 213     case SDLK_KP4:
 214     case SDLK_LEFT:
 215         new_btn = BUTTON_LEFT;
 216         break;
 217     case SDLK_KP6:
 218     case SDLK_RIGHT:
 219         new_btn = BUTTON_RIGHT;
 220         break;
 221     case SDLK_KP8:
 222     case SDLK_UP:
 223         new_btn = BUTTON_UP;
 224         break;
 225     case SDLK_KP2:
 226     case SDLK_DOWN:
 227         new_btn = BUTTON_DOWN;
 228         break;
 229     case SDLK_KP_PLUS:
 230     case SDLK_F8:
 231         new_btn = BUTTON_POWER;
 232         break;
 233     case SDLK_ESCAPE:
 234         new_btn = BUTTON_POWER;
 235         break;
 236     case SDLK_KP_ENTER:
 237     case SDLK_RETURN:
 238     case SDLK_a:
 239         new_btn = BUTTON_A;
 240         break;
 241     case SDLK_KP5:
 242     case SDLK_SPACE:
 243         new_btn = BUTTON_SELECT;
 244         break;
 245     case SDLK_KP_PERIOD:
 246     case SDLK_INSERT:
 247         new_btn = BUTTON_MENU;
 248         break;
 249
 250 #elif CONFIG_KEYPAD == GIGABEAT_S_PAD
 251     case SDLK_KP4:
 252     case SDLK_LEFT:
 253         new_btn = BUTTON_LEFT;
 254         break;
 255     case SDLK_KP6:
 256     case SDLK_RIGHT:
 257         new_btn = BUTTON_RIGHT;
 258         break;
 259     case SDLK_KP8:
 260     case SDLK_UP:
 261         new_btn = BUTTON_UP;
 262         break;
 263     case SDLK_KP2:
 264     case SDLK_DOWN:
 265         new_btn = BUTTON_DOWN;
 266         break;
 267     case SDLK_F8:
 268     case SDLK_ESCAPE:
 269         new_btn = BUTTON_POWER;
 270         break;
 271     case SDLK_KP_PLUS:
 272     case SDLK_KP_ENTER:
 273     case SDLK_RETURN:
 274         new_btn = BUTTON_PLAY;
 275         break;
 276     case SDLK_KP7:
 277         new_btn = BUTTON_BACK;
 278         break;
 279     case SDLK_KP5:
 280     case SDLK_SPACE:
 281         new_btn = BUTTON_SELECT;
 282         break;
 283     case SDLK_KP9:
 284     case SDLK_KP_PERIOD:
 285     case SDLK_INSERT:
 286         new_btn = BUTTON_MENU;
 287         break;
 288
 289 #elif CONFIG_KEYPAD == IAUDIO_X5M5_PAD
 290     case SDLK_KP4:
 291     case SDLK_LEFT:
 292         new_btn = BUTTON_LEFT;
 293         break;
 294     case SDLK_KP6:
 295     case SDLK_RIGHT:
 296         new_btn = BUTTON_RIGHT;
 297         break;
 298     case SDLK_KP8:
 299     case SDLK_UP:
 300         new_btn = BUTTON_UP;
 301         break;
 302     case SDLK_KP2:
 303     case SDLK_DOWN:
 304         new_btn = BUTTON_DOWN;
 305         break;
 306     case SDLK_KP_PLUS:
 307     case SDLK_F8:
 308         new_btn = BUTTON_PLAY;
 309         break;
 310     case SDLK_ESCAPE:
 311         new_btn = BUTTON_POWER;
 312         break;
 313     case SDLK_KP_ENTER:
 314     case SDLK_RETURN:
 315     case SDLK_a:
 316         new_btn = BUTTON_POWER;
 317         break;
 318     case SDLK_KP_DIVIDE:
 319     case SDLK_F1:
 320         new_btn = BUTTON_REC;
 321         break;
 322     case SDLK_KP5:
 323     case SDLK_SPACE:
 324         new_btn = BUTTON_SELECT;
 325         break;
 326
 327 #elif CONFIG_KEYPAD == IAUDIO_M3_PAD
 328     case SDLK_KP4:
 329     case SDLK_LEFT:
 330         new_btn = BUTTON_LEFT;
 331         break;
 332     case SDLK_KP6:
 333     case SDLK_RIGHT:
 334         new_btn = BUTTON_RIGHT;
 335         break;
 336     case SDLK_KP8:
 337     case SDLK_UP:
 338         new_btn = BUTTON_VOL_UP;
 339         break;
 340     case SDLK_KP2:
 341     case SDLK_DOWN:
 342         new_btn = BUTTON_VOL_DOWN;
 343         break;
 344     case SDLK_KP_PERIOD:
 345     case SDLK_INSERT:
 346         new_btn = BUTTON_MODE;
 347         break;
 348     case SDLK_KP_DIVIDE:
 349     case SDLK_F1:
 350         new_btn = BUTTON_REC;
 351         break;
 352     case SDLK_KP5:
 353     case SDLK_SPACE:
 354         new_btn = BUTTON_PLAY;
 355         break;
 356
 357 #elif (CONFIG_KEYPAD == IPOD_1G2G_PAD) || (CONFIG_KEYPAD == IPOD_3G_PAD) \
 358    || (CONFIG_KEYPAD == IPOD_4G_PAD)
 359     case SDLK_KP4:
 360     case SDLK_LEFT:
 361         new_btn = BUTTON_LEFT;
 362         break;
 363     case SDLK_KP6:
 364     case SDLK_RIGHT:
 365         new_btn = BUTTON_RIGHT;
 366         break;
 367     case SDLK_KP8:
 368     case SDLK_UP:
 369         new_btn = BUTTON_SCROLL_BACK;
 370         break;
 371     case SDLK_KP2:
 372     case SDLK_DOWN:
 373         new_btn = BUTTON_SCROLL_FWD;
 374         break;
 375     case SDLK_KP_PLUS:
 376     case SDLK_F8:
 377         new_btn = BUTTON_PLAY;
 378         break;
 379     case SDLK_KP5:
 380     case SDLK_SPACE:
 381         new_btn = BUTTON_SELECT;
 382         break;
 383     case SDLK_KP_PERIOD:
 384     case SDLK_INSERT:
 385         new_btn = BUTTON_MENU;
 386         break;
 387
 388 #elif CONFIG_KEYPAD == IRIVER_H10_PAD
 389     case SDLK_KP4:
 390     case SDLK_LEFT:
 391         new_btn = BUTTON_LEFT;
 392         break;
 393     case SDLK_KP6:
 394     case SDLK_RIGHT:
 395         new_btn = BUTTON_RIGHT;
 396         break;
 397     case SDLK_KP8:
 398     case SDLK_UP:
 399         new_btn = BUTTON_SCROLL_UP;
 400         break;
 401     case SDLK_KP2:
 402     case SDLK_DOWN:
 403         new_btn = BUTTON_SCROLL_DOWN;
 404         break;
 405     case SDLK_KP_PLUS:
 406     case SDLK_F8:
 407         new_btn = BUTTON_POWER;
 408         break;
 409     case SDLK_ESCAPE:
 410         new_btn = BUTTON_POWER;
 411         break;
 412     case SDLK_KP_DIVIDE:
 413     case SDLK_F1:
 414         new_btn = BUTTON_REW;
 415         break;
 416     case SDLK_KP_MULTIPLY:
 417     case SDLK_F2:
 418         new_btn = BUTTON_FF;
 419         break;
 420     case SDLK_KP5:
 421     case SDLK_SPACE:
 422         new_btn = BUTTON_PLAY;
 423         break;
 424
 425 #elif (CONFIG_KEYPAD == IRIVER_H100_PAD) || (CONFIG_KEYPAD == IRIVER_H300_PAD)
 426     case SDLK_t:
 427         if(pressed)
 428             switch(_remote_type)
 429             {
 430                 case REMOTETYPE_UNPLUGGED:
 431                     _remote_type=REMOTETYPE_H100_LCD;
 432                     DEBUGF("Changed remote type to H100\n");
 433                     break;
 434                 case REMOTETYPE_H100_LCD:
 435                     _remote_type=REMOTETYPE_H300_LCD;
 436                     DEBUGF("Changed remote type to H300\n");
 437                     break;
 438                 case REMOTETYPE_H300_LCD:
 439                     _remote_type=REMOTETYPE_H300_NONLCD;
 440                     DEBUGF("Changed remote type to H300 NON-LCD\n");
 441                     break;
 442                 case REMOTETYPE_H300_NONLCD:
 443                     _remote_type=REMOTETYPE_UNPLUGGED;
 444                     DEBUGF("Changed remote type to none\n");
 445                     break;
 446             }
 447         break;
 448     case SDLK_KP4:
 449     case SDLK_LEFT:
 450         new_btn = BUTTON_LEFT;
 451         break;
 452     case SDLK_KP6:
 453     case SDLK_RIGHT:
 454         new_btn = BUTTON_RIGHT;
 455         break;
 456     case SDLK_KP8:
 457     case SDLK_UP:
 458         new_btn = BUTTON_UP;
 459         break;
 460     case SDLK_KP2:
 461     case SDLK_DOWN:
 462         new_btn = BUTTON_DOWN;
 463         break;
 464     case SDLK_KP_PLUS:
 465     case SDLK_F8:
 466         new_btn = BUTTON_ON;
 467         break;
 468     case SDLK_KP_ENTER:
 469     case SDLK_RETURN:
 470     case SDLK_a:
 471         new_btn = BUTTON_OFF;
 472         break;
 473     case SDLK_KP_DIVIDE:
 474     case SDLK_F1:
 475         new_btn = BUTTON_REC;
 476         break;
 477     case SDLK_KP5:
 478     case SDLK_SPACE:
 479         new_btn = BUTTON_SELECT;
 480         break;
 481     case SDLK_KP_PERIOD:
 482     case SDLK_INSERT:
 483         new_btn = BUTTON_MODE;
 484         break;
 485
 486 #elif CONFIG_KEYPAD == IRIVER_IFP7XX_PAD
 487     case SDLK_KP4:
 488     case SDLK_LEFT:
 489         new_btn = BUTTON_LEFT;
 490         break;
 491     case SDLK_KP6:
 492     case SDLK_RIGHT:
 493         new_btn = BUTTON_RIGHT;
 494         break;
 495     case SDLK_KP8:
 496     case SDLK_UP:
 497         new_btn = BUTTON_UP;
 498         break;
 499     case SDLK_KP2:
 500     case SDLK_DOWN:
 501         new_btn = BUTTON_DOWN;
 502         break;
 503     case SDLK_KP_PLUS:
 504     case SDLK_F8:
 505         new_btn = BUTTON_PLAY;
 506         break;
 507     case SDLK_KP_ENTER:
 508     case SDLK_RETURN:
 509     case SDLK_a:
 510        new_btn = BUTTON_EQ;
 511        break;
 512     case SDLK_KP5:
 513     case SDLK_SPACE:
 514         new_btn = BUTTON_SELECT;
 515         break;
 516     case SDLK_KP_PERIOD:
 517     case SDLK_INSERT:
 518         new_btn = BUTTON_MODE;
 519         break;
 520
 521 #elif CONFIG_KEYPAD == ONDIO_PAD
 522     case SDLK_KP4:
 523     case SDLK_LEFT:
 524         new_btn = BUTTON_LEFT;
 525         break;
 526     case SDLK_KP6:
 527     case SDLK_RIGHT:
 528         new_btn = BUTTON_RIGHT;
 529         break;
 530     case SDLK_KP8:
 531     case SDLK_UP:
 532         new_btn = BUTTON_UP;
 533         break;
 534     case SDLK_KP2:
 535     case SDLK_DOWN:
 536         new_btn = BUTTON_DOWN;
 537         break;
 538     case SDLK_KP_ENTER:
 539     case SDLK_RETURN:
 540     case SDLK_a:
 541         new_btn = BUTTON_OFF;
 542         break;
 543     case SDLK_KP_PERIOD:
 544     case SDLK_INSERT:
 545         new_btn = BUTTON_MENU;
 546         break;
 547
 548 #elif CONFIG_KEYPAD == PLAYER_PAD
 549     case SDLK_KP4:
 550     case SDLK_LEFT:
 551         new_btn = BUTTON_LEFT;
 552         break;
 553     case SDLK_KP6:
 554     case SDLK_RIGHT:
 555         new_btn = BUTTON_RIGHT;
 556         break;
 557     case SDLK_KP8:
 558     case SDLK_UP:
 559         new_btn = BUTTON_PLAY;
 560         break;
 561     case SDLK_KP2:
 562     case SDLK_DOWN:
 563         new_btn = BUTTON_STOP;
 564         break;
 565     case SDLK_KP_PLUS:
 566     case SDLK_F8:
 567         new_btn = BUTTON_ON;
 568         break;
 569     case SDLK_KP_PERIOD:
 570     case SDLK_INSERT:
 571         new_btn = BUTTON_MENU;
 572         break;
 573
 574 #elif CONFIG_KEYPAD == RECORDER_PAD
 575     case SDLK_KP4:
 576     case SDLK_LEFT:
 577         new_btn = BUTTON_LEFT;
 578         break;
 579     case SDLK_KP6:
 580     case SDLK_RIGHT:
 581         new_btn = BUTTON_RIGHT;
 582         break;
 583     case SDLK_KP8:
 584     case SDLK_UP:
 585         new_btn = BUTTON_UP;
 586         break;
 587     case SDLK_KP2:
 588     case SDLK_DOWN:
 589         new_btn = BUTTON_DOWN;
 590         break;
 591     case SDLK_KP_PLUS:
 592     case SDLK_F8:
 593         new_btn = BUTTON_ON;
 594         break;
 595     case SDLK_KP_ENTER:
 596     case SDLK_RETURN:
 597     case SDLK_a:
 598         new_btn = BUTTON_OFF;
 599         break;
 600     case SDLK_KP_DIVIDE:
 601     case SDLK_F1:
 602         new_btn = BUTTON_F1;
 603         break;
 604     case SDLK_KP_MULTIPLY:
 605     case SDLK_F2:
 606         new_btn = BUTTON_F2;
 607         break;
 608     case SDLK_KP_MINUS:
 609     case SDLK_F3:
 610         new_btn = BUTTON_F3;
 611         break;
 612     case SDLK_KP5:
 613     case SDLK_SPACE:
 614         new_btn = BUTTON_PLAY;
 615         break;
 616
 617 #elif CONFIG_KEYPAD == ARCHOS_AV300_PAD
 618     case SDLK_KP4:
 619     case SDLK_LEFT:
 620         new_btn = BUTTON_LEFT;
 621         break;
 622     case SDLK_KP6:
 623     case SDLK_RIGHT:
 624         new_btn = BUTTON_RIGHT;
 625         break;
 626     case SDLK_KP8:
 627     case SDLK_UP:
 628         new_btn = BUTTON_UP;
 629         break;
 630     case SDLK_KP2:
 631     case SDLK_DOWN:
 632         new_btn = BUTTON_DOWN;
 633         break;
 634     case SDLK_KP_PLUS:
 635     case SDLK_F8:
 636         new_btn = BUTTON_ON;
 637         break;
 638     case SDLK_KP_ENTER:
 639     case SDLK_RETURN:
 640     case SDLK_a:
 641         new_btn = BUTTON_OFF;
 642         break;
 643     case SDLK_KP_DIVIDE:
 644     case SDLK_F1:
 645         new_btn = BUTTON_F1;
 646         break;
 647     case SDLK_KP_MULTIPLY:
 648     case SDLK_F2:
 649         new_btn = BUTTON_F2;
 650         break;
 651     case SDLK_KP_MINUS:
 652     case SDLK_F3:
 653         new_btn = BUTTON_F3;
 654         break;
 655     case SDLK_KP5:
 656     case SDLK_SPACE:
 657         new_btn = BUTTON_SELECT;
 658         break;
 659
 660 #elif CONFIG_KEYPAD == SANSA_E200_PAD
 661     case SDLK_KP4:
 662     case SDLK_LEFT:
 663         new_btn = BUTTON_LEFT;
 664         break;
 665     case SDLK_KP6:
 666     case SDLK_RIGHT:
 667         new_btn = BUTTON_RIGHT;
 668         break;
 669     case SDLK_KP8:
 670     case SDLK_UP:
 671         new_btn = BUTTON_SCROLL_BACK;
 672         break;
 673     case SDLK_KP2:
 674     case SDLK_DOWN:
 675         new_btn = BUTTON_SCROLL_FWD;
 676         break;
 677     case SDLK_KP9:
 678         new_btn = BUTTON_UP;
 679         break;
 680     case SDLK_KP3:
 681         new_btn = BUTTON_DOWN;
 682         break;
 683     case SDLK_KP1:
 684         new_btn = BUTTON_POWER;
 685         break;
 686     case SDLK_KP7:
 687         new_btn = BUTTON_REC;
 688         break;
 689     case SDLK_KP5:
 690     case SDLK_SPACE:
 691         new_btn = BUTTON_SELECT;
 692         break;
 693
 694 #elif CONFIG_KEYPAD == SANSA_C200_PAD
 695     case SDLK_KP4:
 696     case SDLK_LEFT:
 697         new_btn = BUTTON_LEFT;
 698         break;
 699     case SDLK_KP6:
 700     case SDLK_RIGHT:
 701         new_btn = BUTTON_RIGHT;
 702         break;
 703     case SDLK_KP8:
 704     case SDLK_UP:
 705         new_btn = BUTTON_UP;
 706         break;
 707     case SDLK_KP2:
 708     case SDLK_DOWN:
 709         new_btn = BUTTON_DOWN;
 710         break;
 711     case SDLK_KP3:
 712         new_btn = BUTTON_POWER;
 713         break;
 714     case SDLK_KP1:
 715         new_btn = BUTTON_REC;
 716         break;
 717     case SDLK_KP5:
 718     case SDLK_KP_ENTER:
 719     case SDLK_RETURN:
 720         new_btn = BUTTON_SELECT;
 721         break;
 722     case SDLK_KP7:
 723         new_btn = BUTTON_VOL_DOWN;
 724         break;
 725     case SDLK_KP9:
 726         new_btn = BUTTON_VOL_UP;
 727         break;
 728
 729 #elif CONFIG_KEYPAD == MROBE500_PAD
 730     case SDLK_F9:
 731         new_btn = BUTTON_RC_HEART;
 732         break;
 733     case SDLK_F10:
 734         new_btn = BUTTON_RC_MODE;
 735         break;
 736     case SDLK_F11:
 737         new_btn = BUTTON_RC_VOL_DOWN;
 738         break;
 739     case SDLK_F12:
 740         new_btn = BUTTON_RC_VOL_UP;
 741         break;
 742     case SDLK_LEFT:
 743         new_btn = BUTTON_LEFT;
 744         break;
 745     case SDLK_RIGHT:
 746         new_btn = BUTTON_RIGHT;
 747         break;
 748     case SDLK_UP:
 749         new_btn = BUTTON_RC_PLAY;
 750         break;
 751     case SDLK_DOWN:
 752         new_btn = BUTTON_RC_DOWN;
 753         break;
 754     case SDLK_F8:
 755     case SDLK_ESCAPE:
 756         new_btn = BUTTON_POWER;
 757         break;
 758 #elif CONFIG_KEYPAD == MROBE100_PAD
 759     case SDLK_KP1:
 760         new_btn = BUTTON_DISPLAY;
 761         break;
 762     case SDLK_KP7:
 763         new_btn = BUTTON_MENU;
 764         break;
 765     case SDLK_KP9:
 766         new_btn = BUTTON_PLAY;
 767         break;
 768     case SDLK_KP4:
 769     case SDLK_LEFT:
 770         new_btn = BUTTON_LEFT;
 771         break;
 772     case SDLK_KP6:
 773     case SDLK_RIGHT:
 774         new_btn = BUTTON_RIGHT;
 775         break;
 776     case SDLK_KP8:
 777     case SDLK_UP:
 778         new_btn = BUTTON_UP;
 779         break;
 780     case SDLK_KP2:
 781     case SDLK_DOWN:
 782         new_btn = BUTTON_DOWN;
 783         break;
 784     case SDLK_KP5:
 785     case SDLK_SPACE:
 786         new_btn = BUTTON_SELECT;
 787         break;
 788     case SDLK_KP_MULTIPLY:
 789     case SDLK_F8:
 790     case SDLK_ESCAPE:
 791         new_btn = BUTTON_POWER;
 792         break;
 793
 794 #elif CONFIG_KEYPAD == COWOND2_PAD
 795     case SDLK_ESCAPE:
 796         new_btn = BUTTON_POWER;
 797         break;
 798     case SDLK_KP_PLUS:
 799         new_btn = BUTTON_PLUS;
 800         break;
 801     case SDLK_KP_MINUS:
 802         new_btn = BUTTON_MINUS;
 803         break;
 804     case SDLK_KP_ENTER:
 805         new_btn = BUTTON_MENU;
 806         break;
 807
 808 #elif CONFIG_KEYPAD == CREATIVEZVM_PAD
 809     case SDLK_KP1:
 810         new_btn = BUTTON_BACK;
 811         break;
 812     case SDLK_KP3:
 813         new_btn = BUTTON_MENU;
 814         break;
 815     case SDLK_KP7:
 816         new_btn = BUTTON_CUSTOM;
 817         break;
 818     case SDLK_KP9:
 819         new_btn = BUTTON_PLAY;
 820         break;
 821     case SDLK_KP4:
 822     case SDLK_LEFT:
 823         new_btn = BUTTON_LEFT;
 824         break;
 825     case SDLK_KP6:
 826     case SDLK_RIGHT:
 827         new_btn = BUTTON_RIGHT;
 828         break;
 829     case SDLK_KP8:
 830     case SDLK_UP:
 831         new_btn = BUTTON_UP;
 832         break;
 833     case SDLK_KP2:
 834     case SDLK_DOWN:
 835         new_btn = BUTTON_DOWN;
 836         break;
 837     case SDLK_KP5:
 838     case SDLK_SPACE:
 839         new_btn = BUTTON_SELECT;
 840         break;
 841     case SDLK_KP_MULTIPLY:
 842     case SDLK_F8:
 843     case SDLK_ESCAPE:
 844         new_btn = BUTTON_POWER;
 845         break;
 846 #elif CONFIG_KEYPAD == CREATIVEZV_PAD
 847     case SDLK_KP1:
 848         new_btn = BUTTON_PREV;
 849         break;
 850     case SDLK_KP3:
 851         new_btn = BUTTON_NEXT;
 852         break;
 853     case SDLK_KP7:
 854         new_btn = BUTTON_BACK;
 855         break;
 856     case SDLK_p:
 857         new_btn = BUTTON_PLAY;
 858         break;
 859     case SDLK_KP9:
 860         new_btn = BUTTON_MENU;
 861         break;
 862     case SDLK_KP4:
 863     case SDLK_LEFT:
 864         new_btn = BUTTON_LEFT;
 865         break;
 866     case SDLK_KP6:
 867     case SDLK_RIGHT:
 868         new_btn = BUTTON_RIGHT;
 869         break;
 870     case SDLK_KP8:
 871     case SDLK_UP:
 872         new_btn = BUTTON_UP;
 873         break;
 874     case SDLK_KP2:
 875     case SDLK_DOWN:
 876         new_btn = BUTTON_DOWN;
 877         break;
 878     case SDLK_KP5:
 879     case SDLK_SPACE:
 880         new_btn = BUTTON_SELECT;
 881         break;
 882     case SDLK_KP_MULTIPLY:
 883     case SDLK_F8:
 884     case SDLK_ESCAPE:
 885         new_btn = BUTTON_POWER;
 886         break;
 887     case SDLK_z:
 888         new_btn = BUTTON_VOL_DOWN;
 889         break;
 890     case SDLK_s:
 891         new_btn = BUTTON_VOL_UP;
 892
 893 #elif CONFIG_KEYPAD == MEIZU_M6SL_PAD
 894     case SDLK_KP1:
 895         new_btn = BUTTON_PREV;
 896         break;
 897     case SDLK_KP3:
 898         new_btn = BUTTON_NEXT;
 899         break;
 900     case SDLK_KP_ENTER:
 901     case SDLK_RETURN:
 902     case SDLK_a:
 903         new_btn = BUTTON_PLAY;
 904         break;
 905     case SDLK_KP_PERIOD:
 906     case SDLK_INSERT:
 907         new_btn = BUTTON_MENU;
 908         break;
 909     case SDLK_KP8:
 910     case SDLK_UP:
 911         new_btn = BUTTON_UP;
 912         break;
 913     case SDLK_KP2:
 914     case SDLK_DOWN:
 915         new_btn = BUTTON_DOWN;
 916         break;
 917     case SDLK_KP5:
 918     case SDLK_SPACE:
 919         new_btn = BUTTON_SELECT;
 920         break;
 921 #else
 922 #error No keymap defined!
 923 #endif /* CONFIG_KEYPAD */
 924     case SDLK_KP0:
 925     case SDLK_F5:
 926         if(pressed)
 927         {
 928             queue_broadcast(SYS_SCREENDUMP, 0);
 929             return;
 930         }
 931         break;
 932     }
 933
 934     if (pressed)
 935         btn |= new_btn;
 936     else
 937         btn &= ~new_btn;
 938
 939     /* Lots of stuff copied from real button.c. Not good, I think... */
 940
 941     /* Find out if a key has been released */
 942     diff = btn ^ lastbtn;
 943     if(diff && (btn & diff) == 0)
 944     {
 945 #ifdef HAVE_BACKLIGHT
 946 #ifdef HAVE_REMOTE_LCD
 947         if(diff & BUTTON_REMOTE)
 948             if(!skip_remote_release)
 949                 queue_post(&button_queue, BUTTON_REL | diff, data);
 950             else
 951                 skip_remote_release = false;
 952         else
 953 #endif
 954             if(!skip_release)
 955                 queue_post(&button_queue, BUTTON_REL | diff, data);
 956             else
 957                 skip_release = false;
 958 #else
 959         queue_post(&button_queue, BUTTON_REL | diff, data);
 960 #endif
 961     }
 962
 963     else
 964     {
 965         if ( btn )
 966         {
 967             /* normal keypress */
 968             if ( btn != lastbtn )
 969             {
 970                 post = true;
 971                 repeat = false;
 972                 repeat_speed = REPEAT_INTERVAL_START;
 973
 974             }
 975             else /* repeat? */
 976             {
 977                 if ( repeat )
 978                 {
 979                     if (!post)
 980                         count--;
 981                     if (count == 0)
 982                     {
 983                         post = true;
 984                         /* yes we have repeat */
 985                         repeat_speed--;
 986                         if (repeat_speed < REPEAT_INTERVAL_FINISH)
 987                             repeat_speed = REPEAT_INTERVAL_FINISH;
 988                         count = repeat_speed;
 989
 990                         repeat_count++;
 991                     }
 992                 }
 993                 else
 994                 {
 995                     if (count++ > REPEAT_START)
 996                     {
 997                         post = true;
 998                         repeat = true;
 999                         repeat_count = 0;
1000                         /* initial repeat */
1001                         count = REPEAT_INTERVAL_START;
1002                     }
1003                 }
1004             }
1005             if ( post )
1006             {
1007                 if(repeat)
1008                 {
1009                     if (queue_empty(&button_queue))
1010                     {
1011                         queue_post(&button_queue, BUTTON_REPEAT | btn, data);
1012 #ifdef HAVE_BACKLIGHT
1013 #ifdef HAVE_REMOTE_LCD
1014                             if(btn & BUTTON_REMOTE)
1015                             {
1016                                 if(skip_remote_release)
1017                                     skip_remote_release = false;
1018                             }
1019                             else
1020 #endif
1021                                 if(skip_release)
1022                                     skip_release = false;
1023 #endif
1024                         post = false;
1025                     }
1026                 }
1027                 else
1028                 {
1029 #ifdef HAVE_BACKLIGHT
1030 #ifdef HAVE_REMOTE_LCD
1031                         if (btn & BUTTON_REMOTE) {
1032                             if (!remote_filter_first_keypress
1033                                 || is_remote_backlight_on(false))
1034                                 queue_post(&button_queue, btn, data);
1035                             else
1036                                 skip_remote_release = true;
1037                         }
1038                         else
1039 #endif
1040                             if (!filter_first_keypress
1041                                 || is_backlight_on(false))
1042                                 queue_post(&button_queue, btn, data);
1043                             else
1044                                 skip_release = true;
1045 #else /* no backlight, nothing to skip */
1046                         queue_post(&button_queue, btn, data);
1047 #endif
1048                     post = false;
1049                 }
1050
1051 #ifdef HAVE_REMOTE_LCD
1052                 if(btn & BUTTON_REMOTE)
1053                     remote_backlight_on();
1054                 else
1055 #endif
1056                     backlight_on();
1057
1058             }
1059         }
1060         else
1061         {
1062             repeat = false;
1063             count = 0;
1064         }
1065     }
1066     lastbtn = btn & ~(BUTTON_REL | BUTTON_REPEAT);
1067 }
1068
1069 /* Again copied from real button.c... */
1070
1071 int button_queue_count( void )
1072 {
1073     return queue_count(&button_queue);
1074 }
1075
1076 long button_get(bool block)
1077 {
1078     struct queue_event ev;
1079
1080     if ( block || !queue_empty(&button_queue) ) {
1081         queue_wait(&button_queue, &ev);
1082         button_data = ev.data;
1083         return ev.id;
1084     }
1085     return BUTTON_NONE;
1086 }
1087
1088 long button_get_w_tmo(int ticks)
1089 {
1090     struct queue_event ev;
1091     queue_wait_w_tmo(&button_queue, &ev, ticks);
1092     if (ev.id == SYS_TIMEOUT)
1093         ev.id = BUTTON_NONE;
1094     else
1095         button_data = ev.data;
1096
1097     return ev.id;
1098 }
1099
1100 intptr_t button_get_data(void)
1101 {
1102 #ifdef HAVE_TOUCHPAD
1103     return button_data;
1104 #else
1105     /* Needed by the accelerating wheel driver for Sansa e200 */
1106     return 1 << 24;
1107 #endif
1108 }
1109
1110 #ifdef HAVE_TOUCHPAD
1111 extern bool debug_wps;
1112 void mouse_tick_task(void)
1113 {
1114     static int last_check = 0;
1115     int x,y;
1116     if (TIME_BEFORE(current_tick, last_check+(HZ/10)))
1117         return;
1118     last_check = current_tick;
1119     if (SDL_GetMouseState(&x, &y) & SDL_BUTTON(SDL_BUTTON_LEFT))
1120     {
1121         if(background)
1122         {
1123             x -= UI_LCD_POSX;
1124             y -= UI_LCD_POSY;
1125
1126             if(x<0 || y<0 || x>UI_LCD_WIDTH || y>UI_LCD_HEIGHT)
1127                 return;
1128         }
1129
1130         mouse_coords = (x<<16)|y;
1131         button_event(BUTTON_TOUCHPAD, true);
1132         if (debug_wps)
1133             printf("Mouse at: (%d, %d)\n", x, y);
1134     }
1135 }
1136 #endif
1137 void button_init(void)
1138 {
1139 #ifdef HAVE_TOUCHPAD
1140     tick_add_task(mouse_tick_task);
1141 #endif
1142 }
1143
1144 int button_status(void)
1145 {
1146     return btn;
1147 }
1148
1149 void button_clear_queue(void)
1150 {
1151     queue_clear(&button_queue);
1152 }
1153