static int FrameConfigure(Tcl_Interp *interp, void *recordPtr, int mask)
{
Frame *framePtr = recordPtr;
int width, height;
/*
* Make sure -padding resource, if present, is correct:
*/
if (framePtr->frame.paddingObj) {
Ttk_Padding unused;
if (Ttk_GetPaddingFromObj(interp,
framePtr->core.tkwin,
framePtr->frame.paddingObj,
&unused) != TCL_OK) {
return TCL_ERROR;
}
}
/* See <<NOTE-SIZE>>
*/
if ( TCL_OK != Tk_GetPixelsFromObj(
interp,framePtr->core.tkwin,framePtr->frame.widthObj,&width)
|| TCL_OK != Tk_GetPixelsFromObj(
interp,framePtr->core.tkwin,framePtr->frame.heightObj,&height)
)
{
return TCL_ERROR;
}
if ((width > 0 || height > 0) && (mask & GEOMETRY_CHANGED)) {
Tk_GeometryRequest(framePtr->core.tkwin, width, height);
}
return TtkCoreConfigure(interp, recordPtr, mask);
}
static void TroughElementDraw(
void *clientData, void *elementRecord, Tk_Window tkwin,
Drawable d, Ttk_Box b, unsigned int state)
{
TroughElement *troughPtr = elementRecord;
Tk_3DBorder border = NULL;
int borderWidth = 2, relief = TK_RELIEF_SUNKEN, groove = -1, orient;
border = Tk_Get3DBorderFromObj(tkwin, troughPtr->colorObj);
Ttk_GetOrientFromObj(NULL, troughPtr->orientObj, &orient);
Tk_GetReliefFromObj(NULL, troughPtr->reliefObj, &relief);
Tk_GetPixelsFromObj(NULL, tkwin, troughPtr->borderWidthObj, &borderWidth);
Tk_GetPixelsFromObj(NULL, tkwin, troughPtr->grooveWidthObj, &groove);
if (groove != -1 && groove < b.height && groove < b.width) {
if (orient == TTK_ORIENT_HORIZONTAL) {
b.y = b.y + b.height/2 - groove/2;
b.height = groove;
} else {
b.x = b.x + b.width/2 - groove/2;
b.width = groove;
}
}
Tk_Fill3DRectangle(tkwin, d, border, b.x, b.y, b.width, b.height,
borderWidth, relief);
}
static void SashElementDraw(
void *clientData, void *elementRecord, Tk_Window tkwin,
Drawable d, Ttk_Box b, Ttk_State state)
{
SashElement *sash = elementRecord;
Tk_3DBorder border = Tk_Get3DBorderFromObj(tkwin, sash->borderObj);
GC gc1,gc2;
int relief = TK_RELIEF_RAISED;
int handleSize = 8, handlePad = 8;
int horizontal = *((Ttk_Orient*)clientData) == TTK_ORIENT_HORIZONTAL;
Ttk_Box hb;
Tk_GetPixelsFromObj(NULL, tkwin, sash->handleSizeObj, &handleSize);
Tk_GetPixelsFromObj(NULL, tkwin, sash->handlePadObj, &handlePad);
Tk_GetReliefFromObj(NULL, sash->sashReliefObj, &relief);
switch (relief) {
case TK_RELIEF_RAISED: case TK_RELIEF_RIDGE:
gc1 = Tk_3DBorderGC(tkwin, border, TK_3D_LIGHT_GC);
gc2 = Tk_3DBorderGC(tkwin, border, TK_3D_DARK_GC);
break;
case TK_RELIEF_SUNKEN: case TK_RELIEF_GROOVE:
gc1 = Tk_3DBorderGC(tkwin, border, TK_3D_DARK_GC);
gc2 = Tk_3DBorderGC(tkwin, border, TK_3D_LIGHT_GC);
break;
case TK_RELIEF_SOLID:
gc1 = gc2 = Tk_3DBorderGC(tkwin, border, TK_3D_DARK_GC);
break;
case TK_RELIEF_FLAT:
default:
gc1 = gc2 = Tk_3DBorderGC(tkwin, border, TK_3D_FLAT_GC);
break;
}
/* Draw sash line:
*/
if (horizontal) {
int y = b.y + b.height/2 - 1;
XDrawLine(Tk_Display(tkwin), d, gc1, b.x, y, b.x+b.width, y); ++y;
XDrawLine(Tk_Display(tkwin), d, gc2, b.x, y, b.x+b.width, y);
} else {
int x = b.x + b.width/2 - 1;
XDrawLine(Tk_Display(tkwin), d, gc1, x, b.y, x, b.y+b.height); ++x;
XDrawLine(Tk_Display(tkwin), d, gc2, x, b.y, x, b.y+b.height);
}
/* Draw handle:
*/
if (handleSize >= 0) {
if (horizontal) {
hb = Ttk_StickBox(b, handleSize, handleSize, TTK_STICK_W);
hb.x += handlePad;
} else {
hb = Ttk_StickBox(b, handleSize, handleSize, TTK_STICK_N);
hb.y += handlePad;
}
Tk_Fill3DRectangle(tkwin, d, border,
hb.x, hb.y, hb.width, hb.height, 1, TK_RELIEF_RAISED);
}
}
static void
DrawMenuEntryIndicator(
TkMenu *menuPtr, /* The menu we are drawing */
TkMenuEntry *mePtr, /* The entry we are drawing */
Drawable d, /* The drawable to draw into */
Tk_3DBorder border, /* The background color */
XColor *indicatorColor, /* The color to draw indicators with */
XColor *disableColor, /* The color use use when disabled */
Tk_Font tkfont, /* The font to draw with */
const Tk_FontMetrics *fmPtr,/* The font metrics of the font */
int x, /* The left of the entry rect */
int y, /* The top of the entry rect */
int width, /* Width of menu entry */
int height) /* Height of menu entry */
{
/*
* Draw check-button indicator.
*/
if ((mePtr->type == CHECK_BUTTON_ENTRY) && mePtr->indicatorOn) {
int top, left, activeBorderWidth;
int disabled = (mePtr->state == ENTRY_DISABLED);
XColor *bg;
Tk_GetPixelsFromObj(NULL, menuPtr->tkwin,
menuPtr->activeBorderWidthPtr, &activeBorderWidth);
bg = Tk_3DBorderColor(border);
top = y + height/2;
left = x + activeBorderWidth + DECORATION_BORDER_WIDTH
+ mePtr->indicatorSpace/2;
TkpDrawCheckIndicator(menuPtr->tkwin, menuPtr->display, d, left, top,
border, indicatorColor, bg, disableColor,
(mePtr->entryFlags & ENTRY_SELECTED), disabled, CHECK_MENU);
}
/*
* Draw radio-button indicator.
*/
if ((mePtr->type == RADIO_BUTTON_ENTRY) && mePtr->indicatorOn) {
int top, left, activeBorderWidth;
int disabled = (mePtr->state == ENTRY_DISABLED);
XColor *bg;
Tk_GetPixelsFromObj(NULL, menuPtr->tkwin,
menuPtr->activeBorderWidthPtr, &activeBorderWidth);
bg = Tk_3DBorderColor(border);
top = y + height/2;
left = x + activeBorderWidth + DECORATION_BORDER_WIDTH
+ mePtr->indicatorSpace/2;
TkpDrawCheckIndicator(menuPtr->tkwin, menuPtr->display, d, left, top,
border, indicatorColor, bg, disableColor,
(mePtr->entryFlags & ENTRY_SELECTED), disabled, RADIO_MENU);
}
}
static void
DrawMenuEntryAccelerator(
TkMenu *menuPtr, /* The menu we are drawing */
TkMenuEntry *mePtr, /* The entry we are drawing */
Drawable d, /* The drawable we are drawing into */
GC gc, /* The precalculated gc to draw with */
Tk_Font tkfont, /* The precalculated font */
const Tk_FontMetrics *fmPtr,/* The precalculated metrics */
Tk_3DBorder activeBorder, /* The border for an active item */
int x, /* Left coordinate of entry rect */
int y, /* Top coordinate of entry rect */
int width, /* Width of entry */
int height, /* Height of entry */
int drawArrow) /* Whether or not to draw arrow. */
{
XPoint points[3];
int borderWidth, activeBorderWidth;
/*
* Draw accelerator or cascade arrow.
*/
if (menuPtr->menuType == MENUBAR) {
return;
}
Tk_GetPixelsFromObj(NULL, menuPtr->tkwin, menuPtr->borderWidthPtr,
&borderWidth);
Tk_GetPixelsFromObj(NULL, menuPtr->tkwin, menuPtr->activeBorderWidthPtr,
&activeBorderWidth);
if ((mePtr->type == CASCADE_ENTRY) && drawArrow) {
points[0].x = x + width - borderWidth - activeBorderWidth
- CASCADE_ARROW_WIDTH;
points[0].y = y + (height - CASCADE_ARROW_HEIGHT)/2;
points[1].x = points[0].x;
points[1].y = points[0].y + CASCADE_ARROW_HEIGHT;
points[2].x = points[0].x + CASCADE_ARROW_WIDTH;
points[2].y = points[0].y + CASCADE_ARROW_HEIGHT/2;
Tk_Fill3DPolygon(menuPtr->tkwin, d, activeBorder, points, 3,
DECORATION_BORDER_WIDTH,
(menuPtr->postedCascade == mePtr)
? TK_RELIEF_SUNKEN : TK_RELIEF_RAISED);
} else if (mePtr->accelPtr != NULL) {
const char *accel = Tcl_GetString(mePtr->accelPtr);
int left = x + mePtr->labelWidth + activeBorderWidth
+ mePtr->indicatorSpace;
if (menuPtr->menuType == MENUBAR) {
left += 5;
}
Tk_DrawChars(menuPtr->display, d, gc, tkfont, accel,
mePtr->accelLength, left,
(y + (height + fmPtr->ascent - fmPtr->descent) / 2));
}
}
static void SquareElementSize(
void *clientData, void *elementRecord, Tk_Window tkwin,
int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr)
{
SquareElement *square = elementRecord;
int borderWidth = 0;
Tcl_GetIntFromObj(NULL, square->borderWidthObj, &borderWidth);
*paddingPtr = Ttk_UniformPadding((short)borderWidth);
Tk_GetPixelsFromObj(NULL, tkwin, square->widthObj, widthPtr);
Tk_GetPixelsFromObj(NULL, tkwin, square->heightObj, heightPtr);
}
static void MenuIndicatorElementSize(
void *clientData, void *elementRecord, Tk_Window tkwin,
int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr)
{
MenuIndicatorElement *mi = elementRecord;
Ttk_Padding margins;
Tk_GetPixelsFromObj(NULL, tkwin, mi->widthObj, widthPtr);
Tk_GetPixelsFromObj(NULL, tkwin, mi->heightObj, heightPtr);
Ttk_GetPaddingFromObj(NULL,tkwin,mi->marginObj, &margins);
*widthPtr += Ttk_PaddingWidth(margins);
*heightPtr += Ttk_PaddingHeight(margins);
}
static void TroughElementSize(
void *clientData, void *elementRecord, Tk_Window tkwin,
int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr)
{
TroughElement *troughPtr = elementRecord;
int borderWidth = 2, grooveWidth = 0;
Tk_GetPixelsFromObj(NULL, tkwin, troughPtr->borderWidthObj, &borderWidth);
Tk_GetPixelsFromObj(NULL, tkwin, troughPtr->grooveWidthObj, &grooveWidth);
if (grooveWidth <= 0) {
*paddingPtr = Ttk_UniformPadding((short)borderWidth);
}
}
static void MenubuttonArrowElementDraw(
void *clientData, void *elementRecord, Tk_Window tkwin,
Drawable d, Ttk_Box b, unsigned int state)
{
MenubuttonArrowElement *arrow = elementRecord;
XColor *arrowColor = Tk_GetColorFromObj(tkwin, arrow->colorObj);
GC gc = Tk_GCForColor(arrowColor, d);
int size = MENUBUTTON_ARROW_SIZE;
int postDirection = POST_BELOW;
ArrowDirection arrowDirection = ARROW_DOWN;
int width = 0, height = 0;
Tk_GetPixelsFromObj(NULL, tkwin, arrow->sizeObj, &size);
Tcl_GetIndexFromObjStruct(NULL, arrow->directionObj, directionStrings,
sizeof(char *), ""/*message*/, 0/*flags*/, &postDirection);
/* ... this might not be such a great idea ... */
switch (postDirection) {
case POST_ABOVE: arrowDirection = ARROW_UP; break;
case POST_BELOW: arrowDirection = ARROW_DOWN; break;
case POST_LEFT: arrowDirection = ARROW_LEFT; break;
case POST_RIGHT: arrowDirection = ARROW_RIGHT; break;
case POST_FLUSH: arrowDirection = ARROW_DOWN; break;
}
TtkArrowSize(size, arrowDirection, &width, &height);
b = Ttk_PadBox(b, MenubuttonArrowPadding);
b = Ttk_AnchorBox(b, width, height, TK_ANCHOR_CENTER);
TtkFillArrow(Tk_Display(tkwin), d, gc, b, arrowDirection);
}
/*
* Ttk_GetPaddingFromObj --
*
* Extract a padding specification from a Tcl_Obj * scaled
* to work with a particular Tk_Window.
*
* The string representation of a Ttk_Padding is a list
* of one to four Tk_Pixel specifications, corresponding
* to the left, top, right, and bottom padding.
*
* If the 'bottom' (fourth) element is missing, it defaults to 'top'.
* If the 'right' (third) element is missing, it defaults to 'left'.
* If the 'top' (second) element is missing, it defaults to 'left'.
*
* The internal representation is a Tcl_ListObj containing
* one to four Tk_PixelObj objects.
*
* Returns:
* TCL_OK or TCL_ERROR. In the latter case an error message is
* left in 'interp' and '*paddingPtr' is set to all-zeros.
* Otherwise, *paddingPtr is filled in with the padding specification.
*
*/
int Ttk_GetPaddingFromObj(
Tcl_Interp *interp,
Tk_Window tkwin,
Tcl_Obj *objPtr,
Ttk_Padding *pad)
{
Tcl_Obj **padv;
int i, padc, pixels[4];
if (TCL_OK != Tcl_ListObjGetElements(interp, objPtr, &padc, &padv)) {
goto error;
}
if (padc > 4) {
if (interp) {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "Wrong #elements in padding spec", NULL);
}
goto error;
}
for (i=0; i < padc; ++i) {
if (Tk_GetPixelsFromObj(interp, tkwin, padv[i], &pixels[i]) != TCL_OK) {
goto error;
}
}
TTKInitPadding(padc, pixels, pad);
return TCL_OK;
error:
pad->left = pad->top = pad->right = pad->bottom = 0;
return TCL_ERROR;
}
static void
DrawMenuEntryBackground(
TkMenu *menuPtr, /* The menu we are drawing */
TkMenuEntry *mePtr, /* The entry we are drawing. */
Drawable d, /* The drawable we are drawing into */
Tk_3DBorder activeBorder, /* The border for an active item */
Tk_3DBorder bgBorder, /* The background border */
int x, /* Left coordinate of entry rect */
int y, /* Right coordinate of entry rect */
int width, /* Width of entry rect */
int height) /* Height of entry rect */
{
if (mePtr->state == ENTRY_ACTIVE) {
int relief;
int activeBorderWidth;
bgBorder = activeBorder;
if ((menuPtr->menuType == MENUBAR)
&& ((menuPtr->postedCascade == NULL)
|| (menuPtr->postedCascade != mePtr))) {
relief = TK_RELIEF_FLAT;
} else {
relief = TK_RELIEF_RAISED;
}
Tk_GetPixelsFromObj(NULL, menuPtr->tkwin,
menuPtr->activeBorderWidthPtr, &activeBorderWidth);
Tk_Fill3DRectangle(menuPtr->tkwin, d, bgBorder, x, y, width, height,
activeBorderWidth, relief);
} else {
Tk_Fill3DRectangle(menuPtr->tkwin, d, bgBorder, x, y, width, height,
0, TK_RELIEF_FLAT);
}
}
static void
GetMenuIndicatorGeometry(
TkMenu *menuPtr, /* The menu we are drawing. */
TkMenuEntry *mePtr, /* The entry we are interested in. */
Tk_Font tkfont, /* The precalculated font */
const Tk_FontMetrics *fmPtr,/* The precalculated metrics */
int *widthPtr, /* The resulting width */
int *heightPtr) /* The resulting height */
{
int borderWidth;
if ((mePtr->type == CHECK_BUTTON_ENTRY)
|| (mePtr->type == RADIO_BUTTON_ENTRY)) {
if (!mePtr->hideMargin && mePtr->indicatorOn) {
if ((mePtr->image != NULL) || (mePtr->bitmapPtr != NULL)) {
*widthPtr = (14 * mePtr->height) / 10;
*heightPtr = mePtr->height;
if (mePtr->type == CHECK_BUTTON_ENTRY) {
mePtr->platformEntryData = (TkMenuPlatformEntryData)
INT2PTR((65 * mePtr->height) / 100);
} else {
mePtr->platformEntryData = (TkMenuPlatformEntryData)
INT2PTR((75 * mePtr->height) / 100);
}
} else {
*widthPtr = *heightPtr = mePtr->height;
if (mePtr->type == CHECK_BUTTON_ENTRY) {
mePtr->platformEntryData = (TkMenuPlatformEntryData)
INT2PTR((80 * mePtr->height) / 100);
} else {
mePtr->platformEntryData = (TkMenuPlatformEntryData)
INT2PTR(mePtr->height);
}
}
} else {
Tk_GetPixelsFromObj(NULL, menuPtr->tkwin, menuPtr->borderWidthPtr,
&borderWidth);
*heightPtr = 0;
*widthPtr = borderWidth;
}
} else {
Tk_GetPixelsFromObj(NULL, menuPtr->tkwin, menuPtr->borderWidthPtr,
&borderWidth);
*heightPtr = 0;
*widthPtr = borderWidth;
}
}
static void ClientElementSize(
void *clientData, void *elementRecord, Tk_Window tkwin,
int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr)
{
ClientElement *ce = elementRecord;
int borderWidth = 1;
Tk_GetPixelsFromObj(0, tkwin, ce->borderWidthObj, &borderWidth);
*paddingPtr = Ttk_UniformPadding((short)borderWidth);
}
static void FieldElementSize(
void *clientData, void *elementRecord, Tk_Window tkwin,
int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr)
{
FieldElement *field = elementRecord;
int borderWidth = 2;
Tk_GetPixelsFromObj(NULL, tkwin, field->borderWidthObj, &borderWidth);
*paddingPtr = Ttk_UniformPadding((short)borderWidth);
}
static void ArrowElementSize(
void *clientData, void *elementRecord, Tk_Window tkwin,
int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr)
{
ArrowElement *arrow = elementRecord;
int size = 12;
Tk_GetPixelsFromObj(NULL, tkwin, arrow->sizeObj, &size);
*widthPtr = *heightPtr = size;
}
static void BorderElementSize(
void *clientData, void *elementRecord, Tk_Window tkwin,
int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr)
{
BorderElement *border = (BorderElement*)elementRecord;
int borderWidth = 2;
Tk_GetPixelsFromObj(NULL, tkwin, border->borderWidthObj, &borderWidth);
if (borderWidth == 1) ++borderWidth;
*paddingPtr = Ttk_UniformPadding((short)borderWidth);
}
static void TabElementSize(
void *clientData, void *elementRecord, Tk_Window tkwin,
int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr)
{
TabElement *tab = elementRecord;
int borderWidth = 1;
Tk_GetPixelsFromObj(0, tkwin, tab->borderWidthObj, &borderWidth);
paddingPtr->top = paddingPtr->left = paddingPtr->right = borderWidth;
paddingPtr->bottom = 0;
}
static void SashElementSize(
void *clientData, void *elementRecord, Tk_Window tkwin,
int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr)
{
SashElement *sash = elementRecord;
int sashPad = 2, sashThickness = 6, handleSize = 8;
int horizontal = *((Ttk_Orient*)clientData) == TTK_ORIENT_HORIZONTAL;
Tk_GetPixelsFromObj(NULL, tkwin, sash->sashThicknessObj, &sashThickness);
Tk_GetPixelsFromObj(NULL, tkwin, sash->handleSizeObj, &handleSize);
Tk_GetPixelsFromObj(NULL, tkwin, sash->sashPadObj, &sashPad);
if (sashThickness < handleSize + 2*sashPad)
sashThickness = handleSize + 2*sashPad;
if (horizontal)
*heightPtr = sashThickness;
else
*widthPtr = sashThickness;
}
static void MenubuttonArrowElementSize(
void *clientData, void *elementRecord, Tk_Window tkwin,
int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr)
{
MenubuttonArrowElement *arrow = elementRecord;
int size = MENUBUTTON_ARROW_SIZE;
Tk_GetPixelsFromObj(NULL, tkwin, arrow->sizeObj, &size);
*widthPtr = *heightPtr = 2 * size + 1;
*widthPtr += Ttk_PaddingWidth(MenubuttonArrowPadding);
*heightPtr += Ttk_PaddingHeight(MenubuttonArrowPadding);
}
/*
* Radiobutton indicators: 3-D diamond.
*/
static void DiamondIndicatorElementSize(
void *clientData, void *elementRecord, Tk_Window tkwin,
int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr)
{
IndicatorElement *indicator = elementRecord;
Ttk_Padding margins;
int diameter = 0;
Ttk_GetPaddingFromObj(NULL, tkwin, indicator->marginObj, &margins);
Tk_GetPixelsFromObj(NULL, tkwin, indicator->diameterObj, &diameter);
*widthPtr = diameter + 3 + Ttk_PaddingWidth(margins);
*heightPtr = diameter + 3 + Ttk_PaddingHeight(margins);
}
static void FieldElementDraw(
void *clientData, void *elementRecord, Tk_Window tkwin,
Drawable d, Ttk_Box b, unsigned int state)
{
FieldElement *field = elementRecord;
Tk_3DBorder border = Tk_Get3DBorderFromObj(tkwin, field->borderObj);
int borderWidth = 2;
Tk_GetPixelsFromObj(NULL, tkwin, field->borderWidthObj, &borderWidth);
Tk_Fill3DRectangle(tkwin, d, border,
b.x, b.y, b.width, b.height, borderWidth, TK_RELIEF_SUNKEN);
}
static void IndicatorElementSize(
void *clientData, void *elementRecord, Tk_Window tkwin,
int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr)
{
IndicatorElement *indicator = elementRecord;
Ttk_Padding margins;
int size = 10;
Ttk_GetPaddingFromObj(NULL, tkwin, indicator->marginObj, &margins);
Tk_GetPixelsFromObj(NULL, tkwin, indicator->sizeObj, &size);
*widthPtr = size + Ttk_PaddingWidth(margins);
*heightPtr = size + Ttk_PaddingHeight(margins);
}
static void ThumbElementDraw(
void *clientData, void *elementRecord, Tk_Window tkwin,
Drawable d, Ttk_Box b, unsigned int state)
{
ThumbElement *thumb = elementRecord;
Tk_3DBorder border = Tk_Get3DBorderFromObj(tkwin, thumb->borderObj);
int borderWidth = 2, relief = TK_RELIEF_RAISED;
Tk_GetPixelsFromObj(NULL, tkwin, thumb->borderWidthObj, &borderWidth);
Tk_GetReliefFromObj(NULL, thumb->reliefObj, &relief);
Tk_Fill3DRectangle(tkwin, d, border, b.x, b.y, b.width, b.height,
borderWidth, relief);
}
static void MenuIndicatorElementSize(
void *clientData, void *elementRecord, Tk_Window tkwin,
int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr)
{
MenuIndicatorElement *indicator = elementRecord;
Ttk_Padding margins;
int size = MENUBUTTON_ARROW_SIZE;
Tk_GetPixelsFromObj(NULL, tkwin, indicator->sizeObj, &size);
Ttk_GetPaddingFromObj(NULL, tkwin, indicator->paddingObj, &margins);
TtkArrowSize(size, ARROW_DOWN, widthPtr, heightPtr);
*widthPtr += Ttk_PaddingWidth(margins);
*heightPtr += Ttk_PaddingHeight(margins);
}
static void SliderElementSize(
void *clientData, void *elementRecord, Tk_Window tkwin,
int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr)
{
SliderElement *slider = elementRecord;
int orient, length, thickness;
Ttk_GetOrientFromObj(NULL, slider->orientObj, &orient);
Tk_GetPixelsFromObj(NULL, tkwin, slider->lengthObj, &length);
Tk_GetPixelsFromObj(NULL, tkwin, slider->thicknessObj, &thickness);
switch (orient) {
case TTK_ORIENT_VERTICAL:
*widthPtr = thickness;
*heightPtr = length;
break;
case TTK_ORIENT_HORIZONTAL:
*widthPtr = length;
*heightPtr = thickness;
break;
}
}
static void ArrowElementSize(
void *clientData, void *elementRecord, Tk_Window tkwin,
int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr)
{
ArrowElement *arrow = elementRecord;
int direction = *(int *)clientData;
int width = 14;
Tk_GetPixelsFromObj(NULL, tkwin, arrow->sizeObj, &width);
width -= Ttk_PaddingWidth(ArrowMargins);
TtkArrowSize(width/2, direction, widthPtr, heightPtr);
*widthPtr += Ttk_PaddingWidth(ArrowMargins);
*heightPtr += Ttk_PaddingWidth(ArrowMargins);
}
static void PbarElementSize(
void *clientData, void *elementRecord, Tk_Window tkwin,
int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr)
{
PbarElement *pbar = elementRecord;
int orient, thickness = 15, length = 30, borderWidth = 2;
Ttk_GetOrientFromObj(NULL, pbar->orientObj, &orient);
Tk_GetPixelsFromObj(NULL, tkwin, pbar->thicknessObj, &thickness);
Tk_GetPixelsFromObj(NULL, tkwin, pbar->lengthObj, &length);
Tk_GetPixelsFromObj(NULL, tkwin, pbar->borderWidthObj, &borderWidth);
switch (orient) {
case TTK_ORIENT_HORIZONTAL:
*widthPtr = length + 2 * borderWidth;
*heightPtr = thickness + 2 * borderWidth;
break;
case TTK_ORIENT_VERTICAL:
*widthPtr = thickness + 2 * borderWidth;
*heightPtr = length + 2 * borderWidth;
break;
}
}
static void ArrowElementDraw(
void *clientData, void *elementRecord, Tk_Window tkwin,
Drawable d, Ttk_Box b, unsigned int state)
{
int direction = *(int *)clientData;
ArrowElement *arrow = elementRecord;
Tk_3DBorder border;
int borderWidth;
int relief = TK_RELIEF_RAISED;
int size;
XPoint points[3];
Tk_GetPixelsFromObj(NULL, tkwin, arrow->borderWidthObj, &borderWidth);
border = Tk_Get3DBorderFromObj(tkwin, arrow->borderObj);
Tk_GetReliefFromObj(NULL, arrow->reliefObj, &relief);
size = b.width < b.height ? b.width : b.height;
/*
* @@@ There are off-by-one pixel errors in the way these are drawn;
* @@@ need to take a look at Tk_Fill3DPolygon and X11 to find the
* @@@ exact rules.
*/
switch (direction)
{
case ARROW_UP:
points[2].x = b.x; points[2].y = b.y + size;
points[1].x = b.x + size/2; points[1].y = b.y;
points[0].x = b.x + size; points[0].y = b.y + size;
break;
case ARROW_DOWN:
points[0].x = b.x; points[0].y = b.y;
points[1].x = b.x + size/2; points[1].y = b.y + size;
points[2].x = b.x + size; points[2].y = b.y;
break;
case ARROW_LEFT:
points[0].x = b.x; points[0].y = b.y + size / 2;
points[1].x = b.x + size; points[1].y = b.y + size;
points[2].x = b.x + size; points[2].y = b.y;
break;
case ARROW_RIGHT:
points[0].x = b.x + size; points[0].y = b.y + size / 2;
points[1].x = b.x; points[1].y = b.y;
points[2].x = b.x; points[2].y = b.y + size;
break;
}
Tk_Fill3DPolygon(tkwin, d, border, points, 3, borderWidth, relief);
}
static void TroughElementDraw(
void *clientData, void *elementRecord, Tk_Window tkwin,
Drawable d, Ttk_Box b, unsigned int state)
{
TroughElement *troughPtr = elementRecord;
Tk_3DBorder border = NULL;
int borderWidth = 2, relief = TK_RELIEF_SUNKEN;
border = Tk_Get3DBorderFromObj(tkwin, troughPtr->colorObj);
Tk_GetReliefFromObj(NULL, troughPtr->reliefObj, &relief);
Tk_GetPixelsFromObj(NULL, tkwin, troughPtr->borderWidthObj, &borderWidth);
Tk_Fill3DRectangle(tkwin, d, border, b.x, b.y, b.width, b.height,
borderWidth, relief);
}
static void MenuIndicatorElementDraw(
void *clientData, void *elementRecord, Tk_Window tkwin,
Drawable d, Ttk_Box b, unsigned int state)
{
MenuIndicatorElement *mi = elementRecord;
Tk_3DBorder border = Tk_Get3DBorderFromObj(tkwin, mi->backgroundObj);
Ttk_Padding margins;
int borderWidth = 2;
Ttk_GetPaddingFromObj(NULL,tkwin,mi->marginObj,&margins);
b = Ttk_PadBox(b, margins);
Tk_GetPixelsFromObj(NULL, tkwin, mi->borderWidthObj, &borderWidth);
Tk_Fill3DRectangle(tkwin, d, border, b.x, b.y, b.width, b.height,
borderWidth, TK_RELIEF_RAISED);
}
