diff options
author | Dan Everton <dan@iocaine.org> | 2006-08-12 10:28:30 +0000 |
---|---|---|
committer | Dan Everton <dan@iocaine.org> | 2006-08-12 10:28:30 +0000 |
commit | 9d2929b79b22765701e9db240d967877d7f7bab8 (patch) | |
tree | 0829913b3e58ce5d1886358395d42c5cee80ce6c /uisimulator/x11/lcd-x11.c | |
parent | 509ee3d42cfe0660a107ae169a11cef9c0604b1f (diff) | |
download | rockbox-9d2929b79b22765701e9db240d967877d7f7bab8.tar.gz rockbox-9d2929b79b22765701e9db240d967877d7f7bab8.zip |
Remove Win32 and X11 simulator sources. They've been deprecated for a while in favour of the SDL sim. Time to go.
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@10543 a1c6a512-1295-4272-9138-f99709370657
Diffstat (limited to 'uisimulator/x11/lcd-x11.c')
-rw-r--r-- | uisimulator/x11/lcd-x11.c | 262 |
1 files changed, 0 insertions, 262 deletions
diff --git a/uisimulator/x11/lcd-x11.c b/uisimulator/x11/lcd-x11.c deleted file mode 100644 index c85848c18b..0000000000 --- a/uisimulator/x11/lcd-x11.c +++ /dev/null | |||
@@ -1,262 +0,0 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id$ | ||
9 | * | ||
10 | * Copyright (C) 2002 by Daniel Stenberg <daniel@haxx.se> | ||
11 | * | ||
12 | * All files in this archive are subject to the GNU General Public License. | ||
13 | * See the file COPYING in the source tree root for full license agreement. | ||
14 | * | ||
15 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
16 | * KIND, either express or implied. | ||
17 | * | ||
18 | ****************************************************************************/ | ||
19 | |||
20 | #include <stdio.h> | ||
21 | #include <string.h> | ||
22 | #include <stdarg.h> | ||
23 | #include <stdlib.h> | ||
24 | #include <ctype.h> | ||
25 | #include <sys/types.h> | ||
26 | #include <sys/stat.h> | ||
27 | #include <fcntl.h> | ||
28 | |||
29 | #include <errno.h> | ||
30 | #include <ctype.h> | ||
31 | #include <time.h> | ||
32 | |||
33 | #include "screenhack.h" | ||
34 | #include "config.h" | ||
35 | #include "debug.h" | ||
36 | |||
37 | /* | ||
38 | * Specific implementations for X11, using the generic LCD API and data. | ||
39 | */ | ||
40 | |||
41 | #include "lcd-x11.h" | ||
42 | #include "lcd-playersim.h" | ||
43 | |||
44 | #if LCD_DEPTH == 2 | ||
45 | #define YBLOCK 4 | ||
46 | #define ANDBIT 3 /* AND with this to get the color number */ | ||
47 | #else | ||
48 | #define YBLOCK 8 | ||
49 | #define ANDBIT 1 | ||
50 | #endif | ||
51 | |||
52 | extern void screen_resized(int width, int height); | ||
53 | extern bool lcd_display_redraw; | ||
54 | |||
55 | #ifdef HAVE_LCD_BITMAP | ||
56 | #if LCD_DEPTH==16 | ||
57 | fb_data lcd_framebuffer_copy[LCD_HEIGHT][LCD_WIDTH*2]; | ||
58 | #else | ||
59 | fb_data lcd_framebuffer_copy[LCD_HEIGHT/YBLOCK][LCD_WIDTH]; | ||
60 | #endif | ||
61 | |||
62 | void lcd_update (void) | ||
63 | { | ||
64 | /* update a full screen rect */ | ||
65 | lcd_update_rect(0, 0, LCD_WIDTH, LCD_HEIGHT); | ||
66 | } | ||
67 | |||
68 | void lcd_update_rect(int x_start, int y_start, | ||
69 | int width, int height) | ||
70 | { | ||
71 | int x; | ||
72 | int yline=y_start; | ||
73 | int y; | ||
74 | int p=0; | ||
75 | int bit; | ||
76 | int xmax; | ||
77 | int ymax; | ||
78 | int colors[LCD_WIDTH * LCD_HEIGHT]; | ||
79 | struct coordinate points[LCD_WIDTH * LCD_HEIGHT]; | ||
80 | unsigned force_mask = lcd_display_redraw ? 0xFF : 0; | ||
81 | |||
82 | #if 0 | ||
83 | fprintf(stderr, "%04d: lcd_update_rect(%d, %d, %d, %d)\n", | ||
84 | counter++, x_start, y_start, width, height); | ||
85 | #endif | ||
86 | /* The Y coordinates have to work on even YBLOCK pixel rows */ | ||
87 | ymax = (yline + height)/YBLOCK; | ||
88 | yline /= YBLOCK; | ||
89 | |||
90 | xmax = x_start + width; | ||
91 | |||
92 | if(xmax > LCD_WIDTH) | ||
93 | xmax = LCD_WIDTH; | ||
94 | if(ymax >= LCD_HEIGHT/YBLOCK) | ||
95 | ymax = LCD_HEIGHT/YBLOCK-1; | ||
96 | |||
97 | for(; yline <= ymax; yline++) { | ||
98 | y = yline * YBLOCK; | ||
99 | for(x = x_start; x < xmax; x++) { | ||
100 | unsigned char diff = (lcd_framebuffer[yline][x] | ||
101 | ^ lcd_framebuffer_copy[yline][x]) | ||
102 | | force_mask; | ||
103 | if(diff) { | ||
104 | /* one or more bits/pixels are changed */ | ||
105 | unsigned char mask = ANDBIT; | ||
106 | for(bit = 0; bit < YBLOCK; bit++) { | ||
107 | if(diff & mask) { | ||
108 | /* pixel has changed */ | ||
109 | unsigned int col = lcd_framebuffer[yline][x] & mask; | ||
110 | #if LCD_DEPTH == 2 | ||
111 | colors[p] = col >> (bit * LCD_DEPTH); | ||
112 | #else | ||
113 | colors[p] = col ? 3 : 0; | ||
114 | #endif | ||
115 | points[p].x = x + MARGIN_X; | ||
116 | points[p].y = y + bit + MARGIN_Y; | ||
117 | p++; /* increase the point counter */ | ||
118 | } | ||
119 | mask <<= LCD_DEPTH; | ||
120 | } | ||
121 | |||
122 | /* update the copy */ | ||
123 | lcd_framebuffer_copy[yline][x] = lcd_framebuffer[yline][x]; | ||
124 | } | ||
125 | } | ||
126 | } | ||
127 | |||
128 | dots(colors, &points[0], p); | ||
129 | /* printf("lcd_update_rect: Draws %d pixels, clears %d pixels\n", p, cp);*/ | ||
130 | XtAppLock(app); | ||
131 | XSync(dpy,False); | ||
132 | XtAppUnlock(app); | ||
133 | lcd_display_redraw=false; | ||
134 | } | ||
135 | |||
136 | #ifdef LCD_REMOTE_HEIGHT | ||
137 | extern unsigned char lcd_remote_framebuffer[LCD_REMOTE_HEIGHT/8][LCD_REMOTE_WIDTH]; | ||
138 | unsigned char lcd_remote_framebuffer_copy[LCD_REMOTE_HEIGHT/8][LCD_REMOTE_WIDTH]; | ||
139 | |||
140 | #define REMOTE_START_Y (LCD_HEIGHT + 2*MARGIN_Y) | ||
141 | |||
142 | void lcd_remote_update (void) | ||
143 | { | ||
144 | lcd_remote_update_rect(0, 0, LCD_REMOTE_WIDTH, LCD_REMOTE_HEIGHT); | ||
145 | } | ||
146 | |||
147 | void lcd_remote_update_rect(int x_start, int y_start, | ||
148 | int width, int height) | ||
149 | { | ||
150 | int x; | ||
151 | int yline=y_start; | ||
152 | int y; | ||
153 | int p=0; | ||
154 | int bit; | ||
155 | int xmax; | ||
156 | int ymax; | ||
157 | struct coordinate points[LCD_REMOTE_WIDTH * LCD_REMOTE_HEIGHT]; | ||
158 | int colors[LCD_REMOTE_WIDTH * LCD_REMOTE_HEIGHT]; | ||
159 | unsigned force_mask = lcd_display_redraw ? 0xFF : 0; | ||
160 | |||
161 | #if 0 | ||
162 | fprintf(stderr, "%04d: lcd_update_rect(%d, %d, %d, %d)\n", | ||
163 | counter++, x_start, y_start, width, height); | ||
164 | #endif | ||
165 | /* The Y coordinates have to work on even 8 pixel rows */ | ||
166 | ymax = (yline + height)/8; | ||
167 | yline /= 8; | ||
168 | |||
169 | xmax = x_start + width; | ||
170 | |||
171 | if(xmax > LCD_REMOTE_WIDTH) | ||
172 | xmax = LCD_REMOTE_WIDTH; | ||
173 | if(ymax >= LCD_REMOTE_HEIGHT/8) | ||
174 | ymax = LCD_REMOTE_HEIGHT/8-1; | ||
175 | |||
176 | for(; yline <= ymax; yline++) { | ||
177 | y = yline * 8; | ||
178 | for(x = x_start; x < xmax; x++) { | ||
179 | unsigned char diff = (lcd_remote_framebuffer[yline][x] | ||
180 | ^ lcd_remote_framebuffer_copy[yline][x]) | ||
181 | | force_mask; | ||
182 | if(diff) { | ||
183 | unsigned char mask = 1; | ||
184 | for(bit = 0; bit < 8; bit++) { | ||
185 | if(diff & mask) { | ||
186 | unsigned int col = lcd_remote_framebuffer[yline][x] & mask; | ||
187 | colors[p] = col ? 3 : 0; | ||
188 | points[p].x = x + MARGIN_X; | ||
189 | points[p].y = y + bit + (REMOTE_START_Y + MARGIN_Y); | ||
190 | p++; /* increase the point counter */ | ||
191 | } | ||
192 | mask <<= 1; | ||
193 | } | ||
194 | |||
195 | /* update the copy */ | ||
196 | lcd_remote_framebuffer_copy[yline][x] = | ||
197 | lcd_remote_framebuffer[yline][x]; | ||
198 | } | ||
199 | } | ||
200 | } | ||
201 | |||
202 | dots(colors, &points[0], p); | ||
203 | /* printf("lcd_update_rect: Draws %d pixels, clears %d pixels\n", p, cp);*/ | ||
204 | XtAppLock(app); | ||
205 | XSync(dpy,False); | ||
206 | XtAppUnlock(app); | ||
207 | lcd_display_redraw=false; | ||
208 | } | ||
209 | |||
210 | |||
211 | #endif | ||
212 | |||
213 | #endif | ||
214 | #ifdef HAVE_LCD_CHARCELLS | ||
215 | |||
216 | /* Defined in lcd-playersim.c */ | ||
217 | extern void lcd_print_char(int x, int y); | ||
218 | extern unsigned char lcd_buffer[2][11]; | ||
219 | extern void drawrect(int color, int x1, int y1, int x2, int y2); | ||
220 | |||
221 | extern unsigned char hardware_buffer_lcd[11][2]; | ||
222 | static unsigned char lcd_buffer_copy[11][2]; | ||
223 | |||
224 | void lcd_update (void) | ||
225 | { | ||
226 | bool changed=false; | ||
227 | int x, y; | ||
228 | for (y=0; y<2; y++) { | ||
229 | for (x=0; x<11; x++) { | ||
230 | if (lcd_display_redraw || | ||
231 | lcd_buffer_copy[x][y] != hardware_buffer_lcd[x][y]) { | ||
232 | lcd_buffer_copy[x][y] = hardware_buffer_lcd[x][y]; | ||
233 | lcd_print_char(x, y); | ||
234 | changed=true; | ||
235 | } | ||
236 | } | ||
237 | } | ||
238 | if (changed) | ||
239 | { | ||
240 | XtAppLock(app); | ||
241 | XSync(dpy,False); | ||
242 | XtAppUnlock(app); | ||
243 | } | ||
244 | lcd_display_redraw=false; | ||
245 | } | ||
246 | |||
247 | #endif | ||
248 | |||
249 | #ifdef CONFIG_BACKLIGHT | ||
250 | void sim_backlight(int value) | ||
251 | { | ||
252 | DEBUGF("backlight: %s\n", (value > 0) ? "on" : "off"); | ||
253 | } | ||
254 | #endif | ||
255 | |||
256 | #ifdef HAVE_REMOTE_LCD | ||
257 | void sim_remote_backlight(int value) | ||
258 | { | ||
259 | DEBUGF("remote backlight: %s\n", (value > 0) ? "on" : "off"); | ||
260 | } | ||
261 | #endif | ||
262 | |||