/*
 *      win32.c - this file is part of Geany, a fast and lightweight IDE
 *
 *      Copyright 2005-2012 Enrico Tröger <enrico(dot)troeger(at)uvena(dot)de>
 *      Copyright 2006-2012 Nick Treleaven <nick(dot)treleaven(at)btinternet(dot)com>
 *
 *      This program is free software; you can redistribute it and/or modify
 *      it under the terms of the GNU General Public License as published by
 *      the Free Software Foundation; either version 2 of the License, or
 *      (at your option) any later version.
 *
 *      This program is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *      GNU General Public License for more details.
 *
 *      You should have received a copy of the GNU General Public License along
 *      with this program; if not, write to the Free Software Foundation, Inc.,
 *      51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

/*
 * Special functions for the win32 platform, to provide native dialogs.
 */

#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

#include "win32.h"

#ifdef G_OS_WIN32

#include "dialogs.h"
#include "document.h"
#include "editor.h"
#include "filetypes.h"
#include "project.h"
#include "support.h"
#include "ui_utils.h"
#include "utils.h"

#include <ctype.h>
#include <fcntl.h>
#include <io.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>

#define VC_EXTRALEAN
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <commdlg.h>
#include <shellapi.h>
#include <shlobj.h>

#include <glib/gstdio.h>
#include <gdk/gdkwin32.h>

#define BUFSIZE 4096
#define CMDSIZE 32768

struct _geany_win32_spawn
{
	HANDLE hChildStdinRd;
	HANDLE hChildStdinWr;
	HANDLE hChildStdoutRd;
	HANDLE hChildStdoutWr;
	HANDLE hChildStderrRd;
	HANDLE hChildStderrWr;
	HANDLE hInputFile;
	HANDLE hStdout;
	HANDLE hStderr;
	HANDLE processId;
	DWORD dwExitCode;
};
typedef struct _geany_win32_spawn geany_win32_spawn;

static gboolean GetContentFromHandle(HANDLE hFile, gchar **content, GError **error);
static HANDLE GetTempFileHandle(GError **error);
static gboolean CreateChildProcess(geany_win32_spawn *gw_spawn, TCHAR *szCmdline,
		const TCHAR *dir, GError **error);
static VOID ReadFromPipe(HANDLE hRead, HANDLE hWrite, HANDLE hFile, GError **error);


/* The timer handle used to refresh windows below modal native dialogs. If
 * ever more than one dialog can be shown at a time, this needs to be changed
 * to be for specific dialogs. */
static UINT_PTR dialog_timer = 0;


G_INLINE_FUNC void win32_dialog_reset_timer(HWND hwnd)
{
	if (G_UNLIKELY(dialog_timer != 0))
	{
		KillTimer(hwnd, dialog_timer);
		dialog_timer = 0;
	}
}


