firmware/drivers/lcd-charcell.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2007 by Jens Arnold
  11  * Based on the work of Alan Korr, Kjell Ericson and others
  12  *
  13  * This program is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU General Public License
  15  * as published by the Free Software Foundation; either version 2
  16  * of the License, or (at your option) any later version.
  17  *
  18  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19  * KIND, either express or implied.
  20  *
  21  ****************************************************************************/
  22 #include "config.h"
  23 #include "hwcompat.h"
  24 #include "stdarg.h"
  25 #include "sprintf.h"
  26 #include "lcd.h"
  27 #include "kernel.h"
  28 #include "thread.h"
  29 #include <string.h>
  30 #include <stdlib.h>
  31 #include "file.h"
  32 #include "system.h"
  33 #include "lcd-charcell.h"
  34 #include "rbunicode.h"
  35 #include "scroll_engine.h"
  36
  37 /** definitions **/
  38
  39 #define VARIABLE_XCHARS 16 /* number of software user-definable characters */
  40 /* There must be mappings for this many characters in the 0xe000 unicode range
  41  * in lcd-charset-<target>.c */
  42
  43 #define NO_PATTERN (-1)
  44
  45 static int find_xchar(unsigned long ucs);
  46
  47 /** globals **/
  48
  49 unsigned char lcd_charbuffer[LCD_HEIGHT][LCD_WIDTH];  /* The "frame"buffer */
  50 static unsigned char lcd_substbuffer[LCD_HEIGHT][LCD_WIDTH];
  51 struct pattern_info lcd_patterns[MAX_HW_PATTERNS];
  52 struct cursor_info lcd_cursor;
  53
  54 static unsigned char xfont_variable[VARIABLE_XCHARS][HW_PATTERN_SIZE];
  55 static bool xfont_variable_locked[VARIABLE_XCHARS];
  56 static int xspace; /* stores xhcar id of ' ' - often needed */
  57
  58 static struct viewport default_vp =
  59   {
  60     .x        = 0,
  61     .y        = 0,
  62     .width    = LCD_WIDTH,
  63     .height   = LCD_HEIGHT,
  64   };
  65
  66 static struct viewport* current_vp = &default_vp;
  67
  68 /* LCD init */
  69 void lcd_init (void)
  70 {
  71     lcd_init_device();
  72     lcd_charset_init();
  73     memset(lcd_patterns, 0, sizeof(lcd_patterns));
  74     xspace = find_xchar(' ');
  75     memset(lcd_charbuffer, xchar_info[xspace].hw_char, sizeof(lcd_charbuffer));
  76     scroll_init();
  77 }
  78
  79 /* Viewports */
  80
  81 void lcd_set_viewport(struct viewport* vp)
  82 {
  83     if (vp == NULL)
  84         current_vp = &default_vp;
  85     else
  86         current_vp = vp;
  87 }
  88
  89 void lcd_update_viewport(void)
  90 {
  91     lcd_update();
  92 }
  93
  94 /** parameter handling **/
  95
  96 int lcd_getwidth(void)
  97 {
  98     return current_vp->width;
  99 }
 100
 101 int lcd_getheight(void)
 102 {
 103     return current_vp->height;
 104 }
 105
 106 int lcd_getstringsize(const unsigned char *str, int *w, int *h)
 107 {
 108     int width = utf8length(str);
 109
 110     if (w)
 111         *w = width;
 112     if (h)
 113         *h = 1;
 114
 115     return width;
 116 }
 117
 118 /** low-level functions **/
 119
 120 static int find_xchar(unsigned long ucs)
 121 {
 122     int low = 0;
 123     int high = xchar_info_size - 1;
 124
 125     do
 126     {
 127         int probe = (low + high) >> 1;
 128
 129         if (xchar_info[probe].ucs < ucs)
 130             low = probe + 1;
 131         else if (xchar_info[probe].ucs > ucs)
 132             high = probe - 1;
 133         else
 134             return probe;
 135     }
 136     while (low <= high);
 137
 138     /* Not found: return index of no-char symbol (last symbol, hardcoded). */
 139     return xchar_info_size - 1;
 140 }
 141
 142 static int glyph_to_pat(unsigned glyph)
 143 {
 144     int i;
 145
 146     for (i = 0; i < lcd_pattern_count; i++)
 147         if (lcd_patterns[i].glyph == glyph)
 148             return i;
 149
 150     return NO_PATTERN;
 151 }
 152
 153 static void lcd_free_pat(int pat)
 154 {
 155     int x, y;
 156
 157     if (pat != NO_PATTERN)
 158     {
 159         for (x = 0; x < LCD_WIDTH; x++)
 160             for (y = 0; y < LCD_HEIGHT; y++)
 161                 if (pat == lcd_charbuffer[y][x])
 162                     lcd_charbuffer[y][x] = lcd_substbuffer[y][x];
 163
 164         if (lcd_cursor.enabled && pat == lcd_cursor.hw_char)
 165             lcd_cursor.hw_char = lcd_cursor.subst_char;
 166
 167         lcd_patterns[pat].count = 0;
 168     }
 169 }
 170
 171 static int lcd_get_free_pat(int xchar)
 172 {
 173     static int last_used_pat = 0;
 174
 175     int pat = last_used_pat; /* start from last used pattern */
 176     int least_pat = pat;     /* pattern with least priority */
 177     int least_priority = lcd_patterns[pat].priority;
 178     int i;
 179
 180     for (i = 0; i < lcd_pattern_count; i++)
 181     {
 182         if (++pat >= lcd_pattern_count)  /* Keep 'pat' within limits */
 183             pat = 0;
 184
 185         if (lcd_patterns[pat].count == 0)
 186         {
 187             last_used_pat = pat;
 188             return pat;
 189         }
 190         if (lcd_patterns[pat].priority < least_priority)
 191         {
 192             least_priority = lcd_patterns[pat].priority;
 193             least_pat = pat;
 194         }
 195     }
 196     if (xchar_info[xchar].priority > least_priority) /* prioritized char */
 197     {
 198         lcd_free_pat(least_pat);
 199         last_used_pat = least_pat;
 200         return least_pat;
 201     }
 202     return NO_PATTERN;
 203 }
 204
 205 static const unsigned char *glyph_to_pattern(unsigned glyph)
 206 {
 207     if (glyph & 0x8000)
 208         return xfont_variable[glyph & 0x7fff];
 209     else
 210         return xfont_fixed[glyph];
 211 }
 212
 213 static int map_xchar(int xchar, unsigned char *substitute)
 214 {
 215     int pat;
 216     unsigned glyph;
 217
 218     if (xchar_info[xchar].priority > 0)      /* soft char */
 219     {
 220         glyph = xchar_info[xchar].glyph;
 221         pat = glyph_to_pat(glyph);
 222
 223         if (pat == NO_PATTERN)               /* not yet mapped */
 224         {
 225             pat = lcd_get_free_pat(xchar);   /* try to map */
 226
 227             if (pat == NO_PATTERN)           /* failed: just use substitute */
 228                 return xchar_info[xchar].hw_char;
 229             else
 230             {                            /* define pattern */
 231                 lcd_patterns[pat].priority = xchar_info[xchar].priority;
 232                 lcd_patterns[pat].glyph = glyph;
 233                 memcpy(lcd_patterns[pat].pattern, glyph_to_pattern(glyph),
 234                        HW_PATTERN_SIZE);
 235             }
 236         }
 237         lcd_patterns[pat].count++;           /* increase reference count */
 238         *substitute = xchar_info[xchar].hw_char;
 239         return pat;
 240     }
 241     else                                     /* hardware char */
 242         return xchar_info[xchar].hw_char;
 243 }
 244
 245 static void lcd_putxchar(int x, int y, int xchar)
 246 {
 247     int lcd_char;
 248
 249     /* Adjust for viewport */
 250     x += current_vp->x;
 251     y += current_vp->y;
 252
 253     lcd_char  = lcd_charbuffer[y][x];
 254
 255     if (lcd_char < lcd_pattern_count)        /* old char was soft */
 256         lcd_patterns[lcd_char].count--;      /* decrease old reference count */
 257
 258     lcd_charbuffer[y][x] = map_xchar(xchar, &lcd_substbuffer[y][x]);
 259 }
 260
 261 /** user-definable pattern handling **/
 262
 263 unsigned long lcd_get_locked_pattern(void)
 264 {
 265     int i = 0;
 266
 267     for (i = 0; i < VARIABLE_XCHARS; i++)
 268     {
 269         if (!xfont_variable_locked[i])
 270         {
 271             xfont_variable_locked[i] = true;
 272             return 0xe000 + i;  /* hard-coded */
 273         }
 274     }
 275     return 0;
 276 }
 277
 278 void lcd_unlock_pattern(unsigned long ucs)
 279 {
 280     int xchar = find_xchar(ucs);
 281     unsigned glyph = xchar_info[xchar].glyph;
 282
 283     if (glyph & 0x8000) /* variable extended char */
 284     {
 285         lcd_free_pat(glyph_to_pat(glyph));
 286         xfont_variable_locked[glyph & 0x7fff] = false;
 287     }
 288 }
 289
 290 void lcd_define_pattern(unsigned long ucs, const char *pattern)
 291 {
 292     int xchar = find_xchar(ucs);
 293     unsigned glyph = xchar_info[xchar].glyph;
 294     int pat;
 295
 296     if (glyph & 0x8000) /* variable extended char */
 297     {
 298         memcpy(xfont_variable[glyph & 0x7fff], pattern, HW_PATTERN_SIZE);
 299         pat = glyph_to_pat(glyph);
 300         if (pat != NO_PATTERN)
 301             memcpy(lcd_patterns[pat].pattern, pattern, HW_PATTERN_SIZE);
 302     }
 303 }
 304
 305 /** output functions **/
 306
 307 /* Clear the whole display */
 308 void lcd_clear_display(void)
 309 {
 310     int x, y;
 311     struct viewport* old_vp = current_vp;
 312
 313     lcd_scroll_info.lines = 0;
 314     lcd_remove_cursor();
 315
 316     /* Set the default viewport - required for lcd_putxchar */
 317     current_vp = &default_vp;
 318
 319     for (x = 0; x < LCD_WIDTH; x++)
 320         for (y = 0; y < LCD_HEIGHT; y++)
 321             lcd_putxchar(x, y, xspace);
 322
 323     current_vp = old_vp;
 324 }
 325
 326 /* Clear the current viewport */
 327 void lcd_clear_viewport(void)
 328 {
 329     int x, y;
 330
 331     if (current_vp == &default_vp)
 332     {
 333         lcd_clear_display();
 334     }
 335     else
 336     {
 337         /* Remove the cursor if it is within the current viewport */
 338         if (lcd_cursor.enabled &&
 339             (lcd_cursor.x >= current_vp->x) &&
 340             (lcd_cursor.x <= current_vp->x + current_vp->width) &&
 341             (lcd_cursor.y >= current_vp->y) &&
 342             (lcd_cursor.y <= current_vp->y + current_vp->height))
 343         {
 344             lcd_remove_cursor();
 345         }
 346
 347         for (x = 0; x < current_vp->width; x++)
 348             for (y = 0; y < current_vp->height; y++)
 349                 lcd_putxchar(x, y, xspace);
 350
 351         lcd_scroll_stop(current_vp);
 352     }
 353 }
 354
 355 /* Put an unicode character at the given position */
 356 void lcd_putc(int x, int y, unsigned long ucs)
 357 {
 358     if ((unsigned)x >= (unsigned)current_vp->width ||
 359         (unsigned)y >= (unsigned)current_vp->height)
 360         return;
 361
 362     lcd_putxchar(x, y, find_xchar(ucs));
 363 }
 364
 365 /* Show cursor (alternating with existing character) at the given position */
 366 void lcd_put_cursor(int x, int y, unsigned long cursor_ucs)
 367 {
 368     if ((unsigned)x >= (unsigned)current_vp->width ||
 369         (unsigned)y >= (unsigned)current_vp->height ||
 370         lcd_cursor.enabled)
 371         return;
 372
 373     lcd_cursor.enabled = true;
 374     lcd_cursor.visible = false;
 375     lcd_cursor.hw_char = map_xchar(find_xchar(cursor_ucs), &lcd_cursor.subst_char);
 376     lcd_cursor.x = current_vp->x + x;
 377     lcd_cursor.y = current_vp->y + y;
 378     lcd_cursor.downcount = 0;
 379     lcd_cursor.divider = MAX((HZ/2) / lcd_scroll_info.ticks, 1);
 380 }
 381
 382 /* Remove the cursor */
 383 void lcd_remove_cursor(void)
 384 {
 385     if (lcd_cursor.enabled)
 386     {
 387         if (lcd_cursor.hw_char < lcd_pattern_count)  /* soft char, unmap */
 388             lcd_patterns[lcd_cursor.hw_char].count--;
 389
 390         lcd_cursor.enabled = lcd_cursor.visible = false;
 391     }
 392 }
 393
 394 /* Put a string at a given position, skipping first ofs chars */
 395 static int lcd_putsxyofs(int x, int y, int ofs, const unsigned char *str)
 396 {
 397     unsigned short ucs;
 398     const unsigned char *utf8 = str;
 399
 400     while (*utf8 && x < current_vp->width)
 401     {
 402         utf8 = utf8decode(utf8, &ucs);
 403
 404         if (ofs > 0)
 405         {
 406             ofs--;
 407             continue;
 408         }
 409         lcd_putxchar(x++, y, find_xchar(ucs));
 410     }
 411     return x;
 412 }
 413
 414 /* Put a string at a given position */
 415 void lcd_putsxy(int x, int y, const unsigned char *str)
 416 {
 417     if ((unsigned)y >= (unsigned)current_vp->height)
 418         return;
 419
 420     lcd_putsxyofs(x, y, 0, str);
 421 }
 422
 423 /*** Line oriented text output ***/
 424
 425 /* Put a string at a given char position */
 426 void lcd_puts(int x, int y, const unsigned char *str)
 427 {
 428     lcd_puts_offset(x, y, str, 0);
 429 }
 430
 431 /* Formatting version of lcd_puts */
 432 void lcd_putsf(int x, int y, const unsigned char *fmt, ...)
 433 {
 434     va_list ap;
 435     char buf[256];
 436     va_start(ap, fmt);
 437     vsnprintf(buf, sizeof (buf), fmt, ap);
 438     va_end(ap);
 439     lcd_puts(x, y, buf);
 440 }
 441
 442 /* Put a string at a given char position,  skipping first offset chars */
 443 void lcd_puts_offset(int x, int y, const unsigned char *str, int offset)
 444 {
 445     if ((unsigned)y >= (unsigned)current_vp->height)
 446         return;
 447
 448     /* make sure scrolling is turned off on the line we are updating */
 449     lcd_scroll_stop_line(current_vp, y);
 450
 451     x = lcd_putsxyofs(x, y, offset, str);
 452     while (x < current_vp->width)
 453         lcd_putxchar(x++, y, xspace);
 454 }
 455
 456 /** scrolling **/
 457 void lcd_puts_scroll(int x, int y, const unsigned char *string)
 458 {
 459     lcd_puts_scroll_offset(x, y, string, 0);
 460 }
 461
 462 void lcd_puts_scroll_offset(int x, int y, const unsigned char *string,
 463                             int offset)
 464 {
 465     struct scrollinfo* s;
 466     int len;
 467
 468     if ((unsigned)y >= (unsigned)current_vp->height)
 469         return;
 470
 471     /* remove any previously scrolling line at the same location */
 472     lcd_scroll_stop_line(current_vp, y);
 473
 474     if (lcd_scroll_info.lines >= LCD_SCROLLABLE_LINES) return;
 475
 476     s = &lcd_scroll_info.scroll[lcd_scroll_info.lines];
 477
 478     s->start_tick = current_tick + lcd_scroll_info.delay;
 479
 480     lcd_puts_offset(x, y, string, offset);
 481     len = utf8length(string);
 482
 483     if (current_vp->width - x < len)
 484     {
 485         /* prepare scroll line */
 486         char *end;
 487
 488         memset(s->line, 0, sizeof s->line);
 489         strcpy(s->line, string);
 490
 491         /* get width */
 492         s->len = utf8length(s->line);
 493
 494         /* scroll bidirectional or forward only depending on the string width */
 495         if (lcd_scroll_info.bidir_limit)
 496         {
 497             s->bidir = s->len < (current_vp->width) *
 498                 (100 + lcd_scroll_info.bidir_limit) / 100;
 499         }
 500         else
 501             s->bidir = false;
 502
 503         if (!s->bidir)  /* add spaces if scrolling in the round */
 504         {
 505             strcat(s->line, "   ");
 506             /* get new width incl. spaces */
 507             s->len += SCROLL_SPACING;
 508         }
 509
 510         end = strchr(s->line, '\0');
 511         strlcpy(end, string, utf8seek(s->line, current_vp->width));
 512
 513         s->vp = current_vp;
 514         s->y = y;
 515         s->offset = offset;
 516         s->startx = x;
 517         s->backward = false;
 518         lcd_scroll_info.lines++;
 519     }
 520 }
 521
 522 void lcd_scroll_fn(void)
 523 {
 524     struct scrollinfo* s;
 525     int index;
 526     int xpos, ypos;
 527     bool update;
 528     struct viewport* old_vp = current_vp;
 529
 530     update = false;
 531     for ( index = 0; index < lcd_scroll_info.lines; index++ ) {
 532         s = &lcd_scroll_info.scroll[index];
 533
 534         /* check pause */
 535         if (TIME_BEFORE(current_tick, s->start_tick))
 536             continue;
 537
 538         lcd_set_viewport(s->vp);
 539
 540         if (s->backward)
 541             s->offset--;
 542         else
 543             s->offset++;
 544
 545         xpos = s->startx;
 546         ypos = s->y;
 547
 548         if (s->bidir)  /* scroll bidirectional */
 549         {
 550             if (s->offset <= 0) {
 551                 /* at beginning of line */
 552                 s->offset = 0;
 553                 s->backward = false;
 554                 s->start_tick = current_tick + lcd_scroll_info.delay * 2;
 555             }
 556             if (s->offset >= s->len - (current_vp->width - xpos)) {
 557                 /* at end of line */
 558                 s->offset = s->len - (current_vp->width - xpos);
 559                 s->backward = true;
 560                 s->start_tick = current_tick + lcd_scroll_info.delay * 2;
 561             }
 562         }
 563         else    /* scroll forward the whole time */
 564         {
 565             if (s->offset >= s->len)
 566                 s->offset -= s->len;
 567         }
 568
 569         lcd_putsxyofs(xpos, ypos, s->offset, s->line);
 570         update = true;
 571     }
 572
 573     lcd_set_viewport(old_vp);
 574
 575     if (lcd_cursor.enabled)
 576     {
 577         if (--lcd_cursor.downcount <= 0)
 578         {
 579             lcd_cursor.downcount = lcd_cursor.divider;
 580             lcd_cursor.visible = !lcd_cursor.visible;
 581             update = true;
 582         }
 583     }
 584
 585     if (update)
 586         lcd_update();
 587 }
 588