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