src/motif/gauge.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        gauge.cpp
// Purpose:     wxGauge class
// Author:      Julian Smart
// Modified by:
// Created:     17/09/98
// RCS-ID:      $Id$
// Copyright:   (c) Julian Smart
// Licence:   	wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#ifdef __GNUG__
#pragma implementation "gauge.h"
#endif

#ifdef __VMS__
#include <wx/vms_x_fix.h>
#endif

# include "wx/gauge.h"

#ifdef __VMS__
#pragma message disable nosimpint
#endif
#include <Xm/Xm.h>
#ifdef __VMS__
#pragma message enable nosimpint
#endif
#include "wx/motif/private.h"

IMPLEMENT_DYNAMIC_CLASS(wxGauge, wxControl)

// XmGauge copyright notice:

/*
* Copyright 1994 GROUPE BULL
*
* Permission to use, copy, modify, and distribute this software and its
* documentation for any purpose and without fee is hereby granted, provided
* that the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation, and that the name of GROUPE BULL not be used in advertising
* or publicity pertaining to distribution of the software without specific,
* written prior permission.  GROUPE BULL makes no representations about the
* suitability of this software for any purpose.  It is provided "as is"
* without express or implied warranty.
*
* GROUPE BULL disclaims all warranties with regard to this software,
* including all implied warranties of merchantability and fitness,
* in no event shall GROUPE BULL be liable for any special,
* indirect or consequential damages or any damages
* whatsoever resulting from loss of use, data or profits,
* whether in an action of contract, negligence or other tortious
* action, arising out of or in connection with the use
* or performance of this software.
*
*/

//// PUBLIC XMGAUGE DECLARATIONS
typedef struct _XmGaugeClassRec*	XmGaugeWidgetClass;
typedef struct _XmGaugeRec*	        XmGaugeWidget;

#ifdef __cplusplus
extern "C" WidgetClass xmGaugeWidgetClass;
#else
extern WidgetClass xmGaugeWidgetClass;
#endif

typedef struct _XmGaugeCallbackStruct{
    int reason;
    XEvent *event;
    int value;
} XmGaugeCallbackStruct;


void
XmGaugeSetValue(Widget w, int value);

int
XmGaugeGetValue(Widget w);


bool wxGauge::Create(wxWindow *parent, wxWindowID id,
                     int range,
                     const wxPoint& pos,
                     const wxSize& size,
                     long style,
                     const wxValidator& validator,
                     const wxString& name)
{
    SetName(name);
    SetValidator(validator);
    m_rangeMax = range;
    m_windowStyle = style;
    m_backgroundColour = parent->GetBackgroundColour();
    m_foregroundColour = parent->GetForegroundColour();

    if (parent) parent->AddChild(this);

    if ( id == -1 )
        m_windowId = (int)NewControlId();
    else
        m_windowId = id;

    Widget parentWidget = (Widget) parent->GetClientWidget();

    Arg args[4];
    int count = 4;
    if (style & wxHORIZONTAL)
    {
        XtSetArg (args[0], XmNorientation, XmHORIZONTAL);
        XtSetArg (args[1], XmNprocessingDirection, XmMAX_ON_RIGHT);
    }
    else
    {
        XtSetArg (args[0], XmNorientation, XmVERTICAL);
        XtSetArg (args[1], XmNprocessingDirection, XmMAX_ON_TOP);
    }
    XtSetArg(args[2], XmNminimum, 0);
    XtSetArg(args[3], XmNmaximum, range);
    Widget gaugeWidget = XtCreateManagedWidget("gauge", xmGaugeWidgetClass, parentWidget, args, count);
    m_mainWidget = (WXWidget) gaugeWidget ;

    XtManageChild (gaugeWidget);

    int x = pos.x; int y = pos.y;
    int width = size.x; int height = size.y;
    if (width == -1)
        width = 150;
    if (height == -1)
        height = 80;

    m_font = parent->GetFont();
    ChangeFont(FALSE);

    SetCanAddEventHandler(TRUE);
    AttachWidget (parent, m_mainWidget, (WXWidget) NULL, x, y, width, height);

    ChangeBackgroundColour();

    return TRUE;
}

