wxactivex.cpp

Wxpython Implemented on Windows CE, Source code

        &params, &v, &x, &argErr);

    WXOLE_WARN(hr, "Invoke Prop(...)");

    return v;
};

VARIANT wxActiveX::GetPropAsVariant(const wxString& name)
{
    const PropX& prop = GetPropDesc(name);
    if (! prop.CanGet())
    {
        wxString s;
        s << _T("property <") << name << _T("> is writeonly");
        throw exception(s.mb_str());
    };

    return GetPropAsVariant(prop.memid);
};
    
wxVariant wxActiveX::GetPropAsWxVariant(const wxString& name)
{
    VARIANT v = GetPropAsVariant(name);
    HRESULT hr = VariantChangeType(&v, &v, 0, VT_BSTR);
    if (! SUCCEEDED(hr))
        throw exception("Unable to convert variant");

    wxVariant wv;
    MSWVariantToVariant(v, wv);

    VariantClear(&v);

    return wv;
};

wxString wxActiveX::GetPropAsString(const wxString& name)
{
    VARIANT v = GetPropAsVariant(name);
    HRESULT hr = VariantChangeType(&v, &v, 0, VT_BSTR);
    if (! SUCCEEDED(hr))
        throw exception("Unable to convert variant");

    wxString s = v.bstrVal;
    VariantClear(&v);

    return s;
};

char wxActiveX::GetPropAsChar(const wxString& name)
{
    VARIANT v = GetPropAsVariant(name);
    HRESULT hr = VariantChangeType(&v, &v, 0, VT_I1);
    if (! SUCCEEDED(hr))
        throw exception("Unable to convert variant");

    return v.cVal;
};

long wxActiveX::GetPropAsLong(const wxString& name)
{
    VARIANT v = GetPropAsVariant(name);
    HRESULT hr = VariantChangeType(&v, &v, 0, VT_I4);
    if (! SUCCEEDED(hr))
        throw exception("Unable to convert variant");

    return v.iVal;
};

bool wxActiveX::GetPropAsBool(const wxString& name)
{
    VARIANT v = GetPropAsVariant(name);
    HRESULT hr = VariantChangeType(&v, &v, 0, VT_BOOL);
    if (! SUCCEEDED(hr))
        throw exception("Unable to convert variant");

    return v.boolVal != 0;
};

double wxActiveX::GetPropAsDouble(const wxString& name)
{
    VARIANT v = GetPropAsVariant(name);
    HRESULT hr = VariantChangeType(&v, &v, 0, VT_R8);
    if (! SUCCEEDED(hr))
        throw exception("Unable to convert variant");

    return v.dblVal;
};

wxDateTime wxActiveX::GetPropAsDateTime(const wxString& name)
{
    wxDateTime dt;
    VARIANT v = GetPropAsVariant(name);

    if (! VariantToWxDateTime(v, dt))
        throw exception("Unable to convert variant to wxDateTime");

    return dt;
};

void *wxActiveX::GetPropAsPointer(const wxString& name)
{
    VARIANT v = GetPropAsVariant(name);
    HRESULT hr = VariantChangeType(&v, &v, 0, VT_BYREF);
    if (! SUCCEEDED(hr))
        throw exception("Unable to convert variant");

    return v.byref;
};



// call methods
VARIANT wxActiveX::CallMethod(MEMBERID name, VARIANTARG args[], int argc)
{
    DISPPARAMS pargs = {args, NULL, argc, 0};
    VARIANT retVal;
    VariantInit(&retVal);

    EXCEPINFO x;
    memset(&x, 0, sizeof(x));
    unsigned int argErr = 0;

    HRESULT hr = m_Dispatch->Invoke(
        name, 
        IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD,
        &pargs, &retVal, &x, &argErr);

    WXOLE_WARN(hr, "Invoke Method(...)");
    return retVal;
};

VARIANT wxActiveX::CallMethod(const wxString& name, VARIANTARG args[], int argc)
{
    const FuncX& func = GetMethodDesc(name);
    if (argc < 0)
        argc = func.params.size();

    return CallMethod(func.memid, args, argc);
};


