1 /*------------------------------------------------------------\
2 | |
3 | This file is part of the Alliance CAD System Copyright |
4 | (C) Laboratoire LIP6 - D�partement ASIM Universite P&M Curie|
5 | |
6 | Home page : http://www-asim.lip6.fr/alliance/ |
7 | E-mail : mailto:alliance-users@asim.lip6.fr |
8 | |
9 | This progam is free software; you can redistribute it |
10 | and/or modify it under the terms of the GNU General Public |
11 | License as published by the Free Software Foundation; |
12 | either version 2 of the License, or (at your option) any |
13 | later version. |
14 | |
15 | Alliance VLSI CAD System is distributed in the hope that |
16 | it will be useful, but WITHOUT ANY WARRANTY; |
17 | without even the implied warranty of MERCHANTABILITY or |
18 | FITNESS FOR A PARTICULAR PURPOSE. See the GNU General |
19 | Public License for more details. |
20 | |
21 | You should have received a copy of the GNU General Public |
22 | License along with the GNU C Library; see the file COPYING. |
23 | If not, write to the Free Software Foundation, Inc., |
24 | 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. |
25 | |
26 \------------------------------------------------------------*/
27
28 /*------------------------------------------------------------\
29 | |
30 | Tool : GRAAL |
31 | |
32 | File : View.c |
33 | |
34 | Author : Jacomme Ludovic |
35 | |
36 | Date : 28.03.95 |
37 | |
38 \------------------------------------------------------------*/
39
40 /*------------------------------------------------------------\
41 | |
42 | Include Files |
43 | |
44 \------------------------------------------------------------*/
45
46 # include <stdio.h>
47 # include <signal.h>
48 # include <X11/X.h>
49 # include <Xm/Xm.h>
50
51 # include "mut.h"
52 # include "mph.h"
53 # include "rds.h"
54 # include "rpr.h"
55 # include "rfm.h"
56 # include "GSB.h"
57 # include "GRM.h"
58 # include "GMX.h"
59
60 # include "GMX_view.h"
61
62 /*------------------------------------------------------------\
63 | |
64 | Constants |
65 | |
66 \------------------------------------------------------------*/
67 /*------------------------------------------------------------\
68 | |
69 | Types |
70 | |
71 \------------------------------------------------------------*/
72 /*------------------------------------------------------------\
73 | |
74 | Variables |
75 | |
76 \------------------------------------------------------------*/
77
78 static long GraalGraphicX1;
79 static long GraalGraphicX2;
80 static long GraalGraphicY1;
81 static long GraalGraphicY2;
82 static XFontStruct *GraalTextFont;
83 static GC GraalTextGC;
84 static GC GraalDrawGC;
85 static GC GraalFillGC;
86 static graalview *GraalHeadView = (graalview *)NULL;
87 static graalview *GraalHeadViewString = (graalview *)NULL;
88 static char GraalInterrupt = 0;
89 static char GraalCheckInt = 0;
90
91 /*------------------------------------------------------------\
92 | |
93 | Functions |
94 | |
95 \------------------------------------------------------------*/
96 /*------------------------------------------------------------\
97 | |
98 | Alloc Functions |
99 | |
100 \------------------------------------------------------------*/
101 /*------------------------------------------------------------\
102 | |
103 | GraalAllocView |
104 | |
105 \------------------------------------------------------------*/
106
GraalAllocView()107 graalview *GraalAllocView()
108 {
109 return((graalview *)rdsalloc(sizeof(graalview), 1));
110 }
111
112 /*------------------------------------------------------------\
113 | |
114 | Free Functions |
115 | |
116 \------------------------------------------------------------*/
117 /*------------------------------------------------------------\
118 | |
119 | GraalFreeView |
120 | |
121 \------------------------------------------------------------*/
122
GraalFreeView(FreeView)123 void GraalFreeView( FreeView )
124
125 graalview *FreeView;
126 {
127 rdsfree((char *)FreeView, sizeof(graalview));
128 }
129
130 /*------------------------------------------------------------\
131 | |
132 | GraalAddViewLater |
133 | |
134 \------------------------------------------------------------*/
135
GraalAddViewLater(Rectangle)136 void GraalAddViewLater( Rectangle )
137
138 rdsrec_list *Rectangle;
139 {
140 graalview *View;
141
142 rdsbegin();
143
144 View = GraalAllocView();
145
146 View->RECTANGLE = Rectangle;
147 View->NEXT = GraalHeadView;
148 GraalHeadView = View;
149
150 rdsend();
151 }
152
153 /*------------------------------------------------------------\
154 | |
155 | GraalAddViewString |
156 | |
157 \------------------------------------------------------------*/
158
GraalAddViewString(Rectangle)159 void GraalAddViewString( Rectangle )
160
161 rdsrec_list *Rectangle;
162 {
163 graalview *View;
164
165 rdsbegin();
166
167 View = GraalAllocView();
168
169 View->RECTANGLE = Rectangle;
170 View->NEXT = GraalHeadViewString;
171 GraalHeadViewString = View;
172
173 rdsend();
174 }
175
176 /*------------------------------------------------------------\
177 | |
178 | GraalDelView |
179 | |
180 \------------------------------------------------------------*/
181
GraalDelView()182 void GraalDelView()
183 {
184 graalview *DelView;
185 graalview *View;
186
187 rdsbegin();
188
189 View = GraalHeadView;
190 GraalHeadView = (graalview *)NULL;
191
192 while( View != (graalview *)NULL )
193 {
194 DelView = View;
195 View = View->NEXT;
196
197 GraalFreeView( DelView );
198 }
199
200 rdsend();
201 }
202
203 /*------------------------------------------------------------\
204 | |
205 | GraalDelViewString |
206 | |
207 \------------------------------------------------------------*/
208
GraalDelViewString()209 void GraalDelViewString()
210 {
211 graalview *DelView;
212 graalview *View;
213
214 rdsbegin();
215
216 View = GraalHeadViewString;
217 GraalHeadViewString = (graalview *)NULL;
218
219 while( View != (graalview *)NULL )
220 {
221 DelView = View;
222 View = View->NEXT;
223
224 GraalFreeView( DelView );
225 }
226
227 rdsend();
228 }
229
230 /*------------------------------------------------------------\
231 | |
232 | GraalDisplayOneRectangle |
233 | |
234 \------------------------------------------------------------*/
235
GraalDisplayOneRectangle(Rec)236 void GraalDisplayOneRectangle( Rec )
237
238 rdsrec_list *Rec;
239 {
240 long X1r;
241 long X2r;
242 long Y1r;
243 long Y2r;
244 long DeltaX;
245 long DeltaY;
246 long Xcr;
247 long Ycr;
248 char DrawLine;
249 char Tiny;
250 char Small;
251 char RdsLayer;
252
253 rdsbegin();
254
255 RdsLayer = GetRdsLayer( Rec );
256
257 X1r = (float)( Rec->X ) * GraalLambdaGridStep;
258 Y1r = (float)( Rec->Y ) * GraalLambdaGridStep;
259 X2r = (float)( Rec->X + Rec->DX ) * GraalLambdaGridStep;
260 Y2r = (float)( Rec->Y + Rec->DY ) * GraalLambdaGridStep;
261
262 X1r = ( X1r / GRAAL_RDS_LAMBDA ) - GraalPixelGridX;
263 X2r = ( X2r / GRAAL_RDS_LAMBDA ) - GraalPixelGridX;
264 Y1r = ( Y1r / GRAAL_RDS_LAMBDA ) - GraalPixelGridY;
265 Y2r = ( Y2r / GRAAL_RDS_LAMBDA ) - GraalPixelGridY;
266
267 if ( ( X1r <= X2r ) &&
268 ( Y1r <= Y2r ) )
269 {
270 DrawLine = 0;
271 Tiny = 0;
272 Small = 0;
273
274 DeltaX = X2r - X1r;
275 DeltaY = Y2r - Y1r;
276
277 if ( ( DeltaX <= 1 ) ||
278 ( DeltaY <= 1 ) ) Tiny = 1;
279 else
280 if ( GRAAL_FILL_MODE != GRAAL_FILL_MODE_FILL )
281 {
282 if ( ( DeltaX <= 4 ) ||
283 ( DeltaY <= 4 ) )
284 {
285 if ( ( RdsLayer != RDS_NWELL ) &&
286 ( RdsLayer != RDS_PWELL ) )
287 {
288 Small = ! GRAAL_FORCE_DISPLAY;
289 }
290 }
291 }
292
293 if ( Tiny )
294 {
295 if ( ( DeltaX <= 1 ) &&
296 ( DeltaY <= 1 ) )
297 {
298 XDrawPoint( GraalGraphicDisplay,
299 GraalGraphicPixmap,
300 GraalDrawGC,
301 X1r, GraalGraphicDy - Y1r );
302 }
303 else
304 if ( DeltaX <= 1 )
305 {
306 Xcr = ( X1r + X2r ) >> 1;
307
308 XDrawLine( GraalGraphicDisplay,
309 GraalGraphicPixmap,
310 GraalDrawGC,
311 Xcr, GraalGraphicDy - Y1r,
312 Xcr, GraalGraphicDy - Y2r );
313 }
314 else
315 {
316 Ycr = ( Y1r + Y2r ) >> 1;
317
318 XDrawLine( GraalGraphicDisplay,
319 GraalGraphicPixmap,
320 GraalDrawGC,
321 X1r, GraalGraphicDy - Ycr,
322 X2r, GraalGraphicDy - Ycr );
323 }
324 }
325 else
326 {
327 if ( ! Small )
328 {
329 if ( X1r < GraalGraphicX1 )
330 {
331 X1r = GraalGraphicX1; DrawLine |= GRAAL_WEST_MASK;
332 }
333
334 if ( X2r > GraalGraphicX2 )
335 {
336 X2r = GraalGraphicX2; DrawLine |= GRAAL_EAST_MASK;
337 }
338
339 if ( Y1r < GraalGraphicY1 )
340 {
341 Y1r = GraalGraphicY1; DrawLine |= GRAAL_SOUTH_MASK;
342 }
343
344 if ( Y2r > GraalGraphicY2 )
345 {
346 Y2r = GraalGraphicY2; DrawLine |= GRAAL_NORTH_MASK;
347 }
348 }
349
350 if ( ( X1r <= X2r ) &&
351 ( Y1r <= Y2r ) )
352 {
353 if ( ( X1r == X2r ) &&
354 ( Y1r == Y2r ) )
355 {
356 X2r++;
357 Y2r++;
358 }
359
360 if ( DrawLine == 0 )
361 {
362 XDrawRectangle( GraalGraphicDisplay,
363 GraalGraphicPixmap,
364 GraalDrawGC,
365 X1r, GraalGraphicDy - Y2r,
366 X2r - X1r,
367 Y2r - Y1r );
368 }
369 else
370 {
371 if ( ( DrawLine & GRAAL_WEST_MASK ) == 0 )
372 {
373 XDrawLine( GraalGraphicDisplay,
374 GraalGraphicPixmap,
375 GraalDrawGC,
376 X1r, GraalGraphicDy - Y2r,
377 X1r, GraalGraphicDy - Y1r );
378 }
379
380 if ( ( DrawLine & GRAAL_EAST_MASK ) == 0 )
381 {
382 XDrawLine( GraalGraphicDisplay,
383 GraalGraphicPixmap,
384 GraalDrawGC,
385 X2r, GraalGraphicDy - Y2r,
386 X2r, GraalGraphicDy - Y1r );
387 }
388
389 if ( ( DrawLine & GRAAL_SOUTH_MASK ) == 0 )
390 {
391 XDrawLine( GraalGraphicDisplay,
392 GraalGraphicPixmap,
393 GraalDrawGC,
394 X1r, GraalGraphicDy - Y1r,
395 X2r, GraalGraphicDy - Y1r );
396 }
397
398 if ( ( DrawLine & GRAAL_NORTH_MASK ) == 0 )
399 {
400 XDrawLine( GraalGraphicDisplay,
401 GraalGraphicPixmap,
402 GraalDrawGC,
403 X1r, GraalGraphicDy - Y2r,
404 X2r, GraalGraphicDy - Y2r );
405 }
406 }
407
408 if ( ( ! Small ) &&
409 ( RdsLayer != RDS_ABOX ) &&
410 ( GRAAL_FILL_MODE != GRAAL_FILL_MODE_OUTLINE ) )
411 {
412 if ( GRAAL_FILL_MODE == GRAAL_FILL_MODE_PATTERN )
413 {
414 XSetFillStyle( GraalGraphicDisplay,
415 GraalFillGC,
416 FillStippled );
417 }
418 else
419 {
420 XSetFillStyle( GraalGraphicDisplay,
421 GraalFillGC,
422 FillSolid );
423 }
424
425 XFillRectangle( GraalGraphicDisplay,
426 GraalGraphicPixmap,
427 GraalFillGC,
428 X1r, GraalGraphicDy - Y2r,
429 X2r - X1r,
430 Y2r - Y1r );
431 }
432 }
433 }
434
435 if ( ( DrawLine != 0 ) ||
436 ( Rec->NAME == NULL ) )
437 {
438 ClearGraalDrawText( Rec );
439 }
440 }
441 else
442 {
443 ClearGraalDrawText( Rec );
444 }
445
446 rdsend();
447 }
448
449 /*------------------------------------------------------------\
450 | |
451 | GraalDisplayOneString |
452 | |
453 \------------------------------------------------------------*/
454
GraalDisplayOneString(Rec)455 void GraalDisplayOneString( Rec )
456
457 rdsrec_list *Rec;
458 {
459 char *Name;
460 phcon_list *PhCon;
461 char Buffer[ 512 ];
462 long X1r;
463 long X2r;
464 long Y1r;
465 long Y2r;
466 long WidthText;
467 long HeightText;
468
469 rdsbegin();
470
471 X1r = (float)( Rec->X ) * GraalLambdaGridStep;
472 Y1r = (float)( Rec->Y ) * GraalLambdaGridStep;
473 X2r = (float)( Rec->X + Rec->DX ) * GraalLambdaGridStep;
474 Y2r = (float)( Rec->Y + Rec->DY ) * GraalLambdaGridStep;
475
476 X1r = ( X1r / GRAAL_RDS_LAMBDA ) - GraalPixelGridX;
477 X2r = ( X2r / GRAAL_RDS_LAMBDA ) - GraalPixelGridX;
478 Y1r = ( Y1r / GRAAL_RDS_LAMBDA ) - GraalPixelGridY;
479 Y2r = ( Y2r / GRAAL_RDS_LAMBDA ) - GraalPixelGridY;
480
481 if ( ( GRAAL_CONNECTOR_INDEX ) &&
482 ( IsRdsFigRec( Rec ) ) &&
483 ( IsRdsConnector( Rec ) ) )
484 {
485 PhCon = (phcon_list *)GRAAL_MBK( Rec );
486 sprintf( Buffer, "%s.%ld", PhCon->NAME, PhCon->INDEX );
487 Name = namealloc( Buffer );
488 }
489 else
490 {
491 Name = Rec->NAME;
492 }
493
494 HeightText = GraalTextFont->ascent;
495 WidthText = XTextWidth( GraalTextFont,
496 Name, strlen( Name ) );
497
498 if ( GRAAL_BLACK_BOX_STRING )
499 {
500 XDrawImageString( GraalGraphicDisplay,
501 GraalGraphicPixmap,
502 GraalTextGC,
503 (( X1r + X2r - WidthText ) >> 1),
504 GraalGraphicDy - (( Y1r + Y2r - HeightText ) >> 1),
505 Name, strlen( Name ) );
506 }
507 else
508 {
509 XDrawString( GraalGraphicDisplay,
510 GraalGraphicPixmap,
511 GraalTextGC,
512 (( X1r + X2r - WidthText ) >> 1),
513 GraalGraphicDy - (( Y1r + Y2r - HeightText ) >> 1),
514 Name, strlen( Name ) );
515 }
516
517 ClearGraalDrawText( Rec );
518
519 rdsend();
520 }
521
522 /*------------------------------------------------------------\
523 | |
524 | GraalCheckInterrupt |
525 | |
526 \------------------------------------------------------------*/
527
GraalCheckInterrupt()528 char GraalCheckInterrupt()
529 {
530 XEvent Event;
531 KeySym Key;
532 char Text[ 2 ];
533
534 rdsbegin();
535
536 if ( GraalCheckInt )
537 {
538 if ( XCheckTypedEvent( GraalGraphicDisplay, KeyPress, &Event ) )
539 {
540 XLookupString( &Event.xkey, Text, 1, &Key, 0 );
541
542 if ( Text[ 0 ] == '\003' )
543 {
544 GraalInterrupt = 1;
545
546 XBell( GraalGraphicDisplay, 0 );
547 }
548 }
549 }
550
551 GraalCheckInt = 0;
552
553 rdsend();
554
555 return( GraalInterrupt );
556 }
557
558 /*------------------------------------------------------------\
559 | |
560 | GraalInterruptDisplay |
561 | |
562 \------------------------------------------------------------*/
563
GraalInterruptDisplay()564 void GraalInterruptDisplay()
565 {
566 rdsbegin();
567
568 GraalCheckInt = 1;
569
570 signal( SIGALRM, GraalInterruptDisplay );
571 alarm( 1 );
572
573 rdsend();
574 }
575
576 /*------------------------------------------------------------\
577 | |
578 | GraalFlushEventDisplay |
579 | |
580 \------------------------------------------------------------*/
581
GraalFlushEventDisplay()582 void GraalFlushEventDisplay()
583 {
584 XEvent Event;
585
586 rdsbegin();
587
588 while ( XCheckTypedEvent( GraalGraphicDisplay, KeyPress, &Event ) );
589
590 rdsend();
591 }
592
593 /*------------------------------------------------------------\
594 | |
595 | GraalDisplayFigure |
596 | |
597 \------------------------------------------------------------*/
598
GraalDisplayFigure(GraphicX1,GraphicY1,GraphicX2,GraphicY2)599 void GraalDisplayFigure( GraphicX1, GraphicY1, GraphicX2, GraphicY2 )
600
601 long GraphicX1;
602 long GraphicY1;
603 long GraphicX2;
604 long GraphicY2;
605 {
606 long Offset;
607 graalwin *ScanWin;
608 graalwinrec *ScanWinRec;
609 rdsrec_list *Rec;
610 rdsins_list *Instance;
611 char ScanRec;
612 char Layer;
613 char StaticLayer;
614 long X1;
615 long Y1;
616 long X2;
617 long Y2;
618 long X1r;
619 long Y1r;
620 long X;
621 long Y;
622 long Xmin;
623 long Xmax;
624 long Ymin;
625 long Ymax;
626 long LambdaMin;
627 char DrawText;
628 char DrawTextFig;
629 char DrawTextFigCon;
630 char DrawTextFigSeg;
631 char DrawTextFigRef;
632 char DrawTextIns;
633 char DrawTextInsCon;
634 char DrawTextInsSeg;
635 char DrawTextInsRef;
636 graalview *View;
637
638 rdsbegin();
639
640 GraalTextGC = GraalSmallTextGC;
641 GraalTextFont = GraalSmallTextFont;
642 DrawTextFig = 0;
643 DrawTextFigCon = 0;
644 DrawTextFigSeg = 0;
645 DrawTextFigRef = 0;
646 DrawTextIns = 0;
647 DrawTextInsCon = 0;
648 DrawTextInsSeg = 0;
649 DrawTextInsRef = 0;
650 GraalGraphicX1 = GraphicX1;
651 GraalGraphicX2 = GraphicX2;
652 GraalGraphicY1 = GraphicY1;
653 GraalGraphicY2 = GraphicY2;
654
655 if ( ( GraalLambdaGridStep > GRAAL_LOWER_FIGURE_STEP ) ||
656 ( GRAAL_FORCE_DISPLAY ) )
657 {
658 DrawTextFig = GRAAL_RDS_ACTIVE_NAME_TABLE[ GRAAL_FIGURE_NAME ];
659 }
660
661 if ( ( GraalLambdaGridStep > GRAAL_LOWER_INSTANCE_STEP ) ||
662 ( GRAAL_FORCE_DISPLAY ) )
663 {
664 DrawTextIns = GRAAL_RDS_ACTIVE_NAME_TABLE[ GRAAL_INSTANCE_NAME ];
665 }
666
667 if ( ( GraalLambdaGridStep > GRAAL_LOWER_CONNECTOR_STEP ) ||
668 ( GRAAL_FORCE_DISPLAY ) )
669 {
670 DrawTextInsCon = GRAAL_RDS_ACTIVE_NAME_TABLE[ GRAAL_INSTANCE_CONNECTOR_NAME ];
671 DrawTextFigCon = GRAAL_RDS_ACTIVE_NAME_TABLE[ GRAAL_FIGURE_CONNECTOR_NAME ];
672 }
673
674 if ( ( GraalLambdaGridStep > GRAAL_LOWER_SEGMENT_STEP ) ||
675 ( GRAAL_FORCE_DISPLAY ) )
676 {
677 DrawTextFigSeg = GRAAL_RDS_ACTIVE_NAME_TABLE[ GRAAL_FIGURE_SEGMENT_NAME ];
678 DrawTextInsSeg = GRAAL_RDS_ACTIVE_NAME_TABLE[ GRAAL_INSTANCE_SEGMENT_NAME ];
679 }
680
681 if ( ( GraalLambdaGridStep > GRAAL_LOWER_REFERENCE_STEP ) ||
682 ( GRAAL_FORCE_DISPLAY ) )
683 {
684 DrawTextFigRef = GRAAL_RDS_ACTIVE_NAME_TABLE[ GRAAL_FIGURE_REFERENCE_NAME ];
685 DrawTextInsRef = GRAAL_RDS_ACTIVE_NAME_TABLE[ GRAAL_INSTANCE_REFERENCE_NAME ];
686 }
687
688 if ( GraalLambdaGridStep > GRAAL_LOWER_CONNECTOR_STEP )
689 {
690 GraalTextGC = GraalMediumTextGC;
691 GraalTextFont = GraalMediumTextFont;
692 }
693
694 if ( GraalLambdaGridStep > GRAAL_LOWER_REFERENCE_STEP )
695 {
696 GraalTextGC = GraalLargeTextGC;
697 GraalTextFont = GraalLargeTextFont;
698 }
699
700 GraalClearGraphicWindow( GraphicX1,
701 GraalGraphicDy - GraphicY2,
702 GraphicX2 - GraphicX1,
703 GraphicY2 - GraphicY1 );
704
705 if ( GraalFigureMbk == (phfig_list *)NULL ) return;
706
707 LambdaMin = (float)(4.0 / ( GraalLambdaGridStep ));
708
709 X1 = GraphicX1 + GraalPixelGridX;
710 X2 = GraphicX2 + GraalPixelGridX;
711 Y1 = GraphicY1 + GraalPixelGridY;
712 Y2 = GraphicY2 + GraalPixelGridY;
713
714 X1 = ( X1 / GraalLambdaGridStep );
715 Y1 = ( Y1 / GraalLambdaGridStep );
716 X2 = ( X2 / GraalLambdaGridStep );
717 Y2 = ( Y2 / GraalLambdaGridStep );
718
719 if ( X2 >= 0 ) { X2 = X2 + 1; }
720 if ( Y2 >= 0 ) { Y2 = Y2 + 1; }
721 if ( X1 <= 0 ) { X1 = X1 - 1; }
722 if ( Y1 <= 0 ) { Y1 = Y1 - 1; }
723
724 X1 = X1 * GRAAL_RDS_LAMBDA;
725 X2 = X2 * GRAAL_RDS_LAMBDA;
726 Y1 = Y1 * GRAAL_RDS_LAMBDA;
727 Y2 = Y2 * GRAAL_RDS_LAMBDA;
728
729 Xmin = ( X1 - GraalWindowXmin ) / GraalWindowSide;
730 Xmax = ( X2 - GraalWindowXmin ) / GraalWindowSide;
731 Ymin = ( Y1 - GraalWindowYmin ) / GraalWindowSide;
732 Ymax = ( Y2 - GraalWindowYmin ) / GraalWindowSide;
733
734 if ( Xmin < 0 ) Xmin = 0;
735 if ( Ymin < 0 ) Ymin = 0;
736 if ( Xmin >= GraalWindowDx ) Xmin = GraalWindowDx - 1;
737 if ( Ymin >= GraalWindowDy ) Ymin = GraalWindowDy - 1;
738
739 if ( Xmax < 0 ) Xmax = 0;
740 if ( Ymax < 0 ) Ymax = 0;
741 if ( Xmax >= GraalWindowDx ) Xmax = GraalWindowDx - 1;
742 if ( Ymax >= GraalWindowDy ) Ymax = GraalWindowDy - 1;
743
744 GraalInterrupt = 0;
745 GraalCheckInt = 0;
746
747 signal( SIGALRM, GraalInterruptDisplay );
748 alarm( 1 );
749
750 for ( Layer = 0; Layer < RDS_MAX_LAYER; Layer++ )
751 {
752 if ( GraalCheckInterrupt() ) break;
753
754 StaticLayer = RDS_STATIC_LAYER[ (int)Layer ];
755
756 if ( GRAAL_RDS_ACTIVE_LAYER_TABLE[ (int)StaticLayer ] != 1 ) continue;
757
758 Y = Ymin;
759
760 while ( Y <= Ymax )
761 {
762 if ( GraalCheckInterrupt() ) break;
763
764 X = Xmin;
765
766 while ( X <= Xmax )
767 {
768 if ( GraalCheckInterrupt() ) break;
769
770 Offset = Y * GraalWindowDx + X;
771
772 ScanWin = &GraalWindowTable[ Offset ];
773
774 if ( ScanWin->LAYERTAB != (graalwinrec **)NULL )
775 {
776 for ( ScanWinRec = ScanWin->LAYERTAB[ (int)Layer ];
777 ScanWinRec != (graalwinrec *)NULL;
778 ScanWinRec = ScanWinRec->NEXT )
779 {
780 for ( ScanRec = 0; ScanRec < GRAAL_MAX_REC ; ScanRec++ )
781 {
782 Rec = ScanWinRec->RECTAB[ (int)ScanRec ];
783
784 if ( ( Rec != (rdsrec_list *)NULL ) &&
785 ( ! IsGraalDeleted( Rec ) ) &&
786 ( ! IsGraalInvisible( Rec ) ) &&
787 ( Rec->X <= X2 ) &&
788 ( Rec->Y <= Y2 ) &&
789 ( ( Rec->X + Rec->DX ) >= X1 ) &&
790 ( ( Rec->Y + Rec->DY ) >= Y1 ) )
791 {
792
793 if ( ( ! GRAAL_INSTANCE_INTERFACE ) &&
794 ( ! IsRdsFigRec( Rec ) ) &&
795 ( ! IsRdsInstance( Rec ) ) ) continue;
796
797 if ( ( Rec->DX < LambdaMin ) &&
798 ( Rec->DY < LambdaMin ) )
799 {
800 if ( ! GRAAL_FORCE_DISPLAY ) continue;
801 }
802
803 if ( ! IsGraalOneWindow( Rec ) )
804 {
805 X1r = ( Rec->X - GraalWindowXmin ) / GraalWindowSide;
806 Y1r = ( Rec->Y - GraalWindowYmin ) / GraalWindowSide;
807
808 if ( X1r < 0 ) X1r = 0;
809 if ( Y1r < 0 ) Y1r = 0;
810 if ( X1r >= GraalWindowDx ) X1r = GraalWindowDx - 1;
811 if ( Y1r >= GraalWindowDy ) Y1r = GraalWindowDy - 1;
812
813 if ( X1r < Xmin ) X1r = Xmin;
814 if ( Y1r < Ymin ) Y1r = Ymin;
815
816 if ( ( X1r != X ) || ( Y1r != Y ) )
817 {
818 if ( ! GRAAL_FORCE_DISPLAY ) continue;
819 }
820 }
821
822 if ( ! IsRdsFigRec( Rec ) )
823 {
824 Instance = (rdsins_list *)GRAAL_PREVIOUS( Rec );
825
826 if ( IsGraalDeleted( Instance->LAYERTAB[ RDS_ABOX ] ) ) continue;
827
828 if ( IsRdsConnector( Rec ) )
829 {
830 DrawText = DrawTextInsCon;
831 }
832 else
833 if ( ( IsRdsReference( Rec ) ) ||
834 ( IsRdsVia( Rec ) ) )
835 {
836 DrawText = DrawTextInsRef;
837 }
838 else
839 if ( IsRdsSegment( Rec ) )
840 {
841 DrawText = DrawTextInsSeg;
842 }
843 else
844 {
845 DrawText = DrawTextIns;
846 }
847 }
848 else
849 {
850 if ( IsRdsConnector( Rec ) )
851 {
852 DrawText = DrawTextFigCon;
853 }
854 else
855 if ( ( IsRdsReference( Rec ) ) ||
856 ( IsRdsVia( Rec ) ) )
857 {
858 DrawText = DrawTextFigRef;
859 }
860 else
861 if ( IsRdsSegment( Rec ) )
862 {
863 DrawText = DrawTextFigSeg;
864 }
865 else
866 {
867 DrawText = DrawTextFig;
868 }
869 }
870
871 if ( DrawText ) SetGraalDrawText( Rec );
872
873 if ( ( IsGraalAccepted( Rec ) != 0 ) ||
874 ( IsGraalTreated( Rec ) != 0 ) ||
875 ( IsGraalDruc( Rec ) != 0 ) )
876 {
877 GraalAddViewLater( Rec );
878 }
879 else
880 {
881 GraalDrawGC = GraalLayerDrawGC[ (int)StaticLayer ];
882 GraalFillGC = GraalLayerFillGC[ (int)StaticLayer ];
883
884 GraalDisplayOneRectangle( Rec );
885
886 if ( IsGraalDrawText( Rec ) )
887 {
888 GraalAddViewString( Rec );
889 }
890 }
891 }
892 }
893 }
894 }
895
896 X = X + 1;
897 }
898
899 Y = Y + 1;
900 }
901
902 for ( View = GraalHeadView;
903 View != (graalview *)NULL;
904 View = View->NEXT )
905 {
906 Rec = View->RECTANGLE;
907
908 if ( IsGraalAccepted( Rec ) != 0 )
909 {
910 GraalDrawGC = GraalAcceptDrawGC;
911 GraalFillGC = GraalLayerAcceptGC[ (int)StaticLayer ];
912 }
913 else
914 if ( IsGraalTreated( Rec ) != 0 )
915 {
916 GraalDrawGC = GraalEquiDrawGC;
917 GraalFillGC = GraalLayerEquiGC[ (int)StaticLayer ];
918 }
919 else
920 {
921 GraalDrawGC = GraalDrucDrawGC;
922 GraalFillGC = GraalLayerDrucGC[ (int)StaticLayer ];
923 }
924
925 GraalDisplayOneRectangle( Rec );
926 }
927
928 GraalDelView();
929 }
930
931 for ( View = GraalHeadViewString;
932 View != (graalview *)NULL;
933 View = View->NEXT )
934 {
935 Rec = View->RECTANGLE;
936
937 GraalDisplayOneString( Rec );
938 }
939
940 GraalDelViewString();
941
942 alarm( 0 );
943 GraalFlushEventDisplay();
944
945 rdsend();
946 }
947
948 /*------------------------------------------------------------\
949 | |
950 | GraalDisplayRectangle |
951 | |
952 \------------------------------------------------------------*/
953
GraalDisplayRectangle(Rectangle)954 void GraalDisplayRectangle( Rectangle )
955
956 rdsrec_list *Rectangle;
957 {
958 rdsrec_list *ScanRec;
959 long Xmin;
960 long Ymin;
961 long Xmax;
962 long Ymax;
963
964 rdsbegin();
965
966 Xmin = Rectangle->X;
967 Ymin = Rectangle->Y;
968 Xmax = Xmin + Rectangle->DX;
969 Ymax = Ymin + Rectangle->DY;
970
971 ScanRec = (rdsrec_list *)(Rectangle->USER);
972
973 while ( ScanRec != Rectangle )
974 {
975 if ( Xmin > ScanRec->X )
976 {
977 Xmin = ScanRec->X;
978 }
979
980 if ( Xmax < ( ScanRec->X + ScanRec->DX ) )
981 {
982 Xmax = ScanRec->X + ScanRec->DX;
983 }
984
985 if ( Ymin > ScanRec->Y )
986 {
987 Ymin = ScanRec->Y;
988 }
989
990 if ( Ymax < ( ScanRec->Y + ScanRec->DY ) )
991 {
992 Ymax = ScanRec->Y + ScanRec->DY;
993 }
994
995 ScanRec = (rdsrec_list *)(ScanRec->USER);
996 }
997
998 Xmin = (float)( Xmin ) * GraalLambdaGridStep;
999 Ymin = (float)( Ymin ) * GraalLambdaGridStep;
1000 Xmax = (float)( Xmax ) * GraalLambdaGridStep;
1001 Ymax = (float)( Ymax ) * GraalLambdaGridStep;
1002
1003 Xmin = ( Xmin / GRAAL_RDS_LAMBDA ) - GraalPixelGridX - 1;
1004 Xmax = ( Xmax / GRAAL_RDS_LAMBDA ) - GraalPixelGridX + 1;
1005 Ymin = ( Ymin / GRAAL_RDS_LAMBDA ) - GraalPixelGridY - 1;
1006 Ymax = ( Ymax / GRAAL_RDS_LAMBDA ) - GraalPixelGridY + 1;
1007
1008 if ( Xmin < 0 ) Xmin = 0;
1009 if ( Ymin < 0 ) Ymin = 0;
1010
1011 if ( Xmax > GraalGraphicDx ) Xmax = GraalGraphicDx;
1012 if ( Ymax > GraalGraphicDy ) Ymax = GraalGraphicDy;
1013
1014 if ( ( Xmax > 0 ) &&
1015 ( Ymax > 0 ) &&
1016 ( Xmin < GraalGraphicDx ) &&
1017 ( Ymin < GraalGraphicDy ) )
1018 {
1019 GraalDisplayFigure( Xmin, Ymin , Xmax, Ymax );
1020
1021 GraalRefreshGraphicWindow( Xmin, GraalGraphicDy - Ymax,
1022 Xmax - Xmin, Ymax - Ymin );
1023 }
1024
1025 rdsend();
1026 }
1027