VOID CALLBACK
win32_dialog_update_main_window(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
{
	gint i;

	/* Pump the main window loop a bit, but not enough to lock-up.
	 * The typical `while(gtk_events_pending()) gtk_main_iteration();`
	 * loop causes the entire operating system to lock-up. */
	for (i = 0; i < 4 && gtk_events_pending(); i++)
		gtk_main_iteration();

	/* Cancel any pending timers since we just did an update */
	win32_dialog_reset_timer(hwnd);
}


G_INLINE_FUNC UINT_PTR win32_dialog_queue_main_window_redraw(HWND dlg, UINT msg,
	WPARAM wParam, LPARAM lParam, gboolean postpone)
{
	switch (msg)
	{
		/* Messages that likely mean the window below a dialog needs to be re-drawn. */
		case WM_WINDOWPOSCHANGED:
		case WM_MOVE:
		case WM_SIZE:
		case WM_THEMECHANGED:
			if (postpone)
			{
				win32_dialog_reset_timer(dlg);
				dialog_timer = SetTimer(dlg, 0, 33 /* around 30fps */, win32_dialog_update_main_window);
			}
			else
				win32_dialog_update_main_window(dlg, msg, wParam, lParam);
			break;
	}
	return 0; /* always let the default proc handle it */
}


/* This function is called for OPENFILENAME lpfnHook function and it establishes
 * a timer that is reset each time which will update the main window loop eventually. */
UINT_PTR CALLBACK win32_dialog_explorer_hook_proc(HWND dlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
	return win32_dialog_queue_main_window_redraw(dlg, msg, wParam, lParam, TRUE);
}


/* This function is called for old-school win32 dialogs that accept a proper
 * lpfnHook function for all messages, it doesn't use a timer. */
UINT_PTR CALLBACK win32_dialog_hook_proc(HWND dlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
	return win32_dialog_queue_main_window_redraw(dlg, msg, wParam, lParam, FALSE);
}


static wchar_t *get_file_filters(void)
{
	gchar *string;
	guint i, j, len;
	static wchar_t title[4096];
	GString *str = g_string_sized_new(100);
	GString *all_patterns = g_string_sized_new(100);
	GSList *node;
	gchar *tmp;

	/* create meta file filter "All files" */
	g_string_append_printf(str, "%s\t*\t", _("All files"));
	/* create meta file filter "All Source" (skip GEANY_FILETYPES_NONE) */
	for (i = GEANY_FILETYPES_NONE + 1; i < filetypes_array->len; i++)
	{
		for (j = 0; filetypes[i]->pattern[j] != NULL; j++)
		{
			g_string_append(all_patterns, filetypes[i]->pattern[j]);
			g_string_append_c(all_patterns, ';');
		}
	}
	g_string_append_printf(str, "%s\t%s\t", _("All Source"), all_patterns->str);
	g_string_free(all_patterns, TRUE);
	/* add 'usual' filetypes */
	foreach_slist(node, filetypes_by_title)
	{
		GeanyFiletype *ft = node->data;

		if (G_UNLIKELY(ft->id == GEANY_FILETYPES_NONE))
			continue;
		tmp = g_strjoinv(";", ft->pattern);
		g_string_append_printf(str, "%s\t%s\t", ft->title, tmp);
		g_free(tmp);
	}
	g_string_append_c(str, '\t'); /* the final \0 byte to mark the end of the string */
	string = str->str;
	g_string_free(str, FALSE);

	/* replace all "\t"s by \0 */
	len = strlen(string);
	g_strdelimit(string, "\t", '\0');
	g_assert(string[len - 1] == 0x0);
	MultiByteToWideChar(CP_UTF8, 0, string, len, title, G_N_ELEMENTS(title));
	g_free(string);

	return title;
}


static wchar_t *get_file_filter_all_files(void)
{
	guint len;
	static wchar_t title[4096];
	gchar *filter;

	/* create meta file filter "All files" */
	filter = g_strdup_printf("%s\t*\t", _("All files"));

	len = strlen(filter);
	g_strdelimit(filter, "\t", '\0');
	g_assert(filter[len - 1] == 0x0);
	MultiByteToWideChar(CP_UTF8, 0, filter, len, title, G_N_ELEMENTS(title));
	g_free(filter);

	return title;
}


static wchar_t *get_filters(gboolean project_files)
{
	gchar *string;
	gint len;
	static wchar_t title[1024];

	if (project_files)
	{
		string = g_strconcat(_("Geany project files"), "\t", "*." GEANY_PROJECT_EXT, "\t",
			_("All files"), "\t", "*", "\t", NULL);
	}
	else
	{
		string = g_strconcat(_("Executables"), "\t", "*.exe;*.bat;*.cmd", "\t",
			_("All files"), "\t", "*", "\t", NULL);
	}

	/* replace all "\t"s by \0 */
	len = strlen(string);
	g_strdelimit(string, "\t", '\0');
	g_assert(string[len - 1] == 0x0);
	MultiByteToWideChar(CP_UTF8, 0, string, len, title, G_N_ELEMENTS(title));
	g_free(string);

	return title;
}


/* Converts the given UTF-8 filename or directory name into something usable for Windows and
 * returns the directory part of the given filename. */
static wchar_t *get_dir_for_path(const gchar *utf8_filename)
{
	static wchar_t w_dir[MAX_PATH];
	gchar *result;

	if (g_file_test(utf8_filename, G_FILE_TEST_IS_DIR))
		result = (gchar*) utf8_filename;
	else
		result = g_path_get_dirname(utf8_filename);

	MultiByteToWideChar(CP_UTF8, 0, result, -1, w_dir, G_N_ELEMENTS(w_dir));

	if (result != utf8_filename)
		g_free(result);

	return w_dir;
}


/* Callback function for setting the initial directory of the folder open dialog. This could also
 * be done with BROWSEINFO.pidlRoot and SHParseDisplayName but SHParseDisplayName is not available
 * on systems below Windows XP. So, we go the hard way by creating a callback which will set up the
 * folder when the dialog is initialised. Yeah, I like Windows. */
INT CALLBACK BrowseCallbackProc(HWND hwnd, UINT uMsg, LPARAM lp, LPARAM pData)
{
	win32_dialog_hook_proc(hwnd, uMsg, lp, pData);
	switch (uMsg)
	{
		case BFFM_INITIALIZED:
		{
			SendMessageW(hwnd, BFFM_SETSELECTIONW, TRUE, pData);
			break;
		}
		case BFFM_SELCHANGED:
		{
			/* set the status window to the currently selected path. */
			static wchar_t szDir[MAX_PATH];
			if (SHGetPathFromIDListW((LPITEMIDLIST) lp, szDir))
			{
				SendMessageW(hwnd, BFFM_SETSTATUSTEXTW, 0, (LPARAM) szDir);
			}
			break;
		}
	}
	return 0;
}


/* Shows a folder selection dialog.
 * initial_dir is expected in UTF-8
 * The selected folder name is returned. */
gchar *win32_show_folder_dialog(GtkWidget *parent, const gchar *title, const gchar *initial_dir)
{
	BROWSEINFOW bi;
	LPCITEMIDLIST pidl;
	gchar *result = NULL;
	wchar_t fname[MAX_PATH];
	wchar_t w_title[512];

	MultiByteToWideChar(CP_UTF8, 0, title, -1, w_title, G_N_ELEMENTS(w_title));

	if (parent == NULL)
		parent = main_widgets.window;

	memset(&bi, 0, sizeof bi);
	bi.hwndOwner = GDK_WINDOW_HWND(gtk_widget_get_window(parent));
	bi.pidlRoot = NULL;
	bi.lpszTitle = w_title;
	bi.lpfn = BrowseCallbackProc;
	bi.lParam = (LPARAM) get_dir_for_path(initial_dir);
	bi.ulFlags = BIF_DONTGOBELOWDOMAIN | BIF_RETURNONLYFSDIRS | BIF_STATUSTEXT;

	pidl = SHBrowseForFolderW(&bi);

	/* convert the strange Windows folder list item something into an usual path string ;-) */
	if (pidl != 0)
	{
		if (SHGetPathFromIDListW(pidl, fname))
		{
			result = g_malloc0(MAX_PATH * 2);
			WideCharToMultiByte(CP_UTF8, 0, fname, -1, result, MAX_PATH * 2, NULL, NULL);
		}
		/* SHBrowseForFolder() probably leaks memory here, but how to free the allocated memory? */
	}
	return result;
}


/* Shows a file open dialog.
 * If allow_new_file is set, the file to be opened doesn't have to exist.
 * initial_dir is expected in UTF-8
 * The selected file name is returned.
 * If project_file_filter is set, the file open dialog will have a file filter for Geany project
 * files, a filter for executables otherwise. */
gchar *win32_show_project_open_dialog(GtkWidget *parent, const gchar *title,
								      const gchar *initial_dir, gboolean allow_new_file,
								      gboolean project_file_filter)
{
	OPENFILENAMEW of;
	gint retval;
	wchar_t fname[MAX_PATH];
	wchar_t w_title[512];
	gchar *filename;

	fname[0] = '\0';

	MultiByteToWideChar(CP_UTF8, 0, title, -1, w_title, G_N_ELEMENTS(w_title));

	if (parent == NULL)
		parent = main_widgets.window;

	/* initialise file dialog info struct */
	memset(&of, 0, sizeof of);
#ifdef OPENFILENAME_SIZE_VERSION_400
	of.lStructSize = OPENFILENAME_SIZE_VERSION_400;
#else
	of.lStructSize = sizeof of;
#endif
	of.hwndOwner = GDK_WINDOW_HWND(gtk_widget_get_window(parent));
	of.lpstrFilter = get_filters(project_file_filter);

	of.lpstrCustomFilter = NULL;
	of.nFilterIndex = 0;
	of.lpstrFile = fname;
	of.lpstrInitialDir = get_dir_for_path(initial_dir);
	of.nMaxFile = 2048;
	of.lpstrFileTitle = NULL;
	of.lpstrTitle = w_title;
	of.lpstrDefExt = L"";
	of.Flags = OFN_PATHMUSTEXIST | OFN_EXPLORER | OFN_HIDEREADONLY | OFN_ENABLEHOOK;
	of.lpfnHook = win32_dialog_explorer_hook_proc;
	if (! allow_new_file)
		of.Flags |= OFN_FILEMUSTEXIST;

	retval = GetOpenFileNameW(&of);

	if (! retval)
	{
		if (CommDlgExtendedError())
		{
			gchar *error;
			error = g_strdup_printf("File dialog box error (%x)", (int)CommDlgExtendedError());
			win32_message_dialog(NULL, GTK_MESSAGE_ERROR, error);
			g_free(error);
		}
		return NULL;
	}
	/* convert the resulting filename into UTF-8 (from whatever encoding it has at this moment) */
	filename = g_malloc0(MAX_PATH * 2);
	WideCharToMultiByte(CP_UTF8, 0, fname, -1, filename, MAX_PATH * 2, NULL, NULL);

	return filename;
}


/* initial_dir can be NULL to use the current working directory.
 * Returns: TRUE if the dialog was not cancelled. */
gboolean win32_show_document_open_dialog(GtkWindow *parent, const gchar *title, const gchar *initial_dir)
{
	OPENFILENAMEW of;
	gint retval;
	guint x;
	gchar tmp[MAX_PATH];
	wchar_t fname[MAX_PATH];
	wchar_t w_dir[MAX_PATH];
	wchar_t w_title[512];

	fname[0] = '\0';

	if (initial_dir != NULL)
		MultiByteToWideChar(CP_UTF8, 0, initial_dir, -1, w_dir, G_N_ELEMENTS(w_dir));

	MultiByteToWideChar(CP_UTF8, 0, title, -1, w_title, G_N_ELEMENTS(w_title));

	/* initialise file dialog info struct */
	memset(&of, 0, sizeof of);
#ifdef OPENFILENAME_SIZE_VERSION_400
	of.lStructSize = OPENFILENAME_SIZE_VERSION_400;
#else
	of.lStructSize = sizeof of;
#endif
	of.hwndOwner = GDK_WINDOW_HWND(gtk_widget_get_window(GTK_WIDGET(parent)));
	of.lpstrFilter = get_file_filters();

	of.lpstrCustomFilter = NULL;
	of.nFilterIndex = GEANY_FILETYPES_NONE + 1;
	of.lpstrFile = fname;
	of.lpstrInitialDir = (initial_dir != NULL) ? w_dir : NULL;
	of.nMaxFile = 2048;
	of.lpstrFileTitle = NULL;
	of.lpstrTitle = w_title;
	of.lpstrDefExt = L"";
	of.Flags = OFN_ALLOWMULTISELECT | OFN_FILEMUSTEXIST | OFN_EXPLORER | OFN_ENABLEHOOK;
	of.lpfnHook = win32_dialog_explorer_hook_proc;

	retval = GetOpenFileNameW(&of);

	if (!retval)
	{
		if (CommDlgExtendedError())
		{
			gchar error[100];
			g_snprintf(error, sizeof error, "File dialog box error (%x)", (int)CommDlgExtendedError());
			win32_message_dialog(NULL, GTK_MESSAGE_ERROR, error);
		}
		return FALSE;
	}

	x = of.nFileOffset - 1;
	if (x != wcslen(fname))
	{	/* open a single file */
		WideCharToMultiByte(CP_UTF8, 0, fname, -1, tmp, sizeof(tmp), NULL, NULL);
		document_open_file(tmp, of.Flags & OFN_READONLY, NULL, NULL);
	}
	else
	{	/* open multiple files */
		gchar file_name[MAX_PATH];
		gchar dir_name[MAX_PATH];

		WideCharToMultiByte(CP_UTF8, 0, fname, of.nFileOffset,
			dir_name, sizeof(dir_name), NULL, NULL);
		for (; ;)
		{
			if (! fname[x])
			{
				if (! fname[x + 1])
					break;

				WideCharToMultiByte(CP_UTF8, 0, fname + x + 1, -1,
					tmp, sizeof(tmp), NULL, NULL);
				g_snprintf(file_name, 511, "%s\\%s", dir_name, tmp);

				/* convert the resulting filename into UTF-8 */
				document_open_file(file_name, of.Flags & OFN_READONLY, NULL, NULL);
			}
			x++;
		}
	}
	return (retval != 0);
}


gchar *win32_show_document_save_as_dialog(GtkWindow *parent, const gchar *title,
										  GeanyDocument *doc)
{
	OPENFILENAMEW of;
	gint retval;
	gchar tmp[MAX_PATH];
	wchar_t w_file[MAX_PATH];
	wchar_t w_title[512];
	int n;

	w_file[0] = '\0';

	/* Convert the name of the file for of.lpstrFile */
	n = MultiByteToWideChar(CP_UTF8, 0, DOC_FILENAME(doc), -1, w_file, G_N_ELEMENTS(w_file));

	/* If creating a new file name, convert and append the extension if any */
	if (! doc->file_name && doc->file_type && doc->file_type->extension &&
		n + 1 < (int)G_N_ELEMENTS(w_file))
	{
		w_file[n - 1] = L'.';
		MultiByteToWideChar(CP_UTF8, 0, doc->file_type->extension, -1, &w_file[n],
				G_N_ELEMENTS(w_file) - n - 1);
	}

	MultiByteToWideChar(CP_UTF8, 0, title, -1, w_title, G_N_ELEMENTS(w_title));

	/* initialise file dialog info struct */
	memset(&of, 0, sizeof of);
#ifdef OPENFILENAME_SIZE_VERSION_400
	of.lStructSize = OPENFILENAME_SIZE_VERSION_400;
#else
	of.lStructSize = sizeof of;
#endif
	of.hwndOwner = GDK_WINDOW_HWND(gtk_widget_get_window(GTK_WIDGET(parent)));

	of.lpstrFilter = get_file_filter_all_files();
	of.lpstrCustomFilter = NULL;
	of.nFilterIndex = 0;

	of.lpstrFile = w_file;
	of.nMaxFile = 2048;
	of.lpstrFileTitle = NULL;
	of.lpstrTitle = w_title;
	of.lpstrDefExt = L"";
	of.Flags = OFN_OVERWRITEPROMPT | OFN_EXPLORER | OFN_ENABLEHOOK;
	of.lpfnHook = win32_dialog_explorer_hook_proc;
	retval = GetSaveFileNameW(&of);

	if (! retval)
	{
		if (CommDlgExtendedError())
		{
			gchar *error = g_strdup_printf(
				"File dialog box error (%x)", (gint) CommDlgExtendedError());
			win32_message_dialog(NULL, GTK_MESSAGE_ERROR, error);
			g_free(error);
		}
		return NULL;
	}

	WideCharToMultiByte(CP_UTF8, 0, w_file, -1, tmp, sizeof(tmp), NULL, NULL);

	return g_strdup(tmp);
}


/* initial_dir can be NULL to use the current working directory.
 * Returns: the selected filename */
gchar *win32_show_file_dialog(GtkWindow *parent, const gchar *title, const gchar *initial_file)
{
	OPENFILENAMEW of;
	gint retval;
	gchar tmp[MAX_PATH];
	wchar_t w_file[MAX_PATH];
	wchar_t w_title[512];

	w_file[0] = '\0';

	if (initial_file != NULL)
		MultiByteToWideChar(CP_UTF8, 0, initial_file, -1, w_file, G_N_ELEMENTS(w_file));

	MultiByteToWideChar(CP_UTF8, 0, title, -1, w_title, G_N_ELEMENTS(w_title));

	/* initialise file dialog info struct */
	memset(&of, 0, sizeof of);
#ifdef OPENFILENAME_SIZE_VERSION_400
	of.lStructSize = OPENFILENAME_SIZE_VERSION_400;
#else
	of.lStructSize = sizeof of;
#endif
	of.hwndOwner = GDK_WINDOW_HWND(gtk_widget_get_window(GTK_WIDGET(parent)));

	of.lpstrFile = w_file;
	of.nMaxFile = 2048;
	of.lpstrFileTitle = NULL;
	of.lpstrTitle = w_title;
	of.lpstrDefExt = L"";
	of.Flags = OFN_FILEMUSTEXIST | OFN_EXPLORER | OFN_ENABLEHOOK;
	of.lpfnHook = win32_dialog_explorer_hook_proc;
	retval = GetOpenFileNameW(&of);

	if (! retval)
	{
		if (CommDlgExtendedError())
		{
			gchar *error = g_strdup_printf(
				"File dialog box error (%x)", (gint) CommDlgExtendedError());
			win32_message_dialog(NULL, GTK_MESSAGE_ERROR, error);
			g_free(error);
		}
		return NULL;
	}

	WideCharToMultiByte(CP_UTF8, 0, w_file, -1, tmp, sizeof(tmp), NULL, NULL);

	return g_strdup(tmp);
}


void win32_show_font_dialog(void)
{
	gint retval;
	CHOOSEFONT cf;
	LOGFONT lf;        /* logical font structure */

	memset(&lf, 0, sizeof lf);
	/* TODO: init lf members */

	memset(&cf, 0, sizeof cf);
	cf.lStructSize = sizeof cf;
	cf.hwndOwner = GDK_WINDOW_HWND(gtk_widget_get_window(main_widgets.window));
	cf.lpLogFont = &lf;
	/* support CF_APPLY? */
	cf.Flags = CF_NOSCRIPTSEL | CF_FORCEFONTEXIST | CF_INITTOLOGFONTSTRUCT | CF_SCREENFONTS | CF_ENABLEHOOK;
	cf.lpfnHook = win32_dialog_hook_proc;

	retval = ChooseFont(&cf);

	if (retval)
	{
		gchar *editorfont = g_strdup_printf("%s %d", lf.lfFaceName, (cf.iPointSize / 10));
		ui_set_editor_font(editorfont);
		g_free(editorfont);
	}
}


void win32_show_color_dialog(const gchar *colour)
{
	CHOOSECOLOR cc;
	static COLORREF acr_cust_clr[16];
	static DWORD rgb_current;
	gchar *hex = g_malloc0(12);
	GeanyDocument *doc = document_get_current();

	/* Initialize CHOOSECOLOR */
	memset(&cc, 0, sizeof cc);
	cc.lStructSize = sizeof(cc);
	cc.hwndOwner = GDK_WINDOW_HWND(gtk_widget_get_window(main_widgets.window));
	cc.lpCustColors = (LPDWORD) acr_cust_clr;
	cc.rgbResult = (colour != NULL) ? utils_parse_color_to_bgr(colour) : 0;
	cc.Flags = CC_FULLOPEN | CC_RGBINIT | CC_ENABLEHOOK;
	cc.lpfnHook = win32_dialog_hook_proc;

	if (ChooseColor(&cc))
	{
		rgb_current = cc.rgbResult;
		g_snprintf(hex, 11, "#%02X%02X%02X",
	      (guint) (utils_scale_round(GetRValue(rgb_current), 255)),
	      (guint) (utils_scale_round(GetGValue(rgb_current), 255)),
	      (guint) (utils_scale_round(GetBValue(rgb_current), 255)));

		editor_insert_color(doc->editor, hex);
	}
	g_free(hex);
}


void win32_show_pref_file_dialog(GtkEntry *item)
{
	OPENFILENAMEW of;
	gint retval, len;
	wchar_t fname[MAX_PATH];
	gchar tmp[MAX_PATH];
	gchar **field, *filename;

	fname[0] = '\0';

	/* cut the options from the command line */
	field = g_strsplit(gtk_entry_get_text(GTK_ENTRY(item)), " ", 2);
	if (field[0])
	{
		filename = g_find_program_in_path(field[0]);
		if (filename != NULL && g_file_test(filename, G_FILE_TEST_EXISTS))
		{
			MultiByteToWideChar(CP_UTF8, 0, filename, -1, fname, G_N_ELEMENTS(fname));
			g_free(filename);
		}
	}

	/* initialize file dialog info struct */
	memset(&of, 0, sizeof of);
#ifdef OPENFILENAME_SIZE_VERSION_400
	of.lStructSize = OPENFILENAME_SIZE_VERSION_400;
#else
	of.lStructSize = sizeof of;
#endif
	of.hwndOwner = GDK_WINDOW_HWND(gtk_widget_get_window(ui_widgets.prefs_dialog));

	of.lpstrFilter = get_filters(FALSE);
	of.lpstrCustomFilter = NULL;
	of.nFilterIndex = 1;

	of.lpstrFile = fname;
	of.nMaxFile = 2048;
	of.lpstrFileTitle = NULL;
	/*of.lpstrInitialDir = g_get_home_dir();*/
	of.lpstrInitialDir = NULL;
	of.lpstrTitle = NULL;
	of.lpstrDefExt = L"exe";
	of.Flags = OFN_HIDEREADONLY | OFN_FILEMUSTEXIST | OFN_EXPLORER | OFN_ENABLEHOOK;
	of.lpfnHook = win32_dialog_explorer_hook_proc;
	retval = GetOpenFileNameW(&of);

	if (!retval)
	{
		if (CommDlgExtendedError())
		{
			gchar error[100];
			g_snprintf(error, sizeof error, "File dialog box error (%x)", (int)CommDlgExtendedError());
			win32_message_dialog(NULL, GTK_MESSAGE_ERROR, error);
		}
		g_strfreev(field);
		return;
	}

	len = WideCharToMultiByte(CP_UTF8, 0, fname, -1, tmp, sizeof(tmp), NULL, NULL);
	if ((of.nFileOffset - 1) != len)
	{
		if (g_strv_length(field) > 1)
			/* add the command line args of the old command */
			/** TODO this fails badly when the old command contained spaces, we need quoting here */
			filename = g_strconcat(tmp, " ", field[1], NULL);
		else
		{
			filename = g_strdup(tmp);
		}
		gtk_entry_set_text(GTK_ENTRY(item), filename);
		g_free(filename);
	}
	g_strfreev(field);
}


/* Creates a native Windows message box of the given type and returns always TRUE
 * or FALSE representing th pressed Yes or No button.
 * If type is not GTK_MESSAGE_QUESTION, it returns always TRUE. */
gboolean win32_message_dialog(GtkWidget *parent, GtkMessageType type, const gchar *msg)
{
	gboolean ret = TRUE;
	gint rc;
	guint t;
	const gchar *title;
	HWND parent_hwnd = NULL;
	static wchar_t w_msg[512];
	static wchar_t w_title[512];

	switch (type)
	{
		case GTK_MESSAGE_ERROR:
		{
			t = MB_OK | MB_ICONERROR;
			title = _("Error");
			break;
		}
		case GTK_MESSAGE_QUESTION:
		{
			t = MB_YESNO | MB_ICONQUESTION;
			title = _("Question");
			break;
		}
		case GTK_MESSAGE_WARNING:
		{
			t = MB_OK | MB_ICONWARNING;
			title = _("Warning");
			break;
		}
		default:
		{
			t = MB_OK | MB_ICONINFORMATION;
			title = _("Information");
			break;
		}
	}

	/* convert the Unicode chars to wide chars */
	/** TODO test if LANG == C then possibly skip conversion => g_win32_getlocale() */
	MultiByteToWideChar(CP_UTF8, 0, msg, -1, w_msg, G_N_ELEMENTS(w_msg));
	MultiByteToWideChar(CP_UTF8, 0, title, -1, w_title, G_N_ELEMENTS(w_title));

	if (parent != NULL)
		parent_hwnd = GDK_WINDOW_HWND(gtk_widget_get_window(parent));
	else if (main_widgets.window != NULL)
		parent_hwnd = GDK_WINDOW_HWND(gtk_widget_get_window(main_widgets.window));

	/* display the message box */
	rc = MessageBoxW(parent_hwnd, w_msg, w_title, t);

	if (type == GTK_MESSAGE_QUESTION && rc != IDYES)
		ret = FALSE;

	return ret;
}


/* Little wrapper for _waccess(), returns errno or 0 if there was no error */
gint win32_check_write_permission(const gchar *dir)
{
	static wchar_t w_dir[MAX_PATH];
	MultiByteToWideChar(CP_UTF8, 0, dir, -1, w_dir, G_N_ELEMENTS(w_dir));
	if (_waccess(w_dir, R_OK | W_OK) != 0)
		return errno;
	else
		return 0;
}


/* Just a simple wrapper function to open a browser window */
void win32_open_browser(const gchar *uri)
{
	if (strncmp(uri, "file://", 7) == 0)
	{
		uri += 7;
		if (strchr(uri, ':') != NULL)
		{
			while (*uri == '/')
				uri++;
		}
	}
	ShellExecute(NULL, "open", uri, NULL, NULL, SW_SHOWNORMAL);
}


/* Returns TRUE if the command, which child_pid refers to, returned with a successful exit code,
 * otherwise FALSE. */
gboolean win32_get_exit_status(GPid child_pid)
{
	DWORD exit_code;
	GetExitCodeProcess(child_pid, &exit_code);

	return (exit_code == 0);
}


static FILE *open_std_handle(DWORD handle, const char *mode)
{
	HANDLE lStdHandle;
	int hConHandle;
	FILE *fp;

	lStdHandle = GetStdHandle(handle);
	if (lStdHandle == INVALID_HANDLE_VALUE)
	{
		gchar *err = g_win32_error_message(GetLastError());
		g_warning("GetStdHandle(%ld) failed: %s", (long)handle, err);
		g_free(err);
		return NULL;
	}
	hConHandle = _open_osfhandle((long)lStdHandle, _O_TEXT);
	if (hConHandle == -1)
	{
		gchar *err = g_win32_error_message(GetLastError());
		g_warning("_open_osfhandle(%ld, _O_TEXT) failed: %s", (long)lStdHandle, err);
		g_free(err);
		return NULL;
	}
	fp = _fdopen(hConHandle, mode);
	if (! fp)
	{
		gchar *err = g_win32_error_message(GetLastError());
		g_warning("_fdopen(%d, \"%s\") failed: %s", hConHandle, mode, err);
		g_free(err);
		return NULL;
	}
	if (setvbuf(fp, NULL, _IONBF, 0) != 0)
	{
		gchar *err = g_win32_error_message(GetLastError());
		g_warning("setvbuf(%p, NULL, _IONBF, 0) failed: %s", fp, err);
		g_free(err);
		fclose(fp);
		return NULL;
	}

	return fp;
}


static void debug_setup_console(void)
{
	static const WORD MAX_CONSOLE_LINES = 500;
	CONSOLE_SCREEN_BUFFER_INFO coninfo;
	FILE	*fp;

	/* allocate a console for this app */
	AllocConsole();

	/* set the screen buffer to be big enough to let us scroll text */
	GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &coninfo);
	coninfo.dwSize.Y = MAX_CONSOLE_LINES;
	SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE), coninfo.dwSize);

	/* redirect unbuffered STDOUT to the console */
	fp = open_std_handle(STD_OUTPUT_HANDLE, "w");
	if (fp)
		*stdout = *fp;

	/* redirect unbuffered STDERR to the console */
	fp = open_std_handle(STD_ERROR_HANDLE, "w");
	if (fp)
		*stderr = *fp;

	/* redirect unbuffered STDIN to the console */
	fp = open_std_handle(STD_INPUT_HANDLE, "r");
	if (fp)
		*stdin = *fp;
}


void win32_init_debug_code(void)
{
	if (app->debug_mode)
	{
		/* create a console window to get log messages on Windows,
		 * especially useful when generating tags files */
		debug_setup_console();
		/* Enable GLib process spawn debug mode when Geany was started with the debug flag */
		g_setenv("G_SPAWN_WIN32_DEBUG", "1", FALSE);
	}
}


static gchar *create_temp_file(void)
{
	gchar *name;
	gint fd;

	fd = g_file_open_tmp("tmp_XXXXXX", &name, NULL);
	if (fd == -1)
		name = NULL;
	else
		close(fd);

	return name;
}


/* Sometimes this blocks for 30s before aborting when there are several
 * pages of (error) output and sometimes hangs - see the FIXME.
 * Also gw_spawn.dwExitCode seems to be not set properly. */
/* Process spawning implementation for Windows, by Pierre Joye.
 * Don't call this function directly, use utils_spawn_[a]sync() instead. */
static
gboolean _broken_win32_spawn(const gchar *dir, gchar **argv, gchar **env, GSpawnFlags flags,
					 gchar **std_out, gchar **std_err, gint *exit_status, GError **error)
{
	TCHAR  buffer[CMDSIZE]=TEXT("");
	TCHAR  cmdline[CMDSIZE] = TEXT("");
	TCHAR* lpPart[CMDSIZE]={NULL};
	DWORD  retval = 0;
	gint argc = 0, i;
	gint cmdpos = 0;

	SECURITY_ATTRIBUTES saAttr;
	BOOL fSuccess;
	geany_win32_spawn gw_spawn;

	/* Temp file */
	HANDLE hStdoutTempFile = NULL;
	HANDLE hStderrTempFile = NULL;

	gchar *stdout_content = NULL;
	gchar *stderr_content = NULL;

	while (argv[argc])
	{
		++argc;
	}
	g_return_val_if_fail (std_out == NULL ||
						!(flags & G_SPAWN_STDOUT_TO_DEV_NULL), FALSE);
	g_return_val_if_fail (std_err == NULL ||
						!(flags & G_SPAWN_STDERR_TO_DEV_NULL), FALSE);

	if (flags & G_SPAWN_SEARCH_PATH)
	{
		retval = SearchPath(NULL, argv[0], ".exe", sizeof(buffer), buffer, lpPart);
		if (retval > 0)
			g_snprintf(cmdline, sizeof(cmdline), "\"%s\"", buffer);
		else
			g_strlcpy(cmdline, argv[0], sizeof(cmdline));
		cmdpos = 1;
	}

	for (i = cmdpos; i < argc; i++)
	{
		g_snprintf(cmdline, sizeof(cmdline), "%s %s", cmdline, argv[i]);
		/*MessageBox(NULL, cmdline, cmdline, MB_OK);*/
	}

	if (std_err != NULL)
	{
		hStderrTempFile = GetTempFileHandle(error);
		if (hStderrTempFile == INVALID_HANDLE_VALUE)
		{
			gchar *msg = g_win32_error_message(GetLastError());
			geany_debug("win32_spawn: Second CreateFile failed (%d)", (gint) GetLastError());
			g_set_error(error, G_SPAWN_ERROR, G_FILE_ERROR, "%s", msg);
			g_free(msg);
			return FALSE;
		}
	}

	if (std_out != NULL)
	{
		hStdoutTempFile = GetTempFileHandle(error);
		if (hStdoutTempFile == INVALID_HANDLE_VALUE)
		{
			gchar *msg = g_win32_error_message(GetLastError());
			geany_debug("win32_spawn: Second CreateFile failed (%d)", (gint) GetLastError());
			g_set_error(error, G_SPAWN_ERROR, G_FILE_ERROR, "%s", msg);
			g_free(msg);
			return FALSE;
		}
	}

	/* Set the bInheritHandle flag so pipe handles are inherited. */
	saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
	saAttr.bInheritHandle = TRUE;
	saAttr.lpSecurityDescriptor = NULL;

	/* Get the handle to the current STDOUT and STDERR. */
	gw_spawn.hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
	gw_spawn.hStderr = GetStdHandle(STD_ERROR_HANDLE);
	gw_spawn.dwExitCode = 0;

	/* Create a pipe for the child process's STDOUT. */
	if (! CreatePipe(&(gw_spawn.hChildStdoutRd), &(gw_spawn.hChildStdoutWr), &saAttr, 0))
	{
		gchar *msg = g_win32_error_message(GetLastError());
		geany_debug("win32_spawn: Stdout pipe creation failed (%d)", (gint) GetLastError());
		g_set_error(error, G_SPAWN_ERROR, G_FILE_ERROR_PIPE, "%s", msg);
		g_free(msg);
		return FALSE;
	}

	/* Ensure that the read handle to the child process's pipe for STDOUT is not inherited.*/
	SetHandleInformation(gw_spawn.hChildStdoutRd, HANDLE_FLAG_INHERIT, 0);

	/* Create a pipe for the child process's STDERR. */
	if (! CreatePipe(&(gw_spawn.hChildStderrRd), &(gw_spawn.hChildStderrWr), &saAttr, 0))
	{
		gchar *msg = g_win32_error_message(GetLastError());
		geany_debug("win32_spawn: Stderr pipe creation failed");
		g_set_error(error, G_SPAWN_ERROR, G_FILE_ERROR_PIPE, "%s", msg);
		g_free(msg);
		return FALSE;
	}

	/* Ensure that the read handle to the child process's pipe for STDOUT is not inherited.*/
	SetHandleInformation(gw_spawn.hChildStderrRd, HANDLE_FLAG_INHERIT, 0);

	/* Create a pipe for the child process's STDIN.  */
	if (! CreatePipe(&(gw_spawn.hChildStdinRd), &(gw_spawn.hChildStdinWr), &saAttr, 0))
	{
		gchar *msg = g_win32_error_message(GetLastError());
		geany_debug("win32_spawn: Stdin pipe creation failed");
		g_set_error(error, G_SPAWN_ERROR, G_FILE_ERROR_PIPE, "%s", msg);
		g_free(msg);
		return FALSE;
	}

	/* Ensure that the write handle to the child process's pipe for STDIN is not inherited. */
	SetHandleInformation(gw_spawn.hChildStdinWr, HANDLE_FLAG_INHERIT, 0);

	/* Now create the child process. */
	fSuccess = CreateChildProcess(&gw_spawn, cmdline, dir, error);
	if (exit_status)
	{
		*exit_status = gw_spawn.dwExitCode;
	}

	if (! fSuccess)
	{
		geany_debug("win32_spawn: Create process failed");
		return FALSE;
	}

	/* Read from pipe that is the standard output for child process. */
	if (std_out != NULL)
	{
		ReadFromPipe(gw_spawn.hChildStdoutRd, gw_spawn.hChildStdoutWr, hStdoutTempFile, error);
		if (! GetContentFromHandle(hStdoutTempFile, &stdout_content, error))
		{
			return FALSE;
		}
		*std_out = stdout_content;
	}

	if (std_err != NULL)
	{
		ReadFromPipe(gw_spawn.hChildStderrRd, gw_spawn.hChildStderrWr, hStderrTempFile, error);
		if (! GetContentFromHandle(hStderrTempFile, &stderr_content, error))
		{
			return FALSE;
		}
		*std_err = stderr_content;
	}
	return TRUE;
}


/* Note: g_spawn is broken for receiving both stdio and stderr e.g. when
 * running make and there are compile errors. See glib/giowin32.c header
 * comment about Windows bugs, e.g. #338943 */
/* Simple replacement for _broken_win32_spawn().
 * flags is ignored, G_SPAWN_SEARCH_PATH is implied.
 * Don't call this function directly, use utils_spawn_[a]sync() instead.
 * Adapted from tm_workspace_create_global_tags(). */
gboolean win32_spawn(const gchar *dir, gchar **argv, gchar **env, GSpawnFlags flags,
					 gchar **std_out, gchar **std_err, gint *exit_status, GError **error)
{
	gint ret;
	gboolean fail;
	gchar *tmp_file = create_temp_file();
	gchar *tmp_errfile = create_temp_file();
	gchar *command;
	gchar *locale_command;

	if (env != NULL)
	{
		return _broken_win32_spawn(dir, argv, env, flags, std_out, std_err,
			exit_status, error);
	}
	if (!tmp_file || !tmp_errfile)
	{
		g_warning("%s: Could not create temporary files!", G_STRFUNC);
		return FALSE;
	}
	command = g_strjoinv(" ", argv);
	SETPTR(command, g_strdup_printf("cmd.exe /S /C \"%s >%s 2>%s\"",
		command, tmp_file, tmp_errfile));
	locale_command = g_locale_from_utf8(command, -1, NULL, NULL, NULL);
	if (! locale_command)
		locale_command = g_strdup(command);
	geany_debug("WIN32: actually running command:\n%s", command);
	g_chdir(dir);
	errno = 0;
	ret = system(locale_command);
	/* the command can return -1 as an exit code, so check errno also */
	fail = ret == -1 && errno;
	if (!fail)
	{
		if (std_out != NULL)
			g_file_get_contents(tmp_file, std_out, NULL, NULL);
		if (std_err != NULL)
			g_file_get_contents(tmp_errfile, std_err, NULL, NULL);
	}
	else if (error)
		g_set_error_literal(error, G_SPAWN_ERROR, errno, g_strerror(errno));

	g_free(command);
	g_free(locale_command);
	g_unlink(tmp_file);
	g_free(tmp_file);
	g_unlink(tmp_errfile);
	g_free(tmp_errfile);
	if (exit_status)
		*exit_status = ret;

	return !fail;
}


