#include "webview/Cef3GeometryUtil.h"
|
#include "SWebView.h"
|
#include "webview/Cef3WinUtil.h"
|
#include "Cef3ExtendEvents.h"
|
#include "webview/Cef3MainContext.h"
|
#include "webview/Cef3OsrImeHandlerWin.h"
|
|
namespace SOUI {
|
|
#define CHECK_CEF_BROWSER_HOST \
|
if (first_show_) return; \
|
if ( !webview_handler_ ) return; \
|
CefRefPtr<CefBrowser> pb = webview_handler_->GetBrowser(); \
|
if ( !pb.get() ) return;\
|
CefRefPtr<CefBrowserHost> host = pb->GetHost(); \
|
if (!host) return;
|
|
#define CHECK_CEF_BROWSER_HOST_EX \
|
if ( !webview_handler_ ) return 0; \
|
CefRefPtr<CefBrowser> pb = webview_handler_->GetBrowser(); \
|
if ( !pb.get() ) return 0;\
|
CefRefPtr<CefBrowserHost> host = pb->GetHost(); \
|
if (!host) return 0
|
|
SWebView::SWebView(void)
|
: m_bSkipCursor(FALSE)
|
, m_bInternalPaint(FALSE)
|
, m_bBkgndDirty(TRUE)
|
, hidden_(false)
|
, first_show_(true)
|
, painting_popup_(false)
|
, device_scale_factor_(browser::GetDeviceScaleFactor())
|
, resize_popup_(false)
|
, last_click_x_(0)
|
, last_click_y_(0)
|
, last_click_time_(0)
|
, last_mouse_pos_()
|
, current_mouse_pos_()
|
, mouse_rotation_(false)
|
, mouse_tracking_(false)
|
, last_click_count_(0)
|
, last_click_button_(MBT_LEFT)
|
, last_mouse_down_on_view_(false)
|
, draw_popup_(false) {
|
|
m_evtSet.addEvent(EVENTID(EventWebViewNotify));
|
m_evtSet.addEvent(EVENTID(EventURLChange));
|
m_evtSet.addEvent(EVENTID(EventWebviewLoadEnd));
|
|
m_bDrawFocusRect = FALSE;
|
webview_handler_ = new browser::CCef3WebviewHandler;
|
webview_handler_->AddRef();
|
|
m_bFocusable = TRUE;
|
}
|
|
SWebView::~SWebView(void) {
|
webview_handler_->Release();
|
}
|
|
void SWebView::SetDevTools(bool devtools) {
|
browser::CCef3MainContext::Get()->SetDevToolsClient(this);
|
}
|
// ------------------------------------------------------------------------------
|
//
|
// methods for user
|
//
|
// ------------------------------------------------------------------------------
|
|
BOOL SWebView::LoadURL(const SStringW& url) {
|
if (!webview_handler_) {
|
return FALSE;
|
}
|
|
CefRefPtr<CefBrowser> pb = webview_handler_->GetBrowser();
|
if (pb.get()) {
|
CefRefPtr<CefFrame> frame = pb->GetMainFrame();
|
if (!frame)
|
return FALSE;
|
|
m_strUrl = url;
|
frame->LoadURL((LPCWSTR) url);
|
}
|
return TRUE;
|
}
|
|
SStringW SWebView::GetTitle() {
|
return m_strTitle;
|
}
|
|
SStringW SWebView::GetURL() {
|
return m_strUrl;
|
}
|
|
void SWebView::ExecJavaScript(const SStringW& js) {
|
if (!webview_handler_) {
|
return;
|
}
|
|
CefRefPtr<CefBrowser> pb = webview_handler_->GetBrowser();
|
if (pb.get()) {
|
CefRefPtr<CefFrame> frame = pb->GetMainFrame();
|
if (frame) {
|
frame->ExecuteJavaScript((LPCWSTR) js, L"", 0);
|
}
|
}
|
}
|
|
BOOL SWebView::CanGoBack() {
|
if (!webview_handler_) {
|
return FALSE;
|
}
|
|
CefRefPtr<CefBrowser> pb = webview_handler_->GetBrowser();
|
if (pb.get()) {
|
return pb->CanGoBack();
|
}
|
|
return FALSE;
|
}
|
|
void SWebView::GoBack() {
|
if (!webview_handler_) {
|
return;
|
}
|
|
CefRefPtr<CefBrowser> pb = webview_handler_->GetBrowser();
|
if (pb.get()) {
|
return pb->GoBack();
|
}
|
}
|
|
BOOL SWebView::CanGoForward() {
|
if (!webview_handler_) {
|
return FALSE;
|
}
|
|
CefRefPtr<CefBrowser> pb = webview_handler_->GetBrowser();
|
if (pb.get()) {
|
return pb->CanGoForward();
|
}
|
|
return FALSE;
|
}
|
|
void SWebView::GoForward() {
|
if (!webview_handler_) {
|
return;
|
}
|
|
CefRefPtr<CefBrowser> pb = webview_handler_->GetBrowser();
|
if (pb.get()) {
|
return pb->GoForward();
|
}
|
}
|
|
BOOL SWebView::IsLoading() {
|
if (!webview_handler_) {
|
return FALSE;
|
}
|
|
CefRefPtr<CefBrowser> pb = webview_handler_->GetBrowser();
|
if (pb.get()) {
|
return pb->IsLoading();
|
}
|
|
return FALSE;
|
}
|
|
void SWebView::Reload() {
|
if (!webview_handler_) {
|
return;
|
}
|
|
CefRefPtr<CefBrowser> pb = webview_handler_->GetBrowser();
|
if (pb.get()) {
|
return pb->Reload();
|
}
|
}
|
|
void SWebView::StopLoad() {
|
if (!webview_handler_) {
|
return;
|
}
|
|
CefRefPtr<CefBrowser> pb = webview_handler_->GetBrowser();
|
if (pb.get()) {
|
return pb->StopLoad();
|
}
|
}
|
|
BOOL SWebView::Open() {
|
CefRefPtr<CefBrowser> pb = webview_handler_->GetBrowser();
|
if (pb.get()) {
|
return TRUE;
|
}
|
|
if (!webview_handler_->Open(GetContainer()->GetHostHwnd(), GetClientRect())) {
|
return FALSE;
|
}
|
|
webview_handler_->SetRender(this);
|
webview_handler_->RegisterMessageHandler(this);
|
return TRUE;
|
}
|
|
void SWebView::Close() {
|
webview_handler_->CloseAllBrowsers(true);
|
webview_handler_->SetRender(NULL);
|
webview_handler_->UnRegisterMessgeHandler(this);
|
m_bBkgndDirty = TRUE;
|
m_pBitmapBuff = NULL;
|
}
|
|
void SWebView::GetWebViewSource(std::function<void(const CefString&)> &&callback) {
|
class Visitor : public CefStringVisitor {
|
public:
|
explicit Visitor(std::function<void(const CefString&)> &&cb)
|
: callback_(std::move(cb)) {
|
}
|
virtual void Visit(const CefString& strSource) OVERRIDE {
|
callback_(strSource);
|
}
|
|
private:
|
std::function<void(const CefString &)> callback_;
|
IMPLEMENT_REFCOUNTING(Visitor);
|
};
|
webview_handler_->GetBrowser()->GetMainFrame()->GetSource(new Visitor(std::move(callback)));
|
}
|
|
void SWebView::UpdateBkgndRenderTarget() {
|
// ¸üб³¾°RenderTarget
|
CRect rcWnd = GetClientRect();
|
if (!m_prtBackground) {
|
GETRENDERFACTORY->CreateRenderTarget(&m_prtBackground, rcWnd.Width(), rcWnd.Height());
|
} else {
|
m_prtBackground->Resize(rcWnd.Size());
|
}
|
m_prtBackground->SetViewportOrg(-rcWnd.TopLeft());
|
m_bBkgndDirty = TRUE;
|
}
|
|
int SWebView::OnCreate(LPVOID) {
|
ime_handler_.reset(
|
new browser::CCef3OsrImeHandlerWin(GetContainer()->GetHostHwnd()));
|
Open();
|
if (!m_strUrl.IsEmpty()) {
|
LoadURL(m_strUrl);
|
}
|
|
return 0;
|
}
|
|
void SWebView::OnSize(UINT nType, CSize size) {
|
STRACE(L"webview resized");
|
|
SWindow::OnSize(nType, size);
|
UpdateBkgndRenderTarget();
|
|
if (ime_handler_) {//µ÷ÕûÊäÈë·¨´°¿ÚλÖÃ.°ì·¨Óе㱿
|
CPoint &pt = GetWindowRect().TopLeft();
|
ime_handler_->UpdateHostPosition(CefPoint(pt.x, pt.y));
|
}
|
|
if (!m_pBitmapBuff || (m_pBitmapBuff->Width() != (unsigned int) size.cx || m_pBitmapBuff->Height() != (unsigned int) size.cy)) {
|
CHECK_CEF_BROWSER_HOST;
|
host->WasResized();
|
}
|
|
}
|
|
BOOL SWebView::OnAttrUrl(SStringW strValue, BOOL bLoading) {
|
m_strUrl = strValue;
|
|
if (!bLoading) {
|
LoadURL(strValue);
|
}
|
|
return !bLoading;
|
}
|
|
void SWebView::OnDestroy() {
|
STRACE(L"webview destroy");
|
|
GetContainer()->RevokeDragDrop(GetSwnd());
|
ime_handler_.reset();
|
if (webview_handler_) {
|
Close();
|
}
|
|
SWindow::OnDestroy();
|
}
|
|
void SWebView::OnPaint(IRenderTarget *pRT) {
|
//STRACE(L"web view onpaint");
|
//LOGI(__FILE__, GetCurrentThreadId());
|
|
CRect rcWnd = GetClientRect();
|
|
if (m_bBkgndDirty && m_prtBackground) {
|
m_bBkgndDirty = FALSE;
|
m_prtBackground->BitBlt(rcWnd, pRT, rcWnd.left, rcWnd.top);
|
}
|
|
SWindow::OnPaint(pRT);
|
|
if (!first_show_ && webview_handler_) {
|
CRect rcClipBox;
|
pRT->GetClipBox(rcClipBox);
|
rcClipBox.IntersectRect(rcClipBox, rcWnd);
|
|
CHECK_CEF_BROWSER_HOST;
|
|
// request cef to update buff bitmap
|
m_bInternalPaint = TRUE;
|
|
host->Invalidate(PET_VIEW);
|
|
m_bInternalPaint = FALSE;
|
}
|
|
if (m_pBitmapBuff) {
|
rcWnd.right = rcWnd.left + m_pBitmapBuff->Width();
|
rcWnd.bottom = rcWnd.top + m_pBitmapBuff->Height();
|
pRT->DrawBitmap(rcWnd, m_pBitmapBuff, 0, 0, 0xFF);
|
}
|
}
|
|
LRESULT SWebView::OnCaptureChanged(UINT uMsg, WPARAM wParam, LPARAM lParam) {
|
SendCaptureLostEvent(uMsg, wParam, lParam);
|
return 0;
|
}
|
|
LRESULT SWebView::OnMouseEvent(UINT uMsg, WPARAM wParam, LPARAM lParam) {
|
SendMouseEvent(uMsg, wParam, lParam);
|
return 0;
|
}
|
|
LRESULT SWebView::OnKeyEvent(UINT uMsg, WPARAM wParam, LPARAM lParam) {
|
SendKeyEvent(uMsg, wParam, lParam);
|
return 0;
|
}
|
|
void SWebView::OnSetFocus(SWND wndOld) {
|
CHECK_CEF_BROWSER_HOST;
|
|
STRACE(L"set browser focus");
|
host->SendFocusEvent(true);
|
}
|
|
void SWebView::OnKillFocus(SWND wndFocus) {
|
CHECK_CEF_BROWSER_HOST;
|
|
STRACE(L"kill browser focus");
|
|
host->SendFocusEvent(false);
|
}
|
|
void SWebView::OnShowWindow(BOOL bShow, UINT nStatus) {
|
SWindow::OnShowWindow(bShow, nStatus);
|
|
if (first_show_ && IsVisible(TRUE)) {
|
first_show_ = false;
|
}
|
|
CHECK_CEF_BROWSER_HOST;
|
host->WasHidden(!bShow);
|
|
if (bShow) {
|
SetFocus();
|
host->SendFocusEvent(true);
|
}
|
}
|
|
BOOL SWebView::OnSetCursor(const CPoint &pt) {
|
return TRUE;
|
}
|
|
LRESULT SWebView::OnIMESetContext(UINT message, WPARAM wParam, LPARAM lParam) {
|
lParam &= ~ISC_SHOWUICOMPOSITIONWINDOW;
|
::DefWindowProc(GetContainer()->GetHostHwnd(), message, wParam, lParam);
|
|
// Create Caret Window if required
|
if (ime_handler_) {
|
CPoint &pt = GetWindowRect().TopLeft();
|
ime_handler_->CreateImeWindow();
|
ime_handler_->MoveImeWindow();
|
}
|
|
return 0;
|
}
|
|
LRESULT SWebView::OnIMEStartComposition(UINT message, WPARAM wParam, LPARAM lParam) {
|
if (ime_handler_) {
|
CPoint &pt = GetWindowRect().TopLeft();
|
ime_handler_->CreateImeWindow();
|
ime_handler_->MoveImeWindow();
|
ime_handler_->ResetComposition();
|
}
|
return 0;
|
}
|
|
LRESULT SWebView::OnIMEComposition(UINT message, WPARAM wParam, LPARAM lParam) {
|
if (webview_handler_->GetBrowser() && ime_handler_) {
|
CefRefPtr<CefBrowser> browser = webview_handler_->GetBrowser();
|
CefString cTextStr;
|
if (ime_handler_->GetResult(lParam, cTextStr)) {
|
// Send the text to the browser. The |replacement_range| and
|
// |relative_cursor_pos| params are not used on Windows, so provide
|
// default invalid values.
|
browser->GetHost()->ImeCommitText(cTextStr,
|
CefRange(UINT32_MAX, UINT32_MAX), 0);
|
ime_handler_->ResetComposition();
|
// Continue reading the composition string - Japanese IMEs send both
|
// GCS_RESULTSTR and GCS_COMPSTR.
|
}
|
|
std::vector<CefCompositionUnderline> underlines;
|
int composition_start = 0;
|
|
if (ime_handler_->GetComposition(lParam, cTextStr, underlines,
|
composition_start)) {
|
// Send the composition string to the browser. The |replacement_range|
|
// param is not used on Windows, so provide a default invalid value.
|
browser->GetHost()->ImeSetComposition(
|
cTextStr, underlines, CefRange(UINT32_MAX, UINT32_MAX),
|
CefRange(composition_start,
|
static_cast<int>(composition_start + cTextStr.length())));
|
|
// Update the Candidate Window position. The cursor is at the end so
|
// subtract 1. This is safe because IMM32 does not support non-zero-width
|
// in a composition. Also, negative values are safely ignored in
|
// MoveImeWindow
|
ime_handler_->UpdateCaretPosition(composition_start - 1);
|
} else {
|
OnIMECancelCompositionEvent(message, wParam, lParam);
|
}
|
}
|
return 0;
|
}
|
|
LRESULT SWebView::OnIMECancelCompositionEvent(UINT message, WPARAM wParam, LPARAM lParam) {
|
CefRefPtr<CefBrowser> browser = webview_handler_->GetBrowser();
|
if (browser && ime_handler_) {
|
browser->GetHost()->ImeCancelComposition();
|
ime_handler_->ResetComposition();
|
ime_handler_->DestroyImeWindow();
|
}
|
return 0;
|
}
|
|
// ------------------------------------------------------------------------------
|
//
|
// callback helper methods
|
//
|
// ------------------------------------------------------------------------------
|
//
|
|
|
void SWebView::SendFocusEvent(bool focus) {
|
CHECK_CEF_BROWSER_HOST;
|
|
STRACE(L"sent browser focus:%d", focus);
|
host->SendFocusEvent(focus);
|
}
|
|
void SWebView::SendMouseEvent(UINT message, WPARAM wParam, LPARAM lParam) {
|
CHECK_CEF_BROWSER_HOST;
|
|
LONG currentTime = 0;
|
bool cancelPreviousClick = false;
|
|
if (message == WM_LBUTTONDOWN || message == WM_RBUTTONDOWN ||
|
message == WM_MBUTTONDOWN || message == WM_MOUSEMOVE ||
|
message == WM_MOUSELEAVE) {
|
currentTime = GetMessageTime();
|
|
CRect rcView = GetClientRect();
|
CPoint pt(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
|
|
int x = pt.x - rcView.left;
|
int y = pt.y - rcView.top;
|
|
cancelPreviousClick =
|
(abs(last_click_x_ - x) > (GetSystemMetrics(SM_CXDOUBLECLK) / 2))
|
|| (abs(last_click_y_ - y) > (GetSystemMetrics(SM_CYDOUBLECLK) / 2))
|
|| ((currentTime - last_click_time_) > GetDoubleClickTime());
|
if (cancelPreviousClick &&
|
(message == WM_MOUSEMOVE || message == WM_MOUSELEAVE)) {
|
last_click_count_ = 0;
|
last_click_x_ = 0;
|
last_click_y_ = 0;
|
last_click_time_ = 0;
|
}
|
}
|
|
switch (message) {
|
case WM_LBUTTONDOWN:
|
case WM_RBUTTONDOWN:
|
case WM_MBUTTONDOWN:
|
{
|
SetCapture();
|
SetFocus();
|
CRect rcView = GetClientRect();
|
CPoint pt(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
|
|
int x = pt.x - rcView.left;
|
int y = pt.y - rcView.top;
|
|
if (wParam & MK_SHIFT) {
|
// Start rotation effect.
|
last_mouse_pos_.x = current_mouse_pos_.x = x;
|
last_mouse_pos_.y = current_mouse_pos_.y = y;
|
mouse_rotation_ = true;
|
} else {
|
CefBrowserHost::MouseButtonType btnType =
|
(message == WM_LBUTTONDOWN ? MBT_LEFT : (
|
message == WM_RBUTTONDOWN ? MBT_RIGHT : MBT_MIDDLE));
|
if (!cancelPreviousClick && (btnType == last_click_button_)) {
|
++last_click_count_;
|
} else {
|
last_click_count_ = 1;
|
last_click_x_ = x;
|
last_click_y_ = y;
|
}
|
last_click_time_ = currentTime;
|
last_click_button_ = btnType;
|
|
if (host) {
|
CefMouseEvent mouse_event;
|
mouse_event.x = x;
|
mouse_event.y = y;
|
last_mouse_down_on_view_ = !IsOverPopupWidget(x, y);
|
ApplyPopupOffset(mouse_event.x, mouse_event.y);
|
browser::DeviceToLogical(mouse_event, device_scale_factor_);
|
mouse_event.modifiers = browser::GetCefMouseModifiers(wParam);
|
host->SendMouseClickEvent(mouse_event, btnType, false,
|
last_click_count_);
|
}
|
}
|
} break;
|
|
case WM_LBUTTONUP:
|
case WM_RBUTTONUP:
|
case WM_MBUTTONUP:
|
if (::GetCapture() == GetContainer()->GetHostHwnd())
|
ReleaseCapture();
|
if (mouse_rotation_) {
|
// End rotation effect.
|
mouse_rotation_ = false;
|
//renderer_.SetSpin(0, 0);
|
Invalidate();
|
} else {
|
CRect rcView = GetClientRect();
|
CPoint pt(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
|
|
int x = pt.x - rcView.left;
|
int y = pt.y - rcView.top;
|
|
CefBrowserHost::MouseButtonType btnType =
|
(message == WM_LBUTTONUP ? MBT_LEFT : (
|
message == WM_RBUTTONUP ? MBT_RIGHT : MBT_MIDDLE));
|
if (host) {
|
CefMouseEvent mouse_event;
|
mouse_event.x = x;
|
mouse_event.y = y;
|
if (last_mouse_down_on_view_ &&
|
IsOverPopupWidget(x, y) &&
|
(GetPopupXOffset() || GetPopupYOffset())) {
|
break;
|
}
|
ApplyPopupOffset(mouse_event.x, mouse_event.y);
|
browser::DeviceToLogical(mouse_event, device_scale_factor_);
|
mouse_event.modifiers = browser::GetCefMouseModifiers(wParam);
|
host->SendMouseClickEvent(mouse_event, btnType, true,
|
last_click_count_);
|
}
|
}
|
break;
|
|
case WM_MOUSEMOVE:
|
{
|
CRect rcView = GetClientRect();
|
CPoint pt(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
|
|
int x = pt.x - rcView.left;
|
int y = pt.y - rcView.top;
|
|
bool leave = !rcView.PtInRect(pt) && !IsCaptured();
|
|
if (leave)
|
m_bSkipCursor = TRUE;
|
else
|
m_bSkipCursor = FALSE;
|
|
if (mouse_rotation_) {
|
// Apply rotation effect.
|
current_mouse_pos_.x = x;
|
current_mouse_pos_.y = y;
|
//renderer_.IncrementSpin(
|
// current_mouse_pos_.x - last_mouse_pos_.x,
|
// current_mouse_pos_.y - last_mouse_pos_.y);
|
last_mouse_pos_.x = current_mouse_pos_.x;
|
last_mouse_pos_.y = current_mouse_pos_.y;
|
Invalidate();
|
} else {
|
if (!mouse_tracking_) {
|
// Start tracking mouse leave. Required for the WM_MOUSELEAVE event to
|
// be generated.
|
TRACKMOUSEEVENT tme;
|
tme.cbSize = sizeof(TRACKMOUSEEVENT);
|
tme.dwFlags = TME_LEAVE;
|
tme.hwndTrack = GetContainer()->GetHostHwnd();
|
TrackMouseEvent(&tme);
|
mouse_tracking_ = true;
|
}
|
|
if (host) {
|
CefMouseEvent mouse_event;
|
mouse_event.x = x;
|
mouse_event.y = y;
|
ApplyPopupOffset(mouse_event.x, mouse_event.y);
|
browser::DeviceToLogical(mouse_event, device_scale_factor_);
|
mouse_event.modifiers = browser::GetCefMouseModifiers(wParam);
|
host->SendMouseMoveEvent(mouse_event, false);
|
}
|
}
|
break;
|
}
|
|
case WM_MOUSELEAVE:
|
{
|
if (mouse_tracking_) {
|
// Stop tracking mouse leave.
|
TRACKMOUSEEVENT tme;
|
tme.cbSize = sizeof(TRACKMOUSEEVENT);
|
tme.dwFlags = TME_LEAVE & TME_CANCEL;
|
tme.hwndTrack = GetContainer()->GetHostHwnd();
|
TrackMouseEvent(&tme);
|
mouse_tracking_ = false;
|
}
|
|
if (host) {
|
// Determine the cursor position in screen coordinates.
|
POINT p;
|
::GetCursorPos(&p);
|
::ScreenToClient(GetContainer()->GetHostHwnd(), &p);
|
|
CefMouseEvent mouse_event;
|
mouse_event.x = p.x;
|
mouse_event.y = p.y;
|
browser::DeviceToLogical(mouse_event, device_scale_factor_);
|
mouse_event.modifiers = browser::GetCefMouseModifiers(wParam);
|
host->SendMouseMoveEvent(mouse_event, true);
|
}
|
} break;
|
|
case WM_MOUSEWHEEL:
|
if (host) {
|
CRect rcView = GetClientRect();
|
CPoint pt(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
|
::ClientToScreen(GetContainer()->GetHostHwnd(), &pt);
|
|
POINT screen_point = {pt.x - rcView.left, pt.y - rcView.top};
|
|
HWND scrolled_wnd = ::WindowFromPoint(screen_point);
|
if (scrolled_wnd != GetContainer()->GetHostHwnd())
|
break;
|
|
::ScreenToClient(GetContainer()->GetHostHwnd(), &screen_point);
|
int delta = GET_WHEEL_DELTA_WPARAM(wParam);
|
|
CefMouseEvent mouse_event;
|
mouse_event.x = screen_point.x;
|
mouse_event.y = screen_point.y;
|
ApplyPopupOffset(mouse_event.x, mouse_event.y);
|
browser::DeviceToLogical(mouse_event, device_scale_factor_);
|
mouse_event.modifiers = browser::GetCefMouseModifiers(wParam);
|
host->SendMouseWheelEvent(mouse_event,
|
browser::IsKeyDown(VK_SHIFT) ? delta : 0,
|
!browser::IsKeyDown(VK_SHIFT) ? delta : 0);
|
}
|
break;
|
}
|
|
}
|
|
void SWebView::SendKeyEvent(UINT uMsg, WPARAM wp, LPARAM lp) {
|
CHECK_CEF_BROWSER_HOST;
|
|
CefKeyEvent event;
|
event.windows_key_code = wp;
|
event.native_key_code = lp;
|
event.is_system_key = uMsg == WM_SYSCHAR || uMsg == WM_SYSKEYDOWN ||
|
uMsg == WM_SYSKEYUP;
|
|
if (uMsg == WM_KEYDOWN || uMsg == WM_SYSKEYDOWN)
|
event.type = KEYEVENT_RAWKEYDOWN;
|
else if (uMsg == WM_KEYUP || uMsg == WM_SYSKEYUP)
|
event.type = KEYEVENT_KEYUP;
|
else
|
event.type = KEYEVENT_CHAR;
|
event.modifiers = browser::GetCefKeyboardModifiers(wp, lp);
|
|
host->SendKeyEvent(event);
|
}
|
|
void SWebView::SendCaptureLostEvent(UINT uMsg, WPARAM wp, LPARAM lp) {
|
if (mouse_rotation_)
|
return;
|
|
CHECK_CEF_BROWSER_HOST;
|
|
STRACE(L"browser send capture losted");
|
host->SendCaptureLostEvent();
|
}
|
|
void SWebView::Draw(int x, int y, IBitmap * pbuff) {
|
if (m_bInternalPaint || !m_prtBackground || m_bBkgndDirty) {
|
STRACE(L"on ready...");
|
return;
|
}
|
|
|
CRect rcWnd = GetClientRect();
|
rcWnd.left += x;
|
rcWnd.top += y;
|
|
if ((unsigned int) rcWnd.Width() != pbuff->Width() || (unsigned int) rcWnd.Height() != pbuff->Height()) {
|
rcWnd.right = rcWnd.left + pbuff->Width();
|
rcWnd.bottom = rcWnd.top + pbuff->Height();
|
}
|
|
CAutoRefPtr<IRegion> rgn;
|
GETRENDERFACTORY->CreateRegion(&rgn);
|
rgn->CombineRect(rcWnd, RGN_OR);
|
|
CAutoRefPtr<IRenderTarget> pRT = GetRenderTarget(rcWnd, OLEDC_PAINTBKGND, FALSE);
|
pRT->BitBlt(rcWnd, m_prtBackground, rcWnd.left, rcWnd.top);
|
pRT->DrawBitmap(rcWnd, pbuff, 0, 0, 0xFF);
|
ReleaseRenderTarget(pRT);
|
}
|
|
BOOL SWebView::IsCaptured() {
|
return GetCapture() == GetSwnd();
|
}
|
|
int SWebView::GetPopupXOffset() const {
|
CEF_REQUIRE_UI_THREAD();
|
return original_popup_rect_.x - popup_rc.left;
|
}
|
|
int SWebView::GetPopupYOffset() const {
|
CEF_REQUIRE_UI_THREAD();
|
return original_popup_rect_.y - popup_rc.top;
|
}
|
|
void SWebView::ApplyPopupOffset(int& x, int& y) const {
|
if (IsOverPopupWidget(x, y)) {
|
x += GetPopupXOffset();
|
y += GetPopupYOffset();
|
}
|
}
|
|
bool SWebView::IsOverPopupWidget(int x, int y) const {
|
CEF_REQUIRE_UI_THREAD();
|
int popup_right = popup_rc.left + popup_rc.Width();
|
int popup_bottom = popup_rc.top + popup_rc.Height();
|
return (x >= popup_rc.left) && (x < popup_right) && (y >= popup_rc.top) && (y < popup_bottom);
|
}
|
|
//
|
// SWebViewHandler::MessageHandlermethods
|
//
|
bool SWebView::OnBrowserMessage(CefRefPtr<CefBrowser> browser,
|
CefProcessId source_process,
|
CefRefPtr<CefProcessMessage> message) {
|
EventWebViewNotify evt(this);
|
|
evt.MessageName = message->GetName().ToWString().c_str();
|
CefRefPtr<CefListValue> arg = message->GetArgumentList();
|
|
for (unsigned int i = 0; i < arg->GetSize(); ++i) {
|
SStringW str = arg->GetString(i).ToWString().c_str();
|
evt.Arguments.Add(str);
|
}
|
|
return !!FireEvent(evt);
|
}
|
|
//ClientHandlerOsr::OsrDelegate methods.
|
|
void SWebView::OnAfterCreated(CefRefPtr<CefBrowser> browser) {
|
CEF_REQUIRE_UI_THREAD();
|
if (!m_strUrl.IsEmpty()) {
|
LoadURL(m_strUrl);
|
}
|
}
|
|
|
void SWebView::OnBeforeClose(CefRefPtr<CefBrowser> browser) {
|
CEF_REQUIRE_UI_THREAD();
|
//Destroy();
|
}
|
|
|
bool SWebView::GetRootScreenRect(CefRefPtr<CefBrowser> browser,
|
CefRect& rect) {
|
CEF_REQUIRE_UI_THREAD();
|
return false;
|
}
|
|
bool SWebView::GetViewRect(CefRefPtr<CefBrowser> browser,
|
CefRect& rect) {
|
CEF_REQUIRE_UI_THREAD();
|
|
//STRACE(L"browser get view rect");
|
CRect rc = GetClientRect();
|
|
rect.x = rect.y = 0;
|
rect.width = browser::DeviceToLogical(rc.Width(), device_scale_factor_);
|
rect.height = browser::DeviceToLogical(rc.Height(), device_scale_factor_);
|
return true;
|
}
|
|
bool SWebView::GetScreenPoint(CefRefPtr<CefBrowser> browser,
|
int viewX,
|
int viewY,
|
int& screenX,
|
int& screenY) {
|
CEF_REQUIRE_UI_THREAD();
|
|
// Convert the point from view coordinates to actual screen coordinates.
|
POINT screen_pt = {browser::LogicalToDevice(viewX, device_scale_factor_),
|
browser::LogicalToDevice(viewY, device_scale_factor_)};
|
ClientToScreen(GetContainer()->GetHostHwnd(), &screen_pt);
|
screenX = screen_pt.x;
|
screenY = screen_pt.y;
|
return true;
|
}
|
|
|
bool SWebView::GetScreenInfo(CefRefPtr<CefBrowser> browser,
|
CefScreenInfo& screen_info) {
|
CEF_REQUIRE_UI_THREAD();
|
|
if (!IsVisible())
|
return false;
|
|
CefRect view_rect;
|
GetViewRect(browser, view_rect);
|
|
screen_info.device_scale_factor = device_scale_factor_;
|
|
// The screen info rectangles are used by the renderer to create and position
|
// popups. Keep popups inside the view rectangle.
|
screen_info.rect = view_rect;
|
screen_info.available_rect = view_rect;
|
return true;
|
}
|
|
void SWebView::OnPopupShow(CefRefPtr<CefBrowser> browser,
|
bool show) {
|
CEF_REQUIRE_UI_THREAD();
|
|
if (!show) {
|
original_popup_rect_.Set(0, 0, 0, 0);
|
resize_popup_ = false;
|
CHECK_CEF_BROWSER_HOST;
|
host->Invalidate(PET_VIEW);
|
}
|
}
|
|
|
void SWebView::OnPopupSize(CefRefPtr<CefBrowser> browser,
|
const CefRect& rect) {
|
CEF_REQUIRE_UI_THREAD();
|
|
CefRect &rc = browser::LogicalToDevice(rect, device_scale_factor_);
|
original_popup_rect_ = rc;
|
|
CRect &rcView = GetClientRect();
|
|
if (rc.width <= 0 || rc.height <= 0)
|
return;
|
|
if (rc.x <= 0)
|
rc.x = 0;
|
if (rc.y)
|
rc.y = 0;
|
if (rc.x + rc.width > rcView.Width())
|
rc.x = rcView.Width() - rc.width;
|
if (rc.y + rc.height > rcView.Height())
|
rc.y = rcView.Height() - rc.height;
|
if (rc.x <= 0)
|
rc.x = 0;
|
if (rc.y <= 0)
|
rc.y = 0;
|
popup_rc = CRect(CPoint(rc.x, rc.y), CSize(rc.width, rc.height));
|
|
resize_popup_ = true;
|
}
|
|
|
void SWebView::AdjustPixmap(int width, int height) {
|
if (!m_pBitmapBuff) {
|
GETRENDERFACTORY->CreateBitmap(&m_pBitmapBuff);
|
}
|
|
if (m_pBitmapBuff->Width() != (unsigned int) width || m_pBitmapBuff->Height() != (unsigned int) height) {
|
m_pBitmapBuff->Init(width, height);
|
}
|
}
|
|
|
void SWebView::OnPaint(CefRefPtr<CefBrowser> browser,
|
CefRenderHandler::PaintElementType type,
|
const CefRenderHandler::RectList& dirtyRects,
|
const void* buffer,
|
int width,
|
int height) {
|
CEF_REQUIRE_UI_THREAD();
|
|
if (painting_popup_) {
|
if (type == PET_VIEW) {
|
|
AdjustPixmap(width, height);
|
LPBYTE pDst = (LPBYTE) m_pBitmapBuff->LockPixelBits();
|
if (pDst) {
|
memcpy(pDst, buffer, width * height * 4);
|
m_pBitmapBuff->UnlockPixelBits(pDst);
|
}
|
|
draw_popup_ = false;
|
} else if (type == PET_POPUP) {
|
AdjustPixmap(width, height);
|
LPBYTE pDst = (LPBYTE) m_pBitmapBuff->LockPixelBits();
|
if (pDst) {
|
memcpy(pDst, buffer, width * height * 4);
|
m_pBitmapBuff->UnlockPixelBits(pDst);
|
}
|
|
draw_popup_ = true;
|
}
|
|
return;
|
}
|
|
if (type == PET_VIEW) {
|
AdjustPixmap(width, height);
|
LPBYTE pDst = (LPBYTE) m_pBitmapBuff->LockPixelBits();
|
if (pDst) {
|
memcpy(pDst, buffer, width * height * 4);
|
m_pBitmapBuff->UnlockPixelBits(pDst);
|
}
|
|
draw_popup_ = false;
|
} else if (type == PET_POPUP) {
|
|
AdjustPixmap(width, height);
|
LPBYTE pDst = (LPBYTE) m_pBitmapBuff->LockPixelBits();
|
if (pDst) {
|
memcpy(pDst, buffer, width * height * 4);
|
m_pBitmapBuff->UnlockPixelBits(pDst);
|
}
|
|
draw_popup_ = true;
|
}
|
|
if (type == PET_VIEW && resize_popup_) {
|
painting_popup_ = true;
|
browser->GetHost()->Invalidate(PET_POPUP);
|
painting_popup_ = false;
|
}
|
|
|
if (m_pBitmapBuff) {
|
if (draw_popup_) {
|
Draw(popup_rc.left, popup_rc.top, m_pBitmapBuff);
|
|
} else {
|
Draw(0, 0, m_pBitmapBuff);
|
}
|
}
|
}
|
|
void SWebView::OnCursorChange(CefRefPtr<CefBrowser> browser,
|
CefCursorHandle cursor,
|
CefRenderHandler::CursorType type,
|
const CefCursorInfo& custom_cursor_info) {
|
CEF_REQUIRE_UI_THREAD();
|
|
if (!m_bSkipCursor) {
|
::SetCursor(cursor);
|
}
|
}
|
|
void SWebView::UpdateDragCursor(
|
CefRefPtr<CefBrowser> browser,
|
CefRenderHandler::DragOperation operation) {
|
CEF_REQUIRE_UI_THREAD();
|
m_opCurrentDrag = operation;
|
}
|
|
void SWebView::OnImeCompositionRangeChanged(
|
CefRefPtr<CefBrowser> browser,
|
const CefRange& selection_range,
|
const CefRenderHandler::RectList& character_bounds) {
|
CEF_REQUIRE_UI_THREAD();
|
if (ime_handler_) {
|
// Convert from view coordinates to device coordinates.
|
CefRenderHandler::RectList device_bounds;
|
CefRenderHandler::RectList::const_iterator it = character_bounds.begin();
|
for (; it != character_bounds.end(); ++it) {
|
device_bounds.push_back(browser::LogicalToDevice(*it, device_scale_factor_));
|
}
|
|
ime_handler_->ChangeCompositionRange(selection_range, device_bounds);
|
}
|
}
|
|
void SWebView::OnBeforePopup(CefRefPtr<CefBrowser> browser,
|
CefRefPtr<CefFrame> frame,
|
const CefString& target_url,
|
const CefString& target_frame_name,
|
CefLifeSpanHandler::WindowOpenDisposition target_disposition,
|
bool user_gesture,
|
const CefPopupFeatures& popupFeatures,
|
CefWindowInfo& windowInfo,
|
CefRefPtr<CefClient>& client,
|
CefBrowserSettings& settings,
|
bool* no_javascript_access) {
|
}
|
|
void SWebView::OnAddressChange(CefRefPtr<CefBrowser> browser,
|
CefRefPtr<CefFrame> frame,
|
const CefString &url) {
|
m_strUrl = url.ToWString().c_str();
|
EventURLChange ev(this, m_strUrl);
|
FireEvent(ev);
|
}
|
|
void SWebView::OnLoadEnd(CefRefPtr<CefBrowser> browser,
|
CefRefPtr<CefFrame> frame,
|
int httpStatusCode) {
|
EventWebviewLoadEnd ev(this, httpStatusCode);
|
FireEvent(ev);
|
}
|
|
|
HWND SWebView::getWindowHandle(){
|
return this->GetContainer()->GetHostHwnd();
|
}
|
|
CefClient *SWebView::getClient(){
|
return webview_handler_;
|
}
|
|
}; // namespace SOUI
|
