Mercurial > dive4elements > river

comparison flys-client/src/main/java/org/dive4elements/river/client/client/ui/WQInputPanel.java @ 5834:f507086aa94b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
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 :
http://dive4elements.wald.intevation.org