Tk Source Code

    Ttk_RegisterElement(interp,
	theme, "Menubutton.indicator", &MenuIndicatorElementSpec, NULL);

    Ttk_RegisterElement(interp, theme, "tab", &TabElementSpec, NULL);
    Ttk_RegisterElement(interp, theme, "client", &ClientElementSpec, NULL);

    Ttk_RegisterElement(interp, theme, "slider", &SliderElementSpec, NULL);
    Ttk_RegisterElement(interp, theme, "minslider", &SliderElementSpec, NULL);
    Ttk_RegisterElement(interp, theme, "maxslider", &SliderElementSpec, NULL);
    Ttk_RegisterElement(interp, theme, "bar", &PbarElementSpec, NULL);
    Ttk_RegisterElement(interp, theme, "pbar", &PbarElementSpec, NULL);

    Ttk_RegisterElement(interp, theme, "hgrip",
	    &GripElementSpec,  &GripClientData[0]);
    Ttk_RegisterElement(interp, theme, "vgrip",
	    &GripElementSpec,  &GripClientData[1]);

	    &MenubuttonArrowElementSpec, NULL);

    Ttk_RegisterElement(interp, theme, "field", &FieldElementSpec, NULL);

    Ttk_RegisterElement(interp, theme, "trough", &TroughElementSpec, NULL);
    Ttk_RegisterElement(interp, theme, "thumb", &ThumbElementSpec, NULL);
    Ttk_RegisterElement(interp, theme, "slider", &SliderElementSpec, NULL);
    Ttk_RegisterElement(interp, theme, "minslider", &SliderElementSpec, NULL);
    Ttk_RegisterElement(interp, theme, "maxslider", &SliderElementSpec, NULL);

    Ttk_RegisterElement(interp, theme, "uparrow",
	    &ArrowElementSpec, &ArrowElements[0]);
    Ttk_RegisterElement(interp, theme, "downarrow",
	    &ArrowElementSpec, &ArrowElements[1]);
    Ttk_RegisterElement(interp, theme, "leftarrow",
	    &ArrowElementSpec, &ArrowElements[2]);

	    &ArrowElementSpec, &ArrowElements[3]);
    Ttk_RegisterElement(interp, theme, "arrow",
	    &ArrowElementSpec, &ArrowElements[0]);

    Ttk_RegisterElement(interp, theme, "trough", &TroughElementSpec, NULL);
    Ttk_RegisterElement(interp, theme, "thumb", &ThumbElementSpec, NULL);
    Ttk_RegisterElement(interp, theme, "slider", &SliderElementSpec, NULL);
    Ttk_RegisterElement(interp, theme, "minslider", &SliderElementSpec, NULL);
    Ttk_RegisterElement(interp, theme, "maxslider", &SliderElementSpec, NULL);
    Ttk_RegisterElement(interp, theme, "pbar", &PbarElementSpec, NULL);

    Ttk_RegisterElement(interp, theme, "separator",
	    &SeparatorElementSpec, NULL);
    Ttk_RegisterElement(interp, theme, "hseparator",
	    &HorizontalSeparatorElementSpec, NULL);
    Ttk_RegisterElement(interp, theme, "vseparator",

extern void TtkButton_Init(Tcl_Interp *);
extern void TtkEntry_Init(Tcl_Interp *);
extern void TtkFrame_Init(Tcl_Interp *);
extern void TtkNotebook_Init(Tcl_Interp *);
extern void TtkPanedwindow_Init(Tcl_Interp *);
extern void TtkProgressbar_Init(Tcl_Interp *);
extern void TtkRange_Init(Tcl_Interp *);
extern void TtkScale_Init(Tcl_Interp *);
extern void TtkScrollbar_Init(Tcl_Interp *);
extern void TtkSeparator_Init(Tcl_Interp *);
extern void TtkTreeview_Init(Tcl_Interp *);

#ifdef TTK_SQUARE_WIDGET
extern int TtkSquareWidget_Init(Tcl_Interp *);
#endif

static void RegisterWidgets(Tcl_Interp *interp)
{
    TtkButton_Init(interp);
    TtkEntry_Init(interp);
    TtkFrame_Init(interp);
    TtkNotebook_Init(interp);
    TtkPanedwindow_Init(interp);
    TtkProgressbar_Init(interp);
    TtkRange_Init(interp);
    TtkScale_Init(interp);
    TtkScrollbar_Init(interp);
    TtkSeparator_Init(interp);
    TtkTreeview_Init(interp);
#ifdef TTK_SQUARE_WIDGET
    TtkSquareWidget_Init(interp);
#endif

/*
 * Copyright (C) 2011 Goodwin Lawlor [email protected]
 *
 * ttk::range widget.
 */

#include <tk.h>
#include <string.h>
#include <stdio.h>
#include "ttkTheme.h"
#include "ttkWidget.h"

#define DEF_RANGE_LENGTH "100"

#define MAX(a,b) ((a) > (b) ? (a) : (b))
#define MIN(a,b) ((a) < (b) ? (a) : (b))

/*
 * Range widget record
 */
typedef struct
{
    /* slider element options */
    Tcl_Obj *fromObj;         /* from value - lower bound*/
    Tcl_Obj *toObj;           /* to value - upper bound*/
    Tcl_Obj *minvalueObj;          /* min value */
    Tcl_Obj *maxvalueObj;          /* max value */
    Tcl_Obj *lengthObj;       /* length of the long axis of the range */
    Tcl_Obj *orientObj;       /* widget orientation */
    int orient;

    /* widget options */
    Tcl_Obj *commandObj;
    Tcl_Obj *minvariableObj;
    Tcl_Obj *maxvariableObj;

    /* internal state */
    Ttk_TraceHandle *minvariableTrace;
    Ttk_TraceHandle *maxvariableTrace;

} RangePart;

typedef struct
{
    WidgetCore core;
    RangePart  range;
} Range;

static Tk_OptionSpec RangeOptionSpecs[] =
{
    WIDGET_TAKES_FOCUS,

    {TK_OPTION_STRING, "-command", "command", "Command", "",
	Tk_Offset(Range,range.commandObj), -1,
	TK_OPTION_NULL_OK,0,0},
    {TK_OPTION_STRING, "-minvariable", "minvariable", "Minvariable", "",
	Tk_Offset(Range,range.minvariableObj), -1,
	0,0,0},
    {TK_OPTION_STRING, "-maxvariable", "maxvariable", "Maxvariable", "",
	Tk_Offset(Range,range.maxvariableObj), -1,
	0,0,0},
    {TK_OPTION_STRING_TABLE, "-orient", "orient", "Orient", "horizontal",
	Tk_Offset(Range,range.orientObj),
	Tk_Offset(Range,range.orient), 0,
	(ClientData)ttkOrientStrings, STYLE_CHANGED },

    {TK_OPTION_DOUBLE, "-from", "from", "From", "0",
	Tk_Offset(Range,range.fromObj), -1, 0, 0, 0},
    {TK_OPTION_DOUBLE, "-to", "to", "To", "1.0",
	Tk_Offset(Range,range.toObj), -1, 0, 0, 0},
    {TK_OPTION_DOUBLE, "-minvalue", "minvalue", "Minvalue", "0",
	Tk_Offset(Range,range.minvalueObj), -1, 0, 0, 0},
    {TK_OPTION_DOUBLE, "-maxvalue", "maxvalue", "Maxvalue", "1.0",
	Tk_Offset(Range,range.maxvalueObj), -1, 0, 0, 0},
    {TK_OPTION_PIXELS, "-length", "length", "Length",
	DEF_RANGE_LENGTH, Tk_Offset(Range,range.lengthObj), -1, 0, 0,
    	GEOMETRY_CHANGED},

    WIDGET_INHERIT_OPTIONS(ttkCoreOptionSpecs)
};

static XPoint ValueToPoint(Range *rangePtr, double value);
static double PointToValue(Range *rangePtr, int x, int y);

/* RangeMinVariableChanged --
 * 	Variable trace procedure for range -variable;
 * 	Updates the range's value.
 * 	If the linked variable is not a valid double,
 * 	sets the 'invalid' state.
 */
static void RangeMinVariableChanged(void *recordPtr, const char *minvalue)
{
    Range *range = recordPtr;
    double v;

    if (minvalue == NULL || Tcl_GetDouble(0, minvalue, &v) != TCL_OK) {
	TtkWidgetChangeState(&range->core, TTK_STATE_INVALID, 0);
    } else {
	Tcl_Obj *minvalueObj = Tcl_NewDoubleObj(v);
	Tcl_IncrRefCount(minvalueObj);
	Tcl_DecrRefCount(range->range.minvalueObj);
	range->range.minvalueObj = minvalueObj;
	TtkWidgetChangeState(&range->core, 0, TTK_STATE_INVALID);
    }
    TtkRedisplayWidget(&range->core);
}

/* RangeMaxVariableChanged --
 * 	Variable trace procedure for range -variable;
 * 	Updates the range's value.
 * 	If the linked variable is not a valid double,
 * 	sets the 'invalid' state.
 */
static void RangeMaxVariableChanged(void *recordPtr, const char *maxvalue)
{
    Range *range = recordPtr;
    double v;

    if (maxvalue == NULL || Tcl_GetDouble(0, maxvalue, &v) != TCL_OK) {
	TtkWidgetChangeState(&range->core, TTK_STATE_INVALID, 0);
    } else {
	Tcl_Obj *maxvalueObj = Tcl_NewDoubleObj(v);
	Tcl_IncrRefCount(maxvalueObj);
	Tcl_DecrRefCount(range->range.maxvalueObj);
	range->range.maxvalueObj = maxvalueObj;
	TtkWidgetChangeState(&range->core, 0, TTK_STATE_INVALID);
    }
    TtkRedisplayWidget(&range->core);
}

/* RangeInitialize --
 * 	Range widget initialization hook.
 */
static void RangeInitialize(Tcl_Interp *interp, void *recordPtr)
{
    Range *rangePtr = recordPtr;
    TtkTrackElementState(&rangePtr->core);

}

static void RangeCleanup(void *recordPtr)
{
    Range *range = recordPtr;

    if (range->range.minvariableTrace) {
	Ttk_UntraceVariable(range->range.minvariableTrace);
	range->range.minvariableTrace = 0;
    }

    if (range->range.maxvariableTrace) {
	Ttk_UntraceVariable(range->range.maxvariableTrace);
	range->range.maxvariableTrace = 0;
    }
}

/* RangeConfigure --
 * 	Configuration hook.
 */
static int RangeConfigure(Tcl_Interp *interp, void *recordPtr, int mask)
{
    Range *range = recordPtr;
    Tcl_Obj *minvarName = range->range.minvariableObj;
    Tcl_Obj *maxvarName = range->range.maxvariableObj;
    Ttk_TraceHandle *minvt = 0;
    Ttk_TraceHandle *maxvt = 0;

    if (minvarName != NULL && *Tcl_GetString(minvarName) != '\0') {
	minvt = Ttk_TraceVariable(interp,minvarName, RangeMinVariableChanged,recordPtr);
	if (!minvt) return TCL_ERROR;
    }

    if (maxvarName != NULL && *Tcl_GetString(maxvarName) != '\0') {
	maxvt = Ttk_TraceVariable(interp,maxvarName, RangeMaxVariableChanged,recordPtr);
	if (!maxvt) return TCL_ERROR;
    }

    if (TtkCoreConfigure(interp, recordPtr, mask) != TCL_OK) {
	if (minvt) Ttk_UntraceVariable(minvt);
	if (maxvt) Ttk_UntraceVariable(maxvt);
	return TCL_ERROR;
    }

    if (range->range.minvariableTrace) {
	Ttk_UntraceVariable(range->range.minvariableTrace);
    }
    range->range.minvariableTrace = minvt;

    if (range->range.maxvariableTrace) {
	Ttk_UntraceVariable(range->range.maxvariableTrace);
    }
    range->range.maxvariableTrace = maxvt;

    return TCL_OK;
}

/* RangePostConfigure --
 * 	Post-configuration hook.
 */
static int RangePostConfigure(
    Tcl_Interp *interp, void *recordPtr, int mask)
{
    Range *range = recordPtr;
    int minstatus = TCL_OK;
    int maxstatus = TCL_OK;

    if (range->range.minvariableTrace) {
	minstatus = Ttk_FireTrace(range->range.minvariableTrace);
	if (WidgetDestroyed(&range->core)) {
	    return TCL_ERROR;
	}
	if (minstatus != TCL_OK) {
	    /* Unset -variable: */
	    Ttk_UntraceVariable(range->range.minvariableTrace);
	    Tcl_DecrRefCount(range->range.minvariableObj);
	    range->range.minvariableTrace = 0;
	    range->range.minvariableObj = NULL;
	    minstatus = TCL_ERROR;
	}
    }

    if (range->range.maxvariableTrace) {
	maxstatus = Ttk_FireTrace(range->range.maxvariableTrace);
	if (WidgetDestroyed(&range->core)) {
	    return TCL_ERROR;
	}
	if (maxstatus != TCL_OK) {
	    /* Unset -variable: */
	    Ttk_UntraceVariable(range->range.maxvariableTrace);
	    Tcl_DecrRefCount(range->range.maxvariableObj);
	    range->range.maxvariableTrace = 0;
	    range->range.maxvariableObj = NULL;
	    maxstatus = TCL_ERROR;
	}
    }
    if (minstatus != TCL_OK || maxstatus != TCL_OK) {
	return TCL_ERROR;
    } else {
	return TCL_OK;
    }

}

/* RangeGetLayout --
 *	getLayout hook.
 */
static Ttk_Layout
RangeGetLayout(Tcl_Interp *interp, Ttk_Theme theme, void *recordPtr)
{
    Range *rangePtr = recordPtr;
    return TtkWidgetGetOrientedLayout(
	interp, theme, recordPtr, rangePtr->range.orientObj);
}

/*
 * TroughBox --
 * 	Returns the inner area of the trough element.
 */
static Ttk_Box TroughBox(Range *rangePtr)
{
    return Ttk_ClientRegion(rangePtr->core.layout, "trough");
}

/*
 * TroughRange --
 * 	Return the value area of the trough element, adjusted
 * 	for slider size.
 */
static Ttk_Box TroughRange(Range *rangePtr)
{
    Ttk_Box troughBox = TroughBox(rangePtr);
    Ttk_Element slider = Ttk_FindElement(rangePtr->core.layout,"minslider");

    /*
     * If this is a range widget, adjust range for slider:
     */
    if (slider) {
	Ttk_Box sliderBox = Ttk_ElementParcel(slider);
	if (rangePtr->range.orient == TTK_ORIENT_HORIZONTAL) {
	    troughBox.x += sliderBox.width / 2;
	    troughBox.width -= sliderBox.width;
	} else {
	    troughBox.y += sliderBox.height / 2;
	    troughBox.height -= sliderBox.height;
	}
    }

    return troughBox;
}

/*
 * RangeFraction --
 */
static double RangeFraction(Range *rangePtr, double value)
{
    double from = 0, to = 1, fraction;

    Tcl_GetDoubleFromObj(NULL, rangePtr->range.fromObj, &from);
    Tcl_GetDoubleFromObj(NULL, rangePtr->range.toObj, &to);

    if (from == to) {
	return 1.0;
    }

    fraction = (value - from) / (to - from);

    return fraction < 0 ? 0 : fraction > 1 ? 1 : fraction;
}

/* $range get ?x y? --
 * 	Returns the current value of the range widget, or if $x and
 * 	$y are specified, the value represented by point @x,y.
 */
static int
RangeGetCommand(
    void *recordPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
{
    Range *rangePtr = recordPtr;
    int x, y, r = TCL_OK;
    double value = 0;

    if (objc != 4) {
	Tcl_WrongNumArgs(interp, 1, objv, "get ?x y?");
	return TCL_ERROR;
    }

    r = Tcl_GetIntFromObj(interp, objv[2], &x);
    if (r == TCL_OK)
	r = Tcl_GetIntFromObj(interp, objv[3], &y);
    if (r == TCL_OK) {
	value = PointToValue(rangePtr, x, y);
	Tcl_SetObjResult(interp, Tcl_NewDoubleObj(value));
    }

    return r;
}

static int
RangeGetMinCommand(
    void *recordPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
{
    Range *rangePtr = recordPtr;

    if (objc != 2) {
	Tcl_WrongNumArgs(interp, 1, objv, "getmin");
	return TCL_ERROR;
    }

    Tcl_SetObjResult(interp, rangePtr->range.minvalueObj);

    return TCL_OK;
}

static int
RangeGetMaxCommand(
    void *recordPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
{
    Range *rangePtr = recordPtr;

    if (objc != 2) {
	Tcl_WrongNumArgs(interp, 1, objv, "getmax");
	return TCL_ERROR;
    }

    Tcl_SetObjResult(interp, rangePtr->range.maxvalueObj);

    return TCL_OK;
}

/* $range setmin $newValue
 */
static int
RangeSetMinCommand(
    void *recordPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
{
    Range *rangePtr = recordPtr;
    double from = 0.0, to = 1.0, minvalue, maxvalue;
    int result = TCL_OK;

    if (objc != 3) {
	Tcl_WrongNumArgs(interp, 1, objv, "setmin value");
	return TCL_ERROR;
    }

    if (Tcl_GetDoubleFromObj(interp, objv[2], &minvalue) != TCL_OK) {
	return TCL_ERROR;
    }

    if (rangePtr->core.state & TTK_STATE_DISABLED) {
	return TCL_OK;
    }

    /* ASSERT: fromObj and toObj are valid doubles.
     */
    Tcl_GetDoubleFromObj(interp, rangePtr->range.fromObj, &from);
    Tcl_GetDoubleFromObj(interp, rangePtr->range.toObj, &to);

    /* Limit new value to between 'from' and 'to':
     */
    if (from < to) {
	minvalue = minvalue < from ? from : minvalue > to ? to : minvalue;
    } else {
	minvalue = minvalue < to ? to : minvalue > from ? from : minvalue;
    }

    // Must be <= maxvalue too.
    Tcl_GetDoubleFromObj(NULL, rangePtr->range.maxvalueObj, &maxvalue);
    minvalue = minvalue < maxvalue ? minvalue : maxvalue;

    /*
     * Set value:
     */
    Tcl_DecrRefCount(rangePtr->range.minvalueObj);
    rangePtr->range.minvalueObj = Tcl_NewDoubleObj(minvalue);
    Tcl_IncrRefCount(rangePtr->range.minvalueObj);
    TtkRedisplayWidget(&rangePtr->core);

    /*
     * Set attached variable, if any:
     */
    if (rangePtr->range.minvariableObj != NULL) {
	Tcl_ObjSetVar2(interp, rangePtr->range.minvariableObj, NULL,
	    rangePtr->range.minvalueObj, TCL_GLOBAL_ONLY);
    }
    if (WidgetDestroyed(&rangePtr->core)) {
	return TCL_ERROR;
    }

    /*
     * Invoke -command, if any:
     */
    if (rangePtr->range.commandObj != NULL) {
	Tcl_Obj *cmdObj = Tcl_DuplicateObj(rangePtr->range.commandObj);
	Tcl_IncrRefCount(cmdObj);
	Tcl_AppendToObj(cmdObj, " ", 1);
	Tcl_AppendObjToObj(cmdObj, rangePtr->range.minvalueObj);
	Tcl_AppendToObj(cmdObj, " ", 1);
	Tcl_AppendObjToObj(cmdObj, rangePtr->range.maxvalueObj);
	result = Tcl_EvalObjEx(interp, cmdObj, TCL_EVAL_GLOBAL);
	Tcl_DecrRefCount(cmdObj);
    }

    return result;
}

/* $range setmax $newValue
 */
static int
RangeSetMaxCommand(
    void *recordPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
{
    Range *rangePtr = recordPtr;
    double from = 0.0, to = 1.0, minvalue, maxvalue;
    int result = TCL_OK;

    if (objc != 3) {
	Tcl_WrongNumArgs(interp, 1, objv, "setmax value");
	return TCL_ERROR;
    }

    if (Tcl_GetDoubleFromObj(interp, objv[2], &maxvalue) != TCL_OK) {
	return TCL_ERROR;
    }

    if (rangePtr->core.state & TTK_STATE_DISABLED) {
	return TCL_OK;
    }

    /* ASSERT: fromObj and toObj are valid doubles.
     */
    Tcl_GetDoubleFromObj(interp, rangePtr->range.fromObj, &from);
    Tcl_GetDoubleFromObj(interp, rangePtr->range.toObj, &to);

    /* Limit new value to between 'from' and 'to':
     */
    if (from < to) {
	maxvalue = maxvalue < from ? from : maxvalue > to ? to : maxvalue;
    } else {
	maxvalue = maxvalue < to ? to : maxvalue > from ? from : maxvalue;
    }

    // Must be >= minvalue too.
    Tcl_GetDoubleFromObj(NULL, rangePtr->range.minvalueObj, &minvalue);
    maxvalue = maxvalue > minvalue ? maxvalue : minvalue;

    /*
     * Set value:
     */
    Tcl_DecrRefCount(rangePtr->range.maxvalueObj);
    rangePtr->range.maxvalueObj = Tcl_NewDoubleObj(maxvalue);
    Tcl_IncrRefCount(rangePtr->range.maxvalueObj);
    TtkRedisplayWidget(&rangePtr->core);

    /*
     * Set attached variable, if any:
     */
    if (rangePtr->range.maxvariableObj != NULL) {
	Tcl_ObjSetVar2(interp, rangePtr->range.maxvariableObj, NULL,
	    rangePtr->range.maxvalueObj, TCL_GLOBAL_ONLY);
    }
    if (WidgetDestroyed(&rangePtr->core)) {
	return TCL_ERROR;
    }

    /*
     * Invoke -command, if any:
     */
    if (rangePtr->range.commandObj != NULL) {
	Tcl_Obj *cmdObj = Tcl_DuplicateObj(rangePtr->range.commandObj);
	Tcl_IncrRefCount(cmdObj);
	Tcl_AppendToObj(cmdObj, " ", 1);
	Tcl_AppendObjToObj(cmdObj, rangePtr->range.minvalueObj);
	Tcl_AppendToObj(cmdObj, " ", 1);
	Tcl_AppendObjToObj(cmdObj, rangePtr->range.maxvalueObj);
	result = Tcl_EvalObjEx(interp, cmdObj, TCL_EVAL_GLOBAL);
	Tcl_DecrRefCount(cmdObj);
    }

    return result;
}

static int
RangeCoordsCommand(
    void *recordPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
{
    Range *rangePtr = recordPtr;
    double value;
    int r = TCL_OK;

    if (objc != 3) {
	Tcl_WrongNumArgs(interp, 1, objv, "coords ?value?");
	return TCL_ERROR;
    }

    r = Tcl_GetDoubleFromObj(interp, objv[2], &value);

    if (r == TCL_OK) {
	Tcl_Obj *point[2];
	XPoint pt = ValueToPoint(rangePtr, value);
	point[0] = Tcl_NewIntObj(pt.x);
	point[1] = Tcl_NewIntObj(pt.y);
	Tcl_SetObjResult(interp, Tcl_NewListObj(2, point));
    }
    return r;
}

static int
RangeMinCoordsCommand(
    void *recordPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
{
    Range *rangePtr = recordPtr;
    double value;
    int r = TCL_OK;

    if (objc != 2) {
	Tcl_WrongNumArgs(interp, 1, objv, "mincoords");
	return TCL_ERROR;
    }

    r = Tcl_GetDoubleFromObj(interp, rangePtr->range.minvalueObj, &value);

    if (r == TCL_OK) {
	Tcl_Obj *point[2];
	XPoint pt = ValueToPoint(rangePtr, value);
	point[0] = Tcl_NewIntObj(pt.x);
	point[1] = Tcl_NewIntObj(pt.y);
	Tcl_SetObjResult(interp, Tcl_NewListObj(2, point));
    }
    return r;
}

static int
RangeMaxCoordsCommand(
    void *recordPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
{
    Range *rangePtr = recordPtr;
    double value;
    int r = TCL_OK;

    if (objc != 2) {
	Tcl_WrongNumArgs(interp, 1, objv, "maxcoords");
	return TCL_ERROR;
    }

    r = Tcl_GetDoubleFromObj(interp, rangePtr->range.maxvalueObj, &value);

    if (r == TCL_OK) {
	Tcl_Obj *point[2];
	XPoint pt = ValueToPoint(rangePtr, value);
	point[0] = Tcl_NewIntObj(pt.x);
	point[1] = Tcl_NewIntObj(pt.y);
	Tcl_SetObjResult(interp, Tcl_NewListObj(2, point));
    }
    return r;
}

static void RangeDoLayout(void *clientData)
{
    WidgetCore *corePtr = clientData;
    Ttk_Element minslider = Ttk_FindElement(corePtr->layout, "minslider");
    Ttk_Element maxslider = Ttk_FindElement(corePtr->layout, "maxslider");

    Ttk_PlaceLayout(corePtr->layout,corePtr->state,Ttk_WinBox(corePtr->tkwin));

    /* Adjust the slider position:
     */
    if (minslider && maxslider) {
	Range *rangePtr = clientData;
	Ttk_Box troughBox = TroughBox(rangePtr);
	Ttk_Box minsliderBox = Ttk_ElementParcel(minslider);
	Ttk_Box maxsliderBox = Ttk_ElementParcel(maxslider);
	double minvalue = 0.0, maxvalue = 1.0;
	double minfraction, maxfraction;
	int range, offset;

	Tcl_GetDoubleFromObj(NULL, rangePtr->range.minvalueObj, &minvalue);
	Tcl_GetDoubleFromObj(NULL, rangePtr->range.maxvalueObj, &maxvalue);
	minfraction = RangeFraction(rangePtr, minvalue);
	maxfraction = RangeFraction(rangePtr, maxvalue);

	if (rangePtr->range.orient == TTK_ORIENT_HORIZONTAL) {
	    range = troughBox.width - minsliderBox.width;
	    offset = minsliderBox.x;
	    minsliderBox.x = offset + (int)(minfraction * range);
	    maxsliderBox.x = offset + (int)(maxfraction * range);
	} else {
	    range = troughBox.height - minsliderBox.height;
	    offset = minsliderBox.y;
	    minsliderBox.y = offset + (int)(minfraction * range);
	    maxsliderBox.y = offset + (int)(maxfraction * range);
	}

	Ttk_PlaceElement(corePtr->layout, minslider, minsliderBox);
	Ttk_PlaceElement(corePtr->layout, maxslider, maxsliderBox);

    }
}

/*
 * RangeSize --
 * 	Compute requested size of range.
 */
static int RangeSize(void *clientData, int *widthPtr, int *heightPtr)
{
    WidgetCore *corePtr = clientData;
    Range *rangePtr = clientData;
    int length;

    Ttk_LayoutSize(corePtr->layout, corePtr->state, widthPtr, heightPtr);

    /* Assert the -length configuration option */
    Tk_GetPixelsFromObj(NULL, corePtr->tkwin,
	    rangePtr->range.lengthObj, &length);
    if (rangePtr->range.orient == TTK_ORIENT_VERTICAL) {
	*heightPtr = MAX(*heightPtr, length);
    } else {
	*widthPtr = MAX(*widthPtr, length);
    }

    return 1;
}

static double
PointToValue(Range *rangePtr, int x, int y)
{
    Ttk_Box troughBox = TroughRange(rangePtr);
    double from = 0, to = 1, fraction;

    Tcl_GetDoubleFromObj(NULL, rangePtr->range.fromObj, &from);
    Tcl_GetDoubleFromObj(NULL, rangePtr->range.toObj, &to);

    if (rangePtr->range.orient == TTK_ORIENT_HORIZONTAL) {
	fraction = (double)(x - troughBox.x) / (double)troughBox.width;
    } else {
	fraction = (double)(y - troughBox.y) / (double)troughBox.height;
    }

    fraction = fraction < 0 ? 0 : fraction > 1 ? 1 : fraction;

    return from + fraction * (to-from);
}

/*
 * Return the center point in the widget corresponding to the given
 * value. This point can be used to center the slider.
 */

static XPoint
ValueToPoint(Range *rangePtr, double value)
{
    Ttk_Box troughBox = TroughRange(rangePtr);
    double fraction = RangeFraction(rangePtr, value);
    XPoint pt = {0, 0};

    if (rangePtr->range.orient == TTK_ORIENT_HORIZONTAL) {
	pt.x = troughBox.x + (int)(fraction * troughBox.width);
	pt.y = troughBox.y + troughBox.height / 2;
    } else {
	pt.x = troughBox.x + troughBox.width / 2;
	pt.y = troughBox.y + (int)(fraction * troughBox.height);
    }
    return pt;
}

static const Ttk_Ensemble RangeCommands[] = {
    { "configure",   TtkWidgetConfigureCommand,0 },
    { "cget",        TtkWidgetCgetCommand,0 },
    { "state",       TtkWidgetStateCommand,0 },
    { "instate",     TtkWidgetInstateCommand,0 },
    { "identify",    TtkWidgetIdentifyCommand,0 },
    { "setmin",      RangeSetMinCommand,0 },
    { "setmax",      RangeSetMaxCommand,0 },
    { "get",         RangeGetCommand,0 },
    { "getmin",      RangeGetMinCommand,0 },
    { "getmax",      RangeGetMaxCommand,0 },
    { "coords",      RangeCoordsCommand,0 },
    { "mincoords",   RangeMinCoordsCommand,0 },
    { "maxcoords",   RangeMaxCoordsCommand,0 },
    { 0,0,0 }
};

static WidgetSpec RangeWidgetSpec =
{
    "TRange",			/* Class name */
    sizeof(Range),		/* record size */
    RangeOptionSpecs,		/* option specs */
    RangeCommands,		/* widget commands */
    RangeInitialize,		/* initialization proc */
    RangeCleanup,		/* cleanup proc */
    RangeConfigure,		/* configure proc */
    RangePostConfigure,		/* postConfigure */
    RangeGetLayout, 		/* getLayoutProc */
    RangeSize,			/* sizeProc */
    RangeDoLayout,		/* layoutProc */
    TtkWidgetDisplay		/* displayProc */
};

TTK_BEGIN_LAYOUT(VerticalRangeLayout)
    TTK_GROUP("Vertical.Range.trough", TTK_FILL_BOTH,
	TTK_NODE("Vertical.Range.minslider", TTK_PACK_TOP)
	TTK_NODE("Vertical.Range.maxslider", TTK_PACK_BOTTOM) )
TTK_END_LAYOUT

TTK_BEGIN_LAYOUT(HorizontalRangeLayout)
    TTK_GROUP("Horizontal.Range.trough", TTK_FILL_BOTH,
	TTK_NODE("Horizontal.Range.minslider", TTK_PACK_LEFT)
	TTK_NODE("Horizontal.Range.maxslider", TTK_PACK_RIGHT) )
TTK_END_LAYOUT

/*
 * Initialization.
 */
MODULE_SCOPE
void TtkRange_Init(Tcl_Interp *interp)
{
    Ttk_Theme theme = Ttk_GetDefaultTheme(interp);

    Ttk_RegisterLayout(theme, "Vertical.TRange", VerticalRangeLayout);
    Ttk_RegisterLayout(theme, "Horizontal.TRange", HorizontalRangeLayout);

    RegisterWidget(interp, "ttk::range", &RangeWidgetSpec);
}

	ttk::style configure Heading -font TkHeadingFont -relief raised
	ttk::style configure Treeview -background $colors(-window)
	ttk::style map Treeview \
	    -background [list selected $colors(-selectbg)] \
	    -foreground [list selected $colors(-selectfg)] ;

	ttk::style configure TScale \
	    -groovewidth 4 -troughrelief sunken \
	    -sliderwidth raised -borderwidth 2
	ttk::style configure TRange \
	    -groovewidth 4 -troughrelief sunken \
	    -sliderwidth raised -borderwidth 2
	ttk::style configure TProgressbar \
	    -background $colors(-selectbg) -borderwidth 0
    }
}

	ttk::style configure TLabelframe -borderwidth 2 -relief groove

	ttk::style configure TScrollbar -relief raised
	ttk::style map TScrollbar -relief {{pressed !disabled} sunken}

	ttk::style configure TScale -sliderrelief raised
	ttk::style map TScale -sliderrelief {{pressed !disabled} sunken}
	
	ttk::style configure TRange -sliderrelief raised
	ttk::style map TRange -sliderrelief {{pressed !disabled} sunken}

	ttk::style configure TProgressbar -background SteelBlue
	ttk::style configure TNotebook.Tab \
	    -padding {3m 1m} \
	    -background $colors(-troughbg)
	ttk::style map TNotebook.Tab -background [list selected $colors(-frame)]

	ttk::style configure TScrollbar \
	    -width 12 -arrowsize 12
	ttk::style map TScrollbar \
	    -arrowcolor [list disabled $colors(-disabledfg)]

	ttk::style configure TScale \
	    -sliderrelief raised
	ttk::style configure TRange \
	    -sliderrelief raised
	ttk::style configure TProgressbar \
	    -background $colors(-selectbg)

	ttk::style configure TNotebook.Tab \
	    -padding {4 2} -background $colors(-darker)
	ttk::style map TNotebook.Tab \

# range.tcl - Copyright (C) 2011 Goodwin Lawlor
#
# Bindings for the TRange widget

namespace eval ttk::range {
    variable State
    array set State  {
	dragging 0
    }
}

bind TRange <ButtonPress-1>   { ttk::range::Press %W %x %y }
bind TRange <B1-Motion>       { ttk::range::Drag %W %x %y }
bind TRange <ButtonRelease-1> { ttk::range::Release %W %x %y }

bind TRange <ButtonPress-2>   { ttk::range::Jump %W %x %y }
bind TRange <B2-Motion>       { ttk::range::Drag %W %x %y }
bind TRange <ButtonRelease-2> { ttk::range::Release %W %x %y }

bind TRange <ButtonPress-3>   { ttk::range::Jump %W %x %y }
bind TRange <B3-Motion>       { ttk::range::Drag %W %x %y }
bind TRange <ButtonRelease-3> { ttk::range::Release %W %x %y }

bind TRange <Left>            { ttk::range::Increment %W -1 }
bind TRange <Up>              { ttk::range::Increment %W -1 }
bind TRange <Right>           { ttk::range::Increment %W 1 }
bind TRange <Down>            { ttk::range::Increment %W 1 }
bind TRange <Control-Left>    { ttk::range::Increment %W -10 }
bind TRange <Control-Up>      { ttk::range::Increment %W -10 }
bind TRange <Control-Right>   { ttk::range::Increment %W 10 }
bind TRange <Control-Down>    { ttk::range::Increment %W 10 }
bind TRange <Home>            { %W set [%W cget -from] }
bind TRange <End>             { %W set [%W cget -to] }

proc ttk::range::Press {w x y} {
    variable State
    set State(dragging) 0

    switch -glob -- [$w identify $x $y] {
	*track -
        *trough {
	    set val [$w get $x $y]
	    set min [$w getmin]
	    set max [$w getmax]
	    if {$val < $min} {
		#increment min
		ttk::Repeatedly IncrementMin $w -0.1
	    } elseif {$val > $max} {
		#increment max
		ttk::Repeatedly IncrementMax $w +0.1
	    } else {
		set State(dragging) 3
		set State(initial) [$w get $x $y]
	    }
        }
        *minslider {
            set State(dragging) 1
            set State(initial) [$w getmin]
        }
	*maxslider {
	    # hack to prevent minslider hidding under the maxslider
	    # when both are at the "to" value
	    if {[$w getmin] == [$w cget -to]} {
		set State(dragging) 1
	    } else {
		set State(dragging) 2
	    }
            
            set State(initial) [$w getmax] 
	}
    }
}

# range::Jump -- ButtonPress-2/3 binding for range acts like
#	Press except that clicking in the trough jumps to the
#	clicked position.
proc ttk::range::Jump {w x y} {
    variable State
    set State(dragging) 0

    switch -glob -- [$w identify $x $y] {
	*track -
        *trough {
	    set val [$w get $x $y]
	    set min [$w getmin]
	    set max [$w getmax]
	    if {$val < $min} {
		#jump min
		$w setmin $val
		set State(initial) [$w get $x $y]
	    } elseif {$val > $max} {
		#jump max
		$w setmax $val
		set State(initial) [$w get $x $y]
	    } else {
		set State(dragging) 3
		set State(initial) [$w get $x $y]
	    }
        }
        *slider {
            Press $w $x $y
        }
    }
}

proc ttk::range::Drag {w x y} {
    variable State
    if {$State(dragging) eq 1} {
	$w setmin [$w get $x $y]
    } elseif {$State(dragging) eq 2} {
	$w setmax [$w get $x $y]
    } else {
	set v [$w get $x $y]
	set dv [expr $v - $State(initial)]
	$w setmin [expr [$w getmin] + $dv]
	$w setmax [expr [$w getmax] + $dv]
	set State(initial) $v
    }
}

proc ttk::range::Release {w x y} {
    variable State
    set State(dragging) 0
    ttk::CancelRepeat
}

proc ttk::range::IncrementMin {w delta} {
    if {![winfo exists $w]} return
    $w setmin [expr {[$w getmin] + $delta}]
}

proc ttk::range::IncrementMax {w delta} {
    if {![winfo exists $w]} return
    $w setmax [expr {[$w getmax] + $delta}]
}

source [file join $::ttk::library notebook.tcl]
source [file join $::ttk::library panedwindow.tcl]
source [file join $::ttk::library entry.tcl]
source [file join $::ttk::library combobox.tcl]	;# dependency: entry.tcl
source [file join $::ttk::library spinbox.tcl]  ;# dependency: entry.tcl
source [file join $::ttk::library treeview.tcl]
source [file join $::ttk::library sizegrip.tcl]
source [file join $::ttk::library range.tcl]

## Label and Labelframe bindings:
#  (not enough to justify their own file...)
#
bind TLabelframe <<Invoke>>	{ tk::TabToWindow [tk_focusNext %W] }
bind TLabel <<Invoke>>		{ tk::TabToWindow [tk_focusNext %W] }

            Scale.focus -expand 1 -sticky nswe -children {
                Vertical.Scale.trough -expand 1 -sticky nswe -children {
                    Vertical.Scale.track -sticky ns
                    Vertical.Scale.slider -side top -sticky {}
                }
            }
        }
	
        # Range
        ttk::style element create Horizontal.Range.minslider vsapi \
            TRACKBAR 3 {disabled 5 focus 4 pressed 3 active 2 {} 1} \
            -width 6 -height 12
        ttk::style element create Horizontal.Range.maxslider vsapi \
            TRACKBAR 3 {disabled 5 focus 4 pressed 3 active 2 {} 1} \
            -width 6 -height 12
        ttk::style layout Horizontal.TRange {
            Range.focus -expand 1 -sticky nswe -children {
                Horizontal.Range.trough -expand 1 -sticky nswe -children {
                    Horizontal.Range.track -sticky we
                    Horizontal.Range.minslider -side left -sticky {}
		    Horizontal.Range.maxslider -side right -sticky {}
                }
            }
        }
        ttk::style element create Vertical.Range.minslider vsapi \
            TRACKBAR 6 {disabled 5 focus 4 pressed 3 active 2 {} 1} \
            -width 12 -height 6
        ttk::style element create Vertical.Range.maxslider vsapi \
            TRACKBAR 6 {disabled 5 focus 4 pressed 3 active 2 {} 1} \
            -width 12 -height 6
        ttk::style layout Vertical.TRange {
            Range.focus -expand 1 -sticky nswe -children {
                Vertical.Range.trough -expand 1 -sticky nswe -children {
                    Vertical.Range.track -sticky ns
                    Vertical.Range.maxslider -side top -sticky {}
		    Vertical.Range.minslider -side bottom -sticky {}
                }
            }
        }
        
        # Treeview
        ttk::style configure Item -padding {4 0 0 0}
        
        package provide ttk::theme::vista 1.0
    }
}

	ttk::style configure TLabelframe -borderwidth 2 -relief groove

	ttk::style configure Toolbutton -relief flat -padding {8 4}
	ttk::style map Toolbutton -relief \
	    {disabled flat selected sunken  pressed sunken  active raised}

	ttk::style configure TScale -groovewidth 4
	
	ttk::style configure TRange groovewidth 4

	ttk::style configure TNotebook -tabmargins {2 2 2 0}
	ttk::style configure TNotebook.Tab -padding {3 1} -borderwidth 1
	ttk::style map TNotebook.Tab -expand [list selected {2 2 2 0}]

	# Treeview:
	ttk::style configure Heading -font TkHeadingFont -relief raised

	tkGrid.o tkMain.o tkObj.o tkOldConfig.o tkOption.o tkPack.o tkPlace.o \
	tkSelect.o tkStyle.o tkUndo.o tkUtil.o tkVisual.o tkWindow.o

TTK_OBJS = \
	ttkBlink.o ttkButton.o ttkCache.o ttkClamTheme.o ttkClassicTheme.o \
	ttkDefaultTheme.o ttkElements.o ttkEntry.o ttkFrame.o ttkImage.o \
	ttkInit.o ttkLabel.o ttkLayout.o ttkManager.o ttkNotebook.o \
	ttkPanedwindow.o ttkProgress.o ttkRange.o ttkScale.o ttkScrollbar.o \
        ttkScroll.o ttkSeparator.o ttkSquare.o ttkState.o \
	ttkTagSet.o ttkTheme.o ttkTrace.o ttkTrack.o ttkTreeview.o \
	ttkWidget.o ttkStubInit.o

STUB_OBJS = tkStubInit.o

STUB_LIB_OBJS = tkStubLib.o ttkStubLib.o

	$(TTK_DIR)/ttkInit.c \
	$(TTK_DIR)/ttkLabel.c \
	$(TTK_DIR)/ttkLayout.c \
	$(TTK_DIR)/ttkManager.c \
	$(TTK_DIR)/ttkNotebook.c \
	$(TTK_DIR)/ttkPanedwindow.c \
	$(TTK_DIR)/ttkProgress.c \
	$(TTK_DIR)/ttkRange.c \
	$(TTK_DIR)/ttkScale.c \
	$(TTK_DIR)/ttkScrollbar.c \
	$(TTK_DIR)/ttkScroll.c \
	$(TTK_DIR)/ttkSeparator.c \
	$(TTK_DIR)/ttkSquare.c \
	$(TTK_DIR)/ttkState.c \
	$(TTK_DIR)/ttkTagSet.c \

ttkPanedwindow.o: $(TTK_DIR)/ttkPanedwindow.c
	$(CC) -c $(CC_SWITCHES) $(TTK_DIR)/ttkPanedwindow.c

ttkProgress.o: $(TTK_DIR)/ttkProgress.c
	$(CC) -c $(CC_SWITCHES) $(TTK_DIR)/ttkProgress.c

ttkRange.o: $(TTK_DIR)/ttkRange.c
	$(CC) -c $(CC_SWITCHES) $(TTK_DIR)/ttkRange.c

ttkScale.o: $(TTK_DIR)/ttkScale.c
	$(CC) -c $(CC_SWITCHES) $(TTK_DIR)/ttkScale.c

ttkScroll.o: $(TTK_DIR)/ttkScroll.c
	$(CC) -c $(CC_SWITCHES) $(TTK_DIR)/ttkScroll.c

ttkScrollbar.o: $(TTK_DIR)/ttkScrollbar.c

        $(TMP_DIR)\ttkInit.obj \
        $(TMP_DIR)\ttkLabel.obj \
        $(TMP_DIR)\ttkLayout.obj \
        $(TMP_DIR)\ttkManager.obj \
        $(TMP_DIR)\ttkNotebook.obj \
        $(TMP_DIR)\ttkPanedwindow.obj \
        $(TMP_DIR)\ttkProgress.obj \
	$(TMP_DIR)\ttkRange.obj \
        $(TMP_DIR)\ttkScale.obj \
        $(TMP_DIR)\ttkScrollbar.obj \
        $(TMP_DIR)\ttkScroll.obj \
        $(TMP_DIR)\ttkSeparator.obj \
        $(TMP_DIR)\ttkSquare.obj \
        $(TMP_DIR)\ttkState.obj \
        $(TMP_DIR)\ttkTagSet.obj \

{
    { TUS_DISABLED, 	TTK_STATE_DISABLED, 0 },
    { TUS_PRESSED, 	TTK_STATE_PRESSED, 0 },
    { TUS_FOCUSED, 	TTK_STATE_FOCUS, 0 },
    { TUS_HOT,		TTK_STATE_ACTIVE, 0 },
    { TUS_NORMAL, 	0, 0 }
};

static Ttk_StateTable range_statemap[] =
{
    { TUS_DISABLED, 	TTK_STATE_DISABLED, 0 },
    { TUS_PRESSED, 	TTK_STATE_PRESSED, 0 },
    { TUS_FOCUSED, 	TTK_STATE_FOCUS, 0 },
    { TUS_HOT,		TTK_STATE_ACTIVE, 0 },
    { TUS_NORMAL, 	0, 0 }
};

static Ttk_StateTable tabitem_statemap[] =
{
    { TIS_DISABLED,     TTK_STATE_DISABLED, 0 },
    { TIS_SELECTED,     TTK_STATE_SELECTED, 0 },
    { TIS_HOT,          TTK_STATE_ACTIVE,   0 },
    { TIS_FOCUSED,      TTK_STATE_FOCUS,    0 },

TTK_LAYOUT("Vertical.TScale",
    TTK_GROUP("Scale.focus", TTK_EXPAND|TTK_FILL_BOTH,
	TTK_GROUP("Vertical.Scale.trough", TTK_EXPAND|TTK_FILL_BOTH,
	    TTK_NODE("Vertical.Scale.track", TTK_FILL_Y)
	    TTK_NODE("Vertical.Scale.slider", TTK_PACK_TOP) )))

TTK_LAYOUT("Horizontal.TRange",
    TTK_GROUP("Range.focus", TTK_EXPAND|TTK_FILL_BOTH,
	TTK_GROUP("Horizontal.Range.trough", TTK_EXPAND|TTK_FILL_BOTH,
	    TTK_NODE("Horizontal.Range.track", TTK_FILL_X)
	    TTK_NODE("Horizontal.Range.minslider", TTK_PACK_LEFT)
	    TTK_NODE("Horizontal.Range.maxslider", TTK_PACK_RIGHT) )))

TTK_LAYOUT("Vertical.TRange",
    TTK_GROUP("Range.focus", TTK_EXPAND|TTK_FILL_BOTH,
	TTK_GROUP("Vertical.Range.trough", TTK_EXPAND|TTK_FILL_BOTH,
	    TTK_NODE("Vertical.Range.track", TTK_FILL_Y)
	    TTK_NODE("Vertical.Range.minslider", TTK_PACK_TOP)
	    TTK_NODE("Vertical.Range.maxslider", TTK_PACK_BOTTOM) )))

TTK_END_LAYOUT_TABLE

/*----------------------------------------------------------------------
 * +++ XP element info table:
 */

#define PAD(l,t,r,b) {l,t,r,b}

    	TKP_THUMB, scale_statemap, NOPAD, 0 },
    { "Vertical.Scale.slider", &GenericElementSpec, L"TRACKBAR",
    	TKP_THUMBVERT, scale_statemap, NOPAD, 0 },
    { "Horizontal.Scale.track", &GenericElementSpec, L"TRACKBAR",
    	TKP_TRACK, scale_statemap, NOPAD, 0 },
    { "Vertical.Scale.track", &GenericElementSpec, L"TRACKBAR",
    	TKP_TRACKVERT, scale_statemap, NOPAD, 0 },
    { "Horizontal.Range.slider", &GenericElementSpec, L"TRACKBAR",
    	TKP_THUMB, range_statemap, NOPAD, 0 },
    { "Vertical.Range.slider", &GenericElementSpec, L"TRACKBAR",
    	TKP_THUMBVERT, range_statemap, NOPAD, 0 },
    { "Horizontal.Range.track", &GenericElementSpec, L"TRACKBAR",
    	TKP_TRACK, range_statemap, NOPAD, 0 },
    { "Vertical.Range.track", &GenericElementSpec, L"TRACKBAR",
    	TKP_TRACKVERT, range_statemap, NOPAD, 0 },
    /* ttk::progressbar elements */
    { "Horizontal.Progressbar.pbar", &PbarElementSpec, L"PROGRESS",
    	PP_CHUNK, null_statemap, NOPAD, 0 },
    { "Vertical.Progressbar.pbar", &PbarElementSpec, L"PROGRESS",
    	PP_CHUNKVERT, null_statemap, NOPAD, 0 },
    { "Horizontal.Progressbar.trough", &GenericElementSpec, L"PROGRESS",
    	PP_BAR, null_statemap, PAD(3,3,3,3), IGNORE_THEMESIZE },

	ClientData clientData = NewElementData(procs, infoPtr);
	Ttk_RegisterElementSpec(
	    themePtr, infoPtr->elementName, infoPtr->elementSpec, clientData);
	Ttk_RegisterCleanup(interp, clientData, DestroyElementData);
    }

    Ttk_RegisterElementSpec(themePtr, "Scale.trough", &ttkNullElementSpec, 0);
    Ttk_RegisterElementSpec(themePtr, "Range.trough", &ttkNullElementSpec, 0);

    /*
     * Layouts:
     */
    Ttk_RegisterLayouts(themePtr, LayoutTable);

    Tcl_PkgProvide(interp, "ttk::theme::xpnative", TTK_VERSION);

    return TCL_OK;
}

#endif /* HAVE_UXTHEME_H */