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