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