static gboolean GetContentFromHandle(HANDLE hFile, gchar **content, GError **error)
{
	DWORD filesize;
	gchar * buffer;
	DWORD dwRead;

	filesize = GetFileSize(hFile, NULL);
	if (filesize < 1)
	{
		*content = NULL;
		return TRUE;
	}

	buffer = g_malloc(filesize + 1);
	if (! buffer)
	{
		gchar *msg = g_win32_error_message(GetLastError());
		geany_debug("GetContentFromHandle: Alloc failed");
		g_set_error(error, G_SPAWN_ERROR, G_SPAWN_ERROR, "%s", msg);
		g_free(msg);
		return FALSE;
	}

	SetFilePointer(hFile, 0, NULL, FILE_BEGIN);
	if (! ReadFile(hFile, buffer, filesize, &dwRead, NULL) || dwRead == 0)
	{
		gchar *msg = g_win32_error_message(GetLastError());
		geany_debug("GetContentFromHandle: Cannot read tempfile");
		g_set_error(error, G_SPAWN_ERROR, G_FILE_ERROR_FAILED, "%s", msg);
		g_free(msg);
		return FALSE;
	}

	if (! CloseHandle(hFile))
	{
		gchar *msg = g_win32_error_message(GetLastError());
		geany_debug("GetContentFromHandle: CloseHandle failed (%d)", (gint) GetLastError());
		g_set_error(error, G_SPAWN_ERROR, G_FILE_ERROR_FAILED, "%s", msg);
		g_free(msg);
		g_free(buffer);
		*content = NULL;
		return FALSE;
	}
	buffer[filesize] = '\0';
	*content = buffer;
	return TRUE;
}


