Events.h

Go to the documentation of this file.

 
#ifndef __EVENTS__
#define __EVENTS__
 
#ifndef __OSUTILS__
#include <OSUtils.h>
#endif
 
#ifndef __QUICKDRAW__
#include <Quickdraw.h>
#endif
 
#ifndef __MACTYPES__
#include <MacTypes.h>
#endif
 
#if !TARGET_OS_MAC || !TARGET_API_MAC_OS8
#ifndef __ENDIAN__
#include <Endian.h>
#endif
 
#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
 
  typedef UInt16 EventKind;
  typedef UInt16 EventMask;
  enum
  {
    nullEvent = 0,
    mouseDown = 1,
    mouseUp = 2,
    keyDown = 3,
    keyUp = 4,
    autoKey = 5,
    updateEvt = 6,
    diskEvt = 7, 
    activateEvt = 8,
    osEvt = 15,
    kHighLevelEvent = 23
  };
 
  enum
  {
    mDownMask = 1 << mouseDown,   
    mUpMask = 1 << mouseUp,       
    keyDownMask = 1 << keyDown,   
    keyUpMask = 1 << keyUp,       
    autoKeyMask = 1 << autoKey,   
    updateMask = 1 << updateEvt,  
    diskMask = 1 << diskEvt,      
    activMask = 1 << activateEvt, 
    highLevelEventMask = 0x0400,  
    osMask = 1 << osEvt,          
    everyEvent = 0xFFFF           
  };
 
  enum
  {
    charCodeMask = 0x000000FF,
    keyCodeMask = 0x0000FF00,
    adbAddrMask = 0x00FF0000,
    osEvtMessageMask = (unsigned long)0xFF000000
  };
 
  enum
  {
    mouseMovedMessage = 0x00FA,
    suspendResumeMessage = 0x0001
  };
 
  enum
  {
    resumeFlag = 1 
  };
 
#if CALL_NOT_IN_CARBON
  enum
  {
    convertClipboardFlag =
        2 
  };
 
#endif 
  typedef UInt16 EventModifiers;
  enum
  {
    activeFlagBit = 0,      
    btnStateBit = 7,        
    cmdKeyBit = 8,          
    shiftKeyBit = 9,        
    alphaLockBit = 10,      
    optionKeyBit = 11,      
    controlKeyBit = 12,     
    rightShiftKeyBit = 13,  
    rightOptionKeyBit = 14, 
    rightControlKeyBit = 15 
  };
 
  enum
  {
    activeFlag = 1 << activeFlagBit,
    btnState = 1 << btnStateBit,
    cmdKey = 1 << cmdKeyBit,
    shiftKey = 1 << shiftKeyBit,
    alphaLock = 1 << alphaLockBit,
    optionKey = 1 << optionKeyBit,
    controlKey = 1 << controlKeyBit,
    rightShiftKey = 1 << rightShiftKeyBit,
    rightOptionKey = 1 << rightOptionKeyBit,
    rightControlKey = 1 << rightControlKeyBit
  };
 
  enum
  {
    kNullCharCode = 0,
    kHomeCharCode = 1,
    kEnterCharCode = 3,
    kEndCharCode = 4,
    kHelpCharCode = 5,
    kBellCharCode = 7,
    kBackspaceCharCode = 8,
    kTabCharCode = 9,
    kLineFeedCharCode = 10,
    kVerticalTabCharCode = 11,
    kPageUpCharCode = 11,
    kFormFeedCharCode = 12,
    kPageDownCharCode = 12,
    kReturnCharCode = 13,
    kFunctionKeyCharCode = 16,
    kCommandCharCode = 17,   
    kCheckCharCode = 18,     
    kDiamondCharCode = 19,   
    kAppleLogoCharCode = 20, 
    kEscapeCharCode = 27,
    kClearCharCode = 27,
    kLeftArrowCharCode = 28,
    kRightArrowCharCode = 29,
    kUpArrowCharCode = 30,
    kDownArrowCharCode = 31,
    kSpaceCharCode = 32,
    kDeleteCharCode = 127,
    kBulletCharCode = 165,
    kNonBreakingSpaceCharCode = 202
  };
 
  enum
  {
    kShiftUnicode = 0x21E7,    
    kControlUnicode = 0x2303,  
    kOptionUnicode = 0x2325,   
    kCommandUnicode = 0x2318,  
    kPencilUnicode = 0x270E,   
    kCheckUnicode = 0x2713,    
    kDiamondUnicode = 0x25C6,  
    kBulletUnicode = 0x2022,   
    kAppleLogoUnicode = 0xF8FF 
  };
 
  struct EventRecord
  {
    EventKind what;
    UInt32 message;
    UInt32 when;
    Point where;
    EventModifiers modifiers;
  };
  typedef struct EventRecord EventRecord;
  typedef CALLBACK_API(void, FKEYProcPtr)(void);
  typedef STACK_UPP_TYPE(FKEYProcPtr) FKEYUPP;
