2008-04-02 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     return true;
485 }
486
487 void FrameLoaderClientQt::saveViewStateToItem(WebCore::HistoryItem*)
488 {
489     notImplemented();
490 }
491
492 bool FrameLoaderClientQt::canCachePage() const
493 {
494     // don't do any caching for now
495     return false;
496 }
497
498 void FrameLoaderClientQt::setMainDocumentError(WebCore::DocumentLoader* loader, const WebCore::ResourceError& error)
499 {
500     if (m_firstData) {
501         loader->frameLoader()->setEncoding(m_response.textEncodingName(), false);
502         m_firstData = false;
503     }
504 }
505
506 void FrameLoaderClientQt::committedLoad(WebCore::DocumentLoader* loader, const char* data, int length)
507 {
508     if (!m_frame)
509         return;
510     FrameLoader *fl = loader->frameLoader();
511     if (m_firstData) {
512         fl->setEncoding(m_response.textEncodingName(), false);
513         m_firstData = false;
514     }
515     fl->addData(data, length);
516 }
517
518 WebCore::ResourceError FrameLoaderClientQt::cancelledError(const WebCore::ResourceRequest& request)
519 {
520     return ResourceError("Error", -999, request.url().prettyURL(),
521             QCoreApplication::translate("QWebFrame", "Request cancelled", 0, QCoreApplication::UnicodeUTF8));
522 }
523
524 // copied from WebKit/Misc/WebKitErrors[Private].h
525 enum {
526     WebKitErrorCannotShowMIMEType =                             100,
527     WebKitErrorCannotShowURL =                                  101,
528     WebKitErrorFrameLoadInterruptedByPolicyChange =             102,
529     WebKitErrorCannotUseRestrictedPort = 103, 
530     WebKitErrorCannotFindPlugIn =                               200,
531     WebKitErrorCannotLoadPlugIn =                               201,
532     WebKitErrorJavaUnavailable =                                202,
533 };
534     
535 WebCore::ResourceError FrameLoaderClientQt::blockedError(const WebCore::ResourceRequest& request)
536 {
537     return ResourceError("Error", WebKitErrorCannotUseRestrictedPort, request.url().prettyURL(),
538             QCoreApplication::translate("QWebFrame", "Request blocked", 0, QCoreApplication::UnicodeUTF8));
539 }
540
541
542 WebCore::ResourceError FrameLoaderClientQt::cannotShowURLError(const WebCore::ResourceRequest& request)
543 {
544     return ResourceError("Error", WebKitErrorCannotShowURL, request.url().string(),
545             QCoreApplication::translate("QWebFrame", "Cannot show URL", 0, QCoreApplication::UnicodeUTF8));
546 }
547
548 WebCore::ResourceError FrameLoaderClientQt::interruptForPolicyChangeError(const WebCore::ResourceRequest& request)
549 {
550     return ResourceError("Error", WebKitErrorFrameLoadInterruptedByPolicyChange, request.url().string(),
551             QCoreApplication::translate("QWebFrame", "Frame load interruped by policy change", 0, QCoreApplication::UnicodeUTF8));
552 }
553
554 WebCore::ResourceError FrameLoaderClientQt::cannotShowMIMETypeError(const WebCore::ResourceResponse& response)
555 {
556     return ResourceError("Error", WebKitErrorCannotShowMIMEType, response.url().string(),
557             QCoreApplication::translate("QWebFrame", "Cannot show mimetype", 0, QCoreApplication::UnicodeUTF8));
558 }
559
560 WebCore::ResourceError FrameLoaderClientQt::fileDoesNotExistError(const WebCore::ResourceResponse& response)
561 {
562     return ResourceError("Error", -998 /* ### */, response.url().string(),
563             QCoreApplication::translate("QWebFrame", "File does not exist", 0, QCoreApplication::UnicodeUTF8));
564 }
565
566 bool FrameLoaderClientQt::shouldFallBack(const WebCore::ResourceError&)
567 {
568     notImplemented();
569     return false;
570 }
571
572 WTF::PassRefPtr<WebCore::DocumentLoader> FrameLoaderClientQt::createDocumentLoader(const WebCore::ResourceRequest& request, const SubstituteData& substituteData)
573 {
574     RefPtr<DocumentLoader> loader = new DocumentLoader(request, substituteData);
575     return loader.release();
576 }
577
578 void FrameLoaderClientQt::download(WebCore::ResourceHandle* handle, const WebCore::ResourceRequest&, const WebCore::ResourceRequest&, const WebCore::ResourceResponse&)
579 {
580 #if QT_VERSION >= 0x040400
581     if (!m_webFrame)
582         return;
583
584     QNetworkReplyHandler* handler = handle->getInternal()->m_job;
585     QNetworkReply* reply = handler->release();
586     if (reply) {
587         QWebPage *page = m_webFrame->page();
588         if (page->receivers(SIGNAL(handleUnsupportedContent(QNetworkReply *))))
589             emit m_webFrame->page()->handleUnsupportedContent(reply);
590         else
591             reply->abort();
592     }
593 #endif
594 }
595
596 void FrameLoaderClientQt::assignIdentifierToInitialRequest(unsigned long identifier, WebCore::DocumentLoader*, const WebCore::ResourceRequest&)
597 {
598 }
599
600 void FrameLoaderClientQt::dispatchWillSendRequest(WebCore::DocumentLoader*, unsigned long, WebCore::ResourceRequest& request, const WebCore::ResourceResponse& response)
601 {
602     // seems like the Mac code doesn't do anything here by default neither
603     //qDebug() << "FrameLoaderClientQt::dispatchWillSendRequest" << request.isNull() << request.url().string`();
604 }
605
606 void FrameLoaderClientQt::dispatchDidReceiveAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&)
607 {
608     notImplemented();
609 }
610
611 void FrameLoaderClientQt::dispatchDidCancelAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&)
612 {
613     notImplemented();
614 }
615
616 void FrameLoaderClientQt::dispatchDidReceiveResponse(WebCore::DocumentLoader*, unsigned long, const WebCore::ResourceResponse& response)
617 {
618
619     m_response = response;
620     m_firstData = true;
621     //qDebug() << "    got response from" << response.url().string();
622 }
623
624 void FrameLoaderClientQt::dispatchDidReceiveContentLength(WebCore::DocumentLoader*, unsigned long, int)
625 {
626 }
627
628 void FrameLoaderClientQt::dispatchDidFinishLoading(WebCore::DocumentLoader* loader, unsigned long)
629 {
630 }
631
632 void FrameLoaderClientQt::dispatchDidFailLoading(WebCore::DocumentLoader* loader, unsigned long, const WebCore::ResourceError&)
633 {
634     if (m_firstData) {
635         FrameLoader *fl = loader->frameLoader();
636         fl->setEncoding(m_response.textEncodingName(), false);
637         m_firstData = false;
638     }
639 }
640
641 bool FrameLoaderClientQt::dispatchDidLoadResourceFromMemoryCache(WebCore::DocumentLoader*, const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, int)
642 {
643     notImplemented();
644     return false;
645 }
646
647 void FrameLoaderClientQt::dispatchDidFailProvisionalLoad(const WebCore::ResourceError&)
648 {
649     if (m_webFrame)
650         emit m_webFrame->loadDone(false);
651 }
652
653 void FrameLoaderClientQt::dispatchDidFailLoad(const WebCore::ResourceError&)
654 {
655     if (m_webFrame)
656         emit m_webFrame->loadDone(false);
657 }
658
659 WebCore::Frame* FrameLoaderClientQt::dispatchCreatePage()
660 {
661     if (!m_webFrame)
662         return 0;
663     QWebPage *newPage = m_webFrame->page()->createWindow();
664     if (!newPage)
665         return 0;
666     return newPage->mainFrame()->d->frame;
667 }
668
669 void FrameLoaderClientQt::dispatchDecidePolicyForMIMEType(FramePolicyFunction function, const WebCore::String& MIMEType, const WebCore::ResourceRequest&)
670 {
671     // we need to call directly here
672     Q_ASSERT(!m_policyFunction);
673     m_policyFunction = function;
674     if (canShowMIMEType(MIMEType))
675         slotCallPolicyFunction(PolicyUse);
676     else
677         slotCallPolicyFunction(PolicyDownload);
678 }
679
680 void FrameLoaderClientQt::dispatchDecidePolicyForNewWindowAction(FramePolicyFunction function, const WebCore::NavigationAction&, const WebCore::ResourceRequest&, const WebCore::String&)
681 {
682     Q_ASSERT(!m_policyFunction);
683     m_policyFunction = function;
684     slotCallPolicyFunction(PolicyUse);
685 }
686
687 void FrameLoaderClientQt::dispatchDecidePolicyForNavigationAction(FramePolicyFunction function, const WebCore::NavigationAction& action, const WebCore::ResourceRequest& request)
688 {
689     Q_ASSERT(!m_policyFunction);
690     m_policyFunction = function;
691     if (m_webFrame) {
692 #if QT_VERSION < 0x040400
693         QWebNetworkRequest r(request);
694 #else
695         QNetworkRequest r(request.toNetworkRequest());
696 #endif
697         QWebPage *page = m_webFrame->page();
698
699         if (page->d->navigationRequested(m_webFrame, r, QWebPage::NavigationType(action.type())) ==
700             QWebPage::IgnoreNavigationRequest) {
701             slotCallPolicyFunction(PolicyIgnore);
702             return;
703         }
704     }
705     slotCallPolicyFunction(PolicyUse);
706     return;
707 }
708
709 void FrameLoaderClientQt::dispatchUnableToImplementPolicy(const WebCore::ResourceError&)
710 {
711     notImplemented();
712 }
713
714 void FrameLoaderClientQt::startDownload(const WebCore::ResourceRequest& request)
715 {
716 #if QT_VERSION >= 0x040400
717     if (!m_webFrame)
718         return;
719
720     QWebPage *page = m_webFrame->page();
721     emit m_webFrame->page()->download(request.toNetworkRequest());
722 #endif
723 }
724
725 PassRefPtr<Frame> FrameLoaderClientQt::createFrame(const KURL& url, const String& name, HTMLFrameOwnerElement* ownerElement,
726                                         const String& referrer, bool allowsScrolling, int marginWidth, int marginHeight)
727 {
728     if (!m_webFrame)
729         return 0;
730
731     QWebFrameData frameData;
732     frameData.url = url;
733     frameData.name = name;
734     frameData.ownerElement = ownerElement;
735     frameData.referrer = referrer;
736     frameData.allowsScrolling = allowsScrolling;
737     frameData.marginWidth = marginWidth;
738     frameData.marginHeight = marginHeight;
739
740     QWebFrame* webFrame = new QWebFrame(m_webFrame, &frameData);
741     emit m_webFrame->page()->frameCreated(webFrame);
742
743     RefPtr<Frame> childFrame = adoptRef(webFrame->d->frame);
744
745     // FIXME: All of the below should probably be moved over into WebCore
746     childFrame->tree()->setName(name);
747     m_frame->tree()->appendChild(childFrame);
748     // ### set override encoding if we have one
749
750     FrameLoadType loadType = m_frame->loader()->loadType();
751     FrameLoadType childLoadType = FrameLoadTypeRedirectWithLockedHistory;
752
753     childFrame->loader()->load(frameData.url, frameData.referrer, childLoadType,
754                              String(), 0, 0);
755
756     // The frame's onload handler may have removed it from the document.
757     if (!childFrame->tree()->parent())
758         return 0;
759
760     return childFrame.release();
761 }
762
763 ObjectContentType FrameLoaderClientQt::objectContentType(const KURL& url, const String& _mimeType)
764 {
765 //    qDebug()<<" ++++++++++++++++ url is "<<url.prettyURL()<<", mime = "<<_mimeType;
766     if (_mimeType == "application/x-qt-plugin" || _mimeType == "application/x-qt-styled-widget")
767         return ObjectContentOtherPlugin;
768
769     if (url.isEmpty())
770         return ObjectContentNone;
771
772     String mimeType = _mimeType;
773     if (!mimeType.length()) {
774         QFileInfo fi(url.path());
775         mimeType = MIMETypeRegistry::getMIMETypeForExtension(fi.suffix());
776     }
777
778     if (!mimeType.length())
779         return ObjectContentFrame;
780
781     if (MIMETypeRegistry::isSupportedImageMIMEType(mimeType))
782         return ObjectContentImage;
783
784     if (m_frame->page() && m_frame->page()->pluginData()->supportsMimeType(mimeType))
785         return ObjectContentOtherPlugin;
786
787     if (MIMETypeRegistry::isSupportedNonImageMIMEType(mimeType))
788         return ObjectContentFrame;
789
790     if (url.protocol() == "about")
791         return ObjectContentFrame;
792
793     return ObjectContentNone;
794 }
795
796 static const CSSPropertyID qstyleSheetProperties[] = {
797     CSSPropertyColor,
798     CSSPropertyFontFamily,
799     CSSPropertyFontSize,
800     CSSPropertyFontStyle,
801     CSSPropertyFontWeight
802 };
803
804 const unsigned numqStyleSheetProperties = sizeof(qstyleSheetProperties) / sizeof(qstyleSheetProperties[0]);
805
806 Widget* FrameLoaderClientQt::createPlugin(const IntSize&, Element* element, const KURL& url, const Vector<String>& paramNames,
807                                           const Vector<String>& paramValues, const String& mimeType, bool loadManually)
808 {
809 //     qDebug()<<"------ Creating plugin in FrameLoaderClientQt::createPlugin for "<<url.prettyURL() << mimeType;
810 //     qDebug()<<"------\t url = "<<url.prettyURL();
811
812     if (!m_webFrame)
813         return 0;
814
815     QStringList params;
816     QStringList values;
817     for (int i = 0; i < paramNames.size(); ++i)
818         params.append(paramNames[i]);
819     for (int i = 0; i < paramValues.size(); ++i)
820         values.append(paramValues[i]);
821
822     QString urlStr(url.string());
823     QUrl qurl = urlStr;
824
825     QObject *object = 0;
826
827     if (mimeType == "application/x-qt-plugin" || mimeType == "application/x-qt-styled-widget") {
828         object = m_webFrame->page()->createPlugin(element->getAttribute("classid"), qurl, params, values);
829         QWidget *widget = qobject_cast<QWidget *>(object);
830         if (widget && mimeType == "application/x-qt-styled-widget") {
831             CSSComputedStyleDeclaration cssDecl(element);
832
833             QString styleSheet = element->getAttribute("style");
834             if (!styleSheet.isEmpty())
835                 styleSheet += QLatin1Char(';');
836
837             for (int i = 0; i < numqStyleSheetProperties; ++i) {
838                 CSSPropertyID property = qstyleSheetProperties[i];
839
840                 styleSheet += ::getPropertyName(property);
841                 styleSheet += QLatin1Char(':');
842                 styleSheet += cssDecl.getPropertyValue(property);
843                 styleSheet += QLatin1Char(';');
844             }
845
846             widget->setStyleSheet(styleSheet);
847         }
848     }
849
850 #if QT_VERSION >= 0x040400
851     if (!object) {
852         QWebPluginFactory* factory = m_webFrame->page()->pluginFactory();
853         if (factory)
854             object = factory->create(mimeType, qurl, params, values);
855     }
856 #endif
857
858     if (object) {
859         QWidget *widget = qobject_cast<QWidget *>(object);
860         QWidget *view = m_webFrame->page()->view();
861         if (widget && view) {
862             widget->setParent(view);
863             Widget* w= new Widget();
864             w->setNativeWidget(widget);
865             return w;
866         }
867         // FIXME: make things work for widgetless plugins as well
868         delete object;
869     }
870
871     return 0;
872 }
873
874 void FrameLoaderClientQt::redirectDataToPlugin(Widget* pluginWidget)
875 {
876     notImplemented();
877     return;
878 }
879
880 Widget* FrameLoaderClientQt::createJavaAppletWidget(const IntSize&, Element*, const KURL& baseURL,
881                                                     const Vector<String>& paramNames, const Vector<String>& paramValues)
882 {
883     notImplemented();
884     return 0;
885 }
886
887 String FrameLoaderClientQt::overrideMediaType() const
888 {
889     return String();
890 }
891
892 QString FrameLoaderClientQt::chooseFile(const QString& oldFile)
893 {
894     return webFrame()->page()->chooseFile(webFrame(), oldFile);
895 }
896
897
898 }
899
900 #include "moc_FrameLoaderClientQt.cpp"