gchar *win32_expand_environment_variables(const gchar *str)
{
	gchar expCmdline[32768]; /* 32768 is the limit for ExpandEnvironmentStrings() */

	if (ExpandEnvironmentStrings((LPCTSTR) str, (LPTSTR) expCmdline, sizeof(expCmdline)) != 0)
		return g_strdup(expCmdline);
	else
		return g_strdup(str);
}


static gboolean CreateChildProcess(geany_win32_spawn *gw_spawn, TCHAR *szCmdline,
		const TCHAR *dir, GError **error)
{
	PROCESS_INFORMATION piProcInfo;
	STARTUPINFOW siStartInfo;
	BOOL bFuncRetn = FALSE;
	gchar *expandedCmdline;
	wchar_t w_commandline[CMDSIZE];
	wchar_t w_dir[MAX_PATH];

	/* Set up members of the PROCESS_INFORMATION structure. */
	ZeroMemory(&piProcInfo, sizeof(PROCESS_INFORMATION));

	/* Set up members of the STARTUPINFO structure.*/
	ZeroMemory(&siStartInfo, sizeof(STARTUPINFO));

	siStartInfo.cb         = sizeof(STARTUPINFO);
	siStartInfo.hStdError  = gw_spawn->hChildStderrWr;
	siStartInfo.hStdOutput = gw_spawn->hChildStdoutWr;
	siStartInfo.hStdInput  = gw_spawn->hChildStdinRd;
	siStartInfo.dwFlags   |= STARTF_USESTDHANDLES;

	/* Expand environment variables like %blah%. */
	expandedCmdline = win32_expand_environment_variables(szCmdline);

	MultiByteToWideChar(CP_UTF8, 0, expandedCmdline, -1, w_commandline, G_N_ELEMENTS(w_commandline));
	MultiByteToWideChar(CP_UTF8, 0, dir, -1, w_dir, G_N_ELEMENTS(w_dir));

	/* Create the child process. */
	bFuncRetn = CreateProcessW(NULL,
		w_commandline,             /* command line */
		NULL,          /* process security attributes */
		NULL,          /* primary thread security attributes */
		TRUE,          /* handles are inherited */
		CREATE_NO_WINDOW,             /* creation flags */
		NULL,          /* use parent's environment */
		w_dir,           /* use parent's current directory */
		&siStartInfo,  /* STARTUPINFO pointer */
		&piProcInfo);  /* receives PROCESS_INFORMATION */

	g_free(expandedCmdline);

	if (bFuncRetn == 0)
	{
		gchar *msg = g_win32_error_message(GetLastError());
		geany_debug("CreateChildProcess: CreateProcess failed (%s)", msg);
		g_set_error(error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED, "%s", msg);
		g_free(msg);
		return FALSE;
	}
	else
	{
		gint i;
		gsize ms = 30*1000;

		/* FIXME: this seems to timeout when there are many lines
		 * to read - maybe because the child's pipe is full */
		for (i = 0; i < 2 &&
			WaitForSingleObject(piProcInfo.hProcess, ms) == WAIT_TIMEOUT; i++)
		{
			ui_set_statusbar(FALSE, _("Process timed out after %.02f s!"), ms / 1000.0F);
			geany_debug("CreateChildProcess: timed out");
			TerminateProcess(piProcInfo.hProcess, WAIT_TIMEOUT); /* NOTE: This will not kill grandkids. */
		}

		if (!GetExitCodeProcess(piProcInfo.hProcess, &gw_spawn->dwExitCode))
		{
			gchar *msg = g_win32_error_message(GetLastError());
			geany_debug("GetExitCodeProcess failed: %s", msg);
			g_set_error(error, G_SPAWN_ERROR, G_FILE_ERROR_FAILED, "%s", msg);
			g_free(msg);
		}
		CloseHandle(piProcInfo.hProcess);
		CloseHandle(piProcInfo.hThread);
		return bFuncRetn;
	}
	return FALSE;
}


