WebKit/qt/WebCoreSupport/FrameLoaderClientQt.cpp

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