Category

Development Platform
Home > SourceCode/Document > Windows Develop > Windows Kernel > View Code
mimereg.cpp
Package: shell.rar　[view]
Upload User: xhy777
Upload Date: 2007-02-14
Package Size: 24088k
Code Size: 29k
Category:

Windows Kernel

Development Platform:

Visual C++

mimereg.cpp：Code Content
  1. #include "private.h"
  2. #ifdef UNIX
  3. /* Convert from little endian to big endian format */
  4. #define CONVERTLONG(a,b,c,d) (((unsigned long )a) + 
  5.                            ((unsigned long )b << 8) + 
  6.                            ((unsigned long )c << 16) + 
  7.                            ((unsigned long )d << 24))
  8. #endif /* UNIX */
  10. //
  11. //  Globals
  12. //
  13. CMimeDatabaseReg *g_pMimeDatabaseReg = NULL;
  15. //
  16. //  Globals
  17. //
  18. PRFC1766INFOA   g_pRfc1766Reg = NULL;
  19. UINT            g_cRfc1766Reg = 0, g_cMaxRfc1766 = 0;
  21. //
  22. //  Functions
  23. //
  24. void CMimeDatabaseReg::BuildRfc1766Table(void)
  25. {
  26.     HKEY hKey = NULL;
  27.     DWORD dwIndex, dwType, cInfo, cbMaxValueLen, cbLCID, cb;
  28.     TCHAR szLCID[8], sz[MAX_RFC1766_NAME +  MAX_LOCALE_NAME + 1];
  30.     DebugMsg(DM_TRACE, TEXT("CRfc1766::BuildRfc1766Table called."));
  31.     EnterCriticalSection(&g_cs);
  32.     if (NULL == g_pRfc1766Reg)
  33.     {
  34.         if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_CLASSES_ROOT, REGSTR_KEY_MIME_DATABASE_RFC1766, 0, KEY_READ, &hKey))
  35.         {
  36.             ASSERT(NULL != hKey);
  37.             if (ERROR_SUCCESS == RegQueryInfoKey(hKey, NULL, NULL, 0, NULL, NULL, NULL, &cInfo, &cbMaxValueLen, NULL, NULL, NULL))
  38.             {
  39.                 g_pRfc1766Reg = (PRFC1766INFOA)LocalAlloc(LPTR, sizeof(RFC1766INFOA) * cInfo);
  40.                 if (NULL != g_pRfc1766Reg)
  41.                 {
  42.                     g_cRfc1766Reg = 0;
  43.                     g_cMaxRfc1766 = cInfo;
  44.                     dwIndex = 0;
  45.                     while (g_cRfc1766Reg < g_cMaxRfc1766)
  46.                     {
  47.                         LONG lRet;
  49.                         cbLCID = ARRAYSIZE(szLCID) - 2;
  50.                         cb = sizeof(sz);
  51.                         lRet = RegEnumValue(hKey, dwIndex++, szLCID + 2, &cbLCID, 0, &dwType, (LPBYTE)sz, &cb);
  52.                         if (ERROR_SUCCESS == lRet)
  53.                         {
  54.                             int iLCID;
  56.                             szLCID[0] = TEXT('0');
  57.                             szLCID[1] = TEXT('x');
  58.                             // BUGBUG: We'd better have private function for this instead of using SHLWAPI becuase 16-bit doesn't have SHLWAPI
  59.                             // if (TRUE == StrToIntEx(szLCID, STIF_SUPPORT_HEX, &iLCID))
  60.                             if (iLCID = HexToNum(szLCID + 2))
  61.                             {
  62.                                 g_pRfc1766Reg[g_cRfc1766Reg].lcid = (LCID)iLCID;
  63.                                 if (REG_SZ == dwType)
  64.                                 {
  65.                                     TCHAR *psz = sz;
  67.                                     while (*psz)
  68.                                     {
  69.                                         if (TEXT(';') == *psz)
  70.                                         {
  71.                                             *psz = TEXT('');
  72.                                             break;
  73.                                         }
  74.                                         psz = CharNext(psz);
  75.                                     }
  76.                                     lstrcpyn(g_pRfc1766Reg[g_cRfc1766Reg].szRfc1766, sz, MAX_RFC1766_NAME);
  77.                                     lstrcpyn(g_pRfc1766Reg[g_cRfc1766Reg].szLocaleName, psz + 1, MAX_LOCALE_NAME);
  78.                                     g_cRfc1766Reg++;
  79.                                 }
  80.                             }
  81.                         }
  82.                         else if (ERROR_NO_MORE_ITEMS == lRet)
  83.                             break;
  84.                     }
  85.                 }
  86.             }
  87.             RegCloseKey(hKey);
  88.         }
  89.     }
  90.     LeaveCriticalSection(&g_cs);
  91. }
  93. void CMimeDatabaseReg::FreeRfc1766Table(void)
  94. {
  95.     DebugMsg(DM_TRACE, TEXT("CRfc1766::FreeRfc1766Table called."));
  96.     EnterCriticalSection(&g_cs);
  97.     if (NULL != g_pRfc1766Reg)
  98.     {
  99.         LocalFree(g_pRfc1766Reg);
  100.         g_pRfc1766Reg = NULL;
  101.         g_cRfc1766Reg = g_cMaxRfc1766 = 0;
  102.     }
  103.     LeaveCriticalSection(&g_cs);
  104. }
  106. void CMimeDatabaseReg::EnsureRfc1766Table(void)
  107. {
  108.     // Ensure g_pRfc1766 is initialized
  109.     if (NULL == g_pRfc1766Reg)
  110.         BuildRfc1766Table();
  111. }
  114. STDAPI CMimeDatabaseReg::LcidToRfc1766A(LCID Locale, LPSTR pszRfc1766, int iMaxLength)
  115. {
  116.     UINT i;
  117.     HRESULT hr = E_INVALIDARG;
  119.     EnsureRfc1766Table();
  120.     if (NULL != pszRfc1766 && 0 < iMaxLength)
  121.     {
  122.         for (i = 0; i < g_cRfc1766Reg; i++)
  123.         {
  124.             if (g_pRfc1766Reg[i].lcid == Locale)
  125.                 break;
  126.         }
  127.         if (i < g_cRfc1766Reg)
  128.         {
  129.             lstrcpyn(pszRfc1766, g_pRfc1766Reg[i].szRfc1766, iMaxLength);
  130.             hr = S_OK;
  131.         }
  132.         else
  133.         {
  134.             TCHAR sz[MAX_RFC1766_NAME];
  136.             if (GetLocaleInfoA(Locale, LOCALE_SABBREVLANGNAME, sz, ARRAYSIZE(sz)))
  137.             {
  138.                 CharLowerA(sz);
  139.                 if (!lstrcmpA(sz, TEXT("cht")))
  140.                     lstrcpynA(pszRfc1766, TEXT("zh-cn"), iMaxLength);
  141.                 else if (!lstrcmpA(sz, TEXT("chs")))
  142.                     lstrcpynA(pszRfc1766, TEXT("zh-tw"), iMaxLength);
  143.                 else if (!lstrcmpA(sz, TEXT("jpn")))
  144.                     lstrcpynA(pszRfc1766, TEXT("ja"), iMaxLength);
  145.                 else
  146.                 {
  147.                     sz[2] = TEXT('');
  148.                     lstrcpynA(pszRfc1766, sz, iMaxLength);
  149.                 }
  150.                 hr = S_OK;
  151.             }
  152.             else
  153.                 hr = E_FAIL;
  154.         }
  155.     }
  156.     return hr;
  157. }    
  159. STDAPI CMimeDatabaseReg::LcidToRfc1766W(LCID Locale, LPWSTR pwszRfc1766, int nChar)
  160. {
  161.     HRESULT hr = E_INVALIDARG;
  163.     if (NULL != pwszRfc1766 && 0 < nChar)
  164.     {
  165.         TCHAR sz[MAX_RFC1766_NAME];
  167.         hr = LcidToRfc1766A(Locale, (LPSTR)sz, ARRAYSIZE(sz));
  168.         if (S_OK == hr)
  169.         {
  170.             int i;
  172.             for (i = 0; i < nChar - 1; i++)
  173.             {
  174.                 pwszRfc1766[i] = (WCHAR)sz[i];
  175.                 if (L'' == pwszRfc1766[i])
  176.                     break;
  177.             }
  178.             if (i == nChar - 1)
  179.                 pwszRfc1766[i] = L'';            
  180.         }
  181.     }
  182.     return hr;
  183. }    
  185. STDAPI CMimeDatabaseReg::Rfc1766ToLcidA(PLCID pLocale, LPCSTR pszRfc1766)
  186. {
  187.     UINT i;
  188.     HRESULT hr = E_INVALIDARG;
  190.     EnsureRfc1766Table();
  191.     if (NULL != pLocale && NULL != pszRfc1766)
  192.     {
  193.         for (i = 0; i < g_cRfc1766Reg; i++)
  194.         {
  195.             if (!lstrcmpi(g_pRfc1766Reg[i].szRfc1766, pszRfc1766))
  196.                 break;
  197.         }
  198.         if (i < g_cRfc1766Reg)
  199.         {
  200.             *pLocale = g_pRfc1766Reg[i].lcid;
  201.             hr = S_OK;
  202.         }
  203.         else
  204.         {
  205.             if (2 < lstrlen(pszRfc1766))
  206.             {
  207.                 TCHAR sz[3];
  209.                 sz[0] = pszRfc1766[0];
  210.                 sz[1] = pszRfc1766[1];
  211.                 sz[2] = TEXT('');
  212.                 for (i = 0; i < g_cRfc1766Reg; i++)
  213.                 {
  214.                     if (!lstrcmpi(g_pRfc1766Reg[i].szRfc1766, sz))
  215.                         break;                
  216.                 }
  217.                 if (i < g_cRfc1766Reg)
  218.                 {
  219.                     *pLocale = g_pRfc1766Reg[i].lcid;
  220.                     hr = S_FALSE;
  221.                 }
  222.                 else
  223.                     hr = E_FAIL;
  224.             }
  225.             else
  226.                 hr = E_FAIL;
  227.         }
  228.     }
  229.     return hr;
  230. }
  232. STDAPI CMimeDatabaseReg::Rfc1766ToLcidW(PLCID pLocale, LPCWSTR pwszRfc1766)
  233. {
  234.     HRESULT hr = E_INVALIDARG;
  236.     if (NULL != pLocale && NULL != pwszRfc1766)
  237.     {
  238.         int i;
  239.         TCHAR sz[MAX_RFC1766_NAME];
  241.         for (i = 0; i < MAX_RFC1766_NAME - 1; i++)
  242.         {
  243.             sz[i] = (TCHAR)pwszRfc1766[i];
  244.             if (TEXT('') == sz[i])
  245.                 break;
  246.         }
  247.         if (i == MAX_RFC1766_NAME -1)
  248.             sz[i] = TEXT('');
  250.         hr = Rfc1766ToLcidA(pLocale, (LPCSTR)sz);
  251.     }
  252.     return hr;
  253. }
  256. //
  257. //  CMimeDatabase implementation
  258. //
  259. CMimeDatabaseReg::CMimeDatabaseReg()
  260. {
  261.     DebugMsg(DM_TRACE, TEXT("constructor of CMimeDatabase 0x%08x"), this);
  262.     _pCodePage = NULL;
  263.     _cCodePage = _cMaxCodePage = 0;
  264.     _pCharset = NULL;
  265.     _cCharset = _cMaxCharset = 0;
  266.     _fAllCPCached = FALSE;
  267.     InitializeCriticalSection(&_cs);
  268. }
  270. CMimeDatabaseReg::~CMimeDatabaseReg()
  271. {
  272.     DebugMsg(DM_TRACE, TEXT("destructor of CMimeDatabase 0x%08x"), this);
  273.     FreeMimeDatabase();
  274.     DeleteCriticalSection(&_cs);
  275. }
  277. void CMimeDatabaseReg::BuildCodePageMimeDatabase(void)
  278. {
  279.     HKEY hKey = NULL;
  280.     DWORD cInfo, cbMaxSubKeyLen;
  282.     DebugMsg(DM_TRACE, TEXT("CMimeDatabase::BuildCodePageMimeDatabase called."));
  283.     // Open CodePage Mime Database Key
  284.     if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_CLASSES_ROOT, REGSTR_KEY_MIME_DATABASE_CODEPAGE, 0, KEY_READ, &hKey))
  285.     {
  286.         ASSERT(NULL != hKey);
  287.         if (ERROR_SUCCESS == RegQueryInfoKey(hKey, NULL, NULL, 0, &cInfo, &cbMaxSubKeyLen, NULL, NULL, NULL, NULL, NULL, NULL))
  288.         {
  289.             if (NULL == _pCodePage)
  290.             {
  291.                 _pCodePage = (PMIMECPINFO)LocalAlloc(LPTR, sizeof(MIMECPINFO) * cInfo);
  292.                 if (NULL != _pCodePage)
  293.                     _cMaxCodePage = cInfo;
  295.             }
  296.         }
  297.         RegCloseKey(hKey);
  298.         hKey = NULL;
  299.     }
  301. }
  303. void CMimeDatabaseReg::BuildCharsetMimeDatabase(void)
  304. {
  305.     HKEY hKey = NULL;
  306.     DWORD cInfo, cbMaxSubKeyLen;
  308.     DebugMsg(DM_TRACE, TEXT("CMimeDatabase::BuildCharsetMimeDatabase called."));
  309.     // Open Charset Mime Database Key
  310.     if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_CLASSES_ROOT, REGSTR_KEY_MIME_DATABASE_CHARSET, 0, KEY_READ, &hKey))
  311.     {
  312.         ASSERT(NULL != hKey);
  313.         if (ERROR_SUCCESS == RegQueryInfoKey(hKey, NULL, NULL, 0, &cInfo, &cbMaxSubKeyLen, NULL, NULL, NULL, NULL, NULL, NULL))
  314.         {
  315.             if (NULL == _pCharset)
  316.             {
  317.                 _pCharset = (PMIMECSETINFO)LocalAlloc(LPTR, sizeof(MIMECSETINFO) * cInfo);
  318.                 if (NULL != _pCharset)
  319.                     _cMaxCharset = cInfo;
  320.             }
  321.         }
  322.         RegCloseKey(hKey);
  323.         hKey = NULL;
  324.     }
  325. }
  327. void CMimeDatabaseReg::FreeMimeDatabase(void)
  328. {
  329.     DebugMsg(DM_TRACE, TEXT("CMimeDatabase::FreeMimeDatabase called."));
  330.     EnterCriticalSection(&_cs);
  331.     if (NULL != _pCodePage)
  332.     {
  333.         LocalFree(_pCodePage);
  334.         _pCodePage = NULL;
  335.         _cCodePage = _cMaxCodePage = 0;
  336.     }
  337.     if (NULL != _pCharset)
  338.     {
  339.         LocalFree(_pCharset);
  340.         _pCharset = NULL;
  341.         _cCharset = _cMaxCharset = 0;
  342.     }
  343.     LeaveCriticalSection(&_cs);
  344.     FreeRfc1766Table();
  345. }
  347. STDAPI CMimeDatabaseReg::EnumCodePageInfo(void)
  348. {
  349.     HKEY hKey = NULL;
  350.     DWORD dwIndex = 0;
  351.     MIMECPINFO CPInfo;
  352.     TCHAR szCodePage[15];
  353.     HRESULT hr = S_OK;
  355.     DebugMsg(DM_TRACE, TEXT("CMimeDatabase::EnumCodePageInfo called."));
  356.     EnterCriticalSection(&_cs);
  357.     if (FALSE == _fAllCPCached)
  358.     {
  359.         if (NULL == _pCodePage)
  360.             BuildCodePageMimeDatabase();
  361.         if (_pCodePage)
  362.         {
  363.             // Open CodePage Mime Database Key
  364.             if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_CLASSES_ROOT, REGSTR_KEY_MIME_DATABASE_CODEPAGE, 0, KEY_READ, &hKey))
  365.             {
  366.                 ASSERT(NULL != hKey);
  367.                 while (ERROR_SUCCESS == RegEnumKey(hKey, dwIndex++, szCodePage, ARRAYSIZE(szCodePage)))
  368.                 {
  369.                     UINT uiCodePage = MLStrToInt(szCodePage);
  370.     
  371.                     if (0 <= FindCodePageFromCache(uiCodePage))
  372.                         continue;
  374.                     if (TRUE == FindCodePageFromRegistry(uiCodePage, &CPInfo))
  375.                     {
  376.                         _pCodePage[_cCodePage] = CPInfo;
  377.                         _cCodePage++;
  378.                     }
  379.                 }
  380.                 _fAllCPCached = TRUE;
  381.                 RegCloseKey(hKey);
  382.                 hKey = NULL;
  383.             }
  384.             if (0 < _cCodePage)
  385.                 QSortCodePageInfo(0, _cCodePage-1);
  387.             // Fill empty font face field base on its FamilyCodePage
  388.             for (UINT i = 0; i < _cCodePage; i++)
  389.             {
  390.                 UINT uiFamily;
  391.                 WCHAR wszFixed[MAX_MIMEFACE_NAME], wszProp[MAX_MIMEFACE_NAME];
  393.                 uiFamily = 0;
  394.                 wszFixed[0] = wszProp[0] = TEXT('');
  396.                 if (TEXT('') == _pCodePage[i].wszFixedWidthFont[0] || TEXT('') == _pCodePage[i].wszProportionalFont[0])
  397.                 {
  398.                     if (uiFamily != _pCodePage[i].uiFamilyCodePage)
  399.                     {
  400.                         for (UINT j = 0; j < _cCodePage; j++)
  401.                         {
  402.                             if (_pCodePage[i].uiFamilyCodePage == _pCodePage[j].uiCodePage)
  403.                             {
  404.                                 uiFamily = _pCodePage[j].uiCodePage;
  405.                                 MLStrCpyNW(wszFixed, _pCodePage[j].wszFixedWidthFont, MAX_MIMEFACE_NAME);
  406.                                 MLStrCpyNW(wszProp, _pCodePage[j].wszProportionalFont, MAX_MIMEFACE_NAME);
  407.                                 break;
  408.                             }
  409.                         }                
  410.                     }
  411.                     MLStrCpyNW(_pCodePage[i].wszFixedWidthFont, wszFixed, MAX_MIMEFACE_NAME);
  412.                     MLStrCpyNW(_pCodePage[i].wszProportionalFont, wszProp, MAX_MIMEFACE_NAME);
  413.                 }
  414.             }
  415.         }
  416.         else
  417.         {
  418.             hr = E_OUTOFMEMORY;
  419.         }
  420.     }
  421.     LeaveCriticalSection(&_cs);
  423.     return hr;
  424. }
  426. STDAPI CMimeDatabaseReg::GetNumberOfCodePageInfo(UINT *pcCodePage)
  427. {
  428.     EnterCriticalSection(&_cs);
  429.     if (NULL == _pCodePage)
  430.         BuildCodePageMimeDatabase();
  431.     *pcCodePage = _cMaxCodePage;
  432.     LeaveCriticalSection(&_cs);
  433.     return NOERROR;
  434. }
  436. STDAPI CMimeDatabaseReg::GetCodePageInfo(UINT uiCodePage, PMIMECPINFO pcpInfo)
  437. {
  438.     int idx;
  439.     HRESULT hr = E_FAIL;
  441.     DebugMsg(DM_TRACE, TEXT("CMimeDatabase::GetCodePageInfo called."));
  442.     if (NULL != pcpInfo)
  443.     {
  444.         EnterCriticalSection(&_cs);
  445.         if (NULL == _pCodePage)
  446.             BuildCodePageMimeDatabase();
  448.         if (_pCodePage)
  449.         {
  450.             idx = FindCodePageFromCache(uiCodePage);
  451.             if (0 > idx)
  452.             {
  453.                 MIMECPINFO CPInfo = {0};
  455.                 if (TRUE == FindCodePageFromRegistry(uiCodePage, &CPInfo))
  456.                 {
  457.                     if (CPInfo.uiCodePage != CPInfo.uiFamilyCodePage)
  458.                     {
  459.                         idx = FindCodePageFromCache(CPInfo.uiFamilyCodePage);
  460.                         if (0 > idx)
  461.                         {
  462.                             MIMECPINFO FamilyCPInfo;
  464.                             if (TRUE == FindCodePageFromRegistry(CPInfo.uiFamilyCodePage, &FamilyCPInfo))
  465.                             {
  466.                                 idx = _cCodePage;
  467.                                 _pCodePage[_cCodePage] = FamilyCPInfo;
  468.                                 _cCodePage++;
  469.                             }
  470.                         }
  471.                         MLStrCpyNW(CPInfo.wszFixedWidthFont, _pCodePage[idx].wszFixedWidthFont, MAX_MIMEFACE_NAME);
  472.                         MLStrCpyNW(CPInfo.wszProportionalFont, _pCodePage[idx].wszProportionalFont, MAX_MIMEFACE_NAME);
  473.                     }
  474.                     _pCodePage[_cCodePage] = CPInfo;
  475.                     _cCodePage++;
  476.                     QSortCodePageInfo(0, _cCodePage-1);
  477.                     idx = FindCodePageFromCache(uiCodePage);
  478.                 }
  479.             }
  480.             if (0 <= idx)
  481.             {
  482.                 *pcpInfo = _pCodePage[idx];
  483.                 hr = S_OK;
  484.             }
  485.             LeaveCriticalSection(&_cs);
  486.         }
  487.     }
  488.     return hr;
  489. }
  491. int CMimeDatabaseReg::FindCodePageFromCache(UINT uiCodePage)
  492. {
  493.     UINT i;
  494.     int iRet = -1;
  496.     for (i = 0; i < _cCodePage; i++)
  497.     {
  498.         if (_pCodePage[i].uiCodePage == uiCodePage)
  499.         {
  500.             iRet = i;
  501.             break;
  502.         }
  503.     }
  504.     return iRet;
  505. }
  507. BOOL CMimeDatabaseReg::FindCodePageFromRegistry(UINT uiCodePage, PMIMECPINFO pcpInfo)
  508. {
  509.     HKEY hKey;
  510.     DWORD dw, cb;
  511.     TCHAR szKey[256],  sz[MAX_MIMECP_NAME];
  512.     BOOL fRet = FALSE;
  513.     static UINT s_uiCP = GetACP();
  515.     wsprintf(szKey, TEXT("%s\%d"), REGSTR_KEY_MIME_DATABASE_CODEPAGE, uiCodePage);
  516.     if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_CLASSES_ROOT, szKey, 0, KEY_READ, &hKey))
  517.     {
  518.         TCHAR *psz, *pszComma;
  519.         CHARSETINFO rCharsetInfo;
  521.         pcpInfo->uiCodePage = uiCodePage;
  523.         cb = sizeof(dw);
  524.         if (ERROR_SUCCESS == RegQueryValueEx(hKey, REGSTR_VAL_FAMILY, 0, NULL, (LPBYTE)&dw, &cb))
  525.             pcpInfo->uiFamilyCodePage = (UINT)dw;
  526.         else
  527.             pcpInfo->uiFamilyCodePage = pcpInfo->uiCodePage;
  529.         cb = sizeof(dw);
  530.         if (ERROR_SUCCESS == RegQueryValueEx(hKey, REGSTR_VAL_LEVEL, 0, NULL, (LPBYTE)&dw, &cb))
  531. #ifdef UNIX
  532.         {
  533.            BYTE* px = (BYTE*)&dw;
  534.            pcpInfo->dwFlags = CONVERTLONG(px[0], px[1], px[2], px[3]);
  535.         }
  536. #else
  537.             pcpInfo->dwFlags = dw;
  538. #endif /* UNIX */
  539.         else
  540.             pcpInfo->dwFlags = 0;
  542.         cb = sizeof(sz);
  543.         if (ERROR_SUCCESS == RegQueryValueEx(hKey, REGSTR_VAL_DESCRIPTION, NULL, NULL, (LPBYTE)sz, &cb))
  544.             MultiByteToWideChar(CP_ACP, 0, sz, -1, pcpInfo->wszDescription, ARRAYSIZE(pcpInfo->wszDescription));
  545.         else
  546.         {
  547.             TCHAR szDef[MAX_MIMECP_NAME];
  549.             LoadString(g_hInst, IDS_MIME_LANG_DEFAULT, szDef, ARRAYSIZE(szDef));
  550.             wsprintf(sz, szDef, pcpInfo->uiCodePage);
  551.             MultiByteToWideChar(CP_ACP, 0, sz, -1, pcpInfo->wszDescription, ARRAYSIZE(pcpInfo->wszDescription));
  552.         }
  554.         cb = sizeof(sz);
  555.         if (ERROR_SUCCESS == RegQueryValueEx(hKey, REGSTR_VAL_FIXEDWIDTHFONT, NULL, NULL, (LPBYTE)sz, &cb))
  556.         {
  557.             psz = sz;
  558.             pszComma =  MLStrChr(sz, TEXT(','));
  559.             if (NULL != pszComma)               // If there are multiple font name
  560.             {
  561.                 if (uiCodePage != s_uiCP)
  562.                     psz = pszComma + 1;         // Take right side(English) fontname for non-native codepage info
  563.                 else
  564.                     *pszComma = TEXT('');     // Take left side(DBCS) fontname for native codepage info
  565.             }
  566.             if (lstrlen(psz) >= MAX_MIMEFACE_NAME)
  567.                 psz[MAX_MIMEFACE_NAME-1] = TEXT('');
  568.             MultiByteToWideChar(CP_ACP, 0, psz, -1, pcpInfo->wszFixedWidthFont, ARRAYSIZE(pcpInfo->wszFixedWidthFont));
  569.         }
  570.         else
  571.             pcpInfo->wszFixedWidthFont[0] = L'';
  573.         cb = sizeof(sz);
  574.         if (ERROR_SUCCESS == RegQueryValueEx(hKey, REGSTR_VAL_PROPORTIONALFONT, NULL, NULL, (LPBYTE)sz, &cb))
  575.         {
  576.             psz = sz;
  577.             pszComma = MLStrChr(sz, TEXT(','));
  578.             if (NULL != pszComma)               // If there are multiple font name
  579.             {
  580.                 if (uiCodePage != s_uiCP)
  581.                     psz = pszComma + 1;         // Take right side(English) fontname for non-native codepage info
  582.                 else
  583.                     *pszComma = TEXT('');     // Take left side(DBCS) fontname for native codepage info
  584.             }
  585.             if (lstrlen(psz) >= MAX_MIMEFACE_NAME)
  586.                 psz[MAX_MIMEFACE_NAME-1] = TEXT('');
  587.             MultiByteToWideChar(CP_ACP, 0, psz, -1, pcpInfo->wszProportionalFont, ARRAYSIZE(pcpInfo->wszProportionalFont));
  588.         }
  589.         else
  590.             pcpInfo->wszProportionalFont[0] = L'';
  592.         cb = sizeof(sz);
  593.         if (ERROR_SUCCESS == RegQueryValueEx(hKey, REGSTR_VAL_BODYCHARSET, NULL, NULL, (LPBYTE)sz, &cb))
  594.             MultiByteToWideChar(CP_ACP, 0, sz, -1, pcpInfo->wszBodyCharset, ARRAYSIZE(pcpInfo->wszBodyCharset));
  595.         else
  596.             pcpInfo->wszBodyCharset[0] = L'';
  598.         cb = sizeof(sz);
  599.         if (ERROR_SUCCESS == RegQueryValueEx(hKey, REGSTR_VAL_HEADERCHARSET, NULL, NULL, (LPBYTE)sz, &cb))
  600.             MultiByteToWideChar(CP_ACP, 0, sz, -1, pcpInfo->wszHeaderCharset, ARRAYSIZE(pcpInfo->wszHeaderCharset));
  601.         else
  602.             MLStrCpyNW(pcpInfo->wszHeaderCharset, pcpInfo->wszBodyCharset, MAX_MIMECSET_NAME);
  604.         cb = sizeof(sz);
  605.         if (ERROR_SUCCESS == RegQueryValueEx(hKey, REGSTR_VAL_WEBCHARSET, NULL, NULL, (LPBYTE)sz, &cb))
  606.             MultiByteToWideChar(CP_ACP, 0, sz, -1, pcpInfo->wszWebCharset, ARRAYSIZE(pcpInfo->wszWebCharset));
  607.         else
  608.             MLStrCpyNW(pcpInfo->wszWebCharset, pcpInfo->wszBodyCharset, MAX_MIMECSET_NAME);
  610.         cb = sizeof(sz);
  611.         if (ERROR_SUCCESS == RegQueryValueEx(hKey, REGSTR_VAL_PRIVCONVERTER, NULL, NULL, (LPBYTE)sz, &cb))
  612.             pcpInfo->dwFlags |= MIMECONTF_PRIVCONVERTER;
  614.         if (0 != TranslateCharsetInfo((LPDWORD)pcpInfo->uiFamilyCodePage, &rCharsetInfo, TCI_SRCCODEPAGE))
  615.             pcpInfo->bGDICharset = (BYTE)rCharsetInfo.ciCharset;
  616.         else
  617.             pcpInfo->bGDICharset = DEFAULT_CHARSET;
  620.         if (1200 == pcpInfo->uiFamilyCodePage || 50000 == pcpInfo->uiFamilyCodePage || TRUE == _IsValidCodePage(pcpInfo->uiFamilyCodePage)) // 50000 means user defined
  621.         {
  622.             if (TRUE == CheckFont(pcpInfo->bGDICharset))
  623.             {
  624.                 if (pcpInfo->uiCodePage == pcpInfo->uiFamilyCodePage || TRUE == _IsValidCodePage(pcpInfo->uiCodePage))
  625.                     pcpInfo->dwFlags |= MIMECONTF_VALID|MIMECONTF_VALID;
  626.                 else if (S_OK == IsConvertINetStringAvailable(pcpInfo->uiCodePage, pcpInfo->uiFamilyCodePage))
  627.                     pcpInfo->dwFlags |= MIMECONTF_VALID|MIMECONTF_VALID;
  628.             }
  629.             else
  630.             {
  631.                 if (pcpInfo->uiCodePage == pcpInfo->uiFamilyCodePage || TRUE == _IsValidCodePage(pcpInfo->uiCodePage))
  632.                     pcpInfo->dwFlags |= MIMECONTF_VALID_NLS;
  633.                 else if (S_OK == IsConvertINetStringAvailable(pcpInfo->uiCodePage, pcpInfo->uiFamilyCodePage))
  634.                     pcpInfo->dwFlags |= MIMECONTF_VALID_NLS;
  635.             }
  637.         }
  638.         RegCloseKey(hKey);
  639.         fRet = TRUE;
  640.     }
  641.     return fRet;
  642. }
  644. STDAPI CMimeDatabaseReg::GetCodePageInfoWithIndex(UINT uidx, PMIMECPINFO pcpInfo)
  645. {
  646.     HRESULT hr = NOERROR;
  648.     DebugMsg(DM_TRACE, TEXT("CMimeDatabase::GetCodePageInfoWithIndex called."));
  649.     EnterCriticalSection(&_cs);
  650.     if (NULL == _pCodePage)
  651.         BuildCodePageMimeDatabase();
  652.     if (uidx < _cCodePage && _pCodePage)
  653.         *pcpInfo = _pCodePage[uidx];
  654.     else
  655.         hr = E_FAIL;
  656.     LeaveCriticalSection(&_cs);
  657.     return hr;
  658. }
  660. STDAPI CMimeDatabaseReg::GetCharsetInfo(BSTR Charset, PMIMECSETINFO pcsetInfo)
  661. {
  662.     int idx;
  663.     HRESULT hr = E_FAIL;
  665.     DebugMsg(DM_TRACE, TEXT("CMimeDatabase::GetCharsetInfo called."));
  666.     if (NULL != pcsetInfo)
  667.     {
  668.         EnterCriticalSection(&_cs);
  669.         if (NULL == _pCharset)
  670.             BuildCharsetMimeDatabase();
  671.         if (_pCharset)
  672.         {
  673.             idx = FindCharsetFromCache(Charset);
  674.             if (0 > idx)
  675.                 idx = FindCharsetFromRegistry(Charset, FALSE);
  676.             if (0 <= idx)
  677.             {
  678.                 *pcsetInfo = _pCharset[idx];
  679.                 hr = S_OK;
  680.             }
  681.         }
  682.         LeaveCriticalSection(&_cs);
  683.     }
  684.     return hr;
  685. }
  687. int CMimeDatabaseReg::FindCharsetFromCache(BSTR Charset)
  688. {
  689.     int iStart, iEnd, iMiddle, iCmpResult, iRet = -1;
  691.     iStart = 0;
  692.     iEnd = _cCharset - 1;
  693.     while (iStart <= iEnd)
  694.     {
  695.         iMiddle = (iStart + iEnd) / 2;
  696.         iCmpResult = MLStrCmpIW(Charset, _pCharset[iMiddle].wszCharset);
  697.         if (iCmpResult < 0)
  698.             iEnd = iMiddle - 1;
  699.         else if (iCmpResult > 0)
  700.             iStart = iMiddle + 1;
  701.         else
  702.         {
  703.             iRet = iMiddle;
  704.             break;
  705.         }
  706.     }
  707.     return iRet;
  708. }
  710. int CMimeDatabaseReg::FindCharsetFromRegistry(BSTR Charset, BOOL fFromAlias)
  711. {
  712.     HKEY hKey;
  713.     TCHAR szKey[256], szCharset[MAX_MIMECSET_NAME];
  714.     int iRet = -1;
  716.     WideCharToMultiByte(CP_ACP, 0, Charset, -1, szCharset, ARRAYSIZE(szCharset), NULL, NULL);
  717.     lstrcpy(szKey, REGSTR_KEY_MIME_DATABASE_CHARSET);
  718.     lstrcat(szKey, TEXT("\"));
  719.     lstrcat(szKey, szCharset);
  720.     if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_CLASSES_ROOT, szKey, 0, KEY_READ, &hKey))
  721.     {
  722.         DWORD cb, dw;
  723.         TCHAR sz[MAX_MIMECSET_NAME];
  724.         WCHAR wsz[MAX_MIMECSET_NAME];
  726.         cb = sizeof(sz);
  727.         if (FALSE == fFromAlias && ERROR_SUCCESS == RegQueryValueEx(hKey, REGSTR_VAL_ALIASTO, NULL, NULL, (LPBYTE)sz, &cb))
  728.         {
  729.             MultiByteToWideChar(CP_ACP, 0, sz, -1, wsz, ARRAYSIZE(wsz));
  730.             iRet = FindCharsetFromCache(wsz);
  731.             if (0 > iRet)
  732.                 iRet = FindCharsetFromRegistry(wsz, TRUE);
  733.             if (0 <= iRet)
  734.             {
  735.                 MLStrCpyNW(_pCharset[_cCharset].wszCharset, Charset, MAX_MIMECSET_NAME);
  736.                 _pCharset[_cCharset].uiCodePage = _pCharset[iRet].uiCodePage;
  737.                 _pCharset[_cCharset].uiInternetEncoding = _pCharset[iRet].uiInternetEncoding;
  738.                 _cCharset++;
  739.                 QSortCharsetInfo(0, _cCharset-1);
  740.                 iRet = FindCharsetFromCache(Charset);
  741.             }
  742.         }
  743.         else
  744.         {
  745.             MLStrCpyNW(_pCharset[_cCharset].wszCharset, Charset, MAX_MIMECSET_NAME);
  746.             cb = sizeof(dw);
  747.             if (ERROR_SUCCESS == RegQueryValueEx(hKey, REGSTR_VAL_CODEPAGE, 0, NULL, (LPBYTE)&dw, &cb))
  748.             {
  749.                 _pCharset[_cCharset].uiCodePage = (UINT)dw;
  750.                 cb = sizeof(dw);
  751.                 if (ERROR_SUCCESS == RegQueryValueEx(hKey, REGSTR_VAL_INETENCODING, 0, NULL, (LPBYTE)&dw, &cb))
  752.                 {
  753.                     _pCharset[_cCharset].uiInternetEncoding = (UINT)dw;
  754.                     _cCharset++;
  755.                     QSortCharsetInfo(0, _cCharset-1);
  756.                     iRet = FindCharsetFromCache(Charset);
  757.                 }
  758.             }
  759.         }
  760.         RegCloseKey(hKey);
  761.     }
  762.     return iRet;
  763. }
  766. BOOL CMimeDatabaseReg::CheckFont(BYTE bGDICharset)
  767. {
  768.     BOOL fRet = FALSE;
  770.     DebugMsg(DM_TRACE, TEXT("CMimeDatabase::CheckFont called."));
  771.     if (DEFAULT_CHARSET == bGDICharset)
  772.         fRet = TRUE;
  773.     else
  774.     {
  775.         HDC     hDC;
  776.         LOGFONT lf;
  777.         HWND    hWnd;
  779.         hWnd = GetTopWindow(GetDesktopWindow());
  780.         hDC = GetDC(hWnd);
  782.         if (NULL != hDC)
  783.         {
  784.             lf.lfFaceName[0] = TEXT('');
  785.             lf.lfPitchAndFamily = 0;
  786.             lf.lfCharSet = bGDICharset;
  787.             EnumFontFamiliesEx(hDC, &lf, (FONTENUMPROC)EnumFontFamExProc, (LPARAM)&fRet, 0);
  788.         }
  789.         ReleaseDC(hWnd, hDC);
  790.     }
  791.     return fRet;
  792. }
  794. void CMimeDatabaseReg::QSortCodePageInfo(LONG left, LONG right)
  795. {
  796.     register LONG i, j;
  797.     WCHAR k[MAX_MIMECP_NAME];
  798.     MIMECPINFO t;
  800.     DebugMsg(DM_TRACE, TEXT("CMimeDatabase::QSortCodePageInfo called."));
  801.     i = left;
  802.     j = right;
  803.     MLStrCpyW(k, _pCodePage[(left + right) / 2].wszDescription);
  805.     do  
  806.     {
  807.         while(MLStrCmpIW(_pCodePage[i].wszDescription, k) < 0 && i < right)
  808.             i++;
  809.         while (MLStrCmpIW(_pCodePage[j].wszDescription, k) > 0 && j > left)
  810.             j--;
  812.         if (i <= j)
  813.         {
  814.             t = _pCodePage[i];
  815.             _pCodePage[i] = _pCodePage[j];
  816.             _pCodePage[j] = t;
  817.             i++; j--;
  818.         }
  820.     } while (i <= j);
  822.     if (left < j)
  823.         QSortCodePageInfo(left, j);
  824.     if (i < right)
  825.         QSortCodePageInfo(i, right);
  826. }
  828. void CMimeDatabaseReg::QSortCharsetInfo(LONG left, LONG right)
  829. {
  830.     register LONG i, j;
  831.     WCHAR k[MAX_MIMECSET_NAME];
  832.     MIMECSETINFO t;
  834.     DebugMsg(DM_TRACE, TEXT("CMimeDatabase::QSortCharsetInfo called."));
  835.     i = left;
  836.     j = right;
  837.     MLStrCpyW(k, _pCharset[(left + right) / 2].wszCharset);
  839.     do  
  840.     {
  841.         while(MLStrCmpIW(_pCharset[i].wszCharset, k) < 0 && i < right)
  842.             i++;
  843.         while (MLStrCmpIW(_pCharset[j].wszCharset, k) > 0 && j > left)
  844.             j--;
  846.         if (i <= j)
  847.         {
  848.             t = _pCharset[i];
  849.             _pCharset[i] = _pCharset[j];
  850.             _pCharset[j] = t;
  851.             i++; j--;
  852.         }
  854.     } while (i <= j);
  856.     if (left < j)
  857.         QSortCharsetInfo(left, j);
  858.     if (i < right)
  859.         QSortCharsetInfo(i, right);
  860. }
  862. // validates all cps that are in the same
  863. // family of the given codepage
  864. STDAPI CMimeDatabaseReg::ValidateCP(UINT uiCodePage)
  865. {
  866.     UINT i;
  868.     if (NULL == _pCodePage)
  869.         BuildCodePageMimeDatabase();
  870.     //
  871.     // just look into already cached codepages
  872.     // 
  873.     for (i = 0; i < _cCodePage; i++)
  874.     {
  875.         if (_pCodePage[i].uiFamilyCodePage == uiCodePage)
  876.             _pCodePage[i].dwFlags |=  MIMECONTF_VALID|MIMECONTF_VALID_NLS;
  877.     }
  878.         
  879.     return S_OK; // never fail?
  880. }