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