]>
Commit | Line | Data |
---|---|---|
6a5fa4e0 MG |
1 | /* w_x.c: X Window System support |
2 | * | |
3 | * Micropolis, Unix Version. This game was released for the Unix platform | |
4 | * in or about 1990 and has been modified for inclusion in the One Laptop | |
5 | * Per Child program. Copyright (C) 1989 - 2007 Electronic Arts Inc. If | |
6 | * you need assistance with this program, you may contact: | |
7 | * http://wiki.laptop.org/go/Micropolis or email micropolis@laptop.org. | |
8 | * | |
9 | * This program is free software: you can redistribute it and/or modify | |
10 | * it under the terms of the GNU General Public License as published by | |
11 | * the Free Software Foundation, either version 3 of the License, or (at | |
12 | * your option) any later version. | |
13 | * | |
14 | * This program is distributed in the hope that it will be useful, but | |
15 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
17 | * General Public License for more details. You should have received a | |
18 | * copy of the GNU General Public License along with this program. If | |
19 | * not, see <http://www.gnu.org/licenses/>. | |
20 | * | |
21 | * ADDITIONAL TERMS per GNU GPL Section 7 | |
22 | * | |
23 | * No trademark or publicity rights are granted. This license does NOT | |
24 | * give you any right, title or interest in the trademark SimCity or any | |
25 | * other Electronic Arts trademark. You may not distribute any | |
26 | * modification of this program using the trademark SimCity or claim any | |
27 | * affliation or association with Electronic Arts Inc. or its employees. | |
28 | * | |
29 | * Any propagation or conveyance of this program must include this | |
30 | * copyright notice and these terms. | |
31 | * | |
32 | * If you convey this program (or any modifications of it) and assume | |
33 | * contractual liability for the program to recipients of it, you agree | |
34 | * to indemnify Electronic Arts for any liability that those contractual | |
35 | * assumptions impose on Electronic Arts. | |
36 | * | |
37 | * You may not misrepresent the origins of this program; modified | |
38 | * versions of the program must be marked as such and not identified as | |
39 | * the original program. | |
40 | * | |
41 | * This disclaimer supplements the one included in the General Public | |
42 | * License. TO THE FULLEST EXTENT PERMISSIBLE UNDER APPLICABLE LAW, THIS | |
43 | * PROGRAM IS PROVIDED TO YOU "AS IS," WITH ALL FAULTS, WITHOUT WARRANTY | |
44 | * OF ANY KIND, AND YOUR USE IS AT YOUR SOLE RISK. THE ENTIRE RISK OF | |
45 | * SATISFACTORY QUALITY AND PERFORMANCE RESIDES WITH YOU. ELECTRONIC ARTS | |
46 | * DISCLAIMS ANY AND ALL EXPRESS, IMPLIED OR STATUTORY WARRANTIES, | |
47 | * INCLUDING IMPLIED WARRANTIES OF MERCHANTABILITY, SATISFACTORY QUALITY, | |
48 | * FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT OF THIRD PARTY | |
49 | * RIGHTS, AND WARRANTIES (IF ANY) ARISING FROM A COURSE OF DEALING, | |
50 | * USAGE, OR TRADE PRACTICE. ELECTRONIC ARTS DOES NOT WARRANT AGAINST | |
51 | * INTERFERENCE WITH YOUR ENJOYMENT OF THE PROGRAM; THAT THE PROGRAM WILL | |
52 | * MEET YOUR REQUIREMENTS; THAT OPERATION OF THE PROGRAM WILL BE | |
53 | * UNINTERRUPTED OR ERROR-FREE, OR THAT THE PROGRAM WILL BE COMPATIBLE | |
54 | * WITH THIRD PARTY SOFTWARE OR THAT ANY ERRORS IN THE PROGRAM WILL BE | |
55 | * CORRECTED. NO ORAL OR WRITTEN ADVICE PROVIDED BY ELECTRONIC ARTS OR | |
56 | * ANY AUTHORIZED REPRESENTATIVE SHALL CREATE A WARRANTY. SOME | |
57 | * JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF OR LIMITATIONS ON IMPLIED | |
58 | * WARRANTIES OR THE LIMITATIONS ON THE APPLICABLE STATUTORY RIGHTS OF A | |
59 | * CONSUMER, SO SOME OR ALL OF THE ABOVE EXCLUSIONS AND LIMITATIONS MAY | |
60 | * NOT APPLY TO YOU. | |
61 | */ | |
62 | #include "sim.h" | |
63 | ||
64 | ||
65 | struct XDisplay *XDisplays = NULL; | |
66 | int DisplayCount = 0; | |
67 | #ifdef IS_LINUX | |
68 | int FlushStyle = 3; | |
69 | #else | |
70 | int FlushStyle = 4; | |
71 | #endif | |
72 | int GotXError; | |
73 | ||
74 | ||
75 | unsigned char ColorIntensities[] = { | |
76 | /* COLOR_WHITE */ 255, | |
77 | /* COLOR_YELLOW */ 170, | |
78 | /* COLOR_ORANGE */ 127, | |
79 | /* COLOR_RED */ 85, | |
80 | /* COLOR_DARKRED */ 63, | |
81 | /* COLOR_DARKBLUE */ 76, | |
82 | /* COLOR_LIGHTBLUE */ 144, | |
83 | /* COLOR_BROWN */ 118, | |
84 | /* COLOR_LIGHTGREEN */ 76, | |
85 | /* COLOR_DARKGREEN */ 42, | |
86 | /* COLOR_OLIVE */ 118, | |
87 | /* COLOR_LIGHTBROWN */ 144, | |
88 | /* COLOR_LIGHTGRAY */ 191, | |
89 | /* COLOR_MEDIUMGRAY */ 127, | |
90 | /* COLOR_DARKGRAY */ 63, | |
91 | /* COLOR_BLACK */ 0, | |
92 | }; | |
93 | ||
94 | ||
95 | ViewToTileCoords(SimView *view, int x, int y, int *outx, int *outy) | |
96 | { | |
97 | x = (view->pan_x - ((view->w_width >>1) - x)) >>4; | |
98 | y = (view->pan_y - ((view->w_height >>1) - y)) >>4; | |
99 | ||
100 | if (x < 0) x = 0; | |
101 | if (x >= WORLD_X) x = WORLD_X - 1; | |
102 | if (y < 0) y = 0; | |
103 | if (y >= WORLD_Y) y = WORLD_Y - 1; | |
104 | ||
105 | if (x < view->tile_x) | |
106 | x = view->tile_x; | |
107 | if (x >= view->tile_x + view->tile_width) | |
108 | x = view->tile_x + view->tile_width - 1; | |
109 | if (y < view->tile_y) | |
110 | y = view->tile_y; | |
111 | if (y >= view->tile_y + view->tile_height) | |
112 | y = view->tile_y + view->tile_height - 1; | |
113 | ||
114 | if (view->tool_x_const != -1) | |
115 | x = view->tool_x_const; | |
116 | if (view->tool_y_const != -1) | |
117 | y = view->tool_y_const; | |
118 | ||
119 | *outx = x; *outy = y; | |
120 | } | |
121 | ||
122 | ||
123 | ViewToPixelCoords(SimView *view, int x, int y, int *outx, int *outy) | |
124 | { | |
125 | x = view->pan_x - ((view->w_width >>1) - x); | |
126 | y = view->pan_y - ((view->w_height >>1) - y); | |
127 | ||
128 | if (x < 0) x = 0; | |
129 | if (x >= (WORLD_X <<4)) x = (WORLD_X <<4) - 1; | |
130 | if (y < 0) y = 0; | |
131 | if (y >= (WORLD_Y <<4)) y = (WORLD_Y <<4) - 1; | |
132 | ||
133 | if (x < (view->tile_x <<4)) | |
134 | x = (view->tile_x <<4); | |
135 | if (x >= ((view->tile_x + view->tile_width) <<4)) | |
136 | x = ((view->tile_x + view->tile_width) <<4) - 1; | |
137 | if (y < (view->tile_y <<4)) | |
138 | y = (view->tile_y <<4); | |
139 | if (y >= ((view->tile_y + view->tile_height) <<4)) | |
140 | y = ((view->tile_y + view->tile_height) <<4) - 1; | |
141 | ||
142 | if (view->tool_x_const != -1) | |
143 | x = (view->tool_x_const <<4) + 8; | |
144 | if (view->tool_y_const != -1) | |
145 | y = (view->tool_y_const <<4) + 8; | |
146 | ||
147 | *outx = x; *outy = y; | |
148 | } | |
149 | ||
150 | ||
151 | UpdateFlush() | |
152 | { | |
153 | struct XDisplay *xd; | |
154 | ||
155 | if (sim_skips > 0) { | |
156 | if (sim_skip > 0) { | |
157 | sim_skip--; | |
158 | return; | |
159 | } | |
160 | sim_skip = sim_skips; | |
161 | } | |
162 | ||
163 | switch (FlushStyle) { | |
164 | ||
165 | case 0: | |
166 | break; | |
167 | ||
168 | case 1: | |
169 | for (xd = XDisplays; xd != NULL; xd = xd->next) | |
170 | XFlush(xd->dpy); | |
171 | break; | |
172 | ||
173 | case 2: | |
174 | for (xd = XDisplays; xd != NULL; xd = xd->next) | |
175 | XSync(xd->dpy, False); | |
176 | break; | |
177 | ||
178 | case 3: | |
179 | if (XDisplays && XDisplays->next) { | |
180 | for (xd = XDisplays; xd != NULL; xd = xd->next) { | |
181 | XFlush(xd->dpy); | |
182 | } | |
183 | } | |
184 | for (xd = XDisplays; xd != NULL; xd = xd->next) { | |
185 | XSync(xd->dpy, False); | |
186 | } | |
187 | break; | |
188 | ||
189 | case 4: | |
190 | for (xd = XDisplays; xd != NULL; xd = xd->next) { | |
191 | #ifndef IS_LINUX | |
192 | /* XXX TODO: figure this out for linux and new x libs */ | |
193 | if ((xd->request != xd->dpy->request) || | |
194 | (xd->last_request_read != xd->dpy->last_request_read)) { | |
195 | XSync(xd->dpy, False); | |
196 | xd->request = xd->dpy->request; | |
197 | xd->last_request_read = xd->dpy->last_request_read; | |
198 | } | |
199 | #endif | |
200 | } | |
201 | break; | |
202 | ||
203 | } | |
204 | } | |
205 | ||
206 | ||
207 | int | |
208 | CatchXError(Display *dpy, XErrorEvent *err) | |
209 | { | |
210 | GotXError = 1; | |
211 | #if 0 | |
212 | printf("GOT X ERROR code %d request code %d %d\n", | |
213 | err->error_code, err->request_code, err->minor_code); | |
214 | #endif | |
215 | return (0); | |
216 | } | |
217 | ||
218 | ||
219 | DoStopMicropolis() | |
220 | { | |
221 | (void)XSetErrorHandler(CatchXError); | |
222 | ||
223 | StopToolkit(); | |
224 | ||
225 | if (sim) { | |
226 | while (sim->editor != NULL) { | |
227 | DestroyView(sim->editor); | |
228 | } | |
229 | ||
230 | while (sim->map != NULL) { | |
231 | DestroyView(sim->map); | |
232 | } | |
233 | ||
234 | while (sim->graph != NULL) { | |
235 | DestroyGraph(sim->graph); | |
236 | } | |
237 | ||
238 | #ifdef CAM | |
239 | while (sim->scam != NULL) { | |
240 | DestroyCam(sim->scam); | |
241 | } | |
242 | #endif | |
243 | } | |
244 | } | |
245 | ||
246 | ||
247 | DoTimeoutListen() | |
248 | { | |
249 | while (Tk_DoOneEvent(TK_DONT_WAIT)) ; | |
250 | } | |
251 | ||
252 | ||
253 | Sim * | |
254 | MakeNewSim() | |
255 | { | |
256 | Sim *sim; | |
257 | ||
258 | sim = (Sim *)ckalloc(sizeof(Sim)); | |
259 | sim->editors = 0; sim->editor = NULL; | |
260 | sim->maps = 0; sim->map = NULL; | |
261 | sim->graphs = 0; sim->graph = NULL; | |
262 | sim->sprites = 0; sim->sprite = NULL; | |
263 | #ifdef CAM | |
264 | sim->scams = 0; sim->scam = NULL; | |
265 | #endif | |
266 | sim->overlay = NULL; | |
267 | ||
268 | return (sim); | |
269 | } | |
270 | ||
271 | ||
272 | XDisplay * | |
273 | FindXDisplay(Tk_Window tkwin) | |
274 | { | |
275 | XDisplay *xd; | |
276 | int d = 8; | |
277 | unsigned long valuemask = 0; | |
278 | XGCValues values; | |
279 | XColor rgb, *color; | |
280 | Display *dpy = Tk_Display(tkwin); | |
281 | Screen *screen = Tk_Screen(tkwin); | |
282 | #ifdef IS_LINUX | |
283 | char *display = ":0"; /* XXX TODO: fix this for new x libs */ | |
284 | #else | |
285 | char *display = dpy->display_name; | |
286 | #endif | |
287 | ||
288 | for (xd = XDisplays; | |
289 | xd && (xd->screen != screen); | |
290 | xd = xd->next) ; | |
291 | ||
292 | if (xd != NULL) { | |
293 | return (xd); | |
294 | } else { | |
295 | xd = (struct XDisplay *)ckalloc(sizeof (struct XDisplay)); | |
296 | ||
297 | xd->references = 0; | |
298 | xd->dpy = dpy; | |
299 | xd->display = (char *)ckalloc(strlen(display) + 1); | |
300 | xd->tkDisplay = ((TkWindow *)tkwin)->dispPtr; | |
301 | strcpy(xd->display, display); | |
302 | xd->screen = screen; | |
303 | xd->root = RootWindowOfScreen(xd->screen); | |
304 | ||
305 | xd->visual = Tk_DefaultVisual(xd->screen); | |
306 | xd->depth = Tk_DefaultDepth(xd->screen); | |
307 | xd->colormap = Tk_DefaultColormap(xd->screen); | |
308 | ||
309 | xd->color = (xd->depth != 1); | |
310 | ||
311 | xd->pixels = (int *)ckalloc(16 * sizeof(int)); | |
312 | if (xd->color) { /* Color screen */ | |
313 | int GotColor = 1; | |
314 | ||
315 | #define GETCOLOR(i, name) \ | |
316 | if (!GotColor) { \ | |
317 | xd->pixels[i] = Rand16() & 255; \ | |
318 | } else { \ | |
319 | if ((color = Tk_GetColor(tk_mainInterp, tkwin, \ | |
320 | None, name)) == NULL) { \ | |
321 | xd->pixels[i] = Rand16() & 255; \ | |
322 | GotColor = 0; \ | |
323 | } else { \ | |
324 | switch (xd->depth) { \ | |
325 | case 8: \ | |
326 | xd->pixels[i] = \ | |
327 | color->pixel; \ | |
328 | break; \ | |
329 | case 15: \ | |
330 | xd->pixels[i] = \ | |
331 | (((color->red >> (8 + 3)) & 0x1f) << (5 + 5)) | \ | |
332 | (((color->green >> (8 + 2)) & 0x1f) << (5)) | \ | |
333 | (((color->blue >> (8 + 3)) & 0x1f) << (0)); \ | |
334 | break; \ | |
335 | case 16: \ | |
336 | xd->pixels[i] = \ | |
337 | (((color->red >> (8 + 3)) & 0x1f) << (6 + 5)) | \ | |
338 | (((color->green >> (8 + 2)) & 0x3f) << (5)) | \ | |
339 | (((color->blue >> (8 + 3)) & 0x1f) << (0)); \ | |
340 | break; \ | |
341 | case 24: \ | |
342 | xd->pixels[i] = \ | |
343 | ((color->red & 0xff) << 16) | \ | |
344 | ((color->green & 0xff) << 8) | \ | |
345 | ((color->blue & 0xff) << 0); \ | |
346 | break; \ | |
347 | case 32: \ | |
348 | xd->pixels[i] = \ | |
349 | ((color->red & 0xff) << 16) | \ | |
350 | ((color->green & 0xff) << 8) | \ | |
351 | ((color->blue & 0xff) << 0); \ | |
352 | break; \ | |
353 | } \ | |
354 | } \ | |
355 | } | |
356 | ||
357 | if ((xd->depth == 8) && | |
358 | (Tk_DefaultColormap(xd->screen) == | |
359 | DefaultColormapOfScreen(xd->screen))) { | |
360 | xd->pixels[COLOR_WHITE] = WhitePixelOfScreen(xd->screen); | |
361 | xd->pixels[COLOR_BLACK] = BlackPixelOfScreen(xd->screen); | |
362 | } else { | |
363 | GETCOLOR(COLOR_WHITE, "#ffffff"); | |
364 | GETCOLOR(COLOR_BLACK, "#000000"); | |
365 | } | |
366 | ||
367 | GETCOLOR(COLOR_YELLOW, "#ffff00"); | |
368 | GETCOLOR(COLOR_ORANGE, "#ff7f00"); | |
369 | GETCOLOR(COLOR_RED, "#ff0000"); | |
370 | GETCOLOR(COLOR_DARKRED, "#bf0000"); | |
371 | GETCOLOR(COLOR_DARKBLUE, "#0000e6"); | |
372 | GETCOLOR(COLOR_LIGHTBLUE, "#6666e6"); | |
373 | GETCOLOR(COLOR_BROWN, "#cc4c4c"); | |
374 | GETCOLOR(COLOR_LIGHTGREEN, "#00e600"); | |
375 | GETCOLOR(COLOR_DARKGREEN, "#007f00"); | |
376 | GETCOLOR(COLOR_OLIVE, "#997f4c"); | |
377 | GETCOLOR(COLOR_LIGHTBROWN, "#cc7f66"); | |
378 | GETCOLOR(COLOR_LIGHTGRAY, "#bfbfbf"); | |
379 | GETCOLOR(COLOR_MEDIUMGRAY, "#7f7f7f"); | |
380 | GETCOLOR(COLOR_DARKGRAY, "#3f3f3f"); | |
381 | ||
382 | if (!GotColor) { | |
383 | fprintf(stderr, | |
384 | "Oh, dear. There don't seem to be enough free colors on X display \"%s\".\n", | |
385 | xd->display); | |
386 | fprintf(stderr, | |
387 | "Micropolis will try to run anyway, but might look pretty weird!\n"); | |
388 | } | |
389 | } else { /* Black and white screen */ | |
390 | int white = WhitePixelOfScreen(xd->screen); | |
391 | int black = BlackPixelOfScreen(xd->screen); | |
392 | ||
393 | xd->pixels[COLOR_WHITE] = white; | |
394 | xd->pixels[COLOR_BLACK] = black; | |
395 | ||
396 | xd->pixels[COLOR_YELLOW] = white; | |
397 | xd->pixels[COLOR_ORANGE] = white; | |
398 | xd->pixels[COLOR_RED] = white; | |
399 | xd->pixels[COLOR_DARKRED] = black; | |
400 | xd->pixels[COLOR_DARKBLUE] = black; | |
401 | xd->pixels[COLOR_LIGHTBLUE] = white; | |
402 | xd->pixels[COLOR_BROWN] = black; | |
403 | xd->pixels[COLOR_LIGHTGREEN] = white; | |
404 | xd->pixels[COLOR_DARKGREEN] = black; | |
405 | xd->pixels[COLOR_OLIVE] = black; | |
406 | xd->pixels[COLOR_LIGHTBROWN] = white; | |
407 | xd->pixels[COLOR_LIGHTGRAY] = white; | |
408 | xd->pixels[COLOR_MEDIUMGRAY] = white; | |
409 | xd->pixels[COLOR_DARKGRAY] = black; | |
410 | } | |
411 | ||
412 | xd->gc = Tk_DefaultGC(xd->screen); | |
413 | XSetForeground(xd->dpy, xd->gc, xd->pixels[COLOR_BLACK]); | |
414 | XSetBackground(xd->dpy, xd->gc, xd->pixels[COLOR_WHITE]); | |
415 | XSetLineAttributes(xd->dpy, xd->gc, | |
416 | 1, LineSolid, CapButt, JoinMiter); | |
417 | XSetGraphicsExposures(xd->dpy, xd->gc, False); | |
418 | ||
419 | #ifndef MSDOS | |
420 | { int major, minor, event, error, pixmaps; | |
421 | if (WireMode || | |
422 | (XQueryExtension(xd->dpy, "MIT-SHM", /* Jeez! */ | |
423 | &major, &event, &error) != True) || | |
424 | (XShmQueryVersion(xd->dpy, | |
425 | &major, &minor, &pixmaps) != True)) { | |
426 | fprintf(stderr, | |
427 | "Darn, X display \"%s\" doesn't support the shared memory extension.\n", | |
428 | xd->display); | |
429 | xd->shared = 0; | |
430 | } else { | |
431 | if (!pixmaps) { | |
432 | fprintf(stderr, | |
433 | "Darn, X display \"%s\" claims to support the shared memory extension,\n", | |
434 | xd->display); | |
435 | fprintf(stderr, | |
436 | "but is too lame to support shared memory pixmaps, so Micropolis will run slower.\n"); | |
437 | fprintf(stderr, | |
438 | "Please complain to your X server vendor, %s\n", | |
439 | XServerVendor(xd->dpy)); | |
440 | xd->shared = -1; | |
441 | } else { | |
442 | fprintf(stderr, | |
443 | "Cool, I found the shared memory extension!\n"); | |
37a7c2a1 MG |
444 | fprintf(stderr, |
445 | "Disabled SHM, because it is currently broken!\n"); | |
446 | xd->shared = 0; | |
6a5fa4e0 MG |
447 | } |
448 | } | |
449 | } | |
450 | #else | |
451 | xd->shared = 0; | |
452 | #endif | |
453 | ||
454 | xd->request = -1; | |
455 | xd->last_request_read = -1; | |
456 | xd->big_tile_pixmap = None; | |
457 | xd->objects = NULL; | |
458 | xd->overlay_gc = NULL; | |
459 | xd->gray25_stipple = None; | |
460 | xd->gray50_stipple = None; | |
461 | xd->gray75_stipple = None; | |
462 | xd->vert_stipple = None; | |
463 | xd->horiz_stipple = None; | |
464 | xd->diag_stipple = None; | |
465 | ||
466 | xd->big_tile_image = xd->small_tile_image = NULL; | |
467 | ||
468 | xd->next = XDisplays; XDisplays = xd; | |
469 | } | |
470 | ||
471 | return (xd); | |
472 | } | |
473 | ||
474 | ||
475 | IncRefDisplay(XDisplay *xd) | |
476 | { | |
477 | xd->references++; | |
478 | } | |
479 | ||
480 | ||
481 | DecRefDisplay(XDisplay *xd) | |
482 | { | |
483 | if ((--xd->references) == 0) { | |
484 | /* I'd blow it away, but tk may still be using the display */ | |
485 | } | |
486 | } | |
487 | ||
488 | ||
489 | SimView * | |
490 | InitNewView(SimView *view, char *title, int class, int w, int h) | |
491 | { | |
492 | int type, i; | |
efad9d6d | 493 | int test = 1; |
6a5fa4e0 MG |
494 | int d = 8; |
495 | unsigned long valuemask = 0; | |
496 | char *t; | |
497 | struct XDisplay *xd; | |
498 | XGCValues values; | |
499 | XColor rgb, *color; | |
500 | ||
501 | t = (char *)ckalloc(strlen(title) + 1); | |
502 | strcpy(t, title); | |
503 | ||
504 | view->next = NULL; | |
505 | view->title = t; | |
506 | view->type = -1; | |
507 | view->class = class; | |
508 | view->bigtiles = view->smalltiles = NULL; | |
509 | view->pixels = NULL; | |
510 | view->line_bytes = 0; | |
511 | view->line_bytes8 = 0; | |
512 | view->pixel_bytes = 0; | |
513 | view->depth = 0; | |
514 | view->data = NULL; | |
515 | view->data8 = NULL; | |
516 | view->visible = 0; | |
517 | view->invalid = 0; | |
518 | view->skips = view->skip = 0; | |
519 | view->update = 0; | |
520 | view->map_state = ALMAP; | |
521 | view->show_editors = 1; | |
522 | view->tool_showing = 0; | |
523 | view->tool_mode = 0; | |
524 | view->tool_x = view->tool_y = 0; | |
525 | view->tool_x_const = view->tool_y_const = -1; | |
526 | view->tool_state = dozeState; | |
527 | view->tool_state_save = -1; | |
528 | view->super_user = 0; | |
529 | view->show_me = 1; | |
530 | view->dynamic_filter = 0; | |
531 | view->auto_scroll_token = 0; | |
532 | view->tool_event_time = 0; | |
533 | view->tool_last_event_time = 0; | |
534 | view->w_x = view->w_y = 0; | |
535 | view->w_width = view->w_height = 16; | |
536 | view->m_width = view->m_height = 0; | |
537 | view->i_width = w; view->i_height = h; | |
538 | view->pan_x = view->pan_y = 0; | |
539 | view->tile_x = view->tile_y = 0; | |
540 | view->tile_width = view->tile_height = 0; | |
541 | view->screen_x = view->screen_y = 0; | |
542 | view->screen_width = view->screen_height = 0; | |
543 | view->last_x = view->last_y = view->last_button = 0; | |
544 | view->track_info = NULL; | |
545 | view->message_var = NULL; | |
546 | ||
547 | /* This stuff was initialized in our caller (SimViewCmd) */ | |
548 | /* view->tkwin = NULL; */ | |
549 | /* view->interp = NULL; */ | |
550 | /* view->flags = 0; */ | |
551 | ||
552 | view->x = NULL; | |
553 | view->shminfo = NULL; | |
554 | view->tiles = NULL; | |
555 | view->other_tiles = NULL; | |
556 | view->image = NULL; | |
557 | view->other_image = NULL; | |
558 | view->other_data = NULL; | |
559 | view->pixmap = None; | |
560 | view->pixmap2 = None; | |
561 | view->overlay_pixmap = None; | |
562 | view->overlay_valid = 0; | |
563 | view->fontPtr = NULL; | |
564 | view->updates = 0; | |
565 | view->update_real = view->update_user = view->update_system = 0.0; | |
566 | view->update_context = 0; | |
567 | view->auto_goto = 0; | |
568 | view->auto_going = 0; | |
569 | view->auto_x_goal = view->auto_x_goal = 0; | |
570 | view->auto_speed = 75; | |
571 | view->follow = NULL; | |
572 | view->sound = 1; | |
573 | view->width = 0; view->height = 0; | |
574 | view->show_overlay = 1; | |
575 | view->overlay_mode = 0; | |
576 | ||
577 | view->x = FindXDisplay(view->tkwin); | |
578 | IncRefDisplay(view->x); | |
579 | ||
580 | /* view->x->shared is 1 if the shared memory extension is present and | |
581 | supports shared memory pixmaps, and -1 if it is present but doesn't. */ | |
582 | if (view->x->shared != 1) { | |
583 | view->type = X_Wire_View; | |
584 | } else { | |
585 | view->type = X_Mem_View; | |
586 | } | |
587 | ||
efad9d6d MG |
588 | if ((ImageByteOrder(view->x->dpy) == MSBFirst) == !(*(unsigned char*) (&test))) |
589 | view->x->needs_swap = 0; | |
590 | else | |
591 | view->x->needs_swap = 1; | |
592 | ||
99c730ea | 593 | |
6a5fa4e0 MG |
594 | GetPixmaps(view->x); |
595 | view->pixels = view->x->pixels; | |
596 | ||
597 | if (w == EDITOR_W) w = 256; /* XXX */ | |
598 | if (h == EDITOR_H) h = 256; /* XXX */ | |
599 | ||
600 | view->pan_x = w / 2; view->pan_y = h / 2; | |
601 | DoResizeView(view, w, h); | |
602 | ||
603 | GetViewTiles(view); | |
604 | ||
605 | return (view); | |
606 | } | |
607 | ||
608 | ||
609 | DestroyView(SimView *view) | |
610 | { | |
611 | SimView **vp; | |
612 | ||
613 | CancelRedrawView(view); | |
614 | ||
615 | for (vp = ((view->class == Editor_Class) ? | |
616 | (&sim->editor) : (&sim->map)); | |
617 | (*vp) != NULL; | |
618 | vp = &((*vp)->next)) { | |
619 | if ((*vp) == view) { | |
620 | (*vp) = view->next; | |
621 | if (view->class == Editor_Class) | |
622 | sim->editors--; | |
623 | else | |
624 | sim->maps--; | |
625 | ||
626 | break; | |
627 | } | |
628 | } | |
629 | ||
630 | if (view->title != NULL) { | |
631 | ckfree (view->title); | |
632 | view->title = NULL; | |
633 | } | |
634 | ||
635 | if (view->pixmap != None) { | |
636 | XFreePixmap(view->x->dpy, view->pixmap); | |
637 | view->pixmap = None; | |
638 | } | |
639 | ||
640 | if (view->pixmap2 != None) { | |
641 | XFreePixmap(view->x->dpy, view->pixmap2); | |
642 | view->pixmap2 = None; | |
643 | } | |
644 | ||
645 | if (view->overlay_pixmap != None) { | |
646 | XFreePixmap(view->x->dpy, view->overlay_pixmap); | |
647 | view->overlay_pixmap = None; | |
648 | } | |
649 | ||
650 | if (view->auto_scroll_token) { | |
651 | Tk_DeleteTimerHandler(view->auto_scroll_token); | |
652 | view->auto_scroll_token = 0; | |
653 | } | |
654 | ||
655 | #ifndef MSDOS | |
656 | if (view->shminfo) { | |
657 | XShmDetach(view->x->dpy, view->shminfo); | |
658 | shmdt(view->shminfo->shmaddr); | |
659 | shmctl(view->shminfo->shmid, IPC_RMID, 0); | |
660 | ckfree(view->shminfo); | |
661 | view->shminfo = NULL; | |
662 | if (view->image) { | |
663 | view->image->data = NULL; | |
664 | view->data = NULL; | |
665 | XDestroyImage(view->image); | |
666 | view->image = NULL; | |
667 | } | |
668 | } else { | |
669 | #endif | |
670 | if (view->image) { | |
671 | if (view->image->data) { | |
672 | ckfree(view->image->data); | |
673 | view->image->data = NULL; | |
674 | } | |
675 | view->data = NULL; | |
676 | XDestroyImage(view->image); | |
677 | view->image = NULL; | |
678 | } | |
679 | #ifndef MSDOS | |
680 | } | |
681 | #endif | |
682 | ||
683 | if (view->other_image) { | |
684 | if (view->other_image->data) { | |
685 | ckfree(view->other_image->data); | |
686 | view->other_image->data = NULL; | |
687 | } | |
688 | view->other_data = NULL; | |
689 | XDestroyImage(view->other_image); | |
690 | view->other_image = NULL; | |
691 | } | |
692 | ||
693 | if (view->tiles) | |
694 | FreeTiles(view); | |
695 | ||
696 | DecRefDisplay(view->x); | |
697 | ||
698 | ckfree((char *) view); | |
699 | } | |
700 | ||
701 | ||
702 | unsigned char * | |
703 | AllocPixels(int len, unsigned char pixel) | |
704 | { | |
705 | int i; | |
706 | unsigned char *data, *cp; | |
707 | ||
708 | cp = data = (unsigned char *)ckalloc(len); | |
709 | for (i = len; i > 0; i--) { | |
710 | *(cp++) = pixel; | |
711 | } | |
712 | ||
713 | return (data); | |
714 | } | |
715 | ||
716 | ||
717 | DoResizeView(SimView *view, int w, int h) | |
718 | { | |
719 | int resize = 0; | |
720 | ||
721 | view->w_width = w; | |
722 | view->w_height = h; | |
723 | ||
724 | if (view->class == Map_Class) { /* Map_Class */ | |
725 | view->m_width = w; | |
726 | view->m_height = h; | |
727 | ||
728 | if (view->pixmap2 == None) { | |
729 | ||
730 | view->pixmap2 = XCreatePixmap(view->x->dpy, view->x->root, | |
731 | w, h, view->x->depth); | |
732 | if (view->pixmap2 == None) { | |
733 | fprintf(stderr, | |
734 | "Sorry, Micropolis can't create a pixmap on X display \"%s\"!\n", | |
735 | view->x->display); | |
736 | sim_exit(1); // Just sets tkMustExit and ExitReturn | |
737 | return; | |
738 | } | |
739 | } | |
740 | ||
741 | } else { /* Editor_Class */ | |
742 | ||
743 | if ((w = (w + 31) & (~15)) > view->m_width) | |
744 | view->m_width = w, resize++; | |
745 | if ((h = (h + 31) & (~15)) > view->m_height) | |
746 | view->m_height = h, resize++; | |
747 | ||
748 | if (resize || (view->pixmap2 == None)) { | |
749 | if (view->pixmap2 != None) { | |
750 | XFreePixmap(view->x->dpy, view->pixmap2); | |
751 | view->pixmap2 = None; | |
752 | } | |
753 | view->pixmap2 = XCreatePixmap(view->x->dpy, view->x->root, | |
754 | view->m_width, view->m_height, | |
755 | view->x->depth); | |
756 | if (view->pixmap2 == None) { | |
757 | fprintf(stderr, | |
758 | "Sorry, Micropolis couldn't create a pixmap on X display \"%s\"!\n", | |
759 | view->x->display); | |
760 | sim_exit(1); // Just sets tkMustExit and ExitReturn | |
761 | return; | |
762 | } | |
763 | } | |
764 | ||
765 | if (resize || (view->overlay_pixmap == None)) { | |
766 | view->overlay_mode = 0; | |
767 | if (view->overlay_pixmap != None) { | |
768 | XFreePixmap(view->x->dpy, view->overlay_pixmap); | |
769 | view->overlay_pixmap = None; | |
770 | } | |
771 | view->overlay_pixmap = XCreatePixmap(view->x->dpy, view->x->root, | |
772 | view->m_width, view->m_height, | |
773 | 1); | |
774 | if (view->overlay_pixmap == None) { | |
775 | fprintf(stderr, | |
776 | "Sorry, Micropolis couldn't create another pixmap on X display \"%s\".\n", | |
777 | view->x->display); | |
778 | sim_exit(1); // Just sets tkMustExit and ExitReturn | |
779 | return; | |
780 | } | |
781 | if (view->x->overlay_gc == NULL) { | |
782 | unsigned long valuemask = 0; | |
783 | XGCValues values; | |
784 | ||
785 | view->x->overlay_gc = | |
786 | XCreateGC(view->x->dpy, view->overlay_pixmap, valuemask, &values); | |
787 | XSetForeground(view->x->dpy, view->x->overlay_gc, 0); | |
788 | XSetBackground(view->x->dpy, view->x->overlay_gc, 1); | |
789 | XSetLineAttributes(view->x->dpy, view->x->overlay_gc, | |
790 | 1, LineSolid, CapButt, JoinMiter); | |
791 | XSetGraphicsExposures(view->x->dpy, view->x->overlay_gc, False); | |
792 | } | |
793 | } | |
794 | ||
795 | } | |
796 | ||
797 | #ifndef MSDOS | |
798 | if (view->type != X_Mem_View) { | |
799 | goto SPRING_FORWARD; | |
800 | } | |
801 | ||
802 | if (resize || (view->image == NULL)) { | |
803 | if (view->shminfo && view->image) { | |
804 | if (view->pixmap != None) { | |
805 | XFreePixmap(view->x->dpy, view->pixmap); | |
806 | view->pixmap = None; | |
807 | } | |
808 | XShmDetach(view->x->dpy, view->shminfo); | |
809 | shmdt(view->shminfo->shmaddr); | |
810 | shmctl(view->shminfo->shmid, IPC_RMID, 0); | |
811 | view->image->data = NULL; | |
812 | if (view->data == view->data8) | |
813 | view->data8 = NULL; | |
814 | view->data = NULL; | |
815 | XDestroyImage(view->image); | |
816 | view->image = NULL; | |
817 | } | |
818 | ||
819 | #if 0 | |
820 | /* XShmPixmapFormat is documented but does not exist !!! */ | |
821 | if (XShmPixmapFormat(view->x->dpy) != ZPixmap) { | |
822 | fprintf(stderr, | |
823 | "Darn, display \"%s\" has the wrong shared memory format.\n", | |
824 | view->x->display); | |
825 | goto FALL_BACK; | |
826 | } | |
827 | #endif | |
828 | ||
829 | if (!view->shminfo) { | |
830 | view->shminfo = (XShmSegmentInfo *)ckalloc(sizeof (XShmSegmentInfo)); | |
831 | } | |
832 | ||
833 | view->image = | |
834 | XShmCreateImage(view->x->dpy, view->x->visual, view->x->depth, | |
835 | view->x->color ? ZPixmap : XYBitmap, | |
836 | NULL, view->shminfo, | |
837 | view->m_width, view->m_height); | |
838 | ||
839 | view->line_bytes = view->image->bytes_per_line; | |
840 | ||
841 | switch (view->x->depth) { | |
842 | ||
843 | case 1: | |
844 | view->pixel_bytes = 0; | |
845 | view->depth = 1; | |
846 | break; | |
847 | ||
848 | case 8: | |
849 | view->pixel_bytes = 1; | |
850 | view->depth = 8; | |
851 | break; | |
852 | ||
853 | case 15: | |
854 | view->pixel_bytes = 2; | |
855 | view->depth = 15; | |
856 | break; | |
857 | ||
858 | case 16: | |
859 | view->pixel_bytes = 2; | |
860 | view->depth = 16; | |
861 | break; | |
862 | ||
863 | case 24: | |
864 | /* XXX: TODO: 24 and 32 bit support */ | |
865 | view->pixel_bytes = 4; | |
866 | //view->pixel_bytes = 3; | |
867 | view->depth = 24; | |
868 | break; | |
869 | ||
870 | case 32: | |
871 | /* XXX: TODO: 24 and 32 bit support */ | |
872 | view->pixel_bytes = 4; | |
873 | view->depth = 32; | |
874 | break; | |
875 | ||
876 | default: | |
877 | view->pixel_bytes = 0; | |
878 | view->depth = 0; | |
879 | break; | |
880 | ||
881 | } // switch | |
882 | ||
883 | view->shminfo->shmid = shmget(IPC_PRIVATE, | |
884 | (view->line_bytes * | |
885 | view->m_height), | |
886 | (IPC_CREAT | 0777)); | |
887 | if (view->shminfo->shmid < 0) { | |
888 | perror("shmget"); | |
889 | fprintf(stderr, | |
890 | "Darn, Micropolis can't share memory with X display \"%s\".\n", | |
891 | view->x->display); | |
892 | goto FALL_BACK; | |
893 | } | |
894 | ||
895 | view->data = (unsigned char *)shmat(view->shminfo->shmid, 0, 0); | |
896 | if ((int)view->data == -1) { | |
897 | perror("shmat"); | |
898 | fprintf(stderr, | |
899 | "Darn, Micropolis can't find any memory to share with display \"%s\".\n", | |
900 | view->x->display); | |
901 | goto FALL_BACK; | |
902 | } | |
903 | ||
904 | view->image->data = (char *)view->data; | |
905 | view->shminfo->shmaddr = (char *)view->data; | |
906 | view->shminfo->readOnly = False; | |
907 | ||
908 | { int (*old)(); | |
909 | int result; | |
910 | int attached = 0; | |
911 | GotXError = 0; | |
912 | old = XSetErrorHandler(CatchXError); | |
913 | ||
914 | result = | |
915 | XShmAttach(view->x->dpy, view->shminfo); | |
916 | if (result == 0) { | |
917 | fprintf(stderr, | |
918 | "Darn, the X display \"%s\" can't access Micropolis's shared memory.\n", | |
919 | view->x->display); | |
920 | GotXError = 1; | |
921 | } | |
922 | ||
923 | XSync(view->x->dpy, False); | |
924 | ||
925 | if (!GotXError) { | |
926 | attached = 1; | |
927 | view->pixmap = XShmCreatePixmap(view->x->dpy, view->x->root, | |
928 | view->data, view->shminfo, | |
929 | view->m_width, view->m_height, | |
930 | view->x->depth); | |
931 | XSync(view->x->dpy, False); | |
932 | ||
933 | if (GotXError || | |
934 | (view->pixmap == None)) { | |
935 | fprintf(stderr, | |
936 | "Darn, Micropolis couldn't get a shared memory pixmap on X display \"%s\".\n", | |
937 | view->x->display); | |
938 | GotXError = 1; | |
939 | } | |
940 | } | |
941 | ||
942 | XSetErrorHandler(old); | |
943 | ||
944 | if (GotXError) { | |
945 | view->pixmap = None; | |
946 | if (attached) { | |
947 | XShmDetach(view->x->dpy, view->shminfo); | |
948 | } // if | |
949 | result = shmdt(view->shminfo->shmaddr); | |
950 | result = shmctl(view->shminfo->shmid, IPC_RMID, 0); | |
951 | ckfree(view->shminfo); | |
952 | view->shminfo = NULL; | |
953 | if (view->image) { | |
954 | view->image->data = NULL; | |
955 | view->data = NULL; | |
956 | XDestroyImage(view->image); | |
957 | view->image = NULL; | |
958 | } | |
959 | goto FALL_BACK; | |
960 | } | |
961 | ||
962 | if (view->x->color) { | |
963 | XSetForeground(view->x->dpy, view->x->gc, | |
964 | view->pixels[COLOR_LIGHTBROWN]); | |
965 | } else { | |
966 | XSetForeground(view->x->dpy, view->x->gc, | |
967 | view->pixels[COLOR_WHITE]); | |
968 | } | |
969 | ||
970 | XFillRectangle(view->x->dpy, view->pixmap, view->x->gc, | |
971 | 0, 0, view->m_width, view->m_height); | |
972 | } | |
973 | } | |
974 | ||
975 | goto FINISH; | |
976 | ||
977 | FALL_BACK: | |
978 | ||
979 | fprintf(stderr, | |
980 | "Falling back to the X network protocol on display \"%s\"...\n", | |
981 | view->x->display); | |
982 | #endif | |
983 | ||
984 | view->x->shared = 0; | |
985 | view->type = X_Wire_View; | |
986 | if (view->pixmap != None) { | |
987 | XFreePixmap(view->x->dpy, view->pixmap); | |
988 | view->pixmap = None; | |
989 | } | |
990 | #ifndef MSDOS | |
991 | if (view->shminfo) { | |
992 | if (view->shminfo->shmid >= 0) { | |
993 | if (view->shminfo->shmaddr) { | |
994 | shmdt(view->shminfo->shmaddr); | |
995 | } | |
996 | shmctl(view->shminfo->shmid, IPC_RMID, 0); | |
997 | } | |
998 | ckfree((char *)view->shminfo); | |
999 | view->shminfo = NULL; | |
1000 | } | |
1001 | #endif | |
1002 | if (view->image) { | |
1003 | view->image->data = NULL; | |
1004 | XDestroyImage(view->image); | |
1005 | view->image = NULL; | |
1006 | } | |
1007 | view->data = NULL; | |
1008 | view->line_bytes = 0; | |
1009 | view->pixel_bytes = 0; | |
1010 | view->depth = 0; | |
1011 | ||
1012 | SPRING_FORWARD: | |
1013 | ||
1014 | if (resize || (view->pixmap == None)) { | |
1015 | if (view->pixmap != None) { | |
1016 | XFreePixmap(view->x->dpy, view->pixmap); | |
1017 | view->pixmap = None; | |
1018 | } | |
1019 | view->pixmap = XCreatePixmap(view->x->dpy, view->x->root, | |
1020 | view->m_width, view->m_height, | |
1021 | view->x->depth); | |
1022 | if (view->pixmap == None) { | |
1023 | fprintf(stderr, | |
1024 | "Sorry, Micropolis can't create pixmap on X display \"%s\".\n", | |
1025 | view->x->display); | |
1026 | sim_exit(1); // Just sets tkMustExit and ExitReturn | |
1027 | return; | |
1028 | } | |
1029 | if (view->x->color) { | |
1030 | XSetForeground(view->x->dpy, view->x->gc, | |
1031 | view->pixels[COLOR_LIGHTBROWN]); | |
1032 | } else { | |
1033 | XSetForeground(view->x->dpy, view->x->gc, | |
1034 | view->pixels[COLOR_WHITE]); | |
1035 | } | |
1036 | XFillRectangle(view->x->dpy, view->pixmap, view->x->gc, | |
1037 | 0, 0, view->m_width, view->m_height); | |
1038 | } | |
1039 | ||
1040 | FINISH: | |
1041 | ||
1042 | if (view->class == Editor_Class) { | |
1043 | ||
1044 | AllocTiles(view); | |
1045 | DoAdjustPan(view); | |
1046 | ||
1047 | } else if (view->class == Map_Class) { | |
1048 | ||
1049 | if (view->type == X_Mem_View) { /* Memory Map */ | |
1050 | ||
1051 | if (view->x->color) { | |
1052 | ||
1053 | /* Color, Shared Memory */ | |
1054 | ||
1055 | view->data8 = view->data; | |
1056 | view->line_bytes8 = view->line_bytes; /* XXX: ??? */ | |
1057 | ||
1058 | switch (view->x->depth) { | |
1059 | ||
1060 | case 8: | |
1061 | view->pixel_bytes = 1; | |
1062 | view->depth = 8; | |
1063 | break; | |
1064 | ||
1065 | case 15: | |
1066 | view->pixel_bytes = 2; | |
1067 | view->depth = 15; | |
1068 | break; | |
1069 | ||
1070 | case 16: | |
1071 | view->pixel_bytes = 2; | |
1072 | view->depth = 16; | |
1073 | break; | |
1074 | ||
1075 | case 24: | |
1076 | /* XXX: TODO: 24 and 32 bit support */ | |
1077 | view->pixel_bytes = 4; | |
1078 | //view->pixel_bytes = 3; | |
1079 | view->depth = 24; | |
1080 | break; | |
1081 | ||
1082 | case 32: | |
1083 | /* XXX: TODO: 24 and 32 bit support */ | |
1084 | view->pixel_bytes = 4; | |
1085 | view->depth = 32; | |
1086 | break; | |
1087 | ||
1088 | default: | |
1089 | view->pixel_bytes = 0; | |
1090 | view->depth = 0; | |
1091 | break; | |
1092 | ||
1093 | } // switch | |
1094 | ||
1095 | } else { | |
1096 | ||
1097 | /* Black and White, Shared Memory */ | |
1098 | ||
1099 | if (view->other_image != NULL) { | |
1100 | XDestroyImage(view->other_image); | |
1101 | } | |
1102 | ||
1103 | view->line_bytes8 = view->m_width; /* XXX: fix depth */ | |
1104 | view->pixel_bytes = 0; | |
1105 | view->depth = 1; | |
1106 | ||
1107 | view->other_data = view->data8 = | |
1108 | AllocPixels(view->m_height * view->line_bytes8, /* XXX: fix depth */ | |
1109 | view->pixels[COLOR_WHITE]); | |
1110 | view->other_image = | |
1111 | XCreateImage(view->x->dpy, view->x->visual, 8, /* XXX: fix depth */ | |
1112 | ZPixmap, 0, (char *)view->other_data, | |
1113 | view->m_width, view->m_height, | |
1114 | 8, view->line_bytes8); /* XXX: fix depth */ | |
1115 | } | |
1116 | ||
1117 | } else { /* Wire Map */ | |
1118 | int bitmap_pad; | |
1119 | int bitmap_depth; | |
1120 | ||
1121 | if (view->image != NULL) { | |
1122 | XDestroyImage(view->image); | |
1123 | view->image = NULL; | |
1124 | } | |
1125 | ||
1126 | if (view->other_image != NULL) { | |
1127 | XDestroyImage(view->other_image); | |
1128 | view->other_image = NULL; | |
1129 | } | |
1130 | ||
1131 | if (view->x->color) { | |
1132 | ||
1133 | /* Color, Wire */ | |
1134 | ||
1135 | switch (view->x->depth) { | |
1136 | ||
1137 | case 8: | |
1138 | view->pixel_bytes = 1; | |
1139 | view->depth = 8; | |
1140 | bitmap_pad = 8; | |
1141 | bitmap_depth = 8; | |
1142 | view->line_bytes8 = | |
1143 | ((view->m_width * view->pixel_bytes) + 3) & (~3); | |
1144 | break; | |
1145 | ||
1146 | case 15: | |
1147 | view->pixel_bytes = 2; | |
1148 | view->depth = 15; | |
1149 | bitmap_pad = 16; | |
1150 | bitmap_depth = 16; | |
1151 | view->line_bytes8 = | |
1152 | ((view->m_width * view->pixel_bytes) + 3) & (~3); | |
1153 | break; | |
1154 | ||
1155 | case 16: | |
1156 | view->pixel_bytes = 2; | |
1157 | view->depth = 16; | |
1158 | bitmap_pad = 16; | |
1159 | bitmap_depth = 16; | |
1160 | view->line_bytes8 = | |
1161 | ((view->m_width * view->pixel_bytes) + 3) & (~3); | |
1162 | break; | |
1163 | ||
1164 | case 24: | |
1165 | view->pixel_bytes = 4; | |
1166 | //view->pixel_bytes = 3; | |
1167 | view->depth = 24; | |
93200beb | 1168 | bitmap_depth = 24; |
6a5fa4e0 MG |
1169 | bitmap_pad = 32; |
1170 | view->line_bytes8 = | |
1171 | ((view->m_width * 4) + 3) & (~3); | |
1172 | break; | |
1173 | ||
1174 | case 32: | |
1175 | view->pixel_bytes = 4; | |
1176 | view->depth = 32; | |
1177 | bitmap_pad = 32; | |
1178 | bitmap_depth = 32; | |
1179 | view->line_bytes8 = | |
1180 | ((view->m_width * 4) + 3) & (~3); | |
1181 | break; | |
1182 | ||
1183 | default: | |
1184 | assert(0); /* Unknown depth */ | |
1185 | break; | |
1186 | ||
1187 | } // switch | |
1188 | ||
1189 | view->line_bytes = | |
1190 | view->line_bytes8; | |
1191 | ||
1192 | } else { | |
1193 | ||
1194 | /* Black and White, Wire */ | |
1195 | ||
1196 | view->pixel_bytes = 0; | |
1197 | view->depth = 1; | |
1198 | view->line_bytes8 = | |
1199 | (view->m_width + 3) & (~3); /* XXX: handle depth */ | |
1200 | view->line_bytes = | |
1201 | (view->m_width + 7) >>3; | |
1202 | bitmap_pad = 8; | |
1203 | bitmap_depth = 8; | |
1204 | ||
1205 | } | |
1206 | ||
1207 | view->data = | |
1208 | AllocPixels(view->m_height * view->line_bytes, 0); | |
1209 | view->image = | |
1210 | XCreateImage(view->x->dpy, view->x->visual, | |
1211 | bitmap_depth, | |
1212 | view->x->color ? ZPixmap : XYBitmap, | |
1213 | 0, (char *)view->data, | |
1214 | view->m_width, view->m_height, | |
1215 | bitmap_pad, | |
1216 | view->line_bytes); | |
1217 | ||
1218 | view->other_data = | |
1219 | AllocPixels(view->m_height * view->line_bytes8, 0); | |
1220 | view->other_image = | |
1221 | XCreateImage(view->x->dpy, view->x->visual, | |
1222 | bitmap_depth, | |
1223 | ZPixmap, | |
1224 | 0, (char *)view->other_data, | |
1225 | view->m_width, view->m_height, | |
1226 | bitmap_pad, | |
1227 | view->line_bytes); | |
1228 | ||
1229 | if (view->x->color) { | |
1230 | view->data8 = view->data; | |
1231 | } else { | |
1232 | view->data8 = view->other_data; | |
1233 | } | |
1234 | } | |
1235 | } | |
1236 | } | |
1237 | ||
1238 | ||
1239 | DoPanBy(struct SimView *view, int dx, int dy) | |
1240 | { | |
1241 | DoPanTo(view, view->pan_x + dx, view->pan_y + dy); | |
1242 | } | |
1243 | ||
1244 | ||
1245 | DoPanTo(struct SimView *view, int x, int y) | |
1246 | { | |
1247 | if (view->class != Editor_Class) { | |
1248 | return; | |
1249 | } | |
1250 | ||
1251 | if (x < 0) x = 0; | |
1252 | if (y < 0) y = 0; | |
1253 | if (x > view->i_width) x = view->i_width - 1; | |
1254 | if (y > view->i_height) y = view->i_height - 1; | |
1255 | if ((view->pan_x != x) || | |
1256 | (view->pan_y != y)) { | |
1257 | view->pan_x = x; | |
1258 | view->pan_y = y; | |
1259 | DoAdjustPan(view); | |
1260 | } | |
1261 | } | |
1262 | ||
1263 | /* #define DEBUG_PAN */ | |
1264 | ||
1265 | DoAdjustPan(struct SimView *view) | |
1266 | { | |
1267 | int ww2 = view->w_width >>1, wh2 = view->w_height >>1; | |
1268 | int px = view->pan_x, py = view->pan_y; | |
1269 | int last_tile_x = view->tile_x, last_tile_y = view->tile_y; | |
1270 | int last_tile_width = view->tile_width, last_tile_height = view->tile_height; | |
1271 | int total_width = view->m_width >>4, total_height = view->m_height >>4; | |
1272 | //fprintf(stderr, "DoAdjustPan\n"); | |
1273 | ||
1274 | #ifdef DEBUG_PAN | |
1275 | printf("AdjustPan window %d %d ww2 %d wh2 %d pan %d %d\n", | |
1276 | view->w_width, view->w_height, ww2, wh2, px, py); | |
1277 | printf(" last tile %d %d %d %d\n", | |
1278 | last_tile_x, last_tile_y, last_tile_width, last_tile_height); | |
1279 | #endif | |
1280 | ||
1281 | if ((view->tile_x = ((px - ww2) >>4)) < 0) | |
1282 | view->tile_x = 0; | |
1283 | if ((view->tile_y = ((py - wh2) >>4)) < 0) | |
1284 | view->tile_y = 0; | |
1285 | ||
1286 | #ifdef DEBUG_PAN | |
1287 | printf(" now tile %d %d\n", view->tile_x, view->tile_y); | |
1288 | #endif | |
1289 | ||
1290 | view->tile_width = ((15 + px + ww2) >>4); | |
1291 | view->tile_height = ((15 + py + wh2) >>4); | |
1292 | ||
1293 | #ifdef DEBUG_PAN | |
1294 | printf(" outer tile %d %d\n", view->tile_width, view->tile_height); | |
1295 | #endif | |
1296 | ||
1297 | if (view->tile_width > (view->i_width >>4)) | |
1298 | view->tile_width = (view->i_width >>4); | |
1299 | view->tile_width -= view->tile_x; | |
1300 | if (view->tile_height > (view->i_height >>4)) | |
1301 | view->tile_height = (view->i_height >>4); | |
1302 | view->tile_height -= view->tile_y; | |
1303 | ||
1304 | #ifdef DEBUG_PAN | |
1305 | printf(" tile size %d %d\n", view->tile_width, view->tile_height); | |
1306 | #endif | |
1307 | ||
1308 | if (view->tile_width > (view->m_width >>4)) | |
1309 | view->tile_width = (view->m_width >>4); | |
1310 | if (view->tile_height > (view->m_height >>4)) | |
1311 | view->tile_height = (view->m_height >>4); | |
1312 | ||
1313 | #ifdef DEBUG_PAN | |
1314 | printf(" clipped size %d %d\n", view->tile_width, view->tile_height); | |
1315 | printf(" maximum size %d %d\n", view->m_width >>4, view->m_height >>4); | |
1316 | #endif | |
1317 | ||
1318 | view->screen_x = (ww2 - px) + (view->tile_x <<4); | |
1319 | view->screen_y = (wh2 - py) + (view->tile_y <<4); | |
1320 | view->screen_width = (view->tile_width <<4); | |
1321 | view->screen_height = (view->tile_height <<4); | |
1322 | ||
1323 | #ifdef DEBUG_PAN | |
1324 | printf(" screen %d %d %d %d\n", | |
1325 | view->screen_x, view->screen_y, | |
1326 | view->screen_width, view->screen_height); | |
1327 | #endif | |
1328 | ||
1329 | view->overlay_mode = 0; | |
1330 | // view->skip = 0; | |
1331 | view->invalid = 1; | |
1332 | if (SimSpeed == 0) { | |
1333 | EventuallyRedrawView(view); | |
1334 | } | |
1335 | /* InvalidateEditors(); */ | |
1336 | if (view->show_me) { | |
1337 | RedrawMaps(); | |
1338 | } | |
1339 | /* FixMicropolisTimer(); */ | |
1340 | ||
1341 | { int dx = last_tile_x - view->tile_x, | |
1342 | dy = last_tile_y - view->tile_y; | |
1343 | short **want = view->other_tiles, | |
1344 | **have = view->tiles; | |
1345 | ||
1346 | #ifdef DEBUG_PAN | |
1347 | printf("scrolling %d %d\n", dx, dy); | |
1348 | #endif | |
1349 | ||
1350 | if ((dx != 0) || (dy != 0)) { | |
1351 | int row, col, x, y, | |
1352 | width = view->tile_width, | |
1353 | height = view->tile_height; | |
1354 | ||
1355 | for (col = 0; col < width; col++) | |
1356 | memcpy(want[col], have[col], (height * sizeof(short))); | |
1357 | ||
1358 | for (col = 0; col < total_width; col++) { | |
1359 | x = col - dx; | |
1360 | for (row = 0; row < total_height; row++) { | |
1361 | y = row - dy; | |
1362 | if ((x >= 0) && (x < width) && | |
1363 | (y >= 0) && (y < height)) { | |
1364 | have[col][row] = want[x][y]; | |
1365 | } else { | |
1366 | have[col][row] = -1; | |
1367 | } | |
1368 | } | |
1369 | } | |
1370 | ||
1371 | XCopyArea(view->x->dpy, view->pixmap, view->pixmap, view->x->gc, | |
1372 | 0, 0, view->tile_width <<4, view->tile_height <<4, | |
1373 | dx <<4, dy <<4); | |
1374 | ||
1375 | if (view->type == X_Mem_View) { | |
1376 | XSync(view->x->dpy, False); | |
1377 | } | |
1378 | } | |
1379 | } | |
1380 | } | |
1381 | ||
1382 | ||
1383 | AllocTiles(SimView *view) | |
1384 | { | |
1385 | int row, col; | |
1386 | short **have, **want; | |
1387 | int w = view->m_width / 16, h = view->m_height / 16; | |
1388 | int n = (w + 1) * sizeof (short *); | |
1389 | ||
1390 | if (view->tiles) | |
1391 | FreeTiles(view); | |
1392 | ||
1393 | have = view->tiles = | |
1394 | (short **)ckalloc(n); | |
1395 | ||
1396 | want = view->other_tiles = | |
1397 | (short **)ckalloc(n); | |
1398 | ||
1399 | have[w] = want[w] = NULL; | |
1400 | ||
1401 | n = h * sizeof(short); | |
1402 | for (col = 0; col < w; col++) { | |
1403 | ||
1404 | have[col] = (short *)ckalloc(n); | |
1405 | want[col] = (short *)ckalloc(n); | |
1406 | for (row = 0; row < h; row++) { | |
1407 | have[col][row] = -1; | |
1408 | want[col][row] = -1; | |
1409 | } | |
1410 | } | |
1411 | } | |
1412 | ||
1413 | ||
1414 | FreeTiles(SimView *view) | |
1415 | { | |
1416 | int col; | |
1417 | ||
1418 | for (col = 0; view->tiles[col] != NULL; col++) { | |
1419 | ckfree ((char *)view->tiles[col]); | |
1420 | ckfree ((char *)view->other_tiles[col]); | |
1421 | } | |
1422 | ckfree ((char *)view->tiles); | |
1423 | view->tiles = NULL; | |
1424 | ckfree ((char *)view->other_tiles); | |
1425 | view->other_tiles = NULL; | |
1426 | } | |
1427 | ||
1428 | ||
1429 | #define POINT_BATCH 32 | |
1430 | ||
1431 | Ink *OldInk = NULL; | |
1432 | ||
1433 | ||
1434 | /* XXX: todo: ink locking so someone doesn't erase ink that's being drawn */ | |
1435 | ||
1436 | Ink * | |
1437 | NewInk() | |
1438 | { | |
1439 | Ink *ink; | |
1440 | ||
1441 | if (OldInk) { | |
1442 | ink = OldInk; | |
1443 | OldInk = OldInk->next; | |
1444 | } else { | |
1445 | ink = (Ink *)ckalloc(sizeof(Ink)); | |
1446 | ink->maxlength = POINT_BATCH; | |
1447 | ink->points = (XPoint *)ckalloc(POINT_BATCH * sizeof(XPoint)); | |
1448 | } | |
1449 | ink->length = 0; | |
1450 | ink->color = COLOR_WHITE; | |
1451 | ink->next = NULL; | |
1452 | ink->left = ink->right = ink->top = ink->bottom = | |
1453 | ink->last_x = ink->last_y = -1; | |
1454 | return (ink); | |
1455 | } | |
1456 | ||
1457 | ||
1458 | FreeInk(Ink *ink) | |
1459 | { | |
1460 | ink->next = OldInk; | |
1461 | OldInk = ink; | |
1462 | } | |
1463 | ||
1464 | ||
1465 | StartInk(Ink *ink, int x, int y) | |
1466 | { | |
1467 | ink->length = 1; | |
1468 | ink->left = ink->right = ink->last_x = ink->points[0].x = x; | |
1469 | ink->top = ink->bottom = ink->last_y = ink->points[0].y = y; | |
1470 | } | |
1471 | ||
1472 | ||
1473 | AddInk(Ink *ink, int x, int y) | |
1474 | { | |
1475 | int dx = x - ink->last_x; | |
1476 | int dy = y - ink->last_y; | |
1477 | ||
1478 | if ((dx != 0) || (dy != 0)) { | |
1479 | /* | |
1480 | if (ink->length > 1) { | |
1481 | if ((dx == 0) && | |
1482 | (ink->points[ink->length - 1].x == 0) && | |
1483 | ((ink->points[ink->length - 1].y < 0) ? | |
1484 | (dy < 0) : (dy > 0))) { | |
1485 | ink->points[ink->length - 1].y += dy; | |
1486 | goto ADJUST; | |
1487 | } else if ((dy == 0) && | |
1488 | (ink->points[ink->length - 1].y == 0) && | |
1489 | ((ink->points[ink->length - 1].x < 0) ? | |
1490 | (dx < 0) : (dx > 0))) { | |
1491 | ink->points[ink->length - 1].x += dx; | |
1492 | goto ADJUST; | |
1493 | } | |
1494 | } | |
1495 | */ | |
1496 | ||
1497 | if (ink->length >= ink->maxlength) { | |
1498 | ink->maxlength += POINT_BATCH; | |
1499 | ink->points = (XPoint *)realloc((void *)ink->points, | |
1500 | ink->maxlength * sizeof(XPoint)); | |
1501 | } | |
1502 | ink->points[ink->length].x = dx; | |
1503 | ink->points[ink->length].y = dy; | |
1504 | ink->length++; | |
1505 | ||
1506 | ADJUST: | |
1507 | if (x < ink->left) | |
1508 | ink->left = x; | |
1509 | if (x > ink->right) | |
1510 | ink->right = x; | |
1511 | if (y < ink->top) | |
1512 | ink->top = y; | |
1513 | if (y > ink->bottom) | |
1514 | ink->bottom = y; | |
1515 | ||
1516 | { int left, right, top, bottom; | |
1517 | SimView *view; | |
1518 | ||
1519 | if (ink->last_x < x) { left = ink->last_x; right = x; } | |
1520 | else { left = x; right = ink->last_x; } | |
1521 | if (ink->last_y < y) { top = ink->last_y; bottom = y; } | |
1522 | else { top = y; bottom = ink->last_y; } | |
1523 | ||
1524 | left -= 5; right += 5; top -= 5; bottom += 5; | |
1525 | ||
1526 | for (view = sim->editor; view != NULL; view = view->next) { | |
1527 | int vleft, vtop; | |
1528 | ||
1529 | if ((right >= (vleft = view->pan_x - (view->w_width / 2))) && | |
1530 | (left <= vleft + view->w_width) && | |
1531 | (bottom >= (vtop = view->pan_y - (view->w_height / 2))) && | |
1532 | (top <= vtop + view->w_height)) { | |
1533 | /* XXX: do studly incremental update instead */ | |
1534 | view->overlay_mode = 0; | |
1535 | EventuallyRedrawView(view); | |
1536 | } | |
1537 | } | |
1538 | } | |
1539 | ink->last_x = x; ink->last_y = y; | |
1540 | } | |
1541 | } | |
1542 | ||
1543 | ||
1544 | EraseOverlay() | |
1545 | { | |
1546 | Ink *ink; | |
1547 | ||
1548 | while (sim->overlay) { | |
1549 | ink = sim->overlay; | |
1550 | sim->overlay = ink->next; | |
1551 | FreeInk(ink); | |
1552 | } | |
1553 | } |