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