Category

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

Windows Kernel

Development Platform:

Visual C++

mlstra.cpp：Code Content
  1. // MLStrA.cpp : Implementation of CMLStrA
  2. #include "private.h"
  4. #ifndef NEWMLSTR
  6. #include "mlstr.h"
  7. #ifdef ASTRIMPL
  8. #include "mlswalk.h"
  9. #include "mlsbwalk.h"
  10. #endif
  12. /////////////////////////////////////////////////////////////////////////////
  13. // CMLStrA
  15. #ifdef ASTRIMPL
  16. CMLStrA::CMLStrA(void) :
  17.     m_pMLCPs(NULL)
  18. {
  19. }
  21. CMLStrA::~CMLStrA(void)
  22. {
  23.     if (m_pMLCPs)
  24.         m_pMLCPs->Release();
  25. }
  26. #endif
  28. STDMETHODIMP CMLStrA::Sync(BOOL fNoAccess)
  29. {
  30.     ASSERT_THIS;
  31.     return GetOwner()->Sync(fNoAccess);
  32. }
  34. STDMETHODIMP CMLStrA::GetLength(long* plLen)
  35. {
  36.     ASSERT_THIS;
  37.     return GetOwner()->GetLength(plLen);
  38. }
  40. STDMETHODIMP CMLStrA::SetMLStr(long lDestPos, long lDestLen, IUnknown* pSrcMLStr, long lSrcPos, long lSrcLen)
  41. {
  42.     ASSERT_THIS;
  43.     return GetOwner()->SetMLStr(lDestPos, lDestLen, pSrcMLStr, lSrcPos, lSrcLen);
  44. }
  46. STDMETHODIMP CMLStrA::GetMLStr(long lSrcPos, long lSrcLen, IUnknown* pUnkOuter, DWORD dwClsContext, const IID* piid, IUnknown** ppDestMLStr, long* plDestPos, long* plDestLen)
  47. {
  48.     ASSERT_THIS;
  49.     return GetOwner()->GetMLStr(lSrcPos, lSrcLen, pUnkOuter, dwClsContext, piid, ppDestMLStr, plDestPos, plDestLen);
  50. }
  52. STDMETHODIMP CMLStrA::SetAStr(long lDestPos, long lDestLen, UINT uCodePage, const CHAR* pszSrc, long cchSrc, long* pcchActual, long* plActualLen)
  53. {
  54. #ifdef ASTRIMPL
  55.     ASSERT_THIS;
  56.     ASSERT_READ_BLOCK(pszSrc, cchSrc);
  57.     ASSERT_WRITE_PTR_OR_NULL(pcchActual);
  58.     ASSERT_WRITE_PTR_OR_NULL(plActualLen);
  60.     POWNER const pOwner = GetOwner();
  61.     HRESULT hr = pOwner->CheckThread();
  62.     CMLStr::CLock Lock(TRUE, pOwner, hr);
  63.     long cchDestPos;
  64.     long cchDestLen;
  65.     long cchActual;
  66.     long lActualLen;
  68.     if (SUCCEEDED(hr) && (pOwner->GetBufFlags() & MLSTR_WRITE))
  69.         hr = E_INVALIDARG; // Not writable StrBuf; TODO: Replace StrBuf in this case if allowed
  71.     if (SUCCEEDED(hr) &&
  72.         SUCCEEDED(hr = pOwner->PrepareMLStrBuf()) &&
  73.         SUCCEEDED(hr = pOwner->RegularizePosLen(&lDestPos, &lDestLen)) &&
  74.         SUCCEEDED(hr = pOwner->GetCCh(0, lDestPos, &cchDestPos)) &&
  75.         SUCCEEDED(hr = pOwner->GetCCh(cchDestPos, lDestLen, &cchDestLen)))
  76.     {
  77.         IMLangStringBufA* const pMLStrBufA = pOwner->GetMLStrBufA();
  79.         if (uCodePage == CP_ACP)
  80.             uCodePage = ::GetACP();
  82.         if (pMLStrBufA && uCodePage == pOwner->GetCodePage())
  83.         {
  84.             if (cchSrc > cchDestLen)
  85.             {
  86.                 hr = pMLStrBufA->Insert(cchDestPos, cchSrc - cchDestLen, (pcchActual || plActualLen) ? &cchSrc : NULL);
  87.                 cchSrc += cchDestLen;
  88.             }
  89.             else if  (cchSrc < cchDestLen)
  90.             {
  91.                 hr = pMLStrBufA->Delete(cchDestPos, cchDestLen - cchSrc);
  92.             }
  94.             CMLStrBufWalkA BufWalk(pMLStrBufA, cchDestPos, cchSrc, (pcchActual || plActualLen));
  96.             lActualLen = 0;
  97.             while (BufWalk.Lock(hr))
  98.             {
  99.                 long lLen;
  101.                 if (plActualLen)
  102.                     hr = pOwner->CalcLenA(uCodePage, pszSrc, BufWalk.GetCCh(), &lLen);
  104.                 if (SUCCEEDED(hr))
  105.                 {
  106.                     lActualLen += lLen;
  107.                     ::memcpy(BufWalk.GetStr(), pszSrc, sizeof(CHAR) * BufWalk.GetCCh());
  108.                     pszSrc += BufWalk.GetCCh();
  109.                 }
  111.                 BufWalk.Unlock(hr);
  112.             }
  114.             cchActual = BufWalk.GetDoneCCh();
  115.         }
  116.         else
  117.         {
  118.             IMLangStringWStr* pMLStrW;
  120.             if (SUCCEEDED(hr = pOwner->QueryInterface(IID_IMLangStringWStr, (void**)&pMLStrW)))
  121.             {
  122.                 CMLStrWalkW StrWalk(pMLStrW, lDestPos, lDestLen, MLSTR_WRITE, (pcchActual || plActualLen));
  124.                 cchActual = 0;
  125.                 lActualLen = 0;
  126.                 while (StrWalk.Lock(hr))
  127.                 {
  128.                     long cchWrittenA;
  129.                     long lWrittenLen;
  131.                     if (SUCCEEDED(hr = pOwner->ConvAStrToWStr(uCodePage, pszSrc, cchSrc, StrWalk.GetStr(), StrWalk.GetCCh(), &cchWrittenA, NULL, &lWrittenLen)))
  132.                     {
  133.                         pszSrc += cchWrittenA;
  134.                         cchSrc -= cchWrittenA;
  135.                         cchActual += cchWrittenA;
  136.                         lActualLen += lWrittenLen;
  137.                     }
  139.                     StrWalk.Unlock(hr, lWrittenLen);
  140.                 }
  142.                 pMLStrW->Release();
  143.             }
  144.         }
  145.     }
  147.     if (SUCCEEDED(hr))
  148.     {
  149.         if (pcchActual)
  150.             *pcchActual = cchActual;
  151.         if (plActualLen)
  152.             *plActualLen = lActualLen;
  153.     }
  154.     else
  155.     {
  156.         if (pcchActual)
  157.             *pcchActual = 0;
  158.         if (plActualLen)
  159.             *plActualLen = 0;
  160.     }
  161.     return hr;
  162. #else
  163.     return E_NOTIMPL; // !ASTRIMPL
  164. #endif
  165. }
  167. STDMETHODIMP CMLStrA::SetStrBufA(long lDestPos, long lDestLen, UINT uCodePage, IMLangStringBufA* pSrcBuf, long* pcchActual, long* plActualLen)
  168. {
  169.     ASSERT_THIS;
  170.     return GetOwner()->SetStrBufCommon(this, lDestPos, lDestLen, uCodePage, NULL, pSrcBuf, pcchActual, plActualLen);
  171. }
  173. STDMETHODIMP CMLStrA::GetAStr(long lSrcPos, long lSrcLen, UINT uCodePageIn, UINT* puCodePageOut, CHAR* pszDest, long cchDest, long* pcchActual, long* plActualLen)
  174. {
  175.     ASSERT_THIS;
  176.     ASSERT_WRITE_PTR_OR_NULL(puCodePageOut);
  177.     ASSERT_WRITE_BLOCK_OR_NULL(pszDest, cchDest);
  178.     ASSERT_WRITE_PTR_OR_NULL(pcchActual);
  179.     ASSERT_WRITE_PTR_OR_NULL(plActualLen);
  181.     POWNER const pOwner = GetOwner();
  182.     HRESULT hr = pOwner->CheckThread();
  183. #ifdef ASTRIMPL
  184.     CMLStr::CLock Lock(FALSE, pOwner, hr);
  185. #endif
  186.     long cchSrcPos;
  187.     long cchSrcLen;
  188.     long cchActual;
  189.     long lActualLen;
  191. #ifndef ASTRIMPL
  192.     if (SUCCEEDED(hr = m_pOwner->CheckThread()) &&
  193.         (m_pOwner->IsLocked() || puCodePageOut || uCodePageIn != m_pOwner->GetCodePage())) // !ASTRIMPL
  194.     {
  195.         hr = E_INVALIDARG;
  196.     }
  197. #endif
  199.     if (SUCCEEDED(hr) &&
  200.         SUCCEEDED(hr = pOwner->RegularizePosLen(&lSrcPos, &lSrcLen)) &&
  201.         SUCCEEDED(hr = pOwner->GetCCh(0, lSrcPos, &cchSrcPos)) &&
  202.         SUCCEEDED(hr = pOwner->GetCCh(cchSrcPos, lSrcLen, &cchSrcLen)))
  203.     {
  204. #ifdef ASTRIMPL
  205.         IMLangStringBufA* const pMLStrBufA = pOwner->GetMLStrBufA();
  207.         if (pszDest)
  208.             cchActual = min(cchSrcLen, cchDest);
  209.         else
  210.             cchActual = cchSrcLen;
  212.         if (uCodePageIn == CP_ACP)
  213.             uCodePageIn = ::GetACP();
  215.         if (pMLStrBufA && (puCodePageOut || uCodePageIn == pOwner->GetCodePage()))
  216.         {
  217.             uCodePageIn = pOwner->GetCodePage();
  219.             CMLStrBufWalkA BufWalk(pMLStrBufA, cchSrcPos, cchActual, (pcchActual || plActualLen));
  221.             lActualLen = 0;
  222.             while (BufWalk.Lock(hr))
  223.             {
  224.                 long lLen;
  226.                 if (plActualLen)
  227.                     hr = pOwner->CalcLenA(uCodePageIn, BufWalk.GetStr(), BufWalk.GetCCh(), &lLen);
  229.                 if (SUCCEEDED(hr))
  230.                 {
  231.                     lActualLen += lLen;
  233.                     if (pszDest)
  234.                     {
  235.                         ::memcpy(pszDest, BufWalk.GetStr(), sizeof(CHAR) * BufWalk.GetCCh());
  236.                         pszDest += BufWalk.GetCCh();
  237.                     }
  238.                 }
  240.                 BufWalk.Unlock(hr);
  241.             }
  243.             cchActual = BufWalk.GetDoneCCh();
  244.         }
  245.         else
  246.         {
  247.             IMLangStringWStr* pMLStrW;
  249.             if (SUCCEEDED(hr = pOwner->QueryInterface(IID_IMLangStringWStr, (void**)&pMLStrW)))
  250.             {
  251.                 BOOL fDontHaveCodePageIn = (puCodePageOut != 0);
  252.                 CMLStrWalkW StrWalk(pMLStrW, lSrcPos, lSrcLen, (pcchActual || plActualLen));
  254.                 cchActual = 0;
  255.                 while (StrWalk.Lock(hr))
  256.                 {
  257.                     LCID locale;
  258.                     UINT uLocaleCodePage;
  259.                     DWORD dwLocaleCodePages;
  260.                     DWORD dwStrCodePages;
  261.                     long cchWritten;
  262.                     long lWrittenLen;
  264.                     if (fDontHaveCodePageIn &&
  265.                         SUCCEEDED(hr = pOwner->GetLocale(lSrcPos, lSrcLen, &locale, NULL, NULL)) &&
  266.                         SUCCEEDED(hr = ::LocaleToCodePage(locale, &uLocaleCodePage)) &&
  267.                         SUCCEEDED(hr = PrepareMLangCodePages()) &&
  268.                         SUCCEEDED(hr = GetMLangCodePages()->CodePageToCodePages(uLocaleCodePage, &dwLocaleCodePages)) &&
  269.                         SUCCEEDED(hr = GetMLangCodePages()->GetStrCodePages(StrWalk.GetStr(), StrWalk.GetCCh(), dwLocaleCodePages, &dwStrCodePages, NULL)))
  270.                     {
  271.                         fDontHaveCodePageIn = FALSE;
  272.                         hr = GetMLangCodePages()->CodePagesToCodePage(dwStrCodePages, uLocaleCodePage, &uCodePageIn);
  273.                     }
  275.                     if (SUCCEEDED(hr) &&
  276.                         SUCCEEDED(hr = pOwner->ConvWStrToAStr(pcchActual || plActualLen, uCodePageIn, StrWalk.GetStr(), StrWalk.GetCCh(), pszDest, cchDest, &cchWritten, NULL, &lWrittenLen)))
  277.                     {
  278.                         pszDest += cchWritten;
  279.                         cchDest -= cchWritten;
  280.                         cchActual += cchWritten;
  281.                     }
  283.                     StrWalk.Unlock(hr, lWrittenLen);
  284.                 }
  286.                 lActualLen = StrWalk.GetDoneLen();
  288.                 pMLStrW->Release();
  289.             }
  290.         }
  291.     }
  292. #else
  293.         if (pszDest)
  294.         {
  295.             hr = E_FAIL; // TODO: Not implemented in this version
  296.         }
  297.         else
  298.         {
  299.             cchActual = cchSrcLen;
  300.         }
  301.     }
  303.     if (SUCCEEDED(hr) && plActualLen)
  304.         hr = m_pOwner->CalcLenA(m_pOwner->GetCodePage(), 0, cchActual, &lActualLen);
  305. #endif
  307.     if (SUCCEEDED(hr))
  308.     {
  309. #ifdef ASTRIMPL
  310.         if (puCodePageOut)
  311.             *puCodePageOut = uCodePageIn;
  312. #endif
  313.         if (pcchActual)
  314.             *pcchActual = cchActual;
  315.         if (plActualLen)
  316.             *plActualLen = lActualLen;
  317.     }
  318.     else
  319.     {
  320.         if (puCodePageOut)
  321.             *puCodePageOut = 0;
  322.         if (pcchActual)
  323.             *pcchActual = 0;
  324.         if (plActualLen)
  325.             *plActualLen = 0;
  326.     }
  328.     return hr;
  329. }
  331. STDMETHODIMP CMLStrA::GetStrBufA(long lSrcPos, long lSrcMaxLen, UINT* puDestCodePage, IMLangStringBufA** ppDestBuf, long* plDestLen)
  332. {
  333. #ifdef ASTRIMPL
  334.     ASSERT_THIS;
  335.     ASSERT_WRITE_PTR_OR_NULL(puDestCodePage);
  336.     ASSERT_WRITE_PTR_OR_NULL(ppDestBuf);
  337.     ASSERT_WRITE_PTR_OR_NULL(plDestLen);
  339.     POWNER const pOwner = GetOwner();
  340.     HRESULT hr = pOwner->CheckThread();
  341.     CMLStr::CLock Lock(FALSE, pOwner, hr);
  342.     IMLangStringBufA* pMLStrBufA;
  344.     if (SUCCEEDED(hr) &&
  345.         SUCCEEDED(hr = pOwner->RegularizePosLen(&lSrcPos, &lSrcMaxLen)) &&
  346.         lSrcMaxLen <= 0)
  347.     {
  348.         hr = E_INVALIDARG;
  349.     }
  351.     if (SUCCEEDED(hr))
  352.     {
  353.         pMLStrBufA = pOwner->GetMLStrBufA();
  354.         if (!pMLStrBufA)
  355.             hr = MLSTR_E_STRBUFNOTAVAILABLE;
  356.     }
  358.     if (SUCCEEDED(hr))
  359.     {
  360.         if (puDestCodePage)
  361.             *puDestCodePage = pOwner->GetCodePage();
  362.         if (ppDestBuf)
  363.         {
  364.             pMLStrBufA->AddRef();
  365.             *ppDestBuf = pMLStrBufA;
  366.         }
  367.         if (plDestLen)
  368.             *plDestLen = lSrcMaxLen;
  369.     }
  370.     else
  371.     {
  372.         if (puDestCodePage)
  373.             *puDestCodePage = 0;
  374.         if (ppDestBuf)
  375.             *ppDestBuf = NULL;
  376.         if (plDestLen)
  377.             *plDestLen = 0;
  378.     }
  380.     return hr;
  381. #else
  382.     return E_NOTIMPL; // !ASTRIMPL
  383. #endif
  384. }
  386. STDMETHODIMP CMLStrA::LockAStr(long lSrcPos, long lSrcLen, long lFlags, UINT uCodePageIn, long cchRequest, UINT* puCodePageOut, CHAR** ppszDest, long* pcchDest, long* plDestLen)
  387. {
  388. #ifdef ASTRIMPL
  389.     ASSERT_THIS;
  390.     ASSERT_WRITE_PTR_OR_NULL(puCodePageOut);
  391.     ASSERT_WRITE_PTR_OR_NULL(ppszDest);
  392.     ASSERT_WRITE_PTR_OR_NULL(pcchDest);
  393.     ASSERT_WRITE_PTR_OR_NULL(plDestLen);
  395.     POWNER const pOwner = GetOwner();
  396.     HRESULT hr = pOwner->CheckThread();
  397.     CMLStr::CLock Lock(lFlags & MLSTR_WRITE, pOwner, hr);
  398.     long cchSrcPos;
  399.     long cchSrcLen;
  400.     CHAR* pszBuf = NULL;
  401.     long cchBuf;
  402.     long lLockLen;
  403.     BOOL fDirectLock;
  405.     if (SUCCEEDED(hr) && (!lFlags || (lFlags & ~pOwner->GetBufFlags() & MLSTR_WRITE)))
  406.         hr = E_INVALIDARG; // No flags specified, or not writable StrBuf; TODO: Replace StrBuf in this case if allowed
  408.     if (!(lFlags & MLSTR_WRITE))
  409.         cchRequest = 0;
  411.     if (SUCCEEDED(hr) &&
  412.         SUCCEEDED(hr = pOwner->PrepareMLStrBuf()) &&
  413.         SUCCEEDED(hr = pOwner->RegularizePosLen(&lSrcPos, &lSrcLen)) &&
  414.         SUCCEEDED(hr = pOwner->GetCCh(0, lSrcPos, &cchSrcPos)) &&
  415.         SUCCEEDED(hr = pOwner->GetCCh(cchSrcPos, lSrcLen, &cchSrcLen)))
  416.     {
  417.         IMLangStringBufA* const pMLStrBufA = pOwner->GetMLStrBufA();
  418.         fDirectLock = (pMLStrBufA && (puCodePageOut || uCodePageIn == pOwner->GetCodePage()));
  420.         if (fDirectLock)
  421.         {
  422.             long cchInserted;
  423.             long cchLockLen = cchSrcLen;
  425.             if (puCodePageOut)
  426.                 hr = GetAStr(lSrcPos, lSrcLen, 0, &uCodePageIn, NULL, 0, NULL, NULL);
  428.             if (SUCCEEDED(hr) &&
  429.                 cchRequest > cchSrcLen &&
  430.                 SUCCEEDED(hr = pMLStrBufA->Insert(cchSrcPos + cchSrcLen, cchRequest - cchSrcLen, &cchInserted)))
  431.             {
  432.                 pOwner->SetBufCCh(pOwner->GetBufCCh() + cchInserted);
  433.                 cchLockLen += cchInserted;
  435.                 if (!pcchDest && cchLockLen < cchRequest)
  436.                     hr = E_OUTOFMEMORY; // Can't insert in StrBuf
  437.             }
  439.             if (SUCCEEDED(hr) &&
  440.                 SUCCEEDED(hr = pMLStrBufA->LockBuf(cchSrcPos, cchLockLen, &pszBuf, &cchBuf)) &&
  441.                 !pcchDest && cchBuf < max(cchSrcLen, cchRequest))
  442.             {
  443.                 hr = E_OUTOFMEMORY; // Can't lock StrBuf
  444.             }
  446.             if (plDestLen && SUCCEEDED(hr))
  447.                 hr = pOwner->CalcLenA(uCodePageIn, pszBuf, cchBuf, &lLockLen);
  448.         }
  449.         else
  450.         {
  451.             long cchSize;
  453.             if (SUCCEEDED(hr = pOwner->CalcBufSizeA(lSrcLen, &cchSize)))
  454.             {
  455.                 cchBuf = max(cchSize, cchRequest);
  456.                 hr = pOwner->MemAlloc(sizeof(*pszBuf) * cchBuf, (void**)&pszBuf);
  457.             }
  459.             if (SUCCEEDED(hr) && ((lFlags & MLSTR_READ) || puCodePageOut))
  460.                 hr = GetAStr(lSrcPos, lSrcLen,  uCodePageIn, (puCodePageOut) ? &uCodePageIn : NULL, (lFlags & MLSTR_READ) ? pszBuf : NULL, cchBuf, (pcchDest) ? &cchBuf : NULL, (plDestLen) ? &lLockLen : NULL);
  461.         }
  462.     }
  464.     if (SUCCEEDED(hr) &&
  465.         SUCCEEDED(hr = Lock.FallThrough()))
  466.     {
  467.         hr = pOwner->GetLockInfo()->Lock((fDirectLock) ? pOwner->UnlockAStrDirect : pOwner->UnlockAStrIndirect, lFlags, uCodePageIn, pszBuf, lSrcPos, lSrcLen, cchSrcPos, cchBuf);
  468.     }
  470.     if (SUCCEEDED(hr))
  471.     {
  472.         if (puCodePageOut)
  473.             *puCodePageOut = uCodePageIn;
  474.         if (ppszDest)
  475.             *ppszDest = pszBuf;
  476.         if (pcchDest)
  477.             *pcchDest = cchBuf;
  478.         if (plDestLen)
  479.             *plDestLen = lLockLen;
  480.     }
  481.     else
  482.     {
  483.         if (pszBuf)
  484.         {
  485.             if (fDirectLock)
  486.                 pOwner->GetMLStrBufA()->UnlockBuf(pszBuf, 0, 0);
  487.             else
  488.                 pOwner->MemFree(pszBuf);
  489.         }
  491.         if (puCodePageOut)
  492.             *puCodePageOut = 0;
  493.         if (ppszDest)
  494.             *ppszDest = NULL;
  495.         if (pcchDest)
  496.             *pcchDest = 0;
  497.         if (plDestLen)
  498.             *plDestLen = 0;
  499.     }
  501.     return hr;
  502. #else
  503.     return E_NOTIMPL; // !ASTRIMPL
  504. #endif
  505. }
  507. STDMETHODIMP CMLStrA::UnlockAStr(const CHAR* pszSrc, long cchSrc, long* pcchActual, long* plActualLen)
  508. {
  509. #ifdef ASTRIMPL
  510.     ASSERT_THIS;
  511.     ASSERT_READ_BLOCK(pszSrc, cchSrc);
  512.     ASSERT_WRITE_PTR_OR_NULL(pcchActual);
  513.     ASSERT_WRITE_PTR_OR_NULL(plActualLen);
  515.     return GetOwner()->UnlockStrCommon(pszSrc, cchSrc, pcchActual, plActualLen);
  516. #else
  517.     return E_NOTIMPL; // !ASTRIMPL
  518. #endif
  519. }
  521. STDMETHODIMP CMLStrA::SetLocale(long lDestPos, long lDestLen, LCID locale)
  522. {
  523.     ASSERT_THIS;
  524.     return GetOwner()->SetLocale(lDestPos, lDestLen, locale);
  525. }
  527. STDMETHODIMP CMLStrA::GetLocale(long lSrcPos, long lSrcMaxLen, LCID* plocale, long* plLocalePos, long* plLocaleLen)
  528. {
  529.     ASSERT_THIS;
  530.     return GetOwner()->GetLocale(lSrcPos, lSrcMaxLen, plocale, plLocalePos, plLocaleLen);
  531. }
  533. #else // NEWMLSTR
  535. #include "mlstr.h"
  537. /////////////////////////////////////////////////////////////////////////////
  538. // CMLStrA
  540. CMLStrA::CMLStrA(void) :
  541.     m_pAttrAStr(NULL),
  542.     m_pAttrLocale(NULL),
  543.     m_dwAttrAStrCookie(NULL),
  544.     m_dwAttrLocaleCookie(NULL)
  545. {
  546.     ::InitializeCriticalSection(&m_cs);
  547. }
  549. CMLStrA::~CMLStrA(void)
  550. {
  551.     if (m_dwAttrLocaleCookie)
  552.         GetOwner()->UnregisterAttr(m_dwAttrLocaleCookie);
  553.     if (m_dwAttrAStrCookie)
  554.         GetOwner()->UnregisterAttr(m_dwAttrAStrCookie);
  555.     if (m_pAttrLocale)
  556.         m_pAttrLocale->Release();
  557.     if (m_pAttrAStr)
  558.         m_pAttrAStr->Release();
  560.     ::DeleteCriticalSection(&m_cs);
  561. }
  563. HRESULT CMLStrA::GetAttrAStrReal(IMLStrAttrAStr** ppAttr)
  564. {
  565.     HRESULT hr = S_OK;
  567.     ::EnterCriticalSection(&m_cs);
  569.     if (!m_pAttrAStr)
  570.     {
  571.         IMLStrAttrAStr* pAttr;
  573.         hr = ::CoCreateInstance(CLSID_CMLStrAttrAStr, NULL, CLSCTX_ALL, IID_IUnknown, (void**)&pAttr);
  575.         if (SUCCEEDED(hr))
  576.             hr = GetOwner()->RegisterAttr(pAttr, &m_dwAttrAStrCookie);
  578.         if (SUCCEEDED(hr))
  579.         {
  580.             pAttr->Release();
  582.             hr = GetOwner()->FindAttr(IID_IMLStrAttrAStr, 0, (IUnknown**)&pAttr);
  583.         }
  585.         if (SUCCEEDED(hr))
  586.             m_pAttrAStr = pAttr;
  587.     }
  589.     if (ppAttr)
  590.         *ppAttr = m_pAttrAStr;
  592.     ::LeaveCriticalSection(&m_cs);
  594.     return hr;
  595. }
  597. HRESULT CMLStrA::GetAttrLocaleReal(IMLStrAttrLocale** ppAttr)
  598. {
  599.     HRESULT hr = S_OK;
  601.     ::EnterCriticalSection(&m_cs);
  603.     if (!m_pAttrLocale)
  604.     {
  605.         IMLStrAttrLocale* pAttr;
  607.         hr = ::CoCreateInstance(CLSID_CMLStrAttrLocale, NULL, CLSCTX_ALL, IID_IUnknown, (void**)&pAttr);
  609.         if (SUCCEEDED(hr))
  610.             hr = GetOwner()->RegisterAttr(pAttr, &m_dwAttrLocaleCookie);
  612.         if (SUCCEEDED(hr))
  613.         {
  614.             pAttr->Release();
  616.             hr = GetOwner()->FindAttr(IID_IMLStrAttrLocale, 0, (IUnknown**)&pAttr);
  617.         }
  619.         if (SUCCEEDED(hr))
  620.             m_pAttrLocale = pAttr;
  621.     }
  623.     if (ppAttr)
  624.         *ppAttr = m_pAttrLocale;
  626.     ::LeaveCriticalSection(&m_cs);
  628.     return hr;
  629. }
  631. STDMETHODIMP CMLStrA::LockMLStr(long lPos, long lLen, DWORD dwFlags, DWORD* pdwCookie, long* plActualPos, long* plActualLen)
  632. {
  633.     ASSERT_THIS;
  634.     return GetOwner()->LockMLStr(lPos, lLen, dwFlags, pdwCookie, plActualPos, plActualLen);
  635. }
  637. STDMETHODIMP CMLStrA::UnlockMLStr(DWORD dwCookie)
  638. {
  639.     ASSERT_THIS;
  640.     return GetOwner()->UnlockMLStr(dwCookie);
  641. }
  643. STDMETHODIMP CMLStrA::GetLength(long* plLen)
  644. {
  645.     ASSERT_THIS;
  646.     return GetOwner()->GetLength(plLen);
  647. }
  649. STDMETHODIMP CMLStrA::SetMLStr(long lDestPos, long lDestLen, IUnknown* pSrcMLStr, long lSrcPos, long lSrcLen)
  650. {
  651.     ASSERT_THIS;
  652.     return GetOwner()->SetMLStr(lDestPos, lDestLen, pSrcMLStr, lSrcPos, lSrcLen);
  653. }
  655. STDMETHODIMP CMLStrA::RegisterAttr(IUnknown* pUnk, DWORD* pdwCookie)
  656. {
  657.     ASSERT_THIS;
  658.     return GetOwner()->RegisterAttr(pUnk, pdwCookie);
  659. }
  661. STDMETHODIMP CMLStrA::UnregisterAttr(DWORD dwCookie)
  662. {
  663.     ASSERT_THIS;
  664.     return GetOwner()->UnregisterAttr(dwCookie);
  665. }
  667. STDMETHODIMP CMLStrA::EnumAttr(IEnumUnknown** ppEnumUnk)
  668. {
  669.     ASSERT_THIS;
  670.     return GetOwner()->EnumAttr(ppEnumUnk);
  671. }
  673. STDMETHODIMP CMLStrA::FindAttr(REFIID riid, LPARAM lParam, IUnknown** ppUnk)
  674. {
  675.     ASSERT_THIS;
  676.     return GetOwner()->FindAttr(riid, lParam, ppUnk);
  677. }
  679. STDMETHODIMP CMLStrA::SetAStr(long lDestPos, long lDestLen, UINT uCodePage, const CHAR* pszSrc, long cchSrc, long* pcchActual, long* plActualLen)
  680. {
  681.     ASSERT_THIS;
  683.     IMLStrAttrAStr* pAttr;
  684.     HRESULT hr = GetAttrAStr(&pAttr);
  686.     if (SUCCEEDED(hr))
  687.         hr = pAttr->SetAStr(lDestPos, lDestLen, uCodePage, pszSrc, cchSrc, pcchActual, plActualLen);
  689.     return hr;
  690. }
  692. STDMETHODIMP CMLStrA::SetStrBufA(long lDestPos, long lDestLen, UINT uCodePage, IMLangStringBufA* pSrcBuf, long* pcchActual, long* plActualLen)
  693. {
  694.     ASSERT_THIS;
  696.     IMLStrAttrAStr* pAttr;
  697.     HRESULT hr = GetAttrAStr(&pAttr);
  699.     if (SUCCEEDED(hr))
  700.         hr = pAttr->SetStrBufA(lDestPos, lDestLen, uCodePage, pSrcBuf, pcchActual, plActualLen);
  702.     return hr;
  703. }
  705. STDMETHODIMP CMLStrA::GetAStr(long lSrcPos, long lSrcLen, UINT uCodePageIn, UINT* puCodePageOut, CHAR* pszDest, long cchDest, long* pcchActual, long* plActualLen)
  706. {
  707.     ASSERT_THIS;
  709.     IMLStrAttrAStr* pAttr;
  710.     HRESULT hr = GetAttrAStr(&pAttr);
  712.     if (SUCCEEDED(hr))
  713.         hr = pAttr->GetAStr(lSrcPos, lSrcLen, uCodePageIn, puCodePageOut, pszDest, cchDest, pcchActual, plActualLen);
  715.     return hr;
  716. }
  718. STDMETHODIMP CMLStrA::GetStrBufA(long lSrcPos, long lSrcMaxLen, UINT* puDestCodePage, IMLangStringBufA** ppDestBuf, long* plDestLen)
  719. {
  720.     ASSERT_THIS;
  722.     IMLStrAttrAStr* pAttr;
  723.     HRESULT hr = GetAttrAStr(&pAttr);
  725.     if (SUCCEEDED(hr))
  726.         hr = pAttr->GetStrBufA(lSrcPos, lSrcMaxLen, puDestCodePage, ppDestBuf, plDestLen);
  728.     return hr;
  729. }
  731. STDMETHODIMP CMLStrA::LockAStr(long lSrcPos, long lSrcLen, long lFlags, UINT uCodePageIn, long cchRequest, UINT* puCodePageOut, CHAR** ppszDest, long* pcchDest, long* plDestLen)
  732. {
  733.     ASSERT_THIS;
  735.     IMLStrAttrAStr* pAttr;
  736.     HRESULT hr = GetAttrAStr(&pAttr);
  738.     if (SUCCEEDED(hr))
  739.         hr = pAttr->LockAStr(lSrcPos, lSrcLen, lFlags, uCodePageIn, cchRequest, puCodePageOut, ppszDest, pcchDest, plDestLen);
  741.     return hr;
  742. }
  744. STDMETHODIMP CMLStrA::UnlockAStr(const CHAR* pszSrc, long cchSrc, long* pcchActual, long* plActualLen)
  745. {
  746.     ASSERT_THIS;
  748.     IMLStrAttrAStr* pAttr;
  749.     HRESULT hr = GetAttrAStr(&pAttr);
  751.     if (SUCCEEDED(hr))
  752.         hr = pAttr->UnlockAStr(pszSrc, cchSrc, pcchActual, plActualLen);
  754.     return hr;
  755. }
  757. STDMETHODIMP CMLStrA::SetLocale(long lDestPos, long lDestLen, LCID locale)
  758. {
  759.     ASSERT_THIS;
  761.     IMLStrAttrLocale* pAttr;
  762.     HRESULT hr = GetAttrLocale(&pAttr);
  764.     if (SUCCEEDED(hr))
  765.         hr = pAttr->SetLong(lDestPos, lDestLen, (long)locale);
  767.     return hr;
  768. }
  770. STDMETHODIMP CMLStrA::GetLocale(long lSrcPos, long lSrcMaxLen, LCID* plocale, long* plLocalePos, long* plLocaleLen)
  771. {
  772.     ASSERT_THIS;
  774.     IMLStrAttrLocale* pAttr;
  775.     HRESULT hr = GetAttrLocale(&pAttr);
  777.     if (SUCCEEDED(hr))
  778.         hr = pAttr->GetLong(lSrcPos, lSrcMaxLen, (long*)plocale, plLocalePos, plLocaleLen);
  780.     return hr;
  781. }
  783. #endif NEWMLSTR