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

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