static VOID ReadFromPipe(HANDLE hRead, HANDLE hWrite, HANDLE hFile, GError **error)
{
	DWORD dwRead, dwWritten;
	CHAR chBuf[BUFSIZE];

	/* Close the write end of the pipe before reading from the
	   read end of the pipe. */
	if (! CloseHandle(hWrite))
	{
		gchar *msg = g_win32_error_message(GetLastError());
		geany_debug("ReadFromPipe: Closing handle failed");
		g_set_error(error, G_SPAWN_ERROR, G_FILE_ERROR_PIPE, "%s", msg);
		g_free(msg);
		return;
	}

	/* Read output from the child process, and write to parent's STDOUT. */
	for (;;)
	{
		if (! ReadFile(hRead, chBuf, BUFSIZE, &dwRead, NULL) || dwRead == 0)
			break;

		if (! WriteFile(hFile, chBuf, dwRead, &dwWritten, NULL))
			break;
	}
}


static HANDLE GetTempFileHandle(GError **error)
{
	/* Temp file */
	DWORD dwBufSize = BUFSIZE;
	UINT uRetVal;
	TCHAR szTempName[BUFSIZE];
	TCHAR lpPathBuffer[BUFSIZE];
	DWORD dwRetVal;
	HANDLE hTempFile;

	/* Get the temp path. */
	dwRetVal = GetTempPath(dwBufSize,     /* length of the buffer*/
						   lpPathBuffer); /* buffer for path */

	if (dwRetVal > dwBufSize || (dwRetVal == 0))
	{
		gchar *msg = g_win32_error_message(GetLastError());
		geany_debug("GetTempFileHandle: GetTempPath failed (%d)", (gint) GetLastError());
		g_set_error(error, G_SPAWN_ERROR, G_FILE_ERROR, "%s", msg);
		g_free(msg);
		return NULL;
	}

	/* Create a temporary file for STDOUT. */
	uRetVal = GetTempFileName(lpPathBuffer, /* directory for tmp files */
							  TEXT("GEANY_VCDIFF_"),  /* temp file name prefix */
							  0,            /* create unique name */
							  szTempName);  /* buffer for name */
	if (uRetVal == 0)
	{
		gchar *msg = g_win32_error_message(GetLastError());
		geany_debug("GetTempFileName failed (%d)", (gint) GetLastError());
		g_set_error(error, G_SPAWN_ERROR, G_FILE_ERROR, "%s", msg);
		g_free(msg);
		return NULL;
	}

	hTempFile = CreateFile((LPTSTR) szTempName, /* file name */
						   GENERIC_READ | GENERIC_WRITE, /* open r-w */
						   0,                    /* do not share */
						   NULL,                 /* default security */
						   CREATE_ALWAYS,        /* overwrite existing */
						   FILE_ATTRIBUTE_NORMAL,/* normal file */
						   NULL);                /* no template */

	if (hTempFile == INVALID_HANDLE_VALUE)
	{
		gchar *msg = g_win32_error_message(GetLastError());
		geany_debug("GetTempFileHandle: Second CreateFile failed (%d)", (gint) GetLastError());
		g_set_error(error, G_SPAWN_ERROR, G_FILE_ERROR, "%s", msg);
		g_free(msg);
		return NULL;
	}
	return hTempFile;
}


