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