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