static void
RecomputePlacement(
ClientData clientData) /* Pointer to Master record. */
{
register Master *masterPtr = clientData;
register Slave *slavePtr;
int x, y, width, height, tmp;
int masterWidth, masterHeight, masterX, masterY;
double x1, y1, x2, y2;
int abort; /* May get set to non-zero to abort this
* placement operation. */
masterPtr->flags &= ~PARENT_RECONFIG_PENDING;
/*
* Abort any nested call to RecomputePlacement for this window, since
* we'll do everything necessary here, and set up so this call can be
* aborted if necessary.
*/
if (masterPtr->abortPtr != NULL) {
*masterPtr->abortPtr = 1;
}
masterPtr->abortPtr = &abort;
abort = 0;
Tcl_Preserve(masterPtr);
/*
* Iterate over all the slaves for the master. Each slave's geometry can
* be computed independently of the other slaves. Changes to the window's
* structure could cause almost anything to happen, including deleting the
* parent or child. If this happens, we'll be told to abort.
*/
for (slavePtr = masterPtr->slavePtr; slavePtr != NULL && !abort;
slavePtr = slavePtr->nextPtr) {
/*
* Step 1: compute size and borderwidth of master, taking into account
* desired border mode.
*/
masterX = masterY = 0;
masterWidth = Tk_Width(masterPtr->tkwin);
masterHeight = Tk_Height(masterPtr->tkwin);
if (slavePtr->borderMode == BM_INSIDE) {
masterX = Tk_InternalBorderLeft(masterPtr->tkwin);
masterY = Tk_InternalBorderTop(masterPtr->tkwin);
masterWidth -= masterX + Tk_InternalBorderRight(masterPtr->tkwin);
masterHeight -= masterY +
Tk_InternalBorderBottom(masterPtr->tkwin);
} else if (slavePtr->borderMode == BM_OUTSIDE) {
masterX = masterY = -Tk_Changes(masterPtr->tkwin)->border_width;
masterWidth -= 2 * masterX;
masterHeight -= 2 * masterY;
}
/*
* Step 2: compute size of slave (outside dimensions including border)
* and location of anchor point within master.
*/
x1 = slavePtr->x + masterX + (slavePtr->relX*masterWidth);
x = (int) (x1 + ((x1 > 0) ? 0.5 : -0.5));
y1 = slavePtr->y + masterY + (slavePtr->relY*masterHeight);
y = (int) (y1 + ((y1 > 0) ? 0.5 : -0.5));
if (slavePtr->flags & (CHILD_WIDTH|CHILD_REL_WIDTH)) {
width = 0;
if (slavePtr->flags & CHILD_WIDTH) {
width += slavePtr->width;
}
if (slavePtr->flags & CHILD_REL_WIDTH) {
/*
* The code below is a bit tricky. In order to round correctly
* when both relX and relWidth are specified, compute the
* location of the right edge and round that, then compute
* width. If we compute the width and round it, rounding
* errors in relX and relWidth accumulate.
*/
x2 = x1 + (slavePtr->relWidth*masterWidth);
tmp = (int) (x2 + ((x2 > 0) ? 0.5 : -0.5));
width += tmp - x;
}
} else {
width = Tk_ReqWidth(slavePtr->tkwin)
+ 2*Tk_Changes(slavePtr->tkwin)->border_width;
}
if (slavePtr->flags & (CHILD_HEIGHT|CHILD_REL_HEIGHT)) {
height = 0;
if (slavePtr->flags & CHILD_HEIGHT) {
height += slavePtr->height;
}
if (slavePtr->flags & CHILD_REL_HEIGHT) {
/*
* See note above for rounding errors in width computation.
*/
y2 = y1 + (slavePtr->relHeight*masterHeight);
tmp = (int) (y2 + ((y2 > 0) ? 0.5 : -0.5));
height += tmp - y;
}
} else {
height = Tk_ReqHeight(slavePtr->tkwin)
+ 2*Tk_Changes(slavePtr->tkwin)->border_width;
}
/*
* Step 3: adjust the x and y positions so that the desired anchor
* point on the slave appears at that position. Also adjust for the
* border mode and master's border.
*/
switch (slavePtr->anchor) {
case TK_ANCHOR_N:
x -= width/2;
break;
case TK_ANCHOR_NE:
x -= width;
break;
case TK_ANCHOR_E:
x -= width;
y -= height/2;
break;
case TK_ANCHOR_SE:
x -= width;
y -= height;
break;
case TK_ANCHOR_S:
x -= width/2;
y -= height;
break;
case TK_ANCHOR_SW:
y -= height;
break;
case TK_ANCHOR_W:
y -= height/2;
break;
case TK_ANCHOR_NW:
break;
case TK_ANCHOR_CENTER:
x -= width/2;
y -= height/2;
break;
}
/*
* Step 4: adjust width and height again to reflect inside dimensions
* of window rather than outside. Also make sure that the width and
* height aren't zero.
*/
width -= 2*Tk_Changes(slavePtr->tkwin)->border_width;
height -= 2*Tk_Changes(slavePtr->tkwin)->border_width;
if (width <= 0) {
width = 1;
}
if (height <= 0) {
height = 1;
}
/*
* Step 5: reconfigure the window and map it if needed. If the slave
* is a child of the master, we do this ourselves. If the slave isn't
* a child of the master, let Tk_MaintainGeometry do the work (it will
* re-adjust things as relevant windows map, unmap, and move).
*/
if (masterPtr->tkwin == Tk_Parent(slavePtr->tkwin)) {
if ((x != Tk_X(slavePtr->tkwin))
|| (y != Tk_Y(slavePtr->tkwin))
|| (width != Tk_Width(slavePtr->tkwin))
|| (height != Tk_Height(slavePtr->tkwin))) {
Tk_MoveResizeWindow(slavePtr->tkwin, x, y, width, height);
}
if (abort) {
break;
}
/*
* Don't map the slave unless the master is mapped: the slave will
* get mapped later, when the master is mapped.
*/
if (Tk_IsMapped(masterPtr->tkwin)) {
Tk_MapWindow(slavePtr->tkwin);
}
} else {
if ((width <= 0) || (height <= 0)) {
Tk_UnmaintainGeometry(slavePtr->tkwin, masterPtr->tkwin);
Tk_UnmapWindow(slavePtr->tkwin);
} else {
Tk_MaintainGeometry(slavePtr->tkwin, masterPtr->tkwin,
x, y, width, height);
}
}
}
masterPtr->abortPtr = NULL;
Tcl_Release(masterPtr);
}
void
TkComputeAnchor(
Tk_Anchor anchor, /* Desired anchor. */
Tk_Window tkwin, /* Anchored with respect to this window. */
int padX, int padY, /* Use this extra padding inside window, in
* addition to the internal border. */
int innerWidth, int innerHeight,
/* Size of rectangle to anchor in window. */
int *xPtr, int *yPtr) /* Returns upper-left corner of anchored
* rectangle. */
{
/*
* Handle the horizontal parts.
*/
switch (anchor) {
case TK_ANCHOR_NW:
case TK_ANCHOR_W:
case TK_ANCHOR_SW:
*xPtr = Tk_InternalBorderLeft(tkwin) + padX;
break;
case TK_ANCHOR_N:
case TK_ANCHOR_CENTER:
case TK_ANCHOR_S:
*xPtr = (Tk_Width(tkwin) - innerWidth - Tk_InternalBorderLeft(tkwin) -
Tk_InternalBorderRight(tkwin)) / 2 +
Tk_InternalBorderLeft(tkwin);
break;
default:
*xPtr = Tk_Width(tkwin) - Tk_InternalBorderRight(tkwin) - padX
- innerWidth;
break;
}
/*
* Handle the vertical parts.
*/
switch (anchor) {
case TK_ANCHOR_NW:
case TK_ANCHOR_N:
case TK_ANCHOR_NE:
*yPtr = Tk_InternalBorderTop(tkwin) + padY;
break;
case TK_ANCHOR_W:
case TK_ANCHOR_CENTER:
case TK_ANCHOR_E:
*yPtr = (Tk_Height(tkwin) - innerHeight- Tk_InternalBorderTop(tkwin) -
Tk_InternalBorderBottom(tkwin)) / 2 +
Tk_InternalBorderTop(tkwin);
break;
default:
*yPtr = Tk_Height(tkwin) - Tk_InternalBorderBottom(tkwin) - padY
- innerHeight;
break;
}
}