WebKit/wx/WebKitSupport/FrameLoaderClientWx.cpp

   1 /*
   2  * Copyright (C) 2007 Kevin Ollivier <kevino@theolliviers.com>
   3  *
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  16  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  18  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  19  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  20  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  22  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  23  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  25  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #include "config.h"
  29 #include "FrameLoaderClientWx.h"
  30
  31 #include "DocumentLoader.h"
  32 #include "Frame.h"
  33 #include "FrameLoaderTypes.h"
  34 #include "FrameView.h"
  35 #include "FrameTree.h"
  36 #include "HTMLFormElement.h"
  37 #include "NotImplemented.h"
  38 #include "Page.h"
  39 #include "PlatformString.h"
  40 #include "ProgressTracker.h"
  41 #include "ResourceError.h"
  42 #include "ResourceResponse.h"
  43
  44 #include <stdio.h>
  45
  46 #include "WebView.h"
  47 #include "WebViewPrivate.h"
  48
  49 namespace WebCore {
  50
  51 inline int wxNavTypeFromWebNavType(NavigationType type){
  52     if (type == NavigationTypeLinkClicked)
  53         return wxWEBVIEW_NAV_LINK_CLICKED;
  54
  55     if (type == NavigationTypeFormSubmitted)
  56         return wxWEBVIEW_NAV_FORM_SUBMITTED;
  57
  58     if (type == NavigationTypeBackForward)
  59         return wxWEBVIEW_NAV_BACK_NEXT;
  60
  61     if (type == NavigationTypeReload)
  62         return wxWEBVIEW_NAV_RELOAD;
  63
  64     if (type == NavigationTypeFormResubmitted)
  65         return wxWEBVIEW_NAV_FORM_RESUBMITTED;
  66
  67     return wxWEBVIEW_NAV_OTHER;
  68 }
  69
  70 FrameLoaderClientWx::FrameLoaderClientWx()
  71     : m_frame(0)
  72 {
  73 }
  74
  75
  76 FrameLoaderClientWx::~FrameLoaderClientWx()
  77 {
  78 }
  79
  80 void FrameLoaderClientWx::setFrame(Frame *frame)
  81 {
  82     m_frame = frame;
  83 }
  84
  85 void FrameLoaderClientWx::detachFrameLoader()
  86 {
  87     m_frame = 0;
  88 }
  89
  90 void FrameLoaderClientWx::ref()
  91 {
  92     RefCounted<FrameLoaderClientWx>::ref();
  93 }
  94
  95 void FrameLoaderClientWx::deref()
  96 {
  97     RefCounted<FrameLoaderClientWx>::deref();
  98 }
  99
 100 bool FrameLoaderClientWx::hasWebView() const
 101 {
 102     notImplemented();
 103     return true;
 104 }
 105
 106
 107 bool FrameLoaderClientWx::hasFrameView() const
 108 {
 109     notImplemented();
 110     return true;
 111 }
 112
 113
 114 bool FrameLoaderClientWx::hasBackForwardList() const
 115 {
 116     notImplemented();
 117     return true;
 118 }
 119
 120
 121 void FrameLoaderClientWx::resetBackForwardList()
 122 {
 123     notImplemented();
 124 }
 125
 126
 127 bool FrameLoaderClientWx::provisionalItemIsTarget() const
 128 {
 129     notImplemented();
 130     return false;
 131 }
 132
 133
 134 void FrameLoaderClientWx::makeDocumentView()
 135 {
 136     notImplemented();
 137 }
 138
 139
 140 void FrameLoaderClientWx::makeRepresentation(DocumentLoader*)
 141 {
 142     notImplemented();
 143 }
 144
 145
 146 void FrameLoaderClientWx::forceLayout()
 147 {
 148     notImplemented();
 149 }
 150
 151
 152 void FrameLoaderClientWx::forceLayoutForNonHTML()
 153 {
 154     notImplemented();
 155 }
 156
 157
 158 void FrameLoaderClientWx::updateHistoryForCommit()
 159 {
 160     notImplemented();
 161 }
 162
 163
 164 void FrameLoaderClientWx::updateHistoryForBackForwardNavigation()
 165 {
 166     notImplemented();
 167 }
 168
 169
 170 void FrameLoaderClientWx::updateHistoryForReload()
 171 {
 172     notImplemented();
 173 }
 174
 175
 176 void FrameLoaderClientWx::updateHistoryForStandardLoad()
 177 {
 178     notImplemented();
 179 }
 180
 181
 182 void FrameLoaderClientWx::updateHistoryForInternalLoad()
 183 {
 184     notImplemented();
 185 }
 186
 187
 188 void FrameLoaderClientWx::updateHistoryAfterClientRedirect()
 189 {
 190     notImplemented();
 191 }
 192
 193
 194 void FrameLoaderClientWx::setCopiesOnScroll()
 195 {
 196     // apparently mac specific
 197     notImplemented();
 198 }
 199
 200
 201 LoadErrorResetToken* FrameLoaderClientWx::tokenForLoadErrorReset()
 202 {
 203     notImplemented();
 204     return 0;
 205 }
 206
 207
 208 void FrameLoaderClientWx::resetAfterLoadError(LoadErrorResetToken*)
 209 {
 210     notImplemented();
 211 }
 212
 213
 214 void FrameLoaderClientWx::doNotResetAfterLoadError(LoadErrorResetToken*)
 215 {
 216     notImplemented();
 217 }
 218
 219
 220 void FrameLoaderClientWx::willCloseDocument()
 221 {
 222     notImplemented();
 223 }
 224
 225
 226 void FrameLoaderClientWx::detachedFromParent1()
 227 {
 228     notImplemented();
 229 }
 230
 231
 232 void FrameLoaderClientWx::detachedFromParent2()
 233 {
 234     notImplemented();
 235 }
 236
 237
 238 void FrameLoaderClientWx::detachedFromParent3()
 239 {
 240     notImplemented();
 241 }
 242
 243
 244 void FrameLoaderClientWx::detachedFromParent4()
 245 {
 246     notImplemented();
 247 }
 248
 249
 250 void FrameLoaderClientWx::loadedFromCachedPage()
 251 {
 252     notImplemented();
 253 }
 254
 255
 256 void FrameLoaderClientWx::dispatchDidHandleOnloadEvents()
 257 {
 258     notImplemented();
 259 }
 260
 261
 262 void FrameLoaderClientWx::dispatchDidReceiveServerRedirectForProvisionalLoad()
 263 {
 264     notImplemented();
 265 }
 266
 267
 268 void FrameLoaderClientWx::dispatchDidCancelClientRedirect()
 269 {
 270     notImplemented();
 271 }
 272
 273
 274 void FrameLoaderClientWx::dispatchWillPerformClientRedirect(const KURL&,
 275                                                             double interval,
 276                                                             double fireDate)
 277 {
 278     notImplemented();
 279 }
 280
 281
 282 void FrameLoaderClientWx::dispatchDidChangeLocationWithinPage()
 283 {
 284     notImplemented();
 285 }
 286
 287
 288 void FrameLoaderClientWx::dispatchWillClose()
 289 {
 290     notImplemented();
 291 }
 292
 293
 294 void FrameLoaderClientWx::dispatchDidStartProvisionalLoad()
 295 {
 296     wxWindow* target = m_frame->view()->nativeWindow();
 297     if (target) {
 298         wxWebViewStateChangedEvent wkEvent(target);
 299         wkEvent.SetState(wxWEBVIEW_STATE_NEGOTIATING);
 300         wkEvent.SetURL(m_frame->loader()->provisionalDocumentLoader()->request().url().url());
 301         target->GetEventHandler()->ProcessEvent(wkEvent);
 302     }
 303 }
 304
 305
 306 void FrameLoaderClientWx::dispatchDidReceiveTitle(const String& title)
 307 {
 308     wxWebView* target = static_cast<wxWebView*>(m_frame->view()->nativeWindow());
 309     if (target)
 310         target->SetPageTitle(title);
 311 }
 312
 313
 314 void FrameLoaderClientWx::dispatchDidCommitLoad()
 315 {
 316     wxWindow* target = m_frame->view()->nativeWindow();
 317     if (target) {
 318         wxWebViewStateChangedEvent wkEvent(target);
 319         wkEvent.SetState(wxWEBVIEW_STATE_TRANSFERRING);
 320         wkEvent.SetURL(m_frame->loader()->documentLoader()->request().url().url());
 321         target->GetEventHandler()->ProcessEvent(wkEvent);
 322     }
 323 }
 324
 325 void FrameLoaderClientWx::dispatchDidFinishDocumentLoad()
 326 {
 327     wxWindow* target = m_frame->view()->nativeWindow();
 328     if (target) {
 329         wxWebViewStateChangedEvent wkEvent(target);
 330         wkEvent.SetState(wxWEBVIEW_STATE_STOP);
 331         wkEvent.SetURL(m_frame->loader()->URL().url());
 332         target->GetEventHandler()->ProcessEvent(wkEvent);
 333     }
 334 }
 335
 336 void FrameLoaderClientWx::dispatchDidFinishLoad()
 337 {
 338     notImplemented();
 339 }
 340
 341
 342 void FrameLoaderClientWx::dispatchDidFirstLayout()
 343 {
 344     notImplemented();
 345 }
 346
 347
 348 void FrameLoaderClientWx::dispatchShow()
 349 {
 350     notImplemented();
 351 }
 352
 353
 354 void FrameLoaderClientWx::cancelPolicyCheck()
 355 {
 356     notImplemented();
 357 }
 358
 359
 360 void FrameLoaderClientWx::dispatchWillSubmitForm(FramePolicyFunction function,
 361                                                  PassRefPtr<FormState>)
 362 {
 363     // FIXME: Send an event to allow for alerts and cancellation
 364     if (!m_frame)
 365         return;
 366     (m_frame->loader()->*function)(PolicyUse);
 367 }
 368
 369
 370 void FrameLoaderClientWx::dispatchDidLoadMainResource(DocumentLoader*)
 371 {
 372     notImplemented();
 373 }
 374
 375
 376 void FrameLoaderClientWx::revertToProvisionalState(DocumentLoader*)
 377 {
 378     notImplemented();
 379 }
 380
 381
 382 void FrameLoaderClientWx::clearUnarchivingState(DocumentLoader*)
 383 {
 384     notImplemented();
 385 }
 386
 387 void FrameLoaderClientWx::postProgressStartedNotification()
 388 {
 389     notImplemented();
 390 }
 391
 392 void FrameLoaderClientWx::postProgressEstimateChangedNotification()
 393 {
 394     notImplemented();
 395 }
 396
 397 void FrameLoaderClientWx::postProgressFinishedNotification()
 398 {
 399     wxWindow* target = m_frame->view()->nativeWindow();
 400     if (target) {
 401         wxWebViewStateChangedEvent wkEvent(target);
 402         wkEvent.SetState(wxWEBVIEW_STATE_STOP);
 403         wkEvent.SetURL(m_frame->loader()->url().url());
 404         target->GetEventHandler()->ProcessEvent(wkEvent);
 405     }
 406 }
 407
 408 void FrameLoaderClientWx::progressStarted()
 409 {
 410     notImplemented();
 411 }
 412
 413
 414 void FrameLoaderClientWx::progressCompleted()
 415 {
 416     notImplemented();
 417 }
 418
 419
 420 void FrameLoaderClientWx::setMainFrameDocumentReady(bool b)
 421 {
 422     notImplemented();
 423     // this is only interesting once we provide an external API for the DOM
 424 }
 425
 426
 427 void FrameLoaderClientWx::willChangeTitle(DocumentLoader*)
 428 {
 429     notImplemented();
 430 }
 431
 432
 433 void FrameLoaderClientWx::didChangeTitle(DocumentLoader *l)
 434 {
 435     setTitle(l->title(), l->URL());
 436 }
 437
 438
 439 void FrameLoaderClientWx::finishedLoading(DocumentLoader*)
 440 {
 441     notImplemented();
 442 }
 443
 444
 445 void FrameLoaderClientWx::finalSetupForReplace(DocumentLoader*)
 446 {
 447     notImplemented();
 448 }
 449
 450
 451 void FrameLoaderClientWx::setDefersLoading(bool)
 452 {
 453     notImplemented();
 454 }
 455
 456
 457 bool FrameLoaderClientWx::isArchiveLoadPending(ResourceLoader*) const
 458 {
 459     notImplemented();
 460     return false;
 461 }
 462
 463
 464 void FrameLoaderClientWx::cancelPendingArchiveLoad(ResourceLoader*)
 465 {
 466     notImplemented();
 467 }
 468
 469
 470 void FrameLoaderClientWx::clearArchivedResources()
 471 {
 472     notImplemented();
 473 }
 474
 475
 476 bool FrameLoaderClientWx::canShowMIMEType(const String& MIMEType) const
 477 {
 478     notImplemented();
 479     return true;
 480 }
 481
 482
 483 bool FrameLoaderClientWx::representationExistsForURLScheme(const String& URLScheme) const
 484 {
 485     notImplemented();
 486     return false;
 487 }
 488
 489
 490 String FrameLoaderClientWx::generatedMIMETypeForURLScheme(const String& URLScheme) const
 491 {
 492     notImplemented();
 493     return String();
 494 }
 495
 496
 497 void FrameLoaderClientWx::frameLoadCompleted()
 498 {
 499     notImplemented();
 500 }
 501
 502 void FrameLoaderClientWx::saveViewStateToItem(HistoryItem*)
 503 {
 504     notImplemented();
 505 }
 506
 507 void FrameLoaderClientWx::restoreViewState()
 508 {
 509     notImplemented();
 510 }
 511
 512 void FrameLoaderClientWx::restoreScrollPositionAndViewState()
 513 {
 514     notImplemented();
 515 }
 516
 517
 518 void FrameLoaderClientWx::provisionalLoadStarted()
 519 {
 520     notImplemented();
 521 }
 522
 523
 524 bool FrameLoaderClientWx::shouldTreatURLAsSameAsCurrent(const KURL&) const
 525 {
 526     notImplemented();
 527     return false;
 528 }
 529
 530
 531 void FrameLoaderClientWx::addHistoryItemForFragmentScroll()
 532 {
 533     notImplemented();
 534 }
 535
 536
 537 void FrameLoaderClientWx::didFinishLoad()
 538 {
 539     notImplemented();
 540 }
 541
 542
 543 void FrameLoaderClientWx::prepareForDataSourceReplacement()
 544 {
 545     if (m_frame && m_frame->loader())
 546         m_frame->loader()->detachChildren();
 547 }
 548
 549
 550 void FrameLoaderClientWx::setTitle(const String& title, const KURL&)
 551 {
 552     notImplemented();
 553 }
 554
 555
 556 String FrameLoaderClientWx::userAgent(const KURL&)
 557 {
 558     // FIXME: Use the new APIs introduced by the GTK port to fill in these values.
 559     return String("Mozilla/5.0 (Macintosh; U; Intel Mac OS X; en) AppleWebKit/418.9.1 (KHTML, like Gecko) Safari/419.3");
 560 }
 561
 562 void FrameLoaderClientWx::dispatchDidReceiveIcon()
 563 {
 564     notImplemented();
 565 }
 566
 567 void FrameLoaderClientWx::frameLoaderDestroyed()
 568 {
 569     m_frame = 0;
 570     delete this;
 571 }
 572
 573 bool FrameLoaderClientWx::canHandleRequest(const WebCore::ResourceRequest&) const
 574 {
 575     notImplemented();
 576     return true;
 577 }
 578
 579 void FrameLoaderClientWx::partClearedInBegin()
 580 {
 581     notImplemented();
 582 }
 583
 584 void FrameLoaderClientWx::setDocumentViewFromCachedPage(WebCore::CachedPage*)
 585 {
 586     notImplemented();
 587 }
 588
 589 void FrameLoaderClientWx::updateGlobalHistoryForStandardLoad(const WebCore::KURL&)
 590 {
 591     notImplemented();
 592 }
 593
 594 void FrameLoaderClientWx::updateGlobalHistoryForReload(const WebCore::KURL&)
 595 {
 596     notImplemented();
 597 }
 598
 599 bool FrameLoaderClientWx::shouldGoToHistoryItem(WebCore::HistoryItem*) const
 600 {
 601     notImplemented();
 602     return true;
 603 }
 604
 605 void FrameLoaderClientWx::saveScrollPositionAndViewStateToItem(WebCore::HistoryItem*)
 606 {
 607     notImplemented();
 608 }
 609
 610 void FrameLoaderClientWx::saveDocumentViewToCachedPage(WebCore::CachedPage*)
 611 {
 612     notImplemented();
 613 }
 614
 615 bool FrameLoaderClientWx::canCachePage() const
 616 {
 617     return false;
 618 }
 619
 620 void FrameLoaderClientWx::setMainDocumentError(WebCore::DocumentLoader*, const WebCore::ResourceError&)
 621 {
 622     notImplemented();
 623 }
 624
 625 void FrameLoaderClientWx::committedLoad(WebCore::DocumentLoader* loader, const char* data, int length)
 626 {
 627     if (!m_frame)
 628         return;
 629     FrameLoader* fl = loader->frameLoader();
 630     fl->setEncoding(m_response.textEncodingName(), false);
 631     fl->addData(data, length);
 632 }
 633
 634 WebCore::ResourceError FrameLoaderClientWx::cancelledError(const WebCore::ResourceRequest&)
 635 {
 636     notImplemented();
 637     return ResourceError();
 638 }
 639
 640 WebCore::ResourceError FrameLoaderClientWx::blockedError(const ResourceRequest&)
 641 {
 642     notImplemented();
 643     return ResourceError();
 644 }
 645
 646 WebCore::ResourceError FrameLoaderClientWx::cannotShowURLError(const WebCore::ResourceRequest&)
 647 {
 648     notImplemented();
 649     return ResourceError();
 650 }
 651
 652 WebCore::ResourceError FrameLoaderClientWx::interruptForPolicyChangeError(const WebCore::ResourceRequest&)
 653 {
 654     notImplemented();
 655     return ResourceError();
 656 }
 657
 658 WebCore::ResourceError FrameLoaderClientWx::cannotShowMIMETypeError(const WebCore::ResourceResponse&)
 659 {
 660     notImplemented();
 661     return ResourceError();
 662 }
 663
 664 WebCore::ResourceError FrameLoaderClientWx::fileDoesNotExistError(const WebCore::ResourceResponse&)
 665 {
 666     notImplemented();
 667     return ResourceError();
 668 }
 669
 670 bool FrameLoaderClientWx::shouldFallBack(const WebCore::ResourceError& error)
 671 {
 672     notImplemented();
 673     return false;
 674 }
 675
 676 WTF::PassRefPtr<DocumentLoader> FrameLoaderClientWx::createDocumentLoader(const ResourceRequest& request, const SubstituteData& substituteData)
 677 {
 678     RefPtr<DocumentLoader> loader = new DocumentLoader(request, substituteData);
 679     return loader.release();
 680 }
 681
 682 void FrameLoaderClientWx::download(ResourceHandle*, const ResourceRequest&, const ResourceRequest&, const ResourceResponse&)
 683 {
 684     notImplemented();
 685 }
 686
 687 void FrameLoaderClientWx::assignIdentifierToInitialRequest(unsigned long identifier, DocumentLoader*, const ResourceRequest&)
 688 {
 689     notImplemented();
 690 }
 691
 692 void FrameLoaderClientWx::dispatchWillSendRequest(DocumentLoader*, unsigned long, ResourceRequest& request, const ResourceResponse& response)
 693 {
 694     notImplemented();
 695 }
 696
 697 void FrameLoaderClientWx::dispatchDidReceiveAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&)
 698 {
 699     notImplemented();
 700 }
 701
 702 void FrameLoaderClientWx::dispatchDidCancelAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&)
 703 {
 704     notImplemented();
 705 }
 706
 707 void FrameLoaderClientWx::dispatchDidReceiveResponse(DocumentLoader* loader, unsigned long id, const ResourceResponse& response)
 708 {
 709     notImplemented();
 710     m_response = response;
 711     m_firstData = true;
 712 }
 713
 714 void FrameLoaderClientWx::dispatchDidReceiveContentLength(DocumentLoader* loader, unsigned long id, int length)
 715 {
 716     notImplemented();
 717 }
 718
 719 void FrameLoaderClientWx::dispatchDidFinishLoading(DocumentLoader*, unsigned long)
 720 {
 721     notImplemented();
 722 }
 723
 724 void FrameLoaderClientWx::dispatchDidFailLoading(DocumentLoader*, unsigned long, const ResourceError&)
 725 {
 726     notImplemented();
 727 }
 728
 729 bool FrameLoaderClientWx::dispatchDidLoadResourceFromMemoryCache(DocumentLoader*, const ResourceRequest&, const ResourceResponse&, int)
 730 {
 731     notImplemented();
 732     return false;
 733 }
 734
 735 void FrameLoaderClientWx::dispatchDidFailProvisionalLoad(const ResourceError&)
 736 {
 737     notImplemented();
 738 }
 739
 740 void FrameLoaderClientWx::dispatchDidFailLoad(const ResourceError&)
 741 {
 742     notImplemented();
 743 }
 744
 745 Frame* FrameLoaderClientWx::dispatchCreatePage()
 746 {
 747     notImplemented();
 748     return false;
 749 }
 750
 751 void FrameLoaderClientWx::dispatchDecidePolicyForMIMEType(FramePolicyFunction function, const String& mimetype, const ResourceRequest& request)
 752 {
 753     if (!m_frame)
 754         return;
 755
 756     notImplemented();
 757     (m_frame->loader()->*function)(PolicyUse);
 758 }
 759
 760 void FrameLoaderClientWx::dispatchDecidePolicyForNewWindowAction(FramePolicyFunction function, const NavigationAction&, const ResourceRequest&, const String&)
 761 {
 762     if (!m_frame)
 763         return;
 764
 765     notImplemented();
 766     (m_frame->loader()->*function)(PolicyUse);
 767 }
 768
 769 void FrameLoaderClientWx::dispatchDecidePolicyForNavigationAction(FramePolicyFunction function, const NavigationAction& action, const ResourceRequest& request)
 770 {
 771     if (!m_frame)
 772         return;
 773
 774     wxWindow* target = m_frame->view()->nativeWindow();
 775     if (target) {
 776         wxWebViewBeforeLoadEvent wkEvent(target);
 777         wkEvent.SetNavigationType(wxNavTypeFromWebNavType(action.type()));
 778         wkEvent.SetURL(request.url().url());
 779
 780         target->GetEventHandler()->ProcessEvent(wkEvent);
 781         if (wkEvent.IsCancelled())
 782             (m_frame->loader()->*function)(PolicyIgnore);
 783         else
 784             (m_frame->loader()->*function)(PolicyUse);
 785
 786     }
 787 }
 788
 789 void FrameLoaderClientWx::dispatchUnableToImplementPolicy(const ResourceError&)
 790 {
 791     notImplemented();
 792 }
 793
 794 void FrameLoaderClientWx::startDownload(const ResourceRequest&)
 795 {
 796     notImplemented();
 797 }
 798
 799 bool FrameLoaderClientWx::willUseArchive(ResourceLoader*, const ResourceRequest&, const KURL&) const
 800 {
 801     notImplemented();
 802     return false;
 803 }
 804
 805 PassRefPtr<Frame> FrameLoaderClientWx::createFrame(const KURL& url, const String& name, HTMLFrameOwnerElement* ownerElement,
 806                                    const String& referrer, bool allowsScrolling, int marginWidth, int marginHeight)
 807 {
 808 /*
 809     FIXME: Temporarily disabling code for loading subframes. While most
 810     (i)frames load and are destroyed properly, the iframe created by
 811     google.com in its new homepage does not get destroyed when
 812     document()->detach() is called, as other (i)frames do. It is destroyed on
 813     app shutdown, but until that point, this 'in limbo' frame will do things
 814     like steal keyboard focus and crash when clicked on. (On some platforms,
 815     it is actually a visible object, even though it's not in a valid state.)
 816
 817     Since just about every user is probably going to test against Google at
 818     some point, I'm disabling this functionality until I have time to track down
 819     why it is not being destroyed.
 820 */
 821
 822 /*
 823     wxWindow* parent = m_frame->view()->nativeWindow();
 824
 825     WebViewFrameData* data = new WebViewFrameData();
 826     data->name = name;
 827     data->ownerElement = ownerElement;
 828     data->url = url;
 829     data->referrer = referrer;
 830     data->marginWidth = marginWidth;
 831     data->marginHeight = marginHeight;
 832
 833     wxWebView* newWin = new wxWebView(parent, -1, wxDefaultPosition, wxDefaultSize, data);
 834
 835     RefPtr<Frame> childFrame = newWin->m_impl->frame;
 836
 837     // FIXME: All of the below should probably be moved over into WebCore
 838     childFrame->tree()->setName(name);
 839     m_frame->tree()->appendChild(childFrame);
 840     // ### set override encoding if we have one
 841
 842     FrameLoadType loadType = m_frame->loader()->loadType();
 843     FrameLoadType childLoadType = FrameLoadTypeInternal;
 844
 845     childFrame->loader()->load(url, referrer, childLoadType,
 846                             String(), 0, 0);
 847
 848     // The frame's onload handler may have removed it from the document.
 849     if (!childFrame->tree()->parent())
 850         return 0;
 851
 852     delete data;
 853
 854     return childFrame.get();
 855 */
 856     notImplemented();
 857     return 0;
 858 }
 859
 860 ObjectContentType FrameLoaderClientWx::objectContentType(const KURL& url, const String& mimeType)
 861 {
 862     notImplemented();
 863     return ObjectContentType();
 864 }
 865
 866 Widget* FrameLoaderClientWx::createPlugin(const IntSize&, Element*, const KURL&, const Vector<String>&, const Vector<String>&, const String&, bool loadManually)
 867 {
 868     notImplemented();
 869     return 0;
 870 }
 871
 872 void FrameLoaderClientWx::redirectDataToPlugin(Widget* pluginWidget)
 873 {
 874     notImplemented();
 875     return;
 876 }
 877
 878 Widget* FrameLoaderClientWx::createJavaAppletWidget(const IntSize&, Element*, const KURL& baseURL,
 879                                                     const Vector<String>& paramNames, const Vector<String>& paramValues)
 880 {
 881     notImplemented();
 882     return 0;
 883 }
 884
 885 String FrameLoaderClientWx::overrideMediaType() const
 886 {
 887     notImplemented();
 888     return String();
 889 }
 890
 891 void FrameLoaderClientWx::windowObjectCleared()
 892 {
 893     notImplemented();
 894 }
 895
 896 void FrameLoaderClientWx::didPerformFirstNavigation() const
 897 {
 898     notImplemented();
 899 }
 900
 901 void FrameLoaderClientWx::registerForIconNotification(bool listen)
 902 {
 903     notImplemented();
 904 }
 905
 906 }