| /* |
| * Copyright (C) 2005-2017 Apple 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 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 "WebHTMLViewInternal.h" |
| #import "WebKit.h" |
| #import <pal/spi/mac/NSEventSPI.h> |
| #import <pal/spi/mac/NSGraphicsSPI.h> |
| #import <pal/spi/mac/QuickDrawSPI.h> |
| #import <wtf/Assertions.h> |
| #import <wtf/ObjcRuntimeExtras.h> |
| #import <wtf/cf/TypeCastsCF.h> |
| |
| WTF_DECLARE_CF_TYPE_TRAIT(CFRunLoop); |
| |
| @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 |
| |
| @interface NSWindowGraphicsContext (HIWebView) |
| - (void)_web_setGraphicsPort:(CGContextRef)context; |
| @end |
| |
| @implementation NSWindowGraphicsContext (HIWebView) |
| |
| - (void)_web_setGraphicsPort:(CGContextRef)context |
| { |
| CGContextRetain(context); |
| CGContextRelease(_cgsContext); |
| _cgsContext = context; |
| } |
| |
| @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 '; |
| |
| |
| static SEL _NSSelectorForHICommand(const 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*); |
| |
| 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*, const HIPoint* where); |
| static OSStatus GetRegion(HIWebView*, ControlPartCode inPart, RgnHandle outRgn); |
| static void BoundsChanged(HIWebView* inView, UInt32 inOptions, const HIRect* inOriginalBounds, const HIRect* inCurrentBounds); |
| static void OwningWindowChanged(HIWebView*, WindowRef oldWindow, WindowRef newWindow); |
| static void ActiveStateChanged(HIWebView*); |
| |
| 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*, ControlPartCode desiredFocus, RgnHandle invalidRgn, Boolean focusEverything, ControlPartCode* actualFocus); |
| static NSView* AdvanceFocus(HIWebView*, bool forward); |
| static void RelinquishFocus(HIWebView*, 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*); |
| static void StopUpdateObserver(HIWebView*); |
| |
| //---------------------------------------------------------------------------------- |
| // HIWebViewCreate |
| //---------------------------------------------------------------------------------- |
| // |
| OSStatus HIWebViewCreate(HIViewRef* outControl) |
| { |
| HIWebViewRegisterClass(); |
| return HIObjectCreate(kHIWebViewClassID, nullptr, (HIObjectRef*)outControl); |
| } |
| |
| //---------------------------------------------------------------------------------- |
| // HIWebViewGetWebView |
| //---------------------------------------------------------------------------------- |
| // |
| WebView* HIWebViewGetWebView(HIViewRef inView) |
| { |
| HIWebView* view = (HIWebView*)HIObjectDynamicCast((HIObjectRef)inView, kHIWebViewClassID); |
| WebView* result = nullptr; |
| |
| 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 = nullptr; |
| view->fKitWindow = nullptr; |
| view->fIsComposited = false; |
| view->fUpdateObserver = nullptr; |
| } |
| |
| 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, nullptr); |
| sRegistered = true; |
| } |
| } |
| |
| //---------------------------------------------------------------------------------- |
| // GetBehaviors |
| //---------------------------------------------------------------------------------- |
| // |
| static UInt32 GetBehaviors() |
| { |
| return kControlSupportsDataAccess | kControlSupportsGetRegion | kControlGetsFocusOnClick; |
| } |
| |
| static CGContextRef overrideCGContext(NSWindow *window, CGContextRef context) |
| { |
| #pragma clang diagnostic push |
| #pragma clang diagnostic ignored "-Wdeprecated-declarations" |
| NSWindowGraphicsContext *graphicsContext = (NSWindowGraphicsContext *)window.graphicsContext; |
| CGContextRef savedContext = (CGContextRef)graphicsContext.graphicsPort; |
| #pragma clang diagnostic pop |
| CGContextRetain(savedContext); |
| [graphicsContext _web_setGraphicsPort:context]; |
| return savedContext; |
| } |
| |
| static void restoreCGContext(NSWindow *window, CGContextRef savedContext) |
| { |
| #pragma clang diagnostic push |
| #pragma clang diagnostic ignored "-Wdeprecated-declarations" |
| NSWindowGraphicsContext *graphicsContext = (NSWindowGraphicsContext *)window.graphicsContext; |
| #pragma clang diagnostic pop |
| [graphicsContext _web_setGraphicsPort:savedContext]; |
| CGContextRelease(savedContext); |
| } |
| |
| //---------------------------------------------------------------------------------- |
| // 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; |
| |
| #pragma clang diagnostic push |
| #pragma clang diagnostic ignored "-Wdeprecated-declarations" |
| GetPort(&port); |
| GetPortBounds(port, &portRect); |
| CreateCGContextForPort(port, &inContext); |
| #pragma clang diagnostic push |
| SyncCGContextOriginWithPort(inContext, port); |
| CGContextTranslateCTM(inContext, 0, (portRect.bottom - portRect.top)); |
| CGContextScaleCTM(inContext, 1, -1); |
| createdContext = true; |
| } |
| |
| HIViewGetBounds(inView->fViewRef, &bounds); |
| |
| CGContextRef savedContext = overrideCGContext(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]; |
| |
| restoreCGContext(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, nullptr); |
| |
| 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, nullptr); |
| |
| 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; |
| return kControlNoPart; |
| } |
| |
| //---------------------------------------------------------------------------------- |
| // GetRegion |
| //---------------------------------------------------------------------------------- |
| // |
| static OSStatus GetRegion(HIWebView* inView, ControlPartCode inPart, RgnHandle outRgn) |
| { |
| OSStatus err = eventNotHandledErr; |
| |
| if (inPart == -3 && [inView->fWebView isOpaque]) { |
| // kControlOpaqueMetaPart: |
| 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); |
| } |
| |
| static NSEvent *CreateNSEventAdoptingCGEvent(CGEventRef cgEvent, EventRef eventRef) |
| { |
| NSEvent *result = [[NSEvent alloc] _initWithCGEvent:cgEvent eventRef:eventRef]; |
| CFRelease(cgEvent); |
| return result; |
| } |
| |
| static Boolean |
| CopyEventCGEvent(EventRef event, CGEventRef* cgEvent) |
| { |
| if ((*cgEvent = CopyEventCGEvent(event))) |
| return true; |
| |
| // This event might not have been created directly from a CGS event, and might not |
| // have a CGEventRef associated with it. In that case, try using the event most |
| // recently dispatched by the event dispatcher, which is likely to be the original |
| // user-input event containing a CGEventRef. |
| event = GetCurrentEvent(); |
| if (event && (*cgEvent = CopyEventCGEvent(event))) |
| return true; |
| return false; |
| } |
| |
| static NSEvent *CreateNSEventWithCarbonClickEvent(EventRef inEvent, WindowRef windowRef) |
| { |
| EventRef newEvent; |
| Point where; |
| OSStatus err; |
| UInt32 modifiers; |
| Rect windRect; |
| |
| CGEventRef cgEvent = nullptr; |
| if (!CopyEventCGEvent(inEvent, &cgEvent)) |
| return nil; |
| |
| // We need to make the event be a kEventMouseDown event, or the webkit might trip up when |
| // we click on a Netscape plugin. It calls ConvertEventRefToEventRecord, assuming |
| // that mouseDown was passed an event with a real mouse down eventRef. We just need a |
| // minimal one here. |
| |
| err = CreateEvent(nullptr, kEventClassMouse, kEventMouseDown, GetEventTime(inEvent), 0, &newEvent); |
| if (err != noErr) |
| return nil; |
| |
| GetEventParameter(inEvent, kEventParamWindowMouseLocation, typeQDPoint, nullptr, sizeof(Point), nullptr, &where); |
| GetWindowBounds(windowRef, kWindowStructureRgn, &windRect); |
| where.h += windRect.left; |
| where.v += windRect.top; |
| |
| GetEventParameter(inEvent, kEventParamKeyModifiers, typeUInt32, nullptr, sizeof(UInt32), nullptr, &modifiers); |
| SetEventParameter(newEvent, kEventParamMouseLocation, typeQDPoint, sizeof(Point), &where); |
| SetEventParameter(newEvent, kEventParamKeyModifiers, typeUInt32, sizeof(UInt32), &modifiers); |
| |
| return CreateNSEventAdoptingCGEvent(cgEvent, newEvent); |
| } |
| |
| //---------------------------------------------------------------------------------- |
| // Click |
| //---------------------------------------------------------------------------------- |
| // |
| static OSStatus Click(HIWebView* inView, EventRef inEvent) |
| { |
| NSEvent *kitEvent = CreateNSEventWithCarbonClickEvent(inEvent, GetWindowRef(inView)); |
| |
| if (!inView->fIsComposited) |
| StartUpdateObserver(inView); |
| |
| [inView->fKitWindow sendEvent:kitEvent]; |
| |
| if (!inView->fIsComposited) |
| StopUpdateObserver(inView); |
| |
| [kitEvent release]; |
| |
| return noErr; |
| } |
| |
| static NSEvent *CreateNSEventWithCarbonEvent(EventRef inEvent) |
| { |
| NSEvent *event = [NSEvent eventWithEventRef:inEvent]; |
| if (!event) |
| event = [NSEvent eventWithEventRef:GetCurrentEvent()]; |
| |
| return [event retain]; |
| } |
| |
| //---------------------------------------------------------------------------------- |
| // MouseUp |
| //---------------------------------------------------------------------------------- |
| // |
| static OSStatus MouseUp(HIWebView* inView, EventRef inEvent) |
| { |
| NSEvent* kitEvent = CreateNSEventWithCarbonEvent(inEvent); |
| |
| [inView->fKitWindow sendEvent:kitEvent]; |
| |
| [kitEvent release]; |
| |
| return noErr; |
| } |
| |
| static NSEvent *CreateNSEventWithCarbonMouseMoveEvent(EventRef inEvent, NSWindow *window) |
| { |
| NSEvent* kitEvent = [NSEvent eventWithEventRef:inEvent]; |
| |
| // FIXME: Works around bug 3585644. Can remove it once that bug is fixed. |
| // We preflight here and don't do any work when the window is already correct |
| // because _eventRelativeToWindow will malfunction if the event's window method |
| // has been hijacked by the bug workaround used by Contribute. It's fine to just |
| // leave the event alone if the window is already correct. |
| |
| if ([kitEvent window] != window) |
| kitEvent = [kitEvent _eventRelativeToWindow:window]; |
| |
| return [kitEvent retain]; |
| } |
| |
| //---------------------------------------------------------------------------------- |
| // MouseMoved |
| //---------------------------------------------------------------------------------- |
| // |
| static OSStatus MouseMoved(HIWebView* inView, EventRef inEvent) |
| { |
| NSEvent *kitEvent = CreateNSEventWithCarbonMouseMoveEvent(inEvent, inView->fKitWindow); |
| [inView->fKitWindow sendEvent:kitEvent]; |
| [kitEvent release]; |
| |
| return noErr; |
| } |
| |
| //---------------------------------------------------------------------------------- |
| // MouseDragged |
| //---------------------------------------------------------------------------------- |
| // |
| static OSStatus MouseDragged(HIWebView* inView, EventRef inEvent) |
| { |
| NSEvent* kitEvent = CreateNSEventWithCarbonEvent(inEvent); |
| |
| [inView->fKitWindow sendEvent:kitEvent]; |
| |
| [kitEvent release]; |
| |
| return noErr; |
| } |
| |
| //---------------------------------------------------------------------------------- |
| // MouseDragged |
| //---------------------------------------------------------------------------------- |
| // |
| static OSStatus MouseWheelMoved(HIWebView* inView, EventRef inEvent) |
| { |
| NSEvent* kitEvent = CreateNSEventWithCarbonEvent(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, nullptr, sizeof(point), nullptr, &point); |
| HIViewConvertPoint(&point, inView->fViewRef, nullptr); |
| |
| // 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:NSEventTypeRightMouseDown |
| 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 *), nullptr, &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, nullptr); |
| } |
| |
| [[view->fKitWindow contentView] addSubview:view->fWebView]; |
| |
| GetWindowAttributes(newWindow, &attrs); |
| view->fIsComposited = attrs & kWindowCompositingAttribute; |
| |
| SyncFrame(view); |
| } else { |
| // Be sure to detach the cocoa view, too. |
| if (view->fWebView) |
| [view->fWebView removeFromSuperview]; |
| |
| view->fKitWindow = nullptr; // 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; |
| |
| NSWindow* kitWindow; |
| OSStatus err = noErr; |
| NSEvent* kitEvent; |
| |
| switch (GetEventClass(inEvent)) { |
| case kEventClassControl: |
| switch (GetEventKind(inEvent)) { |
| case kEventControlClick: |
| CarbonWindowAdapter *kitWindow; |
| |
| err = GetWindowProperty(window, NSAppKitPropertyCreator, NSCarbonWindowPropertyTag, sizeof(NSWindow *), nullptr, &kitWindow); |
| |
| // We must be outside the HIWebView, relinquish focus. |
| [kitWindow relinquishFocus]; |
| break; |
| } |
| break; |
| |
| case kEventClassKeyboard: |
| // 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 *), nullptr, &kitWindow); |
| if (err == noErr) { |
| NSResponder* responder = [kitWindow firstResponder]; |
| if (responder != kitWindow) { |
| kitEvent = CreateNSEventWithCarbonEvent(inEvent); |
| |
| [kitWindow sendEvent:kitEvent]; |
| [kitEvent release]; |
| |
| result = noErr; |
| } |
| } |
| break; |
| |
| case kEventClassWindow: |
| |
| |
| err = GetWindowProperty(window, NSAppKitPropertyCreator, NSCarbonWindowPropertyTag, sizeof(NSWindow *), nullptr, &kitWindow); |
| if (err == noErr) { |
| [kitWindow _removeWindowRef]; |
| [kitWindow close]; |
| } |
| result = noErr; |
| break; |
| |
| case kEventClassMouse: |
| switch (GetEventKind(inEvent)) { |
| case kEventMouseMoved: |
| Point where; |
| GetEventParameter(inEvent, kEventParamMouseLocation, typeQDPoint, nullptr, sizeof(Point), nullptr, &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); |
| |
| HIViewRef view = nullptr; |
| |
| 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: |
| HIViewRef view = nullptr; |
| |
| 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) |
| ASSERT_NOT_REACHED(); |
| 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 nullptr; |
| |
| 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; |
| ASSERT([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; |
| } |
| 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; |
| ASSERT(oldFirstResponder == view->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. |
| ASSERT([(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. |
| |
| ASSERT(firstResponder == view->fKitWindow); |
| } |
| } |
| |
| //---------------------------------------------------------------------------------- |
| // 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 = nullptr; |
| NSResponder* resp; |
| |
| resp = [inView->fKitWindow firstResponder]; |
| |
| if ([resp isKindOfClass:[NSView class]]) { |
| NSView* respView = (NSView*)resp; |
| |
| if ((respView == inView->fWebView || [respView isDescendantOf: inView->fWebView]) && inCommand->attributes & kHICommandFromMenu) { |
| SEL selector = _NSSelectorForHICommand(inCommand); |
| |
| if (selector && [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. |
| if (wtfObjcMsgSend<BOOL>(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 nullptr; |
| } |
| |
| return nullptr; |
| } |
| |
| |
| //----------------------------------------------------------------------------------- |
| // 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 = nullptr; |
| 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, nullptr, sizeof(HIObjectRef), nullptr, &object); |
| ASSERT(!result); |
| if (result) |
| return result; |
| |
| // 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 = CreateNSEventWithCarbonEvent(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, nullptr, sizeof(HICommand), nullptr, &command); |
| ASSERT(!result); |
| if (result) |
| return result; |
| |
| 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 = nullptr; |
| |
| GetEventParameter(inEvent, kEventParamRgnHandle, typeQDRgnHandle, nullptr, sizeof(RgnHandle), nullptr, ®ion); |
| GetEventParameter(inEvent, kEventParamCGContextRef, typeCGContextRef, nullptr, sizeof(CGContextRef), nullptr, &context); |
| |
| Draw(view, region, context); |
| result = noErr; |
| break; |
| } |
| |
| case kEventControlHitTest: |
| GetEventParameter(inEvent, kEventParamMouseLocation, typeHIPoint, nullptr, sizeof(HIPoint), nullptr, &where); |
| part = HitTest(view, &where); |
| SetEventParameter(inEvent, kEventParamControlPart, typeControlPartCode, sizeof(ControlPartCode), &part); |
| result = noErr; |
| break; |
| |
| case kEventControlGetPartRegion: |
| GetEventParameter(inEvent, kEventParamControlPart, typeControlPartCode, nullptr, sizeof(ControlPartCode), nullptr, &part); |
| GetEventParameter(inEvent, kEventParamControlRegion, typeQDRgnHandle, nullptr, sizeof(RgnHandle), nullptr, ®ion); |
| result = GetRegion(view, part, region); |
| break; |
| |
| case kEventControlGetData: { |
| GetEventParameter(inEvent, kEventParamControlPart, typeControlPartCode, nullptr, sizeof(ControlPartCode), nullptr, &part); |
| GetEventParameter(inEvent, kEventParamControlDataTag, typeEnumeration, nullptr, sizeof(OSType), nullptr, &tag); |
| GetEventParameter(inEvent, kEventParamControlDataBuffer, typePtr, nullptr, sizeof(Ptr), nullptr, &ptr); |
| GetEventParameter(inEvent, kEventParamControlDataBufferSize, typeByteCount, nullptr, sizeof(Size), nullptr, &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, nullptr, sizeof(UInt32), nullptr, &attrs); |
| GetEventParameter(inEvent, kEventParamOriginalBounds, typeHIRect, nullptr, sizeof(HIRect), nullptr, &prevRect); |
| GetEventParameter(inEvent, kEventParamCurrentBounds, typeHIRect, nullptr, sizeof(HIRect), nullptr, &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, nullptr, sizeof(WindowRef), nullptr, &fromWindow); |
| ASSERT(!result); |
| if (result) |
| return result; |
| |
| result = GetEventParameter(inEvent, kEventParamControlCurrentOwningWindow, typeWindowRef, nullptr, sizeof(WindowRef), nullptr, &toWindow); |
| ASSERT(!result); |
| if (result) |
| return result; |
| |
| 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, nullptr, sizeof(ControlPartCode), nullptr, &desiredFocus); |
| ASSERT(!result); |
| if (result) |
| return result; |
| |
| GetEventParameter(inEvent, kEventParamControlInvalRgn, typeQDRgnHandle, nullptr, sizeof(RgnHandle), nullptr, &invalidRgn); |
| focusEverything = false; // a good default in case the parameter doesn't exist |
| GetEventParameter(inEvent, kEventParamControlFocusEverything, typeBoolean, nullptr, sizeof(Boolean), nullptr, &focusEverything); |
| |
| result = SetFocusPart(view, desiredFocus, invalidRgn, focusEverything, &actualFocus); |
| if (result == noErr) |
| ASSERT(!SetEventParameter(inEvent, kEventParamControlPart, typeControlPartCode, sizeof(ControlPartCode), &actualFocus)); |
| break; |
| } |
| |
| // some other kind of Control event |
| default: |
| break; |
| } |
| break; |
| |
| // some other event class |
| default: |
| break; |
| } |
| return result; |
| } |
| |
| |
| static void UpdateObserver(CFRunLoopObserverRef observer, CFRunLoopActivity activity, void *info); |
| |
| static void StartUpdateObserver(HIWebView* view) |
| { |
| CFRunLoopObserverContext context; |
| CFRunLoopObserverRef observer; |
| CFRunLoopRef mainRunLoop; |
| |
| ASSERT(!view->fIsComposited); |
| ASSERT(!view->fUpdateObserver); |
| |
| context.version = 0; |
| context.info = view; |
| context.retain = nullptr; |
| context.release = nullptr; |
| context.copyDescription = nullptr; |
| |
| mainRunLoop = checked_cf_cast<CFRunLoopRef>(GetCFRunLoopFromEventLoop(GetMainEventLoop())); |
| observer = CFRunLoopObserverCreate(nullptr, kCFRunLoopEntry | kCFRunLoopBeforeWaiting, true, 0, UpdateObserver, &context); |
| CFRunLoopAddObserver(mainRunLoop, observer, kCFRunLoopCommonModes); |
| |
| view->fUpdateObserver = observer; |
| |
| // printf("Update observer started\n"); |
| } |
| |
| static void StopUpdateObserver(HIWebView* view) |
| { |
| ASSERT(!view->fIsComposited); |
| ASSERT(view->fUpdateObserver); |
| |
| CFRunLoopObserverInvalidate(view->fUpdateObserver); |
| CFRelease(view->fUpdateObserver); |
| view->fUpdateObserver = nullptr; |
| |
| // 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, nullptr); |
| // Delay(15, nullptr); |
| Draw1Control(view->fViewRef); |
| ValidWindowRgn(GetControlOwner(view->fViewRef), ourRgn); |
| |
| SetPortVisibleRegion(GetWindowPort(GetControlOwner(view->fViewRef)), saveVis); |
| DisposeRgn(saveVis); |
| } |
| } |
| |
| SetPort(savePort); |
| |
| DisposeRgn(ourRgn); |
| } |
| } |
| |
| DisposeRgn(region); |
| } |
| } |
| |
| #endif |
