?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
(hopefully) fix some broken download stuff I introduced yesterday.
[Rockbox.git] / firmware / drivers / lcd-16bit.c
blobbd5d09368c9748e42b393554852cac0f8bce5ae7
1 /***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id$
9 *
10 * Copyright (C) 2005 by Dave Chapman
11 *
12 * Rockbox driver for 16-bit colour LCDs
13 *
14 * All files in this archive are subject to the GNU General Public License.
15 * See the file COPYING in the source tree root for full license agreement.
16 *
17 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
18 * KIND, either express or implied.
19 *
20 ****************************************************************************/
21 #include "config.h"
22
23 #include "cpu.h"
24 #include "lcd.h"
25 #include "kernel.h"
26 #include "thread.h"
27 #include <string.h>
28 #include <stdlib.h>
29 #include "memory.h"
30 #include "file.h"
31 #include "debug.h"
32 #include "system.h"
33 #include "font.h"
34 #include "rbunicode.h"
35 #include "bidi.h"
36 #include "scroll_engine.h"
37
38 enum fill_opt {
39 OPT_NONE = 0,
40 OPT_SET,
41 OPT_COPY
42 };
43
44 /*** globals ***/
45 fb_data lcd_framebuffer[LCD_FBHEIGHT][LCD_FBWIDTH] IRAM_LCDFRAMEBUFFER __attribute__ ((aligned (16)));
46
47
48 static fb_data* lcd_backdrop = NULL;
49 static long lcd_backdrop_offset IDATA_ATTR = 0;
50
51 #if !defined(TOSHIBA_GIGABEAT_F) || defined(SIMULATOR)
52 static unsigned fg_pattern IDATA_ATTR = LCD_DEFAULT_FG;
53 static unsigned bg_pattern IDATA_ATTR = LCD_DEFAULT_BG;
54 #else
55 unsigned fg_pattern IDATA_ATTR = LCD_DEFAULT_FG;
56 unsigned bg_pattern IDATA_ATTR = LCD_DEFAULT_BG;
57 #endif
58
59 static int drawmode = DRMODE_SOLID;
60 static int xmargin = 0;
61 static int ymargin = 0;
62 static int curfont = FONT_SYSFIXED;
63
64 /* LCD init */
65 void lcd_init(void)
66 {
67 lcd_clear_display();
68
69 /* Call device specific init */
70 lcd_init_device();
71 scroll_init();
72 }
73
74 /*** parameter handling ***/
75
76 void lcd_set_drawmode(int mode)
77 {
78 drawmode = mode & (DRMODE_SOLID|DRMODE_INVERSEVID);
79 }
80
81 int lcd_get_drawmode(void)
82 {
83 return drawmode;
84 }
85
86 void lcd_set_foreground(unsigned color)
87 {
88 fg_pattern = color;
89 }
90
91 unsigned lcd_get_foreground(void)
92 {
93 return fg_pattern;
94 }
95
96 void lcd_set_background(unsigned color)
97 {
98 bg_pattern = color;
99 }
100
101 unsigned lcd_get_background(void)
102 {
103 return bg_pattern;
104 }
105
106 void lcd_set_drawinfo(int mode, unsigned fg_color, unsigned bg_color)
107 {
108 lcd_set_drawmode(mode);
109 fg_pattern = fg_color;
110 bg_pattern = bg_color;
111 }
112
113 void lcd_setmargins(int x, int y)
114 {
115 xmargin = x;
116 ymargin = y;
117 }
118
119 int lcd_getxmargin(void)
120 {
121 return xmargin;
122 }
123
124 int lcd_getymargin(void)
125 {
126 return ymargin;
127 }
128
129 void lcd_setfont(int newfont)
130 {
131 curfont = newfont;
132 }
133
134 int lcd_getstringsize(const unsigned char *str, int *w, int *h)
135 {
136 return font_getstringsize(str, w, h, curfont);
137 }
138
139 /*** low-level drawing functions ***/
140
141 #define LCDADDR(x, y) (&lcd_framebuffer[(y)][(x)])
142
143 static void setpixel(fb_data *address) ICODE_ATTR;
144 static void setpixel(fb_data *address)
145 {
146 *address = fg_pattern;
147 }
148
149 static void clearpixel(fb_data *address) ICODE_ATTR;
150 static void clearpixel(fb_data *address)
151 {
152 *address = bg_pattern;
153 }
154
155 static void clearimgpixel(fb_data *address) ICODE_ATTR;
156 static void clearimgpixel(fb_data *address)
157 {
158 *address = *(fb_data *)((long)address + lcd_backdrop_offset);
159 }
160
161 static void flippixel(fb_data *address) ICODE_ATTR;
162 static void flippixel(fb_data *address)
163 {
164 *address = ~(*address);
165 }
166
167 static void nopixel(fb_data *address) ICODE_ATTR;
168 static void nopixel(fb_data *address)
169 {
170 (void)address;
171 }
172
173 lcd_fastpixelfunc_type* const lcd_fastpixelfuncs_bgcolor[8] = {
174 flippixel, nopixel, setpixel, setpixel,
175 nopixel, clearpixel, nopixel, clearpixel
176 };
177
178 lcd_fastpixelfunc_type* const lcd_fastpixelfuncs_backdrop[8] = {
179 flippixel, nopixel, setpixel, setpixel,
180 nopixel, clearimgpixel, nopixel, clearimgpixel
181 };
182
183 lcd_fastpixelfunc_type* const * lcd_fastpixelfuncs = lcd_fastpixelfuncs_bgcolor;
184
185 void lcd_set_backdrop(fb_data* backdrop)
186 {
187 lcd_backdrop = backdrop;
188 if (backdrop)
189 {
190 lcd_backdrop_offset = (long)backdrop - (long)&lcd_framebuffer[0][0];
191 lcd_fastpixelfuncs = lcd_fastpixelfuncs_backdrop;
192 }
193 else
194 {
195 lcd_backdrop_offset = 0;
196 lcd_fastpixelfuncs = lcd_fastpixelfuncs_bgcolor;
197 }
198 }
199
200 fb_data* lcd_get_backdrop(void)
201 {
202 return lcd_backdrop;
203 }
204
205 /*** drawing functions ***/
206
207 /* Clear the whole display */
208 void lcd_clear_display(void)
209 {
210 fb_data *dst = LCDADDR(0, 0);
211
212 if (drawmode & DRMODE_INVERSEVID)
213 {
214 memset16(dst, fg_pattern, LCD_WIDTH*LCD_HEIGHT);
215 }
216 else
217 {
218 if (!lcd_backdrop)
219 memset16(dst, bg_pattern, LCD_WIDTH*LCD_HEIGHT);
220 else
221 memcpy(dst, lcd_backdrop, sizeof(lcd_framebuffer));
222 }
223
224 lcd_scroll_info.lines = 0;
225 }
226
227 /* Set a single pixel */
228 void lcd_drawpixel(int x, int y)
229 {
230 if (((unsigned)x < LCD_WIDTH) && ((unsigned)y < LCD_HEIGHT))
231 lcd_fastpixelfuncs[drawmode](LCDADDR(x, y));
232 }
233
234 /* Draw a line */
235 void lcd_drawline(int x1, int y1, int x2, int y2)
236 {
237 int numpixels;
238 int i;
239 int deltax, deltay;
240 int d, dinc1, dinc2;
241 int x, xinc1, xinc2;
242 int y, yinc1, yinc2;
243 lcd_fastpixelfunc_type *pfunc = lcd_fastpixelfuncs[drawmode];
244
245 deltax = abs(x2 - x1);
246 deltay = abs(y2 - y1);
247 xinc2 = 1;
248 yinc2 = 1;
249
250 if (deltax >= deltay)
251 {
252 numpixels = deltax;
253 d = 2 * deltay - deltax;
254 dinc1 = deltay * 2;
255 dinc2 = (deltay - deltax) * 2;
256 xinc1 = 1;
257 yinc1 = 0;
258 }
259 else
260 {
261 numpixels = deltay;
262 d = 2 * deltax - deltay;
263 dinc1 = deltax * 2;
264 dinc2 = (deltax - deltay) * 2;
265 xinc1 = 0;
266 yinc1 = 1;
267 }
268 numpixels++; /* include endpoints */
269
270 if (x1 > x2)
271 {
272 xinc1 = -xinc1;
273 xinc2 = -xinc2;
274 }
275
276 if (y1 > y2)
277 {
278 yinc1 = -yinc1;
279 yinc2 = -yinc2;
280 }
281
282 x = x1;
283 y = y1;
284
285 for (i = 0; i < numpixels; i++)
286 {
287 if (((unsigned)x < LCD_WIDTH) && ((unsigned)y < LCD_HEIGHT))
288 pfunc(LCDADDR(x, y));
289
290 if (d < 0)
291 {
292 d += dinc1;
293 x += xinc1;
294 y += yinc1;
295 }
296 else
297 {
298 d += dinc2;
299 x += xinc2;
300 y += yinc2;
301 }
302 }
303 }
304
305 /* Draw a horizontal line (optimised) */
306 void lcd_hline(int x1, int x2, int y)
307 {
308 int x, width;
309 unsigned bits = 0;
310 enum fill_opt fillopt = OPT_NONE;
311 fb_data *dst, *dst_end;
312 lcd_fastpixelfunc_type *pfunc = lcd_fastpixelfuncs[drawmode];
313
314 /* direction flip */
315 if (x2 < x1)
316 {
317 x = x1;
318 x1 = x2;
319 x2 = x;
320 }
321
322 /* nothing to draw? */
323 if (((unsigned)y >= LCD_HEIGHT) || (x1 >= LCD_WIDTH) || (x2 < 0))
324 return;
325
326 /* clipping */
327 if (x1 < 0)
328 x1 = 0;
329 if (x2 >= LCD_WIDTH)
330 x2 = LCD_WIDTH-1;
331
332 if (drawmode & DRMODE_INVERSEVID)
333 {
334 if (drawmode & DRMODE_BG)
335 {
336 if (!lcd_backdrop)
337 {
338 fillopt = OPT_SET;
339 bits = bg_pattern;
340 }
341 else
342 fillopt = OPT_COPY;
343 }
344 }
345 else
346 {
347 if (drawmode & DRMODE_FG)
348 {
349 fillopt = OPT_SET;
350 bits = fg_pattern;
351 }
352 }
353 dst = LCDADDR(x1, y);
354 width = x2 - x1 + 1;
355
356 switch (fillopt)
357 {
358 case OPT_SET:
359 memset16(dst, bits, width);
360 break;
361
362 case OPT_COPY:
363 memcpy(dst, (void *)((long)dst + lcd_backdrop_offset),
364 width * sizeof(fb_data));
365 break;
366
367 case OPT_NONE:
368 dst_end = dst + width;
369 do
370 pfunc(dst++);
371 while (dst < dst_end);
372 break;
373 }
374 }
375
376 /* Draw a vertical line (optimised) */
377 void lcd_vline(int x, int y1, int y2)
378 {
379 int y;
380 fb_data *dst, *dst_end;
381 lcd_fastpixelfunc_type *pfunc = lcd_fastpixelfuncs[drawmode];
382
383 /* direction flip */
384 if (y2 < y1)
385 {
386 y = y1;
387 y1 = y2;
388 y2 = y;
389 }
390
391 /* nothing to draw? */
392 if (((unsigned)x >= LCD_WIDTH) || (y1 >= LCD_HEIGHT) || (y2 < 0))
393 return;
394
395 /* clipping */
396 if (y1 < 0)
397 y1 = 0;
398 if (y2 >= LCD_HEIGHT)
399 y2 = LCD_HEIGHT-1;
400
401 dst = LCDADDR(x, y1);
402 dst_end = dst + (y2 - y1) * LCD_WIDTH;
403
404 do
405 {
406 pfunc(dst);
407 dst += LCD_WIDTH;
408 }
409 while (dst <= dst_end);
410 }
411
412 /* Draw a rectangular box */
413 void lcd_drawrect(int x, int y, int width, int height)
414 {
415 if ((width <= 0) || (height <= 0))
416 return;
417
418 int x2 = x + width - 1;
419 int y2 = y + height - 1;
420
421 lcd_vline(x, y, y2);
422 lcd_vline(x2, y, y2);
423 lcd_hline(x, x2, y);
424 lcd_hline(x, x2, y2);
425 }
426
427 /* Fill a rectangular area */
428 void lcd_fillrect(int x, int y, int width, int height)
429 {
430 unsigned bits = 0;
431 enum fill_opt fillopt = OPT_NONE;
432 fb_data *dst, *dst_end;
433 lcd_fastpixelfunc_type *pfunc = lcd_fastpixelfuncs[drawmode];
434
435 /* nothing to draw? */
436 if ((width <= 0) || (height <= 0) || (x >= LCD_WIDTH) || (y >= LCD_HEIGHT)
437 || (x + width <= 0) || (y + height <= 0))
438 return;
439
440 /* clipping */
441 if (x < 0)
442 {
443 width += x;
444 x = 0;
445 }
446 if (y < 0)
447 {
448 height += y;
449 y = 0;
450 }
451 if (x + width > LCD_WIDTH)
452 width = LCD_WIDTH - x;
453 if (y + height > LCD_HEIGHT)
454 height = LCD_HEIGHT - y;
455
456 if (drawmode & DRMODE_INVERSEVID)
457 {
458 if (drawmode & DRMODE_BG)
459 {
460 if (!lcd_backdrop)
461 {
462 fillopt = OPT_SET;
463 bits = bg_pattern;
464 }
465 else
466 fillopt = OPT_COPY;
467 }
468 }
469 else
470 {
471 if (drawmode & DRMODE_FG)
472 {
473 fillopt = OPT_SET;
474 bits = fg_pattern;
475 }
476 }
477 dst = LCDADDR(x, y);
478 dst_end = dst + height * LCD_WIDTH;
479
480 do
481 {
482 fb_data *dst_row, *row_end;
483
484 switch (fillopt)
485 {
486 case OPT_SET:
487 memset16(dst, bits, width);
488 break;
489
490 case OPT_COPY:
491 memcpy(dst, (void *)((long)dst + lcd_backdrop_offset),
492 width * sizeof(fb_data));
493 break;
494
495 case OPT_NONE:
496 dst_row = dst;
497 row_end = dst_row + width;
498 do
499 pfunc(dst_row++);
500 while (dst_row < row_end);
501 break;
502 }
503 dst += LCD_WIDTH;
504 }
505 while (dst < dst_end);
506 }
507
508 /* About Rockbox' internal monochrome bitmap format:
509 *
510 * A bitmap contains one bit for every pixel that defines if that pixel is
511 * black (1) or white (0). Bits within a byte are arranged vertically, LSB
512 * at top.
513 * The bytes are stored in row-major order, with byte 0 being top left,
514 * byte 1 2nd from left etc. The first row of bytes defines pixel rows
515 * 0..7, the second row defines pixel row 8..15 etc.
516 *
517 * This is the mono bitmap format used on all other targets so far; the
518 * pixel packing doesn't really matter on a 8bit+ target. */
519
520 /* Draw a partial monochrome bitmap */
521
522 void lcd_mono_bitmap_part(const unsigned char *src, int src_x, int src_y,
523 int stride, int x, int y, int width, int height)
524 ICODE_ATTR;
525 void lcd_mono_bitmap_part(const unsigned char *src, int src_x, int src_y,
526 int stride, int x, int y, int width, int height)
527 {
528 const unsigned char *src_end;
529 bool has_backdrop;
530 fb_data *dst, *dst_end, *backdrop;
531 lcd_fastpixelfunc_type *fgfunc, *bgfunc;
532
533 /* nothing to draw? */
534 if ((width <= 0) || (height <= 0) || (x >= LCD_WIDTH) || (y >= LCD_HEIGHT)
535 || (x + width <= 0) || (y + height <= 0))
536 return;
537
538 /* clipping */
539 if (x < 0)
540 {
541 width += x;
542 src_x -= x;
543 x = 0;
544 }
545 if (y < 0)
546 {
547 height += y;
548 src_y -= y;
549 y = 0;
550 }
551 if (x + width > LCD_WIDTH)
552 width = LCD_WIDTH - x;
553 if (y + height > LCD_HEIGHT)
554 height = LCD_HEIGHT - y;
555
556 src += stride * (src_y >> 3) + src_x; /* move starting point */
557 src_y &= 7;
558 src_end = src + width;
559
560 dst = LCDADDR(x, y);
561 has_backdrop = (lcd_backdrop != NULL);
562 backdrop = lcd_backdrop + y * LCD_WIDTH + x;
563 fgfunc = lcd_fastpixelfuncs[drawmode];
564 bgfunc = lcd_fastpixelfuncs[drawmode ^ DRMODE_INVERSEVID];
565 do
566 {
567 const unsigned char *src_col = src++;
568 unsigned data = *src_col >> src_y;
569 fb_data *dst_col = dst++;
570 int numbits = 8 - src_y;
571 fb_data *backdrop_col = backdrop++;
572 dst_end = dst_col + height * LCD_WIDTH;
573 do
574 {
575 switch (drawmode)
576 {
577 case DRMODE_SOLID:
578 if (data & 0x01)
579 *dst_col = fg_pattern;
580 else
581 *dst_col = has_backdrop ? *backdrop_col : bg_pattern;
582 break;
583 case DRMODE_FG:
584 if (data & 0x01)
585 *dst_col = fg_pattern;
586 break;
587 case (DRMODE_SOLID|DRMODE_INVERSEVID):
588 if (data & 0x01)
589 *dst_col = has_backdrop ? *backdrop_col : bg_pattern;
590 else
591 *dst_col = fg_pattern;
592 break;
593 default:
594 if (data & 0x01)
595 fgfunc(dst_col);
596 else
597 bgfunc(dst_col);
598 break;
599 }
600 dst_col += LCD_WIDTH;
601 backdrop_col += LCD_WIDTH;
602 data >>= 1;
603 if (--numbits == 0)
604 {
605 src_col += stride;
606 data = *src_col;
607 numbits = 8;
608 }
609 }
610 while (dst_col < dst_end);
611 }
612 while (src < src_end);
613 }
614 /* Draw a full monochrome bitmap */
615 void lcd_mono_bitmap(const unsigned char *src, int x, int y, int width, int height)
616 {
617 lcd_mono_bitmap_part(src, 0, 0, width, x, y, width, height);
618 }
619
620 /* Draw a partial native bitmap */
621 void lcd_bitmap_part(const fb_data *src, int src_x, int src_y,
622 int stride, int x, int y, int width, int height)
623 ICODE_ATTR;
624 void lcd_bitmap_part(const fb_data *src, int src_x, int src_y,
625 int stride, int x, int y, int width, int height)
626 {
627 fb_data *dst, *dst_end;
628
629 /* nothing to draw? */
630 if ((width <= 0) || (height <= 0) || (x >= LCD_WIDTH) || (y >= LCD_HEIGHT)
631 || (x + width <= 0) || (y + height <= 0))
632 return;
633
634 /* clipping */
635 if (x < 0)
636 {
637 width += x;
638 src_x -= x;
639 x = 0;
640 }
641 if (y < 0)
642 {
643 height += y;
644 src_y -= y;
645 y = 0;
646 }
647 if (x + width > LCD_WIDTH)
648 width = LCD_WIDTH - x;
649 if (y + height > LCD_HEIGHT)
650 height = LCD_HEIGHT - y;
651
652 src += stride * src_y + src_x; /* move starting point */
653 dst = LCDADDR(x, y);
654 dst_end = dst + height * LCD_WIDTH;
655
656 do
657 {
658 memcpy(dst, src, width * sizeof(fb_data));
659 src += stride;
660 dst += LCD_WIDTH;
661 }
662 while (dst < dst_end);
663 }
664
665 /* Draw a full native bitmap */
666 void lcd_bitmap(const fb_data *src, int x, int y, int width, int height)
667 {
668 lcd_bitmap_part(src, 0, 0, width, x, y, width, height);
669 }
670
671 #if !defined(TOSHIBA_GIGABEAT_F) || defined(SIMULATOR)
672 /* Draw a partial native bitmap */
673 void lcd_bitmap_transparent_part(const fb_data *src, int src_x, int src_y,
674 int stride, int x, int y, int width,
675 int height) ICODE_ATTR;
676 void lcd_bitmap_transparent_part(const fb_data *src, int src_x, int src_y,
677 int stride, int x, int y, int width,
678 int height)
679 {
680 fb_data *dst, *dst_end;
681
682 /* nothing to draw? */
683 if ((width <= 0) || (height <= 0) || (x >= LCD_WIDTH) || (y >= LCD_HEIGHT)
684 || (x + width <= 0) || (y + height <= 0))
685 return;
686
687 /* clipping */
688 if (x < 0)
689 {
690 width += x;
691 src_x -= x;
692 x = 0;
693 }
694 if (y < 0)
695 {
696 height += y;
697 src_y -= y;
698 y = 0;
699 }
700 if (x + width > LCD_WIDTH)
701 width = LCD_WIDTH - x;
702 if (y + height > LCD_HEIGHT)
703 height = LCD_HEIGHT - y;
704
705 src += stride * src_y + src_x; /* move starting point */
706 dst = LCDADDR(x, y);
707 dst_end = dst + height * LCD_WIDTH;
708
709 do
710 {
711 int i;
712 for(i = 0;i < width;i++)
713 {
714 if (src[i] == REPLACEWITHFG_COLOR)
715 dst[i] = fg_pattern;
716 else if(src[i] != TRANSPARENT_COLOR)
717 dst[i] = src[i];
718 }
719 src += stride;
720 dst += LCD_WIDTH;
721 }
722 while (dst < dst_end);
723 }
724 #endif /* !defined(TOSHIBA_GIGABEAT_F) || defined(SIMULATOR) */
725
726 /* Draw a full native bitmap with a transparent color */
727 void lcd_bitmap_transparent(const fb_data *src, int x, int y,
728 int width, int height)
729 {
730 lcd_bitmap_transparent_part(src, 0, 0, width, x, y, width, height);
731 }
732
733 /* put a string at a given pixel position, skipping first ofs pixel columns */
734 static void lcd_putsxyofs(int x, int y, int ofs, const unsigned char *str)
735 {
736 unsigned short ch;
737 unsigned short *ucs;
738 struct font* pf = font_get(curfont);
739
740 ucs = bidi_l2v(str, 1);
741
742 while ((ch = *ucs++) != 0 && x < LCD_WIDTH)
743 {
744 int width;
745 const unsigned char *bits;
746
747 /* get proportional width and glyph bits */
748 width = font_get_width(pf,ch);
749
750 if (ofs > width)
751 {
752 ofs -= width;
753 continue;
754 }
755
756 bits = font_get_bits(pf, ch);
757
758 lcd_mono_bitmap_part(bits, ofs, 0, width, x, y, width - ofs, pf->height);
759
760 x += width - ofs;
761 ofs = 0;
762 }
763 }
764
765 /* put a string at a given pixel position */
766 void lcd_putsxy(int x, int y, const unsigned char *str)
767 {
768 lcd_putsxyofs(x, y, 0, str);
769 }
770
771 /*** line oriented text output ***/
772
773 /* put a string at a given char position */
774 void lcd_puts(int x, int y, const unsigned char *str)
775 {
776 lcd_puts_style_offset(x, y, str, STYLE_DEFAULT, 0);
777 }
778
779 void lcd_puts_style(int x, int y, const unsigned char *str, int style)
780 {
781 lcd_puts_style_offset(x, y, str, style, 0);
782 }
783
784 void lcd_puts_offset(int x, int y, const unsigned char *str, int offset)
785 {
786 lcd_puts_style_offset(x, y, str, STYLE_DEFAULT, offset);
787 }
788
789 /* put a string at a given char position, style, and pixel position,
790 * skipping first offset pixel columns */
791 void lcd_puts_style_offset(int x, int y, const unsigned char *str, int style,
792 int offset)
793 {
794 int xpos,ypos,w,h,xrect;
795 int lastmode = drawmode;
796 int oldfgcolor = fg_pattern;
797 int oldbgcolor = bg_pattern;
798
799 /* make sure scrolling is turned off on the line we are updating */
800 lcd_scroll_info.lines &= ~(1 << y);
801
802 if(!str || !str[0])
803 return;
804
805 lcd_getstringsize(str, &w, &h);
806 xpos = xmargin + x*w / utf8length(str);
807 ypos = ymargin + y*h;
808 drawmode = (style & STYLE_INVERT) ?
809 (DRMODE_SOLID|DRMODE_INVERSEVID) : DRMODE_SOLID;
810 if (style & STYLE_COLORED) {
811 if (drawmode == DRMODE_SOLID)
812 fg_pattern = style & STYLE_COLOR_MASK;
813 else
814 bg_pattern = style & STYLE_COLOR_MASK;
815 }
816 lcd_putsxyofs(xpos, ypos, offset, str);
817 drawmode ^= DRMODE_INVERSEVID;
818 xrect = xpos + MAX(w - offset, 0);
819 lcd_fillrect(xrect, ypos, LCD_WIDTH - xrect, h);
820 drawmode = lastmode;
821 fg_pattern = oldfgcolor;
822 bg_pattern = oldbgcolor;
823 }
824
825 /*** scrolling ***/
826 void lcd_puts_scroll(int x, int y, const unsigned char *string)
827 {
828 lcd_puts_scroll_style(x, y, string, STYLE_DEFAULT);
829 }
830
831 void lcd_puts_scroll_style(int x, int y, const unsigned char *string, int style)
832 {
833 lcd_puts_scroll_style_offset(x, y, string, style, 0);
834 }
835
836 void lcd_puts_scroll_offset(int x, int y, const unsigned char *string, int offset)
837 {
838 lcd_puts_scroll_style_offset(x, y, string, STYLE_DEFAULT, offset);
839 }
840
841 void lcd_puts_scroll_style_offset(int x, int y, const unsigned char *string,
842 int style, int offset)
843 {
844 struct scrollinfo* s;
845 int w, h;
846
847 if(y>=LCD_SCROLLABLE_LINES) return;
848
849 s = &lcd_scroll_info.scroll[y];
850
851 s->start_tick = current_tick + lcd_scroll_info.delay;
852 s->invert = false;
853 if (style & STYLE_INVERT) {
854 s->invert = true;
855 }
856 lcd_puts_style_offset(x,y,string,style,offset);
857
858 lcd_getstringsize(string, &w, &h);
859
860 if (LCD_WIDTH - x * 8 - xmargin < w) {
861 /* prepare scroll line */
862 char *end;
863
864 memset(s->line, 0, sizeof s->line);
865 strcpy(s->line, string);
866
867 /* get width */
868 s->width = lcd_getstringsize(s->line, &w, &h);
869
870 /* scroll bidirectional or forward only depending on the string
871 width */
872 if ( lcd_scroll_info.bidir_limit ) {
873 s->bidir = s->width < (LCD_WIDTH - xmargin) *
874 (100 + lcd_scroll_info.bidir_limit) / 100;
875 }
876 else
877 s->bidir = false;
878
879 if (!s->bidir) { /* add spaces if scrolling in the round */
880 strcat(s->line, " ");
881 /* get new width incl. spaces */
882 s->width = lcd_getstringsize(s->line, &w, &h);
883 }
884
885 end = strchr(s->line, '\0');
886 strncpy(end, string, LCD_WIDTH/2);
887
888 s->len = utf8length(string);
889 s->offset = offset;
890 s->startx = xmargin + x * s->width / s->len;
891 s->backward = false;
892 s->line_color = (style&STYLE_COLORED)?
893 (style&STYLE_COLOR_MASK): -1;
894 lcd_scroll_info.lines |= (1<<y);
895 }
896 else
897 /* force a bit switch-off since it doesn't scroll */
898 lcd_scroll_info.lines &= ~(1<<y);
899 }
900
901 void lcd_scroll_fn(void)
902 {
903 struct font* pf;
904 struct scrollinfo* s;
905 int index;
906 int xpos, ypos;
907 int lastmode;
908 unsigned old_fgcolor = fg_pattern;
909 unsigned old_bgcolor = bg_pattern;
910
911 for ( index = 0; index < LCD_SCROLLABLE_LINES; index++ ) {
912 /* really scroll? */
913 if ((lcd_scroll_info.lines & (1 << index)) == 0)
914 continue;
915
916 s = &lcd_scroll_info.scroll[index];
917
918 /* check pause */
919 if (TIME_BEFORE(current_tick, s->start_tick))
920 continue;
921
922 if (s->line_color >= 0) {
923 if (s->invert) {
924 fg_pattern = old_fgcolor;
925 bg_pattern = s->line_color;
926 }
927 else {
928 fg_pattern = s->line_color;
929 bg_pattern = old_bgcolor;
930 }
931 }
932
933 if (s->backward)
934 s->offset -= lcd_scroll_info.step;
935 else
936 s->offset += lcd_scroll_info.step;
937
938 pf = font_get(curfont);
939 xpos = s->startx;
940 ypos = ymargin + index * pf->height;
941
942 if (s->bidir) { /* scroll bidirectional */
943 if (s->offset <= 0) {
944 /* at beginning of line */
945 s->offset = 0;
946 s->backward = false;
947 s->start_tick = current_tick + lcd_scroll_info.delay * 2;
948 }
949 if (s->offset >= s->width - (LCD_WIDTH - xpos)) {
950 /* at end of line */
951 s->offset = s->width - (LCD_WIDTH - xpos);
952 s->backward = true;
953 s->start_tick = current_tick + lcd_scroll_info.delay * 2;
954 }
955 }
956 else {
957 /* scroll forward the whole time */
958 if (s->offset >= s->width)
959 s->offset %= s->width;
960 }
961
962 lastmode = drawmode;
963 drawmode = s->invert ?
964 (DRMODE_SOLID|DRMODE_INVERSEVID) : DRMODE_SOLID;
965 lcd_putsxyofs(xpos, ypos, s->offset, s->line);
966 drawmode = lastmode;
967 lcd_update_rect(xpos, ypos, LCD_WIDTH - xpos, pf->height);
968 }
969
970 fg_pattern = old_fgcolor;
971 bg_pattern = old_bgcolor;
972 }
Open Source Jukebox Firmware