]>
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: \ | |
3fec6683 | 330 | if (xd->visual->red_mask == 0x7c00) { \ |
6a5fa4e0 MG |
331 | xd->pixels[i] = \ |
332 | (((color->red >> (8 + 3)) & 0x1f) << (5 + 5)) | \ | |
333 | (((color->green >> (8 + 2)) & 0x1f) << (5)) | \ | |
334 | (((color->blue >> (8 + 3)) & 0x1f) << (0)); \ | |
3fec6683 MG |
335 | } else { \ |
336 | (((color->blue >> (8 + 3)) & 0x1f) << (5 + 5)) | \ | |
337 | (((color->green >> (8 + 2)) & 0x1f) << (5)) | \ | |
338 | (((color->red >> (8 + 3)) & 0x1f) << (0)); \ | |
339 | } \ | |
6a5fa4e0 MG |
340 | break; \ |
341 | case 16: \ | |
3fec6683 | 342 | if (xd->visual->red_mask == 0xf800) { \ |
6a5fa4e0 MG |
343 | xd->pixels[i] = \ |
344 | (((color->red >> (8 + 3)) & 0x1f) << (6 + 5)) | \ | |
345 | (((color->green >> (8 + 2)) & 0x3f) << (5)) | \ | |
346 | (((color->blue >> (8 + 3)) & 0x1f) << (0)); \ | |
3fec6683 MG |
347 | } else { \ |
348 | xd->pixels[i] = \ | |
349 | (((color->blue >> (8 + 3)) & 0x1f) << (6 + 5)) | \ | |
350 | (((color->green >> (8 + 2)) & 0x3f) << (5)) | \ | |
351 | (((color->red >> (8 + 3)) & 0x1f) << (0)); \ | |
352 | } \ | |
6a5fa4e0 MG |
353 | break; \ |
354 | case 24: \ | |
3fec6683 MG |
355 | case 32: \ |
356 | if (xd->visual->red_mask == 0xff0000) { \ | |
6a5fa4e0 MG |
357 | xd->pixels[i] = \ |
358 | ((color->red & 0xff) << 16) | \ | |
359 | ((color->green & 0xff) << 8) | \ | |
360 | ((color->blue & 0xff) << 0); \ | |
3fec6683 | 361 | } else { \ |
6a5fa4e0 | 362 | xd->pixels[i] = \ |
3fec6683 | 363 | ((color->blue & 0xff) << 16) | \ |
6a5fa4e0 | 364 | ((color->green & 0xff) << 8) | \ |
3fec6683 MG |
365 | ((color->red & 0xff) << 0); \ |
366 | } \ | |
6a5fa4e0 MG |
367 | break; \ |
368 | } \ | |
369 | } \ | |
370 | } | |
371 | ||
372 | if ((xd->depth == 8) && | |
373 | (Tk_DefaultColormap(xd->screen) == | |
374 | DefaultColormapOfScreen(xd->screen))) { | |
375 | xd->pixels[COLOR_WHITE] = WhitePixelOfScreen(xd->screen); | |
376 | xd->pixels[COLOR_BLACK] = BlackPixelOfScreen(xd->screen); | |
377 | } else { | |
378 | GETCOLOR(COLOR_WHITE, "#ffffff"); | |
379 | GETCOLOR(COLOR_BLACK, "#000000"); | |
380 | } | |
381 | ||
382 | GETCOLOR(COLOR_YELLOW, "#ffff00"); | |
383 | GETCOLOR(COLOR_ORANGE, "#ff7f00"); | |
384 | GETCOLOR(COLOR_RED, "#ff0000"); | |
385 | GETCOLOR(COLOR_DARKRED, "#bf0000"); | |
386 | GETCOLOR(COLOR_DARKBLUE, "#0000e6"); | |
387 | GETCOLOR(COLOR_LIGHTBLUE, "#6666e6"); | |
388 | GETCOLOR(COLOR_BROWN, "#cc4c4c"); | |
389 | GETCOLOR(COLOR_LIGHTGREEN, "#00e600"); | |
390 | GETCOLOR(COLOR_DARKGREEN, "#007f00"); | |
391 | GETCOLOR(COLOR_OLIVE, "#997f4c"); | |
392 | GETCOLOR(COLOR_LIGHTBROWN, "#cc7f66"); | |
393 | GETCOLOR(COLOR_LIGHTGRAY, "#bfbfbf"); | |
394 | GETCOLOR(COLOR_MEDIUMGRAY, "#7f7f7f"); | |
395 | GETCOLOR(COLOR_DARKGRAY, "#3f3f3f"); | |
396 | ||
397 | if (!GotColor) { | |
398 | fprintf(stderr, | |
399 | "Oh, dear. There don't seem to be enough free colors on X display \"%s\".\n", | |
400 | xd->display); | |
401 | fprintf(stderr, | |
402 | "Micropolis will try to run anyway, but might look pretty weird!\n"); | |
403 | } | |
404 | } else { /* Black and white screen */ | |
405 | int white = WhitePixelOfScreen(xd->screen); | |
406 | int black = BlackPixelOfScreen(xd->screen); | |
407 | ||
408 | xd->pixels[COLOR_WHITE] = white; | |
409 | xd->pixels[COLOR_BLACK] = black; | |
410 | ||
411 | xd->pixels[COLOR_YELLOW] = white; | |
412 | xd->pixels[COLOR_ORANGE] = white; | |
413 | xd->pixels[COLOR_RED] = white; | |
414 | xd->pixels[COLOR_DARKRED] = black; | |
415 | xd->pixels[COLOR_DARKBLUE] = black; | |
416 | xd->pixels[COLOR_LIGHTBLUE] = white; | |
417 | xd->pixels[COLOR_BROWN] = black; | |
418 | xd->pixels[COLOR_LIGHTGREEN] = white; | |
419 | xd->pixels[COLOR_DARKGREEN] = black; | |
420 | xd->pixels[COLOR_OLIVE] = black; | |
421 | xd->pixels[COLOR_LIGHTBROWN] = white; | |
422 | xd->pixels[COLOR_LIGHTGRAY] = white; | |
423 | xd->pixels[COLOR_MEDIUMGRAY] = white; | |
424 | xd->pixels[COLOR_DARKGRAY] = black; | |
425 | } | |
426 | ||
427 | xd->gc = Tk_DefaultGC(xd->screen); | |
428 | XSetForeground(xd->dpy, xd->gc, xd->pixels[COLOR_BLACK]); | |
429 | XSetBackground(xd->dpy, xd->gc, xd->pixels[COLOR_WHITE]); | |
430 | XSetLineAttributes(xd->dpy, xd->gc, | |
431 | 1, LineSolid, CapButt, JoinMiter); | |
432 | XSetGraphicsExposures(xd->dpy, xd->gc, False); | |
433 | ||
434 | #ifndef MSDOS | |
435 | { int major, minor, event, error, pixmaps; | |
436 | if (WireMode || | |
437 | (XQueryExtension(xd->dpy, "MIT-SHM", /* Jeez! */ | |
438 | &major, &event, &error) != True) || | |
439 | (XShmQueryVersion(xd->dpy, | |
440 | &major, &minor, &pixmaps) != True)) { | |
441 | fprintf(stderr, | |
442 | "Darn, X display \"%s\" doesn't support the shared memory extension.\n", | |
443 | xd->display); | |
444 | xd->shared = 0; | |
445 | } else { | |
446 | if (!pixmaps) { | |
447 | fprintf(stderr, | |
448 | "Darn, X display \"%s\" claims to support the shared memory extension,\n", | |
449 | xd->display); | |
450 | fprintf(stderr, | |
451 | "but is too lame to support shared memory pixmaps, so Micropolis will run slower.\n"); | |
452 | fprintf(stderr, | |
453 | "Please complain to your X server vendor, %s\n", | |
454 | XServerVendor(xd->dpy)); | |
455 | xd->shared = -1; | |
456 | } else { | |
457 | fprintf(stderr, | |
458 | "Cool, I found the shared memory extension!\n"); | |
e20a2581 | 459 | xd->shared = 1; |
6a5fa4e0 MG |
460 | } |
461 | } | |
462 | } | |
463 | #else | |
464 | xd->shared = 0; | |
465 | #endif | |
466 | ||
467 | xd->request = -1; | |
468 | xd->last_request_read = -1; | |
469 | xd->big_tile_pixmap = None; | |
470 | xd->objects = NULL; | |
471 | xd->overlay_gc = NULL; | |
472 | xd->gray25_stipple = None; | |
473 | xd->gray50_stipple = None; | |
474 | xd->gray75_stipple = None; | |
475 | xd->vert_stipple = None; | |
476 | xd->horiz_stipple = None; | |
477 | xd->diag_stipple = None; | |
478 | ||
479 | xd->big_tile_image = xd->small_tile_image = NULL; | |
480 | ||
481 | xd->next = XDisplays; XDisplays = xd; | |
482 | } | |
483 | ||
484 | return (xd); | |
485 | } | |
486 | ||
487 | ||
488 | IncRefDisplay(XDisplay *xd) | |
489 | { | |
490 | xd->references++; | |
491 | } | |
492 | ||
493 | ||
494 | DecRefDisplay(XDisplay *xd) | |
495 | { | |
496 | if ((--xd->references) == 0) { | |
497 | /* I'd blow it away, but tk may still be using the display */ | |
498 | } | |
499 | } | |
500 | ||
501 | ||
502 | SimView * | |
503 | InitNewView(SimView *view, char *title, int class, int w, int h) | |
504 | { | |
505 | int type, i; | |
efad9d6d | 506 | int test = 1; |
6a5fa4e0 MG |
507 | int d = 8; |
508 | unsigned long valuemask = 0; | |
509 | char *t; | |
510 | struct XDisplay *xd; | |
511 | XGCValues values; | |
512 | XColor rgb, *color; | |
513 | ||
514 | t = (char *)ckalloc(strlen(title) + 1); | |
515 | strcpy(t, title); | |
516 | ||
517 | view->next = NULL; | |
518 | view->title = t; | |
519 | view->type = -1; | |
520 | view->class = class; | |
521 | view->bigtiles = view->smalltiles = NULL; | |
522 | view->pixels = NULL; | |
523 | view->line_bytes = 0; | |
524 | view->line_bytes8 = 0; | |
525 | view->pixel_bytes = 0; | |
526 | view->depth = 0; | |
527 | view->data = NULL; | |
528 | view->data8 = NULL; | |
529 | view->visible = 0; | |
530 | view->invalid = 0; | |
531 | view->skips = view->skip = 0; | |
532 | view->update = 0; | |
533 | view->map_state = ALMAP; | |
534 | view->show_editors = 1; | |
535 | view->tool_showing = 0; | |
536 | view->tool_mode = 0; | |
537 | view->tool_x = view->tool_y = 0; | |
538 | view->tool_x_const = view->tool_y_const = -1; | |
539 | view->tool_state = dozeState; | |
540 | view->tool_state_save = -1; | |
541 | view->super_user = 0; | |
542 | view->show_me = 1; | |
543 | view->dynamic_filter = 0; | |
544 | view->auto_scroll_token = 0; | |
545 | view->tool_event_time = 0; | |
546 | view->tool_last_event_time = 0; | |
547 | view->w_x = view->w_y = 0; | |
548 | view->w_width = view->w_height = 16; | |
549 | view->m_width = view->m_height = 0; | |
550 | view->i_width = w; view->i_height = h; | |
551 | view->pan_x = view->pan_y = 0; | |
552 | view->tile_x = view->tile_y = 0; | |
553 | view->tile_width = view->tile_height = 0; | |
554 | view->screen_x = view->screen_y = 0; | |
555 | view->screen_width = view->screen_height = 0; | |
556 | view->last_x = view->last_y = view->last_button = 0; | |
557 | view->track_info = NULL; | |
558 | view->message_var = NULL; | |
559 | ||
560 | /* This stuff was initialized in our caller (SimViewCmd) */ | |
561 | /* view->tkwin = NULL; */ | |
562 | /* view->interp = NULL; */ | |
563 | /* view->flags = 0; */ | |
564 | ||
565 | view->x = NULL; | |
566 | view->shminfo = NULL; | |
567 | view->tiles = NULL; | |
568 | view->other_tiles = NULL; | |
569 | view->image = NULL; | |
570 | view->other_image = NULL; | |
571 | view->other_data = NULL; | |
572 | view->pixmap = None; | |
573 | view->pixmap2 = None; | |
574 | view->overlay_pixmap = None; | |
575 | view->overlay_valid = 0; | |
576 | view->fontPtr = NULL; | |
577 | view->updates = 0; | |
578 | view->update_real = view->update_user = view->update_system = 0.0; | |
579 | view->update_context = 0; | |
580 | view->auto_goto = 0; | |
581 | view->auto_going = 0; | |
582 | view->auto_x_goal = view->auto_x_goal = 0; | |
583 | view->auto_speed = 75; | |
584 | view->follow = NULL; | |
585 | view->sound = 1; | |
586 | view->width = 0; view->height = 0; | |
587 | view->show_overlay = 1; | |
588 | view->overlay_mode = 0; | |
589 | ||
590 | view->x = FindXDisplay(view->tkwin); | |
591 | IncRefDisplay(view->x); | |
592 | ||
593 | /* view->x->shared is 1 if the shared memory extension is present and | |
594 | supports shared memory pixmaps, and -1 if it is present but doesn't. */ | |
595 | if (view->x->shared != 1) { | |
596 | view->type = X_Wire_View; | |
597 | } else { | |
598 | view->type = X_Mem_View; | |
599 | } | |
600 | ||
42be101d | 601 | view->x->needs_swap = !(*(unsigned char*) (&test)); |
276e43ba | 602 | view->x->x_big_endian = (ImageByteOrder(view->x->dpy) == MSBFirst); |
efad9d6d | 603 | |
99c730ea | 604 | |
6a5fa4e0 MG |
605 | GetPixmaps(view->x); |
606 | view->pixels = view->x->pixels; | |
607 | ||
608 | if (w == EDITOR_W) w = 256; /* XXX */ | |
609 | if (h == EDITOR_H) h = 256; /* XXX */ | |
610 | ||
611 | view->pan_x = w / 2; view->pan_y = h / 2; | |
612 | DoResizeView(view, w, h); | |
613 | ||
6a5fa4e0 MG |
614 | return (view); |
615 | } | |
616 | ||
617 | ||
618 | DestroyView(SimView *view) | |
619 | { | |
620 | SimView **vp; | |
621 | ||
622 | CancelRedrawView(view); | |
623 | ||
624 | for (vp = ((view->class == Editor_Class) ? | |
625 | (&sim->editor) : (&sim->map)); | |
626 | (*vp) != NULL; | |
627 | vp = &((*vp)->next)) { | |
628 | if ((*vp) == view) { | |
629 | (*vp) = view->next; | |
630 | if (view->class == Editor_Class) | |
631 | sim->editors--; | |
632 | else | |
633 | sim->maps--; | |
634 | ||
635 | break; | |
636 | } | |
637 | } | |
638 | ||
639 | if (view->title != NULL) { | |
640 | ckfree (view->title); | |
641 | view->title = NULL; | |
642 | } | |
643 | ||
644 | if (view->pixmap != None) { | |
645 | XFreePixmap(view->x->dpy, view->pixmap); | |
646 | view->pixmap = None; | |
647 | } | |
648 | ||
649 | if (view->pixmap2 != None) { | |
650 | XFreePixmap(view->x->dpy, view->pixmap2); | |
651 | view->pixmap2 = None; | |
652 | } | |
653 | ||
654 | if (view->overlay_pixmap != None) { | |
655 | XFreePixmap(view->x->dpy, view->overlay_pixmap); | |
656 | view->overlay_pixmap = None; | |
657 | } | |
658 | ||
659 | if (view->auto_scroll_token) { | |
660 | Tk_DeleteTimerHandler(view->auto_scroll_token); | |
661 | view->auto_scroll_token = 0; | |
662 | } | |
663 | ||
664 | #ifndef MSDOS | |
665 | if (view->shminfo) { | |
666 | XShmDetach(view->x->dpy, view->shminfo); | |
667 | shmdt(view->shminfo->shmaddr); | |
668 | shmctl(view->shminfo->shmid, IPC_RMID, 0); | |
669 | ckfree(view->shminfo); | |
670 | view->shminfo = NULL; | |
671 | if (view->image) { | |
672 | view->image->data = NULL; | |
673 | view->data = NULL; | |
674 | XDestroyImage(view->image); | |
675 | view->image = NULL; | |
676 | } | |
677 | } else { | |
678 | #endif | |
679 | if (view->image) { | |
680 | if (view->image->data) { | |
681 | ckfree(view->image->data); | |
682 | view->image->data = NULL; | |
683 | } | |
684 | view->data = NULL; | |
685 | XDestroyImage(view->image); | |
686 | view->image = NULL; | |
687 | } | |
688 | #ifndef MSDOS | |
689 | } | |
690 | #endif | |
691 | ||
692 | if (view->other_image) { | |
693 | if (view->other_image->data) { | |
694 | ckfree(view->other_image->data); | |
695 | view->other_image->data = NULL; | |
696 | } | |
697 | view->other_data = NULL; | |
698 | XDestroyImage(view->other_image); | |
699 | view->other_image = NULL; | |
700 | } | |
701 | ||
702 | if (view->tiles) | |
703 | FreeTiles(view); | |
704 | ||
705 | DecRefDisplay(view->x); | |
706 | ||
707 | ckfree((char *) view); | |
708 | } | |
709 | ||
710 | ||
711 | unsigned char * | |
712 | AllocPixels(int len, unsigned char pixel) | |
713 | { | |
714 | int i; | |
715 | unsigned char *data, *cp; | |
716 | ||
717 | cp = data = (unsigned char *)ckalloc(len); | |
718 | for (i = len; i > 0; i--) { | |
719 | *(cp++) = pixel; | |
720 | } | |
721 | ||
722 | return (data); | |
723 | } | |
724 | ||
725 | ||
726 | DoResizeView(SimView *view, int w, int h) | |
727 | { | |
728 | int resize = 0; | |
729 | ||
730 | view->w_width = w; | |
731 | view->w_height = h; | |
732 | ||
733 | if (view->class == Map_Class) { /* Map_Class */ | |
734 | view->m_width = w; | |
735 | view->m_height = h; | |
736 | ||
737 | if (view->pixmap2 == None) { | |
738 | ||
739 | view->pixmap2 = XCreatePixmap(view->x->dpy, view->x->root, | |
740 | w, h, view->x->depth); | |
741 | if (view->pixmap2 == None) { | |
742 | fprintf(stderr, | |
743 | "Sorry, Micropolis can't create a pixmap on X display \"%s\"!\n", | |
744 | view->x->display); | |
745 | sim_exit(1); // Just sets tkMustExit and ExitReturn | |
746 | return; | |
747 | } | |
748 | } | |
749 | ||
750 | } else { /* Editor_Class */ | |
751 | ||
752 | if ((w = (w + 31) & (~15)) > view->m_width) | |
753 | view->m_width = w, resize++; | |
754 | if ((h = (h + 31) & (~15)) > view->m_height) | |
755 | view->m_height = h, resize++; | |
756 | ||
757 | if (resize || (view->pixmap2 == None)) { | |
758 | if (view->pixmap2 != None) { | |
759 | XFreePixmap(view->x->dpy, view->pixmap2); | |
760 | view->pixmap2 = None; | |
761 | } | |
762 | view->pixmap2 = XCreatePixmap(view->x->dpy, view->x->root, | |
763 | view->m_width, view->m_height, | |
764 | view->x->depth); | |
765 | if (view->pixmap2 == None) { | |
766 | fprintf(stderr, | |
767 | "Sorry, Micropolis couldn't create a pixmap on X display \"%s\"!\n", | |
768 | view->x->display); | |
769 | sim_exit(1); // Just sets tkMustExit and ExitReturn | |
770 | return; | |
771 | } | |
772 | } | |
773 | ||
774 | if (resize || (view->overlay_pixmap == None)) { | |
775 | view->overlay_mode = 0; | |
776 | if (view->overlay_pixmap != None) { | |
777 | XFreePixmap(view->x->dpy, view->overlay_pixmap); | |
778 | view->overlay_pixmap = None; | |
779 | } | |
780 | view->overlay_pixmap = XCreatePixmap(view->x->dpy, view->x->root, | |
781 | view->m_width, view->m_height, | |
782 | 1); | |
783 | if (view->overlay_pixmap == None) { | |
784 | fprintf(stderr, | |
785 | "Sorry, Micropolis couldn't create another pixmap on X display \"%s\".\n", | |
786 | view->x->display); | |
787 | sim_exit(1); // Just sets tkMustExit and ExitReturn | |
788 | return; | |
789 | } | |
790 | if (view->x->overlay_gc == NULL) { | |
791 | unsigned long valuemask = 0; | |
792 | XGCValues values; | |
793 | ||
794 | view->x->overlay_gc = | |
795 | XCreateGC(view->x->dpy, view->overlay_pixmap, valuemask, &values); | |
796 | XSetForeground(view->x->dpy, view->x->overlay_gc, 0); | |
797 | XSetBackground(view->x->dpy, view->x->overlay_gc, 1); | |
798 | XSetLineAttributes(view->x->dpy, view->x->overlay_gc, | |
799 | 1, LineSolid, CapButt, JoinMiter); | |
800 | XSetGraphicsExposures(view->x->dpy, view->x->overlay_gc, False); | |
801 | } | |
802 | } | |
803 | ||
804 | } | |
805 | ||
806 | #ifndef MSDOS | |
807 | if (view->type != X_Mem_View) { | |
808 | goto SPRING_FORWARD; | |
809 | } | |
810 | ||
811 | if (resize || (view->image == NULL)) { | |
812 | if (view->shminfo && view->image) { | |
813 | if (view->pixmap != None) { | |
814 | XFreePixmap(view->x->dpy, view->pixmap); | |
815 | view->pixmap = None; | |
816 | } | |
817 | XShmDetach(view->x->dpy, view->shminfo); | |
818 | shmdt(view->shminfo->shmaddr); | |
819 | shmctl(view->shminfo->shmid, IPC_RMID, 0); | |
820 | view->image->data = NULL; | |
821 | if (view->data == view->data8) | |
822 | view->data8 = NULL; | |
823 | view->data = NULL; | |
824 | XDestroyImage(view->image); | |
825 | view->image = NULL; | |
826 | } | |
827 | ||
828 | #if 0 | |
829 | /* XShmPixmapFormat is documented but does not exist !!! */ | |
830 | if (XShmPixmapFormat(view->x->dpy) != ZPixmap) { | |
831 | fprintf(stderr, | |
832 | "Darn, display \"%s\" has the wrong shared memory format.\n", | |
833 | view->x->display); | |
834 | goto FALL_BACK; | |
835 | } | |
836 | #endif | |
837 | ||
838 | if (!view->shminfo) { | |
839 | view->shminfo = (XShmSegmentInfo *)ckalloc(sizeof (XShmSegmentInfo)); | |
840 | } | |
841 | ||
842 | view->image = | |
843 | XShmCreateImage(view->x->dpy, view->x->visual, view->x->depth, | |
844 | view->x->color ? ZPixmap : XYBitmap, | |
845 | NULL, view->shminfo, | |
846 | view->m_width, view->m_height); | |
847 | ||
848 | view->line_bytes = view->image->bytes_per_line; | |
849 | ||
850 | switch (view->x->depth) { | |
851 | ||
852 | case 1: | |
853 | view->pixel_bytes = 0; | |
854 | view->depth = 1; | |
855 | break; | |
856 | ||
857 | case 8: | |
858 | view->pixel_bytes = 1; | |
859 | view->depth = 8; | |
860 | break; | |
861 | ||
862 | case 15: | |
863 | view->pixel_bytes = 2; | |
864 | view->depth = 15; | |
865 | break; | |
866 | ||
867 | case 16: | |
868 | view->pixel_bytes = 2; | |
869 | view->depth = 16; | |
870 | break; | |
871 | ||
872 | case 24: | |
873 | /* XXX: TODO: 24 and 32 bit support */ | |
874 | view->pixel_bytes = 4; | |
875 | //view->pixel_bytes = 3; | |
876 | view->depth = 24; | |
877 | break; | |
878 | ||
879 | case 32: | |
880 | /* XXX: TODO: 24 and 32 bit support */ | |
881 | view->pixel_bytes = 4; | |
882 | view->depth = 32; | |
883 | break; | |
884 | ||
885 | default: | |
886 | view->pixel_bytes = 0; | |
887 | view->depth = 0; | |
888 | break; | |
889 | ||
890 | } // switch | |
891 | ||
892 | view->shminfo->shmid = shmget(IPC_PRIVATE, | |
893 | (view->line_bytes * | |
894 | view->m_height), | |
895 | (IPC_CREAT | 0777)); | |
896 | if (view->shminfo->shmid < 0) { | |
897 | perror("shmget"); | |
898 | fprintf(stderr, | |
899 | "Darn, Micropolis can't share memory with X display \"%s\".\n", | |
900 | view->x->display); | |
901 | goto FALL_BACK; | |
902 | } | |
903 | ||
904 | view->data = (unsigned char *)shmat(view->shminfo->shmid, 0, 0); | |
905 | if ((int)view->data == -1) { | |
906 | perror("shmat"); | |
907 | fprintf(stderr, | |
908 | "Darn, Micropolis can't find any memory to share with display \"%s\".\n", | |
909 | view->x->display); | |
910 | goto FALL_BACK; | |
911 | } | |
912 | ||
913 | view->image->data = (char *)view->data; | |
914 | view->shminfo->shmaddr = (char *)view->data; | |
915 | view->shminfo->readOnly = False; | |
916 | ||
917 | { int (*old)(); | |
918 | int result; | |
919 | int attached = 0; | |
920 | GotXError = 0; | |
921 | old = XSetErrorHandler(CatchXError); | |
922 | ||
923 | result = | |
924 | XShmAttach(view->x->dpy, view->shminfo); | |
925 | if (result == 0) { | |
926 | fprintf(stderr, | |
927 | "Darn, the X display \"%s\" can't access Micropolis's shared memory.\n", | |
928 | view->x->display); | |
929 | GotXError = 1; | |
930 | } | |
931 | ||
932 | XSync(view->x->dpy, False); | |
933 | ||
934 | if (!GotXError) { | |
935 | attached = 1; | |
936 | view->pixmap = XShmCreatePixmap(view->x->dpy, view->x->root, | |
937 | view->data, view->shminfo, | |
938 | view->m_width, view->m_height, | |
939 | view->x->depth); | |
940 | XSync(view->x->dpy, False); | |
941 | ||
942 | if (GotXError || | |
943 | (view->pixmap == None)) { | |
944 | fprintf(stderr, | |
945 | "Darn, Micropolis couldn't get a shared memory pixmap on X display \"%s\".\n", | |
946 | view->x->display); | |
947 | GotXError = 1; | |
948 | } | |
949 | } | |
950 | ||
951 | XSetErrorHandler(old); | |
952 | ||
953 | if (GotXError) { | |
954 | view->pixmap = None; | |
955 | if (attached) { | |
956 | XShmDetach(view->x->dpy, view->shminfo); | |
957 | } // if | |
958 | result = shmdt(view->shminfo->shmaddr); | |
959 | result = shmctl(view->shminfo->shmid, IPC_RMID, 0); | |
960 | ckfree(view->shminfo); | |
961 | view->shminfo = NULL; | |
962 | if (view->image) { | |
963 | view->image->data = NULL; | |
964 | view->data = NULL; | |
965 | XDestroyImage(view->image); | |
966 | view->image = NULL; | |
967 | } | |
968 | goto FALL_BACK; | |
969 | } | |
970 | ||
971 | if (view->x->color) { | |
972 | XSetForeground(view->x->dpy, view->x->gc, | |
973 | view->pixels[COLOR_LIGHTBROWN]); | |
974 | } else { | |
975 | XSetForeground(view->x->dpy, view->x->gc, | |
976 | view->pixels[COLOR_WHITE]); | |
977 | } | |
978 | ||
979 | XFillRectangle(view->x->dpy, view->pixmap, view->x->gc, | |
980 | 0, 0, view->m_width, view->m_height); | |
981 | } | |
982 | } | |
983 | ||
984 | goto FINISH; | |
985 | ||
986 | FALL_BACK: | |
987 | ||
988 | fprintf(stderr, | |
989 | "Falling back to the X network protocol on display \"%s\"...\n", | |
990 | view->x->display); | |
991 | #endif | |
992 | ||
993 | view->x->shared = 0; | |
994 | view->type = X_Wire_View; | |
995 | if (view->pixmap != None) { | |
996 | XFreePixmap(view->x->dpy, view->pixmap); | |
997 | view->pixmap = None; | |
998 | } | |
999 | #ifndef MSDOS | |
1000 | if (view->shminfo) { | |
1001 | if (view->shminfo->shmid >= 0) { | |
1002 | if (view->shminfo->shmaddr) { | |
1003 | shmdt(view->shminfo->shmaddr); | |
1004 | } | |
1005 | shmctl(view->shminfo->shmid, IPC_RMID, 0); | |
1006 | } | |
1007 | ckfree((char *)view->shminfo); | |
1008 | view->shminfo = NULL; | |
1009 | } | |
1010 | #endif | |
1011 | if (view->image) { | |
1012 | view->image->data = NULL; | |
1013 | XDestroyImage(view->image); | |
1014 | view->image = NULL; | |
1015 | } | |
1016 | view->data = NULL; | |
1017 | view->line_bytes = 0; | |
1018 | view->pixel_bytes = 0; | |
1019 | view->depth = 0; | |
1020 | ||
1021 | SPRING_FORWARD: | |
1022 | ||
1023 | if (resize || (view->pixmap == None)) { | |
1024 | if (view->pixmap != None) { | |
1025 | XFreePixmap(view->x->dpy, view->pixmap); | |
1026 | view->pixmap = None; | |
1027 | } | |
1028 | view->pixmap = XCreatePixmap(view->x->dpy, view->x->root, | |
1029 | view->m_width, view->m_height, | |
1030 | view->x->depth); | |
1031 | if (view->pixmap == None) { | |
1032 | fprintf(stderr, | |
1033 | "Sorry, Micropolis can't create pixmap on X display \"%s\".\n", | |
1034 | view->x->display); | |
1035 | sim_exit(1); // Just sets tkMustExit and ExitReturn | |
1036 | return; | |
1037 | } | |
1038 | if (view->x->color) { | |
1039 | XSetForeground(view->x->dpy, view->x->gc, | |
1040 | view->pixels[COLOR_LIGHTBROWN]); | |
1041 | } else { | |
1042 | XSetForeground(view->x->dpy, view->x->gc, | |
1043 | view->pixels[COLOR_WHITE]); | |
1044 | } | |
1045 | XFillRectangle(view->x->dpy, view->pixmap, view->x->gc, | |
1046 | 0, 0, view->m_width, view->m_height); | |
1047 | } | |
1048 | ||
1049 | FINISH: | |
1050 | ||
1051 | if (view->class == Editor_Class) { | |
1052 | ||
1053 | AllocTiles(view); | |
1054 | DoAdjustPan(view); | |
1055 | ||
1056 | } else if (view->class == Map_Class) { | |
1057 | ||
1058 | if (view->type == X_Mem_View) { /* Memory Map */ | |
1059 | ||
1060 | if (view->x->color) { | |
1061 | ||
1062 | /* Color, Shared Memory */ | |
1063 | ||
1064 | view->data8 = view->data; | |
1065 | view->line_bytes8 = view->line_bytes; /* XXX: ??? */ | |
1066 | ||
1067 | switch (view->x->depth) { | |
1068 | ||
1069 | case 8: | |
1070 | view->pixel_bytes = 1; | |
1071 | view->depth = 8; | |
1072 | break; | |
1073 | ||
1074 | case 15: | |
1075 | view->pixel_bytes = 2; | |
1076 | view->depth = 15; | |
1077 | break; | |
1078 | ||
1079 | case 16: | |
1080 | view->pixel_bytes = 2; | |
1081 | view->depth = 16; | |
1082 | break; | |
1083 | ||
1084 | case 24: | |
1085 | /* XXX: TODO: 24 and 32 bit support */ | |
1086 | view->pixel_bytes = 4; | |
1087 | //view->pixel_bytes = 3; | |
1088 | view->depth = 24; | |
1089 | break; | |
1090 | ||
1091 | case 32: | |
1092 | /* XXX: TODO: 24 and 32 bit support */ | |
1093 | view->pixel_bytes = 4; | |
1094 | view->depth = 32; | |
1095 | break; | |
1096 | ||
1097 | default: | |
1098 | view->pixel_bytes = 0; | |
1099 | view->depth = 0; | |
1100 | break; | |
1101 | ||
1102 | } // switch | |
1103 | ||
1104 | } else { | |
1105 | ||
1106 | /* Black and White, Shared Memory */ | |
1107 | ||
1108 | if (view->other_image != NULL) { | |
1109 | XDestroyImage(view->other_image); | |
1110 | } | |
1111 | ||
1112 | view->line_bytes8 = view->m_width; /* XXX: fix depth */ | |
1113 | view->pixel_bytes = 0; | |
1114 | view->depth = 1; | |
1115 | ||
1116 | view->other_data = view->data8 = | |
1117 | AllocPixels(view->m_height * view->line_bytes8, /* XXX: fix depth */ | |
1118 | view->pixels[COLOR_WHITE]); | |
1119 | view->other_image = | |
1120 | XCreateImage(view->x->dpy, view->x->visual, 8, /* XXX: fix depth */ | |
1121 | ZPixmap, 0, (char *)view->other_data, | |
1122 | view->m_width, view->m_height, | |
1123 | 8, view->line_bytes8); /* XXX: fix depth */ | |
1124 | } | |
1125 | ||
1126 | } else { /* Wire Map */ | |
1127 | int bitmap_pad; | |
1128 | int bitmap_depth; | |
1129 | ||
1130 | if (view->image != NULL) { | |
1131 | XDestroyImage(view->image); | |
1132 | view->image = NULL; | |
1133 | } | |
1134 | ||
1135 | if (view->other_image != NULL) { | |
1136 | XDestroyImage(view->other_image); | |
1137 | view->other_image = NULL; | |
1138 | } | |
1139 | ||
1140 | if (view->x->color) { | |
1141 | ||
1142 | /* Color, Wire */ | |
1143 | ||
1144 | switch (view->x->depth) { | |
1145 | ||
1146 | case 8: | |
1147 | view->pixel_bytes = 1; | |
1148 | view->depth = 8; | |
1149 | bitmap_pad = 8; | |
1150 | bitmap_depth = 8; | |
1151 | view->line_bytes8 = | |
1152 | ((view->m_width * view->pixel_bytes) + 3) & (~3); | |
1153 | break; | |
1154 | ||
1155 | case 15: | |
1156 | view->pixel_bytes = 2; | |
1157 | view->depth = 15; | |
1158 | bitmap_pad = 16; | |
0ac8627d | 1159 | bitmap_depth = 15; |
6a5fa4e0 MG |
1160 | view->line_bytes8 = |
1161 | ((view->m_width * view->pixel_bytes) + 3) & (~3); | |
1162 | break; | |
1163 | ||
1164 | case 16: | |
1165 | view->pixel_bytes = 2; | |
1166 | view->depth = 16; | |
1167 | bitmap_pad = 16; | |
1168 | bitmap_depth = 16; | |
1169 | view->line_bytes8 = | |
1170 | ((view->m_width * view->pixel_bytes) + 3) & (~3); | |
1171 | break; | |
1172 | ||
1173 | case 24: | |
1174 | view->pixel_bytes = 4; | |
1175 | //view->pixel_bytes = 3; | |
1176 | view->depth = 24; | |
93200beb | 1177 | bitmap_depth = 24; |
6a5fa4e0 MG |
1178 | bitmap_pad = 32; |
1179 | view->line_bytes8 = | |
1180 | ((view->m_width * 4) + 3) & (~3); | |
1181 | break; | |
1182 | ||
1183 | case 32: | |
1184 | view->pixel_bytes = 4; | |
1185 | view->depth = 32; | |
1186 | bitmap_pad = 32; | |
1187 | bitmap_depth = 32; | |
1188 | view->line_bytes8 = | |
1189 | ((view->m_width * 4) + 3) & (~3); | |
1190 | break; | |
1191 | ||
1192 | default: | |
1193 | assert(0); /* Unknown depth */ | |
1194 | break; | |
1195 | ||
1196 | } // switch | |
1197 | ||
1198 | view->line_bytes = | |
1199 | view->line_bytes8; | |
1200 | ||
1201 | } else { | |
1202 | ||
1203 | /* Black and White, Wire */ | |
1204 | ||
1205 | view->pixel_bytes = 0; | |
1206 | view->depth = 1; | |
1207 | view->line_bytes8 = | |
1208 | (view->m_width + 3) & (~3); /* XXX: handle depth */ | |
1209 | view->line_bytes = | |
1210 | (view->m_width + 7) >>3; | |
1211 | bitmap_pad = 8; | |
1212 | bitmap_depth = 8; | |
1213 | ||
1214 | } | |
1215 | ||
1216 | view->data = | |
1217 | AllocPixels(view->m_height * view->line_bytes, 0); | |
1218 | view->image = | |
1219 | XCreateImage(view->x->dpy, view->x->visual, | |
1220 | bitmap_depth, | |
1221 | view->x->color ? ZPixmap : XYBitmap, | |
1222 | 0, (char *)view->data, | |
1223 | view->m_width, view->m_height, | |
1224 | bitmap_pad, | |
1225 | view->line_bytes); | |
1226 | ||
1227 | view->other_data = | |
1228 | AllocPixels(view->m_height * view->line_bytes8, 0); | |
1229 | view->other_image = | |
1230 | XCreateImage(view->x->dpy, view->x->visual, | |
1231 | bitmap_depth, | |
1232 | ZPixmap, | |
1233 | 0, (char *)view->other_data, | |
1234 | view->m_width, view->m_height, | |
1235 | bitmap_pad, | |
1236 | view->line_bytes); | |
1237 | ||
1238 | if (view->x->color) { | |
1239 | view->data8 = view->data; | |
1240 | } else { | |
1241 | view->data8 = view->other_data; | |
1242 | } | |
1243 | } | |
1244 | } | |
06fa6a70 MG |
1245 | |
1246 | GetViewTiles(view); | |
1247 | ||
6a5fa4e0 MG |
1248 | } |
1249 | ||
1250 | ||
1251 | DoPanBy(struct SimView *view, int dx, int dy) | |
1252 | { | |
1253 | DoPanTo(view, view->pan_x + dx, view->pan_y + dy); | |
1254 | } | |
1255 | ||
1256 | ||
1257 | DoPanTo(struct SimView *view, int x, int y) | |
1258 | { | |
1259 | if (view->class != Editor_Class) { | |
1260 | return; | |
1261 | } | |
1262 | ||
1263 | if (x < 0) x = 0; | |
1264 | if (y < 0) y = 0; | |
1265 | if (x > view->i_width) x = view->i_width - 1; | |
1266 | if (y > view->i_height) y = view->i_height - 1; | |
1267 | if ((view->pan_x != x) || | |
1268 | (view->pan_y != y)) { | |
1269 | view->pan_x = x; | |
1270 | view->pan_y = y; | |
1271 | DoAdjustPan(view); | |
1272 | } | |
1273 | } | |
1274 | ||
1275 | /* #define DEBUG_PAN */ | |
1276 | ||
1277 | DoAdjustPan(struct SimView *view) | |
1278 | { | |
1279 | int ww2 = view->w_width >>1, wh2 = view->w_height >>1; | |
1280 | int px = view->pan_x, py = view->pan_y; | |
1281 | int last_tile_x = view->tile_x, last_tile_y = view->tile_y; | |
1282 | int last_tile_width = view->tile_width, last_tile_height = view->tile_height; | |
1283 | int total_width = view->m_width >>4, total_height = view->m_height >>4; | |
1284 | //fprintf(stderr, "DoAdjustPan\n"); | |
1285 | ||
1286 | #ifdef DEBUG_PAN | |
1287 | printf("AdjustPan window %d %d ww2 %d wh2 %d pan %d %d\n", | |
1288 | view->w_width, view->w_height, ww2, wh2, px, py); | |
1289 | printf(" last tile %d %d %d %d\n", | |
1290 | last_tile_x, last_tile_y, last_tile_width, last_tile_height); | |
1291 | #endif | |
1292 | ||
1293 | if ((view->tile_x = ((px - ww2) >>4)) < 0) | |
1294 | view->tile_x = 0; | |
1295 | if ((view->tile_y = ((py - wh2) >>4)) < 0) | |
1296 | view->tile_y = 0; | |
1297 | ||
1298 | #ifdef DEBUG_PAN | |
1299 | printf(" now tile %d %d\n", view->tile_x, view->tile_y); | |
1300 | #endif | |
1301 | ||
1302 | view->tile_width = ((15 + px + ww2) >>4); | |
1303 | view->tile_height = ((15 + py + wh2) >>4); | |
1304 | ||
1305 | #ifdef DEBUG_PAN | |
1306 | printf(" outer tile %d %d\n", view->tile_width, view->tile_height); | |
1307 | #endif | |
1308 | ||
1309 | if (view->tile_width > (view->i_width >>4)) | |
1310 | view->tile_width = (view->i_width >>4); | |
1311 | view->tile_width -= view->tile_x; | |
1312 | if (view->tile_height > (view->i_height >>4)) | |
1313 | view->tile_height = (view->i_height >>4); | |
1314 | view->tile_height -= view->tile_y; | |
1315 | ||
1316 | #ifdef DEBUG_PAN | |
1317 | printf(" tile size %d %d\n", view->tile_width, view->tile_height); | |
1318 | #endif | |
1319 | ||
1320 | if (view->tile_width > (view->m_width >>4)) | |
1321 | view->tile_width = (view->m_width >>4); | |
1322 | if (view->tile_height > (view->m_height >>4)) | |
1323 | view->tile_height = (view->m_height >>4); | |
1324 | ||
1325 | #ifdef DEBUG_PAN | |
1326 | printf(" clipped size %d %d\n", view->tile_width, view->tile_height); | |
1327 | printf(" maximum size %d %d\n", view->m_width >>4, view->m_height >>4); | |
1328 | #endif | |
1329 | ||
1330 | view->screen_x = (ww2 - px) + (view->tile_x <<4); | |
1331 | view->screen_y = (wh2 - py) + (view->tile_y <<4); | |
1332 | view->screen_width = (view->tile_width <<4); | |
1333 | view->screen_height = (view->tile_height <<4); | |
1334 | ||
1335 | #ifdef DEBUG_PAN | |
1336 | printf(" screen %d %d %d %d\n", | |
1337 | view->screen_x, view->screen_y, | |
1338 | view->screen_width, view->screen_height); | |
1339 | #endif | |
1340 | ||
1341 | view->overlay_mode = 0; | |
1342 | // view->skip = 0; | |
1343 | view->invalid = 1; | |
1344 | if (SimSpeed == 0) { | |
1345 | EventuallyRedrawView(view); | |
1346 | } | |
1347 | /* InvalidateEditors(); */ | |
1348 | if (view->show_me) { | |
1349 | RedrawMaps(); | |
1350 | } | |
1351 | /* FixMicropolisTimer(); */ | |
1352 | ||
1353 | { int dx = last_tile_x - view->tile_x, | |
1354 | dy = last_tile_y - view->tile_y; | |
1355 | short **want = view->other_tiles, | |
1356 | **have = view->tiles; | |
1357 | ||
1358 | #ifdef DEBUG_PAN | |
1359 | printf("scrolling %d %d\n", dx, dy); | |
1360 | #endif | |
1361 | ||
1362 | if ((dx != 0) || (dy != 0)) { | |
1363 | int row, col, x, y, | |
1364 | width = view->tile_width, | |
1365 | height = view->tile_height; | |
1366 | ||
1367 | for (col = 0; col < width; col++) | |
1368 | memcpy(want[col], have[col], (height * sizeof(short))); | |
1369 | ||
1370 | for (col = 0; col < total_width; col++) { | |
1371 | x = col - dx; | |
1372 | for (row = 0; row < total_height; row++) { | |
1373 | y = row - dy; | |
1374 | if ((x >= 0) && (x < width) && | |
1375 | (y >= 0) && (y < height)) { | |
1376 | have[col][row] = want[x][y]; | |
1377 | } else { | |
1378 | have[col][row] = -1; | |
1379 | } | |
1380 | } | |
1381 | } | |
1382 | ||
1383 | XCopyArea(view->x->dpy, view->pixmap, view->pixmap, view->x->gc, | |
1384 | 0, 0, view->tile_width <<4, view->tile_height <<4, | |
1385 | dx <<4, dy <<4); | |
1386 | ||
1387 | if (view->type == X_Mem_View) { | |
1388 | XSync(view->x->dpy, False); | |
1389 | } | |
1390 | } | |
1391 | } | |
1392 | } | |
1393 | ||
1394 | ||
1395 | AllocTiles(SimView *view) | |
1396 | { | |
1397 | int row, col; | |
1398 | short **have, **want; | |
1399 | int w = view->m_width / 16, h = view->m_height / 16; | |
1400 | int n = (w + 1) * sizeof (short *); | |
1401 | ||
1402 | if (view->tiles) | |
1403 | FreeTiles(view); | |
1404 | ||
1405 | have = view->tiles = | |
1406 | (short **)ckalloc(n); | |
1407 | ||
1408 | want = view->other_tiles = | |
1409 | (short **)ckalloc(n); | |
1410 | ||
1411 | have[w] = want[w] = NULL; | |
1412 | ||
1413 | n = h * sizeof(short); | |
1414 | for (col = 0; col < w; col++) { | |
1415 | ||
1416 | have[col] = (short *)ckalloc(n); | |
1417 | want[col] = (short *)ckalloc(n); | |
1418 | for (row = 0; row < h; row++) { | |
1419 | have[col][row] = -1; | |
1420 | want[col][row] = -1; | |
1421 | } | |
1422 | } | |
1423 | } | |
1424 | ||
1425 | ||
1426 | FreeTiles(SimView *view) | |
1427 | { | |
1428 | int col; | |
1429 | ||
1430 | for (col = 0; view->tiles[col] != NULL; col++) { | |
1431 | ckfree ((char *)view->tiles[col]); | |
1432 | ckfree ((char *)view->other_tiles[col]); | |
1433 | } | |
1434 | ckfree ((char *)view->tiles); | |
1435 | view->tiles = NULL; | |
1436 | ckfree ((char *)view->other_tiles); | |
1437 | view->other_tiles = NULL; | |
1438 | } | |
1439 | ||
1440 | ||
1441 | #define POINT_BATCH 32 | |
1442 | ||
1443 | Ink *OldInk = NULL; | |
1444 | ||
1445 | ||
1446 | /* XXX: todo: ink locking so someone doesn't erase ink that's being drawn */ | |
1447 | ||
1448 | Ink * | |
1449 | NewInk() | |
1450 | { | |
1451 | Ink *ink; | |
1452 | ||
1453 | if (OldInk) { | |
1454 | ink = OldInk; | |
1455 | OldInk = OldInk->next; | |
1456 | } else { | |
1457 | ink = (Ink *)ckalloc(sizeof(Ink)); | |
1458 | ink->maxlength = POINT_BATCH; | |
1459 | ink->points = (XPoint *)ckalloc(POINT_BATCH * sizeof(XPoint)); | |
1460 | } | |
1461 | ink->length = 0; | |
1462 | ink->color = COLOR_WHITE; | |
1463 | ink->next = NULL; | |
1464 | ink->left = ink->right = ink->top = ink->bottom = | |
1465 | ink->last_x = ink->last_y = -1; | |
1466 | return (ink); | |
1467 | } | |
1468 | ||
1469 | ||
1470 | FreeInk(Ink *ink) | |
1471 | { | |
1472 | ink->next = OldInk; | |
1473 | OldInk = ink; | |
1474 | } | |
1475 | ||
1476 | ||
1477 | StartInk(Ink *ink, int x, int y) | |
1478 | { | |
1479 | ink->length = 1; | |
1480 | ink->left = ink->right = ink->last_x = ink->points[0].x = x; | |
1481 | ink->top = ink->bottom = ink->last_y = ink->points[0].y = y; | |
1482 | } | |
1483 | ||
1484 | ||
1485 | AddInk(Ink *ink, int x, int y) | |
1486 | { | |
1487 | int dx = x - ink->last_x; | |
1488 | int dy = y - ink->last_y; | |
1489 | ||
1490 | if ((dx != 0) || (dy != 0)) { | |
1491 | /* | |
1492 | if (ink->length > 1) { | |
1493 | if ((dx == 0) && | |
1494 | (ink->points[ink->length - 1].x == 0) && | |
1495 | ((ink->points[ink->length - 1].y < 0) ? | |
1496 | (dy < 0) : (dy > 0))) { | |
1497 | ink->points[ink->length - 1].y += dy; | |
1498 | goto ADJUST; | |
1499 | } else if ((dy == 0) && | |
1500 | (ink->points[ink->length - 1].y == 0) && | |
1501 | ((ink->points[ink->length - 1].x < 0) ? | |
1502 | (dx < 0) : (dx > 0))) { | |
1503 | ink->points[ink->length - 1].x += dx; | |
1504 | goto ADJUST; | |
1505 | } | |
1506 | } | |
1507 | */ | |
1508 | ||
1509 | if (ink->length >= ink->maxlength) { | |
1510 | ink->maxlength += POINT_BATCH; | |
1511 | ink->points = (XPoint *)realloc((void *)ink->points, | |
1512 | ink->maxlength * sizeof(XPoint)); | |
1513 | } | |
1514 | ink->points[ink->length].x = dx; | |
1515 | ink->points[ink->length].y = dy; | |
1516 | ink->length++; | |
1517 | ||
1518 | ADJUST: | |
1519 | if (x < ink->left) | |
1520 | ink->left = x; | |
1521 | if (x > ink->right) | |
1522 | ink->right = x; | |
1523 | if (y < ink->top) | |
1524 | ink->top = y; | |
1525 | if (y > ink->bottom) | |
1526 | ink->bottom = y; | |
1527 | ||
1528 | { int left, right, top, bottom; | |
1529 | SimView *view; | |
1530 | ||
1531 | if (ink->last_x < x) { left = ink->last_x; right = x; } | |
1532 | else { left = x; right = ink->last_x; } | |
1533 | if (ink->last_y < y) { top = ink->last_y; bottom = y; } | |
1534 | else { top = y; bottom = ink->last_y; } | |
1535 | ||
1536 | left -= 5; right += 5; top -= 5; bottom += 5; | |
1537 | ||
1538 | for (view = sim->editor; view != NULL; view = view->next) { | |
1539 | int vleft, vtop; | |
1540 | ||
1541 | if ((right >= (vleft = view->pan_x - (view->w_width / 2))) && | |
1542 | (left <= vleft + view->w_width) && | |
1543 | (bottom >= (vtop = view->pan_y - (view->w_height / 2))) && | |
1544 | (top <= vtop + view->w_height)) { | |
1545 | /* XXX: do studly incremental update instead */ | |
1546 | view->overlay_mode = 0; | |
1547 | EventuallyRedrawView(view); | |
1548 | } | |
1549 | } | |
1550 | } | |
1551 | ink->last_x = x; ink->last_y = y; | |
1552 | } | |
1553 | } | |
1554 | ||
1555 | ||
1556 | EraseOverlay() | |
1557 | { | |
1558 | Ink *ink; | |
1559 | ||
1560 | while (sim->overlay) { | |
1561 | ink = sim->overlay; | |
1562 | sim->overlay = ink->next; | |
1563 | FreeInk(ink); | |
1564 | } | |
1565 | } |