By default, the quality of JPG is now 95 instead of 75
[scilab.git] / scilab / modules / graphic_export / src / c / xs2file.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  * Copyright (C) 2009 - DIGITEO - Allan CORNET
6  * desc : interface for xs2file routine
7  * 
8  * This file must be used under the terms of the CeCILL.
9  * This source file is licensed as described in the file COPYING, which
10  * you should have received as part of this distribution.  The terms
11  * are also available at    
12  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
13  *
14  */
15
16 #include <string.h>
17 #include <stdio.h>
18
19 #include "xs2file.h"
20 #include "stack-c.h"
21 #include "GetProperty.h"
22 #include "WindowList.h"
23 #include "IsAScalar.h"
24 #include "CurrentObjectsManagement.h"
25 #include "localization.h"
26 #include "SetJavaProperty.h"
27 #include "Scierror.h"
28 #include "expandPathVariable.h"
29 #include "PATH_MAX.h"
30 #include "MALLOC.h"
31 #include "freeArrayOfString.h"
32 #include "HandleManagement.h"
33 #include "GraphicSynchronizerInterface.h"
34 #include "../../../graphics/src/c/getHandleProperty/getPropertyAssignedValue.h"
35 /*--------------------------------------------------------------------------*/
36 static BOOL isVectorialExport(ExportFileType fileType);
37 /*--------------------------------------------------------------------------*/
38 int xs2file(char * fname, ExportFileType fileType )
39 {
40   /* Check input and output sizes */
41   CheckLhs(0,1);
42   if (isVectorialExport(fileType) || fileType == JPG_EXPORT)
43     {
44       CheckRhs(2,3);
45     }
46   else
47     {
48       CheckRhs(2,2);
49     }
50
51   if (GetType(1) != sci_matrix && GetType(1) != sci_handles)
52     {
53       Scierror(999,_("%s: Wrong type for input argument #%d: An integer or a handle expected.\n"),fname, 1);
54       LhsVar(1) = 0;
55       C2F(putlhsvar)();
56       return 0;
57     }
58
59   if ( (GetType(2) == sci_strings) )
60     {   
61       char **fileName = NULL;
62       char *real_filename = NULL;
63       float jpegCompressionQuality = 0.95f;
64       ExportOrientation orientation = EXPORT_PORTRAIT; /* default orientation */
65       long int lout = 0;
66       int out_n = 0;
67       int m1 = 0, n1 = 0, l1 = 0;
68       int figurenum = -1;
69       sciPointObj* figurePtr = NULL;
70       int status = 0;
71
72       /* get handle by figure number */
73       if(GetType(1) == sci_matrix)
74         {
75           GetRhsVar(1,MATRIX_OF_INTEGER_DATATYPE,&m1,&n1,&l1);
76           if(m1*n1 != 1)
77             {
78               Scierror(999,_("%s: Wrong size for input argument #%d: A scalar expected.\n"),fname, 1);        
79               LhsVar(1) = 0;
80               C2F(putlhsvar)();
81               return 0;
82             }
83
84           figurenum = *istk(l1);
85           if (!sciIsExistingFigure(figurenum))
86             {
87               Scierror(999, "%s: Input argument #%d must be a valid figure_id.\n",fname, 1);
88               LhsVar(1) = 0;
89               C2F(putlhsvar)();
90               return 0;
91             }
92           figurePtr = getFigureFromIndex(figurenum);
93         }
94       /* check given handle */
95       if(GetType(1) == sci_handles)
96         {
97           GetRhsVar(1,GRAPHICAL_HANDLE_DATATYPE,&m1,&n1,&l1);
98           if(m1*n1 != 1)
99             {
100               Scierror(999,_("%s: Wrong size for input argument #%d: A graphic handle expected.\n"),fname, 1);        
101               LhsVar(1) = 0;
102               C2F(putlhsvar)();
103               return 0;
104             }
105           figurePtr = sciGetPointerFromHandle(getHandleFromStack(l1));
106
107           if(figurePtr == NULL)
108             {
109               Scierror(999, "%s: Input argument #%d must be a valid handle.\n",fname, 1);
110               LhsVar(1) = 0;
111               C2F(putlhsvar)();
112               return 0;        
113             }
114           startFigureDataReading(figurePtr);
115           if(sciGetEntityType(figurePtr)!=SCI_FIGURE)
116             {
117               Scierror(999, "%s: Input argument #%d must be a handle on a figure.\n", fname, 1);
118               LhsVar(1) = 0;
119               C2F(putlhsvar)();
120               return 0;        
121             }
122           endFigureDataReading(figurePtr);
123         }
124
125       /* get file name */
126       GetRhsVar(2,MATRIX_OF_STRING_DATATYPE,&m1,&n1,&fileName);
127       if (m1*n1 == 1)
128         {
129           if (Rhs == 3)
130             {
131               int nbCol = 0;
132               int nbRow = 0;
133               
134               if (isVectorialExport(fileType))
135                 {
136
137                   char **sciOrientation = NULL;
138                   
139                   if (GetType(3) != sci_strings)
140                     {
141                       freeArrayOfString(fileName,m1*n1);
142                       Scierror(999,_("%s: Wrong type for input argument #%d: Single character string expected.\n"),fname, 3);
143                       return 0;
144                     }
145                   
146                   GetRhsVar(3,MATRIX_OF_STRING_DATATYPE,&nbRow,&nbCol,&sciOrientation);
147                   if (nbRow*nbCol == 1)
148                     {
149                       /* Value should be 'landscape' or 'portrait' but check only the first character */
150                       /* for compatibility with Scilab 4*/
151                       if (strcmp(sciOrientation[0], "landscape") == 0 || strcmp(sciOrientation[0], "l") == 0)
152                         {
153                           freeArrayOfString(sciOrientation,nbRow*nbCol);
154                           orientation = EXPORT_LANDSCAPE;
155                         }
156                       else if(strcmp(sciOrientation[0], "portrait") == 0 || strcmp(sciOrientation[0], "p") == 0)
157                         {
158                           freeArrayOfString(sciOrientation,nbRow*nbCol);
159                           orientation = EXPORT_PORTRAIT;
160                         }
161                       else
162                         {
163                           freeArrayOfString(fileName,m1*n1);
164                           freeArrayOfString(sciOrientation,nbRow*nbCol);
165                           Scierror(999,_("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"),fname, 3, "portrait", "landscape");
166                           return 0;
167                         }
168                     }
169                   else
170                     {
171                       freeArrayOfString(fileName,m1*n1);
172                       freeArrayOfString(sciOrientation,nbRow*nbCol);
173                       Scierror(999,_("%s: Wrong size for input argument #%d: Single character string expected.\n"),fname, 3);
174                       return 0;
175                     }
176                 }
177               else
178                 {
179                   int quality = 0;
180                   GetRhsVar(3, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &quality);
181                   if (nbRow != 1 || nbCol != 1 || *stk(quality) < 0 || *stk(quality) > 1)
182                     {
183                       freeArrayOfString(fileName, m1 * n1);
184                       Scierror(999,_("%s: Wrong type for input argument #%d: A real between 0 and 1 expected.\n"),fname, 3);
185                       return 0;
186                     }
187                   jpegCompressionQuality = (float) *stk(quality);
188                 }
189             }
190
191           /* Replaces SCI, ~, HOME, TMPDIR by the real path */
192           real_filename = expandPathVariable(fileName[0]);
193
194           /* Call the function for exporting file */
195           status = exportToFile(figurePtr, real_filename, fileType, jpegCompressionQuality, orientation);
196           
197           /* free pointers no more used */
198           if (real_filename)
199             {
200               FREE(real_filename);
201               real_filename = NULL;
202             }
203           freeArrayOfString(fileName,m1*n1);
204
205           /* treat errors */
206           switch(status)
207             {
208             case EXPORT_UNKNOWN_GLEXCEPTION_ERROR :
209               Scierror(999,_("%s: OpenGL error during export.\n"),fname);
210               return 0;
211             case EXPORT_IOEXCEPTION_ERROR :
212               Scierror(999,_("%s: Unable to create export file, permission denied.\n"),fname);
213               return 0;
214             case EXPORT_INVALID_FILE :
215               Scierror(999,_("%s: Unable to create export file, invalid file.\n"),fname);
216               return 0;
217             case EXPORT_GL2PS_ERROR :
218               Scierror(999,_("%s: GL2PS error during export.\n"),fname);
219               return 0;
220             case EXPORT_GL2PS_OVERFLOW :
221               Scierror(999,_("%s: Unable to create export file, figure is too big.\n"),fname);
222               return 0;
223             case EXPORT_GL2PS_UNINITIALIZED :
224               Scierror(999,_("%s: GL2PS error during export.\n"),fname);
225               return 0;
226             default :
227               // NO ERROR
228               break;
229             }
230         }
231       else
232         {
233           freeArrayOfString(fileName,m1*n1);
234           Scierror(999,_("%s: Wrong size for input argument #%d: Single character string expected.\n"),fname, 2);
235           return 0;
236         }
237     }
238   else
239     {
240       Scierror(999,_("%s: Wrong type for input argument #%d: Single character string expected.\n"),fname, 2);
241       return 0;
242     }
243
244   LhsVar(1) = 0;
245   C2F(putlhsvar)();
246   return 0;
247 }
248 /*--------------------------------------------------------------------------*/
249 static BOOL isVectorialExport(ExportFileType fileType)
250 {
251   return fileType == EPS_EXPORT
252     || fileType == PS_EXPORT
253     || fileType == PDF_EXPORT
254     || fileType == SVG_EXPORT;
255 }
256 /*--------------------------------------------------------------------------*/