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 : Select.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 <string.h>
48 # include <Xm/Xm.h>
49 # include <Xm/PushBG.h>
50 # include <Xm/CascadeBG.h>
51
52 # include "mut.h"
53 # include "mph.h"
54 # include "rds.h"
55 # include "rpr.h"
56 # include "rfm.h"
57 # include "GRM.h"
58 # include "GMX.h"
59 # include "GTB.h"
60 # include "GSB.h"
61 # include "GME.h"
62 # include "GMT.h"
63 # include "GMV.h"
64
65 # include "GME_select.h"
66 # include "GRM_select.h"
67 # include "GME_message.h"
68 # include "GME_panel.h"
69 # include "GME_dialog.h"
70
71 /*------------------------------------------------------------\
72 | |
73 | Constants |
74 | |
75 \------------------------------------------------------------*/
76 /*------------------------------------------------------------\
77 | |
78 | Types |
79 | |
80 \------------------------------------------------------------*/
81 /*------------------------------------------------------------\
82 | |
83 | Variables |
84 | |
85 \------------------------------------------------------------*/
86 /*------------------------------------------------------------\
87 | |
88 | Select Buffer |
89 | |
90 \------------------------------------------------------------*/
91
92 static char GraalSelectBuffer [ GRAAL_SELECT_BUFFER_SIZE ];
93
94 /*------------------------------------------------------------\
95 | |
96 | Functions |
97 | |
98 \------------------------------------------------------------*/
99 /*------------------------------------------------------------\
100 | |
101 | GraalAddSelectList |
102 | |
103 \------------------------------------------------------------*/
104
GraalAddSelectList(Rectangle)105 void GraalAddSelectList( Rectangle )
106
107 rdsrec_list *Rectangle;
108 {
109 void *Pointer;
110 int MbkLayer;
111 int Orient;
112
113 rdsbegin();
114
115 GraalSelectBuffer[0] = '\0';
116 Pointer = GRAAL_MBK( Rectangle );
117
118 if ( IsRdsSegment( Rectangle ) )
119 {
120 MbkLayer = ((phseg_list *)Pointer)->LAYER;
121
122 if ( GET_LYNX_TRANSISTOR_TYPE( MbkLayer ) != RDS_LYNX_TRANSISTOR_EMPTY )
123 {
124 sprintf( GraalSelectBuffer,
125 " TRANSISTOR : %s",
126 GRAAL_TRANSISTOR_NAME_TABLE[ (int)((phseg_list *)Pointer)->LAYER ][0] );
127 }
128 else
129 {
130 sprintf( GraalSelectBuffer,
131 " SEGMENT %s : %s",
132 ( Rectangle->NAME != (char *)NULL ) ? Rectangle->NAME : "None",
133 GRAAL_SEGMENT_NAME_TABLE[ (int)((phseg_list *)Pointer)->LAYER ][0] );
134 }
135 }
136 else
137 if ( IsRdsConnector( Rectangle ) )
138 {
139 switch( ((phcon_list *)Pointer)->ORIENT )
140 {
141 case NORTH : Orient = GRAAL_NORTH;
142 break;
143 case SOUTH : Orient = GRAAL_SOUTH;
144 break;
145 case EAST : Orient = GRAAL_EAST;
146 break;
147 default : Orient = GRAAL_WEST;
148 }
149
150 sprintf( GraalSelectBuffer,
151 " CONNECTOR %s : %s %s",
152 ( Rectangle->NAME != (char *)NULL ) ? Rectangle->NAME : "None",
153 GRAAL_CONNECTOR_NAME_TABLE[ (int)((phcon_list *)Pointer)->LAYER ][0],
154 GRAAL_ORIENT_NAME_TABLE[ Orient ][0] );
155 }
156 else
157 if ( IsRdsVia( Rectangle ) )
158 {
159 if ( ( ((phvia_list *)Pointer)->DX == 0 ) &&
160 ( ((phvia_list *)Pointer)->DY == 0 ) )
161 {
162 sprintf( GraalSelectBuffer,
163 " VIA : %s",
164 GRAAL_VIA_NAME_TABLE[ (int)((phvia_list *)Pointer)->TYPE ][0] );
165 }
166 else
167 {
168 sprintf( GraalSelectBuffer,
169 " BIGVIA : %s",
170 GRAAL_BIGVIA_NAME_TABLE[ (int)((phvia_list *)Pointer)->TYPE ][0] );
171 }
172 }
173 else
174 if ( IsRdsReference( Rectangle ) )
175 {
176 sprintf( GraalSelectBuffer,
177 " REFERENCE %s : %s",
178 ( Rectangle->NAME != (char *)NULL ) ? Rectangle->NAME : "None",
179 ( ! strcmp( ((phref_list *)Pointer)->FIGNAME, "ref_ref" ) ) ? "Ref_Ref" : "Ref_Con" );
180 }
181 else
182 if ( IsRdsInstance( Rectangle ) )
183 {
184 sprintf( GraalSelectBuffer,
185 " INSTANCE %s : %s",
186 ((phins_list *)Pointer)->INSNAME,
187 ((phins_list *)Pointer)->FIGNAME );
188 }
189 if ( IsRdsFigure( Rectangle ) )
190 {
191 sprintf( GraalSelectBuffer,
192 " ABUTMENT BOX : %s",
193 ((phfig_list *)Pointer)->NAME );
194 }
195
196 GraalDisplaySelectList( GraalSelectBuffer );
197
198 rdsend();
199 }
200
201 /*------------------------------------------------------------\
202 | |
203 | GraalEditSelectRectangle |
204 | |
205 \------------------------------------------------------------*/
206
GraalEditSelectRectangle(Number)207 void GraalEditSelectRectangle( Number )
208
209 int Number;
210 {
211 int Counter;
212 graalselect *Select;
213
214 rdsbegin();
215
216 Select = GraalHeadSelect;
217
218 for ( Counter = 0; Counter < Number; Counter++ )
219 {
220 Select = Select->NEXT;
221 }
222
223 if ( IsGraalAccepted( Select->RECTANGLE ) )
224 {
225 GraalRejectRectangle( Select->RECTANGLE );
226 }
227 else
228 {
229 GraalAcceptRectangle( Select->RECTANGLE );
230 }
231
232 GraalDisplayRectangle( Select->RECTANGLE );
233
234 rdsend();
235 }
236
237 /*------------------------------------------------------------\
238 | |
239 | GraalEditSelectAccept |
240 | |
241 \------------------------------------------------------------*/
242
GraalEditSelectAccept()243 void GraalEditSelectAccept()
244 {
245 rdsbegin();
246
247 GraalPurgeSelect();
248
249 rdsend();
250 }
251
252 /*------------------------------------------------------------\
253 | |
254 | GraalEditSelectCancel |
255 | |
256 \------------------------------------------------------------*/
257
GraalEditSelectCancel()258 void GraalEditSelectCancel()
259 {
260 rdsbegin();
261
262 GraalEditUnselectAll();
263
264 rdsend();
265 }
266
267 /*------------------------------------------------------------\
268 | |
269 | Select Functions |
270 | |
271 \------------------------------------------------------------*/
272 /*------------------------------------------------------------\
273 | |
274 | GraalEditUnselectAll |
275 | |
276 \------------------------------------------------------------*/
277
GraalEditUnselectAll()278 void GraalEditUnselectAll()
279 {
280 rdsrec_list *Rectangle;
281
282 rdsbegin();
283
284 if ( GraalHeadSelect != (graalselect *)NULL )
285 {
286 if ( GraalHeadSelect->NEXT == (graalselect *)NULL )
287 {
288 Rectangle = GraalHeadSelect->RECTANGLE;
289 GraalDelSelect();
290 GraalDisplayRectangle( Rectangle );
291 }
292 else
293 {
294 GraalDelSelect();
295 GraalZoomRefresh();
296 }
297 }
298
299 rdsend();
300 }
301
302 /*------------------------------------------------------------\
303 | |
304 | GraalEditSelectPoint |
305 | |
306 \------------------------------------------------------------*/
307
GraalEditSelectPoint(LambdaX1,LambdaY1)308 void GraalEditSelectPoint( LambdaX1, LambdaY1 )
309
310 long LambdaX1;
311 long LambdaY1;
312 {
313 long Offset;
314 graalwin *ScanWin;
315 graalwinrec *ScanWinRec;
316 rdsrec_list *Rec;
317 rdsrec_list *CheckRec;
318 graalselect *Select;
319 char ScanRec;
320 char Layer;
321 char StaticLayer;
322 long X;
323 long Y;
324
325 rdsbegin();
326
327 if ( GraalFigureMbk != (phfig_list *)NULL )
328 {
329 LambdaX1 = LambdaX1 * GRAAL_RDS_LAMBDA;
330 LambdaY1 = LambdaY1 * GRAAL_RDS_LAMBDA;
331
332 X = ( LambdaX1 - GraalWindowXmin ) / GraalWindowSide;
333 Y = ( LambdaY1 - GraalWindowYmin ) / GraalWindowSide;
334
335 if ( X < 0 ) X = 0;
336 if ( X > GraalWindowDx ) X = GraalWindowDx - 1;
337 if ( Y < 0 ) Y = 0;
338 if ( Y > GraalWindowDy ) Y = GraalWindowDy - 1;
339
340 Offset = Y * GraalWindowDx + X;
341
342 ScanWin = &GraalWindowTable[ Offset ];
343
344 if ( ScanWin->LAYERTAB != (graalwinrec **)NULL )
345 {
346 for ( Layer = 0; Layer < RDS_MAX_LAYER; Layer++ )
347 {
348 StaticLayer = RDS_STATIC_LAYER[ (int)Layer ];
349
350 if ( GRAAL_RDS_ACTIVE_LAYER_TABLE[ (int)StaticLayer ] != 1 ) continue;
351
352 for ( ScanWinRec = ScanWin->LAYERTAB[ (int)Layer ];
353 ScanWinRec != (graalwinrec *)NULL;
354 ScanWinRec = ScanWinRec->NEXT )
355 {
356 for ( ScanRec = 0; ScanRec < GRAAL_MAX_REC ; ScanRec++ )
357 {
358 Rec = ScanWinRec->RECTAB[ (int)ScanRec ];
359
360 if ( ( Rec != (rdsrec_list *)NULL ) &&
361 ( ! IsGraalDeleted( Rec ) ) &&
362 ( ! IsGraalCut( Rec ) ) &&
363 ( ! IsGraalSelected( Rec ) ) &&
364 ( ! IsGraalDruc( Rec ) ) &&
365 ( Rec->X <= LambdaX1 ) &&
366 ( Rec->Y <= LambdaY1 ) &&
367 ( ( Rec->X + Rec->DX ) >= LambdaX1 ) &&
368 ( ( Rec->Y + Rec->DY ) >= LambdaY1 ) )
369 {
370 if ( IsRdsFigRec( Rec ) )
371 {
372 if ( Layer == RDS_ABOX )
373 {
374 if ( ( Rec->X == LambdaX1 ) ||
375 ( ( Rec->X + Rec->DX ) == LambdaX1 ) )
376 {
377 if ( ( LambdaY1 < Rec->Y ) ||
378 ( LambdaY1 > ( Rec->Y + Rec->DY ) ) )
379
380 continue;
381 }
382 else
383 if ( ( Rec->Y == LambdaY1 ) ||
384 ( ( Rec->Y + Rec->DY ) == LambdaY1 ) )
385 {
386 if ( ( LambdaX1 < Rec->X ) ||
387 ( LambdaX1 > ( Rec->X + Rec->DX ) ) )
388
389 continue;
390 }
391 else continue;
392 }
393
394 CheckRec = (rdsrec_list *)Rec->USER;
395
396 while ( Rec != CheckRec )
397 {
398 StaticLayer = RDS_STATIC_LAYER[ GetRdsLayer( CheckRec ) ];
399
400 if ( GRAAL_RDS_ACTIVE_LAYER_TABLE[ (int)StaticLayer ] != 1 )
401
402 break;
403
404 CheckRec = (rdsrec_list *)CheckRec->USER;
405 }
406
407 if ( Rec == CheckRec )
408 {
409 GraalAddSelect( Rec );
410 }
411 }
412 else
413 {
414 if ( Layer == RDS_ABOX )
415 {
416 GraalAddSelect( Rec );
417 }
418 }
419 }
420 }
421 }
422 }
423 }
424
425 for ( Select = GraalHeadSelect;
426 Select != (graalselect *)NULL;
427 Select = Select->NEXT )
428 {
429 GraalUnselectRectangle( Select->RECTANGLE );
430 }
431 }
432
433 rdsend();
434 }
435
436 /*------------------------------------------------------------\
437 | |
438 | GraalEditSelectWindow |
439 | |
440 \------------------------------------------------------------*/
441
GraalEditSelectWindow(LambdaX1,LambdaY1,LambdaX2,LambdaY2)442 void GraalEditSelectWindow( LambdaX1, LambdaY1, LambdaX2, LambdaY2 )
443
444 long LambdaX1;
445 long LambdaY1;
446 long LambdaX2;
447 long LambdaY2;
448 {
449 long Offset;
450 graalwin *ScanWin;
451 graalwinrec *ScanWinRec;
452 rdsrec_list *Rec;
453 rdsrec_list *CheckRec;
454 graalselect *Select;
455 char ScanRec;
456 char Layer;
457 char StaticLayer;
458 long Xmin;
459 long Ymin;
460 long Xmax;
461 long Ymax;
462 long X;
463 long Y;
464 long Swap;
465
466 rdsbegin();
467
468 if ( ( LambdaX1 != LambdaX2 ) &&
469 ( LambdaY1 != LambdaY2 ) )
470 {
471 if ( LambdaX1 > LambdaX2 )
472 {
473 Swap = LambdaX1; LambdaX1 = LambdaX2; LambdaX2 = Swap;
474 }
475
476 if ( LambdaY1 > LambdaY2 )
477 {
478 Swap = LambdaY1; LambdaY1 = LambdaY2; LambdaY2 = Swap;
479 }
480 }
481
482 if ( GraalFigureMbk != (phfig_list *)NULL )
483 {
484 LambdaX1 = LambdaX1 * GRAAL_RDS_LAMBDA;
485 LambdaX2 = LambdaX2 * GRAAL_RDS_LAMBDA;
486 LambdaY1 = LambdaY1 * GRAAL_RDS_LAMBDA;
487 LambdaY2 = LambdaY2 * GRAAL_RDS_LAMBDA;
488
489 Xmin = ( LambdaX1 - GraalWindowXmin ) / GraalWindowSide;
490 Xmax = ( LambdaX2 - GraalWindowXmin ) / GraalWindowSide;
491 Ymin = ( LambdaY1 - GraalWindowYmin ) / GraalWindowSide;
492 Ymax = ( LambdaY2 - GraalWindowYmin ) / GraalWindowSide;
493
494 if ( Xmin < 0 ) Xmin = 0;
495 if ( Xmin > GraalWindowDx ) Xmin = GraalWindowDx - 1;
496 if ( Ymin < 0 ) Ymin = 0;
497 if ( Ymin > GraalWindowDy ) Ymin = GraalWindowDy - 1;
498
499 if ( Xmax < 0 ) Xmax = 0;
500 if ( Xmax > GraalWindowDx ) Xmax = GraalWindowDx - 1;
501 if ( Ymax < 0 ) Ymax = 0;
502 if ( Ymax > GraalWindowDy ) Ymax = GraalWindowDy - 1;
503
504 for ( Layer = 0; Layer < RDS_MAX_LAYER; Layer++ )
505 {
506 StaticLayer = RDS_STATIC_LAYER[ (int)Layer ];
507
508 if ( GRAAL_RDS_ACTIVE_LAYER_TABLE[ (int)StaticLayer ] != 1 ) continue;
509
510 Y = Ymin;
511
512 while ( Y <= Ymax )
513 {
514 X = Xmin;
515
516 while ( X <= Xmax )
517 {
518 Offset = ( Y * GraalWindowDx ) + X;
519
520 ScanWin = &GraalWindowTable[ Offset ];
521
522 if ( ScanWin->LAYERTAB != (graalwinrec **)NULL )
523 {
524 for ( ScanWinRec = ScanWin->LAYERTAB[ (int)Layer ];
525 ScanWinRec != (graalwinrec *)NULL;
526 ScanWinRec = ScanWinRec->NEXT )
527 {
528 for ( ScanRec = 0; ScanRec < GRAAL_MAX_REC ; ScanRec++ )
529 {
530 Rec = ScanWinRec->RECTAB[ (int)ScanRec ];
531
532 if ( ( Rec != (rdsrec_list *)NULL ) &&
533 ( ! IsGraalDeleted( Rec ) ) &&
534 ( ! IsGraalCut( Rec ) ) &&
535 ( ! IsGraalAccepted( Rec ) ) &&
536 ( ! IsGraalSelected( Rec ) ) &&
537 ( ! IsGraalDruc( Rec ) ) &&
538 ( Rec->X >= LambdaX1 ) &&
539 ( Rec->Y >= LambdaY1 ) &&
540 ( ( Rec->X + Rec->DX ) <= LambdaX2 ) &&
541 ( ( Rec->Y + Rec->DY ) <= LambdaY2 ) )
542 {
543 if ( ( IsRdsFigRec( Rec ) ) ||
544 ( IsRdsInstance( Rec ) ) )
545 {
546 CheckRec = (rdsrec_list *)Rec->USER;
547
548 while ( Rec != CheckRec )
549 {
550 StaticLayer = RDS_STATIC_LAYER[ GetRdsLayer( CheckRec ) ];
551
552 if ( GRAAL_RDS_ACTIVE_LAYER_TABLE[ (int)StaticLayer ] != 1 )
553
554 break;
555
556 CheckRec = (rdsrec_list *)CheckRec->USER;
557 }
558
559 if ( Rec == CheckRec ) GraalAddSelect( Rec );
560 }
561 }
562 }
563 }
564 }
565
566 X = X + 1;
567 }
568
569 Y = Y + 1;
570 }
571 }
572
573 for ( Select = GraalHeadSelect;
574 Select != (graalselect *)NULL;
575 Select = Select->NEXT )
576 {
577 GraalUnselectRectangle( Select->RECTANGLE );
578 }
579 }
580
581 rdsend();
582 }
583
584 /*------------------------------------------------------------\
585 | |
586 | GraalEditSelectFence |
587 | |
588 \------------------------------------------------------------*/
589
GraalEditSelectFence(LambdaX1,LambdaY1,LambdaX2,LambdaY2)590 void GraalEditSelectFence( LambdaX1, LambdaY1, LambdaX2, LambdaY2 )
591
592 long LambdaX1;
593 long LambdaY1;
594 long LambdaX2;
595 long LambdaY2;
596 {
597 long Offset;
598 graalwin *ScanWin;
599 graalwinrec *ScanWinRec;
600 rdsrec_list *Rec;
601 rdsrec_list *CheckRec;
602 graalselect *Select;
603 char ScanRec;
604 char Layer;
605 char StaticLayer;
606 long Xmin;
607 long Ymin;
608 long Xmax;
609 long Ymax;
610 long X;
611 long Y;
612 long Swap;
613
614 rdsbegin();
615
616 if ( ( LambdaX1 != LambdaX2 ) &&
617 ( LambdaY1 != LambdaY2 ) )
618 {
619 if ( LambdaX1 > LambdaX2 )
620 {
621 Swap = LambdaX1; LambdaX1 = LambdaX2; LambdaX2 = Swap;
622 }
623
624 if ( LambdaY1 > LambdaY2 )
625 {
626 Swap = LambdaY1; LambdaY1 = LambdaY2; LambdaY2 = Swap;
627 }
628 }
629
630 if ( GraalFigureMbk != (phfig_list *)NULL )
631 {
632 LambdaX1 = LambdaX1 * GRAAL_RDS_LAMBDA;
633 LambdaX2 = LambdaX2 * GRAAL_RDS_LAMBDA;
634 LambdaY1 = LambdaY1 * GRAAL_RDS_LAMBDA;
635 LambdaY2 = LambdaY2 * GRAAL_RDS_LAMBDA;
636
637 Xmin = ( LambdaX1 - GraalWindowXmin ) / GraalWindowSide;
638 Xmax = ( LambdaX2 - GraalWindowXmin ) / GraalWindowSide;
639 Ymin = ( LambdaY1 - GraalWindowYmin ) / GraalWindowSide;
640 Ymax = ( LambdaY2 - GraalWindowYmin ) / GraalWindowSide;
641
642 if ( Xmin < 0 ) Xmin = 0;
643 if ( Xmin > GraalWindowDx ) Xmin = GraalWindowDx - 1;
644 if ( Ymin < 0 ) Ymin = 0;
645 if ( Ymin > GraalWindowDy ) Ymin = GraalWindowDy - 1;
646
647 if ( Xmax < 0 ) Xmax = 0;
648 if ( Xmax > GraalWindowDx ) Xmax = GraalWindowDx - 1;
649 if ( Ymax < 0 ) Ymax = 0;
650 if ( Ymax > GraalWindowDy ) Ymax = GraalWindowDy - 1;
651
652 for ( Layer = 0; Layer < RDS_MAX_LAYER; Layer++ )
653 {
654 StaticLayer = RDS_STATIC_LAYER[ (int)Layer ];
655
656 if ( GRAAL_RDS_ACTIVE_LAYER_TABLE[ (int)StaticLayer ] != 1 ) continue;
657
658 Y = Ymin;
659
660 while ( Y <= Ymax )
661 {
662 X = Xmin;
663
664 while ( X <= Xmax )
665 {
666 Offset = ( Y * GraalWindowDx ) + X;
667
668 ScanWin = &GraalWindowTable[ Offset ];
669
670 if ( ScanWin->LAYERTAB != (graalwinrec **)NULL )
671 {
672 for ( ScanWinRec = ScanWin->LAYERTAB[ (int)Layer ];
673 ScanWinRec != (graalwinrec *)NULL;
674 ScanWinRec = ScanWinRec->NEXT )
675 {
676 for ( ScanRec = 0; ScanRec < GRAAL_MAX_REC ; ScanRec++ )
677 {
678 Rec = ScanWinRec->RECTAB[ (int)ScanRec ];
679
680 if ( ( Rec != (rdsrec_list *)NULL ) &&
681 ( ! IsGraalDeleted( Rec ) ) &&
682 ( ! IsGraalCut( Rec ) ) &&
683 ( ! IsGraalAccepted( Rec ) ) &&
684 ( ! IsGraalSelected( Rec ) ) &&
685 ( ! IsGraalDruc( Rec ) ) &&
686 ( ( Rec->X + Rec->DX ) >= LambdaX1 ) &&
687 ( ( Rec->Y + Rec->DY ) >= LambdaY1 ) &&
688 ( ( Rec->X ) <= LambdaX2 ) &&
689 ( ( Rec->Y ) <= LambdaY2 ) )
690 {
691 if ( ( IsRdsFigRec( Rec ) ) ||
692 ( IsRdsInstance( Rec ) ) )
693 {
694 CheckRec = (rdsrec_list *)Rec->USER;
695
696 while ( Rec != CheckRec )
697 {
698 StaticLayer = RDS_STATIC_LAYER[ GetRdsLayer( CheckRec ) ];
699
700 if ( GRAAL_RDS_ACTIVE_LAYER_TABLE[ (int)StaticLayer ] != 1 )
701
702 break;
703
704 CheckRec = (rdsrec_list *)CheckRec->USER;
705 }
706
707 if ( Rec == CheckRec ) GraalAddSelect( Rec );
708 }
709 }
710 }
711 }
712 }
713
714 X = X + 1;
715 }
716
717 Y = Y + 1;
718 }
719 }
720
721 for ( Select = GraalHeadSelect;
722 Select != (graalselect *)NULL;
723 Select = Select->NEXT )
724 {
725 GraalUnselectRectangle( Select->RECTANGLE );
726 }
727 }
728
729 rdsend();
730 }
731
732
733 /*------------------------------------------------------------\
734 | |
735 | GraalEditSelectPointCopy |
736 | |
737 \------------------------------------------------------------*/
738
GraalEditSelectPointCopy(LambdaX1,LambdaY1)739 void GraalEditSelectPointCopy( LambdaX1, LambdaY1 )
740
741 long LambdaX1;
742 long LambdaY1;
743 {
744 graalselect *Select;
745 graalselect *DelSelect;
746 graalselect **Previous;
747
748 rdsbegin();
749
750 GraalEditSelectPoint( LambdaX1, LambdaY1 );
751
752 GraalDisplaySelectList( (char *)NULL );
753
754 Previous = &GraalHeadSelect;
755 Select = GraalHeadSelect;
756
757 while ( Select != (graalselect *)NULL )
758 {
759 if ( IsRdsFigure( Select->RECTANGLE ) ||
760 IsRdsInstance( Select->RECTANGLE ) )
761 {
762 DelSelect = Select;
763 Select = Select->NEXT;
764 *Previous = Select;
765
766 GraalFreeSelect( DelSelect );
767 }
768 else
769 {
770 GraalAddSelectList( Select->RECTANGLE );
771
772 Previous = &Select->NEXT;
773 Select = Select->NEXT;
774 }
775 }
776
777 if ( GraalHeadSelect == (graalselect *)NULL )
778 {
779 GraalWarningMessage( GraalMainWindow, "No element found !" );
780 }
781 else
782 {
783 if ( GraalHeadSelect->NEXT != (graalselect *)NULL )
784 {
785 GraalEnterPanel( &GraalEditSelectPanel );
786 GraalLimitedLoop( GraalEditSelectPanel.PANEL );
787 }
788 else
789 {
790 GraalAcceptRectangle( GraalHeadSelect->RECTANGLE );
791 GraalDisplayRectangle( GraalHeadSelect->RECTANGLE );
792 }
793
794 if ( GraalHeadSelect != (graalselect *)NULL )
795 {
796 GraalContinueEditMode( GRAAL_EDIT_COPY_POINT,
797 GraalPromptEditCopy, 1 );
798 }
799 else
800 {
801 GraalChangeEditMode( GRAAL_SELECT_POINT_COPY,
802 GraalPromptSelectPointCopy );
803 }
804 }
805
806 rdsend();
807 }
808
809 /*------------------------------------------------------------\
810 | |
811 | GraalEditSelectWindowCopy |
812 | |
813 \------------------------------------------------------------*/
814
GraalEditSelectWindowCopy(LambdaX1,LambdaY1,LambdaX2,LambdaY2)815 void GraalEditSelectWindowCopy( LambdaX1, LambdaY1, LambdaX2, LambdaY2 )
816
817 long LambdaX1;
818 long LambdaY1;
819 long LambdaX2;
820 long LambdaY2;
821 {
822 graalselect *Select;
823 graalselect *DelSelect;
824 graalselect **Previous;
825
826 rdsbegin();
827
828 GraalEditSelectWindow( LambdaX1, LambdaY1, LambdaX2, LambdaY2 );
829
830 Previous = &GraalHeadSelect;
831 Select = GraalHeadSelect;
832
833 while ( Select != (graalselect *)NULL )
834 {
835 if ( IsRdsFigure( Select->RECTANGLE ) ||
836 IsRdsInstance( Select->RECTANGLE ) )
837 {
838 DelSelect = Select;
839 Select = Select->NEXT;
840 *Previous = Select;
841
842 GraalFreeSelect( DelSelect );
843 }
844 else
845 {
846 GraalAcceptRectangle( Select->RECTANGLE );
847
848 Previous = &Select->NEXT;
849 Select = Select->NEXT;
850 }
851 }
852
853 if ( GraalHeadSelect == (graalselect *)NULL )
854 {
855 GraalWarningMessage( GraalMainWindow, "No element found !" );
856
857 GraalChangeEditMode( GRAAL_SELECT_WINDOW_COPY,
858 GraalPromptSelectWindowCopy );
859 }
860 else
861 {
862 if ( GraalHeadSelect->NEXT == (graalselect *)NULL )
863 {
864 GraalDisplayRectangle( GraalHeadSelect->RECTANGLE );
865 }
866 else
867 {
868 GraalZoomRefresh();
869 }
870
871 GraalContinueEditMode( GRAAL_EDIT_COPY_WINDOW,
872 GraalPromptEditCopy, 0 );
873 }
874
875 rdsend();
876 }
877
878 /*------------------------------------------------------------\
879 | |
880 | GraalEditSelectPointMove |
881 | |
882 \------------------------------------------------------------*/
883
GraalEditSelectPointMove(LambdaX1,LambdaY1)884 void GraalEditSelectPointMove( LambdaX1, LambdaY1 )
885
886 long LambdaX1;
887 long LambdaY1;
888 {
889 graalselect *Select;
890
891 rdsbegin();
892
893 GraalEditSelectPoint( LambdaX1, LambdaY1 );
894
895 GraalDisplaySelectList( (char *)NULL );
896
897 for ( Select = GraalHeadSelect;
898 Select != (graalselect *)NULL;
899 Select = Select->NEXT )
900 {
901 GraalAddSelectList( Select->RECTANGLE );
902 }
903
904 if ( GraalHeadSelect == (graalselect *)NULL )
905 {
906 GraalWarningMessage( GraalMainWindow, "No element found !" );
907 }
908 else
909 {
910 if ( GraalHeadSelect->NEXT != (graalselect *)NULL )
911 {
912 GraalEnterPanel( &GraalEditSelectPanel );
913 GraalLimitedLoop( GraalEditSelectPanel.PANEL );
914 }
915 else
916 {
917 GraalAcceptRectangle( GraalHeadSelect->RECTANGLE );
918 GraalDisplayRectangle( GraalHeadSelect->RECTANGLE );
919 }
920
921 if ( GraalHeadSelect != (graalselect *)NULL )
922 {
923 GraalContinueEditMode( GRAAL_EDIT_MOVE_POINT,
924 GraalPromptEditMove, 1 );
925 }
926 else
927 {
928 GraalChangeEditMode( GRAAL_SELECT_POINT_MOVE,
929 GraalPromptSelectPointMove );
930 }
931 }
932
933 rdsend();
934 }
935
936 /*------------------------------------------------------------\
937 | |
938 | GraalEditSelectWindowMove |
939 | |
940 \------------------------------------------------------------*/
941
GraalEditSelectWindowMove(LambdaX1,LambdaY1,LambdaX2,LambdaY2)942 void GraalEditSelectWindowMove( LambdaX1, LambdaY1, LambdaX2, LambdaY2 )
943
944 long LambdaX1;
945 long LambdaY1;
946 long LambdaX2;
947 long LambdaY2;
948 {
949 graalselect *Select;
950
951 rdsbegin();
952
953 GraalEditSelectWindow( LambdaX1, LambdaY1, LambdaX2, LambdaY2 );
954
955 for ( Select = GraalHeadSelect;
956 Select != (graalselect *)NULL;
957 Select = Select->NEXT )
958 {
959 GraalAcceptRectangle( Select->RECTANGLE );
960 }
961
962 if ( GraalHeadSelect == (graalselect *)NULL )
963 {
964 GraalWarningMessage( GraalMainWindow, "No element found !" );
965
966 GraalChangeEditMode( GRAAL_SELECT_WINDOW_MOVE,
967 GraalPromptSelectWindowMove );
968 }
969 else
970 {
971 if ( GraalHeadSelect->NEXT == (graalselect *)NULL )
972 {
973 GraalDisplayRectangle( GraalHeadSelect->RECTANGLE );
974 }
975 else
976 {
977 GraalZoomRefresh();
978 }
979
980 GraalContinueEditMode( GRAAL_EDIT_MOVE_WINDOW,
981 GraalPromptEditMove, 0 );
982 }
983
984 rdsend();
985 }
986
987 /*------------------------------------------------------------\
988 | |
989 | GraalEditSelectPointDelete |
990 | |
991 \------------------------------------------------------------*/
992
GraalEditSelectPointDelete(LambdaX1,LambdaY1)993 void GraalEditSelectPointDelete( LambdaX1, LambdaY1 )
994
995 long LambdaX1;
996 long LambdaY1;
997 {
998 graalselect *Select;
999
1000 rdsbegin();
1001
1002 GraalEditSelectPoint( LambdaX1, LambdaY1 );
1003
1004 GraalDisplaySelectList( (char *)NULL );
1005
1006 for ( Select = GraalHeadSelect;
1007 Select != (graalselect *)NULL;
1008 Select = Select->NEXT )
1009 {
1010 GraalAddSelectList( Select->RECTANGLE );
1011 }
1012
1013 if ( GraalHeadSelect == (graalselect *)NULL )
1014 {
1015 GraalWarningMessage( GraalMainWindow, "No element found !" );
1016 }
1017 else
1018 {
1019 if ( GraalHeadSelect->NEXT != (graalselect *)NULL )
1020 {
1021 GraalEnterPanel( &GraalEditSelectPanel );
1022 GraalLimitedLoop( GraalEditSelectPanel.PANEL );
1023 }
1024 else
1025 {
1026 GraalAcceptRectangle( GraalHeadSelect->RECTANGLE );
1027 GraalDisplayRectangle( GraalHeadSelect->RECTANGLE );
1028 }
1029
1030 if ( GraalHeadSelect != (graalselect *)NULL )
1031 {
1032 GraalEditDelete();
1033 }
1034 }
1035
1036 rdsend();
1037 }
1038
1039 /*------------------------------------------------------------\
1040 | |
1041 | GraalEditSelectWindowDelete |
1042 | |
1043 \------------------------------------------------------------*/
1044
GraalEditSelectWindowDelete(LambdaX1,LambdaY1,LambdaX2,LambdaY2)1045 void GraalEditSelectWindowDelete( LambdaX1, LambdaY1, LambdaX2, LambdaY2 )
1046
1047 long LambdaX1;
1048 long LambdaY1;
1049 long LambdaX2;
1050 long LambdaY2;
1051 {
1052 graalselect *Select;
1053
1054 rdsbegin();
1055
1056 GraalEditSelectWindow( LambdaX1, LambdaY1, LambdaX2, LambdaY2 );
1057
1058 for ( Select = GraalHeadSelect;
1059 Select != (graalselect *)NULL;
1060 Select = Select->NEXT )
1061 {
1062 GraalAcceptRectangle( Select->RECTANGLE );
1063 }
1064
1065 if ( GraalHeadSelect == (graalselect *)NULL )
1066 {
1067 GraalWarningMessage( GraalMainWindow, "No element found !" );
1068 }
1069 else
1070 {
1071 if ( GraalHeadSelect->NEXT == (graalselect *)NULL )
1072 {
1073 GraalDisplayRectangle( GraalHeadSelect->RECTANGLE );
1074 }
1075 else
1076 {
1077 GraalZoomRefresh();
1078 }
1079
1080 GraalEditDelete();
1081 }
1082
1083 rdsend();
1084 }
1085
1086 /*------------------------------------------------------------\
1087 | |
1088 | GraalEditSelectWindowStretch |
1089 | |
1090 \------------------------------------------------------------*/
1091
GraalEditSelectWindowStretch(LambdaX1,LambdaY1,LambdaX2,LambdaY2)1092 void GraalEditSelectWindowStretch( LambdaX1, LambdaY1, LambdaX2, LambdaY2 )
1093
1094 long LambdaX1;
1095 long LambdaY1;
1096 long LambdaX2;
1097 long LambdaY2;
1098 {
1099 graalselect *Select;
1100 graalselect *DelSelect;
1101 graalselect **Previous;
1102 void *Pointer;
1103
1104 rdsbegin();
1105
1106 GraalEditSelectWindow( LambdaX1, LambdaY1, LambdaX2, LambdaY2 );
1107
1108 Previous = &GraalHeadSelect;
1109 Select = GraalHeadSelect;
1110
1111 while ( Select != (graalselect *)NULL )
1112 {
1113 Pointer = GRAAL_MBK( Select->RECTANGLE );
1114
1115 if ( ( IsRdsSegment( Select->RECTANGLE ) ) ||
1116 ( IsRdsFigure( Select->RECTANGLE ) ) ||
1117 ( ( IsRdsVia( Select->RECTANGLE ) ) &&
1118 ( ( ((phvia_list *)Pointer)->DX != 0 ) ||
1119 ( ((phvia_list *)Pointer)->DY != 0 ) ) ) )
1120 {
1121 GraalAcceptRectangle( Select->RECTANGLE );
1122
1123 Previous = &Select->NEXT;
1124 Select = Select->NEXT;
1125 }
1126 else
1127 {
1128 DelSelect = Select;
1129 Select = Select->NEXT;
1130 *Previous = Select;
1131
1132 GraalFreeSelect( DelSelect );
1133 }
1134 }
1135
1136 if ( GraalHeadSelect == (graalselect *)NULL )
1137 {
1138 GraalWarningMessage( GraalMainWindow, "No element found !" );
1139
1140 GraalChangeEditMode( GRAAL_SELECT_WINDOW_STRETCH,
1141 GraalPromptSelectWindowStretch );
1142 }
1143 else
1144 {
1145 if ( GraalHeadSelect->NEXT == (graalselect *)NULL )
1146 {
1147 GraalDisplayRectangle( GraalHeadSelect->RECTANGLE );
1148 }
1149 else
1150 {
1151 GraalZoomRefresh();
1152 }
1153
1154 GraalContinueEditMode( GRAAL_EDIT_STRETCH_WINDOW,
1155 GraalPromptEditStretch, 0 );
1156 }
1157
1158 rdsend();
1159 }
1160
1161 /*------------------------------------------------------------\
1162 | |
1163 | GraalEditSelectPointStretch |
1164 | |
1165 \------------------------------------------------------------*/
1166
GraalEditSelectPointStretch(LambdaX1,LambdaY1)1167 void GraalEditSelectPointStretch( LambdaX1, LambdaY1 )
1168
1169 long LambdaX1;
1170 long LambdaY1;
1171 {
1172 graalselect *Select;
1173 graalselect *DelSelect;
1174 graalselect **Previous;
1175 void *Pointer;
1176
1177 rdsbegin();
1178
1179 GraalEditSelectPoint( LambdaX1, LambdaY1 );
1180
1181 GraalDisplaySelectList( (char *)NULL );
1182
1183 Previous = &GraalHeadSelect;
1184 Select = GraalHeadSelect;
1185
1186 while ( Select != (graalselect *)NULL )
1187 {
1188 Pointer = GRAAL_MBK( Select->RECTANGLE );
1189
1190 if ( ( IsRdsSegment( Select->RECTANGLE ) ) ||
1191 ( IsRdsFigure( Select->RECTANGLE ) ) ||
1192 ( ( IsRdsVia( Select->RECTANGLE ) ) &&
1193 ( ( ((phvia_list *)Pointer)->DX != 0 ) ||
1194 ( ((phvia_list *)Pointer)->DY != 0 ) ) ) )
1195 {
1196 GraalAddSelectList( Select->RECTANGLE );
1197
1198 Previous = &Select->NEXT;
1199 Select = Select->NEXT;
1200 }
1201 else
1202 {
1203 DelSelect = Select;
1204 Select = Select->NEXT;
1205 *Previous = Select;
1206
1207 GraalFreeSelect( DelSelect );
1208 }
1209 }
1210
1211 if ( GraalHeadSelect == (graalselect *)NULL )
1212 {
1213 GraalWarningMessage( GraalMainWindow, "No element found !" );
1214 }
1215 else
1216 {
1217 if ( GraalHeadSelect->NEXT != (graalselect *)NULL )
1218 {
1219 GraalEnterPanel( &GraalEditSelectPanel );
1220 GraalLimitedLoop( GraalEditSelectPanel.PANEL );
1221 }
1222 else
1223 {
1224 GraalAcceptRectangle( GraalHeadSelect->RECTANGLE );
1225 GraalDisplayRectangle( GraalHeadSelect->RECTANGLE );
1226 }
1227
1228 if ( GraalHeadSelect != (graalselect *)NULL )
1229 {
1230 GraalContinueEditMode( GRAAL_EDIT_STRETCH_POINT,
1231 GraalPromptEditStretch, 1 );
1232 }
1233 else
1234 {
1235 GraalChangeEditMode( GRAAL_SELECT_POINT_STRETCH,
1236 GraalPromptSelectPointStretch );
1237 }
1238 }
1239
1240 rdsend();
1241 }
1242
1243 /*------------------------------------------------------------\
1244 | |
1245 | GraalEditSelectPointModify |
1246 | |
1247 \------------------------------------------------------------*/
1248
GraalEditSelectPointModify(LambdaX1,LambdaY1)1249 void GraalEditSelectPointModify( LambdaX1, LambdaY1 )
1250
1251 long LambdaX1;
1252 long LambdaY1;
1253 {
1254 graalselect *Select;
1255 graalselect *DelSelect;
1256 graalselect **Previous;
1257
1258 rdsbegin();
1259
1260 GraalEditSelectPoint( LambdaX1, LambdaY1 );
1261
1262 GraalDisplaySelectList( (char *)NULL );
1263
1264 Previous = &GraalHeadSelect;
1265 Select = GraalHeadSelect;
1266
1267 while ( Select != (graalselect *)NULL )
1268 {
1269 if ( ! IsRdsFigure( Select->RECTANGLE ) )
1270 {
1271 GraalAddSelectList( Select->RECTANGLE );
1272
1273 Previous = &Select->NEXT;
1274 Select = Select->NEXT;
1275 }
1276 else
1277 {
1278 DelSelect = Select;
1279 Select = Select->NEXT;
1280 *Previous = Select;
1281
1282 GraalFreeSelect( DelSelect );
1283 }
1284 }
1285
1286 if ( GraalHeadSelect == (graalselect *)NULL )
1287 {
1288 GraalWarningMessage( GraalMainWindow, "No element found !" );
1289 }
1290 else
1291 {
1292 if ( GraalHeadSelect->NEXT != (graalselect *)NULL )
1293 {
1294 GraalEnterPanel( &GraalEditSelectPanel );
1295 GraalLimitedLoop( GraalEditSelectPanel.PANEL );
1296 }
1297
1298 if ( GraalHeadSelect != (graalselect *)NULL )
1299 {
1300 GraalEditModify();
1301 }
1302 }
1303
1304 rdsend();
1305 }
1306
1307 /*------------------------------------------------------------\
1308 | |
1309 | GraalEditSelectWindowModify |
1310 | |
1311 \------------------------------------------------------------*/
1312
GraalEditSelectWindowModify(LambdaX1,LambdaY1,LambdaX2,LambdaY2)1313 void GraalEditSelectWindowModify( LambdaX1, LambdaY1, LambdaX2, LambdaY2 )
1314
1315 long LambdaX1;
1316 long LambdaY1;
1317 long LambdaX2;
1318 long LambdaY2;
1319 {
1320 graalselect *Select;
1321 graalselect *DelSelect;
1322 graalselect **Previous;
1323
1324 rdsbegin();
1325
1326 GraalEditSelectWindow( LambdaX1, LambdaY1, LambdaX2, LambdaY2 );
1327
1328 Previous = &GraalHeadSelect;
1329 Select = GraalHeadSelect;
1330
1331 while ( Select != (graalselect *)NULL )
1332 {
1333 if ( ! IsRdsFigure( Select->RECTANGLE ) )
1334 {
1335 Previous = &Select->NEXT;
1336 Select = Select->NEXT;
1337 }
1338 else
1339 {
1340 DelSelect = Select;
1341 Select = Select->NEXT;
1342 *Previous = Select;
1343
1344 GraalFreeSelect( DelSelect );
1345 }
1346 }
1347
1348 if ( GraalHeadSelect == (graalselect *)NULL )
1349 {
1350 GraalWarningMessage( GraalMainWindow, "No element found !" );
1351 }
1352 else
1353 {
1354 GraalEditModify();
1355 }
1356
1357 rdsend();
1358 }
1359
1360 /*------------------------------------------------------------\
1361 | |
1362 | GraalToolsSelectEqui |
1363 | |
1364 \------------------------------------------------------------*/
1365
GraalToolsSelectEqui(LambdaX1,LambdaY1)1366 void GraalToolsSelectEqui( LambdaX1, LambdaY1 )
1367
1368 long LambdaX1;
1369 long LambdaY1;
1370 {
1371 graalselect *Select;
1372 graalselect *DelSelect;
1373 graalselect **Previous;
1374 void *Pointer;
1375 char Delete;
1376 char MbkLayer;
1377 char ViaType;
1378
1379 rdsbegin();
1380
1381 GraalEditSelectPoint( LambdaX1, LambdaY1 );
1382
1383 GraalDisplaySelectList( (char *)NULL );
1384
1385 Previous = &GraalHeadSelect;
1386 Select = GraalHeadSelect;
1387
1388 while ( Select != (graalselect *)NULL )
1389 {
1390 Delete = 0;
1391
1392 if ( IsRdsSegment( Select->RECTANGLE ) )
1393 {
1394 Pointer = GRAAL_MBK( Select->RECTANGLE );
1395
1396 MbkLayer = ((phseg_list *)Pointer)->LAYER;
1397
1398 if ( GET_LYNX_TRANSISTOR_TYPE( MbkLayer ) != RDS_LYNX_TRANSISTOR_EMPTY )
1399
1400 Delete = 1;
1401 }
1402 else
1403 if ( IsRdsVia( Select->RECTANGLE ) )
1404 {
1405 Pointer = GRAAL_MBK( Select->RECTANGLE );
1406 ViaType = ((phvia_list *)Pointer)->TYPE;
1407
1408 for ( MbkLayer = 0; MbkLayer < MBK_MAX_LAYER; MbkLayer++ )
1409 {
1410 if ( GET_LYNX_TRANSISTOR_CX( MbkLayer ) == ViaType )
1411 {
1412 Delete = 1; break;
1413 }
1414 }
1415 }
1416 else
1417 if ( ( IsRdsInstance( Select->RECTANGLE ) ) ||
1418 ( IsRdsFigure( Select->RECTANGLE ) ) )
1419
1420 Delete = 1;
1421
1422 if ( Delete )
1423 {
1424 DelSelect = Select;
1425 Select = Select->NEXT;
1426 *Previous = Select;
1427
1428 GraalFreeSelect( DelSelect );
1429 }
1430 else
1431 {
1432 GraalAddSelectList( Select->RECTANGLE );
1433
1434 Previous = &Select->NEXT;
1435 Select = Select->NEXT;
1436 }
1437 }
1438
1439 if ( GraalHeadSelect == (graalselect *)NULL )
1440 {
1441 GraalWarningMessage( GraalMainWindow, "No element found !" );
1442 }
1443 else
1444 {
1445 if ( GraalHeadSelect->NEXT != (graalselect *)NULL )
1446 {
1447 GraalEnterPanel( &GraalEditSelectPanel );
1448 GraalLimitedLoop( GraalEditSelectPanel.PANEL );
1449 }
1450 else
1451 {
1452 GraalAcceptRectangle( GraalHeadSelect->RECTANGLE );
1453 GraalDisplayRectangle( GraalHeadSelect->RECTANGLE );
1454 }
1455
1456 if ( GraalHeadSelect != (graalselect *)NULL )
1457 {
1458 GraalToolsEqui();
1459 }
1460 }
1461
1462 rdsend();
1463 }
1464
1465 /*------------------------------------------------------------\
1466 | |
1467 | GraalToolsSelectFlatten |
1468 | |
1469 \------------------------------------------------------------*/
1470
GraalToolsSelectFlatten(LambdaX1,LambdaY1,LambdaX2,LambdaY2)1471 void GraalToolsSelectFlatten( LambdaX1, LambdaY1, LambdaX2, LambdaY2 )
1472
1473 long LambdaX1;
1474 long LambdaY1;
1475 long LambdaX2;
1476 long LambdaY2;
1477 {
1478 graalselect *Select;
1479 graalselect *DelSelect;
1480 graalselect **Previous;
1481
1482 rdsbegin();
1483
1484 GraalEditSelectFence( LambdaX1, LambdaY1, LambdaX2, LambdaY2 );
1485
1486 Previous = &GraalHeadSelect;
1487 Select = GraalHeadSelect;
1488
1489 while ( Select != (graalselect *)NULL )
1490 {
1491 if ( ( ! IsRdsInstance( Select->RECTANGLE ) ) ||
1492 ( IsGraalFlatten( Select->RECTANGLE ) ) )
1493 {
1494 DelSelect = Select;
1495 Select = Select->NEXT;
1496 *Previous = Select;
1497
1498 GraalFreeSelect( DelSelect );
1499 }
1500 else
1501 {
1502 GraalAcceptRectangle( Select->RECTANGLE );
1503
1504 Previous = &Select->NEXT;
1505 Select = Select->NEXT;
1506 }
1507 }
1508
1509 if ( GraalHeadSelect == (graalselect *)NULL )
1510 {
1511 GraalWarningMessage( GraalMainWindow, "No instance found !" );
1512 }
1513 else
1514 {
1515 if ( GraalHeadSelect->NEXT == (graalselect *)NULL )
1516 {
1517 GraalDisplayRectangle( GraalHeadSelect->RECTANGLE );
1518 }
1519 else
1520 {
1521 GraalZoomRefresh();
1522 }
1523
1524 GraalToolsFlatten();
1525 }
1526
1527 rdsend();
1528 }
1529
1530 /*------------------------------------------------------------\
1531 | |
1532 | GraalToolsSelectUnflatten |
1533 | |
1534 \------------------------------------------------------------*/
1535
GraalToolsSelectUnflatten(LambdaX1,LambdaY1,LambdaX2,LambdaY2)1536 void GraalToolsSelectUnflatten( LambdaX1, LambdaY1, LambdaX2, LambdaY2 )
1537
1538 long LambdaX1;
1539 long LambdaY1;
1540 long LambdaX2;
1541 long LambdaY2;
1542 {
1543 graalselect *Select;
1544 graalselect *DelSelect;
1545 graalselect **Previous;
1546
1547 rdsbegin();
1548
1549 GraalEditSelectFence( LambdaX1, LambdaY1, LambdaX2, LambdaY2 );
1550
1551 Previous = &GraalHeadSelect;
1552 Select = GraalHeadSelect;
1553
1554 while ( Select != (graalselect *)NULL )
1555 {
1556 if ( ( ! IsRdsInstance( Select->RECTANGLE ) ) ||
1557 ( ! IsGraalFlatten( Select->RECTANGLE ) ) )
1558 {
1559 DelSelect = Select;
1560 Select = Select->NEXT;
1561 *Previous = Select;
1562
1563 GraalFreeSelect( DelSelect );
1564 }
1565 else
1566 {
1567 GraalAcceptRectangle( Select->RECTANGLE );
1568
1569 Previous = &Select->NEXT;
1570 Select = Select->NEXT;
1571 }
1572 }
1573
1574 if ( GraalHeadSelect == (graalselect *)NULL )
1575 {
1576 GraalWarningMessage( GraalMainWindow, "No instance found !" );
1577 }
1578 else
1579 {
1580 if ( GraalHeadSelect->NEXT == (graalselect *)NULL )
1581 {
1582 GraalDisplayRectangle( GraalHeadSelect->RECTANGLE );
1583 }
1584 else
1585 {
1586 GraalZoomRefresh();
1587 }
1588
1589 GraalToolsUnflatten();
1590 }
1591
1592 rdsend();
1593 }
1594
1595 /*------------------------------------------------------------\
1596 | |
1597 | GraalToolsSelectRealFlatten |
1598 | |
1599 \------------------------------------------------------------*/
1600
GraalToolsSelectRealFlatten(LambdaX1,LambdaY1,LambdaX2,LambdaY2)1601 void GraalToolsSelectRealFlatten( LambdaX1, LambdaY1, LambdaX2, LambdaY2 )
1602
1603 long LambdaX1;
1604 long LambdaY1;
1605 long LambdaX2;
1606 long LambdaY2;
1607 {
1608 graalselect *Select;
1609 graalselect *DelSelect;
1610 graalselect **Previous;
1611
1612 rdsbegin();
1613
1614 GraalEditSelectFence( LambdaX1, LambdaY1, LambdaX2, LambdaY2 );
1615
1616 Previous = &GraalHeadSelect;
1617 Select = GraalHeadSelect;
1618
1619 while ( Select != (graalselect *)NULL )
1620 {
1621 if ( ( ! IsRdsInstance( Select->RECTANGLE ) ) ||
1622 ( IsGraalFlatten( Select->RECTANGLE ) ) )
1623 {
1624 DelSelect = Select;
1625 Select = Select->NEXT;
1626 *Previous = Select;
1627
1628 GraalFreeSelect( DelSelect );
1629 }
1630 else
1631 {
1632 GraalAcceptRectangle( Select->RECTANGLE );
1633
1634 Previous = &Select->NEXT;
1635 Select = Select->NEXT;
1636 }
1637 }
1638
1639 if ( GraalHeadSelect == (graalselect *)NULL )
1640 {
1641 GraalWarningMessage( GraalMainWindow, "No instance found !" );
1642 }
1643 else
1644 {
1645 if ( GraalHeadSelect->NEXT == (graalselect *)NULL )
1646 {
1647 GraalDisplayRectangle( GraalHeadSelect->RECTANGLE );
1648 }
1649 else
1650 {
1651 GraalZoomRefresh();
1652 }
1653
1654 GraalToolsRealFlatten();
1655 }
1656
1657 rdsend();
1658 }
1659
1660 /*------------------------------------------------------------\
1661 | |
1662 | GraalToolsSelectHierarchyDown |
1663 | |
1664 \------------------------------------------------------------*/
1665
GraalToolsSelectHierarchyDown(LambdaX1,LambdaY1)1666 void GraalToolsSelectHierarchyDown( LambdaX1, LambdaY1 )
1667
1668 long LambdaX1;
1669 long LambdaY1;
1670 {
1671 graalselect *Select;
1672 graalselect *DelSelect;
1673 graalselect **Previous;
1674
1675 rdsbegin();
1676
1677 GraalEditSelectPoint( LambdaX1, LambdaY1 );
1678
1679 GraalDisplaySelectList( (char *)NULL );
1680
1681 Previous = &GraalHeadSelect;
1682 Select = GraalHeadSelect;
1683
1684 while ( Select != (graalselect *)NULL )
1685 {
1686 if ( ! IsRdsInstance( Select->RECTANGLE ) )
1687 {
1688 DelSelect = Select;
1689 Select = Select->NEXT;
1690 *Previous = Select;
1691
1692 GraalFreeSelect( DelSelect );
1693 }
1694 else
1695 {
1696 GraalAddSelectList( Select->RECTANGLE );
1697
1698 Previous = &Select->NEXT;
1699 Select = Select->NEXT;
1700 }
1701 }
1702
1703 if ( GraalHeadSelect == (graalselect *)NULL )
1704 {
1705 GraalWarningMessage( GraalMainWindow, "No instance found !" );
1706 }
1707 else
1708 {
1709 if ( GraalHeadSelect->NEXT != (graalselect *)NULL )
1710 {
1711 GraalEnterPanel( &GraalEditSelectPanel );
1712 GraalLimitedLoop( GraalEditSelectPanel.PANEL );
1713 }
1714 else
1715 {
1716 GraalAcceptRectangle( GraalHeadSelect->RECTANGLE );
1717 GraalDisplayRectangle( GraalHeadSelect->RECTANGLE );
1718 }
1719
1720 if ( GraalHeadSelect != (graalselect *)NULL )
1721 {
1722 GraalToolsHierarchyDown();
1723 }
1724 }
1725
1726 rdsend();
1727 }
1728