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