| #include "SkTypes.h" |
| |
| #if defined(SK_BUILD_FOR_MAC) && !defined(SK_USE_WXWIDGETS) |
| |
| #include <AGL/agl.h> |
| |
| #include <Carbon/Carbon.h> |
| #include "SkCGUtils.h" |
| |
| #include "SkWindow.h" |
| #include "SkCanvas.h" |
| #include "SkOSMenu.h" |
| #include "SkTime.h" |
| |
| #include "SkGraphics.h" |
| #include <new.h> |
| |
| static void (*gPrevNewHandler)(); |
| |
| extern "C" { |
| static void sk_new_handler() |
| { |
| if (SkGraphics::SetFontCacheUsed(0)) |
| return; |
| if (gPrevNewHandler) |
| gPrevNewHandler(); |
| else |
| sk_throw(); |
| } |
| } |
| |
| static SkOSWindow* gCurrOSWin; |
| static EventTargetRef gEventTarget; |
| static EventQueueRef gCurrEventQ; |
| |
| static OSStatus MyDrawEventHandler(EventHandlerCallRef myHandler, |
| EventRef event, void *userData) { |
| // NOTE: GState is save/restored by the HIView system doing the callback, |
| // so the draw handler doesn't need to do it |
| |
| OSStatus status = noErr; |
| CGContextRef context; |
| HIRect bounds; |
| |
| // Get the CGContextRef |
| status = GetEventParameter (event, kEventParamCGContextRef, |
| typeCGContextRef, NULL, |
| sizeof (CGContextRef), |
| NULL, |
| &context); |
| |
| if (status != noErr) { |
| SkDebugf("Got error %d getting the context!\n", status); |
| return status; |
| } |
| |
| // Get the bounding rectangle |
| HIViewGetBounds ((HIViewRef) userData, &bounds); |
| |
| gCurrOSWin->doPaint(context); |
| return status; |
| } |
| |
| #define SK_MacEventClass FOUR_CHAR_CODE('SKec') |
| #define SK_MacEventKind FOUR_CHAR_CODE('SKek') |
| #define SK_MacEventParamName FOUR_CHAR_CODE('SKev') |
| #define SK_MacEventSinkIDParamName FOUR_CHAR_CODE('SKes') |
| |
| static void set_bindingside(HISideBinding* side, HIViewRef parent, HIBindingKind kind) { |
| side->toView = parent; |
| side->kind = kind; |
| side->offset = 0; |
| } |
| |
| static void set_axisscale(HIAxisScale* axis, HIViewRef parent) { |
| axis->toView = parent; |
| axis->kind = kHILayoutScaleAbsolute; |
| axis->ratio = 1; |
| } |
| |
| static void set_axisposition(HIAxisPosition* pos, HIViewRef parent, HIPositionKind kind) { |
| pos->toView = parent; |
| pos->kind = kind; |
| pos->offset = 0; |
| } |
| |
| SkOSWindow::SkOSWindow(void* hWnd) : fHWND(hWnd), fAGLCtx(NULL) |
| { |
| OSStatus result; |
| WindowRef wr = (WindowRef)hWnd; |
| |
| HIViewRef imageView, parent; |
| HIViewRef rootView = HIViewGetRoot(wr); |
| HIViewFindByID(rootView, kHIViewWindowContentID, &parent); |
| result = HIImageViewCreate(NULL, &imageView); |
| SkASSERT(result == noErr); |
| |
| result = HIViewAddSubview(parent, imageView); |
| SkASSERT(result == noErr); |
| |
| fHVIEW = imageView; |
| |
| HIViewSetVisible(imageView, true); |
| HIViewPlaceInSuperviewAt(imageView, 0, 0); |
| |
| if (true) { |
| HILayoutInfo layout; |
| layout.version = kHILayoutInfoVersionZero; |
| set_bindingside(&layout.binding.left, parent, kHILayoutBindLeft); |
| set_bindingside(&layout.binding.top, parent, kHILayoutBindTop); |
| set_bindingside(&layout.binding.right, parent, kHILayoutBindRight); |
| set_bindingside(&layout.binding.bottom, parent, kHILayoutBindBottom); |
| set_axisscale(&layout.scale.x, parent); |
| set_axisscale(&layout.scale.y, parent); |
| set_axisposition(&layout.position.x, parent, kHILayoutPositionLeft); |
| set_axisposition(&layout.position.y, rootView, kHILayoutPositionTop); |
| HIViewSetLayoutInfo(imageView, &layout); |
| } |
| |
| HIImageViewSetOpaque(imageView, true); |
| HIImageViewSetScaleToFit(imageView, false); |
| |
| static const EventTypeSpec gTypes[] = { |
| { kEventClassKeyboard, kEventRawKeyDown }, |
| { kEventClassKeyboard, kEventRawKeyUp }, |
| { kEventClassMouse, kEventMouseDown }, |
| { kEventClassMouse, kEventMouseDragged }, |
| { kEventClassMouse, kEventMouseMoved }, |
| { kEventClassMouse, kEventMouseUp }, |
| { kEventClassTextInput, kEventTextInputUnicodeForKeyEvent }, |
| { kEventClassWindow, kEventWindowBoundsChanged }, |
| // { kEventClassWindow, kEventWindowDrawContent }, |
| { SK_MacEventClass, SK_MacEventKind } |
| }; |
| |
| EventHandlerUPP handlerUPP = NewEventHandlerUPP(SkOSWindow::EventHandler); |
| int count = SK_ARRAY_COUNT(gTypes); |
| |
| result = InstallEventHandler(GetWindowEventTarget(wr), handlerUPP, |
| count, gTypes, this, nil); |
| SkASSERT(result == noErr); |
| |
| gCurrOSWin = this; |
| gCurrEventQ = GetCurrentEventQueue(); |
| gEventTarget = GetWindowEventTarget(wr); |
| |
| static bool gOnce = true; |
| if (gOnce) { |
| gOnce = false; |
| gPrevNewHandler = set_new_handler(sk_new_handler); |
| } |
| } |
| |
| void SkOSWindow::doPaint(void* ctx) |
| { |
| #if 0 |
| this->update(NULL); |
| |
| const SkBitmap& bm = this->getBitmap(); |
| CGImageRef img = SkCreateCGImageRef(bm); |
| |
| if (img) { |
| CGRect r = CGRectMake(0, 0, bm.width(), bm.height()); |
| |
| CGContextRef cg = reinterpret_cast<CGContextRef>(ctx); |
| |
| CGContextSaveGState(cg); |
| CGContextTranslateCTM(cg, 0, r.size.height); |
| CGContextScaleCTM(cg, 1, -1); |
| |
| CGContextDrawImage(cg, r, img); |
| |
| CGContextRestoreGState(cg); |
| |
| CGImageRelease(img); |
| } |
| #endif |
| } |
| |
| void SkOSWindow::updateSize() |
| { |
| Rect r; |
| |
| GetWindowBounds((WindowRef)fHWND, kWindowContentRgn, &r); |
| this->resize(r.right - r.left, r.bottom - r.top); |
| |
| #if 0 |
| HIRect frame; |
| HIViewRef imageView = (HIViewRef)getHVIEW(); |
| HIViewRef parent = HIViewGetSuperview(imageView); |
| |
| HIViewGetBounds(imageView, &frame); |
| SkDebugf("------ %d bounds %g %g %g %g\n", r.right - r.left, |
| frame.origin.x, frame.origin.y, frame.size.width, frame.size.height); |
| #endif |
| } |
| |
| void SkOSWindow::onHandleInval(const SkIRect& r) |
| { |
| SkEvent* evt = new SkEvent("inval-imageview"); |
| evt->post(this->getSinkID()); |
| } |
| |
| bool SkOSWindow::onEvent(const SkEvent& evt) { |
| if (evt.isType("inval-imageview")) { |
| this->update(NULL); |
| |
| const SkBitmap& bm = this->getBitmap(); |
| |
| CGImageRef img = SkCreateCGImageRef(bm); |
| HIImageViewSetImage((HIViewRef)getHVIEW(), img); |
| CGImageRelease(img); |
| return true; |
| } |
| return INHERITED::onEvent(evt); |
| } |
| |
| void SkOSWindow::onSetTitle(const char title[]) |
| { |
| CFStringRef str = CFStringCreateWithCString(NULL, title, kCFStringEncodingUTF8); |
| SetWindowTitleWithCFString((WindowRef)fHWND, str); |
| CFRelease(str); |
| } |
| |
| void SkOSWindow::onAddMenu(const SkOSMenu* sk_menu) |
| { |
| } |
| |
| static void getparam(EventRef inEvent, OSType name, OSType type, UInt32 size, void* data) |
| { |
| EventParamType actualType; |
| UInt32 actualSize; |
| OSStatus status; |
| |
| status = GetEventParameter(inEvent, name, type, &actualType, size, &actualSize, data); |
| SkASSERT(status == noErr); |
| SkASSERT(actualType == type); |
| SkASSERT(actualSize == size); |
| } |
| |
| 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; |
| } |
| |
| static void post_skmacevent() |
| { |
| EventRef ref; |
| OSStatus status = CreateEvent(nil, SK_MacEventClass, SK_MacEventKind, 0, 0, &ref); |
| SkASSERT(status == noErr); |
| |
| #if 0 |
| status = SetEventParameter(ref, SK_MacEventParamName, SK_MacEventParamName, sizeof(evt), &evt); |
| SkASSERT(status == noErr); |
| status = SetEventParameter(ref, SK_MacEventSinkIDParamName, SK_MacEventSinkIDParamName, sizeof(sinkID), &sinkID); |
| SkASSERT(status == noErr); |
| #endif |
| |
| EventTargetRef target = gEventTarget; |
| SetEventParameter(ref, kEventParamPostTarget, typeEventTargetRef, sizeof(target), &target); |
| SkASSERT(status == noErr); |
| |
| status = PostEventToQueue(gCurrEventQ, ref, kEventPriorityStandard); |
| SkASSERT(status == noErr); |
| |
| ReleaseEvent(ref); |
| } |
| |
| pascal OSStatus SkOSWindow::EventHandler( EventHandlerCallRef inHandler, EventRef inEvent, void* userData ) |
| { |
| SkOSWindow* win = (SkOSWindow*)userData; |
| OSStatus result = eventNotHandledErr; |
| UInt32 wClass = GetEventClass(inEvent); |
| UInt32 wKind = GetEventKind(inEvent); |
| |
| gCurrOSWin = win; // will need to be in TLS. Set this so PostEvent will work |
| |
| switch (wClass) { |
| case kEventClassMouse: { |
| Point pt; |
| getparam(inEvent, kEventParamMouseLocation, typeQDPoint, sizeof(pt), &pt); |
| SetPortWindowPort((WindowRef)win->getHWND()); |
| GlobalToLocal(&pt); |
| |
| switch (wKind) { |
| case kEventMouseDown: |
| if (win->handleClick(pt.h, pt.v, Click::kDown_State)) { |
| result = noErr; |
| } |
| break; |
| case kEventMouseMoved: |
| // fall through |
| case kEventMouseDragged: |
| (void)win->handleClick(pt.h, pt.v, Click::kMoved_State); |
| // result = noErr; |
| break; |
| case kEventMouseUp: |
| (void)win->handleClick(pt.h, pt.v, Click::kUp_State); |
| // result = noErr; |
| break; |
| default: |
| break; |
| } |
| break; |
| } |
| case kEventClassKeyboard: |
| if (wKind == kEventRawKeyDown) { |
| UInt32 raw; |
| getparam(inEvent, kEventParamKeyCode, typeUInt32, sizeof(raw), &raw); |
| SkKey key = raw2key(raw); |
| if (key != kNONE_SkKey) |
| (void)win->handleKey(key); |
| } else if (wKind == kEventRawKeyUp) { |
| UInt32 raw; |
| getparam(inEvent, kEventParamKeyCode, typeUInt32, sizeof(raw), &raw); |
| SkKey key = raw2key(raw); |
| if (key != kNONE_SkKey) |
| (void)win->handleKeyUp(key); |
| } |
| break; |
| case kEventClassTextInput: |
| if (wKind == kEventTextInputUnicodeForKeyEvent) { |
| UInt16 uni; |
| getparam(inEvent, kEventParamTextInputSendText, typeUnicodeText, sizeof(uni), &uni); |
| win->handleChar(uni); |
| } |
| break; |
| case kEventClassWindow: |
| switch (wKind) { |
| case kEventWindowBoundsChanged: |
| win->updateSize(); |
| break; |
| case kEventWindowDrawContent: { |
| CGContextRef cg; |
| result = GetEventParameter(inEvent, |
| kEventParamCGContextRef, |
| typeCGContextRef, |
| NULL, |
| sizeof (CGContextRef), |
| NULL, |
| &cg); |
| if (result != 0) { |
| cg = NULL; |
| } |
| win->doPaint(cg); |
| break; |
| } |
| default: |
| break; |
| } |
| break; |
| case SK_MacEventClass: { |
| SkASSERT(wKind == SK_MacEventKind); |
| if (SkEvent::ProcessEvent()) { |
| post_skmacevent(); |
| } |
| #if 0 |
| SkEvent* evt; |
| SkEventSinkID sinkID; |
| getparam(inEvent, SK_MacEventParamName, SK_MacEventParamName, sizeof(evt), &evt); |
| getparam(inEvent, SK_MacEventSinkIDParamName, SK_MacEventSinkIDParamName, sizeof(sinkID), &sinkID); |
| #endif |
| result = noErr; |
| break; |
| } |
| default: |
| break; |
| } |
| if (result == eventNotHandledErr) { |
| result = CallNextEventHandler(inHandler, inEvent); |
| } |
| return result; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////////////// |
| |
| void SkEvent::SignalNonEmptyQueue() |
| { |
| post_skmacevent(); |
| // SkDebugf("signal nonempty\n"); |
| } |
| |
| static TMTask gTMTaskRec; |
| static TMTask* gTMTaskPtr; |
| |
| static void sk_timer_proc(TMTask* rec) |
| { |
| SkEvent::ServiceQueueTimer(); |
| // SkDebugf("timer task fired\n"); |
| } |
| |
| void SkEvent::SignalQueueTimer(SkMSec delay) |
| { |
| if (gTMTaskPtr) |
| { |
| RemoveTimeTask((QElem*)gTMTaskPtr); |
| DisposeTimerUPP(gTMTaskPtr->tmAddr); |
| gTMTaskPtr = nil; |
| } |
| if (delay) |
| { |
| gTMTaskPtr = &gTMTaskRec; |
| memset(gTMTaskPtr, 0, sizeof(gTMTaskRec)); |
| gTMTaskPtr->tmAddr = NewTimerUPP(sk_timer_proc); |
| OSErr err = InstallTimeTask((QElem*)gTMTaskPtr); |
| // SkDebugf("installtimetask of %d returned %d\n", delay, err); |
| PrimeTimeTask((QElem*)gTMTaskPtr, delay); |
| } |
| } |
| |
| #define USE_MSAA 0 |
| |
| AGLContext create_gl(WindowRef wref) |
| { |
| GLint major, minor; |
| AGLContext ctx; |
| |
| aglGetVersion(&major, &minor); |
| SkDebugf("---- agl version %d %d\n", major, minor); |
| |
| const GLint pixelAttrs[] = { |
| AGL_RGBA, |
| AGL_STENCIL_SIZE, 8, |
| #if USE_MSAA |
| AGL_SAMPLE_BUFFERS_ARB, 1, |
| AGL_MULTISAMPLE, |
| AGL_SAMPLES_ARB, 8, |
| #endif |
| AGL_ACCELERATED, |
| AGL_DOUBLEBUFFER, |
| AGL_NONE |
| }; |
| AGLPixelFormat format = aglChoosePixelFormat(NULL, 0, pixelAttrs); |
| //AGLPixelFormat format = aglCreatePixelFormat(pixelAttrs); |
| SkDebugf("----- agl format %p\n", format); |
| ctx = aglCreateContext(format, NULL); |
| SkDebugf("----- agl context %p\n", ctx); |
| aglDestroyPixelFormat(format); |
| |
| static const GLint interval = 1; |
| aglSetInteger(ctx, AGL_SWAP_INTERVAL, &interval); |
| aglSetCurrentContext(ctx); |
| return ctx; |
| } |
| |
| bool SkOSWindow::attachGL() |
| { |
| if (NULL == fAGLCtx) { |
| fAGLCtx = create_gl((WindowRef)fHWND); |
| if (NULL == fAGLCtx) { |
| return false; |
| } |
| } |
| |
| GLboolean success = true; |
| |
| int width, height; |
| |
| success = aglSetWindowRef((AGLContext)fAGLCtx, (WindowRef)fHWND); |
| width = this->width(); |
| height = this->height(); |
| |
| GLenum err = aglGetError(); |
| if (err) { |
| SkDebugf("---- aglSetWindowRef %d %d %s [%d %d]\n", success, err, |
| aglErrorString(err), width, height); |
| } |
| |
| if (success) { |
| glViewport(0, 0, width, height); |
| glClearColor(0, 0, 0, 0); |
| glClearStencil(0); |
| glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); |
| } |
| return success; |
| } |
| |
| void SkOSWindow::detachGL() { |
| aglSetWindowRef((AGLContext)fAGLCtx, NULL); |
| } |
| |
| void SkOSWindow::presentGL() { |
| aglSwapBuffers((AGLContext)fAGLCtx); |
| } |
| |
| #endif |
| |
