msgfilt.cpp

英文版的 想要的话可以下载了 为大家服务

/*
 * MSGFILT.CPP
 * Koala Client #2, Chapter 6
 *
 * Implementation of a message filter object.
 *
 * Copyright (c)1993-1995 Microsoft Corporation, All Rights Reserved
 *
 * Kraig Brockschmidt, Microsoft
 * Internet  :  [e-mail]
 * Compuserve:  >INTERNET:[e-mail]
 */


#include "objuser2.h"


/*
 * CMessageFilter::CMessageFilter
 * CMessageFilter::~CMessageFilter
 *
 * Parameters (Constructor):
 *  pApp            PAPP of the application
 */

CMessageFilter::CMessageFilter(PAPP pApp)
    {
    m_cRef=0;
    m_pApp=pApp;
    return;
    }

CMessageFilter::~CMessageFilter(void)
    {
    return;
    }



/*
 * CMessageFilter::QueryInterface
 * CMessageFilter::AddRef
 * CMessageFilter::Release
 *
 * Purpose:
 *  Delegating IUnknown members for CMessageFilter.
 */

STDMETHODIMP CMessageFilter::QueryInterface(REFIID riid
    , LPVOID *ppv)
    {
    *ppv=NULL;

    if (IID_IUnknown==riid || IID_IMessageFilter==riid)
        *ppv=this;

    if (NULL!=*ppv)
        {
        ((LPUNKNOWN)*ppv)->AddRef();
        return NOERROR;
        }

    return ResultFromScode(E_NOINTERFACE);
    }

STDMETHODIMP_(ULONG) CMessageFilter::AddRef(void)
    {
    return ++m_cRef;
    }

STDMETHODIMP_(ULONG) CMessageFilter::Release(void)
    {
    if (0!=--m_cRef)
        return m_cRef;

    delete this;
    return 0;
    }






/*
 * CMessageFilter::HandleInComingCall
 *
 * Purpose:
 *  Requests that the container call OleSave for the object that
 *  lives here.  Typically this happens on server shutdown.
 *
 * Parameters:
 *  dwCallType      DWORD indicating the type of call received, from
 *                  the CALLTYPE enumeration
 *  hTaskCaller     HTASK of the caller
 *  dwTickCount     DWORD elapsed tick count since the outgoing call
 *                  was made if dwCallType is not CALLTYPE_TOPLEVEL.
 *                  Ignored for other call types.
 *  pInterfaceInfo  LPINTERFACEINFO providing information about the
 *                  call.  Can be NULL.
 *
 * Return Value:
 *  DWORD           One of SERVERCALL_ISHANDLED (if the call might
 *                  be handled), SERVERCALL_REJECTED (call cannot
 *                  be handled), or SERVERCALL_RETRYLATER (try
 *                  again sometime).
 */

STDMETHODIMP_(DWORD) CMessageFilter::HandleInComingCall
    (DWORD dwCallType, HTASK htaskCaller, DWORD dwTickCount
#ifdef WIN32
    , LPINTERFACEINFO pInterfaceInfo)
#else
    , DWORD dwReserved)
#endif
    {
    /*
     * Because ObjectUser2 doesn't serve any objects itself,
     * this should never occur in this message filter.
     */
    m_pApp->Message(TEXT("CMessageFilter::HandleInComingCall called"));
    return SERVERCALL_ISHANDLED;
    }





/*
 * CMessageFilter::RetryRejectedCall
 *
 * Purpose:
 *  Informs the message filter that an call from this process has
 *  been rejected or delayed from a local or remote server, thus
 *  asking the message filter what to do.
 *
 * Parameters:
 *  hTaskCallee     HTASK of the caller
 *  dwTickCount     DWORD elapsed tick count since the call was made
 *  dwRejectType    DWORD either SERVERCALL_REJECTED or
 *                  SERVERCALL_RETRYLATER as returned by
 *                  HandleInComingCall.
 *
 * Return Value:
 *  DWORD           (DWORD)-1 to cancel the call, any number between
 *                  0 and 100 to try the call again immediately, or
 *                  a value over 100 (but not (DWORD)-1) to instruct
 *                  COM to wait that many milliseconds before trying
 *                  again.
 */

