/*
* ttkLayout.c --
*
* Generic layout processing.
*
* Copyright (c) 2003 Joe English. Freely redistributable.
*
* $Id: ttkLayout.c,v 1.8 2007/03/21 20:06:41 jenglish Exp $
*/
#include <string.h>
#include <tk.h>
#include "ttkThemeInt.h"
#define MAX(a,b) (a > b ? a : b)
#define MIN(a,b) (a < b ? a : b)
/*------------------------------------------------------------------------
* +++ Ttk_Box and Ttk_Padding utilities:
*/
Ttk_Box
Ttk_MakeBox(int x, int y, int width, int height)
{
Ttk_Box b;
b.x = x; b.y = y; b.width = width; b.height = height;
return b;
}
int
Ttk_BoxContains(Ttk_Box box, int x, int y)
{
return box.x <= x && x < box.x + box.width
&& box.y <= y && y < box.y + box.height;
}
Tcl_Obj *
Ttk_NewBoxObj(Ttk_Box box)
{
Tcl_Obj *result[4];
result[0] = Tcl_NewIntObj(box.x);
result[1] = Tcl_NewIntObj(box.y);
result[2] = Tcl_NewIntObj(box.width);
result[3] = Tcl_NewIntObj(box.height);
return Tcl_NewListObj(4, result);
}
/*
* packTop, packBottom, packLeft, packRight --
* Carve out a parcel of the specified height (resp width)
* from the specified cavity.
*
* Returns:
* The new parcel.
*
* Side effects:
* Adjust the cavity.
*/
static Ttk_Box packTop(Ttk_Box *cavity, int height)
{
Ttk_Box parcel;
height = MIN(height, cavity->height);
parcel = Ttk_MakeBox(cavity->x, cavity->y, cavity->width, height);
cavity->y += height;
cavity->height -= height;
return parcel;
}
static Ttk_Box packBottom(Ttk_Box *cavity, int height)
{
height = MIN(height, cavity->height);
cavity->height -= height;
return Ttk_MakeBox(
cavity->x, cavity->y + cavity->height,
cavity->width, height);
}
static Ttk_Box packLeft(Ttk_Box *cavity, int width)
{
Ttk_Box parcel;
width = MIN(width, cavity->width);
parcel = Ttk_MakeBox(cavity->x, cavity->y, width,cavity->height);
cavity->x += width;
cavity->width -= width;
return parcel;
}
static Ttk_Box packRight(Ttk_Box *cavity, int width)
{
width = MIN(width, cavity->width);
cavity->width -= width;
return Ttk_MakeBox(cavity->x + cavity->width,
cavity->y, width, cavity->height);
}
/*
* Ttk_PackBox --
* Carve out a parcel of the specified size on the specified side
* in the specified cavity.
*
* Returns:
* The new parcel.
*
* Side effects:
* Adjust the cavity.
*/
Ttk_Box Ttk_PackBox(Ttk_Box *cavity, int width, int height, Ttk_Side side)
{
switch (side) {
default:
case TTK_SIDE_TOP: return packTop(cavity, height);
case TTK_SIDE_BOTTOM: return packBottom(cavity, height);
case TTK_SIDE_LEFT: return packLeft(cavity, width);
case TTK_SIDE_RIGHT: return packRight(cavity, width);
}
}
/*
* Ttk_PadBox --
* Shrink a box by the specified padding amount.
*/
Ttk_Box Ttk_PadBox(Ttk_Box b, Ttk_Padding p)
{
b.x += p.left;
b.y += p.top;
b.width -= (p.left + p.right);
b.height -= (p.top + p.bottom);
if (b.width <= 0) b.width = 1;
if (b.height <= 0) b.height = 1;
return b;
}
/*
* Ttk_ExpandBox --
* Grow a box by the specified padding amount.
*/
Ttk_Box Ttk_ExpandBox(Ttk_Box b, Ttk_Padding p)
{
b.x -= p.left;
b.y -= p.top;
b.width += (p.left + p.right);
b.height += (p.top + p.bottom);
return b;
}
/*
* Ttk_StickBox --
* Place a box of size w * h in the specified parcel,
* according to the specified sticky bits.
*/
Ttk_Box Ttk_StickBox(Ttk_Box parcel, int width, int height, unsigned sticky)
{
int dx, dy;
if (width > parcel.width) width = parcel.width;
if (height > parcel.height) height = parcel.height;
dx = parcel.width - width;
dy = parcel.height - height;
/*
* X coordinate adjustment:
*/
switch (sticky & (TTK_STICK_W | TTK_STICK_E))
{
case TTK_STICK_W | TTK_STICK_E:
/* no-op -- use entire parcel width */
break;
case TTK_STICK_W:
parcel.width = width;
break;
case TTK_STICK_E:
parcel.x += dx;
parcel.width = width;
break;
default :
parcel.x += dx / 2;
parcel.width = width;
break;
}
/*
* Y coordinate adjustment:
*/
switch (sticky & (TTK_STICK_N | TTK_STICK_S))
{
case TTK_STICK_N | TTK_STICK_S:
/* use entire parcel height */
break;
case TTK_STICK_N:
parcel.height = height;
break;
case TTK_STICK_S:
parcel.y += dy;
parcel.height = height;
break;
default :
parcel.y += dy / 2;
parcel.height = height;
break;
}
return parcel;
}
/*
* AnchorToSticky --
* Convert a Tk_Anchor enum to a TTK_STICKY bitmask.
*/
static Ttk_Sticky AnchorToSticky(Tk_Anchor anchor)
{
switch (anchor)
{
case TK_ANCHOR_N: return TTK_STICK_N;
case TK_ANCHOR_NE: return TTK_STICK_N | TTK_STICK_E;
case TK_ANCHOR_E: return TTK_STICK_E;
case TK_ANCHOR_SE: return TTK_STICK_S | TTK_STICK_E;
case TK_ANCHOR_S: return TTK_STICK_S;
case TK_ANCHOR_SW: return TTK_STICK_S | TTK_STICK_W;
case TK_ANCHOR_W: return TTK_STICK_W;
case TK_ANCHOR_NW: return TTK_STICK_N | TTK_STICK_W;
default:
case TK_ANCHOR_CENTER: return 0;
}
}
/*
* Ttk_AnchorBox --
* Place a box of size w * h in the specified parcel,
* according to the specified anchor.
*/
Ttk_Box Ttk_AnchorBox(Ttk_Box parcel, int width, int height, Tk_Anchor anchor)
{
return Ttk_StickBox(parcel, width, height, AnchorToSticky(anchor));
}
/*
* Ttk_PlaceBox --
* Combine Ttk_PackBox() and Ttk_StickBox().
*/
Ttk_Box Ttk_PlaceBox(
Ttk_Box *cavity, int width, int height, Ttk_Side side, unsigned sticky)
{
return Ttk_StickBox(
Ttk_PackBox(cavity, width, height, side), width, height, sticky);
}
/*
* Ttk_PositionBox --
* Pack and stick a box according to PositionSpec flags.
*/
MODULE_SCOPE Ttk_Box
Ttk_PositionBox(Ttk_Box *cavity, int width, int height, Ttk_PositionSpec flags)
{
Ttk_Box parcel;
if (flags & TTK_EXPAND) parcel = *cavity;
else if (flags & TTK_PACK_TOP) parcel = packTop(cavity, height);
else if (flags & TTK_PACK_LEFT) parcel = packLeft(cavity, width);
else if (flags & TTK_PACK_BOTTOM) parcel = packBottom(cavity, height);
else if (flags & TTK_PACK_RIGHT) parcel = packRight(cavity, width);
else parcel = *cavity;
return Ttk_StickBox(parcel, width, height, flags);
}
/*
* TTKInitPadding --
* Common factor of Ttk_GetPaddingFromObj and Ttk_GetBorderFromObj.
* Initializes Ttk_Padding record, supplying default values
* for missing entries.
*/
static void TTKInitPadding(int padc, int pixels[4], Ttk_Padding *pad)
{
switch (padc)
{
case 1: pixels[1] = pixels[0]; /*FALLTHRU*/
case 2: pixels[2] = pixels[0]; /*FALLTHRU*/
case 3: pixels[3] = pixels[1]; /*FALLTHRU*/
}
pad->left = (short)pixels[0];
pad->top = (short)pixels[1];
pad->right = (short)pixels[2];
pad->bottom = (short)pixels[3];
}
/*
* 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;
}
/* Ttk_GetBorderFromObj --
* Same as Ttk_GetPaddingFromObj, except padding is a list of integers
* instead of Tk_Pixel specifications. Does not require a Tk_Window
* parameter.
*
*/
int Ttk_GetBorderFromObj(Tcl_Interp *interp, 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 border spec", NULL);
}
goto error;
}
for (i=0; i < padc; ++i) {
if (Tcl_GetIntFromObj(interp, 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;
}
/*
* Ttk_MakePadding --
* Return an initialized Ttk_Padding structure.
*/
Ttk_Padding Ttk_MakePadding(short left, short top, short right, short bottom)
{
Ttk_Padding pad;
pad.left = left;
pad.top = top;
pad.right = right;
pad.bottom = bottom;
return pad;
}
/*
* Ttk_UniformPadding --
* Returns a uniform Ttk_Padding structure, with the same
* border width on all sides.
*/
Ttk_Padding Ttk_UniformPadding(short borderWidth)
{
Ttk_Padding pad;
pad.left = pad.top = pad.right = pad.bottom = borderWidth;
return pad;
}
/*
* Ttk_AddPadding --
* Combine two padding records.
*/
Ttk_Padding Ttk_AddPadding(Ttk_Padding p1, Ttk_Padding p2)
{
p1.left += p2.left;
p1.top += p2.top;
p1.right += p2.right;
p1.bottom += p2.bottom;
return p1;
}
/* Ttk_RelievePadding --
* Add an extra n pixels of padding according to specified relief.
* This may be used in element geometry procedures to simulate
* a "pressed-in" look for pushbuttons.
*/
Ttk_Padding Ttk_RelievePadding(Ttk_Padding padding, int relief, int n)
{
switch (relief)
{
case TK_RELIEF_RAISED:
padding.right += n;
padding.bottom += n;
break;
case TK_RELIEF_SUNKEN: /* shift */
padding.left += n;
padding.top += n;
break;
default:
{
int h1 = n/2, h2 = h1 + n % 2;
padding.left += h1;
padding.top += h1;
padding.right += h2;
padding.bottom += h2;
break;
}
}
return padding;
}
/*
* Ttk_GetStickyFromObj --
* Returns a stickiness specification from the specified Tcl_Obj*,
* consisting of any combination of n, s, e, and w.
*
* Returns: TCL_OK if objPtr holds a valid stickiness specification,
* otherwise TCL_ERROR. interp is used for error reporting if non-NULL.
*
*/
int Ttk_GetStickyFromObj(
Tcl_Interp *interp, Tcl_Obj *objPtr, Ttk_Sticky *result)
{
const char *string = Tcl_GetString(objPtr);
Ttk_Sticky sticky = 0;
char c;
while ((c = *string++) != '\0') {
switch (c) {
case 'w': case 'W': sticky |= TTK_STICK_W; break;
case 'e': case 'E': sticky |= TTK_STICK_E; break;
case 'n': case 'N': sticky |= TTK_STICK_N; break;
case 's': case 'S': sticky |= TTK_STICK_S; break;
default:
if (interp) {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp,
"Bad -sticky specification ",
Tcl_GetString(objPtr),
NULL);
}
return TCL_ERROR;
}
}
*result = sticky;
return TCL_OK;
}
/* Ttk_NewStickyObj --
* Construct a new Tcl_Obj * containing a stickiness specification.
*/
Tcl_Obj *Ttk_NewStickyObj(Ttk_Sticky sticky)
{
char buf[5];
char *p = buf;
if (sticky & TTK_STICK_N) *p++ = 'n';
if (sticky & TTK_STICK_S) *p++ = 's';
if (sticky & TTK_STICK_W) *p++ = 'w';
if (sticky & TTK_STICK_E) *p++ = 'e';
*p = '\0';
return Tcl_NewStringObj(buf, p - buf);
}
/*------------------------------------------------------------------------
* +++ Layout nodes.
*/
struct Ttk_LayoutNode_
{
unsigned flags; /* Packing and sticky flags */
Ttk_ElementImpl element; /* Element implementation */
Ttk_State state; /* Current state */
Ttk_Box parcel; /* allocated parcel */
Ttk_LayoutNode *next, *child;
};
static Ttk_LayoutNode *Ttk_NewLayoutNode(unsigned flags, Ttk_ElementImpl element)
{
Ttk_LayoutNode *node = (Ttk_LayoutNode*)ckalloc(sizeof(Ttk_LayoutNode));
node->flags = flags;
node->element = element;
node->state = 0u;
node->next = node->child = 0;
/* parcel uninitialized */
return node;
}
static void Ttk_FreeLayoutNode(Ttk_LayoutNode *node)
{
while (node) {
Ttk_LayoutNode *next = node->next;
Ttk_FreeLayoutNode(node->child);
ckfree((ClientData)node);
node = next;
}
}
/*------------------------------------------------------------------------
* +++ Layout templates.
*/
struct Ttk_TemplateNode_ {
char *name;
unsigned flags;
struct Ttk_TemplateNode_ *next, *child;
};
static Ttk_TemplateNode *Ttk_NewTemplateNode(const char *name, unsigned flags)
{
Ttk_TemplateNode *op = (Ttk_TemplateNode*)ckalloc(sizeof(*op));
op->name = ckalloc(strlen(name) + 1); strcpy(op->name, name);
op->flags = flags;
op->next = op->child = 0;
return op;
}
void Ttk_FreeLayoutTemplate(Ttk_LayoutTemplate op)
{
while (op) {
Ttk_LayoutTemplate next = op->next;
Ttk_FreeLayoutTemplate(op->child);
ckfree(op->name);
ckfree((ClientData)op);
op = next;
}
}
/* InstantiateLayout --
* Create a layout tree from a template.
*/
static Ttk_LayoutNode *
Ttk_InstantiateLayout(Ttk_Theme theme, Ttk_TemplateNode *op)
{
Ttk_ElementImpl elementImpl = Ttk_GetElement(theme, op->name);
Ttk_LayoutNode *node = Ttk_NewLayoutNode(op->flags, elementImpl);
if (op->next) {
node->next = Ttk_InstantiateLayout(theme,op->next);
}
if (op->child) {
node->child = Ttk_InstantiateLayout(theme,op->child);
}
return node;
}
/*
* Ttk_ParseLayoutTemplate --
* Convert a Tcl list into a layout template.
*
* Syntax:
* layoutSpec ::= { elementName ?-option value ...? }+
*/
/* NB: This must match bit definitions TTK_PACK_LEFT etc. */
static const char *packSideStrings[] =
{ "left", "right", "top", "bottom", NULL };
Ttk_LayoutTemplate Ttk_ParseLayoutTemplate(Tcl_Interp *interp, Tcl_Obj *objPtr)
{
enum { OP_SIDE, OP_STICKY, OP_EXPAND, OP_BORDER, OP_UNIT, OP_CHILDREN };
static const char *optStrings[] = {
"-side", "-sticky", "-expand", "-border", "-unit", "-children", 0 };
int i = 0, objc;
Tcl_Obj **objv;
Ttk_TemplateNode *head = 0, *tail = 0;
if (Tcl_ListObjGetElements(interp, objPtr, &objc, &objv) != TCL_OK)
return 0;
while (i < objc) {
char *elementName = Tcl_GetString(objv[i]);
unsigned flags = 0x0, sticky = TTK_FILL_BOTH;
Tcl_Obj *childSpec = 0;
/*
* Parse options:
*/
++i;
while (i < objc) {
const char *optName = Tcl_GetString(objv[i]);
int option, value;
if (optName[0] != '-')
break;
if (Tcl_GetIndexFromObj(
interp, objv[i], optStrings, "option", 0, &option)
!= TCL_OK)
{
goto error;
}
if (++i >= objc) {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp,
"Missing value for option ",Tcl_GetString(objv[i-1]),
NULL);
goto error;
}
switch (option) {
case OP_SIDE: /* <<NOTE-PACKSIDE>> */
if (Tcl_GetIndexFromObj(interp, objv[i], packSideStrings,
"side", 0, &value) != TCL_OK)
{
goto error;
}
flags |= (TTK_PACK_LEFT << value);
break;
case OP_STICKY:
if (Ttk_GetStickyFromObj(interp,objv[i],&sticky) != TCL_OK)
goto error;
break;
case OP_EXPAND:
if (Tcl_GetBooleanFromObj(interp,objv[i],&value) != TCL_OK)
goto error;
if (value)
flags |= TTK_EXPAND;
break;
case OP_BORDER:
if (Tcl_GetBooleanFromObj(interp,objv[i],&value) != TCL_OK)
goto error;
if (value)
flags |= TTK_BORDER;
break;
case OP_UNIT:
if (Tcl_GetBooleanFromObj(interp,objv[i],&value) != TCL_OK)
goto error;
if (value)
flags |= TTK_UNIT;
break;
case OP_CHILDREN:
childSpec = objv[i];
break;
}
++i;
}
/*
* Build new node:
*/
if (tail) {
tail->next = Ttk_NewTemplateNode(elementName, flags | sticky);
tail = tail->next;
} else {
head = tail = Ttk_NewTemplateNode(elementName, flags | sticky);
}
if (childSpec) {
tail->child = Ttk_ParseLayoutTemplate(interp, childSpec);
if (!tail->child) {
goto error;
}
}
}
return head;
error:
Ttk_FreeLayoutTemplate(head);
return 0;
}
/* Ttk_BuildLayoutTemplate --
* Build a layout template tree from a statically defined
* Ttk_LayoutSpec array.
*/
Ttk_LayoutTemplate Ttk_BuildLayoutTemplate(Ttk_LayoutSpec spec)
{
Ttk_TemplateNode *first = 0, *last = 0;
for ( ; !(spec->opcode & TTK_LAYOUT_END) ; ++spec) {
if (spec->elementName) {
Ttk_TemplateNode *node =
Ttk_NewTemplateNode(spec->elementName, spec->opcode);
if (last) {
last->next = node;
} else {
first = node;
}
last = node;
}
if (spec->opcode & TTK_CHILDREN) {
int depth = 1;
last->child = Ttk_BuildLayoutTemplate(spec+1);
/* Skip to end of group:
*/
while (depth) {
++spec;
if (spec->opcode & TTK_CHILDREN) {
++depth;
}
if (spec->opcode & TTK_LAYOUT_END) {
--depth;
}
}
}
} /* for */
return first;
}
Tcl_Obj *Ttk_UnparseLayoutTemplate(Ttk_TemplateNode *node)
{
Tcl_Obj *result = Tcl_NewListObj(0,0);
# define APPENDOBJ(obj) Tcl_ListObjAppendElement(NULL, result, obj)
# define APPENDSTR(str) APPENDOBJ(Tcl_NewStringObj(str,-1))
while (node) {
unsigned flags = node->flags;
APPENDSTR(node->name);
/* Back-compute -side. <<NOTE-PACKSIDE>>
* @@@ NOTES: Ick.
*/
if (flags & TTK_EXPAND) {
APPENDSTR("-expand");
APPENDSTR("1");
} else {
if (flags & _TTK_MASK_PACK) {
int side = 0;
unsigned sideFlags = flags & _TTK_MASK_PACK;
while ((sideFlags & TTK_PACK_LEFT) == 0) {
++side;
sideFlags >>= 1;
}
APPENDSTR("-side");
APPENDSTR(packSideStrings[side]);
}
}
/* In Ttk_ParseLayoutTemplate, default -sticky is "nsew",
* so always include this even if no sticky bits are set.
*/
APPENDSTR("-sticky");
APPENDOBJ(Ttk_NewStickyObj(flags & _TTK_MASK_STICK));
/* @@@ Check again: are these necessary? */
if (flags & TTK_BORDER) { APPENDSTR("-border"); APPENDSTR("1"); }
if (flags & TTK_UNIT) { APPENDSTR("-unit"); APPENDSTR("1"); }
if (node->child) {
APPENDSTR("-children");
APPENDOBJ(Ttk_UnparseLayoutTemplate(node->child));
}
node = node->next;
}
# undef APPENDOBJ
# undef APPENDSTR
return result;
}
/*------------------------------------------------------------------------
* +++ Layouts.
*/
struct Ttk_Layout_
{
Ttk_Style style;
void *recordPtr;
Tk_OptionTable optionTable;
Tk_Window tkwin;
Ttk_LayoutNode *root;
};
static Ttk_Layout TTKNewLayout(
Ttk_Style style,
void *recordPtr,Tk_OptionTable optionTable, Tk_Window tkwin,
Ttk_LayoutNode *root)
{
Ttk_Layout layout = (Ttk_Layout)ckalloc(sizeof(*layout));
layout->style = style;
layout->recordPtr = recordPtr;
layout->optionTable = optionTable;
layout->tkwin = tkwin;
layout->root = root;
return layout;
}
void Ttk_FreeLayout(Ttk_Layout layout)
{
Ttk_FreeLayoutNode(layout->root);
ckfree((ClientData)layout);
}
/*
* Ttk_CreateLayout --
* Create a layout from the specified theme and style name.
* Returns: New layout, 0 on error.
* Leaves an error message in interp's result if there is an error.
*/
Ttk_Layout Ttk_CreateLayout(
Tcl_Interp *interp, /* where to leave error messages */
Ttk_Theme themePtr,
const char *styleName,
void *recordPtr,
Tk_OptionTable optionTable,
Tk_Window tkwin)
{
Ttk_Style style = Ttk_GetStyle(themePtr, styleName);
Ttk_LayoutTemplate layoutTemplate =
Ttk_FindLayoutTemplate(themePtr,styleName);
Ttk_ElementImpl bgelement = Ttk_GetElement(themePtr, "background");
Ttk_LayoutNode *bgnode;
if (!layoutTemplate) {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "Layout ", styleName, " not found", NULL);
return 0;
}
bgnode = Ttk_NewLayoutNode(TTK_FILL_BOTH, bgelement);
bgnode->next = Ttk_InstantiateLayout(themePtr, layoutTemplate);
return TTKNewLayout(style, recordPtr, optionTable, tkwin, bgnode);
}
/* Ttk_CreateSublayout --
* Creates a new sublayout.
*
* Sublayouts are used to draw subparts of a compound widget.
* They use the same Tk_Window, but a different option table
* and data record.
*/
Ttk_Layout
Ttk_CreateSublayout(
Tcl_Interp *interp,
Ttk_Theme themePtr,
Ttk_Layout parentLayout,
const char *baseName,
Tk_OptionTable optionTable)
{
Tcl_DString buf;
const char *styleName;
Ttk_Style style;
Ttk_LayoutTemplate layoutTemplate;
Tcl_DStringInit(&buf);
Tcl_DStringAppend(&buf, Ttk_StyleName(parentLayout->style), -1);
Tcl_DStringAppend(&buf, baseName, -1);
styleName = Tcl_DStringValue(&buf);
style = Ttk_GetStyle(themePtr, styleName);
layoutTemplate = Ttk_FindLayoutTemplate(themePtr, styleName);
if (!layoutTemplate) {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "Layout ", styleName, " not found", NULL);
return 0;
}
Tcl_DStringFree(&buf);
return TTKNewLayout(
style, 0, optionTable, parentLayout->tkwin,
Ttk_InstantiateLayout(themePtr, layoutTemplate));
}
/* Ttk_RebindSublayout --
* Bind sublayout to new data source.
*/
void Ttk_RebindSublayout(Ttk_Layout layout, void *recordPtr)
{
layout->recordPtr = recordPtr;
}
/*
* Ttk_QueryOption --
* Look up an option from a layout's associated option.
*/
Tcl_Obj *Ttk_QueryOption(
Ttk_Layout layout, const char *optionName, Ttk_State state)
{
return Ttk_QueryStyle(
layout->style,layout->recordPtr,layout->optionTable,optionName,state);
}
/*------------------------------------------------------------------------
* +++ Size computation.
*/
static void Ttk_NodeListSize(
Ttk_Layout layout, Ttk_LayoutNode *node,
Ttk_State state, int *widthPtr, int *heightPtr); /* Forward */
static void Ttk_NodeSize(
Ttk_Layout layout, Ttk_LayoutNode *node, Ttk_State state,
int *widthPtr, int *heightPtr, Ttk_Padding *paddingPtr)
{
int elementWidth, elementHeight, subWidth, subHeight;
Ttk_Padding elementPadding;
Ttk_ElementSize(node->element,
layout->style, layout->recordPtr,layout->optionTable, layout->tkwin,
state|node->state,
&elementWidth, &elementHeight, &elementPadding);
Ttk_NodeListSize(layout,node->child,state,&subWidth,&subHeight);
subWidth += Ttk_PaddingWidth(elementPadding);
subHeight += Ttk_PaddingHeight(elementPadding);
*widthPtr = MAX(elementWidth, subWidth);
*heightPtr = MAX(elementHeight, subHeight);
*paddingPtr = elementPadding;
}
static void Ttk_NodeListSize(
Ttk_Layout layout, Ttk_LayoutNode *node,
Ttk_State state, int *widthPtr, int *heightPtr)
{
if (!node) {
*widthPtr = *heightPtr = 0;
} else {
int width, height, restWidth, restHeight;
Ttk_Padding unused;
Ttk_NodeSize(layout, node, state, &width, &height, &unused);
Ttk_NodeListSize(layout, node->next, state, &restWidth, &restHeight);
if (node->flags & (TTK_PACK_LEFT|TTK_PACK_RIGHT)) {
*widthPtr = width + restWidth;
} else {
*widthPtr = MAX(width, restWidth);
}
if (node->flags & (TTK_PACK_TOP|TTK_PACK_BOTTOM)) {
*heightPtr = height + restHeight;
} else {
*heightPtr = MAX(height, restHeight);
}
}
}
/*
* Ttk_LayoutNodeInternalPadding --
* Returns the internal padding of a layout node.
*/
Ttk_Padding Ttk_LayoutNodeInternalPadding(
Ttk_Layout layout, Ttk_LayoutNode *node)
{
int unused;
Ttk_Padding padding;
Ttk_ElementSize(node->element,
layout->style, layout->recordPtr, layout->optionTable, layout->tkwin,
0/*state*/, &unused, &unused, &padding);
return padding;
}
/*
* Ttk_LayoutNodeInternalParcel --
* Returns the inner area of a specified layout node,
* based on current parcel and element's internal padding.
*/
Ttk_Box Ttk_LayoutNodeInternalParcel(Ttk_Layout layout, Ttk_LayoutNode *node)
{
Ttk_Padding padding = Ttk_LayoutNodeInternalPadding(layout, node);
return Ttk_PadBox(node->parcel, padding);
}
/* Ttk_LayoutSize --
* Compute requested size of a layout.
*/
void Ttk_LayoutSize(
Ttk_Layout layout, Ttk_State state, int *widthPtr, int *heightPtr)
{
Ttk_NodeListSize(layout, layout->root, state, widthPtr, heightPtr);
}
void Ttk_LayoutNodeReqSize( /* @@@ Rename this */
Ttk_Layout layout, Ttk_LayoutNode *node, int *widthPtr, int *heightPtr)
{
Ttk_Padding unused;
Ttk_NodeSize(layout, node, 0/*state*/, widthPtr, heightPtr, &unused);
}
/*------------------------------------------------------------------------
* +++ Layout placement.
*/
/* Ttk_PlaceNodeList --
* Compute parcel for each node in a layout tree
* according to position specification and overall size.
*/
static void Ttk_PlaceNodeList(
Ttk_Layout layout, Ttk_LayoutNode *node, Ttk_State state, Ttk_Box cavity)
{
for (; node; node = node->next)
{
int width, height;
Ttk_Padding padding;
/* Compute node size: (@@@ cache this instead?)
*/
Ttk_NodeSize(layout, node, state, &width, &height, &padding);
/* Compute parcel:
*/
node->parcel = Ttk_PositionBox(&cavity, width, height, node->flags);
/* Place child nodes:
*/
if (node->child) {
Ttk_Box childBox = Ttk_PadBox(node->parcel, padding);
Ttk_PlaceNodeList(layout,node->child, state, childBox);
}
}
}
void Ttk_PlaceLayout(Ttk_Layout layout, Ttk_State state, Ttk_Box b)
{
Ttk_PlaceNodeList(layout, layout->root, state, b);
}
/*------------------------------------------------------------------------
* +++ Layout drawing.
*/
/*
* Ttk_DrawLayout --
* Draw a layout tree.
*/
static void Ttk_DrawNodeList(
Ttk_Layout layout, Ttk_State state, Ttk_LayoutNode *node, Drawable d)
{
for (; node; node = node->next)
{
int border = node->flags & TTK_BORDER;
int substate = state;
if (node->flags & TTK_UNIT)
substate |= node->state;
if (node->child && border)
Ttk_DrawNodeList(layout, substate, node->child, d);
Ttk_DrawElement(
node->element,
layout->style,layout->recordPtr,layout->optionTable,layout->tkwin,
d, node->parcel, state | node->state);
if (node->child && !border)
Ttk_DrawNodeList(layout, substate, node->child, d);
}
}
void Ttk_DrawLayout(Ttk_Layout layout, Ttk_State state, Drawable d)
{
Ttk_DrawNodeList(layout, state, layout->root, d);
}
/*------------------------------------------------------------------------
* +++ Inquiry and modification.
*/
/*
* Ttk_LayoutIdentify --
* Find the layout node at the specified x,y coordinate.
*/
static Ttk_LayoutNode *
Ttk_LayoutNodeIdentify(Ttk_LayoutNode *node, int x, int y)
{
Ttk_LayoutNode *closest = NULL;
for (; node; node = node->next) {
if (Ttk_BoxContains(node->parcel, x, y)) {
closest = node;
if (node->child && !(node->flags & TTK_UNIT)) {
Ttk_LayoutNode *childNode =
Ttk_LayoutNodeIdentify(node->child, x,y);
if (childNode) {
closest = childNode;
}
}
}
}
return closest;
}
Ttk_LayoutNode *Ttk_LayoutIdentify(Ttk_Layout layout, int x, int y)
{
return Ttk_LayoutNodeIdentify(layout->root, x, y);
}
/*
* tail --
* Return the last component of an element name, e.g.,
* "Scrollbar.thumb" => "thumb"
*/
static const char *tail(const char *elementName)
{
const char *dot;
while ((dot=strchr(elementName,'.')) != NULL)
elementName = dot + 1;
return elementName;
}
/*
* Ttk_LayoutFindNode --
* Look up a layout node by name.
*/
static Ttk_LayoutNode *
Ttk_LayoutNodeFind(Ttk_LayoutNode *node, const char *nodeName)
{
for (; node ; node = node->next) {
if (!strcmp(tail(Ttk_LayoutNodeName(node)), nodeName))
return node;
if (node->child) {
Ttk_LayoutNode *childNode =
Ttk_LayoutNodeFind(node->child, nodeName);
if (childNode)
return childNode;
}
}
return 0;
}
Ttk_LayoutNode *Ttk_LayoutFindNode(Ttk_Layout layout, const char *nodeName)
{
return Ttk_LayoutNodeFind(layout->root, nodeName);
}
const char *Ttk_LayoutNodeName(Ttk_LayoutNode *node)
{
return Ttk_ElementName(node->element);
}
Ttk_Box Ttk_LayoutNodeParcel(Ttk_LayoutNode *node)
{
return node->parcel;
}
void Ttk_PlaceLayoutNode(Ttk_Layout layout, Ttk_LayoutNode *node, Ttk_Box b)
{
node->parcel = b;
if (node->child) {
Ttk_PlaceNodeList(layout, node->child, 0,
Ttk_PadBox(b, Ttk_LayoutNodeInternalPadding(layout, node)));
}
}
void Ttk_ChangeElementState(Ttk_LayoutNode *node,unsigned set,unsigned clr)
{
node->state = (node->state | set) & ~clr;
}
/*EOF*/