void wxGauge::SetShadowWidth(int w)
{
    if (w == 0)
        w = 1;
    XtVaSetValues((Widget) m_mainWidget, XmNshadowThickness, w, NULL);
}

void wxGauge::SetBezelFace(int WXUNUSED(w))
{
}

void wxGauge::SetRange(int r)
{
    m_rangeMax = r;
    XtVaSetValues((Widget) m_mainWidget, XmNmaximum, r, NULL);
}

void wxGauge::SetValue(int pos)
{
    m_gaugePos = pos;
    XtVaSetValues((Widget) m_mainWidget, XmNvalue, pos, NULL);
}

int wxGauge::GetShadowWidth() const
{
    Dimension w;
    XtVaGetValues((Widget) m_mainWidget, XmNshadowThickness, &w, NULL);
    return (int)w;
}

int wxGauge::GetBezelFace() const
{
    return 0;
}

int wxGauge::GetRange() const
{
    int r;
    XtVaGetValues((Widget) m_mainWidget, XmNmaximum, &r, NULL);
    return (int)r;
    //    return m_rangeMax;
}

int wxGauge::GetValue() const
{
    int pos;
    XtVaGetValues((Widget) m_mainWidget, XmNvalue, &pos, NULL);
    return pos;
    //    return m_gaugePos;
}

void wxGauge::ChangeFont(bool keepOriginalSize)
{
    wxWindow::ChangeFont(keepOriginalSize);
}

void wxGauge::ChangeBackgroundColour()
{
    wxWindow::ChangeBackgroundColour();
}

void wxGauge::ChangeForegroundColour()
{
    wxWindow::ChangeForegroundColour();
}

//// PRIVATE DECLARATIONS FOR XMGAUGE

#include <Xm/PrimitiveP.h>
#include <Xm/DrawP.h>

typedef struct {
    int empty;
} XmGaugeClassPart;

typedef struct _XmGaugeClassRec {
    CoreClassPart	        core_class;
    XmPrimitiveClassPart	primitive_class;
    XmGaugeClassPart	        gauge_class;
} XmGaugeClassRec;


typedef struct _XmGaugePart{
    int value;
    int minimum;
    int maximum;
    unsigned char orientation;
    unsigned char processingDirection;

    XtCallbackList dragCallback;
    XtCallbackList valueChangedCallback;

    /* private fields */
    Boolean dragging;		/* drag in progress ? */
    int oldx, oldy;
    GC gc;
} XmGaugePart;


typedef struct _XmGaugeRec {
    CorePart		core;
    XmPrimitivePart	primitive;
    XmGaugePart	        gauge;
} XmGaugeRec;

extern XmGaugeClassRec xmGaugeClassRec;

/* Copyright 1994 GROUPE BULL -- See license conditions in file COPYRIGHT */

//// XMGAUGE IMPLEMENTATION

void
GaugePick(Widget w, XEvent *e, String *args, Cardinal  *num_args);
void
GaugeDrag(Widget w, XEvent *e, String *args, Cardinal  *num_args);
void
GaugeDrop(Widget w, XEvent *e, String *args, Cardinal  *num_args);


static char translations[] =
"<Btn1Down>: GaugePick()\n\
                            <Btn1Motion>: GaugeDrag()\n\
                            <Btn1Up>: GaugeDrop()\n\
                            ";


static XtActionsRec actions[] = {
    {"GaugePick", GaugePick},
    {"GaugeDrag", GaugeDrag},
    {"GaugeDrop", GaugeDrop},
};

