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