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

comparison mde/gui/widget/layout.d @ 124:a2ef6b549101

Dynamic minimal size changing is now fully supported. Support for reducing minimal size in layouts. Editing numbers as text now always converts new number back to string at end of edit. Floating point number display format changed.

author	Diggory Hardy <diggory.hardy@gmail.com>
date	Mon, 05 Jan 2009 12:43:27 +0000
parents	d3b2cefd46c9
children	c9843fbaac88

comparison

equal deleted inserted replaced

-:d3b2cefd46c9
+:a2ef6b549101
 }
 debug logger.error ("minSizeChange: widget is not my child (code error)");
 return;
 gotCell:
-if (col.newMinWidth (c % cols, nmw) ||
+size_t r = c / cols;
-row.newMinWidth (c / cols, nmh)) {
+c = c % cols;
-parent.minSizeChange (this, col.mw, row.mw);
+bool sizeChange = col.newMinWidth (c, r+colR, nmw);
+sizeChange = row.newMinWidth (r, c+rowR, nmh) || sizeChange;
+if (sizeChange) {
 w = col.w;
 h = row.w;
+parent.minSizeChange (this, col.mw, row.mw);
 }
 mgr.requestRedraw;
 }
 //END Size & position
 debug scope (failure)
 logger.warn ("getWidget: failure; values: click; pos; width: {},{}; {},{}; {},{}", cx, cy, x, y, w, h);
 debug assert (cx >= x && cx < x + w && cy >= y && cy < y + h, "getWidget: not on widget (code error)");
 // Find row/column:
-myDiff i = col.getCell (cx - x);
+ptrdiff_t i = col.getCell (cx - x);
-myDiff j = row.getCell (cy - y);
+ptrdiff_t j = row.getCell (cy - y);
 if (i < 0 || j < 0)	// on a space between widgets
 return this;
 // On a subwidget; recurse call:
 return subWidgets[i + j*cols].getWidget (cx, cy);
 	if (sADD_n == n) return;	// cached data is current
 	sADD_n = n;
 debug (mdeWidgets) logger.trace ("GridWidget: setup on subWidgets...");
 	foreach (widg; subWidgets) {	// make sure all subwidgets have been set up
-	    debug assert (widg);
+	    debug assert (widg, "null widg");
 	    widg.setup (n,flags);
 	}
 debug (mdeWidgets) logger.trace ("GridWidget: setup on subWidgets...done");
 	// make sure both AlignColumns are set up (since first call to setup(n) calls reset):
 	col.setup (n, flags);
 	// Note: shared AlignColumns get this set by all sharing GridWidgets
 col.spacing = row.spacing = useSpacing ? mgr.renderer.layoutSpacing : 0;
 // Calculate the minimal column and row sizes:
+if (colR == size_t.max)
+colR = col.addRows (rows);
+if (rowR == size_t.max)
+rowR = row.addRows (cols);
 // AlignColumns (row, col) takes care of initializing minWidth.
