KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > nightlabs > ipanema > person > edit > blockbased > PersonCompoundDataBlockWizardPage


1 /*
2  * Created on Jan 6, 2005
3  * by alex
4  *
5  */

6 package com.nightlabs.ipanema.person.edit.blockbased;
7
8 import java.util.HashMap JavaDoc;
9 import java.util.Iterator JavaDoc;
10 import java.util.List JavaDoc;
11 import java.util.Map JavaDoc;
12
13 import org.eclipse.swt.SWT;
14 import org.eclipse.swt.widgets.Composite;
15 import org.eclipse.swt.widgets.Control;
16
17 import com.nightlabs.ipanema.person.Person;
18 import com.nightlabs.ipanema.person.PersonDataBlock;
19 import com.nightlabs.ipanema.person.PersonDataNotFoundException;
20 import com.nightlabs.ipanema.person.id.PersonStructBlockID;
21 import com.nightlabs.rcp.composite.TightWrapperComposite;
22 import com.nightlabs.rcp.exceptionhandler.ExceptionHandlerRegistry;
23 import com.nightlabs.rcp.extensionpoint.EPProcessorException;
24 import com.nightlabs.rcp.wizard.DynamicPathWizardPage;
25
26 /**
27  * A WizardPage to define values of PersonDataFields for a
28  * set of PersonDataBlocks.
29  *
30  * @author Alexander Bieber <alex[AT]nightlabs[DOT]de>
31  */

32 public class PersonCompoundDataBlockWizardPage extends DynamicPathWizardPage {
33
34     private Person person;
35     private Map JavaDoc personDataBlockEditors = new HashMap JavaDoc();
36     private Map JavaDoc personDataBlocks = new HashMap JavaDoc();
37     private PersonStructBlockID[] structBlockIDs;
38     private int personDataBlockEditorColumnHint = 2;
39         
40     
41     TightWrapperComposite wrapperComp;
42     
43     private static PersonStructBlockID[] getArrayFromList(List JavaDoc structBlockIDs) {
44         PersonStructBlockID[] blockIDs = new PersonStructBlockID[structBlockIDs.size()];
45         int i = 0;
46         for (Iterator JavaDoc iter = structBlockIDs.iterator(); iter.hasNext();) {
47             PersonStructBlockID structBlockID = (PersonStructBlockID) iter.next();
48             blockIDs[i] = structBlockID;
49             i++;
50         }
51         return blockIDs;
52     }
53     
54     public PersonCompoundDataBlockWizardPage (
55         String JavaDoc pageName,
56         String JavaDoc title,
57         Person person,
58         List JavaDoc structBlockIDs
59     ) {
60         this(pageName, title, person, getArrayFromList(structBlockIDs));
61     }
62
63     /**
64      * Creates a new PersonCompoundDataBlockWizardPage for the
65      * StructBlock identified by the dataBlockID
66      */

67     public PersonCompoundDataBlockWizardPage (
68         String JavaDoc pageName,
69         String JavaDoc title,
70         Person person,
71         PersonStructBlockID[] structBlockIDs
72     ) {
73         super(pageName);
74         this.setTitle(title);
75         if (person == null)
76             throw new IllegalArgumentException JavaDoc("Parameter person must not be null");
77         this.person = person;
78         this.structBlockIDs = structBlockIDs;
79         for (int i = 0; i < structBlockIDs.length; i++) {
80             try {
81                 personDataBlocks.put(structBlockIDs[i],person.getPersonDataBlockGroup(structBlockIDs[i]).getPersonDataBlock(0));
82             } catch (PersonDataNotFoundException e) {
83                 ExceptionHandlerRegistry.syncHandleException(e);
84                 throw new RuntimeException JavaDoc(e);
85             }
86         }
87     }
88     
89     /**
90      * Creates the wrapper Composite.
91      * Has to be called when {@link #createControl(Composite)} is
92      * overridden.
93      *
94      * @param parent
95      */

96     protected void createWrapper(Composite parent) {
97         wrapperComp = new TightWrapperComposite(parent,SWT.NONE,true);
98         setControl(wrapperComp);
99     }
100     
101     /**
102      * Creates a composite with the PersonDataBlockEditor according
103      * to the PersonStructBlockID passed to the constructor.
104      */

105     protected void createPersonDataBlockEditors() {
106         personDataBlockEditors.clear();
107         for (int i = 0; i < structBlockIDs.length; i++) {
108             PersonDataBlock dataBlock = (PersonDataBlock)personDataBlocks.get(structBlockIDs[i]);
109             try {
110                 PersonDataBlockEditor editor =
111                     PersonDataBlockEditorFactoryRegistry.getSharedInstace().getPersonDataBlockEditor(
112 // new PersonDataBlockEditor(
113
dataBlock,
114                                 wrapperComp,
115                                 SWT.NONE,
116                                 getPersonDataBlockEditorColumnHint()
117                             );
118                 
119                 editor.refresh(dataBlock);
120                 personDataBlockEditors.put(
121                     structBlockIDs[i],
122                     editor
123                 );
124             } catch (EPProcessorException e) {
125                 ExceptionHandlerRegistry.asyncHandleException(e);
126             }
127         }
128     }
129     
130     /**
131      * Returns the person passed in the constructor.
132      *
133      * @return
134      */

135     public Person getPerson() {
136         return person;
137     }
138     
139     /**
140      * Retruns one of the PersonDataBlockEditors created by
141      * {@link #createPersonDataBlockEditors()}, thus null
142      * before a call to this method. Null can be returned
143      * as well when a PersonStructBlockID is passed here
144      * that was not in the List the WizardPage was constructed with.
145      *
146      * @return
147      */

148     public PersonDataBlockEditor getPersonDataBlockEditor(PersonStructBlockID structBlockID) {
149         return (PersonDataBlockEditor)personDataBlockEditors.get(structBlockID);
150     }
151     
152     /**
153      * Returns the personDataBlock within the given
154      * Person this Page is associated with.
155      *
156      * @return
157      */

158     public PersonDataBlock getPersonDataBlock(PersonStructBlockID structBlockID) {
159         return (PersonDataBlock)personDataBlocks.get(structBlockID);
160     }
161     
162     /**
163      * Get the hint for the column count of the
164      * PersonDataBlockEditor. Default is 2.
165      * @return
166      */

167     public int getPersonDataBlockEditorColumnHint() {
168         return personDataBlockEditorColumnHint;
169     }
170     /**
171      * Set the hint for the column count of the
172      * PersonDataBlockEditor. Default is 2.
173      *
174      * @param personDataBlockEditorColumnHint
175      */

176     public void setPersonDataBlockEditorColumnHint(
177             int personDataBlockEditorColumnHint) {
178         this.personDataBlockEditorColumnHint = personDataBlockEditorColumnHint;
179     }
180     
181   /**
182    * Set all values to the person.
183    */

184   public void updatePerson() {
185     for (Iterator JavaDoc iter = personDataBlockEditors.values().iterator(); iter.hasNext();) {
186             PersonDataBlockEditor editor = (PersonDataBlockEditor) iter.next();
187             editor.updatePerson();
188         }
189   }
190
191     /**
192      * This implementation of createControl
193      * calls {@link #createWrapper(Composite)} and {@link #createPersonDataBlockEditors()}.
194      * Subclasses can override and call this method themselves.
195      *
196      * @see org.eclipse.jface.dialogs.IDialogPage#createControl(org.eclipse.swt.widgets.Composite)
197      */

198     public Control createPageContents(Composite parent) {
199         createWrapper(parent);
200         createPersonDataBlockEditors();
201         return wrapperComp;
202     }
203 }
204
Popular Tags