Updated unicode/ansi/utf8 macros - fixed issue with only having cf_text set if there is an on copy script

Addins/DittoUtil/PasteImageAsHtmlImage.cpp

@@ -94,8 +94,7 @@ bool CPasteImageAsHtmlImage::ConvertPathToHtmlImageTag(const CDittoInfo &DittoIn
 		if(csIMG.IsEmpty() == FALSE)
 		{
 			pFormats->DeleteAll();
-			CStringA utf8;
-			CTextConvert::ConvertToUTF8(csIMG, utf8);
+			CStringA utf8 = CTextConvert::UnicodeToUTF8(csIMG);
 			pFormats->AddNew(DittoAddinHelpers::GetFormatID(_T("HTML Format")), DittoAddinHelpers::NewGlobalP(utf8.GetBuffer(), utf8.GetLength()));
 			bRet = true;
 		}

Addins/DittoUtil/ReadOnlyFlag.cpp

@@ -126,7 +126,7 @@ bool CReadOnlyFlag::LoadTextFiles(CStringArray &lines, IClipFormats *pFormats)
 		if(stringData != NULL)
 		{
 			CStringA string(stringData);
-			CStringW unicodeString(CTextConvert::MultiByteToUnicodeString(string));
+			CStringW unicodeString(CTextConvert::AnsiToUnicode(string));
 			CString delim(_T("\r\n"));
 
 			CTokenizer token(unicodeString, delim);

ChaiScriptOnCopy.cpp

@@ -75,14 +75,14 @@ bool ChaiScriptOnCopy::ProcessScript(CDittoChaiScript &clipData, std::string scr
 		std::string eString;
 		eString += ee.pretty_print();
 
-		m_lastError = CTextConvert::MultiByteToUnicodeString(eString.c_str());
+		m_lastError = CTextConvert::AnsiToUnicode(eString.c_str());
 	}
 	catch (std::exception &e)
 	{
 		std::string eString;
 		eString += e.what();
 
-		m_lastError = CTextConvert::MultiByteToUnicodeString(eString.c_str());
+		m_lastError = CTextConvert::AnsiToUnicode(eString.c_str());
 	}
 	catch (CException *ex)
 	{

ChaiScriptXml.cpp

@@ -38,8 +38,7 @@ void CChaiScriptXml::Load(CString values)
 	m_list.clear();
 	
 	TiXmlDocument doc;
-	CStringA xmlA;
-	CTextConvert::ConvertToUTF8(values, xmlA);
+	CStringA xmlA = CTextConvert::UnicodeToUTF8(values);
 	doc.Parse(xmlA);
 
 	TiXmlElement *ItemHeader = doc.FirstChildElement("ChaiScripts");
@@ -85,24 +84,19 @@ CString CChaiScriptXml::Save()
 
 		friendElement->SetAttribute("active", listItem.m_active);
 
-		CStringA name;
-		CTextConvert::ConvertToUTF8(listItem.m_name, name);
+		CStringA name = CTextConvert::UnicodeToUTF8(listItem.m_name);
 		friendElement->SetAttribute("name", name);
 
-		CStringA desc;
-		CTextConvert::ConvertToUTF8(listItem.m_description, desc);
+		CStringA desc = CTextConvert::UnicodeToUTF8(listItem.m_description);
 		friendElement->SetAttribute("description", desc);
 
-		CStringA script;
-		CTextConvert::ConvertToUTF8(listItem.m_script, script);
+		CStringA script = CTextConvert::UnicodeToUTF8(listItem.m_script);
 		friendElement->SetAttribute("script", script);
 
-		CStringA guid;
-		CTextConvert::ConvertToUTF8(listItem.m_guid, guid);
+		CStringA guid = CTextConvert::UnicodeToUTF8(listItem.m_guid);
 		friendElement->SetAttribute("guid", guid);
 
-		CStringA version;
-		CTextConvert::ConvertToUTF8(listItem.m_version, version);
+		CStringA version = CTextConvert::UnicodeToUTF8(listItem.m_version);
 		friendElement->SetAttribute("version", version);
 
 		friendOuter->LinkEndChild(friendElement);

Client.cpp

@@ -155,7 +155,7 @@ BOOL CClient::OpenConnection(const TCHAR* servername)
 		pos++;
 	}
 
-	CStringA csServerNameA = CTextConvert::ConvertToChar(parsedServerName);
+	CStringA csServerNameA = CTextConvert::UnicodeToAnsi(parsedServerName);
 
 	//11-5-06 Serge Baranov found that if we are passing in an ip then
 	//don't look the name up using gethostbyname/gethostbyaddr->
@@ -208,21 +208,15 @@ BOOL CClient::SendItem(CClip *pClip, bool manualSend)
 	}
 
 	//Send all text over as UTF-8
-	CStringA dest;
-	if(CTextConvert::ConvertToUTF8(GetComputerName(), dest))
-	{
-		strncpy(Info.m_cComputerName, dest, sizeof(Info.m_cComputerName));
-	}
-
-	if(CTextConvert::ConvertToUTF8(GetIPAddress(), dest))
-	{
-		strncpy(Info.m_cIP, dest, sizeof(Info.m_cIP));	
-	}
-
-	if(CTextConvert::ConvertToUTF8(pClip->m_Desc, dest))
-	{
-		strncpy(Info.m_cDesc, dest, sizeof(Info.m_cDesc));
-	}
+	CStringA dest = CTextConvert::UnicodeToUTF8(GetComputerName());
+	strncpy(Info.m_cComputerName, dest, sizeof(Info.m_cComputerName));
+	
+	dest = CTextConvert::UnicodeToUTF8(GetIPAddress());
+	strncpy(Info.m_cIP, dest, sizeof(Info.m_cIP));	
+	
+	dest = CTextConvert::UnicodeToUTF8(pClip->m_Desc);
+	strncpy(Info.m_cDesc, dest, sizeof(Info.m_cDesc));
+	
 	
 	Info.m_cDesc[sizeof(Info.m_cDesc)-1] = 0;
 	Info.m_cComputerName[sizeof(Info.m_cComputerName)-1] = 0;
@@ -274,13 +268,10 @@ BOOL CClient::SendClipFormat(CClipFormat* pCF)
 			Info.m_lParameter1 = nLenOutput;
 
 			//Send over as UTF-8
-			CStringA dest;
-			if(CTextConvert::ConvertToUTF8(GetFormatName(pCF->m_cfType), dest))
-			{
-				strncpy(Info.m_cDesc, dest, sizeof(Info.m_cDesc));
-				Info.m_cDesc[sizeof(Info.m_cDesc)-1] = 0;
-			}
-
+			CStringA dest = CTextConvert::UnicodeToUTF8(GetFormatName(pCF->m_cfType));
+			strncpy(Info.m_cDesc, dest, sizeof(Info.m_cDesc));
+			Info.m_cDesc[sizeof(Info.m_cDesc)-1] = 0;
+			
 			if(m_SendSocket.SendCSendData(Info, MyEnums::DATA_START) == FALSE)
 				return FALSE;
 

Clip.cpp

@@ -576,8 +576,8 @@ int CClip::LoadFromClipboard(CClipTypes* pClipTypes, bool checkClipboardIgnore,
 				Log(StrF(_T("Start of process copy name: %s, script: %s"), listItem.m_name, listItem.m_script));
 
 				ChaiScriptOnCopy onCopy;
-				CDittoChaiScript clipData(this, (LPCSTR)CTextConvert::ConvertToChar(activeApp), (LPCSTR)CTextConvert::ConvertToChar(activeAppTitle));
-				if (onCopy.ProcessScript(clipData, (LPCSTR)CTextConvert::ConvertToChar(listItem.m_script)) == false)
+				CDittoChaiScript clipData(this, (LPCSTR)CTextConvert::UnicodeToAnsi(activeApp), (LPCSTR)CTextConvert::UnicodeToAnsi(activeAppTitle));
+				if (onCopy.ProcessScript(clipData, (LPCSTR)CTextConvert::UnicodeToAnsi(listItem.m_script)) == false)
 				{
 					Log(StrF(_T("End of process copy name: %s, returned false, not saving this copy to Ditto, last Error: %s"), listItem.m_name, onCopy.m_lastError));
 
@@ -625,13 +625,20 @@ int CClip::LoadFromClipboard(CClipTypes* pClipTypes, bool checkClipboardIgnore,
 		else
 		{
 			auto aString = this->GetCFTextTextFormat();
-			if (aString.GetLength() > g_Opt.m_bDescTextSize)
+			if (aString != "")
 			{
-				m_Desc = aString.Left(g_Opt.m_bDescTextSize);
+				if (aString.GetLength() > g_Opt.m_bDescTextSize)
+				{
+					m_Desc = aString.Left(g_Opt.m_bDescTextSize);
+				}
+				else
+				{
+					m_Desc = aString;
+				}
 			}
 			else
 			{
-				m_Desc = aString;
+				SetDescFromType();
 			}
 		}
 
@@ -1771,8 +1778,7 @@ BOOL CClip::WriteTextToFile(CString path, BOOL unicode, BOOL asci, BOOL utf8)
 		
 		if(utf8 && w != _T(""))
 		{
-			CStringA convToUtf8;
-			CTextConvert::ConvertToUTF8(w, convToUtf8);
+			CStringA convToUtf8 = CTextConvert::UnicodeToUTF8(w);
 			std::byte header[2];
 			header[0] = (std::byte)0xEF;
 			header[1] = (std::byte)0xBB;
@@ -1967,8 +1973,7 @@ bool CClip::AddFileDataToData(CString &errorMessage)
 					if (fileSize < maxSize)
 					{
 						CString src(filePath);
-						CStringA csFilePath;
-						CTextConvert::ConvertToUTF8(src, csFilePath);
+						CStringA csFilePath = CTextConvert::UnicodeToUTF8(src);
 						
 						int bufferSize = (int)fileSize + csFilePath.GetLength() + 1 + md5StringLength + 1;;
 						char *pBuffer = new char[bufferSize];

ClipIds.cpp

@@ -25,8 +25,8 @@ HGLOBAL CClipIDs::Render(UINT cfType)
 		return CClip::LoadFormat(ElementAt(0), cfType);
 	}
 
-	CStringA SepA = CTextConvert::ConvertToChar(g_Opt.GetMultiPasteSeparator());
-	CStringW SepW = CTextConvert::ConvertToUnicode(g_Opt.GetMultiPasteSeparator());
+	CStringA SepA = CTextConvert::UnicodeToAnsi(g_Opt.GetMultiPasteSeparator());
+	CStringW SepW = g_Opt.GetMultiPasteSeparator();
 
 	if(cfType == CF_TEXT)
 	{

CopyProperties.cpp

@@ -570,7 +570,7 @@ void CCopyProperties::OnLbnSelchangeCopyData()
 
 								CStringA md5String = md5.MD5FinalToString();
 
-								this->SetDlgItemText(IDC_EDIT_MD5, CTextConvert::MultiByteToUnicodeString(md5String));
+								this->SetDlgItemText(IDC_EDIT_MD5, CTextConvert::AnsiToUnicode(md5String));
 							}
 						}
 					}

CreateQRCodeImage.cpp

@@ -29,8 +29,7 @@ unsigned char* CCreateQRCodeImage::CreateImage(CString text, int &size)
 	unsigned char* bitmapData = NULL;
 
 
-	CStringA a;
-	CTextConvert::ConvertToUTF8(text, a);
+	CStringA a = CTextConvert::UnicodeToUTF8(text);
 	if (pQRC = QRcode_encodeString(a, 0, QR_ECLEVEL_H, QR_MODE_8, 1))
 	{
 		unWidth = pQRC->width;

CustomFriendsHelper.cpp

@@ -21,8 +21,7 @@ void CCustomFriendsHelper::Load()
 	CString oldValues = CGetSetOptions::GetCustomSendToList();
 
 	TiXmlDocument doc;
-	CStringA xmlA;
-	CTextConvert::ConvertToUTF8(oldValues, xmlA);
+	CStringA xmlA = CTextConvert::UnicodeToUTF8(oldValues);
 	doc.Parse(xmlA);
 
 	TiXmlElement *ItemHeader = doc.FirstChildElement("CustomFriends");
@@ -65,12 +64,10 @@ void CCustomFriendsHelper::Save()
 	{
 		TiXmlElement* friendElement = new TiXmlElement("Friend");
 
-		CStringA nameA;
-		CTextConvert::ConvertToUTF8(listItem.m_name, nameA);
+		CStringA nameA = CTextConvert::UnicodeToUTF8(listItem.m_name);
 		friendElement->SetAttribute("name",  nameA);
 
-		CStringA descA;
-		CTextConvert::ConvertToUTF8(listItem.m_desc, descA);
+		CStringA descA = CTextConvert::UnicodeToUTF8(listItem.m_desc);
 		friendElement->SetAttribute("desc", descA);
 
 		friendOuter->LinkEndChild(friendElement);

DatabaseUtilities.cpp

@@ -515,7 +515,7 @@ BOOL BackupDB(CString dbPath, CString backupPath)
 			char *pBuffer = new char[65536];
 			if(pBuffer != NULL)
 			{
-				gzFile f = gzopen(CTextConvert::ConvertToChar(backupPath), "w");
+				gzFile f = gzopen(CTextConvert::UnicodeToAnsi(backupPath), "w");
 				
 				if(f != NULL)
 				{
@@ -592,7 +592,7 @@ BOOL RestoreDB(CString backupPath)
 
 	try
 	{
-		gzFile f = gzopen(CTextConvert::ConvertToChar(backupPath), "r");
+		gzFile f = gzopen(CTextConvert::UnicodeToAnsi(backupPath), "r");
 		if (f != NULL)
 		{
 			CFile file;

DittoAddin.cpp

@@ -80,7 +80,7 @@ bool CDittoAddin::SupportedFunctions(const CDittoInfo &DittoInfo, FunctionType t
 			for(int i = 0; i < nCount; i++)
 			{
 				CFunction func = Functions[i];
-				Log(StrF(_T("Ditto Addin - Supported Function Display: %s, Function: %s, Desc: %s"), func.m_csDisplayName, CTextConvert::MultiByteToUnicodeString(func.m_csFunction), func.m_csDetailDescription));
+				Log(StrF(_T("Ditto Addin - Supported Function Display: %s, Function: %s, Desc: %s"), func.m_csDisplayName, CTextConvert::AnsiToUnicode(func.m_csFunction), func.m_csDetailDescription));
 			}
 		}
 		else

DittoChaiScript.cpp

@@ -20,13 +20,44 @@ CDittoChaiScript::~CDittoChaiScript()
 {
 }
 
+std::wstring CDittoChaiScript::GetUnicodeString()
+{
+	std::wstring s = _T("");
+	if (m_pClip)
+	{
+		IClipFormat* pFormat = m_pClip->Clips()->FindFormatEx(CF_UNICODETEXT);
+		if (pFormat)
+		{
+			s = pFormat->GetAsCString();
+		}
+		else
+		{
+			s = CTextConvert::AnsiToUnicode(GetAsciiString().c_str());
+		}
+	}
+
+	return s;
+}
+
+void CDittoChaiScript::SetUnicodeString(std::wstring stringVal)
+{
+	if (m_pClip)
+	{
+		m_pClip->Clips()->DeleteAll();
+
+		HGLOBAL hGlobal = ::NewGlobalP((LPVOID)stringVal.c_str(), (stringVal.size() + 1) * 2);
+		ASSERT(hGlobal);
+
+		m_pClip->Clips()->AddNew(CF_UNICODETEXT, hGlobal);
+	}
+}
 
 std::string CDittoChaiScript::GetAsciiString()
 {
 	std::string s = "";
 	if (m_pClip)
 	{
-		IClipFormat *pFormat = m_pClip->Clips()->FindFormatEx(CF_TEXT);
+		IClipFormat* pFormat = m_pClip->Clips()->FindFormatEx(CF_TEXT);
 		if (pFormat)
 		{
 			s = pFormat->GetAsCStringA();
@@ -49,6 +80,8 @@ void CDittoChaiScript::SetAsciiString(std::string stringVal)
 	}
 }
 
+
+
 std::string CDittoChaiScript::GetClipMD5(std::string clipboardFormat)
 {
 	CMd5 md5;
@@ -58,7 +91,7 @@ std::string CDittoChaiScript::GetClipMD5(std::string clipboardFormat)
 
 	if (m_pClip)
 	{
-		int formatId = GetFormatID(CTextConvert::MultiByteToUnicodeString(clipboardFormat.c_str()));
+		int formatId = GetFormatID(CTextConvert::AnsiToUnicode(clipboardFormat.c_str()));
 
 		IClipFormat *pFormat = m_pClip->Clips()->FindFormatEx(formatId);
 		if (pFormat)
@@ -84,7 +117,7 @@ SIZE_T CDittoChaiScript::GetClipSize(std::string clipboardFormat)
 	SIZE_T size = 0;
 	if (m_pClip)
 	{
-		int formatId = GetFormatID(CTextConvert::MultiByteToUnicodeString(clipboardFormat.c_str()));
+		int formatId = GetFormatID(CTextConvert::AnsiToUnicode(clipboardFormat.c_str()));
 
 		IClipFormat *pFormat = m_pClip->Clips()->FindFormatEx(formatId);
 		if (pFormat)
@@ -101,7 +134,7 @@ BOOL CDittoChaiScript::FormatExists(std::string clipboardFormat)
 	BOOL exists = FALSE;
 	if (m_pClip)
 	{
-		int formatId = GetFormatID(CTextConvert::MultiByteToUnicodeString(clipboardFormat.c_str()));
+		int formatId = GetFormatID(CTextConvert::AnsiToUnicode(clipboardFormat.c_str()));
 
 		IClipFormat *pFormat = m_pClip->Clips()->FindFormatEx(formatId);
 		if (pFormat)
@@ -118,7 +151,7 @@ BOOL CDittoChaiScript::RemoveFormat(std::string clipboardFormat)
 	BOOL removed = FALSE;
 	if (m_pClip)
 	{
-		int formatId = GetFormatID(CTextConvert::MultiByteToUnicodeString(clipboardFormat.c_str()));
+		int formatId = GetFormatID(CTextConvert::AnsiToUnicode(clipboardFormat.c_str()));
 
 		if (m_pClip->Clips()->RemoveFormat(formatId))
 		{
@@ -148,8 +181,8 @@ BOOL CDittoChaiScript::AsciiTextMatchesRegex(std::string regex)
 {
 	BOOL matches = false;
 
-	auto ascii = GetAsciiString();
-	std::regex integer(regex);
+	auto ascii = GetUnicodeString();
+	std::wregex integer(CTextConvert::AnsiToUnicode(regex.c_str()));
 	if (regex_match(ascii, integer))
 	{
 		matches = true;
@@ -159,11 +192,14 @@ BOOL CDittoChaiScript::AsciiTextMatchesRegex(std::string regex)
 
 void CDittoChaiScript::AsciiTextReplaceRegex(std::string regex, std::string replaceWith)
 {
-	auto ascii = GetAsciiString();
-	std::regex integer(regex);
+	if (AsciiTextMatchesRegex(regex))
+	{
+		CStringA ascii = CTextConvert::UnicodeToUTF8(GetUnicodeString().c_str());
+		std::regex integer(regex.c_str());
 
-	auto newAscii = regex_replace(ascii, integer, replaceWith);
-	SetAsciiString(newAscii);
+		auto newAscii = std::regex_replace(ascii.GetBuffer(), integer, replaceWith);
+		SetUnicodeString(CTextConvert::Utf8ToUnicode(newAscii.c_str()).GetBuffer());
+	}
 }
 
 
@@ -188,7 +224,7 @@ BOOL CDittoChaiScript::DescriptionMatchesRegex(std::string regex)
 
 	if (m_pClip)
 	{
-		std:string ascii(CTextConvert::ConvertToChar(m_pClip->Description()).GetBuffer());
+		std:string ascii(CTextConvert::UnicodeToAnsi(m_pClip->Description()).GetBuffer());
 		std::regex integer(regex);
 		if (regex_match(ascii, integer))
 		{
@@ -203,7 +239,7 @@ void CDittoChaiScript::DescriptionReplaceRegex(std::string regex, std::string re
 {
 	if (m_pClip)
 	{
-		std:string ascii(CTextConvert::ConvertToChar(m_pClip->Description()).GetBuffer());
+		std:string ascii(CTextConvert::UnicodeToAnsi(m_pClip->Description()).GetBuffer());
 		std::regex integer(regex);
 
 		auto newAscii = regex_replace(ascii, integer, replaceWith);

DittoChaiScript.h

@@ -17,6 +17,9 @@ public:
 	std::string GetAsciiString();
 	void SetAsciiString(std::string stringVal);
 
+	std::wstring CDittoChaiScript::GetUnicodeString();
+	void SetUnicodeString(std::wstring stringVal);
+
 	std::string GetClipMD5(std::string clipboardFormat);
 	SIZE_T GetClipSize(std::string clipboardFormat);
 

DittoRulerRichEditCtrl.cpp

@@ -217,7 +217,7 @@ bool CDittoRulerRichEditCtrl::LoadRTFData(CClip &Clip)
 		csRTFOriginal = r;
 	}
 
-	CStringA csRTF = CTextConvert::ConvertToChar(csRTFOriginal);
+	CStringA csRTF = CTextConvert::UnicodeToAnsi(csRTFOriginal);
 	CClipFormat format;
 	format.m_cfType = RegisterClipboardFormat(_T("Rich Text Format"));
 	int nLength = csRTF.GetLength() + 1;

FileRecieve.cpp

@@ -54,9 +54,8 @@ long CFileRecieve::RecieveFiles(SOCKET sock, CString csIP, CFileTransferProgress
 			break;
 		case MyEnums::DATA_START:
 		{
-			CString csFileName;
+			CString csFileName = CTextConvert::Utf8ToUnicode(Info.m_cDesc);
 			nFilesRecieved++;
-			CTextConvert::ConvertFromUTF8(Info.m_cDesc, csFileName);
 
 			if(m_pProgress != NULL)
 			{
@@ -118,16 +117,16 @@ long CFileRecieve::RecieveFiles(SOCKET sock, CString csIP, CFileTransferProgress
 						md5Error = true;
 						::DeleteFile(fileName);
 
-						LogSendRecieveInfo(StrF(_T("MD5 ERROR Receiving data_end for file: %s, local md5: %s remote md5: %s"), fileName, CTextConvert::MultiByteToUnicodeString(localMd5), CTextConvert::MultiByteToUnicodeString(remoteMd5)));
+						LogSendRecieveInfo(StrF(_T("MD5 ERROR Receiving data_end for file: %s, local md5: %s remote md5: %s"), fileName, CTextConvert::AnsiToUnicode(localMd5), CTextConvert::AnsiToUnicode(remoteMd5)));
 					}
 					else
 					{
-						LogSendRecieveInfo(StrF(_T("Receiving data_end for file: %s, MD5 MATCH local md5: %s remote md5: %s"), fileName, CTextConvert::MultiByteToUnicodeString(localMd5), CTextConvert::MultiByteToUnicodeString(remoteMd5)));
+						LogSendRecieveInfo(StrF(_T("Receiving data_end for file: %s, MD5 MATCH local md5: %s remote md5: %s"), fileName, CTextConvert::AnsiToUnicode(localMd5), CTextConvert::AnsiToUnicode(remoteMd5)));
 					}
 				}
 				else
 				{
-					LogSendRecieveInfo(StrF(_T("Not checking mdf on file transfer, either setting is off or md5 is not sent, md5 Passed In: %s, setting to check: %d"), CTextConvert::MultiByteToUnicodeString(Info.m_md5), CGetSetOptions::GetCheckMd5OnFileTransfers()));
+					LogSendRecieveInfo(StrF(_T("Not checking mdf on file transfer, either setting is off or md5 is not sent, md5 Passed In: %s, setting to check: %d"), CTextConvert::AnsiToUnicode(Info.m_md5), CGetSetOptions::GetCheckMd5OnFileTransfers()));
 				}
 
 				if (md5Error == false)

FileSend.cpp

@@ -124,12 +124,9 @@ BOOL CFileSend::SendFile(CString csFile)
 		CFileException ex;
 		if(file.Open(csFile, CFile::modeRead|CFile::typeBinary|CFile::shareDenyNone, &ex))
 		{
-			CStringA dest;
-			if(CTextConvert::ConvertToUTF8(csFile, dest))
-			{
-				strncpy(Info.m_cDesc, dest, sizeof(Info.m_cDesc));
-				Info.m_cDesc[sizeof(Info.m_cDesc)-1] = 0;
-			}
+			CStringA dest = CTextConvert::UnicodeToUTF8(csFile);
+			strncpy(Info.m_cDesc, dest, sizeof(Info.m_cDesc));
+			Info.m_cDesc[sizeof(Info.m_cDesc)-1] = 0;			
 
 			Info.m_lParameter1 = (long)file.GetLength();
 			if(m_Send.SendCSendData(Info, MyEnums::DATA_START))
@@ -181,7 +178,7 @@ BOOL CFileSend::SendFile(CString csFile)
 					CStringA csMd5 = md5.MD5FinalToString();
 					strncpy(Info.m_md5, csMd5, sizeof(Info.m_md5));
 
-					LogSendRecieveInfo(StrF(_T("Sending data_end for file: %s, md5: %s"), csFile, CTextConvert::MultiByteToUnicodeString(csMd5)));
+					LogSendRecieveInfo(StrF(_T("Sending data_end for file: %s, md5: %s"), csFile, CTextConvert::AnsiToUnicode(csMd5)));
 
 					if(m_Send.SendCSendData(Info, MyEnums::DATA_END))
 						bRet = TRUE;

HyperLink.cpp

@@ -421,7 +421,7 @@ HINSTANCE CHyperLink::GotoURL(LPCTSTR url, int showcmd)
                 lstrcat(pos, _T(" "));
                 lstrcat(pos, url);
 				
-				CStringA keyA = CTextConvert::ConvertToChar(key);
+				CStringA keyA = CTextConvert::UnicodeToAnsi(key);
                 result = (HINSTANCE)WinExec(keyA, showcmd);
             }
         }

MultiLanguage.cpp

@@ -354,12 +354,12 @@ bool CMultiLanguage::LoadLanguageFile(CString csFile)
 		return false;
 	}
 
-	CStringA csPathA = CTextConvert::ConvertToChar(csPath);
+	CStringA csPathA = CTextConvert::UnicodeToAnsi(csPath);
 
 	TiXmlDocument doc(csPathA);
 	if(!doc.LoadFile())
 	{
-		m_csLastError.Format(_T("Error loading file %s - reason = %s, Line: %d, column: %d"), csFile, CTextConvert::ConvertToUnicode(doc.ErrorDesc()), doc.ErrorRow(), doc.ErrorCol());
+		m_csLastError.Format(_T("Error loading file %s - reason = %s, Line: %d, column: %d"), csFile, CTextConvert::AnsiToUnicode(doc.ErrorDesc()), doc.ErrorRow(), doc.ErrorCol());
 		Log(m_csLastError);
 		return false;
 	}
@@ -408,7 +408,7 @@ bool CMultiLanguage::LoadLanguageFile(CString csFile)
 
 bool CMultiLanguage::LoadSection(TiXmlNode &doc, LANGUAGE_ARRAY &Array, CString csSection)
 {
-	CStringA csSectionA = CTextConvert::ConvertToChar(csSection);
+	CStringA csSectionA = CTextConvert::UnicodeToAnsi(csSection);
 	TiXmlNode *node = doc.FirstChild(csSectionA);
 	if(!node)
 	{
@@ -444,7 +444,7 @@ bool CMultiLanguage::LoadSection(TiXmlNode &doc, LANGUAGE_ARRAY &Array, CString
 				}
  				
 				LPCSTR Value = ForeignNode->Value();
-				CTextConvert::ConvertFromUTF8(Value, plItem->m_csForeignLang);
+				plItem->m_csForeignLang = CTextConvert::Utf8ToUnicode(Value);
 
 				//Replace the literal "\n" with line feeds
  				plItem->m_csForeignLang.Replace(_T("\\n"), csLineFeed);
@@ -461,7 +461,7 @@ bool CMultiLanguage::LoadSection(TiXmlNode &doc, LANGUAGE_ARRAY &Array, CString
 
 bool CMultiLanguage::LoadStringTableSection(TiXmlNode &doc, LANGUAGE_MAP &Map, CString csSection)
 {
-	CStringA csSectionA = CTextConvert::ConvertToChar(csSection);
+	CStringA csSectionA = CTextConvert::UnicodeToAnsi(csSection);
 	TiXmlNode *node = doc.FirstChild(csSectionA);
 	if(!node)
 	{
@@ -491,7 +491,7 @@ bool CMultiLanguage::LoadStringTableSection(TiXmlNode &doc, LANGUAGE_MAP &Map, C
 		if(ForeignNode) 
 		{
 			LPCSTR Value = ForeignNode->Value();
-			CTextConvert::ConvertFromUTF8(Value, plItem->m_csForeignLang);
+			plItem->m_csForeignLang = CTextConvert::Utf8ToUnicode(Value);
 
 			//Replace the literal "\n" with line feeds
 			plItem->m_csForeignLang.Replace(_T("\\n"), csLineFeed);

OleClipSource.cpp

@@ -89,7 +89,7 @@ BOOL COleClipSource::DoImmediateRender()
 
 	if(count > 1)
 	{
-		CStringA SepA = CTextConvert::ConvertToChar(g_Opt.GetMultiPasteSeparator());
+		CStringA SepA = CTextConvert::UnicodeToAnsi(g_Opt.GetMultiPasteSeparator());
 		CCF_TextAggregator CFText(SepA);
 		if(m_ClipIDs.AggregateData(CFText, CF_TEXT, g_Opt.m_bMultiPasteReverse, m_pasteOptions.LimitFormatsToText()))
 		{
@@ -99,7 +99,7 @@ BOOL COleClipSource::DoImmediateRender()
 			cf.m_autoDeleteData = false;
 		}
 
-		CStringW SepW = CTextConvert::ConvertToUnicode(g_Opt.GetMultiPasteSeparator());
+		CStringW SepW = g_Opt.GetMultiPasteSeparator();
 		CCF_UnicodeTextAggregator CFUnicodeText(SepW);
 		if(m_ClipIDs.AggregateData(CFUnicodeText, CF_UNICODETEXT, g_Opt.m_bMultiPasteReverse, m_pasteOptions.LimitFormatsToText()))
 		{
@@ -210,7 +210,7 @@ BOOL COleClipSource::DoImmediateRender()
 
 					ChaiScriptOnCopy onPaste;
 					CDittoChaiScript clipData(&clip, "", "");
-					if (onPaste.ProcessScript(clipData, (LPCSTR)CTextConvert::ConvertToChar(element.m_script)) == false)
+					if (onPaste.ProcessScript(clipData, (LPCSTR)CTextConvert::UnicodeToAnsi(element.m_script)) == false)
 					{
 						Log(StrF(_T("End of paste script name: %s, returned false, not saving this copy to Ditto, last Error: %s"), element.m_name, onPaste.m_lastError));
 
@@ -716,7 +716,7 @@ void COleClipSource::AddDateTime(CClip &clip)
 		string += "\r\n\r\n";
 
 		COleDateTime now(COleDateTime::GetCurrentTime());
-		string += CTextConvert::UnicodeStringToMultiByte(now.Format());
+		string += CTextConvert::UnicodeToAnsi(now.Format());
 
 		HGLOBAL hGlobal = NewGlobalP(string.GetBuffer(), ((string.GetLength() + 1)));
 
@@ -738,7 +738,7 @@ void COleClipSource::AddDateTime(CClip &clip)
 			COleDateTime now(COleDateTime::GetCurrentTime());
 				
 			CStringA insert;
-			insert.Format("\\par\r\n\\par\r\n%s", CTextConvert::UnicodeStringToMultiByte(now.Format()));
+			insert.Format("\\par\r\n\\par\r\n%s", CTextConvert::UnicodeToAnsi(now.Format()));
 
 			int count = string.Insert(pos, insert);
 		}
@@ -817,11 +817,9 @@ void COleClipSource::SaveDittoFileDataToFile(CClip &clip)
 				CMd5 calcMd5;
 				CStringA md5String = calcMd5.CalcMD5FromString(stringData, dataSize);
 
-				CString unicodeFilePath;
-				CTextConvert::ConvertFromUTF8(src, unicodeFilePath);
+				CString unicodeFilePath = CTextConvert::Utf8ToUnicode(src);
 
-				CString unicodeMd5;
-				CTextConvert::ConvertFromUTF8(md5String, unicodeMd5);
+				CString unicodeMd5 = CTextConvert::Utf8ToUnicode(md5String);
 
 				Log(StrF(_T("Saving file contents from Ditto, original file: %s, size: %d, md5: %s"), unicodeFilePath, dataSize, unicodeMd5));
 
@@ -1060,8 +1058,8 @@ BOOL COleClipSource::OnRenderGlobalData(LPFORMATETC lpFormatEtc, HGLOBAL* phGlob
 					CString csComputerName;
 					CString csIP;
 
-					CTextConvert::ConvertFromUTF8(pData->m_cIP, csIP);
-					CTextConvert::ConvertFromUTF8(pData->m_cComputerName, csComputerName);
+					csIP = CTextConvert::Utf8ToUnicode(pData->m_cIP);
+					csComputerName = CTextConvert::Utf8ToUnicode(pData->m_cComputerName);
 					
 					GlobalUnlock(pDittoDelayCF_HDROP->m_hgData);
 

Options.cpp

@@ -1544,20 +1544,14 @@ CString CGetSetOptions::GetExtraNetworkPassword(bool bFillArray)
 
 void CGetSetOptions::SetNetworkPassword(CString csPassword)
 {
-	CTextConvert Con;
-	Con.ConvertToUTF8(csPassword, m_csPassword);
-
+	m_csPassword = CTextConvert::UnicodeToUTF8(csPassword);
 	SetProfileString("NetworkStringPassword", csPassword);
 }
 
 CStringA CGetSetOptions::GetNetworkPassword()
 {
 	CString cs = GetProfileString("NetworkStringPassword", "LetMeIn");
-
-	CTextConvert Con;
-	CStringA csReturn;
-	Con.ConvertToUTF8(cs, csReturn);
-
+	CString csReturn = CTextConvert::UnicodeToUTF8(cs);
 	return csReturn;
 }
 

QListCtrl.cpp

@@ -1075,8 +1075,7 @@ bool CQListCtrl::ShowFullDescription(bool bFromAuto, bool fromNextPrev)
 		Clip.m_cfType = GetFormatID(_T("HTML Format"));
 		if (GetClipData(nItem, Clip) && Clip.m_hgData)
 		{
-			CString html;
-			CTextConvert::ConvertFromUTF8(Clip.GetAsCStringA(), html);
+			CString html = CTextConvert::Utf8ToUnicode(Clip.GetAsCStringA());
 			m_pToolTip->SetHtmlText(html);		
 
 			Clip.Free();

QPasteWnd.cpp

@@ -4267,7 +4267,7 @@ bool CQPasteWnd::DoExportToGoogleTranslate()
 					CStringA aText = clip.GetCFTextTextFormat();
 					if (aText != _T(""))
 					{
-						clipText = CTextConvert::MultiByteToUnicodeString(aText);
+						clipText = CTextConvert::AnsiToUnicode(aText);
 					}
 				}
 
@@ -7301,8 +7301,8 @@ bool CQPasteWnd::DoActionEmailTo()
 
 	if (IDs.GetCount() > 1)
 	{
-		CStringA SepA = CTextConvert::ConvertToChar(g_Opt.GetMultiPasteSeparator());
-		CStringW SepW = CTextConvert::ConvertToUnicode(g_Opt.GetMultiPasteSeparator());
+		CStringA SepA = CTextConvert::UnicodeToAnsi(g_Opt.GetMultiPasteSeparator());
+		CStringW SepW = g_Opt.GetMultiPasteSeparator();
 
 		CHTMLFormatAggregator Html(SepA);
 		if (IDs.AggregateData(Html, theApp.m_HTML_Format, g_Opt.m_bMultiPasteReverse, false))
@@ -7397,8 +7397,7 @@ bool CQPasteWnd::DoActionEmailTo()
 					CString html;
 					html.Format(_T("<html><img src=\"%s\"></html>"), file);
 
-					CStringA convToUtf8;
-					CTextConvert::ConvertToUTF8(html, convToUtf8);
+					CStringA convToUtf8 = CTextConvert::UnicodeToUTF8(html);
 					f.Write(convToUtf8.GetBuffer(), convToUtf8.GetLength());
 
 					f.Close();
@@ -7435,7 +7434,7 @@ bool CQPasteWnd::DoActionGmail()
 
 	if (IDs.GetCount() > 1)
 	{
-		CStringW SepW = CTextConvert::ConvertToUnicode(g_Opt.GetMultiPasteSeparator());
+		CStringW SepW = g_Opt.GetMultiPasteSeparator();
 		CCF_UnicodeTextAggregator CFUnicodeText(SepW);
 		if (IDs.AggregateData(CFUnicodeText, CF_UNICODETEXT, g_Opt.m_bMultiPasteReverse, false))
 		{
@@ -7446,7 +7445,7 @@ bool CQPasteWnd::DoActionGmail()
 		}
 		else
 		{
-			CStringA SepA = CTextConvert::ConvertToChar(g_Opt.GetMultiPasteSeparator());
+			CStringA SepA = CTextConvert::UnicodeToAnsi(g_Opt.GetMultiPasteSeparator());
 			CCF_TextAggregator CFText(SepA);
 			if (IDs.AggregateData(CFText, CF_TEXT, g_Opt.m_bMultiPasteReverse, false))
 			{

RecieveSocket.cpp

@@ -82,7 +82,7 @@ LPVOID CRecieveSocket::ReceiveEncryptedData(long lInSize, long &lOutSize)
 				{
 					if(nIndex >= 0 && nIndex < count)
 					{
-						CTextConvert::ConvertToUTF8(g_Opt.m_csNetworkPasswordArray[nIndex], csPassword);
+						csPassword = CTextConvert::UnicodeToUTF8(g_Opt.m_csNetworkPasswordArray[nIndex]);
 					}
 					else
 					{

ScriptEditor.cpp

@@ -283,15 +283,15 @@ void CScriptEditor::OnBnClickedButtonRun()
 	CClip clip;
 
 	ChaiScriptOnCopy test;
-	CDittoChaiScript clipData(&clip, (LPCSTR)CTextConvert::UnicodeStringToMultiByte(app), (LPCSTR)CTextConvert::UnicodeStringToMultiByte(appTitle));
-	clipData.SetAsciiString((LPCSTR)CTextConvert::UnicodeStringToMultiByte(input));
-	clipData.DescriptionReplaceRegex(".*", (LPCSTR)CTextConvert::UnicodeStringToMultiByte(input));
+	CDittoChaiScript clipData(&clip, (LPCSTR)CTextConvert::UnicodeToAnsi(app), (LPCSTR)CTextConvert::UnicodeToAnsi(appTitle));
+	clipData.SetAsciiString((LPCSTR)CTextConvert::UnicodeToAnsi(input));
+	clipData.DescriptionReplaceRegex(".*", (LPCSTR)CTextConvert::UnicodeToAnsi(input));
 	
-	test.ProcessScript(clipData, (LPCSTR)CTextConvert::UnicodeStringToMultiByte(script));
+	test.ProcessScript(clipData, (LPCSTR)CTextConvert::UnicodeToAnsi(script));
 
 	if (test.m_lastError == _T(""))
 	{
-		SetDlgItemText(IDC_EDIT_OUTPUT, _T("returned false\r\n") + CTextConvert::MultiByteToUnicodeString(clipData.GetAsciiString().c_str()));
+		SetDlgItemText(IDC_EDIT_OUTPUT, _T("returned false\r\n") + CTextConvert::AnsiToUnicode(clipData.GetAsciiString().c_str()));
 	}
 	else
 	{

Server.cpp

@@ -45,7 +45,7 @@ UINT  MTServerThread(LPVOID pParam)
 	}
 	else
 	{
-		local.sin_addr.s_addr = inet_addr(CTextConvert::ConvertToChar(bindToIpAddress));
+		local.sin_addr.s_addr = inet_addr(CTextConvert::UnicodeToAnsi(bindToIpAddress));
 	}
 	local.sin_port = htons((u_short)g_Opt.m_lPort);
 	theApp.m_sSocket = socket(AF_INET, SOCK_STREAM, 0);
@@ -202,10 +202,10 @@ void CServer::OnStart(CSendInfo &info)
 	}
 	else
 	{
-		CTextConvert::ConvertFromUTF8(info.m_cIP, m_csIP);
+		m_csIP = CTextConvert::Utf8ToUnicode(info.m_cIP);
 	}
-	CTextConvert::ConvertFromUTF8(info.m_cComputerName, m_csComputerName);
-	CTextConvert::ConvertFromUTF8(info.m_cDesc, m_csDesc);
+	m_csComputerName = CTextConvert::Utf8ToUnicode(info.m_cComputerName);
+	m_csDesc = CTextConvert::Utf8ToUnicode(info.m_cDesc);
 
 	m_manualSend = info.m_manualSend;
 	m_respondPort = info.m_respondPort;
@@ -261,8 +261,7 @@ void CServer::OnDataStart(CSendInfo &info)
 {
 	LogSendRecieveInfo("::DATA_START -- START");
 
-	CString csFormat;
-	CTextConvert::ConvertFromUTF8(info.m_cDesc, csFormat);
+	CString csFormat = CTextConvert::Utf8ToUnicode(info.m_cDesc);
 	m_cf.m_cfType = GetFormatID(csFormat);
 	m_cf.m_hgData = 0;
 	
@@ -384,16 +383,12 @@ void CServer::AddRemoteCF_HDROPFormat()
 
 	CTextConvert Convert;
 
-	CStringA dest;
-	if(CTextConvert::ConvertToUTF8(m_csIP, dest))
-	{
-		strncpy(Drop.m_cIP, dest, sizeof(Drop.m_cIP)-1);
-	}
-	if(CTextConvert::ConvertToUTF8(m_csComputerName, dest))
-	{
-		strncpy(Drop.m_cComputerName, dest, sizeof(Drop.m_cComputerName)-1);
-	}
-
+	CStringA dest = CTextConvert::UnicodeToUTF8(m_csIP);
+	strncpy(Drop.m_cIP, dest, sizeof(Drop.m_cIP)-1);
+	
+	dest = CTextConvert::UnicodeToUTF8(m_csComputerName);
+	strncpy(Drop.m_cComputerName, dest, sizeof(Drop.m_cComputerName)-1);
+	
 	cf.m_hgData = NewGlobalP(&Drop, sizeof(Drop));
 	cf.m_cfType = theApp.m_RemoteCF_HDROP;
 

Shared/TextConvert.cpp

@@ -1,174 +1 @@
-#include "StdAfx.h"
-#include "TextConvert.h"
-
-static BYTE kUtf8Limits[5] = { 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
-
-CTextConvert::CTextConvert()
-{
-}
-
-CTextConvert::~CTextConvert()
-{
-}
-
-CStringW CTextConvert::MultiByteToUnicodeString(const CStringA &srcString)
-{
-	CStringW resultString;
-
-	if(!srcString.IsEmpty())
-	{
-		int numChars = MultiByteToWideChar(CP_ACP, 0, srcString, 
-						srcString.GetLength(), resultString.GetBuffer(srcString.GetLength()), 
-						srcString.GetLength() + 1);
-
-		resultString.ReleaseBuffer(numChars);
-	}
-	return resultString;
-}
-
-CStringA CTextConvert::UnicodeStringToMultiByte(const CStringW &srcString)
-{
-	CStringA resultString;
-	if(!srcString.IsEmpty())
-	{
-		int numRequiredBytes = srcString.GetLength() * sizeof(wchar_t);
-		int numChars = WideCharToMultiByte(CP_ACP, 0, srcString, 
-							srcString.GetLength(), resultString.GetBuffer(numRequiredBytes), 
-							numRequiredBytes + 1, NULL, NULL);
-
-		resultString.ReleaseBuffer(numChars);
-	}
-
-	return resultString;
-}
-
-CStringA CTextConvert::ConvertToChar(const CString &src)
-{
-#ifdef _UNICODE
-	return UnicodeStringToMultiByte(src);
-#else
-	return src;
-#endif
-}
-
-CStringW CTextConvert::ConvertToUnicode(const CString &src)
-{
-#ifdef _UNICODE
-	return src;
-#else
-	return MultiByteToUnicodeString(src);
-#endif
-}
-
-bool CTextConvert::ConvertFromUTF8(const CStringA &src, CString &dest)
-{
-#ifdef _UNICODE	
-	dest.Empty();
-	for(int i = 0; i < src.GetLength();)
-	{
-		BYTE c = (BYTE)src[i++];
-		if (c < 0x80)
-		{
-			dest += (wchar_t)c;
-			continue;
-		}
-		if(c < 0xC0)
-		{
-			dest = src;
-			return false;
-		}
-		int numAdds;
-		for (numAdds = 1; numAdds < 5; numAdds++)
-			if (c < kUtf8Limits[numAdds])
-				break;
-		
-		UINT value = (c - kUtf8Limits[numAdds - 1]);
-		do
-		{
-			if (i >= src.GetLength())
-			{
-				dest = src;
-				return false;
-			}
-			BYTE c2 = (BYTE)src[i++];
-			if (c2 < 0x80 || c2 >= 0xC0)
-			{
-				dest = src;
-				return false;
-			}
-			value <<= 6;
-			value |= (c2 - 0x80);
-			numAdds--;
-		}while(numAdds > 0);
-
-		if (value < 0x10000)
-		{
-			dest += (wchar_t)(value);
-		}
-		else
-		{
-			value -= 0x10000;
-			if (value >= 0x100000)
-			{
-				dest = src;
-				return false;
-			}
-			dest += (wchar_t)(0xD800 + (value >> 10));
-			dest += (wchar_t)(0xDC00 + (value & 0x3FF));
-		}
-	}
-#else
-	dest = src;
-#endif
-	return true; 
-}
-
-bool CTextConvert::ConvertToUTF8(const CString &src, CStringA &dest)
-{
-#ifdef _UNICODE
-	dest.Empty();
-	for(int i = 0; i < src.GetLength();)
-	{
-		UINT value = (UINT)src[i++];
-		if (value < 0x80)
-		{
-			dest += (char)value;
-			continue;
-		}
-		if (value >= 0xD800 && value < 0xE000)
-		{
-			if (value >= 0xDC00)
-			{
-				dest = src;
-				return false;
-			}
-			if (i >= src.GetLength())
-			{
-				dest = src;
-				return false;
-			}
-			UINT c2 = (UINT)src[i++];
-			if (c2 < 0xDC00 || c2 >= 0xE000)
-			{
-				dest = src;
-				return false;
-			}
-			value = ((value - 0xD800) << 10) | (c2 - 0xDC00);
-		}
-		int numAdds;
-		for (numAdds = 1; numAdds < 5; numAdds++)
-			if (value < (((UINT)1) << (numAdds * 5 + 6)))
-				break;
-		dest += (char)(kUtf8Limits[numAdds - 1] + (value >> (6 * numAdds)));
-		do
-		{
-			numAdds--;
-			dest += (char)(0x80 + ((value >> (6 * numAdds)) & 0x3F));
-		}
-		while(numAdds > 0);
-	}
-#else
-	dest = src;
-#endif
-	return true;
-}
+#include "stdafx.h"

Shared/TextConvert.h

@@ -4,17 +4,29 @@ class CTextConvert
 {
 public:
 
-	CTextConvert();
-	~CTextConvert();
+	static CStringA UnicodeToAnsi(CString unicode)
+	{
+		CStringA ansi = CW2A(unicode, CP_ACP);
+		return ansi;
+	}
 
-	static bool ConvertFromUTF8(const CStringA &src, CString &dest);
-	static bool ConvertToUTF8(const CString &src, CStringA &dest);
+	static CStringA UnicodeToUTF8(CString unicode)
+	{
+		CStringA utf8 = CW2A(unicode, CP_UTF8);
+		return utf8;
+	}
 
-	static CStringA UnicodeStringToMultiByte(const CStringW &srcString);
-	static CStringW MultiByteToUnicodeString(const CStringA &srcString);
+	static CString AnsiToUnicode(CStringA ansi)
+	{
+		CString unicode = CA2W(ansi);
+		return unicode;
+	}
 
-	static CStringA ConvertToChar(const CString &src);
-	static CStringW ConvertToUnicode(const CString &src);
+	static CString Utf8ToUnicode(CStringA ansi)
+	{
+		CString unicode = CA2W(ansi, CP_UTF8);
+		return unicode;
+	}
 
 protected:
 };

SymbolEdit.cpp

@@ -199,8 +199,7 @@ CString CSymbolEdit::SavePastSearches()
 	{		
 		TiXmlElement* searchElement = new TiXmlElement("Search");
 
-		CStringA t;
-		CTextConvert::ConvertToUTF8(m_searches[i], t);
+		CStringA t = CTextConvert::UnicodeToUTF8(m_searches[i]);
 		searchElement->SetAttribute("text", t);
 
 		outer->LinkEndChild(searchElement);
@@ -219,8 +218,7 @@ void CSymbolEdit::LoadPastSearches(CString values)
 	m_searches.RemoveAll();
 
 	TiXmlDocument doc;
-	CStringA xmlA;
-	CTextConvert::ConvertToUTF8(values, xmlA);
+	CStringA xmlA = CTextConvert::UnicodeToUTF8(values);
 	doc.Parse(xmlA);
 
 	TiXmlElement *ItemHeader = doc.FirstChildElement("PastSearches");

Theme.cpp

@@ -119,7 +119,7 @@ bool CTheme::Load(CString csTheme, bool bHeaderOnly, bool bCheckLastWriteTime)
 
 	Log(StrF(_T("Loading Theme %s"), csPath));
 
-	CStringA csPathA = CTextConvert::ConvertToChar(csPath);
+	CStringA csPathA = CTextConvert::UnicodeToAnsi(csPath);
 
 	TiXmlDocument doc(csPathA);
 	if(!doc.LoadFile())