Initial community commit

1 files changed, 653 insertions, 0 deletions

diff --git a/Src/Plugins/DSP/dsp_sc/utils.cpp b/Src/Plugins/DSP/dsp_sc/utils.cpp
new file mode 100644
index 00000000..809234df
--- /dev/null
+++ b/Src/Plugins/DSP/dsp_sc/utils.cpp
@@ -0,0 +1,653 @@
+#include <windows.h>
+#include <uxtheme.h>
+#include "utils.h"
+#include "api.h"
+
+#include <time.h>
+#include <string>
+#include <functional>
+#include <stdio.h>
+#include <stdlib.h>
+#include <list>
+#include <fstream>
+#include <sstream>
+#include <shlwapi.h>
+
+#include <winamp/wa_ipc.h>
+#include <winamp/dsp.h>
+#include "resource/resource.h"
+
+extern winampDSPModule module;
+
+// Config file
+char IniName[MAX_PATH] = {0},
+	 IniEncName[MAX_PATH] = {0},
+	 IniDir[MAX_PATH] = {0},
+	 PluginDir[MAX_PATH] = {0};
+wchar_t IniDirW[MAX_PATH] = {0},
+		PluginDirW[MAX_PATH] = {0},
+		SharedDirW[MAX_PATH] = {0};
+HANDLE NextTracks[NUM_OUTPUTS] = {INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE};
+HANDLE SaveEncoded[NUM_OUTPUTS] = {INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE};
+
+static bool IsVista = false,
+			checked = false;
+
+bool IsVistaUp() {
+	if (checked == false) {
+		OSVERSIONINFO version = {0};
+		version.dwOSVersionInfoSize = sizeof(version);
+		if (!GetVersionEx(&version)) ZeroMemory(&version, sizeof(OSVERSIONINFO));
+		IsVista = (version.dwMajorVersion >= 6);
+		checked = true;
+	}
+	return IsVista;
+}
+
+UINT ver = -1;
+UINT GetWinampVersion(HWND winamp)
+{
+	if(ver == -1)
+	{
+		return (ver = SendMessage(winamp, WM_WA_IPC, 0, IPC_GETVERSION));
+	}
+	return ver;
+}
+
+char* LocalisedStringA(UINT uID, char *str, size_t maxlen) {
+	if (WASABI_API_LNG) {
+		if (!str) {
+			return WASABI_API_LNGSTRING(uID);
+		} else {
+			return WASABI_API_LNGSTRING_BUF(uID, str, maxlen);
+		}
+	} else {
+		__declspec(thread) static char *tmp;
+		char* strtmp = 0;
+		if (!str) {
+			if (!tmp) tmp = (char *)malloc(1024*sizeof(char));
+			strtmp = tmp;
+			maxlen = 1024;
+		} else {
+			strtmp = str;
+		}
+		LoadStringA(module.hDllInstance, uID, strtmp, maxlen);
+		return strtmp;
+	}
+}
+
+wchar_t* LocalisedString(UINT uID, wchar_t *str, size_t maxlen) {
+	if (WASABI_API_LNG) {
+		if (!str) {
+			return WASABI_API_LNGSTRINGW(uID);
+		} else {
+			return WASABI_API_LNGSTRINGW_BUF(uID, str, maxlen);
+		}
+	} else {
+		__declspec(thread) static wchar_t *tmp;
+		wchar_t* strtmp = 0;
+		if (!str) {
+			if (!tmp) tmp = (wchar_t *)malloc(1024*sizeof(wchar_t));
+			strtmp = tmp;
+			maxlen = 1024;
+		} else {
+			strtmp = str;
+		}
+		LoadStringW(module.hDllInstance, uID, strtmp, maxlen);
+		return strtmp;
+	}
+}
+
+HWND LocalisedCreateDialog(HINSTANCE instance, UINT dialog_id, HWND hWndParent, DLGPROC DlgProc, LPARAM user_id) {
+	if (WASABI_API_LNG) {
+		return WASABI_API_CREATEDIALOGPARAMW(dialog_id, hWndParent, DlgProc, user_id);
+	} else {
+		return CreateDialogParamW(instance, MAKEINTRESOURCEW(dialog_id), hWndParent, DlgProc, user_id);
+	}
+}
+
+INT_PTR LocalisedDialogBox(HINSTANCE hDllInstance, UINT dialog_id, HWND hWndParent, DLGPROC lpDialogFunc) {
+	if (WASABI_API_LNG) {
+		return WASABI_API_DIALOGBOXW(dialog_id, hWndParent, lpDialogFunc);
+	} else {
+		return DialogBoxW(hDllInstance, MAKEINTRESOURCEW(dialog_id), hWndParent, lpDialogFunc);
+	}
+}
+
+// about the most reliable way i can find to get the Winamp window as it could
+// have been started with the /CLASS= parameter which then means it won't be
+// 'Winamp v1.x' so instead go for a fixed child window which will always be
+// there (and deals with other apps who create a 'fake' Winamp window (like AIMP)
+// and there are two versions to cope with classic or modern skins being used.
+HWND hwndWinamp = 0;
+BOOL CALLBACK EnumWindowsProc(HWND hwnd, LPARAM lParam) {
+	char name[24];
+	GetClassName(hwnd,name,24);
+	// this check will only work for classic skins
+	if (!strnicmp(name, "Winamp PE", 24)) {
+		HWND child = GetWindow(GetWindow(hwnd, GW_CHILD), GW_CHILD);
+		GetClassName(child, name, 24);
+		// this check improves reliability of this check against players
+		// like KMPlayer which also create a fake playlist editor window
+		if (!strnicmp(name, "WinampVis", 24) || strnicmp(name, "TSkinPanel", 24)) {
+			hwndWinamp = GetWindow(hwnd, GW_OWNER);
+			return FALSE;
+		}
+	} else if (!strnicmp(name, "BaseWindow_RootWnd", 24)) {
+		// this check will only work for modern skins
+		HWND child = GetWindow(GetWindow(hwnd, GW_CHILD), GW_CHILD);
+		GetClassName(child, name, 24);
+		if (!strnicmp(name, "Winamp PE", 24)) {
+			hwndWinamp = GetWindow(hwnd, GW_OWNER);
+			return FALSE;
+		}
+	} else if (!strnicmp(name, "Winamp v1.x", 24)) {
+		// this check will fail if /CLASS= was used on Winamp
+		HWND child = GetWindow(hwnd, GW_CHILD);
+		GetClassName(child, name, 24);
+		if (!strnicmp(name, "WinampVis", 24)) {
+			hwndWinamp = hwnd;
+			return FALSE;
+		}
+	}
+	return TRUE;
+}
+
+HWND GetWinampHWND(HWND winamp) {
+	// if no HWND is passed then attemp to find it
+	if (!IsWindow(winamp)) {
+		// but only do the enumeration again if we have an invalid HWND cached
+		if (!IsWindow(hwndWinamp)) {
+			hwndWinamp = 0;
+			EnumThreadWindows(GetCurrentThreadId(), EnumWindowsProc, 0);
+		}
+		return hwndWinamp;
+	} else {
+		return (hwndWinamp = winamp);
+	}
+}
+
+HINSTANCE GetMyInstance() {
+	MEMORY_BASIC_INFORMATION mbi = {0};
+	if (VirtualQuery(GetMyInstance, &mbi, sizeof(mbi))) {
+		return (HINSTANCE)mbi.AllocationBase;
+	}
+	return NULL;
+}
+
+char* GetIniDirectory(HWND winamp) {
+	if (!IniDir[0]) {
+		// this gets the string of the full ini file path
+		strncpy(IniDir, (char*)SendMessage(winamp, WM_WA_IPC, 0, IPC_GETINIDIRECTORY), MAX_PATH);
+	}
+	return IniDir;
+}
+
+wchar_t* GetIniDirectoryW(HWND winamp) {
+	if (!IniDirW[0]) {
+		// this gets the string of the full ini file path
+		wcsncpy(IniDirW, (wchar_t*)SendMessage(winamp, WM_WA_IPC, 0, IPC_GETINIDIRECTORYW), MAX_PATH);
+	}
+	return IniDirW;
+}
+
+char* GetPluginDirectory(HWND winamp) {
+	// this gets the string of the full plug-in folder path
+	strncpy(PluginDir, (char*)SendMessage(winamp, WM_WA_IPC, 0, IPC_GETPLUGINDIRECTORY), MAX_PATH);
+	return PluginDir;
+}
+
+wchar_t* GetPluginDirectoryW(HWND winamp) {
+	// this gets the string of the full plug-in folder path
+	wcsncpy(PluginDirW, (wchar_t*)SendMessage(winamp, WM_WA_IPC, 0, IPC_GETPLUGINDIRECTORYW), MAX_PATH);
+	return PluginDirW;
+}
+
+wchar_t* GetSharedDirectoryW(HWND winamp) {
+	// this gets the string of the full shared dll folder path
+	wchar_t* str = (wchar_t*)SendMessage(winamp, WM_WA_IPC, 0, IPC_GETSHAREDDLLDIRECTORYW);
+	if (str > (wchar_t*)65536) {
+		wcsncpy(SharedDirW, str, MAX_PATH);
+	} else {
+		// and on older versions of Winamp we revert to the plug-ins folder path
+		wcsncpy(SharedDirW, GetPluginDirectoryW(winamp), MAX_PATH);
+	}
+	return SharedDirW;
+}
+
+void GetDefaultNextTracksLogFile(HWND winamp, int bufferLen, wchar_t* buffer, int index) {
+	snwprintf(buffer, bufferLen, L"%s\\Plugins\\dsp_sc_nexttracks_%d.log", GetIniDirectoryW(winamp), index+1);
+}
+
+char* GetSCIniFile(HWND winamp) {
+	if (!IniName[0]) {
+
+		// allows support for multiple instances of the dsp_sc.dll
+		// without the settings being saved into the same section
+		char dll_name[MAX_PATH] = {"dsp_sc"};
+		if (GetModuleFileName(module.hDllInstance, dll_name, MAX_PATH)) {
+			PathStripPath(dll_name);
+			PathRemoveExtension(dll_name);
+		}
+		snprintf(IniName, MAX_PATH, "%s\\Plugins\\%s.ini", GetIniDirectory(winamp), dll_name);
+	}
+	return IniName;
+}
+
+wchar_t* GetSCLogFile(HWND winamp, int bufferLen, wchar_t* logFile, int index) {
+	snwprintf(logFile, bufferLen, L"%s\\Plugins\\dsp_sc_%d.log", GetIniDirectoryW(winamp), index + 1);
+	return logFile;
+}
+
+char* CreateLogFileMessage(char* buffer, wchar_t* message, int* len) {
+	SYSTEMTIME sysTime;
+	GetLocalTime(&sysTime);
+	char d[100], t[100], msg[1024];
+	GetDateFormat(LOCALE_SYSTEM_DEFAULT, 0, &sysTime, "yyyy'-'MM'-'dd", d, 99);
+	GetTimeFormat(LOCALE_SYSTEM_DEFAULT, 0, &sysTime, "HH':'mm':'ss", t, 99);
+
+	std::string utf8 = ConvertToUTF8(message);
+	char* m = (char*)utf8.c_str();
+	char* n = msg;
+	while (m && *m) {
+		if (m && *m && *m == '\n') {
+			*n = ' ';
+		} else if (m) {
+			if (n) *n = *m;
+		}
+		m = CharNext(m);
+		n = CharNext(n);
+	}
+	*n = 0;
+
+	*len = snprintf(buffer, 1024, "%s %s\t%s\r\n", d, t, msg);
+	return buffer;
+}
+
+void StartNextTracks(int index, wchar_t* file) {
+	NextTracks[index] = CreateFileW(file, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_ALWAYS, 0, 0);
+	if (NextTracks[index] != INVALID_HANDLE_VALUE) {
+		// reset the file on loading things
+		SetFilePointer(NextTracks[index], 0, NULL, FILE_BEGIN);
+		SetEndOfFile(NextTracks[index]);
+	}
+}
+
+void WriteNextTracks(int index, HWND winamp, std::vector<int> nextListIdx, std::vector<std::wstring> nextList, bool xml) {
+	if (NextTracks[index] != INVALID_HANDLE_VALUE) {
+		DWORD written;
+
+		// reset the file so if there are no tracks then that'll be set
+		SetFilePointer(NextTracks[index], 0, NULL, FILE_BEGIN);
+		SetEndOfFile(NextTracks[index]);
+
+		std::stringstream s;
+		if (xml) {
+			s << "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n<nexttracks>\n";
+		}
+
+		if (!nextList.empty()) {
+			std::vector<std::wstring>::const_iterator i = nextList.begin();
+			std::vector<int>::const_iterator idx = nextListIdx.begin();
+			for (int count = 1; i != nextList.end(); ++i, ++idx, count++) {
+				wchar_t *file=(wchar_t*)SendMessage(module.hwndParent, WM_WA_IPC, (*idx), IPC_GETPLAYLISTFILEW);
+				if (xml) {
+					std::string filepath = ConvertToUTF8Escaped(file);
+					s << "\t<file seq=\"" << count << "\">" << filepath << "</file>\n\t";
+					std::string next = ConvertToUTF8Escaped((*i).c_str());
+					s << "<title seq=\"" << count << "\">" << next << "</title>\n";
+				} else {
+					std::string rawfilepath = ConvertToUTF8(file);
+					WriteFile(NextTracks[index], rawfilepath.c_str(), rawfilepath.length(), &written, 0);
+					WriteFile(NextTracks[index], "\r\n", 2, &written, 0);
+				}
+			}
+		}
+
+		if (xml) {
+			s << "</nexttracks>\n";
+			WriteFile(NextTracks[index], s.str().data(), s.str().length(), &written, 0);
+		}
+	}
+}
+
+void StopNextTracks(int index) {
+	if (NextTracks[index] != INVALID_HANDLE_VALUE) {
+		CloseHandle(NextTracks[index]);
+		NextTracks[index] = INVALID_HANDLE_VALUE;
+	}
+}
+
+void StartSaveEncoded(int index, wchar_t* file) {
+	SaveEncoded[index] = CreateFileW(file, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_ALWAYS, 0, 0);
+	if (SaveEncoded[index] != INVALID_HANDLE_VALUE) {
+		// reset the file on loading things
+		SetFilePointer(SaveEncoded[index], 0, NULL, FILE_BEGIN);
+		SetEndOfFile(SaveEncoded[index]);
+	}
+}
+
+void WriteSaveEncoded(int index, LPCVOID buffer, int bufferLen) {
+	if (SaveEncoded[index] != INVALID_HANDLE_VALUE) {
+		DWORD written;
+		WriteFile(SaveEncoded[index], buffer, bufferLen, &written, 0);
+	}
+}
+
+void StopSaveEncoded(int index) {
+	if (SaveEncoded[index] != INVALID_HANDLE_VALUE) {
+		CloseHandle(SaveEncoded[index]);
+		SaveEncoded[index] = INVALID_HANDLE_VALUE;
+	}
+}
+
+void StartLogging(int index, int clearOnStart) {
+	wchar_t name[MAX_PATH];
+	logFiles[index] = CreateFileW(GetSCLogFile(module.hwndParent, ARRAYSIZE(name), name, index), GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_ALWAYS, 0, 0);
+	if (logFiles[index] != INVALID_HANDLE_VALUE) {
+		// clear the file when started
+		if (clearOnStart) {
+			SetFilePointer(logFiles[index], 0, NULL, FILE_BEGIN);
+			SetEndOfFile(logFiles[index]);
+		} else {
+			SetFilePointer(logFiles[index], 0, NULL, FILE_END);
+		}
+
+		int len = 0;
+		DWORD written;
+		char buf[1024];
+		CreateLogFileMessage(buf, L"Logging starting", &len);
+		WriteFile(logFiles[index], buf, len, &written, 0);
+	}
+}
+
+void StopLogging(int index) {
+	if (logFiles[index] != INVALID_HANDLE_VALUE) {
+		int len = 0;
+		DWORD written;
+		char buf[1024];
+		CreateLogFileMessage(buf, L"Logging stopping\r\n", &len);
+		WriteFile(logFiles[index], buf, len, &written, 0);
+		CloseHandle(logFiles[index]);
+	}
+	logFiles[index] = INVALID_HANDLE_VALUE;
+}
+
+BOOL IsDirectMouseWheelMessage(const UINT uMsg) {
+	static UINT WINAMP_WM_DIRECT_MOUSE_WHEEL = WM_NULL;
+
+	if (WM_NULL == WINAMP_WM_DIRECT_MOUSE_WHEEL) {
+		WINAMP_WM_DIRECT_MOUSE_WHEEL = RegisterWindowMessageW(L"WINAMP_WM_DIRECT_MOUSE_WHEEL");
+		if (WM_NULL == WINAMP_WM_DIRECT_MOUSE_WHEEL)
+			return FALSE;
+	}
+
+	return (WINAMP_WM_DIRECT_MOUSE_WHEEL == uMsg);
+}
+
+HWND ActiveChildWindowFromPoint(HWND hwnd, POINTS cursor_s, const int *controls, size_t controlsCount) {	
+	POINT pt = {0};
+	RECT controlRect = {0};
+	POINTSTOPOINT(pt, cursor_s);
+
+	while (controlsCount--) {
+		HWND controlWindow = GetDlgItem(hwnd, controls[controlsCount]);
+		if (NULL != controlWindow &&
+			FALSE != GetClientRect(controlWindow, &controlRect)) {
+			MapWindowPoints(controlWindow, HWND_DESKTOP, (POINT*)&controlRect, 2);
+			if (FALSE != PtInRect(&controlRect, pt)) {	
+				unsigned long windowStyle;
+				windowStyle = (unsigned long)GetWindowLongPtrW(controlWindow, GWL_STYLE);
+				if (WS_VISIBLE == ((WS_VISIBLE | WS_DISABLED) & windowStyle))
+					return controlWindow;	
+				break;
+			}
+		}
+	}
+	return NULL;
+}
+
+BOOL DirectMouseWheel_ProcessDialogMessage(HWND hwnd, unsigned int uMsg, WPARAM wParam, LPARAM lParam) {
+	if (FALSE != IsDirectMouseWheelMessage(uMsg)) {
+		const int controls[] = {
+			IDC_MUSSLIDER,
+			IDC_MUS2SLIDER,
+			IDC_MICSLIDER,
+			IDC_FADESLIDER,
+			IDC_MICFADESLIDER,
+		};
+		HWND targetWindow = ActiveChildWindowFromPoint(hwnd, MAKEPOINTS(lParam), controls, ARRAYSIZE(controls));
+		if (NULL != targetWindow) {
+			SendMessage(targetWindow, WM_MOUSEWHEEL, wParam, lParam);
+			SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, (long)TRUE);
+			return TRUE;
+		}
+	}
+	return FALSE;
+}
+
+
+static HCURSOR link_hand_cursor;
+LRESULT link_handlecursor(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) {
+	LRESULT ret = CallWindowProcW((WNDPROC)GetPropW(hwndDlg, L"link_proc"), hwndDlg, uMsg, wParam, lParam);
+	// override the normal cursor behaviour so we have a hand to show it is a link
+	if (uMsg == WM_SETCURSOR) {
+		if ((HWND)wParam == hwndDlg) {
+			if (!link_hand_cursor) {
+				link_hand_cursor = LoadCursor(NULL, IDC_HAND);
+			}
+			SetCursor(link_hand_cursor);
+			return TRUE;
+		}
+	}
+	return ret;
+}
+
+void link_startsubclass(HWND hwndDlg, UINT id) {
+	HWND ctrl = GetDlgItem(hwndDlg, id);
+	if (!GetPropW(ctrl, L"link_proc")) {
+		SetPropW(ctrl, L"link_proc", (HANDLE)SetWindowLongPtrW(ctrl, GWLP_WNDPROC, (LONG_PTR)link_handlecursor));
+	}
+}
+
+BOOL link_handledraw(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) {
+	if (uMsg == WM_DRAWITEM) {
+		DRAWITEMSTRUCT *di = (DRAWITEMSTRUCT *)lParam;
+		if (di->CtlType == ODT_BUTTON) {
+			wchar_t wt[123];
+			int y;
+			RECT r;
+
+			// due to the fun of theming and owner drawing we have to get the background colour
+			if (isthemethere){
+				HTHEME hTheme = OpenThemeData(hwndDlg, L"Tab");
+				if (hTheme) {
+					DrawThemeParentBackground(di->hwndItem, di->hDC, &di->rcItem);
+					CloseThemeData(hTheme);
+				}
+			}
+
+			HPEN hPen, hOldPen;
+			GetDlgItemTextW(hwndDlg, wParam, wt, ARRAYSIZE(wt));
+
+			// draw text
+			SetTextColor(di->hDC, (di->itemState & ODS_SELECTED) ? RGB(220, 0, 0) : RGB(0, 0, 220));
+			r = di->rcItem;
+			r.left += 2;
+			DrawTextW(di->hDC, wt, -1, &r, DT_VCENTER | DT_SINGLELINE);
+
+			memset(&r, 0, sizeof(r));
+			DrawTextW(di->hDC, wt, -1, &r, DT_SINGLELINE | DT_CALCRECT);
+
+			// draw underline
+			y = di->rcItem.bottom - ((di->rcItem.bottom - di->rcItem.top) - (r.bottom - r.top)) / 2 - 1;
+			hPen = CreatePen(PS_SOLID, 0, (di->itemState & ODS_SELECTED) ? RGB(220, 0, 0) : RGB(0, 0, 220));
+			hOldPen = (HPEN) SelectObject(di->hDC, hPen);
+			MoveToEx(di->hDC, di->rcItem.left + 2, y, NULL);
+			LineTo(di->hDC, di->rcItem.right + 2 - ((di->rcItem.right - di->rcItem.left) - (r.right - r.left)), y);
+			SelectObject(di->hDC, hOldPen);
+			DeleteObject(hPen);
+			return TRUE;
+		}
+	}
+	return FALSE;
+}
+
+#include <map>
+class xmlEscapes: public std::map<char,std::string>
+{
+public:
+	xmlEscapes() {  		
+		(*this)['<'] = "&lt;";
+		(*this)['>'] = "&gt;";
+		(*this)['&'] = "&amp;";
+		(*this)['\''] = "&apos;";
+		(*this)['"'] = "&quot;";
+	}
+};
+
+static const xmlEscapes gsXmlEscapes;
+
+// this will only be receiving an already converted
+// string so no need to do the commented part again
+char* escapeXML(const char* s) {
+	static char result[2048] = {0};
+	memset(&result, 0, 2048);
+	int len = strlen(s);
+	for (int x = 0, y = 0; x < len; x++)
+	{
+		xmlEscapes::const_iterator i = gsXmlEscapes.find(s[x]);
+		if (i != gsXmlEscapes.end()) {
+			strcat(&result[y-1], (*i).second.c_str());
+			y += (*i).second.size();
+		} else if (s[x] >= 0 && s[x] <= 31 && s[x] != 9 && s[x] != 10 && s[x] != 13) {
+			// strip out characters which aren't supported by the DNAS
+			// (only allow backspace, linefeed and carriage return)
+			#ifdef DEBUG
+			result[y] = '\xEF';
+			y++;
+			result[y] = '\xBF';
+			y++;
+			result[y] = '\xBD';
+			y++;
+			#endif
+		} else if ((x < len - 2) && s[x] == '\xEF' && s[x+1] == '\xBF' && s[x+2] == '\xBF') {
+			// and any UTF-8 boms which are in there (seen it happen!)
+			x+=2;
+			#ifdef DEBUG
+			result[y] = '\xEF';
+			y++;
+			result[y] = '\xBF';
+			y++;
+			result[y] = '\xBD';
+			y++;
+			#endif
+		} else {
+			result[y] = s[x];
+			y++;
+		}
+	}
+	return result;
+}
+
+char* ConvertToUTF8Escaped(const wchar_t *str) {
+	static char utf8tmp[1024] = {0};
+	memset(&utf8tmp, 0, sizeof(utf8tmp));
+	WideCharToMultiByte(CP_UTF8, 0, str, -1, utf8tmp, sizeof(utf8tmp), 0, 0);
+	return escapeXML(utf8tmp);
+}
+
+char* ConvertToUTF8(const wchar_t *str) {
+	static char utf8tmp2[1024] = {0};
+	memset(&utf8tmp2, 0, sizeof(utf8tmp2));
+	WideCharToMultiByte(CP_UTF8, 0, str, -1, utf8tmp2, sizeof(utf8tmp2), 0, 0);
+	return utf8tmp2;
+}
+
+int ConvertFromUTF8(const char *src, wchar_t *dest, int destlen) {
+	if (destlen == 0)
+		return MultiByteToWideChar(CP_UTF8, 0, src, -1, dest, destlen);
+	int converted = MultiByteToWideChar(CP_UTF8, 0, src, -1, dest, destlen-1);
+	if (!converted)
+		return 0;
+	dest[converted]=0;
+	return converted+1;
+}
+
+DWORD GetPrivateProfileStringUTF8(LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpDefault, LPWSTR lpReturnedString, DWORD nSize, LPCSTR lpFileName) {
+	char tmp[MAX_PATH] = {0};
+	GetPrivateProfileString(lpAppName, lpKeyName, lpDefault, tmp, nSize, lpFileName);
+	return ConvertFromUTF8(tmp, lpReturnedString, nSize);
+}
+
+
+void ShowWindowDlgItem(HWND hDlg, int nIDDlgItem, int nCmdShow) {
+	ShowWindow(GetDlgItem(hDlg, nIDDlgItem), nCmdShow);
+}
+
+void EnableWindowDlgItem(HWND hDlg, int nIDDlgItem, BOOL bEnable) {
+	EnableWindow(GetDlgItem(hDlg, nIDDlgItem), bEnable);
+}
+
+template<typename S,typename F>
+std::vector<S> tokenizer_if(const S &ins,F isdelimiter) throw()
+{
+	std::vector<S> result;
+	S accum;
+
+	for(typename S::const_iterator i = ins.begin(); i != ins.end(); ++i)
+	{
+		if (!isdelimiter(*i))
+		{
+			accum.push_back(*i);// was +=
+		}
+		else
+		{
+			if (!accum.empty())
+			{
+				result.push_back(accum);
+				accum = S();
+			}
+		}
+	}
+
+	if (!accum.empty())
+		result.push_back(accum);
+	return result;
+}
+
+template<typename S>
+inline std::vector<S> tokenizer(const S &ins,typename S::value_type delim) throw()
+	{ return tokenizer_if(ins,bind1st(std::equal_to<typename S::value_type>(),delim)); }
+
+extern char sourceVersion[64];
+bool CompareVersions(char *verStr)
+{
+	bool needsUpdating = false;
+	if (verStr && *verStr)
+	{
+		std::vector<std::string> newVerStr = tokenizer(std::string(verStr), '.');
+		std::vector<std::string> curVerStr = tokenizer(std::string(sourceVersion), '.');
+		int newVer[] = {::atoi(newVerStr[0].c_str()), ::atoi(newVerStr[1].c_str()), ::atoi(newVerStr[2].c_str()), ::atoi(newVerStr[3].c_str())},
+			curVer[] = {::atoi(curVerStr[0].c_str()), ::atoi(curVerStr[1].c_str()), ::atoi(curVerStr[2].c_str()), ::atoi(curVerStr[3].c_str())};
+
+		// look to compare from major to minor parts of the version strings
+		// 2.x.x.x vs 3.x.x.x
+		if (newVer[0] > curVer[0]) {
+			needsUpdating = true;
+		}
+		// 2.0.x.x vs 2.2.x.x
+		else if((newVer[0] == curVer[0]) && (newVer[1] > curVer[1])) {
+			needsUpdating = true;
+		}
+		// 2.0.0.x vs 2.0.1.x
+		else if((newVer[0] == curVer[0]) && (newVer[1] == curVer[1]) && (newVer[2] > curVer[2])) {
+			needsUpdating = true;
+		}
+		// 2.0.0.29 vs 2.0.0.30
+		else if((newVer[0] == curVer[0]) && (newVer[1] == curVer[1]) && (newVer[2] == curVer[2]) && (newVer[3] > curVer[3])) {
+			needsUpdating = true;
+		}
+	}
+	return needsUpdating;
+}
\ No newline at end of file