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; } }