UIW: delete module and move the code in gui
[scilab.git] / scilab / modules / gui / src / java / org / scilab / modules / gui / uiwidget / StringConverters.java
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2012 - Scilab Enterprises - Calixte DENIZET
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.gui.uiwidget;
14
15 import java.awt.Color;
16 import java.awt.Cursor;
17 import java.awt.Dimension;
18 import java.awt.Font;
19 import java.awt.Image;
20 import java.awt.Insets;
21 import java.awt.Point;
22 import java.awt.Rectangle;
23 import java.awt.event.ActionEvent;
24 import java.awt.geom.Rectangle2D;
25 import java.awt.image.BufferedImage;
26 import java.io.File;
27 import java.net.URL;
28 import java.text.DateFormat;
29 import java.text.DecimalFormat;
30 import java.text.DecimalFormatSymbols;
31 import java.text.NumberFormat;
32 import java.text.ParseException;
33 import java.util.Date;
34 import java.util.HashMap;
35 import java.util.Map;
36
37 import javax.imageio.ImageIO;
38 import javax.swing.AbstractAction;
39 import javax.swing.Action;
40 import javax.swing.Icon;
41 import javax.swing.ImageIcon;
42 import javax.swing.KeyStroke;
43 import javax.swing.border.Border;
44
45 import org.scilab.modules.action_binding.InterpreterManagement;
46 import org.scilab.modules.commons.gui.ScilabKeyStroke;
47 import org.scilab.modules.gui.events.callback.CommonCallBack;
48 import org.scilab.modules.gui.events.callback.ScilabCallBack;
49 import org.scilab.modules.gui.utils.Position;
50 import org.scilab.modules.gui.utils.ScilabSwingUtilities;
51 import org.scilab.modules.gui.utils.Size;
52 import org.scilab.modules.gui.uiwidget.components.UIButton;
53 import org.scilab.modules.gui.uiwidget.components.UILabel;
54 import org.scilab.modules.gui.uiwidget.components.UIMenuItem;
55 import org.scilab.modules.gui.uiwidget.components.UIPanel;
56 import org.scilab.modules.gui.uiwidget.components.UIProgressBar;
57 import org.scilab.modules.gui.uiwidget.components.UISlider;
58 import org.scilab.modules.gui.uiwidget.components.UISplit;
59 import org.scilab.modules.gui.uiwidget.components.UITab;
60 import org.scilab.modules.gui.uiwidget.components.UITextfield;
61 import org.scilab.modules.gui.uiwidget.components.UIToolBar;
62 import org.scilab.modules.gui.uiwidget.components.UITools;
63
64 /**
65  * Main class which handle conversion between String and basic Java objects
66  */
67 public final class StringConverters {
68
69     private static final Map<Class, StringConverter> converters = new HashMap<Class, StringConverter>();
70     private static final DateFormat dateformat = DateFormat.getDateInstance(DateFormat.LONG);
71
72     /**
73      * Register a converter
74      * @param clazz the resulting class
75      * @param converter the converter to use
76      */
77     public static final void registerConverter(final Class clazz, final StringConverter converter) {
78         converters.put(clazz, converter);
79     }
80
81     /**
82      * Get the converter to use for a given class
83      * @param clazz the class result
84      * @return the corresponding converter
85      */
86     public static final StringConverter getConverter(final Class clazz) {
87         return converters.get(clazz);
88     }
89
90     /**
91      * Check if a converter is existing
92      * @param clazz the class result
93      * @return true if a converter is existing
94      */
95     public static final boolean containConverter(final Class clazz) {
96         return converters.containsKey(clazz);
97     }
98
99     /**
100      * Get an object from a value
101      * @param clazz the class of the resulting object
102      * @param value the value to convert
103      * @return the converted object
104      */
105     public static final <T> T getObjectFromValue(final Class<T> clazz, final String value) {
106         final StringConverter converter = converters.get(clazz);
107         if (converter == null) {
108             // throw
109         }
110
111         return (T) converter.convert(value);
112     }
113
114     /**
115      * Get an object from a value
116      * @param clazz the class of the resulting object
117      * @param value he value to convert
118      * @param defaultValue the default value
119      * @return the converted object
120      */
121     public static final <T> T getObjectFromValue(final Class<T> clazz, final String value, final T defaultValue) {
122         final StringConverter converter = converters.get(clazz);
123         if (converter == null) {
124             // throw
125         }
126
127         return (value == null || value.isEmpty()) ? defaultValue : (T) converter.convert(value);
128     }
129
130     /**
131      * Interface to implement to parse an attribute String into a Java object
132      */
133     public static interface StringConverter {
134
135         /**
136          * Parse a string
137          * @param str the string to parse
138          * @return the corresponding Object
139          */
140         public Object convert(String str);
141     }
142
143     static {
144         converters.put(int.class, new StringConverter() {
145             public Integer convert(String str) {
146                 if (str == null || str.isEmpty()) {
147                     return Integer.MAX_VALUE;
148                 }
149                 try {
150                     return Integer.parseInt(str);
151                 } catch (NumberFormatException e) {
152                     try {
153                         return (int) Double.parseDouble(str);
154                     } catch (NumberFormatException ee) {
155                         return new Integer(0);
156                     }
157                 }
158             }
159         });
160         converters.put(char.class, new StringConverter() {
161             public Object convert(String str) {
162                 if (str.length() > 0) {
163                     return str.charAt(0);
164                 } else {
165                     return new Character((char) 0);
166                 }
167             }
168         });
169         converters.put(byte.class, new StringConverter() {
170             public Object convert(String str) {
171                 try {
172                     return Byte.parseByte(str);
173                 } catch (NumberFormatException e) {
174                     try {
175                         return (byte) Double.parseDouble(str);
176                     } catch (NumberFormatException ee) {
177                         return new Byte((byte) 0);
178                     }
179                 }
180             }
181         });
182         converters.put(short.class, new StringConverter() {
183             public Object convert(String str) {
184                 try {
185                     return Short.parseShort(str);
186                 } catch (NumberFormatException e) {
187                     try {
188                         return (short) Double.parseDouble(str);
189                     } catch (NumberFormatException ee) {
190                         return new Short((short) 0);
191                     }
192                 }
193             }
194         });
195         converters.put(double.class, new StringConverter() {
196             public Object convert(String str) {
197                 if (str == null || str.isEmpty()) {
198                     return Double.NaN;
199                 }
200
201                 try {
202                     return Double.parseDouble(str);
203                 } catch (NumberFormatException ee) {
204                     return new Double((double) 0);
205                 }
206             }
207         });
208         converters.put(float.class, new StringConverter() {
209             public Object convert(String str) {
210                 try {
211                     return Float.parseFloat(str);
212                 } catch (NumberFormatException ee) {
213                     return new Float((float) 0);
214                 }
215             }
216         });
217         converters.put(boolean.class, new StringConverter() {
218             public Object convert(String str) {
219                 if (str == null || str.isEmpty()) {
220                     return false;
221                 }
222
223                 str = str.toLowerCase();
224                 if (str.equals("on")) {
225                     return true;
226                 }
227
228                 if (str.equals("off")) {
229                     return false;
230                 }
231
232                 return Boolean.parseBoolean(str);
233             }
234         });
235         converters.put(long.class, new StringConverter() {
236             public Object convert(String str) {
237                 try {
238                     return Long.parseLong(str);
239                 } catch (NumberFormatException e) {
240                     try {
241                         return (long) Double.parseDouble(str);
242                     } catch (NumberFormatException ee) {
243                         return new Long((long) 0);
244                     }
245                 }
246             }
247         });
248         converters.put(String.class, new StringConverter() {
249             public Object convert(String str) {
250                 return str;
251             }
252         });
253         converters.put(Object.class, new StringConverter() {
254             public Object convert(String str) {
255                 return str;
256             }
257         });
258         converters.put(Color.class, new StringConverter() {
259             public Object convert(String str) {
260                 return UITools.getColor(str);
261             }
262         });
263         converters.put(KeyStroke.class, new StringConverter() {
264             public Object convert(String str) {
265                 if (str == null || str.isEmpty()) {
266                     return null;
267                 }
268
269                 String[] toks = str.split("[ +]");
270                 StringBuilder buffer = new StringBuilder();
271                 for (int i = 0; i < toks.length - 1; i++) {
272                     if (toks[i].equalsIgnoreCase("OSSCKEY")) {
273                         buffer.append("OSSCKEY ");
274                     } else {
275                         buffer.append(toks[i].toLowerCase());
276                         buffer.append(" ");
277                     }
278                 }
279                 buffer.append(toks[toks.length - 1].toUpperCase());
280                 return ScilabKeyStroke.getKeyStroke(buffer.toString());
281             }
282         });
283         converters.put(ImageIcon.class, new StringConverter() {
284             public Object convert(String str) {
285                 if (str == null || str.isEmpty()) {
286                     return null;
287                 }
288
289                 ImageIcon icon = null;
290
291                 if (str.lastIndexOf('.') == -1) {
292                     String path = ScilabSwingUtilities.findIcon(str);
293                     if (path != null) {
294                         try {
295                             BufferedImage img = ImageIO.read(new File(path));
296                             icon = new ImageIcon(img);
297                         } catch (Exception e) {
298                             return null;
299                         }
300                     }
301                 }
302
303                 if (icon == null) {
304                     try {
305                         URL url = new URL(str);
306                         BufferedImage img = ImageIO.read(url);
307                         icon = new ImageIcon(img);
308                     } catch (Exception e) { }
309                 }
310
311                 if (icon == null) {
312                     try {
313                         BufferedImage img = ImageIO.read(new File(UIWidgetTools.getFile(str).getAbsolutePath()));
314                         icon = new ImageIcon(img);
315                     } catch (Exception e) {
316                         return null;
317                     }
318                 }
319
320                 if (icon != null) {
321                     icon.setDescription(str);
322                 }
323
324                 return icon;
325             }
326         });
327         converters.put(Icon.class, converters.get(ImageIcon.class));
328         converters.put(Image.class, new StringConverter() {
329             public Object convert(String str) {
330                 if (str == null || str.isEmpty()) {
331                     return null;
332                 }
333
334                 if (str.lastIndexOf('.') == -1) {
335                     String path = ScilabSwingUtilities.findIcon(str);
336                     if (path != null) {
337                         try {
338                             return ImageIO.read(new File(path));
339                         } catch (Exception e) {
340                             return null;
341                         }
342                     }
343                 }
344
345                 try {
346                     URL url = new URL(str);
347                     return ImageIO.read(url);
348                 } catch (Exception e) { }
349
350                 try {
351                     return ImageIO.read(new File(UIWidgetTools.getFile(str).getAbsolutePath()));
352                 } catch (Exception e) {
353                     return null;
354                 }
355             }
356         });
357         converters.put(UILabel.Alignment.class, new StringConverter() {
358             public Object convert(String str) {
359                 if (str == null || str.isEmpty()) {
360                     return UILabel.Alignment.CENTER;
361                 }
362
363                 str = str.toLowerCase();
364
365                 if (str.equals("leading")) {
366                     return UILabel.Alignment.LEADING;
367                 } else if (str.equals("left")) {
368                     return UILabel.Alignment.LEFT;
369                 } else if (str.equals("right")) {
370                     return UILabel.Alignment.RIGHT;
371                 } else if (str.equals("trailing")) {
372                     return UILabel.Alignment.TRAILING;
373                 } else {
374                     return UILabel.Alignment.CENTER;
375                 }
376             }
377         });
378         converters.put(UITextfield.Alignment.class, new StringConverter() {
379             public Object convert(String str) {
380                 if (str == null || str.isEmpty()) {
381                     return UITextfield.Alignment.CENTER;
382                 }
383
384                 str = str.toLowerCase();
385
386                 if (str.equals("leading")) {
387                     return UITextfield.Alignment.LEADING;
388                 } else if (str.equals("left")) {
389                     return UITextfield.Alignment.LEFT;
390                 } else if (str.equals("right")) {
391                     return UITextfield.Alignment.RIGHT;
392                 } else if (str.equals("trailing")) {
393                     return UITextfield.Alignment.TRAILING;
394                 } else {
395                     return UITextfield.Alignment.CENTER;
396                 }
397             }
398         });
399         converters.put(UIButton.Alignment.class, new StringConverter() {
400             public Object convert(String str) {
401                 if (str == null || str.isEmpty()) {
402                     return UIButton.Alignment.CENTER;
403                 }
404
405                 str = str.toLowerCase();
406
407                 if (str.equals("leading")) {
408                     return UIButton.Alignment.LEADING;
409                 } else if (str.equals("left")) {
410                     return UIButton.Alignment.LEFT;
411                 } else if (str.equals("right")) {
412                     return UIButton.Alignment.RIGHT;
413                 } else if (str.equals("trailing")) {
414                     return UIButton.Alignment.TRAILING;
415                 } else {
416                     return UIButton.Alignment.CENTER;
417                 }
418             }
419         });
420         converters.put(UITab.Placement.class, new StringConverter() {
421             public Object convert(String str) {
422                 if (str == null || str.isEmpty()) {
423                     return UITab.Placement.TOP;
424                 }
425
426                 str = str.toLowerCase();
427
428                 if (str.equals("bottom")) {
429                     return UITab.Placement.BOTTOM;
430                 } else if (str.equals("left")) {
431                     return UITab.Placement.LEFT;
432                 } else if (str.equals("right")) {
433                     return UITab.Placement.RIGHT;
434                 } else {
435                     return UITab.Placement.TOP;
436                 }
437             }
438         });
439         converters.put(UISplit.Orientation.class, new StringConverter() {
440             public Object convert(String str) {
441                 if (str == null || str.isEmpty()) {
442                     return UISplit.Orientation.HORIZONTAL;
443                 }
444
445                 str = str.toLowerCase();
446
447                 if (str.equals("v") || str.equals("vertical")) {
448                     return UISplit.Orientation.VERTICAL;
449                 } else {
450                     return UISplit.Orientation.HORIZONTAL;
451                 }
452             }
453         });
454         converters.put(UIToolBar.Orientation.class, new StringConverter() {
455             public Object convert(String str) {
456                 if (str == null || str.isEmpty()) {
457                     return UIToolBar.Orientation.HORIZONTAL;
458                 }
459
460                 str = str.toLowerCase();
461
462                 if (str.equals("v") || str.equals("vertical")) {
463                     return UIToolBar.Orientation.VERTICAL;
464                 } else {
465                     return UIToolBar.Orientation.HORIZONTAL;
466                 }
467             }
468         });
469         converters.put(UISlider.Orientation.class, new StringConverter() {
470             public Object convert(String str) {
471                 if (str == null || str.isEmpty()) {
472                     return UISlider.Orientation.HORIZONTAL;
473                 }
474
475                 str = str.toLowerCase();
476
477                 if (str.equals("v") || str.equals("vertical")) {
478                     return UISlider.Orientation.VERTICAL;
479                 } else {
480                     return UISlider.Orientation.HORIZONTAL;
481                 }
482             }
483         });
484         converters.put(UIProgressBar.Orientation.class, new StringConverter() {
485             public Object convert(String str) {
486                 if (str == null || str.isEmpty()) {
487                     return UIProgressBar.Orientation.HORIZONTAL;
488                 }
489
490                 str = str.toLowerCase();
491
492                 if (str.equals("v") || str.equals("vertical")) {
493                     return UIProgressBar.Orientation.VERTICAL;
494                 } else {
495                     return UIProgressBar.Orientation.HORIZONTAL;
496                 }
497             }
498         });
499         converters.put(UIButton.Relief.class, new StringConverter() {
500             public Object convert(String str) {
501                 if (str == null || str.isEmpty()) {
502                     return UIButton.Relief.NORMAL;
503                 }
504
505                 str = str.toLowerCase();
506                 if (str.equals("none")) {
507                     return UIButton.Relief.NONE;
508                 } else if (str.equals("half")) {
509                     return UIButton.Relief.HALF;
510                 } else {
511                     return UIButton.Relief.NORMAL;
512                 }
513             }
514         });
515         converters.put(UIButton.Relief.class, new StringConverter() {
516             public Object convert(String str) {
517                 if (str == null || str.isEmpty()) {
518                     return UIButton.Relief.NORMAL;
519                 }
520
521                 str = str.toLowerCase();
522                 if (str.equals("none")) {
523                     return UIButton.Relief.NONE;
524                 } else if (str.equals("half")) {
525                     return UIButton.Relief.HALF;
526                 } else {
527                     return UIButton.Relief.NORMAL;
528                 }
529             }
530         });
531         converters.put(Border.class, new StringConverter() {
532             public Object convert(String str) {
533                 return UIBorderFactory.getBorder(str);
534             }
535         });
536         converters.put(Date.class, new StringConverter() {
537             public Object convert(String str) {
538                 if (str == null || str.isEmpty()) {
539                     return null;
540                 }
541                 try {
542                     return dateformat.parse(str);
543                 } catch (ParseException e) {
544                     return null;
545                 }
546             }
547         });
548         converters.put(Action.class, new StringConverter() {
549             public Object convert(final String str) {
550                 if (str == null || str.isEmpty()) {
551                     return null;
552                 }
553                 return new AbstractAction() {
554                     public void actionPerformed(ActionEvent e) {
555                         InterpreterManagement.requestScilabExec(str + "()");
556                     }
557                 };
558             }
559         });
560         converters.put(UITools.FontWeight.class, new StringConverter() {
561             public Object convert(String str) {
562                 if (str == null || str.isEmpty()) {
563                     return null;
564                 }
565
566                 str = str.toLowerCase();
567                 return UITools.mapWeight.get(str);
568             }
569         });
570         converters.put(Font.class, new StringConverter() {
571             public Object convert(String str) {
572                 if (str == null || str.isEmpty()) {
573                     return null;
574                 }
575
576                 return UITools.getFont(StyleParser.parseLine(str));
577             }
578         });
579         converters.put(UIPanel.ImageFill.class, new StringConverter() {
580             public Object convert(String str) {
581                 if (str == null || str.isEmpty()) {
582                     return UIPanel.ImageFill.CENTER;
583                 }
584
585                 str = str.toLowerCase();
586                 if (str.equals("fit")) {
587                     return UIPanel.ImageFill.FIT;
588                 } else if (str.equals("repeat")) {
589                     return UIPanel.ImageFill.REPEAT;
590                 } else {
591                     return UIPanel.ImageFill.CENTER;
592                 }
593             }
594         });
595         converters.put(UIMenuItem.MenuType.class, new StringConverter() {
596             public Object convert(String str) {
597                 if (str == null || str.isEmpty()) {
598                     return UIMenuItem.MenuType.NORMAL;
599                 }
600
601                 str = str.toLowerCase();
602                 if (str.equals("radio")) {
603                     return UIMenuItem.MenuType.RADIO;
604                 } else if (str.equals("check")) {
605                     return UIMenuItem.MenuType.CHECK;
606                 } else {
607                     return UIMenuItem.MenuType.NORMAL;
608                 }
609             }
610         });
611         converters.put(Insets.class, new StringConverter() {
612             public Object convert(String str) {
613                 if (str == null || str.isEmpty()) {
614                     return null;
615                 }
616
617                 int[] ints = new int[4];
618                 String[] toks = str.split("[ ,;]");
619                 for (int i = 0; i < toks.length && i < 4; i++) {
620                     try {
621                         ints[i] = Integer.parseInt(toks[i]);
622                     } catch (NumberFormatException e) {
623                         try {
624                             ints[i] = (int) Double.parseDouble(toks[i]);
625                         } catch (NumberFormatException ee) {
626                             ints[i] = 0;
627                         }
628                     }
629                 }
630
631                 return new Insets(ints[0], ints[1], ints[2], ints[3]);
632             }
633         });
634         converters.put(Rectangle.class, new StringConverter() {
635             public Object convert(String str) {
636                 if (str == null || str.isEmpty()) {
637                     return null;
638                 }
639
640                 int[] ints = new int[4];
641                 String[] toks = str.split("[ ,;]");
642                 for (int i = 0; i < toks.length && i < 4; i++) {
643                     try {
644                         ints[i] = Integer.parseInt(toks[i]);
645                     } catch (NumberFormatException e) {
646                         try {
647                             ints[i] = (int) Double.parseDouble(toks[i]);
648                         } catch (NumberFormatException ee) {
649                             ints[i] = 0;
650                         }
651                     }
652                 }
653
654                 return new Rectangle(ints[0], ints[1], ints[2], ints[3]);
655             }
656         });
657         converters.put(Rectangle2D.Double.class, new StringConverter() {
658             public Object convert(String str) {
659                 if (str == null || str.isEmpty()) {
660                     return null;
661                 }
662
663                 final double[] d = new double[4];
664                 String[] toks = str.split("[ ,;]");
665                 for (int i = 0; i < toks.length && i < 4; i++) {
666                     try {
667                         d[i] = (int) Double.parseDouble(toks[i]);
668                     } catch (NumberFormatException ee) {
669                         d[i] = 0;
670                     }
671                 }
672
673                 return new Rectangle2D.Double(d[0], d[1], d[2], d[3]);
674             }
675         });
676         converters.put(Dimension.class, new StringConverter() {
677             public Object convert(String str) {
678                 if (str == null || str.isEmpty()) {
679                     return null;
680                 }
681
682                 int[] ints = new int[2];
683                 String[] toks = str.split("[ ,;]");
684                 for (int i = 0; i < toks.length && i < 2; i++) {
685                     try {
686                         ints[i] = Integer.parseInt(toks[i]);
687                     } catch (NumberFormatException e) {
688                         try {
689                             ints[i] = (int) Double.parseDouble(toks[i]);
690                         } catch (NumberFormatException ee) {
691                             ints[i] = 0;;
692                         }
693                     }
694                 }
695
696                 return new Dimension(ints[0], ints[1]);
697             }
698         });
699         converters.put(Point.class, new StringConverter() {
700             public Object convert(String str) {
701                 if (str == null || str.isEmpty()) {
702                     return null;
703                 }
704
705                 int[] ints = new int[2];
706                 String[] toks = str.split("[ ,;]");
707                 for (int i = 0; i < toks.length && i < 2; i++) {
708                     try {
709                         ints[i] = Integer.parseInt(toks[i]);
710                     } catch (NumberFormatException e) {
711                         try {
712                             ints[i] = (int) Double.parseDouble(toks[i]);
713                         } catch (NumberFormatException ee) {
714                             ints[i] = 0;;
715                         }
716                     }
717                 }
718
719                 return new Point(ints[0], ints[1]);
720             }
721         });
722         converters.put(int[].class, new StringConverter() {
723             public Object convert(String str) {
724                 if (str == null || str.isEmpty()) {
725                     return null;
726                 }
727
728                 String[] toks = str.split("[ ,;]");
729                 int[] ints = new int[toks.length];
730                 for (int i = 0; i < toks.length; i++) {
731                     try {
732                         ints[i] = Integer.parseInt(toks[i]);
733                     } catch (NumberFormatException e) {
734                         try {
735                             ints[i] = (int) Double.parseDouble(toks[i]);
736                         } catch (NumberFormatException ee) {
737                             ints[i] = 0;
738                         }
739                     }
740                 }
741
742                 return ints;
743             }
744         });
745         converters.put(Integer[].class, new StringConverter() {
746             public Object convert(String str) {
747                 if (str == null || str.isEmpty()) {
748                     return null;
749                 }
750
751                 String[] toks = str.split("[ ,;]");
752                 Integer[] ints = new Integer[toks.length];
753                 for (int i = 0; i < toks.length; i++) {
754                     try {
755                         ints[i] = Integer.parseInt(toks[i]);
756                     } catch (NumberFormatException e) {
757                         try {
758                             ints[i] = (int) Double.parseDouble(toks[i]);
759                         } catch (NumberFormatException ee) {
760                             ints[i] = 0;
761                         }
762                     }
763                 }
764
765                 return ints;
766             }
767         });
768         converters.put(int[][].class, new StringConverter() {
769             public Object convert(String str) {
770                 if (str == null || str.isEmpty()) {
771                     return null;
772                 }
773
774                 int rows = 0;
775                 for (int i = 0; i < str.length(); i++) {
776                     if (str.charAt(i) == ';') {
777                         rows++;
778                     }
779                 }
780
781                 String[] toks = str.split("[ ,;]");
782                 int[][] ints = new int[rows][toks.length / rows];
783                 for (int i = 0; i < rows; i++) {
784                     for (int j = 0; j < toks.length / rows; j++) {
785                         try {
786                             ints[i][j] = Integer.parseInt(toks[i * rows + j]);
787                         } catch (NumberFormatException e) {
788                             try {
789                                 ints[i][j] = (int) Double.parseDouble(toks[i * rows + j]);
790                             } catch (NumberFormatException ee) {
791                                 ints[i][j] = 0;
792                             }
793                         }
794                     }
795                 }
796
797                 return ints;
798             }
799         });
800         converters.put(double[].class, new StringConverter() {
801             public Object convert(String str) {
802                 if (str == null || str.isEmpty()) {
803                     return null;
804                 }
805
806                 String[] toks = str.split("[ ,;]");
807                 double[] dbls = new double[toks.length];
808                 for (int i = 0; i < toks.length; i++) {
809                     try {
810                         dbls[i] = Double.parseDouble(toks[i]);
811                     } catch (NumberFormatException e) {
812                         dbls[i] = 0;
813                     }
814                 }
815
816                 return dbls;
817             }
818         });
819         converters.put(Double[].class, new StringConverter() {
820             public Object convert(String str) {
821                 if (str == null || str.isEmpty()) {
822                     return null;
823                 }
824
825                 String[] toks = str.split("[ ,;]");
826                 Double[] dbls = new Double[toks.length];
827                 for (int i = 0; i < toks.length; i++) {
828                     try {
829                         dbls[i] = Double.parseDouble(toks[i]);
830                     } catch (NumberFormatException e) {
831                         dbls[i] = new Double(0);
832                     }
833                 }
834
835                 return dbls;
836             }
837         });
838         converters.put(double[][].class, new StringConverter() {
839             public Object convert(String str) {
840                 if (str == null || str.isEmpty()) {
841                     return null;
842                 }
843
844                 int rows = 0;
845                 for (int i = 0; i < str.length(); i++) {
846                     if (str.charAt(i) == ';') {
847                         rows++;
848                     }
849                 }
850
851                 String[] toks = str.split("[ ,;]");
852                 double[][] dbls = new double[rows][toks.length / rows];
853                 for (int i = 0; i < rows; i++) {
854                     for (int j = 0; j < toks.length / rows; j++) {
855                         try {
856                             dbls[i][j] = Double.parseDouble(toks[i * rows + j]);
857                         } catch (NumberFormatException e) {
858                             dbls[i][j] = 0;
859                         }
860                     }
861                 }
862
863                 return dbls;
864             }
865         });
866         converters.put(String[].class, new StringConverter() {
867             public Object convert(String str) {
868                 if (str == null || str.isEmpty()) {
869                     return null;
870                 }
871
872                 String[] toks = str.split("[ ,]");
873
874                 return toks;
875             }
876         });
877         converters.put(String[][].class, new StringConverter() {
878             public Object convert(String str) {
879                 if (str == null || str.isEmpty()) {
880                     return null;
881                 }
882
883                 String[] toks = str.split("[;]");
884                 String[][] strs = new String[toks.length][];
885                 for (int i = 0; i < toks.length; i++) {
886                     strs[i] = toks[i].split("[ ,]");
887                 }
888
889                 return strs;
890             }
891         });
892         converters.put(Position.class, new StringConverter() {
893             public Object convert(String str) {
894                 if (str == null || str.isEmpty()) {
895                     return new Position(0, 0);
896                 }
897
898                 int[] ints = new int[2];
899                 String[] toks = str.split("[ ,;]");
900                 for (int i = 0; i < toks.length && i < 2; i++) {
901                     try {
902                         ints[i] = Integer.parseInt(toks[i]);
903                     } catch (NumberFormatException e) {
904                         try {
905                             ints[i] = (int) Double.parseDouble(toks[i]);
906                         } catch (NumberFormatException ee) {
907                             ints[i] = 0;;
908                         }
909                     }
910                 }
911
912                 return new Position(ints[0], ints[1]);
913             }
914         });
915         converters.put(Size.class, new StringConverter() {
916             public Object convert(String str) {
917                 if (str == null || str.isEmpty()) {
918                     return new Size(0, 0);
919                 }
920
921                 int[] ints = new int[2];
922                 String[] toks = str.split("[ ,;]");
923                 for (int i = 0; i < toks.length && i < 2; i++) {
924                     try {
925                         ints[i] = Integer.parseInt(toks[i]);
926                     } catch (NumberFormatException e) {
927                         try {
928                             ints[i] = (int) Double.parseDouble(toks[i]);
929                         } catch (NumberFormatException ee) {
930                             ints[i] = 0;;
931                         }
932                     }
933                 }
934
935                 return new Size(ints[0], ints[1]);
936             }
937         });
938         converters.put(CommonCallBack.class, new StringConverter() {
939             public Object convert(String str) {
940                 if (str == null) {
941                     return null;
942                 }
943
944                 return ScilabCallBack.create(str);
945             }
946         });
947         converters.put(DecimalFormat.class, new StringConverter() {
948             public Object convert(String str) {
949                 if (str == null) {
950                     return null;
951                 }
952
953                 DecimalFormat format;
954                 if (str.isEmpty()) {
955                     format = new DecimalFormat();
956                 }
957
958                 try {
959                     format = new DecimalFormat(str);
960                 } catch (IllegalArgumentException e) {
961                     format = (DecimalFormat) NumberFormat.getNumberInstance();
962                 }
963
964                 DecimalFormatSymbols symbols = format.getDecimalFormatSymbols();
965                 symbols.setDecimalSeparator('.');
966                 symbols.setGroupingSeparator('\u00A0');
967
968                 format.setDecimalFormatSymbols(symbols);
969
970                 return format;
971             }
972         });
973         converters.put(UIComponent.class, new StringConverter() {
974             public Object convert(String str) {
975                 if (str == null || str.isEmpty()) {
976                     return null;
977                 }
978
979                 return UILocator.get(str);
980             }
981         });
982         converters.put(File.class, new StringConverter() {
983             public Object convert(String str) {
984                 if (str == null || str.isEmpty()) {
985                     return null;
986                 }
987
988                 return new File(str);
989             }
990         });
991         converters.put(Cursor.class, new StringConverter() {
992             public Object convert(String str) {
993                 if (str == null || str.isEmpty()) {
994                     return null;
995                 }
996
997                 return UICursorFactory.getCursor(str);
998             }
999         });
1000         converters.put(UITools.FontUnit.class, new StringConverter() {
1001             public Object convert(String str) {
1002                 return UITools.FontUnit.fromString(str);
1003             }
1004         });
1005     }
1006 }