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 : Create.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 <Xm/Xm.h>
47 # include <Xm/PushBG.h>
48 # include <Xm/CascadeBG.h>
49
50 # include "mut.h"
51 # include "mph.h"
52 # include "rds.h"
53 # include "rpr.h"
54 # include "rfm.h"
55 # include "GRM.h"
56 # include "GMX.h"
57 # include "GTB.h"
58 # include "GSB.h"
59 # include "GMC.h"
60 # include "GMV.h"
61 # include "GMT.h"
62
63 # include "GMC_create.h"
64 # include "GMC_dialog.h"
65
66 /*------------------------------------------------------------\
67 | |
68 | Constants |
69 | |
70 \------------------------------------------------------------*/
71 /*------------------------------------------------------------\
72 | |
73 | Types |
74 | |
75 \------------------------------------------------------------*/
76 /*------------------------------------------------------------\
77 | |
78 | Variables |
79 | |
80 \------------------------------------------------------------*/
81 /*------------------------------------------------------------\
82 | |
83 | Segment & Wire |
84 | |
85 \------------------------------------------------------------*/
86
87 char GraalSegmentLayer = ALU1;
88 float GraalSegmentWidth = -1.0;
89 char *GraalSegmentName = (char *)NULL;
90 char GraalSegmentWire = GRAAL_FALSE;
91
92 /*------------------------------------------------------------\
93 | |
94 | Via |
95 | |
96 \------------------------------------------------------------*/
97
98 char GraalViaType = CONT_POLY;
99 char *GraalViaName = (char *)NULL;
100
101 /*------------------------------------------------------------\
102 | |
103 | Big Via |
104 | |
105 \------------------------------------------------------------*/
106
107 char GraalBigViaType = CONT_VIA;
108 char *GraalBigViaName = (char *)NULL;
109
110 /*------------------------------------------------------------\
111 | |
112 | Transistor |
113 | |
114 \------------------------------------------------------------*/
115
116 char GraalTransistorType = NTRANS;
117 float GraalTransistorWidth = -1.0;
118 char *GraalTransistorName = (char *)NULL;
119 char GraalTransistorWire = GRAAL_FALSE;
120
121 /*------------------------------------------------------------\
122 | |
123 | Connector |
124 | |
125 \------------------------------------------------------------*/
126
127 char GraalConnectorLayer = ALU1;
128 float GraalConnectorWidth = -1.0;
129 char *GraalConnectorName = (char *)NULL;
130 char GraalConnectorOrient = GRAAL_NORTH;
131
132 /*------------------------------------------------------------\
133 | |
134 | Reference |
135 | |
136 \------------------------------------------------------------*/
137
138 char GraalReferenceType = MBK_REF_REF;
139 char *GraalReferenceName = (char *)NULL;
140
141 /*------------------------------------------------------------\
142 | |
143 | Instance |
144 | |
145 \------------------------------------------------------------*/
146
147 char GraalInstanceSym = NOSYM;
148 char *GraalInstanceName = (char *)NULL;
149 char *GraalInstanceModel = (char *)NULL;
150
151 /*------------------------------------------------------------\
152 | |
153 | Functions |
154 | |
155 \------------------------------------------------------------*/
156 /*------------------------------------------------------------\
157 | |
158 | GraalCreateFigureMbk |
159 | |
160 \------------------------------------------------------------*/
161
GraalCreateFigureMbk()162 void GraalCreateFigureMbk()
163
164 {
165 if ( GraalFigureMbk == (phfig_list *)NULL )
166 {
167 rdsbegin();
168
169 GraalFigureMbk = addphfig( GRAAL_DEFAULT_FIGURE_NAME );
170
171 GraalAddFigure();
172 GraalChangeTopLevelTitle( GraalFigureMbk->NAME );
173
174 rdsend();
175 }
176 }
177
178 /*------------------------------------------------------------\
179 | |
180 | GraalCreateSegmentMbk |
181 | |
182 \------------------------------------------------------------*/
183
GraalCreateSegmentMbk(LambdaX1,LambdaY1,LambdaX2,LambdaY2)184 void GraalCreateSegmentMbk( LambdaX1, LambdaY1, LambdaX2, LambdaY2 )
185
186 long LambdaX1;
187 long LambdaY1;
188 long LambdaX2;
189 long LambdaY2;
190 {
191 rdsrec_list *Rectangle;
192 phseg_list *Segment;
193 char *SaveName;
194 char *SegmentName;
195 long Delta;
196
197 rdsbegin();
198
199 if ( LambdaX1 == LambdaX2 )
200 {
201 Delta = LambdaY2 - LambdaY1;
202 }
203 else
204 {
205 Delta = LambdaX2 - LambdaX1;
206 }
207
208 if ( Delta < 0 ) Delta = - Delta;
209
210 if ( Delta < GRAAL_SCALE * GRAAL_SEGMENT_VALUE_TABLE[(int)GraalSegmentLayer][1] )
211 {
212 GraalErrorMessage( GraalMainWindow, "This segment is too small !" );
213
214 rdsend();
215 return;
216 }
217
218 if ( ( GraalSegmentLayer >= CALU1 ) &&
219 ( GraalSegmentLayer <= CALU9 ) )
220 {
221 SaveName = GraalSegmentName;
222
223 GraalEnterDialog( &GraalChangeSegmentNameDialog );
224
225 if ( GraalCreateDialogCancel )
226 {
227 rdsend();
228 return;
229 }
230
231 SegmentName = GraalSegmentName;
232 GraalSegmentName = SaveName;
233
234 if ( SegmentName == (char *)NULL )
235 {
236 GraalErrorMessage( GraalMainWindow, "Connector must have name !" );
237
238 rdsend();
239 return;
240 }
241 }
242 else
243 {
244 SegmentName = GraalSegmentName;
245 }
246
247 GraalCreateFigureMbk();
248
249 Segment =
250
251 addphseg( GraalFigureMbk, GraalSegmentLayer,
252 (long)( GraalSegmentWidth * SCALE_X ),
253 (long)( LambdaX1 * GRAAL_SCALE_X ),
254 (long)( LambdaY1 * GRAAL_SCALE_X ),
255 (long)( LambdaX2 * GRAAL_SCALE_X ),
256 (long)( LambdaY2 * GRAAL_SCALE_X ),
257 SegmentName );
258
259 Segment->USER = (void *)(&GraalFigureMbk->PHSEG);
260
261 if ( Segment->NEXT != (phseg_list *)NULL )
262 {
263 Segment->NEXT->USER = (void *)(&Segment->NEXT);
264 }
265
266 Rectangle = GraalAddSegment( Segment );
267
268 if ( Rectangle != (rdsrec_list *)NULL )
269 {
270 GraalAddUndo();
271 GraalAddUndoRec( Rectangle );
272
273 if ( ( GraalHeadEqui != (rdsrec_list *)NULL ) ||
274 ( GraalHeadPeek != (graalpeek *)NULL ) )
275 {
276 GraalDelEqui();
277 GraalDelPeek();
278 GraalZoomRefresh();
279 }
280 else
281 {
282 GraalDisplayRectangle( Rectangle );
283 }
284 }
285 else
286 {
287 delphseg( GraalFigureMbk, Segment );
288
289 GraalErrorMessage( GraalMainWindow, "Can't create any segment of this layer !" );
290 }
291
292 rdsend();
293 }
294
295 /*------------------------------------------------------------\
296 | |
297 | GraalCreateViaMbk |
298 | |
299 \------------------------------------------------------------*/
300
GraalCreateViaMbk(LambdaX1,LambdaY1)301 void GraalCreateViaMbk( LambdaX1, LambdaY1 )
302
303 long LambdaX1;
304 long LambdaY1;
305 {
306 rdsrec_list *Rectangle;
307 phvia_list *Via;
308
309 rdsbegin();
310
311 GraalCreateFigureMbk();
312
313 Via = addphvia( GraalFigureMbk, GraalViaType,
314 (long)( LambdaX1 * GRAAL_SCALE_X ),
315 (long)( LambdaY1 * GRAAL_SCALE_X ), 0, 0, GraalViaName );
316
317 Via->USER = (void *)(&GraalFigureMbk->PHVIA);
318
319 if ( Via->NEXT != (phvia_list *)NULL )
320 {
321 Via->NEXT->USER = (void *)(&Via->NEXT);
322 }
323
324 Rectangle = GraalAddVia( Via );
325
326 if ( Rectangle != (rdsrec_list *)NULL )
327 {
328 GraalAddUndo();
329 GraalAddUndoRec( Rectangle );
330
331 if ( ( GraalHeadEqui != (rdsrec_list *)NULL ) ||
332 ( GraalHeadPeek != (graalpeek *)NULL ) )
333 {
334 GraalDelEqui();
335 GraalDelPeek();
336 GraalZoomRefresh();
337 }
338 else
339 {
340 GraalDisplayRectangle( Rectangle );
341 }
342 }
343 else
344 {
345 delphvia( GraalFigureMbk, Via );
346
347 GraalErrorMessage( GraalMainWindow, "Can't create any via of this type !" );
348 }
349
350 rdsend();
351 }
352
353 /*------------------------------------------------------------\
354 | |
355 | GraalCreateBigViaMbk |
356 | |
357 \------------------------------------------------------------*/
358
GraalCreateBigViaMbk(LambdaX1,LambdaY1,LambdaX2,LambdaY2)359 void GraalCreateBigViaMbk( LambdaX1, LambdaY1, LambdaX2, LambdaY2 )
360
361 long LambdaX1;
362 long LambdaY1;
363 {
364 rdsrec_list *Rectangle;
365 phvia_list *Via;
366 long Swap;
367 long ViaDx;
368 long ViaDy;
369
370 rdsbegin();
371
372 if ( ( LambdaX1 != LambdaX2 ) &&
373 ( LambdaY1 != LambdaY2 ) )
374 {
375 if ( LambdaX1 > LambdaX2 )
376 {
377 Swap = LambdaX1; LambdaX1 = LambdaX2; LambdaX2 = Swap;
378 }
379
380 if ( LambdaY1 > LambdaY2 )
381 {
382 Swap = LambdaY1; LambdaY1 = LambdaY2; LambdaY2 = Swap;
383 }
384
385 ViaDx = LambdaX2 - LambdaX1;
386 ViaDy = LambdaY2 - LambdaY1;
387
388 if ( ( ViaDx < GRAAL_SCALE * GRAAL_BIGVIA_VALUE_TABLE[ (int)GraalBigViaType ][0] ) ||
389 ( ViaDy < GRAAL_SCALE * GRAAL_BIGVIA_VALUE_TABLE[ (int)GraalBigViaType ][0] ) )
390 {
391 GraalErrorMessage( GraalMainWindow, "This big via is too small !" );
392
393 rdsend();
394 return;
395 }
396 }
397 else
398 {
399 GraalErrorMessage( GraalMainWindow, "The big via must be rectangular !" );
400
401 rdsend();
402 return;
403 }
404
405 GraalCreateFigureMbk();
406
407 Via = addphvia( GraalFigureMbk, GraalBigViaType,
408 (long)( (( LambdaX1 + LambdaX2 ) / 2.0) * GRAAL_SCALE_X ),
409 (long)( (( LambdaY1 + LambdaY2 ) / 2.0) * GRAAL_SCALE_X ),
410 (long)( ViaDx * GRAAL_SCALE_X ),
411 (long)( ViaDy * GRAAL_SCALE_X ), GraalBigViaName );
412
413 Via->USER = (void *)(&GraalFigureMbk->PHVIA);
414
415 if ( Via->NEXT != (phvia_list *)NULL )
416 {
417 Via->NEXT->USER = (void *)(&Via->NEXT);
418 }
419
420 Rectangle = GraalAddVia( Via );
421
422 if ( Rectangle != (rdsrec_list *)NULL )
423 {
424 GraalAddUndo();
425 GraalAddUndoRec( Rectangle );
426
427 if ( ( GraalHeadEqui != (rdsrec_list *)NULL ) ||
428 ( GraalHeadPeek != (graalpeek *)NULL ) )
429 {
430 GraalDelEqui();
431 GraalDelPeek();
432 GraalZoomRefresh();
433 }
434 else
435 {
436 GraalDisplayRectangle( Rectangle );
437 }
438 }
439 else
440 {
441 delphvia( GraalFigureMbk, Via );
442
443 GraalErrorMessage( GraalMainWindow, "Can't create any big via of this type !" );
444 }
445
446 rdsend();
447 }
448
449 /*------------------------------------------------------------\
450 | |
451 | GraalCreateTransistorMbk |
452 | |
453 \------------------------------------------------------------*/
454
GraalCreateTransistorMbk(LambdaX1,LambdaY1,LambdaX2,LambdaY2)455 void GraalCreateTransistorMbk( LambdaX1, LambdaY1, LambdaX2, LambdaY2 )
456
457 long LambdaX1;
458 long LambdaY1;
459 long LambdaX2;
460 long LambdaY2;
461 {
462 rdsrec_list *Rectangle;
463 phseg_list *Transistor;
464 long Delta;
465
466 rdsbegin();
467
468 if ( LambdaX1 == LambdaX2 )
469 {
470 Delta = LambdaY2 - LambdaY1;
471 }
472 else
473 {
474 Delta = LambdaX2 - LambdaX1;
475 }
476
477 if ( Delta < 0 ) Delta = - Delta;
478
479 if ( Delta < GRAAL_SCALE * GRAAL_SEGMENT_VALUE_TABLE[(int)GraalTransistorType][1] )
480 {
481 GraalErrorMessage( GraalMainWindow, "This transistor is too small !" );
482
483 rdsend();
484 return;
485 }
486
487 GraalCreateFigureMbk();
488
489 Transistor =
490
491 addphseg( GraalFigureMbk, GraalTransistorType,
492 (long)( GraalTransistorWidth * SCALE_X ),
493 (long)( LambdaX1 * GRAAL_SCALE_X ),
494 (long)( LambdaY1 * GRAAL_SCALE_X ),
495 (long)( LambdaX2 * GRAAL_SCALE_X ),
496 (long)( LambdaY2 * GRAAL_SCALE_X ),
497 GraalTransistorName );
498
499 Transistor->USER = (void *)(&GraalFigureMbk->PHSEG);
500
501 if ( Transistor->NEXT != (phseg_list *)NULL )
502 {
503 Transistor->NEXT->USER = (void *)(&Transistor->NEXT);
504 }
505
506 Rectangle = GraalAddSegment( Transistor );
507
508 if ( Rectangle != (rdsrec_list *)NULL )
509 {
510 GraalAddUndo();
511 GraalAddUndoRec( Rectangle );
512
513 if ( ( GraalHeadEqui != (rdsrec_list *)NULL ) ||
514 ( GraalHeadPeek != (graalpeek *)NULL ) )
515 {
516 GraalDelEqui();
517 GraalDelPeek();
518 GraalZoomRefresh();
519 }
520 else
521 {
522 GraalDisplayRectangle( Rectangle );
523 }
524 }
525 else
526 {
527 delphseg( GraalFigureMbk, Transistor );
528
529 GraalErrorMessage( GraalMainWindow, "Can't create any transistor of this type !" );
530 }
531
532 rdsend();
533 }
534
535 /*------------------------------------------------------------\
536 | |
537 | GraalCreateConnectorMbk |
538 | |
539 \------------------------------------------------------------*/
540
GraalCreateConnectorMbk(LambdaX1,LambdaY1)541 void GraalCreateConnectorMbk( LambdaX1, LambdaY1 )
542
543 long LambdaX1;
544 long LambdaY1;
545 {
546 rdsrec_list *Rectangle;
547 phcon_list *Connector;
548 char MbkOrient;
549
550 rdsbegin();
551
552 LambdaX1 = (long)(LambdaX1 * GRAAL_SCALE_X);
553 LambdaY1 = (long)(LambdaY1 * GRAAL_SCALE_X);
554
555 switch ( GraalConnectorOrient )
556 {
557 case GRAAL_NORTH : MbkOrient = NORTH;
558 break;
559 case GRAAL_SOUTH : MbkOrient = SOUTH;
560 break;
561 case GRAAL_EAST : MbkOrient = EAST;
562 break;
563 default : MbkOrient = WEST;
564 }
565
566 GraalEnterDialog( &GraalChangeConnectorNameDialog );
567
568 if ( GraalCreateDialogCancel )
569 {
570 rdsend();
571 return;
572 }
573
574 if ( GraalConnectorName != (char *)NULL )
575 {
576 GraalCreateFigureMbk();
577
578 Connector =
579
580 addphcon( GraalFigureMbk, MbkOrient,
581 GraalConnectorName,
582 LambdaX1, LambdaY1,
583 GraalConnectorLayer,
584 (long)( GraalConnectorWidth * SCALE_X ) );
585
586 Connector->USER = (void *)(&GraalFigureMbk->PHCON);
587
588 if ( Connector->NEXT != (phcon_list *)NULL )
589 {
590 Connector->NEXT->USER = (void *)(&Connector->NEXT);
591 }
592
593 Rectangle = GraalAddConnector( Connector );
594
595 if ( Rectangle != (rdsrec_list *)NULL )
596 {
597 GraalAddUndo();
598 GraalAddUndoRec( Rectangle );
599
600 if ( ( GraalHeadEqui != (rdsrec_list *)NULL ) ||
601 ( GraalHeadPeek != (graalpeek *)NULL ) )
602 {
603 GraalDelEqui();
604 GraalDelPeek();
605 GraalZoomRefresh();
606 }
607 else
608 {
609 GraalDisplayRectangle( Rectangle );
610 }
611 }
612 else
613 {
614 delphcon( GraalFigureMbk, Connector );
615
616 GraalErrorMessage( GraalMainWindow, "Can't create any connector of this layer !" );
617 }
618 }
619 else
620 {
621 GraalErrorMessage( GraalMainWindow, "Connector must have name !" );
622 }
623
624 rdsend();
625 }
626
627 /*------------------------------------------------------------\
628 | |
629 | GraalCreateReferenceMbk |
630 | |
631 \------------------------------------------------------------*/
632
GraalCreateReferenceMbk(LambdaX1,LambdaY1)633 void GraalCreateReferenceMbk( LambdaX1, LambdaY1 )
634
635 long LambdaX1;
636 long LambdaY1;
637 {
638 rdsrec_list *Rectangle;
639 phref_list *Reference;
640
641 rdsbegin();
642
643 GraalEnterDialog( &GraalChangeReferenceNameDialog );
644
645 if ( GraalCreateDialogCancel )
646 {
647 rdsend();
648 return;
649 }
650
651 if ( GraalReferenceName != (char *)NULL )
652 {
653 GraalCreateFigureMbk();
654
655 Reference =
656
657 addphref( GraalFigureMbk,
658 (GraalReferenceType == MBK_REF_REF) ? "ref_ref":"ref_con" ,
659 GraalReferenceName,
660 (long)( LambdaX1 * GRAAL_SCALE_X ),
661 (long)( LambdaY1 * GRAAL_SCALE_X ) );
662
663 Reference->USER = (void *)(&GraalFigureMbk->PHREF);
664
665 if ( Reference->NEXT != (phref_list *)NULL )
666 {
667 Reference->NEXT->USER = (void *)(&Reference->NEXT);
668 }
669
670 Rectangle = GraalAddReference( Reference );
671
672 if ( Rectangle != (rdsrec_list *)NULL )
673 {
674 GraalAddUndo();
675 GraalAddUndoRec( Rectangle );
676
677 if ( ( GraalHeadEqui != (rdsrec_list *)NULL ) ||
678 ( GraalHeadPeek != (graalpeek *)NULL ) )
679 {
680 GraalDelEqui();
681 GraalDelPeek();
682 GraalZoomRefresh();
683 }
684 else
685 {
686 GraalDisplayRectangle( Rectangle );
687 }
688 }
689 else
690 {
691 delphref( GraalFigureMbk, Reference );
692
693 GraalErrorMessage( GraalMainWindow, "Can't create any reference of this type !" );
694 }
695 }
696 else
697 {
698 GraalErrorMessage( GraalMainWindow, "Reference must have name !" );
699 }
700
701 rdsend();
702 }
703
704 /*------------------------------------------------------------\
705 | |
706 | GraalCreateInstanceMbk |
707 | |
708 \------------------------------------------------------------*/
709
GraalCreateInstanceMbk(LambdaX1,LambdaY1)710 void GraalCreateInstanceMbk( LambdaX1, LambdaY1 )
711
712 long LambdaX1;
713 long LambdaY1;
714 {
715 phins_list *InstanceMbk;
716 phins_list *SaveInstance;
717 rdsins_list *InstanceRds;
718
719 rdsbegin();
720
721 GraalEnterChangeInstanceModelDialog();
722
723 if ( GraalCreateDialogCancel )
724 {
725 rdsend();
726 return;
727 }
728
729 if ( GraalInstanceModel != (char *)NULL )
730 {
731 GraalEnterDialog( &GraalChangeInstanceNameDialog );
732
733 if ( GraalCreateDialogCancel )
734 {
735 rdsend();
736 return;
737 }
738
739 if ( GraalInstanceName != (char *)NULL )
740 {
741 GraalCreateFigureMbk();
742
743 if ( GraalFigureMbk->NAME == GraalInstanceModel )
744 {
745 GraalErrorMessage( GraalMainWindow,
746 "A figure cannot be part of itself !" );
747 rdsend();
748 return;
749 }
750
751 for ( InstanceRds = GraalFigureRds->INSTANCE;
752 InstanceRds != (rdsins_list *)NULL;
753 InstanceRds = InstanceRds->NEXT )
754 {
755 if ( InstanceRds->INSNAME == GraalInstanceName )
756 {
757 if ( ! IsGraalDeleted( InstanceRds->LAYERTAB[ RDS_ABOX ] ) )
758 {
759 GraalErrorMessage( GraalMainWindow,
760 "All instances must have different names !" );
761 rdsend();
762 return;
763 }
764 }
765 }
766
767 SaveInstance = GraalFigureMbk->PHINS;
768 GraalFigureMbk->PHINS = (phins_list *)NULL;
769
770 InstanceMbk =
771
772 addphins( GraalFigureMbk,
773 GraalInstanceModel,
774 GraalInstanceName,
775 GraalInstanceSym,
776 (long)( LambdaX1 * GRAAL_SCALE_X ),
777 (long)( LambdaY1 * GRAAL_SCALE_X ) );
778
779 InstanceMbk->NEXT = SaveInstance;
780 InstanceMbk->USER = (void *)(&GraalFigureMbk->PHINS);
781
782 if ( SaveInstance != (phins_list *)NULL )
783 {
784 SaveInstance->USER = (void *)(&InstanceMbk->NEXT);
785 }
786
787 InstanceRds = GraalAddInstance( InstanceMbk );
788
789 GraalDisplayToolsMessage();
790
791 if ( InstanceRds == (rdsins_list *)NULL )
792 {
793 GraalFigureMbk->PHINS = SaveInstance;
794 mbkfree( InstanceMbk );
795
796 GraalErrorMessage( GraalMainWindow, "Unable to load instance model !" );
797 }
798 else
799 {
800 GraalDelEqui();
801 GraalAddUndo();
802 GraalAddUndoRec( InstanceRds->LAYERTAB[ RDS_ABOX ] );
803 GraalZoomRefresh();
804 }
805 }
806 else
807 {
808 GraalErrorMessage( GraalMainWindow, "An instance must have a name !" );
809 }
810 }
811 else
812 {
813 GraalErrorMessage( GraalMainWindow, "An instance model name must specified !" );
814 }
815
816 rdsend();
817 }
818
819 /*------------------------------------------------------------\
820 | |
821 | Graal Create Abutmentbox |
822 | |
823 \------------------------------------------------------------*/
824
GraalCreateAbutmentBoxMbk(LambdaX1,LambdaY1,LambdaX2,LambdaY2)825 void GraalCreateAbutmentBoxMbk( LambdaX1, LambdaY1, LambdaX2, LambdaY2 )
826
827 long LambdaX1;
828 long LambdaY1;
829 long LambdaX2;
830 long LambdaY2;
831 {
832 rdsrec_list *Rectangle;
833 long Swap;
834
835 rdsbegin();
836
837 if ( ( LambdaX1 != LambdaX2 ) &&
838 ( LambdaY1 != LambdaY2 ) )
839 {
840 if ( LambdaX1 > LambdaX2 )
841 {
842 Swap = LambdaX1; LambdaX1 = LambdaX2; LambdaX2 = Swap;
843 }
844
845 if ( LambdaY1 > LambdaY2 )
846 {
847 Swap = LambdaY1; LambdaY1 = LambdaY2; LambdaY2 = Swap;
848 }
849 }
850 else
851 {
852 GraalErrorMessage( GraalMainWindow, "The abutment box must be rectangular !" );
853
854 rdsend();
855 return;
856 }
857
858 GraalCreateFigureMbk();
859
860 GraalFigureMbk->XAB1 = (long)( LambdaX1 * GRAAL_SCALE_X );
861 GraalFigureMbk->YAB1 = (long)( LambdaY1 * GRAAL_SCALE_X );
862 GraalFigureMbk->XAB2 = (long)( LambdaX2 * GRAAL_SCALE_X );
863 GraalFigureMbk->YAB2 = (long)( LambdaY2 * GRAAL_SCALE_X );
864
865 Rectangle = GraalAddAbox();
866
867 if ( Rectangle != (rdsrec_list *)NULL )
868 {
869 GraalAddUndo();
870 GraalAddUndoRec( Rectangle );
871
872 if ( ( GraalHeadEqui != (rdsrec_list *)NULL ) ||
873 ( GraalHeadPeek != (graalpeek *)NULL ) )
874 {
875 GraalDelEqui();
876 GraalDelPeek();
877 GraalZoomRefresh();
878 }
879 else
880 {
881 GraalDisplayRectangle( Rectangle );
882 }
883
884 GraalChangeEditMode( GRAAL_EDIT_MEASURE,
885 GraalPromptEditMeasure );
886 }
887 else
888 {
889 GraalFigureMbk->XAB1 = 0;
890 GraalFigureMbk->YAB1 = 0;
891 GraalFigureMbk->XAB2 = 0;
892 GraalFigureMbk->YAB2 = 0;
893
894 GraalErrorMessage( GraalMainWindow, "Can't create this abutment box !" );
895 }
896
897 rdsend();
898 }
899