75
|
1 /*******************************************************************************
|
|
2 * Copyright (c) 2000, 2007 IBM Corporation and others.
|
|
3 * All rights reserved. This program and the accompanying materials
|
|
4 * are made available under the terms of the Eclipse Public License v1.0
|
|
5 * which accompanies this distribution, and is available at
|
|
6 * http://www.eclipse.org/legal/epl-v10.html
|
|
7 *
|
|
8 * Contributors:
|
|
9 * IBM Corporation - initial API and implementation
|
|
10 * dinko.ivanov@sap.com - patch #70790
|
|
11 * Port to the D programming language:
|
|
12 * Frank Benoit <benoit@tionex.de>
|
|
13 *******************************************************************************/
|
|
14 module dwtx.ui.forms.widgets.ColumnLayout;
|
|
15
|
|
16 import dwtx.ui.forms.widgets.ILayoutExtension;
|
|
17 import dwtx.ui.forms.widgets.ColumnLayoutData;
|
|
18
|
|
19 import dwt.DWT;
|
|
20 import dwt.graphics.Point;
|
|
21 import dwt.graphics.Rectangle;
|
|
22 import dwt.widgets.Composite;
|
|
23 import dwt.widgets.Control;
|
|
24 import dwt.widgets.Layout;
|
|
25
|
|
26 import dwt.dwthelper.utils;
|
|
27
|
|
28 /**
|
|
29 * This layout manager arranges children of the composite parent in vertical
|
|
30 * columns. All the columns are identical size and children are stretched
|
|
31 * horizontally to fill the column width. The goal is to give layout some
|
|
32 * reasonable range of column numbers to allow it to handle various parent
|
|
33 * widths. That way, column number will drop to the lowest number in the range
|
|
34 * when width decreases, and grow up to the highest number in the range when
|
|
35 * allowed by the parent width.
|
|
36 * <p>
|
|
37 * In addition, the layout attempts to 'fill the space' equally i.e. to avoid
|
|
38 * large gaps at the and of the last column.
|
|
39 * <p>
|
|
40 * Child controls are layed out according to their 'natural' (preferred) size.
|
|
41 * For 'stretchy' controls that do not have natural preferred size, it is
|
|
42 * possible to set width and/or height hints using ColumnLayoutData objects.
|
|
43 *
|
|
44 * @see ColumnLayoutData
|
|
45 * @since 3.0
|
|
46 */
|
|
47 public final class ColumnLayout : Layout, ILayoutExtension {
|
|
48 /**
|
|
49 * Minimum number of columns (default is 1).
|
|
50 */
|
|
51 public int minNumColumns = 1;
|
|
52 /**
|
|
53 * Maximum number of columns (default is 3).
|
|
54 */
|
|
55 public int maxNumColumns = 3;
|
|
56 /**
|
|
57 * Horizontal spacing between columns (default is 5).
|
|
58 */
|
|
59 public int horizontalSpacing = 5;
|
|
60 /**
|
|
61 * Vertical spacing between controls (default is 5).
|
|
62 */
|
|
63 public int verticalSpacing = 5;
|
|
64 /**
|
|
65 * Top margin (default is 5).
|
|
66 */
|
|
67 public int topMargin = 5;
|
|
68 /**
|
|
69 * Left margin (default is 5).
|
|
70 */
|
|
71 public int leftMargin = 5;
|
|
72 /**
|
|
73 * Bottom margin (default is 5).
|
|
74 */
|
|
75 public int bottomMargin = 5;
|
|
76 /**
|
|
77 * Right margin (default is 5).
|
|
78 */
|
|
79 public int rightMargin = 5;
|
|
80
|
|
81 /**
|
|
82 * Creates a new instance of the column layout.
|
|
83 */
|
|
84 public this() {
|
|
85 }
|
|
86
|
|
87 /+protected+/ Point computeSize(Composite composite, int wHint, int hHint, bool flushCache) {
|
|
88 if (wHint is 0)
|
|
89 return computeSize(composite, wHint, hHint, minNumColumns);
|
|
90 else if (wHint is DWT.DEFAULT)
|
|
91 return computeSize(composite, wHint, hHint, maxNumColumns);
|
|
92 else
|
|
93 return computeSize(composite, wHint, hHint, -1);
|
|
94 }
|
|
95
|
|
96 private Point computeSize(Composite parent, int wHint, int hHint, int ncolumns) {
|
|
97 Control[] children = parent.getChildren();
|
|
98 int cwidth = 0;
|
|
99 int cheight = 0;
|
|
100 Point[] sizes = new Point[children.length];
|
|
101
|
|
102 int cwHint = DWT.DEFAULT;
|
|
103 if (ncolumns !is -1) {
|
|
104 cwHint = wHint - leftMargin - rightMargin - (ncolumns - 1) * horizontalSpacing;
|
|
105 if (cwHint <= 0)
|
|
106 cwHint = 0;
|
|
107 else
|
|
108 cwHint /= ncolumns;
|
|
109 }
|
|
110
|
|
111 for (int i = 0; i < children.length; i++) {
|
|
112 sizes[i] = computeControlSize(children[i], cwHint);
|
|
113 cwidth = Math.max(cwidth, sizes[i].x);
|
|
114 cheight += sizes[i].y;
|
|
115 }
|
|
116 if (ncolumns is -1) {
|
|
117 // must compute
|
|
118 ncolumns = (wHint - leftMargin - rightMargin - horizontalSpacing) / (cwidth + horizontalSpacing);
|
|
119 ncolumns = Math.min(ncolumns, children.length);
|
|
120 ncolumns = Math.max(ncolumns, minNumColumns);
|
|
121 ncolumns = Math.min(ncolumns, maxNumColumns);
|
|
122 }
|
|
123 int perColHeight = cheight / ncolumns;
|
|
124 if (cheight % ncolumns !is 0)
|
|
125 perColHeight++;
|
|
126 int colHeight = 0;
|
|
127 int[] heights = new int[ncolumns];
|
|
128 int ncol = 0;
|
|
129
|
|
130 bool fillIn = false;
|
|
131
|
|
132 for (int i = 0; i < sizes.length; i++) {
|
|
133 int childHeight = sizes[i].y;
|
|
134 if (i>0 && colHeight + childHeight > perColHeight) {
|
|
135 heights[ncol] = colHeight;
|
|
136 ncol++;
|
|
137 if (ncol is ncolumns || fillIn) {
|
|
138 // overflow - start filling in
|
|
139 fillIn = true;
|
|
140 ncol = findShortestColumn(heights);
|
|
141 }
|
|
142 colHeight = heights[ncol];
|
|
143 }
|
|
144 if (colHeight > 0)
|
|
145 colHeight += verticalSpacing;
|
|
146 colHeight += childHeight;
|
|
147 }
|
|
148 heights[ncol] = Math.max(heights[ncol],colHeight);
|
|
149
|
|
150 Point size = new Point(0, 0);
|
|
151 for (int i = 0; i < ncolumns; i++) {
|
|
152 size.y = Math.max(size.y, heights[i]);
|
|
153 }
|
|
154 size.x = cwidth * ncolumns + (ncolumns - 1) * horizontalSpacing;
|
|
155 size.x += leftMargin + rightMargin;
|
|
156 //System.out.println("ColumnLayout: whint="+wHint+", size.x="+size.x);
|
|
157 size.y += topMargin + bottomMargin;
|
|
158 return size;
|
|
159 }
|
|
160
|
|
161 private Point computeControlSize(Control c, int wHint) {
|
|
162 ColumnLayoutData cd = cast(ColumnLayoutData) c.getLayoutData();
|
|
163 int widthHint = cd !is null ? cd.widthHint : wHint;
|
|
164 int heightHint = cd !is null ? cd.heightHint : DWT.DEFAULT;
|
|
165 return c.computeSize(widthHint, heightHint);
|
|
166 }
|
|
167
|
|
168 private int findShortestColumn(int[] heights) {
|
|
169 int result = 0;
|
|
170 int height = Integer.MAX_VALUE;
|
|
171 for (int i = 0; i < heights.length; i++) {
|
|
172 if (height > heights[i]) {
|
|
173 height = heights[i];
|
|
174 result = i;
|
|
175 }
|
|
176 }
|
|
177 return result;
|
|
178 }
|
|
179
|
|
180 /*
|
|
181 * (non-Javadoc)
|
|
182 *
|
|
183 * @see dwt.widgets.Layout#layout(dwt.widgets.Composite,
|
|
184 * bool)
|
|
185 */
|
|
186 protected void layout(Composite parent, bool flushCache) {
|
|
187 Control[] children = parent.getChildren();
|
|
188 Rectangle carea = parent.getClientArea();
|
|
189 int cwidth = 0;
|
|
190 int cheight = 0;
|
|
191 Point[] sizes = new Point[children.length];
|
|
192 for (int i = 0; i < children.length; i++) {
|
|
193 sizes[i] = computeControlSize(children[i], DWT.DEFAULT);
|
|
194 cwidth = Math.max(cwidth, sizes[i].x);
|
|
195 cheight += sizes[i].y;
|
|
196 }
|
|
197 int ncolumns = (carea.width - leftMargin - rightMargin - horizontalSpacing) / (cwidth + horizontalSpacing);
|
|
198 ncolumns = Math.min(ncolumns, children.length);
|
|
199 ncolumns = Math.max(ncolumns, minNumColumns);
|
|
200 ncolumns = Math.min(ncolumns, maxNumColumns);
|
|
201 int realWidth = (carea.width - leftMargin - rightMargin + horizontalSpacing) / ncolumns - horizontalSpacing;
|
|
202 // int childrenPerColumn = children.length / ncolumns;
|
|
203 // if (children.length % ncolumns !is 0)
|
|
204 // childrenPerColumn++;
|
|
205 // int colWidth = 0;
|
|
206
|
|
207 int fillWidth = Math.max(cwidth, realWidth);
|
|
208
|
|
209 int perColHeight = cheight / ncolumns;
|
|
210 if (cheight % ncolumns !is 0)
|
|
211 perColHeight++;
|
|
212
|
|
213 int colHeight = 0;
|
|
214 int[] heights = new int[ncolumns];
|
|
215 int ncol = 0;
|
|
216 int x = leftMargin;
|
|
217 bool fillIn = false;
|
|
218
|
|
219 for (int i = 0; i < sizes.length; i++) {
|
|
220 Control child = children[i];
|
|
221 Point csize = sizes[i];
|
|
222 ColumnLayoutData cd = cast(ColumnLayoutData) child.getLayoutData();
|
|
223 int align_ = cd !is null ? cd.horizontalAlignment : ColumnLayoutData.FILL;
|
|
224 int childWidth = align_ is ColumnLayoutData.FILL ? fillWidth : csize.x;
|
|
225
|
|
226 if (i>0 && colHeight + csize.y > perColHeight) {
|
|
227 heights[ncol] = colHeight;
|
|
228 if (fillIn || ncol is ncolumns-1) {
|
|
229 // overflow - start filling in
|
|
230 fillIn = true;
|
|
231 ncol = findShortestColumn(heights);
|
|
232
|
|
233 x = leftMargin + ncol * (fillWidth + horizontalSpacing);
|
|
234
|
|
235 }
|
|
236 else {
|
|
237 ncol++;
|
|
238 x += fillWidth + horizontalSpacing;
|
|
239 }
|
|
240 colHeight = heights[ncol];
|
|
241 }
|
|
242 if (colHeight > 0)
|
|
243 colHeight += verticalSpacing;
|
|
244
|
|
245
|
|
246 switch (align_) {
|
|
247 case ColumnLayoutData.LEFT :
|
|
248 case ColumnLayoutData.FILL :
|
|
249 child.setBounds(x, topMargin+colHeight, childWidth, csize.y);
|
|
250 break;
|
|
251 case ColumnLayoutData.RIGHT :
|
|
252 child.setBounds(x + fillWidth - childWidth, topMargin+colHeight, childWidth, csize.y);
|
|
253 break;
|
|
254 case ColumnLayoutData.CENTER :
|
|
255 child.setBounds(x + fillWidth / 2 - childWidth / 2, topMargin+colHeight, childWidth, csize.y);
|
|
256 break;
|
|
257 }
|
|
258
|
|
259 colHeight += csize.y;
|
|
260 }
|
|
261 }
|
|
262
|
|
263 /*
|
|
264 * (non-Javadoc)
|
|
265 *
|
|
266 * @see dwtx.ui.forms.widgets.ILayoutExtension#computeMaximumWidth(dwt.widgets.Composite,
|
|
267 * bool)
|
|
268 */
|
|
269 public int computeMaximumWidth(Composite parent, bool changed) {
|
|
270 return computeSize(parent, DWT.DEFAULT, DWT.DEFAULT, changed).x;
|
|
271 }
|
|
272
|
|
273 /*
|
|
274 * (non-Javadoc)
|
|
275 *
|
|
276 * @see dwtx.ui.forms.widgets.ILayoutExtension#computeMinimumWidth(dwt.widgets.Composite,
|
|
277 * bool)
|
|
278 */
|
|
279 public int computeMinimumWidth(Composite parent, bool changed) {
|
|
280 return computeSize(parent, 0, DWT.DEFAULT, changed).x;
|
|
281 }
|
|
282 }
|