Mercurial > projects > dynamin
annotate dynamin/gui/layout.d @ 39:04d2867d335c
Fix possible incorrect extra space after the last control in a layout.
| author | Jordan Miner <jminer7@gmail.com> |
|---|---|
| date | Wed, 29 Jul 2009 23:27:41 -0500 |
| parents | 69df5369c5f7 |
| children | 735223842a85 |
| rev | line source |
|---|---|
| 0 | 1 // Written in the D programming language |
| 2 // www.digitalmars.com/d/ | |
| 3 | |
| 4 /* | |
| 5 * The contents of this file are subject to the Mozilla Public License Version | |
| 6 * 1.1 (the "License"); you may not use this file except in compliance with | |
| 7 * the License. You may obtain a copy of the License at | |
| 8 * http://www.mozilla.org/MPL/ | |
| 9 * | |
| 10 * Software distributed under the License is distributed on an "AS IS" basis, | |
| 11 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License | |
| 12 * for the specific language governing rights and limitations under the | |
| 13 * License. | |
| 14 * | |
| 15 * The Original Code is the Dynamin library. | |
| 16 * | |
| 17 * The Initial Developer of the Original Code is Jordan Miner. | |
| 18 * Portions created by the Initial Developer are Copyright (C) 2007-2009 | |
| 19 * the Initial Developer. All Rights Reserved. | |
| 20 * | |
| 21 * Contributor(s): | |
| 22 * Jordan Miner <jminer7@gmail.com> | |
| 23 * | |
| 24 */ | |
| 25 | |
| 26 module dynamin.gui.layout; | |
| 27 | |
| 28 import dynamin.all_gui; | |
| 29 import dynamin.gui.control; | |
| 30 import dynamin.all_painting; | |
| 31 import dynamin.core.string; | |
| 32 import tango.io.Stdout; | |
| 33 import dynamin.core.benchmark; | |
| 34 | |
| 35 // this is a temporary file to hold layout code until I figure out what | |
| 36 // files to put it in | |
| 37 | |
| 38 /* | |
| 39 Opera's find dialog: | |
| 40 | |
| 41 auto whatLabel = win.content.add(new Label("Find What")); | |
| 42 ... | |
| 43 | |
| 44 V( whatLabel | |
| 45 H( findBox findButton ) | |
| 46 H( V(wholeWordCheck caseCheck) ~ V(upRadio downRadio) ~) | |
| 47 H( ~ closeButton ) | |
| 48 ) | |
| 49 */ | |
| 50 | |
| 51 enum LayoutType { | |
| 52 None, Table, Control, Filler, Spacer | |
| 53 } | |
| 54 enum Elasticity { | |
| 55 No, Semi, Yes | |
| 56 } | |
| 57 struct LayoutGroup { | |
| 58 LayoutType type; | |
| 59 LayoutGroup* parent; | |
|
37
f9fea816b1fb
Correct a comment and remove an unused variable.
Jordan Miner <jminer7@gmail.com>
parents:
11
diff
changeset
|
60 LayoutGroup[] children; // used if type == LayoutType.Table |
| 0 | 61 Control control; // used if type == LayoutType.Control |
| 62 int numColumns; // used if type == LayoutType.Table | |
| 63 int numRows() { return children.length / numColumns; } | |
| 64 | |
| 65 bool cacheActive; | |
| 66 private Elasticity _elasticXCache, _elasticYCache; | |
| 67 private Size _bestSizeCache; | |
| 68 private int _baselineCache; | |
| 69 | |
| 70 // spacing variables | |
| 71 int spacing = 8; | |
| 72 static LayoutGroup opCall(LayoutType type, LayoutGroup* parent) { | |
| 73 LayoutGroup layout; | |
| 74 layout.type = type; | |
| 75 layout.parent = parent; | |
| 76 layout.children.length = 3; | |
| 77 layout.children.length = 0; | |
| 78 return layout; | |
| 79 } | |
| 80 | |
| 81 void setCache() { | |
| 82 for(int i = 0; i < children.length; ++i) // can't use foreach--copies | |
| 83 children[i].setCache(); | |
| 84 _elasticXCache = _elasticX; | |
| 85 _elasticYCache = _elasticY; | |
| 86 _bestSizeCache = _bestSize; | |
| 87 _baselineCache = _baseline; | |
| 88 cacheActive = true; | |
| 89 } | |
| 90 void clearCache() { | |
| 91 cacheActive = false; | |
| 92 for(int i = 0; i < children.length; ++i) // can't use foreach--copies | |
| 93 children[i].clearCache(); | |
| 94 } | |
| 95 Elasticity elasticX() { return cacheActive ? _elasticXCache : _elasticX; } | |
| 96 Elasticity elasticY() { return cacheActive ? _elasticYCache : _elasticY; } | |
| 97 Size bestSize() { return cacheActive ? _bestSizeCache : _bestSize; } | |
| 98 int baseline() { return cacheActive ? _baselineCache : _baseline; } | |
| 99 | |
| 100 //{{{ _elasticX() | |
| 101 private Elasticity _elasticX() { | |
| 102 switch(type) { | |
| 103 case LayoutType.Control: | |
| 104 return control.elasticX ? Elasticity.Yes : Elasticity.No; | |
| 105 case LayoutType.Table: | |
| 106 auto e = Elasticity.No; | |
| 107 foreach(layout; children) { | |
| 108 if(layout.elasticX > e) | |
| 109 e = layout.elasticX; | |
| 110 if(e == Elasticity.Yes) | |
| 111 return e; | |
| 112 } | |
| 113 return e; | |
| 114 case LayoutType.Filler: | |
|
38
69df5369c5f7
Fix filler to only be elastic in the direction of its parent.
Jordan Miner <jminer7@gmail.com>
parents:
37
diff
changeset
|
115 if(!parent || parent.numColumns > 1 || children.length == 1) |
|
69df5369c5f7
Fix filler to only be elastic in the direction of its parent.
Jordan Miner <jminer7@gmail.com>
parents:
37
diff
changeset
|
116 return Elasticity.Semi; |
|
69df5369c5f7
Fix filler to only be elastic in the direction of its parent.
Jordan Miner <jminer7@gmail.com>
parents:
37
diff
changeset
|
117 else |
|
69df5369c5f7
Fix filler to only be elastic in the direction of its parent.
Jordan Miner <jminer7@gmail.com>
parents:
37
diff
changeset
|
118 return Elasticity.No; |
| 0 | 119 case LayoutType.Spacer: |
| 120 return Elasticity.No; | |
| 121 } | |
| 122 } | |
| 123 //}}} | |
| 124 //{{{ _elasticY() | |
| 125 private Elasticity _elasticY() { | |
| 126 switch(type) { | |
| 127 case LayoutType.Control: | |
| 128 return control.elasticY ? Elasticity.Yes : Elasticity.No; | |
| 129 case LayoutType.Table: | |
| 130 auto e = Elasticity.No; | |
| 131 foreach(layout; children) { | |
| 132 if(layout.elasticY > e) | |
| 133 e = layout.elasticY; | |
| 134 if(e == Elasticity.Yes) | |
| 135 return e; | |
| 136 } | |
| 137 return e; | |
| 138 case LayoutType.Filler: | |
|
38
69df5369c5f7
Fix filler to only be elastic in the direction of its parent.
Jordan Miner <jminer7@gmail.com>
parents:
37
diff
changeset
|
139 if(!parent || parent.numRows > 1 || children.length == 1) |
|
69df5369c5f7
Fix filler to only be elastic in the direction of its parent.
Jordan Miner <jminer7@gmail.com>
parents:
37
diff
changeset
|
140 return Elasticity.Semi; |
|
69df5369c5f7
Fix filler to only be elastic in the direction of its parent.
Jordan Miner <jminer7@gmail.com>
parents:
37
diff
changeset
|
141 else |
|
69df5369c5f7
Fix filler to only be elastic in the direction of its parent.
Jordan Miner <jminer7@gmail.com>
parents:
37
diff
changeset
|
142 return Elasticity.No; |
| 0 | 143 case LayoutType.Spacer: |
| 144 return Elasticity.No; | |
| 145 } | |
| 146 } | |
| 147 //}}} | |
| 148 | |
| 149 //{{{ _bestSize() | |
| 150 private Size _bestSize() { | |
| 151 switch(type) { | |
| 152 case LayoutType.Control: | |
| 153 return control.bestSize; | |
| 154 case LayoutType.Table: | |
| 155 scope colsInfo = new ColRowInfo[numColumns]; | |
| 156 scope rowsInfo = new ColRowInfo[numRows]; | |
| 157 TableInfo info; | |
| 158 getTableSizes(colsInfo, rowsInfo, info); | |
| 159 return info.bestSize; | |
| 160 case LayoutType.Filler: | |
| 161 case LayoutType.Spacer: | |
| 162 return Size(0, 0); | |
| 163 } | |
| 164 } | |
| 165 //}}} | |
| 166 //{{{ _baseline() | |
| 167 private int _baseline() { | |
| 168 switch(type) { | |
| 169 case LayoutType.Control: | |
| 170 return control.baseline; | |
| 171 case LayoutType.Table: | |
| 172 case LayoutType.Filler: | |
| 173 case LayoutType.Spacer: | |
| 174 return 0; | |
| 175 } | |
| 176 } | |
| 177 //}}} | |
| 178 | |
| 179 //{{{ layout() | |
| 180 void layout(Rect rect) { | |
| 181 switch(type) { | |
| 182 case LayoutType.Control: | |
| 183 control.location = Point(rect.x, rect.y); | |
| 184 control.size = Size(rect.width, rect.height); | |
| 185 return; | |
| 186 case LayoutType.Table: | |
| 187 scope colsInfo = new ColRowInfo[numColumns]; | |
| 188 scope rowsInfo = new ColRowInfo[numRows]; | |
| 189 TableInfo info; | |
| 190 getTableSizes(colsInfo, rowsInfo, info); | |
| 191 | |
| 192 real extraWidth = rect.width - bestSize.width; | |
| 193 real extraHeight = rect.height - bestSize.height; | |
| 194 | |
| 195 void distExtra(ref real extra, ref ColRowInfo info, | |
| 196 ref real totalElastic, ref int semis, Elasticity e) { | |
| 197 if(info.elastic == Elasticity.No || extra <= 0) | |
| 198 return; | |
| 199 if(e == Elasticity.Semi && | |
| 200 info.elastic == Elasticity.Semi) { | |
| 201 auto thisExtra = extra / semis; | |
| 202 extra -= thisExtra; | |
| 203 semis--; | |
| 204 info.bestSize += thisExtra; | |
| 205 } else if(e == Elasticity.Yes && | |
| 206 info.elastic == Elasticity.Yes) { | |
| 207 auto thisExtra = extra * info.bestSize/totalElastic; | |
| 208 extra -= thisExtra; | |
| 209 totalElastic -= info.bestSize; // subtract original size | |
| 210 info.bestSize += thisExtra; | |
| 211 } | |
| 212 } | |
| 213 real y = 0; | |
| 214 for(int row = 0; row < numRows; ++row) { // go over each row | |
| 215 distExtra(extraHeight, rowsInfo[row], info.elasticHeight, info.semiRows, elasticY); | |
| 216 | |
| 217 real x = 0; | |
| 218 for(int col = 0; col < numColumns; ++col) { | |
| 219 distExtra(extraWidth, colsInfo[col], info.elasticWidth, info.semiColumns, elasticX); | |
| 220 | |
| 221 auto layout = children[row * numColumns + col]; | |
| 222 | |
| 223 Rect r = Point(x, y) + layout.bestSize; | |
| 224 | |
| 225 if(layout.baseline > 0) | |
| 226 r.y = r.y + rowsInfo[row].baseline - layout.baseline; | |
| 227 if(layout.elasticX) | |
| 228 r.width = colsInfo[col].bestSize; | |
| 229 if(layout.elasticY) | |
| 230 r.height = rowsInfo[row].bestSize; | |
| 231 | |
| 232 layout.layout(r + Point(rect.x, rect.y)); | |
| 233 | |
| 234 x += colsInfo[col].bestSize + | |
| 235 (colsInfo[col].filler ? 0 : spacing); | |
| 236 } | |
| 237 y += rowsInfo[row].bestSize + | |
| 238 (rowsInfo[row].filler ? 0 : spacing); | |
| 239 } | |
| 240 return; | |
| 241 case LayoutType.Filler: | |
| 242 case LayoutType.Spacer: | |
| 243 return; | |
| 244 } | |
| 245 } | |
| 246 //}}} | |
| 247 | |
| 248 struct ColRowInfo { | |
| 249 real bestSize = 0; // large enough to hold the largest control | |
| 250 Elasticity elastic = Elasticity.No; | |
| 251 bool filler = true; // if the entire column/row is filler | |
| 252 real baseline; // only applies to rows: max baseline in row | |
| 253 } | |
| 254 struct TableInfo { | |
| 255 // number of semi-elastic columns/rows | |
| 256 int semiColumns = 0; int semiRows = 0; | |
| 257 // the sum of fully elastic width/height, not including semi | |
| 258 real elasticWidth = 0, elasticHeight = 0; | |
| 259 Size bestSize = Size(0, 0); | |
| 260 } | |
| 261 //{{{ getTableSizes() | |
| 262 // Fills in the passed in array with the column and row sizes, as well | |
| 263 // as whether they are elastic. The passed in arrays must be the right | |
| 264 // sizes. They may be stack allocated. The table best size does | |
| 265 // including spacing, but column and row best sizes do not. | |
| 266 private void getTableSizes(ColRowInfo[] colsInfo, ColRowInfo[] rowsInfo, ref TableInfo info) { | |
| 267 assert(children.length % numColumns == 0); | |
| 268 assert(type == LayoutType.Table); | |
| 269 | |
| 270 assert(colsInfo.length == numColumns); | |
| 271 assert(rowsInfo.length == numRows); | |
| 272 | |
|
37
f9fea816b1fb
Correct a comment and remove an unused variable.
Jordan Miner <jminer7@gmail.com>
parents:
11
diff
changeset
|
273 real max = 0; |
| 0 | 274 LayoutGroup* l; |
| 275 | |
|
39
04d2867d335c
Fix possible incorrect extra space after the last control in a layout.
Jordan Miner <jminer7@gmail.com>
parents:
38
diff
changeset
|
276 bool prevNonFiller = false; |
| 0 | 277 int sp = 0; |
| 278 for(int col = 0; col < numColumns; ++col) { // go down each column | |
| 279 for(int row = 0; row < numRows; ++row) { | |
| 280 l = &children[row * numColumns + col]; | |
| 281 max = l.bestSize.width > max ? l.bestSize.width : max; | |
| 282 if(l.elasticX > colsInfo[col].elastic) | |
| 283 colsInfo[col].elastic = l.elasticX; | |
| 284 if(l.type != LayoutType.Filler) | |
| 285 colsInfo[col].filler = false; | |
| 286 } | |
| 287 colsInfo[col].bestSize = max; | |
| 288 if(colsInfo[col].elastic == Elasticity.Yes) | |
| 289 info.elasticWidth += max; | |
| 290 else if(colsInfo[col].elastic == Elasticity.Semi) | |
| 291 info.semiColumns++; | |
|
39
04d2867d335c
Fix possible incorrect extra space after the last control in a layout.
Jordan Miner <jminer7@gmail.com>
parents:
38
diff
changeset
|
292 // this won't add spacing to the first non-filler |
|
04d2867d335c
Fix possible incorrect extra space after the last control in a layout.
Jordan Miner <jminer7@gmail.com>
parents:
38
diff
changeset
|
293 sp = (!colsInfo[col].filler && prevNonFiller) ? spacing : 0; |
| 0 | 294 info.bestSize.width = info.bestSize.width + sp + max; |
|
39
04d2867d335c
Fix possible incorrect extra space after the last control in a layout.
Jordan Miner <jminer7@gmail.com>
parents:
38
diff
changeset
|
295 prevNonFiller = !colsInfo[col].filler ? true : prevNonFiller ; |
| 0 | 296 max = 0; |
| 297 } | |
| 298 | |
|
39
04d2867d335c
Fix possible incorrect extra space after the last control in a layout.
Jordan Miner <jminer7@gmail.com>
parents:
38
diff
changeset
|
299 prevNonFiller = false; |
| 0 | 300 real maxBl = 0; |
| 301 sp = 0; | |
| 302 for(int row = 0; row < numRows; ++row) { // go over each row | |
| 303 for(int col = 0; col < numColumns; ++col) { | |
| 304 l = &children[row * numColumns + col]; | |
| 305 max = l.bestSize.height > max ? l.bestSize.height : max; | |
| 306 maxBl = l.baseline > maxBl ? l.baseline : maxBl; | |
| 307 if(l.elasticY > rowsInfo[row].elastic) | |
| 308 rowsInfo[row].elastic = l.elasticY; | |
| 309 if(l.type != LayoutType.Filler) | |
| 310 rowsInfo[row].filler = false; | |
| 311 } | |
| 312 rowsInfo[row].bestSize = max; | |
| 313 rowsInfo[row].baseline = maxBl; | |
| 314 if(rowsInfo[row].elastic == Elasticity.Yes) | |
| 315 info.elasticHeight += max; | |
| 316 else if(rowsInfo[row].elastic == Elasticity.Semi) | |
| 317 info.semiRows++; | |
|
39
04d2867d335c
Fix possible incorrect extra space after the last control in a layout.
Jordan Miner <jminer7@gmail.com>
parents:
38
diff
changeset
|
318 // this won't add spacing to the first non-filler |
|
04d2867d335c
Fix possible incorrect extra space after the last control in a layout.
Jordan Miner <jminer7@gmail.com>
parents:
38
diff
changeset
|
319 sp = (!rowsInfo[row].filler && prevNonFiller) ? spacing : 0; |
| 0 | 320 info.bestSize.height = info.bestSize.height + sp + max; |
|
39
04d2867d335c
Fix possible incorrect extra space after the last control in a layout.
Jordan Miner <jminer7@gmail.com>
parents:
38
diff
changeset
|
321 prevNonFiller = !rowsInfo[row].filler ? true : prevNonFiller ; |
| 0 | 322 max = maxBl = 0; |
| 323 } | |
| 324 } | |
| 325 //}}} | |
| 326 } | |
| 327 | |
| 328 //{{{ LayoutPanel class | |
| 329 class LayoutPanel : Panel { | |
| 330 LayoutGroup root; | |
| 331 LayoutGroup* current; | |
| 332 void startLayout(int ncolumns) { | |
| 333 if(current is null) { | |
| 334 root = LayoutGroup(LayoutType.Table, null); | |
| 335 root.numColumns = ncolumns; | |
| 336 current = &root; | |
| 337 return; | |
| 338 } | |
| 339 current.children.length = current.children.length+1; | |
| 340 current.children[$-1] = LayoutGroup(LayoutType.Table, current); | |
| 341 current.children[$-1].numColumns = ncolumns; | |
| 342 current = ¤t.children[$-1]; | |
| 343 } | |
| 344 void endLayout() { | |
| 345 current = current.parent; | |
| 346 } | |
| 347 override void add(Control c) { | |
| 348 if(current is null) | |
| 349 throw new Exception("Cannot add a control until a layout is started"); | |
| 350 current.children.length = current.children.length+1; | |
| 351 current.children[$-1] = LayoutGroup(LayoutType.Control, current); | |
| 352 current.children[$-1].control = c; | |
| 353 super.add(c); | |
| 354 } | |
| 355 void addFiller() { | |
| 356 current.children.length = current.children.length+1; | |
| 357 current.children[$-1] = LayoutGroup(LayoutType.Filler, current); | |
| 358 } | |
| 359 void addSpacer() { | |
| 360 current.children.length = current.children.length+1; | |
| 361 current.children[$-1] = LayoutGroup(LayoutType.Spacer, current); | |
| 362 } | |
| 363 | |
| 364 override Size bestSize() { | |
| 365 return root.bestSize + Size(root.spacing*2, root.spacing*2); | |
| 366 } | |
| 367 override bool elasticX() { return root.elasticX == Elasticity.Yes; } | |
| 368 override bool elasticY() { return root.elasticY == Elasticity.Yes; } | |
| 369 override void layout() { | |
| 370 //benchmarkAndWrite("layout", { | |
| 371 root.setCache(); | |
| 372 int sp = root.spacing; | |
| 373 root.layout(Rect(sp, sp, width-2*sp, height-2*sp)); | |
| 374 root.clearCache(); | |
| 375 //}); | |
| 376 } | |
| 377 } | |
| 378 //}}} | |
| 379 | |
| 380 //{{{ createLayout() etc. | |
| 381 /** | |
| 382 * Note: if you do this: | |
| 383 * ----- | |
| 384 * char[] s = createLayout("V( b1 H(b2 b3) )"); | |
| 385 * ----- | |
| 386 * Then the program will crash when compiled with the -release flag. (I am | |
| 387 * pretty sure it is a DMD bug, but I don't have time to make a testcase | |
| 388 * for a bug that does not bother me.) This will work correctly: | |
| 389 * ----- | |
| 390 * const char[] s = createLayout("V( b1 H(b2 b3) )"); | |
| 391 * ----- | |
| 392 * Because then the function is interpreted at compile time with CTFE. | |
| 393 */ | |
| 394 string createLayout(string layout) { | |
| 395 string code = "delegate LayoutPanel() {\n"; | |
| 396 code ~= "auto panel = new LayoutPanel;\n"; | |
| 397 assert(getToken(layout) == "H" || getToken(layout) == "V" || | |
| 398 getToken(layout) == "T", "layout type 'H', 'V', or 'T' expected"); | |
| 399 code ~= parseLayout(layout); | |
| 400 code ~= "return panel;\n"; | |
| 401 code ~= "}()"; | |
| 402 return code; | |
| 403 } | |
| 404 | |
| 405 void skipWS(ref string str) { | |
| 406 int i = 0; | |
| 407 while(" \t\n\r\v\f".contains(str[i])) | |
| 408 i++; | |
| 409 str = str[i..$]; | |
| 410 } | |
| 411 // advances to the next token and returns it | |
| 412 string nextToken(ref string str) { | |
| 413 skipWS(str); | |
| 414 str = str[getToken(str).length..$]; | |
| 415 return getToken(str); | |
| 416 } | |
| 417 // returns H or V or ( or ) or myControl | |
| 418 // gets the current token | |
| 419 string getToken(string str) { | |
| 420 string idChars = | |
| 421 "_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; | |
| 422 | |
| 423 // TODO: // for line comments? | |
| 424 skipWS(str); | |
|
11
df1c8e659b75
Change layout language to use * for filler and ~ for spacing. Ticket #24
Jordan Miner <jminer7@gmail.com>
parents:
0
diff
changeset
|
425 if("()[]*~".contains(str[0])) { |
| 0 | 426 return str[0..1]; |
| 427 } else if(idChars.contains(str[0])) { | |
| 428 int i = 1; | |
| 429 while(idChars.contains(str[i])) | |
| 430 i++; | |
| 431 return str[0..i]; | |
| 432 } else { | |
| 433 assert(0, "unknown character: " ~ str[0]); | |
| 434 } | |
| 435 } | |
| 436 | |
| 437 // {{{ copied from Phobos | |
| 438 char[] ctfeUintToString(uint u) { | |
| 439 char[uint.sizeof * 3] buffer = void; | |
| 440 int ndigits; | |
| 441 char[] result; | |
| 442 char[] digits = "0123456789"; | |
| 443 | |
| 444 ndigits = 0; | |
| 445 if (u < 10) | |
| 446 // Avoid storage allocation for simple stuff | |
| 447 result = digits[u .. u + 1]; | |
| 448 else | |
| 449 { | |
| 450 while (u) | |
| 451 { | |
| 452 uint c = (u % 10) + '0'; | |
| 453 u /= 10; | |
| 454 ndigits++; | |
| 455 buffer[buffer.length - ndigits] = cast(char)c; | |
| 456 } | |
| 457 result = new char[ndigits]; | |
| 458 result[] = buffer[buffer.length - ndigits .. buffer.length]; | |
| 459 } | |
| 460 return result; | |
| 461 } | |
| 462 uint ctfeStringToUint(char[] s) | |
| 463 { | |
| 464 int length = s.length; | |
| 465 | |
| 466 if (!length) | |
| 467 return 0; | |
| 468 | |
| 469 uint v = 0; | |
| 470 | |
| 471 for (int i = 0; i < length; i++) | |
| 472 { | |
| 473 char c = s[i]; | |
| 474 if (c >= '0' && c <= '9') | |
| 475 { | |
| 476 if (v < uint.max/10 || (v == uint.max/10 && c <= '5')) | |
| 477 v = v * 10 + (c - '0'); | |
| 478 else | |
| 479 return 0; | |
| 480 } | |
| 481 else | |
| 482 return 0; | |
| 483 } | |
| 484 return v; | |
| 485 } | |
| 486 //}}} | |
| 487 | |
| 488 uint parseBody(ref string layout, ref string bcode) { | |
| 489 uint count = 0; | |
| 490 assert(nextToken(layout) == "(", "open parenthesis expected"); | |
| 491 while(nextToken(layout) != ")") { | |
|
11
df1c8e659b75
Change layout language to use * for filler and ~ for spacing. Ticket #24
Jordan Miner <jminer7@gmail.com>
parents:
0
diff
changeset
|
492 if(getToken(layout) == "*") |
| 0 | 493 bcode = bcode ~ "panel.addFiller();\n"; |
|
11
df1c8e659b75
Change layout language to use * for filler and ~ for spacing. Ticket #24
Jordan Miner <jminer7@gmail.com>
parents:
0
diff
changeset
|
494 else if(getToken(layout) == "~") |
| 0 | 495 bcode = bcode ~ "panel.addSpacer();\n"; |
| 496 else | |
| 497 bcode = bcode ~ parseLayout(layout); | |
| 498 count++; | |
| 499 } | |
| 500 bcode = bcode ~ "panel.endLayout();\n"; | |
| 501 return count; | |
| 502 } | |
| 503 | |
| 504 string parseLayout(ref string layout) { | |
| 505 string code = ""; | |
| 506 | |
| 507 if(getToken(layout) == "H") { | |
| 508 string bodyCode; | |
| 509 auto count = parseBody(layout, bodyCode); | |
| 510 code ~= "panel.startLayout(" ~ ctfeUintToString(count) ~ ");\n"; | |
| 511 code ~= bodyCode; | |
| 512 } else if(getToken(layout) == "V") { | |
| 513 code ~= "panel.startLayout(1);\n"; | |
| 514 parseBody(layout, code); | |
| 515 } else if(getToken(layout) == "T") { | |
| 516 assert(nextToken(layout) == "[", "open bracket expected"); | |
| 517 nextToken(layout); | |
| 518 assert("0123456789".contains(getToken(layout)[0]), | |
| 519 "number of table columns expected"); | |
| 520 uint columns = ctfeStringToUint(getToken(layout)); | |
| 521 code ~= "panel.startLayout(" ~ getToken(layout) ~ ");\n"; | |
| 522 assert(nextToken(layout) == "]", "close bracket expected"); | |
| 523 assert(parseBody(layout, code) % columns == 0, | |
| 524 "number of controls must be a multiple of number of columns"); | |
| 525 } else { | |
| 526 code ~= "panel.add(" ~ getToken(layout) ~ ");\n"; | |
| 527 } | |
| 528 | |
| 529 return code; | |
| 530 } | |
| 531 | |
| 532 //{{{ parser tests | |
| 533 static assert(createLayout("H()") != "not evaluatable at compile time"); | |
| 534 //pragma(msg, createLayout("V()")); | |
| 535 | |
| 536 static assert(createLayout("V(c1 c2)") == | |
| 537 `delegate LayoutPanel() { | |
| 538 auto panel = new LayoutPanel; | |
| 539 panel.startLayout(1); | |
| 540 panel.add(c1); | |
| 541 panel.add(c2); | |
| 542 panel.endLayout(); | |
| 543 return panel; | |
| 544 }()`); | |
|
11
df1c8e659b75
Change layout language to use * for filler and ~ for spacing. Ticket #24
Jordan Miner <jminer7@gmail.com>
parents:
0
diff
changeset
|
545 static assert(createLayout("V(c1 * c2 H(c3 ~) c4)") == |
| 0 | 546 `delegate LayoutPanel() { |
| 547 auto panel = new LayoutPanel; | |
| 548 panel.startLayout(1); | |
| 549 panel.add(c1); | |
| 550 panel.addFiller(); | |
| 551 panel.add(c2); | |
| 552 panel.startLayout(2); | |
| 553 panel.add(c3); | |
| 554 panel.addSpacer(); | |
| 555 panel.endLayout(); | |
| 556 panel.add(c4); | |
| 557 panel.endLayout(); | |
| 558 return panel; | |
| 559 }()`); | |
| 560 static assert(createLayout("V( c1 T[2](c2 c3) c4 )") == | |
| 561 `delegate LayoutPanel() { | |
| 562 auto panel = new LayoutPanel; | |
| 563 panel.startLayout(1); | |
| 564 panel.add(c1); | |
| 565 panel.startLayout(2); | |
| 566 panel.add(c2); | |
| 567 panel.add(c3); | |
| 568 panel.endLayout(); | |
| 569 panel.add(c4); | |
| 570 panel.endLayout(); | |
| 571 return panel; | |
| 572 }()`); | |
| 573 //}}} | |
| 574 | |
| 575 //}}} | |
| 576 | |
| 577 unittest { | |
| 578 // TODO: set to basic theme | |
| 579 // test a few basic layouts and verify pixel locations and sizes | |
| 580 } | |
| 581 |