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