wxVariant wxActiveX::CallMethod(const wxString& name, wxVariant args[], int nargs)
{
    const FuncX& func = GetMethodDesc(name);

    if (args == NULL)
        nargs = 0;

    VARIANTARG *vargs = NULL;
    if (nargs < 0)
        nargs = func.params.size();

    if (nargs > 0)
        vargs = new VARIANTARG[nargs];

    if (vargs)
    {
        // init type of vargs
        for (int i = 0; i < nargs; i++)
            vargs[nargs - i - 1].vt = func.params[i].vt;

        // put data
        for (i = 0; i < nargs; i++)
            VariantToMSWVariant(args[i], vargs[nargs - i - 1]);
    };

    VARIANT rv = CallMethod(func.memid, vargs, nargs);

    // process any by ref params
    if (func.hasOut)
    {
        for (int i = 0; i < nargs; i++)
        {
            VARIANTARG& va = vargs[nargs - i - 1];
            const wxActiveX::ParamX &px = func.params[i];

            if (px.IsOut())
            {
                wxVariant& vx = args[i];

                MSWVariantToVariant(va, vx);
            };
        };
    }

    if (vargs)
    {
        for (int i = 0; i < nargs; i++)
            VariantClear(&vargs[i]);
        delete [] vargs;
    };

    wxVariant ret;

    MSWVariantToVariant(rv, ret);
    VariantClear(&rv);

    return ret;
};


///////////////////////////////////////////////

HRESULT wxActiveX::ConnectAdvise(REFIID riid, IUnknown *events)
{
    wxOleConnectionPoint    cp;
    DWORD                   adviseCookie = 0;

    wxAutoOleInterface<IConnectionPointContainer> cpContainer(IID_IConnectionPointContainer, m_ActiveX);
    if (! cpContainer.Ok())
        return E_FAIL;
    
    HRESULT hret = cpContainer->FindConnectionPoint(riid, cp.GetRef());
    if (! SUCCEEDED(hret))
        return hret;
    
    hret = cp->Advise(events, &adviseCookie);

    if (SUCCEEDED(hret))
        m_connections.push_back(wxOleConnection(cp, adviseCookie));
    else
    {
        WXOLE_WARN(hret, "ConnectAdvise");
    };

    return hret;
};

HRESULT wxActiveX::AmbientPropertyChanged(DISPID dispid)
{
    wxAutoOleInterface<IOleControl> oleControl(IID_IOleControl, m_oleObject);

    if (oleControl.Ok())
        return oleControl->OnAmbientPropertyChange(dispid);
    else
        return S_FALSE;
};

#define HIMETRIC_PER_INCH   2540
#define MAP_PIX_TO_LOGHIM(x,ppli)   MulDiv(HIMETRIC_PER_INCH, (x), (ppli))

static void PixelsToHimetric(SIZEL &sz)
{
    static int logX = 0;
    static int logY = 0;

    if (logY == 0)
    {
        // initaliase
        HDC dc = GetDC(NULL);
        logX = GetDeviceCaps(dc, LOGPIXELSX);
        logY = GetDeviceCaps(dc, LOGPIXELSY);
        ReleaseDC(NULL, dc);
    };

#define HIMETRIC_INCH   2540
#define CONVERT(x, logpixels)   MulDiv(HIMETRIC_INCH, (x), (logpixels))

    sz.cx = CONVERT(sz.cx, logX);
    sz.cy = CONVERT(sz.cy, logY);

#undef CONVERT
#undef HIMETRIC_INCH
}


void wxActiveX::OnSize(wxSizeEvent& event)
{
    int w, h;
    GetClientSize(&w, &h);

    RECT posRect;
    posRect.left = 0;
    posRect.top = 0;
    posRect.right = w;
    posRect.bottom = h;

    if (w <= 0 && h <= 0)
        return;

    // extents are in HIMETRIC units
    if (m_oleObject.Ok())
    {
        SIZEL sz = {w, h};
        PixelsToHimetric(sz);

        SIZEL sz2;

        m_oleObject->GetExtent(DVASPECT_CONTENT, &sz2);
        if (sz2.cx !=  sz.cx || sz.cy != sz2.cy)
            m_oleObject->SetExtent(DVASPECT_CONTENT, &sz);
    };

    if (m_oleInPlaceObject.Ok()) 
        m_oleInPlaceObject->SetObjectRects(&posRect, &posRect);
}

void wxActiveX::OnPaint(wxPaintEvent& event)
{
    wxLogTrace(wxT(""),wxT("repainting activex win"));
    wxPaintDC dc(this);
    int w, h;
    GetSize(&w, &h);
    RECT posRect;
    posRect.left = 0;
    posRect.top = 0;
    posRect.right = w;
    posRect.bottom = h;

    // Draw only when control is windowless or deactivated
    if (m_viewObject)
    {
        ::RedrawWindow(m_oleObjectHWND, NULL, NULL, RDW_INTERNALPAINT);
        {
            RECTL *prcBounds = (RECTL *) &posRect;
            m_viewObject->Draw(DVASPECT_CONTENT, -1, NULL, NULL, NULL, 
                (HDC)dc.GetHDC(), prcBounds, NULL, NULL, 0);
        }
    }
    else
    {
        dc.SetBrush(*wxRED_BRUSH);
        dc.DrawRectangle(0, 0, w, h);
        dc.SetBrush(wxNullBrush);
    }
}


