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 : MbkRds.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 <signal.h>
48 # include <setjmp.h>
49 # include "mut.h"
50 # include "mph.h"
51 # include "mpu.h"
52 # include "rds.h"
53 # include "rpr.h"
54 # include "rwi.h"
55 # include "rut.h"
56 # include "rtl.h"
57 # include "rfm.h"
58 # include "GSB.h"
59 # include "GRM.h"
60 # include "vrd.h"
61 # include "GRM_error.h"
62 # include "GRM_window.h"
63 # include "GRM_mbkrds.h"
64 # include "GRM_connector.h"
65
66 /*------------------------------------------------------------\
67 | |
68 | Constants |
69 | |
70 \------------------------------------------------------------*/
71 /*------------------------------------------------------------\
72 | |
73 | Types |
74 | |
75 \------------------------------------------------------------*/
76 /*------------------------------------------------------------\
77 | |
78 | Variables |
79 | |
80 \------------------------------------------------------------*/
81 /*------------------------------------------------------------\
82 | |
83 | For Set Long Jump |
84 | |
85 \------------------------------------------------------------*/
86
87 static jmp_buf GraalJumpBuffer;
88
89 /*------------------------------------------------------------\
90 | |
91 | Graal Figure |
92 | |
93 \------------------------------------------------------------*/
94
95 rdsfig_list *GraalFigureRds = (rdsfig_list *)NULL;
96 graalconrec *GraalHeadConnector = (graalconrec *)NULL;
97 phfig_list *GraalFigureMbk = (phfig_list *)NULL;
98
99 /*------------------------------------------------------------\
100 | |
101 | Graal Exit Handler Functions |
102 | |
103 \------------------------------------------------------------*/
104 /*------------------------------------------------------------\
105 | |
106 | GraalExitHandler |
107 | |
108 \------------------------------------------------------------*/
109
GraalExitHandler()110 void GraalExitHandler()
111 {
112 GraalFlushErrorMessage();
113
114 longjmp( GraalJumpBuffer, 1);
115 }
116
117 /*------------------------------------------------------------\
118 | |
119 | GraalActiveExitHandler |
120 | |
121 \------------------------------------------------------------*/
122
GraalActiveExitHandler()123 void GraalActiveExitHandler()
124 {
125 MBK_EXIT_FUNCTION = GraalExitHandler;
126 }
127
128 /*------------------------------------------------------------\
129 | |
130 | GraalResetExitHandler |
131 | |
132 \------------------------------------------------------------*/
133
GraalResetExitHandler()134 void GraalResetExitHandler()
135 {
136 MBK_EXIT_FUNCTION = NULL;
137 }
138
139 /*------------------------------------------------------------\
140 | |
141 | Graal Add Functions |
142 | |
143 \------------------------------------------------------------*/
144 /*------------------------------------------------------------\
145 | |
146 | Graal Add Figure |
147 | |
148 \------------------------------------------------------------*/
149
GraalAddFigure()150 rdsfig_list *GraalAddFigure()
151
152 {
153 void *Pointer;
154 void *Previous;
155 rdsrec_list *Abox;
156
157 rdsbegin();
158
159 GraalFigureRds = addrdsfig( GraalFigureMbk->NAME, GRAAL_SIZE );
160
161 Abox = aboxmbkrds( GraalFigureMbk, GraalFigureRds );
162
163 if ( Abox != (rdsrec_list *)NULL )
164 {
165 GraalCheckWindow( Abox->X , Abox->Y,
166 Abox->X + Abox->DX, Abox->Y + Abox->DY );
167
168 delrdsfigrec( GraalFigureRds, Abox );
169 }
170
171 GraalAddAbox();
172
173 Previous = (void *)(&(GraalFigureMbk->PHSEG));
174
175 for ( Pointer = (void *)(GraalFigureMbk->PHSEG);
176 Pointer != (void *)NULL;
177 Pointer = (void *)(((phseg_list *)Pointer)->NEXT))
178 {
179 ((phseg_list *)Pointer)->USER = Previous;
180 Previous = (void *)(&((phseg_list *)Pointer)->NEXT);
181
182 GraalAddSegment( (phseg_list *)Pointer );
183 }
184
185 Previous = (void *)(&(GraalFigureMbk->PHCON));
186
187 for ( Pointer = (void *)(GraalFigureMbk->PHCON);
188 Pointer != (void *)NULL;
189 Pointer = (void *)(((phcon_list *)Pointer)->NEXT))
190 {
191 ((phcon_list *)Pointer)->USER = Previous;
192 Previous = (void *)(&((phcon_list *)Pointer)->NEXT);
193
194 GraalAddConnector( (phcon_list *)Pointer );
195 }
196
197 Previous = (void *)(&(GraalFigureMbk->PHREF));
198
199 for ( Pointer = (void *)(GraalFigureMbk->PHREF);
200 Pointer != (void *)NULL;
201 Pointer = (void *)(((phref_list *)Pointer)->NEXT))
202 {
203 ((phref_list *)Pointer)->USER = Previous;
204 Previous = (void *)(&((phref_list *)Pointer)->NEXT);
205
206 GraalAddReference( (phref_list *)Pointer );
207 }
208
209 Previous = (void *)(&(GraalFigureMbk->PHVIA));
210
211 for ( Pointer = (void *)(GraalFigureMbk->PHVIA);
212 Pointer != (void *)NULL;
213 Pointer = (void *)(((phvia_list *)Pointer)->NEXT))
214 {
215 ((phvia_list *)Pointer)->USER = Previous;
216 Previous = (void *)(&((phvia_list *)Pointer)->NEXT);
217
218 GraalAddVia( (phvia_list *)Pointer );
219 }
220
221 Previous = (void *)(&(GraalFigureMbk->PHINS));
222
223 for ( Pointer = (void *)(GraalFigureMbk->PHINS);
224 Pointer != (void *)NULL;
225 Pointer = (void *)(((phins_list *)Pointer)->NEXT))
226 {
227 ((phins_list *)Pointer)->USER = Previous;
228 Previous = (void *)(&((phins_list *)Pointer)->NEXT);
229
230 GraalAddInstance( (phins_list *)Pointer );
231 }
232
233 rdsend();
234 return( GraalFigureRds );
235 }
236
237 /*------------------------------------------------------------\
238 | |
239 | Graal Add Instance |
240 | |
241 \------------------------------------------------------------*/
242
GraalAddInstance(InstanceMbk)243 rdsins_list *GraalAddInstance( InstanceMbk )
244
245 phins_list *InstanceMbk;
246 {
247 rdsins_list *InstanceRds;
248 rdsrec_list *Rectangle;
249 char Layer;
250
251 rdsbegin();
252
253 delphfig( InstanceMbk->FIGNAME );
254
255 if ( Graalgetphfig( InstanceMbk->FIGNAME, 'P' ) == (phfig_list *)NULL )
256 {
257 rdsend();
258 return( (rdsins_list *)NULL );
259 }
260
261 InstanceRds = insmbkrds( GraalFigureRds, InstanceMbk, 'P', 1 );
262 InstanceRds->USER = (void *)(&GraalFigureRds->INSTANCE);
263
264 if ( InstanceRds->NEXT != (rdsins_list *)NULL )
265 {
266 InstanceRds->NEXT->USER = (void *)(&InstanceRds->NEXT);
267 }
268
269 for ( Layer = 0; Layer < RDS_MAX_LAYER; Layer++ )
270 {
271 for ( Rectangle = InstanceRds->LAYERTAB[ (int)Layer ];
272 Rectangle != (rdsrec_list *)NULL;
273 Rectangle = Rectangle->NEXT )
274 {
275 GRAAL_MBK( Rectangle ) = (void *)InstanceMbk;
276 GRAAL_PREVIOUS( Rectangle ) = (rdsrec_list **)InstanceRds;
277
278 GraalInsertRectangle( Rectangle );
279 }
280 }
281
282 rdsend();
283 return( InstanceRds );
284 }
285
286 /*------------------------------------------------------------\
287 | |
288 | Graal Flat Instance |
289 | |
290 \------------------------------------------------------------*/
291
GraalFlatInstance(InstanceRds)292 rdsins_list *GraalFlatInstance( InstanceRds )
293
294 rdsins_list *InstanceRds;
295 {
296 phfig_list *ModelMbk;
297 phins_list *InstanceMbk;
298 rdsrec_list *ScanRec;
299 rdsrec_list *DelRec;
300 char Layer;
301
302 rdsbegin();
303
304 ModelMbk = Graalgetphfig( InstanceRds->FIGNAME, 'A' );
305
306 if ( ModelMbk == (phfig_list *)NULL )
307 {
308 rdsend();
309 return( (rdsins_list *)NULL );
310 }
311
312 ModelMbk = Graalrflattenphfig( ModelMbk, YES, NO );
313
314 if ( ModelMbk == (phfig_list *)NULL )
315 {
316 rdsend();
317 return( (rdsins_list *)NULL );
318 }
319
320 for ( Layer = 0; Layer < RDS_ABOX; Layer++ )
321 {
322 ScanRec = InstanceRds->LAYERTAB[ (int)Layer ];
323
324 InstanceRds->LAYERTAB[ (int)Layer ] = (rdsrec_list *)NULL;
325
326 while( ScanRec != (rdsrec_list *)NULL )
327 {
328 DelRec = ScanRec;
329 ScanRec = ScanRec->NEXT;
330
331 GraalEraseRectangle( DelRec );
332
333 freerdsrec( DelRec, GRAAL_SIZE );
334 }
335 }
336
337 ScanRec = InstanceRds->LAYERTAB[ RDS_ABOX ];
338
339 SetGraalFlatten( ScanRec );
340
341 InstanceMbk = (phins_list *)GRAAL_MBK( ScanRec );
342
343 inssegmbkrds( InstanceMbk, ModelMbk, InstanceRds, 1 );
344 insconmbkrds( InstanceMbk, ModelMbk, InstanceRds );
345 insrefmbkrds( InstanceMbk, ModelMbk, InstanceRds );
346 insviambkrds( InstanceMbk, ModelMbk, InstanceRds, 1 );
347
348 for ( Layer = 0; Layer < RDS_MAX_LAYER; Layer++ )
349 {
350 for ( ScanRec = InstanceRds->LAYERTAB[ (int)Layer ];
351 ScanRec != (rdsrec_list *)NULL;
352 ScanRec = ScanRec->NEXT )
353 {
354 GRAAL_MBK( ScanRec ) = (void *)InstanceMbk;
355 GRAAL_PREVIOUS( ScanRec ) = (rdsrec_list **)InstanceRds;
356
357 GraalInsertRectangle( ScanRec );
358 }
359 }
360
361 delphfig( ModelMbk->NAME );
362
363 rdsend();
364 return( InstanceRds );
365 }
366
367 /*------------------------------------------------------------\
368 | |
369 | Graal Unflat Instance |
370 | |
371 \------------------------------------------------------------*/
372
GraalUnflatInstance(InstanceRds)373 rdsins_list *GraalUnflatInstance( InstanceRds )
374
375 rdsins_list *InstanceRds;
376 {
377 phfig_list *ModelMbk;
378 phins_list *InstanceMbk;
379 rdsrec_list *ScanRec;
380 rdsrec_list *DelRec;
381 char Layer;
382
383 rdsbegin();
384
385 delphfig( InstanceRds->FIGNAME );
386
387 ModelMbk = Graalgetphfig( InstanceRds->FIGNAME, 'P' );
388
389 if ( ModelMbk == (phfig_list *)NULL )
390 {
391 rdsend();
392 return( (rdsins_list *)NULL );
393 }
394
395 for ( Layer = 0; Layer < RDS_ABOX; Layer++ )
396 {
397 ScanRec = InstanceRds->LAYERTAB[ (int)Layer ];
398
399 InstanceRds->LAYERTAB[ (int)Layer ] = (rdsrec_list *)NULL;
400
401 while( ScanRec != (rdsrec_list *)NULL )
402 {
403 DelRec = ScanRec;
404 ScanRec = ScanRec->NEXT;
405
406 GraalEraseRectangle( DelRec );
407
408 freerdsrec( DelRec, GRAAL_SIZE );
409 }
410 }
411
412 ScanRec = InstanceRds->LAYERTAB[ RDS_ABOX ];
413
414 ClearGraalFlatten( ScanRec );
415
416 InstanceMbk = (phins_list *)GRAAL_MBK( ScanRec );
417
418 inssegmbkrds( InstanceMbk, ModelMbk, InstanceRds, 1 );
419 insconmbkrds( InstanceMbk, ModelMbk, InstanceRds );
420 insrefmbkrds( InstanceMbk, ModelMbk, InstanceRds );
421 insviambkrds( InstanceMbk, ModelMbk, InstanceRds, 1 );
422
423 for ( Layer = 0; Layer < RDS_MAX_LAYER; Layer++ )
424 {
425 for ( ScanRec = InstanceRds->LAYERTAB[ (int)Layer ];
426 ScanRec != (rdsrec_list *)NULL;
427 ScanRec = ScanRec->NEXT )
428 {
429 GRAAL_MBK( ScanRec ) = (void *)InstanceMbk;
430 GRAAL_PREVIOUS( ScanRec ) = (rdsrec_list **)InstanceRds;
431
432 GraalInsertRectangle( ScanRec );
433 }
434 }
435
436 delphfig( ModelMbk->NAME );
437
438 rdsend();
439 return( InstanceRds );
440 }
441
442 /*------------------------------------------------------------\
443 | |
444 | Graal Add Segment |
445 | |
446 \------------------------------------------------------------*/
447
GraalAddSegment(SegmentMbk)448 rdsrec_list *GraalAddSegment( SegmentMbk )
449
450 phseg_list *SegmentMbk;
451 {
452 rdsrec_list *ScanRec;
453 rdsrec_list *ScanPrev;
454 rdsrec_list *FirstRec;
455 rdsrec_list **Previous;
456
457 rdsbegin();
458
459 ScanRec = FirstRec = segmbkrds( GraalFigureRds, SegmentMbk, 1 );
460
461 if ( FirstRec == (rdsrec_list *)NULL )
462 {
463 rdsend();
464 return( FirstRec );
465 }
466
467 do
468 {
469 GRAAL_MBK( ScanRec ) = (void *)SegmentMbk;
470
471 if ( ScanRec != FirstRec ) ScanRec->NAME = (char *)0;
472
473 GraalInsertRectangle( ScanRec );
474
475 if ( GRAAL_PREVIOUS( ScanRec ) == (rdsrec_list **)NULL )
476 {
477 Previous = &(GraalFigureRds->LAYERTAB[ GetRdsLayer( ScanRec ) ]);
478
479 for ( ScanPrev = *Previous;
480 ScanPrev != ScanRec;
481 ScanPrev = ScanPrev->NEXT )
482 {
483 if ( GRAAL_PREVIOUS( ScanPrev ) == (rdsrec_list **)NULL )
484 {
485 GRAAL_PREVIOUS( ScanPrev ) = Previous;
486 }
487
488 Previous = &ScanPrev->NEXT;
489 }
490
491 GRAAL_PREVIOUS( ScanRec ) = Previous;
492
493 ScanPrev = ScanPrev->NEXT;
494
495 if ( ( ScanPrev != (rdsrec_list *)NULL ) &&
496 ( GRAAL_PREVIOUS( ScanPrev ) != (rdsrec_list **)NULL ) )
497 {
498 GRAAL_PREVIOUS( ScanPrev ) = &ScanRec->NEXT;
499 }
500 }
501
502 ScanRec = (rdsrec_list *)ScanRec->USER;
503 }
504 while ( ScanRec != FirstRec );
505
506 rdsend();
507 return( FirstRec );
508 }
509
510 /*------------------------------------------------------------\
511 | |
512 | Graal Add Connector |
513 | |
514 \------------------------------------------------------------*/
515
GraalAddConnector(ConnectorMbk)516 rdsrec_list *GraalAddConnector( ConnectorMbk )
517
518 phcon_list *ConnectorMbk;
519 {
520 rdsrec_list *Rectangle;
521
522 rdsbegin();
523
524 Rectangle = conmbkrds( GraalFigureRds, ConnectorMbk );
525
526 if ( Rectangle == (rdsrec_list *)NULL )
527 {
528 rdsend();
529 return( Rectangle );
530 }
531
532 GraalAddConRec( Rectangle );
533
534 GRAAL_MBK( Rectangle ) = (void *)ConnectorMbk;
535
536 GraalInsertRectangle( Rectangle );
537
538 GRAAL_PREVIOUS( Rectangle ) =
539
540 &(GraalFigureRds->LAYERTAB[ GetRdsLayer( Rectangle ) ]);
541
542 if ( Rectangle->NEXT != (rdsrec_list *)NULL )
543 {
544 GRAAL_PREVIOUS( Rectangle->NEXT ) = &Rectangle->NEXT;
545 }
546
547 rdsend();
548 return( Rectangle );
549 }
550
551 /*------------------------------------------------------------\
552 | |
553 | Graal Add Via |
554 | |
555 \------------------------------------------------------------*/
556
GraalAddVia(ViaMbk)557 rdsrec_list *GraalAddVia( ViaMbk )
558
559 phvia_list *ViaMbk;
560 {
561 rdsrec_list *ScanRec;
562 rdsrec_list *ScanPrev;
563 rdsrec_list *FirstRec;
564 rdsrec_list **Previous;
565
566 rdsbegin();
567
568 ScanRec = FirstRec = viambkrds( GraalFigureRds, ViaMbk, 1 );
569
570 if ( FirstRec == (rdsrec_list *)NULL )
571 {
572 rdsend();
573 return( FirstRec );
574 }
575
576 do
577 {
578 GRAAL_MBK( ScanRec ) = (void *)ViaMbk;
579
580 GraalInsertRectangle( ScanRec );
581
582 if ( GRAAL_PREVIOUS( ScanRec ) == (rdsrec_list **)NULL )
583 {
584 Previous = &(GraalFigureRds->LAYERTAB[ GetRdsLayer( ScanRec ) ]);
585
586 for ( ScanPrev = *Previous;
587 ScanPrev != ScanRec;
588 ScanPrev = ScanPrev->NEXT )
589 {
590 if ( GRAAL_PREVIOUS( ScanPrev ) == (rdsrec_list **)NULL )
591 {
592 GRAAL_PREVIOUS( ScanPrev ) = Previous;
593 }
594
595 Previous = &ScanPrev->NEXT;
596 }
597
598 GRAAL_PREVIOUS( ScanRec ) = Previous;
599
600 ScanPrev = ScanPrev->NEXT;
601
602 if ( ( ScanPrev != (rdsrec_list *)NULL ) &&
603 ( GRAAL_PREVIOUS( ScanPrev ) != (rdsrec_list **)NULL ) )
604 {
605 GRAAL_PREVIOUS( ScanPrev ) = &ScanRec->NEXT;
606 }
607 }
608
609 ScanRec = (rdsrec_list *)ScanRec->USER;
610 }
611 while ( ScanRec != FirstRec );
612
613 rdsend();
614 return( FirstRec );
615 }
616
617 /*------------------------------------------------------------\
618 | |
619 | Graal Add Reference |
620 | |
621 \------------------------------------------------------------*/
622
GraalAddReference(ReferenceMbk)623 rdsrec_list *GraalAddReference( ReferenceMbk )
624
625 phref_list *ReferenceMbk;
626 {
627 rdsrec_list *ScanRec;
628 rdsrec_list *ScanPrev;
629 rdsrec_list *FirstRec;
630 rdsrec_list **Previous;
631
632 rdsbegin();
633
634 ScanRec = FirstRec = refmbkrds( GraalFigureRds, ReferenceMbk );
635
636 if ( FirstRec == (rdsrec_list *)NULL )
637 {
638 rdsend();
639 return( FirstRec );
640 }
641
642 do
643 {
644 GRAAL_MBK( ScanRec ) = (void *)ReferenceMbk;
645
646 GraalInsertRectangle( ScanRec );
647
648 if ( GRAAL_PREVIOUS( ScanRec ) == (rdsrec_list **)NULL )
649 {
650 Previous = &(GraalFigureRds->LAYERTAB[ GetRdsLayer( ScanRec ) ]);
651
652 for ( ScanPrev = *Previous;
653 ScanPrev != ScanRec;
654 ScanPrev = ScanPrev->NEXT )
655 {
656 if ( GRAAL_PREVIOUS( ScanPrev ) == (rdsrec_list **)NULL )
657 {
658 GRAAL_PREVIOUS( ScanPrev ) = Previous;
659 }
660
661 Previous = &ScanPrev->NEXT;
662 }
663
664 GRAAL_PREVIOUS( ScanRec ) = Previous;
665
666 ScanPrev = ScanPrev->NEXT;
667
668 if ( ( ScanPrev != (rdsrec_list *)NULL ) &&
669 ( GRAAL_PREVIOUS( ScanPrev ) != (rdsrec_list **)NULL ) )
670 {
671 GRAAL_PREVIOUS( ScanPrev ) = &ScanRec->NEXT;
672 }
673 }
674
675 ScanRec = (rdsrec_list *)ScanRec->USER;
676 }
677 while ( ScanRec != FirstRec );
678
679 rdsend();
680 return( FirstRec );
681 }
682
683 /*------------------------------------------------------------\
684 | |
685 | Graal Add Abox |
686 | |
687 \------------------------------------------------------------*/
688
GraalAddAbox()689 rdsrec_list *GraalAddAbox()
690
691 {
692 rdsrec_list *Rectangle;
693
694 rdsbegin();
695
696 Rectangle = aboxmbkrds( GraalFigureMbk, GraalFigureRds );
697
698 if ( Rectangle != (rdsrec_list *)NULL )
699 {
700 GRAAL_PREVIOUS( Rectangle ) =
701
702 &(GraalFigureRds->LAYERTAB[ RDS_ABOX ]);
703
704 if ( Rectangle->NEXT != (rdsrec_list *)NULL )
705 {
706 GRAAL_PREVIOUS( Rectangle->NEXT ) = &Rectangle->NEXT;
707 }
708
709 GRAAL_MBK( Rectangle ) = (void *)GraalFigureMbk;
710
711 GraalInsertRectangle( Rectangle );
712 }
713
714 rdsend();
715 return( Rectangle );
716 }
717
718 /*------------------------------------------------------------\
719 | |
720 | Graal Delete Functions |
721 | |
722 \------------------------------------------------------------*/
723 /*------------------------------------------------------------\
724 | |
725 | Graal Del Figure |
726 | |
727 \------------------------------------------------------------*/
728
GraalDelFigure()729 void GraalDelFigure()
730
731 {
732 char Layer;
733 rdsrec_list *DelRec;
734 rdsrec_list *ScanRec;
735 rdsins_list *ScanIns;
736 rdsins_list *DelIns;
737
738 rdsbegin();
739
740 for ( Layer = 0; Layer < RDS_MAX_LAYER; Layer++ )
741 {
742 ScanRec = GraalFigureRds->LAYERTAB[ (int)Layer ];
743
744 while ( ScanRec != (rdsrec_list *)NULL )
745 {
746 DelRec = ScanRec;
747 ScanRec = ScanRec->NEXT;
748
749 GraalEraseRecWin( DelRec );
750
751 freerdsrec( DelRec, GRAAL_SIZE );
752 }
753
754 GraalFigureRds->LAYERTAB[ (int)Layer ] = (rdsrec_list *)NULL;
755 }
756
757 ScanIns = GraalFigureRds->INSTANCE;
758
759 while ( ScanIns != (rdsins_list *)NULL )
760 {
761 DelIns = ScanIns;
762 ScanIns = ScanIns->NEXT;
763
764 for ( Layer = 0; Layer < RDS_MAX_LAYER; Layer++ )
765 {
766 ScanRec = GraalFigureRds->LAYERTAB[ (int)Layer ];
767
768 while ( ScanRec != (rdsrec_list *)NULL )
769 {
770 DelRec = ScanRec;
771 ScanRec = ScanRec->NEXT;
772
773 GraalEraseRecWin( DelRec );
774
775 freerdsrec( DelRec, GRAAL_SIZE );
776 }
777 }
778
779 freerdsins( DelIns );
780 }
781
782 GraalFigureRds->INSTANCE = (rdsins_list *)NULL;
783
784 while ( HEAD_RDSFIG != (rdsfig_list *)0 )
785 {
786 delrdsfig( HEAD_RDSFIG->NAME );
787 }
788
789 while ( HEAD_PHFIG != (phfig_list *)0 )
790 {
791 delphfig( HEAD_PHFIG->NAME );
792 }
793
794 GraalDelAllConRec();
795
796 GraalFigureRds = (rdsfig_list *)NULL;
797 GraalFigureMbk = (phfig_list *)NULL;
798
799 GraalEraseWindow();
800
801 rdsend();
802 }
803
804 /*------------------------------------------------------------\
805 | |
806 | Graal Del Instance |
807 | |
808 \------------------------------------------------------------*/
809
GraalDelInstance(InstanceRds)810 void GraalDelInstance( InstanceRds )
811
812 rdsins_list *InstanceRds;
813 {
814 phins_list *InstanceMbk;
815 rdsrec_list *ScanRec;
816 rdsrec_list *DelRec;
817 char Layer;
818
819 rdsbegin();
820
821 *(rdsins_list **)(InstanceRds->USER) = InstanceRds->NEXT;
822
823 if ( InstanceRds->NEXT != (rdsins_list *)NULL )
824 {
825 InstanceRds->NEXT->USER = InstanceRds->USER;
826 }
827
828 InstanceMbk = (phins_list *)GRAAL_MBK( InstanceRds->LAYERTAB[ RDS_ABOX ] );
829
830 *(phins_list **)(InstanceMbk->USER) = InstanceMbk->NEXT;
831
832 if ( InstanceMbk->NEXT != (phins_list *)NULL )
833 {
834 InstanceMbk->NEXT->USER = InstanceMbk->USER;
835 }
836
837 for ( Layer = 0; Layer < RDS_MAX_LAYER; Layer++ )
838 {
839 ScanRec = InstanceRds->LAYERTAB[ (int)Layer ];
840
841 while( ScanRec != (rdsrec_list *)NULL )
842 {
843 DelRec = ScanRec;
844 ScanRec = ScanRec->NEXT;
845
846 GraalEraseRectangle( DelRec );
847
848 freerdsrec( DelRec, GRAAL_SIZE );
849 }
850 }
851
852 freerdsins( InstanceRds );
853 mbkfree( InstanceMbk );
854
855 rdsend();
856 }
857
858 /*------------------------------------------------------------\
859 | |
860 | Graal Del Rectangle |
861 | |
862 \------------------------------------------------------------*/
863
GraalDelRectangle(Rectangle)864 void GraalDelRectangle( Rectangle )
865
866 rdsrec_list *Rectangle;
867 {
868 rdsrec_list *ScanRec;
869 rdsrec_list *DelRec;
870 void *Pointer;
871
872 rdsbegin();
873
874 Pointer = GRAAL_MBK( Rectangle );
875
876 if ( IsRdsSegment( Rectangle ) )
877 {
878 *((phseg_list **)(((phseg_list *)Pointer)->USER)) = ((phseg_list *)Pointer)->NEXT;
879
880 if ( ((phseg_list *)Pointer)->NEXT != (phseg_list *)NULL )
881 {
882 ((phseg_list *)Pointer)->NEXT->USER = ((phseg_list *)Pointer)->USER;
883 }
884
885 mbkfree( Pointer );
886 }
887 else
888 if ( IsRdsVia( Rectangle ) )
889 {
890 *(phvia_list **)(((phvia_list *)Pointer)->USER) = ((phvia_list *)Pointer)->NEXT;
891
892 if (((phvia_list *)Pointer)->NEXT != (phvia_list *)NULL )
893 {
894 ((phvia_list *)Pointer)->NEXT->USER = ((phvia_list *)Pointer)->USER;
895 }
896
897 mbkfree( Pointer );
898 }
899 else
900 if ( IsRdsConnector( Rectangle ) )
901 {
902 *(phcon_list **)(((phcon_list *)Pointer)->USER) = ((phcon_list *)Pointer)->NEXT;
903
904 if (((phcon_list *)Pointer)->NEXT != (phcon_list *)NULL )
905 {
906 ((phcon_list *)Pointer)->NEXT->USER = ((phcon_list *)Pointer)->USER;
907 }
908
909 GraalDelConRec( Rectangle );
910
911 mbkfree( Pointer );
912 }
913 else
914 if ( IsRdsReference( Rectangle ) )
915 {
916 *(phref_list **)(((phref_list *)Pointer)->USER) = ((phref_list *)Pointer)->NEXT;
917
918 if (((phref_list *)Pointer)->NEXT != (phref_list *)NULL )
919 {
920 ((phref_list *)Pointer)->NEXT->USER = ((phref_list *)Pointer)->USER;
921 }
922
923 mbkfree( Pointer );
924 }
925 /*\
926 else
927 if ( IsRdsFigure( Rectangle ) )
928 {
929 if ( GraalFigureRds->LAYERTAB[ RDS_ABOX ] == Rectangle )
930 {
931 GraalFigureMbk->XAB1 = 0;
932 GraalFigureMbk->YAB1 = 0;
933 GraalFigureMbk->XAB2 = 0;
934 GraalFigureMbk->YAB2 = 0;
935 }
936 }
937 \*/
938
939 ScanRec = Rectangle;
940
941 do
942 {
943 DelRec = ScanRec;
944 ScanRec = (rdsrec_list *)(ScanRec->USER);
945
946 *(GRAAL_PREVIOUS( DelRec )) = DelRec->NEXT;
947
948 if ( DelRec->NEXT != (rdsrec_list *)NULL )
949 {
950 GRAAL_PREVIOUS( DelRec->NEXT ) = GRAAL_PREVIOUS( DelRec );
951 }
952
953 GraalEraseRectangle( DelRec );
954
955 freerdsrec( DelRec, GRAAL_SIZE );
956 }
957 while ( ScanRec != Rectangle );
958
959 rdsend();
960 }
961
962 /*------------------------------------------------------------\
963 | |
964 | Graal Save Figure |
965 | |
966 \------------------------------------------------------------*/
967
GraalSaveFigure()968 char GraalSaveFigure()
969
970 {
971 rdsbegin();
972
973 GraalDelUndo( &GraalHeadRedo );
974 GraalDelUndo( &GraalHeadUndo );
975
976 rdsend();
977 return( Graalsavephfig( GraalFigureMbk ) );
978 }
979
980 /*------------------------------------------------------------\
981 | |
982 | Graalgetphfig |
983 | |
984 \------------------------------------------------------------*/
985
Graalgetphfig(FigureName,Mode)986 phfig_list *Graalgetphfig( FigureName, Mode )
987
988 char *FigureName;
989 char Mode;
990 {
991 phfig_list *FigureMbk;
992
993 rdsbegin();
994
995 GraalActiveExitHandler();
996
997 if ( setjmp( GraalJumpBuffer ) == 0 )
998 {
999 FigureMbk = getphfig( FigureName, Mode );
1000
1001 GraalResetExitHandler();
1002
1003 if ( ( FigureMbk->XAB1 == FigureMbk->XAB2 ) &&
1004 ( FigureMbk->YAB1 == FigureMbk->YAB2 ) )
1005 {
1006 FigureMbk->XAB1 = 0;
1007 FigureMbk->XAB2 = 0;
1008 FigureMbk->YAB1 = 0;
1009 FigureMbk->YAB2 = 0;
1010 }
1011
1012 rdsend();
1013 return( FigureMbk );
1014 }
1015
1016 GraalResetExitHandler();
1017
1018 delphfig( FigureName );
1019
1020 rdsend();
1021 return( (phfig_list *)NULL );
1022 }
1023
1024 /*------------------------------------------------------------\
1025 | |
1026 | Graalrflattenphfig |
1027 | |
1028 \------------------------------------------------------------*/
1029
Graalrflattenphfig(FigureMbk,Concat,Catal)1030 phfig_list *Graalrflattenphfig( FigureMbk, Concat, Catal )
1031
1032 phfig_list *FigureMbk;
1033 char Concat;
1034 char Catal;
1035 {
1036 rdsbegin();
1037
1038 GraalActiveExitHandler();
1039
1040 if ( setjmp( GraalJumpBuffer ) == 0 )
1041 {
1042 rflattenphfig( FigureMbk, Concat, Catal );
1043
1044 GraalResetExitHandler();
1045
1046 rdsend();
1047 return( FigureMbk );
1048 }
1049
1050 GraalResetExitHandler();
1051
1052 rdsend();
1053 return( (phfig_list *)NULL );
1054 }
1055
1056 /*------------------------------------------------------------\
1057 | |
1058 | Graalflattenphfig |
1059 | |
1060 \------------------------------------------------------------*/
1061
Graalflattenphfig(FigureMbk,Name,Concat)1062 phfig_list *Graalflattenphfig( FigureMbk, Name, Concat )
1063
1064 phfig_list *FigureMbk;
1065 char *Name;
1066 char Concat;
1067 {
1068 rdsbegin();
1069
1070 GraalActiveExitHandler();
1071
1072 if ( setjmp( GraalJumpBuffer ) == 0 )
1073 {
1074 flattenphfig( FigureMbk, Name, Concat );
1075
1076 GraalResetExitHandler();
1077
1078 rdsend();
1079 return( FigureMbk );
1080 }
1081
1082 GraalResetExitHandler();
1083
1084 rdsend();
1085 return( (phfig_list *)NULL );
1086 }
1087
1088 /*------------------------------------------------------------\
1089 | |
1090 | Graalsavephfig |
1091 | |
1092 \------------------------------------------------------------*/
1093
Graalsavephfig(FigureMbk)1094 char Graalsavephfig( FigureMbk )
1095
1096 phfig_list *FigureMbk;
1097 {
1098 rdsbegin();
1099
1100 GraalActiveExitHandler();
1101
1102 if ( setjmp( GraalJumpBuffer ) == 0 )
1103 {
1104 savephfig( FigureMbk );
1105
1106 GraalResetExitHandler();
1107
1108 rdsend();
1109 return( GRAAL_TRUE );
1110 }
1111
1112 GraalResetExitHandler();
1113
1114 rdsend();
1115 return( GRAAL_FALSE );
1116 }
1117
1118 /*------------------------------------------------------------\
1119 | |
1120 | Graaldrucrdsfig |
1121 | |
1122 \------------------------------------------------------------*/
1123
Graaldrucrdsfig(Figure)1124 rdsfig_list *Graaldrucrdsfig( Figure )
1125
1126 rdsfig_list *Figure;
1127 {
1128 rdsfig_list *FigureError;
1129
1130 rdsbegin();
1131
1132 GraalActiveExitHandler();
1133
1134 if ( setjmp( GraalJumpBuffer ) == 0 )
1135 {
1136 FigureError = drucrdsfig( Figure,
1137 RDS_TECHNO_NAME,
1138 "_druc_err_" );
1139 GraalResetExitHandler();
1140
1141 rdsend();
1142 return( FigureError );
1143 }
1144
1145 GraalResetExitHandler();
1146
1147 delrdsfig( Figure->NAME );
1148
1149 rdsend();
1150 return( (rdsfig_list *)NULL );
1151 }
1152
1153 /*------------------------------------------------------------\
1154 | |
1155 | Graalgetrdsfig |
1156 | |
1157 \------------------------------------------------------------*/
1158
Graalgetrdsfig(FigureName,Mode)1159 rdsfig_list *Graalgetrdsfig( FigureName, Mode )
1160
1161 char *FigureName;
1162 char Mode;
1163 {
1164 rdsfig_list *FigureRds;
1165
1166 rdsbegin();
1167
1168 FigureName = namealloc( FigureName );
1169 GraalActiveExitHandler();
1170
1171 if ( setjmp( GraalJumpBuffer ) == 0 )
1172 {
1173 FigureRds = getrdsfig( FigureName, Mode, GRAAL_SIZE );
1174
1175 GraalResetExitHandler();
1176
1177 rdsend();
1178 return( FigureRds );
1179 }
1180
1181 GraalResetExitHandler();
1182
1183 delrdsfig( FigureName );
1184
1185 rdsend();
1186 return( (rdsfig_list *)NULL );
1187 }
1188
1189 /*------------------------------------------------------------\
1190 | |
1191 | Graalrflattenrdsfig |
1192 | |
1193 \------------------------------------------------------------*/
1194
Graalrflattenrdsfig(Figure,Concat,Catal)1195 rdsfig_list *Graalrflattenrdsfig( Figure, Concat, Catal )
1196
1197 rdsfig_list *Figure;
1198 char Concat;
1199 char Catal;
1200 {
1201 rdsbegin();
1202
1203 GraalActiveExitHandler();
1204
1205 if ( setjmp( GraalJumpBuffer ) == 0 )
1206 {
1207 rflattenrdsfig( Figure, Concat, Catal );
1208
1209 GraalResetExitHandler();
1210
1211 rdsend();
1212 return( Figure );
1213 }
1214
1215 GraalResetExitHandler();
1216
1217 rdsend();
1218 return( (rdsfig_list *)0 );
1219 }
1220