8d186e3dab066048884d6eb859e8052b1e149590
[scilab.git] / scilab / modules / gui / sci_gateway / cpp / sci_toprint.cpp
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) INRIA - Allan CORNET
4  * Copyright (C) 2008 - INRIA - Vincent COUVERT (Java version)
5  * Copyright (C) 2011 - DIGITEO - Allan CORNET
6  *
7  * This file must be used under the terms of the CeCILL.
8  * This source file is licensed as described in the file COPYING, which
9  * you should have received as part of this distribution.  The terms
10  * are also available at
11  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
12  *
13 */
14
15 /*--------------------------------------------------------------------------*/
16 #include "CallScilabBridge.hxx"
17 #include "GiwsException.hxx"
18
19 extern "C"
20 {
21 #include "api_scilab.h"
22 #include "sci_malloc.h"
23 #include "sciprint.h"
24 #include "Scierror.h"
25 #include "FileExist.h"
26 #include "freeArrayOfString.h"
27 #include "localization.h"
28 #include "gw_gui.h"
29 #include "getScilabJavaVM.h"
30 #include "getFullFilename.h"
31 #include "loadOnUseClassPath.h"
32 #include "configvariable_interface.h"
33 #include "FigureList.h"
34 }
35 /*--------------------------------------------------------------------------*/
36 static BOOL loadedDep = FALSE;
37
38 /*--------------------------------------------------------------------------*/
39 using namespace org_scilab_modules_gui_bridge;
40
41 /*--------------------------------------------------------------------------*/
42 static int sci_toprint_one_rhs(void* _pvCtx, const char *fname);
43 static int sci_toprint_two_rhs(void* _pvCtx, const char *fname);
44 /*--------------------------------------------------------------------------*/
45 int sci_toprint(char *fname, void* pvApiCtx)
46 {
47     CheckInputArgument(pvApiCtx, 1, 2);
48     CheckOutputArgument(pvApiCtx, 0, 1);
49
50     if (!loadedDep)
51     {
52         loadOnUseClassPath("pdf_ps_eps_graphic_export");
53         loadedDep = TRUE;
54     }
55
56     if (nbInputArgument(pvApiCtx) == 1)
57     {
58         return sci_toprint_one_rhs(pvApiCtx, fname);
59     }
60     else
61     {
62         return sci_toprint_two_rhs(pvApiCtx, fname);
63     }
64     return 0;
65 }
66
67 /*--------------------------------------------------------------------------*/
68 static int sci_toprint_one_rhs(void* _pvCtx, const char *fname)
69 {
70     SciErr sciErr;
71     int *piAddressVarOne = NULL;
72
73     sciErr = getVarAddressFromPosition(_pvCtx, 1, &piAddressVarOne);
74     if (sciErr.iErr)
75     {
76         printError(&sciErr, 0);
77         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
78         return 1;
79     }
80
81     if (isStringType(_pvCtx, piAddressVarOne))
82     {
83         char *fileName = NULL;
84         BOOL iRet = FALSE;
85
86         if (getAllocatedSingleString(_pvCtx, piAddressVarOne, &fileName) == 0)
87         {
88             char *fullName = getFullFilename(fileName);
89
90             freeAllocatedSingleString(fileName);
91             if (fullName)
92             {
93                 if (FileExist(fullName))
94                 {
95                     try
96                     {
97                         iRet = booltoBOOL(CallScilabBridge::printFile(getScilabJavaVM(), fullName));
98                     }
99                     catch (const GiwsException::JniException & e)
100                     {
101                         FREE(fullName);
102                         fullName = NULL;
103                         Scierror(999, _("%s: An exception occurred: %s\n%s\n"), fname, e.getJavaDescription().c_str(),
104                                  e.getJavaExceptionName().c_str());
105                         return 1;
106                     }
107                 }
108                 else
109                 {
110                     if (getWarningMode())
111                     {
112                         sciprint(_("%s: The file %s does not exist.\n"), fname, fullName);
113                     }
114                     iRet = FALSE;
115                 }
116                 FREE(fullName);
117                 fullName = NULL;
118             }
119
120             createScalarBoolean(_pvCtx, nbInputArgument(_pvCtx) + 1, iRet);
121             AssignOutputVariable(_pvCtx, 1) = nbInputArgument(_pvCtx) + 1;
122             ReturnArguments(_pvCtx);
123             return 0;
124         }
125         else
126         {
127             Scierror(999, _("%s: Memory allocation error.\n"), fname);
128         }
129     }
130     else if (isDoubleType(_pvCtx, piAddressVarOne))
131     {
132         if (isScalar(_pvCtx, piAddressVarOne))
133         {
134             double dValue = 0.;
135
136             if (!getScalarDouble(_pvCtx, piAddressVarOne, &dValue))
137             {
138                 int num_win = (int)dValue;
139                 BOOL iRet = FALSE;
140
141                 if (num_win < 0)
142                 {
143                     Scierror(999, _("%s: Wrong value for input argument #%d: Positive integers expected.\n"), fname);
144                     return 1;
145                 }
146
147                 if (getFigureFromIndex((int) num_win) == NULL)
148                 {
149                     Scierror(999, "%s: Figure with figure_id %d does not exist.\n", fname, (int)num_win);
150                     return 1;
151                 }
152
153                 try
154                 {
155                     iRet = booltoBOOL(CallScilabBridge::printFigure(getScilabJavaVM(), getFigureFromIndex((int) num_win), FALSE, FALSE));
156                 }
157                 catch (const GiwsException::JniException & e)
158                 {
159                     Scierror(999, _("%s: An exception occurred: %s\n%s\n"), fname, e.getJavaDescription().c_str(), e.getJavaExceptionName().c_str());
160                     return 1;
161                 }
162
163                 createScalarBoolean(_pvCtx, nbInputArgument(_pvCtx) + 1, iRet);
164                 AssignOutputVariable(_pvCtx, 1) = nbInputArgument(_pvCtx) + 1;
165                 ReturnArguments(_pvCtx);
166                 return 0;
167             }
168             else
169             {
170                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
171             }
172         }
173         else
174         {
175             Scierror(999, _("%s: Wrong size for input argument #%d: Positive integer expected.\n"), fname, 1);
176         }
177     }
178     else
179     {
180         Scierror(999, _("%s: Wrong type for input argument #%d.\n"), fname, 1);
181     }
182     return 1;
183 }
184
185 /*--------------------------------------------------------------------------*/
186 static int sci_toprint_two_rhs(void* _pvCtx, const char *fname)
187 {
188     SciErr sciErr;
189     int *piAddressVarOne = NULL;
190     int *piAddressVarTwo = NULL;
191
192     sciErr = getVarAddressFromPosition(_pvCtx, 1, &piAddressVarOne);
193     if (sciErr.iErr)
194     {
195         printError(&sciErr, 0);
196         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
197         return 1;
198     }
199
200     sciErr = getVarAddressFromPosition(_pvCtx, 2, &piAddressVarTwo);
201     if (sciErr.iErr)
202     {
203         printError(&sciErr, 0);
204         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
205         return 1;
206     }
207
208     if (isStringType(_pvCtx, piAddressVarOne))
209     {
210         if (isScalar(_pvCtx, piAddressVarTwo))
211         {
212             if (isStringType(_pvCtx, piAddressVarTwo))
213             {
214                 char *pageHeader = NULL;
215                 char **pStVarOne = NULL;
216                 int *lenStVarOne = NULL;
217                 int mOne = 0, nOne = 0;
218                 int mnOne = 0;
219                 int lenLineToPrint = 0;
220                 int i = 0;
221                 char *lines = NULL;
222
223                 sciErr = getMatrixOfString(_pvCtx, piAddressVarOne, &mOne, &nOne, NULL, NULL);
224                 if (sciErr.iErr)
225                 {
226                     printError(&sciErr, 0);
227                     Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
228                     return 1;
229                 }
230
231                 if (!((mOne == 1) || (nOne == 1)))
232                 {
233                     Scierror(999, _("%s: Wrong size for input argument #%d: A 1-by-n or m-by-1 array expected.\n"), fname, 1);
234                     return 1;
235                 }
236
237                 mnOne = mOne * nOne;
238
239                 lenStVarOne = (int *)MALLOC(sizeof(int) * mnOne);
240                 if (lenStVarOne == NULL)
241                 {
242                     Scierror(999, _("%s: No more memory.\n"), fname);
243                     return 1;
244                 }
245
246                 sciErr = getMatrixOfString(_pvCtx, piAddressVarOne, &mOne, &nOne, lenStVarOne, NULL);
247                 if (sciErr.iErr)
248                 {
249                     printError(&sciErr, 0);
250                     Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
251                     return 1;
252                 }
253
254                 for (i = 0; i < mnOne; i++)
255                 {
256                     lenLineToPrint = lenLineToPrint + lenStVarOne[i] + (int)strlen("\n") + 1;
257                 }
258
259                 pStVarOne = (char **)MALLOC(sizeof(char *) * mnOne);
260                 if (pStVarOne == NULL)
261                 {
262                     FREE(lenStVarOne);
263                     lenStVarOne = NULL;
264                     Scierror(999, _("%s: No more memory.\n"), fname);
265                     return 1;
266                 }
267
268                 for (i = 0; i < mnOne; i++)
269                 {
270                     pStVarOne[i] = (char *)MALLOC(sizeof(char) * (lenStVarOne[i] + 1));
271                     if (pStVarOne[i] == NULL)
272                     {
273                         freeArrayOfString(pStVarOne, i);
274                         if (lenStVarOne)
275                         {
276                             FREE(lenStVarOne);
277                             lenStVarOne = NULL;
278                         }
279                         Scierror(999, _("%s: No more memory.\n"), fname);
280                         return 1;
281                     }
282                 }
283
284                 sciErr = getMatrixOfString(_pvCtx, piAddressVarOne, &mOne, &nOne, lenStVarOne, pStVarOne);
285                 if (lenStVarOne)
286                 {
287                     FREE(lenStVarOne);
288                     lenStVarOne = NULL;
289                 }
290                 if (sciErr.iErr)
291                 {
292                     freeArrayOfString(pStVarOne, mnOne);
293                     printError(&sciErr, 0);
294                     Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
295                     return 1;
296                 }
297
298                 lines = (char *)MALLOC((lenLineToPrint + 1) * sizeof(char));
299                 if (lines == NULL)
300                 {
301                     freeArrayOfString(pStVarOne, mnOne);
302                     Scierror(999, _("%s: No more memory.\n"), fname);
303                     return 1;
304                 }
305
306                 for (i = 0; i < mnOne; i++)
307                 {
308                     if (i == 0)
309                     {
310                         sprintf(lines, "%s\n", pStVarOne[i]);
311                     }
312                     else
313                     {
314                         sprintf(lines, "%s%s\n", lines, pStVarOne[i]);
315                     }
316                 }
317                 freeArrayOfString(pStVarOne, mnOne);
318
319                 if (getAllocatedSingleString(_pvCtx, piAddressVarTwo, &pageHeader) == 0)
320                 {
321                     BOOL iRet = FALSE;
322
323                     try
324                     {
325                         iRet = booltoBOOL(CallScilabBridge::printString(getScilabJavaVM(), lines, pageHeader));
326                     }
327
328                     catch (const GiwsException::JniException & e)
329                     {
330                         freeAllocatedSingleString(pageHeader);
331                         if (lines)
332                         {
333                             FREE(lines);
334                             lines = NULL;
335                         }
336                         Scierror(999, _("%s: An exception occurred: %s\n%s\n"), fname, e.getJavaDescription().c_str(),
337                                  e.getJavaExceptionName().c_str());
338                         return 1;
339                     }
340
341                     freeAllocatedSingleString(pageHeader);
342                     if (lines)
343                     {
344                         FREE(lines);
345                         lines = NULL;
346                     }
347
348                     createScalarBoolean(_pvCtx, nbInputArgument(_pvCtx) + 1, iRet);
349                     AssignOutputVariable(_pvCtx, 1) = nbInputArgument(_pvCtx) + 1;
350                     ReturnArguments(_pvCtx);
351                     return 0;
352                 }
353                 else
354                 {
355                     if (lines)
356                     {
357                         FREE(lines);
358                         lines = NULL;
359                     }
360                     Scierror(999, _("%s: Memory allocation error.\n"), fname);
361                 }
362             }
363             else
364             {
365                 Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), fname, 2);
366             }
367         }
368         else
369         {
370             Scierror(999, _("%s: Wrong size for input argument #%d: String expected.\n"), fname, 2);
371         }
372     }
373     else if (isDoubleType(_pvCtx, piAddressVarOne))
374     {
375         if (isScalar(_pvCtx, piAddressVarOne))
376         {
377             int num_win = 0;
378             double dValue = 0.;
379
380             if (!getScalarDouble(_pvCtx, piAddressVarOne, &dValue))
381             {
382                 num_win = (int)dValue;
383
384                 if (num_win < 0)
385                 {
386                     Scierror(999, _("%s: Wrong value for input argument #%d: Positive integers expected.\n"), fname);
387                     return 1;
388                 }
389             }
390             else
391             {
392                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
393                 return 1;
394             }
395
396             if (!sciIsExistingFigure((int)num_win))
397             {
398                 Scierror(999, "%s: Figure with figure_id %d does not exist.\n", fname, (int)num_win);
399                 return 1;
400             }
401
402             if (isStringType(_pvCtx, piAddressVarTwo))
403             {
404                 BOOL iRet = FALSE;
405
406                 if (isScalar(_pvCtx, piAddressVarTwo))
407                 {
408                     char *outputType = NULL;
409
410                     if (getAllocatedSingleString(_pvCtx, piAddressVarTwo, &outputType) == 0)
411                     {
412                         if ((strcmp(outputType, "pos") == 0) || (strcmp(outputType, "gdi") == 0))
413                         {
414                             try
415                             {
416                                 if (strcmp(outputType, "pos") == 0)
417                                 {
418                                     iRet = booltoBOOL(CallScilabBridge::printFigure(getScilabJavaVM(), getFigureFromIndex(num_win), TRUE, FALSE));
419                                 }
420                                 else
421                                 {
422                                     iRet = booltoBOOL((int)CallScilabBridge::printFigure(getScilabJavaVM(), getFigureFromIndex(num_win), FALSE, FALSE));
423                                 }
424                             }
425                             catch (const GiwsException::JniException & e)
426                             {
427                                 Scierror(999, _("%s: An exception occurred: %s\n%s\n"), fname, e.getJavaDescription().c_str(),
428                                          e.getJavaExceptionName().c_str());
429                                 freeAllocatedSingleString(outputType);
430                                 return 1;
431                             }
432
433                             createScalarBoolean(_pvCtx, nbInputArgument(_pvCtx) + 1, iRet);
434                             AssignOutputVariable(_pvCtx, 1) = nbInputArgument(_pvCtx) + 1;
435                             ReturnArguments(_pvCtx);
436                             return 0;
437                         }
438                         else
439                         {
440                             Scierror(999, _("%s: Wrong input argument #%d: '%s' or '%s' expected.\n"), fname, 2, "pos", "gdi");
441                         }
442                         freeAllocatedSingleString(outputType);
443                     }
444                     else
445                     {
446                         Scierror(999, _("%s: Memory allocation error.\n"), fname);
447                     }
448                 }
449                 else
450                 {
451                     Scierror(999, _("%s: Wrong size for input argument #%d: 'pos' or 'gdi' value expected.\n"), fname, 2);
452                 }
453             }
454             else
455             {
456                 Scierror(999, _("%s: Wrong type for input argument #%d.\n"), fname, 2);
457             }
458         }
459         else
460         {
461             Scierror(999, _("%s: Wrong size for input argument #%d: Positive integer expected.\n"), fname, 1);
462         }
463     }
464     else
465     {
466         Scierror(999, _("%s: Wrong type for input argument #%d.\n"), fname, 1);
467     }
468     return 1;
469 }
470
471 /*--------------------------------------------------------------------------*/