* macosx/tkMacOSXBitmap.c, macosx/tkMacOSXButton.c:

	* macosx/tkMacOSXCarbonEvents.c, macosx/tkMacOSXClipboard.c:
	* macosx/tkMacOSXCursor.c, macosx/tkMacOSXDialog.c:
	* macosx/tkMacOSXDraw.c, macosx/tkMacOSXEvent.c:
	* macosx/tkMacOSXFont.c, macosx/tkMacOSXInit.c, macosx/tkMacOSXInt.h:
	* macosx/tkMacOSXKeyEvent.c, macosx/tkMacOSXMenu.c:
	* macosx/tkMacOSXMenubutton.c, macosx/tkMacOSXMouseEvent.c:
	* macosx/tkMacOSXScale.c, macosx/tkMacOSXWindowEvent.c:
	* macosx/tkMacOSXWm.c: Revert of commits from 2007-04-13 which
	broke the OS X build.

1 files changed, 200 insertions, 199 deletions

diff --git a/macosx/tkMacOSXCarbonEvents.c b/macosx/tkMacOSXCarbonEvents.c
index 81706ba..18c519e 100644
--- a/macosx/tkMacOSXCarbonEvents.c
+++ b/macosx/tkMacOSXCarbonEvents.c
@@ -1,13 +1,14 @@
 /*
  * 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.
+ *	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 Daniel A. Steffen <das@users.sourceforge.net>
@@ -15,45 +16,51 @@
  * 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.
- *
- * RCS: @(#) $Id: tkMacOSXCarbonEvents.c,v 1.14 2007/04/13 14:51:17 dkf Exp $
+ *      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.
+ *
+ * RCS: @(#) $Id: tkMacOSXCarbonEvents.c,v 1.15 2007/04/21 19:06:37 hobbs Exp $
  */
 
 #include "tkMacOSXInt.h"
@@ -66,51 +73,44 @@
 #endif
 */
 
-/*
- * Declarations of functions used only in this file:
- */
-
-static OSStatus		CarbonEventHandlerProc(EventHandlerCallRef callRef,
-			    EventRef event, void *userData);
-static OSStatus		InstallStandardApplicationEventHandler(void);
-static void		ExitRaelEventHandlerProc(EventHandlerCallRef,
-			    EventRef, void *) __attribute__ ((__noreturn__));
-static void		CarbonTimerProc(EventLoopTimerRef timer,
-			    void *userData);
-
-/*
- * Static data used by several functions in this file:
- */
+/* Declarations of functions used only in this file */
+static OSStatus CarbonEventHandlerProc(EventHandlerCallRef callRef,
+			      EventRef event, void *userData);
+static OSStatus InstallStandardApplicationEventHandler();
+static void ExitRaelEventHandlerProc (EventHandlerCallRef, EventRef, void*)
+	__attribute__ ((__noreturn__));
+static void CarbonTimerProc(EventLoopTimerRef timer, void *userData);
 
+/* Static data used by several functions in this file */
 static jmp_buf exitRaelJmpBuf;
 static EventLoopTimerRef carbonTimer = NULL;
 static int carbonTimerEnabled = 0;
-
+
 /*
  *----------------------------------------------------------------------
  *
  * CarbonEventHandlerProc --
  *
- *	This procedure is the handler for all registered CarbonEvents.
+ *	  This procedure is the handler for all registered CarbonEvents.
  *
  * Results:
- *	OS status code.
+ *	  OS status code.
  *
  * Side effects:
- *	Dispatches CarbonEvents.
+ *	  Dispatches CarbonEvents.
  *
  *----------------------------------------------------------------------
  */
 
 static OSStatus
