scilab/modules/graphic_objects/src/java/org/scilab/modules/graphic_objects/builder/Builder.java

   1 /*
   2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3  * Copyright (C) 2012 - Scilab Enterprises - Calixte DENIZET
   4  * Copyright (C) 2013 - Scilab Enterprises - Antoine ELIAS
   5  *
   6  * This file must be used under the terms of the CeCILL.
   7  * This source file is licensed as described in the file COPYING, which
   8  * you should have received as part of this distribution.  The terms
   9  * are also available at
  10  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
  11  *
  12  */
  13
  14 package org.scilab.modules.graphic_objects.builder;
  15
  16 import java.util.ArrayList;
  17 import java.util.StringTokenizer;
  18
  19 import org.scilab.modules.graphic_objects.ScilabNativeView;
  20 import org.scilab.modules.graphic_objects.arc.Arc;
  21 import org.scilab.modules.graphic_objects.axes.Axes;
  22 import org.scilab.modules.graphic_objects.axis.Axis;
  23 import org.scilab.modules.graphic_objects.fec.Fec;
  24 import org.scilab.modules.graphic_objects.figure.Figure;
  25 import org.scilab.modules.graphic_objects.figure.Figure.BarType;
  26 import org.scilab.modules.graphic_objects.graphicController.GraphicController;
  27 import org.scilab.modules.graphic_objects.graphicModel.GraphicModel;
  28 import org.scilab.modules.graphic_objects.graphicObject.GraphicObject;
  29 import org.scilab.modules.graphic_objects.graphicObject.GraphicObject.Type;
  30 import org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties;
  31 import org.scilab.modules.graphic_objects.imageplot.Imageplot;
  32 import org.scilab.modules.graphic_objects.label.Label;
  33 import org.scilab.modules.graphic_objects.legend.Legend;
  34 import org.scilab.modules.graphic_objects.lighting.Light;
  35 import org.scilab.modules.graphic_objects.lighting.Light.LightType;
  36 import org.scilab.modules.graphic_objects.polyline.Polyline;
  37 import org.scilab.modules.graphic_objects.rectangle.Rectangle;
  38 import org.scilab.modules.graphic_objects.surface.Surface;
  39 import org.scilab.modules.graphic_objects.textObject.Font;
  40 import org.scilab.modules.graphic_objects.textObject.Text;
  41 import org.scilab.modules.graphic_objects.vectfield.Champ;
  42 import org.scilab.modules.graphic_objects.vectfield.Segs;
  43
  44 public final class Builder {
  45     public final static int createRect(int parentSubwin, double x, double y, double height, double width, int foreground, int background, int isfilled, int isline) {
  46         GraphicController controller = GraphicController.getController();
  47         Axes axes = (Axes) controller.getObjectFromId(parentSubwin);
  48
  49         if (height < 0 || width < 0) {
  50             return 0;
  51         }
  52
  53         Integer iRect = controller.askObject(Type.RECTANGLE, false);
  54
  55         /*
  56          * Sets the rectangle's parent in order to initialize the former's
  57          * Contoured properties with the latter's values (cloneGraphicContext
  58          * call below)
  59          */
  60
  61         Rectangle rect = (Rectangle) controller.getObjectFromId(iRect);
  62         rect.setUpperLeftPoint(new Double[] { x, y, 0.0 });
  63         rect.setHeight(height);
  64         rect.setWidth(width);
  65
  66         rect.setVisible(axes.getVisible());
  67
  68         /* Clip state and region */
  69         /* To be checked for consistency */
  70
  71         rect.setClipBox(axes.getClipBox());
  72         rect.setClipBoxSet(axes.getClipBoxSet());
  73         rect.setClipState(axes.getClipState());
  74         rect.setMarkMode(axes.getMarkMode());
  75
  76         /*
  77          * Initializes the contour properties (background, foreground, etc) to
  78          * the default values (those of the parent Axes).
  79          */
  80         cloneGraphicContext(parentSubwin, iRect);
  81
  82         /* Contour settings */
  83         rect.setLineMode(isline == 1);
  84         rect.setFillMode(isfilled == 1);
  85
  86         if (foreground != -1) {
  87             rect.setLineColor(foreground);
  88         }
  89
  90         if (background != -1) {
  91             rect.setBackground(background);
  92         }
  93
  94         controller.objectCreated(iRect);
  95
  96         /*
  97          * Sets the Axes as the rectangle's parent and adds the rectangle to its
  98          * parent's list of children.
  99          */
 100         //setGraphicObjectRelationship(pparentsubwinUID, pobjUID);
 101
 102         return iRect;
 103     }
 104
 105     public static int cloneGraphicContext(int sourceIdentifier, int destIdentifier) {
 106         GraphicController controller = GraphicController.getController();
 107         Boolean lineMode = false;
 108         Integer foreground = 0;
 109         Integer lineStyle = 0;
 110         Integer background = 0;
 111         Integer markForeground = 0;
 112         Integer markBackground = 0;
 113         Integer markStyle = 0;
 114         Integer markSize = 0;
 115         Integer markSizeUnit = 0;
 116         Double lineThickness = 0.;
 117
 118         /*
 119          * All these properties are passed by value thus do not care to release
 120          * them and do not call releaseGraphicObjectProperty on purpose.
 121          */
 122
 123         lineMode = (Boolean) controller.getProperty(sourceIdentifier, GraphicObjectProperties.__GO_LINE_MODE__);
 124         foreground = (Integer) controller.getProperty(sourceIdentifier, GraphicObjectProperties.__GO_LINE_COLOR__);
 125         lineThickness = (Double) controller.getProperty(sourceIdentifier, GraphicObjectProperties.__GO_LINE_THICKNESS__);
 126         lineStyle = (Integer) controller.getProperty(sourceIdentifier, GraphicObjectProperties.__GO_LINE_STYLE__);
 127
 128         background = (Integer) controller.getProperty(sourceIdentifier, GraphicObjectProperties.__GO_BACKGROUND__);
 129
 130         markForeground = (Integer) controller.getProperty(sourceIdentifier, GraphicObjectProperties.__GO_MARK_FOREGROUND__);
 131
 132         markBackground = (Integer) controller.getProperty(sourceIdentifier, GraphicObjectProperties.__GO_MARK_BACKGROUND__);
 133
 134         markStyle = (Integer) controller.getProperty(sourceIdentifier, GraphicObjectProperties.__GO_MARK_STYLE__);
 135
 136         markSize = (Integer) controller.getProperty(sourceIdentifier, GraphicObjectProperties.__GO_MARK_SIZE__);
 137
 138         markSizeUnit = (Integer) controller.getProperty(sourceIdentifier, GraphicObjectProperties.__GO_MARK_SIZE_UNIT__);
 139
 140         controller.setProperty(destIdentifier, GraphicObjectProperties.__GO_LINE_MODE__, lineMode);
 141         controller.setProperty(destIdentifier, GraphicObjectProperties.__GO_LINE_COLOR__, foreground);
 142         controller.setProperty(destIdentifier, GraphicObjectProperties.__GO_LINE_THICKNESS__, lineThickness);
 143         controller.setProperty(destIdentifier, GraphicObjectProperties.__GO_LINE_STYLE__, lineStyle);
 144
 145         controller.setProperty(destIdentifier, GraphicObjectProperties.__GO_BACKGROUND__, background);
 146
 147         controller.setProperty(destIdentifier, GraphicObjectProperties.__GO_MARK_FOREGROUND__, markForeground);
 148         controller.setProperty(destIdentifier, GraphicObjectProperties.__GO_MARK_BACKGROUND__, markBackground);
 149         controller.setProperty(destIdentifier, GraphicObjectProperties.__GO_MARK_STYLE__, markStyle);
 150         controller.setProperty(destIdentifier, GraphicObjectProperties.__GO_MARK_SIZE__, markSize);
 151         controller.setProperty(destIdentifier, GraphicObjectProperties.__GO_MARK_SIZE_UNIT__, markSizeUnit);
 152
 153         return 0;
 154     }
 155
 156     public static int cloneFontContext(int sourceIdentifier, int destIdentifier) {
 157         GraphicController controller = GraphicController.getController();
 158
 159         Integer fontColor = (Integer) controller.getProperty(sourceIdentifier, GraphicObjectProperties.__GO_FONT_COLOR__);
 160         Integer fontStyle = (Integer) controller.getProperty(sourceIdentifier, GraphicObjectProperties.__GO_FONT_STYLE__);
 161         Double fontSize = (Double) controller.getProperty(sourceIdentifier, GraphicObjectProperties.__GO_FONT_SIZE__);
 162         Boolean fontFractional = (Boolean) controller.getProperty(sourceIdentifier, GraphicObjectProperties.__GO_FONT_FRACTIONAL__);
 163
 164         controller.setProperty(destIdentifier, GraphicObjectProperties.__GO_FONT_COLOR__, fontColor);
 165         controller.setProperty(destIdentifier, GraphicObjectProperties.__GO_FONT_STYLE__, fontStyle);
 166         controller.setProperty(destIdentifier, GraphicObjectProperties.__GO_FONT_SIZE__, fontSize);
 167         controller.setProperty(destIdentifier, GraphicObjectProperties.__GO_FONT_FRACTIONAL__, fontFractional);
 168
 169         return 0;
 170     }
 171
 172     public static int createHiddenLabel(int parent) {
 173
 174         GraphicController controller = GraphicController.getController();
 175
 176         Integer iLabel = controller.askObject(Type.LABEL, false);
 177         Label label = (Label) controller.getObjectFromId(iLabel);
 178
 179         //Hide Label as they are non explicit children
 180         label.setHidden(true);
 181         label.setAutoPosition(true);
 182         label.setAutoRotation(true);
 183
 184         cloneGraphicContext(parent, iLabel);
 185         cloneFontContext(parent, iLabel);
 186         controller.objectCreated(iLabel);
 187
 188         // Sets the label's parent
 189         controller.setGraphicObjectRelationship(parent, iLabel);
 190
 191         return iLabel;
 192     }
 193
 194     public static void initSubWinBounds(int subWin) {
 195         GraphicController controller = GraphicController.getController();
 196
 197         controller.setProperty(subWin, GraphicObjectProperties.__GO_X_AXIS_LOG_FLAG__, false);
 198         controller.setProperty(subWin, GraphicObjectProperties.__GO_Y_AXIS_LOG_FLAG__, false);
 199         controller.setProperty(subWin, GraphicObjectProperties.__GO_Z_AXIS_LOG_FLAG__, false);
 200     }
 201
 202     public static void reinitSubWin(int subWin) {
 203         GraphicController controller = GraphicController.getController();
 204         Integer label = 0;
 205
 206         for (Integer childId : (Integer[]) controller.getProperty(subWin, GraphicObjectProperties.__GO_CHILDREN__)) {
 207             GraphicModel.getModel().deleteObject(childId);
 208         }
 209
 210         label = createHiddenLabel(subWin);
 211         controller.setProperty(subWin, GraphicObjectProperties.__GO_TITLE__, label);
 212
 213         label = createHiddenLabel(subWin);
 214         controller.setProperty(subWin, GraphicObjectProperties.__GO_X_AXIS_LABEL__, label);
 215
 216         label = createHiddenLabel(subWin);
 217         controller.setProperty(subWin, GraphicObjectProperties.__GO_Y_AXIS_LABEL__, label);
 218
 219         label = createHiddenLabel(subWin);
 220         controller.setProperty(subWin, GraphicObjectProperties.__GO_Z_AXIS_LABEL__, label);
 221
 222         controller.setProperty(subWin, GraphicObjectProperties.__GO_X_AXIS_LOCATION__, 0);
 223         controller.setProperty(subWin, GraphicObjectProperties.__GO_Y_AXIS_LOCATION__, 4);
 224         controller.setProperty(subWin, GraphicObjectProperties.__GO_VISIBLE__, true);
 225         controller.setProperty(subWin, GraphicObjectProperties.__GO_FIRST_PLOT__, true);
 226
 227         Integer axesModel = GraphicModel.getAxesModel().getIdentifier();
 228         Axes axes = (Axes) controller.getObjectFromId(axesModel);
 229
 230         controller.setProperty(subWin, GraphicObjectProperties.__GO_VIEW__, axes.getView());
 231         controller.setProperty(subWin, GraphicObjectProperties.__GO_ROTATION_ANGLES__, axes.getRotationAngles());
 232         controller.setProperty(subWin, GraphicObjectProperties.__GO_ROTATION_ANGLES_3D__, axes.getRotationAngles3d());
 233     }
 234
 235     public static boolean isAxesRedrawing(int subWin) {
 236         GraphicController controller = GraphicController.getController();
 237         Axes axes = (Axes) controller.getObjectFromId(subWin);
 238
 239         if (axes.getAutoClear()) {
 240             reinitSubWin(subWin);
 241             return true;
 242         }
 243         return false;
 244     }
 245
 246     public static int createLabel(int parent, int type) {
 247         GraphicController controller = GraphicController.getController();
 248         Double[] position = new Double[3];
 249         position[0] = 1.0;
 250         position[1] = 1.0;
 251         position[2] = 1.0;
 252
 253         //check parent type
 254         Integer parentType = (Integer) controller.getProperty(parent, GraphicObjectProperties.__GO_TYPE__);
 255         if (parentType != GraphicObjectProperties.__GO_AXES__) {
 256             return 1;
 257         }
 258
 259         //get axes model
 260         Integer axesModel = GraphicModel.getAxesModel().getIdentifier();
 261
 262         //get type label from axes model
 263         Integer labelSource = (Integer) controller.getProperty(axesModel, type);
 264
 265         //clone label
 266         Integer newLabel = controller.cloneObject(labelSource);
 267         controller.setProperty(newLabel, GraphicObjectProperties.__GO_POSITION__, position);
 268         // Auto position must be reset as setting the position has set it to false
 269         Boolean autoPosition = (Boolean) controller.getProperty(labelSource, GraphicObjectProperties.__GO_AUTO_POSITION__);
 270         controller.setProperty(newLabel, GraphicObjectProperties.__GO_AUTO_POSITION__, autoPosition);
 271
 272         // Set relation between newLabel and parent
 273         controller.setProperty(parent, type, newLabel);
 274         controller.setGraphicObjectRelationship(parent, newLabel);
 275         return 0;
 276     }
 277
 278     public final static int createFigureFromModel() {
 279         GraphicController controller = GraphicController.getController();
 280         return controller.cloneObject(GraphicModel.getFigureModel().getIdentifier());
 281     }
 282
 283     public final static int cloneAxesModel(int parent) {
 284         GraphicController controller = GraphicController.getController();
 285
 286         Integer newAxes = controller.cloneObject(GraphicModel.getAxesModel().getIdentifier());
 287         createLabel(newAxes, GraphicObjectProperties.__GO_X_AXIS_LABEL__);
 288         createLabel(newAxes, GraphicObjectProperties.__GO_Y_AXIS_LABEL__);
 289         createLabel(newAxes, GraphicObjectProperties.__GO_Z_AXIS_LABEL__);
 290         createLabel(newAxes, GraphicObjectProperties.__GO_TITLE__);
 291
 292         controller.setGraphicObjectRelationship(parent, newAxes);
 293         controller.setProperty(parent, GraphicObjectProperties.__GO_SELECTED_CHILD__, newAxes);
 294
 295         ScilabNativeView.ScilabNativeView__setCurrentSubWin(newAxes);
 296         ScilabNativeView.ScilabNativeView__setCurrentObject(newAxes);
 297         return newAxes;
 298     }
 299
 300     public final static void cloneMenus(int iModel, int iParent) {
 301         GraphicController controller = GraphicController.getController();
 302         GraphicObject model = controller.getObjectFromId(iModel);
 303
 304         Integer[] children = model.getChildren();
 305
 306         for (int i = children.length - 1; i >= 0; i--) {
 307             GraphicObject child = controller.getObjectFromId(children[i]);
 308             if (child.getType() == GraphicObjectProperties.__GO_UIMENU__) {
 309                 Integer newMenu = controller.cloneObject(children[i]);
 310                 controller.setGraphicObjectRelationship(iParent, newMenu);
 311
 312                 cloneMenus(children[i], newMenu);
 313             }
 314         }
 315     }
 316
 317     public final static int createFigure(boolean dockable, int menubarType, int toolbarType, boolean defaultAxes, boolean visible, double[] figureSize, double[] axesSize, double[] position,
 318                                          boolean menubar, boolean toolbar, boolean infobar) {
 319         GraphicController controller = GraphicController.getController();
 320         Integer figModel = GraphicModel.getFigureModel().getIdentifier();
 321         Integer figId = controller.cloneObject(figModel, false);
 322         Figure figure = (Figure) controller.getObjectFromId(figId);
 323         figure.setDockable(dockable);
 324         figure.setMenubar(menubarType);
 325         figure.setToolbar(toolbarType);
 326         figure.setVisible(visible);
 327         figure.setDefaultAxes(defaultAxes);
 328
 329         //set figure size only if axes size is not set too
 330         if (figureSize != null && figureSize.length == 2 && (axesSize == null || axesSize.length == 0)) {
 331             figure.setSize(new Integer[] { (int) figureSize[0], (int) figureSize[1] });
 332         }
 333
 334         if (position != null && position.length == 2) {
 335             figure.setPosition(new Integer[] { (int) position[0], (int) position[1] });
 336         }
 337
 338         figure.setMenubarVisible(menubar);
 339         figure.setToolbarVisible(toolbar);
 340         figure.setInfobarVisible(infobar);
 341
 342         controller.objectCreated(figId);
 343
 344         ScilabNativeView.ScilabNativeView__setCurrentFigure(figId);
 345
 346         if (menubarType == BarType.FIGURE.ordinal()) {
 347             cloneMenus(figModel, figId);
 348         }
 349
 350         if (defaultAxes) {
 351             //clone default axes
 352             cloneAxesModel(figId);
 353         }
 354
 355         if (axesSize != null && axesSize.length == 2) {
 356             controller.setProperty(figId, GraphicObjectProperties.__GO_AXES_SIZE__, new Integer[] { (int) axesSize[0], (int) axesSize[1] });
 357         }
 358
 359         return figId;
 360     }
 361
 362     public final static int createNewFigureWithAxes() {
 363         GraphicController controller = GraphicController.getController();
 364         Integer figModel = GraphicModel.getFigureModel().getIdentifier();
 365
 366         //clone default figure
 367         Integer newFigure = createFigureFromModel();
 368
 369         //Clone the default menus
 370         cloneMenus(figModel, newFigure);
 371
 372         //set ID to 0
 373         controller.setProperty(newFigure, GraphicObjectProperties.__GO_ID__, 0);
 374
 375         //clone default axes
 376         cloneAxesModel(newFigure);
 377         ScilabNativeView.ScilabNativeView__setCurrentFigure(newFigure);
 378
 379         //Force axes size after window creation
 380         Integer[] axesSize = (Integer[]) controller.getProperty(figModel, GraphicObjectProperties.__GO_AXES_SIZE__);
 381         controller.setProperty(newFigure, GraphicObjectProperties.__GO_AXES_SIZE__, axesSize);
 382
 383         controller.setProperty(newFigure, GraphicObjectProperties.__GO_VALID__, true);
 384
 385         return newFigure;
 386     }
 387
 388     public final static int createSubWin(int parentFigure) {
 389         //GraphicController controller = GraphicController.getController();
 390         //GraphicObject parent = controller.getObjectFromId(parentFigure);
 391         //if (parent.getType() != GraphicObjectProperties.__GO_FIGURE__) {
 392         //    return 0;
 393         //}
 394
 395         return cloneAxesModel(parentFigure);
 396     }
 397
 398     public final static int createText(int iParentsubwinUID, String[] str, int nbRow, int nbCol, double x, double y, boolean autoSize, double[] userSize, int centerPos, int foreground,
 399                                        boolean isForeground, int background, boolean isBackground, boolean isBoxed, boolean isLine, boolean isFilled, int align) {
 400
 401         GraphicController controller = GraphicController.getController();
 402         int iText = controller.askObject(Type.TEXT, false);
 403
 404         Axes axes = (Axes) controller.getObjectFromId(iParentsubwinUID);
 405         Text text = (Text) controller.getObjectFromId(iText);
 406
 407         //clip
 408         text.setClipBox(axes.getClipBox());
 409         text.setClipBoxSet(axes.getClipBoxSet());
 410         text.setClipState(axes.getClipState());
 411
 412         //text
 413         Integer[] dimensions = new Integer[2];
 414         dimensions[0] = nbRow;
 415         dimensions[1] = nbCol;
 416         text.setTextArrayDimensions(dimensions);
 417         text.setTextStrings(str);
 418
 419         //position
 420         Double[] position = new Double[3];
 421         position[0] = x;
 422         position[1] = y;
 423         position[2] = 0.0;
 424         text.setPosition(position);
 425
 426         //test box
 427         Double[] setUserSize = new Double[2];
 428         text.setTextBoxMode(centerPos);
 429         text.setAutoDimensioning(autoSize);
 430
 431         if (autoSize == false || centerPos != 0) {
 432             setUserSize[0] = userSize[0];
 433             setUserSize[1] = userSize[1];
 434         } else {
 435             setUserSize[0] = 0.0;
 436             setUserSize[1] = 0.0;
 437         }
 438         text.setTextBox(setUserSize);
 439
 440         int alignment = align - 1;
 441         if (alignment < 0 || alignment > 2) {
 442             alignment = 0;
 443         }
 444
 445         text.setAlignment(alignment);
 446
 447         cloneGraphicContext(iParentsubwinUID, iText);
 448         cloneFontContext(iParentsubwinUID, iText);
 449
 450         text.setBox(isBoxed);
 451         text.setLineMode(isLine);
 452         text.setFillMode(isFilled);
 453
 454         if (isForeground) {
 455             text.setLineColor(foreground);
 456         }
 457
 458         if (isBackground) {
 459             text.setBackground(background);
 460         }
 461
 462         text.setVisible(axes.getVisible());
 463         controller.objectCreated(iText);
 464         return iText;
 465     }
 466
 467     public final static int createArc(int parent, double x, double y, double h, double w, double startAngle, double endAngle, int foreground, boolean isForeground, int background,
 468                                       boolean isBackground, boolean filled, boolean line) {
 469
 470         GraphicController controller = GraphicController.getController();
 471         int iArc = controller.askObject(Type.ARC, false);
 472
 473         Axes axes = (Axes) controller.getObjectFromId(parent);
 474         Arc arc = (Arc) controller.getObjectFromId(iArc);
 475
 476         //set visible false during construction
 477         arc.setVisible(false);
 478
 479         Double[] upperLeftPoint = new Double[3];
 480         upperLeftPoint[0] = x;
 481         upperLeftPoint[1] = y;
 482         upperLeftPoint[2] = 0.0;
 483
 484         arc.setUpperLeftPoint(upperLeftPoint);
 485         arc.setHeight(h);
 486         arc.setWidth(w);
 487         arc.setStartAngle(startAngle);
 488         arc.setEndAngle(endAngle);
 489         arc.setArcDrawingMethod(axes.getArcDrawingMethod());
 490
 491         //clip
 492         arc.setClipBox(axes.getClipBox());
 493         arc.setClipBoxSet(axes.getClipBoxSet());
 494         arc.setClipState(axes.getClipState());
 495
 496         cloneGraphicContext(parent, iArc);
 497
 498         arc.setLineMode(line);
 499         arc.setFillMode(filled);
 500
 501         if (isForeground) {
 502             arc.setLineColor(foreground);
 503         }
 504
 505         if (isBackground) {
 506             arc.setBackground(background);
 507         }
 508
 509         arc.setVisible(axes.getVisible());
 510         controller.objectCreated(iArc);
 511         controller.setGraphicObjectRelationship(parent, iArc);
 512         return iArc;
 513     }
 514
 515     public final static int createAxis(int parent, int dir, int tics, double[] vx, double[] vy, int subint, String format, int fontSize, int textColor, int ticsColor, boolean seg) {
 516
 517         GraphicController controller = GraphicController.getController();
 518         int iAxis = controller.askObject(Type.AXIS, false);
 519
 520         Axes axes = (Axes) controller.getObjectFromId(parent);
 521         Axis axis = (Axis) controller.getObjectFromId(iAxis);
 522
 523         //clip box
 524         axis.setClipBox(axes.getClipBox());
 525         axis.setClipBoxSet(false);
 526
 527         axis.setTicksDirection(dir);
 528         axis.setTicksStyle(tics);
 529
 530         axis.setXTicksCoords(toDouble(vx));
 531         axis.setYTicksCoords(toDouble(vy));
 532
 533         if (format != null && format.equals("") == false) {
 534             axis.setFormatn(format);
 535         }
 536
 537         axis.setSubticks(subint);
 538         axis.setTicksSegment(seg);
 539         cloneGraphicContext(parent, iAxis);
 540         cloneFontContext(parent, iAxis);
 541
 542         Font font = axis.getFont();
 543         font.setSize(new Double(fontSize));
 544         font.setColor(textColor);
 545         axis.setTicksColor(ticsColor);
 546
 547         controller.objectCreated(iAxis);
 548         controller.setGraphicObjectRelationship(parent, iAxis);
 549         return iAxis;
 550     }
 551
 552     public static int createCompound(int parent, int[] children) {
 553         GraphicController controller = GraphicController.getController();
 554         int iCompound = controller.askObject(Type.COMPOUND);
 555
 556         GraphicObject obj = controller.getObjectFromId(parent);
 557         for (int i = 0; i < children.length; i++) {
 558             controller.setGraphicObjectRelationship(iCompound, children[i]);
 559         }
 560
 561         controller.setGraphicObjectRelationship(parent, iCompound);
 562         controller.setProperty(iCompound, GraphicObjectProperties.__GO_VISIBLE__, obj.getVisible());
 563         return iCompound;
 564     }
 565
 566     public static int createCompoundSeq(int parent, int childrenCount) {
 567         GraphicController controller = GraphicController.getController();
 568         int iCompound = controller.askObject(Type.COMPOUND);
 569         GraphicObject axes = controller.getObjectFromId(parent);
 570
 571         Integer[] children = axes.getChildren();
 572
 573         /*
 574          * Remove the last "number" created objects (located at the children
 575          * list's head) and add them to the compound in the same order
 576          */
 577         for (int i = 0; i < childrenCount; i++) {
 578             /*
 579              * Set the parent-child relationship between the Compound and each
 580              * aggregated object. Children are added to the Compound from the
 581              * least recent to the most recent, to preserve their former
 582              * ordering.
 583              */
 584             controller.setGraphicObjectRelationship(iCompound, children[childrenCount - i - 1]);
 585         }
 586
 587         controller.setGraphicObjectRelationship(parent, iCompound);
 588
 589         /*
 590          * visibility is obtained from the parent Figure, whereas it is
 591          * retrieved from the parent Axes in ConstructCompound. To be made
 592          * consistent.
 593          */
 594         Figure fig = (Figure) controller.getObjectFromId(axes.getParentFigure());
 595         controller.setProperty(iCompound, GraphicObjectProperties.__GO_VISIBLE__, fig.getVisible());
 596         return iCompound;
 597     }
 598
 599     public static int createFec(int parent, double[] zminmax, int[] colminmax, int[] colout, boolean with_mesh) {
 600
 601         GraphicController controller = GraphicController.getController();
 602         int iFec = controller.askObject(Type.FEC, false);
 603         Axes axes = (Axes) controller.getObjectFromId(parent);
 604         Fec fec = (Fec) controller.getObjectFromId(iFec);
 605
 606         fec.setZBounds(toDouble(zminmax));
 607         fec.setColorRange(toInteger(colminmax));
 608         fec.setOutsideColor(toInteger(colout));
 609
 610         fec.setVisible(axes.getVisible());
 611
 612         //clip box
 613         fec.setClipBox(axes.getClipBox());
 614         fec.setClipBoxSet(axes.getClipBoxSet());
 615         fec.setClipState(axes.getClipState());
 616
 617         cloneGraphicContext(parent, iFec);
 618
 619         fec.setLineMode(with_mesh);
 620
 621         controller.objectCreated(iFec);
 622         return iFec;
 623     }
 624
 625     public static int createGrayplot(int parent, int type, double[] pvecx, int n1, int n2) {
 626
 627         int[] objectTypes = new int[] { GraphicObjectProperties.__GO_GRAYPLOT__, GraphicObjectProperties.__GO_MATPLOT__, GraphicObjectProperties.__GO_MATPLOT__ };
 628
 629         GraphicController controller = GraphicController.getController();
 630         int iPlot = controller.askObject(GraphicObject.getTypeFromName(objectTypes[type]), false);
 631         Axes axes = (Axes) controller.getObjectFromId(parent);
 632         Imageplot plot = (Imageplot) controller.getObjectFromId(iPlot);
 633
 634         if (type == 2) { //Matplot1
 635             Double[] data = new Double[pvecx.length];
 636             for (int i = 0; i < pvecx.length; i++) {
 637                 data[i] = pvecx[i];
 638             }
 639             plot.setTranslate(data);
 640
 641             Double[] scale = new Double[2];
 642             scale[0] = (pvecx[2] - pvecx[0]) / (n2 - 1.0);
 643             scale[1] = (pvecx[3] - pvecx[1]) / (n1 - 1.0);
 644             plot.setScale(scale);
 645         }
 646
 647         plot.setVisible(axes.getVisible());
 648
 649         //clip box
 650         plot.setClipBox(axes.getClipBox());
 651         plot.setClipBoxSet(axes.getClipBoxSet());
 652         plot.setClipState(axes.getClipState());
 653
 654         cloneGraphicContext(parent, iPlot);
 655         controller.objectCreated(iPlot);
 656         return iPlot;
 657     }
 658
 659     public static int createPolyline(int parent, boolean closed, int plot, int foreground, boolean isForeground, int[] background, int mark_style, boolean isMarkStyle, int mark_foreground,
 660                                      boolean isMarkForeground, int mark_background, boolean isMarkBackground, boolean isline, boolean isfilled, boolean ismark, boolean isinterp) {
 661
 662         GraphicController controller = GraphicController.getController();
 663         int iPoly = controller.askObject(Type.POLYLINE, false);
 664         Axes axes = (Axes) controller.getObjectFromId(parent);
 665         Polyline poly = (Polyline) controller.getObjectFromId(iPoly);
 666
 667         poly.setVisible(false);
 668
 669         //clip box
 670         poly.setClipBox(axes.getClipBox());
 671         poly.setClipBoxSet(axes.getClipBoxSet());
 672         poly.setClipState(axes.getClipState());
 673
 674         poly.setClosed(closed);
 675         poly.setPolylineStyle(plot);
 676
 677         cloneGraphicContext(parent, iPoly);
 678
 679         poly.setMarkMode(ismark);
 680         poly.setLineMode(isline);
 681         poly.setFillMode(isfilled);
 682         poly.setInterpColorMode(isinterp);
 683
 684         if (isForeground) {
 685             poly.setLineColor(foreground);
 686         }
 687
 688         if (background.length != 0) {
 689             if (isinterp) {
 690                 /* 3 or 4 values to store */
 691                 Integer[] color = new Integer[background.length];
 692                 for (int i = 0; i < background.length; i++) {
 693                     color[i] = background[i];
 694                 }
 695
 696                 poly.setInterpColorVector(color);
 697             } else {
 698                 poly.setBackground(background[0]);
 699             }
 700         }
 701
 702         if (isMarkStyle) {
 703             poly.setMarkStyle(mark_style);
 704         }
 705
 706         if (isMarkForeground) {
 707             poly.setMarkForeground(mark_foreground);
 708         }
 709
 710         if (isMarkBackground) {
 711             poly.setMarkBackground(mark_background);
 712         }
 713
 714         poly.setVisible(true);
 715         controller.objectCreated(iPoly);
 716         return iPoly;
 717     }
 718
 719     public static int createLegend(int parent, String[] text, int[] handles) {
 720         GraphicController controller = GraphicController.getController();
 721         Axes axes = (Axes) controller.getObjectFromId(parent);
 722
 723         if (axes.getHasLegendChild()) {
 724             controller.removeRelationShipAndDelete(axes.getLegendChild());
 725         }
 726
 727         int iLeg = controller.askObject(Type.LEGEND, false);
 728         Legend leg = (Legend) controller.getObjectFromId(iLeg);
 729
 730         leg.setParent(parent);
 731         leg.setVisible(axes.getVisible());
 732
 733         int count = handles.length;
 734         Integer[] textDims = new Integer[2];
 735         textDims[0] = count;
 736         textDims[1] = 1;
 737
 738         leg.setTextArrayDimensions(textDims);
 739         leg.setTextStrings(text);
 740
 741         /*
 742          * Links are ordered from most recent to least recent, as their
 743          * referred-to Polylines in the latter's parent Compound object.
 744          */
 745
 746         ArrayList<Integer> links = new ArrayList<Integer>();
 747         for (int i = count - 1; i >= 0; i--) {
 748             links.add(count - i - 1, handles[i]);
 749         }
 750
 751         leg.setLinks(links);
 752
 753         leg.setClipBoxSet(false);
 754         leg.setClipState(0); //OFF
 755         leg.setClipBox(axes.getClipBox());
 756
 757         cloneGraphicContext(parent, iLeg);
 758         cloneFontContext(parent, iLeg);
 759
 760         leg.setFillMode(true);
 761
 762         controller.objectCreated(iLeg);
 763         leg.setParent(0);
 764         controller.setGraphicObjectRelationship(parent, iLeg);
 765         return iLeg;
 766     }
 767
 768     public static int createSegs(int parent, double[] vx, double[] vy, double[] vz, boolean isVZ, int[] style, double arsize) {
 769         GraphicController controller = GraphicController.getController();
 770         Axes axes = (Axes) controller.getObjectFromId(parent);
 771         int iSegs = controller.askObject(Type.SEGS, false);
 772         Segs segs = (Segs) controller.getObjectFromId(iSegs);
 773
 774         segs.setVisible(axes.getVisible());
 775
 776         //clip box
 777         segs.setClipBox(axes.getClipBox());
 778         segs.setClipBoxSet(axes.getClipBoxSet());
 779         segs.setClipState(axes.getClipState());
 780
 781         /* Segs: Nbr1/2 arrows, Nbr1 is the number of endpoints */
 782         int numberArrows = vx.length / 2;
 783
 784         segs.setNumberArrows(numberArrows);
 785         segs.setArrowSize(arsize);
 786
 787         Double[] arrowCoords = new Double[3 * numberArrows];
 788         for (int i = 0; i < numberArrows; i++) {
 789             arrowCoords[3 * i] = vx[2 * i];
 790             arrowCoords[3 * i + 1] = vy[2 * i];
 791             if (isVZ) {
 792                 arrowCoords[3 * i + 2] = vz[2 * i];
 793             } else {
 794                 arrowCoords[3 * i + 2] = 0.0;
 795             }
 796         }
 797
 798         segs.setBase(arrowCoords);
 799
 800         for (int i = 0; i < numberArrows; i++) {
 801             arrowCoords[3 * i] = vx[2 * i + 1];
 802             arrowCoords[3 * i + 1] = vy[2 * i + 1];
 803             if (isVZ) {
 804                 arrowCoords[3 * i + 2] = vz[2 * i + 1];
 805             } else {
 806                 arrowCoords[3 * i + 2] = 0.0;
 807             }
 808         }
 809
 810         segs.setDirection(arrowCoords);
 811         segs.setColors(toInteger(style));
 812
 813         cloneGraphicContext(parent, iSegs);
 814         controller.objectCreated(iSegs);
 815         controller.setGraphicObjectRelationship(parent, iSegs);
 816         return iSegs;
 817     }
 818
 819     public static int createChamp(int parent, double[] vx, double[] vy, double[] vfx, double[] vfy, double arsize, boolean typeofchamp) {
 820
 821         GraphicController controller = GraphicController.getController();
 822         Axes axes = (Axes) controller.getObjectFromId(parent);
 823
 824         int iChamp = controller.askObject(Type.CHAMP, false);
 825         Champ champ = (Champ) controller.getObjectFromId(iChamp);
 826
 827         champ.setVisible(axes.getVisible());
 828
 829         //clip box
 830         champ.setClipBox(axes.getClipBox());
 831         champ.setClipBoxSet(axes.getClipBoxSet());
 832         champ.setClipState(axes.getClipState());
 833
 834         int numberArrows = vx.length * vy.length;
 835         champ.setNumberArrows(numberArrows);
 836
 837         Integer[] dimensions = new Integer[] { vx.length, vy.length };
 838         champ.setDimensions(dimensions);
 839
 840         champ.setArrowSize(arsize);
 841
 842         Double[] arrowCoords = new Double[3 * numberArrows];
 843
 844         //convert vx Double
 845         Double[] temp = new Double[vx.length];
 846         for (int i = 0; i < vx.length; i++) {
 847             temp[i] = vx[i];
 848         }
 849         champ.setBaseX(temp);
 850
 851         //convert vy Double
 852         temp = new Double[vy.length];
 853         for (int i = 0; i < vy.length; i++) {
 854             temp[i] = vy[i];
 855         }
 856         champ.setBaseY(temp);
 857
 858         for (int i = 0; i < numberArrows; i++) {
 859             arrowCoords[3 * i] = vfx[i];
 860             arrowCoords[3 * i + 1] = vfy[i];
 861             arrowCoords[3 * i + 2] = 0.0;
 862         }
 863
 864         champ.setDirection(arrowCoords);
 865         champ.setColored(typeofchamp);
 866
 867         cloneGraphicContext(parent, iChamp);
 868
 869         controller.objectCreated(iChamp);
 870         controller.setGraphicObjectRelationship(parent, iChamp);
 871
 872         return iChamp;
 873     }
 874
 875     public static int createSurface(int parent, int typeof3d, int colorFlag, int colorMode) {
 876         GraphicController controller = GraphicController.getController();
 877         Axes axes = (Axes) controller.getObjectFromId(parent);
 878
 879         int iSurf = controller.askObject(GraphicObject.getTypeFromName(typeof3d), false);
 880         Surface surf = (Surface) controller.getObjectFromId(iSurf);
 881
 882         surf.setVisible(axes.getVisible());
 883
 884         //clip box
 885         surf.setClipBox(axes.getClipBox());
 886         surf.setClipBoxSet(axes.getClipBoxSet());
 887         surf.setClipState(axes.getClipState());
 888
 889         surf.setColorFlag(colorFlag);
 890         surf.setColorMode(colorMode);
 891
 892         surf.setHiddenColor(axes.getHiddenColor());
 893
 894         surf.setSurfaceMode(true);
 895         cloneGraphicContext(parent, iSurf);
 896         controller.objectCreated(iSurf);
 897         controller.setGraphicObjectRelationship(parent, iSurf);
 898
 899         return iSurf;
 900     }
 901
 902     public static void initSubWinTo3d(int iSubwin, String legend, boolean isLegend, int[] flag, double alpha, double theta, double[] ebox, double[] x, double[] y, double[] z) {
 903         GraphicController controller = GraphicController.getController();
 904
 905         // Force 3d view
 906         controller.setProperty(iSubwin, GraphicObjectProperties.__GO_VIEW__, 1);
 907
 908         if (isLegend) {
 909             StringTokenizer strTok = new StringTokenizer(legend, "@");
 910             int iToken = strTok.countTokens();
 911             if (iToken > 0) {
 912                 //X
 913                 String str[] = new String[] { strTok.nextToken() };
 914                 Integer label = (Integer) controller.getProperty(iSubwin, GraphicObjectProperties.__GO_X_AXIS_LABEL__);
 915                 Integer[] dims = new Integer[] { 1, 1 };
 916                 controller.setProperty(label, GraphicObjectProperties.__GO_TEXT_ARRAY_DIMENSIONS__, dims);
 917                 controller.setProperty(label, GraphicObjectProperties.__GO_TEXT_STRINGS__, str);
 918             }
 919
 920             if (iToken > 1) {
 921                 //Y
 922                 String str[] = new String[] { strTok.nextToken() };
 923                 Integer label = (Integer) controller.getProperty(iSubwin, GraphicObjectProperties.__GO_Y_AXIS_LABEL__);
 924                 Integer[] dims = new Integer[] { 1, 1 };
 925                 controller.setProperty(label, GraphicObjectProperties.__GO_TEXT_ARRAY_DIMENSIONS__, dims);
 926                 controller.setProperty(label, GraphicObjectProperties.__GO_TEXT_STRINGS__, str);
 927             }
 928
 929             if (iToken > 2) {
 930                 //Z
 931                 String str[] = new String[] { strTok.nextToken() };
 932                 Integer label = (Integer) controller.getProperty(iSubwin, GraphicObjectProperties.__GO_Z_AXIS_LABEL__);
 933                 Integer[] dims = new Integer[] { 1, 1 };
 934                 controller.setProperty(label, GraphicObjectProperties.__GO_TEXT_ARRAY_DIMENSIONS__, dims);
 935                 controller.setProperty(label, GraphicObjectProperties.__GO_TEXT_STRINGS__, str);
 936             }
 937         }
 938
 939         // Force psubwin->logflags to linear
 940         controller.setProperty(iSubwin, GraphicObjectProperties.__GO_X_AXIS_LOG_FLAG__, false);
 941         controller.setProperty(iSubwin, GraphicObjectProperties.__GO_Y_AXIS_LOG_FLAG__, false);
 942         controller.setProperty(iSubwin, GraphicObjectProperties.__GO_Z_AXIS_LOG_FLAG__, false);
 943
 944         Boolean firstPlot = (Boolean) controller.getProperty(iSubwin, GraphicObjectProperties.__GO_FIRST_PLOT__);
 945
 946         if (firstPlot && (flag[2] == 0 || flag[2] == 1)) {
 947             /* Nothing to do */
 948         } else {
 949             if (flag[2] == 0 || flag[2] == 1) {
 950                 if (firstPlot) {
 951                     controller.setProperty(iSubwin, GraphicObjectProperties.__GO_X_AXIS_VISIBLE__, false);
 952                     controller.setProperty(iSubwin, GraphicObjectProperties.__GO_Y_AXIS_VISIBLE__, false);
 953                     controller.setProperty(iSubwin, GraphicObjectProperties.__GO_Z_AXIS_VISIBLE__, false);
 954
 955                     // 0: OFF
 956                     controller.setProperty(iSubwin, GraphicObjectProperties.__GO_BOX_TYPE__, 0);
 957
 958                     Integer label = 0;
 959                     label = (Integer) controller.getProperty(iSubwin, GraphicObjectProperties.__GO_X_AXIS_LABEL__);
 960                     controller.setProperty(label, GraphicObjectProperties.__GO_VISIBLE__, false);
 961                     label = (Integer) controller.getProperty(iSubwin, GraphicObjectProperties.__GO_Y_AXIS_LABEL__);
 962                     controller.setProperty(label, GraphicObjectProperties.__GO_VISIBLE__, false);
 963                     label = (Integer) controller.getProperty(iSubwin, GraphicObjectProperties.__GO_Z_AXIS_LABEL__);
 964                     controller.setProperty(label, GraphicObjectProperties.__GO_VISIBLE__, false);
 965                 }
 966             } else if (flag[2] == 2) {
 967                 controller.setProperty(iSubwin, GraphicObjectProperties.__GO_X_AXIS_VISIBLE__, false);
 968                 controller.setProperty(iSubwin, GraphicObjectProperties.__GO_Y_AXIS_VISIBLE__, false);
 969                 controller.setProperty(iSubwin, GraphicObjectProperties.__GO_Z_AXIS_VISIBLE__, false);
 970
 971                 //2: HIDDEN_AXES
 972                 controller.setProperty(iSubwin, GraphicObjectProperties.__GO_BOX_TYPE__, 2);
 973
 974                 Integer label = 0;
 975                 label = (Integer) controller.getProperty(iSubwin, GraphicObjectProperties.__GO_X_AXIS_LABEL__);
 976                 controller.setProperty(label, GraphicObjectProperties.__GO_VISIBLE__, false);
 977                 label = (Integer) controller.getProperty(iSubwin, GraphicObjectProperties.__GO_Y_AXIS_LABEL__);
 978                 controller.setProperty(label, GraphicObjectProperties.__GO_VISIBLE__, false);
 979                 label = (Integer) controller.getProperty(iSubwin, GraphicObjectProperties.__GO_Z_AXIS_LABEL__);
 980                 controller.setProperty(label, GraphicObjectProperties.__GO_VISIBLE__, false);
 981
 982             } else if (flag[2] == 3) {
 983                 controller.setProperty(iSubwin, GraphicObjectProperties.__GO_X_AXIS_VISIBLE__, false);
 984                 controller.setProperty(iSubwin, GraphicObjectProperties.__GO_Y_AXIS_VISIBLE__, false);
 985                 controller.setProperty(iSubwin, GraphicObjectProperties.__GO_Z_AXIS_VISIBLE__, false);
 986
 987                 //1: ON
 988                 controller.setProperty(iSubwin, GraphicObjectProperties.__GO_BOX_TYPE__, 1);
 989
 990                 Integer label = 0;
 991                 label = (Integer) controller.getProperty(iSubwin, GraphicObjectProperties.__GO_X_AXIS_LABEL__);
 992                 controller.setProperty(label, GraphicObjectProperties.__GO_VISIBLE__, true);
 993                 label = (Integer) controller.getProperty(iSubwin, GraphicObjectProperties.__GO_Y_AXIS_LABEL__);
 994                 controller.setProperty(label, GraphicObjectProperties.__GO_VISIBLE__, true);
 995                 label = (Integer) controller.getProperty(iSubwin, GraphicObjectProperties.__GO_Z_AXIS_LABEL__);
 996                 controller.setProperty(label, GraphicObjectProperties.__GO_VISIBLE__, true);
 997
 998             } else if (flag[2] == 4) {
 999                 controller.setProperty(iSubwin, GraphicObjectProperties.__GO_X_AXIS_VISIBLE__, true);
1000                 controller.setProperty(iSubwin, GraphicObjectProperties.__GO_Y_AXIS_VISIBLE__, true);
1001                 controller.setProperty(iSubwin, GraphicObjectProperties.__GO_Z_AXIS_VISIBLE__, true);
1002
1003                 //1: ON
1004                 controller.setProperty(iSubwin, GraphicObjectProperties.__GO_BOX_TYPE__, 1);
1005
1006                 Integer label = 0;
1007                 label = (Integer) controller.getProperty(iSubwin, GraphicObjectProperties.__GO_X_AXIS_LABEL__);
1008                 controller.setProperty(label, GraphicObjectProperties.__GO_VISIBLE__, true);
1009                 label = (Integer) controller.getProperty(iSubwin, GraphicObjectProperties.__GO_Y_AXIS_LABEL__);
1010                 controller.setProperty(label, GraphicObjectProperties.__GO_VISIBLE__, true);
1011                 label = (Integer) controller.getProperty(iSubwin, GraphicObjectProperties.__GO_Z_AXIS_LABEL__);
1012                 controller.setProperty(label, GraphicObjectProperties.__GO_VISIBLE__, true);
1013             }
1014         }
1015
1016         Double[] rotationAngles = new Double[] { alpha, theta };
1017         controller.setProperty(iSubwin, GraphicObjectProperties.__GO_ROTATION_ANGLES__, rotationAngles);
1018
1019         Double[] dataBounds = (Double[]) controller.getProperty(iSubwin, GraphicObjectProperties.__GO_DATA_BOUNDS__);
1020         Boolean autoScale = (Boolean) controller.getProperty(iSubwin, GraphicObjectProperties.__GO_AUTO_SCALE__);
1021
1022         Double rect[] = new Double[] { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
1023         if (autoScale) {
1024             // compute and merge new specified bounds with data bounds
1025             switch (flag[1]) {
1026                 case 0:
1027                     break;
1028                 case 1:
1029                 case 3:
1030                 case 5:
1031                 case 7:
1032                     rect[0] = ebox[0]; // xmin
1033                     rect[1] = ebox[1]; // xmax
1034                     rect[2] = ebox[2]; // ymin
1035                     rect[3] = ebox[3]; // ymax
1036                     rect[4] = ebox[4]; // zmin
1037                     rect[5] = ebox[5]; // zmax
1038                     break;
1039                 case 2:
1040                 case 4:
1041                 case 6:
1042                 case 8:
1043                     double[] res = getDrect(x, rect[0], rect[1], dataBounds[0], dataBounds[1]);
1044                     rect[0] = res[0];
1045                     rect[1] = res[1];
1046
1047                     res = getDrect(y, rect[2], rect[3], dataBounds[2], dataBounds[3]);
1048                     rect[2] = res[0];
1049                     rect[3] = res[1];
1050
1051                     res = getDrect(z, rect[4], rect[5], dataBounds[4], dataBounds[5]);
1052                     rect[4] = res[0];
1053                     rect[5] = res[1];
1054                     break;
1055             }
1056
1057             if (firstPlot == false) {
1058                 rect[0] = Math.min(dataBounds[0], rect[0]); // xmin
1059                 rect[1] = Math.max(dataBounds[1], rect[1]); // xmax
1060                 rect[2] = Math.min(dataBounds[2], rect[2]); // ymin
1061                 rect[3] = Math.max(dataBounds[3], rect[3]); // ymax
1062                 rect[4] = Math.min(dataBounds[4], rect[4]); // zmin
1063                 rect[5] = Math.max(dataBounds[5], rect[5]); // zmax
1064             }
1065
1066             if (flag[1] != 0) {
1067                 controller.setProperty(iSubwin, GraphicObjectProperties.__GO_DATA_BOUNDS__, rect);
1068             }
1069         }
1070
1071         if (flag[1] != 0) {
1072             boolean isoview = (flag[1] == 3 || flag[1] == 4 || flag[1] == 5 || flag[1] == 6);
1073             controller.setProperty(iSubwin, GraphicObjectProperties.__GO_ISOVIEW__, isoview);
1074         }
1075     }
1076
1077     private static double[] getDrect(double[] x, double min, double max, double defaultMin, double defaultMax) {
1078         double refMax = Double.NEGATIVE_INFINITY;
1079         double refMin = Double.POSITIVE_INFINITY;
1080         boolean isInfinite = true;
1081
1082         for (int i = 0; i < x.length; i++) {
1083             Double tmp = x[i];
1084             if (tmp.isInfinite() == false && tmp.isNaN() == false) {
1085                 refMin = Math.min(refMin, tmp);
1086                 refMax = Math.max(refMax, tmp);
1087                 isInfinite = false;
1088             }
1089         }
1090
1091         if (isInfinite) {
1092             refMin = defaultMin;
1093             refMax = defaultMax;
1094         }
1095
1096         return new double[] { refMin, refMax };
1097     }
1098
1099     private static boolean isValidType(int type) {
1100         return type >= 0 && type <= 1;
1101     }
1102
1103     private static boolean isValidColor(double[] color) {
1104         return (color[0] >= 0.0 && color[0] <= 1.0) && (color[1] >= 0.0 && color[1] <= 1.0) && (color[2] >= 0.0 && color[2] <= 1.0);
1105     }
1106
1107     public static int createLight(int parent, int type, boolean visible, double[] pos, double[] dir, double[] ambient, double[] diffuse, double[] specular) {
1108         GraphicController controller = GraphicController.getController();
1109
1110         int iLight = controller.askObject(Type.LIGHT, false);
1111         Light light = (Light) controller.getObjectFromId(iLight);
1112
1113         light.setVisible(visible);
1114         if (isValidType(type)) {
1115             light.setLightType(LightType.intToEnum(type));
1116         }
1117
1118         if (pos.length == 3) {
1119             light.setPosition(toDouble(pos));
1120         }
1121
1122         if (dir.length == 3) {
1123             light.setDirection(toDouble(dir));
1124         }
1125         if (ambient.length == 3) {
1126             if (isValidColor(ambient)) {
1127                 light.setAmbientColor(toDouble(ambient));
1128             }
1129         }
1130         if (diffuse.length == 3) {
1131             if (isValidColor(diffuse)) {
1132                 light.setDiffuseColor(toDouble(diffuse));
1133             }
1134         }
1135         if (specular.length == 3) {
1136             if (isValidColor(specular)) {
1137                 light.setSpecularColor(toDouble(specular));
1138             }
1139         }
1140
1141         controller.objectCreated(iLight);
1142         // Set light's parent
1143         controller.setGraphicObjectRelationship(parent, iLight);
1144         return iLight;
1145     }
1146
1147     private static Double[] toDouble(double[] var) {
1148         Double[] ret = new Double[var.length];
1149         for (int i = 0; i < var.length; i++) {
1150             ret[i] = var[i];
1151         }
1152
1153         return ret;
1154     }
1155
1156     private static Integer[] toInteger(int[] var) {
1157         Integer[] ret = new Integer[var.length];
1158         for (int i = 0; i < var.length; i++) {
1159             ret[i] = var[i];
1160         }
1161
1162         return ret;
1163     }
1164 }