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