CDPP / AMDA_IHM

Commit 9e70b8ef5767dfde899cfd05f4534db82df3074f

Authored by Menouar AZIB
2 parents ded8189b 86615884
Exists in master and in 72 other branches 10098, 10178, 5390, 6629, 7616, 8459, 8528, 9014, 9016Bis, 9084, 9326, 9505, 9660, 9750, 9750.bck, 9800, 9980, FER_10285, FER_10400, FER_10435, FER_10557, FER_10663, FER_10765, FER_10828, FER_10828_2, FER_10829, FER_10836, FER_10852, FER_10934, FER_11100, FER_11242, FER_11478, FER_11500, FER_11537, FER_11586, FER_11588, FER_5119, FER_5165, FER_6265, FER_6860, FER_6899, FER_6951, FER_7618, FER_7862, FER_8455, FER_9629, FER_9660, FER_9915, FER_CR41, FER_CR42, FER_CR43, FER_TFCat, Histo1D2D, MAZ_10936, MAZ_11362, MAZ_11427, MAZ_6018, MAZ_9016_New, MAZ_FIX_9016, New_ColorMaps, SpeasyGet, akkodis/amdadev, amdadev, amdadev_test, anr_tempete, cu2022, density_maps, develop, epn-tap, mlplasmas, openam, test-merge

Merge background subtraction dans develop

Showing 6 changed files with 1493 additions and 1225 deletions   Show diff stats
Inline Side-by-side
js/app/models/PlotObjects/PlotObjectConfig.js
  Diff comments   View file @9e70b8e
... ... @@ -11,488 +11,514 @@
11 11 ******************************************************************************
12 12 * : :21/07/2015: BRE - file creation
13 13 */
14   -
15   -
  14 +
  15 +
