src/html/htmlctrl/webkit/webkit.mm

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