#if CALL_NOT_IN_CARBON
  FKEYUPP
  NewFKEYUPP(FKEYProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppFKEYProcInfo = 0x00000000
  }; 
#ifdef __cplusplus
  inline FKEYUPP NewFKEYUPP(FKEYProcPtr userRoutine)
  {
    return (FKEYUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppFKEYProcInfo,
                                         GetCurrentArchitecture());
  }
#else
#define NewFKEYUPP(userRoutine)                                           \
  (FKEYUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppFKEYProcInfo, \
                                 GetCurrentArchitecture())
#endif
#endif
 
  void
  DisposeFKEYUPP(FKEYUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeFKEYUPP(FKEYUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeFKEYUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  InvokeFKEYUPP(FKEYUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokeFKEYUPP(FKEYUPP userUPP)
  {
    CALL_ZERO_PARAMETER_UPP(userUPP, uppFKEYProcInfo);
  }
#else
#define InvokeFKEYUPP(userUPP) \
  CALL_ZERO_PARAMETER_UPP((userUPP), uppFKEYProcInfo)
#endif
#endif
 
#endif 
#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
#define NewFKEYProc(userRoutine) NewFKEYUPP(userRoutine)
#define CallFKEYProc(userRoutine) InvokeFKEYUPP(userRoutine)
#endif 
  void
  GetMouse(Point *mouseLoc);
 
  Boolean
  Button(void);
 
  Boolean
  StillDown(void);
 
  Boolean
  WaitMouseUp(void);
 
  UInt32
  KeyTranslate(const void *transData, UInt16 keycode, UInt32 *state);
 
  UInt32
  GetCaretTime(void);
 
#if TARGET_OS_MAC && TARGET_API_MAC_OS8
 
  typedef UInt32 KeyMap[4];
#else
typedef BigEndianLong KeyMap[4];
#endif 
  typedef UInt8 KeyMapByteArray[16];
  void
  GetKeys(KeyMap theKeys);
 
  enum
  {
    networkEvt = 10,
    driverEvt = 11,
    app1Evt = 12,
    app2Evt = 13,
    app3Evt = 14,
    app4Evt = 15,
    networkMask = 0x0400,
    driverMask = 0x0800,
    app1Mask = 0x1000,
    app2Mask = 0x2000,
    app3Mask = 0x4000,
    app4Mask = 0x8000
  };
 
  struct EvQEl
  {
    QElemPtr qLink;
    SInt16 qType;
    EventKind evtQWhat; 
    UInt32 evtQMessage;
    UInt32 evtQWhen;
    Point evtQWhere;
    EventModifiers evtQModifiers;
  };
  typedef struct EvQEl EvQEl;
  typedef EvQEl *EvQElPtr;
  typedef CALLBACK_API_REGISTER68K(void, GetNextEventFilterProcPtr,
                                   (EventRecord * theEvent, Boolean *result));
  typedef REGISTER_UPP_TYPE(GetNextEventFilterProcPtr) GetNextEventFilterUPP;
#if CALL_NOT_IN_CARBON
  GetNextEventFilterUPP
  NewGetNextEventFilterUPP(GetNextEventFilterProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppGetNextEventFilterProcInfo = 0x000000BF
  }; 
#ifdef __cplusplus
  inline GetNextEventFilterUPP
  NewGetNextEventFilterUPP(GetNextEventFilterProcPtr userRoutine)
  {
    return (GetNextEventFilterUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppGetNextEventFilterProcInfo,
        GetCurrentArchitecture());
  }
#else
#define NewGetNextEventFilterUPP(userRoutine)                                 \
  (GetNextEventFilterUPP) NewRoutineDescriptor((ProcPtr)(userRoutine),        \
                                               uppGetNextEventFilterProcInfo, \
                                               GetCurrentArchitecture())
#endif
#endif
 
  void
  DisposeGetNextEventFilterUPP(GetNextEventFilterUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeGetNextEventFilterUPP(GetNextEventFilterUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeGetNextEventFilterUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  InvokeGetNextEventFilterUPP(EventRecord *theEvent, Boolean *result,
                              GetNextEventFilterUPP userUPP);
#if !OPAQUE_UPP_TYPES && \
    (!TARGET_OS_MAC || !TARGET_CPU_68K || TARGET_RT_MAC_CFM)
#ifdef __cplusplus
  inline void InvokeGetNextEventFilterUPP(EventRecord *theEvent, Boolean *result,
                                          GetNextEventFilterUPP userUPP)
  {
    CALL_TWO_PARAMETER_UPP(userUPP, uppGetNextEventFilterProcInfo, theEvent,
                           result);
  }
#else
#define InvokeGetNextEventFilterUPP(theEvent, result, userUPP)                 \
  CALL_TWO_PARAMETER_UPP((userUPP), uppGetNextEventFilterProcInfo, (theEvent), \
                         (result))
#endif
#endif
 
#endif 
#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
#define NewGetNextEventFilterProc(userRoutine) \
  NewGetNextEventFilterUPP(userRoutine)
#define CallGetNextEventFilterProc(userRoutine, theEvent, result) \
  InvokeGetNextEventFilterUPP(theEvent, result, userRoutine)
#endif 
  typedef GetNextEventFilterUPP GNEFilterUPP;
 
}
if (theEvent.what == keyDown)
{
  </ pre>
              * \copyright THINK Reference © 1991 - 1992 Symantec Corporation
                                                        *    \non_carbon_cfm in InterfaceLib 7.1 and
      later
          *    \carbon_lib in CarbonLib 1.0 and
      later
          *    \mac_os_x in version 10.0 and
      later
              * /
          UInt32
              GetDblTime(void);
 
  void
  SetEventMask(EventMask value);
 
#if CALL_NOT_IN_CARBON
 
  QHdrPtr
  GetEvQHdr(void);
 
#endif 
#if CALL_NOT_IN_CARBON
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PPostEvent(__A0, __D0, __A1)
#endif
  OSErr
  PPostEvent(EventKind eventCode, UInt32 eventMsg, EvQElPtr * qEl);
 
#endif 
  Boolean
  GetNextEvent(EventMask eventMask, EventRecord * theEvent);
 
  Boolean
  WaitNextEvent(EventMask eventMask, EventRecord * theEvent, UInt32 sleep,
                RgnHandle mouseRgn) ;
 
  Boolean
  EventAvail(EventMask eventMask, EventRecord * theEvent);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 PostEvent(__A0, __D0)
#endif
  OSErr
  PostEvent(EventKind eventNum, UInt32 eventMsg);
 
#if CALL_NOT_IN_CARBON
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 OSEventAvail(__D0, __A0)
#endif
  Boolean
  OSEventAvail(EventMask mask, EventRecord * theEvent);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __D0 GetOSEvent(__D0, __A0)
#endif
  Boolean
  GetOSEvent(EventMask mask, EventRecord * theEvent);
 
#endif 
  void
  FlushEvents(EventMask whichMask, EventMask stopMask);
 
#if CALL_NOT_IN_CARBON
  void
  SystemClick(const EventRecord *theEvent, WindowRef theWindow);
 
  EventLoop(); /* ExitToShell elsewhere */
}
EventLoop()
{
  MaintainCursor();
  MaintainMenus();
  SystemTask();
  if (GetNextEvent(everyEvent, &theEvent))
  {
    .....process events...
        .
  }
}
DAs wanting a timeslice every so often should set bit 5 of the drvrFlags
    word and a tick count in drvrDelay in the driver header.You should not depend on any particular accuracy,
    since an application may fail to call
        SystemTask often
        enough(e.g., when saving a file)
            .To receive periodic
    timeslices with more accuracy,
    install a vertical retrace task via VInstall
        or a timer interrupt task via InsTime.</ pre>
                       * \copyright THINK Reference © 1991 -
                   1992 Symantec Corporation
                       *    \non_carbon_cfm in InterfaceLib 7.1 and
               later
                       *    \carbon_lib not available
                   *    \mac_os_x not available
                   * /
                   void
                       SystemTask(void);
 
Boolean
SystemEvent(const EventRecord *theEvent);
 
#endif 
#if OLDROUTINENAMES
#define KeyTrans(transData, keycode, state) \
  KeyTranslate(transData, keycode, state)
#endif 
void
GetGlobalMouse(Point *globalMouse);
 
UInt32
GetCurrentKeyModifiers(void);
 
Boolean
CheckEventQueueForUserCancel(void);
 
typedef struct OpaqueEventRef *EventRef;
void
KeyScript(short code);
 
Boolean
IsCmdChar(const EventRecord *event, short test);
 
SInt16
LMGetKeyThresh(void);
 
void
LMSetKeyThresh(SInt16 value);
 
SInt16
LMGetKeyRepThresh(void);
 
void
LMSetKeyRepThresh(SInt16 value);
 
UInt8
LMGetKbdLast(void);
 
void
LMSetKbdLast(UInt8 value);
 
UInt8
LMGetKbdType(void);
 
void
LMSetKbdType(UInt8 value);
 
#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 
* /*/*/ * /*/*/ * /*/*/ */*/