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(path, title, 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(path, title, 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 }