4d70d25e57f1b0aca8dbd80b0ce535422bb63178
[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     // ### hack
242     emit m_webFrame->urlChanged(m_webFrame->url());
243     emit titleChanged(title);
244 }
245
246
247 void FrameLoaderClientQt::dispatchDidCommitLoad()
248 {
249     if (m_frame->tree()->parent())
250         return;
251     m_webFrame->page()->d->updateNavigationActions();
252 }
253
254
255 void FrameLoaderClientQt::dispatchDidFinishDocumentLoad()
256 {
257     if (m_frame->tree()->parent())
258         return;
259     m_webFrame->page()->d->updateNavigationActions();
260 }
261
262
263 void FrameLoaderClientQt::dispatchDidFinishLoad()
264 {
265     if (m_webFrame)
266         emit m_webFrame->loadDone(true);
267     if (m_frame->tree()->parent())
268         return;
269     m_webFrame->page()->d->updateNavigationActions();
270 }
271
272
273 void FrameLoaderClientQt::dispatchDidFirstLayout()
274 {
275     if (m_webFrame)
276         emit m_webFrame->initialLayoutComplete();
277 }
278
279
280 void FrameLoaderClientQt::dispatchShow()
281 {
282     notImplemented();
283 }
284
285
286 void FrameLoaderClientQt::cancelPolicyCheck()
287 {
288 //    qDebug() << "FrameLoaderClientQt::cancelPolicyCheck";
289     m_policyFunction = 0;
290 }
291
292
293 void FrameLoaderClientQt::dispatchWillSubmitForm(FramePolicyFunction function,
294                                                  PassRefPtr<FormState>)
295 {
296     notImplemented();
297     Q_ASSERT(!m_policyFunction);
298     // FIXME: This is surely too simple
299     callPolicyFunction(function, PolicyUse);
300 }
301
302
303 void FrameLoaderClientQt::dispatchDidLoadMainResource(DocumentLoader*)
304 {
305 }
306
307
308 void FrameLoaderClientQt::revertToProvisionalState(DocumentLoader*)
309 {
310     notImplemented();
311 }
312
313
314 void FrameLoaderClientQt::postProgressStartedNotification()
315 {
316     if (m_webFrame && m_frame->page())
317         emit loadStarted();
318     if (m_frame->tree()->parent())
319         return;
320     m_webFrame->page()->d->updateNavigationActions();
321 }
322
323 void FrameLoaderClientQt::postProgressEstimateChangedNotification()
324 {
325     if (m_webFrame && m_frame->page())
326         emit loadProgressChanged(qRound(m_frame->page()->progress()->estimatedProgress() * 100));
327 }
328
329 void FrameLoaderClientQt::postProgressFinishedNotification()
330 {
331     if (m_webFrame && m_frame->page())
332         emit loadFinished();
333 }
334
335 void FrameLoaderClientQt::setMainFrameDocumentReady(bool b)
336 {
337     // this is only interesting once we provide an external API for the DOM
338 }
339
340
341 void FrameLoaderClientQt::willChangeTitle(DocumentLoader*)
342 {
343     // no need for, dispatchDidReceiveTitle is the right callback
344 }
345
346
347 void FrameLoaderClientQt::didChangeTitle(DocumentLoader *)
348 {
349     // no need for, dispatchDidReceiveTitle is the right callback
350 }
351
352
353 void FrameLoaderClientQt::finishedLoading(DocumentLoader* loader)
354 {
355     if (m_firstData) {
356         FrameLoader *fl = loader->frameLoader();
357         fl->setEncoding(m_response.textEncodingName(), false);
358         m_firstData = false;
359     }
360 }
361
362
363 bool FrameLoaderClientQt::canShowMIMEType(const String& MIMEType) const
364 {
365     if (MIMETypeRegistry::isSupportedImageMIMEType(MIMEType))
366         return true;
367
368     if (MIMETypeRegistry::isSupportedNonImageMIMEType(MIMEType))
369         return true;
370
371     return false;
372 }
373
374 bool FrameLoaderClientQt::representationExistsForURLScheme(const String& URLScheme) const
375 {
376     return false;
377 }
378
379
380 String FrameLoaderClientQt::generatedMIMETypeForURLScheme(const String& URLScheme) const
381 {
382     notImplemented();
383     return String();
384 }
385
386
387 void FrameLoaderClientQt::frameLoadCompleted()
388 {
389     // Note: Can be called multiple times.
390     // Even if already complete, we might have set a previous item on a frame that
391     // didn't do any data loading on the past transaction. Make sure to clear these out.
392     m_frame->loader()->setPreviousHistoryItem(0);
393 }
394
395
396 void FrameLoaderClientQt::restoreViewState()
397 {
398     notImplemented();
399 }
400
401
402 void FrameLoaderClientQt::provisionalLoadStarted()
403 {
404     // don't need to do anything here
405 }
406
407
408 void FrameLoaderClientQt::didFinishLoad()
409 {
410 //     notImplemented();
411 }
412
413
414 void FrameLoaderClientQt::prepareForDataSourceReplacement()
415 {
416     m_frame->loader()->detachChildren();
417 }
418
419 void FrameLoaderClientQt::setTitle(const String&, const KURL&)
420 {
421     // no need for, dispatchDidReceiveTitle is the right callback
422 }
423
424
425 String FrameLoaderClientQt::userAgent(const KURL& url)
426 {
427     if (m_webFrame) {
428         return m_webFrame->page()->userAgentFor(QUrl((QString)url.string()));
429     }
430     return String();
431 }
432
433 void FrameLoaderClientQt::dispatchDidReceiveIcon()
434 {
435     if (m_webFrame) {
436         emit m_webFrame->iconLoaded();
437     }
438 }
439
440 void FrameLoaderClientQt::frameLoaderDestroyed()
441 {
442     delete m_webFrame;
443     m_frame = 0;
444     m_webFrame = 0;
445
446     delete this;
447 }
448
449 bool FrameLoaderClientQt::canHandleRequest(const WebCore::ResourceRequest&) const
450 {
451     return true;
452 }
453
454 void FrameLoaderClientQt::windowObjectCleared()
455 {
456     if (m_webFrame)
457         emit m_webFrame->cleared();
458 }
459
460 void FrameLoaderClientQt::didPerformFirstNavigation() const
461 {
462     if (m_frame->tree()->parent())
463         return;
464     m_webFrame->page()->d->updateNavigationActions();
465 }
466
467 void FrameLoaderClientQt::registerForIconNotification(bool)
468 {
469     notImplemented();
470 }
471
472 void FrameLoaderClientQt::updateGlobalHistory(const WebCore::KURL& url)
473 {
474     QWebHistoryInterface *history = QWebHistoryInterface::defaultInterface();
475     if (history)
476         history->addHistoryEntry(url.prettyURL());
477 }
478
479 bool FrameLoaderClientQt::shouldGoToHistoryItem(WebCore::HistoryItem *item) const
480 {
481     if (item) {
482         return true;
483     }
484     return false;
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     QNetworkReplyHandler* handler = handle->getInternal()->m_job;
582     QNetworkReply* reply = handler->release();
583     if (reply) {
584         QWebPage *page = m_webFrame->page();
585         if (page->receivers(SIGNAL(handleUnsupportedContent(QNetworkReply *))))
586             emit m_webFrame->page()->handleUnsupportedContent(reply);
587         else
588             reply->abort();
589     }
590 #endif
591 }
592
593 void FrameLoaderClientQt::assignIdentifierToInitialRequest(unsigned long identifier, WebCore::DocumentLoader*, const WebCore::ResourceRequest&)
594 {
595 }
596
597 void FrameLoaderClientQt::dispatchWillSendRequest(WebCore::DocumentLoader*, unsigned long, WebCore::ResourceRequest& request, const WebCore::ResourceResponse& response)
598 {
599     // seems like the Mac code doesn't do anything here by default neither
600     //qDebug() << "FrameLoaderClientQt::dispatchWillSendRequest" << request.isNull() << request.url().string`();
601 }
602
603 void FrameLoaderClientQt::dispatchDidReceiveAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&)
604 {
605     notImplemented();
606 }
607
608 void FrameLoaderClientQt::dispatchDidCancelAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&)
609 {
610     notImplemented();
611 }
612
613 void FrameLoaderClientQt::dispatchDidReceiveResponse(WebCore::DocumentLoader*, unsigned long, const WebCore::ResourceResponse& response)
614 {
615
616     m_response = response;
617     m_firstData = true;
618     //qDebug() << "    got response from" << response.url().string();
619 }
620
621 void FrameLoaderClientQt::dispatchDidReceiveContentLength(WebCore::DocumentLoader*, unsigned long, int)
622 {
623 }
624
625 void FrameLoaderClientQt::dispatchDidFinishLoading(WebCore::DocumentLoader* loader, unsigned long)
626 {
627 }
628
629 void FrameLoaderClientQt::dispatchDidFailLoading(WebCore::DocumentLoader* loader, unsigned long, const WebCore::ResourceError&)
630 {
631     if (m_firstData) {
632         FrameLoader *fl = loader->frameLoader();
633         fl->setEncoding(m_response.textEncodingName(), false);
634         m_firstData = false;
635     }
636 }
637
638 bool FrameLoaderClientQt::dispatchDidLoadResourceFromMemoryCache(WebCore::DocumentLoader*, const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, int)
639 {
640     notImplemented();
641     return false;
642 }
643
644 void FrameLoaderClientQt::dispatchDidFailProvisionalLoad(const WebCore::ResourceError&)
645 {
646     if (m_webFrame)
647         emit m_webFrame->loadDone(false);
648 }
649
650 void FrameLoaderClientQt::dispatchDidFailLoad(const WebCore::ResourceError&)
651 {
652     if (m_webFrame)
653         emit m_webFrame->loadDone(false);
654 }
655
656 WebCore::Frame* FrameLoaderClientQt::dispatchCreatePage()
657 {
658     if (!m_webFrame)
659         return 0;
660     QWebPage *newPage = m_webFrame->page()->createWindow();
661     if (!newPage)
662         return 0;
663     return newPage->mainFrame()->d->frame;
664 }
665
666 void FrameLoaderClientQt::dispatchDecidePolicyForMIMEType(FramePolicyFunction function, const WebCore::String& MIMEType, const WebCore::ResourceRequest&)
667 {
668     // we need to call directly here
669     Q_ASSERT(!m_policyFunction);
670     m_policyFunction = function;
671     if (canShowMIMEType(MIMEType))
672         slotCallPolicyFunction(PolicyUse);
673     else
674         slotCallPolicyFunction(PolicyDownload);
675 }
676
677 void FrameLoaderClientQt::dispatchDecidePolicyForNewWindowAction(FramePolicyFunction function, const WebCore::NavigationAction&, const WebCore::ResourceRequest&, const WebCore::String&)
678 {
679     Q_ASSERT(!m_policyFunction);
680     m_policyFunction = function;
681     slotCallPolicyFunction(PolicyUse);
682 }
683
684 void FrameLoaderClientQt::dispatchDecidePolicyForNavigationAction(FramePolicyFunction function, const WebCore::NavigationAction& action, const WebCore::ResourceRequest& request)
685 {
686     Q_ASSERT(!m_policyFunction);
687     m_policyFunction = function;
688     if (m_webFrame) {
689 #if QT_VERSION < 0x040400
690         QWebNetworkRequest r(request);
691 #else
692         QNetworkRequest r(request.toNetworkRequest());
693 #endif
694         QWebPage *page = m_webFrame->page();
695
696         if (page->d->navigationRequested(m_webFrame, r, QWebPage::NavigationType(action.type())) ==
697             QWebPage::IgnoreNavigationRequest) {
698             slotCallPolicyFunction(PolicyIgnore);
699             return;
700         }
701     }
702     slotCallPolicyFunction(PolicyUse);
703     return;
704 }
705
706 void FrameLoaderClientQt::dispatchUnableToImplementPolicy(const WebCore::ResourceError&)
707 {
708     notImplemented();
709 }
710
711 void FrameLoaderClientQt::startDownload(const WebCore::ResourceRequest& request)
712 {
713 #if QT_VERSION >= 0x040400
714     QWebPage *page = m_webFrame->page();
715     emit m_webFrame->page()->download(request.toNetworkRequest());
716 #endif
717 }
718
719 PassRefPtr<Frame> FrameLoaderClientQt::createFrame(const KURL& url, const String& name, HTMLFrameOwnerElement* ownerElement,
720                                         const String& referrer, bool allowsScrolling, int marginWidth, int marginHeight)
721 {
722     QWebFrameData frameData;
723     frameData.url = url;
724     frameData.name = name;
725     frameData.ownerElement = ownerElement;
726     frameData.referrer = referrer;
727     frameData.allowsScrolling = allowsScrolling;
728     frameData.marginWidth = marginWidth;
729     frameData.marginHeight = marginHeight;
730
731     QWebFrame* webFrame = new QWebFrame(m_webFrame, &frameData);
732     emit m_webFrame->page()->frameCreated(webFrame);
733
734     RefPtr<Frame> childFrame = adoptRef(webFrame->d->frame);
735
736     // FIXME: All of the below should probably be moved over into WebCore
737     childFrame->tree()->setName(name);
738     m_frame->tree()->appendChild(childFrame);
739     // ### set override encoding if we have one
740
741     FrameLoadType loadType = m_frame->loader()->loadType();
742     FrameLoadType childLoadType = FrameLoadTypeRedirectWithLockedHistory;
743
744     childFrame->loader()->load(frameData.url, frameData.referrer, childLoadType,
745                              String(), 0, 0);
746
747     // The frame's onload handler may have removed it from the document.
748     if (!childFrame->tree()->parent())
749         return 0;
750
751     return childFrame.release();
752 }
753
754 ObjectContentType FrameLoaderClientQt::objectContentType(const KURL& url, const String& _mimeType)
755 {
756 //    qDebug()<<" ++++++++++++++++ url is "<<url.prettyURL()<<", mime = "<<_mimeType;
757     if (_mimeType == "application/x-qt-plugin" || _mimeType == "application/x-qt-styled-widget")
758         return ObjectContentOtherPlugin;
759
760     if (url.isEmpty())
761         return ObjectContentNone;
762
763     String mimeType = _mimeType;
764     if (!mimeType.length()) {
765         QFileInfo fi(url.path());
766         mimeType = MIMETypeRegistry::getMIMETypeForExtension(fi.suffix());
767     }
768
769     if (!mimeType.length())
770         return ObjectContentFrame;
771
772     if (MIMETypeRegistry::isSupportedImageMIMEType(mimeType))
773         return ObjectContentImage;
774
775     if (m_frame->page() && m_frame->page()->pluginData()->supportsMimeType(mimeType))
776         return ObjectContentOtherPlugin;
777
778     if (MIMETypeRegistry::isSupportedNonImageMIMEType(mimeType))
779         return ObjectContentFrame;
780
781     if (url.protocol() == "about")
782         return ObjectContentFrame;
783
784     return ObjectContentNone;
785 }
786
787 static const CSSPropertyID qstyleSheetProperties[] = {
788     CSSPropertyColor,
789     CSSPropertyFontFamily,
790     CSSPropertyFontSize,
791     CSSPropertyFontStyle,
792     CSSPropertyFontWeight
793 };
794
795 const unsigned numqStyleSheetProperties = sizeof(qstyleSheetProperties) / sizeof(qstyleSheetProperties[0]);
796
797 Widget* FrameLoaderClientQt::createPlugin(const IntSize&, Element* element, const KURL& url, const Vector<String>& paramNames,
798                                           const Vector<String>& paramValues, const String& mimeType, bool loadManually)
799 {
800 //     qDebug()<<"------ Creating plugin in FrameLoaderClientQt::createPlugin for "<<url.prettyURL() << mimeType;
801 //     qDebug()<<"------\t url = "<<url.prettyURL();
802     QStringList params;
803     QStringList values;
804     for (int i = 0; i < paramNames.size(); ++i)
805         params.append(paramNames[i]);
806     for (int i = 0; i < paramValues.size(); ++i)
807         values.append(paramValues[i]);
808
809     QString urlStr(url.string());
810     QUrl qurl = urlStr;
811
812     QObject *object = 0;
813
814     if (mimeType == "application/x-qt-plugin" || mimeType == "application/x-qt-styled-widget") {
815         object = m_webFrame->page()->createPlugin(element->getAttribute("classid"), qurl, params, values);
816         QWidget *widget = qobject_cast<QWidget *>(object);
817         if (widget && mimeType == "application/x-qt-styled-widget") {
818             CSSComputedStyleDeclaration cssDecl(element);
819
820             QString styleSheet = element->getAttribute("style");
821             if (!styleSheet.isEmpty())
822                 styleSheet += QLatin1Char(';');
823
824             for (int i = 0; i < numqStyleSheetProperties; ++i) {
825                 CSSPropertyID property = qstyleSheetProperties[i];
826
827                 styleSheet += ::getPropertyName(property);
828                 styleSheet += QLatin1Char(':');
829                 styleSheet += cssDecl.getPropertyValue(property);
830                 styleSheet += QLatin1Char(';');
831             }
832
833             widget->setStyleSheet(styleSheet);
834         }
835     }
836
837 #if QT_VERSION >= 0x040400
838     if (!object) {
839         QWebPluginFactory* factory = m_webFrame->page()->pluginFactory();
840         if (factory)
841             object = factory->create(mimeType, qurl, params, values);
842     }
843 #endif
844
845     if (object) {
846         QWidget *widget = qobject_cast<QWidget *>(object);
847         QWidget *view = m_webFrame->page()->view();
848         if (widget && view) {
849             widget->setParent(view);
850             Widget* w= new Widget();
851             w->setNativeWidget(widget);
852             return w;
853         }
854         // FIXME: make things work for widgetless plugins as well
855         delete object;
856     }
857
858     return 0;
859 }
860
861 void FrameLoaderClientQt::redirectDataToPlugin(Widget* pluginWidget)
862 {
863     notImplemented();
864     return;
865 }
866
867 Widget* FrameLoaderClientQt::createJavaAppletWidget(const IntSize&, Element*, const KURL& baseURL,
868                                                     const Vector<String>& paramNames, const Vector<String>& paramValues)
869 {
870     notImplemented();
871     return 0;
872 }
873
874 String FrameLoaderClientQt::overrideMediaType() const
875 {
876     return String();
877 }
878
879 QString FrameLoaderClientQt::chooseFile(const QString& oldFile)
880 {
881     return webFrame()->page()->chooseFile(webFrame(), oldFile);
882 }
883
884
885 }
886
887 #include "moc_FrameLoaderClientQt.cpp"