mirror of
https://github.com/ONLYOFFICE/core.git
synced 2026-07-11 07:23:34 +08:00
2276da418e
git-svn-id: svn://fileserver/activex/AVS/Sources/TeamlabOffice/trunk/ServerComponents@62078 954022d7-b5bf-4e40-9824-e11837661b57
1081 lines
27 KiB
C++
1081 lines
27 KiB
C++
#include "Utils.h"
|
||
#include <vector>
|
||
|
||
// Следующие функции нужны для поиска FontFile по названию фонта
|
||
#define WUNKNOWNSTR _T("unknown Windows version")
|
||
|
||
#define W95STR _T("Windows 95")
|
||
#define W95SP1STR _T("Windows 95 SP1")
|
||
#define W95OSR2STR _T("Windows 95 OSR2")
|
||
#define W98STR _T("Windows 98")
|
||
#define W98SP1STR _T("Windows 98 SP1")
|
||
#define W98SESTR _T("Windows 98 SE")
|
||
#define WMESTR _T("Windows ME")
|
||
|
||
#define WNT351STR _T("Windows NT 3.51")
|
||
#define WNT4STR _T("Windows NT 4")
|
||
#define W2KSTR _T("Windows 2000")
|
||
#define WXPSTR _T("Windows XP")
|
||
#define WVSTR _T("Windows Vista")
|
||
#define W7STR _T("Windows 7")
|
||
#define W8STR _T("Windows 8")
|
||
|
||
#define WCESTR _T("Windows CE")
|
||
|
||
|
||
#define WUNKNOWN 0
|
||
|
||
#define W9XFIRST 1
|
||
#define W95 1
|
||
#define W95SP1 2
|
||
#define W95OSR2 3
|
||
#define W98 4
|
||
#define W98SP1 5
|
||
#define W98SE 6
|
||
#define WME 7
|
||
#define W9XLAST 99
|
||
|
||
#define WNTFIRST 101
|
||
#define WNT351 101
|
||
#define WNT4 102
|
||
#define W2K 103
|
||
#define WXP 104
|
||
#define WVista 105
|
||
#define W7 106
|
||
#define W8 107
|
||
#define WNTLAST 199
|
||
|
||
#define WCEFIRST 201
|
||
#define WCE 201
|
||
#define WCELAST 299
|
||
|
||
|
||
int UtilsAToI(const char* str)
|
||
{
|
||
bool bFlag = false;
|
||
int nRes = 0;
|
||
|
||
// ищем первый не пустой символ
|
||
|
||
while( *str )
|
||
{
|
||
if ( IS_WHITE_SPACE(*str) )
|
||
str++;
|
||
else
|
||
{
|
||
if ( *str == '-')
|
||
{
|
||
bFlag = true;
|
||
str++;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
while (*str >= '0' && *str <= '9')
|
||
{
|
||
nRes *= 10;
|
||
nRes += *str - '0';
|
||
str++;
|
||
}
|
||
|
||
if ( bFlag )
|
||
nRes *= -1;
|
||
|
||
return nRes;
|
||
}
|
||
|
||
double UtilsAToF(const char *str)
|
||
{
|
||
bool bFlag = false;
|
||
int nVal = 0;
|
||
double dRes = 0;
|
||
int nTmp = 1;
|
||
|
||
// ищем первый не пустой символ
|
||
|
||
while (*str)
|
||
{
|
||
if ( IS_WHITE_SPACE(*str) )
|
||
str++;
|
||
else
|
||
{
|
||
if (*str == '-') {
|
||
bFlag = true;
|
||
str++;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
while (*str >= '0' && *str <= '9')
|
||
{
|
||
if (nVal > 3276)
|
||
break;
|
||
|
||
nVal *= 10;
|
||
nVal += *str - '0';
|
||
str++;
|
||
}
|
||
|
||
if (*str == '.')
|
||
{
|
||
str++;
|
||
while (*str >= '0' && *str <= '9')
|
||
{
|
||
if (nVal > 214748364)
|
||
break;
|
||
|
||
nVal *= 10;
|
||
nVal += *str - '0';
|
||
str++;
|
||
nTmp *= 10;
|
||
}
|
||
}
|
||
|
||
dRes = (double) nVal / nTmp;
|
||
|
||
if ( bFlag )
|
||
dRes *= -1;
|
||
|
||
return dRes;
|
||
}
|
||
char* UtilsIToA(char *str, int nVal, char *eptr)
|
||
{
|
||
char* sTemp;
|
||
char sBuf[INT_LEN + 1];
|
||
|
||
if ( nVal < 0)
|
||
{
|
||
if ( nVal < LIMIT_MIN_INT )
|
||
nVal = LIMIT_MIN_INT;
|
||
*str++ = '-';
|
||
nVal = - nVal;
|
||
}
|
||
else if ( nVal > LIMIT_MAX_INT )
|
||
{
|
||
nVal = LIMIT_MAX_INT;
|
||
}
|
||
else if ( nVal == 0)
|
||
{
|
||
*str++ = '0';
|
||
}
|
||
|
||
sTemp = sBuf + INT_LEN;
|
||
*sTemp-- = 0;
|
||
|
||
while ( nVal > 0)
|
||
{
|
||
*sTemp = (char)( nVal % 10) + '0';
|
||
nVal /= 10;
|
||
sTemp--;
|
||
}
|
||
|
||
sTemp++;
|
||
while ( str < eptr && *sTemp != 0)
|
||
*str++ = *sTemp++;
|
||
|
||
*str = 0;
|
||
|
||
return str;
|
||
}
|
||
char* UtilsIToA2(char *str, unsigned int nVal, unsigned int nLen)
|
||
{
|
||
char* sT;
|
||
char* sU;
|
||
|
||
if ( nVal > LIMIT_MAX_INT )
|
||
nVal = LIMIT_MAX_INT;
|
||
|
||
sU = str + nLen - 1;
|
||
*sU = 0;
|
||
sT = sU - 1;
|
||
while ( nVal > 0 && sT >= str )
|
||
{
|
||
*sT = (char)( nVal % 10) + '0';
|
||
nVal /= 10;
|
||
sT--;
|
||
}
|
||
|
||
while (str <= sT)
|
||
*sT-- = '0';
|
||
|
||
return str + nLen - 1;
|
||
}
|
||
char* UtilsFToA(char *str, float fVal, char *eptr)
|
||
{
|
||
int nNPartVal = 0;
|
||
int nFPartVal = 0;
|
||
char sBuf[REAL_LEN + 1];
|
||
char* sptr = str;
|
||
char* sTemp;
|
||
|
||
unsigned int nIndex = 0;
|
||
|
||
if ( fVal > LIMIT_MAX_REAL)
|
||
fVal = LIMIT_MAX_REAL;
|
||
else
|
||
if ( fVal < LIMIT_MIN_REAL)
|
||
fVal = LIMIT_MIN_REAL;
|
||
|
||
sTemp = sBuf + REAL_LEN;
|
||
*sTemp-- = 0;
|
||
|
||
if ( fVal < 0 )
|
||
{
|
||
*str++ = '-';
|
||
fVal = -fVal;
|
||
}
|
||
|
||
// разделяем целую и дробную части
|
||
nNPartVal = (int)( fVal + 0.000005 );
|
||
nFPartVal = (int)((float)( fVal - nNPartVal + 0.000005) * 100000);
|
||
|
||
// пишем дробную часть
|
||
for ( nIndex = 0; nIndex < 5; nIndex++)
|
||
{
|
||
*sTemp = (char)( nFPartVal % 10) + '0';
|
||
nFPartVal /= 10;
|
||
sTemp--;
|
||
}
|
||
|
||
// пишем целую часть
|
||
*sTemp-- = '.';
|
||
*sTemp = '0';
|
||
if ( nNPartVal == 0 )
|
||
sTemp--;
|
||
|
||
while (nNPartVal > 0)
|
||
{
|
||
*sTemp = (char)(nNPartVal % 10) + '0';
|
||
nNPartVal /= 10;
|
||
sTemp--;
|
||
}
|
||
|
||
sTemp++;
|
||
|
||
while (str <= eptr && *sTemp != 0)
|
||
*str++ = *sTemp++;
|
||
str--;
|
||
|
||
|
||
// TODO: при избавлении от нулей при сдвиге конец строки тоже нужно чистить
|
||
// пример число -00.90123 рельузльтат "-0.901234"
|
||
|
||
while (str > sptr)
|
||
{
|
||
if (*str == '0')
|
||
*str = 0;
|
||
else {
|
||
if (*str == '.')
|
||
*str = 0;
|
||
break;
|
||
}
|
||
str--;
|
||
}
|
||
|
||
return (*str == 0) ? str : ++str;
|
||
}
|
||
|
||
BYTE* UtilsMemCpy(BYTE* pDst, const BYTE *pSrc, DWORD nLen)
|
||
{
|
||
if (nLen > 0)
|
||
memcpy( pDst, pSrc, nLen );
|
||
|
||
return pDst;
|
||
}
|
||
|
||
BYTE* UtilsStrCpy(char *sDst, const char *sSrc, char *eptr)
|
||
{
|
||
if ( NULL != sSrc )
|
||
{
|
||
while ( eptr > sDst && *sSrc != 0)
|
||
*sDst++ = *sSrc++;
|
||
}
|
||
|
||
*sDst = 0;
|
||
|
||
return (BYTE*)sDst;
|
||
}
|
||
|
||
|
||
int UtilsMemCmp (const BYTE *s1, const BYTE *s2, unsigned int nLen)
|
||
{
|
||
if ( nLen == 0 )
|
||
return 0;
|
||
|
||
while ( *s1 == *s2 )
|
||
{
|
||
nLen--;
|
||
if (nLen == 0)
|
||
return 0;
|
||
s1++;
|
||
s2++;
|
||
}
|
||
|
||
return *s1 - *s2;
|
||
}
|
||
|
||
int UtilsStrCmp (const char *s1, const char *s2)
|
||
{
|
||
if (!s1 || !s2)
|
||
{
|
||
if (!s1 && !s2)
|
||
return 0;
|
||
if (!s1 && s2)
|
||
return -1;
|
||
else
|
||
return 1;
|
||
}
|
||
|
||
while (*s1 == *s2)
|
||
{
|
||
s1++;
|
||
s2++;
|
||
if (*s1 == 0 || *s2 == 0)
|
||
break;
|
||
}
|
||
|
||
return (BYTE)*s1 - (BYTE)*s2;
|
||
}
|
||
|
||
|
||
void* UtilsMemSet(void *pBuf, BYTE nChar, DWORD nLen)
|
||
{
|
||
BYTE* pBuffer = (BYTE*)pBuf;
|
||
memset( pBuffer, nChar, nLen );
|
||
|
||
pBuffer += nLen;
|
||
|
||
return pBuffer;
|
||
}
|
||
|
||
|
||
DWORD UtilsStrLen(const char *str, int nMaxLen)
|
||
{
|
||
int nLen = 0;
|
||
|
||
if ( !str )
|
||
return 0;
|
||
|
||
while ( *str != 0 && ( nMaxLen < 0 || nLen < nMaxLen) )
|
||
{
|
||
str++;
|
||
nLen++;
|
||
}
|
||
|
||
return (DWORD)nLen;
|
||
}
|
||
|
||
const char* UtilsStrStr(const char *s1, const char *s2, DWORD nMaxLen)
|
||
{
|
||
DWORD nLen = UtilsStrLen(s2, -1);
|
||
|
||
if ( !s1 )
|
||
return NULL;
|
||
|
||
if ( nLen == 0 )
|
||
return s1;
|
||
|
||
if ( nMaxLen == 0 )
|
||
nMaxLen = UtilsStrLen (s1, -1);
|
||
|
||
if ( nMaxLen < nLen)
|
||
return NULL;
|
||
|
||
nMaxLen -= nLen;
|
||
nMaxLen++;
|
||
|
||
while ( nMaxLen > 0 )
|
||
{
|
||
if ( UtilsMemCmp ((const BYTE*)s1, (const BYTE*)s2, nLen) == 0 )
|
||
return s1;
|
||
|
||
s1++;
|
||
nMaxLen--;
|
||
}
|
||
|
||
return NULL;
|
||
}
|
||
|
||
|
||
void UtilsUIntArrayClearRepeat(unsigned short** ppArray, int *pnCount, unsigned short unEmptySymbol)
|
||
{
|
||
int nCount = *pnCount;
|
||
unsigned short *pArray = *ppArray;
|
||
unsigned short *pClearArray = new unsigned short[nCount];
|
||
int nCurCount = 0;
|
||
|
||
for ( int nIndex = 0; nIndex < nCount; nIndex++ )
|
||
{
|
||
bool bRepeat = false;
|
||
for ( int nClearIndex = 0; nClearIndex < nCurCount; nClearIndex++ )
|
||
{
|
||
if ( pClearArray[nClearIndex] == pArray[nIndex] )
|
||
{
|
||
bRepeat = true;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if ( !bRepeat )
|
||
{
|
||
pClearArray[nCurCount] = pArray[nIndex];
|
||
nCurCount++;
|
||
}
|
||
}
|
||
for ( int nIndex = 0; nIndex < nCurCount; nIndex++ )
|
||
{
|
||
pArray[nIndex] = pClearArray[nIndex];
|
||
}
|
||
for ( int nIndex = nCurCount; nIndex < nCount; nIndex++ )
|
||
{
|
||
pArray[nIndex] = unEmptySymbol;
|
||
}
|
||
*pnCount = nCurCount;
|
||
delete []pClearArray;
|
||
}
|
||
Box ToBox(short nLeft, short nBottom, short nRight, short nTop)
|
||
{
|
||
Box oBox;
|
||
|
||
oBox.fLeft = nLeft;
|
||
oBox.fBottom = nBottom;
|
||
oBox.fRight = nRight;
|
||
oBox.fTop = nTop;
|
||
|
||
return oBox;
|
||
}
|
||
Box ToBox(float fLeft, float fBottom, float fRight, float fTop)
|
||
{
|
||
Box oBox;
|
||
|
||
oBox.fLeft = fLeft;
|
||
oBox.fBottom = fBottom;
|
||
oBox.fRight = fRight;
|
||
oBox.fTop = fTop;
|
||
|
||
return oBox;
|
||
}
|
||
TPoint ToPoint(short x, short y)
|
||
{
|
||
TPoint oPoint;
|
||
|
||
oPoint.fX = x;
|
||
oPoint.fY = y;
|
||
|
||
return oPoint;
|
||
}
|
||
|
||
TRect ToRect(float fLeft, float fBottom, float fRight, float fTop)
|
||
{
|
||
TRect oRect;
|
||
|
||
oRect.fLeft = fLeft;
|
||
oRect.fBottom = fBottom;
|
||
oRect.fRight = fRight;
|
||
oRect.fTop = fTop;
|
||
|
||
return oRect;
|
||
}
|
||
|
||
|
||
void UInt16Swap(unsigned short *pnValue)
|
||
{
|
||
|
||
BYTE aTemp[2];
|
||
|
||
UtilsMemCpy( aTemp, (BYTE*)pnValue, 2);
|
||
*pnValue = (unsigned short)((BYTE)aTemp[0] << 8 | (BYTE)aTemp[1]);
|
||
}
|
||
|
||
|
||
|
||
|
||
void UIntChangeBit(unsigned int *pnValue, short nBit)
|
||
{
|
||
// работаем только с 4-байтовыми числами
|
||
if ( nBit < 0 || nBit > 31 )
|
||
return;
|
||
|
||
BYTE aBits[32];
|
||
|
||
for ( int nIndex = 0, nCurBit = 1; nIndex < 32; nIndex++, nCurBit *= 2 )
|
||
{
|
||
aBits[nIndex] = (*pnValue) & nCurBit ? 1 : 0;
|
||
}
|
||
aBits[nBit] = 1 - aBits[nBit];
|
||
*pnValue = 0;
|
||
for ( int nIndex = 0, nCurBit = 1; nIndex < 32; nIndex++, nCurBit *= 2 )
|
||
{
|
||
*pnValue += nCurBit * aBits[nIndex];
|
||
}
|
||
}
|
||
void UtilsStrClear(std::wstring & sString)
|
||
{
|
||
// Убираем пробелы, запятые и минусы(тире).
|
||
int nIndex = 0;
|
||
while ( nIndex < sString.length() )
|
||
{
|
||
char nChar = sString[nIndex];
|
||
if ( nChar == ' ' || nChar == ',' || nChar == '-' )
|
||
{
|
||
sString.erase(sString.begin() + nIndex);
|
||
}
|
||
else
|
||
{
|
||
++nIndex;
|
||
}
|
||
}
|
||
|
||
}
|
||
void UtilsStrClear(CString & sString)
|
||
{
|
||
// Убираем пробелы, запятые и минусы(тире).
|
||
int nIndex = 0;
|
||
while ( nIndex < sString.GetLength() )
|
||
{
|
||
char nChar = sString[nIndex];
|
||
if ( nChar == ' ' || nChar == ',' || nChar == '-' )
|
||
{
|
||
sString.Delete(nIndex);
|
||
}
|
||
else
|
||
{
|
||
++nIndex;
|
||
}
|
||
}
|
||
|
||
}
|
||
#if defined(_WIN32) || defined (_WIN64)
|
||
long GetNextNameValue(HKEY key, LPCTSTR pszSubkey, LPTSTR pszName, LPTSTR pszData)
|
||
{
|
||
static HKEY hkey = NULL; // registry handle, kept open between calls
|
||
static DWORD dwIndex = 0; // count of values returned
|
||
LONG retval;
|
||
|
||
// if all parameters are NULL then close key
|
||
if (pszSubkey == NULL && pszName == NULL && pszData == NULL)
|
||
{
|
||
if (hkey)
|
||
RegCloseKey(hkey);
|
||
hkey = NULL;
|
||
return ERROR_SUCCESS;
|
||
}
|
||
|
||
// if subkey is specified then open key (first time)
|
||
if (pszSubkey && pszSubkey[0] != 0)
|
||
{
|
||
retval = RegOpenKeyEx(key, pszSubkey, 0, KEY_READ, &hkey);
|
||
if (retval != ERROR_SUCCESS)
|
||
{
|
||
return retval;
|
||
}
|
||
dwIndex = 0;
|
||
}
|
||
else
|
||
{
|
||
dwIndex++;
|
||
}
|
||
|
||
///_ASSERTE(pszName != NULL && pszData != NULL); todooo
|
||
|
||
*pszName = 0;
|
||
*pszData = 0;
|
||
|
||
TCHAR szValueName[MAX_PATH];
|
||
DWORD dwValueNameSize = sizeof(szValueName)-1;
|
||
BYTE szValueData[MAX_PATH];
|
||
DWORD dwValueDataSize = sizeof(szValueData)-1;
|
||
DWORD dwType = 0;
|
||
|
||
retval = RegEnumValue(hkey, dwIndex, szValueName, &dwValueNameSize, NULL,
|
||
&dwType, szValueData, &dwValueDataSize);
|
||
if (retval == ERROR_SUCCESS)
|
||
{
|
||
lstrcpy(pszName, (LPTSTR)szValueName);
|
||
lstrcpy(pszData, (LPTSTR)szValueData);
|
||
}
|
||
|
||
return retval;
|
||
}
|
||
#endif
|
||
// dwPlatFormID dwMajorVersion dwMinorVersion dwBuildNumber
|
||
// 95 1 4 0 950
|
||
// 95 SP1 1 4 0 >950 && <=1080
|
||
// 95 OSR2 1 4 <10 >1080
|
||
// 98 1 4 10 1998
|
||
// 98 SP1 1 4 10 >1998 && <2183
|
||
// 98 SE 1 4 10 >=2183
|
||
// ME 1 4 90 3000
|
||
|
||
// Windows NT 3.51 2 3 51
|
||
// Windows NT 4 2 4 0 1381
|
||
// Windows 2000 2 5 0 2195
|
||
// Windows XP 2 5 1 2600
|
||
// Windows Vista 2 6 0 6000
|
||
// Windows Vista SP1 2 6 0 6001
|
||
// Windows Vista SP2 2 6 0 6002
|
||
// Windows 7 2 6 1 7600
|
||
// Windows 7 SP1 2 6 1 7601
|
||
// Windows Server 2012 2 6 2 9200
|
||
// Windows 8 2 6 2 9200
|
||
// Windows 8.1 2 6 3 9431
|
||
|
||
// CE 3
|
||
|
||
#if defined(_WIN32) || defined(_WIN64)
|
||
bool GetFontFile (NSStructures::CFont *pFont, std::wstring & wsFontName, std::wstring & wsDisplayName, std::wstring & wsFontFile, bool *bBold, bool *bItalic)
|
||
{
|
||
TCHAR szName[2 * MAX_PATH];
|
||
TCHAR szData[2 * MAX_PATH];
|
||
|
||
int nVersion;
|
||
TCHAR szVersion[100];
|
||
GetWinVer(szVersion, sizeof(szVersion)/sizeof(TCHAR)-1, &nVersion);
|
||
|
||
TCHAR szFontPath[1000];
|
||
|
||
if ( (nVersion >= WNTFIRST ) && ( nVersion <= WNTLAST) )
|
||
_tcscpy(szFontPath, _T("Software\\Microsoft\\Windows NT\\CurrentVersion\\Fonts"));
|
||
else
|
||
_tcscpy(szFontPath, _T("Software\\Microsoft\\Windows\\CurrentVersion\\Fonts"));
|
||
|
||
bool bResult = false;
|
||
|
||
// Сначала пробежимся по списку фонтов и узнаем сколько из них начинаются с имени lpszFontName
|
||
string_replaceAll(wsFontName, _T("Adobe"), _T("A"));
|
||
UtilsStrClear( wsFontName );
|
||
|
||
int nFontCount = 0;
|
||
while (GetNextNameValue(HKEY_LOCAL_MACHINE, szFontPath, szName, szData) == ERROR_SUCCESS)
|
||
{
|
||
std::wstring sName(szName);
|
||
UtilsStrClear( sName );
|
||
|
||
if (sName.find(wsFontName) >=0 )
|
||
{
|
||
nFontCount++;
|
||
}
|
||
|
||
szFontPath[0] = _T('\0'); // this will get next value, same key
|
||
}
|
||
GetNextNameValue(HKEY_LOCAL_MACHINE, NULL, NULL, NULL); // close the registry key
|
||
|
||
// Восстанавливаем Путь в реестре
|
||
if ( (nVersion >= WNTFIRST ) && ( nVersion <= WNTLAST) )
|
||
_tcscpy(szFontPath, _T("Software\\Microsoft\\Windows NT\\CurrentVersion\\Fonts"));
|
||
else
|
||
_tcscpy(szFontPath, _T("Software\\Microsoft\\Windows\\CurrentVersion\\Fonts"));
|
||
|
||
//_ASSERTE(lpszFontName && lpszFontName[0] != 0);
|
||
if (wsFontName.length() < 1)
|
||
return false;
|
||
|
||
//_ASSERTE(lpszDisplayName);
|
||
if (wsDisplayName.length() < 1)
|
||
return false;
|
||
|
||
//_ASSERTE(lpszFontFile);
|
||
if (wsFontFile.length() < 1)
|
||
return false;
|
||
|
||
wsDisplayName = _T("");
|
||
wsFontFile = _T("");
|
||
|
||
bool blBold = *bBold;
|
||
bool blItalic = *bItalic;
|
||
|
||
string_replaceAll(wsFontName, _T("Adobe"), _T("A"));
|
||
UtilsStrClear( wsFontName );
|
||
|
||
std::vector<std::wstring> arr_wsDisplayName;
|
||
std::vector<std::wstring> arr_wsFontFile;
|
||
while (GetNextNameValue(HKEY_LOCAL_MACHINE, szFontPath, szName, szData) == ERROR_SUCCESS)
|
||
{
|
||
std::wstring sName(szName);
|
||
|
||
UtilsStrClear( sName );
|
||
|
||
if ( sName.find(wsFontName) >=0 )//todooo проверить
|
||
{
|
||
bResult = true;
|
||
arr_wsDisplayName.push_back(sName);
|
||
arr_wsFontFile.push_back(szData);
|
||
}
|
||
|
||
//if (_tcsnicmp(lpszFontName, szName, _tcslen(lpszFontName)) == 0)
|
||
//{
|
||
// bResult = true;
|
||
// _tcsncpy( arrlpszDisplayName[nCurFontIndex], szName, nDisplayNameSize - 1);
|
||
// _tcsncpy( arrlpszFontFile[nCurFontIndex], szData, nFontFileSize - 1);
|
||
// nCurFontIndex++;
|
||
//}
|
||
|
||
szName[0] = _T('\0');
|
||
szFontPath[0] = _T('\0'); // this will get next value, same key
|
||
}
|
||
GetNextNameValue(HKEY_LOCAL_MACHINE, NULL, NULL, NULL); // close the registry key
|
||
|
||
// в массив пишем номер фонта в массиве arrlpszDisplayName, с соответствующими настройками
|
||
// { font, font bold, font italic, font bold italic}
|
||
int arrFont[4] = { -1, -1, -1, -1 };
|
||
|
||
std::wstring sFontRTT = wsFontName + _T("Regular") + _T("(TrueType)\0");
|
||
std::wstring sFontBTT = wsFontName + _T("Bold") + _T("(TrueType)\0");
|
||
std::wstring sFontITT = wsFontName + _T("Italic") + _T("(TrueType)\0");
|
||
// oblique = Italic
|
||
std::wstring sFontOTT = wsFontName + _T("Oblique") + _T("(TrueType)\0");
|
||
std::wstring sFontBITT = wsFontName + _T("BoldItalic") + _T("(TrueType)\0");
|
||
std::wstring sFontBOTT = wsFontName + _T("BoldOblique") + _T("(TrueType)\0");
|
||
std::wstring sFontTT = wsFontName + _T("(TrueType)\0");
|
||
|
||
std::wstring sFontROT = wsFontName + _T("Regular") + _T("(OpenType)\0");
|
||
std::wstring sFontBOT = wsFontName + _T("Bold") + _T("(OpenType)\0");
|
||
std::wstring sFontIOT = wsFontName + _T("Italic") + _T("(OpenType)\0");
|
||
// oblique = Italic
|
||
std::wstring sFontOOT = wsFontName + _T("Oblique") + _T("(OpenType)\0");
|
||
std::wstring sFontBIOT = wsFontName + _T("BoldItalic") + _T("(OpenType)\0");
|
||
std::wstring sFontBOOT = wsFontName + _T("BoldOblique") + _T("(OpenType)\0");
|
||
std::wstring sFontOT = wsFontName + _T("(OpenType)\0");
|
||
|
||
nFontCount = arr_wsDisplayName.size();
|
||
for ( unsigned int nIndex = 0; nIndex < nFontCount; nIndex++ )
|
||
{
|
||
// самое главное в начале проверить именно Bold Italic и Bold Oblique
|
||
if (( arr_wsDisplayName[nIndex].find(sFontBITT) >= 0 ) ||
|
||
( arr_wsDisplayName[nIndex].find(sFontBOTT) >= 0 ) ||
|
||
( arr_wsDisplayName[nIndex].find(sFontBIOT) >= 0 ) ||
|
||
( arr_wsDisplayName[nIndex].find(sFontBOOT) >= 0 ) )
|
||
|
||
{
|
||
if ( arrFont[3] < 0 )
|
||
arrFont[3] = nIndex;
|
||
}
|
||
if (( arr_wsDisplayName[nIndex].find(sFontITT) >= 0 ) ||
|
||
( arr_wsDisplayName[nIndex].find(sFontOTT) >= 0 ) ||
|
||
( arr_wsDisplayName[nIndex].find(sFontIOT) >= 0 ) ||
|
||
( arr_wsDisplayName[nIndex].find(sFontOOT) >= 0 ))
|
||
|
||
{
|
||
if ( arrFont[2] < 0 )
|
||
arrFont[2] = nIndex;
|
||
}
|
||
if ( arr_wsDisplayName[nIndex].find(sFontBTT) >= 0 ||
|
||
arr_wsDisplayName[nIndex].find(sFontBOT) >= 0 )
|
||
{
|
||
if ( arrFont[1] < 0 )
|
||
arrFont[1] = nIndex;
|
||
}
|
||
if ( arr_wsDisplayName[nIndex].find(sFontTT) >= 0 ||
|
||
arr_wsDisplayName[nIndex].find(sFontOT) >= 0 ||
|
||
arr_wsDisplayName[nIndex].find(sFontRTT) >= 0 ||
|
||
arr_wsDisplayName[nIndex].find(sFontROT) >= 0 )
|
||
{
|
||
if ( arrFont[0] < 0 )
|
||
arrFont[0] = nIndex;
|
||
}
|
||
}
|
||
if ( bResult )
|
||
{
|
||
if ( blBold && blItalic && arrFont[3] >= 0 )
|
||
{
|
||
wsDisplayName = arr_wsDisplayName[arrFont[3]];
|
||
wsFontFile = arr_wsFontFile[arrFont[3]];
|
||
blBold = false;
|
||
blItalic = false;
|
||
}
|
||
else if ( blBold && blItalic && arrFont[3] < 0 && arrFont[1] >= 0 )
|
||
{
|
||
wsDisplayName = arr_wsDisplayName[arrFont[1]];
|
||
wsFontFile = arr_wsFontFile[arrFont[1]];
|
||
blBold = false;
|
||
}
|
||
else if ( blBold && blItalic && arrFont[3] < 0 && arrFont[2] >= 0 )
|
||
{
|
||
wsDisplayName = arr_wsDisplayName[arrFont[2]];
|
||
wsFontFile = arr_wsFontFile[arrFont[2]];
|
||
blItalic = false;
|
||
}
|
||
else if ( blBold && blItalic && arrFont[3] < 0 && arrFont[0] >= 0 )
|
||
{
|
||
wsDisplayName = arr_wsDisplayName[arrFont[0]];
|
||
wsFontFile = arr_wsFontFile[arrFont[0]];
|
||
}
|
||
else if ( blBold && !blItalic && arrFont[1] >= 0 )
|
||
{
|
||
wsDisplayName = arr_wsDisplayName[arrFont[1]];
|
||
wsFontFile = arr_wsFontFile[arrFont[1]];
|
||
blBold = false;
|
||
}
|
||
else if ( blBold && !blItalic && arrFont[1] < 0 && arrFont[0] >= 0 )
|
||
{
|
||
wsDisplayName = arr_wsDisplayName[arrFont[0]];
|
||
wsFontFile = arr_wsFontFile[arrFont[0]];
|
||
}
|
||
else if ( !blBold && blItalic && arrFont[2] >= 0 )
|
||
{
|
||
wsDisplayName = arr_wsDisplayName[arrFont[2]];
|
||
wsFontFile = arr_wsFontFile[arrFont[2]];
|
||
blItalic = false;
|
||
}
|
||
else if ( !blBold && blItalic && arrFont[2] < 0 && arrFont[0] >= 0 )
|
||
{
|
||
wsDisplayName = arr_wsDisplayName[arrFont[0]];
|
||
wsFontFile = arr_wsFontFile[arrFont[0]];
|
||
}
|
||
else if ( !blBold && !blItalic && arrFont[0] >= 0 )
|
||
{
|
||
wsDisplayName = arr_wsDisplayName[arrFont[0]];
|
||
wsFontFile = arr_wsFontFile[arrFont[0]];
|
||
}
|
||
else
|
||
{
|
||
// если не один из предыдущих вариантов не прошел, тогда берем первый попавшийся фонт
|
||
// запоминая, нужно ли в будущем делать Bold и Italic
|
||
int nIndex = 0;
|
||
for ( ; nIndex < 4; nIndex++ )
|
||
if ( arrFont[nIndex] >= 0 )
|
||
break;
|
||
if ( nIndex >= 4 )
|
||
bResult = false;
|
||
|
||
if ( bResult )
|
||
{
|
||
switch ( nIndex )
|
||
{
|
||
case 0: break;
|
||
case 1: blBold = false; break;
|
||
case 2: blItalic = false; break;
|
||
case 3: blItalic = false; blBold = false; break;
|
||
}
|
||
wsDisplayName = arr_wsDisplayName[arrFont[nIndex]];
|
||
wsFontFile = arr_wsFontFile[arrFont[nIndex]];
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
*bBold = blBold;
|
||
*bItalic = blItalic;
|
||
|
||
arr_wsDisplayName.clear();
|
||
arr_wsFontFile.clear();
|
||
|
||
return bResult;
|
||
}
|
||
|
||
|
||
|
||
#elif defined(__linux__)
|
||
bool GetFontFile (NSStructures::CFont *pFont, std::wstring & wsFontName, std::wstring & wsDisplayName, std::wstring & wsFontFile, bool *bBold, bool *bItalic)
|
||
{
|
||
//todooo linux
|
||
return false;
|
||
}
|
||
|
||
#else
|
||
bool GetFontFile (NSStructures::CFont *pFont, std::wstring & wsFontName, std::wstring & wsDisplayName, std::wstring & wsFontFile, bool *bBold, bool *bItalic)
|
||
{
|
||
//todooo mac
|
||
return false;
|
||
}
|
||
#endif
|
||
#ifdef BUILD_CONFIG_OPENSOURCE_VERSION
|
||
bool GetFontFile2(NSStructures::CFont *pFont, LPCTSTR lpszFontName, LPTSTR lpszDisplayName, int nDisplayNameSize, LPTSTR lpszFontFile, int nFontFileSize, bool *bBold, bool *bItalic, CFontManager *pFontManager)
|
||
{
|
||
if ( pFontManager )
|
||
{
|
||
long lStyle = *bBold + 2 * *bItalic;
|
||
|
||
CString sParams;
|
||
sParams.Format( _T("<FontProperties><Name value='%ls'/><Style bold='%d' italic='%d'/></FontProperties>"), lpszFontName, ( *bBold ? 1 : 0 ), ( *bItalic ? 1 : 0 ) );
|
||
BSTR bsParams = sParams.AllocSysString();
|
||
|
||
BSTR bsFontName = NULL;
|
||
BSTR bsFontPath = NULL;
|
||
BSTR bsFontStyle = NULL;
|
||
LONG lIndex = 0;
|
||
//todooo
|
||
//if ( S_OK != ( pFontManager->GetWinFontByParams( bsParams, &bsFontName, &bsFontPath, &bsFontStyle, &lIndex ) ) )
|
||
//{
|
||
// ::SysFreeString( bsParams );
|
||
// ::SysFreeString( bsFontName );
|
||
// ::SysFreeString( bsFontPath );
|
||
// ::SysFreeString( bsFontStyle );
|
||
// return false;
|
||
//}
|
||
|
||
::SysFreeString( bsParams );
|
||
|
||
::memset( lpszFontFile, 0x00, nFontFileSize );
|
||
::memset( lpszDisplayName, 0x00, nDisplayNameSize );
|
||
|
||
_tcsncpy( lpszFontFile, bsFontPath, min( nFontFileSize - 1, wcslen( bsFontPath ) ) );
|
||
::SysFreeString( bsFontPath );
|
||
|
||
_tcsncpy( lpszDisplayName, bsFontName, min( nDisplayNameSize - 1, wcslen( bsFontName ) ) );
|
||
::SysFreeString( bsFontName );
|
||
|
||
// pFontManager->raw_GetAdditionalParam( _T("GetFontIndex"), &vTemp );
|
||
|
||
CString sStyle( bsFontStyle );
|
||
::SysFreeString( bsFontStyle );
|
||
|
||
if ( *bBold && -1 != sStyle.Find( _T("Bold") ) )
|
||
*bBold = false;
|
||
|
||
if ( *bItalic && ( -1 != sStyle.Find( _T("Italic") ) || -1 != sStyle.Find( _T("Oblique") ) ) )
|
||
*bItalic = false;
|
||
|
||
return true;
|
||
}
|
||
else
|
||
{
|
||
return GetFontFile( pFont, lpszFontName, lpszDisplayName, nDisplayNameSize, lpszFontFile, nFontFileSize, bBold, bItalic );
|
||
}
|
||
}
|
||
#else
|
||
bool GetFontFile2(NSStructures::CFont *pFont, std::wstring & wsFontName, std::wstring & wsDisplayName, std::wstring & wsFontFile, bool *bBold, bool *bItalic, CFontManager *pFontManager)
|
||
{
|
||
if ( pFontManager )
|
||
{
|
||
long lStyle = *bBold + 2 * *bItalic;
|
||
CFontSelectFormat oFontSelectFormat;
|
||
oFontSelectFormat.wsName = new std::wstring(wsFontName);
|
||
oFontSelectFormat.bBold = new INT(*bBold);
|
||
oFontSelectFormat.bItalic = new INT(*bItalic);
|
||
CFontInfo* pFontInfo = pFontManager->GetFontInfoByParams(oFontSelectFormat);
|
||
if(NULL == pFontInfo)
|
||
return false;
|
||
wsFontFile = pFontInfo->m_wsFontPath;
|
||
wsDisplayName = pFontInfo->m_wsFontName;
|
||
|
||
if (*bBold && pFontInfo->m_bBold)
|
||
*bBold = false;
|
||
|
||
if (*bItalic && pFontInfo->m_bItalic)
|
||
*bItalic = false;
|
||
|
||
return true;
|
||
}
|
||
else
|
||
{
|
||
return GetFontFile( pFont, wsFontName, wsDisplayName, wsFontFile, bBold, bItalic );
|
||
}
|
||
}
|
||
#endif
|
||
|
||
|
||
bool GetWinVer(LPTSTR lpszVersion, int nVersionSize, int *pnVersion)
|
||
{
|
||
#if defined (_WIN32) || defined(_WIN64)
|
||
_tcsncpy(lpszVersion, WUNKNOWNSTR, nVersionSize-1);
|
||
*pnVersion = WUNKNOWN;
|
||
|
||
TCHAR *cp = NULL;
|
||
|
||
OSVERSIONINFO osinfo;
|
||
osinfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
|
||
|
||
if ( !GetVersionEx(&osinfo) )
|
||
return false;
|
||
|
||
DWORD dwPlatformId = osinfo.dwPlatformId;
|
||
DWORD dwMinorVersion = osinfo.dwMinorVersion;
|
||
DWORD dwMajorVersion = osinfo.dwMajorVersion;
|
||
DWORD dwBuildNumber = osinfo.dwBuildNumber & 0xFFFF; // Win 95 needs this
|
||
|
||
if ((dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) && (dwMajorVersion == 4))
|
||
{
|
||
if ((dwMinorVersion < 10) && (dwBuildNumber == 950))
|
||
{
|
||
cp = W95STR;
|
||
*pnVersion = W95;
|
||
}
|
||
else if ((dwMinorVersion < 10) &&
|
||
((dwBuildNumber > 950) && (dwBuildNumber <= 1080)))
|
||
{
|
||
cp = W95SP1STR;
|
||
*pnVersion = W95SP1;
|
||
}
|
||
else if ((dwMinorVersion < 10) && (dwBuildNumber > 1080))
|
||
{
|
||
cp = W95OSR2STR;
|
||
*pnVersion = W95OSR2;
|
||
}
|
||
else if ((dwMinorVersion == 10) && (dwBuildNumber == 1998))
|
||
{
|
||
cp = W98STR;
|
||
*pnVersion = W98;
|
||
}
|
||
else if ((dwMinorVersion == 10) &&
|
||
((dwBuildNumber > 1998) && (dwBuildNumber < 2183)))
|
||
{
|
||
cp = W98SP1STR;
|
||
*pnVersion = W98SP1;
|
||
}
|
||
else if ((dwMinorVersion == 10) && (dwBuildNumber >= 2183))
|
||
{
|
||
cp = W98SESTR;
|
||
*pnVersion = W98SE;
|
||
}
|
||
else if (dwMinorVersion == 90)
|
||
{
|
||
cp = WMESTR;
|
||
*pnVersion = WME;
|
||
}
|
||
}
|
||
else if (dwPlatformId == VER_PLATFORM_WIN32_NT)
|
||
{
|
||
if ((dwMajorVersion == 3) && (dwMinorVersion == 51))
|
||
{
|
||
cp = WNT351STR;
|
||
*pnVersion = WNT351;
|
||
}
|
||
else if ((dwMajorVersion == 4) && (dwMinorVersion == 0))
|
||
{
|
||
cp = WNT4STR;
|
||
*pnVersion = WNT4;
|
||
}
|
||
else if ((dwMajorVersion == 5) && (dwMinorVersion == 0))
|
||
{
|
||
cp = W2KSTR;
|
||
*pnVersion = W2K;
|
||
}
|
||
else if ((dwMajorVersion == 5) && (dwMinorVersion == 1))
|
||
{
|
||
cp = WXPSTR;
|
||
*pnVersion = WXP;
|
||
}
|
||
else if ((dwMajorVersion == 6) && (dwMinorVersion == 0))
|
||
{
|
||
cp = WVSTR;
|
||
*pnVersion = WVista;
|
||
}
|
||
else if ((dwMajorVersion == 6) && (dwMinorVersion == 1))
|
||
{
|
||
cp = W7STR;
|
||
*pnVersion = W7;
|
||
}
|
||
else if ((dwMajorVersion == 6) && (dwMinorVersion == 2))
|
||
{
|
||
cp = W8STR;
|
||
*pnVersion = W8;
|
||
}
|
||
}
|
||
//else if (dwPlatformId == VER_PLATFORM_WIN32_CE)///????? todooo
|
||
//{
|
||
// cp = WCESTR;
|
||
// *pnVersion = WCE;
|
||
//}
|
||
|
||
_tcsncpy(lpszVersion, cp, nVersionSize-1);
|
||
|
||
return true;
|
||
#else
|
||
return false;
|
||
#endif
|
||
}
|
||
|