Initial community commit

1 files changed, 1136 insertions, 0 deletions

diff --git a/Src/Winamp/lang.cpp b/Src/Winamp/lang.cpp
new file mode 100644
index 00000000..5c2f9581
--- /dev/null
+++ b/Src/Winamp/lang.cpp
@@ -0,0 +1,1136 @@
+/** (c) Nullsoft, Inc.         C O N F I D E N T I A L
+** Filename: 
+** Project:
+** Description: Utility functions for handling language support
+** Author:
+** Created:
+**/
+
+#include <locale.h>
+#include "main.h"
+#include "language.h"
+#include "../nu/AutoWide.h"
+#include "../nu/AutoChar.h"
+#include "minizip/unzip.h"
+#include <vector>
+#include "../nu/AutoCharFn.h"
+
+typedef struct {
+	wchar_t *module;
+	wchar_t *guidstr;	// generally is 0 or 39 (38+null)
+	int guid;
+	int external;
+	HINSTANCE hDllInstance;
+} winampLangStruct;
+
+static std::vector<winampLangStruct*> lnglist;
+int already_extracted = 0, prev_wlz_ex_state = 0, geno = 1, started = 0;
+
+// data storage of the read in values requires just the hash and the id to be stored
+// and has to be logged against the different id types so just need a list of structs
+// based against each type (dialog, string resource, etc)
+
+// for the moment we deal with the following resource types
+// RT_DIALOG, RT_MENU, RT_STRING & custom resources
+// so for initial implementation we only need to store upto 4 hash+id lists
+
+#if 0
+typedef struct {
+	int id;
+	char id_str[32];
+	char hash[17];
+	char str[64];
+} hashstruct;
+
+std::vector<hashstruct*> dialogList;
+std::vector<hashstruct*> menuList;
+std::vector<hashstruct*> stringList;	// will be the largest of the lot
+std::vector<hashstruct*> customList; // should be very few of this
+#endif
+
+// have section header (text or int id)
+// then the hash and then the id that's related the hash eg the dialog resource id
+
+void ReadHashFileDetails(char* data, DWORD datalen)
+{
+#if 0
+	char* p = data, *s = p, *t = 0, *u;
+	while(s && *s)
+	{
+		// is it the start of a block that we've just gotten to...
+		if(*s == '@' || *s == '#')
+		{
+			int id = -1;
+			char id_str[32] = {0};
+			u = s = CharNext(s);
+			if(!*s){break;}
+
+			// advance to the end of the line to get the block identifier
+			// would need to use the @ or # to process the type used
+			// ie if a type 5 then only use on dialog loading calls
+			while(u && *u && *u != '\n'){u = CharNext(u);}
+			if(*u == '\n'){u = CharNext(u);*CharPrev(p,u) = 0;}
+			if(!*u){break;}
+
+			// identifier of the block is found here :)
+			if(*s)
+			{
+				id = atoi(s);
+				if(!id)
+				{
+					lstrcpyn(id_str, s, sizeof(id_str));
+				}
+			}
+			*CharPrev(p,u) = '\n';
+
+			while(s && *s && (*s != '@' && *s != '#'))
+			{
+				int end = 0;
+
+				while(s && *s && *s != '\n'){s = CharNext(s);}
+				if(*s == '\n'){s = CharNext(s);}
+				// if nothing else then need to abort (since we don't want to do bad things)
+				// and have to take into account where in the buffer we are otherwise we can
+				// end up going into the next part of the dll/exe resource data due to how
+				// it is all stored/handled in them (ie butted up against each other)
+				if(!*s || s >= p+datalen){break;}
+
+				t = s;
+				// do a check after we've advanced to the start of a new line
+				// so that we can see if we've hit a new resource type block
+				if(*s == '@' || *s == '#')
+				{
+					s = CharPrev(p,s);
+					break;
+				}
+
+				// scan through to the start of the second part of the <hash:id> block
+				while(t && *t && *t != ':')
+				{
+					t = CharNext(t);
+				}
+
+				if(*t == ':')
+				{
+					t = CharNext(t);
+					*CharPrev(p,t) = 0;
+				}
+
+				// scan through to the end of the line so that we then have the id
+				u = t;
+				while(u && *u && *u != '\n')
+				{
+					u = CharNext(u);
+				}
+
+				if(*u == '\n')
+				{
+					u = CharNext(u);
+					*CharPrev(p,u) = 0;
+				}
+
+				// hash and identifier of the entry is found here :)
+				// -> need to check how it works with IDD_CRASHDLG$()
+				if(*s)
+				{
+					hashstruct* tempList = reinterpret_cast<hashstruct*>(calloc(1, sizeof(hashstruct)));
+					ZeroMemory(tempList,sizeof(hashstruct));
+
+					/*if(*t == 1) wsprintf(a,"%s %d (%s)\n", s, *t, t+1);
+					else wsprintf(a,"%s %s (%d)\n", s, t+1, *t);*/
+					if(*t == 1)	// int_id
+						lstrcpyn(tempList->str, t+1, sizeof(tempList->str));
+					else		// string_id
+						lstrcpyn(tempList->str, t+1, *t/*sizeof(tempList->str)*/);
+
+					lstrcpyn(tempList->hash, s, sizeof(tempList->hash));
+					if(id) tempList->id = id;
+
+					switch(id)
+					{
+						case RT_MENU:
+						{
+							menuList.push_back(tempList);
+						}
+							break;
+						case RT_DIALOG:
+						{
+							dialogList.push_back(tempList);
+						}
+							break;
+						case RT_STRING:
+						{
+							stringList.push_back(tempList);
+						}
+							break;
+						default:
+							// only do if there's no id from atoi (indicates a custom resource id)
+							if(!id)
+							{
+								lstrcpyn(tempList->id_str, id_str, sizeof(tempList->id_str));
+								customList.push_back(tempList);
+							}
+							break;
+					}
+
+					{
+						char zz[100] = {0};
+						StringCchPrintf(zz,100,"ID: '%s' %d\t%s %s\n",
+										tempList->id_str, tempList->id,
+										tempList->hash, tempList->str);
+						OutputDebugString(zz);
+					}
+				}
+				*CharPrev(p,u) = '\n';
+				s = CharPrev(p,u);
+			}
+		}
+		s = CharNext(s);
+	}
+#endif
+}
+
+int GetImageHashData(HINSTANCE imageInstance)
+{
+	DWORD datalen = 0;
+	void* data = langManager->LoadResourceFromFile(imageInstance,imageInstance,L"HASH",L"HASH",&datalen);
+	ReadHashFileDetails((char*)data,datalen);
+	UnlockResource(data);
+	FreeResource(data);
+	return 0;
+}
+
+#ifdef _DEBUG
+static void CheckLangThread()
+{
+	if (mainThreadId != GetCurrentThreadId())
+	{
+//		DebugBreak();
+		/**
+		** If you hit this breakpoint, it's because you tried to use WASABI_API_LANG->GetString on another thread,
+		** without supplying your own buffer.
+		** You really don't want to be doing that.
+		** Hit alt+7, check what function is calling GetString/GetStringW and go fix it.
+		** Now.
+		**/
+	}
+}
+
+#else
+#define CheckLangThread()
+#endif
+
+char *getString(UINT uID, char *str, size_t maxlen)
+{
+	return langManager->GetString(language_pack_instance,hMainInstance, uID, str, maxlen);
+}
+
+int LPMessageBox(HWND parent, UINT idMessage, UINT idTitle, UINT type)
+{
+	wchar_t message[32768] = {0};
+	wchar_t title[256] = {0};
+
+	// TODO consider exposing something in the winamp.lng file so we can follow this where possible as it should allow for a localised messagebox as long as the OS supports the language
+	// return MessageBoxExW(parent,getStringW(idMessage,message,32768),getStringW(idTitle,title,256),type,MAKELANGID(LANG_FRENCH, SUBLANG_FRENCH));
+	return MessageBoxW(parent,getStringW(idMessage,message,32768),getStringW(idTitle,title,256),type);
+}
+
+char* Language::GetString(HINSTANCE hinst, HINSTANCE owner, UINT uID, char *str, size_t maxlen)
+{
+	__declspec(thread) static char *buf;
+	if (!str)
+	{
+		CheckLangThread();
+		if (!buf)
+			buf = (char *)calloc(LANG_STATIC_BUFFER_SIZE, sizeof(buf[0]));
+		str = buf; 
+		maxlen = LANG_STATIC_BUFFER_SIZE; 
+	}
+
+	// sometimes we need to ignore things i.e. accessing on closing, etc
+	if (((unsigned long)str >= 65536) && !LoadStringA((started ? hinst : owner), uID, str, (int)maxlen))
+	{
+		if (hinst == owner || !LoadStringA(owner, uID, str, (int)maxlen))
+		{
+			lstrcpynA(str, "Error loading string", (int)maxlen);
+		}
+	}
+	return str;
+}
+
+wchar_t *getStringW(UINT uID, wchar_t *str, size_t maxlen)
+{
+	return langManager->GetStringW(language_pack_instance,hMainInstance, uID, str, maxlen);
+}
+
+wchar_t* Language::GetStringW(HINSTANCE hinst, HINSTANCE owner, UINT uID, wchar_t *str, size_t maxlen)
+{
+	__declspec(thread) static wchar_t *buf;
+	if (!str) 
+	{
+		CheckLangThread();
+		if (!buf) 	
+			buf = (wchar_t *)calloc(LANG_STATIC_BUFFER_SIZE, sizeof(buf[0]));
+		str = buf; 
+		maxlen = LANG_STATIC_BUFFER_SIZE; 
+	}
+
+	// sometimes we need to ignore things i.e. accessing on closing, etc
+	if (((unsigned long)str >= 65536) && !LoadStringW((started ? hinst : owner), uID, str, (int)maxlen))
+	{
+		if (hinst == owner || !LoadStringW(owner, uID, str, (int)maxlen))
+		{
+			lstrcpynW(str, L"Error loading string", (int)maxlen);
+		}
+	}
+	return str;
+}
+
+char* Language::GetStringFromGUID(const GUID guid, HINSTANCE owner, UINT uID, char *str, size_t maxlen)
+{
+	__declspec(thread) static char *buf;
+	if (!str) 
+	{
+		CheckLangThread();
+		if (!buf) 	
+			buf = (char *)calloc(LANG_STATIC_BUFFER_SIZE, sizeof(buf[0]));
+		str = buf; 
+		maxlen = LANG_STATIC_BUFFER_SIZE; 
+	}
+
+	HINSTANCE tl = FindDllHandleByGUID(guid);
+	if(!tl) tl = owner;
+
+	// sometimes we need to ignore things i.e. accessing on closing, etc
+	if (((unsigned long)str >= 65536) && !LoadStringA((started ? tl : owner), uID, str, (int)maxlen))
+	{
+		if (!LoadStringA(owner, uID, str, (int)maxlen))
+		{
+			lstrcpynA(str, "Error loading string", (int)maxlen);
+		}
+	}
+	return str;
+}
+
+wchar_t* Language::GetStringFromGUIDW(const GUID guid, HINSTANCE owner, UINT uID, wchar_t *str, size_t maxlen)
+{
+	__declspec(thread) static wchar_t *buf;
+	if (!str) 
+	{
+		CheckLangThread();
+		if (!buf) 	
+			buf = (wchar_t *)calloc(LANG_STATIC_BUFFER_SIZE, sizeof(buf[0]));
+		str = buf; 
+		maxlen = LANG_STATIC_BUFFER_SIZE; 
+	}
+
+	HINSTANCE tl = FindDllHandleByGUID(guid);
+	if(!tl) tl = owner;
+
+	// sometimes we need to ignore things i.e. accessing on closing, etc
+	if (((unsigned long)str >= 65536) && !LoadStringW((started ? tl : owner), uID, str, (int) maxlen))
+	{
+		if (!LoadStringW(owner, uID, str, (int) maxlen))
+		{
+			lstrcpynW(str, L"Error loading string", (int) maxlen);
+		}
+	}
+	return str;
+}
+
+const wchar_t *Language::GetLanguageFolder()
+{
+	return (LANGTEMPDIR[0] ? LANGTEMPDIR : lang_directory);
+}
+
+void* Language::LoadResourceFromFileW(HINSTANCE hinst, HINSTANCE owner, LPCWSTR lpType, LPCWSTR lpName, DWORD* size)
+{
+	HINSTANCE hmod = hinst;
+	HRSRC rsrc = FindResourceW(hmod, lpName, lpType);
+	if(!rsrc)
+	{
+		hmod = owner;
+		rsrc = FindResourceW(hmod, lpName, lpType);
+	}
+	if(rsrc)
+	{
+		HGLOBAL resourceHandle = LoadResource(hmod, rsrc);
+		if(size){*size = SizeofResource(hmod, rsrc);}
+		return LockResource(resourceHandle);
+	}
+	return 0;
+}
+
+void* Language::LoadResourceFromFile(HINSTANCE hinst, HINSTANCE owner, LPCTSTR lpType, LPCTSTR lpName, DWORD* size)
+{
+	HINSTANCE hmod = hinst;
+	HRSRC rsrc = FindResource(hmod, lpName, lpType);
+	if(!rsrc)
+	{
+		hmod = owner;
+		rsrc = FindResource(hmod, lpName, lpType);
+	}
+	if(rsrc)
+	{
+		HGLOBAL resourceHandle = LoadResource(hmod, rsrc);
+		if(size){*size = SizeofResource(hmod, rsrc);}
+		return LockResource(resourceHandle);
+	}
+	return 0;
+}
+
+const wchar_t *Language::GetLanguageIdentifier( int mode )
+{
+	static wchar_t id_str[ 9 ] = { 0 };
+	id_str[ 0 ] = 0;
+	// 5.58 fix - was returning en-US on all calls to this via load_extra_lng(..)
+	// make sure to try to use a loaded winamp.lng as load_extra_lng(..) relies on
+	// this for the path to use but calls it before getStringW(..) will work fully
+	GetStringFromGUIDW( WinampLangGUID, hMainInstance, LANG_PACK_LANG_ID, id_str, 9 );
+
+	if ( !_wcsicmp( id_str, L"Error l" ) )
+	{
+		id_str[ 0 ] = 0;
+	}
+
+	if ( mode && id_str[ 0 ] )
+	{
+		wchar_t *iStr = id_str;
+
+		while ( iStr && *iStr && *iStr != L'-' )
+		{
+			iStr = CharNextW( iStr );
+		}
+
+		if ( iStr && *iStr == '-' )
+		{
+			iStr = CharNextW( iStr );
+			*CharPrevW( id_str, iStr ) = 0;
+		}
+
+		if ( mode == LANG_LANG_CODE )
+			return id_str;
+		else if ( mode == LANG_COUNTRY_CODE )
+			return iStr;
+	}
+
+	return ( id_str[ 0 ] ? id_str : 0 );
+}
+
+HWND Language::CreateLDialogParam( HINSTANCE localised, HINSTANCE original, UINT id, HWND parent, DLGPROC proc, LPARAM param )
+{
+	HWND hwnd = (HWND)CreateDialogParamA( localised, MAKEINTRESOURCEA( id ), parent, proc, param );
+	if ( !hwnd && localised != original )
+		hwnd = (HWND)CreateDialogParamA( original, MAKEINTRESOURCEA( id ), parent, proc, param );
+	return hwnd;
+}
+
+HWND Language::CreateLDialogParamW( HINSTANCE localised, HINSTANCE original, UINT id, HWND parent, DLGPROC proc, LPARAM param )
+{
+	HWND hwnd = (HWND)CreateDialogParamW( localised, MAKEINTRESOURCEW( id ), parent, proc, param );
+	if ( !hwnd && localised != original )
+		hwnd = (HWND)CreateDialogParamW( original, MAKEINTRESOURCEW( id ), parent, proc, param );
+	return hwnd;
+}
+
+INT_PTR Language::LDialogBoxParam( HINSTANCE localised, HINSTANCE original, UINT id, HWND parent, DLGPROC proc, LPARAM param )
+{
+	INT_PTR ret = DialogBoxParamA( localised, MAKEINTRESOURCEA( id ), parent, proc, param );
+	if ( ( ret == -1 && GetLastError() != ERROR_SUCCESS ) && localised != original )
+		ret = DialogBoxParamA( original, MAKEINTRESOURCEA( id ), parent, proc, param );
+	return ret;
+}
+
+INT_PTR Language::LDialogBoxParamW( HINSTANCE localised, HINSTANCE original, UINT id, HWND parent, DLGPROC proc, LPARAM param )
+{
+	INT_PTR ret = DialogBoxParamW( localised, MAKEINTRESOURCEW( id ), parent, proc, param );
+	if ( ( ret == -1 && GetLastError() != ERROR_SUCCESS ) && localised != original )
+		ret = DialogBoxParamW( original, MAKEINTRESOURCEW( id ), parent, proc, param );
+	return ret;
+}
+
+HWND LPCreateDialogParam( int id, HWND parent, DLGPROC proc, LPARAM param )
+{
+	return langManager->CreateLDialogParam( language_pack_instance, hMainInstance, id, parent, proc, param );
+}
+
+HWND LPCreateDialogParamW( int id, HWND parent, DLGPROC proc, LPARAM param )
+{
+	return langManager->CreateLDialogParamW( language_pack_instance, hMainInstance, id, parent, proc, param );
+}
+
+INT_PTR LPDialogBoxParam( int id, HWND parent, DLGPROC proc, LPARAM param )
+{
+	return langManager->LDialogBoxParam( language_pack_instance, hMainInstance, id, parent, proc, param );
+}
+
+INT_PTR LPDialogBoxParamW( int id, HWND parent, DLGPROC proc, LPARAM param )
+{
+	return langManager->LDialogBoxParamW( language_pack_instance, hMainInstance, id, parent, proc, param );
+}
+
+HMENU Language::LoadLMenu( HINSTANCE localised, HINSTANCE original, UINT id )
+{
+	HMENU menu = LoadMenuA( localised, MAKEINTRESOURCEA( id ) );
+	if ( !menu && localised != original )
+		menu = LoadMenuA( original, MAKEINTRESOURCEA( id ) );
+	
+	return menu;
+}
+
+HMENU Language::LoadLMenuW(HINSTANCE localised, HINSTANCE original, UINT id)
+{
+	HMENU menu = LoadMenuW(localised, MAKEINTRESOURCEW(id));
+	if (!menu && localised != original)
+		menu = LoadMenuW(original, MAKEINTRESOURCEW(id));
+	return menu;
+}
+
+HACCEL Language::LoadAcceleratorsA(HINSTANCE hinst, HINSTANCE owner, LPCSTR lpTableName)
+{
+	HACCEL hAccel = ::LoadAcceleratorsA(hinst, lpTableName);
+	if (!hAccel && hinst != owner)
+		hAccel = ::LoadAcceleratorsA(owner, lpTableName);
+	return hAccel;
+}
+
+HACCEL Language::LoadAcceleratorsW(HINSTANCE hinst, HINSTANCE owner, LPCWSTR lpTableName)
+{
+	HACCEL hAccel = ::LoadAcceleratorsW(hinst, lpTableName);
+	if (!hAccel && hinst != owner)
+		hAccel = ::LoadAcceleratorsW(owner, lpTableName);
+	return hAccel;
+}
+
+// Implemented in 5.58+
+// when we're loading a language pack we really need to specify if we're
+// going to require correct use of the user's locale setting so that the
+// output of certain text ie '%+6.1f' uses the correct decimal separator
+// ref: http://msdn.microsoft.com/en-us/library/aa246453%28VS.60%29.aspx
+BOOL Language::UseUserNumericLocale(void)
+{
+	wchar_t tmp[4] = {0}, lang[4] = {0}, ctry[4] = {0};
+	GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SISO639LANGNAME, lang, 4);
+	GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SISO3166CTRYNAME, ctry, 4);
+
+	// do this check to ensure that the we only change the locale
+	// if the language pack and the user locale identifiers match
+	if(!_wcsicmp(lang, GetLanguageIdentifier(LANG_LANG_CODE)) &&
+	   !_wcsicmp(ctry, GetLanguageIdentifier(LANG_COUNTRY_CODE)) &&
+	   GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SABBREVLANGNAME, tmp, 4))
+	{
+		_configthreadlocale(_ENABLE_PER_THREAD_LOCALE);
+		// now we set the functions to use the user's numeric locale
+		return !!_wsetlocale(LC_NUMERIC,tmp);
+	}
+	return FALSE;
+}
+
+_locale_t Language::Get_C_NumericLocale(void)
+{
+	__declspec(thread) static _locale_t C_locale;
+	if(!C_locale) C_locale = _create_locale(LC_NUMERIC, "C");
+	return C_locale;
+}
+
+// Implemented in 5.64+
+wchar_t* Language::FormattedSizeString(wchar_t *pszDest, int cchDest, __int64 size)
+{
+	if (!pszDest) return 0;
+	size_t remaining = cchDest;
+	DWORD part = 0;
+	pszDest[0] = 0x00;
+
+	if (size < 1024)
+	{
+		StringCchPrintfExW(pszDest, cchDest, NULL, &remaining, STRSAFE_IGNORE_NULLS,
+						   L"%u %s", (DWORD)(size >> 10) + ((((DWORD)(size))&1023) ? 1: 0),
+						   getStringW(IDS_BYTES, NULL, 0));
+	}
+	else if (size < 1048576)
+	{
+		part = ((((DWORD)(size))&1023)*100) >> 10;
+		if (part > 0)
+		{
+			StringCchPrintfExW(pszDest, cchDest, NULL, &remaining, STRSAFE_IGNORE_NULLS, L"%u.%02u %s",
+							   (DWORD)(size >> 10), part, getStringW(geno ? IDS_KB : IDS_KIB, NULL, 0));
+		}
+		else
+		{
+			StringCchPrintfExW(pszDest, cchDest, NULL, &remaining, STRSAFE_IGNORE_NULLS, L"%u %s",
+							   (DWORD)(size >> 10), getStringW(geno ? IDS_KB : IDS_KIB, NULL, 0));
+		}
+	}
+	else if (size < 1073741824)
+	{
+		part = ((((DWORD)(size >> 10))&1023)*100) >> 10;
+		if (part > 0)
+		{
+			StringCchPrintfExW(pszDest, cchDest, NULL, &remaining, STRSAFE_IGNORE_NULLS, L"%u.%02u %s",
+							   (DWORD)(size >> 20), part, getStringW(geno ? IDS_MB : IDS_MIB, NULL, 0));
+		}
+		else
+		{
+			StringCchPrintfExW(pszDest, cchDest, NULL, &remaining, STRSAFE_IGNORE_NULLS, L"%u %s",
+							   (DWORD)(size >> 20), getStringW(geno ? IDS_MB : IDS_MIB, NULL, 0));
+		}
+	}
+	else if (size < 1099511627776)
+	{
+		part = ((((DWORD)(size >> 20))&1023)*100) >> 10;
+		if (part > 0)
+		{
+			StringCchPrintfExW(pszDest, cchDest, NULL, &remaining, STRSAFE_IGNORE_NULLS, L"%u.%02u %s",
+							   (DWORD)(size >> 30), part, getStringW(geno ? IDS_GB : IDS_GIB, NULL, 0));
+		}
+		else
+		{
+			StringCchPrintfExW(pszDest, cchDest, NULL, &remaining, STRSAFE_IGNORE_NULLS, L"%u %s",
+							   (DWORD)(size >> 30), getStringW(geno ? IDS_GB : IDS_GIB, NULL, 0));
+		}
+	}
+	else
+	{
+		part = ((((DWORD)(size >> 30))&1023)*100) >> 10;
+		if (part > 0)
+		{
+			StringCchPrintfExW(pszDest, cchDest, NULL, &remaining, STRSAFE_IGNORE_NULLS, L"%u.%02u %s",
+							   (DWORD)(size >> 40), part, getStringW(geno ? IDS_TB : IDS_TIB, NULL, 0));
+		}
+		else
+		{
+			StringCchPrintfExW(pszDest, cchDest, NULL, &remaining, STRSAFE_IGNORE_NULLS, L"%u %s",
+							   (DWORD)(size >> 40), getStringW(geno ? IDS_TB : IDS_TIB, NULL, 0));
+		}
+	}
+
+
+	return pszDest;
+}
+
+HMENU LPLoadMenu(UINT id)
+{
+	return langManager->LoadLMenu(language_pack_instance, hMainInstance, id);
+}
+
+
+void Lang_CleanupZip(void)
+{
+	if (!LANGTEMPDIR[0]) return ;
+	if (_cleanupDirW(LANGTEMPDIR))
+	{
+		char str[78] = {0};
+		StringCchPrintfA(str,78,"lang_clean_up%ws",szAppName);
+		_w_s(str, 0);
+	}
+}
+
+
+// attempt to cleanup the last extracted temp folder for a wlz incase Winamp crashed on exit
+void Lang_CleanupAfterCrash(void)
+{
+	wchar_t buf[1024] = {0};
+	char str[78] = {0};
+	StringCchPrintfA(str,78,"lang_clean_up%ws",szAppName);
+	_r_sW(str, buf, sizeof(buf));
+	if (buf[0])
+	{
+		_cleanupDirW(buf);
+		_w_s(str, 0);
+	}
+}
+
+static int load_extra_lng(BOOL force)
+{
+	int is_wlz = 0;
+	if (langManager)
+	{
+		const wchar_t *lang_identifier = langManager->GetLanguageIdentifier(LANG_IDENT_STR);
+		if (lang_identifier || force)
+		{
+			wchar_t extra_lang_path[MAX_PATH] = {0};
+			wchar_t lng_file[MAX_PATH] = {0};
+
+			if (!force)
+				PathCombineW(extra_lang_path, LANGDIR, lang_identifier);
+			else
+				lstrcpynW(extra_lang_path, lang_directory, MAX_PATH);
+
+			PathCombineW(lng_file, extra_lang_path, L"*.lng");
+			WIN32_FIND_DATAW find_data = {0};
+			HANDLE h = FindFirstFileW(lng_file, &find_data);
+
+			if (h != INVALID_HANDLE_VALUE)
+			{
+				do
+				{
+					PathCombineW(lng_file, extra_lang_path, find_data.cFileName);
+					is_wlz = 1;
+					winampLangStruct* templng = reinterpret_cast<winampLangStruct*>(calloc(1, sizeof(winampLangStruct)));
+					templng->module = _wcsdup(lng_file);
+
+					bool exception = (!lstrcmpiW(templng->module, L"omBrowser.lng") || !lstrcmpiW(templng->module, L"ml_online.lng"));
+
+					// the plain LoadLibrary(..) generally works though as we only want to
+					// load the lng files for resources (and that some people's lng files
+					// can generally end up being corrupted after a few edits), we instead
+					// try to load as an image / data file (so doesn't re-map things, etc)
+					templng->hDllInstance = LoadLibraryExW(lng_file, NULL, (!exception ? LOAD_LIBRARY_AS_IMAGE_RESOURCE | LOAD_LIBRARY_AS_DATAFILE : 0));
+					// incase of running on an older OS, try it as a plain LoadLibrary(..)
+					if (!templng->hDllInstance) templng->hDllInstance = LoadLibraryW(lng_file);
+					if (templng->hDllInstance)
+					{
+						wchar_t s[39] = {0};
+						if(LoadStringW(templng->hDllInstance, LANG_DLL_GUID_STRING_ID, s, 39))
+						{
+							templng->external = 1;
+							templng->guidstr = _wcsdup(s);
+							GetImageHashData(templng->hDllInstance);
+						}
+						// only keep if it's a valid lng dll ie doesn't have load issues
+						lnglist.push_back(templng);
+					}
+				}
+				while (FindNextFileW(h, &find_data));
+				FindClose(h);
+			}
+		}
+	}
+	return is_wlz;
+}
+
+
+// return 1 if we're working from a wlz otherwise return 0
+int extract_wlz_to_dir(wchar_t* readme_only_wlz_extraction, BOOL *skip)
+{
+	int is_wlz = 0;
+	if (config_langpack[0] || readme_only_wlz_extraction && readme_only_wlz_extraction[0])
+	{
+		wchar_t* langpack = (readme_only_wlz_extraction?readme_only_wlz_extraction:config_langpack),
+				 tempdirbuf[MAX_PATH] = {0}, *TEMPDIR = LANGTEMPDIR;
+
+		if (_wcsicmp(extensionW(langpack), L"zip") && _wcsicmp(extensionW(langpack), L"wlz"))
+		{
+			if (PathIsFileSpecW(langpack) || PathIsRelativeW(langpack))
+				PathCombineW(lang_directory, LANGDIR, langpack);
+			else 
+				StringCchCopyW(lang_directory, MAX_PATH, langpack);
+
+			is_wlz = load_extra_lng(TRUE);
+			if (skip) *skip = is_wlz;
+		}
+		else
+		{
+			wchar_t dirmask[MAX_PATH*4] = {0};
+			char str[78] = {0};
+			unzFile f = {0};
+
+			// make sure that we use a different folder from the current wlz temp folder otherwise we have issues
+			if(readme_only_wlz_extraction){
+				wchar_t buf[MAX_PATH] = {0};
+				GetTempPathW(MAX_PATH, buf);
+				GetTempFileNameW(buf, L"WLZ", GetTickCount(), tempdirbuf);
+				TEMPDIR = tempdirbuf;
+			}
+
+			CreateDirectoryW(TEMPDIR, NULL);
+			StringCchPrintfA(str,78,"lang_clean_up%ws",szAppName);
+			if(!readme_only_wlz_extraction){
+				StringCchCopyW(lang_directory, MAX_PATH, TEMPDIR);
+				_w_sW(str, TEMPDIR);
+			}
+
+			if (PathIsFileSpecW(langpack)|| PathIsRelativeW(langpack))
+				PathCombineW(dirmask, LANGDIR, langpack);
+			else
+				StringCchCopyW(dirmask, MAX_PATH*4, langpack);
+
+			// now we're going to extract, if doing a temp extraction then set the path into the passed buffer
+			if(readme_only_wlz_extraction){
+				StringCchCopyW(readme_only_wlz_extraction, MAX_PATH, TEMPDIR);
+			}
+
+			f = unzOpen(AutoCharFn(dirmask));
+			if (f)
+			{
+				if (unzGoToFirstFile(f) == UNZ_OK)
+				{
+					OVERLAPPED asyncIO = {0};
+					int isNT = (GetVersion() < 0x80000000);
+					if (isNT)
+					{
+						asyncIO.hEvent = CreateEvent(NULL, FALSE, TRUE, NULL);
+						asyncIO.OffsetHigh = 0;
+					}
+					do
+					{
+						char filename[MAX_PATH] = {0}, *fn = 0, *p = 0;
+						if (isNT)
+							SetEvent(asyncIO.hEvent);
+						unzGetCurrentFileInfo(f, NULL, filename, sizeof(filename), NULL, 0, NULL, 0);
+
+						//Only extract the file-types that could be in a skin
+						//If we don't filter here it's a security hole
+
+						// expand out folders if we've got a freeform based folder
+						if(!_strnicmp(filename,"freeform\\",9) || !_strnicmp(filename,"freeform/",9))
+							fn = filename;
+						// otherwise just extract to the root of the temp directory
+						else
+							fn = scanstr_back(filename, "\\/", filename - 1) + 1;
+
+						p = extension(fn);
+						// TODO: really should enum image loaders so we only extract supported image files
+						if (!_stricmp(p, "lng") || !_stricmp(p, "ini") || !_stricmp(p, "txt") ||
+							!_stricmp(p, "png") || !_stricmp(p, "bmp") || !_stricmp(p, "gif") ||
+							!_stricmp(p, "jpg") || !_stricmp(p, "xml") || !_stricmp(p, "htm") ||
+							// not too keen on dll in there but that's how the GN dlls are named
+							!_stricmp(p, "dll"))
+						{
+							if (unzOpenCurrentFile(f) == UNZ_OK)
+							{
+								PathCombineW(dirmask, TEMPDIR, AutoWide(fn));
+								CreateDirectoryForFileW(dirmask, TEMPDIR);
+
+								HANDLE fp = CreateFileW(dirmask, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL | (isNT ? FILE_FLAG_OVERLAPPED : 0), NULL);
+								if (fp != INVALID_HANDLE_VALUE)
+								{
+									int l = 0, pos = 0, bufNum=0;
+
+									#define LANG_ZIP_BUFFER_SIZE 2048
+									char buf[LANG_ZIP_BUFFER_SIZE*2] = {0};
+									int success = 1;
+									do
+									{
+										DWORD written = 0;
+										bufNum = !bufNum;
+										l = unzReadCurrentFile(f, buf+LANG_ZIP_BUFFER_SIZE*bufNum, LANG_ZIP_BUFFER_SIZE);
+										if (!l)
+											unzCloseCurrentFile(f);
+										if (isNT)
+										{
+											WaitForSingleObject(asyncIO.hEvent, INFINITE);
+											if (l > 0)
+											{
+												asyncIO.Offset = pos;
+												if (WriteFile(fp, buf+LANG_ZIP_BUFFER_SIZE*bufNum, l, NULL, &asyncIO) == FALSE
+													&& GetLastError() != ERROR_IO_PENDING)
+												{
+													success=0;
+												}
+												pos += l;
+											}
+										}
+										else
+										{
+											if (l > 0)
+											{
+												if (WriteFile(fp, buf+LANG_ZIP_BUFFER_SIZE*bufNum, l, &written, NULL) == FALSE)
+													success = 0;
+											}
+										}
+									} while (l > 0 && success);
+
+									CloseHandle(fp);
+
+									// cache information about the extracted lng files
+									if(!_stricmp(p, "lng") && !readme_only_wlz_extraction)
+									{
+										is_wlz = 1;
+										winampLangStruct* templng = reinterpret_cast<winampLangStruct*>(calloc(1, sizeof(winampLangStruct)));
+										templng->module = AutoWideDup(filename);
+
+										bool exception = (!lstrcmpiW(templng->module, L"omBrowser.lng") || !lstrcmpiW(templng->module, L"ml_online.lng"));
+
+										// the plain LoadLibrary(..) generally works though as we only want to
+										// load the lng files for resources (and that some people's lng files
+										// can generally end up being corrupted after a few edits), we instead
+										// try to load as an image / data file (so doesn't re-map things, etc)
+										templng->hDllInstance = LoadLibraryExW(dirmask, NULL, (!exception ? LOAD_LIBRARY_AS_IMAGE_RESOURCE | LOAD_LIBRARY_AS_DATAFILE : 0));
+										if (!templng->hDllInstance) templng->hDllInstance = LoadLibraryW(dirmask);
+										if (templng->hDllInstance)
+										{
+											wchar_t s[39] = {0};
+											if(LoadStringW(templng->hDllInstance, LANG_DLL_GUID_STRING_ID, s, 39))
+											{
+												templng->guidstr = _wcsdup(s);
+												GetImageHashData(templng->hDllInstance);
+											}
+											// only keep if it's a valid lng dll ie doesn't have load issues
+											lnglist.push_back(templng);
+										}
+									}
+								}
+							}
+						}
+					}
+					while (unzGoToNextFile(f) == UNZ_OK);
+					if (isNT && asyncIO.hEvent)
+					{
+						CloseHandle(asyncIO.hEvent);
+					}
+				} 
+				unzClose(f);
+			}
+		}
+	}
+	else lang_directory[0] = 0;
+
+	return is_wlz;
+}
+
+
+HINSTANCE Language::FindDllHandleByGUID(const GUID guid)
+{
+	wchar_t gs[40] = {0};
+	getGUIDstr(guid,gs);
+
+	for ( winampLangStruct *l_lng : lnglist )
+	{
+		if( l_lng->guidstr && *l_lng->guidstr && !_wcsnicmp(gs, l_lng->guidstr, 38))
+			return l_lng->hDllInstance;
+	}
+
+	return NULL;
+}
+
+
+HINSTANCE Language::FindDllHandleByString(const char* _str)
+{
+	AutoWide str__(_str);
+	const wchar_t *str = str__;
+	if(str && *str)
+	{
+		for ( winampLangStruct *l_lng : lnglist )
+		{
+			if ( l_lng->module && *l_lng->module && !_wcsnicmp( l_lng->module, str, lstrlenW( str ) ) )
+				return l_lng->hDllInstance;
+		}
+	}
+	return NULL;
+}
+
+
+HINSTANCE Language::FindDllHandleByStringW(const wchar_t* _str)
+{
+	AutoChar str__(_str);
+	const wchar_t *str = _str;
+	if(str && *str)
+	{
+		for ( winampLangStruct *l_lng : lnglist )
+		{
+			if( l_lng->module && *l_lng->module && !_wcsnicmp( l_lng->module, str, lstrlenW(str)))
+				return l_lng->hDllInstance;
+		}
+	}
+	return NULL;
+}
+
+
+HINSTANCE Lang_InitLangSupport(HINSTANCE hinst, const GUID guid)
+{
+	geno = _r_i("geno", 1);
+	started = 1;
+	return langManager->StartLanguageSupport(hinst, guid);
+}
+
+
+void Lang_FollowUserDecimalLocale(void)
+{
+	langManager->UseUserNumericLocale();
+}
+
+
+// use this to load based on the module specified so that we make sure
+// we've got the correct hinstance based on lng file or default handle
+HINSTANCE Language::StartLanguageSupport(HINSTANCE hinstance, const GUID guid)
+{
+	if (!g_safeMode)
+	{
+		HWND agent = FindWindowW(L"WinampAgentMain", NULL);
+		wchar_t winampaLngPath[MAX_PATH] = {0};
+		int is_wlz = 0;
+
+		// if we find Winamp Agent running then we need to tell it
+		// to unload it's winampa.lng for what we're about to do..
+		if (IsWindow(agent) && !already_extracted)
+		{
+			SendMessageW(agent, WM_USER + 16, 1, 0);
+		}
+
+		// always remove winampa.lng just incase we crashed and it leaves things out of synch
+		if(!already_extracted){
+			StringCchPrintfW(winampaLngPath, MAX_PATH, L"%s\\winampa.lng", CONFIGDIR);
+			DeleteFileW(winampaLngPath);
+		}
+
+		config_load_langpack_var();
+		if(!already_extracted)
+		{
+			BOOL skip = FALSE;
+			already_extracted = 1;
+			prev_wlz_ex_state = is_wlz = extract_wlz_to_dir(0, &skip);
+			if (!skip) load_extra_lng(FALSE);
+			else LANGTEMPDIR[0] = 0;
+		}
+		else
+		{
+			is_wlz = prev_wlz_ex_state;
+			agent = 0;
+		}
+
+		// make sure that we don't try and load the exe/dll being localised as the lng dll
+		wchar_t modulename[MAX_PATH] = {0}, *p = 0;
+		GetModuleFileNameW(hinstance, modulename, MAX_PATH);
+		p = scanstr_backW(modulename, L"\\/", NULL);
+		if(p) p = CharNextW(p);
+
+		// if is_wlz != 0 then we can attempt to use the wlz extracted files otherwise
+		// (for the time being) we drop back to the older lng pack system
+		// either way we still need to make sure that what we're using is valid
+		if (config_langpack[0] && is_wlz)
+		{
+			HMODULE h = langManager->FindDllHandleByGUID(guid);
+			if(!h)	// possible fallback usage if things failed to work on guid look up
+			{		// though wouldn't be reliable if people change the lng file names
+				wchar_t tmpfile[MAX_PATH], *t = 0;
+				lstrcpynW(tmpfile,p,MAX_PATH);
+				t = scanstr_backW(tmpfile, L".", NULL);
+				lstrcpynW(t,L".lng",MAX_PATH);
+				h = langManager->FindDllHandleByStringW(tmpfile);
+			}
+
+			if (h)
+			{
+				// if the wlz was able to be loaded (as we believe at this point)
+				// then we see if Winamp Agent is running and tell it to refresh
+				// it's version of winampa.lng once we've copied into %inidir%
+				if (IsWindow(agent))
+				{
+					// copy from the wlz folder to the settings folder
+					wchar_t winampaWlzPath[MAX_PATH] = {0};
+					StringCchPrintfW(winampaWlzPath, MAX_PATH, L"%s\\winampa.lng", lang_directory);
+					CopyFileW(winampaWlzPath,winampaLngPath,FALSE);
+					SendMessageW(agent, WM_USER + 16, 0, 0);
+				}
+
+				// if we get here then we've managed to load the language pack
+				// (still could be invalid but that's generally from failed dll files)
+				return h;
+			}
+		}
+	}
+
+	// make sure we return the passed hinstance incase of failure to load/invalid lng file/etc
+	return hinstance;
+}
+
+
+void Lang_EndLangSupport(void)
+{
+	started = 0;
+
+	// need to fully clean up things here including unloading of the langpack
+	HINSTANCE old_language_pack_instance = language_pack_instance;
+	if(language_pack_instance != hMainInstance)
+	{
+		FreeLibrary(language_pack_instance);
+		language_pack_instance = hMainInstance;
+	}
+
+	for ( winampLangStruct *l_lng : lnglist )
+	{
+		if( l_lng->module)
+		{
+			free( l_lng->module);
+			l_lng->module = 0;
+		}
+
+		if( l_lng->guidstr)
+		{
+			free( l_lng->guidstr);
+			l_lng->guidstr = 0;
+		}
+
+		// this check is to prevent trying to re-free the winamp.lng (as it's done earlier)
+		// as well as anything which is not in the temp folder to avoid any unloading issues
+		if ( !l_lng->external && l_lng->hDllInstance && ( l_lng->hDllInstance != old_language_pack_instance ) )
+		{
+			FreeLibrary( l_lng->hDllInstance );
+			l_lng->hDllInstance = 0;
+		}
+	}
+
+	lnglist.clear();
+	prev_wlz_ex_state = already_extracted = 0;
+}
+
+
+HINSTANCE Lang_FakeWinampLangHInst(HINSTANCE adjustedHInst){
+	HINSTANCE previousHInst = language_pack_instance;
+	language_pack_instance = adjustedHInst;
+	started = !!adjustedHInst;
+	return previousHInst;
+}
+
+
+void Lang_LocaliseAgentOnTheFly(BOOL refresh){
+	// if we need to refresh then attempt to use the winampa.lng from the
+	// current language pack if one is present and has been extracted so
+	// we test to see if we've extracted a language pack already
+	if(already_extracted){
+	HWND agent = FindWindowW(L"WinampAgentMain", NULL);
+	wchar_t winampaLngPath[MAX_PATH] = {0};
+
+		// if we find Winamp Agent running then we need to tell it
+		// to unload it's winampa.lng for what we're about to do...
+		// although this is likely to be a new load, doing this will
+		// help to ensure that things are unloaded incase of issues
+		if(IsWindow(agent)){
+			SendMessageW(agent, WM_USER + 16, 1, 0);
+		}
+
+		// always remove winampa.lng just incase we crashed and it leaves things out of synch
+		StringCchPrintfW(winampaLngPath, MAX_PATH, L"%s\\winampa.lng", CONFIGDIR);
+		DeleteFileW(winampaLngPath);
+
+		if(refresh){
+		wchar_t winampaWlzPath[MAX_PATH] = {0};
+			StringCchPrintfW(winampaWlzPath, MAX_PATH, L"%s\\winampa.lng", lang_directory);
+			CopyFileW(winampaWlzPath,winampaLngPath,FALSE);
+			SendMessageW(agent, WM_USER + 16, 0, 0);
+		}
+	}
+}
+
+
+#ifdef CBCLASS
+#undef CBCLASS
+#endif
+
+#define CBCLASS Language
+START_DISPATCH;
+CB( API_LANGUAGE_GETSTRING,             GetString )
+CB( API_LANGUAGE_GETSTRINGW,            GetStringW )
+CB( API_LANGUAGE_GETSTRINGFROMGUID,     GetStringFromGUID )
+CB( API_LANGUAGE_GETSTRINGFROMGUIDW,    GetStringFromGUIDW )
+CB( API_LANGUAGE_GETHINSTANCEBYGUID,    FindDllHandleByGUID )
+CB( API_LANGUAGE_GETHINSTANCEBYNAME,    FindDllHandleByString )
+CB( API_LANGUAGE_GETHINSTANCEBYNAMEW,   FindDllHandleByStringW )
+CB( API_LANGUAGE_STARTUP,               StartLanguageSupport )
+CB( API_LANGUAGE_GETLANGUAGEFOLDER,     GetLanguageFolder )
+CB( API_LANGUAGE_CREATELDIALOGPARAM,    CreateLDialogParam )
+CB( API_LANGUAGE_LDIALOGBOXPARAM,       LDialogBoxParam )
+CB( API_LANGUAGE_LOADLMENU,             LoadLMenu )
+CB( API_LANGUAGE_CREATELDIALOGPARAMW,   CreateLDialogParamW )
+CB( API_LANGUAGE_LDIALOGBOXPARAMW,      LDialogBoxParamW )
+CB( API_LANGUAGE_LOADLMENUW,            LoadLMenuW )
+CB( API_LANGUAGE_GETLANGUAGEIDENTIFIER, GetLanguageIdentifier )
+CB( API_LANGUAGE_LOADRESOURCEFROMFILEA, LoadResourceFromFile )
+CB( API_LANGUAGE_LOADRESOURCEFROMFILEW, LoadResourceFromFileW )
+CB( API_LANGUAGE_LOADACCELERATORSA,     LoadAcceleratorsA )
+CB( API_LANGUAGE_LOADACCELERATORSW,     LoadAcceleratorsW )
+CB( API_LANGUAGE_USEUSERNUMERICLOCALE,  UseUserNumericLocale )
+CB( API_LANGUAGE_GET_C_NUMERICLOCALE,   Get_C_NumericLocale )
+CB( API_LANGUAGE_FORMATTEDSIZESTRING,   FormattedSizeString )
+END_DISPATCH
\ No newline at end of file