16 16 Ext.define('amdaPlotObj.PlotObjectConfig', {
17 17 singleton: true,
18   -
19   - defaultValues : {
20   - file : {
21   - format : 'PNG',
22   - output : 'INTERACTIVE',
  18 +
  19 + defaultValues: {
  20 + file: {
  21 + format: 'PNG',
  22 + output: 'INTERACTIVE',
23 23 oneFilePerInterval: false
24 24 },
25   - tree : {
26   - fullView : false
  25 + tree: {
  26 + fullView: false
27 27 },
28   - page : {
29   - xMargin : 5.,
30   - yMargin : 5.,
31   - mode : 'color',
  28 + page: {
  29 + xMargin: 5.,
  30 + yMargin: 5.,
  31 + mode: 'color',
32 32 orientation: 'landscape',
33   - dimension : 'ISO A4',
34   - title : {
  33 + dimension: 'ISO A4',
  34 + title: {
35 35 position: 'top',
36 36 alignment: ' center',
37 37 color: '#000000'
38 38 },
39   - font : {
40   - name : 'sans-serif',
  39 + font: {
  40 + name: 'sans-serif',
41 41 size: '8'
42 42 },
43   - layout : {
44   - type : 'vertical',
45   - panelHeight : 0.5,
46   - panelSpacing : 0.,
47   - expand : false,
48   - timeAxesLegend : true
  43 + layout: {
  44 + type: 'vertical',
  45 + panelHeight: 0.5,
  46 + panelSpacing: 0.,
  47 + expand: false,
  48 + timeAxesLegend: true
49 49 }
50 50 },
51   - panel : {
52   - plotType : 'timePlot',
53   - isotropic : false,
54   - title : {
  51 + panel: {
  52 + plotType: 'timePlot',
  53 + isotropic: false,
  54 + title: {
55 55 position: 'top',
56 56 alignment: ' center',
57 57 color: '#000000'
58 58 },
59   - font : {
60   - name : 'sans-serif',
  59 + font: {
  60 + name: 'sans-serif',
61 61 size: '8'
62 62 },
63   - backgroundColor : 'none',
64   - status : {
65   - position : 'top',
66   - colorMap : 0
  63 + backgroundColor: 'none',
  64 + status: {
  65 + position: 'top',
  66 + colorMap: 0
67 67 }
68 68 },
69   - axis : {
70   - scale : 'linear',
71   - tickPosition : 'outwards',
72   - color : '#000000',
73   - thickness : '1',
74   - legend : {
  69 + axis: {
  70 + scale: 'linear',
  71 + tickPosition: 'outwards',
  72 + color: '#000000',
  73 + thickness: '1',
  74 + legend: {
75 75 color: '#000000',
76   - font : {
77   - name : 'sans-serif',
  76 + font: {
  77 + name: 'sans-serif',
78 78 size: '8'
79 79 }
80 80 },
81   - timeFormat : 'dd/mm/yy',
82   - colorMap : '1'
  81 + timeFormat: 'dd/mm/yy',
  82 + colorMap: '1'
83 83 },
84   - serie : {
85   - yAxis : 'y-left',
86   - resolution : 3000,
87   - lines : {
88   - style : 'plain',
89   - width : 1,
90   - color : 'auto'
  84 + serie: {
  85 + yAxis: 'y-left',
  86 + resolution: 3000,
  87 + lines: {
  88 + style: 'plain',
  89 + width: 1,
  90 + color: 'auto'
91 91 },
92   - symbols : {
93   - type : 'dot',
94   - size : 3,
95   - color : 'auto'
  92 + symbols: {
  93 + type: 'dot',
  94 + size: 3,
  95 + color: 'auto'
96 96 },
97   - resamplingMode : 'xparam',
98   - timetick : {
  97 + resamplingMode: 'xparam',
  98 + timetick: {
99 99 type: 'auto',
100 100 step: 3600,
101   - nbmajor : 5,
102   - nbminor : 5,
103   - color : '#FF0000',
104   - symbols : {
  101 + nbmajor: 5,
  102 + nbminor: 5,
  103 + color: '#FF0000',
  104 + symbols: {
105 105 type: 'full-circle',
106 106 size: 10,
107 107 color: '#FF0000'
108 108 },
109   - firstsymbols : {
  109 + firstsymbols: {
110 110 type: 'triangle',
111 111 size: 4,
112 112 color: '#00FF00'
113 113 },
114   - font : {
115   - name : 'sans-serif',
  114 + font: {
  115 + name: 'sans-serif',
116 116 size: '8'
117 117 }
118 118 },
119   - intervaltick : {
  119 + intervaltick: {
120 120 mode: 'start-time',
121   - color : '#FF0000',
122   - symbols : {
  121 + color: '#FF0000',
  122 + symbols: {
123 123 type: 'full-circle',
124 124 size: 10,
125 125 color: '#FF0000'
126 126 },
127   - font : {
128   - name : 'sans-serif',
  127 + font: {
  128 + name: 'sans-serif',
129 129 size: '8'
130 130 }
131 131 },
132   - errorbar : {
  132 + errorbar: {
133 133 type: 'min-max',
134   - lines : {
135   - style : 'plain',
136   - width : 1,
137   - color : 'auto'
  134 + lines: {
  135 + style: 'plain',
  136 + width: 1,
  137 + color: 'auto'
138 138 }
139 139 },
140   - projection : 'XY',
141   -
  140 + projection: 'XY',
  141 +
142 142 },
143   - spectro : {
144   - yAxis : 'y-left',
145   - resolution : 3000
  143 + spectro: {
  144 + yAxis: 'y-left',
  145 + resolution: 3000
146 146 },
147   - legends : {
148   - series : {
149   - type : 'text-only',
150   - position : 'outside',
  147 + legends: {
  148 + series: {
  149 + type: 'text-only',
  150 + position: 'outside',
151 151 text: {
152   - color : '#000000'
  152 + color: '#000000'
153 153 },
154 154 border: {
155   - color : '#000000'
  155 + color: '#000000'
156 156 },
157   - intervalinfo : {
158   - type : 'start-stop'
  157 + intervalinfo: {
  158 + type: 'start-stop'
159 159 },
160   - font : {
161   - name : 'sans-serif',
  160 + font: {
  161 + name: 'sans-serif',
162 162 size: '8'
163 163 }
164 164 },
165   - text : {
166   - position : 'left',
167   - color : '#000000',
168   - font : {
169   - name : 'sans-serif',
  165 + text: {
  166 + position: 'left',
  167 + color: '#000000',
  168 + font: {
  169 + name: 'sans-serif',
170 170 size: '8'
171 171 }
172 172 }
173 173 },
174   - constants : {
175   - axisId : 'y-left',
176   - line : {
177   - style : 'plain',
178   - width : 1,
179   - color : '#000000'
  174 + constants: {
  175 + axisId: 'y-left',
  176 + line: {
  177 + style: 'plain',
  178 + width: 1,
  179 + color: '#000000'
180 180 }
181 181 },
182   - textObjs : {
183   - yAxisId : 'y-left',
184   - xRelative : true,
185   - yRelative : true,
186   - align : 'left',
187   - color : '#000000',
188   - font : {
189   - name : 'sans-serif',
  182 + textObjs: {
  183 + yAxisId: 'y-left',
  184 + xRelative: true,
  185 + yRelative: true,
  186 + align: 'left',
  187 + color: '#000000',
  188 + font: {
  189 + name: 'sans-serif',
190 190 size: '8'
191 191 }
192 192 },
193   - curves : {
194   - line : {
195   - style : 'plain',
196   - width : 1,
197   - color : '#000000'
  193 + curves: {
  194 + line: {
  195 + style: 'plain',
  196 + width: 1,
  197 + color: '#000000'
198 198 }
199 199 },
200   - fills : {
201   - type : 'serie-constant',
202   - greaterColor : 'none',
203   - lessColor : 'none'
  200 + fills: {
  201 + type: 'serie-constant',
  202 + greaterColor: 'none',
  203 + lessColor: 'none'
204 204 },
205   - filtering:{
206   - level:1
207   - }
  205 + filtering: {
  206 + level: 1
  207 + }
208 208 },
209   -
210   - getValueByKey : function(dataList, key)
211   - {
  209 +
  210 + getValueByKey: function (dataList, key) {
212 211 var value = '';
213 212 Ext.each(dataList, function (data) {
214   - if (data.key == key)
215   - {
  213 + if (data.key == key) {
216 214 value = data.value;
217 215 return;
218 216 }
219 217 });
220 218 return value;
221 219 },
222   -
223   - availableFileFormats : [
224   - {'key' : 'PNG', 'value' : 'PNG'},
225   - {'key' : 'PDF', 'value' : 'PDF'},
226   - {'key' : 'PS', 'value' : 'PS'},
227   - {'key' : 'SVG', 'value' : 'SVG'}
228   - ],
229   -
230   - availableFileOutputsForPng : [
231   - {'key' : 'INTERACTIVE', 'value' : 'screen'},
232   - {'key' : 'TGZ', 'value' : 'tar+gzip archive'},
233   - {'key' : 'ZIP', 'value' : 'zip archive'}
234   - ],
235   -
236   - availableFileOutputsForOtherFormats : [
237   - {'key' : 'TGZ', 'value' : 'tar+gzip archive'},
238   - {'key' : 'ZIP', 'value' : 'zip archive'}
239   - ],
240   -
241   - availablePageModes : [
242   - {'key' : 'color', 'value' : 'Color'},
243   - {'key' : 'grayscale', 'value' : 'Grayscale'}
244   - ],
245   -
246   - availablePageOrientations : [
247   - {'key' : 'landscape', 'value' : 'Landscape'},
248   - {'key' : 'portrait', 'value' : 'Portrait'}
249   - ],
250   -
251   - availablePageDimensions : [
252   - {'key' : 'ISO A4', 'value' : 'ISO A4'},
253   - {'key' : 'US letter', 'value' : 'US letter'}
254   - ],
255   -
256   - availablePlotTypes : [
257   - {'key' : 'timePlot', value : 'Time Plot'},
258   - {'key' : 'xyPlot', value : 'Scatter Plot'},
259   - {'key' : 'epochPlot', value : 'Epoch Plot'},
260   - {'key' : 'instantPlot', value : 'Instant Plot'},
261   - {'key' : 'statusPlot', value : 'Status Plot'},
262   - {'key' : 'tickPlot', value : 'Tick Plot'}
263   - ],
264   -
265   - availableFontNames : [
266   - {'key' : 'sans-serif', 'value' : 'sans-serif'},
267   - {'key' : 'serif', 'value' : 'serif'},
268   - {'key' : 'monospace', 'value' : 'monospace'},
269   - {'key' : 'script', 'value' : 'script'}
270   - ],
271   -
272   - availableTitlePositions : [
273   - {'key' : 'top', 'value' : 'Top'},
274   - {'key' : 'bottom', 'value' : 'Bottom'}
275   - ],
276   -
277   - availableTitleAlignments : [
278   - {'key' : 'center', 'value' : 'Center'},
279   - {'key' : 'left', 'value' : 'Left'},
280   - {'key' : 'right', 'value' : 'Right'}
281   - ],
282   -
283   - availableAxisScales : [
284   - {'key' : 'linear', 'value' : 'Linear'},
285   - {'key' : 'logarithmic', 'value' : 'Logarithmic'}
286   - ],
287   -
288   - availableTicksPositions : [
289   - {'key' : 'inwards', 'value' : 'Inwards'},
290   - {'key' : 'outwards', 'value' : 'Outwards'}
291   - ],
292   -
293   - availableTimeAxisFormats : [
294   - {'key' : 'dd/mm/yy', 'value' : 'dd/mm/yy'},
295   - {'key' : 'ddd/yy', 'value' : 'ddd/yy'},
296   - {'key' : 'DD/MM/YYYY', 'value' : 'dd/mm/yyyy'},
297   - {'key' : 'yyyy/dd/mm', 'value' : 'yyyy/dd/mm'},
298   - {'key' : 'yyyy-dd-mm', 'value' : 'yyyy-dd-mm'}
299   - ],
300   -
301   - availableYAxes : [
302   - {'key' : 'y-left', 'value' : 'Left'},
303   - {'key' : 'y-right', 'value' : 'Right'}
304   - ],
305   -
306   - availableResolutions : [
307   - {'key' : 3000, 'value' : '3000'},
308   - {'key' : 10000, 'value' : '10000'},
309   - {'key' : 50000, 'value' : '50000'},
310   - {'key' : 100000, 'value' : '100000'}
311   - ],
312   -
313   - availableLinesStyles : [
314   - {'key' : 'plain', 'value' : 'Plain'},
315   - {'key' : 'dot', 'value' : 'Dot'},
316   - {'key' : 'long-spaced-dot', 'value' : 'Long spaced dot'},
317   - {'key' : 'long-short-dot', 'value' : 'Long short dot'}
318   - ],
319   -
320   - availableSymbolsTypes : [
321   - {'key' : 'dot', 'value' : 'Dot'},
322   - {'key' : 'plus', 'value' : 'Plus'},
323   - {'key' : 'wildcard', 'value' : 'Wildcard'},
324   - {'key' : 'circle', 'value' : 'Circle'},
325   - {'key' : 'crux', 'value' : 'Crux'},
326   - {'key' : 'square', 'value' : 'Square'},
327   - {'key' : 'triangle', 'value' : 'Triangle'},
328   - {'key' : 'crux-in-circle', 'value' : 'Crux in circle'},
329   - {'key' : 'dot-in-circle', 'value' : 'Dot in circle'},
330   - {'key' : 'diamond', 'value' : 'Diamond'},
331   - {'key' : 'star', 'value' : 'Star'},
332   - {'key' : 'david-star', 'value' : 'David star'},
333   - {'key' : 'full-square', 'value' : 'Full square'},
334   - {'key' : 'full-circle', 'value' : 'Full circle'},
335   - {'key' : 'full-star', 'value' : 'Full star'}
336   - ],
337   -
338   - availableColorMaps : [
339   - {'key' : '0', 'value' : 'Blue Red'},
340   - {'key' : '1', 'value' : 'Default'},
341   - {'key' : '2', 'value' : 'Blue Yellow'},
342   - {'key' : '3', 'value' : 'Grayscale'},
343   - {'key' : '4', 'value' : 'AMDA Default'},
344   - {'key' : '5', 'value' : 'GeoWhite'},
345   - {'key' : '6', 'value' : 'GeoBlack'},
346   - {'key' : '7', 'value' : 'Violet Yellow'},
347   - {'key' : '8', 'value' : 'Red Blue 4'}
348   - ],
349   -
350   - availableColors : [
351   - {'key' : 'auto', 'color' : 'auto', 'value' : 'auto'},
352   - {'key' : '[0,0,0]', 'color' : '#000000', 'value' : 'Black'},
353   - {'key' : '[0,0,255]', 'color' : '#0000ff', 'value' : 'Blue'},
354   - {'key' : '[255,0,0]', 'color' : '#ff0000', 'value' : 'Red'},
355   - {'key' : '[0,255,255]', 'color' : '#00ffff', 'value' : 'Cyan'},
356   - {'key' : '[255,0,255]', 'color' : '#ff00ff', 'value' : 'Magenta'},
357   - {'key' : '[0,128,0]', 'color' : '#008000', 'value' : 'Green'},
358   - {'key' : '[128,128,128]', 'color' : '#808080', 'value' : 'Gray'},
359   - {'key' : '[0,255,0]', 'color' : '#00ff00', 'value' : 'Lime'},
360   - {'key' : '[128,0,0]', 'color' : '#800000', 'value' : 'Maroon'},
361   - {'key' : '[0,0,128]', 'color' : '#000080', 'value' : 'Navy'},
362   - {'key' : '[128,128,0]', 'color' : '#808000', 'value' : 'Olive'},
363   - {'key' : '[128,0,128]', 'color' : '#800080', 'value' : 'Purple'},
364   - {'key' : '[192,192,192]', 'color' : '#c0c0c0', 'value' : 'Silver'},
365   - {'key' : '[0,128,128]', 'color' : '#008080', 'value' : 'Teal'},
366   - {'key' : '[255,255,0]', 'color' : '#ffff00', 'value' : 'Yellow'},
367   - {'key' : '[0,64,64]', 'color' : '#004040', 'value' : 'Cyprus'}
368   - ],
369   -
370   - availableBackgroundColors : [
371   - {'color' : 'none', 'value' : 'None'},
372   - {'key' : '[0,0,0]', 'color' : '#000000', 'value' : 'Black'},
373   - {'key' : '[0,0,255]', 'color' : '#0000FF', 'value' : 'Blue'},
374   - {'key' : '[255,0,0]', 'color' : '#FF0000', 'value' : 'Red'},
375   - {'key' : '[0,255,255]', 'color' : '#00FFFF', 'value' : 'Cyan'},
376   - {'key' : '[255,0,255]', 'color' : '#FF00FF', 'value' : 'Magenta'},
377   - {'key' : '[0,128,0]', 'color' : '#008000', 'value' : 'Green'},
378   - {'key' : '[128,128,128]', 'color' : '#808080', 'value' : 'Gray'},
379   - {'key' : '[0,255,0]', 'color' : '#00FF00', 'value' : 'Lime'},
380   - {'key' : '[128,0,0]', 'color' : '#800000', 'value' : 'Maroon'},
381   - {'key' : '[0,0,128]', 'color' : '#000080', 'value' : 'Navy'},
382   - {'key' : '[128,128,0]', 'color' : '#808000', 'value' : 'Olive'},
383   - {'key' : '[128,0,128]', 'color' : '#800080', 'value' : 'Purple'},
384   - {'key' : '[192,192,192]', 'color' : '#C0C0C0', 'value' : 'Silver'},
385   - {'key' : '[0,128,128]', 'color' : '#008080', 'value' : 'Teal'},
386   - {'key' : '[255,255,0]', 'color' : '#FFFF00', 'value' : 'Yellow'},
387   - {'key' : '[0,64,64]', 'color' : '#004040', 'value' : 'Cyprus'}
388   - ],
389   -
390   - availableStatusBarPositions : [
391   - {'key' : 'top', 'value' : 'Top'},
392   - {'key' : 'bottom', 'value' : 'Bottom'}
393   - ],
394   -
395   - availableStatusBarColorMaps : [
396   - {'key' : '0', 'value' : '0'},
397   - {'key' : '1', 'value' : '1'},
398   - {'key' : '2', 'value' : '2'}
399   - ],
400   -
401   - availablePageLayouts : [
402   - {'key' : 'vertical', 'value' : 'Vertical'},
403   - {'key' : 'auto', 'value' : 'Auto'},
404   - {'key' : 'manual', 'value' : 'Manual'}
405   - ],
406   -
407   - availableResamplingModes : [
408   - {'key' : 'xparam', 'value' : 'X Parameter'},
409   - {'key' : 'yparam', 'value' : 'Y Parameter'}
410   - ],
411   -
412   - availableOrbitSerieProjections : [
413   - {'key' : 'XY', 'value' : 'XY'},
414   - {'key' : 'XZ', 'value' : 'XZ'},
415   - {'key' : 'YZ', 'value' : 'YZ'},
416   - {'key' : 'XR', 'value' : 'XR'},
417   - {'key' : 'YR', 'value' : 'YR'},
418   - {'key' : 'ZR', 'value' : 'ZR'}
419   - ],
420   -
421   - availableDimsOnXAxis : [
422   - {'key' : '0', 'value' : 'First dimension'},
423   - {'key' : '1', 'value' : 'Second dimension'}
424   - ],
425   -
426   - availableTimeTickTypes : [
427   - {'key' : 'auto', 'value' : 'Auto'},
428   - {'key' : 'time-step', 'value' : 'Time step'},
429   - {'key' : 'nb-major', 'value' : 'Num. of major symb.'}
430   - ],
431   -
432   - availableIntervalTickModes : [
433   - {'key' : 'symbol-only', 'value' : 'Symbol only'},
434   - {'key' : 'interval-index', 'value' : 'Interval index'},
435   - {'key' : 'start-time', 'value' : 'Start time'},
436   - {'key' : 'start-stop-time', 'value' : 'Start/Stop times'}
437   - ],
438   -
439   - availableErrorBarTypes : [
440   - {'key' : 'min-max', 'value' : 'Min./Max. Parameters'},
441   - {'key' : 'delta', 'value' : 'Delta parameter'}
442   - ],
443   -
444   - availableLegendSeriesTypes : [
445   - {'key' : 'text-line-symbol', 'value' : 'Text, Line & Symbols'},
446   - {'key' : 'text-only', 'value' : 'Text only'}
447   - ],
448   -
449   - availableLegendSeriesPositions : [
450   - {'key' : 'inside', 'value' : 'Inside'},
451   - {'key' : 'outside', 'value' : 'Outside'}
452   - ],
453   -
454   - availableLegendSeriesIntervalInfoTypes : [
455   - {'key' : 'index', 'value' : 'Interval Index'},
456   - {'key' : 'start-stop', 'value' : 'Interval Start/Stop'}
457   - ],
458   -
459   - availableLegendTextPositions : [
460   - {'key' : 'right', 'value' : 'Right'},
461   - {'key' : 'left', 'value' : 'Left'},
462   - {'key' : 'top', 'value' : 'Top'},
463   - {'key' : 'bottom', 'value' : 'Bottom'}
464   - ],
465   -
466   - availableConstantAxes : [
467   - {'key' : 'x', 'value' : 'X / Time / Epoch'},
468   - {'key' : 'y-left', 'value' : 'Y Left'},
469   - {'key' : 'y-right', 'value' : 'Y Right'}
470   - ],
471   -
472   - availableTextAlignments : [
473   - {'key' : 'left', 'value' : 'Left'},
474   - {'key' : 'center', 'value' : 'Center'},
475   - {'key' : 'right', 'value' : 'Right'}
476   - ],
477   -
478   - availableFillTypes : [
479   - {'key' : 'serie-constant', 'value' : 'Serie / Constant'},
480   - {'key' : 'serie-serie', 'value' : 'Serie / Serie'}
481   - ],
482   - availableSpectroNormalization : [
483   - {'key' : 'none', 'value' : 'None'},
484   - {'key' : 'linear', 'value' : 'Linear'},
485   - {'key' : 'log', 'value' : 'Logarithmic'}
486   - ],
487   -
488   - availableFilteringLevel : [
489   - {'key' : 1, 'value' : 'Weak'},
490   - {'key' : 2, 'value' : 'Intermediate/moderated'},
491   - {'key' : 3, 'value' : 'Strong'}
492   - ],
493   -
494   - getParamConfig : function(paramId, onParamConfigLoaded) {
495   - AmdaAction.getParamPlotInit({"paramId" : paramId}, function (result, e) {
  220 +
  221 + availableFileFormats: [
  222 + { 'key': 'PNG', 'value': 'PNG' },
  223 + { 'key': 'PDF', 'value': 'PDF' },
  224 + { 'key': 'PS', 'value': 'PS' },
  225 + { 'key': 'SVG', 'value': 'SVG' }
  226 + ],
  227 +
  228 + availableFileOutputsForPng: [
  229 + { 'key': 'INTERACTIVE', 'value': 'screen' },
  230 + { 'key': 'TGZ', 'value': 'tar+gzip archive' },
  231 + { 'key': 'ZIP', 'value': 'zip archive' }
  232 + ],
  233 +
  234 + availableFileOutputsForOtherFormats: [
  235 + { 'key': 'TGZ', 'value': 'tar+gzip archive' },
  236 + { 'key': 'ZIP', 'value': 'zip archive' }
  237 + ],
  238 +
  239 + availablePageModes: [
  240 + { 'key': 'color', 'value': 'Color' },
  241 + { 'key': 'grayscale', 'value': 'Grayscale' }
  242 + ],
  243 +
  244 + availablePageOrientations: [
  245 + { 'key': 'landscape', 'value': 'Landscape' },
  246 + { 'key': 'portrait', 'value': 'Portrait' }
  247 + ],
  248 +
  249 + availablePageDimensions: [
  250 + { 'key': 'ISO A4', 'value': 'ISO A4' },
  251 + { 'key': 'US letter', 'value': 'US letter' }
  252 + ],
  253 +
  254 + availablePlotTypes: [
  255 + { 'key': 'timePlot', value: 'Time Plot' },
  256 + { 'key': 'xyPlot', value: 'Scatter Plot' },
  257 + { 'key': 'epochPlot', value: 'Epoch Plot' },
  258 + { 'key': 'instantPlot', value: 'Instant Plot' },
  259 + { 'key': 'statusPlot', value: 'Status Plot' },
  260 + { 'key': 'tickPlot', value: 'Tick Plot' }
  261 + ],
  262 +
  263 + availableFontNames: [
  264 + { 'key': 'sans-serif', 'value': 'sans-serif' },
  265 + { 'key': 'serif', 'value': 'serif' },
  266 + { 'key': 'monospace', 'value': 'monospace' },
  267 + { 'key': 'script', 'value': 'script' }
  268 + ],
  269 +
  270 + availableTitlePositions: [
  271 + { 'key': 'top', 'value': 'Top' },
  272 + { 'key': 'bottom', 'value': 'Bottom' }
  273 + ],
  274 +
  275 + availableTitleAlignments: [
  276 + { 'key': 'center', 'value': 'Center' },
  277 + { 'key': 'left', 'value': 'Left' },
  278 + { 'key': 'right', 'value': 'Right' }
  279 + ],
  280 +
  281 + availableAxisScales: [
  282 + { 'key': 'linear', 'value': 'Linear' },
  283 + { 'key': 'logarithmic', 'value': 'Logarithmic' }
  284 + ],
  285 +
  286 + availableTicksPositions: [
  287 + { 'key': 'inwards', 'value': 'Inwards' },
  288 + { 'key': 'outwards', 'value': 'Outwards' }
  289 + ],
  290 +
  291 + availableTimeAxisFormats: [
  292 + { 'key': 'dd/mm/yy', 'value': 'dd/mm/yy' },
  293 + { 'key': 'ddd/yy', 'value': 'ddd/yy' },
  294 + { 'key': 'DD/MM/YYYY', 'value': 'dd/mm/yyyy' },
  295 + { 'key': 'yyyy/dd/mm', 'value': 'yyyy/dd/mm' },
  296 + { 'key': 'yyyy-dd-mm', 'value': 'yyyy-dd-mm' }
  297 + ],
  298 +
  299 + availableYAxes: [
  300 + { 'key': 'y-left', 'value': 'Left' },
  301 + { 'key': 'y-right', 'value': 'Right' }
  302 + ],
  303 +
  304 + availableResolutions: [
  305 + { 'key': 3000, 'value': '3000' },
  306 + { 'key': 10000, 'value': '10000' },
  307 + { 'key': 50000, 'value': '50000' },
  308 + { 'key': 100000, 'value': '100000' }
  309 + ],
  310 +
  311 + availableLinesStyles: [
  312 + { 'key': 'plain', 'value': 'Plain' },
  313 + { 'key': 'dot', 'value': 'Dot' },
  314 + { 'key': 'long-spaced-dot', 'value': 'Long spaced dot' },
  315 + { 'key': 'long-short-dot', 'value': 'Long short dot' }
  316 + ],
  317 +
  318 + availableSymbolsTypes: [
  319 + { 'key': 'dot', 'value': 'Dot' },
  320 + { 'key': 'plus', 'value': 'Plus' },
  321 + { 'key': 'wildcard', 'value': 'Wildcard' },
  322 + { 'key': 'circle', 'value': 'Circle' },
  323 + { 'key': 'crux', 'value': 'Crux' },
  324 + { 'key': 'square', 'value': 'Square' },
  325 + { 'key': 'triangle', 'value': 'Triangle' },
  326 + { 'key': 'crux-in-circle', 'value': 'Crux in circle' },
  327 + { 'key': 'dot-in-circle', 'value': 'Dot in circle' },
  328 + { 'key': 'diamond', 'value': 'Diamond' },
  329 + { 'key': 'star', 'value': 'Star' },
  330 + { 'key': 'david-star', 'value': 'David star' },
  331 + { 'key': 'full-square', 'value': 'Full square' },
  332 + { 'key': 'full-circle', 'value': 'Full circle' },
  333 + { 'key': 'full-star', 'value': 'Full star' }
  334 + ],
  335 +
  336 + availableColorMaps: [
  337 + { 'key': '0', 'value': 'Blue Red' },
  338 + { 'key': '1', 'value': 'Default' },
  339 + { 'key': '2', 'value': 'Blue Yellow' },
  340 + { 'key': '3', 'value': 'Grayscale' },
  341 + { 'key': '4', 'value': 'AMDA Default' },
  342 + { 'key': '5', 'value': 'GeoWhite' },
  343 + { 'key': '6', 'value': 'GeoBlack' },
  344 + { 'key': '7', 'value': 'Violet Yellow' },
  345 + { 'key': '8', 'value': 'Red Blue 4' }
  346 + ],
  347 +
  348 + availableColors: [
  349 + { 'key': 'auto', 'color': 'auto', 'value': 'auto' },
  350 + { 'key': '[0,0,0]', 'color': '#000000', 'value': 'Black' },
  351 + { 'key': '[0,0,255]', 'color': '#0000ff', 'value': 'Blue' },
  352 + { 'key': '[255,0,0]', 'color': '#ff0000', 'value': 'Red' },
  353 + { 'key': '[0,255,255]', 'color': '#00ffff', 'value': 'Cyan' },
  354 + { 'key': '[255,0,255]', 'color': '#ff00ff', 'value': 'Magenta' },
  355 + { 'key': '[0,128,0]', 'color': '#008000', 'value': 'Green' },
  356 + { 'key': '[128,128,128]', 'color': '#808080', 'value': 'Gray' },
  357 + { 'key': '[0,255,0]', 'color': '#00ff00', 'value': 'Lime' },
  358 + { 'key': '[128,0,0]', 'color': '#800000', 'value': 'Maroon' },
  359 + { 'key': '[0,0,128]', 'color': '#000080', 'value': 'Navy' },
  360 + { 'key': '[128,128,0]', 'color': '#808000', 'value': 'Olive' },
  361 + { 'key': '[128,0,128]', 'color': '#800080', 'value': 'Purple' },
  362 + { 'key': '[192,192,192]', 'color': '#c0c0c0', 'value': 'Silver' },
  363 + { 'key': '[0,128,128]', 'color': '#008080', 'value': 'Teal' },
  364 + { 'key': '[255,255,0]', 'color': '#ffff00', 'value': 'Yellow' },
  365 + { 'key': '[0,64,64]', 'color': '#004040', 'value': 'Cyprus' }
  366 + ],
  367 +
  368 + availableBackgroundColors: [
  369 + { 'color': 'none', 'value': 'None' },
  370 + { 'key': '[0,0,0]', 'color': '#000000', 'value': 'Black' },
  371 + { 'key': '[0,0,255]', 'color': '#0000FF', 'value': 'Blue' },
  372 + { 'key': '[255,0,0]', 'color': '#FF0000', 'value': 'Red' },
  373 + { 'key': '[0,255,255]', 'color': '#00FFFF', 'value': 'Cyan' },
  374 + { 'key': '[255,0,255]', 'color': '#FF00FF', 'value': 'Magenta' },
  375 + { 'key': '[0,128,0]', 'color': '#008000', 'value': 'Green' },
  376 + { 'key': '[128,128,128]', 'color': '#808080', 'value': 'Gray' },
  377 + { 'key': '[0,255,0]', 'color': '#00FF00', 'value': 'Lime' },
  378 + { 'key': '[128,0,0]', 'color': '#800000', 'value': 'Maroon' },
  379 + { 'key': '[0,0,128]', 'color': '#000080', 'value': 'Navy' },
  380 + { 'key': '[128,128,0]', 'color': '#808000', 'value': 'Olive' },
  381 + { 'key': '[128,0,128]', 'color': '#800080', 'value': 'Purple' },
  382 + { 'key': '[192,192,192]', 'color': '#C0C0C0', 'value': 'Silver' },
  383 + { 'key': '[0,128,128]', 'color': '#008080', 'value': 'Teal' },
  384 + { 'key': '[255,255,0]', 'color': '#FFFF00', 'value': 'Yellow' },
  385 + { 'key': '[0,64,64]', 'color': '#004040', 'value': 'Cyprus' }
  386 + ],
  387 +
  388 + availableStatusBarPositions: [
  389 + { 'key': 'top', 'value': 'Top' },
  390 + { 'key': 'bottom', 'value': 'Bottom' }
  391 + ],
  392 +
  393 + availableStatusBarColorMaps: [
  394 + { 'key': '0', 'value': '0' },
  395 + { 'key': '1', 'value': '1' },
  396 + { 'key': '2', 'value': '2' }
  397 + ],
  398 +
  399 + availablePageLayouts: [
  400 + { 'key': 'vertical', 'value': 'Vertical' },
  401 + { 'key': 'auto', 'value': 'Auto' },
  402 + { 'key': 'manual', 'value': 'Manual' }
  403 + ],
  404 +
  405 + availableResamplingModes: [
  406 + { 'key': 'xparam', 'value': 'X Parameter' },
  407 + { 'key': 'yparam', 'value': 'Y Parameter' }
  408 + ],
  409 +
  410 + availableOrbitSerieProjections: [
  411 + { 'key': 'XY', 'value': 'XY' },
  412 + { 'key': 'XZ', 'value': 'XZ' },
  413 + { 'key': 'YZ', 'value': 'YZ' },
  414 + { 'key': 'XR', 'value': 'XR' },
  415 + { 'key': 'YR', 'value': 'YR' },
  416 + { 'key': 'ZR', 'value': 'ZR' }
  417 + ],
  418 +
  419 + availableDimsOnXAxis: [
  420 + { 'key': '0', 'value': 'First dimension' },
  421 + { 'key': '1', 'value': 'Second dimension' }
  422 + ],
  423 +
  424 + availableTimeTickTypes: [
  425 + { 'key': 'auto', 'value': 'Auto' },
  426 + { 'key': 'time-step', 'value': 'Time step' },
  427 + { 'key': 'nb-major', 'value': 'Num. of major symb.' }
  428 + ],
  429 +
  430 + availableIntervalTickModes: [
  431 + { 'key': 'symbol-only', 'value': 'Symbol only' },
  432 + { 'key': 'interval-index', 'value': 'Interval index' },
  433 + { 'key': 'start-time', 'value': 'Start time' },
  434 + { 'key': 'start-stop-time', 'value': 'Start/Stop times' }
  435 + ],
  436 +
  437 + availableErrorBarTypes: [
  438 + { 'key': 'min-max', 'value': 'Min./Max. Parameters' },
  439 + { 'key': 'delta', 'value': 'Delta parameter' }
  440 + ],
  441 +
  442 + availableLegendSeriesTypes: [
  443 + { 'key': 'text-line-symbol', 'value': 'Text, Line & Symbols' },
  444 + { 'key': 'text-only', 'value': 'Text only' }
  445 + ],
  446 +
  447 + availableLegendSeriesPositions: [
  448 + { 'key': 'inside', 'value': 'Inside' },
  449 + { 'key': 'outside', 'value': 'Outside' }
  450 + ],
  451 +
  452 + availableLegendSeriesIntervalInfoTypes: [
  453 + { 'key': 'index', 'value': 'Interval Index' },
  454 + { 'key': 'start-stop', 'value': 'Interval Start/Stop' }
  455 + ],
  456 +
  457 + availableLegendTextPositions: [
  458 + { 'key': 'right', 'value': 'Right' },
  459 + { 'key': 'left', 'value': 'Left' },
  460 + { 'key': 'top', 'value': 'Top' },
  461 + { 'key': 'bottom', 'value': 'Bottom' }
  462 + ],
  463 +
  464 + availableConstantAxes: [
  465 + { 'key': 'x', 'value': 'X / Time / Epoch' },
  466 + { 'key': 'y-left', 'value': 'Y Left' },
  467 + { 'key': 'y-right', 'value': 'Y Right' }
  468 + ],
  469 +
  470 + availableTextAlignments: [
  471 + { 'key': 'left', 'value': 'Left' },
  472 + { 'key': 'center', 'value': 'Center' },
  473 + { 'key': 'right', 'value': 'Right' }
  474 + ],
  475 +
  476 + availableFillTypes: [
  477 + { 'key': 'serie-constant', 'value': 'Serie / Constant' },
  478 + { 'key': 'serie-serie', 'value': 'Serie / Serie' }
  479 + ],
  480 + availableSpectroNormalization: [
  481 + { 'key': 'none', 'value': 'None' },
  482 + { 'key': 'linear', 'value': 'Linear' },
  483 + { 'key': 'log', 'value': 'Logarithmic' }
  484 + ],
  485 +
  486 + availableFilteringLevel: [
  487 + { 'key': 1, 'value': 'Weak' },
  488 + { 'key': 2, 'value': 'Intermediate/moderated' },
  489 + { 'key': 3, 'value': 'Strong' }
  490 + ],
  491 +
  492 + fieldComboBox: {
  493 + key: 'key',
  494 + value: 'value'
  495 + },
  496 +
  497 + bgSubstraction: {
  498 + tableName: "channels-param-info",
  499 + tableChannels: "channels",
  500 + tableRelatedDim: 'relatedDim',
  501 + name: 'Background Substraction',
  502 + type: {
  503 + label: "Type ",
  504 + key: "background_sub_type",
  505 + values: {
  506 + bychannel: "By Channel",
  507 + fixedvalue: "Fixed Value"
  508 + }
  509 + },
  510 + value: {
  511 + textinputlabel: "Fixed value ",
  512 + key: "background_sub_value",
  513 + textinputkey: "background_sub_by_value",
  514 + dimlabel: 'Dim ',
  515 + dimkey: 'background_sub_dim',
  516 + dimNullValue: "-1"
  517 + }
  518 + },
  519 +
  520 + getParamConfig: function (paramId, onParamConfigLoaded) {
  521 + AmdaAction.getParamPlotInit({ "paramId": paramId }, function (result, e) {
496 522 onParamConfigLoaded(result.success, result.data);
497 523 });
498 524 }
... ...
js/app/models/PlotObjects/PlotSpectroObject.js
  Diff comments   View file @9e70b8e
... ... @@ -11,73 +11,83 @@
11 11 ******************************************************************************
12 12 * : :21/08/2015: BRE - file creation
13 13 */
14   -
15   -
  14 +
  15 +
16 16 Ext.define('amdaPlotObj.PlotSpectroObject', {
17   - extend: 'Ext.data.Model',
18   -
19   - requires: [
20   - 'amdaPlotObj.PlotObjectConfig'
21   - ],
22   -
23   - fields : [
24   - {name: 'spectro-yaxis', type: 'string'},
25   - {name: 'spectro-resolution', type: 'int'},
26   - {name: 'spectro-value-min', type: 'float', useNull:true},
27   - {name: 'spectro-value-max', type: 'float', useNull:true},
28   - {name: 'spectro-log0-as-min', type: 'boolean'},
29   - {name: 'spectro-normalization', type: 'string'},
30   - //Filtering
31   - {name: 'filtering-activated', type: 'boolean'},
32   - {name:'filtering-level', type:'int'}
33   - ],
34   -
35   - constructor: function(){
  17 + extend: 'Ext.data.Model',
  18 +
  19 + requires: [
  20 + 'amdaPlotObj.PlotObjectConfig'
  21 + ],
  22 +
  23 + fields: [
  24 + { name: 'spectro-yaxis', type: 'string' },
  25 + { name: 'spectro-resolution', type: 'int' },
  26 + { name: 'spectro-value-min', type: 'float', useNull: true },
  27 + { name: 'spectro-value-max', type: 'float', useNull: true },
  28 + { name: 'spectro-log0-as-min', type: 'boolean' },
  29 + { name: 'spectro-normalization', type: 'string' },
  30 + //Filtering
  31 + { name: 'filtering-activated', type: 'boolean' },
  32 + { name: 'filtering-level', type: 'int' },
  33 +
  34 + { name: amdaPlotObj.PlotObjectConfig.bgSubstraction.name, type: 'boolean' },
  35 + { name: amdaPlotObj.PlotObjectConfig.bgSubstraction.type.key, type: 'string' },
  36 + { name: amdaPlotObj.PlotObjectConfig.bgSubstraction.value.key, type: 'string' },
  37 + { name: amdaPlotObj.PlotObjectConfig.bgSubstraction.value.dimkey, type: 'string' }
  38 + ],
  39 +
  40 + constructor: function () {
36 41 var me = this;
37 42 me.callParent(arguments);
38   - if ((arguments.length > 0) && arguments[0])
39   - {
  43 + if ((arguments.length > 0) && arguments[0]) {
40 44 }
41   - else
42   - {
43   - //new object, set default fields values
44   - me.setDefaultValues();
  45 + else {
  46 + //new object, set default fields values
  47 + me.setDefaultValues();
45 48 }
46 49 this.dirty = false;
47 50 },
48   -
49   - loadFromData : function(drawData)
50   - {
51   - Ext.Object.each(drawData, function(key, value) {
52   - if (key == 'type')
53   - return;
54   - this.set(key, value);
55   - }, this);
  51 +
  52 + loadFromData: function (drawData) {
  53 + Ext.Object.each(drawData, function (key, value) {
  54 + if (key == 'type')
  55 + return;
  56 + this.set(key, value);
  57 + }, this);
56 58 },
57   -
58   - setDefaultValues: function()
59   - {
60   - this.set('spectro-yaxis', amdaPlotObj.PlotObjectConfig.defaultValues.spectro.yAxis);
61   - this.set('spectro-resolution', amdaPlotObj.PlotObjectConfig.defaultValues.spectro.resolution);
62   - this.set('spectro-log0-as-min', false);
63   - this.set('spectro-normalization', "none");
64   - // filtering
65   - this.set( 'filtering-activated', false);
66   - this.set('filtering-level', amdaPlotObj.PlotObjectConfig.defaultValues.filtering.level);
  59 +
  60 + setDefaultValues: function () {
  61 + this.set('spectro-yaxis', amdaPlotObj.PlotObjectConfig.defaultValues.spectro.yAxis);
  62 + this.set('spectro-resolution', amdaPlotObj.PlotObjectConfig.defaultValues.spectro.resolution);
  63 + this.set('spectro-log0-as-min', false);
  64 + this.set('spectro-normalization', "none");
  65 + // filtering
  66 + this.set('filtering-activated', false);
  67 + this.set('filtering-level', amdaPlotObj.PlotObjectConfig.defaultValues.filtering.level);
  68 +
  69 + this.set(amdaPlotObj.PlotObjectConfig.bgSubstraction.name, false);
  70 + this.set(amdaPlotObj.PlotObjectConfig.bgSubstraction.type.key, null);
  71 + this.set(amdaPlotObj.PlotObjectConfig.bgSubstraction.value.key, amdaPlotObj.PlotObjectConfig.bgSubstraction.value.dimNullValue);
  72 + this.set(amdaPlotObj.PlotObjectConfig.bgSubstraction.value.dimkey, amdaPlotObj.PlotObjectConfig.bgSubstraction.value.dimNullValue);
67 73 },
68   -
69   - getJsonValues : function()
70   - {
71   - var spectroValues = new Object();
72   -
73   - spectroValues['spectro-yaxis'] = this.get('spectro-yaxis');
74   - spectroValues['spectro-resolution'] = this.get('spectro-resolution');
75   - spectroValues['spectro-value-min'] = this.get('spectro-value-min');
76   - spectroValues['spectro-value-max'] = this.get('spectro-value-max');
77   - spectroValues['spectro-log0-as-min'] = this.get('spectro-log0-as-min');
78   - spectroValues['spectro-normalization'] = this.get('spectro-normalization');
79   - spectroValues['filtering-activated'] = this.get('filtering-activated');
80   - spectroValues['filtering-level'] = this.get('filtering-level');
81   - return spectroValues;
  74 +
  75 + getJsonValues: function () {
  76 + var spectroValues = new Object();
  77 +
  78 + spectroValues['spectro-yaxis'] = this.get('spectro-yaxis');
  79 + spectroValues['spectro-resolution'] = this.get('spectro-resolution');
  80 + spectroValues['spectro-value-min'] = this.get('spectro-value-min');
  81 + spectroValues['spectro-value-max'] = this.get('spectro-value-max');
  82 + spectroValues['spectro-log0-as-min'] = this.get('spectro-log0-as-min');
  83 + spectroValues['spectro-normalization'] = this.get('spectro-normalization');
  84 + spectroValues['filtering-activated'] = this.get('filtering-activated');
  85 + spectroValues['filtering-level'] = this.get('filtering-level');
  86 +
  87 + spectroValues[amdaPlotObj.PlotObjectConfig.bgSubstraction.name] = this.get(amdaPlotObj.PlotObjectConfig.bgSubstraction.name);
  88 + spectroValues[amdaPlotObj.PlotObjectConfig.bgSubstraction.type.key] = this.get(amdaPlotObj.PlotObjectConfig.bgSubstraction.type.key);
  89 + spectroValues[amdaPlotObj.PlotObjectConfig.bgSubstraction.value.key] = this.get(amdaPlotObj.PlotObjectConfig.bgSubstraction.value.key);
  90 + spectroValues[amdaPlotObj.PlotObjectConfig.bgSubstraction.value.dimkey] = this.get(amdaPlotObj.PlotObjectConfig.bgSubstraction.value.dimkey);
  91 + return spectroValues;
82 92 }
83 93 });
... ...
js/app/views/ParamArgumentsUI.js
  Diff comments   View file @9e70b8e
... ... @@ -12,56 +12,58 @@
12 12 Ext.define('amdaUI.ParamArgumentsUI', {
13 13 extend: 'Ext.container.Container',
14 14 alias: 'widget.paramArguments',
15   -
  15 +
16 16 regexp_istemplate: /^template_(.*)/,
17   -
  17 +
18 18 paramRequestObject: null,
19 19 onChange: null,
20 20 onModifyHeight: null,
21 21 pluginOwner: null,
22   - inRebuild : false,
23   -
24   - constructor: function(config) {
25   - this.init(config);
  22 + inRebuild: false,
  23 +
  24 + constructor: function (config) {
  25 + this.init(config);
26 26 this.callParent(arguments);
27 27 },
28   -
29   - init : function(config) {
  28 +
  29 + init: function (config) {
30 30 var myConf = {
31 31 layout: {
32 32 type: 'vbox',
33 33 align: 'stretch'
34   - },
  34 + },
35 35 };
36   -
37   - Ext.apply (this , Ext.apply (arguments, myConf));
  36 +
  37 + Ext.apply(this, Ext.apply(arguments, myConf));
38 38 },
39   -
40   - editParameter: function(paramRequestObject, uiScope, onReady) {
  39 +
  40 + editParameter: function (paramRequestObject, uiScope, onReady) {
41 41 this.paramRequestObject = paramRequestObject;
42 42  
43 43 var me = this;
44 44 me.getEl().mask();
45 45 me.resetArguments();
46   -
  46 +
47 47 var explorerModule = myDesktopApp.getLoadedModule(myDesktopApp.dynamicModules.explorer.id);
48   -
  48 +
49 49 if (explorerModule) {
50 50 explorerModule.getParamInfo(paramRequestObject.get('paramid'), function (paramInfo) {
51 51 if (paramInfo) {
  52 + paramRequestObject.set(amdaPlotObj.PlotObjectConfig.bgSubstraction.tableName, paramInfo.data.tables);
  53 +
52 54 if (!paramRequestObject.get('is-init')) {
53 55 if (paramInfo.data && paramInfo.data.dimensions) {
54 56 //Init each dimensions and set parameter type (0: scalar, 1: vector or 2: Tab2D)
55   - paramRequestObject.set('type',0);
  57 + paramRequestObject.set('type', 0);
56 58 if (me.initDimension('dim1', paramInfo.data)) {
57   - paramRequestObject.set('type',paramRequestObject.get('type')+1);
  59 + paramRequestObject.set('type', paramRequestObject.get('type') + 1);
58 60 }
59 61 if (me.initDimension('dim2', paramInfo.data)) {
60   - paramRequestObject.set('type',paramRequestObject.get('type')+1);
  62 + paramRequestObject.set('type', paramRequestObject.get('type') + 1);
61 63 }
62 64 if (paramRequestObject.get('type') == 2) {
63 65 //Tab2D
64   - var dim2RelatedTable = me.getRelatedTableFromDim('dim2',paramInfo.data.tables);
  66 + var dim2RelatedTable = me.getRelatedTableFromDim('dim2', paramInfo.data.tables);
65 67 if (!dim2RelatedTable.variable) {
66 68 paramRequestObject.set('dim2-index', 0);
67 69 }
... ... @@ -77,13 +79,13 @@ Ext.define('amdaUI.ParamArgumentsUI', {
77 79 if (onReady)
78 80 onReady(uiScope);
79 81 me.getEl().unmask();
80   - });
  82 + });
81 83 }
82 84 else
83 85 me.getEl().unmask();
84 86 },
85 87  
86   - initDimension: function(relatedDim, data) {
  88 + initDimension: function (relatedDim, data) {
87 89 if (!data || !data.dimensions || !data.dimensions[relatedDim] || this.paramRequestObject.get('is-init')) {
88 90 return false;
89 91 }
... ... @@ -92,23 +94,23 @@ Ext.define('amdaUI.ParamArgumentsUI', {
92 94 if (relatedTable) {
93 95 var minmax = this.getDimensionMinMaxValues(relatedDim, data);
94 96 if (!minmax) {
95   - myDesktopApp.warningMsg('Min/Max '+this.getDimensionTitle(relatedDim, data)+' values are undefined<br/>Arbitrary values are taken');
  97 + myDesktopApp.warningMsg('Min/Max ' + this.getDimensionTitle(relatedDim, data) + ' values are undefined<br/>Arbitrary values are taken');
96 98 minmax = {
97 99 'min': 10,
98 100 'max': 10000
99 101 };
100 102 }
101   - this.paramRequestObject.set(relatedDim+'-min-value', minmax['min']);
102   - this.paramRequestObject.set(relatedDim+'-max-value', minmax['max']);
103   - this.paramRequestObject.set(relatedDim+'-min-index', 0);
104   - this.paramRequestObject.set(relatedDim+'-max-index', parseInt(data.dimensions[relatedDim])-1);
  103 + this.paramRequestObject.set(relatedDim + '-min-value', minmax['min']);
  104 + this.paramRequestObject.set(relatedDim + '-max-value', minmax['max']);
  105 + this.paramRequestObject.set(relatedDim + '-min-index', 0);
  106 + this.paramRequestObject.set(relatedDim + '-max-index', parseInt(data.dimensions[relatedDim]) - 1);
105 107 }
106 108 return true;
107 109 }
108 110 return false;
109 111 },
110 112  
111   - getDimensionMinMaxValues: function(relatedDim, data) {
  113 + getDimensionMinMaxValues: function (relatedDim, data) {
112 114 var relatedTable = this.getRelatedTableFromDim(relatedDim, data.tables);
113 115 if (relatedTable.variable) {
114 116 if (Ext.Object.isEmpty(relatedTable.minmax)) {
... ... @@ -138,7 +140,7 @@ Ext.define(&#39;amdaUI.ParamArgumentsUI&#39;, {
138 140 };
139 141 },
140 142  
141   - getDimensionTitle: function(relatedDim, data) {
  143 + getDimensionTitle: function (relatedDim, data) {
142 144 var relatedTable = this.getRelatedTableFromDim(relatedDim, data.tables);
143 145 var title = 'Unknown';
144 146 if (relatedTable) {
... ... @@ -154,8 +156,8 @@ Ext.define(&#39;amdaUI.ParamArgumentsUI&#39;, {
154 156 }
155 157 return title;
156 158 },
157   -
158   - rebuildAll: function(paramInfoResult , uiScope) {
  159 +
  160 + rebuildAll: function (paramInfoResult, uiScope) {
159 161 this.inRebuild = true;
160 162 //Rebuild arguments selection
161 163 this.rebuildArguments(paramInfoResult, uiScope);
... ... @@ -163,402 +165,402 @@ Ext.define(&#39;amdaUI.ParamArgumentsUI&#39;, {
163 165 var templateArgsValues = this.paramRequestObject.get('template_args');
164 166 if (!templateArgsValues)
165 167 templateArgsValues = {};
166   - if (paramInfoResult.template && paramInfoResult.template.arguments) {
  168 + if (paramInfoResult.template && paramInfoResult.template.arguments) {
167 169 //Add default template args definition if needed
168 170 Ext.Object.each(paramInfoResult.template.arguments, function (argKey, argDef) {
169 171 if (!templateArgsValues[argKey])
170 172 templateArgsValues[argKey] = argDef['default'];
171 173 }, this);
172   -
  174 +
173 175 this.paramRequestObject.set('template_args', templateArgsValues);
174 176 }
175   -
176   -
  177 +
  178 +
177 179 //Init values in interface
178 180 this.items.each(function (item) {
179 181 if (!item.argId)
180 182 return;
181 183 if (this.regexp_istemplate.test(item.argId)) {
182 184 var arg_key = this.regexp_istemplate.exec(item.argId)[1];
183   -
  185 +
184 186 if (this.paramRequestObject.get('template_args') && this.paramRequestObject.get('template_args')[arg_key])
185 187 item.setValue(this.paramRequestObject.get('template_args')[arg_key]);
186 188 }
187 189 else if (item.argId == 'dim1' || item.argId == 'dim2') {
188   - item.setValue(this.paramRequestObject.get(item.argId+'-index'));
189   - var sumInRangeField = item.up().down('[name=sum_fieldset_'+item.argId +']');
  190 + item.setValue(this.paramRequestObject.get(item.argId + '-index'));
  191 + var sumInRangeField = item.up().down('[name=sum_fieldset_' + item.argId + ']');
190 192 if (sumInRangeField) {
191 193 //Fill fields
192   - sumInRangeField.down('textfield[name=value_min_' + item.argId + ']').setValue(this.paramRequestObject.get(item.argId+'-min-value'));
193   - sumInRangeField.down('textfield[name=value_max_' + item.argId + ']').setValue(this.paramRequestObject.get(item.argId+'-max-value'));
194   - sumInRangeField.down('textfield[name=index_min_' + item.argId + ']').setValue(this.paramRequestObject.get(item.argId+'-min-index'));
195   - sumInRangeField.down('textfield[name=index_max_' + item.argId + ']').setValue(this.paramRequestObject.get(item.argId+'-max-index'));
196   - if (this.paramRequestObject.get(item.argId+'-sum-type') > 0) {
  194 + sumInRangeField.down('textfield[name=value_min_' + item.argId + ']').setValue(this.paramRequestObject.get(item.argId + '-min-value'));
  195 + sumInRangeField.down('textfield[name=value_max_' + item.argId + ']').setValue(this.paramRequestObject.get(item.argId + '-max-value'));
  196 + sumInRangeField.down('textfield[name=index_min_' + item.argId + ']').setValue(this.paramRequestObject.get(item.argId + '-min-index'));
  197 + sumInRangeField.down('textfield[name=index_max_' + item.argId + ']').setValue(this.paramRequestObject.get(item.argId + '-max-index'));
  198 + if (this.paramRequestObject.get(item.argId + '-sum-type') > 0) {
197 199 sumInRangeField.expand();
198 200 }
199 201 else {
200 202 sumInRangeField.collapse();
201 203 }
202 204 }
203   - }
204   - else
205   - item.setValue(this.paramRequestObject.get(item.argId));
206   - this.inRebuild = false;
207   - }, this);
208   - },
209   -
210   - getValues: function() {
211   - var values = {type : paramRequestObject.get('type')};
212   - this.items.each(function(item) {
213   - if (!item.argId)
214   - return;
215   - if (this.regexp_istemplate.test(item.argId)) {
216   - var arg_key = this.regexp_istemplate.exec(item.argId)[1];
217   - if (!values['template_args'])
218   - values['template_args'] = {};
219   - values['template_args'][arg_key] = item.getValue();
220   - }
221   - else
222   - values[item.argId] = item.getValue();
223   - }, this);
224   -
225   - return values;
226   - },
227   -
228   - resetValues: function() {
229   - this.items.each(function (item) {
230   - if (item.reset)
231   - item.reset();
232   - });
233   - },
234   -
235   - resetArguments: function(noArgsMsg) {
236   - this.removeAll();
237   - if (!noArgsMsg)
238   - this.add(new Ext.form.Label({text: 'No argument for this parameter', argId: null}));
239   - },
240   -
241   - rebuildArguments: function(result, uiScope) {
242   - this.resetArguments(true);
243   -
244   - if (result.data && result.data.dimensions) {
245   - if (result.data.dimensions.dim1 && (parseInt(result.data.dimensions.dim1) > 1) || this.getRelatedTableFromDim('dim1',result.data.tables)) {
246   - this.buildDimIndexSelection("dim1", result.data, uiScope);
247   - }
248   - if (result.data.dimensions.dim2 && (parseInt(result.data.dimensions.dim2) > 1) || this.getRelatedTableFromDim('dim2',result.data.tables)) {
249   - this.buildDimIndexSelection("dim2", result.data, uiScope);
250   - }
251   - }
252   -
253   - var isTemplate = (result.template && result.template.arguments);
254   - if (isTemplate)
255   - this.buildTemplateArguments(result.template.arguments, uiScope);
256   -
257   - if ((this.paramRequestObject.get('type') == 0) && !isTemplate)
258   - //Add no args message
259   - this.resetArguments(false);
260   - },
261   -
262   - getRelatedTableFromDim : function(relatedDim, tables) {
263   - var relatedTable = null;
  205 + }
  206 + else
  207 + item.setValue(this.paramRequestObject.get(item.argId));
  208 + this.inRebuild = false;
  209 + }, this);
  210 + },
  211 +
  212 + getValues: function () {
  213 + var values = { type: paramRequestObject.get('type') };
  214 + this.items.each(function (item) {
  215 + if (!item.argId)
  216 + return;
  217 + if (this.regexp_istemplate.test(item.argId)) {
  218 + var arg_key = this.regexp_istemplate.exec(item.argId)[1];
  219 + if (!values['template_args'])
  220 + values['template_args'] = {};
  221 + values['template_args'][arg_key] = item.getValue();
  222 + }
  223 + else
  224 + values[item.argId] = item.getValue();
  225 + }, this);
  226 +
  227 + return values;
  228 + },
  229 +
  230 + resetValues: function () {
  231 + this.items.each(function (item) {
  232 + if (item.reset)
  233 + item.reset();
  234 + });
  235 + },
  236 +
  237 + resetArguments: function (noArgsMsg) {
  238 + this.removeAll();
  239 + if (!noArgsMsg)
  240 + this.add(new Ext.form.Label({ text: 'No argument for this parameter', argId: null }));
  241 + },
  242 +
  243 + rebuildArguments: function (result, uiScope) {
  244 + this.resetArguments(true);
  245 +
  246 + if (result.data && result.data.dimensions) {
  247 + if (result.data.dimensions.dim1 && (parseInt(result.data.dimensions.dim1) > 1) || this.getRelatedTableFromDim('dim1', result.data.tables)) {
  248 + this.buildDimIndexSelection("dim1", result.data, uiScope);
  249 + }
  250 + if (result.data.dimensions.dim2 && (parseInt(result.data.dimensions.dim2) > 1) || this.getRelatedTableFromDim('dim2', result.data.tables)) {
  251 + this.buildDimIndexSelection("dim2", result.data, uiScope);
  252 + }
  253 + }
  254 +
  255 + var isTemplate = (result.template && result.template.arguments);
  256 + if (isTemplate)
  257 + this.buildTemplateArguments(result.template.arguments, uiScope);
  258 +
  259 + if ((this.paramRequestObject.get('type') == 0) && !isTemplate)
  260 + //Add no args message
  261 + this.resetArguments(false);
  262 + },
  263 +
  264 + getRelatedTableFromDim: function (relatedDim, tables) {
  265 + var relatedTable = null;
264 266 if (tables) {
265   - Ext.each(tables, function(table, index) {
  267 + Ext.each(tables, function (table, index) {
266 268 if (table.relatedDim == relatedDim)
267 269 relatedTable = table;
268 270 }, this);
269 271 }
270 272 return relatedTable;
271   - },
272   -
273   - buildDimIndexSelection: function(relatedDim, data, uiScope) {
274   - var ruler = {
275   - xtype: 'box',
276   - autoEl : {
277   - tag : 'hr'
278   - }
279   - };
280   - //Check if this dimension is attached to a table
  273 + },
  274 +
  275 + buildDimIndexSelection: function (relatedDim, data, uiScope) {
  276 + var ruler = {
  277 + xtype: 'box',
  278 + autoEl: {
  279 + tag: 'hr'
  280 + }
  281 + };
  282 + //Check if this dimension is attached to a table
281 283 var relatedTable = this.getRelatedTableFromDim(relatedDim, data.tables);
282 284 var dimSize = data.dimensions[relatedDim];
283   -
  285 +
284 286 var title = this.getDimensionTitle(relatedDim, data);
285   -
  287 +
286 288 var indexes = [];
287   - indexes.push({'key' : '*', 'value' : 'All'});
288   -
  289 + indexes.push({ 'key': '*', 'value': 'All' });
  290 +
289 291 if (relatedTable) {
290 292 //If it's not a variable table => enable channel selection
291 293 if (!relatedTable.variable)
292 294 Ext.Object.each(relatedTable.channels, function (index, channel) {
293   - indexes.push({'key' : index.toString(), 'value' : index + ' : [' + channel.min + ', ' + channel.max + ']'});
  295 + indexes.push({ 'key': index.toString(), 'value': index + ' : [' + channel.min + ', ' + channel.max + ']' });
294 296 });
295 297 }
296 298 else {
297 299 //Else, use components
298 300 Ext.Object.each(data.components, function (index, component) {
299 301 if (relatedDim == "dim1" && component.index_1 != "")
300   - indexes.push({'key' : component.index_1, 'value' : index + ' : ' + component.name});
  302 + indexes.push({ 'key': component.index_1, 'value': index + ' : ' + component.name });
301 303 else if (relatedDim == "dim2" && component.index_2 != "")
302   - indexes.push({'key' : component.index_2, 'value' : index + ' : ' + component.name});
  304 + indexes.push({ 'key': component.index_2, 'value': index + ' : ' + component.name });
303 305 });
304 306 }
305 307  
306 308 //Add combo box
307 309 var indexesStore = Ext.create('Ext.data.Store', {
308   - fields: ['key', 'value'],
309   - data : indexes
  310 + fields: ['key', 'value'],
  311 + data: indexes
310 312 });
311 313  
312 314 var indexesCombo = Ext.create('Ext.form.ComboBox', {
313   - fieldLabel: title,
314   - store: indexesStore,
315   - queryMode: 'local',
316   - displayField: 'value',
317   - valueField: 'key',
318   - value: '*',
319   - editable: false,
320   - argId: relatedDim,
321   - hidden: (relatedTable ? relatedTable.variable : false),
322   - listeners: {
323   - change: function(field, newValue, oldValue, eOpts) {
324   - this.paramRequestObject.set(relatedDim+'-index', newValue);
325   - if (!this.inRebuild && (this.onChange != null))
326   - this.onChange(uiScope, relatedDim, newValue, oldValue, false);
327   - },
328   - scope: this
329   - }
330   -
  315 + fieldLabel: title,
  316 + store: indexesStore,
  317 + queryMode: 'local',
  318 + displayField: 'value',
  319 + valueField: 'key',
  320 + value: '*',
  321 + editable: false,
  322 + argId: relatedDim,
  323 + hidden: (relatedTable ? relatedTable.variable : false),
  324 + listeners: {
  325 + change: function (field, newValue, oldValue, eOpts) {
  326 + this.paramRequestObject.set(relatedDim + '-index', newValue);
  327 + if (!this.inRebuild && (this.onChange != null))
  328 + this.onChange(uiScope, relatedDim, newValue, oldValue, false);
  329 + },
  330 + scope: this
  331 + }
  332 +
331 333 });
332   -
  334 +
333 335 this.add(indexesCombo);
334   -
  336 +
335 337 if (relatedTable) {
336 338 var sumTypes = Ext.create('Ext.data.Store', {
337 339 fields: ['type', 'name'],
338 340 data: [
339   - {'type': 1, 'name': 'Between Values'},
340   - {'type': 2, 'name': 'Between Indexes'}
  341 + { 'type': 1, 'name': 'Between Values' },
  342 + { 'type': 2, 'name': 'Between Indexes' }
341 343 ]
342 344 });
343 345 var sumItems = [
344   - {
345   - xtype: 'combobox',
346   - name: 'sum_type_'+relatedDim,
347   - store: sumTypes,
348   - queryMode: 'local',
349   - editable: false,
350   - displayField: 'name',
351   - valueField: 'type',
352   - fieldLabel: 'Type',
353   - value: 1,
354   - listeners: {
355   - change: function(field, newValue, oldValue, eOpts) {
356   - this.paramRequestObject.set(relatedDim+'-sum-type',newValue);
357   - field.up().down('[name=value_min_'+relatedDim+']').setVisible(newValue == 1);
358   - field.up().down('[name=value_max_'+relatedDim+']').setVisible(newValue == 1);
359   - field.up().down('[name=index_min_'+relatedDim+']').setVisible(newValue == 2);
360   - field.up().down('[name=index_max_'+relatedDim+']').setVisible(newValue == 2);
361   - if (!this.inRebuild && (this.onChange != null))
362   - this.onChange(uiScope, relatedDim, newValue, oldValue, false);
  346 + {
  347 + xtype: 'combobox',
  348 + name: 'sum_type_' + relatedDim,
  349 + store: sumTypes,
  350 + queryMode: 'local',
  351 + editable: false,
  352 + displayField: 'name',
  353 + valueField: 'type',
  354 + fieldLabel: 'Type',
  355 + value: 1,
  356 + listeners: {
  357 + change: function (field, newValue, oldValue, eOpts) {
  358 + this.paramRequestObject.set(relatedDim + '-sum-type', newValue);
  359 + field.up().down('[name=value_min_' + relatedDim + ']').setVisible(newValue == 1);
  360 + field.up().down('[name=value_max_' + relatedDim + ']').setVisible(newValue == 1);
  361 + field.up().down('[name=index_min_' + relatedDim + ']').setVisible(newValue == 2);
  362 + field.up().down('[name=index_max_' + relatedDim + ']').setVisible(newValue == 2);
  363 + if (!this.inRebuild && (this.onChange != null))
  364 + this.onChange(uiScope, relatedDim, newValue, oldValue, false);
  365 + },
  366 + scope: this
  367 + }
363 368 },
364   - scope: this
365   - }
366   - },
367   - {
368   - xtype: 'numberfield',
369   - name: 'value_min_'+relatedDim,
370   - fieldLabel: 'Min.',
371   - decimalPrecision : 3,
372   - value: 0.,
373   - listeners: {
374   - change: function(field, newValue, oldValue, eOpts) {
375   - this.paramRequestObject.set(relatedDim+'-min-value', newValue);
376   - if (!this.inRebuild && (this.onChange != null))
377   - this.onChange(uiScope, relatedDim, newValue, oldValue, false);
378   - },
379   - scope: this
380   - }
381   - },
382   - {
383   - xtype: 'numberfield',
384   - name: 'value_max_'+relatedDim,
385   - fieldLabel: 'Max.',
386   - decimalPrecision : 3,
387   - value: 0.,
388   - listeners: {
389   - change: function(field, newValue, oldValue, eOpts) {
390   - this.paramRequestObject.set(relatedDim+'-max-value', newValue);
391   - if (!this.inRebuild && (this.onChange != null))
392   - this.onChange(uiScope, relatedDim, newValue, oldValue, false);
393   - },
394   - scope: this
395   - }
396   - },
397   - {
398   - xtype: 'numberfield',
399   - name: 'index_min_'+relatedDim,
400   - fieldLabel: 'Min.',
401   - allowDecimals: false,
402   - value: 0,
403   - minValue: 0,
404   - hidden: true,
405   - listeners: {
406   - change: function(field, newValue, oldValue, eOpts) {
407   - this.paramRequestObject.set(relatedDim+'-min-index', newValue);
408   - if (!this.inRebuild && (this.onChange != null))
409   - this.onChange(uiScope, relatedDim, newValue, oldValue, false);
410   - },
411   - scope: this
412   - }
413   - },
414   - {
415   - xtype: 'numberfield',
416   - name: 'index_max_'+relatedDim,
417   - fieldLabel: 'Max.',
418   - allowDecimals: false,
419   - value: 0,
420   - minValue: 0,
421   - hidden: true,
422   - listeners: {
423   - change: function(field, newValue, oldValue, eOpts) {
424   - this.paramRequestObject.set(relatedDim+'-max-index', newValue);
425   - if (!this.inRebuild && (this.onChange != null))
426   - this.onChange(uiScope, relatedDim, newValue, oldValue, false);
427   - },
428   - scope: this
429   - }
430   - }
  369 + {
  370 + xtype: 'numberfield',
  371 + name: 'value_min_' + relatedDim,
  372 + fieldLabel: 'Min.',
  373 + decimalPrecision: 3,
  374 + value: 0.,
  375 + listeners: {
  376 + change: function (field, newValue, oldValue, eOpts) {
  377 + this.paramRequestObject.set(relatedDim + '-min-value', newValue);
  378 + if (!this.inRebuild && (this.onChange != null))
  379 + this.onChange(uiScope, relatedDim, newValue, oldValue, false);
  380 + },
  381 + scope: this
  382 + }
  383 + },
  384 + {
  385 + xtype: 'numberfield',
  386 + name: 'value_max_' + relatedDim,
  387 + fieldLabel: 'Max.',
  388 + decimalPrecision: 3,
  389 + value: 0.,
  390 + listeners: {
  391 + change: function (field, newValue, oldValue, eOpts) {
  392 + this.paramRequestObject.set(relatedDim + '-max-value', newValue);
  393 + if (!this.inRebuild && (this.onChange != null))
  394 + this.onChange(uiScope, relatedDim, newValue, oldValue, false);
  395 + },
  396 + scope: this
  397 + }
  398 + },
  399 + {
  400 + xtype: 'numberfield',
  401 + name: 'index_min_' + relatedDim,
  402 + fieldLabel: 'Min.',
  403 + allowDecimals: false,
  404 + value: 0,
  405 + minValue: 0,
  406 + hidden: true,
  407 + listeners: {
  408 + change: function (field, newValue, oldValue, eOpts) {
  409 + this.paramRequestObject.set(relatedDim + '-min-index', newValue);
  410 + if (!this.inRebuild && (this.onChange != null))
  411 + this.onChange(uiScope, relatedDim, newValue, oldValue, false);
  412 + },
  413 + scope: this
  414 + }
  415 + },
  416 + {
  417 + xtype: 'numberfield',
  418 + name: 'index_max_' + relatedDim,
  419 + fieldLabel: 'Max.',
  420 + allowDecimals: false,
  421 + value: 0,
  422 + minValue: 0,
  423 + hidden: true,
  424 + listeners: {
  425 + change: function (field, newValue, oldValue, eOpts) {
  426 + this.paramRequestObject.set(relatedDim + '-max-index', newValue);
  427 + if (!this.inRebuild && (this.onChange != null))
  428 + this.onChange(uiScope, relatedDim, newValue, oldValue, false);
  429 + },
  430 + scope: this
  431 + }
  432 + }
431 433 ];
432   -
  434 +
433 435 var sumRangeFieldSet = Ext.create('Ext.form.FieldSet', {
434 436 title: relatedTable.variable ? title + " - Sum. in range" : "Sum. in range",
435 437 collapsed: true,
436   - checkboxName: 'sum_checkbox_'+relatedDim,
  438 + checkboxName: 'sum_checkbox_' + relatedDim,
437 439 checkboxToggle: true,
438   - name: 'sum_fieldset_'+relatedDim,
  440 + name: 'sum_fieldset_' + relatedDim,
439 441 layout: {
440   - type: 'vbox',
441   - pack: 'start',
442   - align: 'stretch'
  442 + type: 'vbox',
  443 + pack: 'start',
  444 + align: 'stretch'
443 445 },
444 446 items: sumItems,
445 447 listeners: {
446   - expand: function(fieldset, eOpts) {
447   - if (this.paramRequestObject.get(relatedDim+'-sum-type') == 0) {
448   - this.paramRequestObject.set(relatedDim+'-sum-type',1);
449   - }
450   - fieldset.down('[name=sum_type_'+relatedDim+']').setValue(this.paramRequestObject.get(relatedDim+'-sum-type'));
451   - indexesCombo.setDisabled(true);
452   - if (!this.inRebuild && (this.onChange != null))
453   - this.onChange(uiScope, relatedDim, true, false, false);
454   - if (this.onModifyHeight)
455   - this.onModifyHeight(this.pluginOwner);
  448 + expand: function (fieldset, eOpts) {
  449 + if (this.paramRequestObject.get(relatedDim + '-sum-type') == 0) {
  450 + this.paramRequestObject.set(relatedDim + '-sum-type', 1);
  451 + }
  452 + fieldset.down('[name=sum_type_' + relatedDim + ']').setValue(this.paramRequestObject.get(relatedDim + '-sum-type'));
  453 + indexesCombo.setDisabled(true);
  454 + if (!this.inRebuild && (this.onChange != null))
  455 + this.onChange(uiScope, relatedDim, true, false, false);
  456 + if (this.onModifyHeight)
  457 + this.onModifyHeight(this.pluginOwner);
456 458 },
457   - collapse: function(fieldset, eOpts) {
458   - indexesCombo.setDisabled(false);
459   - this.paramRequestObject.set(relatedDim+'-sum-type', 0);
460   - if (!this.inRebuild && (this.onChange != null))
461   - this.onChange(uiScope, relatedDim, false, true, false);
462   - if (this.onModifyHeight)
463   - this.onModifyHeight(this.pluginOwner);
  459 + collapse: function (fieldset, eOpts) {
  460 + indexesCombo.setDisabled(false);
  461 + this.paramRequestObject.set(relatedDim + '-sum-type', 0);
  462 + if (!this.inRebuild && (this.onChange != null))
  463 + this.onChange(uiScope, relatedDim, false, true, false);
  464 + if (this.onModifyHeight)
  465 + this.onModifyHeight(this.pluginOwner);
464 466 },
465 467 scope: this
466 468 }
467 469 });
468 470 this.add(sumRangeFieldSet);
469   - this.add(ruler);
  471 + this.add(ruler);
470 472 }
471 473 return indexesCombo;
472 474 },
473   -
474   - buildTemplateArguments: function(arguments, uiScope) {
475   - var me = this;
476   - Ext.Object.each(arguments, function (key, argument) {
477   - switch (argument.type) {
478   - case 'float' :
479   - var argumentField = Ext.create('Ext.form.NumberField', {
480   - argId: 'template_' + key,
481   - fieldLabel: argument.name,
482   - decimalPrecision : 3,
483   - allowBlank : false,
484   - value: parseFloat(argument.default),
485   - listeners: {
486   - change: function(field, newValue, oldValue, eOpts) {
487   - var template_args = me.paramRequestObject.get('template_args');
488   - if (!template_args)
489   - template_args = {};
490   - template_args[key] = newValue;
491   - me.paramRequestObject.set('template_args', template_args);
492   - if (!this.inRebuild && (me.onChange != null))
493   - me.onChange(uiScope, key, newValue, oldValue, true);
494   - },
495   - scope: me
496   - }
497   - });
498   -
499   - me.add(argumentField);
500   - break;
501   - case 'list' :
502   - var items = [];
503   - Ext.Object.each(argument.items, function (itemKey, itemName) {
504   - items.push({'key' : itemKey, 'value' : itemName});
505   - });
506   -
507   - var itemsStore = Ext.create('Ext.data.Store', {
508   - fields: ['key', 'value'],
509   - data : items
510   - });
511   -
512   - var itemsCombo = Ext.create('Ext.form.ComboBox', {
513   - fieldLabel: argument.name,
514   - store: itemsStore,
515   - queryMode: 'local',
516   - displayField: 'value',
517   - valueField: 'key',
518   - value: argument.default,
519   - editable: false,
520   - argId: 'template_' + key,
521   - listeners: {
522   - change: function(field, newValue, oldValue, eOpts) {
523   - var template_args = me.paramRequestObject.get('template_args');
524   - if (!template_args)
525   - template_args = {};
526   - template_args[key] = newValue;
527   - me.paramRequestObject.set('template_args', template_args);
528   - if (!this.inRebuild && (me.onChange != null))
529   - me.onChange(uiScope, key, newValue, oldValue, true);
530   - },
531   - scope: me
532   - }
533   -
534   - });
535   -
536   - me.add(itemsCombo);
537   - break;
538   - case 'bool' :
539   - var argumentField = Ext.create('Ext.form.Checkbox', {
540   - argId: 'template_' + key,
541   - fieldLabel: argument.name,
542   - value: (parseInt(argument.default) == 1),
543   - listeners: {
544   - change: function(field, newValue, oldValue, eOpts) {
545   - var template_args = me.paramRequestObject.get('template_args');
546   - if (!template_args)
547   - template_args = {};
548   - template_args[key] = newValue;
549   - me.paramRequestObject.set('template_args', template_args);
550   - if (!this.inRebuild && (me.onChange != null))
551   - me.onChange(uiScope, key, newValue, oldValue, true);
552   - },
553   - scope: me
554   - }
555   - });
556   -
557   - me.add(argumentField);
558   - break;
559   - default:
560   - console.log('Template argument type not yet implemented: '+argument.type);
561   - }
562   - });
563   - }
  475 +
  476 + buildTemplateArguments: function (arguments, uiScope) {
  477 + var me = this;
  478 + Ext.Object.each(arguments, function (key, argument) {
  479 + switch (argument.type) {
  480 + case 'float':
  481 + var argumentField = Ext.create('Ext.form.NumberField', {
  482 + argId: 'template_' + key,
  483 + fieldLabel: argument.name,
  484 + decimalPrecision: 3,
  485 + allowBlank: false,
  486 + value: parseFloat(argument.default),
  487 + listeners: {
  488 + change: function (field, newValue, oldValue, eOpts) {
  489 + var template_args = me.paramRequestObject.get('template_args');
  490 + if (!template_args)
  491 + template_args = {};
  492 + template_args[key] = newValue;
  493 + me.paramRequestObject.set('template_args', template_args);
  494 + if (!this.inRebuild && (me.onChange != null))
  495 + me.onChange(uiScope, key, newValue, oldValue, true);
  496 + },
  497 + scope: me
  498 + }
  499 + });
  500 +
  501 + me.add(argumentField);
  502 + break;
  503 + case 'list':
  504 + var items = [];
  505 + Ext.Object.each(argument.items, function (itemKey, itemName) {
  506 + items.push({ 'key': itemKey, 'value': itemName });
  507 + });
  508 +
  509 + var itemsStore = Ext.create('Ext.data.Store', {
  510 + fields: ['key', 'value'],
  511 + data: items
  512 + });
  513 +
  514 + var itemsCombo = Ext.create('Ext.form.ComboBox', {
  515 + fieldLabel: argument.name,
  516 + store: itemsStore,
  517 + queryMode: 'local',
  518 + displayField: 'value',
  519 + valueField: 'key',
  520 + value: argument.default,
  521 + editable: false,
  522 + argId: 'template_' + key,
  523 + listeners: {
  524 + change: function (field, newValue, oldValue, eOpts) {
  525 + var template_args = me.paramRequestObject.get('template_args');
  526 + if (!template_args)
  527 + template_args = {};
  528 + template_args[key] = newValue;
  529 + me.paramRequestObject.set('template_args', template_args);
  530 + if (!this.inRebuild && (me.onChange != null))
  531 + me.onChange(uiScope, key, newValue, oldValue, true);
  532 + },
  533 + scope: me
  534 + }
  535 +
  536 + });
  537 +
  538 + me.add(itemsCombo);
  539 + break;
  540 + case 'bool':
  541 + var argumentField = Ext.create('Ext.form.Checkbox', {
  542 + argId: 'template_' + key,
  543 + fieldLabel: argument.name,
  544 + value: (parseInt(argument.default) == 1),
  545 + listeners: {
  546 + change: function (field, newValue, oldValue, eOpts) {
  547 + var template_args = me.paramRequestObject.get('template_args');
  548 + if (!template_args)
  549 + template_args = {};
  550 + template_args[key] = newValue;
  551 + me.paramRequestObject.set('template_args', template_args);
  552 + if (!this.inRebuild && (me.onChange != null))
  553 + me.onChange(uiScope, key, newValue, oldValue, true);
  554 + },
  555 + scope: me
  556 + }
  557 + });
  558 +
  559 + me.add(argumentField);
  560 + break;
  561 + default:
  562 + console.log('Template argument type not yet implemented: ' + argument.type);
  563 + }
  564 + });
  565 + }
564 566 });
... ...
js/app/views/PlotComponents/PlotParamForm.js
  Diff comments   View file @9e70b8e
... ... @@ -10,98 +10,96 @@
10 10  
11 11 Ext.define('amdaPlotComp.PlotParamForm', {
12 12 extend: 'amdaPlotComp.PlotStandardForm',
13   -
  13 +
14 14 requires: [
15   - 'amdaPlotComp.PlotSerieForm',
16   - 'amdaPlotComp.PlotOrbitSerieForm',
17   - 'amdaPlotComp.PlotSpectroForm',
18   - 'amdaPlotComp.PlotStatusBarForm',
19   - 'amdaPlotComp.PlotTickBarForm',
20   - 'amdaPlotComp.PlotInstantSerieForm',
21   - 'amdaPlotComp.PlotInstantSpectroForm',
22   - 'amdaPlotComp.PlotIntervalsForm',
23   - 'amdaUI.ParamArgumentsUI'
  15 + 'amdaPlotComp.PlotSerieForm',
  16 + 'amdaPlotComp.PlotOrbitSerieForm',
  17 + 'amdaPlotComp.PlotSpectroForm',
  18 + 'amdaPlotComp.PlotStatusBarForm',
  19 + 'amdaPlotComp.PlotTickBarForm',
  20 + 'amdaPlotComp.PlotInstantSerieForm',
  21 + 'amdaPlotComp.PlotInstantSpectroForm',
  22 + 'amdaPlotComp.PlotIntervalsForm',
  23 + 'amdaUI.ParamArgumentsUI'
24 24 ],
25   -
  25 +
26 26 drawingOptionsContainer: null,
27   -
28   - drawingOptionsFormsManager : new Ext.AbstractManager(),
29   -
30   - paramArgs : null,
31   -
32   - isFirstMsg: true,
33   -
34   - destroy: function() {
  27 +
  28 + drawingOptionsFormsManager: new Ext.AbstractManager(),
  29 +
  30 + paramArgs: null,
  31 +
  32 + isFirstMsg: true,
  33 +
  34 + destroy: function () {
35 35 this.drawingOptionsFormsManager.each(function (key, value, length) {
36   - this.drawingOptionsFormsManager.unregister(value);
  36 + this.drawingOptionsFormsManager.unregister(value);
37 37 value.destroy();
38   - }, this);
  38 + }, this);
39 39 this.callParent();
40 40 },
41   -
42   - setObject : function(object) {
  41 +
  42 + setObject: function (object) {
43 43 this.object = object;
44 44 this.loadRecord(this.object);
45 45 this.updateDrawingOptions(this.object.get('param-drawing-type'), this.object.get('paramid'));
46 46 },
47   -
48   - getDrawingOptionsForm: function(type) {
  47 +
  48 + getDrawingOptionsForm: function (type) {
49 49 var formId = '';
50 50 if (!type || (type == ''))
51 51 formId = 'none';
52 52 else
53 53 formId = type;
54   -
  54 +
55 55 formId += '-drawing-options-form';
56   - if (!this.drawingOptionsFormsManager.get(formId))
57   - {
58   - switch(type)
59   - {
  56 + if (!this.drawingOptionsFormsManager.get(formId)) {
  57 + switch (type) {
60 58 //Create drawing options form
61   - case 'serie' :
62   - this.drawingOptionsFormsManager.register(new amdaPlotComp.PlotSerieForm({id : formId}));
  59 + case 'serie':
  60 + this.drawingOptionsFormsManager.register(new amdaPlotComp.PlotSerieForm({ id: formId }));
63 61 break;
64   - case 'orbit-serie' :
65   - this.drawingOptionsFormsManager.register(new amdaPlotComp.PlotOrbitSerieForm({id : formId}));
  62 + case 'orbit-serie':
  63 + this.drawingOptionsFormsManager.register(new amdaPlotComp.PlotOrbitSerieForm({ id: formId }));
66 64 break;
67   - case 'spectro' :
68   - this.drawingOptionsFormsManager.register(new amdaPlotComp.PlotSpectroForm({id : formId}));
  65 + case 'spectro':
  66 + this.drawingOptionsFormsManager.register(new amdaPlotComp.PlotSpectroForm({ id: formId }));
69 67 break;
70   - case 'status-bar' :
71   - this.drawingOptionsFormsManager.register(new amdaPlotComp.PlotStatusBarForm({id : formId}));
  68 + case 'status-bar':
  69 + this.drawingOptionsFormsManager.register(new amdaPlotComp.PlotStatusBarForm({ id: formId }));
72 70 break;
73   - case 'tick-bar' :
74   - this.drawingOptionsFormsManager.register(new amdaPlotComp.PlotTickBarForm({id : formId}));
  71 + case 'tick-bar':
  72 + this.drawingOptionsFormsManager.register(new amdaPlotComp.PlotTickBarForm({ id: formId }));
75 73 break;
76   - case 'iserie' :
77   - this.drawingOptionsFormsManager.register(new amdaPlotComp.PlotInstantSerieForm({id : formId}));
  74 + case 'iserie':
  75 + this.drawingOptionsFormsManager.register(new amdaPlotComp.PlotInstantSerieForm({ id: formId }));
78 76 break;
79   - case 'ispectro' :
80   - this.drawingOptionsFormsManager.register(new amdaPlotComp.PlotInstantSpectroForm({id : formId}));
  77 + case 'ispectro':
  78 + this.drawingOptionsFormsManager.register(new amdaPlotComp.PlotInstantSpectroForm({ id: formId }));
81 79 break;
82   - case 'intervals' :
83   - this.drawingOptionsFormsManager.register(new amdaPlotComp.PlotIntervalsForm({id : formId}));
  80 + case 'intervals':
  81 + this.drawingOptionsFormsManager.register(new amdaPlotComp.PlotIntervalsForm({ id: formId }));
84 82 break;
85   - default :
86   - this.drawingOptionsFormsManager.register(new Ext.form.Label({id : formId, text: 'No available options for this drawing type'}));
  83 + default:
  84 + this.drawingOptionsFormsManager.register(new Ext.form.Label({ id: formId, text: 'No available options for this drawing type' }));
87 85 }
88 86 }
89   -
  87 +
90 88 return this.drawingOptionsFormsManager.get(formId);
91   -
  89 +
92 90 },
93   -
94   - updateDrawingOptions: function(drawingType, paramId) {
  91 +
  92 + updateDrawingOptions: function (drawingType, paramId) {
95 93 var typeField = this.getForm().findField('param-drawing-type');
96   -
  94 +
97 95 var availableDrawingObjects = this.object.getAvailableDrawingObjectByPlotType(this.crtTree.getSelectedPlotType());
98 96 typeField.getStore().loadData(availableDrawingObjects);
99 97 typeField.suspendEvents();
100 98 typeField.setValue(drawingType);
101 99 typeField.resumeEvents(false);
102   -
  100 +
103 101 this.drawingOptionsContainer.removeAll(false);
104   -
  102 +
105 103 var drawingOptionsForm = this.getDrawingOptionsForm(drawingType);
106 104 this.drawingOptionsContainer.add(drawingOptionsForm);
107 105 drawingOptionsForm.crtTree = this.crtTree;
... ... @@ -112,8 +110,8 @@ Ext.define(&#39;amdaPlotComp.PlotParamForm&#39;, {
112 110 uiScope.crtTree.refresh();
113 111 });
114 112 },
115   -
116   - onChangeParamArgs: function(uiScope, args_key, newValue, oldValue, isTemplateArg) {
  113 +
  114 + onChangeParamArgs: function (uiScope, args_key, newValue, oldValue, isTemplateArg) {
117 115 if ((uiScope.isFirstMsg) && (uiScope.object.get('type') == 2) && (uiScope.object.get('dim1-sum-type') == 0) && (uiScope.object.get('dim2-sum-type') == 0) &&
118 116 (uiScope.object.get('dim1-index') == '*') && (uiScope.object.get('dim2-index') == '*')) {
119 117 uiScope.isFirstMsg = false;
... ... @@ -121,35 +119,34 @@ Ext.define(&#39;amdaPlotComp.PlotParamForm&#39;, {
121 119 }
122 120 uiScope.crtTree.refresh();
123 121 },
124   -
125   - getFormItems: function() {
  122 +
  123 + getFormItems: function () {
126 124 var me = this;
127   -
  125 +
128 126 this.drawingOptionsContainer = Ext.create('Ext.container.Container', {
129 127 layout: 'fit'
130 128 });
131   -
  129 +
132 130 this.paramArgs = Ext.create('amdaUI.ParamArgumentsUI', {
133   - onChange : me.onChangeParamArgs,
  131 + onChange: me.onChangeParamArgs,
134 132 scope: me
135 133 });
136   -
  134 +
137 135 //ToDoparamArgsPlug
138 136 var paramInfoFieldSet = this.addStandardFieldSet('Arguments', '', [this.paramArgs]);
139 137 paramInfoFieldSet.collapsed = false;
140   -
  138 +
141 139 return [
142   - paramInfoFieldSet,
143   - this.addStandardCombo('param-drawing-type', 'Drawing type', [{'key' : '', 'value' : 'None'}], function(name, value, oldValue) {
144   - if (me.object.get('param-drawing-type') != value)
145   - {
146   - me.object.changeDrawingType(value);
147   - me.object.set('param-drawing-type', value);
148   - me.crtTree.refresh();
149   - me.updateDrawingOptions(value);
150   - }
151   - }),
152   - this.drawingOptionsContainer
  140 + paramInfoFieldSet,
  141 + this.addStandardCombo('param-drawing-type', 'Drawing type', [{ 'key': '', 'value': 'None' }], function (name, value, oldValue) {
  142 + if (me.object.get('param-drawing-type') != value) {
  143 + me.object.changeDrawingType(value);
  144 + me.object.set('param-drawing-type', value);
  145 + me.crtTree.refresh();
  146 + me.updateDrawingOptions(value);
  147 + }
  148 + }),
  149 + this.drawingOptionsContainer
153 150 ];
154 151 }
155 152 });
... ...
js/app/views/PlotComponents/PlotSpectroForm.js
  Diff comments   View file @9e70b8e
... ... @@ -10,46 +10,282 @@
10 10  
11 11 Ext.define('amdaPlotComp.PlotSpectroForm', {
12 12 extend: 'amdaPlotComp.PlotStandardForm',
13   -
14   - setObject : function(object) {
  13 +
  14 + requires: [
  15 + 'amdaUI.ParamArgumentsUI'
  16 + ],
  17 + setObject: function (object) {
  18 + this.data = object.data;
15 19 this.object = object.get('param-drawing-object');
  20 +
16 21 this.loadRecord(this.object);
17 22 },
18   -
19   - getValuesRangeItems: function() {
  23 +
  24 + getValuesRangeItems: function () {
  25 + return [
  26 + this.addStandardFloat2('spectro-value-min', 'Min value', -Number.MAX_VALUE, Number.MAX_VALUE, true),
  27 + this.addStandardFloat2('spectro-value-max', 'Max value', -Number.MAX_VALUE, Number.MAX_VALUE, true)
  28 + ];
  29 + },
  30 + getFilteringItems: function () {
  31 + return [
  32 + this.addStandardCombo('filtering-level', 'Level', amdaPlotObj.PlotObjectConfig.availableFilteringLevel)
  33 + ];
  34 + },
  35 +
  36 + /**
  37 + * Populate the comboBoxValue by the set of channel data related to the selected dimension
  38 + * @param {*} ref the reference of the current instance of this class
  39 + * @param {*} index dimension's index
  40 + * @param {*} comboBoxV the comboBoxValue
  41 + * @returns
  42 + */
  43 + populateComboBoxValue: (ref, index, comboBoxV) => {
  44 + if (ref.data[amdaPlotObj.PlotObjectConfig.bgSubstraction.tableName][index].variable)
  45 + return;
  46 +
  47 + const channelsData = ref.data[amdaPlotObj.PlotObjectConfig.bgSubstraction.tableName][index]
  48 + [amdaPlotObj.PlotObjectConfig.bgSubstraction.tableChannels];
  49 +
  50 + const keyTemp = amdaPlotObj.PlotObjectConfig.fieldComboBox.key;
  51 + const valueTemp = amdaPlotObj.PlotObjectConfig.fieldComboBox.value;
  52 +
  53 + const newDataForStore = [];
  54 + //Loop through the channels
  55 + for (channelIndex in channelsData) {
  56 + const channelData = channelsData[channelIndex];
  57 + let item = {};
  58 + item[keyTemp] = channelIndex;
  59 + item[valueTemp] = channelIndex + " : [" + channelData.min + " , " + channelData.max + "]";
  60 + newDataForStore.push(item);
  61 + }
  62 +
  63 + //Update the label of the field
  64 + comboBoxV.setFieldLabel(ref.data[amdaPlotObj.PlotObjectConfig.bgSubstraction.tableName][index]["name"]
  65 + + " (" + ref.data[amdaPlotObj.PlotObjectConfig.bgSubstraction.tableName][index]["units"] + ") ");
  66 +
  67 + comboBoxV.store.loadData(newDataForStore);
  68 + },
  69 +
  70 + /**
  71 + * Populate the comboBoxDim by the set of dimensions related to the selected parameter
  72 + * @param {*} ref the reference of the current instance of this class
  73 + * @param {*} comboBoxDim the comboBoxDim reference
  74 + */
  75 + populateComboBoxDim: (ref, comboBoxDim) => {
  76 + const keyTemp = amdaPlotObj.PlotObjectConfig.fieldComboBox.key;
  77 + const valueTemp = amdaPlotObj.PlotObjectConfig.fieldComboBox.value;
  78 +
  79 + const newDataForStore = [];
  80 + for (indexTable in ref.data[amdaPlotObj.PlotObjectConfig.bgSubstraction.tableName]) {
  81 + const table = ref.data[amdaPlotObj.PlotObjectConfig.bgSubstraction.tableName][indexTable];
  82 + let item = {};
  83 + item[keyTemp] = indexTable;
  84 + item[valueTemp] = table[amdaPlotObj.PlotObjectConfig.bgSubstraction.tableRelatedDim];
  85 + newDataForStore.push(item);
  86 + }
  87 +
  88 + //Set the new store
  89 + comboBoxDim.store.loadData(newDataForStore);
  90 + },
  91 +
  92 + /**
  93 + * Add a textInput which holds Background Substraction value when fixedvalue is selected
  94 + * @param {*} ref the reference of the current instance of this class
  95 + * @returns addStandardFloat2
  96 + */
  97 + addComboBoxBackgroundSubFixedValue: (ref) => {
  98 + return ref.addStandardFloat2(amdaPlotObj.PlotObjectConfig.bgSubstraction.value.textinputkey,
  99 + amdaPlotObj.PlotObjectConfig.bgSubstraction.value.textinputlabel, 0
  100 + , Number.MAX_VALUE, true, true, (name, newValue, oldValue) => {
  101 + if (oldValue !== newValue) {
  102 + if (!newValue) {
  103 + ref.object.set(amdaPlotObj.PlotObjectConfig.bgSubstraction.value.key,
  104 + amdaPlotObj.PlotObjectConfig.bgSubstraction.value.dimNullValue);
  105 + return;
  106 + }
  107 + ref.object.set(amdaPlotObj.PlotObjectConfig.bgSubstraction.value.key,
  108 + newValue);
  109 + }
  110 + });
  111 + },
  112 +
  113 + /**
  114 + * Reset ComboBoxDim and textInput
  115 + *
  116 + * @param {*} ref the reference of the current instance of this class
  117 + */
  118 + resetDependentComponents: (ref) => {
  119 + const comboBoxDim = ref.getForm().findField(amdaPlotObj.PlotObjectConfig.bgSubstraction.value.dimkey);
  120 + ref.populateComboBoxDim(ref, comboBoxDim);
  121 + comboBoxDim.setVisible(false);
  122 + comboBoxDim.setValue(amdaPlotObj.PlotObjectConfig.bgSubstraction.value.dimNullValue);
  123 +
  124 + const textInputV = ref.getForm().findField(amdaPlotObj.PlotObjectConfig.bgSubstraction.value.textinputkey);
  125 + textInputV.setVisible(false);
  126 + textInputV.setValue(null);
  127 + },
  128 +
  129 + /**
  130 + * Add a comboBox which holds Background Substraction type : bychannel, fixedvalue
  131 + * @param {*} ref the reference of the current instance of this class
  132 + * @returns StandardCombo
  133 + */
  134 + addComboBoxBackgroundSubType: (ref) => {
  135 + const data = [];
  136 + for (value in amdaPlotObj.PlotObjectConfig.bgSubstraction.type.values) {
  137 + const keyTemp = amdaPlotObj.PlotObjectConfig.fieldComboBox.key;
  138 + const valueTemp = amdaPlotObj.PlotObjectConfig.fieldComboBox.value;
  139 + let item = {};
  140 + item[keyTemp] = value;
  141 + item[valueTemp] = amdaPlotObj.PlotObjectConfig.bgSubstraction.type.values[value];
  142 + data.push(item);
  143 + }
  144 +
  145 + const comboBoxType = ref.addStandardCombo(amdaPlotObj.PlotObjectConfig.bgSubstraction.type.key,
  146 + amdaPlotObj.PlotObjectConfig.bgSubstraction.type.label, data,
  147 + (name, newKey, oldKey) => {
  148 + if (newKey !== oldKey) {
  149 + const newValue = amdaPlotObj.PlotObjectConfig.bgSubstraction.type.values[newKey];
  150 + if (newKey === null || newValue === undefined) {
  151 + ref.resetDependentComponents(ref);
  152 + return;
  153 + }
  154 +
  155 + //ComboBoxDim
  156 + const comboBoxDim = ref.getForm().findField(amdaPlotObj.PlotObjectConfig.bgSubstraction.value.dimkey);
  157 + //Fixed value input
  158 + const textInputV = ref.getForm().findField(amdaPlotObj.PlotObjectConfig.bgSubstraction.value.textinputkey);
  159 +
  160 + //By channel
  161 + if (newValue === amdaPlotObj.PlotObjectConfig.bgSubstraction.type.values.bychannel) {
  162 + const nbDims = ref.data[amdaPlotObj.PlotObjectConfig.bgSubstraction.tableName].length;
  163 + //Show comboBoxDim
  164 + comboBoxDim.select(comboBoxDim.store.getAt(0));
  165 + if (nbDims > 1)
  166 + comboBoxDim.setVisible(true);
  167 +
  168 + //Hide comboBoxDim
  169 + else
  170 + comboBoxDim.setVisible(false);
  171 +
  172 + //Hide text input
  173 + textInputV.setValue(null);
  174 + textInputV.setVisible(false);
  175 + }
  176 + //By fixed value
  177 + else if (newValue === amdaPlotObj.PlotObjectConfig.bgSubstraction.type.values.fixedvalue) {
  178 + //Hide comboBoxDim
  179 + comboBoxDim.setVisible(false);
  180 + comboBoxDim.setValue(amdaPlotObj.PlotObjectConfig.bgSubstraction.value.dimNullValue);
  181 + //Show text input
  182 + textInputV.setValue(null);
  183 + textInputV.setVisible(true);
  184 + }
  185 + //Another value
  186 + else {
  187 + console.warn("Unkown key : ", newKey);
  188 + }
  189 + }
  190 + });
  191 +
  192 + return comboBoxType;
  193 + },
  194 +
  195 + /**
  196 + * Add a comboBox which holds Background Substraction value
  197 + * @param {*} ref the reference of the current instance of this class
  198 + * @returns StandardCombo
  199 + */
  200 + addComboBoxBackgroundSubValue: (ref) => {
  201 + const comboBoxValue = ref.addStandardCombo(amdaPlotObj.PlotObjectConfig.bgSubstraction.value.key,
  202 + "", [],
  203 + (name, newKey, oldKey) => {
  204 + if (newKey !== oldKey) {
  205 + ref.object.set(amdaPlotObj.PlotObjectConfig.bgSubstraction.value.key,
  206 + newKey);
  207 + }
  208 + });
  209 +
  210 + return comboBoxValue;
  211 + },
  212 +
  213 + /**
  214 + * Add a comboBox which holds Background Substraction dimension
  215 + * @param {*} ref the reference of the current instance of this class
  216 + * @returns StandardCombo
  217 + */
  218 + addComboBoxBackgroundSubDim: (ref) => {
  219 + const comboBoxDim = ref.addStandardCombo(amdaPlotObj.PlotObjectConfig.bgSubstraction.value.dimkey,
  220 + amdaPlotObj.PlotObjectConfig.bgSubstraction.value.dimlabel, [],
  221 + (name, newKey, oldKey) => {
  222 + const comboBoxV = ref.getForm().findField(amdaPlotObj.PlotObjectConfig.bgSubstraction.value.key);
  223 +
  224 + if (newKey === amdaPlotObj.PlotObjectConfig.bgSubstraction.value.dimNullValue) {
  225 + comboBoxV.setValue(amdaPlotObj.PlotObjectConfig.bgSubstraction.value.dimNullValue);
  226 + comboBoxV.setVisible(false);
  227 + return;
  228 + }
  229 +
  230 + if (newKey !== null && newKey !== undefined) {
  231 + comboBoxV.setVisible(true);
  232 + ref.populateComboBoxValue(ref, newKey, comboBoxV);
  233 + comboBoxV.select(comboBoxV.store.getAt(0));
  234 + }
  235 +
  236 + ref.object.set(amdaPlotObj.PlotObjectConfig.bgSubstraction.value.dimkey,
  237 + newKey);
  238 +
  239 + });
  240 +
  241 + return comboBoxDim;
  242 + },
  243 +
  244 + /**
  245 + * Add Background Substraction items
  246 + * @returns StandardFieldSet
  247 + */
  248 + getBackgroundSubItems: function () {
20 249 return [
21   - this.addStandardFloat2('spectro-value-min', 'Min value', -Number.MAX_VALUE, Number.MAX_VALUE, true),
22   - this.addStandardFloat2('spectro-value-max', 'Max value', -Number.MAX_VALUE, Number.MAX_VALUE, true)
  250 + this.addComboBoxBackgroundSubType(this),
  251 + this.addComboBoxBackgroundSubDim(this),
  252 + this.addComboBoxBackgroundSubValue(this),
  253 + this.addComboBoxBackgroundSubFixedValue(this)
23 254 ];
24 255 },
25   - getFilteringItems: function(){
26   - return[
27   - this.addStandardCombo('filtering-level', 'Level', amdaPlotObj.PlotObjectConfig.availableFilteringLevel)
28   - ];
29   - },
30   -
31   - getFormItems: function() {
32   - var me = this;
  256 +
  257 + getFormItems: function () {
  258 + const ref = this;
  259 + const field = this.addStandardFieldSet(amdaPlotObj.PlotObjectConfig.bgSubstraction.name,
  260 + amdaPlotObj.PlotObjectConfig.bgSubstraction.name, this.getBackgroundSubItems(),
  261 + function (name, newKey, oldKey) {
  262 + const comboBoxType = ref.getForm().findField(amdaPlotObj.PlotObjectConfig.bgSubstraction.type.key);
  263 + comboBoxType.setValue(null);
  264 + if (newKey) {
  265 + comboBoxType.setValue(Object.keys(amdaPlotObj.PlotObjectConfig.bgSubstraction.type.values)[0]);
  266 + }
  267 + });
  268 +
33 269 return [
34   - this.addStandardCombo('spectro-resolution', 'Points per plot', amdaPlotObj.PlotObjectConfig.availableResolutions, function(name, value, oldValue) {
35   - me.object.set('spectro-resolution', value);
36   - }),
37   - this.addStandardCombo('spectro-yaxis', 'Y axis', amdaPlotObj.PlotObjectConfig.availableYAxes, function(name, value, oldValue) {
38   - me.object.set('spectro-yaxis', value);
39   - me.crtTree.refresh();
  270 + this.addStandardCombo('spectro-resolution', 'Points per plot', amdaPlotObj.PlotObjectConfig.availableResolutions, function (name, value, oldValue) {
  271 + ref.object.set('spectro-resolution', value);
  272 + }),
  273 + this.addStandardCombo('spectro-yaxis', 'Y axis', amdaPlotObj.PlotObjectConfig.availableYAxes, function (name, value, oldValue) {
  274 + ref.object.set('spectro-yaxis', value);
  275 + ref.crtTree.refresh();
40 276 }),
41   - myDesktopApp.addAmdaInfo('MinMaxThreshold','vertical-align:bottom'),
  277 + myDesktopApp.addAmdaInfo('MinMaxThreshold', 'vertical-align:bottom'),
42 278 this.addStandardFieldSet('Min/Max thresholds', '', this.getValuesRangeItems()),
43   - this.addStandardCheck('spectro-log0-as-min', 'Show 0 values as Min Values in log scale', function(name, value, oldValue) {
44   - me.object.set('spectro-log0-as-min', value);
  279 + this.addStandardCheck('spectro-log0-as-min', 'Show 0 values as Min Values in log scale', function (name, value, oldValue) {
  280 + ref.object.set('spectro-log0-as-min', value);
  281 + }),
  282 + this.addStandardCombo('spectro-normalization', 'Normalization', amdaPlotObj.PlotObjectConfig.availableSpectroNormalization, function (name, value, oldValue) {
  283 + if (ref.object.get('spectro-normalization') != value) {
  284 + ref.object.set('spectro-normalization', value);
  285 + }
45 286 }),
46   - this.addStandardCombo('spectro-normalization', 'Normalization', amdaPlotObj.PlotObjectConfig.availableSpectroNormalization, function(name, value, oldValue) {
47   - if (me.object.get('spectro-normalization') != value)
48   - {
49   - me.object.set('spectro-normalization', value);
50   - }
51   - }),
52   - this.addStandardFieldSet('Spike Filtering ( ! Experimental ! )', 'filtering-activated', this.getFilteringItems())
  287 + this.addStandardFieldSet('Spike Filtering ( ! Experimental ! )', 'filtering-activated', this.getFilteringItems()),
  288 + field
53 289 ];
54 290 }
55 291 });
... ...
js/app/views/PlotComponents/PlotStandardForm.js
  Diff comments   View file @9e70b8e
... ... @@ -10,112 +10,112 @@
10 10  
11 11 Ext.define('amdaPlotComp.PlotStandardForm', {
12 12 extend: 'Ext.form.Panel',
13   -
14   - requires : [
15   - 'amdaPlotObj.PlotObjectConfig',
16   - 'amdaPlotComp.EraseTrigger'
  13 +
  14 + requires: [
  15 + 'amdaPlotObj.PlotObjectConfig',
  16 + 'amdaPlotComp.EraseTrigger'
17 17 ],
18   -
19   - //Object associated to this form
20   - object: null,
21   -
22   - //Link to the tree
23   - crtTree: null,
24   - desableTickNumber:true,
25   - desableTickSpacing:true,
26   -
27   - constructor: function(config) {
  18 +
  19 + //Object associated to this form
  20 + object: null,
  21 +
  22 + //Link to the tree
  23 + crtTree: null,
  24 + desableTickNumber: true,
  25 + desableTickSpacing: true,
  26 +
  27 + constructor: function (config) {
28 28 this.init(config);
29 29 this.callParent(arguments);
30 30 },
31   -
32   - setObject : function(object) {
  31 +
  32 + setObject: function (object) {
33 33 this.object = object;
34 34 this.loadRecord(this.object);
35 35 },
36   -
  36 +
37 37 //To override to add form components
38   - getFormItems: function() {
  38 + getFormItems: function () {
39 39 return [];
40 40 },
41   -
  41 +
42 42 //Function called after element creation by PlotElementPanel
43   - updateElement: function(onAfterUpdate) {
44   - if (onAfterUpdate)
45   - onAfterUpdate();
46   - },
47   -
48   - //
49   - addStandardText: function(name, label, onChange) {
  43 + updateElement: function (onAfterUpdate) {
  44 + if (onAfterUpdate)
  45 + onAfterUpdate();
  46 + },
  47 +
  48 + //
  49 + addStandardText: function (name, label, onChange) {
50 50 return {
51   - xtype: 'textfield',
52   - name: name,
53   - fieldLabel: label,
54   - listeners: {
55   - change: function(field, newValue, oldValue, eOpts) {
56   - this.object.set(name, newValue);
57   - if (onChange != null)
58   - onChange(name, newValue, oldValue);
59   - },
60   - scope: this
61   - }
62   - };
  51 + xtype: 'textfield',
  52 + name: name,
  53 + fieldLabel: label,
  54 + listeners: {
  55 + change: function (field, newValue, oldValue, eOpts) {
  56 + this.object.set(name, newValue);
  57 + if (onChange != null)
  58 + onChange(name, newValue, oldValue);
  59 + },
  60 + scope: this
  61 + }
  62 + };
63 63 },
64   -
65   - addStandardFloat: function(name, label, min, max, allowBlank, onChange) {
  64 +
  65 + addStandardFloat: function (name, label, min, max, allowBlank, onChange) {
66 66 allowBlank = (typeof allowBlank !== 'undefined') ? allowBlank : false;
67   -
  67 +
68 68 return {
69   - xtype: 'numberfield',
70   - name: name,
71   - fieldLabel: label,
72   - decimalPrecision : 20,
73   - minValue : min,
74   - maxValue : max,
75   - allowBlank : allowBlank,
76   - listeners: {
77   - change: function(field, newValue, oldValue, eOpts) {
78   - this.object.set(name, newValue);
79   - if (onChange != null)
80   - onChange(name, newValue, oldValue);
81   - },
82   - scope: this
83   - }
84   - };
  69 + xtype: 'numberfield',
  70 + name: name,
  71 + fieldLabel: label,
  72 + decimalPrecision: 20,
  73 + minValue: min,
  74 + maxValue: max,
  75 + allowBlank: allowBlank,
  76 + listeners: {
  77 + change: function (field, newValue, oldValue, eOpts) {
  78 + this.object.set(name, newValue);
  79 + if (onChange != null)
  80 + onChange(name, newValue, oldValue);
  81 + },
  82 + scope: this
  83 + }
  84 + };
85 85 },
86   - addStandardInteger: function(name, label, min, max, allowBlank, hidden,onChange) {
  86 + addStandardInteger: function (name, label, min, max, allowBlank, hidden, onChange) {
87 87 allowBlank = (typeof allowBlank !== 'undefined') ? allowBlank : false;
88   -
  88 +
89 89 return {
90   - xtype: 'numberfield',
91   - name: name,
92   - fieldLabel: label,
93   - hidden : (hidden)? true:false,
94   - regex:/^\d+$/,
95   - decimalPrecision : 20,
96   - minValue : min,
97   - maxValue : max,
98   - allowBlank : allowBlank,
99   - listeners: {
100   - change: function(field, newValue, oldValue, eOpts) {
101   - this.object.set(name, newValue);
102   - if (onChange != null)
103   - onChange(name, newValue, oldValue);
104   - },
105   - scope: this
106   - }
107   - };
  90 + xtype: 'numberfield',
  91 + name: name,
  92 + fieldLabel: label,
  93 + hidden: (hidden) ? true : false,
  94 + regex: /^\d+$/,
  95 + decimalPrecision: 20,
  96 + minValue: min,
  97 + maxValue: max,
  98 + allowBlank: allowBlank,
  99 + listeners: {
  100 + change: function (field, newValue, oldValue, eOpts) {
  101 + this.object.set(name, newValue);
  102 + if (onChange != null)
  103 + onChange(name, newValue, oldValue);
  104 + },
  105 + scope: this
  106 + }
  107 + };
108 108 },
109 109  
110   - addStandardFloat2: function(name, label, min, max, allowBlank, hidden, onChange) {
  110 + addStandardFloat2: function (name, label, min, max, allowBlank, hidden, onChange) {
111 111 allowBlank = (typeof allowBlank !== 'undefined') ? allowBlank : false;
112 112  
113 113 return {
114 114 xtype: 'textfield',
115 115 name: name,
116 116 fieldLabel: label,
117   - regex : /[-+]?(?:\d*\.?\d+|\d+\.?\d*)(?:[eE][-+]?\d+)?/,
118   - hidden : (hidden)? true:false,
  117 + regex: /[-+]?(?:\d*\.?\d+|\d+\.?\d*)(?:[eE][-+]?\d+)?/,
  118 + hidden: (hidden) ? true : false,
119 119 validator: function (val) {
120 120 var errMsg = null;
121 121 if (!allowBlank && Ext.isEmpty(val)) {
... ... @@ -127,11 +127,11 @@ Ext.define(&#39;amdaPlotComp.PlotStandardForm&#39;, {
127 127 else if ((typeof max !== 'undefined') && (parseFloat(val) > max)) {
128 128 errMsg = 'Max. allowed value is ' + max;
129 129 }
130   -
  130 +
131 131 return errMsg ? errMsg : true;
132 132 },
133 133 listeners: {
134   - change: function(field, newValue, oldValue, eOpts) {
  134 + change: function (field, newValue, oldValue, eOpts) {
135 135 this.object.set(name, newValue);
136 136 if (onChange != null)
137 137 onChange(name, newValue, oldValue);
... ... @@ -140,51 +140,51 @@ Ext.define(&#39;amdaPlotComp.PlotStandardForm&#39;, {
140 140 }
141 141 };
142 142 },
143   -
144   - addStandardCombo: function(name, label, availableData, onChange) {
  143 +
  144 + addStandardCombo: function (name, label, availableData, onChange) {
145 145 var comboStore = Ext.create('Ext.data.Store', {
146   - fields: ['key', 'value'],
147   - data : availableData
  146 + fields: [amdaPlotObj.PlotObjectConfig.fieldComboBox.key, amdaPlotObj.PlotObjectConfig.fieldComboBox.value],
  147 + data: availableData
148 148 });
149   -
  149 +
150 150 return {
151   - xtype: 'combo',
152   - name: name,
153   - fieldLabel: label,
154   - store: comboStore,
155   - queryMode: 'local',
156   - displayField: 'value',
157   - valueField: 'key',
158   - editable: false,
159   - listeners: {
160   - change: function(combo, newValue, oldValue, eOpts) {
161   - if (onChange != null)
162   - onChange(name, newValue, oldValue);
163   - this.object.set(name, newValue);
164   - },
165   - scope: this
166   - }
167   - };
  151 + xtype: 'combo',
  152 + name: name,
  153 + fieldLabel: label,
  154 + store: comboStore,
  155 + queryMode: 'local',
  156 + displayField: 'value',
  157 + valueField: 'key',
  158 + editable: false,
  159 + listeners: {
  160 + change: function (combo, newValue, oldValue, eOpts) {
  161 + if (onChange != null)
  162 + onChange(name, newValue, oldValue);
  163 + this.object.set(name, newValue);
  164 + },
  165 + scope: this
  166 + }
  167 + };
168 168 },
169   -
170   - addStandardCheck: function(name, label, onChange, tooltip) {
  169 +
  170 + addStandardCheck: function (name, label, onChange, tooltip) {
171 171  
172 172 return {
173 173 xtype: 'checkbox',
174 174 name: name,
175 175 boxLabel: label,
176 176 listeners: {
177   - change: function(combo, newValue, oldValue, eOpts) {
  177 + change: function (combo, newValue, oldValue, eOpts) {
178 178 this.object.set(name, newValue);
179 179 if (onChange != null)
180 180 onChange(name, newValue, oldValue);
181 181 },
182   - render: function(c) {
  182 + render: function (c) {
183 183 if (tooltip) {
184 184 Ext.create('Ext.tip.ToolTip', {
185 185 target: c.getEl(),
186 186 dismissDelay: 0,
187   - html: tooltip
  187 + html: tooltip
188 188 });
189 189 }
190 190 },
... ... @@ -192,34 +192,32 @@ Ext.define(&#39;amdaPlotComp.PlotStandardForm&#39;, {
192 192 }
193 193 };
194 194 },
195   -
196   - addStandardFieldSet: function(title, checkboxName, items, onChangeCheck) {
  195 +
  196 + addStandardFieldSet: function (title, checkboxName, items, onChangeCheck) {
197 197 return {
198   - xtype: 'fieldset',
199   - cls : 'child-fieldset',
200   - title: title,
201   - collapsible: true,
202   - collapsed: true,
203   - checkboxName: checkboxName,
204   - checkboxToggle: checkboxName != '',
205   - layout: {
206   - type: 'vbox',
207   - pack: 'start',
208   - align: 'stretch'
  198 + xtype: 'fieldset',
  199 + cls: 'child-fieldset',
  200 + title: title,
  201 + collapsible: true,
  202 + collapsed: true,
  203 + checkboxName: checkboxName,
  204 + checkboxToggle: checkboxName != '',
  205 + layout: {
  206 + type: 'vbox',
  207 + pack: 'start',
  208 + align: 'stretch'
209 209 },
210 210 items: items,
211 211 listeners: {
212   - expand: function(fieldset, eOpts) {
213   - if (checkboxName != '')
214   - {
  212 + expand: function (fieldset, eOpts) {
  213 + if (checkboxName != '') {
215 214 this.object.set(checkboxName, true);
216 215 if (onChangeCheck != null)
217 216 onChangeCheck(checkboxName, true, false);
218 217 }
219 218 },
220   - collapse: function(fieldset, eOpts) {
221   - if (checkboxName != '')
222   - {
  219 + collapse: function (fieldset, eOpts) {
  220 + if (checkboxName != '') {
223 221 this.object.set(checkboxName, false);
224 222 if (onChangeCheck != null)
225 223 onChangeCheck(checkboxName, false, true);
... ... @@ -227,214 +225,213 @@ Ext.define(&#39;amdaPlotComp.PlotStandardForm&#39;, {
227 225 },
228 226 scope: this
229 227 }
230   - };
  228 + };
231 229 },
232   -
233   - addStandardFont: function(namePrefix) {
  230 +
  231 + addStandardFont: function (namePrefix) {
234 232 var fontItems = [
235   - this.addStandardCombo(namePrefix+'-name', 'Name', amdaPlotObj.PlotObjectConfig.availableFontNames),
236   - {
237   - xtype : 'toolbar',
238   - bodyStyle: { background : '#dfe8f6' },
  233 + this.addStandardCombo(namePrefix + '-name', 'Name', amdaPlotObj.PlotObjectConfig.availableFontNames),
  234 + {
  235 + xtype: 'toolbar',
  236 + bodyStyle: { background: '#dfe8f6' },
239 237 border: false,
240   - items : [
241   - {
242   - xtype: 'numberfield',
243   - name: namePrefix+'-size',
244   - fieldLabel: 'Size',
245   - labelWidth: 60,
246   - width: 150,
247   - maxValue: 32,
248   - minValue: 6,
249   - value: 12,
250   - listeners: {
251   - change: function(field, newValue, oldValue, eOpts) {
252   - this.object.set(namePrefix+'-size', newValue);
253   - },
254   - scope: this
255   - }
256   - },
257   - ' ',
258   - {
259   - xtype: 'checkbox',
260   - name: namePrefix+'-bold',
261   - boxLabel: '<b>B</b>',
262   - width: 30,
263   - listeners: {
264   - change: function(combo, newValue, oldValue, eOpts) {
265   - this.object.set(namePrefix+'-bold', newValue);
266   - },
267   - scope: this
268   - }
269   - },
270   - {
271   - xtype: 'checkbox',
272   - name: namePrefix+'-italic',
273   - boxLabel: '<i>I</i>',
274   - width: 30,
275   - listeners: {
276   - change: function(combo, newValue, oldValue, eOpts) {
277   - this.object.set(namePrefix+'-italic', newValue);
278   - },
279   - scope: this
280   - }
281   - }
282   - ]
283   - }
  238 + items: [
  239 + {
  240 + xtype: 'numberfield',
  241 + name: namePrefix + '-size',
  242 + fieldLabel: 'Size',
  243 + labelWidth: 60,
  244 + width: 150,
  245 + maxValue: 32,
  246 + minValue: 6,
  247 + value: 12,
  248 + listeners: {
  249 + change: function (field, newValue, oldValue, eOpts) {
  250 + this.object.set(namePrefix + '-size', newValue);
  251 + },
  252 + scope: this
  253 + }
  254 + },
  255 + ' ',
  256 + {
  257 + xtype: 'checkbox',
  258 + name: namePrefix + '-bold',
  259 + boxLabel: '<b>B</b>',
  260 + width: 30,
  261 + listeners: {
  262 + change: function (combo, newValue, oldValue, eOpts) {
  263 + this.object.set(namePrefix + '-bold', newValue);
  264 + },
  265 + scope: this
  266 + }
  267 + },
  268 + {
  269 + xtype: 'checkbox',
  270 + name: namePrefix + '-italic',
  271 + boxLabel: '<i>I</i>',
  272 + width: 30,
  273 + listeners: {
  274 + change: function (combo, newValue, oldValue, eOpts) {
  275 + this.object.set(namePrefix + '-italic', newValue);
  276 + },
  277 + scope: this
  278 + }
  279 + }
  280 + ]
  281 + }
284 282 ];
285   -
286   - return this.addStandardFieldSet('Font', namePrefix+'-activated', fontItems);
  283 +
  284 + return this.addStandardFieldSet('Font', namePrefix + '-activated', fontItems);
287 285 },
288   -
289   - addStandardColor: function(name, label, availableData, onChange) {
  286 +
  287 + addStandardColor: function (name, label, availableData, onChange) {
290 288 var comboStore = Ext.create('Ext.data.Store', {
291   - fields: ['color', 'value'],
292   - data : availableData
  289 + fields: ['color', 'value'],
  290 + data: availableData
293 291 });
294   -
  292 +
295 293 return {
296   - xtype: 'combo',
297   - name: name,
298   - fieldLabel: label,
299   - store: comboStore,
300   - queryMode: 'local',
301   - displayField: 'value',
302   - valueField: 'color',
303   - editable: false,
304   - tpl: Ext.create('Ext.XTemplate',
305   - '<ul class="x-list-plain"><tpl for=".">',
306   - '<li role="option" class="x-boundlist-item" style="color: {color};">{value}</li>',
307   - '</tpl></ul>'
308   - ),
309   - // template for the content inside text field
310   - displayTpl: Ext.create('Ext.XTemplate',
311   - '<tpl for=".">',
312   - '{value}',
313   - '</tpl>'
314   - ),
315   -
316   -
317   - listeners: {
318   - change: function(combo, newValue, oldValue, eOpts) {
319   - this.object.set(name, newValue);
320   - if (onChange != null)
321   - onChange(name, newValue, oldValue);
322   - },
323   - scope: this
324   - }
325   - };
  294 + xtype: 'combo',
  295 + name: name,
  296 + fieldLabel: label,
  297 + store: comboStore,
  298 + queryMode: 'local',
  299 + displayField: 'value',
  300 + valueField: 'color',
  301 + editable: false,
  302 + tpl: Ext.create('Ext.XTemplate',
  303 + '<ul class="x-list-plain"><tpl for=".">',
  304 + '<li role="option" class="x-boundlist-item" style="color: {color};">{value}</li>',
  305 + '</tpl></ul>'
  306 + ),
  307 + // template for the content inside text field
  308 + displayTpl: Ext.create('Ext.XTemplate',
  309 + '<tpl for=".">',
  310 + '{value}',
  311 + '</tpl>'
  312 + ),
  313 +
  314 +
  315 + listeners: {
  316 + change: function (combo, newValue, oldValue, eOpts) {
  317 + this.object.set(name, newValue);
  318 + if (onChange != null)
  319 + onChange(name, newValue, oldValue);
  320 + },
  321 + scope: this
  322 + }
  323 + };
326 324 },
327   -
328   - addStandardParamDropTarget: function(name, label, onChange) {
  325 +
  326 + addStandardParamDropTarget: function (name, label, onChange) {
329 327 return {
330   - xtype: 'erasetrigger',
331   - name: name,
332   - fieldLabel: label,
333   - emptyText: 'Drop a parameter',
334   - listeners: {
335   - change: function(field, newValue, oldValue, eOpts) {
336   - this.object.set(name, newValue);
337   - if (onChange != null)
338   - onChange(name, newValue, oldValue);
339   - },
340   - afterrender: function(field, eOpts ){
341   - var paramTarget = new Ext.dd.DropTarget(field.el.dom,
342   - {
343   - ddGroup: 'explorerTree',
344   - notifyEnter: function(ddSource, e, data) {
345   - },
346   - notifyDrop: function(ddSource, e, data) {
347   - var selectedRecord = ddSource.dragData.records[0];
348   - switch (selectedRecord.$className)
349   - {
350   - case 'amdaModel.LocalParamNode' :
351   - case 'amdaModel.RemoteParamNode' :
352   - case 'amdaModel.RemoteSimuParamNode' :
353   - if (!selectedRecord.get('isParameter') || selectedRecord.get('disable'))
354   - return false;
355   - if (selectedRecord.get('alias') != "" )
356   - field.setValue("#"+selectedRecord.get('alias'));
357   - else
358   - field.setValue(selectedRecord.get('id'));
359   - return true;
360   - case 'amdaModel.AliasNode' :
361   - if (!selectedRecord.isLeaf())
362   - return false;
363   - field.setValue("#"+selectedRecord.get('text'));
364   - return true;
365   - case 'amdaModel.DerivedParamNode' :
366   - if (!selectedRecord.isLeaf())
367   - return false;
368   - field.setValue("ws_"+selectedRecord.get('text'));
369   - return true;
370   - case 'amdaModel.MyDataParamNode' :
371   - if (!selectedRecord.isLeaf())
372   - return false;
373   - field.setValue("wsd_"+selectedRecord.get('text'));
374   - return true;
375   - default :
376   - return false;
377   - }
378   - return true;
379   - }
380   - }
381   - );
382   - },
383   - scope: this
384   - }
385   - };
  328 + xtype: 'erasetrigger',
  329 + name: name,
  330 + fieldLabel: label,
  331 + emptyText: 'Drop a parameter',
  332 + listeners: {
  333 + change: function (field, newValue, oldValue, eOpts) {
  334 + this.object.set(name, newValue);
  335 + if (onChange != null)
  336 + onChange(name, newValue, oldValue);
  337 + },
  338 + afterrender: function (field, eOpts) {
  339 + var paramTarget = new Ext.dd.DropTarget(field.el.dom,
  340 + {
  341 + ddGroup: 'explorerTree',
  342 + notifyEnter: function (ddSource, e, data) {
  343 + },
  344 + notifyDrop: function (ddSource, e, data) {
  345 + var selectedRecord = ddSource.dragData.records[0];
  346 + switch (selectedRecord.$className) {
  347 + case 'amdaModel.LocalParamNode':
  348 + case 'amdaModel.RemoteParamNode':
  349 + case 'amdaModel.RemoteSimuParamNode':
  350 + if (!selectedRecord.get('isParameter') || selectedRecord.get('disable'))
  351 + return false;
  352 + if (selectedRecord.get('alias') != "")
  353 + field.setValue("#" + selectedRecord.get('alias'));
  354 + else
  355 + field.setValue(selectedRecord.get('id'));
  356 + return true;
  357 + case 'amdaModel.AliasNode':
  358 + if (!selectedRecord.isLeaf())
  359 + return false;
  360 + field.setValue("#" + selectedRecord.get('text'));
  361 + return true;
  362 + case 'amdaModel.DerivedParamNode':
  363 + if (!selectedRecord.isLeaf())
  364 + return false;
  365 + field.setValue("ws_" + selectedRecord.get('text'));
  366 + return true;
  367 + case 'amdaModel.MyDataParamNode':
  368 + if (!selectedRecord.isLeaf())
  369 + return false;
  370 + field.setValue("wsd_" + selectedRecord.get('text'));
  371 + return true;
  372 + default:
  373 + return false;
  374 + }
  375 + return true;
  376 + }
  377 + }
  378 + );
  379 + },
  380 + scope: this
  381 + }
  382 + };
386 383 },
387   -
388   - addStandardDate: function(name, label, onChange) {
389   - return {
390   - xtype: 'datefield',
391   - name: name,
392   - format: 'Y/m/d H:i:s',
393   - enforceMaxLength : true,
394   - maxLength: 19,
395   - fieldLabel: label,
396   - listeners: {
397   - change: function(field, newValue, oldValue, eOpts) {
398   - this.object.set(name, newValue);
399   - if (onChange != null)
400   - onChange(name, newValue, oldValue);
401   - },
402   - scope : this
403   - }
404   - };
  384 +
  385 + addStandardDate: function (name, label, onChange) {
  386 + return {
  387 + xtype: 'datefield',
  388 + name: name,
  389 + format: 'Y/m/d H:i:s',
  390 + enforceMaxLength: true,
  391 + maxLength: 19,
  392 + fieldLabel: label,
  393 + listeners: {
  394 + change: function (field, newValue, oldValue, eOpts) {
  395 + this.object.set(name, newValue);
  396 + if (onChange != null)
  397 + onChange(name, newValue, oldValue);
  398 + },
  399 + scope: this
  400 + }
  401 + };
405 402 },
406   -
407   - addStandardLineItems: function(namePrefix) {
  403 +
  404 + addStandardLineItems: function (namePrefix) {
408 405 return [
409   - this.addStandardCombo(namePrefix+'-style', 'Style', amdaPlotObj.PlotObjectConfig.availableLinesStyles),
410   - this.addStandardFloat(namePrefix+'-width', 'Width', 1, 10),
411   - this.addStandardColor(namePrefix+'-color', 'Color', amdaPlotObj.PlotObjectConfig.availableColors)
  406 + this.addStandardCombo(namePrefix + '-style', 'Style', amdaPlotObj.PlotObjectConfig.availableLinesStyles),
  407 + this.addStandardFloat(namePrefix + '-width', 'Width', 1, 10),
  408 + this.addStandardColor(namePrefix + '-color', 'Color', amdaPlotObj.PlotObjectConfig.availableColors)
412 409 ];
413 410 },
414   -
415   - addStandardSymbolsItems: function(namePrefix) {
  411 +
  412 + addStandardSymbolsItems: function (namePrefix) {
416 413 return [
417   - this.addStandardCombo(namePrefix+'-type', 'Type', amdaPlotObj.PlotObjectConfig.availableSymbolsTypes),
418   - this.addStandardFloat(namePrefix+'-size', 'Size', 1, 10),
419   - this.addStandardColor(namePrefix+'-color', 'Color', amdaPlotObj.PlotObjectConfig.availableColors)
420   - ];
  414 + this.addStandardCombo(namePrefix + '-type', 'Type', amdaPlotObj.PlotObjectConfig.availableSymbolsTypes),
  415 + this.addStandardFloat(namePrefix + '-size', 'Size', 1, 10),
  416 + this.addStandardColor(namePrefix + '-color', 'Color', amdaPlotObj.PlotObjectConfig.availableColors)
  417 + ];
421 418 },
422   -
423   - init : function(config) {
  419 +
  420 + init: function (config) {
424 421 var me = this;
425   -
  422 +
426 423 var myConf = {
427   - bodyPadding: 5,
428   - bodyStyle: { background : '#dfe8f6' },
429   - border: false,
430   - layout: {
431   - type: 'vbox',
432   - pack: 'start',
433   - align: 'stretch'
434   - },
435   - items: this.getFormItems()
  424 + bodyPadding: 5,
  425 + bodyStyle: { background: '#dfe8f6' },
  426 + border: false,
  427 + layout: {
  428 + type: 'vbox',
  429 + pack: 'start',
  430 + align: 'stretch'
  431 + },
  432 + items: this.getFormItems()
436 433 };
437   -
438   - Ext.apply (this , Ext.apply (arguments, myConf));
  434 +
  435 + Ext.apply(this, Ext.apply(arguments, myConf));
439 436 }
440 437 });
... ...