WebChromeClient.cpp [plain text]
#include "config.h"
#include "WebChromeClient.h"
#include "WebElementPropertyBag.h"
#include "WebFrame.h"
#include "WebHistory.h"
#include "WebMutableURLRequest.h"
#include "WebSecurityOrigin.h"
#include "WebView.h"
#pragma warning(push, 0)
#include <WebCore/BString.h>
#include <WebCore/Console.h>
#include <WebCore/ContextMenu.h>
#include <WebCore/Cursor.h>
#include <WebCore/FileChooser.h>
#include <WebCore/FloatRect.h>
#include <WebCore/FrameLoadRequest.h>
#include <WebCore/FrameView.h>
#include <WebCore/LocalizedStrings.h>
#include <WebCore/NotImplemented.h>
#include <WebCore/Page.h>
#include <WebCore/WindowFeatures.h>
#pragma warning(pop)
#include <tchar.h>
using namespace WebCore;
static const size_t maxFilePathsListSize = USHRT_MAX;
WebChromeClient::WebChromeClient(WebView* webView)
: m_webView(webView)
{
}
void WebChromeClient::chromeDestroyed()
{
delete this;
}
void WebChromeClient::setWindowRect(const FloatRect& r)
{
IWebUIDelegate* uiDelegate = 0;
if (SUCCEEDED(m_webView->uiDelegate(&uiDelegate))) {
RECT rect = IntRect(r);
uiDelegate->setFrame(m_webView, &rect);
uiDelegate->Release();
}
}
FloatRect WebChromeClient::windowRect()
{
IWebUIDelegate* uiDelegate = 0;
if (SUCCEEDED(m_webView->uiDelegate(&uiDelegate))) {
RECT rect;
HRESULT retval = uiDelegate->webViewFrame(m_webView, &rect);
uiDelegate->Release();
if (SUCCEEDED(retval))
return rect;
}
return FloatRect();
}
FloatRect WebChromeClient::pageRect()
{
RECT rect;
m_webView->frameRect(&rect);
return rect;
}
float WebChromeClient::scaleFactor()
{
return 1.0;
}
void WebChromeClient::focus()
{
IWebUIDelegate* uiDelegate = 0;
if (SUCCEEDED(m_webView->uiDelegate(&uiDelegate))) {
uiDelegate->webViewFocus(m_webView);
uiDelegate->Release();
}
m_webView->updateActiveState();
}
void WebChromeClient::unfocus()
{
IWebUIDelegate* uiDelegate = 0;
if (SUCCEEDED(m_webView->uiDelegate(&uiDelegate))) {
uiDelegate->webViewUnfocus(m_webView);
uiDelegate->Release();
}
m_webView->updateActiveState();
}
bool WebChromeClient::canTakeFocus(FocusDirection direction)
{
IWebUIDelegate* uiDelegate = 0;
BOOL bForward = (direction == FocusDirectionForward) ? TRUE : FALSE;
BOOL result = FALSE;
if (SUCCEEDED(m_webView->uiDelegate(&uiDelegate))) {
uiDelegate->canTakeFocus(m_webView, bForward, &result);
uiDelegate->Release();
}
return !!result;
}
void WebChromeClient::takeFocus(FocusDirection direction)
{
IWebUIDelegate* uiDelegate = 0;
BOOL bForward = (direction == FocusDirectionForward) ? TRUE : FALSE;
if (SUCCEEDED(m_webView->uiDelegate(&uiDelegate))) {
uiDelegate->takeFocus(m_webView, bForward);
uiDelegate->Release();
}
}
Page* WebChromeClient::createWindow(Frame*, const FrameLoadRequest& frameLoadRequest, const WindowFeatures& features)
{
if (features.dialog) {
COMPtr<IWebUIDelegate> delegate = uiDelegate();
if (!delegate)
return 0;
COMPtr<IWebMutableURLRequest> request(AdoptCOM, WebMutableURLRequest::createInstance(frameLoadRequest.resourceRequest()));
COMPtr<IWebView> dialog;
if (FAILED(delegate->createModalDialog(m_webView, request.get(), &dialog)))
return 0;
return core(dialog.get());
}
Page* page = 0;
IWebUIDelegate* uiDelegate = 0;
IWebMutableURLRequest* request = WebMutableURLRequest::createInstance(frameLoadRequest.resourceRequest());
if (SUCCEEDED(m_webView->uiDelegate(&uiDelegate))) {
IWebView* webView = 0;
if (SUCCEEDED(uiDelegate->createWebViewWithRequest(m_webView, request, &webView))) {
page = core(webView);
webView->Release();
}
uiDelegate->Release();
}
request->Release();
return page;
}
void WebChromeClient::show()
{
IWebUIDelegate* uiDelegate = 0;
if (SUCCEEDED(m_webView->uiDelegate(&uiDelegate))) {
uiDelegate->webViewShow(m_webView);
uiDelegate->Release();
}
}
bool WebChromeClient::canRunModal()
{
BOOL result = FALSE;
if (COMPtr<IWebUIDelegate> delegate = uiDelegate())
delegate->canRunModal(m_webView, &result);
return result;
}
void WebChromeClient::runModal()
{
if (COMPtr<IWebUIDelegate> delegate = uiDelegate())
delegate->runModal(m_webView);
}
void WebChromeClient::setToolbarsVisible(bool visible)
{
IWebUIDelegate* uiDelegate = 0;
if (SUCCEEDED(m_webView->uiDelegate(&uiDelegate))) {
uiDelegate->setToolbarsVisible(m_webView, visible);
uiDelegate->Release();
}
}
bool WebChromeClient::toolbarsVisible()
{
BOOL result = false;
IWebUIDelegate* uiDelegate = 0;
if (SUCCEEDED(m_webView->uiDelegate(&uiDelegate))) {
uiDelegate->webViewAreToolbarsVisible(m_webView, &result);
uiDelegate->Release();
}
return result != false;
}
void WebChromeClient::setStatusbarVisible(bool visible)
{
IWebUIDelegate* uiDelegate = 0;
if (SUCCEEDED(m_webView->uiDelegate(&uiDelegate))) {
uiDelegate->setStatusBarVisible(m_webView, visible);
uiDelegate->Release();
}
}
bool WebChromeClient::statusbarVisible()
{
BOOL result = false;
IWebUIDelegate* uiDelegate = 0;
if (SUCCEEDED(m_webView->uiDelegate(&uiDelegate))) {
uiDelegate->webViewIsStatusBarVisible(m_webView, &result);
uiDelegate->Release();
}
return result != false;
}
void WebChromeClient::setScrollbarsVisible(bool b)
{
WebFrame* webFrame = m_webView->topLevelFrame();
if (webFrame)
webFrame->setAllowsScrolling(b);
}
bool WebChromeClient::scrollbarsVisible()
{
WebFrame* webFrame = m_webView->topLevelFrame();
BOOL b = false;
if (webFrame)
webFrame->allowsScrolling(&b);
return !!b;
}
void WebChromeClient::setMenubarVisible(bool visible)
{
COMPtr<IWebUIDelegate> delegate = uiDelegate();
if (!delegate)
return;
delegate->setMenuBarVisible(m_webView, visible);
}
bool WebChromeClient::menubarVisible()
{
COMPtr<IWebUIDelegate> delegate = uiDelegate();
if (!delegate)
return true;
BOOL result = true;
delegate->isMenuBarVisible(m_webView, &result);
return result;
}
void WebChromeClient::setResizable(bool resizable)
{
IWebUIDelegate* uiDelegate = 0;
if (SUCCEEDED(m_webView->uiDelegate(&uiDelegate))) {
uiDelegate->setResizable(m_webView, resizable);
uiDelegate->Release();
}
}
void WebChromeClient::addMessageToConsole(MessageSource source, MessageLevel level, const String& message, unsigned line, const String& url)
{
COMPtr<IWebUIDelegate> uiDelegate;
if (SUCCEEDED(m_webView->uiDelegate(&uiDelegate))) {
COMPtr<IWebUIDelegatePrivate> uiPrivate;
if (SUCCEEDED(uiDelegate->QueryInterface(IID_IWebUIDelegatePrivate, (void**)&uiPrivate)))
uiPrivate->webViewAddMessageToConsole(m_webView, BString(message), line, BString(url), true);
}
}
bool WebChromeClient::canRunBeforeUnloadConfirmPanel()
{
IWebUIDelegate* ui;
if (SUCCEEDED(m_webView->uiDelegate(&ui)) && ui) {
ui->Release();
return true;
}
return false;
}
bool WebChromeClient::runBeforeUnloadConfirmPanel(const String& message, Frame* frame)
{
BOOL result = TRUE;
IWebUIDelegate* ui;
if (SUCCEEDED(m_webView->uiDelegate(&ui)) && ui) {
WebFrame* webFrame = kit(frame);
ui->runBeforeUnloadConfirmPanelWithMessage(m_webView, BString(message), webFrame, &result);
ui->Release();
}
return !!result;
}
void WebChromeClient::closeWindowSoon()
{
m_webView->setGroupName(0);
m_webView->stopLoading(0);
m_webView->closeWindowSoon();
}
void WebChromeClient::runJavaScriptAlert(Frame*, const String& message)
{
COMPtr<IWebUIDelegate> ui;
if (SUCCEEDED(m_webView->uiDelegate(&ui)))
ui->runJavaScriptAlertPanelWithMessage(m_webView, BString(message));
}
bool WebChromeClient::runJavaScriptConfirm(Frame*, const String& message)
{
BOOL result = FALSE;
COMPtr<IWebUIDelegate> ui;
if (SUCCEEDED(m_webView->uiDelegate(&ui)))
ui->runJavaScriptConfirmPanelWithMessage(m_webView, BString(message), &result);
return !!result;
}
bool WebChromeClient::runJavaScriptPrompt(Frame*, const String& message, const String& defaultValue, String& result)
{
COMPtr<IWebUIDelegate> ui;
if (FAILED(m_webView->uiDelegate(&ui)))
return false;
TimerBase::fireTimersInNestedEventLoop();
BSTR resultBSTR = 0;
if (FAILED(ui->runJavaScriptTextInputPanelWithPrompt(m_webView, BString(message), BString(defaultValue), &resultBSTR)))
return false;
if (resultBSTR) {
result = String(resultBSTR, SysStringLen(resultBSTR));
SysFreeString(resultBSTR);
return true;
}
return false;
}
void WebChromeClient::setStatusbarText(const String& statusText)
{
COMPtr<IWebUIDelegate> uiDelegate;
if (SUCCEEDED(m_webView->uiDelegate(&uiDelegate))) {
uiDelegate->setStatusText(m_webView, BString(statusText));
}
}
bool WebChromeClient::shouldInterruptJavaScript()
{
COMPtr<IWebUIDelegate> uiDelegate;
if (SUCCEEDED(m_webView->uiDelegate(&uiDelegate))) {
COMPtr<IWebUIDelegatePrivate> uiPrivate;
if (SUCCEEDED(uiDelegate->QueryInterface(IID_IWebUIDelegatePrivate, (void**)&uiPrivate))) {
BOOL result;
if (SUCCEEDED(uiPrivate->webViewShouldInterruptJavaScript(m_webView, &result)))
return !!result;
}
}
return false;
}
bool WebChromeClient::tabsToLinks() const
{
BOOL enabled = FALSE;
IWebPreferences* preferences;
if (SUCCEEDED(m_webView->preferences(&preferences)))
preferences->tabsToLinks(&enabled);
return !!enabled;
}
IntRect WebChromeClient::windowResizerRect() const
{
IntRect intRect;
IWebUIDelegate* ui;
if (SUCCEEDED(m_webView->uiDelegate(&ui)) && ui) {
IWebUIDelegatePrivate* uiPrivate;
if (SUCCEEDED(ui->QueryInterface(IID_IWebUIDelegatePrivate, (void**)&uiPrivate))) {
RECT r;
if (SUCCEEDED(uiPrivate->webViewResizerRect(m_webView, &r)))
intRect = IntRect(r.left, r.top, r.right-r.left, r.bottom-r.top);
uiPrivate->Release();
}
ui->Release();
}
return intRect;
}
void WebChromeClient::repaint(const IntRect& windowRect, bool contentChanged, bool immediate, bool repaintContentOnly)
{
ASSERT(core(m_webView->topLevelFrame()));
m_webView->repaint(windowRect, contentChanged, immediate, repaintContentOnly);
}
void WebChromeClient::scroll(const IntSize& delta, const IntRect& scrollViewRect, const IntRect& clipRect)
{
ASSERT(core(m_webView->topLevelFrame()));
m_webView->scrollBackingStore(core(m_webView->topLevelFrame())->view(), delta.width(), delta.height(), scrollViewRect, clipRect);
}
IntRect WebChromeClient::windowToScreen(const IntRect& rect) const
{
HWND viewWindow;
if (FAILED(m_webView->viewWindow(reinterpret_cast<OLE_HANDLE*>(&viewWindow))))
return rect;
POINT topLeft = {0, 0};
IntRect result = rect;
::ClientToScreen(viewWindow, &topLeft);
result.move(topLeft.x, topLeft.y);
return result;
}
IntPoint WebChromeClient::screenToWindow(const IntPoint& point) const
{
POINT result = point;
HWND viewWindow;
if (FAILED(m_webView->viewWindow(reinterpret_cast<OLE_HANDLE*>(&viewWindow))))
return point;
::ScreenToClient(viewWindow, &result);
return result;
}
PlatformWidget WebChromeClient::platformWindow() const
{
HWND viewWindow;
if (FAILED(m_webView->viewWindow(reinterpret_cast<OLE_HANDLE*>(&viewWindow))))
return 0;
return viewWindow;
}
void WebChromeClient::contentsSizeChanged(Frame*, const IntSize&) const
{
notImplemented();
}
void WebChromeClient::mouseDidMoveOverElement(const HitTestResult& result, unsigned modifierFlags)
{
COMPtr<IWebUIDelegate> uiDelegate;
if (FAILED(m_webView->uiDelegate(&uiDelegate)))
return;
COMPtr<WebElementPropertyBag> element;
element.adoptRef(WebElementPropertyBag::createInstance(result));
uiDelegate->mouseDidMoveOverElement(m_webView, element.get(), modifierFlags);
}
void WebChromeClient::setToolTip(const String& toolTip)
{
m_webView->setToolTip(toolTip);
}
void WebChromeClient::print(Frame* frame)
{
COMPtr<IWebUIDelegate> uiDelegate;
if (SUCCEEDED(m_webView->uiDelegate(&uiDelegate)))
uiDelegate->printFrame(m_webView, kit(frame));
}
#if ENABLE(DATABASE)
void WebChromeClient::exceededDatabaseQuota(Frame* frame, const String& databaseIdentifier)
{
COMPtr<WebSecurityOrigin> origin(AdoptCOM, WebSecurityOrigin::createInstance(frame->document()->securityOrigin()));
COMPtr<IWebUIDelegate> uiDelegate;
if (SUCCEEDED(m_webView->uiDelegate(&uiDelegate))) {
COMPtr<IWebUIDelegatePrivate> uiDelegatePrivate(Query, uiDelegate);
if (uiDelegatePrivate)
uiDelegatePrivate->exceededDatabaseQuota(m_webView, kit(frame), origin.get(), BString(databaseIdentifier));
else {
TCHAR path[MAX_PATH];
HMODULE safariHandle = GetModuleHandle(TEXT("Safari.exe"));
if (!safariHandle)
return;
GetModuleFileName(safariHandle, path, ARRAYSIZE(path));
DWORD handle;
DWORD versionSize = GetFileVersionInfoSize(path, &handle);
if (!versionSize)
return;
Vector<char> data(versionSize);
if (!GetFileVersionInfo(path, 0, versionSize, data.data()))
return;
LPCTSTR productVersion;
UINT productVersionLength;
if (!VerQueryValue(data.data(), TEXT("\\StringFileInfo\\040904b0\\ProductVersion"), (void**)&productVersion, &productVersionLength))
return;
if (_tcsncmp(TEXT("3.1"), productVersion, productVersionLength) > 0) {
const unsigned long long defaultQuota = 5 * 1024 * 1024; origin->setQuota(defaultQuota);
}
}
}
}
#endif
void WebChromeClient::populateVisitedLinks()
{
WebHistory* history = WebHistory::sharedHistory();
if (!history)
return;
history->addVisitedLinksToPageGroup(m_webView->page()->group());
}
bool WebChromeClient::paintCustomScrollbar(GraphicsContext* context, const FloatRect& rect, ScrollbarControlSize size,
ScrollbarControlState state, ScrollbarPart pressedPart, bool vertical,
float value, float proportion, ScrollbarControlPartMask parts)
{
if (context->paintingDisabled())
return false;
COMPtr<IWebUIDelegate> delegate = uiDelegate();
if (!delegate)
return false;
WebScrollbarControlPartMask webParts = WebNoScrollPart;
if (parts & BackButtonStartPart) webParts |= WebBackButtonPart;
if (parts & BackTrackPart)
webParts |= WebBackTrackPart;
if (parts & ThumbPart)
webParts |= WebThumbPart;
if (parts & ForwardTrackPart)
webParts |= WebForwardTrackPart;
if (parts & ForwardButtonStartPart) webParts |= WebForwardButtonPart;
WebScrollbarControlPart webPressedPart = WebNoScrollPart;
switch (pressedPart) {
case BackButtonStartPart: webPressedPart = WebBackButtonPart;
break;
case BackTrackPart:
webPressedPart = WebBackTrackPart;
break;
case ThumbPart:
webPressedPart = WebThumbPart;
break;
case ForwardTrackPart:
webPressedPart = WebForwardTrackPart;
break;
case ForwardButtonStartPart: webPressedPart = WebForwardButtonPart;
break;
default:
break;
}
WebScrollBarControlSize webSize;
switch (size) {
case SmallScrollbar:
webSize = WebSmallScrollbar;
break;
case RegularScrollbar:
default:
webSize = WebRegularScrollbar;
}
WebScrollbarControlState webState = 0;
if (state & ActiveScrollbarState)
webState |= WebActiveScrollbarState;
if (state & EnabledScrollbarState)
webState |= WebEnabledScrollbarState;
if (state & PressedScrollbarState)
webState |= WebPressedScrollbarState;
RECT webRect = enclosingIntRect(rect);
HDC hDC = context->getWindowsContext(webRect);
HRESULT hr = delegate->paintCustomScrollbar(m_webView, hDC, webRect, webSize, webState, webPressedPart,
vertical, value, proportion, webParts);
context->releaseWindowsContext(hDC, webRect);
return SUCCEEDED(hr);
}
bool WebChromeClient::paintCustomScrollCorner(GraphicsContext* context, const FloatRect& rect)
{
if (context->paintingDisabled())
return false;
COMPtr<IWebUIDelegate> delegate = uiDelegate();
if (!delegate)
return false;
RECT webRect = enclosingIntRect(rect);
HDC hDC = context->getWindowsContext(webRect);
HRESULT hr = delegate->paintCustomScrollCorner(m_webView, hDC, webRect);
context->releaseWindowsContext(hDC, webRect);
return SUCCEEDED(hr);
}
void WebChromeClient::runOpenPanel(Frame*, PassRefPtr<FileChooser> prpFileChooser)
{
RefPtr<FileChooser> fileChooser = prpFileChooser;
HWND viewWindow;
if (FAILED(m_webView->viewWindow(reinterpret_cast<OLE_HANDLE*>(&viewWindow))))
return;
bool multiFile = fileChooser->allowsMultipleFiles();
Vector<TCHAR> fileBuf(multiFile ? maxFilePathsListSize : MAX_PATH);
OPENFILENAME ofn;
memset(&ofn, 0, sizeof(ofn));
fileBuf[0] = '\0';
ofn.lStructSize = sizeof(ofn);
ofn.hwndOwner = viewWindow;
String allFiles = allFilesText();
allFiles.append(TEXT("\0*.*\0\0"), 6);
ofn.lpstrFilter = allFiles.charactersWithNullTermination();
ofn.lpstrFile = fileBuf.data();
ofn.nMaxFile = fileBuf.size();
String dialogTitle = uploadFileText();
ofn.lpstrTitle = dialogTitle.charactersWithNullTermination();
ofn.Flags = OFN_ENABLESIZING | OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST | OFN_EXPLORER;
if (multiFile)
ofn.Flags = ofn.Flags | OFN_ALLOWMULTISELECT;
if (GetOpenFileName(&ofn)) {
TCHAR* files = fileBuf.data();
Vector<String> fileList;
String file(files);
if (multiFile) {
while (!file.isEmpty()) {
TCHAR* nextFilePtr = files + file.length() + 1;
String nextFile(nextFilePtr);
if (files != fileBuf.data() || nextFile.isEmpty())
fileList.append(file);
files = nextFilePtr;
file = nextFile;
}
} else
fileList.append(file);
ASSERT(fileList.size());
fileChooser->chooseFiles(fileList);
}
}
bool WebChromeClient::setCursor(PlatformCursorHandle cursor)
{
if (!cursor)
return false;
if (COMPtr<IWebUIDelegate> delegate = uiDelegate()) {
COMPtr<IWebUIDelegatePrivate> delegatePrivate(Query, delegate);
if (delegatePrivate) {
if (SUCCEEDED(delegatePrivate->webViewSetCursor(m_webView, reinterpret_cast<OLE_HANDLE>(cursor))))
return true;
}
}
::SetCursor(cursor);
return true;
}
void WebChromeClient::requestGeolocationPermissionForFrame(Frame*, Geolocation*)
{
notImplemented();
}
COMPtr<IWebUIDelegate> WebChromeClient::uiDelegate()
{
COMPtr<IWebUIDelegate> delegate;
m_webView->uiDelegate(&delegate);
return delegate;
}