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