Xcos: do not update cell size on loading
[scilab.git] / scilab / modules / xcos / src / java / org / scilab / modules / xcos / palette / PreLoadedElement.java
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2010 - DIGITEO - Clement DAVID
4  *
5  * This file must be used under the terms of the CeCILL.
6  * This source file is licensed as described in the file COPYING, which
7  * you should have received as part of this distribution.  The terms
8  * are also available at
9  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
10  *
11  */
12
13 package org.scilab.modules.xcos.palette;
14
15 import static java.util.Arrays.asList;
16
17 import java.io.File;
18 import java.io.IOException;
19 import java.util.List;
20
21 import org.scilab.modules.types.ScilabString;
22 import org.scilab.modules.types.ScilabTList;
23 import org.scilab.modules.types.ScilabType;
24 import org.scilab.modules.xcos.io.scicos.AbstractElement;
25 import org.scilab.modules.xcos.io.scicos.ScicosFormatException;
26 import org.scilab.modules.xcos.io.scicos.ScicosFormatException.WrongElementException;
27 import org.scilab.modules.xcos.io.scicos.ScicosFormatException.WrongStructureException;
28 import org.scilab.modules.xcos.io.scicos.ScicosFormatException.WrongTypeException;
29 import org.scilab.modules.xcos.palette.model.PaletteBlock;
30 import org.scilab.modules.xcos.palette.model.PreLoaded;
31 import org.scilab.modules.xcos.palette.model.VariablePath;
32
33 /**
34  * Decode a palette into a {@link PreLoaded} palette.
35  */
36 public class PreLoadedElement extends AbstractElement<PreLoaded> {
37     private static final List<String> DATA_FIELD_NAMES = asList("palette", "name", "blockNames", "blocks", "icons", "style");
38
39     /** Mutable field to easily get the data through methods */
40     private ScilabTList data;
41
42     /**
43      * Default constructor
44      */
45     public PreLoadedElement() {
46     }
47
48     /**
49      * Check the type name compatibility.
50      *
51      * @param element
52      *            the current element
53      * @return <code>true</code> if the data can be decoded by this instance,
54      *         <code>false</code> otherwise.
55      * @see org.scilab.modules.xcos.io.scicos.Element#canDecode(org.scilab.modules.types.ScilabType)
56      */
57     @Override
58     public boolean canDecode(ScilabType element) {
59         data = (ScilabTList) element;
60
61         final String type = ((ScilabString) data.get(0)).getData()[0][0];
62         return type.equals(DATA_FIELD_NAMES.get(0));
63     }
64
65     /**
66      * Decode the current element on the into argument.
67      *
68      * @param element
69      *            the Scilab data
70      * @param into
71      *            the target of the decoding (may be null)
72      * @return the filled instance
73      * @throws ScicosFormatException
74      *             on decoding error
75      * @see org.scilab.modules.xcos.io.scicos.Element#decode(org.scilab.modules.types.ScilabType,
76      *      java.lang.Object)
77      */
78     @Override
79     public PreLoaded decode(ScilabType element, PreLoaded into) throws ScicosFormatException {
80         data = (ScilabTList) element;
81         PreLoaded palette = into;
82
83         validate();
84
85         if (into == null) {
86             palette = new PreLoaded();
87         }
88
89         palette.setEnable(true);
90
91         /*
92          * get the data
93          */
94
95         int field = 1;
96         String[][] name = ((ScilabString) data.get(field)).getData();
97
98         field++;
99         String[][] blockNames = ((ScilabString) data.get(field)).getData();
100
101         field++;
102         String[][] blocks = ((ScilabString) data.get(field)).getData();
103
104         field++;
105         String[][] icons = ((ScilabString) data.get(field)).getData();
106
107         /*
108          * Configure the current palette instance
109          */
110
111         palette.setName(name[0][0]);
112
113         final List<PaletteBlock> paletteBlocks = palette.getBlock();
114         for (int i = 0; i < blockNames.length; i++) {
115             for (int j = 0; j < blockNames[i].length; j++) {
116                 PaletteBlock current = new PaletteBlock();
117                 current.setName(blockNames[i][j]);
118
119                 VariablePath iconPath = new VariablePath();
120                 iconPath.setVariable(null);
121                 File icon = new File(icons[i][j]);
122                 if (!icon.exists()) {
123                     try {
124                         Palette.generatePaletteIcon(blockNames[i][j], icons[i][j]);
125                     } catch (IOException e) {
126                         throw new WrongTypeException(e);
127                     }
128                 }
129                 iconPath.setPath(icons[i][j]);
130                 current.setIcon(iconPath);
131
132                 paletteBlocks.add(current);
133             }
134         }
135
136         return palette;
137     }
138
139     /**
140      * Validate the current data.
141      *
142      * This method doesn't pass the metrics because it perform many test.
143      * Therefore all these tests are trivial and the conditioned action only
144      * throw an exception.
145      *
146      * @throws ScicosFormatException
147      *             when there is a validation error.
148      */
149     // CSOFF: CyclomaticComplexity
150     // CSOFF: NPathComplexity
151     private void validate() throws ScicosFormatException {
152         if (!canDecode(data)) {
153             throw new WrongElementException();
154         }
155
156         int field = 0;
157
158         // we test if the structure as enough field
159         if (data.size() != DATA_FIELD_NAMES.size()) {
160             throw new WrongStructureException(DATA_FIELD_NAMES);
161         }
162
163         /*
164          * Checking the TList header
165          */
166
167         // Check the first field
168         if (!(data.get(field) instanceof ScilabString)) {
169             throw new WrongTypeException(DATA_FIELD_NAMES, field);
170         }
171         final String[] header = ((ScilabString) data.get(field)).getData()[0];
172
173         // Checking for the field names
174         if (header.length != DATA_FIELD_NAMES.size()) {
175             throw new WrongStructureException(DATA_FIELD_NAMES);
176         }
177         for (int i = 0; i < header.length; i++) {
178             if (!header[i].equals(DATA_FIELD_NAMES.get(i))) {
179                 throw new WrongStructureException(DATA_FIELD_NAMES);
180             }
181         }
182
183         /*
184          * Checking the data
185          */
186
187         // the second field must contain the palette name.
188         field++;
189         if (!(data.get(field) instanceof ScilabString) || data.get(field).getWidth() != 1 || data.get(field).getHeight() != 1) {
190             throw new WrongTypeException(DATA_FIELD_NAMES, field);
191         }
192
193         // the third field must contains the block name (row column)
194         field++;
195         if (!(data.get(field) instanceof ScilabString) || data.get(field).getWidth() != 1) {
196             throw new WrongTypeException(DATA_FIELD_NAMES, field);
197         }
198
199         // the fourth field must contains the block instance path (row column)
200         field++;
201         if (!(data.get(field) instanceof ScilabString) || data.get(field).getWidth() != 1) {
202             throw new WrongTypeException(DATA_FIELD_NAMES, field);
203         }
204
205         // the fifth field must contains the block icon path (row column)
206         field++;
207         if (!(data.get(field) instanceof ScilabString) || data.get(field).getWidth() != 1) {
208             throw new WrongTypeException(DATA_FIELD_NAMES, field);
209         }
210
211         // the sixth field is handled by the StyleElement decoder.
212     }
213
214     /**
215      * Not implemented yet, always return null.
216      *
217      * @param from
218      *            the source
219      * @param element
220      *            the destination
221      * @return null
222      * @see org.scilab.modules.xcos.io.scicos.Element#encode(java.lang.Object,
223      *      org.scilab.modules.types.ScilabType)
224      */
225     @Override
226     @Deprecated
227     public ScilabType encode(PreLoaded from, ScilabType element) {
228         return null;
229     }
230
231 }