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 : Cursor.c |
33 | |
34 | Author : Jacomme Ludovic |
35 | |
36 | Date : 28.03.95 |
37 | |
38 \------------------------------------------------------------*/
39
40 /*------------------------------------------------------------\
41 | |
42 | Include Files |
43 | |
44 \------------------------------------------------------------*/
45
46 # include <stdio.h>
47 # include <X11/Intrinsic.h>
48 # include <X11/StringDefs.h>
49 # include <Xm/Xm.h>
50
51 # include "mut.h"
52 # include "mph.h"
53 # include "rds.h"
54 # include "rpr.h"
55 # include "GSB.h"
56 # include "GMX.h"
57 # include "GMX_view.h"
58 # include "GMX_grid.h"
59 # include "GMX_cursor.h"
60
61 /*------------------------------------------------------------\
62 | |
63 | Constants |
64 | |
65 \------------------------------------------------------------*/
66 /*------------------------------------------------------------\
67 | |
68 | Types |
69 | |
70 \------------------------------------------------------------*/
71 /*------------------------------------------------------------\
72 | |
73 | Variables |
74 | |
75 \------------------------------------------------------------*/
76 /*------------------------------------------------------------\
77 | |
78 | Buffer |
79 | |
80 \------------------------------------------------------------*/
81
82 static char GraalCursorBuffer[ GRAAL_MAX_CURSOR_BUFFER ];
83
84 /*------------------------------------------------------------\
85 | |
86 | Coordinates |
87 | |
88 \------------------------------------------------------------*/
89
90 Position GraalCursorX = 0;
91 Position GraalCursorY = 0;
92 Position GraalCursorSaveX = 0;
93 Position GraalCursorSaveY = 0;
94 char GraalCursorSaved = GRAAL_FALSE;
95 char GraalCursorInside = GRAAL_FALSE;
96 char GraalCursorType = GRAAL_INPUT_HALF_BOX;
97
98 long GraalLambdaCursorX = 0;
99 long GraalLambdaCursorY = 0;
100 long GraalPixelCursorX = 0;
101 long GraalPixelCursorY = 0;
102
103 long GraalLambdaCursorSaveX[ 2 ] = { 0, 0 };
104 long GraalLambdaCursorSaveY[ 2 ] = { 0, 0 };
105 char GraalCursorIndex = 0;
106
107 /*------------------------------------------------------------\
108 | |
109 | Functions |
110 | |
111 \------------------------------------------------------------*/
112 /*------------------------------------------------------------\
113 | |
114 | GraalComputeCursor |
115 | |
116 \------------------------------------------------------------*/
117
GraalComputeCursor(X,Y)118 void GraalComputeCursor( X, Y )
119
120 Position X;
121 Position Y;
122 {
123 rdsbegin();
124
125 Y = GraalGraphicDy - Y;
126
127 GraalLambdaCursorX = X + GraalPixelGridX;
128 GraalLambdaCursorY = Y + GraalPixelGridY;
129
130 if ( GraalLambdaCursorX < 0 )
131 {
132 GraalLambdaCursorX = ((float)(GraalLambdaCursorX) / GraalLambdaGridStep) - 0.5 ;
133 }
134 else
135 {
136 GraalLambdaCursorX = ((float)(GraalLambdaCursorX) / GraalLambdaGridStep) + 0.5 ;
137 }
138
139 if ( GraalLambdaCursorY < 0 )
140 {
141 GraalLambdaCursorY = ((float)(GraalLambdaCursorY) / GraalLambdaGridStep) - 0.5 ;
142 }
143 else
144 {
145 GraalLambdaCursorY = ((float)(GraalLambdaCursorY) / GraalLambdaGridStep) + 0.5 ;
146 }
147
148 GraalPixelCursorX = ((float)(GraalLambdaCursorX) * GraalLambdaGridStep);
149 GraalPixelCursorY = ((float)(GraalLambdaCursorY) * GraalLambdaGridStep);
150
151 GraalCursorX = GraalPixelCursorX - GraalPixelGridX;
152 GraalCursorY = GraalPixelCursorY - GraalPixelGridY;
153 GraalCursorY = GraalGraphicDy - GraalCursorY;
154
155 rdsend();
156 }
157
158 /*------------------------------------------------------------\
159 | |
160 | GraalDisplayCoordinates |
161 | |
162 \------------------------------------------------------------*/
163
GraalDisplayCoordinates()164 void GraalDisplayCoordinates()
165
166 {
167 rdsbegin();
168
169 sprintf( GraalCursorBuffer, "%.2f", (float)GraalLambdaCursorX / (float)GRAAL_SCALE );
170 GraalDisplayMessage( GRAAL_MESSAGE_X, GraalCursorBuffer );
171
172 sprintf( GraalCursorBuffer, "%.2f", (float)GraalLambdaCursorY / (float)GRAAL_SCALE );
173 GraalDisplayMessage( GRAAL_MESSAGE_Y, GraalCursorBuffer );
174
175 sprintf( GraalCursorBuffer, "%.2f",
176 (float)( GraalLambdaCursorX - GraalLambdaCursorSaveX[0] ) / (float)GRAAL_SCALE );
177 GraalDisplayMessage( GRAAL_MESSAGE_DX, GraalCursorBuffer );
178
179 sprintf( GraalCursorBuffer, "%.2f",
180 (float)( GraalLambdaCursorY - GraalLambdaCursorSaveY[0] ) / (float)GRAAL_SCALE );
181 GraalDisplayMessage( GRAAL_MESSAGE_DY, GraalCursorBuffer );
182
183 rdsend();
184 }
185
186 /*------------------------------------------------------------\
187 | |
188 | GraalPointCursor |
189 | |
190 \------------------------------------------------------------*/
191
GraalPointCursor()192 void GraalPointCursor()
193
194 {
195 rdsbegin();
196
197 GraalUndisplayCursor();
198
199 GraalLambdaCursorSaveX[ (int)GraalCursorIndex ] = GraalLambdaCursorX;
200 GraalLambdaCursorSaveY[ (int)GraalCursorIndex ] = GraalLambdaCursorY;
201
202 GraalCursorIndex = GraalCursorIndex + 1;
203
204 GraalDisplayCursor();
205
206 rdsend();
207 }
208
209 /*------------------------------------------------------------\
210 | |
211 | GraalResetCursor |
212 | |
213 \------------------------------------------------------------*/
214
GraalResetCursor()215 void GraalResetCursor()
216
217 {
218 rdsbegin();
219
220 GraalUndisplayCursor();
221
222 GraalCursorIndex = GraalCursorIndex - 1;
223
224 GraalDisplayCursor();
225
226 rdsend();
227 }
228
229 /*------------------------------------------------------------\
230 | |
231 | GraalChangeCursor |
232 | |
233 \------------------------------------------------------------*/
234
GraalChangeCursorType(ArrayX,ArrayY,Index,Type)235 void GraalChangeCursorType( ArrayX, ArrayY, Index, Type )
236
237 long *ArrayX;
238 long *ArrayY;
239 char Index;
240 char Type;
241 {
242 rdsbegin();
243
244 GraalUndisplayCursor();
245
246 GraalCursorType = Type;
247 GraalCursorIndex = Index;
248
249 if ( Index != 0 )
250 {
251 GraalLambdaCursorSaveX[ 0 ] = ArrayX[0];
252 GraalLambdaCursorSaveY[ 0 ] = ArrayY[0];
253 GraalLambdaCursorSaveX[ 1 ] = ArrayX[1];
254 GraalLambdaCursorSaveY[ 1 ] = ArrayY[1];
255 }
256
257 GraalDisplayCursor();
258
259 rdsend();
260 }
261
262 /*------------------------------------------------------------\
263 | |
264 | GraalDrawCursor |
265 | |
266 \------------------------------------------------------------*/
267
GraalDrawCursor()268 void GraalDrawCursor()
269
270 {
271 long X1;
272 long Y1;
273 long X2;
274 long Y2;
275 long DeltaX;
276 long DeltaY;
277 long Swap;
278 char DrawLine;
279
280 rdsbegin();
281
282 XDrawLine( GraalGraphicDisplay,
283 XtWindow( GraalGraphicWindow ),
284 GraalXorGC,
285 GraalCursorSaveX - GRAAL_CURSOR_SIZE,
286 GraalCursorSaveY - GRAAL_CURSOR_SIZE,
287 GraalCursorSaveX + GRAAL_CURSOR_SIZE,
288 GraalCursorSaveY + GRAAL_CURSOR_SIZE );
289
290 XDrawLine( GraalGraphicDisplay,
291 XtWindow( GraalGraphicWindow ),
292 GraalXorGC,
293 GraalCursorSaveX - GRAAL_CURSOR_SIZE,
294 GraalCursorSaveY + GRAAL_CURSOR_SIZE,
295 GraalCursorSaveX + GRAAL_CURSOR_SIZE,
296 GraalCursorSaveY - GRAAL_CURSOR_SIZE );
297
298 if ( GraalCursorIndex > 0 )
299 {
300 X1 = (float)(GraalLambdaCursorSaveX[0]) * GraalLambdaGridStep;
301 Y1 = (float)(GraalLambdaCursorSaveY[0]) * GraalLambdaGridStep;
302 X1 = X1 - GraalPixelGridX;
303 Y1 = Y1 - GraalPixelGridY;
304 Y1 = GraalGraphicDy - Y1;
305
306 if ( GraalCursorIndex == 1 )
307 {
308 X2 = GraalCursorSaveX;
309 Y2 = GraalCursorSaveY;
310 }
311 else
312 {
313 X2 = (float)(GraalLambdaCursorSaveX[1]) * GraalLambdaGridStep;
314 Y2 = (float)(GraalLambdaCursorSaveY[1]) * GraalLambdaGridStep;
315 X2 = X2 - GraalPixelGridX;
316 Y2 = Y2 - GraalPixelGridY;
317 Y2 = GraalGraphicDy - Y2;
318 }
319
320 switch( GraalCursorType )
321 {
322 case GRAAL_INPUT_POINT :
323
324 break;
325
326 case GRAAL_INPUT_LINE :
327
328 XDrawLine( GraalGraphicDisplay,
329 XtWindow( GraalGraphicWindow ),
330 GraalXorGC,
331 X1, Y1, X2, Y2 );
332 break;
333
334 case GRAAL_INPUT_HALF_BOX :
335
336 XDrawLine( GraalGraphicDisplay,
337 XtWindow( GraalGraphicWindow ),
338 GraalXorGC,
339 X1, Y1, X2, Y1 );
340
341 XDrawLine( GraalGraphicDisplay,
342 XtWindow( GraalGraphicWindow ),
343 GraalXorGC,
344 X2, Y1, X2, Y2 );
345 break;
346
347 case GRAAL_INPUT_ORTHO :
348 case GRAAL_INPUT_SORTHO :
349 case GRAAL_INPUT_LSTRING :
350
351 DeltaX = X2 - X1; if ( DeltaX < 0 ) DeltaX = - DeltaX;
352 DeltaY = Y2 - Y1; if ( DeltaY < 0 ) DeltaY = - DeltaY;
353
354 if ( DeltaX > DeltaY )
355 {
356 Y2 = Y1;
357
358 if ( X1 > X2 ) { Swap = X1; X1 = X2; X2 = Swap; }
359
360 if ( X1 < 0 ) X1 = 0;
361 if ( X2 > GraalGraphicDx ) X2 = GraalGraphicDx;
362
363 if ( ( X1 < X2 ) &&
364 ( Y1 >= 0 ) &&
365 ( Y1 <= GraalGraphicDy ) )
366 {
367 XDrawLine( GraalGraphicDisplay,
368 XtWindow( GraalGraphicWindow ),
369 GraalXorGC,
370 X1, Y1, X2, Y2 );
371 }
372 }
373 else
374 {
375 X2 = X1;
376
377 if ( Y1 > Y2 ) { Swap = Y1; Y1 = Y2; Y2 = Swap; }
378
379 if ( Y1 < 0 ) Y1 = 0;
380 if ( Y2 > GraalGraphicDy ) Y2 = GraalGraphicDy;
381
382 if ( ( Y1 < Y2 ) &&
383 ( X1 >= 0 ) &&
384 ( X1 <= GraalGraphicDx ) )
385 {
386 XDrawLine( GraalGraphicDisplay,
387 XtWindow( GraalGraphicWindow ),
388 GraalXorGC,
389 X1, Y1, X2, Y2 );
390 }
391 }
392
393 break;
394
395 case GRAAL_INPUT_BOX :
396
397 if ( X1 > X2 ) { Swap = X1; X1 = X2; X2 = Swap; }
398 if ( Y1 > Y2 ) { Swap = Y1; Y1 = Y2; Y2 = Swap; }
399
400 DrawLine = 0;
401
402 if ( X1 < 0 )
403 {
404 X1 = 0; DrawLine |= GRAAL_WEST_MASK;
405 }
406
407 if ( X2 > GraalGraphicDx )
408 {
409 X2 = GraalGraphicDx; DrawLine |= GRAAL_EAST_MASK;
410 }
411
412 if ( Y1 < 0 )
413 {
414 Y1 = 0; DrawLine |= GRAAL_SOUTH_MASK;
415 }
416
417 if ( Y2 > GraalGraphicDy )
418 {
419 Y2 = GraalGraphicDy; DrawLine |= GRAAL_NORTH_MASK;
420 }
421
422 if ( DrawLine == 0 )
423 {
424 XDrawRectangle( GraalGraphicDisplay,
425 XtWindow( GraalGraphicWindow ),
426 GraalXorGC,
427 X1, Y1,
428 X2 - X1, Y2 - Y1 );
429 }
430 else
431 {
432 if ( ( DrawLine & GRAAL_WEST_MASK ) == 0 )
433 {
434 XDrawLine( GraalGraphicDisplay,
435 XtWindow( GraalGraphicWindow ),
436 GraalXorGC,
437 X1, Y2,
438 X1, Y1 );
439 }
440
441 if ( ( DrawLine & GRAAL_EAST_MASK ) == 0 )
442 {
443 XDrawLine( GraalGraphicDisplay,
444 XtWindow( GraalGraphicWindow ),
445 GraalXorGC,
446 X2, Y2,
447 X2, Y1 );
448 }
449
450 if ( ( DrawLine & GRAAL_SOUTH_MASK ) == 0 )
451 {
452 XDrawLine( GraalGraphicDisplay,
453 XtWindow( GraalGraphicWindow ),
454 GraalXorGC,
455 X1, Y1,
456 X2, Y1 );
457 }
458
459 if ( ( DrawLine & GRAAL_NORTH_MASK ) == 0 )
460 {
461 XDrawLine( GraalGraphicDisplay,
462 XtWindow( GraalGraphicWindow ),
463 GraalXorGC,
464 X1, Y2,
465 X2, Y2 );
466 }
467 }
468
469 break;
470
471 }
472 }
473
474 rdsend();
475 }
476
477 /*------------------------------------------------------------\
478 | |
479 | GraalUndisplayCursor |
480 | |
481 \------------------------------------------------------------*/
482
GraalUndisplayCursor()483 void GraalUndisplayCursor()
484
485 {
486 rdsbegin();
487
488 if ( GraalCursorInside == GRAAL_TRUE )
489 {
490 if ( GraalCursorSaved == GRAAL_TRUE )
491 {
492 GraalDrawCursor();
493 }
494
495 GraalCursorSaved = GRAAL_FALSE;
496 }
497
498 rdsend();
499 }
500
501 /*------------------------------------------------------------\
502 | |
503 | GraalDisplayCursor |
504 | |
505 \------------------------------------------------------------*/
506
GraalDisplayCursor()507 void GraalDisplayCursor()
508
509 {
510 rdsbegin();
511
512 if ( GraalCursorInside == GRAAL_TRUE )
513 {
514 if ( GraalCursorSaved == GRAAL_TRUE )
515 {
516 GraalDrawCursor();
517
518 GraalCursorSaved = GRAAL_FALSE;
519 }
520
521 if ( ( GraalCursorY >= 0 ) &&
522 ( GraalCursorX <= GraalGraphicDx ) )
523 {
524 GraalCursorSaveX = GraalCursorX;
525 GraalCursorSaveY = GraalCursorY;
526
527 GraalDrawCursor();
528
529 GraalCursorSaved = GRAAL_TRUE;
530 }
531 }
532
533 rdsend();
534 }
535