Lothario
/
axmol
mirror of https://github.com/axmolengine/axmol.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
axmol/cocos/ui/UIWebViewImpl_win32.cpp

843 lines
26 KiB
C++
Raw Normal View History

add simple implement of WebView for win32 1.add simple implement of WebView for win32 2.Modify `std::string' to `const std::string &' as issues 7958 said 3.Open the test case in cpp-tests
2014-09-17 22:30:15 +08:00
#include "platform/CCPlatformConfig.h"
#if CC_TARGET_PLATFORM == CC_PLATFORM_WIN32
#include <atlbase.h>
#include <atlwin.h>
#include <ExDispid.h>
#include <UrlMon.h>
#include "UIWebViewImpl_win32.h"
#include "UIWebView.h"
#include "base/CCDirector.h"
#include "platform/CCFileUtils.h"
#include "platform/CCGLView.h"
class Win32WebControl : public DWebBrowserEvents2
{
public:
Win32WebControl();
bool createWebView(
const std::function<bool (const std::string &)> &shouldStartLoading,
const std::function<void (const std::string &)> &didFinishLoading,
const std::function<void (const std::string &)> &didFailLoading,
const std::function<void (const std::string &)> &onJsCallback);
void removeWebView();
void setWebViewRect(const int left, const int top, const int width, const int height);
void setJavascriptInterfaceScheme(const std::string &scheme) const;
void loadData(const std::string &data, const std::string &MIMEType, const std::string &encoding, const std::string &baseURL) const;
void loadHTMLString(const std::string &html, const std::string &baseURL);
fix compile error
2014-09-18 14:04:54 +08:00
void loadURL(const std::string &url) const;
add simple implement of WebView for win32 1.add simple implement of WebView for win32 2.Modify `std::string' to `const std::string &' as issues 7958 said 3.Open the test case in cpp-tests
2014-09-17 22:30:15 +08:00
void loadFile(const std::string &filePath) const;
void stopLoading() const;
void reload() const;
bool canGoBack() const;
bool canGoForward() const;
void goBack() const;
void goForward() const;
void evaluateJS(const std::string &js) const;
void setScalesPageToFit(const bool scalesPageToFit) const;
void setWebViewVisible(const bool visible) const;
// Implement IUnknown
virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppvObject);
virtual ULONG STDMETHODCALLTYPE AddRef(void);
virtual ULONG STDMETHODCALLTYPE Release(void);
// Implement IDispatch
virtual HRESULT STDMETHODCALLTYPE GetTypeInfoCount(UINT *pctinfo);
virtual HRESULT STDMETHODCALLTYPE GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo);
virtual HRESULT STDMETHODCALLTYPE GetIDsOfNames(
REFIID riid,
LPOLESTR *rgszNames,
UINT cNames,
LCID lcid,
DISPID *rgDispId);
virtual HRESULT STDMETHODCALLTYPE Invoke(
DISPID dispIdMember,
REFIID riid,
LCID lcid,
WORD wFlags,
DISPPARAMS *pDispParams,
VARIANT *pVarResult,
EXCEPINFO *pExcepInfo,
UINT *puArgErr);
private:
CAxWindow _winContainer;
IWebBrowser2 *_webBrowser2;
IConnectionPoint *_connectionPoint;
IDispatch *_htmlDoc;
bool _goBackEnabled;
bool _goForwardEnabled;
DWORD _cookie;
ULONG _reference;
std::function<bool (const std::string &)> _shouldStartLoading;
std::function<void (const std::string &)> _didFinishLoading;
std::function<void (const std::string &)> _didFailLoading;
std::function<void (const std::string &)> _onJsCallback;
std::string _htmlWillLoad;
static bool s_isInitialized;
static CComModule s_module;
static void lazyInit();
void _loadHTMLString(const std::string &html) const;
fix compile error
2014-09-18 14:04:54 +08:00
void loadURL(BSTR url) const;
void loadURL(const std::wstring &url) const;
add simple implement of WebView for win32 1.add simple implement of WebView for win32 2.Modify `std::string' to `const std::string &' as issues 7958 said 3.Open the test case in cpp-tests
2014-09-17 22:30:15 +08:00
};
namespace cocos2d {
namespace experimental {
namespace ui {
WebViewImpl::WebViewImpl(WebView *webView) : _createSucceeded(false), _systemWebControl(nullptr), _webView(webView)
{
_systemWebControl = new Win32WebControl();
if (_systemWebControl == nullptr)
{
return;
}
_createSucceeded = _systemWebControl->createWebView(
[this](const std::string &url)->bool {
compile error & code spelling error 1.fix compile error on win32 2.modify spelling error
2014-09-18 11:52:23 +08:00
std::function<bool (WebView *sender, const std::string &url)> shouldStartLoading = _webView->getOnShouldStartLoading();
if (shouldStartLoading != nullptr)
add simple implement of WebView for win32 1.add simple implement of WebView for win32 2.Modify `std::string' to `const std::string &' as issues 7958 said 3.Open the test case in cpp-tests
2014-09-17 22:30:15 +08:00
{
fix compile error
2014-09-18 14:22:40 +08:00
return shouldStartLoading(_webView, url);
add simple implement of WebView for win32 1.add simple implement of WebView for win32 2.Modify `std::string' to `const std::string &' as issues 7958 said 3.Open the test case in cpp-tests
2014-09-17 22:30:15 +08:00
}
return true;
},
[this](const std::string &url) {
compile error & code spelling error 1.fix compile error on win32 2.modify spelling error
2014-09-18 11:52:23 +08:00
WebView::ccWebViewCallback didFinishLoading = _webView->getOnDidFinishLoading();
if (didFinishLoading != nullptr)
add simple implement of WebView for win32 1.add simple implement of WebView for win32 2.Modify `std::string' to `const std::string &' as issues 7958 said 3.Open the test case in cpp-tests
2014-09-17 22:30:15 +08:00
{
compile error & code spelling error 1.fix compile error on win32 2.modify spelling error
2014-09-18 11:52:23 +08:00
didFinishLoading(_webView, url);
add simple implement of WebView for win32 1.add simple implement of WebView for win32 2.Modify `std::string' to `const std::string &' as issues 7958 said 3.Open the test case in cpp-tests
2014-09-17 22:30:15 +08:00
}
},
[this](const std::string &url) {
fix compile error
2014-09-18 14:22:40 +08:00
WebView::ccWebViewCallback didFailLoading = _webView->getOnDidFailLoading();
compile error & code spelling error 1.fix compile error on win32 2.modify spelling error
2014-09-18 11:52:23 +08:00
if (didFailLoading != nullptr)
add simple implement of WebView for win32 1.add simple implement of WebView for win32 2.Modify `std::string' to `const std::string &' as issues 7958 said 3.Open the test case in cpp-tests
2014-09-17 22:30:15 +08:00
{
compile error & code spelling error 1.fix compile error on win32 2.modify spelling error
2014-09-18 11:52:23 +08:00
didFailLoading(_webView, url);
add simple implement of WebView for win32 1.add simple implement of WebView for win32 2.Modify `std::string' to `const std::string &' as issues 7958 said 3.Open the test case in cpp-tests
2014-09-17 22:30:15 +08:00
}
},
[this](const std::string &url) {
compile error & code spelling error 1.fix compile error on win32 2.modify spelling error
2014-09-18 11:52:23 +08:00
WebView::ccWebViewCallback onJsCallback = _webView->getOnJSCallback();
if (onJsCallback != nullptr)
add simple implement of WebView for win32 1.add simple implement of WebView for win32 2.Modify `std::string' to `const std::string &' as issues 7958 said 3.Open the test case in cpp-tests
2014-09-17 22:30:15 +08:00
{
compile error & code spelling error 1.fix compile error on win32 2.modify spelling error
2014-09-18 11:52:23 +08:00
onJsCallback(_webView, url);
add simple implement of WebView for win32 1.add simple implement of WebView for win32 2.Modify `std::string' to `const std::string &' as issues 7958 said 3.Open the test case in cpp-tests
2014-09-17 22:30:15 +08:00
}
});
}
WebViewImpl::~WebViewImpl()
{
if (_systemWebControl != nullptr)
{
_systemWebControl->removeWebView();
delete _systemWebControl;
_systemWebControl = nullptr;
}
}
void WebViewImpl::loadData(const Data &data, const std::string &MIMEType, const std::string &encoding, const std::string &baseURL)
{
if (_createSucceeded)
{
std::string dataString(reinterpret_cast<char *>(data.getBytes()), static_cast<unsigned int>(data.getSize()));
_systemWebControl->loadData(dataString, MIMEType, encoding, baseURL);
}
}
void WebViewImpl::loadHTMLString(const std::string &string, const std::string &baseURL)
{
if (_createSucceeded)
{
_systemWebControl->loadHTMLString(string, baseURL);
}
}
fix compile error
2014-09-18 14:04:54 +08:00
void WebViewImpl::loadURL(const std::string &url)
add simple implement of WebView for win32 1.add simple implement of WebView for win32 2.Modify `std::string' to `const std::string &' as issues 7958 said 3.Open the test case in cpp-tests
2014-09-17 22:30:15 +08:00
{
if (_createSucceeded)
{
fix compile error
2014-09-18 14:04:54 +08:00
_systemWebControl->loadURL(url);
add simple implement of WebView for win32 1.add simple implement of WebView for win32 2.Modify `std::string' to `const std::string &' as issues 7958 said 3.Open the test case in cpp-tests
2014-09-17 22:30:15 +08:00
}
}
void WebViewImpl::loadFile(const std::string &fileName)
{
if (_createSucceeded)
{
std::string fullPath = FileUtils::getInstance()->fullPathForFilename(fileName);
_systemWebControl->loadFile(fullPath);
}
}
void WebViewImpl::stopLoading()
{
if (_createSucceeded)
{
_systemWebControl->stopLoading();
}
}
void WebViewImpl::reload()
{
if (_createSucceeded)
{
_systemWebControl->reload();
}
}
bool WebViewImpl::canGoBack()
{
if (_createSucceeded)
{
return _systemWebControl->canGoBack();
}
return false;
}
bool WebViewImpl::canGoForward()
{
if (_createSucceeded)
{
return _systemWebControl->canGoForward();
}
return false;
}
void WebViewImpl::goBack()
{
if (_createSucceeded)
{
_systemWebControl->goBack();
}
}
void WebViewImpl::goForward()
{
if (_createSucceeded)
{
_systemWebControl->goForward();
}
}
void WebViewImpl::setJavascriptInterfaceScheme(const std::string &scheme)
{
if (_createSucceeded)
{
_systemWebControl->setJavascriptInterfaceScheme(scheme);
}
}
void WebViewImpl::evaluateJS(const std::string &js)
{
if (_createSucceeded)
{
_systemWebControl->evaluateJS(js);
}
}
void WebViewImpl::setScalesPageToFit(const bool scalesPageToFit)
{
if (_createSucceeded)
{
_systemWebControl->setScalesPageToFit(scalesPageToFit);
}
}
void WebViewImpl::draw(Renderer *renderer, Mat4 const &transform, uint32_t flags)
{
if (_createSucceeded && (flags & Node::FLAGS_TRANSFORM_DIRTY))
{
Director *directorInstance = cocos2d::Director::getInstance();
GLView *glView = directorInstance->getOpenGLView();
const Size &frameSize = glView->getFrameSize();
const Size &winSize = directorInstance->getWinSize();
Vec2 leftBottom = this->_webView->convertToWorldSpace(Point::ZERO);
Vec2 rightTop = this->_webView->convertToWorldSpace(Point(_webView->getContentSize().width, _webView->getContentSize().height));
float uiLeft = frameSize.width / 2 + (leftBottom.x - winSize.width / 2) * glView->getScaleX();
float uiTop = frameSize.height / 2 - (rightTop.y - winSize.height / 2) * glView->getScaleY();
_systemWebControl->setWebViewRect(uiLeft, uiTop,
(rightTop.x - leftBottom.x) * glView->getScaleX(),
(rightTop.y - leftBottom.y) * glView->getScaleY());
}
}
void WebViewImpl::setVisible(bool visible)
{
if (_createSucceeded)
{
_systemWebControl->setWebViewVisible(visible);
}
}
} // namespace ui
} // namespace experimental
} //namespace cocos2d
//
// Implement Win32WebControl
//
bool Win32WebControl::s_isInitialized = false;
CComModule Win32WebControl::s_module;
void Win32WebControl::lazyInit()
{
HWND hwnd = cocos2d::Director::getInstance()->getOpenGLView()->getWin32Window();
LONG style = GetWindowLong(hwnd, GWL_STYLE);
SetWindowLong(hwnd, GWL_STYLE, style | WS_CLIPCHILDREN);
HINSTANCE hInstance = GetModuleHandle(NULL);
CoInitialize(NULL);
s_module.Init(NULL, hInstance);
AtlAxWinInit();
}
static HGLOBAL globalAllocWstringFromString(const std::string &str)
{
int len = MultiByteToWideChar(CP_UTF8, 0, str.c_str(), -1, NULL, 0);
if (len <= 0)
{
return NULL;
}
HGLOBAL wstr = GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT, (len + 1) * sizeof(WCHAR));
if (wstr == NULL)
{
return NULL;
}
MultiByteToWideChar(CP_UTF8, 0, str.c_str(), -1, (WCHAR *)wstr, len);
return wstr;
}
static std::string bstr2string(BSTR bstr)
{
wchar_t *str = OLE2W(bstr);
std::string ret;
int len = WideCharToMultiByte(CP_UTF8, 0, str, -1, NULL, 0, NULL, NULL);
if (len > 0)
{
HGLOBAL utf8Str = GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT, len + 1);
if (utf8Str != NULL)
{
WideCharToMultiByte(CP_UTF8, 0, str, -1, (char *)utf8Str, len, NULL, NULL);
ret.assign((char *)utf8Str);
GlobalFree(utf8Str);
}
}
return ret;
}
static bool isUrlJs(BSTR url)
{
return wcsncmp(OLE2W(url), L"javascript:", 11) == 0;
}
Win32WebControl::Win32WebControl()
: _webBrowser2(NULL)
, _connectionPoint(NULL)
, _htmlDoc(NULL)
, _goBackEnabled(true)
, _goForwardEnabled(true)
, _cookie(0)
, _reference(0)
, _shouldStartLoading(nullptr)
, _didFinishLoading(nullptr)
, _didFailLoading(nullptr)
{
if (!s_isInitialized)
{
lazyInit();
}
}
bool Win32WebControl::createWebView(
const std::function<bool (const std::string &)> &shouldStartLoading,
const std::function<void (const std::string &)> &didFinishLoading,
const std::function<void (const std::string &)> &didFailLoading,
const std::function<void (const std::string &)> &onJsCallback)
{
bool ret = false;
IConnectionPointContainer *container = NULL;
do
{
HWND hwnd = cocos2d::Director::getInstance()->getOpenGLView()->getWin32Window();
_winContainer.Create(hwnd, NULL, NULL, WS_CHILD | WS_VISIBLE);
HRESULT hr;
hr = _winContainer.CreateControl(L"shell.Explorer.2");
CC_BREAK_IF(FAILED(hr));
hr = _winContainer.QueryControl(__uuidof(IWebBrowser2), (void **)&_webBrowser2);
CC_BREAK_IF(FAILED(hr) || _webBrowser2 == NULL);
_webBrowser2->put_Silent(VARIANT_TRUE);
VARIANT var;
VariantInit(&var);
var.vt = VT_BSTR;
var.bstrVal = SysAllocString(L"about:blank");
hr = _webBrowser2->Navigate2(&var, NULL, NULL, NULL, NULL);
SysFreeString(var.bstrVal);
VariantClear(&var);
CC_BREAK_IF(FAILED(hr));
hr = _webBrowser2->QueryInterface(IID_IConnectionPointContainer, (void **)&container);
CC_BREAK_IF(FAILED(hr));
hr = container->FindConnectionPoint(DIID_DWebBrowserEvents2, &_connectionPoint);
CC_BREAK_IF(FAILED(hr));
hr = _connectionPoint->Advise(this, &_cookie);
CC_BREAK_IF(FAILED(hr));
hr = _webBrowser2->get_Document(&_htmlDoc);
CC_BREAK_IF(FAILED(hr));
ret = true;
} while (0);
if (!ret)
{
removeWebView();
}
if (container != NULL)
{
container->Release();
container = NULL;
}
_shouldStartLoading = shouldStartLoading;
_didFinishLoading = didFinishLoading;
_didFailLoading = didFailLoading;
_onJsCallback = onJsCallback;
return ret;
}
void Win32WebControl::removeWebView()
{
if (_connectionPoint != NULL)
{
_connectionPoint->Unadvise(_cookie);
_connectionPoint->Release();
_connectionPoint = NULL;
}
if (_htmlDoc != NULL)
{
_htmlDoc->Release();
_htmlDoc = NULL;
}
if (_webBrowser2 != NULL)
{
_webBrowser2->Release();
_webBrowser2 = NULL;
}
_winContainer.DestroyWindow();
}
void Win32WebControl::setWebViewRect(const int left, const int top, const int width, const int height)
{
_winContainer.MoveWindow(left, top, width, height);
}
void Win32WebControl::setJavascriptInterfaceScheme(const std::string &scheme) const
{
}
void Win32WebControl::loadData(const std::string &data, const std::string &MIMEType, const std::string &encoding, const std::string &baseURL) const
{
}
void Win32WebControl::loadHTMLString(const std::string &html, const std::string &baseURL)
{
//if (baseURL.empty())
//{
_loadHTMLString(html);
//}
//else
//{
// _htmlWillLoad = html;
fix compile error
2014-09-18 14:04:54 +08:00
// loadURL(baseURL);
add simple implement of WebView for win32 1.add simple implement of WebView for win32 2.Modify `std::string' to `const std::string &' as issues 7958 said 3.Open the test case in cpp-tests
2014-09-17 22:30:15 +08:00
//}
}
void Win32WebControl::_loadHTMLString(const std::string &html) const
{
bool flag = false;
HGLOBAL htmlText = globalAllocWstringFromString(html);
if (htmlText != NULL)
{
IStream *stream = NULL;
if (SUCCEEDED(CreateStreamOnHGlobal(htmlText, FALSE, &stream)))
{
IPersistStreamInit *persistStreamInit = NULL;
if (SUCCEEDED(_htmlDoc->QueryInterface(IID_IPersistStreamInit, (void **)&persistStreamInit)))
{
if (SUCCEEDED(persistStreamInit->InitNew()) && SUCCEEDED(persistStreamInit->Load(stream)))
{
flag = true;
}
persistStreamInit->Release();
}
stream->Release();
}
GlobalFree(htmlText);
}
if (flag)
{
if (_didFinishLoading != nullptr)
{
std::string str("data:text/html,");
str.append(html);
_didFinishLoading(str);
}
}
else
{
if (_didFailLoading != nullptr)
{
std::string str("data:text/html,");
str.append(html);
_didFailLoading(str);
}
}
}
fix compile error
2014-09-18 14:04:54 +08:00
void Win32WebControl::loadURL(BSTR url) const
add simple implement of WebView for win32 1.add simple implement of WebView for win32 2.Modify `std::string' to `const std::string &' as issues 7958 said 3.Open the test case in cpp-tests
2014-09-17 22:30:15 +08:00
{
VARIANT var;
VariantInit(&var);
var.vt = VT_BSTR;
var.bstrVal = url;
_webBrowser2->Navigate2(&var, NULL, NULL, NULL, NULL);
VariantClear(&var);
}
fix compile error
2014-09-18 14:04:54 +08:00
void Win32WebControl::loadURL(const std::wstring &url) const
add simple implement of WebView for win32 1.add simple implement of WebView for win32 2.Modify `std::string' to `const std::string &' as issues 7958 said 3.Open the test case in cpp-tests
2014-09-17 22:30:15 +08:00
{
BSTR bstr = SysAllocString(url.c_str());
fix compile error
2014-09-18 14:04:54 +08:00
loadURL(bstr);
add simple implement of WebView for win32 1.add simple implement of WebView for win32 2.Modify `std::string' to `const std::string &' as issues 7958 said 3.Open the test case in cpp-tests
2014-09-17 22:30:15 +08:00
SysFreeString(bstr);
}
fix compile error
2014-09-18 14:04:54 +08:00
void Win32WebControl::loadURL(const std::string &url) const
add simple implement of WebView for win32 1.add simple implement of WebView for win32 2.Modify `std::string' to `const std::string &' as issues 7958 said 3.Open the test case in cpp-tests
2014-09-17 22:30:15 +08:00
{
HGLOBAL unicodeStr = globalAllocWstringFromString(url);
if (unicodeStr != NULL)
{
fix compile error
2014-09-18 14:04:54 +08:00
loadURL(std::wstring((WCHAR *)unicodeStr));
add simple implement of WebView for win32 1.add simple implement of WebView for win32 2.Modify `std::string' to `const std::string &' as issues 7958 said 3.Open the test case in cpp-tests
2014-09-17 22:30:15 +08:00
GlobalFree(unicodeStr);
}
}
void Win32WebControl::loadFile(const std::string &filePath) const
{
HGLOBAL unicodeStr = globalAllocWstringFromString(filePath);
if (unicodeStr != NULL)
{
fix compile error
2014-09-18 14:04:54 +08:00
loadURL(std::wstring((WCHAR *)unicodeStr));
add simple implement of WebView for win32 1.add simple implement of WebView for win32 2.Modify `std::string' to `const std::string &' as issues 7958 said 3.Open the test case in cpp-tests
2014-09-17 22:30:15 +08:00
GlobalFree(unicodeStr);
}
}
void Win32WebControl::stopLoading() const
{
_webBrowser2->Stop();
}
void Win32WebControl::reload() const
{
_webBrowser2->Refresh();
}
bool Win32WebControl::canGoBack() const
{
return _goBackEnabled;
}
bool Win32WebControl::canGoForward() const
{
return _goForwardEnabled;
}
void Win32WebControl::goBack() const
{
_webBrowser2->GoBack();
}
void Win32WebControl::goForward() const
{
_webBrowser2->GoForward();
}
void Win32WebControl::evaluateJS(const std::string &js) const
{
std::string url("javascript:");
url.append(js);
fix compile error
2014-09-18 14:04:54 +08:00
loadURL(url);
add simple implement of WebView for win32 1.add simple implement of WebView for win32 2.Modify `std::string' to `const std::string &' as issues 7958 said 3.Open the test case in cpp-tests
2014-09-17 22:30:15 +08:00
}
void Win32WebControl::setScalesPageToFit(const bool scalesPageToFit) const
{
}
void Win32WebControl::setWebViewVisible(const bool visible) const
{
_webBrowser2->put_Visible(visible ? VARIANT_TRUE : VARIANT_FALSE);
}
// Implement IUnknown
HRESULT STDMETHODCALLTYPE Win32WebControl::QueryInterface(REFIID riid, void **ppvObject)
{
BOOL isBadPtr = FALSE;
CCASSERT(!(isBadPtr = IsBadWritePtr(ppvObject, sizeof(void *))), "");
if (isBadPtr)
{
return E_POINTER;
}
*ppvObject = NULL;
if (IsEqualIID(riid, IID_IUnknown) || IsEqualIID(riid, IID_IDispatch) || IsEqualIID(riid, DIID_DWebBrowserEvents2))
{
AddRef();
*ppvObject = this;
return S_OK;
}
return E_NOINTERFACE;
}
ULONG STDMETHODCALLTYPE Win32WebControl::AddRef(void)
{
InterlockedIncrement(&_reference);
return _reference;
}
ULONG STDMETHODCALLTYPE Win32WebControl::Release(void)
{
CCASSERT(_reference > 0, "reference count should greater than 0");
InterlockedDecrement(&_reference);
// do not delete this if _reference == 0, otherwise, it will crash when call removeWebView
return _reference;
}
// Implement IDispatch
HRESULT STDMETHODCALLTYPE Win32WebControl::GetTypeInfoCount(UINT *pctinfo)
{
*pctinfo = 0;
return S_OK;
}
HRESULT STDMETHODCALLTYPE Win32WebControl::GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
{
UNREFERENCED_PARAMETER(iTInfo);
UNREFERENCED_PARAMETER(lcid);
*ppTInfo = NULL;
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE Win32WebControl::GetIDsOfNames(
REFIID riid,
LPOLESTR *rgszNames,
UINT cNames,
LCID lcid,
DISPID *rgDispId)
{
UNREFERENCED_PARAMETER(riid);
UNREFERENCED_PARAMETER(rgszNames);
UNREFERENCED_PARAMETER(cNames);
UNREFERENCED_PARAMETER(lcid);
UNREFERENCED_PARAMETER(rgDispId);
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE Win32WebControl::Invoke(
DISPID dispIdMember,
REFIID riid,
LCID lcid,
WORD wFlags,
DISPPARAMS *pDispParams,
VARIANT *pVarResult,
EXCEPINFO *pExcepInfo,
UINT *puArgErr)
{
if (!IsEqualIID(riid, IID_NULL)) // riid should always be IID_NULL
{
return DISP_E_UNKNOWNINTERFACE;
}
switch (dispIdMember)
{
case DISPID_COMMANDSTATECHANGE:
if (pDispParams != NULL && pDispParams->cArgs == 2)
{
const VARIANTARG *rgvarg = pDispParams->rgvarg;
if (rgvarg[0].vt == VT_BOOL && rgvarg[1].vt == VT_I4)
{
switch (rgvarg[1].intVal)
{
case CSC_NAVIGATEFORWARD:
_goForwardEnabled = (rgvarg[0].boolVal != VARIANT_FALSE); // VARIANT_TRUE is -1
return S_OK;
case CSC_NAVIGATEBACK:
_goBackEnabled = (rgvarg[0].boolVal != VARIANT_FALSE); // VARIANT_TRUE is -1
return S_OK;
default:
break;
}
}
}
break;
case DISPID_BEFORENAVIGATE2:
if (pDispParams != NULL && pDispParams->cArgs == 7)
{
VARIANTARG *rgvarg = pDispParams->rgvarg;
if (rgvarg[6].vt == VT_DISPATCH && rgvarg[6].pdispVal == _webBrowser2)
{
if (rgvarg[0].vt == (VT_BYREF | VT_BOOL) && rgvarg[5].vt == (VT_BYREF | VT_VARIANT))
{
VARIANT_BOOL *cancel = rgvarg[0].pboolVal;
BSTR url = rgvarg[5].pvarVal->bstrVal;
*cancel = VARIANT_FALSE;
if (isUrlJs(url))
{
if (_onJsCallback != nullptr)
{
_onJsCallback(bstr2string(url));
}
}
else
{
if (_shouldStartLoading != nullptr)
{
*cancel = _shouldStartLoading(bstr2string(url)) ? VARIANT_FALSE : VARIANT_TRUE; // VARIANT_TRUE is -1
}
}
return S_OK;
}
}
}
break;
case DISPID_DOCUMENTCOMPLETE:
if (pDispParams != NULL && pDispParams->cArgs == 2)
{
const VARIANTARG *rgvarg = pDispParams->rgvarg;
if (rgvarg[1].vt == VT_DISPATCH && rgvarg[1].pdispVal == _webBrowser2 && rgvarg[0].vt == (VT_BYREF | VT_VARIANT))
{
READYSTATE state;
if (SUCCEEDED(_webBrowser2->get_ReadyState(&state)) && state == READYSTATE_COMPLETE)
{
BSTR url = rgvarg[0].pvarVal->bstrVal;
if (_didFinishLoading != nullptr && !isUrlJs(url)) // ignore js
{
_didFinishLoading(bstr2string(url));
}
if (!_htmlWillLoad.empty())
{
_loadHTMLString(_htmlWillLoad);
_htmlWillLoad.clear();
}
return S_OK;
}
}
}
break;
case DISPID_NAVIGATECOMPLETE2:
if (pDispParams != NULL && pDispParams->cArgs == 2)
{
const VARIANTARG *rgvarg = pDispParams->rgvarg;
if (rgvarg[1].vt == VT_DISPATCH && rgvarg[1].pdispVal == _webBrowser2)
{
if (rgvarg[0].vt == (VT_BYREF | VT_VARIANT))
{
BSTR url = rgvarg[0].pvarVal->bstrVal;
return S_OK;
}
}
}
break;
case DISPID_NAVIGATEERROR:
if (pDispParams != NULL && pDispParams->cArgs == 5)
{
const VARIANTARG *rgvarg = pDispParams->rgvarg;
if (rgvarg[4].vt == VT_DISPATCH && rgvarg[4].pdispVal == _webBrowser2)
{
if (rgvarg[3].vt == (VT_BYREF | VT_VARIANT) && rgvarg[1].vt == (VT_BYREF | VT_VARIANT) && rgvarg[0].vt == (VT_BYREF | VT_BOOL))
{
VARIANT_BOOL *cancel = rgvarg[0].pboolVal;
HRESULT codes = rgvarg[1].pvarVal->lVal;
BSTR url = rgvarg[3].pvarVal->bstrVal;
if (_didFailLoading != nullptr && !isUrlJs(url)) // ignore js
{
_didFailLoading(bstr2string(url));
}
*cancel = VARIANT_FALSE;
return S_OK;
}
}
}
break;
case DISPID_PROGRESSCHANGE:
if (pDispParams != NULL && pDispParams->cArgs == 2)
{
const VARIANTARG *rgvarg = pDispParams->rgvarg;
if (rgvarg[0].vt == VT_I4 && rgvarg[1].vt == VT_I4)
{
LONG maxProgress = rgvarg[0].lVal;
LONG curProgress = rgvarg[1].lVal;
return S_OK;
}
}
break;
case DISPID_NEWWINDOW2:
if (pDispParams != NULL && pDispParams->cArgs == 2)
{
const VARIANTARG *rgvarg = pDispParams->rgvarg;
if (rgvarg[0].vt == (VT_BYREF | VT_BOOL) && rgvarg[1].vt == (VT_BYREF | VT_DISPATCH))
{
VARIANT_BOOL *cancel = rgvarg[0].pboolVal;
IDispatch **dis = rgvarg[1].ppdispVal;
*dis = NULL;
*cancel = VARIANT_TRUE; // forbit to create new window
return S_OK;
}
}
break;
case DISPID_NEWWINDOW3:
if (pDispParams != NULL && pDispParams->cArgs == 5)
{
const VARIANTARG *rgvarg = pDispParams->rgvarg;
if (rgvarg[0].vt == VT_BSTR && rgvarg[1].vt == VT_BSTR && rgvarg[2].vt == VT_I4
&& rgvarg[3].vt == (VT_BYREF | VT_BOOL) && rgvarg[4].vt == (VT_BYREF | VT_DISPATCH))
{
BSTR url = rgvarg[0].bstrVal;
BSTR urlContext = rgvarg[1].bstrVal;
LONG flags = rgvarg[2].lVal;
VARIANT_BOOL *cancel = rgvarg[3].pboolVal;
IDispatch **dis = rgvarg[4].ppdispVal;
*dis = NULL;
*cancel = VARIANT_TRUE; // forbit to create new window
fix compile error
2014-09-18 14:04:54 +08:00
loadURL(url);
add simple implement of WebView for win32 1.add simple implement of WebView for win32 2.Modify `std::string' to `const std::string &' as issues 7958 said 3.Open the test case in cpp-tests
2014-09-17 22:30:15 +08:00
return S_OK;
}
}
break;
default:
break;
}
return E_NOTIMPL;
}
#endif // CC_TARGET_PLATFORM == CC_PLATFORM_WIN32