History

My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/java/awt/CardLayout.java (1 of 18352 files). Show all

Unified · Split

java/pkg/java/awt/CardLayout.java+612−0
@@ -0,0 +1,612 @@
1+/*
2+ * Copyright (c) 1995, 2006, Oracle and/or its affiliates. All rights reserved.
3+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4+ *
5+ * This code is free software; you can redistribute it and/or modify it
6+ * under the terms of the GNU General Public License version 2 only, as
7+ * published by the Free Software Foundation. Oracle designates this
8+ * particular file as subject to the "Classpath" exception as provided
9+ * by Oracle in the LICENSE file that accompanied this code.
10+ *
11+ * This code is distributed in the hope that it will be useful, but WITHOUT
12+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14+ * version 2 for more details (a copy is included in the LICENSE file that
15+ * accompanied this code).
16+ *
17+ * You should have received a copy of the GNU General Public License version
18+ * 2 along with this work; if not, write to the Free Software Foundation,
19+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20+ *
21+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22+ * or visit www.oracle.com if you need additional information or have any
23+ * questions.
24+ */
25+
26+package java.awt;
27+
28+import java.util.Hashtable;
29+import java.util.Vector;
30+import java.util.Enumeration;
31+
32+import java.io.Serializable;
33+import java.io.ObjectInputStream;
34+import java.io.ObjectOutputStream;
35+import java.io.ObjectStreamField;
36+import java.io.IOException;
37+
38+/**
39+ * A <code>CardLayout</code> object is a layout manager for a
40+ * container. It treats each component in the container as a card.
41+ * Only one card is visible at a time, and the container acts as
42+ * a stack of cards. The first component added to a
43+ * <code>CardLayout</code> object is the visible component when the
44+ * container is first displayed.
45+ * <p>
46+ * The ordering of cards is determined by the container's own internal
47+ * ordering of its component objects. <code>CardLayout</code>
48+ * defines a set of methods that allow an application to flip
49+ * through these cards sequentially, or to show a specified card.
50+ * The {@link CardLayout#addLayoutComponent}
51+ * method can be used to associate a string identifier with a given card
52+ * for fast random access.
53+ *
54+ * @author Arthur van Hoff
55+ * @see java.awt.Container
56+ * @since JDK1.0
57+ */
58+
59+public class CardLayout implements LayoutManager2,
60+ Serializable {
61+
62+ private static final long serialVersionUID = -4328196481005934313L;
63+
64+ /*
65+ * This creates a Vector to store associated
66+ * pairs of components and their names.
67+ * @see java.util.Vector
68+ */
69+ Vector vector = new Vector();
70+
71+ /*
72+ * A pair of Component and String that represents its name.
73+ */
74+ class Card implements Serializable {
75+ static final long serialVersionUID = 6640330810709497518L;
76+ public String name;
77+ public Component comp;
78+ public Card(String cardName, Component cardComponent) {
79+ name = cardName;
80+ comp = cardComponent;
81+ }
82+ }
83+
84+ /*
85+ * Index of Component currently displayed by CardLayout.
86+ */
87+ int currentCard = 0;
88+
89+
90+ /*
91+ * A cards horizontal Layout gap (inset). It specifies
92+ * the space between the left and right edges of a
93+ * container and the current component.
94+ * This should be a non negative Integer.
95+ * @see getHgap()
96+ * @see setHgap()
97+ */
98+ int hgap;
99+
100+ /*
101+ * A cards vertical Layout gap (inset). It specifies
102+ * the space between the top and bottom edges of a
103+ * container and the current component.
104+ * This should be a non negative Integer.
105+ * @see getVgap()
106+ * @see setVgap()
107+ */
108+ int vgap;
109+
110+ /**
111+ * @serialField tab Hashtable
112+ * deprectated, for forward compatibility only
113+ * @serialField hgap int
114+ * @serialField vgap int
115+ * @serialField vector Vector
116+ * @serialField currentCard int
117+ */
118+ private static final ObjectStreamField[] serialPersistentFields = {
119+ new ObjectStreamField("tab", Hashtable.class),
120+ new ObjectStreamField("hgap", Integer.TYPE),
121+ new ObjectStreamField("vgap", Integer.TYPE),
122+ new ObjectStreamField("vector", Vector.class),
123+ new ObjectStreamField("currentCard", Integer.TYPE)
124+ };
125+
126+ /**
127+ * Creates a new card layout with gaps of size zero.
128+ */
129+ public CardLayout() {
130+ this(0, 0);
131+ }
132+
133+ /**
134+ * Creates a new card layout with the specified horizontal and
135+ * vertical gaps. The horizontal gaps are placed at the left and
136+ * right edges. The vertical gaps are placed at the top and bottom
137+ * edges.
138+ * @param hgap the horizontal gap.
139+ * @param vgap the vertical gap.
140+ */
141+ public CardLayout(int hgap, int vgap) {
142+ this.hgap = hgap;
143+ this.vgap = vgap;
144+ }
145+
146+ /**
147+ * Gets the horizontal gap between components.
148+ * @return the horizontal gap between components.
149+ * @see java.awt.CardLayout#setHgap(int)
150+ * @see java.awt.CardLayout#getVgap()
151+ * @since JDK1.1
152+ */
153+ public int getHgap() {
154+ return hgap;
155+ }
156+
157+ /**
158+ * Sets the horizontal gap between components.
159+ * @param hgap the horizontal gap between components.
160+ * @see java.awt.CardLayout#getHgap()
161+ * @see java.awt.CardLayout#setVgap(int)
162+ * @since JDK1.1
163+ */
164+ public void setHgap(int hgap) {
165+ this.hgap = hgap;
166+ }
167+
168+ /**
169+ * Gets the vertical gap between components.
170+ * @return the vertical gap between components.
171+ * @see java.awt.CardLayout#setVgap(int)
172+ * @see java.awt.CardLayout#getHgap()
173+ */
174+ public int getVgap() {
175+ return vgap;
176+ }
177+
178+ /**
179+ * Sets the vertical gap between components.
180+ * @param vgap the vertical gap between components.
181+ * @see java.awt.CardLayout#getVgap()
182+ * @see java.awt.CardLayout#setHgap(int)
183+ * @since JDK1.1
184+ */
185+ public void setVgap(int vgap) {
186+ this.vgap = vgap;
187+ }
188+
189+ /**
190+ * Adds the specified component to this card layout's internal
191+ * table of names. The object specified by <code>constraints</code>
192+ * must be a string. The card layout stores this string as a key-value
193+ * pair that can be used for random access to a particular card.
194+ * By calling the <code>show</code> method, an application can
195+ * display the component with the specified name.
196+ * @param comp the component to be added.
197+ * @param constraints a tag that identifies a particular
198+ * card in the layout.
199+ * @see java.awt.CardLayout#show(java.awt.Container, java.lang.String)
200+ * @exception IllegalArgumentException if the constraint is not a string.
201+ */
202+ public void addLayoutComponent(Component comp, Object constraints) {
203+ synchronized (comp.getTreeLock()) {
204+ if (constraints == null){
205+ constraints = "";
206+ }
207+ if (constraints instanceof String) {
208+ addLayoutComponent((String)constraints, comp);
209+ } else {
210+ throw new IllegalArgumentException("cannot add to layout: constraint must be a string");
211+ }
212+ }
213+ }
214+
215+ /**
216+ * @deprecated replaced by
217+ * <code>addLayoutComponent(Component, Object)</code>.
218+ */
219+ @Deprecated
220+ public void addLayoutComponent(String name, Component comp) {
221+ synchronized (comp.getTreeLock()) {
222+ if (!vector.isEmpty()) {
223+ comp.setVisible(false);
224+ }
225+ for (int i=0; i < vector.size(); i++) {
226+ if (((Card)vector.get(i)).name.equals(name)) {
227+ ((Card)vector.get(i)).comp = comp;
228+ return;
229+ }
230+ }
231+ vector.add(new Card(name, comp));
232+ }
233+ }
234+
235+ /**
236+ * Removes the specified component from the layout.
237+ * If the card was visible on top, the next card underneath it is shown.
238+ * @param comp the component to be removed.
239+ * @see java.awt.Container#remove(java.awt.Component)
240+ * @see java.awt.Container#removeAll()
241+ */
242+ public void removeLayoutComponent(Component comp) {
243+ synchronized (comp.getTreeLock()) {
244+ for (int i = 0; i < vector.size(); i++) {
245+ if (((Card)vector.get(i)).comp == comp) {
246+ // if we remove current component we should show next one
247+ if (comp.isVisible() && (comp.getParent() != null)) {
248+ next(comp.getParent());
249+ }
250+
251+ vector.remove(i);
252+
253+ // correct currentCard if this is necessary
254+ if (currentCard > i) {
255+ currentCard--;
256+ }
257+ break;
258+ }
259+ }
260+ }
261+ }
262+
263+ /**
264+ * Determines the preferred size of the container argument using
265+ * this card layout.
266+ * @param parent the parent container in which to do the layout
267+ * @return the preferred dimensions to lay out the subcomponents
268+ * of the specified container
269+ * @see java.awt.Container#getPreferredSize
270+ * @see java.awt.CardLayout#minimumLayoutSize
271+ */
272+ public Dimension preferredLayoutSize(Container parent) {
273+ synchronized (parent.getTreeLock()) {
274+ Insets insets = parent.getInsets();
275+ int ncomponents = parent.getComponentCount();
276+ int w = 0;
277+ int h = 0;
278+
279+ for (int i = 0 ; i < ncomponents ; i++) {
280+ Component comp = parent.getComponent(i);
281+ Dimension d = comp.getPreferredSize();
282+ if (d.width > w) {
283+ w = d.width;
284+ }
285+ if (d.height > h) {
286+ h = d.height;
287+ }
288+ }
289+ return new Dimension(insets.left + insets.right + w + hgap*2,
290+ insets.top + insets.bottom + h + vgap*2);
291+ }
292+ }
293+
294+ /**
295+ * Calculates the minimum size for the specified panel.
296+ * @param parent the parent container in which to do the layout
297+ * @return the minimum dimensions required to lay out the
298+ * subcomponents of the specified container
299+ * @see java.awt.Container#doLayout
300+ * @see java.awt.CardLayout#preferredLayoutSize
301+ */
302+ public Dimension minimumLayoutSize(Container parent) {
303+ synchronized (parent.getTreeLock()) {
304+ Insets insets = parent.getInsets();
305+ int ncomponents = parent.getComponentCount();
306+ int w = 0;
307+ int h = 0;
308+
309+ for (int i = 0 ; i < ncomponents ; i++) {
310+ Component comp = parent.getComponent(i);
311+ Dimension d = comp.getMinimumSize();
312+ if (d.width > w) {
313+ w = d.width;
314+ }
315+ if (d.height > h) {
316+ h = d.height;
317+ }
318+ }
319+ return new Dimension(insets.left + insets.right + w + hgap*2,
320+ insets.top + insets.bottom + h + vgap*2);
321+ }
322+ }
323+
324+ /**
325+ * Returns the maximum dimensions for this layout given the components
326+ * in the specified target container.
327+ * @param target the component which needs to be laid out
328+ * @see Container
329+ * @see #minimumLayoutSize
330+ * @see #preferredLayoutSize
331+ */
332+ public Dimension maximumLayoutSize(Container target) {
333+ return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
334+ }
335+
336+ /**
337+ * Returns the alignment along the x axis. This specifies how
338+ * the component would like to be aligned relative to other
339+ * components. The value should be a number between 0 and 1
340+ * where 0 represents alignment along the origin, 1 is aligned
341+ * the furthest away from the origin, 0.5 is centered, etc.
342+ */
343+ public float getLayoutAlignmentX(Container parent) {
344+ return 0.5f;
345+ }
346+
347+ /**
348+ * Returns the alignment along the y axis. This specifies how
349+ * the component would like to be aligned relative to other
350+ * components. The value should be a number between 0 and 1
351+ * where 0 represents alignment along the origin, 1 is aligned
352+ * the furthest away from the origin, 0.5 is centered, etc.
353+ */
354+ public float getLayoutAlignmentY(Container parent) {
355+ return 0.5f;
356+ }
357+
358+ /**
359+ * Invalidates the layout, indicating that if the layout manager
360+ * has cached information it should be discarded.
361+ */
362+ public void invalidateLayout(Container target) {
363+ }
364+
365+ /**
366+ * Lays out the specified container using this card layout.
367+ * <p>
368+ * Each component in the <code>parent</code> container is reshaped
369+ * to be the size of the container, minus space for surrounding
370+ * insets, horizontal gaps, and vertical gaps.
371+ *
372+ * @param parent the parent container in which to do the layout
373+ * @see java.awt.Container#doLayout
374+ */
375+ public void layoutContainer(Container parent) {
376+ synchronized (parent.getTreeLock()) {
377+ Insets insets = parent.getInsets();
378+ int ncomponents = parent.getComponentCount();
379+ Component comp = null;
380+ boolean currentFound = false;
381+
382+ for (int i = 0 ; i < ncomponents ; i++) {
383+ comp = parent.getComponent(i);
384+ comp.setBounds(hgap + insets.left, vgap + insets.top,
385+ parent.width - (hgap*2 + insets.left + insets.right),
386+ parent.height - (vgap*2 + insets.top + insets.bottom));
387+ if (comp.isVisible()) {
388+ currentFound = true;
389+ }
390+ }
391+
392+ if (!currentFound && ncomponents > 0) {
393+ parent.getComponent(0).setVisible(true);
394+ }
395+ }
396+ }
397+
398+ /**
399+ * Make sure that the Container really has a CardLayout installed.
400+ * Otherwise havoc can ensue!
401+ */
402+ void checkLayout(Container parent) {
403+ if (parent.getLayout() != this) {
404+ throw new IllegalArgumentException("wrong parent for CardLayout");
405+ }
406+ }
407+
408+ /**
409+ * Flips to the first card of the container.
410+ * @param parent the parent container in which to do the layout
411+ * @see java.awt.CardLayout#last
412+ */
413+ public void first(Container parent) {
414+ synchronized (parent.getTreeLock()) {
415+ checkLayout(parent);
416+ int ncomponents = parent.getComponentCount();
417+ for (int i = 0 ; i < ncomponents ; i++) {
418+ Component comp = parent.getComponent(i);
419+ if (comp.isVisible()) {
420+ comp.setVisible(false);
421+ break;
422+ }
423+ }
424+ if (ncomponents > 0) {
425+ currentCard = 0;
426+ parent.getComponent(0).setVisible(true);
427+ parent.validate();
428+ }
429+ }
430+ }
431+
432+ /**
433+ * Flips to the next card of the specified container. If the
434+ * currently visible card is the last one, this method flips to the
435+ * first card in the layout.
436+ * @param parent the parent container in which to do the layout
437+ * @see java.awt.CardLayout#previous
438+ */
439+ public void next(Container parent) {
440+ synchronized (parent.getTreeLock()) {
441+ checkLayout(parent);
442+ int ncomponents = parent.getComponentCount();
443+ for (int i = 0 ; i < ncomponents ; i++) {
444+ Component comp = parent.getComponent(i);
445+ if (comp.isVisible()) {
446+ comp.setVisible(false);
447+ currentCard = (i + 1) % ncomponents;
448+ comp = parent.getComponent(currentCard);
449+ comp.setVisible(true);
450+ parent.validate();
451+ return;
452+ }
453+ }
454+ showDefaultComponent(parent);
455+ }
456+ }
457+
458+ /**
459+ * Flips to the previous card of the specified container. If the
460+ * currently visible card is the first one, this method flips to the
461+ * last card in the layout.
462+ * @param parent the parent container in which to do the layout
463+ * @see java.awt.CardLayout#next
464+ */
465+ public void previous(Container parent) {
466+ synchronized (parent.getTreeLock()) {
467+ checkLayout(parent);
468+ int ncomponents = parent.getComponentCount();
469+ for (int i = 0 ; i < ncomponents ; i++) {
470+ Component comp = parent.getComponent(i);
471+ if (comp.isVisible()) {
472+ comp.setVisible(false);
473+ currentCard = ((i > 0) ? i-1 : ncomponents-1);
474+ comp = parent.getComponent(currentCard);
475+ comp.setVisible(true);
476+ parent.validate();
477+ return;
478+ }
479+ }
480+ showDefaultComponent(parent);
481+ }
482+ }
483+
484+ void showDefaultComponent(Container parent) {
485+ if (parent.getComponentCount() > 0) {
486+ currentCard = 0;
487+ parent.getComponent(0).setVisible(true);
488+ parent.validate();
489+ }
490+ }
491+
492+ /**
493+ * Flips to the last card of the container.
494+ * @param parent the parent container in which to do the layout
495+ * @see java.awt.CardLayout#first
496+ */
497+ public void last(Container parent) {
498+ synchronized (parent.getTreeLock()) {
499+ checkLayout(parent);
500+ int ncomponents = parent.getComponentCount();
501+ for (int i = 0 ; i < ncomponents ; i++) {
502+ Component comp = parent.getComponent(i);
503+ if (comp.isVisible()) {
504+ comp.setVisible(false);
505+ break;
506+ }
507+ }
508+ if (ncomponents > 0) {
509+ currentCard = ncomponents - 1;
510+ parent.getComponent(currentCard).setVisible(true);
511+ parent.validate();
512+ }
513+ }
514+ }
515+
516+ /**
517+ * Flips to the component that was added to this layout with the
518+ * specified <code>name</code>, using <code>addLayoutComponent</code>.
519+ * If no such component exists, then nothing happens.
520+ * @param parent the parent container in which to do the layout
521+ * @param name the component name
522+ * @see java.awt.CardLayout#addLayoutComponent(java.awt.Component, java.lang.Object)
523+ */
524+ public void show(Container parent, String name) {
525+ synchronized (parent.getTreeLock()) {
526+ checkLayout(parent);
527+ Component next = null;
528+ int ncomponents = vector.size();
529+ for (int i = 0; i < ncomponents; i++) {
530+ Card card = (Card)vector.get(i);
531+ if (card.name.equals(name)) {
532+ next = card.comp;
533+ currentCard = i;
534+ break;
535+ }
536+ }
537+ if ((next != null) && !next.isVisible()) {
538+ ncomponents = parent.getComponentCount();
539+ for (int i = 0; i < ncomponents; i++) {
540+ Component comp = parent.getComponent(i);
541+ if (comp.isVisible()) {
542+ comp.setVisible(false);
543+ break;
544+ }
545+ }
546+ next.setVisible(true);
547+ parent.validate();
548+ }
549+ }
550+ }
551+
552+ /**
553+ * Returns a string representation of the state of this card layout.
554+ * @return a string representation of this card layout.
555+ */
556+ public String toString() {
557+ return getClass().getName() + "[hgap=" + hgap + ",vgap=" + vgap + "]";
558+ }
559+
560+ /**
561+ * Reads serializable fields from stream.
562+ */
563+ private void readObject(ObjectInputStream s)
564+ throws ClassNotFoundException, IOException
565+ {
566+ ObjectInputStream.GetField f = s.readFields();
567+
568+ hgap = f.get("hgap", 0);
569+ vgap = f.get("vgap", 0);
570+
571+ if (f.defaulted("vector")) {
572+ // pre-1.4 stream
573+ Hashtable tab = (Hashtable)f.get("tab", null);
574+ vector = new Vector();
575+ if (tab != null && !tab.isEmpty()) {
576+ for (Enumeration e = tab.keys() ; e.hasMoreElements() ; ) {
577+ String key = (String)e.nextElement();
578+ Component comp = (Component)tab.get(key);
579+ vector.add(new Card(key, comp));
580+ if (comp.isVisible()) {
581+ currentCard = vector.size() - 1;
582+ }
583+ }
584+ }
585+ } else {
586+ vector = (Vector)f.get("vector", null);
587+ currentCard = f.get("currentCard", 0);
588+ }
589+ }
590+
591+ /**
592+ * Writes serializable fields to stream.
593+ */
594+ private void writeObject(ObjectOutputStream s)
595+ throws IOException
596+ {
597+ Hashtable tab = new Hashtable();
598+ int ncomponents = vector.size();
599+ for (int i = 0; i < ncomponents; i++) {
600+ Card card = (Card)vector.get(i);
601+ tab.put(card.name, card.comp);
602+ }
603+
604+ ObjectOutputStream.PutField f = s.putFields();
605+ f.put("hgap", hgap);
606+ f.put("vgap", vgap);
607+ f.put("vector", vector);
608+ f.put("currentCard", currentCard);
609+ f.put("tab", tab);
610+ s.writeFields();
611+ }
612+}