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