summaryrefslogtreecommitdiffstats
path: root/generic
diff options
context:
space:
mode:
Diffstat (limited to 'generic')
-rw-r--r--generic/tkGrid.c624
1 files changed, 315 insertions, 309 deletions
diff --git a/generic/tkGrid.c b/generic/tkGrid.c
index 8f8c33a..6e43869 100644
--- a/generic/tkGrid.c
+++ b/generic/tkGrid.c
@@ -8,7 +8,7 @@
* See the file "license.terms" for information on usage and redistribution
* of this file, and for a DISCLAIMER OF ALL WARRANTIES.
*
- * RCS: @(#) $Id: tkGrid.c,v 1.36 2005/04/03 15:21:48 pspjuth Exp $
+ * RCS: @(#) $Id: tkGrid.c,v 1.37 2005/04/04 08:53:00 dkf Exp $
*/
#include "tkInt.h"
@@ -21,10 +21,6 @@
# undef MAX
#endif
#define MAX(x,y) ((x) > (y) ? (x) : (y))
-#ifdef MIN
-# undef MIN
-#endif
-#define MIN(x,y) ((x) > (y) ? (y) : (x))
#define COLUMN (1) /* working on column offsets */
#define ROW (2) /* working on row offsets */
@@ -77,28 +73,28 @@
*/
typedef struct SlotInfo {
- int minSize; /* The minimum size of this slot (in pixels).
+ int minSize; /* The minimum size of this slot (in pixels).
* It is set via the rowconfigure or
* columnconfigure commands. */
- int weight; /* The resize weight of this slot. (0) means
+ int weight; /* The resize weight of this slot. (0) means
* this slot doesn't resize. Extra space in
* the layout is given distributed among slots
* inproportion to their weights. */
- int pad; /* Extra padding, in pixels, required for
+ int pad; /* Extra padding, in pixels, required for
* this slot. This amount is "added" to the
* largest slave in the slot. */
- Tk_Uid uniform; /* Value of -uniform option. It is used to
+ Tk_Uid uniform; /* Value of -uniform option. It is used to
* group slots that should have the same
* size. */
- int offset; /* This is a cached value used for
+ int offset; /* This is a cached value used for
* introspection. It is the pixel
* offset of the right or bottom edge
* of this slot from the beginning of the
* layout. */
- int temp; /* This is a temporary value used for
- * calculating adjusted weights when
- * shrinking the layout below its
- * nominal size. */
+ int temp; /* This is a temporary value used for
+ * calculating adjusted weights when
+ * shrinking the layout below its
+ * nominal size. */
} SlotInfo;
/*
@@ -118,7 +114,7 @@ typedef struct GridLayout {
* constrants, such as size or padding. */
int pad; /* Padding needed for this slot */
int weight; /* Slot weight, controls resizing. */
- Tk_Uid uniform; /* Value of -uniform option. It is used to
+ Tk_Uid uniform; /* Value of -uniform option. It is used to
* group slots that should have the same
* size. */
int minOffset; /* The minimum offset, in pixels, from
@@ -310,7 +306,7 @@ static Tk_GeomMgr gridMgrType = {
};
/*
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
*
* Tk_GridCmd --
*
@@ -323,7 +319,7 @@ static Tk_GeomMgr gridMgrType = {
* Side effects:
* See the user documentation.
*
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
*/
int
@@ -338,14 +334,15 @@ Tk_GridObjCmd(clientData, interp, objc, objv)
static CONST char *optionStrings[] = {
"anchor", "bbox", "columnconfigure", "configure",
"forget", "info", "location", "propagate", "remove",
- "rowconfigure", "size", "slaves", (char *) NULL };
+ "rowconfigure", "size", "slaves", (char *) NULL
+ };
enum options {
GRID_ANCHOR, GRID_BBOX, GRID_COLUMNCONFIGURE, GRID_CONFIGURE,
GRID_FORGET, GRID_INFO, GRID_LOCATION, GRID_PROPAGATE, GRID_REMOVE,
- GRID_ROWCONFIGURE, GRID_SIZE, GRID_SLAVES };
+ GRID_ROWCONFIGURE, GRID_SIZE, GRID_SLAVES
+ };
int index;
-
if (objc >= 2) {
char *argv1 = Tcl_GetString(objv[1]);
if ((argv1[0] == '.') || (argv1[0] == REL_SKIP) ||
@@ -364,24 +361,23 @@ Tk_GridObjCmd(clientData, interp, objc, objv)
}
switch ((enum options) index) {
- case GRID_ANCHOR:
- return GridAnchorCommand(tkwin, interp, objc, objv);
- case GRID_BBOX:
+ case GRID_ANCHOR:
+ return GridAnchorCommand(tkwin, interp, objc, objv);
+ case GRID_BBOX:
return GridBboxCommand(tkwin, interp, objc, objv);
- case GRID_CONFIGURE:
+ case GRID_CONFIGURE:
return ConfigureSlaves(interp, tkwin, objc-2, objv+2);
- case GRID_FORGET:
- case GRID_REMOVE:
+ case GRID_FORGET: case GRID_REMOVE:
return GridForgetRemoveCommand(tkwin, interp, objc, objv);
- case GRID_INFO:
+ case GRID_INFO:
return GridInfoCommand(tkwin, interp, objc, objv);
- case GRID_LOCATION:
+ case GRID_LOCATION:
return GridLocationCommand(tkwin, interp, objc, objv);
- case GRID_PROPAGATE:
+ case GRID_PROPAGATE:
return GridPropagateCommand(tkwin, interp, objc, objv);
- case GRID_SIZE:
+ case GRID_SIZE:
return GridSizeCommand(tkwin, interp, objc, objv);
- case GRID_SLAVES:
+ case GRID_SLAVES:
return GridSlavesCommand(tkwin, interp, objc, objv);
/*
@@ -393,8 +389,8 @@ Tk_GridObjCmd(clientData, interp, objc, objv)
* grid rowconfigure <master> <index> -option value -option value.
*/
- case GRID_COLUMNCONFIGURE:
- case GRID_ROWCONFIGURE:
+ case GRID_COLUMNCONFIGURE:
+ case GRID_ROWCONFIGURE:
return GridRowColumnConfigureCommand(tkwin, interp, objc, objv);
}
@@ -443,10 +439,10 @@ GridAnchorCommand(tkwin, interp, objc, objv)
masterPtr = GetGrid(master);
if (objc == 3) {
- gridPtr = masterPtr->masterDataPtr;
- Tcl_SetResult(interp, (char *) Tk_NameOfAnchor(gridPtr == NULL ?
- GRID_DEFAULT_ANCHOR : gridPtr->anchor), TCL_VOLATILE);
- return TCL_OK;
+ gridPtr = masterPtr->masterDataPtr;
+ Tcl_SetResult(interp, (char *) Tk_NameOfAnchor(gridPtr == NULL ?
+ GRID_DEFAULT_ANCHOR : gridPtr->anchor), TCL_VOLATILE);
+ return TCL_OK;
}
InitMasterData(masterPtr);
@@ -549,18 +545,21 @@ GridBboxCommand(tkwin, interp, objc, objv)
return TCL_OK;
}
if (objc == 3) {
- row = column = 0;
+ row = 0;
+ column = 0;
row2 = endY;
column2 = endX;
}
if (column > column2) {
int temp = column;
- column = column2, column2 = temp;
+ column = column2;
+ column2 = temp;
}
if (row > row2) {
int temp = row;
- row = row2, row2 = temp;
+ row = row2;
+ row2 = temp;
}
if (column > 0 && column < endX) {
@@ -639,12 +638,16 @@ GridForgetRemoveCommand(tkwin, interp, objc, objv)
*/
if (c == 'f') {
- slavePtr->column = slavePtr->row = -1;
+ slavePtr->column = -1;
+ slavePtr->row = -1;
slavePtr->numCols = 1;
slavePtr->numRows = 1;
- slavePtr->padX = slavePtr->padY = 0;
- slavePtr->padLeft = slavePtr->padTop = 0;
- slavePtr->iPadX = slavePtr->iPadY = 0;
+ slavePtr->padX = 0;
+ slavePtr->padY = 0;
+ slavePtr->padLeft = 0;
+ slavePtr->padTop = 0;
+ slavePtr->iPadX = 0;
+ slavePtr->iPadY = 0;
slavePtr->doubleBw = 2*Tk_Changes(tkwin)->border_width;
if (slavePtr->flags & REQUESTED_RELAYOUT) {
Tcl_CancelIdleCall(ArrangeGrid, (ClientData) slavePtr);
@@ -784,7 +787,7 @@ GridLocationCommand(tkwin, interp, objc, objv)
while (masterPtr->flags & REQUESTED_RELAYOUT) {
Tcl_CancelIdleCall(ArrangeGrid, (ClientData) masterPtr);
- ArrangeGrid ((ClientData) masterPtr);
+ ArrangeGrid((ClientData) masterPtr);
}
SetGridSize(masterPtr);
endX = MAX(gridPtr->columnEnd, gridPtr->columnMax);
@@ -924,7 +927,8 @@ GridRowColumnConfigureCommand(tkwin, interp, objc, objv)
int i, j, first, last;
char *string;
static CONST char *optionStrings[] = {
- "-minsize", "-pad", "-uniform", "-weight", (char *) NULL };
+ "-minsize", "-pad", "-uniform", "-weight", (char *) NULL
+ };
enum options { ROWCOL_MINSIZE, ROWCOL_PAD, ROWCOL_UNIFORM, ROWCOL_WEIGHT };
int index;
@@ -944,7 +948,8 @@ GridRowColumnConfigureCommand(tkwin, interp, objc, objv)
string = Tcl_GetString(objv[1]);
masterPtr = GetGrid(master);
slotType = (*string == 'c') ? COLUMN : ROW;
- first = last = 0; /* lint */
+ first = 0; /* lint */
+ last = 0; /* lint */
if ((objc == 4) || (objc == 5)) {
if (lObjc != 1) {
@@ -1095,7 +1100,7 @@ GridRowColumnConfigureCommand(tkwin, interp, objc, objv)
}
if (index == ROWCOL_MINSIZE) {
if (Tk_GetPixelsFromObj(interp, master, objv[i+1],
- &size) != TCL_OK) {
+ &size) != TCL_OK) {
return TCL_ERROR;
} else {
slotPtr[slot].minSize = size;
@@ -1113,14 +1118,15 @@ GridRowColumnConfigureCommand(tkwin, interp, objc, objv)
slotPtr[slot].weight = wt;
}
} else if (index == ROWCOL_UNIFORM) {
- slotPtr[slot].uniform = Tk_GetUid(Tcl_GetString(objv[i+1]));
+ slotPtr[slot].uniform =
+ Tk_GetUid(Tcl_GetString(objv[i+1]));
if (slotPtr[slot].uniform != NULL &&
slotPtr[slot].uniform[0] == 0) {
slotPtr[slot].uniform = NULL;
}
} else if (index == ROWCOL_PAD) {
- if (Tk_GetPixelsFromObj(interp, master, objv[i+1], &size)
- != TCL_OK) {
+ if (Tk_GetPixelsFromObj(interp, master, objv[i+1],
+ &size) != TCL_OK) {
return TCL_ERROR;
} else if (size < 0) {
Tcl_AppendResult(interp, "invalid arg \"",
@@ -1147,8 +1153,7 @@ GridRowColumnConfigureCommand(tkwin, interp, objc, objv)
if (slotType == ROW) {
int last = masterPtr->masterDataPtr->rowMax - 1;
while ((last >= 0) && (slotPtr[last].weight == 0)
- && (slotPtr[last].pad == 0)
- && (slotPtr[last].minSize == 0)
+ && (slotPtr[last].pad == 0) && (slotPtr[last].minSize == 0)
&& (slotPtr[last].uniform == NULL)) {
last--;
}
@@ -1156,8 +1161,7 @@ GridRowColumnConfigureCommand(tkwin, interp, objc, objv)
} else {
int last = masterPtr->masterDataPtr->columnMax - 1;
while ((last >= 0) && (slotPtr[last].weight == 0)
- && (slotPtr[last].pad == 0)
- && (slotPtr[last].minSize == 0)
+ && (slotPtr[last].pad == 0) && (slotPtr[last].minSize == 0)
&& (slotPtr[last].uniform == NULL)) {
last--;
}
@@ -1255,7 +1259,8 @@ GridSlavesCommand(tkwin, interp, objc, objv)
int i, value;
int row = -1, column = -1;
static CONST char *optionStrings[] = {
- "-column", "-row", (char *) NULL };
+ "-column", "-row", (char *) NULL
+ };
enum options { SLAVES_COLUMN, SLAVES_ROW };
int index;
Tcl_Obj *res;
@@ -1293,7 +1298,7 @@ GridSlavesCommand(tkwin, interp, objc, objv)
res = Tcl_NewListObj(0, NULL);
for (slavePtr = masterPtr->slavePtr; slavePtr != NULL;
- slavePtr = slavePtr->nextPtr) {
+ slavePtr = slavePtr->nextPtr) {
if (column>=0 && (slavePtr->column > column
|| slavePtr->column+slavePtr->numCols-1 < column)) {
continue;
@@ -1310,7 +1315,7 @@ GridSlavesCommand(tkwin, interp, objc, objv)
}
/*
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
*
* GridReqProc --
*
@@ -1324,7 +1329,7 @@ GridSlavesCommand(tkwin, interp, objc, objv)
* Arranges for tkwin, and all its managed siblings, to
* be re-arranged at the next idle point.
*
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
*/
static void
@@ -1345,7 +1350,7 @@ GridReqProc(clientData, tkwin)
}
/*
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
*
* GridLostSlaveProc --
*
@@ -1358,7 +1363,7 @@ GridReqProc(clientData, tkwin)
* Side effects:
* Forgets all grid-related information about the slave.
*
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
*/
static void
@@ -1377,7 +1382,7 @@ GridLostSlaveProc(clientData, tkwin)
}
/*
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
*
* AdjustOffsets --
*
@@ -1393,7 +1398,7 @@ GridLostSlaveProc(clientData, tkwin)
* Side effects:
* The slot offsets are modified to shrink the layout.
*
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
*/
static int
@@ -1540,7 +1545,7 @@ AdjustOffsets(size, slots, slotPtr)
}
/*
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
*
* AdjustForSticky --
*
@@ -1554,7 +1559,7 @@ AdjustOffsets(size, slots, slotPtr)
* Side effects:
* None.
*
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
*/
static void
@@ -1599,15 +1604,14 @@ AdjustForSticky(slavePtr, xPtr, yPtr, widthPtr, heightPtr)
}
/*
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
*
* ArrangeGrid --
*
- * This procedure is invoked (using the Tcl_DoWhenIdle
- * mechanism) to re-layout a set of windows managed by
- * the grid. It is invoked at idle time so that a
- * series of grid requests can be merged into a single
- * layout operation.
+ * This procedure is invoked (using the Tcl_DoWhenIdle mechanism)
+ * to re-layout a set of windows managed by the grid. It is
+ * invoked at idle time so that a series of grid requests can be
+ * merged into a single layout operation.
*
* Results:
* None.
@@ -1615,7 +1619,7 @@ AdjustForSticky(slavePtr, xPtr, yPtr, widthPtr, heightPtr)
* Side effects:
* The slaves of masterPtr may get resized or moved.
*
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
*/
static void
@@ -1690,7 +1694,7 @@ ArrangeGrid(clientData)
}
masterPtr->abortPtr = NULL;
Tcl_Release((ClientData) masterPtr);
- return;
+ return;
}
/*
@@ -1707,11 +1711,11 @@ ArrangeGrid(clientData)
Tk_InternalBorderTop(masterPtr->tkwin) -
Tk_InternalBorderBottom(masterPtr->tkwin);
usedX = AdjustOffsets(realWidth,
- MAX(slotPtr->columnEnd,slotPtr->columnMax), slotPtr->columnPtr);
- usedY = AdjustOffsets(realHeight,
- MAX(slotPtr->rowEnd,slotPtr->rowMax), slotPtr->rowPtr);
+ MAX(slotPtr->columnEnd, slotPtr->columnMax), slotPtr->columnPtr);
+ usedY = AdjustOffsets(realHeight, MAX(slotPtr->rowEnd, slotPtr->rowMax),
+ slotPtr->rowPtr);
TkComputeAnchor(masterPtr->masterDataPtr->anchor, masterPtr->tkwin,
- 0, 0, usedX, usedY, &slotPtr->startX, &slotPtr->startY);
+ 0, 0, usedX, usedY, &slotPtr->startX, &slotPtr->startY);
/*
* Now adjust the actual size of the slave to its cavity by
@@ -1732,49 +1736,49 @@ ArrangeGrid(clientData)
width = slotPtr->columnPtr[slavePtr->numCols+col-1].offset - x;
height = slotPtr->rowPtr[slavePtr->numRows+row-1].offset - y;
- x += slotPtr->startX;
- y += slotPtr->startY;
+ x += slotPtr->startX;
+ y += slotPtr->startY;
AdjustForSticky(slavePtr, &x, &y, &width, &height);
/*
* Now put the window in the proper spot. (This was taken directly
* from tkPack.c.) If the slave is a child of the master, then
- * do this here. Otherwise let Tk_MaintainGeometry do the work.
- */
-
- if (masterPtr->tkwin == Tk_Parent(slavePtr->tkwin)) {
- if ((width <= 0) || (height <= 0)) {
- Tk_UnmapWindow(slavePtr->tkwin);
- } else {
- 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 if the master isn't mapped: wait
- * until the master gets mapped later.
- */
-
- 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);
- }
- }
+ * do this here. Otherwise let Tk_MaintainGeometry do the work.
+ */
+
+ if (masterPtr->tkwin == Tk_Parent(slavePtr->tkwin)) {
+ if ((width <= 0) || (height <= 0)) {
+ Tk_UnmapWindow(slavePtr->tkwin);
+ } else {
+ 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 if the master isn't mapped: wait
+ * until the master gets mapped later.
+ */
+
+ 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;
@@ -1782,7 +1786,7 @@ ArrangeGrid(clientData)
}
/*
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
*
* ResolveConstraints --
*
@@ -1798,7 +1802,7 @@ ArrangeGrid(clientData)
* The slot offsets are copied into the SlotInfo structure for the
* geometry master.
*
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
*/
static int
@@ -1806,26 +1810,26 @@ ResolveConstraints(masterPtr, slotType, maxOffset)
Gridder *masterPtr; /* The geometry master for this grid. */
int slotType; /* Either ROW or COLUMN. */
int maxOffset; /* The actual maximum size of this layout
- * in pixels, or 0 (not currently used). */
+ * in pixels, or 0 (not currently used). */
{
register SlotInfo *slotPtr; /* Pointer to row/col constraints. */
register Gridder *slavePtr; /* List of slave windows in this grid. */
int constraintCount; /* Count of rows or columns that have
- * constraints. */
+ * constraints. */
int slotCount; /* Last occupied row or column. */
int gridCount; /* The larger of slotCount and constraintCount.
- */
+ */
GridLayout *layoutPtr; /* Temporary layout structure. */
int requiredSize; /* The natural size of the grid (pixels).
* This is the minimum size needed to
* accomodate all of the slaves at their
* requested sizes. */
int offset; /* The pixel offset of the right edge of the
- * current slot from the beginning of the
- * layout. */
+ * current slot from the beginning of the
+ * layout. */
int slot; /* The current slot. */
int start; /* The first slot of a contiguous set whose
- * constraints are not yet fully resolved. */
+ * constraints are not yet fully resolved. */
int end; /* The Last slot of a contiguous set whose
* constraints are not yet fully resolved. */
UniformGroup uniformPre[UNIFORM_PREALLOC];
@@ -1859,7 +1863,7 @@ ResolveConstraints(masterPtr, slotType, maxOffset)
* Make sure there is enough memory for the layout.
*/
- gridCount = MAX(constraintCount,slotCount);
+ gridCount = MAX(constraintCount, slotCount);
if (gridCount >= TYPICAL_SIZE) {
layoutPtr = (GridLayout *) ckalloc(sizeof(GridLayout) * (1+gridCount));
} else {
@@ -1885,18 +1889,18 @@ ResolveConstraints(masterPtr, slotType, maxOffset)
*/
for (slot=0; slot < constraintCount; slot++) {
- layoutPtr[slot].minSize = slotPtr[slot].minSize;
- layoutPtr[slot].weight = slotPtr[slot].weight;
- layoutPtr[slot].uniform = slotPtr[slot].uniform;
- layoutPtr[slot].pad = slotPtr[slot].pad;
- layoutPtr[slot].binNextPtr = NULL;
+ layoutPtr[slot].minSize = slotPtr[slot].minSize;
+ layoutPtr[slot].weight = slotPtr[slot].weight;
+ layoutPtr[slot].uniform = slotPtr[slot].uniform;
+ layoutPtr[slot].pad = slotPtr[slot].pad;
+ layoutPtr[slot].binNextPtr = NULL;
}
- for(;slot<gridCount;slot++) {
- layoutPtr[slot].minSize = 0;
- layoutPtr[slot].weight = 0;
- layoutPtr[slot].uniform = NULL;
- layoutPtr[slot].pad = 0;
- layoutPtr[slot].binNextPtr = NULL;
+ for (; slot<gridCount; slot++) {
+ layoutPtr[slot].minSize = 0;
+ layoutPtr[slot].weight = 0;
+ layoutPtr[slot].uniform = NULL;
+ layoutPtr[slot].pad = 0;
+ layoutPtr[slot].binNextPtr = NULL;
}
/*
@@ -1913,9 +1917,9 @@ ResolveConstraints(masterPtr, slotType, maxOffset)
*/
switch (slotType) {
- case COLUMN:
+ case COLUMN:
for (slavePtr = masterPtr->slavePtr; slavePtr != NULL;
- slavePtr = slavePtr->nextPtr) {
+ slavePtr = slavePtr->nextPtr) {
int rightEdge = slavePtr->column + slavePtr->numCols - 1;
slavePtr->size = Tk_ReqWidth(slavePtr->tkwin) +
slavePtr->padX + slavePtr->iPadX + slavePtr->doubleBw;
@@ -1930,9 +1934,9 @@ ResolveConstraints(masterPtr, slotType, maxOffset)
}
}
break;
- case ROW:
+ case ROW:
for (slavePtr = masterPtr->slavePtr; slavePtr != NULL;
- slavePtr = slavePtr->nextPtr) {
+ slavePtr = slavePtr->nextPtr) {
int rightEdge = slavePtr->row + slavePtr->numRows - 1;
slavePtr->size = Tk_ReqHeight(slavePtr->tkwin) +
slavePtr->padY + slavePtr->iPadY + slavePtr->doubleBw;
@@ -1947,7 +1951,7 @@ ResolveConstraints(masterPtr, slotType, maxOffset)
}
}
break;
- }
+ }
/*
* Step 2b.
@@ -2032,17 +2036,18 @@ ResolveConstraints(masterPtr, slotType, maxOffset)
* that would fit all of the slaves. This determines the minimum
*/
- for (offset=slot=0; slot < gridCount; slot++) {
- layoutPtr[slot].minOffset = layoutPtr[slot].minSize + offset;
- for (slavePtr = layoutPtr[slot].binNextPtr; slavePtr != NULL;
- slavePtr = slavePtr->binNextPtr) {
- int span = (slotType == COLUMN) ? slavePtr->numCols : slavePtr->numRows;
- int required = slavePtr->size + layoutPtr[slot - span].minOffset;
- if (required > layoutPtr[slot].minOffset) {
- layoutPtr[slot].minOffset = required;
- }
- }
- offset = layoutPtr[slot].minOffset;
+ for (offset=0,slot=0; slot < gridCount; slot++) {
+ layoutPtr[slot].minOffset = layoutPtr[slot].minSize + offset;
+ for (slavePtr = layoutPtr[slot].binNextPtr; slavePtr != NULL;
+ slavePtr = slavePtr->binNextPtr) {
+ int span = (slotType == COLUMN) ?
+ slavePtr->numCols : slavePtr->numRows;
+ int required = slavePtr->size + layoutPtr[slot - span].minOffset;
+ if (required > layoutPtr[slot].minOffset) {
+ layoutPtr[slot].minOffset = required;
+ }
+ }
+ offset = layoutPtr[slot].minOffset;
}
/*
@@ -2053,7 +2058,7 @@ ResolveConstraints(masterPtr, slotType, maxOffset)
requiredSize = offset;
if (maxOffset > offset) {
- offset=maxOffset;
+ offset=maxOffset;
}
/*
@@ -2065,17 +2070,18 @@ ResolveConstraints(masterPtr, slotType, maxOffset)
*/
for (slot=0; slot < gridCount; slot++) {
- layoutPtr[slot].maxOffset = offset;
+ layoutPtr[slot].maxOffset = offset;
}
for (slot=gridCount-1; slot > 0;) {
- for (slavePtr = layoutPtr[slot].binNextPtr; slavePtr != NULL;
- slavePtr = slavePtr->binNextPtr) {
- int span = (slotType == COLUMN) ? slavePtr->numCols : slavePtr->numRows;
- int require = offset - slavePtr->size;
- int startSlot = slot - span;
- if (startSlot >=0 && require < layoutPtr[startSlot].maxOffset) {
- layoutPtr[startSlot].maxOffset = require;
- }
+ for (slavePtr = layoutPtr[slot].binNextPtr; slavePtr != NULL;
+ slavePtr = slavePtr->binNextPtr) {
+ int span = (slotType == COLUMN) ?
+ slavePtr->numCols : slavePtr->numRows;
+ int require = offset - slavePtr->size;
+ int startSlot = slot - span;
+ if (startSlot >=0 && require < layoutPtr[startSlot].maxOffset) {
+ layoutPtr[startSlot].maxOffset = require;
+ }
}
offset -= layoutPtr[slot].minSize;
slot--;
@@ -2098,23 +2104,23 @@ ResolveConstraints(masterPtr, slotType, maxOffset)
*/
for (start = 0; start < gridCount;) {
- int totalWeight = 0; /* Sum of the weights for all of the
- * slots in this span. */
- int need = 0; /* The minimum space needed to layout
- * this span. */
- int have; /* The actual amount of space that will
- * be taken up by this span. */
- int weight; /* Cumulative weights of the columns in
- * this span. */
- int noWeights = 0; /* True if the span has no weights. */
-
- /*
- * Find a span by identifying ranges of slots whose edges are
- * already constrained at fixed offsets, but whose internal
- * slot boundaries have a range of possible positions.
- */
-
- if (layoutPtr[start].minOffset == layoutPtr[start].maxOffset) {
+ int totalWeight = 0; /* Sum of the weights for all of the
+ * slots in this span. */
+ int need = 0; /* The minimum space needed to layout
+ * this span. */
+ int have; /* The actual amount of space that will
+ * be taken up by this span. */
+ int weight; /* Cumulative weights of the columns in
+ * this span. */
+ int noWeights = 0; /* True if the span has no weights. */
+
+ /*
+ * Find a span by identifying ranges of slots whose edges are
+ * already constrained at fixed offsets, but whose internal
+ * slot boundaries have a range of possible positions.
+ */
+
+ if (layoutPtr[start].minOffset == layoutPtr[start].maxOffset) {
start++;
continue;
}
@@ -2160,94 +2166,95 @@ ResolveConstraints(masterPtr, slotType, maxOffset)
* roundoff errors.
*/
- while (1) {
- int prevMinOffset = layoutPtr[start - 1].minOffset;
- prevGrow = 0;
- accWeight = 0;
- for (slot = start; slot <= end; slot++) {
- weight = noWeights ? 1 : layoutPtr[slot].weight;
- accWeight += weight;
- grow = (have - need) * accWeight / totalWeight - prevGrow;
- prevGrow += grow;
-
- if ((weight > 0) &&
- ((prevMinOffset + layoutPtr[slot].minSize + grow)
- > layoutPtr[slot].maxOffset)) {
- int newHave;
- /*
- * There is not enough room to grow that much.
- * Calculate how much this slot can grow and how much
- * "have" that corresponds to.
- */
-
- grow = layoutPtr[slot].maxOffset -
- layoutPtr[slot].minSize - prevMinOffset;
- newHave = grow * totalWeight / weight;
- if (newHave > totalWeight) {
- /*
- * By distributing multiples of totalWeight
- * we minimize rounding errors since they will
- * only happen in the last loop(s).
- */
-
- newHave = newHave / totalWeight * totalWeight;
- }
- if (newHave <= 0) {
- /*
- * We can end up with a "have" of 0 here if
- * the previous slots have taken all the space.
- * In that case we cannot guess an appropriate
- * "have" so we just try some lower "have" that
- * is >= 1, to make sure this terminates.
- */
-
- newHave = (have - need) - 1;
- if (newHave > (3 * totalWeight)) {
- /* Go down 25% for large values */
- newHave = newHave * 3 / 4;
- }
- if (newHave > totalWeight) {
- /* Round down to a multiple of totalWeight. */
- newHave = newHave / totalWeight * totalWeight;
- }
- if (newHave <= 0) {
- newHave = 1;
- }
- }
- have = newHave + need;
- /*
- * Restart loop to check if the new "have" will fit.
- */
-
- break;
- }
- prevMinOffset += layoutPtr[slot].minSize + grow;
- if (prevMinOffset < layoutPtr[slot].minOffset) {
- prevMinOffset = layoutPtr[slot].minOffset;
- }
- }
- /* Quit the loop if the for loop ran all the way */
- if (slot > end) break;
- }
+ do {
+ int prevMinOffset = layoutPtr[start - 1].minOffset;
+ prevGrow = 0;
+ accWeight = 0;
+ for (slot = start; slot <= end; slot++) {
+ weight = noWeights ? 1 : layoutPtr[slot].weight;
+ accWeight += weight;
+ grow = (have - need) * accWeight / totalWeight - prevGrow;
+ prevGrow += grow;
+
+ if ((weight > 0) &&
+ ((prevMinOffset + layoutPtr[slot].minSize + grow)
+ > layoutPtr[slot].maxOffset)) {
+ int newHave;
+ /*
+ * There is not enough room to grow that much.
+ * Calculate how much this slot can grow and how much
+ * "have" that corresponds to.
+ */
+
+ grow = layoutPtr[slot].maxOffset -
+ layoutPtr[slot].minSize - prevMinOffset;
+ newHave = grow * totalWeight / weight;
+ if (newHave > totalWeight) {
+ /*
+ * By distributing multiples of totalWeight
+ * we minimize rounding errors since they will
+ * only happen in the last loop(s).
+ */
+
+ newHave = newHave / totalWeight * totalWeight;
+ }
+ if (newHave <= 0) {
+ /*
+ * We can end up with a "have" of 0 here if
+ * the previous slots have taken all the space.
+ * In that case we cannot guess an appropriate
+ * "have" so we just try some lower "have" that
+ * is >= 1, to make sure this terminates.
+ */
+
+ newHave = (have - need) - 1;
+ if (newHave > (3 * totalWeight)) {
+ /* Go down 25% for large values */
+ newHave = newHave * 3 / 4;
+ }
+ if (newHave > totalWeight) {
+ /* Round down to a multiple of totalWeight. */
+ newHave = newHave / totalWeight * totalWeight;
+ }
+ if (newHave <= 0) {
+ newHave = 1;
+ }
+ }
+ have = newHave + need;
+ /*
+ * Restart loop to check if the new "have" will fit.
+ */
+
+ break;
+ }
+ prevMinOffset += layoutPtr[slot].minSize + grow;
+ if (prevMinOffset < layoutPtr[slot].minOffset) {
+ prevMinOffset = layoutPtr[slot].minOffset;
+ }
+ }
+ /*
+ * Quit the outer loop if the inner loop ran all the way.
+ */
+ } while (slot <= end);
/*
* Now distribute the extra space among the slots by
* adjusting the minSizes and minOffsets.
*/
- prevGrow = 0;
- accWeight = 0;
- for (slot = start; slot <= end; slot++) {
- accWeight += noWeights ? 1 : layoutPtr[slot].weight;
- grow = (have - need) * accWeight / totalWeight - prevGrow;
- prevGrow += grow;
- layoutPtr[slot].minSize += grow;
- if ((layoutPtr[slot-1].minOffset + layoutPtr[slot].minSize)
- > layoutPtr[slot].minOffset) {
- layoutPtr[slot].minOffset = layoutPtr[slot-1].minOffset +
- layoutPtr[slot].minSize;
- }
- }
+ prevGrow = 0;
+ accWeight = 0;
+ for (slot = start; slot <= end; slot++) {
+ accWeight += noWeights ? 1 : layoutPtr[slot].weight;
+ grow = (have - need) * accWeight / totalWeight - prevGrow;
+ prevGrow += grow;
+ layoutPtr[slot].minSize += grow;
+ if ((layoutPtr[slot-1].minOffset + layoutPtr[slot].minSize)
+ > layoutPtr[slot].minOffset) {
+ layoutPtr[slot].minOffset = layoutPtr[slot-1].minOffset +
+ layoutPtr[slot].minSize;
+ }
+ }
/*
* Having pushed the top/left boundaries of the slots to
@@ -2258,15 +2265,13 @@ ResolveConstraints(masterPtr, slotType, maxOffset)
for (slot = end; slot > start; slot--) {
/* maxOffset may not go up */
if ((layoutPtr[slot].maxOffset-layoutPtr[slot].minSize)
- < layoutPtr[slot-1].maxOffset)
- {
+ < layoutPtr[slot-1].maxOffset) {
layoutPtr[slot-1].maxOffset =
layoutPtr[slot].maxOffset-layoutPtr[slot].minSize;
}
}
}
-
/*
* Step 6.
* All of the space has been apportioned; copy the
@@ -2274,7 +2279,7 @@ ResolveConstraints(masterPtr, slotType, maxOffset)
*/
for (slot=0; slot < gridCount; slot++) {
- slotPtr[slot].offset = layoutPtr[slot].minOffset;
+ slotPtr[slot].offset = layoutPtr[slot].minOffset;
}
--layoutPtr;
@@ -2285,24 +2290,22 @@ ResolveConstraints(masterPtr, slotType, maxOffset)
}
/*
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
*
* GetGrid --
*
- * This internal procedure is used to locate a Grid
- * structure for a given window, creating one if one
- * doesn't exist already.
+ * This internal procedure is used to locate a Grid structure for
+ * a given window, creating one if one doesn't exist already.
*
* Results:
* The return value is a pointer to the Grid structure
* corresponding to tkwin.
*
* Side effects:
- * A new grid structure may be created. If so, then
- * a callback is set up to clean things up when the
- * window is deleted.
+ * A new grid structure may be created. If so, then a callback
+ * is set up to clean things up when the window is deleted.
*
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
*/
static Gridder *
@@ -2337,13 +2340,17 @@ GetGrid(tkwin)
gridPtr->slavePtr = NULL;
gridPtr->binNextPtr = NULL;
- gridPtr->column = gridPtr->row = -1;
+ gridPtr->column = -1;
+ gridPtr->row = -1;
gridPtr->numCols = 1;
gridPtr->numRows = 1;
- gridPtr->padX = gridPtr->padY = 0;
- gridPtr->padLeft = gridPtr->padTop = 0;
- gridPtr->iPadX = gridPtr->iPadY = 0;
+ gridPtr->padX = 0;
+ gridPtr->padY = 0;
+ gridPtr->padLeft = 0;
+ gridPtr->padTop = 0;
+ gridPtr->iPadX = 0;
+ gridPtr->iPadY = 0;
gridPtr->doubleBw = 2*Tk_Changes(tkwin)->border_width;
gridPtr->abortPtr = NULL;
gridPtr->flags = 0;
@@ -2357,7 +2364,7 @@ GetGrid(tkwin)
}
/*
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
*
* SetGridSize --
*
@@ -2372,7 +2379,7 @@ GetGrid(tkwin)
* Additional space is allocated for the constraints to accomodate
* the offsets.
*
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
*/
static void
@@ -2383,9 +2390,9 @@ SetGridSize(masterPtr)
int maxX = 0, maxY = 0;
for (slavePtr = masterPtr->slavePtr; slavePtr != NULL;
- slavePtr = slavePtr->nextPtr) {
- maxX = MAX(maxX,slavePtr->numCols + slavePtr->column);
- maxY = MAX(maxY,slavePtr->numRows + slavePtr->row);
+ slavePtr = slavePtr->nextPtr) {
+ maxX = MAX(maxX, slavePtr->numCols + slavePtr->column);
+ maxY = MAX(maxY, slavePtr->numRows + slavePtr->row);
}
masterPtr->masterDataPtr->columnEnd = maxX;
masterPtr->masterDataPtr->rowEnd = maxY;
@@ -2394,7 +2401,7 @@ SetGridSize(masterPtr)
}
/*
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
*
* CheckSlotData --
*
@@ -2410,7 +2417,7 @@ SetGridSize(masterPtr)
* a row or column constraints may be allocated, and the constraint
* maximums are adjusted.
*
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
*/
static int
@@ -2420,8 +2427,8 @@ CheckSlotData(masterPtr, slot, slotType, checkOnly)
int slotType; /* ROW or COLUMN */
int checkOnly; /* don't allocate new space if true */
{
- int numSlot; /* number of slots already allocated (Space) */
- int end; /* last used constraint */
+ int numSlot; /* number of slots already allocated (Space) */
+ int end; /* last used constraint */
/*
* If slot is out of bounds, return immediately.
@@ -2445,14 +2452,14 @@ CheckSlotData(masterPtr, slot, slotType, checkOnly)
end = (slotType == ROW) ? masterPtr->masterDataPtr->rowMax :
masterPtr->masterDataPtr->columnMax;
if (checkOnly == CHECK_ONLY) {
- return (end < slot) ? TCL_ERROR : TCL_OK;
+ return ((end < slot) ? TCL_ERROR : TCL_OK);
} else {
numSlot = (slotType == ROW) ? masterPtr->masterDataPtr->rowSpace
- : masterPtr->masterDataPtr->columnSpace;
+ : masterPtr->masterDataPtr->columnSpace;
if (slot >= numSlot) {
- int newNumSlot = slot + PREALLOC ;
- size_t oldSize = numSlot * sizeof(SlotInfo) ;
- size_t newSize = newNumSlot * sizeof(SlotInfo) ;
+ int newNumSlot = slot + PREALLOC ;
+ size_t oldSize = numSlot * sizeof(SlotInfo);
+ size_t newSize = newNumSlot * sizeof(SlotInfo);
SlotInfo *new = (SlotInfo *) ckalloc(newSize);
SlotInfo *old = (slotType == ROW) ?
masterPtr->masterDataPtr->rowPtr :
@@ -2480,7 +2487,7 @@ CheckSlotData(masterPtr, slot, slotType, checkOnly)
}
/*
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
*
* InitMasterData --
*
@@ -2495,7 +2502,7 @@ CheckSlotData(masterPtr, slot, slotType, checkOnly)
* A new master grid structure may be created. If so, then
* it is initialized.
*
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
*/
static void
@@ -2646,12 +2653,12 @@ GridStructureProc(clientData, eventPtr)
if (eventPtr->type == ConfigureNotify) {
if ((gridPtr->slavePtr != NULL)
- && !(gridPtr->flags & REQUESTED_RELAYOUT)) {
+ && !(gridPtr->flags & REQUESTED_RELAYOUT)) {
gridPtr->flags |= REQUESTED_RELAYOUT;
Tcl_DoWhenIdle(ArrangeGrid, (ClientData) gridPtr);
}
if ((gridPtr->masterPtr != NULL)
- && (gridPtr->doubleBw != 2*Tk_Changes(gridPtr->tkwin)->border_width)) {
+ && (gridPtr->doubleBw != 2*Tk_Changes(gridPtr->tkwin)->border_width)) {
if (!(gridPtr->masterPtr->flags & REQUESTED_RELAYOUT)) {
gridPtr->doubleBw = 2*Tk_Changes(gridPtr->tkwin)->border_width;
gridPtr->masterPtr->flags |= REQUESTED_RELAYOUT;
@@ -2665,7 +2672,7 @@ GridStructureProc(clientData, eventPtr)
Unlink(gridPtr);
}
for (gridPtr2 = gridPtr->slavePtr; gridPtr2 != NULL;
- gridPtr2 = nextPtr) {
+ gridPtr2 = nextPtr) {
Tk_UnmapWindow(gridPtr2->tkwin);
gridPtr2->masterPtr = NULL;
nextPtr = gridPtr2->nextPtr;
@@ -2688,7 +2695,7 @@ GridStructureProc(clientData, eventPtr)
register Gridder *gridPtr2;
for (gridPtr2 = gridPtr->slavePtr; gridPtr2 != NULL;
- gridPtr2 = gridPtr2->nextPtr) {
+ gridPtr2 = gridPtr2->nextPtr) {
Tk_UnmapWindow(gridPtr2->tkwin);
}
}
@@ -2742,8 +2749,8 @@ ConfigureSlaves(interp, tkwin, objc, objv)
int numSkip; /* number of 'x' found */
static CONST char *optionStrings[] = {
"-column", "-columnspan", "-in", "-ipadx", "-ipady",
- "-padx", "-pady", "-row", "-rowspan", "-sticky",
- (char *) NULL };
+ "-padx", "-pady", "-row", "-rowspan", "-sticky", (char *) NULL
+ };
enum options {
CONF_COLUMN, CONF_COLUMNSPAN, CONF_IN, CONF_IPADX, CONF_IPADY,
CONF_PADX, CONF_PADY, CONF_ROW, CONF_ROWSPAN, CONF_STICKY };
@@ -2757,7 +2764,7 @@ ConfigureSlaves(interp, tkwin, objc, objv)
*/
firstChar = 0;
- for (numWindows = i = 0; i < objc; i++) {
+ for (numWindows=0, i=0; i < objc; i++) {
prevChar = firstChar;
string = Tcl_GetStringFromObj(objv[i], (int *) &length);
firstChar = string[0];
@@ -2830,7 +2837,7 @@ ConfigureSlaves(interp, tkwin, objc, objv)
for (i = numWindows; i < objc; i += 2) {
if (Tcl_GetIndexFromObj(interp, objv[i], optionStrings, "option", 0,
- &index) != TCL_OK) {
+ &index) != TCL_OK) {
return TCL_ERROR;
}
if (index == CONF_IN) {
@@ -2918,7 +2925,7 @@ ConfigureSlaves(interp, tkwin, objc, objv)
* configuration information to default values (there could
* be old values left from a previous packer)."
*
- * I [D.S.] disagree with this statement. If a slave is disabled (using
+ * I [D.S.] disagree with this statement. If a slave is disabled (using
* "forget") and then re-enabled, I submit that 90% of the time the
* programmer will want it to retain its old configuration information.
* If the programmer doesn't want this behavior, then the
@@ -2964,8 +2971,7 @@ ConfigureSlaves(interp, tkwin, objc, objv)
InitMasterData(masterPtr);
} else if (index == CONF_IPADX) {
if ((Tk_GetPixelsFromObj(interp, slave, objv[i+1], &tmp)
- != TCL_OK)
- || (tmp < 0)) {
+ != TCL_OK) || (tmp < 0)) {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "bad ipadx value \"",
Tcl_GetString(objv[i+1]),
@@ -2976,8 +2982,7 @@ ConfigureSlaves(interp, tkwin, objc, objv)
slavePtr->iPadX = tmp*2;
} else if (index == CONF_IPADY) {
if ((Tk_GetPixelsFromObj(interp, slave, objv[i+1], &tmp)
- != TCL_OK)
- || (tmp < 0)) {
+ != TCL_OK) || (tmp < 0)) {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "bad ipady value \"",
Tcl_GetString(objv[i+1]),
@@ -3098,8 +3103,7 @@ ConfigureSlaves(interp, tkwin, objc, objv)
if (masterPtr->masterPtr == slavePtr) {
Tcl_AppendResult(interp, "can't put ", Tcl_GetString(objv[j]),
" inside ", Tk_PathName(masterPtr->tkwin),
- ", would cause management loop.",
- (char *) NULL);
+ ", would cause management loop.", (char *) NULL);
Unlink(slavePtr);
return TCL_ERROR;
}
@@ -3167,7 +3171,9 @@ ConfigureSlaves(interp, tkwin, objc, objv)
/* Count the number of consecutive ^'s starting from this position */
for (width = 1; width + j < numWindows; width++) {
char *string = Tcl_GetString(objv[j+width]);
- if (*string != REL_VERT) break;
+ if (*string != REL_VERT) {
+ break;
+ }
}
/*
@@ -3188,7 +3194,7 @@ ConfigureSlaves(interp, tkwin, objc, objv)
match = 0;
for (slavePtr = masterPtr->slavePtr; slavePtr != NULL;
- slavePtr = slavePtr->nextPtr) {
+ slavePtr = slavePtr->nextPtr) {
if (slavePtr->column == lastColumn
&& slavePtr->row + slavePtr->numRows - 1 == lastRow) {
@@ -3256,7 +3262,7 @@ StickyToString(flags, result)
if (count) {
result[count] = '\0';
} else {
- sprintf(result,"{}");
+ sprintf(result, "{}");
}
}