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