static void
DrawSlider(XmGaugeWidget gw, Boolean clear)
{
#define THIS gw->gauge
    int size, sht;
    float ratio;
    /***chubraev
    char string[20];
    int len;
    unsigned long backgr,foregr;
    XRectangle rects[1];
    ***/

    sht = gw->primitive.shadow_thickness;

    ratio =  (float)THIS.value/
        (float)(THIS.maximum - THIS.minimum);
        /***chubraev
        sprintf(string,"%-d%%",(int)(ratio*100));
        len=strlen(string);
        XtVaGetValues(gw,XmNbackground,&backgr,XmNforeground,&foregr,NULL);
    ***/

    if(clear) {
        XClearArea(XtDisplay(gw), XtWindow(gw), sht, sht,
            gw->core.width - 2 * sht, gw->core.height - 2 * sht, False);
    }
    switch(THIS.orientation) {
    case XmHORIZONTAL:
        size = (int) ((gw->core.width - 2 * sht)*ratio);
        /***chubraev
        XDrawString(XtDisplay(gw), XtWindow(gw), THIS.gc, sht+gw->core.width/2,
        gw->core.height - 2 * sht, string, len);
        ***/
        switch(THIS.processingDirection) {
        case XmMAX_ON_RIGHT:
        case XmMAX_ON_BOTTOM:
            XFillRectangle(XtDisplay(gw), XtWindow(gw), THIS.gc,
                sht, sht, size, gw->core.height - 2 * sht);

                /***chubraev
                rects[0].x = sht; rects[0].y = sht;
                rects[0].width = size; rects[0].height = gw->core.height - 2 * sht;
            ***/
            break;
        case XmMAX_ON_LEFT:
        case XmMAX_ON_TOP:
            XFillRectangle(XtDisplay(gw), XtWindow(gw), THIS.gc,
                gw->core.width - size - sht, sht,
                size, gw->core.height - 2 * sht);

                /***chubraev
                rects[0].x = gw->core.width - size - sht; rects[0].y = sht;
                rects[0].width = size; rects[0].height = gw->core.height - 2 * sht;
            ***/
            break;
        }
        /***chubraev
        XSetClipRectangles(XtDisplay(gw), THIS.gc, 0, 0, rects, 1, Unsorted);
        XSetForeground(XtDisplay(gw), THIS.gc, backgr);
        XDrawString(XtDisplay(gw), XtWindow(gw), THIS.gc, sht+gw->core.width/2,
        gw->core.height - 2 * sht, string, len);
        ***/

        break;
        case XmVERTICAL:
            size = (int) ((gw->core.height - 2 * sht)*ratio);
            /***chubraev
            XDrawString(XtDisplay(gw), XtWindow(gw), THIS.gc, sht,
            sht+gw->core.height/2, string,len);
            ***/
            switch(THIS.processingDirection) {
            case XmMAX_ON_RIGHT:
            case XmMAX_ON_BOTTOM:
                XFillRectangle(XtDisplay(gw), XtWindow(gw), THIS.gc,
                    sht, sht, gw->core.width - 2 * sht, size);

                    /***chubraev
                    rects[0].x = sht; rects[0].y = sht;
                    rects[0].width = gw->core.width - 2 * sht; rects[0].height = size;
                ***/
                break;
            case XmMAX_ON_LEFT:
            case XmMAX_ON_TOP:
                XFillRectangle(XtDisplay(gw), XtWindow(gw), THIS.gc,
                    sht, gw->core.height - size - sht,
                    gw->core.width - 2 * sht, size);

                    /***chubraev
                    rects[0].x = sht; rects[0].y = gw->core.height - size - sht;
                    rects[0].width = gw->core.width - 2 * sht; rects[0].height = size;
                ***/
            }
            /***chubraev
            XSetClipRectangles(XtDisplay(gw), THIS.gc, 0, 0, rects, 1, Unsorted);
            XSetForeground(XtDisplay(gw), THIS.gc, backgr);
            XDrawString(XtDisplay(gw), XtWindow(gw), THIS.gc, sht,
            sht+gw->core.height/2, string,len);
            ***/
            break;
    }
    /***chubraev
    XSetClipMask(XtDisplay(gw), THIS.gc, None);
    XSetForeground(XtDisplay(gw), THIS.gc, foregr);
    ***/
#undef THIS
}

