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