AEInteraction.h

Go to the documentation of this file.

 
#ifndef __AEINTERACTION__
#define __AEINTERACTION__
 
#ifndef __AEDATAMODEL__
#include <AEDataModel.h>
#endif
 
#ifndef __NOTIFICATION__
#include <Notification.h>
#endif
 
#ifndef __EVENTS__
#include <Events.h>
#endif
 
#if PRAGMA_ONCE
#pragma once
#endif
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#if PRAGMA_IMPORT
#pragma import on
#endif
 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = mac68k
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(push, 2)
#elif PRAGMA_STRUCT_PACK
#pragma pack(2)
#endif
 
  /**************************************************************************
    AppleEvent callbacks.
  **************************************************************************/
  typedef CALLBACK_API(Boolean, AEIdleProcPtr)(EventRecord *theEvent,
                                               long *sleepTime,
                                               RgnHandle *mouseRgn);
  typedef CALLBACK_API(Boolean, AEFilterProcPtr)(EventRecord *theEvent,
                                                 long returnID,
                                                 long transactionID,
                                                 const AEAddressDesc *sender);
  typedef STACK_UPP_TYPE(AEIdleProcPtr) AEIdleUPP;
  typedef STACK_UPP_TYPE(AEFilterProcPtr) AEFilterUPP;
 
  /**************************************************************************
    The next couple of calls are basic routines used to create, send,
    and process AppleEvents.
  **************************************************************************/
  OSErr
  AESend(const AppleEvent *theAppleEvent, AppleEvent *reply, AESendMode sendMode,
         AESendPriority sendPriority, long timeOutInTicks,
         AEIdleUPP idleProc, /* can be NULL */
         AEFilterUPP filterProc) /* can be NULL */;
 
  OSErr
  AEProcessAppleEvent(const EventRecord *theEventRecord);
 
  OSErr
  AEResetTimer(const AppleEvent *reply);
 
  /**************************************************************************
    The following three calls are used to allow applications to behave
    courteously when a user interaction such as a dialog box is needed.
  **************************************************************************/
 
  typedef SInt8 AEInteractAllowed;
  enum
  {
    kAEInteractWithSelf = 0,
    kAEInteractWithLocal = 1,
    kAEInteractWithAll = 2
  };
 
  OSErr
  AEGetInteractionAllowed(AEInteractAllowed *level);
 
  OSErr
  AESetInteractionAllowed(AEInteractAllowed level);
 
  OSErr
  AEInteractWithUser(long timeOutInTicks, NMRecPtr nmReqPtr, AEIdleUPP idleProc);
 
  /**************************************************************************
   The following four calls are available for applications which need more
   sophisticated control over when and how events are processed. Applications
   which implement multi-session servers or which implement their own
   internal event queueing will probably be the major clients of these
   routines. They can be called from within a handler to prevent the AEM from
   disposing of the AppleEvent when the handler returns. They can be used to
   asynchronously process the event (as MacApp does).
  **************************************************************************/
 
  OSErr
  AESuspendTheCurrentEvent(const AppleEvent *theAppleEvent);
 
  /* Constants for Refcon in AEResumeTheCurrentEvent with kAEUseStandardDispatch
   */
  enum
  {
    kAEDoNotIgnoreHandler = 0x00000000,
    kAEIgnoreAppPhacHandler =
        0x00000001, /* available only in vers 1.0.1 and greater */
    kAEIgnoreAppEventHandler =
        0x00000002, /* available only in vers 1.0.1 and greater */
    kAEIgnoreSysPhacHandler =
        0x00000004, /* available only in vers 1.0.1 and greater */
    kAEIgnoreSysEventHandler =
        0x00000008, /* available only in vers 1.0.1 and greater */
    kAEIngoreBuiltInEventHandler =
        0x00000010, /* available only in vers 1.0.1 and greater */
    kAEDontDisposeOnResume =
        (long)0x80000000 /* available only in vers 1.0.1 and greater */
  };
 
  /* Constants for AEResumeTheCurrentEvent */
  enum
  {
    kAENoDispatch = 0, /* dispatch parameter to AEResumeTheCurrentEvent takes a
                          pointer to a dispatch */
    kAEUseStandardDispatch =
        (long)0xFFFFFFFF /* table, or one of these two constants */
  };
 
  OSErr
  AEResumeTheCurrentEvent(const AppleEvent *theAppleEvent,
                          const AppleEvent *reply,
                          AEEventHandlerUPP dispatcher, /* can be NULL */
                          long handlerRefcon);
 
  OSErr
  AEGetTheCurrentEvent(AppleEvent *theAppleEvent);
 
  OSErr
  AESetTheCurrentEvent(const AppleEvent *theAppleEvent);
 
  /**************************************************************************
    AppleEvent callbacks.
  **************************************************************************/
  AEIdleUPP
  NewAEIdleUPP(AEIdleProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppAEIdleProcInfo = 0x00000FD0
  }; /* pascal 1_byte Func(4_bytes, 4_bytes, 4_bytes) */