/* Old code
*/
#if 0
static void
DrawSlider(XmGaugeWidget gw, Boolean clear)
{
#define THIS gw->gauge
    int size, sht;
    /*    float ratio; */

    sht = gw->primitive.shadow_thickness;
    /* See fix comment below: can cause divide by zero error.
    ratio = (float)((float)THIS.maximum -
    (float)THIS.minimum) / (float)THIS.value;
    */
    if(clear) {
        XClearArea(XtDisplay(gw), XtWindow(gw), sht, sht,
            gw->core.width - 2 * sht, gw->core.height - 2 * sht, False);
    }
    switch(THIS.orientation) {
    case XmHORIZONTAL:
        /*	size = (gw->core.width - 2 * sht) / ratio; */
        /* A fix suggested by Dmitri Chubraev */
        size = (gw->core.width - 2 * sht) /((float)THIS.maximum-(float)THIS.minimum)*(float)THIS.value;
        switch(THIS.processingDirection) {
        case XmMAX_ON_RIGHT:
        case XmMAX_ON_BOTTOM:
            XFillRectangle(XtDisplay(gw), XtWindow(gw), THIS.gc,
                sht, sht, size, gw->core.height - 2 * sht);
            break;
        case XmMAX_ON_LEFT:
        case XmMAX_ON_TOP:
            XFillRectangle(XtDisplay(gw), XtWindow(gw), THIS.gc,
                gw->core.width - size - sht, sht,
                size, gw->core.height - 2 * sht);
            break;
        }
        break;
        case XmVERTICAL:
            size = (gw->core.height - 2 * sht) /((float)THIS.maximum-(float)THIS.minimum)*(float)THIS.value;
            /*	size = (gw->core.height - 2 * sht)/ ratio; */
            switch(THIS.processingDirection) {
            case XmMAX_ON_RIGHT:
            case XmMAX_ON_BOTTOM:
                XFillRectangle(XtDisplay(gw), XtWindow(gw), THIS.gc,
                    sht, sht, gw->core.width - 2 * sht, size);
                break;
            case XmMAX_ON_LEFT:
            case XmMAX_ON_TOP:
                XFillRectangle(XtDisplay(gw), XtWindow(gw), THIS.gc,
                    sht, gw->core.height - size - sht,
                    gw->core.width - 2 * sht, size);
            }
            break;
    }
#undef THIS
}
#endif

static void
Initialize(Widget WXUNUSED(req), Widget new_w, ArgList WXUNUSED(args), Cardinal *WXUNUSED(num_args ))
{
    XmGaugeWidget gw = (XmGaugeWidget)new_w;
#define THIS gw->gauge
    XGCValues values;

    values.foreground = gw->primitive.foreground;
    THIS.gc = XtGetGC(new_w, GCForeground, &values);

#undef THIS

}


static void
Destroy(Widget w)
{
    XmGaugeWidget gw = (XmGaugeWidget)w;
#define THIS gw->gauge
    XtReleaseGC(w, THIS.gc);
#undef THIS
}


static Boolean
SetValues(
          Widget cw,
          Widget WXUNUSED(rw),
          Widget nw,
          ArgList WXUNUSED(args),
          Cardinal *WXUNUSED(num_args) )
{
    XmGaugeWidget cgw = (XmGaugeWidget)cw;
    XmGaugeWidget ngw = (XmGaugeWidget)nw;

    Boolean redraw = False;
    if(cgw->primitive.foreground != ngw->primitive.foreground) {
        XGCValues values;

        redraw = True;
        XtReleaseGC(nw, ngw->gauge.gc);
        values.foreground = ngw->primitive.foreground;
        ngw->gauge.gc = XtGetGC(nw, GCForeground, &values);
    }
    if(cgw->gauge.value != ngw->gauge.value) {
        redraw = True;
    }
    return redraw;
}


static void
ExposeProc(Widget w, XEvent *WXUNUSED(event), Region WXUNUSED(r))
{
    XmGaugeWidget gw = (XmGaugeWidget)w;
#define THIS gw->gauge
    int sht;

    sht = gw->primitive.shadow_thickness;
    _XmDrawShadows(XtDisplay(w), XtWindow(w),
        gw->primitive.top_shadow_GC,
        gw->primitive.bottom_shadow_GC,
        0, 0, w->core.width, w->core.height,
        sht, XmSHADOW_IN);
    DrawSlider(gw, False);
#undef THIS
}


