CTLWRAP.CPP

//=--------------------------------------------------------------------------= 
// CtlWrap.Cpp 
//=--------------------------------------------------------------------------= 
// Copyright 1995 - 1998 Microsoft Corporation.  All Rights Reserved. 
// 
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF  
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO  
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A  
// PARTICULAR PURPOSE. 
//=--------------------------------------------------------------------------= 
// 
// wrappers for various routines that have slightly different implementations 
// for windowed and windowless controls. 
// 
#include "IPServer.H" 
 
#include "CtrlObj.H" 
 
 
// for ASSERT and FAIL 
// 
SZTHISFILE 
 
//=--------------------------------------------------------------------------= 
// COleControl::OcxGetFocus    [wrapper] 
//=--------------------------------------------------------------------------= 
// indicates whether or not we have the focus. 
// 
// Parameters: 
//    none 
// 
// Output: 
//    TRUE if we have focus, else false 
// 
// Notes: 
// 
BOOL COleControl::OcxGetFocus 
( 
    void 
) 
{ 
    // if we're windowless, the site provides this functionality 
    // 
    if (m_pInPlaceSiteWndless) { 
        return (m_pInPlaceSiteWndless->GetFocus() == S_OK); 
    } else { 
 
        // we've got a window.  just let the APIs do our work 
        // 
        if (m_fInPlaceActive) 
            return (GetFocus() == m_hwnd); 
        else 
            return FALSE; 
    } 
 
    // dead code 
} 
 
//=--------------------------------------------------------------------------= 
// COleControl::OcxGetWindowRect    [wrapper] 
//=--------------------------------------------------------------------------= 
// returns the current rectangle for this control, and correctly handles 
// windowless vs windowed. 
// 
// Parameters: 
//    LPRECT                - [out]  duh. 
// 
// Output: 
//    BOOL                  - false means unexpected. 
// 
// Notes: 
// 
BOOL COleControl::OcxGetWindowRect 
( 
    LPRECT prc 
) 
{ 
    // if we're windowless, then we have this information already! 
    // 
    if (Windowless()) { 
        *prc = m_rcLocation; 
        return TRUE; 
    } else 
        return GetWindowRect(m_hwnd, prc); 
 
    // dead code 
} 
 
//=--------------------------------------------------------------------------= 
// COleControl::OcxDefWindowProc    [wrapper] 
//=--------------------------------------------------------------------------= 
// default window processing 
// 
// Parameters: 
//    UINT           - [in] duh. 
//    WPARAM         - [in] duh. 
//    LPARAM         - [in] DUH. 
// 
// Output: 
//    LRESULT 
// 
// Notes: 
// 
LRESULT COleControl::OcxDefWindowProc 
( 
    UINT   msg, 
    WPARAM wParam, 
    LPARAM lParam 
) 
{ 
    LRESULT l; 
 
    // if we're windowless, this is a site provided pointer 
    // 
    if (m_pInPlaceSiteWndless) 
        m_pInPlaceSiteWndless->OnDefWindowMessage(msg, wParam, lParam, &l); 
    else 
        // we've got a window -- just pass it along 
        // 
        l = DefWindowProc(m_hwnd, msg, wParam, lParam); 
 
    return l; 
} 
 
//=--------------------------------------------------------------------------= 
// COleControl::OcxGetDC    [wrapper] 
//=--------------------------------------------------------------------------= 
// wraps the functionality of GetDC, and correctly handles windowless controls 
// 
// Parameters: 
//    none 
// 
// Output: 
//    HDC            - null means we couldn't get one 
// 
// Notes: 
//    - we don't bother with a bunch of the IOleInPlaceSiteWindowless::GetDc 
//      parameters, since the windows GetDC doesn't expose these either. users 
//      wanting that sort of fine tuned control can call said routine 
//      explicitly 
// 
HDC COleControl::OcxGetDC 
( 
    void 
) 
{ 
    HDC hdc = NULL; 
 
    // if we're windowless, the site provides this functionality. 
    // 
    if (m_pInPlaceSiteWndless) 
        m_pInPlaceSiteWndless->GetDC(NULL, 0, &hdc); 
    else 
        hdc = GetDC(m_hwnd); 
 
    return hdc; 
} 
 
