1:
37:
38:
39: package ;
40:
41: import ;
42: import ;
43: import ;
44: import ;
45: import ;
46: import ;
47:
48:
62: public class SpringLayout implements LayoutManager2
63: {
64:
65:
66: public static final String EAST = "East";
67:
68:
69: public static final String NORTH = "North";
70:
71:
72: public static final String SOUTH = "South";
73:
74:
75: public static final String WEST = "West";
76:
77:
78: private Map constraintsMap;
79:
80:
91: public static class Constraints
92: {
93:
94:
95:
96: private Spring x;
97:
98:
99: private Spring y;
100:
101:
102: private Spring height;
103:
104:
105: private Spring width;
106:
107:
108: private Spring east;
109:
110:
111: private Spring south;
112:
113:
117: public Constraints()
118: {
119: x = y = height = width = east = south = null;
120: }
121:
122:
128: public Constraints(Spring x, Spring y)
129: {
130: this.x = x;
131: this.y = y;
132: width = height = east = south = null;
133: }
134:
135:
143: public Constraints(Spring x, Spring y, Spring width, Spring height)
144: {
145: this.x = x;
146: this.y = y;
147: this.width = width;
148: this.height = height;
149: east = south = null;
150: }
151:
152:
160: public Spring getConstraint(String edgeName)
161: {
162: Spring retVal = null;
163: if (edgeName.equals(SpringLayout.NORTH))
164: retVal = y;
165: else if (edgeName.equals(SpringLayout.WEST))
166: retVal = x;
167: else if (edgeName.equals(SpringLayout.SOUTH))
168: {
169: retVal = south;
170: if ((retVal == null) && (y != null) && (height != null))
171: retVal = Spring.sum(y, height);
172: }
173: else if (edgeName.equals(SpringLayout.EAST))
174: {
175: retVal = east;
176: if ((retVal == null) && (x != null) && (width != null))
177: retVal = Spring.sum(x, width);
178: }
179:
180: return retVal;
181: }
182:
183:
188: public Spring getHeight()
189: {
190: Spring retVal = height;
191: if ((retVal == null) && (y != null) && (south != null))
192: {
193: retVal = Spring.sum(south, Spring.minus(y));
194: }
195: return retVal;
196: }
197:
198:
203: public Spring getWidth()
204: {
205: Spring retVal = width;
206: if ((retVal == null) && (x != null) && (east != null))
207: {
208: retVal = Spring.sum(east, Spring.minus(x));
209: }
210: return retVal;
211: }
212:
213:
218: public Spring getX()
219: {
220: Spring retVal = x;
221: if ((retVal == null) && (width != null) && (east != null))
222: {
223: retVal = Spring.sum(east, Spring.minus(width));
224: }
225: return retVal;
226: }
227:
228:
233: public Spring getY()
234: {
235: Spring retVal = y;
236: if ((retVal == null) && (height != null) && (south != null))
237: {
238: retVal = Spring.sum(south, Spring.minus(height));
239: }
240: return retVal;
241: }
242:
243:
252: public void setConstraint(String edgeName, Spring s)
253: {
254:
255: if (edgeName.equals(SpringLayout.WEST))
256: {
257: x = s;
258: if ((width != null) && (east != null))
259: width = Spring.sum(east, Spring.minus(x));
260: }
261: else if (edgeName.equals(SpringLayout.NORTH))
262: {
263: y = s;
264: if ((height != null) && (south != null))
265: height = Spring.sum(south, Spring.minus(y));
266: }
267: else if (edgeName.equals(SpringLayout.EAST))
268: {
269: east = s;
270: if ((x != null) && (width != null))
271: x = Spring.sum(east, Spring.minus(width));
272: }
273: else if (edgeName.equals(SpringLayout.SOUTH))
274: {
275: south = s;
276: if ((height != null) && (y != null))
277: y = Spring.sum(south, Spring.minus(height));
278: }
279:
280: }
281:
282:
287: public void setHeight(Spring s)
288: {
289: height = s;
290: if ((south != null) && (y != null))
291: south = Spring.sum(y, height);
292:
293: }
294:
295:
300: public void setWidth(Spring s)
301: {
302: width = s;
303: if ((east != null) && (x != null))
304: east = Spring.sum(x, width);
305:
306: }
307:
308:
313: public void setX(Spring s)
314: {
315: x = s;
316: if ((width != null) && (east != null))
317: width = Spring.sum(east, Spring.minus(x));
318:
319: }
320:
321:
326: public void setY(Spring s)
327: {
328: y = s;
329: if ((height != null) && (south != null))
330: height = Spring.sum(south, Spring.minus(y));
331:
332: }
333: }
334:
335:
338: public SpringLayout()
339: {
340:
341: constraintsMap = new HashMap();
342: }
343:
344:
352: public void addLayoutComponent(Component component, Object constraint)
353: {
354: constraintsMap.put(component, constraint);
355: }
356:
357:
358:
367: public void addLayoutComponent(String name, Component c)
368: {
369:
370: }
371:
372:
381: public Spring getConstraint(String edgeName, Component c)
382: {
383: Constraints constraints = getConstraints(c);
384: return constraints.getConstraint(edgeName);
385: }
386:
387:
395: public SpringLayout.Constraints getConstraints(Component c)
396: {
397: Constraints constraints = (Constraints) constraintsMap.get(c);
398: if (constraints == null)
399: {
400: Container parent = c.getParent();
401: constraints = new Constraints();
402: if (parent != null)
403: {
404: constraints.setX
405: (Spring.constant(parent.getInsets().left));
406: constraints.setY
407: (Spring.constant(parent.getInsets().top));
408: }
409: else
410: {
411: constraints.setX
412: (Spring.constant(0));
413: constraints.setY
414: (Spring.constant(0));
415:
416: }
417: constraints.setWidth
418: (Spring.constant(c.getMinimumSize().width,
419: c.getPreferredSize().width,
420: c.getMaximumSize().width));
421: constraints.setHeight
422: (Spring.constant(c.getMinimumSize().height,
423: c.getPreferredSize().height,
424: c.getMaximumSize().height));
425:
426: constraintsMap.put(c, constraints);
427:
428: }
429:
430: return constraints;
431: }
432:
433:
440: public float getLayoutAlignmentX(Container p)
441: {
442: return 0.0F;
443: }
444:
445:
452: public float getLayoutAlignmentY(Container p)
453: {
454: return 0.0F;
455: }
456:
457:
460: public void invalidateLayout(Container p)
461: {
462:
463: }
464:
465:
470: public void layoutContainer(Container p)
471: {
472:
473: addLayoutComponent(p, new Constraints(Spring.constant(0),
474: Spring.constant(0)));
475:
476: int offsetX = p.getInsets().left;
477: int offsetY = p.getInsets().right;
478:
479: Component[] components = p.getComponents();
480: for (int index = 0; index < components.length; index++)
481: {
482: Component c = components[index];
483: Constraints constraints = getConstraints(c);
484: int x = constraints.getX().getValue();
485: int y = constraints.getY().getValue();
486: int width = constraints.getWidth().getValue();
487: int height = constraints.getHeight().getValue();
488:
489: c.setLocation(x + offsetX, y + offsetY);
490: c.setSize(width, height);
491: }
492:
493: }
494:
495:
502: public Dimension maximumLayoutSize(Container p)
503: {
504: int maxX = 0;
505: int maxY = 0;
506:
507: int offsetX = p.getInsets().left;
508: int offsetY = p.getInsets().right;
509:
510: Component[] components = p.getComponents();
511: for (int index = 0; index < components.length; index++)
512: {
513: Component c = components[index];
514: Constraints constraints = getConstraints(c);
515: int x = constraints.getX().getMaximumValue();
516: int y = constraints.getY().getMaximumValue();
517: int width = constraints.getWidth().getMaximumValue();
518: int height = constraints.getHeight().getMaximumValue();
519:
520: int rightEdge = offsetX + x + width;
521: if (rightEdge > maxX)
522: maxX = rightEdge;
523: int bottomEdge = offsetY + y + height;
524: if (bottomEdge > maxY)
525: maxY = bottomEdge;
526: }
527:
528: return new Dimension(maxX, maxY);
529: }
530:
531:
532:
539: public Dimension minimumLayoutSize(Container p)
540: {
541: int maxX = 0;
542: int maxY = 0;
543:
544: int offsetX = p.getInsets().left;
545: int offsetY = p.getInsets().right;
546:
547: Component[] components = p.getComponents();
548: for (int index = 0; index < components.length; index++)
549: {
550: Component c = components[index];
551: Constraints constraints = getConstraints(c);
552: int x = constraints.getX().getMinimumValue();
553: int y = constraints.getY().getMinimumValue();
554: int width = constraints.getWidth().getMinimumValue();
555: int height = constraints.getHeight().getMinimumValue();
556:
557: int rightEdge = offsetX + x + width;
558: if (rightEdge > maxX)
559: maxX = rightEdge;
560: int bottomEdge = offsetY + y + height;
561: if (bottomEdge > maxY)
562: maxY = bottomEdge;
563: }
564:
565: return new Dimension(maxX, maxY);
566: }
567:
568:
575: public Dimension preferredLayoutSize(Container p)
576: {
577: int maxX = 0;
578: int maxY = 0;
579:
580: int offsetX = p.getInsets().left;
581: int offsetY = p.getInsets().right;
582:
583: Component[] components = p.getComponents();
584: for (int index = 0; index < components.length; index++)
585: {
586: Component c = components[index];
587: Constraints constraints = getConstraints(c);
588: int x = constraints.getX().getPreferredValue();
589: int y = constraints.getY().getPreferredValue();
590: int width = constraints.getWidth().getPreferredValue();
591: int height = constraints.getHeight().getPreferredValue();
592:
593: int rightEdge = offsetX + x + width;
594: if (rightEdge > maxX)
595: maxX = rightEdge;
596: int bottomEdge = offsetY + y + height;
597: if (bottomEdge > maxY)
598: maxY = bottomEdge;
599: }
600:
601: return new Dimension(maxX, maxY);
602: }
603:
604:
615: public void putConstraint(String e1, Component c1, int pad, String e2,
616: Component c2)
617: {
618: Constraints constraints1 = getConstraints(c1);
619: Constraints constraints2 = getConstraints(c2);
620:
621: Spring strut = Spring.constant(pad);
622: Spring otherEdge = constraints2.getConstraint(e2);
623: constraints1.setConstraint(e1, Spring.sum(strut, otherEdge));
624:
625: }
626:
627:
638: public void putConstraint(String e1, Component c1, Spring s, String e2,
639: Component c2)
640: {
641: Constraints constraints1 = getConstraints(c1);
642: Constraints constraints2 = getConstraints(c2);
643:
644: Spring otherEdge = constraints2.getConstraint(e2);
645: constraints1.setConstraint(e1, Spring.sum(s, otherEdge));
646:
647: }
648:
649:
653: public void removeLayoutComponent(Component c)
654: {
655:
656: }
657: }