diff options
Diffstat (limited to 'generic')
| -rw-r--r-- | generic/tkGrid.c | 624 |
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, "{}"); } } |