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