]> git.mxchange.org Git - flightgear.git/blob - src/GUI/layout.cxx
Finish what was committed in a broken state yesterday.
[flightgear.git] / src / GUI / layout.cxx
1 #include "layout.hxx"
2
3 // This file contains the actual layout engine.  It has no dependence
4 // on outside libraries; see layout-props.cxx for the glue code.
5
6 // Note, property names with leading double-underscores (__bx, etc...)
7 // are debugging information, and can be safely removed.
8
9 const int DEFAULT_PADDING = 2;
10
11 int LayoutWidget::UNIT = 5;
12
13 bool LayoutWidget::eq(const char* a, const char* b)
14 {
15     while(*a && (*a == *b)) { a++; b++; }
16     return *a == *b;
17 }
18
19 // Normal widgets get a padding of 4 pixels.  Layout groups shouldn't
20 // have visible padding by default, except for top-level dialog groups
21 // which need to leave two pixels for the puFrame's border.  This
22 // value can, of course, be overriden by the parent groups
23 // <default-padding> property, or per widget with <padding>.
24 int LayoutWidget::padding()
25 {
26     int pad = isType("group") ? 0 : 4;
27     // As comments above note,  this was being set to 2.  For some
28     // reason this causes the dialogs to shrink on subsequent pops
29     // so for now we'll make "dialog" padding 0.
30     if(isType("dialog")) pad = 0;
31     if(hasParent() && parent().hasField("default-padding"))
32         pad = parent().getNum("default-padding");
33     if(hasField("padding"))
34         pad = getNum("padding");
35     return pad;
36 }
37
38 void LayoutWidget::calcPrefSize(int* w, int* h)
39 {
40     *w = *h = 0; // Ask for nothing by default
41
42     int legw = stringLength(getStr("legend"));
43     int labw = stringLength(getStr("label"));
44
45     if(isType("dialog") || isType("group")) {
46         if(!hasField("layout")) {
47             // Legacy support for groups without layout managers.
48             if(hasField("width")) *w = getNum("width");
49             if(hasField("height")) *h = getNum("height");
50         } else {
51             const char* layout = getStr("layout");
52             if     (eq(layout, "hbox" )) doHVBox(false, false, w, h);
53             else if(eq(layout, "vbox" )) doHVBox(false, true, w, h);
54             else if(eq(layout, "table")) doTable(false, w, h);
55         }
56     } else if (isType("text")) {
57         *w = labw;
58         *h = 4*UNIT; // FIXME: multi line height?
59     } else if (isType("button")) {
60         *w = legw + 6*UNIT + (labw ? labw + UNIT : 0);
61         *h = 6*UNIT;
62     } else if (isType("checkbox") || isType("radio")) {
63         *w = 3*UNIT + (labw ? (3*UNIT + labw) : 0);
64         *h = 3*UNIT;
65     } else if (isType("input") || isType("combo") || isType("select")) {
66         *w = 17*UNIT;
67         *h = 6*UNIT;
68     } else if (isType("slider")) {
69         *w = *h = 17*UNIT;
70         if(getBool("vertical")) *w = 4*UNIT;
71         else                    *h = 4*UNIT;
72     } else if (isType("list") || isType("airport-list") || isType("dial")) {
73         *w = *h = 12*UNIT;
74     }
75
76     // Throw it all out if the user specified a fixed preference
77     if(hasField("pref-width"))  *w = getNum("pref-width");
78     if(hasField("pref-height")) *h = getNum("pref-height");
79
80     // And finally correct for cell padding
81     int pad = 2*padding();
82     *w += pad;
83     *h += pad;
84
85     // Store what we calculated
86     setNum("__pw", *w);
87     setNum("__ph", *h);
88 }
89
90 // Set up geometry such that the widget lives "inside" the specified 
91 void LayoutWidget::layout(int x, int y, int w, int h)
92 {
93     setNum("__bx", x);
94     setNum("__by", y);
95     setNum("__bw", w);
96     setNum("__bh", h);
97
98     // Correct for padding.
99     int pad = padding();
100     x += pad;
101     y += pad;
102     w -= 2*pad;
103     h -= 2*pad;
104
105     int prefw = 0, prefh = 0;
106     calcPrefSize(&prefw, &prefh);
107     prefw -= 2*pad;
108     prefh -= 2*pad;
109
110     // "Parent Set" values override widget preferences
111     if(hasField("_psw")) prefw = getNum("_psw");
112     if(hasField("_psh")) prefh = getNum("_psh");
113
114     bool isGroup = isType("dialog") || isType("group");
115
116     // Correct our box for alignment.  The values above correspond to
117     // a "fill" alignment.
118     const char* halign = isGroup ? "fill" : "center";
119     if(hasField("halign")) halign = getStr("halign");
120     if(eq(halign, "left")) {
121         w = prefw;
122     } else if(eq(halign, "right")) {
123         x += w - prefw;
124         w = prefw;
125     } else if(eq(halign, "center")) {
126         x += (w - prefw)/2;
127         w = prefw;
128     }
129     const char* valign = isGroup ? "fill" : "center";
130     if(hasField("valign")) valign = getStr("valign");
131     if(eq(valign, "bottom")) {
132         h = prefh;
133     } else if(eq(valign, "top")) {
134         y += h - prefh;
135         h = prefh;
136     } else if(eq(valign, "center")) {
137         y += (h - prefh)/2;
138         h = prefh;
139     }
140
141     // PUI widgets interpret their size differently depending on
142     // type, so diddle the values as needed to fit the widget into
143     // the x/y/w/h box we have calculated.
144     if (isType("text")) {
145         // puText labels are layed out to the right of the box, so
146         // zero the width.
147         w = 0;
148     } else if (isType("input") || isType("combo") || isType("select")) {
149         // Fix the height to a constant
150         y += (h - 6*UNIT) / 2;
151         h = 6*UNIT;
152     } else if (isType("checkbox") || isType("radio")) {
153         // The PUI dimensions are of the check area only.  Center it
154         // on the left side of our box.
155         y += (h - 3*UNIT) / 2;
156         w = h = 3*UNIT;
157     } else if (isType("slider")) {
158         // Fix the thickness to a constant
159         if(getBool("vertical")) { x += (w-4*UNIT)/2; w = 4*UNIT; }
160         else                    { y += (h-4*UNIT)/2; h = 4*UNIT; }
161     }
162
163     // Set out output geometry
164     setNum("x", x);
165     setNum("y", y);
166     setNum("width", w);
167     setNum("height", h);
168
169     // Finally, if we are ourselves a layout object, do the actual layout.
170     if(isGroup && hasField("layout")) {
171         const char* layout = getStr("layout");
172         if     (eq(layout, "hbox" )) doHVBox(true, false);
173         else if(eq(layout, "vbox" )) doHVBox(true, true);
174         else if(eq(layout, "table")) doTable(true);
175     }
176 }
177
178 // Convention: the "A" cooridinate refers to the major axis of the
179 // container (width, for an hbox), "B" is minor.
180 void LayoutWidget::doHVBox(bool doLayout, bool vertical, int* w, int* h)
181 {
182     int nc = nChildren();
183     int* prefA = doLayout ? new int[nc] : 0;
184     int i, totalA = 0, maxB = 0, nStretch = 0;
185     int nEq = 0, eqA = 0, eqB = 0, eqTotalA = 0;
186     for(i=0; i<nc; i++) {
187         LayoutWidget child = getChild(i);
188         int a, b;
189         child.calcPrefSize(vertical ? &b : &a, vertical ? &a : &b);
190         if(doLayout) prefA[i] = a;
191         totalA += a;
192         if(b > maxB) maxB = b;
193         if(child.getBool("stretch")) {
194             nStretch++;
195         } else if(child.getBool("equal")) {
196             int pad = child.padding();
197             nEq++;
198             eqTotalA += a - 2*pad;
199             if(a-2*pad > eqA) eqA = a - 2*pad;
200             if(b-2*pad > eqB) eqB = b - 2*pad;
201         }
202     }
203     if(nStretch == 0) nStretch = nc;
204     totalA += nEq * eqA - eqTotalA; 
205
206     if(!doLayout) {
207         if(vertical) { *w = maxB;   *h = totalA; }
208         else         { *w = totalA; *h = maxB; }
209         return;
210     }
211
212     int currA = 0;
213     int availA = getNum(vertical ? "height" : "width");
214     int availB = getNum(vertical ? "width" : "height");
215     bool stretchAll = nStretch == nc ? true : false;
216     int stretch = availA - totalA;
217     if(stretch < 0) stretch = 0;
218     for(i=0; i<nc; i++) {
219         // Swap the child order for vertical boxes, so we lay out
220         // from top to bottom instead of along the cartesian Y axis.
221         int idx = vertical ? (nc-i-1) : i;
222         LayoutWidget child = getChild(idx);
223         if(child.getBool("equal")) {
224             int pad = child.padding();
225             prefA[idx] = eqA + 2*pad;
226             // Use "parent set" values to communicate the setting to
227             // the child.
228             child.setNum(vertical ? "_psh" : "_psw", eqA);
229             child.setNum(vertical ? "_psw" : "_psh", eqB);
230         }
231         if(stretchAll || child.getBool("stretch")) {
232             int chunk = stretch / nStretch;
233             stretch -= chunk;
234             nStretch--;
235             prefA[idx] += chunk;
236             child.setNum("__stretch", chunk);
237         }
238         if(vertical) child.layout(    0, currA,   availB, prefA[idx]);
239         else         child.layout(currA,     0, prefA[idx],   availB);
240         currA += prefA[idx];
241     }
242
243     delete[] prefA;
244 }
245
246 struct TabCell {
247     TabCell() {}
248     LayoutWidget child;
249     int w, h, row, col, rspan, cspan;
250 };
251
252 void LayoutWidget::doTable(bool doLayout, int* w, int* h)
253 {
254     int i, j, nc = nChildren();
255     TabCell* children = new TabCell[nc];
256     
257     // Pass 1: initialize bookeeping structures
258     int rows = 0, cols = 0;
259     for(i=0; i<nc; i++) {
260         TabCell* cell = &children[i];
261         cell->child = getChild(i);
262         cell->child.calcPrefSize(&cell->w, &cell->h);
263         cell->row = cell->child.getNum("row");
264         cell->col = cell->child.getNum("col");
265         cell->rspan = cell->child.hasField("rowspan") ? cell->child.getNum("rowspan") : 1;
266         cell->cspan = cell->child.hasField("colspan") ? cell->child.getNum("colspan") : 1;
267         if(cell->row + cell->rspan > rows) rows = cell->row + cell->rspan;
268         if(cell->col + cell->cspan > cols) cols = cell->col + cell->cspan;
269     }
270     int* rowSizes = new int[rows];
271     int* colSizes = new int[cols];
272     for(i=0; i<rows; i++) rowSizes[i] = 0;
273     for(i=0; i<cols; i++) colSizes[i] = 0;
274
275     // Pass 1a (hack): we want row zero to be the top, not the
276     // (cartesian: y==0) bottom, so reverse the sense of the row
277     // numbers.
278     for(i=0; i<nc; i++) {
279         TabCell* cell = &children[i];
280         cell->row = rows - cell->row - cell->rspan;
281     }
282     
283     // Pass 2: get sizes for single-cell children
284     for(i=0; i<nc; i++) {
285         TabCell* cell = &children[i];
286         if(cell->rspan < 2 && cell->h > rowSizes[cell->row])
287             rowSizes[cell->row] = cell->h;
288         if(cell->cspan < 2 && cell->w > colSizes[cell->col])
289             colSizes[cell->col] = cell->w;
290     }
291     
292     // Pass 3: multi-cell children, make space as needed
293     for(i=0; i<nc; i++) {
294         TabCell* cell = &children[i];
295         if(cell->rspan > 1) {
296             int total = 0;
297             for(j=0; j<cell->rspan; j++)
298                 total += rowSizes[cell->row + j];
299             int extra = total - cell->h;
300             if(extra > 0) {
301                 for(j=0; j<cell->rspan; j++) {
302                     int chunk = extra / (cell->rspan - j);
303                     rowSizes[cell->row + j] += chunk;
304                     extra -= chunk;
305                 }
306             }
307         }
308         if(cell->cspan > 1) {
309             int total = 0;
310             for(j=0; j<cell->cspan; j++)
311                 total += colSizes[cell->col + j];
312             int extra = total - cell->w;
313             if(extra > 0) {
314                 for(j=0; j<cell->cspan; j++) {
315                     int chunk = extra / (cell->cspan - j);
316                     colSizes[cell->col + j] += chunk;
317                     extra -= chunk;
318                 }
319             }
320         }
321     }
322
323     // Calculate our preferred sizes, and return if we aren't doing layout
324     int prefw=0, prefh=0;
325     for(i=0; i<cols; i++) prefw += colSizes[i];
326     for(i=0; i<rows; i++) prefh += rowSizes[i];
327
328     if(!doLayout) {
329         *w = prefw; *h = prefh;
330         delete[] children; delete[] rowSizes; delete[] colSizes;
331         return;
332     }
333
334     // Allocate extra space
335     int pad = 2*padding();
336     int extra = getNum("height") - pad - prefh;
337     for(i=0; i<rows; i++) {
338         int chunk = extra / (rows - i);
339         rowSizes[i] += chunk;
340         extra -= chunk;
341     }
342     extra = getNum("width") - pad - prefw;
343     for(i=0; i<cols; i++) {
344         int chunk = extra / (cols - i);
345         colSizes[i] += chunk;
346         extra -= chunk;
347     }
348
349     // Finally, lay out the children (with just two more temporary
350     // arrays for calculating coordinates)
351     int* rowY = new int[rows];
352     int total = 0;
353     for(i=0; i<rows; i++) { rowY[i] = total; total += rowSizes[i]; }
354
355     int* colX = new int[cols];
356     total = 0;
357     for(i=0; i<cols; i++) { colX[i] = total; total += colSizes[i]; }
358
359     for(i=0; i<nc; i++) {
360         TabCell* cell = &children[i];
361         int w = 0, h = 0;
362         for(j=0; j<cell->rspan; j++) h += rowSizes[cell->row + j];
363         for(j=0; j<cell->cspan; j++) w += colSizes[cell->col + j];
364         int x = colX[cell->col];
365         int y = rowY[cell->row];
366         cell->child.layout(x, y, w, h);
367     }    
368
369     // Clean up
370     delete[] children;
371     delete[] rowSizes;
372     delete[] colSizes;
373     delete[] rowY;
374     delete[] colX;
375 }