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 : Window.c |
33 | |
34 | Author : Jacomme Ludovic |
35 | |
36 | Date : 28.03.95 |
37 | |
38 \------------------------------------------------------------*/
39 /*------------------------------------------------------------\
40 | |
41 | Include Files |
42 | |
43 \------------------------------------------------------------*/
44
45 # include <stdio.h>
46 # include <stdlib.h>
47 # include "mut.h"
48 # include "mph.h"
49 # include "rds.h"
50 # include "rpr.h"
51 # include "rfm.h"
52 # include "GSB.h"
53 # include "GRM.h"
54 # include "GRM_window.h"
55
56 /*------------------------------------------------------------\
57 | |
58 | Variables |
59 | |
60 \------------------------------------------------------------*/
61
62 long GraalWindowXmin = 0;
63 long GraalWindowYmin = 0;
64 long GraalWindowXmax = 0;
65 long GraalWindowYmax = 0;
66 long GraalWindowDx = 0;
67 long GraalWindowDy = 0;
68 long GraalWindowSide = 0;
69 long GraalWindowSize = 0;
70 graalwin *GraalWindowTable = (graalwin *)NULL;
71
72 long GraalBoundXmin = 0;
73 long GraalBoundYmin = 0;
74 long GraalBoundXmax = 0;
75 long GraalBoundYmax = 0;
76
77 char GraalRecomputeBound = GRAAL_TRUE;
78
79 /*------------------------------------------------------------\
80 | |
81 | Functions |
82 | |
83 \------------------------------------------------------------*/
84 /*------------------------------------------------------------\
85 | |
86 | Alloc Functions |
87 | |
88 \------------------------------------------------------------*/
89 /*------------------------------------------------------------\
90 | |
91 | GraalAllocWinLayer |
92 | |
93 \------------------------------------------------------------*/
94
GraalAllocWinLayer(GraalWin)95 graalwin *GraalAllocWinLayer( GraalWin )
96
97 graalwin *GraalWin;
98 {
99 if ( GraalWin->LAYERTAB == (graalwinrec **)NULL )
100 {
101 GraalWin->LAYERTAB =
102
103 (graalwinrec **)rdsallocblock( sizeof(graalwinrec *) * RDS_MAX_LAYER );
104 }
105
106 return GraalWin;
107 }
108
109 /*------------------------------------------------------------\
110 | |
111 | GraalAllocWinRec |
112 | |
113 \------------------------------------------------------------*/
114
GraalAllocWinRec()115 graalwinrec *GraalAllocWinRec()
116 {
117 return((graalwinrec *)rdsalloc(sizeof(graalwinrec), 1));
118 }
119
120 /*------------------------------------------------------------\
121 | |
122 | GraalAllocRecWin |
123 | |
124 \------------------------------------------------------------*/
125
GraalAllocRecWin()126 graalrecwin *GraalAllocRecWin()
127 {
128 return((graalrecwin *)rdsalloc(sizeof(graalrecwin), 1));
129 }
130
131 /*------------------------------------------------------------\
132 | |
133 | Free Functions |
134 | |
135 \------------------------------------------------------------*/
136 /*------------------------------------------------------------\
137 | |
138 | GraalFreeWinLayer |
139 | |
140 \------------------------------------------------------------*/
141
GraalFreeWinLayer(FreeWin)142 void GraalFreeWinLayer( FreeWin )
143
144 graalwin *FreeWin;
145 {
146 if ( FreeWin->LAYERTAB != (graalwinrec **)NULL )
147 {
148 rdsfreeblock( (char *)FreeWin->LAYERTAB );
149 FreeWin->LAYERTAB = (graalwinrec **)NULL;
150 }
151 }
152
153 /*------------------------------------------------------------\
154 | |
155 | GraalFreeWinRec |
156 | |
157 \------------------------------------------------------------*/
158
GraalFreeWinRec(FreeWinRec)159 void GraalFreeWinRec( FreeWinRec )
160
161 graalwinrec *FreeWinRec;
162 {
163 rdsfree((char *)FreeWinRec, sizeof(graalwinrec));
164 }
165
166 /*------------------------------------------------------------\
167 | |
168 | GraalFreeRecWin |
169 | |
170 \------------------------------------------------------------*/
171
GraalFreeRecWin(FreeRecWin)172 void GraalFreeRecWin( FreeRecWin )
173
174 graalrecwin *FreeRecWin;
175 {
176 rdsfree((char *)FreeRecWin, sizeof(graalrecwin));
177 }
178
179 /*------------------------------------------------------------\
180 | |
181 | Init Functions |
182 | |
183 \------------------------------------------------------------*/
184 /*------------------------------------------------------------\
185 | |
186 | Graalgetenv |
187 | |
188 \------------------------------------------------------------*/
189
Graalgetenv(Name)190 long Graalgetenv( Name )
191
192 char *Name;
193 {
194 char *String;
195
196 String = mbkgetenv( Name );
197
198 if ( String == (char *)NULL )
199 {
200 return( 0 );
201 }
202
203 return( atoi( String ) );
204 }
205
206 /*------------------------------------------------------------\
207 | |
208 | GraalInitializeWindow |
209 | |
210 \------------------------------------------------------------*/
211
GraalInitializeWindow()212 void GraalInitializeWindow()
213 {
214 rdsbegin();
215
216 if ( GraalWindowTable == (graalwin *)NULL )
217 {
218 GraalWindowDx = Graalgetenv( GRAAL_WINDOW_DX );
219 GraalWindowDy = Graalgetenv( GRAAL_WINDOW_DY );
220 GraalWindowXmin = Graalgetenv( GRAAL_WINDOW_XMIN );
221 GraalWindowYmin = Graalgetenv( GRAAL_WINDOW_YMIN );
222 GraalWindowSide = Graalgetenv( GRAAL_WINDOW_SIDE );
223
224 if ( ( GraalWindowDx <= 0 ) ||
225 ( GraalWindowDy <= 0 ) ||
226 ( GraalWindowSide <= 0 ) )
227 {
228 GraalWindowDx = GRAAL_DEFAULT_WINDOW_DX;
229 GraalWindowDy = GRAAL_DEFAULT_WINDOW_DY;
230 GraalWindowSize = GRAAL_DEFAULT_WINDOW_DX * GRAAL_DEFAULT_WINDOW_DY;
231 GraalWindowXmin = GRAAL_DEFAULT_WINDOW_XMIN * GRAAL_RDS_LAMBDA;
232 GraalWindowYmin = GRAAL_DEFAULT_WINDOW_YMIN * GRAAL_RDS_LAMBDA;
233 GraalWindowXmax = GRAAL_DEFAULT_WINDOW_XMAX * GRAAL_RDS_LAMBDA;
234 GraalWindowYmax = GRAAL_DEFAULT_WINDOW_YMAX * GRAAL_RDS_LAMBDA;
235 GraalWindowSide = GRAAL_DEFAULT_WINDOW_SIDE * GRAAL_RDS_LAMBDA;
236 }
237 else
238 {
239 GraalWindowSize = GraalWindowDx * GraalWindowDy;
240 GraalWindowSide = GraalWindowSide * GRAAL_RDS_LAMBDA;
241 GraalWindowXmin = GraalWindowXmin * GRAAL_RDS_LAMBDA;
242 GraalWindowYmin = GraalWindowYmin * GRAAL_RDS_LAMBDA;
243 GraalWindowXmax = GraalWindowXmin + ( GraalWindowDx * GraalWindowSide );
244 GraalWindowYmax = GraalWindowYmin + ( GraalWindowDy * GraalWindowSide );
245 }
246
247 GraalWindowTable =
248
249 (graalwin *)rdsallocblock( sizeof(graalwin) * GraalWindowSize );
250 }
251
252 rdsend();
253 }
254
255 /*------------------------------------------------------------\
256 | |
257 | Purge Functions |
258 | |
259 \------------------------------------------------------------*/
260 /*------------------------------------------------------------\
261 | |
262 | GraalEraseWindow |
263 | |
264 \------------------------------------------------------------*/
265
GraalEraseWindow()266 void GraalEraseWindow()
267
268 {
269 long Offset;
270 graalwin *ScanWin;
271 graalwinrec *ScanWinRec;
272 graalwinrec *DelWinRec;
273 char Layer;
274
275 rdsbegin();
276
277 for ( Offset = 0; Offset < GraalWindowSize; Offset++ )
278 {
279 ScanWin = &GraalWindowTable[ Offset ];
280
281 if ( ScanWin->LAYERTAB != (graalwinrec **)NULL )
282 {
283 for ( Layer = 0; Layer < RDS_MAX_LAYER; Layer++ )
284 {
285 ScanWinRec = ScanWin->LAYERTAB[ (int)Layer ];
286
287 while ( ScanWinRec != (graalwinrec *)NULL )
288 {
289 DelWinRec = ScanWinRec;
290 ScanWinRec = ScanWinRec->NEXT;
291
292 GraalFreeWinRec( DelWinRec );
293 }
294 }
295
296 GraalFreeWinLayer( ScanWin );
297 }
298 }
299
300 rdsend();
301 }
302
303 /*------------------------------------------------------------\
304 | |
305 | GraalInsertRectangle |
306 | |
307 \------------------------------------------------------------*/
308
GraalInsertRectangle(Rectangle)309 void GraalInsertRectangle( Rectangle )
310
311 rdsrec_list *Rectangle;
312 {
313 graalwin *LinkWin;
314 graalrecwin *RecWin;
315 graalwinrec *WinRec;
316 char Layer;
317 char Index;
318 long Offset;
319
320 long X1;
321 long X2;
322 long Y1;
323 long Y2;
324 long FirstX;
325
326 rdsbegin();
327
328 Y1 = ( Rectangle->Y - 1 - GraalWindowYmin ) / GraalWindowSide;
329 Y2 = ( Rectangle->Y + Rectangle->DY - GraalWindowYmin ) / GraalWindowSide;
330 X1 = ( Rectangle->X - 1 - GraalWindowXmin ) / GraalWindowSide;
331 X2 = ( Rectangle->X + Rectangle->DX - GraalWindowXmin ) / GraalWindowSide;
332
333 if ( X1 < 0 ) X1 = 0;
334 if ( X2 < 0 ) X2 = 0;
335 if ( X1 >= GraalWindowDx ) X1 = GraalWindowDx - 1;
336 if ( X2 >= GraalWindowDx ) X2 = GraalWindowDx - 1;
337
338 if ( Y1 < 0 ) Y1 = 0;
339 if ( Y2 < 0 ) Y2 = 0;
340 if ( Y1 >= GraalWindowDy ) Y1 = GraalWindowDy - 1;
341 if ( Y2 >= GraalWindowDy ) Y2 = GraalWindowDy - 1;
342
343 FirstX = X1;
344
345 while ( Y1 <= Y2 )
346 {
347 X1 = FirstX;
348
349 while ( X1 <= X2 )
350 {
351 Offset = Y1 * GraalWindowDx + X1;
352
353 LinkWin = &GraalWindowTable[ Offset ];
354
355 if ( LinkWin->LAYERTAB == (graalwinrec **)NULL )
356 {
357 GraalAllocWinLayer( LinkWin );
358 }
359
360 if ( GRAAL_WINDOW( Rectangle ) == (graalrecwin *)NULL )
361 {
362 GRAAL_WINDOW( Rectangle ) = (graalrecwin *)LinkWin;
363
364 SetGraalOneWindow( Rectangle );
365 }
366 else
367 {
368 if ( IsGraalOneWindow( Rectangle ) )
369 {
370 ClearGraalOneWindow( Rectangle );
371
372 RecWin = GraalAllocRecWin();
373 RecWin->WINDOW = (graalwin *)GRAAL_WINDOW( Rectangle );
374 GRAAL_WINDOW( Rectangle ) = RecWin;
375 }
376
377 RecWin = GraalAllocRecWin();
378 RecWin->WINDOW = LinkWin;
379 RecWin->NEXT = GRAAL_WINDOW( Rectangle );
380 GRAAL_WINDOW( Rectangle ) = RecWin;
381 }
382
383 Layer = GetRdsLayer( Rectangle );
384
385 WinRec = LinkWin->LAYERTAB[ (int)Layer ];
386
387 if ( WinRec == (graalwinrec *)NULL )
388 {
389 WinRec = GraalAllocWinRec();
390 LinkWin->LAYERTAB[ (int)Layer ] = WinRec;
391 WinRec->RECTAB[ 0 ] = Rectangle;
392 }
393 else
394 {
395 for ( Index = 0; Index < GRAAL_MAX_REC; Index++ )
396 {
397 if ( WinRec->RECTAB[ (int)Index ] == (rdsrec_list *)NULL ) break;
398 }
399
400 if ( Index == GRAAL_MAX_REC )
401 {
402 WinRec = GraalAllocWinRec();
403 WinRec->NEXT = LinkWin->LAYERTAB[ (int)Layer ];
404 LinkWin->LAYERTAB[ (int)Layer ] = WinRec;
405 WinRec->RECTAB[ 0 ] = Rectangle;
406 }
407 else
408 {
409 WinRec->RECTAB[ (int)Index ] = Rectangle;
410 }
411 }
412
413 X1 = X1 + 1;
414 }
415
416 Y1 = Y1 + 1;
417 }
418
419 rdsend();
420 }
421
422 /*------------------------------------------------------------\
423 | |
424 | GraalEraseRectangle |
425 | |
426 \------------------------------------------------------------*/
427
GraalEraseRectangle(Rectangle)428 void GraalEraseRectangle( Rectangle )
429
430 rdsrec_list *Rectangle;
431 {
432 graalrecwin StaticRecWin;
433 graalrecwin *ScanRecWin;
434 graalrecwin *DelRecWin;
435 graalwinrec *ScanWinRec;
436 graalwinrec *FirstWinRec;
437 graalwin *ScanWin;
438
439 char Layer;
440 char Index;
441 char Found;
442
443 rdsbegin();
444
445 if ( IsGraalOneWindow( Rectangle ) )
446 {
447 StaticRecWin.NEXT = (graalrecwin *)NULL;
448 StaticRecWin.WINDOW = (graalwin *)GRAAL_WINDOW( Rectangle );
449 ScanRecWin = &StaticRecWin;
450 }
451 else
452 {
453 ScanRecWin = GRAAL_WINDOW( Rectangle );
454 }
455
456 Layer = GetRdsLayer( Rectangle );
457
458 while ( ScanRecWin != (graalrecwin *)NULL )
459 {
460 DelRecWin = ScanRecWin;
461 ScanRecWin = ScanRecWin->NEXT;
462
463 ScanWin = DelRecWin->WINDOW;
464 Found = GRAAL_MAX_REC;
465
466 FirstWinRec = ScanWin->LAYERTAB[ (int)Layer ];
467
468 for ( ScanWinRec = FirstWinRec;
469 ScanWinRec != (graalwinrec *)NULL;
470 ScanWinRec = ScanWinRec->NEXT )
471 {
472 for ( Index = 0; Index < GRAAL_MAX_REC; Index++ )
473 {
474 if ( ScanWinRec->RECTAB[ (int)Index ] == Rectangle )
475 {
476 Found = Index; break;
477 }
478 }
479
480 if ( Found != GRAAL_MAX_REC ) break;
481 }
482
483 if ( ScanWinRec == FirstWinRec )
484 {
485 ScanWinRec->RECTAB[ (int)Found ] = (rdsrec_list *)NULL;
486 }
487 else
488 {
489 for ( Index = 0; Index < GRAAL_MAX_REC; Index++ )
490 {
491 if ( FirstWinRec->RECTAB[ (int)Index ] != (rdsrec_list *)NULL ) break;
492 }
493
494 ScanWinRec->RECTAB[ (int)Found ] = FirstWinRec->RECTAB[ (int)Index ];
495 FirstWinRec->RECTAB[ (int)Index ] = (rdsrec_list *)NULL;
496 }
497
498 for ( Index = 0; Index < GRAAL_MAX_REC; Index++ )
499 {
500 if ( FirstWinRec->RECTAB[ (int)Index ] != (rdsrec_list *)NULL ) break;
501 }
502
503 if ( Index == GRAAL_MAX_REC )
504 {
505 ScanWin->LAYERTAB[ (int)Layer ] = FirstWinRec->NEXT;
506
507 GraalFreeWinRec( FirstWinRec );
508 }
509
510 if ( DelRecWin != &StaticRecWin )
511 {
512 GraalFreeRecWin( DelRecWin );
513 }
514 }
515
516 rdsend();
517 }
518
519 /*------------------------------------------------------------\
520 | |
521 | GraalEraseRecWin |
522 | |
523 \------------------------------------------------------------*/
524
GraalEraseRecWin(Rectangle)525 void GraalEraseRecWin( Rectangle )
526
527 rdsrec_list *Rectangle;
528 {
529 graalrecwin *ScanRecWin;
530 graalrecwin *DelRecWin;
531
532 rdsbegin();
533
534 if ( ! IsGraalOneWindow( Rectangle ) )
535 {
536 ScanRecWin = GRAAL_WINDOW( Rectangle );
537
538 do
539 {
540 DelRecWin = ScanRecWin;
541 ScanRecWin = ScanRecWin->NEXT;
542
543 GraalFreeRecWin( DelRecWin );
544 }
545 while ( ScanRecWin != (graalrecwin *)NULL );
546 }
547
548 GRAAL_WINDOW( Rectangle ) = (graalrecwin *)NULL;
549
550 rdsend();
551 }
552
553 /*------------------------------------------------------------\
554 | |
555 | GraalViewWindow |
556 | |
557 \------------------------------------------------------------*/
558
559 # ifdef DEBUG
560
GraalViewWindow()561 void GraalViewWindow()
562 {
563 graalwin *ScanWin;
564 graalwinrec *ScanWinRec;
565 rdsrec_list *Rectangle;
566 long X;
567 long Y;
568 long Xmin;
569 long Ymin;
570 long Xmax;
571 long Ymax;
572 long Counter;
573 long MaskCounter;
574 char Layer;
575 char ScanRec;
576
577 rdsbegin();
578
579 fprintf( stdout, "\n\t--> Window\n" );
580 fprintf( stdout, "\n\tXMIN : %d" , GraalWindowXmin );
581 fprintf( stdout, "\n\tXMAX : %d" , GraalWindowXmax );
582 fprintf( stdout, "\n\tYMIN : %d" , GraalWindowYmin );
583 fprintf( stdout, "\n\tYMAX : %d" , GraalWindowYmax );
584 fprintf( stdout, "\n\tDX : %d" , GraalWindowDx );
585 fprintf( stdout, "\n\tDY : %d" , GraalWindowDy );
586 fprintf( stdout, "\n\tSIDE : %d" , GraalWindowSide );
587 fprintf( stdout, "\n\tSIZE : %d\n", GraalWindowSize );
588
589 fprintf( stdout, "\n\t--> Dump all windows\n" );
590
591 Ymin = GraalWindowYmin;
592 Ymax = Ymin + GraalWindowSide;
593 Y = 0;
594
595 MaskCounter = 0;
596
597 while ( Y < GraalWindowDy )
598 {
599 Xmin = GraalWindowXmin;
600 Xmax = Xmin + GraalWindowSide ;
601 X = 0;
602
603 ScanWin = GraalWindowTable[ Y * GraalWindowDx ];
604
605 while ( X < GraalWindowDx )
606 {
607 if ( ScanWin != (graalwin *)NULL )
608 {
609 fprintf( stdout, "\n\t--> Window[ %d, %d ]\n", X, Y );
610
611 fprintf( stdout, "\n\tXMIN : %d" , Xmin );
612 fprintf( stdout, "\n\tYMIN : %d" , Ymin );
613 fprintf( stdout, "\n\tXMAX : %d" , Xmax );
614 fprintf( stdout, "\n\tYMAX : %d\n", Ymax );
615
616 Counter = 0;
617
618 for ( Layer = 0; Layer < RDS_MAX_LAYER; Layer++ )
619 {
620 for ( ScanWinRec = ScanWin->LAYERTAB[ Layer ];
621 ScanWinRec != (graalwinrec *)NULL;
622 ScanWinRec = ScanWinRec->NEXT )
623 {
624 for ( ScanRec = 0; ScanRec < GRAAL_MAX_REC ; ScanRec++ )
625 {
626 Rectangle = ScanWinRec->RECTAB[ ScanRec ];
627
628 if ( Rectangle != (rdsrec_list *)NULL )
629 {
630 if ( ( Rectangle->X > Xmax ) ||
631 ( Rectangle->Y > Ymax ) ||
632 ( Rectangle->X + Rectangle->DX < Xmin ) ||
633 ( Rectangle->Y + Rectangle->DY < Ymin ) )
634 {
635 viewrdsrec( Rectangle );
636 }
637 else
638 {
639 Counter = Counter + 1;
640 }
641 }
642 }
643 }
644 }
645
646 MaskCounter = MaskCounter + Counter;
647
648 fprintf( stdout, "\n\t<-- Total rectangles %d", Counter );
649 }
650
651 Xmin = Xmax;
652 Xmax = Xmax + GraalWindowSide;
653 X = X + 1;
654
655 ScanWin = GraalWindowTable[ Y * GraalWindowDx + X ];
656 }
657
658 Ymin = Ymax;
659 Ymax = Ymax + GraalWindowSide;
660 Y = Y + 1;
661 }
662
663 fprintf( stdout, "\n<-- Total Rectangles %d\n", MaskCounter );
664
665 rdsend();
666 }
667
668 # endif
669
670 /*------------------------------------------------------------\
671 | |
672 | GraalComputeBound |
673 | |
674 \------------------------------------------------------------*/
675
GraalComputeBound()676 char GraalComputeBound()
677
678 {
679 graalwin *ScanWin;
680 graalwinrec *ScanWinRec;
681 rdsrec_list *Rec;
682 long Offset;
683 long X;
684 long Y;
685 char Layer;
686 char FirstBound;
687 char ScanRec;
688
689 if ( GraalFigureMbk == (phfig_list *)NULL )
690 {
691 return( GRAAL_FALSE );
692 }
693
694 if ( GraalRecomputeBound == GRAAL_FALSE )
695 {
696 return( GRAAL_TRUE );
697 }
698
699 rdsbegin();
700
701 GraalBoundXmin = 0;
702 GraalBoundXmax = 0;
703 GraalBoundYmin = 0;
704 GraalBoundYmax = 0;
705
706 Y = 0;
707
708 FirstBound = 1;
709
710 while ( ( Y < GraalWindowDy ) &&
711 ( FirstBound == 1 ) )
712 {
713 Offset = Y * GraalWindowDx;
714 X = 0;
715
716 while ( X < GraalWindowDx )
717 {
718 ScanWin = &GraalWindowTable[ Offset ];
719
720 if ( ScanWin->LAYERTAB != (graalwinrec **)NULL )
721 {
722 for ( Layer = 0; Layer < RDS_MAX_LAYER; Layer++ )
723 {
724 for ( ScanWinRec = ScanWin->LAYERTAB[ (int)Layer ];
725 ScanWinRec != (graalwinrec *)NULL;
726 ScanWinRec = ScanWinRec->NEXT )
727 {
728 for ( ScanRec = 0; ScanRec < GRAAL_MAX_REC ; ScanRec++ )
729 {
730 Rec = ScanWinRec->RECTAB[ (int)ScanRec ];
731
732 if ( ( Rec != (rdsrec_list *)NULL ) &&
733 ( ! IsGraalDeleted( Rec ) ) )
734 {
735 if ( FirstBound == 1 )
736 {
737 FirstBound = 0;
738 GraalBoundYmin = Rec->Y;
739 }
740 else
741 if ( Rec->Y < GraalBoundYmin )
742 {
743 GraalBoundYmin = Rec->Y;
744 }
745 }
746 }
747 }
748 }
749 }
750
751 X = X + 1;
752 Offset = Offset + 1;
753 }
754
755 Y = Y + 1;
756 }
757
758 if ( FirstBound == 1 )
759 {
760 rdsend();
761 return( GRAAL_FALSE );
762 }
763
764 FirstBound = 1;
765
766 Y = GraalWindowDy - 1;
767
768 while ( ( Y >= 0 ) &&
769 ( FirstBound == 1 ) )
770 {
771 Offset = Y * GraalWindowDx;
772 X = 0;
773
774 while ( X < GraalWindowDx )
775 {
776 ScanWin = &GraalWindowTable[ Offset ];
777
778 if ( ScanWin->LAYERTAB != (graalwinrec **)NULL )
779 {
780 for ( Layer = 0; Layer < RDS_MAX_LAYER; Layer++ )
781 {
782 for ( ScanWinRec = ScanWin->LAYERTAB[ (int)Layer ];
783 ScanWinRec != (graalwinrec *)NULL;
784 ScanWinRec = ScanWinRec->NEXT )
785 {
786 for ( ScanRec = 0; ScanRec < GRAAL_MAX_REC ; ScanRec++ )
787 {
788 Rec = ScanWinRec->RECTAB[ (int)ScanRec ];
789
790 if ( ( Rec != (rdsrec_list *)NULL ) &&
791 ( ! IsGraalDeleted( Rec ) ) )
792 {
793 if ( FirstBound == 1 )
794 {
795 FirstBound = 0;
796 GraalBoundYmax = Rec->Y + Rec->DY;
797 }
798 else
799 if ( ( Rec->Y + Rec->DY ) > GraalBoundYmax )
800 {
801 GraalBoundYmax = Rec->Y + Rec->DY;
802 }
803 }
804 }
805 }
806 }
807 }
808
809 X = X + 1;
810 Offset = Offset + 1;
811 }
812
813 Y = Y - 1;
814 }
815
816 FirstBound = 1;
817
818 X = GraalWindowDx - 1;
819
820 while ( ( X >= 0 ) &&
821 ( FirstBound == 1 ) )
822 {
823 Offset = X;
824 Y = 0;
825
826 while ( Y < GraalWindowDy )
827 {
828 ScanWin = &GraalWindowTable[ Offset ];
829
830 if ( ScanWin->LAYERTAB != (graalwinrec **)NULL )
831 {
832 for ( Layer = 0; Layer < RDS_MAX_LAYER; Layer++ )
833 {
834 for ( ScanWinRec = ScanWin->LAYERTAB[ (int)Layer ];
835 ScanWinRec != (graalwinrec *)NULL;
836 ScanWinRec = ScanWinRec->NEXT )
837 {
838 for ( ScanRec = 0; ScanRec < GRAAL_MAX_REC ; ScanRec++ )
839 {
840 Rec = ScanWinRec->RECTAB[ (int)ScanRec ];
841
842 if ( ( Rec != (rdsrec_list *)NULL ) &&
843 ( ! IsGraalDeleted( Rec ) ) )
844 {
845 if ( FirstBound == 1 )
846 {
847 FirstBound = 0;
848 GraalBoundXmax = Rec->X + Rec->DX;
849 }
850 else
851 if ( ( Rec->X + Rec->DX ) > GraalBoundXmax )
852 {
853 GraalBoundXmax = Rec->X + Rec->DX;
854 }
855 }
856 }
857 }
858 }
859 }
860
861 Y = Y + 1;
862 Offset = Offset + GraalWindowDx;
863 }
864
865 X = X - 1;
866 }
867
868 X = 0;
869
870 FirstBound = 1;
871
872 while ( ( X < GraalWindowDx ) &&
873 ( FirstBound == 1 ) )
874 {
875 Offset = X;
876 Y = 0;
877
878 while ( Y < GraalWindowDy )
879 {
880 ScanWin = &GraalWindowTable[ Offset ];
881
882 if ( ScanWin->LAYERTAB != (graalwinrec **)NULL )
883 {
884 for ( Layer = 0; Layer < RDS_MAX_LAYER; Layer++ )
885 {
886 for ( ScanWinRec = ScanWin->LAYERTAB[ (int)Layer ];
887 ScanWinRec != (graalwinrec *)NULL;
888 ScanWinRec = ScanWinRec->NEXT )
889 {
890 for ( ScanRec = 0; ScanRec < GRAAL_MAX_REC ; ScanRec++ )
891 {
892 Rec = ScanWinRec->RECTAB[ (int)ScanRec ];
893
894 if ( ( Rec != (rdsrec_list *)NULL ) &&
895 ( ! IsGraalDeleted( Rec ) ) )
896 {
897 if ( FirstBound == 1 )
898 {
899 FirstBound = 0;
900 GraalBoundXmin = Rec->X;
901 }
902 else
903 if ( Rec->X < GraalBoundXmin )
904 {
905 GraalBoundXmin = Rec->X;
906 }
907 }
908 }
909 }
910 }
911 }
912
913 Y = Y + 1;
914 Offset = Offset + GraalWindowDx;
915 }
916
917 X = X + 1;
918 }
919
920 GraalRecomputeBound = GRAAL_FALSE;
921
922 rdsend();
923 return( GRAAL_TRUE );
924 }
925
926 /*------------------------------------------------------------\
927 | |
928 | GraalCheckWindow |
929 | |
930 \------------------------------------------------------------*/
931
GraalCheckWindow(CheckXmin,CheckYmin,CheckXmax,CheckYmax)932 void GraalCheckWindow( CheckXmin, CheckYmin, CheckXmax, CheckYmax )
933
934 long CheckXmin;
935 long CheckYmin;
936 long CheckXmax;
937 long CheckYmax;
938 {
939 long Border;
940 long SideX;
941 long SideY;
942 char Compute;
943
944 rdsbegin();
945
946 Compute = 0;
947 Border = GRAAL_WINDOW_BORDER * GRAAL_RDS_LAMBDA;
948
949 if ( ( CheckXmin - Border ) < GraalWindowXmin )
950 {
951 GraalWindowXmin = CheckXmin - Border;
952 Compute = 1;
953 }
954
955 if ( ( CheckYmin - Border ) < GraalWindowYmin )
956 {
957 GraalWindowYmin = CheckYmin - Border;
958 Compute = 1;
959 }
960
961 if ( ( CheckXmax + Border ) > GraalWindowXmax )
962 {
963 GraalWindowXmax = CheckXmax + Border;
964 Compute = 1;
965 }
966
967 if ( ( CheckYmax + Border ) > GraalWindowYmax )
968 {
969 GraalWindowYmax = CheckYmax + Border;
970 Compute = 1;
971 }
972
973 if ( Compute )
974 {
975 GraalEraseWindow();
976 rdsfreeblock( GraalWindowTable );
977
978 GraalWindowDx = GRAAL_DEFAULT_WINDOW_DX;
979 GraalWindowDy = GRAAL_DEFAULT_WINDOW_DY;
980
981 SideX = 1 + ( GraalWindowXmax - GraalWindowXmin ) / GraalWindowDx;
982 SideY = 1 + ( GraalWindowYmax - GraalWindowYmin ) / GraalWindowDy;
983
984 if ( SideX < SideY )
985 {
986 GraalWindowSide = SideY;
987 }
988 else
989 {
990 GraalWindowSide = SideX;
991 }
992
993 GraalWindowDx = 1 + ( GraalWindowXmax - GraalWindowXmin ) / GraalWindowSide;
994 GraalWindowDy = 1 + ( GraalWindowYmax - GraalWindowYmin ) / GraalWindowSide;
995
996 GraalWindowXmax = GraalWindowXmin + ( GraalWindowDx * GraalWindowSide );
997 GraalWindowYmax = GraalWindowYmin + ( GraalWindowDy * GraalWindowSide );
998 GraalWindowSize = GraalWindowDx * GraalWindowDy;
999
1000 GraalWindowTable =
1001
1002 (graalwin *)rdsallocblock( sizeof(graalwin) * GraalWindowSize );
1003 }
1004
1005 rdsend();
1006 }
1007