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     : RefCounted<FrameLoaderClientWx>(0)
  72     , m_frame(0)
  73 {
  74 }
  75
  76
  77 FrameLoaderClientWx::~FrameLoaderClientWx()
  78 {
  79 }
  80
  81 void FrameLoaderClientWx::setFrame(Frame *frame)
  82 {
  83     m_frame = frame;
  84 }
  85
  86 void FrameLoaderClientWx::detachFrameLoader()
  87 {
  88     m_frame = 0;
  89 }
  90
  91 void FrameLoaderClientWx::ref()
  92 {
  93     RefCounted<FrameLoaderClientWx>::ref();
  94 }
  95
  96 void FrameLoaderClientWx::deref()
  97 {
  98     RefCounted<FrameLoaderClientWx>::deref();
  99 }
 100
 101 bool FrameLoaderClientWx::hasWebView() const
 102 {
 103     notImplemented();
 104     return true;
 105 }
 106
 107
 108 bool FrameLoaderClientWx::hasFrameView() const
 109 {
 110     notImplemented();
 111     return true;
 112 }
 113
 114
 115 bool FrameLoaderClientWx::hasBackForwardList() const
 116 {
 117     notImplemented();
 118     return true;
 119 }
 120
 121
 122 void FrameLoaderClientWx::resetBackForwardList()
 123 {
 124     notImplemented();
 125 }
 126
 127
 128 bool FrameLoaderClientWx::provisionalItemIsTarget() const
 129 {
 130     notImplemented();
 131     return false;
 132 }
 133
 134 void FrameLoaderClientWx::makeRepresentation(DocumentLoader*)
 135 {
 136     notImplemented();
 137 }
 138
 139
 140 void FrameLoaderClientWx::forceLayout()
 141 {
 142     notImplemented();
 143 }
 144
 145
 146 void FrameLoaderClientWx::forceLayoutForNonHTML()
 147 {
 148     notImplemented();
 149 }
 150
 151
 152 void FrameLoaderClientWx::updateHistoryForCommit()
 153 {
 154     notImplemented();
 155 }
 156
 157
 158 void FrameLoaderClientWx::updateHistoryForBackForwardNavigation()
 159 {
 160     notImplemented();
 161 }
 162
 163
 164 void FrameLoaderClientWx::updateHistoryForReload()
 165 {
 166     notImplemented();
 167 }
 168
 169
 170 void FrameLoaderClientWx::updateHistoryForStandardLoad()
 171 {
 172     notImplemented();
 173 }
 174
 175
 176 void FrameLoaderClientWx::updateHistoryForInternalLoad()
 177 {
 178     notImplemented();
 179 }
 180
 181
 182 void FrameLoaderClientWx::updateHistoryAfterClientRedirect()
 183 {
 184     notImplemented();
 185 }
 186
 187
 188 void FrameLoaderClientWx::setCopiesOnScroll()
 189 {
 190     // apparently mac specific
 191     notImplemented();
 192 }
 193
 194
 195 LoadErrorResetToken* FrameLoaderClientWx::tokenForLoadErrorReset()
 196 {
 197     notImplemented();
 198     return 0;
 199 }
 200
 201
 202 void FrameLoaderClientWx::resetAfterLoadError(LoadErrorResetToken*)
 203 {
 204     notImplemented();
 205 }
 206
 207
 208 void FrameLoaderClientWx::doNotResetAfterLoadError(LoadErrorResetToken*)
 209 {
 210     notImplemented();
 211 }
 212
 213
 214 void FrameLoaderClientWx::willCloseDocument()
 215 {
 216     notImplemented();
 217 }
 218
 219
 220 void FrameLoaderClientWx::detachedFromParent1()
 221 {
 222     notImplemented();
 223 }
 224
 225
 226 void FrameLoaderClientWx::detachedFromParent2()
 227 {
 228     notImplemented();
 229 }
 230
 231
 232 void FrameLoaderClientWx::detachedFromParent3()
 233 {
 234     notImplemented();
 235 }
 236
 237
 238 void FrameLoaderClientWx::detachedFromParent4()
 239 {
 240     notImplemented();
 241 }
 242
 243
 244 void FrameLoaderClientWx::loadedFromCachedPage()
 245 {
 246     notImplemented();
 247 }
 248
 249
 250 void FrameLoaderClientWx::dispatchDidHandleOnloadEvents()
 251 {
 252     wxWindow* target = m_frame->view()->nativeWindow();
 253     if (target) {
 254         wxWebViewLoadEvent wkEvent(target);
 255         wkEvent.SetState(wxWEBVIEW_LOAD_ONLOAD_HANDLED);
 256         wkEvent.SetURL(m_frame->loader()->documentLoader()->request().url().string());
 257         target->GetEventHandler()->ProcessEvent(wkEvent);
 258     }
 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         wxWebViewLoadEvent wkEvent(target);
 299         wkEvent.SetState(wxWEBVIEW_LOAD_NEGOTIATING);
 300         wkEvent.SetURL(m_frame->loader()->provisionalDocumentLoader()->request().url().string());
 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         wxWebViewLoadEvent wkEvent(target);
 319         wkEvent.SetState(wxWEBVIEW_LOAD_TRANSFERRING);
 320         wkEvent.SetURL(m_frame->loader()->documentLoader()->request().url().string());
 321         target->GetEventHandler()->ProcessEvent(wkEvent);
 322     }
 323 }
 324
 325 void FrameLoaderClientWx::dispatchDidFinishDocumentLoad()
 326 {
 327     wxWindow* target = m_frame->view()->nativeWindow();
 328     if (target) {
 329         wxWebViewLoadEvent wkEvent(target);
 330         wkEvent.SetState(wxWEBVIEW_LOAD_DOC_COMPLETED);
 331         wkEvent.SetURL(m_frame->loader()->url().string());
 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 void FrameLoaderClientWx::postProgressStartedNotification()
 382 {
 383     notImplemented();
 384 }
 385
 386 void FrameLoaderClientWx::postProgressEstimateChangedNotification()
 387 {
 388     notImplemented();
 389 }
 390
 391 void FrameLoaderClientWx::postProgressFinishedNotification()
 392 {
 393     wxWindow* target = m_frame->view()->nativeWindow();
 394     if (target) {
 395         wxWebViewLoadEvent wkEvent(target);
 396         wkEvent.SetState(wxWEBVIEW_LOAD_DL_COMPLETED);
 397         wkEvent.SetURL(m_frame->loader()->url().string());
 398         target->GetEventHandler()->ProcessEvent(wkEvent);
 399     }
 400 }
 401
 402 void FrameLoaderClientWx::progressStarted()
 403 {
 404     notImplemented();
 405 }
 406
 407
 408 void FrameLoaderClientWx::progressCompleted()
 409 {
 410     notImplemented();
 411 }
 412
 413
 414 void FrameLoaderClientWx::setMainFrameDocumentReady(bool b)
 415 {
 416     notImplemented();
 417     // this is only interesting once we provide an external API for the DOM
 418 }
 419
 420
 421 void FrameLoaderClientWx::willChangeTitle(DocumentLoader*)
 422 {
 423     notImplemented();
 424 }
 425
 426
 427 void FrameLoaderClientWx::didChangeTitle(DocumentLoader *l)
 428 {
 429     setTitle(l->title(), l->url());
 430 }
 431
 432
 433 void FrameLoaderClientWx::finishedLoading(DocumentLoader*)
 434 {
 435     notImplemented();
 436 }
 437
 438
 439 bool FrameLoaderClientWx::canShowMIMEType(const String& MIMEType) const
 440 {
 441     notImplemented();
 442     return true;
 443 }
 444
 445
 446 bool FrameLoaderClientWx::representationExistsForURLScheme(const String& URLScheme) const
 447 {
 448     notImplemented();
 449     return false;
 450 }
 451
 452
 453 String FrameLoaderClientWx::generatedMIMETypeForURLScheme(const String& URLScheme) const
 454 {
 455     notImplemented();
 456     return String();
 457 }
 458
 459
 460 void FrameLoaderClientWx::frameLoadCompleted()
 461 {
 462     notImplemented();
 463 }
 464
 465 void FrameLoaderClientWx::saveViewStateToItem(HistoryItem*)
 466 {
 467     notImplemented();
 468 }
 469
 470 void FrameLoaderClientWx::restoreViewState()
 471 {
 472     notImplemented();
 473 }
 474
 475 void FrameLoaderClientWx::restoreScrollPositionAndViewState()
 476 {
 477     notImplemented();
 478 }
 479
 480
 481 void FrameLoaderClientWx::provisionalLoadStarted()
 482 {
 483     notImplemented();
 484 }
 485
 486
 487 bool FrameLoaderClientWx::shouldTreatURLAsSameAsCurrent(const KURL&) const
 488 {
 489     notImplemented();
 490     return false;
 491 }
 492
 493
 494 void FrameLoaderClientWx::addHistoryItemForFragmentScroll()
 495 {
 496     notImplemented();
 497 }
 498
 499
 500 void FrameLoaderClientWx::didFinishLoad()
 501 {
 502     notImplemented();
 503 }
 504
 505
 506 void FrameLoaderClientWx::prepareForDataSourceReplacement()
 507 {
 508     if (m_frame && m_frame->loader())
 509         m_frame->loader()->detachChildren();
 510 }
 511
 512
 513 void FrameLoaderClientWx::setTitle(const String& title, const KURL&)
 514 {
 515     notImplemented();
 516 }
 517
 518
 519 String FrameLoaderClientWx::userAgent(const KURL&)
 520 {
 521     // FIXME: Use the new APIs introduced by the GTK port to fill in these values.
 522     return String("Mozilla/5.0 (Macintosh; U; Intel Mac OS X; en) AppleWebKit/418.9.1 (KHTML, like Gecko) Safari/419.3");
 523 }
 524
 525 void FrameLoaderClientWx::dispatchDidReceiveIcon()
 526 {
 527     notImplemented();
 528 }
 529
 530 void FrameLoaderClientWx::frameLoaderDestroyed()
 531 {
 532     m_frame = 0;
 533     delete this;
 534 }
 535
 536 bool FrameLoaderClientWx::canHandleRequest(const WebCore::ResourceRequest&) const
 537 {
 538     notImplemented();
 539     return true;
 540 }
 541
 542 void FrameLoaderClientWx::partClearedInBegin()
 543 {
 544     notImplemented();
 545 }
 546
 547 void FrameLoaderClientWx::updateGlobalHistory(const WebCore::KURL&)
 548 {
 549     notImplemented();
 550 }
 551
 552 bool FrameLoaderClientWx::shouldGoToHistoryItem(WebCore::HistoryItem*) const
 553 {
 554     notImplemented();
 555     return true;
 556 }
 557
 558 void FrameLoaderClientWx::saveScrollPositionAndViewStateToItem(WebCore::HistoryItem*)
 559 {
 560     notImplemented();
 561 }
 562
 563 bool FrameLoaderClientWx::canCachePage() const
 564 {
 565     return false;
 566 }
 567
 568 void FrameLoaderClientWx::setMainDocumentError(WebCore::DocumentLoader*, const WebCore::ResourceError&)
 569 {
 570     notImplemented();
 571 }
 572
 573 void FrameLoaderClientWx::committedLoad(WebCore::DocumentLoader* loader, const char* data, int length)
 574 {
 575     if (!m_frame)
 576         return;
 577     FrameLoader* fl = loader->frameLoader();
 578     fl->setEncoding(m_response.textEncodingName(), false);
 579     fl->addData(data, length);
 580 }
 581
 582 WebCore::ResourceError FrameLoaderClientWx::cancelledError(const WebCore::ResourceRequest&)
 583 {
 584     notImplemented();
 585     return ResourceError();
 586 }
 587
 588 WebCore::ResourceError FrameLoaderClientWx::blockedError(const ResourceRequest&)
 589 {
 590     notImplemented();
 591     return ResourceError();
 592 }
 593
 594 WebCore::ResourceError FrameLoaderClientWx::cannotShowURLError(const WebCore::ResourceRequest&)
 595 {
 596     notImplemented();
 597     return ResourceError();
 598 }
 599
 600 WebCore::ResourceError FrameLoaderClientWx::interruptForPolicyChangeError(const WebCore::ResourceRequest&)
 601 {
 602     notImplemented();
 603     return ResourceError();
 604 }
 605
 606 WebCore::ResourceError FrameLoaderClientWx::cannotShowMIMETypeError(const WebCore::ResourceResponse&)
 607 {
 608     notImplemented();
 609     return ResourceError();
 610 }
 611
 612 WebCore::ResourceError FrameLoaderClientWx::fileDoesNotExistError(const WebCore::ResourceResponse&)
 613 {
 614     notImplemented();
 615     return ResourceError();
 616 }
 617
 618 bool FrameLoaderClientWx::shouldFallBack(const WebCore::ResourceError& error)
 619 {
 620     notImplemented();
 621     return false;
 622 }
 623
 624 WTF::PassRefPtr<DocumentLoader> FrameLoaderClientWx::createDocumentLoader(const ResourceRequest& request, const SubstituteData& substituteData)
 625 {
 626     RefPtr<DocumentLoader> loader = new DocumentLoader(request, substituteData);
 627     return loader.release();
 628 }
 629
 630 void FrameLoaderClientWx::download(ResourceHandle*, const ResourceRequest&, const ResourceRequest&, const ResourceResponse&)
 631 {
 632     notImplemented();
 633 }
 634
 635 void FrameLoaderClientWx::assignIdentifierToInitialRequest(unsigned long identifier, DocumentLoader*, const ResourceRequest&)
 636 {
 637     notImplemented();
 638 }
 639
 640 void FrameLoaderClientWx::dispatchWillSendRequest(DocumentLoader*, unsigned long, ResourceRequest& request, const ResourceResponse& response)
 641 {
 642     notImplemented();
 643 }
 644
 645 void FrameLoaderClientWx::dispatchDidReceiveAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&)
 646 {
 647     notImplemented();
 648 }
 649
 650 void FrameLoaderClientWx::dispatchDidCancelAuthenticationChallenge(DocumentLoader*, unsigned long, const AuthenticationChallenge&)
 651 {
 652     notImplemented();
 653 }
 654
 655 void FrameLoaderClientWx::dispatchDidReceiveResponse(DocumentLoader* loader, unsigned long id, const ResourceResponse& response)
 656 {
 657     notImplemented();
 658     m_response = response;
 659     m_firstData = true;
 660 }
 661
 662 void FrameLoaderClientWx::dispatchDidReceiveContentLength(DocumentLoader* loader, unsigned long id, int length)
 663 {
 664     notImplemented();
 665 }
 666
 667 void FrameLoaderClientWx::dispatchDidFinishLoading(DocumentLoader*, unsigned long)
 668 {
 669     notImplemented();
 670 }
 671
 672 void FrameLoaderClientWx::dispatchDidFailLoading(DocumentLoader*, unsigned long, const ResourceError&)
 673 {
 674     notImplemented();
 675 }
 676
 677 bool FrameLoaderClientWx::dispatchDidLoadResourceFromMemoryCache(DocumentLoader*, const ResourceRequest&, const ResourceResponse&, int)
 678 {
 679     notImplemented();
 680     return false;
 681 }
 682
 683 void FrameLoaderClientWx::dispatchDidFailProvisionalLoad(const ResourceError&)
 684 {
 685     notImplemented();
 686 }
 687
 688 void FrameLoaderClientWx::dispatchDidFailLoad(const ResourceError&)
 689 {
 690     notImplemented();
 691 }
 692
 693 Frame* FrameLoaderClientWx::dispatchCreatePage()
 694 {
 695     notImplemented();
 696     return false;
 697 }
 698
 699 void FrameLoaderClientWx::dispatchDecidePolicyForMIMEType(FramePolicyFunction function, const String& mimetype, const ResourceRequest& request)
 700 {
 701     if (!m_frame)
 702         return;
 703
 704     notImplemented();
 705     (m_frame->loader()->*function)(PolicyUse);
 706 }
 707
 708 void FrameLoaderClientWx::dispatchDecidePolicyForNewWindowAction(FramePolicyFunction function, const NavigationAction&, const ResourceRequest&, const String&)
 709 {
 710     if (!m_frame)
 711         return;
 712
 713     notImplemented();
 714     (m_frame->loader()->*function)(PolicyUse);
 715 }
 716
 717 void FrameLoaderClientWx::dispatchDecidePolicyForNavigationAction(FramePolicyFunction function, const NavigationAction& action, const ResourceRequest& request)
 718 {
 719     if (!m_frame)
 720         return;
 721
 722     wxWindow* target = m_frame->view()->nativeWindow();
 723     if (target) {
 724         wxWebViewBeforeLoadEvent wkEvent(target);
 725         wkEvent.SetNavigationType(wxNavTypeFromWebNavType(action.type()));
 726         wkEvent.SetURL(request.url().string());
 727
 728         target->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_frame->view()->nativeWindow();
 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     notImplemented();
 861 }
 862
 863 }