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