-foreach (i,widget; subWidgets) {
+for (size_t r = 0; r < rows; ++r) {
-// Increase dimensions if current minimal size is larger:
+for (size_t c = 0; c < cols; ++c) {
-myIt j = i % cols;	// column
+size_t i = r*cols + c;
-wdim md = widget.minWidth;
+col.minCellWidths[i+colR*cols] = subWidgets[i].minWidth;
-if (col.minWidth[j] < md) col.minWidth[j] = md;
+	row.minCellWidths[(c+rowR)*rows+r] = subWidgets[i].minHeight;
-j = i / cols;		// row
+}
-md = widget.minHeight;
-if (row.minWidth[j] < md) row.minWidth[j] = md;
 }
 // Find which cols/rows are resizable:
 // AlignColumns initializes sizable, and sets first and last sizables.
 forCols:
-for (myIt i = 0; i < cols; ++i) {				// for each column
+for (size_t i = 0; i < cols; ++i) {				// for each column
-for (myIt j = 0; j < subWidgets.length; j += cols)	// for each row
+for (size_t j = 0; j < subWidgets.length; j += cols)	// for each row
 if (!subWidgets[i+j].isWSizable)	// column not resizable
 continue forCols;			// continue the outer for loop
 // column is resizable if we get to here
 col.sizable[i] = true;
 }
 forRows:
-for (myIt i = 0; i < subWidgets.length; i += cols) {	// for each row
+for (size_t i = 0; i < subWidgets.length; i += cols) {	// for each row
-for (myIt j = 0; j < cols; ++j)			// for each column
+for (size_t j = 0; j < cols; ++j)			// for each column
 if (!subWidgets[i+j].isHSizable)
 continue forRows;
 row.sizable[i / cols] = true;
 }
 }
 private:
-override void setColWidth (myIt i, wdim w, int dir) {
+override void setColWidth (size_t i, wdim w, int dir) {
-for (myIt j = 0; j < rows; ++j) {
+for (size_t j = 0; j < rows; ++j) {
 subWidgets[i + cols*j].setWidth (w, dir);
 }
 }
-override void setRowHeight (myIt j, wdim h, int dir) {
+override void setRowHeight (size_t j, wdim h, int dir) {
-for (myIt i = 0; i < cols; ++i) {
+for (size_t i = 0; i < cols; ++i) {
 subWidgets[i + cols*j].setHeight (h, dir);
 }
 }
 protected:
 // Data for resizing cols/rows:
 wdim dragX, dragY;	// coords where drag starts
 //END Col/row resizing callback
-myIt cols, rows;	// number of cells in grid
+size_t cols, rows;	// number of cells in grid
 wdim[] initWidths;  // see this / setInitialSize
 uint sADD_n = uint.max;	// param n of last setup call after setupAlignDimData has run
 bool useSpacing;	// add inter-row/col spacing?
 /* All widgets in the grid, by row. Order:  [ 0 1 ]
 *                                          [ 2 3 ] */
-//IChildWidget[] subWidgets;
+//IChildWidget[] subWidgets; (inherited from AParentWidget)
-AlignColumns col, row;
+AlignColumns col, row;	// aligners for cols and rows
+				// "rows" allocated in col and row; return value of *.addRows():
+size_t colR = size_t.max, rowR = size_t.max;
 }
 /**************************************************************************************************
 * Alignment device
 package class AlignColumns
 {
 /** Instance returned will be shared with any other widgets of same widgetID.
 *
 * Also ensures each widget sharing an instance expects the same number of columns. */
-static AlignColumns getInstance (widgetID id, myIt columns) {
+static AlignColumns getInstance (widgetID id, size_t columns) {
 AlignColumns* p = id in instances;
 if (p) {
-if (p.minWidth.length != columns)
+if (p.cols != columns)
 throw new GuiException ("AlignColumns: no. of columns varies between sharing widgets (code error)");
 //logger.trace ("Shared alignment for: "~id);
 return *p;
 } else {
 auto a = new AlignColumns (columns);
 /** Create an instance. After creation, the number of columns can only be changed by calling
 * reset.
 *
 * After creation, minimal widths should be set for all columns (minWidth) and
 * setWidths must be called before other functions are used. */
-this (myIt columns) {
+this (size_t columns) {
 	if (columns < 1)
 	    throw new GuiException("AlignColumns: created with <1 column (code error)");
 	minWidth.length = columns;
 	sizable.length = columns;
+cols = columns;
 }
 /** Like IChildWidget's setup; calls sADD delegates. */
 void setup (uint n, uint flags) {
 	if (n != setup_n) {
 	    setup_n = n;
 	    setupWidths = false;
-	    reset (minWidth.length);
+	    reset (cols);
 	    foreach (dg; sADD)
 		dg (n, flags);	// set flag 1
 	}
 }
 /** Reset all column information (only keep set callbacks).
 *
 * Widths should be set after calling, as on creation. */
-void reset (myIt columns) {
+void reset (size_t columns) {
 minWidth[] = 0;
 sizable[] = false;
 firstSizable = -1;
 lastSizable = -1;
+}
+/** Add num "rows" to the aligner. They start at the returned index r, thus the values in
+* minCellWidths to set are minCellWidths[cols*r..cols*(r+num)].
+*
+* Calling this function is necessary to allocate room in minCellWidths. */
+size_t addRows (size_t num) {
+size_t r = rows;
+rows += num;
+minCellWidths.length = cols*rows;
+return r;
 }
 /** Initialize widths, either from minWidths or from supplied list, checking validity.
 *
 * Also calculates first/lastSizable from sizable, overall minimal width and column positions.
 */
 void setWidths (wdim[] data = null) {
 	if (!setupWidths) {
 	    setupWidths = true;
+// Set minWidth
+assert (minCellWidths.length == rows * cols, "minCellWidths: bad length");
+for (size_t c = 0; c < cols; ++c)
+for (size_t r = 0; r < rows; ++r) {
+wdim mcw = minCellWidths[c+r*cols];
+if (minWidth[c] < mcw)
+minWidth[c] = mcw;
+}
+/* Calculate the minimal width of all columns plus spacing. */
+mw = spacing * cast(wdim)(cols - 1);
+foreach (imw; minWidth)
+mw += imw;
+// set width
 if (data || width) {	// use existing/external data: need to check validity
 if (data) {
-assert (data.length == minWidth.length, "setWidths called with bad data length (code error)");
+assert (data.length == cols, "setWidths called with bad data length (code error)");
 width = data.dup;	// data is shared by other widgets with same id so must be .dup'ed
 }
 foreach (i, m; minWidth) {
 if (!sizable[i] || width[i] < m)    // if width is fixed or less than minimum
 width[i] = m;
 }
 } else
 width = minWidth.dup;
-/* Calculate the minimal width of all columns plus spacing. */
-mw = spacing * cast(wdim)(minWidth.length - 1);
-foreach (imw; minWidth)
-mw += imw;
 genPositions;
 foreach (i,s; sizable) {
 if (s) {
 firstSizable = i;
 }
 }
 /** Add a callback to be called to notify changes in a column's width, and the sADD callback.
 */
-typeof(this) addCallbacks (void delegate (myIt,wdim,int) setCW, void delegate (uint,uint) sDg) {
+typeof(this) addCallbacks (void delegate (size_t,wdim,int) setCW, void delegate (uint,uint) sDg) {
 	assert (setCW && sDg, "AlignColumns.addCallbacks: null callback (code error)");
 setWidthCb ~= setCW;
 	sADD ~= sDg;
 return this;
 }
 /** Get the row/column of relative position l.
 *
 * returns:
 * -i if in space to left of col i, or i if on col i. */
-myDiff getCell (wdim l) {
+ptrdiff_t getCell (wdim l) {
 debug assert (width, "AlignColumns not initialized when getCell called (code error)");
-myDiff i = minWidth.length - 1;     // starting from right...
+ptrdiff_t i = cols - 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
-debug assert (i+1 < minWidth.length, "getCell: l >= total width (code error)");
+debug assert (i+1 < cols, "getCell: l >= total width (code error)");
 return -i - 1;                  // note: i might be 0 so cannot just return -i
 }
 return i;
 }
 }
 if (nw == w) return w;
 wdim diff = nw - w;
 if (firstSizable == -1)
-diff = adjustCellSizes (diff, minWidth.length-1, -1);
+diff = adjustCellSizes (diff, cols-1, -1);
 else
 diff = adjustCellSizes (diff, (dir == -1 ? lastSizable : firstSizable), dir);
 genPositions;
 debug if (nw != w) {
-logger.trace ("resizeWidth on {} to {} failed, new width: {}, diff {}, firstSizable {}, columns {}",cast(void*)this, nw,w, diff, firstSizable, minWidth.length);
+logger.trace ("resizeWidth on {} to {} failed, new width: {}, diff {}, firstSizable {}, columns {}",cast(void*)this, nw,w, diff, firstSizable, cols);
 /+ Also print column widths & positions:
 logger.trace ("resizeWidth to {} failed! Column dimensions and positions:",nw);
 foreach (i,w; width)
 logger.trace ("\t{}\t{}", w,pos[i]);+/
 }
 *
 * This and resizeCols are for moving dividers between cells. */
 bool findResizeCols (wdim l) {
 resizeU = -getCell (l);             // potential start for upward-resizes
 if (resizeU <= 0)
-return true;        // not on a space between cells
+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
+if (resizeU >= cols) {	// 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
+resizeU = -1;		// resizeU is tested to check whether resizes are possible
 return true;
 }
 }
 return false;                       // can resize
 /** Called when one of the cells in column col now has minimal width nmw.
 *
 * Enlarges column minimal width if necessary; tries to keep total width the same but returns
 * true if it cannot. */
-bool newMinWidth (myDiff col, wdim nmw) {
+bool newMinWidth (size_t col, size_t row, wdim nmw) {
-bool r = false;
+minCellWidths[col + row*cols] = nmw;
-if (minWidth[col] < nmw) {
+wdim nd = 0;	// negative diff to keep overall size constant if possible
+if (minWidth[col] < nmw) {	// increase minimal
 minWidth[col] = nmw;
-wdim d = nmw - width[col];
+nd = width[col] - nmw;	// negative diff
-if (d > 0 || (d < 0 && !sizable[col])) {
+} else if (minWidth[col] > nmw) {	// potentially decrease minimal
-d = -adjustCellSizes (d, col, -1);
+nmw = 0;
-if (d != adjustCellSizes (d, minWidth.length-1, -1))
+for (size_t r = 0; r < rows; ++r) {
-r = true;	// if unable to keep overall size the same
+wdim mcw = minCellWidths[col+r*cols];
-genPositions;
+if (nmw < mcw)
-}
+nmw = mcw;
-mw = spacing * cast(wdim)(minWidth.length - 1);
+}
-foreach (imw; minWidth)
+minWidth[col] = nmw;
-mw += imw;
+if (!sizable[col])
-}
+nd = width[col] - nmw;
-return r;
+} else
+return false;
+mw = spacing * cast(wdim)(cols - 1);
+foreach (imw; minWidth)
+mw += imw;
+if (nd != 0) {	// needs enlarging
+width[col] = nmw;
+foreach (dg; setWidthCb)
+dg(col, nmw, -1);
+if (lastSizable >= 0)
+	adjustCellSizes (nd, lastSizable, -1);	// doesn't necessarily resize exactly
+genPositions;
+}
+return true;
 }
 /* Generate position infomation for each column and set w. */
 private void genPositions () {
-pos.length = minWidth.length;
+pos.length = cols;
 w = 0;
 foreach (i, cw; width) {
 pos[i] = w;
 w += cw + spacing;
 /* 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
+*  start= index for col/row to start resizing on; assumed to be sizable
 *  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.
 *
+* Doesn't touch non-sizable columns (except start which is only assumed sizable).
+*
 * Note: Check variable used for start is valid before calling! If a non-sizable column's
 *  index is passed, this should get increased (if diff > 0) but not decreased.
 */
-private wdim adjustCellSizes (wdim diff, myDiff start, int incr)
+private wdim adjustCellSizes (wdim diff, ptrdiff_t start, int incr)
 in {
-assert (width.length == minWidth.length, "CellAlign.adjustCellSizes: width is null (code error)");
+assert (width.length == cols, "CellAlign.adjustCellSizes: width is invalid (code error)");
 // Most likely if passed negative when sizing is disabled:
-assert (start >= 0 && start < minWidth.length, "adjustCellSizes: invalid start");
+assert (start >= 0 && start < cols, "adjustCellSizes: invalid start");
 debug assert (incr == 1 || incr == -1, "adjustCellSizes: invalid incr");
 } body {
 debug scope(failure) logger.trace ("adjustCellSizes: failure");
-myDiff i = start;
+ptrdiff_t i = start;
 if (diff > 0) {             // increase size of first resizable cell
 width[i] += diff;
 foreach (dg; setWidthCb)
 dg(i, width[i], incr);
 }
 dg(i, width[i], incr);
 // rd is remainder to decrease by
 do {
 i += incr;
-if (i < 0 || i >= minWidth.length) {    // run out of next cells
+if (i < 0 || i >= cols) {	// run out of next cells
 diff -= rd; // still had rd left to decrease
 break aCSwhile;     // exception: Array index out of bounds
 }
 } while (!sizable[i])       // iterate again if row/col isn't resizable
 }
 // else no adjustment needed (diff == 0)
 return diff;
 }
-/** Minimal width for each column.
-*
+/** Minimal widths per cell.
-* Initialized to zero. Each class using this AlignColumns should, for each column, increase
+*
-* this value to the maximum of the minimal widths (in other words, set
+* Array of all cells, organised like GridLayoutWidget.subWidgets when representing columns,
-* minWidth[i] = max(minWidth[i], cell.minWidth) for each cell in column i). */
+* with rows and columns swapped when representing rows.
-wdim[]  minWidth;           // minimal widths (set by genCachedConstructionData)
+*
+* Then minWidth[i] = min(minCellWidths[i]) (where min acts on an array). */
+wdim[] minCellWidths;
 /** For each column i, sizable[i] is true if that column is resizable.
 *
 * Set along with minWidth before calling setWidths. */
 bool[]  sizable;            // set by genCachedConstructionData
 wdim[]  width;              // only adjusted within the class
 wdim[]  pos;                /// ditto
 wdim    spacing;            // used by genPositions (which cannot access the layout class's data)
 wdim    w,mw;               // current & minimal widths
 protected:
-myDiff  resizeD,            // resizeCols works down from this index (<0 if not resizing)
+/* Minimal width for each column.
+*
+* Set by setWidths. */
+wdim[]  minWidth;
+size_t  cols, rows;		// number of columns and rows (wrong way round when AlignColumns
+				// represents rows)
+ptrdiff_t  resizeD,            // resizeCols works down from this index (<0 if not resizing)
 resizeU;            // and up from this index
 /* indicies of the first/last resizable column (negative if none are resizable). */
-myDiff  firstSizable = -1, lastSizable = -1;  // set by calcFLSbl
+ptrdiff_t  firstSizable = -1, lastSizable = -1;  // set by calcFLSbl
 // Callbacks used to actually adjust a column's width:
-void delegate (myIt,wdim,int) setWidthCb[]; // set width of a column, with resize direction
+void delegate (size_t,wdim,int) setWidthCb[]; // set width of a column, with resize direction
 void delegate (uint,uint) sADD[];	// setupAlignDimData dlgs
 uint setup_n = uint.max;	// param n of last setup call
 bool setupWidths;		// setWidths has been run
 }
 debug invariant()
 {
 if (setupWidths) {
-assert (width.length == minWidth.length);
+assert (width.length == cols, "invariant: bad width length");
 wdim x = 0;
 foreach (i,w; width) {
-assert (minWidth[i] <= w);	// even when "not sizable", cols may get enlarged
+assert (minWidth[i] <= w, "invariant: min size not reached");	// even when "not sizable", cols may get enlarged
-assert (x == pos[i]);
+assert (x == pos[i], "invariant: position wrong");
 x += w + spacing;
 }
-assert (x - spacing == w);
+assert (x - spacing == w, "invariant: w is wrong");
-x = spacing * cast(wdim)(minWidth.length - 1);
+x = spacing * cast(wdim)(cols - 1);
 foreach (mw; minWidth)
 x += mw;
-assert (x == mw);
+assert (x == mw, "invariant: mw is wrong");
 }
 }
 debug (mdeUnitTest) unittest {
 bool throws (void delegate() dg) {
 assert (b.width[3] == 12);
 logger.info ("Unittest complete.");
 }
 }
-// Index types. Note that in some cases they need to hold negative values.
-// int is used for resizing direction (although ptrdiff_t would be more appropriate),
-// since the value must always be -1 or +1.
-alias size_t myIt;
-alias ptrdiff_t myDiff;

Mercurial > projects > mde

comparison mde/gui/widget/layout.d @ 124:a2ef6b549101