KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > swingwtx > swing > SizeRequirements


1 /*
2    SwingWT
3    Copyright(c)2003-2004, R. Rawson-Tetley
4  
5    For more information on distributing and using this program, please
6    see the accompanying "COPYING" file.
7  
8    Contact me by electronic mail: bobintetley@users.sourceforge.net
9  
10    $Log: SizeRequirements.java,v $
11    Revision 1.4 2004/04/20 16:36:16 bobintetley
12    Code cleanup
13
14  
15  */

16 package swingwtx.swing;
17
18 public class SizeRequirements {
19     
20     public int minimum;
21     public int preferred;
22     public int maximum;
23     public float alignment;
24     
25     public SizeRequirements() {
26         minimum = 0;
27         preferred = 0;
28         maximum = 0;
29         alignment = (float) .5;
30     }
31     
32     public SizeRequirements(int min, int pref, int max, float a) {
33         minimum = min;
34         preferred = pref;
35         maximum = max;
36         if (a > 1)
37             alignment = 1;
38         else if (a < 0)
39             alignment = 0;
40         else
41             alignment = a;
42     }
43
44     
45     public static SizeRequirements getTiledSizeRequirements(SizeRequirements[] children) {
46         SizeRequirements total = new SizeRequirements();
47         for (int i = 0; i < children.length; i++) {
48             SizeRequirements req = children[i];
49             total.minimum = (int) Math.min((long) total.minimum + (long) req.minimum, Integer.MAX_VALUE);
50             total.preferred = (int) Math.min((long) total.preferred + (long) req.preferred, Integer.MAX_VALUE);
51             total.maximum = (int) Math.min((long) total.maximum + (long) req.maximum, Integer.MAX_VALUE);
52         }
53         return total;
54     }
55     public static SizeRequirements getAlignedSizeRequirements(SizeRequirements[] children) {
56         SizeRequirements totalAscent = new SizeRequirements();
57         SizeRequirements totalDescent = new SizeRequirements();
58         for (int i = 0; i < children.length; i++) {
59             SizeRequirements req = children[i];
60             
61             int ascent = (int) (req.alignment * req.minimum);
62             int descent = req.minimum - ascent;
63             totalAscent.minimum = Math.max(ascent, totalAscent.minimum);
64             totalDescent.minimum = Math.max(descent, totalDescent.minimum);
65             
66             ascent = (int) (req.alignment * req.preferred);
67             descent = req.preferred - ascent;
68             totalAscent.preferred = Math.max(ascent, totalAscent.preferred);
69             totalDescent.preferred = Math.max(descent, totalDescent.preferred);
70             
71             ascent = (int) (req.alignment * req.maximum);
72             descent = req.maximum - ascent;
73             totalAscent.maximum = Math.max(ascent, totalAscent.maximum);
74             totalDescent.maximum = Math.max(descent, totalDescent.maximum);
75         }
76         int min = (int) Math.min((long) totalAscent.minimum + (long) totalDescent.minimum, Integer.MAX_VALUE);
77         int pref = (int) Math.min((long) totalAscent.preferred + (long) totalDescent.preferred, Integer.MAX_VALUE);
78         int max = (int) Math.min((long) totalAscent.maximum + (long) totalDescent.maximum, Integer.MAX_VALUE);
79         float alignment = 0.0f;
80         if (min > 0) {
81             alignment = (float) totalAscent.minimum / min;
82             alignment = alignment > 1 ? 1 : alignment < 0 ? 0 : alignment;
83         }
84         return new SizeRequirements(min, pref, max, alignment);
85     }
86     public static void calculateTiledPositions(int allocated,
87                                                 SizeRequirements total,
88                                                 SizeRequirements[] children,
89                                                 int[] offsets,
90                                                 int[] spans) {
91         calculateTiledPositions(allocated, total, children, offsets, spans, true);
92     }
93     public static void calculateTiledPositions(int allocated,
94                                                 SizeRequirements total,
95                                                 SizeRequirements[] children,
96                                                 int[] offsets,
97                                                 int[] spans,
98                                                 boolean forward) {
99         long min = 0;
100         long pref = 0;
101         long max = 0;
102         for (int i = 0; i < children.length; i++) {
103             min += children[i].minimum;
104             pref += children[i].preferred;
105             max += children[i].maximum;
106         }
107         if (allocated >= pref) {
108             
109             float totalPlay = Math.min(allocated - pref, max - pref);
110             float factor = (max - pref == 0) ? 0 : totalPlay / (max - pref);
111             int totalOffset;
112
113             if( forward ) {
114                 totalOffset = 0;
115                 for (int i = 0; i < spans.length; i++) {
116                     offsets[i] = totalOffset;
117                     SizeRequirements req = children[i];
118                     int play = (int)(factor * (req.maximum - req.preferred));
119                     spans[i] = (int) Math.min((long) req.preferred + (long) play, Integer.MAX_VALUE);
120                     totalOffset = (int) Math.min((long) totalOffset + (long) spans[i], Integer.MAX_VALUE);
121                 }
122             } else {
123                 totalOffset = allocated;
124                 for (int i = 0; i < spans.length; i++) {
125                     SizeRequirements req = children[i];
126                     int play = (int)(factor * (req.maximum - req.preferred));
127                     spans[i] = (int) Math.min((long) req.preferred + (long) play, Integer.MAX_VALUE);
128                     offsets[i] = totalOffset - spans[i];
129                     totalOffset = (int) Math.max((long) totalOffset - (long) spans[i], 0);
130                 }
131             }
132             
133             
134         } else {
135             
136             float totalPlay = Math.min(pref - allocated, pref - min);
137             float factor = (pref - min == 0) ? 0 : totalPlay / (pref - min);
138             int totalOffset;
139             if( forward ) {
140                 totalOffset = 0;
141                 for (int i = 0; i < spans.length; i++) {
142                     offsets[i] = totalOffset;
143                     SizeRequirements req = children[i];
144                     float play = factor * (req.preferred - req.minimum);
145                     spans[i] = (int)(req.preferred - play);
146                     totalOffset = (int) Math.min((long) totalOffset + (long) spans[i], Integer.MAX_VALUE);
147                 }
148             } else {
149                 totalOffset = allocated;
150                 for (int i = 0; i < spans.length; i++) {
151                     SizeRequirements req = children[i];
152                     float play = factor * (req.preferred - req.minimum);
153                     spans[i] = (int)(req.preferred - play);
154                     offsets[i] = totalOffset - spans[i];
155                     totalOffset = (int) Math.max((long) totalOffset - (long) spans[i], 0);
156                 }
157             }
158             
159         }
160     }
161
162     public static void calculateAlignedPositions(int allocated,
163                                                 SizeRequirements total,
164                                                 SizeRequirements[] children,
165                                                 int[] offsets,
166                                                 int[] spans) {
167         calculateAlignedPositions( allocated, total, children, offsets, spans, true );
168     }
169     
170     public static void calculateAlignedPositions(int allocated,
171                                                 SizeRequirements total,
172                                                 SizeRequirements[] children,
173                                                 int[] offsets,
174                                                 int[] spans,
175                                                 boolean normal) {
176                                                     
177         float totalAlignment = normal ? total.alignment : 1 - total.alignment;
178         
179         int totalAscent = (int)(allocated * totalAlignment);
180         int totalDescent = allocated - totalAscent;
181         for (int i = 0; i < children.length; i++) {
182             SizeRequirements req = children[i];
183             float alignment = normal ? req.alignment : 1 - req.alignment;
184             int maxAscent = (int)(req.maximum * alignment);
185             int maxDescent = req.maximum - maxAscent;
186             int ascent = Math.min(totalAscent, maxAscent);
187             int descent = Math.min(totalDescent, maxDescent);
188             
189             offsets[i] = totalAscent - ascent;
190             spans[i] = (int) Math.min((long) ascent + (long) descent, Integer.MAX_VALUE);
191         }
192     }
193     
194     public static int[] adjustSizes(int delta, SizeRequirements[] children) {
195         return new int[0];
196     }
197     
198         
199     public String JavaDoc toString() {
200         return "[" + minimum + "," + preferred + "," + maximum + "]@" + alignment;
201     }
202 }
Popular Tags