Better handle NULL path arguments in w32_filesel.c
[claws.git] / src / gtk / w32_filesel.c
1 /*
2  * Claws Mail -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 2016 The Claws Mail Team
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 3 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program. If not, see <http://www.gnu.org/licenses/>.
17  *
18  */
19
20 #ifdef HAVE_CONFIG_H
21 #  include "config.h"
22 #endif
23
24 #define UNICODE
25 #define _UNICODE
26
27 #include <glib.h>
28 #include <glib/gi18n.h>
29 #include <gdk/gdkwin32.h>
30 #include <pthread.h>
31
32 #include <windows.h>
33 #include <shlobj.h>
34
35 #include "claws.h"
36 #include "alertpanel.h"
37 #include "manage_window.h"
38 #include "utils.h"
39
40 static OPENFILENAME o;
41 static BROWSEINFO b;
42
43 /* Since running the native dialogs in the same thread stops GTK+
44  * loop from redrawing other windows on the background, we need
45  * to run the dialogs in a separate thread. */
46
47 /* TODO: There's a lot of code repeat in this file, it could be
48  * refactored to be neater. */
49
50 struct _WinChooserCtx {
51         void *data;
52         gboolean return_value;
53         PIDLIST_ABSOLUTE return_value_pidl;
54         gboolean done;
55 };
56
57 typedef struct _WinChooserCtx WinChooserCtx;
58
59 static void *threaded_GetOpenFileName(void *arg)
60 {
61         WinChooserCtx *ctx = (WinChooserCtx *)arg;
62
63         g_return_val_if_fail(ctx != NULL, NULL);
64         g_return_val_if_fail(ctx->data != NULL, NULL);
65
66         ctx->return_value = GetOpenFileName(ctx->data);
67         ctx->done = TRUE;
68
69         return NULL;
70 }
71
72 static void *threaded_GetSaveFileName(void *arg)
73 {
74         WinChooserCtx *ctx = (WinChooserCtx *)arg;
75
76         g_return_val_if_fail(ctx != NULL, NULL);
77         g_return_val_if_fail(ctx->data != NULL, NULL);
78
79         ctx->return_value = GetSaveFileName(ctx->data);
80         ctx->done = TRUE;
81
82         return NULL;
83 }
84
85 static void *threaded_SHBrowseForFolder(void *arg)
86 {
87         WinChooserCtx *ctx = (WinChooserCtx *)arg;
88
89         g_return_val_if_fail(ctx != NULL, NULL);
90         g_return_val_if_fail(ctx->data != NULL, NULL);
91
92         ctx->return_value_pidl = SHBrowseForFolder(ctx->data);
93
94         ctx->done = TRUE;
95
96         return NULL;
97 }
98
99 /* This function handles calling GetOpenFilename(), using
100  * global static variable o.
101  * It expects o.lpstrFile to point to an already allocated buffer,
102  * of size at least MAXPATHLEN. */
103 static const gboolean _file_open_dialog(const gchar *path, const gchar *title,
104                 const gchar *filter, const gboolean multi)
105 {
106         gboolean ret;
107         gunichar2 *path16 = NULL;
108         gunichar2 *title16 = NULL;
109         gunichar2 *filter16 = NULL;
110         gunichar2 *win_filter16 = NULL;
111         glong conv_items, sz;
112         GError *error = NULL;
113         WinChooserCtx *ctx;
114 #ifdef USE_PTHREAD
115         pthread_t pt;
116 #endif
117
118         /* Path needs to be converted to UTF-16, so that the native chooser
119          * can understand it. */
120         path16 = g_utf8_to_utf16(path ? path : "",
121                         -1, NULL, NULL, &error);
122         if (error != NULL) {
123                 alertpanel_error(_("Could not convert file path to UTF-16:\n\n%s"),
124                                 error->message);
125                 debug_print("file path '%s' conversion to UTF-16 failed\n", path);
126                 g_error_free(error);
127                 error = NULL;
128                 return FALSE;
129         }
130
131         /* Chooser dialog title needs to be UTF-16 as well. */
132         title16 = g_utf8_to_utf16(title ? title : "",
133                         -1, NULL, NULL, &error);
134         if (error != NULL) {
135                 debug_print("dialog title '%s' conversion to UTF-16 failed\n", title);
136                 g_error_free(error);
137                 error = NULL;
138         }
139
140         o.lStructSize = sizeof(OPENFILENAME);
141         if (focus_window != NULL)
142                 o.hwndOwner = GDK_WINDOW_HWND(gtk_widget_get_window(focus_window));
143         else
144                 o.hwndOwner = NULL;
145         o.hInstance = NULL;
146         o.lpstrFilter = NULL;
147         o.lpstrCustomFilter = NULL;
148         o.nFilterIndex = 0;
149         o.nMaxFile = MAXPATHLEN;
150         o.lpstrFileTitle = NULL;
151         o.lpstrInitialDir = path16;
152         o.lpstrTitle = title16;
153         if (multi)
154                 o.Flags = OFN_LONGNAMES | OFN_EXPLORER | OFN_ALLOWMULTISELECT;
155         else
156                 o.Flags = OFN_LONGNAMES | OFN_EXPLORER;
157
158         if (filter != NULL && strlen(filter) > 0) {
159                 debug_print("Setting filter '%s'\n", filter);
160                 filter16 = g_utf8_to_utf16(filter, -1, NULL, &conv_items, &error);
161                 /* We're creating a UTF16 (2 bytes for each character) string:
162                  * "filter\0filter\0\0"
163                  * As g_utf8_to_utf16() will stop on first null byte, even if
164                  * we pass string length in its second argument, we have to
165                  * construct this string manually.
166                  * conv_items contains number of UTF16 characters of our filter.
167                  * Therefore we need enough bytes to store the filter string twice
168                  * and three null chars. */
169                 sz = sizeof(gunichar2);
170                 win_filter16 = g_malloc0(conv_items*sz*2 + sz*3);
171                 memcpy(win_filter16, filter16, conv_items*sz);
172                 memcpy(win_filter16 + conv_items*sz + sz, filter16, conv_items*sz);
173                 g_free(filter16);
174
175                 if (error != NULL) {
176                         debug_print("dialog title '%s' conversion to UTF-16 failed\n", title);
177                         g_error_free(error);
178                         error = NULL;
179                 }
180                 o.lpstrFilter = (LPCTSTR)win_filter16;
181                 o.nFilterIndex = 1;
182         }
183
184         ctx = g_new0(WinChooserCtx, 1);
185         ctx->data = &o;
186         ctx->done = FALSE;
187
188 #ifdef USE_PTHREAD
189         if (pthread_create(&pt, PTHREAD_CREATE_JOINABLE, threaded_GetOpenFileName,
190                                 (void *)ctx) != 0) {
191                 debug_print("Couldn't run in a thread, continuing unthreaded.\n");
192                 threaded_GetOpenFileName(ctx);
193         } else {
194                 while (!ctx->done) {
195                         claws_do_idle();
196                 }
197                 pthread_join(pt, NULL);
198         }
199         ret = ctx->return_value;
200 #else
201         debug_print("No threads available, continuing unthreaded.\n");
202         ret = GetOpenFileName(&o);
203 #endif
204
205         g_free(win_filter16);
206         if (path16 != NULL) {
207                 g_free(path16);
208         }
209         g_free(title16);
210         g_free(ctx);
211
212         return ret;
213 }
214
215 gchar *filesel_select_file_open_with_filter(const gchar *title, const gchar *path,
216                               const gchar *filter)
217 {
218         gchar *str = NULL;
219         GError *error = NULL;
220
221         o.lpstrFile = g_malloc0(MAXPATHLEN);
222         if (!_file_open_dialog(title, path, filter, FALSE)) {
223                 g_free(o.lpstrFile);
224                 return NULL;
225         }
226
227         /* Now convert the returned file path back from UTF-16. */
228         str = g_utf16_to_utf8(o.lpstrFile, o.nMaxFile, NULL, NULL, &error);
229         if (error != NULL) {
230                 alertpanel_error(_("Could not convert file path back to UTF-8:\n\n%s"),
231                                 error->message);
232                 debug_print("returned file path conversion to UTF-8 failed\n");
233                 g_error_free(error);
234         }
235
236         g_free(o.lpstrFile);
237         return str;
238 }
239
240 GList *filesel_select_multiple_files_open_with_filter(const gchar *title,
241                 const gchar *path, const gchar *filter)
242 {
243         GList *file_list = NULL;
244         gchar *dir = NULL;
245         gchar *file = NULL;
246         gunichar2 *f;
247         GError *error = NULL;
248
249         o.lpstrFile = g_malloc0(MAXPATHLEN);
250         if (!_file_open_dialog(title, path, filter, TRUE)) {
251                 g_free(o.lpstrFile);
252                 return NULL;
253         }
254
255         /* Now convert the returned directory and file names back from UTF-16.
256          * The content of o.lpstrFile is:
257          * "directory\0file\0file\0...\0file\0\0" for multiple files selected,
258          * "fullfilepath\0" for single file. */
259         dir = g_utf16_to_utf8(o.lpstrFile, o.nMaxFile, NULL, NULL, &error);
260         if (error != NULL) {
261                 alertpanel_error(_("Could not convert file path back to UTF-8:\n\n%s"),
262                                 error->message);
263                 debug_print("returned file path conversion to UTF-8 failed\n");
264                 g_error_free(error);
265         }
266
267         f = o.lpstrFile + g_utf8_strlen(dir, -1) + 1;
268
269         do {
270                 file = g_utf16_to_utf8(f, o.nMaxFile, NULL, NULL, &error);
271                 if (error != NULL) {
272                         alertpanel_error(_("Could not convert file path back to UTF-8:\n\n%s"),
273                                         error->message);
274                         debug_print("returned file path conversion to UTF-8 failed\n");
275                         g_error_free(error);
276                 }
277
278                 if (file == NULL || strlen(file) == 0) {
279                         g_free(file);
280                         break;
281                 }
282
283                 debug_print("Selected file '%s%c%s'\n",
284                                 dir, G_DIR_SEPARATOR, file);
285                 file_list = g_list_append(file_list,
286                                 g_strconcat(dir, G_DIR_SEPARATOR_S, file, NULL));
287
288                 f = f + g_utf8_strlen(file, -1) + 1;
289                 g_free(file);
290         } while (TRUE);
291
292         if (file_list == NULL) {
293                 debug_print("Selected single file '%s'\n", dir);
294                 file_list = g_list_append(file_list, dir);
295         } else {
296                 g_free(dir);
297         }
298
299         g_free(o.lpstrFile);
300         return file_list;
301 }
302
303 gchar *filesel_select_file_open(const gchar *title, const gchar *path)
304 {
305         return filesel_select_file_open_with_filter(title, path, NULL);
306 }
307
308 GList *filesel_select_multiple_files_open(const gchar *title, const gchar *path)
309 {
310         return filesel_select_multiple_files_open_with_filter(title, path, NULL);
311 }
312
313 gchar *filesel_select_file_save(const gchar *title, const gchar *path)
314 {
315         gboolean ret;
316         gchar *str, *filename = NULL;
317         gunichar2 *filename16, *path16, *title16;
318         glong conv_items;
319         GError *error = NULL;
320         WinChooserCtx *ctx;
321 #ifdef USE_PTHREAD
322         pthread_t pt;
323 #endif
324
325         /* Find the filename part, if any */
326         if (path == NULL || path[strlen(path)-1] == G_DIR_SEPARATOR) {
327                 filename = "";
328         } else if ((filename = strrchr(path, G_DIR_SEPARATOR)) != NULL) {
329                 filename++;
330         } else {
331                 filename = (char *) path;
332         }
333
334         /* Convert it to UTF-16. */
335         filename16 = g_utf8_to_utf16(filename, -1, NULL, &conv_items, &error);
336         if (error != NULL) {
337                 alertpanel_error(_("Could not convert attachment name to UTF-16:\n\n%s"),
338                                 error->message);
339                 debug_print("filename '%s' conversion to UTF-16 failed\n", filename);
340                 g_error_free(error);
341                 return NULL;
342         }
343
344         /* Path needs to be converted to UTF-16, so that the native chooser
345          * can understand it. */
346         path16 = g_utf8_to_utf16(path, -1, NULL, NULL, &error);
347         if (error != NULL) {
348                 alertpanel_error(_("Could not convert file path to UTF-16:\n\n%s"),
349                                 error->message);
350                 debug_print("file path '%s' conversion to UTF-16 failed\n", path);
351                 g_error_free(error);
352                 g_free(filename16);
353                 return NULL;
354         }
355
356         /* Chooser dialog title needs to be UTF-16 as well. */
357         title16 = g_utf8_to_utf16(title, -1, NULL, NULL, &error);
358         if (error != NULL) {
359                 debug_print("dialog title '%s' conversion to UTF-16 failed\n", title);
360                 g_error_free(error);
361         }
362
363         o.lStructSize = sizeof(OPENFILENAME);
364         if (focus_window != NULL)
365                 o.hwndOwner = GDK_WINDOW_HWND(gtk_widget_get_window(focus_window));
366         else
367                 o.hwndOwner = NULL;
368         o.lpstrFilter = NULL;
369         o.lpstrCustomFilter = NULL;
370         o.lpstrFile = g_malloc0(MAXPATHLEN);
371         if (path16 != NULL)
372                 memcpy(o.lpstrFile, filename16, conv_items * sizeof(gunichar2));
373         o.nMaxFile = MAXPATHLEN;
374         o.lpstrFileTitle = NULL;
375         o.lpstrInitialDir = path16;
376         o.lpstrTitle = title16;
377         o.Flags = OFN_LONGNAMES | OFN_EXPLORER;
378
379         ctx = g_new0(WinChooserCtx, 1);
380         ctx->data = &o;
381         ctx->return_value = FALSE;
382         ctx->done = FALSE;
383
384 #ifdef USE_PTHREAD
385         if (pthread_create(&pt, PTHREAD_CREATE_JOINABLE, threaded_GetSaveFileName,
386                                 (void *)ctx) != 0) {
387                 debug_print("Couldn't run in a thread, continuing unthreaded.\n");
388                 threaded_GetSaveFileName(ctx);
389         } else {
390                 while (!ctx->done) {
391                         claws_do_idle();
392                 }
393                 pthread_join(pt, NULL);
394         }
395         ret = ctx->return_value;
396 #else
397         debug_print("No threads available, continuing unthreaded.\n");
398         ret = GetSaveFileName(&o);
399 #endif
400
401         g_free(filename16);
402         g_free(path16);
403         g_free(title16);
404         g_free(ctx);
405
406         if (!ret) {
407                 g_free(o.lpstrFile);
408                 return NULL;
409         }
410
411         /* Now convert the returned file path back from UTF-16. */
412         str = g_utf16_to_utf8(o.lpstrFile, o.nMaxFile, NULL, NULL, &error);
413         if (error != NULL) {
414                 alertpanel_error(_("Could not convert file path back to UTF-8:\n\n%s"),
415                                 error->message);
416                 debug_print("returned file path conversion to UTF-8 failed\n");
417                 g_error_free(error);
418         }
419
420         g_free(o.lpstrFile);
421         return str;
422 }
423
424 /* This callback function is used to set the folder browse dialog
425  * selection from filesel_select_file_open_folder() to set
426  * chosen starting folder ("path" argument to that function. */
427 static int CALLBACK _open_folder_callback(HWND hwnd, UINT uMsg,
428                 LPARAM lParam, LPARAM lpData)
429 {
430         if (uMsg != BFFM_INITIALIZED)
431                 return 0;
432
433         SendMessage(hwnd, BFFM_SETSELECTION, TRUE, lpData);
434         return 0;
435 }
436
437 gchar *filesel_select_file_open_folder(const gchar *title, const gchar *path)
438 {
439         PIDLIST_ABSOLUTE pidl;
440         gchar *str;
441         gunichar2 *path16, *title16;
442         glong conv_items;
443         GError *error = NULL;
444         WinChooserCtx *ctx;
445 #ifdef USE_PTHREAD
446         pthread_t pt;
447 #endif
448
449         /* Path needs to be converted to UTF-16, so that the native chooser
450          * can understand it. */
451         path16 = g_utf8_to_utf16(path ? path : "",
452                         -1, NULL, &conv_items, &error);
453         if (error != NULL) {
454                 alertpanel_error(_("Could not convert file path to UTF-16:\n\n%s"),
455                                 error->message);
456                 debug_print("file path '%s' conversion to UTF-16 failed\n", path);
457                 g_error_free(error);
458                 return NULL;
459         }
460
461         /* Chooser dialog title needs to be UTF-16 as well. */
462         title16 = g_utf8_to_utf16(title ? title : "",
463                         -1, NULL, NULL, &error);
464         if (error != NULL) {
465                 debug_print("dialog title '%s' conversion to UTF-16 failed\n", title);
466                 g_error_free(error);
467         }
468
469         if (focus_window != NULL)
470                 b.hwndOwner = GDK_WINDOW_HWND(gtk_widget_get_window(focus_window));
471         else
472                 b.hwndOwner = NULL;
473         b.pszDisplayName = g_malloc(MAXPATHLEN);
474         b.lpszTitle = title16;
475         b.ulFlags = 0;
476         b.pidlRoot = NULL;
477         b.lpfn = _open_folder_callback;
478         b.lParam = (LPARAM)path16;
479
480         CoInitialize(NULL);
481
482         ctx = g_new0(WinChooserCtx, 1);
483         ctx->data = &b;
484         ctx->done = FALSE;
485
486 #ifdef USE_PTHREAD
487         if (pthread_create(&pt, PTHREAD_CREATE_JOINABLE, threaded_SHBrowseForFolder,
488                                 (void *)ctx) != 0) {
489                 debug_print("Couldn't run in a thread, continuing unthreaded.\n");
490                 threaded_SHBrowseForFolder(ctx);
491         } else {
492                 while (!ctx->done) {
493                         claws_do_idle();
494                 }
495                 pthread_join(pt, NULL);
496         }
497         pidl = ctx->return_value_pidl;
498 #else
499         debug_print("No threads available, continuing unthreaded.\n");
500         pidl = SHBrowseForFolder(&b);
501 #endif
502
503         g_free(b.pszDisplayName);
504         g_free(title16);
505         g_free(path16);
506
507         if (pidl == NULL) {
508                 CoUninitialize();
509                 g_free(ctx);
510                 return NULL;
511         }
512
513         path16 = malloc(MAX_PATH);
514         if (!SHGetPathFromIDList(pidl, path16)) {
515                 CoTaskMemFree(pidl);
516                 CoUninitialize();
517                 g_free(path16);
518                 g_free(ctx);
519                 return NULL;
520         }
521
522         /* Now convert the returned file path back from UTF-16. */
523         /* Unfortunately, there is no field in BROWSEINFO struct to indicate
524          * actual length of string in pszDisplayName, so we have to assume
525          * the string is null-terminated. */
526         str = g_utf16_to_utf8(path16, -1, NULL, NULL, &error);
527         if (error != NULL) {
528                 alertpanel_error(_("Could not convert file path back to UTF-8:\n\n%s"),
529                                 error->message);
530                 debug_print("returned file path conversion to UTF-8 failed\n");
531                 g_error_free(error);
532         }
533         CoTaskMemFree(pidl);
534         CoUninitialize();
535         g_free(ctx);
536         g_free(path16);
537
538         return str;
539 }
540
541 gchar *filesel_select_file_save_folder(const gchar *title, const gchar *path)
542 {
543         return filesel_select_file_open_folder(title, path);
544 }