Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
tree: 1337bce10e
Fetching contributors…

Cannot retrieve contributors at this time

694 lines (638 sloc) 20.964 kb
/*
* 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},
{kEventClassFont, kEventFontPanelClosed},
{kEventClassFont, kEventFontSelection},
};
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:
*/
Jump to Line
Something went wrong with that request. Please try again.