Return to w_tk.c CVS log

Up to [Micropolis - Activity] / micropolis / src / sim

Annotation of micropolis/src/sim/w_tk.c, revision 1.1

1.1     ! root        1: /* w_tk.c
        !             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  [email protected].
        !             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: #ifdef MSDOS
        !            65: #define filename2UNIX(name)    \
        !            66:     {   char *p; for (p = name; *p; p++) if (*p == '\\') *p = '/'; }
        !            67: #else
        !            68: #define filename2UNIX(name)    /**/
        !            69: #endif
        !            70: 
        !            71: 
        !            72: Tcl_Interp *tk_mainInterp = NULL;
        !            73: Tcl_CmdBuf buffer = NULL;
        !            74: Tk_TimerToken sim_timer_token = 0;
        !            75: int sim_timer_idle = 0;
        !            76: int sim_timer_set = 0;
        !            77: Tk_Window MainWindow;
        !            78: int UpdateDelayed = 0;
        !            79: int AutoScrollEdge = 16;
        !            80: int AutoScrollStep = 16;
        !            81: int AutoScrollDelay = 10;
        !            82: Tk_TimerToken earthquake_timer_token;
        !            83: int earthquake_timer_set = 0;
        !            84: int earthquake_delay = 3000;
        !            85: int PerformanceTiming;
        !            86: double FlushTime;
        !            87: int NeedRest = 0;
        !            88: 
        !            89: 
        !            90: #define DEF_VIEW_FONT  "-Adobe-Helvetica-Bold-R-Normal-*-140-*"
        !            91: 
        !            92: Tk_ConfigSpec TileViewConfigSpecs[] = {
        !            93:     {TK_CONFIG_FONT, "-font", (char *) NULL, (char *) NULL,
        !            94:        DEF_VIEW_FONT, Tk_Offset(SimView, fontPtr), 0},
        !            95:     {TK_CONFIG_STRING, "-messagevar", (char *) NULL, (char *) NULL,
        !            96:        NULL, Tk_Offset(SimView, message_var), 0},
        !            97:     {TK_CONFIG_PIXELS, "-width", "width", "Width",
        !            98:        0, Tk_Offset(SimView, width), 0},
        !            99:     {TK_CONFIG_PIXELS, "-height", "height", "Height",
        !           100:        0, Tk_Offset(SimView, height), 0},
        !           101:     {TK_CONFIG_END, (char *) NULL, (char *) NULL, (char *) NULL,
        !           102:        (char *) NULL, 0, 0}
        !           103: };
        !           104: 
        !           105: 
        !           106: int TileViewCmd(CLIENT_ARGS);
        !           107: int ConfigureTileView(Tcl_Interp *interp, SimView *view,
        !           108:                      int argc, char **argv, int flags);
        !           109: static void TileViewEventProc(ClientData clientData, XEvent *eventPtr);
        !           110: static void DestroyTileView(ClientData clientData);
        !           111: 
        !           112: int ConfigureSimGraph(Tcl_Interp *interp, SimGraph *graph,
        !           113:                      int argc, char **argv, int flags);
        !           114: 
        !           115: static void MicropolisTimerProc(ClientData clientData);
        !           116: 
        !           117: int SimCmd(CLIENT_ARGS);
        !           118: int DoEditorCmd(CLIENT_ARGS);
        !           119: int DoMapCmd(CLIENT_ARGS);
        !           120: int GraphViewCmd(CLIENT_ARGS);
        !           121: int DoGraphCmd(CLIENT_ARGS);
        !           122: int SpriteCmd(CLIENT_ARGS);
        !           123: extern int Tk_PieMenuCmd();
        !           124: extern int Tk_IntervalCmd();
        !           125: 
        !           126: 
        !           127: int
        !           128: TileViewCmd(CLIENT_ARGS)
        !           129: {
        !           130:   Tk_Window tkwin = (Tk_Window) clientData;
        !           131:   SimView *view;
        !           132:   int viewclass;
        !           133: 
        !           134:   if (argc < 2) {
        !           135:     Tcl_AppendResult(interp, "wrong # args:  should be \"",
        !           136:                     argv[0], " pathName ?options?\"", (char *) NULL);
        !           137:     return TCL_ERROR;
        !           138:   }
        !           139: 
        !           140:   if (strcmp(argv[0], "editorview") == 0)
        !           141:     viewclass = Editor_Class;
        !           142:   else if (strcmp(argv[0], "mapview") == 0)
        !           143:     viewclass = Map_Class;
        !           144:   else {
        !           145:     return TCL_ERROR;
        !           146:   }
        !           147: 
        !           148:   tkwin = Tk_CreateWindowFromPath(interp, tkwin,
        !           149:                                  argv[1], (char *) NULL);
        !           150:   if (tkwin == NULL) {
        !           151:     return TCL_ERROR;
        !           152:   }
        !           153: 
        !           154:   view = (SimView *)ckalloc(sizeof (SimView));
        !           155: 
        !           156:   view->tkwin = tkwin;
        !           157:   view->interp = interp;
        !           158:   view->flags = 0;
        !           159: 
        !           160:   if (viewclass == Editor_Class) {
        !           161:     Tk_SetClass(view->tkwin, "EditorView");
        !           162: 
        !           163:     Tk_CreateEventHandler(view->tkwin,
        !           164:                          VisibilityChangeMask |
        !           165:                          ExposureMask |
        !           166:                          StructureNotifyMask |
        !           167:                          EnterWindowMask |
        !           168:                          LeaveWindowMask |
        !           169:                          PointerMotionMask,
        !           170:                          TileViewEventProc, (ClientData) view);
        !           171:     Tcl_CreateCommand(interp, Tk_PathName(view->tkwin),
        !           172:                      DoEditorCmd, (ClientData) view, (void (*)()) NULL);
        !           173:   } else {
        !           174:     Tk_SetClass(view->tkwin, "MapView");
        !           175: 
        !           176:     Tk_CreateEventHandler(view->tkwin,
        !           177:                          VisibilityChangeMask |
        !           178:                          ExposureMask |
        !           179:                          StructureNotifyMask /* |
        !           180:                          EnterWindowMask |
        !           181:                          LeaveWindowMask |
        !           182:                          PointerMotionMask */ ,
        !           183:                          TileViewEventProc, (ClientData) view);
        !           184:     Tcl_CreateCommand(interp, Tk_PathName(view->tkwin),
        !           185:                      DoMapCmd, (ClientData) view, (void (*)()) NULL);
        !           186:   }
        !           187: 
        !           188:   Tk_MakeWindowExist(view->tkwin);
        !           189: 
        !           190:   if (getenv("XSYNCHRONIZE") != NULL) {
        !           191:     XSynchronize(Tk_Display(tkwin), 1);
        !           192:   }
        !           193: 
        !           194:   if (viewclass == Editor_Class) {
        !           195:     InitNewView(view, "MicropolisEditor", Editor_Class, EDITOR_W, EDITOR_H);
        !           196:     DoNewEditor(view);
        !           197:   } else {
        !           198:     InitNewView(view, "MicropolisMap", Map_Class, MAP_W, MAP_H);
        !           199:     DoNewMap(view);
        !           200:   }
        !           201: 
        !           202:   if (ConfigureTileView(interp, view, argc-2, argv+2, 0) != TCL_OK) {
        !           203:     /* XXX: destroy view */
        !           204:     Tk_DestroyWindow(view->tkwin);
        !           205:     return TCL_ERROR;
        !           206:   }
        !           207: 
        !           208:   switch (view->class) {
        !           209:   case Editor_Class:
        !           210:     break;
        !           211:   case Map_Class:
        !           212:     view->invalid = 1;
        !           213:     view->update = 1;
        !           214:     DoUpdateMap(view);
        !           215:     break;
        !           216:   }
        !           217: 
        !           218:   interp->result = Tk_PathName(view->tkwin);
        !           219:   return TCL_OK;
        !           220: }
        !           221: 
        !           222: 
        !           223: int
        !           224: ConfigureTileView(Tcl_Interp *interp, SimView *view,
        !           225:             int argc, char **argv, int flags)
        !           226: {
        !           227:   if (Tk_ConfigureWidget(interp, view->tkwin, TileViewConfigSpecs,
        !           228:                         argc, argv, (char *) view, flags) != TCL_OK) {
        !           229:     return TCL_ERROR;
        !           230:   }
        !           231: 
        !           232:   if (view->class == Map_Class) {
        !           233:     Tk_GeometryRequest(view->tkwin, MAP_W, MAP_H);
        !           234:   } else {
        !           235:     if (view->width || view->height) {
        !           236:       Tk_GeometryRequest(view->tkwin, view->width, view->height);
        !           237:     }
        !           238:   }
        !           239:   EventuallyRedrawView(view);
        !           240:   return TCL_OK;
        !           241: }
        !           242: 
        !           243: 
        !           244: InvalidateMaps()
        !           245: {
        !           246:   SimView *view;
        !           247: 
        !           248: //fprintf(stderr, "InvalidateMaps\n");
        !           249:   for (view = sim->map; view != NULL; view = view->next) {
        !           250:     view->invalid = 1;
        !           251:     view->skip = 0;
        !           252:     EventuallyRedrawView(view);
        !           253:   }
        !           254:   sim_skip = 0;
        !           255: }
        !           256: 
        !           257: 
        !           258: InvalidateEditors()
        !           259: {
        !           260:   SimView *view;
        !           261: 
        !           262: //fprintf(stderr, "InvalidateEditors\n");
        !           263:   for (view = sim->editor; view != NULL; view = view->next) {
        !           264:     view->invalid = 1;
        !           265:     view->skip = 0;
        !           266:     EventuallyRedrawView(view);
        !           267:   }
        !           268:   sim_skip = 0;
        !           269: }
        !           270: 
        !           271: 
        !           272: RedrawMaps()
        !           273: {
        !           274:   SimView *view;
        !           275: 
        !           276: //fprintf(stderr, "RedrawMaps\n");
        !           277: 
        !           278:   for (view = sim->map; view != NULL; view = view->next) {
        !           279:     view->skip = 0;
        !           280:     EventuallyRedrawView(view);
        !           281:   }
        !           282:   sim_skip = 0;
        !           283: }
        !           284: 
        !           285: 
        !           286: RedrawEditors()
        !           287: {
        !           288:   SimView *view;
        !           289: 
        !           290: //fprintf(stderr, "RedrawEditors\n");
        !           291: 
        !           292:   for (view = sim->editor; view != NULL; view = view->next) {
        !           293:     view->skip = 0;
        !           294:     EventuallyRedrawView(view);
        !           295:   }
        !           296:   sim_skip = 0;
        !           297: }
        !           298: 
        !           299: 
        !           300: static void
        !           301: DisplayTileView(ClientData clientData)
        !           302: {
        !           303:   SimView *view = (SimView *) clientData;
        !           304:   Tk_Window tkwin = view->tkwin;
        !           305:   Pixmap pm = None;
        !           306:   Drawable d;
        !           307: 
        !           308:   view->flags &= ~VIEW_REDRAW_PENDING;
        !           309:   if (view->visible && (tkwin != NULL) && Tk_IsMapped(tkwin)) {
        !           310:     switch (view->class) {
        !           311:     case Editor_Class:
        !           312:       view->skip = 0;
        !           313:       view->update = 1;
        !           314:       DoUpdateEditor(view);
        !           315:       break;
        !           316:     case Map_Class:
        !           317: //fprintf(stderr, "DisplayTileView\n");
        !           318:       view->skip = 0;
        !           319:       view->update = 1;
        !           320:       DoUpdateMap(view);
        !           321:       break;
        !           322:     }
        !           323:   }
        !           324: }
        !           325: 
        !           326: 
        !           327: /* comefrom:
        !           328:     ConfigureTileView
        !           329:     TileViewEventProc expose configure motion
        !           330:     InvalidateMaps
        !           331:     EraserTo
        !           332:     DoSetMapState
        !           333:     AddInk
        !           334:     EraserTo
        !           335:  */
        !           336: 
        !           337: EventuallyRedrawView(SimView *view)
        !           338: {
        !           339:   if (!(view->flags & VIEW_REDRAW_PENDING)) {
        !           340:     Tk_DoWhenIdle(DisplayTileView, (ClientData) view);
        !           341:     view->flags |= VIEW_REDRAW_PENDING;
        !           342:   }
        !           343: 
        !           344: }
        !           345: 
        !           346: 
        !           347: CancelRedrawView(SimView *view)
        !           348: {
        !           349:   if (view->flags & VIEW_REDRAW_PENDING) {
        !           350:     Tk_CancelIdleCall(DisplayTileView, (ClientData) view);
        !           351:   }
        !           352:   view->flags &= ~VIEW_REDRAW_PENDING;
        !           353: }
        !           354: 
        !           355: 
        !           356: static void
        !           357: TileAutoScrollProc(ClientData clientData)
        !           358: {
        !           359:   SimView *view = (SimView *)clientData;
        !           360:   char buf[256];
        !           361: 
        !           362:   if (view->tool_mode != 0) {
        !           363:     int dx = 0, dy = 0;
        !           364:     int result, root_x, root_y, x, y;
        !           365:     unsigned int key_buttons;
        !           366:     Window root, child;
        !           367: 
        !           368:     XQueryPointer(Tk_Display(view->tkwin), Tk_WindowId(view->tkwin),
        !           369:                  &root, &child, &root_x, &root_y, &x, &y, &key_buttons);
        !           370: 
        !           371:     if (x < AutoScrollEdge)
        !           372:       dx = -AutoScrollStep;
        !           373:     else if (x > (view->w_width - AutoScrollEdge))
        !           374:       dx = AutoScrollStep;
        !           375:     if (y < AutoScrollEdge)
        !           376:       dy = -AutoScrollStep;
        !           377:     else if (y > (view->w_height - AutoScrollEdge))
        !           378:       dy = AutoScrollStep;
        !           379: 
        !           380:     if (dx || dy) {
        !           381:       int px = view->pan_x, py = view->pan_y;
        !           382: 
        !           383:       if (view->tool_mode == -1) {
        !           384:        dx = -dx; dy = -dy;
        !           385:       }
        !           386: 
        !           387:       DoPanBy(view, dx, dy);
        !           388:       view->tool_x += view->pan_x - px;
        !           389:       view->tool_y += view->pan_y - py;
        !           390:       view->auto_scroll_token =
        !           391:        Tk_CreateTimerHandler(AutoScrollDelay, TileAutoScrollProc,
        !           392:                              (ClientData) view);
        !           393: 
        !           394:       sprintf(buf, "UIDidPan %s %d %d", Tk_PathName(view->tkwin), x, y);
        !           395:       Eval(buf);
        !           396:     }
        !           397:   }
        !           398: }
        !           399: 
        !           400: 
        !           401: static void
        !           402: TileViewEventProc(ClientData clientData, XEvent *eventPtr)
        !           403: {
        !           404:   SimView *view = (SimView *) clientData;
        !           405: 
        !           406:   if ((eventPtr->type == Expose) && (eventPtr->xexpose.count == 0)) {
        !           407:     view->visible = 1;
        !           408:     EventuallyRedrawView(view);
        !           409:   } else if (eventPtr->type == MapNotify) {
        !           410:     view->visible = 1;
        !           411:   } else if (eventPtr->type == UnmapNotify) {
        !           412:     view->visible = 0;
        !           413:   } else if (eventPtr->type == VisibilityNotify) {
        !           414:     if (eventPtr->xvisibility.state == VisibilityFullyObscured)
        !           415:       view->visible = 0;
        !           416:     else
        !           417:       view->visible = 1;
        !           418:   } else if (eventPtr->type == ConfigureNotify) {
        !           419:     if (view->class == Editor_Class)
        !           420:       DoResizeView(view,
        !           421:                   eventPtr->xconfigure.width,
        !           422:                   eventPtr->xconfigure.height);
        !           423:     EventuallyRedrawView(view);
        !           424:   } else if (eventPtr->type == DestroyNotify) {
        !           425:     Tcl_DeleteCommand(view->interp, Tk_PathName(view->tkwin));
        !           426:     view->tkwin = NULL;
        !           427:     CancelRedrawView(view);
        !           428:     Tk_EventuallyFree((ClientData) view, DestroyTileView);
        !           429:   } else if ((view->class == Editor_Class) &&
        !           430:             (view->show_me != 0) &&
        !           431:             ((eventPtr->type == EnterNotify) ||
        !           432:              (eventPtr->type == LeaveNotify) ||
        !           433:              (eventPtr->type == MotionNotify))) {
        !           434:     int last_x = view->tool_x, last_y = view->tool_y,
        !           435:         last_showing = view->tool_showing;
        !           436:     int x, y, showing, autoscroll;
        !           437: 
        !           438:     if (eventPtr->type == EnterNotify) {
        !           439:       showing = 1;
        !           440:       x = eventPtr->xcrossing.x; y = eventPtr->xcrossing.y;
        !           441:     } else if (eventPtr->type == LeaveNotify) {
        !           442:       showing = 0;
        !           443:       x = eventPtr->xcrossing.x; y = eventPtr->xcrossing.y;
        !           444:     } else {
        !           445:       showing = 1;
        !           446:       x = eventPtr->xmotion.x; y = eventPtr->xmotion.y;
        !           447:     }
        !           448: 
        !           449:     if (view->tool_mode != 0) {
        !           450: 
        !           451:       if ((x < AutoScrollEdge) ||
        !           452:          (x > (view->w_width - AutoScrollEdge)) ||
        !           453:          (y < AutoScrollEdge) ||
        !           454:          (y > (view->w_height - AutoScrollEdge))) {
        !           455:        if (!view->auto_scroll_token) {
        !           456:          view->auto_scroll_token =
        !           457:            Tk_CreateTimerHandler(AutoScrollDelay, TileAutoScrollProc,
        !           458:                                  (ClientData) view);
        !           459:        }
        !           460:       } else {
        !           461:        if (view->auto_scroll_token) {
        !           462:          Tk_DeleteTimerHandler(view->auto_scroll_token);
        !           463:          view->auto_scroll_token = 0;
        !           464:        }
        !           465:       }
        !           466:     }
        !           467: 
        !           468:     ViewToPixelCoords(view, x, y, &x, &y);
        !           469:     view->tool_showing = showing;
        !           470: 
        !           471:     if (view->tool_mode != -1) {
        !           472:       view->tool_x = x; view->tool_y = y;
        !           473:     }
        !           474: 
        !           475: /* XXX: redraw all views showing cursor */
        !           476: /* XXX: also, make sure switching tools works w/out moving */
        !           477:     if (((view->tool_showing != last_showing) ||
        !           478:         (view->tool_x != last_x) ||
        !           479:         (view->tool_y != last_y))) {
        !           480: #if 1
        !           481:       EventuallyRedrawView(view);
        !           482: #else
        !           483:       RedrawEditors();
        !           484: #endif
        !           485:     }
        !           486:   }
        !           487: }
        !           488: 
        !           489: 
        !           490: static void
        !           491: DestroyTileView(ClientData clientData)
        !           492: {
        !           493:   SimView *view = (SimView *) clientData;
        !           494: 
        !           495:   DestroyView(view);
        !           496: }
        !           497: 
        !           498: 
        !           499: void
        !           500: StdinProc(ClientData clientData, int mask)
        !           501: {
        !           502:   char line[200];
        !           503:   static int gotPartial = 0;
        !           504:   char *cmd;
        !           505:   int result;
        !           506:   
        !           507:   if (mask & TK_READABLE) {
        !           508:     if (fgets(line, 200, stdin) == NULL) {
        !           509:       if (!gotPartial) {
        !           510:        if (sim_tty) {
        !           511:          sim_exit(0); // Just sets tkMustExit and ExitReturn
        !           512:          return;
        !           513:        } else {
        !           514:          Tk_DeleteFileHandler(0);
        !           515:        }
        !           516:        return;
        !           517:       } else {
        !           518:        line[0] = 0;
        !           519:       }
        !           520:     }
        !           521:     cmd = Tcl_AssembleCmd(buffer, line);
        !           522:     if (cmd == NULL) {
        !           523:       gotPartial = 1;
        !           524:       return;
        !           525:     }
        !           526:     gotPartial = 0;
        !           527:     result = Tcl_RecordAndEval(tk_mainInterp, cmd, 0);
        !           528:     if (*tk_mainInterp->result != 0) {
        !           529:       if ((result != TCL_OK) || sim_tty) {
        !           530:        printf("%s\n", tk_mainInterp->result);
        !           531:       }
        !           532:     }
        !           533:     if (sim_tty) {
        !           534:       printf("sim:\n");
        !           535:       fflush(stdout);
        !           536:     }
        !           537:   }
        !           538: }
        !           539: 
        !           540: 
        !           541: static void
        !           542: StructureProc(ClientData clientData, XEvent *eventPtr)
        !           543: {
        !           544:   if (eventPtr->type == DestroyNotify) {
        !           545:     MainWindow = NULL;
        !           546:   }
        !           547: }
        !           548: 
        !           549: 
        !           550: static void
        !           551: DelayedMap(ClientData clientData)
        !           552: {
        !           553:   while (Tk_DoOneEvent(TK_IDLE_EVENTS) != 0) {
        !           554:     /* Empty loop body. */
        !           555:   }
        !           556:   if (MainWindow == NULL) {
        !           557:     return;
        !           558:   }
        !           559:   Tk_MapWindow(MainWindow);
        !           560: }
        !           561: 
        !           562: 
        !           563: DidStopPan(SimView *view)
        !           564: {
        !           565:   char buf[256];
        !           566:   sprintf(buf, "UIDidStopPan %s", Tk_PathName(view->tkwin));
        !           567:        
        !           568:   Eval(buf);
        !           569: }
        !           570: 
        !           571: 
        !           572: static void
        !           573: MicropolisTimerProc(ClientData clientData)
        !           574: {
        !           575:   sim_timer_token = NULL;
        !           576:   sim_timer_set = 0;
        !           577: 
        !           578:   if (NeedRest > 0) {
        !           579:     NeedRest--;
        !           580:   }
        !           581: 
        !           582:   if (SimSpeed) {
        !           583:     sim_loop(1);
        !           584:     StartMicropolisTimer();
        !           585:   } else {
        !           586:     StopMicropolisTimer();
        !           587:   }
        !           588: }
        !           589: 
        !           590: 
        !           591: void
        !           592: ReallyStartMicropolisTimer(ClientData clientData)
        !           593: {
        !           594:   int delay = sim_delay;
        !           595:   XDisplay *xd = XDisplays;
        !           596: 
        !           597:   StopMicropolisTimer();
        !           598: 
        !           599:   while (xd != NULL) {
        !           600:     if ((NeedRest > 0) ||
        !           601:        ShakeNow ||
        !           602:        (xd->tkDisplay->buttonWinPtr != NULL) ||
        !           603:        (xd->tkDisplay->grabWinPtr != NULL)) {
        !           604:       if (ShakeNow || NeedRest) {
        !           605:        if (delay < 50000) delay = 50000;
        !           606:       } else {
        !           607:       }
        !           608:       break;
        !           609:     }
        !           610:     xd = xd->next;
        !           611:   }
        !           612: 
        !           613:   sim_timer_token =
        !           614:     Tk_CreateMicroTimerHandler(
        !           615:       0,
        !           616:       delay,
        !           617:       MicropolisTimerProc,
        !           618:       (ClientData)0);
        !           619: 
        !           620:   sim_timer_set = 1;
        !           621: }
        !           622: 
        !           623: 
        !           624: StartMicropolisTimer()
        !           625: {
        !           626:   if (sim_timer_idle == 0) {
        !           627:     sim_timer_idle = 1;
        !           628:     Tk_DoWhenIdle(
        !           629:       ReallyStartMicropolisTimer,
        !           630:       NULL);
        !           631:   }
        !           632: }
        !           633: 
        !           634: 
        !           635: StopMicropolisTimer()
        !           636: {
        !           637:   if (sim_timer_idle != 0) {
        !           638:     sim_timer_idle = 0;
        !           639:     Tk_CancelIdleCall(
        !           640:       ReallyStartMicropolisTimer,
        !           641:       NULL);
        !           642:   }
        !           643: 
        !           644:   if (sim_timer_set) {
        !           645:     if (sim_timer_token != 0) {
        !           646:       Tk_DeleteTimerHandler(sim_timer_token);
        !           647:       sim_timer_token = 0;
        !           648:     }
        !           649:     sim_timer_set = 0;
        !           650:   }
        !           651: }
        !           652: 
        !           653: 
        !           654: FixMicropolisTimer()
        !           655: {
        !           656:   if (sim_timer_set) {
        !           657:     StartMicropolisTimer(NULL);
        !           658:   }
        !           659: }
        !           660: 
        !           661: 
        !           662: static void
        !           663: DelayedUpdate(ClientData clientData)
        !           664: {
        !           665: //fprintf(stderr, "DelayedUpdate\n");
        !           666:   UpdateDelayed = 0;
        !           667:   sim_skip = 0;
        !           668:   sim_update();
        !           669: }
        !           670: 
        !           671: 
        !           672: Kick()
        !           673: {
        !           674:   if (!UpdateDelayed) {
        !           675:     UpdateDelayed = 1;
        !           676:     Tk_DoWhenIdle(DelayedUpdate, (ClientData) NULL);
        !           677:   }
        !           678: }
        !           679: 
        !           680: 
        !           681: void
        !           682: StopEarthquake()
        !           683: {
        !           684:   ShakeNow = 0;
        !           685:   if (earthquake_timer_set) {
        !           686:     Tk_DeleteTimerHandler(earthquake_timer_token);
        !           687:   }
        !           688:   earthquake_timer_set = 0;
        !           689: }
        !           690: 
        !           691: 
        !           692: DoEarthQuake(void)
        !           693: {
        !           694:   MakeSound("city", "Explosion-Low");
        !           695:   Eval("UIEarthQuake");
        !           696:   ShakeNow++;
        !           697:   if (earthquake_timer_set) {
        !           698:     Tk_DeleteTimerHandler(earthquake_timer_token);
        !           699:   }
        !           700:   Tk_CreateTimerHandler(earthquake_delay, (void (*)())StopEarthquake, (ClientData) 0);
        !           701:   earthquake_timer_set = 1;
        !           702: }
        !           703: 
        !           704: 
        !           705: StopToolkit()
        !           706: {
        !           707:   if (tk_mainInterp != NULL) {
        !           708:     Eval("catch {DoStopMicropolis}");
        !           709:   }
        !           710: }
        !           711: 
        !           712: 
        !           713: Eval(char *buf)
        !           714: {
        !           715:   int result = Tcl_Eval(tk_mainInterp, buf, 0, (char **) NULL);
        !           716:   if (result != TCL_OK) {
        !           717:     char *errorinfo = Tcl_GetVar(tk_mainInterp, "errorInfo",
        !           718:                                 TCL_GLOBAL_ONLY);
        !           719:     if (errorinfo == NULL) errorinfo = "<no backtrace>";
        !           720:     fprintf(stderr, "Micropolis: error in TCL code: %s\n%s\n",
        !           721:            tk_mainInterp->result, errorinfo);
        !           722:   }
        !           723:   return (result);
        !           724: }
        !           725: 
        !           726: 
        !           727: tk_main()
        !           728: {
        !           729:   char *p, *msg;
        !           730:   char buf[20];
        !           731:   char initCmd[256];
        !           732:   Tk_3DBorder border;
        !           733: 
        !           734:   tk_mainInterp = Tcl_CreateExtendedInterp();
        !           735: 
        !           736: #if 0
        !           737:   /* XXX: Figure out Extended TCL */
        !           738:   tclAppName     = "Wish";
        !           739:   tclAppLongname = "Wish - Tk Shell";
        !           740:   tclAppVersion  = TK_VERSION;
        !           741:   Tcl_ShellEnvInit (interp, TCLSH_ABORT_STARTUP_ERR,
        !           742:                     name,
        !           743:                     0, NULL,           /* argv var already set  */
        !           744:                     fileName == NULL,  /* interactive?          */
        !           745:                     NULL);             /* Standard default file */
        !           746: #endif
        !           747: 
        !           748:   MainWindow = Tk_CreateMainWindow(tk_mainInterp, FirstDisplay, "Micropolis");
        !           749:   if (MainWindow == NULL) {
        !           750:     fprintf(stderr, "%s\n", tk_mainInterp->result);
        !           751:     sim_really_exit(1); // Just sets tkMustExit and ExitReturn
        !           752:   }
        !           753:   Tk_SetClass(MainWindow, "Tk");
        !           754:   Tk_CreateEventHandler(MainWindow, StructureNotifyMask,
        !           755:                        StructureProc, (ClientData) NULL);
        !           756: /*  Tk_DoWhenIdle(DelayedMap, (ClientData) NULL); */
        !           757: 
        !           758:   Tk_GeometryRequest(MainWindow, 256, 256);
        !           759:   border = Tk_Get3DBorder(tk_mainInterp, MainWindow, None, "gray75");
        !           760:   if (border == NULL) {
        !           761:     Tcl_SetResult(tk_mainInterp, (char *) NULL, TCL_STATIC);
        !           762:     Tk_SetWindowBackground(MainWindow,
        !           763:                           WhitePixelOfScreen(Tk_Screen(MainWindow)));
        !           764:   } else {
        !           765:     Tk_SetBackgroundFromBorder(MainWindow, border);
        !           766:   }
        !           767:   XSetForeground(Tk_Display(MainWindow),
        !           768:                 DefaultGCOfScreen(Tk_Screen(MainWindow)),
        !           769:                 BlackPixelOfScreen(Tk_Screen(MainWindow)));
        !           770: 
        !           771:   sim_command_init();
        !           772:   map_command_init();
        !           773:   editor_command_init();
        !           774:   graph_command_init();
        !           775:   date_command_init();
        !           776:   sprite_command_init();
        !           777: 
        !           778: #ifdef CAM
        !           779:   cam_command_init();
        !           780: #endif
        !           781: 
        !           782:   Tcl_CreateCommand(tk_mainInterp, "piemenu", Tk_PieMenuCmd,
        !           783:                    (ClientData)MainWindow, (void (*)()) NULL);
        !           784:   Tcl_CreateCommand(tk_mainInterp, "interval", Tk_IntervalCmd,
        !           785:                    (ClientData)MainWindow, (void (*)()) NULL);
        !           786: 
        !           787:   sim = MakeNewSim();
        !           788: 
        !           789:   sprintf(initCmd, "source %s/micropolis.tcl", ResourceDir);
        !           790:   filename2UNIX(initCmd);
        !           791:   if (Eval(initCmd)) {
        !           792:     sim_exit(1); // Just sets tkMustExit and ExitReturn
        !           793:     goto bail;
        !           794:   }
        !           795: 
        !           796:   sim_init();
        !           797: 
        !           798:   buffer = Tcl_CreateCmdBuf();
        !           799: 
        !           800:   if (sim_tty) {
        !           801:     Tk_CreateFileHandler(0, TK_READABLE, StdinProc, (ClientData) 0);
        !           802:   }
        !           803: 
        !           804:   { char buf[1024];
        !           805: 
        !           806:     sprintf(buf, "UIStartMicropolis {%s} {%s} {%s}",
        !           807:            HomeDir, ResourceDir, HostName);
        !           808:     filename2UNIX(buf);
        !           809:     if (Eval(buf) != TCL_OK) {
        !           810:       sim_exit(1); // Just sets tkMustExit and ExitReturn
        !           811:       goto bail;
        !           812:     }
        !           813:   }
        !           814: 
        !           815:   if (sim_tty) {
        !           816:     printf("sim:\n");
        !           817:   }
        !           818:   fflush(stdout);
        !           819: 
        !           820:   Tk_MainLoop();
        !           821: 
        !           822:   sim_exit(0); // Just sets tkMustExit and ExitReturn
        !           823: 
        !           824:  bail:
        !           825: 
        !           826:   if (buffer != NULL) {
        !           827:     Tcl_DeleteCmdBuf(buffer);
        !           828:   }
        !           829: 
        !           830:   Tcl_DeleteInterp(tk_mainInterp);
        !           831: }
        !           832: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.