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  * All files in this archive are subject to the GNU General Public License.
  13  * See the file COPYING in the source tree root for full license agreement.
  14  *
  15  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  16  * KIND, either express or implied.
  17  *
  18  ****************************************************************************/
  19
  20 #include "uisdl.h"
  21 #include "lcd-charcell.h"
  22 #include "lcd-remote.h"
  23 #include "config.h"
  24 #include "button.h"
  25 #include "kernel.h"
  26 #include "backlight.h"
  27 #include "misc.h"
  28
  29 #include "debug.h"
  30 /* how long until repeat kicks in */
  31 #define REPEAT_START      6
  32
  33 /* the speed repeat starts at */
  34 #define REPEAT_INTERVAL_START   4
  35
  36 /* speed repeat finishes at */
  37 #define REPEAT_INTERVAL_FINISH  2
  38
  39 #if defined(IRIVER_H100_SERIES) || defined (IRIVER_H300_SERIES)
  40 int _remote_type=REMOTETYPE_H100_LCD;
  41
  42 int remote_type(void)
  43 {
  44     return _remote_type;
  45 }
  46 #endif
  47
  48 struct event_queue button_queue;
  49
  50 static int btn = 0;    /* Hopefully keeps track of currently pressed keys... */
  51
  52 #if CONFIG_BACKLIGHT
  53 static bool filter_first_keypress;
  54
  55 void set_backlight_filter_keypress(bool value)
  56 {
  57     filter_first_keypress = value;
  58 }
  59 #ifdef HAVE_REMOTE_LCD
  60 static bool remote_filter_first_keypress;
  61
  62 void set_remote_backlight_filter_keypress(bool value)
  63 {
  64     remote_filter_first_keypress = value;
  65 }
  66 #endif
  67 #endif
  68
  69 #ifdef HAS_BUTTON_HOLD
  70 bool hold_button_state = false;
  71 bool button_hold(void) {
  72     return hold_button_state;
  73 }
  74 #endif
  75
  76 #ifdef HAS_REMOTE_BUTTON_HOLD
  77 bool remote_hold_button_state = false;
  78 bool remote_button_hold(void) {
  79     return remote_hold_button_state;
  80 }
  81 #endif
  82
  83 void button_event(int key, bool pressed)
  84 {
  85     int new_btn = 0;
  86     int diff = 0;
  87     static int count = 0;
  88     static int lastbtn;
  89     static int repeat_speed = REPEAT_INTERVAL_START;
  90     static int repeat_count = 0;
  91     static bool repeat = false;
  92     static bool post = false;
  93 #if CONFIG_BACKLIGHT
  94     static bool skip_release = false;
  95 #ifdef HAVE_REMOTE_LCD
  96     static bool skip_remote_release = false;
  97 #endif
  98 #endif
  99     static bool usb_connected = false;
 100     if (usb_connected && key != SDLK_u)
 101         return;
 102     switch (key)
 103     {
 104
 105     case SDLK_u:
 106         if (!pressed)
 107         {
 108             usb_connected = !usb_connected;
 109             if (usb_connected)
 110                 queue_post(&button_queue, SYS_USB_CONNECTED, 0);
 111             else
 112                 queue_post(&button_queue, SYS_USB_DISCONNECTED, 0);
 113         }
 114         return;
 115
 116 #ifdef HAS_BUTTON_HOLD
 117     case SDLK_h:
 118         if(pressed)
 119         {
 120             hold_button_state = !hold_button_state;
 121             DEBUGF("Hold button is %s\n", hold_button_state?"ON":"OFF");
 122         }
 123         return;
 124 #endif
 125
 126 #ifdef HAS_REMOTE_BUTTON_HOLD
 127     case SDLK_j:
 128         if(pressed)
 129         {
 130             remote_hold_button_state = !remote_hold_button_state;
 131             DEBUGF("Remote hold button is %s\n",
 132                    remote_hold_button_state?"ON":"OFF");
 133         }
 134         return;
 135 #endif
 136
 137 #if CONFIG_KEYPAD == GIGABEAT_PAD
 138     case SDLK_KP4:
 139     case SDLK_LEFT:
 140         new_btn = BUTTON_LEFT;
 141         break;
 142     case SDLK_KP6:
 143     case SDLK_RIGHT:
 144         new_btn = BUTTON_RIGHT;
 145         break;
 146     case SDLK_KP8:
 147     case SDLK_UP:
 148         new_btn = BUTTON_UP;
 149         break;
 150     case SDLK_KP2:
 151     case SDLK_DOWN:
 152         new_btn = BUTTON_DOWN;
 153         break;
 154     case SDLK_KP_PLUS:
 155     case SDLK_F8:
 156         new_btn = BUTTON_POWER;
 157         break;
 158     case SDLK_ESCAPE:
 159         new_btn = BUTTON_POWER;
 160         break;
 161     case SDLK_KP_ENTER:
 162     case SDLK_RETURN:
 163     case SDLK_a:
 164         new_btn = BUTTON_A;
 165         break;
 166     case SDLK_KP5:
 167     case SDLK_SPACE:
 168         new_btn = BUTTON_SELECT;
 169         break;
 170     case SDLK_KP_PERIOD:
 171     case SDLK_INSERT:
 172         new_btn = BUTTON_MENU;
 173         break;
 174
 175 #elif CONFIG_KEYPAD == IAUDIO_X5_PAD
 176     case SDLK_KP4:
 177     case SDLK_LEFT:
 178         new_btn = BUTTON_LEFT;
 179         break;
 180     case SDLK_KP6:
 181     case SDLK_RIGHT:
 182         new_btn = BUTTON_RIGHT;
 183         break;
 184     case SDLK_KP8:
 185     case SDLK_UP:
 186         new_btn = BUTTON_UP;
 187         break;
 188     case SDLK_KP2:
 189     case SDLK_DOWN:
 190         new_btn = BUTTON_DOWN;
 191         break;
 192     case SDLK_KP_PLUS:
 193     case SDLK_F8:
 194         new_btn = BUTTON_PLAY;
 195         break;
 196     case SDLK_ESCAPE:
 197         new_btn = BUTTON_POWER;
 198         break;
 199     case SDLK_KP_ENTER:
 200     case SDLK_RETURN:
 201     case SDLK_a:
 202         new_btn = BUTTON_POWER;
 203         break;
 204     case SDLK_KP_DIVIDE:
 205     case SDLK_F1:
 206         new_btn = BUTTON_REC;
 207         break;
 208     case SDLK_KP5:
 209     case SDLK_SPACE:
 210         new_btn = BUTTON_SELECT;
 211         break;
 212
 213 #elif (CONFIG_KEYPAD == IPOD_3G_PAD) || (CONFIG_KEYPAD == IPOD_4G_PAD)
 214     case SDLK_KP4:
 215     case SDLK_LEFT:
 216         new_btn = BUTTON_LEFT;
 217         break;
 218     case SDLK_KP6:
 219     case SDLK_RIGHT:
 220         new_btn = BUTTON_RIGHT;
 221         break;
 222     case SDLK_KP8:
 223     case SDLK_UP:
 224         new_btn = BUTTON_SCROLL_BACK;
 225         break;
 226     case SDLK_KP2:
 227     case SDLK_DOWN:
 228         new_btn = BUTTON_SCROLL_FWD;
 229         break;
 230     case SDLK_KP_PLUS:
 231     case SDLK_F8:
 232         new_btn = BUTTON_PLAY;
 233         break;
 234     case SDLK_KP5:
 235     case SDLK_SPACE:
 236         new_btn = BUTTON_SELECT;
 237         break;
 238     case SDLK_KP_PERIOD:
 239     case SDLK_INSERT:
 240         new_btn = BUTTON_MENU;
 241         break;
 242
 243 #elif CONFIG_KEYPAD == IRIVER_H10_PAD
 244     case SDLK_KP4:
 245     case SDLK_LEFT:
 246         new_btn = BUTTON_LEFT;
 247         break;
 248     case SDLK_KP6:
 249     case SDLK_RIGHT:
 250         new_btn = BUTTON_RIGHT;
 251         break;
 252     case SDLK_KP8:
 253     case SDLK_UP:
 254         new_btn = BUTTON_SCROLL_UP;
 255         break;
 256     case SDLK_KP2:
 257     case SDLK_DOWN:
 258         new_btn = BUTTON_SCROLL_DOWN;
 259         break;
 260     case SDLK_KP_PLUS:
 261     case SDLK_F8:
 262         new_btn = BUTTON_POWER;
 263         break;
 264     case SDLK_ESCAPE:
 265         new_btn = BUTTON_POWER;
 266         break;
 267     case SDLK_KP_DIVIDE:
 268     case SDLK_F1:
 269         new_btn = BUTTON_REW;
 270         break;
 271     case SDLK_KP_MULTIPLY:
 272     case SDLK_F2:
 273         new_btn = BUTTON_FF;
 274         break;
 275     case SDLK_KP5:
 276     case SDLK_SPACE:
 277         new_btn = BUTTON_PLAY;
 278         break;
 279
 280 #elif (CONFIG_KEYPAD == IRIVER_H100_PAD) || (CONFIG_KEYPAD == IRIVER_H300_PAD)
 281     case SDLK_t:
 282         if(pressed)
 283             switch(_remote_type)
 284             {
 285                 case REMOTETYPE_UNPLUGGED:
 286                     _remote_type=REMOTETYPE_H100_LCD;
 287                     DEBUGF("Changed remote type to H100\n");
 288                     break;
 289                 case REMOTETYPE_H100_LCD:
 290                     _remote_type=REMOTETYPE_H300_LCD;
 291                     DEBUGF("Changed remote type to H300\n");
 292                     break;
 293                 case REMOTETYPE_H300_LCD:
 294                     _remote_type=REMOTETYPE_H300_NONLCD;
 295                     DEBUGF("Changed remote type to H300 NON-LCD\n");
 296                     break;
 297                 case REMOTETYPE_H300_NONLCD:
 298                     _remote_type=REMOTETYPE_UNPLUGGED;
 299                     DEBUGF("Changed remote type to none\n");
 300                     break;
 301             }
 302         break;
 303     case SDLK_KP4:
 304     case SDLK_LEFT:
 305         new_btn = BUTTON_LEFT;
 306         break;
 307     case SDLK_KP6:
 308     case SDLK_RIGHT:
 309         new_btn = BUTTON_RIGHT;
 310         break;
 311     case SDLK_KP8:
 312     case SDLK_UP:
 313         new_btn = BUTTON_UP;
 314         break;
 315     case SDLK_KP2:
 316     case SDLK_DOWN:
 317         new_btn = BUTTON_DOWN;
 318         break;
 319     case SDLK_KP_PLUS:
 320     case SDLK_F8:
 321         new_btn = BUTTON_ON;
 322         break;
 323     case SDLK_KP_ENTER:
 324     case SDLK_RETURN:
 325     case SDLK_a:
 326         new_btn = BUTTON_OFF;
 327         break;
 328     case SDLK_KP_DIVIDE:
 329     case SDLK_F1:
 330         new_btn = BUTTON_REC;
 331         break;
 332     case SDLK_KP5:
 333     case SDLK_SPACE:
 334         new_btn = BUTTON_SELECT;
 335         break;
 336     case SDLK_KP_PERIOD:
 337     case SDLK_INSERT:
 338         new_btn = BUTTON_MODE;
 339         break;
 340
 341 #elif CONFIG_KEYPAD == IRIVER_IFP7XX_PAD
 342     case SDLK_KP4:
 343     case SDLK_LEFT:
 344         new_btn = BUTTON_LEFT;
 345         break;
 346     case SDLK_KP6:
 347     case SDLK_RIGHT:
 348         new_btn = BUTTON_RIGHT;
 349         break;
 350     case SDLK_KP8:
 351     case SDLK_UP:
 352         new_btn = BUTTON_UP;
 353         break;
 354     case SDLK_KP2:
 355     case SDLK_DOWN:
 356         new_btn = BUTTON_DOWN;
 357         break;
 358     case SDLK_KP_PLUS:
 359     case SDLK_F8:
 360         new_btn = BUTTON_PLAY;
 361         break;
 362     case SDLK_KP_ENTER:
 363     case SDLK_RETURN:
 364     case SDLK_a:
 365        new_btn = BUTTON_EQ;
 366        break;
 367     case SDLK_KP5:
 368     case SDLK_SPACE:
 369         new_btn = BUTTON_SELECT;
 370         break;
 371     case SDLK_KP_PERIOD:
 372     case SDLK_INSERT:
 373         new_btn = BUTTON_MODE;
 374         break;
 375
 376 #elif CONFIG_KEYPAD == ONDIO_PAD
 377     case SDLK_KP4:
 378     case SDLK_LEFT:
 379         new_btn = BUTTON_LEFT;
 380         break;
 381     case SDLK_KP6:
 382     case SDLK_RIGHT:
 383         new_btn = BUTTON_RIGHT;
 384         break;
 385     case SDLK_KP8:
 386     case SDLK_UP:
 387         new_btn = BUTTON_UP;
 388         break;
 389     case SDLK_KP2:
 390     case SDLK_DOWN:
 391         new_btn = BUTTON_DOWN;
 392         break;
 393     case SDLK_KP_ENTER:
 394     case SDLK_RETURN:
 395     case SDLK_a:
 396         new_btn = BUTTON_OFF;
 397         break;
 398     case SDLK_KP_PERIOD:
 399     case SDLK_INSERT:
 400         new_btn = BUTTON_MENU;
 401         break;
 402
 403 #elif CONFIG_KEYPAD == PLAYER_PAD
 404     case SDLK_KP4:
 405     case SDLK_LEFT:
 406         new_btn = BUTTON_LEFT;
 407         break;
 408     case SDLK_KP6:
 409     case SDLK_RIGHT:
 410         new_btn = BUTTON_RIGHT;
 411         break;
 412     case SDLK_KP8:
 413     case SDLK_UP:
 414         new_btn = BUTTON_PLAY;
 415         break;
 416     case SDLK_KP2:
 417     case SDLK_DOWN:
 418         new_btn = BUTTON_STOP;
 419         break;
 420     case SDLK_KP_PLUS:
 421     case SDLK_F8:
 422         new_btn = BUTTON_ON;
 423         break;
 424     case SDLK_KP_PERIOD:
 425     case SDLK_INSERT:
 426         new_btn = BUTTON_MENU;
 427         break;
 428
 429 #elif CONFIG_KEYPAD == RECORDER_PAD
 430     case SDLK_KP4:
 431     case SDLK_LEFT:
 432         new_btn = BUTTON_LEFT;
 433         break;
 434     case SDLK_KP6:
 435     case SDLK_RIGHT:
 436         new_btn = BUTTON_RIGHT;
 437         break;
 438     case SDLK_KP8:
 439     case SDLK_UP:
 440         new_btn = BUTTON_UP;
 441         break;
 442     case SDLK_KP2:
 443     case SDLK_DOWN:
 444         new_btn = BUTTON_DOWN;
 445         break;
 446     case SDLK_KP_PLUS:
 447     case SDLK_F8:
 448         new_btn = BUTTON_ON;
 449         break;
 450     case SDLK_KP_ENTER:
 451     case SDLK_RETURN:
 452     case SDLK_a:
 453         new_btn = BUTTON_OFF;
 454         break;
 455     case SDLK_KP_DIVIDE:
 456     case SDLK_F1:
 457         new_btn = BUTTON_F1;
 458         break;
 459     case SDLK_KP_MULTIPLY:
 460     case SDLK_F2:
 461         new_btn = BUTTON_F2;
 462         break;
 463     case SDLK_KP_MINUS:
 464     case SDLK_F3:
 465         new_btn = BUTTON_F3;
 466         break;
 467     case SDLK_KP5:
 468     case SDLK_SPACE:
 469         new_btn = BUTTON_PLAY;
 470         break;
 471
 472 #elif CONFIG_KEYPAD == ARCHOS_AV300_PAD
 473     case SDLK_KP4:
 474     case SDLK_LEFT:
 475         new_btn = BUTTON_LEFT;
 476         break;
 477     case SDLK_KP6:
 478     case SDLK_RIGHT:
 479         new_btn = BUTTON_RIGHT;
 480         break;
 481     case SDLK_KP8:
 482     case SDLK_UP:
 483         new_btn = BUTTON_UP;
 484         break;
 485     case SDLK_KP2:
 486     case SDLK_DOWN:
 487         new_btn = BUTTON_DOWN;
 488         break;
 489     case SDLK_KP_PLUS:
 490     case SDLK_F8:
 491         new_btn = BUTTON_ON;
 492         break;
 493     case SDLK_KP_ENTER:
 494     case SDLK_RETURN:
 495     case SDLK_a:
 496         new_btn = BUTTON_OFF;
 497         break;
 498     case SDLK_KP_DIVIDE:
 499     case SDLK_F1:
 500         new_btn = BUTTON_F1;
 501         break;
 502     case SDLK_KP_MULTIPLY:
 503     case SDLK_F2:
 504         new_btn = BUTTON_F2;
 505         break;
 506     case SDLK_KP_MINUS:
 507     case SDLK_F3:
 508         new_btn = BUTTON_F3;
 509         break;
 510     case SDLK_KP5:
 511     case SDLK_SPACE:
 512         new_btn = BUTTON_SELECT;
 513         break;
 514
 515 #elif CONFIG_KEYPAD == SANSA_E200_PAD
 516     case SDLK_KP4:
 517     case SDLK_LEFT:
 518         new_btn = BUTTON_LEFT;
 519         break;
 520     case SDLK_KP6:
 521     case SDLK_RIGHT:
 522         new_btn = BUTTON_RIGHT;
 523         break;
 524     case SDLK_KP8:
 525     case SDLK_UP:
 526         new_btn = BUTTON_SCROLL_UP;
 527         break;
 528     case SDLK_KP2:
 529     case SDLK_DOWN:
 530         new_btn = BUTTON_SCROLL_DOWN;
 531         break;
 532     case SDLK_KP9:
 533         new_btn = BUTTON_UP;
 534         break;
 535     case SDLK_KP3:
 536         new_btn = BUTTON_DOWN;
 537         break;
 538     case SDLK_KP1:
 539         new_btn = BUTTON_POWER;
 540         break;
 541     case SDLK_KP7:
 542         new_btn = BUTTON_REC;
 543         break;
 544     case SDLK_KP5:
 545     case SDLK_SPACE:
 546         new_btn = BUTTON_SELECT;
 547         break;
 548
 549 #endif /* CONFIG_KEYPAD */
 550     case SDLK_KP0:
 551     case SDLK_F5:
 552         if(pressed)
 553         {
 554             screen_dump();
 555             return;
 556         }
 557         break;
 558     }
 559
 560     if (pressed)
 561         btn |= new_btn;
 562     else
 563         btn &= ~new_btn;
 564
 565     /* Lots of stuff copied from real button.c. Not good, I think... */
 566
 567     /* Find out if a key has been released */
 568     diff = btn ^ lastbtn;
 569     if(diff && (btn & diff) == 0)
 570     {
 571 #if CONFIG_BACKLIGHT
 572 #ifdef HAVE_REMOTE_LCD
 573         if(diff & BUTTON_REMOTE)
 574             if(!skip_remote_release)
 575                 queue_post(&button_queue, BUTTON_REL | diff, 0);
 576             else
 577                 skip_remote_release = false;
 578         else
 579 #endif
 580             if(!skip_release)
 581                 queue_post(&button_queue, BUTTON_REL | diff, 0);
 582             else
 583                 skip_release = false;
 584 #else
 585         queue_post(&button_queue, BUTTON_REL | diff, 0);
 586 #endif
 587     }
 588
 589     else
 590     {
 591         if ( btn )
 592         {
 593             /* normal keypress */
 594             if ( btn != lastbtn )
 595             {
 596                 post = true;
 597                 repeat = false;
 598                 repeat_speed = REPEAT_INTERVAL_START;
 599
 600             }
 601             else /* repeat? */
 602             {
 603                 if ( repeat )
 604                 {
 605                     if (!post)
 606                         count--;
 607                     if (count == 0)
 608                     {
 609                         post = true;
 610                         /* yes we have repeat */
 611                         repeat_speed--;
 612                         if (repeat_speed < REPEAT_INTERVAL_FINISH)
 613                             repeat_speed = REPEAT_INTERVAL_FINISH;
 614                         count = repeat_speed;
 615
 616                         repeat_count++;
 617                     }
 618                 }
 619                 else
 620                 {
 621                     if (count++ > REPEAT_START)
 622                     {
 623                         post = true;
 624                         repeat = true;
 625                         repeat_count = 0;
 626                         /* initial repeat */
 627                         count = REPEAT_INTERVAL_START;
 628                     }
 629                 }
 630             }
 631             if ( post )
 632             {
 633                 if(repeat)
 634                 {
 635                     if (queue_empty(&button_queue))
 636                     {
 637                         queue_post(&button_queue, BUTTON_REPEAT | btn, 0);
 638 #if CONFIG_BACKLIGHT
 639 #ifdef HAVE_REMOTE_LCD
 640                             if(btn & BUTTON_REMOTE)
 641                             {
 642                                 if(skip_remote_release)
 643                                     skip_remote_release = false;
 644                             }
 645                             else
 646 #endif
 647                                 if(skip_release)
 648                                     skip_release = false;
 649 #endif
 650                         post = false;
 651                     }
 652                 }
 653                 else
 654                 {
 655 #if CONFIG_BACKLIGHT
 656 #ifdef HAVE_REMOTE_LCD
 657                         if (btn & BUTTON_REMOTE) {
 658                             if (!remote_filter_first_keypress || is_remote_backlight_on())
 659                                 queue_post(&button_queue, btn, 0);
 660                             else
 661                                 skip_remote_release = true;
 662                         }
 663                         else
 664 #endif
 665                             if (!filter_first_keypress || is_backlight_on())
 666                                 queue_post(&button_queue, btn, 0);
 667                             else
 668                                 skip_release = true;
 669 #else /* no backlight, nothing to skip */
 670                         queue_post(&button_queue, btn, 0);
 671 #endif
 672                     post = false;
 673                 }
 674
 675 #ifdef HAVE_REMOTE_LCD
 676                 if(btn & BUTTON_REMOTE)
 677                     remote_backlight_on();
 678                 else
 679 #endif
 680                     backlight_on();
 681
 682             }
 683         }
 684         else
 685         {
 686             repeat = false;
 687             count = 0;
 688         }
 689     }
 690     lastbtn = btn & ~(BUTTON_REL | BUTTON_REPEAT);
 691 }
 692
 693 /* Again copied from real button.c... */
 694
 695 long button_get(bool block)
 696 {
 697     struct event ev;
 698
 699     if ( block || !queue_empty(&button_queue) ) {
 700         queue_wait(&button_queue, &ev);
 701         return ev.id;
 702     }
 703     return BUTTON_NONE;
 704 }
 705
 706 long button_get_w_tmo(int ticks)
 707 {
 708     struct event ev;
 709     queue_wait_w_tmo(&button_queue, &ev, ticks);
 710     return (ev.id != SYS_TIMEOUT)? ev.id: BUTTON_NONE;
 711 }
 712
 713 void button_init(void)
 714 {
 715 }
 716
 717 int button_status(void)
 718 {
 719     return btn;
 720 }
 721
 722 void button_clear_queue(void)
 723 {
 724     queue_clear(&button_queue);
 725 }