GUI module ported to api_scilab. test_run("gui")
[scilab.git] / scilab / modules / gui / sci_gateway / cpp / sci_uiputfile.cpp
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2009 - DIGITEO - Vincent COUVERT
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 /*------------------------------------------------------------------------*/
14 /* file: sci_uiputfile.cpp                                                */
15 /* desc : interface for uiputfile routine                                 */
16 /*------------------------------------------------------------------------*/
17 #include "CallJuigetfile.hxx"
18 #include "GiwsException.hxx"
19
20 extern "C"
21 {
22 #include <string.h>
23 #include <stdio.h>
24 #include "gw_gui.h"
25 #include "PATH_MAX.h"
26 #include "api_scilab.h"
27 #include "MALLOC.h"
28 #include "localization.h"
29 #include "Scierror.h"
30 #include "expandPathVariable.h"
31 #include "freeArrayOfString.h"
32 #ifdef _MSC_VER
33 #include "strdup_windows.h"
34 #endif
35 #include "BOOL.h"
36 }
37 using namespace org_scilab_modules_gui_filechooser;
38
39 /*--------------------------------------------------------------------------*/
40
41 int sci_uiputfile(char *fname, unsigned long fname_len)
42 {
43     SciErr sciErr;
44
45     int nbRow  = 0, nbCol  = 0;
46     int nbRow2 = 0, nbCol2 = 0;
47     int nbRow3 = 0, nbCol3 = 0;
48
49     int nbRowOutSelection = 1, nbColOutSelection = 0;
50     int nbRowOutFilterIndex = 1, nbColOutFilterIndex = 1;
51     int nbRowOutPath = 1, nbColOutPath = 1;
52
53     char** mask = NULL;
54     char** description = NULL;
55
56     char* titleBox = NULL;
57     char* selectionPathName = NULL;
58     char* initialDirectory = NULL;
59
60     int multipleSelection = 0;
61
62     char **selection = NULL;
63     char **selectionFileNames = NULL;
64     int selectionSize = 0;
65     int filterIndex = 0;
66
67     char *menuCallback = NULL;
68
69     int* piAddr1 = NULL;
70     int* piAddr2 = NULL;
71     int* piAddr3 = NULL;
72
73     CheckInputArgument(pvApiCtx, 0, 3);
74     CheckOutputArgument(pvApiCtx, 1, 3);
75
76     //inputs checking
77     /* call uiputfile with 1 arg */
78     if (nbInputArgument(pvApiCtx) >= 1)
79     {
80         if (checkInputArgumentType(pvApiCtx, 1, sci_strings) == FALSE)
81         {
82             Scierror(999, _("%s: Wrong type for input argument #%d: A string matrix expected.\n"), fname, 1);
83             return 1;
84         }
85
86         sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
87         if (sciErr.iErr)
88         {
89             printError(&sciErr, 0);
90             return 1;
91         }
92
93         if (getAllocatedMatrixOfString(pvApiCtx, piAddr1, &nbRow, &nbCol, &mask))
94         {
95             printError(&sciErr, 0);
96             return 1;
97         }
98
99         if (nbCol == 1)
100         {
101             // only masks of files are provided
102             description = NULL;
103         }
104         else if (nbCol == 2)
105         {
106             // mask contains both the masks for files and the description of each mask
107             // in the sequence [m1, m2,..., mn, d1, d2,...,dn].
108             // So description is at the middle of the array.
109             description = (char **)MALLOC(sizeof(char *) * nbRow);
110             for (int i = 0; i < nbRow; i++)
111             {
112                 description[i] = strdup(mask[nbRow + i]);
113             }
114         }
115         else
116         {
117             freeAllocatedMatrixOfString(nbRow, nbCol, mask);
118             Scierror(999, _("%s: Wrong size for input argument #%d: A string matrix expected.\n"), fname, 1);
119             return 1;
120         }
121     }
122
123     /* call uiputfile with 2 arg */
124     if (nbInputArgument(pvApiCtx) >= 2)
125     {
126         char *path = NULL;
127         if (checkInputArgumentType(pvApiCtx, 2, sci_strings) == FALSE)
128         {
129             freeArrayOfString(description, nbRow);
130             freeAllocatedMatrixOfString(nbRow, nbCol, mask);
131             Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 2);
132             return 1;
133         }
134
135         sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
136         if (sciErr.iErr)
137         {
138             freeArrayOfString(description, nbRow);
139             freeAllocatedMatrixOfString(nbRow, nbCol, mask);
140             printError(&sciErr, 0);
141             return 1;
142         }
143
144         if (getAllocatedSingleString(pvApiCtx, piAddr2, &initialDirectory))
145         {
146             freeArrayOfString(description, nbRow);
147             freeAllocatedMatrixOfString(nbRow, nbCol, mask);
148             printError(&sciErr, 0);
149             return 1;
150         }
151
152         path = expandPathVariable(initialDirectory);
153         freeAllocatedSingleString(initialDirectory);
154         initialDirectory = path;
155     }
156
157     /* call uiputfile with 3 arg */
158     if (Rhs >= 3)
159     {
160         if (checkInputArgumentType(pvApiCtx, 3, sci_strings) == FALSE)
161         {
162             freeArrayOfString(description, nbRow);
163             freeAllocatedMatrixOfString(nbRow, nbCol, mask);
164             freeAllocatedSingleString(initialDirectory);
165             Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 3);
166             return 1;
167         }
168
169         sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3);
170         if (sciErr.iErr)
171         {
172             freeArrayOfString(description, nbRow);
173             freeAllocatedMatrixOfString(nbRow, nbCol, mask);
174             freeAllocatedSingleString(initialDirectory);
175             printError(&sciErr, 0);
176             return 1;
177         }
178
179         if (getAllocatedSingleString(pvApiCtx, piAddr3, &titleBox))
180         {
181             freeArrayOfString(description, nbRow);
182             freeAllocatedMatrixOfString(nbRow, nbCol, mask);
183             freeAllocatedSingleString(initialDirectory);
184             printError(&sciErr, 0);
185             return 1;
186         }
187     }
188
189     try
190     {
191         /* Call Java */
192         switch (nbInputArgument(pvApiCtx))
193         {
194             case 0:
195                 CallJuiputfileWithoutInput();
196                 break;
197
198             case 1:
199                 CallJuiputfileOnlyWithMask(mask, description, nbRow);
200                 break;
201
202             case 2:
203                 CallJuiputfileWithMaskAndInitialdirectory(mask, description, nbRow, initialDirectory);
204                 break;
205
206             case 3:
207                 CallJuiputfileWithoutMultipleSelection(mask, description, nbRow, initialDirectory, titleBox);
208                 break;
209
210             default:
211                 // never here
212                 break;
213         }
214
215         // free pointer
216         freeArrayOfString(description, nbRow);
217         freeAllocatedMatrixOfString(nbRow, nbCol, mask);
218         freeAllocatedSingleString(initialDirectory);
219         freeAllocatedSingleString(titleBox);
220
221         // Get return values
222         selection = getJuigetfileSelection();
223         selectionPathName = getJuigetfileSelectionPathName();
224         selectionFileNames = getJuigetfileSelectionFileNames();
225         selectionSize = getJuigetfileSelectionSize();
226         multipleSelection = getJuigetfileMultipleSelection();
227         filterIndex = getJuigetfileFilterIndex();
228         menuCallback = getJuigetfileMenuCallback();
229     }
230     catch (const GiwsException::JniException & e)
231     {
232         freeArrayOfString(description, nbRow);
233         freeAllocatedMatrixOfString(nbRow, nbCol, mask);
234         freeAllocatedSingleString(initialDirectory);
235         freeAllocatedSingleString(titleBox);
236         Scierror(999, _("%s: A Java exception arisen:\n%s"), fname, e.whatStr().c_str());
237         return 1;
238     }
239
240     // nbColOutSelection
241     nbColOutSelection = selectionSize;
242
243     //if cancel is selected on the filechooser
244     if (strcmp(selection[0], "") == 0)
245     {
246         // "" is returned as filename
247         sciErr = createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 1, 1, selection);
248         if (sciErr.iErr)
249         {
250             printError(&sciErr, 0);
251             Scierror(999, _("%s: Memory allocation error.\n"), fname);
252             return 1;
253         }
254
255         AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
256
257         if (nbOutputArgument(pvApiCtx) > 1)
258         {
259             // "" is returned as pathname
260             sciErr = createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 2, 1, 1, selection);
261             if (sciErr.iErr)
262             {
263                 printError(&sciErr, 0);
264                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
265                 return 1;
266             }
267
268             AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
269         }
270
271         if (nbOutputArgument(pvApiCtx) > 2)
272         {
273             // 0 is returned as pathname
274             double tmp = 0;
275             sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 3, 1, 1, &tmp);
276             if (sciErr.iErr)
277             {
278                 printError(&sciErr, 0);
279                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
280                 return 1;
281             }
282
283             AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx) + 3;
284         }
285
286         returnArguments(pvApiCtx);
287         return 0;
288     }
289
290     // Only one output then it contains path+filenames
291     if (nbOutputArgument(pvApiCtx) == 1)
292     {
293         sciErr = createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRowOutSelection, nbColOutSelection, selection);
294         if (sciErr.iErr)
295         {
296             printError(&sciErr, 0);
297             Scierror(999, _("%s: Memory allocation error.\n"), fname);
298             return 1;
299         }
300
301         AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
302         returnArguments(pvApiCtx);
303         return 0;
304     }
305
306     // More than one output
307     sciErr = createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRowOutSelection, nbColOutSelection, selectionFileNames);
308     if (sciErr.iErr)
309     {
310         printError(&sciErr, 0);
311         Scierror(999, _("%s: Memory allocation error.\n"), fname);
312         return 1;
313     }
314
315     if (createSingleString(pvApiCtx, nbInputArgument(pvApiCtx) + 2, selectionPathName))
316     {
317         printError(&sciErr, 0);
318         return 1;
319     }
320
321     AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
322     AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
323
324     if (nbOutputArgument(pvApiCtx) > 2)
325     {
326         if (createScalarDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 3, filterIndex))
327         {
328             printError(&sciErr, 0);
329             return 1;
330         }
331         AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx) + 3;
332     }
333
334     returnArguments(pvApiCtx);
335     return 0;
336
337 }
338
339 /*--------------------------------------------------------------------------*/