void
Tk_MacOSXSetupTkNotifier()
{
ThreadSpecificData *tsdPtr = Tcl_GetThreadData(&dataKey,
sizeof(ThreadSpecificData));
if (!tsdPtr->initialized) {
/* HACK ALERT: There is a bug in Jaguar where when it goes to make
* the event queue for the Main Event Loop, it stores the Current
* event loop rather than the Main Event Loop in the Queue structure.
* So we have to make sure that the Main Event Queue gets set up on
* the main thread. Calling GetMainEventQueue will force this to
* happen.
*/
GetMainEventQueue();
tsdPtr->initialized = 1;
/* Install Carbon events event source in main event loop thread. */
if (GetCurrentEventLoop() == GetMainEventLoop()) {
if (!pthread_main_np()) {
/*
* Panic if the Carbon main event loop thread (i.e. the
* thread where HIToolbox was first loaded) is not the
* main application thread, as Carbon does not support
* this properly.
*/
Tcl_Panic("Tk_MacOSXSetupTkNotifier: %s",
"first [load] of TkAqua has to occur in the main thread!");
}
Tcl_CreateEventSource(CarbonEventsSetupProc,
CarbonEventsCheckProc, GetMainEventQueue());
TkCreateExitHandler(TkMacOSXNotifyExitHandler, NULL);
}
}
}
bool QEventDispatcherMac::unregisterTimer(int id)
{
#ifndef QT_NO_DEBUG
if (id < 1) {
qWarning("QEventDispatcherUNIX::unregisterTimer: invalid argument");
return false;
} else if (thread() != QThread::currentThread()) {
qWarning("QObject::killTimer: timers cannot be stopped from another thread");
return false;
}
#endif
Q_D(QEventDispatcherMac);
if(!d->macTimerList || id <= 0)
return false; // not init'd or invalid timer
for (int i = 0; i < d->macTimerList->size(); ++i) {
const MacTimerInfo &t = d->macTimerList->at(i);
if (t.id == id) {
if (t.mac_timer) {
RemoveEventLoopTimer(t.mac_timer);
if (t.pending) {
EventComparatorUPP fnc = NewEventComparatorUPP(find_timer_event);
FlushSpecificEventsFromQueue(GetMainEventQueue(), fnc, (void *)&t);
DisposeEventComparatorUPP(fnc);
}
} else {
d->zero_timer_count--;
}
d->macTimerList->removeAt(i);
return true;
}
}
return false;
}
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;
}
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;
}
// Is a message/event pending?
bool wxApp::Pending()
{
// without the receive event (with pull param = false ) nothing is ever reported
EventRef theEvent;
ReceiveNextEvent (0, NULL, kEventDurationNoWait, false, &theEvent);
return GetNumEventsInQueue( GetMainEventQueue() ) > 0 ;
}
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);
}
void MessagePump::_initReceiverQueue()
{
if( !_receiverQueue )
{
_receiverQueue = GetCurrentEventQueue();
_needGlobalLock = ( _receiverQueue == GetMainEventQueue( ));
EQASSERT( _receiverQueue );
}
EQASSERTINFO( _receiverQueue == GetCurrentEventQueue(),
"MessagePump::dispatch() called from two different threads" );
}
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 );
}
int
TkMacOSXCountAndProcessMacEvents()
{
EventQueueRef qPtr;
int eventCount;
qPtr = GetMainEventQueue();
eventCount = GetNumEventsInQueue(qPtr);
if (eventCount) {
int n, err;
for (n = 0, err = 0;n<eventCount && !err;n++) {
err = ReceiveAndProcessEvent();
}
}
return eventCount;
}
bool
COSXEventQueueBuffer::addEvent(UInt32 dataID)
{
EventRef event;
OSStatus error = CreateEvent(
kCFAllocatorDefault,
'Syne',
dataID,
0,
kEventAttributeNone,
&event);
if (error == noErr) {
error = PostEventToQueue(GetMainEventQueue(), event,
kEventPriorityStandard);
ReleaseEvent(event);
}
return (error == noErr);
}
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);
}
}
bool QEventDispatcherMac::unregisterTimers(QObject *obj)
{
#ifndef QT_NO_DEBUG
if (!obj) {
qWarning("QEventDispatcherUNIX::unregisterTimers: invalid argument");
return false;
} else if (obj->thread() != thread() || thread() != QThread::currentThread()) {
qWarning("QObject::killTimers: timers cannot be stopped from another thread");
return false;
}
#endif
Q_D(QEventDispatcherMac);
if(!d->macTimerList) // not initialized
return false;
MacTimerList removes;
for (int i = 0; i < d->macTimerList->size(); ++i) {
const MacTimerInfo &t = d->macTimerList->at(i);
if (t.obj == obj) {
if (t.mac_timer) {
RemoveEventLoopTimer(t.mac_timer);
if (t.pending) {
EventComparatorUPP fnc = NewEventComparatorUPP(find_timer_event);
FlushSpecificEventsFromQueue(GetMainEventQueue(), fnc, (void *)&t);
DisposeEventComparatorUPP(fnc);
}
} else {
d->zero_timer_count--;
}
removes += t;
}
}
for (MacTimerList::Iterator it = removes.begin(); it != removes.end(); ++it) {
for (int i = 0; i < d->macTimerList->size(); ++i) {
const MacTimerInfo &info = d->macTimerList->at(i);
if (info.id == (*it).id)
d->macTimerList->removeAt(i);
}
}
return true;
}
QEventDispatcherMac::~QEventDispatcherMac()
{
Q_D(QEventDispatcherMac);
//timer cleanup
d->zero_timer_count = 0;
if(d->macTimerList) {
for (int i = 0; i < d->macTimerList->size(); ++i) {
const MacTimerInfo &t = d->macTimerList->at(i);
if (t.mac_timer) {
RemoveEventLoopTimer(t.mac_timer);
if (t.pending) {
EventComparatorUPP fnc = NewEventComparatorUPP(find_timer_event);
FlushSpecificEventsFromQueue(GetMainEventQueue(), fnc, (void *)&t);
DisposeEventComparatorUPP(fnc);
}
}
}
delete d->macTimerList;
d->macTimerList = 0;
}
if(timerUPP) {
DisposeEventLoopTimerUPP(timerUPP);
timerUPP = 0;
}
// Remove CFSockets from the runloop.
for (MacSocketHash::ConstIterator it = d->macSockets.constBegin(); it != d->macSockets.constEnd(); ++it) {
MacSocketInfo *socketInfo = (*it);
if (CFSocketIsValid(socketInfo->socket)) {
qt_mac_remove_socket_from_runloop(socketInfo->socket, socketInfo->runloop);
CFRunLoopSourceInvalidate(socketInfo->runloop);
CFRelease(socketInfo->runloop);
CFSocketInvalidate(socketInfo->socket);
CFRelease(socketInfo->socket);
}
}
CFRunLoopRemoveSource(runLoopForCarbonLoop(GetMainEventLoop()), d->postedEventsSource, kCFRunLoopCommonModes);
CFRelease(d->postedEventsSource);
d->postedEventsSource = 0;
}
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;
}
}
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 );
}
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;
}
}
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_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;
}
bool QEventDispatcherMac::processEvents(QEventLoop::ProcessEventsFlags flags)
{
Q_D(QEventDispatcherMac);
#if 0
//TrackDrag says you may not use the EventManager things..
if(qt_mac_in_drag) {
qWarning("Qt: Cannot process events whilst dragging!");
return false;
}
#endif
d->interrupt = false;
emit awake();
#ifndef QT_MAC_NO_QUICKDRAW
if(!qt_mac_safe_pdev) { //create an empty widget and this can be used for a port anytime
QWidget *tlw = new QWidget;
tlw->setAttribute(Qt::WA_DeleteOnClose);
tlw->setObjectName(QLatin1String("empty_widget"));
tlw->hide();
qt_mac_safe_pdev = tlw;
}
#endif
bool retVal = false;
for (;;) {
QApplicationPrivate::sendPostedEvents(0, 0, d->threadData);
if (d->activateTimers() > 0) //send null timers
retVal = true;
do {
EventRef event;
if (!(flags & QEventLoop::ExcludeUserInputEvents)
&& !d->queuedUserInputEvents.isEmpty()) {
// process a pending user input event
event = d->queuedUserInputEvents.takeFirst();
} else {
OSStatus err = ReceiveNextEvent(0,0, kEventDurationNoWait, true, &event);
if(err != noErr)
continue;
// else
if (flags & QEventLoop::ExcludeUserInputEvents) {
UInt32 ekind = GetEventKind(event),
eclass = GetEventClass(event);
switch(eclass) {
case kEventClassQt:
if(ekind != kEventQtRequestContext)
break;
// fall through
case kEventClassMouse:
case kEventClassKeyboard:
d->queuedUserInputEvents.append(event);
continue;
}
}
}
if (!filterEvent(&event) && qt_mac_send_event(flags, event))
retVal = true;
ReleaseEvent(event);
} while(!d->interrupt && GetNumEventsInQueue(GetMainEventQueue()) > 0);
bool canWait = (d->threadData->canWait
&& !retVal
&& !d->interrupt
&& (flags & QEventLoop::WaitForMoreEvents)
&& !d->zero_timer_count);
if (canWait) {
emit aboutToBlock();
while(CFRunLoopRunInMode(kCFRunLoopDefaultMode, 1.0e20, true) == kCFRunLoopRunTimedOut);
flags &= ~QEventLoop::WaitForMoreEvents;
emit awake();
} else {
CFRunLoopRunInMode(kCFRunLoopDefaultMode, kEventDurationNoWait, true);
break;
}
}
return retVal;
}
bool QEventDispatcherMac::hasPendingEvents()
{
extern uint qGlobalPostedEventsCount();
return qGlobalPostedEventsCount() || (qt_is_gui_used && GetNumEventsInQueue(GetMainEventQueue()));
}
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;
}
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);
}