static XtResource
resources[] = {
#define offset(field) XtOffset(XmGaugeWidget, gauge.field)
    {XmNvalue, XmCValue, XtRInt, sizeof(int),
        offset(value), XtRImmediate, (caddr_t)10},

    {XmNminimum, XmCValue, XtRInt, sizeof(int),
    offset(minimum), XtRImmediate, (caddr_t)0},

    {XmNmaximum, XmCValue, XtRInt, sizeof(int),
    offset(maximum), XtRImmediate, (caddr_t)100},

    {XmNorientation, XmCOrientation, XmROrientation, sizeof(unsigned char),
    offset(orientation), XtRImmediate, (caddr_t)XmVERTICAL},

    {XmNprocessingDirection, XmCProcessingDirection,
    XmRProcessingDirection, sizeof(unsigned char),
    offset(processingDirection), XtRImmediate, (caddr_t)XmMAX_ON_RIGHT},

    {XmNdragCallback, XmCCallback, XmRCallback, sizeof(XtCallbackList),
    offset(dragCallback), XtRImmediate, (caddr_t)NULL},

    {XmNvalueChangedCallback, XmCCallback, XmRCallback, sizeof(XtCallbackList),
    offset(valueChangedCallback), XtRImmediate, (caddr_t)NULL},


#undef offset
};


XmGaugeClassRec xmGaugeClassRec = {
    {				/* core fields */
        (WidgetClass) &xmPrimitiveClassRec, /* superclass		*/
            "XmGauge",		/* class_name		*/
            sizeof(XmGaugeRec),	/* widget_size		*/
            NULL,			/* class_initialize		*/
            NULL,			/* class_part_initialize	*/
            FALSE,			/* class_inited		*/
            Initialize,		/* initialize		*/
            NULL,			/* initialize_hook		*/
            XtInheritRealize,	/* realize			*/
            actions,		/* actions			*/
            XtNumber(actions),	/* num_actions		*/
            resources,		/* resources		*/
            XtNumber(resources),	/* num_resources		*/
            NULLQUARK,		/* xrm_class		*/
            TRUE,			/* compress_motion		*/
            TRUE,			/* compress_exposure	*/
            TRUE,			/* compress_enterleave	*/
            FALSE,			/* visible_interest		*/
            Destroy,		/* destroy			*/
            NULL,			/* resize			*/
            ExposeProc,		/* expose			*/
            SetValues,		/* set_values		*/
            NULL,			/* set_values_hook		*/
            XtInheritSetValuesAlmost, /* set_values_almost	*/
            NULL,			/* get_values_hook		*/
            NULL,			/* accept_focus		*/
            XtVersion,		/* version			*/
            NULL,			/* callback_private		*/
            translations,		/* tm_table			*/
            NULL,			/* query_geometry		*/
            NULL,			/* display_accelerator	*/
            NULL			/* extension		*/
    },
				/* primitive_class fields */
    {
            NULL,			/* border_highlight	*/
                NULL,			/* border_unhighlight	*/
                NULL,			/* translations		*/
                NULL,			/* arm_and_activate	*/
                NULL,			/* syn_resources	*/
                0,			/* num_syn_resources	*/
                NULL			/* extension		*/
        },
        { /* gauge fields */
                0			/* empty		*/
            }
};

WidgetClass xmGaugeWidgetClass = (WidgetClass)&xmGaugeClassRec;


void
GaugePick(Widget WXUNUSED(w), XEvent *WXUNUSED(e), String *WXUNUSED(args), Cardinal  *WXUNUSED(num_args))
{
    /* Commented out for a read-only gauge in wxWindows */
#if 0
    XmGaugeWidget gw = (XmGaugeWidget)w;
#define THIS gw->gauge
    int size, sht;
    float ratio;
    Boolean dragging = False;
    XButtonEvent *event = (XButtonEvent *)e;
    int x, y;

    x = event->x;
    y = event->y;
    sht = gw->primitive.shadow_thickness;
    _XmDrawShadows(XtDisplay(w), XtWindow(w),
        gw->primitive.top_shadow_GC,
        gw->primitive.bottom_shadow_GC,
        0, 0, w->core.width, w->core.height,
        sht, XmSHADOW_IN);


    ratio = (float)((float)THIS.maximum -
        (float)THIS.minimum) / (float)THIS.value;
    switch(THIS.orientation) {
    case XmHORIZONTAL:
        size = (w->core.width - 2 * sht) / ratio;
        switch(THIS.processingDirection) {
        case XmMAX_ON_RIGHT:
        case XmMAX_ON_BOTTOM:
            dragging = (x > sht) && (y > sht) &&
                (x < sht + size) && (y < w->core.height - sht);
            break;
        case XmMAX_ON_LEFT:
        case XmMAX_ON_TOP:
            dragging = (x > w->core.width - size - sht) && (y > sht) &&
                (x < w->core.width - sht) && (y < w->core.height + sht);
            break;
        }
        break;
        case XmVERTICAL:
            size = (w->core.height - 2 * sht) / ratio;
            switch(THIS.processingDirection) {
            case XmMAX_ON_RIGHT:
            case XmMAX_ON_BOTTOM:
                dragging = (x > sht) && (y > sht) &&
                    (x < w->core.width - sht) &&
                    (y < w->core.width - 2 * sht + size);
                break;
            case XmMAX_ON_LEFT:
            case XmMAX_ON_TOP:
                dragging = (x > sht) && (y > w->core.height - size - sht) &&
                    (x < w->core.width - sht) && (y < w->core.height - sht);
            }
            break;
    }
    THIS.dragging = dragging;
    THIS.oldx = x;
    THIS.oldy = y;
#undef THIS
#endif
}

