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()