apps/action.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2006 Jonathan Gordon
  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 #include <stdio.h>
  22 #include <string.h>
  23 #include <stdlib.h>
  24
  25 #include "config.h"
  26 #include "lang.h"
  27
  28 #include "appevents.h"
  29 #include "button.h"
  30 #include "action.h"
  31 #include "kernel.h"
  32 #include "debug.h"
  33 #include "splash.h"
  34 #include "settings.h"
  35 #include "pcmbuf.h"
  36 #include "misc.h"
  37 #if defined(HAVE_LCD_BITMAP) && !defined(BOOTLOADER)
  38 #include "language.h"
  39 #endif
  40 #include "viewport.h"
  41
  42 static int last_button = BUTTON_NONE|BUTTON_REL; /* allow the ipod wheel to
  43                                                     work on startup */
  44 static intptr_t last_data = 0;
  45 static int last_action = ACTION_NONE;
  46 static bool repeated = false;
  47 static bool wait_for_release = false;
  48
  49 #ifdef HAVE_TOUCHSCREEN
  50 static bool short_press = false;
  51 #endif
  52
  53 #define REPEAT_WINDOW_TICKS HZ/10
  54 static int last_action_tick = 0;
  55
  56 /* software keylock stuff */
  57 #ifndef HAS_BUTTON_HOLD
  58 static bool keys_locked = false;
  59 static int unlock_combo = BUTTON_NONE;
  60 static bool screen_has_lock = false;
  61 #endif /* HAVE_SOFTWARE_KEYLOCK */
  62
  63 /*
  64  * do_button_check is the worker function for get_default_action.
  65  * returns ACTION_UNKNOWN or the requested return value from the list.
  66  */
  67 static inline int do_button_check(const struct button_mapping *items,
  68                                   int button, int last_button, int *start)
  69 {
  70     int i = 0;
  71     int ret = ACTION_UNKNOWN;
  72
  73     while (items[i].button_code != BUTTON_NONE)
  74     {
  75         if (items[i].button_code == button)
  76         {
  77             if ((items[i].pre_button_code == BUTTON_NONE)
  78                 || (items[i].pre_button_code == last_button))
  79             {
  80                 ret = items[i].action_code;
  81                 break;
  82             }
  83         }
  84         i++;
  85     }
  86     *start = i;
  87     return ret;
  88 }
  89
  90 #if defined(HAVE_LCD_BITMAP) && !defined(BOOTLOADER)
  91 /*
  92  * button is horizontally inverted to support RTL language if the given language
  93  * and context combination require that
  94  */
  95 static int button_flip_horizontally(int context, int button)
  96 {
  97     int newbutton;
  98
  99     if (!(lang_is_rtl() && ((context == CONTEXT_STD) ||
 100         (context == CONTEXT_TREE) || (context == CONTEXT_LIST) ||
 101         (context == CONTEXT_MAINMENU))))
 102     {
 103         return button;
 104     }
 105
 106     newbutton = button &
 107         ~(BUTTON_LEFT | BUTTON_RIGHT
 108 #if defined(BUTTON_SCROLL_BACK) && defined(BUTTON_SCROLL_FWD) && \
 109     !defined(SIMULATOR)
 110         | BUTTON_SCROLL_BACK | BUTTON_SCROLL_FWD
 111 #endif
 112 #if defined(BUTTON_MINUS) && defined(BUTTON_PLUS) && \
 113     !defined(SIMULATOR)
 114         | BUTTON_MINUS | BUTTON_PLUS
 115 #endif
 116         );
 117
 118     if (button & BUTTON_LEFT)
 119         newbutton |= BUTTON_RIGHT;
 120     if (button & BUTTON_RIGHT)
 121         newbutton |= BUTTON_LEFT;
 122 #if defined(BUTTON_SCROLL_BACK) && defined(BUTTON_SCROLL_FWD) && \
 123     !defined(SIMULATOR)
 124     if (button & BUTTON_SCROLL_BACK)
 125         newbutton |= BUTTON_SCROLL_FWD;
 126     if (button & BUTTON_SCROLL_FWD)
 127         newbutton |= BUTTON_SCROLL_BACK;
 128 #endif
 129 #if defined(BUTTON_MINUS) && defined(BUTTON_PLUS) && \
 130     !defined(SIMULATOR)
 131     if (button & BUTTON_MINUS)
 132         newbutton |= BUTTON_PLUS;
 133     if (button & BUTTON_PLUS)
 134         newbutton |= BUTTON_MINUS;
 135 #endif
 136
 137     return newbutton;
 138 }
 139 #endif
 140
 141 static inline int get_next_context(const struct button_mapping *items, int i)
 142 {
 143     while (items[i].button_code != BUTTON_NONE)
 144         i++;
 145     return (items[i].action_code == ACTION_NONE ) ?
 146             CONTEXT_STD :
 147             items[i].action_code;
 148 }
 149 /*
 150  * int get_action_worker(int context, struct button_mapping *user_mappings,
 151    int timeout)
 152    This function searches the button list for the given context for the just
 153    pressed button.
 154    If there is a match it returns the value from the list.
 155    If there is no match..
 156         the last item in the list "points" to the next context in a chain
 157         so the "chain" is followed until the button is found.
 158         putting ACTION_NONE will get CONTEXT_STD which is always the last list checked.
 159
 160    Timeout can be TIMEOUT_NOBLOCK to return immediatly
 161                   TIMEOUT_BLOCK   to wait for a button press
 162    Any number >0   to wait that many ticks for a press
 163  */
 164 static int get_action_worker(int context, int timeout,
 165                              const struct button_mapping* (*get_context_map)(int) )
 166 {
 167     const struct button_mapping *items = NULL;
 168     int button;
 169     int i=0;
 170     int ret = ACTION_UNKNOWN;
 171     static int last_context = CONTEXT_STD;
 172
 173
 174     send_event(GUI_EVENT_ACTIONUPDATE, NULL);
 175
 176     if (timeout == TIMEOUT_NOBLOCK)
 177         button = button_get(false);
 178     else if  (timeout == TIMEOUT_BLOCK)
 179         button = button_get(true);
 180     else
 181         button = button_get_w_tmo(timeout);
 182
 183     /* Data from sys events can be pulled with button_get_data */
 184     if (button == BUTTON_NONE || button & SYS_EVENT)
 185         return button;
 186     /* Don't send any buttons through untill we see the release event */
 187     if (wait_for_release)
 188     {
 189         if (button&BUTTON_REL)
 190         {
 191             wait_for_release = false;
 192         }
 193         return ACTION_NONE;
 194     }
 195
 196
 197 #if CONFIG_CODEC == SWCODEC
 198     /* Produce keyclick */
 199     if (global_settings.keyclick && !(button & BUTTON_REL))
 200         if (!(button & BUTTON_REPEAT) || global_settings.keyclick_repeats)
 201             pcmbuf_beep(4000, KEYCLICK_DURATION, 2500*global_settings.keyclick);
 202 #endif
 203
 204     if ((context != last_context) && ((last_button & BUTTON_REL) == 0))
 205     {
 206         if (button & BUTTON_REL)
 207         {
 208             last_button = button;
 209             last_action = ACTION_NONE;
 210         }
 211         /* eat all buttons until the previous button was |BUTTON_REL
 212            (also eat the |BUTTON_REL button) */
 213         return ACTION_NONE; /* "safest" return value */
 214     }
 215     last_context = context;
 216 #ifndef HAS_BUTTON_HOLD
 217     screen_has_lock = ((context & ALLOW_SOFTLOCK) == ALLOW_SOFTLOCK);
 218     if (screen_has_lock && keys_locked)
 219     {
 220         if (button == unlock_combo)
 221         {
 222             last_button = BUTTON_NONE;
 223             keys_locked = false;
 224             splash(HZ/2, str(LANG_KEYLOCK_OFF));
 225             return ACTION_REDRAW;
 226         }
 227         else
 228 #if (BUTTON_REMOTE != 0)
 229             if ((button & BUTTON_REMOTE) == 0)
 230 #endif
 231         {
 232             if ((button & BUTTON_REL))
 233                 splash(HZ/2, str(LANG_KEYLOCK_ON));
 234             return ACTION_REDRAW;
 235         }
 236     }
 237     context &= ~ALLOW_SOFTLOCK;
 238 #endif /* HAS_BUTTON_HOLD */
 239
 240 #ifdef HAVE_TOUCHSCREEN
 241     if (button & BUTTON_TOUCHSCREEN)
 242     {
 243         repeated = false;
 244         short_press = false;
 245         if (last_button & BUTTON_TOUCHSCREEN)
 246         {
 247             if ((button & BUTTON_REL) &&
 248                 ((last_button & BUTTON_REPEAT)==0))
 249             {
 250                 short_press = true;
 251             }
 252             else if (button & BUTTON_REPEAT)
 253                 repeated = true;
 254         }
 255         last_button = button;
 256         return ACTION_TOUCHSCREEN;
 257     }
 258 #endif
 259
 260 #if defined(HAVE_LCD_BITMAP) && !defined(BOOTLOADER)
 261     button = button_flip_horizontally(context, button);
 262 #endif
 263
 264     /*   logf("%x,%x",last_button,button); */
 265     while (1)
 266     {
 267         /*     logf("context = %x",context); */
 268 #if (BUTTON_REMOTE != 0)
 269         if (button & BUTTON_REMOTE)
 270             context |= CONTEXT_REMOTE;
 271 #endif
 272         if ((context & CONTEXT_PLUGIN) && get_context_map)
 273             items = get_context_map(context);
 274         else
 275             items = get_context_mapping(context);
 276
 277         if (items == NULL)
 278             break;
 279
 280         ret = do_button_check(items,button,last_button,&i);
 281
 282         if (ret == ACTION_UNKNOWN)
 283         {
 284             context = get_next_context(items,i);
 285
 286             if (context != (int)CONTEXT_STOPSEARCHING)
 287             {
 288                 i = 0;
 289                 continue;
 290             }
 291         }
 292
 293         /* Action was found or STOPSEARCHING was specified */
 294         break;
 295     }
 296     /* DEBUGF("ret = %x\n",ret); */
 297 #ifndef HAS_BUTTON_HOLD
 298     if (screen_has_lock && (ret == ACTION_STD_KEYLOCK))
 299     {
 300         unlock_combo = button;
 301         keys_locked = true;
 302         splash(HZ/2, str(LANG_KEYLOCK_ON));
 303
 304         button_clear_queue();
 305         return ACTION_REDRAW;
 306     }
 307 #endif
 308     if ((current_tick - last_action_tick < REPEAT_WINDOW_TICKS)
 309          && (ret == last_action))
 310         repeated = true;
 311     else
 312         repeated = false;
 313
 314     last_button = button;
 315     last_action = ret;
 316     last_data   = button_get_data();
 317     last_action_tick = current_tick;
 318     return ret;
 319 }
 320
 321 int get_action(int context, int timeout)
 322 {
 323     return get_action_worker(context,timeout,NULL);
 324 }
 325
 326 int get_custom_action(int context,int timeout,
 327                       const struct button_mapping* (*get_context_map)(int))
 328 {
 329     return get_action_worker(context,timeout,get_context_map);
 330 }
 331
 332 bool action_userabort(int timeout)
 333 {
 334     int action = get_action_worker(CONTEXT_STD,timeout,NULL);
 335     bool ret = (action == ACTION_STD_CANCEL);
 336     if(!ret)
 337     {
 338         default_event_handler(action);
 339     }
 340     return ret;
 341 }
 342
 343 #ifndef HAS_BUTTON_HOLD
 344 bool is_keys_locked(void)
 345 {
 346     return (screen_has_lock && keys_locked);
 347 }
 348 #endif
 349
 350 intptr_t get_action_data(void)
 351 {
 352     return last_data;
 353 }
 354
 355 int get_action_statuscode(int *button)
 356 {
 357     int ret = 0;
 358     if (button)
 359         *button = last_button;
 360
 361     if (last_button & BUTTON_REMOTE)
 362         ret |= ACTION_REMOTE;
 363     if (repeated)
 364         ret |= ACTION_REPEAT;
 365     return ret;
 366 }
 367
 368 #ifdef HAVE_TOUCHSCREEN
 369 /* return BUTTON_NONE               on error
 370  *        BUTTON_REPEAT             if repeated press
 371  *        BUTTON_REPEAT|BUTTON_REL  if release after repeated press
 372  *        BUTTON_REL                if it's a short press = release after press
 373  *        BUTTON_TOUCHSCREEN        if press
 374  */
 375 int action_get_touchscreen_press(short *x, short *y)
 376 {
 377     static int last_data = 0;
 378     int data;
 379     if ((last_button & BUTTON_TOUCHSCREEN) == 0)
 380         return BUTTON_NONE;
 381     data = button_get_data();
 382     if (last_button & BUTTON_REL)
 383     {
 384         *x = (last_data&0xffff0000)>>16;
 385         *y = (last_data&0xffff);
 386     }
 387     else
 388     {
 389         *x = (data&0xffff0000)>>16;
 390         *y = (data&0xffff);
 391     }
 392     last_data = data;
 393     if (repeated)
 394         return BUTTON_REPEAT;
 395     if (short_press)
 396         return BUTTON_REL;
 397     /* This is to return a BUTTON_REL after a BUTTON_REPEAT. */
 398     if (last_button & BUTTON_REL)
 399         return BUTTON_REPEAT|BUTTON_REL;
 400     return BUTTON_TOUCHSCREEN;
 401 }
 402
 403 int action_get_touchscreen_press_in_vp(short *x1, short *y1, struct viewport *vp)
 404 {
 405     short x, y;
 406     int ret;
 407
 408     ret = action_get_touchscreen_press(&x, &y);
 409
 410     if (ret != BUTTON_NONE && viewport_point_within_vp(vp, x, y))
 411     {
 412         *x1 = x - vp->x;
 413         *y1 = y - vp->y;
 414         return ret;
 415     }
 416     if (ret & BUTTON_TOUCHSCREEN)
 417         return ACTION_UNKNOWN;
 418     return BUTTON_NONE;
 419 }
 420 #endif
 421
 422 /* Don't let get_action*() return any ACTION_* values until the current buttons
 423  * have been released. SYS_* and BUTTON_NONE will go through.
 424  * Any actions relying on _RELEASE won't get seen.
 425  */
 426 void action_wait_for_release(void)
 427 {
 428     wait_for_release = true;
 429 }
 430