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"