projects/mde: mde/gui/widget/layout.d comparison

comparison mde/gui/widget/layout.d @ 45:0fd51d2c6c8a

Several changes to resising windows and layout widgets. This commit still has some bugs. Moved the implementable widgets from mde.gui.widget.Widget to miscWidgets, leaving base widgets in Widget. Rewrote some of GridLayoutWidget's implementation. Made many operations general to work for either columns or rows. Some optimisations were intended but ended up being removed due to problems. Allowed layout's to resize from either direction (only with window resizes). committer: Diggory Hardy <diggory.hardy@gmail.com>

author	Diggory Hardy <diggory.hardy@gmail.com>
date	Thu, 22 May 2008 11:34:09 +0100
parents	1530d9c04d4d
children	03fa79a48c48

comparison

equal deleted inserted replaced

-:07bd1a09e161
+:0fd51d2c6c8a
 module mde.gui.widget.layout;
 import mde.gui.widget.Widget;
 import mde.gui.exception;
-import tango.io.Stdout;
 debug {
 import tango.util.log.Log : Log, Logger;
 private Logger logger;
 static this () {
 logger = Log.getLogger ("mde.gui.widget.layout");
 super (wind, data);
 rows = data[1];
 cols = data[2];
 if (data.length != 3 + rows * cols) throw new WidgetDataException;
-/* data.length >= 3 so besides checking the length is correct, this tells us:
+/* data.length >= 4 so besides checking the length is correct, this tells us:
 *      rows * cols >= 4 - 3 = 1            a free check!
 * The only thing not checked is whether both rows and cols are negative, which would
-* cause an exception when dynamic arrays are allocated later (and is unlikely). */
+* cause an exception when dynamic arrays are allocated by genCachedConstructionData, which
+* is an acceptible method of failure (and is unlikely anyway). */
 // Get all sub-widgets
 subWidgets.length = rows*cols;
 foreach (i, ref subWidget; subWidgets) {
 subWidget = window.makeWidget (data[i+3]);
 * Note: if setSize gets called afterwards, it should have same dimensions and so not do
 * anything. */
 int lenUsed = 0;
 if (data.length < rows + cols) {    // data error; use defaults
-colW = colWMin.dup;
+col.dupMin;
-rowH = rowHMin.dup;
+row.dupMin;
 } else {                            // sufficient data
 lenUsed = rows+cols;
-colW = data[0..cols];
+col.setCheck (data[0..cols]);
-rowH = data[cols..lenUsed];
+row.setCheck (data[cols..lenUsed]);
+}
-// Check row sizes are valid:
-//NOTE: this could be made optional
-//NOTE: could also check non-resizable sizes are not too large
+// Generate cached mutable data
-foreach (i, ref w; colW)
+// Calculate column and row locations:
-if (w < colWMin[i]) w = colWMin[i];
+w = col.genPositions;
-foreach (i, ref h; rowH)
+h = row.genPositions;
-if (h < rowHMin[i]) h = rowHMin[i];
-}
+// Tell subwidgets their new sizes. Positions are given by a later call to setPosition.
+foreach (i,widget; subWidgets)
-genCachedMutableData;
+// Resizing direction is arbitrarily set to "high direction":
-w = colW[$-1] + colX[$-1];
+widget.setSize (col.width[i % cols], row.width[i / cols], true, true);
-h = rowY[$-1] + rowH[$-1];
 return data[lenUsed..$];
 }
 int[] getCreationData () {
 int[] getMutableData () {
 int[] ret;
 foreach (widget; subWidgets)
 ret ~= widget.getMutableData;
-ret ~= colW ~ rowH;
+ret ~= col.width ~ row.width;
 return ret;
 }
 bool isWSizable () {
-return (sizableCols.length != 0);
+return col.firstSizable >= 0;
 }
 bool isHSizable () {
-return (sizableRows.length != 0);
+return row.firstSizable >= 0;
 }
 /* Calculates the minimal size from all rows and columns of widgets. */
 void getMinimalSize (out int mw, out int mh) {
 mw = this.mw;
 mh = this.mh;
 }
-void setSize (int nw, int nh) {
+void setSize (int nw, int nh, bool wHigh, bool hHigh) {
-// Step 1: calculate the row/column sizes.
+debug scope (failure) {
-w += adjustCellSizes (colW, colWMin, sizableCols, nw - w, true);
+char[128] tmp;
-h += adjustCellSizes (rowH, rowHMin, sizableRows, nh - h, true);
+logger.trace ("setSize failed: hHigh = " ~ (hHigh ? "true" : "false"));
+logger.trace (logger.format (tmp, "rows to resize: {}, {}", row.firstSizable, row.lastSizable));
-// Step 2: calculate the row/column offsets (positions) and set the sub-widget's sizes.
+}
-genCachedMutableData;
+// Optimisation (could easily be called with same sizes if a parent layout widget is
+// resized, since many columns/rows may not be resized).
-// Step 3: position needs to be set
+if (nw == w && nh == h) return;
-// Currently this happens by specifying that setPosition should be run after setSize.
+// calculate the row/column sizes (and new positions)
+if (wHigh)
+w += col.adjustCellSizes (nw - w, col.lastSizable, -1);
+else
+w += col.adjustCellSizes (nw - w, col.firstSizable, 1);
+if (hHigh)
+h += row.adjustCellSizes (nh - h, row.lastSizable, -1);
+else
+h += row.adjustCellSizes (nh - h, row.firstSizable, 1);
+// set the sub-widget's sizes & positions
+setSubWidgetSP (wHigh, hHigh);
 }
 void setPosition (int x, int y) {
 this.x = x;
 this.y = y;
 foreach (i,widget; subWidgets)
-widget.setPosition (x + colX[i % cols], y + rowY[i / cols]);
+widget.setPosition (x + col.pos[i % cols], y + row.pos[i / cols]);
 }
 // Find the relevant widget.
 IWidget getWidget (int cx, int cy) {
-int lx = cx - x, ly = cy - y;       // use coords relative to this widget
+debug scope (failure)
+logger.warn ("getWidget: failure");
-// Find the column
+// Find row/column:
-int i = cols - 1;                   // starting from right...
+myDiff i = col.getCell (cx - x);
-while (lx < colX[i]) {              // decrement while left of this column
+myDiff j = row.getCell (cy - y);
-debug assert (i > 0, "getWidget: left of first column");  // should be impossible
+if (i < 0 || j < 0)	// on a space between widgets
---i;
+return this;
-}                                   // now (lx >= colX[i])
-if (lx >= colX[i] + colW[i]) return this;   // between columns
+// On a subwidget; recurse call:
+return subWidgets[i + j*cols].getWidget (cx, cy);
-// Find the row;
-int j = rows - 1;
-while (ly < rowY[j]) {
-debug assert (j > 0, "getWidget: above first row");   // should be impossible
---j;
-}
-if (ly >= rowY[j] + rowH[j]) return this;
-// Now we know it's in widget (i,j)'s cell (but the widget may not take up the whole cell)
-lx -= colX[i];
-ly -= rowY[j];
-IWidget widg = subWidgets[i + j*cols];
-widg.getCurrentSize (i,j);
-if (lx < i && ly < j)
-return widg.getWidget (cx, cy);
-return this;    // wasn't in cell
 }
 // Resizing columns & rows
 void clickEvent (ushort cx, ushort cy, ubyte b, bool state) {
 debug scope (failure)
 if (b == 1 && state == true) {
 /* Note: Because of getWidget, this function is only called if the click is not on a
 * sub-widget, so we know it's on some divisor (so at least one of resizeCol and
 * resizeRow is non-negative). */
-// Find the column
+// find col/row's resizeD & resizeU
-if (sizableCols.length != 0) {
+if (col.findResize (cx - x) && row.findResize (cy - y))
-int l = cx - x;                 // use relative coords
+return;		// unable to resize
-size_t i = cols - 1;            // index, from right
-while (l < colX[i]) {           // decrement while left of this column
-debug assert (i > 0, "clickEvent: left of first column");
---i;
-}                               // now (l >= colX[resizeCol])
-if (l < colX[i] + colW[i]) i = -1;  // on a sub-widget
-// Set resizeColsL / resizeColsH
-// Want to find j such that [0..j],[j..$] divide sizableCols about i:
-size_t j = 0;
-while (j < sizableCols.length && sizableCols[j] <= i) ++j;
-resizeColsL = sizableCols[0..j];
-resizeColsH = sizableCols[j..$];
-// Cannot resize if either list is empty. resizeCallback checks the length of L,
-// but to save it checking R too, we set L's length zero if R's is.
-if (resizeColsH.length == 0)
-resizeColsL = null;
-}
-// Find the row
-if (sizableRows.length != 0) {
-int l = cy - y;
-size_t i = rows - 1;
-while (l < rowY[i]) {
-debug assert (i > 0, "clickEvent: above first row");
---i;
-}
-if (l < rowY[i] + rowH[i]) i = -1;
-size_t j = 0;
-while (j < sizableRows.length && sizableRows[j] <= i) ++j;
-resizeRowsL = sizableRows[0..j];
-resizeRowsH = sizableRows[j..$];
-if (resizeRowsH.length == 0)
-resizeRowsL = null;
-}
-if (resizeColsL is null && resizeRowsL is null)
-return;     // no resizing to do
 dragX = cx;
 dragY = cy;
 window.gui.addClickCallback (&endCallback);
 private:
 //BEGIN Cache calculation functions
 /* Calculations which need to be run whenever a new sub-widget structure is set
 * (i.e. to produce cached data calculated from construction data). */
 void genCachedConstructionData () {
+col.spacing = row.spacing = window.renderer.layoutSpacing;
 // Calculate the minimal column and row sizes:
-colWMin = new int[cols];    // set length, making sure the arrays are initialised to zero
+// set length, making sure the arrays are initialised to zero:
-rowHMin = new int[rows];
+col.minWidth = new int[cols];
+row.minWidth = new int[rows];
 int ww, wh;     // sub-widget minimal sizes
 foreach (i,widget; subWidgets) {
 widget.getMinimalSize (ww, wh);
 // Increase dimensions if current minimal size is larger:
-uint n = i % cols;      // column
+myIt n = i % cols;	// column
-if (colWMin[n] < ww) colWMin[n] = ww;
+if (col.minWidth[n] < ww) col.minWidth[n] = ww;
-n = i / cols;           // row
+n = i / cols;		// row
-if (rowHMin[n] < wh) rowHMin[n] = wh;
+if (row.minWidth[n] < wh) row.minWidth[n] = wh;
 }
 // Calculate the overall minimal size, starting with the spacing:
-mh = window.renderer.layoutSpacing;     // use mh temporarily
+mh = window.renderer.layoutSpacing;	// use mh temporarily
 mw = mh * (cols - 1);
 mh *= (rows - 1);
-foreach (x; colWMin)            // add the column/row's dimensions
+foreach (x; col.minWidth)		// add the column/row's dimensions
 mw += x;
-foreach (x; rowHMin)
+foreach (x; row.minWidth)
 mh += x;
 // Find which cols/rows are resizable:
-sizableCols = sizableRows = null;   // reset; we're about to concatenate to them
+// reset:
+col.sizable = new bool[cols];
+row.sizable = new bool[rows];
+col.firstSizable = row.firstSizable = -1;
 forCols:
-for (uint i = 0; i < cols; ++i) {                       // for each column
+for (myIt i = 0; i < cols; ++i) {				// for each column
-for (uint j = 0; j < subWidgets.length; j += cols)  // for each row
+for (myIt j = 0; j < subWidgets.length; j += cols)	// for each row
-if (!subWidgets[i+j].isWSizable)        // column not resizable
+if (!subWidgets[i+j].isWSizable)	// column not resizable
-continue forCols;                   // continue the outer for loop
+continue forCols;			// continue the outer for loop
 // column is resizable if we get to here
-sizableCols ~= i;
+col.sizable[i] = true;
+if (col.firstSizable < 0)
+col.firstSizable = i;
+col.lastSizable = i;
 }
 forRows:
-for (uint i = 0; i < subWidgets.length; i += cols) {    // for each row
+for (myIt i = 0; i < subWidgets.length; i += cols) {	// for each row
-for (uint j = 0; j < cols; ++j)                     // for each column
+for (myIt j = 0; j < cols; ++j)			// for each column
 if (!subWidgets[i+j].isHSizable)
 continue forRows;
-sizableRows ~= i / cols;
+row.lastSizable = i / cols;
-}
+row.sizable[row.lastSizable] = true;
-}
+if (row.firstSizable < 0)
+row.firstSizable = row.lastSizable;
-/* Calculations which need to be run whenever resizing occurs (or deeper alterations)
+}
-* (i.e. to produce cached data calculated from construction and mutable data). */
+}
-void genCachedMutableData () {
-// Calculate column and row locations:
+// set sub-widgets size & position (done after resizing widget or rows/columns)
-colX.length = cols;
+void setSubWidgetSP (bool wH, bool hH) {
-rowY.length = rows;
+for (myIt i = 0; i < cols; ++i)
-int spacing = window.renderer.layoutSpacing;
+for (myIt j = 0; j < rows; ++j)
+{
-int cum = 0;
+IWidget widget = subWidgets[i + cols*j];
-foreach (i, x; rowH) {
+widget.setSize (col.width[i], row.width[j], wH, hH);
-rowY[i] = cum;
+widget.setPosition (x + col.pos[i], y + row.pos[j]);
-cum += x + spacing;
+}
-}
-cum = 0;
-foreach (i, x; colW) {
-colX[i] = cum;
-cum += x + spacing;
-}
-// Tell subwidgets their new sizes:
-foreach (i,widget; subWidgets)
-widget.setSize (colW[i % cols], rowH[i / cols]);
 }
 //END Cache calculation functions
-/* Adjust the total size of rows/columns (including spacing) by diff.
-*
-* Params:
-*  cellD       = current sizes; is adjusted by the function to new sizes
-*  cellDMin    = minimal sizes (see colWMin/rowHMin)
-*  sizableCells= List of indexes in cellD for cells which are resizable
-*  diff        = amount to increase/decrease the total size
-*  startHigh   = if true, start resizing from the tail end of cellD, instead of the beginning
-*
-* Returns:
-*  The amount adjusted. This may be larger than diff, since cellD is clamped by cellDMin.
-*/
-int adjustCellSizes (ref int[] cellD, ref int[] cellDMin, ref size_t[] sizableCells, int diff, bool startHigh)
-in {// Could occur if adjust isn't called first, but this would be a code error:
-assert (cellD !is null, "adjustCellSizes: cellD is null");
-} body {
-// Cannot resize if no cells are sizable:
-if (sizableCells.length == 0) return 0;
-size_t si = (startHigh ? sizableCells.length-1 : 0);    // starting index of sizableCells
-// FIXME: could do with an overhaul
-if (diff > 0) {         // increase size of first resizable cell
-cellD[sizableCells[si]] += diff;
-return diff;
-}
-else if (diff < 0) {    // decrease
-size_t sc = (startHigh ? -1 : 1);   // amount to iterate
-size_t ci;          // index in cellD
-int rd = diff;      // running diff
-while (true) {
-ci = sizableCells[si];
-cellD[ci] += rd; // decrease this cell's size (but may be too much)
-rd = cellD[ci] - cellDMin[ci];
-if (rd >= 0)    // OK; we're done
-return diff;// we hit the mark exactly
-// else we decreased it too much!
-cellD[ci] = cellDMin[ci];
-// rd is remainder to decrease by
-si += sc;       // iterate
-if (si < 0 || si >= sizableCells.length)        // run out of next cells
-return diff - rd;   // still had rd left to decrease
-}
-}
-else                   // no adjustment needed
-return 0;
-}
 //BEGIN Col/row resizing
 void resizeCallback (ushort cx, ushort cy) {
-int move;           // NOTE: all resizing is relative, unlike in Window
+col.resize (cx - dragX);
+row.resize (cy - dragY);
-if (resizeColsL.length != 0) {
-move = cx - dragX;
+// NOTE: all adjustments are relative; might be better if they were absolute?
+dragX = cx;
-// do shrinking first (in case we hit the minimum)
+dragY = cy;
-// Note: we rely on x[a..b] pointing to the same memory as x
-if (move < 0) {
+// NOTE: Resizing direction is set to "high direction" which isn't always going to be
-move = -adjustCellSizes (colW, colWMin, resizeColsL, move, false);
+// correct. A more accurate but more complex approach might be to get
-adjustCellSizes (colW, colWMin, resizeColsH, move, true);
+// adjustCellSizes to do the work.
-} else {
+setSubWidgetSP (true, true);
-move = -adjustCellSizes (colW, colWMin, resizeColsH, -move, true);
-adjustCellSizes (colW, colWMin, resizeColsL, move, false);
-}
-dragX = cx;
-}
-if (resizeRowsL.length != 0) {
-move = cy - dragY;
-// do shrinking first (in case we hit the minimum)
-// Note: we rely on x[a..b] pointing to the same memory as x
-if (move < 0) {
-move = -adjustCellSizes (rowH, rowHMin, resizeRowsL, move, false);
-adjustCellSizes (rowH, rowHMin, resizeRowsH, move, true);
-} else {
-move = -adjustCellSizes (rowH, rowHMin, resizeRowsH, -move, true);
-adjustCellSizes (rowH, rowHMin, resizeRowsL, move, false);
-}
-dragY = cy;
-}
-// NOTE: this might be able to be made more efficient, but basically this all needs to happen:
-genCachedMutableData;
-setPosition (x,y);
 window.requestRedraw;
 }
 bool endCallback (ushort cx, ushort cy, ubyte b, bool state) {
 if (b == 1 && state == false) {
 window.gui.removeCallbacks (cast(void*) this);
-// Remove unwanted data (although it shouldn't free any memory):
+return true;	// we've handled the up-click
-resizeColsL = resizeColsH = resizeRowsL = resizeRowsH = null;
+}
-return true;    // we've handled the up-click
+return false;		// we haven't handled it
-}
-return false;       // we haven't handled it
 }
 protected:
 // Data for resizing cols/rows:
-int dragX, dragY;   // coords where drag starts
+int dragX, dragY;	// coords where drag starts
-// Lists of columns/rows with lower/higher index than the resize position
-size_t[] resizeColsL, resizeColsH, resizeRowsL, resizeRowsH;
 //END Col/row resizing
-//BEGIN Construction (i.e. non-mutable) data
+myIt cols, rows;	// number of cells in grid
-int cols, rows;     // number of cells in grid
 /* All widgets in the grid, by row. Order:  [ 0 1 ]
 *                                          [ 2 3 ] */
 IWidget[] subWidgets;
-// Cached data calculated from construction data:
+/* Widths, positions, etc., either of columns or of rows
-// Minimal column width / row height:
+*
-int[] colWMin, rowHMin;
+* The purpose of this struct is mostly to unify functionality which must work the same on both
-int mw, mh;         // minimal dimensions
+* horizontal and vertical cell placement.
+*
-// All resizable cols/rows, in order:
+* Most notation corresponds to horizontal layout (columns), simply for easy of naming. */
-size_t[] sizableCols, sizableRows;
+struct CellDimensions {
-//END Construction data
+int[] pos,	// relative position (cumulative width[i-1] plus spacing)
+width,	// current widths
+minWidth;	// minimal widths (set by genCachedConstructionData)
-//BEGIN Mutable data
+bool[] sizable;	// true if col is resizable (set by genCachedConstructionData)
-int[] colW, rowH;   // column width / row height (largest size in col/row)
+myDiff firstSizable,	// first col which is resizable, negative if none
+lastSizable;	// as above, but last (set by genCachedConstructionData)
-// Cached data calculated from construction and mutable data:
+myDiff resizeD,	// resize down from this index (<0 if not resizing)
-int[] colX, rowY;   // cumulative colW[i-1] + padding (add x to get column's left x-coord)
+resizeU;	// and up from this index
-//END Mutable data
+int spacing;	// used by genPositions (which cannot access the layout class's data)
+void dupMin () {
+width = minWidth.dup;
+}
+void setCheck (int[] data) {
+// Set to provided data:
+width = data;
+// And check sizes are valid:
+foreach (i, m; minWidth)
+// if fixed width or width is less than minimum:
+if (!sizable[i] || width[i] < m)
+width[i] = m;
+}
+// Generate position infomation and return total width (i.e. widget width/height)
+int genPositions () {
+pos.length = minWidth.length;
+int x = 0;
+foreach (i, w; width) {
+pos[i] = x;
+x += w + spacing;
+}
+return x - spacing;
+}
+// Get the row/column a click occured in
+// Returns -i if in space to left of col i, or i if on col i
+myDiff getCell (int l) {
+myDiff i = minWidth.length - 1;	// starting from right...
+while (l < pos[i]) {		// decrement while left of this column
+debug assert (i > 0, "getCell: l < pos[0] (code error)");
+--i;
+}					// now (l >= pos[i])
+if (l >= pos[i] + width[i])		// between columns
+return -i - 1;			// note: i might be 0 so cannot just return -i
+return i;
+}
+// Calculate resizeU/resizeD, and return true if unable to resize.
+bool findResize (int l) {
+resizeU = -getCell (l);		// potential start for upward-resizes
+if (resizeU <= 0) return true;	// not on a space between cells
+resizeD = resizeU - 1;		// potential start for downward-resizes
+while (!sizable[resizeU]) {		// find first actually resizable column (upwards)
+++resizeU;
+if (resizeU >= minWidth.length) {	// cannot resize
+resizeU = -1;
+return true;
+}
+}
+while (!sizable[resizeD]) {		// find first actually resizable column (downwards)
+--resizeD;
+if (resizeD < 0) {		// cannot resize
+resizeU = -1;	// resizeU is tested to check whether resizes are possible
+return true;
+}
+}
+return false;			// can resize
+}
+/* Adjust the total size of rows/columns (including spacing) by diff.
+*
+* Params:
+*  diff	= amount to increase/decrease the total size
+*  start= index for col/row to start resizing on
+*  incr	= direction to resize in (added to index each step). Must be either -1 or +1.
+*
+* Returns:
+*  The amount adjusted. This may be larger than diff, since cellD is clamped by cellDMin.
+*/
+int adjustCellSizes (int diff, myDiff start, myDiff incr)
+in {// Could occur if adjust isn't called first, but this would be a code error:
+char[128] tmp;
+logger.trace (logger.format (tmp, "start is {}", start));
+assert (width !is null, "adjustCellSizes: width is null");
+assert (start >= 0 && start < minWidth.length, "adjustCellSizes: invalid start");
+assert (incr == 1 || incr == -1, "adjustCellSizes: invalid incr");
+} body {
+debug scope(failure)
+logger.trace ("adjustCellSizes: failure");
+myDiff i = start;
+if (diff > 0) {		// increase size of first resizable cell
+width[i] += diff;
+}
+else if (diff < 0) {	// decrease
+int rd = diff;		// running diff
+aCSwhile:
+while (true) {
+width[i] += rd;	// decrease this cell's size (but may be too much)
+rd = width[i] - minWidth[i];
+if (rd >= 0)	// OK; we're done
+break;		// we hit the mark exactly: diff is correct
+// else we decreased it too much!
+width[i] = minWidth[i];
+// rd is remainder to decrease by
+bool it = true;	// iterate (force first time)
+while (it) {
+i += incr;
+if (i < 0 || i >= minWidth.length) {	// run out of next cells
+diff -= rd;	// still had rd left to decrease
+break aCSwhile;	// exception: Array index out of bounds
+}
+it = !sizable[i];	// iterate again if row/col isn't resizable
+}
+}
+}
+// else no adjustment needed (diff == 0)
+genPositions;
+return diff;
+}
+void resize (int diff) {
+if (resizeU <= 0) return;
+// do shrinking first (in case we hit the minimum)
+if (diff >= 0) {
+diff = -adjustCellSizes (-diff, resizeU, 1);
+adjustCellSizes (diff, resizeD, -1);
+} else {
+diff = -adjustCellSizes (diff, resizeD, -1);
+adjustCellSizes (diff, resizeU, 1);
+}
+}
+}
+CellDimensions col, row;
+// Index types. Note that in some cases they need to hold negative values.
+alias size_t myIt;
+alias ptrdiff_t myDiff;
 }

Mercurial > projects > mde

comparison mde/gui/widget/layout.d @ 45:0fd51d2c6c8a