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 : Tools.c |
33 | |
34 | Author : Jacomme Ludovic |
35 | |
36 | Date : 28.03.95 |
37 | |
38 \------------------------------------------------------------*/
39 /*------------------------------------------------------------\
40 | |
41 | Include Files |
42 | |
43 \------------------------------------------------------------*/
44
45 # include <stdio.h>
46 # include <Xm/Xm.h>
47 # include <Xm/PushBG.h>
48 # ifdef HAVE_XPM
49 # include <X11/xpm.h>
50 # endif
51
52 # include "mut.h"
53 # include "mph.h"
54 # include "rds.h"
55 # include "rfm.h"
56 # include "rpr.h"
57 # include "rwi.h"
58 # include "rut.h"
59 # include "GTB.h"
60 # include "GSB.h"
61 # include "GMX.h"
62 # include "GMF.h"
63 # include "GRM.h"
64 # include "GMT.h"
65 # include "GMV.h"
66
67 # include "GMT_tools.h"
68 # include "GMT_panel.h"
69 # include "GMT_message.h"
70 # include "GRM_select.h"
71 # include "GMF_menu.h"
72 # include "GMF_file.h"
73 # include "GRM_window.h"
74
75 /*------------------------------------------------------------\
76 | |
77 | Constants |
78 | |
79 \------------------------------------------------------------*/
80 /*------------------------------------------------------------\
81 | |
82 | Types |
83 | |
84 \------------------------------------------------------------*/
85 /*------------------------------------------------------------\
86 | |
87 | Variables |
88 | |
89 \------------------------------------------------------------*/
90
91 graalhierarchy *GraalHeadHierarchy = (graalhierarchy *)0;
92
93 char GraalToolsFilter[ 10 ] = "*.";
94 char GraalToolsExtention[ 10 ] = ".";
95
96 char GraalToolsBuffer[ 128 ];
97 char GraalToolsDirectoryBuffer[ 512 ];
98
99 /*------------------------------------------------------------\
100 | |
101 | Hierarchy Show Buffer |
102 | |
103 \------------------------------------------------------------*/
104
105 static char GraalHierarchyShowMessage[ GRAAL_HIERARCHY_SHOW_MESSAGE_SIZE ];
106 static char *GraalScanHierarchyShow;
107
108 /*------------------------------------------------------------\
109 | |
110 | Functions |
111 | |
112 \------------------------------------------------------------*/
113 /*------------------------------------------------------------\
114 | |
115 | GraalAllocHierarchy |
116 | |
117 \------------------------------------------------------------*/
118
GraalAllocHierarchy()119 graalhierarchy *GraalAllocHierarchy ()
120
121 {
122 return ( (graalhierarchy *) rdsalloc ( sizeof ( graalhierarchy ), 1));
123 }
124
125 /*------------------------------------------------------------\
126 | |
127 | GraalFreeHierarchy |
128 | |
129 \------------------------------------------------------------*/
130
GraalFreeHierarchy(FreeHierarchy)131 void GraalFreeHierarchy ( FreeHierarchy )
132
133 graalhierarchy *FreeHierarchy;
134
135 {
136 rdsfree( (char *)FreeHierarchy, sizeof(FreeHierarchy) );
137 }
138
139 /*------------------------------------------------------------\
140 | |
141 | GraalAddHierarchy |
142 | |
143 \------------------------------------------------------------*/
144
GraalAddHierarchy(Name)145 void GraalAddHierarchy( Name )
146
147 char *Name;
148 {
149 graalhierarchy *GraalHierarchy;
150
151 rdsbegin();
152
153 GraalHierarchy = GraalAllocHierarchy ();
154 GraalHierarchy->NAME = Name;
155 GraalHierarchy->X = GraalLambdaGridX;
156 GraalHierarchy->Y = GraalLambdaGridY;
157 GraalHierarchy->DX = GraalLambdaGridDx;
158 GraalHierarchy->DY = GraalLambdaGridDy;
159 GraalHierarchy->NEXT = GraalHeadHierarchy;
160 GraalHeadHierarchy = GraalHierarchy;
161
162 rdsend();
163 }
164
165 /*------------------------------------------------------------\
166 | |
167 | GraalDelHierarchy |
168 | |
169 \------------------------------------------------------------*/
170
GraalDelHierarchy()171 char GraalDelHierarchy()
172
173 {
174 graalhierarchy *GraalHierarchy;
175
176 if ( GraalHeadHierarchy != (graalhierarchy *) NULL )
177 {
178 rdsbegin();
179
180 GraalHierarchy = GraalHeadHierarchy;
181 GraalHeadHierarchy = GraalHeadHierarchy->NEXT;
182 GraalFreeHierarchy( GraalHierarchy );
183
184 rdsend();
185 return( GRAAL_TRUE );
186 }
187
188 return( GRAAL_FALSE );
189 }
190
191 /*------------------------------------------------------------\
192 | |
193 | GraalToolsEqui |
194 | |
195 \------------------------------------------------------------*/
196
GraalToolsEqui()197 void GraalToolsEqui()
198
199 {
200 rdsbegin();
201
202 GraalSetMouseCursor( GraalGraphicWindow, GRAAL_WATCH_CURSOR );
203
204 if ( GraalHeadSelect != (graalselect *)NULL )
205 {
206 GraalExtractEqui( GraalHeadSelect->RECTANGLE );
207 }
208
209 GraalDelSelect();
210 GraalZoomRefresh();
211
212 rdsend();
213 }
214
215 /*------------------------------------------------------------\
216 | |
217 | GraalToolsRealFlatten |
218 | |
219 \------------------------------------------------------------*/
220
GraalToolsRealFlatten()221 void GraalToolsRealFlatten()
222
223 {
224 graalselect *Select;
225 graalselect *DelSelect;
226 graalselect **PrevSelect;
227 char Buffer[ 512 ];
228
229 rdsbegin();
230
231 GraalSetMouseCursor( GraalGraphicWindow, GRAAL_WATCH_CURSOR );
232
233 GraalDelPeek();
234
235 Select = GraalHeadSelect;
236 PrevSelect = &GraalHeadSelect;
237
238 while ( Select != (graalselect *)NULL )
239 {
240 if ( GraalRealFlatInstance( Select->RECTANGLE ) )
241 {
242 DelSelect = Select;
243 Select = Select->NEXT;
244 *PrevSelect = Select;
245
246 GraalFreeSelect( DelSelect );
247 }
248 else
249 {
250 PrevSelect = &Select->NEXT;
251 Select = Select->NEXT;
252 }
253 }
254
255 GraalDelSelect();
256
257 GraalZoomRefresh();
258 GraalDisplayToolsMessage();
259
260 sprintf( Buffer, "%s_real_flat", GraalFigureRds->NAME );
261 GraalFigureMbk->NAME = namealloc( Buffer );
262
263 GraalChangeTopLevelTitle( GraalFigureMbk->NAME );
264
265 rdsend();
266 }
267
268 /*------------------------------------------------------------\
269 | |
270 | GraalToolsFlatten |
271 | |
272 \------------------------------------------------------------*/
273
GraalToolsFlatten()274 void GraalToolsFlatten()
275
276 {
277 graalselect *Select;
278 rdsrec_list *Rectangle;
279 rdsins_list *Instance;
280
281 rdsbegin();
282
283 GraalSetMouseCursor( GraalGraphicWindow, GRAAL_WATCH_CURSOR );
284
285 GraalDelPeek();
286
287 for ( Select = GraalHeadSelect;
288 Select != (graalselect *)NULL;
289 Select = Select->NEXT )
290 {
291 Rectangle = Select->RECTANGLE;
292
293 Instance = (rdsins_list *)GRAAL_PREVIOUS( Rectangle );
294
295 GraalFlatInstance( Instance );
296 }
297
298 GraalDelSelect();
299 GraalZoomRefresh();
300 GraalDisplayToolsMessage();
301
302 rdsend();
303 }
304
305 /*------------------------------------------------------------\
306 | |
307 | GraalToolsUnflatten |
308 | |
309 \------------------------------------------------------------*/
310
GraalToolsUnflatten()311 void GraalToolsUnflatten()
312
313 {
314 graalselect *Select;
315 rdsrec_list *Rectangle;
316 rdsins_list *Instance;
317
318 rdsbegin();
319
320 GraalSetMouseCursor( GraalGraphicWindow, GRAAL_WATCH_CURSOR );
321
322 for ( Select = GraalHeadSelect;
323 Select != (graalselect *)NULL;
324 Select = Select->NEXT )
325 {
326 Rectangle = Select->RECTANGLE;
327
328 Instance = (rdsins_list *)GRAAL_PREVIOUS( Rectangle );
329 GraalUnflatInstance( Instance );
330 }
331
332 GraalDelSelect();
333 GraalZoomRefresh();
334
335 rdsend();
336 }
337
338 /*------------------------------------------------------------\
339 | |
340 | GraalToolsPeek |
341 | |
342 \------------------------------------------------------------*/
343
GraalToolsPeek(LambdaX1,LambdaY1,LambdaX2,LambdaY2)344 void GraalToolsPeek( LambdaX1, LambdaY1, LambdaX2, LambdaY2 )
345
346 long LambdaX1;
347 long LambdaY1;
348 long LambdaX2;
349 long LambdaY2;
350 {
351 long Offset;
352 graalwin *ScanWin;
353 graalwinrec *ScanWinRec;
354 rdsrec_list *Rec;
355 graalpeek *Peek;
356 char ScanRec;
357 long XabMin;
358 long XabMax;
359 long YabMin;
360 long YabMax;
361 long Xmin;
362 long Xmax;
363 long Ymin;
364 long Ymax;
365 long X;
366 long Y;
367 long Swap;
368
369 rdsbegin();
370
371 if ( ( LambdaX1 != LambdaX2 ) &&
372 ( LambdaY1 != LambdaY2 ) )
373 {
374 if ( LambdaX1 > LambdaX2 )
375 {
376 Swap = LambdaX1; LambdaX1 = LambdaX2; LambdaX2 = Swap;
377 }
378
379 if ( LambdaY1 > LambdaY2 )
380 {
381 Swap = LambdaY1; LambdaY1 = LambdaY2; LambdaY2 = Swap;
382 }
383 }
384
385 if ( GraalFigureMbk != (phfig_list *)NULL )
386 {
387 GraalSetMouseCursor( GraalGraphicWindow, GRAAL_WATCH_CURSOR );
388
389 GraalDelEqui();
390 GraalDelPeek();
391
392 LambdaX1 = LambdaX1 * GRAAL_RDS_LAMBDA;
393 LambdaX2 = LambdaX2 * GRAAL_RDS_LAMBDA;
394 LambdaY1 = LambdaY1 * GRAAL_RDS_LAMBDA;
395 LambdaY2 = LambdaY2 * GRAAL_RDS_LAMBDA;
396
397 XabMin = LambdaX1 - GRAAL_PEEK_BOUND;
398 YabMin = LambdaY1 - GRAAL_PEEK_BOUND;
399 XabMax = LambdaX2 + GRAAL_PEEK_BOUND;
400 YabMax = LambdaY2 + GRAAL_PEEK_BOUND;
401
402 Xmin = ( LambdaX1 - GraalWindowXmin ) / GraalWindowSide;
403 Xmax = ( LambdaX2 - GraalWindowXmin ) / GraalWindowSide;
404 Ymin = ( LambdaY1 - GraalWindowYmin ) / GraalWindowSide;
405 Ymax = ( LambdaY2 - GraalWindowYmin ) / GraalWindowSide;
406
407 if ( Xmin < 0 ) Xmin = 0;
408 if ( Xmin > GraalWindowDx ) Xmin = GraalWindowDx - 1;
409 if ( Ymin < 0 ) Ymin = 0;
410 if ( Ymin > GraalWindowDy ) Ymin = GraalWindowDy - 1;
411
412 if ( Xmax < 0 ) Xmax = 0;
413 if ( Xmax > GraalWindowDx ) Xmax = GraalWindowDx - 1;
414 if ( Ymax < 0 ) Ymax = 0;
415 if ( Ymax > GraalWindowDy ) Ymax = GraalWindowDy - 1;
416
417 Y = Ymin;
418
419 while ( Y <= Ymax )
420 {
421 X = Xmin;
422
423 while ( X <= Xmax )
424 {
425 Offset = ( Y * GraalWindowDx ) + X;
426
427 ScanWin = &GraalWindowTable[ Offset ];
428
429 if ( ScanWin->LAYERTAB != (graalwinrec **)NULL )
430 {
431 for ( ScanWinRec = ScanWin->LAYERTAB[ RDS_ABOX ];
432 ScanWinRec != (graalwinrec *)NULL;
433 ScanWinRec = ScanWinRec->NEXT )
434 {
435 for ( ScanRec = 0; ScanRec < GRAAL_MAX_REC ; ScanRec++ )
436 {
437 Rec = ScanWinRec->RECTAB[ (int)ScanRec ];
438
439 if ( ( Rec != (rdsrec_list *)NULL ) &&
440 ( ! IsRdsFigRec( Rec ) ) &&
441 ( ! IsGraalDeleted( Rec ) ) &&
442 ( ! IsGraalFlatten( Rec ) ) &&
443 ( ! IsGraalPeek( Rec ) ) &&
444 ( ( Rec->X + Rec->DX ) >= XabMin ) &&
445 ( ( Rec->Y + Rec->DY ) >= YabMin ) &&
446 ( ( Rec->X ) <= XabMax ) &&
447 ( ( Rec->Y ) <= YabMax ) )
448 {
449 GraalAddPeek( Rec );
450 }
451 }
452 }
453 }
454
455 X = X + 1;
456 }
457
458 Y = Y + 1;
459 }
460
461 for ( Peek = GraalHeadPeek;
462 Peek != (graalpeek *)NULL;
463 Peek = Peek->NEXT )
464 {
465 GraalPeekInstance( Peek->RECTANGLE,
466 LambdaX1, LambdaY1,
467 LambdaX2, LambdaY2 );
468 }
469
470 GraalZoomRefresh();
471 GraalDisplayToolsMessage();
472
473 GraalSetMouseCursor( GraalGraphicWindow, GRAAL_NORMAL_CURSOR );
474 }
475
476 rdsend();
477 }
478
479 /*------------------------------------------------------------\
480 | |
481 | GraalToolsUnpeek |
482 | |
483 \------------------------------------------------------------*/
484
GraalToolsUnpeek()485 void GraalToolsUnpeek()
486 {
487 if ( GraalHeadPeek != (graalpeek *)NULL )
488 {
489 rdsbegin();
490
491 GraalSetMouseCursor( GraalGraphicWindow, GRAAL_WATCH_CURSOR );
492 GraalDelEqui();
493 GraalDelPeek();
494 GraalZoomRefresh();
495 GraalSetMouseCursor( GraalGraphicWindow, GRAAL_NORMAL_CURSOR );
496
497 rdsend();
498 }
499 }
500
501 /*------------------------------------------------------------\
502 | |
503 | GraalToolsHierarchyDown |
504 | |
505 \------------------------------------------------------------*/
506
GraalToolsHierarchyDown()507 void GraalToolsHierarchyDown()
508 {
509 rdsrec_list *Rectangle;
510 rdsins_list *Instance;
511 char *ModelName;
512
513 rdsbegin();
514
515 if ( GraalHeadSelect != (graalselect *)0 )
516 {
517 Rectangle = GraalHeadSelect->RECTANGLE;
518 Instance = (rdsins_list *)GRAAL_PREVIOUS( Rectangle );
519 ModelName = Instance->FIGNAME;
520
521 GraalDelSelect();
522
523 if ( GraalHeadUndo != (graalundo *)NULL )
524 {
525 CallbackFileSaveAs( NULL, NULL, NULL );
526 }
527
528 GraalAddHierarchy( GraalFigureRds->NAME );
529
530 GraalFileOpen( ModelName, 1 );
531 }
532
533 rdsend();
534 }
535
536 /*------------------------------------------------------------\
537 | |
538 | GraalToolsHierarchyShow |
539 | |
540 \------------------------------------------------------------*/
541
GraalToolsHierarchyShow(LambdaX1,LambdaY1)542 void GraalToolsHierarchyShow( LambdaX1, LambdaY1 )
543
544 long LambdaX1;
545 long LambdaY1;
546 {
547 graalselect *Select;
548 phins_list *InsMbk;
549 phins_list *ScanInsMbk;
550 phfig_list *ModelMbk;
551 long X;
552 long Y;
553 long Xab1;
554 long Yab1;
555 long Xab2;
556 long Yab2;
557
558 rdsbegin();
559
560 GraalScanHierarchyShow = GraalHierarchyShowMessage;
561
562 if ( GraalFigureMbk == (phfig_list *)0 )
563 {
564 sprintf( GraalScanHierarchyShow, "No current figure !" );
565 GraalScanHierarchyShow += strlen( GraalScanHierarchyShow );
566 }
567 else
568 {
569 GraalSetMouseCursor( GraalGraphicWindow, GRAAL_WATCH_CURSOR );
570
571 LambdaX1 = (long)( LambdaX1 * GRAAL_SCALE_X );
572 LambdaY1 = (long)( LambdaY1 * GRAAL_SCALE_X );
573
574 sprintf( GraalScanHierarchyShow, "FIGURE %s : (%.2f, %.2f)\n",
575 GraalFigureMbk->NAME,
576 (float)LambdaX1 / (float)SCALE_X,
577 (float)LambdaY1 / (float)SCALE_X );
578
579 GraalScanHierarchyShow += strlen( GraalScanHierarchyShow );
580
581 InsMbk = (phins_list *)0;
582
583 for ( Select = GraalHeadSelect;
584 Select != (graalselect *)NULL;
585 Select = Select->NEXT )
586 {
587 if ( IsRdsInstance( Select->RECTANGLE ) )
588 {
589 InsMbk = (phins_list *)GRAAL_MBK( Select->RECTANGLE );
590 }
591 }
592
593 GraalDelSelect();
594
595 while ( InsMbk != (phins_list *)0 )
596 {
597 ModelMbk = Graalgetphfig( InsMbk->FIGNAME, 'A' );
598
599 sprintf( GraalScanHierarchyShow, "INSTANCE %s (%s,%s)\n",
600 InsMbk->INSNAME,
601 InsMbk->FIGNAME,
602 GRAAL_SYMMETRY_NAME_TABLE[ (int)InsMbk->TRANSF ][0] );
603
604 GraalScanHierarchyShow += strlen( GraalScanHierarchyShow );
605
606 if ( ModelMbk == (phfig_list *)0 )
607 {
608 sprintf( GraalScanHierarchyShow, "Unable to load model %s !!\n",
609 InsMbk->FIGNAME );
610
611 break;
612 }
613
614 invxyflat( &X, &Y, LambdaX1, LambdaY1,
615 InsMbk->XINS , InsMbk->YINS ,
616 ModelMbk->XAB1, ModelMbk->YAB1,
617 ModelMbk->XAB2, ModelMbk->YAB2,
618 InsMbk->TRANSF );
619
620 sprintf( GraalScanHierarchyShow, "MODEL %s : (%.2f, %.2f)\n",
621 InsMbk->FIGNAME,
622 (float)X / (float)SCALE_X,
623 (float)Y / (float)SCALE_X );
624
625 GraalScanHierarchyShow += strlen( GraalScanHierarchyShow );
626
627 LambdaX1 = X;
628 LambdaY1 = Y;
629
630 for ( ScanInsMbk = ModelMbk->PHINS;
631 ScanInsMbk != (phins_list *)0;
632 ScanInsMbk = ScanInsMbk->NEXT )
633 {
634 ModelMbk = Graalgetphfig( ScanInsMbk->FIGNAME, 'P' );
635
636 if ( ModelMbk != (phfig_list *)0 )
637 {
638 xyflat
639 ( &Xab1 , &Yab1,
640 ModelMbk->XAB1 , ModelMbk->YAB1,
641 ScanInsMbk->XINS , ScanInsMbk->YINS,
642 ModelMbk->XAB1 , ModelMbk->YAB1,
643 ModelMbk->XAB2 , ModelMbk->YAB2,
644 ScanInsMbk->TRANSF
645 );
646
647 xyflat
648 ( &Xab2 , &Yab2,
649 ModelMbk->XAB2 , ModelMbk->YAB2,
650 ScanInsMbk->XINS , ScanInsMbk->YINS,
651 ModelMbk->XAB1 , ModelMbk->YAB1,
652 ModelMbk->XAB2 , ModelMbk->YAB2,
653 ScanInsMbk->TRANSF
654 );
655
656 if ( ( LambdaX1 >= Xab1 ) &&
657 ( LambdaX1 <= Xab2 ) &&
658 ( LambdaY1 >= Yab1 ) &&
659 ( LambdaY1 <= Yab2 ) ) break;
660 }
661 }
662
663 InsMbk = ScanInsMbk;
664 }
665
666 GraalSetMouseCursor( GraalGraphicWindow, GRAAL_NORMAL_CURSOR );
667 }
668
669 GraalDisplayHierarchyShowMessage( GraalHierarchyShowMessage );
670 GraalEnterPanel( &GraalToolsHierarchyShowPanel );
671
672 rdsend();
673 }
674
675 /*------------------------------------------------------------\
676 | |
677 | GraalToolsHierarchyUp |
678 | |
679 \------------------------------------------------------------*/
680
GraalToolsHierarchyUp()681 void GraalToolsHierarchyUp()
682 {
683 if ( GraalHeadHierarchy == (graalhierarchy *)0 )
684 {
685 GraalErrorMessage( GraalMainWindow, "No previous model !" );
686 }
687 else
688 {
689 if ( GraalHeadUndo != (graalundo *)NULL )
690 {
691 CallbackFileSaveAs( NULL, NULL, NULL );
692 }
693
694 GraalFileOpen( GraalHeadHierarchy->NAME, 0 );
695
696 GraalLambdaGridX = GraalHeadHierarchy->X;
697 GraalLambdaGridY = GraalHeadHierarchy->Y;
698 GraalLambdaGridDx = GraalHeadHierarchy->DX;
699 GraalLambdaGridDy = GraalHeadHierarchy->DY;
700
701 GraalComputeLambdaGrid();
702 GraalComputeAndDisplayMap();
703
704 GraalZoomRefresh();
705 GraalDelHierarchy();
706 }
707 }
708
709 /*------------------------------------------------------------\
710 | |
711 | GraalToolsHierarchyReload |
712 | |
713 \------------------------------------------------------------*/
714
GraalToolsHierarchyReload()715 void GraalToolsHierarchyReload()
716 {
717 long SaveLambdaGridX;
718 long SaveLambdaGridY;
719 long SaveLambdaGridDx;
720 long SaveLambdaGridDy;
721
722 if ( GraalFigureMbk != (phfig_list *)NULL )
723 {
724 if ( GraalHeadUndo != (graalundo *)NULL )
725 {
726 CallbackFileSaveAs( NULL, NULL, NULL );
727 }
728
729 SaveLambdaGridX = GraalLambdaGridX;
730 SaveLambdaGridY = GraalLambdaGridY;
731 SaveLambdaGridDx = GraalLambdaGridDx;
732 SaveLambdaGridDy = GraalLambdaGridDy;
733
734 GraalFileOpen( GraalFigureRds->NAME, 0 );
735
736 GraalLambdaGridX = SaveLambdaGridX;
737 GraalLambdaGridY = SaveLambdaGridY;
738 GraalLambdaGridDx = SaveLambdaGridDx;
739 GraalLambdaGridDy = SaveLambdaGridDy;
740
741 GraalComputeLambdaGrid();
742 GraalComputeAndDisplayMap();
743
744 GraalZoomRefresh();
745 }
746 }
747
748 /*------------------------------------------------------------\
749 | |
750 | GraalToolsDelAllHierarchy |
751 | |
752 \------------------------------------------------------------*/
753
GraalToolsDelAllHierarchy()754 void GraalToolsDelAllHierarchy()
755 {
756 while ( GraalHeadHierarchy != (graalhierarchy *)0 )
757 {
758 GraalDelHierarchy();
759 }
760 }
761
762 /*------------------------------------------------------------\
763 | |
764 | GraalToolsLoadError |
765 | |
766 \------------------------------------------------------------*/
767
GraalToolsLoadError(FileName)768 void GraalToolsLoadError( FileName )
769
770 char *FileName;
771 {
772 rdsfig_list *FigureRds;
773 rdsfig_list *HeadFigureRds;
774 rdsrec_list *ScanRec;
775 rdsrec_list *ErrorRec;
776 int Layer;
777 int Index;
778 char *SWAP_WORK_LIB = WORK_LIB;
779
780 rdsbegin();
781
782 GraalSetMouseCursor( GraalGraphicWindow, GRAAL_WATCH_CURSOR );
783 GraalUndisplayCursor();
784
785 GraalRecomputeBound = GRAAL_TRUE;
786
787 if ( GRAAL_WORK_LIB == (char *)NULL )
788 {
789 GRAAL_WORK_LIB = WORK_LIB;
790 }
791
792 for ( Index = strlen( FileName ); Index >= 0; Index-- )
793 {
794 if ( FileName[ Index ] == '/' ) break;
795 }
796
797 if ( Index >= 0 )
798 {
799 strcpy( GraalToolsDirectoryBuffer, FileName );
800 strcpy( GraalToolsBuffer, FileName + Index + 1);
801
802 GraalToolsDirectoryBuffer[ Index + 1 ] = '\0';
803
804 WORK_LIB = GraalToolsDirectoryBuffer;
805 }
806 else
807 {
808 strcpy( GraalToolsBuffer, FileName );
809
810 WORK_LIB = GRAAL_WORK_LIB;
811 }
812
813 Index = strlen( GraalToolsBuffer ) - strlen( GraalToolsExtention );
814
815 if ( Index >= 0 )
816 {
817 if ( ! strcmp( GraalToolsBuffer + Index, GraalToolsExtention ) )
818 {
819 GraalToolsBuffer[ Index ] = '\0';
820 }
821 }
822
823 HeadFigureRds = HEAD_RDSFIG;
824 HEAD_RDSFIG = (rdsfig_list *)0;
825
826 FigureRds = Graalgetrdsfig( GraalToolsBuffer, 'V' );
827
828 if ( FigureRds == (rdsfig_list *)0 )
829 {
830 GraalDisplayToolsMessage();
831 GraalErrorMessage( GraalMainWindow, "Unable to open this figure !" );
832 }
833 else
834 {
835 FigureRds = Graalrflattenrdsfig( FigureRds, RDS_YES, RDS_NO );
836
837 if ( FigureRds == (rdsfig_list *)0 )
838 {
839 GraalDisplayToolsMessage();
840 GraalErrorMessage( GraalMainWindow, "Unable to open this figure !" );
841 }
842 else
843 {
844 for ( Layer = 0; Layer < RDS_MAX_LAYER; Layer++ )
845 {
846 for ( ScanRec = FigureRds->LAYERTAB[ Layer ];
847 ScanRec != (rdsrec_list *)0;
848 ScanRec = ScanRec->NEXT )
849 {
850 ErrorRec =
851
852 addrdsfigrec( GraalFigureRds, ScanRec->NAME,
853 GetRdsLayer( ScanRec ),
854 ScanRec->X , ScanRec->Y,
855 ScanRec->DX, ScanRec->DY );
856
857 SetGraalDruc( ErrorRec );
858
859 if ( ErrorRec->NEXT != (rdsrec_list *)NULL )
860 {
861 GRAAL_PREVIOUS( ErrorRec->NEXT ) = &ErrorRec->NEXT;
862 }
863
864 GRAAL_PREVIOUS( ErrorRec ) =
865
866 &GraalFigureRds->LAYERTAB[ GetRdsLayer( ErrorRec ) ];
867
868 GraalInsertRectangle( ErrorRec );
869 ErrorRec->USER = (void *)ErrorRec;
870 }
871 }
872
873 delrdsfig( FigureRds->NAME );
874 }
875 }
876
877 while ( HEAD_RDSFIG != (rdsfig_list *)0 )
878 {
879 delrdsfig( HEAD_RDSFIG->NAME );
880 }
881
882 HeadFigureRds = HEAD_RDSFIG;
883 HEAD_RDSFIG = HeadFigureRds;
884
885 GraalZoomRefresh();
886 GraalSetMouseCursor( GraalGraphicWindow, GRAAL_NORMAL_CURSOR );
887 GraalDisplayCursor();
888
889 WORK_LIB = SWAP_WORK_LIB;
890
891 rdsend();
892 }
893
894 /*------------------------------------------------------------\
895 | |
896 | GraalToolsSavePixmap |
897 | |
898 \------------------------------------------------------------*/
899
GraalToolsSavePixmap(FileName)900 void GraalToolsSavePixmap( FileName )
901
902 char *FileName;
903 {
904 # ifdef HAVE_XPM
905 XpmAttributes Attribute;
906 char *XpmFileName;
907 int Error;
908
909 XpmFileName = rdsallocblock( strlen( FileName ) + 4 );
910 sprintf( XpmFileName, "%s.xpm", FileName );
911
912 Attribute.colormap = GraalColorMap;
913 Attribute.valuemask = XpmColormap;
914
915 GraalSetMouseCursor( GraalGraphicWindow, GRAAL_WATCH_CURSOR );
916
917 Error = XpmWriteFileFromPixmap( GraalGraphicDisplay,
918 XpmFileName,
919 GraalGraphicPixmap,
920 (Pixmap)0, &Attribute );
921
922 GraalSetMouseCursor( GraalGraphicWindow, GRAAL_NORMAL_CURSOR );
923
924 if ( Error )
925 {
926 GraalErrorMessage( GraalMainWindow, "Unable to save xpm file !" );
927 }
928
929 rdsfreeblock( XpmFileName );
930 # else
931
932 GraalErrorMessage( GraalMainWindow, "XPM cannot be used: Not enabled at compile time !" );
933
934 # endif
935 }
936