//=--------------------------------------------------------------------------= 
// COleControl::OcxReleaseDC    [wrapper] 
//=--------------------------------------------------------------------------= 
// releases a DC returned by OcxGetDC 
// 
// Parameters: 
//    HDC             - [in] release me 
// 
// Output: 
//    none 
// 
// Notes: 
// 
void COleControl::OcxReleaseDC 
( 
    HDC hdc 
) 
{ 
    // if we're windowless, the site does this for us 
    // 
    if (m_pInPlaceSiteWndless) 
        m_pInPlaceSiteWndless->ReleaseDC(hdc); 
    else 
        ReleaseDC(m_hwnd, hdc); 
} 
 
//=--------------------------------------------------------------------------= 
// COleControl::OcxSetCapture    [wrapper] 
//=--------------------------------------------------------------------------= 
// provides a means for the control to get or release capture. 
// 
// Parameters: 
//    BOOL            - [in] true means take, false release 
// 
// Output: 
//    BOOL            - true means it's yours, false nuh-uh 
// 
// Notes: 
// 
BOOL COleControl::OcxSetCapture 
( 
    BOOL fGrab 
) 
{ 
    HRESULT hr; 
 
    // the host does this for us if we're windowless [i'm getting really bored 
    // of typing that] 
    // 
    if (m_pInPlaceSiteWndless) { 
        hr = m_pInPlaceSiteWndless->SetCapture(fGrab); 
        return (hr == S_OK); 
    } else { 
        // people shouldn't call this when they're not in-place active, but 
        // just in case... 
        // 
        if (m_fInPlaceActive) { 
            SetCapture(m_hwnd); 
            return TRUE; 
        } else 
            return FALSE; 
    } 
 
    // dead code 
} 
 
//=--------------------------------------------------------------------------= 
// COleControl::OcxGetCapture    [wrapper] 
//=--------------------------------------------------------------------------= 
// tells you whether or not you have the capture. 
// 
// Parameters: 
//    none 
// 
// Output: 
//    BOOL         - true it's yours, false it's not 
// 
// Notes: 
// 
BOOL COleControl::OcxGetCapture 
( 
    void 
) 
{ 
    // host does this for windowless dudes 
    // 
    if (m_pInPlaceSiteWndless) 
        return m_pInPlaceSiteWndless->GetCapture() == S_OK; 
    else { 
        // people shouldn't call this when they're not in-place active, but 
        // just in case. 
        // 
        if (m_fInPlaceActive) 
            return GetCapture() == m_hwnd; 
        else 
            return FALSE; 
    } 
 
    // dead code 
} 
 
//=--------------------------------------------------------------------------= 
// COleControl::OcxInvalidateRect    [wrapper] 
//=--------------------------------------------------------------------------= 
// invalidates the control's rectangle 
// 
// Parameters: 
//    LPCRECT            - [in] rectangle to invalidate 
//    BOOL               - [in] do we erase background first? 
// 
// Output: 
//    BOOL 
// 
// Notes: 
// 
BOOL COleControl::OcxInvalidateRect 
( 
    LPCRECT prcInvalidate, 
    BOOL    fErase 
) 
{ 
    // if we're windowless, then we need to get the site to do all this for 
    // us 
    if (m_pInPlaceSiteWndless) 
        return m_pInPlaceSiteWndless->InvalidateRect(prcInvalidate, fErase) == S_OK; 
    else { 
        // otherwise do something different depending on whether or not we're 
        // in place active or not 
        // 
        if (m_fInPlaceActive) 
            return InvalidateRect(m_hwnd, prcInvalidate, TRUE); 
        else 
            ViewChanged(); 
    } 
 
    return TRUE; 
} 
 
//=--------------------------------------------------------------------------= 
// COleControl::OcxScrollRect    [wrapper] 
//=--------------------------------------------------------------------------= 
// does some window scrolling for the control 
// 
// Parameters: 
//    LPCRECT             - [in] region to scroll 
//    LPCRECT             - [in] region to clip 
//    int                 - [in] dx to scroll 
//    int                 - [in] dy to scroll 
// 
// Output: 
//    BOOL 
// 
// Notes: 
// 
BOOL COleControl::OcxScrollRect 
( 
    LPCRECT  prcBounds, 
    LPCRECT  prcClip, 
    int      dx, 
    int      dy 
) 
{ 
    // if we're windowless, the site provides this functionality, otherwise 
    // APIs do the job 
    // 
    if (m_pInPlaceSiteWndless) 
        return m_pInPlaceSiteWndless->ScrollRect(dx, dy, prcBounds, prcClip) == S_OK; 
    else { 
        if (m_fInPlaceActive)  
            ScrollWindowEx(m_hwnd, dx, dy, prcBounds, prcClip, NULL, NULL, SW_INVALIDATE); 
        else 
            return FALSE; 
    } 
 
    return TRUE; 
}