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