path: root/Src/Winamp/lang.cpp

/** (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