Mercurial > dive4elements > river
comparison flys-client/src/main/java/org/dive4elements/river/client/client/ui/WQInputPanel.java @ 5834:f507086aa94b
Repaired internal references.
author | Sascha L. Teichmann <teichmann@intevation.de> |
---|---|
date | Thu, 25 Apr 2013 12:31:32 +0200 |
parents | flys-client/src/main/java/de/intevation/flys/client/client/ui/WQInputPanel.java@b296d435fc69 |
children | 821a02bbfb4e |
comparison
equal
deleted
inserted
replaced
5833:a2bdc0f524e8 | 5834:f507086aa94b |
---|---|
1 package de.intevation.flys.client.client.ui; | |
2 | |
3 import com.google.gwt.core.client.GWT; | |
4 import com.google.gwt.i18n.client.NumberFormat; | |
5 import com.google.gwt.user.client.rpc.AsyncCallback; | |
6 | |
7 import com.smartgwt.client.data.Record; | |
8 import com.smartgwt.client.util.SC; | |
9 import com.smartgwt.client.widgets.Canvas; | |
10 import com.smartgwt.client.widgets.Label; | |
11 import com.smartgwt.client.widgets.form.DynamicForm; | |
12 import com.smartgwt.client.widgets.form.fields.FormItem; | |
13 import com.smartgwt.client.widgets.form.fields.RadioGroupItem; | |
14 import com.smartgwt.client.widgets.form.fields.events.BlurEvent; | |
15 import com.smartgwt.client.widgets.form.fields.events.BlurHandler; | |
16 import com.smartgwt.client.widgets.form.fields.events.ChangeEvent; | |
17 import com.smartgwt.client.widgets.form.fields.events.ChangeHandler; | |
18 import com.smartgwt.client.widgets.grid.events.CellClickEvent; | |
19 import com.smartgwt.client.widgets.grid.events.CellClickHandler; | |
20 import com.smartgwt.client.widgets.layout.HLayout; | |
21 import com.smartgwt.client.widgets.layout.VLayout; | |
22 import com.smartgwt.client.widgets.tab.Tab; | |
23 import com.smartgwt.client.widgets.tab.TabSet; | |
24 | |
25 import de.intevation.flys.client.client.Config; | |
26 import de.intevation.flys.client.client.FLYSConstants; | |
27 import de.intevation.flys.client.client.services.WQInfoService; | |
28 import de.intevation.flys.client.client.services.WQInfoServiceAsync; | |
29 import de.intevation.flys.client.client.ui.wq.QDTable; | |
30 import de.intevation.flys.client.client.ui.wq.WTable; | |
31 import de.intevation.flys.client.shared.model.ArtifactDescription; | |
32 import de.intevation.flys.client.shared.model.Data; | |
33 import de.intevation.flys.client.shared.model.DataItem; | |
34 import de.intevation.flys.client.shared.model.DataList; | |
35 import de.intevation.flys.client.shared.model.DefaultData; | |
36 import de.intevation.flys.client.shared.model.DefaultDataItem; | |
37 import de.intevation.flys.client.shared.model.WQInfoObject; | |
38 import de.intevation.flys.client.shared.model.WQInfoRecord; | |
39 | |
40 import java.util.ArrayList; | |
41 import java.util.LinkedHashMap; | |
42 import java.util.List; | |
43 | |
44 | |
45 /** | |
46 * This UIProvider creates a widget to enter W or Q data. | |
47 * | |
48 * @author <a href="mailto:ingo.weinzierl@intevation.de">Ingo Weinzierl</a> | |
49 */ | |
50 public class WQInputPanel | |
51 extends AbstractUIProvider | |
52 implements ChangeHandler, BlurHandler | |
53 { | |
54 private static final long serialVersionUID = 4797387993390350341L; | |
55 | |
56 /** The message class that provides i18n strings.*/ | |
57 protected FLYSConstants MESSAGE = GWT.create(FLYSConstants.class); | |
58 | |
59 protected WQInfoServiceAsync wqInfoService = | |
60 GWT.create(WQInfoService.class); | |
61 | |
62 /** The constant field name for choosing w or q mode.*/ | |
63 public static final String FIELD_WQ_W_FREE = "WFREE"; | |
64 | |
65 /** The constant field name for choosing w or q mode.*/ | |
66 public static final String FIELD_WQ = "wq"; | |
67 | |
68 /** The constant field value for W input mode.*/ | |
69 public static final String FIELD_WQ_W = "W"; | |
70 | |
71 /** The constant field value for Q input mode.*/ | |
72 public static final String FIELD_WQ_Q = "Q"; | |
73 | |
74 /** The constant field value for Q input mode.*/ | |
75 public static final String FIELD_WQ_Q_FREE = "QFREE"; | |
76 | |
77 /** The constant field name for choosing single values or range.*/ | |
78 public static final String FIELD_MODE = "mode"; | |
79 | |
80 /** The constant field value for single input mode.*/ | |
81 public static final String FIELD_MODE_SINGLE = "single"; | |
82 | |
83 /** The constant field value for range input mode.*/ | |
84 public static final String FIELD_MODE_RANGE = "range"; | |
85 | |
86 /** The constant value that determines the width of the left panel.*/ | |
87 public static final int WIDTH_LEFT_UPPER = 400; | |
88 | |
89 public static final int WIDTH_LEFT_LOWER = 223; | |
90 | |
91 /** The container that manages the w and q panels.*/ | |
92 protected HLayout container; | |
93 | |
94 /** The RadioGroupItem that determines the w/q input mode.*/ | |
95 protected DynamicForm modes; | |
96 | |
97 /** The min values for the 'from' property in the W-Range input mode.*/ | |
98 protected double minW; | |
99 | |
100 /** The min values for the 'from' property in the Q-Range input mode.*/ | |
101 protected double minQ; | |
102 | |
103 /** The min value for the 'from' property in the free Q-Range input mode.*/ | |
104 protected double minQFree; | |
105 | |
106 /** The min value for the 'from' property in the free W-Range input mode.*/ | |
107 protected double minWFree; | |
108 | |
109 /** The max values for the 'from' property in the W-Range input mode.*/ | |
110 protected double maxW; | |
111 | |
112 /** The max values for the 'from' property in the Q-Range input mode.*/ | |
113 protected double maxQ; | |
114 | |
115 /** The max value for the 'from' property in the free Q-Range input mode.*/ | |
116 protected double maxQFree; | |
117 | |
118 /** The max value for the 'from' property in the free W-Range input mode.*/ | |
119 protected double maxWFree; | |
120 | |
121 /** The 'from' value entered in the range W mode.*/ | |
122 protected double fromW; | |
123 | |
124 /** The 'to' value entered in the range W mode.*/ | |
125 protected double toW; | |
126 | |
127 /** The 'step' value entered in the range W mode.*/ | |
128 protected double stepW; | |
129 | |
130 /** The values entered in the single W mode.*/ | |
131 protected double[] valuesW; | |
132 | |
133 /** The values entered in the single W mode.*/ | |
134 protected double[] valuesWFree; | |
135 | |
136 /** The 'from' value entered in the range Q mode.*/ | |
137 protected double fromQ; | |
138 | |
139 /** The 'from' value entered in the range free Q mode.*/ | |
140 protected double fromQFree; | |
141 | |
142 /** The 'from' value entered in the range free W mode.*/ | |
143 protected double fromWFree; | |
144 | |
145 /** The 'to' value entered in the range Q mode.*/ | |
146 protected double toQ; | |
147 | |
148 /** The 'to' value entered in the range free Q mode.*/ | |
149 protected double toQFree; | |
150 | |
151 /** The 'to' value entered in the range free W mode.*/ | |
152 protected double toWFree; | |
153 | |
154 /** The 'step' value entered in the range Q mode.*/ | |
155 protected double stepQ; | |
156 | |
157 /** The 'step' value entered in the range free Q mode.*/ | |
158 protected double stepQFree; | |
159 | |
160 /** The 'step' value entered in the range free W mode.*/ | |
161 protected double stepWFree; | |
162 | |
163 /** The values entered in the single Q mode.*/ | |
164 protected double[] valuesQ; | |
165 | |
166 /** The values entered in the single free Q mode.*/ | |
167 protected double[] valuesQFree; | |
168 | |
169 /** The input panel for W values*/ | |
170 protected DoubleArrayPanel wArrayPanel; | |
171 | |
172 /** The input panel for q values*/ | |
173 protected DoubleArrayPanel qArrayPanel; | |
174 | |
175 /** The input panel for free q values*/ | |
176 protected DoubleArrayPanel qFreeArrayPanel; | |
177 | |
178 /** The input panel for free w values*/ | |
179 protected DoubleArrayPanel wFreeArrayPanel; | |
180 | |
181 /** The input panel for w range*/ | |
182 protected DoubleRangePanel wRangePanel; | |
183 | |
184 /** The input panel for q range*/ | |
185 protected DoubleRangePanel qRangePanel; | |
186 | |
187 /** The input panel for free q range*/ | |
188 protected DoubleRangePanel qFreeRangePanel; | |
189 | |
190 /** The input panel for free w range*/ | |
191 protected DoubleRangePanel wFreeRangePanel; | |
192 | |
193 protected QDTable qdTable; | |
194 | |
195 protected WTable wTable; | |
196 | |
197 protected TabSet tabs; | |
198 | |
199 /** | |
200 * Creates a new WQInputPanel instance. | |
201 */ | |
202 public WQInputPanel() { | |
203 qdTable = new QDTable(); | |
204 wTable = new WTable(); | |
205 | |
206 initTableListeners(); | |
207 } | |
208 | |
209 | |
210 /** | |
211 * Initializes the listeners of the WQD tables. | |
212 */ | |
213 protected void initTableListeners() { | |
214 CellClickHandler handler = new CellClickHandler() { | |
215 @Override | |
216 public void onCellClick(CellClickEvent e) { | |
217 if (isWMode() || qdTable.isLocked()) { | |
218 return; | |
219 } | |
220 | |
221 int idx = e.getColNum(); | |
222 Record r = e.getRecord (); | |
223 double val = r.getAttributeAsDouble("value"); | |
224 | |
225 if (idx == 0) { | |
226 if (isRangeMode()) { | |
227 qRangePanel.setFrom(val); | |
228 } | |
229 else { | |
230 qArrayPanel.addValue(val); | |
231 } | |
232 } | |
233 else if (idx == 1) { | |
234 if (isRangeMode()) { | |
235 qRangePanel.setTo(val); | |
236 } | |
237 else { | |
238 qArrayPanel.addValue(val); | |
239 } | |
240 } | |
241 } | |
242 }; | |
243 | |
244 qdTable.addCellClickHandler(handler); | |
245 } | |
246 | |
247 | |
248 /** | |
249 * This method calls createWidget and puts a 'next' button to the bottom. | |
250 * | |
251 * @param data The data that is displayed. | |
252 * | |
253 * @return the widget. | |
254 */ | |
255 @Override | |
256 public Canvas create(DataList data) { | |
257 initDefaults(data); | |
258 | |
259 Canvas widget = createWidget(data); | |
260 Canvas submit = getNextButton(); | |
261 Label label = new Label(MESSAGE.wqTitle()); | |
262 | |
263 label.setHeight(25); | |
264 | |
265 VLayout layout = new VLayout(); | |
266 layout.setMembersMargin(10); | |
267 | |
268 layout.addMember(label); | |
269 layout.addMember(widget); | |
270 layout.addMember(submit); | |
271 | |
272 initHelperPanel(); | |
273 initUserDefaults(data); | |
274 | |
275 return layout; | |
276 } | |
277 | |
278 | |
279 /** Inits the helper panel. */ | |
280 // TODO duplicate in WQAdaptedInputPanel | |
281 protected void initHelperPanel() { | |
282 tabs = new TabSet(); | |
283 tabs.setWidth100(); | |
284 tabs.setHeight100(); | |
285 | |
286 Tab wTab = new Tab(MESSAGE.wq_table_w()); | |
287 Tab qTab = new Tab(MESSAGE.wq_table_q()); | |
288 | |
289 qdTable.showSelect(); | |
290 wTab.setPane(wTable); | |
291 qTab.setPane(qdTable); | |
292 | |
293 tabs.addTab(wTab, 0); | |
294 tabs.addTab(qTab, 1); | |
295 | |
296 helperContainer.addMember(tabs); | |
297 | |
298 fetchWQData(); | |
299 } | |
300 | |
301 | |
302 @Override | |
303 public Canvas createOld(DataList dataList) { | |
304 List<Data> items = dataList.getAll(); | |
305 | |
306 Data dMode = getData(items, "wq_isq"); | |
307 Data dFree = getData(items, "wq_isfree"); | |
308 Data dSelection = getData(items, "wq_isrange"); | |
309 Data dSingle = getData(items, "wq_single"); | |
310 Data dFrom = getData(items, "wq_from"); | |
311 Data dTo = getData(items, "wq_to"); | |
312 Data dStep = getData(items, "wq_step"); | |
313 | |
314 DataItem[] mode = dMode.getItems(); | |
315 String strMode = mode[0].getStringValue(); | |
316 boolean isQMode = Boolean.valueOf(strMode); | |
317 | |
318 DataItem[] free = dFree.getItems(); | |
319 String strFree = free[0].getStringValue(); | |
320 boolean isFree = Boolean.valueOf(strFree); | |
321 | |
322 HLayout layout = new HLayout(); | |
323 layout.setWidth("400px"); | |
324 | |
325 Label label = new Label(dataList.getLabel()); | |
326 label.setWidth("200px"); | |
327 | |
328 VLayout vLabel = null; | |
329 | |
330 DataItem[] selItem = dSelection.getItems(); | |
331 boolean isRange = selItem != null | |
332 ? Boolean.valueOf(selItem[0].getStringValue()) | |
333 : false; | |
334 | |
335 if (!isRange) { | |
336 DataItem[] single = dSingle.getItems(); | |
337 | |
338 vLabel = !isQMode | |
339 ? createWString(single[0]) | |
340 : createQString(single[0]); | |
341 } | |
342 else { | |
343 DataItem[] from = dFrom.getItems(); | |
344 DataItem[] to = dTo.getItems(); | |
345 DataItem[] step = dStep.getItems(); | |
346 | |
347 vLabel = !isQMode | |
348 ? createWString(from[0], to[0], step[0]) | |
349 : createQString(from[0], to[0], step[0]); | |
350 } | |
351 | |
352 VLayout selectedLayout = new VLayout(); | |
353 String wqMode = null; | |
354 | |
355 if (!isQMode) { | |
356 wqMode = isFree ? MESSAGE.wqWFree() : MESSAGE.wqW(); | |
357 } | |
358 else { | |
359 wqMode = isFree ? MESSAGE.wqQ() : MESSAGE.wqQGauge(); | |
360 } | |
361 | |
362 Label mLabel = new Label(wqMode); | |
363 mLabel.setWidth(175); | |
364 mLabel.setHeight(20); | |
365 | |
366 selectedLayout.addMember(mLabel); | |
367 selectedLayout.addMember(vLabel); | |
368 selectedLayout.setHeight(40); | |
369 | |
370 Canvas back = getBackButton(dataList.getState()); | |
371 | |
372 layout.addMember(label); | |
373 layout.addMember(selectedLayout); | |
374 layout.addMember(back); | |
375 | |
376 return layout; | |
377 } | |
378 | |
379 | |
380 /** | |
381 * This method reads the default values defined in the DataItems of the Data | |
382 * objects in <i>list</i>. | |
383 * | |
384 * @param list The DataList container that stores the Data objects. | |
385 */ | |
386 protected void initDefaults(DataList list) { | |
387 Data f = getData(list.getAll(), "wq_from"); | |
388 Data t = getData(list.getAll(), "wq_to"); | |
389 Data s = getData(list.getAll(), "wq_step"); | |
390 | |
391 DataItem fQItem = getDataItem(f.getItems(), "minQ"); | |
392 DataItem fWItem = getDataItem(f.getItems(), "minW"); | |
393 DataItem tQItem = getDataItem(t.getItems(), "maxQ"); | |
394 DataItem tWItem = getDataItem(t.getItems(), "maxW"); | |
395 DataItem sQItem = getDataItem(s.getItems(), "stepQ"); | |
396 DataItem sWItem = getDataItem(s.getItems(), "stepW"); | |
397 DataItem fQFItem = getDataItem(f.getItems(), "minQFree"); | |
398 DataItem tQFItem = getDataItem(t.getItems(), "maxQFree"); | |
399 DataItem sQFItem = getDataItem(s.getItems(), "stepQFree"); | |
400 DataItem fWFItem = getDataItem(f.getItems(), "minWFree"); | |
401 DataItem tWFItem = getDataItem(t.getItems(), "maxWFree"); | |
402 DataItem sWFItem = getDataItem(s.getItems(), "stepWFree"); | |
403 | |
404 minW = Double.valueOf(fWItem.getStringValue()); | |
405 maxW = Double.valueOf(tWItem.getStringValue()); | |
406 stepW = Double.valueOf(sWItem.getStringValue()); | |
407 | |
408 minQ = Double.valueOf(fQItem.getStringValue()); | |
409 maxQ = Double.valueOf(tQItem.getStringValue()); | |
410 stepQ = Double.valueOf(sQItem.getStringValue()); | |
411 | |
412 minQFree = Double.valueOf(fQFItem.getStringValue()); | |
413 maxQFree = Double.valueOf(tQFItem.getStringValue()); | |
414 stepQFree = Double.valueOf(sQFItem.getStringValue()); | |
415 | |
416 minWFree = Double.valueOf(fWFItem.getStringValue()); | |
417 maxWFree = Double.valueOf(tWFItem.getStringValue()); | |
418 stepWFree = Double.valueOf(sWFItem.getStringValue()); | |
419 | |
420 this.fromW = minW; | |
421 this.toW = maxW; | |
422 | |
423 this.fromQ = minQ; | |
424 this.toQ = maxQ; | |
425 | |
426 this.fromQFree = minQFree; | |
427 this.toQFree = maxQFree; | |
428 | |
429 this.fromWFree = minWFree; | |
430 this.toWFree = maxWFree; | |
431 } | |
432 | |
433 | |
434 /** | |
435 * Initializes the form items with former inserted user data. | |
436 * | |
437 * @param list The DataList that contains the user data. | |
438 */ | |
439 protected void initUserDefaults(DataList list) { | |
440 List<Data> allData = list.getAll(); | |
441 | |
442 Data m = getData(allData, "wq_isq"); | |
443 DataItem modeItem = m != null ? m.getDefault() : null; | |
444 boolean isQ = modeItem != null | |
445 ? Boolean.valueOf(modeItem.getStringValue()) | |
446 : false; | |
447 | |
448 Data f = getData(allData, "wq_isfree"); | |
449 DataItem freeItem = f != null ? f.getDefault() : null; | |
450 boolean isFree = freeItem != null | |
451 ? Boolean.valueOf(freeItem.getStringValue()) | |
452 : false; | |
453 | |
454 Data s = getData(allData, "wq_isrange"); | |
455 DataItem sI = s != null ? s.getDefault() : null; | |
456 boolean isRange = sI != null | |
457 ? Boolean.valueOf(sI.getStringValue()) | |
458 : false; | |
459 | |
460 initUserSingleValues(list, isQ); | |
461 initUserRangeValues(list, isQ); | |
462 | |
463 if (isQ) { | |
464 modes.setValue(FIELD_WQ, isQ); | |
465 } | |
466 else { | |
467 modes.setValue(FIELD_WQ, isFree ? FIELD_WQ_Q_FREE : FIELD_WQ_Q); | |
468 } | |
469 | |
470 if(isRange) { | |
471 modes.setValue(FIELD_MODE, FIELD_MODE_RANGE); | |
472 } | |
473 else { | |
474 modes.setValue(FIELD_MODE, FIELD_MODE_SINGLE); | |
475 } | |
476 updatePanels(isQ, isFree, isRange); | |
477 } | |
478 | |
479 | |
480 /** | |
481 * Initializes the single values of W or Q from DataList. | |
482 * | |
483 * @param list The DataList that contains the 'wq_single' object. | |
484 * @param isQ W or Q mode? | |
485 */ | |
486 protected void initUserSingleValues(DataList list, boolean isQ) { | |
487 List<Data> allData = list.getAll(); | |
488 | |
489 | |
490 Data s = getData(allData, "wq_single"); | |
491 DataItem i = s != null ? s.getDefault() : null; | |
492 GWT.log("init values: " + i.getStringValue()); | |
493 | |
494 if (i != null) { | |
495 String value = i.getStringValue(); | |
496 String[] split = value.split(" "); | |
497 | |
498 int num = split != null ? split.length : 0; | |
499 | |
500 double[] values = new double[num]; | |
501 | |
502 for (int j = 0; j < num; j++) { | |
503 try { | |
504 values[j] = Double.valueOf(split[j]); | |
505 } | |
506 catch (NumberFormatException nfe) { | |
507 // nothing to do | |
508 } | |
509 } | |
510 | |
511 if (!isQ) { | |
512 setSingleW(values); | |
513 } | |
514 else { | |
515 setSingleQ(values); | |
516 } | |
517 } | |
518 } | |
519 | |
520 | |
521 /** | |
522 * Initializes the range values of W or Q from DataList. | |
523 * | |
524 * @param list The DataList that contains the 'wq_single' object. | |
525 * @param isQ W or Q mode? | |
526 */ | |
527 protected void initUserRangeValues(DataList list, boolean isQ) { | |
528 List<Data> allData = list.getAll(); | |
529 | |
530 // init range mode values | |
531 Data f = getData(allData, "wq_from"); | |
532 Data t = getData(allData, "wq_to"); | |
533 Data s = getData(allData, "wq_step"); | |
534 | |
535 if (f != null && t != null && s != null) { | |
536 DataItem dF = f.getDefault(); | |
537 DataItem dT = t.getDefault(); | |
538 DataItem dS = s.getDefault(); | |
539 | |
540 String fS = dF != null ? dF.getStringValue() : null; | |
541 String tS = dT != null ? dT.getStringValue() : null; | |
542 String sS = dS != null ? dS.getStringValue() : null; | |
543 | |
544 try { | |
545 double from = Double.valueOf(fS); | |
546 double to = Double.valueOf(tS); | |
547 double step = Double.valueOf(sS); | |
548 | |
549 if (!isQ) { | |
550 setWRangeValues(from, to, step); | |
551 } | |
552 else { | |
553 setQRangeValues(from, to, step); | |
554 } | |
555 } | |
556 catch (NumberFormatException nfe) { | |
557 // do nothing | |
558 } | |
559 } | |
560 } | |
561 | |
562 | |
563 protected void setQRangeValues(double f, double t, double s) { | |
564 setFromQ(f); | |
565 setToQ(t); | |
566 setStepQ(s); | |
567 } | |
568 | |
569 | |
570 protected void setWRangeValues(double f, double t, double s) { | |
571 setFromW(f); | |
572 setToW(t); | |
573 setStepW(s); | |
574 } | |
575 | |
576 | |
577 protected VLayout createWString(DataItem from, DataItem to, DataItem step) { | |
578 VLayout v = new VLayout(); | |
579 | |
580 StringBuilder sb = new StringBuilder(); | |
581 sb.append(from.getLabel()); | |
582 sb.append(" " + MESSAGE.unitWFrom() + " "); | |
583 sb.append(to.getLabel()); | |
584 sb.append(" " + MESSAGE.unitWTo() + " "); | |
585 sb.append(step.getLabel()); | |
586 sb.append(" " + MESSAGE.unitWStep()); | |
587 | |
588 v.addMember(new Label(sb.toString())); | |
589 | |
590 return v; | |
591 } | |
592 | |
593 | |
594 protected VLayout createWString(DataItem single) { | |
595 String label = single.getLabel().trim(); | |
596 String[] cols = label.split(";"); | |
597 | |
598 VLayout v = new VLayout(); | |
599 | |
600 for (String col: cols) { | |
601 Label l = new Label(col + " " + MESSAGE.unitWSingle()); | |
602 l.setHeight(20); | |
603 | |
604 v.addMember(l); | |
605 } | |
606 | |
607 return v; | |
608 } | |
609 | |
610 | |
611 protected VLayout createQString(DataItem from, DataItem to, DataItem step) { | |
612 VLayout v = new VLayout(); | |
613 | |
614 StringBuilder sb = new StringBuilder(); | |
615 sb.append(from.getLabel()); | |
616 sb.append(" " + MESSAGE.unitQFrom() + " "); | |
617 sb.append(to.getLabel()); | |
618 sb.append(" " + MESSAGE.unitQTo() + " "); | |
619 sb.append(step.getLabel()); | |
620 sb.append(" " + MESSAGE.unitQStep()); | |
621 | |
622 v.addMember(new Label(sb.toString())); | |
623 | |
624 return v; | |
625 } | |
626 | |
627 | |
628 protected VLayout createQString(DataItem single) { | |
629 String label = single.getLabel().trim(); | |
630 String[] cols = label.split(";"); | |
631 | |
632 VLayout v = new VLayout(); | |
633 | |
634 for (String col: cols) { | |
635 Label l = new Label(col + " " + MESSAGE.unitQSingle()); | |
636 l.setHeight(20); | |
637 | |
638 v.addMember(l); | |
639 } | |
640 | |
641 return v; | |
642 } | |
643 | |
644 | |
645 /** | |
646 * This method creates the whole widget. There is a panel on the left, that | |
647 * allows the user to enter values manually by keyboard. On the right, there | |
648 * is a table that allows the user to enter values by mouse click. | |
649 * | |
650 * @param data The data that is displayed in the table on the right. | |
651 * | |
652 * @return the widget. | |
653 */ | |
654 protected Canvas createWidget(DataList data) { | |
655 VLayout layout = new VLayout(); | |
656 container = new HLayout(); | |
657 Canvas modeForm = createModePanel(); | |
658 | |
659 container.setMembersMargin(30); | |
660 | |
661 // the initial panel is the Single-W panel. | |
662 double[] values = getSingleQ(); | |
663 qArrayPanel = new DoubleArrayPanel( | |
664 MESSAGE.unitQSingle(), values, this); | |
665 container.addMember(qArrayPanel); | |
666 | |
667 layout.addMember(modeForm); | |
668 layout.addMember(container); | |
669 | |
670 return layout; | |
671 } | |
672 | |
673 | |
674 /** | |
675 * This method creates the mode panel. It contains two radio button panels | |
676 * that allows the user to switch the input mode between w/q and | |
677 * single/range input. | |
678 * | |
679 * @return a panel. | |
680 */ | |
681 protected Canvas createModePanel() { | |
682 RadioGroupItem wq = new RadioGroupItem(FIELD_WQ); | |
683 wq.setShowTitle(false); | |
684 wq.setVertical(true); | |
685 wq.setWidth(WIDTH_LEFT_UPPER); | |
686 wq.setWrap(false); | |
687 | |
688 RadioGroupItem mode = new RadioGroupItem(FIELD_MODE); | |
689 mode.setShowTitle(false); | |
690 mode.setVertical(false); | |
691 mode.setWidth(WIDTH_LEFT_LOWER); | |
692 | |
693 LinkedHashMap wqValues = new LinkedHashMap(); | |
694 wqValues.put(FIELD_WQ_W, MESSAGE.wqW()); | |
695 wqValues.put(FIELD_WQ_W_FREE, MESSAGE.wqWFree()); | |
696 wqValues.put(FIELD_WQ_Q_FREE, MESSAGE.wqQ()); | |
697 wqValues.put(FIELD_WQ_Q, MESSAGE.wqQGauge()); | |
698 | |
699 LinkedHashMap modeValues = new LinkedHashMap(); | |
700 modeValues.put(FIELD_MODE_SINGLE, MESSAGE.wqSingle()); | |
701 modeValues.put(FIELD_MODE_RANGE, MESSAGE.wqRange()); | |
702 | |
703 wq.setValueMap(wqValues); | |
704 mode.setValueMap(modeValues); | |
705 | |
706 wq.addChangeHandler(this); | |
707 mode.addChangeHandler(this); | |
708 | |
709 modes = new DynamicForm(); | |
710 modes.setFields(wq, mode); | |
711 modes.setWidth(WIDTH_LEFT_UPPER); | |
712 modes.setNumCols(1); | |
713 | |
714 LinkedHashMap initial = new LinkedHashMap(); | |
715 initial.put(FIELD_WQ, FIELD_WQ_Q); | |
716 initial.put(FIELD_MODE, FIELD_MODE_SINGLE); | |
717 modes.setValues(initial); | |
718 | |
719 return modes; | |
720 } | |
721 | |
722 | |
723 @Override | |
724 public List<String> validate() { | |
725 if (isRangeMode()) { | |
726 return validateRangeValues(); | |
727 } | |
728 else { | |
729 return validateSingleValues(); | |
730 } | |
731 } | |
732 | |
733 | |
734 protected List<String> validateRangeValues() { | |
735 if (isWFree()) { | |
736 return validateRange(wFreeRangePanel, minWFree, maxWFree); | |
737 } | |
738 else if (isQFree()) { | |
739 return validateRange(qFreeRangePanel, minQFree, maxQFree); | |
740 } | |
741 else if (isWMode()) { | |
742 return validateRange(wRangePanel, minW, maxW); | |
743 } | |
744 else { | |
745 return validateRange(qRangePanel, minQ, maxQ); | |
746 } | |
747 } | |
748 | |
749 protected List<String> validateSingleValues() { | |
750 if (isWFree()) { | |
751 return validateSingle(wFreeArrayPanel, minWFree, maxWFree); | |
752 } | |
753 else if (isWMode()) { | |
754 return validateSingle(wArrayPanel, minW, maxW); | |
755 //return validateSingle(wArrayPanel, 0, 100000); | |
756 } | |
757 else if (isQFree()) { | |
758 return validateSingle(qFreeArrayPanel, minQFree, maxQFree); | |
759 } | |
760 else { | |
761 return validateSingle(qArrayPanel, minQ, maxQ); | |
762 } | |
763 } | |
764 | |
765 | |
766 protected List<String> validateRange( | |
767 DoubleRangePanel panel, | |
768 double min, double max) | |
769 { | |
770 List<String> errors = new ArrayList<String>(); | |
771 NumberFormat nf = NumberFormat.getDecimalFormat(); | |
772 | |
773 if (!panel.validateForm()) { | |
774 errors.add(MESSAGE.wrongFormat()); | |
775 } | |
776 | |
777 double from; | |
778 double to; | |
779 double step; | |
780 | |
781 try { | |
782 from = panel.getFrom(); | |
783 to = panel.getTo(); | |
784 step = panel.getStep(); | |
785 } | |
786 catch (NullPointerException npe) { | |
787 errors.add(MESSAGE.missingInput()); | |
788 return errors; | |
789 } | |
790 | |
791 if (from < min || from > max) { | |
792 String tmp = MESSAGE.error_validate_lower_range(); | |
793 tmp = tmp.replace("$1", nf.format(from)); | |
794 tmp = tmp.replace("$2", nf.format(min)); | |
795 errors.add(tmp); | |
796 from = min; | |
797 } | |
798 | |
799 if (to < min || to > max) { | |
800 String tmp = MESSAGE.error_validate_upper_range(); | |
801 tmp = tmp.replace("$1", nf.format(to)); | |
802 tmp = tmp.replace("$2", nf.format(max)); | |
803 errors.add(tmp); | |
804 to = max; | |
805 } | |
806 | |
807 if (!errors.isEmpty()) { | |
808 panel.setValues(from, to, step); | |
809 } | |
810 | |
811 return errors; | |
812 } | |
813 | |
814 | |
815 protected List<String> validateSingle( | |
816 DoubleArrayPanel panel, | |
817 double min, double max) | |
818 { | |
819 List<String> errors = new ArrayList<String>(); | |
820 NumberFormat nf = NumberFormat.getDecimalFormat(); | |
821 | |
822 if (!panel.validateForm()) { | |
823 errors.add(MESSAGE.wrongFormat()); | |
824 } | |
825 | |
826 double[] values = panel.getInputValues(); | |
827 | |
828 if (values == null || values.length == 0) { | |
829 errors.add(MESSAGE.atLeastOneValue()); | |
830 return errors; | |
831 } | |
832 | |
833 double[] good = new double[values.length]; | |
834 int idx = 0; | |
835 | |
836 for (double value: values) { | |
837 if (value < min || value > max) { | |
838 String tmp = MESSAGE.error_validate_range(); | |
839 tmp = tmp.replace("$1", nf.format(value)); | |
840 tmp = tmp.replace("$2", nf.format(min)); | |
841 tmp = tmp.replace("$3", nf.format(max)); | |
842 errors.add(tmp); | |
843 } | |
844 else { | |
845 good[idx++] = value; | |
846 } | |
847 } | |
848 | |
849 double[] justGood = new double[idx]; | |
850 for (int i = 0; i < justGood.length; i++) { | |
851 justGood[i] = good[i]; | |
852 } | |
853 | |
854 if (!errors.isEmpty()) { | |
855 panel.setValues(justGood); | |
856 } | |
857 | |
858 return errors; | |
859 } | |
860 | |
861 | |
862 /** | |
863 * This method returns the selected data. | |
864 * | |
865 * @return the selected/inserted data. | |
866 */ | |
867 @Override | |
868 public Data[] getData() { | |
869 // XXX If we have entered a value and click right afterwards on the | |
870 // 'next' button, the BlurEvent is not fired, and the values are not | |
871 // saved. So, we gonna save those values explicitly. | |
872 if (!isRangeMode()) { | |
873 Canvas member = container.getMember(0); | |
874 if (member instanceof DoubleArrayPanel) { | |
875 DoubleArrayPanel form = (DoubleArrayPanel) member; | |
876 if (isWFree()) { | |
877 saveSingleWFreeValues(form); | |
878 } | |
879 else if (isWMode()) { | |
880 saveSingleWValues(form); | |
881 } | |
882 else if (isQFree()) { | |
883 saveSingleQFreeValues(form); | |
884 } | |
885 else { | |
886 saveSingleQValues(form); | |
887 } | |
888 } | |
889 | |
890 return getSingleData(); | |
891 } | |
892 else { | |
893 Canvas member = container.getMember(0); | |
894 if (member instanceof DoubleRangePanel) { | |
895 DoubleRangePanel form = (DoubleRangePanel) member; | |
896 | |
897 if (isWFree()) { | |
898 saveRangeWFreeValues(form); | |
899 } | |
900 else if (isWMode()) { | |
901 saveRangeWValues(form); | |
902 } | |
903 else if (isQFree()) { | |
904 saveRangeQFreeValues(form); | |
905 } | |
906 else { | |
907 saveRangeQValues(form); | |
908 } | |
909 } | |
910 | |
911 return getRangeData(); | |
912 } | |
913 } | |
914 | |
915 | |
916 /** | |
917 * Collects the required data for single mode and resets the data for range | |
918 * mode. | |
919 */ | |
920 protected Data[] getSingleData() { | |
921 DataItem from = new DefaultDataItem("wq_from", "wq_from", ""); | |
922 DataItem to = new DefaultDataItem("wq_to", "wq_to", ""); | |
923 DataItem step = new DefaultDataItem("wq_step", "wq_step", ""); | |
924 | |
925 return new Data[] { | |
926 getDataMode(), | |
927 getFree(), | |
928 getDataSelectionMode(), | |
929 getDataSingle(), | |
930 new DefaultData( | |
931 "wq_from", | |
932 null, | |
933 null, | |
934 new DataItem[] {from}), | |
935 new DefaultData( | |
936 "wq_to", | |
937 null, | |
938 null, | |
939 new DataItem[] {to}), | |
940 new DefaultData( | |
941 "wq_step", | |
942 null, | |
943 null, | |
944 new DataItem[] {step}) }; | |
945 } | |
946 | |
947 | |
948 /** | |
949 * Collects the required data for range mode and resets the data for single | |
950 * mode. | |
951 */ | |
952 protected Data[] getRangeData() { | |
953 DataItem item = new DefaultDataItem("wq_single", "wq_single", ""); | |
954 | |
955 return new Data[] { | |
956 getDataMode(), | |
957 getFree(), | |
958 getDataSelectionMode(), | |
959 getDataFrom(), | |
960 getDataTo(), | |
961 getDataStep(), | |
962 new DefaultData( | |
963 "wq_single", | |
964 null, | |
965 null, | |
966 new DataItem[] {item}) }; | |
967 } | |
968 | |
969 | |
970 /** | |
971 * Returns the Data object for the 'mode' attribute. | |
972 * | |
973 * @return the Data object for the 'mode' attribute. | |
974 */ | |
975 protected Data getDataMode() { | |
976 String wqMode = modes.getValueAsString(FIELD_WQ); | |
977 | |
978 String value = null; | |
979 if (wqMode.equals(FIELD_WQ_Q_FREE) || wqMode.equals(FIELD_WQ_Q)) { | |
980 GWT.log("getData: FIELD_WQ_Q || FIELD_WQ_Q_FREE"); | |
981 value = "true"; | |
982 } | |
983 else { | |
984 GWT.log("getData: FIELD_WQ_W || FIELD_WQ_W_FREE"); | |
985 value = "false"; | |
986 } | |
987 | |
988 DataItem item = new DefaultDataItem("wq_isq", "wq_isq", value); | |
989 return new DefaultData( | |
990 "wq_isq", null, null, new DataItem[] { item }); | |
991 } | |
992 | |
993 | |
994 /** | |
995 * Returns the Q mode. The Q mode can be "true" or "false". True means, the | |
996 * calculation is not based on a gauge, false means the calculation should | |
997 * be based on a gauge. | |
998 * | |
999 * @return the Data object for the 'wq_free' attribute. | |
1000 */ | |
1001 protected Data getFree() { | |
1002 String value = ""; | |
1003 if(!isWMode()) { | |
1004 value = isQFree() ? "true" : "false"; | |
1005 } | |
1006 else { | |
1007 value = isWFree() ? "true" : "false"; | |
1008 } | |
1009 DataItem item = new DefaultDataItem("wq_isfree", "wq_isfree", value); | |
1010 return new DefaultData( | |
1011 "wq_isfree", null, null, new DataItem[] { item }); | |
1012 } | |
1013 | |
1014 | |
1015 /** | |
1016 * Returns the Data object for the 'mode' attribute. | |
1017 * | |
1018 * @return the Data object for the 'mode' attribute. | |
1019 */ | |
1020 protected Data getDataSelectionMode() { | |
1021 String wqSelection = modes.getValueAsString(FIELD_MODE); | |
1022 | |
1023 String isRange = "true"; | |
1024 if (wqSelection.equals(FIELD_MODE_SINGLE)) { | |
1025 isRange = "false"; | |
1026 } | |
1027 DataItem item = new DefaultDataItem( | |
1028 "wq_isrange", "wq_isrange", isRange); | |
1029 | |
1030 return new DefaultData( | |
1031 "wq_isrange", null, null, new DataItem[] { item }); | |
1032 } | |
1033 | |
1034 | |
1035 /** | |
1036 * Returns the data object for the 'single' attribute. | |
1037 * | |
1038 * @return the Data object for the 'single' attribute. | |
1039 */ | |
1040 protected Data getDataSingle() { | |
1041 double[] values = getFinalSingle(); | |
1042 StringBuilder sb = new StringBuilder(); | |
1043 for (double value: values) { | |
1044 sb.append(Double.toString(value)); | |
1045 sb.append(" "); | |
1046 } | |
1047 | |
1048 DataItem item = new DefaultDataItem( | |
1049 "wq_single", "wq_single", sb.toString()); | |
1050 | |
1051 return new DefaultData( | |
1052 "wq_single", null, null, new DataItem[] { item }); | |
1053 } | |
1054 | |
1055 | |
1056 /** | |
1057 * Returns the Data object for the 'from' attribute. | |
1058 * | |
1059 * @return the Data object for the 'from' attribute. | |
1060 */ | |
1061 protected Data getDataFrom() { | |
1062 String value = Double.valueOf(getFinalFrom()).toString(); | |
1063 DataItem item = new DefaultDataItem("wq_from", "wq_from", value); | |
1064 return new DefaultData( | |
1065 "wq_from", null, null, new DataItem[] { item }); | |
1066 } | |
1067 | |
1068 | |
1069 /** | |
1070 * Returns the Data object for the 'to' attribute. | |
1071 * | |
1072 * @return the Data object for the 'to' attribute. | |
1073 */ | |
1074 protected Data getDataTo() { | |
1075 String value = Double.valueOf(getFinalTo()).toString(); | |
1076 DataItem item = new DefaultDataItem("wq_to", "wq_to", value); | |
1077 return new DefaultData( | |
1078 "wq_to", null, null, new DataItem[] { item }); | |
1079 } | |
1080 | |
1081 | |
1082 /** | |
1083 * Returns the Data object for the 'step' attribute. | |
1084 * | |
1085 * @return the Data object for the 'step' attribute. | |
1086 */ | |
1087 protected Data getDataStep() { | |
1088 String value = Double.valueOf(getFinalStep()).toString(); | |
1089 DataItem item = new DefaultDataItem("wq_step","wq_step", value); | |
1090 return new DefaultData( | |
1091 "wq_step", null, null, new DataItem[] { item }); | |
1092 } | |
1093 | |
1094 | |
1095 protected double[] getFinalSingle() { | |
1096 if (isWFree()) { | |
1097 return getSingleWFree(); | |
1098 } | |
1099 else if (isWMode()) { | |
1100 return getSingleW(); | |
1101 } | |
1102 else if (isQFree()) { | |
1103 return getSingleQFree(); | |
1104 } | |
1105 else { | |
1106 return getSingleQ(); | |
1107 } | |
1108 } | |
1109 | |
1110 | |
1111 /** | |
1112 * Returns the value of 'from' depending on the selected input mode. | |
1113 * | |
1114 * @return the value of 'from' depending on the selected input mode. | |
1115 */ | |
1116 protected double getFinalFrom() { | |
1117 if (isRangeMode()) { | |
1118 if (isWFree()) { | |
1119 return getFromWFree(); | |
1120 } | |
1121 else if (isWMode()) { | |
1122 return getFromW(); | |
1123 } | |
1124 else if (isQFree()) { | |
1125 return getFromQFree(); | |
1126 } | |
1127 else { | |
1128 return getFromQ(); | |
1129 } | |
1130 } | |
1131 else { | |
1132 double[] values = null; | |
1133 | |
1134 if (isWFree()) { | |
1135 values = getSingleWFree(); | |
1136 } | |
1137 else if (isWMode()) { | |
1138 values = getSingleW(); | |
1139 } | |
1140 else if (isQFree()) { | |
1141 values = getSingleQFree(); | |
1142 } | |
1143 else { | |
1144 values = getSingleQ(); | |
1145 } | |
1146 | |
1147 double value = Double.MAX_VALUE; | |
1148 for (double v: values) { | |
1149 value = value < v ? value : v; | |
1150 } | |
1151 | |
1152 return value; | |
1153 } | |
1154 } | |
1155 | |
1156 | |
1157 /** | |
1158 * Returns the value of 'to' depending on the selected input mode. | |
1159 * | |
1160 * @return the value of 'to' depending on the selected input mode. | |
1161 */ | |
1162 protected double getFinalTo() { | |
1163 if (isRangeMode()) { | |
1164 if (isWFree()) { | |
1165 return getToWFree(); | |
1166 } | |
1167 else if (isWMode()) { | |
1168 return getToW(); | |
1169 } | |
1170 else if (isQFree()) { | |
1171 return getToQFree(); | |
1172 } | |
1173 else { | |
1174 return getToQ(); | |
1175 } | |
1176 } | |
1177 else { | |
1178 double[] values = null; | |
1179 | |
1180 if (isWFree()) { | |
1181 values = getSingleWFree(); | |
1182 } | |
1183 else if (isWMode()) { | |
1184 values = getSingleW(); | |
1185 } | |
1186 else if (isQFree()) { | |
1187 values = getSingleQFree(); | |
1188 } | |
1189 else { | |
1190 values = getSingleQ(); | |
1191 } | |
1192 | |
1193 double value = Double.MIN_VALUE; | |
1194 for (double v: values) { | |
1195 value = value > v ? value : v; | |
1196 } | |
1197 | |
1198 return value; | |
1199 } | |
1200 } | |
1201 | |
1202 | |
1203 /** | |
1204 * Returns the value of 'step' depending on the selected input mode. | |
1205 * | |
1206 * @return the value of 'step' depending on the selected input mode. | |
1207 */ | |
1208 protected double getFinalStep() { | |
1209 if (isRangeMode()) { | |
1210 if (isWFree()) { | |
1211 return getStepWFree(); | |
1212 } | |
1213 else if (isWMode()) { | |
1214 return getStepW(); | |
1215 } | |
1216 else if (isQFree()) { | |
1217 return getStepQFree(); | |
1218 } | |
1219 else { | |
1220 return getStepQ(); | |
1221 } | |
1222 } | |
1223 else { | |
1224 // we have no field to enter the 'step' attribute in the | |
1225 // single mode | |
1226 return 0d; | |
1227 } | |
1228 } | |
1229 | |
1230 | |
1231 /** | |
1232 * Determines the range/single mode. | |
1233 * | |
1234 * @return true if the range mode is activated. | |
1235 */ | |
1236 public boolean isRangeMode() { | |
1237 String rMode = modes.getValueAsString(FIELD_MODE); | |
1238 | |
1239 return rMode.equals(FIELD_MODE_RANGE); | |
1240 } | |
1241 | |
1242 | |
1243 /** | |
1244 * Determines the w/q mode. | |
1245 * | |
1246 * @return true, if the W mode is activated. | |
1247 */ | |
1248 public boolean isWMode() { | |
1249 String wq = modes.getValueAsString(FIELD_WQ); | |
1250 return wq.contains("W"); | |
1251 } | |
1252 | |
1253 | |
1254 public boolean isQFree() { | |
1255 String wqMode = modes.getValueAsString(FIELD_WQ); | |
1256 return wqMode.equals(FIELD_WQ_Q_FREE); | |
1257 } | |
1258 | |
1259 protected boolean isWFree() { | |
1260 String wqMode = modes.getValueAsString(FIELD_WQ); | |
1261 return wqMode.equals(FIELD_WQ_W_FREE); | |
1262 } | |
1263 | |
1264 | |
1265 /** | |
1266 * This method changes the lower panel with the input fields depending on | |
1267 * the combination of the two radio button panels. | |
1268 * | |
1269 * @param event The ChangeEvent. | |
1270 */ | |
1271 @Override | |
1272 public void onChange(ChangeEvent event) { | |
1273 DynamicForm form = event.getForm(); | |
1274 FormItem item = event.getItem(); | |
1275 | |
1276 boolean isQ = false; | |
1277 boolean isFree = false; | |
1278 boolean isRange = false; | |
1279 | |
1280 if (item.getFieldName().equals(FIELD_MODE)) { | |
1281 String wq = form.getValueAsString(FIELD_WQ); | |
1282 isQ = wq.contains("Q"); | |
1283 isFree = wq.contains("FREE"); | |
1284 isRange = ((String) event.getValue()).equals(FIELD_MODE_RANGE); | |
1285 } | |
1286 else { | |
1287 String wq = ((String) event.getValue()); | |
1288 isQ = wq.contains("Q"); | |
1289 isFree = wq.contains("FREE"); | |
1290 isRange = | |
1291 form.getValueAsString(FIELD_MODE).equals(FIELD_MODE_RANGE); | |
1292 } | |
1293 | |
1294 if (isQ && isFree) { | |
1295 qdTable.hideIconFields(); | |
1296 } | |
1297 else { | |
1298 qdTable.showIconFields(); | |
1299 } | |
1300 | |
1301 if (!isRange) { | |
1302 qdTable.showSelect(); | |
1303 } | |
1304 else { | |
1305 qdTable.showIconFields(); | |
1306 } | |
1307 | |
1308 updatePanels(isQ, isFree, isRange); | |
1309 } | |
1310 | |
1311 | |
1312 protected void updatePanels(boolean isQ, boolean isFree, boolean isRange) { | |
1313 container.removeMembers(container.getMembers()); | |
1314 | |
1315 if (!isQ && isFree) { | |
1316 if (!isRange) { | |
1317 // Single W mode | |
1318 double[] values = getSingleWFree(); | |
1319 | |
1320 wFreeArrayPanel = new DoubleArrayPanel( | |
1321 MESSAGE.unitWSingle(), values, this); | |
1322 | |
1323 container.addMember(wFreeArrayPanel); | |
1324 } | |
1325 else { | |
1326 // Range W mode | |
1327 double from = getFromWFree(); | |
1328 double to = getToWFree(); | |
1329 double step = getStepWFree(); | |
1330 | |
1331 wFreeRangePanel = new DoubleRangePanel( | |
1332 MESSAGE.unitWFrom(), MESSAGE.unitWTo(), MESSAGE.unitWStep(), | |
1333 from, to, step, | |
1334 250, | |
1335 this); | |
1336 container.addMember(wFreeRangePanel); | |
1337 } | |
1338 | |
1339 tabs.selectTab(0); | |
1340 } | |
1341 else if (!isQ) { | |
1342 if (!isRange) { | |
1343 // Single W mode | |
1344 double[] values = getSingleW(); | |
1345 | |
1346 wArrayPanel = new DoubleArrayPanel( | |
1347 MESSAGE.unitWSingle(), values, this); | |
1348 | |
1349 container.addMember(wArrayPanel); | |
1350 } | |
1351 else { | |
1352 // Range W mode | |
1353 double from = getFromW(); | |
1354 double to = getToW(); | |
1355 double step = getStepW(); | |
1356 | |
1357 wRangePanel = new DoubleRangePanel( | |
1358 MESSAGE.unitWFrom(), MESSAGE.unitWTo(), MESSAGE.unitWStep(), | |
1359 from, to, step, | |
1360 250, | |
1361 this); | |
1362 container.addMember(wRangePanel); | |
1363 } | |
1364 | |
1365 tabs.selectTab(0); | |
1366 } | |
1367 else if (isQ && isFree) { | |
1368 if (!isRange) { | |
1369 // Single Q mode | |
1370 double[] values = getSingleQFree(); | |
1371 | |
1372 qFreeArrayPanel = new DoubleArrayPanel( | |
1373 MESSAGE.unitQSingle(), values, this); | |
1374 container.addMember(qFreeArrayPanel); | |
1375 } | |
1376 else { | |
1377 // Range Q mode | |
1378 double from = getFromQFree(); | |
1379 double to = getToQFree(); | |
1380 double step = getStepQFree(); | |
1381 | |
1382 qFreeRangePanel = new DoubleRangePanel( | |
1383 MESSAGE.unitQFrom(), MESSAGE.unitQTo(), MESSAGE.unitQStep(), | |
1384 from, to, step, | |
1385 250, | |
1386 this); | |
1387 container.addMember(qFreeRangePanel); | |
1388 } | |
1389 | |
1390 tabs.selectTab(1); | |
1391 } | |
1392 else { | |
1393 if (!isRange) { | |
1394 // Single Q mode | |
1395 double[] values = getSingleQ(); | |
1396 | |
1397 qArrayPanel = new DoubleArrayPanel( | |
1398 MESSAGE.unitQSingle(), values, this); | |
1399 container.addMember(qArrayPanel); | |
1400 } | |
1401 else { | |
1402 // Range Q mode | |
1403 double from = getFromQ(); | |
1404 double to = getToQ(); | |
1405 double step = getStepQ(); | |
1406 | |
1407 qRangePanel = new DoubleRangePanel( | |
1408 MESSAGE.unitQFrom(), MESSAGE.unitQTo(), MESSAGE.unitQStep(), | |
1409 from, to, step, | |
1410 250, | |
1411 this); | |
1412 container.addMember(qRangePanel); | |
1413 } | |
1414 | |
1415 tabs.selectTab(1); | |
1416 } | |
1417 } | |
1418 | |
1419 /** | |
1420 * This method is called if the value of one of the input fields might have | |
1421 * changed. The entered values are validated and stored. | |
1422 * | |
1423 * @param event The BlurEvent. | |
1424 */ | |
1425 @Override | |
1426 public void onBlur(BlurEvent event) { | |
1427 DynamicForm form = event.getForm(); | |
1428 FormItem item = event.getItem(); | |
1429 | |
1430 String wqMode = (String) modes.getValue(FIELD_WQ); | |
1431 String inputMode = (String) modes.getValue(FIELD_MODE); | |
1432 | |
1433 if (wqMode.equals(FIELD_WQ_W)) { | |
1434 if (inputMode.equals(FIELD_MODE_SINGLE)) { | |
1435 DoubleArrayPanel p = (DoubleArrayPanel) form; | |
1436 saveSingleWValue(p, item); | |
1437 } | |
1438 else { | |
1439 DoubleRangePanel p = (DoubleRangePanel) form; | |
1440 saveRangeWValue(p, item); | |
1441 } | |
1442 } | |
1443 else if (wqMode.equals(FIELD_WQ_W_FREE)) { | |
1444 if (inputMode.equals(FIELD_MODE_SINGLE)) { | |
1445 DoubleArrayPanel p = (DoubleArrayPanel) form; | |
1446 saveSingleWFreeValue(p, item); | |
1447 } | |
1448 else { | |
1449 DoubleRangePanel p = (DoubleRangePanel) form; | |
1450 saveRangeWFreeValue(p, item); | |
1451 } | |
1452 } | |
1453 else if (wqMode.equals(FIELD_WQ_Q_FREE)) { | |
1454 if (inputMode.equals(FIELD_MODE_SINGLE)) { | |
1455 DoubleArrayPanel p = (DoubleArrayPanel) form; | |
1456 saveSingleQFreeValue(p, item); | |
1457 } | |
1458 else { | |
1459 DoubleRangePanel p = (DoubleRangePanel) form; | |
1460 saveRangeQFreeValue(p, item); | |
1461 } | |
1462 } | |
1463 else { | |
1464 if (inputMode.equals(FIELD_MODE_SINGLE)) { | |
1465 DoubleArrayPanel p = (DoubleArrayPanel) form; | |
1466 saveSingleQValue(p, item); | |
1467 } | |
1468 else { | |
1469 DoubleRangePanel p = (DoubleRangePanel) form; | |
1470 saveRangeQValue(p, item); | |
1471 } | |
1472 } | |
1473 } | |
1474 | |
1475 | |
1476 protected void saveSingleWValues(DoubleArrayPanel p) { | |
1477 FormItem[] formItems = p.getFields(); | |
1478 | |
1479 for (FormItem item: formItems) { | |
1480 if (item.getFieldName().equals(DoubleArrayPanel.FIELD_NAME)) { | |
1481 saveSingleWValue(p, item); | |
1482 } | |
1483 } | |
1484 } | |
1485 | |
1486 | |
1487 protected void saveSingleWFreeValues(DoubleArrayPanel p) { | |
1488 FormItem[] formItems = p.getFields(); | |
1489 | |
1490 for (FormItem item: formItems) { | |
1491 if (item.getFieldName().equals(DoubleArrayPanel.FIELD_NAME)) { | |
1492 saveSingleWFreeValue(p, item); | |
1493 } | |
1494 } | |
1495 } | |
1496 | |
1497 | |
1498 protected void saveSingleQValues(DoubleArrayPanel p) { | |
1499 FormItem[] formItems = p.getFields(); | |
1500 | |
1501 for (FormItem item: formItems) { | |
1502 if (item.getFieldName().equals(DoubleArrayPanel.FIELD_NAME)) { | |
1503 saveSingleQValue(p, item); | |
1504 } | |
1505 } | |
1506 } | |
1507 | |
1508 | |
1509 protected void saveSingleQFreeValues(DoubleArrayPanel p) { | |
1510 FormItem[] formItems = p.getFields(); | |
1511 | |
1512 for (FormItem item: formItems) { | |
1513 if (item.getFieldName().equals(DoubleArrayPanel.FIELD_NAME)) { | |
1514 saveSingleQFreeValue(p, item); | |
1515 } | |
1516 } | |
1517 } | |
1518 | |
1519 | |
1520 protected void saveSingleWValue(DoubleArrayPanel p, FormItem item) { | |
1521 if (p.validateForm(item)) { | |
1522 setSingleW(p.getInputValues(item)); | |
1523 } | |
1524 } | |
1525 | |
1526 | |
1527 protected void saveSingleWFreeValue(DoubleArrayPanel p, FormItem item) { | |
1528 if (p.validateForm(item)) { | |
1529 setSingleWFree(p.getInputValues(item)); | |
1530 } | |
1531 } | |
1532 | |
1533 | |
1534 protected void saveSingleQValue(DoubleArrayPanel p, FormItem item) { | |
1535 if (p.validateForm(item)) { | |
1536 setSingleQ(p.getInputValues(item)); | |
1537 } | |
1538 } | |
1539 | |
1540 | |
1541 protected void saveSingleQFreeValue(DoubleArrayPanel p, FormItem item) { | |
1542 if (p.validateForm(item)) { | |
1543 setSingleQFree(p.getInputValues(item)); | |
1544 } | |
1545 } | |
1546 | |
1547 | |
1548 protected void saveRangeWValues(DoubleRangePanel p) { | |
1549 FormItem[] formItems = p.getFields(); | |
1550 | |
1551 for (FormItem item: formItems) { | |
1552 saveRangeWValue(p, item); | |
1553 } | |
1554 } | |
1555 | |
1556 | |
1557 protected void saveRangeWFreeValues(DoubleRangePanel p) { | |
1558 FormItem[] formItems = p.getFields(); | |
1559 | |
1560 for (FormItem item: formItems) { | |
1561 saveRangeWFreeValue(p, item); | |
1562 } | |
1563 } | |
1564 | |
1565 | |
1566 protected void saveRangeQValues(DoubleRangePanel p) { | |
1567 FormItem[] formItems = p.getFields(); | |
1568 | |
1569 for (FormItem item: formItems) { | |
1570 saveRangeQValue(p, item); | |
1571 } | |
1572 } | |
1573 | |
1574 | |
1575 protected void saveRangeQFreeValues(DoubleRangePanel p) { | |
1576 FormItem[] formItems = p.getFields(); | |
1577 | |
1578 for (FormItem item: formItems) { | |
1579 saveRangeQFreeValue(p, item); | |
1580 } | |
1581 } | |
1582 | |
1583 | |
1584 protected void saveRangeWValue(DoubleRangePanel p, FormItem item) { | |
1585 if (p.validateForm()) { | |
1586 setFromW(p.getFrom()); | |
1587 setToW(p.getTo()); | |
1588 setStepW(p.getStep()); | |
1589 } | |
1590 } | |
1591 | |
1592 | |
1593 protected void saveRangeWFreeValue(DoubleRangePanel p, FormItem item) { | |
1594 if (p.validateForm()) { | |
1595 setFromWFree(p.getFrom()); | |
1596 setToWFree(p.getTo()); | |
1597 setStepWFree(p.getStep()); | |
1598 } | |
1599 } | |
1600 | |
1601 | |
1602 protected void saveRangeQValue(DoubleRangePanel p, FormItem item) { | |
1603 if (p.validateForm()) { | |
1604 setFromQ(p.getFrom()); | |
1605 setToQ(p.getTo()); | |
1606 setStepQ(p.getStep()); | |
1607 } | |
1608 } | |
1609 | |
1610 | |
1611 protected void saveRangeQFreeValue(DoubleRangePanel p, FormItem item) { | |
1612 if (p.validateForm()) { | |
1613 setFromQFree(p.getFrom()); | |
1614 setToQFree(p.getTo()); | |
1615 setStepQFree(p.getStep()); | |
1616 } | |
1617 } | |
1618 | |
1619 | |
1620 protected double[] getSingleQ() { | |
1621 return valuesQ; | |
1622 } | |
1623 | |
1624 | |
1625 protected double[] getSingleQFree() { | |
1626 return valuesQFree; | |
1627 } | |
1628 | |
1629 | |
1630 protected void setSingleQ(double[] values) { | |
1631 valuesQ = values; | |
1632 } | |
1633 | |
1634 | |
1635 protected void setSingleQFree(double[] values) { | |
1636 valuesQFree = values; | |
1637 } | |
1638 | |
1639 | |
1640 protected double getFromQ() { | |
1641 return fromQ; | |
1642 } | |
1643 | |
1644 | |
1645 protected double getFromQFree() { | |
1646 return fromQFree; | |
1647 } | |
1648 | |
1649 | |
1650 protected void setFromQ(double fromQ) { | |
1651 this.fromQ = fromQ; | |
1652 } | |
1653 | |
1654 | |
1655 protected void setFromQFree(double fromQ) { | |
1656 this.fromQFree = fromQ; | |
1657 } | |
1658 | |
1659 | |
1660 protected double getToQ() { | |
1661 return toQ; | |
1662 } | |
1663 | |
1664 | |
1665 protected double getToQFree() { | |
1666 return toQFree; | |
1667 } | |
1668 | |
1669 | |
1670 protected void setToQ(double toQ) { | |
1671 this.toQ = toQ; | |
1672 } | |
1673 | |
1674 | |
1675 protected void setToQFree(double toQ) { | |
1676 this.toQFree = toQ; | |
1677 } | |
1678 | |
1679 | |
1680 protected double getStepQ() { | |
1681 return stepQ; | |
1682 } | |
1683 | |
1684 | |
1685 protected double getStepQFree() { | |
1686 return stepQFree; | |
1687 } | |
1688 | |
1689 | |
1690 protected void setStepQ(double stepQ) { | |
1691 this.stepQ = stepQ; | |
1692 } | |
1693 | |
1694 | |
1695 protected void setStepQFree(double stepQ) { | |
1696 this.stepQFree = stepQ; | |
1697 } | |
1698 | |
1699 protected double[] getSingleW() { | |
1700 return valuesW; | |
1701 } | |
1702 | |
1703 protected double[] getSingleWFree() { | |
1704 return valuesWFree; | |
1705 } | |
1706 | |
1707 protected void setSingleW(double[] values) { | |
1708 valuesW = values; | |
1709 } | |
1710 | |
1711 protected void setSingleWFree(double[] values) { | |
1712 valuesWFree = values; | |
1713 } | |
1714 | |
1715 protected double getFromW() { | |
1716 return fromW; | |
1717 } | |
1718 | |
1719 protected double getFromWFree() { | |
1720 return fromWFree; | |
1721 } | |
1722 | |
1723 protected void setFromW(double fromW) { | |
1724 this.fromW = fromW; | |
1725 } | |
1726 | |
1727 protected void setFromWFree(double fromW) { | |
1728 this.fromW = fromW; | |
1729 } | |
1730 | |
1731 protected double getToW() { | |
1732 return toW; | |
1733 } | |
1734 | |
1735 protected double getToWFree() { | |
1736 return toWFree; | |
1737 } | |
1738 | |
1739 protected void setToW(double toW) { | |
1740 this.toW = toW; | |
1741 } | |
1742 | |
1743 protected void setToWFree(double toW) { | |
1744 this.toWFree = toW; | |
1745 } | |
1746 | |
1747 protected double getStepW() { | |
1748 return stepW; | |
1749 } | |
1750 | |
1751 protected double getStepWFree() { | |
1752 return stepWFree; | |
1753 } | |
1754 | |
1755 protected void setStepW(double stepW) { | |
1756 this.stepW = stepW; | |
1757 } | |
1758 | |
1759 protected void setStepWFree(double stepW) { | |
1760 this.stepWFree = stepW; | |
1761 } | |
1762 | |
1763 /** | |
1764 * Determines the min and max kilometer value selected in a former state. A | |
1765 * bit silly, but we need to run over each value of the "old data" to find | |
1766 * such values because it is not available here. | |
1767 * | |
1768 * @param data The DataList which contains the whole data inserted for the | |
1769 * current artifact. | |
1770 * | |
1771 * @return a double array with [min, max]. | |
1772 */ | |
1773 protected double[] getMinMaxKM(DataList[] data) { | |
1774 ArtifactDescription adesc = artifact.getArtifactDescription(); | |
1775 return adesc.getKMRange(); | |
1776 } | |
1777 | |
1778 | |
1779 /** | |
1780 * Returns the name of the selected river. | |
1781 * | |
1782 * @param data The DataList with all data. | |
1783 * | |
1784 * @return the name of the current river. | |
1785 */ | |
1786 protected String getRiverName() { | |
1787 ArtifactDescription adesc = artifact.getArtifactDescription(); | |
1788 return adesc.getRiver(); | |
1789 } | |
1790 | |
1791 | |
1792 protected void fetchWQData() { | |
1793 Config config = Config.getInstance(); | |
1794 String locale = config.getLocale (); | |
1795 | |
1796 ArtifactDescription adescr = artifact.getArtifactDescription(); | |
1797 DataList[] data = adescr.getOldData(); | |
1798 | |
1799 double[] mm = getMinMaxKM(data); | |
1800 String river = getRiverName(); | |
1801 | |
1802 wqInfoService.getWQInfo(locale, river, mm[0], mm[1], | |
1803 new AsyncCallback<WQInfoObject[]>() { | |
1804 @Override | |
1805 public void onFailure(Throwable caught) { | |
1806 GWT.log("Could not recieve wq informations."); | |
1807 SC.warn(caught.getMessage()); | |
1808 } | |
1809 | |
1810 @Override | |
1811 public void onSuccess(WQInfoObject[] wqi) { | |
1812 int num = wqi != null ? wqi.length :0; | |
1813 GWT.log("Recieved " + num + " wq informations."); | |
1814 | |
1815 if (num == 0) { | |
1816 return; | |
1817 } | |
1818 | |
1819 addWQInfo(wqi); | |
1820 | |
1821 String wq = (String) modes.getValue(FIELD_WQ); | |
1822 String sr = (String) modes.getValue(FIELD_MODE); | |
1823 GWT.log("sending: " + wq + ", " + sr); | |
1824 boolean isQ = wq.contains("Q"); | |
1825 boolean isFree = wq.contains("FREE"); | |
1826 boolean isRange = sr.equals(FIELD_MODE_RANGE); | |
1827 | |
1828 updatePanels(isQ, isFree, isRange); | |
1829 } | |
1830 } | |
1831 ); | |
1832 } | |
1833 | |
1834 | |
1835 protected void addWQInfo (WQInfoObject[] wqi) { | |
1836 for(WQInfoObject wi: wqi) { | |
1837 WQInfoRecord rec = new WQInfoRecord(wi); | |
1838 | |
1839 if (wi.getType().equals("W")) { | |
1840 wTable.addData(rec); | |
1841 } | |
1842 else { | |
1843 qdTable.addData(rec); | |
1844 } | |
1845 } | |
1846 } | |
1847 } | |
1848 // vim:set ts=4 sw=4 si et sta sts=4 fenc=utf8 : |