| /* |
| * Copyright 2011 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #import "SkNSView.h" |
| #include "SkCanvas.h" |
| #include "SkSurface.h" |
| #include "SkCGUtils.h" |
| #include "SkEvent.h" |
| static_assert(SK_SUPPORT_GPU, "not_implemented_for_non_gpu_build"); |
| #include <OpenGL/gl.h> |
| |
| //#define FORCE_REDRAW |
| // Can be dropped when we no longer support 10.6. |
| #if defined(MAC_OS_X_VERSION_10_7) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_7 |
| #define RETINA_API_AVAILABLE 1 |
| #else |
| #define RETINA_API_AVAILABLE 0 |
| #endif |
| |
| @implementation SkNSView |
| @synthesize fWind, fTitle, fOptionsDelegate, fGLContext; |
| |
| BOOL fRedrawRequestPending; |
| |
| - (id)initWithCoder:(NSCoder*)coder { |
| if ((self = [super initWithCoder:coder])) { |
| self = [self initWithDefaults]; |
| [self setUpWindow]; |
| } |
| return self; |
| } |
| |
| - (id)initWithFrame:(NSRect)frameRect { |
| if ((self = [super initWithFrame:frameRect])) { |
| self = [self initWithDefaults]; |
| [self setUpWindow]; |
| } |
| return self; |
| } |
| |
| - (id)initWithDefaults { |
| #if RETINA_API_AVAILABLE |
| [self setWantsBestResolutionOpenGLSurface:YES]; |
| #endif |
| fRedrawRequestPending = false; |
| fWind = NULL; |
| return self; |
| } |
| |
| - (void)setUpWindow { |
| [[NSNotificationCenter defaultCenter] addObserver:self |
| selector:@selector(backingPropertiesChanged:) |
| name:@"NSWindowDidChangeBackingPropertiesNotification" |
| object:[self window]]; |
| if (fWind) { |
| fWind->setVisibleP(true); |
| NSSize size = self.frame.size; |
| #if RETINA_API_AVAILABLE |
| size = [self convertSizeToBacking:self.frame.size]; |
| #endif |
| fWind->resize((int) size.width, (int) size.height); |
| [[self window] setAcceptsMouseMovedEvents:YES]; |
| } |
| } |
| |
| -(BOOL) isFlipped { |
| return YES; |
| } |
| |
| - (BOOL)acceptsFirstResponder { |
| return YES; |
| } |
| |
| - (float)scaleFactor { |
| NSWindow *window = [self window]; |
| #if RETINA_API_AVAILABLE |
| if (window) { |
| return [window backingScaleFactor]; |
| } |
| return [[NSScreen mainScreen] backingScaleFactor]; |
| #else |
| if (window) { |
| return [window userSpaceScaleFactor]; |
| } |
| return [[NSScreen mainScreen] userSpaceScaleFactor]; |
| #endif |
| } |
| |
| - (void)backingPropertiesChanged:(NSNotification *)notification { |
| CGFloat oldBackingScaleFactor = (CGFloat)[ |
| [notification.userInfo objectForKey:@"NSBackingPropertyOldScaleFactorKey"] doubleValue |
| ]; |
| CGFloat newBackingScaleFactor = [self scaleFactor]; |
| if (oldBackingScaleFactor == newBackingScaleFactor) { |
| return; |
| } |
| |
| // TODO: need a better way to force a refresh (that works). |
| // [fGLContext update] does not appear to update if the point size has not changed, |
| // even if the backing size has changed. |
| [self setFrameSize:NSMakeSize(self.frame.size.width + 1, self.frame.size.height + 1)]; |
| } |
| |
| - (void)resizeSkView:(NSSize)newSize { |
| #if RETINA_API_AVAILABLE |
| newSize = [self convertSizeToBacking:newSize]; |
| #endif |
| if (fWind && (fWind->width() != newSize.width || fWind->height() != newSize.height)) { |
| fWind->resize((int) newSize.width, (int) newSize.height); |
| if (fGLContext) { |
| glClear(GL_STENCIL_BUFFER_BIT); |
| [fGLContext update]; |
| } |
| } |
| } |
| |
| - (void) setFrameSize:(NSSize)newSize { |
| [super setFrameSize:newSize]; |
| [self resizeSkView:newSize]; |
| } |
| |
| - (void)dealloc { |
| [self freeNativeWind]; |
| self.fGLContext = nil; |
| self.fTitle = nil; |
| [super dealloc]; |
| } |
| |
| - (void)freeNativeWind { |
| delete fWind; |
| fWind = nil; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| - (void)drawSkia { |
| fRedrawRequestPending = false; |
| if (fWind) { |
| sk_sp<SkSurface> surface(fWind->makeSurface()); |
| fWind->draw(surface->getCanvas()); |
| #ifdef FORCE_REDRAW |
| fWind->inval(NULL); |
| #endif |
| } |
| } |
| |
| - (void)setSkTitle:(const char *)title { |
| self.fTitle = [NSString stringWithUTF8String:title]; |
| [[self window] setTitle:self.fTitle]; |
| } |
| |
| - (BOOL)onHandleEvent:(const SkEvent&)evt { |
| return false; |
| } |
| |
| #include "SkOSMenu.h" |
| - (void)onAddMenu:(const SkOSMenu*)menu { |
| [self.fOptionsDelegate view:self didAddMenu:menu]; |
| } |
| |
| - (void)onUpdateMenu:(const SkOSMenu*)menu { |
| [self.fOptionsDelegate view:self didUpdateMenu:menu]; |
| } |
| |
| - (void)postInvalWithRect:(const SkIRect*)r { |
| if (!fRedrawRequestPending) { |
| fRedrawRequestPending = true; |
| [self setNeedsDisplay:YES]; |
| [self performSelector:@selector(drawSkia) withObject:nil afterDelay:0]; |
| } |
| } |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| #include "SkKey.h" |
| enum { |
| SK_MacReturnKey = 36, |
| SK_MacDeleteKey = 51, |
| SK_MacEndKey = 119, |
| SK_MacLeftKey = 123, |
| SK_MacRightKey = 124, |
| SK_MacDownKey = 125, |
| SK_MacUpKey = 126, |
| SK_Mac0Key = 0x52, |
| SK_Mac1Key = 0x53, |
| SK_Mac2Key = 0x54, |
| SK_Mac3Key = 0x55, |
| SK_Mac4Key = 0x56, |
| SK_Mac5Key = 0x57, |
| SK_Mac6Key = 0x58, |
| SK_Mac7Key = 0x59, |
| SK_Mac8Key = 0x5b, |
| SK_Mac9Key = 0x5c |
| }; |
| |
| static SkKey raw2key(UInt32 raw) |
| { |
| static const struct { |
| UInt32 fRaw; |
| SkKey fKey; |
| } gKeys[] = { |
| { SK_MacUpKey, kUp_SkKey }, |
| { SK_MacDownKey, kDown_SkKey }, |
| { SK_MacLeftKey, kLeft_SkKey }, |
| { SK_MacRightKey, kRight_SkKey }, |
| { SK_MacReturnKey, kOK_SkKey }, |
| { SK_MacDeleteKey, kBack_SkKey }, |
| { SK_MacEndKey, kEnd_SkKey }, |
| { SK_Mac0Key, k0_SkKey }, |
| { SK_Mac1Key, k1_SkKey }, |
| { SK_Mac2Key, k2_SkKey }, |
| { SK_Mac3Key, k3_SkKey }, |
| { SK_Mac4Key, k4_SkKey }, |
| { SK_Mac5Key, k5_SkKey }, |
| { SK_Mac6Key, k6_SkKey }, |
| { SK_Mac7Key, k7_SkKey }, |
| { SK_Mac8Key, k8_SkKey }, |
| { SK_Mac9Key, k9_SkKey } |
| }; |
| |
| for (unsigned i = 0; i < SK_ARRAY_COUNT(gKeys); i++) |
| if (gKeys[i].fRaw == raw) |
| return gKeys[i].fKey; |
| return kNONE_SkKey; |
| } |
| |
| - (void)keyDown:(NSEvent *)event { |
| if (NULL == fWind) |
| return; |
| |
| SkKey key = raw2key([event keyCode]); |
| if (kNONE_SkKey != key) |
| fWind->handleKey(key); |
| else{ |
| unichar c = [[event characters] characterAtIndex:0]; |
| fWind->handleChar((SkUnichar)c); |
| } |
| } |
| |
| - (void)keyUp:(NSEvent *)event { |
| if (NULL == fWind) |
| return; |
| |
| SkKey key = raw2key([event keyCode]); |
| if (kNONE_SkKey != key) |
| fWind->handleKeyUp(key); |
| // else |
| // unichar c = [[event characters] characterAtIndex:0]; |
| } |
| |
| static const struct { |
| unsigned fNSModifierMask; |
| unsigned fSkModifierMask; |
| } gModifierMasks[] = { |
| { NSAlphaShiftKeyMask, kShift_SkModifierKey }, |
| { NSShiftKeyMask, kShift_SkModifierKey }, |
| { NSControlKeyMask, kControl_SkModifierKey }, |
| { NSAlternateKeyMask, kOption_SkModifierKey }, |
| { NSCommandKeyMask, kCommand_SkModifierKey }, |
| }; |
| |
| static unsigned convertNSModifiersToSk(NSUInteger nsModi) { |
| unsigned skModi = 0; |
| for (size_t i = 0; i < SK_ARRAY_COUNT(gModifierMasks); ++i) { |
| if (nsModi & gModifierMasks[i].fNSModifierMask) { |
| skModi |= gModifierMasks[i].fSkModifierMask; |
| } |
| } |
| return skModi; |
| } |
| |
| - (void)mouseDown:(NSEvent *)event { |
| NSPoint p = [event locationInWindow]; |
| unsigned modi = convertNSModifiersToSk([event modifierFlags]); |
| |
| if ([self mouse:p inRect:[self bounds]] && fWind) { |
| NSPoint loc = [self convertPoint:p fromView:nil]; |
| #if RETINA_API_AVAILABLE |
| loc = [self convertPointToBacking:loc]; //y-up |
| loc.y = -loc.y; |
| #endif |
| fWind->handleClick((int) loc.x, (int) loc.y, |
| SkView::Click::kDown_State, self, modi); |
| } |
| } |
| |
| - (void)mouseDragged:(NSEvent *)event { |
| NSPoint p = [event locationInWindow]; |
| unsigned modi = convertNSModifiersToSk([event modifierFlags]); |
| |
| if ([self mouse:p inRect:[self bounds]] && fWind) { |
| NSPoint loc = [self convertPoint:p fromView:nil]; |
| #if RETINA_API_AVAILABLE |
| loc = [self convertPointToBacking:loc]; //y-up |
| loc.y = -loc.y; |
| #endif |
| fWind->handleClick((int) loc.x, (int) loc.y, |
| SkView::Click::kMoved_State, self, modi); |
| } |
| } |
| |
| - (void)mouseMoved:(NSEvent *)event { |
| NSPoint p = [event locationInWindow]; |
| unsigned modi = convertNSModifiersToSk([event modifierFlags]); |
| |
| if ([self mouse:p inRect:[self bounds]] && fWind) { |
| NSPoint loc = [self convertPoint:p fromView:nil]; |
| #if RETINA_API_AVAILABLE |
| loc = [self convertPointToBacking:loc]; //y-up |
| loc.y = -loc.y; |
| #endif |
| fWind->handleClick((int) loc.x, (int) loc.y, |
| SkView::Click::kMoved_State, self, modi); |
| } |
| } |
| |
| - (void)mouseUp:(NSEvent *)event { |
| NSPoint p = [event locationInWindow]; |
| unsigned modi = convertNSModifiersToSk([event modifierFlags]); |
| |
| if ([self mouse:p inRect:[self bounds]] && fWind) { |
| NSPoint loc = [self convertPoint:p fromView:nil]; |
| #if RETINA_API_AVAILABLE |
| loc = [self convertPointToBacking:loc]; //y-up |
| loc.y = -loc.y; |
| #endif |
| fWind->handleClick((int) loc.x, (int) loc.y, |
| SkView::Click::kUp_State, self, modi); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #include <OpenGL/OpenGL.h> |
| |
| static CGLContextObj createGLContext(int msaaSampleCount) { |
| GLint major, minor; |
| CGLGetVersion(&major, &minor); |
| |
| static const CGLPixelFormatAttribute attributes[] = { |
| kCGLPFAStencilSize, (CGLPixelFormatAttribute) 8, |
| kCGLPFAAccelerated, |
| kCGLPFADoubleBuffer, |
| kCGLPFAOpenGLProfile, (CGLPixelFormatAttribute) kCGLOGLPVersion_3_2_Core, |
| (CGLPixelFormatAttribute)0 |
| }; |
| |
| CGLPixelFormatObj format; |
| GLint npix = 0; |
| if (msaaSampleCount > 0) { |
| static const int kAttributeCount = SK_ARRAY_COUNT(attributes); |
| CGLPixelFormatAttribute msaaAttributes[kAttributeCount + 5]; |
| memcpy(msaaAttributes, attributes, sizeof(attributes)); |
| SkASSERT(0 == msaaAttributes[kAttributeCount - 1]); |
| msaaAttributes[kAttributeCount - 1] = kCGLPFASampleBuffers; |
| msaaAttributes[kAttributeCount + 0] = (CGLPixelFormatAttribute)1; |
| msaaAttributes[kAttributeCount + 1] = kCGLPFAMultisample; |
| msaaAttributes[kAttributeCount + 2] = kCGLPFASamples; |
| msaaAttributes[kAttributeCount + 3] = |
| (CGLPixelFormatAttribute)msaaSampleCount; |
| msaaAttributes[kAttributeCount + 4] = (CGLPixelFormatAttribute)0; |
| CGLChoosePixelFormat(msaaAttributes, &format, &npix); |
| } |
| if (!npix) { |
| CGLChoosePixelFormat(attributes, &format, &npix); |
| } |
| CGLContextObj ctx; |
| CGLCreateContext(format, NULL, &ctx); |
| CGLDestroyPixelFormat(format); |
| |
| static const GLint interval = 1; |
| CGLSetParameter(ctx, kCGLCPSwapInterval, &interval); |
| CGLSetCurrentContext(ctx); |
| return ctx; |
| } |
| |
| - (void)viewDidMoveToWindow { |
| [super viewDidMoveToWindow]; |
| |
| //Attaching view to fGLContext requires that the view to be part of a window, |
| //and that the NSWindow instance must have a CoreGraphics counterpart (or |
| //it must NOT be deferred or should have been on screen at least once) |
| if ([fGLContext view] != self && nil != self.window) { |
| [fGLContext setView:self]; |
| } |
| } |
| - (bool)attach:(SkOSWindow::SkBackEndTypes)attachType |
| withMSAASampleCount:(int) sampleCount |
| andGetInfo:(SkOSWindow::AttachmentInfo*) info { |
| if (nil == fGLContext) { |
| CGLContextObj ctx = createGLContext(sampleCount); |
| SkASSERT(ctx); |
| fGLContext = [[NSOpenGLContext alloc] initWithCGLContextObj:ctx]; |
| CGLReleaseContext(ctx); |
| if (NULL == fGLContext) { |
| return false; |
| } |
| [fGLContext setView:self]; |
| } |
| |
| [fGLContext makeCurrentContext]; |
| CGLPixelFormatObj format = CGLGetPixelFormat((CGLContextObj)[fGLContext CGLContextObj]); |
| CGLDescribePixelFormat(format, 0, kCGLPFASamples, &info->fSampleCount); |
| CGLDescribePixelFormat(format, 0, kCGLPFAStencilSize, &info->fStencilBits); |
| NSSize size = self.bounds.size; |
| #if RETINA_API_AVAILABLE |
| size = [self convertSizeToBacking:size]; |
| #endif |
| glViewport(0, 0, (int) size.width, (int) size.height); |
| glClearColor(0, 0, 0, 0); |
| glClearStencil(0); |
| glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); |
| return true; |
| } |
| |
| - (void)detach { |
| [fGLContext release]; |
| fGLContext = nil; |
| } |
| |
| - (void)present { |
| if (nil != fGLContext) { |
| [fGLContext flushBuffer]; |
| } |
| } |
| |
| - (void)setVSync:(bool)enable { |
| if (fGLContext) { |
| GLint interval = enable ? 1 : 0; |
| CGLContextObj ctx = (CGLContextObj)[fGLContext CGLContextObj]; |
| CGLSetParameter(ctx, kCGLCPSwapInterval, &interval); |
| } |
| } |
| @end |
