Integration of OCCT 6.5.0 from SVN
[occt.git] / samples / java / java / util / ToolbarLayout.java
1
2 //Title:        JAD demo application
3 //Version:
4 //Copyright:    Copyright (c) 1999
5 //Author:       User Interface group
6 //Company:      MatraDatavision
7 //Description:  Example of using JAD architecture
8 package util;
9
10 import java.awt.*;
11
12
13 public class ToolbarLayout implements LayoutManager
14 {
15 //=======================================================================//
16 // Constants
17 //=======================================================================//
18   // Alignment
19   public static final int CENTER = 0;
20   public static final int LEFT = 1;
21   public static final int RIGHT = 2;
22   public static final int TOP = 3;
23   public static final int BOTTOM = 4;
24
25
26 //=======================================================================//
27 // Internal variables
28 //=======================================================================//
29   private int xAlign;       // horizontal alignment of components
30   private int yAlign;       // vertical alignment of components
31   private int hgap;         // horizontal gap between components
32   private int vgap;         // vertical gap between components
33
34
35 //=======================================================================//
36 // Constructors
37 //=======================================================================//
38   public ToolbarLayout()
39   {
40     this(CENTER, CENTER, 1, 1);
41   }
42
43   public ToolbarLayout(int xAlign, int yAlign)
44   {
45     this(xAlign, yAlign, 1, 1);
46   }
47
48   public ToolbarLayout(int xAlign, int yAlign, int hgap, int vgap)
49   {
50     this.xAlign = xAlign;
51     this.yAlign = yAlign;
52     this.hgap = hgap;
53     this.vgap = vgap;
54   }
55
56 //=======================================================================//
57 // Setting/Getting parameters
58 //=======================================================================//
59   public int getAlignmentX()
60   {
61     return xAlign;
62   }
63
64   public void setAlignmentX(int xAlign)
65   {
66     this.xAlign = xAlign;
67   }
68
69   public int getAlignmentY()
70   {
71     return yAlign;
72   }
73
74   public void setAlignmentY(int yAlign)
75   {
76     this.yAlign = yAlign;
77   }
78
79   public int getHgap()
80   {
81     return hgap;
82   }
83
84   public void setHgap(int hgap)
85   {
86     this.hgap = hgap;
87   }
88
89   public int getVgap()
90   {
91     return vgap;
92   }
93
94   public void setVgap(int vgap)
95   {
96     this.vgap = vgap;
97   }
98
99 //=======================================================================//
100 // LayoutManager interface implementation
101 //=======================================================================//
102   public void addLayoutComponent(String name, Component comp)
103   {
104   }
105
106   public void removeLayoutComponent(Component comp)
107   {
108   }
109
110   public Dimension preferredLayoutSize(Container parent)
111   {
112     synchronized (parent.getTreeLock())
113     {
114         Dimension dim = new Dimension(0, 0);
115         Insets insets = parent.getInsets();
116       int maxWidth = parent.getWidth() - (insets.left + insets.right + hgap*2);
117         int compCount = parent.getComponentCount();
118       int maxRowWidth = 0, maxRowHeight = 0;
119       int x = 0;
120
121         for (int i = 0 ; i < compCount ; i++)
122       {
123         Component m = parent.getComponent(i);
124             if (m.isVisible())
125         {
126                 Dimension d = m.getPreferredSize();
127           if ((x == 0) || ((x + d.width) <= maxWidth))
128           {
129             if (x > 0) x += hgap;
130             x += d.width;
131             maxRowHeight = Math.max(maxRowHeight, d.height);
132           }
133           else
134           {
135             // It's time to start new line
136             if (dim.height > 0) dim.height += vgap;
137             dim.height += maxRowHeight;
138             maxRowWidth = Math.max(maxRowWidth, x);
139
140             x = d.width;
141             maxRowHeight = d.height;
142           }
143               }
144           }
145       // Process the last row
146       if (dim.height > 0) dim.height += vgap;
147       dim.height += maxRowHeight;
148       maxRowWidth = Math.max(maxRowWidth, x);
149
150       dim.width = maxRowWidth;
151
152         dim.width += insets.left + insets.right + hgap*2;
153         dim.height += insets.top + insets.bottom + vgap*2;
154
155         return dim;
156     }
157   }
158
159
160   public Dimension minimumLayoutSize(Container parent)
161   {
162     synchronized (parent.getTreeLock())
163     {
164         Dimension dim = new Dimension(0, 0);
165         Insets insets = parent.getInsets();
166       int maxWidth = parent.getWidth() - (insets.left + insets.right + hgap*2);
167         int compCount = parent.getComponentCount();
168       int maxRowWidth = 0, maxRowHeight = 0;
169       int x = 0;
170
171         for (int i = 0 ; i < compCount ; i++)
172       {
173         Component m = parent.getComponent(i);
174             if (m.isVisible())
175         {
176                 Dimension d = m.getMinimumSize();
177           if ((x == 0) || ((x + d.width) <= maxWidth))
178           {
179             if (x > 0) x += hgap;
180             x += d.width;
181             maxRowHeight = Math.max(maxRowHeight, d.height);
182           }
183           else
184           {
185             // It's time to start new line
186             if (dim.height > 0) dim.height += vgap;
187             dim.height += maxRowHeight;
188             maxRowWidth = Math.max(maxRowWidth, x);
189
190             x = d.width;
191             maxRowHeight = d.height;
192           }
193               }
194           }
195       // Process the last row
196       if (dim.height > 0) dim.height += vgap;
197       dim.height += maxRowHeight;
198       maxRowWidth = Math.max(maxRowWidth, x);
199
200       dim.width = maxRowWidth;
201
202         dim.width += insets.left + insets.right + hgap*2;
203         dim.height += insets.top + insets.bottom + vgap*2;
204
205         return dim;
206     }
207 /*
208     synchronized (parent.getTreeLock())
209     {
210             Dimension dim = new Dimension(0, 0);
211         int nmembers = parent.getComponentCount();
212
213         for (int i = 0 ; i < nmembers ; i++)
214       {
215               Component m = parent.getComponent(i);
216             if (m.isVisible())
217         {
218                 Dimension d = m.getMinimumSize();
219                 dim.height = Math.max(dim.height, d.height);
220                 if (i > 0) dim.width += hgap;
221                 dim.width += d.width;
222         }
223       }
224         Insets insets = parent.getInsets();
225         dim.width += insets.left + insets.right + hgap*2;
226         dim.height += insets.top + insets.bottom + vgap*2;
227         return dim;
228     }
229 */
230   }
231
232   public void layoutContainer(Container parent)
233   {
234     synchronized (parent.getTreeLock())
235     {
236         Insets insets = parent.getInsets();
237         int maxwidth = parent.getWidth() - (insets.left + insets.right + hgap*2);
238         int compCount = parent.getComponentCount();
239         int x = 0, y = insets.top + vgap;
240         int rowHeight = 0, start = 0;
241
242       boolean ltr = parent.getComponentOrientation().isLeftToRight();
243
244         for (int i = 0; i < compCount; i++)
245       {
246               Component m = parent.getComponent(i);
247               if (m.isVisible())
248         {
249                 Dimension d = m.getPreferredSize();
250                 m.setSize(d.width, d.height);
251
252                 if ((x == 0) || ((x + d.width) <= maxwidth))
253           {
254                     if (x > 0) x += hgap;
255                     x += d.width;
256                         rowHeight = Math.max(rowHeight, d.height);
257                 }
258           else
259           {
260                     layoutRow(parent, insets.left + hgap, y, maxwidth - x,
261                       rowHeight, start, i, ltr);
262                         x = d.width;
263                         y += vgap + rowHeight;
264                         rowHeight = d.height;
265                         start = i;
266                       }
267               }
268             }
269             layoutRow(parent, insets.left + hgap, y, maxwidth - x,
270                 rowHeight, start, compCount, ltr);
271     }
272   }
273
274   
275   private void layoutRow(Container parent,
276                          int x, int y, int freeWidth, int rowHeight,
277                          int rowStart, int rowEnd, boolean ltr)
278   {
279     synchronized (parent.getTreeLock())
280     {
281         switch (xAlign)
282       {
283         case LEFT:
284                 x += ltr ? 0 : freeWidth;
285             break;
286         case CENTER:
287             x += freeWidth/2;
288             break;
289         case RIGHT:
290             x += ltr ? freeWidth : 0;
291             break;
292         }
293         for (int i = rowStart; i < rowEnd; i++)
294       {
295               Component m = parent.getComponent(i);
296               if (m.isVisible())
297         {
298           int y2 = y;
299           switch (yAlign)
300           {
301             case TOP:
302               y2 += 0;
303               break;
304             case CENTER:
305               y2 += (rowHeight - m.getHeight())/2;
306               break;
307             case BOTTOM:
308               y2 += rowHeight - m.getHeight();
309               break;
310           }
311                 if (ltr)
312             m.setLocation(x, y2);
313                 else
314             m.setLocation(parent.getWidth() - x - m.getWidth(), y2);
315           x += m.getWidth() + hgap;
316             }
317         }
318     }
319   }
320
321
322 }
323
324
325