projects / tas-yagle.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Initial version of donated sources by Avertec, 3.4p5.
[tas-yagle.git] / distrib / sources / yagle / cgv / cgv_build.c
1 /*------------------------------------------------------------\
2 | |
3 | Tool : Cgv |
4 | |
5 | File : Cgv Build |
6 | |
7 | Authors : Picault Stephane |
8 | Miramond Benoit |
9 | |
10 | Date : 04.03.98 |
11 | |
12 \------------------------------------------------------------*/
13
14 #include <stdio.h>
15 #include <stdlib.h>
16 #include <string.h>
17
18 #include MUT_H
19 #include SLB_H
20 #include CGV_H
21
22 #define BOX_SIZE_MIN 5
23 #define BOX_SIZE_MAX (BOX_SIZE_MIN*3)
24
25 //#define DEBUG
26
27 int CGV_SCALE = 1 ;
28
29 static int CgvNetCompare __P((cgvnet_list **, cgvnet_list **));
30 static int CheckNetIntersection __P((chain_list *, cgvnet_list *));
31
32 /*------------------------------------------------------------\
33 | Function Loc Destroy Transparence |
34 \------------------------------------------------------------*/
35
36 static void
37 loc_destroytransparence(Figure, Transparence)
38 cgvfig_list *Figure;
39 cgvbox_list *Transparence;
40 {
41 cgvnet_list *CgvNet;
42 cgvwir_list *CgvWire;
43
44 CgvNet = Transparence->CON_IN->NET;
45 CgvWire = addcgvwir(Figure, CgvNet);
46
47 CgvWire->X = Transparence->X + Transparence->CON_IN->X_REL;
48 CgvWire->Y = Transparence->Y + Transparence->CON_IN->Y_REL;
49 CgvWire->DX = Transparence->X + Transparence->CON_OUT->X_REL;
50 CgvWire->DY = Transparence->Y + Transparence->CON_OUT->Y_REL;
51
52 /* return(0); */
53 }
54
55 /*------------------------------------------------------------\
56 | Function Loc Destroy Cluster |
57 \------------------------------------------------------------*/
58
59 static void
60 loc_destroycluster(Figure, Cluster)
61 cgvfig_list *Figure;
62 cgvbox_list *Cluster;
63 {
64 cgvwir_list *CgvWire;
65 cgvbox_list *Box;
66 cgvbox_list *Box1;
67 cgvbox_list *Box2;
68 cgvcon_list *Con;
69 cgvcon_list *ConCast;
70 cgvnet_list *CgvNet;
71 cgvcon_list *ClusterCon;
72 chain_list *ScanBox;
73 chain_list *ScanCon;
74
75 ScanBox = (chain_list *) Cluster->SOURCE;
76 Box = (cgvbox_list *) ScanBox->DATA;
77 ScanBox = ScanBox->NEXT;
78 Box2 = (cgvbox_list *) ScanBox->DATA;
79 ScanBox = ScanBox->NEXT;
80 Box1 = (cgvbox_list *) ScanBox->DATA;
81
82
83 Box1->USER = (void *) Cluster->USER;
84 Box1->X = Cluster->X;
85 Box1->Y = Cluster->Y;
86 Box1->DX = (Cluster->DX / 3);
87
88 for (Con = Box1->CON_OUT;
89 Con != (cgvcon_list *) 0;
90 Con = Con->NEXT) {
91 Con->X_REL = Box1->DX + 2;
92 }
93
94 for (Con = Box1->CON_IN;
95 Con != (cgvcon_list *) 0;
96 Con = Con->NEXT) {
97 ClusterCon = (cgvcon_list *) Con->USER;
98
99 CgvNet = Con->NET;
100
101 for (ScanCon = CgvNet->CON_NET;
102 ScanCon != (chain_list *) 0;
103 ScanCon = ScanCon->NEXT) {
104 ConCast = (cgvcon_list *) ScanCon->DATA;
105 if (ConCast == ClusterCon) {
106 ScanCon->DATA = (void *) Con;
107 }
108 }
109 }
110
111 Box2->USER = (void *) Cluster->USER;
112 Box2->X = Cluster->X;
113 Box2->Y = Cluster->Y + Box1->DY;
114 Box2->DX = (Cluster->DX / 3);
115
116 for (Con = Box2->CON_OUT;
117 Con != (cgvcon_list *) 0;
118 Con = Con->NEXT) {
119 Con->X_REL = Box2->DX + 2;
120 }
121
122 for (Con = Box2->CON_IN;
123 Con != (cgvcon_list *) 0;
124 Con = Con->NEXT) {
125 ClusterCon = (cgvcon_list *) Con->USER;
126
127 CgvNet = Con->NET;
128
129 for (ScanCon = CgvNet->CON_NET;
130 ScanCon != (chain_list *) 0;
131 ScanCon = ScanCon->NEXT) {
132 ConCast = (cgvcon_list *) ScanCon->DATA;
133 if (ConCast == ClusterCon) {
134 ScanCon->DATA = (void *) Con;
135 }
136 }
137 }
138
139 Box->USER = (void *) Cluster->USER;
140 Box->X = Cluster->X + ((Cluster->DX * 2) / 3);
141 Box->Y = Cluster->Y + (Cluster->CON_OUT->Y_REL - 4);
142 Box->DX = (Cluster->DX / 3);
143
144 for (Con = Box->CON_OUT;
145 Con != (cgvcon_list *) 0;
146 Con = Con->NEXT) {
147 Con->X_REL = Box->DX + 2;
148
149 ClusterCon = (cgvcon_list *) Con->USER;
150
151 CgvNet = Con->NET;
152
153 for (ScanCon = CgvNet->CON_NET;
154 ScanCon != (chain_list *) 0;
155 ScanCon = ScanCon->NEXT) {
156 ConCast = (cgvcon_list *) ScanCon->DATA;
157 if (ConCast == ClusterCon) {
158 ScanCon->DATA = (void *) Con;
159 }
160 }
161 }
162
163 CgvWire = addcgvwir(Figure, Box1->CON_OUT->NET);
164
165 CgvWire->X = Box1->X + Box1->CON_OUT->X_REL;
166 CgvWire->Y = Box1->Y + Box1->CON_OUT->Y_REL;
167 CgvWire->DX = Box->X + Box->CON_IN->NEXT->X_REL;
168 CgvWire->DY = Box->Y + Box->CON_IN->NEXT->Y_REL;
169
170 CgvWire = addcgvwir(Figure, Box2->CON_OUT->NET);
171
172 CgvWire->X = Box2->X + Box2->CON_OUT->X_REL;
173 CgvWire->Y = Box2->Y + Box2->CON_OUT->Y_REL;
174 CgvWire->DX = Box->X + Box->CON_IN->X_REL;
175 CgvWire->DY = Box->Y + Box->CON_IN->Y_REL;
176 }
177
178
179 /*------------------------------------------------------------\
180 | Function Loc Build Cluster |
181 \------------------------------------------------------------*/
182 /*
183 static void
184 loc_buildcluster(Figure)
185 cgvfig_list *Figure;
186 {
187 cgvcon_list *Con1;
188 cgvbox_list *Box;
189 cgvcon_list *Con2;
190 cgvcon_list *CgvCon;
191 cgvcon_list *ConCast;
192 cgvcon_list *ClusterCon;
193 cgvbox_list *Box1;
194 cgvbox_list *Box2;
195 cgvbox_list *Cluster;
196 cgvnet_list *CgvNet;
197
198 chain_list *ScanCon;
199 int Go;
200
201
202 for (Box = Figure->BOX;
203 Box != (cgvbox_list *) 0;
204 Box = Box->NEXT) {
205
206 Go = 1;
207
208 if ((!IsCgvBoxCluster(Box)) &&
209 (!IsCgvBoxClusterised(Box)) &&
210 (Box->NUMBER_IN == 2) &&
211 (Box->NUMBER_OUT == 1)) {
212 Con2 = (cgvcon_list *) Box->CON_IN;
213 Con1 = (cgvcon_list *) Box->CON_IN->NEXT;
214
215 if ((Con1->NET->NUMBER_OUT == 1) && (Con2->NET->NUMBER_OUT == 1)
216 && (Con1->NET->NUMBER_IN == 1) && (Con2->NET->NUMBER_IN == 1)) {
217 for (ScanCon = Con1->NET->CON_NET;
218 ScanCon != (chain_list *) 0;
219 ScanCon = ScanCon->NEXT) {
220 ConCast = (cgvcon_list *) ScanCon->DATA;
221
222 if (ConCast != Con1) {
223 if (ConCast->ROOT_TYPE == CGV_ROOT_CON_BOX) {
224 Box1 = ConCast->ROOT;
225
226 if (IsCgvBoxClusterised(Box1)
227 || IsCgvBoxCluster(Box1)
228 || (Box1->NUMBER_OUT != 1)) {
229 Go = 0;
230 }
231 }
232 else
233 Go = 0;
234 }
235 }
236
237 if (Go == 1) {
238 for (ScanCon = Con2->NET->CON_NET;
239 ScanCon != (chain_list *) 0;
240 ScanCon = ScanCon->NEXT) {
241 ConCast = (cgvcon_list *) ScanCon->DATA;
242
243 if (ConCast != Con2) {
244 if (ConCast->ROOT_TYPE == CGV_ROOT_CON_BOX) {
245 Box2 = ConCast->ROOT;
246
247 if (IsCgvBoxClusterised(Box2)
248 || IsCgvBoxCluster(Box2)
249 || (Box2->NUMBER_OUT != 1)) {
250 Go = 0;
251 }
252 }
253 else {
254 Go = 0;
255 }
256 }
257 }
258 }
259 if (Go == 1) {
260 Cluster = addcgvbox(Figure, "Cluster");
261
262 SetCgvBoxCluster(Cluster);
263
264 SetCgvBoxClusterised(Box1);
265 Cluster->SOURCE = (chain_list *) addchain((chain_list *) Cluster->SOURCE
266 ,(void *) Box1);
267
268 Box1->CON_IN = (cgvcon_list *) reverse((chain_list *) Box1->CON_IN);
269
270 for (CgvCon = Box1->CON_IN;
271 CgvCon != (cgvcon_list *) 0;
272 CgvCon = CgvCon->NEXT) {
273 ClusterCon = addcgvboxconin(Figure, Cluster, CgvCon->NAME);
274
275 CgvNet = CgvCon->NET;
276
277 for (ScanCon = CgvNet->CON_NET;
278 ScanCon != (chain_list *) 0;
279 ScanCon = ScanCon->NEXT) {
280 ConCast = (cgvcon_list *) ScanCon->DATA;
281 if (ConCast == CgvCon) {
282 ScanCon->DATA = (void *) ClusterCon;
283 }
284 }
285
286 ClusterCon->NET = CgvNet;
287
288 CgvCon->USER = (void *) ClusterCon;
289 }
290
291 Box1->CON_IN = (cgvcon_list *) reverse((chain_list *) Box1->CON_IN);
292
293 SetCgvBoxClusterised(Box2);
294 Cluster->SOURCE = (chain_list *) addchain((chain_list *) Cluster->SOURCE
295 ,(void *) Box2);
296
297 Box2->CON_IN = (cgvcon_list *) reverse((chain_list *) Box2->CON_IN);
298
299 for (CgvCon = Box2->CON_IN;
300 CgvCon != (cgvcon_list *) 0;
301 CgvCon = CgvCon->NEXT) {
302 ClusterCon = addcgvboxconin(Figure, Cluster, CgvCon->NAME);
303
304 CgvNet = CgvCon->NET;
305
306 for (ScanCon = CgvNet->CON_NET;
307 ScanCon != (chain_list *) 0;
308 ScanCon = ScanCon->NEXT) {
309 ConCast = (cgvcon_list *) ScanCon->DATA;
310 if (ConCast == CgvCon) {
311 ScanCon->DATA = (void *) ClusterCon;
312 }
313 }
314
315 ClusterCon->NET = CgvNet;
316
317 CgvCon->USER = (void *) ClusterCon;
318
319 }
320
321 Box2->CON_IN = (cgvcon_list *) reverse((chain_list *) Box2->CON_IN);
322
323 SetCgvBoxClusterised(Box);
324 Cluster->SOURCE = (chain_list *) addchain((chain_list *) Cluster->SOURCE
325 ,(void *) Box);
326
327 for (CgvCon = Box->CON_OUT;
328 CgvCon != (cgvcon_list *) 0;
329 CgvCon = CgvCon->NEXT) {
330 ClusterCon = addcgvboxconout(Figure, Cluster, CgvCon->NAME);
331
332 CgvNet = CgvCon->NET;
333
334 for (ScanCon = CgvNet->CON_NET;
335 ScanCon != (chain_list *) 0;
336 ScanCon = ScanCon->NEXT) {
337 ConCast = (cgvcon_list *) ScanCon->DATA;
338 if (ConCast == CgvCon) {
339 ScanCon->DATA = (void *) ClusterCon;
340 }
341 }
342
343 ClusterCon->NET = CgvNet;
344 CgvCon->USER = (void *) ClusterCon;
345 }
346 }
347 }
348 }
349 }
350 }
351 */
352
353 /*------------------------------------------------------------\
354 | Function Loc Build Place First |
355 \------------------------------------------------------------*/
356 /*
357 static cgvcol_list *
358 loc_buildplacefirst(Figure)
359 cgvfig_list *Figure;
360 {
361 cgvcol_list *ColMax;
362 cgvcel_list *Cell;
363 cgvcol_list *Column;
364 cgvbox_list *Box;
365 cgvcon_list *Con;
366
367 long MaxCumulY = 0;
368 long CumulY;
369
370 #ifndef __ALL__WARNING__
371 Figure = NULL;
372 #endif
373
374 for (Column = HEAD_CGVCOL;
375 Column != (cgvcol_list *) 0;
376 Column = Column->NEXT) {
377 CumulY = 0;
378
379 for (Cell = Column->CELL;
380 Cell != (cgvcel_list *) 0;
381 Cell = Cell->NEXT) {
382 if (Cell->TYPE == CGV_CEL_BOX) {
383 Box = (cgvbox_list *) Cell->ROOT;
384 Box->Y = CumulY;
385 CumulY += Box->DY + 5*CGV_SCALE;
386 if (Box->DX > Column->MAX_DX_CELL) {
387 Column->MAX_DX_CELL = Box->DX;
388 }
389 }
390 else if (Cell->TYPE == CGV_CEL_CON) {
391 Con = (cgvcon_list *) Cell->ROOT;
392 Con->Y_REL = CumulY;
393 CumulY += 3*CGV_SCALE;
394 if (2*CGV_SCALE > Column->MAX_DX_CELL) {
395 Column->MAX_DX_CELL = 2*CGV_SCALE;
396 }
397 }
398 }
399 if (MaxCumulY < CumulY) {
400 ColMax = Column;
401 MaxCumulY = CumulY;
402 }
403 }
404 for (Cell = ColMax->CELL;
405 Cell != (cgvcel_list *) 0;
406 Cell = Cell->NEXT) {
407 if (Cell->TYPE == CGV_CEL_BOX) {
408 SetCgvBoxPlaced((cgvbox_list *) Cell->ROOT);
409 }
410 if (Cell->TYPE == CGV_CEL_CON) {
411 SetCgvConPlaced((cgvcon_list *) Cell->ROOT);
412 }
413
414 }
415 return (ColMax);
416 }
417 */
418
419
420 /*------------------------------------------------------------\
421 | Function Loc Build Place In |
422 \------------------------------------------------------------*/
423
424 /*
425 static cgvfig_list *
426 loc_buildplacein(Figure, ColumnFrom, ColumnTo)
427 cgvfig_list *Figure;
428 cgvcol_list *ColumnFrom;
429 cgvcol_list *ColumnTo;
430 {
431 cgvcel_list *CellTo;
432 cgvcon_list *ConTo;
433 cgvbox_list *BoxTo;
434
435 cgvcel_list *CellFrom;
436 cgvbox_list *BoxFrom;
437 cgvcon_list *ConFrom;
438
439 chain_list *Chain;
440 char Begin = 1;
441 long CumulY;
442
443 for (CellTo = ColumnTo->LAST_CELL; CellTo; CellTo = CellTo->PREV) {
444 if (CellTo->TYPE == CGV_CEL_BOX) {
445 BoxTo = (cgvbox_list *) CellTo->ROOT;
446
447 for (ConTo = BoxTo->CON_IN; ConTo; ConTo = ConTo->NEXT) {
448 for (Chain = ConTo->NET->CON_NET; Chain; Chain = Chain->NEXT) {
449 ConFrom = (cgvcon_list *) Chain->DATA;
450
451 if (IsCgvConInternal(ConFrom) && IsCgvConOut(ConFrom)) {
452 BoxFrom = (cgvbox_list *) ConFrom->ROOT;
453
454 if (IsCgvBoxTaged(BoxFrom) && !IsCgvBoxPlaced(BoxFrom)) {
455 CellFrom = (cgvcel_list *) BoxFrom->USER;
456 if (CellFrom->COL == ColumnFrom) {
457 if (Begin) {
458 // juste une idee de grandeur
459 CumulY = BoxTo->Y + 2 * (BoxFrom->DY) + (BoxTo->DY);
460 Begin = 0;
461 }
462
463 if ((BoxTo->Y + ConTo->Y_REL - ConFrom->Y_REL + BoxFrom->DY) <= CumulY) {
464 BoxFrom->Y = BoxTo->Y + ConTo->Y_REL - ConFrom->Y_REL;
465 }
466 else {
467 BoxFrom->Y = CumulY - BoxFrom->DY;
468 }
469 CumulY = BoxFrom->Y - CGV_SCALE;
470 SetCgvBoxPlaced(BoxFrom);
471 }
472 }
473 }
474 if (IsCgvConExternal(ConFrom) && IsCgvConIn(ConFrom)
475 && !IsCgvConPlaced(ConFrom) && IsCgvConTaged(ConFrom)) {
476 CellFrom = (cgvcel_list *) ConFrom->USER;
477 if (CellFrom->COL == ColumnFrom) {
478
479 if (!IsCgvConPlaced(ConFrom)) {
480 if (Begin) {
481 CumulY = BoxTo->Y + 2 * (BoxFrom->DY) + (BoxTo->DY);
482 Begin = 0;
483 }
484
485 if (BoxTo->Y + ConTo->Y_REL <= CumulY) {
486 ConFrom->Y_REL = BoxTo->Y + ConTo->Y_REL;
487 }
488 else {
489 ConFrom->Y_REL = CumulY - 5*CGV_SCALE;
490 }
491 SetCgvConPlaced(ConFrom);
492 CumulY = ConFrom->Y_REL - CGV_SCALE;
493 }
494 }
495 }
496 }
497 }
498 }
499 }
500 return (Figure);
501 }
502 */
503
504 /*------------------------------------------------------------\
505 | Function Loc Build Place Out |
506 \------------------------------------------------------------*/
507
508 /*
509 static cgvfig_list *
510 loc_buildplaceout(Figure, ColumnFrom, ColumnTo)
511 cgvfig_list *Figure;
512 cgvcol_list *ColumnFrom;
513 cgvcol_list *ColumnTo;
514 {
515 chain_list *Chain;
516
517 char Begin = 1;
518
519 cgvbox_list *FirstBox = NULL;
520 cgvbox_list *BoxFrom;
521 cgvcon_list *ConFrom;
522 cgvcel_list *CellFrom;
523
524 cgvcon_list *ConTo;
525 cgvcel_list *CellTo;
526 cgvbox_list *BoxTo;
527 long CumulY;
528
529 for (CellTo = ColumnTo->LAST_CELL; CellTo; CellTo = CellTo->PREV) {
530 if (CellTo->TYPE == CGV_CEL_BOX) {
531 BoxTo = (cgvbox_list *) CellTo->ROOT;
532
533 for (ConTo = BoxTo->CON_IN; ConTo && !IsCgvBoxPlaced(BoxTo); ConTo = ConTo->NEXT) {
534 for (Chain = ConTo->NET->CON_NET; Chain && !IsCgvBoxPlaced(BoxTo); Chain = Chain->NEXT) {
535 ConFrom = (cgvcon_list *) Chain->DATA;
536 if (ConFrom != ConTo) {
537 if (IsCgvConInternal(ConFrom) && IsCgvConOut(ConFrom)) {
538 BoxFrom = (cgvbox_list *) ConFrom->ROOT;
539 if (BoxFrom->NUMBER_OUT == 0) {
540 continue;
541 }
542
543 if (IsCgvBoxTaged(BoxFrom)) {
544 CellFrom = (cgvcel_list *) BoxFrom->USER;
545 if (CellFrom->COL == ColumnFrom) {
546 if (Begin) {
547 // juste une idee de grandeur
548 CumulY = BoxFrom->Y + 2 * (BoxTo->DY + BoxFrom->DY);
549 Begin = 0;
550 }
551 if ((BoxFrom->Y + ConFrom->Y_REL - ConTo->Y_REL + BoxTo->DY) <= CumulY) {
552 SetCgvBoxPlaced(BoxTo);
553 BoxTo->Y = BoxFrom->Y + ConFrom->Y_REL - ConTo->Y_REL;
554 CumulY = BoxTo->Y - CGV_SCALE;
555 }
556 else {
557 //BoxTo->Y = CumulY - BoxTo->DY;
558 }
559 // 3 fev 2000
560 if (FirstBox != NULL) {
561 if (!IsCgvBoxPlaced(FirstBox)) {
562 FirstBox->Y = BoxTo->Y + BoxTo->DY + 2*CGV_SCALE;
563 SetCgvBoxPlaced(FirstBox);
564 }
565 }
566 // fin
567 }
568 }
569 }
570 }
571 }
572 }
573 if (!IsCgvBoxPlaced(BoxTo)) {
574 // 3 fev 2000
575 if (Begin) {
576 FirstBox = BoxTo;
577 }
578 // fin
579 else {
580 BoxTo->Y = CumulY - BoxTo->DY;
581 SetCgvBoxPlaced(BoxTo);
582 CumulY = BoxTo->Y - CGV_SCALE;
583 }
584 }
585 }
586
587 if (CellTo->TYPE == CGV_CEL_CON) {
588 ConTo = (cgvcon_list *) CellTo->ROOT;
589
590 for (Chain = ConTo->NET->CON_NET; Chain && !IsCgvConPlaced(ConTo); Chain = Chain->NEXT) {
591 ConFrom = (cgvcon_list *) Chain->DATA;
592 if (ConFrom != ConTo) {
593 if (IsCgvConInternal(ConFrom) && IsCgvConOut(ConFrom)) {
594 BoxFrom = (cgvbox_list *) ConFrom->ROOT;
595 if (IsCgvBoxTaged(BoxFrom)) {
596 CellFrom = (cgvcel_list *) BoxFrom->USER;
597 if (CellFrom->COL == ColumnFrom) {
598 if (Begin) {
599 CumulY = BoxFrom->Y + 2 * (BoxFrom->DY);
600 Begin = 0;
601 }
602 if ((BoxFrom->Y + ConFrom->Y_REL + 2*CGV_SCALE) <= CumulY) {
603 SetCgvConPlaced(ConTo);
604 ConTo->Y_REL = BoxFrom->Y + ConFrom->Y_REL;
605 CumulY = ConTo->Y_REL - CGV_SCALE;
606 }
607 else {
608 // ConTo->Y_REL = CumulY;
609 }
610 }
611 }
612 }
613 }
614 }
615 if (Begin && IsCgvConPlaced(ConTo)) {
616 ConTo->Y_REL = CumulY;
617 SetCgvConPlaced(ConTo);
618 CumulY = ConTo->Y_REL - CGV_SCALE;
619 }
620 }
621 }
622 return (Figure);
623 }
624 */
625
626 /*------------------------------------------------------------\
627 | Function Loc Build Place |
628 \------------------------------------------------------------*/
629 /*
630 static cgvfig_list *
631 loc_buildplace(Figure)
632 cgvfig_list *Figure;
633 {
634
635 cgvcol_list *Column;
636 cgvcol_list *MaxColumn;
637
638 MaxColumn = loc_buildplacefirst(Figure);
639
640 for (Column = MaxColumn; Column->NEXT; Column = Column->NEXT) {
641 loc_buildplaceout(Figure, Column, Column->NEXT);
642 }
643
644 HEAD_CGVCOL = (cgvcol_list *) reverse((chain_list *) HEAD_CGVCOL);
645
646 for (Column = MaxColumn; Column->NEXT; Column = Column->NEXT) {
647 loc_buildplacein(Figure, Column->NEXT, Column);
648 }
649
650 HEAD_CGVCOL = (cgvcol_list *) reverse((chain_list *) HEAD_CGVCOL);
651
652 return (Figure);
653 }
654 */
655
656 /*------------------------------------------------------------\
657 | Function Loc Routage Canal |
658 \------------------------------------------------------------*/
659
660 static long
661 loc_routage_canal(Figure, ColumnFrom, ColumnTo, Xdep)
662 cgvfig_list *Figure;
663 cgvcol_list *ColumnFrom;
664 cgvcol_list *ColumnTo;
665 long Xdep;
666 {
667 cgvcel_list *ScanCell;
668 cgvbox_list *CgvBox;
669 cgvnet_list *CgvNet;
670 cgvnet_list **CgvNetTable;
671 cgvwir_list *CgvWire;
672 cgvcon_list *ScanCon;
673 cgvcon_list *CgvCon;
674 chain_list *CgvNetList = NULL;
675 chain_list *CurChannelNets = NULL;
676 chain_list *ptchain;
677 long numcgvnet = 0;
678 long channel;
679 long i = 0;
680
681 Xdep += ColumnFrom->MAX_DX_CELL;
682
683 /* Traverse Canal Input and Output Connectors to */
684 /* obtain list of CgvNets in Canal and their */
685 /* vertical extremities with direction */
686
687 /* Channel Input Connectors */
688
689 for (ScanCell = ColumnFrom->CELL; ScanCell; ScanCell = ScanCell->NEXT) {
690 if (ScanCell->TYPE == CGV_CEL_BOX) {
691 CgvBox = (cgvbox_list *) ScanCell->ROOT;
692 for (ScanCon = CgvBox->CON_OUT; ScanCon; ScanCon = ScanCon->NEXT) {
693 CgvNet = ScanCon->NET;
694 if (!IsCgvNetCanal(CgvNet)) {
695 numcgvnet++;
696 SetCgvNetCanal(CgvNet);
697 CgvNetList = addchain(CgvNetList, CgvNet);
698 CgvNet->YMAX = CgvBox->Y + ScanCon->Y_REL;
699 CgvNet->YMIN = CgvBox->Y + ScanCon->Y_REL;
700 }
701 else if ((CgvBox->Y + ScanCon->Y_REL) > (CgvNet->YMAX)) {
702 CgvNet->YMAX = CgvBox->Y + ScanCon->Y_REL;
703 }
704 else if ((CgvBox->Y + ScanCon->Y_REL) < (CgvNet->YMIN)) {
705 CgvNet->YMIN = CgvBox->Y + ScanCon->Y_REL;
706 }
707 }
708 }
709 else if (ScanCell->TYPE == CGV_CEL_CON) {
710 CgvCon = (cgvcon_list *) ScanCell->ROOT;
711
712 CgvNet = CgvCon->NET;
713 if (!IsCgvNetCanal(CgvNet)) {
714 numcgvnet++;
715 SetCgvNetCanal(CgvNet);
716 CgvNetList = addchain(CgvNetList, CgvNet);
717 CgvNet->YMAX = CgvCon->Y_REL;
718 CgvNet->YMIN = CgvCon->Y_REL;
719 }
720 if ((CgvCon->Y_REL) > (CgvNet->YMAX)) {
721 CgvNet->YMAX = CgvCon->Y_REL;
722 }
723 if ((CgvCon->Y_REL) < (CgvNet->YMIN)) {
724 CgvNet->YMIN = CgvCon->Y_REL;
725 }
726 }
727 }
728
729 /* Channel Output connectors */
730
731 for (ScanCell = ColumnTo->CELL; ScanCell; ScanCell = ScanCell->NEXT) {
732 if (ScanCell->TYPE == CGV_CEL_BOX) {
733 CgvBox = (cgvbox_list *) ScanCell->ROOT;
734 for (ScanCon = CgvBox->CON_IN; ScanCon; ScanCon = ScanCon->NEXT) {
735 CgvNet = ScanCon->NET;
736 if (!IsCgvNetCanal(CgvNet)) {
737 numcgvnet++;
738 SetCgvNetCanal(CgvNet);
739 CgvNetList = addchain(CgvNetList, CgvNet);
740 CgvNet->YMAX = CgvBox->Y + ScanCon->Y_REL;
741 SetCgvNetMaxOutput(CgvNet);
742 CgvNet->YMIN = CgvBox->Y + ScanCon->Y_REL;
743 SetCgvNetMinOutput(CgvNet);
744 }
745 else if ((CgvBox->Y + ScanCon->Y_REL) > (CgvNet->YMAX)) {
746 CgvNet->YMAX = CgvBox->Y + ScanCon->Y_REL;
747 SetCgvNetMaxOutput(CgvNet);
748 }
749 else if ((CgvBox->Y + ScanCon->Y_REL) < (CgvNet->YMIN)) {
750 CgvNet->YMIN = CgvBox->Y + ScanCon->Y_REL;
751 SetCgvNetMinOutput(CgvNet);
752 }
753 }
754 }
755 else if (ScanCell->TYPE == CGV_CEL_CON) {
756 CgvCon = (cgvcon_list *) ScanCell->ROOT;
757
758 CgvNet = CgvCon->NET;
759 if (!IsCgvNetCanal(CgvNet)) {
760 numcgvnet++;
761 SetCgvNetCanal(CgvNet);
762 CgvNetList = addchain(CgvNetList, CgvNet);
763 CgvNet->YMAX = CgvCon->Y_REL;
764 SetCgvNetMaxOutput(CgvNet);
765 CgvNet->YMIN = CgvCon->Y_REL;
766 SetCgvNetMinOutput(CgvNet);
767 }
768 if ((CgvCon->Y_REL) > (CgvNet->YMAX)) {
769 CgvNet->YMAX = CgvCon->Y_REL;
770 SetCgvNetMaxOutput(CgvNet);
771 }
772 if ((CgvCon->Y_REL) < (CgvNet->YMIN)) {
773 CgvNet->YMIN = CgvCon->Y_REL;
774 SetCgvNetMinOutput(CgvNet);
775 }
776 }
777 }
778
779 /* build table of CgvNets and sort */
780
781 CgvNetTable = (cgvnet_list **) mbkalloc(numcgvnet * sizeof(cgvnet_list *));
782 for (ptchain = CgvNetList; ptchain; ptchain = ptchain->NEXT) {
783 CgvNetTable[i++] = (cgvnet_list *) ptchain->DATA;
784 }
785 qsort(CgvNetTable, numcgvnet, sizeof(cgvnet_list *), (void *) CgvNetCompare);
786
787 /* Allocate a channel number to each CgvNet */
788
789 channel = Xdep + 4*CGV_SCALE;
790 for (i = 0; i < numcgvnet; i++) {
791 if ((CgvNetTable[i])->YMAX == (CgvNetTable[i])->YMIN) {
792 (CgvNetTable[i])->CANAL = channel;
793 continue;
794 }
795 if (CheckNetIntersection(CurChannelNets, CgvNetTable[i])) {
796 channel += 2*CGV_SCALE;
797 if (CurChannelNets)
798 freechain(CurChannelNets);
799 CurChannelNets = addchain(NULL, CgvNetTable[i]);
800 }
801 else
802 CurChannelNets = addchain(CurChannelNets, CgvNetTable[i]);
803 (CgvNetTable[i])->CANAL = channel;
804 }
805 mbkfree(CgvNetTable);
806
807 /* Draw horizontal wires from input column to vertical wire */
808
809 for (ScanCell = ColumnFrom->CELL; ScanCell; ScanCell = ScanCell->NEXT) {
810 if (ScanCell->TYPE == CGV_CEL_BOX) {
811 CgvBox = ScanCell->ROOT;
812
813 for (ScanCon = CgvBox->CON_OUT; ScanCon; ScanCon = ScanCon->NEXT) {
814 CgvNet = ScanCon->NET;
815 if (CgvNet->CON_NET->NEXT == NULL) continue;
816 CgvWire = addcgvwir(Figure, CgvNet);
817 CgvWire->X = CgvBox->X + ScanCon->X_REL;
818 CgvWire->DX = CgvNet->CANAL;
819 CgvWire->Y = CgvBox->Y + ScanCon->Y_REL;
820 CgvWire->DY = CgvBox->Y + ScanCon->Y_REL;
821 }
822 }
823 else if (ScanCell->TYPE == CGV_CEL_CON) {
824 CgvCon = (cgvcon_list *) ScanCell->ROOT;
825 CgvNet = CgvCon->NET;
826 CgvWire = addcgvwir(Figure, CgvNet);
827 CgvWire->X = CgvCon->X_REL + 2*CGV_SCALE;
828 CgvWire->DX = CgvNet->CANAL;
829 CgvWire->Y = CgvCon->Y_REL;
830 CgvWire->DY = CgvCon->Y_REL;
831 }
832 }
833
834 /* Draw horizontal wires from vertical wire to output column */
835
836 for (ScanCell = ColumnTo->CELL; ScanCell; ScanCell = ScanCell->NEXT) {
837 if (ScanCell->TYPE == CGV_CEL_BOX) {
838 CgvBox = ScanCell->ROOT;
839 CgvBox->X = channel + 6*CGV_SCALE + (ColumnTo->MAX_DX_CELL - CgvBox->DX) / 2;
840
841 for (ScanCon = CgvBox->CON_IN; ScanCon; ScanCon = ScanCon->NEXT) {
842 CgvNet = ScanCon->NET;
843 if (CgvNet->CON_NET->NEXT == NULL) continue;
844 CgvWire = addcgvwir(Figure, CgvNet);
845 CgvWire->X = CgvBox->X + ScanCon->X_REL;
846 CgvWire->DX = CgvNet->CANAL;
847 CgvWire->Y = CgvBox->Y + ScanCon->Y_REL;
848 CgvWire->DY = CgvBox->Y + ScanCon->Y_REL;
849 }
850 }
851 else if (ScanCell->TYPE == CGV_CEL_CON) {
852 CgvCon = (cgvcon_list *) ScanCell->ROOT;
853 CgvCon->X_REL = channel + 6*CGV_SCALE;
854 if (!(IsCgvConIn(CgvCon) && IsCgvConExternal(CgvCon))) {
855 CgvNet = CgvCon->NET;
856 CgvWire = addcgvwir(Figure, CgvNet);
857 CgvWire->X = CgvCon->X_REL - 2*CGV_SCALE;
858 CgvWire->DX = CgvNet->CANAL;
859 CgvWire->Y = CgvCon->Y_REL;
860 CgvWire->DY = CgvCon->Y_REL;
861 }
862 }
863 }
864
865 /* Draw vertical wires */
866
867 for (ptchain = CgvNetList; ptchain; ptchain = ptchain->NEXT) {
868 CgvNet = (cgvnet_list *) ptchain->DATA;
869 ClearCgvNetCanal(CgvNet);
870 ClearCgvNetDir(CgvNet);
871 if (CgvNet->YMIN == CgvNet->YMAX) {
872 continue;
873 }
874 CgvWire = addcgvwir(Figure, CgvNet);
875 CgvWire->X = CgvNet->CANAL;
876 CgvWire->DX = CgvNet->CANAL;
877 CgvWire->Y = CgvNet->YMIN;
878 CgvWire->DY = CgvNet->YMAX;
879 }
880 freechain(CgvNetList);
881
882 return (channel + 6*CGV_SCALE);
883 }
884
885 /*------------------------------------------------------------\
886 | Function CgvNetCompare |
887 \------------------------------------------------------------*/
888
889 static int
890 CgvNetCompare(net1, net2)
891 cgvnet_list **net1;
892 cgvnet_list **net2;
893 {
894 long type1, type2;
895
896 type1 = GetCgvNetDirType(*net1);
897 type2 = GetCgvNetDirType(*net2);
898
899 if (type1 > type2) {
900 return (1);
901 }
902 if (type1 < type2) {
903 return (-1);
904 }
905
906 switch (type1) {
907 case 0:
908 return (((*net1)->YMAX - (*net1)->YMIN) - ((*net2)->YMAX - (*net2)->YMIN));
909 break;
910 case CGV_NET_MINDIR:
911 return ((*net1)->YMIN - (*net2)->YMIN);
912 break;
913 case CGV_NET_MAXDIR:
914 return ((*net2)->YMAX - (*net1)->YMAX);
915 break;
916 case CGV_NET_MAXDIR | CGV_NET_MINDIR:
917 return (((*net2)->YMAX - (*net2)->YMIN) - ((*net1)->YMAX - (*net1)->YMIN));
918 break;
919 }
920 return 0;
921 }
922
923 /*------------------------------------------------------------\
924 | Function CgvNetCompare |
925 \------------------------------------------------------------*/
926
927 static int
928 CheckNetIntersection(NetList, Net)
929 chain_list *NetList;
930 cgvnet_list *Net;
931 {
932 chain_list *ptchain;
933 cgvnet_list *CmpNet;
934
935 for (ptchain = NetList;
936 ptchain != (chain_list *) 0;
937 ptchain = ptchain->NEXT) {
938 CmpNet = (cgvnet_list *) ptchain->DATA;
939 if ((Net->YMIN > CmpNet->YMAX) || (Net->YMAX < CmpNet->YMIN)) {
940 continue;
941 }
942 else {
943 break;
944 }
945 }
946 if (ptchain != NULL) {
947 return (1);
948 }
949 else {
950 return (0);
951 }
952 }
953
954
955 /*------------------------------------------------------------\
956 | Function Loc Route |
957 \------------------------------------------------------------*/
958
959 cgvfig_list *loc_route(Figure)
960 cgvfig_list *Figure;
961 {
962 cgvcol_list *Column_from;
963 cgvcol_list *Column_to;
964
965 long Xdep = 0;
966
967 for (Column_from = HEAD_CGVCOL;
968 Column_from->NEXT != (cgvcol_list *) 0;
969 Column_from = Column_from->NEXT) {
970 Column_to = Column_from->NEXT;
971 Xdep = loc_routage_canal(Figure, Column_from, Column_to, Xdep);
972 }
973 return (Figure);
974 }
975
976
977 /*------------------------------------------------------------\
978 | Function Loc Add Transparence |
979 \------------------------------------------------------------*/
980
981 cgvbox_list *loc_add_transparence(Figure, Net)
982 cgvfig_list *Figure;
983 cgvnet_list *Net;
984 {
985 cgvbox_list *Box;
986 cgvcon_list *Con_in;
987 cgvcon_list *Con_out;
988 static int num = 1;
989 char buffer[1024];
990
991
992 sprintf(buffer,"transparence_%d", num++);
993 Box = addcgvbox(Figure, namealloc(buffer));
994 SetCgvBoxTransparence(Box);
995
996 Con_out = addcgvboxconout(Figure, Box, "T_out");
997 Con_in = addcgvboxconin(Figure, Box, "T_in");
998
999 addcgvnetcon(Net, Con_out);
1000 addcgvnetcon(Net, Con_in);
1001
1002 return (Box);
1003 }
1004
1005
1006 /*------------------------------------------------------------\
1007 | Function Loc Test Trans |
1008 +-------------------------------------------------------------+
1009 | renvoie 1 si un Net traverse une colonne |
1010 | 0 sinon |
1011 \------------------------------------------------------------*/
1012
1013 int
1014 loc_test_trans(Net, Column)
1015 cgvnet_list *Net;
1016 cgvcol_list *Column;
1017 {
1018 cgvcel_list *CgvCel;
1019 cgvcon_list *CgvCon;
1020 cgvbox_list *CgvBox;
1021 chain_list *ChainCon;
1022
1023 for (ChainCon = Net->CON_NET;
1024 ChainCon != (chain_list *) 0;
1025 ChainCon = ChainCon->NEXT) {
1026 CgvCon = (cgvcon_list *) ChainCon->DATA;
1027 if (IsCgvConInternal(CgvCon)) {
1028 CgvBox = (cgvbox_list *) CgvCon->ROOT;
1029 if (IsCgvBoxTransparence(CgvBox)) {
1030 CgvCel = (cgvcel_list *) CgvBox->USER;
1031 if (CgvCel->COL == Column) {
1032 return (0);
1033 }
1034 }
1035 }
1036 }
1037 return (1);
1038 }
1039
1040 /*------------------------------------------------------------\
1041 | loc_isanyconbefore(Cell,FirstColumn) |
1042 \------------------------------------------------------------*/
1043 static int
1044 loc_isanyconbefore(Cell,FirstColumn)
1045 cgvcel_list *Cell;
1046 cgvcol_list *FirstColumn;
1047 {
1048 cgvcol_list *Current;
1049 cgvcol_list *Previous;
1050 cgvcol_list *Box2Col;
1051 cgvbox_list *CellBox;
1052 cgvbox_list *Box2;
1053 cgvnet_list *Net;
1054 cgvcon_list *Con2;
1055 chain_list *Chain;
1056 cgvcel_list *Cell2Col;
1057
1058 Current = Cell->COL;
1059 CellBox = (cgvbox_list*)Cell->ROOT; // CellBox est une transparence
1060 Net = CellBox->CON_OUT->NET;
1061
1062 for (Chain = Net->CON_NET; Chain;Chain = Chain->NEXT) {
1063 Con2 = (cgvcon_list *) Chain->DATA;
1064 Box2 = (cgvbox_list*)Con2->ROOT;
1065 if (IsCgvBoxTaged(Box2) && !IsCgvBoxTransparence(Box2) ) {
1066 Cell2Col = (cgvcel_list*)Box2->USER;
1067 Box2Col = Cell2Col->COL;
1068 for (Previous=FirstColumn; Previous != Current->NEXT; Previous = Previous->NEXT) {
1069 if (Previous == Box2Col) return 1;
1070 }
1071
1072 }
1073 else if (IsCgvConExternal(Con2))
1074 return 1;
1075 }
1076 return 0;
1077 }
1078
1079 /*------------------------------------------------------------\
1080 | loc_placelostcell(FirstColumn) |
1081 \------------------------------------------------------------*/
1082 void loc_placelostcell(FirstColumn,Figure)
1083 cgvcol_list *FirstColumn;
1084 cgvfig_list *Figure;
1085 {
1086
1087 cgvcon_list *Con;
1088 cgvcon_list *Con2;
1089 chain_list *Chain;
1090 cgvbox_list *Box;
1091 cgvbox_list *Box2;
1092 cgvcol_list *Column;
1093 cgvcol_list *Column2;
1094 cgvcel_list *Cell;
1095 cgvcel_list *Cell2;
1096 cgvcel_list *ptnextcell;
1097
1098 for (Column = FirstColumn;Column;Column=Column->NEXT) {
1099 for (Cell = Column->CELL; Cell; Cell = ptnextcell) {
1100 if (Cell->TYPE == CGV_CEL_BOX) {
1101 Box = (cgvbox_list *) Cell->ROOT;
1102
1103 if (Box->CON_OUT)
1104 Con = Box->CON_OUT;
1105 else
1106 continue;
1107
1108 if (Column->NEXT)
1109 Column2=Column->NEXT;
1110 else
1111 Column2=Column;
1112
1113 for (Chain = Con->NET->CON_NET; Chain; Chain = Chain->NEXT) {
1114 Con2 = (cgvcon_list *) Chain->DATA;
1115 if (Con2 != Con) {
1116 Box2 = (cgvbox_list *) Con2->ROOT;
1117 if (IsCgvConIn(Con2) && !IsCgvBoxTaged(Box2)
1118 && Con2->ROOT_TYPE == CGV_ROOT_CON_BOX){
1119 if(IsCgvBoxTransparence(Box)) {
1120 if(!loc_isanyconbefore(Cell,FirstColumn)) {
1121 Cell2 = Cell;
1122 if (Cell2->PREV) {
1123 Cell = Cell2->PREV;
1124 if (Cell2->NEXT) {
1125 Cell->NEXT = Cell2->NEXT;
1126 Cell->NEXT->PREV = Cell;
1127 } // if (Cell2->NEXT)
1128 else {
1129 Cell->NEXT = NULL;
1130 Column->LAST_CELL = Cell;
1131 } // !Cell2->NEXT
1132 } // if (Cell2->PREV)
1133 else {
1134 Column->CELL = Cell2->NEXT;
1135 if (Cell2->NEXT) {
1136 Cell2->NEXT->PREV = NULL;
1137 } // if (Cell2->NEXT)
1138 else {
1139 Cell->NEXT = NULL;
1140 Column->LAST_CELL = Cell;
1141 } // !Cell2->NEXT
1142 } // !Cell2->PREV
1143 cgvdeltransparence(Cell2,Figure);
1144 Column->NUMBER_CELL--;
1145 } // if(!loc_isanyconbefore(Cell,FirstColumn))
1146 } // if(IsCgvBoxTransparence(Box))
1147 else {
1148 SetCgvBoxTaged(Box2);
1149 Cell2 = addcgvcel(Column2);
1150 addcgvboxtocgvcel(Box2, Cell2);
1151 Column2->NUMBER_CELL++;
1152 } // !IsCgvBoxTransparence(Box)
1153 } // if (IsCgvConIn(Con2))
1154 } // if Con2 != Con
1155 } // for Chain
1156 } // if (Cell->TYPE == CGV_CEL_BOX)
1157 ptnextcell = Cell->NEXT;
1158 } // for Cell
1159 } // for Column
1160
1161
1162 }
1163
1164 /*------------------------------------------------------------\
1165 | Function Loc Placement Initial |
1166 +-------------------------------------------------------------+
1167 | placement initial, dans les colonnes |
1168 \------------------------------------------------------------*/
1169 cgvbox_list *removebox(cgvbox_list *list, cgvbox_list *b)
1170 {
1171 cgvbox_list *c0;
1172 if (b==list)
1173 {
1174 return list->NEXT;
1175 }
1176 else
1177 {
1178 for (c0=list; c0!=NULL && c0->NEXT!=b; c0=c0->NEXT) ;
1179 if (c0!=NULL) c0->NEXT=c0->NEXT->NEXT;
1180 }
1181 return list;
1182 }
1183
1184 void removefake(cgvfig_list *cgvf, cgvcol_list *col)
1185 {
1186 cgvcel_list *c, *cel, *cel0;
1187 cgvcon_list *con, *boxcon, *c0;
1188 cgvbox_list *box;
1189 chain_list *cl, *pred;
1190 cgvcol_list *col0;
1191
1192 for (c=col->CELL; c!=NULL; c=c->NEXT)
1193 {
1194 if (c->TYPE == CGV_CEL_CON)
1195 {
1196 con=(cgvcon_list *)c->ROOT;
1197 // printf("check con %s\n",con->NAME);
1198 if (strcmp(con->NAME,"$$**$$")==0)
1199 {
1200 if (col->CELL==c)
1201 {
1202 col->CELL=col->CELL->NEXT;
1203 }
1204 else
1205 {
1206 for (cel=col->CELL; cel->NEXT!=c; cel=cel->NEXT) ;
1207 cel->NEXT=cel->NEXT->NEXT;
1208 }
1209 col->NUMBER_CELL--;
1210
1211 if (con==cgvf->CON_OUT)
1212 {
1213 cgvf->CON_OUT=cgvf->CON_OUT->NEXT;
1214 }
1215 else
1216 {
1217 for (c0=cgvf->CON_OUT; c0->NEXT!=con; c0=c0->NEXT) ;
1218 c0->NEXT=c0->NEXT->NEXT;
1219 }
1220 cgvf->NUMBER_OUT--;
1221
1222 for (cl=con->NET->CON_NET; cl!=NULL; cl=cl->NEXT)
1223 {
1224 boxcon=(cgvcon_list *)cl->DATA;
1225 // printf("%s\n",boxcon->NAME);
1226 if (IsCgvConExternal(boxcon) && IsCgvConOut(boxcon)) continue;
1227
1228 box=(cgvbox_list *)boxcon->ROOT;
1229 if (IsCgvBoxTransparence(box))
1230 {
1231 cel0=(cgvcel_list *)box->USER;
1232 col0=col->NEXT;
1233 if (col0->CELL==cel0)
1234 {
1235 col0->CELL=col0->CELL->NEXT;
1236 }
1237 else
1238 {
1239 for (cel=col0->CELL; cel!=NULL && cel->NEXT!=cel0; cel=cel->NEXT) ;
1240 if (cel!=NULL) cel->NEXT=cel->NEXT->NEXT;
1241 }
1242 col0->NUMBER_CELL--;
1243 cgvf->BOX=removebox(cgvf->BOX, box);
1244 continue;
1245 }
1246
1247 pred=cl;
1248
1249 //printf("remove on %s\n",box->NAME);
1250
1251 if (boxcon==box->CON_OUT)
1252 {
1253 box->CON_OUT=box->CON_OUT->NEXT;
1254 }
1255 else
1256 {
1257 for (c0=box->CON_OUT; c0->NEXT!=boxcon; c0=c0->NEXT) ;
1258 c0->NEXT=c0->NEXT->NEXT;
1259 }
1260 // printf("remove on %s, out=%d, %p\n",box->NAME,box->NUMBER_OUT,box->CON_OUT);
1261 }
1262 con->NET->CON_NET=NULL;
1263 }
1264 }
1265 }
1266 }
1267
1268 void removecon(chain_list **ch, cgvcon_list *con)
1269 {
1270 chain_list *cl=*ch, *temp;
1271 if (cl->DATA==con) { *ch=cl->NEXT; cl->NEXT=NULL; freechain(cl); return ;}
1272 for (; cl->NEXT!=NULL; cl=cl->NEXT)
1273 if (cl->NEXT->DATA==con)
1274 {
1275 temp=cl->NEXT;
1276 cl->NEXT=temp->NEXT; temp->NEXT=NULL; freechain(temp);
1277 break;
1278 }
1279 if (cl==NULL) avt_errmsg(CGV_ERRMSG, "001", AVT_ERROR, 1);
1280 // printf("NOT FOUND\n");
1281 }
1282 int cgv_has_input(chain_list *cl)
1283 {
1284 cgvcon_list *con;
1285 while (cl!=NULL)
1286 {
1287 con=(cgvcon_list *)cl->DATA;
1288 if (IsCgvConIn(con) && IsCgvConExternal(con)) return 1;
1289 cl=cl->NEXT;
1290 }
1291 return 0;
1292 }
1293 cgvcol_list *merge(cgvfig_list *cgvf, cgvcol_list *old, cgvcol_list *new)
1294 {
1295 cgvcol_list *prev_new, *oldold, *prev_old, *nextnew;
1296 cgvcel_list *c, *cel, *next;
1297 cgvbox_list *Box, *pBox, *nextb;
1298 chain_list *cl;
1299 cgvcon_list *con;
1300 ht *h;
1301
1302 old = (cgvcol_list *) reverse((chain_list *) old);
1303 oldold=old;
1304 new = (cgvcol_list *) reverse((chain_list *) new);
1305
1306 while (old!=NULL && new!=NULL)
1307 {
1308 h=addht(100);
1309 for (c=old->CELL; c!=NULL; c=c->NEXT)
1310 {
1311 if (c->TYPE == CGV_CEL_BOX)
1312 {
1313 Box=(cgvbox_list *)c->ROOT;
1314 if (IsCgvBoxTransparence(Box))
1315 addhtitem(h, Box->CON_IN->NET, (long)c);
1316 }
1317 }
1318 for (c=new->CELL; c!=NULL; c=c->NEXT)
1319 {
1320 if (c->TYPE == CGV_CEL_BOX)
1321 {
1322 Box=(cgvbox_list *)c->ROOT;
1323 if (IsCgvBoxTransparence(Box))
1324 {
1325 if (gethtitem(h, Box->CON_IN->NET)!=EMPTYHT)
1326 {
1327 Box->NAME=NULL;
1328 }
1329 else
1330 {
1331 addhtitem(h, Box->CON_IN->NET, (long)c);
1332 }
1333 }
1334 }
1335 c->COL=old; old->NUMBER_CELL++;
1336 }
1337 delht(h);
1338 old->CELL=(cgvcel_list *)append((chain_list *)old->CELL, (chain_list *)new->CELL);
1339 prev_old=old;
1340 old=old->NEXT;
1341 prev_new=new;
1342 new=new->NEXT;
1343 }
1344
1345 if (prev_new!=NULL)
1346 while (old!=NULL)
1347 {
1348 for (c=prev_new->CELL; c!=NULL; c=c->NEXT)
1349 {
1350 if (c->TYPE == CGV_CEL_BOX)
1351 {
1352 Box=(cgvbox_list *)c->ROOT;
1353 if (Box->NAME!=NULL && IsCgvBoxTransparence(Box) && cgv_has_input(Box->CON_IN->NET->CON_NET) && loc_test_trans(Box->CON_IN->NET, old))
1354 {
1355 Box = loc_add_transparence(cgvf, Box->CON_IN->NET);
1356 Box->NAME="sup0";
1357 SetCgvBoxTaged(Box);
1358 cel = addcgvcel(old);
1359 addcgvboxtocgvcel(Box, cel);
1360 SetCgvBoxTaged(Box);
1361 SetCgvBoxReTaged(Box);
1362 }
1363 }
1364 }
1365 old=old->NEXT;
1366 }
1367
1368 if (prev_old!=NULL)
1369 while (new!=NULL)
1370 {
1371 nextnew=new->NEXT;
1372 prev_old->NEXT=new;
1373 new->NEXT=NULL;
1374 for (c=prev_old->CELL; c!=NULL; c=c->NEXT)
1375 {
1376 if (c->TYPE == CGV_CEL_BOX)
1377 {
1378 Box=(cgvbox_list *)c->ROOT;
1379 if (IsCgvBoxTransparence(Box) && cgv_has_input(Box->CON_IN->NET->CON_NET)
1380 && loc_test_trans(Box->CON_IN->NET, new))
1381 {
1382 Box = loc_add_transparence(cgvf, Box->CON_IN->NET);
1383 Box->NAME="sup";
1384 SetCgvBoxTaged(Box);
1385 cel = addcgvcel(new);
1386 addcgvboxtocgvcel(Box, cel);
1387 SetCgvBoxTaged(Box);
1388 SetCgvBoxReTaged(Box);
1389 }
1390 }
1391 }
1392 prev_old=new;// oldold=prev_old;
1393 new=nextnew;
1394 }
1395
1396 for (Box=cgvf->BOX, pBox=NULL; Box!=NULL; Box=nextb)
1397 {
1398 nextb=Box->NEXT;
1399 if (Box->NAME==NULL)
1400 {
1401 if (pBox==NULL) cgvf->BOX=Box->NEXT;
1402 else pBox->NEXT=Box->NEXT;
1403 }
1404 else
1405 pBox=Box;
1406 }
1407
1408 oldold=(cgvcol_list *) reverse((chain_list *) oldold);
1409
1410 for (prev_old=NULL, old=oldold; old!=NULL; prev_old=old, old=old->NEXT)
1411 {
1412 for (c=old->CELL; c!=NULL; c=c->NEXT)
1413 {
1414 if (c->TYPE == CGV_CEL_BOX)
1415 {
1416 Box=(cgvbox_list *)c->ROOT;
1417 if (Box->NAME==NULL) continue;
1418 // printf("-- %s",Box->NAME);
1419 if (IsCgvBoxTransparence(Box) && !cgv_has_input(Box->CON_IN->NET->CON_NET))
1420 {
1421 for (cl=Box->CON_IN->NET->CON_NET; cl!=NULL; cl=cl->NEXT)
1422 {
1423 con=(cgvcon_list *)cl->DATA;
1424 if (IsCgvConExternal(con)) continue;
1425 pBox=(cgvbox_list *)con->ROOT;
1426 if (pBox==Box || pBox->NAME==NULL) continue;
1427 cel=pBox->USER;
1428 if (cel->COL==prev_old || cel->COL==old)
1429 {
1430 // printf(">%s<",pBox->NAME);
1431 break;
1432 }
1433 }
1434 if (cl==NULL)
1435 {
1436 Box->NAME=NULL;
1437 // printf(" X");
1438 }
1439 }
1440 // printf(" -\n");
1441 }
1442 }
1443 }
1444
1445 for (old=oldold; old!=NULL; old=old->NEXT)
1446 {
1447 for (c=old->CELL, cel=NULL; c!=NULL; c=next)
1448 {
1449 next=c->NEXT;
1450 if (c->TYPE == CGV_CEL_BOX)
1451 {
1452 Box=(cgvbox_list *)c->ROOT;
1453 if (Box->NAME==NULL)
1454 {
1455 printf("remove\n");
1456 old->NUMBER_CELL--;
1457 if (cel==NULL) old->CELL=c->NEXT;
1458 else cel->NEXT=c->NEXT;
1459 removecon(&Box->CON_IN->NET->CON_NET, Box->CON_IN);
1460 removecon(&Box->CON_OUT->NET->CON_NET, Box->CON_OUT);
1461 continue;
1462 }
1463 else cel=c;
1464 }
1465 else
1466 cel=c;
1467 }
1468
1469 for (c=old->CELL; c!=NULL; c=c->NEXT)
1470 {
1471 if (c->TYPE == CGV_CEL_BOX)
1472 {
1473 Box=(cgvbox_list *)c->ROOT;
1474 if (Box->NAME==NULL) EXIT(8);
1475 }
1476 }
1477 }
1478
1479 for (Box=cgvf->BOX, pBox=NULL; Box!=NULL; Box=nextb)
1480 {
1481 nextb=Box->NEXT;
1482 if (Box->NAME==NULL)
1483 {
1484 if (pBox==NULL) cgvf->BOX=Box->NEXT;
1485 else pBox->NEXT=Box->NEXT;
1486 }
1487 else
1488 pBox=Box;
1489 }
1490
1491 for (Box=cgvf->BOX; Box!=NULL; Box=Box->NEXT)
1492 {
1493 if (Box->NAME==NULL) EXIT(9);
1494 }
1495
1496 return oldold;
1497 }
1498
1499 void markhitfromout(chain_list *cl)
1500 {
1501 cgvcon_list *c;
1502 cgvbox_list *b;
1503 while (cl!=NULL)
1504 {
1505 c=(cgvcon_list *)cl->DATA;
1506 if (IsCgvConOut(c) && IsCgvConInternal(c))
1507 {
1508 b=(cgvbox_list *)c->ROOT;
1509 if (!IsCgvBoxHit(b))
1510 {
1511 SetCgvBoxHit(b);
1512 for (c=b->CON_IN; c!=NULL; c=c->NEXT)
1513 {
1514 if (c->NET->CANAL==0)
1515 {
1516 markhitfromout(c->NET->CON_NET);
1517 c->NET->CANAL=1;
1518 }
1519 }
1520 }
1521 }
1522 cl=cl->NEXT;
1523 }
1524 }
1525
1526 static int unplaced=0;
1527 static cgvfig_list *loc_placement_initial(cgvfig_list *Figure)
1528 {
1529 int cpt;
1530 cgvcon_list *Con;
1531 cgvcon_list *Con2;
1532 chain_list *Chain;
1533
1534 cgvbox_list *Box;
1535 cgvbox_list *Box2;
1536 cgvbox_list *Box4;
1537 cgvcol_list *Column2, *firstcolumn;
1538 cgvcol_list *Column;
1539 cgvcel_list *Cell;
1540 cgvcel_list *Cell2;
1541
1542 cgvbox_list *BoxBox4, *b;
1543 cgvcel_list *BoxCell2;
1544 cgvnet_list *net;
1545
1546 long cpt_transparence = 0;
1547 int nb_conin = 0;
1548
1549 // on compte les connecteurs d'entree +
1550
1551 nb_conin = 0;
1552
1553 for (Con = Figure->CON_IN;
1554 Con != (cgvcon_list *) 0;
1555 Con = Con->NEXT) {
1556 nb_conin++;
1557 }
1558
1559 /* connecteurs externes de sortie dans la premiere colonne */
1560
1561 firstcolumn = Column2 = addcgvcol();
1562 Column = addcgvcol();
1563
1564 for (net=Figure->NET; net!=NULL; net=net->NEXT) net->CANAL=0; // marquage
1565
1566 for (Con = Figure->CON_OUT; Con != NULL; Con = Con->NEXT) {
1567 if (IsCgvConTaged(Con)) continue;
1568
1569 addcgvcontocgvcel(Con, addcgvcel(Column2));
1570 SetCgvConTaged(Con);
1571 markhitfromout(Con->NET->CON_NET);
1572 for (Chain = Con->NET->CON_NET;
1573 Chain != (chain_list *) 0;
1574 Chain = Chain->NEXT) {
1575 if (loc_test_trans(Con->NET, Column)) {
1576 Box2 = loc_add_transparence(Figure, Con->NET);
1577 /*cpt_transparence++;*/
1578 SetCgvBoxTaged(Box2);
1579 Cell2 = addcgvcel(Column);
1580 addcgvboxtocgvcel(Box2, Cell2);
1581 }
1582 }
1583 }
1584 #ifdef DEBUG
1585 fprintf(stdout,"loop:");fflush(stdout);
1586 #endif
1587 while ((Column->NUMBER_CELL != 0)
1588 && (Column->NUMBER_CELL != cpt_transparence)) {
1589 Column2 = Column;
1590 Column = addcgvcol();
1591 #ifdef DEBUG
1592 fprintf(stdout,".");fflush(stdout);
1593 #endif
1594
1595 cpt_transparence = 0;
1596
1597 cpt = Column2->NUMBER_CELL;
1598
1599 for (Cell = Column2->CELL;
1600 Cell != (cgvcel_list *) 0;
1601 Cell = Cell->NEXT) {
1602 if (Cell->TYPE == CGV_CEL_BOX) {
1603 Box = (cgvbox_list *) Cell->ROOT;
1604 SetCgvBoxReTaged(Box);
1605 }
1606 }
1607
1608 for (Cell = Column2->LAST_CELL; Cell!=NULL; Cell = (cgvcel_list *) Cell->PREV)
1609 {
1610 if (Cell->TYPE == CGV_CEL_BOX)
1611 {
1612 Box = (cgvbox_list *) Cell->ROOT;
1613 /* if (!IsCgvBoxTransparence(Box))
1614 for (Con = Box->CON_IN; Con ; Con = Con->NEXT)
1615 {
1616 for (Chain = Con->NET->CON_NET; Chain != NULL; Chain = Chain->NEXT)
1617 {
1618 Con2 = (cgvcon_list *) Chain->DATA;
1619 if (Con != Con2)
1620 {
1621 b=(cgvbox_list *) Con2->ROOT;
1622 if (IsCgvConIn(Con2) && IsCgvConInternal(Con2)
1623 && !IsCgvBoxTaged(b))
1624 {
1625 b->misc.UNDER=Box;
1626 SetCgvBoxTaged(b);
1627 SetCgvBoxReTaged(b);
1628 Cell2 = addcgvcel(Column2);
1629 addcgvboxtocgvcel(b, Cell2);
1630 // printf("add %s under %s\n",b->NAME,Box->NAME);
1631 }
1632 }
1633 }
1634
1635 }
1636 */
1637 if (!IsCgvBoxTransparence(Box))
1638 for (Con = Box->CON_OUT; Con ; Con = Con->NEXT)
1639 {
1640 for (Chain = Con->NET->CON_NET; Chain != NULL; Chain = Chain->NEXT)
1641 {
1642 Con2 = (cgvcon_list *) Chain->DATA;
1643 if (Con != Con2)
1644 {
1645 b=(cgvbox_list *) Con2->ROOT;
1646 if (IsCgvConOut(Con2) && IsCgvConInternal(Con2)
1647 && !IsCgvBoxReTaged(b))
1648 {
1649 if (!IsCgvBoxTaged(b))
1650 {
1651 b->misc.UNDER=Box;
1652 SetCgvBoxTaged(b);
1653 SetCgvBoxReTaged(b);
1654 Cell2 = addcgvcel(Column2);
1655 addcgvboxtocgvcel(b, Cell2);
1656 // printf("add %s under %s\n",b->NAME,Box->NAME);
1657 }
1658 else
1659 if (!IsCgvBoxReTaged(b) && loc_test_trans(Con2->NET, Column2))
1660 {
1661 Box4 = loc_add_transparence(Figure, Con2->NET);
1662 //Box4->NAME="2";
1663 SetCgvBoxTaged(Box4);
1664 SetCgvBoxReTaged(Box4);
1665 Cell2 = addcgvcel(Column2);
1666 addcgvboxtocgvcel(Box4, Cell2);
1667 Box4->misc.UNDER=Box;
1668 }
1669 }
1670
1671 if (!IsCgvBoxHit(b) && IsCgvConIn(Con2) && IsCgvConInternal(Con2)
1672 && !IsCgvBoxTaged(b))
1673 {
1674 // b->misc.UNDER=Box;
1675 SetCgvBoxTaged(b);
1676 // SetCgvBoxReTaged(b);
1677 Cell2 = addcgvcel(Column);
1678 addcgvboxtocgvcel(b, Cell2);
1679 // printf("add %s under %s\n",b->NAME,Box->NAME);
1680 }
1681 }
1682 }
1683
1684 }
1685 }
1686 }
1687
1688
1689 for (Cell = Column2->LAST_CELL; Cell!=NULL; Cell = Cell->PREV)
1690 {
1691 if (Cell->TYPE == CGV_CEL_BOX) {
1692 Box = (cgvbox_list *) Cell->ROOT;
1693 for (Con = Box->CON_IN; Con ; Con = Con->NEXT)
1694 {
1695 for (Chain = Con->NET->CON_NET; Chain != NULL; Chain = Chain->NEXT)
1696 {
1697 Con2 = (cgvcon_list *) Chain->DATA;
1698 b=(cgvbox_list *) Con2->ROOT;
1699 if (Con != Con2)
1700 {
1701 if (IsCgvConOut(Con2) && IsCgvConInternal(Con2)
1702 && !IsCgvBoxTaged(b))
1703 {
1704 SetCgvBoxTaged(b);
1705 Cell2 = addcgvcel(Column);
1706 addcgvboxtocgvcel(b, Cell2);
1707 }
1708 if (IsCgvConIn(Con2) && IsCgvConExternal(Con2)
1709 /*&& !IsCgvBoxTaged(b)*/ && loc_test_trans(Con2->NET, Column))
1710 {
1711 Box4 = loc_add_transparence(Figure, Con2->NET);
1712 Box4->NAME="3";
1713 cpt_transparence++;
1714 SetCgvBoxTaged(Box4);
1715 Cell2 = addcgvcel(Column);
1716 addcgvboxtocgvcel(Box4, Cell2);
1717 // Box4->misc.UNDER=b;
1718 }
1719 if (IsCgvConIn(Con2) && IsCgvConInternal(Con2)
1720 && !IsCgvBoxReTaged(b) && loc_test_trans(Con2->NET, Column))
1721 {
1722 Box4 = loc_add_transparence(Figure, Con2->NET);
1723 // printf("=2=> %s\n", Box->NAME);
1724 Box4->NAME="2";
1725 cpt_transparence++;
1726 SetCgvBoxTaged(Box4);
1727 Cell2 = addcgvcel(Column);
1728 addcgvboxtocgvcel(Box4, Cell2);
1729 Box4->misc.UNDER=b;
1730 }
1731 if (IsCgvConOut(Con2) && IsCgvConExternal(Con2)
1732 && loc_test_trans(Con2->NET, Column2))
1733 {
1734 // printf("=1=> %s\n", Box->NAME);
1735 Box4 = loc_add_transparence(Figure, Con2->NET);
1736 Box4->NAME="1";
1737 SetCgvBoxTaged(Box4);
1738 SetCgvBoxReTaged(Box4);
1739 Cell2 = addcgvcel(Column2);
1740 addcgvboxtocgvcel(Box4, Cell2);
1741 // Box4->misc.UNDER=b;
1742 }
1743 /* if (IsCgvConOut(Con2) && IsCgvConInternal(Con2) && !IsCgvBoxReTaged(b)
1744 && loc_test_trans(Con->NET, Column2))
1745 {
1746 Box4 = loc_add_transparence(Figure, Con2->NET);
1747 Box4->NAME="5";
1748 SetCgvBoxTaged(Box4);
1749 SetCgvBoxReTaged(Box4);
1750 Cell2 = addcgvcel(Column2);
1751 addcgvboxtocgvcel(Box4, Cell2);
1752 Box4->misc.UNDER=b;
1753 }*/
1754 }
1755 }
1756
1757 }
1758 if (!IsCgvBoxTransparence(Box))
1759 for (Con = Box->CON_OUT; Con ; Con = Con->NEXT)
1760 {
1761 for (Chain = Con->NET->CON_NET; Chain != NULL; Chain = Chain->NEXT)
1762 {
1763 Con2 = (cgvcon_list *) Chain->DATA;
1764 b=(cgvbox_list *) Con2->ROOT;
1765 if (Con != Con2)
1766 {
1767 if (IsCgvConIn(Con2) && IsCgvConInternal(Con2)
1768 && loc_test_trans(Con->NET, Column2))
1769 {
1770 if (!IsCgvBoxReTaged(b) || ((cgvcel_list *)b->USER)->COL==Column2)
1771 {
1772 BoxBox4 = loc_add_transparence(Figure, Con->NET);
1773 //BoxBox4->NAME = namealloc("OUT_In_Int_Tag");
1774 SetCgvBoxTaged(BoxBox4);
1775 SetCgvBoxReTaged(BoxBox4);
1776 BoxCell2 = addcgvcel(Column2);
1777 addcgvboxtocgvcel(BoxBox4, BoxCell2);
1778 BoxBox4->misc.UNDER=b;
1779 }
1780 }
1781 if (IsCgvConIn(Con2) && IsCgvConExternal(Con2)
1782 && loc_test_trans(Con->NET, Column2))
1783 {
1784 Box4 = loc_add_transparence(Figure, Con2->NET);
1785 //Box4->NAME="6";
1786 SetCgvBoxTaged(Box4);
1787 SetCgvBoxReTaged(Box4);
1788 Cell2 = addcgvcel(Column2);
1789 addcgvboxtocgvcel(Box4, Cell2);
1790 Box4->misc.UNDER=b;
1791 }
1792 }
1793 }
1794 }
1795 }
1796 }
1797 }
1798
1799 // les connecteurs externes d'entrees... +
1800 #ifdef DEBUG
1801 fprintf(stdout,"\n");
1802 #endif
1803 /*
1804 for (Cell = Column2->CELL; Cell != NULL; Cell = Cell->NEXT)
1805 {
1806 if (Cell->TYPE == CGV_CEL_BOX) {
1807 Box = (cgvbox_list *) Cell->ROOT;
1808 SetCgvBoxReTaged(Box);
1809 }
1810 }
1811 */
1812
1813 for (Box=Figure->BOX; Box!=NULL; Box=Box->NEXT)
1814 {
1815 if (!IsCgvBoxTaged(Box) && !IsCgvBoxTransparence(Box))
1816 {
1817 cgvnet_list *n;
1818 cgvcon_list *c;
1819 cgvcol_list *oldHEAD_CGVCOL;
1820
1821 n=addcgvnet(Figure);
1822 Box->CON_OUT=(cgvcon_list *)reverse((chain_list *)Box->CON_OUT);
1823 c=addcgvboxcon(Figure, Box, "$$**$$", CGV_CON_OUT);
1824 Box->CON_OUT=(cgvcon_list *)reverse((chain_list *)Box->CON_OUT);
1825 Box->NUMBER_OUT--;
1826 addcgvnetcon(n, c);
1827 c=addcgvfigcon(Figure, "$$**$$", CGV_CON_OUT);
1828 addcgvnetcon(n, c);
1829 oldHEAD_CGVCOL=HEAD_CGVCOL;
1830 HEAD_CGVCOL=NULL;
1831 #ifdef DEBUG
1832 fprintf(stdout,"placing unplaced from %s\n",Box->NAME);
1833 #endif
1834 unplaced++;
1835 Figure=loc_placement_initial(Figure);
1836 unplaced--;
1837
1838 // HEAD_CGVCOL=oldHEAD_CGVCOL;
1839 Column=HEAD_CGVCOL=merge(Figure, oldHEAD_CGVCOL, HEAD_CGVCOL);
1840 }
1841 }
1842
1843 if (unplaced!=0) return Figure;
1844
1845 Column2 = Column;
1846 Column = addcgvcol();
1847 cpt = Column2->NUMBER_CELL;
1848
1849 for (Cell = Column2->CELL; Cell!=NULL; Cell = (cgvcel_list *) Cell->NEXT)
1850 {
1851 if (Cell->TYPE == CGV_CEL_BOX)
1852 {
1853 Box = (cgvbox_list *) Cell->ROOT;
1854 Con2 = Box->CON_IN;
1855 for (Chain = Con2->NET->CON_NET; Chain != NULL; Chain = Chain->NEXT)
1856 {
1857 Con = (cgvcon_list *) Chain->DATA;
1858 if (IsCgvConExternal(Con) && IsCgvConIn(Con) && !IsCgvConTaged(Con))
1859 {
1860 Cell2 = addcgvcel(Column);
1861 addcgvcontocgvcel(Con, Cell2);
1862 SetCgvConTaged(Con);
1863 }
1864 }
1865 }
1866 }
1867
1868
1869
1870 /* printf("lost cell\n");
1871 loc_placelostcell(Column,Figure);
1872 */
1873 for (Con = Figure->CON_IN; Con != NULL; Con = Con->NEXT)
1874 {
1875 if (!IsCgvConTaged(Con))
1876 {
1877 // printf("-- %s\n",Con->NAME);
1878 Cell2 = addcgvcel(Column);
1879 addcgvcontocgvcel(Con, Cell2);
1880 SetCgvConUnTaged(Con);
1881 }
1882 }
1883
1884
1885
1886 return (Figure);
1887 }
1888
1889 /*------------------------------------------------------------\
1890 | Function Loc Build Box |
1891 \------------------------------------------------------------*/
1892
1893 void default_box(cgvbox_list *Box, int H_ref)
1894 {
1895 cgvcon_list *Con;
1896 long Y_cont1;
1897 long Y_cont2;
1898 float H_cell_ref;
1899 float H_cell_x;
1900 /*
1901 if(Box->SOURCE_TYPE == CGV_SOURCE_CNSCELL) {
1902 H_cell_ref = XYAG_DEFAULT_FACTOR * H_ref;
1903 H_cell_x = XYAG_DEFAULT_FACTOR;}
1904 else */{
1905 H_cell_ref = H_ref*0.7;
1906 H_cell_x = 1;
1907 }
1908
1909 if (Box->NUMBER_IN >= Box->NUMBER_OUT) {
1910 Box->DY = H_cell_ref * (Box->NUMBER_IN)*CGV_SCALE;
1911 Y_cont1 = Box->DY - (H_cell_ref / 2)*CGV_SCALE;
1912 Y_cont2 = Box->DY - (Box->NUMBER_IN - Box->NUMBER_OUT) * (H_cell_ref / 2)*CGV_SCALE - (H_cell_ref / 2)*CGV_SCALE;
1913 }
1914 else {
1915 Box->DY = H_cell_ref * ((Box->NUMBER_OUT)*CGV_SCALE);
1916 Y_cont1 = Box->DY - (Box->NUMBER_OUT - Box->NUMBER_IN) * (H_cell_ref / 2)*CGV_SCALE - (H_cell_ref / 2)*CGV_SCALE;
1917 Y_cont2 = Box->DY - (H_cell_ref / 2)*CGV_SCALE;
1918 }
1919 if (Box->DY<3*CGV_SCALE) Box->DY=3*CGV_SCALE;
1920 if (IsCgvBoxCluster(Box)) {
1921 //Box->DX = BOX_SIZE_MAX*CGV_SCALE;
1922 Box->DX = Box->DY * (1+exp(-(Box->NUMBER_IN))) / H_cell_x ;
1923 }
1924 else {
1925 if (IsCgvBoxTransparence(Box)) {
1926 //Box->DX = BOX_SIZE_MAX*CGV_SCALE;
1927 Box->DX = Box->DY * (1+exp(-(Box->NUMBER_IN))) / H_cell_x ;
1928 }
1929 else {
1930 if ( (Box->DY / (H_cell_x*1.5) ) >= BOX_SIZE_MAX*CGV_SCALE) {
1931 Box->DX = BOX_SIZE_MAX*CGV_SCALE;
1932 }
1933 else {
1934 if ( (Box->DY / (H_cell_x*1.5) ) <= BOX_SIZE_MIN*CGV_SCALE) {
1935 Box->DX = BOX_SIZE_MIN*CGV_SCALE;
1936 }
1937 else {
1938 Box->DX = Box->DY / (H_cell_x*1.5) ;
1939 }
1940 }
1941 }
1942 }
1943
1944 for (Con = Box->CON_IN;
1945 Con != (cgvcon_list *) 0;
1946 Con = Con->NEXT) {
1947 Con->X_REL = 0;
1948 Con->Y_REL = Y_cont1;
1949 Y_cont1 = Y_cont1 - H_cell_ref*CGV_SCALE;
1950 }
1951 for (Con = Box->CON_OUT;
1952 Con != (cgvcon_list *) 0;
1953 Con = Con->NEXT) {
1954 Con->X_REL = Box->DX ;
1955 Con->Y_REL = Y_cont2;
1956 Y_cont2 = Y_cont2 - H_cell_ref*CGV_SCALE;
1957 }
1958 }
1959
1960 cgvfig_list *loc_buildbox(cgvfig_list *Figure)
1961 {
1962 cgvbox_list *Box;
1963 long H_ref;
1964
1965 if ( Figure->LIBRARY != NULL)
1966 H_ref = Figure->LIBRARY->REFHEIGHT ;
1967 else
1968 H_ref = XYAG_DEFAULT_HEIGHT;
1969
1970 for (Box = Figure->BOX;
1971 Box != (cgvbox_list *) 0;
1972 Box = Box->NEXT) {
1973 if (Box->SYMBOL != NULL) {
1974
1975 slib_box *ptbound;
1976 cgvcon_list *ptcgvcon;
1977 pin *ptslibpin;
1978
1979 ptbound = Box->SYMBOL->BOX;
1980
1981 Box->DX = ptbound->X_MAX - ptbound->X_MIN ;
1982 Box->DY = ptbound->Y_MAX - ptbound->Y_MIN ;
1983
1984 for(ptcgvcon=Box->CON_IN;ptcgvcon;ptcgvcon=ptcgvcon->NEXT) {
1985 if (ptcgvcon->SUB_NAME!=NULL)
1986 ptslibpin = slib_getpin(Box->SYMBOL,ptcgvcon->SUB_NAME);
1987 else
1988 ptslibpin = slib_getpin(Box->SYMBOL,ptcgvcon->NAME);
1989
1990 if (ptslibpin==NULL)
1991 {
1992 default_box(Box, H_ref);
1993 Box->SYMBOL=NULL;
1994 break;
1995 }
1996 ptcgvcon->X_REL = ptslibpin->X - ptbound->X_MIN ;
1997 ptcgvcon->Y_REL = ptslibpin->Y - ptbound->Y_MIN ;
1998 }
1999 if (ptcgvcon) continue;
2000 for(ptcgvcon=Box->CON_OUT;ptcgvcon;ptcgvcon=ptcgvcon->NEXT) {
2001 if (strcmp(ptcgvcon->NAME,"$$**$$")==0) continue; // "fake for unplaced" connector
2002 if (ptcgvcon->SUB_NAME!=NULL)
2003 ptslibpin = slib_getpin(Box->SYMBOL,ptcgvcon->SUB_NAME);
2004 else
2005 ptslibpin = slib_getpin(Box->SYMBOL,ptcgvcon->NAME);
2006 if (ptslibpin==NULL)
2007 {
2008 default_box(Box, H_ref);
2009 Box->SYMBOL=NULL;
2010 break;
2011 }
2012 ptcgvcon->X_REL = ptslibpin->X - ptbound->X_MIN ;
2013 ptcgvcon->Y_REL = ptslibpin->Y - ptbound->Y_MIN ;
2014 }
2015
2016 }
2017 else {
2018 default_box(Box, H_ref);
2019 }
2020 }
2021 return (Figure);
2022 }
2023
2024 /*------------------------------------------------------------\
2025 | Function Loc Clean All |
2026 \------------------------------------------------------------*/
2027
2028 void loc_clean_all(Figure)
2029 cgvfig_list *Figure;
2030 {
2031 cgvbox_list *ScanBox;
2032
2033 for (ScanBox = Figure->BOX;
2034 ScanBox != (cgvbox_list *) 0;
2035 ScanBox = ScanBox->NEXT) {
2036 if (IsCgvBoxCluster(ScanBox)) {
2037 loc_destroycluster(Figure, ScanBox);
2038 }
2039 if (IsCgvBoxTransparence(ScanBox)) {
2040 loc_destroytransparence(Figure, ScanBox);
2041 }
2042 }
2043 delcgvcol();
2044 }
2045
2046 /*------------------------------------------------------------\
2047 | Function Set Scale |
2048 \------------------------------------------------------------*/
2049
2050 void
2051 cgv_setscale(scale)
2052 int scale;
2053 {
2054 CGV_SCALE = scale;
2055 }
2056
2057 /*------------------------------------------------------------\
2058 | Function Build |
2059 \------------------------------------------------------------*/
2060
2061
2062 /* zinaps */
2063 FILE *f;
2064
2065 int comp_y(const void *a, const void *b)
2066 {
2067 cgvcel_list *a0=*(cgvcel_list **)a;
2068 cgvcel_list *b0=*(cgvcel_list **)b;
2069 int ay, by;
2070 if (a0->TYPE == CGV_CEL_BOX) ay=((cgvbox_list *)a0->ROOT)->Y;
2071 else ay=((cgvcon_list *)a0->ROOT)->Y_REL;
2072 if (b0->TYPE == CGV_CEL_BOX) by=((cgvbox_list *)b0->ROOT)->Y;
2073 else by=((cgvcon_list *)b0->ROOT)->Y_REL;
2074 if (ay<by) return -1;
2075 if (ay>by) return 1;
2076 return 0;
2077 }
2078
2079 int comp_name(const void *a, const void *b)
2080 {
2081 cgvcel_list **a0=(cgvcel_list **)a;
2082 cgvcel_list **b0=(cgvcel_list **)b;
2083 if (strcmp(((cgvcon_list *)(*a0)->ROOT)->NAME,((cgvcon_list *)(*b0)->ROOT)->NAME)<0) return -1;
2084 if (strcmp(((cgvcon_list *)(*a0)->ROOT)->NAME,((cgvcon_list *)(*b0)->ROOT)->NAME)>0) return 1;
2085 return 0;
2086 }
2087
2088
2089 #define POUR_SORTIES 0
2090 #define POUR_ENTREES 1
2091 #define FAILED_MOYENNE -123456
2092
2093 int addmarge(cgvbox_list *box)
2094 {
2095 if (!IsCgvBoxTransparence(box)) return MARGE;
2096 return 0;
2097 }
2098
2099 //static int DEBUG=0;
2100
2101 int comp_moyenne(cgvcon_list *con, cgvcol_list *pred, int dir)
2102 {
2103 chain_list *cl;
2104 cgvcon_list *con0;
2105 cgvcel_list *c;
2106 int cmoyenne=0, cnb=0, hastransp=1;
2107 cgvbox_list *b0;
2108 for (cl = con->NET->CON_NET; cl!=NULL; cl=cl->NEXT)
2109 {
2110 con0 = (cgvcon_list *) cl->DATA;
2111 b0=(cgvbox_list *)con0->ROOT;
2112
2113 if (con0!=con/* && IsCgvBoxTaged(b0)*/)
2114 {
2115 if (IsCgvConExternal(con0))
2116 {
2117 c=(cgvcel_list *)con0->USER;
2118 if (c->COL==pred && ((dir==POUR_SORTIES && IsCgvConIn(con0)) || (dir==POUR_ENTREES && IsCgvConOut(con0))))
2119 {
2120 if (hastransp) { cnb=0; cmoyenne=0; hastransp=0; }
2121 cmoyenne+=con0->Y_REL; cnb++;
2122 // if (DEBUG) printf("c+(%s): %d ",con0->NAME,con0->Y_REL);
2123 }
2124 }
2125 else
2126 {
2127 c=(cgvcel_list *)b0->USER;
2128 if ((!IsCgvBoxTransparence(b0)
2129 && ((dir==POUR_SORTIES && IsCgvConOut(con0))
2130 || (dir==POUR_ENTREES && IsCgvConIn(con0))))
2131 || (hastransp && IsCgvBoxTransparence(b0) && IsCgvConIn(con0)))
2132 {
2133 if (/*IsCgvBoxTaged(b0) &&*/ c->COL==pred)
2134 {
2135 if (!IsCgvBoxTransparence(b0) && hastransp)
2136 { cnb=0; cmoyenne=0; hastransp=0; }
2137 cmoyenne+=b0->Y+con0->Y_REL; cnb++;
2138 // if (DEBUG) printf("c1(%s)+: %d ",con0->NAME,con0->Y_REL);
2139 }
2140 }
2141 }
2142 }
2143 }
2144 if (cnb==0) return FAILED_MOYENNE;
2145 return cmoyenne/cnb;
2146 }
2147
2148 int comp_moyenne_last_chance(cgvcon_list *con)
2149 {
2150 chain_list *cl;
2151 cgvcon_list *con0;
2152 int cmoyenne=0, cnb=0;
2153 cgvbox_list *b0;
2154 for (cl = con->NET->CON_NET; cl!=NULL; cl=cl->NEXT)
2155 {
2156 con0 = (cgvcon_list *) cl->DATA;
2157 b0=(cgvbox_list *)con0->ROOT;
2158 // if (!IsCgvBoxTaged(b0)) continue;
2159 if (con0!=con)
2160 {
2161 if (IsCgvConExternal(con0))
2162 {
2163 cmoyenne+=con0->Y_REL; cnb++;
2164 }
2165 else
2166 {
2167 if (!IsCgvBoxTransparence(b0)
2168 || (IsCgvBoxTransparence(b0) && IsCgvConIn(con0)))
2169 {
2170 cmoyenne+=b0->Y+con0->Y_REL; cnb++;
2171 }
2172 }
2173 }
2174 }
2175 if (cnb==0) return FAILED_MOYENNE;
2176 return cmoyenne/cnb;
2177 }
2178 int comp_moyenne_sans_transparence(cgvcon_list *con)
2179 {
2180 chain_list *cl;
2181 cgvcon_list *con0;
2182 // cgvcel_list *c;
2183 int upper=12345678, y=FAILED_MOYENNE;
2184 cgvbox_list *b0;
2185 for (cl = con->NET->CON_NET; cl!=NULL; cl=cl->NEXT)
2186 {
2187 con0 = (cgvcon_list *) cl->DATA;
2188 b0=(cgvbox_list *)con0->ROOT;
2189 if (!IsCgvBoxTaged(b0)) continue;
2190 if (con0!=con)
2191 {
2192 if (IsCgvConExternal(con0))
2193 {
2194 y=con0->Y_REL;
2195 if (y<upper) upper=y;
2196 }
2197 else
2198 {
2199 if (!IsCgvBoxTransparence(b0))
2200 {
2201 y=b0->Y-MARGE;
2202 if (y<upper) upper=y;
2203 }
2204 }
2205 }
2206 }
2207 return y;
2208 }
2209
2210
2211 chain_list *move_all_transparence_to(cgvcon_list *con, int y)
2212 {
2213 chain_list *cl, *cl1=NULL;
2214 cgvcon_list *con0;
2215 cgvbox_list *b0;
2216 for (cl = con->NET->CON_NET; cl!=NULL; cl=cl->NEXT)
2217 {
2218 con0 = (cgvcon_list *) cl->DATA;
2219 b0=(cgvbox_list *)con0->ROOT;
2220 if (!IsCgvConExternal(con0) && !IsCgvBoxTaged(b0) &&
2221 (!IsCgvBoxTransparence(b0) || (IsCgvBoxTransparence(b0) && IsCgvConIn(con0))))
2222 {
2223 b0->Y=y;
2224 cl1=addchain(cl1, b0);
2225 }
2226 }
2227 return cl1;
2228 }
2229
2230
2231
2232 int notplacedmode=0;
2233
2234 void aligner_par_rapport_aux_entrees(cgvcol_list *cur, cgvcol_list *pred, int avoidinterface)
2235 {
2236 cgvcon_list *con;
2237 cgvcel_list *cell;
2238 int cmoyenne, cnb, tmoyenne, tmoyenne0, tnb;
2239 cgvbox_list *box;
2240
2241 if (pred==NULL)
2242 {
2243 int y=0, cnt;
2244 cgvcel_list **tab;
2245 if (!avoidinterface)
2246 {
2247 for (cell = cur->CELL, cnt=0; cell; cell = cell->NEXT, cnt++) ;
2248
2249 tab=(cgvcel_list **)mbkalloc(sizeof(cgvcel_list *)*cnt);
2250 for (cell = cur->CELL, cnt=0; cell; cell = cell->NEXT, cnt++) tab[cnt]=cell;
2251
2252 qsort(tab, cnt, sizeof(cgvcel_list *), comp_name);
2253
2254 for (y= 0; y<cnt; y++)
2255 {
2256 con = (cgvcon_list *) tab[y]->ROOT;
2257 con->Y_REL = y*100*CGV_SCALE;
2258 box = (cgvbox_list *)con->ROOT;
2259 // fprintf(f,"con %s: y=%d\n",con->NAME, y);
2260 }
2261 mbkfree(tab);
2262 }
2263 }
2264 else
2265 {
2266 for (cell = cur->CELL; cell; cell = cell->NEXT)
2267 {
2268
2269 if (cell->TYPE == CGV_CEL_BOX)
2270 {
2271 // les boites normales
2272 box = (cgvbox_list *) cell->ROOT;
2273 tnb=0; tmoyenne=0;
2274 // if (strcmp(box->NAME,"tr_00589")==0) DEBUG=1;
2275 for (con = box->CON_OUT; con!=NULL; con=con->NEXT)
2276 {
2277 cmoyenne=comp_moyenne(con, pred, POUR_ENTREES);
2278 if (cmoyenne!=FAILED_MOYENNE)
2279 {
2280 tmoyenne+=cmoyenne-con->Y_REL; tnb++;
2281 }
2282 }
2283 for (con = box->CON_IN, cnb=0, tmoyenne0=0; con!=NULL; con=con->NEXT)
2284 {
2285 cmoyenne=comp_moyenne(con, cur->NEXT, POUR_SORTIES);
2286 if (cmoyenne!=FAILED_MOYENNE)
2287 {
2288 tmoyenne0+=cmoyenne-con->Y_REL; cnb++;
2289 }
2290 }
2291 // if (strcmp(box->NAME,"transparence_49")==0) printf("(0)%s: %d %d\n",box->NAME,tnb, cnb);
2292 if (tnb==0 || cnb==0) {SetCgvBoxUnTaged(box);/*printf("2.untag %d %d %s\n",tnb, cnb,box->NAME);*/}
2293 if (tnb==0) { tmoyenne=tmoyenne0; tnb=cnb; }
2294 if (tnb!=0) box->Y=(tmoyenne/tnb);
2295 // DEBUG=0;
2296 // fprintf(f,"/ %s: tmoy=%d (%d) %s\n",box->NAME,tmoyenne, tnb,IsCgvBoxTaged(box)?"tagged":"x");
2297 }
2298 else
2299 {
2300 con = (cgvcon_list *) cell->ROOT;
2301 cmoyenne=comp_moyenne(con, pred, POUR_ENTREES);
2302 // if (cmoyenne==FAILED_MOYENNE) {/*fprintf(f,"on %s.%s\n",box->NAME,con->NAME);*/EXIT(5);}
2303 if (cmoyenne!=FAILED_MOYENNE) con->Y_REL=cmoyenne;
2304 // fprintf(f,">%s> %s: cmoy=%d (%d)\n",con->NAME,box->NAME,cnb, cmoyenne);
2305 }
2306 }
2307 }
2308 }
2309
2310 void aligner_par_rapport_aux_sorties(cgvcol_list *cur, cgvcol_list *pred, int avoidinterface)
2311 {
2312 cgvcon_list *con;
2313 cgvcel_list *cell;
2314 int cmoyenne, cnb, tmoyenne, tnb, tmoyenne0;
2315 cgvbox_list *box;
2316
2317 if (pred==NULL)
2318 {
2319 int y=0;
2320 if (!avoidinterface)
2321 {
2322 for (cell = cur->CELL; cell; cell = cell->NEXT)
2323 {
2324 con = (cgvcon_list *) cell->ROOT;
2325 con->Y_REL = y;
2326 // fprintf(f,"con %s: y=%d\n",con->NAME, y);
2327 y+=100*CGV_SCALE;
2328 }
2329 }
2330 }
2331 else
2332 {
2333 for (cell = cur->CELL; cell; cell = cell->NEXT)
2334 {
2335
2336 if (cell->TYPE == CGV_CEL_BOX)
2337 {
2338 // les boites normales
2339 box = (cgvbox_list *) cell->ROOT;
2340 tnb=0; tmoyenne=0;
2341 for (con = box->CON_IN; con!=NULL; con=con->NEXT)
2342 {
2343 cmoyenne=comp_moyenne(con, pred, POUR_SORTIES);
2344 if (cmoyenne!=FAILED_MOYENNE)
2345 {
2346 tmoyenne+=cmoyenne-con->Y_REL; tnb++;
2347 }
2348 }
2349 for (con = box->CON_OUT, cnb=0, tmoyenne0=0; con!=NULL; con=con->NEXT)
2350 {
2351 cmoyenne=comp_moyenne(con, cur->NEXT, POUR_ENTREES);
2352 if (cmoyenne!=FAILED_MOYENNE)
2353 {
2354 tmoyenne0+=cmoyenne-con->Y_REL; cnb++;
2355 }
2356 }
2357 // if (strcmp(box->NAME,"transparence_49")==0) printf("(1)%s: %d %d\n",box->NAME,tnb, cnb);
2358 if (tnb==0 || cnb==0) {SetCgvBoxUnTaged(box);/*printf("untag %d %d %s\n",tnb, cnb,box->NAME);*/}
2359 if (tnb==0) { tmoyenne=tmoyenne0; tnb=cnb; }
2360
2361 if (tnb!=0) box->Y=(tmoyenne/tnb);
2362 // fprintf(f,"> %s: tmoy=%d (%d) %s\n",box->NAME,tmoyenne, tnb,IsCgvBoxTaged(box)?"tagged":"x");
2363 }
2364 else
2365 {
2366 con = (cgvcon_list *) cell->ROOT;
2367
2368 cmoyenne=comp_moyenne(con, pred, POUR_SORTIES);
2369 // if (cmoyenne==FAILED_MOYENNE) {fprintf(f,"on %s.%s\n",box->NAME,con->NAME);EXIT(8);}
2370 if (cmoyenne!=FAILED_MOYENNE) con->Y_REL=cmoyenne;
2371
2372 // fprintf(f,">%s> %s: cmoy=%d (%d)\n",con->NAME,box->NAME, cmoyenne, cnb);
2373 }
2374 }
2375 }
2376 }
2377 void justuntagiffree(cgvcol_list *cur, cgvcol_list *pred)
2378 {
2379 cgvcon_list *con;
2380 cgvcel_list *cell;
2381 int cmoyenne, cnb, tmoyenne, tnb, tmoyenne0;
2382 cgvbox_list *box;
2383
2384 if (pred==NULL) return;
2385
2386 for (cell = cur->CELL; cell; cell = cell->NEXT)
2387 {
2388
2389 if (cell->TYPE == CGV_CEL_BOX)
2390 {
2391 // les boites normales
2392 box = (cgvbox_list *) cell->ROOT;
2393 tnb=0; tmoyenne=0;
2394 for (con = box->CON_IN; con!=NULL; con=con->NEXT)
2395 {
2396 cmoyenne=comp_moyenne(con, pred, POUR_SORTIES);
2397 if (cmoyenne!=FAILED_MOYENNE)
2398 {
2399 tmoyenne+=cmoyenne-con->Y_REL; tnb++;
2400 }
2401 }
2402 for (con = box->CON_OUT, cnb=0, tmoyenne0=0; con!=NULL; con=con->NEXT)
2403 {
2404 cmoyenne=comp_moyenne(con, cur->NEXT, POUR_ENTREES);
2405 if (cmoyenne!=FAILED_MOYENNE)
2406 {
2407 tmoyenne0+=cmoyenne-con->Y_REL; cnb++;
2408 }
2409 }
2410 if (tnb==0 || cnb==0) {SetCgvBoxUnTaged(box);/*printf("3. untag %d %d %s\n",tnb, cnb,box->NAME);*/}
2411
2412 }
2413 }
2414 }
2415
2416 void aligner_par_rapport_aux_sorties_et_aux_entrees(cgvcol_list *cur, cgvcol_list *pred)
2417 {
2418 cgvcon_list *con;
2419 cgvcel_list *cell;
2420 int cmoyenne, tmoyenne, tnb;
2421 cgvbox_list *box;
2422
2423 #ifndef __ALL__WARNING__
2424 pred = NULL;
2425 #endif
2426
2427 for (cell = cur->CELL; cell; cell = cell->NEXT)
2428 {
2429 if (cell->TYPE == CGV_CEL_BOX)
2430 {
2431 // les boites normales
2432 box = (cgvbox_list *) cell->ROOT;
2433 if (!IsCgvBoxTaged(box))
2434 {
2435 tnb=0; tmoyenne=0;
2436 for (con = box->CON_IN; con!=NULL; con=con->NEXT)
2437 {
2438 // cmoyenne=comp_moyenne(con, pred, POUR_SORTIES);
2439 cmoyenne=comp_moyenne_sans_transparence(con);
2440 if (cmoyenne!=FAILED_MOYENNE)
2441 {
2442 tmoyenne+=cmoyenne-con->Y_REL; tnb++;
2443 }
2444 }
2445 for (con = box->CON_OUT; con!=NULL; con=con->NEXT)
2446 {
2447 // cmoyenne=comp_moyenne(con, cur->NEXT, POUR_ENTREES);
2448 cmoyenne=comp_moyenne_sans_transparence(con);
2449 if (cmoyenne!=FAILED_MOYENNE)
2450 {
2451 tmoyenne+=cmoyenne-con->Y_REL; tnb++;
2452 }
2453 }
2454
2455 if (tnb!=0)
2456 {
2457 box->Y=(tmoyenne/tnb);
2458 // fprintf(f,"MOVED %s: tmoy=%d (%d)\n",box->NAME,tmoyenne, tnb);
2459 }
2460 }
2461 }
2462 }
2463 }
2464
2465 int find_space_for(cgvcol_list *c, int y, int size)
2466 {
2467 cgvcel_list *cell, **tab;
2468 int cnt=0, i;
2469 cgvbox_list *box, *box1;
2470
2471 for (cell = c->CELL, cnt=0; cell; cell = cell->NEXT)
2472 {
2473 // box=(cgvbox_list *)cell->ROOT;
2474 /* if (IsCgvBoxTaged(box))*/ cnt++;
2475 }
2476
2477 tab=(cgvcel_list **)mbkalloc(sizeof(cgvcel_list *)*cnt);
2478 for (cell = c->CELL, cnt=0; cell; cell = cell->NEXT)
2479 {
2480 /* box=(cgvbox_list *)cell->ROOT;
2481 if (IsCgvBoxTaged(box))*/ { tab[cnt++]=cell; }
2482 }
2483
2484 qsort(tab, cnt, sizeof(cgvcel_list *), comp_y);
2485
2486 for (i=cnt-1;i>=0;i--)
2487 {
2488 box=(cgvbox_list *)tab[i]->ROOT;
2489 if (box->Y<y) break;
2490 }
2491
2492 if (i<0)
2493 {
2494 if (y-size<=box->Y) {mbkfree(tab);return y;}
2495 }
2496 else
2497 if (i==cnt-1)
2498 {
2499 if (y>=box->Y+box->DY) {mbkfree(tab);return y;}
2500 }
2501 else
2502 {
2503 box1=(cgvbox_list *)tab[i+1]->ROOT;
2504 if (box1->Y-(box->Y+box->DY+addmarge(box))>=size && box1->Y-size<y) {mbkfree(tab); return box1->Y-size;}
2505 if (y>=box->Y+box->DY && y+size<=box1->Y){mbkfree(tab);return y;}
2506 }
2507
2508 i--;
2509 // if (i>=0) fprintf(f,"h(%s),",box->NAME);
2510 while (i>=0)
2511 {
2512 box=(cgvbox_list *)tab[i]->ROOT;
2513 box1=(cgvbox_list *)tab[i+1]->ROOT;
2514 // fprintf(f,"%s-%s=%d,",box1->NAME,box->NAME,box1->Y-(box->Y+box->DY));
2515 if (box1->Y-(box->Y+box->DY+addmarge(box))>=size) {mbkfree(tab);return box1->Y-size;}
2516 i--;
2517 }
2518 box=(cgvbox_list *)tab[0]->ROOT;
2519 mbkfree(tab);
2520 // fprintf(f,"B");
2521 return box->Y-size;
2522 }
2523
2524 int find_space_for2(cgvcol_list *c, int y, int size)
2525 {
2526 cgvcel_list *cell, **tab;
2527 int cnt=0, i;
2528 cgvbox_list *box, *box1;
2529
2530 for (cell = c->CELL, cnt=0; cell; cell = cell->NEXT)
2531 {
2532 // box=(cgvbox_list *)cell->ROOT;
2533 /* if (IsCgvBoxTaged(box))*/ cnt++;
2534 }
2535
2536 tab=(cgvcel_list **)mbkalloc(sizeof(cgvcel_list *)*cnt);
2537 for (cell = c->CELL, cnt=0; cell; cell = cell->NEXT)
2538 {
2539 tab[cnt++]=cell;
2540 }
2541
2542 qsort(tab, cnt, sizeof(cgvcel_list *), comp_y);
2543
2544 for (i=cnt-1;i>=0;i--)
2545 {
2546 box=(cgvbox_list *)tab[i]->ROOT;
2547 if (box->Y<y) break;
2548 }
2549
2550 if (i<0)
2551 {
2552 if (y-size<=box->Y) {mbkfree(tab);return y;}
2553 }
2554 else
2555 if (i==cnt-1)
2556 {
2557 if (y>=box->Y+box->DY) {mbkfree(tab);return y;}
2558 }
2559 else
2560 {
2561 box1=(cgvbox_list *)tab[i+1]->ROOT;
2562 if (box1->Y-(box->Y+box->DY+addmarge(box))>=size && box1->Y-size<y) {mbkfree(tab); return box1->Y-size;}
2563 if (y>=box->Y+box->DY && y+size<=box1->Y){mbkfree(tab);return y;}
2564 }
2565
2566 i++;
2567 // if (i>=0) fprintf(f,"h(%s),",box->NAME);
2568 while (i<cnt-1)
2569 {
2570 box=(cgvbox_list *)tab[i]->ROOT;
2571 box1=(cgvbox_list *)tab[i+1]->ROOT;
2572 // fprintf(f,"%s-%s=%d,",box1->NAME,box->NAME,box1->Y-(box->Y+box->DY));
2573 if (box1->Y-(box->Y+box->DY+addmarge(box))>=size) {mbkfree(tab);return box1->Y-size;}
2574 i++;
2575 }
2576 box=(cgvbox_list *)tab[cnt-1]->ROOT;
2577 mbkfree(tab);
2578 // fprintf(f,"B");
2579 return box->Y+box->DY+addmarge(box);
2580 }
2581
2582 int tasser_les_non_places(cgvcol_list *c, int moy)
2583 {
2584 cgvcel_list *cell, **tab;
2585 int cnt=0, i, cury=FAILED_MOYENNE, cury1=FAILED_MOYENNE, cc=0, concc=0;
2586 int bcury, bcury1;
2587 cgvbox_list *box;
2588 cgvcon_list *con;
2589
2590 for (cell = c->CELL, cnt=0; cell; cell = cell->NEXT) cnt++;
2591
2592 if (cnt==0) return 0;
2593
2594 tab=(cgvcel_list **)mbkalloc(sizeof(cgvcel_list *)*cnt);
2595 for (cell = c->CELL, cnt=0; cell; cell = cell->NEXT)
2596 {
2597 tab[cnt++]=cell;
2598 }
2599
2600 qsort(tab, cnt, sizeof(cgvcel_list *), comp_y);
2601
2602 cury=FAILED_MOYENNE; //((cgvbox_list *)(tab[cnt-1]->ROOT))->Y;
2603 for (i=cnt-1;i>=0;i--)
2604 {
2605 if (tab[i]->TYPE == CGV_CEL_BOX)
2606 {
2607 box=(cgvbox_list *)tab[i]->ROOT;
2608 // printf("TG: %s\n",box->NAME);
2609 if (IsCgvBoxTaged(box))
2610 {
2611 if (cury==FAILED_MOYENNE) { cury=box->Y+box->DY+addmarge(box); bcury=cury;/* printf("-- top=%s\n",box->NAME);*/ }
2612 cury1=box->Y;
2613 }
2614 if (!IsCgvBoxTaged(box))
2615 {
2616 cc++;
2617 // fprintf(f,"isuntag %s\n",box->NAME);
2618 }
2619 }
2620 else
2621 {
2622 con = (cgvcon_list *) tab[i]->ROOT;
2623 // printf("%s: %d\n",con->NAME, con->Y_REL);
2624 if (IsCgvConTaged(con))
2625 {
2626 if (cury==FAILED_MOYENNE) { cury=con->Y_REL+MARGE; bcury=cury; }
2627 cury1=con->Y_REL;
2628 }
2629
2630 if (!IsCgvConTaged(con))
2631 {
2632 /*printf("%s\n",con->NAME);*/
2633 cc++;
2634 concc++;
2635 }
2636 }
2637 }
2638 // printf("cc=%d, cury=%d, moy=%d\n",cc,cury,moy);
2639 if (cc==0 || (concc==0 && cury==FAILED_MOYENNE)) { mbkfree(tab); return 0; }
2640 if (cury==FAILED_MOYENNE) { cury1=cury=moy; bcury=cury; }
2641
2642 bcury1=cury1;
2643
2644 for (i=0;i<cnt;i++)
2645 {
2646 if (tab[i]->TYPE == CGV_CEL_BOX)
2647 {
2648 box=(cgvbox_list *)tab[i]->ROOT;
2649 // if (!IsCgvBoxTaged(box)) printf("-1> %s %d\n",box->NAME,box->Y);
2650 if (!IsCgvBoxTaged(box) && box->Y>=bcury)
2651 {
2652 box->Y=cury;
2653 cury=box->Y+box->DY+addmarge(box);
2654 // printf("2. %s\n",box->NAME);
2655 }
2656 }
2657 else
2658 {
2659 con = (cgvcon_list *) tab[i]->ROOT;
2660 // printf("%s: [%d]\n",con->NAME, bcury);
2661 if (!IsCgvConTaged(con) && con->Y_REL>=bcury)
2662 {
2663 // printf("2. %s\n",con->NAME);
2664 con->Y_REL=cury+ MARGE;
2665 cury=con->Y_REL;
2666 // SetCgvConTaged(con);
2667 }
2668 }
2669 }
2670
2671 for (i=cnt-1;i>=0;i--)
2672 {
2673 if (tab[i]->TYPE == CGV_CEL_BOX)
2674 {
2675 box=(cgvbox_list *)tab[i]->ROOT;
2676 // if (!IsCgvBoxTaged(box)) printf("-2> %s %d\n",box->NAME,box->Y);
2677 if (!IsCgvBoxTaged(box) && box->Y<=bcury1)
2678 {
2679 box->Y=cury1-(box->DY+addmarge(box));
2680 cury1=box->Y;
2681 // printf("1. %s\n",box->NAME);
2682 }
2683 }
2684 else
2685 {
2686 con = (cgvcon_list *) tab[i]->ROOT;
2687 // printf("%s: [%d]\n",con->NAME, bcury1);
2688 if (!IsCgvConTaged(con) && con->Y_REL<=bcury1)
2689 {
2690 // printf("1. %s\n",con->NAME);
2691 con->Y_REL=cury1-MARGE;
2692 cury1=con->Y_REL;
2693 // SetCgvConTaged(con);
2694 }
2695 }
2696 }
2697 mbkfree(tab);
2698 return cc;
2699 }
2700
2701 void essayer_d_aligner_par_rapport_aux_entrees(cgvcol_list *cur, cgvcol_list *pred)
2702 {
2703 cgvcon_list *con;
2704 cgvcel_list *cell;
2705 int cmoyenne, y, tmoyenne, tnb, besty;
2706 cgvbox_list *box;
2707
2708 for (cell = cur->CELL; cell; cell = cell->NEXT)
2709 {
2710
2711 if (cell->TYPE == CGV_CEL_BOX)
2712 {
2713 // les boites normales
2714 box = (cgvbox_list *) cell->ROOT;
2715 tnb=0; tmoyenne=0;
2716 besty=FAILED_MOYENNE;
2717 for (con = box->CON_OUT; con!=NULL; con=con->NEXT)
2718 {
2719 cmoyenne=comp_moyenne(con, pred, POUR_ENTREES);
2720 if (cmoyenne!=FAILED_MOYENNE)
2721 {
2722 tmoyenne+=cmoyenne-con->Y_REL; tnb++;
2723 }
2724 }
2725 if (tnb!=0) {besty=tmoyenne/tnb;}
2726 else
2727 {
2728 for (con = box->CON_OUT; con!=NULL; con=con->NEXT)
2729 {
2730 cmoyenne=comp_moyenne(con, pred, POUR_SORTIES);
2731 if (cmoyenne!=FAILED_MOYENNE)
2732 {
2733 tmoyenne+=cmoyenne-con->Y_REL; tnb++;
2734 }
2735 }
2736 if (tnb!=0) {besty=tmoyenne/tnb;}
2737 else
2738 {
2739 for (con = box->CON_OUT; con!=NULL; con=con->NEXT)
2740 {
2741 cmoyenne=comp_moyenne(con, cur, POUR_SORTIES);
2742 if (cmoyenne!=FAILED_MOYENNE)
2743 {
2744 tmoyenne+=cmoyenne-con->Y_REL; tnb++;
2745 }
2746 }
2747 if (tnb!=0) {besty=tmoyenne/tnb;}
2748 else
2749 {
2750 for (con = box->CON_OUT; con!=NULL; con=con->NEXT)
2751 {
2752 cmoyenne=comp_moyenne(con, cur, POUR_ENTREES);
2753 if (cmoyenne!=FAILED_MOYENNE)
2754 {
2755 tmoyenne+=cmoyenne-con->Y_REL; tnb++;
2756 }
2757 }
2758 if (tnb!=0) {besty=tmoyenne/tnb;}
2759 }
2760 }
2761 }
2762
2763 // fprintf(f,"try %s: tmoy=%d \n",box->NAME, tmoyenne/tnb);
2764
2765 if (besty!=FAILED_MOYENNE)
2766 {
2767 int y0;
2768 y=find_space_for(cur, besty, box->DY+addmarge(box));
2769 y0=find_space_for2(cur, besty, box->DY+addmarge(box));
2770 /* if (strcmp(box->NAME,"transparence_36")==0
2771 || strcmp(box->NAME,"nand3_d")==0
2772 )
2773 printf("%s: y=%d y0=%d, besty=%d %d %d\n",box->NAME,y,y0,besty,tmoyenne,tnb);*/
2774 if (abs(box->Y-besty)>abs(besty-y))
2775 box->Y=y;
2776 if (abs(box->Y-besty)>abs(besty-y0))
2777 box->Y=y0;
2778 }
2779 }
2780 else
2781 {
2782 con = (cgvcon_list *) cell->ROOT;
2783 cmoyenne=comp_moyenne(con, pred, POUR_ENTREES);
2784 con->Y_REL=cmoyenne;
2785 }
2786 }
2787 }
2788
2789 chain_list *aligner_les_transparences_de_boucle(cgvcol_list *cur)
2790 {
2791 cgvcel_list *cell;
2792 int y;
2793 cgvbox_list *box;
2794
2795 for (cell = cur->CELL; cell; cell = cell->NEXT)
2796 {
2797 if (cell->TYPE == CGV_CEL_BOX)
2798 {
2799 // les boites normales
2800 box = (cgvbox_list *) cell->ROOT;
2801 if (!IsCgvBoxTaged(box)/* && IsCgvBoxTransparence(box)*/)
2802 {
2803 y=comp_moyenne_sans_transparence(box->CON_IN);
2804 return move_all_transparence_to(box->CON_IN, y);
2805 }
2806 }
2807 }
2808 return NULL;
2809 }
2810
2811 static cgvfig_list *loc_laisser_pendouiller_out_vers_in(cgvfig_list *Figure, int avoidinterface)
2812 {
2813 cgvcol_list *Column_from=NULL;
2814 cgvcol_list *Column_to;
2815
2816 HEAD_CGVCOL = (cgvcol_list *) reverse((chain_list *) HEAD_CGVCOL);
2817 #ifdef DEBUG
2818 fprintf(stdout,"pendouillage:");
2819 #endif
2820 for (Column_to = HEAD_CGVCOL;
2821 Column_to != NULL;
2822 Column_to = Column_to->NEXT) {
2823 #ifdef DEBUG
2824 fprintf(stdout,"."); fflush(stdout);
2825 #endif
2826 aligner_par_rapport_aux_entrees(Column_to, Column_from, avoidinterface);
2827 Column_from = Column_to;
2828
2829 }
2830 #ifdef DEBUG
2831 fprintf(stdout,"\n");
2832 #endif
2833 HEAD_CGVCOL = (cgvcol_list *) reverse((chain_list *) HEAD_CGVCOL);
2834 // fclose(f);
2835 return (Figure);
2836 }
2837 /*
2838 static cgvfig_list *loc_laisser_pendouiller_in_vers_out(cgvfig_list *Figure, int avoidinterface)
2839 {
2840 cgvcol_list *Column_from=NULL;
2841 cgvcol_list *Column_to;
2842
2843 for (Column_to = HEAD_CGVCOL;
2844 Column_to != NULL;
2845 Column_to = Column_to->NEXT) {
2846
2847 aligner_par_rapport_aux_sorties(Column_to, Column_from, avoidinterface);
2848 Column_from = Column_to;
2849
2850 }
2851
2852 return (Figure);
2853 }
2854 */
2855
2856 int colsize(cgvcol_list *cur)
2857 {
2858 cgvcel_list *cell;
2859 int size=0;
2860 cgvbox_list *box;
2861
2862 for (cell = cur->CELL; cell; cell = cell->NEXT)
2863 {
2864 if (cell->TYPE == CGV_CEL_BOX)
2865 {
2866 // les boites normales
2867 box = (cgvbox_list *) cell->ROOT;
2868 // fprintf(f,"%s ",box->NAME);
2869 size+=box->DY;
2870 }
2871 }
2872
2873 // fprintf(f,"= %d\n",size);
2874 return size;
2875 }
2876
2877 void displaycol(cgvcol_list *c)
2878 {
2879 cgvcel_list *cell;
2880 cgvbox_list *box;
2881
2882 for (cell = c->CELL; cell; cell = cell->NEXT)
2883 {
2884 if (cell->TYPE == CGV_CEL_BOX)
2885 {
2886 box = (cgvbox_list *) cell->ROOT;
2887 // printf("->%s\n",box->NAME);
2888 /* if (strcmp(box->NAME,"tr_00589")==0)
2889 printf("%s :HERE\n",box->NAME);*/
2890 }
2891 }
2892 }
2893
2894 static cgvcol_list *highestcolumn()
2895 {
2896 cgvcol_list *c, *best;
2897 int high=0, a;
2898
2899 for (c = HEAD_CGVCOL; c != NULL; c = c->NEXT)
2900 {
2901 if ((a=colsize(c))>=high)
2902 {
2903 high=a; best=c;
2904 }
2905 }
2906
2907 // fprintf(f,"best col size=%d\n",high);
2908 displaycol(best);
2909 return best;
2910 }
2911 static void cleantags(cgvfig_list *cgvf)
2912 {
2913 cgvcol_list *c;
2914 cgvbox_list *box;
2915
2916 #ifndef __ALL__WARNING__
2917 cgvf = NULL;
2918 #endif
2919 for (c = HEAD_CGVCOL; c != NULL; c = c->NEXT)
2920 {
2921 cgvcel_list *cell;
2922 for (cell = c->CELL; cell; cell = cell->NEXT)
2923 {
2924 if (cell->TYPE == CGV_CEL_BOX)
2925 {
2926 box=(cgvbox_list *) cell->ROOT;
2927 SetCgvBoxTaged(box);
2928 }
2929 else
2930 {
2931 // SetCgvConTaged((cgvcon_list *) cell->ROOT);
2932 }
2933 // fprintf(f,"tag %s\n",box->NAME);
2934 }
2935 }
2936
2937 }
2938
2939 static void untagfloatingcon(cgvcol_list *c)
2940 {
2941 cgvcel_list *cell;
2942 cgvcon_list *con;
2943 for (cell = c->CELL; cell; cell = cell->NEXT)
2944 {
2945 con=(cgvcon_list *)cell->ROOT;
2946 if (con->NET->CON_NET==NULL || con->NET->CON_NET->NEXT==NULL)
2947 SetCgvConUnTaged(con);
2948 }
2949 }
2950
2951 void tasser_cellules(cgvcol_list *c, int *centre)
2952 {
2953 cgvcel_list *cell, **tab;
2954 int cnt=0, i, base=0;
2955 cgvbox_list *box;
2956
2957 for (cell = c->CELL, cnt=0; cell; cell = cell->NEXT, cnt++)
2958 {
2959 if (cell->TYPE == CGV_CEL_BOX)
2960 {
2961 box=(cgvbox_list *)cell->ROOT;
2962 if (box->misc.UNDER!=NULL) box->Y = box->misc.UNDER->Y - (box->misc.UNDER->DY/2);
2963 }
2964 }
2965
2966 tab=(cgvcel_list **)mbkalloc(sizeof(cgvcel_list *)*cnt);
2967 for (cell = c->CELL, cnt=0; cell; cell = cell->NEXT, cnt++) tab[cnt]=cell;
2968
2969 qsort(tab, cnt, sizeof(cgvcel_list *), comp_y);
2970
2971 for (i=0;i<cnt;i++)
2972 {
2973 if (tab[i]->TYPE == CGV_CEL_BOX)
2974 {
2975 box=(cgvbox_list *)tab[i]->ROOT;
2976 box->Y=base;
2977 base=base+box->DY+addmarge(box);
2978 }
2979 else
2980 {
2981 ((cgvcon_list *)tab[i]->ROOT)->Y_REL=base;
2982 base=base+MARGE;
2983 }
2984 }
2985 *centre=base/2;
2986 mbkfree(tab);
2987 }
2988
2989 void getcellinfo(cgvcel_list *c, int *y, int *dy, int *marge)
2990 {
2991 if (c->TYPE == CGV_CEL_BOX)
2992 {
2993 *y=((cgvbox_list *)c->ROOT)->Y;
2994 *dy=((cgvbox_list *)c->ROOT)->DY;
2995 if (!IsCgvBoxTransparence((cgvbox_list *)c->ROOT)) *marge=MARGE;
2996 else *marge=0;
2997 }
2998 else
2999 {
3000 *y=((cgvcon_list *)c->ROOT)->Y_REL;
3001 *dy=MARGE;
3002 *marge=0;
3003 }
3004 }
3005 void setcelly(cgvcel_list *c, int y)
3006 {
3007 if (c->TYPE == CGV_CEL_BOX) ((cgvbox_list *)c->ROOT)->Y=y;
3008 else ((cgvcon_list *)c->ROOT)->Y_REL=y;
3009 }
3010
3011 int getcelly(cgvcel_list *c)
3012 {
3013 if (c->TYPE == CGV_CEL_BOX) return ((cgvbox_list *)c->ROOT)->Y;
3014 return ((cgvcon_list *)c->ROOT)->Y_REL;
3015 }
3016
3017 void organiser_cellules(cgvcol_list *c, int centre)
3018 {
3019 cgvcel_list *cell, **tab;
3020 int cnt=0, i, spaceunder, spaceover, j;
3021 int y0, y1, dy0, dy1, m0, m1;
3022
3023 for (cell = c->CELL, cnt=0; cell; cell = cell->NEXT, cnt++) ;
3024
3025 tab=(cgvcel_list **)mbkalloc(sizeof(cgvcel_list *)*cnt);
3026 for (cell = c->CELL, cnt=0; cell; cell = cell->NEXT, cnt++) tab[cnt]=cell;
3027
3028 qsort(tab, cnt, sizeof(cgvcel_list *), comp_y);
3029
3030 // printf("new\n");
3031 for (i=0;i<cnt;i++)
3032 {
3033 /* if (tab[i]->TYPE != CGV_CEL_BOX)
3034 printf("%s\n",((cgvcon_list *)tab[i]->ROOT)->NAME);
3035 */
3036 // fprintf(f,"->\n");
3037 // box=(cgvbox_list *)tab[i]->ROOT;
3038 getcellinfo(tab[i], &y0, &dy0, &m0);
3039 if (i==0) spaceunder=100000;
3040 else
3041 {
3042 getcellinfo(tab[i-1], &y1, &dy1, &m1);
3043 /*box1=(cgvbox_list *)tab[i-1]->ROOT;*/
3044 spaceunder=y0 - ( y1 + dy1 + m1 );
3045 // fprintf(f, "cunder: y=%d dy=%d y1=%d\n",box->Y, box->DY, box1->Y);
3046 }
3047
3048 if (i==cnt-1) spaceover=100000;
3049 else
3050 {
3051 getcellinfo(tab[i+1], &y1, &dy1, &m1);
3052 //box1=(cgvbox_list *)tab[i+1]->ROOT;
3053 spaceover=y1 - ( y0 + dy0 + m0);
3054 // fprintf(f, "cover: y=%d dy=%d y1=%d\n",box1->Y, box1->DY, box->Y);
3055 }
3056
3057 // fprintf(f, "mv: %s u=%d o=%d\n",box->NAME, spaceunder, spaceover);
3058 if (spaceunder<0 && spaceover>0 && spaceover>=-spaceunder)
3059 {
3060 setcelly(tab[i], getcelly(tab[i]) + -spaceunder);
3061 /* fprintf(f,"(y+%d)",-spaceunder); */}
3062 else
3063 if (spaceover<0 && spaceunder>0 && spaceunder>=-spaceover)
3064 {
3065 setcelly(tab[i], getcelly(tab[i]) - -spaceover);
3066 // box->Y -= -spaceover;
3067 /*fprintf(f,"(y-%d)",-spaceover); */
3068 }
3069 else if (spaceover<0 || spaceunder<0)
3070 {
3071 int movedir;
3072 if (spaceover<0 && spaceunder<0)
3073 {
3074 if (getcelly(tab[i])<centre) movedir=1; else movedir=0;
3075 }
3076 else
3077 {
3078 if (spaceover<0) movedir=1; else movedir=0;
3079 }
3080 if (movedir==1)
3081 {
3082 setcelly(tab[i], getcelly(tab[i]) - -spaceover);
3083 // box->Y -= -spaceover;
3084 // fprintf(f,"(2)y-%d=%d)",-spaceover,box->Y);
3085 // lastbox=box;
3086 y0=getcelly(tab[i]);
3087 for (j=i-1; j>=0; j--)
3088 {
3089 // box1=(cgvbox_list *)tab[j]->ROOT;
3090 getcellinfo(tab[j], &y1, &dy1, &m1);
3091 if (y0>= y1 + dy1 + m1) break;
3092 setcelly(tab[j], y0 - (dy1 + m1));
3093 // box1->Y=lastbox->Y-(box1->DY+addmarge(box1));
3094 // fprintf(f,"(%s moveddw %d)",box1->NAME,box1->Y);
3095 getcellinfo(tab[j], &y0, &dy0, &m0);
3096 // y0=y1;
3097 // lastbox=box1;
3098 }
3099 }
3100 else
3101 {
3102 setcelly(tab[i], getcelly(tab[i]) + -spaceunder);
3103 // box->Y += -spaceunder;
3104 // fprintf(f,"(2)y+%d)",-spaceunder);
3105 // lastbox=box;
3106 getcellinfo(tab[i], &y0, &dy0, &m0);
3107 for (j=i+1; j<cnt; j++)
3108 {
3109 // box1=(cgvbox_list *)tab[j]->ROOT;
3110 getcellinfo(tab[j], &y1, &dy1, &m1);
3111 if (y1>= y0 + dy0 + m0) break;
3112 setcelly(tab[j], y0 + dy0 + m0);
3113 // box1->Y=lastbox->Y+lastbox->DY+addmarge(lastbox);
3114 // fprintf(f,"(%s movedup %d)",box1->NAME,box1->Y);
3115 // lastbox=box1;
3116 getcellinfo(tab[j], &y0, &dy0, &m0);
3117 }
3118 }
3119 }
3120 /* else
3121 fprintf(f,"GOOD");
3122
3123 fprintf(f,"<-\n");
3124 */
3125 }
3126 mbkfree(tab);
3127 }
3128
3129 void addfakecon(cgvfig_list *cgvf)
3130 {
3131 cgvbox_list *box=cgvf->BOX;
3132 cgvnet_list *n;
3133 cgvcon_list *c;
3134 while (box!=NULL)
3135 {
3136 if (box->NUMBER_OUT==0)
3137 {
3138 n=addcgvnet(cgvf);
3139 c=addcgvboxcon(cgvf, box, "**$$**", CGV_CON_OUT);
3140 addcgvnetcon(n, c);
3141 c=addcgvfigcon(cgvf, "$$**$$", CGV_CON_OUT);
3142 }
3143 box=box->NEXT;
3144 }
3145 }
3146
3147
3148 void updatecolumninfos(cgvcol_list *Column)
3149 {
3150 cgvcel_list *Cell;
3151 cgvbox_list *Box;
3152 cgvcon_list *Con;
3153
3154 while (Column!=NULL)
3155 {
3156 for (Cell = Column->CELL; Cell != NULL; Cell = Cell->NEXT)
3157 {
3158 if (Cell->TYPE == CGV_CEL_BOX)
3159 {
3160 Box = (cgvbox_list *) Cell->ROOT;
3161 if (Box->DX > Column->MAX_DX_CELL)
3162 {
3163 Column->MAX_DX_CELL = Box->DX;
3164 }
3165 }
3166 else
3167 if (Cell->TYPE == CGV_CEL_CON)
3168 {
3169 Con = (cgvcon_list *) Cell->ROOT;
3170 if (2*CGV_SCALE > Column->MAX_DX_CELL)
3171 {
3172 Column->MAX_DX_CELL = 2*CGV_SCALE;
3173 }
3174 }
3175 }
3176 Column=Column->NEXT;
3177 }
3178 }
3179
3180 void aligner_en_avant_best(cgvcol_list *best, int centre, cgvfig_list *Figure)
3181 {
3182 cgvcol_list *c, *pred, *pred0;
3183 int y;
3184
3185 pred0=best->NEXT;
3186 HEAD_CGVCOL = (cgvcol_list *) reverse((chain_list *) HEAD_CGVCOL);
3187
3188
3189 #ifdef DEBUG
3190 fprintf(stdout,"left:");
3191 #endif
3192
3193 for (c = best->NEXT, pred=best; c != NULL; pred=c, c = c->NEXT)
3194 {
3195 #ifdef DEBUG
3196 fprintf(stdout,".");fflush(stdout);
3197 #endif
3198 aligner_par_rapport_aux_entrees(c, pred, 1);
3199 organiser_cellules(c, centre);
3200 /*if (c->NEXT!=NULL)*/ tasser_les_non_places(c, centre);
3201 }
3202 #ifdef DEBUG
3203 fprintf(stdout,"\n");
3204 #endif
3205
3206 pred0=best->NEXT;
3207 HEAD_CGVCOL = (cgvcol_list *) reverse((chain_list *) HEAD_CGVCOL);
3208
3209 #ifdef DEBUG
3210 fprintf(stdout,"right:");
3211 #endif
3212 for (c = best->NEXT, pred=best; c != NULL; pred=c, c = c->NEXT)
3213 {
3214 #ifdef DEBUG
3215 fprintf(stdout,".");fflush(stdout);
3216 #endif
3217 aligner_par_rapport_aux_sorties(c, pred, 1);
3218 organiser_cellules(c, centre);
3219 /* if (c->NEXT!=NULL)*/ tasser_les_non_places(c, centre);
3220 }
3221 #ifdef DEBUG
3222 fprintf(stdout,"\n");
3223 #endif
3224
3225
3226 HEAD_CGVCOL = (cgvcol_list *) reverse((chain_list *) HEAD_CGVCOL);
3227
3228 #ifdef DEBUG
3229 fprintf(stdout,"whole:");
3230 #endif
3231
3232 for (c = HEAD_CGVCOL->NEXT, pred=HEAD_CGVCOL; c != NULL ; pred=c, c = c->NEXT)
3233 {
3234 if (c->NUMBER_CELL<800)
3235 {
3236 #ifdef DEBUG
3237 fprintf(stdout,".");fflush(stdout);
3238 #endif
3239 }
3240 else
3241 {
3242 #ifdef DEBUG
3243 fprintf(stdout,"_");fflush(stdout);
3244 #endif
3245 if (c==best) tasser_les_non_places(best, centre);
3246 continue;
3247 }
3248 /* cgvcel_list *cel;
3249 for (cel=c->CELL; cel!=NULL; cel=cel->NEXT)
3250 if (cel->TYPE==CGV_CEL_BOX && strcmp(((cgvbox_list *)cel->ROOT)->NAME,"transparence_188")==0) break;
3251 if (cel!=NULL) break;
3252 */
3253 for (y=0;y<5;y++)
3254 {
3255 essayer_d_aligner_par_rapport_aux_entrees(c, pred);
3256 organiser_cellules(c, centre);
3257 }
3258
3259 if (c==best) tasser_les_non_places(best, centre);
3260 /*
3261 if (tasser_les_non_places(c))
3262 {
3263 for (y=0;y<2;y++)
3264 {
3265 essayer_d_aligner_par_rapport_aux_entrees(c, pred);
3266 }
3267 }
3268 */
3269 //organiser_cellules(c, centre);
3270 }
3271 #ifdef DEBUG
3272 fprintf(stdout,"\n");
3273 #endif
3274 /*
3275 tasser_les_non_places(best);
3276 */
3277 tasser_les_non_places(pred, centre);
3278 untagfloatingcon(HEAD_CGVCOL);
3279 tasser_les_non_places(HEAD_CGVCOL, centre);
3280
3281 removefake(Figure, HEAD_CGVCOL);
3282 HEAD_CGVCOL = (cgvcol_list *) reverse((chain_list *) HEAD_CGVCOL);
3283 }
3284
3285
3286 void
3287 buildcgvfig(Figure)
3288 cgvfig_list *Figure;
3289 {
3290 cgvcol_list *best;
3291 int centre;
3292 #ifdef DEBUG
3293 fprintf(stdout, "--- Detection des clusters ---\n");
3294 fflush(stdout);
3295 #endif
3296 /* loc_buildcluster(Figure);*/
3297 #ifdef DEBUG
3298 fprintf(stdout, "----- Placement initial -----\n");
3299 fflush(stdout);
3300 #endif
3301 // addfakecon(Figure);
3302 loc_placement_initial(Figure);
3303 #ifdef DEBUG
3304 fprintf(stdout, "--- Fabrication des boites ---\n");
3305 fflush(stdout);
3306 #endif
3307 loc_buildbox(Figure);
3308 #ifdef DEBUG
3309 fprintf(stdout, "--------- Placement ---------\n");
3310 fflush(stdout);
3311 #endif
3312 // loc_buildplace(Figure);
3313 updatecolumninfos(HEAD_CGVCOL);
3314
3315 /* zinaps was here */
3316 // f=fopen("r","wt");
3317 // if (strchr(Figure->NAME,'#')==NULL)
3318 {
3319 cleantags(Figure);
3320 loc_laisser_pendouiller_out_vers_in(Figure, 0);
3321 best=highestcolumn();
3322 tasser_cellules(best, &centre);
3323 // cleantags();
3324 aligner_en_avant_best(best, centre, Figure);
3325 }
3326
3327 // fclose(f);
3328
3329 /* --------------- */
3330 #ifdef DEBUG
3331 fprintf(stdout, "---------- Routage ----------\n");
3332 fflush(stdout);
3333 #endif
3334 loc_route(Figure);
3335 #ifdef DEBUG
3336 fprintf(stdout, "---------- Nettoyage --------\n");
3337 fflush(stdout);
3338 #endif
3339 loc_clean_all(Figure);
3340 }