#define round(x) ( (x) > 0 ? ((x) + 0.5) : -(-(x) + 0.5) )

void
GaugeDrag(Widget WXUNUSED(w), XEvent *WXUNUSED(e), String *WXUNUSED(args), Cardinal  *WXUNUSED(num_args))
{
    /* Commented out for a read-only gauge in wxWindows */
#if 0
    XmGaugeWidget gw = (XmGaugeWidget)w;
#define THIS gw->gauge
    int sht, x, y, max, value;
    float ratio, nratio, size, nsize, fvalue, delta;
    XMotionEvent *event = (XMotionEvent *)e;

    if( ! THIS.dragging) return;

    x = event->x;
    y = event->y;
    sht = gw->primitive.shadow_thickness;

    ratio = (float)THIS.value / (float)((float)THIS.maximum -
        (float)THIS.minimum);
    switch(THIS.orientation) {
    case XmHORIZONTAL:
        max = (w->core.width - 2 * sht);
        size = (float)max * ratio;
        delta =  (float)x - (float)THIS.oldx;
        break;
    case XmVERTICAL:
        max = (w->core.height - 2 * sht);
        size = (float) max * ratio;
        delta =  (float)y - (float)THIS.oldy;
        break;
    }
    switch(THIS.processingDirection) {
    case XmMAX_ON_RIGHT:
    case XmMAX_ON_BOTTOM:
        nsize = size + delta;
        break;
    default:
        nsize = size - delta;
    }
    if(nsize > (float)max) nsize = (float)max;
    if(nsize < (float)0 ) nsize = (float)0;
    nratio =  nsize / (float)max;

    fvalue = (int)((float)THIS.maximum -
        (float)THIS.minimum) * (float)nsize / (float)max;
    value = round(fvalue);

    THIS.value = value;
    THIS.oldx = x;
    THIS.oldy = y;

    /* clear old slider only if it was larger */
    DrawSlider(gw, (nsize < size));

    {
        XmGaugeCallbackStruct call;

        if(NULL  != THIS.dragCallback) {
            call.reason = XmCR_DRAG;
            call.event = e;
            call.value = THIS.value;
            XtCallCallbacks(w, XmNdragCallback, &call);
        }
    }
#undef THIS
#endif
}


void
GaugeDrop(Widget WXUNUSED(w), XEvent *WXUNUSED(e), String *WXUNUSED(args), Cardinal  *WXUNUSED(num_args))
{
    /* Commented out for a read-only gauge in wxWindows */
#if 0
    XmGaugeWidget gw = (XmGaugeWidget)w;
#define THIS gw->gauge
    if( ! THIS.dragging) return;

    if(NULL  != THIS.valueChangedCallback) {
        XmGaugeCallbackStruct call;
        call.reason = XmCR_VALUE_CHANGED;
        call.event = e;
        call.value = THIS.value;
        XtCallCallbacks(w, XmNvalueChangedCallback, &call);
    }
    THIS.dragging = False;
#undef THIS
#endif
}

void
XmGaugeSetValue(Widget w, int value)
{
    XmGaugeWidget gw = (XmGaugeWidget)w;

    gw->gauge.value = value;
    DrawSlider(gw, True);
    XFlush(XtDisplay(w));
}

int
XmGaugeGetValue(Widget w)
{
    XmGaugeWidget gw = (XmGaugeWidget)w;

    return gw->gauge.value;
}
Commit	Line	Data
	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	}