#ifdef __cplusplus
  inline AEIdleUPP NewAEIdleUPP(AEIdleProcPtr userRoutine)
  {
    return (AEIdleUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppAEIdleProcInfo, GetCurrentArchitecture());
  }
#else
#define NewAEIdleUPP(userRoutine)                                             \
  (AEIdleUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppAEIdleProcInfo, \
                                   GetCurrentArchitecture())
#endif
#endif
 
  AEFilterUPP
  NewAEFilterUPP(AEFilterProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppAEFilterProcInfo = 0x00003FD0
  }; /* pascal 1_byte Func(4_bytes, 4_bytes, 4_bytes, 4_bytes) */
#ifdef __cplusplus
  inline AEFilterUPP NewAEFilterUPP(AEFilterProcPtr userRoutine)
  {
    return (AEFilterUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppAEFilterProcInfo, GetCurrentArchitecture());
  }
#else
#define NewAEFilterUPP(userRoutine)   \
  (AEFilterUPP) NewRoutineDescriptor( \
      (ProcPtr)(userRoutine), uppAEFilterProcInfo, GetCurrentArchitecture())
#endif
#endif
 
  void
  DisposeAEIdleUPP(AEIdleUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeAEIdleUPP(AEIdleUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeAEIdleUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeAEFilterUPP(AEFilterUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeAEFilterUPP(AEFilterUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeAEFilterUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  Boolean
  InvokeAEIdleUPP(EventRecord *theEvent, long *sleepTime, RgnHandle *mouseRgn,
                  AEIdleUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline Boolean InvokeAEIdleUPP(EventRecord *theEvent, long *sleepTime,
                                 RgnHandle *mouseRgn, AEIdleUPP userUPP)
  {
    return (Boolean)CALL_THREE_PARAMETER_UPP(userUPP, uppAEIdleProcInfo, theEvent,
                                             sleepTime, mouseRgn);
  }
#else
#define InvokeAEIdleUPP(theEvent, sleepTime, mouseRgn, userUPP)                \
  (Boolean) CALL_THREE_PARAMETER_UPP((userUPP), uppAEIdleProcInfo, (theEvent), \
                                     (sleepTime), (mouseRgn))
#endif
#endif
 
  Boolean
  InvokeAEFilterUPP(EventRecord *theEvent, long returnID, long transactionID,
                    const AEAddressDesc *sender, AEFilterUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline Boolean InvokeAEFilterUPP(EventRecord *theEvent, long returnID,
                                   long transactionID,
                                   const AEAddressDesc *sender,
                                   AEFilterUPP userUPP)
  {
    return (Boolean)CALL_FOUR_PARAMETER_UPP(
        userUPP, uppAEFilterProcInfo, theEvent, returnID, transactionID, sender);
  }
#else
#define InvokeAEFilterUPP(theEvent, returnID, transactionID, sender, userUPP) \
  (Boolean)                                                                   \
      CALL_FOUR_PARAMETER_UPP((userUPP), uppAEFilterProcInfo, (theEvent),     \
                              (returnID), (transactionID), (sender))
#endif
#endif
 
#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
/* support for pre-Carbon UPP routines: New...Proc and Call...Proc */
#define NewAEIdleProc(userRoutine) NewAEIdleUPP(userRoutine)
#define NewAEFilterProc(userRoutine) NewAEFilterUPP(userRoutine)
#define CallAEIdleProc(userRoutine, theEvent, sleepTime, mouseRgn) \
  InvokeAEIdleUPP(theEvent, sleepTime, mouseRgn, userRoutine)
#define CallAEFilterProc(userRoutine, theEvent, returnID, transactionID, \
                         sender)                                         \
  InvokeAEFilterUPP(theEvent, returnID, transactionID, sender, userRoutine)
#endif /* CALL_NOT_IN_CARBON */
 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = reset
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(pop)
#elif PRAGMA_STRUCT_PACK
#pragma pack()
#endif
 
#ifdef PRAGMA_IMPORT_OFF
#pragma import off
#elif PRAGMA_IMPORT
#pragma import reset
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif /* __AEINTERACTION__ */
* /*/*/ * /