apps/recorder/keyboard.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 by Björn Stenberg
  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 "kernel.h"
  22 #include "system.h"
  23 #include "version.h"
  24 #include <string.h>
  25 #include "font.h"
  26 #include "screens.h"
  27 #include "talk.h"
  28 #include "settings.h"
  29 #include "misc.h"
  30 #include "rbunicode.h"
  31 #include "buttonbar.h"
  32 #include "logf.h"
  33 #include "hangul.h"
  34 #include "action.h"
  35 #include "icon.h"
  36 #include "pcmbuf.h"
  37 #include "lang.h"
  38 #include "keyboard.h"
  39 #include "viewport.h"
  40 #include "file.h"
  41
  42 #ifndef O_BINARY
  43 #define O_BINARY 0
  44 #endif
  45
  46
  47 #define DEFAULT_MARGIN 6
  48 #define KBD_BUF_SIZE 500
  49
  50 #if (CONFIG_KEYPAD == IRIVER_H100_PAD) || \
  51     (CONFIG_KEYPAD == IRIVER_H300_PAD)
  52 #define KBD_CURSOR_KEYS /* certain key combos move the cursor even if not
  53                            in line edit mode */
  54 #define KBD_MODES /* I-Rivers can use picker, line edit and cursor keys */
  55 #define KBD_MORSE_INPUT /* I-Rivers have a Morse input mode */
  56
  57 #elif CONFIG_KEYPAD == ONDIO_PAD /* restricted Ondio keypad */
  58 #define KBD_MODES /* Ondio uses 2 modes, picker and line edit */
  59
  60 #elif (CONFIG_KEYPAD == IPOD_1G2G_PAD) || (CONFIG_KEYPAD == IPOD_3G_PAD) \
  61    || (CONFIG_KEYPAD == IPOD_4G_PAD)
  62 #define KBD_MODES /* iPod uses 2 modes, picker and line edit */
  63 #define KBD_MORSE_INPUT
  64
  65 #elif CONFIG_KEYPAD == IRIVER_IFP7XX_PAD
  66 #define KBD_MODES /* iFP7xx uses 2 modes, picker and line edit */
  67
  68 #elif (CONFIG_KEYPAD == IAUDIO_X5M5_PAD) || (CONFIG_KEYPAD == IAUDIO_M3_PAD)
  69 #define KBD_MODES /* iAudios use 2 modes, picker and line edit */
  70
  71 #elif CONFIG_KEYPAD == IRIVER_H10_PAD
  72 #define KBD_MODES /* iriver H10 uses 2 modes, picker and line edit */
  73 #define KBD_MORSE_INPUT
  74
  75 #elif CONFIG_KEYPAD == GIGABEAT_PAD
  76 #define KBD_CURSOR_KEYS
  77 #define KBD_MODES
  78 #define KBD_MORSE_INPUT
  79
  80 #elif CONFIG_KEYPAD == SANSA_E200_PAD \
  81     || CONFIG_KEYPAD == SANSA_FUZE_PAD
  82 #define KBD_CURSOR_KEYS
  83 #define KBD_MODES
  84
  85 #elif CONFIG_KEYPAD == SANSA_C200_PAD
  86 #define KBD_CURSOR_KEYS
  87 #define KBD_MODES
  88
  89 #elif CONFIG_KEYPAD == MROBE100_PAD
  90 #define KBD_MORSE_INPUT
  91 #endif
  92
  93 struct keyboard_parameters
  94 {
  95     const unsigned char* default_kbd;
  96     int DEFAULT_LINES;
  97     unsigned short kbd_buf[KBD_BUF_SIZE];
  98     int nchars;
  99     int font_w;
 100     int font_h;
 101     struct font* font;
 102     int curfont;
 103     int main_x;
 104     int main_y;
 105     int max_chars;
 106     int max_chars_text;
 107     int lines;
 108     int pages;
 109     int keyboard_margin;
 110     int old_main_y;
 111     int curpos;
 112     int leftpos;
 113     int page;
 114     int x;
 115     int y;
 116 #ifdef KBD_MODES
 117     bool line_edit;
 118 #endif
 119     bool hangul;
 120     unsigned short hlead, hvowel, htail;
 121 };
 122
 123 static struct keyboard_parameters kbd_param[NB_SCREENS];
 124 static bool kbd_loaded = false;
 125
 126 #ifdef KBD_MORSE_INPUT
 127 /* FIXME: We should put this to a configuration file. */
 128 static const char *morse_alphabets =
 129     "abcdefghijklmnopqrstuvwxyz1234567890,.?-@ ";
 130 static const unsigned char morse_codes[] = {
 131     0x05,0x18,0x1a,0x0c,0x02,0x12,0x0e,0x10,0x04,0x17,0x0d,0x14,0x07,
 132     0x06,0x0f,0x16,0x1d,0x0a,0x08,0x03,0x09,0x11,0x0b,0x19,0x1b,0x1c,
 133     0x2f,0x27,0x23,0x21,0x20,0x30,0x38,0x3c,0x3e,0x3f,
 134     0x73,0x55,0x4c,0x61,0x5a,0x80 };
 135
 136 static bool morse_mode = false;
 137 #endif
 138
 139 /* Loads a custom keyboard into memory
 140    call with NULL to reset keyboard    */
 141 int load_kbd(unsigned char* filename)
 142 {
 143     int fd, l;
 144     int i = 0;
 145     unsigned char buf[4];
 146
 147     if (filename == NULL)
 148     {
 149         kbd_loaded = false;
 150         return 0;
 151     }
 152
 153     fd = open_utf8(filename, O_RDONLY|O_BINARY);
 154     if (fd < 0)
 155         return 1;
 156
 157     while (read(fd, buf, 1) == 1 && i < KBD_BUF_SIZE)
 158     {
 159         /* check how many bytes to read for this character */
 160         static const unsigned char sizes[4] = { 0x80, 0xe0, 0xf0, 0xf5 };
 161         size_t count;
 162
 163         for (count = 0; count < ARRAYLEN(sizes); count++)
 164         {
 165             if (buf[0] < sizes[count])
 166                 break;
 167         }
 168
 169         if (count >= ARRAYLEN(sizes))
 170             continue; /* Invalid size. */
 171
 172         if (read(fd, &buf[1], count) != (ssize_t)count)
 173         {
 174             close(fd);
 175             kbd_loaded = false;
 176             return 1;
 177         }
 178
 179         FOR_NB_SCREENS(l)
 180             utf8decode(buf, &kbd_param[l].kbd_buf[i]);
 181
 182         if (kbd_param[0].kbd_buf[i] != 0xFEFF &&
 183             kbd_param[0].kbd_buf[i] != '\r') /*skip BOM & carriage returns */
 184         {
 185             i++;
 186         }
 187     }
 188
 189     close(fd);
 190     kbd_loaded = true;
 191
 192     FOR_NB_SCREENS(l)
 193         kbd_param[l].nchars = i;
 194
 195     return 0;
 196 }
 197
 198 /* helper function to spell a char if voice UI is enabled */
 199 static void kbd_spellchar(unsigned short c)
 200 {
 201     if (global_settings.talk_menu) /* voice UI? */
 202     {
 203         unsigned char tmp[5];
 204         /* store char to pass to talk_spell */
 205         unsigned char* utf8 = utf8encode(c, tmp);
 206         *utf8 = 0;
 207
 208         if(c == ' ')
 209             talk_id(VOICE_BLANK, false);
 210         else
 211             talk_spell(tmp, false);
 212     }
 213 }
 214
 215 #ifdef KBD_MODES
 216 static void say_edit(void)
 217 {
 218     if(global_settings.talk_menu)
 219         talk_id(VOICE_EDIT, false);
 220 }
 221 #endif
 222
 223 static void kbd_inschar(unsigned char* text, int buflen,
 224                         int* editpos, unsigned short ch)
 225 {
 226     int i, j, k, len;
 227     unsigned char tmp[4];
 228     unsigned char* utf8;
 229
 230     len = strlen(text);
 231     k = utf8length(text);
 232     utf8 = utf8encode(ch, tmp);
 233     j = (long)utf8 - (long)tmp;
 234
 235     if (len + j < buflen)
 236     {
 237         for (i = len+j; k >= *editpos; i--)
 238         {
 239             text[i] = text[i-j];
 240             if ((text[i] & MASK) != COMP)
 241                 k--;
 242         }
 243
 244         while (j--)
 245             text[i--] = tmp[j];
 246
 247         (*editpos)++;
 248     }
 249 }
 250
 251 static void kbd_delchar(unsigned char* text, int* editpos)
 252 {
 253     int i = 0;
 254     unsigned char* utf8;
 255
 256     if (*editpos > 0)
 257     {
 258         utf8 = text + utf8seek(text, *editpos);
 259
 260         do
 261         {
 262             i++;
 263             utf8--;
 264         }
 265         while ((*utf8 & MASK) == COMP);
 266
 267         while (utf8[i])
 268         {
 269             *utf8 = utf8[i];
 270             utf8++;
 271         }
 272
 273         *utf8 = 0;
 274         (*editpos)--;
 275     }
 276 }
 277
 278 /* Lookup k value based on state of param (pm) */
 279 static int get_param_k(const struct keyboard_parameters *pm)
 280 {
 281     return (pm->page*pm->lines + pm->y)*pm->max_chars + pm->x;
 282 }
 283
 284 int kbd_input(char* text, int buflen)
 285 {
 286     bool done = false;
 287 #ifdef CPU_ARM
 288     /* This seems to keep the sizes for ARM way down */
 289     struct keyboard_parameters * volatile param = kbd_param;
 290 #else
 291     struct keyboard_parameters * const param = kbd_param;
 292 #endif
 293     int l; /* screen loop variable */
 294     int text_w = 0;
 295     int editpos;                /* Edit position on all screens */
 296     const int statusbar_size = 0;
 297     unsigned short ch;
 298     unsigned char *utf8;
 299     bool cur_blink = true;      /* Cursor on/off flag */
 300     int ret;
 301 #ifdef KBD_MORSE_INPUT
 302     bool morse_reading = false;
 303     unsigned char morse_code = 0;
 304     int morse_tick = 0;
 305     char buf[2];
 306 #endif
 307     int oldbars = viewportmanager_set_statusbar(VP_SB_HIDE_ALL);
 308     FOR_NB_SCREENS(l)
 309     {
 310         struct keyboard_parameters *pm = &param[l];
 311 #if LCD_WIDTH >= 160 && LCD_HEIGHT >= 96
 312         struct screen *sc = &screens[l];
 313
 314         if (sc->getwidth() >= 160 && sc->getheight() >= 96)
 315         {
 316             pm->default_kbd =
 317                 "ABCDEFG abcdefg !?\" @#$%+'\n"
 318                 "HIJKLMN hijklmn 789 &_()-`\n"
 319                 "OPQRSTU opqrstu 456 §|{}/<\n"
 320                 "VWXYZ., vwxyz.,0123 ~=[]*>\n"
 321                 "ÀÁÂÃÄÅÆ ÌÍÎÏ ÈÉÊË ¢£¤¥¦§©®\n"
 322                 "àáâãäåæ ìíîï èéêë «»°ºª¹²³\n"
 323                 "ÓÒÔÕÖØ ÇÐÞÝß ÙÚÛÜ ¯±×÷¡¿µ·\n"
 324                 "òóôõöø çðþýÿ ùúûü ¼½¾¬¶¨:;";
 325
 326             pm->DEFAULT_LINES = 8;
 327         }
 328         else
 329 #endif /* LCD_WIDTH >= 160 && LCD_HEIGHT >= 96 */
 330         {
 331             pm->default_kbd =
 332                 "ABCDEFG !?\" @#$%+'\n"
 333                 "HIJKLMN 789 &_()-`\n"
 334                 "OPQRSTU 456 §|{}/<\n"
 335                 "VWXYZ.,0123 ~=[]*>\n"
 336
 337                 "abcdefg ¢£¤¥¦§©®¬\n"
 338                 "hijklmn «»°ºª¹²³¶\n"
 339                 "opqrstu ¯±×÷¡¿µ·¨\n"
 340                 "vwxyz., :;¼½¾    \n"
 341
 342                 "ÀÁÂÃÄÅÆ ÌÍÎÏ ÈÉÊË\n"
 343                 "àáâãäåæ ìíîï èéêë\n"
 344                 "ÓÒÔÕÖØ ÇÐÞÝß ÙÚÛÜ\n"
 345                 "òóôõöø çðþýÿ ùúûü";
 346
 347             pm->DEFAULT_LINES = 4;
 348         }
 349     }
 350
 351     char outline[256];
 352 #ifdef HAVE_BUTTONBAR
 353     struct gui_buttonbar buttonbar;
 354     bool buttonbar_config = global_settings.buttonbar;
 355
 356     global_settings.buttonbar = true;
 357     gui_buttonbar_init(&buttonbar);
 358
 359     FOR_NB_SCREENS(l)
 360         gui_buttonbar_set_display(&buttonbar, &screens[l]);
 361 #endif
 362
 363     FOR_NB_SCREENS(l)
 364     {
 365         struct keyboard_parameters *pm = &param[l];
 366
 367         if ( !kbd_loaded )
 368         {
 369             /* Copy default keyboard to buffer */
 370             const unsigned char *p = pm->default_kbd;
 371             int i = 0;
 372
 373             pm->curfont = FONT_SYSFIXED;
 374
 375             while (*p != 0)
 376                 p = utf8decode(p, &pm->kbd_buf[i++]);
 377
 378             pm->nchars = i;
 379         }
 380         else
 381         {
 382             pm->curfont = FONT_UI;
 383         }
 384     }
 385
 386     FOR_NB_SCREENS(l)
 387     {
 388         struct keyboard_parameters *pm = &param[l];
 389         struct screen *sc = &screens[l];
 390         int i, w;
 391
 392         pm->font = font_get(pm->curfont);
 393         pm->font_h = pm->font->height;
 394
 395         /* check if FONT_UI fits the screen */
 396         if (2*pm->font_h + 3 + statusbar_size +
 397             BUTTONBAR_HEIGHT > sc->getheight())
 398         {
 399             pm->font = font_get(FONT_SYSFIXED);
 400             pm->font_h = pm->font->height;
 401             pm->curfont = FONT_SYSFIXED;
 402         }
 403
 404         sc->setfont(pm->curfont);
 405         pm->font_w = 0; /* reset font width */
 406         /* find max width of keyboard glyphs */
 407         for (i = 0; i < pm->nchars; i++)
 408         {
 409             w = font_get_width(pm->font, pm->kbd_buf[i]);
 410             if ( w > pm->font_w )
 411                 pm->font_w = w;
 412         }
 413
 414         /* Since we're going to be adding spaces, make sure that we check
 415          * their width too */
 416         w = font_get_width( pm->font, ' ' );
 417         if ( w > pm->font_w )
 418             pm->font_w = w;
 419     }
 420
 421     FOR_NB_SCREENS(l)
 422     {
 423         struct keyboard_parameters *pm = &param[l];
 424         struct screen *sc = &screens[l];
 425         int i = 0;
 426
 427         /* Pad lines with spaces */
 428         while (i < pm->nchars)
 429         {
 430             if (pm->kbd_buf[i] == '\n')
 431             {
 432                 int k = sc->getwidth() / pm->font_w
 433                         - i % ( sc->getwidth() / pm->font_w ) - 1;
 434                 int j;
 435
 436                 if (k == sc->getwidth() / pm->font_w - 1)
 437                 {
 438                     pm->nchars--;
 439
 440                     for (j = i; j < pm->nchars; j++)
 441                     {
 442                         pm->kbd_buf[j] = pm->kbd_buf[j + 1];
 443                     }
 444                 }
 445                 else
 446                 {
 447                     if (pm->nchars + k - 1 >= KBD_BUF_SIZE)
 448                     {   /* We don't want to overflow the buffer */
 449                         k = KBD_BUF_SIZE - pm->nchars;
 450                     }
 451
 452                     for (j = pm->nchars + k - 1; j > i + k; j--)
 453                     {
 454                         pm->kbd_buf[j] = pm->kbd_buf[j-k];
 455                     }
 456
 457                     pm->nchars += k;
 458                     k++;
 459
 460                     while (k--)
 461                     {
 462                         pm->kbd_buf[i++] = ' ';
 463                     }
 464                 }
 465             }
 466             else
 467             {
 468                 i++;
 469             }
 470         }
 471     }
 472
 473     /* Find max width for text string */
 474     utf8 = text;
 475     FOR_NB_SCREENS(l)
 476     {
 477         struct keyboard_parameters *pm = &param[l];
 478         struct screen *sc = &screens[l];
 479
 480         text_w = pm->font_w;
 481
 482         while (*utf8)
 483         {
 484             int w = font_get_width(pm->font, ch);
 485             utf8 = (unsigned char*)utf8decode(utf8, &ch);
 486
 487             if (w > text_w)
 488                 text_w = w;
 489         }
 490
 491         pm->max_chars_text = sc->getwidth() / text_w - 2;
 492
 493         /* Calculate keyboard grid size */
 494         pm->max_chars = sc->getwidth() / pm->font_w;
 495
 496         if (!kbd_loaded)
 497         {
 498             pm->lines = pm->DEFAULT_LINES;
 499             pm->keyboard_margin = DEFAULT_MARGIN;
 500         }
 501         else
 502         {
 503             pm->lines = (sc->getheight() - BUTTONBAR_HEIGHT - statusbar_size)
 504                             / pm->font_h - 1;
 505             pm->keyboard_margin = sc->getheight() - BUTTONBAR_HEIGHT -
 506                 statusbar_size - (pm->lines+1)*pm->font_h;
 507
 508             if (pm->keyboard_margin < 3)
 509             {
 510                 pm->lines--;
 511                 pm->keyboard_margin += pm->font_h;
 512             }
 513
 514             if (pm->keyboard_margin > 6)
 515                 pm->keyboard_margin = 6;
 516         }
 517
 518         pm->pages = (pm->nchars + (pm->lines*pm->max_chars-1))
 519              / (pm->lines*pm->max_chars);
 520
 521         if (pm->pages == 1 && kbd_loaded)
 522             pm->lines = (pm->nchars + pm->max_chars - 1) / pm->max_chars;
 523
 524         pm->main_y = pm->font_h*pm->lines + pm->keyboard_margin + statusbar_size;
 525         pm->main_x = 0;
 526         pm->keyboard_margin -= pm->keyboard_margin/2;
 527
 528 #ifdef KBD_MORSE_INPUT
 529         pm->old_main_y = pm->main_y;
 530         if (morse_mode)
 531             pm->main_y = sc->getheight() - pm->font_h;
 532 #endif
 533     }
 534
 535     /* Initial edit position is after last character */
 536     editpos = utf8length(text);
 537
 538     if (global_settings.talk_menu) /* voice UI? */
 539         talk_spell(text, true); /* spell initial text */
 540
 541
 542     while (!done)
 543     {
 544         /* These declarations are assigned to the screen on which the key
 545            action occurred - pointers save a lot of space over array notation
 546            when accessing the same array element countless times */
 547         int button;
 548 #if NB_SCREENS > 1
 549         int button_screen;
 550 #else
 551         const int button_screen = 0;
 552 #endif
 553         struct keyboard_parameters *pm;
 554         struct screen *sc;
 555
 556         int len_utf8 = utf8length(text);
 557
 558         FOR_NB_SCREENS(l)
 559             screens[l].clear_display();
 560
 561 #ifdef KBD_MORSE_INPUT
 562         if (morse_mode)
 563         {
 564             FOR_NB_SCREENS(l)
 565             {
 566                 /* declare scoped pointers inside screen loops - hide the
 567                    declarations from previous block level */
 568                 const int w = 6; /* sysfixed font width */
 569                 struct keyboard_parameters *pm = &param[l];
 570                 struct screen *sc = &screens[l];
 571                 int i;
 572
 573                 sc->setfont(FONT_SYSFIXED); /* Draw morse code screen with sysfont */
 574                 pm->x = 0;
 575                 pm->y = statusbar_size;
 576                 buf[1] = '\0';
 577
 578                 /* Draw morse code table with code descriptions. */
 579                 for (i = 0; morse_alphabets[i] != '\0'; i++)
 580                 {
 581                     int morse_len;
 582                     int j;
 583
 584                     buf[0] = morse_alphabets[i];
 585                     sc->putsxy(pm->x, pm->y, buf);
 586
 587                     for (j = 0; (morse_codes[i] >> j) > 0x01; j++) ;
 588                     morse_len = j;
 589
 590                     pm->x += w + 3;
 591                     for (j = 0; j < morse_len; j++)
 592                     {
 593                         if ((morse_codes[i] >> (morse_len-j-1)) & 0x01)
 594                             sc->fillrect(pm->x + j*4, pm->y + 2, 3, 4);
 595                         else
 596                             sc->fillrect(pm->x + j*4, pm->y + 3, 1, 2);
 597                     }
 598
 599                     pm->x += w*5 - 3;
 600                     if (pm->x >= sc->getwidth() - w*6)
 601                     {
 602                         pm->x = 0;
 603                         pm->y += 8; /* sysfixed font height */
 604                     }
 605                 }
 606             }
 607         }
 608         else
 609 #endif /* KBD_MORSE_INPUT */
 610         {
 611             /* draw page */
 612             FOR_NB_SCREENS(l)
 613             {
 614                 struct keyboard_parameters *pm = &param[l];
 615                 struct screen *sc = &screens[l];
 616                 int i, j, k;
 617
 618                 sc->setfont(pm->curfont);
 619
 620                 k = pm->page*pm->max_chars*pm->lines;
 621
 622                 for (i = j = 0; j < pm->lines && k < pm->nchars; k++)
 623                 {
 624                     int w;
 625                     utf8 = utf8encode(pm->kbd_buf[k], outline);
 626                     *utf8 = 0;
 627
 628                     sc->getstringsize(outline, &w, NULL);
 629                     sc->putsxy(i*pm->font_w + (pm->font_w-w) / 2,
 630                                j*pm->font_h + statusbar_size, outline);
 631
 632                     if (++i >= pm->max_chars)
 633                     {
 634                         i = 0;
 635                         j++;
 636                     }
 637                 }
 638             }
 639         }
 640
 641         /* separator */
 642         FOR_NB_SCREENS(l)
 643         {
 644             struct keyboard_parameters *pm = &param[l];
 645             struct screen *sc = &screens[l];
 646             int i = 0, j = 0;
 647
 648             /* Clear text area one pixel above separator line so any overdraw
 649                doesn't collide */
 650             sc->set_drawmode(DRMODE_SOLID | DRMODE_INVERSEVID);
 651             sc->fillrect(0, pm->main_y - pm->keyboard_margin - 1,
 652                          sc->getwidth(), pm->font_h + 4);
 653             sc->set_drawmode(DRMODE_SOLID);
 654
 655             sc->hline(0, sc->getwidth() - 1, pm->main_y - pm->keyboard_margin);
 656
 657             /* write out the text */
 658             sc->setfont(pm->curfont);
 659
 660             pm->curpos = MIN(editpos, pm->max_chars_text
 661                                 - MIN(len_utf8 - editpos, 2));
 662             pm->leftpos = editpos - pm->curpos;
 663             utf8 = text + utf8seek(text, pm->leftpos);
 664
 665             text_w = pm->font_w;
 666
 667             while (*utf8 && i < pm->max_chars_text)
 668             {
 669                 outline[j++] = *utf8++;
 670
 671                 if ((*utf8 & MASK) != COMP)
 672                 {
 673                     int w;
 674                     outline[j] = 0;
 675                     j=0;
 676                     i++;
 677                     sc->getstringsize(outline, &w, NULL);
 678                     sc->putsxy(i*text_w + (text_w-w)/2, pm->main_y, outline);
 679                 }
 680             }
 681
 682             if (pm->leftpos > 0)
 683             {
 684                 /* Draw nicer bitmap arrow if room, else settle for "<". */
 685                 if (text_w >= 6 && pm->font_h >= 8)
 686                 {
 687                     screen_put_iconxy(sc, (text_w - 6) / 2,
 688                                       pm->main_y + (pm->font_h - 8) / 2 ,
 689                                       Icon_Reverse_Cursor);
 690                 }
 691                 else
 692                 {
 693                     int w;
 694                     sc->getstringsize("<", &w, NULL);
 695                     sc->putsxy(text_w - w, pm->main_y, "<");
 696                 }
 697             }
 698
 699             if (len_utf8 - pm->leftpos > pm->max_chars_text)
 700             {
 701                 /* Draw nicer bitmap arrow if room, else settle for ">". */
 702                 if (text_w >= 6 && pm->font_h >= 8)
 703                 {
 704                     screen_put_iconxy(sc, sc->getwidth() - text_w +
 705                                       (text_w - 6) / 2,
 706                                       pm->main_y + (pm->font_h - 8) / 2,
 707                                       Icon_Cursor);
 708                 }
 709                 else
 710                 {
 711                     sc->putsxy(sc->getwidth() - text_w, pm->main_y, ">");
 712                 }
 713             }
 714
 715             /* cursor */
 716             i = (pm->curpos + 1) * text_w;
 717
 718             if (cur_blink)
 719                 sc->vline(i, pm->main_y, pm->main_y + pm->font_h - 1);
 720
 721             if (pm->hangul) /* draw underbar */
 722                 sc->hline(pm->curpos*text_w, (pm->curpos+1)*text_w,
 723                           pm->main_y + pm->font_h - 1);
 724         }
 725
 726         cur_blink = !cur_blink;
 727
 728 #ifdef HAVE_BUTTONBAR
 729         /* draw the button bar */
 730         gui_buttonbar_set(&buttonbar, "Shift", "OK", "Del");
 731         gui_buttonbar_draw(&buttonbar);
 732 #endif
 733
 734         FOR_NB_SCREENS(l)
 735         {
 736             struct keyboard_parameters *pm = &param[l];
 737             struct screen *sc = &screens[l];
 738
 739             sc->set_drawmode(DRMODE_COMPLEMENT);
 740 #ifdef KBD_MODES
 741             if (pm->line_edit)
 742                 sc->fillrect(0, pm->main_y - pm->keyboard_margin + 2,
 743                              sc->getwidth(), pm->font_h + 2);
 744             else /* highlight the key that has focus */
 745 #endif
 746                 sc->fillrect(pm->font_w*pm->x,
 747                              statusbar_size + pm->font_h*pm->y,
 748                              pm->font_w, pm->font_h);
 749             sc->set_drawmode(DRMODE_SOLID);
 750         }
 751
 752         FOR_NB_SCREENS(l)
 753             screens[l].update();
 754
 755         button = get_action(CONTEXT_KEYBOARD, HZ/2);
 756 #if NB_SCREENS > 1
 757         button_screen = (get_action_statuscode(NULL) & ACTION_REMOTE) ? 1 : 0;
 758 #endif
 759         pm = &param[button_screen];
 760         sc = &screens[button_screen];
 761
 762 #if defined KBD_MORSE_INPUT && !defined KBD_MODES
 763         if (morse_mode)
 764         {
 765             /* Remap some buttons for morse mode. */
 766             if (button == ACTION_KBD_LEFT)
 767                 button = ACTION_KBD_CURSOR_LEFT;
 768             if (button == ACTION_KBD_RIGHT)
 769                 button = ACTION_KBD_CURSOR_RIGHT;
 770         }
 771 #endif
 772
 773         switch ( button )
 774         {
 775             case ACTION_KBD_ABORT:
 776                 FOR_NB_SCREENS(l)
 777                     screens[l].setfont(FONT_UI);
 778                 ret = -1; done = true;
 779                 break;
 780
 781             case ACTION_KBD_PAGE_FLIP:
 782             {
 783                 int k;
 784 #ifdef KBD_MORSE_INPUT
 785                 if (morse_mode)
 786                     break;
 787 #endif
 788                 if (++pm->page >= pm->pages)
 789                      pm->page = 0;
 790
 791                 k = get_param_k(pm);
 792                 kbd_spellchar(pm->kbd_buf[k]);
 793                 break;
 794                 }
 795
 796 #ifdef KBD_MORSE_INPUT
 797             case ACTION_KBD_MORSE_INPUT:
 798                 morse_mode = !morse_mode;
 799
 800                 FOR_NB_SCREENS(l)
 801                 {
 802                     struct keyboard_parameters *pm = &param[l];
 803                     struct screen *sc = &screens[l];
 804
 805                     pm->x = pm->y = pm->page = 0;
 806
 807                     if (morse_mode)
 808                     {
 809                         pm->old_main_y = pm->main_y;
 810                         pm->main_y = sc->getheight() - pm->font_h;
 811                     }
 812                     else
 813                     {
 814                         pm->main_y = pm->old_main_y;
 815                     }
 816                 }
 817                 /* FIXME: We should talk something like Morse mode.. */
 818                 break;
 819 #endif /* KBD_MORSE_INPUT */
 820
 821             case ACTION_KBD_RIGHT:
 822 #ifdef KBD_MODES
 823 #ifdef KBD_MORSE_INPUT
 824                 /* allow cursor change in non line edit morse mode */
 825                 if (pm->line_edit || morse_mode)
 826 #else
 827                 /* right doubles as cursor_right in line_edit */
 828                 if (pm->line_edit)
 829 #endif
 830                 {
 831                     pm->hangul = false;
 832
 833                     if (editpos < len_utf8)
 834                     {
 835                         int c = utf8seek(text, ++editpos);
 836                         kbd_spellchar(text[c]);
 837                     }
 838 #if CONFIG_CODEC == SWCODEC
 839                     else if (global_settings.talk_menu)
 840                         pcmbuf_beep(1000, 150, 1500);
 841 #endif
 842                 }
 843                 else
 844 #endif /* KBD_MODES */
 845                 {
 846                     int k;
 847 #ifdef KBD_MORSE_INPUT
 848                     if (morse_mode)
 849                         break;
 850 #endif
 851                     if (++pm->x >= pm->max_chars)
 852                     {
 853 #ifndef KBD_PAGE_FLIP
 854                         /* no dedicated flip key - flip page on wrap */
 855                         if (++pm->page >= pm->pages)
 856                             pm->page = 0;
 857 #endif
 858                         pm->x = 0;
 859                     }
 860
 861                     k = get_param_k(pm);
 862                     kbd_spellchar(pm->kbd_buf[k]);
 863                 }
 864                 break;
 865
 866             case ACTION_KBD_LEFT:
 867 #ifdef KBD_MODES
 868 #ifdef KBD_MORSE_INPUT
 869                 /* allow cursor change in non line edit morse mode */
 870                 if (pm->line_edit || morse_mode)
 871 #else
 872                 /* left doubles as cursor_left in line_edit */
 873                 if (pm->line_edit)
 874 #endif
 875                 {
 876                     pm->hangul = false;
 877
 878                     if (editpos > 0)
 879                     {
 880                         int c = utf8seek(text, --editpos);
 881                         kbd_spellchar(text[c]);
 882                     }
 883 #if CONFIG_CODEC == SWCODEC
 884                     else if (global_settings.talk_menu)
 885                         pcmbuf_beep(1000, 150, 1500);
 886 #endif
 887                 }
 888                 else
 889 #endif /* KBD_MODES */
 890                 {
 891                     int k;
 892 #ifdef KBD_MORSE_INPUT
 893                     if (morse_mode)
 894                         break;
 895 #endif
 896                     if (--pm->x < 0)
 897                     {
 898 #ifndef KBD_PAGE_FLIP
 899                         /* no dedicated flip key - flip page on wrap */
 900                         if (--pm->page < 0)
 901                             pm->page = pm->pages - 1;
 902 #endif
 903                         pm->x = pm->max_chars - 1;
 904                     }
 905
 906                     k = get_param_k(pm);
 907                     kbd_spellchar(pm->kbd_buf[k]);
 908                 }
 909                 break;
 910
 911             case ACTION_KBD_DOWN:
 912 #ifdef KBD_MORSE_INPUT
 913 #ifdef KBD_MODES
 914                 if (morse_mode)
 915                 {
 916                     pm->line_edit = !pm->line_edit;
 917                     if(pm->line_edit)
 918                         say_edit();
 919                 }
 920                 else
 921 #else
 922                 if (morse_mode)
 923                     break;
 924 #endif
 925 #endif /* KBD_MORSE_INPUT */
 926                 {
 927 #ifdef KBD_MODES
 928                     if (pm->line_edit)
 929                     {
 930                         pm->y = 0;
 931                         pm->line_edit = false;
 932                     }
 933                     else
 934 #endif
 935                     if (++pm->y >= pm->lines)
 936 #ifdef KBD_MODES
 937                     {
 938                         pm->line_edit = true;
 939                         say_edit();
 940                     }
 941 #else
 942                         pm->y = 0;
 943 #endif
 944                 }
 945 #ifdef KBD_MODES
 946                 if (!pm->line_edit)
 947 #endif
 948                 {
 949                     int k = get_param_k(pm);
 950                     kbd_spellchar(pm->kbd_buf[k]);
 951                 }
 952                 break;
 953
 954             case ACTION_KBD_UP:
 955 #ifdef KBD_MORSE_INPUT
 956 #ifdef KBD_MODES
 957                 if (morse_mode)
 958                 {
 959                     pm->line_edit = !pm->line_edit;
 960                     if(pm->line_edit)
 961                         say_edit();
 962                 }
 963                 else
 964 #else
 965                 if (morse_mode)
 966                     break;
 967 #endif
 968 #endif /* KBD_MORSE_INPUT */
 969                 {
 970 #ifdef KBD_MODES
 971                     if (pm->line_edit)
 972                     {
 973                         pm->y = pm->lines - 1;
 974                         pm->line_edit = false;
 975                     }
 976                     else
 977 #endif
 978                     if (--pm->y < 0)
 979 #ifdef KBD_MODES
 980                     {
 981                         pm->line_edit = true;
 982                         say_edit();
 983                     }
 984 #else
 985                         pm->y = pm->lines - 1;
 986 #endif
 987                 }
 988 #ifdef KBD_MODES
 989                 if (!pm->line_edit)
 990 #endif
 991                 {
 992                     int k = get_param_k(pm);
 993                     kbd_spellchar(pm->kbd_buf[k]);
 994                 }
 995                 break;
 996
 997             case ACTION_KBD_DONE:
 998                 /* accepts what was entered and continues */
 999                 ret = 0;
1000                 done = true;
1001                 break;
1002
1003 #ifdef KBD_MORSE_INPUT
1004             case ACTION_KBD_MORSE_SELECT:
1005                 if (morse_mode && morse_reading)
1006                 {
1007                     morse_code <<= 1;
1008                     if ((current_tick - morse_tick) > HZ/5)
1009                         morse_code |= 0x01;
1010                 }
1011
1012                 break;
1013 #endif /* KBD_MORSE_INPUT */
1014
1015             case ACTION_KBD_SELECT:
1016             case ACTION_KBD_SELECT_REM:
1017 #ifdef KBD_MORSE_INPUT
1018 #ifdef KBD_MODES
1019                 if (morse_mode && !pm->line_edit)
1020 #else
1021                 if (morse_mode)
1022 #endif
1023                 {
1024                     morse_tick = current_tick;
1025
1026                     if (!morse_reading)
1027                     {
1028                         morse_reading = true;
1029                         morse_code = 1;
1030                     }
1031                     break;
1032                 }
1033 #endif /* KBD_MORSE_INPUT */
1034
1035                 /* inserts the selected char */
1036 #ifdef KBD_MODES
1037                 if (pm->line_edit)
1038                 { /* select doubles as backspace in line_edit */
1039                     if (pm->hangul)
1040                     {
1041                         if (pm->htail)
1042                             pm->htail = 0;
1043                         else if (pm->hvowel)
1044                             pm->hvowel = 0;
1045                         else
1046                             pm->hangul = false;
1047                     }
1048
1049                     kbd_delchar(text, &editpos);
1050
1051                     if (pm->hangul)
1052                     {
1053                         if (pm->hvowel)
1054                             ch = hangul_join(pm->hlead, pm->hvowel, pm->htail);
1055                         else
1056                             ch = pm->hlead;
1057                         kbd_inschar(text, buflen, &editpos, ch);
1058                     }
1059                 }
1060                 else
1061 #endif /* KBD_MODES */
1062                 {
1063                     /* find input char */
1064                     int k = get_param_k(pm);
1065                     ch = (k < pm->nchars) ? pm->kbd_buf[k] : ' ';
1066
1067                     /* check for hangul input */
1068                     if (ch >= 0x3131 && ch <= 0x3163)
1069                     {
1070                         unsigned short tmp;
1071
1072                         if (!pm->hangul)
1073                         {
1074                             pm->hlead = pm->hvowel = pm->htail = 0;
1075                             pm->hangul = true;
1076                         }
1077
1078                         if (!pm->hvowel)
1079                         {
1080                             pm->hvowel = ch;
1081                         }
1082                         else if (!pm->htail)
1083                         {
1084                             pm->htail = ch;
1085                         }
1086                         else
1087                         { /* previous hangul complete */
1088                             /* check whether tail is actually lead of next char */
1089                             tmp = hangul_join(pm->htail, ch, 0);
1090
1091                             if (tmp != 0xfffd)
1092                             {
1093                                 tmp = hangul_join(pm->hlead, pm->hvowel, 0);
1094                                 kbd_delchar(text, &editpos);
1095                                 kbd_inschar(text, buflen, &editpos, tmp);
1096                                 /* insert dummy char */
1097                                 kbd_inschar(text, buflen, &editpos, ' ');
1098                                 pm->hlead = pm->htail;
1099                                 pm->hvowel = ch;
1100                                 pm->htail = 0;
1101                             }
1102                             else
1103                             {
1104                                 pm->hvowel = pm->htail = 0;
1105                                 pm->hlead = ch;
1106                             }
1107                         }
1108
1109                         /* combine into hangul */
1110                         tmp = hangul_join(pm->hlead, pm->hvowel, pm->htail);
1111
1112                         if (tmp != 0xfffd)
1113                         {
1114                             kbd_delchar(text, &editpos);
1115                             ch = tmp;
1116                         }
1117                         else
1118                         {
1119                             pm->hvowel = pm->htail = 0;
1120                             pm->hlead = ch;
1121                         }
1122                     }
1123                     else
1124                     {
1125                         pm->hangul = false;
1126                     }
1127
1128                     /* insert char */
1129                     kbd_inschar(text, buflen, &editpos, ch);
1130                 }
1131
1132                 if (global_settings.talk_menu) /* voice UI? */
1133                     talk_spell(text, false);
1134
1135                 /* speak revised text */
1136                 break;
1137
1138 #if !defined (KBD_MODES) || defined (KBD_CURSOR_KEYS)
1139             case ACTION_KBD_BACKSPACE:
1140                 if (pm->hangul)
1141                 {
1142                     if (pm->htail)
1143                         pm->htail = 0;
1144                     else if (pm->hvowel)
1145                         pm->hvowel = 0;
1146                     else
1147                         pm->hangul = false;
1148                 }
1149
1150                 kbd_delchar(text, &editpos);
1151
1152                 if (pm->hangul)
1153                 {
1154                     if (pm->hvowel)
1155                         ch = hangul_join(pm->hlead, pm->hvowel, pm->htail);
1156                     else
1157                         ch = pm->hlead;
1158                     kbd_inschar(text, buflen, &editpos, ch);
1159                 }
1160
1161                 if (global_settings.talk_menu) /* voice UI? */
1162                     talk_spell(text, false);   /* speak revised text */
1163                 break;
1164
1165             case ACTION_KBD_CURSOR_RIGHT:
1166                 pm->hangul = false;
1167
1168                 if (editpos < len_utf8)
1169                 {
1170                     int c = utf8seek(text, ++editpos);
1171                     kbd_spellchar(text[c]);
1172                 }
1173 #if CONFIG_CODEC == SWCODEC
1174                 else if (global_settings.talk_menu)
1175                     pcmbuf_beep(1000, 150, 1500);
1176 #endif
1177                 break;
1178
1179             case ACTION_KBD_CURSOR_LEFT:
1180                 pm->hangul = false;
1181
1182                 if (editpos > 0)
1183                 {
1184                     int c = utf8seek(text, --editpos);
1185                     kbd_spellchar(text[c]);
1186                 }
1187 #if CONFIG_CODEC == SWCODEC
1188                 else if (global_settings.talk_menu)
1189                     pcmbuf_beep(1000, 150, 1500);
1190 #endif
1191                 break;
1192 #endif /* !defined (KBD_MODES) || defined (KBD_CURSOR_KEYS) */
1193
1194             case BUTTON_NONE:
1195 #ifdef KBD_MORSE_INPUT
1196                 if (morse_reading)
1197                 {
1198                     int j;
1199                     logf("Morse: 0x%02x", morse_code);
1200                     morse_reading = false;
1201
1202                     for (j = 0; morse_alphabets[j] != '\0'; j++)
1203                     {
1204                         if (morse_codes[j] == morse_code)
1205                             break ;
1206                     }
1207
1208                     if (morse_alphabets[j] == '\0')
1209                     {
1210                         logf("Morse code not found");
1211                         break ;
1212                     }
1213
1214                     /* turn off hangul input */
1215                     FOR_NB_SCREENS(l)
1216                         param[l].hangul = false;
1217                     kbd_inschar(text, buflen, &editpos, morse_alphabets[j]);
1218
1219                     if (global_settings.talk_menu) /* voice UI? */
1220                         talk_spell(text, false);   /* speak revised text */
1221                 }
1222 #endif /* KBD_MORSE_INPUT */
1223                 break;
1224
1225             default:
1226                 if (default_event_handler(button) == SYS_USB_CONNECTED)
1227                 {
1228                     FOR_NB_SCREENS(l)
1229                         screens[l].setfont(FONT_SYSFIXED);
1230                 }
1231                 break;
1232
1233         } /* end switch */
1234
1235         if (button != BUTTON_NONE)
1236         {
1237             cur_blink = true;
1238         }
1239     }
1240
1241 #ifdef HAVE_BUTTONBAR
1242     global_settings.buttonbar = buttonbar_config;
1243 #endif
1244
1245     FOR_NB_SCREENS(l)
1246         screens[l].setfont(FONT_UI);
1247     viewportmanager_set_statusbar(oldbars);
1248
1249     if (ret < 0)
1250         splash(HZ/2, ID2P(LANG_CANCEL));
1251     return ret;
1252 }