distrib/sources/yagle/xyagle/XMX_view.c

   1 /*------------------------------------------------------------\
   2 |                                                             |
   3 | Tool    :                   XYAG                            |
   4 |                                                             |
   5 | File    :                   View.c                          |
   6 |                                                             |
   7 | Authors :              Jacomme Ludovic                      |
   8 |                        Lester Anthony                       |
   9 |                                                             |
  10 \------------------------------------------------------------*/
  11
  12 #include <stdio.h>
  13 #include <math.h>
  14 #include <signal.h>
  15 #include <limits.h>
  16 #include <Xm/Xm.h>
  17
  18 #include MUT_H
  19 #include SLB_H
  20 #include MLO_H
  21 #include CGV_H
  22 #include XSB_H
  23 #include XYA_H
  24 #include XMX_H
  25
  26 #include "XMX_view.h"
  27
  28 static long     XyagGraphicX1;
  29 static long     XyagGraphicX2;
  30 static long     XyagGraphicY1;
  31 static long     XyagGraphicY2;
  32 static XFontStruct *XyagTextFont;
  33 static GC       XyagTextGC;
  34 static GC       XyagDrawGC;
  35 static char     XyagInterrupt = 0;
  36
  37 static xyagview_list *XyagHeadView = NULL;
  38
  39 #define STOP_IN_LONG_SPACE(x) if (x<0) x=0; else if (x>16000) x=16000
  40
  41 /*------------------------------------------------------------\
  42 |                         XyagAllocView                       |
  43 \------------------------------------------------------------*/
  44
  45 xyagview_list *
  46 XyagAllocView()
  47 {
  48     xyagview_list  *view;
  49
  50     view = (xyagview_list *)mbkalloc(sizeof(xyagview_list));
  51     view->NEXT = NULL;
  52     view->OBJECT = NULL;
  53     return view;
  54 }
  55
  56 /*------------------------------------------------------------\
  57 |                          XyagFreeView                       |
  58 \------------------------------------------------------------*/
  59
  60 void
  61 XyagFreeView(FreeView)
  62     xyagview_list  *FreeView;
  63 {
  64     mbkfree(FreeView);
  65 }
  66
  67 /*------------------------------------------------------------\
  68 |                        XyagAddViewLater                     |
  69 \------------------------------------------------------------*/
  70
  71 void
  72 XyagAddViewLater(Obj)
  73     xyagobj_list   *Obj;
  74 {
  75     xyagview_list  *View;
  76
  77     View = XyagAllocView();
  78
  79     View->OBJECT = Obj;
  80     View->NEXT = XyagHeadView;
  81     XyagHeadView = View;
  82 }
  83
  84 /*------------------------------------------------------------\
  85 |                        XyagDelView                          |
  86 \------------------------------------------------------------*/
  87
  88 void
  89 XyagDelView()
  90 {
  91     xyagview_list  *DelView;
  92     xyagview_list  *View;
  93
  94     View = XyagHeadView;
  95     XyagHeadView = (xyagview_list *) NULL;
  96
  97     while (View != (xyagview_list *) NULL) {
  98         DelView = View;
  99         View = View->NEXT;
 100         XyagFreeView(DelView);
 101     }
 102 }
 103
 104 /*------------------------------------------------------------\
 105 |                     XyagInterruptDisplay                    |
 106 \------------------------------------------------------------*/
 107
 108 void
 109 XyagInterruptDisplay()
 110 {
 111     XEvent          Event;
 112     KeySym          Key;
 113     char            Text;
 114
 115     signal(SIGALRM, XyagInterruptDisplay);
 116     alarm(1);
 117
 118     if (XCheckTypedEvent(XyagGraphicDisplay, KeyPress, &Event)) {
 119         XLookupString(&Event.xkey, &Text, 1, &Key, 0);
 120
 121         if (Text == '\003') {
 122             XyagInterrupt = 1;
 123             XBell(XyagGraphicDisplay, 0);
 124         }
 125     }
 126 }
 127
 128 /*------------------------------------------------------------\
 129 |                     XyagFlushEventDisplay                   |
 130 \------------------------------------------------------------*/
 131
 132 void
 133 XyagFlushEventDisplay()
 134 {
 135     XEvent          Event;
 136
 137     while (XCheckTypedEvent(XyagGraphicDisplay, KeyPress, &Event));
 138 }
 139
 140 /*------------------------------------------------------------\
 141 |                       XyagComputeHexagon                    |
 142 \------------------------------------------------------------*/
 143
 144 char XyagComputeHexagon(long long X1, long long Y1, long long X2, long long Y2, XPoint *Points)
 145 {
 146     long long            StepX;
 147     long long            StepY;
 148
 149     StepY = (Y2 - Y1) >> 1;
 150     StepX = StepY >> 1;
 151
 152     if ((StepY > 0) && (StepX > 0)) {
 153         Points[0].x = X1 + StepX;
 154         Points[0].y = Y1;
 155         Points[1].x = X1;
 156         Points[1].y = Y1 + StepY;
 157         Points[2].x = X1 + StepX;
 158         Points[2].y = Y2;
 159         Points[3].x = X2 - StepX;
 160         Points[3].y = Y2;
 161         Points[4].x = X2;
 162         Points[4].y = Y1 + StepY;
 163         Points[5].x = X2 - StepX;
 164         Points[5].y = Y1;
 165         Points[6].x = X1 + StepX;
 166         Points[6].y = Y1;
 167
 168         return (XYAG_TRUE);
 169     }
 170
 171     return (XYAG_FALSE);
 172 }
 173
 174 /*------------------------------------------------------------\
 175 |                       XyagDisplayArrow                      |
 176 \------------------------------------------------------------*/
 177
 178 char XyagComputeArrow(long long X1, long long Y1, long long X2, long long Y2, XPoint *Points)
 179 {
 180     float           LineX;
 181     float           LineY;
 182     float           HalfX;
 183     float           HalfY;
 184     float           CrossX;
 185     float           CrossY;
 186     float           Norm;
 187
 188     LineX = (float) (X2 - X1);
 189     LineY = (float) (Y2 - Y1);
 190
 191     if ((LineX != 0.0) || (LineY != 0.0)) {
 192         Norm = sqrt((LineX * LineX) + (LineY * LineY));
 193         Norm = Norm / XyagUnitGridStep;
 194         LineX = LineX / Norm;
 195         LineY = LineY / Norm;
 196         HalfX = LineX / 2;
 197         HalfY = LineY / 2;
 198         CrossX = -HalfY;
 199         CrossY = HalfX;
 200
 201         Points[0].x = X1 + LineX;
 202         Points[0].y = Y1 + LineY;
 203         Points[1].x = Points[0].x + LineX + HalfX + CrossX;
 204         Points[1].y = Points[0].y + LineY + HalfY + CrossY;
 205         Points[2].x = Points[0].x + LineX + HalfX - CrossX;
 206         Points[2].y = Points[0].y + LineY + HalfY - CrossY;
 207
 208         return (XYAG_TRUE);
 209     }
 210
 211     return (XYAG_FALSE);
 212 }
 213
 214 /*------------------------------------------------------------\
 215 |                  XyagDrawUserDefinedObject                  |
 216 \------------------------------------------------------------*/
 217 void XyagDrawUserDefinedObject(Obj)
 218      xyagobj_list   *Obj;
 219 {
 220     motif_draw  *ptm_draw;
 221
 222     for(ptm_draw=Obj->SYMBOL->MOTIF->DRAW;ptm_draw;ptm_draw=ptm_draw->NEXT)
 223       {
 224
 225       long long X1r , X2r , Y1r , Y2r ;
 226
 227       long long Xorigin = Obj->X - Obj->SYMBOL->BOX->X_MIN ;
 228       long long Yorigin = Obj->Y - Obj->SYMBOL->BOX->Y_MIN ;
 229
 230       if(ptm_draw->TYPE == MOTIF_T_LINE)
 231        {
 232         motif_line *ptm_data;
 233         ptm_data=ptm_draw->DATA.MLINE;
 234
 235         X1r = ( ( Xorigin + ptm_data->START_X ) * XyagUnitGridStep / XYAG_UNIT ) - XyagPixelGridX ;
 236         Y1r = ( ( Yorigin - ptm_data->START_Y ) * XyagUnitGridStep / XYAG_UNIT ) - XyagPixelGridY ;
 237         X2r = ( ( Xorigin + ptm_data->END_X )   * XyagUnitGridStep / XYAG_UNIT ) - XyagPixelGridX ;
 238         Y2r = ( ( Yorigin - ptm_data->END_Y )   * XyagUnitGridStep / XYAG_UNIT ) - XyagPixelGridY ;
 239
 240         XDrawLine(XyagGraphicDisplay,
 241                   XyagGraphicPixmap,
 242                   XyagDrawGC,
 243                   X1r , XyagGraphicDy - Y1r ,
 244                   X2r , XyagGraphicDy - Y2r );
 245        }
 246       if(ptm_draw->TYPE == MOTIF_T_ARC)
 247        {
 248         motif_arc *ptm_data;
 249         ptm_data=ptm_draw->DATA.MARC;
 250
 251         X1r = ( ( Xorigin + ptm_data->CORNER_X ) * XyagUnitGridStep / XYAG_UNIT ) - XyagPixelGridX ;
 252         Y1r = ( ( Yorigin - ptm_data->CORNER_Y ) * XyagUnitGridStep / XYAG_UNIT ) - XyagPixelGridY ;
 253         X2r = ptm_data->R * 2 * XyagUnitGridStep / XYAG_UNIT ;
 254
 255         XDrawArc(XyagGraphicDisplay,
 256                  XyagGraphicPixmap,
 257                  XyagDrawGC,
 258                  X1r , XyagGraphicDy - Y1r ,
 259                  X2r,  X2r,
 260                  ptm_data->ALPHA ,
 261                  ptm_data->DELTA );
 262         }
 263     }
 264 }
 265
 266 /*------------------------------------------------------------\
 267 |                     XyagDisplayOneObject                    |
 268 \------------------------------------------------------------*/
 269
 270 void
 271 XyagDisplayOneObject(Obj)
 272     xyagobj_list   *Obj;
 273 {
 274     XPoint          Points[7];
 275     int             Index;
 276     long long            X1r;
 277     long long            X2r;
 278     long long            Y1r;
 279     long long            Y2r;
 280     long long            DeltaX;
 281     long long            DeltaY, tmpy0, tmpy1;
 282
 283     if (IsXyagLineLeft(Obj)) {
 284         X1r = Obj->X + Obj->DX;
 285         X2r = Obj->X;
 286     }
 287     else {
 288         X1r = Obj->X;
 289         X2r = Obj->X + Obj->DX;
 290     }
 291
 292     if (IsXyagLineDown(Obj)) {
 293         Y1r = Obj->Y + Obj->DY;
 294         Y2r = Obj->Y;
 295     }
 296     else {
 297         Y1r = Obj->Y;
 298         Y2r = Obj->Y + Obj->DY;
 299     }
 300
 301     X1r = (float) (X1r) * XyagUnitGridStep;
 302     Y1r = (float) (Y1r) * XyagUnitGridStep;
 303     X2r = (float) (X2r) * XyagUnitGridStep;
 304     Y2r = (float) (Y2r) * XyagUnitGridStep;
 305
 306     X1r = (X1r / XYAG_UNIT) - XyagPixelGridX;
 307     X2r = (X2r / XYAG_UNIT) - XyagPixelGridX;
 308     Y1r = (Y1r / XYAG_UNIT) - XyagPixelGridY;
 309     Y2r = (Y2r / XYAG_UNIT) - XyagPixelGridY;
 310
 311     DeltaX = X2r - X1r;
 312     DeltaY = Y2r - Y1r;
 313
 314     if (DeltaX <= 0)
 315         DeltaX = 1;
 316     if (DeltaY <= 0)
 317         DeltaY = 1;
 318
 319     switch (GetXyagObjectType(Obj)) {
 320     case XYAG_OBJECT_LINE:
 321       tmpy0=XyagGraphicDy - Y1r;
 322       tmpy1=XyagGraphicDy - Y2r;
 323 /*      printf("<%lld %lld> <%lld %lld> %ld\n",X1r,Y1r, X2r, Y2r, XyagGraphicDy);
 324       printf("\t<%d %d> <%lld %lld>\n",(int)tmpy0,(int)tmpy1, tmpy0, tmpy1);
 325 */
 326       STOP_IN_LONG_SPACE(X1r);
 327       STOP_IN_LONG_SPACE(X2r);
 328       STOP_IN_LONG_SPACE(tmpy0);
 329       STOP_IN_LONG_SPACE(tmpy1);
 330
 331         XDrawLine(XyagGraphicDisplay,
 332                   XyagGraphicPixmap,
 333                   XyagDrawGC,
 334                   X1r, tmpy0,
 335                   X2r, tmpy1);
 336         break;
 337
 338     case XYAG_OBJECT_ARROW:
 339
 340         XDrawLine(XyagGraphicDisplay,
 341                   XyagGraphicPixmap,
 342                   XyagDrawGC,
 343                   X1r, XyagGraphicDy - Y1r,
 344                   X2r, XyagGraphicDy - Y2r);
 345
 346         if (XyagComputeArrow(X1r, Y1r, X2r, Y2r, Points)) {
 347             Points[0].y = XyagGraphicDy - Points[0].y;
 348             Points[1].y = XyagGraphicDy - Points[1].y;
 349             Points[2].y = XyagGraphicDy - Points[2].y;
 350
 351             XFillPolygon(XyagGraphicDisplay,
 352                          XyagGraphicPixmap,
 353                          XyagDrawGC, Points, 3,
 354                          Convex,
 355                          CoordModeOrigin);
 356         }
 357
 358         break;
 359
 360     case XYAG_OBJECT_HEXAGON:
 361
 362         if (XyagComputeHexagon(X1r, Y1r, X2r, Y2r, Points)) {
 363             for (Index = 0; Index < 7; Index++) {
 364                 Points[Index].y = XyagGraphicDy - Points[Index].y;
 365             }
 366
 367             XDrawLines(XyagGraphicDisplay,
 368                        XyagGraphicPixmap,
 369                        XyagDrawGC, Points, 7,
 370                        CoordModeOrigin);
 371         }
 372
 373         break;
 374
 375     case XYAG_OBJECT_CIRCLE:
 376
 377         XDrawArc(XyagGraphicDisplay,
 378                  XyagGraphicPixmap,
 379                  XyagDrawGC,
 380                  X1r, XyagGraphicDy - Y2r,
 381                  DeltaX, DeltaY, 0, 23040);
 382         break;
 383
 384     case XYAG_OBJECT_RECTANGLE:
 385
 386         XDrawRectangle(XyagGraphicDisplay,
 387                        XyagGraphicPixmap,
 388                        XyagDrawGC,
 389                        X1r, XyagGraphicDy - Y2r,
 390                        DeltaX, DeltaY);
 391
 392         break;
 393
 394     case XYAG_OBJECT_TRIANGLE:
 395
 396         XDrawLine(XyagGraphicDisplay,
 397                   XyagGraphicPixmap,
 398                   XyagDrawGC,
 399                   X1r, XyagGraphicDy - Y1r,
 400                   X2r, (XyagGraphicDy - Y1r - (DeltaY >> 1)));
 401
 402         XDrawLine(XyagGraphicDisplay,
 403                   XyagGraphicPixmap,
 404                   XyagDrawGC,
 405                   X1r, XyagGraphicDy - Y1r,
 406                   X1r, XyagGraphicDy - Y2r);
 407
 408         XDrawLine(XyagGraphicDisplay,
 409                   XyagGraphicPixmap,
 410                   XyagDrawGC,
 411                   X1r, XyagGraphicDy - Y2r,
 412                   X2r, (XyagGraphicDy - Y1r - (DeltaY >> 1)));
 413
 414         break;
 415
 416     case XYAG_OBJECT_SLIB:
 417
 418         XyagDrawUserDefinedObject(Obj);
 419
 420         break;
 421
 422     case XYAG_OBJECT_CELL:
 423
 424         XDrawRectangle(XyagGraphicDisplay,
 425                        XyagGraphicPixmap,
 426                        XyagDrawGC,
 427                        X1r, XyagGraphicDy - Y2r,
 428                        DeltaX, DeltaY);
 429
 430         break;
 431     }
 432 }
 433
 434 /*------------------------------------------------------------\
 435 |                     XyagDisplayOneString                    |
 436 \------------------------------------------------------------*/
 437
 438 void
 439 XyagDisplayOneString(Obj)
 440     xyagobj_list   *Obj;
 441 {
 442     long long            X1r;
 443     long long            X2r;
 444     long long            Y1r;
 445     long long            Y2r;
 446     long long            DeltaX;
 447     long long            DeltaY;
 448     long long            WidthText;
 449     long long            HeightText;
 450     int             Length;
 451
 452     if (IsXyagLineLeft(Obj)) {
 453         X1r = Obj->X + Obj->DX;
 454         X2r = Obj->X;
 455     }
 456     else {
 457         X1r = Obj->X;
 458         X2r = Obj->X + Obj->DX;
 459     }
 460
 461     if (IsXyagLineDown(Obj)) {
 462         Y1r = Obj->Y + Obj->DY;
 463         Y2r = Obj->Y;
 464     }
 465     else {
 466         Y1r = Obj->Y;
 467         Y2r = Obj->Y + Obj->DY;
 468     }
 469
 470     X1r = (float) (X1r) * XyagUnitGridStep;
 471     Y1r = (float) (Y1r) * XyagUnitGridStep;
 472     X2r = (float) (X2r) * XyagUnitGridStep;
 473     Y2r = (float) (Y2r) * XyagUnitGridStep;
 474
 475     X1r = (X1r / XYAG_UNIT) - XyagPixelGridX;
 476     X2r = (X2r / XYAG_UNIT) - XyagPixelGridX;
 477     Y1r = (Y1r / XYAG_UNIT) - XyagPixelGridY;
 478     Y2r = (Y2r / XYAG_UNIT) - XyagPixelGridY;
 479
 480     DeltaX = X2r - X1r;
 481     DeltaY = Y2r - Y1r;
 482
 483     if (DeltaX <= 0)
 484         DeltaX = 1;
 485     if (DeltaY <= 0)
 486         DeltaY = 1;
 487
 488     Length = strlen(Obj->NAME);
 489     WidthText = XTextWidth(XyagTextFont, Obj->NAME, Length);
 490     HeightText = XyagTextFont->ascent;
 491
 492     if (Obj->TYPE == XYAG_OBJECT_TEXT_RIGHT) {
 493         XDrawString(XyagGraphicDisplay,
 494                     XyagGraphicPixmap,
 495                     XyagTextGC,
 496                     X1r,
 497                     XyagGraphicDy - ((Y1r + Y2r - HeightText) >> 1),
 498                     Obj->NAME, Length);
 499     }
 500     else if (Obj->TYPE == XYAG_OBJECT_TEXT_LEFT) {
 501         XDrawString(XyagGraphicDisplay,
 502                     XyagGraphicPixmap,
 503                     XyagTextGC,
 504                     X2r - WidthText,
 505                     XyagGraphicDy - ((Y1r + Y2r - HeightText) >> 1),
 506                     Obj->NAME, Length);
 507     }
 508     else {
 509         XDrawString(XyagGraphicDisplay,
 510                     XyagGraphicPixmap,
 511                     XyagTextGC,
 512                     (X2r + X1r - WidthText) >> 1,
 513                     XyagGraphicDy - ((Y1r + Y2r - HeightText) >> 1),
 514                     Obj->NAME, Length);
 515     }
 516 }
 517
 518 /*------------------------------------------------------------\
 519 |                     XyagDisplayFigure                       |
 520 \------------------------------------------------------------*/
 521
 522 void
 523 XyagDisplayFigure(GraphicX1, GraphicY1, GraphicX2, GraphicY2)
 524     long            GraphicX1;
 525     long            GraphicY1;
 526     long            GraphicX2;
 527     long            GraphicY2;
 528 {
 529     xyagview_list  *View;
 530     xyagobj_list   *Obj;
 531     long long            X1;
 532     long long            Y1;
 533     long long            X2;
 534     long long            Y2;
 535     int             Layer;
 536     char            DisplayText;
 537     extern int      CGV_SCALE;
 538
 539     DisplayText = 1;
 540
 541     XyagGraphicX1 = GraphicX1;
 542     XyagGraphicX2 = GraphicX2;
 543     XyagGraphicY1 = GraphicY1;
 544     XyagGraphicY2 = GraphicY2;
 545
 546     if (XyagUnitGridStep*CGV_SCALE > 10.0) {
 547         XyagTextGC = XyagLargeTextGC;
 548         XyagTextFont = XyagLargeTextFont;
 549     }
 550     else if (XyagUnitGridStep*CGV_SCALE > 6.0) {
 551         XyagTextGC = XyagMediumTextGC;
 552         XyagTextFont = XyagMediumTextFont;
 553     }
 554     else if (XyagUnitGridStep*CGV_SCALE > 3.0) {
 555         XyagTextGC = XyagSmallTextGC;
 556         XyagTextFont = XyagSmallTextFont;
 557     }
 558     else {
 559         DisplayText = XYAG_FORCE_DISPLAY;
 560     }
 561
 562     XyagClearGraphicWindow(GraphicX1,
 563                            XyagGraphicDy - GraphicY2,
 564                            GraphicX2 - GraphicX1,
 565                            GraphicY2 - GraphicY1);
 566
 567     if (XyagFigure == (xyagfig_list *) NULL)
 568         return;
 569
 570     X1 = GraphicX1 + XyagPixelGridX;
 571     X2 = GraphicX2 + XyagPixelGridX;
 572     Y1 = GraphicY1 + XyagPixelGridY;
 573     Y2 = GraphicY2 + XyagPixelGridY;
 574
 575 //    printf("gridstep=%g\n",XyagUnitGridStep);
 576     X1 = (X1 / XyagUnitGridStep);
 577     Y1 = (Y1 / XyagUnitGridStep);
 578     X2 = (X2 / XyagUnitGridStep);
 579     Y2 = (Y2 / XyagUnitGridStep);
 580
 581     if (X2 >= 0) {
 582         X2 = X2 + 1;
 583     }
 584     if (Y2 >= 0) {
 585         Y2 = Y2 + 1;
 586     }
 587     if (X1 <= 0) {
 588         X1 = X1 - 1;
 589     }
 590     if (Y1 <= 0) {
 591         Y1 = Y1 - 1;
 592     }
 593
 594     X1 = X1 * XYAG_UNIT;
 595     X2 = X2 * XYAG_UNIT;
 596     Y1 = Y1 * XYAG_UNIT;
 597     Y2 = Y2 * XYAG_UNIT;
 598
 599     XyagInterrupt = 0;
 600
 601     signal(SIGALRM, XyagInterruptDisplay);
 602     alarm(1);
 603
 604     for (Layer = 0; Layer < XYAG_MAX_LAYER; Layer++) {
 605         if (XyagInterrupt)
 606             break;
 607
 608         if (XYAG_ACTIVE_LAYER_TABLE[Layer] == 0)
 609             continue;
 610
 611         XyagDrawGC = XyagLayerDrawGC[Layer];
 612
 613         for (Obj = XyagFigure->OBJECT[Layer];
 614              Obj != (xyagobj_list *) NULL;
 615              Obj = Obj->NEXT) {
 616             if (XyagInterrupt)
 617                 break;
 618
 619             if (XYAG_ACTIVE_LAYER_TABLE[Obj->LAYER] == 0)
 620                 continue;
 621
 622             if ((Obj->X <= X2) &&
 623                 (Obj->Y <= Y2) &&
 624                 (Obj->X + Obj->DX >= X1) &&
 625                 (Obj->Y + Obj->DY >= Y1)) {
 626                 if ((IsXyagAccept(Obj)) ||
 627                     (IsXyagConnect(Obj))) {
 628                     XyagAddViewLater(Obj);
 629                 }
 630                 else {
 631                     XyagDisplayOneObject(Obj);
 632
 633                     if (Obj->NAME != (char *) 0) {
 634                         if (DisplayText) {
 635                             if (((IsXyagCgvCon(Obj) &&
 636                             XYAG_ACTIVE_NAME_TABLE[XYAG_CONNECTOR_NAME])) ||
 637                                 ((IsXyagCgvBox(Obj) &&
 638                              XYAG_ACTIVE_NAME_TABLE[XYAG_INSTANCE_NAME]))) {
 639                                 XyagDisplayOneString(Obj);
 640                             }
 641                         }
 642                     }
 643                 }
 644             }
 645         }
 646     }
 647
 648     for (View = XyagHeadView;
 649          View != (xyagview_list *) NULL;
 650          View = View->NEXT) {
 651         Obj = View->OBJECT;
 652
 653         if (IsXyagAccept(Obj)) {
 654             XyagDrawGC = XyagAcceptDrawGC;
 655         }
 656         else {
 657             XyagDrawGC = XyagConnectDrawGC;
 658         }
 659
 660         XyagDisplayOneObject(Obj);
 661
 662         if (Obj->NAME != (char *) 0) {
 663             if (DisplayText) {
 664                 XyagDisplayOneString(Obj);
 665             }
 666         }
 667     }
 668
 669     XyagDelView();
 670
 671     alarm(0);
 672     XyagFlushEventDisplay();
 673 }
 674
 675 /*------------------------------------------------------------\
 676 |                     XyagDisplayObject                       |
 677 \------------------------------------------------------------*/
 678
 679 void
 680 XyagDisplayObject(Obj)
 681     xyagobj_list   *Obj;
 682 {
 683     xyagobj_list   *ScanObj;
 684     long long            Xmin;
 685     long long            Ymin;
 686     long long            Xmax;
 687     long long            Ymax;
 688
 689     Xmin = Obj->X;
 690     Ymin = Obj->Y;
 691     Xmax = Xmin + Obj->DX;
 692     Ymax = Ymin + Obj->DY;
 693
 694     ScanObj = Obj->LINK;
 695
 696     while (ScanObj != Obj) {
 697         if (Xmin > ScanObj->X) {
 698             Xmin = ScanObj->X;
 699         }
 700
 701         if (Xmax < (ScanObj->X + ScanObj->DX)) {
 702             Xmax = ScanObj->X + ScanObj->DX;
 703         }
 704
 705         if (Ymin > ScanObj->Y) {
 706             Ymin = ScanObj->Y;
 707         }
 708
 709         if (Ymax < (ScanObj->Y + ScanObj->DY)) {
 710             Ymax = ScanObj->Y + ScanObj->DY;
 711         }
 712
 713         ScanObj = ScanObj->LINK;
 714     }
 715
 716     Xmin = (float) (Xmin - XYAG_UNIT) * XyagUnitGridStep;
 717     Ymin = (float) (Ymin - XYAG_UNIT) * XyagUnitGridStep;
 718     Xmax = (float) (Xmax + XYAG_UNIT) * XyagUnitGridStep;
 719     Ymax = (float) (Ymax + XYAG_UNIT) * XyagUnitGridStep;
 720
 721     Xmin = (Xmin / XYAG_UNIT) - XyagPixelGridX - 1;
 722     Xmax = (Xmax / XYAG_UNIT) - XyagPixelGridX + 1;
 723     Ymin = (Ymin / XYAG_UNIT) - XyagPixelGridY - 1;
 724     Ymax = (Ymax / XYAG_UNIT) - XyagPixelGridY + 1;
 725
 726     if (Xmin < 0)
 727         Xmin = 0;
 728     if (Ymin < 0)
 729         Ymin = 0;
 730
 731     if (Xmax > XyagGraphicDx)
 732         Xmax = XyagGraphicDx;
 733     if (Ymax > XyagGraphicDy)
 734         Ymax = XyagGraphicDy;
 735
 736     if ((Xmax > 0) &&
 737         (Ymax > 0) &&
 738         (Xmin < XyagGraphicDx) &&
 739         (Ymin < XyagGraphicDy)) {
 740         XyagDisplayFigure(Xmin, Ymin, Xmax, Ymax);
 741
 742         XyagRefreshGraphicWindow(Xmin, XyagGraphicDy - Ymax,
 743                                  Xmax - Xmin, Ymax - Ymin);
 744     }
 745 }