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    :                   Edit.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 "GMV.h"
63 # include "GMT.h"
64 
65 # include "GME_edit.h"
66 # include "GME_panel.h"
67 # include "GME_message.h"
68 
69 /*------------------------------------------------------------\
70 |                                                             |
71 |                           Constants                         |
72 |                                                             |
73 \------------------------------------------------------------*/
74 /*------------------------------------------------------------\
75 |                                                             |
76 |                            Types                            |
77 |                                                             |
78 \------------------------------------------------------------*/
79 /*------------------------------------------------------------\
80 |                                                             |
81 |                          Variables                          |
82 |                                                             |
83 \------------------------------------------------------------*/
84 /*------------------------------------------------------------\
85 |                                                             |
86 |                        Identify Buffer                      |
87 |                                                             |
88 \------------------------------------------------------------*/
89 
90   static char  GraalIdentifyMessage[ GRAAL_IDENTIFY_MESSAGE_SIZE ];
91   static char  GraalIdentifyBuffer [ GRAAL_IDENTIFY_BUFFER_SIZE  ];
92   static char *GraalScanIdentify;
93   static long  GraalIdentifyLength;
94 
95 /*------------------------------------------------------------\
96 |                                                             |
97 |                          Functions                          |
98 |                                                             |
99 \------------------------------------------------------------*/
100 /*------------------------------------------------------------\
101 |                                                             |
102 |                      GraalEditTreatUndo                     |
103 |                                                             |
104 \------------------------------------------------------------*/
105 
GraalEditTreatUndo(HeadUndo)106 void GraalEditTreatUndo( HeadUndo )
107 
108   graalundo *HeadUndo;
109 {
110   rdsrec_list  *Rec;
111   graalundorec *UndoRec;
112   char          OneElement;
113 
114   if ( ( HeadUndo->UNDO->NEXT != (graalundorec *)NULL ) ||
115        ( GraalHeadEqui        != (rdsrec_list  *)NULL ) ||
116        ( GraalHeadPeek        != (graalpeek    *)NULL ) )
117   {
118     OneElement = GRAAL_FALSE;
119   }
120   else
121   {
122     OneElement = (GraalHeadSelect == (graalselect *)NULL);
123   }
124 
125   GraalDelSelect();
126   GraalDelEqui();
127   GraalDelPeek();
128   GraalRecomputeBound = GRAAL_TRUE;
129 
130   for ( UndoRec  = HeadUndo->UNDO;
131         UndoRec != (graalundorec *)NULL;
132         UndoRec  = UndoRec->NEXT )
133   {
134     Rec = UndoRec->RECTANGLE;
135 
136     if ( GetRdsLayer( Rec ) != RDS_ABOX )
137     {
138       if ( IsGraalDeleted( Rec ) )
139       {
140         GraalUndeleteRectangle( Rec );
141         if ( OneElement ) GraalDisplayRectangle( Rec );
142       }
143       else
144       {
145         GraalDeleteRectangle( Rec );
146         if ( OneElement ) GraalDisplayRectangle( Rec );
147       }
148     }
149     else
150     {
151       if ( IsRdsFigure( Rec ) )
152       {
153         if ( IsGraalDeleted( Rec ) )
154         {
155           ClearGraalDeleted( Rec );
156 
157           GraalFigureMbk->XAB1 = (long)( Rec->X * GRAAL_SCALE_X / GRAAL_RDS_LAMBDA );
158           GraalFigureMbk->YAB1 = (long)( Rec->Y * GRAAL_SCALE_X / GRAAL_RDS_LAMBDA );
159           GraalFigureMbk->XAB2 = (long)( ( Rec->X + Rec->DX ) * GRAAL_SCALE_X / GRAAL_RDS_LAMBDA );
160           GraalFigureMbk->YAB2 = (long)( ( Rec->Y + Rec->DY ) * GRAAL_SCALE_X / GRAAL_RDS_LAMBDA );
161         }
162         else
163         {
164           GraalFigureMbk->XAB1 = 0;
165           GraalFigureMbk->XAB2 = 0;
166           GraalFigureMbk->YAB1 = 0;
167           GraalFigureMbk->YAB2 = 0;
168 
169           GraalDeleteRectangle( Rec );
170         }
171       }
172       else
173       {
174         if ( IsGraalDeleted( Rec ) )
175         {
176           ClearGraalDeleted( Rec );
177         }
178         else
179         {
180           GraalDeleteRectangle( Rec );
181         }
182       }
183 
184       OneElement = GRAAL_FALSE;
185     }
186   }
187 
188   HeadUndo->UNDO = (graalundorec *)reverse( (chain_list *)HeadUndo->UNDO );
189 
190   if ( ! OneElement )
191   {
192     GraalZoomRefresh();
193   }
194 }
195 
196 /*------------------------------------------------------------\
197 |                                                             |
198 |                      GraalEditRedo                          |
199 |                                                             |
200 \------------------------------------------------------------*/
201 
GraalEditRedo()202 void GraalEditRedo()
203 
204 {
205   graalundo *NewUndo;
206 
207   rdsbegin();
208 
209   if ( GraalHeadRedo != (graalundo *)NULL )
210   {
211     GraalEditTreatUndo( GraalHeadRedo );
212 
213     NewUndo       = GraalHeadRedo;
214     GraalHeadRedo = GraalHeadRedo->NEXT;
215     NewUndo->NEXT = GraalHeadUndo;
216     GraalHeadUndo = NewUndo;
217   }
218   else
219   {
220     GraalWarningMessage( GraalMainWindow, "Nothing to Redo !" );
221   }
222 
223   rdsend();
224 }
225 
226 /*------------------------------------------------------------\
227 |                                                             |
228 |                      GraalEditUndo                          |
229 |                                                             |
230 \------------------------------------------------------------*/
231 
GraalEditUndo()232 void GraalEditUndo()
233 
234 {
235   graalundo *NewRedo;
236 
237   rdsbegin();
238 
239   if ( GraalHeadUndo != (graalundo *)NULL )
240   {
241     GraalEditTreatUndo( GraalHeadUndo );
242 
243     NewRedo       = GraalHeadUndo;
244     GraalHeadUndo = GraalHeadUndo->NEXT;
245     NewRedo->NEXT = GraalHeadRedo;
246     GraalHeadRedo = NewRedo;
247   }
248   else
249   {
250     GraalWarningMessage( GraalMainWindow, "Nothing to undo !" );
251   }
252 
253   rdsend();
254 }
255 
256 /*------------------------------------------------------------\
257 |                                                             |
258 |                         GraalAddIdentify                    |
259 |                                                             |
260 \------------------------------------------------------------*/
261 
GraalAddIdentify(Rectangle)262 char GraalAddIdentify( Rectangle )
263 
264   rdsrec_list *Rectangle;
265 {
266   void *Pointer;
267   char  Orient;
268   char  MbkLayer;
269   long  Length;
270 
271   rdsbegin();
272 
273   GraalIdentifyBuffer[0] = '\0';
274   Pointer = GRAAL_MBK( Rectangle );
275 
276   if ( IsRdsSegment( Rectangle ) )
277   {
278     MbkLayer = ((phseg_list *)Pointer)->LAYER;
279 
280     if ( GET_LYNX_TRANSISTOR_TYPE( MbkLayer ) != RDS_LYNX_TRANSISTOR_EMPTY )
281     {
282       sprintf( GraalIdentifyBuffer,
283       "TRANSISTOR :\n\n  NAME : %s\n  TYPE : %s\n  X1 : %.2f\n  Y1 : %.2f\n  X2 : %.2f  \n  Y2 : %.2f\n  WIDTH : %.2f\n\n",
284       (((phseg_list *)Pointer)->NAME != (char *)0) ? ((phseg_list *)Pointer)->NAME : "None",
285       GRAAL_TRANSISTOR_NAME_TABLE[ (int)((phseg_list *)Pointer)->LAYER ][0],
286       (float)((phseg_list *)Pointer)->X1    / (float)SCALE_X,
287       (float)((phseg_list *)Pointer)->Y1    / (float)SCALE_X,
288       (float)((phseg_list *)Pointer)->X2    / (float)SCALE_X,
289       (float)((phseg_list *)Pointer)->Y2    / (float)SCALE_X,
290       (float)((phseg_list *)Pointer)->WIDTH / (float)SCALE_X );
291     }
292     else
293     {
294       sprintf( GraalIdentifyBuffer,
295       "SEGMENT :\n\n  NAME : %s\n  LAYER : %s\n  X1 : %.2f\n  Y1 : %.2f\n  X2 : %.2f\n  Y2 : %.2f\n  WIDTH : %.2f\n\n",
296       (((phseg_list *)Pointer)->NAME != (char *)0) ? ((phseg_list *)Pointer)->NAME : "None",
297       GRAAL_SEGMENT_NAME_TABLE[ (int)((phseg_list *)Pointer)->LAYER ][0],
298       (float)((phseg_list *)Pointer)->X1    / (float)SCALE_X,
299       (float)((phseg_list *)Pointer)->Y1    / (float)SCALE_X,
300       (float)((phseg_list *)Pointer)->X2    / (float)SCALE_X,
301       (float)((phseg_list *)Pointer)->Y2    / (float)SCALE_X,
302       (float)((phseg_list *)Pointer)->WIDTH / (float)SCALE_X );
303     }
304   }
305   else
306   if ( IsRdsConnector( Rectangle ) )
307   {
308     switch( ((phcon_list *)Pointer)->ORIENT )
309     {
310       case NORTH : Orient = GRAAL_NORTH;
311       break;
312       case SOUTH : Orient = GRAAL_SOUTH;
313       break;
314       case EAST  : Orient = GRAAL_EAST;
315       break;
316       default    : Orient = GRAAL_WEST;
317     }
318 
319     sprintf( GraalIdentifyBuffer,
320     "CONNECTOR :\n\n  NAME : %s\n  LAYER : %s\n  XCON : %.2f\n  YCON : %.2f\n  WIDTH : %.2f\n  ORIENT : %s\n  INDEX : %ld\n\n",
321     (((phcon_list *)Pointer)->NAME != (char *)0) ? ((phcon_list *)Pointer)->NAME : "None",
322     GRAAL_CONNECTOR_NAME_TABLE[ (int)((phcon_list *)Pointer)->LAYER ][0],
323     (float)((phcon_list *)Pointer)->XCON  / (float)SCALE_X,
324     (float)((phcon_list *)Pointer)->YCON  / (float)SCALE_X,
325     (float)((phcon_list *)Pointer)->WIDTH / (float)SCALE_X,
326     GRAAL_ORIENT_NAME_TABLE[ (int)Orient ][0],
327     ((phcon_list *)Pointer)->INDEX );
328   }
329   else
330   if ( IsRdsVia( Rectangle ) )
331   {
332     if ( ( ((phvia_list *)Pointer)->DX == 0 ) &&
333          ( ((phvia_list *)Pointer)->DY == 0 ) )
334     {
335       sprintf( GraalIdentifyBuffer,
336       "VIA :\n\n  NAME : %s\n  TYPE: %s\n  XVIA : %.2f\n  YVIA : %.2f\n\n",
337       (((phvia_list *)Pointer)->NAME != (char *)0) ? ((phvia_list *)Pointer)->NAME : "None",
338       GRAAL_VIA_NAME_TABLE[ (int)((phvia_list *)Pointer)->TYPE ][0],
339       (float)((phvia_list *)Pointer)->XVIA  / (float)SCALE_X,
340       (float)((phvia_list *)Pointer)->YVIA  / (float)SCALE_X );
341     }
342     else
343     {
344       sprintf( GraalIdentifyBuffer,
345       "BIGVIA :\n\n  NAME: %s\n  TYPE: %s\n  XVIA : %.2f\n  YVIA : %.2f\n  DX   : %.2f\n  DY  : %.2f\n\n",
346       (((phvia_list *)Pointer)->NAME != (char *)0) ? ((phvia_list *)Pointer)->NAME : "None",
347       GRAAL_BIGVIA_NAME_TABLE[ (int)((phvia_list *)Pointer)->TYPE ][0],
348       (float)((phvia_list *)Pointer)->XVIA / (float)SCALE_X,
349       (float)((phvia_list *)Pointer)->YVIA / (float)SCALE_X,
350       (float)((phvia_list *)Pointer)->DX   / (float)SCALE_X,
351       (float)((phvia_list *)Pointer)->DY   / (float)SCALE_X );
352     }
353   }
354   else
355   if ( IsRdsReference( Rectangle ) )
356   {
357     sprintf( GraalIdentifyBuffer,
358     "REFERENCE :\n\n  NAME : %s\n  TYPE : %s\n  XREF : %.2f\n  YREF : %.2f\n\n",
359     (((phref_list *)Pointer)->NAME != (char *)0) ? ((phref_list *)Pointer)->NAME : "None",
360     ( ! strcmp( ((phref_list *)Pointer)->FIGNAME, "ref_ref" ) ) ? "Ref_Ref" : "Ref_Con",
361     (float)((phref_list *)Pointer)->XREF  / (float)SCALE_X,
362     (float)((phref_list *)Pointer)->YREF  / (float)SCALE_X );
363   }
364   else
365   if ( IsRdsInstance( Rectangle ) )
366   {
367     Orient = ((phins_list *)Pointer)->TRANSF;
368 
369     sprintf( GraalIdentifyBuffer,
370     "INSTANCE :\n\n  NAME : %s\n  MODEL : %s\n  TRANSF : %s\n  XINS : %.2f\n  YINS : %.2f\n\n",
371     ((phins_list *)Pointer)->INSNAME,
372     ((phins_list *)Pointer)->FIGNAME,
373     GRAAL_SYMMETRY_NAME_TABLE[ (int)Orient ][0],
374     (float)((phins_list *)Pointer)->XINS  / (float)SCALE_X,
375     (float)((phins_list *)Pointer)->YINS  / (float)SCALE_X );
376   }
377   if ( IsRdsFigure( Rectangle ) )
378   {
379     sprintf( GraalIdentifyBuffer,
380     "ABUTMENT BOX :\n\n  NAME : %s\n  XAB1 : %.2f\n  YAB1 : %.2f\n  XAB2 : %.2f\n  YAB2 : %.2f\n\n",
381     ((phfig_list *)Pointer)->NAME,
382     (float)((phfig_list *)Pointer)->XAB1  / (float)SCALE_X,
383     (float)((phfig_list *)Pointer)->YAB1  / (float)SCALE_X,
384     (float)((phfig_list *)Pointer)->XAB2  / (float)SCALE_X,
385     (float)((phfig_list *)Pointer)->YAB2  / (float)SCALE_X );
386   }
387 
388   Length = strlen( GraalIdentifyBuffer );
389 
390   if ( ( GraalIdentifyLength + Length ) < ( GRAAL_IDENTIFY_MESSAGE_SIZE - 1 ) )
391   {
392     strcpy( GraalScanIdentify, GraalIdentifyBuffer );
393 
394     GraalScanIdentify   += Length;
395     GraalIdentifyLength += Length;
396 
397     rdsend();
398     return( GRAAL_TRUE );
399   }
400 
401   strcpy( GraalScanIdentify, "#" );
402 
403   rdsend();
404   return( GRAAL_FALSE );
405 }
406 
407 /*------------------------------------------------------------\
408 |                                                             |
409 |                     GraalEditIdentify                       |
410 |                                                             |
411 \------------------------------------------------------------*/
412 
GraalEditIdentify()413 void GraalEditIdentify()
414 {
415   graalselect *Select;
416 
417   rdsbegin();
418 
419   strcpy( GraalIdentifyMessage, "No element found !" );
420   GraalScanIdentify   = GraalIdentifyMessage;
421   GraalIdentifyLength = 0;
422 
423   for ( Select  = GraalHeadSelect;
424         Select != (graalselect *)NULL;
425         Select  = Select->NEXT )
426   {
427     if ( ! GraalAddIdentify( Select->RECTANGLE ) ) break;
428   }
429 
430   GraalDelSelect();
431 
432   GraalDisplayIdentifyMessage( GraalIdentifyMessage );
433   GraalEnterPanel( &GraalEditIdentifyPanel       );
434 
435   rdsend();
436 }
437 
438 /*------------------------------------------------------------\
439 |                                                             |
440 |                        GraalEditCopy                        |
441 |                                                             |
442 \------------------------------------------------------------*/
443 
GraalEditCopy(LambdaX1,LambdaY1,LambdaX2,LambdaY2,Mode)444 void GraalEditCopy( LambdaX1, LambdaY1, LambdaX2, LambdaY2, Mode )
445 
446    long LambdaX1;
447    long LambdaY1;
448    long LambdaX2;
449    long LambdaY2;
450    char Mode;
451 {
452   graalselect *Select;
453   rdsrec_list *Rectangle;
454   rdsrec_list *NewRec;
455   void        *Element;
456   void        *Pointer;
457   char         FirstUndo;
458   long         DeltaX;
459   long         DeltaY;
460   long         X1;
461   long         X2;
462   long         Y1;
463   long         Y2;
464 
465   rdsbegin();
466 
467   DeltaX = (long)( ( LambdaX2 - LambdaX1 ) * GRAAL_SCALE_X );
468   DeltaY = (long)( ( LambdaY2 - LambdaY1 ) * GRAAL_SCALE_X );
469 
470   FirstUndo = 1;
471 
472   for ( Select  = GraalHeadSelect;
473         Select != (graalselect *)NULL;
474         Select  = Select->NEXT )
475   {
476     Rectangle = Select->RECTANGLE;
477 
478     if ( IsRdsSegment( Rectangle ) )
479     {
480       if ( FirstUndo )
481       {
482         GraalAddUndo();
483 
484         FirstUndo = 0;
485       }
486 
487       Pointer = GRAAL_MBK( Rectangle );
488 
489       X1 = ((phseg_list *)Pointer)->X1 + DeltaX;
490       Y1 = ((phseg_list *)Pointer)->Y1 + DeltaY;
491       X2 = ((phseg_list *)Pointer)->X2 + DeltaX;
492       Y2 = ((phseg_list *)Pointer)->Y2 + DeltaY;
493 
494       Element = (void *)
495 
496          addphseg( GraalFigureMbk,
497                    ((phseg_list *)Pointer)->LAYER,
498                    ((phseg_list *)Pointer)->WIDTH,
499                    X1, Y1, X2, Y2,
500                    ((phseg_list *)Pointer)->NAME );
501 
502       ((phseg_list *)Element)->TYPE = ((phseg_list *)Pointer)->TYPE;
503       ((phseg_list *)Element)->USER = (void *)(&GraalFigureMbk->PHSEG);
504 
505       if ( ((phseg_list *)Element)->NEXT != (phseg_list *)NULL )
506       {
507         ((phseg_list *)Element)->NEXT->USER = (void *)(&((phseg_list *)Element)->NEXT);
508       }
509 
510       NewRec = GraalAddSegment( ((phseg_list *)Element) );
511 
512       GraalAddUndoRec( NewRec );
513     }
514     else
515     if ( IsRdsVia( Rectangle ) )
516     {
517       if ( FirstUndo )
518       {
519         GraalAddUndo();
520 
521         FirstUndo = 0;
522       }
523 
524       Pointer = GRAAL_MBK( Rectangle );
525 
526       X1 = ((phvia_list *)Pointer)->XVIA + DeltaX;
527       Y1 = ((phvia_list *)Pointer)->YVIA + DeltaY;
528 
529       Element = (void *)
530 
531          addphvia( GraalFigureMbk,
532                    ((phvia_list *)Pointer)->TYPE, X1, Y1,
533                    ((phvia_list *)Pointer)->DX, ((phvia_list *)Pointer)->DY,
534                    ((phvia_list *)Pointer)->NAME );
535 
536       ((phvia_list *)Element)->USER = (void *)(&GraalFigureMbk->PHVIA);
537 
538       if ( ((phvia_list *)Element)->NEXT != (phvia_list *)NULL )
539       {
540         ((phvia_list *)Element)->NEXT->USER = (void *)(&((phvia_list *)Element)->NEXT);
541       }
542 
543       NewRec = GraalAddVia( ((phvia_list *)Element) );
544 
545       GraalAddUndoRec( NewRec );
546     }
547     else
548     if ( IsRdsReference( Rectangle ) )
549     {
550       if ( FirstUndo )
551       {
552         GraalAddUndo();
553 
554         FirstUndo = 0;
555       }
556 
557       Pointer = GRAAL_MBK( Rectangle );
558 
559       X1 = ((phref_list *)Pointer)->XREF + DeltaX;
560       Y1 = ((phref_list *)Pointer)->YREF + DeltaY;
561 
562       Element = (void *)
563 
564          addphref( GraalFigureMbk,
565                    ((phref_list *)Pointer)->FIGNAME,
566                    Rectangle->NAME, X1, Y1 );
567 
568       ((phref_list *)Element)->USER = (void *)(&GraalFigureMbk->PHREF);
569 
570       if ( ((phref_list *)Element)->NEXT != (phref_list *)NULL )
571       {
572         ((phref_list *)Element)->NEXT->USER = (void *)(&((phref_list *)Element)->NEXT);
573       }
574 
575       NewRec = GraalAddReference( ((phvia_list *)Element) );
576 
577       GraalAddUndoRec( NewRec );
578     }
579     else
580     if ( IsRdsConnector( Rectangle ) )
581     {
582       if ( FirstUndo )
583       {
584         GraalAddUndo();
585 
586         FirstUndo = 0;
587       }
588 
589       Pointer = GRAAL_MBK( Rectangle );
590 
591       X1 = ((phcon_list *)Pointer)->XCON + DeltaX;
592       Y1 = ((phcon_list *)Pointer)->YCON + DeltaY;
593 
594       Element = (void *)
595 
596         addphcon( GraalFigureMbk,
597                   ((phcon_list *)Pointer)->ORIENT,
598                   Rectangle->NAME,
599                   X1, Y1,
600                   ((phcon_list *)Pointer)->LAYER,
601                   ((phcon_list *)Pointer)->WIDTH );
602 
603       ((phcon_list *)Element)->USER = (void *)(&GraalFigureMbk->PHCON);
604 
605       if ( ((phcon_list *)Element)->NEXT != (phcon_list *)NULL )
606       {
607         ((phcon_list *)Element)->NEXT->USER = (void *)(&((phcon_list *)Element)->NEXT);
608       }
609 
610       NewRec = GraalAddConnector( ((phcon_list *)Element) );
611 
612       GraalAddUndoRec( NewRec );
613     }
614   }
615 
616   GraalDelEqui();
617   GraalDelPeek();
618   GraalDelSelect();
619   GraalZoomRefresh();
620 
621   if ( Mode == 0 )
622   {
623     GraalChangeEditMode( GRAAL_SELECT_POINT_COPY,
624                          GraalPromptSelectPointCopy );
625   }
626   else
627   {
628     GraalChangeEditMode( GRAAL_SELECT_WINDOW_COPY,
629                          GraalPromptSelectWindowCopy );
630   }
631 
632   rdsend();
633 }
634 
635 /*------------------------------------------------------------\
636 |                                                             |
637 |                        GraalEditMove                        |
638 |                                                             |
639 \------------------------------------------------------------*/
640 
GraalEditMove(LambdaX1,LambdaY1,LambdaX2,LambdaY2,Mode)641 void GraalEditMove( LambdaX1, LambdaY1, LambdaX2, LambdaY2, Mode )
642 
643    long LambdaX1;
644    long LambdaY1;
645    long LambdaX2;
646    long LambdaY2;
647    char Mode;
648 {
649   graalselect *Select;
650   rdsrec_list *Rectangle;
651   rdsrec_list *NewRec;
652   rdsins_list *Instance;
653   phins_list  *SaveInstance;
654   graalconrec *ConRec;
655   void        *Element;
656   void        *Pointer;
657   char         FirstUndo;
658   long         DeltaX;
659   long         DeltaY;
660   long         X1;
661   long         X2;
662   long         Y1;
663   long         Y2;
664 
665   rdsbegin();
666 
667   DeltaX = (long)( ( LambdaX2 - LambdaX1 ) * GRAAL_SCALE_X );
668   DeltaY = (long)( ( LambdaY2 - LambdaY1 ) * GRAAL_SCALE_X );
669 
670   FirstUndo = 1;
671 
672   for ( Select  = GraalHeadSelect;
673         Select != (graalselect *)NULL;
674         Select  = Select->NEXT )
675   {
676     if ( IsRdsFigure( Select->RECTANGLE ) )
677     {
678       FirstUndo = 0;
679 
680       GraalAddUndo();
681       GraalDeleteRectangle( Select->RECTANGLE );
682       GraalAddUndoRec( Select->RECTANGLE );
683 
684       GraalFigureMbk->XAB1 += DeltaX;
685       GraalFigureMbk->XAB2 += DeltaX;
686       GraalFigureMbk->YAB1 += DeltaY;
687       GraalFigureMbk->YAB2 += DeltaY;
688 
689       NewRec = GraalAddAbox();
690       GraalAddUndoRec( NewRec );
691 
692       for ( ConRec  = GraalHeadConRec;
693             ConRec != (graalconrec *)NULL;
694             ConRec  = ConRec->NEXT )
695       {
696         Rectangle = ConRec->RECTANGLE;
697 
698         if ( ! IsGraalDeleted( Rectangle ) )
699         {
700           Pointer = GRAAL_MBK( Rectangle );
701 
702           X1 = ((phcon_list *)Pointer)->XCON + DeltaX;
703           Y1 = ((phcon_list *)Pointer)->YCON + DeltaY;
704 
705           if ( ( X1 < GraalFigureMbk->XAB1 ) ||
706                ( X1 > GraalFigureMbk->XAB2 ) ||
707                ( Y1 < GraalFigureMbk->YAB1 ) ||
708                ( Y1 > GraalFigureMbk->YAB2 ) ) continue;
709 
710           if ( ( X1 != GraalFigureMbk->XAB1 ) &&
711                ( X1 != GraalFigureMbk->XAB2 ) &&
712                ( Y1 != GraalFigureMbk->YAB1 ) &&
713                ( Y1 != GraalFigureMbk->YAB2 ) ) continue;
714 
715           GraalDeleteRectangle( Rectangle );
716           GraalRejectRectangle( Rectangle );
717           GraalAddUndoRec( Rectangle );
718 
719           Element = (void *)
720 
721             addphcon( GraalFigureMbk,
722                       ((phcon_list *)Pointer)->ORIENT,
723                       Rectangle->NAME,
724                       X1, Y1,
725                       ((phcon_list *)Pointer)->LAYER,
726                       ((phcon_list *)Pointer)->WIDTH );
727 
728           ((phcon_list *)Element)->USER = (void *)(&GraalFigureMbk->PHCON);
729 
730           if ( ((phcon_list *)Element)->NEXT != (phcon_list *)NULL )
731           {
732             ((phcon_list *)Element)->NEXT->USER = (void *)(&((phcon_list *)Element)->NEXT);
733           }
734 
735           NewRec = GraalAddConnector( ((phcon_list *)Element) );
736           GraalAddUndoRec( NewRec );
737         }
738       }
739 
740       break;
741     }
742   }
743 
744   for ( Select  = GraalHeadSelect;
745         Select != (graalselect *)NULL;
746         Select  = Select->NEXT )
747   {
748     Rectangle = Select->RECTANGLE;
749 
750     if ( ! IsGraalAccepted( Rectangle ) ) continue;
751 
752     if ( IsRdsSegment( Rectangle ) )
753     {
754       if ( FirstUndo )
755       {
756         GraalAddUndo();
757 
758         FirstUndo = 0;
759       }
760 
761       GraalDeleteRectangle( Rectangle );
762       GraalAddUndoRec( Rectangle );
763 
764       Pointer = GRAAL_MBK( Rectangle );
765 
766       X1 = ((phseg_list *)Pointer)->X1 + DeltaX;
767       Y1 = ((phseg_list *)Pointer)->Y1 + DeltaY;
768       X2 = ((phseg_list *)Pointer)->X2 + DeltaX;
769       Y2 = ((phseg_list *)Pointer)->Y2 + DeltaY;
770 
771       Element = (void *)
772 
773          addphseg( GraalFigureMbk,
774                    ((phseg_list *)Pointer)->LAYER,
775                    ((phseg_list *)Pointer)->WIDTH,
776                    X1, Y1, X2, Y2,
777                    ((phseg_list *)Pointer)->NAME );
778 
779       ((phseg_list *)Element)->TYPE = ((phseg_list *)Pointer)->TYPE;
780       ((phseg_list *)Element)->USER = (void *)(&GraalFigureMbk->PHSEG);
781 
782       if ( ((phseg_list *)Element)->NEXT != (phseg_list *)NULL )
783       {
784         ((phseg_list *)Element)->NEXT->USER = (void *)(&((phseg_list *)Element)->NEXT);
785       }
786 
787       NewRec = GraalAddSegment( ((phseg_list *)Element) );
788       GraalAddUndoRec( NewRec );
789     }
790     else
791     if ( IsRdsVia( Rectangle ) )
792     {
793       if ( FirstUndo )
794       {
795         GraalAddUndo();
796 
797         FirstUndo = 0;
798       }
799 
800       GraalDeleteRectangle( Rectangle );
801       GraalAddUndoRec( Rectangle );
802 
803       Pointer = GRAAL_MBK( Rectangle );
804 
805       X1 = ((phvia_list *)Pointer)->XVIA + DeltaX;
806       Y1 = ((phvia_list *)Pointer)->YVIA + DeltaY;
807 
808       Element = (void *)
809 
810          addphvia( GraalFigureMbk,
811                    ((phvia_list *)Pointer)->TYPE, X1, Y1,
812                    ((phvia_list *)Pointer)->DX, ((phvia_list *)Pointer)->DY,
813                    ((phvia_list *)Pointer)->NAME );
814 
815       ((phvia_list *)Element)->USER = (void *)(&GraalFigureMbk->PHVIA);
816 
817       if ( ((phvia_list *)Element)->NEXT != (phvia_list *)NULL )
818       {
819         ((phvia_list *)Element)->NEXT->USER = (void *)(&((phvia_list *)Element)->NEXT);
820       }
821 
822       NewRec = GraalAddVia( ((phvia_list *)Element) );
823 
824       GraalAddUndoRec( NewRec );
825     }
826     else
827     if ( IsRdsReference( Rectangle ) )
828     {
829       if ( FirstUndo )
830       {
831         GraalAddUndo();
832 
833         FirstUndo = 0;
834       }
835 
836       GraalDeleteRectangle( Rectangle );
837       GraalAddUndoRec( Rectangle );
838 
839       Pointer = GRAAL_MBK( Rectangle );
840 
841       X1 = ((phref_list *)Pointer)->XREF + DeltaX;
842       Y1 = ((phref_list *)Pointer)->YREF + DeltaY;
843 
844       Element = (void *)
845 
846          addphref( GraalFigureMbk,
847                    ((phref_list *)Pointer)->FIGNAME,
848                    Rectangle->NAME, X1, Y1 );
849 
850       ((phref_list *)Element)->USER = (void *)(&GraalFigureMbk->PHREF);
851 
852       if ( ((phref_list *)Element)->NEXT != (phref_list *)NULL )
853       {
854         ((phref_list *)Element)->NEXT->USER = (void *)(&((phref_list *)Element)->NEXT);
855       }
856 
857       NewRec = GraalAddReference( ((phvia_list *)Element) );
858 
859       GraalAddUndoRec( NewRec );
860     }
861     else
862     if ( IsRdsConnector( Rectangle ) )
863     {
864       if ( FirstUndo )
865       {
866         GraalAddUndo();
867 
868         FirstUndo = 0;
869       }
870 
871       GraalDeleteRectangle( Rectangle );
872       GraalAddUndoRec( Rectangle );
873 
874       Pointer = GRAAL_MBK( Rectangle );
875 
876       X1 = ((phcon_list *)Pointer)->XCON + DeltaX;
877       Y1 = ((phcon_list *)Pointer)->YCON + DeltaY;
878 
879       Element = (void *)
880 
881         addphcon( GraalFigureMbk,
882                  ((phcon_list *)Pointer)->ORIENT,
883                   Rectangle->NAME,
884                   X1, Y1,
885                   ((phcon_list *)Pointer)->LAYER,
886                   ((phcon_list *)Pointer)->WIDTH );
887 
888       ((phcon_list *)Element)->USER = (void *)(&GraalFigureMbk->PHCON);
889 
890       if ( ((phcon_list *)Element)->NEXT != (phcon_list *)NULL )
891       {
892         ((phcon_list *)Element)->NEXT->USER = (void *)(&((phcon_list *)Element)->NEXT);
893       }
894 
895       NewRec = GraalAddConnector( ((phcon_list *)Element) );
896 
897       GraalAddUndoRec( NewRec );
898     }
899     else
900     if ( IsRdsInstance( Rectangle ) )
901     {
902       if ( FirstUndo )
903       {
904         GraalAddUndo();
905 
906         FirstUndo = 0;
907       }
908 
909       GraalDeleteRectangle( Rectangle );
910       GraalAddUndoRec( Rectangle );
911 
912       Pointer = GRAAL_MBK( Rectangle );
913 
914       X1 = ((phins_list *)Pointer)->XINS + DeltaX;
915       Y1 = ((phins_list *)Pointer)->YINS + DeltaY;
916 
917       SaveInstance          = GraalFigureMbk->PHINS;
918       GraalFigureMbk->PHINS = (phins_list *)NULL;
919 
920       Element = (void *)
921 
922          addphins( GraalFigureMbk,
923                    ((phins_list *)Pointer)->FIGNAME,
924                    ((phins_list *)Pointer)->INSNAME,
925                    ((phins_list *)Pointer)->TRANSF,
926                    X1, Y1 );
927 
928       ((phins_list *)Element)->NEXT = SaveInstance;
929       ((phins_list *)Element)->USER = (void *)(&GraalFigureMbk->PHINS);
930 
931       if ( SaveInstance != (phins_list *)NULL )
932       {
933         SaveInstance->USER = (void *)(&((phins_list *)Element)->NEXT);
934       }
935 
936       Instance = GraalAddInstance( ((phins_list *)Element) );
937 
938       GraalDisplayToolsMessage();
939 
940       if ( Instance == (rdsins_list *)NULL )
941       {
942         GraalErrorMessage( GraalMainWindow, "Unable to load instance model !" );
943       }
944       else
945       {
946         NewRec   = Instance->LAYERTAB[ RDS_ABOX ];
947 
948         GraalAddUndoRec( NewRec );
949       }
950     }
951   }
952 
953   GraalDelEqui();
954   GraalDelPeek();
955   GraalDelSelect();
956   GraalZoomRefresh();
957 
958   if ( Mode == 0 )
959   {
960     GraalChangeEditMode( GRAAL_SELECT_POINT_MOVE,
961                          GraalPromptSelectPointMove );
962   }
963   else
964   {
965     GraalChangeEditMode( GRAAL_SELECT_WINDOW_MOVE,
966                          GraalPromptSelectWindowMove );
967   }
968 
969   rdsend();
970 }
971 
972 /*------------------------------------------------------------\
973 |                                                             |
974 |                        GraalEditDelete                      |
975 |                                                             |
976 \------------------------------------------------------------*/
977 
GraalEditDelete()978 void GraalEditDelete()
979 {
980   graalselect *Select;
981   rdsrec_list *Rectangle;
982   char         FirstUndo;
983   graalconrec *ConRec;
984 
985   rdsbegin();
986 
987   FirstUndo = 1;
988 
989   for ( Select  = GraalHeadSelect;
990         Select != (graalselect *)NULL;
991         Select  = Select->NEXT )
992   {
993     if ( IsRdsFigure( Select->RECTANGLE ) )
994     {
995       FirstUndo = 0;
996 
997       GraalAddUndo();
998       GraalDeleteRectangle( Select->RECTANGLE );
999       GraalAddUndoRec( Select->RECTANGLE );
1000 
1001       GraalFigureMbk->XAB1 = 0;
1002       GraalFigureMbk->XAB2 = 0;
1003       GraalFigureMbk->YAB1 = 0;
1004       GraalFigureMbk->YAB2 = 0;
1005 
1006       for ( ConRec  = GraalHeadConRec;
1007             ConRec != (graalconrec *)NULL;
1008             ConRec  = ConRec->NEXT )
1009       {
1010         Rectangle = ConRec->RECTANGLE;
1011 
1012         if ( ! IsGraalDeleted( Rectangle ) )
1013         {
1014           GraalRejectRectangle( Rectangle );
1015           GraalDeleteRectangle( Rectangle );
1016           GraalAddUndoRec( Rectangle );
1017         }
1018       }
1019 
1020       break;
1021     }
1022   }
1023 
1024   for ( Select  = GraalHeadSelect;
1025         Select != (graalselect *)NULL;
1026         Select  = Select->NEXT )
1027   {
1028     Rectangle = Select->RECTANGLE;
1029 
1030     if ( ! IsGraalAccepted( Rectangle ) ) continue;
1031 
1032     if ( ( IsRdsSegment( Rectangle   ) ) ||
1033          ( IsRdsVia( Rectangle       ) ) ||
1034          ( IsRdsReference( Rectangle ) ) ||
1035          ( IsRdsConnector( Rectangle ) ) ||
1036          ( IsRdsInstance( Rectangle  ) ) )
1037     {
1038       if ( FirstUndo )
1039       {
1040         GraalAddUndo();
1041         FirstUndo = 0;
1042       }
1043 
1044       GraalDeleteRectangle( Rectangle );
1045       GraalAddUndoRec( Rectangle );
1046     }
1047   }
1048 
1049   GraalDelEqui();
1050   GraalDelPeek();
1051   GraalDelSelect();
1052   GraalZoomRefresh();
1053 
1054   rdsend();
1055 }
1056 
1057 /*------------------------------------------------------------\
1058 |                                                             |
1059 |                       GraalEditStretch                      |
1060 |                                                             |
1061 \------------------------------------------------------------*/
1062 
GraalEditStretch(LambdaX1,LambdaY1,LambdaX2,LambdaY2,Mode)1063 void GraalEditStretch( LambdaX1, LambdaY1, LambdaX2, LambdaY2, Mode )
1064 
1065   long LambdaX1;
1066   long LambdaY1;
1067   long LambdaX2;
1068   long LambdaY2;
1069   char Mode;
1070 {
1071   graalselect *Select;
1072   rdsrec_list *Rectangle;
1073   rdsrec_list *NewRec;
1074   graalconrec *ConRec;
1075   void        *Element;
1076   void        *Pointer;
1077   char         FirstUndo;
1078   char         Orient;
1079   char         Stretch;
1080   long         Delta;
1081   long         Delta1;
1082   long         Delta2;
1083   long         Length;
1084   long         X1;
1085   long         X2;
1086   long         Y1;
1087   long         Y2;
1088   long         Xab1;
1089   long         Xab2;
1090   long         Yab1;
1091   long         Yab2;
1092   long         Xvia;
1093   long         Yvia;
1094   long         DXvia;
1095   long         DYvia;
1096 
1097   rdsbegin();
1098 
1099   Orient = 0;
1100 
1101   LambdaX1 = (long)( LambdaX1 * GRAAL_SCALE_X );
1102   LambdaX2 = (long)( LambdaX2 * GRAAL_SCALE_X );
1103   LambdaY1 = (long)( LambdaY1 * GRAAL_SCALE_X );
1104   LambdaY2 = (long)( LambdaY2 * GRAAL_SCALE_X );
1105 
1106   if ( LambdaX2 != LambdaX1 )
1107   {
1108     Delta  = LambdaX2 - LambdaX1;
1109     Orient = ( Delta > 0 ) ? GRAAL_EAST : GRAAL_WEST;
1110   }
1111   else
1112   {
1113     Delta  = LambdaY2 - LambdaY1;
1114     Orient = ( Delta > 0 ) ? GRAAL_NORTH : GRAAL_SOUTH;
1115   }
1116 
1117   if ( Delta != 0 )
1118   {
1119     FirstUndo = 1;
1120 
1121     for ( Select  = GraalHeadSelect;
1122           Select != (graalselect *)NULL;
1123           Select  = Select->NEXT )
1124     {
1125       Rectangle = Select->RECTANGLE;
1126 
1127       if ( IsRdsFigure( Rectangle ) )
1128       {
1129         X1 = GraalFigureMbk->XAB1;
1130         X2 = GraalFigureMbk->XAB2;
1131         Y1 = GraalFigureMbk->YAB1;
1132         Y2 = GraalFigureMbk->YAB2;
1133 
1134         Stretch = 0;
1135 
1136         if ( ( Orient == GRAAL_EAST ) ||
1137              ( Orient == GRAAL_WEST ) )
1138         {
1139           Delta1 = X1 - LambdaX1;
1140           Delta2 = X2 - LambdaX1;
1141 
1142           if ( Delta1 < 0 ) Delta1 = -Delta1;
1143           if ( Delta2 < 0 ) Delta2 = -Delta2;
1144 
1145           if ( Delta1 < Delta2 ) X1 += Delta;
1146           else                   X2 += Delta;
1147 
1148           if ( X2 > X1 )
1149           {
1150             Stretch = 1;
1151           }
1152         }
1153         else
1154         {
1155           Delta1 = Y1 - LambdaY1;
1156           Delta2 = Y2 - LambdaY1;
1157 
1158           if ( Delta1 < 0 ) Delta1 = -Delta1;
1159           if ( Delta2 < 0 ) Delta2 = -Delta2;
1160 
1161           if ( Delta1 < Delta2 ) Y1 += Delta;
1162           else                   Y2 += Delta;
1163 
1164           if ( Y2 > Y1 )
1165           {
1166             Stretch = 1;
1167           }
1168         }
1169 
1170         if ( Stretch )
1171         {
1172           if ( FirstUndo )
1173           {
1174             GraalAddUndo();
1175 
1176             FirstUndo = 0;
1177           }
1178 
1179           GraalDeleteRectangle( Rectangle );
1180           GraalAddUndoRec( Rectangle );
1181 
1182 
1183           Xab1 = GraalFigureMbk->XAB1;
1184           Xab2 = GraalFigureMbk->XAB2;
1185           Yab1 = GraalFigureMbk->YAB1;
1186           Yab2 = GraalFigureMbk->YAB2;
1187 
1188           GraalFigureMbk->XAB1 = X1;
1189           GraalFigureMbk->YAB1 = Y1;
1190           GraalFigureMbk->XAB2 = X2;
1191           GraalFigureMbk->YAB2 = Y2;
1192 
1193           NewRec = GraalAddAbox();
1194           GraalAddUndoRec( NewRec );
1195 
1196           for ( ConRec  = GraalHeadConRec;
1197                 ConRec != (graalconrec *)NULL;
1198                 ConRec  = ConRec->NEXT )
1199           {
1200             Rectangle = ConRec->RECTANGLE;
1201 
1202             if ( ! IsGraalDeleted( Rectangle ) )
1203             {
1204               Stretch = 0;
1205               Pointer = GRAAL_MBK( Rectangle );
1206 
1207               X1 = ((phcon_list *)Pointer)->XCON;
1208               Y1 = ((phcon_list *)Pointer)->YCON;
1209 
1210               if ( ( X1 < Xab1 ) ||
1211                    ( X1 > Xab2 ) ||
1212                    ( Y1 < Yab1 ) ||
1213                    ( Y1 > Yab2 ) ) continue;
1214 
1215               if ( ( X1 != Xab1 ) &&
1216                    ( X1 != Xab2 ) &&
1217                    ( Y1 != Yab1 ) &&
1218                    ( Y1 != Yab2 ) ) continue;
1219 
1220               if ( ( X1 != GraalFigureMbk->XAB1 ) &&
1221                    ( X1 != GraalFigureMbk->XAB2 ) &&
1222                    ( Y1 != GraalFigureMbk->YAB1 ) &&
1223                    ( Y1 != GraalFigureMbk->YAB2 ) )
1224               {
1225                 switch ( Orient )
1226                 {
1227                   case GRAAL_SOUTH:
1228                   case GRAAL_NORTH: Y1 += Delta;
1229 
1230                   break;
1231 
1232                   case GRAAL_WEST:
1233                   case GRAAL_EAST:  X1 += Delta;
1234 
1235                   break;
1236                 }
1237 
1238                 Stretch = 1;
1239               }
1240 
1241               if ( X1 < GraalFigureMbk->XAB1 )
1242               {
1243                 X1 = GraalFigureMbk->XAB1; Stretch = 1;
1244               }
1245 
1246               if ( X1 > GraalFigureMbk->XAB2 )
1247               {
1248                 X1 = GraalFigureMbk->XAB2; Stretch = 1;
1249               }
1250 
1251               if ( Y1 < GraalFigureMbk->YAB1 )
1252               {
1253                 Y1 = GraalFigureMbk->YAB1; Stretch = 1;
1254               }
1255 
1256               if ( Y1 > GraalFigureMbk->YAB2 )
1257               {
1258                 Y1 = GraalFigureMbk->YAB2; Stretch = 1;
1259               }
1260 
1261               if ( Stretch )
1262               {
1263                 GraalDeleteRectangle( Rectangle );
1264                 GraalRejectRectangle( Rectangle );
1265                 GraalAddUndoRec( Rectangle );
1266 
1267                 Element = (void *)
1268 
1269                   addphcon( GraalFigureMbk,
1270                             ((phcon_list *)Pointer)->ORIENT,
1271                             Rectangle->NAME,
1272                             X1, Y1,
1273                             ((phcon_list *)Pointer)->LAYER,
1274                             ((phcon_list *)Pointer)->WIDTH );
1275 
1276                 ((phcon_list *)Element)->USER = (void *)(&GraalFigureMbk->PHCON);
1277 
1278                 if ( ((phcon_list *)Element)->NEXT != (phcon_list *)NULL )
1279                 {
1280                   ((phcon_list *)Element)->NEXT->USER =
1281 
1282                          (void *)(&((phcon_list *)Element)->NEXT);
1283                 }
1284 
1285                 NewRec = GraalAddConnector( ((phcon_list *)Element) );
1286                 GraalAddUndoRec( NewRec );
1287               }
1288             }
1289           }
1290         }
1291 
1292         break;
1293       }
1294     }
1295 
1296     for ( Select  = GraalHeadSelect;
1297           Select != (graalselect *)NULL;
1298           Select  = Select->NEXT )
1299     {
1300       Rectangle = Select->RECTANGLE;
1301 
1302       if ( IsRdsSegment( Rectangle ) )
1303       {
1304         Pointer = GRAAL_MBK( Rectangle );
1305 
1306         X1 = ((phseg_list *)Pointer)->X1;
1307         Y1 = ((phseg_list *)Pointer)->Y1;
1308         X2 = ((phseg_list *)Pointer)->X2;
1309         Y2 = ((phseg_list *)Pointer)->Y2;
1310 
1311         Length = (long)( GRAAL_SEGMENT_VALUE_TABLE[ (int)((phseg_list *)Pointer)->LAYER ][1] * SCALE_X );
1312 
1313         Stretch = 0;
1314 
1315         switch ( ((phseg_list *)Pointer)->TYPE )
1316         {
1317           case RIGHT :
1318           case LEFT  :
1319 
1320             if ( ( Orient == GRAAL_EAST ) ||
1321                  ( Orient == GRAAL_WEST ) )
1322             {
1323               Delta1 = X1 - LambdaX1;
1324               Delta2 = X2 - LambdaX1;
1325 
1326               if ( Delta1 < 0 ) Delta1 = -Delta1;
1327               if ( Delta2 < 0 ) Delta2 = -Delta2;
1328 
1329               if ( Delta1 < Delta2 ) X1 += Delta;
1330               else                   X2 += Delta;
1331 
1332               if ( ( X2 - X1 ) >= Length )
1333               {
1334                 Stretch = 1;
1335               }
1336             }
1337 
1338             break;
1339 
1340           case UP    :
1341           case DOWN  :
1342 
1343             if ( ( Orient == GRAAL_NORTH ) ||
1344                  ( Orient == GRAAL_SOUTH ) )
1345             {
1346               Delta1 = Y1 - LambdaY1;
1347               Delta2 = Y2 - LambdaY1;
1348 
1349               if ( Delta1 < 0 ) Delta1 = -Delta1;
1350               if ( Delta2 < 0 ) Delta2 = -Delta2;
1351 
1352               if ( Delta1 < Delta2 ) Y1 += Delta;
1353               else                   Y2 += Delta;
1354 
1355               if ( ( Y2 - Y1 ) >= Length )
1356               {
1357                 Stretch = 1;
1358               }
1359             }
1360 
1361             break;
1362         }
1363 
1364         if ( Stretch )
1365         {
1366           if ( FirstUndo )
1367           {
1368             GraalAddUndo();
1369 
1370             FirstUndo = 0;
1371           }
1372 
1373           GraalDeleteRectangle( Rectangle );
1374           GraalAddUndoRec( Rectangle );
1375 
1376           Element = (void *)
1377 
1378              addphseg( GraalFigureMbk,
1379                        ((phseg_list *)Pointer)->LAYER,
1380                        ((phseg_list *)Pointer)->WIDTH,
1381                        X1, Y1, X2, Y2,
1382                        ((phseg_list *)Pointer)->NAME );
1383 
1384           ((phseg_list *)Element)->TYPE = ((phseg_list *)Pointer)->TYPE;
1385           ((phseg_list *)Element)->USER = (void *)(&GraalFigureMbk->PHSEG);
1386 
1387           if ( ((phseg_list *)Element)->NEXT != (phseg_list *)NULL )
1388           {
1389             ((phseg_list *)Element)->NEXT->USER = (void *)(&((phseg_list *)Element)->NEXT);
1390           }
1391 
1392           NewRec = GraalAddSegment( ((phseg_list *)Element) );
1393           GraalAddUndoRec( NewRec );
1394         }
1395       }
1396       else
1397       if ( IsRdsVia( Rectangle ) )
1398       {
1399         Pointer = GRAAL_MBK( Rectangle );
1400 
1401         Xvia  = ((phvia_list *)Pointer)->XVIA;
1402         Yvia  = ((phvia_list *)Pointer)->YVIA;
1403         DXvia = ((phvia_list *)Pointer)->DX;
1404         DYvia = ((phvia_list *)Pointer)->DY;
1405 
1406         X1 = Xvia - (DXvia >> 1);
1407         Y1 = Yvia - (DYvia >> 1);
1408         X2 = X1 + DXvia;
1409         Y2 = Y1 + DYvia;
1410 
1411         Length = (long)( GRAAL_BIGVIA_VALUE_TABLE[ (int)((phvia_list *)Pointer)->TYPE ][0] * SCALE_X );
1412 
1413         Stretch = 0;
1414 
1415         if ( ( Orient == GRAAL_EAST ) ||
1416              ( Orient == GRAAL_WEST ) )
1417         {
1418           Delta1 = X1 - LambdaX1;
1419           Delta2 = X2 - LambdaX1;
1420 
1421           if ( Delta1 < 0 ) Delta1 = -Delta1;
1422           if ( Delta2 < 0 ) Delta2 = -Delta2;
1423 
1424           if ( Delta1 < Delta2 ) X1 += Delta;
1425           else                   X2 += Delta;
1426 
1427           if ( ( X2 - X1 ) >= Length )
1428           {
1429             Stretch = 1;
1430           }
1431         }
1432         else
1433         if ( ( Orient == GRAAL_NORTH ) ||
1434              ( Orient == GRAAL_SOUTH ) )
1435         {
1436           Delta1 = Y1 - LambdaY1;
1437           Delta2 = Y2 - LambdaY1;
1438 
1439           if ( Delta1 < 0 ) Delta1 = -Delta1;
1440           if ( Delta2 < 0 ) Delta2 = -Delta2;
1441 
1442           if ( Delta1 < Delta2 ) Y1 += Delta;
1443           else                   Y2 += Delta;
1444 
1445           if ( ( Y2 - Y1 ) >= Length )
1446           {
1447             Stretch = 1;
1448           }
1449         }
1450 
1451         if ( Stretch )
1452         {
1453           DXvia = X2 - X1;
1454           DYvia = Y2 - Y1;
1455           Xvia  = X1 + (DXvia >> 1);
1456           Yvia  = Y1 + (DYvia >> 1);
1457 
1458           if ( FirstUndo )
1459           {
1460             GraalAddUndo();
1461 
1462             FirstUndo = 0;
1463           }
1464 
1465           GraalDeleteRectangle( Rectangle );
1466           GraalAddUndoRec( Rectangle );
1467 
1468           Element = (void *)
1469 
1470              addphvia( GraalFigureMbk,
1471                       ((phvia_list *)Pointer)->TYPE, Xvia, Yvia, DXvia, DYvia,
1472                       ((phvia_list *)Pointer)->NAME );
1473 
1474           ((phvia_list *)Element)->USER = (void *)(&GraalFigureMbk->PHVIA);
1475 
1476           if ( ((phvia_list *)Element)->NEXT != (phvia_list *)NULL )
1477           {
1478             ((phvia_list *)Element)->NEXT->USER = (void *)(&((phvia_list *)Element)->NEXT);
1479           }
1480 
1481           NewRec = GraalAddVia( ((phvia_list *)Element) );
1482 
1483           GraalAddUndoRec( NewRec );
1484         }
1485       }
1486     }
1487   }
1488 
1489   GraalDelEqui();
1490   GraalDelPeek();
1491   GraalDelSelect();
1492   GraalZoomRefresh();
1493 
1494   if ( Mode == 0 )
1495   {
1496     GraalChangeEditMode( GRAAL_SELECT_POINT_STRETCH,
1497                          GraalPromptSelectPointStretch );
1498   }
1499   else
1500   {
1501     GraalChangeEditMode( GRAAL_SELECT_WINDOW_STRETCH,
1502                          GraalPromptSelectWindowStretch );
1503   }
1504 
1505   rdsend();
1506 }
1507