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;
}
/*
Position the contentView (presumed to be a subview of the frameView) by
asking the content view for its metrics and positioning it appropriately.
*/
OSStatus PositionContentViewWithMetrics(HIViewRef frameView, HIViewRef contentView)
{
HIViewFrameMetrics metrics = { 0, 0, 0, 0 };
EventRef getMetricsEvent = NULL;
// First we check the frame metrics of the content view by asking it (politely) for the
// metrics it wants
verify_noerr(CreateEvent(NULL, kEventClassControl, kEventControlGetFrameMetrics, GetCurrentEventTime(), 0, &getMetricsEvent));
if(NULL != getMetricsEvent) {
SetEventParameter(getMetricsEvent, kEventParamDirectObject, typeControlRef, sizeof(contentView), &contentView);
SetEventParameter(getMetricsEvent, kEventParamControlFrameMetrics, typeControlFrameMetrics, sizeof(metrics), &metrics);
OSStatus result = SendEventToEventTarget(getMetricsEvent, HIObjectGetEventTarget((HIObjectRef)contentView));
if(result == noErr) {
verify_noerr(GetEventParameter(getMetricsEvent, kEventParamControlFrameMetrics, typeControlFrameMetrics, NULL, sizeof(metrics), NULL, &metrics));
}
ReleaseEvent(getMetricsEvent);
getMetricsEvent = NULL;
}
// Now we reposition the content view based on the metrics we got from it.
HIRect bounds, contentRect;
HIViewGetBounds(frameView, &bounds);
contentRect.origin.x = metrics.left;
contentRect.origin.y = metrics.top;
contentRect.size.width = bounds.size.width - (metrics.left + metrics.right);
contentRect.size.height = bounds.size.height - (metrics.top + metrics.bottom);
HIViewSetFrame(contentView, &contentRect);
return 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;
}
//-----------------------------------------------------------------------------
// CreateCustomToolbarItem
//-----------------------------------------------------------------------------
// Our 'public' API to create our custom URL item.
//
HIToolbarItemRef
CreateCustomToolbarItem( CFStringRef inIdentifier, CFTypeRef inURL )
{
OSStatus err;
EventRef event;
UInt32 options = kHIToolbarItemAllowDuplicates;
HIToolbarItemRef result = NULL;
RegisterCustomToolbarItemClass();
err = CreateEvent( NULL, kEventClassHIObject, kEventHIObjectInitialize,
GetCurrentEventTime(), 0, &event );
require_noerr( err, CantCreateEvent );
SetEventParameter( event, kEventParamToolbarItemIdentifier, typeCFStringRef, sizeof( CFStringRef ), &inIdentifier );
SetEventParameter( event, kEventParamAttributes, typeUInt32, sizeof( UInt32 ), &options );
if ( inURL )
SetEventParameter( event, kEventParamToolbarItemConfigData, typeCFTypeRef, sizeof( CFTypeRef ), &inURL );
err = HIObjectCreate( kCustomToolbarItemClassID, event, (HIObjectRef*)&result );
check_noerr( err );
ReleaseEvent( event );
CantCreateEvent:
return result;
}
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;
}
//-----------------------------------------------------------------------------------
static void DoTheTracking(EventRef inEvent, MTViewData* data)
{
MouseTrackingResult mouseResult;
ControlPartCode part;
Point qdPt;
HIPoint where;
// Extract the mouse location (local coordinates!)
GetEventParameter(inEvent, kEventParamMouseLocation, typeHIPoint, NULL, sizeof(HIPoint), NULL, &where);
CGAffineTransform m = CGAffineTransformIdentity;
// Reset the path
if (data->thePath != NULL)
CGPathRelease(data->thePath);
data->thePath = CGPathCreateMutable();
#if CG_COORDINATES
where.y = FlipHIViewYCoordinate(data->theView, where.y);
#endif
CGPathMoveToPoint(data->thePath, &m, where.x, where.y);
// fprintf(stderr, "StartPt: (%g, %g\n", where.x, where.y);
while (true)
{
// Watch the mouse for change: qdPt comes back in global coordinates!
TrackMouseLocation((GrafPtr)(-1), &qdPt, &mouseResult);
// Bail out when the mouse is released
if ( mouseResult == kMouseTrackingMouseReleased )
{
HIViewSetNeedsDisplay(data->theView, true);
break;
}
// Need to convert from global
where = QDGlobalToHIViewLocal(qdPt, data->theView);
#if CG_COORDINATES
where.y = FlipHIViewYCoordinate(data->theView, where.y);
#endif
CGPathAddLineToPoint(data->thePath, &m, where.x, where.y);
// fprintf(stderr, "TrackPt: (%g, %g\n", where.x, where.y);
part = 0;
SetEventParameter(inEvent, kEventParamControlPart, typeControlPartCode, sizeof(ControlPartCode), &part);
HIViewSetNeedsDisplay(data->theView, true);
}
// Send back the part upon which the mouse was released
part = kControlEntireControl;
SetEventParameter(inEvent, kEventParamControlPart, typeControlPartCode, sizeof(ControlPartCode), &part);
}
extern OSStatus
HICreateScrollingTextBox(
const HIRect * inBounds, /* can be NULL */
CFStringRef inScrollingText,
Boolean inAutoScroll,
UInt32 inDelayBeforeAutoScroll,
UInt32 inDelayBetweenAutoScroll,
UInt16 inAutoScrollAmount,
HIViewRef * outHIView)
{
*outHIView = NULL;
EventRef theInitializeEvent = NULL;
HIViewRef scrollView;
OSStatus status;
status = CreateEvent(NULL, kEventClassHIObject, kEventHIObjectInitialize, GetCurrentEventTime(), kEventAttributeUserEvent, &theInitializeEvent);
// settings
SetEventParameter(theInitializeEvent, kEventParamScrollingText, typeCFStringRef, sizeof(inScrollingText), &inScrollingText);
SetEventParameter(theInitializeEvent, kEventParamAutoScroll, typeBoolean, sizeof(inAutoScroll), &inAutoScroll);
SetEventParameter(theInitializeEvent, kEventParamDelayBeforeAutoScroll, typeUInt32, sizeof(inDelayBeforeAutoScroll), &inDelayBeforeAutoScroll);
SetEventParameter(theInitializeEvent, kEventParamDelayBetweenAutoScroll, typeUInt32, sizeof(inDelayBetweenAutoScroll), &inDelayBetweenAutoScroll);
SetEventParameter(theInitializeEvent, kEventParamAutoScrollAmount, typeSInt16, sizeof(inAutoScrollAmount), &inAutoScrollAmount);
HIObjectRef hiObject;
status = HIObjectCreate(GetScrollingTextBoxClass(), theInitializeEvent, &hiObject);
HIViewSetVisible((HIViewRef)hiObject, true);
if (!inAutoScroll)
{
//
// Manual scrolling, we need to be embedded in a scroll view
//
status = HIScrollViewCreate(kHIScrollViewOptionsVertScroll, &scrollView);
status = HIViewAddSubview(scrollView, (HIViewRef)hiObject);
if (inBounds != NULL)
HIViewSetFrame(scrollView, inBounds);
EventTypeSpec event = {kEventClassControl, kEventControlDraw};
InstallEventHandler(GetControlEventTarget(scrollView), FrameView, 1, &event, NULL, NULL);
*outHIView = scrollView;
}
else
{
if (inBounds != NULL)
HIViewSetFrame((HIViewRef)hiObject, inBounds);
*outHIView = (HIViewRef)hiObject;
}
return status;
}
// -----------------------------------------------------------------------------
// HITestViewHitTest
// -----------------------------------------------------------------------------
// Check to see if a point hits the view
//
OSStatus HITestViewHitTest(
EventRef inEvent,
HITestViewData* inData )
{
OSStatus err;
HIRect bounds;
HIPoint where;
ControlPartCode part;
// Extract the mouse location
err = GetEventParameter( inEvent, kEventParamMouseLocation, typeHIPoint,
NULL, sizeof( HIPoint ), NULL, &where );
require_noerr( err, ParameterMissing );
// Is the mouse in the view?
err = HIViewGetBounds( inData->view, &bounds );
if ( CGRectContainsPoint( bounds, where ) )
part = 1;
else
part = kControlNoPart;
// Send back the value of the hit part
err = SetEventParameter( inEvent, kEventParamControlPart, typeControlPartCode,
sizeof( ControlPartCode ), &part );
ParameterMissing:
return err;
}
static pascal OSStatus ViewClassHandler(EventHandlerCallRef inCaller, EventRef inEvent, void* inRefcon)
{
OSStatus result = eventNotHandledErr;
int* pain = (int*)inRefcon;
if (GetEventClass(inEvent) == kEventClassHIObject) {
switch (GetEventKind(inEvent)) {
case kEventHIObjectConstruct: {
int* pa = new int;
GetEventParameter(inEvent,kEventParamHIObjectInstance, typeHIObjectRef, NULL, sizeof(int), NULL, &pa);
result = SetEventParameter(inEvent, kEventParamHIObjectInstance, typeVoidPtr, sizeof(int), &pa);
break;
}
case kEventHIObjectDestruct: {
if (pain != NULL) {
delete pain;
}
result = noErr;
break;
}
}
}
return result;
}
// -----------------------------------------------------------------------------
// HITestViewConstruct
// -----------------------------------------------------------------------------
// Do any instatiation-time preparation for the view.
//
OSStatus HITestViewConstruct(
EventRef inEvent )
{
OSStatus err;
HITestViewData* data;
// don't CallNextEventHandler!
data = (HITestViewData*) malloc( sizeof( HITestViewData ) );
require_action( data != NULL, CantMalloc, err = memFullErr );
err = GetEventParameter( inEvent, kEventParamHIObjectInstance, typeHIObjectRef,
NULL, sizeof( HIObjectRef ), NULL, (HIObjectRef*) &data->view );
require_noerr( err, ParameterMissing );
// Set the userData that will be used with all subsequent eventHandler calls
err = SetEventParameter( inEvent, kEventParamHIObjectInstance, typeVoidPtr,
sizeof( HITestViewData* ), &data );
ParameterMissing:
if ( err != noErr )
free( data );
CantMalloc:
return err;
}
/*****************************************************
*
* UserPaneHandler(inHandlerCallRef, inEvent, inUserData)
*
* Purpose: called to handle the UserPane used as an embedder in the HIScrollView
*
* Inputs: inHandlerCallRef - reference to the current handler call chain
* inEvent - the event
* inUserData - app-specified data you passed in the call to InstallEventHandler
*
* Returns: OSStatus - noErr indicates the event was handled
* eventNotHandledErr indicates the event was not handled and the Toolbox should take over
*/
static pascal OSStatus UserPaneHandler(EventHandlerCallRef inHandlerCallRef, EventRef inEvent, void * inUserData)
{
OSStatus status = eventNotHandledErr;
HIViewRef userPane = (HIViewRef)inUserData;
HIRect bounds;
HIViewGetBounds(userPane, &bounds);
// the following is a very straightforward simple yet complete implementation of the
// kEventClassScrollable protocol which is enough to make the User Pane scrolls along its embedded content
switch (GetEventKind(inEvent))
{
#pragma mark * kEventScrollableGetInfo
case kEventScrollableGetInfo:
{
// we're being asked to return information about the scrolled view that we set as Event Parameters
HISize lineSize = { 1, 1 }, imageSize = {3000, 2000};
SetEventParameter(inEvent, kEventParamViewSize, typeHISize, sizeof(bounds.size), &bounds.size);
SetEventParameter(inEvent, kEventParamImageSize, typeHISize, sizeof(imageSize), &imageSize);
SetEventParameter(inEvent, kEventParamLineSize, typeHISize, sizeof(lineSize), &lineSize);
SetEventParameter(inEvent, kEventParamOrigin, typeHIPoint, sizeof(bounds.origin), &bounds.origin);
status = noErr;
break;
}
#pragma mark * kEventScrollableScrollTo
case kEventScrollableScrollTo:
{
// we're being asked to scroll, we just do a sanity check and ask for a redraw if the location is different
HIPoint where;
GetEventParameter(inEvent, kEventParamOrigin, typeHIPoint, NULL, sizeof(where), NULL, &where);
if ((bounds.origin.y != where.y) || (bounds.origin.x != where.x))
{
HIViewSetBoundsOrigin(userPane, where.x, where.y);
HIViewSetNeedsDisplay(userPane, true);
}
status = noErr;
break;
}
}
} // UserPaneHandler
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 );
}
/* 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 MCRevolutionStackViewRelink(WindowRef p_window, MCStack *p_new_stack)
{
EventRef t_event;
CreateEvent(NULL, 'revo', 'rlnk', GetCurrentEventTime(), 0, &t_event);
SetEventParameter(t_event, 'Stak', typeVoidPtr, sizeof(void *), &p_new_stack);
HIViewRef t_root;
GetRootControl(p_window, &t_root);
HIViewRef t_view;
GetIndexedSubControl(t_root, 1, &t_view);
SendEventToEventTarget(t_event, GetControlEventTarget(t_view));
ReleaseEvent(t_event);
}
/*
The public routine exported from this file that creates a star-shaped frame
view suitable for the given menuType.
*/
OSStatus CreateStarFrame(MenuRef inMenu, ThemeMenuType menuType, HIViewRef *outFrameView)
{
OSStatus errStatus = noErr;
static bool isRegistered = false;
// Register the StarMenuFrame subclass if necessary
if(!isRegistered) {
verify_noerr( HIObjectRegisterSubclass (
kStarFrameClassID,
kHIViewClassID,
kNilOptions,
StarFrameEventHandler,
GetEventTypeCount( gStarFrameHandledEvents ),
gStarFrameHandledEvents,
NULL,
&gStarFrameClassRef));
isRegistered = true;
}
// Create an instance of the StarMenuFrame
EventRef initEvent = NULL;
errStatus = CreateEvent(NULL, kEventClassHIObject, kEventHIObjectInitialize, 0, 0, &initEvent );
if(noErr == errStatus && initEvent) {
// store the initialization parameters in the event
SetEventParameter( initEvent, kEventParamMenuRef, typeMenuRef, sizeof(inMenu), &inMenu);
SetEventParameter( initEvent, kEventParamMenuType, typeThemeMenuType, sizeof(menuType), &menuType);
verify_noerr(errStatus = HIObjectCreate(kStarFrameClassID, initEvent, (HIObjectRef *) outFrameView));
ReleaseEvent(initEvent);
initEvent = nil;
}
return errStatus;
}
/*----------------------------------------------------------------------------------------------------------*/
void myScrollingTextTimeProc(EventLoopTimerRef inTimer, void *inUserData)
{
ScrollingTextBoxData* myData = (ScrollingTextBoxData*)inUserData;
HIPoint where = {0.0, myData->originPoint.y + myData->autoScrollAmount};
// If we reached the end of our text, let's start again
if (where.y >= myData->height - 10.0) where.y = 0.0;
// Creating and sending our ScrollTo event
EventRef theEvent;
CreateEvent(NULL, kEventClassScrollable, kEventScrollableScrollTo, GetCurrentEventTime(), kEventAttributeUserEvent, &theEvent);
SetEventParameter(theEvent, kEventParamOrigin, typeHIPoint, sizeof(where), &where);
SendEventToEventTarget(theEvent, GetControlEventTarget(myData->view));
ReleaseEvent(theEvent);
}
//
// Build a custom event to send to our window handler when movie audio extraction
// completes for the current movie (without the user pressing the "Stop" button
// to stop it before it runs to the end). We'll then update our button title to
// reflect this.
//
OSStatus SendExtractionStatusEventToWindow(Boolean extractionPaused)
{
OSStatus err = noErr;
EventRef event = NULL;
err = CreateEvent( NULL, kEventClassMovieExtractState, kEventKQueue, GetCurrentEventTime(), kEventAttributeNone, &event );
if ( err != noErr ) goto Bail;
err = SetEventParameter( event, kEventParamDirectObject, typeKEvent, sizeof(Boolean), &extractionPaused ); // Send the event
if ( err != noErr ) goto Bail;
err = SendEventToEventTarget (event, GetWindowEventTarget(mWindow)); // Post the event for our window handler
Bail:
if ( event != NULL ) (void) ReleaseEvent( event );
return( err );
}
OSStatus MCRevolutionStackViewCreate(MCStack *p_stack, ControlRef* r_control)
{
HIRevolutionStackViewRegister();
EventRef t_event;
CreateEvent(NULL, kEventClassHIObject, kEventHIObjectInitialize, GetCurrentEventTime(), 0, &t_event);
SetEventParameter(t_event, 'Stak', typeVoidPtr, sizeof(void *), &p_stack);
ControlRef t_control;
HIObjectCreate(kHIRevolutionStackViewClassID, t_event, (HIObjectRef *)&t_control);
ReleaseEvent(t_event);
*r_control = t_control;
return noErr;
}
OSStatus HIOpenGLViewEventControlHitTest (EventHandlerCallRef, EventRef inEvent, HIOpenGLViewData* inData)
{
// Extract the mouse location
HIPoint where;
ControlPartCode part;
OSStatus err = GetEventParameter(inEvent, kEventParamMouseLocation, typeHIPoint, nil, sizeof(HIPoint), nil, &where);
require_noerr(err, ParameterMissing);
// Is the mouse in the view?
HIRect bounds;
err = HIViewGetBounds(inData->mControl, &bounds);
part = CGRectContainsPoint(bounds, where) ? 1 : kControlNoPart;
// Send back the value of the hit part
err = SetEventParameter(inEvent, kEventParamControlPart, typeControlPartCode, sizeof(ControlPartCode), &part);
ParameterMissing:
return err;
}
OSStatus
CreateMouseTrackingView(HIViewRef parentView, const Rect* inBounds, HIViewID* inViewID)
{
#define kCanvasClassID CFSTR( "com.apple.sample.canvasview" )
OSStatus err;
EventRef event;
HIViewRef theView;
// Register this class
err = MyMTViewRegister(kCanvasClassID);
require_noerr( err, CantRegister );
// Make an initialization event
err = CreateEvent( NULL, kEventClassHIObject, kEventHIObjectInitialize, GetCurrentEventTime(), 0, &event );
require_noerr( err, CantCreateEvent );
// If bounds were specified, push them into the initialization event
// so that they can be used in the initialization handler.
if ( inBounds != NULL )
{
err = SetEventParameter(event, kCanvasBoundsParam, typeQDRectangle, sizeof(Rect), inBounds);
require_noerr( err, CantSetParameter );
}
err = HIObjectCreate(kCanvasClassID, event, (HIObjectRef*)&theView);
require_noerr(err, CantCreate);
if (parentView != NULL)
{
err = HIViewAddSubview(parentView, theView);
}
SetControlID(theView, inViewID); // useful if a handler needs to call GetControlByID()
HIViewSetVisible(theView, true);
CantCreate:
CantSetParameter:
CantCreateEvent:
ReleaseEvent( event );
CantRegister:
return err;
}
pascal OSStatus dockmenuhandler (EventHandlerCallRef nextHandler, EventRef theEvent, void* userData) {
/*
7.1b22 PBS: called from the system when the dock icon is right-clicked.
Build a contextual menu and return it.
*/
#pragma unused(nextHandler) /*happy compiler*/
#pragma unused(theEvent)
#pragma unused(userData)
hdlmenu hmenu;
hdlmenurecord hm;
static boolean flinited = false;
menuid = 0;
dockmenuresetmenustack (); /*7.1b23 PBS: maintain a stack of submenus*/
if (!flinited) { /*install command handler first time*/
dockmenuinstallhandler ();
flinited = true;
} /*if*/
hmenu = Newmenu (defaultpopupmenuid, BIGSTRING (""));
if (!dockmenufillpopup (hmenu, &hm))
goto exit;
dockmenuaddtomenustack (hmenu, defaultpopupmenuid);
hcurrmenurecord = hm;
SetEventParameter (theEvent, kEventParamMenuRef, typeMenuRef, sizeof (MenuRef), &hmenu);
exit:
return (noErr); /*all's well in dock-menu-land*/
} /*dockmenuhandler*/
OSStatus HIOpenGLViewCreate (WindowRef inWindow, const Rect* inBounds, ControlRef* outControl)
{
// Register this class
OSStatus err = HIOpenGLViewRegister();
require_noerr(err, CantRegister);
// Make an initialization event
EventRef event;
err = CreateEvent(nil, kEventClassHIObject, kEventHIObjectInitialize, GetCurrentEventTime(), 0, &event);
require_noerr(err, CantCreateEvent);
// If bounds were specified, push the them into the initialization
// event so that they can be used in the initialization handler.
if (inBounds != nil)
{
err = SetEventParameter(event, 'Boun', typeQDRectangle, sizeof(Rect), inBounds);
require_noerr(err, CantSetParameter);
}
// Make a new instantiation of this class
err = HIObjectCreate(kHIOpenGLViewClassID, event, (HIObjectRef*)outControl);
require_noerr(err, CantCreate);
// If a parent window was specified, place the new view into the parent window.
if (inWindow != nil)
{
ControlRef root = nil;
err = GetRootControl(inWindow, &root);
require_noerr(err, CantGetRootControl);
err = HIViewAddSubview(root, *outControl);
}
CantCreate:
CantGetRootControl:
CantSetParameter:
CantCreateEvent:
ReleaseEvent(event);
CantRegister:
return err;
}
/*
Handle the messages necessary for creating the custom StarMenuFame
class.
*/
OSStatus HandleStarFrameObjectEvents(
EventHandlerCallRef inCallRef,
EventRef inEvent,
StarFrameData* frameData)
{
OSStatus err = eventNotHandledErr;
switch ( GetEventKind( inEvent ) ) {
case kEventHIObjectConstruct:
frameData = (StarFrameData *) calloc(1, sizeof(StarFrameData));
frameData->menu = NULL;
GetEventParameter(inEvent, kEventParamHIObjectInstance, typeHIObjectRef, NULL, sizeof( frameData->hiSelf ), NULL, &frameData->hiSelf );
// This important step actually associates our frameData with the view being initialized
SetEventParameter(inEvent, kEventParamHIObjectInstance, typeVoidPtr, sizeof( frameData ), &frameData );
err = noErr;
break;
case kEventHIObjectInitialize:
err = CallNextEventHandler( inCallRef, inEvent );
if ( err == noErr ) {
GetEventParameter(inEvent, kEventParamMenuRef, typeMenuRef, NULL, sizeof(frameData->menu), NULL, &frameData->menu);
GetEventParameter(inEvent, kEventParamMenuType, typeThemeMenuType, NULL, sizeof( frameData->menuType ), NULL, &frameData->menuType );
}
err = noErr;
break;
case kEventHIObjectDestruct:
free( (void*) frameData );
err = noErr;
break;
default:
break;
}
return err;
}
/*****************************************************
*
* Handle_TextInputEvent(inHandlerCallRef, inEvent, inUserData)
*
* Purpose: called to intercept keystrokes which are destined for a control
*
* Inputs: inHandlerCallRef - reference to the current handler call chain
* inEvent - the event
* inUserData - app-specified data you passed in the call to InstallEventHandler
*
* Returns: OSStatus - noErr indicates the event was handled
* eventNotHandledErr indicates the event was not handled and the Toolbox should take over
*/
static pascal OSStatus Handle_TextInputEvent(EventHandlerCallRef inHandlerCallRef, EventRef inEvent, void *inUserData)
{
OSStatus status;
UniChar ch = 0;
status = GetEventParameter(inEvent, kEventParamTextInputSendText, typeUnicodeText, NULL, sizeof(ch), NULL, &ch);
require_noerr(status, ExitTextInput);
if ((ch == kReturnCharCode) || (ch == kEnterCharCode))
{
//
// we got return or enter so we validate the edit text control by sending a command
//
EventRef theEvent;
CreateEvent(NULL, kEventClassCommand, kEventCommandProcess, GetCurrentEventTime(), kEventAttributeUserEvent, &theEvent);
HICommandExtended theCommand;
theCommand.attributes = kHICommandFromControl;
theCommand.commandID = 'SVet';
theCommand.source.control = (ControlRef)inUserData;
SetEventParameter(theEvent, kEventParamDirectObject, typeHICommand, sizeof(theCommand), &theCommand);
SendEventToEventTarget(theEvent, GetWindowEventTarget(GetControlOwner((ControlRef)inUserData)));
ReleaseEvent(theEvent);
status = noErr;
}
if ( ((ch >= '0') && (ch <= '9')) ||
(ch == kBackspaceCharCode) ||
(ch == kLeftArrowCharCode) ||
(ch == kRightArrowCharCode) ||
(ch == kUpArrowCharCode) ||
(ch == kDownArrowCharCode) )
status = eventNotHandledErr;
else
status = noErr;
ExitTextInput:
return status;
} // Handle_TextInputEvent
OSStatus HIOpenGLViewEventHIObjectConstruct (EventHandlerCallRef, EventRef inEvent, HIOpenGLViewData*)
{
OSStatus err;
HIOpenGLViewData* data;
// don't CallNextEventHandler!
data = (HIOpenGLViewData*)malloc(sizeof(HIOpenGLViewData));
require_action(data != nil, CantMalloc, err = memFullErr);
data->mControl = nil;
data->mContext = nil;
err = GetEventParameter(inEvent, kEventParamHIObjectInstance, typeHIObjectRef, nil, sizeof(HIObjectRef), nil, (HIObjectRef*) &data->mControl);
require_noerr(err, ParameterMissing);
// Set the userData that will be used with all subsequent eventHandler calls
err = SetEventParameter(inEvent, kEventParamHIObjectInstance, typeVoidPtr, sizeof(HIOpenGLViewData*), &data);
ParameterMissing:
if (err != noErr) free(data);
CantMalloc:
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);
}
/**
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
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;
}
}
