void
renderspu_SystemWindowSize(WindowInfo *window, GLint w, GLint h)
{
CRASSERT(window);
CRASSERT(window->window);
OSStatus status = noErr;
/* Send a event to the main thread, cause some function of Carbon aren't
* thread safe */
EventRef evt;
status = CreateEvent(NULL, kEventClassVBox, kEventVBoxResizeWindow, 0, kEventAttributeNone, &evt);
CHECK_CARBON_RC_RETURN_VOID (status, "Render SPU (renderspu_SystemWindowSize): CreateEvent Failed ");
status = SetEventParameter(evt, kEventParamWindowRef, typeWindowRef, sizeof(window->window), &window->window);
CHECK_CARBON_RC_RETURN_VOID (status, "Render SPU (renderspu_SystemWindowSize): SetEventParameter Failed");
HISize s = CGSizeMake (w, h);
status = SetEventParameter(evt, kEventParamDimensions, typeHISize, sizeof (s), &s);
CHECK_CARBON_RC_RETURN_VOID (status, "Render SPU (renderspu_SystemWindowSize): SetEventParameter Failed");
status = SetEventParameter(evt, kEventParamUserData, typeVoidPtr, sizeof (window), &window);
CHECK_CARBON_RC_RETURN_VOID (status, "Render SPU (renderspu_SystemWindowSize): SetEventParameter Failed");
status = PostEventToQueue(GetMainEventQueue(), evt, kEventPriorityStandard);
CHECK_CARBON_RC_RETURN_VOID (status, "Render SPU (renderspu_SystemWindowSize): SendEventToEventTarget Failed");
DEBUG_MSG_POETZSCH (("Size %d visible %d\n", window->BltInfo.Base.id, IsWindowVisible (window->window)));
/* save the new size */
window->BltInfo.width = w;
window->BltInfo.height = h;
}
bool
OSXEventQueueBuffer::addEvent(UInt32 dataID)
{
EventRef event;
OSStatus error = CreateEvent(
kCFAllocatorDefault,
'Syne',
dataID,
0,
kEventAttributeNone,
&event);
if (error == noErr) {
assert(m_carbonEventQueue != NULL);
error = PostEventToQueue(
m_carbonEventQueue,
event,
kEventPriorityStandard);
ReleaseEvent(event);
}
return (error == noErr);
}
void
renderspu_SystemWindowPosition(WindowInfo *window,
GLint x, GLint y)
{
CRASSERT(window);
CRASSERT(window->window);
OSStatus status = noErr;
/* Send a event to the main thread, cause some function of Carbon aren't
* thread safe */
EventRef evt;
status = CreateEvent(NULL, kEventClassVBox, kEventVBoxMoveWindow, 0, kEventAttributeNone, &evt);
CHECK_CARBON_RC_RETURN_VOID (status, "Render SPU (renderspu_SystemWindowPosition): CreateEvent Failed");
status = SetEventParameter(evt, kEventParamWindowRef, typeWindowRef, sizeof(window->window), &window->window);
CHECK_CARBON_RC_RETURN_VOID (status, "Render SPU (renderspu_SystemWindowPosition): SetEventParameter Failed");
HIPoint p = CGPointMake (x, y);
status = SetEventParameter(evt, kEventParamOrigin, typeHIPoint, sizeof (p), &p);
CHECK_CARBON_RC_RETURN_VOID (status, "Render SPU (renderspu_SystemWindowPosition): SetEventParameter Failed");
status = SetEventParameter(evt, kEventParamUserData, typeVoidPtr, sizeof (window), &window);
CHECK_CARBON_RC_RETURN_VOID (status, "Render SPU (renderspu_SystemWindowPosition): SetEventParameter Failed");
status = PostEventToQueue(GetMainEventQueue(), evt, kEventPriorityStandard);
CHECK_CARBON_RC_RETURN_VOID (status, "Render SPU (renderspu_SystemWindowPosition): PostEventToQueue Failed");
/* save the new pos */
window->x = x;
window->y = y;
}
void PostCustomEvent(DWORD id, void *data, DWORD size)
{
EventRef e;
CreateEvent(NULL,'blah','blah',0,0,&e);
SetEventParameter(e,'evid',0,sizeof(id),&id);
SetEventParameter(e,'data',0,size,data);
PostEventToQueue(GetMainEventQueue(),e,kEventPriorityHigh);
ReleaseEvent(e);
}
OP_STATUS MacOpMessageLoop::PostMessage(UINT32 msg, void *data, UINT32 param1, UINT32 param2)
{
// if(!mh)
// {
// return OpStatus::OK;
// }
EventRef operaEvent = NULL;
OSStatus err = CreateEvent(NULL, kEventClassOperaPlatformIndependent, kEventOperaMessage,
0, kEventAttributeUserEvent,
&operaEvent);
if(err == noErr)
{
err = SetEventParameter(operaEvent,
kEventParamOperaMessage,
typeInteger,
sizeof(UINT32),
&msg);
err |= SetEventParameter(operaEvent,
kEventParamOperaMessageData,
typeInteger,
sizeof(void *),
&data);
err |= SetEventParameter(operaEvent,
kEventParamOperaMessageParam1,
typeInteger,
sizeof(UINT32),
¶m1);
err |= SetEventParameter(operaEvent,
kEventParamOperaMessageParam2,
typeInteger,
sizeof(UINT32),
¶m2);
if (err == noErr)
{
EventPriority priority;
if (msg >= MSG_LOW_PRI_START && msg <= MSG_LOW_PRI_END) {
priority = kEventPriorityLow;
} else {
priority = kEventPriorityStandard;
}
PostEventToQueue(gMainEventQueue, operaEvent, priority);
}
}
ReleaseEvent(operaEvent);
return OpStatus::OK;
}
void Shell::RequestExit()
{
EventRef event;
OSStatus result = CreateEvent(NULL, // default allocator
kEventClassApplication,
kEventAppQuit,
0,
kEventAttributeNone,
&event);
if (result == noErr)
PostEventToQueue(GetMainEventQueue(), event, kEventPriorityStandard);
}
/* Either show or hide the render SPU's window. */
void
renderspu_SystemShowWindow(WindowInfo *window, GLboolean showIt)
{
CRASSERT(window);
CRASSERT(window->window);
if (!IsValidWindowPtr(window->window))
return;
if(showIt)
{
/* Force moving the win to the right position before we show it */
renderspu_SystemWindowPosition (window, window->x, window->y);
OSStatus status = noErr;
/* Send a event to the main thread, cause some function of Carbon
* aren't thread safe */
EventRef evt;
status = CreateEvent(NULL, kEventClassVBox, kEventVBoxShowWindow, 0, kEventAttributeNone, &evt);
CHECK_CARBON_RC_RETURN_VOID (status, "Render SPU (renderspu_SystemShowWindow): CreateEvent Failed");
status = SetEventParameter(evt, kEventParamWindowRef, typeWindowRef, sizeof (window->window), &window->window);
CHECK_CARBON_RC_RETURN_VOID (status, "Render SPU (renderspu_SystemShowWindow): SetEventParameter Failed");
status = SetEventParameter(evt, kEventParamUserData, typeVoidPtr, sizeof (window), &window);
CHECK_CARBON_RC_RETURN_VOID (status, "Render SPU (renderspu_SystemWindowShow): SetEventParameter Failed");
//status = SendEventToEventTarget (evt, GetWindowEventTarget (HIViewGetWindow ((HIViewRef)render_spu_parent_window_id)));
status = PostEventToQueue(GetMainEventQueue(), evt, kEventPriorityStandard);
CHECK_CARBON_RC_RETURN_VOID (status, "Render SPU (renderspu_SystemShowWindow): PostEventToQueue Failed");
}
else
{
EventRef evt;
OSStatus status = CreateEvent(NULL, kEventClassVBox, kEventVBoxHideWindow, 0, kEventAttributeNone, &evt);
CHECK_CARBON_RC_RETURN_VOID (status, "Render SPU (renderspu_SystemShowWindow): CreateEvent Failed");
status = SetEventParameter(evt, kEventParamWindowRef, typeWindowRef, sizeof (window->window), &window->window);
CHECK_CARBON_RC_RETURN_VOID (status, "Render SPU (renderspu_SystemShowWindow): SetEventParameter Failed");
status = PostEventToQueue(GetMainEventQueue(), evt, kEventPriorityStandard);
CHECK_CARBON_RC_RETURN_VOID (status, "Render SPU (renderspu_SystemShowWindow): PostEventToQueue Failed");
}
}
void TabbedWindow::Terminate( void )
{
EventQueueRef eventQueue = GetMainEventQueue();
EventRef event;
OSStatus status;
status = CreateEvent( kCFAllocatorDefault, kEventClassApplication, kEventAppQuit,
GetCurrentEventTime(), kEventAttributeNone, &event );
if ( status == noErr )
status = PostEventToQueue( eventQueue, event, kEventPriorityStandard );
ReleaseEvent( event );
}
void
temp_run_application_event_loop(void)
{
OSStatus err;
EventRef dummy_event;
EventHandlerRef install_handler;
EventTypeSpec event_spec = { 'KWIN', 'KWIN' };
// Create UPP for dummy_event_handler and for quit_event_handler
err = noErr;
dummy_event = 0;
g_dummy_event_handler_UPP = NewEventHandlerUPP(dummy_event_handler);
g_quit_handler_UPP = NewEventHandlerUPP(quit_event_handler);
if((g_dummy_event_handler_UPP == 0) || (g_quit_handler_UPP == 0)) {
err = memFullErr;
}
if(err == noErr) {
err = InstallApplicationEventHandler(g_dummy_event_handler_UPP,
1, &event_spec, 0, &install_handler);
if(err == noErr) {
err = MacCreateEvent(NULL, 'KWIN', 'KWIN',
GetCurrentEventTime(), kEventAttributeNone,
&dummy_event);
if(err == noErr) {
err = PostEventToQueue(GetMainEventQueue(),
dummy_event, kEventPriorityHigh);
}
if(err == noErr) {
RunApplicationEventLoop();
}
(void)RemoveEventHandler(install_handler);
}
}
if(dummy_event != NULL) {
ReleaseEvent(dummy_event);
}
}
void
CreateAddItemEvent()
{
EventRef event;
OSStatus err;
err = MacCreateEvent(NULL, kEventClassApplication, kAddItemToBrowser, GetCurrentEventTime(), kEventAttributeNone, &event);
if (err == noErr)
{
err = PostEventToQueue(GetMainEventQueue(), event, kEventPriorityHigh);
if (err != noErr)
{
gEventHandled = true;
}
ReleaseEvent(event);
}
else
{
gEventHandled = true;
}
}
static void post_skmacevent()
{
EventRef ref;
OSStatus status = CreateEvent(nil, SK_MacEventClass, SK_MacEventKind, 0, 0, &ref);
SkASSERT(status == noErr);
#if 0
status = SetEventParameter(ref, SK_MacEventParamName, SK_MacEventParamName, sizeof(evt), &evt);
SkASSERT(status == noErr);
status = SetEventParameter(ref, SK_MacEventSinkIDParamName, SK_MacEventSinkIDParamName, sizeof(sinkID), &sinkID);
SkASSERT(status == noErr);
#endif
EventTargetRef target = gEventTarget;
SetEventParameter(ref, kEventParamPostTarget, typeEventTargetRef, sizeof(target), &target);
SkASSERT(status == noErr);
status = PostEventToQueue(gCurrEventQ, ref, kEventPriorityStandard);
SkASSERT(status == noErr);
ReleaseEvent(ref);
}
OSStatus PostKQueueEvent( struct kevent *kevp )
{
OSStatus err = noErr;
EventRef event = NULL;
MPControlInfo *mpControl = kevp->udata;
err = CreateEvent( NULL, kEventClassMP, kEventKQueue, GetCurrentEventTime(), kEventAttributeNone, &event );
if ( err != noErr ) goto Bail;
err = SetEventParameter( event, kEventParamDirectObject, typeKEvent, sizeof(struct kevent), kevp ); // Send the kevent
if ( err != noErr ) goto Bail;
err = SetEventParameter( event, kEventParamPostTarget, typeEventTargetRef, sizeof(void*), &mpControl->eventTarget ); // Target the date control
if ( err != noErr ) goto Bail;
err = SetEventParameter( event, kEventParamControlRef, typeControlRef, sizeof(ControlRef), &mpControl->dateControl ); // ControlRef to update
if ( err != noErr ) goto Bail;
err = PostEventToQueue( GetMainEventQueue(), event, kEventPriorityStandard ); // Post the event to the main event queue on the main thread
Bail:
if ( event != NULL ) (void) ReleaseEvent( event );
return( err );
}
OSStatus sendDone(void)
{
OSStatus result;
EventRef evt;
result = CreateEvent(
NULL,
kEventClassCustom,
kEventCustomDone,
0,
kEventAttributeNone,
&evt);
// This event needs to be targeted at the window so it goes to the window's handler.
if(result == noErr)
{
EventTargetRef target = GetWindowEventTarget(gWindow);
result = SetEventParameter (
evt,
kEventParamPostTarget,
typeEventTargetRef,
sizeof(target),
&target);
}
if(result == noErr)
{
// Send the event
PostEventToQueue(
GetMainEventQueue(),
evt,
kEventPriorityStandard);
}
return(result);
}
void
renderspu_SystemSwapBuffers(WindowInfo *window, GLint flags)
{
CRASSERT(window);
CRASSERT(window->window);
ContextInfo *context = renderspuGetWindowContext(window);
if(!context)
crError("Render SPU (renderspu_SystemSwapBuffers): SwapBuffers got a null context from the window");
RTSemFastMutexRequest(render_spu.syncMutex);
// DEBUG_MSG_POETZSCH (("Swapped %d context %x visible: %d\n", window->BltInfo.Base.id, context->context, IsWindowVisible (window->window)));
if (context->visual &&
context->visual->visAttribs & CR_DOUBLE_BIT)
render_spu.ws.aglSwapBuffers(context->context);
else
glFlush();
RTSemFastMutexRelease(render_spu.syncMutex);
/* This method seems called very often. To prevent the dock using all free
* resources we update the dock only two times per second. */
uint64_t curTS = RTTimeMilliTS();
if ((curTS - render_spu.uiDockUpdateTS) > 500)
{
OSStatus status = noErr;
/* Send a event to the main thread, cause some function of Carbon aren't
* thread safe */
EventRef evt;
status = CreateEvent(NULL, kEventClassVBox, kEventVBoxUpdateDock, 0, kEventAttributeNone, &evt);
CHECK_CARBON_RC_RETURN_VOID (status, "Render SPU (renderspu_SystemSwapBuffers): CreateEvent Failed");
status = PostEventToQueue(GetMainEventQueue(), evt, kEventPriorityStandard);
CHECK_CARBON_RC_RETURN_VOID (status, "Render SPU (renderspu_SystemSwapBuffers): PostEventToQueue Failed");
render_spu.uiDockUpdateTS = curTS;
}
}
void
renderspu_SystemDestroyWindow(WindowInfo *window)
{
CRASSERT(window);
CRASSERT(window->visual);
if(!window->nativeWindow)
{
EventRef evt;
OSStatus status = CreateEvent(NULL, kEventClassVBox, kEventVBoxDisposeWindow, 0, kEventAttributeNone, &evt);
CHECK_CARBON_RC_RETURN_VOID (status, "Render SPU (renderspu_SystemDestroyWindow): CreateEvent Failed");
status = SetEventParameter(evt, kEventParamWindowRef, typeWindowRef, sizeof (window->window), &window->window);
CHECK_CARBON_RC_RETURN_VOID (status, "Render SPU (renderspu_SystemDestroyWindow): SetEventParameter Failed");
status = PostEventToQueue(GetMainEventQueue(), evt, kEventPriorityStandard);
CHECK_CARBON_RC_RETURN_VOID (status, "Render SPU (renderspu_SystemDestroyWindow): PostEventToQueue Failed");
}
/* Delete the dummy context */
if(window->dummyContext)
{
render_spu.ws.aglSetDrawable(window->dummyContext, NULL);
render_spu.ws.aglDestroyContext(window->dummyContext);
window->dummyContext = NULL;
}
/* Reset some values */
window->bufferName = -1;
window->visual = NULL;
window->window = NULL;
if (window->hVisibleRegion)
{
DisposeRgn(window->hVisibleRegion);
window->hVisibleRegion = 0;
}
}
/**
ui_sync : callb:(void -> void) -> void
<doc>
Queue a method call [callb] to be executed by the main thread while running the UI event
loop. This can be used to perform UI updates in the UI thread using results processed by
another thread.
</doc>
**/
static value ui_sync( value f ) {
value *r;
val_check_function(f,0);
r = alloc_root(1);
*r = f;
# if defined(NEKO_WINDOWS)
while( !PostMessage(data.wnd,WM_SYNC_CALL,0,(LPARAM)r) )
Sleep(100);
# elif defined(NEKO_MAC)
EventRef e;
CreateEvent(NULL,UIEvent,eCall,GetCurrentEventTime(),kEventAttributeUserEvent,&e);
SetEventParameter(e,pFunc,typeVoidPtr,sizeof(void*),&r);
PostEventToQueue(GetMainEventQueue(),e,kEventPriorityStandard);
ReleaseEvent(e);
# elif defined(NEKO_LINUX)
// the lock should not be needed because GTK is MT-safe
// however the GTK lock mechanism is a LOT slower than
// using a pthread_mutex
pthread_mutex_lock(&data.lock);
gtk_timeout_add( 0, onSyncCall, (gpointer)r );
pthread_mutex_unlock(&data.lock);
# endif
return val_null;
}
void MessagePump::postWakeup()
{
if( _receiverQueue )
PostEventToQueue( _receiverQueue, _wakeupEvent, kEventPriorityStandard);
}
OSStatus sendProgress(long cur, long max, CFStringRef text = NULL)
{
OSStatus result;
EventRef evt;
result = CreateEvent(
NULL,
kEventClassCustom,
kEventCustomProgress,
0,
kEventAttributeNone,
&evt);
// This event needs to be targeted at the window so it goes to the window's handler.
if(result == noErr)
{
EventTargetRef target = GetWindowEventTarget(gWindow);
result = SetEventParameter (
evt,
kEventParamPostTarget,
typeEventTargetRef,
sizeof(target),
&target);
}
if(result == noErr)
{
result = SetEventParameter (
evt,
kEventParamCustomCurValue,
typeLongInteger,
sizeof(cur),
&cur);
}
if(result == noErr)
{
result = SetEventParameter (
evt,
kEventParamCustomMaxValue,
typeLongInteger,
sizeof(max),
&max);
}
if(result == noErr)
{
if(text != NULL)
{
result = SetEventParameter (
evt,
kEventParamCustomText,
typeCFStringRef,
sizeof(text),
&text);
}
}
if(result == noErr)
{
// Send the event
PostEventToQueue(
GetMainEventQueue(),
evt,
kEventPriorityStandard);
}
return(result);
}
bool
QvisApplication::macEventFilter(EventHandlerCallRef er, EventRef event)
{
UInt32 ekind = GetEventKind(event), eclass = GetEventClass(event);
bool ret = false;
switch(eclass)
{
case kEventClassWindow:
{ // new scope
//qDebug("macEventFilter: kEventClassWindow");
WindowRef wid;
GetEventParameter(event, kEventParamDirectObject, typeWindowRef, NULL,
sizeof(WindowRef), NULL, &wid);
QWidget *widget = QWidget::find((WId)wid);
if(widget)
{
if(ekind == kEventWindowShown)
{
QString mainWindowName(QString("VisIt ") + QString(VISIT_VERSION));
if(mainWindowName == QString(widget->windowTitle()))
emit showApplication();
//qDebug("ekind = kEventWindowShown");
}
else if(ekind == kEventWindowHidden)
{
QString mainWindowName(QString("VisIt ") + QString(VISIT_VERSION));
if(mainWindowName == QString(widget->windowTitle()))
emit hideApplication();
//qDebug("ekind = kEventWindowHidden");
}
#ifdef PRINT_CARBON_EVENTS
else if(ekind == kEventWindowClose)
qDebug("\tkEventWindowClose");
else if(ekind == kEventWindowDrawContent)
qDebug("\tkEventWindowDrawContent");
else if(ekind == kEventWindowBoundsChanged)
qDebug("\tkEventWindowBoundsChanged");
#endif
}
break;
}
// Trap for other Carbon events.
case kEventClassApplication:
if(ekind == kEventAppDeactivated)
{
//qDebug("\tkEventAppDeactivated");
// We're deactivating the application so the next time we activate it
// via the menu, we need to make it active.
needToMakeActive = true;
}
else if(ekind == kEventAppActivated)
{
//qDebug("\tkEventAppActivated");
needToMakeActive = false;
}
#ifdef PRINT_CARBON_EVENTS
else if(ekind == kEventAppQuit)
qDebug("\tkEventAppQuit");
else if(ekind == kEventAppLaunchNotification)
qDebug("\tkEventAppLaunchNotification");
else if(ekind == kEventAppLaunched)
qDebug("\tkEventAppLaunched");
else if(ekind == kEventAppTerminated)
qDebug("\tkEventAppTerminated");
else if(ekind == kEventAppFrontSwitched)
qDebug("\tkEventAppFrontSwitched");
else if(ekind == kEventAppFocusMenuBar)
qDebug("\tkEventAppFocusMenuBar");
else if(ekind == kEventAppFocusNextDocumentWindow)
qDebug("\tkEventAppFocusNextDocumentWindow");
else if(ekind == kEventAppFocusNextFloatingWindow)
qDebug("\tkEventAppFocusNextFloatingWindow");
else if(ekind == kEventAppFocusToolbar)
qDebug("\tkEventAppFocusToolbar");
else if(ekind == kEventAppFocusDrawer)
qDebug("\tkEventAppFocusDrawer");
else if(ekind == kEventAppGetDockTileMenu)
qDebug("\tkEventAppGetDockTileMenu");
else if(ekind == kEventAppIsEventInInstantMouser)
qDebug("\tkEventAppIsEventInInstantMouser");
else if(ekind == kEventAppHidden)
qDebug("\tkEventAppHidden");
else if(ekind == kEventAppShown)
qDebug("\tkEventAppShown");
else if(ekind == kEventAppSystemUIModeChanged)
qDebug("\tkEventAppSystemUIModeChanged");
else if(ekind == kEventAppAvailableWindowBoundsChanged)
qDebug("\tkEventAppAvailableWindowBoundsChanged");
else if(ekind == kEventAppActiveWindowChanged)
qDebug("\tkEventAppActiveWindowChanged");
break;
case kEventClassCommand:
qDebug("kEventClassCommand");
break;
case kEventClassControl:
qDebug("kEventClassControl");
break;
case kEventClassKeyboard:
qDebug("kEventClassKeyboard");
break;
#endif
case kEventClassMenu:
#ifdef PRINT_CARBON_EVENTS
qDebug("kEventClassMenu");
if(ekind == kEventMenuBeginTracking)
qDebug("\tkEventMenuBeginTracking");
else if(ekind == kEventMenuEndTracking)
qDebug("\tkEventMenuEndTracking");
else if(ekind == kEventMenuChangeTrackingMode)
qDebug("\tkEventMenuChangeTrackingMode");
else if(ekind == kEventMenuClosed)
qDebug("\tkEventMenuClosed");
else if(ekind == kEventMenuTargetItem)
qDebug("\tkEventMenuTargetItem");
else if(ekind == kEventMenuMatchKey)
qDebug("\tkEventMenuMatchKey");
else if(ekind == kEventMenuEnableItems)
qDebug("\tkEventMenuEnableItems");
else
#endif
if(ekind == kEventMenuOpening)
{
//qDebug("\tkEventMenuOpening");
if(needToMakeActive)
{
// If we got here then it's from making the menu active after having
// left the application for the viewer. In this case, we pull some
// tricks on Qt to make it execute the AppActivated event before the
// current event.
needToMakeActive = false;
// Inject a Carbon event to make the application active.
CreateEvent(NULL, kEventClassApplication, kEventAppActivated, GetCurrentEventTime(),
NULL, &request_make_app_active);
PostEventToQueue(GetCurrentEventQueue(), request_make_app_active, kEventPriorityHigh);
// Inject a directive to exit a sub-event loop that we'll be creating.
QTimer::singleShot(10, this, SLOT(exitTheLoop()));
// Start a new event loop to make the app active and then quit
// the sub-event loop.
eventLoop = new QEventLoop(0);
eventLoop->exec();
}
}
break;
#ifdef PRINT_CARBON_EVENTS
case kEventClassMouse:
qDebug("kEventClassMouse");
break;
#endif
}
return ret;
}
GLboolean
renderspu_SystemVBoxCreateWindow(VisualInfo *visual, GLboolean showIt,
WindowInfo *window)
{
CRASSERT(visual);
CRASSERT(window);
WindowAttributes winAttr = kWindowNoShadowAttribute | kWindowCompositingAttribute | kWindowIgnoreClicksAttribute | kWindowStandardHandlerAttribute | kWindowLiveResizeAttribute;
WindowClass winClass = kOverlayWindowClass;
Rect windowRect;
OSStatus status = noErr;
window->visual = visual;
window->nativeWindow = NULL;
if(window->window && IsValidWindowPtr(window->window))
{
EventRef evt;
status = CreateEvent(NULL, kEventClassVBox, kEventVBoxDisposeWindow, 0, kEventAttributeNone, &evt);
CHECK_CARBON_RC_RETURN (status, "Render SPU (renderspu_SystemVBoxCreateWindow): CreateEvent Failed", false);
status = SetEventParameter(evt, kEventParamWindowRef, typeWindowRef, sizeof (window->window), &window->window);
CHECK_CARBON_RC_RETURN (status, "Render SPU (renderspu_SystemVBoxCreateWindow): SetEventParameter Failed", false);
status = PostEventToQueue(GetMainEventQueue(), evt, kEventPriorityStandard);
CHECK_CARBON_RC_RETURN (status, "Render SPU (renderspu_SystemVBoxCreateWindow): PostEventToQueue Failed", false);
}
windowRect.left = window->x;
windowRect.top = window->y;
windowRect.right = window->x + window->BltInfo.width;
windowRect.bottom = window->y + window->BltInfo.height;
status = CreateNewWindow(winClass, winAttr, &windowRect, &window->window);
CHECK_CARBON_RC_RETURN (status, "Render SPU (renderspu_SystemVBoxCreateWindow): CreateNewWindow Failed", GL_FALSE);
/* We set a title for debugging purposes */
CFStringRef title_string;
title_string = CFStringCreateWithCStringNoCopy(NULL, window->title,
kCFStringEncodingMacRoman, NULL);
SetWindowTitleWithCFString(window->BltInfo.window, title_string);
CFRelease(title_string);
/* The parent has to be in its own group */
WindowRef parent = NULL;
if (render_spu_parent_window_id)
{
parent = HIViewGetWindow ((HIViewRef)render_spu_parent_window_id);
SetWindowGroup (parent, render_spu.pParentGroup);
}
/* Add the new window to the master group */
SetWindowGroup(window->window, render_spu.pMasterGroup);
/* This will be initialized on the first attempt to attach the global
* context to this new window */
window->bufferName = -1;
window->dummyContext = NULL;
window->hVisibleRegion = 0;
if(showIt)
renderspu_SystemShowWindow(window, GL_TRUE);
crDebug("Render SPU (renderspu_SystemVBoxCreateWindow): actual window (x, y, width, height): %d, %d, %d, %d",
window->x, window->y, window->BltInfo.width, window->BltInfo.height);
return GL_TRUE;
}
