readviewmenuext.cpp

来自「WIndows mobile 5.0 pocket pc sdk sample 」· C++ 代码 · 共 612 行 · 第 1/2 页

    const TCHAR cszSMSService[] = TEXT("SMS");
    const TCHAR cszASyncService[] = TEXT("ActiveSync");
    
    IMAPIProp *pProp = NULL;    
    LPSPropValue pval = NULL;

    hr = GetIMAPIPropForMsg(&pProp);
    CHR(hr);    

    hr = HrGetOneProp (pProp, PR_SERVICE_NAME, &pval);
    CHR(hr);

    if ( (wcscmp(pval->Value.lpszW, cszSMSService) != 0) &&
         (wcscmp(pval->Value.lpszW, cszASyncService) != 0) )
    {
        fIsEnabled = TRUE;
    }

Error:
    return fIsEnabled;
}


///////////////////////////////////////////////////////////////////////////////
// ReplyUsing
//
//  Composes a reply to the current message using the "Outlook E-mail" account
//
HRESULT MenuExtension::ReplyUsing(void)
{
    HRESULT hr = S_OK;

    IMAPIProp *pProp = NULL;    
    
    ULONG rgTags[] = {4, PR_MESSAGE_CLASS, PR_SENDER_EMAIL_ADDRESS, PR_SUBJECT, PR_BODY};
    ULONG cProps = 0;
    LPSPropValue rgProps = NULL;

    MAILCOMPOSEFIELDS mcfReply = {0};
    LPTSTR pszReplySubject = NULL;
    LPTSTR pszReplyBody = NULL;
    LPTSTR pszOriginalBody = NULL;

    hr = GetIMAPIPropForMsg(&pProp);
    CHR(hr);
                        
    // Get the properties we are interested in from the original message
    hr = pProp->GetProps((LPSPropTagArray) rgTags, MAPI_UNICODE, &cProps, &rgProps);
    CHR(hr);


    if (PR_MESSAGE_CLASS == rgProps[0].ulPropTag)
    {
        mcfReply.pszMsgClass = rgProps[0].Value.lpszW;
    }

    if (PR_SENDER_EMAIL_ADDRESS == rgProps[1].ulPropTag)
    {
        mcfReply.pszTo = rgProps[1].Value.lpszW;
    }

    if (PR_SUBJECT == rgProps[2].ulPropTag)
    {
        hr = GetSubjectForReply(rgProps[2].Value.lpszW, &pszReplySubject);
        if (SUCCEEDED(hr))
        {
            mcfReply.pszSubject = pszReplySubject;
        }
    }

    if (PR_BODY == rgProps[3].ulPropTag)
    {            
        pszOriginalBody = rgProps[4].Value.lpszW;
    }
    else 
    {
        // Note: In this sample, we are simply extracting the PR_BODY property of the message.
        // For MIME messages, you would need to open the PR_CE_MIME_TEXT property and then parse
        // the MIME headers and content to extract the original body text to include in the reply.            
        // That is beyond the scope of what we are demonstrating here, so GetBodyForReply will simply
        // return a default string if the PR_BODY value we pass in is empty.
    }
    hr = GetBodyForReply(pszOriginalBody, &pszReplyBody);
    if (SUCCEEDED(hr))
    {
        mcfReply.pszBody= pszReplyBody;
    }
    
    // This sample replies using ActiveSync account
    mcfReply.dwFlags = MCF_ACCOUNT_IS_NAME;
    mcfReply.pszAccount = TEXT("ActiveSync");

    mcfReply.cbSize = sizeof(mcfReply);

    hr = MailComposeMessage(&mcfReply);

Error:
    MAPIFreeBuffer(rgProps);
    delete[] pszReplySubject;
    delete[] pszReplyBody;
    
    return hr;
}


///////////////////////////////////////////////////////////////////////////////
// GetSubjectForReply
//
//  This allocates a new string containing the reply subject.  
//  Caller responsible for memory cleanup.
//
HRESULT MenuExtension::GetSubjectForReply(LPCTSTR pszOriginal, LPTSTR* ppszReplySubject)
{    
    HRESULT hr = S_OK;
    const TCHAR cszReplySubjectPrefix[] = TEXT("RE: ");
    UINT cchReplySubject;

    CPR(pszOriginal);

    cchReplySubject = lstrlen(pszOriginal) + ARRAYSIZE(cszReplySubjectPrefix);

    *ppszReplySubject = new TCHAR[cchReplySubject];
    CPR(*ppszReplySubject);

    hr = StringCchCopy(*ppszReplySubject, cchReplySubject, cszReplySubjectPrefix);
    CHR(hr);

    hr = StringCchCat(*ppszReplySubject, cchReplySubject, pszOriginal);
    CHR(hr);
    
Error:
    return hr;
}


///////////////////////////////////////////////////////////////////////////////
// GetBodyForReply
//
//  This allocates a new string containing the reply body.  
//  Caller responsible for memory cleanup.
//
HRESULT MenuExtension::GetBodyForReply(LPTSTR pszOriginal, LPTSTR* ppszReplyBody)
{
    HRESULT hr = S_OK;
    const TCHAR cszReplyBodyPrefix[] = TEXT("\n\n-- original message --\n");
    const TCHAR cszNoBodyInReply[] = TEXT("\n\n[original message not included in reply]");    
    UINT cchReplyBody;

    if (pszOriginal)
    {        
        cchReplyBody = lstrlen(pszOriginal) + ARRAYSIZE(cszReplyBodyPrefix);

        *ppszReplyBody = new TCHAR[cchReplyBody];
        CPR(*ppszReplyBody);

        hr = StringCchCopy(*ppszReplyBody, cchReplyBody, cszReplyBodyPrefix);
        CHR(hr);

        hr = StringCchCat(*ppszReplyBody, cchReplyBody, pszOriginal);
        CHR(hr);
    }
    else
    {
        cchReplyBody = ARRAYSIZE(cszNoBodyInReply);
        
        *ppszReplyBody = new TCHAR[cchReplyBody];
        CPR(*ppszReplyBody);
        
        hr = StringCchCopy(*ppszReplyBody, cchReplyBody, cszNoBodyInReply);
        CHR(hr);
    }

Error:    
    return hr;
}


///////////////////////////////////////////////////////////////////////////////
// IsMessage
//
//  Determines if the ItemRef is a Message
// 
BOOL MenuExtension::IsMessage(ItemRef *pir)
{
    return IsEqualGUID(*(pir->pType), ITI_MessageItemRef);
}


///////////////////////////////////////////////////////////////////////////////
// IsMessageFormEx
//
//  Returns TRUE if the ItemRef is a MessageForm, FALSE otherwise.
// 
BOOL MenuExtension::IsMessageFormEx(ItemRef *pir)
{
    return IsEqualGUID(*(pir->pType), ITI_MessageFormExItemRef);
}    


///////////////////////////////////////////////////////////////////////////////
// GetItemRefArray
//
//  Retrieve the ItemRefArray from the application site
// 
HRESULT MenuExtension::GetItemRefArray(ItemRefArray **ppItemArray)
{
    HRESULT hr = E_FAIL;
    
    IDataObject* pDataObj = NULL;
    
    FORMATETC fmt;
    ZeroMemory(&fmt, sizeof(fmt));
    fmt.cfFormat = ::RegisterClipboardFormat(CFNAME_ITEMREFARRAY);
    fmt.dwAspect = DVASPECT_CONTENT;
    fmt.lindex = -1;
    fmt.ptd = NULL;
    fmt.tymed = TYMED_HGLOBAL;

    STGMEDIUM stg;
    ZeroMemory(&stg, sizeof(stg));

    // Be sure that there is a site.  Remember the "site" is a pointer to the 
    //  object in the UI that the menu extension will be acting on.
    if(m_pSite)
    {
        // Get the IDataObject interface for the site 
        hr = m_pSite->QueryInterface(IID_IDataObject, (void**)&pDataObj);
        CHR(hr);

        if (pDataObj)
        {
            // Get the FORMATETC and the STGMEDIUM from the IDataObject
            hr = pDataObj->GetData(&fmt, &stg);
            CHR(hr);

            if ( NULL != stg.hGlobal)
            {
                // Pull the ItemRefArray out of the STGMEDIUM stucture.
                *ppItemArray = (ItemRefArray *)stg.hGlobal;
            }
            else
            {
                CHR(E_FAIL);
            }
        }
        else 
        {
            CHR(E_FAIL);
        }            
    }

Error:
    RELEASE_OBJ(pDataObj);
    return hr;
}


///////////////////////////////////////////////////////////////////////////////
// GetIMAPIPropForMsg
//
//  Retrieves an IMAPIProp interface to the current message
// 
HRESULT MenuExtension::GetIMAPIPropForMsg(IMAPIProp** ppProp)
{
    HRESULT hr = S_OK;
    
    ItemRefArray *pItemArray = NULL;
    ItemRef *pRefMsg = NULL;
    IMessage *pMsg = NULL;

    hr = GetItemRefArray(&pItemArray);
    CHR(hr);

    if (pItemArray)
    {          
        ULONG cbEntry = 0;
        ENTRYID *pEntryID = NULL;

        // Get the 1st item and verify that it is a Message item
        pRefMsg = &pItemArray->rgRefs[0];
        CBR(IsMessage(pRefMsg));

        // Get the Entry Size - cbEntryID from the ItemRef
        cbEntry = ((SBinary *)pRefMsg->pRef)->cb;
        CBR(cbEntry);
        
        // Get the pointer to the EntryID from the ItemRef
        pEntryID = (ENTRYID *) ((SBinary *)pRefMsg->pRef)->lpb;
        CPR(pEntryID);
        
        // Open the Message
        // Note if you have a Message's Entry ID you can go straight to it
        //   no need to open the folder first
        hr = m_pSession->OpenEntry(cbEntry, pEntryID, NULL, 0, NULL, (LPUNKNOWN *)&pMsg);
        CHR(hr);
        CPR(pMsg);
             
        // Get an IMAPIProp Interface
        hr = pMsg->QueryInterface(IID_IMAPIProp, (LPVOID *) ppProp);
    }

Error:
    RELEASE_OBJ(pMsg);  
    return hr;      
}