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"

#include <Xm/Xm.h>
#include <wx/motif/private.h>

#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxGauge, wxControl)
#endif

// 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_windowFont = parent->GetFont();
    ChangeFont(FALSE);

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

    ChangeBackgroundColour();

    return TRUE;
}

void wxGauge::SetSize(int x, int y, int width, int height, int sizeFlags)
{
    wxControl::SetSize(x, y, width, height, sizeFlags);
}

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

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