]> git.zerfleddert.de Git - micropolis/blob - src/sim/w_x.c
projects / micropolis / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
fix real cause of crash when falling back to wire mode
[micropolis] / src / sim / w_x.c
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 if (xd->visual->red_mask == 0x7c00) { \
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)); \
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 } \
340 break; \
341 case 16: \
342 if (xd->visual->red_mask == 0xf800) { \
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)); \
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 } \
353 break; \
354 case 24: \
355 case 32: \
356 if (xd->visual->red_mask == 0xff0000) { \
357 xd->pixels[i] = \
358 ((color->red & 0xff) << 16) | \
359 ((color->green & 0xff) << 8) | \
360 ((color->blue & 0xff) << 0); \
361 } else { \
362 xd->pixels[i] = \
363 ((color->blue & 0xff) << 16) | \
364 ((color->green & 0xff) << 8) | \
365 ((color->red & 0xff) << 0); \
366 } \
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");
459 xd->shared = 1;
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;
506 int test = 1;
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
601 view->x->needs_swap = !(*(unsigned char*) (&test));
602 view->x->x_big_endian = (ImageByteOrder(view->x->dpy) == MSBFirst);
603
604
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
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;
1159 bitmap_depth = 15;
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;
1177 bitmap_depth = 24;
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 }
1245
1246 GetViewTiles(view);
1247
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 }
Micropolis
Impressum, Datenschutz