[SCM] WebKit Debian packaging branch, debian/unstable, updated. debian/1.1.15-1-40151-g37bb677
voas
voas at 268f45cc-cd09-0410-ab3c-d52691b4dbfc
Sat Sep 26 07:27:42 UTC 2009
The following commit has been merged in the debian/unstable branch:
commit 0840e2d64ee064984dbf87dc80d1dae9f6e245a6
Author: voas <voas at 268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Date: Thu Mar 6 21:40:55 2003 +0000
2003-03-06 Ed Voas voas at apple.com
Reviewed by Richard.
First cut of Carbon view support. It will need tweaking as we go,
but I think I finally have all the assertions taken care of, and
I also believe that I have the drawing glitches all sorted out now.
* Carbon.subproj/CarbonUtils.h: Added.
* Carbon.subproj/CarbonUtils.m: Added.
(InitWebKitForCarbon):
(PoolCleaner):
(ConvertNSImageToCGImageRef):
* Carbon.subproj/CarbonWindowAdapter.h: Added.
* Carbon.subproj/CarbonWindowAdapter.m: Added.
(+[CarbonWindowAdapter frameViewClassForStyleMask:]):
(-[CarbonWindowAdapter initWithContentRect:styleMask:backing:defer:]):
(-[CarbonWindowAdapter initWithCarbonWindowRef:takingOwnership:disableOrdering:carbon:]):
(-[CarbonWindowAdapter setViewsNeedDisplay:]):
(-[CarbonWindowAdapter initWithCarbonWindowRef:takingOwnership:]):
(-[CarbonWindowAdapter dealloc]):
(-[CarbonWindowAdapter windowRef]):
(-[CarbonWindowAdapter _hasWindowRef]):
(-[CarbonWindowAdapter _managesWindowRef]):
(-[CarbonWindowAdapter _removeWindowRef]):
(-[CarbonWindowAdapter _carbonWindowClass]):
(-[CarbonWindowAdapter reconcileToCarbonWindowBounds]):
(-[CarbonWindowAdapter sendSuperEvent:]):
(-[CarbonWindowAdapter _cancelKey:]):
(-[CarbonWindowAdapter _commonAwake]):
(-[CarbonWindowAdapter _destroyRealWindow:]):
(-[CarbonWindowAdapter _oldPlaceWindow:]):
(-[CarbonWindowAdapter _termWindowIfOwner]):
(-[CarbonWindowAdapter _windowMovedToRect:]):
(-[CarbonWindowAdapter constrainFrameRect:toScreen:]):
(-[CarbonWindowAdapter selectKeyViewFollowingView:]):
(-[CarbonWindowAdapter selectKeyViewPrecedingView:]):
(-[CarbonWindowAdapter makeKeyWindow]):
(-[CarbonWindowAdapter canBecomeKeyWindow]):
(-[CarbonWindowAdapter canBecomeMainWindow]):
(-[CarbonWindowAdapter encodeWithCoder:]):
(-[CarbonWindowAdapter initWithCoder:]):
(-[CarbonWindowAdapter setContentView:]):
(-[CarbonWindowAdapter worksWhenModal]):
(-[CarbonWindowAdapter _setModalWindowLevel]):
(-[CarbonWindowAdapter _clearModalWindowLevel]):
(-[CarbonWindowAdapter carbonHICommandIDFromActionSelector:]):
(-[CarbonWindowAdapter sendCarbonProcessHICommandEvent:]):
(-[CarbonWindowAdapter sendCarbonUpdateHICommandStatusEvent:withMenuRef:andMenuItemIndex:]):
(-[CarbonWindowAdapter _handleRootBoundsChanged]):
(-[CarbonWindowAdapter _handleContentBoundsChanged]):
(-[CarbonWindowAdapter _handleCarbonEvent:callRef:]):
(NSCarbonWindowHandleEvent):
* Carbon.subproj/CarbonWindowContentView.h: Added.
* Carbon.subproj/CarbonWindowContentView.m: Added.
* Carbon.subproj/CarbonWindowFrame.h: Added.
* Carbon.subproj/CarbonWindowFrame.m: Added.
(+[CarbonWindowFrame frameRectForContentRect:styleMask:]):
(+[CarbonWindowFrame contentRectForFrameRect:styleMask:]):
(+[CarbonWindowFrame minFrameSizeForMinContentSize:styleMask:]):
(-[CarbonWindowFrame frameRectForContentRect:styleMask:]):
(-[CarbonWindowFrame contentRectForFrameRect:styleMask:]):
(-[CarbonWindowFrame minFrameSizeForMinContentSize:styleMask:]):
(-[CarbonWindowFrame initWithFrame:styleMask:owner:]):
(-[CarbonWindowFrame dealloc]):
(-[CarbonWindowFrame _setFrameNeedsDisplay:]):
(-[CarbonWindowFrame _setSheet:]):
(-[CarbonWindowFrame _updateButtonState]):
(-[CarbonWindowFrame _windowChangedKeyState]):
(-[CarbonWindowFrame _showToolbarWithAnimation:]):
(-[CarbonWindowFrame _hideToolbarWithAnimation:]):
(-[CarbonWindowFrame closeButton]):
(-[CarbonWindowFrame styleMask]):
(-[CarbonWindowFrame dragRectForFrameRect:]):
(-[CarbonWindowFrame isOpaque]):
(-[CarbonWindowFrame minimizeButton]):
(-[CarbonWindowFrame setTitle:]):
(-[CarbonWindowFrame title]):
(-[CarbonWindowFrame _sheetHeightAdjustment]):
(-[CarbonWindowFrame _maxTitlebarTitleRect]):
(-[CarbonWindowFrame _clearDragMargins]):
(-[CarbonWindowFrame _resetDragMargins]):
* Carbon.subproj/HIViewAdapter.h: Added.
* Carbon.subproj/HIViewAdapter.m: Added.
(+[HIViewAdapter bindHIViewToNSView:nsView:]):
(+[HIViewAdapter getHIViewForNSView:]):
(+[HIViewAdapter unbindNSView:]):
(-[HIViewAdapter initWithFrame:view:]):
(-[HIViewAdapter hiView]):
(-[HIViewAdapter nextValidKeyView]):
(-[HIViewAdapter setNeedsDisplay:]):
(-[HIViewAdapter setNeedsDisplayInRect:]):
(-[CarbonSheetInterceptor _orderFrontRelativeToWindow:]):
(-[CarbonSheetInterceptor _orderOutRelativeToWindow:]):
* Carbon.subproj/HIWebView.h: Added.
* Carbon.subproj/HIWebView.m: Added.
(if):
(switch):
* Carbon.subproj/HIWebViewPriv.h: Added.
* WebKit.exp:
* WebKit.pbproj/project.pbxproj:
git-svn-id: http://svn.webkit.org/repository/webkit/trunk@3764 268f45cc-cd09-0410-ab3c-d52691b4dbfc
diff --git a/WebKit/Carbon.subproj/CarbonUtils.h b/WebKit/Carbon.subproj/CarbonUtils.h
new file mode 100644
index 0000000..e171cbd
--- /dev/null
+++ b/WebKit/Carbon.subproj/CarbonUtils.h
@@ -0,0 +1,26 @@
+/*
+ * CarbonUtils.h
+ * WebKit
+ *
+ * Created by Ed Voas on Mon Feb 17 2003.
+ * Copyright (c) 2003 __MyCompanyName__. All rights reserved.
+ *
+ */
+#ifndef __HIWEBCARBONUTILS__
+#define __HIWEBCARBONUTILS__
+
+#import <Carbon/Carbon.h>
+#import <WebKit/WebKit.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void InitWebKitForCarbon( void );
+extern CGImageRef ConvertNSImageToCGImageRef( NSImage* inImage );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // __HIWEBCARBONUTILS__
\ No newline at end of file
diff --git a/WebKit/Carbon.subproj/CarbonUtils.m b/WebKit/Carbon.subproj/CarbonUtils.m
new file mode 100644
index 0000000..77bb3d8
--- /dev/null
+++ b/WebKit/Carbon.subproj/CarbonUtils.m
@@ -0,0 +1,79 @@
+/*
+ * CarbonUtils.c
+ * WebKit
+ *
+ * Created by Ed Voas on Mon Feb 17 2003.
+ * Copyright (c) 2003 __MyCompanyName__. All rights reserved.
+ *
+ */
+
+#include "CarbonUtils.h"
+
+extern CGImageRef _NSCreateImageRef( unsigned char *const bitmapData[5], int pixelsWide, int pixelsHigh, int bitsPerSample, int samplesPerPixel, int bitsPerPixel, int bytesPerRow, BOOL isPlanar, BOOL hasAlpha, NSString *colorSpaceName, CGColorSpaceRef customColorSpace, id sourceObj);
+
+static void PoolCleaner( EventLoopTimerRef inTimer, EventLoopIdleTimerMessage inState, void *inUserData );
+
+static NSAutoreleasePool* sPool;
+
+void
+InitWebKitForCarbon()
+{
+ static bool sAppKitLoaded;
+
+ if ( !sAppKitLoaded )
+ {
+ NSApplicationLoad();
+
+ sPool = [[NSAutoreleasePool allocWithZone:NULL] init];
+
+ InstallEventLoopIdleTimer( GetMainEventLoop(), 1.0, 0, PoolCleaner, 0, NULL );
+
+ sAppKitLoaded = true;
+ }
+}
+
+static void
+PoolCleaner( EventLoopTimerRef inTimer, EventLoopIdleTimerMessage inState, void *inUserData )
+{
+ if ( inState == kEventLoopIdleTimerStarted )
+ {
+ [sPool release];
+ sPool = [[NSAutoreleasePool allocWithZone:NULL] init];
+ }
+}
+
+CGImageRef
+ConvertNSImageToCGImageRef(
+ NSImage* inImage )
+{
+ NSArray* reps = [inImage representations];
+ NSBitmapImageRep* rep = NULL;
+ CGImageRef image = NULL;
+ unsigned i;
+
+ for ( i=0; i < [reps count]; i++ )
+ {
+ if ( [[reps objectAtIndex:i] isKindOfClass:[NSBitmapImageRep class]] )
+ {
+ rep = [reps objectAtIndex:i];
+ break;
+ }
+ }
+
+ if ( rep )
+ {
+ //CGColorSpaceRef csync = (CGColorSpaceRef)[rep valueForProperty:NSImageColorSyncProfileData];
+
+ unsigned char* planes[5];
+
+ [rep getBitmapDataPlanes:planes];
+
+ image = _NSCreateImageRef( planes, [rep pixelsWide], [rep pixelsHigh],
+ [rep bitsPerSample], [rep samplesPerPixel], [rep bitsPerPixel],
+ [rep bytesPerRow], [rep isPlanar], [rep hasAlpha], [rep colorSpaceName],
+ NULL, rep);
+ }
+
+ return image;
+}
+
diff --git a/WebKit/Carbon.subproj/CarbonWindowAdapter.h b/WebKit/Carbon.subproj/CarbonWindowAdapter.h
new file mode 100644
index 0000000..951a31c
--- /dev/null
+++ b/WebKit/Carbon.subproj/CarbonWindowAdapter.h
@@ -0,0 +1,46 @@
+//
+// NSCarbonWindowAdapter.h
+// Synergy
+//
+// Created by Ed Voas on Fri Jan 17 2003.
+// Copyright (c) 2003 __MyCompanyName__. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import <AppKit/AppKit.h>
+#import <HIToolbox/CarbonEvents.h>
+#import <HIToolbox/MacWindows.h>
+
+ at interface CarbonWindowAdapter : NSWindow {
+
+ @private
+
+ // The Carbon window that's being encapsulated, and whether or not this object owns (has responsibility for disposing) it.
+ WindowRef _windowRef;
+ BOOL _windowRefIsOwned;
+ BOOL _carbon;
+
+ // The UPP for the event handler that we use to deal with various Carbon events, and the event handler itself.
+ EventHandlerUPP _handleEventUPP;
+ EventHandlerRef _eventHandler;
+
+ // Yes if this object should let Carbon handle kEventWindowActivated and kEventWindowDeactivated events. No otherwise.
+ BOOL _passingCarbonWindowActivationEvents;
+
+}
+
+// Initializers.
+- (id)initWithCarbonWindowRef:(WindowRef)inWindowRef takingOwnership:(BOOL)inWindowRefIsOwned;
+- (id)initWithCarbonWindowRef:(WindowRef)inWindowRef takingOwnership:(BOOL)inWindowRefIsOwned disableOrdering:(BOOL)inDisableOrdering carbon:(BOOL)inCarbon;
+
+// Accessors.
+- (WindowRef)windowRef;
+
+// Update this window's frame and content rectangles to match the Carbon window's structure and content bounds rectangles. Return yes if the update was really necessary, no otherwise.
+- (BOOL)reconcileToCarbonWindowBounds;
+
+// Handle an event just like an NSWindow would.
+- (void)sendSuperEvent:(NSEvent *)inEvent;
+
+
+ at end
diff --git a/WebKit/Carbon.subproj/CarbonWindowAdapter.m b/WebKit/Carbon.subproj/CarbonWindowAdapter.m
new file mode 100644
index 0000000..f8d252b
--- /dev/null
+++ b/WebKit/Carbon.subproj/CarbonWindowAdapter.m
@@ -0,0 +1,997 @@
+//
+// CarbonWindowAdapter.m
+// Synergy
+//
+// Created by Ed Voas on Fri Jan 17 2003.
+// Copyright (c) 2003 __MyCompanyName__. All rights reserved.
+//
+
+/*
+ NSCarbonWindow.m
+ Application Kit
+ Copyright (c) 2000-2002, Apple Computer, Inc.
+ All rights reserved.
+ Original Author: Mark Piccirelli
+ Responsibility: Mark Piccirelli
+
+The subclass of NSWindow that encapsulates a Carbon window, in such a manner that the encapsulated Carbon window can at least be shown as a app-modal dialog or document-modal sheet by the AppKit sheet-showing machinery.
+*/
+
+
+// Things that I've never bothered working out:
+// For non-sheet windows, handle Carbon WindowMove events so as to do the same things as -[NSWindow _windowMoved].
+// Check to see how this stuff deals with various screen size change scenarious.
+// M.P. Warning - 9/17/01
+
+// Create an NSWindow(Private) to declare the private NSWindow methods we call from here, to do away with compiler warnings. 2776110. M.P. To Do - 9/17/00
+
+// There are some invariants I'm maintaining for objects of this class which have been successfully initialized but not deallocated. These all make it easier to not override every single method of NSWindow.
+// _auxiliaryStorage->auxWFlags.hasShadow will always be false if the Carbon window has a kWindowNoShadowAttribute, and vice versa.
+// _auxiliaryStorage->_auxWFlags.minimized will always reflect the window's Carbon collapsed state.
+// _borderView will always point to an NSCarbonWindowFrame.
+// _contentView will always point to an NSCarbonWindowContentView;
+// _frame will always reflect the window's Carbon kWindowStructureRgn bounds.
+// _styleMask will always have _NSCarbonWindowMask set, and will have NSClosableWindowMask, NSMiniaturizableWindowMask, NSResizableWindowMask, and/or NSTitledWindowMask set as appropriate.
+// _wflags.oneShot and _wflags.delayedOneShot will always be false.
+// _wFlags.visible will always reflect the window's Carbon visibility.
+// _windowNum will always be greater than zero, and valid.
+// The instance variables involved are ones that came to my attention during the initial writing of this class; I haven't methodically gone through NSWindow's ivar list or anything like that. M.P. Notice - 10/10/00
+
+// Things that have to be worked on if NSCarbonWindows are ever used for something other than dialogs and sheets:
+// Clicking on an NSCarbonWindow while a Cocoa app-modal dialog is shown does not beep, as it should [old bug, maybe fixed now].
+// Handling of mouse clicks or key presses for any window control (close, miniaturize, zoom) might not be all there.
+// Handling of miniaturization of Carbon windows via title bar double-click might not be all there.
+// The background on NSCarbonWindowTester's sample window (not sample dialog or sample sheet) might be wrong.
+// The controls on NSCarbonWindowTester's sample window look inactive when the window is inactive, but have first-click behavior.
+// M.P. Warning - 12/14/00
+
+// Some things would have to be made public if someone wanted to subclass this so as to support more menu item commands. M.P. Warning - 9/19/00
+
+
+#import "CarbonWindowAdapter.h"
+#import "CarbonWindowFrame.h"
+#import "CarbonWindowContentView.h"
+#import "HIViewAdapter.h"
+
+#import <AppKit/AppKit.h>
+#import <CoreGraphics/CGSWindow.h>
+#import <HIToolbox/CarbonEvents.h>
+#import <HIToolbox/CarbonEventsPriv.h>
+#import <HIToolbox/Controls.h>
+#import <HIToolbox/ControlsPriv.h>
+#import <HIToolbox/WindowsPriv.h>
+#import <HIToolbox/HIView.h>
+#import <assert.h>
+
+// Turn off the assertions in this file.
+// If this is commented out, uncomment it before committing to CVS. M.P. Warning - 10/18/01
+#undef assert
+#define assert(X)
+
+enum
+{
+ _NSCarbonWindowMask = 1 << 25
+};
+
+// Carbon SPI functions.
+// The fact that these are declared here instead of in an HIToolbox header is a bad thing. 2776459. M.P. To Do - 9/18/01
+OSStatus _SetWindowCGOrderingEnabled(WindowRef inWindow, Boolean inEnableWindow);
+OSStatus _SyncWindowWithCGAfterMove(WindowRef inWindow);
+OSStatus SyncWindowToCGSWindow(WindowRef inWindow, CGSWindowID inWindowID);
+
+// Copied-and-pasted AppKit miscellany.
+#define WINDOWSMENUWINDOW(w) (!_wFlags.excludedFromWindowsMenu && \
+ [w _miniaturizedOrCanBecomeMain] && [w _isDocWindow])
+extern float _NXScreenMaxYForRect(NSRect *rect);
+extern MenuRef _NSGetCarbonMenu(NSMenu* menu);
+extern int _NSMenuToCarbonIndex(NSMenu* menu, int index);
+extern void _NXOrderKeyAndMain( void );
+extern void _NXShowKeyAndMain( void );
+
+// Forward declarations.
+static OSStatus NSCarbonWindowHandleEvent(EventHandlerCallRef inEventHandlerCallRef, EventRef inEventRef, void *inUserData);
+
+
+// Constants that we use to fiddle with NSViewCarbonControls.
+extern const ControlFocusPart NSViewCarbonControlMagicPartCode;
+extern const OSType NSAppKitPropertyCreator;
+extern const OSType NSViewCarbonControlViewPropertyTag;
+extern const OSType NSCarbonWindowPropertyTag;
+
+ at interface NSWindow(HIWebView)
+- _initContent:(const NSRect *)contentRect styleMask:(unsigned int)aStyle backing:(NSBackingStoreType)bufferingType defer:(BOOL)flag contentView:aView;
+- (void)_oldPlaceWindow:(NSRect)frameRect;
+- (void)_windowMovedToRect:(NSRect)actualFrame;
+- (void)_setWindowNumber:(int)nativeWindow;
+- (NSGraphicsContext *)_threadContext;
+- (void)_setFrame:(NSRect)newWindowFrameRect;
+- (void)_setVisible:(BOOL)flag;
+ at end
+
+ at interface NSApplication(HIWebView)
+- (void)setIsActive:(BOOL)aFlag;
+- (id)_setMouseActivationInProgress:(BOOL)flag;
+ at end
+
+ at implementation CarbonWindowAdapter
+
+
+// Return an appropriate window frame class.
++ (Class)frameViewClassForStyleMask:(unsigned int)style {
+
+ // There's only one appropriate window style, and only one appropriate window frame class.
+ assert(style & _NSCarbonWindowMask);
+ return [CarbonWindowFrame class];
+
+}
+
+
+// Overriding of the parent class' designated initializer, just for safety's sake.
+- (id)initWithContentRect:(NSRect)contentRect styleMask:(unsigned int)style backing:(NSBackingStoreType)bufferingType defer:(BOOL)flag {
+
+ // Do the standard Cocoa thing.
+ self = [super initWithContentRect:contentRect styleMask:style backing:bufferingType defer:flag];
+ if (self==nil) return nil;
+
+ // Simple.
+ _windowRef = NULL;
+ _windowRefIsOwned = NO;
+ _eventHandler = NULL;
+
+ // Done.
+ return self;
+
+}
+
+// Given a reference to a Carbon window that is to be encapsulated, an indicator of whether or not this object should take responsibility for disposing of the Carbon window, and an indicator of whether to disable Carbon window ordering, initialize. This is the class' designated initializer.
+- (id)initWithCarbonWindowRef:(WindowRef)inWindowRef takingOwnership:(BOOL)inWindowRefIsOwned disableOrdering:(BOOL)inDisableOrdering carbon:(BOOL)inCarbon {
+
+ NSBackingStoreType backingStoreType;
+ CarbonWindowContentView *carbonWindowContentView;
+ NSWindow *windowAsProperty;
+ OSStatus osStatus;
+ UInt32 windowFeatures;
+ WindowAttributes windowAttributes;
+ unsigned int styleMask;
+ void *nativeWindow;
+ WindowModality windowModality;
+ ControlRef contentView;
+
+ // Simple.
+ // It's very weak to have to put this before the invocation of [super initWithContentRect:...], but -setContentView: is invoked from within that initializer. It turns out that the common admonition about not calling virtual functions from within C++ constructors makes sense in Objective-C too. M.P. Notice - 10/10/00
+ _windowRef = inWindowRef;
+ //_auxiliaryStorage->_windowRef = inWindowRef;
+ _windowRefIsOwned = inWindowRefIsOwned;
+ _carbon = inCarbon;
+
+ // Find out the window's CoreGraphics window reference.
+ nativeWindow = GetNativeWindowFromWindowRef(inWindowRef);
+
+ // Find out the window's Carbon window attributes.
+ osStatus = GetWindowAttributes(inWindowRef, &windowAttributes);
+ if (osStatus!=noErr) NSLog(@"A Carbon window's attributes couldn't be gotten.");
+
+ // Find out the window's Carbon window features.
+ osStatus = GetWindowFeatures(inWindowRef, &windowFeatures);
+ if (osStatus!=noErr) NSLog(@"A Carbon window's features couldn't be gotten.");
+
+ // Figure out the window's backing store type.
+ // This switch statement is inspired by one in HIToolbox/Windows/Platform/CGSPlatform.c's CreatePlatformWindow(). M.P. Notice - 8/2/00
+ switch (windowAttributes & (kWindowNoBufferingAttribute | kWindowRetainedAttribute)) {
+ case kWindowNoAttributes:
+ backingStoreType = NSBackingStoreBuffered;
+ break;
+ case kWindowRetainedAttribute:
+ backingStoreType = NSBackingStoreRetained;
+ break;
+ case kWindowNoBufferingAttribute:
+ default:
+ backingStoreType = NSBackingStoreNonretained;
+ break;
+ }
+
+ // Figure out the window's style mask.
+ styleMask = _NSCarbonWindowMask;
+ if (windowAttributes & kWindowCloseBoxAttribute) styleMask |= NSClosableWindowMask;
+ if (windowAttributes & kWindowResizableAttribute) styleMask |= NSResizableWindowMask;
+ if (windowFeatures & kWindowCanCollapse) styleMask |= NSMiniaturizableWindowMask;
+ if (windowFeatures & kWindowHasTitleBar) styleMask |= NSTitledWindowMask;
+
+ osStatus = GetWindowModality(_windowRef, &windowModality, NULL);
+ if (osStatus != noErr) {
+ NSLog(@"Couldn't get window modality: error=%d", osStatus);
+ return nil;
+ }
+
+ if (windowModality == kWindowModalityNone || windowModality == kWindowModalityWindowModal) {
+ if (inDisableOrdering) {
+ // Take over the ordering of the window from Carbon.
+ osStatus = _SetWindowCGOrderingEnabled(inWindowRef, FALSE);
+ if (osStatus!=noErr) NSLog(@"A Carbon window's ordering couldn't be disabled.");
+ }
+ }
+
+ // Create one of our special content views.
+ carbonWindowContentView = [[[CarbonWindowContentView alloc] init] autorelease];
+
+ // Do some standard Cocoa initialization. The defer argument's value is YES because we don't want -[NSWindow _commonAwake] to get called. It doesn't appear that any relevant NSWindow code checks _wFlags.deferred, so we should be able to get away with the lie.
+ self = (CarbonWindowAdapter*)[super _initContent:NULL styleMask:styleMask backing:backingStoreType defer:YES contentView:carbonWindowContentView];
+ if (!self) return nil;
+ assert(_contentView);
+
+ // Record accurately whether or not this window has a shadow, in case someone asks.
+ // _auxiliaryStorage->_auxWFlags.hasShadow = (windowAttributes & kWindowNoShadowAttribute) ? NO : YES;
+
+ // Record the window number.
+ [self _setWindowNumber:(int)nativeWindow];
+
+ // Set up from the frame rectangle.
+ // We didn't even really try to get it right at _initContent:... time, because it's more trouble that it's worth to write a real +[NSCarbonWindow frameRectForContentRect:styleMask:]. M.P. Notice - 10/10/00
+ [self reconcileToCarbonWindowBounds];
+
+ if (windowModality == kWindowModalityNone || windowModality == kWindowModalityWindowModal || inDisableOrdering) {
+ // Install an event handler for the Carbon window events in which we're interested.
+ const EventTypeSpec kEvents[] = {
+ { kEventClassWindow, kEventWindowActivated },
+ { kEventClassWindow, kEventWindowDeactivated },
+ { kEventClassWindow, kEventWindowBoundsChanged },
+ { kEventClassWindow, kEventWindowShown },
+ { kEventClassWindow, kEventWindowHidden }
+ };
+
+ const EventTypeSpec kControlBoundsChangedEvent = { kEventClassControl, kEventControlBoundsChanged };
+
+ osStatus = InstallEventHandler( GetWindowEventTarget(_windowRef), NSCarbonWindowHandleEvent, GetEventTypeCount( kEvents ), kEvents, (void*)self, &_eventHandler);
+ if (osStatus!=noErr) {
+ [self release];
+ return nil;
+ }
+
+ osStatus = InstallEventHandler( GetControlEventTarget( HIViewGetRoot( _windowRef ) ), NSCarbonWindowHandleEvent, 1, &kControlBoundsChangedEvent, (void*)self, &_eventHandler);
+ if (osStatus!=noErr) {
+ [self release];
+ return nil;
+ }
+
+ HIViewFindByID( HIViewGetRoot( _windowRef ), kHIViewWindowContentID, &contentView );
+ osStatus = InstallEventHandler( GetControlEventTarget( contentView ), NSCarbonWindowHandleEvent, 1, &kControlBoundsChangedEvent, (void*)self, &_eventHandler);
+ if (osStatus!=noErr) {
+ [self release];
+ return nil;
+ }
+ }
+
+ // Put a pointer to this Cocoa NSWindow in a Carbon window property tag.
+ // Right now, this is just used by NSViewCarbonControl. M.P. Notice - 10/9/00
+ windowAsProperty = self;
+ osStatus = SetWindowProperty(_windowRef, NSAppKitPropertyCreator, NSCarbonWindowPropertyTag, sizeof(NSWindow *), &windowAsProperty);
+ if (osStatus!=noErr) {
+ [self release];
+ return nil;
+ }
+
+ // Ignore the Carbon window activation/deactivation events that Carbon sends to its windows at app activation/deactivation. We'll send such events when we think it's appropriate.
+ _passingCarbonWindowActivationEvents = NO;
+
+ // Done.
+ return self;
+
+}
+
+- (void)setViewsNeedDisplay:(BOOL)wellDoThey {
+ // Make sure we can flush anything that needs it.
+
+ // Apparently we don't need to sync the context anymore now that we are
+ // using the HIView context. I might need to turn this back on when I get
+ // around to making this work in non-composited mode. We'll see. But this
+ // function needs to exist no matter what to make sure the normal appkit
+ // thing does not happen.
+
+/// CGContextRef cgContext = (CGContextRef)[[self _threadContext] graphicsPort];
+/// CGContextSynchronize( cgContext );
+}
+
+// Given a reference to a Carbon window that is to be encapsulated, and an indicator of whether or not this object should take responsibility for disposing of the Carbon window, initialize.
+- (id)initWithCarbonWindowRef:(WindowRef)inWindowRef takingOwnership:(BOOL)inWindowRefIsOwned {
+ // for now, set disableOrdering to YES because that is what we've been doing and is therefore lower risk. However, I think it would be correct to set it to NO.
+ return [self initWithCarbonWindowRef:inWindowRef takingOwnership:inWindowRefIsOwned disableOrdering:YES carbon:NO];
+}
+
+
+// Clean up.
+- (void)dealloc {
+
+ // Clean up, if necessary.
+ // if we didn't remove the event handler at dealloc time, we would risk getting sent events after the window has been deallocated. See 2702179. M.P. Notice - 6/1/01
+ if (_eventHandler) RemoveEventHandler(_eventHandler);
+
+ // Do the standard Cocoa thing.
+ [super dealloc];
+
+}
+
+- (WindowRef)windowRef {
+
+ // Simple.
+ return _windowRef;
+
+}
+
+// should always be YES, but check in order to avoid initialization or deallocation surprises
+- (BOOL)_hasWindowRef {
+ return (_windowRef != NULL);
+}
+
+// an NSCarbonWindow does not manage the windowRef. The windowRef manages the NSCarbonWindow
+- (BOOL)_managesWindowRef {
+ return NO;
+}
+
+- (void)_removeWindowRef {
+ _windowRef = NULL;
+
+ if (_eventHandler) RemoveEventHandler(_eventHandler);
+
+ _eventHandler = NULL;
+}
+
+- (WindowClass)_carbonWindowClass {
+ WindowClass windowClass = kDocumentWindowClass;
+ OSStatus osStatus;
+
+ if ([self _hasWindowRef]) {
+ osStatus = GetWindowClass([self windowRef], &windowClass);
+ if (osStatus != noErr) {
+ NSLog(@"Couldn't get window class: error=%d", osStatus);
+ }
+ }
+ return windowClass;
+}
+
+// Update this window's frame and content frame rectangles to match the Carbon window's structure bounds and content bounds rectangles. Return yes if the update was really necessary, no otherwise.
+- (BOOL)reconcileToCarbonWindowBounds {
+
+ OSStatus osStatus;
+ NSRect newContentFrameRect;
+ NSRect newWindowFrameRect;
+ NSRect oldContentFrameRect;
+ Rect windowContentBoundsRect;
+ Rect windowStructureBoundsRect;
+
+ // Initialize for safe returning.
+ BOOL reconciliationWasNecessary = NO;
+
+ // Precondition check.
+ assert(_contentView);
+
+ // Get the Carbon window's bounds, which are expressed in global screen coordinates, with (0,0) at the top-left of the main screen.
+ osStatus = GetWindowBounds(_windowRef, kWindowStructureRgn, &windowStructureBoundsRect);
+ if (osStatus!=noErr) NSLog(@"A Carbon window's structure bounds couldn't be gotten.");
+ osStatus = GetWindowBounds(_windowRef, kWindowContentRgn, &windowContentBoundsRect);
+ if (osStatus!=noErr) NSLog(@"A Carbon window's content bounds couldn't be gotten.");
+
+ // Set the frame rectangle of the border view and this window from the Carbon window's structure region bounds.
+ newWindowFrameRect.origin.x = windowStructureBoundsRect.left;
+ newWindowFrameRect.origin.y = _NXScreenMaxYForRect(NULL) - windowStructureBoundsRect.bottom;
+ newWindowFrameRect.size.width = windowStructureBoundsRect.right - windowStructureBoundsRect.left;
+ newWindowFrameRect.size.height = windowStructureBoundsRect.bottom - windowStructureBoundsRect.top;
+ if (!NSEqualRects(newWindowFrameRect, _frame)) {
+ [self _setFrame:newWindowFrameRect];
+ [_borderView setFrameSize:newWindowFrameRect.size];
+ reconciliationWasNecessary = YES;
+ }
+
+ // Set the content view's frame rect from the Carbon window's content region bounds.
+ newContentFrameRect.origin.x = windowContentBoundsRect.left - windowStructureBoundsRect.left;
+ newContentFrameRect.origin.y = windowStructureBoundsRect.bottom - windowContentBoundsRect.bottom;
+ newContentFrameRect.size.width = windowContentBoundsRect.right - windowContentBoundsRect.left;
+ newContentFrameRect.size.height = windowContentBoundsRect.bottom - windowContentBoundsRect.top;
+ oldContentFrameRect = [_contentView frame];
+ if (!NSEqualRects(newContentFrameRect, oldContentFrameRect)) {
+ [_contentView setFrame:newContentFrameRect];
+ reconciliationWasNecessary = YES;
+ }
+
+ // Done.
+ return reconciliationWasNecessary;
+
+}
+
+
+// Handle an event just like an NSWindow would.
+- (void)sendSuperEvent:(NSEvent *)inEvent {
+
+ // Filter out a few events that just result in complaints in the log.
+ // Ignore some unknown event that gets sent when NSTextViews in printing accessory views are focused. M.P. Notice - 12/7/00
+ BOOL ignoreEvent = NO;
+ NSEventType eventType = [inEvent type];
+ if (eventType==NSSystemDefined) {
+ short eventSubtype = [inEvent subtype];
+ if (eventSubtype==7) {
+ ignoreEvent = YES;
+ }
+ }
+
+ // Simple.
+ if (!ignoreEvent) [super sendEvent:inEvent];
+
+}
+
+
+// There's no override of _addCursorRect:cursor:forView:, despite the fact that NSWindow's invokes [self windowNumber], because Carbon windows won't have subviews, and therefore won't have cursor rects.
+
+
+// There's no override of _autoResizeState, despite the fact that NSWindow's operates on _windowNum, because it looks like it might work on Carbon windows as is.
+
+
+// Disappointingly, -_blockHeartBeat: is not immediately invoked to turn off heartbeating. Heartbeating is turned off by setting the gDefaultButtonPaused global variable, and then this method is invoked later, if that global is set (at heartbeating time I guess). Something has to change if we want to hook this up in Carbon windows. M.P. Warning - 9/17/01
+/*
+// Do the right thing for a Carbon window.
+- (void)_blockHeartBeat:(BOOL)flag {
+
+ ControlRef defaultButton;
+ OSStatus osStatus;
+
+ // Do the standard Cocoa thing.
+ [super _blockHeartBeat:flag];
+
+ // If there's a default Carbon button in this Carbon window, make it stop pulsing, the Carbon way.
+ // This is inspired by HIToolbox/Controls/Definitions/ButtonCDEF.c's ButtonEventHandler(). M.P. Notice - 12/5/00
+ osStatus = GetWindowDefaultButton(_windowRef, &defaultButton);
+ if (osStatus==noErr && defaultButton) {
+ Boolean anotherButtonIsTracking = flag ? TRUE : FALSE;
+ osStatus = SetControlData(defaultButton, kControlNoPart, kControlPushButtonAnotherButtonTrackingTag, sizeof(Boolean), &anotherButtonIsTracking);
+ if (osStatus==noErr) DrawOneControl(defaultButton);
+ else NSLog(@"Some data couldn't be set in a Carbon control.");
+ }
+
+}
+*/
+
+
+// Do the right thing for a Carbon window.
+- (void)_cancelKey:(id)sender {
+
+ // Most of the time the handling of the cancel key will be done by Carbon, but this method will be invoked if an NSCarbonWindow is wrapping a Carbon window that contains an NSViewCarbonControl, and the escape key or whatever is pressed with an NSTextView focused. Just do what Carbon would do.
+ ControlRef cancelButton;
+ GetWindowCancelButton(_windowRef, &cancelButton);
+ if (cancelButton) {
+ if (IsControlActive(cancelButton)) {
+ HIViewSimulateClick(cancelButton, kControlButtonPart, 0, NULL);
+ }
+ }
+
+}
+
+
+
+// Do the right thing for a Carbon window.
+- (void)_commonAwake {
+
+ // Complain, because this should never be called. We insist that -[NSCarbonWindow initWithCarbonWindowRef] is the only valid initializer for instances of this class, and that there's no such thing as a one-shot NSCarbonWindow.
+ NSLog(@"-[NSCarbonWindow _commonAwake] is not implemented.");
+
+}
+
+
+// There's no override of _commonInitFrame:styleMask:backing:defer:, despite the fact that NSWindow's modifies quite a few instance variables, because it gets called in a harmless way if the class instance is properly initialized with -[NSCarbonWindow initWithCarbonWindowRef:takingOwnership:].
+
+
+// Do the right thing for a Carbon window.
+- _destroyRealWindow:(BOOL)orderingOut {
+
+ // Complain, because this should never be called. We don't support one-shot NSCarbonWindows.
+ NSLog(@"-[NSCarbonWindow _destroyRealWindow:] is not implemented.");
+ return self;
+
+}
+
+
+// There's no override of _discardCursorRectsForView, despite the fact that NSWindow's invokes [self windowNumber], because Carbon windows won't have subviews, and therefore won't have cursor rects.
+
+
+// There's no override of _forceFlushWindowToScreen, despite the fact that NSWindow's invokes [self windowNumber], because it looks like it might work on Carbon windows as is.
+
+
+// There's no override of _getPositionFromServer, despite the fact that NSWindow's operates on _windowNum, because it's only called from -[NSApplication _activateWindows], which is hopefully about to become obsolete any second now.
+
+
+// There's no override of _globalWindowNum, despite the fact that NSWindow's invokes [self windowNumber], because it looks like it might work on Carbon windows as is.
+
+
+// There's no override of _initContent:styleMask:backing:defer:contentView:, despite the fact that NSWindow's modifies _auxiliaryStorage->_auxWFlags.hasShadow, because it will never get called if the class instance is properly initialized with -[NSCarbonWindow initWithCarbonWindowRef:takingOwnership:].
+
+
+// There's no override of _initContent:styleMask:backing:defer:counterpart:, despite the fact that NSWindow's modifies _auxiliaryStorage->_auxWFlags.hasShadow, because it will never get called if the class instance is properly initialized with -[NSCarbonWindow initWithCarbonWindowRef:takingOwnership:].
+
+
+// Do what NSWindow would do, but then sychronize the Carbon window structures.
+- (void)_oldPlaceWindow:(NSRect)frameRect {
+
+ OSStatus osStatus;
+
+ // Do the standard Cocoa thing.
+ [super _oldPlaceWindow:frameRect];
+
+ // Tell Carbon to update its various regions.
+ // Despite its name, this function should be called early and often, even if the window isn't visible yet. 2702648. M.P. Notice - 7/24/01
+ osStatus = _SyncWindowWithCGAfterMove(_windowRef);
+ if (osStatus!=noErr) NSLog(@"A Carbon window's bounds couldn't be synchronized (%i).", (int)osStatus);
+
+}
+
+
+// There's no override of _orderOutAndCalcKeyWithCounter:, despite the fact that NSWindow's invokes [self windowNumber], because it looks like it might work on Carbon windows as is.
+
+
+// There's no override of _realHeartBeatThreadContext, despite the fact that NSWindows's invokes [self windowNumber], because it looks like it might not do anything that will effect a Carbon window.
+
+
+// There's no override of _registerWithDockIfNeeded, despite the fact that NSWindow's invokes [self windowNumber], because it looks like it might work on Carbon windows as is.
+
+
+// There's no override of _removeCursorRect:cursor:forView:, despite the fact that NSWindow's invokes [self windowNumber], because Carbon windows won't have subviews, and therefore won't have cursor rects.
+
+
+// There's no override of _setAvoidsActivation:, despite the fact that NSWindow's invokes [self windowNumber], because it looks like it might work on Carbon windows as is.
+
+
+// There's no override of _setFrame:, despite the fact that NSWindow's modifies _frame, because it looks like it might work on Carbon windows as is. The synchronization of the Carbon window bounds rect to the Cocoa frame rect is done in the overrides of _oldPlaceWindow: and _windowMovedToRect:.
+
+
+// There's no override of _setFrameCommon:display:stashSize:, despite the fact that NSWindow's invokes [self windowNumber], because it looks like it might work on Carbon windows as is.
+
+
+// There's no override of _setWindowNumber:, despite the fact that NSWindow's modifies _windowNum and invokes [self windowNumber], because it looks like it might work on Carbon windows as is.
+
+
+// Do what NSWindow would do, but for a Carbon window.
+// This function is mostly cut-and-pasted from -[NSWindow _termWindowIfOwner]. M.P. Notice - 8/7/00
+- (void)_termWindowIfOwner {
+ assert([self _doesOwnRealWindow]);
+ [self _setWindowNumber:-1];
+ _wFlags.isTerminating = YES;
+ if (_windowRef && _windowRefIsOwned) DisposeWindow(_windowRef);
+ // KW - need to clear window shadow state so it gets reset correctly when new window created
+// if ([_borderView respondsToSelector:@selector(setShadowState:)]) {
+// [_borderView setShadowState:kFrameShadowNone];
+// }
+ _wFlags.isTerminating = NO;
+}
+
+
+// There's no override of _threadContext, despite the fact that NSWindow's invokes [self windowNumber], because it looks like it might not do anything that will effect a Carbon window.
+
+
+// There's no override of _windowMoved:, despite the fact that NSWindow's operates on _windowNum, because it looks like it might work on Carbon windows as is.
+
+
+// Do what NSWindow would do, but then sychronize the Carbon window structures.
+- (void)_windowMovedToRect:(NSRect)actualFrame {
+
+ OSStatus osStatus;
+
+ // Do the standard Cocoa thing.
+ [super _windowMovedToRect:actualFrame];
+
+ // Let Carbon know that the window has been moved, unless this method is being called "early."
+ if (_wFlags.visible) {
+ osStatus = _SyncWindowWithCGAfterMove(_windowRef);
+ if (osStatus!=noErr) NSLog(@"A Carbon window's bounds couldn't be synchronized (%i).", (int)osStatus);
+ }
+
+}
+
+- (NSRect)constrainFrameRect:(NSRect)actualFrame toScreen:(NSScreen *)screen {
+ // let Carbon decide window size and position
+ return actualFrame;
+}
+
+- (void)selectKeyViewFollowingView:(NSView *)aView {
+ HIViewRef view = NULL;
+
+ view = [HIViewAdapter getHIViewForNSView:aView];
+
+ if ( view )
+ {
+ HIViewRef contentView;
+
+ GetRootControl( GetControlOwner( view ), &contentView );
+ HIViewAdvanceFocus( contentView, 0 );
+ }
+ else
+ {
+ [super selectKeyViewFollowingView:aView];
+ }
+}
+
+- (void)selectKeyViewPrecedingView:(NSView *)aView {
+ HIViewRef view = NULL;
+
+ view = [HIViewAdapter getHIViewForNSView:aView];
+
+ if ( view )
+ {
+ HIViewRef contentView;
+
+ GetRootControl( GetControlOwner( view ), &contentView );
+ HIViewAdvanceFocus( contentView, shiftKey );
+ }
+ else
+ {
+ [super selectKeyViewPrecedingView:aView];
+ }
+}
+
+- (void)makeKeyWindow {
+ [NSApp _setMouseActivationInProgress:NO];
+ [NSApp setIsActive:YES];
+ [super makeKeyWindow];
+ _NXOrderKeyAndMain();
+ _NXShowKeyAndMain();
+}
+
+
+// Do the right thing for a Carbon window.
+- (BOOL)canBecomeKeyWindow {
+
+ return YES;
+}
+
+// Do the right thing for a Carbon window.
+- (BOOL)canBecomeMainWindow {
+ OSStatus osStatus;
+ WindowClass windowClass;
+ // By default, Carbon windows cannot become the main window.
+ // What about when the default isn't right? Requiring subclassing seems harsh. M.P. Warning - 9/17/01
+ // KW - modify this to allow document windows to become main
+ // This is primarily to get the right look, so that you don't have two windows that both look active - one Cocoa document and one Carbon document
+ osStatus = GetWindowClass(_windowRef, &windowClass);
+ return (osStatus == noErr && windowClass == kDocumentWindowClass);
+
+}
+
+
+// There's no override of deminiaturize:, despite the fact that NSWindow's invokes [self windowNumber], because it looks like it might work on Carbon windows as is.
+
+
+// There's no override of disableCursorRects, despite the fact that NSWindow's invokes [self windowNumber], because Carbon windows won't have subviews, and therefore won't have cursor rects.
+
+
+
+// There's no override of enableCursorRects, despite the fact that NSWindow's invokes [self windowNumber], because Carbon windows won't have subviews, and therefore won't have cursor rects.
+
+
+// Do the right thing for a Carbon window.
+- (void)encodeWithCoder:(NSCoder *)coder {
+
+ // Actually, this will probably never be implemented. M.P. Notice - 8/2/00
+ NSLog(@"-[NSCarbonWindow encodeWithCoder:] is not implemented.");
+
+}
+
+
+// There's no override of frame, despite the fact that NSWindow's returns _frame, because _frame is one of the instance variables whose value we're keeping synchronized with the Carbon window.
+
+
+// Do the right thing for a Carbon window.
+- (id)initWithCoder:(NSCoder *)coder {
+
+ // Actually, this will probably never be implemented. M.P. Notice - 8/2/00
+ NSLog(@"-[NSCarbonWindow initWithCoder:] is not implemented.");
+ [self release];
+ return nil;
+
+}
+
+
+// There's no override of level, despite the fact that NSWindow's returns _level, because _level is one of the instance variables whose value we're keeping synchronized with the Carbon window.
+
+
+// There's no override of miniaturize:, despite the fact that NSWindow's invokes [self windowNumber], because it looks like it might work on Carbon windows as is.
+
+
+// There's no override of resizeToScreenWithEvent:, despite the fact that NSWindow's operates on _windowNum.
+// It looks like it's only called when an _NSForceResizeEventType event is passed into -[NSWindow sendEvent:], and I can't find any instances of that happening.
+
+/*
+// Do the right thing for a Carbon Window.
+- (void)sendEvent:(NSEvent *)theEvent {
+
+ // Not all events are handled in the same manner.
+ NSEventType eventType = [theEvent type];
+ if (eventType==NSAppKitDefined) {
+
+ // Handle the event the Cocoa way. Carbon won't understand it anyway.
+ [super sendEvent:theEvent];
+
+ }
+}
+*/
+
+// There's no override of setAcceptsMouseMovedEvents:, despite the fact that NSWindow's invokes [self windowNumber], because it looks like it might work on Carbon windows as is.
+
+
+// There's no override of setBackingType:, despite the fact that NSWindow's invokes [self windowNumber], because it's apparently not expected to do anything anyway, judging from the current implementation of PSsetwindowtype().
+
+
+// Do what NSWindow would do, but for a Carbon window.
+- (void)setContentView:(NSView *)aView {
+
+ NSRect contentFrameRect;
+ OSStatus osStatus;
+ Rect windowContentBoundsRect;
+
+ // Precondition check.
+ assert(_borderView);
+ assert([_borderView isKindOfClass:[CarbonWindowFrame class]]);
+ assert(_windowRef);
+
+ // Parameter check.
+ assert(aView);
+ assert([aView isKindOfClass:[CarbonWindowContentView class]]);
+
+ // Find out the window's Carbon window structure region (content) bounds.
+ osStatus = GetWindowBounds(_windowRef, kWindowContentRgn, &windowContentBoundsRect);
+ if (osStatus!=noErr) NSLog(@"A Carbon window's content bounds couldn't be gotten.");
+ contentFrameRect.origin = NSZeroPoint;
+ contentFrameRect.size.width = windowContentBoundsRect.right - windowContentBoundsRect.left;
+ contentFrameRect.size.height = windowContentBoundsRect.bottom - windowContentBoundsRect.top;
+
+ // If the content view is still in some other view hierarchy, pry it free.
+ [_contentView removeFromSuperview];
+ assert(![_contentView superview]);
+
+ // Record the content view, and size it to this window's content frame.
+ _contentView = aView;
+ [_contentView setFrame:contentFrameRect];
+
+ // Make the content view a subview of the border view.
+ [_borderView addSubview:_contentView];
+
+ // Tell the content view it's new place in the responder chain.
+ [_contentView setNextResponder:self];
+
+}
+
+
+// There's no override of setDepthLimit:, despite the fact that NSWindow's invokes [self windowNumber], because it looks like it might work on Carbon windows as is.
+
+
+- (BOOL)worksWhenModal {
+ WindowClass windowClass = [self _carbonWindowClass];
+ return (windowClass == kFloatingWindowClass || windowClass == kUtilityWindowClass);
+}
+
+- (void)_setModalWindowLevel {
+ return;
+}
+
+- _clearModalWindowLevel {
+ return nil;
+}
+
+// There's no override of setLevel:, despite the fact that NSWindow's invokes [self windowNumber], because it looks like it might work on Carbon windows as is.
+// I thought at first that there should be a mapping between Cocoa level and Carbon window class, but experiments convince me that such is not the case. M.P. Notice - 9/18/00
+
+
+// There's no override of windowNumber, despite the fact that NSWindow's returns _windowNum, because _windowNum is one of the instance variables whose value we're keeping synchronized with the Carbon window.
+
+
+- (UInt32)carbonHICommandIDFromActionSelector:(SEL)inActionSelector {
+
+ // Initialize with the default return value.
+ UInt32 hiCommandID = 0;
+
+ // Pretty simple, if tedious.
+ if (inActionSelector==@selector(clear:)) hiCommandID = kHICommandClear;
+ else if (inActionSelector==@selector(copy:)) hiCommandID = kHICommandCopy;
+ else if (inActionSelector==@selector(cut:)) hiCommandID = kHICommandCut;
+ else if (inActionSelector==@selector(paste:)) hiCommandID = kHICommandPaste;
+ else if (inActionSelector==@selector(redo:)) hiCommandID = kHICommandRedo;
+ else if (inActionSelector==@selector(selectAll:)) hiCommandID = kHICommandSelectAll;
+ else if (inActionSelector==@selector(undo:)) hiCommandID = kHICommandUndo;
+
+ // Done.
+ return hiCommandID;
+
+}
+
+
+- (void)sendCarbonProcessHICommandEvent:(UInt32)inHICommandID {
+
+ EventTargetRef eventTargetRef;
+ HICommand hiCommand;
+ OSStatus osStatus;
+
+ // Initialize for safe error handling.
+ EventRef eventRef = NULL;
+
+ // Create a Process Command event. Don't mention anything about the menu item, because we don't want the Carbon Event handler fiddling with it.
+ hiCommand.attributes = 0;
+ hiCommand.commandID = inHICommandID;
+ hiCommand.menu.menuRef = 0;
+ hiCommand.menu.menuItemIndex = 0;
+ osStatus = CreateEvent(NULL, kEventClassCommand, kEventCommandProcess, GetCurrentEventTime(), kEventAttributeNone, &eventRef);
+ if (osStatus!=noErr) {
+ NSLog(@"CreateEvent() returned %i.", (int)osStatus);
+ goto CleanUp;
+ }
+ osStatus = SetEventParameter(eventRef, kEventParamDirectObject, typeHICommand, sizeof(HICommand), &hiCommand);
+ if (osStatus!=noErr) {
+ NSLog(@"SetEventParameter() returned %i.", (int)osStatus);
+ goto CleanUp;
+ }
+
+ // Send a Carbon event to whatever has the Carbon user focus.
+ eventTargetRef = GetUserFocusEventTarget();
+ osStatus = SendEventToEventTarget(eventRef, eventTargetRef);
+ if (osStatus!=noErr) {
+ NSLog(@"SendEventToEventTarget() returned %i.", (int)osStatus);
+ goto CleanUp;
+ }
+
+CleanUp:
+
+ // Clean up.
+ if (eventRef) ReleaseEvent(eventRef);
+
+}
+
+
+- (Boolean)sendCarbonUpdateHICommandStatusEvent:(UInt32)inHICommandID withMenuRef:(MenuRef)inMenuRef andMenuItemIndex:(UInt16)inMenuItemIndex {
+
+ EventTargetRef eventTargetRef;
+ HICommand hiCommand;
+ OSStatus osStatus;
+
+ // Initialize for safe error handling and flag returning.
+ Boolean eventWasHandled = FALSE;
+ EventRef eventRef = NULL;
+
+ // Create a Process Command event. Don't mention anything about the menu item, because we don't want the Carbon Event handler fiddling with it.
+ hiCommand.attributes = kHICommandFromMenu;
+ hiCommand.commandID = inHICommandID;
+ hiCommand.menu.menuRef = inMenuRef;
+ hiCommand.menu.menuItemIndex = inMenuItemIndex;
+ osStatus = CreateEvent(NULL, kEventClassCommand, kEventCommandUpdateStatus, GetCurrentEventTime(), kEventAttributeNone, &eventRef);
+ if (osStatus!=noErr) {
+ NSLog(@"CreateEvent() returned %i.", (int)osStatus);
+ goto CleanUp;
+ }
+ osStatus = SetEventParameter(eventRef, kEventParamDirectObject, typeHICommand, sizeof(HICommand), &hiCommand);
+ if (osStatus!=noErr) {
+ NSLog(@"SetEventParameter() returned %i.", (int)osStatus);
+ goto CleanUp;
+ }
+
+ // Send a Carbon event to whatever has the Carbon user focus.
+ eventTargetRef = GetUserFocusEventTarget();
+ osStatus = SendEventToEventTarget(eventRef, eventTargetRef);
+ if (osStatus==noErr) {
+ eventWasHandled = TRUE;
+ } else if (osStatus!=eventNotHandledErr) {
+ NSLog(@"SendEventToEventTarget() returned %i.", (int)osStatus);
+ goto CleanUp;
+ }
+
+CleanUp:
+
+ // Clean up.
+ if (eventRef) ReleaseEvent(eventRef);
+
+ // Done.
+ return eventWasHandled;
+
+}
+
+- (void)_handleRootBoundsChanged
+{
+ HIViewRef root = HIViewGetRoot( _windowRef );
+ HIRect frame;
+
+ HIViewGetFrame( root, &frame );
+ [_borderView setFrameSize:*(NSSize*)&frame.size];
+}
+
+- (void)_handleContentBoundsChanged
+{
+ HIViewRef root, contentView;
+ HIRect rootBounds, contentFrame;
+ NSRect oldContentFrameRect;
+
+ root = HIViewGetRoot( _windowRef );
+ HIViewFindByID( root, kHIViewWindowContentID, &contentView );
+ HIViewGetFrame( contentView, &contentFrame );
+ HIViewGetBounds( root, &rootBounds );
+
+ // Set the content view's frame rect from the Carbon window's content region bounds.
+ contentFrame.origin.y = rootBounds.size.height - CGRectGetMaxY( contentFrame );
+
+ oldContentFrameRect = [_contentView frame];
+ if ( !NSEqualRects( *(NSRect*)&contentFrame, oldContentFrameRect ) ) {
+ [_contentView setFrame:*(NSRect*)&contentFrame];
+ }
+}
+
+- (OSStatus)_handleCarbonEvent:(EventRef)inEvent callRef:(EventHandlerCallRef)inCallRef {
+ OSStatus result = eventNotHandledErr;
+
+ switch ( GetEventClass( inEvent ) )
+ {
+ case kEventClassControl:
+ {
+ ControlRef control;
+
+ check( GetEventKind( inEvent ) == kEventControlBoundsChanged );
+
+ GetEventParameter( inEvent, kEventParamDirectObject, typeControlRef, NULL,
+ sizeof( ControlRef ), NULL, &control );
+
+ if ( control == HIViewGetRoot( _windowRef ) )
+ [self _handleRootBoundsChanged];
+ else
+ [self _handleContentBoundsChanged];
+ }
+ break;
+
+ case kEventClassWindow:
+ switch ( GetEventKind( inEvent ) )
+ {
+ case kEventWindowShown:
+ [self _setVisible:YES];
+ break;
+
+ case kEventWindowHidden:
+ [self _setVisible:NO];
+ break;
+
+ case kEventWindowActivated:
+ [self makeKeyWindow];
+ break;
+
+ case kEventWindowDeactivated:
+ [self resignKeyWindow];
+ break;
+
+ case kEventWindowBoundsChanged:
+ [self reconcileToCarbonWindowBounds];
+ break;
+ }
+ break;
+ }
+
+ return result;
+}
+
+// Handle various events that Carbon is sending to our window.
+static OSStatus NSCarbonWindowHandleEvent(EventHandlerCallRef inEventHandlerCallRef, EventRef inEventRef, void *inUserData) {
+
+ // default action is to send event to next handler. We modify osStatus as necessary where we don't want this behavior
+ OSStatus osStatus = eventNotHandledErr;
+
+ // We do different things for different event types.
+ CarbonWindowAdapter *carbonWindow = (CarbonWindowAdapter *)inUserData;
+
+ osStatus = [carbonWindow _handleCarbonEvent: inEventRef callRef: inEventHandlerCallRef];
+
+ // Done. If we want to propagate the event, we return eventNotHandledErr to send it to the next handler
+ return osStatus;
+
+}
+
+/*
+void _NSSetModalWindowClassLevel(int level) {
+ WindowGroupRef groupRef;
+ // Carbon will handle modality in its own way
+ // if (_NSIsCarbonApp()) {
+ return;
+ // }//
+ groupRef = GetWindowGroupOfClass(kModalWindowClass);
+// if (groupRef) {
+// SetWindowGroupLevel(groupRef, level);
+// }
+}
+*/
+
+ at end // implementation CarbonWindowAdapter
diff --git a/WebKit/Carbon.subproj/CarbonWindowContentView.h b/WebKit/Carbon.subproj/CarbonWindowContentView.h
new file mode 100644
index 0000000..20cf086
--- /dev/null
+++ b/WebKit/Carbon.subproj/CarbonWindowContentView.h
@@ -0,0 +1,18 @@
+/*
+ CarbonWindowContentView.h
+ Application Kit
+ Copyright (c) 2000-2001, Apple Computer, Inc.
+ All rights reserved.
+ Original Author: Mark Piccirelli
+ Responsibility: Mark Piccirelli
+
+ The class of objects that are meant to be used as _contentViews of NSCarbonWindow objects. It's really just used to provide the context in which views that are being shown by NSViewCarbonControls can operate.
+*/
+
+
+#import <AppKit/NSView.h>
+
+
+ at interface CarbonWindowContentView : NSView { }
+
+ at end // interface CarbonWindowContentView
diff --git a/WebKit/Carbon.subproj/CarbonWindowContentView.m b/WebKit/Carbon.subproj/CarbonWindowContentView.m
new file mode 100644
index 0000000..7309d3e
--- /dev/null
+++ b/WebKit/Carbon.subproj/CarbonWindowContentView.m
@@ -0,0 +1,27 @@
+/*
+ NSCarbonWindowContentView.m
+ Application Kit
+ Copyright (c) 2000-2001, Apple Computer, Inc.
+ All rights reserved.
+ Original Author: Mark Piccirelli
+ Responsibility: Mark Piccirelli
+
+ The class of objects that are meant to be used as _contentViews of NSCarbonWindow objects. It's really just used to provide the context in which views that are being shown by NSViewCarbonControls can operate.
+*/
+
+
+#import "CarbonWindowContentView.h"
+#import "CarbonWindowAdapter.h"
+#import <QD/Quickdraw.h>
+#import <assert.h>
+
+
+// Turn off the assertions in this file.
+// If this is commented out, uncomment it before committing to CVS. M.P. Warning - 10/18/01
+#undef assert
+#define assert(X)
+
+
+ at implementation CarbonWindowContentView
+
+ at end // implementation CarbonWindowContentView
diff --git a/WebKit/Carbon.subproj/CarbonWindowFrame.h b/WebKit/Carbon.subproj/CarbonWindowFrame.h
new file mode 100644
index 0000000..9746be7
--- /dev/null
+++ b/WebKit/Carbon.subproj/CarbonWindowFrame.h
@@ -0,0 +1,32 @@
+/*
+ NSCarbonWindowFrame.h
+ Application Kit
+ Copyright (c) 2000-2001, Apple Computer, Inc.
+ All rights reserved.
+ Original Author: Mark Piccirelli
+ Responsibility: Mark Piccirelli
+
+The class of objects that are meant to be used as _borderViews of NSCarbonWindow objects. It's really only a subclass of NSView for the benefit of embedded NSViewCarbonControls.
+*/
+
+
+#import <AppKit/AppKit.h>
+
+
+//@class NSCarbonWindow;
+//@class NSCarbonWindowContentView;
+
+
+ at interface CarbonWindowFrame : NSView
+
+// Instance variables.
+{
+
+ @private
+
+ // Something we keep around just to return when it's asked for.
+ unsigned int _styleMask;
+
+}
+
+ at end // interface NSCarbonWindowFrame
diff --git a/WebKit/Carbon.subproj/CarbonWindowFrame.m b/WebKit/Carbon.subproj/CarbonWindowFrame.m
new file mode 100644
index 0000000..aaef338
--- /dev/null
+++ b/WebKit/Carbon.subproj/CarbonWindowFrame.m
@@ -0,0 +1,252 @@
+/*
+ NSCarbonWindowFrame.m
+ Application Kit
+ Copyright (c) 2000-2001, Apple Computer, Inc.
+ All rights reserved.
+ Original Author: Mark Piccirelli
+ Responsibility: Mark Piccirelli
+
+The class of objects that are meant to be used as _borderViews of NSCarbonWindow objects. It's really only a subclass of NSView for the benefit of embedded NSViewCarbonControls.
+*/
+
+
+#import "CarbonWindowFrame.h"
+#import "CarbonWindowAdapter.h"
+#import "CarbonWindowContentView.h"
+#import <Foundation/NSGeometry.h>
+#import <Foundation/NSUtilities.h>
+#import <HIToolbox/MacWindows.h>
+#import <assert.h>
+
+ at interface NSView(Secret)
+- (void)_setWindow:(NSWindow *)window;
+ at end
+
+// Turn off the assertions in this file.
+// If this is commented out, uncomment it before committing to CVS. M.P. Warning - 10/18/01
+#undef assert
+#define assert(X)
+
+
+ at class NSButton;
+/*
+
+ at interface NSThemeFrame(NSHijackedClassMethods)
+
++ (float)_titlebarHeight:(unsigned int)style;
+
+ at end
+*/
+
+ at implementation CarbonWindowFrame
+
+
+// Given a content rectangle and style mask, return a corresponding frame rectangle.
++ (NSRect)frameRectForContentRect:(NSRect)contentRect styleMask:(unsigned int)style {
+
+ // We don't bother figuring out a good value, because content rects weren't so meaningful for NSCarbonWindows in the past, but this might not be a good assumption anymore. M.P. Warning - 12/5/00
+ return contentRect;
+
+}
+
++ (NSRect)contentRectForFrameRect:(NSRect)frameRect styleMask:(unsigned int)style {
+
+ // We don't bother figuring out a good value, because content rects weren't so meaningful for NSCarbonWindows in the past, but this might not be a good assumption anymore. KW - copied from +frameRectForContentRect:styleMask
+ return frameRect;
+
+}
+
++ (NSSize)minFrameSizeForMinContentSize:(NSSize)cSize styleMask:(unsigned int)style {
+ // See comments above. We don't make any assumptions about the relationship between content rects and frame rects
+ return cSize;
+}
+
+- (NSRect)frameRectForContentRect:(NSRect)cRect styleMask:(unsigned int)style {
+ return [[self class] frameRectForContentRect: cRect styleMask:style];
+}
+- (NSRect)contentRectForFrameRect:(NSRect)fRect styleMask:(unsigned int)style {
+ return [[self class] contentRectForFrameRect: fRect styleMask:style];
+}
+- (NSSize)minFrameSizeForMinContentSize:(NSSize)cSize styleMask:(unsigned int)style {
+ return [[self class] minFrameSizeForMinContentSize:cSize styleMask: style];
+}
+
+// Initialize.
+- (id)initWithFrame:(NSRect)inFrameRect styleMask:(unsigned int)inStyleMask owner:(NSWindow *)inOwningWindow {
+
+ // Parameter check.
+ if (![inOwningWindow isKindOfClass:[CarbonWindowAdapter class]]) NSLog(@"CarbonWindowFrames can only be owned by CarbonWindowAdapters.");
+
+ // Do the standard Cocoa thing.
+ self = [super initWithFrame:inFrameRect];
+ if (!self) return nil;
+
+ // Record what we'll need later.
+ _styleMask = inStyleMask;
+
+ // Do what NSFrameView's method of the same name does.
+ [self _setWindow:inOwningWindow];
+ [self setNextResponder:inOwningWindow];
+
+ // Done.
+ return self;
+
+}
+
+
+// Deallocate.
+- (void)dealloc {
+
+ // Simple.
+ [super dealloc];
+
+}
+
+
+// Sink a method invocation.
+- (void)_setFrameNeedsDisplay:(BOOL)needsDisplay {
+
+}
+
+
+// Sink a method invocation.
+- (void)_setSheet:(BOOL)sheetFlag {
+
+}
+
+
+// Sink a method invocation.
+- (void)_updateButtonState {
+
+}
+
+#if 0
+// Sink a method invocation.
+- (void)_windowChangedKeyState {
+}
+#endif
+
+// Toolbar methods that NSWindow expects to be there.
+- (BOOL)_canHaveToolbar { return NO; }
+- (BOOL)_toolbarIsInTransition { return NO; }
+- (BOOL)_toolbarIsShown { return NO; }
+- (BOOL)_toolbarIsHidden { return NO; }
+- (void)_showToolbarWithAnimation:(BOOL)animate {}
+- (void)_hideToolbarWithAnimation:(BOOL)animate {}
+- (float)_distanceFromToolbarBaseToTitlebar { return 0; }
+
+
+// Refuse to admit there's a close button on the window.
+- (NSButton *)closeButton {
+
+ // Simple.
+ return nil;
+}
+
+
+// Return what's asked for.
+- (unsigned int)styleMask {
+
+ // Simple.
+ return _styleMask;
+
+}
+
+
+// Return what's asked for.
+- (NSRect)dragRectForFrameRect:(NSRect)frameRect {
+
+ // Do what NSThemeFrame would do.
+ // If we just return NSZeroRect here, _NXMakeWindowVisible() gets all befuddled in the sheet-showing case, a window-moving loop is entered, and the sheet gets moved right off of the screen. M.P. Warning - 3/23/01
+ NSRect dragRect;
+ dragRect.size.height = 27;//[NSThemeFrame _titlebarHeight:[self styleMask]];
+ dragRect.origin.y = NSMaxY(frameRect) - dragRect.size.height;
+ dragRect.size.width = frameRect.size.width;
+ dragRect.origin.x = frameRect.origin.x;
+ return dragRect;
+
+}
+
+
+// Return what's asked for.
+- (BOOL)isOpaque {
+
+ // Return a value that will make -[NSWindow displayIfNeeded] on our Carbon window actually work.
+ return YES;
+
+}
+
+
+// Refuse to admit there's a minimize button on the window.
+- (NSButton *)minimizeButton {
+
+ // Simple.
+ return nil;
+
+}
+
+
+// Do the right thing for a Carbon window.
+- (void)setTitle:(NSString *)title {
+
+ CarbonWindowAdapter *carbonWindow;
+ OSStatus osStatus;
+ WindowRef windowRef;
+
+ // Set the Carbon window's title.
+ carbonWindow = (CarbonWindowAdapter *)[self window];
+ windowRef = [carbonWindow windowRef];
+ osStatus = SetWindowTitleWithCFString(windowRef, (CFStringRef)title);
+ if (osStatus!=noErr) NSLog(@"A Carbon window's title couldn't be set.");
+
+}
+
+
+// Return what's asked for.
+- (NSString *)title {
+
+ CFStringRef windowTitle;
+ CarbonWindowAdapter *carbonWindow;
+ NSString *windowTitleAsNSString;
+ OSStatus osStatus;
+ WindowRef windowRef;
+
+ // Return the Carbon window's title.
+ carbonWindow = (CarbonWindowAdapter *)[self window];
+ windowRef = [carbonWindow windowRef];
+ osStatus = CopyWindowTitleAsCFString(windowRef, &windowTitle);
+ if (osStatus==noErr) {
+ windowTitleAsNSString = (NSString *)windowTitle;
+ } else {
+ NSLog(@"A Carbon window's title couldn't be gotten.");
+ windowTitleAsNSString = @"";
+ }
+ return [windowTitleAsNSString autorelease];
+
+}
+
+
+// Return what's asked for.
+- (float)_sheetHeightAdjustment {
+
+ // Do what NSThemeFrame would do.
+ return 22;//[NSThemeFrame _titlebarHeight:([self styleMask] & ~NSDocModalWindowMask)];
+
+}
+
+// Return what's asked for.
+- (float)_maxTitlebarTitleRect {
+
+ // Do what NSThemeFrame would do.
+ return 22;//[NSThemeFrame _titlebarHeight:([self styleMask] & ~NSDocModalWindowMask)];
+
+}
+
+- (void)_clearDragMargins {
+}
+
+- (void)_resetDragMargins {
+}
+
+
+ at end // implementation NSCarbonWindowFrame
diff --git a/WebKit/Carbon.subproj/HIViewAdapter.h b/WebKit/Carbon.subproj/HIViewAdapter.h
new file mode 100644
index 0000000..abf1cfe
--- /dev/null
+++ b/WebKit/Carbon.subproj/HIViewAdapter.h
@@ -0,0 +1,22 @@
+//
+// NSHIViewAdapter.h
+// Synergy
+//
+// Created by Ed Voas on Mon Jan 20 2003.
+// Copyright (c) 2003 __MyCompanyName__. All rights reserved.
+//
+
+#import <WebKit/WebKit.h>
+#include <HIToolbox/HIView.h>
+
+ at interface HIViewAdapter : NSView {
+// HIViewRef _hiView;
+}
+
++ (void)bindHIViewToNSView:(HIViewRef)hiView nsView:(NSView*)nsView;
++ (void)unbindNSView:(NSView*)nsView;
++ (HIViewRef)getHIViewForNSView:(NSView*)inView;
+//- (id)initWithFrame:(NSRect)frame view:(HIViewRef) inView;
+//- (HIViewRef)hiView;
+
+ at end
diff --git a/WebKit/Carbon.subproj/HIViewAdapter.m b/WebKit/Carbon.subproj/HIViewAdapter.m
new file mode 100644
index 0000000..2907bae
--- /dev/null
+++ b/WebKit/Carbon.subproj/HIViewAdapter.m
@@ -0,0 +1,204 @@
+//
+// NSHIViewAdapter.m
+// Synergy
+//
+// Created by Ed Voas on Mon Jan 20 2003.
+// Copyright (c) 2003 __MyCompanyName__. All rights reserved.
+//
+
+#import "HIViewAdapter.h"
+
+extern OSStatus _HIViewSetNeedsDisplayInRect( HIViewRef inView, const HIRect* inBounds, Boolean inNeedsDisplay );
+
+#define SHEET_INTERCEPTOR 0
+
+ at interface NSView(ShhhhDontTell)
+- (NSRect)_dirtyRect;
+ at end
+
+#if SHEET_INTERCEPTOR
+ at interface CarbonSheetInterceptor : NSWindow
+{
+}
+
+- (void)_orderFrontRelativeToWindow:(NSWindow *)docWindow;
+ at end
+#endif
+
+ at implementation HIViewAdapter
+
+static CFMutableDictionaryRef sViewMap;
+
++ (void)bindHIViewToNSView:(HIViewRef)hiView nsView:(NSView*)nsView
+{
+ if ( sViewMap == NULL )
+ {
+ [HIViewAdapter poseAsClass: [NSView class]];
+#if SHEET_INTERCEPTOR
+ [CarbonSheetInterceptor poseAsClass: [NSWindow class]];
+#endif
+ sViewMap = CFDictionaryCreateMutable( NULL, 0, NULL, NULL );
+ }
+
+ CFDictionaryAddValue( sViewMap, nsView, hiView );
+}
+
++ (HIViewRef)getHIViewForNSView:(NSView*)inView
+{
+ return sViewMap ? (HIViewRef)CFDictionaryGetValue( sViewMap, inView ) : NULL;
+}
+
++ (void)unbindNSView:(NSView*)inView
+{
+ CFDictionaryRemoveValue( sViewMap, inView );
+}
+
+- (id)initWithFrame:(NSRect)frame view:(HIViewRef) inView {
+ self = [super initWithFrame:frame];
+// if (self) {
+// _hiView = inView;
+// }
+ return self;
+}
+
+#if 0
+- (HIViewRef)hiView {
+ return _hiView;
+}
+
+- (NSView*)nextValidKeyView {
+ //fprintf( stderr, "spoofing next valid key view\n" );
+ return [_window contentView];
+}
+#endif
+
+- (void)setNeedsDisplay:(BOOL)flag {
+ [super setNeedsDisplay:flag];
+
+ if ( flag == NO )
+ {
+ HIViewRef hiView = NULL;
+ NSRect targetBounds = [self visibleRect];
+ NSRect validRect = targetBounds;
+ NSView* view = self;
+
+ while ( view ) {
+ targetBounds = [view visibleRect];
+ if ( (hiView = [HIViewAdapter getHIViewForNSView:view]) != NULL )
+ break;
+ validRect = [view convertRect:validRect toView:[view superview]];
+ view = [view superview];
+ }
+
+ if ( hiView )
+ {
+ HIRect rect;
+
+ //printf( "validating %g %g %g %g\n", validRect.origin.y, validRect.origin.x,
+ // NSMaxY( validRect ), NSMaxX( validRect ) );
+
+ //printf( "targetBounds.size.height = %g, NSMaxY( validRect ) = %g\n", targetBounds.size.height, NSMaxY( validRect ) );
+
+ // flip rect here and convert to region
+
+ rect.origin.x = validRect.origin.x;
+ rect.origin.y = targetBounds.size.height - NSMaxY( validRect );
+ rect.size.height = validRect.size.height;
+ rect.size.width = validRect.size.width;
+
+ //printf( " flipped to %g %g %g %g\n", rect.origin.y, rect.origin.x,
+ // CGRectGetMaxY( rect ), CGRectGetMaxX( rect ) );
+
+ _HIViewSetNeedsDisplayInRect( hiView, &rect, false );
+ }
+ }
+}
+
+- (void)setNeedsDisplayInRect:(NSRect)invalidRect {
+ [super setNeedsDisplayInRect:invalidRect];
+
+ if (_vFlags.needsDisplay || _vFlags.needsDisplayForBounds)
+ {
+ HIViewRef hiView = NULL;
+ NSRect targetBounds = _bounds;
+ NSView* view = self;
+
+ invalidRect = [self _dirtyRect];
+
+ while ( view ) {
+ targetBounds = [view bounds];
+ if ( (hiView = [HIViewAdapter getHIViewForNSView:view]) != NULL )
+ break;
+ invalidRect = [view convertRect:invalidRect toView:[view superview]];
+ view = [view superview];
+ }
+
+ if ( hiView )
+ {
+ if ( NSWidth( invalidRect ) > 0 && NSHeight( invalidRect ) )
+ {
+ HIRect rect;
+
+ //printf( "invalidating %g %g %g %g\n", invalidRect.origin.y, invalidRect.origin.x,
+ // NSMaxY( invalidRect ), NSMaxX( invalidRect ) );
+
+ //printf( "targetBounds.size.height = %g, NSMaxY( invalidRect ) = %g\n", targetBounds.size.height, NSMaxY( invalidRect ) );
+
+ // flip rect here and convert to region
+
+ rect.origin.x = invalidRect.origin.x;
+ rect.origin.y = targetBounds.size.height - NSMaxY( invalidRect );
+ rect.size.height = invalidRect.size.height;
+ rect.size.width = invalidRect.size.width;
+
+ //printf( " flipped to %g %g %g %g\n", rect.origin.y, rect.origin.x,
+ // CGRectGetMaxY( rect ), CGRectGetMaxX( rect ) );
+
+ _HIViewSetNeedsDisplayInRect( hiView, &rect, true );
+ }
+ }
+ else
+ [_window setViewsNeedDisplay:YES];
+ }
+}
+
+- (NSView *)nextValidKeyView
+{
+ HIViewRef hiView = [HIViewAdapter getHIViewForNSView:self];
+ NSView* retVal = NULL;
+
+ if ( hiView )
+ {
+ //fprintf( stderr, "spoofing next valid key view\n" );
+ retVal = [_window contentView];
+ }
+ else
+ {
+ retVal = [super nextValidKeyView];
+ }
+
+ return retVal;
+}
+
+ at end
+
+#if SHEET_INTERCEPTOR
+ at implementation CarbonSheetInterceptor
+
+- (void)_orderFrontRelativeToWindow:(NSWindow *)docWindow
+{
+ printf( "Here I am!\n" );
+ [docWindow _attachSheetWindow:self];
+ SetWindowClass( [self windowRef], kSheetWindowClass );
+ ShowSheetWindow( [self windowRef], [docWindow windowRef] );
+}
+
+- (void)_orderOutRelativeToWindow:(NSWindow *)docWindow
+{
+ printf( "Here I go!\n" );
+ HideSheetWindow( [self windowRef] );
+ [docWindow _detachSheetWindow];
+}
+
+ at end
+#endif
diff --git a/WebKit/Carbon.subproj/HIWebView.h b/WebKit/Carbon.subproj/HIWebView.h
new file mode 100644
index 0000000..694a4cd
--- /dev/null
+++ b/WebKit/Carbon.subproj/HIWebView.h
@@ -0,0 +1,74 @@
+#ifndef __HIWEBVIEW__
+#define __HIWEBVIEW__
+
+#ifndef __HIWEBCONTROLLER__
+#include <WebKit/WebController.h>
+#endif
+
+
+
+#include <AvailabilityMacros.h>
+
+#if PRAGMA_ONCE
+#pragma once
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * HIWebViewCreate()
+ *
+ * Summary:
+ * Creates a new web view.
+ *
+ * Parameters:
+ *
+ * outControl:
+ * The new web view.
+ *
+ * Result:
+ * An operating system status code.
+ *
+ * Availability:
+ * Mac OS X: in version 10.2 and later
+ * CarbonLib: not available
+ * Non-Carbon CFM: not available
+ */
+extern OSStatus
+HIWebViewCreate(HIViewRef * outControl);
+
+
+/*
+ * HIWebViewGetController()
+ *
+ * Summary:
+ * Returns the web controller for a given web view, or NULL if not
+ * bound to one.
+ *
+ * Parameters:
+ *
+ * inView:
+ * The view to inspect.
+ *
+ * Result:
+ * A web controller, or NULL.
+ *
+ * Availability:
+ * Mac OS X: in version 10.2 and later
+ * CarbonLib: not available
+ * Non-Carbon CFM: not available
+ */
+extern WebController*
+HIWebViewGetController(HIViewRef inView);
+
+extern WebController*
+WebControllerCreateWithHIView( HIViewRef inView, CFStringRef inName );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __HIWEBVIEW__ */
+
diff --git a/WebKit/Carbon.subproj/HIWebView.m b/WebKit/Carbon.subproj/HIWebView.m
new file mode 100644
index 0000000..4f84eaf
--- /dev/null
+++ b/WebKit/Carbon.subproj/HIWebView.m
@@ -0,0 +1,1400 @@
+/*
+ * HIWebView.c
+ * Synergy
+ *
+ * Created by Ed Voas on Tue Feb 11 2003.
+ * Copyright (c) 2003 __MyCompanyName__. All rights reserved.
+ *
+ */
+
+#include "HIWebViewPriv.h"
+//#include "HIWebController.h"
+
+#include "CarbonWindowAdapter.h"
+
+#include <AppKit/NSGraphicsContextPrivate.h>
+#include <CoreGraphics/CGSEvent.h>
+#include <WebKit/WebKit.h>
+#include "HIViewAdapter.h"
+
+extern Boolean GetEventPlatformEventRecord( EventRef inEvent, void * eventRec );
+
+struct HIWebView
+{
+ HIViewRef fViewRef;
+
+ WebView* fWebView;
+ NSView* fFirstResponder;
+ CarbonWindowAdapter * fKitWindow;
+};
+typedef struct HIWebView HIWebView;
+
+ at interface NSGraphicsContext (Secret)
+- (void)setCGContext:(CGContextRef)cgContext;
+ at end
+
+ at interface NSWindow(Secret)
+- (NSGraphicsContext *)_threadContext;
+- (NSView *)_borderView;
+- (void)_removeWindowRef;
+ at end
+
+ at interface NSEvent( Secret )
+- (NSEvent *)_initWithCGSEvent:(CGSEventRecord)cgsEvent eventRef:(void *)eventRef;
+ at end
+
+ at interface NSView( Secret )
+- (void) _setHIView:(HIViewRef)view;
+- (void) _clearDirtyRectsForTree;
+- (BOOL) _allowsContextMenus;
+ at end
+
+ at interface NSMenu( Secret )
+- (void)_popUpMenuWithEvent:(NSEvent*)event forView:(NSView*)view;
+ at end
+
+ at interface MenuItemProxy : NSObject <NSValidatedUserInterfaceItem> {
+ int _tag;
+ SEL _action;
+}
+
+- (id)initWithAction:(SEL)action;
+- (SEL)action;
+- (int)tag;
+
+ at end
+
+ at 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;
+}
+ at end
+
+
+ at implementation NSWindowGraphicsContext (NSHLTBAdditions)
+- (void)setCGContext:(CGContextRef)cgContext {
+ CGContextRetain(cgContext);
+ if (_cgsContext) {
+ CGContextRelease(_cgsContext);
+ }
+ _cgsContext = cgContext;
+}
+ at end
+
+static const OSType NSAppKitPropertyCreator = 'akit';
+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* 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 void HIWebViewRegisterClass( void );
+
+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 WindowCloseHandler( EventHandlerCallRef inCallRef, EventRef inEvent, void* inUserData );
+
+//----------------------------------------------------------------------------------
+// HIWebViewCreate
+//----------------------------------------------------------------------------------
+//
+OSStatus
+HIWebViewCreate( HIViewRef* outControl )
+{
+ OSStatus err;
+
+ HIWebViewRegisterClass();
+
+ err = HIObjectCreate( kHIWebViewClassID, NULL, (HIObjectRef*)outControl );
+
+ return err;
+}
+
+//----------------------------------------------------------------------------------
+// HIWebViewGetNSView
+//----------------------------------------------------------------------------------
+//
+NSView*
+HIWebViewGetNSView( HIViewRef inView )
+{
+ HIWebView* view = (HIWebView*)HIObjectDynamicCast( (HIObjectRef)inView, kHIWebViewClassID );
+ NSView* result = NULL;
+
+ if ( view )
+ result = view->fWebView;
+
+ return result;
+}
+
+//----------------------------------------------------------------------------------
+// HIWebViewGetController
+//----------------------------------------------------------------------------------
+//
+WebController*
+HIWebViewGetController( HIViewRef inControl )
+{
+ HIWebView* view = (HIWebView*)HIObjectDynamicCast( (HIObjectRef)inControl, kHIWebViewClassID );
+ WebController* result = NULL;
+
+ if ( view )
+ result = [[view->fWebView webFrame] controller];
+
+ return result;
+}
+
+extern WebController*
+WebControllerCreateWithHIView( HIViewRef inView, CFStringRef inName )
+{
+ NSView* view = HIWebViewGetNSView( inView );
+ WebController* result = NULL;
+
+ if ( view )
+ result = [[WebController alloc] initWithView: (WebView*)view frameName:nil setName:(NSString*)inName];
+
+ 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;
+
+ view->fWebView = [[WebView alloc] initWithFrame: frame];
+ [HIViewAdapter bindHIViewToNSView:inView nsView:view->fWebView];
+
+ view->fFirstResponder = NULL;
+ view->fKitWindow = NULL;
+ }
+
+ return view;
+}
+
+//----------------------------------------------------------------------------------
+// HIWebViewDestructor
+//----------------------------------------------------------------------------------
+//
+static void
+HIWebViewDestructor( HIWebView* inView )
+{
+ [HIViewAdapter unbindNSView:inView->fWebView];
+ [inView->fWebView release];
+
+ free( inView );
+}
+
+//----------------------------------------------------------------------------------
+// HIWebViewRegisterClass
+//----------------------------------------------------------------------------------
+//
+static 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;
+ CGContextRef temp;
+ Rect drawRect;
+ HIRect hiRect;
+
+ HIViewGetBounds( inView->fViewRef, &bounds );
+// CGContextStrokeRect( inContext, bounds );
+
+ temp = (CGContextRef)[[inView->fKitWindow _threadContext] graphicsPort];
+ CGContextRetain( temp );
+ [[inView->fKitWindow _threadContext] setCGContext: inContext];
+ [NSGraphicsContext setCurrentContext:[inView->fKitWindow _threadContext] ];
+
+ GetRegionBounds( limitRgn, &drawRect );
+
+ 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;
+
+ [inView->fWebView displayIfNeededInRect: *(NSRect*)&hiRect];
+
+ [[inView->fKitWindow _threadContext] setCGContext: temp];
+
+ CGContextRelease( temp );
+}
+
+//----------------------------------------------------------------------------------
+// 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 = CGRectGetMaxY( bounds );
+ temp.right = CGRectGetMaxX( bounds );
+
+ RectRgn( outRgn, &temp );
+ err = noErr;
+ }
+ }
+
+ return err;
+}
+
+//----------------------------------------------------------------------------------
+// GetRegion
+//----------------------------------------------------------------------------------
+//
+static WindowRef
+GetWindowRef( HIWebView* inView )
+{
+ return GetControlOwner( inView->fViewRef );
+}
+
+//----------------------------------------------------------------------------------
+// Click
+//----------------------------------------------------------------------------------
+//
+static OSStatus
+Click( HIWebView* inView, EventRef inEvent )
+{
+ CGSEventRecord eventRec;
+ NSEvent* kitEvent;
+ ControlRef focus;
+// NSView* targ;
+ EventRef newEvent;
+ Point where;
+ OSStatus err;
+ UInt32 modifiers;
+ Rect windRect;
+
+ GetEventPlatformEventRecord( inEvent, &eventRec );
+
+ // 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( NULL, kEventClassMouse, kEventMouseDown, GetEventTime( inEvent ), 0, &newEvent );
+ require_noerr( err, CantAllocNewEvent );
+
+ GetEventParameter( inEvent, kEventParamWindowMouseLocation, typeQDPoint, NULL,
+ sizeof( Point ), NULL, &where );
+ GetWindowBounds( GetWindowRef( inView ), kWindowStructureRgn, &windRect );
+ where.h += windRect.left;
+ where.v += windRect.top;
+
+ GetEventParameter( inEvent, kEventParamKeyModifiers, typeUInt32, NULL,
+ sizeof( UInt32 ), NULL, &modifiers );
+ SetEventParameter( newEvent, kEventParamMouseLocation, typeQDPoint, sizeof( Point ), &where );
+ SetEventParameter( newEvent, kEventParamKeyModifiers, typeUInt32, sizeof( UInt32 ), &modifiers );
+
+ kitEvent = [[NSEvent alloc] _initWithCGSEvent:(CGSEventRecord)eventRec eventRef:(void *)newEvent];
+
+ // Grab the keyboard focus
+ // ¥¥¥ FIX: Need to switch to a real part code, not focusnextpart. Have to handle
+ // subviews properly as well.
+
+ GetKeyboardFocus( GetWindowRef( inView ), &focus );
+ if ( focus != inView->fViewRef )
+ SetKeyboardFocus( GetWindowRef( inView ), inView->fViewRef, kControlFocusNextPart );
+
+// targ = [[inView->fKitWindow _borderView] hitTest:[kitEvent locationInWindow]];
+
+// [targ mouseDown:kitEvent];
+ [inView->fKitWindow sendEvent:kitEvent];
+
+ [kitEvent release];
+
+CantAllocNewEvent:
+ return noErr;
+}
+
+//----------------------------------------------------------------------------------
+// MouseUp
+//----------------------------------------------------------------------------------
+//
+static OSStatus
+MouseUp( HIWebView* inView, EventRef inEvent )
+{
+ CGSEventRecord eventRec;
+ NSEvent* kitEvent;
+// NSView* targ;
+
+ GetEventPlatformEventRecord( inEvent, &eventRec );
+ RetainEvent( inEvent );
+ kitEvent = [[NSEvent alloc] _initWithCGSEvent:(CGSEventRecord)eventRec eventRef:(void *)inEvent];
+
+// targ = [[inView->fKitWindow _borderView] hitTest:[kitEvent locationInWindow]];
+
+// [targ mouseUp:kitEvent];
+
+ [inView->fKitWindow sendEvent:kitEvent];
+
+ [kitEvent release];
+
+ return noErr;
+}
+
+//----------------------------------------------------------------------------------
+// MouseMoved
+//----------------------------------------------------------------------------------
+//
+static OSStatus
+MouseMoved( HIWebView* inView, EventRef inEvent )
+{
+ CGSEventRecord eventRec;
+ NSEvent* kitEvent;
+// NSView* targ;
+
+ GetEventPlatformEventRecord( inEvent, &eventRec );
+ RetainEvent( inEvent );
+ kitEvent = [[NSEvent alloc] _initWithCGSEvent:(CGSEventRecord)eventRec eventRef:(void *)inEvent];
+
+// targ = [[inView->fKitWindow _borderView] hitTest:[kitEvent locationInWindow]];
+
+// [targ mouseMoved:kitEvent];
+ [inView->fKitWindow sendEvent:kitEvent];
+
+ [kitEvent release];
+
+ return noErr;
+}
+
+//----------------------------------------------------------------------------------
+// MouseDragged
+//----------------------------------------------------------------------------------
+//
+static OSStatus
+MouseDragged( HIWebView* inView, EventRef inEvent )
+{
+ CGSEventRecord eventRec;
+ NSEvent* kitEvent;
+// NSView* targ;
+
+ GetEventPlatformEventRecord( inEvent, &eventRec );
+ RetainEvent( inEvent );
+ kitEvent = [[NSEvent alloc] _initWithCGSEvent:(CGSEventRecord)eventRec eventRef:(void *)inEvent];
+
+// targ = [[inView->fKitWindow _borderView] hitTest:[kitEvent locationInWindow]];
+
+// [targ mouseDragged:kitEvent];
+ [inView->fKitWindow sendEvent:kitEvent];
+
+ [kitEvent release];
+
+ return noErr;
+}
+
+//----------------------------------------------------------------------------------
+// MouseDragged
+//----------------------------------------------------------------------------------
+//
+static OSStatus
+MouseWheelMoved( HIWebView* inView, EventRef inEvent )
+{
+ CGSEventRecord eventRec;
+ NSEvent* kitEvent;
+// NSView* targ;
+
+ GetEventPlatformEventRecord( inEvent, &eventRec );
+ RetainEvent( inEvent );
+ kitEvent = [[NSEvent alloc] _initWithCGSEvent:(CGSEventRecord)eventRec eventRef:(void *)inEvent];
+
+// targ = [[inView->fKitWindow _borderView] hitTest:[kitEvent locationInWindow]];
+
+// [targ scrollWheel:kitEvent];
+ [inView->fKitWindow sendEvent:kitEvent];
+
+ [kitEvent release];
+
+ return noErr;
+}
+
+//----------------------------------------------------------------------------------
+// ContextMenuClick
+//----------------------------------------------------------------------------------
+//
+static OSStatus
+ContextMenuClick( HIWebView* inView, EventRef inEvent )
+{
+ CGSEventRecord eventRec;
+ NSEvent* kitEvent;
+ OSStatus result = eventNotHandledErr;
+ NSView* targ;
+
+ GetEventPlatformEventRecord( inEvent, &eventRec );
+ RetainEvent( inEvent );
+ kitEvent = [[NSEvent alloc] _initWithCGSEvent:(CGSEventRecord)eventRec eventRef:(void *)inEvent];
+
+ targ = [[inView->fKitWindow _borderView] hitTest:[kitEvent locationInWindow]];
+
+ if ( [targ _allowsContextMenus] )
+ {
+ NSMenu * contextMenu = [targ menuForEvent:kitEvent];
+
+ if ( contextMenu )
+ {
+ [contextMenu _popUpMenuWithEvent:kitEvent forView:targ];
+ result = noErr;
+ }
+ }
+
+ [kitEvent release];
+
+ return result;
+}
+
+//----------------------------------------------------------------------------------
+// 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 )
+ {
+ OSStatus err = GetWindowProperty(newWindow, NSAppKitPropertyCreator, NSCarbonWindowPropertyTag, sizeof(NSWindow *), NULL, &view->fKitWindow);
+ if ( err != noErr )
+ {
+ const EventTypeSpec kWindowEvents[] = { { kEventClassWindow, kEventWindowClosed } };
+
+ view->fKitWindow = [[CarbonWindowAdapter alloc] initWithCarbonWindowRef: newWindow takingOwnership: NO disableOrdering:NO carbon:YES];
+ SetWindowProperty(newWindow, NSAppKitPropertyCreator, NSCarbonWindowPropertyTag, sizeof(NSWindow *), &view->fKitWindow);
+
+ InstallWindowEventHandler( newWindow, WindowCloseHandler, GetEventTypeCount( kWindowEvents ), kWindowEvents, newWindow, NULL );
+ }
+
+ [[view->fKitWindow contentView] addSubview:view->fWebView];
+ SyncFrame( view );
+ }
+}
+
+//----------------------------------------------------------------------------------
+// WindowCloseHandler
+//----------------------------------------------------------------------------------
+//
+static OSStatus
+WindowCloseHandler( EventHandlerCallRef inCallRef, EventRef inEvent, void* inUserData )
+{
+ WindowRef window = (WindowRef)inUserData;
+ OSStatus err;
+ NSWindow* kitWindow;
+
+ err = GetWindowProperty( window, NSAppKitPropertyCreator, NSCarbonWindowPropertyTag, sizeof(NSWindow *), NULL, &kitWindow);
+ if ( err == noErr )
+ {
+ [kitWindow _removeWindowRef];
+ [kitWindow close];
+ }
+
+ return noErr;
+}
+
+
+//----------------------------------------------------------------------------------
+// SyncFrame
+//----------------------------------------------------------------------------------
+//
+static void
+SyncFrame( HIWebView* inView )
+{
+ HIViewRef parent = HIViewGetSuperview( inView->fViewRef );
+
+ if ( parent )
+ {
+ 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 );
+
+ [inView->fWebView setFrameOrigin: 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 );
+ partCodeToReturn = freshlyMadeFirstResponderView ? desiredFocus : kControlFocusNoPart;
+ //NSLog(freshlyMadeFirstResponderView ? @"Advanced the key focus." : @"Relinquished the key focus.");
+ }
+ else
+ {
+ // What's this?
+ check(false);
+ freshlyMadeFirstResponderView = nil;
+ partCodeToReturn = kControlFocusNoPart;
+ }
+
+ 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];
+
+ if ( [resp performSelector:@selector(validateUserInterfaceItem:) withObject: 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;
+
+ 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:
+ {
+ CGSEventRecord eventRec;
+ NSEvent* kitEvent;
+
+ GetEventPlatformEventRecord( inEvent, &eventRec );
+ RetainEvent( inEvent );
+ kitEvent = [[NSEvent alloc] _initWithCGSEvent:(CGSEventRecord)eventRec eventRef:(void *)inEvent];
+
+ [view->fKitWindow sendSuperEvent:kitEvent];
+
+ 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, typeLongInteger, 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, typeLongInteger, 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 kEventControlDragEnter:
+ case kEventControlDragLeave:
+ case kEventControlDragWithin:
+ {
+ DragRef drag;
+ bool likesDrag;
+
+ inEvent.GetParameter( kEventParamDragRef, &drag );
+
+ switch ( inEvent.GetKind() )
+ {
+ case kEventControlDragEnter:
+ likesDrag = DragEnter( drag );
+
+ // Why only if likesDrag? What if it doesn't? No parameter?
+ if ( likesDrag )
+ result = inEvent.SetParameter( kEventParamControlLikesDrag, likesDrag );
+ break;
+
+ case kEventControlDragLeave:
+ DragLeave( drag );
+ result = noErr;
+ break;
+
+ case kEventControlDragWithin:
+ DragWithin( drag );
+ result = noErr;
+ break;
+ }
+ }
+ break;
+
+ case kEventControlDragReceive:
+ {
+ DragRef drag;
+
+ inEvent.GetParameter( kEventParamDragRef, &drag );
+
+ result = DragReceive( drag );
+ }
+ 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;
+}
diff --git a/WebKit/Carbon.subproj/HIWebViewPriv.h b/WebKit/Carbon.subproj/HIWebViewPriv.h
new file mode 100644
index 0000000..7863a19
--- /dev/null
+++ b/WebKit/Carbon.subproj/HIWebViewPriv.h
@@ -0,0 +1,27 @@
+/*
+ * HIWebViewPriv.h
+ * Synergy
+ *
+ * Created by Ed Voas on Tue Feb 11 2003.
+ * Copyright (c) 2003 __MyCompanyName__. All rights reserved.
+ *
+ */
+
+#ifndef WebKit_HIWEBVIEWPRIV
+#define WebKit_HIWEBVIEWPRIV
+
+#include <Carbon/Carbon.h>
+#include <AppKit/AppKit.h>
+#include "HIWebView.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern NSView* HIWebViewGetNSView( HIViewRef inView );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // WebKit_HIWEBVIEWPRIV
diff --git a/WebKit/ChangeLog b/WebKit/ChangeLog
index 063289f..9d1eee5 100644
--- a/WebKit/ChangeLog
+++ b/WebKit/ChangeLog
@@ -1,3 +1,105 @@
+2003-03-06 Ed Voas voas at apple.com
+
+ Reviewed by Richard.
+
+ First cut of Carbon view support. It will need tweaking as we go,
+ but I think I finally have all the assertions taken care of, and
+ I also believe that I have the drawing glitches all sorted out now.
+
+ * Carbon.subproj/CarbonUtils.h: Added.
+ * Carbon.subproj/CarbonUtils.m: Added.
+ (InitWebKitForCarbon):
+ (PoolCleaner):
+ (ConvertNSImageToCGImageRef):
+ * Carbon.subproj/CarbonWindowAdapter.h: Added.
+ * Carbon.subproj/CarbonWindowAdapter.m: Added.
+ (+[CarbonWindowAdapter frameViewClassForStyleMask:]):
+ (-[CarbonWindowAdapter initWithContentRect:styleMask:backing:defer:]):
+ (-[CarbonWindowAdapter initWithCarbonWindowRef:takingOwnership:disableOrdering:carbon:]):
+ (-[CarbonWindowAdapter setViewsNeedDisplay:]):
+ (-[CarbonWindowAdapter initWithCarbonWindowRef:takingOwnership:]):
+ (-[CarbonWindowAdapter dealloc]):
+ (-[CarbonWindowAdapter windowRef]):
+ (-[CarbonWindowAdapter _hasWindowRef]):
+ (-[CarbonWindowAdapter _managesWindowRef]):
+ (-[CarbonWindowAdapter _removeWindowRef]):
+ (-[CarbonWindowAdapter _carbonWindowClass]):
+ (-[CarbonWindowAdapter reconcileToCarbonWindowBounds]):
+ (-[CarbonWindowAdapter sendSuperEvent:]):
+ (-[CarbonWindowAdapter _cancelKey:]):
+ (-[CarbonWindowAdapter _commonAwake]):
+ (-[CarbonWindowAdapter _destroyRealWindow:]):
+ (-[CarbonWindowAdapter _oldPlaceWindow:]):
+ (-[CarbonWindowAdapter _termWindowIfOwner]):
+ (-[CarbonWindowAdapter _windowMovedToRect:]):
+ (-[CarbonWindowAdapter constrainFrameRect:toScreen:]):
+ (-[CarbonWindowAdapter selectKeyViewFollowingView:]):
+ (-[CarbonWindowAdapter selectKeyViewPrecedingView:]):
+ (-[CarbonWindowAdapter makeKeyWindow]):
+ (-[CarbonWindowAdapter canBecomeKeyWindow]):
+ (-[CarbonWindowAdapter canBecomeMainWindow]):
+ (-[CarbonWindowAdapter encodeWithCoder:]):
+ (-[CarbonWindowAdapter initWithCoder:]):
+ (-[CarbonWindowAdapter setContentView:]):
+ (-[CarbonWindowAdapter worksWhenModal]):
+ (-[CarbonWindowAdapter _setModalWindowLevel]):
+ (-[CarbonWindowAdapter _clearModalWindowLevel]):
+ (-[CarbonWindowAdapter carbonHICommandIDFromActionSelector:]):
+ (-[CarbonWindowAdapter sendCarbonProcessHICommandEvent:]):
+ (-[CarbonWindowAdapter sendCarbonUpdateHICommandStatusEvent:withMenuRef:andMenuItemIndex:]):
+ (-[CarbonWindowAdapter _handleRootBoundsChanged]):
+ (-[CarbonWindowAdapter _handleContentBoundsChanged]):
+ (-[CarbonWindowAdapter _handleCarbonEvent:callRef:]):
+ (NSCarbonWindowHandleEvent):
+ * Carbon.subproj/CarbonWindowContentView.h: Added.
+ * Carbon.subproj/CarbonWindowContentView.m: Added.
+ * Carbon.subproj/CarbonWindowFrame.h: Added.
+ * Carbon.subproj/CarbonWindowFrame.m: Added.
+ (+[CarbonWindowFrame frameRectForContentRect:styleMask:]):
+ (+[CarbonWindowFrame contentRectForFrameRect:styleMask:]):
+ (+[CarbonWindowFrame minFrameSizeForMinContentSize:styleMask:]):
+ (-[CarbonWindowFrame frameRectForContentRect:styleMask:]):
+ (-[CarbonWindowFrame contentRectForFrameRect:styleMask:]):
+ (-[CarbonWindowFrame minFrameSizeForMinContentSize:styleMask:]):
+ (-[CarbonWindowFrame initWithFrame:styleMask:owner:]):
+ (-[CarbonWindowFrame dealloc]):
+ (-[CarbonWindowFrame _setFrameNeedsDisplay:]):
+ (-[CarbonWindowFrame _setSheet:]):
+ (-[CarbonWindowFrame _updateButtonState]):
+ (-[CarbonWindowFrame _windowChangedKeyState]):
+ (-[CarbonWindowFrame _showToolbarWithAnimation:]):
+ (-[CarbonWindowFrame _hideToolbarWithAnimation:]):
+ (-[CarbonWindowFrame closeButton]):
+ (-[CarbonWindowFrame styleMask]):
+ (-[CarbonWindowFrame dragRectForFrameRect:]):
+ (-[CarbonWindowFrame isOpaque]):
+ (-[CarbonWindowFrame minimizeButton]):
+ (-[CarbonWindowFrame setTitle:]):
+ (-[CarbonWindowFrame title]):
+ (-[CarbonWindowFrame _sheetHeightAdjustment]):
+ (-[CarbonWindowFrame _maxTitlebarTitleRect]):
+ (-[CarbonWindowFrame _clearDragMargins]):
+ (-[CarbonWindowFrame _resetDragMargins]):
+ * Carbon.subproj/HIViewAdapter.h: Added.
+ * Carbon.subproj/HIViewAdapter.m: Added.
+ (+[HIViewAdapter bindHIViewToNSView:nsView:]):
+ (+[HIViewAdapter getHIViewForNSView:]):
+ (+[HIViewAdapter unbindNSView:]):
+ (-[HIViewAdapter initWithFrame:view:]):
+ (-[HIViewAdapter hiView]):
+ (-[HIViewAdapter nextValidKeyView]):
+ (-[HIViewAdapter setNeedsDisplay:]):
+ (-[HIViewAdapter setNeedsDisplayInRect:]):
+ (-[CarbonSheetInterceptor _orderFrontRelativeToWindow:]):
+ (-[CarbonSheetInterceptor _orderOutRelativeToWindow:]):
+ * Carbon.subproj/HIWebView.h: Added.
+ * Carbon.subproj/HIWebView.m: Added.
+ (if):
+ (switch):
+ * Carbon.subproj/HIWebViewPriv.h: Added.
+ * WebKit.exp:
+ * WebKit.pbproj/project.pbxproj:
+
=== Safari-65 ===
2003-03-05 Richard Williamson <rjw at apple.com>
diff --git a/WebKit/WebKit.exp b/WebKit/WebKit.exp
index 6f0e3e1..f4d19cf 100644
--- a/WebKit/WebKit.exp
+++ b/WebKit/WebKit.exp
@@ -64,3 +64,14 @@ _WebIconSmallSize
_WebModifiedBookmarkKey
_WebURLNamePboardType
_WebURLPboardType
+
+##
+## Carbon Support
+##
+
+_WebControllerCreateWithHIView
+_HIWebViewGetController
+_HIWebViewCreate
+_ConvertNSImageToCGImageRef
+_InitWebKitForCarbon
+
diff --git a/WebKit/WebKit.pbproj/project.pbxproj b/WebKit/WebKit.pbproj/project.pbxproj
index 98bcf42..3718ff2 100644
--- a/WebKit/WebKit.pbproj/project.pbxproj
+++ b/WebKit/WebKit.pbproj/project.pbxproj
@@ -97,6 +97,7 @@
089C1665FE841158C02AAC07,
F5B36B400281DE87018635CB,
9C7CABBB0190A37C0ECA16EA,
+ F7EBEE5903F9DB2203CA0DE6,
0867D69AFE84028FC02AAC07,
034768DFFF38A50411DB9C8B,
);
@@ -109,9 +110,9 @@
F5C2869302846DCD018635CA,
F5C2869402846DCD018635CA,
F5C2869502846DCD018635CA,
- F8216299029F4FB501000131,
- F821629A029F4FB501000131,
- F821629B029F4FB501000131,
+ F738C9E903FAD3DF0321FBE0,
+ F738C9EA03FAD3DF0321FBE0,
+ F738C9EB03FAD3DF0321FBE0,
936F62C1039DF33B008635CE,
);
isa = PBXGroup;
@@ -303,6 +304,13 @@
8466AEDE03F1F82100CA2ACA,
8324709A03F32305003026AC,
2D36FD5F03F78F9E00A80166,
+ F7EBEEAF03F9DBA103CA0DE6,
+ F7EBEEB103F9DBA103CA0DE6,
+ F7EBEEB303F9DBA103CA0DE6,
+ F7EBEEB903F9DBA103CA0DE6,
+ F7EBEEC903F9DBA103CA0DE6,
+ F7EBEECB03F9DBA103CA0DE6,
+ F79B974A04019934036909D2,
700BC50D04144DA100A80182,
70BC9ED904144FC500A80182,
70BC9EDC0414514E00A80182,
@@ -420,7 +428,13 @@
832B2D1703B10990009CF105,
84A992C503CE696800CA2ACA,
2D81DAB503EB0B2D00A80166,
- 83730F9903FB1E660004736E,
+ F7FE6303040C27B003CA0DE6,
+ F7FE6304040C27B103CA0DE6,
+ F7FE6305040C27B203CA0DE6,
+ F7FE6306040C27B203CA0DE6,
+ F7FE630D040C27BC03CA0DE6,
+ F7FE6315040C27C703CA0DE6,
+ F7FE633E040C4AFC03CA0DE6,
700BC50E04144DA100A80182,
70BC9ED704144F3200A80182,
70BC9EDD0414514E00A80182,
@@ -434,10 +448,10 @@
F5C287BB02846DCD018635CA,
F5C287BC02846DCD018635CA,
F5C287BD02846DCD018635CA,
- F82162D8029F4FB501000131,
- F82162D9029F4FB501000131,
- F52BD8BA02DF4FBD018635CA,
936F62C2039DF33B008635CE,
+ F738CA5703FAD3DF0321FBE0,
+ F738CA5803FAD3DF0321FBE0,
+ F738CA5903FAD3DF0321FBE0,
);
isa = PBXFrameworksBuildPhase;
runOnlyForDeploymentPostprocessing = 0;
@@ -1915,12 +1929,6 @@
path = WebKitErrors.m;
refType = 4;
};
- 83730F9903FB1E660004736E = {
- fileRef = 83730F9803FB1E660004736E;
- isa = PBXBuildFile;
- settings = {
- };
- };
8398847A03426FB000BC5F5E = {
fileEncoding = 4;
isa = PBXFileReference;
@@ -2966,12 +2974,6 @@
);
};
};
- F52BD8BA02DF4FBD018635CA = {
- fileRef = F8216299029F4FB501000131;
- isa = PBXBuildFile;
- settings = {
- };
- };
F52CA6BD02DF9D0F018635CA = {
children = (
35081D9202B6D4D80ACA2ACA,
@@ -3886,38 +3888,274 @@
//F52
//F53
//F54
-//F80
-//F81
-//F82
-//F83
-//F84
- F8216299029F4FB501000131 = {
+//F70
+//F71
+//F72
+//F73
+//F74
+ F738C9E903FAD3DF0321FBE0 = {
isa = PBXFrameworkReference;
- path = JavaScriptCore.framework;
- refType = 3;
+ name = JavaScriptCore.framework;
+ path = build/JavaScriptCore.framework;
+ refType = 4;
};
- F821629A029F4FB501000131 = {
+ F738C9EA03FAD3DF0321FBE0 = {
isa = PBXFrameworkReference;
- path = WebCore.framework;
- refType = 3;
+ name = WebCore.framework;
+ path = build/WebCore.framework;
+ refType = 4;
};
- F821629B029F4FB501000131 = {
+ F738C9EB03FAD3DF0321FBE0 = {
isa = PBXFrameworkReference;
- path = WebFoundation.framework;
- refType = 3;
+ name = WebFoundation.framework;
+ path = build/WebFoundation.framework;
+ refType = 4;
+ };
+ F738CA5703FAD3DF0321FBE0 = {
+ fileRef = F738C9E903FAD3DF0321FBE0;
+ isa = PBXBuildFile;
+ settings = {
+ };
+ };
+ F738CA5803FAD3DF0321FBE0 = {
+ fileRef = F738C9EA03FAD3DF0321FBE0;
+ isa = PBXBuildFile;
+ settings = {
+ };
+ };
+ F738CA5903FAD3DF0321FBE0 = {
+ fileRef = F738C9EB03FAD3DF0321FBE0;
+ isa = PBXBuildFile;
+ settings = {
+ };
+ };
+ F79B974804019934036909D2 = {
+ fileEncoding = 30;
+ isa = PBXFileReference;
+ path = CarbonUtils.h;
+ refType = 4;
+ };
+ F79B974904019934036909D2 = {
+ fileEncoding = 30;
+ isa = PBXFileReference;
+ path = CarbonUtils.m;
+ refType = 4;
+ usesTabs = 0;
+ };
+ F79B974A04019934036909D2 = {
+ fileRef = F79B974804019934036909D2;
+ isa = PBXBuildFile;
+ settings = {
+ ATTRIBUTES = (
+ Public,
+ );
+ };
+ };
+ F7EBEE5903F9DB2203CA0DE6 = {
+ children = (
+ F7EBEECF03F9DBBD03CA0DE6,
+ F7EBEED203F9DBFE03CA0DE6,
+ F7EBEED103F9DBEB03CA0DE6,
+ );
+ isa = PBXGroup;
+ name = "Carbon Support";
+ path = Carbon.subproj;
+ refType = 2;
+ };
+ F7EBEE9003F9DBA103CA0DE6 = {
+ fileEncoding = 30;
+ isa = PBXFileReference;
+ path = CarbonWindowAdapter.h;
+ refType = 4;
+ };
+ F7EBEE9103F9DBA103CA0DE6 = {
+ fileEncoding = 30;
+ isa = PBXFileReference;
+ path = CarbonWindowAdapter.m;
+ refType = 4;
+ };
+ F7EBEE9203F9DBA103CA0DE6 = {
+ fileEncoding = 30;
+ isa = PBXFileReference;
+ path = CarbonWindowContentView.h;
+ refType = 4;
+ };
+ F7EBEE9303F9DBA103CA0DE6 = {
+ fileEncoding = 30;
+ isa = PBXFileReference;
+ path = CarbonWindowContentView.m;
+ refType = 4;
+ };
+ F7EBEE9403F9DBA103CA0DE6 = {
+ fileEncoding = 30;
+ isa = PBXFileReference;
+ path = CarbonWindowFrame.h;
+ refType = 4;
+ };
+ F7EBEE9503F9DBA103CA0DE6 = {
+ fileEncoding = 30;
+ isa = PBXFileReference;
+ path = CarbonWindowFrame.m;
+ refType = 4;
+ };
+ F7EBEE9A03F9DBA103CA0DE6 = {
+ fileEncoding = 30;
+ isa = PBXFileReference;
+ path = HIViewAdapter.h;
+ refType = 4;
+ };
+ F7EBEE9B03F9DBA103CA0DE6 = {
+ fileEncoding = 30;
+ isa = PBXFileReference;
+ path = HIViewAdapter.m;
+ refType = 4;
+ };
+ F7EBEEAA03F9DBA103CA0DE6 = {
+ fileEncoding = 30;
+ isa = PBXFileReference;
+ path = HIWebView.h;
+ refType = 4;
+ };
+ F7EBEEAB03F9DBA103CA0DE6 = {
+ fileEncoding = 30;
+ isa = PBXFileReference;
+ path = HIWebView.m;
+ refType = 4;
+ usesTabs = 0;
+ };
+ F7EBEEAC03F9DBA103CA0DE6 = {
+ fileEncoding = 30;
+ isa = PBXFileReference;
+ path = HIWebViewPriv.h;
+ refType = 4;
+ };
+ F7EBEEAF03F9DBA103CA0DE6 = {
+ fileRef = F7EBEE9003F9DBA103CA0DE6;
+ isa = PBXBuildFile;
+ settings = {
+ };
+ };
+ F7EBEEB103F9DBA103CA0DE6 = {
+ fileRef = F7EBEE9203F9DBA103CA0DE6;
+ isa = PBXBuildFile;
+ settings = {
+ };
};
- F82162D8029F4FB501000131 = {
- fileRef = F821629A029F4FB501000131;
+ F7EBEEB303F9DBA103CA0DE6 = {
+ fileRef = F7EBEE9403F9DBA103CA0DE6;
isa = PBXBuildFile;
settings = {
};
};
- F82162D9029F4FB501000131 = {
- fileRef = F821629B029F4FB501000131;
+ F7EBEEB903F9DBA103CA0DE6 = {
+ fileRef = F7EBEE9A03F9DBA103CA0DE6;
isa = PBXBuildFile;
settings = {
};
};
+ F7EBEEC903F9DBA103CA0DE6 = {
+ fileRef = F7EBEEAA03F9DBA103CA0DE6;
+ isa = PBXBuildFile;
+ settings = {
+ ATTRIBUTES = (
+ Public,
+ );
+ };
+ };
+ F7EBEECB03F9DBA103CA0DE6 = {
+ fileRef = F7EBEEAC03F9DBA103CA0DE6;
+ isa = PBXBuildFile;
+ settings = {
+ ATTRIBUTES = (
+ );
+ };
+ };
+ F7EBEECF03F9DBBD03CA0DE6 = {
+ children = (
+ F7EBEE9003F9DBA103CA0DE6,
+ F7EBEE9103F9DBA103CA0DE6,
+ F7EBEE9203F9DBA103CA0DE6,
+ F7EBEE9303F9DBA103CA0DE6,
+ F7EBEE9403F9DBA103CA0DE6,
+ F7EBEE9503F9DBA103CA0DE6,
+ F7EBEE9A03F9DBA103CA0DE6,
+ F7EBEE9B03F9DBA103CA0DE6,
+ );
+ isa = PBXGroup;
+ name = "AppKit Overrides";
+ refType = 4;
+ };
+ F7EBEED103F9DBEB03CA0DE6 = {
+ children = (
+ F7EBEEAA03F9DBA103CA0DE6,
+ F7EBEEAB03F9DBA103CA0DE6,
+ F7EBEEAC03F9DBA103CA0DE6,
+ );
+ isa = PBXGroup;
+ name = "C API";
+ refType = 4;
+ };
+ F7EBEED203F9DBFE03CA0DE6 = {
+ children = (
+ F79B974804019934036909D2,
+ F79B974904019934036909D2,
+ );
+ isa = PBXGroup;
+ name = Glue;
+ refType = 4;
+ };
+ F7FE6303040C27B003CA0DE6 = {
+ fileRef = F7EBEE9103F9DBA103CA0DE6;
+ isa = PBXBuildFile;
+ settings = {
+ };
+ };
+ F7FE6304040C27B103CA0DE6 = {
+ fileRef = F7EBEE9303F9DBA103CA0DE6;
+ isa = PBXBuildFile;
+ settings = {
+ };
+ };
+ F7FE6305040C27B203CA0DE6 = {
+ fileRef = F7EBEE9503F9DBA103CA0DE6;
+ isa = PBXBuildFile;
+ settings = {
+ };
+ };
+ F7FE6306040C27B203CA0DE6 = {
+ fileRef = F7EBEE9B03F9DBA103CA0DE6;
+ isa = PBXBuildFile;
+ settings = {
+ };
+ };
+ F7FE630D040C27BC03CA0DE6 = {
+ fileRef = F79B974904019934036909D2;
+ isa = PBXBuildFile;
+ settings = {
+ };
+ };
+ F7FE6315040C27C703CA0DE6 = {
+ fileRef = F7EBEEAB03F9DBA103CA0DE6;
+ isa = PBXBuildFile;
+ settings = {
+ };
+ };
+ F7FE633E040C4AFC03CA0DE6 = {
+ fileRef = 83730F9803FB1E660004736E;
+ isa = PBXBuildFile;
+ settings = {
+ };
+ };
+//F70
+//F71
+//F72
+//F73
+//F74
+//F80
+//F81
+//F82
+//F83
+//F84
F8CA15B4029A399401000122 = {
children = (
F8CA15B5029A39D901000122,
--
WebKit Debian packaging
More information about the Pkg-webkit-commits
mailing list