scilab/modules/gui/src/java/org/scilab/modules/gui/uiwidget/ObjectToScilabConverters.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.Insets;
  19 import java.awt.LayoutManager;
  20 import java.awt.Point;
  21 import java.awt.Rectangle;
  22 import java.awt.geom.Rectangle2D;
  23 import java.io.File;
  24 import java.net.URL;
  25 import java.util.HashMap;
  26 import java.util.Map;
  27
  28 import javax.swing.Icon;
  29 import javax.swing.ImageIcon;
  30 import javax.swing.KeyStroke;
  31
  32 import org.scilab.modules.gui.events.callback.CommonCallBack;
  33 import org.scilab.modules.gui.utils.Position;
  34 import org.scilab.modules.gui.utils.Size;
  35 import org.scilab.modules.types.ScilabHandle;
  36 import org.scilab.modules.types.ScilabStackPutter;
  37 import org.scilab.modules.gui.uiwidget.callback.UICallback;
  38
  39 /**
  40  * Class to provide easy way to convert a Java object into a Scilab variable and to put the result
  41  * on the Scilab stack at the given position
  42  */
  43 public final class ObjectToScilabConverters {
  44
  45     private static final Map<Class, ObjectConverter> converters = new HashMap<Class, ObjectConverter>();
  46
  47     /**
  48      * Put the Java object o on the Scilab stack at the position stackPos
  49      * An ObjetConverter is searched and if none has been found an empty matrix is put
  50      * @param o the Java object to convert and put.
  51      * @param stackPos the Scilab stack position.
  52      */
  53     public static void putOnScilabStack(Object o, int stackPos) {
  54         if (o == null) {
  55             ScilabStackPutter.putEmpty(stackPos);
  56         } else {
  57             final Class clazz = o.getClass();
  58             ObjectConverter converter;
  59             if (o instanceof UIComponent) {
  60                 converter = converters.get(UIComponent.class);
  61             } else {
  62                 converter = converters.get(clazz);
  63             }
  64
  65             if (converter == null) {
  66                 converter = getConverter(clazz);
  67             }
  68
  69             if (converter == null) {
  70                 ScilabStackPutter.putEmpty(stackPos);
  71             } else {
  72                 converter.convert(o, stackPos);
  73             }
  74         }
  75     }
  76
  77     /**
  78      * Get a converter for derived class
  79      * @param clazz the class
  80      * @return a converter
  81      */
  82     private static final ObjectConverter getConverter(Class clazz) {
  83         for (Map.Entry<Class, ObjectConverter> entry : converters.entrySet()) {
  84             Class key = entry.getKey();
  85             if (key != Object.class && key.isAssignableFrom(clazz)) {
  86                 return entry.getValue();
  87             }
  88         }
  89
  90         return null;
  91     }
  92
  93     /**
  94      * Interface to implement to parse an attribute String into a Java object
  95      */
  96     public static interface ObjectConverter {
  97
  98         /**
  99          * Convert an object
 100          * @param o the Object to put on the Scilab stack
 101          */
 102         public void convert(Object o, int stackPos);
 103     }
 104
 105     static {
 106         converters.put(Integer.class, new ObjectConverter() {
 107             public void convert(Object o, int stackPos) {
 108                 ScilabStackPutter.put(stackPos, (double) ((Integer) o).intValue());
 109             }
 110         });
 111         converters.put(int[].class, new ObjectConverter() {
 112             public void convert(Object o, int stackPos) {
 113                 ScilabStackPutter.put(stackPos, (int[]) o, false, false);
 114             }
 115         });
 116         converters.put(int[][].class, new ObjectConverter() {
 117             public void convert(Object o, int stackPos) {
 118                 ScilabStackPutter.put(stackPos, (int[][]) o, false, true);
 119             }
 120         });
 121         converters.put(Double.class, new ObjectConverter() {
 122             public void convert(Object o, int stackPos) {
 123                 ScilabStackPutter.put(stackPos, ((Double) o).doubleValue());
 124             }
 125         });
 126         converters.put(double[].class, new ObjectConverter() {
 127             public void convert(Object o, int stackPos) {
 128                 ScilabStackPutter.put(stackPos, (double[]) o, false);
 129             }
 130         });
 131         converters.put(Double[].class, new ObjectConverter() {
 132             public void convert(Object o, int stackPos) {
 133                 Double[] d = (Double[]) o;
 134                 double[] dd = new double[d.length];
 135                 for (int i = 0; i < dd.length; i++) {
 136                     dd[i] = d[i];
 137                 }
 138                 ScilabStackPutter.put(stackPos, dd, false);
 139             }
 140         });
 141         converters.put(double[][].class, new ObjectConverter() {
 142             public void convert(Object o, int stackPos) {
 143                 ScilabStackPutter.put(stackPos, (double[][]) o, true);
 144             }
 145         });
 146         converters.put(Boolean.class, new ObjectConverter() {
 147             public void convert(Object o, int stackPos) {
 148                 ScilabStackPutter.put(stackPos, ((Boolean) o).booleanValue());
 149             }
 150         });
 151         converters.put(boolean[].class, new ObjectConverter() {
 152             public void convert(Object o, int stackPos) {
 153                 ScilabStackPutter.put(stackPos, (boolean[]) o, false);
 154             }
 155         });
 156         converters.put(boolean[][].class, new ObjectConverter() {
 157             public void convert(Object o, int stackPos) {
 158                 ScilabStackPutter.put(stackPos, (boolean[][]) o, true);
 159             }
 160         });
 161         converters.put(Float.class, new ObjectConverter() {
 162             public void convert(Object o, int stackPos) {
 163                 ScilabStackPutter.put(stackPos, (double) ((Float) o).floatValue());
 164             }
 165         });
 166         converters.put(String.class, new ObjectConverter() {
 167             public void convert(Object o, int stackPos) {
 168                 ScilabStackPutter.put(stackPos, (String) o);
 169             }
 170         });
 171         converters.put(String[].class, new ObjectConverter() {
 172             public void convert(Object o, int stackPos) {
 173                 ScilabStackPutter.put(stackPos, (String[]) o, false);
 174             }
 175         });
 176         converters.put(String[][].class, new ObjectConverter() {
 177             public void convert(Object o, int stackPos) {
 178                 ScilabStackPutter.put(stackPos, (String[][]) o, true);
 179             }
 180         });
 181         converters.put(Object.class, new ObjectConverter() {
 182             public void convert(Object o, int stackPos) {
 183                 ScilabStackPutter.put(stackPos, o.toString());
 184             }
 185         });
 186         converters.put(Object[].class, new ObjectConverter() {
 187             public void convert(Object o, int stackPos) {
 188                 String[] strs = new String[((Object[]) o).length];
 189                 for (int i = 0; i < strs.length; i++) {
 190                     Object ob = ((Object[]) o)[i];
 191                     strs[i] = ob == null ? "" : ob.toString();
 192                 }
 193                 ScilabStackPutter.put(stackPos, strs, false);
 194             }
 195         });
 196         converters.put(Object[][].class, new ObjectConverter() {
 197             public void convert(Object o, int stackPos) {
 198                 String[][] strs = new String[((Object[][]) o).length][((Object[][]) o)[0].length];
 199                 for (int i = 0; i < strs.length; i++) {
 200                     for (int j = 0; j < strs[0].length; j++) {
 201                         Object ob = ((Object[][]) o)[i][j];
 202                         strs[i][j] = ob == null ? "" : ob.toString();
 203                     }
 204                 }
 205                 ScilabStackPutter.put(stackPos, strs, true);
 206             }
 207         });
 208         converters.put(Color.class, new ObjectConverter() {
 209             public void convert(Object o, int stackPos) {
 210                 Color c = (Color) o;
 211                 ScilabStackPutter.put(stackPos, new double[] {(double) c.getRed(), (double) c.getGreen(), (double) c.getBlue(), (double) c.getAlpha()} , false);
 212             }
 213         });
 214         converters.put(Icon.class, new ObjectConverter() {
 215             public void convert(Object o, int stackPos) {
 216                 if (o instanceof ImageIcon) {
 217                     ScilabStackPutter.put(stackPos, ((ImageIcon) o).getDescription());
 218                 } else {
 219                     ScilabStackPutter.put(stackPos, "Cannot convert " + o.toString());
 220                 }
 221             }
 222         });
 223         converters.put(ImageIcon.class, new ObjectConverter() {
 224             public void convert(Object o, int stackPos) {
 225                 ScilabStackPutter.put(stackPos, ((ImageIcon) o).getDescription());
 226             }
 227         });
 228         converters.put(LayoutManager.class, new ObjectConverter() {
 229             public void convert(Object o, int stackPos) {
 230                 if (o instanceof LayoutManager) {
 231                     ScilabStackPutter.put(stackPos, UILayoutFactory.getStringRepresentation((LayoutManager) o));
 232                 } else {
 233                     ScilabStackPutter.put(stackPos, "Cannot convert " + o.toString());
 234                 }
 235             }
 236         });
 237         converters.put(Insets.class, new ObjectConverter() {
 238             public void convert(Object o, int stackPos) {
 239                 Insets i = (Insets) o;
 240                 ScilabStackPutter.put(stackPos, new double[] {(double) i.top, (double) i.left, (double) i.bottom, (double) i.right} , false);
 241             }
 242         });
 243         converters.put(Rectangle.class, new ObjectConverter() {
 244             public void convert(Object o, int stackPos) {
 245                 Rectangle r = (Rectangle) o;
 246                 ScilabStackPutter.put(stackPos, new double[] {(double) r.x, (double) r.y, (double) r.width, (double) r.height} , false);
 247             }
 248         });
 249         converters.put(Rectangle2D.Double.class, new ObjectConverter() {
 250             public void convert(Object o, int stackPos) {
 251                 Rectangle2D.Double r = (Rectangle2D.Double) o;
 252                 ScilabStackPutter.put(stackPos, new double[] {r.x, r.y, r.width, r.height} , false);
 253             }
 254         });
 255         converters.put(Dimension.class, new ObjectConverter() {
 256             public void convert(Object o, int stackPos) {
 257                 Dimension d = (Dimension) o;
 258                 ScilabStackPutter.put(stackPos, new double[] {(double) d.width, (double) d.height} , false);
 259             }
 260         });
 261         converters.put(Point.class, new ObjectConverter() {
 262             public void convert(Object o, int stackPos) {
 263                 Point p = (Point) o;
 264                 ScilabStackPutter.put(stackPos, new double[] {(double) p.x, (double) p.y} , false);
 265             }
 266         });
 267         converters.put(Position.class, new ObjectConverter() {
 268             public void convert(Object o, int stackPos) {
 269                 Position p = (Position) o;
 270                 ScilabStackPutter.put(stackPos, new double[] {(double) p.getX(), (double) p.getY()} , false);
 271             }
 272         });
 273         converters.put(Size.class, new ObjectConverter() {
 274             public void convert(Object o, int stackPos) {
 275                 Size s = (Size) o;
 276                 ScilabStackPutter.put(stackPos, new double[] {(double) s.getWidth(), (double) s.getHeight()} , false);
 277             }
 278         });
 279         converters.put(CommonCallBack.class, new ObjectConverter() {
 280             public void convert(Object o, int stackPos) {
 281                 CommonCallBack cb = (CommonCallBack) o;
 282                 ScilabStackPutter.put(stackPos, cb.getCommand());
 283             }
 284         });
 285         converters.put(UIComponent.class, new ObjectConverter() {
 286             public void convert(Object o, int stackPos) {
 287                 UIComponent ui = (UIComponent) o;
 288                 ScilabHandle handle = new ScilabHandle((long) (-ui.getUid() - 1));
 289                 ScilabStackPutter.put(stackPos, handle);
 290             }
 291         });
 292         converters.put(UIComponent[].class, new ObjectConverter() {
 293             public void convert(Object o, int stackPos) {
 294                 UIComponent[] uis = (UIComponent[]) o;
 295                 long[][] hdls = new long[1][uis.length];
 296                 for (int i = 0; i < uis.length; i++) {
 297                     hdls[0][i] = (long) (-uis[i].getUid() - 1);
 298                 }
 299                 ScilabHandle handle = new ScilabHandle(hdls);
 300                 ScilabStackPutter.put(stackPos, handle);
 301             }
 302         });
 303         converters.put(File.class, new ObjectConverter() {
 304             public void convert(Object o, int stackPos) {
 305                 ScilabStackPutter.put(stackPos, o.toString());
 306             }
 307         });
 308         converters.put(URL.class, new ObjectConverter() {
 309             public void convert(Object o, int stackPos) {
 310                 ScilabStackPutter.put(stackPos, o.toString());
 311             }
 312         });
 313         converters.put(Cursor.class, new ObjectConverter() {
 314             public void convert(Object o, int stackPos) {
 315                 ScilabStackPutter.put(stackPos, UICursorFactory.getString((Cursor) o));
 316             }
 317         });
 318         converters.put(KeyStroke.class, new ObjectConverter() {
 319             public void convert(Object o, int stackPos) {
 320                 KeyStroke ks = (KeyStroke) o;
 321                 String s = o.toString();
 322                 int pos = s.lastIndexOf(' ');
 323                 if (pos != -1) {
 324                     String key = s.substring(pos + 1);
 325                     pos = s.lastIndexOf(' ', pos - 1);
 326                     if (pos != -1) {
 327                         s = s.substring(0, pos);
 328                         ScilabStackPutter.put(stackPos, s + " " + key);
 329                     } else {
 330                         ScilabStackPutter.put(stackPos, key);
 331                     }
 332                 } else {
 333                     ScilabStackPutter.put(stackPos, new double[0], false);
 334                 }
 335             }
 336         });
 337         converters.put(UICallback.class, new ObjectConverter() {
 338             public void convert(Object o, int stackPos) {
 339                 ScilabStackPutter.put(stackPos, o.toString());
 340             }
 341         });
 342     }
 343 }