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