-CarbonEventHandlerProc(
-    EventHandlerCallRef callRef,
-    EventRef event,
-    void *userData)
+CarbonEventHandlerProc (
+	EventHandlerCallRef callRef,
+	EventRef event,
+	void *userData)
 {
-    OSStatus result = eventNotHandledErr;
-    TkMacOSXEvent macEvent;
-    MacEventStatus eventStatus;
+    OSStatus	     result = eventNotHandledErr;
+    TkMacOSXEvent    macEvent;
+    MacEventStatus   eventStatus;
 
     macEvent.eventRef = event;
     macEvent.eClass = GetEventClass(macEvent.eventRef);
@@ -123,14 +123,11 @@ CarbonEventHandlerProc(
     if (macEvent.eKind != kEventMouseMoved &&
 	    macEvent.eKind != kEventMouseDragged) {
 	TkMacOSXCarbonEventToAscii(event, buf);
-	LOG_MSG("CarbonEventHandlerProc started handling %s", buf);
+	fprintf(stderr, "CarbonEventHandlerProc started handling %s\n", buf);
 	TkMacOSXInitNamedDebugSymbol(HIToolbox, void, _DebugPrintEvent,
 		EventRef inEvent);
 	if (_DebugPrintEvent) {
-	    /*
-	     * Carbon-internal event debugging (c.f. Technote 2124)
-	     */
-
+	    /* Carbon-internal event debugging (c.f. Technote 2124) */
 	    _DebugPrintEvent(event);
 	}
     }
@@ -144,7 +141,8 @@ CarbonEventHandlerProc(
 #if defined(TK_MAC_DEBUG) && defined(TK_MAC_DEBUG_CARBON_EVENTS)
     if (macEvent.eKind != kEventMouseMoved &&
 	    macEvent.eKind != kEventMouseDragged) {
-	LOG_MSG("CarbonEventHandlerProc finished handling %s: %s handled",
+	fprintf(stderr,
+		"CarbonEventHandlerProc finished handling %s: %s handled\n",
 		buf, eventStatus.stopProcessing ? "   " : "not");
     }
 #endif /* TK_MAC_DEBUG_CARBON_EVENTS */
@@ -156,71 +154,81 @@ CarbonEventHandlerProc(
  *
  * TkMacOSXInitCarbonEvents --
  *
- *	This procedure initializes all CarbonEvent handlers.
+ *	  This procedure initializes all CarbonEvent handlers.
  *
  * Results:
- *	None.
+ *	  None.
  *
  * Side effects:
- *	Handlers for Carbon Events are registered.
+ *	  Handlers for Carbon Events are registered.
  *
  *----------------------------------------------------------------------
  */
 
 MODULE_SCOPE void
-TkMacOSXInitCarbonEvents(
-    Tcl_Interp *interp)
+TkMacOSXInitCarbonEvents (
+	Tcl_Interp *interp)
 {
     OSStatus err;
     const EventTypeSpec dispatcherEventTypes[] = {
-	{kEventClassMouse,	 kEventMouseDown},
-	{kEventClassMouse,	 kEventMouseUp},
-	{kEventClassMouse,	 kEventMouseMoved},
-	{kEventClassMouse,	 kEventMouseDragged},
-	{kEventClassMouse,	 kEventMouseWheelMoved},
-	{kEventClassWindow,	 kEventWindowUpdate},
-	{kEventClassWindow,	 kEventWindowActivated},
-	{kEventClassWindow,	 kEventWindowDeactivated},
-	{kEventClassKeyboard,	 kEventRawKeyDown},
-	{kEventClassKeyboard,	 kEventRawKeyRepeat},
-	{kEventClassKeyboard,	 kEventRawKeyUp},
-	{kEventClassKeyboard,	 kEventRawKeyModifiersChanged},
-	{kEventClassKeyboard,	 kEventRawKeyRepeat},
-	{kEventClassApplication, kEventAppActivated},
-	{kEventClassApplication, kEventAppDeactivated},
-	{kEventClassApplication, kEventAppQuit},
+	    {kEventClassMouse,		kEventMouseDown},
+	    {kEventClassMouse,		kEventMouseUp},
+	    {kEventClassMouse,		kEventMouseMoved},
+	    {kEventClassMouse,		kEventMouseDragged},
+	    {kEventClassMouse,		kEventMouseWheelMoved},
+	    {kEventClassWindow,		kEventWindowUpdate},
+	    {kEventClassWindow,		kEventWindowActivated},
+	    {kEventClassWindow,		kEventWindowDeactivated},
+	    {kEventClassKeyboard,	kEventRawKeyDown},
+	    {kEventClassKeyboard,	kEventRawKeyRepeat},
+	    {kEventClassKeyboard,	kEventRawKeyUp},
+	    {kEventClassKeyboard,	kEventRawKeyModifiersChanged},
+	    {kEventClassKeyboard,	kEventRawKeyRepeat},
+	    {kEventClassApplication,	kEventAppActivated},
+	    {kEventClassApplication,	kEventAppDeactivated},
+	    {kEventClassApplication,	kEventAppQuit},
     };
     const EventTypeSpec applicationEventTypes[] = {
-	{kEventClassMenu,	 kEventMenuBeginTracking},
-	{kEventClassMenu,	 kEventMenuEndTracking},
-	{kEventClassCommand,	 kEventCommandProcess},
-	{kEventClassCommand,	 kEventCommandUpdateStatus},
-	{kEventClassMouse,	 kEventMouseWheelMoved},
-	{kEventClassWindow,	 kEventWindowExpanded},
-	{kEventClassApplication, kEventAppHidden},
-	{kEventClassApplication, kEventAppShown},
-	{kEventClassApplication, kEventAppAvailableWindowBoundsChanged},
+	    {kEventClassMenu,		kEventMenuBeginTracking},
+	    {kEventClassMenu,		kEventMenuEndTracking},
+	    {kEventClassCommand,	kEventCommandProcess},
+	    {kEventClassCommand,	kEventCommandUpdateStatus},
+	    {kEventClassMouse,		kEventMouseWheelMoved},
+	    {kEventClassWindow,		kEventWindowExpanded},
+	    {kEventClassApplication,	kEventAppHidden},
+	    {kEventClassApplication,	kEventAppShown},
+	    {kEventClassApplication,    kEventAppAvailableWindowBoundsChanged},
     };
     EventHandlerUPP handler = NewEventHandlerUPP(CarbonEventHandlerProc);
 
     err = InstallStandardApplicationEventHandler();
-    LOG_ON_ERROR(InstallStandardApplicationEventHandler);
+    if (err != noErr) {
+#ifdef TK_MAC_DEBUG
+	fprintf(stderr, "InstallStandardApplicationEventHandler failed, %d\n",
+		(int) err);
+#endif
+    }
     err = InstallEventHandler(GetEventDispatcherTarget(), handler,
 	    GetEventTypeCount(dispatcherEventTypes), dispatcherEventTypes,
 	    (void *) interp, NULL);
-    LOG_ON_ERROR(InstallEventHandler);
+    if (err != noErr) {
+#ifdef TK_MAC_DEBUG
+	fprintf(stderr, "InstallEventHandler failed, %d\n", (int) err);
+#endif
+    }
     err = InstallEventHandler(GetApplicationEventTarget(), handler,
 	    GetEventTypeCount(applicationEventTypes), applicationEventTypes,
 	    (void *) interp, NULL);
-    LOG_ON_ERROR(InstallEventHandler);
+    if (err != noErr) {
+#ifdef TK_MAC_DEBUG
+	fprintf(stderr, "InstallEventHandler failed, %d\n", (int) err);
+#endif
+    }
 
 #if defined(TK_MAC_DEBUG) && defined(TK_MAC_DEBUG_CARBON_EVENTS)
     TkMacOSXInitNamedDebugSymbol(HIToolbox, void, TraceEventByName, char*);
     if (TraceEventByName) {
-	/*
-	 * Carbon-internal event debugging (c.f. Technote 2124)
-	 */
-
+	/* Carbon-internal event debugging (c.f. Technote 2124) */
 	TraceEventByName("kEventMouseDown");
 	TraceEventByName("kEventMouseUp");
 	TraceEventByName("kEventMouseWheelMoved");
@@ -253,38 +261,34 @@ TkMacOSXInitCarbonEvents(
  *
  * InstallStandardApplicationEventHandler --
  *
- *	This procedure installs the carbon standard application event handler.
+ *	  This procedure installs the carbon standard application event
+ *	  handler.
  *
  * Results:
- *	OS status code.
+ *	  OS status code.
  *
  * Side effects:
- *	Standard handlers for application Carbon Events are registered.
+ *	  Standard handlers for application Carbon Events are registered.
  *
  *----------------------------------------------------------------------
  */
 
 static OSStatus
-InstallStandardApplicationEventHandler(void)
+InstallStandardApplicationEventHandler()
 {
-    /*
-     * 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
-    };
+   /*
+    * 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;
@@ -298,7 +302,7 @@ InstallStandardApplicationEventHandler(void)
 		&exitRaelEventHandlerRef);
     }
     if (err == noErr) {
-	err = CreateEvent(NULL, kExitRaelEvent, kExitRaelEvent,
+	err = CreateEvent(NULL, kExitRaelEvent, kExitRaelEvent, 
 		GetCurrentEventTime(), kEventAttributeNone, &exitRaelEvent);
     }
     if (err == noErr) {
@@ -308,11 +312,7 @@ InstallStandardApplicationEventHandler(void)
     if (err == noErr) {
 	if (!setjmp(exitRaelJmpBuf)) {
 	    RunApplicationEventLoop();
-
-	    /*
-	     * This point should never be reached!
-	     */
-
+	    /* This point should never be reached ! */
 	    Tcl_Panic("RunApplicationEventLoop exited !");
 	}
     }
@@ -333,24 +333,23 @@ InstallStandardApplicationEventHandler(void)
  *
  * 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.
+ *	  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!
+ *	  None. Never returns !
  *
  * Side effects:
- *	longjmp()s back to InstallStandardApplicationEventHandler().
+ *	  longjmp back to InstallStandardApplicationEventHandler().
  *
  *----------------------------------------------------------------------
  */
 
 static void
-ExitRaelEventHandlerProc(
-    EventHandlerCallRef callRef,
-    EventRef event,
-    void *userData)
+ExitRaelEventHandlerProc (
+	EventHandlerCallRef callRef,
+	EventRef event, void *userData)
 {
     longjmp(exitRaelJmpBuf, 1);
 }
@@ -360,36 +359,33 @@ ExitRaelEventHandlerProc(
  *
  * CarbonTimerProc --
  *
- *	This procedure is the carbon timer handler that runs the tcl event
- *	loop periodically. It does not process TCL_WINDOW_EVENTS to avoid
- *	reentry issues with Carbon, nor TCL_IDLE_EVENTS since it is only
- *	intended to be called during short periods of busy time such as during
- *	menu tracking.
+ *	  This procedure is the carbon timer handler that runs the tcl
+ *	  event loop periodically. It does not process TCL_WINDOW_EVENTS
+ *	  to avoid reentry issues with Carbon, nor TCL_IDLE_EVENTS since
+ *	  it is only intended to be called during short periods of busy
+ *	  time such as during menu tracking.
  *
  * Results:
- *	None.
+ *	  None.
  *
  * Side effects:
- *	Runs the Tcl event loop.
+ *	  Runs the Tcl event loop.
  *
  *----------------------------------------------------------------------
  */
 
 static void
-CarbonTimerProc(
-    EventLoopTimerRef timer,
-    void *userData)
+CarbonTimerProc (
+	EventLoopTimerRef timer,
+	void *userData)
 {
-    if (carbonTimerEnabled) {
-	/*
-	 * Avoid starving main event loop: process at most 4 events.
-	 */
-
+    if(carbonTimerEnabled) {
+	/* Avoid starving main event loop: process at most 4 events. */
 	int i = 4;
-	while (--i && Tcl_DoOneEvent(
+	while(--i && Tcl_DoOneEvent(
 		TCL_FILE_EVENTS|TCL_TIMER_EVENTS|TCL_DONT_WAIT)) {
-#ifdef TK_MAC_DEBUG_CARBON_EVENTS
-	    LOG_MSG("Processed tcl event from carbon timer");
+#if defined(TK_MAC_DEBUG) && defined(TK_MAC_DEBUG_CARBON_EVENTS)
+	    fprintf(stderr, "Processed tcl event from carbon timer\n");
 #endif /* TK_MAC_DEBUG_CARBON_EVENTS */
 	}
     }
@@ -400,75 +396,80 @@ CarbonTimerProc(
  *
  * 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 is run by HIToolbox (e.g. during
- *	menutracking) to ensure that non-window non-idle tcl events are
- *	processed.
+ *	  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 is
+ *	  run by HIToolbox (e.g. during menutracking) to ensure that
+ *	  non-window non-idle tcl events are processed.
  *
  * Results:
- *	OS status code.
+ *	  OS status code.
  *
  * Side effects:
- *	Carbon event timer is installed and started.
+ *	  Carbon event timer is installed and started.
  *
  *----------------------------------------------------------------------
  */
 
 MODULE_SCOPE OSStatus
-TkMacOSXStartTclEventLoopCarbonTimer(void)
+TkMacOSXStartTclEventLoopCarbonTimer()
 {
     OSStatus err;
 
-    if (!carbonTimer) {
+    if(!carbonTimer) {
 	EventLoopTimerUPP timerUPP = NewEventLoopTimerUPP(CarbonTimerProc);
-
 	err = InstallEventLoopTimer(GetMainEventLoop(), kEventDurationNoWait,
 		5 * kEventDurationMillisecond, timerUPP, NULL, &carbonTimer);
-	LOG_ON_ERROR(InstallEventLoopTimer);
+	if (err != noErr) {
+#ifdef TK_MAC_DEBUG
+	    fprintf(stderr, "InstallEventLoopTimer failed, %d\n", (int) err);
+#endif
+	}
     } else {
 	err = SetEventLoopTimerNextFireTime(carbonTimer, kEventDurationNoWait);
-	LOG_ON_ERROR(SetEventLoopTimerNextFireTime);
+	if (err != noErr) {
+#ifdef TK_MAC_DEBUG
+	    fprintf(stderr, "SetEventLoopTimerNextFireTime failed, %d\n",
+		    (int) err);
+#endif
+	}
     }
     carbonTimerEnabled = 1;
     return err;
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
  * TkMacOSXStopTclEventLoopCarbonTimer --
  *
- *	This procedure stops the carbon event timer started by
- *	TkMacOSXStartTclEventLoopCarbonTimer().
+ *	  This procedure stops the carbon event timer started by
+ *	  TkMacOSXStartTclEventLoopCarbonTimer().
  *
  * Results:
- *	OS status code.
+ *	  OS status code.
  *
  * Side effects:
- *	Carbon event timer is stopped.
+ *	 Carbon event timer is stopped.
  *
  *----------------------------------------------------------------------
  */
 
 MODULE_SCOPE OSStatus
-TkMacOSXStopTclEventLoopCarbonTimer(void)
+TkMacOSXStopTclEventLoopCarbonTimer()
 {
     OSStatus err = noErr;
 
-    if (carbonTimer) {
-	err = SetEventLoopTimerNextFireTime(carbonTimer,
-		kEventDurationForever);
-	LOG_ON_ERROR(SetEventLoopTimerNextFireTime);
+    if(carbonTimer) {
+	err = SetEventLoopTimerNextFireTime(carbonTimer, kEventDurationForever);
+	if (err != noErr) {
+#ifdef TK_MAC_DEBUG
+	    fprintf(stderr, "SetEventLoopTimerNextFireTime failed, %d\n",
+		    (int) err);
+#endif
+	}
     }
     carbonTimerEnabled = 0;
     return err;
 }
 
-/*
- * Local Variables:
- * mode: c
- * c-basic-offset: 4
- * fill-column: 78
- * End:
- */