src/osx/webview_webkit.mm

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/osx/webview_webkit.mm
   3 // Purpose:     wxWebViewWebKit - embeddable web kit control,
   4 //                             OS X implementation of web view component
   5 // Author:      Jethro Grassie / Kevin Ollivier / Marianne Gagnon
   6 // Modified by:
   7 // Created:     2004-4-16
   8 // RCS-ID:      $Id$
   9 // Copyright:   (c) Jethro Grassie / Kevin Ollivier / Marianne Gagnon
  10 // Licence:     wxWindows licence
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13 // http://developer.apple.com/mac/library/documentation/Cocoa/Reference/WebKit/Classes/WebView_Class/Reference/Reference.html
  14
  15 #include "wx/osx/webview_webkit.h"
  16
  17 #if wxUSE_WEBVIEW && wxUSE_WEBVIEW_WEBKIT && (defined(__WXOSX_COCOA__) \
  18                                           ||  defined(__WXOSX_CARBON__))
  19
  20 // For compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifndef WX_PRECOMP
  24     #include "wx/wx.h"
  25 #endif
  26
  27 #include "wx/osx/private.h"
  28 #include "wx/cocoa/string.h"
  29 #include "wx/hashmap.h"
  30 #include "wx/filesys.h"
  31
  32 #include <WebKit/WebKit.h>
  33 #include <WebKit/HIWebView.h>
  34 #include <WebKit/CarbonUtils.h>
  35
  36 #include <Foundation/NSURLError.h>
  37
  38 #define DEBUG_WEBKIT_SIZING 0
  39
  40 // ----------------------------------------------------------------------------
  41 // macros
  42 // ----------------------------------------------------------------------------
  43
  44 wxIMPLEMENT_DYNAMIC_CLASS(wxWebViewWebKit, wxWebView);
  45
  46 BEGIN_EVENT_TABLE(wxWebViewWebKit, wxControl)
  47 #if defined(__WXMAC__) && wxOSX_USE_CARBON
  48     EVT_SIZE(wxWebViewWebKit::OnSize)
  49 #endif
  50 END_EVENT_TABLE()
  51
  52 #if defined(__WXOSX__) && wxOSX_USE_CARBON
  53
  54 // ----------------------------------------------------------------------------
  55 // Carbon Events handlers
  56 // ----------------------------------------------------------------------------
  57
  58 // prototype for function in src/osx/carbon/nonownedwnd.cpp
  59 void SetupMouseEvent( wxMouseEvent &wxevent , wxMacCarbonEvent &cEvent );
  60
  61 static const EventTypeSpec eventList[] =
  62 {
  63     //{ kEventClassControl, kEventControlTrack } ,
  64     { kEventClassMouse, kEventMouseUp },
  65     { kEventClassMouse, kEventMouseDown },
  66     { kEventClassMouse, kEventMouseMoved },
  67     { kEventClassMouse, kEventMouseDragged },
  68
  69     { kEventClassKeyboard, kEventRawKeyDown } ,
  70     { kEventClassKeyboard, kEventRawKeyRepeat } ,
  71     { kEventClassKeyboard, kEventRawKeyUp } ,
  72     { kEventClassKeyboard, kEventRawKeyModifiersChanged } ,
  73
  74     { kEventClassTextInput, kEventTextInputUnicodeForKeyEvent } ,
  75     { kEventClassTextInput, kEventTextInputUpdateActiveInputArea } ,
  76
  77 #if DEBUG_WEBKIT_SIZING == 1
  78     { kEventClassControl, kEventControlBoundsChanged } ,
  79 #endif
  80 };
  81
  82 // mix this in from window.cpp
  83 pascal OSStatus wxMacUnicodeTextEventHandler(EventHandlerCallRef handler,
  84                                              EventRef event, void *data) ;
  85
  86 // NOTE: This is mostly taken from KeyboardEventHandler in toplevel.cpp, but
  87 // that expects the data pointer is a top-level window, so I needed to change
  88 // that in this case. However, once 2.8 is out, we should factor out the common
  89 // logic among the two functions and merge them.
  90 static pascal OSStatus wxWebKitKeyEventHandler(EventHandlerCallRef handler,
  91                                                EventRef event, void *data)
  92 {
  93     OSStatus result = eventNotHandledErr ;
  94     wxMacCarbonEvent cEvent( event ) ;
  95
  96     wxWebViewWebKit* thisWindow = (wxWebViewWebKit*) data ;
  97     wxWindow* focus = thisWindow ;
  98
  99     unsigned char charCode ;
 100     wxChar uniChar[2] ;
 101     uniChar[0] = 0;
 102     uniChar[1] = 0;
 103
 104     UInt32 keyCode ;
 105     UInt32 modifiers ;
 106     UInt32 when = EventTimeToTicks( GetEventTime( event ) ) ;
 107
 108 #if wxUSE_UNICODE
 109     ByteCount dataSize = 0 ;
 110     if ( GetEventParameter(event, kEventParamKeyUnicodes, typeUnicodeText,
 111                            NULL, 0 , &dataSize, NULL ) == noErr)
 112     {
 113         UniChar buf[2] ;
 114         int numChars = dataSize / sizeof( UniChar) + 1;
 115
 116         UniChar* charBuf = buf ;
 117
 118         if ( numChars * 2 > 4 )
 119             charBuf = new UniChar[ numChars ] ;
 120         GetEventParameter(event, kEventParamKeyUnicodes, typeUnicodeText, NULL,
 121                           dataSize , NULL , charBuf) ;
 122         charBuf[ numChars - 1 ] = 0;
 123
 124 #if SIZEOF_WCHAR_T == 2
 125         uniChar = charBuf[0] ;
 126 #else
 127         wxMBConvUTF16 converter ;
 128         converter.MB2WC( uniChar , (const char*)charBuf , 2 ) ;
 129 #endif
 130
 131         if ( numChars * 2 > 4 )
 132             delete[] charBuf ;
 133     }
 134 #endif
 135
 136     GetEventParameter(event, kEventParamKeyMacCharCodes, typeChar, NULL,
 137                       sizeof(char), NULL, &charCode );
 138     GetEventParameter(event, kEventParamKeyCode, typeUInt32, NULL,
 139                       sizeof(UInt32), NULL, &keyCode );
 140     GetEventParameter(event, kEventParamKeyModifiers, typeUInt32, NULL,
 141                       sizeof(UInt32), NULL, &modifiers );
 142
 143     UInt32 message = (keyCode << 8) + charCode;
 144     switch ( GetEventKind( event ) )
 145     {
 146         case kEventRawKeyRepeat :
 147         case kEventRawKeyDown :
 148         {
 149             WXEVENTREF formerEvent = wxTheApp->MacGetCurrentEvent() ;
 150             WXEVENTHANDLERCALLREF formerHandler =
 151                 wxTheApp->MacGetCurrentEventHandlerCallRef() ;
 152
 153             wxTheApp->MacSetCurrentEvent( event , handler ) ;
 154             if ( /* focus && */ wxTheApp->MacSendKeyDownEvent(
 155                 focus, message, modifiers, when, uniChar[0]))
 156             {
 157                 result = noErr ;
 158             }
 159             wxTheApp->MacSetCurrentEvent( formerEvent , formerHandler ) ;
 160         }
 161         break ;
 162
 163         case kEventRawKeyUp :
 164             if ( /* focus && */ wxTheApp->MacSendKeyUpEvent(
 165                 focus , message , modifiers , when , uniChar[0] ) )
 166             {
 167                 result = noErr ;
 168             }
 169             break ;
 170
 171         case kEventRawKeyModifiersChanged :
 172             {
 173                 wxKeyEvent event(wxEVT_KEY_DOWN);
 174
 175                 event.m_shiftDown = modifiers & shiftKey;
 176                 event.m_controlDown = modifiers & controlKey;
 177                 event.m_altDown = modifiers & optionKey;
 178                 event.m_metaDown = modifiers & cmdKey;
 179
 180 #if wxUSE_UNICODE
 181                 event.m_uniChar = uniChar[0] ;
 182 #endif
 183
 184                 event.SetTimestamp(when);
 185                 event.SetEventObject(focus);
 186
 187                 if ( /* focus && */ (modifiers ^ wxApp::s_lastModifiers ) & controlKey )
 188                 {
 189                     event.m_keyCode = WXK_CONTROL ;
 190                     event.SetEventType( ( modifiers & controlKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
 191                     focus->GetEventHandler()->ProcessEvent( event ) ;
 192                 }
 193                 if ( /* focus && */ (modifiers ^ wxApp::s_lastModifiers ) & shiftKey )
 194                 {
 195                     event.m_keyCode = WXK_SHIFT ;
 196                     event.SetEventType( ( modifiers & shiftKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
 197                     focus->GetEventHandler()->ProcessEvent( event ) ;
 198                 }
 199                 if ( /* focus && */ (modifiers ^ wxApp::s_lastModifiers ) & optionKey )
 200                 {
 201                     event.m_keyCode = WXK_ALT ;
 202                     event.SetEventType( ( modifiers & optionKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
 203                     focus->GetEventHandler()->ProcessEvent( event ) ;
 204                 }
 205                 if ( /* focus && */ (modifiers ^ wxApp::s_lastModifiers ) & cmdKey )
 206                 {
 207                     event.m_keyCode = WXK_COMMAND ;
 208                     event.SetEventType( ( modifiers & cmdKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
 209                     focus->GetEventHandler()->ProcessEvent( event ) ;
 210                 }
 211
 212                 wxApp::s_lastModifiers = modifiers ;
 213             }
 214             break ;
 215
 216         default:
 217             break;
 218     }
 219
 220     return result ;
 221 }
 222
 223 static pascal OSStatus wxWebViewWebKitEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
 224 {
 225     OSStatus result = eventNotHandledErr ;
 226
 227     wxMacCarbonEvent cEvent( event ) ;
 228
 229     ControlRef controlRef ;
 230     wxWebViewWebKit* thisWindow = (wxWebViewWebKit*) data ;
 231     wxNonOwnedWindow* tlw = NULL;
 232     if (thisWindow)
 233         tlw = thisWindow->MacGetTopLevelWindow();
 234
 235     cEvent.GetParameter( kEventParamDirectObject , &controlRef ) ;
 236
 237     wxWindow* currentMouseWindow = thisWindow ;
 238
 239     if ( wxApp::s_captureWindow )
 240         currentMouseWindow = wxApp::s_captureWindow;
 241
 242     switch ( GetEventClass( event ) )
 243     {
 244         case kEventClassKeyboard:
 245         {
 246             result = wxWebKitKeyEventHandler(handler, event, data);
 247             break;
 248         }
 249
 250         case kEventClassTextInput:
 251         {
 252             result = wxMacUnicodeTextEventHandler(handler, event, data);
 253             break;
 254         }
 255
 256         case kEventClassMouse:
 257         {
 258             switch ( GetEventKind( event ) )
 259             {
 260                 case kEventMouseDragged :
 261                 case kEventMouseMoved :
 262                 case kEventMouseDown :
 263                 case kEventMouseUp :
 264                 {
 265                     wxMouseEvent wxevent(wxEVT_LEFT_DOWN);
 266                     SetupMouseEvent( wxevent , cEvent ) ;
 267
 268                     currentMouseWindow->ScreenToClient( &wxevent.m_x , &wxevent.m_y ) ;
 269                     wxevent.SetEventObject( currentMouseWindow ) ;
 270                     wxevent.SetId( currentMouseWindow->GetId() ) ;
 271
 272                     if ( currentMouseWindow->GetEventHandler()->ProcessEvent(wxevent) )
 273                     {
 274                         result = noErr;
 275                     }
 276
 277                     break; // this should enable WebKit to fire mouse dragged and mouse up events...
 278                 }
 279                 default :
 280                     break ;
 281             }
 282         }
 283         default:
 284             break;
 285     }
 286
 287     result = CallNextEventHandler(handler, event);
 288     return result ;
 289 }
 290
 291 DEFINE_ONE_SHOT_HANDLER_GETTER( wxWebViewWebKitEventHandler )
 292
 293 #endif
 294
 295 @interface WebViewLoadDelegate : NSObject
 296 {
 297     wxWebViewWebKit* webKitWindow;
 298 }
 299
 300 - initWithWxWindow: (wxWebViewWebKit*)inWindow;
 301
 302 @end
 303
 304 @interface WebViewPolicyDelegate : NSObject
 305 {
 306     wxWebViewWebKit* webKitWindow;
 307 }
 308
 309 - initWithWxWindow: (wxWebViewWebKit*)inWindow;
 310
 311 @end
 312
 313 @interface WebViewUIDelegate : NSObject
 314 {
 315     wxWebViewWebKit* webKitWindow;
 316 }
 317
 318 - initWithWxWindow: (wxWebViewWebKit*)inWindow;
 319
 320 @end
 321
 322 //We use a hash to map scheme names to wxWebViewHandler
 323 WX_DECLARE_STRING_HASH_MAP(wxSharedPtr<wxWebViewHandler>, wxStringToWebHandlerMap);
 324
 325 static wxStringToWebHandlerMap g_stringHandlerMap;
 326
 327 @interface WebViewCustomProtocol : NSURLProtocol
 328 {
 329 }
 330 @end
 331
 332 // ----------------------------------------------------------------------------
 333 // creation/destruction
 334 // ----------------------------------------------------------------------------
 335
 336 bool wxWebViewWebKit::Create(wxWindow *parent,
 337                                  wxWindowID winID,
 338                                  const wxString& strURL,
 339                                  const wxPoint& pos,
 340                                  const wxSize& size, long style,
 341                                  const wxString& name)
 342 {
 343     m_busy = false;
 344
 345     DontCreatePeer();
 346     wxControl::Create(parent, winID, pos, size, style, wxDefaultValidator, name);
 347
 348 #if wxOSX_USE_CARBON
 349     wxMacControl* peer = new wxMacControl(this);
 350     WebInitForCarbon();
 351     HIWebViewCreate( peer->GetControlRefAddr() );
 352
 353     m_webView = (WebView*) HIWebViewGetWebView( peer->GetControlRef() );
 354
 355 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_3
 356     if ( UMAGetSystemVersion() >= 0x1030 )
 357         HIViewChangeFeatures( peer->GetControlRef() , kHIViewIsOpaque , 0 ) ;
 358 #endif
 359     InstallControlEventHandler(peer->GetControlRef(),
 360                                GetwxWebViewWebKitEventHandlerUPP(),
 361                                GetEventTypeCount(eventList), eventList, this,
 362                               (EventHandlerRef *)&m_webKitCtrlEventHandler);
 363     SetPeer(peer);
 364 #else
 365     NSRect r = wxOSXGetFrameForControl( this, pos , size ) ;
 366     m_webView = [[WebView alloc] initWithFrame:r
 367                                      frameName:@"webkitFrame"
 368                                      groupName:@"webkitGroup"];
 369     SetPeer(new wxWidgetCocoaImpl( this, m_webView ));
 370 #endif
 371
 372     MacPostControlCreate(pos, size);
 373
 374 #if wxOSX_USE_CARBON
 375     HIViewSetVisible( GetPeer()->GetControlRef(), true );
 376 #endif
 377     [m_webView setHidden:false];
 378
 379
 380
 381     // Register event listener interfaces
 382     WebViewLoadDelegate* loadDelegate =
 383             [[WebViewLoadDelegate alloc] initWithWxWindow: this];
 384
 385     [m_webView setFrameLoadDelegate:loadDelegate];
 386
 387     // this is used to veto page loads, etc.
 388     WebViewPolicyDelegate* policyDelegate =
 389             [[WebViewPolicyDelegate alloc] initWithWxWindow: this];
 390
 391     [m_webView setPolicyDelegate:policyDelegate];
 392
 393     WebViewUIDelegate* uiDelegate =
 394             [[WebViewUIDelegate alloc] initWithWxWindow: this];
 395
 396     [m_webView setUIDelegate:uiDelegate];
 397
 398     //Register our own class for custom scheme handling
 399     [NSURLProtocol registerClass:[WebViewCustomProtocol class]];
 400
 401     LoadURL(strURL);
 402     return true;
 403 }
 404
 405 wxWebViewWebKit::~wxWebViewWebKit()
 406 {
 407     WebViewLoadDelegate* loadDelegate = [m_webView frameLoadDelegate];
 408     WebViewPolicyDelegate* policyDelegate = [m_webView policyDelegate];
 409     WebViewUIDelegate* uiDelegate = [m_webView UIDelegate];
 410     [m_webView setFrameLoadDelegate: nil];
 411     [m_webView setPolicyDelegate: nil];
 412     [m_webView setUIDelegate: nil];
 413
 414     if (loadDelegate)
 415         [loadDelegate release];
 416
 417     if (policyDelegate)
 418         [policyDelegate release];
 419
 420     if (uiDelegate)
 421         [uiDelegate release];
 422 }
 423
 424 // ----------------------------------------------------------------------------
 425 // public methods
 426 // ----------------------------------------------------------------------------
 427
 428 bool wxWebViewWebKit::CanGoBack() const
 429 {
 430     if ( !m_webView )
 431         return false;
 432
 433     return [m_webView canGoBack];
 434 }
 435
 436 bool wxWebViewWebKit::CanGoForward() const
 437 {
 438     if ( !m_webView )
 439         return false;
 440
 441     return [m_webView canGoForward];
 442 }
 443
 444 void wxWebViewWebKit::GoBack()
 445 {
 446     if ( !m_webView )
 447         return;
 448
 449     [(WebView*)m_webView goBack];
 450 }
 451
 452 void wxWebViewWebKit::GoForward()
 453 {
 454     if ( !m_webView )
 455         return;
 456
 457     [(WebView*)m_webView goForward];
 458 }
 459
 460 void wxWebViewWebKit::Reload(wxWebViewReloadFlags flags)
 461 {
 462     if ( !m_webView )
 463         return;
 464
 465     if (flags & wxWEB_VIEW_RELOAD_NO_CACHE)
 466     {
 467         // TODO: test this indeed bypasses the cache
 468         [[m_webView preferences] setUsesPageCache:NO];
 469         [[m_webView mainFrame] reload];
 470         [[m_webView preferences] setUsesPageCache:YES];
 471     }
 472     else
 473     {
 474         [[m_webView mainFrame] reload];
 475     }
 476 }
 477
 478 void wxWebViewWebKit::Stop()
 479 {
 480     if ( !m_webView )
 481         return;
 482
 483     [[m_webView mainFrame] stopLoading];
 484 }
 485
 486 bool wxWebViewWebKit::CanGetPageSource() const
 487 {
 488     if ( !m_webView )
 489         return false;
 490
 491     WebDataSource* dataSource = [[m_webView mainFrame] dataSource];
 492     return ( [[dataSource representation] canProvideDocumentSource] );
 493 }
 494
 495 wxString wxWebViewWebKit::GetPageSource() const
 496 {
 497
 498     if (CanGetPageSource())
 499         {
 500         WebDataSource* dataSource = [[m_webView mainFrame] dataSource];
 501                 wxASSERT (dataSource != nil);
 502
 503                 id<WebDocumentRepresentation> representation = [dataSource representation];
 504                 wxASSERT (representation != nil);
 505
 506                 NSString* source = [representation documentSource];
 507                 if (source == nil)
 508                 {
 509                         return wxEmptyString;
 510                 }
 511
 512         return wxStringWithNSString( source );
 513     }
 514
 515     return wxEmptyString;
 516 }
 517
 518 bool wxWebViewWebKit::CanIncreaseTextSize() const
 519 {
 520     if ( !m_webView )
 521         return false;
 522
 523     if ([m_webView canMakeTextLarger])
 524         return true;
 525     else
 526         return false;
 527 }
 528
 529 void wxWebViewWebKit::IncreaseTextSize()
 530 {
 531     if ( !m_webView )
 532         return;
 533
 534     if (CanIncreaseTextSize())
 535         [m_webView makeTextLarger:(WebView*)m_webView];
 536 }
 537
 538 bool wxWebViewWebKit::CanDecreaseTextSize() const
 539 {
 540     if ( !m_webView )
 541         return false;
 542
 543     if ([m_webView canMakeTextSmaller])
 544         return true;
 545     else
 546         return false;
 547 }
 548
 549 void wxWebViewWebKit::DecreaseTextSize()
 550 {
 551     if ( !m_webView )
 552         return;
 553
 554     if (CanDecreaseTextSize())
 555         [m_webView makeTextSmaller:(WebView*)m_webView];
 556 }
 557
 558 void wxWebViewWebKit::Print()
 559 {
 560
 561     // TODO: allow specifying the "show prompt" parameter in Print() ?
 562     bool showPrompt = true;
 563
 564     if ( !m_webView )
 565         return;
 566
 567     id view = [[[m_webView mainFrame] frameView] documentView];
 568     NSPrintOperation *op = [NSPrintOperation printOperationWithView:view
 569                                  printInfo: [NSPrintInfo sharedPrintInfo]];
 570     if (showPrompt)
 571     {
 572         [op setShowsPrintPanel: showPrompt];
 573         // in my tests, the progress bar always freezes and it stops the whole
 574         // print operation. do not turn this to true unless there is a
 575         // workaround for the bug.
 576         [op setShowsProgressPanel: false];
 577     }
 578     // Print it.
 579     [op runOperation];
 580 }
 581
 582 void wxWebViewWebKit::SetEditable(bool enable)
 583 {
 584     if ( !m_webView )
 585         return;
 586
 587     [m_webView setEditable:enable ];
 588 }
 589
 590 bool wxWebViewWebKit::IsEditable() const
 591 {
 592     if ( !m_webView )
 593         return false;
 594
 595     return [m_webView isEditable];
 596 }
 597
 598 void wxWebViewWebKit::SetZoomType(wxWebViewZoomType zoomType)
 599 {
 600     // there is only one supported zoom type at the moment so this setter
 601     // does nothing beyond checking sanity
 602     wxASSERT(zoomType == wxWEB_VIEW_ZOOM_TYPE_TEXT);
 603 }
 604
 605 wxWebViewZoomType wxWebViewWebKit::GetZoomType() const
 606 {
 607     // for now that's the only one that is supported
 608     // FIXME: does the default zoom type change depending on webkit versions? :S
 609     //        Then this will be wrong
 610     return wxWEB_VIEW_ZOOM_TYPE_TEXT;
 611 }
 612
 613 bool wxWebViewWebKit::CanSetZoomType(wxWebViewZoomType type) const
 614 {
 615     switch (type)
 616     {
 617         // for now that's the only one that is supported
 618         // TODO: I know recent versions of webkit support layout zoom too,
 619         //       check if we can support it
 620         case wxWEB_VIEW_ZOOM_TYPE_TEXT:
 621             return true;
 622
 623         default:
 624             return false;
 625     }
 626 }
 627
 628 int wxWebViewWebKit::GetScrollPos()
 629 {
 630     id result = [[m_webView windowScriptObject]
 631                     evaluateWebScript:@"document.body.scrollTop"];
 632     return [result intValue];
 633 }
 634
 635 void wxWebViewWebKit::SetScrollPos(int pos)
 636 {
 637     if ( !m_webView )
 638         return;
 639
 640     wxString javascript;
 641     javascript.Printf(wxT("document.body.scrollTop = %d;"), pos);
 642     [[m_webView windowScriptObject] evaluateWebScript:
 643             (NSString*)wxNSStringWithWxString( javascript )];
 644 }
 645
 646 wxString wxWebViewWebKit::GetSelectedText() const
 647 {
 648     NSString* selection = [[m_webView selectedDOMRange] markupString];
 649     if (!selection) return wxEmptyString;
 650
 651     return wxStringWithNSString(selection);
 652 }
 653
 654 void wxWebViewWebKit::RunScript(const wxString& javascript)
 655 {
 656     if ( !m_webView )
 657         return;
 658
 659     [[m_webView windowScriptObject] evaluateWebScript:
 660                     (NSString*)wxNSStringWithWxString( javascript )];
 661 }
 662
 663 void wxWebViewWebKit::OnSize(wxSizeEvent &event)
 664 {
 665 #if defined(__WXMAC__) && wxOSX_USE_CARBON
 666     // This is a nasty hack because WebKit seems to lose its position when it is
 667     // embedded in a control that is not itself the content view for a TLW.
 668     // I put it in OnSize because these calcs are not perfect, and in fact are
 669     // basically guesses based on reverse engineering, so it's best to give
 670     // people the option of overriding OnSize with their own calcs if need be.
 671     // I also left some test debugging print statements as a convenience if
 672     // a(nother) problem crops up.
 673
 674     wxWindow* tlw = MacGetTopLevelWindow();
 675
 676     NSRect frame = [(WebView*)m_webView frame];
 677     NSRect bounds = [(WebView*)m_webView bounds];
 678
 679 #if DEBUG_WEBKIT_SIZING
 680     fprintf(stderr,"Carbon window x=%d, y=%d, width=%d, height=%d\n",
 681             GetPosition().x, GetPosition().y, GetSize().x, GetSize().y);
 682     fprintf(stderr, "Cocoa window frame x=%G, y=%G, width=%G, height=%G\n",
 683             frame.origin.x, frame.origin.y,
 684             frame.size.width, frame.size.height);
 685     fprintf(stderr, "Cocoa window bounds x=%G, y=%G, width=%G, height=%G\n",
 686             bounds.origin.x, bounds.origin.y,
 687             bounds.size.width, bounds.size.height);
 688 #endif
 689
 690     // This must be the case that Apple tested with, because well, in this one case
 691     // we don't need to do anything! It just works. ;)
 692     if (GetParent() == tlw) return;
 693
 694     // since we no longer use parent coordinates, we always want 0,0.
 695     int x = 0;
 696     int y = 0;
 697
 698     HIRect rect;
 699     rect.origin.x = x;
 700     rect.origin.y = y;
 701
 702 #if DEBUG_WEBKIT_SIZING
 703     printf("Before conversion, origin is: x = %d, y = %d\n", x, y);
 704 #endif
 705
 706     // NB: In most cases, when calling HIViewConvertRect, what people want is to
 707     // use GetRootControl(), and this tripped me up at first. But in fact, what
 708     // we want is the root view, because we need to make the y origin relative
 709     // to the very top of the window, not its contents, since we later flip
 710     // the y coordinate for Cocoa.
 711     HIViewConvertRect (&rect, GetPeer()->GetControlRef(),
 712                                 HIViewGetRoot(
 713                                     (WindowRef) MacGetTopLevelWindowRef()
 714                                  ));
 715
 716     x = (int)rect.origin.x;
 717     y = (int)rect.origin.y;
 718
 719 #if DEBUG_WEBKIT_SIZING
 720     printf("Moving Cocoa frame origin to: x = %d, y = %d\n", x, y);
 721 #endif
 722
 723     if (tlw){
 724         //flip the y coordinate to convert to Cocoa coordinates
 725         y = tlw->GetSize().y - ((GetSize().y) + y);
 726     }
 727
 728 #if DEBUG_WEBKIT_SIZING
 729     printf("y = %d after flipping value\n", y);
 730 #endif
 731
 732     frame.origin.x = x;
 733     frame.origin.y = y;
 734     [(WebView*)m_webView setFrame:frame];
 735
 736     if (IsShown())
 737         [(WebView*)m_webView display];
 738     event.Skip();
 739 #endif
 740 }
 741
 742 void wxWebViewWebKit::MacVisibilityChanged(){
 743 #if defined(__WXMAC__) && wxOSX_USE_CARBON
 744     bool isHidden = !IsControlVisible( GetPeer()->GetControlRef());
 745     if (!isHidden)
 746         [(WebView*)m_webView display];
 747
 748     [m_webView setHidden:isHidden];
 749 #endif
 750 }
 751
 752 void wxWebViewWebKit::LoadURL(const wxString& url)
 753 {
 754     [[m_webView mainFrame] loadRequest:[NSURLRequest requestWithURL:
 755             [NSURL URLWithString:wxNSStringWithWxString(url)]]];
 756 }
 757
 758 wxString wxWebViewWebKit::GetCurrentURL() const
 759 {
 760     return wxStringWithNSString([m_webView mainFrameURL]);
 761 }
 762
 763 wxString wxWebViewWebKit::GetCurrentTitle() const
 764 {
 765     return wxStringWithNSString([m_webView mainFrameTitle]);
 766 }
 767
 768 float wxWebViewWebKit::GetWebkitZoom() const
 769 {
 770     return [m_webView textSizeMultiplier];
 771 }
 772
 773 void wxWebViewWebKit::SetWebkitZoom(float zoom)
 774 {
 775     [m_webView setTextSizeMultiplier:zoom];
 776 }
 777
 778 wxWebViewZoom wxWebViewWebKit::GetZoom() const
 779 {
 780     float zoom = GetWebkitZoom();
 781
 782     // arbitrary way to map float zoom to our common zoom enum
 783     if (zoom <= 0.55)
 784     {
 785         return wxWEB_VIEW_ZOOM_TINY;
 786     }
 787     else if (zoom > 0.55 && zoom <= 0.85)
 788     {
 789         return wxWEB_VIEW_ZOOM_SMALL;
 790     }
 791     else if (zoom > 0.85 && zoom <= 1.15)
 792     {
 793         return wxWEB_VIEW_ZOOM_MEDIUM;
 794     }
 795     else if (zoom > 1.15 && zoom <= 1.45)
 796     {
 797         return wxWEB_VIEW_ZOOM_LARGE;
 798     }
 799     else if (zoom > 1.45)
 800     {
 801         return wxWEB_VIEW_ZOOM_LARGEST;
 802     }
 803
 804     // to shut up compilers, this can never be reached logically
 805     wxASSERT(false);
 806     return wxWEB_VIEW_ZOOM_MEDIUM;
 807 }
 808
 809 void wxWebViewWebKit::SetZoom(wxWebViewZoom zoom)
 810 {
 811     // arbitrary way to map our common zoom enum to float zoom
 812     switch (zoom)
 813     {
 814         case wxWEB_VIEW_ZOOM_TINY:
 815             SetWebkitZoom(0.4f);
 816             break;
 817
 818         case wxWEB_VIEW_ZOOM_SMALL:
 819             SetWebkitZoom(0.7f);
 820             break;
 821
 822         case wxWEB_VIEW_ZOOM_MEDIUM:
 823             SetWebkitZoom(1.0f);
 824             break;
 825
 826         case wxWEB_VIEW_ZOOM_LARGE:
 827             SetWebkitZoom(1.3);
 828             break;
 829
 830         case wxWEB_VIEW_ZOOM_LARGEST:
 831             SetWebkitZoom(1.6);
 832             break;
 833
 834         default:
 835             wxASSERT(false);
 836     }
 837
 838 }
 839
 840 void wxWebViewWebKit::DoSetPage(const wxString& src, const wxString& baseUrl)
 841 {
 842    if ( !m_webView )
 843         return;
 844
 845     [[m_webView mainFrame] loadHTMLString:(NSString*)wxNSStringWithWxString(src)
 846                                   baseURL:[NSURL URLWithString:
 847                                     wxNSStringWithWxString( baseUrl )]];
 848 }
 849
 850 void wxWebViewWebKit::Cut()
 851 {
 852     if ( !m_webView )
 853         return;
 854
 855     [(WebView*)m_webView cut:m_webView];
 856 }
 857
 858 void wxWebViewWebKit::Copy()
 859 {
 860     if ( !m_webView )
 861         return;
 862
 863     [(WebView*)m_webView copy:m_webView];
 864 }
 865
 866 void wxWebViewWebKit::Paste()
 867 {
 868     if ( !m_webView )
 869         return;
 870
 871     [(WebView*)m_webView paste:m_webView];
 872 }
 873
 874 void wxWebViewWebKit::DeleteSelection()
 875 {
 876     if ( !m_webView )
 877         return;
 878
 879     [(WebView*)m_webView deleteSelection];
 880 }
 881
 882 bool wxWebViewWebKit::HasSelection() const
 883 {
 884     DOMRange* range = [m_webView selectedDOMRange];
 885     if(!range)
 886     {
 887         return false;
 888     }
 889     else
 890     {
 891         return true;
 892     }
 893 }
 894
 895 void wxWebViewWebKit::ClearSelection()
 896 {
 897     //We use javascript as selection isn't exposed at the moment in webkit
 898     RunScript("window.getSelection().removeAllRanges();");
 899 }
 900
 901 void wxWebViewWebKit::SelectAll()
 902 {
 903     RunScript("window.getSelection().selectAllChildren(document.body);");
 904 }
 905
 906 wxString wxWebViewWebKit::GetSelectedSource() const
 907 {
 908     wxString script = ("var range = window.getSelection().getRangeAt(0);"
 909                        "var element = document.createElement('div');"
 910                        "element.appendChild(range.cloneContents());"
 911                        "return element.innerHTML;");
 912     id result = [[m_webView windowScriptObject]
 913                    evaluateWebScript:wxNSStringWithWxString(script)];
 914     return wxStringWithNSString([result stringValue]);
 915 }
 916
 917 wxString wxWebViewWebKit::GetPageText() const
 918 {
 919     id result = [[m_webView windowScriptObject]
 920                  evaluateWebScript:@"document.body.textContent"];
 921     return wxStringWithNSString([result stringValue]);
 922 }
 923
 924 void wxWebViewWebKit::EnableHistory(bool enable)
 925 {
 926     if ( !m_webView )
 927         return;
 928
 929     [m_webView setMaintainsBackForwardList:enable];
 930 }
 931
 932 void wxWebViewWebKit::ClearHistory()
 933 {
 934     [m_webView setMaintainsBackForwardList:NO];
 935     [m_webView setMaintainsBackForwardList:YES];
 936 }
 937
 938 wxVector<wxSharedPtr<wxWebViewHistoryItem> > wxWebViewWebKit::GetBackwardHistory()
 939 {
 940     wxVector<wxSharedPtr<wxWebViewHistoryItem> > backhist;
 941     WebBackForwardList* history = [m_webView backForwardList];
 942     int count = [history backListCount];
 943     for(int i = -count; i < 0; i++)
 944     {
 945         WebHistoryItem* item = [history itemAtIndex:i];
 946         wxString url = wxStringWithNSString([item URLString]);
 947         wxString title = wxStringWithNSString([item title]);
 948         wxWebViewHistoryItem* wxitem = new wxWebViewHistoryItem(url, title);
 949         wxitem->m_histItem = item;
 950         wxSharedPtr<wxWebViewHistoryItem> itemptr(wxitem);
 951         backhist.push_back(itemptr);
 952     }
 953     return backhist;
 954 }
 955
 956 wxVector<wxSharedPtr<wxWebViewHistoryItem> > wxWebViewWebKit::GetForwardHistory()
 957 {
 958     wxVector<wxSharedPtr<wxWebViewHistoryItem> > forwardhist;
 959     WebBackForwardList* history = [m_webView backForwardList];
 960     int count = [history forwardListCount];
 961     for(int i = 1; i <= count; i++)
 962     {
 963         WebHistoryItem* item = [history itemAtIndex:i];
 964         wxString url = wxStringWithNSString([item URLString]);
 965         wxString title = wxStringWithNSString([item title]);
 966         wxWebViewHistoryItem* wxitem = new wxWebViewHistoryItem(url, title);
 967         wxitem->m_histItem = item;
 968         wxSharedPtr<wxWebViewHistoryItem> itemptr(wxitem);
 969         forwardhist.push_back(itemptr);
 970     }
 971     return forwardhist;
 972 }
 973
 974 void wxWebViewWebKit::LoadHistoryItem(wxSharedPtr<wxWebViewHistoryItem> item)
 975 {
 976     [m_webView goToBackForwardItem:item->m_histItem];
 977 }
 978
 979 bool wxWebViewWebKit::CanUndo() const
 980 {
 981     return [[m_webView undoManager] canUndo];
 982 }
 983
 984 bool wxWebViewWebKit::CanRedo() const
 985 {
 986     return [[m_webView undoManager] canRedo];
 987 }
 988
 989 void wxWebViewWebKit::Undo()
 990 {
 991     [[m_webView undoManager] undo];
 992 }
 993
 994 void wxWebViewWebKit::Redo()
 995 {
 996     [[m_webView undoManager] redo];
 997 }
 998
 999 void wxWebViewWebKit::RegisterHandler(wxSharedPtr<wxWebViewHandler> handler)
1000 {
1001     g_stringHandlerMap[handler->GetName()] = handler;
1002 }
1003
1004 //------------------------------------------------------------
1005 // Listener interfaces
1006 //------------------------------------------------------------
1007
1008 // NB: I'm still tracking this down, but it appears the Cocoa window
1009 // still has these events fired on it while the Carbon control is being
1010 // destroyed. Therefore, we must be careful to check both the existence
1011 // of the Carbon control and the event handler before firing events.
1012
1013 @implementation WebViewLoadDelegate
1014
1015 - initWithWxWindow: (wxWebViewWebKit*)inWindow
1016 {
1017     [super init];
1018     webKitWindow = inWindow;    // non retained
1019     return self;
1020 }
1021
1022 - (void)webView:(WebView *)sender
1023     didStartProvisionalLoadForFrame:(WebFrame *)frame
1024 {
1025     webKitWindow->m_busy = true;
1026 }
1027
1028 - (void)webView:(WebView *)sender didCommitLoadForFrame:(WebFrame *)frame
1029 {
1030     webKitWindow->m_busy = true;
1031
1032     if (webKitWindow && frame == [sender mainFrame]){
1033         NSString *url = [[[[frame dataSource] request] URL] absoluteString];
1034         wxString target = wxStringWithNSString([frame name]);
1035         wxWebViewEvent event(wxEVT_COMMAND_WEB_VIEW_NAVIGATED,
1036                              webKitWindow->GetId(),
1037                              wxStringWithNSString( url ),
1038                              target);
1039
1040         if (webKitWindow && webKitWindow->GetEventHandler())
1041             webKitWindow->GetEventHandler()->ProcessEvent(event);
1042     }
1043 }
1044
1045 - (void)webView:(WebView *)sender didFinishLoadForFrame:(WebFrame *)frame
1046 {
1047     webKitWindow->m_busy = false;
1048
1049     if (webKitWindow && frame == [sender mainFrame]){
1050         NSString *url = [[[[frame dataSource] request] URL] absoluteString];
1051
1052         wxString target = wxStringWithNSString([frame name]);
1053         wxWebViewEvent event(wxEVT_COMMAND_WEB_VIEW_LOADED,
1054                              webKitWindow->GetId(),
1055                              wxStringWithNSString( url ),
1056                              target);
1057
1058         if (webKitWindow && webKitWindow->GetEventHandler())
1059             webKitWindow->GetEventHandler()->ProcessEvent(event);
1060     }
1061 }
1062
1063 wxString nsErrorToWxHtmlError(NSError* error, wxWebViewNavigationError* out)
1064 {
1065     *out = wxWEB_NAV_ERR_OTHER;
1066
1067     if ([[error domain] isEqualToString:NSURLErrorDomain])
1068     {
1069         switch ([error code])
1070         {
1071             case NSURLErrorCannotFindHost:
1072             case NSURLErrorFileDoesNotExist:
1073             case NSURLErrorRedirectToNonExistentLocation:
1074                 *out = wxWEB_NAV_ERR_NOT_FOUND;
1075                 break;
1076
1077             case NSURLErrorResourceUnavailable:
1078             case NSURLErrorHTTPTooManyRedirects:
1079 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
1080             case NSURLErrorDataLengthExceedsMaximum:
1081 #endif
1082             case NSURLErrorBadURL:
1083             case NSURLErrorFileIsDirectory:
1084                 *out = wxWEB_NAV_ERR_REQUEST;
1085                 break;
1086
1087             case NSURLErrorTimedOut:
1088             case NSURLErrorDNSLookupFailed:
1089             case NSURLErrorNetworkConnectionLost:
1090             case NSURLErrorCannotConnectToHost:
1091             case NSURLErrorNotConnectedToInternet:
1092             //case NSURLErrorInternationalRoamingOff:
1093             //case NSURLErrorCallIsActive:
1094             //case NSURLErrorDataNotAllowed:
1095                 *out = wxWEB_NAV_ERR_CONNECTION;
1096                 break;
1097
1098             case NSURLErrorCancelled:
1099             case NSURLErrorUserCancelledAuthentication:
1100                 *out = wxWEB_NAV_ERR_USER_CANCELLED;
1101                 break;
1102
1103 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
1104             case NSURLErrorCannotDecodeRawData:
1105             case NSURLErrorCannotDecodeContentData:
1106             case NSURLErrorCannotParseResponse:
1107 #endif
1108             case NSURLErrorBadServerResponse:
1109                 *out = wxWEB_NAV_ERR_REQUEST;
1110                 break;
1111
1112             case NSURLErrorUserAuthenticationRequired:
1113             case NSURLErrorSecureConnectionFailed:
1114 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
1115             case NSURLErrorClientCertificateRequired:
1116 #endif
1117                 *out = wxWEB_NAV_ERR_AUTH;
1118                 break;
1119
1120             case NSURLErrorNoPermissionsToReadFile:
1121                                 *out = wxWEB_NAV_ERR_SECURITY;
1122                 break;
1123
1124             case NSURLErrorServerCertificateHasBadDate:
1125             case NSURLErrorServerCertificateUntrusted:
1126             case NSURLErrorServerCertificateHasUnknownRoot:
1127             case NSURLErrorServerCertificateNotYetValid:
1128             case NSURLErrorClientCertificateRejected:
1129                 *out = wxWEB_NAV_ERR_CERTIFICATE;
1130                 break;
1131         }
1132     }
1133
1134     wxString message = wxStringWithNSString([error localizedDescription]);
1135     NSString* detail = [error localizedFailureReason];
1136     if (detail != NULL)
1137     {
1138         message = message + " (" + wxStringWithNSString(detail) + ")";
1139     }
1140     return message;
1141 }
1142
1143 - (void)webView:(WebView *)sender didFailLoadWithError:(NSError*) error
1144         forFrame:(WebFrame *)frame
1145 {
1146     webKitWindow->m_busy = false;
1147
1148     if (webKitWindow && frame == [sender mainFrame]){
1149         NSString *url = [[[[frame dataSource] request] URL] absoluteString];
1150
1151         wxWebViewNavigationError type;
1152         wxString description = nsErrorToWxHtmlError(error, &type);
1153                 wxWebViewEvent event(wxEVT_COMMAND_WEB_VIEW_ERROR,
1154                                      webKitWindow->GetId(),
1155                              wxStringWithNSString( url ),
1156                              wxEmptyString);
1157                 event.SetString(description);
1158                 event.SetInt(type);
1159
1160                 if (webKitWindow && webKitWindow->GetEventHandler())
1161                 {
1162                         webKitWindow->GetEventHandler()->ProcessEvent(event);
1163                 }
1164     }
1165 }
1166
1167 - (void)webView:(WebView *)sender
1168         didFailProvisionalLoadWithError:(NSError*)error
1169                                forFrame:(WebFrame *)frame
1170 {
1171     webKitWindow->m_busy = false;
1172
1173     if (webKitWindow && frame == [sender mainFrame]){
1174         NSString *url = [[[[frame provisionalDataSource] request] URL]
1175                             absoluteString];
1176
1177                 wxWebViewNavigationError type;
1178         wxString description = nsErrorToWxHtmlError(error, &type);
1179                 wxWebViewEvent event(wxEVT_COMMAND_WEB_VIEW_ERROR,
1180                                      webKitWindow->GetId(),
1181                              wxStringWithNSString( url ),
1182                              wxEmptyString);
1183                 event.SetString(description);
1184                 event.SetInt(type);
1185
1186                 if (webKitWindow && webKitWindow->GetEventHandler())
1187                         webKitWindow->GetEventHandler()->ProcessEvent(event);
1188     }
1189 }
1190
1191 - (void)webView:(WebView *)sender didReceiveTitle:(NSString *)title
1192                                          forFrame:(WebFrame *)frame
1193 {
1194     wxString target = wxStringWithNSString([frame name]);
1195     wxWebViewEvent event(wxEVT_COMMAND_WEB_VIEW_TITLE_CHANGED,
1196                          webKitWindow->GetId(),
1197                          webKitWindow->GetCurrentURL(),
1198                          target);
1199
1200     event.SetString(wxStringWithNSString(title));
1201
1202     if (webKitWindow && webKitWindow->GetEventHandler())
1203         webKitWindow->GetEventHandler()->ProcessEvent(event);
1204 }
1205 @end
1206
1207 @implementation WebViewPolicyDelegate
1208
1209 - initWithWxWindow: (wxWebViewWebKit*)inWindow
1210 {
1211     [super init];
1212     webKitWindow = inWindow;    // non retained
1213     return self;
1214 }
1215
1216 - (void)webView:(WebView *)sender
1217         decidePolicyForNavigationAction:(NSDictionary *)actionInformation
1218                                 request:(NSURLRequest *)request
1219                                   frame:(WebFrame *)frame
1220                        decisionListener:(id<WebPolicyDecisionListener>)listener
1221 {
1222     wxUnusedVar(frame);
1223
1224     webKitWindow->m_busy = true;
1225     NSString *url = [[request URL] absoluteString];
1226     wxString target = wxStringWithNSString([frame name]);
1227     wxWebViewEvent event(wxEVT_COMMAND_WEB_VIEW_NAVIGATING,
1228                          webKitWindow->GetId(),
1229                          wxStringWithNSString( url ), target);
1230
1231     if (webKitWindow && webKitWindow->GetEventHandler())
1232         webKitWindow->GetEventHandler()->ProcessEvent(event);
1233
1234     if (!event.IsAllowed())
1235     {
1236         webKitWindow->m_busy = false;
1237         [listener ignore];
1238     }
1239     else
1240     {
1241         [listener use];
1242     }
1243 }
1244
1245 - (void)webView:(WebView *)sender
1246       decidePolicyForNewWindowAction:(NSDictionary *)actionInformation
1247                              request:(NSURLRequest *)request
1248                         newFrameName:(NSString *)frameName
1249                     decisionListener:(id < WebPolicyDecisionListener >)listener
1250 {
1251     wxUnusedVar(actionInformation);
1252
1253     NSString *url = [[request URL] absoluteString];
1254     wxWebViewEvent event(wxEVT_COMMAND_WEB_VIEW_NEWWINDOW,
1255                          webKitWindow->GetId(),
1256                          wxStringWithNSString( url ), "");
1257
1258     if (webKitWindow && webKitWindow->GetEventHandler())
1259         webKitWindow->GetEventHandler()->ProcessEvent(event);
1260
1261     [listener ignore];
1262 }
1263 @end
1264
1265 @implementation WebViewCustomProtocol
1266
1267 + (BOOL)canInitWithRequest:(NSURLRequest *)request
1268 {
1269     NSString *scheme = [[request URL] scheme];
1270
1271     wxStringToWebHandlerMap::const_iterator it;
1272     for( it = g_stringHandlerMap.begin(); it != g_stringHandlerMap.end(); ++it )
1273     {
1274         if(it->first.IsSameAs(wxStringWithNSString(scheme)))
1275         {
1276             return YES;
1277         }
1278     }
1279
1280         return NO;
1281 }
1282
1283 + (NSURLRequest *)canonicalRequestForRequest:(NSURLRequest *)request
1284 {
1285     //We don't do any processing here as the wxWebViewHandler classes do it
1286     return request;
1287 }
1288
1289 - (void)startLoading
1290 {
1291     NSURLRequest *request = [self request];
1292         NSString* path = [[request URL] absoluteString];
1293
1294     wxString wxpath = wxStringWithNSString(path);
1295     wxString scheme = wxStringWithNSString([[request URL] scheme]);
1296     wxFSFile* file = g_stringHandlerMap[scheme]->GetFile(wxpath);
1297     size_t length = file->GetStream()->GetLength();
1298
1299
1300     NSURLResponse *response =  [[NSURLResponse alloc] initWithURL:[request URL]
1301                                            MIMEType:wxNSStringWithWxString(file->GetMimeType())
1302                                            expectedContentLength:length
1303                                            textEncodingName:nil];
1304
1305     //Load the data, we malloc it so it is tidied up properly
1306     void* buffer = malloc(length);
1307     file->GetStream()->Read(buffer, length);
1308     NSData *data = [[NSData alloc] initWithBytesNoCopy:buffer length:length];
1309
1310     id<NSURLProtocolClient> client = [self client];
1311
1312     //We do not support caching anything yet
1313         [client URLProtocol:self didReceiveResponse:response
1314             cacheStoragePolicy:NSURLCacheStorageNotAllowed];
1315
1316     //Set the data
1317         [client URLProtocol:self didLoadData:data];
1318
1319         //Notify that we have finished
1320         [client URLProtocolDidFinishLoading:self];
1321
1322         [response release];
1323 }
1324
1325 - (void)stopLoading
1326 {
1327
1328 }
1329
1330 @end
1331
1332
1333 @implementation WebViewUIDelegate
1334
1335 - initWithWxWindow: (wxWebViewWebKit*)inWindow
1336 {
1337     [super init];
1338     webKitWindow = inWindow;    // non retained
1339     return self;
1340 }
1341
1342 - (void)webView:(WebView *)sender printFrameView:(WebFrameView *)frameView
1343 {
1344     wxUnusedVar(sender);
1345     wxUnusedVar(frameView);
1346
1347     webKitWindow->Print();
1348 }
1349 @end
1350
1351 #endif //wxUSE_WEBVIEW && wxUSE_WEBVIEW_WEBKIT