wxactivex.cpp

Wxpython Implemented on Windows CE, Source code

    WXOLE_TRACE("IDispatch::GetIDsOfNames");
    return E_NOTIMPL;
}

HRESULT FrameSite::GetTypeInfo(unsigned int iTInfo, LCID lcid, ITypeInfo ** ppTInfo)
{
    WXOLE_TRACE("IDispatch::GetTypeInfo");
    return E_NOTIMPL;
}

HRESULT FrameSite::GetTypeInfoCount(unsigned int * pcTInfo)
{
    WXOLE_TRACE("IDispatch::GetTypeInfoCount");
    return E_NOTIMPL;
}

HRESULT FrameSite::Invoke(DISPID dispIdMember, REFIID riid, LCID lcid,
                          WORD wFlags, DISPPARAMS * pDispParams,
                          VARIANT * pVarResult, EXCEPINFO * pExcepInfo,
                          unsigned int * puArgErr)
{
    WXOLE_TRACE("IDispatch::Invoke");

    if (!(wFlags & DISPATCH_PROPERTYGET))
        return S_OK;

    HRESULT hr;

    if (pVarResult == NULL) 
        return E_INVALIDARG;

    //The most common case is boolean, use as an initial type
    V_VT(pVarResult) = VT_BOOL;

    switch (dispIdMember)
    {
        case DISPID_AMBIENT_MESSAGEREFLECT:
            WXOLE_TRACE("Invoke::DISPID_AMBIENT_MESSAGEREFLECT");
            V_BOOL(pVarResult)= FALSE;
            return S_OK;

        case DISPID_AMBIENT_DISPLAYASDEFAULT:
            WXOLE_TRACE("Invoke::DISPID_AMBIENT_DISPLAYASDEFAULT");
            V_BOOL(pVarResult)= TRUE;
            return S_OK;

        case DISPID_AMBIENT_OFFLINEIFNOTCONNECTED:
            WXOLE_TRACE("Invoke::DISPID_AMBIENT_OFFLINEIFNOTCONNECTED");
            V_BOOL(pVarResult) = TRUE;
            return S_OK;


        case DISPID_AMBIENT_SILENT:
            WXOLE_TRACE("Invoke::DISPID_AMBIENT_SILENT");
            V_BOOL(pVarResult)= TRUE;
            return S_OK;

        case DISPID_AMBIENT_APPEARANCE:
            pVarResult->vt = VT_BOOL;
            pVarResult->boolVal = m_bAmbientAppearance;
            break;

        case DISPID_AMBIENT_FORECOLOR:
            pVarResult->vt = VT_I4;
            pVarResult->lVal = (long) m_clrAmbientForeColor;
            break;

        case DISPID_AMBIENT_BACKCOLOR:
            pVarResult->vt = VT_I4;
            pVarResult->lVal = (long) m_clrAmbientBackColor;
            break;

        case DISPID_AMBIENT_LOCALEID:
            pVarResult->vt = VT_I4;
            pVarResult->lVal = (long) m_nAmbientLocale;
            break;

        case DISPID_AMBIENT_USERMODE:
            pVarResult->vt = VT_BOOL;
            pVarResult->boolVal = m_window->m_bAmbientUserMode;
            break;

        case DISPID_AMBIENT_SHOWGRABHANDLES:
            pVarResult->vt = VT_BOOL;
            pVarResult->boolVal = m_bAmbientShowGrabHandles;
            break;

        case DISPID_AMBIENT_SHOWHATCHING:
            pVarResult->vt = VT_BOOL;
            pVarResult->boolVal = m_bAmbientShowHatching;
            break;

        default:
            return DISP_E_MEMBERNOTFOUND;
    }

    return S_OK;
}

//IOleWindow

HRESULT FrameSite::GetWindow(HWND * phwnd)
{
    WXOLE_TRACE("IOleWindow::GetWindow");
    if (phwnd == NULL) 
        return E_INVALIDARG;
    (*phwnd) = m_hWndParent;
    return S_OK;
}

HRESULT FrameSite::ContextSensitiveHelp(BOOL fEnterMode)
{
    WXOLE_TRACE("IOleWindow::ContextSensitiveHelp");
    return S_OK;
}

