VirtualBox

source: vbox/trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu_cocoa_helper.m@ 69500

Last change on this file since 69500 was 69500, checked in by vboxsync, 7 years ago

*: scm --update-copyright-year
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 101.3 KB
Line 
1/* $Id: renderspu_cocoa_helper.m 69500 2017-10-28 15:14:05Z vboxsync $ */
2/** @file
3 * VirtualBox OpenGL Cocoa Window System Helper Implementation.
4 *
5 * This source file is shared between the SharedOpenGL HGCM service and the
6 * SVGA3d emulation.
7 */
8
9/*
10 * Copyright (C) 2009-2017 Oracle Corporation
11 *
12 * This file is part of VirtualBox Open Source Edition (OSE), as
13 * available from http://www.virtualbox.org. This file is free software;
14 * you can redistribute it and/or modify it under the terms of the GNU
15 * General Public License (GPL) as published by the Free Software
16 * Foundation, in version 2 as it comes in the "COPYING" file of the
17 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
18 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
19 */
20
21/** @page pg_opengl_cocoa OpenGL - Cocoa Window System Helper
22 *
23 * How this works:
24 * In general it is not so easy like on the other platforms, cause Cocoa
25 * doesn't support any clipping of already painted stuff. In Mac OS X there is
26 * the concept of translucent canvas's e.g. windows and there it is just
27 * painted what should be visible to the user. Unfortunately this isn't the
28 * concept of chromium. Therefor I reroute all OpenGL operation from the guest
29 * to a frame buffer object (FBO). This is a OpenGL extension, which is
30 * supported by all OS X versions we support (AFAIC tell). Of course the guest
31 * doesn't know that and we have to make sure that the OpenGL state always is
32 * in the right state to paint into the FBO and not to the front/back buffer.
33 * Several functions below (like cocoaBindFramebufferEXT, cocoaGetIntegerv,
34 * ...) doing this. When a swap or finish is triggered by the guest, the
35 * content (which is already bound to an texture) is painted on the screen
36 * within a separate OpenGL context. This allows the usage of the same
37 * resources (texture ids, buffers ...) but at the same time having an
38 * different internal OpenGL state. Another advantage is that we can paint a
39 * thumbnail of the current output in a much more smaller (GPU accelerated
40 * scale) version on a third context and use glReadPixels to get the actual
41 * data. glReadPixels is a very slow operation, but as we just use a much more
42 * smaller image, we can handle it (anyway this is only done 5 times per
43 * second).
44 *
45 * Other things to know:
46 * - If the guest request double buffering, we have to make sure there are two
47 * buffers. We use the same FBO with 2 color attachments. Also glDrawBuffer
48 * and glReadBuffer is intercepted to make sure it is painted/read to/from
49 * the correct buffers. On swap our buffers are swapped and not the
50 * front/back buffer.
51 * - If the guest request a depth/stencil buffer, a combined render buffer for
52 * this is created.
53 * - If the size of the guest OpenGL window changes, all FBO's, textures, ...
54 * need to be recreated.
55 * - We need to track any changes to the parent window
56 * (create/destroy/move/resize). The various classes like OverlayHelperView,
57 * OverlayWindow, ... are there for.
58 * - The HGCM service runs on a other thread than the Main GUI. Keeps this
59 * always in mind (see e.g. performSelectorOnMainThread in renderFBOToView)
60 * - We make heavy use of late binding. We can not be sure that the GUI (or any
61 * other third party GUI), overwrite our NSOpenGLContext. So we always ask if
62 * this is our own one, before use. Really neat concept of Objective-C/Cocoa
63 * ;)
64 *
65 */
66
67
68/*********************************************************************************************************************************
69* Header Files *
70*********************************************************************************************************************************/
71#ifdef IN_VMSVGA3D
72# define LOG_GROUP LOG_GROUP_DEV_VMSVGA
73#endif
74#include "renderspu_cocoa_helper.h"
75
76#import <Cocoa/Cocoa.h>
77#undef PVM /* sys/param.h (included via Cocoa.h) pollutes the namespace with this define. */
78
79#ifndef IN_VMSVGA3D
80# include "chromium.h" /* For the visual bits of chromium */
81#endif
82
83#include <iprt/assert.h>
84#include <iprt/critsect.h>
85#include <iprt/mem.h>
86#include <iprt/string.h>
87#include <iprt/time.h>
88#include <iprt/thread.h>
89
90#include <VBox/VBoxOGL.h>
91#include <VBox/log.h>
92
93#ifdef IN_VMSVGA3D
94# include "DevVGA-SVGA3d-cocoa.h"
95# include <OpenGL/OpenGL.h>
96# include <OpenGL/gl3.h>
97# include <OpenGL/gl3ext.h>
98# include <OpenGL/glext.h>
99#else
100# include <cr_vreg.h>
101# include <cr_error.h>
102# include <cr_blitter.h>
103# ifdef VBOX_WITH_CRDUMPER_THUMBNAIL
104# include <cr_pixeldata.h>
105# endif
106# include "renderspu.h"
107#endif
108
109
110
111/*********************************************************************************************************************************
112* Defined Constants And Macros *
113*********************************************************************************************************************************/
114/* Debug macros */
115/** @def FBO
116 * Disable this to see how the output is without the FBO in the middle of the processing chain. */
117#define FBO 1
118/** @def CR_RENDER_FORCE_PRESENT_MAIN_THREAD
119 * Force present schedule to main thread. */
120/** @def SHOW_WINDOW_BACKGROUND
121 * Define this to see the window background even if the window is clipped. */
122/** @def DEBUG_VERBOSE
123 * Define this to get some debug info about the messages flow. */
124#if 0 || defined(DOXYGEN_RUNNING)
125# define CR_RENDER_FORCE_PRESENT_MAIN_THREAD
126# define SHOW_WINDOW_BACKGROUND 1
127# define DEBUG_VERBOSE
128#endif
129
130#ifdef DEBUG_VERBOSE
131# error "should be disabled!"
132# ifdef IN_VMSVGA3D
133# define DEBUG_INFO(text) do { LogRel(text); AssertFailed(); } while (0)
134# define DEBUG_WARN(text) do { LogRel(text); AssertFailed(); } while (0)
135# else
136# define DEBUG_INFO(text) do { LogRel(text); AssertFailed(); } while (0)
137# define DEBUG_WARN(text) do { LogRel(text); AssertFailed(); } while (0)
138# endif
139
140# define DEBUG_MSG(text) do { LogRel(text); } while (0)
141# define DEBUG_MSG_1(text) do { LogRel(text); } while (0)
142
143#else
144
145# ifdef IN_VMSVGA3D
146# define DEBUG_INFO(text) do { LogRel(text); } while (0)
147# define DEBUG_WARN(text) do { LogRel(text); } while (0)
148# else
149# define DEBUG_INFO(text) do { crInfo text; } while (0)
150# define DEBUG_WARN(text) do { crWarning text; } while (0)
151#endif
152# define DEBUG_MSG(text) do {} while (0)
153# define DEBUG_MSG_1(text) do {} while (0)
154
155#endif
156#ifdef IN_VMSVGA3D
157# define DEBUG_MSG_NOT_VMSVGA3D(a_TextArgs) do {} while (0)
158# define COCOA_LOG_FLOW(a_TextArgs) LogFlow(a_TextArgs)
159#else
160# define DEBUG_MSG_NOT_VMSVGA3D(a_TextArgs) DEBUG_MSG(a_TextArgs)
161# define COCOA_LOG_FLOW(a_TextArgs) DEBUG_MSG(a_TextArgs)
162#endif
163
164
165#define DEBUG_FUNC_ENTER() DEBUG_MSG(("==>%s\n", __PRETTY_FUNCTION__))
166#define DEBUG_FUNC_LEAVE() DEBUG_MSG(("<==%s\n", __PRETTY_FUNCTION__))
167
168#define DEBUG_GL_SAVE_STATE() \
169 do { \
170 glPushAttrib(GL_ALL_ATTRIB_BITS); \
171 glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS); \
172 glMatrixMode(GL_PROJECTION); \
173 glPushMatrix(); \
174 glMatrixMode(GL_TEXTURE); \
175 glPushMatrix(); \
176 glMatrixMode(GL_COLOR); \
177 glPushMatrix(); \
178 glMatrixMode(GL_MODELVIEW); \
179 glPushMatrix(); \
180 } while (0)
181
182#define DEBUG_GL_RESTORE_STATE() \
183 do { \
184 glMatrixMode(GL_MODELVIEW); \
185 glPopMatrix(); \
186 glMatrixMode(GL_COLOR); \
187 glPopMatrix(); \
188 glMatrixMode(GL_TEXTURE); \
189 glPopMatrix(); \
190 glMatrixMode(GL_PROJECTION); \
191 glPopMatrix(); \
192 glPopClientAttrib(); \
193 glPopAttrib(); \
194 } while (0)
195
196#ifdef VBOX_STRICT
197# define DEBUG_CLEAR_GL_ERRORS() \
198 do { \
199 while (glGetError() != GL_NO_ERROR) \
200 { /* nothing */ } \
201 } while (0)
202# define DEBUG_CHECK_GL_ERROR(a_szOp) \
203 do { \
204 GLenum iGlCheckErr = glGetError(); \
205 if (RT_UNLIKELY(iGlCheckErr != GL_NO_ERROR)) \
206 AssertMsgFailed((a_szOp ": iGlCheckErr=%#x\n", iGlCheckErr)); \
207 } while (0)
208#else
209# define DEBUG_CLEAR_GL_ERRORS() do {} while (0)
210# define DEBUG_CHECK_GL_ERROR(a_szOp) do {} while (0)
211#endif
212
213/* Whether we control NSView automatic content zooming on Retina/HiDPI displays. */
214#define VBOX_WITH_CONFIGURABLE_HIDPI_SCALING 1
215
216
217#ifdef IN_VMSVGA3D
218
219/*
220 * VMSVGA3D compatibility glue.
221 */
222typedef struct WindowInfo WindowInfo;
223
224# define CR_RGB_BIT RT_BIT_32(0)
225
226# define CR_ALPHA_BIT RT_BIT_32(1)
227# define CR_DEPTH_BIT RT_BIT_32(2)
228# define CR_STENCIL_BIT RT_BIT_32(3)
229# define CR_ACCUM_BIT RT_BIT_32(4)
230# define CR_DOUBLE_BIT RT_BIT_32(5)
231# define CR_STEREO_BIT RT_BIT_32(6)
232# define CR_MULTISAMPLE_BIT RT_BIT_32(7)
233
234# define CR_OVERLAY_BIT RT_BIT_32(8)
235# define CR_PBUFFER_BIT RT_BIT_32(9)
236# define VMSVGA3D_NON_DEFAULT_PROFILE_BIT RT_BIT_32(31)
237# define CR_ALL_BITS UINT32_C(0x800003ff)
238
239#endif /* IN_VMSVGA3D */
240
241
242/**
243 * Works functions that creates a NSOpenGLPixelFormat instance.
244 *
245 * @returns Instance.
246 * @param fVisParams Context flags.
247 */
248static NSOpenGLPixelFormat *vboxCreatePixelFormat(GLbitfield fVisParams)
249{
250 NSOpenGLPixelFormatAttribute attribs[24] =
251 {
252#ifdef IN_VMSVGA3D
253 NSOpenGLPFAOpenGLProfile, (NSOpenGLPixelFormatAttribute)0,
254#endif
255 NSOpenGLPFAAccelerated,
256 NSOpenGLPFAColorSize, (NSOpenGLPixelFormatAttribute)24
257 };
258#ifndef IN_VMSVGA3D
259 int i = 3;
260#else
261 int i = 3+2;
262 if (fVisParams & VMSVGA3D_NON_DEFAULT_PROFILE_BIT)
263 attribs[1] = VBOX_VMSVGA3D_DEFAULT_OGL_PROFILE >= 3.2 ? NSOpenGLProfileVersionLegacy : NSOpenGLProfileVersion3_2Core;
264 else
265 attribs[1] = VBOX_VMSVGA3D_DEFAULT_OGL_PROFILE >= 3.2 ? NSOpenGLProfileVersion3_2Core : NSOpenGLProfileVersionLegacy;
266#endif
267
268 if (fVisParams & CR_ALPHA_BIT)
269 {
270 COCOA_LOG_FLOW((" CR_ALPHA_BIT requested\n"));
271 attribs[i++] = NSOpenGLPFAAlphaSize;
272 attribs[i++] = 8;
273 }
274 if (fVisParams & CR_DEPTH_BIT)
275 {
276 COCOA_LOG_FLOW((" CR_DEPTH_BIT requested\n"));
277 attribs[i++] = NSOpenGLPFADepthSize;
278 attribs[i++] = 24;
279 }
280 if (fVisParams & CR_STENCIL_BIT)
281 {
282 COCOA_LOG_FLOW((" CR_STENCIL_BIT requested\n"));
283 attribs[i++] = NSOpenGLPFAStencilSize;
284 attribs[i++] = 8;
285 }
286 if (fVisParams & CR_ACCUM_BIT)
287 {
288 COCOA_LOG_FLOW((" CR_ACCUM_BIT requested\n"));
289 attribs[i++] = NSOpenGLPFAAccumSize;
290 if (fVisParams & CR_ALPHA_BIT)
291 attribs[i++] = 32;
292 else
293 attribs[i++] = 24;
294 }
295 if (fVisParams & CR_MULTISAMPLE_BIT)
296 {
297 COCOA_LOG_FLOW((" CR_MULTISAMPLE_BIT requested\n"));
298 attribs[i++] = NSOpenGLPFASampleBuffers;
299 attribs[i++] = 1;
300 attribs[i++] = NSOpenGLPFASamples;
301 attribs[i++] = 4;
302 }
303 if (fVisParams & CR_DOUBLE_BIT)
304 {
305 COCOA_LOG_FLOW((" CR_DOUBLE_BIT requested\n"));
306 attribs[i++] = NSOpenGLPFADoubleBuffer;
307 }
308 if (fVisParams & CR_STEREO_BIT)
309 {
310 /* We don't support that.
311 COCOA_LOG_FLOW((" CR_STEREO_BIT requested\n"));
312 attribs[i++] = NSOpenGLPFAStereo;
313 */
314 }
315
316 if (VBoxOglIsOfflineRenderingAppropriate())
317 {
318 COCOA_LOG_FLOW((" Offline rendering is enabled\n"));
319 attribs[i++] = NSOpenGLPFAAllowOfflineRenderers;
320 }
321
322 /* Mark the end */
323 attribs[i++] = 0;
324
325 /* Instantiate the pixel format object. */
326 return [[NSOpenGLPixelFormat alloc] initWithAttributes:attribs];
327}
328
329
330static NSOpenGLContext *vboxCtxGetCurrent(void)
331{
332#ifdef IN_VMSVGA3D
333 return [NSOpenGLContext currentContext];
334#else
335 GET_CONTEXT(pCtxInfo);
336 if (pCtxInfo)
337 {
338 Assert(pCtxInfo->context);
339 return pCtxInfo->context;
340 }
341 return nil;
342#endif
343}
344
345static bool vboxCtxSyncCurrentInfo(void)
346{
347#ifdef IN_VMSVGA3D
348 return false;
349#else
350 bool fAdjusted = false;
351 GET_CONTEXT(pCtxInfo);
352 NSOpenGLContext *pCtx = [NSOpenGLContext currentContext];
353 NSView *pView = pCtx ? [pCtx view] : nil;
354 if (pCtxInfo)
355 {
356 WindowInfo *pWinInfo = pCtxInfo->currentWindow;
357 Assert(pWinInfo);
358 if ( pCtxInfo->context != pCtx
359 || pWinInfo->window != pView)
360 {
361 renderspu_SystemMakeCurrent(pWinInfo, 0, pCtxInfo);
362 fAdjusted = true;
363 }
364 }
365 else if (pCtx)
366 {
367 [NSOpenGLContext clearCurrentContext];
368 fAdjusted = true;
369 }
370
371 return fAdjusted;
372#endif
373}
374
375
376/**
377 * State carrying structure for use with vboxCtxEnter and vboxCtxLeave
378 */
379typedef struct VBOX_CR_RENDER_CTX_INFO
380{
381 bool fIsValid;
382 NSOpenGLContext *pCtx;
383 NSView *pView;
384} VBOX_CR_RENDER_CTX_INFO;
385/** Pointer to render context info for use with vboxCtxEnter/Leave. */
386typedef VBOX_CR_RENDER_CTX_INFO *PVBOX_CR_RENDER_CTX_INFO;
387
388static void vboxCtxEnter(NSOpenGLContext *pNewCtx, PVBOX_CR_RENDER_CTX_INFO pCtxInfo)
389{
390 NSOpenGLContext *pOldCtx = vboxCtxGetCurrent();
391 NSView *pOldView = pOldCtx ? [pOldCtx view] : nil;
392 NSView *pNewView = [pNewCtx view];
393
394 Assert(pNewCtx);
395
396 if ( pOldCtx != pNewCtx
397 || pOldView != pNewView)
398 {
399 if (pOldCtx != nil)
400 glFlush();
401
402 DEBUG_CLEAR_GL_ERRORS();
403 [pNewCtx makeCurrentContext];
404 DEBUG_CHECK_GL_ERROR("makeCurrentContext");
405
406 pCtxInfo->fIsValid = true;
407 pCtxInfo->pCtx = pOldCtx;
408 /** @todo r=bird: Why do we save the NEW VIEW here? vboxCtxLeave calls it 'pOldView'. Bug? */
409 pCtxInfo->pView = pNewView;
410 }
411 else
412 {
413 /* No context switch necessary. */
414 pCtxInfo->fIsValid = false;
415 }
416}
417
418static void vboxCtxLeave(PVBOX_CR_RENDER_CTX_INFO pCtxInfo)
419{
420 if (pCtxInfo->fIsValid)
421 {
422 NSOpenGLContext *pOldCtx = pCtxInfo->pCtx;
423 NSView *pOldView = pCtxInfo->pView;
424
425 glFlush();
426 if (pOldCtx != nil)
427 {
428 /* vboxCtxEnter saves the new view, not the old. So, what we actually
429 do here is switching the view of the old context to that of the new
430 one (wrt vboxCtxEnter) before making it current. */
431 /** @todo r=bird: Figure out what we really want to do here, and either rename
432 * pOldView or fix the code. */
433 if ([pOldCtx view] != pOldView)
434 {
435 DEBUG_CLEAR_GL_ERRORS();
436 [pOldCtx setView: pOldView];
437 DEBUG_CHECK_GL_ERROR("setView");
438 }
439
440 DEBUG_CLEAR_GL_ERRORS();
441 [pOldCtx makeCurrentContext];
442 DEBUG_CHECK_GL_ERROR("makeCurrentContext");
443
444#ifdef VBOX_STRICT
445 {
446 NSOpenGLContext *pTstOldCtx = [NSOpenGLContext currentContext];
447 NSView *pTstOldView = pTstOldCtx ? [pTstOldCtx view] : nil;
448 Assert(pTstOldCtx == pOldCtx);
449 Assert(pTstOldView == pOldView);
450 }
451#endif
452 }
453 else
454 {
455 [NSOpenGLContext clearCurrentContext];
456 }
457 }
458}
459
460
461/**
462 * Custom OpenGL context class.
463 *
464 * This implementation doesn't allow to set a view to the context, but save the
465 * view for later use. Also it saves a copy of the pixel format used to create
466 * that context for later use.
467 */
468@interface OverlayOpenGLContext: NSOpenGLContext
469{
470@private
471 NSOpenGLPixelFormat *m_pPixelFormat;
472 NSView *m_pView;
473}
474- (NSOpenGLPixelFormat *)openGLPixelFormat;
475@end
476
477/**
478 * Abstrack task class.
479 */
480@interface VBoxTask : NSObject
481{
482}
483- (void)run;
484@end
485
486@implementation VBoxTask
487/** Run method that the child classes must reimplement.
488 * This will abort the process. */
489- (void)run
490{
491 AssertReleaseFailed();
492}
493@end
494
495
496/**
497 * Generic task class for executing a given method select.
498 */
499@interface VBoxTaskPerformSelector : VBoxTask
500{
501@private
502 id m_Object;
503 SEL m_Selector;
504 id m_Arg;
505}
506- (id)initWithObject:(id)aObject selector:(SEL)aSelector arg:(id)aArg;
507- (void)run;
508- (void)dealloc;
509@end
510
511@implementation VBoxTaskPerformSelector
512
513/**
514 * Initializes a VBoxTaskPerformSelector.
515 *
516 * @param aObject The object (reference not consumed).
517 * @param aSelector The method selector.
518 * @param aArg The method argument (reference not consumed).
519 */
520- (id)initWithObject:(id)aObject selector:(SEL)aSelector arg:(id)aArg
521{
522 self = [super init];
523 if (self)
524 {
525 [aObject retain];
526 m_Object = aObject;
527 m_Selector = aSelector;
528 if (aArg != nil)
529 [aArg retain];
530 m_Arg = aArg;
531 }
532
533 return self;
534}
535
536- (void)run
537{
538 [m_Object performSelector:m_Selector withObject:m_Arg];
539}
540
541- (void)dealloc
542{
543 [m_Object release];
544 if (m_Arg != nil)
545 [m_Arg release];
546
547 [super dealloc];
548}
549@end
550
551
552/**
553 *
554 */
555@interface VBoxTaskComposite : VBoxTask
556{
557@private
558 NSUInteger m_CurIndex;
559 RTCRITSECT m_Lock;
560 NSMutableArray *m_pArray;
561}
562- (id)init;
563- (void)add:(VBoxTask *)pTask;
564- (void)run;
565- (void)dealloc;
566@end
567
568@implementation VBoxTaskComposite
569- (id)init
570{
571 self = [super init];
572
573 if (self)
574 {
575 int rc = RTCritSectInit(&m_Lock);
576 if (!RT_SUCCESS(rc))
577 {
578 DEBUG_WARN(("RTCritSectInit failed %d\n", rc));
579 return nil;
580 }
581
582 m_CurIndex = 0;
583
584 m_pArray = [[NSMutableArray alloc] init];
585 }
586
587 return self;
588}
589
590/**
591 * Adds a task to the composite task object.
592 *
593 * @param pTask Task to add. Reference is NOT consumed.
594 */
595- (void)add:(VBoxTask *)pTask
596{
597 [pTask retain];
598 int rc = RTCritSectEnter(&m_Lock);
599 if (RT_SUCCESS(rc))
600 {
601 [m_pArray addObject:pTask];
602 RTCritSectLeave(&m_Lock);
603 }
604 else
605 {
606 DEBUG_WARN(("RTCritSectEnter failed %d\n", rc));
607 [pTask release];
608 }
609}
610
611- (void)run
612{
613 for (;;)
614 {
615 /*
616 * Dequeue a task.
617 */
618 int rc = RTCritSectEnter(&m_Lock);
619 if (RT_FAILURE(rc))
620 {
621 DEBUG_WARN(("RTCritSectEnter failed %d\n", rc));
622 break;
623 }
624
625 NSUInteger count = [m_pArray count];
626 Assert(m_CurIndex <= count);
627 if (m_CurIndex == count)
628 {
629 [m_pArray removeAllObjects];
630 m_CurIndex = 0;
631 RTCritSectLeave(&m_Lock);
632 break;
633 }
634
635 VBoxTask *pTask = (VBoxTask *)[m_pArray objectAtIndex:m_CurIndex];
636 Assert(pTask != nil);
637
638 ++m_CurIndex;
639
640 /*
641 * Remove the first 1025 empty entires.
642 */
643 if (m_CurIndex > 1024)
644 {
645 NSRange range;
646 range.location = 0;
647 range.length = m_CurIndex;
648 [m_pArray removeObjectsInRange:range];
649 m_CurIndex = 0;
650 }
651 RTCritSectLeave(&m_Lock);
652
653 /*
654 * Run the task and release it.
655 */
656 [pTask run];
657 [pTask release];
658 }
659}
660
661- (void)dealloc
662{
663 NSUInteger count = [m_pArray count];
664 for (;m_CurIndex < count; ++m_CurIndex)
665 {
666 VBoxTask *pTask = (VBoxTask*)[m_pArray objectAtIndex:m_CurIndex];
667 DEBUG_WARN(("dealloc with non-empty tasks! %p\n", pTask));
668 [pTask release];
669 }
670
671 [m_pArray release];
672 RTCritSectDelete(&m_Lock);
673
674 [super dealloc];
675}
676@end
677
678
679/**
680 *
681 *
682 */
683@interface VBoxMainThreadTaskRunner : NSObject
684{
685@private
686 VBoxTaskComposite *m_pTasks;
687}
688- (id)init;
689- (void)add:(VBoxTask *)pTask;
690- (void)addObj:(id)aObject selector:(SEL)aSelector arg:(id)aArg;
691- (void)runTasks;
692- (bool)runTasksSyncIfPossible;
693- (void)dealloc;
694+ (VBoxMainThreadTaskRunner *) globalInstance;
695@end
696
697@implementation VBoxMainThreadTaskRunner
698- (id)init
699{
700 self = [super init];
701 if (self)
702 {
703 m_pTasks = [[VBoxTaskComposite alloc] init];
704 }
705
706 return self;
707}
708
709+ (VBoxMainThreadTaskRunner *) globalInstance
710{
711 static dispatch_once_t s_DispatchOnce;
712 static VBoxMainThreadTaskRunner *s_pRunner = nil;
713 dispatch_once(&s_DispatchOnce, ^{
714 s_pRunner = [[VBoxMainThreadTaskRunner alloc] init];
715 });
716 return s_pRunner;
717}
718
719- (void)add:(VBoxTask *)pTask
720{
721 DEBUG_FUNC_ENTER();
722 [m_pTasks add:pTask];
723 /** @todo r=bird: Unbalanced [self retain]. */
724 [self retain];
725
726 if (![self runTasksSyncIfPossible])
727 {
728 DEBUG_MSG(("task will be processed async\n"));
729 [self performSelectorOnMainThread:@selector(runTasks) withObject:nil waitUntilDone:NO];
730 }
731
732 DEBUG_FUNC_LEAVE();
733}
734
735/**
736 * Adds a task calling an object method (selector).
737 *
738 * @param aObject The object (reference not consumed)..
739 * @param aSelector The method selector.
740 * @param aArg The method argument (reference not consumed).
741 */
742- (void)addObj:(id)aObject selector:(SEL)aSelector arg:(id)aArg
743{
744 VBoxTaskPerformSelector *pSelTask = [[VBoxTaskPerformSelector alloc] initWithObject:aObject selector:aSelector arg:aArg];
745 [self add:pSelTask];
746 [pSelTask release];
747}
748
749
750/**
751 * Internal method for running the pending tasks.
752 */
753- (void)runTasks
754{
755 if ([NSThread isMainThread])
756 {
757 [m_pTasks run];
758 /** @todo r=bird: This release and the retain in the add method aren't
759 * necessarily balanced if there are more than one call to add().
760 *
761 * This could probably end up deleting the singleton prematurely and leave
762 * globalInstance() returning pointers to a stale object in freed memory,
763 * quite possibly causing crashes or/and heap corruption. */
764 [self release];
765 }
766 else
767 {
768 DEBUG_WARN(("run tasks called not on main thread!\n"));
769#ifndef DEBUG_VERBOSE
770 AssertFailed();
771#endif
772 [self performSelectorOnMainThread:@selector(runTasks) withObject:nil waitUntilDone:YES];
773 }
774}
775
776/**
777 * Callback for calling runTasks via renderspuCalloutClient.
778 * @param pvUser The VBoxMainThreadTaskRunner singleton.
779 */
780static DECLCALLBACK(void) VBoxMainThreadTaskRunner_RcdRunCallback(void *pvUser)
781{
782 DEBUG_FUNC_ENTER();
783 VBoxMainThreadTaskRunner *pRunner = (VBoxMainThreadTaskRunner *)pvUser;
784 Assert(pRunner == [VBoxMainThreadTaskRunner globalInstance]);
785 [pRunner runTasks];
786 DEBUG_FUNC_LEAVE();
787}
788
789/**
790 * Runs pending tasks synchronously, if possible in the current context.
791 *
792 * @returns true if executed tasks, false if not possible.
793 */
794- (bool)runTasksSyncIfPossible
795{
796#ifndef IN_VMSVGA3D
797 /*
798 * Call on main thread (?) via renderspuCalloutClient (whatever that is).
799 */
800 if (renderspuCalloutAvailable())
801 {
802 Assert(![NSThread isMainThread]);
803 renderspuCalloutClient(VBoxMainThreadTaskRunner_RcdRunCallback, self);
804 return true;
805 }
806#endif
807
808 /*
809 * Run directly if on main thread.
810 */
811 if ([NSThread isMainThread])
812 {
813 [self runTasks];
814 return true;
815 }
816
817 /* Not possible. */
818 return false;
819}
820
821- (void)dealloc
822{
823 /** @todo r=bird: WTF is the point of the deallocator. The object is a singelton
824 * stored in an inaccessible static variable! */
825 [m_pTasks release];
826 m_pTasks = nil;
827
828 [super dealloc];
829}
830
831@end
832
833#ifndef IN_VMSVGA3D
834@class DockOverlayView;
835#endif
836
837/**
838 * The custom view class.
839 *
840 * This is the main class of the cocoa OpenGL implementation. It manages a
841 * frame buffer object for the rendering of the guest applications. The guest
842 * applications render in this frame buffer which is bound to an OpenGL texture.
843 * To display the guest content, a secondary shared OpenGL context of the main
844 * OpenGL context is created. The secondary context is marked as non-opaque and
845 * the texture is displayed on an object which is composed out of the several
846 * visible region rectangles.
847 */
848@interface OverlayView : NSView
849{
850@private
851 NSView *m_pParentView;
852 NSWindow *m_pOverlayWin;
853
854 NSOpenGLContext *m_pGLCtx;
855 NSOpenGLContext *m_pSharedGLCtx;
856 RTTHREAD m_Thread;
857
858 GLuint m_FBOId;
859
860#ifndef IN_VMSVGA3D
861 /** The corresponding dock tile view of this OpenGL view & all helper
862 * members. */
863 DockOverlayView *m_DockTileView;
864
865 GLfloat m_FBOThumbScaleX;
866 GLfloat m_FBOThumbScaleY;
867 uint64_t m_msDockUpdateTS;
868#endif
869
870 /** @name For clipping
871 * @remarks appears to be unused and a complete waste of time + heap.
872 * @{ */
873 GLint m_cClipRects;
874 GLint *m_paClipRects;
875 /** @} */
876
877 /** @name Position/Size tracking
878 * @{ */
879 NSPoint m_Pos;
880 NSSize m_Size;
881 /** @} */
882
883 /** This is necessary for clipping on the root window */
884 NSRect m_RootRect;
885 float m_yInvRootOffset;
886
887#ifndef IN_VMSVGA3D
888 CR_BLITTER *m_pBlitter;
889 WindowInfo *m_pWinInfo;
890#endif
891 bool m_fNeedViewportUpdate;
892 bool m_fNeedCtxUpdate;
893 bool m_fDataVisible;
894 bool m_fCleanupNeeded;
895 bool m_fEverSized;
896}
897- (id)initWithFrame:(NSRect)frame thread:(RTTHREAD)aThread parentView:(NSView *)pParentView winInfo:(WindowInfo *)pWinInfo
898 fVisParams:(GLbitfield) fVisParams;
899- (void)setGLCtx:(NSOpenGLContext*)pCtx;
900- (NSOpenGLContext *)glCtx;
901
902- (void)setParentView: (NSView *)view;
903- (NSView *)parentView;
904- (void)setOverlayWin: (NSWindow *)win;
905- (NSWindow *)overlayWin;
906
907- (void)vboxSetPos:(NSPoint)pos;
908- (void)vboxSetPosUI:(NSPoint)pos;
909- (void)vboxSetPosUIObj:(NSValue *)pPos;
910- (NSPoint)pos;
911- (bool)isEverSized;
912- (void)vboxDestroy;
913- (void)vboxSetSizeUI:(NSSize)size;
914- (void)vboxSetSizeUIObj:(NSValue *)pSize;
915- (void)vboxSetSize:(NSSize)size;
916- (NSSize)size;
917- (void)updateViewportCS;
918#ifdef VBOX_WITH_CONFIGURABLE_HIDPI_SCALING
919- (NSRect)safeConvertRectToBacking:(NSRect *)pRect;
920- (CGFloat)safeGetBackingScaleFactor;
921#endif
922- (NSRect)safeConvertToScreen:(NSRect *)pRect;
923- (void)vboxReshapePerform;
924- (void)vboxReshapeOnResizePerform;
925- (void)vboxReshapeOnReparentPerform;
926
927#ifndef IN_VMSVGA3D
928- (void)createDockTile;
929- (void)deleteDockTile;
930#endif
931
932- (void)makeCurrentFBO;
933- (void)swapFBO;
934- (void)vboxSetVisible:(GLboolean)fVisible;
935- (void)vboxSetVisibleUIObj:(NSNumber *)pVisible;
936- (void)vboxSetVisibleUI:(GLboolean)fVisible;
937- (void)vboxTryDraw;
938- (void)vboxTryDrawUI;
939- (void)vboxReparent:(NSView *)pParentView;
940- (void)vboxReparentUI:(NSView *)pParentView;
941- (void)vboxPresent:(const VBOXVR_SCR_COMPOSITOR *)pCompositor;
942- (void)vboxPresentCS:(const VBOXVR_SCR_COMPOSITOR *)pCompositor;
943#ifndef IN_VMSVGA3D
944- (void)vboxPresentToDockTileCS:(const VBOXVR_SCR_COMPOSITOR *)pCompositor;
945#endif
946- (void)vboxPresentToViewCS:(const VBOXVR_SCR_COMPOSITOR *)pCompositor;
947- (void)presentComposition:(const VBOXVR_SCR_COMPOSITOR_ENTRY *)pChangedEntry;
948#ifndef IN_VMSVGA3D
949- (void)vboxBlitterSyncWindow;
950#endif
951
952- (void)clearVisibleRegions;
953- (void)setVisibleRegions:(GLint)cRects paRects:(const GLint *)paRects;
954- (GLboolean)vboxNeedsEmptyPresent;
955
956#ifndef IN_VMSVGA3D
957- (NSView *)dockTileScreen;
958- (void)reshapeDockTile;
959#endif
960- (void)cleanupData;
961@end
962
963/**
964 * Helper view.
965 *
966 * This view is added as a sub view of the parent view to track
967 * main window changes. Whenever the main window is changed
968 * (which happens on fullscreen/seamless entry/exit) the overlay
969 * window is informed & can add them self as a child window
970 * again.
971 */
972@class OverlayWindow;
973@interface OverlayHelperView: NSView
974{
975@private
976 OverlayWindow *m_pOverlayWindow;
977}
978-(id)initWithOverlayWindow:(NSRect)frame overlayWindow:(OverlayWindow *)pOverlayWindow;
979@end
980
981/**
982 * Custom window class.
983 *
984 * This is the overlay window which contains our custom NSView.
985 * Its a direct child of the Qt Main window. It marks its background
986 * transparent & non opaque to make clipping possible. It also disable mouse
987 * events and handle frame change events of the parent view.
988 */
989@interface OverlayWindow : NSWindow
990{
991@private
992 NSView *m_pParentView;
993 OverlayView *m_pOverlayView;
994 OverlayHelperView *m_pOverlayHelperView;
995 NSThread *m_Thread;
996}
997- (id)initWithParentView:(NSView *)pParentView overlayView:(OverlayView *)pOverlayView;
998- (void)parentWindowFrameChanged:(NSNotification *)note;
999- (void)parentWindowChanged:(NSWindow *)pWindow;
1000@end
1001
1002
1003#ifndef IN_VMSVGA3D
1004/**
1005 * Dock overlay view class.
1006 */
1007@interface DockOverlayView: NSView
1008{
1009 NSBitmapImageRep *m_ThumbBitmap;
1010 NSImage *m_ThumbImage;
1011 NSLock *m_Lock;
1012}
1013- (void)dealloc;
1014- (void)cleanup;
1015- (void)lock;
1016- (void)unlock;
1017- (void)setFrame:(NSRect)frame;
1018- (void)drawRect:(NSRect)aRect;
1019- (NSBitmapImageRep *)thumbBitmap;
1020- (NSImage *)thumbImage;
1021@end
1022
1023@implementation DockOverlayView
1024- (id)init
1025{
1026 DEBUG_FUNC_ENTER();
1027 self = [super init];
1028 if (self)
1029 {
1030 /*
1031 * We need a lock cause the thumb image could be accessed from the main
1032 * thread when someone is calling display on the dock tile & from the
1033 * OpenGL thread when the thumbnail is updated.
1034 */
1035 m_Lock = [[NSLock alloc] init];
1036 }
1037
1038 DEBUG_FUNC_LEAVE();
1039
1040 return self;
1041}
1042
1043- (void)dealloc
1044{
1045 DEBUG_FUNC_ENTER();
1046
1047 [self cleanup];
1048 [m_Lock release];
1049
1050 [super dealloc];
1051
1052 DEBUG_FUNC_LEAVE();
1053}
1054
1055- (void)cleanup
1056{
1057 DEBUG_FUNC_ENTER();
1058
1059 if (m_ThumbImage != nil)
1060 {
1061 [m_ThumbImage release];
1062 m_ThumbImage = nil;
1063 }
1064
1065 if (m_ThumbBitmap != nil)
1066 {
1067 [m_ThumbBitmap release];
1068 m_ThumbBitmap = nil;
1069 }
1070
1071 DEBUG_FUNC_LEAVE();
1072}
1073
1074- (void)lock
1075{
1076 DEBUG_FUNC_ENTER();
1077 [m_Lock lock];
1078 DEBUG_FUNC_LEAVE();
1079}
1080
1081- (void)unlock
1082{
1083 DEBUG_FUNC_ENTER();
1084 [m_Lock unlock];
1085 DEBUG_FUNC_LEAVE();
1086}
1087
1088- (void)setFrame:(NSRect)frame
1089{
1090 DEBUG_FUNC_ENTER();
1091 [super setFrame:frame];
1092
1093 [self lock];
1094 [self cleanup];
1095
1096 if ( frame.size.width > 0
1097 && frame.size.height > 0)
1098 {
1099 /* Create a buffer for our thumbnail image. Its in the size of this view. */
1100 m_ThumbBitmap = [[NSBitmapImageRep alloc] initWithBitmapDataPlanes:NULL
1101 pixelsWide:frame.size.width
1102 pixelsHigh:frame.size.height
1103 bitsPerSample:8
1104 samplesPerPixel:4
1105 hasAlpha:YES
1106 isPlanar:NO
1107 colorSpaceName:NSDeviceRGBColorSpace
1108 bitmapFormat:NSAlphaFirstBitmapFormat
1109 bytesPerRow:frame.size.width * 4
1110 bitsPerPixel:8 * 4
1111 ];
1112 m_ThumbImage = [[NSImage alloc] initWithSize:[m_ThumbBitmap size]];
1113 [m_ThumbImage addRepresentation:m_ThumbBitmap];
1114 }
1115
1116 [self unlock];
1117 DEBUG_FUNC_LEAVE();
1118}
1119
1120- (BOOL)isFlipped
1121{
1122 DEBUG_FUNC_ENTER();
1123 DEBUG_FUNC_LEAVE();
1124 return YES;
1125}
1126
1127- (void)drawRect:(NSRect)aRect
1128{
1129 NSRect frame;
1130 DEBUG_FUNC_ENTER();
1131 [self lock];
1132
1133#ifdef SHOW_WINDOW_BACKGROUND
1134 [[NSColor colorWithCalibratedRed:1.0 green:0.0 blue:0.0 alpha:0.7] set];
1135 frame = [self frame];
1136 [NSBezierPath fillRect:NSMakeRect(0, 0, frame.size.width, frame.size.height)];
1137#endif /* SHOW_WINDOW_BACKGROUND */
1138 if (m_ThumbImage != nil)
1139 [m_ThumbImage drawAtPoint:NSMakePoint(0, 0) fromRect:NSZeroRect operation:NSCompositeSourceOver fraction:1.0];
1140
1141 [self unlock];
1142 DEBUG_FUNC_LEAVE();
1143}
1144
1145- (NSBitmapImageRep *)thumbBitmap
1146{
1147 DEBUG_FUNC_ENTER();
1148 DEBUG_FUNC_LEAVE();
1149 return m_ThumbBitmap;
1150}
1151
1152- (NSImage *)thumbImage
1153{
1154 DEBUG_FUNC_ENTER();
1155 DEBUG_FUNC_LEAVE();
1156 return m_ThumbImage;
1157}
1158@end
1159#endif /* !IN_VMSVGA3D */
1160
1161
1162/********************************************************************************
1163*
1164* OverlayOpenGLContext class implementation
1165*
1166********************************************************************************/
1167@implementation OverlayOpenGLContext
1168
1169-(id)initWithFormat:(NSOpenGLPixelFormat *)format shareContext:(NSOpenGLContext *)share
1170{
1171 DEBUG_FUNC_ENTER();
1172
1173 m_pPixelFormat = NULL;
1174 m_pView = NULL;
1175
1176 self = [super initWithFormat:format shareContext:share];
1177 Assert(self != nil);
1178 if (self)
1179 m_pPixelFormat = format;
1180
1181 DEBUG_MSG(("OCTX(%p): init OverlayOpenGLContext\n", (void *)self));
1182 DEBUG_FUNC_LEAVE();
1183 return self;
1184}
1185
1186- (void)dealloc
1187{
1188 DEBUG_FUNC_ENTER();
1189 DEBUG_MSG(("OCTX(%p): dealloc OverlayOpenGLContext\n", (void *)self));
1190
1191 [m_pPixelFormat release];
1192
1193 [super dealloc];
1194
1195 DEBUG_FUNC_LEAVE();
1196}
1197
1198-(bool)isDoubleBuffer
1199{
1200 DEBUG_FUNC_ENTER();
1201
1202 GLint val;
1203 [m_pPixelFormat getValues:&val forAttribute:NSOpenGLPFADoubleBuffer forVirtualScreen:0];
1204
1205 DEBUG_FUNC_LEAVE();
1206 return val == GL_TRUE ? YES : NO;
1207}
1208
1209-(void)setView:(NSView *)view
1210{
1211 DEBUG_FUNC_ENTER();
1212 DEBUG_MSG(("OCTX(%p): setView: new view: %p\n", (void *)self, (void *)view));
1213
1214#if 1 /* def FBO */
1215 m_pView = view;;
1216#else
1217 [super setView: view];
1218#endif
1219
1220 DEBUG_FUNC_LEAVE();
1221}
1222
1223-(NSView *)view
1224{
1225 DEBUG_FUNC_ENTER();
1226 DEBUG_FUNC_LEAVE();
1227#if 1 /* def FBO */
1228 return m_pView;
1229#else
1230 return [super view];
1231#endif
1232}
1233
1234-(void)clearDrawable
1235{
1236 DEBUG_FUNC_ENTER();
1237 DEBUG_MSG(("OCTX(%p): clearDrawable\n", (void *)self));
1238
1239 m_pView = NULL;;
1240 [super clearDrawable];
1241
1242 DEBUG_FUNC_LEAVE();
1243}
1244
1245-(NSOpenGLPixelFormat *)openGLPixelFormat
1246{
1247 DEBUG_FUNC_ENTER();
1248 DEBUG_FUNC_LEAVE();
1249
1250 return m_pPixelFormat;
1251}
1252
1253@end /* @implementation OverlayOpenGLContext */
1254
1255
1256/********************************************************************************
1257*
1258* OverlayHelperView class implementation
1259*
1260********************************************************************************/
1261@implementation OverlayHelperView
1262
1263-(id)initWithOverlayWindow:(NSRect)frame overlayWindow:(OverlayWindow *)pOverlayWindow
1264{
1265 DEBUG_FUNC_ENTER();
1266
1267 self = [super initWithFrame:frame];
1268#ifdef IN_VMSVGA3D
1269 self.autoresizingMask = NSViewWidthSizable | NSViewHeightSizable;
1270#endif
1271
1272 m_pOverlayWindow = pOverlayWindow;
1273
1274 DEBUG_MSG(("OHVW(%p): init OverlayHelperView\n", (void *)self));
1275 DEBUG_FUNC_LEAVE();
1276 return self;
1277}
1278
1279-(void)viewDidMoveToWindow
1280{
1281 DEBUG_FUNC_ENTER();
1282 DEBUG_MSG(("OHVW(%p): viewDidMoveToWindow: new win: %p\n", (void *)self, (void *)[self window]));
1283
1284 [m_pOverlayWindow parentWindowChanged:[self window]];
1285
1286 DEBUG_FUNC_LEAVE();
1287}
1288
1289@end
1290
1291
1292/********************************************************************************
1293*
1294* OverlayWindow class implementation
1295*
1296********************************************************************************/
1297@implementation OverlayWindow
1298
1299- (id)initWithParentView:(NSView *)pParentView overlayView:(OverlayView *)pOverlayView
1300{
1301 DEBUG_FUNC_ENTER();
1302 NSWindow *pParentWin = nil;
1303
1304 self = [super initWithContentRect:NSZeroRect styleMask:NSBorderlessWindowMask backing:NSBackingStoreBuffered defer:NO];
1305 if (self)
1306 {
1307 m_pParentView = pParentView;
1308 m_pOverlayView = pOverlayView;
1309 m_Thread = [NSThread currentThread];
1310
1311 [m_pOverlayView setOverlayWin: self];
1312
1313#ifdef IN_VMSVGA3D
1314 NSRect frame = [pParentView frame];
1315 frame.origin.x = frame.origin.x = 0;
1316 m_pOverlayHelperView = [[OverlayHelperView alloc] initWithOverlayWindow:frame
1317 overlayWindow:self];
1318#else
1319 m_pOverlayHelperView = [[OverlayHelperView alloc] initWithOverlayWindow:NSZeroRect
1320 overlayWindow:self];
1321#endif
1322
1323 /* Add the helper view as a child of the parent view to get notifications */
1324 [pParentView addSubview:m_pOverlayHelperView];
1325
1326 /* Make sure this window is transparent */
1327#ifdef SHOW_WINDOW_BACKGROUND
1328 /* For debugging */
1329 [self setBackgroundColor:[NSColor colorWithCalibratedRed:1.0 green:0.0 blue:0.0 alpha:0.7]];
1330#else
1331 [self setBackgroundColor:[NSColor clearColor]];
1332#endif
1333 [self setOpaque:NO];
1334 [self setAlphaValue:.999];
1335
1336 /* Disable mouse events for this window */
1337 [self setIgnoresMouseEvents:YES];
1338
1339 pParentWin = [m_pParentView window];
1340
1341 /* Initial set the position to the parents view top/left (Compiz fix). */
1342 [self setFrameOrigin:
1343 [pParentWin convertBaseToScreen:
1344 [m_pParentView convertPoint:NSZeroPoint toView:nil]]];
1345
1346 /* Set the overlay view as our content view */
1347 [self setContentView:m_pOverlayView];
1348
1349 /* Add ourself as a child to the parent views window. Note: this has to
1350 * be done last so that everything else is setup in
1351 * parentWindowChanged. */
1352 [pParentWin addChildWindow:self ordered:NSWindowAbove];
1353 }
1354
1355 DEBUG_MSG(("OWIN(%p): init OverlayWindow\n", (void *)self));
1356 DEBUG_FUNC_LEAVE();
1357 return self;
1358}
1359
1360- (void)dealloc
1361{
1362 DEBUG_FUNC_ENTER();
1363 DEBUG_MSG(("OWIN(%p): dealloc OverlayWindow\n", (void *)self));
1364
1365 [[NSNotificationCenter defaultCenter] removeObserver:self];
1366
1367 [m_pOverlayHelperView removeFromSuperview];
1368 [m_pOverlayHelperView release];
1369
1370 [super dealloc];
1371
1372 DEBUG_FUNC_LEAVE();
1373}
1374
1375- (void)parentWindowFrameChanged:(NSNotification *)pNote
1376{
1377 DEBUG_FUNC_ENTER();
1378 DEBUG_MSG(("OWIN(%p): parentWindowFrameChanged\n", (void *)self));
1379
1380 /*
1381 * Reposition this window with the help of the OverlayView. Perform the
1382 * call in the OpenGL thread.
1383 */
1384 /*
1385 [m_pOverlayView performSelector:@selector(vboxReshapePerform) onThread:m_Thread withObject:nil waitUntilDone:YES];
1386 */
1387
1388 if ([m_pOverlayView isEverSized])
1389 {
1390 if ([NSThread isMainThread])
1391 [m_pOverlayView vboxReshapePerform];
1392 else
1393 [self performSelectorOnMainThread:@selector(vboxReshapePerform) withObject:nil waitUntilDone:NO];
1394 }
1395
1396 DEBUG_FUNC_LEAVE();
1397}
1398
1399- (void)parentWindowChanged:(NSWindow *)pWindow
1400{
1401 DEBUG_FUNC_ENTER();
1402 DEBUG_MSG(("OWIN(%p): parentWindowChanged\n", (void *)self));
1403
1404 [[NSNotificationCenter defaultCenter] removeObserver:self];
1405
1406 if (pWindow != nil)
1407 {
1408 /* Ask to get notifications when our parent window frame changes. */
1409 [[NSNotificationCenter defaultCenter]
1410 addObserver:self
1411 selector:@selector(parentWindowFrameChanged:)
1412 name:NSWindowDidResizeNotification
1413 object:pWindow];
1414
1415 /* Add us self as child window */
1416 [pWindow addChildWindow:self ordered:NSWindowAbove];
1417
1418 /*
1419 * Reshape the overlay view after a short waiting time to let the main
1420 * window resize itself properly.
1421 */
1422 /*
1423 [m_pOverlayView performSelector:@selector(vboxReshapePerform) withObject:nil afterDelay:0.2];
1424 [NSTimer scheduledTimerWithTimeInterval:0.2 target:m_pOverlayView selector:@selector(vboxReshapePerform) userInfo:nil repeats:NO];
1425 */
1426
1427 if ([m_pOverlayView isEverSized])
1428 {
1429 if ([NSThread isMainThread])
1430 [m_pOverlayView vboxReshapePerform];
1431 else
1432 [self performSelectorOnMainThread:@selector(vboxReshapePerform) withObject:nil waitUntilDone:NO];
1433 }
1434 }
1435
1436 DEBUG_FUNC_LEAVE();
1437}
1438
1439@end /* @implementation OverlayWindow */
1440
1441
1442
1443/********************************************************************************
1444*
1445* OverlayView class implementation
1446*
1447********************************************************************************/
1448@implementation OverlayView
1449
1450- (id)initWithFrame:(NSRect)frame thread:(RTTHREAD)aThread parentView:(NSView *)pParentView winInfo:(WindowInfo *)pWinInfo
1451 fVisParams:(GLbitfield) fVisParams
1452{
1453 COCOA_LOG_FLOW(("%s: self=%p aThread=%p pParentView=%p pWinInfo=%p fVisParams=%#x\n", __PRETTY_FUNCTION__, (void *)self,
1454 (void *)aThread, (void *)pParentView, (void *)pWinInfo, fVisParams));
1455
1456 m_pParentView = pParentView;
1457 /* Make some reasonable defaults */
1458 m_pGLCtx = nil;
1459 m_pSharedGLCtx = nil;
1460 m_Thread = aThread;
1461 m_FBOId = 0;
1462 m_cClipRects = 0;
1463 m_paClipRects = NULL;
1464 m_Pos = NSZeroPoint;
1465 m_Size = NSMakeSize(1, 1);
1466 m_RootRect = NSMakeRect(0, 0, m_Size.width, m_Size.height);
1467 m_yInvRootOffset = 0;
1468#ifndef IN_VMSVGA3D
1469 m_pBlitter = nil;
1470 m_pWinInfo = pWinInfo;
1471#endif
1472 m_fNeedViewportUpdate = true;
1473 m_fNeedCtxUpdate = true;
1474 m_fDataVisible = false;
1475 m_fCleanupNeeded = false;
1476 m_fEverSized = false;
1477
1478 self = [super initWithFrame:frame];
1479#if defined(VBOX_WITH_CONFIGURABLE_HIDPI_SCALING) && !defined(IN_VMSVGA3D)
1480 /* Always allocate HiDPI-ready backing store for NSView, so we will be able change HiDPI scaling option in runtime. */
1481 crDebug("HiDPI: Allocate big backing store for NSView. Up-scaling is currently %s.", render_spu.fUnscaledHiDPI ? "OFF" : "ON");
1482 [self performSelector:@selector(setWantsBestResolutionOpenGLSurface:) withObject: (id)YES];
1483#endif
1484
1485 COCOA_LOG_FLOW(("%s: returns self=%p\n", __PRETTY_FUNCTION__, (void *)self));
1486 return self;
1487}
1488
1489- (void)cleanupData
1490{
1491 COCOA_LOG_FLOW(("%s: self=%p\n", __PRETTY_FUNCTION__, (void *)self));
1492
1493#ifndef IN_VMSVGA3D
1494 [self deleteDockTile];
1495#endif
1496
1497 [self setGLCtx:nil];
1498
1499 if (m_pSharedGLCtx)
1500 {
1501 if ([m_pSharedGLCtx view] == self)
1502 [m_pSharedGLCtx clearDrawable];
1503
1504 [m_pSharedGLCtx release];
1505 m_pSharedGLCtx = nil;
1506
1507
1508#ifndef IN_VMSVGA3D
1509 CrBltTerm(m_pBlitter);
1510 RTMemFree(m_pBlitter);
1511 m_pBlitter = nil;
1512#endif
1513 }
1514
1515 [self clearVisibleRegions];
1516
1517 COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
1518}
1519
1520- (void)dealloc
1521{
1522 COCOA_LOG_FLOW(("%s: self=%p\n", __PRETTY_FUNCTION__, (void *)self));
1523
1524 [self cleanupData];
1525 [super dealloc];
1526
1527 COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
1528}
1529
1530- (void)drawRect:(NSRect)aRect
1531{
1532 COCOA_LOG_FLOW(("%s: self=%p aRect=%d,%d %d,%d\n", __PRETTY_FUNCTION__, (void *)self, (int)aRect.origin.x, (int)aRect.origin.y,
1533 (int)aRect.size.width, (int)aRect.size.height));
1534
1535 [self vboxTryDrawUI];
1536
1537 COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
1538}
1539
1540- (void)setGLCtx:(NSOpenGLContext *)pCtx
1541{
1542 COCOA_LOG_FLOW(("%s: self=%p pCtx=%p (old=%p)\n", __PRETTY_FUNCTION__, (void *)self, (void *)pCtx, m_pGLCtx));
1543
1544 /*
1545 * Only do something if the context changes.
1546 */
1547 if (m_pGLCtx != pCtx)
1548 {
1549 /* Ensure the context drawable is cleared to avoid holding a reference to inexistent view. */
1550 if (m_pGLCtx)
1551 {
1552#ifdef IN_VMSVGA3D
1553 Assert(!pCtx);
1554#endif
1555 [m_pGLCtx clearDrawable];
1556 [m_pGLCtx release];
1557 /*[m_pGLCtx performSelectorOnMainThread:@selector(release) withObject:nil waitUntilDone:NO];*/
1558 }
1559
1560 m_pGLCtx = pCtx;
1561 if (pCtx)
1562 [pCtx retain];
1563 }
1564
1565 COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
1566}
1567
1568- (NSOpenGLContext *)glCtx
1569{
1570 COCOA_LOG_FLOW(("%s: self=%p returns %p\n", __PRETTY_FUNCTION__, (void *)self, (void *)m_pGLCtx));
1571 return m_pGLCtx;
1572}
1573
1574- (NSView *)parentView
1575{
1576 COCOA_LOG_FLOW(("%s: self=%p returns %p\n", __PRETTY_FUNCTION__, (void *)self, (void *)m_pParentView));
1577 return m_pParentView;
1578}
1579
1580- (void)setParentView:(NSView *)pView
1581{
1582 COCOA_LOG_FLOW(("%s: self=%p pView=%p (old=%p)\n", __PRETTY_FUNCTION__, (void *)self, (void *)pView, m_pParentView));
1583
1584 m_pParentView = pView;
1585
1586 COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
1587}
1588
1589- (void)setOverlayWin:(NSWindow *)pWin
1590{
1591 COCOA_LOG_FLOW(("%s: self=%p pWin=%p (old=%p)\n", __PRETTY_FUNCTION__, (void *)self, (void *)pWin, m_pOverlayWin));
1592
1593 m_pOverlayWin = pWin;
1594
1595 COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
1596}
1597
1598- (NSWindow *)overlayWin
1599{
1600 COCOA_LOG_FLOW(("%s: self=%p returns %p\n", __PRETTY_FUNCTION__, (void *)self, (void *)m_pOverlayWin));
1601 return m_pOverlayWin;
1602}
1603
1604- (void)vboxSetPosUI:(NSPoint)pos
1605{
1606 COCOA_LOG_FLOW(("%s: self=%p pos=%d,%d (old pos=%d,%d)\n", __PRETTY_FUNCTION__, (void *)self, (int)pos.x, (int)pos.y,
1607 (int)m_Pos.x, (int)m_Pos.y));
1608
1609 DEBUG_MSG(("vboxSetPosUI: [%d, %d].\n", (int)pos.x, (int)pos.y));
1610
1611 m_Pos = pos;
1612
1613 if (m_fEverSized)
1614 [self vboxReshapePerform];
1615
1616 COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
1617}
1618
1619- (void)vboxSetPosUIObj:(NSValue *)pPos
1620{
1621 COCOA_LOG_FLOW(("%s: self=%p pPos=%p (%d,%d) (old pos=%d,%d)\n", __PRETTY_FUNCTION__, (void *)self, pPos,
1622 (int)[pPos pointValue].x, (int)[pPos pointValue].y, (int)m_Pos.x, (int)m_Pos.y));
1623
1624 NSPoint pos = [pPos pointValue];
1625 [self vboxSetPosUI:pos];
1626
1627 COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
1628}
1629
1630- (void)vboxSetPos:(NSPoint)pos
1631{
1632 COCOA_LOG_FLOW(("%s: self=%p pos=%d,%d (old pos=%d,%d)\n", __PRETTY_FUNCTION__, (void *)self, (int)pos.x, (int)pos.y,
1633 (int)m_Pos.x, (int)m_Pos.y));
1634
1635 VBoxMainThreadTaskRunner *pRunner = [VBoxMainThreadTaskRunner globalInstance];
1636 NSValue *pPos = [NSValue valueWithPoint:pos];
1637 [pRunner addObj:self selector:@selector(vboxSetPosUIObj:) arg:pPos];
1638
1639 COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
1640}
1641
1642- (NSPoint)pos
1643{
1644 COCOA_LOG_FLOW(("%s: self=%p returns %d,%d\n", __PRETTY_FUNCTION__, (void *)self, (int)m_Pos.x, (int)m_Pos.y));
1645 return m_Pos;
1646}
1647
1648- (bool)isEverSized
1649{
1650 COCOA_LOG_FLOW(("%s: self=%p returns %d\n", __PRETTY_FUNCTION__, (void *)self, m_fEverSized));
1651 return m_fEverSized;
1652}
1653
1654- (void)vboxDestroy
1655{
1656 COCOA_LOG_FLOW(("%s: self=%p\n", __PRETTY_FUNCTION__, (void *)self));
1657 BOOL fIsMain = [NSThread isMainThread];
1658 NSWindow *pWin = nil;
1659
1660 Assert(fIsMain);
1661
1662 /* Hide the view early. */
1663 [self setHidden: YES];
1664
1665 pWin = [self window];
1666 [[NSNotificationCenter defaultCenter] removeObserver:pWin];
1667 [pWin setContentView: nil];
1668 [[pWin parentWindow] removeChildWindow: pWin];
1669
1670 if (fIsMain)
1671 [pWin release];
1672 else
1673 {
1674 /* We can NOT run synchronously with the main thread since this may lead to a deadlock,
1675 caused by main thread waiting xpcom thread, xpcom thread waiting to main hgcm thread,
1676 and main hgcm thread waiting for us, this is why use waitUntilDone:NO,
1677 which should cause no harm. */
1678 [pWin performSelectorOnMainThread:@selector(release) withObject:nil waitUntilDone:NO];
1679 }
1680
1681 [self cleanupData];
1682
1683 if (fIsMain)
1684 [self release];
1685 else
1686 {
1687 /* We can NOT run synchronously with the main thread since this may lead to a deadlock,
1688 caused by main thread waiting xpcom thread, xpcom thread waiting to main hgcm thread,
1689 and main hgcm thread waiting for us, this is why use waitUntilDone:NO.
1690 We need to avoid concurrency though, so we cleanup some data right away via a cleanupData call. */
1691 [self performSelectorOnMainThread:@selector(release) withObject:nil waitUntilDone:NO];
1692 }
1693
1694#ifndef IN_VMSVGA3D
1695 renderspuWinRelease(m_pWinInfo);
1696#endif
1697
1698 COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
1699}
1700
1701- (void)vboxSetSizeUIObj:(NSValue *)pSize
1702{
1703 COCOA_LOG_FLOW(("%s: self=%p pSize=%p (%d,%d)\n", __PRETTY_FUNCTION__, (void *)self, (void *)pSize,
1704 (int)[pSize sizeValue].width, (int)[pSize sizeValue].height));
1705
1706 NSSize size = [pSize sizeValue];
1707 [self vboxSetSizeUI:size];
1708
1709 COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
1710}
1711
1712- (void)vboxSetSizeUI:(NSSize)size
1713{
1714 COCOA_LOG_FLOW(("%s: self=%p size=%d,%d\n", __PRETTY_FUNCTION__, (void *)self, (int)size.width, (int)size.height));
1715
1716 m_Size = size;
1717 m_fEverSized = true;
1718
1719 DEBUG_MSG(("OVIW(%p): vboxSetSize: new size: %dx%d\n", (void *)self, (int)m_Size.width, (int)m_Size.height));
1720 [self vboxReshapeOnResizePerform];
1721
1722 /* ensure window contents is updated after that */
1723 [self vboxTryDrawUI];
1724
1725 COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
1726}
1727
1728- (void)vboxSetSize:(NSSize)size
1729{
1730 COCOA_LOG_FLOW(("%s: self=%p size=%d,%d\n", __PRETTY_FUNCTION__, (void *)self, (int)size.width, (int)size.height));
1731
1732 VBoxMainThreadTaskRunner *pRunner = [VBoxMainThreadTaskRunner globalInstance];
1733 NSValue *pSize = [NSValue valueWithSize:size];
1734 [pRunner addObj:self selector:@selector(vboxSetSizeUIObj:) arg:pSize];
1735
1736 COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
1737}
1738
1739- (NSSize)size
1740{
1741 COCOA_LOG_FLOW(("%s: self=%p returns %d,%d\n", __PRETTY_FUNCTION__, (void *)self, (int)m_Size.width, (int)m_Size.height));
1742 return m_Size;
1743}
1744
1745- (void)updateViewportCS
1746{
1747 COCOA_LOG_FLOW(("%s: self=%p\n", __PRETTY_FUNCTION__, (void *)self));
1748
1749 /* Update the viewport for our OpenGL view. */
1750 [m_pSharedGLCtx update];
1751
1752#ifndef IN_VMSVGA3D
1753 [self vboxBlitterSyncWindow];
1754#endif
1755
1756 /* Clear background to transparent. */
1757 glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
1758
1759 COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
1760}
1761
1762- (void)vboxReshapeOnResizePerform
1763{
1764 COCOA_LOG_FLOW(("%s: self=%p\n", __PRETTY_FUNCTION__, (void *)self));
1765
1766 [self vboxReshapePerform];
1767#ifndef IN_VMSVGA3D
1768 [self createDockTile];
1769#endif
1770
1771 /* have to rebind GL_TEXTURE_RECTANGLE_ARB as m_FBOTexId could be changed in updateFBO call */
1772 m_fNeedViewportUpdate = true;
1773#if 0
1774 pCurCtx = [NSOpenGLContext currentContext];
1775 if (pCurCtx && pCurCtx == m_pGLCtx && (pCurView = [pCurCtx view]) == self)
1776 {
1777 [m_pGLCtx update];
1778 m_fNeedCtxUpdate = false;
1779 }
1780 else
1781 {
1782 /* do it in a lazy way */
1783 m_fNeedCtxUpdate = true;
1784 }
1785#endif
1786
1787 COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
1788}
1789
1790- (void)vboxReshapeOnReparentPerform
1791{
1792 COCOA_LOG_FLOW(("%s: self=%p\n", __PRETTY_FUNCTION__, (void *)self));
1793 [self vboxReshapePerform];
1794#ifndef IN_VMSVGA3D
1795 [self createDockTile];
1796#endif
1797 COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
1798}
1799
1800#ifdef VBOX_WITH_CONFIGURABLE_HIDPI_SCALING
1801- (NSRect)safeConvertRectToBacking:(NSRect *)pRect
1802{
1803 NSRect resultingRect = NSZeroRect;
1804
1805 NSWindow *pWindow = [m_pParentView window];
1806 if (pWindow)
1807 {
1808 if ([pWindow respondsToSelector:@selector(convertRectToBacking:)])
1809 {
1810 NSMethodSignature *pSignature = [pWindow methodSignatureForSelector:@selector(convertRectToBacking:)];
1811 if (pSignature)
1812 {
1813 NSInvocation *pInvocation = [NSInvocation invocationWithMethodSignature:pSignature];
1814 if (pInvocation)
1815 {
1816 [pInvocation setSelector:@selector(convertRectToBacking:)];
1817 [pInvocation setTarget:pWindow];
1818 [pInvocation setArgument:pRect atIndex:2];
1819 [pInvocation invoke];
1820 [pInvocation getReturnValue:&resultingRect];
1821
1822 DEBUG_MSG(("safeConvertRectToBacking: convert [X, Y, WxH]: [%d, %d, %dx%d] -> [%d, %d, %dx%d]\n",
1823 (int)pRect ->origin.x, (int)pRect ->origin.y, (int)pRect ->size.width, (int)pRect ->size.width,
1824 (int)resultingRect.origin.x, (int)resultingRect.origin.y, (int)resultingRect.size.width, (int)resultingRect.size.width));
1825
1826 return resultingRect;
1827 }
1828 }
1829 }
1830 }
1831 else
1832 /* Should never happen. */
1833 DEBUG_WARN(("safeConvertRectToBacking: parent widget has no window.\n"));
1834
1835 resultingRect = *pRect;
1836
1837 DEBUG_MSG(("safeConvertRectToBacking (reurn as is): convert [X, Y, WxH]: [%d, %d, %dx%d] -> [%d, %d, %dx%d]\n",
1838 (int)pRect ->origin.x, (int)pRect ->origin.y, (int)pRect ->size.width, (int)pRect ->size.width,
1839 (int)resultingRect.origin.x, (int)resultingRect.origin.y, (int)resultingRect.size.width, (int)resultingRect.size.width));
1840
1841 return resultingRect;
1842}
1843
1844
1845- (CGFloat)safeGetBackingScaleFactor
1846{
1847 /* Assume its default value. */
1848 CGFloat backingScaleFactor = 1.;
1849
1850 NSWindow *pWindow = [m_pParentView window];
1851 if (pWindow)
1852 {
1853 NSScreen *pScreen = [pWindow screen];
1854 if (pScreen)
1855 {
1856 if ([pScreen respondsToSelector:@selector(backingScaleFactor)])
1857 {
1858 NSMethodSignature *pSignature = [pScreen methodSignatureForSelector:@selector(backingScaleFactor)];
1859 if (pSignature)
1860 {
1861 NSInvocation *pInvocation = [NSInvocation invocationWithMethodSignature:pSignature];
1862 if (pInvocation)
1863 {
1864 [pInvocation setSelector:@selector(backingScaleFactor)];
1865 [pInvocation setTarget:pScreen];
1866 [pInvocation invoke];
1867 [pInvocation getReturnValue:&backingScaleFactor];
1868
1869 DEBUG_MSG(("safeGetBackingScaleFactor: %d\n", (int)backingScaleFactor));
1870
1871 return backingScaleFactor;
1872 }
1873 else
1874 DEBUG_WARN(("safeGetBackingScaleFactor: unable to create invocation for backingScaleFactor method signature.\n"));
1875 }
1876 else
1877 DEBUG_WARN(("safeGetBackingScaleFactor: unable to create method signature for backingScaleFactor selector.\n"));
1878 }
1879 else
1880 DEBUG_WARN(("safeGetBackingScaleFactor: NSScreen does not respond to backingScaleFactor selector.\n"));
1881 }
1882 else
1883 /* Should never happen. */
1884 DEBUG_WARN(("safeGetBackingScaleFactor: parent window has no screen.\n"));
1885 }
1886 else
1887 /* Should never happen. */
1888 DEBUG_WARN(("safeGetBackingScaleFactor: parent widget has no window.\n"));
1889
1890 return backingScaleFactor;
1891}
1892
1893#endif
1894
1895
1896- (NSRect)safeConvertToScreen:(NSRect *)pRect
1897{
1898 NSRect resultingRect = NSZeroRect;
1899
1900 NSWindow *pWindow = [m_pParentView window];
1901 if (pWindow)
1902 {
1903 if ([pWindow respondsToSelector:@selector(convertRectToScreen:)])
1904 {
1905 NSMethodSignature *pSignature = [pWindow methodSignatureForSelector:@selector(convertRectToScreen:)];
1906 if (pSignature)
1907 {
1908 NSInvocation *pInvocation = [NSInvocation invocationWithMethodSignature:pSignature];
1909 if (pInvocation)
1910 {
1911 [pInvocation setSelector:@selector(convertRectToScreen:)];
1912 [pInvocation setTarget:pWindow];
1913 [pInvocation setArgument:pRect atIndex:2];
1914 [pInvocation invoke];
1915 [pInvocation getReturnValue:&resultingRect];
1916
1917 DEBUG_MSG(("safeConvertToScreen: convert [X, Y, WxH]: [%d, %d, %dx%d] -> [%d, %d, %dx%d]\n",
1918 (int)pRect ->origin.x, (int)pRect ->origin.y, (int)pRect ->size.width, (int)pRect ->size.width,
1919 (int)resultingRect.origin.x, (int)resultingRect.origin.y, (int)resultingRect.size.width, (int)resultingRect.size.width));
1920
1921 return resultingRect;
1922 }
1923 }
1924 }
1925
1926 /* If we failed, let's use deprecated @selector(convertBaseToScreen:). It is a bit hacky,
1927 * but what to do if we stick to SDK 10.6. */
1928 resultingRect.origin = [[m_pParentView window] convertBaseToScreen:pRect->origin];
1929 resultingRect.size = pRect->size;
1930 }
1931 else
1932 /* Should never happen. */
1933 DEBUG_WARN(("safeConvertToScreen: parent widget has no window.\n"));
1934
1935 DEBUG_MSG(("safeConvertToScreen (deprecated method): convert [X, Y, WxH]: [%d, %d, %dx%d] -> [%d, %d, %dx%d]\n",
1936 (int)pRect ->origin.x, (int)pRect ->origin.y, (int)pRect ->size.width, (int)pRect ->size.width,
1937 (int)resultingRect.origin.x, (int)resultingRect.origin.y, (int)resultingRect.size.width, (int)resultingRect.size.width));
1938
1939 return resultingRect;
1940}
1941
1942- (void)vboxReshapePerform
1943{
1944#ifndef IN_VMSVGA3D
1945 COCOA_LOG_FLOW(("%s: self=%p - m_DockTileView=%p\n", __PRETTY_FUNCTION__, (void *)self, (void *)m_DockTileView));
1946#else
1947 COCOA_LOG_FLOW(("%s: self=%p\n", __PRETTY_FUNCTION__, (void *)self));
1948#endif
1949
1950 /* NOTE: Please consider the next naming convention for variables.
1951 *
1952 * Rectangle variables:
1953 *
1954 * <object to represent><coordinate system>:
1955 * <object to represent>:
1956 * parentFrame - a frame of the parent container (NSView) object
1957 * childFrame - a frame required to display guest content
1958 * windowFrame - resulting window frame constructed as an intersection of parentFrame and childFrame
1959 * <coordinate system>:
1960 * VCS - View Coordinate System
1961 * WCS - Window Coordinate System
1962 * SCS - Screen Coordinate System
1963 *
1964 * The same convention applied to offset variables naming as well which are of format:
1965 *
1966 * <object to represent><coordinate><coordinate system>.
1967 *
1968 * https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/CocoaDrawingGuide/Transforms/Transforms.html
1969 */
1970
1971 NSRect parentFrameVCS, parentFrameWCS, parentFrameSCS;
1972 NSRect childFrameWCS, childFrameSCS;
1973 NSRect windowFrameSCS;
1974
1975 CGFloat childFrameXWCS, childFrameYWCS;
1976
1977 /* We need to construct a new window frame (windowFrameSCS) for entire NSWindow object in
1978 * screen coordinates. In order to make 3D overlay window to do not overlap Cocoa and Qt GUI elements (titlebar,
1979 * Qt statusbar, scroll bars etc) let's do the next. Get parent view visible area (parentFrameSCS) in (NS)Screen
1980 * coordinates. Then get the area required to diaplay guest content (childFrameSCS) in (NS)Screen coordinates as well.
1981 * The intersection of these two areas in screen coordinates will be a new frame for entire NSWindow object. */
1982
1983 parentFrameVCS = [m_pParentView frame];
1984 parentFrameWCS = [m_pParentView convertRect:parentFrameVCS toView:nil];
1985 parentFrameSCS = [self safeConvertToScreen:&parentFrameWCS];
1986
1987 /* Choose childFrame origin in a bit special way. Its pop-left corner should stick to its parent top-left corner. */
1988 childFrameXWCS = parentFrameWCS.origin.x + m_Pos.x;
1989 childFrameYWCS = parentFrameWCS.origin.y - m_Pos.y - (m_Size.height - parentFrameWCS.size.height);
1990 childFrameWCS = NSMakeRect(childFrameXWCS, childFrameYWCS, m_Size.width, m_Size.height);
1991 childFrameSCS = [self safeConvertToScreen:&childFrameWCS];
1992
1993 windowFrameSCS = NSIntersectionRect(parentFrameSCS, childFrameSCS);
1994
1995 DEBUG_MSG(("vboxReshapePerform: a new overlay frame [%d, %d, %dx%d] has been constructed from intersection of window frame "
1996 "[%d, %d, %dx%d] and guest content rectangle [%d, %d, %dx%d]; m_Pos=[%d, %d], m_Size=%dx%d.\n",
1997 (int)windowFrameSCS.origin.x, (int)windowFrameSCS.origin.y, (int)windowFrameSCS.size.width, (int)windowFrameSCS.size.width,
1998 (int)parentFrameSCS.origin.x, (int)parentFrameSCS.origin.y, (int)parentFrameSCS.size.width, (int)parentFrameSCS.size.width,
1999 (int)childFrameSCS .origin.x, (int)childFrameSCS .origin.y, (int)childFrameSCS .size.width, (int)childFrameSCS .size.width,
2000 (int)m_Pos.x, (int)m_Pos.y, (int)m_Size.width, (int)m_Size.height));
2001
2002 /** @todo galitsyn: drop this!
2003 * Later we have to correct the texture position in the case the window is
2004 * out of the parents window frame. So save the shift values for later use. */
2005 m_RootRect.origin.x = windowFrameSCS.origin.x - childFrameSCS.origin.x;
2006 m_RootRect.origin.y = childFrameSCS.size.height + childFrameSCS.origin.y - (windowFrameSCS.size.height + windowFrameSCS.origin.y);
2007 m_RootRect.size = windowFrameSCS.size;
2008 m_yInvRootOffset = windowFrameSCS.origin.y - childFrameSCS.origin.y;
2009
2010 DEBUG_MSG(("vboxReshapePerform: [%#p]: m_RootRect pos[%d : %d] size[%d : %d]\n",
2011 (void *)self, (int)m_RootRect.origin.x, (int)m_RootRect.origin.y, (int)m_RootRect.size.width, (int)m_RootRect.size.height));
2012
2013 /* Set the new frame. */
2014 [[self window] setFrame:windowFrameSCS display:YES];
2015
2016#ifndef IN_VMSVGA3D
2017 /* Inform the dock tile view as well. */
2018 [self reshapeDockTile];
2019#endif
2020
2021 /* Make sure the context is updated accordingly. */
2022 /* [self updateViewport]; */
2023 if (m_pSharedGLCtx)
2024 {
2025 VBOX_CR_RENDER_CTX_INFO CtxInfo;
2026 vboxCtxEnter(m_pSharedGLCtx, &CtxInfo);
2027
2028 [self updateViewportCS];
2029
2030 vboxCtxLeave(&CtxInfo);
2031 }
2032
2033 COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
2034}
2035
2036#ifndef IN_VMSVGA3D
2037
2038- (void)createDockTile
2039{
2040 COCOA_LOG_FLOW(("%s: self=%p\n", __PRETTY_FUNCTION__, (void *)self));
2041 NSView *pDockScreen = nil;
2042
2043 [self deleteDockTile];
2044
2045 /* Is there a dock tile preview enabled in the GUI? If so setup a
2046 * additional thumbnail view for the dock tile. */
2047 pDockScreen = [self dockTileScreen];
2048 if (pDockScreen)
2049 {
2050 m_DockTileView = [[DockOverlayView alloc] init];
2051 [self reshapeDockTile];
2052 [pDockScreen addSubview:m_DockTileView];
2053 }
2054
2055 COCOA_LOG_FLOW(("%s: returns - m_DockTileView\n", __PRETTY_FUNCTION__, (void *)m_DockTileView));
2056}
2057
2058- (void)deleteDockTile
2059{
2060 COCOA_LOG_FLOW(("%s: self=%p - m_DockTileView=%p\n", __PRETTY_FUNCTION__, (void *)self, (void *)m_DockTileView));
2061
2062 if (m_DockTileView != nil)
2063 {
2064 [m_DockTileView removeFromSuperview];
2065 [m_DockTileView release];
2066 m_DockTileView = nil;
2067 }
2068
2069 COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
2070}
2071
2072#endif /* !IN_VMSVGA3D */
2073
2074- (void)makeCurrentFBO
2075{
2076 COCOA_LOG_FLOW(("%s: self=%p - m_pGLCtx=%p m_fNeedCtxUpdate=%d\n", __PRETTY_FUNCTION__, (void *)self,
2077 (void *)m_pGLCtx, m_fNeedCtxUpdate));
2078
2079 if (m_pGLCtx)
2080 {
2081 NSOpenGLContext *pPrevCtx = [NSOpenGLContext currentContext];
2082
2083#ifdef IN_VMSVGA3D
2084 /* Always flush before flush. glXMakeCurrent and wglMakeCurrent does this
2085 implicitly, seemingly NSOpenGLContext::makeCurrentContext doesn't. */
2086 if (pPrevCtx != nil)
2087 {
2088 DEBUG_CLEAR_GL_ERRORS();
2089 glFlush();
2090 DEBUG_CHECK_GL_ERROR("glFlush");
2091 }
2092#endif
2093
2094 if ([m_pGLCtx view] != self)
2095 {
2096#ifndef IN_VMSVGA3D
2097 /* We change the active view, so flush first */
2098 if (pPrevCtx != nil)
2099 glFlush();
2100#endif
2101 DEBUG_CLEAR_GL_ERRORS();
2102 [m_pGLCtx setView: self];
2103 DEBUG_CHECK_GL_ERROR("setView");
2104 }
2105
2106#if 0
2107 if (pPrevCtx != m_pGLCtx)
2108#endif
2109 {
2110 DEBUG_CLEAR_GL_ERRORS();
2111 [m_pGLCtx makeCurrentContext];
2112 DEBUG_CHECK_GL_ERROR("makeCurrentContext");
2113 Assert([NSOpenGLContext currentContext] == m_pGLCtx);
2114 Assert([m_pGLCtx view] == self);
2115 }
2116
2117 if (m_fNeedCtxUpdate == true)
2118 {
2119 [m_pGLCtx update];
2120 m_fNeedCtxUpdate = false;
2121 }
2122
2123 if (!m_FBOId)
2124 {
2125 glGenFramebuffersEXT(1, &m_FBOId);
2126 Assert(m_FBOId);
2127 }
2128 }
2129
2130 COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
2131}
2132
2133- (bool)vboxSharedCtxCreate
2134{
2135 COCOA_LOG_FLOW(("%s: self=%p\n", __PRETTY_FUNCTION__, (void *)self));
2136
2137 if (m_pSharedGLCtx)
2138 {
2139 COCOA_LOG_FLOW(("%s: returns true (m_pSharedGLCtx=%p)\n", __PRETTY_FUNCTION__, (void *)m_pSharedGLCtx));
2140 return true;
2141 }
2142
2143#ifndef IN_VMSVGA3D
2144 Assert(!m_pBlitter);
2145 m_pBlitter = RTMemAlloc(sizeof(*m_pBlitter));
2146 if (RT_UNLIKELY(!m_pBlitter))
2147 {
2148 DEBUG_WARN(("m_pBlitter allocation failed"));
2149 COCOA_LOG_FLOW(("%s: returns false - m_pBlitter allocation failed\n", __PRETTY_FUNCTION__));
2150 return false;
2151 }
2152
2153 int rc = CrBltInit(m_pBlitter, NULL, false /*fCreateNewCtx*/, false /*fForceDrawBlt*/,
2154 &render_spu.GlobalShaders, &render_spu.blitterDispatch);
2155 if (RT_FAILURE(rc))
2156 {
2157 DEBUG_WARN(("CrBltInit failed, rc %d", rc));
2158 RTMemFree(m_pBlitter);
2159 m_pBlitter = NULL;
2160
2161 COCOA_LOG_FLOW(("%s: returns false - CrBltInit failed with rc=%Rrc\n", __PRETTY_FUNCTION__, rc));
2162 return false;
2163 }
2164
2165 COCOA_LOG_FLOW(("%s: blitter (%p) created successfully for view 0x%p\n", (void *)m_pBlitter, (void *)self));
2166#endif /* !IN_VMSVGA3D */
2167
2168 /* Create a shared context out of the main context. Use the same pixel format. */
2169 NSOpenGLPixelFormat *pPixelFormat = [(OverlayOpenGLContext *)m_pGLCtx openGLPixelFormat];
2170 NSOpenGLContext *pSharedGLCtx = [[NSOpenGLContext alloc] initWithFormat:pPixelFormat shareContext:m_pGLCtx];
2171
2172 /* Set the new context as non opaque */
2173 GLint opaque = 0;
2174 [pSharedGLCtx setValues:&opaque forParameter:NSOpenGLCPSurfaceOpacity];
2175
2176 /* Set this view as the drawable for the new context */
2177 [pSharedGLCtx setView:self];
2178 m_fNeedViewportUpdate = true;
2179
2180 m_pSharedGLCtx = pSharedGLCtx;
2181
2182 COCOA_LOG_FLOW(("%s: returns true - new m_pSharedGLCtx=%p\n", __PRETTY_FUNCTION__, (void *)m_pSharedGLCtx));
2183 return true;
2184}
2185
2186- (void)vboxTryDraw
2187{
2188 COCOA_LOG_FLOW(("%s: self=%p\n", __PRETTY_FUNCTION__, (void *)self));
2189
2190 glFlush();
2191
2192 /* Issue to the gui thread. */
2193 [self performSelectorOnMainThread:@selector(vboxTryDrawUI) withObject:nil waitUntilDone:NO];
2194
2195 COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
2196}
2197
2198- (void)vboxSetVisible:(GLboolean)fVisible
2199{
2200 COCOA_LOG_FLOW(("%s: self=%p fVisible=%d\n", __PRETTY_FUNCTION__, (void *)self, fVisible));
2201
2202 VBoxMainThreadTaskRunner *pRunner = [VBoxMainThreadTaskRunner globalInstance];
2203 NSNumber *pVisObj = [NSNumber numberWithBool:fVisible];
2204 [pRunner addObj:self selector:@selector(vboxSetVisibleUIObj:) arg:pVisObj];
2205
2206 COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
2207}
2208
2209- (void)vboxSetVisibleUI:(GLboolean)fVisible
2210{
2211 COCOA_LOG_FLOW(("%s: self=%p fVisible=%d\n", __PRETTY_FUNCTION__, (void *)self, fVisible));
2212
2213 [self setHidden: !fVisible];
2214
2215 COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
2216}
2217
2218- (void)vboxSetVisibleUIObj:(NSNumber *)pVisibleObj
2219{
2220 COCOA_LOG_FLOW(("%s: self=%p pVisibleObj=%p(%d)\n", __PRETTY_FUNCTION__,
2221 (void *)self, (void *)pVisibleObj, [pVisibleObj boolValue]));
2222
2223 BOOL fVisible = [pVisibleObj boolValue];
2224 [self vboxSetVisibleUI:fVisible];
2225
2226 COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
2227}
2228
2229- (void)vboxReparent:(NSView *)pParentView
2230{
2231 COCOA_LOG_FLOW(("%s: self=%p pParentView=%p\n", __PRETTY_FUNCTION__, (void *)self, (void *)pParentView));
2232
2233 VBoxMainThreadTaskRunner *pRunner = [VBoxMainThreadTaskRunner globalInstance];
2234 [pRunner addObj:self selector:@selector(vboxReparentUI:) arg:pParentView];
2235
2236 COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
2237}
2238
2239- (void)vboxReparentUI:(NSView *)pParentView
2240{
2241 COCOA_LOG_FLOW(("%s: self=%p pParentView=%p\n", __PRETTY_FUNCTION__, (void *)self, (void *)pParentView));
2242
2243 /* Make sure the window is removed from any previous parent window. */
2244 if ([[self overlayWin] parentWindow] != nil)
2245 {
2246 [[[self overlayWin] parentWindow] removeChildWindow:[self overlayWin]];
2247 }
2248
2249 /* Set the new parent view */
2250 [self setParentView: pParentView];
2251
2252 /* Add the overlay window as a child to the new parent window */
2253 if (pParentView != nil)
2254 {
2255 [[pParentView window] addChildWindow:[self overlayWin] ordered:NSWindowAbove];
2256 if ([self isEverSized])
2257 [self vboxReshapeOnReparentPerform];
2258 }
2259
2260 COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
2261}
2262
2263- (void)vboxTryDrawUI
2264{
2265 COCOA_LOG_FLOW(("%s: self=%p\n", __PRETTY_FUNCTION__, (void *)self));
2266
2267 if ([self isHidden])
2268 {
2269 COCOA_LOG_FLOW(("%s: returns - request to draw on a hidden view\n", __PRETTY_FUNCTION__));
2270 return;
2271 }
2272
2273 if ([[self overlayWin] parentWindow] == nil)
2274 {
2275 COCOA_LOG_FLOW(("%s: returns - request to draw a view w/o a parent\n", __PRETTY_FUNCTION__));
2276 return;
2277 }
2278
2279#ifdef IN_VMSVGA3D
2280 if (!m_pSharedGLCtx)
2281 {
2282 Assert(!m_fDataVisible);
2283 Assert(!m_fCleanupNeeded);
2284 if (![self vboxSharedCtxCreate])
2285 {
2286 COCOA_LOG_FLOW(("%s: returns - vboxSharedCtxCreate failed\n", __PRETTY_FUNCTION__));
2287 return;
2288 }
2289 Assert(m_pSharedGLCtx);
2290 }
2291#endif
2292
2293 const VBOXVR_SCR_COMPOSITOR *pCompositor = NULL;
2294#ifndef IN_VMSVGA3D
2295 int rc = renderspuVBoxCompositorLock(m_pWinInfo, &pCompositor);
2296 if (RT_FAILURE(rc))
2297 {
2298 COCOA_LOG_FLOW(("%s: returns - renderspuVBoxCompositorLock failed (%Rrc)\n", __PRETTY_FUNCTION__, rc));
2299 return;
2300 }
2301
2302 if (!pCompositor && !m_fCleanupNeeded)
2303 {
2304 renderspuVBoxCompositorUnlock(m_pWinInfo);
2305 COCOA_LOG_FLOW(("%s: returns - noCompositorUI\n", __PRETTY_FUNCTION__));
2306 return;
2307 }
2308
2309 VBOXVR_SCR_COMPOSITOR TmpCompositor;
2310 if (pCompositor)
2311 {
2312 if (!m_pSharedGLCtx)
2313 {
2314 Assert(!m_fDataVisible);
2315 Assert(!m_fCleanupNeeded);
2316 renderspuVBoxCompositorRelease(m_pWinInfo);
2317 if (![self vboxSharedCtxCreate])
2318 {
2319 COCOA_LOG_FLOW(("%s: returns - vboxSharedCtxCreate failed\n", __PRETTY_FUNCTION__));
2320 return;
2321 }
2322
2323 Assert(m_pSharedGLCtx);
2324
2325 pCompositor = renderspuVBoxCompositorAcquire(m_pWinInfo);
2326 Assert(!m_fDataVisible);
2327 Assert(!m_fCleanupNeeded);
2328 if (!pCompositor)
2329 {
2330 COCOA_LOG_FLOW(("%s: returns - Failed to reacquire compositor\n", __PRETTY_FUNCTION__));
2331 return;
2332 }
2333 }
2334 }
2335 else
2336 {
2337 DEBUG_MSG(("%s: NeedCleanup\n", __PRETTY_FUNCTION__));
2338 Assert(m_fCleanupNeeded);
2339 CrVrScrCompositorInit(&TmpCompositor, NULL);
2340 pCompositor = &TmpCompositor;
2341 }
2342#endif /* !IN_VMSVGA3D */
2343
2344
2345 if ([self lockFocusIfCanDraw])
2346 {
2347 COCOA_LOG_FLOW(("%s: Calling vboxPresent\n", __PRETTY_FUNCTION__));
2348 [self vboxPresent:pCompositor];
2349 [self unlockFocus];
2350 }
2351#ifndef IN_VMSVGA3D /** @todo VMSVGA3 */
2352 else if (!m_pWinInfo->visible)
2353 {
2354 COCOA_LOG_FLOW(("%s: NotVisible\n", __PRETTY_FUNCTION__));
2355 m_fCleanupNeeded = false;
2356 }
2357#endif
2358 else
2359 {
2360 COCOA_LOG_FLOW(("%s: Reschedule\n", __PRETTY_FUNCTION__));
2361 [NSTimer scheduledTimerWithTimeInterval:0.1 target:self selector:@selector(vboxTryDrawUI) userInfo:nil repeats:NO];
2362 }
2363
2364#ifndef IN_VMSVGA3D
2365 renderspuVBoxCompositorUnlock(m_pWinInfo);
2366#endif
2367 COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
2368}
2369
2370- (void)swapFBO
2371{
2372 COCOA_LOG_FLOW(("%s: self=%p - m_pGLCtx=%p\n", __PRETTY_FUNCTION__, (void *)self, (void *)m_pGLCtx));
2373 [m_pGLCtx flushBuffer];
2374 COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
2375}
2376
2377- (void)vboxPresent:(PCVBOXVR_SCR_COMPOSITOR)pCompositor
2378{
2379 COCOA_LOG_FLOW(("%s: self=%p pCompositor=%p\n", __PRETTY_FUNCTION__, (void *)self, (void *)pCompositor));
2380 /*DEBUG_MSG(("OVIW(%p): renderFBOToView\n", (void *)self));*/
2381#ifndef IN_VMSVGA3D
2382 AssertPtr(pCompositor);
2383#endif
2384
2385 VBOX_CR_RENDER_CTX_INFO CtxInfo;
2386 vboxCtxEnter(m_pSharedGLCtx, &CtxInfo);
2387
2388 [self vboxPresentCS:pCompositor];
2389
2390 vboxCtxLeave(&CtxInfo);
2391 COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
2392}
2393
2394- (void)vboxPresentCS:(PCVBOXVR_SCR_COMPOSITOR)pCompositor
2395{
2396 COCOA_LOG_FLOW(("%s: self=%p pCompositor=%p\n", __PRETTY_FUNCTION__, (void *)self, (void *)pCompositor));
2397 if ([m_pSharedGLCtx view] != self)
2398 {
2399 COCOA_LOG_FLOW(("%s: Not current view of shared ctx! Switching... (self=%p, view=%p, m_pSharedGLCtx)\n",
2400 __PRETTY_FUNCTION__, (void *)self, (void *)[m_pSharedGLCtx view], (void *)m_pSharedGLCtx));
2401 [m_pSharedGLCtx setView: self];
2402 m_fNeedViewportUpdate = true;
2403 }
2404
2405 if (m_fNeedViewportUpdate)
2406 {
2407 [self updateViewportCS];
2408 m_fNeedViewportUpdate = false;
2409 }
2410
2411 m_fCleanupNeeded = false;
2412
2413#ifndef IN_VMSVGA3D
2414 /* Render FBO content to the dock tile when necessary. */
2415 [self vboxPresentToDockTileCS:pCompositor];
2416#endif
2417
2418 /* change to #if 0 to see thumbnail image */
2419#if 1
2420 [self vboxPresentToViewCS:pCompositor];
2421#else
2422 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
2423 [m_pSharedGLCtx flushBuffer];
2424#endif
2425
2426 COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
2427}
2428
2429DECLINLINE(void) vboxNSRectToRect(const NSRect *pR, RTRECT *pRect)
2430{
2431 pRect->xLeft = (int)pR->origin.x;
2432 pRect->yTop = (int)pR->origin.y;
2433 pRect->xRight = (int)(pR->origin.x + pR->size.width);
2434 pRect->yBottom = (int)(pR->origin.y + pR->size.height);
2435}
2436
2437DECLINLINE(void) vboxNSRectToRectUnstretched(const NSRect *pR, RTRECT *pRect, float xStretch, float yStretch)
2438{
2439 pRect->xLeft = (int)(pR->origin.x / xStretch);
2440 pRect->yTop = (int)(pR->origin.y / yStretch);
2441 pRect->xRight = (int)((pR->origin.x + pR->size.width) / xStretch);
2442 pRect->yBottom = (int)((pR->origin.y + pR->size.height) / yStretch);
2443}
2444
2445DECLINLINE(void) vboxNSRectToRectStretched(const NSRect *pR, RTRECT *pRect, float xStretch, float yStretch)
2446{
2447 pRect->xLeft = (int)(pR->origin.x * xStretch);
2448 pRect->yTop = (int)(pR->origin.y * yStretch);
2449 pRect->xRight = (int)((pR->origin.x + pR->size.width) * xStretch);
2450 pRect->yBottom = (int)((pR->origin.y + pR->size.height) * yStretch);
2451}
2452
2453- (void)vboxPresentToViewCS:(PCVBOXVR_SCR_COMPOSITOR)pCompositor
2454{
2455 NSRect r = [self frame];
2456 COCOA_LOG_FLOW(("%s: self=%p - r={%d,%d %d,%d}\n", __PRETTY_FUNCTION__, (void *)self,
2457 (int)r.origin.x, (int)r.origin.y, (int)r.size.width, (int)r.size.height));
2458
2459#if 1 /* Set to 0 to see the docktile instead of the real output */
2460 float backingStretchFactor = 1.;
2461# if defined(VBOX_WITH_CONFIGURABLE_HIDPI_SCALING) && !defined(IN_VMSVGA3D)
2462 /* Adjust viewport according to current NSView's backing store parameters. */
2463 if (render_spu.fUnscaledHiDPI)
2464 {
2465 /* Update stretch factor in order to satisfy current NSView's backing store parameters. */
2466 backingStretchFactor = [self safeGetBackingScaleFactor];
2467 }
2468
2469 NSRect regularBounds = [self bounds];
2470 NSRect backingBounds = [self safeConvertRectToBacking:&regularBounds];
2471 glViewport(0, 0, backingBounds.size.width, backingBounds.size.height);
2472
2473 //crDebug("HiDPI: vboxPresentToViewCS: up-scaling is %s (backingStretchFactor=%d).",
2474 // render_spu.fUnscaledHiDPI ? "OFF" : "ON", (int)backingStretchFactor);
2475# endif
2476
2477 glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, 0);
2478 glDrawBuffer(GL_BACK);
2479
2480 /* Clear background to transparent */
2481 glClear(GL_COLOR_BUFFER_BIT);
2482
2483 m_fDataVisible = false;
2484
2485# ifndef IN_VMSVGA3D
2486 float xStretch;
2487 float yStretch;
2488 CrVrScrCompositorGetStretching(pCompositor, &xStretch, &yStretch);
2489
2490 VBOXVR_SCR_COMPOSITOR_CONST_ITERATOR CIter;
2491 const VBOXVR_SCR_COMPOSITOR_ENTRY *pEntry;
2492 CrVrScrCompositorConstIterInit(pCompositor, &CIter);
2493
2494 while ((pEntry = CrVrScrCompositorConstIterNext(&CIter)) != NULL)
2495 {
2496 uint32_t cRegions;
2497 const RTRECT *paSrcRegions, *paDstRegions;
2498 int rc = CrVrScrCompositorEntryRegionsGet(pCompositor, pEntry, &cRegions, &paSrcRegions, &paDstRegions, NULL);
2499 uint32_t fFlags = CrVrScrCompositorEntryFlagsCombinedGet(pCompositor, pEntry);
2500 if (RT_SUCCESS(rc))
2501 {
2502 rc = CrBltEnter(m_pBlitter);
2503 if (RT_SUCCESS(rc))
2504 {
2505 uint32_t i;
2506 for (i = 0; i < cRegions; ++i)
2507 {
2508 const CR_TEXDATA *pTexData;
2509 PCRTRECT pSrcRect = &paSrcRegions[i];
2510 PCRTRECT pDstRect = &paDstRegions[i];
2511 RTRECT DstRect, RestrictDstRect;
2512 RTRECT SrcRect, RestrictSrcRect;
2513
2514 vboxNSRectToRect(&m_RootRect, &RestrictDstRect);
2515 VBoxRectIntersected(&RestrictDstRect, pDstRect, &DstRect);
2516
2517 if (VBoxRectIsZero(&DstRect))
2518 continue;
2519
2520 VBoxRectTranslate(&DstRect, -RestrictDstRect.xLeft, -RestrictDstRect.yTop);
2521
2522 vboxNSRectToRectUnstretched(&m_RootRect, &RestrictSrcRect, xStretch / backingStretchFactor, yStretch / backingStretchFactor);
2523 VBoxRectTranslate(&RestrictSrcRect,
2524 -CrVrScrCompositorEntryRectGet(pEntry)->xLeft,
2525 -CrVrScrCompositorEntryRectGet(pEntry)->yTop);
2526 VBoxRectIntersected(&RestrictSrcRect, pSrcRect, &SrcRect);
2527
2528 if (VBoxRectIsZero(&SrcRect))
2529 continue;
2530
2531 pSrcRect = &SrcRect;
2532 pDstRect = &DstRect;
2533
2534 pTexData = CrVrScrCompositorEntryTexGet(pEntry);
2535
2536 CrBltBlitTexMural(m_pBlitter, true, CrTdTexGet(pTexData), pSrcRect, pDstRect, 1, fFlags | CRBLT_F_NOALPHA);
2537
2538 m_fDataVisible = true;
2539 }
2540 CrBltLeave(m_pBlitter);
2541 }
2542 else
2543 {
2544 DEBUG_WARN(("CrBltEnter failed rc %d", rc));
2545# ifndef DEBUG_VERBOSE
2546 AssertMsgFailed(("CrBltEnter failed rc %Rrc", rc));
2547# endif
2548 }
2549 }
2550 else
2551 {
2552 AssertMsgFailed(("BlitStretched: CrVrScrCompositorEntryRegionsGet failed rc %Rrc\n", rc));
2553 DEBUG_MSG_1(("BlitStretched: CrVrScrCompositorEntryRegionsGet failed rc %d\n", rc));
2554 }
2555 }
2556# endif /* !IN_VMSVGA3D */
2557#endif
2558
2559 /*
2560 glFinish();
2561 */
2562 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
2563 [m_pSharedGLCtx flushBuffer];
2564
2565 COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
2566}
2567
2568- (void)presentComposition:(PCVBOXVR_SCR_COMPOSITOR_ENTRY)pChangedEntry
2569{
2570 COCOA_LOG_FLOW(("%s: self=%p pChangedEntry=%p\n", __PRETTY_FUNCTION__, (void *)self, (void *)pChangedEntry));
2571 [self vboxTryDraw];
2572}
2573
2574#ifndef IN_VMSVGA3D
2575- (void)vboxBlitterSyncWindow
2576{
2577 COCOA_LOG_FLOW(("%s: self=%p\n", __PRETTY_FUNCTION__, (void *)self));
2578 CR_BLITTER_WINDOW WinInfo;
2579 NSRect r;
2580
2581 if (!m_pBlitter)
2582 return;
2583
2584 RT_ZERO(WinInfo);
2585
2586 r = [self frame];
2587 WinInfo.width = r.size.width;
2588 WinInfo.height = r.size.height;
2589
2590 Assert(WinInfo.width == m_RootRect.size.width);
2591 Assert(WinInfo.height == m_RootRect.size.height);
2592
2593 /*CrBltMuralSetCurrentInfo(m_pBlitter, NULL);*/
2594
2595 CrBltMuralSetCurrentInfo(m_pBlitter, &WinInfo);
2596 CrBltCheckUpdateViewport(m_pBlitter);
2597}
2598#endif /* !IN_VMSVGA3D */
2599
2600#ifndef IN_VMSVGA3D
2601# ifdef VBOX_WITH_CRDUMPER_THUMBNAIL
2602static int g_cVBoxTgaCtr = 0;
2603# endif
2604- (void)vboxPresentToDockTileCS:(PCVBOXVR_SCR_COMPOSITOR)pCompositor
2605{
2606 COCOA_LOG_FLOW(("%s: self=%p pCompositor=%p\n", __PRETTY_FUNCTION__, (void *)self, (void *)pCompositor));
2607 NSRect r = [self frame];
2608 NSRect rr = NSZeroRect;
2609 NSDockTile *pDT = nil;
2610 float xStretch;
2611 float yStretch;
2612
2613 if ([m_DockTileView thumbBitmap] != nil)
2614 {
2615 /*
2616 * Only update after at least 200 ms, cause glReadPixels is
2617 * heavy performance wise.
2618 */
2619 uint64_t msTS = RTTimeSystemMilliTS();
2620 VBOXVR_SCR_COMPOSITOR_CONST_ITERATOR CIter;
2621 const VBOXVR_SCR_COMPOSITOR_ENTRY *pEntry;
2622
2623 if (msTS - m_msDockUpdateTS > 200)
2624 {
2625 m_msDockUpdateTS = msTS;
2626# if 0
2627 /** @todo check this for optimization */
2628 glBindTexture(GL_TEXTURE_RECTANGLE_ARB, myTextureName);
2629 glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_STORAGE_HINT_APPLE,
2630 GL_STORAGE_SHARED_APPLE);
2631 glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE);
2632 glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA,
2633 sizex, sizey, 0, GL_BGRA,
2634 GL_UNSIGNED_INT_8_8_8_8_REV, myImagePtr);
2635 glCopyTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB,
2636 0, 0, 0, 0, 0, image_width, image_height);
2637 glFlush();
2638 /* Do other work processing here, using a double or triple buffer */
2639 glGetTexImage(GL_TEXTURE_RECTANGLE_ARB, 0, GL_BGRA,
2640 GL_UNSIGNED_INT_8_8_8_8_REV, pixels);
2641# endif
2642 glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, 0);
2643 glDrawBuffer(GL_BACK);
2644
2645 /* Clear background to transparent */
2646 glClear(GL_COLOR_BUFFER_BIT);
2647
2648 rr = [m_DockTileView frame];
2649
2650 CrVrScrCompositorGetStretching(pCompositor, &xStretch, &yStretch);
2651
2652 CrVrScrCompositorConstIterInit(pCompositor, &CIter);
2653 while ((pEntry = CrVrScrCompositorConstIterNext(&CIter)) != NULL)
2654 {
2655 uint32_t cRegions;
2656 PCRTRECT paSrcRegions;
2657 PCRTRECT paDstRegions;
2658 int rc = CrVrScrCompositorEntryRegionsGet(pCompositor, pEntry, &cRegions, &paSrcRegions, &paDstRegions, NULL);
2659 uint32_t fFlags = CrVrScrCompositorEntryFlagsCombinedGet(pCompositor, pEntry);
2660 if (RT_SUCCESS(rc))
2661 {
2662 rc = CrBltEnter(m_pBlitter);
2663 if (RT_SUCCESS(rc))
2664 {
2665 uint32_t i;
2666 for (i = 0; i < cRegions; ++i)
2667 {
2668 const CR_TEXDATA *pTexData;
2669 PCRTRECT pSrcRect = &paSrcRegions[i];
2670 PCRTRECT pDstRect = &paDstRegions[i];
2671 RTRECT DstRect, RestrictDstRect;
2672 RTRECT SrcRect, RestrictSrcRect;
2673
2674 vboxNSRectToRect(&m_RootRect, &RestrictDstRect);
2675 VBoxRectIntersected(&RestrictDstRect, pDstRect, &DstRect);
2676
2677 VBoxRectTranslate(&DstRect, -RestrictDstRect.xLeft, -RestrictDstRect.yTop);
2678
2679 VBoxRectScale(&DstRect, m_FBOThumbScaleX, m_FBOThumbScaleY);
2680
2681 if (VBoxRectIsZero(&DstRect))
2682 continue;
2683
2684 vboxNSRectToRectUnstretched(&m_RootRect, &RestrictSrcRect, xStretch, yStretch);
2685 VBoxRectTranslate(&RestrictSrcRect,
2686 -CrVrScrCompositorEntryRectGet(pEntry)->xLeft,
2687 -CrVrScrCompositorEntryRectGet(pEntry)->yTop);
2688 VBoxRectIntersected(&RestrictSrcRect, pSrcRect, &SrcRect);
2689
2690 if (VBoxRectIsZero(&SrcRect))
2691 continue;
2692
2693 pSrcRect = &SrcRect;
2694 pDstRect = &DstRect;
2695
2696 pTexData = CrVrScrCompositorEntryTexGet(pEntry);
2697
2698 CrBltBlitTexMural(m_pBlitter, true, CrTdTexGet(pTexData), pSrcRect, pDstRect, 1, fFlags);
2699 }
2700 CrBltLeave(m_pBlitter);
2701 }
2702 else
2703 {
2704 DEBUG_WARN(("CrBltEnter failed rc %d", rc));
2705# ifndef DEBUG_VERBOSE
2706 AssertMsgFailed(("CrBltEnter failed rc %Rrc", rc));
2707# endif
2708 }
2709 }
2710 else
2711 {
2712 DEBUG_MSG_1(("BlitStretched: CrVrScrCompositorEntryRegionsGet failed rc %d\n", rc));
2713 AssertMsgFailed(("BlitStretched: CrVrScrCompositorEntryRegionsGet failed rc %Rrc\n", rc));
2714 }
2715 }
2716
2717 glFinish();
2718
2719 glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, 0);
2720 glReadBuffer(GL_BACK);
2721
2722 /* Here the magic of reading the FBO content in our own buffer
2723 * happens. We have to lock this access, in the case the dock
2724 * is updated currently. */
2725 [m_DockTileView lock];
2726 glReadPixels(0, m_RootRect.size.height - rr.size.height, rr.size.width, rr.size.height,
2727 GL_BGRA,
2728 GL_UNSIGNED_INT_8_8_8_8,
2729 [[m_DockTileView thumbBitmap] bitmapData]);
2730 [m_DockTileView unlock];
2731
2732# ifdef VBOX_WITH_CRDUMPER_THUMBNAIL
2733 ++g_cVBoxTgaCtr;
2734 crDumpNamedTGAF((GLint)rr.size.width, (GLint)rr.size.height,
2735 [[m_DockTileView thumbBitmap] bitmapData], "/Users/leo/vboxdumps/dump%d.tga", g_cVBoxTgaCtr);
2736# endif
2737
2738 pDT = [[NSApplication sharedApplication] dockTile];
2739
2740 /* Send a display message to the dock tile in the main thread */
2741 [[[NSApplication sharedApplication] dockTile] performSelectorOnMainThread:@selector(display) withObject:nil
2742 waitUntilDone:NO];
2743 }
2744 }
2745}
2746#endif /* !IN_VMSVGA3D */
2747
2748- (void)clearVisibleRegions
2749{
2750 if (m_paClipRects)
2751 {
2752 RTMemFree(m_paClipRects);
2753 m_paClipRects = NULL;
2754 }
2755 m_cClipRects = 0;
2756}
2757
2758- (GLboolean)vboxNeedsEmptyPresent
2759{
2760 if (m_fDataVisible)
2761 {
2762 m_fCleanupNeeded = true;
2763 return GL_TRUE;
2764 }
2765
2766 return GL_FALSE;
2767}
2768
2769- (void)setVisibleRegions:(GLint)cRects paRects:(const GLint *)paRects
2770{
2771 COCOA_LOG_FLOW(("%s: self=%p cRects=%d paRects=%p\n", __PRETTY_FUNCTION__, (void *)self, cRects, (void *)paRects));
2772 GLint cOldRects = m_cClipRects;
2773
2774 [self clearVisibleRegions];
2775
2776 if (cRects > 0)
2777 {
2778#ifdef DEBUG_poetzsch
2779 int i = 0;
2780 for (i = 0; i < cRects; ++i)
2781 DEBUG_MSG_1(("OVIW(%p): setVisibleRegions: %d - %d %d %d %d\n", (void *)self, i, paRects[i * 4], paRects[i * 4 + 1], paRects[i * 4 + 2], paRects[i * 4 + 3]));
2782#endif
2783
2784 m_paClipRects = (GLint *)RTMemDup(paRects, sizeof(GLint) * 4 * cRects);
2785 m_cClipRects = cRects;
2786 }
2787
2788 COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
2789}
2790
2791#ifndef IN_VMSVGA3D
2792
2793- (NSView *)dockTileScreen
2794{
2795 COCOA_LOG_FLOW(("%s: self=%p\n", __PRETTY_FUNCTION__, (void *)self));
2796 NSView *pContentView = [[[NSApplication sharedApplication] dockTile] contentView];
2797 NSView *pScreenContent = nil;
2798
2799 /*
2800 * First try the new variant which checks if this window is within the
2801 * screen which is previewed in the dock.
2802 */
2803 if ([pContentView respondsToSelector:@selector(screenContentWithParentView:)])
2804 pScreenContent = [pContentView performSelector:@selector(screenContentWithParentView:) withObject:(id)m_pParentView];
2805 /*
2806 * If it fails, fall back to the old variant (VBox...).
2807 */
2808 else if ([pContentView respondsToSelector:@selector(screenContent)])
2809 pScreenContent = [pContentView performSelector:@selector(screenContent)];
2810
2811 COCOA_LOG_FLOW(("%s: returns %p (pContentView=%p)\n", __PRETTY_FUNCTION__, (void *)pScreenContent, (void *)pContentView));
2812 return pScreenContent;
2813}
2814
2815- (void)reshapeDockTile
2816{
2817 COCOA_LOG_FLOW(("%s:\n", __PRETTY_FUNCTION__));
2818 NSRect newFrame = NSZeroRect;
2819 NSView *pView = [self dockTileScreen];
2820 if (pView != nil)
2821 {
2822 NSRect dockFrame = [pView frame];
2823 /** @todo This is not correct, we should use framebuffer size here, while
2824 * parent view frame size may differ in case of scrolling. */
2825 NSRect parentFrame = [m_pParentView frame];
2826
2827 m_FBOThumbScaleX = (float)dockFrame.size.width / parentFrame.size.width;
2828 m_FBOThumbScaleY = (float)dockFrame.size.height / parentFrame.size.height;
2829 newFrame = NSMakeRect((int)(m_Pos.x * m_FBOThumbScaleX),
2830 (int)(dockFrame.size.height - (m_Pos.y + m_Size.height - m_yInvRootOffset) * m_FBOThumbScaleY),
2831 (int)(m_Size.width * m_FBOThumbScaleX),
2832 (int)(m_Size.height * m_FBOThumbScaleY));
2833 /*
2834 NSRect newFrame = NSMakeRect ((int)roundf(m_Pos.x * m_FBOThumbScaleX), (int)roundf(dockFrame.size.height - (m_Pos.y + m_Size.height) * m_FBOThumbScaleY), (int)roundf(m_Size.width * m_FBOThumbScaleX), (int)roundf(m_Size.height * m_FBOThumbScaleY));
2835 NSRect newFrame = NSMakeRect ((m_Pos.x * m_FBOThumbScaleX), (dockFrame.size.height - (m_Pos.y + m_Size.height) * m_FBOThumbScaleY), (m_Size.width * m_FBOThumbScaleX), (m_Size.height * m_FBOThumbScaleY));
2836 printf ("%f %f %f %f - %f %f\n", newFrame.origin.x, newFrame.origin.y, newFrame.size.width, newFrame.size.height, m_Size.height, m_FBOThumbScaleY);
2837 */
2838 [m_DockTileView setFrame: newFrame];
2839 }
2840 COCOA_LOG_FLOW(("%s: returns - newFrame={%d,%d %d,%d} pView=%d\n", __PRETTY_FUNCTION__, (int)newFrame.origin.x,
2841 (int)newFrame.origin.y, (int)newFrame.size.width, (int)newFrame.size.height, (void *)pView));
2842}
2843
2844#endif /* !IN_VMSVGA3D */
2845
2846@end /* @implementation OverlayView */
2847
2848
2849/********************************************************************************
2850*
2851* OpenGL context management
2852*
2853********************************************************************************/
2854void cocoaGLCtxCreate(NativeNSOpenGLContextRef *ppCtx, GLbitfield fVisParams, NativeNSOpenGLContextRef pSharedCtx)
2855{
2856 COCOA_LOG_FLOW(("cocoaGLCtxCreate: ppCtx=%p fVisParams=%#x pSharedCtx=%p\n", (void *)ppCtx, fVisParams, (void *)pSharedCtx));
2857 NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
2858
2859 NSOpenGLPixelFormat *pFmt = vboxCreatePixelFormat(fVisParams);
2860 if (pFmt)
2861 {
2862 *ppCtx = [[OverlayOpenGLContext alloc] initWithFormat:pFmt shareContext:pSharedCtx];
2863 Assert(*ppCtx);
2864
2865 /* Enable multi threaded OpenGL engine */
2866 /*
2867 CGLContextObj cglCtx = [*ppCtx CGLContextObj];
2868 CGLError err = CGLEnable(cglCtx, kCGLCEMPEngine);
2869 if (err != kCGLNoError)
2870 printf ("Couldn't enable MT OpenGL engine!\n");
2871 */
2872 }
2873 else
2874 {
2875 AssertFailed();
2876 *ppCtx = NULL;
2877 }
2878
2879 [pPool release];
2880 COCOA_LOG_FLOW(("cocoaGLCtxCreate: returns *ppCtx=%p\n", (void *)*ppCtx));
2881}
2882
2883void cocoaGLCtxDestroy(NativeNSOpenGLContextRef pCtx)
2884{
2885 COCOA_LOG_FLOW(("cocoaGLCtxDestroy: pCtx=%p\n", (void *)pCtx));
2886 NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
2887
2888 [pCtx release];
2889 /*[pCtx performSelectorOnMainThread:@selector(release) withObject:nil waitUntilDone:NO];*/
2890
2891 [pPool release];
2892 COCOA_LOG_FLOW(("cocoaGLCtxDestroy: returns\n"));
2893}
2894
2895/********************************************************************************
2896*
2897* View management
2898*
2899********************************************************************************/
2900static OverlayView *vboxViewCreate(WindowInfo *pWinInfo, NativeNSViewRef pParentView, GLbitfield fVisParams)
2901{
2902 COCOA_LOG_FLOW(("vboxViewCreate: pWinInfo=%p pParentView=%p fVisParams=%#x\n", pWinInfo, (void *)pParentView, fVisParams));
2903
2904 /* Create our worker view. */
2905 OverlayView *pView = [[OverlayView alloc] initWithFrame:NSZeroRect
2906 thread:RTThreadSelf()
2907 parentView:pParentView
2908 winInfo:pWinInfo
2909 fVisParams:fVisParams];
2910
2911 if (pView)
2912 {
2913 /* We need a real window as container for the view */
2914 [[OverlayWindow alloc] initWithParentView:pParentView overlayView:pView];
2915 /* Return the freshly created overlay view */
2916 COCOA_LOG_FLOW(("vboxViewCreate: returns %p\n", (void *)pView));
2917 return pView;
2918 }
2919
2920 COCOA_LOG_FLOW(("vboxViewCreate: returns NULL\n"));
2921 return NULL;
2922}
2923
2924#ifndef IN_VMSVGA3D
2925
2926typedef struct CR_RCD_CREATEVIEW
2927{
2928 WindowInfo *pWinInfo;
2929 NSView *pParentView;
2930 GLbitfield fVisParams;
2931 /* out */
2932 OverlayView *pView;
2933} CR_RCD_CREATEVIEW;
2934
2935static DECLCALLBACK(void) vboxRcdCreateView(void *pvCb)
2936{
2937 CR_RCD_CREATEVIEW *pCreateView = (CR_RCD_CREATEVIEW *)pvCb;
2938 pCreateView->pView = vboxViewCreate(pCreateView->pWinInfo, pCreateView->pParentView, pCreateView->fVisParams);
2939 COCOA_LOG_FLOW(("vboxRcdCreateView: returns pView=%p\n", (void *)pCreateView->pView));
2940}
2941
2942#endif /* !IN_VMSVGA3D */
2943
2944void cocoaViewCreate(NativeNSViewRef *ppView, WindowInfo *pWinInfo, NativeNSViewRef pParentView, GLbitfield fVisParams)
2945{
2946 COCOA_LOG_FLOW(("cocoaViewCreate: ppView=%p pWinInfo=%p pParentView=%p fVisParams=%#x\n",
2947 (void *)ppView, (void *)pWinInfo, (void *)pParentView, fVisParams));
2948 NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
2949
2950 /* make sure all tasks are run, to preserve the order */
2951 VBoxMainThreadTaskRunner *pRunner = [VBoxMainThreadTaskRunner globalInstance];
2952 [pRunner runTasksSyncIfPossible];
2953
2954#ifndef IN_VMSVGA3D
2955 renderspuWinRetain(pWinInfo);
2956
2957 if (renderspuCalloutAvailable())
2958 {
2959 CR_RCD_CREATEVIEW CreateView;
2960 CreateView.pWinInfo = pWinInfo;
2961 CreateView.pParentView = pParentView;
2962 CreateView.fVisParams = fVisParams;
2963 CreateView.pView = NULL;
2964 renderspuCalloutClient(vboxRcdCreateView, &CreateView);
2965 *ppView = CreateView.pView;
2966 }
2967 else
2968#endif
2969 {
2970 DEBUG_MSG_NOT_VMSVGA3D(("no callout available on createWindow\n"));
2971#if 0
2972 dispatch_sync(dispatch_get_main_queue(), ^{
2973#endif
2974 *ppView = vboxViewCreate(pWinInfo, pParentView, fVisParams);
2975#if 0
2976 });
2977#endif
2978 }
2979
2980#ifndef IN_VMSVGA3D
2981 if (!*ppView)
2982 renderspuWinRelease(pWinInfo);
2983#endif
2984
2985 [pPool release];
2986 COCOA_LOG_FLOW(("cocoaViewCreate: returns *ppView=%p\n", (void *)*ppView));
2987}
2988
2989#ifndef IN_VMSVGA3D
2990void cocoaViewReparent(NativeNSViewRef pView, NativeNSViewRef pParentView)
2991{
2992 COCOA_LOG_FLOW(("cocoaViewReparent: pView=%p pParentView=%p\n", (void *)pView, (void *)pParentView));
2993 NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
2994
2995 OverlayView *pOView = (OverlayView *)pView;
2996 if (pOView)
2997 [pOView vboxReparent:pParentView];
2998
2999 [pPool release];
3000 COCOA_LOG_FLOW(("cocoaViewReparent: returns\n"));
3001}
3002#endif /* !IN_VMSVGA3D */
3003
3004void cocoaViewDestroy(NativeNSViewRef pView)
3005{
3006 COCOA_LOG_FLOW(("cocoaViewDestroy: pView=%p\n", (void *)pView));
3007 NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
3008
3009 VBoxMainThreadTaskRunner *pRunner = [VBoxMainThreadTaskRunner globalInstance];
3010 [pRunner addObj:pView selector:@selector(vboxDestroy) arg:nil];
3011
3012 [pPool release];
3013 COCOA_LOG_FLOW(("cocoaViewDestroy: returns\n"));
3014}
3015
3016#ifndef IN_VMSVGA3D
3017void cocoaViewShow(NativeNSViewRef pView, GLboolean fShowIt)
3018{
3019 COCOA_LOG_FLOW(("cocoaViewShow: pView=%p fShowIt=%d\n", (void *)pView, fShowIt));
3020 NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
3021
3022 [(OverlayView *)pView vboxSetVisible:fShowIt];
3023
3024 [pPool release];
3025 COCOA_LOG_FLOW(("cocoaViewShow: returns\n"));
3026}
3027#endif /* IN_VMSVGA3D */
3028
3029void cocoaViewDisplay(NativeNSViewRef pView)
3030{
3031 COCOA_LOG_FLOW(("cocoaViewDisplay: pView=%p\n", (void *)pView));
3032 NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
3033
3034#ifndef IN_VMSVGA3D
3035 DEBUG_WARN(("cocoaViewDisplay should never happen!\n"));
3036 DEBUG_MSG_1(("cocoaViewDisplay %p\n", (void *)pView));
3037#endif
3038 [(OverlayView *)pView swapFBO];
3039
3040 [pPool release];
3041 COCOA_LOG_FLOW(("cocoaViewDisplay: returns\n"));
3042}
3043
3044void cocoaViewSetPosition(NativeNSViewRef pView, NativeNSViewRef pParentView, int x, int y)
3045{
3046 COCOA_LOG_FLOW(("cocoaViewSetPosition: pView=%p pParentView=%p x=%d y=%d\n", (void *)pView, (void *)pParentView, x, y));
3047 NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
3048
3049 [(OverlayView *)pView vboxSetPos:NSMakePoint(x, y)];
3050
3051 [pPool release];
3052 COCOA_LOG_FLOW(("cocoaViewSetPosition: returns\n"));
3053}
3054
3055void cocoaViewSetSize(NativeNSViewRef pView, int cx, int cy)
3056{
3057 COCOA_LOG_FLOW(("cocoaViewSetSize: pView=%p cx=%d cy=%d\n", (void *)pView, cx, cy));
3058 NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
3059 OverlayView *pOverlayView = (OverlayView *)pView;
3060
3061 [pOverlayView vboxSetSize:NSMakeSize(cx, cy)];
3062
3063 [pPool release];
3064 COCOA_LOG_FLOW(("cocoaViewSetSize: returns\n"));
3065}
3066
3067#ifndef IN_VMSVGA3D
3068
3069typedef struct CR_RCD_GETGEOMETRY
3070{
3071 OverlayView *pView;
3072 NSRect rect;
3073} CR_RCD_GETGEOMETRY;
3074
3075static DECLCALLBACK(void) vboxRcdGetGeomerty(void *pvUser)
3076{
3077 CR_RCD_GETGEOMETRY *pGetGeometry = (CR_RCD_GETGEOMETRY *)pvUser;
3078 pGetGeometry->rect = [[pGetGeometry->pView window] frame];
3079 COCOA_LOG_FLOW(("vboxRcdGetGeomerty: (x,y)=(%d,%d) (cx,cy)=(%d,%d)\n", pGetGeometry->rect.origin.x, pGetGeometry->rect.origin.y,
3080 pGetGeometry->rect.size.width, pGetGeometry->rect.size.height));
3081}
3082
3083void cocoaViewGetGeometry(NativeNSViewRef pView, int *px, int *py, int *pcx, int *pcy)
3084{
3085 COCOA_LOG_FLOW(("cocoaViewGetGeometry: pView=%p px=%p py=%p pcx=%p pcy=%p\n",
3086 (void *)pView, (void *)px, (void *)py, (void *)pcx, (void *)pcy));
3087 NSAutoreleasePool *pPool;
3088 pPool = [[NSAutoreleasePool alloc] init];
3089
3090 /* make sure all tasks are run, to preserve the order */
3091 VBoxMainThreadTaskRunner *pRunner = [VBoxMainThreadTaskRunner globalInstance];
3092 [pRunner runTasksSyncIfPossible];
3093
3094 NSRect frame;
3095#ifndef IN_VMSVGA3D
3096 if (renderspuCalloutAvailable())
3097 {
3098 CR_RCD_GETGEOMETRY GetGeometry;
3099 GetGeometry.pView = (OverlayView *)pView;
3100 renderspuCalloutClient(vboxRcdGetGeomerty, &GetGeometry);
3101 frame = GetGeometry.rect;
3102 }
3103 else
3104#endif
3105 {
3106 DEBUG_MSG_NOT_VMSVGA3D(("no callout available on getGeometry\n"));
3107 frame = [[pView window] frame];
3108 }
3109
3110 *px = frame.origin.x;
3111 *py = frame.origin.y;
3112 *pcx = frame.size.width;
3113 *pcy = frame.size.height;
3114
3115 [pPool release];
3116 COCOA_LOG_FLOW(("cocoaViewGetGeometry: returns *px=%d, *py=%d, *pcx=%d, *pcy=%d\n", *px, *py, *pcx, *pcy));
3117}
3118
3119void cocoaViewPresentComposition(NativeNSViewRef pView, PCVBOXVR_SCR_COMPOSITOR_ENTRY pChangedEntry)
3120{
3121 COCOA_LOG_FLOW(("cocoaViewPresentComposition: pView=%p pChangedEntry=%p\n", (void *)pView, (void *)pChangedEntry));
3122 NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
3123 NSOpenGLContext *pCtx;
3124
3125# ifdef IN_VMSVGA3D
3126 Assert([(OverlayView *)pView glCtx]);
3127
3128# else
3129 /* The view may not necesserily have a GL context set. */
3130 pCtx = [(OverlayView *)pView glCtx];
3131 if (!pCtx)
3132 {
3133 ContextInfo *pCtxInfo = renderspuDefaultSharedContextAcquire();
3134 if (!pCtxInfo)
3135 {
3136 DEBUG_WARN(("renderspuDefaultSharedContextAcquire returned NULL"));
3137
3138 [pPool release];
3139 DEBUG_FUNC_LEAVE();
3140 return;
3141 }
3142
3143 pCtx = pCtxInfo->context;
3144
3145 [(OverlayView *)pView setGLCtx:pCtx];
3146 }
3147# endif
3148
3149 [(OverlayView *)pView presentComposition:pChangedEntry];
3150
3151 [pPool release];
3152 COCOA_LOG_FLOW(("cocoaViewPresentComposition: returns\n"));
3153}
3154
3155#endif /* !IN_VMSVGA3D */
3156
3157void cocoaViewMakeCurrentContext(NativeNSViewRef pView, NativeNSOpenGLContextRef pCtx)
3158{
3159 COCOA_LOG_FLOW(("cocoaViewMakeCurrentContext: pView=%p pCtx=%p\n", (void *)pView, (void *)pCtx));
3160 NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
3161
3162 if (pView)
3163 {
3164 [(OverlayView *)pView setGLCtx:pCtx];
3165 [(OverlayView *)pView makeCurrentFBO];
3166 }
3167 else
3168 {
3169#ifdef IN_VMSVGA3D
3170 /* Always flush before flush. glXMakeCurrent and wglMakeCurrent does this
3171 implicitly, seemingly NSOpenGLContext::makeCurrentContext doesn't. */
3172 if ([NSOpenGLContext currentContext] != nil)
3173 {
3174 DEBUG_CLEAR_GL_ERRORS();
3175 glFlush();
3176 DEBUG_CHECK_GL_ERROR("glFlush");
3177 }
3178#endif
3179 [NSOpenGLContext clearCurrentContext];
3180 }
3181
3182 [pPool release];
3183 COCOA_LOG_FLOW(("cocoaViewMakeCurrentContext: returns\n"));
3184}
3185
3186#ifndef IN_VMSVGA3D
3187
3188GLboolean cocoaViewNeedsEmptyPresent(NativeNSViewRef pView)
3189{
3190 COCOA_LOG_FLOW(("cocoaViewNeedsEmptyPresent: pView=%p\n", (void *)pView));
3191 NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
3192
3193 GLboolean fNeedsPresent = [(OverlayView *)pView vboxNeedsEmptyPresent];
3194
3195 [pPool release];
3196 COCOA_LOG_FLOW(("cocoaViewNeedsEmptyPresent: returns %d\n", fNeedsPresent));
3197 return fNeedsPresent;
3198}
3199
3200void cocoaViewSetVisibleRegion(NativeNSViewRef pView, GLint cRects, const GLint *paRects)
3201{
3202 COCOA_LOG_FLOW(("cocoaViewSetVisibleRegion: pView=%p cRects=%d paRects=%p)\n", (void *)pView, cRects, (void const *)paRects));
3203 NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
3204
3205 [(OverlayView *)pView setVisibleRegions:cRects paRects:paRects];
3206
3207 [pPool release];
3208 COCOA_LOG_FLOW(("cocoaViewSetVisibleRegion: returns\n"));
3209}
3210
3211#endif /* IN_VMSVGA3D */
3212
3213#ifdef IN_VMSVGA3D
3214/*
3215 * VMSVGA3D interface.
3216 */
3217
3218VMSVGA3DCOCOA_DECL(bool) vmsvga3dCocoaCreateViewAndContext(NativeNSViewRef *ppView, NativeNSOpenGLContextRef *ppCtx,
3219 NativeNSViewRef pParentView, uint32_t cx, uint32_t cy,
3220 NativeNSOpenGLContextRef pSharedCtx, bool fOtherProfile)
3221{
3222 NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
3223 GLbitfield fVisParams = CR_ALPHA_BIT | CR_DEPTH_BIT | CR_DOUBLE_BIT | (fOtherProfile ? VMSVGA3D_NON_DEFAULT_PROFILE_BIT : 0);
3224 bool fRc = false;
3225
3226 cocoaGLCtxCreate(ppCtx, fVisParams, pSharedCtx);
3227 if (*ppCtx)
3228 {
3229 cocoaViewCreate(ppView, NULL, pParentView, fVisParams);
3230 if (*ppView)
3231 {
3232 cocoaViewSetSize(*ppView, cx, cy);
3233 [(OverlayView *)*ppView setGLCtx: *ppCtx];
3234 fRc = true;
3235 }
3236 else
3237 [*ppCtx release];
3238 }
3239
3240 [pPool release];
3241 return fRc;
3242}
3243
3244VMSVGA3DCOCOA_DECL(void) vmsvga3dCocoaDestroyViewAndContext(NativeNSViewRef pView, NativeNSOpenGLContextRef pCtx)
3245{
3246 cocoaGLCtxDestroy(pCtx);
3247 cocoaViewDestroy(pView);
3248}
3249
3250VMSVGA3DCOCOA_DECL(void) vmsvga3dCocoaViewSetPosition(NativeNSViewRef pView, NativeNSViewRef pParentView, int x, int y)
3251{
3252 cocoaViewSetPosition(pView, pParentView, x, y);
3253}
3254
3255VMSVGA3DCOCOA_DECL(void) vmsvga3dCocoaViewSetSize(NativeNSViewRef pView, int w, int h)
3256{
3257 cocoaViewSetSize(pView, w, h);
3258}
3259
3260VMSVGA3DCOCOA_DECL(void) vmsvga3dCocoaViewMakeCurrentContext(NativeNSViewRef pView, NativeNSOpenGLContextRef pCtx)
3261{
3262 Assert(!pView || [(OverlayView *)pView glCtx] == pCtx || [(OverlayView *)pView glCtx] == nil);
3263 cocoaViewMakeCurrentContext(pView, pCtx);
3264}
3265
3266VMSVGA3DCOCOA_DECL(void) vmsvga3dCocoaSwapBuffers(NativeNSViewRef pView, NativeNSOpenGLContextRef pCtx)
3267{
3268# if 1
3269 Assert([(OverlayView *)pView glCtx] == pCtx);
3270 Assert([pCtx view] == pView);
3271 cocoaViewDisplay(pView);
3272# else
3273 DEBUG_FUNC_ENTER();
3274 NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
3275
3276 Assert([(OverlayView *)pView glCtx] == pCtx);
3277 Assert([pCtx view] == pView);
3278
3279 [pCtx flushBuffer];
3280
3281 [pPool release];
3282 DEBUG_FUNC_LEAVE();
3283# endif
3284}
3285
3286#endif /* IN_VMSVGA3D */
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette