firmware/drivers/lcd-1bit-vert.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 by Alan Korr
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21
  22 #include "config.h"
  23
  24 #include "lcd.h"
  25 #include "kernel.h"
  26 #include "thread.h"
  27 #include <string.h>
  28 #include <stdlib.h>
  29 #include "file.h"
  30 #include "debug.h"
  31 #include "system.h"
  32 #include "font.h"
  33 #include "rbunicode.h"
  34 #include "bidi.h"
  35 #include "scroll_engine.h"
  36
  37 #ifndef LCDFN /* Not compiling for remote - define macros for main LCD. */
  38 #define LCDFN(fn) lcd_ ## fn
  39 #define FBFN(fn)  fb_ ## fn
  40 #define LCDM(ma) LCD_ ## ma
  41 #define LCDNAME "lcd_"
  42 #define MAIN_LCD
  43 #endif
  44
  45 /*** globals ***/
  46
  47 FBFN(data) LCDFN(framebuffer)[LCDM(FBHEIGHT)][LCDM(FBWIDTH)]
  48 #if CONFIG_CPU != SH7034
  49            IBSS_ATTR
  50 #endif
  51            ;
  52
  53 static struct viewport default_vp =
  54 {
  55     .x        = 0,
  56     .y        = 0,
  57     .width    = LCDM(WIDTH),
  58     .height   = LCDM(HEIGHT),
  59     .font     = FONT_SYSFIXED,
  60     .drawmode = DRMODE_SOLID,
  61 };
  62
  63 static struct viewport* current_vp = &default_vp;
  64
  65 /*** Viewports ***/
  66
  67 void LCDFN(set_viewport)(struct viewport* vp)
  68 {
  69     if (vp == NULL)
  70         current_vp = &default_vp;
  71     else
  72         current_vp = vp;
  73 }
  74
  75 void LCDFN(update_viewport)(void)
  76 {
  77     LCDFN(update_rect)(current_vp->x, current_vp->y,
  78                        current_vp->width, current_vp->height);
  79 }
  80
  81 void LCDFN(update_viewport_rect)(int x, int y, int width, int height)
  82 {
  83     LCDFN(update_rect)(current_vp->x + x, current_vp->y + y, width, height);
  84 }
  85
  86 /* LCD init */
  87 void LCDFN(init)(void)
  88 {
  89     LCDFN(clear_display)();
  90 #ifndef SIMULATOR
  91     LCDFN(init_device)();
  92 #endif
  93 #ifdef MAIN_LCD
  94     scroll_init();
  95 #endif
  96 }
  97
  98 /*** parameter handling ***/
  99
 100 void LCDFN(set_drawmode)(int mode)
 101 {
 102     current_vp->drawmode = mode & (DRMODE_SOLID|DRMODE_INVERSEVID);
 103 }
 104
 105 int LCDFN(get_drawmode)(void)
 106 {
 107     return current_vp->drawmode;
 108 }
 109
 110 int LCDFN(getwidth)(void)
 111 {
 112     return current_vp->width;
 113 }
 114
 115 int LCDFN(getheight)(void)
 116 {
 117     return current_vp->height;
 118 }
 119
 120 void LCDFN(setfont)(int newfont)
 121 {
 122     current_vp->font = newfont;
 123 }
 124
 125 int LCDFN(getfont)(void)
 126 {
 127     return current_vp->font;
 128 }
 129
 130 int LCDFN(getstringsize)(const unsigned char *str, int *w, int *h)
 131 {
 132     return font_getstringsize(str, w, h, current_vp->font);
 133 }
 134
 135 /*** low-level drawing functions ***/
 136
 137 static void setpixel(int x, int y)
 138 {
 139     LCDFN(framebuffer)[y>>3][x] |= 1 << (y & 7);
 140 }
 141
 142 static void clearpixel(int x, int y)
 143 {
 144     LCDFN(framebuffer)[y>>3][x] &= ~(1 << (y & 7));
 145 }
 146
 147 static void flippixel(int x, int y)
 148 {
 149     LCDFN(framebuffer)[y>>3][x] ^= 1 << (y & 7);
 150 }
 151
 152 static void nopixel(int x, int y)
 153 {
 154     (void)x;
 155     (void)y;
 156 }
 157
 158 LCDFN(pixelfunc_type)* const LCDFN(pixelfuncs)[8] = {
 159     flippixel, nopixel, setpixel, setpixel,
 160     nopixel, clearpixel, nopixel, clearpixel
 161 };
 162
 163 static void ICODE_ATTR flipblock(FBFN(data) *address, unsigned mask,
 164                                  unsigned bits)
 165 {
 166     *address ^= bits & mask;
 167 }
 168
 169 static void ICODE_ATTR bgblock(FBFN(data) *address, unsigned mask,
 170                                unsigned bits)
 171 {
 172     *address &= bits | ~mask;
 173 }
 174
 175 static void ICODE_ATTR fgblock(FBFN(data) *address, unsigned mask,
 176                                unsigned bits)
 177 {
 178     *address |= bits & mask;
 179 }
 180
 181 static void ICODE_ATTR solidblock(FBFN(data) *address, unsigned mask,
 182                                   unsigned bits)
 183 {
 184     unsigned data = *(char*)address;
 185
 186     bits    ^= data;
 187     *address = data ^ (bits & mask);
 188 }
 189
 190 static void ICODE_ATTR flipinvblock(FBFN(data) *address, unsigned mask,
 191                                     unsigned bits)
 192 {
 193     *address ^= ~bits & mask;
 194 }
 195
 196 static void ICODE_ATTR bginvblock(FBFN(data) *address, unsigned mask,
 197                                   unsigned bits)
 198 {
 199     *address &= ~(bits & mask);
 200 }
 201
 202 static void ICODE_ATTR fginvblock(FBFN(data) *address, unsigned mask,
 203                                   unsigned bits)
 204 {
 205     *address |= ~bits & mask;
 206 }
 207
 208 static void ICODE_ATTR solidinvblock(FBFN(data) *address, unsigned mask,
 209                                      unsigned bits)
 210 {
 211     unsigned data = *(char *)address;
 212
 213     bits     = ~bits ^ data;
 214     *address = data ^ (bits & mask);
 215 }
 216
 217 LCDFN(blockfunc_type)* const LCDFN(blockfuncs)[8] = {
 218     flipblock, bgblock, fgblock, solidblock,
 219     flipinvblock, bginvblock, fginvblock, solidinvblock
 220 };
 221
 222 /*** drawing functions ***/
 223
 224 /* Clear the whole display */
 225 void LCDFN(clear_display)(void)
 226 {
 227     unsigned bits = (current_vp->drawmode & DRMODE_INVERSEVID) ? 0xFFu : 0;
 228
 229     memset(LCDFN(framebuffer), bits, sizeof LCDFN(framebuffer));
 230     LCDFN(scroll_info).lines = 0;
 231 }
 232
 233 /* Clear the current viewport */
 234 void LCDFN(clear_viewport)(void)
 235 {
 236     int oldmode;
 237
 238     if (current_vp == &default_vp)
 239     {
 240         LCDFN(clear_display)();
 241     }
 242     else
 243     {
 244         oldmode = current_vp->drawmode;
 245
 246         /* Invert the INVERSEVID bit and set basic mode to SOLID */
 247         current_vp->drawmode = (~current_vp->drawmode & DRMODE_INVERSEVID) |
 248                                DRMODE_SOLID;
 249
 250         LCDFN(fillrect)(0, 0, current_vp->width, current_vp->height);
 251
 252         current_vp->drawmode = oldmode;
 253
 254         LCDFN(scroll_stop)(current_vp);
 255     }
 256 }
 257
 258 /* Set a single pixel */
 259 void LCDFN(drawpixel)(int x, int y)
 260 {
 261     if (((unsigned)x < (unsigned)current_vp->width) &&
 262         ((unsigned)y < (unsigned)current_vp->height))
 263         LCDFN(pixelfuncs)[current_vp->drawmode](current_vp->x + x, current_vp->y + y);
 264 }
 265
 266 /* Draw a line */
 267 void LCDFN(drawline)(int x1, int y1, int x2, int y2)
 268 {
 269     int numpixels;
 270     int i;
 271     int deltax, deltay;
 272     int d, dinc1, dinc2;
 273     int x, xinc1, xinc2;
 274     int y, yinc1, yinc2;
 275     LCDFN(pixelfunc_type) *pfunc = LCDFN(pixelfuncs)[current_vp->drawmode];
 276
 277     deltax = abs(x2 - x1);
 278     if (deltax == 0)
 279     {
 280         DEBUGF(LCDNAME "drawline() called for vertical line - optimisation.\n");
 281         LCDFN(vline)(x1, y1, y2);
 282         return;
 283     }
 284     deltay = abs(y2 - y1);
 285     if (deltay == 0)
 286     {
 287         DEBUGF(LCDNAME "drawline() called for horizontal line - optimisation.\n");
 288         LCDFN(hline)(x1, x2, y1);
 289         return;
 290     }
 291     xinc2 = 1;
 292     yinc2 = 1;
 293
 294     if (deltax >= deltay)
 295     {
 296         numpixels = deltax;
 297         d = 2 * deltay - deltax;
 298         dinc1 = deltay * 2;
 299         dinc2 = (deltay - deltax) * 2;
 300         xinc1 = 1;
 301         yinc1 = 0;
 302     }
 303     else
 304     {
 305         numpixels = deltay;
 306         d = 2 * deltax - deltay;
 307         dinc1 = deltax * 2;
 308         dinc2 = (deltax - deltay) * 2;
 309         xinc1 = 0;
 310         yinc1 = 1;
 311     }
 312     numpixels++; /* include endpoints */
 313
 314     if (x1 > x2)
 315     {
 316         xinc1 = -xinc1;
 317         xinc2 = -xinc2;
 318     }
 319
 320     if (y1 > y2)
 321     {
 322         yinc1 = -yinc1;
 323         yinc2 = -yinc2;
 324     }
 325
 326     x = x1;
 327     y = y1;
 328
 329     for (i = 0; i < numpixels; i++)
 330     {
 331         if (((unsigned)x < (unsigned)current_vp->width)
 332             && ((unsigned)y < (unsigned)current_vp->height))
 333             pfunc(current_vp->x + x, current_vp->y + y);
 334
 335         if (d < 0)
 336         {
 337             d += dinc1;
 338             x += xinc1;
 339             y += yinc1;
 340         }
 341         else
 342         {
 343             d += dinc2;
 344             x += xinc2;
 345             y += yinc2;
 346         }
 347     }
 348 }
 349
 350 /* Draw a horizontal line (optimised) */
 351 void LCDFN(hline)(int x1, int x2, int y)
 352 {
 353     int x, width;
 354     unsigned char *dst, *dst_end;
 355     unsigned mask;
 356     LCDFN(blockfunc_type) *bfunc;
 357
 358     /* direction flip */
 359     if (x2 < x1)
 360     {
 361         x = x1;
 362         x1 = x2;
 363         x2 = x;
 364     }
 365
 366     /* nothing to draw? */
 367     if (((unsigned)y >= (unsigned)current_vp->height) || (x1 >= current_vp->width)
 368         || (x2 < 0))
 369         return;
 370
 371     /* clipping */
 372     if (x1 < 0)
 373         x1 = 0;
 374     if (x2 >= current_vp->width)
 375         x2 = current_vp->width-1;
 376
 377     width = x2 - x1 + 1;
 378
 379     /* adjust to viewport */
 380     x1 += current_vp->x;
 381     y += current_vp->y;
 382
 383     bfunc = LCDFN(blockfuncs)[current_vp->drawmode];
 384     dst   = &LCDFN(framebuffer)[y>>3][x1];
 385     mask  = 1 << (y & 7);
 386
 387     dst_end = dst + width;
 388     do
 389         bfunc(dst++, mask, 0xFFu);
 390     while (dst < dst_end);
 391 }
 392
 393 /* Draw a vertical line (optimised) */
 394 void LCDFN(vline)(int x, int y1, int y2)
 395 {
 396     int ny;
 397     FBFN(data) *dst;
 398     unsigned mask, mask_bottom;
 399     LCDFN(blockfunc_type) *bfunc;
 400
 401     /* direction flip */
 402     if (y2 < y1)
 403     {
 404         ny = y1;
 405         y1 = y2;
 406         y2 = ny;
 407     }
 408
 409     /* nothing to draw? */
 410     if (((unsigned)x >= (unsigned)current_vp->width) || (y1 >= current_vp->height)
 411         || (y2 < 0))
 412         return;
 413
 414     /* clipping */
 415     if (y1 < 0)
 416         y1 = 0;
 417     if (y2 >= current_vp->height)
 418         y2 = current_vp->height-1;
 419
 420     /* adjust for viewport */
 421     y1 += current_vp->y;
 422     y2 += current_vp->y;
 423     x += current_vp->x;
 424
 425     bfunc = LCDFN(blockfuncs)[current_vp->drawmode];
 426     dst   = &LCDFN(framebuffer)[y1>>3][x];
 427     ny    = y2 - (y1 & ~7);
 428     mask  = 0xFFu << (y1 & 7);
 429     mask_bottom = 0xFFu >> (~ny & 7);
 430
 431     for (; ny >= 8; ny -= 8)
 432     {
 433         bfunc(dst, mask, 0xFFu);
 434         dst += LCDM(WIDTH);
 435         mask = 0xFFu;
 436     }
 437     mask &= mask_bottom;
 438     bfunc(dst, mask, 0xFFu);
 439 }
 440
 441 /* Draw a rectangular box */
 442 void LCDFN(drawrect)(int x, int y, int width, int height)
 443 {
 444     if ((width <= 0) || (height <= 0))
 445         return;
 446
 447     int x2 = x + width - 1;
 448     int y2 = y + height - 1;
 449
 450     LCDFN(vline)(x, y, y2);
 451     LCDFN(vline)(x2, y, y2);
 452     LCDFN(hline)(x, x2, y);
 453     LCDFN(hline)(x, x2, y2);
 454 }
 455
 456 /* Fill a rectangular area */
 457 void LCDFN(fillrect)(int x, int y, int width, int height)
 458 {
 459     int ny;
 460     FBFN(data) *dst, *dst_end;
 461     unsigned mask, mask_bottom;
 462     unsigned bits = 0;
 463     LCDFN(blockfunc_type) *bfunc;
 464     bool fillopt = false;
 465
 466     /* nothing to draw? */
 467     if ((width <= 0) || (height <= 0) || (x >= current_vp->width)
 468         || (y >= current_vp->height) || (x + width <= 0) || (y + height <= 0))
 469         return;
 470
 471     /* clipping */
 472     if (x < 0)
 473     {
 474         width += x;
 475         x = 0;
 476     }
 477     if (y < 0)
 478     {
 479         height += y;
 480         y = 0;
 481     }
 482     if (x + width > current_vp->width)
 483         width = current_vp->width - x;
 484     if (y + height > current_vp->height)
 485         height = current_vp->height - y;
 486
 487     /* adjust for viewport */
 488     x += current_vp->x;
 489     y += current_vp->y;
 490
 491     if (current_vp->drawmode & DRMODE_INVERSEVID)
 492     {
 493         if (current_vp->drawmode & DRMODE_BG)
 494         {
 495             fillopt = true;
 496         }
 497     }
 498     else
 499     {
 500         if (current_vp->drawmode & DRMODE_FG)
 501         {
 502             fillopt = true;
 503             bits = 0xFFu;
 504         }
 505     }
 506     bfunc = LCDFN(blockfuncs)[current_vp->drawmode];
 507     dst   = &LCDFN(framebuffer)[y>>3][x];
 508     ny    = height - 1 + (y & 7);
 509     mask  = 0xFFu << (y & 7);
 510     mask_bottom = 0xFFu >> (~ny & 7);
 511
 512     for (; ny >= 8; ny -= 8)
 513     {
 514         if (fillopt && (mask == 0xFFu))
 515             memset(dst, bits, width);
 516         else
 517         {
 518             FBFN(data) *dst_row = dst;
 519
 520             dst_end = dst_row + width;
 521             do
 522                 bfunc(dst_row++, mask, 0xFFu);
 523             while (dst_row < dst_end);
 524         }
 525
 526         dst += LCDM(WIDTH);
 527         mask = 0xFFu;
 528     }
 529     mask &= mask_bottom;
 530
 531     if (fillopt && (mask == 0xFFu))
 532         memset(dst, bits, width);
 533     else
 534     {
 535         dst_end = dst + width;
 536         do
 537             bfunc(dst++, mask, 0xFFu);
 538         while (dst < dst_end);
 539     }
 540 }
 541
 542 /* About Rockbox' internal bitmap format:
 543  *
 544  * A bitmap contains one bit for every pixel that defines if that pixel is
 545  * black (1) or white (0). Bits within a byte are arranged vertically, LSB
 546  * at top.
 547  * The bytes are stored in row-major order, with byte 0 being top left,
 548  * byte 1 2nd from left etc. The first row of bytes defines pixel rows
 549  * 0..7, the second row defines pixel row 8..15 etc.
 550  *
 551  * This is the same as the internal lcd hw format. */
 552
 553 /* Draw a partial bitmap */
 554 void ICODE_ATTR LCDFN(bitmap_part)(const unsigned char *src, int src_x,
 555                                    int src_y, int stride, int x, int y,
 556                                    int width, int height)
 557 {
 558     int shift, ny;
 559     FBFN(data) *dst, *dst_end;
 560     unsigned mask, mask_bottom;
 561     LCDFN(blockfunc_type) *bfunc;
 562
 563     /* nothing to draw? */
 564     if ((width <= 0) || (height <= 0) || (x >= current_vp->width)
 565         || (y >= current_vp->height) || (x + width <= 0) || (y + height <= 0))
 566         return;
 567
 568     /* clipping */
 569     if (x < 0)
 570     {
 571         width += x;
 572         src_x -= x;
 573         x = 0;
 574     }
 575     if (y < 0)
 576     {
 577         height += y;
 578         src_y -= y;
 579         y = 0;
 580     }
 581     if (x + width > current_vp->width)
 582         width = current_vp->width - x;
 583     if (y + height > current_vp->height)
 584         height = current_vp->height - y;
 585
 586     /* adjust for viewport */
 587     x += current_vp->x;
 588     y += current_vp->y;
 589
 590     src    += stride * (src_y >> 3) + src_x; /* move starting point */
 591     src_y  &= 7;
 592     y      -= src_y;
 593     dst    = &LCDFN(framebuffer)[y>>3][x];
 594     shift  = y & 7;
 595     ny     = height - 1 + shift + src_y;
 596
 597     bfunc  = LCDFN(blockfuncs)[current_vp->drawmode];
 598     mask   = 0xFFu << (shift + src_y);
 599     mask_bottom = 0xFFu >> (~ny & 7);
 600
 601     if (shift == 0)
 602     {
 603         bool copyopt = (current_vp->drawmode == DRMODE_SOLID);
 604
 605         for (; ny >= 8; ny -= 8)
 606         {
 607             if (copyopt && (mask == 0xFFu))
 608                 memcpy(dst, src, width);
 609             else
 610             {
 611                 const unsigned char *src_row = src;
 612                 FBFN(data) *dst_row = dst;
 613
 614                 dst_end = dst_row + width;
 615                 do
 616                     bfunc(dst_row++, mask, *src_row++);
 617                 while (dst_row < dst_end);
 618             }
 619
 620             src += stride;
 621             dst += LCDM(WIDTH);
 622             mask = 0xFFu;
 623         }
 624         mask &= mask_bottom;
 625
 626         if (copyopt && (mask == 0xFFu))
 627             memcpy(dst, src, width);
 628         else
 629         {
 630             dst_end = dst + width;
 631             do
 632                 bfunc(dst++, mask, *src++);
 633             while (dst < dst_end);
 634         }
 635     }
 636     else
 637     {
 638         dst_end = dst + width;
 639         do
 640         {
 641             const unsigned char *src_col = src++;
 642             FBFN(data) *dst_col = dst++;
 643             unsigned mask_col = mask;
 644             unsigned data = 0;
 645
 646             for (y = ny; y >= 8; y -= 8)
 647             {
 648                 data |= *src_col << shift;
 649
 650                 if (mask_col & 0xFFu)
 651                 {
 652                     bfunc(dst_col, mask_col, data);
 653                     mask_col = 0xFFu;
 654                 }
 655                 else
 656                     mask_col >>= 8;
 657
 658                 src_col += stride;
 659                 dst_col += LCDM(WIDTH);
 660                 data >>= 8;
 661             }
 662             data |= *src_col << shift;
 663             bfunc(dst_col, mask_col & mask_bottom, data);
 664         }
 665         while (dst < dst_end);
 666     }
 667 }
 668
 669 /* Draw a full bitmap */
 670 void LCDFN(bitmap)(const unsigned char *src, int x, int y, int width,
 671                    int height)
 672 {
 673     LCDFN(bitmap_part)(src, 0, 0, width, x, y, width, height);
 674 }
 675
 676 /* put a string at a given pixel position, skipping first ofs pixel columns */
 677 static void LCDFN(putsxyofs)(int x, int y, int ofs, const unsigned char *str)
 678 {
 679     unsigned short ch;
 680     unsigned short *ucs;
 681     struct font* pf = font_get(current_vp->font);
 682
 683     ucs = bidi_l2v(str, 1);
 684
 685     while ((ch = *ucs++) != 0 && x < current_vp->width)
 686     {
 687         int width;
 688         const unsigned char *bits;
 689
 690         /* get proportional width and glyph bits */
 691         width = font_get_width(pf, ch);
 692
 693         if (ofs > width)
 694         {
 695             ofs -= width;
 696             continue;
 697         }
 698
 699         bits = font_get_bits(pf, ch);
 700
 701         LCDFN(mono_bitmap_part)(bits, ofs, 0, width, x, y, width - ofs,
 702                                 pf->height);
 703
 704         x += width - ofs;
 705         ofs = 0;
 706     }
 707 }
 708 /* put a string at a given pixel position */
 709 void LCDFN(putsxy)(int x, int y, const unsigned char *str)
 710 {
 711     LCDFN(putsxyofs)(x, y, 0, str);
 712 }
 713
 714 /*** Line oriented text output ***/
 715
 716 /* put a string at a given char position */
 717 void LCDFN(puts)(int x, int y, const unsigned char *str)
 718 {
 719     LCDFN(puts_style_offset)(x, y, str, STYLE_DEFAULT, 0);
 720 }
 721
 722 void LCDFN(puts_style)(int x, int y, const unsigned char *str, int style)
 723 {
 724     LCDFN(puts_style_offset)(x, y, str, style, 0);
 725 }
 726
 727 void LCDFN(puts_offset)(int x, int y, const unsigned char *str, int offset)
 728 {
 729     LCDFN(puts_style_offset)(x, y, str, STYLE_DEFAULT, offset);
 730 }
 731
 732 /* put a string at a given char position, style, and pixel position,
 733  * skipping first offset pixel columns */
 734 void LCDFN(puts_style_offset)(int x, int y, const unsigned char *str,
 735                               int style, int offset)
 736 {
 737     int xpos,ypos,w,h,xrect;
 738     int lastmode = current_vp->drawmode;
 739
 740     /* make sure scrolling is turned off on the line we are updating */
 741     LCDFN(scroll_stop_line)(current_vp, y);
 742
 743     if(!str || !str[0])
 744         return;
 745
 746     LCDFN(getstringsize)(str, &w, &h);
 747     xpos = x*w / utf8length(str);
 748     ypos = y*h;
 749     current_vp->drawmode = (style & STYLE_INVERT) ?
 750                            (DRMODE_SOLID|DRMODE_INVERSEVID) : DRMODE_SOLID;
 751     LCDFN(putsxyofs)(xpos, ypos, offset, str);
 752     current_vp->drawmode ^= DRMODE_INVERSEVID;
 753     xrect = xpos + MAX(w - offset, 0);
 754     LCDFN(fillrect)(xrect, ypos, current_vp->width - xrect, h);
 755     current_vp->drawmode = lastmode;
 756 }
 757
 758 /*** scrolling ***/
 759
 760 void LCDFN(puts_scroll)(int x, int y, const unsigned char *string)
 761 {
 762     LCDFN(puts_scroll_style)(x, y, string, STYLE_DEFAULT);
 763 }
 764
 765 void LCDFN(puts_scroll_style)(int x, int y, const unsigned char *string,
 766                               int style)
 767 {
 768      LCDFN(puts_scroll_style_offset)(x, y, string, style, 0);
 769 }
 770
 771 void LCDFN(puts_scroll_offset)(int x, int y, const unsigned char *string,
 772                                int offset)
 773 {
 774      LCDFN(puts_scroll_style_offset)(x, y, string, STYLE_DEFAULT, offset);
 775 }
 776
 777 void LCDFN(puts_scroll_style_offset)(int x, int y, const unsigned char *string,
 778                                      int style, int offset)
 779 {
 780     struct scrollinfo* s;
 781     int w, h;
 782
 783     if ((unsigned)y >= (unsigned)current_vp->height)
 784         return;
 785
 786     /* remove any previously scrolling line at the same location */
 787     LCDFN(scroll_stop_line)(current_vp, y);
 788
 789     if (LCDFN(scroll_info.lines) >= LCDM(SCROLLABLE_LINES)) return;
 790
 791     s = &LCDFN(scroll_info).scroll[LCDFN(scroll_info).lines];
 792
 793     s->start_tick = current_tick + LCDFN(scroll_info).delay;
 794     s->style = style;
 795     if (style & STYLE_INVERT) {
 796         LCDFN(puts_style_offset)(x,y,string,STYLE_INVERT,offset);
 797     }
 798     else
 799         LCDFN(puts_offset)(x,y,string,offset);
 800
 801     LCDFN(getstringsize)(string, &w, &h);
 802
 803     if (current_vp->width - x * 8 < w) {
 804         /* prepare scroll line */
 805         char *end;
 806
 807         memset(s->line, 0, sizeof s->line);
 808         strcpy(s->line, string);
 809
 810         /* get width */
 811         s->width = LCDFN(getstringsize)(s->line, &w, &h);
 812
 813         /* scroll bidirectional or forward only depending on the string
 814            width */
 815         if ( LCDFN(scroll_info).bidir_limit ) {
 816             s->bidir = s->width < (current_vp->width) *
 817                 (100 + LCDFN(scroll_info).bidir_limit) / 100;
 818         }
 819         else
 820             s->bidir = false;
 821
 822         if (!s->bidir) { /* add spaces if scrolling in the round */
 823             strcat(s->line, "   ");
 824             /* get new width incl. spaces */
 825             s->width = LCDFN(getstringsize)(s->line, &w, &h);
 826         }
 827
 828         end = strchr(s->line, '\0');
 829         strncpy(end, string, current_vp->width/2);
 830
 831         s->vp = current_vp;
 832         s->y = y;
 833         s->len = utf8length(string);
 834         s->offset = offset;
 835         s->startx = x * s->width / s->len;;
 836         s->backward = false;
 837
 838         LCDFN(scroll_info).lines++;
 839     }
 840 }
 841
 842 void LCDFN(scroll_fn)(void)
 843 {
 844     struct font* pf;
 845     struct scrollinfo* s;
 846     int index;
 847     int xpos, ypos;
 848     int lastmode;
 849     struct viewport* old_vp = current_vp;
 850
 851     for ( index = 0; index < LCDFN(scroll_info).lines; index++ ) {
 852         s = &LCDFN(scroll_info).scroll[index];
 853
 854         /* check pause */
 855         if (TIME_BEFORE(current_tick, s->start_tick))
 856             continue;
 857
 858         LCDFN(set_viewport)(s->vp);
 859
 860         if (s->backward)
 861             s->offset -= LCDFN(scroll_info).step;
 862         else
 863             s->offset += LCDFN(scroll_info).step;
 864
 865         pf = font_get(current_vp->font);
 866         xpos = s->startx;
 867         ypos = s->y * pf->height;
 868
 869         if (s->bidir) { /* scroll bidirectional */
 870             if (s->offset <= 0) {
 871                 /* at beginning of line */
 872                 s->offset = 0;
 873                 s->backward = false;
 874                 s->start_tick = current_tick + LCDFN(scroll_info).delay * 2;
 875             }
 876             if (s->offset >= s->width - (current_vp->width - xpos)) {
 877                 /* at end of line */
 878                 s->offset = s->width - (current_vp->width - xpos);
 879                 s->backward = true;
 880                 s->start_tick = current_tick + LCDFN(scroll_info).delay * 2;
 881             }
 882         }
 883         else {
 884             /* scroll forward the whole time */
 885             if (s->offset >= s->width)
 886                 s->offset %= s->width;
 887         }
 888
 889         lastmode = current_vp->drawmode;
 890         current_vp->drawmode = (s->style&STYLE_INVERT) ?
 891                                (DRMODE_SOLID|DRMODE_INVERSEVID) : DRMODE_SOLID;
 892         LCDFN(putsxyofs)(xpos, ypos, s->offset, s->line);
 893         current_vp->drawmode = lastmode;
 894         LCDFN(update_viewport_rect)(xpos, ypos, current_vp->width - xpos, pf->height);
 895     }
 896
 897     LCDFN(set_viewport)(old_vp);
 898 }