STDMETHODIMP_(DWORD) CMessageFilter::RetryRejectedCall
    (HTASK htaskCallee, DWORD dwTickCount, DWORD dwRejectType)
    {
    UINT    uRet;
    TCHAR   szMsg[256];

    /*
     * A message is pointless as ObjectUserWndProc will
     * output a message as soon as the call returns, overwriting
     * anything we might print here.
     */
    if (SERVERCALL_REJECTED==dwRejectType)
        return (DWORD)-1;

    wsprintf(szMsg, TEXT("RetryRejectedCall waiting %lu")
        , dwTickCount);
    m_pApp->Message(szMsg);


    /*
     * If we've waited over 5 seconds, put up the busy dialog.
     * Otherwise continue waiting.
     */
    if (dwTickCount < 5000)
        return 200;

    m_pApp->Message
        (TEXT("CMessageFilter::RetryRejectedCall showing busy dialog"));

    uRet=DisplayBusyDialog(htaskCallee, 0L);

    switch (uRet)
        {
        case OLEUI_CANCEL:
            return (DWORD)-1;

        case OLEUI_BZ_SWITCHTOSELECTED:
            /*
             * This case won't happen without BZ_NOTRESPONDINGDIALOG,
             * but we would wait maybe 10 seconds if it did.
             */
            return 10000;

        case OLEUI_BZ_RETRYSELECTED:
            m_pApp->Message(TEXT("Waiting another second"));
            return 1000;

        default:
            break;
        }

    return 0;
    }



/*
 * CMessageFilter::MessagePending
 *
 * Purpose:
 *  Gives the caller a chance to process messages while waiting for
 *  a call to an object to complete, to handle things like focus
 *  changes and input.  Usually returning PENDINGMSG_DEFPROCESS
 *  takes care of most things, except that it discards input.  This
 *  function is really useful is you want to process input while
 *  a call is in progress.
 *
 * Parameters:
 *  hTaskCallee     HTASK of the caller
 *  dwTickCount     DWORD elapsed tick count since the call was made
 *  dwPendingType   DWORD with the type of call made from the
 *                  PENDINGTYPE enumeration.
 *
 * Return Value:
 *  DWORD           One of PENDINGMSG_CANCELCALL (cancels the call
 *                  under extreme conditions), PENDINGMSG_WAITNO-
 *                  PROCESS (continue waiting), or PENDINGMSG_WAIT-
 *                  DEFPROCESS (invoke default handling).
 */

STDMETHODIMP_(DWORD) CMessageFilter::MessagePending
    (HTASK htaskCallee, DWORD dwTickCount, DWORD dwPendingType)
    {
    return PENDINGMSG_WAITDEFPROCESS;
    }







/*
 * CMessageFilter::DisplayBusyDialog
 *
 * Purpose:
 *  Invokes the standard Busy dialog using hTask to find the
 *  window handle of the server that's busy.
 *
 * Parameters:
 *  hTask           HTASK received in the message filter.
 *  dwFlags         DWORD flags to use when invoking the dialog
 *
 * Return Value:
 *  UINT            Result of the dialog, one of OLEUI_BZ_:
 *                  SWITCHTOSELECTED, RETRYSELECTED, CALLUNBLOCKED.
 */

UINT CMessageFilter::DisplayBusyDialog(HTASK hTask, DWORD dwFlags)
    {
    OLEUIBUSY   bz;

    //Clear out everything we don't use
    memset(&bz, 0, sizeof(bz));

    bz.cbStruct=sizeof(OLEUIBUSY);
    bz.dwFlags=dwFlags;
    bz.hWndOwner=m_pApp->m_hWnd;
    bz.hTask=hTask;
    bz.lphWndDialog=NULL;

    return OleUIBusy(&bz);
    }