utf: windows_tools 2
[scilab.git] / scilab / modules / windows_tools / src / c / scilab_windows / FilesAssociations.c
1 /*
2 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 * Copyright (C) INRIA - Allan CORNET
4 * Copyright (C) DIGITEO - 2009-2010 - Allan CORNET
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 #include <stdio.h>
16 #include <stdlib.h>
17 #include <string.h>
18 #include <stdarg.h>
19 #include "TextToPrint.h"
20 #include <windows.h>
21 #include <Winuser.h>
22 #include <shlwapi.h>
23 #include "version.h"
24 #include "FilesAssociations.h"
25 #include "sci_malloc.h"
26 #include "FindScilab.h"
27 #include "wmcopydata.h"
28 #include "os_string.h"
29 #include "MutexClosingScilab.h"
30 #include "with_module.h"
31 #include "FileExist.h"
32 #include "getshortpathname.h"
33 /*--------------------------------------------------------------------------*/
34 static void ReplaceSlash(char *pathout, char *pathin);
35 static void ExtensionFileIntoLowerCase(char *fichier);
36 static BOOL isGoodExtension(char *chainefichier, char *ext);
37 static BOOL IsAScicosFileCOS(char *chainefichier);
38 static BOOL IsAScicosFileCOSF(char *chainefichier);
39 static BOOL IsAScicosFileXCOS(char *chainefichier);
40 static BOOL IsAScicosFileZCOS(char *chainefichier);
41 static BOOL IsASciNotesFileSCE(char *chainefichier);
42 static BOOL IsASciNotesFileSCI(char *chainefichier);
43 static BOOL IsASciNotesFileTST(char *chainefichier);
44 /*--------------------------------------------------------------------------*/
45 #define MSG_SCIMSG1 "%s -e load(getlongpathname('%s'));disp(getlongpathname('%s')+ascii(32)+'loaded');"
46 #define MSG_SCIMSG2_XCOS "%s -e xcos(getlongpathname('%s'));"
47 #define MSG_SCIMSG3_XCOS "execstr('xcos(getlongpathname(''%s''));','errcatch');"
48 #define MSG_SCIMSG4 "%s -e exec(getlongpathname('%s'));"
49 #define MSG_SCIMSG5_EDITOR "%s -e editor(getlongpathname('%s'));"
50 /* we try to launch scilab editor */
51 #define MSG_SCIMSG6_EDITOR "execstr('editor(getlongpathname(''%s''));','errcatch');"
52 #define MSG_SCIMSG7 "Scilab Communication"
53 /*--------------------------------------------------------------------------*/
54 /* Teste si le fichier a une extension .sav ou .bin*/
55 /* retourne TRUE si c'est le cas sinon FALSE */
56 BOOL IsABinOrSavFile(char *chainefichier)
57 {
58     if (isGoodExtension(chainefichier, ".BIN") || isGoodExtension(chainefichier, ".SAV")
59             || isGoodExtension(chainefichier, ".SOD"))
60     {
61         return TRUE;
62     }
63     return FALSE;
64 }
65 /*--------------------------------------------------------------------------*/
66 BOOL IsAScicosFile(char *chainefichier)
67 {
68     if (IsAScicosFileCOS(chainefichier) ||
69             IsAScicosFileCOSF(chainefichier) ||
70             IsAScicosFileXCOS(chainefichier) ||
71             IsAScicosFileZCOS(chainefichier))
72     {
73         return TRUE;
74     }
75     return FALSE;
76 }
77 /*--------------------------------------------------------------------------*/
78 BOOL IsAScicosFileCOS(char *chainefichier)
79 {
80     return isGoodExtension(chainefichier, ".COS");
81 }
82 /*--------------------------------------------------------------------------*/
83 BOOL IsAScicosFileCOSF(char *chainefichier)
84 {
85     return isGoodExtension(chainefichier, ".COSF");
86 }
87 /*--------------------------------------------------------------------------*/
88 BOOL IsAScicosFileXCOS(char *chainefichier)
89 {
90     return isGoodExtension(chainefichier, ".XCOS");
91 }
92 /*--------------------------------------------------------------------------*/
93 BOOL IsAScicosFileZCOS(char *chainefichier)
94 {
95     return isGoodExtension(chainefichier, ".ZCOS");
96 }
97 /*--------------------------------------------------------------------------*/
98 BOOL IsASciNotesFile(char *chainefichier)
99 {
100     if (IsASciNotesFileSCE(chainefichier) ||
101             IsASciNotesFileSCI(chainefichier) ||
102             IsASciNotesFileTST(chainefichier))
103     {
104         return TRUE;
105     }
106     return FALSE;
107 }
108 /*--------------------------------------------------------------------------*/
109 BOOL IsASciNotesFileSCE(char *chainefichier)
110 {
111     return isGoodExtension(chainefichier, ".SCE");
112 }
113 /*--------------------------------------------------------------------------*/
114 BOOL IsASciNotesFileSCI(char *chainefichier)
115 {
116     return isGoodExtension(chainefichier, ".SCI");
117 }
118 /*--------------------------------------------------------------------------*/
119 BOOL IsASciNotesFileTST(char *chainefichier)
120 {
121     return isGoodExtension(chainefichier, ".TST");
122 }
123 /*--------------------------------------------------------------------------*/
124 int CommandByFileExtension(char *fichier, int OpenCode, char *Cmd)
125 {
126     int ReturnedValue = 0;
127     if (FileExist(fichier))
128     {
129         BOOL bConverted = FALSE;
130         char FinalFileName[(MAX_PATH * 2) + 1];
131         char *ShortPath = NULL;
132         char PathWScilex[(MAX_PATH * 2) + 1];
133
134
135         /* Recuperation du nom du fichier au format 8.3 */
136         ShortPath = getshortpathname(fichier, &bConverted);
137         GetShortPathName(fichier, ShortPath, MAX_PATH);
138         ReplaceSlash(FinalFileName, ShortPath);
139         if (ShortPath)
140         {
141             FREE(ShortPath);
142             ShortPath = NULL;
143         }
144
145         GetModuleFileName ((HINSTANCE)GetModuleHandle(NULL), PathWScilex, MAX_PATH);
146         ReturnedValue = 1;
147
148         switch (OpenCode)
149         {
150             case 0:
151             default: /* -O Open file with editor */
152             {
153                 if (!HaveAnotherWindowScilab() || haveMutexClosingScilab())
154                 {
155                     if (with_module("scinotes"))
156                     {
157                         wsprintf(Cmd, MSG_SCIMSG5_EDITOR, PathWScilex, FinalFileName);
158                     }
159                     else
160                     {
161                         MessageBox(NULL, "Please install editor module.", "Error", MB_ICONSTOP);
162                         exit(0);
163                     }
164                 }
165                 else
166                 {
167                     char *ScilabDestination = NULL;
168
169                     if (with_module("scinotes"))
170                     {
171                         wsprintf(Cmd, MSG_SCIMSG6_EDITOR, FinalFileName);
172                     }
173                     else
174                     {
175                         MessageBox(NULL, "Please install editor module.", "Error", MB_ICONSTOP);
176                         exit(0);
177                     }
178
179                     ScilabDestination = getLastScilabFound();
180                     if (ScilabDestination)
181                     {
182                         SendCommandToAnotherScilab(MSG_SCIMSG7, ScilabDestination, Cmd);
183                         FREE(ScilabDestination);
184                         exit(0);
185                     }
186                     else
187                     {
188                         if (with_module("scinotes"))
189                         {
190                             wsprintf(Cmd, MSG_SCIMSG5_EDITOR, PathWScilex, FinalFileName);
191                         }
192                         else
193                         {
194                             MessageBox(NULL, "Please install editor module.", "Error", MB_ICONSTOP);
195                             exit(0);
196                         }
197                     }
198                 }
199             }
200             break;
201
202             case 1: /* -X eXecute file */
203             {
204                 if (IsABinOrSavFile(FinalFileName) == TRUE)
205                 {
206                     /* C'est un fichier .BIN ou .SAV d'ou load */
207                     wsprintf(Cmd, MSG_SCIMSG1, PathWScilex, FinalFileName, FinalFileName);
208                 }
209                 else
210                 {
211                     if (IsAScicosFile(fichier) == TRUE)
212                     {
213                         ExtensionFileIntoLowerCase(FinalFileName);
214                         if (!HaveAnotherWindowScilab() || haveMutexClosingScilab())
215                         {
216                             if (with_module("xcos"))
217                             {
218                                 wsprintf(Cmd, MSG_SCIMSG2_XCOS, PathWScilex, FinalFileName);
219                             }
220                             else
221                             {
222                                 MessageBox(NULL, "Please install xcos module.", "Error", MB_ICONSTOP);
223                                 exit(0);
224                             }
225                         }
226                         else
227                         {
228                             char *ScilabDestination = NULL;
229
230                             if (with_module("xcos"))
231                             {
232                                 wsprintf(Cmd, MSG_SCIMSG3_XCOS, FinalFileName);
233                             }
234                             else
235                             {
236                                 MessageBox(NULL, "Please install xcos module.", "Error", MB_ICONSTOP);
237                                 exit(0);
238                             }
239
240                             ScilabDestination = getLastScilabFound();
241                             if (ScilabDestination)
242                             {
243                                 SendCommandToAnotherScilab(MSG_SCIMSG7, ScilabDestination, Cmd);
244                                 FREE(ScilabDestination);
245                                 exit(0);
246                             }
247                             else
248                             {
249                                 if (with_module("xcos"))
250                                 {
251                                     wsprintf(Cmd, MSG_SCIMSG2_XCOS, PathWScilex, FinalFileName);
252                                 }
253                                 else
254                                 {
255                                     MessageBox(NULL, "Please install xcos module.", "Error", MB_ICONSTOP);
256                                     exit(0);
257                                 }
258                             }
259                         }
260                     }
261                     else
262                     {
263                         wsprintf(Cmd, MSG_SCIMSG4, PathWScilex, FinalFileName);
264                     }
265                 }
266             }
267             break;
268
269             case 2: /* -P Print file */
270             {
271                 PrintFile(fichier);
272                 strcpy(Cmd, " ");
273                 exit(0);
274             }
275             break;
276         }
277     }
278     return ReturnedValue;
279 }
280 /*--------------------------------------------------------------------------*/
281 static void ExtensionFileIntoLowerCase(char *fichier)
282 {
283     char *tmpfile = NULL;
284     char *buffer = NULL;
285     char *lastdot = NULL;
286     char *ext = NULL;
287
288     tmpfile = os_strdup(fichier);
289     buffer = strtok(tmpfile, ".");
290     while (buffer = strtok(NULL, "."))
291     {
292         lastdot = buffer;
293     }
294     /* le dernier . permet d'avoir l'extension */
295     ext = _strlwr(lastdot); /* Fichier en Majuscule */
296
297     strcpy(&fichier[strlen(fichier) - strlen(ext)], ext);
298
299     FREE(tmpfile);
300 }
301 /*--------------------------------------------------------------------------*/
302 static void ReplaceSlash(char *pathout, char *pathin)
303 {
304     int i = 0;
305     int len_pathin = (int)strlen(pathin);
306     for (i = 0; i < len_pathin; i++)
307     {
308         if (pathin[i] == '\\')
309         {
310             pathout[i] = '/';
311         }
312         else
313         {
314             pathout[i] = pathin[i];
315         }
316     }
317     pathout[i] = '\0';
318 }
319 /*--------------------------------------------------------------------------*/
320 static BOOL isGoodExtension(char *chainefichier, char *ext)
321 {
322     char *ExtensionFilename = PathFindExtension(chainefichier);
323     if (ExtensionFilename)
324     {
325         if (_stricmp(ExtensionFilename, ext) == 0)
326         {
327             return TRUE;
328         }
329     }
330     return FALSE;
331 }
332 /*--------------------------------------------------------------------------*/