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

comparison mde/gui/widget/layout.d @ 58:d43523ed4b62

Included a wdim typedef for all variables to do with window position or size instead of just using int.

author	Diggory Hardy <diggory.hardy@gmail.com>
date	Sat, 14 Jun 2008 17:15:06 +0100
parents	03fa79a48c48
children	891211f034f2

comparison

equal deleted inserted replaced

-:9e1f05fbbcef
+:d43523ed4b62
 if (data.length < rows + cols) {    // data error; use defaults
 col.dupMin;
 row.dupMin;
 } else {                            // sufficient data
 lenUsed = rows+cols;
-col.setCheck (data[0..cols]);
+col.setCheck (cast(wdim[])data[0..cols]);
-row.setCheck (data[cols..lenUsed]);
+row.setCheck (cast(wdim[])data[cols..lenUsed]);
 }
 // Generate cached mutable data
 // Calculate column and row locations:
 int[] getMutableData () {
 int[] ret;
 foreach (widget; subWidgets)
 ret ~= widget.getMutableData;
-ret ~= col.width ~ row.width;
+return ret ~ cast(int[])col.width ~ cast(int[])row.width;
-return ret;
 }
 //END Creation & saving
 //BEGIN Size & position
 bool isWSizable () {
 bool isHSizable () {
 return row.firstSizable >= 0;
 }
 /* Calculates the minimal size from all rows and columns of widgets. */
-void getMinimalSize (out int mw, out int mh) {
+void getMinimalSize (out wdim mw, out wdim mh) {
 mw = this.mw;
 mh = this.mh;
 }
-void setWidth (int nw, int dir) {
+void setWidth (wdim nw, int dir) {
 if (nw == w) return;
 w += col.adjustCellSizes (nw - w, (dir == -1 ? col.lastSizable : col.firstSizable), dir);
 // Note: setPosition must be called after!
 }
-void setHeight (int nh, int dir) {
+void setHeight (wdim nh, int dir) {
 if (nh == h) return;
 h += row.adjustCellSizes (nh - h, (dir == -1 ? row.lastSizable : row.firstSizable), dir);
 // Note: setPosition must be called after!
 }
-void setPosition (int x, int y) {
+void setPosition (wdim x, wdim y) {
 this.x = x;
 this.y = y;
 foreach (i,widget; subWidgets)
 widget.setPosition (x + col.pos[i % cols], y + row.pos[i / cols]);
 }
 //END Size & position
 // Find the relevant widget.
-IWidget getWidget (int cx, int cy) {
+IWidget getWidget (wdim cx, wdim cy) {
 debug scope (failure)
 logger.warn ("getWidget: failure");
 // Find row/column:
 myDiff i = col.getCell (cx - x);
 myDiff j = row.getCell (cy - y);
 // On a subwidget; recurse call:
 return subWidgets[i + j*cols].getWidget (cx, cy);
 }
 // Resizing columns & rows
-void clickEvent (ushort cx, ushort cy, ubyte b, bool state) {
+void clickEvent (wdabs cx, wdabs cy, ubyte b, bool state) {
 debug scope (failure)
 logger.warn ("clickEvent: 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
 col.setColWidth = &setColWidth;
 row.setColWidth = &setRowHeight;
 // Calculate the minimal column and row sizes:
 // set length, making sure the arrays are initialised to zero:
-col.minWidth = new int[cols];
+col.minWidth = new wdim[cols];
-row.minWidth = new int[rows];
+row.minWidth = new wdim[rows];
-int ww, wh;     // sub-widget minimal sizes
+wdim ww, wh;     // sub-widget minimal sizes
 foreach (i,widget; subWidgets) {
 widget.getMinimalSize (ww, wh);
 // Increase dimensions if current minimal size is larger:
 myIt n = i % cols;	// column
 }
 // Calculate the overall minimal size, starting with the spacing:
 mh = window.renderer.layoutSpacing;	// use mh temporarily
-mw = mh * (cols - 1);
+mw = mh * cast(wdim)(cols - 1);
-mh *= (rows - 1);
+mh *= cast(wdim)(rows - 1);
 foreach (x; col.minWidth)		// add the column/row's dimensions
 mw += x;
 foreach (x; row.minWidth)
 mh += x;
 }
 }
 //END Cache calculation functions
-void setColWidth (myIt i, int w, int dir) {
+void setColWidth (myIt i, wdim w, int dir) {
 for (myIt j = 0; j < rows; ++j) {
 subWidgets[i + cols*j].setWidth (w, dir);
 }
 }
-void setRowHeight (myIt j, int h, int dir) {
+void setRowHeight (myIt j, wdim h, int dir) {
 for (myIt i = 0; i < cols; ++i) {
 subWidgets[i + cols*j].setHeight (h, dir);
 }
 }
 //BEGIN Col/row resizing callback
-void resizeCallback (ushort cx, ushort cy) {
+void resizeCallback (wdim cx, wdim cy) {
 col.resize (cx - dragX);
 row.resize (cy - dragY);
 // NOTE: all adjustments are relative; might be better if they were absolute?
 dragX = cx;
 foreach (i,widget; subWidgets)
 widget.setPosition (x + col.pos[i % cols],
 y + row.pos[i / cols]);
 window.requestRedraw;
 }
-bool endCallback (ushort cx, ushort cy, ubyte b, bool state) {
+bool endCallback (wdabs cx, wdabs cy, ubyte b, bool state) {
 if (b == 1 && state == false) {
 window.gui.removeCallbacks (cast(void*) this);
 return true;	// we've handled the up-click
 }
 return false;		// we haven't handled it
 }
 protected:
 // Data for resizing cols/rows:
-int dragX, dragY;	// coords where drag starts
+wdim dragX, dragY;	// coords where drag starts
 //END Col/row resizing callback
 myIt cols, rows;	// number of cells in grid
 * The purpose of this struct is mostly to unify functionality which must work the same on both
 * horizontal and vertical cell placement.
 *
 * Most notation corresponds to horizontal layout (columns), simply for easy of naming. */
 struct CellDimensions {
-int[] pos,	// relative position (cumulative width[i-1] plus spacing)
+wdim[] pos,	// relative position (cumulative width[i-1] plus spacing)
 width,	// current widths
 minWidth;	// minimal widths (set by genCachedConstructionData)
 bool[] sizable;	// true if col is resizable (set by genCachedConstructionData)
 myDiff firstSizable,	// first col which is resizable, negative if none
 lastSizable;	// as above, but last (set by genCachedConstructionData)
 myDiff resizeD,	// resize down from this index (<0 if not resizing)
 resizeU;	// and up from this index
-int spacing;	// used by genPositions (which cannot access the layout class's data)
+wdim spacing;	// used by genPositions (which cannot access the layout class's data)
 /* This is a delegate to a enclosing class's function, since:
 * a different implementation is needed for cols or rows
 * we're unable to access enclosing class members directly */
-void delegate (myIt,int,int) setColWidth;	// set width of a column, with resize direction
+void delegate (myIt,wdim,int) setColWidth;	// set width of a column, with resize direction
 void dupMin () {
 width = minWidth.dup;
 }
-void setCheck (int[] data) {
+void setCheck (wdim[] 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 () {
+wdim genPositions () {
 pos.length = minWidth.length;
-int x = 0;
+wdim 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 getCell (wdim 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])
 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) {
+bool findResize (wdim 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)
 *  The amount adjusted. This may be larger than diff, since cellD is clamped by cellDMin.
 *
 * 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.
 */
-int adjustCellSizes (int diff, myDiff start, int incr)
+wdim adjustCellSizes (wdim diff, myDiff start, int incr)
 in {
 // Could occur if adjust isn't called first, but this would be a code error:
 assert (width !is null, "adjustCellSizes: width is null");
 // Most likely if passed negative when sizing is disabled:
 assert (start >= 0 && start < minWidth.length, "adjustCellSizes: invalid start");
 if (diff > 0) {		// increase size of first resizable cell
 width[i] += diff;
 setColWidth (i, width[i], incr);
 }
 else if (diff < 0) {	// decrease
-int rd = diff;		// running diff
+wdim 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
 genPositions;
 return diff;
 }
-void resize (int diff) {
+void resize (wdim diff) {
 if (resizeU <= 0) return;
 // do shrinking first (in case we hit the minimum)
 if (diff >= 0) {
 diff = -adjustCellSizes (-diff, resizeU, 1);
 }
 }
 CellDimensions col, row;
 // 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),
+// int is used for resizing direction (although ptrdiff_t would be more appropriate),
 // since the value must always be -1 or +1 and int is smaller on X86_64.
 alias size_t myIt;
 alias ptrdiff_t myDiff;
 }

Mercurial > projects > mde

comparison mde/gui/widget/layout.d @ 58:d43523ed4b62