?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Updated dutch voice translations
[kugel-rb.git] / firmware / drivers / lcd-1bit-vert.c
blob75d1e660c4df8c83c89f85a7bed2df6c1ae3f9db
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 }
My public Rockbox git repo