gpaxplugin.cpp

一个用于智能手机的多媒体库适合S60 WinCE的跨平台开发库

	
	gf_term_set_option(m_term, GF_OPT_AUDIO_VOLUME, 100);
    
	RECT rc;
    ::GetWindowRect(m_hWnd, &rc);
    m_width = rc.right-rc.left;
    m_height = rc.bottom-rc.top;
	if (m_bAutoStart && strlen(m_url)) Play();
    return 0;

	//Error Processing
err_exit:
    if(m_user.modules)
        gf_modules_del(m_user.modules);
    m_user.modules = NULL;
    if(m_user.config)
        gf_cfg_del(m_user.config);
    m_user.config = NULL;
	return 1;
}

void CGPAXPlugin::UnloadTerm()
{
	if (m_term) {
		GF_Terminal *a_term = m_term;
		m_term = NULL;
		gf_term_del(a_term);
	}
	if (m_user.modules) gf_modules_del(m_user.modules);
	if (m_user.config) gf_cfg_del(m_user.config);
	memset(&m_user, 0, sizeof(m_user));
}
CGPAXPlugin::~CGPAXPlugin()
{
	UnloadTerm();
#ifndef _WIN32_WCE
	if (m_pBrowser) m_pBrowser->Release();
	m_pBrowser = NULL;
#endif
}
LRESULT CGPAXPlugin::OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
	UnloadTerm();
    return 0;
}


HRESULT CGPAXPlugin::OnDraw(ATL_DRAWINFO& di)
{
	if (m_term && m_bInitialDraw) {
		m_bInitialDraw = FALSE;
		if (m_bAutoStart) Play();
	}
    return S_OK;
}

// Load is called before OnCreate, but it may not be called at
// all if there are no parameters.
STDMETHODIMP CGPAXPlugin::Load(LPPROPERTYBAG pPropBag, LPERRORLOG pErrorLog)
{
	char szOpt[1024];
    // examine the <embed>/<param> tag arguments

    ReadParamString(pPropBag,pErrorLog,L"src", m_url, MAXLEN_URL);

    if (ReadParamString(pPropBag,pErrorLog,L"autostart", szOpt, 1024))
		m_bAutoStart = (!stricmp(szOpt, "false") || !stricmp(szOpt, "no")) ? 0 : 1;

    if (ReadParamString(pPropBag,pErrorLog,L"use3d", szOpt, 1024))
		m_bUse3D = (!stricmp(szOpt, "true") || !stricmp(szOpt, "yes")) ? 1 : 0;

    if (ReadParamString(pPropBag,pErrorLog,L"aspectratio", szOpt, 1024)) {
		if (!stricmp(szOpt, "keep")) m_AR = GF_ASPECT_RATIO_KEEP;
		else if (!stricmp(szOpt, "16:9")) m_AR = GF_ASPECT_RATIO_16_9;
		else if (!stricmp(szOpt, "4:3")) m_AR = GF_ASPECT_RATIO_4_3;
		else if (!stricmp(szOpt, "fill")) m_AR = GF_ASPECT_RATIO_FILL_SCREEN;
	}

    if (ReadParamString(pPropBag,pErrorLog,L"loop", szOpt, 1024))
		m_bLoop = !stricmp(szOpt, "true") ? 0 : 1;

	UpdateURL();

#ifndef _WIN32_WCE
	/*get the top-level container*/
	if (!m_pBrowser) {
		IServiceProvider *isp, *isp2 = NULL;
		if ( SUCCEEDED(m_spClientSite->QueryInterface(IID_IServiceProvider, reinterpret_cast<void **>(&isp)) ) ) {

			if (SUCCEEDED(isp->QueryService(SID_STopLevelBrowser, IID_IServiceProvider, reinterpret_cast<void **>(&isp2)) ) ) {
				isp2->QueryService(SID_SWebBrowserApp, IID_IWebBrowser2, reinterpret_cast<void **>(&m_pBrowser));
				isp2->Release();
			}
			isp->Release();
		}
	}
	if (m_pBrowser) m_pBrowser->put_StatusText(L"GPAC Ready");
#endif

	return IPersistPropertyBagImpl<CGPAXPlugin>::Load(pPropBag, pErrorLog);
}

void CGPAXPlugin::UpdateURL()
{
	/*get absolute URL*/
	if (!strlen(m_url)) return;
	IMoniker* pMoniker	= NULL;
	LPOLESTR sDisplayName;

	if (SUCCEEDED(m_spClientSite->GetMoniker(OLEGETMONIKER_TEMPFORUSER,
									   OLEWHICHMK_CONTAINER,
									   &pMoniker) ) ) {
		char parent_url[1024];
		pMoniker->GetDisplayName(NULL, NULL, &sDisplayName);
		wcstombs(parent_url, sDisplayName, 300);
		pMoniker->Release();

		char *abs_url = gf_url_concatenate(parent_url, m_url);
		if (abs_url) {
			strcpy(m_url, abs_url);
			free(abs_url);
		}
	}
}

STDMETHODIMP CGPAXPlugin::Save(LPPROPERTYBAG pPropBag, BOOL fClearDirty, BOOL fSaveAllProperties)
{
	u16 wurl[MAXLEN_URL];
	const char *sptr;
	u16 len;

    VARIANT value;
    if( pPropBag == NULL) return E_INVALIDARG;

    VariantInit(&value);

    V_VT(&value) = VT_BOOL;
    V_BOOL(&value) = m_bAutoStart ? VARIANT_TRUE : VARIANT_FALSE;
    pPropBag->Write(OLESTR("AutoStart"), &value);
    VariantClear(&value);

    V_VT(&value) = VT_BSTR;

	sptr = (const char *)m_url;
	len = gf_utf8_mbstowcs(wurl, MAXLEN_URL, &sptr);
    V_BSTR(&value) = SysAllocStringLen(NULL, len+1);
	memcpy(V_BSTR(&value) , wurl, len*sizeof(u16));
	V_BSTR(&value) [len] = 0;
	
    pPropBag->Write(OLESTR("src"), &value);
    VariantClear(&value);
    return S_OK;
}

