[wxWidgets.git] / 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
4bb6408c JS	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
89c7e962 JS	18	#include <Xm/Xm.h>
	19	#include <wx/motif/private.h>
	20
4bb6408c JS	21	#if !USE_SHARED_LIBRARY
	22	IMPLEMENT_DYNAMIC_CLASS(wxGauge, wxControl)
	23	#endif
	24
89c7e962 JS	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
4bb6408c JS	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;
0d57be45 JS	88	m_backgroundColour = parent->GetBackgroundColour();
0d57be45 JS	89	m_foregroundColour = parent->GetForegroundColour();
4bb6408c JS	90
	91	if (parent) parent->AddChild(this);
	92
	93	if ( id == -1 )
	94	m_windowId = (int)NewControlId();
	95	else
	96	m_windowId = id;
	97
89c7e962 JS	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);
4bb6408c	118
89c7e962 JS	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
4b5f3fe6 JS	126	m_windowFont = parent->GetFont();
	127	ChangeFont(FALSE);
	128
89c7e962 JS	129	SetCanAddEventHandler(TRUE);
	130	AttachWidget (parent, m_mainWidget, (WXWidget) NULL, x, y, width, height);
	131
0d57be45	132	ChangeBackgroundColour();
89c7e962 JS	133
89c7e962 JS	134	return TRUE;
4bb6408c JS	135	}
	136
	137	void wxGauge::SetSize(int x, int y, int width, int height, int sizeFlags)
	138	{
89c7e962	139	wxControl::SetSize(x, y, width, height, sizeFlags);
4bb6408c JS	140	}
	141
	142	void wxGauge::SetShadowWidth(int w)
	143	{
89c7e962 JS	144	if (w == 0)
	145	w = 1;
	146	XtVaSetValues((Widget) m_mainWidget, XmNshadowThickness, w, NULL);
4bb6408c JS	147	}
	148
	149	void wxGauge::SetBezelFace(int w)
	150	{
4bb6408c JS	151	}
	152
	153	void wxGauge::SetRange(int r)
	154	{
	155	m_rangeMax = r;
89c7e962	156	XtVaSetValues((Widget) m_mainWidget, XmNmaximum, r, NULL);
4bb6408c JS	157	}
	158
	159	void wxGauge::SetValue(int pos)
	160	{
	161	m_gaugePos = pos;
89c7e962	162	XtVaSetValues((Widget) m_mainWidget, XmNvalue, pos, NULL);
4bb6408c JS	163	}
	164
	165	int wxGauge::GetShadowWidth() const
	166	{
89c7e962 JS	167	Dimension w;
	168	XtVaGetValues((Widget) m_mainWidget, XmNshadowThickness, &w, NULL);
	169	return (int)w;
4bb6408c JS	170	}
	171
	172	int wxGauge::GetBezelFace() const
	173	{
4bb6408c JS	174	return 0;
	175	}
	176
	177	int wxGauge::GetRange() const
	178	{
89c7e962 JS	179	int r;
	180	XtVaGetValues((Widget) m_mainWidget, XmNmaximum, &r, NULL);
	181	return (int)r;
	182	// return m_rangeMax;
4bb6408c JS	183	}
	184
	185	int wxGauge::GetValue() const
	186	{
89c7e962 JS	187	int pos;
	188	XtVaGetValues((Widget) m_mainWidget, XmNvalue, &pos, NULL);
	189	return pos;
	190	// return m_gaugePos;
	191	}
	192
4b5f3fe6	193	void wxGauge::ChangeFont(bool keepOriginalSize)
0d57be45	194	{
4b5f3fe6	195	wxWindow::ChangeFont(keepOriginalSize);
0d57be45 JS	196	}
	197
	198	void wxGauge::ChangeBackgroundColour()
	199	{
321db4b6	200	wxWindow::ChangeBackgroundColour();
0d57be45 JS	201	}
	202
	203	void wxGauge::ChangeForegroundColour()
	204	{
321db4b6	205	wxWindow::ChangeForegroundColour();
0d57be45 JS	206	}
0d57be45 JS	207
89c7e962 JS	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
4bb6408c JS	668	}
4bb6408c JS	669
89c7e962 JS	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	}