Reviewed by Kevin Ollivier.
[WebKit.git] / WebKit / wx / WebKitSupport / FrameLoaderClientWx.cpp
1 /*
2  * Copyright (C) 2007 Kevin Ollivier <kevino@theolliviers.com>
3  *
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
16  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
18  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
19  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
22  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
23  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26  */
27  
28 #include "config.h"
29 #include "FrameLoaderClientWx.h"
30
31 #include <JavaScriptCore/JavaScript.h>
32 #include <JavaScriptCore/APICast.h>
33
34 #include "DocumentLoader.h"
35 #include "Frame.h"
36 #include "FrameLoaderTypes.h"
37 #include "FrameView.h"
38 #include "FrameTree.h"
39 #include "HTMLFormElement.h"
40 #include "HTMLFrameOwnerElement.h"
41 #include "NotImplemented.h"
42 #include "Page.h"
43 #include "PlatformString.h"
44 #include "ProgressTracker.h"
45 #include "RenderPart.h"
46 #include "ResourceError.h"
47 #include "ResourceResponse.h"
48 #include "ScriptController.h"
49
50 #include <stdio.h>
51
52 #include "WebFrame.h"
53 #include "WebView.h"
54 #include "WebViewPrivate.h"
55
56 namespace WebCore {
57
58 inline int wxNavTypeFromWebNavType(NavigationType type){
59     if (type == NavigationTypeLinkClicked)
60         return wxWEBVIEW_NAV_LINK_CLICKED;
61     
62     if (type == NavigationTypeFormSubmitted)
63         return wxWEBVIEW_NAV_FORM_SUBMITTED;
64         
65     if (type == NavigationTypeBackForward)
66         return wxWEBVIEW_NAV_BACK_NEXT;
67         
68     if (type == NavigationTypeReload)
69         return wxWEBVIEW_NAV_RELOAD;
70         
71     if (type == NavigationTypeFormResubmitted)
72         return wxWEBVIEW_NAV_FORM_RESUBMITTED;
73         
74     return wxWEBVIEW_NAV_OTHER;
75 }
76
77 FrameLoaderClientWx::FrameLoaderClientWx()
78     : m_frame(0)
79 {
80 }
81
82
83 FrameLoaderClientWx::~FrameLoaderClientWx()
84 {
85 }
86
87 void FrameLoaderClientWx::setFrame(Frame *frame)
88 {
89     m_frame = frame;
90 }
91
92 void FrameLoaderClientWx::setWebView(wxWebView *webview)
93 {
94     m_webView = webview;
95 }
96
97 void FrameLoaderClientWx::detachFrameLoader()
98 {
99     m_frame = 0;
100 }
101
102 bool FrameLoaderClientWx::hasWebView() const
103 {
104     return m_webView != NULL;
105 }
106
107 bool FrameLoaderClientWx::hasBackForwardList() const
108 {
109     notImplemented();
110     return true;
111 }
112
113
114 void FrameLoaderClientWx::resetBackForwardList()
115 {
116     notImplemented();
117 }
118
119
120 bool FrameLoaderClientWx::provisionalItemIsTarget() const
121 {
122     notImplemented();
123     return false;
124 }
125
126 void FrameLoaderClientWx::makeRepresentation(DocumentLoader*)
127 {
128     notImplemented();
129 }
130
131
132 void FrameLoaderClientWx::forceLayout()
133 {
134     notImplemented();
135 }
136
137
138 void FrameLoaderClientWx::forceLayoutForNonHTML()
139 {
140     notImplemented();
141 }
142
143
144 void FrameLoaderClientWx::updateHistoryForCommit()
145 {
146     notImplemented();
147 }
148
149
150 void FrameLoaderClientWx::updateHistoryForBackForwardNavigation()
151 {
152     notImplemented();
153 }
154
155
156 void FrameLoaderClientWx::updateHistoryForReload()
157 {
158     notImplemented();
159 }
160
161
162 void FrameLoaderClientWx::updateHistoryForStandardLoad()
163 {
164     notImplemented();
165 }
166
167
168 void FrameLoaderClientWx::updateHistoryForInternalLoad()
169 {
170     notImplemented();
171 }
172
173
174 void FrameLoaderClientWx::updateHistoryAfterClientRedirect()
175 {
176     notImplemented();
177 }
178
179
180 void FrameLoaderClientWx::setCopiesOnScroll()
181 {
182     // apparently mac specific
183     notImplemented();
184 }
185
186
187 LoadErrorResetToken* FrameLoaderClientWx::tokenForLoadErrorReset()
188 {
189     notImplemented();
190     return 0;
191 }
192
193
194 void FrameLoaderClientWx::resetAfterLoadError(LoadErrorResetToken*)
195 {
196     notImplemented();
197 }
198
199
200 void FrameLoaderClientWx::doNotResetAfterLoadError(LoadErrorResetToken*)
201 {
202     notImplemented();
203 }
204
205
206 void FrameLoaderClientWx::willCloseDocument()
207 {
208     notImplemented();
209 }
210
211
212 void FrameLoaderClientWx::detachedFromParent2()
213 {
214     notImplemented();
215 }
216
217
218 void FrameLoaderClientWx::detachedFromParent3()
219 {
220     notImplemented();
221 }
222
223 void FrameLoaderClientWx::dispatchDidHandleOnloadEvents()
224 {
225     if (m_webView) {
226         wxWebViewLoadEvent wkEvent(m_webView);
227         wkEvent.SetState(wxWEBVIEW_LOAD_ONLOAD_HANDLED);
228         wkEvent.SetURL(m_frame->loader()->documentLoader()->request().url().string());
229         m_webView->GetEventHandler()->ProcessEvent(wkEvent);
230     }
231 }
232
233
234 void FrameLoaderClientWx::dispatchDidReceiveServerRedirectForProvisionalLoad()
235 {
236     notImplemented();
237 }
238
239
240 void FrameLoaderClientWx::dispatchDidCancelClientRedirect()
241 {
242     notImplemented();
243 }
244
245
246 void FrameLoaderClientWx::dispatchWillPerformClientRedirect(const KURL&,
247                                                             double interval,
248                                                             double fireDate)
249 {
250     notImplemented();
251 }
252
253
254 void FrameLoaderClientWx::dispatchDidChangeLocationWithinPage()
255 {
256     notImplemented();
257 }
258
259
260 void FrameLoaderClientWx::dispatchWillClose()
261 {
262     notImplemented();
263 }
264
265
266 void FrameLoaderClientWx::dispatchDidStartProvisionalLoad()
267 {
268     if (m_webView) {
269         wxWebViewLoadEvent wkEvent(m_webView);
270         wkEvent.SetState(wxWEBVIEW_LOAD_NEGOTIATING);
271         wkEvent.SetURL(m_frame->loader()->provisionalDocumentLoader()->request().url().string());
272         m_webView->GetEventHandler()->ProcessEvent(wkEvent);
273     }
274 }
275
276
277 void FrameLoaderClientWx::dispatchDidReceiveTitle(const String& title)
278 {
279     if (m_webView) {
280         m_webView->SetPageTitle(title);
281         wxWebViewReceivedTitleEvent wkEvent(m_webView);
282         wkEvent.SetTitle(title);
283         m_webView->GetEventHandler()->ProcessEvent(wkEvent);
284     }
285 }
286
287
288 void FrameLoaderClientWx::dispatchDidCommitLoad()
289 {
290     if (m_webView) {
291         wxWebViewLoadEvent wkEvent(m_webView);
292         wkEvent.SetState(wxWEBVIEW_LOAD_TRANSFERRING);
293         wkEvent.SetURL(m_frame->loader()->documentLoader()->request().url().string());
294         m_webView->GetEventHandler()->ProcessEvent(wkEvent);
295     }
296 }
297
298 void FrameLoaderClientWx::dispatchDidFinishDocumentLoad()
299 {
300     if (m_webView) {
301         wxWebViewLoadEvent wkEvent(m_webView);
302         wkEvent.SetState(wxWEBVIEW_LOAD_DOC_COMPLETED);
303         wkEvent.SetURL(m_frame->loader()->url().string());
304         m_webView->GetEventHandler()->ProcessEvent(wkEvent);
305     }
306 }
307
308 void FrameLoaderClientWx::dispatchDidFinishLoad()
309 {
310     notImplemented();
311 }
312
313
314 void FrameLoaderClientWx::dispatchDidFirstLayout()
315 {
316     notImplemented();
317 }
318
319 void FrameLoaderClientWx::dispatchDidFirstVisuallyNonEmptyLayout()
320 {
321     notImplemented();
322 }
323
324 void FrameLoaderClientWx::dispatchShow()
325 {
326     notImplemented();
327 }
328
329
330 void FrameLoaderClientWx::cancelPolicyCheck()
331 {
332     notImplemented();
333 }
334
335
336 void FrameLoaderClientWx::dispatchWillSubmitForm(FramePolicyFunction function,
337                                                  PassRefPtr<FormState>)
338 {
339     // FIXME: Send an event to allow for alerts and cancellation
340     if (!m_frame)
341         return;
342     (m_frame->loader()->*function)(PolicyUse);
343 }
344
345
346 void FrameLoaderClientWx::dispatchDidLoadMainResource(DocumentLoader*)
347 {
348     notImplemented();
349 }
350
351
352 void FrameLoaderClientWx::revertToProvisionalState(DocumentLoader*)
353 {
354     notImplemented();
355 }
356
357 void FrameLoaderClientWx::postProgressStartedNotification()
358 {
359     notImplemented();
360 }
361
362 void FrameLoaderClientWx::postProgressEstimateChangedNotification()
363 {
364     notImplemented();
365 }
366
367 void FrameLoaderClientWx::postProgressFinishedNotification()
368 {
369     if (m_webView) {
370         wxWebViewLoadEvent wkEvent(m_webView);
371         wkEvent.SetState(wxWEBVIEW_LOAD_DL_COMPLETED);
372         wkEvent.SetURL(m_frame->loader()->url().string());
373         m_webView->GetEventHandler()->ProcessEvent(wkEvent);
374     }
375 }
376
377 void FrameLoaderClientWx::progressStarted()
378 {
379     notImplemented();
380 }
381
382
383 void FrameLoaderClientWx::progressCompleted()
384 {
385     notImplemented();
386 }
387
388
389 void FrameLoaderClientWx::setMainFrameDocumentReady(bool b)
390 {
391     notImplemented();
392     // this is only interesting once we provide an external API for the DOM
393 }
394
395
396 void FrameLoaderClientWx::willChangeTitle(DocumentLoader*)
397 {
398     notImplemented();
399 }
400
401
402 void FrameLoaderClientWx::didChangeTitle(DocumentLoader *l)
403 {
404     setTitle(l->title(), l->url());
405 }
406
407
408 void FrameLoaderClientWx::finishedLoading(DocumentLoader*)
409 {
410     notImplemented();
411 }
412
413
414 bool FrameLoaderClientWx::canShowMIMEType(const String& MIMEType) const
415 {
416     notImplemented();
417     return true;
418 }
419
420
421 bool FrameLoaderClientWx::representationExistsForURLScheme(const String& URLScheme) const
422 {
423     notImplemented();
424     return false;
425 }
426
427
428 String FrameLoaderClientWx::generatedMIMETypeForURLScheme(const String& URLScheme) const
429 {
430     notImplemented();
431     return String();
432 }
433
434
435 void FrameLoaderClientWx::frameLoadCompleted()
436 {
437     notImplemented();
438 }
439
440 void FrameLoaderClientWx::saveViewStateToItem(HistoryItem*)
441 {
442     notImplemented();
443 }
444
445 void FrameLoaderClientWx::restoreViewState()
446 {
447     notImplemented();
448 }
449         
450 void FrameLoaderClientWx::restoreScrollPositionAndViewState()
451 {
452     notImplemented();
453 }
454
455
456 void FrameLoaderClientWx::provisionalLoadStarted()
457 {
458     notImplemented();
459 }
460
461
462 bool FrameLoaderClientWx::shouldTreatURLAsSameAsCurrent(const KURL&) const
463 {
464     notImplemented();
465     return false;
466 }
467
468
469 void FrameLoaderClientWx::addHistoryItemForFragmentScroll()
470 {
471     notImplemented();
472 }
473
474
475 void FrameLoaderClientWx::didFinishLoad()
476 {
477     notImplemented();
478 }
479
480
481 void FrameLoaderClientWx::prepareForDataSourceReplacement()
482 {
483     notImplemented();
484 }
485
486
487 void FrameLoaderClientWx::setTitle(const String& title, const KURL&)
488 {
489     notImplemented();
490 }
491
492
493 String FrameLoaderClientWx::userAgent(const KURL&)
494 {
495     // FIXME: Use the new APIs introduced by the GTK port to fill in these values.
496     return String("Mozilla/5.0 (Macintosh; U; Intel Mac OS X; en) AppleWebKit/418.9.1 (KHTML, like Gecko) Safari/419.3");
497 }
498
499 void FrameLoaderClientWx::dispatchDidReceiveIcon()
500 {
501     notImplemented();
502 }
503
504 void FrameLoaderClientWx::frameLoaderDestroyed()
505 {
506     m_frame = 0;
507     delete this;
508 }
509
510 bool FrameLoaderClientWx::canHandleRequest(const WebCore::ResourceRequest&) const
511 {
512     notImplemented();
513     return true;
514 }
515
516 void FrameLoaderClientWx::partClearedInBegin()
517 {
518     notImplemented();
519 }
520
521 void FrameLoaderClientWx::updateGlobalHistory()
522 {
523     notImplemented();
524 }
525
526 void FrameLoaderClientWx::updateGlobalHistoryRedirectLinks()
527 {
528     notImplemented();
529 }
530
531 bool FrameLoaderClientWx::shouldGoToHistoryItem(WebCore::HistoryItem*) const
532 {
533     notImplemented();
534     return true;
535 }
536
537 void FrameLoaderClientWx::saveScrollPositionAndViewStateToItem(WebCore::HistoryItem*)
538 {
539     notImplemented();
540 }
541
542 bool FrameLoaderClientWx::canCachePage() const
543 {
544     return false;
545 }
546
547 void FrameLoaderClientWx::setMainDocumentError(WebCore::DocumentLoader*, const WebCore::ResourceError&)
548 {
549     notImplemented();
550 }
551
552 void FrameLoaderClientWx::committedLoad(WebCore::DocumentLoader* loader, const char* data, int length)
553 {
554     if (!m_frame)
555         return;
556     FrameLoader* fl = loader->frameLoader();
557     fl->setEncoding(m_response.textEncodingName(), false);
558     fl->addData(data, length);
559 }
560
561 WebCore::ResourceError FrameLoaderClientWx::cancelledError(const WebCore::ResourceRequest&)
562 {
563     notImplemented();
564     return ResourceError();
565 }
566
567 WebCore::ResourceError FrameLoaderClientWx::blockedError(const ResourceRequest&)
568 {
569     notImplemented();
570     return ResourceError();
571 }
572
573 WebCore::ResourceError FrameLoaderClientWx::cannotShowURLError(const WebCore::ResourceRequest&)
574 {
575     notImplemented();
576     return ResourceError();
577 }
578
579 WebCore::ResourceError FrameLoaderClientWx::interruptForPolicyChangeError(const WebCore::ResourceRequest&)
580 {
581     notImplemented();
582     return ResourceError();
583 }
584
585 WebCore::ResourceError FrameLoaderClientWx::cannotShowMIMETypeError(const WebCore::ResourceResponse&)
586 {
587     notImplemented();
588     return ResourceError();
589 }
590
591 WebCore::ResourceError FrameLoaderClientWx::fileDoesNotExistError(const WebCore::ResourceResponse&)
592 {
593     notImplemented();
594     return ResourceError();
595 }
596
597 bool FrameLoaderClientWx::shouldFallBack(const WebCore::ResourceError& error)
598 {
599     notImplemented();
600     return false;
601 }
602
603 WTF::PassRefPtr<DocumentLoader> FrameLoaderClientWx::createDocumentLoader(const ResourceRequest& request, const SubstituteData& substituteData)
604 {
605     return DocumentLoader::create(request, substituteData);
606 }
607
608 void FrameLoaderClientWx::download(ResourceHandle*, const ResourceRequest&, const ResourceRequest&, const ResourceResponse&)
609 {
610     notImplemented();
611 }
612
613 void FrameLoaderClientWx::assignIdentifierToInitialRequest(unsigned long identifier, DocumentLoader*, const ResourceRequest&)
614 {
615     notImplemented();   
616 }
617
618 void FrameLoaderClientWx::dispatchWillSendRequest(DocumentLoader*, unsigned long, ResourceRequest& request, const ResourceResponse& response)
619 {
620     notImplemented();
621 }
622
623 bool FrameLoaderClientWx::shouldUseCredentialStorage(DocumentLoader*, unsigned long)
624 {
625     notImplemented();
626     return false;
627 }
628
629 void FrameLoaderClientWx::dispatchDidReceiveAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&)
630 {
631     notImplemented();
632 }
633
634 void FrameLoaderClientWx::dispatchDidCancelAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&)
635 {
636     notImplemented();
637 }
638
639 void FrameLoaderClientWx::dispatchDidReceiveResponse(DocumentLoader* loader, unsigned long id, const ResourceResponse& response)
640 {
641     notImplemented();
642     m_response = response;
643     m_firstData = true;
644 }
645
646 void FrameLoaderClientWx::dispatchDidReceiveContentLength(DocumentLoader* loader, unsigned long id, int length)
647 {
648     notImplemented();
649 }
650
651 void FrameLoaderClientWx::dispatchDidFinishLoading(DocumentLoader*, unsigned long)
652 {
653     notImplemented();
654 }
655
656 void FrameLoaderClientWx::dispatchDidFailLoading(DocumentLoader*, unsigned long, const ResourceError&)
657 {
658     notImplemented();
659 }
660
661 bool FrameLoaderClientWx::dispatchDidLoadResourceFromMemoryCache(DocumentLoader*, const ResourceRequest&, const ResourceResponse&, int)
662 {
663     notImplemented();
664     return false;
665 }
666
667 void FrameLoaderClientWx::dispatchDidFailProvisionalLoad(const ResourceError&)
668 {
669     notImplemented();
670 }
671
672 void FrameLoaderClientWx::dispatchDidFailLoad(const ResourceError&)
673 {
674     notImplemented();
675 }
676
677 Frame* FrameLoaderClientWx::dispatchCreatePage()
678 {
679     notImplemented();
680     return false;
681 }
682
683 void FrameLoaderClientWx::dispatchDecidePolicyForMIMEType(FramePolicyFunction function, const String& mimetype, const ResourceRequest& request)
684 {
685     if (!m_frame)
686         return;
687     
688     notImplemented();
689     (m_frame->loader()->*function)(PolicyUse);
690 }
691
692 void FrameLoaderClientWx::dispatchDecidePolicyForNewWindowAction(FramePolicyFunction function, const NavigationAction&, const ResourceRequest&, PassRefPtr<FormState>, const String&)
693 {
694     if (!m_frame)
695         return;
696
697     notImplemented();
698     (m_frame->loader()->*function)(PolicyUse);
699 }
700
701 void FrameLoaderClientWx::dispatchDecidePolicyForNavigationAction(FramePolicyFunction function, const NavigationAction& action, const ResourceRequest& request, PassRefPtr<FormState>)
702 {
703     if (!m_frame)
704         return;
705         
706     if (m_webView) {
707         wxWebViewBeforeLoadEvent wkEvent(m_webView);
708         wkEvent.SetNavigationType(wxNavTypeFromWebNavType(action.type()));
709         wkEvent.SetURL(request.url().string());
710         
711         m_webView->GetEventHandler()->ProcessEvent(wkEvent);
712         if (wkEvent.IsCancelled())
713             (m_frame->loader()->*function)(PolicyIgnore);
714         else
715             (m_frame->loader()->*function)(PolicyUse);
716         
717     }
718 }
719
720 void FrameLoaderClientWx::dispatchUnableToImplementPolicy(const ResourceError&)
721 {
722     notImplemented();
723 }
724
725 void FrameLoaderClientWx::startDownload(const ResourceRequest&)
726 {
727     notImplemented();
728 }
729
730 PassRefPtr<Frame> FrameLoaderClientWx::createFrame(const KURL& url, const String& name, HTMLFrameOwnerElement* ownerElement,
731                                    const String& referrer, bool allowsScrolling, int marginWidth, int marginHeight)
732 {
733 /*
734     FIXME: Temporarily disabling code for loading subframes. While most 
735     (i)frames load and are destroyed properly, the iframe created by
736     google.com in its new homepage does not get destroyed when 
737     document()->detach() is called, as other (i)frames do. It is destroyed on 
738     app shutdown, but until that point, this 'in limbo' frame will do things
739     like steal keyboard focus and crash when clicked on. (On some platforms,
740     it is actually a visible object, even though it's not in a valid state.)
741     
742     Since just about every user is probably going to test against Google at 
743     some point, I'm disabling this functionality until I have time to track down
744     why it is not being destroyed.
745 */
746
747 /*
748     wxWindow* parent = m_webView;
749
750     WebViewFrameData* data = new WebViewFrameData();
751     data->name = name;
752     data->ownerElement = ownerElement;
753     data->url = url;
754     data->referrer = referrer;
755     data->marginWidth = marginWidth;
756     data->marginHeight = marginHeight;
757
758     wxWebView* newWin = new wxWebView(parent, -1, wxDefaultPosition, wxDefaultSize, data);
759
760     RefPtr<Frame> childFrame = newWin->m_impl->frame;
761
762     // FIXME: All of the below should probably be moved over into WebCore
763     childFrame->tree()->setName(name);
764     m_frame->tree()->appendChild(childFrame);
765     // ### set override encoding if we have one
766
767     FrameLoadType loadType = m_frame->loader()->loadType();
768     FrameLoadType childLoadType = FrameLoadTypeInternal;
769
770     childFrame->loader()->load(url, referrer, childLoadType,
771                             String(), 0, 0);
772     
773     // The frame's onload handler may have removed it from the document.
774     if (!childFrame->tree()->parent())
775         return 0;
776     
777     delete data;
778     
779     return childFrame.get();
780 */
781     notImplemented();
782     return 0;
783 }
784
785 ObjectContentType FrameLoaderClientWx::objectContentType(const KURL& url, const String& mimeType)
786 {
787     notImplemented();
788     return ObjectContentType();
789 }
790
791 Widget* FrameLoaderClientWx::createPlugin(const IntSize&, HTMLPlugInElement*, const KURL&, const Vector<String>&, const Vector<String>&, const String&, bool loadManually)
792 {
793     notImplemented();
794     return 0;
795 }
796
797 void FrameLoaderClientWx::redirectDataToPlugin(Widget* pluginWidget)
798 {
799     notImplemented();
800     return;
801 }
802
803 ResourceError FrameLoaderClientWx::pluginWillHandleLoadError(const ResourceResponse&)
804 {
805     notImplemented();
806     return ResourceError();
807 }
808
809 Widget* FrameLoaderClientWx::createJavaAppletWidget(const IntSize&, HTMLAppletElement*, const KURL& baseURL,
810                                                     const Vector<String>& paramNames, const Vector<String>& paramValues)
811 {
812     notImplemented();
813     return 0;
814 }
815
816 String FrameLoaderClientWx::overrideMediaType() const
817 {
818     notImplemented();
819     return String();
820 }
821
822 void FrameLoaderClientWx::windowObjectCleared()
823 {
824     if (m_webView) {
825         wxWebViewWindowObjectClearedEvent wkEvent(m_webView);
826         Frame* coreFrame = m_webView->GetMainFrame()->GetFrame();
827         JSGlobalContextRef context = toGlobalRef(coreFrame->script()->globalObject()->globalExec());
828         JSObjectRef windowObject = toRef(coreFrame->script()->globalObject());
829         wkEvent.SetJSContext(context);
830         wkEvent.SetWindowObject(windowObject);
831         m_webView->GetEventHandler()->ProcessEvent(wkEvent);
832     }
833 }
834
835 void FrameLoaderClientWx::documentElementAvailable()
836 {
837 }
838
839 void FrameLoaderClientWx::didPerformFirstNavigation() const
840 {
841     notImplemented();
842 }
843
844 void FrameLoaderClientWx::registerForIconNotification(bool listen)
845 {
846     notImplemented();
847 }
848
849 void FrameLoaderClientWx::savePlatformDataToCachedFrame(CachedFrame*)
850
851     notImplemented();
852 }
853
854 void FrameLoaderClientWx::transitionToCommittedFromCachedFrame(CachedFrame*)
855
856     notImplemented();
857 }
858
859 void FrameLoaderClientWx::transitionToCommittedForNewPage()
860
861     ASSERT(m_frame);
862     ASSERT(m_webView);
863     
864     Page* page = m_frame->page();
865     ASSERT(page);
866
867     bool isMainFrame = m_frame == page->mainFrame();
868
869     m_frame->setView(0);
870
871     FrameView* frameView;
872     if (isMainFrame)
873         frameView = new FrameView(m_frame, IntRect(m_webView->GetRect()).size());
874     else
875         frameView = new FrameView(m_frame);
876
877     ASSERT(frameView);
878     m_frame->setView(frameView);
879     frameView->deref(); // FrameViews are created with a ref count of 1. Release this ref since we've assigned it to frame.
880
881     frameView->setPlatformWidget(m_webView);
882
883     if (m_frame->ownerRenderer())
884         m_frame->ownerRenderer()->setWidget(frameView);
885
886     if (HTMLFrameOwnerElement* owner = m_frame->ownerElement())
887         m_frame->view()->setScrollbarModes(owner->scrollingMode(), owner->scrollingMode());
888 }
889
890 }