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