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