Implement canShowMIMEType
[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     if (MimeTypeRegistry::isSupportedImageMIMEType(MIMEType))
496         return true;
497
498     if (MimeTypeRegistry::isSupportedNonImageMIMEType(MIMEType))
499         return true;
500
501     return false;
502 }
503
504
505 bool FrameLoaderClientQt::representationExistsForURLScheme(const String& URLScheme) const
506 {
507     notImplemented();
508     qDebug() << "    scheme is" << URLScheme;
509     return false;
510 }
511
512
513 String FrameLoaderClientQt::generatedMIMETypeForURLScheme(const String& URLScheme) const
514 {
515     notImplemented();
516     return String();
517 }
518
519
520 void FrameLoaderClientQt::frameLoadCompleted()
521 {
522     notImplemented();
523 }
524
525
526 void FrameLoaderClientQt::restoreViewState()
527 {
528     notImplemented();
529 }
530
531
532 void FrameLoaderClientQt::provisionalLoadStarted()
533 {
534     // don't need to do anything here
535 }
536
537
538 bool FrameLoaderClientQt::shouldTreatURLAsSameAsCurrent(const KURL&) const
539 {
540     notImplemented();
541     return false;
542 }
543
544
545 void FrameLoaderClientQt::addHistoryItemForFragmentScroll()
546 {
547     notImplemented();
548 }
549
550
551 void FrameLoaderClientQt::didFinishLoad()
552 {
553 //     notImplemented();
554 }
555
556
557 void FrameLoaderClientQt::prepareForDataSourceReplacement()
558 {
559     m_frame->loader()->detachChildren();
560 }
561
562
563 void FrameLoaderClientQt::setTitle(const String& title)
564 {
565     QString t = title;
566     emit titleChanged(t);
567 }
568
569
570 void FrameLoaderClientQt::setTitle(const String& title, const KURL& url)
571 {
572     Q_UNUSED(url)
573     setTitle(title);
574 }
575
576
577 String FrameLoaderClientQt::userAgent(const KURL&)
578 {
579     return "Mozilla/5.0 (Macintosh; U; Intel Mac OS X; en) AppleWebKit/418.9.1 (KHTML, like Gecko) Safari/419.3 Qt";
580 }
581
582 void FrameLoaderClientQt::dispatchDidReceiveIcon()
583 {
584     notImplemented();
585 }
586
587 void FrameLoaderClientQt::frameLoaderDestroyed()
588 {
589     Q_ASSERT(m_webFrame == 0);
590     Q_ASSERT(m_frame == 0);
591     delete this;
592 }
593
594 bool FrameLoaderClientQt::canHandleRequest(const WebCore::ResourceRequest&) const
595 {
596     return true;
597 }
598
599 void FrameLoaderClientQt::windowObjectCleared() const
600 {
601     if (m_webFrame)
602         emit m_webFrame->cleared();
603 }
604
605 void FrameLoaderClientQt::setDocumentViewFromCachedPage(CachedPage*)
606 {
607     notImplemented();
608 }
609
610 void FrameLoaderClientQt::updateGlobalHistoryForStandardLoad(const WebCore::KURL&)
611 {
612     notImplemented();
613 }
614
615 void FrameLoaderClientQt::updateGlobalHistoryForReload(const WebCore::KURL&)
616 {
617     notImplemented();
618 }
619
620 bool FrameLoaderClientQt::shouldGoToHistoryItem(WebCore::HistoryItem *item) const
621 {
622     if (item) {
623         return true;
624     }
625     return false;
626 }
627
628 void FrameLoaderClientQt::saveViewStateToItem(WebCore::HistoryItem*)
629 {
630     notImplemented();
631 }
632
633 void FrameLoaderClientQt::saveDocumentViewToCachedPage(CachedPage*)
634 {
635     notImplemented();
636 }
637
638 bool FrameLoaderClientQt::canCachePage() const
639 {
640     // don't do any caching for now
641     return false;
642 }
643
644 void FrameLoaderClientQt::setMainDocumentError(WebCore::DocumentLoader* loader, const WebCore::ResourceError& error)
645 {
646     if (m_firstData) {
647         loader->frameLoader()->setEncoding(m_response.textEncodingName(), false);
648         m_firstData = false;
649     }
650 }
651
652 void FrameLoaderClientQt::committedLoad(WebCore::DocumentLoader* loader, const char* data, int length)
653 {
654     qDebug() << "FrameLoaderClientQt::committedLoad" << length;
655     if (!m_frame)
656         return;
657     FrameLoader *fl = loader->frameLoader();
658     if (m_firstData) {
659         fl->setEncoding(m_response.textEncodingName(), false);
660         m_firstData = false;
661     }
662     fl->addData(data, length);
663 }
664
665 WebCore::ResourceError FrameLoaderClientQt::cancelledError(const WebCore::ResourceRequest&)
666 {
667     notImplemented();
668     return ResourceError();
669 }
670
671 WebCore::ResourceError FrameLoaderClientQt::blockedError(const WebCore::ResourceRequest&)
672 {
673     notImplemented();
674     return ResourceError();
675 }
676
677
678 WebCore::ResourceError FrameLoaderClientQt::cannotShowURLError(const WebCore::ResourceRequest&)
679 {
680     notImplemented();
681     return ResourceError();
682 }
683
684 WebCore::ResourceError FrameLoaderClientQt::interruptForPolicyChangeError(const WebCore::ResourceRequest&)
685 {
686     notImplemented();
687     return ResourceError();
688 }
689
690 WebCore::ResourceError FrameLoaderClientQt::cannotShowMIMETypeError(const WebCore::ResourceResponse&)
691 {
692     notImplemented();
693     return ResourceError();
694 }
695
696 WebCore::ResourceError FrameLoaderClientQt::fileDoesNotExistError(const WebCore::ResourceResponse&)
697 {
698     notImplemented();
699     return ResourceError();
700 }
701
702 bool FrameLoaderClientQt::shouldFallBack(const WebCore::ResourceError&)
703 {
704     notImplemented();
705     return false;
706 }
707
708 WTF::PassRefPtr<WebCore::DocumentLoader> FrameLoaderClientQt::createDocumentLoader(const WebCore::ResourceRequest& request, const SubstituteData& substituteData)
709 {
710     RefPtr<DocumentLoader> loader = new DocumentLoader(request, substituteData);
711     return loader.release();
712 }
713
714 void FrameLoaderClientQt::download(WebCore::ResourceHandle*, const WebCore::ResourceRequest&, const WebCore::ResourceResponse&)
715 {
716     notImplemented();
717 }
718
719 void FrameLoaderClientQt::assignIdentifierToInitialRequest(unsigned long identifier, WebCore::DocumentLoader*, const WebCore::ResourceRequest&)
720 {
721     notImplemented();   
722 }
723
724 void FrameLoaderClientQt::dispatchWillSendRequest(WebCore::DocumentLoader*, unsigned long, WebCore::ResourceRequest& request, const WebCore::ResourceResponse& response)
725 {
726     // seems like the Mac code doesn't do anything here by default neither
727     //qDebug() << "FrameLoaderClientQt::dispatchWillSendRequest" << request.isNull() << request.url().url();
728 }
729
730 void FrameLoaderClientQt::dispatchDidReceiveAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&)
731 {
732     notImplemented();
733 }
734
735 void FrameLoaderClientQt::dispatchDidCancelAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&)
736 {
737     notImplemented();
738 }
739
740 void FrameLoaderClientQt::dispatchDidReceiveResponse(WebCore::DocumentLoader*, unsigned long, const WebCore::ResourceResponse& response)
741 {
742
743     m_response = response;
744     m_firstData = true;
745     //qDebug() << "    got response from" << response.url().url();
746 }
747
748 void FrameLoaderClientQt::dispatchDidReceiveContentLength(WebCore::DocumentLoader*, unsigned long, int)
749 {
750     notImplemented();
751 }
752
753 void FrameLoaderClientQt::dispatchDidFinishLoading(WebCore::DocumentLoader* loader, unsigned long)
754 {
755 }
756
757 void FrameLoaderClientQt::dispatchDidFailLoading(WebCore::DocumentLoader* loader, unsigned long, const WebCore::ResourceError&)
758 {
759     if (m_firstData) {
760         FrameLoader *fl = loader->frameLoader();
761         fl->setEncoding(m_response.textEncodingName(), false);
762         m_firstData = false;
763     }
764 }
765
766 bool FrameLoaderClientQt::dispatchDidLoadResourceFromMemoryCache(WebCore::DocumentLoader*, const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, int)
767 {
768     notImplemented();
769     return false;
770 }
771
772 void FrameLoaderClientQt::dispatchDidFailProvisionalLoad(const WebCore::ResourceError&)
773 {
774     if (m_webFrame)
775         emit m_webFrame->loadDone(false);    
776 }
777
778 void FrameLoaderClientQt::dispatchDidFailLoad(const WebCore::ResourceError&)
779 {
780     if (m_webFrame)
781         emit m_webFrame->loadDone(false);    
782 }
783
784 WebCore::Frame* FrameLoaderClientQt::dispatchCreatePage()
785 {
786     notImplemented();
787     return 0;
788 }
789
790 void FrameLoaderClientQt::dispatchDecidePolicyForMIMEType(FramePolicyFunction function, const WebCore::String&, const WebCore::ResourceRequest&)
791 {
792     // we need to call directly here
793     Q_ASSERT(!m_policyFunction);
794     m_policyFunction = function;
795     slotCallPolicyFunction(PolicyUse);
796 }
797
798 void FrameLoaderClientQt::dispatchDecidePolicyForNewWindowAction(FramePolicyFunction function, const WebCore::NavigationAction&, const WebCore::ResourceRequest&, const WebCore::String&)
799 {
800     notImplemented();
801     Q_ASSERT(!m_policyFunction);
802     callPolicyFunction(function, PolicyIgnore);
803 }
804
805 void FrameLoaderClientQt::dispatchDecidePolicyForNavigationAction(FramePolicyFunction function, const WebCore::NavigationAction&, const WebCore::ResourceRequest& request)
806 {
807     Q_ASSERT(!m_policyFunction);
808     m_policyFunction = function;
809     slotCallPolicyFunction(PolicyUse);
810     return;
811 }
812
813 void FrameLoaderClientQt::dispatchUnableToImplementPolicy(const WebCore::ResourceError&)
814 {
815     notImplemented();
816 }
817
818 void FrameLoaderClientQt::startDownload(const WebCore::ResourceRequest&)
819 {
820     notImplemented();
821 }
822
823 bool FrameLoaderClientQt::willUseArchive(WebCore::ResourceLoader*, const WebCore::ResourceRequest&, const WebCore::KURL&) const
824 {
825     notImplemented();
826     return false;
827 }
828
829 Frame* FrameLoaderClientQt::createFrame(const KURL& url, const String& name, HTMLFrameOwnerElement* ownerElement,
830                                         const String& referrer, bool allowsScrolling, int marginWidth, int marginHeight)
831 {
832     QWebFrameData frameData;
833     frameData.url = url;
834     frameData.name = name;
835     frameData.ownerElement = ownerElement;
836     frameData.referrer = referrer;
837     frameData.allowsScrolling = allowsScrolling;
838     frameData.marginWidth = marginWidth;
839     frameData.marginHeight = marginHeight;
840
841     QWebFrame* webFrame = m_webFrame->page()->createFrame(m_webFrame, &frameData);
842
843     RefPtr<Frame> childFrame = webFrame->d->frame;
844
845     // FIXME: All of the below should probably be moved over into WebCore
846     childFrame->tree()->setName(name);
847     m_frame->tree()->appendChild(childFrame);
848     // ### set override encoding if we have one
849
850     FrameLoadType loadType = m_frame->loader()->loadType();
851     FrameLoadType childLoadType = FrameLoadTypeInternal;
852
853     childFrame->loader()->load(frameData.url, frameData.referrer, childLoadType,
854                              String(), 0, 0, WTF::HashMap<String, String>());
855
856     // The frame's onload handler may have removed it from the document.
857     if (!childFrame->tree()->parent())
858         return 0;
859
860     return childFrame.get();
861 }
862
863 ObjectContentType FrameLoaderClientQt::objectContentType(const KURL& url, const String& mimeType)
864 {
865     if (!url.isValid())
866         return ObjectContentType();
867     
868     //This is not really correct. it works because getMIMETypeForExtension
869     //  currently returns only the mimetypes that frames can handle
870     QFileInfo fi(url.path());
871     String rtype = MimeTypeRegistry::getMIMETypeForExtension(fi.suffix());
872     if (!rtype.isEmpty())
873         return ObjectContentFrame;
874     return ObjectContentType();
875 }
876
877 Widget* FrameLoaderClientQt::createPlugin(Element*, const KURL&, const Vector<String>&, const Vector<String>&, const String&, bool)
878 {
879     notImplemented();
880     return 0;
881 }
882
883 void FrameLoaderClientQt::redirectDataToPlugin(Widget* pluginWidget)
884 {
885     notImplemented();
886     return;
887 }
888
889 Widget* FrameLoaderClientQt::createJavaAppletWidget(const IntSize&, Element*, const KURL& baseURL,
890                                                     const Vector<String>& paramNames, const Vector<String>& paramValues)
891 {
892     notImplemented();
893     return 0;
894 }
895
896 String FrameLoaderClientQt::overrideMediaType() const
897 {
898     notImplemented();
899     return String();
900 }
901
902 }
903
904 #include "FrameLoaderClientQt.moc"