//IOleInPlaceUIWindow

HRESULT FrameSite::GetBorder(LPRECT lprectBorder)
{
    WXOLE_TRACE("IOleInPlaceUIWindow::GetBorder");
    if (lprectBorder == NULL) 
        return E_INVALIDARG;
    return INPLACE_E_NOTOOLSPACE;
}

HRESULT FrameSite::RequestBorderSpace(LPCBORDERWIDTHS pborderwidths)
{
    WXOLE_TRACE("IOleInPlaceUIWindow::RequestBorderSpace");
    if (pborderwidths == NULL) 
        return E_INVALIDARG;
    return INPLACE_E_NOTOOLSPACE;
}

HRESULT FrameSite::SetBorderSpace(LPCBORDERWIDTHS pborderwidths)
{
    WXOLE_TRACE("IOleInPlaceUIWindow::SetBorderSpace");
    return S_OK;
}

HRESULT FrameSite::SetActiveObject(IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
{
    WXOLE_TRACE("IOleInPlaceUIWindow::SetActiveObject");

    if (pActiveObject)
        pActiveObject->AddRef();

    m_window->m_oleInPlaceActiveObject = pActiveObject;
    return S_OK;
}

//IOleInPlaceFrame

HRESULT FrameSite::InsertMenus(HMENU hmenuShared, LPOLEMENUGROUPWIDTHS lpMenuWidths)
{
    WXOLE_TRACE("IOleInPlaceFrame::InsertMenus");
    return S_OK;
}

HRESULT FrameSite::SetMenu(HMENU hmenuShared, HOLEMENU holemenu, HWND hwndActiveObject)
{
    WXOLE_TRACE("IOleInPlaceFrame::SetMenu");
    return S_OK;
}

HRESULT FrameSite::RemoveMenus(HMENU hmenuShared)
{
    WXOLE_TRACE("IOleInPlaceFrame::RemoveMenus");
    return S_OK;
}

HRESULT FrameSite::SetStatusText(LPCOLESTR pszStatusText)
{
    WXOLE_TRACE("IOleInPlaceFrame::SetStatusText");
    //((wxFrame*)wxGetApp().GetTopWindow())->GetStatusBar()->SetStatusText(pszStatusText);
    return S_OK;
}

HRESULT FrameSite::EnableModeless(BOOL fEnable)
{
    WXOLE_TRACE("IOleInPlaceFrame::EnableModeless");
    return S_OK;
}

HRESULT FrameSite::TranslateAccelerator(LPMSG lpmsg, WORD wID)
{
    WXOLE_TRACE("IOleInPlaceFrame::TranslateAccelerator");
    // TODO: send an event with this id
    if (m_window->m_oleInPlaceActiveObject.Ok())
        m_window->m_oleInPlaceActiveObject->TranslateAccelerator(lpmsg);

    return S_FALSE;
}

//IOleInPlaceSite

HRESULT FrameSite::CanInPlaceActivate()
{
    WXOLE_TRACE("IOleInPlaceSite::CanInPlaceActivate");
    return S_OK;
}

HRESULT FrameSite::OnInPlaceActivate()
{
    WXOLE_TRACE("IOleInPlaceSite::OnInPlaceActivate");
    m_bInPlaceActive = true;
    return S_OK;
}

HRESULT FrameSite::OnUIActivate()
{
    WXOLE_TRACE("IOleInPlaceSite::OnUIActivate");
    m_bUIActive = true;
    return S_OK;
}

HRESULT FrameSite::GetWindowContext(IOleInPlaceFrame **ppFrame,
                                    IOleInPlaceUIWindow **ppDoc,
                                    LPRECT lprcPosRect,
                                    LPRECT lprcClipRect,
                                    LPOLEINPLACEFRAMEINFO lpFrameInfo)
{
    WXOLE_TRACE("IOleInPlaceSite::GetWindowContext");
    if (ppFrame == NULL || ppDoc == NULL || lprcPosRect == NULL ||
        lprcClipRect == NULL || lpFrameInfo == NULL)
    {
        if (ppFrame != NULL) 
            (*ppFrame) = NULL;
        if (ppDoc != NULL) 
            (*ppDoc) = NULL;
        return E_INVALIDARG;
    }

    HRESULT hr = QueryInterface(IID_IOleInPlaceFrame, (void **) ppFrame);
    if (! SUCCEEDED(hr))
    {
        WXOLE_TRACE("IOleInPlaceSite::IOleInPlaceFrame Error !");
        return E_UNEXPECTED;
    };

    hr = QueryInterface(IID_IOleInPlaceUIWindow, (void **) ppDoc);
    if (! SUCCEEDED(hr))
    {
        WXOLE_TRACE("IOleInPlaceSite::IOleInPlaceUIWindow Error !");
        (*ppFrame)->Release();
        *ppFrame = NULL;
        return E_UNEXPECTED;
    };

    int w, h;
    m_window->GetClientSize(&w, &h);
    if (lprcPosRect)
    {
        lprcPosRect->left = lprcPosRect->top = 0;
        lprcPosRect->right = w;
        lprcPosRect->bottom = h;
    };
    if (lprcClipRect)
    {
        lprcClipRect->left = lprcClipRect->top = 0;
        lprcClipRect->right = w;
        lprcClipRect->bottom = h;
    };

    memset(lpFrameInfo, 0, sizeof(OLEINPLACEFRAMEINFO));
    lpFrameInfo->cb = sizeof(OLEINPLACEFRAMEINFO);
    lpFrameInfo->hwndFrame = m_hWndParent;

    return S_OK;
}

HRESULT FrameSite::Scroll(SIZE scrollExtent)
{
    WXOLE_TRACE("IOleInPlaceSite::Scroll");
    return S_OK;
}

HRESULT FrameSite::OnUIDeactivate(BOOL fUndoable)
{
    WXOLE_TRACE("IOleInPlaceSite::OnUIDeactivate");
    m_bUIActive = false;
    return S_OK;
}

HRESULT FrameSite::OnInPlaceDeactivate()
{
    WXOLE_TRACE("IOleInPlaceSite::OnInPlaceDeactivate");
    m_bInPlaceActive = false;
    return S_OK;
}

HRESULT FrameSite::DiscardUndoState()
{
    WXOLE_TRACE("IOleInPlaceSite::DiscardUndoState");
    return S_OK;
}

HRESULT FrameSite::DeactivateAndUndo()
{
    WXOLE_TRACE("IOleInPlaceSite::DeactivateAndUndo");
    return S_OK;
}

HRESULT FrameSite::OnPosRectChange(LPCRECT lprcPosRect)
{
    WXOLE_TRACE("IOleInPlaceSite::OnPosRectChange");
    if (m_window->m_oleInPlaceObject.Ok() && lprcPosRect)
        m_window->m_oleInPlaceObject->SetObjectRects(lprcPosRect, lprcPosRect);

    return S_OK;
}

//IOleInPlaceSiteEx

HRESULT FrameSite::OnInPlaceActivateEx(BOOL * pfNoRedraw, DWORD dwFlags)
{
    WXOLE_TRACE("IOleInPlaceSiteEx::OnInPlaceActivateEx");
    OleLockRunning(m_window->m_ActiveX, TRUE, FALSE);
    if (pfNoRedraw) 
        (*pfNoRedraw) = FALSE;
    return S_OK;
}

HRESULT FrameSite::OnInPlaceDeactivateEx(BOOL fNoRedraw)
{
    WXOLE_TRACE("IOleInPlaceSiteEx::OnInPlaceDeactivateEx");
    OleLockRunning(m_window->m_ActiveX, FALSE, FALSE);
    return S_OK;
}

HRESULT FrameSite::RequestUIActivate()
{
    WXOLE_TRACE("IOleInPlaceSiteEx::RequestUIActivate");
    return S_OK;
}


//IOleClientSite

HRESULT FrameSite::SaveObject()
{
    WXOLE_TRACE("IOleClientSite::SaveObject");
    return S_OK;
}

const char *OleGetMonikerToStr(DWORD dwAssign)
{
    switch (dwAssign)
    {
    case OLEGETMONIKER_ONLYIFTHERE  : return "OLEGETMONIKER_ONLYIFTHERE";
    case OLEGETMONIKER_FORCEASSIGN  : return "OLEGETMONIKER_FORCEASSIGN";
    case OLEGETMONIKER_UNASSIGN     : return "OLEGETMONIKER_UNASSIGN";
    case OLEGETMONIKER_TEMPFORUSER  : return "OLEGETMONIKER_TEMPFORUSER";    
    default                         : return "Bad Enum";
    };
};

const char *OleGetWhicMonikerStr(DWORD dwWhichMoniker)
{
    switch(dwWhichMoniker)
    {
    case OLEWHICHMK_CONTAINER   : return "OLEWHICHMK_CONTAINER";
    case OLEWHICHMK_OBJREL      : return "OLEWHICHMK_OBJREL";
    case OLEWHICHMK_OBJFULL     : return "OLEWHICHMK_OBJFULL";
    default                     : return "Bad Enum";
    };
};

HRESULT FrameSite::GetMoniker(DWORD dwAssign, DWORD dwWhichMoniker,
                              IMoniker ** ppmk)
{
    WXOLE_TRACEOUT("IOleClientSite::GetMoniker(" << OleGetMonikerToStr(dwAssign) << ", " << OleGetWhicMonikerStr(dwWhichMoniker) << ")");


    if (! ppmk)
        return E_FAIL;

    /*
    HRESULT hr = CreateFileMoniker(L"e:\\dev\\wxie\\bug-zap.swf", ppmk);
    if (SUCCEEDED(hr))
        return S_OK;
    */
    *ppmk = NULL;
    
    return E_FAIL ;
}

HRESULT FrameSite::GetContainer(LPOLECONTAINER * ppContainer)
{
    WXOLE_TRACE("IOleClientSite::GetContainer");
    if (ppContainer == NULL) 
        return E_INVALIDARG;
    
    HRESULT hr = QueryInterface(IID_IOleContainer, (void**)(ppContainer));
    wxASSERT(SUCCEEDED(hr));

    return hr;
}

HRESULT FrameSite::ShowObject()
{
    WXOLE_TRACE("IOleClientSite::ShowObject");
    if (m_window->m_oleObjectHWND)
        ::ShowWindow(m_window->m_oleObjectHWND, SW_SHOW);
    return S_OK;
}

HRESULT FrameSite::OnShowWindow(BOOL fShow)
{
    WXOLE_TRACE("IOleClientSite::OnShowWindow");
    return S_OK;
}

HRESULT FrameSite::RequestNewObjectLayout()
{
    WXOLE_TRACE("IOleClientSite::RequestNewObjectLayout");
    return E_NOTIMPL;
}

// IParseDisplayName

HRESULT FrameSite::ParseDisplayName(IBindCtx *pbc, LPOLESTR pszDisplayName,
                                    ULONG *pchEaten, IMoniker **ppmkOut)
{
    WXOLE_TRACE("IParseDisplayName::ParseDisplayName");
    return E_NOTIMPL;
}

//IOleContainer

HRESULT FrameSite::EnumObjects(DWORD grfFlags, IEnumUnknown **ppenum)
{
    WXOLE_TRACE("IOleContainer::EnumObjects");
    return E_NOTIMPL;
}

HRESULT FrameSite::LockContainer(BOOL fLock)
{
    WXOLE_TRACE("IOleContainer::LockContainer");
    // TODO
    return S_OK;
}

//IOleItemContainer

HRESULT FrameSite::GetObject(LPOLESTR pszItem, DWORD dwSpeedNeeded, 
                             IBindCtx * pbc, REFIID riid, void ** ppvObject)
{
    WXOLE_TRACE("IOleItemContainer::GetObject");
    if (pszItem == NULL) 
        return E_INVALIDARG;
    if (ppvObject == NULL) 
        return E_INVALIDARG;

    *ppvObject = NULL;
    return MK_E_NOOBJECT;
}

HRESULT FrameSite::GetObjectStorage(LPOLESTR pszItem, IBindCtx * pbc, 
                                    REFIID riid, void ** ppvStorage)
{
    WXOLE_TRACE("IOleItemContainer::GetObjectStorage");
    if (pszItem == NULL) 
        return E_INVALIDARG;
    if (ppvStorage == NUL