summaryrefslogtreecommitdiffstats
path: root/macosx/tkMacOSXCarbonEvents.c
diff options
context:
space:
mode:
Diffstat (limited to 'macosx/tkMacOSXCarbonEvents.c')
-rw-r--r--macosx/tkMacOSXCarbonEvents.c690
1 files changed, 0 insertions, 690 deletions
diff --git a/macosx/tkMacOSXCarbonEvents.c b/macosx/tkMacOSXCarbonEvents.c
deleted file mode 100644
index 1a71cbb..0000000
--- a/macosx/tkMacOSXCarbonEvents.c
+++ /dev/null
@@ -1,690 +0,0 @@
-/*
- * tkMacOSXCarbonEvents.c --
- *
- * This file implements functions that register for and handle
- * various Carbon Events and Timers. Most carbon events of interest
- * to TkAqua are processed in a handler registered on the dispatcher
- * event target so that we get first crack at them before HIToolbox
- * dispatchers/processes them further.
- * As some events are sent directly to the focus or app event target
- * and not dispatched normally, we also register a handler on the
- * application event target.
- *
- * Copyright 2001, Apple Computer, Inc.
- * Copyright (c) 2005-2008 Daniel A. Steffen <das@users.sourceforge.net>
- *
- * See the file "license.terms" for information on usage and redistribution of
- * this file, and for a DISCLAIMER OF ALL WARRANTIES.
- *
- * The following terms apply to all files originating from Apple
- * Computer, Inc. ("Apple") and associated with the software
- * unless explicitly disclaimed in individual files.
- *
- *
- * Apple hereby grants permission to use, copy, modify,
- * distribute, and license this software and its documentation
- * for any purpose, provided that existing copyright notices are
- * retained in all copies and that this notice is included
- * verbatim in any distributions. No written agreement, license,
- * or royalty fee is required for any of the authorized
- * uses. Modifications to this software may be copyrighted by
- * their authors and need not follow the licensing terms
- * described here, provided that the new terms are clearly
- * indicated on the first page of each file where they apply.
- *
- *
- * IN NO EVENT SHALL APPLE, THE AUTHORS OR DISTRIBUTORS OF THE
- * SOFTWARE BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL,
- * INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF
- * THIS SOFTWARE, ITS DOCUMENTATION, OR ANY DERIVATIVES THEREOF,
- * EVEN IF APPLE OR THE AUTHORS HAVE BEEN ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE. APPLE, THE AUTHORS AND
- * DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING,
- * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. THIS
- * SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, AND APPLE,THE
- * AUTHORS AND DISTRIBUTORS HAVE NO OBLIGATION TO PROVIDE
- * MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
- *
- * GOVERNMENT USE: If you are acquiring this software on behalf
- * of the U.S. government, the Government shall have only
- * "Restricted Rights" in the software and related documentation
- * as defined in the Federal Acquisition Regulations (FARs) in
- * Clause 52.227.19 (c) (2). If you are acquiring the software
- * on behalf of the Department of Defense, the software shall be
- * classified as "Commercial Computer Software" and the
- * Government shall have only "Restricted Rights" as defined in
- * Clause 252.227-7013 (c) (1) of DFARs. Notwithstanding the
- * foregoing, the authors grant the U.S. Government and others
- * acting in its behalf permission to use and distribute the
- * software in accordance with the terms specified in this
- * license.
- */
-
-#include "tkMacOSXPrivate.h"
-#include "tkMacOSXEvent.h"
-#include "tkMacOSXDebug.h"
-
-/*
-#ifdef TK_MAC_DEBUG
-#define TK_MAC_DEBUG_CARBON_EVENTS
-#endif
-*/
-
-/*
- * Declarations of functions used only in this file:
- */
-
-static OSStatus CarbonEventHandlerProc(EventHandlerCallRef callRef,
- EventRef event, void *userData);
-static OSStatus InstallStandardApplicationEventHandler(void);
-static void CarbonTimerProc(EventLoopTimerRef timer, void *userData);
-
-/*
- * Static data used by several functions in this file:
- */
-
-static EventLoopTimerRef carbonTimer = NULL;
-static int carbonTimerEnabled = 0;
-static EventHandlerUPP carbonEventHandlerUPP = NULL;
-static Tcl_Interp *carbonEventInterp = NULL;
-static int inTrackingLoop = 0;
-
-#if MAC_OS_X_VERSION_MIN_REQUIRED < 1050
-/*
- * For InstallStandardApplicationEventHandler():
- */
-
-static jmp_buf exitRaelJmpBuf;
-static void ExitRaelEventHandlerProc(EventHandlerCallRef callRef,
- EventRef event, void *userData) __attribute__ ((__noreturn__));
-#endif
-
-
-/*
- *----------------------------------------------------------------------
- *
- * CarbonEventHandlerProc --
- *
- * This procedure is the handler for all registered CarbonEvents.
- *
- * Results:
- * OS status code.
- *
- * Side effects:
- * Dispatches CarbonEvents.
- *
- *----------------------------------------------------------------------
- */
-
-static OSStatus
-CarbonEventHandlerProc(
- EventHandlerCallRef callRef,
- EventRef event,
- void *userData)
-{
- OSStatus err = eventNotHandledErr;
- TkMacOSXEvent macEvent;
- MacEventStatus eventStatus;
-
- macEvent.eventRef = event;
- macEvent.eClass = GetEventClass(event);
- macEvent.eKind = GetEventKind(event);
- macEvent.interp = (Tcl_Interp *) userData;
- macEvent.callRef = callRef;
- bzero(&eventStatus, sizeof(eventStatus));
-
-#ifdef TK_MAC_DEBUG_CARBON_EVENTS
- if (!(macEvent.eClass == kEventClassMouse && (
- macEvent.eKind == kEventMouseMoved ||
- macEvent.eKind == kEventMouseDragged))) {
- TkMacOSXDbgMsg("Started handling %s",
- TkMacOSXCarbonEventToAscii(event));
- TkMacOSXInitNamedDebugSymbol(HIToolbox, void, _DebugPrintEvent,
- EventRef inEvent);
- if (_DebugPrintEvent) {
- /*
- * Carbon-internal event debugging (c.f. Technote 2124)
- */
-
- _DebugPrintEvent(event);
- }
- }
-#endif /* TK_MAC_DEBUG_CARBON_EVENTS */
-
- TkMacOSXProcessEvent(&macEvent,&eventStatus);
- if (eventStatus.stopProcessing) {
- err = noErr;
- }
-
-#ifdef TK_MAC_DEBUG_CARBON_EVENTS
- if (macEvent.eKind != kEventMouseMoved &&
- macEvent.eKind != kEventMouseDragged) {
- TkMacOSXDbgMsg("Finished handling %s: %s handled",
- TkMacOSXCarbonEventToAscii(event),
- eventStatus.stopProcessing ? " " : "not");
- }
-#endif /* TK_MAC_DEBUG_CARBON_EVENTS */
- return err;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * TkMacOSXInitCarbonEvents --
- *
- * This procedure initializes all CarbonEvent handlers.
- *
- * Results:
- * None.
- *
- * Side effects:
- * Handlers for Carbon Events are registered.
- *
- *----------------------------------------------------------------------
- */
-
-MODULE_SCOPE void
-TkMacOSXInitCarbonEvents(
- Tcl_Interp *interp)
-{
- const EventTypeSpec dispatcherEventTypes[] = {
- {kEventClassKeyboard, kEventRawKeyDown},
- {kEventClassKeyboard, kEventRawKeyRepeat},
- {kEventClassKeyboard, kEventRawKeyUp},
- {kEventClassKeyboard, kEventRawKeyModifiersChanged},
- {kEventClassKeyboard, kEventRawKeyRepeat},
- };
- const EventTypeSpec applicationEventTypes[] = {
- {kEventClassMenu, kEventMenuBeginTracking},
- {kEventClassMenu, kEventMenuEndTracking},
- {kEventClassMenu, kEventMenuOpening},
- {kEventClassMenu, kEventMenuTargetItem},
- {kEventClassCommand, kEventCommandProcess},
- {kEventClassCommand, kEventCommandUpdateStatus},
- {kEventClassApplication, kEventAppActivated},
- {kEventClassApplication, kEventAppDeactivated},
- {kEventClassApplication, kEventAppQuit},
- {kEventClassApplication, kEventAppHidden},
- {kEventClassApplication, kEventAppShown},
- {kEventClassApplication, kEventAppAvailableWindowBoundsChanged},
- {kEventClassAppearance, kEventAppearanceScrollBarVariantChanged},
- };
-
- carbonEventHandlerUPP = NewEventHandlerUPP(CarbonEventHandlerProc);
- carbonEventInterp = interp;
- ChkErr(InstallStandardApplicationEventHandler);
- ChkErr(InstallEventHandler, GetEventDispatcherTarget(),
- carbonEventHandlerUPP, GetEventTypeCount(dispatcherEventTypes),
- dispatcherEventTypes, (void *) carbonEventInterp, NULL);
- ChkErr(InstallEventHandler, GetApplicationEventTarget(),
- carbonEventHandlerUPP, GetEventTypeCount(applicationEventTypes),
- applicationEventTypes, (void *) carbonEventInterp, NULL);
-
-#ifdef TK_MAC_DEBUG_CARBON_EVENTS
- TkMacOSXInitNamedSymbol(HIToolbox, void, DebugTraceEvent, OSType, UInt32,
- Boolean);
- if (DebugTraceEvent) {
- unsigned int i;
- const EventTypeSpec *e;
-
- for (i = 0, e = dispatcherEventTypes;
- i < GetEventTypeCount(dispatcherEventTypes); i++, e++) {
- DebugTraceEvent(e->eventClass, e->eventKind, 1);
- }
- for (i = 0, e = applicationEventTypes;
- i < GetEventTypeCount(applicationEventTypes); i++, e++) {
- DebugTraceEvent(e->eventClass, e->eventKind, 1);
- }
- DebugTraceEvent = NULL; /* Only enable tracing once. */
- }
-#endif /* TK_MAC_DEBUG_CARBON_EVENTS */
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * TkMacOSXInstallWindowCarbonEventHandler --
- *
- * This procedure installs our window CarbonEvent handler.
- *
- * Results:
- * None.
- *
- * Side effects:
- * Handler for Carbon Events is registered.
- *
- *----------------------------------------------------------------------
- */
-
-MODULE_SCOPE void
-TkMacOSXInstallWindowCarbonEventHandler(
- Tcl_Interp *interp, WindowRef window)
-{
- const EventTypeSpec windowEventTypes[] = {
- {kEventClassMouse, kEventMouseDown},
- {kEventClassMouse, kEventMouseUp},
- {kEventClassMouse, kEventMouseMoved},
- {kEventClassMouse, kEventMouseDragged},
- {kEventClassMouse, kEventMouseWheelMoved},
- {kEventClassWindow, kEventWindowActivated},
- {kEventClassWindow, kEventWindowDeactivated},
- {kEventClassWindow, kEventWindowUpdate},
- {kEventClassWindow, kEventWindowExpanding},
- {kEventClassWindow, kEventWindowBoundsChanged},
- {kEventClassWindow, kEventWindowDragStarted},
- {kEventClassWindow, kEventWindowDragCompleted},
- {kEventClassWindow, kEventWindowConstrain},
- {kEventClassWindow, kEventWindowGetRegion},
- {kEventClassWindow, kEventWindowDrawContent},
- };
-
- ChkErr(InstallEventHandler, GetWindowEventTarget(window),
- carbonEventHandlerUPP, GetEventTypeCount(windowEventTypes),
- windowEventTypes, (void *) (interp ? interp : carbonEventInterp),
- NULL);
-
-#ifdef TK_MAC_DEBUG_CARBON_EVENTS
- TkMacOSXInitNamedSymbol(HIToolbox, void, DebugTraceEvent, OSType, UInt32,
- Boolean);
- if (DebugTraceEvent) {
- unsigned int i;
- const EventTypeSpec *e;
-
- for (i = 0, e = windowEventTypes;
- i < GetEventTypeCount(windowEventTypes); i++, e++) {
- if (!(e->eventClass == kEventClassMouse && (
- e->eventKind == kEventMouseMoved ||
- e->eventKind == kEventMouseDragged))) {
- DebugTraceEvent(e->eventClass, e->eventKind, 1);
- }
- }
- }
-#endif /* TK_MAC_DEBUG_CARBON_EVENTS */
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * InstallStandardApplicationEventHandler --
- *
- * This procedure installs the carbon standard application event
- * handler.
- *
- * Results:
- * OS status code.
- *
- * Side effects:
- * Standard handlers for application Carbon Events are registered.
- *
- *----------------------------------------------------------------------
- */
-
-static OSStatus
-InstallStandardApplicationEventHandler(void)
-{
- OSStatus err = memFullErr;
-
- TK_IF_HI_TOOLBOX(5,
- /*
- * The approach below does not work correctly in Leopard, it leads to
- * crashes in [NSView unlockFocus] whenever HIToolbox uses Cocoa (Help
- * menu, Nav Services, Color Picker). While it is now possible to
- * install the standard app handler with InstallStandardEventHandler(),
- * to fully replicate RAEL the standard menubar event handler also needs
- * to be installed. Unfortunately there appears to be no public API to
- * obtain the menubar event target. As a workaround, for now we resort
- * to calling the HIToolbox-internal GetMenuBarEventTarget() directly
- * (symbol acquired via TkMacOSXInitNamedSymbol() from HIToolbox
- * version 343, may not exist in later versions).
- */
- err = ChkErr(InstallStandardEventHandler, GetApplicationEventTarget());
- TkMacOSXInitNamedSymbol(HIToolbox, EventTargetRef,
- GetMenuBarEventTarget, void);
- if (GetMenuBarEventTarget) {
- ChkErr(InstallStandardEventHandler, GetMenuBarEventTarget());
- } else {
- TkMacOSXDbgMsg("Unable to install standard menubar event handler");
- }
- ) TK_ELSE_HI_TOOLBOX (5,
- /*
- * This is a hack to workaround missing Carbon API to install the
- * standard application event handler (InstallStandardEventHandler()
- * does not work on the application target). The only way to install the
- * standard app handler is to call RunApplicationEventLoop(), but since
- * we are running our own event loop, we'll immediately need to break
- * out of RAEL again: we do this via longjmp out of the
- * ExitRaelEventHandlerProc event handler called first off from RAEL by
- * posting a high priority dummy event. This workaround is derived from
- * a similar approach in Technical Q&A 1061.
- */
- enum {
- kExitRaelEvent = 'ExiT'
- };
- const EventTypeSpec exitRaelEventType = {
- kExitRaelEvent, kExitRaelEvent
- };
- EventHandlerUPP exitRaelEventHandler;
- EventHandlerRef exitRaelEventHandlerRef = NULL;
- EventRef exitRaelEvent = NULL;
-
- exitRaelEventHandler = NewEventHandlerUPP(
- (EventHandlerProcPtr) ExitRaelEventHandlerProc);
- if (exitRaelEventHandler) {
- err = ChkErr(InstallEventHandler, GetEventDispatcherTarget(),
- exitRaelEventHandler, 1, &exitRaelEventType, NULL,
- &exitRaelEventHandlerRef);
- }
- if (err == noErr) {
- err = ChkErr(CreateEvent, NULL, kExitRaelEvent, kExitRaelEvent,
- GetCurrentEventTime(), kEventAttributeNone,
- &exitRaelEvent);
- }
- if (err == noErr) {
- err = ChkErr(PostEventToQueue, GetMainEventQueue(), exitRaelEvent,
- kEventPriorityHigh);
- }
- if (err == noErr) {
- if (!setjmp(exitRaelJmpBuf)) {
- RunApplicationEventLoop();
-
- /*
- * This point should never be reached!
- */
-
- Tcl_Panic("RunApplicationEventLoop exited !");
- }
- }
- if (exitRaelEvent) {
- ReleaseEvent(exitRaelEvent);
- }
- if (exitRaelEventHandlerRef) {
- RemoveEventHandler(exitRaelEventHandlerRef);
- }
- if (exitRaelEventHandler) {
- DisposeEventHandlerUPP(exitRaelEventHandler);
- }
- ) TK_ENDIF
- return err;
-}
-
-#if MAC_OS_X_VERSION_MIN_REQUIRED < 1050
-/*
- *----------------------------------------------------------------------
- *
- * ExitRaelEventHandlerProc --
- *
- * This procedure is the dummy event handler used to break out of
- * RAEL via longjmp, it is called as the first ever event handler
- * in RAEL by posting a high priority dummy event.
- *
- * Results:
- * None. Never returns !
- *
- * Side effects:
- * longjmp back to InstallStandardApplicationEventHandler().
- *
- *----------------------------------------------------------------------
- */
-
-static void
-ExitRaelEventHandlerProc(
- EventHandlerCallRef callRef,
- EventRef event,
- void *userData)
-{
- longjmp(exitRaelJmpBuf, 1);
-}
-#endif
-
-/*
- *----------------------------------------------------------------------
- *
- * TkMacOSXRunTclEventLoop --
- *
- * Process a limited number of tcl events.
- *
- * Results:
- * Returns 1 if events were handled and 0 otherwise.
- *
- * Side effects:
- * Runs the Tcl event loop.
- *
- *----------------------------------------------------------------------
- */
-
-MODULE_SCOPE int
-TkMacOSXRunTclEventLoop(void)
-{
- int i = 4, result = 0;
-
- /* Avoid starving main event loop: process at most 4 events. */
- while(--i && Tcl_ServiceAll()) {
- result = 1;
- }
- return result;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * CarbonTimerProc --
- *
- * This procedure is the carbon timer handler that runs the tcl
- * event loop periodically.
- *
- * Results:
- * None.
- *
- * Side effects:
- * Runs the Tcl event loop.
- *
- *----------------------------------------------------------------------
- */
-
-static void
-CarbonTimerProc(
- EventLoopTimerRef timer,
- void *userData)
-{
- if(carbonTimerEnabled > 0 && TkMacOSXRunTclEventLoop()) {
-#ifdef TK_MAC_DEBUG_CARBON_EVENTS
- TkMacOSXDbgMsg("Processed tcl events from carbon timer");
-#endif /* TK_MAC_DEBUG_CARBON_EVENTS */
- }
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * TkMacOSXStartTclEventLoopCarbonTimer --
- *
- * This procedure installs (if necessary) and starts a carbon
- * event timer that runs the tcl event loop periodically.
- * It should be called whenever a nested carbon event loop might
- * run by HIToolbox (e.g. during mouse tracking) to ensure that
- * tcl events continue to be processed.
- *
- * Results:
- * OS status code.
- *
- * Side effects:
- * Carbon event timer is installed and started.
- *
- *----------------------------------------------------------------------
- */
-
-MODULE_SCOPE OSStatus
-TkMacOSXStartTclEventLoopCarbonTimer(void)
-{
- OSStatus err = noErr;
-
- if (++carbonTimerEnabled > 0) {
- if(!carbonTimer) {
- EventLoopTimerUPP timerUPP = NewEventLoopTimerUPP(CarbonTimerProc);
-
- err = ChkErr(InstallEventLoopTimer, GetMainEventLoop(),
- 5 * kEventDurationMillisecond,
- 5 * kEventDurationMillisecond,
- timerUPP, NULL, &carbonTimer);
- } else {
- err = ChkErr(SetEventLoopTimerNextFireTime, carbonTimer,
- 5 * kEventDurationMillisecond);
- }
- }
- return err;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * TkMacOSXStopTclEventLoopCarbonTimer --
- *
- * This procedure stops the carbon event timer started by
- * TkMacOSXStartTclEventLoopCarbonTimer().
- *
- * Results:
- * OS status code.
- *
- * Side effects:
- * Carbon event timer is stopped.
- *
- *----------------------------------------------------------------------
- */
-
-MODULE_SCOPE OSStatus
-TkMacOSXStopTclEventLoopCarbonTimer(void)
-{
- OSStatus err = noErr;
-
- if (--carbonTimerEnabled == 0) {
- if(carbonTimer) {
- err = ChkErr(SetEventLoopTimerNextFireTime, carbonTimer,
- kEventDurationForever);
- }
- }
- return err;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * TkMacOSXTrackingLoop --
- *
- * Call with 1 before entering a mouse tracking loop (e.g. window
- * resizing or menu tracking) to enable tcl event processing but
- * disable carbon event processing (except for update events)
- * during the loop, and with 0 after exiting the loop to reset.
- *
- * Results:
- * None.
- *
- * Side effects:
- * None.
- *
- *----------------------------------------------------------------------
- */
-
-MODULE_SCOPE void
-TkMacOSXTrackingLoop(int tracking)
-{
- static int previousServiceMode = TCL_SERVICE_NONE;
-
- if (tracking) {
- inTrackingLoop++;
- previousServiceMode = Tcl_SetServiceMode(TCL_SERVICE_ALL);
- TkMacOSXStartTclEventLoopCarbonTimer();
-#ifdef TK_MAC_DEBUG_CARBON_EVENTS
- TkMacOSXDbgMsg("Entering tracking loop");
-#endif /* TK_MAC_DEBUG_CARBON_EVENTS */
- } else {
- TkMacOSXStopTclEventLoopCarbonTimer();
- previousServiceMode = Tcl_SetServiceMode(previousServiceMode);
- inTrackingLoop--;
-#ifdef TK_MAC_DEBUG_CARBON_EVENTS
- TkMacOSXDbgMsg("Exiting tracking loop");
-#endif /* TK_MAC_DEBUG_CARBON_EVENTS */
- }
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * TkMacOSXReceiveAndDispatchEvent --
- *
- * This receives a carbon event and sends it to the carbon event
- * dispatcher.
- *
- * Results:
- * Mac OS status
- *
- * Side effects:
- * This receives and dispatches the next Carbon event.
- *
- *----------------------------------------------------------------------
- */
-MODULE_SCOPE OSStatus
-TkMacOSXReceiveAndDispatchEvent(void)
-{
- static EventTargetRef targetRef = NULL;
- int numEventTypes = 0;
- const EventTypeSpec *eventTypes = NULL;
- EventRef eventRef;
- OSStatus err;
- const EventTypeSpec trackingEventTypes[] = {
- {'dniw', kEventWindowUpdate},
- {kEventClassWindow, kEventWindowUpdate},
- };
-
- if (inTrackingLoop > 0) {
- eventTypes = trackingEventTypes;
- numEventTypes = GetEventTypeCount(trackingEventTypes);
- }
-
- /*
- * This is a poll, since we have already counted the events coming
- * into this routine, and are guaranteed to have one waiting.
- */
-
- err = ReceiveNextEvent(numEventTypes, eventTypes,
- kEventDurationNoWait, true, &eventRef);
- if (err == noErr) {
-#ifdef TK_MAC_DEBUG_CARBON_EVENTS
- UInt32 kind = GetEventKind(eventRef);
-
- if (kind != kEventMouseMoved && kind != kEventMouseDragged) {
- TkMacOSXDbgMsg("Dispatching %s", TkMacOSXCarbonEventToAscii(eventRef));
- TkMacOSXInitNamedDebugSymbol(HIToolbox, void, _DebugPrintEvent,
- EventRef inEvent);
- if (_DebugPrintEvent) {
- /* Carbon-internal event debugging (c.f. Technote 2124) */
- _DebugPrintEvent(eventRef);
- }
- }
-#endif /* TK_MAC_DEBUG_CARBON_EVENTS */
- if (!targetRef) {
- targetRef = GetEventDispatcherTarget();
- }
- TkMacOSXStartTclEventLoopCarbonTimer();
- err = SendEventToEventTarget(eventRef, targetRef);
- TkMacOSXStopTclEventLoopCarbonTimer();
- if (err != noErr && err != eventLoopTimedOutErr
- && err != eventNotHandledErr) {
- TkMacOSXDbgMsg("SendEventToEventTarget(%s) failed: %ld",
- TkMacOSXCarbonEventToAscii(eventRef), err);
- }
- ReleaseEvent(eventRef);
- } else if (err != eventLoopTimedOutErr) {
- TkMacOSXDbgMsg("ReceiveNextEvent failed: %ld", err);
- }
- return err;
-}
-
-/*
- * Local Variables:
- * mode: c
- * c-basic-offset: 4
- * fill-column: 79
- * coding: utf-8
- * End:
- */