Jarek Kobus <jkobus@trolltech.com>
[WebKit-https.git] / WebKit / qt / 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 "CSSComputedStyleDeclaration.h"
32 #include "CSSPropertyNames.h"
33 #include "FrameLoaderClientQt.h"
34 #include "FrameTree.h"
35 #include "FrameView.h"
36 #include "DocumentLoader.h"
37 #include "MIMETypeRegistry.h"
38 #include "ResourceResponse.h"
39 #include "Page.h"
40 #include "ProgressTracker.h"
41 #include "ResourceRequest.h"
42 #include "HistoryItem.h"
43 #include "HTMLFormElement.h"
44 #include "NotImplemented.h"
45 #include "QNetworkReplyHandler.h"
46 #include "ResourceHandleInternal.h"
47 #include "ResourceHandle.h"
48
49 #include "qwebpage.h"
50 #include "qwebframe.h"
51 #include "qwebframe_p.h"
52 #include "qwebhistoryinterface.h"
53
54 #include <qfileinfo.h>
55
56 #include <QCoreApplication>
57 #include <QDebug>
58 #if QT_VERSION >= 0x040400
59 #include <QNetworkRequest>
60 #include <QNetworkReply>
61 #else
62 #include "qwebnetworkinterface_p.h"
63 #include "qwebobjectplugin_p.h"
64 #endif
65
66 namespace WebCore
67 {
68
69 FrameLoaderClientQt::FrameLoaderClientQt()
70     : m_frame(0)
71     , m_webFrame(0)
72     , m_firstData(false)
73     , m_policyFunction(0)
74 {
75     connect(this, SIGNAL(sigCallPolicyFunction(int)), this, SLOT(slotCallPolicyFunction(int)), Qt::QueuedConnection);
76 }
77
78
79 FrameLoaderClientQt::~FrameLoaderClientQt()
80 {
81 }
82
83 void FrameLoaderClientQt::setFrame(QWebFrame* webFrame, Frame* frame)
84 {
85     m_webFrame = webFrame;
86     m_frame = frame;
87     if (!m_webFrame || !m_webFrame->page()) {
88         qWarning("FrameLoaderClientQt::setFrame frame without Page!");
89         return;
90     }
91
92     connect(this, SIGNAL(loadStarted()),
93             m_webFrame, SIGNAL(loadStarted()));
94     connect(this, SIGNAL(loadProgressChanged(int)),
95             m_webFrame->page(), SIGNAL(loadProgressChanged(int)));
96     connect(this, SIGNAL(loadFinished()),
97             m_webFrame, SIGNAL(loadFinished()));
98     connect(this, SIGNAL(titleChanged(const QString&)),
99             m_webFrame, SIGNAL(titleChanged(const QString&)));
100 }
101
102 QWebFrame* FrameLoaderClientQt::webFrame() const
103 {
104     return m_webFrame;
105 }
106
107 void FrameLoaderClientQt::callPolicyFunction(FramePolicyFunction function, PolicyAction action)
108 {
109     ASSERT(!m_policyFunction);
110     ASSERT(function);
111
112     m_policyFunction = function;
113     emit sigCallPolicyFunction(action);
114 }
115
116 void FrameLoaderClientQt::slotCallPolicyFunction(int action)
117 {
118     if (!m_frame || !m_policyFunction)
119         return;
120     FramePolicyFunction function = m_policyFunction;
121     m_policyFunction = 0;
122     (m_frame->loader()->*function)(WebCore::PolicyAction(action));
123 }
124
125 bool FrameLoaderClientQt::hasWebView() const
126 {
127     //notImplemented();
128     return true;
129 }
130
131
132 bool FrameLoaderClientQt::hasFrameView() const
133 {
134     //notImplemented();
135     return true;
136 }
137
138
139 bool FrameLoaderClientQt::hasBackForwardList() const
140 {
141     notImplemented();
142     return false;
143 }
144
145
146 void FrameLoaderClientQt::resetBackForwardList()
147 {
148     notImplemented();
149 }
150
151
152 bool FrameLoaderClientQt::provisionalItemIsTarget() const
153 {
154     notImplemented();
155     return false;
156 }
157
158
159 bool FrameLoaderClientQt::loadProvisionalItemFromPageCache()
160 {
161     notImplemented();
162     return false;
163 }
164
165
166 void FrameLoaderClientQt::invalidateCurrentItemPageCache()
167 {
168     notImplemented();
169 }
170
171 void FrameLoaderClientQt::savePlatformDataToCachedPage(CachedPage*) 
172 {
173     notImplemented();
174 }
175
176 void FrameLoaderClientQt::transitionToCommittedFromCachedPage(CachedPage*)
177
178     notImplemented();
179 }
180
181 void FrameLoaderClientQt::transitionToCommittedForNewPage() 
182
183 //    qDebug() << "FrameLoaderClientQt::makeDocumentView" << m_frame->document();
184
185 //     if (!m_frame->document())
186 //         m_frame->loader()->createEmptyDocument();
187 }
188
189
190 void FrameLoaderClientQt::makeRepresentation(DocumentLoader*)
191 {
192     // don't need this for now I think.
193 }
194
195
196 void FrameLoaderClientQt::forceLayout()
197 {
198     m_frame->view()->setNeedsLayout();
199     m_frame->view()->layout();
200 }
201
202
203 void FrameLoaderClientQt::forceLayoutForNonHTML()
204 {
205 }
206
207
208 void FrameLoaderClientQt::setCopiesOnScroll()
209 {
210     // apparently mac specific
211 }
212
213
214 LoadErrorResetToken* FrameLoaderClientQt::tokenForLoadErrorReset()
215 {
216     notImplemented();
217     return 0;
218 }
219
220
221 void FrameLoaderClientQt::resetAfterLoadError(LoadErrorResetToken*)
222 {
223     notImplemented();
224 }
225
226
227 void FrameLoaderClientQt::doNotResetAfterLoadError(LoadErrorResetToken*)
228 {
229     notImplemented();
230 }
231
232
233 void FrameLoaderClientQt::willCloseDocument()
234 {
235     notImplemented();
236 }
237
238 void FrameLoaderClientQt::detachedFromParent2()
239 {
240 }
241
242
243 void FrameLoaderClientQt::detachedFromParent3()
244 {
245 }
246
247
248 void FrameLoaderClientQt::detachedFromParent4()
249 {
250     if (!m_webFrame)
251         return;
252     m_webFrame->d->frame = 0;
253     m_webFrame->d->frameView = 0;
254     m_webFrame = 0;
255     m_frame = 0;
256 }
257
258
259 void FrameLoaderClientQt::loadedFromCachedPage()
260 {
261     notImplemented();
262 }
263
264
265 void FrameLoaderClientQt::dispatchDidHandleOnloadEvents()
266 {
267     // don't need this one
268 }
269
270
271 void FrameLoaderClientQt::dispatchDidReceiveServerRedirectForProvisionalLoad()
272 {
273     notImplemented();
274 }
275
276
277 void FrameLoaderClientQt::dispatchDidCancelClientRedirect()
278 {
279     notImplemented();
280 }
281
282
283 void FrameLoaderClientQt::dispatchWillPerformClientRedirect(const KURL&,
284                                                             double interval,
285                                                             double fireDate)
286 {
287     notImplemented();
288 }
289
290
291 void FrameLoaderClientQt::dispatchDidChangeLocationWithinPage()
292 {
293     notImplemented();
294 }
295
296
297 void FrameLoaderClientQt::dispatchWillClose()
298 {
299 }
300
301
302 void FrameLoaderClientQt::dispatchDidStartProvisionalLoad()
303 {
304     if (m_webFrame)
305         emit m_webFrame->provisionalLoad();
306 }
307
308
309 void FrameLoaderClientQt::dispatchDidReceiveTitle(const String& title)
310 {
311     // ### hack
312     emit m_webFrame->urlChanged(m_webFrame->url());
313     emit titleChanged(title);
314 }
315
316
317 void FrameLoaderClientQt::dispatchDidCommitLoad()
318 {
319     if (m_frame->tree()->parent())
320         return;
321     m_webFrame->page()->d->updateNavigationActions();
322 }
323
324
325 void FrameLoaderClientQt::dispatchDidFinishDocumentLoad()
326 {
327     if (m_frame->tree()->parent())
328         return;
329     m_webFrame->page()->d->updateNavigationActions();
330 }
331
332
333 void FrameLoaderClientQt::dispatchDidFinishLoad()
334 {
335     if (m_webFrame)
336         emit m_webFrame->loadDone(true);
337     if (m_frame->tree()->parent())
338         return;
339     m_webFrame->page()->d->updateNavigationActions();
340 }
341
342
343 void FrameLoaderClientQt::dispatchDidFirstLayout()
344 {
345     if (m_webFrame)
346         emit m_webFrame->initialLayoutComplete();
347 }
348
349
350 void FrameLoaderClientQt::dispatchShow()
351 {
352     notImplemented();
353 }
354
355
356 void FrameLoaderClientQt::cancelPolicyCheck()
357 {
358 //    qDebug() << "FrameLoaderClientQt::cancelPolicyCheck";
359     m_policyFunction = 0;
360 }
361
362
363 void FrameLoaderClientQt::dispatchWillSubmitForm(FramePolicyFunction function,
364                                                  PassRefPtr<FormState>)
365 {
366     notImplemented();
367     Q_ASSERT(!m_policyFunction);
368     // FIXME: This is surely too simple
369     callPolicyFunction(function, PolicyUse);
370 }
371
372
373 void FrameLoaderClientQt::dispatchDidLoadMainResource(DocumentLoader*)
374 {
375 }
376
377
378 void FrameLoaderClientQt::clearLoadingFromPageCache(DocumentLoader*)
379 {
380     notImplemented();
381 }
382
383
384 bool FrameLoaderClientQt::isLoadingFromPageCache(DocumentLoader*)
385 {
386     notImplemented();
387     return false;
388 }
389
390
391 void FrameLoaderClientQt::revertToProvisionalState(DocumentLoader*)
392 {
393     notImplemented();
394 }
395
396
397 void FrameLoaderClientQt::clearUnarchivingState(DocumentLoader*)
398 {
399     notImplemented();
400 }
401
402
403 void FrameLoaderClientQt::postProgressStartedNotification()
404 {
405     if (m_webFrame && m_frame->page())
406         emit loadStarted();
407     if (m_frame->tree()->parent())
408         return;
409     m_webFrame->page()->d->updateNavigationActions();
410 }
411
412 void FrameLoaderClientQt::postProgressEstimateChangedNotification()
413 {
414     if (m_webFrame && m_frame->page())
415         emit loadProgressChanged(qRound(m_frame->page()->progress()->estimatedProgress() * 100));
416 }
417
418 void FrameLoaderClientQt::postProgressFinishedNotification()
419 {
420     if (m_webFrame && m_frame->page())
421         emit loadFinished();
422 }
423
424 void FrameLoaderClientQt::setMainFrameDocumentReady(bool b)
425 {
426     // this is only interesting once we provide an external API for the DOM
427 }
428
429
430 void FrameLoaderClientQt::willChangeTitle(DocumentLoader*)
431 {
432     // no need for, dispatchDidReceiveTitle is the right callback
433 }
434
435
436 void FrameLoaderClientQt::didChangeTitle(DocumentLoader *)
437 {
438     // no need for, dispatchDidReceiveTitle is the right callback
439 }
440
441
442 void FrameLoaderClientQt::finishedLoading(DocumentLoader* loader)
443 {
444     if (m_firstData) {
445         FrameLoader *fl = loader->frameLoader();
446         fl->setEncoding(m_response.textEncodingName(), false);
447         m_firstData = false;
448     }
449 }
450
451
452 void FrameLoaderClientQt::finalSetupForReplace(DocumentLoader*)
453 {
454     notImplemented();
455 }
456
457
458 void FrameLoaderClientQt::setDefersLoading(bool)
459 {
460     notImplemented();
461 }
462
463
464 bool FrameLoaderClientQt::isArchiveLoadPending(ResourceLoader*) const
465 {
466     return false;
467 }
468
469
470 void FrameLoaderClientQt::cancelPendingArchiveLoad(ResourceLoader*)
471 {
472     notImplemented();
473 }
474
475
476 void FrameLoaderClientQt::clearArchivedResources()
477 {
478     // don't think we need to do anything here currently
479 }
480
481
482 bool FrameLoaderClientQt::canShowMIMEType(const String& MIMEType) const
483 {
484     if (MIMETypeRegistry::isSupportedImageMIMEType(MIMEType))
485         return true;
486
487     if (MIMETypeRegistry::isSupportedNonImageMIMEType(MIMEType))
488         return true;
489
490     return false;
491 }
492
493 bool FrameLoaderClientQt::representationExistsForURLScheme(const String& URLScheme) const
494 {
495     return false;
496 }
497
498
499 String FrameLoaderClientQt::generatedMIMETypeForURLScheme(const String& URLScheme) const
500 {
501     notImplemented();
502     return String();
503 }
504
505
506 void FrameLoaderClientQt::frameLoadCompleted()
507 {
508     // Note: Can be called multiple times.
509     // Even if already complete, we might have set a previous item on a frame that
510     // didn't do any data loading on the past transaction. Make sure to clear these out.
511     m_frame->loader()->setPreviousHistoryItem(0);
512 }
513
514
515 void FrameLoaderClientQt::restoreViewState()
516 {
517     notImplemented();
518 }
519
520
521 void FrameLoaderClientQt::provisionalLoadStarted()
522 {
523     // don't need to do anything here
524 }
525
526
527 bool FrameLoaderClientQt::shouldTreatURLAsSameAsCurrent(const KURL&) const
528 {
529     notImplemented();
530     return false;
531 }
532
533
534 void FrameLoaderClientQt::addHistoryItemForFragmentScroll()
535 {
536     notImplemented();
537 }
538
539
540 void FrameLoaderClientQt::didFinishLoad()
541 {
542 //     notImplemented();
543 }
544
545
546 void FrameLoaderClientQt::prepareForDataSourceReplacement()
547 {
548     m_frame->loader()->detachChildren();
549 }
550
551 void FrameLoaderClientQt::setTitle(const String&, const KURL&)
552 {
553     // no need for, dispatchDidReceiveTitle is the right callback
554 }
555
556
557 String FrameLoaderClientQt::userAgent(const KURL& url)
558 {
559     if (m_webFrame) {
560         return m_webFrame->page()->userAgentFor(QUrl((QString)url.string()));
561     }
562     return String();
563 }
564
565 void FrameLoaderClientQt::dispatchDidReceiveIcon()
566 {
567     if (m_webFrame) {
568         emit m_webFrame->iconLoaded();
569     }
570 }
571
572 void FrameLoaderClientQt::frameLoaderDestroyed()
573 {
574     Q_ASSERT(m_webFrame == 0);
575     Q_ASSERT(m_frame == 0);
576     delete this;
577 }
578
579 bool FrameLoaderClientQt::canHandleRequest(const WebCore::ResourceRequest&) const
580 {
581     return true;
582 }
583
584 void FrameLoaderClientQt::windowObjectCleared()
585 {
586     if (m_webFrame)
587         emit m_webFrame->cleared();
588 }
589
590 void FrameLoaderClientQt::didPerformFirstNavigation() const
591 {
592     if (m_frame->tree()->parent())
593         return;
594     m_webFrame->page()->d->updateNavigationActions();
595 }
596
597 void FrameLoaderClientQt::registerForIconNotification(bool)
598 {
599     notImplemented();
600 }
601
602 void FrameLoaderClientQt::updateGlobalHistoryForStandardLoad(const WebCore::KURL& url)
603 {
604     QWebHistoryInterface *history = QWebHistoryInterface::defaultInterface();
605     if (history)
606         history->addHistoryEntry(url.prettyURL());
607 }
608
609 void FrameLoaderClientQt::updateGlobalHistoryForReload(const WebCore::KURL&)
610 {
611     notImplemented();
612 }
613
614 bool FrameLoaderClientQt::shouldGoToHistoryItem(WebCore::HistoryItem *item) const
615 {
616     if (item) {
617         return true;
618     }
619     return false;
620 }
621
622 void FrameLoaderClientQt::saveViewStateToItem(WebCore::HistoryItem*)
623 {
624     notImplemented();
625 }
626
627 bool FrameLoaderClientQt::canCachePage() const
628 {
629     // don't do any caching for now
630     return false;
631 }
632
633 void FrameLoaderClientQt::setMainDocumentError(WebCore::DocumentLoader* loader, const WebCore::ResourceError& error)
634 {
635     if (m_firstData) {
636         loader->frameLoader()->setEncoding(m_response.textEncodingName(), false);
637         m_firstData = false;
638     }
639 }
640
641 void FrameLoaderClientQt::committedLoad(WebCore::DocumentLoader* loader, const char* data, int length)
642 {
643     if (!m_frame)
644         return;
645     FrameLoader *fl = loader->frameLoader();
646     if (m_firstData) {
647         fl->setEncoding(m_response.textEncodingName(), false);
648         m_firstData = false;
649     }
650     fl->addData(data, length);
651 }
652
653 WebCore::ResourceError FrameLoaderClientQt::cancelledError(const WebCore::ResourceRequest& request)
654 {
655     return ResourceError("Error", -999, request.url().prettyURL(),
656             QCoreApplication::translate("QWebFrame", "Request cancelled", 0, QCoreApplication::UnicodeUTF8));
657 }
658
659 // copied from WebKit/Misc/WebKitErrors[Private].h
660 enum {
661     WebKitErrorCannotShowMIMEType =                             100,
662     WebKitErrorCannotShowURL =                                  101,
663     WebKitErrorFrameLoadInterruptedByPolicyChange =             102,
664     WebKitErrorCannotUseRestrictedPort = 103, 
665     WebKitErrorCannotFindPlugIn =                               200,
666     WebKitErrorCannotLoadPlugIn =                               201,
667     WebKitErrorJavaUnavailable =                                202,
668 };
669     
670 WebCore::ResourceError FrameLoaderClientQt::blockedError(const WebCore::ResourceRequest& request)
671 {
672     return ResourceError("Error", WebKitErrorCannotUseRestrictedPort, request.url().prettyURL(),
673             QCoreApplication::translate("QWebFrame", "Request blocked", 0, QCoreApplication::UnicodeUTF8));
674 }
675
676
677 WebCore::ResourceError FrameLoaderClientQt::cannotShowURLError(const WebCore::ResourceRequest& request)
678 {
679     return ResourceError("Error", WebKitErrorCannotShowURL, request.url().string(),
680             QCoreApplication::translate("QWebFrame", "Cannot show URL", 0, QCoreApplication::UnicodeUTF8));
681 }
682
683 WebCore::ResourceError FrameLoaderClientQt::interruptForPolicyChangeError(const WebCore::ResourceRequest& request)
684 {
685     return ResourceError("Error", WebKitErrorFrameLoadInterruptedByPolicyChange, request.url().string(),
686             QCoreApplication::translate("QWebFrame", "Frame load interruped by policy change", 0, QCoreApplication::UnicodeUTF8));
687 }
688
689 WebCore::ResourceError FrameLoaderClientQt::cannotShowMIMETypeError(const WebCore::ResourceResponse& response)
690 {
691     return ResourceError("Error", WebKitErrorCannotShowMIMEType, response.url().string(),
692             QCoreApplication::translate("QWebFrame", "Cannot show mimetype", 0, QCoreApplication::UnicodeUTF8));
693 }
694
695 WebCore::ResourceError FrameLoaderClientQt::fileDoesNotExistError(const WebCore::ResourceResponse& response)
696 {
697     return ResourceError("Error", -998 /* ### */, response.url().string(),
698             QCoreApplication::translate("QWebFrame", "File does not exist", 0, QCoreApplication::UnicodeUTF8));
699 }
700
701 bool FrameLoaderClientQt::shouldFallBack(const WebCore::ResourceError&)
702 {
703     notImplemented();
704     return false;
705 }
706
707 WTF::PassRefPtr<WebCore::DocumentLoader> FrameLoaderClientQt::createDocumentLoader(const WebCore::ResourceRequest& request, const SubstituteData& substituteData)
708 {
709     RefPtr<DocumentLoader> loader = new DocumentLoader(request, substituteData);
710     return loader.release();
711 }
712
713 void FrameLoaderClientQt::download(WebCore::ResourceHandle* handle, const WebCore::ResourceRequest&, const WebCore::ResourceRequest&, const WebCore::ResourceResponse&)
714 {
715 #if QT_VERSION >= 0x040400
716     QNetworkReplyHandler* handler = handle->getInternal()->m_job;
717     QNetworkReply* reply = handler->release();
718     if (reply) {
719         QWebPage *page = m_webFrame->page();
720         if (page->receivers(SIGNAL(handleUnsupportedContent(QNetworkReply *))))
721             emit m_webFrame->page()->handleUnsupportedContent(reply);
722         else
723             reply->abort();
724     }
725 #endif
726 }
727
728 void FrameLoaderClientQt::assignIdentifierToInitialRequest(unsigned long identifier, WebCore::DocumentLoader*, const WebCore::ResourceRequest&)
729 {
730 }
731
732 void FrameLoaderClientQt::dispatchWillSendRequest(WebCore::DocumentLoader*, unsigned long, WebCore::ResourceRequest& request, const WebCore::ResourceResponse& response)
733 {
734     // seems like the Mac code doesn't do anything here by default neither
735     //qDebug() << "FrameLoaderClientQt::dispatchWillSendRequest" << request.isNull() << request.url().string`();
736 }
737
738 void FrameLoaderClientQt::dispatchDidReceiveAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&)
739 {
740     notImplemented();
741 }
742
743 void FrameLoaderClientQt::dispatchDidCancelAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&)
744 {
745     notImplemented();
746 }
747
748 void FrameLoaderClientQt::dispatchDidReceiveResponse(WebCore::DocumentLoader*, unsigned long, const WebCore::ResourceResponse& response)
749 {
750
751     m_response = response;
752     m_firstData = true;
753     //qDebug() << "    got response from" << response.url().string();
754 }
755
756 void FrameLoaderClientQt::dispatchDidReceiveContentLength(WebCore::DocumentLoader*, unsigned long, int)
757 {
758 }
759
760 void FrameLoaderClientQt::dispatchDidFinishLoading(WebCore::DocumentLoader* loader, unsigned long)
761 {
762 }
763
764 void FrameLoaderClientQt::dispatchDidFailLoading(WebCore::DocumentLoader* loader, unsigned long, const WebCore::ResourceError&)
765 {
766     if (m_firstData) {
767         FrameLoader *fl = loader->frameLoader();
768         fl->setEncoding(m_response.textEncodingName(), false);
769         m_firstData = false;
770     }
771 }
772
773 bool FrameLoaderClientQt::dispatchDidLoadResourceFromMemoryCache(WebCore::DocumentLoader*, const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, int)
774 {
775     notImplemented();
776     return false;
777 }
778
779 void FrameLoaderClientQt::dispatchDidFailProvisionalLoad(const WebCore::ResourceError&)
780 {
781     if (m_webFrame)
782         emit m_webFrame->loadDone(false);
783 }
784
785 void FrameLoaderClientQt::dispatchDidFailLoad(const WebCore::ResourceError&)
786 {
787     if (m_webFrame)
788         emit m_webFrame->loadDone(false);
789 }
790
791 WebCore::Frame* FrameLoaderClientQt::dispatchCreatePage()
792 {
793     if (!m_webFrame)
794         return 0;
795     QWebPage *newPage = m_webFrame->page()->createWindow();
796     if (!newPage)
797         return 0;
798     return newPage->mainFrame()->d->frame.get();
799 }
800
801 void FrameLoaderClientQt::dispatchDecidePolicyForMIMEType(FramePolicyFunction function, const WebCore::String& MIMEType, const WebCore::ResourceRequest&)
802 {
803     // we need to call directly here
804     Q_ASSERT(!m_policyFunction);
805     m_policyFunction = function;
806     if (canShowMIMEType(MIMEType))
807         slotCallPolicyFunction(PolicyUse);
808     else
809         slotCallPolicyFunction(PolicyDownload);
810 }
811
812 void FrameLoaderClientQt::dispatchDecidePolicyForNewWindowAction(FramePolicyFunction function, const WebCore::NavigationAction&, const WebCore::ResourceRequest&, const WebCore::String&)
813 {
814     Q_ASSERT(!m_policyFunction);
815     m_policyFunction = function;
816     slotCallPolicyFunction(PolicyUse);
817 }
818
819 void FrameLoaderClientQt::dispatchDecidePolicyForNavigationAction(FramePolicyFunction function, const WebCore::NavigationAction& action, const WebCore::ResourceRequest& request)
820 {
821     Q_ASSERT(!m_policyFunction);
822     m_policyFunction = function;
823     if (m_webFrame) {
824 #if QT_VERSION < 0x040400
825         QWebNetworkRequest r(request);
826 #else
827         QNetworkRequest r(request.toNetworkRequest());
828 #endif
829         QWebPage *page = m_webFrame->page();
830
831         if (page->d->navigationRequested(m_webFrame, r, QWebPage::NavigationType(action.type())) ==
832             QWebPage::IgnoreNavigationRequest) {
833             slotCallPolicyFunction(PolicyIgnore);
834             return;
835         }
836     }
837     slotCallPolicyFunction(PolicyUse);
838     return;
839 }
840
841 void FrameLoaderClientQt::dispatchUnableToImplementPolicy(const WebCore::ResourceError&)
842 {
843     notImplemented();
844 }
845
846 void FrameLoaderClientQt::startDownload(const WebCore::ResourceRequest& request)
847 {
848 #if QT_VERSION >= 0x040400
849     QWebPage *page = m_webFrame->page();
850     emit m_webFrame->page()->download(request.toNetworkRequest());
851 #endif
852 }
853
854 bool FrameLoaderClientQt::willUseArchive(WebCore::ResourceLoader*, const WebCore::ResourceRequest&, const WebCore::KURL&) const
855 {
856     return false;
857 }
858
859 PassRefPtr<Frame> FrameLoaderClientQt::createFrame(const KURL& url, const String& name, HTMLFrameOwnerElement* ownerElement,
860                                         const String& referrer, bool allowsScrolling, int marginWidth, int marginHeight)
861 {
862     QWebFrameData frameData;
863     frameData.url = url;
864     frameData.name = name;
865     frameData.ownerElement = ownerElement;
866     frameData.referrer = referrer;
867     frameData.allowsScrolling = allowsScrolling;
868     frameData.marginWidth = marginWidth;
869     frameData.marginHeight = marginHeight;
870
871     QWebFrame* webFrame = new QWebFrame(m_webFrame, &frameData);
872     emit m_webFrame->page()->frameCreated(webFrame);
873
874     RefPtr<Frame> childFrame = adoptRef(webFrame->d->frame.get());
875
876     // FIXME: All of the below should probably be moved over into WebCore
877     childFrame->tree()->setName(name);
878     m_frame->tree()->appendChild(childFrame);
879     // ### set override encoding if we have one
880
881     FrameLoadType loadType = m_frame->loader()->loadType();
882     FrameLoadType childLoadType = FrameLoadTypeRedirectWithLockedHistory;
883
884     childFrame->loader()->load(frameData.url, frameData.referrer, childLoadType,
885                              String(), 0, 0);
886
887     // The frame's onload handler may have removed it from the document.
888     if (!childFrame->tree()->parent())
889         return 0;
890
891     return childFrame.release();
892 }
893
894 ObjectContentType FrameLoaderClientQt::objectContentType(const KURL& url, const String& _mimeType)
895 {
896 //    qDebug()<<" ++++++++++++++++ url is "<<url.prettyURL()<<", mime = "<<_mimeType;
897     if (_mimeType == "application/x-qt-plugin" || _mimeType == "application/x-qt-styled-widget")
898         return ObjectContentOtherPlugin;
899
900     if (url.isEmpty())
901         return ObjectContentNone;
902
903     String mimeType = _mimeType;
904     if (!mimeType.length()) {
905         QFileInfo fi(url.path());
906         mimeType = MIMETypeRegistry::getMIMETypeForExtension(fi.suffix());
907     }
908
909     if (!mimeType.length())
910         return ObjectContentFrame;
911
912     if (MIMETypeRegistry::isSupportedImageMIMEType(mimeType))
913         return ObjectContentImage;
914
915     // ### FIXME Qt 4.4
916 #if QT_VERSION < 0x040400
917     if (QWebFactoryLoader::self()->supportsMimeType(mimeType))
918         return ObjectContentNetscapePlugin;
919 #endif
920
921     if (MIMETypeRegistry::isSupportedNonImageMIMEType(mimeType))
922         return ObjectContentFrame;
923
924     if (url.protocol() == "about")
925         return ObjectContentFrame;
926
927     return ObjectContentNone;
928 }
929
930 static const CSSPropertyID qstyleSheetProperties[] = {
931     CSS_PROP_COLOR,
932     CSS_PROP_FONT_FAMILY,
933     CSS_PROP_FONT_SIZE,
934     CSS_PROP_FONT_STYLE,
935     CSS_PROP_FONT_WEIGHT
936 };
937
938 const unsigned numqStyleSheetProperties = sizeof(qstyleSheetProperties) / sizeof(qstyleSheetProperties[0]);
939
940 Widget* FrameLoaderClientQt::createPlugin(const IntSize&, Element* element, const KURL& url, const Vector<String>& paramNames,
941                                           const Vector<String>& paramValues, const String& mimeType, bool loadManually)
942 {
943 //     qDebug()<<"------ Creating plugin in FrameLoaderClientQt::createPlugin for "<<url.prettyURL() << mimeType;
944 //     qDebug()<<"------\t url = "<<url.prettyURL();
945     QStringList params;
946     QStringList values;
947     for (int i = 0; i < paramNames.size(); ++i)
948         params.append(paramNames[i]);
949     for (int i = 0; i < paramValues.size(); ++i)
950         values.append(paramValues[i]);
951
952     QString urlStr(url.string());
953     QUrl qurl = urlStr;
954
955     QObject *object = 0;
956
957     if (mimeType == "application/x-qt-plugin" || mimeType == "application/x-qt-styled-widget") {
958         object = m_webFrame->page()->createPlugin(element->getAttribute("classid"), qurl, params, values);
959         QWidget *widget = qobject_cast<QWidget *>(object);
960         if (widget && mimeType == "application/x-qt-styled-widget") {
961             CSSComputedStyleDeclaration cssDecl(element);
962
963             QString styleSheet = element->getAttribute("style");
964             if (!styleSheet.isEmpty())
965                 styleSheet += QLatin1Char(';');
966
967             for (int i = 0; i < numqStyleSheetProperties; ++i) {
968                 CSSPropertyID property = qstyleSheetProperties[i];
969
970                 styleSheet += ::getPropertyName(property);
971                 styleSheet += QLatin1Char(':');
972                 styleSheet += cssDecl.getPropertyValue(property);
973                 styleSheet += QLatin1Char(';');
974             }
975
976             widget->setStyleSheet(styleSheet);
977         }
978     }
979
980     // ### FIXME: qt 4.4
981 #if QT_VERSION < 0x040400
982     if (!object)
983         object = QWebFactoryLoader::self()->create(m_webFrame, qurl, mimeType, params, values);
984 #endif
985
986     if (object) {
987         QWidget *widget = qobject_cast<QWidget *>(object);
988         QWidget *view = m_webFrame->page()->view();
989         if (widget && view) {
990             widget->setParent(view);
991             Widget* w= new Widget();
992             w->setNativeWidget(widget);
993             return w;
994         }
995         // FIXME: make things work for widgetless plugins as well
996         delete object;
997     }
998
999     return 0;
1000 }
1001
1002 void FrameLoaderClientQt::redirectDataToPlugin(Widget* pluginWidget)
1003 {
1004     notImplemented();
1005     return;
1006 }
1007
1008 Widget* FrameLoaderClientQt::createJavaAppletWidget(const IntSize&, Element*, const KURL& baseURL,
1009                                                     const Vector<String>& paramNames, const Vector<String>& paramValues)
1010 {
1011     notImplemented();
1012     return 0;
1013 }
1014
1015 String FrameLoaderClientQt::overrideMediaType() const
1016 {
1017     return String();
1018 }
1019
1020 QString FrameLoaderClientQt::chooseFile(const QString& oldFile)
1021 {
1022     return webFrame()->page()->chooseFile(webFrame(), oldFile);
1023 }
1024
1025
1026 }
1027
1028 #include "moc_FrameLoaderClientQt.cpp"