/* From GDK (they got it from MS Knowledge Base article Q130698) */
static gboolean resolve_link(HWND hWnd, wchar_t *link, gchar **lpszPath)
{
	WIN32_FILE_ATTRIBUTE_DATA wfad;
	HRESULT hres;
	IShellLinkW *pslW = NULL;
	IPersistFile *ppf = NULL;
	LPVOID pslWV = NULL;
	LPVOID ppfV = NULL;

	/* Check if the file is empty first because IShellLink::Resolve for some reason succeeds
	 * with an empty file and returns an empty "link target". (#524151) */
	if (!GetFileAttributesExW(link, GetFileExInfoStandard, &wfad) ||
		(wfad.nFileSizeHigh == 0 && wfad.nFileSizeLow == 0))
	{
	  return FALSE;
	}

	/* Assume failure to start with: */
	*lpszPath = 0;

	CoInitialize(NULL);

	hres = CoCreateInstance(
		&CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, &IID_IShellLinkW, &pslWV);

	if (SUCCEEDED(hres))
	{
		/* The IShellLink interface supports the IPersistFile interface.
		 * Get an interface pointer to it. */
		pslW = (IShellLinkW*) pslWV;
		hres = pslW->lpVtbl->QueryInterface(pslW, &IID_IPersistFile, &ppfV);
	}

	if (SUCCEEDED(hres))
	{
		/* Load the file. */
		ppf = (IPersistFile*) ppfV;
		hres = ppf->lpVtbl->Load(ppf, link, STGM_READ);
	}

	if (SUCCEEDED(hres))
	{
		/* Resolve the link by calling the Resolve() interface function. */
		hres = pslW->lpVtbl->Resolve(pslW, hWnd, SLR_ANY_MATCH | SLR_NO_UI);
	}

	if (SUCCEEDED(hres))
	{
		wchar_t wtarget[MAX_PATH];

		hres = pslW->lpVtbl->GetPath(pslW, wtarget, MAX_PATH, NULL, 0);
		if (SUCCEEDED(hres))
			*lpszPath = g_utf16_to_utf8(wtarget, -1, NULL, NULL, NULL);
	}

	if (ppf)
		ppf->lpVtbl->Release(ppf);

	if (pslW)
		pslW->lpVtbl->Release(pslW);

	return SUCCEEDED(hres);
}


/* Checks whether file_name is a Windows shortcut. file_name is expected in UTF-8 encoding.
 * If file_name is a Windows shortcut, it returns the target in UTF-8 encoding.
 * If it is not a shortcut, it returns a newly allocated copy of file_name. */
gchar *win32_get_shortcut_target(const gchar *file_name)
{
	gchar *path = NULL;
	wchar_t *wfilename = g_utf8_to_utf16(file_name, -1, NULL, NULL, NULL);
	HWND hWnd = NULL;
	
	if (main_widgets.window != NULL)
	{
		GdkWindow *window = gtk_widget_get_window(main_widgets.window);
		if (window != NULL)
			hWnd = GDK_WINDOW_HWND(window);
	}
	
	resolve_link(hWnd, wfilename, &path);
	g_free(wfilename);

	if (path == NULL)
		return g_strdup(file_name);
	else
		return path;
}


void win32_set_working_directory(const gchar *dir)
{
	SetCurrentDirectory(dir);
}


gchar *win32_get_installation_dir(void)
{
	return g_win32_get_package_installation_directory_of_module(NULL);
}


gchar *win32_get_user_config_dir(void)
{
	HRESULT hr;
	wchar_t path[MAX_PATH];

	hr = SHGetFolderPathAndSubDirW(NULL, CSIDL_APPDATA | CSIDL_FLAG_CREATE, NULL, SHGFP_TYPE_CURRENT, L"geany", path);
	if (SUCCEEDED(hr))
	{
		// GLib always uses UTF-8 for filename encoding on Windows
		int u8_size = WideCharToMultiByte(CP_UTF8, 0, path, -1, NULL, 0, NULL, NULL);
		if (u8_size > 0)
		{
			gchar *u8_path = g_malloc0(u8_size + 1);
			if (u8_path != NULL &&
				WideCharToMultiByte(CP_UTF8, 0, path, -1, u8_path, u8_size, NULL, NULL))
			{
				return u8_path;
			}
		}
	}

	// glib fallback
	g_warning("Failed to retrieve Windows config dir, falling back to default");
	return g_build_filename(g_get_user_config_dir(), "geany", NULL);
}

#endif