void wxActiveX::OnMouse(wxMouseEvent& event)
{
    if (m_oleObjectHWND == NULL) 
    { 
        wxLogTrace(wxT(""),wxT("no oleInPlaceObject")); 
        event.Skip(); 
        return; 
    }

    wxLogTrace(wxT(""),wxT("mouse event"));
    UINT msg = 0;
    WPARAM wParam = 0;
    LPARAM lParam = 0;
    LRESULT lResult = 0;

    if (event.m_metaDown) 
        wParam |= MK_CONTROL;
    if (event.m_shiftDown) 
        wParam |= MK_SHIFT;
    if (event.m_leftDown) 
        wParam |= MK_LBUTTON;
    if (event.m_middleDown) 
        wParam |= MK_MBUTTON;
    if (event.m_rightDown) 
        wParam |= MK_RBUTTON;
    lParam = event.m_x << 16;
    lParam |= event.m_y;

    if (event.LeftDown()) 
        msg = WM_LBUTTONDOWN;
    else if (event.LeftDClick()) 
        msg = WM_LBUTTONDBLCLK;
    else if (event.LeftUp()) 
        msg = WM_LBUTTONUP;
    else if (event.MiddleDown()) 
        msg = WM_MBUTTONDOWN;
    else if (event.MiddleDClick()) 
        msg = WM_MBUTTONDBLCLK;
    else if (event.MiddleUp()) 
        msg = WM_MBUTTONUP;
    else if (event.RightDown()) 
        msg = WM_RBUTTONDOWN;
    else if (event.RightDClick()) 
        msg = WM_RBUTTONDBLCLK;
    else if (event.RightUp()) 
        msg = WM_RBUTTONUP;
    else if (event.Moving() || event.Dragging()) 
        msg = WM_MOUSEMOVE;

    wxString log;
    if (msg == 0) 
    { 
        wxLogTrace(wxT(""),wxT("no message"));
        event.Skip(); return; 
    };

    if (!::SendMessage(m_oleObjectHWND, msg, wParam, lParam)) 
    { 
        wxLogTrace(wxT(""),wxT("msg not delivered"));
        event.Skip(); 
        return; 
    };

    wxLogTrace(wxT(""),wxT("msg sent"));
}

bool wxActiveX::MSWTranslateMessage(WXMSG *msg){
	
	if (msg->message == WM_KEYDOWN){		
		HRESULT result = m_oleInPlaceActiveObject->TranslateAccelerator(msg);
		return (result == S_OK);
	}
	
	return wxWindow::MSWTranslateMessage(msg);
}

long wxActiveX::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
{
    if (m_oleObjectHWND == NULL)
        return wxWindow::MSWWindowProc(nMsg, wParam, lParam);

    switch(nMsg)
    {
    case WM_CHAR:
    case WM_DEADCHAR:
    case WM_KEYDOWN:
    case WM_KEYUP:
    case WM_SYSCHAR:
    case WM_SYSDEADCHAR:
    case WM_SYSKEYDOWN:
    case WM_SYSKEYUP:
        PostMessage(m_oleObjectHWND, nMsg, wParam, lParam);

    default:
        return wxWindow::MSWWindowProc(nMsg, wParam, lParam);
    };
};

void wxActiveX::OnSetFocus(wxFocusEvent& event)
{
    if (m_oleInPlaceActiveObject.Ok()) 
        m_oleInPlaceActiveObject->OnFrameWindowActivate(TRUE);
}

void wxActiveX::OnKillFocus(wxFocusEvent& event)
{
    if (m_oleInPlaceActiveObject.Ok()) 
        m_oleInPlaceActiveObject->OnFrameWindowActivate(FALSE);
}


FrameSite::FrameSite(wxActiveX * win)
{
    m_window = win;
    m_bSupportsWindowlessActivation = true;
    m_bInPlaceLocked = false;
    m_bUIActive = false;
    m_bInPlaceActive = false;
    m_bWindowless = false;

    m_nAmbientLocale = 0;
    m_clrAmbientForeColor = ::GetSysColor(COLOR_WINDOWTEXT);
    m_clrAmbientBackColor = ::GetSysColor(COLOR_WINDOW);
    m_bAmbientShowHatching = true;
    m_bAmbientShowGrabHandles = true;
    m_bAmbientAppearance = true;
 
    m_hDCBuffer = NULL;
    m_hWndParent = (HWND)m_window->GetHWND();
}

FrameSite::~FrameSite()
{
}


//IDispatch

HRESULT FrameSite::GetIDsOfNames(REFIID riid, OLECHAR ** rgszNames, unsigned int cNames,
                                 LCID lcid, DISPID * rgDispId)
{