src/win32.c

   1 /*
   2  *      win32.c - this file is part of Geany, a fast and lightweight IDE
   3  *
   4  *      Copyright 2005-2010 Enrico Tröger <enrico(dot)troeger(at)uvena(dot)de>
   5  *      Copyright 2006-2010 Nick Treleaven <nick(dot)treleaven(at)btinternet(dot)com>
   6  *
   7  *      This program is free software; you can redistribute it and/or modify
   8  *      it under the terms of the GNU General Public License as published by
   9  *      the Free Software Foundation; either version 2 of the License, or
  10  *      (at your option) any later version.
  11  *
  12  *      This program is distributed in the hope that it will be useful,
  13  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *      GNU General Public License for more details.
  16  *
  17  *      You should have received a copy of the GNU General Public License
  18  *      along with this program; if not, write to the Free Software
  19  *      Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  20  *
  21  *  $Id$
  22  */
  23
  24 /*
  25  * Special functions for the win32 platform, to provide native dialogs.
  26  */
  27
  28 #include "geany.h"
  29
  30 #ifdef G_OS_WIN32
  31
  32 #define VC_EXTRALEAN
  33 #define WIN32_LEAN_AND_MEAN
  34 #include <windows.h>
  35 #include <commdlg.h>
  36 #include <shlobj.h>
  37 #include <io.h>
  38 #include <fcntl.h>
  39
  40 #include <string.h>
  41 #include <ctype.h>
  42 #include <math.h>
  43 #include <stdlib.h>
  44
  45 #include <gdk/gdkwin32.h>
  46
  47 #include "win32.h"
  48
  49 #include "document.h"
  50 #include "support.h"
  51 #include "utils.h"
  52 #include "ui_utils.h"
  53 #include "sciwrappers.h"
  54 #include "dialogs.h"
  55 #include "filetypes.h"
  56 #include "project.h"
  57 #include "editor.h"
  58
  59 #define BUFSIZE 4096
  60 #define CMDSIZE 32768
  61
  62 struct _geany_win32_spawn
  63 {
  64         HANDLE hChildStdinRd;
  65         HANDLE hChildStdinWr;
  66         HANDLE hChildStdoutRd;
  67         HANDLE hChildStdoutWr;
  68         HANDLE hChildStderrRd;
  69         HANDLE hChildStderrWr;
  70         HANDLE hInputFile;
  71         HANDLE hStdout;
  72         HANDLE hStderr;
  73         HANDLE processId;
  74         DWORD dwExitCode;
  75 };
  76 typedef struct _geany_win32_spawn geany_win32_spawn;
  77
  78 static gboolean GetContentFromHandle(HANDLE hFile, gchar **content, GError **error);
  79 static HANDLE GetTempFileHandle(GError **error);
  80 static gboolean CreateChildProcess(geany_win32_spawn *gw_spawn, TCHAR *szCmdline, const TCHAR *dir, GError **error);
  81 static VOID ReadFromPipe(HANDLE hRead, HANDLE hWrite, HANDLE hFile, GError **error);
  82
  83
  84 static wchar_t *get_file_filters(void)
  85 {
  86         gchar *string;
  87         guint i, j, len;
  88         static wchar_t title[4096];
  89         GString *str = g_string_sized_new(100);
  90         GString *all_patterns = g_string_sized_new(100);
  91         GSList *node;
  92         gchar *tmp;
  93
  94         /* create meta file filter "All files" */
  95         g_string_append_printf(str, "%s\t*\t", _("All files"));
  96         /* create meta file filter "All Source" (skip GEANY_FILETYPES_NONE) */
  97         for (i = GEANY_FILETYPES_NONE + 1; i < filetypes_array->len; i++)
  98         {
  99                 for (j = 0; filetypes[i]->pattern[j] != NULL; j++)
 100                 {
 101                         g_string_append(all_patterns, filetypes[i]->pattern[j]);
 102                         g_string_append_c(all_patterns, ';');
 103                 }
 104         }
 105         g_string_append_printf(str, "%s\t%s\t", _("All Source"), all_patterns->str);
 106         g_string_free(all_patterns, TRUE);
 107         /* add 'usual' filetypes */
 108         foreach_slist(node, filetypes_by_title)
 109         {
 110                 GeanyFiletype *ft = node->data;
 111
 112                 if (G_UNLIKELY(ft->id == GEANY_FILETYPES_NONE))
 113                         continue;
 114                 tmp = g_strjoinv(";", ft->pattern);
 115                 g_string_append_printf(str, "%s\t%s\t", ft->title, tmp);
 116                 g_free(tmp);
 117         }
 118         g_string_append_c(str, '\t'); /* the final \0 byte to mark the end of the string */
 119         string = str->str;
 120         g_string_free(str, FALSE);
 121
 122         /* replace all "\t"s by \0 */
 123         len = strlen(string);
 124         for (i = 0; i < len; i++)
 125         {
 126                 if (string[i] == '\t')
 127                         string[i] = '\0';
 128         }
 129         MultiByteToWideChar(CP_UTF8, 0, string, len, title, sizeof(title));
 130         g_free(string);
 131
 132         return title;
 133 }
 134
 135
 136 static wchar_t *get_file_filter_all_files(void)
 137 {
 138         guint len;
 139         static wchar_t title[4096];
 140         gchar *filter;
 141
 142         /* create meta file filter "All files" */
 143         filter = g_strdup_printf("%s\0*\0", _("All files"));
 144
 145         len = strlen(_("All files")) + 3;
 146         MultiByteToWideChar(CP_UTF8, 0, filter, len, title, sizeof(title));
 147         g_free(filter);
 148
 149         return title;
 150 }
 151
 152
 153 static wchar_t *get_filters(gboolean project_files)
 154 {
 155         gchar *string;
 156         gint i, len;
 157         static wchar_t title[1024];
 158
 159         if (project_files)
 160         {
 161                 string = g_strconcat(_("Geany project files"), "\t", "*." GEANY_PROJECT_EXT, "\t",
 162                         filetypes[GEANY_FILETYPES_NONE]->title, "\t",
 163                         filetypes[GEANY_FILETYPES_NONE]->pattern[0], "\t", NULL);
 164         }
 165         else
 166         {
 167                 string = g_strconcat(_("Executables"), "\t", "*.exe;*.bat;*.cmd", "\t",
 168                         filetypes[GEANY_FILETYPES_NONE]->title, "\t",
 169                         filetypes[GEANY_FILETYPES_NONE]->pattern[0], "\t", NULL);
 170         }
 171
 172         /* replace all "\t"s by \0 */
 173         len = strlen(string);
 174         for (i = 0; i < len; i++)
 175         {
 176                 if (string[i] == '\t') string[i] = '\0';
 177         }
 178         MultiByteToWideChar(CP_UTF8, 0, string, len, title, sizeof(title));
 179         g_free(string);
 180
 181         return title;
 182 }
 183
 184
 185 /* Converts the given UTF-8 filename or directory name into something usable for Windows and
 186  * returns the directory part of the given filename. */
 187 static wchar_t *get_dir_for_path(const gchar *utf8_filename)
 188 {
 189         static wchar_t w_dir[MAX_PATH];
 190         gchar *result;
 191
 192         if (g_file_test(utf8_filename, G_FILE_TEST_IS_DIR))
 193                 result = (gchar*) utf8_filename;
 194         else
 195                 result = g_path_get_dirname(utf8_filename);
 196
 197         MultiByteToWideChar(CP_UTF8, 0, result, -1, w_dir, sizeof(w_dir));
 198
 199         if (result != utf8_filename)
 200                 g_free(result);
 201
 202         return w_dir;
 203 }
 204
 205
 206 /* Callback function for setting the initial directory of the folder open dialog. This could also
 207  * be done with BROWSEINFO.pidlRoot and SHParseDisplayName but SHParseDisplayName is not available
 208  * on systems below Windows XP. So, we go the hard way by creating a callback which will set up the
 209  * folder when the dialog is initialised. Yeah, I like Windows. */
 210 INT CALLBACK BrowseCallbackProc(HWND hwnd, UINT uMsg, LPARAM lp, LPARAM pData)
 211 {
 212         switch (uMsg)
 213         {
 214                 case BFFM_INITIALIZED:
 215                 {
 216                         SendMessageW(hwnd, BFFM_SETSELECTIONW, TRUE, pData);
 217                         break;
 218                 }
 219                 case BFFM_SELCHANGED:
 220                 {
 221                         /* set the status window to the currently selected path. */
 222                         static wchar_t szDir[MAX_PATH];
 223                         if (SHGetPathFromIDListW((LPITEMIDLIST) lp, szDir))
 224                         {
 225                                 SendMessageW(hwnd, BFFM_SETSTATUSTEXTW, 0, (LPARAM) szDir);
 226                         }
 227                         break;
 228                 }
 229         }
 230         return 0;
 231 }
 232
 233
 234 /* Shows a folder selection dialog.
 235  * initial_dir is expected in UTF-8
 236  * The selected folder name is returned. */
 237 gchar *win32_show_folder_dialog(GtkWidget *parent, const gchar *title, const gchar *initial_dir)
 238 {
 239         BROWSEINFOW bi;
 240         LPCITEMIDLIST pidl;
 241         gchar *result = NULL;
 242         wchar_t fname[MAX_PATH];
 243         wchar_t w_title[512];
 244
 245         MultiByteToWideChar(CP_UTF8, 0, title, -1, w_title, sizeof(w_title));
 246
 247         if (parent == NULL)
 248                 parent = main_widgets.window;
 249
 250         memset(&bi, 0, sizeof bi);
 251         bi.hwndOwner = GDK_WINDOW_HWND(parent->window);
 252         bi.pidlRoot = NULL;
 253         bi.lpszTitle = w_title;
 254         bi.lpfn = BrowseCallbackProc;
 255         bi.lParam = (LPARAM) get_dir_for_path(initial_dir);
 256         bi.ulFlags = BIF_DONTGOBELOWDOMAIN | BIF_RETURNONLYFSDIRS | BIF_STATUSTEXT;
 257
 258         pidl = SHBrowseForFolderW(&bi);
 259
 260         /* convert the strange Windows folder list item something into an usual path string ;-) */
 261         if (pidl != 0)
 262         {
 263                 if (SHGetPathFromIDListW(pidl, fname))
 264                 {
 265                         result = g_malloc0(MAX_PATH * 2);
 266                         WideCharToMultiByte(CP_UTF8, 0, fname, -1, result, MAX_PATH * 2, NULL, NULL);
 267                 }
 268                 /* SHBrowseForFolder() probably leaks memory here, but how to free the allocated memory? */
 269         }
 270         return result;
 271 }
 272
 273
 274 /* Shows a file open dialog.
 275  * If allow_new_file is set, the file to be opened doesn't have to exist.
 276  * initial_dir is expected in UTF-8
 277  * The selected file name is returned.
 278  * If project_file_filter is set, the file open dialog will have a file filter for Geany project
 279  * files, a filter for executables otherwise. */
 280 gchar *win32_show_project_open_dialog(GtkWidget *parent, const gchar *title,
 281                                                                       const gchar *initial_dir, gboolean allow_new_file,
 282                                                                       gboolean project_file_filter)
 283 {
 284         OPENFILENAMEW of;
 285         gint retval;
 286         wchar_t fname[MAX_PATH];
 287         wchar_t w_title[512];
 288         gchar *filename;
 289
 290         fname[0] = '\0';
 291
 292         MultiByteToWideChar(CP_UTF8, 0, title, -1, w_title, sizeof(w_title));
 293
 294         if (parent == NULL)
 295                 parent = main_widgets.window;
 296
 297         /* initialise file dialog info struct */
 298         memset(&of, 0, sizeof of);
 299 #ifdef OPENFILENAME_SIZE_VERSION_400
 300         of.lStructSize = OPENFILENAME_SIZE_VERSION_400;
 301 #else
 302         of.lStructSize = sizeof of;
 303 #endif
 304         of.hwndOwner = GDK_WINDOW_HWND(parent->window);
 305         of.lpstrFilter = get_filters(project_file_filter);
 306
 307         of.lpstrCustomFilter = NULL;
 308         of.nFilterIndex = 0;
 309         of.lpstrFile = fname;
 310         of.lpstrInitialDir = get_dir_for_path(initial_dir);
 311         of.nMaxFile = 2048;
 312         of.lpstrFileTitle = NULL;
 313         of.lpstrTitle = w_title;
 314         of.lpstrDefExt = L"";
 315         of.Flags = OFN_PATHMUSTEXIST | OFN_EXPLORER | OFN_HIDEREADONLY;
 316         if (! allow_new_file)
 317                 of.Flags |= OFN_FILEMUSTEXIST;
 318
 319         retval = GetOpenFileNameW(&of);
 320
 321         if (! retval)
 322         {
 323                 if (CommDlgExtendedError())
 324                 {
 325                         gchar *error;
 326                         error = g_strdup_printf("File dialog box error (%x)", (int)CommDlgExtendedError());
 327                         win32_message_dialog(NULL, GTK_MESSAGE_ERROR, error);
 328                         g_free(error);
 329                 }
 330                 return NULL;
 331         }
 332         /* convert the resulting filename into UTF-8 (from whatever encoding it has at this moment) */
 333         filename = g_malloc0(MAX_PATH * 2);
 334         WideCharToMultiByte(CP_UTF8, 0, fname, -1, filename, MAX_PATH * 2, NULL, NULL);
 335
 336         return filename;
 337 }
 338
 339
 340 /* initial_dir can be NULL to use the current working directory.
 341  * Returns: TRUE if the dialog was not cancelled. */
 342 gboolean win32_show_document_open_dialog(GtkWindow *parent, const gchar *title, const gchar *initial_dir)
 343 {
 344         OPENFILENAMEW of;
 345         gint retval;
 346         guint x;
 347         gchar tmp[MAX_PATH];
 348         wchar_t fname[MAX_PATH];
 349         wchar_t w_dir[MAX_PATH];
 350         wchar_t w_title[512];
 351
 352         fname[0] = '\0';
 353
 354         if (initial_dir != NULL)
 355                 MultiByteToWideChar(CP_UTF8, 0, initial_dir, -1, w_dir, sizeof(w_dir));
 356
 357         MultiByteToWideChar(CP_UTF8, 0, title, -1, w_title, sizeof(w_title));
 358
 359         /* initialise file dialog info struct */
 360         memset(&of, 0, sizeof of);
 361 #ifdef OPENFILENAME_SIZE_VERSION_400
 362         of.lStructSize = OPENFILENAME_SIZE_VERSION_400;
 363 #else
 364         of.lStructSize = sizeof of;
 365 #endif
 366         of.hwndOwner = GDK_WINDOW_HWND(GTK_WIDGET(parent)->window);
 367         of.lpstrFilter = get_file_filters();
 368
 369         of.lpstrCustomFilter = NULL;
 370         of.nFilterIndex = GEANY_FILETYPES_NONE + 1;
 371         of.lpstrFile = fname;
 372         of.lpstrInitialDir = (initial_dir != NULL) ? w_dir : NULL;
 373         of.nMaxFile = 2048;
 374         of.lpstrFileTitle = NULL;
 375         of.lpstrTitle = w_title;
 376         of.lpstrDefExt = L"";
 377         of.Flags = OFN_ALLOWMULTISELECT | OFN_FILEMUSTEXIST | OFN_EXPLORER;
 378
 379         retval = GetOpenFileNameW(&of);
 380
 381         if (!retval)
 382         {
 383                 if (CommDlgExtendedError())
 384                 {
 385                         gchar error[100];
 386                         g_snprintf(error, sizeof error, "File dialog box error (%x)", (int)CommDlgExtendedError());
 387                         win32_message_dialog(NULL, GTK_MESSAGE_ERROR, error);
 388                 }
 389                 return FALSE;
 390         }
 391
 392         x = of.nFileOffset - 1;
 393         if (x != wcslen(fname))
 394         {       /* open a single file */
 395                 WideCharToMultiByte(CP_UTF8, 0, fname, -1, tmp, sizeof(tmp), NULL, NULL);
 396                 document_open_file(tmp, of.Flags & OFN_READONLY, NULL, NULL);
 397         }
 398         else
 399         {       /* open multiple files */
 400                 gchar file_name[MAX_PATH];
 401                 gchar dir_name[MAX_PATH];
 402
 403                 WideCharToMultiByte(CP_UTF8, 0, fname, of.nFileOffset,
 404                         dir_name, sizeof(dir_name), NULL, NULL);
 405                 for (; ;)
 406                 {
 407                         if (! fname[x])
 408                         {
 409                                 if (! fname[x + 1])
 410                                         break;
 411
 412                                 WideCharToMultiByte(CP_UTF8, 0, fname + x + 1, -1,
 413                                         tmp, sizeof(tmp), NULL, NULL);
 414                                 g_snprintf(file_name, 511, "%s\\%s", dir_name, tmp);
 415
 416                                 /* convert the resulting filename into UTF-8 */
 417                                 document_open_file(file_name, of.Flags & OFN_READONLY, NULL, NULL);
 418                         }
 419                         x++;
 420                 }
 421         }
 422         return (retval != 0);
 423 }
 424
 425
 426 gchar *win32_show_document_save_as_dialog(GtkWindow *parent, const gchar *title,
 427                                                                                   const gchar *initial_file)
 428 {
 429         OPENFILENAMEW of;
 430         gint retval;
 431         gchar tmp[MAX_PATH];
 432         wchar_t w_file[MAX_PATH];
 433         wchar_t w_title[512];
 434         guint x;
 435
 436         w_file[0] = '\0';
 437
 438         if (initial_file != NULL)
 439                 MultiByteToWideChar(CP_UTF8, 0, initial_file, -1, w_file, sizeof(w_file));
 440
 441         MultiByteToWideChar(CP_UTF8, 0, title, -1, w_title, sizeof(w_title));
 442
 443         /* initialise file dialog info struct */
 444         memset(&of, 0, sizeof of);
 445 #ifdef OPENFILENAME_SIZE_VERSION_400
 446         of.lStructSize = OPENFILENAME_SIZE_VERSION_400;
 447 #else
 448         of.lStructSize = sizeof of;
 449 #endif
 450         of.hwndOwner = GDK_WINDOW_HWND(GTK_WIDGET(parent)->window);
 451
 452         of.lpstrFilter = get_file_filter_all_files();
 453         of.lpstrCustomFilter = NULL;
 454         of.nFilterIndex = 0;
 455
 456         of.lpstrFile = w_file;
 457         of.nMaxFile = 2048;
 458         of.lpstrFileTitle = NULL;
 459         of.lpstrTitle = w_title;
 460         of.lpstrDefExt = L"";
 461         of.Flags = OFN_FILEMUSTEXIST | OFN_EXPLORER;
 462         retval = GetSaveFileNameW(&of);
 463
 464         if (! retval)
 465         {
 466                 if (CommDlgExtendedError())
 467                 {
 468                         gchar *error = g_strdup_printf(
 469                                 "File dialog box error (%x)", (gint) CommDlgExtendedError());
 470                         win32_message_dialog(NULL, GTK_MESSAGE_ERROR, error);
 471                         g_free(error);
 472                 }
 473                 return NULL;
 474         }
 475
 476         WideCharToMultiByte(CP_UTF8, 0, w_file, -1, tmp, sizeof(tmp), NULL, NULL);
 477
 478         return g_strdup(tmp);
 479 }
 480
 481
 482 /* initial_dir can be NULL to use the current working directory.
 483  * Returns: the selected filename */
 484 gchar *win32_show_file_dialog(GtkWindow *parent, const gchar *title, const gchar *initial_file)
 485 {
 486         OPENFILENAMEW of;
 487         gint retval;
 488         gchar tmp[MAX_PATH];
 489         wchar_t w_file[MAX_PATH];
 490         wchar_t w_title[512];
 491         guint x;
 492
 493         w_file[0] = '\0';
 494
 495         if (initial_file != NULL)
 496                 MultiByteToWideChar(CP_UTF8, 0, initial_file, -1, w_file, sizeof(w_file));
 497
 498         MultiByteToWideChar(CP_UTF8, 0, title, -1, w_title, sizeof(w_title));
 499
 500         /* initialise file dialog info struct */
 501         memset(&of, 0, sizeof of);
 502 #ifdef OPENFILENAME_SIZE_VERSION_400
 503         of.lStructSize = OPENFILENAME_SIZE_VERSION_400;
 504 #else
 505         of.lStructSize = sizeof of;
 506 #endif
 507         of.hwndOwner = GDK_WINDOW_HWND(GTK_WIDGET(parent)->window);
 508
 509         of.lpstrFile = w_file;
 510         of.nMaxFile = 2048;
 511         of.lpstrFileTitle = NULL;
 512         of.lpstrTitle = w_title;
 513         of.lpstrDefExt = L"";
 514         of.Flags = OFN_FILEMUSTEXIST | OFN_EXPLORER;
 515         retval = GetOpenFileNameW(&of);
 516
 517         if (! retval)
 518         {
 519                 if (CommDlgExtendedError())
 520                 {
 521                         gchar *error = g_strdup_printf(
 522                                 "File dialog box error (%x)", (gint) CommDlgExtendedError());
 523                         win32_message_dialog(NULL, GTK_MESSAGE_ERROR, error);
 524                         g_free(error);
 525                 }
 526                 return NULL;
 527         }
 528
 529         WideCharToMultiByte(CP_UTF8, 0, w_file, -1, tmp, sizeof(tmp), NULL, NULL);
 530
 531         return g_strdup(tmp);
 532 }
 533
 534
 535 void win32_show_font_dialog(void)
 536 {
 537         gint retval;
 538         CHOOSEFONT cf;
 539         LOGFONT lf;        /* logical font structure */
 540
 541         memset(&cf, 0, sizeof cf);
 542         cf.lStructSize = sizeof cf;
 543         cf.hwndOwner = GDK_WINDOW_HWND(main_widgets.window->window);
 544         cf.lpLogFont = &lf;
 545         cf.Flags = CF_APPLY | CF_NOSCRIPTSEL | CF_FORCEFONTEXIST | CF_INITTOLOGFONTSTRUCT | CF_SCREENFONTS;
 546
 547         retval = ChooseFont(&cf);
 548
 549         if (retval)
 550         {
 551                 gchar *editorfont = g_strdup_printf("%s %d", lf.lfFaceName, (cf.iPointSize / 10));
 552                 ui_set_editor_font(editorfont);
 553                 g_free(editorfont);
 554         }
 555 }
 556
 557
 558 void win32_show_color_dialog(const gchar *colour)
 559 {
 560         CHOOSECOLOR cc;
 561         static COLORREF acr_cust_clr[16];
 562         static DWORD rgb_current;
 563         gchar *hex = g_malloc0(12);
 564         GeanyDocument *doc = document_get_current();
 565
 566         /* Initialize CHOOSECOLOR */
 567         memset(&cc, 0, sizeof cc);
 568         cc.lStructSize = sizeof(cc);
 569         cc.hwndOwner = GDK_WINDOW_HWND(main_widgets.window->window);
 570         cc.lpCustColors = (LPDWORD) acr_cust_clr;
 571         cc.rgbResult = (colour != NULL) ? utils_strtod(colour, NULL, colour[0] == '#') : 0;
 572         cc.Flags = CC_FULLOPEN | CC_RGBINIT;
 573
 574         if (ChooseColor(&cc))
 575         {
 576                 rgb_current = cc.rgbResult;
 577                 g_snprintf(hex, 11, "#%02X%02X%02X",
 578               (guint) (utils_scale_round(GetRValue(rgb_current), 255)),
 579               (guint) (utils_scale_round(GetGValue(rgb_current), 255)),
 580               (guint) (utils_scale_round(GetBValue(rgb_current), 255)));
 581
 582                 editor_insert_color(doc->editor, hex);
 583         }
 584         g_free(hex);
 585 }
 586
 587
 588 void win32_show_pref_file_dialog(GtkEntry *item)
 589 {
 590         OPENFILENAMEW of;
 591         gint retval, len;
 592         wchar_t fname[MAX_PATH];
 593         gchar tmp[MAX_PATH];
 594         gchar **field, *filename;
 595
 596         fname[0] = '\0';
 597
 598         /* cut the options from the command line */
 599         field = g_strsplit(gtk_entry_get_text(GTK_ENTRY(item)), " ", 2);
 600         if (field[0])
 601         {
 602                 filename = g_find_program_in_path(field[0]);
 603                 if (filename != NULL && g_file_test(filename, G_FILE_TEST_EXISTS))
 604                 {
 605                         MultiByteToWideChar(CP_UTF8, 0, filename, -1, fname, sizeof(fname));
 606                         g_free(filename);
 607                 }
 608         }
 609
 610         /* initialize file dialog info struct */
 611         memset(&of, 0, sizeof of);
 612 #ifdef OPENFILENAME_SIZE_VERSION_400
 613         of.lStructSize = OPENFILENAME_SIZE_VERSION_400;
 614 #else
 615         of.lStructSize = sizeof of;
 616 #endif
 617         of.hwndOwner = GDK_WINDOW_HWND(ui_widgets.prefs_dialog->window);
 618
 619         of.lpstrFilter = get_filters(FALSE);
 620         of.lpstrCustomFilter = NULL;
 621         of.nFilterIndex = 1;
 622
 623         of.lpstrFile = fname;
 624         of.nMaxFile = 2048;
 625         of.lpstrFileTitle = NULL;
 626         /*of.lpstrInitialDir = g_get_home_dir();*/
 627         of.lpstrInitialDir = NULL;
 628         of.lpstrTitle = NULL;
 629         of.lpstrDefExt = L"exe";
 630         of.Flags = OFN_HIDEREADONLY | OFN_FILEMUSTEXIST | OFN_EXPLORER;
 631         retval = GetOpenFileNameW(&of);
 632
 633         if (!retval)
 634         {
 635                 if (CommDlgExtendedError())
 636                 {
 637                         gchar error[100];
 638                         g_snprintf(error, sizeof error, "File dialog box error (%x)", (int)CommDlgExtendedError());
 639                         win32_message_dialog(NULL, GTK_MESSAGE_ERROR, error);
 640                 }
 641                 g_strfreev(field);
 642                 return;
 643         }
 644
 645         len = WideCharToMultiByte(CP_UTF8, 0, fname, -1, tmp, sizeof(tmp), NULL, NULL);
 646         if ((of.nFileOffset - 1) != len)
 647         {
 648                 if (g_strv_length(field) > 1)
 649                         /* add the command line args of the old command */
 650                         /** TODO this fails badly when the old command contained spaces, we need quoting here */
 651                         filename = g_strconcat(tmp, " ", field[1], NULL);
 652                 else
 653                 {
 654                         filename = g_strdup(tmp);
 655                 }
 656                 gtk_entry_set_text(GTK_ENTRY(item), filename);
 657                 g_free(filename);
 658         }
 659         g_strfreev(field);
 660 }
 661
 662
 663 /* Creates a native Windows message box of the given type and returns always TRUE
 664  * or FALSE representing th pressed Yes or No button.
 665  * If type is not GTK_MESSAGE_QUESTION, it returns always TRUE. */
 666 gboolean win32_message_dialog(GtkWidget *parent, GtkMessageType type, const gchar *msg)
 667 {
 668         gboolean ret = TRUE;
 669         gint rc;
 670         guint t;
 671         const gchar *title;
 672         HWND parent_hwnd = NULL;
 673         static wchar_t w_msg[512];
 674         static wchar_t w_title[512];
 675
 676         switch (type)
 677         {
 678                 case GTK_MESSAGE_ERROR:
 679                 {
 680                         t = MB_OK | MB_ICONERROR;
 681                         title = _("Error");
 682                         break;
 683                 }
 684                 case GTK_MESSAGE_QUESTION:
 685                 {
 686                         t = MB_YESNO | MB_ICONQUESTION;
 687                         title = _("Question");
 688                         break;
 689                 }
 690                 case GTK_MESSAGE_WARNING:
 691                 {
 692                         t = MB_OK | MB_ICONWARNING;
 693                         title = _("Warning");
 694                         break;
 695                 }
 696                 default:
 697                 {
 698                         t = MB_OK | MB_ICONINFORMATION;
 699                         title = _("Information");
 700                         break;
 701                 }
 702         }
 703
 704         /* convert the Unicode chars to wide chars */
 705         /** TODO test if LANG == C then possibly skip conversion => g_win32_getlocale() */
 706         MultiByteToWideChar(CP_UTF8, 0, msg, -1, w_msg, G_N_ELEMENTS(w_msg));
 707         MultiByteToWideChar(CP_UTF8, 0, title, -1, w_title, G_N_ELEMENTS(w_title));
 708
 709         if (parent != NULL)
 710                 parent_hwnd = GDK_WINDOW_HWND(parent->window);
 711         else if (main_widgets.window != NULL)
 712                 parent_hwnd = GDK_WINDOW_HWND(main_widgets.window->window);
 713
 714         /* display the message box */
 715         rc = MessageBoxW(parent_hwnd, w_msg, w_title, t);
 716
 717         if (type == GTK_MESSAGE_QUESTION && rc != IDYES)
 718                 ret = FALSE;
 719
 720         return ret;
 721 }
 722
 723
 724 /* Little wrapper for _waccess(), returns errno or 0 if there was no error */
 725 gint win32_check_write_permission(const gchar *dir)
 726 {
 727         static wchar_t w_dir[MAX_PATH];
 728         MultiByteToWideChar(CP_UTF8, 0, dir, -1, w_dir, sizeof w_dir);
 729         if (_waccess(w_dir, R_OK | W_OK) != 0)
 730                 return errno;
 731         else
 732                 return 0;
 733 }
 734
 735
 736 /* Special dialog to ask for an action when closing an unsaved file */
 737 gint win32_message_dialog_unsaved(const gchar *msg)
 738 {
 739         static wchar_t w_msg[512];
 740         static wchar_t w_title[512];
 741         HWND parent_hwnd = NULL;
 742         gint ret;
 743
 744         /* convert the Unicode chars to wide chars */
 745         MultiByteToWideChar(CP_UTF8, 0, msg, -1, w_msg, G_N_ELEMENTS(w_msg));
 746         MultiByteToWideChar(CP_UTF8, 0, _("Question"), -1, w_title, G_N_ELEMENTS(w_title));
 747
 748         if (main_widgets.window != NULL)
 749                 parent_hwnd = GDK_WINDOW_HWND(main_widgets.window->window);
 750
 751         ret = MessageBoxW(parent_hwnd, w_msg, w_title, MB_YESNOCANCEL | MB_ICONQUESTION);
 752         switch (ret)
 753         {
 754                 case IDYES: ret = GTK_RESPONSE_YES; break;
 755                 case IDNO: ret = GTK_RESPONSE_NO; break;
 756                 case IDCANCEL: ret = GTK_RESPONSE_CANCEL; break;
 757         }
 758
 759         return ret;
 760 }
 761
 762
 763 /* Just a simple wrapper function to open a browser window */
 764 void win32_open_browser(const gchar *uri)
 765 {
 766         if (strncmp(uri, "file://", 7) == 0)
 767         {
 768                 uri += 7;
 769                 if (strchr(uri, ':') != NULL)
 770                 {
 771                         while (*uri == '/')
 772                                 uri++;
 773                 }
 774         }
 775         ShellExecute(NULL, "open", uri, NULL, NULL, SW_SHOWNORMAL);
 776 }
 777
 778
 779 /* Returns TRUE if the command, which child_pid refers to, returned with a successful exit code,
 780  * otherwise FALSE. */
 781 gboolean win32_get_exit_status(GPid child_pid)
 782 {
 783         DWORD exit_code;
 784         GetExitCodeProcess(child_pid, &exit_code);
 785
 786         return (exit_code == 0);
 787 }
 788
 789
 790 static void debug_setup_console()
 791 {
 792         static const WORD MAX_CONSOLE_LINES = 500;
 793         gint     hConHandle;
 794         glong    lStdHandle;
 795         CONSOLE_SCREEN_BUFFER_INFO coninfo;
 796         FILE    *fp;
 797
 798         /* allocate a console for this app */
 799         AllocConsole();
 800
 801         /* set the screen buffer to be big enough to let us scroll text */
 802         GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &coninfo);
 803         coninfo.dwSize.Y = MAX_CONSOLE_LINES;
 804         SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE), coninfo.dwSize);
 805
 806         /* redirect unbuffered STDOUT to the console */
 807         lStdHandle = (long)GetStdHandle(STD_OUTPUT_HANDLE);
 808         hConHandle = _open_osfhandle(lStdHandle, _O_TEXT);
 809         fp = _fdopen(hConHandle, "w");
 810         *stdout = *fp;
 811         setvbuf(stdout, NULL, _IONBF, 0);
 812
 813         /* redirect unbuffered STDERR to the console */
 814         lStdHandle = (long)GetStdHandle(STD_ERROR_HANDLE);
 815         hConHandle = _open_osfhandle(lStdHandle, _O_TEXT);
 816         fp = _fdopen(hConHandle, "w");
 817         *stderr = *fp;
 818         setvbuf(stderr, NULL, _IONBF, 0);
 819 }
 820
 821
 822 void win32_init_debug_code(void)
 823 {
 824         if (app->debug_mode)
 825         {
 826                 /* create a console window to get log messages on Windows */
 827                 /** TODO remove me? */
 828                 debug_setup_console();
 829                 /* Enable GLib process spawn debug mode when Geany was started with the debug flag */
 830                 g_setenv("G_SPAWN_WIN32_DEBUG", "1", FALSE);
 831         }
 832 }
 833
 834
 835 gchar *win32_get_hostname(void)
 836 {
 837         gchar hostname[100];
 838         DWORD size = sizeof(hostname);
 839
 840         if (GetComputerName(hostname, &size))
 841                 return g_strdup(hostname);
 842         else
 843                 return g_strdup("localhost");
 844 }
 845
 846
 847 /* Process spawning implementation for Windows, by Pierre Joye.
 848  * Don't call this function directly, use utils_spawn_[a]sync() instead. */
 849 gboolean win32_spawn(const gchar *dir, gchar **argv, gchar **env, GSpawnFlags flags,
 850                                          gchar **std_out, gchar **std_err, gint *exit_status, GError **error)
 851 {
 852         TCHAR  buffer[CMDSIZE]=TEXT("");
 853         TCHAR  cmdline[CMDSIZE] = TEXT("");
 854         TCHAR* lpPart[CMDSIZE]={NULL};
 855         DWORD  retval = 0;
 856         gint argc = 0, i;
 857         gint cmdpos = 0;
 858
 859         SECURITY_ATTRIBUTES saAttr;
 860         BOOL fSuccess;
 861         geany_win32_spawn gw_spawn;
 862
 863         /* Temp file */
 864         HANDLE hStdoutTempFile = NULL;
 865         HANDLE hStderrTempFile = NULL;
 866
 867         gchar *stdout_content = NULL;
 868         gchar *stderr_content = NULL;
 869
 870         while (argv[argc])
 871         {
 872                 ++argc;
 873         }
 874         g_return_val_if_fail (std_out == NULL ||
 875                                                 !(flags & G_SPAWN_STDOUT_TO_DEV_NULL), FALSE);
 876         g_return_val_if_fail (std_err == NULL ||
 877                                                 !(flags & G_SPAWN_STDERR_TO_DEV_NULL), FALSE);
 878
 879         if (flags & G_SPAWN_SEARCH_PATH)
 880         {
 881                 retval = SearchPath(NULL, argv[0], ".exe", sizeof(buffer), buffer, lpPart);
 882                 if (retval > 0)
 883                         g_snprintf(cmdline, sizeof(cmdline), "\"%s\"", buffer);
 884                 else
 885                         g_strlcpy(cmdline, argv[0], sizeof(cmdline));
 886                 cmdpos = 1;
 887         }
 888
 889         for (i = cmdpos; i < argc; i++)
 890         {
 891                 g_snprintf(cmdline, sizeof(cmdline), "%s %s", cmdline, argv[i]);
 892                 /*MessageBox(NULL, cmdline, cmdline, MB_OK);*/
 893         }
 894
 895         if (std_err != NULL)
 896         {
 897                 hStderrTempFile = GetTempFileHandle(error);
 898                 if (hStderrTempFile == INVALID_HANDLE_VALUE)
 899                 {
 900                         gchar *msg = g_win32_error_message(GetLastError());
 901                         geany_debug("win32_spawn: Second CreateFile failed (%d)", (gint) GetLastError());
 902                         if (error != NULL)
 903                                 *error = g_error_new(G_SPAWN_ERROR, G_FILE_ERROR, "%s", msg);
 904                         g_free(msg);
 905                         return FALSE;
 906                 }
 907         }
 908
 909         if (std_out != NULL)
 910         {
 911                 hStdoutTempFile = GetTempFileHandle(error);
 912                 if (hStdoutTempFile == INVALID_HANDLE_VALUE)
 913                 {
 914                         gchar *msg = g_win32_error_message(GetLastError());
 915                         geany_debug("win32_spawn: Second CreateFile failed (%d)", (gint) GetLastError());
 916                         if (error != NULL)
 917                                 *error = g_error_new(G_SPAWN_ERROR, G_FILE_ERROR, "%s", msg);
 918                         g_free(msg);
 919                         return FALSE;
 920                 }
 921         }
 922
 923         /* Set the bInheritHandle flag so pipe handles are inherited. */
 924         saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
 925         saAttr.bInheritHandle = TRUE;
 926         saAttr.lpSecurityDescriptor = NULL;
 927
 928         /* Get the handle to the current STDOUT and STDERR. */
 929         gw_spawn.hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
 930         gw_spawn.hStderr = GetStdHandle(STD_ERROR_HANDLE);
 931         gw_spawn.dwExitCode = 0;
 932
 933         /* Create a pipe for the child process's STDOUT. */
 934         if (! CreatePipe(&(gw_spawn.hChildStdoutRd), &(gw_spawn.hChildStdoutWr), &saAttr, 0))
 935         {
 936                 gchar *msg = g_win32_error_message(GetLastError());
 937                 geany_debug("win32_spawn: Stdout pipe creation failed (%d)", (gint) GetLastError());
 938                 if (error != NULL)
 939                         *error = g_error_new(G_SPAWN_ERROR, G_FILE_ERROR_PIPE, "%s", msg);
 940                 g_free(msg);
 941                 return FALSE;
 942         }
 943
 944         /* Ensure that the read handle to the child process's pipe for STDOUT is not inherited.*/
 945         SetHandleInformation(gw_spawn.hChildStdoutRd, HANDLE_FLAG_INHERIT, 0);
 946
 947         /* Create a pipe for the child process's STDERR. */
 948         if (! CreatePipe(&(gw_spawn.hChildStderrRd), &(gw_spawn.hChildStderrWr), &saAttr, 0))
 949         {
 950                 gchar *msg = g_win32_error_message(GetLastError());
 951                 geany_debug("win32_spawn: Stderr pipe creation failed");
 952                 if (error != NULL)
 953                         *error = g_error_new(G_SPAWN_ERROR, G_FILE_ERROR_PIPE, "%s", msg);
 954                 g_free(msg);
 955                 return FALSE;
 956         }
 957
 958         /* Ensure that the read handle to the child process's pipe for STDOUT is not inherited.*/
 959         SetHandleInformation(gw_spawn.hChildStderrRd, HANDLE_FLAG_INHERIT, 0);
 960
 961         /* Create a pipe for the child process's STDIN.  */
 962         if (! CreatePipe(&(gw_spawn.hChildStdinRd), &(gw_spawn.hChildStdinWr), &saAttr, 0))
 963         {
 964                 gchar *msg = g_win32_error_message(GetLastError());
 965                 geany_debug("win32_spawn: Stdin pipe creation failed");
 966                 if (error != NULL)
 967                         *error = g_error_new(G_SPAWN_ERROR, G_FILE_ERROR_PIPE, "%s", msg);
 968                 g_free(msg);
 969                 return FALSE;
 970         }
 971
 972         /* Ensure that the write handle to the child process's pipe for STDIN is not inherited. */
 973         SetHandleInformation(gw_spawn.hChildStdinWr, HANDLE_FLAG_INHERIT, 0);
 974
 975         /* Now create the child process. */
 976         fSuccess = CreateChildProcess(&gw_spawn, cmdline, dir, error);
 977         if (exit_status)
 978         {
 979                 *exit_status = gw_spawn.dwExitCode;
 980         }
 981
 982         if (! fSuccess)
 983         {
 984                 geany_debug("win32_spawn: Create process failed");
 985                 if (error != NULL)
 986                         *error = g_error_new(G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED, "Create process failed");
 987                 return FALSE;
 988         }
 989
 990         /* Read from pipe that is the standard output for child process. */
 991         if (std_out != NULL)
 992         {
 993                 ReadFromPipe(gw_spawn.hChildStdoutRd, gw_spawn.hChildStdoutWr, hStdoutTempFile, error);
 994                 if (! GetContentFromHandle(hStdoutTempFile, &stdout_content, error))
 995                 {
 996                         return FALSE;
 997                 }
 998                 *std_out = stdout_content;
 999         }
1000
1001         if (std_err != NULL)
1002         {
1003                 ReadFromPipe(gw_spawn.hChildStderrRd, gw_spawn.hChildStderrWr, hStderrTempFile, error);
1004                 if (! GetContentFromHandle(hStderrTempFile, &stderr_content, error))
1005                 {
1006                         return FALSE;
1007                 }
1008                 *std_err = stderr_content;
1009         }
1010         return TRUE;
1011 }
1012
1013
1014 static gboolean GetContentFromHandle(HANDLE hFile, gchar **content, GError **error)
1015 {
1016         DWORD filesize;
1017         gchar * buffer;
1018         DWORD dwRead;
1019
1020         filesize = GetFileSize(hFile, NULL);
1021         if (filesize < 1)
1022         {
1023                 *content = NULL;
1024                 return TRUE;
1025         }
1026
1027         buffer = g_malloc(filesize + 1);
1028         if (! buffer)
1029         {
1030                 gchar *msg = g_win32_error_message(GetLastError());
1031                 geany_debug("GetContentFromHandle: Alloc failed");
1032                 if (error != NULL)
1033                         *error = g_error_new(G_SPAWN_ERROR, G_SPAWN_ERROR, "%s", msg);
1034                 g_free(msg);
1035                 return FALSE;
1036         }
1037
1038         SetFilePointer(hFile, 0, NULL, FILE_BEGIN);
1039         if (! ReadFile(hFile, buffer, filesize, &dwRead, NULL) || dwRead == 0)
1040         {
1041                 gchar *msg = g_win32_error_message(GetLastError());
1042                 geany_debug("GetContentFromHandle: Cannot read tempfile");
1043                 if (error != NULL)
1044                         *error = g_error_new(G_SPAWN_ERROR, G_FILE_ERROR_FAILED, "%s", msg);
1045                 g_free(msg);
1046                 return FALSE;
1047         }
1048
1049         if (! CloseHandle(hFile))
1050         {
1051                 gchar *msg = g_win32_error_message(GetLastError());
1052                 geany_debug("GetContentFromHandle: CloseHandle failed (%d)", (gint) GetLastError());
1053                 if (error != NULL)
1054                         *error = g_error_new(G_SPAWN_ERROR, G_FILE_ERROR_FAILED, "%s", msg);
1055                 g_free(msg);
1056                 g_free(buffer);
1057                 *content = NULL;
1058                 return FALSE;
1059         }
1060         buffer[filesize] = '\0';
1061         *content = buffer;
1062         return TRUE;
1063 }
1064
1065
1066 gchar *win32_expand_environment_variables(const gchar *str)
1067 {
1068         gchar expCmdline[32768]; /* 32768 is the limit for ExpandEnvironmentStrings() */
1069
1070         if (ExpandEnvironmentStrings((LPCTSTR) str, (LPTSTR) expCmdline, sizeof(expCmdline)) != 0)
1071                 return g_strdup(expCmdline);
1072         else
1073                 return g_strdup(str);
1074 }
1075
1076
1077 static gboolean CreateChildProcess(geany_win32_spawn *gw_spawn, TCHAR *szCmdline, const TCHAR *dir, GError **error)
1078 {
1079         PROCESS_INFORMATION piProcInfo;
1080         STARTUPINFOW siStartInfo;
1081         BOOL bFuncRetn = FALSE;
1082         gchar *expandedCmdline;
1083         wchar_t w_commandline[CMDSIZE];
1084         wchar_t w_dir[MAX_PATH];
1085
1086         /* Set up members of the PROCESS_INFORMATION structure. */
1087         ZeroMemory(&piProcInfo, sizeof(PROCESS_INFORMATION));
1088
1089         /* Set up members of the STARTUPINFO structure.*/
1090         ZeroMemory(&siStartInfo, sizeof(STARTUPINFO));
1091
1092         siStartInfo.cb         = sizeof(STARTUPINFO);
1093         siStartInfo.hStdError  = gw_spawn->hChildStderrWr;
1094         siStartInfo.hStdOutput = gw_spawn->hChildStdoutWr;
1095         siStartInfo.hStdInput  = gw_spawn->hChildStdinRd;
1096         siStartInfo.dwFlags   |= STARTF_USESTDHANDLES;
1097
1098         /* Expand environment variables like %blah%. */
1099         expandedCmdline = win32_expand_environment_variables(szCmdline);
1100
1101         MultiByteToWideChar(CP_UTF8, 0, expandedCmdline, -1, w_commandline, sizeof(w_commandline));
1102         MultiByteToWideChar(CP_UTF8, 0, dir, -1, w_dir, sizeof(w_dir));
1103
1104         /* Create the child process. */
1105         bFuncRetn = CreateProcessW(NULL,
1106                 w_commandline,             /* command line */
1107                 NULL,          /* process security attributes */
1108                 NULL,          /* primary thread security attributes */
1109                 TRUE,          /* handles are inherited */
1110                 CREATE_NO_WINDOW,             /* creation flags */
1111                 NULL,          /* use parent's environment */
1112                 w_dir,           /* use parent's current directory */
1113                 &siStartInfo,  /* STARTUPINFO pointer */
1114                 &piProcInfo);  /* receives PROCESS_INFORMATION */
1115
1116         g_free(expandedCmdline);
1117
1118         if (bFuncRetn == 0)
1119         {
1120                 gchar *msg = g_win32_error_message(GetLastError());
1121                 geany_debug("CreateChildProcess: CreateProcess failed (%s)", msg);
1122                 if (*error != NULL)
1123                         *error = g_error_new(G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED, "%s", msg);
1124                 g_free(msg);
1125                 return FALSE;
1126         }
1127         else
1128         {
1129                 gint i;
1130                 DWORD dwStatus;
1131
1132                 for (i = 0; i < 2 && (dwStatus = WaitForSingleObject(piProcInfo.hProcess, 30*1000)) == WAIT_TIMEOUT; i++)
1133                 {
1134                         geany_debug("CreateChildProcess: CreateProcess failed");
1135                         TerminateProcess(piProcInfo.hProcess, WAIT_TIMEOUT); /* NOTE: This will not kill grandkids. */
1136                 }
1137
1138                 if (GetExitCodeProcess(piProcInfo.hProcess, &gw_spawn->dwExitCode) != 0)
1139                 {
1140                         gchar *msg = g_win32_error_message(GetLastError());
1141                         geany_debug("GetExitCodeProcess failed: %s", msg);
1142                         if (error != NULL)
1143                                 *error = g_error_new(G_SPAWN_ERROR, G_FILE_ERROR_FAILED, "%s", msg);
1144                         g_free(msg);
1145                 }
1146                 CloseHandle(piProcInfo.hProcess);
1147                 CloseHandle(piProcInfo.hThread);
1148                 return bFuncRetn;
1149         }
1150         return FALSE;
1151 }
1152
1153
1154 static VOID ReadFromPipe(HANDLE hRead, HANDLE hWrite, HANDLE hFile, GError **error)
1155 {
1156         DWORD dwRead, dwWritten;
1157         CHAR chBuf[BUFSIZE];
1158
1159         /* Close the write end of the pipe before reading from the
1160            read end of the pipe. */
1161         if (! CloseHandle(hWrite))
1162         {
1163                 gchar *msg = g_win32_error_message(GetLastError());
1164                 geany_debug("ReadFromPipe: Closing handle failed");
1165                 if (error != NULL)
1166                         *error = g_error_new(G_SPAWN_ERROR, G_FILE_ERROR_PIPE, "%s", msg);
1167                 g_free(msg);
1168                 return;
1169         }
1170
1171         /* Read output from the child process, and write to parent's STDOUT. */
1172         for (;;)
1173         {
1174                 if (! ReadFile(hRead, chBuf, BUFSIZE, &dwRead, NULL) || dwRead == 0)
1175                         break;
1176
1177                 if (! WriteFile(hFile, chBuf, dwRead, &dwWritten, NULL))
1178                         break;
1179         }
1180 }
1181
1182
1183 static HANDLE GetTempFileHandle(GError **error)
1184 {
1185         /* Temp file */
1186         DWORD dwBufSize = BUFSIZE;
1187         UINT uRetVal;
1188         TCHAR szTempName[BUFSIZE];
1189         TCHAR lpPathBuffer[BUFSIZE];
1190         DWORD dwRetVal;
1191         HANDLE hTempFile;
1192
1193         /* Get the temp path. */
1194         dwRetVal = GetTempPath(dwBufSize,     /* length of the buffer*/
1195                                                    lpPathBuffer); /* buffer for path */
1196
1197         if (dwRetVal > dwBufSize || (dwRetVal == 0))
1198         {
1199                 gchar *msg = g_win32_error_message(GetLastError());
1200                 geany_debug("GetTempFileHandle: GetTempPath failed (%d)", (gint) GetLastError());
1201                 if (error != NULL)
1202                         *error = g_error_new(G_SPAWN_ERROR, G_FILE_ERROR, "%s", msg);
1203                 g_free(msg);
1204                 return NULL;
1205         }
1206
1207         /* Create a temporary file for STDOUT. */
1208         uRetVal = GetTempFileName(lpPathBuffer, /* directory for tmp files */
1209                                                           TEXT("GEANY_VCDIFF_"),  /* temp file name prefix */
1210                                                           0,            /* create unique name */
1211                                                           szTempName);  /* buffer for name */
1212         if (uRetVal == 0)
1213         {
1214                 gchar *msg = g_win32_error_message(GetLastError());
1215                 geany_debug("GetTempFileName failed (%d)", (gint) GetLastError());
1216                 if (error != NULL)
1217                         *error = g_error_new(G_SPAWN_ERROR, G_FILE_ERROR, "%s", msg);
1218                 g_free(msg);
1219                 return NULL;
1220         }
1221
1222         hTempFile = CreateFile((LPTSTR) szTempName, /* file name */
1223                                                    GENERIC_READ | GENERIC_WRITE, /* open r-w */
1224                                                    0,                    /* do not share */
1225                                                    NULL,                 /* default security */
1226                                                    CREATE_ALWAYS,        /* overwrite existing */
1227                                                    FILE_ATTRIBUTE_NORMAL,/* normal file */
1228                                                    NULL);                /* no template */
1229
1230         if (hTempFile == INVALID_HANDLE_VALUE)
1231         {
1232                 gchar *msg = g_win32_error_message(GetLastError());
1233                 geany_debug("GetTempFileHandle: Second CreateFile failed (%d)", (gint) GetLastError());
1234                 if (error != NULL)
1235                         *error = g_error_new(G_SPAWN_ERROR, G_FILE_ERROR, "%s", msg);
1236                 g_free(msg);
1237                 return NULL;
1238         }
1239         return hTempFile;
1240 }
1241
1242
1243 /* From GDK (they got it from MS Knowledge Base article Q130698) */
1244 static gboolean resolve_link(HWND hWnd, wchar_t *link, gchar **lpszPath)
1245 {
1246         WIN32_FILE_ATTRIBUTE_DATA wfad;
1247         HRESULT hres;
1248         IShellLinkW *pslW = NULL;
1249         IPersistFile *ppf = NULL;
1250         LPVOID pslWV = NULL;
1251         LPVOID ppfV = NULL;
1252
1253         /* Check if the file is empty first because IShellLink::Resolve for some reason succeeds
1254          * with an empty file and returns an empty "link target". (#524151) */
1255         if (!GetFileAttributesExW(link, GetFileExInfoStandard, &wfad) ||
1256                 (wfad.nFileSizeHigh == 0 && wfad.nFileSizeLow == 0))
1257         {
1258           return FALSE;
1259         }
1260
1261         /* Assume failure to start with: */
1262         *lpszPath = 0;
1263
1264         CoInitialize(NULL);
1265
1266         hres = CoCreateInstance(
1267                 &CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, &IID_IShellLinkW, &pslWV);
1268
1269         if (SUCCEEDED(hres))
1270         {
1271                 /* The IShellLink interface supports the IPersistFile interface.
1272                  * Get an interface pointer to it. */
1273                 pslW = (IShellLinkW*) pslWV;
1274                 hres = pslW->lpVtbl->QueryInterface(pslW, &IID_IPersistFile, &ppfV);
1275         }
1276
1277         if (SUCCEEDED(hres))
1278         {
1279                 /* Load the file. */
1280                 ppf = (IPersistFile*) ppfV;
1281                 hres = ppf->lpVtbl->Load(ppf, link, STGM_READ);
1282         }
1283
1284         if (SUCCEEDED(hres))
1285         {
1286                 /* Resolve the link by calling the Resolve() interface function. */
1287                 hres = pslW->lpVtbl->Resolve(pslW, hWnd, SLR_ANY_MATCH | SLR_NO_UI);
1288         }
1289
1290         if (SUCCEEDED(hres))
1291         {
1292                 wchar_t wtarget[MAX_PATH];
1293
1294                 hres = pslW->lpVtbl->GetPath(pslW, wtarget, MAX_PATH, NULL, 0);
1295                 if (SUCCEEDED(hres))
1296                         *lpszPath = g_utf16_to_utf8(wtarget, -1, NULL, NULL, NULL);
1297         }
1298
1299         if (ppf)
1300                 ppf->lpVtbl->Release(ppf);
1301
1302         if (pslW)
1303                 pslW->lpVtbl->Release(pslW);
1304
1305         return SUCCEEDED(hres);
1306 }
1307
1308
1309 /* Checks whether file_name is a Windows shortcut. file_name is expected in UTF-8 encoding.
1310  * If file_name is a Windows shortcut, it returns the target in UTF-8 encoding.
1311  * If it is not a shortcut, it returns a newly allocated copy of file_name. */
1312 gchar *win32_get_shortcut_target(const gchar *file_name)
1313 {
1314         gchar *path = NULL;
1315         wchar_t *wfilename = g_utf8_to_utf16(file_name, -1, NULL, NULL, NULL);
1316
1317         resolve_link(GDK_WINDOW_HWND(main_widgets.window->window), wfilename, &path);
1318         g_free(wfilename);
1319
1320         if (path == NULL)
1321                 return g_strdup(file_name);
1322         else
1323                 return path;
1324 }
1325
1326
1327 void win32_set_working_directory(const gchar *dir)
1328 {
1329         SetCurrentDirectory(dir);
1330 }
1331
1332
1333 gchar *win32_get_installation_dir(void)
1334 {
1335 #if GLIB_CHECK_VERSION(2, 16, 0)
1336         return g_win32_get_package_installation_directory_of_module(NULL);
1337 #else
1338         return g_win32_get_package_installation_directory(NULL, NULL);
1339 #endif
1340 }
1341
1342
1343 #endif