scilab/modules/graphics/sci_gateway/c/sci_xarrows.c

   1 /*
   2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3  * Copyright (C) 2006 - INRIA - Fabrice Leray
   4  * Copyright (C) 2006 - INRIA - Jean-Baptiste Silvy
   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 /*------------------------------------------------------------------------*/
  15 /* file: sci_xarrows.h                                                    */
  16 /* desc : interface for xarrows routine                                   */
  17 /*------------------------------------------------------------------------*/
  18
  19 #include "gw_graphics.h"
  20 #include "sciCall.h"
  21 #include "api_scilab.h"
  22 #include "localization.h"
  23 #include "Scierror.h"
  24 #include "HandleManagement.h"
  25 #include "BuildObjects.h"
  26 /*--------------------------------------------------------------------------*/
  27 int sci_xarrows(char *fname, unsigned long fname_len)
  28 {
  29     SciErr sciErr;
  30
  31     int* piAddrl1 = NULL;
  32     double* l1 = NULL;
  33     int* piAddrl2 = NULL;
  34     double* l2 = NULL;
  35     int* piAddrl3 = NULL;
  36     double* l3 = NULL;
  37     int* piAddr4 = NULL;
  38     int* l4 = NULL;
  39     double* dl4 = NULL;
  40
  41     int dstyle = -1, m1 = 0, n1 = 0, m2 = 0, n2 = 0, m3 = 1, n3 = 1;
  42     int *style = NULL, flag = 0;
  43     int m4 = 0, n4 = 0, mn2 = 0;
  44     double arsize = -1.0;
  45     double * zptr = NULL;
  46     int stylePos = 4;
  47     int *piAddr = NULL;
  48
  49     CheckInputArgument(pvApiCtx, 2, 5);
  50
  51     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1);
  52     if (sciErr.iErr)
  53     {
  54         printError(&sciErr, 0);
  55         return 1;
  56     }
  57
  58     // Retrieve a matrix of double at position 1.
  59     sciErr = getMatrixOfDouble(pvApiCtx, piAddrl1, &m1, &n1, &l1);
  60     if (sciErr.iErr)
  61     {
  62         printError(&sciErr, 0);
  63         Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
  64         return 1;
  65     }
  66
  67     sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrl2);
  68     if (sciErr.iErr)
  69     {
  70         printError(&sciErr, 0);
  71         return 1;
  72     }
  73
  74     // Retrieve a matrix of double at position 2.
  75     sciErr = getMatrixOfDouble(pvApiCtx, piAddrl2, &m2, &n2, &l2);
  76     if (sciErr.iErr)
  77     {
  78         printError(&sciErr, 0);
  79         Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2);
  80         return 1;
  81     }
  82
  83     mn2 = m2 * n2;
  84     //CheckSameDims
  85     if (m1 != m2 || n1 != n2)
  86     {
  87         Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 1, m1, n1);
  88         return 1;
  89     }
  90
  91     if (mn2 == 0)
  92     {
  93         AssignOutputVariable(pvApiCtx, 1) = 0;
  94         ReturnArguments(pvApiCtx);
  95         return 0;
  96     }
  97
  98     if (nbInputArgument(pvApiCtx) >= 3)
  99     {
 100         sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrl3);
 101         if (sciErr.iErr)
 102         {
 103             printError(&sciErr, 0);
 104             return 1;
 105         }
 106
 107         // Retrieve a matrix of double at position 3.
 108         sciErr = getMatrixOfDouble(pvApiCtx, piAddrl3, &m3, &n3, &l3);
 109         if (sciErr.iErr)
 110         {
 111             printError(&sciErr, 0);
 112             Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3);
 113             return 1;
 114         }
 115
 116         if (m3 == m1 && n3 == n1)
 117         {
 118             zptr = l3;
 119             if (nbInputArgument(pvApiCtx) >= 4)
 120             {
 121                 sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr4);
 122                 if (sciErr.iErr)
 123                 {
 124                     printError(&sciErr, 0);
 125                     return 1;
 126                 }
 127
 128                 // Retrieve a matrix of double at position 4.
 129                 sciErr = getMatrixOfDouble(pvApiCtx, piAddr4, &m4, &n4, &dl4);
 130                 if (sciErr.iErr)
 131                 {
 132                     printError(&sciErr, 0);
 133                     Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 4);
 134                     return 1;
 135                 }
 136
 137                 if (m4 != 1 || n4 != 1)
 138                 {
 139                     Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, 4);
 140                     return 1;
 141                 }
 142             }
 143             arsize = *dl4;
 144             stylePos = 5;
 145         }
 146         else if (m3 == 1 && n3 == 1)
 147         {
 148             if (nbInputArgument(pvApiCtx) > 4)
 149             {
 150                 Scierror(999, _("%s: Wrong number of input arguments: at least %d expected.\n"), fname, 4);
 151                 return 1;
 152             }
 153
 154             arsize = *l3;
 155         }
 156         else
 157         {
 158             Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix or a scalar expected.\n"), fname, 3, m1, n1);
 159             return 1;
 160         }
 161     }
 162
 163     if (nbInputArgument(pvApiCtx) >= stylePos)
 164     {
 165         sciErr = getVarAddressFromPosition(pvApiCtx, stylePos, &piAddr);
 166         if (sciErr.iErr)
 167         {
 168             printError(&sciErr, 0);
 169             return 1;
 170         }
 171
 172         // Retrieve a matrix of double at position 4 or 5.
 173         sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddr, &m4, &n4, &l4);
 174         if (sciErr.iErr)
 175         {
 176             printError(&sciErr, 0);
 177             Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, stylePos);
 178             return 1;
 179         }
 180
 181         //CheckVector
 182         if (m4 != 1 && n4 != 1)
 183         {
 184             Scierror(999, _("%s: Wrong size for input argument #%d: Vector expected.\n"), fname, stylePos);
 185             return 1;
 186         }
 187
 188         if (m4 * n4 == 1)
 189         {
 190             dstyle = *(int*)(l4);
 191         }
 192         if (m4 * n4 != 1 && m2 * n2 / 2 != m4 * n4)
 193         {
 194             Scierror(999, _("%s: Wrong size for input argument #%d: %d expected.\n"), fname, stylePos, m2 * n2 / 2);
 195             return 0;
 196         }
 197     }
 198
 199     /* NG beg */
 200     if (nbInputArgument(pvApiCtx) == stylePos && m4 * n4 != 1)
 201     {
 202         style = (int*)(l4);
 203         flag = 1;
 204     }
 205     else
 206     {
 207         style = &dstyle;
 208         flag = 0;
 209     }
 210
 211     getOrCreateDefaultSubwin();
 212
 213     Objsegs(style, flag, mn2, (l1), (l2), zptr, arsize);
 214
 215     AssignOutputVariable(pvApiCtx, 1) = 0;
 216     ReturnArguments(pvApiCtx);
 217     return 0;
 218 }
 219 /*--------------------------------------------------------------------------*/