The Tor Browser / file comparison

comparison: gfx/skia/trunk/src/views/mac/SkOSWindow_Mac.cpp

gfx/skia/trunk/src/views/mac/SkOSWindow_Mac.cpp

branch
TOR_BUG_9701
changeset 11
deefc01c0e14
equal deleted inserted replaced
-1:000000000000 0:ec0f06ed2742
1 /*
2 * Copyright 2011 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8 #include "SkTypes.h"
9
10 #if defined(SK_BUILD_FOR_MAC)
11
12 #include <AGL/agl.h>
13
14 #include <Carbon/Carbon.h>
15 #include "SkCGUtils.h"
16
17 #include "SkWindow.h"
18 #include "SkCanvas.h"
19 #include "SkOSMenu.h"
20 #include "SkTime.h"
21
22 #include "SkGraphics.h"
23 #include <new.h>
24
25 static void (*gPrevNewHandler)();
26
27 extern "C" {
28 static void sk_new_handler()
29 {
30 if (SkGraphics::SetFontCacheUsed(0))
31 return;
32 if (gPrevNewHandler)
33 gPrevNewHandler();
34 else
35 sk_throw();
36 }
37 }
38
39 static SkOSWindow* gCurrOSWin;
40 static EventTargetRef gEventTarget;
41 static EventQueueRef gCurrEventQ;
42
43 static OSStatus MyDrawEventHandler(EventHandlerCallRef myHandler,
44 EventRef event, void *userData) {
45 // NOTE: GState is save/restored by the HIView system doing the callback,
46 // so the draw handler doesn't need to do it
47
48 OSStatus status = noErr;
49 CGContextRef context;
50 HIRect bounds;
51
52 // Get the CGContextRef
53 status = GetEventParameter (event, kEventParamCGContextRef,
54 typeCGContextRef, NULL,
55 sizeof (CGContextRef),
56 NULL,
57 &context);
58
59 if (status != noErr) {
60 SkDebugf("Got error %d getting the context!\n", status);
61 return status;
62 }
63
64 // Get the bounding rectangle
65 HIViewGetBounds ((HIViewRef) userData, &bounds);
66
67 gCurrOSWin->doPaint(context);
68 return status;
69 }
70
71 #define SK_MacEventClass FOUR_CHAR_CODE('SKec')
72 #define SK_MacEventKind FOUR_CHAR_CODE('SKek')
73 #define SK_MacEventParamName FOUR_CHAR_CODE('SKev')
74 #define SK_MacEventSinkIDParamName FOUR_CHAR_CODE('SKes')
75
76 static void set_bindingside(HISideBinding* side, HIViewRef parent, HIBindingKind kind) {
77 side->toView = parent;
78 side->kind = kind;
79 side->offset = 0;
80 }
81
82 static void set_axisscale(HIAxisScale* axis, HIViewRef parent) {
83 axis->toView = parent;
84 axis->kind = kHILayoutScaleAbsolute;
85 axis->ratio = 1;
86 }
87
88 static void set_axisposition(HIAxisPosition* pos, HIViewRef parent, HIPositionKind kind) {
89 pos->toView = parent;
90 pos->kind = kind;
91 pos->offset = 0;
92 }
93
94 SkOSWindow::SkOSWindow(void* hWnd) : fHWND(hWnd), fAGLCtx(NULL)
95 {
96 OSStatus result;
97 WindowRef wr = (WindowRef)hWnd;
98
99 HIViewRef imageView, parent;
100 HIViewRef rootView = HIViewGetRoot(wr);
101 HIViewFindByID(rootView, kHIViewWindowContentID, &parent);
102 result = HIImageViewCreate(NULL, &imageView);
103 SkASSERT(result == noErr);
104
105 result = HIViewAddSubview(parent, imageView);
106 SkASSERT(result == noErr);
107
108 fHVIEW = imageView;
109
110 HIViewSetVisible(imageView, true);
111 HIViewPlaceInSuperviewAt(imageView, 0, 0);
112
113 if (true) {
114 HILayoutInfo layout;
115 layout.version = kHILayoutInfoVersionZero;
116 set_bindingside(&layout.binding.left, parent, kHILayoutBindLeft);
117 set_bindingside(&layout.binding.top, parent, kHILayoutBindTop);
118 set_bindingside(&layout.binding.right, parent, kHILayoutBindRight);
119 set_bindingside(&layout.binding.bottom, parent, kHILayoutBindBottom);
120 set_axisscale(&layout.scale.x, parent);
121 set_axisscale(&layout.scale.y, parent);
122 set_axisposition(&layout.position.x, parent, kHILayoutPositionLeft);
123 set_axisposition(&layout.position.y, rootView, kHILayoutPositionTop);
124 HIViewSetLayoutInfo(imageView, &layout);
125 }
126
127 HIImageViewSetOpaque(imageView, true);
128 HIImageViewSetScaleToFit(imageView, false);
129
130 static const EventTypeSpec gTypes[] = {
131 { kEventClassKeyboard, kEventRawKeyDown },
132 { kEventClassKeyboard, kEventRawKeyUp },
133 { kEventClassMouse, kEventMouseDown },
134 { kEventClassMouse, kEventMouseDragged },
135 { kEventClassMouse, kEventMouseMoved },
136 { kEventClassMouse, kEventMouseUp },
137 { kEventClassTextInput, kEventTextInputUnicodeForKeyEvent },
138 { kEventClassWindow, kEventWindowBoundsChanged },
139 // { kEventClassWindow, kEventWindowDrawContent },
140 { SK_MacEventClass, SK_MacEventKind }
141 };
142
143 EventHandlerUPP handlerUPP = NewEventHandlerUPP(SkOSWindow::EventHandler);
144 int count = SK_ARRAY_COUNT(gTypes);
145
146 result = InstallEventHandler(GetWindowEventTarget(wr), handlerUPP,
147 count, gTypes, this, nil);
148 SkASSERT(result == noErr);
149
150 gCurrOSWin = this;
151 gCurrEventQ = GetCurrentEventQueue();
152 gEventTarget = GetWindowEventTarget(wr);
153
154 static bool gOnce = true;
155 if (gOnce) {
156 gOnce = false;
157 gPrevNewHandler = set_new_handler(sk_new_handler);
158 }
159 }
160
161 void SkOSWindow::doPaint(void* ctx)
162 {
163 #if 0
164 this->update(NULL);
165
166 const SkBitmap& bm = this->getBitmap();
167 CGImageRef img = SkCreateCGImageRef(bm);
168
169 if (img) {
170 CGRect r = CGRectMake(0, 0, bm.width(), bm.height());
171
172 CGContextRef cg = reinterpret_cast<CGContextRef>(ctx);
173
174 CGContextSaveGState(cg);
175 CGContextTranslateCTM(cg, 0, r.size.height);
176 CGContextScaleCTM(cg, 1, -1);
177
178 CGContextDrawImage(cg, r, img);
179
180 CGContextRestoreGState(cg);
181
182 CGImageRelease(img);
183 }
184 #endif
185 }
186
187 void SkOSWindow::updateSize()
188 {
189 Rect r;
190
191 GetWindowBounds((WindowRef)fHWND, kWindowContentRgn, &r);
192 this->resize(r.right - r.left, r.bottom - r.top);
193
194 #if 0
195 HIRect frame;
196 HIViewRef imageView = (HIViewRef)getHVIEW();
197 HIViewRef parent = HIViewGetSuperview(imageView);
198
199 HIViewGetBounds(imageView, &frame);
200 SkDebugf("------ %d bounds %g %g %g %g\n", r.right - r.left,
201 frame.origin.x, frame.origin.y, frame.size.width, frame.size.height);
202 #endif
203 }
204
205 void SkOSWindow::onHandleInval(const SkIRect& r)
206 {
207 (new SkEvent("inval-imageview", this->getSinkID()))->post();
208 }
209
210 bool SkOSWindow::onEvent(const SkEvent& evt) {
211 if (evt.isType("inval-imageview")) {
212 this->update(NULL);
213
214 SkEvent query("ignore-window-bitmap");
215 if (!this->doQuery(&query) || !query.getFast32()) {
216 const SkBitmap& bm = this->getBitmap();
217
218 CGImageRef img = SkCreateCGImageRef(bm);
219 HIImageViewSetImage((HIViewRef)getHVIEW(), img);
220 CGImageRelease(img);
221 }
222 return true;
223 }
224 return INHERITED::onEvent(evt);
225 }
226
227 void SkOSWindow::onSetTitle(const char title[])
228 {
229 CFStringRef str = CFStringCreateWithCString(NULL, title, kCFStringEncodingUTF8);
230 SetWindowTitleWithCFString((WindowRef)fHWND, str);
231 CFRelease(str);
232 }
233
234 void SkOSWindow::onAddMenu(const SkOSMenu* sk_menu)
235 {
236 }
237
238 static void getparam(EventRef inEvent, OSType name, OSType type, UInt32 size, void* data)
239 {
240 EventParamType actualType;
241 UInt32 actualSize;
242 OSStatus status;
243
244 status = GetEventParameter(inEvent, name, type, &actualType, size, &actualSize, data);
245 SkASSERT(status == noErr);
246 SkASSERT(actualType == type);
247 SkASSERT(actualSize == size);
248 }
249
250 enum {
251 SK_MacReturnKey = 36,
252 SK_MacDeleteKey = 51,
253 SK_MacEndKey = 119,
254 SK_MacLeftKey = 123,
255 SK_MacRightKey = 124,
256 SK_MacDownKey = 125,
257 SK_MacUpKey = 126,
258
259 SK_Mac0Key = 0x52,
260 SK_Mac1Key = 0x53,
261 SK_Mac2Key = 0x54,
262 SK_Mac3Key = 0x55,
263 SK_Mac4Key = 0x56,
264 SK_Mac5Key = 0x57,
265 SK_Mac6Key = 0x58,
266 SK_Mac7Key = 0x59,
267 SK_Mac8Key = 0x5b,
268 SK_Mac9Key = 0x5c
269 };
270
271 static SkKey raw2key(UInt32 raw)
272 {
273 static const struct {
274 UInt32 fRaw;
275 SkKey fKey;
276 } gKeys[] = {
277 { SK_MacUpKey, kUp_SkKey },
278 { SK_MacDownKey, kDown_SkKey },
279 { SK_MacLeftKey, kLeft_SkKey },
280 { SK_MacRightKey, kRight_SkKey },
281 { SK_MacReturnKey, kOK_SkKey },
282 { SK_MacDeleteKey, kBack_SkKey },
283 { SK_MacEndKey, kEnd_SkKey },
284 { SK_Mac0Key, k0_SkKey },
285 { SK_Mac1Key, k1_SkKey },
286 { SK_Mac2Key, k2_SkKey },
287 { SK_Mac3Key, k3_SkKey },
288 { SK_Mac4Key, k4_SkKey },
289 { SK_Mac5Key, k5_SkKey },
290 { SK_Mac6Key, k6_SkKey },
291 { SK_Mac7Key, k7_SkKey },
292 { SK_Mac8Key, k8_SkKey },
293 { SK_Mac9Key, k9_SkKey }
294 };
295
296 for (unsigned i = 0; i < SK_ARRAY_COUNT(gKeys); i++)
297 if (gKeys[i].fRaw == raw)
298 return gKeys[i].fKey;
299 return kNONE_SkKey;
300 }
301
302 static void post_skmacevent()
303 {
304 EventRef ref;
305 OSStatus status = CreateEvent(nil, SK_MacEventClass, SK_MacEventKind, 0, 0, &ref);
306 SkASSERT(status == noErr);
307
308 #if 0
309 status = SetEventParameter(ref, SK_MacEventParamName, SK_MacEventParamName, sizeof(evt), &evt);
310 SkASSERT(status == noErr);
311 status = SetEventParameter(ref, SK_MacEventSinkIDParamName, SK_MacEventSinkIDParamName, sizeof(sinkID), &sinkID);
312 SkASSERT(status == noErr);
313 #endif
314
315 EventTargetRef target = gEventTarget;
316 SetEventParameter(ref, kEventParamPostTarget, typeEventTargetRef, sizeof(target), &target);
317 SkASSERT(status == noErr);
318
319 status = PostEventToQueue(gCurrEventQ, ref, kEventPriorityStandard);
320 SkASSERT(status == noErr);
321
322 ReleaseEvent(ref);
323 }
324
325 pascal OSStatus SkOSWindow::EventHandler( EventHandlerCallRef inHandler, EventRef inEvent, void* userData )
326 {
327 SkOSWindow* win = (SkOSWindow*)userData;
328 OSStatus result = eventNotHandledErr;
329 UInt32 wClass = GetEventClass(inEvent);
330 UInt32 wKind = GetEventKind(inEvent);
331
332 gCurrOSWin = win; // will need to be in TLS. Set this so PostEvent will work
333
334 switch (wClass) {
335 case kEventClassMouse: {
336 Point pt;
337 getparam(inEvent, kEventParamMouseLocation, typeQDPoint, sizeof(pt), &pt);
338 SetPortWindowPort((WindowRef)win->getHWND());
339 GlobalToLocal(&pt);
340
341 switch (wKind) {
342 case kEventMouseDown:
343 if (win->handleClick(pt.h, pt.v, Click::kDown_State)) {
344 result = noErr;
345 }
346 break;
347 case kEventMouseMoved:
348 // fall through
349 case kEventMouseDragged:
350 (void)win->handleClick(pt.h, pt.v, Click::kMoved_State);
351 // result = noErr;
352 break;
353 case kEventMouseUp:
354 (void)win->handleClick(pt.h, pt.v, Click::kUp_State);
355 // result = noErr;
356 break;
357 default:
358 break;
359 }
360 break;
361 }
362 case kEventClassKeyboard:
363 if (wKind == kEventRawKeyDown) {
364 UInt32 raw;
365 getparam(inEvent, kEventParamKeyCode, typeUInt32, sizeof(raw), &raw);
366 SkKey key = raw2key(raw);
367 if (key != kNONE_SkKey)
368 (void)win->handleKey(key);
369 } else if (wKind == kEventRawKeyUp) {
370 UInt32 raw;
371 getparam(inEvent, kEventParamKeyCode, typeUInt32, sizeof(raw), &raw);
372 SkKey key = raw2key(raw);
373 if (key != kNONE_SkKey)
374 (void)win->handleKeyUp(key);
375 }
376 break;
377 case kEventClassTextInput:
378 if (wKind == kEventTextInputUnicodeForKeyEvent) {
379 UInt16 uni;
380 getparam(inEvent, kEventParamTextInputSendText, typeUnicodeText, sizeof(uni), &uni);
381 win->handleChar(uni);
382 }
383 break;
384 case kEventClassWindow:
385 switch (wKind) {
386 case kEventWindowBoundsChanged:
387 win->updateSize();
388 break;
389 case kEventWindowDrawContent: {
390 CGContextRef cg;
391 result = GetEventParameter(inEvent,
392 kEventParamCGContextRef,
393 typeCGContextRef,
394 NULL,
395 sizeof (CGContextRef),
396 NULL,
397 &cg);
398 if (result != 0) {
399 cg = NULL;
400 }
401 win->doPaint(cg);
402 break;
403 }
404 default:
405 break;
406 }
407 break;
408 case SK_MacEventClass: {
409 SkASSERT(wKind == SK_MacEventKind);
410 if (SkEvent::ProcessEvent()) {
411 post_skmacevent();
412 }
413 #if 0
414 SkEvent* evt;
415 SkEventSinkID sinkID;
416 getparam(inEvent, SK_MacEventParamName, SK_MacEventParamName, sizeof(evt), &evt);
417 getparam(inEvent, SK_MacEventSinkIDParamName, SK_MacEventSinkIDParamName, sizeof(sinkID), &sinkID);
418 #endif
419 result = noErr;
420 break;
421 }
422 default:
423 break;
424 }
425 if (result == eventNotHandledErr) {
426 result = CallNextEventHandler(inHandler, inEvent);
427 }
428 return result;
429 }
430
431 ///////////////////////////////////////////////////////////////////////////////////////
432
433 void SkEvent::SignalNonEmptyQueue()
434 {
435 post_skmacevent();
436 // SkDebugf("signal nonempty\n");
437 }
438
439 static TMTask gTMTaskRec;
440 static TMTask* gTMTaskPtr;
441
442 static void sk_timer_proc(TMTask* rec)
443 {
444 SkEvent::ServiceQueueTimer();
445 // SkDebugf("timer task fired\n");
446 }
447
448 void SkEvent::SignalQueueTimer(SkMSec delay)
449 {
450 if (gTMTaskPtr)
451 {
452 RemoveTimeTask((QElem*)gTMTaskPtr);
453 DisposeTimerUPP(gTMTaskPtr->tmAddr);
454 gTMTaskPtr = nil;
455 }
456 if (delay)
457 {
458 gTMTaskPtr = &gTMTaskRec;
459 memset(gTMTaskPtr, 0, sizeof(gTMTaskRec));
460 gTMTaskPtr->tmAddr = NewTimerUPP(sk_timer_proc);
461 OSErr err = InstallTimeTask((QElem*)gTMTaskPtr);
462 // SkDebugf("installtimetask of %d returned %d\n", delay, err);
463 PrimeTimeTask((QElem*)gTMTaskPtr, delay);
464 }
465 }
466
467 #define USE_MSAA 0
468
469 AGLContext create_gl(WindowRef wref)
470 {
471 GLint major, minor;
472 AGLContext ctx;
473
474 aglGetVersion(&major, &minor);
475 SkDebugf("---- agl version %d %d\n", major, minor);
476
477 const GLint pixelAttrs[] = {
478 AGL_RGBA,
479 AGL_STENCIL_SIZE, 8,
480 #if USE_MSAA
481 AGL_SAMPLE_BUFFERS_ARB, 1,
482 AGL_MULTISAMPLE,
483 AGL_SAMPLES_ARB, 8,
484 #endif
485 AGL_ACCELERATED,
486 AGL_DOUBLEBUFFER,
487 AGL_NONE
488 };
489 AGLPixelFormat format = aglChoosePixelFormat(NULL, 0, pixelAttrs);
490 //AGLPixelFormat format = aglCreatePixelFormat(pixelAttrs);
491 SkDebugf("----- agl format %p\n", format);
492 ctx = aglCreateContext(format, NULL);
493 SkDebugf("----- agl context %p\n", ctx);
494 aglDestroyPixelFormat(format);
495
496 static const GLint interval = 1;
497 aglSetInteger(ctx, AGL_SWAP_INTERVAL, &interval);
498 aglSetCurrentContext(ctx);
499 return ctx;
500 }
501
502 bool SkOSWindow::attach(SkBackEndTypes /* attachType */)
503 {
504 if (NULL == fAGLCtx) {
505 fAGLCtx = create_gl((WindowRef)fHWND);
506 if (NULL == fAGLCtx) {
507 return false;
508 }
509 }
510
511 GLboolean success = true;
512
513 int width, height;
514
515 success = aglSetWindowRef((AGLContext)fAGLCtx, (WindowRef)fHWND);
516 width = this->width();
517 height = this->height();
518
519 GLenum err = aglGetError();
520 if (err) {
521 SkDebugf("---- aglSetWindowRef %d %d %s [%d %d]\n", success, err,
522 aglErrorString(err), width, height);
523 }
524
525 if (success) {
526 glViewport(0, 0, width, height);
527 glClearColor(0, 0, 0, 0);
528 glClearStencil(0);
529 glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
530 }
531 return success;
532 }
533
534 void SkOSWindow::detach() {
535 aglSetWindowRef((AGLContext)fAGLCtx, NULL);
536 }
537
538 void SkOSWindow::present() {
539 aglSwapBuffers((AGLContext)fAGLCtx);
540 }
541
542 #endif

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial