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 == IRIVER_H10_PAD
  94
  95 /* TODO: Check keyboard mappings */
  96
  97 #define KBD_SELECT BUTTON_REW
  98 #define KBD_ABORT BUTTON_FF
  99 #define KBD_LEFT BUTTON_LEFT
 100 #define KBD_RIGHT BUTTON_RIGHT
 101 #define KBD_UP BUTTON_SCROLL_UP
 102 #define KBD_DOWN BUTTON_SCROLL_DOWN
 103
 104 #elif (CONFIG_KEYPAD == SANSA_E200_PAD) || \
 105 (CONFIG_KEYPAD == SANSA_C200_PAD)
 106
 107 /* TODO: Check keyboard mappings */
 108
 109 #define KBD_SELECT BUTTON_SELECT
 110 #define KBD_ABORT BUTTON_POWER
 111 #define KBD_LEFT BUTTON_LEFT
 112 #define KBD_RIGHT BUTTON_RIGHT
 113 #define KBD_UP BUTTON_UP
 114 #define KBD_DOWN BUTTON_DOWN
 115
 116 #endif
 117
 118
 119 struct keyboard_parameters {
 120     const unsigned char* default_kbd;
 121     int DEFAULT_LINES;
 122     unsigned short kbd_buf[KBD_BUF_SIZE];
 123     int nchars;
 124     int font_w;
 125     int font_h;
 126     struct font* font;
 127     int curfont;
 128     int main_x;
 129     int main_y;
 130     int max_chars;
 131     int max_chars_text;
 132     int lines;
 133     int pages;
 134     int keyboard_margin;
 135     int old_main_y;
 136     int curpos;
 137     int leftpos;
 138     int page;
 139     int x;
 140     int y;
 141 };
 142
 143 struct keyboard_parameters param[NB_SCREENS];
 144
 145 int zx_kbd_input(char* text/*, int buflen*/)
 146 {
 147     bool done = false;
 148     int i, j, k, w, l;
 149     int text_w = 0;
 150     int len_utf8/*, c = 0*/;
 151     int editpos;
 152 /*    int statusbar_size = global_settings.statusbar ? STATUSBAR_HEIGHT : 0;*/
 153     unsigned short ch/*, tmp, hlead = 0, hvowel = 0, htail = 0*/;
 154     /*bool hangul = false;*/
 155     unsigned char *utf8;
 156     const unsigned char *p;
 157     bool cur_blink = true;
 158     int char_screen = 0;
 159
 160     FOR_NB_SCREENS(l)
 161     {
 162              param[l].default_kbd =
 163                       "1234567890\n"
 164                       "qwertyuiop\n"
 165                       "asdfghjkl\n"
 166                       "zxcvbnm\n"
 167                       "S\n"
 168                       "E";
 169
 170              param[l].DEFAULT_LINES = 7;
 171     }
 172
 173     char outline[256];
 174     int button, lastbutton = 0;
 175     FOR_NB_SCREENS(l)
 176     {
 177             /* Copy default keyboard to buffer */
 178             i = 0;
 179             param[l].curfont = FONT_SYSFIXED;
 180             p = param[l].default_kbd;
 181             while (*p != 0)
 182                 p = rb->utf8decode(p, &param[l].kbd_buf[i++]);
 183             param[l].nchars = i;
 184 /*            param[l].curfont = FONT_UI;*/
 185     }
 186     FOR_NB_SCREENS(l)
 187     {
 188         param[l].font = rb->font_get(param[l].curfont);
 189         param[l].font_h = param[l].font->height;
 190
 191             /* check if FONT_UI fits the screen */
 192         if (2*param[l].font_h+3 + BUTTONBAR_HEIGHT > rb->screens[l]->height) {
 193             param[l].font = rb->font_get(FONT_SYSFIXED);
 194             param[l].font_h = param[l].font->height;
 195             param[l].curfont = FONT_SYSFIXED;
 196         }
 197
 198         rb->screens[l]->setfont(param[l].curfont);
 199         /* find max width of keyboard glyphs */
 200         for (i=0; i<param[l].nchars; i++) {
 201             w = rb->font_get_width(param[l].font, param[l].kbd_buf[i]);
 202             if (w > param[l].font_w)
 203                 param[l].font_w = w;
 204         }
 205         /* Since we're going to be adding spaces, make sure that we check
 206          * their width too */
 207         w = rb->font_get_width( param[l].font, ' ' );
 208         if( w > param[l].font_w )
 209             param[l].font_w = w;
 210     }
 211     FOR_NB_SCREENS(l)
 212     {
 213         i = 0;
 214         /* Pad lines with spaces */
 215         while( i < param[l].nchars )
 216         {
 217             if( param[l].kbd_buf[i] == '\n' )
 218             {
 219                 k = ( rb->screens[l]->width / param[l].font_w )
 220                         - i % ( rb->screens[l]->width / param[l].font_w ) - 1;
 221                 if( k == ( rb->screens[l]->width / param[l].font_w ) - 1 )
 222                 {
 223                     param[l].nchars--;
 224                     for( j = i; j < param[l].nchars; j++ )
 225                     {
 226                         param[l].kbd_buf[j] = param[l].kbd_buf[j+1];
 227                     }
 228                 }
 229                 else
 230                 {
 231                     if( param[l].nchars + k - 1 >= KBD_BUF_SIZE )
 232                     {   /* We don't want to overflow the buffer */
 233                         k = KBD_BUF_SIZE - param[l].nchars;
 234                     }
 235                     for( j = param[l].nchars + k - 1; j > i+k; j-- )
 236                     {
 237                         param[l].kbd_buf[j] = param[l].kbd_buf[j-k];
 238                     }
 239                     param[l].nchars += k;
 240                     k++;
 241                     while( k-- )
 242                     {
 243                         param[l].kbd_buf[i++] = ' ';
 244                     }
 245                 }
 246             }
 247             else
 248                 i++;
 249         }
 250     }
 251
 252     /* find max width for text string */
 253     utf8 = text;
 254     FOR_NB_SCREENS(l)
 255     {
 256         text_w = param[l].font_w;
 257         while (*utf8) {
 258             utf8 = (unsigned char*)rb->utf8decode(utf8, &ch);
 259             w = rb->font_get_width(param[l].font, ch);
 260             if (w > text_w)
 261                 text_w = w;
 262         }
 263         param[l].max_chars_text = rb->screens[l]->width / text_w - 2;
 264
 265     /* calculate keyboard grid size */
 266         param[l].max_chars = rb->screens[l]->width / param[l].font_w;
 267         if (!kbd_loaded) {
 268             param[l].lines = param[l].DEFAULT_LINES;
 269             param[l].keyboard_margin = DEFAULT_MARGIN;
 270         } else {
 271             param[l].lines = (rb->screens[l]->height - BUTTONBAR_HEIGHT - statusbar_size) / param[l].font_h - 1;
 272             param[l].keyboard_margin = rb->screens[l]->height - BUTTONBAR_HEIGHT -
 273                 statusbar_size - (param[l].lines+1)*param[l].font_h;
 274             if (param[l].keyboard_margin < 3) {
 275                 param[l].lines--;
 276                 param[l].keyboard_margin += param[l].font_h;
 277             }
 278             if (param[l].keyboard_margin > 6)
 279                 param[l].keyboard_margin = 6;
 280         }
 281
 282         param[l].pages = (param[l].nchars + (param[l].lines*param[l].max_chars-1))
 283              /(param[l].lines*param[l].max_chars);
 284         if (param[l].pages == 1 && kbd_loaded)
 285             param[l].lines = (param[l].nchars + param[l].max_chars - 1) / param[l].max_chars;
 286
 287         param[l].main_y = param[l].font_h*param[l].lines + param[l].keyboard_margin + statusbar_size;
 288         param[l].main_x = 0;
 289         param[l].keyboard_margin -= param[l].keyboard_margin/2;
 290
 291     }
 292     editpos = rb->utf8length(text);
 293
 294
 295
 296     while(!done)
 297     {
 298         len_utf8 = rb->utf8length(text);
 299         FOR_NB_SCREENS(l)
 300             rb->screens[l]->clear_display();
 301
 302
 303             /* draw page */
 304             FOR_NB_SCREENS(l)
 305             {
 306                 rb->screens[l]->setfont(param[l].curfont);
 307                 k = param[l].page*param[l].max_chars*param[l].lines;
 308                 for (i=j=0; j < param[l].lines && k < param[l].nchars; k++) {
 309                     utf8 = rb->utf8encode(param[l].kbd_buf[k], outline);
 310                     *utf8 = 0;
 311                     rb->screens[l]->getstringsize(outline, &w, NULL);
 312                     rb->screens[l]->putsxy(i*param[l].font_w + (param[l].font_w-w)/2, j*param[l].font_h
 313                           + statusbar_size, outline);
 314                     if (++i == param[l].max_chars) {
 315                         i = 0;
 316                         j++;
 317                     }
 318                 }
 319             }
 320
 321
 322         /* separator */
 323         FOR_NB_SCREENS(l)
 324         {
 325             rb->screens[l]->hline(0, rb->screens[l]->width - 1, param[l].main_y - param[l].keyboard_margin);
 326
 327         /* write out the text */
 328 #if 0
 329                         rb->screens[l]->setfont(param[l].curfont);
 330
 331             i=j=0;
 332             param[l].curpos = MIN(editpos, param[l].max_chars_text
 333                                 - MIN(len_utf8 - editpos, 2));
 334             param[l].leftpos = editpos - param[l].curpos;
 335             utf8 = text + rb->utf8seek(text, param[l].leftpos);
 336
 337             text_w = param[l].font_w;
 338             while (*utf8 && i < param[l].max_chars_text) {
 339                 outline[j++] = *utf8++;
 340                 if ((*utf8 & MASK) != COMP) {
 341                     outline[j] = 0;
 342                     j=0;
 343                     i++;
 344                     rb->screens[l]->getstringsize(outline, &w, NULL);
 345                     rb->screens[l]->putsxy(i*text_w + (text_w-w)/2, param[l].main_y, outline);
 346                 }
 347             }
 348
 349             if (param[l].leftpos) {
 350                 rb->screens[l]->getstringsize("<", &w, NULL);
 351                 rb->screens[l]->putsxy(text_w - w, param[l].main_y, "<");
 352             }
 353             if (len_utf8 - param[l].leftpos > param[l].max_chars_text)
 354                 rb->screens[l]->putsxy(rb->screens[l]->width - text_w, param[l].main_y, ">");
 355
 356             /* cursor */
 357             i = (param[l].curpos + 1) * text_w;
 358             if (cur_blink)
 359                 rb->screens[l]->vline(i, param[l].main_y, param[l].main_y + param[l].font_h-1);
 360
 361             if (hangul) /* draw underbar */
 362                 rb->screens[l]->hline(param[l].curpos*text_w, (param[l].curpos+1)*text_w,
 363                                        param[l].main_y+param[l].font_h-1);
 364 #endif
 365                 }
 366         cur_blink = !cur_blink;
 367
 368
 369             /* highlight the key that has focus */
 370             FOR_NB_SCREENS(l)
 371             {
 372                 rb->screens[l]->set_drawmode(DRMODE_COMPLEMENT);
 373                 rb->screens[l]->fillrect(param[l].font_w * param[l].x,
 374                                         statusbar_size + param[l].font_h * param[l].y,
 375                                         param[l].font_w, param[l].font_h);
 376                 rb->screens[l]->set_drawmode(DRMODE_SOLID);
 377             }
 378
 379
 380 /*        gui_syncstatusbar_draw(&statusbars, true);*/
 381         FOR_NB_SCREENS(l)
 382         rb->screens[l]->update();
 383
 384         button = rb->button_get_w_tmo(HZ/2);
 385
 386         switch ( button ) {
 387
 388             case KBD_ABORT:
 389                 FOR_NB_SCREENS(l)
 390                     rb->screens[l]->setfont(FONT_UI);
 391
 392                 return -1;
 393                 break;
 394
 395             case KBD_RIGHT:
 396             case KBD_RIGHT | BUTTON_REPEAT:
 397                 {
 398                     FOR_NB_SCREENS(l)
 399                     {
 400                         if (++param[l].x == param[l].max_chars) {
 401                             param[l].x = 0;
 402                         /* no dedicated flip key - flip page on wrap */
 403                             if (++param[l].page == param[l].pages)
 404                                 param[l].page = 0;
 405                         }
 406                         k = (param[l].page*param[l].lines + param[l].y)*param[l].max_chars + param[l].x;
 407                         /*kbd_spellchar(param[l].kbd_buf[k]);*/
 408                     }
 409                 }
 410                 break;
 411             case KBD_LEFT:
 412             case KBD_LEFT | BUTTON_REPEAT:
 413                 {
 414                     FOR_NB_SCREENS(l)
 415                     {
 416                         if (param[l].x)
 417                             param[l].x--;
 418                         else
 419                         {
 420                         /* no dedicated flip key - flip page on wrap */
 421                             if (--param[l].page < 0)
 422                                 param[l].page = (param[l].pages-1);
 423                             param[l].x = param[l].max_chars - 1;
 424                         }
 425                         k = (param[l].page*param[l].lines +
 426                             param[l].y)*param[l].max_chars + param[l].x;
 427                        /* kbd_spellchar(param[l].kbd_buf[k]);*/
 428                     }
 429                 }
 430                 break;
 431
 432             case KBD_DOWN:
 433             case KBD_DOWN | BUTTON_REPEAT:
 434                 {
 435                     FOR_NB_SCREENS(l)
 436                     {
 437                         if (param[l].y < param[l].lines - 1)
 438                             param[l].y++;
 439                         else
 440                             param[l].y=0;
 441                     }
 442                     FOR_NB_SCREENS(l)
 443                     {
 444                         k = (param[l].page*param[l].lines + param[l].y)*
 445                                  param[l].max_chars + param[l].x;
 446                         /*kbd_spellchar(param[l].kbd_buf[k]);*/
 447                     }
 448                 }
 449                 break;
 450
 451             case KBD_UP:
 452             case KBD_UP | BUTTON_REPEAT:
 453                 {
 454                     FOR_NB_SCREENS(l)
 455                     {
 456                         if (param[l].y)
 457                             param[l].y--;
 458                         else
 459                             param[l].y = param[l].lines - 1;
 460                     }
 461                     FOR_NB_SCREENS(l)
 462                     {
 463                         k = (param[l].page*param[l].lines + param[l].y)*
 464                                param[l].max_chars + param[l].x;
 465                         /*kbd_spellchar(param[l].kbd_buf[k]);*/
 466                     }
 467                 }
 468                 break;
 469
 470             case KBD_SELECT:
 471             {
 472                 if (button == KBD_SELECT)
 473                     char_screen = 0;
 474
 475                 /* inserts the selected char */
 476
 477                     /* find input char */
 478                         k = (param[char_screen].page*param[char_screen].lines +
 479                             param[char_screen].y)*param[char_screen].max_chars +
 480                             param[char_screen].x;
 481                         if (k < param[char_screen].nchars)
 482                             ch = param[char_screen].kbd_buf[k];
 483                         else
 484                             ch = ' ';
 485                         text[0]=ch;
 486                         done = true;
 487             }
 488                 break;
 489
 490             case BUTTON_NONE:
 491                 /*gui_syncstatusbar_draw(&statusbars, false);*/
 492
 493                 break;
 494
 495             default:
 496                 if(rb->default_event_handler(button) == SYS_USB_CONNECTED)
 497                     FOR_NB_SCREENS(l)
 498                         rb->screens[l]->setfont(FONT_SYSFIXED);
 499                 break;
 500
 501         }
 502         if (button != BUTTON_NONE)
 503         {
 504             lastbutton = button;
 505             cur_blink = true;
 506         }
 507     }
 508     FOR_NB_SCREENS(l)
 509         rb->screens[l]->setfont(FONT_UI);
 510     return 0;
 511 }