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