src/html/htmlctrl/webkit/webkit.mm

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        webkit.mm
   3 // Purpose:     wxWebKitCtrl - embeddable web kit control
   4 // Author:      Jethro Grassie / Kevin Ollivier
   5 // Modified by:
   6 // Created:     2004-4-16
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Jethro Grassie / Kevin Ollivier
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // For compilers that support precompilation, includes "wx.h".
  13 #include "wx/wxprec.h"
  14 #include "wx/splitter.h"
  15
  16 #ifndef WX_PRECOMP
  17     #include "wx/wx.h"
  18 #endif
  19
  20 #if wxUSE_WEBKIT
  21
  22 #ifdef __WXCOCOA__
  23 #include "wx/cocoa/autorelease.h"
  24 #else
  25 #include "wx/osx/private.h"
  26
  27 #include <WebKit/WebKit.h>
  28 #include <WebKit/HIWebView.h>
  29 #include <WebKit/CarbonUtils.h>
  30 #endif
  31
  32 #include "wx/html/webkit.h"
  33
  34 #define DEBUG_WEBKIT_SIZING 0
  35
  36 extern WXDLLEXPORT_DATA(const char) wxWebKitCtrlNameStr[] = "webkitctrl";
  37
  38 // ----------------------------------------------------------------------------
  39 // macros
  40 // ----------------------------------------------------------------------------
  41
  42 IMPLEMENT_DYNAMIC_CLASS(wxWebKitCtrl, wxControl)
  43
  44 BEGIN_EVENT_TABLE(wxWebKitCtrl, wxControl)
  45 #if defined(__WXMAC__) && wxOSX_USE_CARBON
  46     EVT_SIZE(wxWebKitCtrl::OnSize)
  47 #endif
  48 END_EVENT_TABLE()
  49
  50 #if defined(__WXOSX__) && wxOSX_USE_CARBON
  51
  52 // ----------------------------------------------------------------------------
  53 // Carbon Events handlers
  54 // ----------------------------------------------------------------------------
  55
  56 // prototype for function in src/osx/carbon/nonownedwnd.cpp
  57 void SetupMouseEvent( wxMouseEvent &wxevent , wxMacCarbonEvent &cEvent );
  58
  59 static const EventTypeSpec eventList[] =
  60 {
  61     //{ kEventClassControl, kEventControlTrack } ,
  62     { kEventClassMouse, kEventMouseUp },
  63     { kEventClassMouse, kEventMouseDown },
  64     { kEventClassMouse, kEventMouseMoved },
  65     { kEventClassMouse, kEventMouseDragged },
  66
  67     { kEventClassKeyboard, kEventRawKeyDown } ,
  68     { kEventClassKeyboard, kEventRawKeyRepeat } ,
  69     { kEventClassKeyboard, kEventRawKeyUp } ,
  70     { kEventClassKeyboard, kEventRawKeyModifiersChanged } ,
  71
  72     { kEventClassTextInput, kEventTextInputUnicodeForKeyEvent } ,
  73     { kEventClassTextInput, kEventTextInputUpdateActiveInputArea } ,
  74
  75 #if DEBUG_WEBKIT_SIZING == 1
  76     { kEventClassControl, kEventControlBoundsChanged } ,
  77 #endif
  78 };
  79
  80 // mix this in from window.cpp
  81 pascal OSStatus wxMacUnicodeTextEventHandler( EventHandlerCallRef handler , EventRef event , void *data ) ;
  82
  83 // NOTE: This is mostly taken from KeyboardEventHandler in toplevel.cpp, but
  84 // that expects the data pointer is a top-level window, so I needed to change
  85 // that in this case. However, once 2.8 is out, we should factor out the common logic
  86 // among the two functions and merge them.
  87 static pascal OSStatus wxWebKitKeyEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
  88 {
  89     OSStatus result = eventNotHandledErr ;
  90     wxMacCarbonEvent cEvent( event ) ;
  91
  92     wxWebKitCtrl* thisWindow = (wxWebKitCtrl*) data ;
  93     wxWindow* focus = thisWindow ;
  94
  95     unsigned char charCode ;
  96     wxChar uniChar[2] ;
  97     uniChar[0] = 0;
  98     uniChar[1] = 0;
  99
 100     UInt32 keyCode ;
 101     UInt32 modifiers ;
 102     Point point ;
 103     UInt32 when = EventTimeToTicks( GetEventTime( event ) ) ;
 104
 105 #if wxUSE_UNICODE
 106     ByteCount dataSize = 0 ;
 107     if ( GetEventParameter( event, kEventParamKeyUnicodes, typeUnicodeText, NULL, 0 , &dataSize, NULL ) == noErr )
 108     {
 109         UniChar buf[2] ;
 110         int numChars = dataSize / sizeof( UniChar) + 1;
 111
 112         UniChar* charBuf = buf ;
 113
 114         if ( numChars * 2 > 4 )
 115             charBuf = new UniChar[ numChars ] ;
 116         GetEventParameter( event, kEventParamKeyUnicodes, typeUnicodeText, NULL, dataSize , NULL , charBuf ) ;
 117         charBuf[ numChars - 1 ] = 0;
 118
 119 #if SIZEOF_WCHAR_T == 2
 120         uniChar = charBuf[0] ;
 121 #else
 122         wxMBConvUTF16 converter ;
 123         converter.MB2WC( uniChar , (const char*)charBuf , 2 ) ;
 124 #endif
 125
 126         if ( numChars * 2 > 4 )
 127             delete[] charBuf ;
 128     }
 129 #endif
 130
 131     GetEventParameter( event, kEventParamKeyMacCharCodes, typeChar, NULL, sizeof(char), NULL, &charCode );
 132     GetEventParameter( event, kEventParamKeyCode, typeUInt32, NULL, sizeof(UInt32), NULL, &keyCode );
 133     GetEventParameter( event, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modifiers );
 134     GetEventParameter( event, kEventParamMouseLocation, typeQDPoint, NULL, sizeof(Point), NULL, &point );
 135
 136     UInt32 message = (keyCode << 8) + charCode;
 137     switch ( GetEventKind( event ) )
 138     {
 139         case kEventRawKeyRepeat :
 140         case kEventRawKeyDown :
 141             {
 142                 WXEVENTREF formerEvent = wxTheApp->MacGetCurrentEvent() ;
 143                 WXEVENTHANDLERCALLREF formerHandler = wxTheApp->MacGetCurrentEventHandlerCallRef() ;
 144                 wxTheApp->MacSetCurrentEvent( event , handler ) ;
 145                 if ( /* focus && */ wxTheApp->MacSendKeyDownEvent(
 146                     focus , message , modifiers , when , point.h , point.v , uniChar[0] ) )
 147                 {
 148                     result = noErr ;
 149                 }
 150                 wxTheApp->MacSetCurrentEvent( formerEvent , formerHandler ) ;
 151             }
 152             break ;
 153
 154         case kEventRawKeyUp :
 155             if ( /* focus && */ wxTheApp->MacSendKeyUpEvent(
 156                 focus , message , modifiers , when , point.h , point.v , uniChar[0] ) )
 157             {
 158                 result = noErr ;
 159             }
 160             break ;
 161
 162         case kEventRawKeyModifiersChanged :
 163             {
 164                 wxKeyEvent event(wxEVT_KEY_DOWN);
 165
 166                 event.m_shiftDown = modifiers & shiftKey;
 167                 event.m_controlDown = modifiers & controlKey;
 168                 event.m_altDown = modifiers & optionKey;
 169                 event.m_metaDown = modifiers & cmdKey;
 170                 event.m_x = point.h;
 171                 event.m_y = point.v;
 172
 173 #if wxUSE_UNICODE
 174                 event.m_uniChar = uniChar[0] ;
 175 #endif
 176
 177                 event.SetTimestamp(when);
 178                 event.SetEventObject(focus);
 179
 180                 if ( /* focus && */ (modifiers ^ wxApp::s_lastModifiers ) & controlKey )
 181                 {
 182                     event.m_keyCode = WXK_CONTROL ;
 183                     event.SetEventType( ( modifiers & controlKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
 184                     focus->GetEventHandler()->ProcessEvent( event ) ;
 185                 }
 186                 if ( /* focus && */ (modifiers ^ wxApp::s_lastModifiers ) & shiftKey )
 187                 {
 188                     event.m_keyCode = WXK_SHIFT ;
 189                     event.SetEventType( ( modifiers & shiftKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
 190                     focus->GetEventHandler()->ProcessEvent( event ) ;
 191                 }
 192                 if ( /* focus && */ (modifiers ^ wxApp::s_lastModifiers ) & optionKey )
 193                 {
 194                     event.m_keyCode = WXK_ALT ;
 195                     event.SetEventType( ( modifiers & optionKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
 196                     focus->GetEventHandler()->ProcessEvent( event ) ;
 197                 }
 198                 if ( /* focus && */ (modifiers ^ wxApp::s_lastModifiers ) & cmdKey )
 199                 {
 200                     event.m_keyCode = WXK_COMMAND ;
 201                     event.SetEventType( ( modifiers & cmdKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
 202                     focus->GetEventHandler()->ProcessEvent( event ) ;
 203                 }
 204
 205                 wxApp::s_lastModifiers = modifiers ;
 206             }
 207             break ;
 208
 209         default:
 210             break;
 211     }
 212
 213     return result ;
 214 }
 215
 216 static pascal OSStatus wxWebKitCtrlEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
 217 {
 218     OSStatus result = eventNotHandledErr ;
 219
 220     wxMacCarbonEvent cEvent( event ) ;
 221
 222     ControlRef controlRef ;
 223     wxWebKitCtrl* thisWindow = (wxWebKitCtrl*) data ;
 224     wxNonOwnedWindow* tlw = NULL;
 225     if (thisWindow)
 226         tlw = thisWindow->MacGetTopLevelWindow();
 227
 228     cEvent.GetParameter( kEventParamDirectObject , &controlRef ) ;
 229
 230     wxWindow* currentMouseWindow = thisWindow ;
 231
 232     if ( wxApp::s_captureWindow )
 233         currentMouseWindow = wxApp::s_captureWindow;
 234
 235     switch ( GetEventClass( event ) )
 236     {
 237         case kEventClassKeyboard:
 238         {
 239             result = wxWebKitKeyEventHandler(handler, event, data);
 240             break;
 241         }
 242
 243         case kEventClassTextInput:
 244         {
 245             result = wxMacUnicodeTextEventHandler(handler, event, data);
 246             break;
 247         }
 248
 249         case kEventClassMouse:
 250         {
 251             switch ( GetEventKind( event ) )
 252             {
 253                 case kEventMouseDragged :
 254                 case kEventMouseMoved :
 255                 case kEventMouseDown :
 256                 case kEventMouseUp :
 257                 {
 258                     wxMouseEvent wxevent(wxEVT_LEFT_DOWN);
 259                     SetupMouseEvent( wxevent , cEvent ) ;
 260
 261                     currentMouseWindow->ScreenToClient( &wxevent.m_x , &wxevent.m_y ) ;
 262                     wxevent.SetEventObject( currentMouseWindow ) ;
 263                     wxevent.SetId( currentMouseWindow->GetId() ) ;
 264
 265                     if ( currentMouseWindow->GetEventHandler()->ProcessEvent(wxevent) )
 266                     {
 267                         result = noErr;
 268                     }
 269
 270                     break; // this should enable WebKit to fire mouse dragged and mouse up events...
 271                 }
 272                 default :
 273                     break ;
 274             }
 275         }
 276         default:
 277             break;
 278     }
 279
 280     result = CallNextEventHandler(handler, event);
 281     return result ;
 282 }
 283
 284 DEFINE_ONE_SHOT_HANDLER_GETTER( wxWebKitCtrlEventHandler )
 285
 286 #endif
 287
 288 // ----------------------------------------------------------------------------
 289 // wxWebKit Events
 290 // ----------------------------------------------------------------------------
 291
 292 IMPLEMENT_DYNAMIC_CLASS( wxWebKitStateChangedEvent, wxCommandEvent )
 293
 294 wxDEFINE_EVENT( wxEVT_WEBKIT_STATE_CHANGED, wxWebKitStateChangedEvent );
 295
 296 wxWebKitStateChangedEvent::wxWebKitStateChangedEvent( wxWindow* win )
 297 {
 298     SetEventType( wxEVT_WEBKIT_STATE_CHANGED);
 299     if ( win )
 300     {
 301         SetEventObject( win );
 302         SetId(win->GetId());
 303     }
 304 }
 305
 306 IMPLEMENT_DYNAMIC_CLASS( wxWebKitBeforeLoadEvent, wxCommandEvent )
 307
 308 wxDEFINE_EVENT( wxEVT_WEBKIT_BEFORE_LOAD, wxWebKitBeforeLoadEvent );
 309
 310 wxWebKitBeforeLoadEvent::wxWebKitBeforeLoadEvent( wxWindow* win )
 311 {
 312     m_cancelled = false;
 313     SetEventType( wxEVT_WEBKIT_BEFORE_LOAD);
 314     if ( win )
 315     {
 316         SetEventObject( win );
 317         SetId(win->GetId());
 318     }
 319 }
 320
 321
 322 IMPLEMENT_DYNAMIC_CLASS( wxWebKitNewWindowEvent, wxCommandEvent )
 323
 324 wxDEFINE_EVENT( wxEVT_WEBKIT_NEW_WINDOW, wxWebKitNewWindowEvent );
 325
 326 wxWebKitNewWindowEvent::wxWebKitNewWindowEvent( wxWindow* win )
 327 {
 328     SetEventType( wxEVT_WEBKIT_NEW_WINDOW);
 329     if ( win )
 330     {
 331         SetEventObject( win );
 332         SetId(win->GetId());
 333     }
 334 }
 335
 336
 337
 338 //---------------------------------------------------------
 339 // helper functions for NSString<->wxString conversion
 340 //---------------------------------------------------------
 341
 342 inline wxString wxStringWithNSString(NSString *nsstring)
 343 {
 344 #if wxUSE_UNICODE
 345     return wxString([nsstring UTF8String], wxConvUTF8);
 346 #else
 347     return wxString([nsstring lossyCString]);
 348 #endif // wxUSE_UNICODE
 349 }
 350
 351 inline NSString* wxNSStringWithWxString(const wxString &wxstring)
 352 {
 353 #if wxUSE_UNICODE
 354     return [NSString stringWithUTF8String: wxstring.mb_str(wxConvUTF8)];
 355 #else
 356     return [NSString stringWithCString: wxstring.c_str() length:wxstring.Len()];
 357 #endif // wxUSE_UNICODE
 358 }
 359
 360 inline int wxNavTypeFromWebNavType(int type){
 361     if (type == WebNavigationTypeLinkClicked)
 362         return wxWEBKIT_NAV_LINK_CLICKED;
 363
 364     if (type == WebNavigationTypeFormSubmitted)
 365         return wxWEBKIT_NAV_FORM_SUBMITTED;
 366
 367     if (type == WebNavigationTypeBackForward)
 368         return wxWEBKIT_NAV_BACK_NEXT;
 369
 370     if (type == WebNavigationTypeReload)
 371         return wxWEBKIT_NAV_RELOAD;
 372
 373     if (type == WebNavigationTypeFormResubmitted)
 374         return wxWEBKIT_NAV_FORM_RESUBMITTED;
 375
 376     return wxWEBKIT_NAV_OTHER;
 377 }
 378
 379 @interface MyFrameLoadMonitor : NSObject
 380 {
 381     wxWebKitCtrl* webKitWindow;
 382 }
 383
 384 - initWithWxWindow: (wxWebKitCtrl*)inWindow;
 385
 386 @end
 387
 388 @interface MyPolicyDelegate : NSObject
 389 {
 390     wxWebKitCtrl* webKitWindow;
 391 }
 392
 393 - initWithWxWindow: (wxWebKitCtrl*)inWindow;
 394
 395 @end
 396
 397 // ----------------------------------------------------------------------------
 398 // creation/destruction
 399 // ----------------------------------------------------------------------------
 400
 401 bool wxWebKitCtrl::Create(wxWindow *parent,
 402                                  wxWindowID winID,
 403                                  const wxString& strURL,
 404                                  const wxPoint& pos,
 405                                  const wxSize& size, long style,
 406                                  const wxValidator& validator,
 407                                  const wxString& name)
 408 {
 409
 410     m_currentURL = strURL;
 411     //m_pageTitle = _("Untitled Page");
 412
 413  //still needed for wxCocoa??
 414 /*
 415     int width, height;
 416     wxSize sizeInstance;
 417     if (size.x == wxDefaultCoord || size.y == wxDefaultCoord)
 418     {
 419         m_parent->GetClientSize(&width, &height);
 420         sizeInstance.x = width;
 421         sizeInstance.y = height;
 422     }
 423     else
 424     {
 425         sizeInstance.x = size.x;
 426         sizeInstance.y = size.y;
 427     }
 428 */
 429     // now create and attach WebKit view...
 430 #ifdef __WXCOCOA__
 431     wxControl::Create(parent, m_windowID, pos, sizeInstance, style , validator , name);
 432     SetSize(pos.x, pos.y, sizeInstance.x, sizeInstance.y);
 433
 434     wxTopLevelWindowCocoa *topWin = wxDynamicCast(this, wxTopLevelWindowCocoa);
 435     NSWindow* nsWin = topWin->GetNSWindow();
 436     NSRect rect;
 437     rect.origin.x = pos.x;
 438     rect.origin.y = pos.y;
 439     rect.size.width = sizeInstance.x;
 440     rect.size.height = sizeInstance.y;
 441     m_webView = (WebView*)[[WebView alloc] initWithFrame:rect frameName:@"webkitFrame" groupName:@"webkitGroup"];
 442     SetNSView(m_webView);
 443     [m_cocoaNSView release];
 444
 445     if(m_parent) m_parent->CocoaAddChild(this);
 446     SetInitialFrameRect(pos,sizeInstance);
 447 #else
 448     m_macIsUserPane = false;
 449     wxControl::Create(parent, winID, pos, size, style , validator , name);
 450 #if wxOSX_USE_CARBON
 451     m_peer = new wxMacControl(this);
 452     WebInitForCarbon();
 453     HIWebViewCreate( m_peer->GetControlRefAddr() );
 454
 455     m_webView = (WebView*) HIWebViewGetWebView( m_peer->GetControlRef() );
 456
 457 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_3
 458     if ( UMAGetSystemVersion() >= 0x1030 )
 459         HIViewChangeFeatures( m_peer->GetControlRef() , kHIViewIsOpaque , 0 ) ;
 460 #endif
 461     InstallControlEventHandler( m_peer->GetControlRef() , GetwxWebKitCtrlEventHandlerUPP(),
 462         GetEventTypeCount(eventList), eventList, this,
 463         (EventHandlerRef *)&m_webKitCtrlEventHandler);
 464 #else
 465     NSRect r = wxOSXGetFrameForControl( this, pos , size ) ;
 466     m_webView = [[WebView alloc] initWithFrame:r frameName:@"webkitFrame" groupName:@"webkitGroup"];
 467
 468     m_peer = new wxWidgetCocoaImpl( this, m_webView );
 469 #endif
 470     MacPostControlCreate(pos, size);
 471 #if wxOSX_USE_CARBON
 472     HIViewSetVisible( m_peer->GetControlRef(), true );
 473 #endif
 474     [m_webView setHidden:false];
 475
 476 #endif
 477
 478     // Register event listener interfaces
 479     MyFrameLoadMonitor* myFrameLoadMonitor = [[MyFrameLoadMonitor alloc] initWithWxWindow: this];
 480     [m_webView setFrameLoadDelegate:myFrameLoadMonitor];
 481
 482     // this is used to veto page loads, etc.
 483     MyPolicyDelegate* myPolicyDelegate = [[MyPolicyDelegate alloc] initWithWxWindow: this];
 484     [m_webView setPolicyDelegate:myPolicyDelegate];
 485
 486     LoadURL(m_currentURL);
 487     return true;
 488 }
 489
 490 wxWebKitCtrl::~wxWebKitCtrl()
 491 {
 492     MyFrameLoadMonitor* myFrameLoadMonitor = [m_webView frameLoadDelegate];
 493     MyPolicyDelegate* myPolicyDelegate = [m_webView policyDelegate];
 494     [m_webView setFrameLoadDelegate: nil];
 495     [m_webView setPolicyDelegate: nil];
 496
 497     if (myFrameLoadMonitor)
 498         [myFrameLoadMonitor release];
 499
 500     if (myPolicyDelegate)
 501         [myPolicyDelegate release];
 502 }
 503
 504 // ----------------------------------------------------------------------------
 505 // public methods
 506 // ----------------------------------------------------------------------------
 507
 508 void wxWebKitCtrl::LoadURL(const wxString &url)
 509 {
 510     if( !m_webView )
 511         return;
 512
 513     [[m_webView mainFrame] loadRequest:[NSURLRequest requestWithURL:[NSURL URLWithString:wxNSStringWithWxString(url)]]];
 514
 515     m_currentURL = url;
 516 }
 517
 518 bool wxWebKitCtrl::CanGoBack(){
 519     if ( !m_webView )
 520         return false;
 521
 522     return [m_webView canGoBack];
 523 }
 524
 525 bool wxWebKitCtrl::CanGoForward(){
 526     if ( !m_webView )
 527         return false;
 528
 529     return [m_webView canGoForward];
 530 }
 531
 532 bool wxWebKitCtrl::GoBack(){
 533     if ( !m_webView )
 534         return false;
 535
 536     bool result = [(WebView*)m_webView goBack];
 537     return result;
 538 }
 539
 540 bool wxWebKitCtrl::GoForward(){
 541     if ( !m_webView )
 542         return false;
 543
 544     bool result = [(WebView*)m_webView goForward];
 545     return result;
 546 }
 547
 548 void wxWebKitCtrl::Reload(){
 549     if ( !m_webView )
 550         return;
 551
 552     [[m_webView mainFrame] reload];
 553 }
 554
 555 void wxWebKitCtrl::Stop(){
 556     if ( !m_webView )
 557         return;
 558
 559     [[m_webView mainFrame] stopLoading];
 560 }
 561
 562 bool wxWebKitCtrl::CanGetPageSource(){
 563     if ( !m_webView )
 564         return false;
 565
 566     WebDataSource* dataSource = [[m_webView mainFrame] dataSource];
 567     return ( [[dataSource representation] canProvideDocumentSource] );
 568 }
 569
 570 wxString wxWebKitCtrl::GetPageSource(){
 571
 572     if (CanGetPageSource()){
 573         WebDataSource* dataSource = [[m_webView mainFrame] dataSource];
 574         return wxStringWithNSString( [[dataSource representation] documentSource] );
 575     }
 576
 577     return wxEmptyString;
 578 }
 579
 580 wxString wxWebKitCtrl::GetSelection(){
 581     if ( !m_webView )
 582         return wxEmptyString;
 583
 584     NSString* selectedText = [[m_webView selectedDOMRange] toString];
 585     return wxStringWithNSString( selectedText );
 586 }
 587
 588 bool wxWebKitCtrl::CanIncreaseTextSize(){
 589     if ( !m_webView )
 590         return false;
 591
 592     if ([m_webView canMakeTextLarger])
 593         return true;
 594     else
 595         return false;
 596 }
 597
 598 void wxWebKitCtrl::IncreaseTextSize(){
 599     if ( !m_webView )
 600         return;
 601
 602     if (CanIncreaseTextSize())
 603         [m_webView makeTextLarger:(WebView*)m_webView];
 604 }
 605
 606 bool wxWebKitCtrl::CanDecreaseTextSize(){
 607     if ( !m_webView )
 608         return false;
 609
 610     if ([m_webView canMakeTextSmaller])
 611         return true;
 612     else
 613         return false;
 614 }
 615
 616 void wxWebKitCtrl::DecreaseTextSize(){
 617     if ( !m_webView )
 618         return;
 619
 620     if (CanDecreaseTextSize())
 621         [m_webView makeTextSmaller:(WebView*)m_webView];
 622 }
 623
 624 void wxWebKitCtrl::SetPageSource(const wxString& source, const wxString& baseUrl){
 625     if ( !m_webView )
 626         return;
 627
 628     [[m_webView mainFrame] loadHTMLString:(NSString*)wxNSStringWithWxString( source ) baseURL:[NSURL URLWithString:wxNSStringWithWxString( baseUrl )]];
 629
 630 }
 631
 632 void wxWebKitCtrl::Print(bool showPrompt){
 633     if ( !m_webView )
 634         return;
 635
 636     id view = [[[m_webView mainFrame] frameView] documentView];
 637     NSPrintOperation *op = [NSPrintOperation printOperationWithView:view printInfo: [NSPrintInfo sharedPrintInfo]];
 638     if (showPrompt){
 639         [op setShowsPrintPanel: showPrompt];
 640         // in my tests, the progress bar always freezes and it stops the whole print operation.
 641         // do not turn this to true unless there is a workaround for the bug.
 642         [op setShowsProgressPanel: false];
 643     }
 644     // Print it.
 645     [op runOperation];
 646 }
 647
 648 void wxWebKitCtrl::MakeEditable(bool enable){
 649     if ( !m_webView )
 650         return;
 651
 652     [m_webView setEditable:enable ];
 653 }
 654
 655 bool wxWebKitCtrl::IsEditable(){
 656     if ( !m_webView )
 657         return false;
 658
 659     return [m_webView isEditable];
 660 }
 661
 662 int wxWebKitCtrl::GetScrollPos(){
 663     id result = [[m_webView windowScriptObject] evaluateWebScript:@"document.body.scrollTop"];
 664     return [result intValue];
 665 }
 666
 667 void wxWebKitCtrl::SetScrollPos(int pos){
 668     if ( !m_webView )
 669         return;
 670
 671     wxString javascript;
 672     javascript.Printf(wxT("document.body.scrollTop = %d;"), pos);
 673     [[m_webView windowScriptObject] evaluateWebScript:(NSString*)wxNSStringWithWxString( javascript )];
 674 }
 675
 676 wxString wxWebKitCtrl::RunScript(const wxString& javascript){
 677     if ( !m_webView )
 678         return wxEmptyString;
 679
 680     id result = [[m_webView windowScriptObject] evaluateWebScript:(NSString*)wxNSStringWithWxString( javascript )];
 681
 682     NSString* resultAsString;
 683     NSString* className = NSStringFromClass([result class]);
 684     if ([className isEqualToString:@"NSCFNumber"])
 685         resultAsString = [NSString stringWithFormat:@"%@", result];
 686     else if ([className isEqualToString:@"NSCFString"])
 687         resultAsString = result;
 688     else if ([className isEqualToString:@"NSCFBoolean"]){
 689         if ([result boolValue])
 690             resultAsString = @"true";
 691         else
 692             resultAsString = @"false";
 693     }
 694     else if ([className isEqualToString:@"WebScriptObject"])
 695         resultAsString = [result stringRepresentation];
 696     else
 697         return wxString(); // This can happen, see e.g. #12361.
 698
 699     return wxStringWithNSString( resultAsString );
 700 }
 701
 702 void wxWebKitCtrl::OnSize(wxSizeEvent &event){
 703 #if defined(__WXMAC_) && wxOSX_USE_CARBON
 704     // This is a nasty hack because WebKit seems to lose its position when it is embedded
 705     // in a control that is not itself the content view for a TLW.
 706     // I put it in OnSize because these calcs are not perfect, and in fact are basically
 707     // guesses based on reverse engineering, so it's best to give people the option of
 708     // overriding OnSize with their own calcs if need be.
 709     // I also left some test debugging print statements as a convenience if a(nother)
 710     // problem crops up.
 711
 712     wxWindow* tlw = MacGetTopLevelWindow();
 713
 714     NSRect frame = [(WebView*)m_webView frame];
 715     NSRect bounds = [(WebView*)m_webView bounds];
 716
 717 #if DEBUG_WEBKIT_SIZING
 718     fprintf(stderr,"Carbon window x=%d, y=%d, width=%d, height=%d\n", GetPosition().x, GetPosition().y, GetSize().x, GetSize().y);
 719     fprintf(stderr, "Cocoa window frame x=%G, y=%G, width=%G, height=%G\n", frame.origin.x, frame.origin.y, frame.size.width, frame.size.height);
 720     fprintf(stderr, "Cocoa window bounds x=%G, y=%G, width=%G, height=%G\n", bounds.origin.x, bounds.origin.y, bounds.size.width, bounds.size.height);
 721 #endif
 722
 723     // This must be the case that Apple tested with, because well, in this one case
 724     // we don't need to do anything! It just works. ;)
 725     if (GetParent() == tlw){
 726         return;
 727     }
 728
 729     // since we no longer use parent coordinates, we always want 0,0.
 730     int x = 0;
 731     int y = 0;
 732
 733     HIRect rect;
 734     rect.origin.x = x;
 735     rect.origin.y = y;
 736
 737 #if DEBUG_WEBKIT_SIZING
 738     printf("Before conversion, origin is: x = %d, y = %d\n", x, y);
 739 #endif
 740
 741     // NB: In most cases, when calling HIViewConvertRect, what people want is to use GetRootControl(),
 742     // and this tripped me up at first. But in fact, what we want is the root view, because we need to
 743     // make the y origin relative to the very top of the window, not its contents, since we later flip
 744     // the y coordinate for Cocoa.
 745     HIViewConvertRect (&rect, m_peer->GetControlRef(),
 746                                 HIViewGetRoot( (WindowRef) MacGetTopLevelWindowRef() ) );
 747
 748     x = (int)rect.origin.x;
 749     y = (int)rect.origin.y;
 750
 751 #if DEBUG_WEBKIT_SIZING
 752     printf("Moving Cocoa frame origin to: x = %d, y = %d\n", x, y);
 753 #endif
 754
 755     if (tlw){
 756         //flip the y coordinate to convert to Cocoa coordinates
 757         y = tlw->GetSize().y - ((GetSize().y) + y);
 758     }
 759
 760 #if DEBUG_WEBKIT_SIZING
 761     printf("y = %d after flipping value\n", y);
 762 #endif
 763
 764     frame.origin.x = x;
 765     frame.origin.y = y;
 766     [(WebView*)m_webView setFrame:frame];
 767
 768     if (IsShown())
 769         [(WebView*)m_webView display];
 770     event.Skip();
 771 #endif
 772 }
 773
 774 void wxWebKitCtrl::MacVisibilityChanged(){
 775 #if defined(__WXMAC__) && wxOSX_USE_CARBON
 776     bool isHidden = !IsControlVisible( m_peer->GetControlRef());
 777     if (!isHidden)
 778         [(WebView*)m_webView display];
 779
 780     [m_webView setHidden:isHidden];
 781 #endif
 782 }
 783
 784 //------------------------------------------------------------
 785 // Listener interfaces
 786 //------------------------------------------------------------
 787
 788 // NB: I'm still tracking this down, but it appears the Cocoa window
 789 // still has these events fired on it while the Carbon control is being
 790 // destroyed. Therefore, we must be careful to check both the existence
 791 // of the Carbon control and the event handler before firing events.
 792
 793 @implementation MyFrameLoadMonitor
 794
 795 - initWithWxWindow: (wxWebKitCtrl*)inWindow
 796 {
 797     [super init];
 798     webKitWindow = inWindow;    // non retained
 799     return self;
 800 }
 801
 802 - (void)webView:(WebView *)sender didStartProvisionalLoadForFrame:(WebFrame *)frame
 803 {
 804     if (webKitWindow && frame == [sender mainFrame]){
 805         NSString *url = [[[[frame provisionalDataSource] request] URL] absoluteString];
 806         wxWebKitStateChangedEvent thisEvent(webKitWindow);
 807         thisEvent.SetState(wxWEBKIT_STATE_NEGOTIATING);
 808         thisEvent.SetURL( wxStringWithNSString( url ) );
 809         if (webKitWindow->GetEventHandler())
 810             webKitWindow->GetEventHandler()->ProcessEvent( thisEvent );
 811     }
 812 }
 813
 814 - (void)webView:(WebView *)sender didCommitLoadForFrame:(WebFrame *)frame
 815 {
 816     if (webKitWindow && frame == [sender mainFrame]){
 817         NSString *url = [[[[frame dataSource] request] URL] absoluteString];
 818         wxWebKitStateChangedEvent thisEvent(webKitWindow);
 819         thisEvent.SetState(wxWEBKIT_STATE_TRANSFERRING);
 820         thisEvent.SetURL( wxStringWithNSString( url ) );
 821         if (webKitWindow->GetEventHandler())
 822             webKitWindow->GetEventHandler()->ProcessEvent( thisEvent );
 823     }
 824 }
 825
 826 - (void)webView:(WebView *)sender didFinishLoadForFrame:(WebFrame *)frame
 827 {
 828     if (webKitWindow && frame == [sender mainFrame]){
 829         NSString *url = [[[[frame dataSource] request] URL] absoluteString];
 830         wxWebKitStateChangedEvent thisEvent(webKitWindow);
 831         thisEvent.SetState(wxWEBKIT_STATE_STOP);
 832         thisEvent.SetURL( wxStringWithNSString( url ) );
 833         if (webKitWindow->GetEventHandler())
 834             webKitWindow->GetEventHandler()->ProcessEvent( thisEvent );
 835     }
 836 }
 837
 838 - (void)webView:(WebView *)sender didFailLoadWithError:(NSError*) error forFrame:(WebFrame *)frame
 839 {
 840     wxUnusedVar(error);
 841
 842     if (webKitWindow && frame == [sender mainFrame]){
 843         NSString *url = [[[[frame dataSource] request] URL] absoluteString];
 844         wxWebKitStateChangedEvent thisEvent(webKitWindow);
 845         thisEvent.SetState(wxWEBKIT_STATE_FAILED);
 846         thisEvent.SetURL( wxStringWithNSString( url ) );
 847         if (webKitWindow->GetEventHandler())
 848             webKitWindow->GetEventHandler()->ProcessEvent( thisEvent );
 849     }
 850 }
 851
 852 - (void)webView:(WebView *)sender didFailProvisionalLoadWithError:(NSError*) error forFrame:(WebFrame *)frame
 853 {
 854     wxUnusedVar(error);
 855
 856     if (webKitWindow && frame == [sender mainFrame]){
 857         NSString *url = [[[[frame provisionalDataSource] request] URL] absoluteString];
 858         wxWebKitStateChangedEvent thisEvent(webKitWindow);
 859         thisEvent.SetState(wxWEBKIT_STATE_FAILED);
 860         thisEvent.SetURL( wxStringWithNSString( url ) );
 861         if (webKitWindow->GetEventHandler())
 862             webKitWindow->GetEventHandler()->ProcessEvent( thisEvent );
 863     }
 864 }
 865
 866 - (void)webView:(WebView *)sender didReceiveTitle:(NSString *)title forFrame:(WebFrame *)frame
 867 {
 868     if (webKitWindow && frame == [sender mainFrame]){
 869         webKitWindow->SetPageTitle(wxStringWithNSString( title ));
 870     }
 871 }
 872 @end
 873
 874 @implementation MyPolicyDelegate
 875
 876 - initWithWxWindow: (wxWebKitCtrl*)inWindow
 877 {
 878     [super init];
 879     webKitWindow = inWindow;    // non retained
 880     return self;
 881 }
 882
 883 - (void)webView:(WebView *)sender decidePolicyForNavigationAction:(NSDictionary *)actionInformation request:(NSURLRequest *)request frame:(WebFrame *)frame decisionListener:(id<WebPolicyDecisionListener>)listener
 884 {
 885     wxUnusedVar(sender);
 886     wxUnusedVar(frame);
 887
 888     wxWebKitBeforeLoadEvent thisEvent(webKitWindow);
 889
 890     // Get the navigation type.
 891     NSNumber *n = [actionInformation objectForKey:WebActionNavigationTypeKey];
 892     int actionType = [n intValue];
 893     thisEvent.SetNavigationType( wxNavTypeFromWebNavType(actionType) );
 894
 895     NSString *url = [[request URL] absoluteString];
 896     thisEvent.SetURL( wxStringWithNSString( url ) );
 897
 898     if (webKitWindow && webKitWindow->GetEventHandler())
 899         webKitWindow->GetEventHandler()->ProcessEvent(thisEvent);
 900
 901     if (thisEvent.IsCancelled())
 902         [listener ignore];
 903     else
 904         [listener use];
 905 }
 906
 907 - (void)webView:(WebView *)sender decidePolicyForNewWindowAction:(NSDictionary *)actionInformation request:(NSURLRequest *)request newFrameName:(NSString *)frameName decisionListener:(id < WebPolicyDecisionListener >)listener
 908 {
 909     wxUnusedVar(sender);
 910     wxUnusedVar(actionInformation);
 911     wxWebKitNewWindowEvent thisEvent(webKitWindow);
 912
 913     NSString *url = [[request URL] absoluteString];
 914     thisEvent.SetURL( wxStringWithNSString( url ) );
 915     thisEvent.SetTargetName( wxStringWithNSString( frameName ) );
 916
 917     if (webKitWindow && webKitWindow->GetEventHandler())
 918         webKitWindow->GetEventHandler()->ProcessEvent(thisEvent);
 919
 920     [listener use];
 921 }
 922 @end
 923
 924 #endif //wxUSE_WEBKIT