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