STDMETHODIMP CGPAXPlugin::Play()
{
	if (m_term) {
		if (!m_bIsConnected) {
			if (strlen(m_url)) {
				gf_term_connect(m_term, m_url);
				gf_term_set_option(m_term, GF_OPT_ASPECT_RATIO, m_AR);
			}
		} else
			gf_term_set_option(m_term, GF_OPT_PLAY_STATE, GF_STATE_PLAYING);   //if target is connected, set it playing
	}
    return S_OK;
}

STDMETHODIMP CGPAXPlugin::Pause()
{
    if(m_term) {
		if (gf_term_get_option(m_term, GF_OPT_PLAY_STATE) == GF_STATE_PAUSED) {
	        gf_term_set_option(m_term, GF_OPT_PLAY_STATE, GF_STATE_PLAYING);
		} else {
	        gf_term_set_option(m_term, GF_OPT_PLAY_STATE, GF_STATE_PAUSED);
		}
	}
    return S_OK;
}

STDMETHODIMP CGPAXPlugin::Stop()
{
    if(m_term) gf_term_disconnect(m_term);     //set it stop
    return S_OK;
}

STDMETHODIMP CGPAXPlugin::Update(BSTR _mtype, BSTR _updates)
{
    if (m_term) {
		u16 *srcp;
		u32 len;
		char mtype[1024], *updates;

		srcp = _mtype;
		len = gf_utf8_wcstombs(mtype, 1024, (const u16 **)&srcp);
		mtype[len] = 0;

		srcp = _updates;
		len = gf_utf8_wcstombs(NULL, 0, (const u16 **)&srcp);
		if (len) {
			updates = (char *) malloc(sizeof(char) * (len+1));
			srcp = _updates;
			len = gf_utf8_wcstombs(updates, len, (const u16 **)&srcp);
			updates[len] = 0;
			gf_term_scene_update(m_term, mtype, updates);
			free(updates);
		}
	}
    return S_OK;
}

STDMETHODIMP CGPAXPlugin::get_src(BSTR *url)
{
	u16 wurl[MAXLEN_URL];
	const char *sptr;
	u16 len;
    if (url==NULL) return E_POINTER;

	sptr = (const char *)m_url;
	len = gf_utf8_mbstowcs(wurl, MAXLEN_URL, &sptr);
    *url = SysAllocStringLen(NULL, len+1);
	memcpy(*url, wurl, len*sizeof(u16));
	*url[len] = 0;
    return S_OK;
}
STDMETHODIMP CGPAXPlugin::put_src(BSTR url)
{
	const u16 *srcp = url;
	u32 len = gf_utf8_wcstombs(m_url, MAXLEN_URL, &srcp);
	m_url[len] = 0;
	UpdateURL();
    return S_OK;
}

STDMETHODIMP CGPAXPlugin::get_AutoStart(VARIANT_BOOL *as)
{
    if (as==NULL) return E_POINTER;
    *as = m_bAutoStart ? VARIANT_TRUE: VARIANT_FALSE;
    return S_OK;
}
STDMETHODIMP CGPAXPlugin::put_AutoStart(VARIANT_BOOL as)
{
    m_bAutoStart = (as !=VARIANT_FALSE) ? TRUE: FALSE;
    return S_OK;
}

STDMETHODIMP CGPAXPlugin::GetInterfaceSafetyOptions(      
    REFIID riid,
    DWORD *pdwSupportedOptions,
    DWORD *pdwEnabledOptions
)
{
    if( (NULL == pdwSupportedOptions) || (NULL == pdwEnabledOptions) )
        return E_POINTER;

    *pdwSupportedOptions = INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACESAFE_FOR_UNTRUSTED_CALLER;

    if ((IID_IDispatch == riid) || (IID_IGPAX == riid)) {
        *pdwEnabledOptions = INTERFACESAFE_FOR_UNTRUSTED_CALLER;
        return NOERROR;
    }
    else if (IID_IPersistPropertyBag == riid)  {
        *pdwEnabledOptions = INTERFACESAFE_FOR_UNTRUSTED_DATA;
        return NOERROR;
    }
    *pdwEnabledOptions = 0;
    return E_NOINTERFACE;
};

STDMETHODIMP CGPAXPlugin::SetInterfaceSafetyOptions(      
    REFIID riid,
    DWORD dwOptionSetMask,
    DWORD dwEnabledOptions
)
{
    if ((IID_IDispatch == riid) || (IID_IGPAX == riid) ) {
        if( (INTERFACESAFE_FOR_UNTRUSTED_CALLER == dwOptionSetMask)
         && (INTERFACESAFE_FOR_UNTRUSTED_CALLER == dwEnabledOptions) ) {
            return NOERROR;
        }
        return E_FAIL;
    }
    else if (IID_IPersistPropertyBag == riid) {
        if( (INTERFACESAFE_FOR_UNTRUSTED_DATA == dwOptionSetMask)
         && (INTERFACESAFE_FOR_UNTRUSTED_DATA == dwEnabledOptions) ) {
            return NOERROR;
        }
        return E_FAIL;
    }
    return E_FAIL;
};