| /* |
| * Copyright (C) 2005 Apple Computer, Inc. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of |
| * its contributors may be used to endorse or promote products derived |
| * from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY |
| * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
| * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY |
| * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
| * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
| * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #ifndef __LP64__ |
| |
| #import "HIWebView.h" |
| |
| #import "CarbonWindowAdapter.h" |
| #import "HIViewAdapter.h" |
| #import "QuickDrawCompatibility.h" |
| #import "WebHTMLViewInternal.h" |
| #import "WebKit.h" |
| #import <WebKitSystemInterface.h> |
| #import <objc/objc-runtime.h> |
| |
| @interface NSWindow (AppKitSecretsHIWebViewKnows) |
| - (void)_removeWindowRef; |
| @end |
| |
| @interface NSView (AppKitSecretsHIWebViewKnows) |
| - (void)_clearDirtyRectsForTree; |
| @end |
| |
| extern "C" void HIWebViewRegisterClass(); |
| |
| @interface MenuItemProxy : NSObject <NSValidatedUserInterfaceItem> |
| { |
| int _tag; |
| SEL _action; |
| } |
| |
| - (id)initWithAction:(SEL)action; |
| - (SEL)action; |
| - (int)tag; |
| |
| @end |
| |
| @implementation MenuItemProxy |
| |
| - (id)initWithAction:(SEL)action |
| { |
| [super init]; |
| if (self == nil) return nil; |
| |
| _action = action; |
| |
| return self; |
| } |
| |
| - (SEL)action |
| { |
| return _action; |
| } |
| |
| - (int)tag |
| { |
| return 0; |
| } |
| |
| @end |
| |
| struct HIWebView |
| { |
| HIViewRef fViewRef; |
| |
| WebView* fWebView; |
| NSView* fFirstResponder; |
| CarbonWindowAdapter * fKitWindow; |
| bool fIsComposited; |
| CFRunLoopObserverRef fUpdateObserver; |
| }; |
| typedef struct HIWebView HIWebView; |
| |
| static const OSType NSAppKitPropertyCreator = 'akit'; |
| /* |
| These constants are not used. Commented out to make the compiler happy. |
| static const OSType NSViewCarbonControlViewPropertyTag = 'view'; |
| static const OSType NSViewCarbonControlAutodisplayPropertyTag = 'autd'; |
| static const OSType NSViewCarbonControlFirstResponderViewPropertyTag = 'frvw'; |
| */ |
| static const OSType NSCarbonWindowPropertyTag = 'win '; |
| |
| #ifdef BUILDING_ON_TIGER |
| const int typeByteCount = typeSInt32; |
| #endif |
| |
| static SEL _NSSelectorForHICommand( const HICommand* hiCommand ); |
| |
| static const EventTypeSpec kEvents[] = { |
| { kEventClassHIObject, kEventHIObjectConstruct }, |
| { kEventClassHIObject, kEventHIObjectDestruct }, |
| |
| { kEventClassMouse, kEventMouseUp }, |
| { kEventClassMouse, kEventMouseMoved }, |
| { kEventClassMouse, kEventMouseDragged }, |
| { kEventClassMouse, kEventMouseWheelMoved }, |
| |
| { kEventClassKeyboard, kEventRawKeyDown }, |
| { kEventClassKeyboard, kEventRawKeyRepeat }, |
| |
| { kEventClassCommand, kEventCommandProcess }, |
| { kEventClassCommand, kEventCommandUpdateStatus }, |
| |
| { kEventClassControl, kEventControlInitialize }, |
| { kEventClassControl, kEventControlDraw }, |
| { kEventClassControl, kEventControlHitTest }, |
| { kEventClassControl, kEventControlGetPartRegion }, |
| { kEventClassControl, kEventControlGetData }, |
| { kEventClassControl, kEventControlBoundsChanged }, |
| { kEventClassControl, kEventControlActivate }, |
| { kEventClassControl, kEventControlDeactivate }, |
| { kEventClassControl, kEventControlOwningWindowChanged }, |
| { kEventClassControl, kEventControlClick }, |
| { kEventClassControl, kEventControlContextualMenuClick }, |
| { kEventClassControl, kEventControlSetFocusPart } |
| }; |
| |
| #define kHIViewBaseClassID CFSTR( "com.apple.hiview" ) |
| #define kHIWebViewClassID CFSTR( "com.apple.HIWebView" ) |
| |
| static HIWebView* HIWebViewConstructor( HIViewRef inView ); |
| static void HIWebViewDestructor( HIWebView* view ); |
| |
| static OSStatus HIWebViewEventHandler( |
| EventHandlerCallRef inCallRef, |
| EventRef inEvent, |
| void * inUserData ); |
| |
| static UInt32 GetBehaviors(); |
| static ControlKind GetKind(); |
| static void Draw( HIWebView* inView, RgnHandle limitRgn, CGContextRef inContext ); |
| static ControlPartCode HitTest( HIWebView* view, const HIPoint* where ); |
| static OSStatus GetRegion( HIWebView* view, ControlPartCode inPart, RgnHandle outRgn ); |
| static void BoundsChanged( |
| HIWebView* inView, |
| UInt32 inOptions, |
| const HIRect* inOriginalBounds, |
| const HIRect* inCurrentBounds ); |
| static void OwningWindowChanged( |
| HIWebView* view, |
| WindowRef oldWindow, |
| WindowRef newWindow ); |
| static void ActiveStateChanged( HIWebView* view ); |
| |
| static OSStatus Click( HIWebView* inView, EventRef inEvent ); |
| static OSStatus ContextMenuClick( HIWebView* inView, EventRef inEvent ); |
| static OSStatus MouseUp( HIWebView* inView, EventRef inEvent ); |
| static OSStatus MouseMoved( HIWebView* inView, EventRef inEvent ); |
| static OSStatus MouseDragged( HIWebView* inView, EventRef inEvent ); |
| static OSStatus MouseWheelMoved( HIWebView* inView, EventRef inEvent ); |
| |
| static OSStatus ProcessCommand( HIWebView* inView, const HICommand* inCommand ); |
| static OSStatus UpdateCommandStatus( HIWebView* inView, const HICommand* inCommand ); |
| |
| static OSStatus SetFocusPart( |
| HIWebView* view, |
| ControlPartCode desiredFocus, |
| RgnHandle invalidRgn, |
| Boolean focusEverything, |
| ControlPartCode* actualFocus ); |
| static NSView* AdvanceFocus( HIWebView* view, bool forward ); |
| static void RelinquishFocus( HIWebView* view, bool inAutodisplay ); |
| |
| static WindowRef GetWindowRef( HIWebView* inView ); |
| static void SyncFrame( HIWebView* inView ); |
| |
| static OSStatus WindowHandler( EventHandlerCallRef inCallRef, EventRef inEvent, void* inUserData ); |
| |
| static void StartUpdateObserver( HIWebView* view ); |
| static void StopUpdateObserver( HIWebView* view ); |
| |
| static inline void HIRectToQDRect( const HIRect* inRect, Rect* outRect ) |
| { |
| outRect->top = (SInt16)CGRectGetMinY( *inRect ); |
| outRect->left = (SInt16)CGRectGetMinX( *inRect ); |
| outRect->bottom = (SInt16)CGRectGetMaxY( *inRect ); |
| outRect->right = (SInt16)CGRectGetMaxX( *inRect ); |
| } |
| |
| //---------------------------------------------------------------------------------- |
| // HIWebViewCreate |
| //---------------------------------------------------------------------------------- |
| // |
| OSStatus |
| HIWebViewCreate(HIViewRef* outControl) |
| { |
| HIWebViewRegisterClass(); |
| return HIObjectCreate(kHIWebViewClassID, NULL, (HIObjectRef*)outControl); |
| } |
| |
| //---------------------------------------------------------------------------------- |
| // HIWebViewGetWebView |
| //---------------------------------------------------------------------------------- |
| // |
| WebView* |
| HIWebViewGetWebView( HIViewRef inView ) |
| { |
| HIWebView* view = (HIWebView*)HIObjectDynamicCast( (HIObjectRef)inView, kHIWebViewClassID ); |
| WebView* result = NULL; |
| |
| if ( view ) |
| result = view->fWebView; |
| |
| return result; |
| } |
| |
| //---------------------------------------------------------------------------------- |
| // HIWebViewConstructor |
| //---------------------------------------------------------------------------------- |
| // |
| |
| static HIWebView* |
| HIWebViewConstructor( HIViewRef inView ) |
| { |
| HIWebView* view = (HIWebView*)malloc( sizeof( HIWebView ) ); |
| |
| if ( view ) |
| { |
| NSRect frame = { { 0, 0 }, { 400, 400 } }; |
| |
| view->fViewRef = inView; |
| |
| WebView *webView = [[WebView alloc] initWithFrame: frame]; |
| CFRetain(webView); |
| [webView release]; |
| view->fWebView = webView; |
| [HIViewAdapter bindHIViewToNSView:inView nsView:view->fWebView]; |
| |
| view->fFirstResponder = NULL; |
| view->fKitWindow = NULL; |
| view->fIsComposited = false; |
| view->fUpdateObserver = NULL; |
| } |
| |
| return view; |
| } |
| |
| //---------------------------------------------------------------------------------- |
| // HIWebViewDestructor |
| //---------------------------------------------------------------------------------- |
| // |
| static void |
| HIWebViewDestructor( HIWebView* inView ) |
| { |
| [HIViewAdapter unbindNSView:inView->fWebView]; |
| CFRelease(inView->fWebView); |
| |
| free(inView); |
| } |
| |
| //---------------------------------------------------------------------------------- |
| // HIWebViewRegisterClass |
| //---------------------------------------------------------------------------------- |
| // |
| void |
| HIWebViewRegisterClass() |
| { |
| static bool sRegistered; |
| |
| if ( !sRegistered ) |
| { |
| HIObjectRegisterSubclass( kHIWebViewClassID, kHIViewBaseClassID, 0, HIWebViewEventHandler, |
| GetEventTypeCount( kEvents ), kEvents, 0, NULL ); |
| sRegistered = true; |
| } |
| } |
| |
| //---------------------------------------------------------------------------------- |
| // GetBehaviors |
| //---------------------------------------------------------------------------------- |
| // |
| static UInt32 |
| GetBehaviors() |
| { |
| return kControlSupportsDataAccess | kControlSupportsGetRegion | kControlGetsFocusOnClick; |
| } |
| |
| //---------------------------------------------------------------------------------- |
| // Draw |
| //---------------------------------------------------------------------------------- |
| // |
| static void |
| Draw( HIWebView* inView, RgnHandle limitRgn, CGContextRef inContext ) |
| { |
| HIRect bounds; |
| Rect drawRect; |
| HIRect hiRect; |
| bool createdContext = false; |
| |
| if (!inView->fIsComposited) |
| { |
| GrafPtr port; |
| Rect portRect; |
| |
| GetPort( &port ); |
| GetPortBounds( port, &portRect ); |
| CreateCGContextForPort( port, &inContext ); |
| SyncCGContextOriginWithPort( inContext, port ); |
| CGContextTranslateCTM( inContext, 0, (portRect.bottom - portRect.top) ); |
| CGContextScaleCTM( inContext, 1, -1 ); |
| createdContext = true; |
| } |
| |
| HIViewGetBounds( inView->fViewRef, &bounds ); |
| |
| CGContextRef savedContext = WKNSWindowOverrideCGContext(inView->fKitWindow, inContext); |
| [NSGraphicsContext setCurrentContext:[inView->fKitWindow graphicsContext]]; |
| |
| GetRegionBounds( limitRgn, &drawRect ); |
| |
| if ( !inView->fIsComposited ) |
| OffsetRect( &drawRect, (SInt16)-bounds.origin.x, (SInt16)-bounds.origin.y ); |
| |
| hiRect.origin.x = drawRect.left; |
| hiRect.origin.y = bounds.size.height - drawRect.bottom; // flip y |
| hiRect.size.width = drawRect.right - drawRect.left; |
| hiRect.size.height = drawRect.bottom - drawRect.top; |
| |
| // printf( "Drawing: drawRect is (%g %g) (%g %g)\n", hiRect.origin.x, hiRect.origin.y, |
| // hiRect.size.width, hiRect.size.height ); |
| |
| // FIXME: We need to do layout before Carbon has decided what region needs drawn. |
| // In Cocoa we make sure to do layout and invalidate any new regions before draw, so everything |
| // can be drawn in one pass. Doing a layout here will cause new regions to be invalidated, but they |
| // will not all be drawn in this pass since we already have a fixed rect we are going to display. |
| |
| NSView <WebDocumentView> *documentView = [[[inView->fWebView mainFrame] frameView] documentView]; |
| if ([documentView isKindOfClass:[WebHTMLView class]]) |
| [(WebHTMLView *)documentView _web_updateLayoutAndStyleIfNeededRecursive]; |
| |
| if ( inView->fIsComposited ) |
| [inView->fWebView displayIfNeededInRect: *(NSRect*)&hiRect]; |
| else |
| [inView->fWebView displayRect:*(NSRect*)&hiRect]; |
| |
| WKNSWindowRestoreCGContext(inView->fKitWindow, savedContext); |
| |
| if ( !inView->fIsComposited ) |
| { |
| HIViewRef view; |
| HIViewFindByID( HIViewGetRoot( GetControlOwner( inView->fViewRef ) ), kHIViewWindowGrowBoxID, &view ); |
| if ( view ) |
| { |
| HIRect frame; |
| |
| HIViewGetBounds( view, &frame ); |
| HIViewConvertRect( &frame, view, NULL ); |
| |
| hiRect.origin.x = drawRect.left; |
| hiRect.origin.y = drawRect.top; |
| hiRect.size.width = drawRect.right - drawRect.left; |
| hiRect.size.height = drawRect.bottom - drawRect.top; |
| |
| HIViewConvertRect( &hiRect, inView->fViewRef, NULL ); |
| |
| if ( CGRectIntersectsRect( frame, hiRect ) ) |
| HIViewSetNeedsDisplay( view, true ); |
| } |
| } |
| |
| if ( createdContext ) |
| { |
| CGContextSynchronize( inContext ); |
| CGContextRelease( inContext ); |
| } |
| } |
| |
| //---------------------------------------------------------------------------------- |
| // HitTest |
| //---------------------------------------------------------------------------------- |
| // |
| static ControlPartCode |
| HitTest( HIWebView* view, const HIPoint* where ) |
| { |
| HIRect bounds; |
| |
| HIViewGetBounds( view->fViewRef, &bounds ); |
| |
| if ( CGRectContainsPoint( bounds, *where ) ) |
| return 1; |
| else |
| return kControlNoPart; |
| } |
| |
| //---------------------------------------------------------------------------------- |
| // GetRegion |
| //---------------------------------------------------------------------------------- |
| // |
| static OSStatus |
| GetRegion( |
| HIWebView* inView, |
| ControlPartCode inPart, |
| RgnHandle outRgn ) |
| { |
| OSStatus err = eventNotHandledErr; |
| |
| if ( inPart == -3 ) // kControlOpaqueMetaPart: |
| { |
| if ( [inView->fWebView isOpaque] ) |
| { |
| HIRect bounds; |
| Rect temp; |
| |
| HIViewGetBounds( inView->fViewRef, &bounds ); |
| |
| temp.top = (SInt16)bounds.origin.y; |
| temp.left = (SInt16)bounds.origin.x; |
| temp.bottom = (SInt16)CGRectGetMaxY( bounds ); |
| temp.right = (SInt16)CGRectGetMaxX( bounds ); |
| |
| RectRgn( outRgn, &temp ); |
| err = noErr; |
| } |
| } |
| |
| return err; |
| } |
| |
| static WindowRef |
| GetWindowRef( HIWebView* inView ) |
| { |
| return GetControlOwner( inView->fViewRef ); |
| } |
| |
| //---------------------------------------------------------------------------------- |
| // Click |
| //---------------------------------------------------------------------------------- |
| // |
| static OSStatus |
| Click(HIWebView* inView, EventRef inEvent) |
| { |
| NSEvent *kitEvent = WKCreateNSEventWithCarbonClickEvent(inEvent, GetWindowRef(inView)); |
| |
| if (!inView->fIsComposited) |
| StartUpdateObserver(inView); |
| |
| [inView->fKitWindow sendEvent:kitEvent]; |
| |
| if (!inView->fIsComposited) |
| StopUpdateObserver(inView); |
| |
| [kitEvent release]; |
| |
| return noErr; |
| } |
| |
| //---------------------------------------------------------------------------------- |
| // MouseUp |
| //---------------------------------------------------------------------------------- |
| // |
| static OSStatus |
| MouseUp( HIWebView* inView, EventRef inEvent ) |
| { |
| NSEvent* kitEvent = WKCreateNSEventWithCarbonEvent(inEvent); |
| |
| [inView->fKitWindow sendEvent:kitEvent]; |
| |
| [kitEvent release]; |
| |
| return noErr; |
| } |
| |
| //---------------------------------------------------------------------------------- |
| // MouseMoved |
| //---------------------------------------------------------------------------------- |
| // |
| static OSStatus |
| MouseMoved( HIWebView* inView, EventRef inEvent ) |
| { |
| NSEvent *kitEvent = WKCreateNSEventWithCarbonMouseMoveEvent(inEvent, inView->fKitWindow); |
| [inView->fKitWindow sendEvent:kitEvent]; |
| [kitEvent release]; |
| |
| return noErr; |
| } |
| |
| //---------------------------------------------------------------------------------- |
| // MouseDragged |
| //---------------------------------------------------------------------------------- |
| // |
| static OSStatus |
| MouseDragged( HIWebView* inView, EventRef inEvent ) |
| { |
| NSEvent* kitEvent = WKCreateNSEventWithCarbonEvent(inEvent); |
| |
| [inView->fKitWindow sendEvent:kitEvent]; |
| |
| [kitEvent release]; |
| |
| return noErr; |
| } |
| |
| //---------------------------------------------------------------------------------- |
| // MouseDragged |
| //---------------------------------------------------------------------------------- |
| // |
| static OSStatus |
| MouseWheelMoved( HIWebView* inView, EventRef inEvent ) |
| { |
| NSEvent* kitEvent = WKCreateNSEventWithCarbonEvent(inEvent); |
| |
| [inView->fKitWindow sendEvent:kitEvent]; |
| |
| [kitEvent release]; |
| |
| return noErr; |
| } |
| |
| //---------------------------------------------------------------------------------- |
| // ContextMenuClick |
| //---------------------------------------------------------------------------------- |
| // |
| static OSStatus |
| ContextMenuClick( HIWebView* inView, EventRef inEvent ) |
| { |
| NSView *webView = inView->fWebView; |
| NSWindow *window = [webView window]; |
| |
| // Get the point out of the event. |
| HIPoint point; |
| GetEventParameter(inEvent, kEventParamMouseLocation, typeHIPoint, NULL, sizeof(point), NULL, &point); |
| HIViewConvertPoint(&point, inView->fViewRef, NULL); |
| |
| // Flip the Y coordinate, since Carbon is flipped relative to the AppKit. |
| NSPoint location = NSMakePoint(point.x, [window frame].size.height - point.y); |
| |
| // Make up an event with the point and send it to the window. |
| NSEvent *kitEvent = [NSEvent mouseEventWithType:NSRightMouseDown |
| location:location |
| modifierFlags:0 |
| timestamp:GetEventTime(inEvent) |
| windowNumber:[window windowNumber] |
| context:0 |
| eventNumber:0 |
| clickCount:1 |
| pressure:0]; |
| [inView->fKitWindow sendEvent:kitEvent]; |
| return noErr; |
| } |
| |
| //---------------------------------------------------------------------------------- |
| // GetKind |
| //---------------------------------------------------------------------------------- |
| // |
| static ControlKind |
| GetKind() |
| { |
| const ControlKind kMyKind = { 'appl', 'wbvw' }; |
| |
| return kMyKind; |
| } |
| |
| //---------------------------------------------------------------------------------- |
| // BoundsChanged |
| //---------------------------------------------------------------------------------- |
| // |
| static void |
| BoundsChanged( |
| HIWebView* inView, |
| UInt32 inOptions, |
| const HIRect* inOriginalBounds, |
| const HIRect* inCurrentBounds ) |
| { |
| if ( inView->fWebView ) |
| { |
| SyncFrame( inView ); |
| } |
| } |
| |
| //---------------------------------------------------------------------------------- |
| // OwningWindowChanged |
| //---------------------------------------------------------------------------------- |
| // |
| static void |
| OwningWindowChanged( |
| HIWebView* view, |
| WindowRef oldWindow, |
| WindowRef newWindow ) |
| { |
| if ( newWindow ){ |
| WindowAttributes attrs; |
| |
| OSStatus err = GetWindowProperty(newWindow, NSAppKitPropertyCreator, NSCarbonWindowPropertyTag, sizeof(NSWindow *), NULL, &view->fKitWindow); |
| if ( err != noErr ) |
| { |
| const EventTypeSpec kWindowEvents[] = { |
| { kEventClassWindow, kEventWindowClosed }, |
| { kEventClassMouse, kEventMouseMoved }, |
| { kEventClassMouse, kEventMouseUp }, |
| { kEventClassMouse, kEventMouseDragged }, |
| { kEventClassMouse, kEventMouseWheelMoved }, |
| { kEventClassKeyboard, kEventRawKeyDown }, |
| { kEventClassKeyboard, kEventRawKeyRepeat }, |
| { kEventClassKeyboard, kEventRawKeyUp }, |
| { kEventClassControl, kEventControlClick }, |
| }; |
| |
| view->fKitWindow = [[CarbonWindowAdapter alloc] initWithCarbonWindowRef: newWindow takingOwnership: NO disableOrdering:NO carbon:YES]; |
| SetWindowProperty(newWindow, NSAppKitPropertyCreator, NSCarbonWindowPropertyTag, sizeof(NSWindow *), &view->fKitWindow); |
| |
| InstallWindowEventHandler( newWindow, WindowHandler, GetEventTypeCount( kWindowEvents ), kWindowEvents, newWindow, NULL ); |
| } |
| |
| [[view->fKitWindow contentView] addSubview:view->fWebView]; |
| |
| GetWindowAttributes( newWindow, &attrs ); |
| view->fIsComposited = ( ( attrs & kWindowCompositingAttribute ) != 0 ); |
| |
| SyncFrame( view ); |
| } |
| else |
| { |
| // Be sure to detach the cocoa view, too. |
| if ( view->fWebView ) |
| [view->fWebView removeFromSuperview]; |
| |
| view->fKitWindow = NULL; // break the ties that bind |
| } |
| } |
| |
| //------------------------------------------------------------------------------------- |
| // WindowHandler |
| //------------------------------------------------------------------------------------- |
| // Redirect mouse events to the views beneath them. This is required for WebKit to work |
| // properly. We install it once per window. We also tap into window close to release |
| // the NSWindow that shadows our Carbon window. |
| // |
| static OSStatus |
| WindowHandler( EventHandlerCallRef inCallRef, EventRef inEvent, void* inUserData ) |
| { |
| WindowRef window = (WindowRef)inUserData; |
| OSStatus result = eventNotHandledErr; |
| |
| switch( GetEventClass( inEvent ) ) |
| { |
| case kEventClassControl: |
| { |
| switch( GetEventKind( inEvent ) ) |
| { |
| case kEventControlClick: |
| { |
| CarbonWindowAdapter *kitWindow; |
| OSStatus err; |
| |
| err = GetWindowProperty( window, NSAppKitPropertyCreator, NSCarbonWindowPropertyTag, sizeof(NSWindow *), NULL, &kitWindow); |
| |
| // We must be outside the HIWebView, relinquish focus. |
| [kitWindow relinquishFocus]; |
| } |
| break; |
| } |
| } |
| break; |
| |
| case kEventClassKeyboard: |
| { |
| NSWindow* kitWindow; |
| OSStatus err; |
| NSEvent* kitEvent; |
| |
| // if the first responder in the kit window is something other than the |
| // window, we assume a subview of the webview is focused. we must send |
| // the event to the window so that it goes through the kit's normal TSM |
| // logic, and -- more importantly -- allows any delegates associated |
| // with the first responder to have a chance at the event. |
| |
| err = GetWindowProperty( window, NSAppKitPropertyCreator, NSCarbonWindowPropertyTag, sizeof(NSWindow *), NULL, &kitWindow); |
| if ( err == noErr ) |
| { |
| NSResponder* responder = [kitWindow firstResponder]; |
| if ( responder != kitWindow ) |
| { |
| kitEvent = WKCreateNSEventWithCarbonEvent(inEvent); |
| |
| [kitWindow sendEvent:kitEvent]; |
| [kitEvent release]; |
| |
| result = noErr; |
| } |
| } |
| } |
| break; |
| |
| case kEventClassWindow: |
| { |
| NSWindow* kitWindow; |
| OSStatus err; |
| |
| err = GetWindowProperty( window, NSAppKitPropertyCreator, NSCarbonWindowPropertyTag, sizeof(NSWindow *), NULL, &kitWindow); |
| if ( err == noErr ) |
| { |
| [kitWindow _removeWindowRef]; |
| [kitWindow close]; |
| } |
| |
| result = noErr; |
| } |
| break; |
| |
| case kEventClassMouse: |
| switch (GetEventKind(inEvent)) |
| { |
| case kEventMouseMoved: |
| { |
| Point where; |
| GetEventParameter(inEvent, kEventParamMouseLocation, typeQDPoint, NULL, sizeof(Point), NULL, &where); |
| |
| WindowRef temp; |
| FindWindow(where, &temp); |
| if (temp == window) |
| { |
| Rect bounds; |
| GetWindowBounds(window, kWindowStructureRgn, &bounds); |
| where.h -= bounds.left; |
| where.v -= bounds.top; |
| SetEventParameter(inEvent, kEventParamWindowRef, typeWindowRef, sizeof(WindowRef), &window); |
| SetEventParameter(inEvent, kEventParamWindowMouseLocation, typeQDPoint, sizeof(Point), &where); |
| |
| OSStatus err = noErr; |
| HIViewRef view = NULL; |
| |
| err = HIViewGetViewForMouseEvent(HIViewGetRoot(window), inEvent, &view); |
| if (err == noErr && view && HIObjectIsOfClass((HIObjectRef)view, kHIWebViewClassID)) |
| result = SendEventToEventTargetWithOptions(inEvent, HIObjectGetEventTarget((HIObjectRef)view), kEventTargetDontPropagate); |
| } |
| } |
| break; |
| |
| case kEventMouseUp: |
| case kEventMouseDragged: |
| case kEventMouseWheelMoved: |
| { |
| OSStatus err = noErr; |
| HIViewRef view = NULL; |
| |
| err = HIViewGetViewForMouseEvent(HIViewGetRoot(window), inEvent, &view); |
| if (err == noErr && view && HIObjectIsOfClass((HIObjectRef)view, kHIWebViewClassID)) |
| result = SendEventToEventTargetWithOptions(inEvent, HIObjectGetEventTarget((HIObjectRef)view), kEventTargetDontPropagate); |
| } |
| break; |
| } |
| break; |
| } |
| |
| return result; |
| } |
| |
| |
| //---------------------------------------------------------------------------------- |
| // SyncFrame |
| //---------------------------------------------------------------------------------- |
| // |
| static void |
| SyncFrame( HIWebView* inView ) |
| { |
| HIViewRef parent = HIViewGetSuperview( inView->fViewRef ); |
| |
| if ( parent ) |
| { |
| if ( inView->fIsComposited ) |
| { |
| HIRect frame; |
| HIRect parentBounds; |
| NSPoint origin; |
| |
| HIViewGetFrame( inView->fViewRef, &frame ); |
| HIViewGetBounds( parent, &parentBounds ); |
| |
| origin.x = frame.origin.x; |
| origin.y = parentBounds.size.height - CGRectGetMaxY( frame ); |
| // printf( "syncing to (%g %g) (%g %g)\n", origin.x, origin.y, |
| // frame.size.width, frame.size.height ); |
| [inView->fWebView setFrameOrigin: origin]; |
| [inView->fWebView setFrameSize: *(NSSize*)&frame.size]; |
| } |
| else |
| { |
| GrafPtr port = GetWindowPort( GetControlOwner( inView->fViewRef ) ); |
| PixMapHandle portPix = GetPortPixMap( port ); |
| Rect bounds; |
| HIRect rootFrame; |
| HIRect frame; |
| |
| GetControlBounds( inView->fViewRef, &bounds ); |
| OffsetRect( &bounds, -(**portPix).bounds.left, -(**portPix).bounds.top ); |
| |
| // printf( "control lives at %d %d %d %d in window-coords\n", bounds.top, bounds.left, |
| // bounds.bottom, bounds.right ); |
| |
| HIViewGetFrame( HIViewGetRoot( GetControlOwner( inView->fViewRef ) ), &rootFrame ); |
| |
| frame.origin.x = bounds.left; |
| frame.origin.y = rootFrame.size.height - bounds.bottom; |
| frame.size.width = bounds.right - bounds.left; |
| frame.size.height = bounds.bottom - bounds.top; |
| |
| // printf( " before frame convert (%g %g) (%g %g)\n", frame.origin.x, frame.origin.y, |
| // frame.size.width, frame.size.height ); |
| |
| [inView->fWebView convertRect:*(NSRect*)&frame fromView:nil]; |
| |
| // printf( " moving web view to (%g %g) (%g %g)\n", frame.origin.x, frame.origin.y, |
| // frame.size.width, frame.size.height ); |
| |
| [inView->fWebView setFrameOrigin: *(NSPoint*)&frame.origin]; |
| [inView->fWebView setFrameSize: *(NSSize*)&frame.size]; |
| } |
| } |
| } |
| |
| //---------------------------------------------------------------------------------- |
| // SetFocusPart |
| //---------------------------------------------------------------------------------- |
| // |
| static OSStatus |
| SetFocusPart( |
| HIWebView* view, |
| ControlPartCode desiredFocus, |
| RgnHandle invalidRgn, |
| Boolean focusEverything, |
| ControlPartCode* actualFocus ) |
| { |
| NSView * freshlyMadeFirstResponderView; |
| SInt32 partCodeToReturn; |
| |
| // Do what Carbon is telling us to do. |
| if ( desiredFocus == kControlFocusNoPart ) |
| { |
| // Relinquish the keyboard focus. |
| RelinquishFocus( view, true ); //(autodisplay ? YES : NO)); |
| freshlyMadeFirstResponderView = nil; |
| partCodeToReturn = kControlFocusNoPart; |
| //NSLog(@"Relinquished the key focus because we have no choice."); |
| } |
| else if ( desiredFocus == kControlFocusNextPart || desiredFocus == kControlFocusPrevPart ) |
| { |
| BOOL goForward = (desiredFocus == kControlFocusNextPart ); |
| |
| // Advance the keyboard focus, maybe right off of this view. Maybe a subview of this one already has the keyboard focus, maybe not. |
| freshlyMadeFirstResponderView = AdvanceFocus( view, goForward ); |
| if (freshlyMadeFirstResponderView) |
| partCodeToReturn = desiredFocus; |
| else |
| partCodeToReturn = kControlFocusNoPart; |
| //NSLog(freshlyMadeFirstResponderView ? @"Advanced the key focus." : @"Relinquished the key focus."); |
| } |
| else |
| { |
| // What's this? |
| if (desiredFocus != kControlIndicatorPart) { |
| check(false); |
| } |
| freshlyMadeFirstResponderView = nil; |
| partCodeToReturn = desiredFocus; |
| } |
| |
| view->fFirstResponder = freshlyMadeFirstResponderView; |
| |
| *actualFocus = partCodeToReturn; |
| |
| // Done. |
| return noErr; |
| } |
| |
| //---------------------------------------------------------------------------------- |
| // AdvanceFocus |
| //---------------------------------------------------------------------------------- |
| // |
| static NSView* |
| AdvanceFocus( HIWebView* view, bool forward ) |
| { |
| NSResponder* oldFirstResponder; |
| NSView* currentKeyView; |
| NSView* viewWeMadeFirstResponder; |
| |
| // Focus on some part (subview) of this control (view). Maybe |
| // a subview of this one already has the keyboard focus, maybe not. |
| |
| oldFirstResponder = [view->fKitWindow firstResponder]; |
| |
| // If we tab out of our NSView, it will no longer be the responder |
| // when we get here. We'll try this trick for now. We might need to |
| // tag the view appropriately. |
| |
| if ( view->fFirstResponder && ( (NSResponder*)view->fFirstResponder != oldFirstResponder ) ) |
| { |
| return NULL; |
| } |
| |
| if ( [oldFirstResponder isKindOfClass:[NSView class]] ) |
| { |
| NSView* tentativeNewKeyView; |
| |
| // Some view in this window already has the keyboard focus. It better at least be a subview of this one. |
| NSView* oldFirstResponderView = (NSView *)oldFirstResponder; |
| check( [oldFirstResponderView isDescendantOf:view->fWebView] ); |
| |
| if ( oldFirstResponderView != view->fFirstResponder |
| && ![oldFirstResponderView isDescendantOf:view->fFirstResponder] ) |
| { |
| // Despite our efforts to record what view we made the first responder |
| // (for use in the next paragraph) we couldn't keep up because the user |
| // has clicked in a text field to make it the key focus, instead of using |
| // the tab key. Find a control on which it's reasonable to invoke |
| // -[NSView nextValidKeyView], taking into account the fact that |
| // NSTextFields always pass on first-respondership to a temporarily- |
| // contained NSTextView. |
| |
| NSView *viewBeingTested; |
| currentKeyView = oldFirstResponderView; |
| viewBeingTested = currentKeyView; |
| while ( viewBeingTested != view->fWebView ) |
| { |
| if ( [viewBeingTested isKindOfClass:[NSTextField class]] ) |
| { |
| currentKeyView = viewBeingTested; |
| break; |
| } |
| else |
| { |
| viewBeingTested = [viewBeingTested superview]; |
| } |
| } |
| } |
| else |
| { |
| // We recorded which view we made into the first responder the |
| // last time the user hit the tab key, and nothing has invalidated |
| // our recorded value since. |
| |
| currentKeyView = view->fFirstResponder; |
| } |
| |
| // Try to move on to the next or previous key view. We use the laboriously |
| // recorded/figured currentKeyView instead of just oldFirstResponder as the |
| // jumping-off-point when searching for the next valid key view. This is so |
| // we don't get fooled if we recently made some view the first responder, but |
| // it passed on first-responder-ness to some temporary subview. |
| |
| // You can't put normal views in a window with Carbon-control-wrapped views. |
| // Stuff like this would break. M.P. Notice - 12/2/00 |
| |
| tentativeNewKeyView = forward ? [currentKeyView nextValidKeyView] : [currentKeyView previousValidKeyView]; |
| if ( tentativeNewKeyView && [tentativeNewKeyView isDescendantOf:view->fWebView] ) |
| { |
| // The user has tabbed to another subview of this control view. Change the keyboard focus. |
| //NSLog(@"Tabbed to the next or previous key view."); |
| |
| [view->fKitWindow makeFirstResponder:tentativeNewKeyView]; |
| viewWeMadeFirstResponder = tentativeNewKeyView; |
| } |
| else |
| { |
| // The user has tabbed past the subviews of this control view. The window is the first responder now. |
| //NSLog(@"Tabbed past the first or last key view."); |
| [view->fKitWindow makeFirstResponder:view->fKitWindow]; |
| viewWeMadeFirstResponder = nil; |
| } |
| } |
| else |
| { |
| // No view in this window has the keyboard focus. This view should |
| // try to select one of its key subviews. We're not interested in |
| // the subviews of sibling views here. |
| |
| //NSLog(@"No keyboard focus in window. Attempting to set..."); |
| |
| NSView *tentativeNewKeyView; |
| check(oldFirstResponder==fKitWindow); |
| if ( [view->fWebView acceptsFirstResponder] ) |
| tentativeNewKeyView = view->fWebView; |
| else |
| tentativeNewKeyView = [view->fWebView nextValidKeyView]; |
| if ( tentativeNewKeyView && [tentativeNewKeyView isDescendantOf:view->fWebView] ) |
| { |
| // This control view has at least one subview that can take the keyboard focus. |
| if ( !forward ) |
| { |
| // The user has tabbed into this control view backwards. Find |
| // and select the last subview of this one that can take the |
| // keyboard focus. Watch out for loops of valid key views. |
| |
| NSView *firstTentativeNewKeyView = tentativeNewKeyView; |
| NSView *nextTentativeNewKeyView = [tentativeNewKeyView nextValidKeyView]; |
| while ( nextTentativeNewKeyView |
| && [nextTentativeNewKeyView isDescendantOf:view->fWebView] |
| && nextTentativeNewKeyView!=firstTentativeNewKeyView) |
| { |
| tentativeNewKeyView = nextTentativeNewKeyView; |
| nextTentativeNewKeyView = [tentativeNewKeyView nextValidKeyView]; |
| } |
| |
| } |
| |
| // Set the keyboard focus. |
| //NSLog(@"Tabbed into the first or last key view."); |
| [view->fKitWindow makeFirstResponder:tentativeNewKeyView]; |
| viewWeMadeFirstResponder = tentativeNewKeyView; |
| } |
| else |
| { |
| // This control view has no subviews that can take the keyboard focus. |
| //NSLog(@"Can't tab into this view."); |
| viewWeMadeFirstResponder = nil; |
| } |
| } |
| |
| // Done. |
| return viewWeMadeFirstResponder; |
| } |
| |
| |
| //---------------------------------------------------------------------------------- |
| // RelinquishFocus |
| //---------------------------------------------------------------------------------- |
| // |
| static void |
| RelinquishFocus( HIWebView* view, bool inAutodisplay ) |
| { |
| NSResponder* firstResponder; |
| |
| // Apparently Carbon thinks that some subview of this control view has the keyboard focus, |
| // or we wouldn't be being asked to relinquish focus. |
| |
| firstResponder = [view->fKitWindow firstResponder]; |
| if ( [firstResponder isKindOfClass:[NSView class]] ) |
| { |
| // Some subview of this control view really is the first responder right now. |
| check( [(NSView *)firstResponder isDescendantOf:view->fWebView] ); |
| |
| // Make the window the first responder, so that no view is the key view. |
| [view->fKitWindow makeFirstResponder:view->fKitWindow]; |
| |
| // If this control is not allowed to do autodisplay, don't let |
| // it autodisplay any just-changed focus rings or text on the |
| // next go around the event loop. I'm probably clearing more |
| // dirty rects than I have to, but it doesn't seem to hurt in |
| // the print panel accessory view case, and I don't have time |
| // to figure out exactly what -[NSCell _setKeyboardFocusRingNeedsDisplay] |
| // is doing when invoked indirectly from -makeFirstResponder up above. M.P. Notice - 12/4/00 |
| |
| if ( !inAutodisplay ) |
| [[view->fWebView opaqueAncestor] _clearDirtyRectsForTree]; |
| } |
| else |
| { |
| // The Cocoa first responder does not correspond to the Carbon |
| // control that has the keyboard focus. This can happen when |
| // you've closed a dialog by hitting return in an NSTextView |
| // that's a subview of this one; Cocoa closed the window, and |
| // now Carbon is telling this control to relinquish the focus |
| // as it's being disposed. There's nothing to do. |
| |
| check(firstResponder==window); |
| } |
| } |
| |
| //---------------------------------------------------------------------------------- |
| // ActiveStateChanged |
| //---------------------------------------------------------------------------------- |
| // |
| static void |
| ActiveStateChanged( HIWebView* view ) |
| { |
| if ( [view->fWebView respondsToSelector:@selector(setEnabled)] ) |
| { |
| [(NSControl*)view->fWebView setEnabled: IsControlEnabled( view->fViewRef )]; |
| HIViewSetNeedsDisplay( view->fViewRef, true ); |
| } |
| } |
| |
| |
| //---------------------------------------------------------------------------------- |
| // ProcessCommand |
| //---------------------------------------------------------------------------------- |
| // |
| static OSStatus |
| ProcessCommand( HIWebView* inView, const HICommand* inCommand ) |
| { |
| OSStatus result = eventNotHandledErr; |
| NSResponder* resp; |
| |
| resp = [inView->fKitWindow firstResponder]; |
| |
| if ( [resp isKindOfClass:[NSView class]] ) |
| { |
| NSView* respView = (NSView*)resp; |
| |
| if ( respView == inView->fWebView |
| || [respView isDescendantOf: inView->fWebView] ) |
| { |
| switch ( inCommand->commandID ) |
| { |
| case kHICommandCut: |
| case kHICommandCopy: |
| case kHICommandPaste: |
| case kHICommandClear: |
| case kHICommandSelectAll: |
| { |
| SEL selector = _NSSelectorForHICommand( inCommand ); |
| if ( [respView respondsToSelector:selector] ) |
| { |
| [respView performSelector:selector withObject:nil]; |
| result = noErr; |
| } |
| } |
| break; |
| } |
| } |
| } |
| |
| return result; |
| } |
| |
| //---------------------------------------------------------------------------------- |
| // UpdateCommandStatus |
| //---------------------------------------------------------------------------------- |
| // |
| static OSStatus |
| UpdateCommandStatus( HIWebView* inView, const HICommand* inCommand ) |
| { |
| OSStatus result = eventNotHandledErr; |
| MenuItemProxy* proxy = NULL; |
| NSResponder* resp; |
| |
| resp = [inView->fKitWindow firstResponder]; |
| |
| if ( [resp isKindOfClass:[NSView class]] ) |
| { |
| NSView* respView = (NSView*)resp; |
| |
| if ( respView == inView->fWebView |
| || [respView isDescendantOf: inView->fWebView] ) |
| { |
| if ( inCommand->attributes & kHICommandFromMenu ) |
| { |
| SEL selector = _NSSelectorForHICommand( inCommand ); |
| |
| if ( selector ) |
| { |
| if ( [resp respondsToSelector: selector] ) |
| { |
| proxy = [[MenuItemProxy alloc] initWithAction: selector]; |
| |
| // Can't use -performSelector:withObject: here because the method we're calling returns BOOL, while |
| // -performSelector:withObject:'s return value is assumed to be an id. |
| BOOL (*validationFunction)(id, SEL, id) = (BOOL (*)(id, SEL, id))objc_msgSend; |
| if (validationFunction(resp, @selector(validateUserInterfaceItem:), proxy)) |
| EnableMenuItem( inCommand->menu.menuRef, inCommand->menu.menuItemIndex ); |
| else |
| DisableMenuItem( inCommand->menu.menuRef, inCommand->menu.menuItemIndex ); |
| |
| result = noErr; |
| } |
| } |
| } |
| } |
| } |
| |
| if ( proxy ) |
| [proxy release]; |
| |
| return result; |
| } |
| |
| // Blatantly stolen from AppKit and cropped a bit |
| |
| //---------------------------------------------------------------------------------- |
| // _NSSelectorForHICommand |
| //---------------------------------------------------------------------------------- |
| // |
| static SEL |
| _NSSelectorForHICommand( const HICommand* inCommand ) |
| { |
| switch ( inCommand->commandID ) |
| { |
| case kHICommandUndo: return @selector(undo:); |
| case kHICommandRedo: return @selector(redo:); |
| case kHICommandCut : return @selector(cut:); |
| case kHICommandCopy : return @selector(copy:); |
| case kHICommandPaste: return @selector(paste:); |
| case kHICommandClear: return @selector(delete:); |
| case kHICommandSelectAll: return @selector(selectAll:); |
| default: return NULL; |
| } |
| |
| return NULL; |
| } |
| |
| |
| //----------------------------------------------------------------------------------- |
| // HIWebViewEventHandler |
| //----------------------------------------------------------------------------------- |
| // Our object's virtual event handler method. I'm not sure if we need this these days. |
| // We used to do various things with it, but those days are long gone... |
| // |
| static OSStatus |
| HIWebViewEventHandler( |
| EventHandlerCallRef inCallRef, |
| EventRef inEvent, |
| void * inUserData ) |
| { |
| OSStatus result = eventNotHandledErr; |
| HIPoint where; |
| OSType tag; |
| void * ptr; |
| Size size; |
| UInt32 features; |
| RgnHandle region = NULL; |
| ControlPartCode part; |
| HIWebView* view = (HIWebView*)inUserData; |
| |
| // [NSApp setWindowsNeedUpdate:YES] must be called before events so that ActivateTSMDocument is called to set an active document. |
| // Without an active document, TSM will use a default document which uses a bottom-line input window which we don't want. |
| [NSApp setWindowsNeedUpdate:YES]; |
| |
| switch ( GetEventClass( inEvent ) ) |
| { |
| case kEventClassHIObject: |
| switch ( GetEventKind( inEvent ) ) |
| { |
| case kEventHIObjectConstruct: |
| { |
| HIObjectRef object; |
| |
| result = GetEventParameter( inEvent, kEventParamHIObjectInstance, |
| typeHIObjectRef, NULL, sizeof( HIObjectRef ), NULL, &object ); |
| require_noerr( result, MissingParameter ); |
| |
| // on entry for our construct event, we're passed the |
| // creation proc we registered with for this class. |
| // we use it now to create the instance, and then we |
| // replace the instance parameter data with said instance |
| // as type void. |
| |
| view = HIWebViewConstructor( (HIViewRef)object ); |
| |
| if ( view ) |
| { |
| SetEventParameter( inEvent, kEventParamHIObjectInstance, |
| typeVoidPtr, sizeof( void * ), &view ); |
| } |
| } |
| break; |
| |
| case kEventHIObjectDestruct: |
| HIWebViewDestructor( view ); |
| // result is unimportant |
| break; |
| } |
| break; |
| |
| case kEventClassKeyboard: |
| { |
| NSEvent* kitEvent = WKCreateNSEventWithCarbonEvent(inEvent); |
| [view->fKitWindow sendSuperEvent:kitEvent]; |
| [kitEvent release]; |
| result = noErr; |
| } |
| break; |
| |
| case kEventClassMouse: |
| switch ( GetEventKind( inEvent ) ) |
| { |
| case kEventMouseUp: |
| result = MouseUp( view, inEvent ); |
| break; |
| |
| case kEventMouseWheelMoved: |
| result = MouseWheelMoved( view, inEvent ); |
| break; |
| |
| case kEventMouseMoved: |
| result = MouseMoved( view, inEvent ); |
| break; |
| |
| case kEventMouseDragged: |
| result = MouseDragged( view, inEvent ); |
| break; |
| } |
| break; |
| |
| case kEventClassCommand: |
| { |
| HICommand command; |
| |
| result = GetEventParameter( inEvent, kEventParamDirectObject, typeHICommand, NULL, |
| sizeof( HICommand ), NULL, &command ); |
| require_noerr( result, MissingParameter ); |
| |
| switch ( GetEventKind( inEvent ) ) |
| { |
| case kEventCommandProcess: |
| result = ProcessCommand( view, &command ); |
| break; |
| |
| case kEventCommandUpdateStatus: |
| result = UpdateCommandStatus( view, &command ); |
| break; |
| } |
| } |
| break; |
| |
| case kEventClassControl: |
| switch ( GetEventKind( inEvent ) ) |
| { |
| case kEventControlInitialize: |
| features = GetBehaviors(); |
| SetEventParameter( inEvent, kEventParamControlFeatures, typeUInt32, |
| sizeof( UInt32 ), &features ); |
| result = noErr; |
| break; |
| |
| case kEventControlDraw: |
| { |
| CGContextRef context = NULL; |
| |
| GetEventParameter( inEvent, kEventParamRgnHandle, typeQDRgnHandle, NULL, |
| sizeof( RgnHandle ), NULL, ®ion ); |
| GetEventParameter( inEvent, kEventParamCGContextRef, typeCGContextRef, NULL, |
| sizeof( CGContextRef ), NULL, &context ); |
| |
| Draw( view, region, context ); |
| |
| result = noErr; |
| } |
| break; |
| |
| case kEventControlHitTest: |
| GetEventParameter( inEvent, kEventParamMouseLocation, typeHIPoint, NULL, |
| sizeof( HIPoint ), NULL, &where ); |
| part = HitTest( view, &where ); |
| SetEventParameter( inEvent, kEventParamControlPart, typeControlPartCode, sizeof( ControlPartCode ), &part ); |
| result = noErr; |
| break; |
| |
| case kEventControlGetPartRegion: |
| GetEventParameter( inEvent, kEventParamControlPart, typeControlPartCode, NULL, |
| sizeof( ControlPartCode ), NULL, &part ); |
| GetEventParameter( inEvent, kEventParamControlRegion, typeQDRgnHandle, NULL, |
| sizeof( RgnHandle ), NULL, ®ion ); |
| result = GetRegion( view, part, region ); |
| break; |
| |
| case kEventControlGetData: |
| GetEventParameter(inEvent, kEventParamControlPart, typeControlPartCode, NULL, sizeof(ControlPartCode), NULL, &part); |
| GetEventParameter(inEvent, kEventParamControlDataTag, typeEnumeration, NULL, sizeof(OSType), NULL, &tag); |
| GetEventParameter(inEvent, kEventParamControlDataBuffer, typePtr, NULL, sizeof(Ptr), NULL, &ptr); |
| GetEventParameter(inEvent, kEventParamControlDataBufferSize, typeByteCount, NULL, sizeof(Size), NULL, &size); |
| |
| if (tag == kControlKindTag) { |
| Size outSize; |
| result = noErr; |
| |
| if (ptr) { |
| if (size != sizeof(ControlKind)) |
| result = errDataSizeMismatch; |
| else |
| (*(ControlKind *)ptr) = GetKind(); |
| } |
| |
| outSize = sizeof(ControlKind); |
| SetEventParameter(inEvent, kEventParamControlDataBufferSize, typeByteCount, sizeof(Size), &outSize); |
| } |
| |
| break; |
| |
| case kEventControlBoundsChanged: |
| { |
| HIRect prevRect, currRect; |
| UInt32 attrs; |
| |
| GetEventParameter( inEvent, kEventParamAttributes, typeUInt32, NULL, |
| sizeof( UInt32 ), NULL, &attrs ); |
| GetEventParameter( inEvent, kEventParamOriginalBounds, typeHIRect, NULL, |
| sizeof( HIRect ), NULL, &prevRect ); |
| GetEventParameter( inEvent, kEventParamCurrentBounds, typeHIRect, NULL, |
| sizeof( HIRect ), NULL, &currRect ); |
| |
| BoundsChanged( view, attrs, &prevRect, &currRect ); |
| result = noErr; |
| } |
| break; |
| |
| case kEventControlActivate: |
| ActiveStateChanged( view ); |
| result = noErr; |
| break; |
| |
| case kEventControlDeactivate: |
| ActiveStateChanged( view ); |
| result = noErr; |
| break; |
| |
| case kEventControlOwningWindowChanged: |
| { |
| WindowRef fromWindow, toWindow; |
| |
| result = GetEventParameter( inEvent, kEventParamControlOriginalOwningWindow, typeWindowRef, NULL, |
| sizeof( WindowRef ), NULL, &fromWindow ); |
| require_noerr( result, MissingParameter ); |
| |
| result = GetEventParameter( inEvent, kEventParamControlCurrentOwningWindow, typeWindowRef, NULL, |
| sizeof( WindowRef ), NULL, &toWindow ); |
| require_noerr( result, MissingParameter ); |
| |
| OwningWindowChanged( view, fromWindow, toWindow ); |
| |
| result = noErr; |
| } |
| break; |
| |
| case kEventControlClick: |
| result = Click( view, inEvent ); |
| break; |
| |
| case kEventControlContextualMenuClick: |
| result = ContextMenuClick( view, inEvent ); |
| break; |
| |
| case kEventControlSetFocusPart: |
| { |
| ControlPartCode desiredFocus; |
| RgnHandle invalidRgn; |
| Boolean focusEverything; |
| ControlPartCode actualFocus; |
| |
| result = GetEventParameter( inEvent, kEventParamControlPart, typeControlPartCode, NULL, |
| sizeof( ControlPartCode ), NULL, &desiredFocus ); |
| require_noerr( result, MissingParameter ); |
| |
| GetEventParameter( inEvent, kEventParamControlInvalRgn, typeQDRgnHandle, NULL, |
| sizeof( RgnHandle ), NULL, &invalidRgn ); |
| |
| focusEverything = false; // a good default in case the parameter doesn't exist |
| |
| GetEventParameter( inEvent, kEventParamControlFocusEverything, typeBoolean, NULL, |
| sizeof( Boolean ), NULL, &focusEverything ); |
| |
| result = SetFocusPart( view, desiredFocus, invalidRgn, focusEverything, &actualFocus ); |
| |
| if ( result == noErr ) |
| verify_noerr( SetEventParameter( inEvent, kEventParamControlPart, typeControlPartCode, |
| sizeof( ControlPartCode ), &actualFocus ) ); |
| } |
| break; |
| |
| // some other kind of Control event |
| default: |
| break; |
| } |
| break; |
| |
| // some other event class |
| default: |
| break; |
| } |
| |
| MissingParameter: |
| return result; |
| } |
| |
| |
| static void UpdateObserver(CFRunLoopObserverRef observer, CFRunLoopActivity activity, void *info); |
| |
| static void |
| StartUpdateObserver( HIWebView* view ) |
| { |
| CFRunLoopObserverContext context; |
| CFRunLoopObserverRef observer; |
| CFRunLoopRef mainRunLoop; |
| |
| check( view->fIsComposited == false ); |
| check( view->fUpdateObserver == NULL ); |
| |
| context.version = 0; |
| context.info = view; |
| context.retain = NULL; |
| context.release = NULL; |
| context.copyDescription = NULL; |
| |
| mainRunLoop = (CFRunLoopRef)GetCFRunLoopFromEventLoop( GetMainEventLoop() ); |
| observer = CFRunLoopObserverCreate( NULL, kCFRunLoopEntry | kCFRunLoopBeforeWaiting, true, 0, UpdateObserver, &context ); |
| CFRunLoopAddObserver( mainRunLoop, observer, kCFRunLoopCommonModes ); |
| |
| view->fUpdateObserver = observer; |
| |
| // printf( "Update observer started\n" ); |
| } |
| |
| static void |
| StopUpdateObserver( HIWebView* view ) |
| { |
| check( view->fIsComposited == false ); |
| check( view->fUpdateObserver != NULL ); |
| |
| CFRunLoopObserverInvalidate( view->fUpdateObserver ); |
| CFRelease( view->fUpdateObserver ); |
| view->fUpdateObserver = NULL; |
| |
| // printf( "Update observer removed\n" ); |
| } |
| |
| static void |
| UpdateObserver( CFRunLoopObserverRef observer, CFRunLoopActivity activity, void *info ) |
| { |
| HIWebView* view = (HIWebView*)info; |
| RgnHandle region = NewRgn(); |
| |
| // printf( "Update observer called\n" ); |
| |
| if ( region ) |
| { |
| GetWindowRegion( GetControlOwner( view->fViewRef ), kWindowUpdateRgn, region ); |
| |
| if ( !EmptyRgn( region ) ) |
| { |
| RgnHandle ourRgn = NewRgn(); |
| Rect rect; |
| |
| GetWindowBounds( GetControlOwner( view->fViewRef ), kWindowStructureRgn, &rect ); |
| |
| // printf( "Update region is non-empty\n" ); |
| |
| if ( ourRgn ) |
| { |
| Rect rect; |
| GrafPtr savePort, port; |
| Point offset = { 0, 0 }; |
| |
| port = GetWindowPort( GetControlOwner( view->fViewRef ) ); |
| |
| GetPort( &savePort ); |
| SetPort( port ); |
| |
| GlobalToLocal( &offset ); |
| OffsetRgn( region, offset.h, offset.v ); |
| |
| GetControlBounds( view->fViewRef, &rect ); |
| RectRgn( ourRgn, &rect ); |
| |
| // printf( "our control is at %d %d %d %d\n", |
| // rect.top, rect.left, rect.bottom, rect.right ); |
| |
| GetRegionBounds( region, &rect ); |
| // printf( "region is at %d %d %d %d\n", |
| // rect.top, rect.left, rect.bottom, rect.right ); |
| |
| SectRgn( ourRgn, region, ourRgn ); |
| |
| GetRegionBounds( ourRgn, &rect ); |
| // printf( "intersection is %d %d %d %d\n", |
| // rect.top, rect.left, rect.bottom, rect.right ); |
| if ( !EmptyRgn( ourRgn ) ) |
| { |
| RgnHandle saveVis = NewRgn(); |
| |
| // printf( "looks like we should draw\n" ); |
| |
| if ( saveVis ) |
| { |
| // RGBColor kRedColor = { 0xffff, 0, 0 }; |
| |
| GetPortVisibleRegion( GetWindowPort( GetControlOwner( view->fViewRef ) ), saveVis ); |
| SetPortVisibleRegion( GetWindowPort( GetControlOwner( view->fViewRef ) ), ourRgn ); |
| |
| // RGBForeColor( &kRedColor ); |
| // PaintRgn( ourRgn ); |
| // QDFlushPortBuffer( port, NULL ); |
| // Delay( 15, NULL ); |
| |
| Draw1Control( view->fViewRef ); |
| ValidWindowRgn( GetControlOwner( view->fViewRef ), ourRgn ); |
| |
| SetPortVisibleRegion( GetWindowPort( GetControlOwner( view->fViewRef ) ), saveVis ); |
| DisposeRgn( saveVis ); |
| } |
| } |
| |
| SetPort( savePort ); |
| |
| DisposeRgn( ourRgn ); |
| } |
| } |
| |
| DisposeRgn( region ); |
| } |
| } |
| |
| #endif |
