Revision 1881 org.gvsig.tools/library/trunk/org.gvsig.tools/org.gvsig.tools.dynform/org.gvsig.tools.dynform.impl/src/main/java/org/gvsig/tools/dynform/impl/DefaultDynFormManager.java

View differences:

DefaultDynFormManager.java
24 24
package org.gvsig.tools.dynform.impl;
25 25

  
26 26
import java.util.HashMap;
27
import java.util.List;
28 27
import java.util.Map;
29
import org.apache.commons.lang3.StringUtils;
30

  
31 28
import org.gvsig.tools.dispose.DisposableIterator;
29

  
32 30
import org.gvsig.tools.dynform.DynFormDefinition;
33 31
import org.gvsig.tools.dynform.DynFormManager;
34 32
import org.gvsig.tools.dynform.JDynForm;
35
import org.gvsig.tools.dynform.JDynFormSet;
36 33
import org.gvsig.tools.dynform.spi.DynFormSPILocator;
37 34
import org.gvsig.tools.dynform.spi.DynFormSPIManager;
38 35
import org.gvsig.tools.dynobject.DynObject;
39
import org.gvsig.tools.dynobject.DynObjectSet;
40 36
import org.gvsig.tools.dynobject.DynStruct;
41
import org.gvsig.tools.service.Service;
42 37
import org.gvsig.tools.service.ServiceException;
43 38
import org.gvsig.tools.dynform.JDynForm.DynFormContext;
39
import org.gvsig.tools.dynform.JDynFormSet;
40
import org.gvsig.tools.dynform.services.dynformset.base.BaseJDynFormSetFactory;
41
import org.gvsig.tools.dynform.spi.dynform.JDynFormFactory;
42
import org.gvsig.tools.dynform.spi.dynformset.JDynFormSetFactory;
43
import org.gvsig.tools.dynobject.DynObjectSet;
44
import org.gvsig.tools.dynobject.Tags;
45
import org.gvsig.tools.util.ResourcesStorage;
46
import org.gvsig.tools.util.ResourcesStorageEmpty;
44 47

  
45
@SuppressWarnings({"unchecked", "rawtypes"})
48
@SuppressWarnings("UseSpecificCatch")
46 49
public class DefaultDynFormManager implements DynFormManager {
47 50

  
51
    
52
    private class EmptyDynFormContext implements DynFormContext {
53

  
54
        @Override
55
        public ResourcesStorage getResourcesStorage() {
56
            return new ResourcesStorageEmpty();
57
        }
58
        
59
    }
60
    
48 61
    DynFormSPIManager serviceManager = null;
49 62

  
50 63
    private Map definitions = null;
51
    private String defaultJDynFormSetname = "Subform";
64
    private final JDynFormFactory defaultJDynFormFactory;
65
    private final JDynFormSetFactory defaultJDynFormSetFactory;
52 66
            
53 67
    public DefaultDynFormManager() {
68
        this.defaultJDynFormFactory = new DefaultJDynFormFactory();
69
        this.defaultJDynFormSetFactory = new BaseJDynFormSetFactory();
54 70
    }
55 71

  
56 72
    public DynFormSPIManager getServiceManager() {
......
68 84
    }
69 85

  
70 86
    @Override
71
    public Service getService(DynObject parameters) throws ServiceException {
72
        Service service = this.serviceManager.createService(parameters);
73
        return service;
74
    }
75

  
76
    @Override
77 87
    public DynFormDefinition getDefinition(String name) {
78 88
        DefaultDynFormDefinition x;
79 89
        x = (DefaultDynFormDefinition) this.getDefinitions().get(name);
......
102 112
    }
103 113

  
104 114
    @Override
105
    public JDynForm createJDynForm(DynFormContext context, DynFormDefinition definition) throws ServiceException {
106
        DynFormSPIManager serviceManager = this.getServiceManager();
107
        JDynForm jdynform;
115
    public JDynFormSet createJDynFormSet(DynFormContext context, DynFormDefinition definition) {
116
        return this.createJDynFormSet(context, definition, null);
117
    }
118
    
119
    @Override
120
    public JDynFormSet createJDynFormSet(DynFormContext context, DynFormDefinition definition, Tags contextTags) {
121
        if( context == null ) {
122
            context = new EmptyDynFormContext();
123
        }
124
        JDynFormSet jdynformset;
108 125
        try {
109
            
110
            String s = (String) definition.getTags().get(DynFormSPIManager.TAG_DYNFORM_LAYOUTMODE);
111
            String serviceName ;
112
            if( StringUtils.isEmpty(s) ) {
113
                serviceName = serviceManager.makeServiceName(definition.getName());
114
            } else {
115
                serviceName = serviceManager.makeServiceName(s);
126
            JDynFormSetFactory factory = getServiceManager().getJDynFormSetFactory(context,definition, contextTags);
127
            jdynformset = factory.create(getServiceManager(), context, definition, contextTags);
128
//            jdynformset.setContext(context);
129
        } catch (Exception ex) {
130
            jdynformset = this.defaultJDynFormSetFactory.create(getServiceManager(), context, definition, contextTags);
131
        }
132
        return jdynformset;
133
    }
134
    
135
    @Override
136
    public JDynFormSet createJDynFormSet(DynFormContext context, DynObjectSet data) {
137
        DynObject obj = null;
138
        DisposableIterator it = null;
139
        try {
140
            if ( data.getSize() < 1 ) {
141
                throw new IllegalArgumentException("The DynObjectSet not has elements.");
116 142
            }
117
            DynObject params = serviceManager.createServiceParameters(serviceName);
118
            if(params.hasDynValue(DynFormSPIManager.FIELD_FORMSETDEFINITION) || params.getDynValue(DynFormSPIManager.FIELD_FORMSETDEFINITION) == null){
119
            	params.setDynValue(DynFormSPIManager.FIELD_FORMSETDEFINITION, definition);
143
            it = data.iterator();
144
            obj = (DynObject) it.next();
145
        } catch (Exception e) {
146
            throw new RuntimeException(e.getLocalizedMessage(), e);
147
        } finally {
148
            if ( it != null ) {
149
                it.dispose();
120 150
            }
121
            if(params.hasDynValue(DynFormSPIManager.FIELD_FORM_CONTEXT) || params.getDynValue(DynFormSPIManager.FIELD_FORM_CONTEXT) == null){
122
            	params.setDynValue(DynFormSPIManager.FIELD_FORM_CONTEXT, context);
123
            }
124
            jdynform = (JDynForm) serviceManager.getService(params);
151
        }
152
        DynFormDefinition definition = this.getDefinition(obj);
153
        JDynFormSet formset = this.createJDynFormSet(null, definition);
154
        formset.setValues(data);
155
        return formset;
156
    }    
157

  
158
    @Override
159
    public JDynForm createJDynForm(DynFormContext context, DynFormDefinition definition) {
160
        if( context == null ) {
161
            context = new EmptyDynFormContext();
162
        }
163
        JDynForm jdynform;
164
        try {
165
            JDynFormFactory factory = getServiceManager().getJDynFormFactory(context, definition);
166
            jdynform = factory.create(getServiceManager(), context, definition);
125 167
            jdynform.setContext(context);
126
        } catch (ServiceException ex) {
127
            jdynform = new DefaultJDynForm(this, definition, context);
168
        } catch (Exception ex) {
169
            jdynform = this.defaultJDynFormFactory.create(getServiceManager(), context, definition);
128 170
        }
129 171
        return jdynform;
130 172
    }
131 173

  
132 174
    @Override
133
    public JDynForm createJDynForm(DynFormContext context, DynStruct struct) throws ServiceException {
175
    public JDynForm createJDynForm(DynFormContext context, DynStruct struct) {
134 176
        DynFormDefinition definition = this.getDefinition(struct);
135 177
        return this.createJDynForm(context, definition);
136 178
    }
137 179

  
138 180
    @Override
139
    public JDynForm createJDynForm(DynFormContext context, DynObject obj) throws ServiceException {
181
    public JDynForm createJDynForm(DynFormContext context, DynObject obj) {
140 182
        DynFormDefinition definition = this.getDefinition(obj);
141 183
        JDynForm x = this.createJDynForm(context, definition);
142 184
        x.setValues(obj);
......
144 186
    }
145 187

  
146 188
    @Override
147
    public JDynForm createJDynForm(DynFormDefinition definition) throws ServiceException {
189
    public JDynForm createJDynForm(DynFormDefinition definition) {
148 190
        return this.createJDynForm(null, definition);
149 191
    }
150 192
    @Override
151
    public JDynForm createJDynForm(DynStruct struct) throws ServiceException {
193
    public JDynForm createJDynForm(DynStruct struct) {
152 194
        return this.createJDynForm(null, struct);
153 195
    }
154 196

  
155 197
    @Override
156
    public JDynForm createJDynForm(DynObject obj) throws ServiceException {
198
    public JDynForm createJDynForm(DynObject obj) {
157 199
        return this.createJDynForm(null, obj);
158 200
    }
159 201
        
160
        
161
        @Override
162
    public JDynFormSet createJDynFormSet(DynFormDefinition definition)
163
            throws ServiceException {
164
        return this.createJDynFormSet(this.defaultJDynFormSetname, definition);
165
    }
166

  
167 202
    @Override
168
    public JDynFormSet createJDynFormSet(DynStruct struct) throws ServiceException {
169
        return this.createJDynFormSet(this.defaultJDynFormSetname, struct);
170
    }
171

  
172
    @Override
173
    public JDynFormSet createJDynFormSet(DynObjectSet data)
174
            throws ServiceException {
175
        return this.createJDynFormSet(this.defaultJDynFormSetname, data);
176
    }
177

  
178
    @Override
179
    public JDynFormSet createJDynFormSet(List data)
180
            throws ServiceException {
181
        return this.createJDynFormSet(this.defaultJDynFormSetname, data);
182
    }
183

  
184
    @Override
185
    public DynObject createServiceParameters(String name)
186
            throws ServiceException {
187
        DynObject params = this.getServiceManager().createServiceParameters(name);
188
        return params;
189
    }
190

  
191
    @Override
192
    public JDynFormSet createJDynFormSet(String name, DynFormDefinition definition) throws ServiceException {
193
        DynObject params = this.createServiceParameters(name);
194
        params.setDynValue("definition", definition);
195
        JDynFormSet formset = (JDynFormSet) this.getServiceManager().getService(params);
196
        return formset;
197
    }
198

  
199
    @Override
200
    public JDynFormSet createJDynFormSet(String name, DynStruct struct) throws ServiceException {
201
        DynFormDefinition definition = this.getDefinition(struct);
202
        return this.createJDynFormSet(name, definition);
203
    }
204

  
205
    @Override
206
    public JDynFormSet createJDynFormSet(String name, List data) throws ServiceException {
207
        if ( data.size() < 1 ) {
208
            throw new IllegalArgumentException("The DynObjectSet not has elements.");
209
        }
210
        DynObject obj = (DynObject) data.get(0);
211
        JDynFormSet formset = this.createJDynFormSet(name, obj.getDynClass());
212
        formset.setValues(data);
213
        return formset;
214
    }
215

  
216
    @Override
217
    public JDynFormSet createJDynFormSet(String name, DynObjectSet data) throws ServiceException {
218
        DynObject obj = null;
219
        DisposableIterator it = null;
220
        try {
221
            if ( data.getSize() < 1 ) {
222
                throw new IllegalArgumentException("The DynObjectSet not has elements.");
223
            }
224
            it = data.iterator();
225
            obj = (DynObject) it.next();
226
        } catch (Exception e) {
227
            throw new RuntimeException(e.getLocalizedMessage(), e);
228
        } finally {
229
            if ( it != null ) {
230
                it.dispose();
231
            }
232
        }
233
        JDynFormSet formset = this.createJDynFormSet(name, obj.getDynClass());
234
        formset.setValues(data);
235
        return formset;
236
    }
237

  
238
    @Override
239
    public String getDefaultJDynFormSetName() {
240
        return this.defaultJDynFormSetname;
241
    }
242

  
243
    @Override
244
    public void setDefaultJDynFormSetName(String name) {
245
        this.defaultJDynFormSetname = name;
246
    }
247
    
248
    @Override
249 203
    public void removeDefinition(String name) {
250 204
        this.getDefinitions().remove(name);
251 205
    }
206
    
252 207
}

Also available in: Unified diff