9ffdc1aab6c44a77f8703f79a1f49154c2e6ba3d
[WebKit-https.git] / WebKitQt / WebCoreSupport / FrameLoaderClientQt.cpp
1 /*
2  * Copyright (C) 2006 Zack Rusin <zack@kde.org>
3  * Copyright (C) 2006 Apple Computer, Inc.  All rights reserved.
4  * Copyright (C) 2007 Trolltech ASA
5  *
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  *
17  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
20  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
21  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
22  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
23  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
24  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
25  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29
30 #include "config.h"
31 #include "FrameLoaderClientQt.h"
32 #include "FrameTree.h"
33 #include "FrameView.h"
34 #include "DocumentLoader.h"
35 #include "ResourceResponse.h"
36 #include "Page.h"
37 #include "ProgressTracker.h"
38 #include "ResourceRequest.h"
39
40 #include "qwebpage.h"
41 #include "qwebframe.h"
42 #include "qwebframe_p.h"
43
44 #include "qdebug.h"
45
46 #define notImplemented() qDebug("FIXME: UNIMPLEMENTED: %s:%d (%s)", __FILE__, __LINE__, __FUNCTION__)
47 #define methodDebug() qDebug("FrameLoaderClientQt: %s loader=%p", __FUNCTION__, (m_frame ? m_frame->loader() : 0))
48
49 namespace WebCore
50 {
51
52 FrameLoaderClientQt::FrameLoaderClientQt()
53     : m_frame(0)
54     , m_webFrame(0)
55     , m_firstData(false)
56     , m_policyFunction(0)
57 {
58     connect(this, SIGNAL(sigCallPolicyFunction(int)), this, SLOT(slotCallPolicyFunction(int)), Qt::QueuedConnection);
59 }
60
61
62 FrameLoaderClientQt::~FrameLoaderClientQt()
63 {
64 }
65
66 void FrameLoaderClientQt::setFrame(QWebFrame *webFrame, FrameQt *frame)
67 {
68     m_webFrame = webFrame;
69     m_frame = frame;
70     if (!m_webFrame || !m_webFrame->page()) {
71         qWarning("FrameLoaderClientQt::setFrame frame without Page!");
72         return;
73     }
74
75     connect(this, SIGNAL(loadStarted(QWebFrame*)),
76             m_webFrame->page(), SIGNAL(loadStarted(QWebFrame *)));
77     connect(this, SIGNAL(loadProgressChanged(double)),
78             m_webFrame->page(), SIGNAL(loadProgressChanged(double)));
79     connect(this, SIGNAL(loadFinished(QWebFrame*)),
80             m_webFrame->page(), SIGNAL(loadFinished(QWebFrame *)));
81     connect(this, SIGNAL(titleChanged(const QString&)),
82             m_webFrame, SIGNAL(titleChanged(const QString&)));
83 }
84
85 void FrameLoaderClientQt::detachFrameLoader()
86 {
87     disconnect(this, SIGNAL(loadStarted(QWebFrame*)));
88     disconnect(this, SIGNAL(loadProgressChanged(double)));
89     disconnect(this, SIGNAL(loadFinished(QWebFrame*)));
90     disconnect(this, SIGNAL(titleChanged(const QString&)));
91     m_webFrame = 0;
92     m_frame = 0;
93 }
94
95 void FrameLoaderClientQt::callPolicyFunction(FramePolicyFunction function, PolicyAction action)
96 {
97     qDebug() << "FrameLoaderClientQt::callPolicyFunction";
98     ASSERT(!m_policyFunction);
99
100     m_policyFunction = function;
101     emit sigCallPolicyFunction(action);
102 }
103
104 void FrameLoaderClientQt::slotCallPolicyFunction(int action)
105 {
106     qDebug() << "FrameLoaderClientQt::slotCallPolicyFunction";
107     if (!m_frame || !m_policyFunction)
108         return;
109     (m_frame->loader()->*m_policyFunction)(WebCore::PolicyAction(action));
110     m_policyFunction = 0;
111 }
112
113 bool FrameLoaderClientQt::hasWebView() const
114 {
115     //notImplemented();
116     return true;
117 }
118
119
120 bool FrameLoaderClientQt::hasFrameView() const
121 {
122     //notImplemented();
123     return true;
124 }
125
126
127 bool FrameLoaderClientQt::hasBackForwardList() const
128 {
129     notImplemented();
130     return false;
131 }
132
133
134 void FrameLoaderClientQt::resetBackForwardList()
135 {
136     notImplemented();
137 }
138
139
140 bool FrameLoaderClientQt::provisionalItemIsTarget() const
141 {
142     notImplemented();
143     return false;
144 }
145
146
147 bool FrameLoaderClientQt::loadProvisionalItemFromPageCache()
148 {
149     notImplemented();
150     return false;
151 }
152
153
154 void FrameLoaderClientQt::invalidateCurrentItemPageCache()
155 {
156     notImplemented();
157 }
158
159
160 bool FrameLoaderClientQt::privateBrowsingEnabled() const
161 {
162     notImplemented();
163     return false;
164 }
165
166
167 void FrameLoaderClientQt::makeDocumentView()
168 {
169     qDebug() << "FrameLoaderClientQt::makeDocumentView" << m_frame->document();
170     
171 //     if (!m_frame->document()) 
172 //         m_frame->loader()->createEmptyDocument();
173 }
174
175
176 void FrameLoaderClientQt::makeRepresentation(DocumentLoader*)
177 {
178     // don't need this for now I think.
179 }
180
181
182 void FrameLoaderClientQt::forceLayout()
183 {
184     notImplemented();
185 }
186
187
188 void FrameLoaderClientQt::forceLayoutForNonHTML()
189 {
190     notImplemented();
191 }
192
193
194 void FrameLoaderClientQt::updateHistoryForCommit()
195 {
196     notImplemented();
197 }
198
199
200 void FrameLoaderClientQt::updateHistoryForBackForwardNavigation()
201 {
202     notImplemented();
203 }
204
205
206 void FrameLoaderClientQt::updateHistoryForReload()
207 {
208     notImplemented();
209 }
210
211
212 void FrameLoaderClientQt::updateHistoryForStandardLoad()
213 {
214     notImplemented();
215 }
216
217
218 void FrameLoaderClientQt::updateHistoryForInternalLoad()
219 {
220     notImplemented();
221 }
222
223
224 void FrameLoaderClientQt::updateHistoryAfterClientRedirect()
225 {
226     notImplemented();
227 }
228
229
230 void FrameLoaderClientQt::setCopiesOnScroll()
231 {
232     // apparently mac specific 
233 }
234
235
236 LoadErrorResetToken* FrameLoaderClientQt::tokenForLoadErrorReset()
237 {
238     notImplemented();
239     return 0;
240 }
241
242
243 void FrameLoaderClientQt::resetAfterLoadError(LoadErrorResetToken*)
244 {
245     notImplemented();
246 }
247
248
249 void FrameLoaderClientQt::doNotResetAfterLoadError(LoadErrorResetToken*)
250 {
251     notImplemented();
252 }
253
254
255 void FrameLoaderClientQt::willCloseDocument()
256 {
257     notImplemented();
258 }
259
260 void FrameLoaderClientQt::detachedFromParent2()
261 {
262     notImplemented();
263 }
264
265
266 void FrameLoaderClientQt::detachedFromParent3()
267 {
268     if (!m_webFrame)
269         return;
270     if (m_webFrame->d->frameView)
271         m_webFrame->d->frameView->setScrollArea(0);
272     m_webFrame->d->frameView = 0;
273 }
274
275
276 void FrameLoaderClientQt::detachedFromParent4()
277 {
278     delete m_webFrame;
279     m_webFrame = 0;
280     m_frame = 0;
281 }
282
283
284 void FrameLoaderClientQt::loadedFromPageCache()
285 {
286     notImplemented();
287 }
288
289
290 void FrameLoaderClientQt::dispatchDidHandleOnloadEvents()
291 {
292     if (m_webFrame)
293         emit m_webFrame->loadDone(true);
294 }
295
296
297 void FrameLoaderClientQt::dispatchDidReceiveServerRedirectForProvisionalLoad()
298 {
299     notImplemented();
300 }
301
302
303 void FrameLoaderClientQt::dispatchDidCancelClientRedirect()
304 {
305     notImplemented();
306 }
307
308
309 void FrameLoaderClientQt::dispatchWillPerformClientRedirect(const KURL&,
310                                                             double interval,
311                                                             double fireDate)
312 {
313     notImplemented();
314 }
315
316
317 void FrameLoaderClientQt::dispatchDidChangeLocationWithinPage()
318 {
319     notImplemented();
320 }
321
322
323 void FrameLoaderClientQt::dispatchWillClose()
324 {
325     notImplemented();
326 }
327
328
329 void FrameLoaderClientQt::dispatchDidStartProvisionalLoad()
330 {
331     // we're not interested in this neither I think
332 }
333
334
335 void FrameLoaderClientQt::dispatchDidReceiveTitle(const String& title)
336 {
337     setTitle(title);
338 }
339
340
341 void FrameLoaderClientQt::dispatchDidCommitLoad()
342 {
343     notImplemented();
344 }
345
346
347 void FrameLoaderClientQt::dispatchDidFinishDocumentLoad()
348 {
349     notImplemented();
350 }
351
352
353 void FrameLoaderClientQt::dispatchDidFinishLoad()
354 {
355 }
356
357
358 void FrameLoaderClientQt::dispatchDidFirstLayout()
359 {
360     //notImplemented();
361 }
362
363
364 void FrameLoaderClientQt::dispatchShow()
365 {
366     notImplemented();
367 }
368
369
370 void FrameLoaderClientQt::cancelPolicyCheck()
371 {
372     qDebug() << "FrameLoaderClientQt::cancelPolicyCheck";
373     m_policyFunction = 0;
374 }
375
376
377 void FrameLoaderClientQt::dispatchWillSubmitForm(FramePolicyFunction function,
378                                                  PassRefPtr<FormState>)
379 {
380     notImplemented();
381     // FIXME: This is surely too simple
382     callPolicyFunction(function, PolicyUse);
383 }
384
385
386 void FrameLoaderClientQt::dispatchDidLoadMainResource(DocumentLoader*)
387 {
388     notImplemented();
389 }
390
391
392 void FrameLoaderClientQt::clearLoadingFromPageCache(DocumentLoader*)
393 {
394     notImplemented();
395 }
396
397
398 bool FrameLoaderClientQt::isLoadingFromPageCache(DocumentLoader*)
399 {
400     notImplemented();
401     return false;
402 }
403
404
405 void FrameLoaderClientQt::revertToProvisionalState(DocumentLoader*)
406 {
407     notImplemented();
408 }
409
410
411 void FrameLoaderClientQt::clearUnarchivingState(DocumentLoader*)
412 {
413     notImplemented();
414 }
415
416
417 void FrameLoaderClientQt::postProgressStartedNotification()
418 {
419     if (m_webFrame && m_frame->page())
420         emit loadStarted(m_webFrame);
421 }
422
423 void FrameLoaderClientQt::postProgressEstimateChangedNotification()
424 {
425     if (m_webFrame && m_frame->page())
426         emit loadProgressChanged(m_frame->page()->progress()->estimatedProgress());
427 }
428
429 void FrameLoaderClientQt::postProgressFinishedNotification()
430 {
431     if (m_webFrame && m_frame->page())
432         emit loadFinished(m_webFrame);
433 }
434
435 void FrameLoaderClientQt::setMainFrameDocumentReady(bool b)
436 {
437     // this is only interesting once we provide an external API for the DOM
438 }
439
440
441 void FrameLoaderClientQt::willChangeTitle(DocumentLoader*)
442 {
443     notImplemented();
444 }
445
446
447 void FrameLoaderClientQt::didChangeTitle(DocumentLoader *l)
448 {
449     setTitle(l->title());
450 }
451
452
453 void FrameLoaderClientQt::finishedLoading(DocumentLoader* loader)
454 {
455     if (m_firstData) {
456         FrameLoader *fl = loader->frameLoader();
457         fl->setEncoding(m_response.textEncodingName(), false);
458         m_firstData = false;
459     }
460 }
461
462
463 void FrameLoaderClientQt::finalSetupForReplace(DocumentLoader*)
464 {
465     notImplemented();
466 }
467
468
469 void FrameLoaderClientQt::setDefersLoading(bool)
470 {
471     notImplemented();
472 }
473
474
475 bool FrameLoaderClientQt::isArchiveLoadPending(ResourceLoader*) const
476 {
477     notImplemented();
478     return false;
479 }
480
481
482 void FrameLoaderClientQt::cancelPendingArchiveLoad(ResourceLoader*)
483 {
484     notImplemented();
485 }
486
487
488 void FrameLoaderClientQt::clearArchivedResources()
489 {
490     // don't think we need to do anything here currently
491 }
492
493
494 bool FrameLoaderClientQt::canShowMIMEType(const String& MIMEType) const
495 {
496     // FIXME: This is not good enough in the general case
497     qDebug() << "FrameLoaderClientQt::canShowMIMEType" << MIMEType;
498     return true;
499 }
500
501
502 bool FrameLoaderClientQt::representationExistsForURLScheme(const String& URLScheme) const
503 {
504     notImplemented();
505     qDebug() << "    scheme is" << URLScheme;
506     return false;
507 }
508
509
510 String FrameLoaderClientQt::generatedMIMETypeForURLScheme(const String& URLScheme) const
511 {
512     notImplemented();
513     return String();
514 }
515
516
517 void FrameLoaderClientQt::frameLoadCompleted()
518 {
519     notImplemented();
520 }
521
522
523 void FrameLoaderClientQt::restoreScrollPositionAndViewState()
524 {
525     notImplemented();
526 }
527
528
529 void FrameLoaderClientQt::provisionalLoadStarted()
530 {
531     // don't need to do anything here
532 }
533
534
535 bool FrameLoaderClientQt::shouldTreatURLAsSameAsCurrent(const KURL&) const
536 {
537     notImplemented();
538     return false;
539 }
540
541
542 void FrameLoaderClientQt::addHistoryItemForFragmentScroll()
543 {
544     notImplemented();
545 }
546
547
548 void FrameLoaderClientQt::didFinishLoad()
549 {
550     notImplemented();
551 }
552
553
554 void FrameLoaderClientQt::prepareForDataSourceReplacement()
555 {
556     m_frame->loader()->detachChildren();
557 }
558
559
560 void FrameLoaderClientQt::setTitle(const String& title)
561 {
562     QString t = title;
563     emit titleChanged(t);
564 }
565
566
567 void FrameLoaderClientQt::setTitle(const String& title, const KURL& url)
568 {
569     Q_UNUSED(url)
570     setTitle(title);
571 }
572
573
574 String FrameLoaderClientQt::userAgent()
575 {
576     return "Mozilla/5.0 (Macintosh; U; Intel Mac OS X; en) AppleWebKit/418.9.1 (KHTML, like Gecko) Safari/419.3 Qt";
577 }
578
579 void FrameLoaderClientQt::dispatchDidReceiveIcon()
580 {
581     notImplemented();
582 }
583
584 void FrameLoaderClientQt::frameLoaderDestroyed()
585 {
586     m_webFrame = 0;
587     m_frame = 0;
588     delete this;
589 }
590
591 bool FrameLoaderClientQt::canHandleRequest(const WebCore::ResourceRequest&) const
592 {
593     return true;
594 }
595
596 void FrameLoaderClientQt::windowObjectCleared() const
597 {
598     if (m_webFrame)
599         emit m_webFrame->cleared();
600 }
601
602 void FrameLoaderClientQt::setDocumentViewFromPageCache(WebCore::PageCache*)
603 {
604     notImplemented();
605 }
606
607 void FrameLoaderClientQt::updateGlobalHistoryForStandardLoad(const WebCore::KURL&)
608 {
609     notImplemented();
610 }
611
612 void FrameLoaderClientQt::updateGlobalHistoryForReload(const WebCore::KURL&)
613 {
614     notImplemented();
615 }
616
617 bool FrameLoaderClientQt::shouldGoToHistoryItem(WebCore::HistoryItem *item) const
618 {
619     if (item) {
620         return true;
621     }
622     return false;
623 }
624
625 void FrameLoaderClientQt::saveScrollPositionAndViewStateToItem(WebCore::HistoryItem*)
626 {
627     notImplemented();
628 }
629
630 void FrameLoaderClientQt::saveDocumentViewToPageCache(WebCore::PageCache*)
631 {
632     notImplemented();
633 }
634
635 bool FrameLoaderClientQt::canCachePage() const
636 {
637     // don't do any caching for now
638     return false;
639 }
640
641 void FrameLoaderClientQt::setMainDocumentError(WebCore::DocumentLoader* loader, const WebCore::ResourceError&)
642 {
643     if (m_firstData) {
644         loader->frameLoader()->setEncoding(m_response.textEncodingName(), false);
645         m_firstData = false;
646     }
647     if (m_webFrame)
648         emit m_webFrame->loadDone(false);
649 }
650
651 void FrameLoaderClientQt::committedLoad(WebCore::DocumentLoader* loader, const char* data, int length)
652 {
653     qDebug() << "FrameLoaderClientQt::committedLoad" << length;
654     if (!m_frame)
655         return;
656     FrameLoader *fl = loader->frameLoader();
657     if (m_firstData) {
658         fl->setEncoding(m_response.textEncodingName(), false);
659         m_firstData = false;
660     }
661     fl->addData(data, length);
662 }
663
664 WebCore::ResourceError FrameLoaderClientQt::cancelledError(const WebCore::ResourceRequest&)
665 {
666     notImplemented();
667     return ResourceError();
668 }
669
670 WebCore::ResourceError FrameLoaderClientQt::cannotShowURLError(const WebCore::ResourceRequest&)
671 {
672     notImplemented();
673     return ResourceError();
674 }
675
676 WebCore::ResourceError FrameLoaderClientQt::interruptForPolicyChangeError(const WebCore::ResourceRequest&)
677 {
678     notImplemented();
679     return ResourceError();
680 }
681
682 WebCore::ResourceError FrameLoaderClientQt::cannotShowMIMETypeError(const WebCore::ResourceResponse&)
683 {
684     notImplemented();
685     return ResourceError();
686 }
687
688 WebCore::ResourceError FrameLoaderClientQt::fileDoesNotExistError(const WebCore::ResourceResponse&)
689 {
690     notImplemented();
691     return ResourceError();
692 }
693
694 bool FrameLoaderClientQt::shouldFallBack(const WebCore::ResourceError&)
695 {
696     notImplemented();
697     return false;
698 }
699
700 WTF::PassRefPtr<WebCore::DocumentLoader> FrameLoaderClientQt::createDocumentLoader(const WebCore::ResourceRequest& request)
701 {
702     RefPtr<DocumentLoader> loader = new DocumentLoader(request);
703     return loader.release();
704 }
705
706 void FrameLoaderClientQt::download(WebCore::ResourceHandle*, const WebCore::ResourceRequest&, const WebCore::ResourceResponse&)
707 {
708     notImplemented();
709 }
710
711 void FrameLoaderClientQt::assignIdentifierToInitialRequest(unsigned long identifier, WebCore::DocumentLoader*, const WebCore::ResourceRequest&)
712 {
713     notImplemented();   
714 }
715
716 void FrameLoaderClientQt::dispatchWillSendRequest(WebCore::DocumentLoader*, unsigned long, WebCore::ResourceRequest& request, const WebCore::ResourceResponse& response)
717 {
718     // seems like the Mac code doesn't do anything here by default neither
719     qDebug() << "FrameLoaderClientQt::dispatchWillSendRequest" << request.isNull() << request.url().url();
720 }
721
722 void FrameLoaderClientQt::dispatchDidReceiveAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&)
723 {
724     notImplemented();
725 }
726
727 void FrameLoaderClientQt::dispatchDidCancelAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&)
728 {
729     notImplemented();
730 }
731
732 void FrameLoaderClientQt::dispatchDidReceiveResponse(WebCore::DocumentLoader*, unsigned long, const WebCore::ResourceResponse& response)
733 {
734
735     m_response = response;
736     m_firstData = true;
737     qDebug() << "    got response from" << response.url().url();
738 }
739
740 void FrameLoaderClientQt::dispatchDidReceiveContentLength(WebCore::DocumentLoader*, unsigned long, int)
741 {
742     notImplemented();
743 }
744
745 void FrameLoaderClientQt::dispatchDidFinishLoading(WebCore::DocumentLoader* loader, unsigned long)
746 {
747 }
748
749 void FrameLoaderClientQt::dispatchDidFailLoading(WebCore::DocumentLoader* loader, unsigned long, const WebCore::ResourceError&)
750 {
751     if (m_firstData) {
752         FrameLoader *fl = loader->frameLoader();
753         fl->setEncoding(m_response.textEncodingName(), false);
754         m_firstData = false;
755     }
756 }
757
758 bool FrameLoaderClientQt::dispatchDidLoadResourceFromMemoryCache(WebCore::DocumentLoader*, const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, int)
759 {
760     notImplemented();
761 }
762
763 void FrameLoaderClientQt::dispatchDidFailProvisionalLoad(const WebCore::ResourceError&)
764 {
765     notImplemented();
766 }
767
768 void FrameLoaderClientQt::dispatchDidFailLoad(const WebCore::ResourceError&)
769 {
770     notImplemented();
771 }
772
773 WebCore::Frame* FrameLoaderClientQt::dispatchCreatePage()
774 {
775     notImplemented();
776 }
777
778 void FrameLoaderClientQt::dispatchDecidePolicyForMIMEType(FramePolicyFunction function, const WebCore::String&, const WebCore::ResourceRequest&)
779 {
780     // we need to call directly here
781     m_policyFunction = function;
782     slotCallPolicyFunction(PolicyUse);
783 }
784
785 void FrameLoaderClientQt::dispatchDecidePolicyForNewWindowAction(FramePolicyFunction function, const WebCore::NavigationAction&, const WebCore::ResourceRequest&, const WebCore::String&)
786 {
787     notImplemented();
788     callPolicyFunction(function, PolicyIgnore);
789 }
790
791 void FrameLoaderClientQt::dispatchDecidePolicyForNavigationAction(FramePolicyFunction function, const WebCore::NavigationAction&, const WebCore::ResourceRequest& request)
792 {
793
794     KURL url = request.url();
795     if (url.isEmpty() || url.protocol() == "about") {
796         m_policyFunction = function;
797         slotCallPolicyFunction(PolicyUse);
798         return;
799     }
800     callPolicyFunction(function, PolicyUse);
801 }
802
803 void FrameLoaderClientQt::dispatchUnableToImplementPolicy(const WebCore::ResourceError&)
804 {
805     notImplemented();
806 }
807
808 void FrameLoaderClientQt::startDownload(const WebCore::ResourceRequest&)
809 {
810     notImplemented();
811 }
812
813 bool FrameLoaderClientQt::willUseArchive(WebCore::ResourceLoader*, const WebCore::ResourceRequest&, const WebCore::KURL&) const
814 {
815     notImplemented();
816     return false;
817 }
818
819 Frame* FrameLoaderClientQt::createFrame(const KURL& url, const String& name, HTMLFrameOwnerElement* ownerElement,
820                                         const String& referrer, bool allowsScrolling, int marginWidth, int marginHeight)
821 {
822     QWebFrameData frameData;
823     frameData.url = url;
824     frameData.name = name;
825     frameData.ownerElement = ownerElement;
826     frameData.referrer = referrer;
827     frameData.allowsScrolling = allowsScrolling;
828     frameData.marginWidth = marginWidth;
829     frameData.marginHeight = marginHeight;
830         
831
832     QWebFrame* webFrame = m_webFrame->page()->createFrame(m_webFrame, &frameData);
833
834     RefPtr<Frame> childFrame = webFrame->d->frame;
835
836     // FIXME: All of the below should probably be moved over into WebCore
837     childFrame->tree()->setName(name);
838     m_frame->tree()->appendChild(childFrame);
839     // ### set override encoding if we have one
840
841     FrameLoadType loadType = m_frame->loader()->loadType();
842     FrameLoadType childLoadType = FrameLoadTypeInternal;
843
844     childFrame->loader()->load(frameData.url, frameData.referrer, childLoadType,
845                              String(), 0, 0, WTF::HashMap<String, String>());
846     
847     // The frame's onload handler may have removed it from the document.
848     if (!childFrame->tree()->parent())
849         return 0;
850     
851     return childFrame.get();
852 }
853
854 ObjectContentType FrameLoaderClientQt::objectContentType(const KURL& url, const String& mimeType)
855 {
856     notImplemented();
857     return ObjectContentType();
858 }
859
860 Widget* FrameLoaderClientQt::createPlugin(Element*, const KURL&, const Vector<String>&, const Vector<String>&, const String&, bool)
861 {
862     notImplemented();
863     return 0;
864 }
865
866 void FrameLoaderClientQt::redirectDataToPlugin(Widget* pluginWidget)
867 {
868     notImplemented();
869     return;
870 }
871
872 Widget* FrameLoaderClientQt::createJavaAppletWidget(const IntSize&, Element*, const KURL& baseURL,
873                                                     const Vector<String>& paramNames, const Vector<String>& paramValues)
874 {
875     notImplemented();
876     return 0;
877 }
878
879 String FrameLoaderClientQt::overrideMediaType() const
880 {
881     notImplemented();
882     return String();
883 }
884
885 }
886
887 #include "FrameLoaderClientQt.moc"