apps/plugins/zxbox/zxbox_keyb.c

   1 #include "zxconfig.h"
   2
   3 #ifndef O_BINARY
   4 #define O_BINARY 0
   5 #endif
   6
   7 #if CONFIG_KEYPAD == RECORDER_PAD
   8 #define BUTTONBAR_HEIGHT 8
   9 #else
  10 #define BUTTONBAR_HEIGHT 0
  11 #endif
  12
  13 #define DEFAULT_MARGIN 6
  14 #define KBD_BUF_SIZE 500
  15 #define kbd_loaded false
  16 #define statusbar_size 0
  17
  18 #if (CONFIG_KEYPAD == IRIVER_H100_PAD) || \
  19     (CONFIG_KEYPAD == IRIVER_H300_PAD)
  20 #define KBD_SELECT BUTTON_SELECT
  21 #define KBD_ABORT BUTTON_OFF
  22 #define KBD_LEFT BUTTON_LEFT
  23 #define KBD_RIGHT BUTTON_RIGHT
  24 #define KBD_UP BUTTON_UP
  25 #define KBD_DOWN BUTTON_DOWN
  26
  27 #elif CONFIG_KEYPAD == RECORDER_PAD
  28 #define KBD_SELECT BUTTON_PLAY
  29 #define KBD_ABORT BUTTON_OFF
  30 #define KBD_LEFT BUTTON_LEFT
  31 #define KBD_RIGHT BUTTON_RIGHT
  32 #define KBD_UP BUTTON_UP
  33 #define KBD_DOWN BUTTON_DOWN
  34
  35 #elif CONFIG_KEYPAD == ARCHOS_AV300_PAD
  36 #define KBD_SELECT BUTTON_SELECT
  37 #define KBD_ABORT BUTTON_OFF
  38 #define KBD_LEFT BUTTON_LEFT
  39 #define KBD_RIGHT BUTTON_RIGHT
  40 #define KBD_UP BUTTON_UP
  41 #define KBD_DOWN BUTTON_DOWN
  42
  43 #elif CONFIG_KEYPAD == ONDIO_PAD /* restricted Ondio keypad */
  44 #define KBD_SELECT BUTTON_MENU
  45 #define KBD_ABORT BUTTON_OFF
  46 #define KBD_LEFT BUTTON_LEFT
  47 #define KBD_RIGHT BUTTON_RIGHT
  48 #define KBD_UP BUTTON_UP
  49 #define KBD_DOWN BUTTON_DOWN
  50
  51 #elif (CONFIG_KEYPAD == IPOD_4G_PAD) || \
  52       (CONFIG_KEYPAD == IPOD_3G_PAD) || \
  53       (CONFIG_KEYPAD == IPOD_1G2G_PAD)
  54
  55 #define KBD_SELECT BUTTON_SELECT
  56 #define KBD_ABORT BUTTON_MENU
  57 #define KBD_LEFT BUTTON_LEFT
  58 #define KBD_RIGHT BUTTON_RIGHT
  59 #define KBD_UP BUTTON_SCROLL_BACK
  60 #define KBD_DOWN BUTTON_SCROLL_FWD
  61
  62 #elif CONFIG_KEYPAD == IRIVER_IFP7XX_PAD
  63
  64 /* TODO: Check keyboard mappings */
  65
  66 #define KBD_SELECT BUTTON_SELECT
  67 #define KBD_ABORT BUTTON_PLAY
  68 #define KBD_LEFT BUTTON_LEFT
  69 #define KBD_RIGHT BUTTON_RIGHT
  70 #define KBD_UP BUTTON_UP
  71 #define KBD_DOWN BUTTON_DOWN
  72
  73 #elif CONFIG_KEYPAD == IAUDIO_X5M5_PAD
  74
  75 /* TODO: Check keyboard mappings */
  76
  77 #define KBD_SELECT BUTTON_SELECT
  78 #define KBD_ABORT BUTTON_REC
  79 #define KBD_LEFT BUTTON_LEFT
  80 #define KBD_RIGHT BUTTON_RIGHT
  81 #define KBD_UP BUTTON_UP
  82 #define KBD_DOWN BUTTON_DOWN
  83
  84 #elif CONFIG_KEYPAD == GIGABEAT_PAD
  85
  86 #define KBD_SELECT BUTTON_SELECT
  87 #define KBD_ABORT BUTTON_POWER
  88 #define KBD_LEFT BUTTON_LEFT
  89 #define KBD_RIGHT BUTTON_RIGHT
  90 #define KBD_UP BUTTON_UP
  91 #define KBD_DOWN BUTTON_DOWN
  92
  93 #elif CONFIG_KEYPAD == GIGABEAT_S_PAD
  94
  95 #define KBD_SELECT BUTTON_SELECT
  96 #define KBD_ABORT BUTTON_POWER
  97 #define KBD_LEFT BUTTON_LEFT
  98 #define KBD_RIGHT BUTTON_RIGHT
  99 #define KBD_UP BUTTON_UP
 100 #define KBD_DOWN BUTTON_DOWN
 101
 102 #elif CONFIG_KEYPAD == IRIVER_H10_PAD
 103
 104 /* TODO: Check keyboard mappings */
 105
 106 #define KBD_SELECT BUTTON_REW
 107 #define KBD_ABORT BUTTON_FF
 108 #define KBD_LEFT BUTTON_LEFT
 109 #define KBD_RIGHT BUTTON_RIGHT
 110 #define KBD_UP BUTTON_SCROLL_UP
 111 #define KBD_DOWN BUTTON_SCROLL_DOWN
 112
 113 #elif (CONFIG_KEYPAD == SANSA_E200_PAD) || \
 114 (CONFIG_KEYPAD == SANSA_C200_PAD) || \
 115 (CONFIG_KEYPAD == MROBE100_PAD)
 116
 117 /* TODO: Check keyboard mappings */
 118
 119 #define KBD_SELECT BUTTON_SELECT
 120 #define KBD_ABORT BUTTON_POWER
 121 #define KBD_LEFT BUTTON_LEFT
 122 #define KBD_RIGHT BUTTON_RIGHT
 123 #define KBD_UP BUTTON_UP
 124 #define KBD_DOWN BUTTON_DOWN
 125
 126 #elif CONFIG_KEYPAD == IAUDIO_M3_PAD
 127
 128 #define KBD_SELECT BUTTON_RC_PLAY
 129 #define KBD_ABORT BUTTON_RC_REC
 130 #define KBD_LEFT BUTTON_RC_REW
 131 #define KBD_RIGHT BUTTON_RC_FF
 132 #define KBD_UP BUTTON_RC_VOL_UP
 133 #define KBD_DOWN BUTTON_RC_VOL_DOWN
 134
 135 #elif CONFIG_KEYPAD == COWOND2_PAD
 136
 137 #define KBD_ABORT BUTTON_POWER
 138
 139 #endif
 140
 141 #ifdef HAVE_TOUCHPAD
 142 #ifndef KBD_SELECT
 143 #define KBD_SELECT BUTTON_CENTER
 144 #endif
 145 #ifndef KBD_ABORT
 146 #define KBD_ABORT  BUTTON_TOPLEFT
 147 #endif
 148 #ifndef KBD_LEFT
 149 #define KBD_LEFT   BUTTON_MIDLEFT
 150 #endif
 151 #ifndef KBD_RIGHT
 152 #define KBD_RIGHT  BUTTON_MIDRIGHT
 153 #endif
 154 #ifndef KBD_UP
 155 #define KBD_UP     BUTTON_TOPMIDDLE
 156 #endif
 157 #ifndef KBD_DOWN
 158 #define KBD_DOWN   BUTTON_BOTTOMMIDDLE
 159 #endif
 160 #endif
 161
 162 struct keyboard_parameters {
 163     const unsigned char* default_kbd;
 164     int DEFAULT_LINES;
 165     unsigned short kbd_buf[KBD_BUF_SIZE];
 166     int nchars;
 167     int font_w;
 168     int font_h;
 169     struct font* font;
 170     int curfont;
 171     int main_x;
 172     int main_y;
 173     int max_chars;
 174     int max_chars_text;
 175     int lines;
 176     int pages;
 177     int keyboard_margin;
 178     int old_main_y;
 179     int curpos;
 180     int leftpos;
 181     int page;
 182     int x;
 183     int y;
 184 };
 185
 186 struct keyboard_parameters param[NB_SCREENS];
 187
 188 int zx_kbd_input(char* text/*, int buflen*/)
 189 {
 190     bool done = false;
 191     int i, j, k, w, l;
 192     int text_w = 0;
 193     int len_utf8/*, c = 0*/;
 194     int editpos;
 195 /*    int statusbar_size = global_settings.statusbar ? STATUSBAR_HEIGHT : 0;*/
 196     unsigned short ch/*, tmp, hlead = 0, hvowel = 0, htail = 0*/;
 197     /*bool hangul = false;*/
 198     unsigned char *utf8;
 199     const unsigned char *p;
 200     bool cur_blink = true;
 201     int char_screen = 0;
 202
 203     FOR_NB_SCREENS(l)
 204     {
 205              param[l].default_kbd =
 206                       "1234567890\n"
 207                       "qwertyuiop\n"
 208                       "asdfghjkl\n"
 209                       "zxcvbnm\n"
 210                       "S\n"
 211                       "E";
 212
 213              param[l].DEFAULT_LINES = 7;
 214     }
 215
 216     char outline[256];
 217     int button, lastbutton = 0;
 218     FOR_NB_SCREENS(l)
 219     {
 220             /* Copy default keyboard to buffer */
 221             i = 0;
 222             param[l].curfont = FONT_SYSFIXED;
 223             p = param[l].default_kbd;
 224             while (*p != 0)
 225                 p = rb->utf8decode(p, &param[l].kbd_buf[i++]);
 226             param[l].nchars = i;
 227 /*            param[l].curfont = FONT_UI;*/
 228     }
 229     FOR_NB_SCREENS(l)
 230     {
 231         param[l].font = rb->font_get(param[l].curfont);
 232         param[l].font_h = param[l].font->height;
 233
 234             /* check if FONT_UI fits the screen */
 235         if (2*param[l].font_h+3 + BUTTONBAR_HEIGHT > rb->screens[l]->height) {
 236             param[l].font = rb->font_get(FONT_SYSFIXED);
 237             param[l].font_h = param[l].font->height;
 238             param[l].curfont = FONT_SYSFIXED;
 239         }
 240
 241         rb->screens[l]->setfont(param[l].curfont);
 242         /* find max width of keyboard glyphs */
 243         for (i=0; i<param[l].nchars; i++) {
 244             w = rb->font_get_width(param[l].font, param[l].kbd_buf[i]);
 245             if (w > param[l].font_w)
 246                 param[l].font_w = w;
 247         }
 248         /* Since we're going to be adding spaces, make sure that we check
 249          * their width too */
 250         w = rb->font_get_width( param[l].font, ' ' );
 251         if( w > param[l].font_w )
 252             param[l].font_w = w;
 253     }
 254     FOR_NB_SCREENS(l)
 255     {
 256         i = 0;
 257         /* Pad lines with spaces */
 258         while( i < param[l].nchars )
 259         {
 260             if( param[l].kbd_buf[i] == '\n' )
 261             {
 262                 k = ( rb->screens[l]->width / param[l].font_w )
 263                         - i % ( rb->screens[l]->width / param[l].font_w ) - 1;
 264                 if( k == ( rb->screens[l]->width / param[l].font_w ) - 1 )
 265                 {
 266                     param[l].nchars--;
 267                     for( j = i; j < param[l].nchars; j++ )
 268                     {
 269                         param[l].kbd_buf[j] = param[l].kbd_buf[j+1];
 270                     }
 271                 }
 272                 else
 273                 {
 274                     if( param[l].nchars + k - 1 >= KBD_BUF_SIZE )
 275                     {   /* We don't want to overflow the buffer */
 276                         k = KBD_BUF_SIZE - param[l].nchars;
 277                     }
 278                     for( j = param[l].nchars + k - 1; j > i+k; j-- )
 279                     {
 280                         param[l].kbd_buf[j] = param[l].kbd_buf[j-k];
 281                     }
 282                     param[l].nchars += k;
 283                     k++;
 284                     while( k-- )
 285                     {
 286                         param[l].kbd_buf[i++] = ' ';
 287                     }
 288                 }
 289             }
 290             else
 291                 i++;
 292         }
 293     }
 294
 295     /* find max width for text string */
 296     utf8 = text;
 297     FOR_NB_SCREENS(l)
 298     {
 299         text_w = param[l].font_w;
 300         while (*utf8) {
 301             utf8 = (unsigned char*)rb->utf8decode(utf8, &ch);
 302             w = rb->font_get_width(param[l].font, ch);
 303             if (w > text_w)
 304                 text_w = w;
 305         }
 306         param[l].max_chars_text = rb->screens[l]->width / text_w - 2;
 307
 308     /* calculate keyboard grid size */
 309         param[l].max_chars = rb->screens[l]->width / param[l].font_w;
 310         if (!kbd_loaded) {
 311             param[l].lines = param[l].DEFAULT_LINES;
 312             param[l].keyboard_margin = DEFAULT_MARGIN;
 313         } else {
 314             param[l].lines = (rb->screens[l]->height - BUTTONBAR_HEIGHT - statusbar_size) / param[l].font_h - 1;
 315             param[l].keyboard_margin = rb->screens[l]->height - BUTTONBAR_HEIGHT -
 316                 statusbar_size - (param[l].lines+1)*param[l].font_h;
 317             if (param[l].keyboard_margin < 3) {
 318                 param[l].lines--;
 319                 param[l].keyboard_margin += param[l].font_h;
 320             }
 321             if (param[l].keyboard_margin > 6)
 322                 param[l].keyboard_margin = 6;
 323         }
 324
 325         param[l].pages = (param[l].nchars + (param[l].lines*param[l].max_chars-1))
 326              /(param[l].lines*param[l].max_chars);
 327         if (param[l].pages == 1 && kbd_loaded)
 328             param[l].lines = (param[l].nchars + param[l].max_chars - 1) / param[l].max_chars;
 329
 330         param[l].main_y = param[l].font_h*param[l].lines + param[l].keyboard_margin + statusbar_size;
 331         param[l].main_x = 0;
 332         param[l].keyboard_margin -= param[l].keyboard_margin/2;
 333
 334     }
 335     editpos = rb->utf8length(text);
 336
 337
 338
 339     while(!done)
 340     {
 341         len_utf8 = rb->utf8length(text);
 342         FOR_NB_SCREENS(l)
 343             rb->screens[l]->clear_display();
 344
 345
 346             /* draw page */
 347             FOR_NB_SCREENS(l)
 348             {
 349                 rb->screens[l]->setfont(param[l].curfont);
 350                 k = param[l].page*param[l].max_chars*param[l].lines;
 351                 for (i=j=0; j < param[l].lines && k < param[l].nchars; k++) {
 352                     utf8 = rb->utf8encode(param[l].kbd_buf[k], outline);
 353                     *utf8 = 0;
 354                     rb->screens[l]->getstringsize(outline, &w, NULL);
 355                     rb->screens[l]->putsxy(i*param[l].font_w + (param[l].font_w-w)/2, j*param[l].font_h
 356                           + statusbar_size, outline);
 357                     if (++i == param[l].max_chars) {
 358                         i = 0;
 359                         j++;
 360                     }
 361                 }
 362             }
 363
 364
 365         /* separator */
 366         FOR_NB_SCREENS(l)
 367         {
 368             rb->screens[l]->hline(0, rb->screens[l]->width - 1, param[l].main_y - param[l].keyboard_margin);
 369
 370         /* write out the text */
 371 #if 0
 372                         rb->screens[l]->setfont(param[l].curfont);
 373
 374             i=j=0;
 375             param[l].curpos = MIN(editpos, param[l].max_chars_text
 376                                 - MIN(len_utf8 - editpos, 2));
 377             param[l].leftpos = editpos - param[l].curpos;
 378             utf8 = text + rb->utf8seek(text, param[l].leftpos);
 379
 380             text_w = param[l].font_w;
 381             while (*utf8 && i < param[l].max_chars_text) {
 382                 outline[j++] = *utf8++;
 383                 if ((*utf8 & MASK) != COMP) {
 384                     outline[j] = 0;
 385                     j=0;
 386                     i++;
 387                     rb->screens[l]->getstringsize(outline, &w, NULL);
 388                     rb->screens[l]->putsxy(i*text_w + (text_w-w)/2, param[l].main_y, outline);
 389                 }
 390             }
 391
 392             if (param[l].leftpos) {
 393                 rb->screens[l]->getstringsize("<", &w, NULL);
 394                 rb->screens[l]->putsxy(text_w - w, param[l].main_y, "<");
 395             }
 396             if (len_utf8 - param[l].leftpos > param[l].max_chars_text)
 397                 rb->screens[l]->putsxy(rb->screens[l]->width - text_w, param[l].main_y, ">");
 398
 399             /* cursor */
 400             i = (param[l].curpos + 1) * text_w;
 401             if (cur_blink)
 402                 rb->screens[l]->vline(i, param[l].main_y, param[l].main_y + param[l].font_h-1);
 403
 404             if (hangul) /* draw underbar */
 405                 rb->screens[l]->hline(param[l].curpos*text_w, (param[l].curpos+1)*text_w,
 406                                        param[l].main_y+param[l].font_h-1);
 407 #endif
 408                 }
 409         cur_blink = !cur_blink;
 410
 411
 412             /* highlight the key that has focus */
 413             FOR_NB_SCREENS(l)
 414             {
 415                 rb->screens[l]->set_drawmode(DRMODE_COMPLEMENT);
 416                 rb->screens[l]->fillrect(param[l].font_w * param[l].x,
 417                                         statusbar_size + param[l].font_h * param[l].y,
 418                                         param[l].font_w, param[l].font_h);
 419                 rb->screens[l]->set_drawmode(DRMODE_SOLID);
 420             }
 421
 422
 423 /*        gui_syncstatusbar_draw(&statusbars, true);*/
 424         FOR_NB_SCREENS(l)
 425         rb->screens[l]->update();
 426
 427         button = rb->button_get_w_tmo(HZ/2);
 428
 429         switch ( button ) {
 430
 431             case KBD_ABORT:
 432                 FOR_NB_SCREENS(l)
 433                     rb->screens[l]->setfont(FONT_UI);
 434
 435                 return -1;
 436                 break;
 437
 438             case KBD_RIGHT:
 439             case KBD_RIGHT | BUTTON_REPEAT:
 440                 {
 441                     FOR_NB_SCREENS(l)
 442                     {
 443                         if (++param[l].x == param[l].max_chars) {
 444                             param[l].x = 0;
 445                         /* no dedicated flip key - flip page on wrap */
 446                             if (++param[l].page == param[l].pages)
 447                                 param[l].page = 0;
 448                         }
 449                         k = (param[l].page*param[l].lines + param[l].y)*param[l].max_chars + param[l].x;
 450                         /*kbd_spellchar(param[l].kbd_buf[k]);*/
 451                     }
 452                 }
 453                 break;
 454             case KBD_LEFT:
 455             case KBD_LEFT | BUTTON_REPEAT:
 456                 {
 457                     FOR_NB_SCREENS(l)
 458                     {
 459                         if (param[l].x)
 460                             param[l].x--;
 461                         else
 462                         {
 463                         /* no dedicated flip key - flip page on wrap */
 464                             if (--param[l].page < 0)
 465                                 param[l].page = (param[l].pages-1);
 466                             param[l].x = param[l].max_chars - 1;
 467                         }
 468                         k = (param[l].page*param[l].lines +
 469                             param[l].y)*param[l].max_chars + param[l].x;
 470                        /* kbd_spellchar(param[l].kbd_buf[k]);*/
 471                     }
 472                 }
 473                 break;
 474
 475             case KBD_DOWN:
 476             case KBD_DOWN | BUTTON_REPEAT:
 477                 {
 478                     FOR_NB_SCREENS(l)
 479                     {
 480                         if (param[l].y < param[l].lines - 1)
 481                             param[l].y++;
 482                         else
 483                             param[l].y=0;
 484                     }
 485                     FOR_NB_SCREENS(l)
 486                     {
 487                         k = (param[l].page*param[l].lines + param[l].y)*
 488                                  param[l].max_chars + param[l].x;
 489                         /*kbd_spellchar(param[l].kbd_buf[k]);*/
 490                     }
 491                 }
 492                 break;
 493
 494             case KBD_UP:
 495             case KBD_UP | BUTTON_REPEAT:
 496                 {
 497                     FOR_NB_SCREENS(l)
 498                     {
 499                         if (param[l].y)
 500                             param[l].y--;
 501                         else
 502                             param[l].y = param[l].lines - 1;
 503                     }
 504                     FOR_NB_SCREENS(l)
 505                     {
 506                         k = (param[l].page*param[l].lines + param[l].y)*
 507                                param[l].max_chars + param[l].x;
 508                         /*kbd_spellchar(param[l].kbd_buf[k]);*/
 509                     }
 510                 }
 511                 break;
 512
 513             case KBD_SELECT:
 514             {
 515                 if (button == KBD_SELECT)
 516                     char_screen = 0;
 517
 518                 /* inserts the selected char */
 519
 520                     /* find input char */
 521                         k = (param[char_screen].page*param[char_screen].lines +
 522                             param[char_screen].y)*param[char_screen].max_chars +
 523                             param[char_screen].x;
 524                         if (k < param[char_screen].nchars)
 525                             ch = param[char_screen].kbd_buf[k];
 526                         else
 527                             ch = ' ';
 528                         text[0]=ch;
 529                         done = true;
 530             }
 531                 break;
 532
 533             case BUTTON_NONE:
 534                 /*gui_syncstatusbar_draw(&statusbars, false);*/
 535
 536                 break;
 537
 538             default:
 539                 if(rb->default_event_handler(button) == SYS_USB_CONNECTED)
 540                     FOR_NB_SCREENS(l)
 541                         rb->screens[l]->setfont(FONT_SYSFIXED);
 542                 break;
 543
 544         }
 545         if (button != BUTTON_NONE)
 546         {
 547             lastbutton = button;
 548             cur_blink = true;
 549         }
 550     }
 551     FOR_NB_SCREENS(l)
 552         rb->screens[l]->setfont(FONT_UI);
 553     return 0;
 554 }