WebKit/win/WebView.cpp

   1 /*
   2  * Copyright (C) 2006, 2007 Apple, Inc.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27 #include "WebKitDLL.h"
  28 #include "WebView.h"
  29
  30 #include "CFDictionaryPropertyBag.h"
  31 #include "DOMCoreClasses.h"
  32 #include "IWebNotification.h"
  33 #include "WebDebugProgram.h"
  34 #include "WebDocumentLoader.h"
  35 #include "WebEditorClient.h"
  36 #include "WebElementPropertyBag.h"
  37 #include "WebFrame.h"
  38 #include "WebBackForwardList.h"
  39 #include "WebChromeClient.h"
  40 #include "WebContextMenuClient.h"
  41 #include "WebDragClient.h"
  42 #include "WebIconDatabase.h"
  43 #include "WebInspectorClient.h"
  44 #include "WebKit.h"
  45 #include "WebKitStatisticsPrivate.h"
  46 #include "WebMutableURLRequest.h"
  47 #include "WebNotificationCenter.h"
  48 #include "WebPreferences.h"
  49 #pragma warning( push, 0 )
  50 #include <CoreGraphics/CGContext.h>
  51 #include <CFNetwork/CFHTTPCookiesPriv.h>
  52 #include <WebCore/BString.h>
  53 #include <WebCore/Cache.h>
  54 #include <WebCore/CommandByName.h>
  55 #include <WebCore/ContextMenu.h>
  56 #include <WebCore/ContextMenuController.h>
  57 #include <WebCore/CString.h>
  58 #include <WebCore/Cursor.h>
  59 #include <WebCore/Document.h>
  60 #include <WebCore/DragController.h>
  61 #include <WebCore/DragData.h>
  62 #include <WebCore/Editor.h>
  63 #include <WebCore/EventHandler.h>
  64 #include <WebCore/FocusController.h>
  65 #include <WebCore/FrameLoader.h>
  66 #include <WebCore/FrameTree.h>
  67 #include <WebCore/FrameView.h>
  68 #include <WebCore/FrameWin.h>
  69 #include <WebCore/GDIObjectCounter.h>
  70 #include <WebCore/GraphicsContext.h>
  71 #include <WebCore/HistoryItem.h>
  72 #include <WebCore/HitTestResult.h>
  73 #include <WebCore/IntRect.h>
  74 #include <WebCore/KeyboardEvent.h>
  75 #include <WebCore/Language.h>
  76 #include <WebCore/MIMETypeRegistry.h>
  77 #include <WebCore/NotImplemented.h>
  78 #include <WebCore/Page.h>
  79 #include <WebCore/PageCache.h>
  80 #include <WebCore/PlatformKeyboardEvent.h>
  81 #include <WebCore/PlatformMouseEvent.h>
  82 #include <WebCore/PlatformWheelEvent.h>
  83 #include <WebCore/PluginDatabaseWin.h>
  84 #include <WebCore/PlugInInfoStore.h>
  85 #include <WebCore/ProgressTracker.h>
  86 #include <WebCore/ResourceHandle.h>
  87 #include <WebCore/ResourceHandleClient.h>
  88 #include <WebCore/SelectionController.h>
  89 #include <WebCore/Settings.h>
  90 #include <WebCore/TypingCommand.h>
  91 #pragma warning(pop)
  92 #include <JavaScriptCore/collector.h>
  93 #include <JavaScriptCore/value.h>
  94 #include <CFNetwork/CFURLProtocolPriv.h>
  95 #include <tchar.h>
  96 #include <dimm.h>
  97 #include <windowsx.h>
  98 #include <ShlObj.h>
  99
 100 using namespace WebCore;
 101 using KJS::JSLock;
 102 using std::min;
 103
 104 const LPCWSTR kWebViewWindowClassName = L"WebViewWindowClass";
 105
 106 const int WM_XP_THEMECHANGED = 0x031A;
 107 const int WM_VISTA_MOUSEHWHEEL = 0x020E;
 108
 109 static const int maxToolTipWidth = 250;
 110
 111 static ATOM registerWebView();
 112 static LRESULT CALLBACK WebViewWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
 113
 114 HRESULT createMatchEnumerator(Vector<IntRect>* rects, IEnumTextMatches** matches);
 115
 116 static bool continuousSpellCheckingEnabled;
 117 static bool grammarCheckingEnabled;
 118
 119 // WebView ----------------------------------------------------------------
 120
 121 bool WebView::s_allowSiteSpecificHacks = false;
 122
 123 WebView::WebView()
 124 : m_refCount(0)
 125 , m_hostWindow(0)
 126 , m_viewWindow(0)
 127 , m_mainFrame(0)
 128 , m_page(0)
 129 , m_hasCustomDropTarget(false)
 130 , m_useBackForwardList(true)
 131 , m_userAgentOverridden(false)
 132 , m_textSizeMultiplier(1)
 133 , m_mouseActivated(false)
 134 , m_dragData(0)
 135 , m_currentCharacterCode(0)
 136 , m_isBeingDestroyed(false)
 137 , m_paintCount(0)
 138 , m_hasSpellCheckerDocumentTag(false)
 139 , m_smartInsertDeleteEnabled(false)
 140 , m_didClose(false)
 141 , m_inIMEComposition(0)
 142 , m_toolTipHwnd(0)
 143 , m_closeWindowTimer(this, &WebView::closeWindowTimerFired)
 144 {
 145     KJS::Collector::registerAsMainThread();
 146
 147     m_backingStoreSize.cx = m_backingStoreSize.cy = 0;
 148
 149     CoCreateInstance(CLSID_DragDropHelper, 0, CLSCTX_INPROC_SERVER, IID_IDropTargetHelper,(void**)&m_dropTargetHelper);
 150
 151     COMPtr<IWebPreferences> prefs;
 152     if (SUCCEEDED(preferences(&prefs))) {
 153         BOOL enabled;
 154         if (SUCCEEDED(prefs->continuousSpellCheckingEnabled(&enabled)))
 155             continuousSpellCheckingEnabled = !!enabled;
 156         if (SUCCEEDED(prefs->grammarCheckingEnabled(&enabled)))
 157             grammarCheckingEnabled = !!enabled;
 158     }
 159
 160     WebDebugProgram::viewAdded(this);
 161     WebViewCount++;
 162     gClassCount++;
 163 }
 164
 165 WebView::~WebView()
 166 {
 167     deleteBackingStore();
 168
 169     // <rdar://4958382> m_viewWindow will be destroyed when m_hostWindow is destroyed, but if
 170     // setHostWindow was never called we will leak our HWND. If we still have a valid HWND at
 171     // this point, we should just destroy it ourselves.
 172     if (::IsWindow(m_viewWindow))
 173         ::DestroyWindow(m_viewWindow);
 174
 175     delete m_page;
 176
 177     WebDebugProgram::viewRemoved(this);
 178     WebViewCount--;
 179     gClassCount--;
 180 }
 181
 182 WebView* WebView::createInstance()
 183 {
 184     WebView* instance = new WebView();
 185     instance->AddRef();
 186     return instance;
 187 }
 188
 189 void WebView::close()
 190 {
 191     if (m_didClose)
 192         return;
 193
 194     m_didClose = true;
 195
 196     Frame* frame = m_page->mainFrame();
 197     if (frame)
 198         frame->loader()->detachFromParent();
 199
 200     m_page->setGroupName(String());
 201     setHostWindow(0);
 202
 203     setDownloadDelegate(0);
 204     setEditingDelegate(0);
 205     setFrameLoadDelegate(0);
 206     setFrameLoadDelegatePrivate(0);
 207     setPolicyDelegate(0);
 208     setResourceLoadDelegate(0);
 209     setUIDelegate(0);
 210     setFormDelegate(0);
 211
 212     delete m_page;
 213     m_page = 0;
 214
 215     registerForIconNotification(false);
 216     IWebNotificationCenter* notifyCenter = WebNotificationCenter::defaultCenterInternal();
 217     COMPtr<IWebPreferences> prefs;
 218     if (SUCCEEDED(preferences(&prefs)))
 219         notifyCenter->removeObserver(this, WebPreferences::webPreferencesChangedNotification(), prefs.get());
 220     prefs = 0;  // make sure we release the reference, since WebPreferences::removeReferenceForIdentifier will check for last reference to WebPreferences
 221     if (m_preferences) {
 222         BSTR identifier = 0;
 223         if (SUCCEEDED(m_preferences->identifier(&identifier)))
 224             WebPreferences::removeReferenceForIdentifier(identifier);
 225         if (identifier)
 226             SysFreeString(identifier);
 227         m_preferences = 0;
 228     }
 229
 230     deleteBackingStore();
 231 }
 232
 233 void WebView::deleteBackingStore()
 234 {
 235     m_backingStoreBitmap.clear();
 236     m_backingStoreDirtyRegion.clear();
 237
 238     m_backingStoreSize.cx = m_backingStoreSize.cy = 0;
 239 }
 240
 241 bool WebView::ensureBackingStore()
 242 {
 243     RECT windowRect;
 244     ::GetClientRect(m_viewWindow, &windowRect);
 245     LONG width = windowRect.right - windowRect.left;
 246     LONG height = windowRect.bottom - windowRect.top;
 247     if (width > 0 && height > 0 && (width != m_backingStoreSize.cx || height != m_backingStoreSize.cy)) {
 248         deleteBackingStore();
 249
 250         m_backingStoreSize.cx = width;
 251         m_backingStoreSize.cy = height;
 252         BITMAPINFO bitmapInfo;
 253         bitmapInfo.bmiHeader.biSize          = sizeof(BITMAPINFOHEADER);
 254         bitmapInfo.bmiHeader.biWidth         = width;
 255         bitmapInfo.bmiHeader.biHeight        = -height;
 256         bitmapInfo.bmiHeader.biPlanes        = 1;
 257         bitmapInfo.bmiHeader.biBitCount      = 32;
 258         bitmapInfo.bmiHeader.biCompression   = BI_RGB;
 259         bitmapInfo.bmiHeader.biSizeImage     = 0;
 260         bitmapInfo.bmiHeader.biXPelsPerMeter = 0;
 261         bitmapInfo.bmiHeader.biYPelsPerMeter = 0;
 262         bitmapInfo.bmiHeader.biClrUsed       = 0;
 263         bitmapInfo.bmiHeader.biClrImportant  = 0;
 264
 265         void* pixels = NULL;
 266         m_backingStoreBitmap.set(::CreateDIBSection(NULL, &bitmapInfo, DIB_RGB_COLORS, &pixels, NULL, 0));
 267         return true;
 268     }
 269
 270     return false;
 271 }
 272
 273 void WebView::addToDirtyRegion(const IntRect& dirtyRect)
 274 {
 275     HRGN newRegion = ::CreateRectRgn(dirtyRect.x(), dirtyRect.y(),
 276                                      dirtyRect.right(), dirtyRect.bottom());
 277     addToDirtyRegion(newRegion);
 278 }
 279
 280 void WebView::addToDirtyRegion(HRGN newRegion)
 281 {
 282     LOCAL_GDI_COUNTER(0, __FUNCTION__);
 283
 284     if (m_backingStoreDirtyRegion) {
 285         HRGN combinedRegion = ::CreateRectRgn(0,0,0,0);
 286         ::CombineRgn(combinedRegion, m_backingStoreDirtyRegion.get(), newRegion, RGN_OR);
 287         ::DeleteObject(newRegion);
 288         m_backingStoreDirtyRegion.set(combinedRegion);
 289     } else
 290         m_backingStoreDirtyRegion.set(newRegion);
 291 }
 292
 293 void WebView::scrollBackingStore(FrameView* frameView, int dx, int dy, const IntRect& scrollViewRect, const IntRect& clipRect)
 294 {
 295     LOCAL_GDI_COUNTER(0, __FUNCTION__);
 296
 297     // If there's no backing store we don't need to update it
 298     if (!m_backingStoreBitmap) {
 299         if (m_uiDelegatePrivate)
 300             m_uiDelegatePrivate->webViewScrolled(this);
 301
 302         return;
 303     }
 304
 305     // Make a region to hold the invalidated scroll area.
 306     HRGN updateRegion = ::CreateRectRgn(0, 0, 0, 0);
 307
 308     // Collect our device context info and select the bitmap to scroll.
 309     HDC windowDC = ::GetDC(m_viewWindow);
 310     HDC bitmapDC = ::CreateCompatibleDC(windowDC);
 311     ::SelectObject(bitmapDC, m_backingStoreBitmap.get());
 312
 313     // Scroll the bitmap.
 314     RECT scrollRectWin(scrollViewRect);
 315     RECT clipRectWin(clipRect);
 316     ::ScrollDC(bitmapDC, dx, dy, &scrollRectWin, &clipRectWin, updateRegion, 0);
 317     RECT regionBox;
 318     ::GetRgnBox(updateRegion, &regionBox);
 319
 320     // Flush.
 321     GdiFlush();
 322
 323     // Add the dirty region to the backing store's dirty region.
 324     addToDirtyRegion(updateRegion);
 325
 326     if (m_uiDelegatePrivate)
 327         m_uiDelegatePrivate->webViewScrolled(this);
 328
 329     // Update the backing store.
 330     updateBackingStore(frameView, bitmapDC, false);
 331
 332     // Clean up.
 333     ::DeleteDC(bitmapDC);
 334     ::ReleaseDC(m_viewWindow, windowDC);
 335
 336 }
 337
 338 void WebView::updateBackingStore(FrameView* frameView, HDC dc, bool backingStoreCompletelyDirty)
 339 {
 340     LOCAL_GDI_COUNTER(0, __FUNCTION__);
 341
 342     HDC windowDC = 0;
 343     HDC bitmapDC = dc;
 344     if (!dc) {
 345         windowDC = ::GetDC(m_viewWindow);
 346         bitmapDC = ::CreateCompatibleDC(windowDC);
 347         ::SelectObject(bitmapDC, m_backingStoreBitmap.get());
 348     }
 349
 350     if (m_backingStoreBitmap && (m_backingStoreDirtyRegion || backingStoreCompletelyDirty)) {
 351         // Do a layout first so that everything we render to the backing store is always current.
 352         if (Frame* coreFrame = core(m_mainFrame))
 353             if (FrameView* view = coreFrame->view())
 354                 view->layoutIfNeededRecursive();
 355
 356         // This emulates the Mac smarts for painting rects intelligently.  This is
 357         // very important for us, since we double buffer based off dirty rects.
 358         bool useRegionBox = true;
 359         const int cRectThreshold = 10;
 360         const float cWastedSpaceThreshold = 0.75f;
 361         RECT regionBox;
 362         if (!backingStoreCompletelyDirty) {
 363             ::GetRgnBox(m_backingStoreDirtyRegion.get(), &regionBox);
 364             DWORD regionDataSize = GetRegionData(m_backingStoreDirtyRegion.get(), sizeof(RGNDATA), NULL);
 365             if (regionDataSize) {
 366                 RGNDATA* regionData = (RGNDATA*)malloc(regionDataSize);
 367                 GetRegionData(m_backingStoreDirtyRegion.get(), regionDataSize, regionData);
 368                 if (regionData->rdh.nCount <= cRectThreshold) {
 369                     double unionPixels = (regionBox.right - regionBox.left) * (regionBox.bottom - regionBox.top);
 370                     double singlePixels = 0;
 371
 372                     unsigned i;
 373                     RECT* rect;
 374                     for (i = 0, rect = (RECT*)regionData->Buffer; i < regionData->rdh.nCount; i++, rect++)
 375                         singlePixels += (rect->right - rect->left) * (rect->bottom - rect->top);
 376                     double wastedSpace = 1.0 - (singlePixels / unionPixels);
 377                     if (wastedSpace > cWastedSpaceThreshold) {
 378                         // Paint individual rects.
 379                         useRegionBox = false;
 380                         for (i = 0, rect = (RECT*)regionData->Buffer; i < regionData->rdh.nCount; i++, rect++)
 381                             paintIntoBackingStore(frameView, bitmapDC, rect);
 382                     }
 383                 }
 384                 free(regionData);
 385             }
 386         } else
 387             ::GetClientRect(m_viewWindow, &regionBox);
 388
 389         if (useRegionBox)
 390             paintIntoBackingStore(frameView, bitmapDC, &regionBox);
 391
 392         if (m_uiDelegatePrivate) {
 393             COMPtr<IWebUIDelegatePrivate2> uiDelegatePrivate2(Query, m_uiDelegatePrivate);
 394             if (uiDelegatePrivate2)
 395                 uiDelegatePrivate2->webViewPainted(this);
 396         }
 397
 398         m_backingStoreDirtyRegion.clear();
 399     }
 400
 401     if (!dc) {
 402         ::DeleteDC(bitmapDC);
 403         ::ReleaseDC(m_viewWindow, windowDC);
 404     }
 405
 406     GdiFlush();
 407 }
 408
 409 void WebView::paint(HDC dc, LPARAM options)
 410 {
 411     LOCAL_GDI_COUNTER(0, __FUNCTION__);
 412
 413     Frame* coreFrame = core(m_mainFrame);
 414     if (!coreFrame)
 415         return;
 416     FrameView* frameView = coreFrame->view();
 417
 418     m_paintCount++;
 419
 420     RECT rcPaint;
 421     HDC hdc;
 422     OwnPtr<HRGN> region;
 423     int regionType = NULLREGION;
 424     PAINTSTRUCT ps;
 425     if (!dc) {
 426         region.set(CreateRectRgn(0,0,0,0));
 427         regionType = GetUpdateRgn(m_viewWindow, region.get(), false);
 428         hdc = BeginPaint(m_viewWindow, &ps);
 429         rcPaint = ps.rcPaint;
 430     } else {
 431         hdc = dc;
 432         ::GetClientRect(m_viewWindow, &rcPaint);
 433         if (options & PRF_ERASEBKGND)
 434             ::FillRect(hdc, &rcPaint, (HBRUSH)GetStockObject(WHITE_BRUSH));
 435     }
 436
 437     HDC bitmapDC = ::CreateCompatibleDC(hdc);
 438     bool backingStoreCompletelyDirty = ensureBackingStore();
 439     ::SelectObject(bitmapDC, m_backingStoreBitmap.get());
 440
 441     // Update our backing store if needed.
 442     updateBackingStore(frameView, bitmapDC, backingStoreCompletelyDirty);
 443
 444     // Now we blit the updated backing store
 445     IntRect windowDirtyRect = rcPaint;
 446
 447     // Apply the same heuristic for this update region too.
 448     bool useWindowDirtyRect = true;
 449     if (region && regionType == COMPLEXREGION) {
 450         LOCAL_GDI_COUNTER(1, __FUNCTION__" (COMPLEXREGION)");
 451
 452         const int cRectThreshold = 10;
 453         const float cWastedSpaceThreshold = 0.75f;
 454         DWORD regionDataSize = GetRegionData(region.get(), sizeof(RGNDATA), NULL);
 455         if (regionDataSize) {
 456             RGNDATA* regionData = (RGNDATA*)malloc(regionDataSize);
 457             GetRegionData(region.get(), regionDataSize, regionData);
 458             if (regionData->rdh.nCount <= cRectThreshold) {
 459                 double unionPixels = windowDirtyRect.width() * windowDirtyRect.height();
 460                 double singlePixels = 0;
 461
 462                 unsigned i;
 463                 RECT* rect;
 464                 for (i = 0, rect = (RECT*)regionData->Buffer; i < regionData->rdh.nCount; i++, rect++)
 465                     singlePixels += (rect->right - rect->left) * (rect->bottom - rect->top);
 466                 double wastedSpace = 1.0 - (singlePixels / unionPixels);
 467                 if (wastedSpace > cWastedSpaceThreshold) {
 468                     // Paint individual rects.
 469                     useWindowDirtyRect = false;
 470                     for (i = 0, rect = (RECT*)regionData->Buffer; i < regionData->rdh.nCount; i++, rect++)
 471                         paintIntoWindow(bitmapDC, hdc, rect);
 472                 }
 473             }
 474             free(regionData);
 475         }
 476     }
 477
 478     if (useWindowDirtyRect)
 479         paintIntoWindow(bitmapDC, hdc, &rcPaint);
 480
 481     ::DeleteDC(bitmapDC);
 482
 483     // Paint the gripper.
 484     COMPtr<IWebUIDelegate> ui;
 485     if (SUCCEEDED(uiDelegate(&ui))) {
 486         COMPtr<IWebUIDelegatePrivate> uiPrivate;
 487         if (SUCCEEDED(ui->QueryInterface(IID_IWebUIDelegatePrivate, (void**)&uiPrivate))) {
 488             RECT r;
 489             if (SUCCEEDED(uiPrivate->webViewResizerRect(this, &r))) {
 490                 LOCAL_GDI_COUNTER(2, __FUNCTION__" webViewDrawResizer delegate call");
 491                 uiPrivate->webViewDrawResizer(this, hdc, (frameView->resizerOverlapsContent() ? true : false), &r);
 492             }
 493         }
 494     }
 495
 496     if (!dc)
 497         EndPaint(m_viewWindow, &ps);
 498
 499     m_paintCount--;
 500 }
 501
 502 void WebView::paintIntoBackingStore(FrameView* frameView, HDC bitmapDC, LPRECT dirtyRect)
 503 {
 504     LOCAL_GDI_COUNTER(0, __FUNCTION__);
 505
 506 #if FLASH_BACKING_STORE_REDRAW
 507     HDC dc = ::GetDC(m_viewWindow);
 508     OwnPtr<HBRUSH> yellowBrush = CreateSolidBrush(RGB(255, 255, 0));
 509     FillRect(dc, dirtyRect, yellowBrush.get());
 510     GdiFlush();
 511     Sleep(50);
 512     paintIntoWindow(bitmapDC, dc, dirtyRect);
 513     ::ReleaseDC(m_viewWindow, dc);
 514 #endif
 515
 516     FillRect(bitmapDC, dirtyRect, (HBRUSH)GetStockObject(WHITE_BRUSH));
 517     if (frameView && frameView->frame() && frameView->frame()->renderer()) {
 518         GraphicsContext gc(bitmapDC);
 519         gc.save();
 520         gc.clip(IntRect(*dirtyRect));
 521         frameView->paint(&gc, IntRect(*dirtyRect));
 522         gc.restore();
 523     }
 524 }
 525
 526 void WebView::paintIntoWindow(HDC bitmapDC, HDC windowDC, LPRECT dirtyRect)
 527 {
 528     LOCAL_GDI_COUNTER(0, __FUNCTION__);
 529 #if FLASH_WINDOW_REDRAW
 530     OwnPtr<HBRUSH> greenBrush = CreateSolidBrush(RGB(0, 255, 0));
 531     FillRect(windowDC, dirtyRect, greenBrush.get());
 532     GdiFlush();
 533     Sleep(50);
 534 #endif
 535
 536     // Blit the dirty rect from the backing store into the same position
 537     // in the destination DC.
 538     BitBlt(windowDC, dirtyRect->left, dirtyRect->top, dirtyRect->right - dirtyRect->left, dirtyRect->bottom - dirtyRect->top, bitmapDC,
 539            dirtyRect->left, dirtyRect->top, SRCCOPY);
 540 }
 541
 542 void WebView::frameRect(RECT* rect)
 543 {
 544     ::GetWindowRect(m_viewWindow, rect);
 545 }
 546
 547 void WebView::closeWindowSoon()
 548 {
 549     m_closeWindowTimer.startOneShot(0);
 550     AddRef();
 551 }
 552
 553 void WebView::closeWindowTimerFired(WebCore::Timer<WebView>*)
 554 {
 555     closeWindow();
 556     Release();
 557 }
 558
 559 void WebView::closeWindow()
 560 {
 561     if (m_hasSpellCheckerDocumentTag) {
 562         if (m_editingDelegate)
 563             m_editingDelegate->closeSpellDocument(this);
 564         m_hasSpellCheckerDocumentTag = false;
 565     }
 566
 567     COMPtr<IWebUIDelegate> ui;
 568     if (SUCCEEDED(uiDelegate(&ui)))
 569         ui->webViewClose(this);
 570 }
 571
 572 bool WebView::canHandleRequest(const WebCore::ResourceRequest& request)
 573 {
 574     // On the mac there's an about url protocol implementation but CFNetwork doesn't have that.
 575     if (equalIgnoringCase(String(request.url().protocol()), "about"))
 576         return true;
 577
 578     if (CFURLProtocolCanHandleRequest(request.cfURLRequest()))
 579         return true;
 580
 581     // FIXME: Mac WebKit calls _representationExistsForURLScheme here
 582     return false;
 583 }
 584
 585 Page* WebView::page()
 586 {
 587     return m_page;
 588 }
 589
 590 bool WebView::handleContextMenuEvent(WPARAM wParam, LPARAM lParam)
 591 {
 592     static const int contextMenuMargin = 1;
 593
 594     // Translate the screen coordinates into window coordinates
 595     POINT coords = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
 596     if (coords.x == -1 || coords.y == -1) {
 597         FrameView* view = m_page->mainFrame()->view();
 598         if (!view)
 599             return false;
 600
 601         int rightAligned = ::GetSystemMetrics(SM_MENUDROPALIGNMENT);
 602         IntPoint location;
 603
 604         // The context menu event was generated from the keyboard, so show the context menu by the current selection.
 605         Position start = m_page->mainFrame()->selectionController()->selection().start();
 606         Position end = m_page->mainFrame()->selectionController()->selection().end();
 607
 608         if (!start.node() || !end.node())
 609             location = IntPoint(rightAligned ? view->contentsWidth() - contextMenuMargin : contextMenuMargin, contextMenuMargin);
 610         else {
 611             RenderObject* renderer = start.node()->renderer();
 612             if (!renderer)
 613                 return false;
 614
 615             // Calculate the rect of the first line of the selection (cribbed from -[WebCoreFrameBridge firstRectForDOMRange:]).
 616             int extraWidthToEndOfLine = 0;
 617             IntRect startCaretRect = renderer->caretRect(start.offset(), DOWNSTREAM, &extraWidthToEndOfLine);
 618             IntRect endCaretRect = renderer->caretRect(end.offset(), UPSTREAM);
 619
 620             IntRect firstRect;
 621             if (startCaretRect.y() == endCaretRect.y())
 622                 firstRect = IntRect(min(startCaretRect.x(), endCaretRect.x()), startCaretRect.y(), abs(endCaretRect.x() - startCaretRect.x()), max(startCaretRect.height(), endCaretRect.height()));
 623             else
 624                 firstRect = IntRect(startCaretRect.x(), startCaretRect.y(), startCaretRect.width() + extraWidthToEndOfLine, startCaretRect.height());
 625
 626             location = IntPoint(rightAligned ? firstRect.right() : firstRect.x(), firstRect.bottom());
 627         }
 628
 629         location = view->contentsToWindow(location);
 630         // FIXME: The IntSize(0, -1) is a hack to get the hit-testing to result in the selected element.
 631         // Ideally we'd have the position of a context menu event be separate from its target node.
 632         coords = location + IntSize(0, -1);
 633     } else {
 634         if (!::ScreenToClient(m_viewWindow, &coords))
 635             return false;
 636     }
 637
 638     lParam = MAKELPARAM(coords.x, coords.y);
 639
 640     // The contextMenuController() holds onto the last context menu that was popped up on the
 641     // page until a new one is created. We need to clear this menu before propagating the event
 642     // through the DOM so that we can detect if we create a new menu for this event, since we
 643     // won't create a new menu if the DOM swallows the event and the defaultEventHandler does
 644     // not run.
 645     m_page->contextMenuController()->clearContextMenu();
 646
 647     Frame* focusedFrame = m_page->focusController()->focusedOrMainFrame();
 648     focusedFrame->view()->setCursor(pointerCursor());
 649     PlatformMouseEvent mouseEvent(m_viewWindow, WM_RBUTTONUP, wParam, lParam);
 650     bool handledEvent = focusedFrame->eventHandler()->sendContextMenuEvent(mouseEvent);
 651     if (!handledEvent)
 652         return false;
 653
 654     // Show the menu
 655     ContextMenu* coreMenu = m_page->contextMenuController()->contextMenu();
 656     if (!coreMenu)
 657         return false;
 658
 659     Node* node = coreMenu->hitTestResult().innerNonSharedNode();
 660     if (!node)
 661         return false;
 662
 663     Frame* frame = node->document()->frame();
 664     if (!frame)
 665         return false;
 666
 667     FrameView* view = frame->view();
 668     if (!view)
 669         return false;
 670
 671     POINT point(view->contentsToWindow(coreMenu->hitTestResult().point()));
 672
 673     // Translate the point to screen coordinates
 674     if (!::ClientToScreen(view->containingWindow(), &point))
 675         return false;
 676
 677     BOOL hasCustomMenus = false;
 678     if (m_uiDelegate)
 679         m_uiDelegate->hasCustomMenuImplementation(&hasCustomMenus);
 680
 681     if (hasCustomMenus)
 682         m_uiDelegate->trackCustomPopupMenu((IWebView*)this, (OLE_HANDLE)(ULONG64)coreMenu->platformDescription(), &point);
 683     else {
 684         // Surprisingly, TPM_RIGHTBUTTON means that items are selectable with either the right OR left mouse button
 685         UINT flags = TPM_RIGHTBUTTON | TPM_TOPALIGN | TPM_VERPOSANIMATION | TPM_HORIZONTAL
 686             | TPM_LEFTALIGN | TPM_HORPOSANIMATION;
 687         ::TrackPopupMenuEx(coreMenu->platformDescription(), flags, point.x, point.y, view->containingWindow(), 0);
 688     }
 689
 690     return true;
 691 }
 692
 693 bool WebView::onMeasureItem(WPARAM /*wParam*/, LPARAM lParam)
 694 {
 695     if (!m_uiDelegate)
 696         return false;
 697
 698     BOOL hasCustomMenus = false;
 699     m_uiDelegate->hasCustomMenuImplementation(&hasCustomMenus);
 700     if (!hasCustomMenus)
 701         return false;
 702
 703     m_uiDelegate->measureCustomMenuItem((IWebView*)this, (void*)lParam);
 704     return true;
 705 }
 706
 707 bool WebView::onDrawItem(WPARAM /*wParam*/, LPARAM lParam)
 708 {
 709     if (!m_uiDelegate)
 710         return false;
 711
 712     BOOL hasCustomMenus = false;
 713     m_uiDelegate->hasCustomMenuImplementation(&hasCustomMenus);
 714     if (!hasCustomMenus)
 715         return false;
 716
 717     m_uiDelegate->drawCustomMenuItem((IWebView*)this, (void*)lParam);
 718     return true;
 719 }
 720
 721 bool WebView::onInitMenuPopup(WPARAM wParam, LPARAM /*lParam*/)
 722 {
 723     if (!m_uiDelegate)
 724         return false;
 725
 726     HMENU menu = (HMENU)wParam;
 727     if (!menu)
 728         return false;
 729
 730     BOOL hasCustomMenus = false;
 731     m_uiDelegate->hasCustomMenuImplementation(&hasCustomMenus);
 732     if (!hasCustomMenus)
 733         return false;
 734
 735     m_uiDelegate->addCustomMenuDrawingData((IWebView*)this, (OLE_HANDLE)(ULONG64)menu);
 736     return true;
 737 }
 738
 739 bool WebView::onUninitMenuPopup(WPARAM wParam, LPARAM /*lParam*/)
 740 {
 741     if (!m_uiDelegate)
 742         return false;
 743
 744     HMENU menu = (HMENU)wParam;
 745     if (!menu)
 746         return false;
 747
 748     BOOL hasCustomMenus = false;
 749     m_uiDelegate->hasCustomMenuImplementation(&hasCustomMenus);
 750     if (!hasCustomMenus)
 751         return false;
 752
 753     m_uiDelegate->cleanUpCustomMenuDrawingData((IWebView*)this, (OLE_HANDLE)(ULONG64)menu);
 754     return true;
 755 }
 756
 757 void WebView::performContextMenuAction(WPARAM wParam, LPARAM lParam, bool byPosition)
 758 {
 759     ContextMenu* menu = m_page->contextMenuController()->contextMenu();
 760     ASSERT(menu);
 761
 762     ContextMenuItem* item = byPosition ? menu->itemAtIndex((unsigned)wParam, (HMENU)lParam) : menu->itemWithAction((ContextMenuAction)wParam);
 763     if (!item)
 764         return;
 765     m_page->contextMenuController()->contextMenuItemSelected(item);
 766     delete item;
 767 }
 768
 769 bool WebView::handleMouseEvent(UINT message, WPARAM wParam, LPARAM lParam)
 770 {
 771     static LONG globalClickCount;
 772     static IntPoint globalPrevPoint;
 773     static MouseButton globalPrevButton;
 774     static LONG globalPrevMouseDownTime;
 775
 776     // Create our event.
 777     PlatformMouseEvent mouseEvent(m_viewWindow, message, wParam, lParam, m_mouseActivated);
 778
 779     bool insideThreshold = abs(globalPrevPoint.x() - mouseEvent.pos().x()) < ::GetSystemMetrics(SM_CXDOUBLECLK) &&
 780                            abs(globalPrevPoint.y() - mouseEvent.pos().y()) < ::GetSystemMetrics(SM_CYDOUBLECLK);
 781     LONG messageTime = ::GetMessageTime();
 782
 783     bool handled = false;
 784     if (message == WM_LBUTTONDOWN || message == WM_MBUTTONDOWN || message == WM_RBUTTONDOWN) {
 785         // FIXME: I'm not sure if this is the "right" way to do this
 786         // but without this call, we never become focused since we don't allow
 787         // the default handling of mouse events.
 788         SetFocus(m_viewWindow);
 789
 790         // Always start capturing events when the mouse goes down in our HWND.
 791         ::SetCapture(m_viewWindow);
 792
 793         if (((messageTime - globalPrevMouseDownTime) < (LONG)::GetDoubleClickTime()) &&
 794             insideThreshold &&
 795             mouseEvent.button() == globalPrevButton)
 796             globalClickCount++;
 797         else
 798             // Reset the click count.
 799             globalClickCount = 1;
 800         globalPrevMouseDownTime = messageTime;
 801         globalPrevButton = mouseEvent.button();
 802         globalPrevPoint = mouseEvent.pos();
 803
 804         mouseEvent.setClickCount(globalClickCount);
 805         handled = m_page->mainFrame()->eventHandler()->handleMousePressEvent(mouseEvent);
 806     } else if (message == WM_LBUTTONDBLCLK || message == WM_MBUTTONDBLCLK || message == WM_RBUTTONDBLCLK) {
 807         globalClickCount++;
 808         mouseEvent.setClickCount(globalClickCount);
 809         handled = m_page->mainFrame()->eventHandler()->handleMousePressEvent(mouseEvent);
 810     } else if (message == WM_LBUTTONUP || message == WM_MBUTTONUP || message == WM_RBUTTONUP) {
 811         // Record the global position and the button of the up.
 812         globalPrevButton = mouseEvent.button();
 813         globalPrevPoint = mouseEvent.pos();
 814         mouseEvent.setClickCount(globalClickCount);
 815         m_page->mainFrame()->eventHandler()->handleMouseReleaseEvent(mouseEvent);
 816         ::ReleaseCapture();
 817     } else if (message == WM_MOUSEMOVE) {
 818         if (!insideThreshold)
 819             globalClickCount = 0;
 820         mouseEvent.setClickCount(globalClickCount);
 821         handled = m_page->mainFrame()->eventHandler()->mouseMoved(mouseEvent);
 822     }
 823     setMouseActivated(false);
 824     return handled;
 825 }
 826
 827 bool WebView::mouseWheel(WPARAM wParam, LPARAM lParam, bool isHorizontal)
 828 {
 829     // Ctrl+Mouse wheel doesn't ever go into WebCore.  It is used to
 830     // zoom instead (Mac zooms the whole Desktop, but Windows browsers trigger their
 831     // own local zoom modes for Ctrl+wheel).
 832     if (wParam & MK_CONTROL) {
 833         short delta = short(HIWORD(wParam));
 834         if (delta < 0)
 835             makeTextLarger(0);
 836         else
 837             makeTextSmaller(0);
 838         return true;
 839     }
 840
 841     PlatformWheelEvent wheelEvent(m_viewWindow, wParam, lParam, isHorizontal);
 842     Frame* coreFrame = core(m_mainFrame);
 843     if (!coreFrame)
 844         return false;
 845
 846     return coreFrame->eventHandler()->handleWheelEvent(wheelEvent);
 847 }
 848
 849 bool WebView::execCommand(WPARAM wParam, LPARAM /*lParam*/)
 850 {
 851     Frame* frame = m_page->focusController()->focusedOrMainFrame();
 852     bool handled = false;
 853     switch (LOWORD(wParam)) {
 854     case SelectAll:
 855         handled = frame->editor()->execCommand("SelectAll");
 856         break;
 857     case Undo:
 858         handled = frame->editor()->execCommand("Undo");
 859         break;
 860     case Redo:
 861         handled = frame->editor()->execCommand("Redo");
 862         break;
 863     default:
 864         break;
 865     }
 866     return handled;
 867 }
 868
 869 bool WebView::keyUp(WPARAM virtualKeyCode, LPARAM keyData)
 870 {
 871     // Don't send key events for shift, ctrl, alt and capslock keys when they're by themselves
 872     if (virtualKeyCode == VK_SHIFT || virtualKeyCode == VK_CONTROL || virtualKeyCode == VK_MENU || virtualKeyCode == VK_CAPITAL)
 873         return false;
 874
 875     PlatformKeyboardEvent keyEvent(m_viewWindow, virtualKeyCode, keyData, m_currentCharacterCode);
 876
 877     // Don't send key events for alt+space and alt+f4.
 878     if (keyEvent.altKey() && (virtualKeyCode == VK_SPACE || virtualKeyCode == VK_F4))
 879         return false;
 880
 881     Frame* frame = m_page->focusController()->focusedOrMainFrame();
 882     m_currentCharacterCode = 0;
 883
 884     return frame->eventHandler()->keyEvent(keyEvent);
 885 }
 886
 887 static const unsigned CtrlKey = 1 << 0;
 888 static const unsigned AltKey = 1 << 1;
 889 static const unsigned ShiftKey = 1 << 2;
 890
 891
 892 struct KeyEntry {
 893     unsigned virtualKey;
 894     unsigned modifiers;
 895     const char* name;
 896 };
 897
 898 static const KeyEntry keyEntries[] = {
 899     { VK_LEFT,   0,                  "MoveLeft"                                    },
 900     { VK_LEFT,   ShiftKey,           "MoveLeftAndModifySelection"                  },
 901     { VK_LEFT,   CtrlKey,            "MoveWordLeft"                                },
 902     { VK_LEFT,   CtrlKey | ShiftKey, "MoveWordLeftAndModifySelection"              },
 903     { VK_RIGHT,  0,                  "MoveRight"                                   },
 904     { VK_RIGHT,  ShiftKey,           "MoveRightAndModifySelection"                 },
 905     { VK_RIGHT,  CtrlKey,            "MoveWordRight"                               },
 906     { VK_RIGHT,  CtrlKey | ShiftKey, "MoveWordRightAndModifySelection"             },
 907     { VK_UP,     0,                  "MoveUp"                                      },
 908     { VK_UP,     ShiftKey,           "MoveUpAndModifySelection"                    },
 909     { VK_PRIOR,  ShiftKey,           "MoveUpAndModifySelection"                    },
 910     { VK_DOWN,   0,                  "MoveDown"                                    },
 911     { VK_DOWN,   ShiftKey,           "MoveDownAndModifySelection"                  },
 912     { VK_NEXT,   ShiftKey,           "MoveDownAndModifySelection"                  },
 913     { VK_PRIOR,  0,                  "MoveUpByPageAndModifyCaret"                  },
 914     { VK_NEXT,   0,                  "MoveDownByPageAndModifyCaret"                },
 915     { VK_HOME,   0,                  "MoveToBeginningOfLine"                       },
 916     { VK_HOME,   ShiftKey,           "MoveToBeginningOfLineAndModifySelection"     },
 917     { VK_HOME,   CtrlKey,            "MoveToBeginningOfDocument"                   },
 918     { VK_HOME,   CtrlKey | ShiftKey, "MoveToBeginningOfDocumentAndModifySelection" },
 919
 920     { VK_END,    0,                  "MoveToEndOfLine"                             },
 921     { VK_END,    ShiftKey,           "MoveToEndOfLineAndModifySelection"           },
 922     { VK_END,    CtrlKey,            "MoveToEndOfDocument"                         },
 923     { VK_END,    CtrlKey | ShiftKey, "MoveToEndOfDocumentAndModifySelection"       },
 924
 925     { VK_BACK,   0,                  "BackwardDelete"                              },
 926     { VK_BACK,   ShiftKey,           "BackwardDelete"                              },
 927     { VK_DELETE, 0,                  "ForwardDelete"                               },
 928     { VK_DELETE, ShiftKey,           "ForwardDelete"                               },
 929     { VK_BACK,   CtrlKey,            "DeleteWordBackward"                          },
 930     { VK_DELETE, CtrlKey,            "DeleteWordForward"                           },
 931
 932     { 'B',       CtrlKey,            "ToggleBold"                                  },
 933     { 'I',       CtrlKey,            "ToggleItalic"                                },
 934
 935     { VK_ESCAPE, 0,                  "Cancel"                                      },
 936     { VK_OEM_PERIOD, CtrlKey,        "Cancel"                                      },
 937     { VK_TAB,    0,                  "InsertTab"                                   },
 938     { VK_TAB,    ShiftKey,           "InsertBacktab"                               },
 939     { VK_RETURN, 0,                  "InsertNewline"                               },
 940     { VK_RETURN, CtrlKey,            "InsertNewline"                               },
 941     { VK_RETURN, AltKey,             "InsertNewline"                               },
 942     { VK_RETURN, AltKey | ShiftKey,  "InsertNewline"                               },
 943
 944     { 'C',       CtrlKey,            "Copy"                                        },
 945     { 'V',       CtrlKey,            "Paste"                                       },
 946     { 'X',       CtrlKey,            "Cut"                                         },
 947     { 'A',       CtrlKey,            "SelectAll"                                   },
 948     { 'Z',       CtrlKey,            "Undo"                                        },
 949     { 'Z',       CtrlKey | ShiftKey, "Redo"                                        },
 950 };
 951
 952 const char* WebView::interpretKeyEvent(const KeyboardEvent* evt)
 953 {
 954     const PlatformKeyboardEvent* keyEvent = evt->keyEvent();
 955     if (!keyEvent)
 956         return "";
 957
 958     static HashMap<int, const char*>* commandsMap = 0;
 959
 960     if (!commandsMap) {
 961         commandsMap = new HashMap<int, const char*>;
 962
 963         for (unsigned i = 0; i < _countof(keyEntries); i++)
 964             commandsMap->set(keyEntries[i].modifiers << 16 | keyEntries[i].virtualKey, keyEntries[i].name);
 965     }
 966
 967     unsigned modifiers = 0;
 968     if (keyEvent->shiftKey())
 969         modifiers |= ShiftKey;
 970     if (keyEvent->altKey())
 971         modifiers |= AltKey;
 972     if (keyEvent->ctrlKey())
 973         modifiers |= CtrlKey;
 974
 975     return commandsMap->get(modifiers << 16 | keyEvent->WindowsKeyCode());
 976 }
 977
 978 bool WebView::handleEditingKeyboardEvent(KeyboardEvent* evt)
 979 {
 980     String command(interpretKeyEvent(evt));
 981
 982     Node* node = evt->target()->toNode();
 983     ASSERT(node);
 984     Frame* frame = node->document()->frame();
 985     ASSERT(frame);
 986
 987     if (!command.isEmpty())
 988         if (frame->editor()->execCommand(command, evt))
 989             return true;
 990
 991     if (!evt->keyEvent())
 992         return false;
 993
 994     if (evt->keyEvent()->text().length() == 1) {
 995         UChar ch = evt->keyEvent()->text()[0];
 996         // Don't insert null or control characters as they can reslt in unexpected behaviour
 997         if (ch < ' ')
 998             return false;
 999     }
1000
1001     return frame->editor()->insertText(evt->keyEvent()->text(), evt);
1002 }
1003
1004 bool WebView::keyDown(WPARAM virtualKeyCode, LPARAM keyData, bool systemKeyDown)
1005 {
1006     // Don't send key events for shift, ctrl, alt and capslock keys when they're by themselves
1007     if (virtualKeyCode == VK_SHIFT || virtualKeyCode == VK_CONTROL ||  virtualKeyCode == VK_MENU || virtualKeyCode == VK_CAPITAL)
1008         return false;
1009
1010     // Don't send key events for alt+space and alt+f4, since the OS needs to handle that.
1011     if (systemKeyDown && (virtualKeyCode == VK_SPACE || virtualKeyCode == VK_F4))
1012         return false;
1013
1014     MSG msg;
1015     // If the next message is a WM_CHAR message, then take it out of the queue, and use
1016     // the message parameters to get the character code to construct the PlatformKeyboardEvent.
1017     if (systemKeyDown) {
1018         if (::PeekMessage(&msg, m_viewWindow, WM_SYSCHAR, WM_SYSCHAR, PM_REMOVE))
1019             m_currentCharacterCode = (UChar)msg.wParam;
1020     } else if (::PeekMessage(&msg, m_viewWindow, WM_CHAR, WM_CHAR, PM_REMOVE))
1021         m_currentCharacterCode = (UChar)msg.wParam;
1022
1023     // FIXME: We need to check WM_UNICHAR to support supplementary characters.
1024     // FIXME: We may need to handle other messages for international text.
1025
1026     m_inIMEKeyDown = virtualKeyCode == VK_PROCESSKEY;
1027     if (virtualKeyCode == VK_PROCESSKEY && !m_inIMEComposition)
1028         virtualKeyCode = MapVirtualKey(LOBYTE(HIWORD(keyData)), 1);
1029
1030     PlatformKeyboardEvent keyEvent(m_viewWindow, virtualKeyCode, keyData, m_currentCharacterCode);
1031     Frame* frame = m_page->focusController()->focusedOrMainFrame();
1032     bool handled = frame->eventHandler()->keyEvent(keyEvent);
1033     m_inIMEKeyDown = false;
1034     if (handled)
1035         return true;
1036
1037     // We need to handle back/forward using either Backspace(+Shift) or Ctrl+Left/Right Arrow keys.
1038     int windowsKeyCode = keyEvent.WindowsKeyCode();
1039     if ((windowsKeyCode == VK_BACK && keyEvent.shiftKey()) || (windowsKeyCode == VK_RIGHT && keyEvent.ctrlKey()))
1040         m_page->goForward();
1041     else if (windowsKeyCode == VK_BACK || (windowsKeyCode == VK_LEFT && keyEvent.ctrlKey()))
1042         m_page->goBack();
1043
1044     // Need to scroll the page if the arrow keys, space(shift), pgup/dn, or home/end are hit.
1045     ScrollDirection direction;
1046     ScrollGranularity granularity;
1047     switch (windowsKeyCode) {
1048         case VK_LEFT:
1049             granularity = ScrollByLine;
1050             direction = ScrollLeft;
1051             break;
1052         case VK_RIGHT:
1053             granularity = ScrollByLine;
1054             direction = ScrollRight;
1055             break;
1056         case VK_UP:
1057             granularity = ScrollByLine;
1058             direction = ScrollUp;
1059             break;
1060         case VK_DOWN:
1061             granularity = ScrollByLine;
1062             direction = ScrollDown;
1063             break;
1064         case VK_HOME:
1065             granularity = ScrollByDocument;
1066             direction = ScrollUp;
1067             break;
1068         case VK_END:
1069             granularity = ScrollByDocument;
1070             direction = ScrollDown;
1071             break;
1072         case VK_SPACE:
1073             granularity = ScrollByPage;
1074             direction = (GetKeyState(VK_SHIFT) & 0x8000) ? ScrollUp : ScrollDown;
1075             break;
1076         case VK_PRIOR:
1077             granularity = ScrollByPage;
1078             direction = ScrollUp;
1079             break;
1080         case VK_NEXT:
1081             granularity = ScrollByPage;
1082             direction = ScrollDown;
1083             break;
1084         default:
1085             // We return true here so the WM_CHAR handler won't pick up unhandled messages.
1086             return true;
1087     }
1088
1089     if (!frame->eventHandler()->scrollOverflow(direction, granularity))
1090         frame->view()->scroll(direction, granularity);
1091
1092     return true;
1093 }
1094
1095 bool WebView::inResizer(LPARAM lParam)
1096 {
1097     if (!m_uiDelegatePrivate)
1098         return false;
1099
1100     RECT r;
1101     if (FAILED(m_uiDelegatePrivate->webViewResizerRect(this, &r)))
1102         return false;
1103
1104     POINT pt;
1105     pt.x = LOWORD(lParam);
1106     pt.y = HIWORD(lParam);
1107     return !!PtInRect(&r, pt);
1108 }
1109
1110 void WebView::initializeCacheSizesIfNecessary()
1111 {
1112     static bool didInitialize;
1113     if (didInitialize)
1114         return;
1115
1116     COMPtr<IWebPreferences> prefs;
1117     if (FAILED(preferences(&prefs)))
1118         return;
1119
1120    UINT pageCacheSize;
1121    if (SUCCEEDED(prefs->pageCacheSize(&pageCacheSize)))
1122         pageCache()->setCapacity(pageCacheSize);
1123
1124    UINT objectCacheSize;
1125    if (SUCCEEDED(prefs->objectCacheSize(&objectCacheSize)))
1126         cache()->setCapacities(0, objectCacheSize, objectCacheSize);
1127
1128     didInitialize = true;
1129 }
1130
1131 static ATOM registerWebViewWindowClass()
1132 {
1133     static bool haveRegisteredWindowClass = false;
1134     if (haveRegisteredWindowClass)
1135         return true;
1136
1137     WNDCLASSEX wcex;
1138
1139     wcex.cbSize = sizeof(WNDCLASSEX);
1140
1141     wcex.style          = CS_DBLCLKS;
1142     wcex.lpfnWndProc    = WebViewWndProc;
1143     wcex.cbClsExtra     = 0;
1144     wcex.cbWndExtra     = 4; // 4 bytes for the IWebView pointer
1145     wcex.hInstance      = gInstance;
1146     wcex.hIcon          = 0;
1147     wcex.hCursor        = ::LoadCursor(0, IDC_ARROW);
1148     wcex.hbrBackground  = 0;
1149     wcex.lpszMenuName   = 0;
1150     wcex.lpszClassName  = kWebViewWindowClassName;
1151     wcex.hIconSm        = 0;
1152
1153     return RegisterClassEx(&wcex);
1154 }
1155
1156 namespace WebCore {
1157     extern HCURSOR lastSetCursor;
1158 }
1159
1160 static LRESULT CALLBACK WebViewWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
1161 {
1162     LRESULT lResult = 0;
1163     LONG_PTR longPtr = GetWindowLongPtr(hWnd, 0);
1164     WebView* webView = reinterpret_cast<WebView*>(longPtr);
1165     WebFrame* mainFrameImpl = webView ? webView->topLevelFrame() : 0;
1166     if (!mainFrameImpl || webView->isBeingDestroyed())
1167         return DefWindowProc(hWnd, message, wParam, lParam);
1168
1169     ASSERT(webView);
1170
1171     bool handled = true;
1172
1173     switch (message) {
1174         case WM_PAINT: {
1175             COMPtr<IWebDataSource> dataSource;
1176             mainFrameImpl->dataSource(&dataSource);
1177             Frame* coreFrame = core(mainFrameImpl);
1178             if (!webView->isPainting() && (!dataSource || coreFrame && (coreFrame->view()->didFirstLayout() || !coreFrame->loader()->committedFirstRealDocumentLoad())))
1179                 webView->paint(0, 0);
1180             else
1181                 ValidateRect(hWnd, 0);
1182             break;
1183         }
1184         case WM_PRINTCLIENT:
1185             webView->paint((HDC)wParam, lParam);
1186             break;
1187         case WM_DESTROY:
1188             webView->close();
1189             webView->setIsBeingDestroyed();
1190             webView->revokeDragDrop();
1191             break;
1192         case WM_MOUSEMOVE:
1193             if (webView->inResizer(lParam))
1194                 SetCursor(LoadCursor(0, IDC_SIZENWSE));
1195             // fall through
1196         case WM_LBUTTONDOWN:
1197         case WM_MBUTTONDOWN:
1198         case WM_RBUTTONDOWN:
1199         case WM_LBUTTONDBLCLK:
1200         case WM_MBUTTONDBLCLK:
1201         case WM_RBUTTONDBLCLK:
1202         case WM_LBUTTONUP:
1203         case WM_MBUTTONUP:
1204         case WM_RBUTTONUP:
1205             if (Frame* coreFrame = core(mainFrameImpl))
1206                 if (coreFrame->view()->didFirstLayout())
1207                     handled = webView->handleMouseEvent(message, wParam, lParam);
1208             break;
1209         case WM_MOUSEWHEEL:
1210         case WM_VISTA_MOUSEHWHEEL:
1211             if (Frame* coreFrame = core(mainFrameImpl))
1212                 if (coreFrame->view()->didFirstLayout())
1213                     handled = webView->mouseWheel(wParam, lParam, (wParam & MK_SHIFT) || message == WM_VISTA_MOUSEHWHEEL);
1214             break;
1215         case WM_SYSKEYDOWN:
1216             handled = webView->keyDown(wParam, lParam, true);
1217             break;
1218         case WM_KEYDOWN:
1219             handled = webView->keyDown(wParam, lParam);
1220             break;
1221         case WM_SYSKEYUP:
1222         case WM_KEYUP:
1223             handled = webView->keyUp(wParam, lParam);
1224             break;
1225         case WM_SIZE:
1226             if (webView->isBeingDestroyed())
1227                 // If someone has sent us this message while we're being destroyed, we should bail out so we don't crash.
1228                 break;
1229
1230             if (lParam != 0) {
1231                 webView->deleteBackingStore();
1232                 if (Frame* coreFrame = core(mainFrameImpl)) {
1233                     coreFrame->view()->resize(LOWORD(lParam), HIWORD(lParam));
1234
1235                     if (!coreFrame->loader()->isLoading())
1236                         coreFrame->sendResizeEvent();
1237                 }
1238             }
1239             break;
1240         case WM_SHOWWINDOW:
1241             lResult = DefWindowProc(hWnd, message, wParam, lParam);
1242             if (wParam == 0)
1243                 // The window is being hidden (e.g., because we switched tabs.
1244                 // Null out our backing store.
1245                 webView->deleteBackingStore();
1246             break;
1247         case WM_SETFOCUS: {
1248             COMPtr<IWebUIDelegate> uiDelegate;
1249             COMPtr<IWebUIDelegatePrivate> uiDelegatePrivate;
1250             if (SUCCEEDED(webView->uiDelegate(&uiDelegate)) && uiDelegate &&
1251                 SUCCEEDED(uiDelegate->QueryInterface(IID_IWebUIDelegatePrivate, (void**) &uiDelegatePrivate)) && uiDelegatePrivate)
1252                 uiDelegatePrivate->webViewReceivedFocus(webView);
1253             // FIXME: Merge this logic with updateActiveState, and switch this over to use updateActiveState
1254
1255             // It's ok to just always do setWindowHasFocus, since we won't fire the focus event on the DOM
1256             // window unless the value changes.  It's also ok to do setIsActive inside focus,
1257             // because Windows has no concept of having to update control tints (e.g., graphite vs. aqua)
1258             // and therefore only needs to update the selection (which is limited to the focused frame).
1259             FocusController* focusController = webView->page()->focusController();
1260             if (Frame* frame = focusController->focusedFrame()) {
1261                 frame->setIsActive(true);
1262
1263                 // If the previously focused window is a child of ours (for example a plugin), don't send any
1264                 // focus events.
1265                 if (!IsChild(hWnd, reinterpret_cast<HWND>(wParam)))
1266                     frame->setWindowHasFocus(true);
1267             } else
1268                 focusController->setFocusedFrame(webView->page()->mainFrame());
1269             break;
1270         }
1271         case WM_KILLFOCUS: {
1272             COMPtr<IWebUIDelegate> uiDelegate;
1273             COMPtr<IWebUIDelegatePrivate> uiDelegatePrivate;
1274             if (SUCCEEDED(webView->uiDelegate(&uiDelegate)) && uiDelegate &&
1275                 SUCCEEDED(uiDelegate->QueryInterface(IID_IWebUIDelegatePrivate, (void**) &uiDelegatePrivate)) && uiDelegatePrivate)
1276                 uiDelegatePrivate->webViewLostFocus(webView, (OLE_HANDLE)(ULONG64)wParam);
1277             // FIXME: Merge this logic with updateActiveState, and switch this over to use updateActiveState
1278
1279             // However here we have to be careful.  If we are losing focus because of a deactivate,
1280             // then we need to remember our focused target for restoration later.
1281             // If we are losing focus to another part of our window, then we are no longer focused for real
1282             // and we need to clear out the focused target.
1283             FocusController* focusController = webView->page()->focusController();
1284             webView->resetIME(focusController->focusedOrMainFrame());
1285             if (GetAncestor(hWnd, GA_ROOT) != GetFocus()) {
1286                 if (Frame* frame = focusController->focusedFrame()) {
1287                     frame->setIsActive(false);
1288
1289                     // If we're losing focus to a child of ours, don't send blur events.
1290                     if (!IsChild(hWnd, reinterpret_cast<HWND>(wParam)))
1291                         frame->setWindowHasFocus(false);
1292                 }
1293             } else
1294                 focusController->setFocusedFrame(0);
1295             break;
1296         }
1297         case WM_CUT:
1298             webView->cut(0);
1299             break;
1300         case WM_COPY:
1301             webView->copy(0);
1302             break;
1303         case WM_PASTE:
1304             webView->paste(0);
1305             break;
1306         case WM_CLEAR:
1307             webView->delete_(0);
1308             break;
1309         case WM_COMMAND:
1310             if (HIWORD(wParam))
1311                 handled = webView->execCommand(wParam, lParam);
1312             else // If the high word of wParam is 0, the message is from a menu
1313                 webView->performContextMenuAction(wParam, lParam, false);
1314             break;
1315         case WM_MENUCOMMAND:
1316             webView->performContextMenuAction(wParam, lParam, true);
1317             break;
1318         case WM_CONTEXTMENU:
1319             handled = webView->handleContextMenuEvent(wParam, lParam);
1320             break;
1321         case WM_INITMENUPOPUP:
1322             handled = webView->onInitMenuPopup(wParam, lParam);
1323             break;
1324         case WM_MEASUREITEM:
1325             handled = webView->onMeasureItem(wParam, lParam);
1326             break;
1327         case WM_DRAWITEM:
1328             handled = webView->onDrawItem(wParam, lParam);
1329             break;
1330         case WM_UNINITMENUPOPUP:
1331             handled = webView->onUninitMenuPopup(wParam, lParam);
1332             break;
1333         case WM_XP_THEMECHANGED:
1334             if (Frame* coreFrame = core(mainFrameImpl)) {
1335                 webView->deleteBackingStore();
1336                 coreFrame->view()->themeChanged();
1337             }
1338             break;
1339         case WM_MOUSEACTIVATE:
1340             webView->setMouseActivated(true);
1341             break;
1342         case WM_GETDLGCODE: {
1343             COMPtr<IWebUIDelegate> uiDelegate;
1344             COMPtr<IWebUIDelegatePrivate> uiDelegatePrivate;
1345             LONG_PTR dlgCode = 0;
1346             UINT keyCode = 0;
1347             if (lParam) {
1348                 LPMSG lpMsg = (LPMSG)lParam;
1349                 if (lpMsg->message == WM_KEYDOWN)
1350                     keyCode = (UINT) lpMsg->wParam;
1351             }
1352             if (SUCCEEDED(webView->uiDelegate(&uiDelegate)) && uiDelegate &&
1353                 SUCCEEDED(uiDelegate->QueryInterface(IID_IWebUIDelegatePrivate, (void**) &uiDelegatePrivate)) && uiDelegatePrivate &&
1354                 SUCCEEDED(uiDelegatePrivate->webViewGetDlgCode(webView, keyCode, &dlgCode)))
1355                 return dlgCode;
1356             handled = false;
1357             break;
1358         }
1359
1360         case WM_IME_STARTCOMPOSITION:
1361             handled = webView->onIMEStartComposition();
1362             break;
1363         case WM_IME_REQUEST:
1364             webView->onIMERequest(wParam, lParam, &lResult);
1365             break;
1366         case WM_IME_COMPOSITION:
1367             handled = webView->onIMEComposition(lParam);
1368             break;
1369         case WM_IME_ENDCOMPOSITION:
1370             handled = webView->onIMEEndComposition();
1371             break;
1372         case WM_IME_CHAR:
1373             handled = webView->onIMEChar(wParam, lParam);
1374             break;
1375         case WM_IME_NOTIFY:
1376             handled = webView->onIMENotify(wParam, lParam, &lResult);
1377             break;
1378         case WM_IME_SELECT:
1379             handled = webView->onIMESelect(wParam, lParam);
1380             break;
1381         case WM_IME_SETCONTEXT:
1382             handled = webView->onIMESetContext(wParam, lParam);
1383             break;
1384         case WM_SETCURSOR:
1385             if (lastSetCursor) {
1386                 SetCursor(lastSetCursor);
1387                 break;
1388             }
1389             __fallthrough;
1390         default:
1391             handled = false;
1392             break;
1393     }
1394
1395     if (!handled)
1396         lResult = DefWindowProc(hWnd, message, wParam, lParam);
1397
1398     return lResult;
1399 }
1400
1401 HRESULT WebView::updateWebCoreSettingsFromPreferences(IWebPreferences* preferences)
1402 {
1403     HRESULT hr;
1404     BSTR str;
1405     int size;
1406     BOOL enabled;
1407
1408     Settings* settings = m_page->settings();
1409
1410     hr = preferences->cursiveFontFamily(&str);
1411     if (FAILED(hr))
1412         return hr;
1413     settings->setCursiveFontFamily(AtomicString(str, SysStringLen(str)));
1414     SysFreeString(str);
1415
1416     hr = preferences->defaultFixedFontSize(&size);
1417     if (FAILED(hr))
1418         return hr;
1419     settings->setDefaultFixedFontSize(size);
1420
1421     hr = preferences->defaultFontSize(&size);
1422     if (FAILED(hr))
1423         return hr;
1424     settings->setDefaultFontSize(size);
1425
1426     hr = preferences->defaultTextEncodingName(&str);
1427     if (FAILED(hr))
1428         return hr;
1429     settings->setDefaultTextEncodingName(String(str, SysStringLen(str)));
1430     SysFreeString(str);
1431
1432     hr = preferences->fantasyFontFamily(&str);
1433     if (FAILED(hr))
1434         return hr;
1435     settings->setFantasyFontFamily(AtomicString(str, SysStringLen(str)));
1436     SysFreeString(str);
1437
1438     hr = preferences->fixedFontFamily(&str);
1439     if (FAILED(hr))
1440         return hr;
1441     settings->setFixedFontFamily(AtomicString(str, SysStringLen(str)));
1442     SysFreeString(str);
1443
1444     hr = preferences->isJavaEnabled(&enabled);
1445     if (FAILED(hr))
1446         return hr;
1447     settings->setJavaEnabled(!!enabled);
1448
1449     hr = preferences->isJavaScriptEnabled(&enabled);
1450     if (FAILED(hr))
1451         return hr;
1452     settings->setJavaScriptEnabled(!!enabled);
1453
1454     hr = preferences->javaScriptCanOpenWindowsAutomatically(&enabled);
1455     if (FAILED(hr))
1456         return hr;
1457     settings->setJavaScriptCanOpenWindowsAutomatically(!!enabled);
1458
1459     hr = preferences->minimumFontSize(&size);
1460     if (FAILED(hr))
1461         return hr;
1462     settings->setMinimumFontSize(size);
1463
1464     hr = preferences->minimumLogicalFontSize(&size);
1465     if (FAILED(hr))
1466         return hr;
1467     settings->setMinimumLogicalFontSize(size);
1468
1469     hr = preferences->arePlugInsEnabled(&enabled);
1470     if (FAILED(hr))
1471         return hr;
1472     settings->setPluginsEnabled(!!enabled);
1473
1474     hr = preferences->privateBrowsingEnabled(&enabled);
1475     if (FAILED(hr))
1476         return hr;
1477     settings->setPrivateBrowsingEnabled(!!enabled);
1478
1479     hr = preferences->sansSerifFontFamily(&str);
1480     if (FAILED(hr))
1481         return hr;
1482     settings->setSansSerifFontFamily(AtomicString(str, SysStringLen(str)));
1483     SysFreeString(str);
1484
1485     hr = preferences->serifFontFamily(&str);
1486     if (FAILED(hr))
1487         return hr;
1488     settings->setSerifFontFamily(AtomicString(str, SysStringLen(str)));
1489     SysFreeString(str);
1490
1491     hr = preferences->standardFontFamily(&str);
1492     if (FAILED(hr))
1493         return hr;
1494     settings->setStandardFontFamily(AtomicString(str, SysStringLen(str)));
1495     SysFreeString(str);
1496
1497     hr = preferences->loadsImagesAutomatically(&enabled);
1498     if (FAILED(hr))
1499         return hr;
1500     settings->setLoadsImagesAutomatically(!!enabled);
1501
1502     hr = preferences->userStyleSheetEnabled(&enabled);
1503     if (FAILED(hr))
1504         return hr;
1505     if (enabled) {
1506         hr = preferences->userStyleSheetLocation(&str);
1507         if (FAILED(hr))
1508             return hr;
1509
1510         RetainPtr<CFStringRef> urlString(AdoptCF, String(str, SysStringLen(str)).createCFString());
1511         RetainPtr<CFURLRef> url(AdoptCF, CFURLCreateWithString(kCFAllocatorDefault, urlString.get(), 0));
1512
1513         // Check if the passed in string is a path and convert it to a URL.
1514         // FIXME: This is a workaround for nightly builds until we can get Safari to pass
1515         // in an URL here. See <rdar://problem/5478378>
1516         if (!url) {
1517             DWORD len = SysStringLen(str) + 1;
1518
1519             int result = WideCharToMultiByte(CP_UTF8, 0, str, len, 0, 0, 0, 0);
1520             Vector<UInt8> utf8Path(result);
1521             if (!WideCharToMultiByte(CP_UTF8, 0, str, len, (LPSTR)utf8Path.data(), result, 0, 0))
1522                 return E_FAIL;
1523
1524             url.adoptCF(CFURLCreateFromFileSystemRepresentation(0, utf8Path.data(), result - 1, false));
1525         }
1526
1527         settings->setUserStyleSheetLocation(url.get());
1528         SysFreeString(str);
1529     } else {
1530         settings->setUserStyleSheetLocation(KURL(DeprecatedString("")));
1531     }
1532
1533     hr = preferences->shouldPrintBackgrounds(&enabled);
1534     if (FAILED(hr))
1535         return hr;
1536     settings->setShouldPrintBackgrounds(!!enabled);
1537
1538     hr = preferences->textAreasAreResizable(&enabled);
1539     if (FAILED(hr))
1540         return hr;
1541     settings->setTextAreasAreResizable(!!enabled);
1542
1543     WebKitEditableLinkBehavior behavior;
1544     hr = preferences->editableLinkBehavior(&behavior);
1545     if (FAILED(hr))
1546         return hr;
1547     settings->setEditableLinkBehavior((EditableLinkBehavior)behavior);
1548
1549     WebKitCookieStorageAcceptPolicy acceptPolicy;
1550     hr = preferences->cookieStorageAcceptPolicy(&acceptPolicy);
1551     if (FAILED(hr))
1552         return hr;
1553
1554     hr = preferences->usesPageCache(&enabled);
1555     if (FAILED(hr))
1556         return hr;
1557     settings->setUsesPageCache(!!enabled);
1558
1559     hr = preferences->isDOMPasteAllowed(&enabled);
1560     if (FAILED(hr))
1561         return hr;
1562     settings->setDOMPasteAllowed(!!enabled);
1563
1564     ResourceHandle::setCookieStorageAcceptPolicy(acceptPolicy);
1565
1566     settings->setShowsURLsInToolTips(false);
1567
1568     settings->setForceFTPDirectoryListings(true);
1569
1570     settings->setDeveloperExtrasEnabled(developerExtrasEnabled());
1571
1572     m_mainFrame->invalidate(); // FIXME
1573
1574     return S_OK;
1575 }
1576
1577 bool WebView::developerExtrasEnabled() const
1578 {
1579     COMPtr<WebPreferences> webPrefs;
1580     if (SUCCEEDED(m_preferences->QueryInterface(IID_WebPreferences, (void**)&webPrefs)) && webPrefs->developerExtrasDisabledByOverride())
1581         return false;
1582
1583 #ifdef NDEBUG
1584     BOOL enabled = FALSE;
1585     COMPtr<IWebPreferencesPrivate> prefsPrivate;
1586     return SUCCEEDED(m_preferences->QueryInterface(&prefsPrivate)) && SUCCEEDED(prefsPrivate->developerExtrasEnabled(&enabled)) && enabled;
1587 #else
1588     return true;
1589 #endif
1590 }
1591
1592 static String osVersion()
1593 {
1594     String osVersion;
1595     OSVERSIONINFO versionInfo = {0};
1596     versionInfo.dwOSVersionInfoSize = sizeof(versionInfo);
1597     GetVersionEx(&versionInfo);
1598
1599     if (versionInfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) {
1600         if (versionInfo.dwMajorVersion == 4) {
1601             if (versionInfo.dwMinorVersion == 0)
1602                 osVersion = "Windows 95";
1603             else if (versionInfo.dwMinorVersion == 10)
1604                 osVersion = "Windows 98";
1605             else if (versionInfo.dwMinorVersion == 90)
1606                 osVersion = "Windows 98; Win 9x 4.90";
1607         }
1608     } else if (versionInfo.dwPlatformId == VER_PLATFORM_WIN32_NT)
1609         osVersion = String::format("Windows NT %d.%d", versionInfo.dwMajorVersion, versionInfo.dwMinorVersion);
1610
1611     if (!osVersion.length())
1612         osVersion = String::format("Windows %d.%d", versionInfo.dwMajorVersion, versionInfo.dwMinorVersion);
1613
1614     return osVersion;
1615 }
1616
1617 static String webKitVersion()
1618 {
1619     String versionStr = "420+";
1620     void* data = 0;
1621
1622     struct LANGANDCODEPAGE {
1623         WORD wLanguage;
1624         WORD wCodePage;
1625     } *lpTranslate;
1626
1627     TCHAR path[MAX_PATH];
1628     GetModuleFileName(gInstance, path, ARRAYSIZE(path));
1629     DWORD handle;
1630     DWORD versionSize = GetFileVersionInfoSize(path, &handle);
1631     if (!versionSize)
1632         goto exit;
1633     data = malloc(versionSize);
1634     if (!data)
1635         goto exit;
1636     if (!GetFileVersionInfo(path, 0, versionSize, data))
1637         goto exit;
1638     UINT cbTranslate;
1639     if (!VerQueryValue(data, TEXT("\\VarFileInfo\\Translation"), (LPVOID*)&lpTranslate, &cbTranslate))
1640         goto exit;
1641     TCHAR key[256];
1642     _stprintf_s(key, ARRAYSIZE(key), TEXT("\\StringFileInfo\\%04x%04x\\ProductVersion"), lpTranslate[0].wLanguage, lpTranslate[0].wCodePage);
1643     LPCTSTR productVersion;
1644     UINT productVersionLength;
1645     if (!VerQueryValue(data, (LPTSTR)(LPCTSTR)key, (void**)&productVersion, &productVersionLength))
1646         goto exit;
1647     versionStr = String(productVersion, productVersionLength);
1648
1649 exit:
1650     if (data)
1651         free(data);
1652     return versionStr;
1653 }
1654
1655 const String& WebView::userAgentForKURL(const KURL&)
1656 {
1657     if (m_userAgentOverridden)
1658         return m_userAgentCustom;
1659
1660     if (!m_userAgentStandard.length())
1661         m_userAgentStandard = String::format("Mozilla/5.0 (Windows; U; %s; %s) AppleWebKit/%s (KHTML, like Gecko)%s%s", osVersion().latin1().data(), defaultLanguage().latin1().data(), webKitVersion().latin1().data(), (m_applicationName.length() ? " " : ""), m_applicationName.latin1().data());
1662     return m_userAgentStandard;
1663 }
1664
1665 // IUnknown -------------------------------------------------------------------
1666
1667 HRESULT STDMETHODCALLTYPE WebView::QueryInterface(REFIID riid, void** ppvObject)
1668 {
1669     *ppvObject = 0;
1670     if (IsEqualGUID(riid, CLSID_WebView))
1671         *ppvObject = this;
1672     else if (IsEqualGUID(riid, IID_IUnknown))
1673         *ppvObject = static_cast<IWebView*>(this);
1674     else if (IsEqualGUID(riid, IID_IWebView))
1675         *ppvObject = static_cast<IWebView*>(this);
1676     else if (IsEqualGUID(riid, IID_IWebViewPrivate))
1677         *ppvObject = static_cast<IWebViewPrivate*>(this);
1678     else if (IsEqualGUID(riid, IID_IWebIBActions))
1679         *ppvObject = static_cast<IWebIBActions*>(this);
1680     else if (IsEqualGUID(riid, IID_IWebViewCSS))
1681         *ppvObject = static_cast<IWebViewCSS*>(this);
1682     else if (IsEqualGUID(riid, IID_IWebViewEditing))
1683         *ppvObject = static_cast<IWebViewEditing*>(this);
1684     else if (IsEqualGUID(riid, IID_IWebViewUndoableEditing))
1685         *ppvObject = static_cast<IWebViewUndoableEditing*>(this);
1686     else if (IsEqualGUID(riid, IID_IWebViewEditingActions))
1687         *ppvObject = static_cast<IWebViewEditingActions*>(this);
1688     else if (IsEqualGUID(riid, IID_IWebNotificationObserver))
1689         *ppvObject = static_cast<IWebNotificationObserver*>(this);
1690     else if (IsEqualGUID(riid, IID_IDropTarget))
1691         *ppvObject = static_cast<IDropTarget*>(this);
1692     else
1693         return E_NOINTERFACE;
1694
1695     AddRef();
1696     return S_OK;
1697 }
1698
1699 ULONG STDMETHODCALLTYPE WebView::AddRef(void)
1700 {
1701     return ++m_refCount;
1702 }
1703
1704 ULONG STDMETHODCALLTYPE WebView::Release(void)
1705 {
1706     ULONG newRef = --m_refCount;
1707     if (!newRef)
1708         delete(this);
1709
1710     return newRef;
1711 }
1712
1713 // IWebView --------------------------------------------------------------------
1714
1715 HRESULT STDMETHODCALLTYPE WebView::canShowMIMEType(
1716     /* [in] */ BSTR mimeType,
1717     /* [retval][out] */ BOOL* canShow)
1718 {
1719     String mimeTypeStr(mimeType, SysStringLen(mimeType));
1720
1721     if (!canShow)
1722         return E_POINTER;
1723
1724     *canShow = MIMETypeRegistry::isSupportedImageMIMEType(mimeTypeStr) ||
1725         MIMETypeRegistry::isSupportedNonImageMIMEType(mimeTypeStr) ||
1726         PlugInInfoStore::supportsMIMEType(mimeTypeStr);
1727
1728     return S_OK;
1729 }
1730
1731 HRESULT STDMETHODCALLTYPE WebView::canShowMIMETypeAsHTML(
1732     /* [in] */ BSTR /*mimeType*/,
1733     /* [retval][out] */ BOOL* canShow)
1734 {
1735     // FIXME
1736     *canShow = TRUE;
1737     return S_OK;
1738 }
1739
1740 HRESULT STDMETHODCALLTYPE WebView::MIMETypesShownAsHTML(
1741     /* [retval][out] */ IEnumVARIANT** /*enumVariant*/)
1742 {
1743     ASSERT_NOT_REACHED();
1744     return E_NOTIMPL;
1745 }
1746
1747 HRESULT STDMETHODCALLTYPE WebView::setMIMETypesShownAsHTML(
1748         /* [size_is][in] */ BSTR* /*mimeTypes*/,
1749         /* [in] */ int /*cMimeTypes*/)
1750 {
1751     ASSERT_NOT_REACHED();
1752     return E_NOTIMPL;
1753 }
1754
1755 HRESULT STDMETHODCALLTYPE WebView::URLFromPasteboard(
1756     /* [in] */ IDataObject* /*pasteboard*/,
1757     /* [retval][out] */ BSTR* /*url*/)
1758 {
1759     ASSERT_NOT_REACHED();
1760     return E_NOTIMPL;
1761 }
1762
1763 HRESULT STDMETHODCALLTYPE WebView::URLTitleFromPasteboard(
1764     /* [in] */ IDataObject* /*pasteboard*/,
1765     /* [retval][out] */ BSTR* /*urlTitle*/)
1766 {
1767     ASSERT_NOT_REACHED();
1768     return E_NOTIMPL;
1769 }
1770
1771 HRESULT STDMETHODCALLTYPE WebView::initWithFrame(
1772     /* [in] */ RECT frame,
1773     /* [in] */ BSTR frameName,
1774     /* [in] */ BSTR groupName)
1775 {
1776     HRESULT hr = S_OK;
1777
1778     if (m_viewWindow)
1779         return E_FAIL;
1780
1781     registerWebViewWindowClass();
1782
1783     if (!::IsWindow(m_hostWindow)) {
1784         ASSERT_NOT_REACHED();
1785         return E_FAIL;
1786     }
1787
1788     m_viewWindow = CreateWindowEx(0, kWebViewWindowClassName, 0, WS_CHILD | WS_CLIPCHILDREN,
1789         frame.left, frame.top, frame.right - frame.left, frame.bottom - frame.top, m_hostWindow, 0, gInstance, 0);
1790     ASSERT(::IsWindow(m_viewWindow));
1791
1792     hr = registerDragDrop();
1793     if (FAILED(hr))
1794         return hr;
1795
1796     m_groupName = String(groupName, SysStringLen(groupName));
1797
1798     m_page = new Page(new WebChromeClient(this), new WebContextMenuClient(this), new WebEditorClient(this), new WebDragClient(this), new WebInspectorClient(this));
1799     // FIXME: 4931464 - When we do cache pages on Windows this needs to be removed so the "should I cache this page?" check
1800     // in FrameLoader::provisionalLoadStarted() doesn't always fail
1801     m_page->settings()->setUsesPageCache(false);
1802
1803     // Try to set the FTP Directory template path in WebCore when the first WebView is initialized
1804     static bool setFTPDirectoryTemplatePathOnce = false;
1805
1806     if (!setFTPDirectoryTemplatePathOnce && m_uiDelegate) {
1807         COMPtr<IWebUIDelegate2> uiDelegate2;
1808         if (SUCCEEDED(m_uiDelegate->QueryInterface(IID_IWebUIDelegate2, (void**)&uiDelegate2))) {
1809             BSTR path;
1810             if (SUCCEEDED(uiDelegate2->ftpDirectoryTemplatePath(this, &path))) {
1811                 m_page->settings()->setFTPDirectoryTemplatePath(String(path, SysStringLen(path)));
1812                 SysFreeString(path);
1813                 setFTPDirectoryTemplatePathOnce = true;
1814             }
1815         }
1816     }
1817
1818     WebFrame* webFrame = WebFrame::createInstance();
1819     webFrame->initWithWebFrameView(0 /*FIXME*/, this, m_page, 0);
1820     m_mainFrame = webFrame;
1821     webFrame->Release(); // The WebFrame is owned by the Frame, so release our reference to it.
1822     m_page->mainFrame()->view()->resize(frame.right - frame.left, frame.bottom - frame.top);
1823
1824     m_page->mainFrame()->tree()->setName(String(frameName, SysStringLen(frameName)));
1825     m_page->mainFrame()->init();
1826     m_page->setGroupName(m_groupName);
1827
1828     #pragma warning(suppress: 4244)
1829     SetWindowLongPtr(m_viewWindow, 0, (LONG_PTR)this);
1830     ShowWindow(m_viewWindow, SW_SHOW);
1831
1832     initializeCacheSizesIfNecessary();
1833     initializeToolTipWindow();
1834
1835     // Update WebCore with preferences.  These values will either come from an archived WebPreferences,
1836     // or from the standard preferences, depending on whether this method was called from initWithCoder:
1837     // or initWithFrame, respectively.
1838     //[self _updateWebCoreSettingsFromPreferences: [self preferences]];
1839     COMPtr<IWebPreferences> prefs;
1840     if (FAILED(preferences(&prefs)))
1841         return hr;
1842     hr = updateWebCoreSettingsFromPreferences(prefs.get());
1843     if (FAILED(hr))
1844         return hr;
1845
1846     // Use default cookie storage
1847     RetainPtr<CFHTTPCookieStorageRef> cookies(AdoptCF, CFHTTPCookieStorageCreateFromFile(kCFAllocatorDefault, 0, 0));
1848     ResourceHandle::setCookieStorage(cookies.get());
1849
1850     // Register to receive notifications whenever preference values change.
1851     //[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(_preferencesChangedNotification:)
1852     //                                             name:WebPreferencesChangedNotification object:[self preferences]];
1853     IWebNotificationCenter* notifyCenter = WebNotificationCenter::defaultCenterInternal();
1854     if (!WebPreferences::webPreferencesChangedNotification())
1855         return E_OUTOFMEMORY;
1856     notifyCenter->addObserver(this, WebPreferences::webPreferencesChangedNotification(), prefs.get());
1857
1858     setSmartInsertDeleteEnabled(TRUE);
1859     return hr;
1860 }
1861
1862 static bool initCommonControls()
1863 {
1864     static bool haveInitialized = false;
1865     if (haveInitialized)
1866         return true;
1867
1868     INITCOMMONCONTROLSEX init;
1869     init.dwSize = sizeof(init);
1870     init.dwICC = ICC_TREEVIEW_CLASSES;
1871     haveInitialized = !!::InitCommonControlsEx(&init);
1872     return haveInitialized;
1873 }
1874
1875 void WebView::initializeToolTipWindow()
1876 {
1877     if (!initCommonControls())
1878         return;
1879
1880     m_toolTipHwnd = CreateWindowEx(0, TOOLTIPS_CLASS, 0, WS_POPUP | TTS_NOPREFIX | TTS_ALWAYSTIP,
1881                                    CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
1882                                    m_viewWindow, 0, 0, 0);
1883     if (!m_toolTipHwnd)
1884         return;
1885
1886     TOOLINFO info = {0};
1887     info.cbSize = sizeof(info);
1888     info.uFlags = TTF_IDISHWND | TTF_SUBCLASS ;
1889     info.uId = reinterpret_cast<UINT_PTR>(m_viewWindow);
1890
1891     ::SendMessage(m_toolTipHwnd, TTM_ADDTOOL, 0, reinterpret_cast<LPARAM>(&info));
1892     ::SendMessage(m_toolTipHwnd, TTM_SETMAXTIPWIDTH, 0, maxToolTipWidth);
1893
1894     ::SetWindowPos(m_toolTipHwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
1895 }
1896
1897 void WebView::setToolTip(const String& toolTip)
1898 {
1899     if (!m_toolTipHwnd)
1900         return;
1901
1902     if (toolTip == m_toolTip)
1903         return;
1904
1905     m_toolTip = toolTip;
1906
1907     if (!m_toolTip.isEmpty()) {
1908         TOOLINFO info = {0};
1909         info.cbSize = sizeof(info);
1910         info.uFlags = TTF_IDISHWND;
1911         info.uId = reinterpret_cast<UINT_PTR>(m_viewWindow);
1912         info.lpszText = const_cast<UChar*>(m_toolTip.charactersWithNullTermination());
1913         ::SendMessage(m_toolTipHwnd, TTM_UPDATETIPTEXT, 0, reinterpret_cast<LPARAM>(&info));
1914     }
1915
1916     ::SendMessage(m_toolTipHwnd, TTM_ACTIVATE, !m_toolTip.isEmpty(), 0);
1917 }
1918
1919 HRESULT WebView::notifyDidAddIcon(IWebNotification* notification)
1920 {
1921     COMPtr<IPropertyBag> propertyBag;
1922     HRESULT hr = notification->userInfo(&propertyBag);
1923     if (FAILED(hr))
1924         return hr;
1925     if (!propertyBag)
1926         return E_FAIL;
1927
1928     COMPtr<CFDictionaryPropertyBag> dictionaryPropertyBag;
1929     hr = propertyBag->QueryInterface(IID_CFDictionaryPropertyBag, (void**)&dictionaryPropertyBag);
1930     if (FAILED(hr))
1931         return hr;
1932
1933     CFDictionaryRef dictionary = dictionaryPropertyBag->dictionary();
1934     if (!dictionary)
1935         return E_FAIL;
1936
1937     CFTypeRef value = CFDictionaryGetValue(dictionary, WebIconDatabase::iconDatabaseNotificationUserInfoURLKey());
1938     if (!value)
1939         return E_FAIL;
1940     if (CFGetTypeID(value) != CFStringGetTypeID())
1941         return E_FAIL;
1942
1943     String mainFrameURL;
1944     if (m_mainFrame)
1945         mainFrameURL = m_mainFrame->url().url();
1946
1947     if (!mainFrameURL.isEmpty() && mainFrameURL == String((CFStringRef)value))
1948         dispatchDidReceiveIconFromWebFrame(m_mainFrame);
1949
1950     return hr;
1951 }
1952
1953 void WebView::registerForIconNotification(bool listen)
1954 {
1955     IWebNotificationCenter* nc = WebNotificationCenter::defaultCenterInternal();
1956     if (listen)
1957         nc->addObserver(this, WebIconDatabase::iconDatabaseDidAddIconNotification(), 0);
1958     else
1959         nc->removeObserver(this, WebIconDatabase::iconDatabaseDidAddIconNotification(), 0);
1960 }
1961
1962 void WebView::dispatchDidReceiveIconFromWebFrame(WebFrame* frame)
1963 {
1964     registerForIconNotification(false);
1965
1966     if (m_frameLoadDelegate)
1967         // FIXME: <rdar://problem/5491010> - Pass in the right HBITMAP.
1968         m_frameLoadDelegate->didReceiveIcon(this, 0, frame);
1969 }
1970
1971 HRESULT STDMETHODCALLTYPE WebView::setUIDelegate(
1972     /* [in] */ IWebUIDelegate* d)
1973 {
1974     m_uiDelegate = d;
1975
1976     if (m_uiDelegatePrivate)
1977         m_uiDelegatePrivate = 0;
1978
1979     if (d) {
1980         if (FAILED(d->QueryInterface(IID_IWebUIDelegatePrivate, (void**)&m_uiDelegatePrivate)))
1981             m_uiDelegatePrivate = 0;
1982     }
1983
1984     return S_OK;
1985 }
1986
1987 HRESULT STDMETHODCALLTYPE WebView::uiDelegate(
1988     /* [out][retval] */ IWebUIDelegate** d)
1989 {
1990     if (!m_uiDelegate)
1991         return E_FAIL;
1992
1993     return m_uiDelegate.copyRefTo(d);
1994 }
1995
1996 HRESULT STDMETHODCALLTYPE WebView::setResourceLoadDelegate(
1997     /* [in] */ IWebResourceLoadDelegate* d)
1998 {
1999     m_resourceLoadDelegate = d;
2000     return S_OK;
2001 }
2002
2003 HRESULT STDMETHODCALLTYPE WebView::resourceLoadDelegate(
2004     /* [out][retval] */ IWebResourceLoadDelegate** d)
2005 {
2006     if (!m_resourceLoadDelegate)
2007         return E_FAIL;
2008
2009     return m_resourceLoadDelegate.copyRefTo(d);
2010 }
2011
2012 HRESULT STDMETHODCALLTYPE WebView::setDownloadDelegate(
2013     /* [in] */ IWebDownloadDelegate* d)
2014 {
2015     m_downloadDelegate = d;
2016     return S_OK;
2017 }
2018
2019 HRESULT STDMETHODCALLTYPE WebView::downloadDelegate(
2020     /* [out][retval] */ IWebDownloadDelegate** d)
2021 {
2022     if (!m_downloadDelegate)
2023         return E_FAIL;
2024
2025     return m_downloadDelegate.copyRefTo(d);
2026 }
2027
2028 HRESULT STDMETHODCALLTYPE WebView::setFrameLoadDelegate(
2029     /* [in] */ IWebFrameLoadDelegate* d)
2030 {
2031     m_frameLoadDelegate = d;
2032     return S_OK;
2033 }
2034
2035 HRESULT STDMETHODCALLTYPE WebView::frameLoadDelegate(
2036     /* [out][retval] */ IWebFrameLoadDelegate** d)
2037 {
2038     if (!m_frameLoadDelegate)
2039         return E_FAIL;
2040
2041     return m_frameLoadDelegate.copyRefTo(d);
2042 }
2043
2044 HRESULT STDMETHODCALLTYPE WebView::setPolicyDelegate(
2045     /* [in] */ IWebPolicyDelegate* d)
2046 {
2047     m_policyDelegate = d;
2048     return S_OK;
2049 }
2050
2051 HRESULT STDMETHODCALLTYPE WebView::policyDelegate(
2052     /* [out][retval] */ IWebPolicyDelegate** d)
2053 {
2054     if (!m_policyDelegate)
2055         return E_FAIL;
2056     return m_policyDelegate.copyRefTo(d);
2057 }
2058
2059 HRESULT STDMETHODCALLTYPE WebView::mainFrame(
2060     /* [out][retval] */ IWebFrame** frame)
2061 {
2062     if (!frame) {
2063         ASSERT_NOT_REACHED();
2064         return E_POINTER;
2065     }
2066
2067     *frame = m_mainFrame;
2068     if (!m_mainFrame)
2069         return E_FAIL;
2070
2071     m_mainFrame->AddRef();
2072     return S_OK;
2073 }
2074
2075 HRESULT STDMETHODCALLTYPE WebView::focusedFrame(
2076     /* [out][retval] */ IWebFrame** frame)
2077 {
2078     if (!frame) {
2079         ASSERT_NOT_REACHED();
2080         return E_POINTER;
2081     }
2082
2083     *frame = 0;
2084     Frame* f = m_page->focusController()->focusedFrame();
2085     if (!f)
2086         return E_FAIL;
2087
2088     WebFrame* webFrame = kit(f);
2089     if (!webFrame)
2090         return E_FAIL;
2091
2092     return webFrame->QueryInterface(IID_IWebFrame, (void**) frame);
2093 }
2094 HRESULT STDMETHODCALLTYPE WebView::backForwardList(
2095     /* [out][retval] */ IWebBackForwardList** list)
2096 {
2097     if (!m_useBackForwardList)
2098         return E_FAIL;
2099
2100     *list = WebBackForwardList::createInstance(m_page->backForwardList());
2101
2102     return S_OK;
2103 }
2104
2105 HRESULT STDMETHODCALLTYPE WebView::setMaintainsBackForwardList(
2106     /* [in] */ BOOL flag)
2107 {
2108     m_useBackForwardList = !!flag;
2109     return S_OK;
2110 }
2111
2112 HRESULT STDMETHODCALLTYPE WebView::goBack(
2113     /* [retval][out] */ BOOL* succeeded)
2114 {
2115     *succeeded = m_page->goBack();
2116     return S_OK;
2117 }
2118
2119 HRESULT STDMETHODCALLTYPE WebView::goForward(
2120     /* [retval][out] */ BOOL* succeeded)
2121 {
2122     *succeeded = m_page->goForward();
2123     return S_OK;
2124 }
2125
2126 HRESULT STDMETHODCALLTYPE WebView::goToBackForwardItem(
2127     /* [in] */ IWebHistoryItem* item,
2128     /* [retval][out] */ BOOL* succeeded)
2129 {
2130     *succeeded = FALSE;
2131
2132     COMPtr<WebHistoryItem> webHistoryItem;
2133     HRESULT hr = item->QueryInterface(CLSID_WebHistoryItem, (void**)&webHistoryItem);
2134     if (FAILED(hr))
2135         return hr;
2136
2137     m_page->goToItem(webHistoryItem->historyItem(), FrameLoadTypeIndexedBackForward);
2138     *succeeded = TRUE;
2139
2140     return S_OK;
2141 }
2142
2143 HRESULT STDMETHODCALLTYPE WebView::setTextSizeMultiplier(
2144     /* [in] */ float multiplier)
2145 {
2146     if (m_textSizeMultiplier != multiplier)
2147         m_textSizeMultiplier = multiplier;
2148
2149     if (!m_mainFrame)
2150         return E_FAIL;
2151
2152     m_mainFrame->setTextSizeMultiplier(multiplier);
2153     return S_OK;
2154 }
2155
2156 HRESULT STDMETHODCALLTYPE WebView::textSizeMultiplier(
2157     /* [retval][out] */ float* multiplier)
2158 {
2159     *multiplier = m_textSizeMultiplier;
2160     return S_OK;
2161 }
2162
2163 HRESULT STDMETHODCALLTYPE WebView::setApplicationNameForUserAgent(
2164     /* [in] */ BSTR applicationName)
2165 {
2166     m_applicationName = String(applicationName, SysStringLen(applicationName));
2167     m_userAgentStandard = String();
2168     return S_OK;
2169 }
2170
2171 HRESULT STDMETHODCALLTYPE WebView::applicationNameForUserAgent(
2172     /* [retval][out] */ BSTR* applicationName)
2173 {
2174     *applicationName = SysAllocStringLen(m_applicationName.characters(), m_applicationName.length());
2175     if (!*applicationName && m_applicationName.length())
2176         return E_OUTOFMEMORY;
2177     return S_OK;
2178 }
2179
2180 HRESULT STDMETHODCALLTYPE WebView::setCustomUserAgent(
2181     /* [in] */ BSTR userAgentString)
2182 {
2183     m_userAgentOverridden = true;
2184     m_userAgentCustom = String(userAgentString, SysStringLen(userAgentString));
2185     return S_OK;
2186 }
2187
2188 HRESULT STDMETHODCALLTYPE WebView::customUserAgent(
2189     /* [retval][out] */ BSTR* userAgentString)
2190 {
2191     *userAgentString = 0;
2192     if (!m_userAgentOverridden)
2193         return S_OK;
2194     *userAgentString = SysAllocStringLen(m_userAgentCustom.characters(), m_userAgentCustom.length());
2195     if (!*userAgentString && m_userAgentCustom.length())
2196         return E_OUTOFMEMORY;
2197     return S_OK;
2198 }
2199
2200 HRESULT STDMETHODCALLTYPE WebView::userAgentForURL(
2201     /* [in] */ BSTR url,
2202     /* [retval][out] */ BSTR* userAgent)
2203 {
2204     DeprecatedString urlStr((DeprecatedChar*)url, SysStringLen(url));
2205     String userAgentString = this->userAgentForKURL(KURL(urlStr));
2206     *userAgent = SysAllocStringLen(userAgentString.characters(), userAgentString.length());
2207     if (!*userAgent && userAgentString.length())
2208         return E_OUTOFMEMORY;
2209     return S_OK;
2210 }
2211
2212 HRESULT STDMETHODCALLTYPE WebView::supportsTextEncoding(
2213     /* [retval][out] */ BOOL* supports)
2214 {
2215     *supports = TRUE;
2216     return S_OK;
2217 }
2218
2219 HRESULT STDMETHODCALLTYPE WebView::setCustomTextEncodingName(
2220     /* [in] */ BSTR encodingName)
2221 {
2222     if (!m_mainFrame)
2223         return E_FAIL;
2224
2225     HRESULT hr;
2226     BSTR oldEncoding;
2227     hr = customTextEncodingName(&oldEncoding);
2228     if (FAILED(hr))
2229         return hr;
2230
2231     if (oldEncoding != encodingName && (!oldEncoding || !encodingName || _tcscmp(oldEncoding, encodingName))) {
2232         if (Frame* coreFrame = core(m_mainFrame))
2233             coreFrame->loader()->reloadAllowingStaleData(String(encodingName, SysStringLen(encodingName)));
2234     }
2235
2236     return S_OK;
2237 }
2238
2239 HRESULT STDMETHODCALLTYPE WebView::customTextEncodingName(
2240     /* [retval][out] */ BSTR* encodingName)
2241 {
2242     HRESULT hr = S_OK;
2243     COMPtr<IWebDataSource> dataSource;
2244     COMPtr<WebDataSource> dataSourceImpl;
2245     *encodingName = 0;
2246
2247     if (!m_mainFrame)
2248         return E_FAIL;
2249
2250     if (FAILED(m_mainFrame->provisionalDataSource(&dataSource)) || !dataSource) {
2251         hr = m_mainFrame->dataSource(&dataSource);
2252         if (FAILED(hr) || !dataSource)
2253             return hr;
2254     }
2255
2256     hr = dataSource->QueryInterface(IID_WebDataSource, (void**)&dataSourceImpl);
2257     if (FAILED(hr))
2258         return hr;
2259
2260     BString str = dataSourceImpl->documentLoader()->overrideEncoding();
2261     if (FAILED(hr))
2262         return hr;
2263
2264     if (!*encodingName)
2265         *encodingName = SysAllocStringLen(m_overrideEncoding.characters(), m_overrideEncoding.length());
2266
2267     if (!*encodingName && m_overrideEncoding.length())
2268         return E_OUTOFMEMORY;
2269
2270     return S_OK;
2271 }
2272
2273 HRESULT STDMETHODCALLTYPE WebView::setMediaStyle(
2274     /* [in] */ BSTR /*media*/)
2275 {
2276     ASSERT_NOT_REACHED();
2277     return E_NOTIMPL;
2278 }
2279
2280 HRESULT STDMETHODCALLTYPE WebView::mediaStyle(
2281     /* [retval][out] */ BSTR* /*media*/)
2282 {
2283     ASSERT_NOT_REACHED();
2284     return E_NOTIMPL;
2285 }
2286
2287 HRESULT STDMETHODCALLTYPE WebView::stringByEvaluatingJavaScriptFromString(
2288     /* [in] */ BSTR script, // assumes input does not have "JavaScript" at the begining.
2289     /* [retval][out] */ BSTR* result)
2290 {
2291     if (!result) {
2292         ASSERT_NOT_REACHED();
2293         return E_POINTER;
2294     }
2295
2296     *result = 0;
2297
2298     Frame* coreFrame = core(m_mainFrame);
2299     if (!coreFrame)
2300         return E_FAIL;
2301
2302     KJS::JSValue* scriptExecutionResult = coreFrame->loader()->executeScript(WebCore::String(script), true);
2303     if(!scriptExecutionResult)
2304         return E_FAIL;
2305     else if (scriptExecutionResult->isString()) {
2306         JSLock lock;
2307         *result = BString(String(scriptExecutionResult->getString()));
2308     }
2309
2310     return S_OK;
2311 }
2312
2313 HRESULT STDMETHODCALLTYPE WebView::windowScriptObject(
2314     /* [retval][out] */ IWebScriptObject** /*webScriptObject*/)
2315 {
2316     ASSERT_NOT_REACHED();
2317     return E_NOTIMPL;
2318 }
2319
2320 HRESULT STDMETHODCALLTYPE WebView::setPreferences(
2321     /* [in] */ IWebPreferences* prefs)
2322 {
2323     if (m_preferences == prefs)
2324         return S_OK;
2325
2326     IWebNotificationCenter* nc = WebNotificationCenter::defaultCenterInternal();
2327     COMPtr<IWebPreferences> oldPrefs;
2328     if (SUCCEEDED(preferences(&oldPrefs)) && oldPrefs) {
2329         nc->removeObserver(this, WebPreferences::webPreferencesChangedNotification(), oldPrefs.get());
2330         BSTR identifier = 0;
2331         HRESULT hr = oldPrefs->identifier(&identifier);
2332         oldPrefs = 0;   // make sure we release the reference, since WebPreferences::removeReferenceForIdentifier will check for last reference to WebPreferences
2333         if (SUCCEEDED(hr))
2334             WebPreferences::removeReferenceForIdentifier(identifier);
2335         if (identifier)
2336             SysFreeString(identifier);
2337     }
2338     m_preferences = prefs;
2339     COMPtr<IWebPreferences> newPrefs;
2340     if (SUCCEEDED(preferences(&newPrefs)))
2341         nc->addObserver(this, WebPreferences::webPreferencesChangedNotification(), newPrefs.get());
2342     HRESULT hr = nc->postNotificationName(WebPreferences::webPreferencesChangedNotification(), newPrefs.get(), 0);
2343     if (FAILED(hr))
2344         return hr;
2345
2346     return S_OK;
2347 }
2348
2349 HRESULT STDMETHODCALLTYPE WebView::preferences(
2350     /* [retval][out] */ IWebPreferences** prefs)
2351 {
2352     HRESULT hr = S_OK;
2353
2354     if (!m_preferences)
2355         m_preferences = WebPreferences::sharedStandardPreferences();
2356
2357     m_preferences.copyRefTo(prefs);
2358     return hr;
2359 }
2360
2361 HRESULT STDMETHODCALLTYPE WebView::setPreferencesIdentifier(
2362     /* [in] */ BSTR /*anIdentifier*/)
2363 {
2364     ASSERT_NOT_REACHED();
2365     return E_NOTIMPL;
2366 }
2367
2368 HRESULT STDMETHODCALLTYPE WebView::preferencesIdentifier(
2369     /* [retval][out] */ BSTR* /*anIdentifier*/)
2370 {
2371     ASSERT_NOT_REACHED();
2372     return E_NOTIMPL;
2373 }
2374
2375 HRESULT STDMETHODCALLTYPE WebView::setHostWindow(
2376     /* [in] */ OLE_HANDLE oleWindow)
2377 {
2378     HWND window = (HWND)(ULONG64)oleWindow;
2379     if (m_viewWindow && window)
2380         SetParent(m_viewWindow, window);
2381
2382     m_hostWindow = window;
2383
2384     return S_OK;
2385 }
2386
2387 HRESULT STDMETHODCALLTYPE WebView::hostWindow(
2388     /* [retval][out] */ OLE_HANDLE* window)
2389 {
2390     *window = (OLE_HANDLE)(ULONG64)m_hostWindow;
2391     return S_OK;
2392 }
2393
2394
2395 static Frame *incrementFrame(Frame *curr, bool forward, bool wrapFlag)
2396 {
2397     return forward
2398         ? curr->tree()->traverseNextWithWrap(wrapFlag)
2399         : curr->tree()->traversePreviousWithWrap(wrapFlag);
2400 }
2401
2402 HRESULT STDMETHODCALLTYPE WebView::searchFor(
2403     /* [in] */ BSTR str,
2404     /* [in] */ BOOL forward,
2405     /* [in] */ BOOL caseFlag,
2406     /* [in] */ BOOL wrapFlag,
2407     /* [retval][out] */ BOOL* found)
2408 {
2409     if (!found)
2410         return E_INVALIDARG;
2411
2412     if (!m_page || !m_page->mainFrame())
2413         return E_UNEXPECTED;
2414
2415     if (!str || !SysStringLen(str))
2416         return E_INVALIDARG;
2417
2418     String search(str, SysStringLen(str));
2419
2420
2421     WebCore::Frame* frame = m_page->focusController()->focusedOrMainFrame();
2422     WebCore::Frame* startFrame = frame;
2423     do {
2424         *found = frame->findString(search, !!forward, !!caseFlag, false, true);
2425         if (*found) {
2426             if (frame != startFrame)
2427                 startFrame->selectionController()->clear();
2428             m_page->focusController()->setFocusedFrame(frame);
2429             return S_OK;
2430         }
2431         frame = incrementFrame(frame, !!forward, !!wrapFlag);
2432     } while (frame && frame != startFrame);
2433
2434     // Search contents of startFrame, on the other side of the selection that we did earlier.
2435     // We cheat a bit and just research with wrap on
2436     if (wrapFlag && !startFrame->selectionController()->isNone()) {
2437         *found = startFrame->findString(search, !!forward, !!caseFlag, true, true);
2438         m_page->focusController()->setFocusedFrame(frame);
2439     }
2440
2441     return S_OK;
2442 }
2443
2444 HRESULT STDMETHODCALLTYPE WebView::updateActiveState()
2445 {
2446     Frame* frame = m_page->mainFrame();
2447
2448     HWND window = ::GetAncestor(m_viewWindow, GA_ROOT);
2449     HWND activeWindow = ::GetActiveWindow();
2450     bool windowIsKey = window == activeWindow;
2451     activeWindow = ::GetAncestor(activeWindow, GA_ROOTOWNER);
2452
2453     bool windowOrSheetIsKey = windowIsKey || (window == activeWindow);
2454
2455     frame->setIsActive(windowIsKey);
2456
2457     Frame* focusedFrame = m_page->focusController()->focusedOrMainFrame();
2458     frame->setWindowHasFocus(frame == focusedFrame && windowOrSheetIsKey);
2459
2460     return S_OK;
2461 }
2462
2463 HRESULT STDMETHODCALLTYPE WebView::markAllMatchesForText(
2464     BSTR str, BOOL caseSensitive, BOOL highlight, UINT limit, UINT* matches)
2465 {
2466     if (!matches)
2467         return E_INVALIDARG;
2468
2469     if (!m_page || !m_page->mainFrame())
2470         return E_UNEXPECTED;
2471
2472     if (!str || !SysStringLen(str))
2473         return E_INVALIDARG;
2474
2475     String search(str, SysStringLen(str));
2476     *matches = 0;
2477
2478     WebCore::Frame* frame = m_page->mainFrame();
2479     do {
2480         frame->setMarkedTextMatchesAreHighlighted(!!highlight);
2481         *matches += frame->markAllMatchesForText(search, !!caseSensitive, (limit == 0)? 0 : (limit - *matches));
2482         frame = incrementFrame(frame, true, false);
2483     } while (frame);
2484
2485     return S_OK;
2486
2487 }
2488
2489 HRESULT STDMETHODCALLTYPE WebView::unmarkAllTextMatches()
2490 {
2491     if (!m_page || !m_page->mainFrame())
2492         return E_UNEXPECTED;
2493
2494     WebCore::Frame* frame = m_page->mainFrame();
2495     do {
2496         if (Document* document = frame->document())
2497             document->removeMarkers(DocumentMarker::TextMatch);
2498         frame = incrementFrame(frame, true, false);
2499     } while (frame);
2500
2501
2502     return S_OK;
2503 }
2504
2505 HRESULT STDMETHODCALLTYPE WebView::rectsForTextMatches(
2506     IEnumTextMatches** pmatches)
2507 {
2508     Vector<IntRect> allRects;
2509     WebCore::Frame* frame = m_page->mainFrame();
2510     do {
2511         if (Document* document = frame->document()) {
2512             IntRect visibleRect = enclosingIntRect(frame->view()->visibleContentRect());
2513             Vector<IntRect> frameRects = document->renderedRectsForMarkers(DocumentMarker::TextMatch);
2514             IntPoint frameOffset(-frame->view()->scrollOffset().width(), -frame->view()->scrollOffset().height());
2515             frameOffset = frame->view()->convertToContainingWindow(frameOffset);
2516
2517             Vector<IntRect>::iterator end = frameRects.end();
2518             for (Vector<IntRect>::iterator it = frameRects.begin(); it < end; it++) {
2519                 it->intersect(visibleRect);
2520                 it->move(frameOffset.x(), frameOffset.y());
2521                 allRects.append(*it);
2522             }
2523         }
2524         frame = incrementFrame(frame, true, false);
2525     } while (frame);
2526
2527     return createMatchEnumerator(&allRects, pmatches);
2528 }
2529
2530 HRESULT STDMETHODCALLTYPE WebView::generateSelectionImage(BOOL forceWhiteText, OLE_HANDLE* hBitmap)
2531 {
2532     *hBitmap = 0;
2533
2534     WebCore::Frame* frame = m_page->focusController()->focusedOrMainFrame();
2535
2536     if (frame) {
2537         HBITMAP bitmap = imageFromSelection(frame, forceWhiteText ? TRUE : FALSE);
2538         *hBitmap = (OLE_HANDLE)(ULONG64)bitmap;
2539     }
2540
2541     return S_OK;
2542 }
2543
2544 HRESULT STDMETHODCALLTYPE WebView::selectionImageRect(RECT* rc)
2545 {
2546     WebCore::Frame* frame = m_page->focusController()->focusedOrMainFrame();
2547
2548     if (frame) {
2549         IntRect ir = enclosingIntRect(frame->selectionRect());
2550         ir = frame->view()->convertToContainingWindow(ir);
2551         ir.move(-frame->view()->scrollOffset().width(), -frame->view()->scrollOffset().height());
2552         rc->left = ir.x();
2553         rc->top = ir.y();
2554         rc->bottom = rc->top + ir.height();
2555         rc->right = rc->left + ir.width();
2556     }
2557
2558     return S_OK;
2559 }
2560
2561 HRESULT STDMETHODCALLTYPE WebView::registerViewClass(
2562     /* [in] */ IWebDocumentView* /*view*/,
2563     /* [in] */ IWebDocumentRepresentation* /*representation*/,
2564     /* [in] */ BSTR /*forMIMEType*/)
2565 {
2566     ASSERT_NOT_REACHED();
2567     return E_NOTIMPL;
2568 }
2569
2570 HRESULT STDMETHODCALLTYPE WebView::setGroupName(
2571         /* [in] */ BSTR groupName)
2572 {
2573     m_groupName = String(groupName, SysStringLen(groupName));
2574     return S_OK;
2575 }
2576
2577 HRESULT STDMETHODCALLTYPE WebView::groupName(
2578         /* [retval][out] */ BSTR* groupName)
2579 {
2580     *groupName = SysAllocStringLen(m_groupName.characters(), m_groupName.length());
2581     if (!*groupName && m_groupName.length())
2582         return E_OUTOFMEMORY;
2583     return S_OK;
2584 }
2585
2586 HRESULT STDMETHODCALLTYPE WebView::estimatedProgress(
2587         /* [retval][out] */ double* estimatedProgress)
2588 {
2589     *estimatedProgress = m_page->progress()->estimatedProgress();
2590     return S_OK;
2591 }
2592
2593 HRESULT STDMETHODCALLTYPE WebView::isLoading(
2594         /* [retval][out] */ BOOL* isLoading)
2595 {
2596     COMPtr<IWebDataSource> dataSource;
2597     COMPtr<IWebDataSource> provisionalDataSource;
2598
2599     if (!isLoading)
2600         return E_POINTER;
2601
2602     *isLoading = FALSE;
2603
2604     if (SUCCEEDED(m_mainFrame->dataSource(&dataSource)))
2605         dataSource->isLoading(isLoading);
2606
2607     if (*isLoading)
2608         return S_OK;
2609
2610     if (SUCCEEDED(m_mainFrame->provisionalDataSource(&provisionalDataSource)))
2611         provisionalDataSource->isLoading(isLoading);
2612     return S_OK;
2613 }
2614
2615 HRESULT STDMETHODCALLTYPE WebView::elementAtPoint(
2616         /* [in] */ LPPOINT point,
2617         /* [retval][out] */ IPropertyBag** elementDictionary)
2618 {
2619     if (!elementDictionary) {
2620         ASSERT_NOT_REACHED();
2621         return E_POINTER;
2622     }
2623
2624     *elementDictionary = 0;
2625
2626     Frame* frame = core(m_mainFrame);
2627     if (!frame)
2628         return E_FAIL;
2629
2630     IntPoint webCorePoint = IntPoint(point->x, point->y);
2631     HitTestResult result = HitTestResult(webCorePoint);
2632     if (frame->renderer())
2633         result = frame->eventHandler()->hitTestResultAtPoint(webCorePoint, false);
2634     *elementDictionary = WebElementPropertyBag::createInstance(result);
2635     return S_OK;
2636 }
2637
2638 HRESULT STDMETHODCALLTYPE WebView::pasteboardTypesForSelection(
2639     /* [retval][out] */ IEnumVARIANT** /*enumVariant*/)
2640 {
2641     ASSERT_NOT_REACHED();
2642     return E_NOTIMPL;
2643 }
2644
2645 HRESULT STDMETHODCALLTYPE WebView::writeSelectionWithPasteboardTypes(
2646         /* [size_is][in] */ BSTR* /*types*/,
2647         /* [in] */ int /*cTypes*/,
2648         /* [in] */ IDataObject* /*pasteboard*/)
2649 {
2650     ASSERT_NOT_REACHED();
2651     return E_NOTIMPL;
2652 }
2653
2654 HRESULT STDMETHODCALLTYPE WebView::pasteboardTypesForElement(
2655     /* [in] */ IPropertyBag* /*elementDictionary*/,
2656     /* [retval][out] */ IEnumVARIANT** /*enumVariant*/)
2657 {
2658     ASSERT_NOT_REACHED();
2659     return E_NOTIMPL;
2660 }
2661
2662 HRESULT STDMETHODCALLTYPE WebView::writeElement(
2663         /* [in] */ IPropertyBag* /*elementDictionary*/,
2664         /* [size_is][in] */ BSTR* /*withPasteboardTypes*/,
2665         /* [in] */ int /*cWithPasteboardTypes*/,
2666         /* [in] */ IDataObject* /*pasteboard*/)
2667 {
2668     ASSERT_NOT_REACHED();
2669     return E_NOTIMPL;
2670 }
2671
2672 HRESULT STDMETHODCALLTYPE WebView::selectedText(
2673         /* [out, retval] */ BSTR* text)
2674 {
2675     if (!text) {
2676         ASSERT_NOT_REACHED();
2677         return E_POINTER;
2678     }
2679
2680     *text = 0;
2681
2682     Frame* focusedFrame = (m_page && m_page->focusController()) ? m_page->focusController()->focusedOrMainFrame() : 0;
2683     if (!focusedFrame)
2684         return E_FAIL;
2685
2686     String frameSelectedText = focusedFrame->selectedText();
2687     *text = SysAllocStringLen(frameSelectedText.characters(), frameSelectedText.length());
2688     if (!*text && frameSelectedText.length())
2689         return E_OUTOFMEMORY;
2690     return S_OK;
2691 }
2692
2693 HRESULT STDMETHODCALLTYPE WebView::centerSelectionInVisibleArea(
2694         /* [in] */ IUnknown* /* sender */)
2695 {
2696     Frame* coreFrame = core(m_mainFrame);
2697     if (!coreFrame)
2698         return E_FAIL;
2699
2700     coreFrame->revealSelection(RenderLayer::gAlignCenterAlways);
2701     return S_OK;
2702 }
2703
2704
2705 HRESULT STDMETHODCALLTYPE WebView::moveDragCaretToPoint(
2706         /* [in] */ LPPOINT /*point*/)
2707 {
2708     ASSERT_NOT_REACHED();
2709     return E_NOTIMPL;
2710 }
2711
2712 HRESULT STDMETHODCALLTYPE WebView::removeDragCaret( void)
2713 {
2714     ASSERT_NOT_REACHED();
2715     return E_NOTIMPL;
2716 }
2717
2718 HRESULT STDMETHODCALLTYPE WebView::setDrawsBackground(
2719         /* [in] */ BOOL /*drawsBackground*/)
2720 {
2721     ASSERT_NOT_REACHED();
2722     return E_NOTIMPL;
2723 }
2724
2725 HRESULT STDMETHODCALLTYPE WebView::drawsBackground(
2726         /* [retval][out] */ BOOL* /*drawsBackground*/)
2727 {
2728     ASSERT_NOT_REACHED();
2729     return E_NOTIMPL;
2730 }
2731
2732 HRESULT STDMETHODCALLTYPE WebView::setMainFrameURL(
2733         /* [in] */ BSTR /*urlString*/)
2734 {
2735     ASSERT_NOT_REACHED();
2736     return E_NOTIMPL;
2737 }
2738
2739 HRESULT STDMETHODCALLTYPE WebView::mainFrameURL(
2740         /* [retval][out] */ BSTR* /*urlString*/)
2741 {
2742     ASSERT_NOT_REACHED();
2743     return E_NOTIMPL;
2744 }
2745
2746 HRESULT STDMETHODCALLTYPE WebView::mainFrameDocument(
2747         /* [retval][out] */ IDOMDocument** document)
2748 {
2749     if (document)
2750         *document = 0;
2751     if (!m_mainFrame)
2752         return E_FAIL;
2753     return m_mainFrame->DOMDocument(document);
2754 }
2755
2756 HRESULT STDMETHODCALLTYPE WebView::mainFrameTitle(
2757         /* [retval][out] */ BSTR* /*title*/)
2758 {
2759     ASSERT_NOT_REACHED();
2760     return E_NOTIMPL;
2761 }
2762
2763 HRESULT STDMETHODCALLTYPE WebView::mainFrameIcon(
2764         /* [retval][out] */ OLE_HANDLE* /*hBitmap*/)
2765 {
2766     ASSERT_NOT_REACHED();
2767     return E_NOTIMPL;
2768 }
2769
2770 // IWebIBActions ---------------------------------------------------------------
2771
2772 HRESULT STDMETHODCALLTYPE WebView::takeStringURLFrom(
2773         /* [in] */ IUnknown* /*sender*/)
2774 {
2775     ASSERT_NOT_REACHED();
2776     return E_NOTIMPL;
2777 }
2778
2779 HRESULT STDMETHODCALLTYPE WebView::stopLoading(
2780         /* [in] */ IUnknown* /*sender*/)
2781 {
2782     if (!m_mainFrame)
2783         return E_FAIL;
2784
2785     return m_mainFrame->stopLoading();
2786 }
2787
2788 HRESULT STDMETHODCALLTYPE WebView::reload(
2789         /* [in] */ IUnknown* /*sender*/)
2790 {
2791     if (!m_mainFrame)
2792         return E_FAIL;
2793
2794     return m_mainFrame->reload();
2795 }
2796
2797 HRESULT STDMETHODCALLTYPE WebView::canGoBack(
2798         /* [in] */ IUnknown* /*sender*/,
2799         /* [retval][out] */ BOOL* result)
2800 {
2801     *result = !!m_page->backForwardList()->backItem();
2802     return S_OK;
2803 }
2804
2805 HRESULT STDMETHODCALLTYPE WebView::goBack(
2806         /* [in] */ IUnknown* /*sender*/)
2807 {
2808     ASSERT_NOT_REACHED();
2809     return E_NOTIMPL;
2810 }
2811
2812 HRESULT STDMETHODCALLTYPE WebView::canGoForward(
2813         /* [in] */ IUnknown* /*sender*/,
2814         /* [retval][out] */ BOOL* result)
2815 {
2816     *result = !!m_page->backForwardList()->forwardItem();
2817     return S_OK;
2818 }
2819
2820 HRESULT STDMETHODCALLTYPE WebView::goForward(
2821         /* [in] */ IUnknown* /*sender*/)
2822 {
2823     ASSERT_NOT_REACHED();
2824     return E_NOTIMPL;
2825 }
2826
2827 #define MinimumTextSizeMultiplier   0.5f
2828 #define MaximumTextSizeMultiplier   3.0f
2829 #define TextSizeMultiplierRatio     1.2f
2830
2831 HRESULT STDMETHODCALLTYPE WebView::canMakeTextLarger(
2832         /* [in] */ IUnknown* /*sender*/,
2833         /* [retval][out] */ BOOL* result)
2834 {
2835     bool canGrowMore = m_textSizeMultiplier*TextSizeMultiplierRatio < MaximumTextSizeMultiplier;
2836     *result = canGrowMore ? TRUE : FALSE;
2837     return S_OK;
2838 }
2839
2840 HRESULT STDMETHODCALLTYPE WebView::makeTextLarger(
2841         /* [in] */ IUnknown* /*sender*/)
2842 {
2843     float newScale = m_textSizeMultiplier*TextSizeMultiplierRatio;
2844     bool canGrowMore = newScale < MaximumTextSizeMultiplier;
2845     if (!canGrowMore)
2846         return E_FAIL;
2847     return setTextSizeMultiplier(newScale);
2848
2849 }
2850
2851 HRESULT STDMETHODCALLTYPE WebView::canMakeTextSmaller(
2852         /* [in] */ IUnknown* /*sender*/,
2853         /* [retval][out] */ BOOL* result)
2854 {
2855     bool canShrinkMore = m_textSizeMultiplier/TextSizeMultiplierRatio > MinimumTextSizeMultiplier;
2856     *result = canShrinkMore ? TRUE : FALSE;
2857     return S_OK;
2858 }
2859
2860 HRESULT STDMETHODCALLTYPE WebView::makeTextSmaller(
2861         /* [in] */ IUnknown* /*sender*/)
2862 {
2863     float newScale = m_textSizeMultiplier/TextSizeMultiplierRatio;
2864     bool canShrinkMore = newScale > MinimumTextSizeMultiplier;
2865     if (!canShrinkMore)
2866         return E_FAIL;
2867     return setTextSizeMultiplier(newScale);
2868 }
2869
2870 HRESULT STDMETHODCALLTYPE WebView::canMakeTextStandardSize(
2871     /* [in] */ IUnknown* /*sender*/,
2872     /* [retval][out] */ BOOL* result)
2873 {
2874     bool notAlreadyStandard = m_textSizeMultiplier != 1.0f;
2875     *result = notAlreadyStandard ? TRUE : FALSE;
2876     return S_OK;
2877 }
2878
2879 HRESULT STDMETHODCALLTYPE WebView::makeTextStandardSize(
2880     /* [in] */ IUnknown* /*sender*/)
2881 {
2882     bool notAlreadyStandard = m_textSizeMultiplier != 1.0f;
2883     if (notAlreadyStandard)
2884         return setTextSizeMultiplier(1.0f);
2885     return S_OK;
2886 }
2887
2888 HRESULT STDMETHODCALLTYPE WebView::toggleContinuousSpellChecking(
2889     /* [in] */ IUnknown* /*sender*/)
2890 {
2891     HRESULT hr;
2892     BOOL enabled;
2893     if (FAILED(hr = isContinuousSpellCheckingEnabled(&enabled)))
2894         return hr;
2895     return setContinuousSpellCheckingEnabled(enabled ? FALSE : TRUE);
2896 }
2897
2898 HRESULT STDMETHODCALLTYPE WebView::toggleSmartInsertDelete(
2899     /* [in] */ IUnknown* /*sender*/)
2900 {
2901     BOOL enabled = FALSE;
2902     HRESULT hr = smartInsertDeleteEnabled(&enabled);
2903     if (FAILED(hr))
2904         return hr;
2905
2906     return setSmartInsertDeleteEnabled(enabled ? FALSE : TRUE);
2907 }
2908
2909 HRESULT STDMETHODCALLTYPE WebView::toggleGrammarChecking(
2910     /* [in] */ IUnknown* /*sender*/)
2911 {
2912     BOOL enabled;
2913     HRESULT hr = isGrammarCheckingEnabled(&enabled);
2914     if (FAILED(hr))
2915         return hr;
2916
2917     return setGrammarCheckingEnabled(enabled ? FALSE : TRUE);
2918 }
2919
2920 // IWebViewCSS -----------------------------------------------------------------
2921
2922 HRESULT STDMETHODCALLTYPE WebView::computedStyleForElement(
2923         /* [in] */ IDOMElement* /*element*/,
2924         /* [in] */ BSTR /*pseudoElement*/,
2925         /* [retval][out] */ IDOMCSSStyleDeclaration** /*style*/)
2926 {
2927     ASSERT_NOT_REACHED();
2928     return E_NOTIMPL;
2929 }
2930
2931 // IWebViewEditing -------------------------------------------------------------
2932
2933 HRESULT STDMETHODCALLTYPE WebView::editableDOMRangeForPoint(
2934         /* [in] */ LPPOINT /*point*/,
2935         /* [retval][out] */ IDOMRange** /*range*/)
2936 {
2937     ASSERT_NOT_REACHED();
2938     return E_NOTIMPL;
2939 }
2940
2941 HRESULT STDMETHODCALLTYPE WebView::setSelectedDOMRange(
2942         /* [in] */ IDOMRange* /*range*/,
2943         /* [in] */ WebSelectionAffinity /*affinity*/)
2944 {
2945     ASSERT_NOT_REACHED();
2946     return E_NOTIMPL;
2947 }
2948
2949 HRESULT STDMETHODCALLTYPE WebView::selectedDOMRange(
2950         /* [retval][out] */ IDOMRange** /*range*/)
2951 {
2952     ASSERT_NOT_REACHED();
2953     return E_NOTIMPL;
2954 }
2955
2956 HRESULT STDMETHODCALLTYPE WebView::selectionAffinity(
2957         /* [retval][out][retval][out] */ WebSelectionAffinity* /*affinity*/)
2958 {
2959     ASSERT_NOT_REACHED();
2960     return E_NOTIMPL;
2961 }
2962
2963 HRESULT STDMETHODCALLTYPE WebView::setEditable(
2964         /* [in] */ BOOL /*flag*/)
2965 {
2966     ASSERT_NOT_REACHED();
2967     return E_NOTIMPL;
2968 }
2969
2970 HRESULT STDMETHODCALLTYPE WebView::isEditable(
2971         /* [retval][out] */ BOOL* /*isEditable*/)
2972 {
2973     ASSERT_NOT_REACHED();
2974     return E_NOTIMPL;
2975 }
2976
2977 HRESULT STDMETHODCALLTYPE WebView::setTypingStyle(
2978         /* [in] */ IDOMCSSStyleDeclaration* /*style*/)
2979 {
2980     ASSERT_NOT_REACHED();
2981     return E_NOTIMPL;
2982 }
2983
2984 HRESULT STDMETHODCALLTYPE WebView::typingStyle(
2985         /* [retval][out] */ IDOMCSSStyleDeclaration** /*style*/)
2986 {
2987     ASSERT_NOT_REACHED();
2988     return E_NOTIMPL;
2989 }
2990
2991 HRESULT STDMETHODCALLTYPE WebView::setSmartInsertDeleteEnabled(
2992         /* [in] */ BOOL flag)
2993 {
2994     m_smartInsertDeleteEnabled = !!flag;
2995     return S_OK;
2996 }
2997
2998 HRESULT STDMETHODCALLTYPE WebView::smartInsertDeleteEnabled(
2999         /* [retval][out] */ BOOL* enabled)
3000 {
3001     *enabled = m_smartInsertDeleteEnabled ? TRUE : FALSE;
3002     return S_OK;
3003 }
3004
3005 HRESULT STDMETHODCALLTYPE WebView::setContinuousSpellCheckingEnabled(
3006         /* [in] */ BOOL flag)
3007 {
3008     if (continuousSpellCheckingEnabled != !!flag) {
3009         continuousSpellCheckingEnabled = !!flag;
3010         COMPtr<IWebPreferences> prefs;
3011         if (SUCCEEDED(preferences(&prefs)))
3012             prefs->setContinuousSpellCheckingEnabled(flag);
3013     }
3014
3015     BOOL spellCheckingEnabled;
3016     if (SUCCEEDED(isContinuousSpellCheckingEnabled(&spellCheckingEnabled)) && spellCheckingEnabled)
3017         preflightSpellChecker();
3018     else
3019         m_mainFrame->unmarkAllMisspellings();
3020
3021     return S_OK;
3022 }
3023
3024 HRESULT STDMETHODCALLTYPE WebView::isContinuousSpellCheckingEnabled(
3025         /* [retval][out] */ BOOL* enabled)
3026 {
3027     *enabled = (continuousSpellCheckingEnabled && continuousCheckingAllowed()) ? TRUE : FALSE;
3028     return S_OK;
3029 }
3030
3031 HRESULT STDMETHODCALLTYPE WebView::spellCheckerDocumentTag(
3032         /* [retval][out] */ int* tag)
3033 {
3034     // we just use this as a flag to indicate that we've spell checked the document
3035     // and need to close the spell checker out when the view closes.
3036     *tag = 0;
3037     m_hasSpellCheckerDocumentTag = true;
3038     return S_OK;
3039 }
3040
3041 static COMPtr<IWebEditingDelegate> spellingDelegateForTimer;
3042
3043 static void preflightSpellCheckerNow()
3044 {
3045     spellingDelegateForTimer->preflightChosenSpellServer();
3046     spellingDelegateForTimer = 0;
3047 }
3048
3049 static void CALLBACK preflightSpellCheckerTimerCallback(HWND, UINT, UINT_PTR id, DWORD)
3050 {
3051     ::KillTimer(0, id);
3052     preflightSpellCheckerNow();
3053 }
3054
3055 void WebView::preflightSpellChecker()
3056 {
3057     // As AppKit does, we wish to delay tickling the shared spellchecker into existence on application launch.
3058     if (!m_editingDelegate)
3059         return;
3060
3061     BOOL exists;
3062     spellingDelegateForTimer = m_editingDelegate;
3063     if (SUCCEEDED(m_editingDelegate->sharedSpellCheckerExists(&exists)) && exists)
3064         preflightSpellCheckerNow();
3065     else
3066         ::SetTimer(0, 0, 2000, preflightSpellCheckerTimerCallback);
3067 }
3068
3069 bool WebView::continuousCheckingAllowed()
3070 {
3071     static bool allowContinuousSpellChecking = true;
3072     static bool readAllowContinuousSpellCheckingDefault = false;
3073     if (!readAllowContinuousSpellCheckingDefault) {
3074         COMPtr<IWebPreferences> prefs;
3075         if (SUCCEEDED(preferences(&prefs))) {
3076             BOOL allowed;
3077             prefs->allowContinuousSpellChecking(&allowed);
3078             allowContinuousSpellChecking = !!allowed;
3079         }
3080         readAllowContinuousSpellCheckingDefault = true;
3081     }
3082     return allowContinuousSpellChecking;
3083 }
3084
3085 HRESULT STDMETHODCALLTYPE WebView::undoManager(
3086         /* [retval][out] */ IWebUndoManager** /*manager*/)
3087 {
3088     ASSERT_NOT_REACHED();
3089     return E_NOTIMPL;
3090 }
3091
3092 HRESULT STDMETHODCALLTYPE WebView::setEditingDelegate(
3093         /* [in] */ IWebEditingDelegate* d)
3094 {
3095     m_editingDelegate = d;
3096     return S_OK;
3097 }
3098
3099 HRESULT STDMETHODCALLTYPE WebView::editingDelegate(
3100         /* [retval][out] */ IWebEditingDelegate** d)
3101 {
3102     if (!d) {
3103         ASSERT_NOT_REACHED();
3104         return E_POINTER;
3105     }
3106
3107     *d = m_editingDelegate.get();
3108     if (!*d)
3109         return E_FAIL;
3110
3111     (*d)->AddRef();
3112     return S_OK;
3113 }
3114
3115 HRESULT STDMETHODCALLTYPE WebView::styleDeclarationWithText(
3116         /* [in] */ BSTR /*text*/,
3117         /* [retval][out] */ IDOMCSSStyleDeclaration** /*style*/)
3118 {
3119     ASSERT_NOT_REACHED();
3120     return E_NOTIMPL;
3121 }
3122
3123 HRESULT STDMETHODCALLTYPE WebView::hasSelectedRange(
3124         /* [retval][out] */ BOOL* hasSelectedRange)
3125 {
3126     *hasSelectedRange = m_page->mainFrame()->selectionController()->isRange();
3127     return S_OK;
3128 }
3129
3130 HRESULT STDMETHODCALLTYPE WebView::cutEnabled(
3131         /* [retval][out] */ BOOL* enabled)
3132 {
3133     Editor* editor = m_page->focusController()->focusedOrMainFrame()->editor();
3134     *enabled = editor->canCut() || editor->canDHTMLCut();
3135     return S_OK;
3136 }
3137
3138 HRESULT STDMETHODCALLTYPE WebView::copyEnabled(
3139         /* [retval][out] */ BOOL* enabled)
3140 {
3141     Editor* editor = m_page->focusController()->focusedOrMainFrame()->editor();
3142     *enabled = editor->canCopy() || editor->canDHTMLCopy();
3143     return S_OK;
3144 }
3145
3146 HRESULT STDMETHODCALLTYPE WebView::pasteEnabled(
3147         /* [retval][out] */ BOOL* enabled)
3148 {
3149     Editor* editor = m_page->focusController()->focusedOrMainFrame()->editor();
3150     *enabled = editor->canPaste() || editor->canDHTMLPaste();
3151     return S_OK;
3152 }
3153
3154 HRESULT STDMETHODCALLTYPE WebView::deleteEnabled(
3155         /* [retval][out] */ BOOL* enabled)
3156 {
3157     *enabled = m_page->focusController()->focusedOrMainFrame()->editor()->canDelete();
3158     return S_OK;
3159 }
3160
3161 HRESULT STDMETHODCALLTYPE WebView::editingEnabled(
3162         /* [retval][out] */ BOOL* enabled)
3163 {
3164     *enabled = m_page->focusController()->focusedOrMainFrame()->editor()->canEdit();
3165     return S_OK;
3166 }
3167
3168 HRESULT STDMETHODCALLTYPE WebView::isGrammarCheckingEnabled(
3169     /* [retval][out] */ BOOL* enabled)
3170 {
3171     *enabled = grammarCheckingEnabled ? TRUE : FALSE;
3172     return S_OK;
3173 }
3174
3175 HRESULT STDMETHODCALLTYPE WebView::setGrammarCheckingEnabled(
3176     BOOL enabled)
3177 {
3178     if (grammarCheckingEnabled == !!enabled)
3179         return S_OK;
3180
3181     grammarCheckingEnabled = !!enabled;
3182     COMPtr<IWebPreferences> prefs;
3183     if (SUCCEEDED(preferences(&prefs)))
3184         prefs->setGrammarCheckingEnabled(enabled);
3185
3186     m_editingDelegate->updateGrammar();
3187
3188     // We call _preflightSpellChecker when turning continuous spell checking on, but we don't need to do that here
3189     // because grammar checking only occurs on code paths that already preflight spell checking appropriately.
3190
3191     BOOL grammarEnabled;
3192     if (SUCCEEDED(isGrammarCheckingEnabled(&grammarEnabled)) && !grammarEnabled)
3193         m_mainFrame->unmarkAllBadGrammar();
3194
3195     return S_OK;
3196 }
3197
3198 // IWebViewUndoableEditing -----------------------------------------------------
3199
3200 HRESULT STDMETHODCALLTYPE WebView::replaceSelectionWithNode(
3201         /* [in] */ IDOMNode* /*node*/)
3202 {
3203     ASSERT_NOT_REACHED();
3204     return E_NOTIMPL;
3205 }
3206
3207 HRESULT STDMETHODCALLTYPE WebView::replaceSelectionWithText(
3208         /* [in] */ BSTR text)
3209 {
3210     String textString(text, ::SysStringLen(text));
3211     Position start = m_page->mainFrame()->selectionController()->selection().start();
3212     m_page->focusController()->focusedOrMainFrame()->editor()->insertText(textString, 0);
3213     m_page->mainFrame()->selectionController()->setBase(start);
3214     return S_OK;
3215 }
3216
3217 HRESULT STDMETHODCALLTYPE WebView::replaceSelectionWithMarkupString(
3218         /* [in] */ BSTR /*markupString*/)
3219 {
3220     ASSERT_NOT_REACHED();
3221     return E_NOTIMPL;
3222 }
3223
3224 HRESULT STDMETHODCALLTYPE WebView::replaceSelectionWithArchive(
3225         /* [in] */ IWebArchive* /*archive*/)
3226 {
3227     ASSERT_NOT_REACHED();
3228     return E_NOTIMPL;
3229 }
3230
3231 HRESULT STDMETHODCALLTYPE WebView::deleteSelection( void)
3232 {
3233     m_page->focusController()->focusedOrMainFrame()->editor()->deleteSelectionWithSmartDelete();
3234     return S_OK;
3235 }
3236
3237 HRESULT STDMETHODCALLTYPE WebView::clearSelection( void)
3238 {
3239     m_page->focusController()->focusedOrMainFrame()->selectionController()->clear();
3240     return S_OK;
3241 }
3242
3243 HRESULT STDMETHODCALLTYPE WebView::applyStyle(
3244         /* [in] */ IDOMCSSStyleDeclaration* /*style*/)
3245 {
3246     ASSERT_NOT_REACHED();
3247     return E_NOTIMPL;
3248 }
3249
3250 // IWebViewEditingActions ------------------------------------------------------
3251
3252 HRESULT STDMETHODCALLTYPE WebView::copy(
3253         /* [in] */ IUnknown* /*sender*/)
3254 {
3255     m_page->focusController()->focusedOrMainFrame()->editor()->execCommand("Copy");
3256     return S_OK;
3257 }
3258
3259 HRESULT STDMETHODCALLTYPE WebView::cut(
3260         /* [in] */ IUnknown* /*sender*/)
3261 {
3262     m_page->focusController()->focusedOrMainFrame()->editor()->execCommand("Cut");
3263     return S_OK;
3264 }
3265
3266 HRESULT STDMETHODCALLTYPE WebView::paste(
3267         /* [in] */ IUnknown* /*sender*/)
3268 {
3269     m_page->focusController()->focusedOrMainFrame()->editor()->execCommand("Paste");
3270     return S_OK;
3271 }
3272
3273 HRESULT STDMETHODCALLTYPE WebView::copyURL(
3274         /* [in] */ BSTR url)
3275 {
3276     String temp(url, SysStringLen(url));
3277     m_page->focusController()->focusedOrMainFrame()->editor()->copyURL(KURL(temp.deprecatedString()), "");
3278     return S_OK;
3279 }
3280
3281
3282 HRESULT STDMETHODCALLTYPE WebView::copyFont(
3283         /* [in] */ IUnknown* /*sender*/)
3284 {
3285     ASSERT_NOT_REACHED();
3286     return E_NOTIMPL;
3287 }
3288
3289 HRESULT STDMETHODCALLTYPE WebView::pasteFont(
3290         /* [in] */ IUnknown* /*sender*/)
3291 {
3292     ASSERT_NOT_REACHED();
3293     return E_NOTIMPL;
3294 }
3295
3296 HRESULT STDMETHODCALLTYPE WebView::delete_(
3297         /* [in] */ IUnknown* /*sender*/)
3298 {
3299     m_page->focusController()->focusedOrMainFrame()->editor()->execCommand("Delete");
3300     return S_OK;
3301 }
3302
3303 HRESULT STDMETHODCALLTYPE WebView::pasteAsPlainText(
3304         /* [in] */ IUnknown* /*sender*/)
3305 {
3306     ASSERT_NOT_REACHED();
3307     return E_NOTIMPL;
3308 }
3309
3310 HRESULT STDMETHODCALLTYPE WebView::pasteAsRichText(
3311         /* [in] */ IUnknown* /*sender*/)
3312 {
3313     ASSERT_NOT_REACHED();
3314     return E_NOTIMPL;
3315 }
3316
3317 HRESULT STDMETHODCALLTYPE WebView::changeFont(
3318         /* [in] */ IUnknown* /*sender*/)
3319 {
3320     ASSERT_NOT_REACHED();
3321     return E_NOTIMPL;
3322 }
3323
3324 HRESULT STDMETHODCALLTYPE WebView::changeAttributes(
3325         /* [in] */ IUnknown* /*sender*/)
3326 {
3327     ASSERT_NOT_REACHED();
3328     return E_NOTIMPL;
3329 }
3330
3331 HRESULT STDMETHODCALLTYPE WebView::changeDocumentBackgroundColor(
3332         /* [in] */ IUnknown* /*sender*/)
3333 {
3334     ASSERT_NOT_REACHED();
3335     return E_NOTIMPL;
3336 }
3337
3338 HRESULT STDMETHODCALLTYPE WebView::changeColor(
3339         /* [in] */ IUnknown* /*sender*/)
3340 {
3341     ASSERT_NOT_REACHED();
3342     return E_NOTIMPL;
3343 }
3344
3345 HRESULT STDMETHODCALLTYPE WebView::alignCenter(
3346         /* [in] */ IUnknown* /*sender*/)
3347 {
3348     ASSERT_NOT_REACHED();
3349     return E_NOTIMPL;
3350 }
3351
3352 HRESULT STDMETHODCALLTYPE WebView::alignJustified(
3353         /* [in] */ IUnknown* /*sender*/)
3354 {
3355     ASSERT_NOT_REACHED();
3356     return E_NOTIMPL;
3357 }
3358
3359 HRESULT STDMETHODCALLTYPE WebView::alignLeft(
3360         /* [in] */ IUnknown* /*sender*/)
3361 {
3362     ASSERT_NOT_REACHED();
3363     return E_NOTIMPL;
3364 }
3365
3366 HRESULT STDMETHODCALLTYPE WebView::alignRight(
3367         /* [in] */ IUnknown* /*sender*/)
3368 {
3369     ASSERT_NOT_REACHED();
3370     return E_NOTIMPL;
3371 }
3372
3373 HRESULT STDMETHODCALLTYPE WebView::checkSpelling(
3374         /* [in] */ IUnknown* /*sender*/)
3375 {
3376     if (!m_editingDelegate) {
3377         LOG_ERROR("No NSSpellChecker");
3378         return E_FAIL;
3379     }
3380
3381     core(m_mainFrame)->editor()->advanceToNextMisspelling();
3382     return S_OK;
3383 }
3384
3385 HRESULT STDMETHODCALLTYPE WebView::showGuessPanel(
3386         /* [in] */ IUnknown* /*sender*/)
3387 {
3388     if (!m_editingDelegate) {
3389         LOG_ERROR("No NSSpellChecker");
3390         return E_FAIL;
3391     }
3392
3393     // Post-Tiger, this menu item is a show/hide toggle, to match AppKit. Leave Tiger behavior alone
3394     // to match rest of OS X.
3395     BOOL showing;
3396     if (SUCCEEDED(m_editingDelegate->spellingUIIsShowing(&showing)) && showing) {
3397         m_editingDelegate->showSpellingUI(FALSE);
3398     }
3399
3400     core(m_mainFrame)->editor()->advanceToNextMisspelling(true);
3401     m_editingDelegate->showSpellingUI(TRUE);
3402     return S_OK;
3403 }
3404
3405 HRESULT STDMETHODCALLTYPE WebView::performFindPanelAction(
3406         /* [in] */ IUnknown* /*sender*/)
3407 {
3408     ASSERT_NOT_REACHED();
3409     return E_NOTIMPL;
3410 }
3411
3412 HRESULT STDMETHODCALLTYPE WebView::startSpeaking(
3413         /* [in] */ IUnknown* /*sender*/)
3414 {
3415     ASSERT_NOT_REACHED();
3416     return E_NOTIMPL;
3417 }
3418
3419 HRESULT STDMETHODCALLTYPE WebView::stopSpeaking(
3420         /* [in] */ IUnknown* /*sender*/)
3421 {
3422     ASSERT_NOT_REACHED();
3423     return E_NOTIMPL;
3424 }
3425
3426 // IWebNotificationObserver -----------------------------------------------------------------
3427
3428 HRESULT STDMETHODCALLTYPE WebView::onNotify(
3429     /* [in] */ IWebNotification* notification)
3430 {
3431     BSTR nameBSTR;
3432     HRESULT hr = notification->name(&nameBSTR);
3433     if (FAILED(hr))
3434         return hr;
3435
3436     BString name;
3437     name.adoptBSTR(nameBSTR);
3438
3439     if (!_tcscmp(name, WebIconDatabase::iconDatabaseDidAddIconNotification()))
3440         return notifyDidAddIcon(notification);
3441
3442     COMPtr<IUnknown> unkPrefs;
3443     hr = notification->getObject(&unkPrefs);
3444     if (FAILED(hr))
3445         return hr;
3446
3447     COMPtr<IWebPreferences> preferences;
3448     hr = unkPrefs->QueryInterface(IID_IWebPreferences, (void**)&preferences);
3449     if (FAILED(hr))
3450         return hr;
3451
3452     hr = updateWebCoreSettingsFromPreferences(preferences.get());
3453
3454     return hr;
3455 }
3456
3457 // IWebViewPrivate ------------------------------------------------------------
3458
3459 HRESULT STDMETHODCALLTYPE WebView::setCustomDropTarget(
3460     /* [in] */ IDropTarget* dt)
3461 {
3462     ASSERT(::IsWindow(m_viewWindow));
3463     if (!dt)
3464         return E_POINTER;
3465     m_hasCustomDropTarget = true;
3466     revokeDragDrop();
3467     return ::RegisterDragDrop(m_viewWindow,dt);
3468 }
3469
3470 HRESULT STDMETHODCALLTYPE WebView::removeCustomDropTarget()
3471 {
3472     if (!m_hasCustomDropTarget)
3473         return S_OK;
3474     m_hasCustomDropTarget = false;
3475     revokeDragDrop();
3476     return registerDragDrop();
3477 }
3478
3479 HRESULT STDMETHODCALLTYPE WebView::setInViewSourceMode(
3480         /* [in] */ BOOL flag)
3481 {
3482     if (!m_mainFrame)
3483         return E_FAIL;
3484
3485     return m_mainFrame->setInViewSourceMode(flag);
3486 }
3487
3488 HRESULT STDMETHODCALLTYPE WebView::inViewSourceMode(
3489         /* [retval][out] */ BOOL* flag)
3490 {
3491     if (!m_mainFrame)
3492         return E_FAIL;
3493
3494     return m_mainFrame->inViewSourceMode(flag);
3495 }
3496
3497 HRESULT STDMETHODCALLTYPE WebView::viewWindow(
3498         /* [retval][out] */ OLE_HANDLE *window)
3499 {
3500     *window = (OLE_HANDLE)(ULONG64)m_viewWindow;
3501     return S_OK;
3502 }
3503
3504 HRESULT STDMETHODCALLTYPE WebView::setFormDelegate(
3505     /* [in] */ IWebFormDelegate *formDelegate)
3506 {
3507     m_formDelegate = formDelegate;
3508     return S_OK;
3509 }
3510
3511 HRESULT STDMETHODCALLTYPE WebView::formDelegate(
3512     /* [retval][out] */ IWebFormDelegate **formDelegate)
3513 {
3514     if (!m_formDelegate)
3515         return E_FAIL;
3516
3517     return m_formDelegate.copyRefTo(formDelegate);
3518 }
3519
3520 HRESULT STDMETHODCALLTYPE WebView::setFrameLoadDelegatePrivate(
3521     /* [in] */ IWebFrameLoadDelegatePrivate* d)
3522 {
3523     m_frameLoadDelegatePrivate = d;
3524     return S_OK;
3525 }
3526
3527 HRESULT STDMETHODCALLTYPE WebView::frameLoadDelegatePrivate(
3528     /* [out][retval] */ IWebFrameLoadDelegatePrivate** d)
3529 {
3530     if (!m_frameLoadDelegatePrivate)
3531         return E_FAIL;
3532
3533     return m_frameLoadDelegatePrivate.copyRefTo(d);
3534 }
3535
3536 HRESULT STDMETHODCALLTYPE WebView::scrollOffset(
3537     /* [retval][out] */ LPPOINT offset)
3538 {
3539     if (!offset)
3540         return E_POINTER;
3541     IntSize offsetIntSize = m_page->mainFrame()->view()->scrollOffset();
3542     offset->x = offsetIntSize.width();
3543     offset->y = offsetIntSize.height();
3544     return S_OK;
3545 }
3546
3547 HRESULT STDMETHODCALLTYPE WebView::scrollBy(
3548     /* [in] */ LPPOINT offset)
3549 {
3550     if (!offset)
3551         return E_POINTER;
3552     m_page->mainFrame()->view()->scrollBy(offset->x, offset->y);
3553     return S_OK;
3554 }
3555
3556 HRESULT STDMETHODCALLTYPE WebView::visibleContentRect(
3557     /* [retval][out] */ LPRECT rect)
3558 {
3559     if (!rect)
3560         return E_POINTER;
3561     FloatRect visibleContent = m_page->mainFrame()->view()->visibleContentRect();
3562     rect->left = (LONG) visibleContent.x();
3563     rect->top = (LONG) visibleContent.y();
3564     rect->right = (LONG) visibleContent.right();
3565     rect->bottom = (LONG) visibleContent.bottom();
3566     return S_OK;
3567 }
3568
3569 static DWORD dragOperationToDragCursor(DragOperation op) {
3570     DWORD res = DROPEFFECT_NONE;
3571     if (op & DragOperationCopy)
3572         res = DROPEFFECT_COPY;
3573     else if (op & DragOperationLink)
3574         res = DROPEFFECT_LINK;
3575     else if (op & DragOperationMove)
3576         res = DROPEFFECT_MOVE;
3577     else if (op & DragOperationGeneric)
3578         res = DROPEFFECT_MOVE; //This appears to be the Firefox behaviour
3579     return res;
3580 }
3581
3582 static DragOperation keyStateToDragOperation(DWORD) {
3583     //FIXME: This is currently very simple, it may need to actually
3584     //work out an appropriate DragOperation in future -- however this
3585     //behaviour appears to match FireFox
3586     return (DragOperation)(DragOperationCopy | DragOperationLink);
3587 }
3588
3589 HRESULT STDMETHODCALLTYPE WebView::DragEnter(
3590         IDataObject* pDataObject, DWORD grfKeyState, POINTL pt, DWORD* pdwEffect)
3591 {
3592     m_dragData = 0;
3593
3594     if (m_dropTargetHelper)
3595         m_dropTargetHelper->DragEnter(m_viewWindow, pDataObject, (POINT*)&pt, *pdwEffect);
3596
3597     POINTL localpt = pt;
3598     ::ScreenToClient(m_viewWindow, (LPPOINT)&localpt);
3599     DragData data(pDataObject, IntPoint(localpt.x, localpt.y),
3600         IntPoint(pt.x, pt.y), keyStateToDragOperation(grfKeyState));
3601     *pdwEffect = dragOperationToDragCursor(m_page->dragController()->dragEntered(&data));
3602
3603     m_dragData = pDataObject;
3604
3605     return S_OK;
3606 }
3607
3608 HRESULT STDMETHODCALLTYPE WebView::DragOver(
3609         DWORD grfKeyState, POINTL pt, DWORD* pdwEffect)
3610 {
3611     if (m_dropTargetHelper)
3612         m_dropTargetHelper->DragOver((POINT*)&pt, *pdwEffect);
3613
3614     if (m_dragData) {
3615         POINTL localpt = pt;
3616         ::ScreenToClient(m_viewWindow, (LPPOINT)&localpt);
3617         DragData data(m_dragData.get(), IntPoint(localpt.x, localpt.y),
3618             IntPoint(pt.x, pt.y), keyStateToDragOperation(grfKeyState));
3619         *pdwEffect = dragOperationToDragCursor(m_page->dragController()->dragUpdated(&data));
3620     } else
3621         *pdwEffect = DROPEFFECT_NONE;
3622
3623     return S_OK;
3624 }
3625
3626 HRESULT STDMETHODCALLTYPE WebView::DragLeave()
3627 {
3628     if (m_dropTargetHelper)
3629         m_dropTargetHelper->DragLeave();
3630
3631     if (m_dragData) {
3632         DragData data(m_dragData.get(), IntPoint(), IntPoint(),
3633             DragOperationNone);
3634         m_page->dragController()->dragExited(&data);
3635         m_dragData = 0;
3636     }
3637     return S_OK;
3638 }
3639
3640 HRESULT STDMETHODCALLTYPE WebView::Drop(
3641         IDataObject* pDataObject, DWORD grfKeyState, POINTL pt, DWORD* pdwEffect)
3642 {
3643     if (m_dropTargetHelper)
3644         m_dropTargetHelper->Drop(pDataObject, (POINT*)&pt, *pdwEffect);
3645
3646     m_dragData = 0;
3647     *pdwEffect = DROPEFFECT_NONE;
3648     POINTL localpt = pt;
3649     ::ScreenToClient(m_viewWindow, (LPPOINT)&localpt);
3650     DragData data(pDataObject, IntPoint(localpt.x, localpt.y),
3651         IntPoint(pt.x, pt.y), keyStateToDragOperation(grfKeyState));
3652     m_page->dragController()->performDrag(&data);
3653     return S_OK;
3654 }
3655
3656 HRESULT STDMETHODCALLTYPE WebView::canHandleRequest(
3657     IWebURLRequest *request,
3658     BOOL *result)
3659 {
3660     COMPtr<WebMutableURLRequest> requestImpl;
3661
3662     HRESULT hr = request->QueryInterface(CLSID_WebMutableURLRequest, (void**)&requestImpl);
3663     if (FAILED(hr))
3664         return hr;
3665
3666     *result = !!canHandleRequest(requestImpl->resourceRequest());
3667     return S_OK;
3668 }
3669
3670 HRESULT STDMETHODCALLTYPE WebView::clearFocusNode()
3671 {
3672     if (m_page && m_page->focusController())
3673         m_page->focusController()->setFocusedNode(0, 0);
3674     return S_OK;
3675 }
3676
3677 HRESULT STDMETHODCALLTYPE WebView::setTabKeyCyclesThroughElements(
3678     /* [in] */ BOOL cycles)
3679 {
3680     if (m_page)
3681         m_page->setTabKeyCyclesThroughElements(!!cycles);
3682
3683     return S_OK;
3684 }
3685
3686 HRESULT STDMETHODCALLTYPE WebView::tabKeyCyclesThroughElements(
3687     /* [retval][out] */ BOOL* result)
3688 {
3689     if (!result) {
3690         ASSERT_NOT_REACHED();
3691         return E_POINTER;
3692     }
3693
3694     *result = m_page && m_page->tabKeyCyclesThroughElements() ? TRUE : FALSE;
3695     return S_OK;
3696 }
3697
3698 HRESULT STDMETHODCALLTYPE WebView::setAllowSiteSpecificHacks(
3699     /* [in] */ BOOL allow)
3700 {
3701     s_allowSiteSpecificHacks = !!allow;
3702     return S_OK;
3703 }
3704
3705 HRESULT STDMETHODCALLTYPE WebView::addAdditionalPluginPath(
3706         /* [in] */ BSTR path)
3707 {
3708     PluginDatabaseWin::installedPlugins()->addExtraPluginPath(String(path, SysStringLen(path)));
3709     return S_OK;
3710 }
3711
3712 HRESULT STDMETHODCALLTYPE WebView::loadBackForwardListFromOtherView(
3713     /* [in] */ IWebView* otherView)
3714 {
3715     if (!m_page)
3716         return E_FAIL;
3717
3718     // It turns out the right combination of behavior is done with the back/forward load
3719     // type.  (See behavior matrix at the top of WebFramePrivate.)  So we copy all the items
3720     // in the back forward list, and go to the current one.
3721     BackForwardList* backForwardList = m_page->backForwardList();
3722     ASSERT(!backForwardList->currentItem()); // destination list should be empty
3723
3724     COMPtr<WebView> otherWebView;
3725     if (FAILED(otherView->QueryInterface(CLSID_WebView, (void**)&otherWebView)))
3726         return E_FAIL;
3727     BackForwardList* otherBackForwardList = otherWebView->m_page->backForwardList();
3728     if (!otherBackForwardList->currentItem())
3729         return S_OK; // empty back forward list, bail
3730
3731     HistoryItem* newItemToGoTo = 0;
3732
3733     int lastItemIndex = otherBackForwardList->forwardListCount();
3734     for (int i = -otherBackForwardList->backListCount(); i <= lastItemIndex; ++i) {
3735         if (!i) {
3736             // If this item is showing , save away its current scroll and form state,
3737             // since that might have changed since loading and it is normally not saved
3738             // until we leave that page.
3739             otherWebView->m_page->mainFrame()->loader()->saveDocumentAndScrollState();
3740         }
3741         RefPtr<HistoryItem> newItem = otherBackForwardList->itemAtIndex(i)->copy();
3742         if (!i)
3743             newItemToGoTo = newItem.get();
3744         backForwardList->addItem(newItem.release());
3745     }
3746