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         /* find max width of keyboard glyphs.
 412          * since we're going to be adding spaces,
 413          * max width is at least their width */
 414         pm->font_w = font_get_width(pm->font, ' ');
 415         for (i = 0; i < pm->nchars; i++)
 416         {
 417             if (pm->kbd_buf[i] != '\n')
 418             {
 419                 w = font_get_width(pm->font, pm->kbd_buf[i]);
 420                 if (w > pm->font_w)
 421                     pm->font_w = w;
 422             }
 423         }
 424     }
 425
 426     FOR_NB_SCREENS(l)
 427     {
 428         struct keyboard_parameters *pm = &param[l];
 429         struct screen *sc = &screens[l];
 430         int i = 0;
 431
 432         pm->max_chars = sc->getwidth() / pm->font_w;
 433
 434         /* Pad lines with spaces */
 435         while (i < pm->nchars)
 436         {
 437             if (pm->kbd_buf[i] == '\n')
 438             {
 439                 int k = pm->max_chars - i % ( pm->max_chars ) - 1;
 440                 int j;
 441
 442                 if (k == pm->max_chars - 1)
 443                 {
 444                     pm->nchars--;
 445
 446                     for (j = i; j < pm->nchars; j++)
 447                     {
 448                         pm->kbd_buf[j] = pm->kbd_buf[j + 1];
 449                     }
 450                 }
 451                 else
 452                 {
 453                     if (pm->nchars + k - 1 >= KBD_BUF_SIZE)
 454                     {   /* We don't want to overflow the buffer */
 455                         k = KBD_BUF_SIZE - pm->nchars;
 456                     }
 457
 458                     for (j = pm->nchars + k - 1; j > i + k; j--)
 459                     {
 460                         pm->kbd_buf[j] = pm->kbd_buf[j-k];
 461                     }
 462
 463                     pm->nchars += k;
 464                     k++;
 465
 466                     while (k--)
 467                     {
 468                         pm->kbd_buf[i++] = ' ';
 469                     }
 470                 }
 471             }
 472             else
 473             {
 474                 i++;
 475             }
 476         }
 477     }
 478
 479     /* Find max width for text string */
 480     FOR_NB_SCREENS(l)
 481     {
 482         struct keyboard_parameters *pm = &param[l];
 483         struct screen *sc = &screens[l];
 484         int icon_w, sc_w, sc_h;
 485
 486         pm->text_w = pm->font_w;
 487
 488         utf8 = text;
 489         while (*utf8)
 490         {
 491             int w;
 492             utf8 = (unsigned char*)utf8decode(utf8, &ch);
 493             w = font_get_width(pm->font, ch);
 494             if (w > pm->text_w)
 495                 pm->text_w = w;
 496         }
 497
 498         icon_w = get_icon_width(l);
 499         sc_w = sc->getwidth();
 500         sc_h = sc->getheight();
 501         pm->max_chars_text = (sc_w - icon_w * 2 - 2) / pm->text_w;
 502         if(pm->max_chars_text < 3 && icon_w > pm->text_w)
 503             pm->max_chars_text = sc_w / 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_h - BUTTONBAR_HEIGHT - statusbar_size)
 513                             / pm->font_h - 1;
 514             pm->keyboard_margin = sc_h - BUTTONBAR_HEIGHT - statusbar_size
 515                                     - (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_h - 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(i - text_w, i, pm->main_y + pm->font_h - 1);
 733         }
 734
 735         cur_blink = !cur_blink;
 736
 737 #ifdef HAVE_BUTTONBAR
 738         /* draw the button bar */
 739         gui_buttonbar_set(&buttonbar, "Shift", "OK", "Del");
 740         gui_buttonbar_draw(&buttonbar);
 741 #endif
 742
 743         FOR_NB_SCREENS(l)
 744         {
 745             struct keyboard_parameters *pm = &param[l];
 746             struct screen *sc = &screens[l];
 747
 748             sc->set_drawmode(DRMODE_COMPLEMENT);
 749 #ifdef KBD_MODES
 750             if (pm->line_edit)
 751                 sc->fillrect(0, pm->main_y - pm->keyboard_margin + 2,
 752                              sc->getwidth(), pm->font_h + 2);
 753             else /* highlight the key that has focus */
 754 #endif
 755 #ifdef KBD_MORSE_INPUT
 756             if(!morse_mode)
 757 #endif
 758                 sc->fillrect(pm->font_w*pm->x,
 759                              statusbar_size + pm->font_h*pm->y,
 760                              pm->font_w, pm->font_h);
 761             sc->set_drawmode(DRMODE_SOLID);
 762         }
 763
 764         FOR_NB_SCREENS(l)
 765             screens[l].update();
 766
 767         button = get_action(CONTEXT_KEYBOARD, HZ/2);
 768 #if NB_SCREENS > 1
 769         button_screen = (get_action_statuscode(NULL) & ACTION_REMOTE) ? 1 : 0;
 770 #endif
 771         pm = &param[button_screen];
 772         sc = &screens[button_screen];
 773
 774 #if defined(KBD_MODES) || defined(KBD_MORSE_INPUT)
 775         /* Remap some buttons to allow to move
 776          * cursor in line edit mode and morse mode. */
 777 #if defined(KBD_MODES) && defined(KBD_MORSE_INPUT)
 778         if (pm->line_edit || morse_mode)
 779 #elif defined(KBD_MODES)
 780         if (pm->line_edit)
 781 #else /* defined(KBD_MORSE_INPUT) */
 782         if (morse_mode)
 783 #endif
 784         {
 785             if (button == ACTION_KBD_LEFT)
 786                 button = ACTION_KBD_CURSOR_LEFT;
 787             if (button == ACTION_KBD_RIGHT)
 788                 button = ACTION_KBD_CURSOR_RIGHT;
 789         }
 790 #endif /* defined(KBD_MODES) || defined(KBD_MORSE_INPUT) */
 791
 792         switch ( button )
 793         {
 794             case ACTION_KBD_ABORT:
 795                 ret = -1;
 796                 done = true;
 797                 break;
 798
 799             case ACTION_KBD_PAGE_FLIP:
 800             {
 801 #ifdef KBD_MORSE_INPUT
 802                 if (morse_mode)
 803                     break;
 804 #endif
 805                 if (++pm->page >= pm->pages)
 806                     pm->page = 0;
 807
 808                 ch = get_kbd_ch(pm);
 809                 kbd_spellchar(ch);
 810                 break;
 811                 }
 812
 813 #ifdef KBD_MORSE_INPUT
 814             case ACTION_KBD_MORSE_INPUT:
 815                 morse_mode = !morse_mode;
 816
 817                 FOR_NB_SCREENS(l)
 818                 {
 819                     struct keyboard_parameters *pm = &param[l];
 820                     struct screen *sc = &screens[l];
 821
 822                     if (morse_mode)
 823                     {
 824                         pm->old_main_y = pm->main_y;
 825                         pm->main_y = sc->getheight() - pm->font_h;
 826                     }
 827                     else
 828                     {
 829                         pm->main_y = pm->old_main_y;
 830                     }
 831                 }
 832                 /* FIXME: We should talk something like Morse mode.. */
 833                 break;
 834 #endif /* KBD_MORSE_INPUT */
 835
 836             case ACTION_KBD_RIGHT:
 837                 if (++pm->x >= pm->max_chars)
 838                 {
 839 #ifndef KBD_PAGE_FLIP
 840                     /* no dedicated flip key - flip page on wrap */
 841                     if (++pm->page >= pm->pages)
 842                         pm->page = 0;
 843 #endif
 844                     pm->x = 0;
 845                 }
 846
 847                 ch = get_kbd_ch(pm);
 848                 kbd_spellchar(ch);
 849                 break;
 850
 851             case ACTION_KBD_LEFT:
 852                 if (--pm->x < 0)
 853                 {
 854 #ifndef KBD_PAGE_FLIP
 855                     /* no dedicated flip key - flip page on wrap */
 856                     if (--pm->page < 0)
 857                         pm->page = pm->pages - 1;
 858 #endif
 859                     pm->x = pm->max_chars - 1;
 860                 }
 861
 862                 ch = get_kbd_ch(pm);
 863                 kbd_spellchar(ch);
 864                 break;
 865
 866             case ACTION_KBD_DOWN:
 867 #ifdef KBD_MORSE_INPUT
 868 #ifdef KBD_MODES
 869                 if (morse_mode)
 870                 {
 871                     pm->line_edit = !pm->line_edit;
 872                     if(pm->line_edit)
 873                         say_edit();
 874                 }
 875                 else
 876 #else
 877                 if (morse_mode)
 878                     break;
 879 #endif
 880 #endif /* KBD_MORSE_INPUT */
 881                 {
 882 #ifdef KBD_MODES
 883                     if (pm->line_edit)
 884                     {
 885                         pm->y = 0;
 886                         pm->line_edit = false;
 887                     }
 888                     else
 889 #endif
 890                     if (++pm->y >= pm->lines)
 891 #ifdef KBD_MODES
 892                     {
 893                         pm->line_edit = true;
 894                         say_edit();
 895                     }
 896 #else
 897                         pm->y = 0;
 898 #endif
 899                 }
 900 #ifdef KBD_MODES
 901                 if (!pm->line_edit)
 902 #endif
 903                 {
 904                     ch = get_kbd_ch(pm);
 905                     kbd_spellchar(ch);
 906                 }
 907                 break;
 908
 909             case ACTION_KBD_UP:
 910 #ifdef KBD_MORSE_INPUT
 911 #ifdef KBD_MODES
 912                 if (morse_mode)
 913                 {
 914                     pm->line_edit = !pm->line_edit;
 915                     if(pm->line_edit)
 916                         say_edit();
 917                 }
 918                 else
 919 #else
 920                 if (morse_mode)
 921                     break;
 922 #endif
 923 #endif /* KBD_MORSE_INPUT */
 924                 {
 925 #ifdef KBD_MODES
 926                     if (pm->line_edit)
 927                     {
 928                         pm->y = pm->lines - 1;
 929                         pm->line_edit = false;
 930                     }
 931                     else
 932 #endif
 933                     if (--pm->y < 0)
 934 #ifdef KBD_MODES
 935                     {
 936                         pm->line_edit = true;
 937                         say_edit();
 938                     }
 939 #else
 940                         pm->y = pm->lines - 1;
 941 #endif
 942                 }
 943 #ifdef KBD_MODES
 944                 if (!pm->line_edit)
 945 #endif
 946                 {
 947                     ch = get_kbd_ch(pm);
 948                     kbd_spellchar(ch);
 949                 }
 950                 break;
 951
 952             case ACTION_KBD_DONE:
 953                 /* accepts what was entered and continues */
 954                 ret = 0;
 955                 done = true;
 956                 break;
 957
 958 #ifdef KBD_MORSE_INPUT
 959             case ACTION_KBD_MORSE_SELECT:
 960                 if (morse_mode && morse_reading)
 961                 {
 962                     morse_code <<= 1;
 963                     if ((current_tick - morse_tick) > HZ/5)
 964                         morse_code |= 0x01;
 965                 }
 966
 967                 break;
 968 #endif /* KBD_MORSE_INPUT */
 969
 970             case ACTION_KBD_SELECT:
 971 #ifdef KBD_MORSE_INPUT
 972 #ifdef KBD_MODES
 973                 if (morse_mode && !pm->line_edit)
 974 #else
 975                 if (morse_mode)
 976 #endif
 977                 {
 978                     morse_tick = current_tick;
 979
 980                     if (!morse_reading)
 981                     {
 982                         morse_reading = true;
 983                         morse_code = 1;
 984                     }
 985                     break;
 986                 }
 987 #endif /* KBD_MORSE_INPUT */
 988
 989                 /* inserts the selected char */
 990 #ifdef KBD_MODES
 991                 if (pm->line_edit)
 992                 { /* select doubles as backspace in line_edit */
 993                     if (pm->hangul)
 994                     {
 995                         if (pm->htail)
 996                             pm->htail = 0;
 997                         else if (pm->hvowel)
 998                             pm->hvowel = 0;
 999                         else
1000                             pm->hangul = false;
1001                     }
1002
1003                     kbd_delchar(text, &editpos);
1004
1005                     if (pm->hangul)
1006                     {
1007                         if (pm->hvowel)
1008                             ch = hangul_join(pm->hlead, pm->hvowel, pm->htail);
1009                         else
1010                             ch = pm->hlead;
1011                         kbd_inschar(text, buflen, &editpos, ch);
1012                     }
1013                 }
1014                 else
1015 #endif /* KBD_MODES */
1016                 {
1017                     /* find input char */
1018                     ch = get_kbd_ch(pm);
1019
1020                     /* check for hangul input */
1021                     if (ch >= 0x3131 && ch <= 0x3163)
1022                     {
1023                         unsigned short tmp;
1024
1025                         if (!pm->hangul)
1026                         {
1027                             pm->hlead = pm->hvowel = pm->htail = 0;
1028                             pm->hangul = true;
1029                         }
1030
1031                         if (!pm->hvowel)
1032                         {
1033                             pm->hvowel = ch;
1034                         }
1035                         else if (!pm->htail)
1036                         {
1037                             pm->htail = ch;
1038                         }
1039                         else
1040                         { /* previous hangul complete */
1041                             /* check whether tail is actually lead of next char */
1042                             tmp = hangul_join(pm->htail, ch, 0);
1043
1044                             if (tmp != 0xfffd)
1045                             {
1046                                 tmp = hangul_join(pm->hlead, pm->hvowel, 0);
1047                                 kbd_delchar(text, &editpos);
1048                                 kbd_inschar(text, buflen, &editpos, tmp);
1049                                 /* insert dummy char */
1050                                 kbd_inschar(text, buflen, &editpos, ' ');
1051                                 pm->hlead = pm->htail;
1052                                 pm->hvowel = ch;
1053                                 pm->htail = 0;
1054                             }
1055                             else
1056                             {
1057                                 pm->hvowel = pm->htail = 0;
1058                                 pm->hlead = ch;
1059                             }
1060                         }
1061
1062                         /* combine into hangul */
1063                         tmp = hangul_join(pm->hlead, pm->hvowel, pm->htail);
1064
1065                         if (tmp != 0xfffd)
1066                         {
1067                             kbd_delchar(text, &editpos);
1068                             ch = tmp;
1069                         }
1070                         else
1071                         {
1072                             pm->hvowel = pm->htail = 0;
1073                             pm->hlead = ch;
1074                         }
1075                     }
1076                     else
1077                     {
1078                         pm->hangul = false;
1079                     }
1080
1081                     /* insert char */
1082                     kbd_inschar(text, buflen, &editpos, ch);
1083                 }
1084
1085                 if (global_settings.talk_menu) /* voice UI? */
1086                     talk_spell(text, false);
1087
1088                 /* speak revised text */
1089                 break;
1090
1091 #if !defined (KBD_MODES) || defined (KBD_CURSOR_KEYS)
1092             case ACTION_KBD_BACKSPACE:
1093                 if (pm->hangul)
1094                 {
1095                     if (pm->htail)
1096                         pm->htail = 0;
1097                     else if (pm->hvowel)
1098                         pm->hvowel = 0;
1099                     else
1100                         pm->hangul = false;
1101                 }
1102
1103                 kbd_delchar(text, &editpos);
1104
1105                 if (pm->hangul)
1106                 {
1107                     if (pm->hvowel)
1108                         ch = hangul_join(pm->hlead, pm->hvowel, pm->htail);
1109                     else
1110                         ch = pm->hlead;
1111                     kbd_inschar(text, buflen, &editpos, ch);
1112                 }
1113
1114                 if (global_settings.talk_menu) /* voice UI? */
1115                     talk_spell(text, false);   /* speak revised text */
1116                 break;
1117 #endif /* !defined (KBD_MODES) || defined (KBD_CURSOR_KEYS) */
1118
1119             case ACTION_KBD_CURSOR_RIGHT:
1120                 pm->hangul = false;
1121
1122                 if (editpos < len_utf8)
1123                 {
1124                     int c = utf8seek(text, ++editpos);
1125                     kbd_spellchar(text[c]);
1126                 }
1127 #if CONFIG_CODEC == SWCODEC
1128                 else if (global_settings.talk_menu)
1129                     pcmbuf_beep(1000, 150, 1500);
1130 #endif
1131                 break;
1132
1133             case ACTION_KBD_CURSOR_LEFT:
1134                 pm->hangul = false;
1135
1136                 if (editpos > 0)
1137                 {
1138                     int c = utf8seek(text, --editpos);
1139                     kbd_spellchar(text[c]);
1140                 }
1141 #if CONFIG_CODEC == SWCODEC
1142                 else if (global_settings.talk_menu)
1143                     pcmbuf_beep(1000, 150, 1500);
1144 #endif
1145                 break;
1146
1147             case BUTTON_NONE:
1148 #ifdef KBD_MORSE_INPUT
1149                 if (morse_reading)
1150                 {
1151                     int j;
1152                     logf("Morse: 0x%02x", morse_code);
1153                     morse_reading = false;
1154
1155                     for (j = 0; morse_alphabets[j] != '\0'; j++)
1156                     {
1157                         if (morse_codes[j] == morse_code)
1158                             break ;
1159                     }
1160
1161                     if (morse_alphabets[j] == '\0')
1162                     {
1163                         logf("Morse code not found");
1164                         break ;
1165                     }
1166
1167                     /* turn off hangul input */
1168                     FOR_NB_SCREENS(l)
1169                         param[l].hangul = false;
1170                     kbd_inschar(text, buflen, &editpos, morse_alphabets[j]);
1171
1172                     if (global_settings.talk_menu) /* voice UI? */
1173                         talk_spell(text, false);   /* speak revised text */
1174                 }
1175 #endif /* KBD_MORSE_INPUT */
1176                 break;
1177
1178             default:
1179                 if (default_event_handler(button) == SYS_USB_CONNECTED)
1180                 {
1181                     FOR_NB_SCREENS(l)
1182                         screens[l].setfont(FONT_SYSFIXED);
1183                 }
1184                 break;
1185
1186         } /* end switch */
1187
1188         if (button != BUTTON_NONE)
1189         {
1190             cur_blink = true;
1191         }
1192     }
1193
1194 #ifdef HAVE_BUTTONBAR
1195     global_settings.buttonbar = buttonbar_config;
1196 #endif
1197
1198     if (ret < 0)
1199         splash(HZ/2, ID2P(LANG_CANCEL));
1200
1201     FOR_NB_SCREENS(l)
1202         screens[l].setfont(FONT_UI);
1203     viewportmanager_set_statusbar(oldbars);
1204     send_event(GUI_EVENT_REFRESH, NULL);
1205
1206     return ret;
1207 }