]> git.saurik.com Git - wxWidgets.git/blob - src/motif/gauge.cpp
use WX_ASSERT_STR/SIZET_EQUAL instead of CPPUNIT_ASSERT_EQUAL with casts
[wxWidgets.git] / src / motif / gauge.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/motif/gauge.cpp
3 // Purpose: wxGauge class
4 // Author: Julian Smart
5 // Modified by:
6 // Created: 17/09/98
7 // RCS-ID: $Id$
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // For compilers that support precompilation, includes "wx.h".
13 #include "wx/wxprec.h"
14
15 #ifdef __VMS
16 #include "wx/vms_x_fix.h"
17 #undef XtDisplay
18 #undef XtScreen
19 #undef XtWindow
20 #undef XtIsRealized
21 #undef XtParent
22 #undef XtClass
23 #endif
24
25 #include "wx/gauge.h"
26
27 #ifndef WX_PRECOMP
28 #include "wx/math.h"
29 #endif
30
31 #ifdef __OS2__
32 #include <types.h>
33 #endif
34
35 #ifdef __VMS__
36 #pragma message disable nosimpint
37 #endif
38 #include <Xm/Xm.h>
39 #ifdef __WXMOTIF20__
40 #include <Xm/Scale.h>
41 #endif // __WXMOTIF20__
42 #ifdef __VMS__
43 #pragma message enable nosimpint
44 #endif
45 #include "wx/motif/private.h"
46
47 IMPLEMENT_DYNAMIC_CLASS(wxGauge, wxControl)
48
49 #if !wxCHECK_MOTIF_VERSION( 2, 0 ) || wxCHECK_LESSTIF()
50
51 // XmGauge copyright notice:
52
53 /*
54 * Copyright 1994 GROUPE BULL
55 *
56 * Permission to use, copy, modify, and distribute this software and its
57 * documentation for any purpose and without fee is hereby granted, provided
58 * that the above copyright notice appear in all copies and that both that
59 * copyright notice and this permission notice appear in supporting
60 * documentation, and that the name of GROUPE BULL not be used in advertising
61 * or publicity pertaining to distribution of the software without specific,
62 * written prior permission. GROUPE BULL makes no representations about the
63 * suitability of this software for any purpose. It is provided "as is"
64 * without express or implied warranty.
65 *
66 * GROUPE BULL disclaims all warranties with regard to this software,
67 * including all implied warranties of merchantability and fitness,
68 * in no event shall GROUPE BULL be liable for any special,
69 * indirect or consequential damages or any damages
70 * whatsoever resulting from loss of use, data or profits,
71 * whether in an action of contract, negligence or other tortious
72 * action, arising out of or in connection with the use
73 * or performance of this software.
74 *
75 */
76
77 //// PUBLIC XMGAUGE DECLARATIONS
78 typedef struct _XmGaugeClassRec* XmGaugeWidgetClass;
79 typedef struct _XmGaugeRec* XmGaugeWidget;
80
81 #ifdef __cplusplus
82 extern "C" WidgetClass xmGaugeWidgetClass;
83 #else
84 extern WidgetClass xmGaugeWidgetClass;
85 #endif
86
87 typedef struct _XmGaugeCallbackStruct{
88 int reason;
89 XEvent *event;
90 int value;
91 } XmGaugeCallbackStruct;
92
93
94 void
95 XmGaugeSetValue(Widget w, int value);
96
97 int
98 XmGaugeGetValue(Widget w);
99
100 #endif // !wxCHECK_MOTIF_VERSION( 2, 0 ) || wxCHECK_LESSTIF()
101
102 bool wxGauge::Create(wxWindow *parent, wxWindowID id,
103 int range,
104 const wxPoint& pos,
105 const wxSize& size,
106 long style,
107 const wxValidator& validator,
108 const wxString& name)
109 {
110 if( !CreateControl( parent, id, pos, size, style, validator, name ) )
111 return false;
112 PreCreation();
113
114 Widget parentWidget = (Widget) parent->GetClientWidget();
115
116 Arg args[7];
117 int count = 4;
118 if (style & wxGA_HORIZONTAL)
119 {
120 XtSetArg (args[0], XmNorientation, XmHORIZONTAL);
121 XtSetArg (args[1], XmNprocessingDirection, XmMAX_ON_RIGHT);
122 }
123 else
124 {
125 XtSetArg (args[0], XmNorientation, XmVERTICAL);
126 XtSetArg (args[1], XmNprocessingDirection, XmMAX_ON_TOP);
127 }
128 XtSetArg(args[2], XmNminimum, 0);
129 XtSetArg(args[3], XmNmaximum, range);
130 #if wxCHECK_MOTIF_VERSION( 2, 0 ) && !wxCHECK_LESSTIF()
131 XtSetArg(args[4], XmNeditable, False); ++count;
132 XtSetArg(args[5], XmNslidingMode, XmTHERMOMETER); ++count;
133 // XtSetArg(args[6], XmNsliderVisual, XmFOREGROUND_COLOR ); ++count;
134 Widget gaugeWidget =
135 XtCreateManagedWidget("gauge", xmScaleWidgetClass,
136 parentWidget, args, count);
137 #else
138 Widget gaugeWidget =
139 XtCreateManagedWidget("gauge", xmGaugeWidgetClass,
140 parentWidget, args, count);
141 #endif
142 m_mainWidget = (WXWidget) gaugeWidget ;
143
144 XtManageChild (gaugeWidget);
145
146 int x = pos.x; int y = pos.y;
147 wxSize best = GetBestSize();
148 if( size.x != wxDefaultCoord ) best.x = size.x;
149 if( size.y != wxDefaultCoord ) best.y = size.y;
150
151 PostCreation();
152 AttachWidget (parent, m_mainWidget, (WXWidget) NULL, x, y,
153 best.x, best.y);
154
155 return true;
156 }
157
158 wxSize wxGauge::DoGetBestSize() const
159 {
160 if( HasFlag(wxGA_HORIZONTAL) )
161 return wxSize( 100, 18 );
162 else
163 return wxSize( 18, 100 );
164 }
165
166 void wxGauge::SetShadowWidth(int w)
167 {
168 if (w == 0)
169 w = 1;
170 XtVaSetValues((Widget) m_mainWidget, XmNshadowThickness, w, NULL);
171 }
172
173 void wxGauge::SetRange(int r)
174 {
175 XtVaSetValues((Widget) m_mainWidget, XmNmaximum, r, NULL);
176 }
177
178 void wxGauge::SetValue(int pos)
179 {
180 XtVaSetValues((Widget) m_mainWidget, XmNvalue, pos, NULL);
181 }
182
183 int wxGauge::GetShadowWidth() const
184 {
185 Dimension w;
186 XtVaGetValues((Widget) m_mainWidget, XmNshadowThickness, &w, NULL);
187 return (int)w;
188 }
189
190 int wxGauge::GetRange() const
191 {
192 int r;
193 XtVaGetValues((Widget) m_mainWidget, XmNmaximum, &r, NULL);
194 return (int)r;
195 }
196
197 int wxGauge::GetValue() const
198 {
199 int pos;
200 XtVaGetValues((Widget) m_mainWidget, XmNvalue, &pos, NULL);
201 return pos;
202 }
203
204 void wxGauge::DoMoveWindow(int x, int y, int width, int height)
205 {
206 wxGaugeBase::DoMoveWindow( x, y, width, height );
207 #ifdef __WXMOTIF20__
208 XtVaSetValues( (Widget)m_mainWidget,
209 XmNscaleHeight, height,
210 NULL );
211 #endif
212 }
213
214 #if !wxCHECK_MOTIF_VERSION( 2, 0 ) || wxCHECK_LESSTIF()
215
216 //// PRIVATE DECLARATIONS FOR XMGAUGE
217
218 #include <Xm/PrimitiveP.h>
219 #include <Xm/DrawP.h>
220
221 typedef struct {
222 int empty;
223 } XmGaugeClassPart;
224
225 typedef struct _XmGaugeClassRec {
226 CoreClassPart core_class;
227 XmPrimitiveClassPart primitive_class;
228 XmGaugeClassPart gauge_class;
229 } XmGaugeClassRec;
230
231
232 typedef struct _XmGaugePart{
233 int value;
234 int minimum;
235 int maximum;
236 unsigned char orientation;
237 unsigned char processingDirection;
238
239 XtCallbackList dragCallback;
240 XtCallbackList valueChangedCallback;
241
242 /* private fields */
243 Boolean dragging; /* drag in progress ? */
244 int oldx, oldy;
245 GC gc;
246 } XmGaugePart;
247
248
249 typedef struct _XmGaugeRec {
250 CorePart core;
251 XmPrimitivePart primitive;
252 XmGaugePart gauge;
253 } XmGaugeRec;
254
255 extern XmGaugeClassRec xmGaugeClassRec;
256
257 /* Copyright 1994 GROUPE BULL -- See license conditions in file COPYRIGHT */
258
259 //// XMGAUGE IMPLEMENTATION
260
261 void
262 GaugePick(Widget w, XEvent *e, String *args, Cardinal *num_args);
263 void
264 GaugeDrag(Widget w, XEvent *e, String *args, Cardinal *num_args);
265 void
266 GaugeDrop(Widget w, XEvent *e, String *args, Cardinal *num_args);
267
268
269
270 static char translations[] =
271 "<Btn1Down>: GaugePick()\n\
272 <Btn1Motion>: GaugeDrag()\n\
273 <Btn1Up>: GaugeDrop()\n\
274 ";
275
276
277
278 static XtActionsRec actions[] = {
279 {"GaugePick", GaugePick},
280 {"GaugeDrag", GaugeDrag},
281 {"GaugeDrop", GaugeDrop},
282 };
283
284 static void
285 DrawSlider(XmGaugeWidget gw, Boolean clear)
286 {
287 #define THIS gw->gauge
288 int size, sht;
289 float ratio;
290 /***chubraev
291 char string[20];
292 int len;
293 unsigned long backgr,foregr;
294 XRectangle rects[1];
295 ***/
296
297 sht = gw->primitive.shadow_thickness;
298
299 ratio = (float)THIS.value/
300 (float)(THIS.maximum - THIS.minimum);
301 /***chubraev
302 sprintf(string,"%-d%%",(int)(ratio*100));
303 len=strlen(string);
304 XtVaGetValues(gw,XmNbackground,&backgr,XmNforeground,&foregr,NULL);
305 ***/
306
307 if(clear) {
308 XClearArea(XtDisplay(gw), XtWindow(gw), sht, sht,
309 gw->core.width - 2 * sht, gw->core.height - 2 * sht, False);
310 }
311 switch(THIS.orientation) {
312 case XmHORIZONTAL:
313 size = (int) ((gw->core.width - 2 * sht)*ratio);
314 /***chubraev
315 XDrawString(XtDisplay(gw), XtWindow(gw), THIS.gc, sht+gw->core.width/2,
316 gw->core.height - 2 * sht, string, len);
317 ***/
318 switch(THIS.processingDirection) {
319 case XmMAX_ON_RIGHT:
320 case XmMAX_ON_BOTTOM:
321 XFillRectangle(XtDisplay(gw), XtWindow(gw), THIS.gc,
322 sht, sht, size, gw->core.height - 2 * sht);
323
324 /***chubraev
325 rects[0].x = sht; rects[0].y = sht;
326 rects[0].width = size; rects[0].height = gw->core.height - 2 * sht;
327 ***/
328 break;
329 case XmMAX_ON_LEFT:
330 case XmMAX_ON_TOP:
331 XFillRectangle(XtDisplay(gw), XtWindow(gw), THIS.gc,
332 gw->core.width - size - sht, sht,
333 size, gw->core.height - 2 * sht);
334
335 /***chubraev
336 rects[0].x = gw->core.width - size - sht; rects[0].y = sht;
337 rects[0].width = size; rects[0].height = gw->core.height - 2 * sht;
338 ***/
339 break;
340 }
341 /***chubraev
342 XSetClipRectangles(XtDisplay(gw), THIS.gc, 0, 0, rects, 1, Unsorted);
343 XSetForeground(XtDisplay(gw), THIS.gc, backgr);
344 XDrawString(XtDisplay(gw), XtWindow(gw), THIS.gc, sht+gw->core.width/2,
345 gw->core.height - 2 * sht, string, len);
346 ***/
347
348 break;
349 case XmVERTICAL:
350 size = (int) ((gw->core.height - 2 * sht)*ratio);
351 /***chubraev
352 XDrawString(XtDisplay(gw), XtWindow(gw), THIS.gc, sht,
353 sht+gw->core.height/2, string,len);
354 ***/
355 switch(THIS.processingDirection) {
356 case XmMAX_ON_RIGHT:
357 case XmMAX_ON_BOTTOM:
358 XFillRectangle(XtDisplay(gw), XtWindow(gw), THIS.gc,
359 sht, sht, gw->core.width - 2 * sht, size);
360
361 /***chubraev
362 rects[0].x = sht; rects[0].y = sht;
363 rects[0].width = gw->core.width - 2 * sht; rects[0].height = size;
364 ***/
365 break;
366 case XmMAX_ON_LEFT:
367 case XmMAX_ON_TOP:
368 XFillRectangle(XtDisplay(gw), XtWindow(gw), THIS.gc,
369 sht, gw->core.height - size - sht,
370 gw->core.width - 2 * sht, size);
371
372 /***chubraev
373 rects[0].x = sht; rects[0].y = gw->core.height - size - sht;
374 rects[0].width = gw->core.width - 2 * sht; rects[0].height = size;
375 ***/
376 }
377 /***chubraev
378 XSetClipRectangles(XtDisplay(gw), THIS.gc, 0, 0, rects, 1, Unsorted);
379 XSetForeground(XtDisplay(gw), THIS.gc, backgr);
380 XDrawString(XtDisplay(gw), XtWindow(gw), THIS.gc, sht,
381 sht+gw->core.height/2, string,len);
382 ***/
383 break;
384 }
385 /***chubraev
386 XSetClipMask(XtDisplay(gw), THIS.gc, None);
387 XSetForeground(XtDisplay(gw), THIS.gc, foregr);
388 ***/
389 #undef THIS
390 }
391
392 /* Old code
393 */
394 #if 0
395 static void
396 DrawSlider(XmGaugeWidget gw, Boolean clear)
397 {
398 #define THIS gw->gauge
399 int size, sht;
400 /* float ratio; */
401
402 sht = gw->primitive.shadow_thickness;
403 /* See fix comment below: can cause divide by zero error.
404 ratio = (float)((float)THIS.maximum -
405 (float)THIS.minimum) / (float)THIS.value;
406 */
407 if(clear) {
408 XClearArea(XtDisplay(gw), XtWindow(gw), sht, sht,
409 gw->core.width - 2 * sht, gw->core.height - 2 * sht, False);
410 }
411 switch(THIS.orientation) {
412 case XmHORIZONTAL:
413 /* size = (gw->core.width - 2 * sht) / ratio; */
414 /* A fix suggested by Dmitri Chubraev */
415 size = (gw->core.width - 2 * sht) /((float)THIS.maximum-(float)THIS.minimum)*(float)THIS.value;
416 switch(THIS.processingDirection) {
417 case XmMAX_ON_RIGHT:
418 case XmMAX_ON_BOTTOM:
419 XFillRectangle(XtDisplay(gw), XtWindow(gw), THIS.gc,
420 sht, sht, size, gw->core.height - 2 * sht);
421 break;
422 case XmMAX_ON_LEFT:
423 case XmMAX_ON_TOP:
424 XFillRectangle(XtDisplay(gw), XtWindow(gw), THIS.gc,
425 gw->core.width - size - sht, sht,
426 size, gw->core.height - 2 * sht);
427 break;
428 }
429 break;
430 case XmVERTICAL:
431 size = (gw->core.height - 2 * sht) /((float)THIS.maximum-(float)THIS.minimum)*(float)THIS.value;
432 /* size = (gw->core.height - 2 * sht)/ ratio; */
433 switch(THIS.processingDirection) {
434 case XmMAX_ON_RIGHT:
435 case XmMAX_ON_BOTTOM:
436 XFillRectangle(XtDisplay(gw), XtWindow(gw), THIS.gc,
437 sht, sht, gw->core.width - 2 * sht, size);
438 break;
439 case XmMAX_ON_LEFT:
440 case XmMAX_ON_TOP:
441 XFillRectangle(XtDisplay(gw), XtWindow(gw), THIS.gc,
442 sht, gw->core.height - size - sht,
443 gw->core.width - 2 * sht, size);
444 }
445 break;
446 }
447 #undef THIS
448 }
449 #endif
450
451 static void
452 Initialize(Widget WXUNUSED(req), Widget new_w, ArgList WXUNUSED(args), Cardinal *WXUNUSED(num_args ))
453 {
454 XmGaugeWidget gw = (XmGaugeWidget)new_w;
455 #define THIS gw->gauge
456 XGCValues values;
457
458 values.foreground = gw->primitive.foreground;
459 THIS.gc = XtGetGC(new_w, GCForeground, &values);
460
461 #undef THIS
462
463 }
464
465
466
467 static void
468 Destroy(Widget w)
469 {
470 XmGaugeWidget gw = (XmGaugeWidget)w;
471 #define THIS gw->gauge
472 XtReleaseGC(w, THIS.gc);
473 #undef THIS
474 }
475
476
477
478
479 static Boolean
480 SetValues(
481 Widget cw,
482 Widget WXUNUSED(rw),
483 Widget nw,
484 ArgList WXUNUSED(args),
485 Cardinal *WXUNUSED(num_args) )
486 {
487 XmGaugeWidget cgw = (XmGaugeWidget)cw;
488 XmGaugeWidget ngw = (XmGaugeWidget)nw;
489
490 Boolean redraw = False;
491 if(cgw->primitive.foreground != ngw->primitive.foreground) {
492 XGCValues values;
493
494 redraw = True;
495 XtReleaseGC(nw, ngw->gauge.gc);
496 values.foreground = ngw->primitive.foreground;
497 ngw->gauge.gc = XtGetGC(nw, GCForeground, &values);
498 }
499 if(cgw->gauge.value != ngw->gauge.value) {
500 redraw = True;
501 }
502 return redraw;
503 }
504
505
506
507
508 static void
509 ExposeProc(Widget w, XEvent *WXUNUSED(event), Region WXUNUSED(r))
510 {
511 XmGaugeWidget gw = (XmGaugeWidget)w;
512 #define THIS gw->gauge
513 int sht;
514
515 sht = gw->primitive.shadow_thickness;
516 _XmDrawShadows(XtDisplay(w), XtWindow(w),
517 gw->primitive.top_shadow_GC,
518 gw->primitive.bottom_shadow_GC,
519 0, 0, w->core.width, w->core.height,
520 (Dimension)sht, XmSHADOW_IN);
521 DrawSlider(gw, False);
522 #undef THIS
523 }
524
525
526
527
528
529 static XtResource
530 resources[] = {
531 #define offset(field) XtOffset(XmGaugeWidget, gauge.field)
532 {XmNvalue, XmCValue, XtRInt, sizeof(int),
533 offset(value), XtRImmediate, (caddr_t)10},
534
535 {XmNminimum, XmCValue, XtRInt, sizeof(int),
536 offset(minimum), XtRImmediate, (caddr_t)0},
537
538 {XmNmaximum, XmCValue, XtRInt, sizeof(int),
539 offset(maximum), XtRImmediate, (caddr_t)100},
540
541 {XmNorientation, XmCOrientation, XmROrientation, sizeof(unsigned char),
542 offset(orientation), XtRImmediate, (caddr_t)XmVERTICAL},
543
544 {XmNprocessingDirection, XmCProcessingDirection,
545 XmRProcessingDirection, sizeof(unsigned char),
546 offset(processingDirection), XtRImmediate, (caddr_t)XmMAX_ON_RIGHT},
547
548 {XmNdragCallback, XmCCallback, XmRCallback, sizeof(XtCallbackList),
549 offset(dragCallback), XtRImmediate, (caddr_t)NULL},
550
551 {XmNvalueChangedCallback, XmCCallback, XmRCallback, sizeof(XtCallbackList),
552 offset(valueChangedCallback), XtRImmediate, (caddr_t)NULL},
553
554
555 #undef offset
556 };
557
558
559 XmGaugeClassRec xmGaugeClassRec = {
560 { /* core fields */
561 (WidgetClass) &xmPrimitiveClassRec, /* superclass */
562 "XmGauge", /* class_name */
563 sizeof(XmGaugeRec), /* widget_size */
564 NULL, /* class_initialize */
565 NULL, /* class_part_initialize */
566 False, /* class_inited */
567 Initialize, /* initialize */
568 NULL, /* initialize_hook */
569 XtInheritRealize, /* realize */
570 actions, /* actions */
571 XtNumber(actions), /* num_actions */
572 resources, /* resources */
573 XtNumber(resources), /* num_resources */
574 NULLQUARK, /* xrm_class */
575 True, /* compress_motion */
576 True, /* compress_exposure */
577 True, /* compress_enterleave */
578 False, /* visible_interest */
579 Destroy, /* destroy */
580 NULL, /* resize */
581 ExposeProc, /* expose */
582 SetValues, /* set_values */
583 NULL, /* set_values_hook */
584 XtInheritSetValuesAlmost, /* set_values_almost */
585 NULL, /* get_values_hook */
586 NULL, /* accept_focus */
587 XtVersion, /* version */
588 NULL, /* callback_private */
589 translations, /* tm_table */
590 NULL, /* query_geometry */
591 NULL, /* display_accelerator */
592 NULL /* extension */
593 },
594 /* primitive_class fields */
595 {
596 NULL, /* border_highlight */
597 NULL, /* border_unhighlight */
598 NULL, /* translations */
599 NULL, /* arm_and_activate */
600 NULL, /* syn_resources */
601 0, /* num_syn_resources */
602 NULL /* extension */
603 },
604 { /* gauge fields */
605 0 /* empty */
606 }
607 };
608
609 WidgetClass xmGaugeWidgetClass = (WidgetClass)&xmGaugeClassRec;
610
611
612
613
614 void
615 GaugePick(Widget WXUNUSED(w), XEvent *WXUNUSED(e), String *WXUNUSED(args), Cardinal *WXUNUSED(num_args))
616 {
617 /* Commented out for a read-only gauge in wxWidgets */
618 #if 0
619 XmGaugeWidget gw = (XmGaugeWidget)w;
620 #define THIS gw->gauge
621 int size, sht;
622 float ratio;
623 Boolean dragging = False;
624 XButtonEvent *event = (XButtonEvent *)e;
625 int x, y;
626
627 x = event->x;
628 y = event->y;
629 sht = gw->primitive.shadow_thickness;
630 _XmDrawShadows(XtDisplay(w), XtWindow(w),
631 gw->primitive.top_shadow_GC,
632 gw->primitive.bottom_shadow_GC,
633 0, 0, w->core.width, w->core.height,
634 sht, XmSHADOW_IN);
635
636
637 ratio = (float)((float)THIS.maximum -
638 (float)THIS.minimum) / (float)THIS.value;
639 switch(THIS.orientation) {
640 case XmHORIZONTAL:
641 size = (w->core.width - 2 * sht) / ratio;
642 switch(THIS.processingDirection) {
643 case XmMAX_ON_RIGHT:
644 case XmMAX_ON_BOTTOM:
645 dragging = (x > sht) && (y > sht) &&
646 (x < sht + size) && (y < w->core.height - sht);
647 break;
648 case XmMAX_ON_LEFT:
649 case XmMAX_ON_TOP:
650 dragging = (x > w->core.width - size - sht) && (y > sht) &&
651 (x < w->core.width - sht) && (y < w->core.height + sht);
652 break;
653 }
654 break;
655 case XmVERTICAL:
656 size = (w->core.height - 2 * sht) / ratio;
657 switch(THIS.processingDirection) {
658 case XmMAX_ON_RIGHT:
659 case XmMAX_ON_BOTTOM:
660 dragging = (x > sht) && (y > sht) &&
661 (x < w->core.width - sht) &&
662 (y < w->core.width - 2 * sht + size);
663 break;
664 case XmMAX_ON_LEFT:
665 case XmMAX_ON_TOP:
666 dragging = (x > sht) && (y > w->core.height - size - sht) &&
667 (x < w->core.width - sht) && (y < w->core.height - sht);
668 }
669 break;
670 }
671 THIS.dragging = dragging;
672 THIS.oldx = x;
673 THIS.oldy = y;
674 #undef THIS
675 #endif
676 }
677
678 void
679 GaugeDrag(Widget WXUNUSED(w), XEvent *WXUNUSED(e), String *WXUNUSED(args), Cardinal *WXUNUSED(num_args))
680 {
681 /* Commented out for a read-only gauge in wxWidgets */
682 #if 0
683 XmGaugeWidget gw = (XmGaugeWidget)w;
684 #define THIS gw->gauge
685 int sht, x, y, max, value;
686 float ratio, nratio, size, nsize, fvalue, delta;
687 XMotionEvent *event = (XMotionEvent *)e;
688
689 if( ! THIS.dragging) return;
690
691 x = event->x;
692 y = event->y;
693 sht = gw->primitive.shadow_thickness;
694
695 ratio = (float)THIS.value / (float)((float)THIS.maximum -
696 (float)THIS.minimum);
697 switch(THIS.orientation) {
698 case XmHORIZONTAL:
699 max = (w->core.width - 2 * sht);
700 size = (float)max * ratio;
701 delta = (float)x - (float)THIS.oldx;
702 break;
703 case XmVERTICAL:
704 max = (w->core.height - 2 * sht);
705 size = (float) max * ratio;
706 delta = (float)y - (float)THIS.oldy;
707 break;
708 }
709 switch(THIS.processingDirection) {
710 case XmMAX_ON_RIGHT:
711 case XmMAX_ON_BOTTOM:
712 nsize = size + delta;
713 break;
714 default:
715 nsize = size - delta;
716 }
717 if(nsize > (float)max) nsize = (float)max;
718 if(nsize < (float)0 ) nsize = (float)0;
719 nratio = nsize / (float)max;
720
721 fvalue = (int)((float)THIS.maximum -
722 (float)THIS.minimum) * (float)nsize / (float)max;
723 value = wxRound(fvalue);
724
725 THIS.value = value;
726 THIS.oldx = x;
727 THIS.oldy = y;
728
729 /* clear old slider only if it was larger */
730 DrawSlider(gw, (nsize < size));
731
732 {
733 XmGaugeCallbackStruct call;
734
735 if(NULL != THIS.dragCallback) {
736 call.reason = XmCR_DRAG;
737 call.event = e;
738 call.value = THIS.value;
739 XtCallCallbacks(w, XmNdragCallback, &call);
740 }
741 }
742 #undef THIS
743 #endif
744 }
745
746
747 void
748 GaugeDrop(Widget WXUNUSED(w), XEvent *WXUNUSED(e), String *WXUNUSED(args), Cardinal *WXUNUSED(num_args))
749 {
750 /* Commented out for a read-only gauge in wxWidgets */
751 #if 0
752 XmGaugeWidget gw = (XmGaugeWidget)w;
753 #define THIS gw->gauge
754 if( ! THIS.dragging) return;
755
756 if(NULL != THIS.valueChangedCallback) {
757 XmGaugeCallbackStruct call;
758 call.reason = XmCR_VALUE_CHANGED;
759 call.event = e;
760 call.value = THIS.value;
761 XtCallCallbacks(w, XmNvalueChangedCallback, &call);
762 }
763 THIS.dragging = False;
764 #undef THIS
765 #endif
766 }
767
768 void
769 XmGaugeSetValue(Widget w, int value)
770 {
771 XmGaugeWidget gw = (XmGaugeWidget)w;
772
773 gw->gauge.value = value;
774 DrawSlider(gw, True);
775 XFlush(XtDisplay(w));
776 }
777
778 int
779 XmGaugeGetValue(Widget w)
780 {
781 XmGaugeWidget gw = (XmGaugeWidget)w;
782
783 return gw->gauge.value;
784 }
785
786 #endif // !wxCHECK_MOTIF_VERSION( 2, 0 ) || wxCHECK_LESSTIF()