1 /*

     2  * Copyright (C) 2005, 2006, 2007 Apple Inc. All rights reserved.

     3  *

     4  * Redistribution and use in source and binary forms, with or without

     5  * modification, are permitted provided that the following conditions

     6  * are met:

     7  *

     8  * 1.  Redistributions of source code must retain the above copyright

     9  *     notice, this list of conditions and the following disclaimer. 

    10  * 2.  Redistributions in binary form must reproduce the above copyright

    11  *     notice, this list of conditions and the following disclaimer in the

    12  *     documentation and/or other materials provided with the distribution. 

    13  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of

    14  *     its contributors may be used to endorse or promote products derived

    15  *     from this software without specific prior written permission. 

    16  *

    17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY

    18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

    19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

    20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY

    21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

    22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

    23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

    24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

    25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

    26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    27  */

    28 

    29 #ifndef __LP64__

    30 

    31 #import "WebBaseNetscapePluginView.h"

    32 

    33 #import "WebDataSourceInternal.h"

    34 #import "WebDefaultUIDelegate.h"

    35 #import "WebFrameBridge.h"

    36 #import "WebFrameInternal.h" 

    37 #import "WebFrameView.h"

    38 #import "WebGraphicsExtras.h"

    39 #import "WebKitLogging.h"

    40 #import "WebKitNSStringExtras.h"

    41 #import "WebKitSystemInterface.h"

    42 #import "WebNSDataExtras.h"

    43 #import "WebNSDictionaryExtras.h"

    44 #import "WebNSObjectExtras.h"

    45 #import "WebNSURLExtras.h"

    46 #import "WebNSURLRequestExtras.h"

    47 #import "WebNSViewExtras.h"

    48 #import "WebNetscapePluginPackage.h"

    49 #import "WebNetscapePluginStream.h"

    50 #import "WebNullPluginView.h"

    51 #import "WebPreferences.h"

    52 #import "WebViewInternal.h"

    53 #import <Carbon/Carbon.h>

    54 #import <JavaScriptCore/Assertions.h>

    55 #import <JavaScriptCore/JSLock.h>

    56 #import <JavaScriptCore/npruntime_impl.h>

    57 #import <WebCore/Document.h>

    58 #import <WebCore/Element.h>

    59 #import <WebCore/Frame.h> 

    60 #import <WebCore/FrameLoader.h> 

    61 #import <WebCore/FrameTree.h> 

    62 #import <WebCore/Page.h> 

    63 #import <WebCore/SoftLinking.h> 

    64 #import <WebCore/WebCoreObjCExtras.h>

    65 #import <WebKit/DOMPrivate.h>

    66 #import <WebKit/WebUIDelegate.h>

    67 #import <objc/objc-runtime.h>

    68 

    69 using namespace WebCore;

    70 

    71 // Send null events 50 times a second when active, so plug-ins like Flash get high frame rates.

    72 #define NullEventIntervalActive         0.02

    73 #define NullEventIntervalNotActive      0.25

    74 

    75 #define LoginWindowDidSwitchFromUserNotification    @"WebLoginWindowDidSwitchFromUserNotification"

    76 #define LoginWindowDidSwitchToUserNotification      @"WebLoginWindowDidSwitchToUserNotification"

    77 

    78 SOFT_LINK_FRAMEWORK(OpenGL)

    79 SOFT_LINK_FRAMEWORK(AGL)

    80 

    81 SOFT_LINK(OpenGL, CGLGetOffScreen, CGLError, (CGLContextObj ctx, GLsizei *width, GLsizei *height, GLint *rowbytes, void **baseaddr), (ctx, width, height, rowbytes, baseaddr))

    82 SOFT_LINK(OpenGL, CGLSetOffScreen, CGLError, (CGLContextObj ctx, GLsizei width, GLsizei height, GLint rowbytes, void *baseaddr), (ctx, width, height, rowbytes, baseaddr))

    83 SOFT_LINK(OpenGL, glViewport, void, (GLint x, GLint y, GLsizei width, GLsizei height), (x, y, width, height))

    84 SOFT_LINK(AGL, aglCreateContext, AGLContext, (AGLPixelFormat pix, AGLContext share), (pix, share))

    85 SOFT_LINK(AGL, aglSetWindowRef, GLboolean, (AGLContext ctx, WindowRef window), (ctx, window))

    86 SOFT_LINK(AGL, aglSetDrawable, GLboolean, (AGLContext ctx, AGLDrawable draw), (ctx, draw))

    87 #ifndef BUILDING_ON_TIGER

    88 SOFT_LINK(AGL, aglChoosePixelFormat, AGLPixelFormat, (const void *gdevs, GLint ndev, const GLint *attribs), (gdevs, ndev, attribs))

    89 #else

    90 SOFT_LINK(AGL, aglChoosePixelFormat, AGLPixelFormat, (const AGLDevice *gdevs, GLint ndev, const GLint *attribs), (gdevs, ndev, attribs))

    91 #endif

    92 SOFT_LINK(AGL, aglDestroyPixelFormat, void, (AGLPixelFormat pix), (pix))

    93 SOFT_LINK(AGL, aglDestroyContext, GLboolean, (AGLContext ctx), (ctx))

    94 SOFT_LINK(AGL, aglGetCGLContext, GLboolean, (AGLContext ctx, void **cgl_ctx), (ctx, cgl_ctx))

    95 SOFT_LINK(AGL, aglGetCurrentContext, AGLContext, (void), ())

    96 SOFT_LINK(AGL, aglSetCurrentContext, GLboolean, (AGLContext ctx), (ctx))

    97 SOFT_LINK(AGL, aglGetError, GLenum, (void), ())

    98 SOFT_LINK(AGL, aglUpdateContext, GLboolean, (AGLContext ctx), (ctx))

    99 SOFT_LINK(AGL, aglErrorString, const GLubyte *, (GLenum code), (code))

   100 

   101 @interface WebBaseNetscapePluginView (Internal)

   102 - (void)_viewHasMoved;

   103 - (NPError)_createPlugin;

   104 - (void)_destroyPlugin;

   105 - (NSBitmapImageRep *)_printedPluginBitmap;

   106 - (BOOL)_createAGLContextIfNeeded;

   107 - (BOOL)_createWindowedAGLContext;

   108 - (BOOL)_createWindowlessAGLContext;

   109 - (CGLContextObj)_cglContext;

   110 - (BOOL)_getAGLOffscreenBuffer:(GLvoid **)outBuffer width:(GLsizei *)outWidth height:(GLsizei *)outHeight;

   111 - (void)_destroyAGLContext;

   112 - (void)_reshapeAGLWindow;

   113 - (void)_hideAGLWindow;

   114 - (NSImage *)_aglOffscreenImageForDrawingInRect:(NSRect)drawingInRect;

   115 - (void)_redeliverStream;

   116 @end

   117 

   118 static WebBaseNetscapePluginView *currentPluginView = nil;

   119 

   120 typedef struct OpaquePortState* PortState;

   121 

   122 #ifndef NP_NO_QUICKDRAW

   123 

   124 // QuickDraw is not available in 64-bit

   125 

   126 typedef struct {

   127     GrafPtr oldPort;

   128     GDHandle oldDevice;

   129     Point oldOrigin;

   130     RgnHandle oldClipRegion;

   131     RgnHandle oldVisibleRegion;

   132     RgnHandle clipRegion;

   133     BOOL forUpdate;

   134 } PortState_QD;

   135 

   136 #endif /* NP_NO_QUICKDRAW */

   137 

   138 typedef struct {

   139     CGContextRef context;

   140 } PortState_CG;

   141 

   142 typedef struct {

   143     AGLContext oldContext;

   144 } PortState_GL;

   145 

   146 @interface WebPluginRequest : NSObject

   147 {

   148     NSURLRequest *_request;

   149     NSString *_frameName;

   150     void *_notifyData;

   151     BOOL _didStartFromUserGesture;

   152     BOOL _sendNotification;

   153 }

   154 

   155 - (id)initWithRequest:(NSURLRequest *)request frameName:(NSString *)frameName notifyData:(void *)notifyData sendNotification:(BOOL)sendNotification didStartFromUserGesture:(BOOL)currentEventIsUserGesture;

   156 

   157 - (NSURLRequest *)request;

   158 - (NSString *)frameName;

   159 - (void *)notifyData;

   160 - (BOOL)isCurrentEventUserGesture;

   161 - (BOOL)sendNotification;

   162 

   163 @end

   164 

   165 @interface NSData (WebPluginDataExtras)

   166 - (BOOL)_web_startsWithBlankLine;

   167 - (NSInteger)_web_locationAfterFirstBlankLine;

   168 @end

   169 

   170 static OSStatus TSMEventHandler(EventHandlerCallRef inHandlerRef, EventRef inEvent, void *pluginView);

   171 

   172 @interface WebBaseNetscapePluginView (ForwardDeclarations)

   173 - (void)setWindowIfNecessary;

   174 - (NPError)loadRequest:(NSMutableURLRequest *)request inTarget:(const char *)cTarget withNotifyData:(void *)notifyData sendNotification:(BOOL)sendNotification;

   175 @end

   176 

   177 @implementation WebBaseNetscapePluginView

   178 

   179 + (void)initialize

   180 {

   181 #ifndef BUILDING_ON_TIGER

   182     WebCoreObjCFinalizeOnMainThread(self);

   183 #endif

   184     WKSendUserChangeNotifications();

   185 }

   186 

   187 #pragma mark EVENTS

   188 

   189 + (void)getCarbonEvent:(EventRecord *)carbonEvent

   190 {

   191     carbonEvent->what = nullEvent;

   192     carbonEvent->message = 0;

   193     carbonEvent->when = TickCount();

   194     

   195     GetGlobalMouse(&carbonEvent->where);

   196     carbonEvent->where.h = static_cast<short>(carbonEvent->where.h * HIGetScaleFactor());

   197     carbonEvent->where.v = static_cast<short>(carbonEvent->where.v * HIGetScaleFactor());

   198     carbonEvent->modifiers = GetCurrentKeyModifiers();

   199     if (!Button())

   200         carbonEvent->modifiers |= btnState;

   201 }

   202 

   203 - (void)getCarbonEvent:(EventRecord *)carbonEvent

   204 {

   205     [[self class] getCarbonEvent:carbonEvent];

   206 }

   207 

   208 - (EventModifiers)modifiersForEvent:(NSEvent *)event

   209 {

   210     EventModifiers modifiers;

   211     unsigned int modifierFlags = [event modifierFlags];

   212     NSEventType eventType = [event type];

   213     

   214     modifiers = 0;

   215     

   216     if (eventType != NSLeftMouseDown && eventType != NSRightMouseDown)

   217         modifiers |= btnState;

   218     

   219     if (modifierFlags & NSCommandKeyMask)

   220         modifiers |= cmdKey;

   221     

   222     if (modifierFlags & NSShiftKeyMask)

   223         modifiers |= shiftKey;

   224 

   225     if (modifierFlags & NSAlphaShiftKeyMask)

   226         modifiers |= alphaLock;

   227 

   228     if (modifierFlags & NSAlternateKeyMask)

   229         modifiers |= optionKey;

   230 

   231     if (modifierFlags & NSControlKeyMask || eventType == NSRightMouseDown)

   232         modifiers |= controlKey;

   233     

   234     return modifiers;

   235 }

   236 

   237 - (void)getCarbonEvent:(EventRecord *)carbonEvent withEvent:(NSEvent *)cocoaEvent

   238 {

   239     if (WKConvertNSEventToCarbonEvent(carbonEvent, cocoaEvent)) {

   240         carbonEvent->where.h = static_cast<short>(carbonEvent->where.h * HIGetScaleFactor());

   241         carbonEvent->where.v = static_cast<short>(carbonEvent->where.v * HIGetScaleFactor());

   242         return;

   243     }

   244     

   245     NSPoint where = [[cocoaEvent window] convertBaseToScreen:[cocoaEvent locationInWindow]];

   246         

   247     carbonEvent->what = nullEvent;

   248     carbonEvent->message = 0;

   249     carbonEvent->when = (UInt32)([cocoaEvent timestamp] * 60); // seconds to ticks

   250     carbonEvent->where.h = (short)where.x;

   251     carbonEvent->where.v = (short)(NSMaxY([[[NSScreen screens] objectAtIndex:0] frame]) - where.y);

   252     carbonEvent->modifiers = [self modifiersForEvent:cocoaEvent];

   253 }

   254 

   255 - (BOOL)superviewsHaveSuperviews

   256 {

   257     NSView *contentView = [[self window] contentView];

   258     NSView *view;

   259     for (view = self; view != nil; view = [view superview]) { 

   260         if (view == contentView) {

   261             return YES;

   262         }

   263     }

   264     return NO;

   265 }

   266 

   267 #ifndef NP_NO_QUICKDRAW

   268 

   269 // The WindowRef created by -[NSWindow windowRef] has a QuickDraw GrafPort that covers 

   270 // the entire window frame (or structure region to use the Carbon term) rather then just the window content.

   271 // We can remove this when <rdar://problem/4201099> is fixed.

   272 - (void)fixWindowPort

   273 {

   274     ASSERT(drawingModel == NPDrawingModelQuickDraw);

   275     

   276     NSWindow *currentWindow = [self currentWindow];

   277     if ([currentWindow isKindOfClass:objc_getClass("NSCarbonWindow")])

   278         return;

   279     

   280     float windowHeight = [currentWindow frame].size.height;

   281     NSView *contentView = [currentWindow contentView];

   282     NSRect contentRect = [contentView convertRect:[contentView frame] toView:nil]; // convert to window-relative coordinates

   283     

   284     CGrafPtr oldPort;

   285     GetPort(&oldPort);    

   286     SetPort(GetWindowPort((WindowRef)[currentWindow windowRef]));

   287     

   288     MovePortTo(static_cast<short>(contentRect.origin.x), /* Flip Y */ static_cast<short>(windowHeight - NSMaxY(contentRect)));

   289     PortSize(static_cast<short>(contentRect.size.width), static_cast<short>(contentRect.size.height));

   290     

   291     SetPort(oldPort);

   292 }

   293 

   294 static UInt32 getQDPixelFormatForBitmapContext(CGContextRef context)

   295 {

   296     UInt32 byteOrder = CGBitmapContextGetBitmapInfo(context) & kCGBitmapByteOrderMask;

   297     if (byteOrder == kCGBitmapByteOrderDefault)

   298         switch (CGBitmapContextGetBitsPerPixel(context)) {

   299             case 16:

   300                 byteOrder = kCGBitmapByteOrder16Host;

   301                 break;

   302             case 32:

   303                 byteOrder = kCGBitmapByteOrder32Host;

   304                 break;

   305         }

   306     switch (byteOrder) {

   307         case kCGBitmapByteOrder16Little:

   308             return k16LE555PixelFormat;

   309         case kCGBitmapByteOrder32Little:

   310             return k32BGRAPixelFormat;

   311         case kCGBitmapByteOrder16Big:

   312             return k16BE555PixelFormat;

   313         case kCGBitmapByteOrder32Big:

   314             return k32ARGBPixelFormat;

   315     }

   316     ASSERT_NOT_REACHED();

   317     return 0;

   318 }

   319 

   320 static inline void getNPRect(const CGRect& cgr, NPRect& npr)

   321 {

   322     npr.top = static_cast<uint16>(cgr.origin.y);

   323     npr.left = static_cast<uint16>(cgr.origin.x);

   324     npr.bottom = static_cast<uint16>(CGRectGetMaxY(cgr));

   325     npr.right = static_cast<uint16>(CGRectGetMaxX(cgr));

   326 }

   327 

   328 #endif

   329 

   330 static inline void getNPRect(const NSRect& nr, NPRect& npr)

   331 {

   332     npr.top = static_cast<uint16>(nr.origin.y);

   333     npr.left = static_cast<uint16>(nr.origin.x);

   334     npr.bottom = static_cast<uint16>(NSMaxY(nr));

   335     npr.right = static_cast<uint16>(NSMaxX(nr));

   336 }

   337 

   338 - (NSRect)visibleRect

   339 {

   340     // WebCore may impose an additional clip (via CSS overflow or clip properties).  Fetch

   341     // that clip now.    

   342     return NSIntersectionRect([self convertRect:[element _windowClipRect] fromView:nil], [super visibleRect]);

   343 }

   344 

   345 - (PortState)saveAndSetNewPortStateForUpdate:(BOOL)forUpdate

   346 {

   347     ASSERT([self currentWindow] != nil);

   348 

   349 #ifndef NP_NO_QUICKDRAW

   350     // If drawing with QuickDraw, fix the window port so that it has the same bounds as the NSWindow's

   351     // content view.  This makes it easier to convert between AppKit view and QuickDraw port coordinates.

   352     if (drawingModel == NPDrawingModelQuickDraw)

   353         [self fixWindowPort];

   354 #endif

   355 

   356     WindowRef windowRef = (WindowRef)[[self currentWindow] windowRef];

   357     ASSERT(windowRef);

   358     

   359     // Use AppKit to convert view coordinates to NSWindow coordinates.

   360     NSRect boundsInWindow = [self convertRect:[self bounds] toView:nil];

   361     NSRect visibleRectInWindow = [self convertRect:[self visibleRect] toView:nil];

   362     

   363     // Flip Y to convert NSWindow coordinates to top-left-based window coordinates.

   364     float borderViewHeight = [[self currentWindow] frame].size.height;

   365     boundsInWindow.origin.y = borderViewHeight - NSMaxY(boundsInWindow);

   366     visibleRectInWindow.origin.y = borderViewHeight - NSMaxY(visibleRectInWindow);

   367     

   368 #ifndef NP_NO_QUICKDRAW

   369     // Look at the Carbon port to convert top-left-based window coordinates into top-left-based content coordinates.

   370     if (drawingModel == NPDrawingModelQuickDraw) {

   371         ::Rect portBounds;

   372         CGrafPtr port = GetWindowPort(windowRef);

   373         GetPortBounds(port, &portBounds);

   374 

   375         PixMap *pix = *GetPortPixMap(port);

   376         boundsInWindow.origin.x += pix->bounds.left - portBounds.left;

   377         boundsInWindow.origin.y += pix->bounds.top - portBounds.top;

   378         visibleRectInWindow.origin.x += pix->bounds.left - portBounds.left;

   379         visibleRectInWindow.origin.y += pix->bounds.top - portBounds.top;

   380     }

   381 #endif

   382     

   383     window.x = (int32)boundsInWindow.origin.x; 

   384     window.y = (int32)boundsInWindow.origin.y;

   385     window.width = static_cast<uint32>(NSWidth(boundsInWindow));

   386     window.height = static_cast<uint32>(NSHeight(boundsInWindow));

   387     

   388     // "Clip-out" the plug-in when:

   389     // 1) it's not really in a window or off-screen or has no height or width.

   390     // 2) window.x is a "big negative number" which is how WebCore expresses off-screen widgets.

   391     // 3) the window is miniaturized or the app is hidden

   392     // 4) we're inside of viewWillMoveToWindow: with a nil window. In this case, superviews may already have nil 

   393     // superviews and nil windows and results from convertRect:toView: are incorrect.

   394     NSWindow *realWindow = [self window];

   395     if (window.width <= 0 || window.height <= 0 || window.x < -100000

   396             || realWindow == nil || [realWindow isMiniaturized]

   397             || [NSApp isHidden]

   398             || ![self superviewsHaveSuperviews]

   399             || [self isHiddenOrHasHiddenAncestor]) {

   400 

   401         // The following code tries to give plug-ins the same size they will eventually have.

   402         // The specifiedWidth and specifiedHeight variables are used to predict the size that

   403         // WebCore will eventually resize us to.

   404 

   405         // The QuickTime plug-in has problems if you give it a width or height of 0.

   406         // Since other plug-ins also might have the same sort of trouble, we make sure

   407         // to always give plug-ins a size other than 0,0.

   408 

   409         if (window.width <= 0)

   410             window.width = specifiedWidth > 0 ? specifiedWidth : 100;

   411         if (window.height <= 0)

   412             window.height = specifiedHeight > 0 ? specifiedHeight : 100;

   413 

   414         window.clipRect.bottom = window.clipRect.top;

   415         window.clipRect.left = window.clipRect.right;

   416     } else {

   417         getNPRect(visibleRectInWindow, window.clipRect);

   418     }

   419     

   420     // Save the port state, set up the port for entry into the plugin

   421     PortState portState;

   422     switch (drawingModel) {

   423 #ifndef NP_NO_QUICKDRAW

   424         case NPDrawingModelQuickDraw: {

   425             // Set up NS_Port.

   426             ::Rect portBounds;

   427             CGrafPtr port = GetWindowPort(windowRef);

   428             GetPortBounds(port, &portBounds);

   429             nPort.qdPort.port = port;

   430             nPort.qdPort.portx = (int32)-boundsInWindow.origin.x;

   431             nPort.qdPort.porty = (int32)-boundsInWindow.origin.y;

   432             window.window = &nPort;

   433 

   434             PortState_QD *qdPortState = (PortState_QD*)malloc(sizeof(PortState_QD));

   435             portState = (PortState)qdPortState;

   436             

   437             GetGWorld(&qdPortState->oldPort, &qdPortState->oldDevice);    

   438 

   439             qdPortState->oldOrigin.h = portBounds.left;

   440             qdPortState->oldOrigin.v = portBounds.top;

   441 

   442             qdPortState->oldClipRegion = NewRgn();

   443             GetPortClipRegion(port, qdPortState->oldClipRegion);

   444             

   445             qdPortState->oldVisibleRegion = NewRgn();

   446             GetPortVisibleRegion(port, qdPortState->oldVisibleRegion);

   447             

   448             RgnHandle clipRegion = NewRgn();

   449             qdPortState->clipRegion = clipRegion;

   450 

   451             CGContextRef currentContext = (CGContextRef)[[NSGraphicsContext currentContext] graphicsPort];

   452             if (currentContext && WKCGContextIsBitmapContext(currentContext)) {

   453                 // We use WKCGContextIsBitmapContext here, because if we just called CGBitmapContextGetData

   454                 // on any context, we'd log to the console every time. But even if WKCGContextIsBitmapContext

   455                 // returns true, it still might not be a context we need to create a GWorld for; for example

   456                 // transparency layers will return true, but return 0 for CGBitmapContextGetData.

   457                 void* offscreenData = CGBitmapContextGetData(currentContext);

   458                 if (offscreenData) {

   459                     // If the current context is an offscreen bitmap, then create a GWorld for it.

   460                     ::Rect offscreenBounds;

   461                     offscreenBounds.top = 0;

   462                     offscreenBounds.left = 0;

   463                     offscreenBounds.right = CGBitmapContextGetWidth(currentContext);

   464                     offscreenBounds.bottom = CGBitmapContextGetHeight(currentContext);

   465                     GWorldPtr newOffscreenGWorld;

   466                     QDErr err = NewGWorldFromPtr(&newOffscreenGWorld,

   467                         getQDPixelFormatForBitmapContext(currentContext), &offscreenBounds, 0, 0, 0,

   468                         static_cast<char*>(offscreenData), CGBitmapContextGetBytesPerRow(currentContext));

   469                     ASSERT(newOffscreenGWorld && !err);

   470                     if (!err) {

   471                         if (offscreenGWorld)

   472                             DisposeGWorld(offscreenGWorld);

   473                         offscreenGWorld = newOffscreenGWorld;

   474 

   475                         SetGWorld(offscreenGWorld, NULL);

   476 

   477                         port = offscreenGWorld;

   478 

   479                         nPort.qdPort.port = port;

   480                         boundsInWindow = [self bounds];

   481                         

   482                         // Generate a QD origin based on the current affine transform for currentContext.

   483                         CGAffineTransform offscreenMatrix = CGContextGetCTM(currentContext);

   484                         CGPoint origin = {0,0};

   485                         CGPoint axisFlip = {1,1};

   486                         origin = CGPointApplyAffineTransform(origin, offscreenMatrix);

   487                         axisFlip = CGPointApplyAffineTransform(axisFlip, offscreenMatrix);

   488                         

   489                         // Quartz bitmaps have origins at the bottom left, but the axes may be inverted, so handle that.

   490                         origin.x = offscreenBounds.left - origin.x * (axisFlip.x - origin.x);

   491                         origin.y = offscreenBounds.bottom + origin.y * (axisFlip.y - origin.y);

   492                         

   493                         nPort.qdPort.portx = static_cast<int32>(-boundsInWindow.origin.x + origin.x);

   494                         nPort.qdPort.porty = static_cast<int32>(-boundsInWindow.origin.y - origin.y);

   495                         window.x = 0;

   496                         window.y = 0;

   497                         window.window = &nPort;

   498 

   499                         // Use the clip bounds from the context instead of the bounds we created

   500                         // from the window above.

   501                         getNPRect(CGContextGetClipBoundingBox(currentContext), window.clipRect);

   502                     }

   503                 }

   504             }

   505 

   506             MacSetRectRgn(clipRegion,

   507                 window.clipRect.left + nPort.qdPort.portx, window.clipRect.top + nPort.qdPort.porty,

   508                 window.clipRect.right + nPort.qdPort.portx, window.clipRect.bottom + nPort.qdPort.porty);

   509             

   510             // Clip to dirty region so plug-in does not draw over already-drawn regions of the window that are

   511             // not going to be redrawn this update.  This forces plug-ins to play nice with z-index ordering.

   512             if (forUpdate) {

   513                 RgnHandle viewClipRegion = NewRgn();

   514                 

   515                 // Get list of dirty rects from the opaque ancestor -- WebKit does some tricks with invalidation and

   516                 // display to enable z-ordering for NSViews; a side-effect of this is that only the WebHTMLView

   517                 // knows about the true set of dirty rects.

   518                 NSView *opaqueAncestor = [self opaqueAncestor];

   519                 const NSRect *dirtyRects;

   520                 NSInteger dirtyRectCount, dirtyRectIndex;

   521                 [opaqueAncestor getRectsBeingDrawn:&dirtyRects count:&dirtyRectCount];

   522 

   523                 for (dirtyRectIndex = 0; dirtyRectIndex < dirtyRectCount; dirtyRectIndex++) {

   524                     NSRect dirtyRect = [self convertRect:dirtyRects[dirtyRectIndex] fromView:opaqueAncestor];

   525                     if (!NSEqualSizes(dirtyRect.size, NSZeroSize)) {

   526                         // Create a region for this dirty rect

   527                         RgnHandle dirtyRectRegion = NewRgn();

   528                         SetRectRgn(dirtyRectRegion, static_cast<short>(NSMinX(dirtyRect)), static_cast<short>(NSMinY(dirtyRect)), static_cast<short>(NSMaxX(dirtyRect)), static_cast<short>(NSMaxY(dirtyRect)));

   529                         

   530                         // Union this dirty rect with the rest of the dirty rects

   531                         UnionRgn(viewClipRegion, dirtyRectRegion, viewClipRegion);

   532                         DisposeRgn(dirtyRectRegion);

   533                     }

   534                 }

   535             

   536                 // Intersect the dirty region with the clip region, so that we only draw over dirty parts

   537                 SectRgn(clipRegion, viewClipRegion, clipRegion);

   538                 DisposeRgn(viewClipRegion);

   539             }

   540 

   541             // Switch to the port and set it up.

   542             SetPort(port);

   543             PenNormal();

   544             ForeColor(blackColor);

   545             BackColor(whiteColor);

   546             SetOrigin(nPort.qdPort.portx, nPort.qdPort.porty);

   547             SetPortClipRegion(nPort.qdPort.port, clipRegion);

   548 

   549             if (forUpdate) {

   550                 // AppKit may have tried to help us by doing a BeginUpdate.

   551                 // But the invalid region at that level didn't include AppKit's notion of what was not valid.

   552                 // We reset the port's visible region to counteract what BeginUpdate did.

   553                 SetPortVisibleRegion(nPort.qdPort.port, clipRegion);

   554                 InvalWindowRgn(windowRef, clipRegion);

   555             }

   556             

   557             qdPortState->forUpdate = forUpdate;

   558             break;

   559         }

   560 #endif /* NP_NO_QUICKDRAW */

   561 

   562         case NPDrawingModelCoreGraphics: {            

   563             // A CoreGraphics plugin's window may only be set while the plugin view is being updated

   564             ASSERT(forUpdate && [NSView focusView] == self);

   565 

   566             CGContextRef context = static_cast<CGContextRef>([[NSGraphicsContext currentContext] graphicsPort]);

   567 

   568             PortState_CG *cgPortState = (PortState_CG *)malloc(sizeof(PortState_CG));

   569             portState = (PortState)cgPortState;

   570             cgPortState->context = context;

   571             

   572             // Update the plugin's window/context

   573             nPort.cgPort.window = windowRef;

   574             nPort.cgPort.context = context;

   575             window.window = &nPort.cgPort;

   576 

   577             // Save current graphics context's state; will be restored by -restorePortState:

   578             CGContextSaveGState(context);

   579             

   580             // Get list of dirty rects from the opaque ancestor -- WebKit does some tricks with invalidation and

   581             // display to enable z-ordering for NSViews; a side-effect of this is that only the WebHTMLView

   582             // knows about the true set of dirty rects.

   583             NSView *opaqueAncestor = [self opaqueAncestor];

   584             const NSRect *dirtyRects;

   585             NSInteger count;

   586             [opaqueAncestor getRectsBeingDrawn:&dirtyRects count:&count];

   587             Vector<CGRect, 16> convertedDirtyRects;

   588             convertedDirtyRects.resize(count);

   589             for (int i = 0; i < count; ++i)

   590                 reinterpret_cast<NSRect&>(convertedDirtyRects[i]) = [self convertRect:dirtyRects[i] fromView:opaqueAncestor];

   591             CGContextClipToRects(context, convertedDirtyRects.data(), count);

   592 

   593             break;

   594         }

   595 

   596         case NPDrawingModelOpenGL: {

   597             // An OpenGL plugin's window may only be set while the plugin view is being updated

   598             ASSERT(forUpdate && [NSView focusView] == self);

   599 

   600             // Clear the "current" window and context -- they will be assigned below (if all goes well)

   601             nPort.aglPort.window = NULL;

   602             nPort.aglPort.context = NULL;

   603             

   604             // Create AGL context if needed

   605             if (![self _createAGLContextIfNeeded]) {

   606                 LOG_ERROR("Could not create AGL context");

   607                 return NULL;

   608             }

   609             

   610             // Update the plugin's window/context

   611             nPort.aglPort.window = windowRef;

   612             nPort.aglPort.context = [self _cglContext];

   613             window.window = &nPort.aglPort;

   614             

   615             // Save/set current AGL context

   616             PortState_GL *glPortState = (PortState_GL *)malloc(sizeof(PortState_GL));

   617             portState = (PortState)glPortState;

   618             glPortState->oldContext = aglGetCurrentContext();

   619             aglSetCurrentContext(aglContext);

   620             

   621             // Adjust viewport according to clip

   622             switch (window.type) {

   623                 case NPWindowTypeWindow:

   624                     glViewport(static_cast<GLint>(NSMinX(boundsInWindow) - NSMinX(visibleRectInWindow)),

   625                         static_cast<GLint>(NSMaxY(visibleRectInWindow) - NSMaxY(boundsInWindow)),

   626                             window.width, window.height);

   627                     break;

   628                 

   629                 case NPWindowTypeDrawable: {

   630                     GLsizei width, height;

   631                     if ([self _getAGLOffscreenBuffer:NULL width:&width height:&height])

   632                         glViewport(0, 0, width, height);

   633                     break;

   634                 }

   635                 

   636                 default:

   637                     ASSERT_NOT_REACHED();

   638                     break;

   639             }

   640             break;

   641         }

   642         

   643         default:

   644             ASSERT_NOT_REACHED();

   645             portState = NULL;

   646             break;

   647     }

   648     

   649     return portState;

   650 }

   651 

   652 - (PortState)saveAndSetNewPortState

   653 {

   654     return [self saveAndSetNewPortStateForUpdate:NO];

   655 }

   656 

   657 - (void)restorePortState:(PortState)portState

   658 {

   659     ASSERT([self currentWindow]);

   660     ASSERT(portState);

   661     

   662     switch (drawingModel) {

   663 #ifndef NP_NO_QUICKDRAW

   664         case NPDrawingModelQuickDraw: {

   665             PortState_QD *qdPortState = (PortState_QD *)portState;

   666             WindowRef windowRef = (WindowRef)[[self currentWindow] windowRef];

   667             CGrafPtr port = GetWindowPort(windowRef);

   668 

   669             SetPort(port);

   670 

   671             if (qdPortState->forUpdate)

   672                 ValidWindowRgn(windowRef, qdPortState->clipRegion);

   673 

   674             SetOrigin(qdPortState->oldOrigin.h, qdPortState->oldOrigin.v);

   675 

   676             SetPortClipRegion(port, qdPortState->oldClipRegion);

   677             if (qdPortState->forUpdate)

   678                 SetPortVisibleRegion(port, qdPortState->oldVisibleRegion);

   679 

   680             DisposeRgn(qdPortState->oldClipRegion);

   681             DisposeRgn(qdPortState->oldVisibleRegion);

   682             DisposeRgn(qdPortState->clipRegion);

   683 

   684             SetGWorld(qdPortState->oldPort, qdPortState->oldDevice);

   685             break;

   686         }

   687 #endif /* NP_NO_QUICKDRAW */

   688         

   689         case NPDrawingModelCoreGraphics:

   690             ASSERT([NSView focusView] == self);

   691             ASSERT(((PortState_CG *)portState)->context == nPort.cgPort.context);

   692             CGContextRestoreGState(nPort.cgPort.context);

   693             break;

   694         

   695         case NPDrawingModelOpenGL:

   696             aglSetCurrentContext(((PortState_GL *)portState)->oldContext);

   697             break;

   698         

   699         default:

   700             ASSERT_NOT_REACHED();

   701             break;

   702     }

   703 }

   704 

   705 - (BOOL)sendEvent:(EventRecord *)event

   706 {

   707     if (![self window])

   708         return NO;

   709     ASSERT(event);

   710    

   711     // If at any point the user clicks or presses a key from within a plugin, set the 

   712     // currentEventIsUserGesture flag to true. This is important to differentiate legitimate 

   713     // window.open() calls;  we still want to allow those.  See rdar://problem/4010765

   714     if (event->what == mouseDown || event->what == keyDown || event->what == mouseUp || event->what == autoKey)

   715         currentEventIsUserGesture = YES;

   716     

   717     suspendKeyUpEvents = NO;

   718     

   719     if (!isStarted)

   720         return NO;

   721 

   722     ASSERT(NPP_HandleEvent);

   723     

   724     // Make sure we don't call NPP_HandleEvent while we're inside NPP_SetWindow.

   725     // We probably don't want more general reentrancy protection; we are really

   726     // protecting only against this one case, which actually comes up when

   727     // you first install the SVG viewer plug-in.

   728     if (inSetWindow)

   729         return NO;

   730 

   731     Frame* frame = core([self webFrame]);

   732     if (!frame)

   733         return NO;

   734     Page* page = frame->page();

   735     if (!page)

   736         return NO;

   737 

   738     bool wasDeferring = page->defersLoading();

   739     if (!wasDeferring)

   740         page->setDefersLoading(true);

   741 

   742     // Can only send updateEvt to CoreGraphics and OpenGL plugins when actually drawing

   743     ASSERT((drawingModel != NPDrawingModelCoreGraphics && drawingModel != NPDrawingModelOpenGL) || event->what != updateEvt || [NSView focusView] == self);

   744     

   745     BOOL updating = event->what == updateEvt;

   746     PortState portState;

   747     if ((drawingModel != NPDrawingModelCoreGraphics && drawingModel != NPDrawingModelOpenGL) || event->what == updateEvt) {

   748         // In CoreGraphics or OpenGL mode, the port state only needs to be saved/set when redrawing the plug-in view.  The plug-in is not

   749         // allowed to draw at any other time.

   750         portState = [self saveAndSetNewPortStateForUpdate:updating];

   751         

   752         // We may have changed the window, so inform the plug-in.

   753         [self setWindowIfNecessary];

   754     } else

   755         portState = NULL;

   756     

   757 #if !defined(NDEBUG) && !defined(NP_NO_QUICKDRAW)

   758     // Draw green to help debug.

   759     // If we see any green we know something's wrong.

   760     // Note that PaintRect() only works for QuickDraw plugins; otherwise the current QD port is undefined.

   761     if (drawingModel == NPDrawingModelQuickDraw && !isTransparent && event->what == updateEvt) {

   762         ForeColor(greenColor);

   763         const ::Rect bigRect = { -10000, -10000, 10000, 10000 };

   764         PaintRect(&bigRect);

   765         ForeColor(blackColor);

   766     }

   767 #endif

   768     

   769     // Temporarily retain self in case the plug-in view is released while sending an event. 

   770     [[self retain] autorelease];

   771     

   772     BOOL acceptedEvent;

   773     [self willCallPlugInFunction];

   774     {

   775         KJS::JSLock::DropAllLocks dropAllLocks;

   776         acceptedEvent = NPP_HandleEvent(plugin, event);

   777     }

   778     [self didCallPlugInFunction];

   779     

   780     currentEventIsUserGesture = NO;

   781     

   782     if (portState) {

   783         if ([self currentWindow])

   784             [self restorePortState:portState];

   785         free(portState);

   786     }

   787 

   788     if (!wasDeferring)

   789         page->setDefersLoading(false);

   790             

   791     return acceptedEvent;

   792 }

   793 

   794 - (void)sendActivateEvent:(BOOL)activate

   795 {

   796     EventRecord event;

   797     

   798     [self getCarbonEvent:&event];

   799     event.what = activateEvt;

   800     WindowRef windowRef = (WindowRef)[[self window] windowRef];

   801     event.message = (unsigned long)windowRef;

   802     if (activate) {

   803         event.modifiers |= activeFlag;

   804     }

   805     

   806     BOOL acceptedEvent;

   807     acceptedEvent = [self sendEvent:&event]; 

   808     

   809     LOG(PluginEvents, "NPP_HandleEvent(activateEvent): %d  isActive: %d", acceptedEvent, activate);

   810 }

   811 

   812 - (BOOL)sendUpdateEvent

   813 {

   814     EventRecord event;

   815     

   816     [self getCarbonEvent:&event];

   817     event.what = updateEvt;

   818     WindowRef windowRef = (WindowRef)[[self window] windowRef];

   819     event.message = (unsigned long)windowRef;

   820 

   821     BOOL acceptedEvent = [self sendEvent:&event];

   822 

   823     LOG(PluginEvents, "NPP_HandleEvent(updateEvt): %d", acceptedEvent);

   824 

   825     return acceptedEvent;

   826 }

   827 

   828 -(void)sendNullEvent

   829 {

   830     EventRecord event;

   831 

   832     [self getCarbonEvent:&event];

   833 

   834     // Plug-in should not react to cursor position when not active or when a menu is down.

   835     MenuTrackingData trackingData;

   836     OSStatus error = GetMenuTrackingData(NULL, &trackingData);

   837 

   838     // Plug-in should not react to cursor position when the actual window is not key.

   839     if (![[self window] isKeyWindow] || (error == noErr && trackingData.menu)) {

   840         // FIXME: Does passing a v and h of -1 really prevent it from reacting to the cursor position?

   841         event.where.v = -1;

   842         event.where.h = -1;

   843     }

   844     

   845     [self sendEvent:&event];

   846 }

   847 

   848 - (void)stopNullEvents

   849 {

   850     [nullEventTimer invalidate];

   851     [nullEventTimer release];

   852     nullEventTimer = nil;

   853 }

   854 

   855 - (void)restartNullEvents

   856 {

   857     ASSERT([self window]);

   858     

   859     if (nullEventTimer)

   860         [self stopNullEvents];

   861     

   862     if (!isStarted || [[self window] isMiniaturized])

   863         return;

   864 

   865     NSTimeInterval interval;

   866 

   867     // If the plugin is completely obscured (scrolled out of view, for example), then we will

   868     // send null events at a reduced rate.

   869     interval = !isCompletelyObscured ? NullEventIntervalActive : NullEventIntervalNotActive;    

   870     nullEventTimer = [[NSTimer scheduledTimerWithTimeInterval:interval

   871                                                        target:self

   872                                                      selector:@selector(sendNullEvent)

   873                                                      userInfo:nil

   874                                                       repeats:YES] retain];

   875 }

   876 

   877 - (BOOL)acceptsFirstResponder

   878 {

   879     return YES;

   880 }

   881 

   882 - (void)installKeyEventHandler

   883 {

   884     static const EventTypeSpec sTSMEvents[] =

   885     {

   886     { kEventClassTextInput, kEventTextInputUnicodeForKeyEvent }

   887     };

   888     

   889     if (!keyEventHandler) {

   890         InstallEventHandler(GetWindowEventTarget((WindowRef)[[self window] windowRef]),

   891                             NewEventHandlerUPP(TSMEventHandler),

   892                             GetEventTypeCount(sTSMEvents),

   893                             sTSMEvents,

   894                             self,

   895                             &keyEventHandler);

   896     }

   897 }

   898 

   899 - (void)removeKeyEventHandler

   900 {

   901     if (keyEventHandler) {

   902         RemoveEventHandler(keyEventHandler);

   903         keyEventHandler = NULL;

   904     }

   905 }

   906 

   907 - (void)setHasFocus:(BOOL)flag

   908 {

   909     if (hasFocus != flag) {

   910         hasFocus = flag;

   911         EventRecord event;

   912         [self getCarbonEvent:&event];

   913         BOOL acceptedEvent;

   914         if (hasFocus) {

   915             event.what = getFocusEvent;

   916             acceptedEvent = [self sendEvent:&event]; 

   917             LOG(PluginEvents, "NPP_HandleEvent(getFocusEvent): %d", acceptedEvent);

   918             [self installKeyEventHandler];

   919         } else {

   920             event.what = loseFocusEvent;

   921             acceptedEvent = [self sendEvent:&event]; 

   922             LOG(PluginEvents, "NPP_HandleEvent(loseFocusEvent): %d", acceptedEvent);

   923             [self removeKeyEventHandler];

   924         }

   925     }

   926 }

   927 

   928 - (BOOL)becomeFirstResponder

   929 {

   930     [self setHasFocus:YES];

   931     return YES;

   932 }

   933 

   934 - (BOOL)resignFirstResponder

   935 {

   936     [self setHasFocus:NO];    

   937     return YES;

   938 }

   939 

   940 // AppKit doesn't call mouseDown or mouseUp on right-click. Simulate control-click

   941 // mouseDown and mouseUp so plug-ins get the right-click event as they do in Carbon (3125743).

   942 - (void)rightMouseDown:(NSEvent *)theEvent

   943 {

   944     [self mouseDown:theEvent];

   945 }

   946 

   947 - (void)rightMouseUp:(NSEvent *)theEvent

   948 {

   949     [self mouseUp:theEvent];

   950 }

   951 

   952 - (void)mouseDown:(NSEvent *)theEvent

   953 {

   954     EventRecord event;

   955 

   956     [self getCarbonEvent:&event withEvent:theEvent];

   957     event.what = mouseDown;

   958 

   959     BOOL acceptedEvent;

   960     acceptedEvent = [self sendEvent:&event]; 

   961     

   962     LOG(PluginEvents, "NPP_HandleEvent(mouseDown): %d pt.v=%d, pt.h=%d", acceptedEvent, event.where.v, event.where.h);

   963 }

   964 

   965 - (void)mouseUp:(NSEvent *)theEvent

   966 {

   967     EventRecord event;

   968     

   969     [self getCarbonEvent:&event withEvent:theEvent];

   970     event.what = mouseUp;

   971 

   972     BOOL acceptedEvent;

   973     acceptedEvent = [self sendEvent:&event]; 

   974     

   975     LOG(PluginEvents, "NPP_HandleEvent(mouseUp): %d pt.v=%d, pt.h=%d", acceptedEvent, event.where.v, event.where.h);

   976 }

   977 

   978 - (void)mouseEntered:(NSEvent *)theEvent

   979 {

   980     EventRecord event;

   981     

   982     [self getCarbonEvent:&event withEvent:theEvent];

   983     event.what = adjustCursorEvent;

   984 

   985     BOOL acceptedEvent;

   986     acceptedEvent = [self sendEvent:&event]; 

   987 

   988     LOG(PluginEvents, "NPP_HandleEvent(mouseEntered): %d", acceptedEvent);

   989 }

   990 

   991 - (void)mouseExited:(NSEvent *)theEvent

   992 {

   993     EventRecord event;

   994     

   995     [self getCarbonEvent:&event withEvent:theEvent];

   996     event.what = adjustCursorEvent;

   997 

   998     BOOL acceptedEvent;

   999     acceptedEvent = [self sendEvent:&event]; 

  1000 

  1001     // Set cursor back to arrow cursor.  Because NSCursor doesn't know about changes that the plugin made, we could get confused about what we think the

  1002     // current cursor is otherwise.  Therefore we have no choice but to unconditionally reset the cursor when the mouse exits the plugin.

  1003     [[NSCursor arrowCursor] set];

  1004 

  1005     LOG(PluginEvents, "NPP_HandleEvent(mouseExited): %d", acceptedEvent);

  1006 }

  1007 

  1008 - (void)mouseDragged:(NSEvent *)theEvent

  1009 {

  1010     // Do nothing so that other responders don't respond to the drag that initiated in this view.

  1011 }

  1012 

  1013 - (UInt32)keyMessageForEvent:(NSEvent *)event

  1014 {

  1015     NSData *data = [[event characters] dataUsingEncoding:CFStringConvertEncodingToNSStringEncoding(CFStringGetSystemEncoding())];

  1016     if (!data) {

  1017         return 0;

  1018     }

  1019     UInt8 characterCode;

  1020     [data getBytes:&characterCode length:1];

  1021     UInt16 keyCode = [event keyCode];

  1022     return keyCode << 8 | characterCode;

  1023 }

  1024 

  1025 - (void)keyUp:(NSEvent *)theEvent

  1026 {

  1027     WKSendKeyEventToTSM(theEvent);

  1028     

  1029     // TSM won't send keyUp events so we have to send them ourselves.

  1030     // Only send keyUp events after we receive the TSM callback because this is what plug-in expect from OS 9.

  1031     if (!suspendKeyUpEvents) {

  1032         EventRecord event;

  1033         

  1034         [self getCarbonEvent:&event withEvent:theEvent];

  1035         event.what = keyUp;

  1036         

  1037         if (event.message == 0) {

  1038             event.message = [self keyMessageForEvent:theEvent];

  1039         }

  1040         

  1041         [self sendEvent:&event];

  1042     }

  1043 }

  1044 

  1045 - (void)keyDown:(NSEvent *)theEvent

  1046 {

  1047     suspendKeyUpEvents = YES;

  1048     WKSendKeyEventToTSM(theEvent);

  1049 }

  1050 

  1051 static OSStatus TSMEventHandler(EventHandlerCallRef inHandlerRef, EventRef inEvent, void *pluginView)

  1052 {    

  1053     EventRef rawKeyEventRef;

  1054     OSStatus status = GetEventParameter(inEvent, kEventParamTextInputSendKeyboardEvent, typeEventRef, NULL, sizeof(EventRef), NULL, &rawKeyEventRef);

  1055     if (status != noErr) {

  1056         LOG_ERROR("GetEventParameter failed with error: %d", status);

  1057         return noErr;

  1058     }

  1059     

  1060     // Two-pass read to allocate/extract Mac charCodes

  1061     ByteCount numBytes;    

  1062     status = GetEventParameter(rawKeyEventRef, kEventParamKeyMacCharCodes, typeChar, NULL, 0, &numBytes, NULL);

  1063     if (status != noErr) {

  1064         LOG_ERROR("GetEventParameter failed with error: %d", status);

  1065         return noErr;

  1066     }

  1067     char *buffer = (char *)malloc(numBytes);

  1068     status = GetEventParameter(rawKeyEventRef, kEventParamKeyMacCharCodes, typeChar, NULL, numBytes, NULL, buffer);

  1069     if (status != noErr) {

  1070         LOG_ERROR("GetEventParameter failed with error: %d", status);

  1071         free(buffer);

  1072         return noErr;

  1073     }

  1074     

  1075     EventRef cloneEvent = CopyEvent(rawKeyEventRef);

  1076     unsigned i;

  1077     for (i = 0; i < numBytes; i++) {

  1078         status = SetEventParameter(cloneEvent, kEventParamKeyMacCharCodes, typeChar, 1 /* one char code */, &buffer[i]);

  1079         if (status != noErr) {

  1080             LOG_ERROR("SetEventParameter failed with error: %d", status);

  1081             free(buffer);

  1082             return noErr;

  1083         }

  1084         

  1085         EventRecord eventRec;

  1086         if (ConvertEventRefToEventRecord(cloneEvent, &eventRec)) {

  1087             BOOL acceptedEvent;

  1088             acceptedEvent = [(WebBaseNetscapePluginView *)pluginView sendEvent:&eventRec];

  1089             

  1090             LOG(PluginEvents, "NPP_HandleEvent(keyDown): %d charCode:%c keyCode:%lu",

  1091                 acceptedEvent, (char) (eventRec.message & charCodeMask), (eventRec.message & keyCodeMask));

  1092             

  1093             // We originally thought that if the plug-in didn't accept this event,

  1094             // we should pass it along so that keyboard scrolling, for example, will work.

  1095             // In practice, this is not a good idea, because plug-ins tend to eat the event but return false.

  1096             // MacIE handles each key event twice because of this, but we will emulate the other browsers instead.

  1097         }

  1098     }

  1099     ReleaseEvent(cloneEvent);

  1100     

  1101     free(buffer);

  1102 

  1103     return noErr;

  1104 }

  1105 

  1106 // Fake up command-modified events so cut, copy, paste and select all menus work.

  1107 - (void)sendModifierEventWithKeyCode:(int)keyCode character:(char)character

  1108 {

  1109     EventRecord event;

  1110     [self getCarbonEvent:&event];

  1111     event.what = keyDown;

  1112     event.modifiers |= cmdKey;

  1113     event.message = keyCode << 8 | character;

  1114     [self sendEvent:&event];

  1115 }

  1116 

  1117 - (void)cut:(id)sender

  1118 {

  1119     [self sendModifierEventWithKeyCode:7 character:'x'];

  1120 }

  1121 

  1122 - (void)copy:(id)sender

  1123 {

  1124     [self sendModifierEventWithKeyCode:8 character:'c'];

  1125 }

  1126 

  1127 - (void)paste:(id)sender

  1128 {

  1129     [self sendModifierEventWithKeyCode:9 character:'v'];

  1130 }

  1131 

  1132 - (void)selectAll:(id)sender

  1133 {

  1134     [self sendModifierEventWithKeyCode:0 character:'a'];

  1135 }