开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 系统编程 > 查看源码
attrstrw.cpp
资源名称：shell.rar　[点击查看]
上传用户：xhy777
上传日期：2007-02-14
资源大小：24088k
文件大小：16k
源码类别：

系统编程

开发平台：

Visual C++

attrstrw.cpp：源码内容
  1. // AttrStrW.cpp : Implementation of CMLStrAttrWStr
  2. #include "private.h"
  4. #ifdef NEWMLSTR
  6. #include "attrstrw.h"
  7. #include "mlsbwalk.h"
  9. /////////////////////////////////////////////////////////////////////////////
  10. // CMLStrAttrWStr
  12. CMLStrAttrWStr::CMLStrAttrWStr(void) :
  13.     m_pMLStr(NULL)
  14. {
  15. }
  17. CMLStrAttrWStr::~CMLStrAttrWStr(void)
  18. {
  19.     VERIFY(SetClient(NULL)); // Clean m_pMLStr
  20. }
  22. STDMETHODIMP CMLStrAttrWStr::SetClient(IUnknown* pUnk)
  23. {
  24.     ASSERT_THIS;
  25.     ASSERT_READ_PTR_OR_NULL(pUnk);
  27.     HRESULT hr = S_OK;
  29.     // Release old client
  30.     IMLangString* const pMLStr = m_pMLStr;
  31.     if (pMLStr && SUCCEEDED(hr = StartEndConnectionMLStr(pMLStr, FALSE))) // End connection to MLStr
  32.     {
  33.         pMLStr->Release();
  34.         m_pMLStr = NULL;
  35.     }
  37.     // Set new client
  38.     if (SUCCEEDED(hr) && pUnk) // pUnk is given
  39.     {
  40.         ASSERT(!m_pMLStr);
  41.         if (SUCCEEDED(hr = pUnk->QueryInterface(IID_IMLangString, (void**)&m_pMLStr)))
  42.         {
  43.             ASSERT_READ_PTR(m_pMLStr);
  44.             if (FAILED(hr = StartEndConnectionMLStr(pUnk, TRUE))) // Start connection to MLStr
  45.             {
  46.                 m_pMLStr->Release();
  47.                 m_pMLStr = NULL;
  48.             }
  49.         }
  50.     }
  52.     return hr;
  53. }
  55. HRESULT CMLStrAttrWStr::StartEndConnectionMLStr(IUnknown* const pUnk, BOOL fStart)
  56. {
  57.     ASSERT_THIS;
  58.     ASSERT_READ_PTR(pUnk);
  60.     HRESULT hr;
  61.     IConnectionPointContainer* pCPC;
  63.     if (SUCCEEDED(hr = pUnk->QueryInterface(IID_IConnectionPointContainer, (void**)&pCPC)))
  64.     {
  65.         ASSERT_READ_PTR(pCPC);
  67.         IConnectionPoint* pCP;
  69.         if (SUCCEEDED(hr = pCPC->FindConnectionPoint(IID_IMLangStringNotifySink, &pCP)))
  70.         {
  71.             ASSERT_READ_PTR(pCP);
  73.             if (fStart)
  74.                 hr = pCP->Advise((IMLStrAttr*)this, &m_dwMLStrCookie);
  75.             else
  76.                 hr = pCP->Unadvise(m_dwMLStrCookie);
  78.             pCP->Release();
  79.         }
  81.         pCPC->Release();
  82.     }
  84.     return hr;
  85. }
  87. STDMETHODIMP CMLStrAttrWStr::GetClient(IUnknown** ppUnk)
  88. {
  89.     ASSERT_THIS;
  90.     ASSERT_WRITE_PTR_OR_NULL(ppUnk);
  92.     if (ppUnk)
  93.     {
  94.         IUnknown* const pUnk = m_pMLStr;
  95.         *ppUnk = pUnk;
  96.         if (pUnk)
  97.             pUnk->AddRef();
  98.     }
  100.     return S_OK;
  101. }
  103. STDMETHODIMP CMLStrAttrWStr::QueryAttr(REFIID riid, LPARAM lParam, IUnknown** ppUnk, long* lConf)
  104. {
  105.     return E_NOTIMPL; // CMLStrAttrWStr::QueryAttr()
  106. }
  108. STDMETHODIMP CMLStrAttrWStr::GetAttrInterface(IID* pIID, LPARAM* plParam)
  109. {
  110.     return E_NOTIMPL; // CMLStrAttrWStr::GetAttrInterface()
  111. }
  113. STDMETHODIMP CMLStrAttrWStr::SetMLStr(long lDestPos, long lDestLen, IUnknown* pSrcMLStr, long lSrcPos, long lSrcLen)
  114. {
  115.     return E_NOTIMPL; // CMLStrAttrWStr::SetMLStr()
  116. }
  118. STDMETHODIMP CMLStrAttrWStr::SetWStr(long lDestPos, long lDestLen, const WCHAR* pszSrc, long cchSrc, long* pcchActual, long* plActualLen)
  119. {
  120.     ASSERT_THIS;
  121.     ASSERT_READ_BLOCK(pszSrc, cchSrc);
  122.     ASSERT_WRITE_PTR_OR_NULL(pcchActual);
  123.     ASSERT_WRITE_PTR_OR_NULL(plActualLen);
  125.     HRESULT hr = CheckThread();
  126.     CLock Lock(TRUE, this, hr);
  127.     long cchDestPos;
  128.     long cchDestLen;
  129.     long cchActual;
  130.     long lActualLen;
  132.     if (SUCCEEDED(hr) && (GetBufFlags() & MLSTR_WRITE))
  133.         hr = E_INVALIDARG; // Not writable StrBuf; TODO: Replace StrBuf in this case if allowed
  135.     if (SUCCEEDED(hr) &&
  136.         SUCCEEDED(hr = PrepareMLStrBuf()) &&
  137.         SUCCEEDED(hr = RegularizePosLen(&lDestPos, &lDestLen)) &&
  138.         SUCCEEDED(hr = GetCCh(0, lDestPos, &cchDestPos)) &&
  139.         SUCCEEDED(hr = GetCCh(cchDestPos, lDestLen, &cchDestLen)))
  140.     {
  141.         IMLangStringBufW* const pMLStrBufW = GetMLStrBufW();
  143.         if (pMLStrBufW)
  144.         {
  145.             if (cchSrc > cchDestLen)
  146.             {
  147.                 hr = pMLStrBufW->Insert(cchDestPos, cchSrc - cchDestLen, (pcchActual || plActualLen) ? &cchSrc : NULL);
  148.                 cchSrc += cchDestLen;
  149.             }
  150.             else if  (cchSrc < cchDestLen)
  151.             {
  152.                 hr = pMLStrBufW->Delete(cchDestPos, cchDestLen - cchSrc);
  153.             }
  155.             CMLStrBufWalkW BufWalk(pMLStrBufW, cchDestPos, cchSrc, (pcchActual || plActualLen));
  157.             lActualLen = 0;
  158.             while (BufWalk.Lock(hr))
  159.             {
  160.                 long lLen;
  162.                 if (plActualLen)
  163.                     hr = CalcLenW(pszSrc, BufWalk.GetCCh(), &lLen);
  165.                 if (SUCCEEDED(hr))
  166.                 {
  167.                     lActualLen += lLen;
  168.                     ::memcpy(BufWalk.GetStr(), pszSrc, sizeof(WCHAR) * BufWalk.GetCCh());
  169.                     pszSrc += BufWalk.GetCCh();
  170.                 }
  172.                 BufWalk.Unlock(hr);
  173.             }
  175.             cchActual = BufWalk.GetDoneCCh();
  176.         }
  177.         else
  178.         {
  179.             IMLangStringBufA* const pMLStrBufA = GetMLStrBufA(); // Should succeed because PrepareMLStrBuf() above was succeeded
  180.             const UINT uCodePage = GetCodePage();
  181.             long cchSrcA;
  183.             if (SUCCEEDED(hr = ConvWStrToAStr(pcchActual || plActualLen, uCodePage, pszSrc, cchSrc, NULL, 0, &cchSrcA, NULL, NULL)))
  184.             {
  185.                 if (cchSrcA > cchDestLen)
  186.                 {
  187.                     hr = pMLStrBufA->Insert(cchDestPos, cchSrcA - cchDestLen, (pcchActual || plActualLen) ? &cchSrcA : NULL);
  188.                     cchSrcA += cchDestLen;
  189.                 }
  190.                 else if  (cchSrcA < cchDestLen)
  191.                 {
  192.                     hr = pMLStrBufA->Delete(cchDestPos, cchDestLen - cchSrcA);
  193.                 }
  194.             }
  196.             CMLStrBufWalkA BufWalk(pMLStrBufA, cchDestPos, cchSrcA, (pcchActual || plActualLen));
  198.             cchActual = 0;
  199.             lActualLen = 0;
  200.             while (BufWalk.Lock(hr))
  201.             {
  202.                 long cchWrittenA;
  203.                 long cchWrittenW;
  204.                 long lWrittenLen;
  206.                 if (SUCCEEDED(hr = ConvWStrToAStr(pcchActual || plActualLen, uCodePage, pszSrc, cchSrc, BufWalk.GetStr(), BufWalk.GetCCh(), &cchWrittenA, &cchWrittenW, &lWrittenLen)))
  207.                 {
  208.                     pszSrc += cchWrittenW;
  209.                     cchSrc -= cchWrittenW;
  210.                     cchActual += cchWrittenW;
  211.                     lActualLen += lWrittenLen;
  212.                 }
  214.                 BufWalk.Unlock(hr, cchWrittenA);
  215.             }
  216.         }
  217.     }
  219.     if (SUCCEEDED(hr))
  220.     {
  221.         if (pcchActual)
  222.             *pcchActual = cchActual;
  223.         if (plActualLen)
  224.             *plActualLen = lActualLen;
  225.     }
  226.     else
  227.     {
  228.         if (pcchActual)
  229.             *pcchActual = 0;
  230.         if (plActualLen)
  231.             *plActualLen = 0;
  232.     }
  233.     return hr;
  234. }
  236. STDMETHODIMP CMLStrAttrWStr::SetStrBufW(long lDestPos, long lDestLen, IMLangStringBufW* pSrcBuf, long* pcchActual, long* plActualLen)
  237. {
  238.     ASSERT_THIS;
  239.     return SetStrBufCommon(this, lDestPos, lDestLen, 0, pSrcBuf, NULL, pcchActual, plActualLen);
  240. }
  242. STDMETHODIMP CMLStrAttrWStr::GetWStr(long lSrcPos, long lSrcLen, WCHAR* pszDest, long cchDest, long* pcchActual, long* plActualLen)
  243. {
  244.     ASSERT_THIS;
  245.     ASSERT_WRITE_BLOCK_OR_NULL(pszDest, cchDest);
  246.     ASSERT_WRITE_PTR_OR_NULL(pcchActual);
  247.     ASSERT_WRITE_PTR_OR_NULL(plActualLen);
  249.     HRESULT hr = CheckThread();
  250.     CLock Lock(FALSE, this, hr);
  251.     long cchSrcPos;
  252.     long cchSrcLen;
  253.     long cchActual;
  254.     long lActualLen;
  256.     if (SUCCEEDED(hr) &&
  257.         SUCCEEDED(hr = RegularizePosLen(&lSrcPos, &lSrcLen)) &&
  258.         SUCCEEDED(hr = GetCCh(0, lSrcPos, &cchSrcPos)) &&
  259.         SUCCEEDED(hr = GetCCh(cchSrcPos, lSrcLen, &cchSrcLen)))
  260.     {
  261.         IMLangStringBufW* const pMLStrBufW = GetMLStrBufW();
  262.         IMLangStringBufA* const pMLStrBufA = GetMLStrBufA();
  264.         if (pszDest)
  265.             cchActual = min(cchSrcLen, cchDest);
  266.         else
  267.             cchActual = cchSrcLen;
  269.         if (pMLStrBufW)
  270.         {
  271.             CMLStrBufWalkW BufWalk(pMLStrBufW, cchSrcPos, cchActual, (pcchActual || plActualLen));
  273.             lActualLen = 0;
  274.             while (BufWalk.Lock(hr))
  275.             {
  276.                 long lLen;
  278.                 if (plActualLen)
  279.                     hr = CalcLenW(BufWalk.GetStr(), BufWalk.GetCCh(), &lLen);
  281.                 if (SUCCEEDED(hr))
  282.                 {
  283.                     lActualLen += lLen;
  285.                     if (pszDest)
  286.                     {
  287.                         ::memcpy(pszDest, BufWalk.GetStr(), sizeof(WCHAR) * BufWalk.GetCCh());
  288.                         pszDest += BufWalk.GetCCh();
  289.                     }
  290.                 }
  292.                 BufWalk.Unlock(hr);
  293.             }
  295.             cchActual = BufWalk.GetDoneCCh();
  296.         }
  297.         else if (pMLStrBufA)
  298.         {
  299.             CMLStrBufWalkA BufWalk(pMLStrBufA, cchSrcPos, cchActual, (pcchActual || plActualLen));
  301.             cchActual = 0;
  302.             lActualLen = 0;
  303.             while ((!pszDest || cchDest > 0) && BufWalk.Lock(hr))
  304.             {
  305.                 CHAR* const pszBuf = BufWalk.GetStr();
  306.                 long cchWrittenA;
  307.                 long cchWrittenW;
  308.                 long lWrittenLen;
  310.                 if (SUCCEEDED(hr = ConvAStrToWStr(GetCodePage(), pszBuf, BufWalk.GetCCh(), pszDest, cchDest, &cchWrittenA, &cchWrittenW, &lWrittenLen)))
  311.                 {
  312.                     lActualLen += lWrittenLen;
  313.                     cchActual += cchWrittenW;
  315.                     if (pszDest)
  316.                     {
  317.                         pszDest += cchWrittenW;
  318.                         cchDest -= cchWrittenW;
  319.                     }
  320.                 }
  322.                 BufWalk.Unlock(hr, cchWrittenA);
  323.             }
  324.         }
  325.         else
  326.         {
  327.             ASSERT(cchActual == 0); // MLStrBuf is not available
  328.             lActualLen = 0;
  329.         }
  330.     }
  332.     if (SUCCEEDED(hr))
  333.     {
  334.         if (pcchActual)
  335.             *pcchActual = cchActual;
  336.         if (plActualLen)
  337.             *plActualLen = lActualLen;
  338.     }
  339.     else
  340.     {
  341.         if (pcchActual)
  342.             *pcchActual = 0;
  343.         if (plActualLen)
  344.             *plActualLen = 0;
  345.     }
  346.     return hr;
  347. }
  349. STDMETHODIMP CMLStrAttrWStr::GetStrBufW(long lSrcPos, long lSrcMaxLen, IMLangStringBufW** ppDestBuf, long* plDestLen)
  350. {
  351.     ASSERT_THIS;
  352.     ASSERT_WRITE_PTR_OR_NULL(ppDestBuf);
  353.     ASSERT_WRITE_PTR_OR_NULL(plDestLen);
  355.     HRESULT hr = CheckThread();
  356.     CLock Lock(FALSE, this, hr);
  357.     IMLangStringBufW* pMLStrBufW;
  359.     if (SUCCEEDED(hr) &&
  360.         SUCCEEDED(hr = RegularizePosLen(&lSrcPos, &lSrcMaxLen)) &&
  361.         lSrcMaxLen <= 0)
  362.     {
  363.         hr = E_INVALIDARG;
  364.     }
  366.     if (SUCCEEDED(hr))
  367.     {
  368.         pMLStrBufW = GetMLStrBufW();
  369.         if (!pMLStrBufW)
  370.             hr = MLSTR_E_STRBUFNOTAVAILABLE;
  371.     }
  373.     if (SUCCEEDED(hr))
  374.     {
  375.         if (ppDestBuf)
  376.         {
  377.             pMLStrBufW->AddRef();
  378.             *ppDestBuf = pMLStrBufW;
  379.         }
  380.         if (plDestLen)
  381.             *plDestLen = lSrcMaxLen;
  382.     }
  383.     else
  384.     {
  385.         if (ppDestBuf)
  386.             *ppDestBuf = NULL;
  387.         if (plDestLen)
  388.             *plDestLen = 0;
  389.     }
  391.     return hr;
  392. }
  394. STDMETHODIMP CMLStrAttrWStr::LockWStr(long lSrcPos, long lSrcLen, long lFlags, long cchRequest, WCHAR** ppszDest, long* pcchDest, long* plDestLen)
  395. {
  396.     ASSERT_THIS;
  397.     ASSERT_WRITE_PTR_OR_NULL(ppszDest);
  398.     ASSERT_WRITE_PTR_OR_NULL(pcchDest);
  399.     ASSERT_WRITE_PTR_OR_NULL(plDestLen);
  401.     HRESULT hr = CheckThread();
  402.     CLock Lock(lFlags & MLSTR_WRITE, this, hr);
  403.     long cchSrcPos;
  404.     long cchSrcLen;
  405.     WCHAR* pszBuf = NULL;
  406.     long cchBuf;
  407.     long lLockLen;
  408.     BOOL fDirectLock;
  410.     if (SUCCEEDED(hr) && (!lFlags || (lFlags & ~GetBufFlags() & MLSTR_WRITE)))
  411.         hr = E_INVALIDARG; // No flags specified, or not writable StrBuf; TODO: Replace StrBuf in this case if allowed
  413.     if (!(lFlags & MLSTR_WRITE))
  414.         cchRequest = 0;
  416.     if (SUCCEEDED(hr) &&
  417.         SUCCEEDED(hr = PrepareMLStrBuf()) &&
  418.         SUCCEEDED(hr = RegularizePosLen(&lSrcPos, &lSrcLen)) &&
  419.         SUCCEEDED(hr = GetCCh(0, lSrcPos, &cchSrcPos)) &&
  420.         SUCCEEDED(hr = GetCCh(cchSrcPos, lSrcLen, &cchSrcLen)))
  421.     {
  422.         IMLangStringBufW* const pMLStrBufW = GetMLStrBufW();
  423.         fDirectLock = (pMLStrBufW != 0);
  425.         if (fDirectLock)
  426.         {
  427.             long cchInserted;
  428.             long cchLockLen = cchSrcLen;
  430.             if (cchRequest > cchSrcLen &&
  431.                 SUCCEEDED(hr = pMLStrBufW->Insert(cchSrcPos + cchSrcLen, cchRequest - cchSrcLen, &cchInserted)))
  432.             {
  433.                 SetBufCCh(GetBufCCh() + cchInserted);
  434.                 cchLockLen += cchInserted;
  436.                 if (!pcchDest && cchLockLen < cchRequest)
  437.                     hr = E_OUTOFMEMORY; // Can't insert in StrBuf
  438.             }
  440.             if (SUCCEEDED(hr) &&
  441.                 SUCCEEDED(hr = pMLStrBufW->LockBuf(cchSrcPos, cchLockLen, &pszBuf, &cchBuf)) &&
  442.                 !pcchDest && cchBuf < max(cchSrcLen, cchRequest))
  443.             {
  444.                 hr = E_OUTOFMEMORY; // Can't lock StrBuf
  445.             }
  447.             if (plDestLen && SUCCEEDED(hr))
  448.                 hr = CalcLenW(pszBuf, cchBuf, &lLockLen);
  449.         }
  450.         else
  451.         {
  452.             long cchSize;
  454.             if (SUCCEEDED(hr = CalcBufSizeW(lSrcLen, &cchSize)))
  455.             {
  456.                 cchBuf = max(cchSize, cchRequest);
  457.                 hr = MemAlloc(sizeof(*pszBuf) * cchBuf, (void**)&pszBuf);
  458.             }
  460.             if (SUCCEEDED(hr) && (lFlags & MLSTR_READ))
  461.                 hr = GetWStr(lSrcPos, lSrcLen,  pszBuf, cchBuf, (pcchDest) ? &cchBuf : NULL, (plDestLen) ? &lLockLen : NULL);
  462.         }
  463.     }
  465.     if (SUCCEEDED(hr) &&
  466.         SUCCEEDED(hr = Lock.FallThrough()))
  467.     {
  468.         hr = GetLockInfo()->Lock((fDirectLock) ? UnlockWStrDirect : UnlockWStrIndirect, lFlags, 0, pszBuf, lSrcPos, lSrcLen, cchSrcPos, cchBuf);
  469.     }
  471.     if (SUCCEEDED(hr))
  472.     {
  473.         if (ppszDest)
  474.             *ppszDest = pszBuf;
  475.         if (pcchDest)
  476.             *pcchDest = cchBuf;
  477.         if (plDestLen)
  478.             *plDestLen = lLockLen;
  479.     }
  480.     else
  481.     {
  482.         if (pszBuf)
  483.         {
  484.             if (fDirectLock)
  485.                 GetMLStrBufW()->UnlockBuf(pszBuf, 0, 0);
  486.             else
  487.                 MemFree(pszBuf);
  488.         }
  490.         if (ppszDest)
  491.             *ppszDest = NULL;
  492.         if (pcchDest)
  493.             *pcchDest = 0;
  494.         if (plDestLen)
  495.             *plDestLen = 0;
  496.     }
  498.     return hr;
  499. }
  501. STDMETHODIMP CMLStrAttrWStr::UnlockWStr(const WCHAR* pszSrc, long cchSrc, long* pcchActual, long* plActualLen)
  502. {
  503.     ASSERT_THIS;
  504.     ASSERT_READ_BLOCK(pszSrc, cchSrc);
  505.     ASSERT_WRITE_PTR_OR_NULL(pcchActual);
  506.     ASSERT_WRITE_PTR_OR_NULL(plActualLen);
  508.     return UnlockStrCommon(pszSrc, cchSrc, pcchActual, plActualLen);
  509. }
  511. STDMETHODIMP CMLStrAttrWStr::OnRegisterAttr(IUnknown* pUnk)
  512. {
  513.     return E_NOTIMPL; // CMLStrAttrWStr::OnRegisterAttr()
  514. }
  516. STDMETHODIMP CMLStrAttrWStr::OnUnregisterAttr(IUnknown* pUnk)
  517. {
  518.     return E_NOTIMPL; // CMLStrAttrWStr::OnUnregisterAttr()
  519. }
  521. STDMETHODIMP CMLStrAttrWStr::OnRequestEdit(long lDestPos, long lDestLen, long lNewLen, REFIID riid, LPARAM lParam, IUnknown* pUnk)
  522. {
  523.     return E_NOTIMPL; // CMLStrAttrWStr::OnRequestEdit()
  524. }
  526. STDMETHODIMP CMLStrAttrWStr::OnCanceledEdit(long lDestPos, long lDestLen, long lNewLen, REFIID riid, LPARAM lParam, IUnknown* pUnk)
  527. {
  528.     return E_NOTIMPL; // CMLStrAttrWStr::OnCanceledEdit()
  529. }
  531. STDMETHODIMP CMLStrAttrWStr::OnChanged(long lDestPos, long lDestLen, long lNewLen, REFIID riid, LPARAM lParam, IUnknown* pUnk)
  532. {
  533.     return E_NOTIMPL; // CMLStrAttrWStr::OnChanged()
  534. }
  536. #endif // NEWMLSTR