Drag.h

Go to the documentation of this file.

 
#ifndef __DRAG__
#define __DRAG__
 
#ifndef __MACTYPES__
#include <MacTypes.h>
#endif
 
#ifndef __EVENTS__
#include <Events.h>
#endif
 
#ifndef __FILES__
#include <Files.h>
#endif
 
#ifndef __APPLEEVENTS__
#include <AppleEvents.h>
#endif
 
#ifndef __QUICKDRAW__
#include <Quickdraw.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
 
  typedef struct OpaqueDragRef *DragRef;
  typedef UInt32 DragItemRef;
  typedef OSType FlavorType;
  typedef UInt32 DragAttributes;
  enum
  {
    kDragHasLeftSenderWindow =
        (1L << 0), 
    kDragInsideSenderApplication =
        (1L << 1), 
    kDragInsideSenderWindow =
        (1L << 2) 
  };
 
  typedef UInt32 DragBehaviors;
  enum
  {
    kDragBehaviorNone = 0,
    kDragBehaviorZoomBackAnimation =
        (1L << 0) 
  };
 
  typedef UInt32 DragImageFlags;
  enum
  {
    kDragRegionAndImage = (1L << 4) 
  };
 
  enum
  {
    kDragStandardTranslucency = 0L, 
    kDragDarkTranslucency = 1L,     
    kDragDarkerTranslucency = 2L,   
    kDragOpaqueTranslucency = 3L    
  };
 
  typedef SInt16 DragRegionMessage;
  enum
  {
    kDragRegionBegin = 1, 
    kDragRegionDraw = 2,  
    kDragRegionHide = 3,  
    kDragRegionIdle = 4,  
    kDragRegionEnd = 5    
  };
 
  typedef SInt16 ZoomAcceleration;
  enum
  {
    kZoomNoAcceleration = 0, 
    kZoomAccelerate = 1,     
    kZoomDecelerate = 2      
  };
 
  typedef UInt32 FlavorFlags;
  enum
  {
    flavorSenderOnly = (1 << 0),       
    flavorSenderTranslated = (1 << 1), 
    flavorNotSaved = (1 << 2),         
    flavorSystemTranslated = (1 << 8), 
    flavorDataPromised = (1 << 9)      
  };
 
  enum
  {
    kDragFlavorTypeHFS = FOUR_CHAR_CODE('hfs '), 
    kDragFlavorTypePromiseHFS =
        FOUR_CHAR_CODE('phfs'),                      
    flavorTypeHFS = kDragFlavorTypeHFS,              
    flavorTypePromiseHFS = kDragFlavorTypePromiseHFS 
  };
 
  enum
  {
    kDragPromisedFlavorFindFile =
        FOUR_CHAR_CODE('rWm1'), 
    kDragPromisedFlavor =
        FOUR_CHAR_CODE('fssP') 
  };
 
  enum
  {
    kDragPseudoCreatorVolumeOrDirectory =
        FOUR_CHAR_CODE('MACS'), 
    kDragPseudoFileTypeVolume =
        FOUR_CHAR_CODE('disk'), 
    kDragPseudoFileTypeDirectory =
        FOUR_CHAR_CODE('fold') 
  };
 
  enum
  {
    flavorTypeDirectory =
        FOUR_CHAR_CODE('diry') 
  };
 
  enum
  {
    kFlavorTypeClippingName = FOUR_CHAR_CODE(
        'clnm'), 
    kFlavorTypeClippingFilename =
        FOUR_CHAR_CODE('clfn'), 
    kFlavorTypeDragToTrashOnly =
        FOUR_CHAR_CODE('fdtt'), 
    kFlavorTypeFinderNoTrackingBehavior = FOUR_CHAR_CODE(
        'fntb') 
  };
 
  typedef SInt16 DragTrackingMessage;
  enum
  {
    kDragTrackingEnterHandler = 1, 
    kDragTrackingEnterWindow = 2,  
    kDragTrackingInWindow = 3,     
    kDragTrackingLeaveWindow = 4,  
    kDragTrackingLeaveHandler = 5  
  };
 
  enum
  {
    kDragActionNothing = 0L,
    kDragActionCopy = 1L,
    kDragActionAlias = (1L << 1),
    kDragActionGeneric = (1L << 2),
    kDragActionPrivate = (1L << 3),
    kDragActionMove = (1L << 4),
    kDragActionDelete = (1L << 5),
    kDragActionAll = (long)0xFFFFFFFF
  };
 
  typedef UInt32 DragActions;
  struct HFSFlavor
  {
    OSType fileType;    
    OSType fileCreator; 
    UInt16 fdFlags;     
    FSSpec fileSpec;    
  };
  typedef struct HFSFlavor HFSFlavor;
  struct PromiseHFSFlavor
  {
    OSType fileType;           
    OSType fileCreator;        
    UInt16 fdFlags;            
    FlavorType promisedFlavor; 
  };
  typedef struct PromiseHFSFlavor PromiseHFSFlavor;
  typedef CALLBACK_API(OSErr,
                       DragTrackingHandlerProcPtr)(DragTrackingMessage message,
                                                   WindowRef theWindow,
                                                   void *handlerRefCon,
                                                   DragRef theDrag);
  typedef CALLBACK_API(OSErr, DragReceiveHandlerProcPtr)(WindowRef theWindow,
                                                         void *handlerRefCon,
                                                         DragRef theDrag);
  typedef STACK_UPP_TYPE(DragTrackingHandlerProcPtr) DragTrackingHandlerUPP;
  typedef STACK_UPP_TYPE(DragReceiveHandlerProcPtr) DragReceiveHandlerUPP;
  DragTrackingHandlerUPP
  NewDragTrackingHandlerUPP(DragTrackingHandlerProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppDragTrackingHandlerProcInfo = 0x00003FA0
  }; 
#ifdef __cplusplus
  inline DragTrackingHandlerUPP
  NewDragTrackingHandlerUPP(DragTrackingHandlerProcPtr userRoutine)
  {
    return (DragTrackingHandlerUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppDragTrackingHandlerProcInfo,
        GetCurrentArchitecture());
  }
#else
#define NewDragTrackingHandlerUPP(userRoutine)                \
  (DragTrackingHandlerUPP) NewRoutineDescriptor(              \
      (ProcPtr)(userRoutine), uppDragTrackingHandlerProcInfo, \
      GetCurrentArchitecture())
#endif
#endif
 
  DragReceiveHandlerUPP
  NewDragReceiveHandlerUPP(DragReceiveHandlerProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppDragReceiveHandlerProcInfo = 0x00000FE0
  }; 
#ifdef __cplusplus
  inline DragReceiveHandlerUPP
  NewDragReceiveHandlerUPP(DragReceiveHandlerProcPtr userRoutine)
  {
    return (DragReceiveHandlerUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppDragReceiveHandlerProcInfo,
        GetCurrentArchitecture());
  }
#else
#define NewDragReceiveHandlerUPP(userRoutine)                                 \
  (DragReceiveHandlerUPP) NewRoutineDescriptor((ProcPtr)(userRoutine),        \
                                               uppDragReceiveHandlerProcInfo, \
                                               GetCurrentArchitecture())
#endif
#endif
 
  void
  DisposeDragTrackingHandlerUPP(DragTrackingHandlerUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeDragTrackingHandlerUPP(DragTrackingHandlerUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeDragTrackingHandlerUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeDragReceiveHandlerUPP(DragReceiveHandlerUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeDragReceiveHandlerUPP(DragReceiveHandlerUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeDragReceiveHandlerUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  OSErr
  InvokeDragTrackingHandlerUPP(DragTrackingMessage message, WindowRef theWindow,
                               void *handlerRefCon, DragRef theDrag,
                               DragTrackingHandlerUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline OSErr InvokeDragTrackingHandlerUPP(DragTrackingMessage message,
                                            WindowRef theWindow,
                                            void *handlerRefCon, DragRef theDrag,
                                            DragTrackingHandlerUPP userUPP)
  {
    return (OSErr)CALL_FOUR_PARAMETER_UPP(userUPP, uppDragTrackingHandlerProcInfo,
                                          message, theWindow, handlerRefCon,
                                          theDrag);
  }
#else
#define InvokeDragTrackingHandlerUPP(message, theWindow, handlerRefCon,      \
                                     theDrag, userUPP)                       \
  (OSErr) CALL_FOUR_PARAMETER_UPP((userUPP), uppDragTrackingHandlerProcInfo, \
                                  (message), (theWindow), (handlerRefCon),   \
                                  (theDrag))
#endif
#endif
 
  OSErr
  InvokeDragReceiveHandlerUPP(WindowRef theWindow, void *handlerRefCon,
                              DragRef theDrag, DragReceiveHandlerUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline OSErr InvokeDragReceiveHandlerUPP(WindowRef theWindow,
                                           void *handlerRefCon, DragRef theDrag,
                                           DragReceiveHandlerUPP userUPP)
  {
    return (OSErr)CALL_THREE_PARAMETER_UPP(userUPP, uppDragReceiveHandlerProcInfo,
                                           theWindow, handlerRefCon, theDrag);
  }
#else
#define InvokeDragReceiveHandlerUPP(theWindow, handlerRefCon, theDrag,       \
                                    userUPP)                                 \
  (OSErr) CALL_THREE_PARAMETER_UPP((userUPP), uppDragReceiveHandlerProcInfo, \
                                   (theWindow), (handlerRefCon), (theDrag))
#endif
#endif
 
#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
#define NewDragTrackingHandlerProc(userRoutine) \
  NewDragTrackingHandlerUPP(userRoutine)
#define NewDragReceiveHandlerProc(userRoutine) \
  NewDragReceiveHandlerUPP(userRoutine)
#define CallDragTrackingHandlerProc(userRoutine, message, theWindow,       \
                                    handlerRefCon, theDrag)                \
  InvokeDragTrackingHandlerUPP(message, theWindow, handlerRefCon, theDrag, \
                               userRoutine)
#define CallDragReceiveHandlerProc(userRoutine, theWindow, handlerRefCon, \
                                   theDrag)                               \
  InvokeDragReceiveHandlerUPP(theWindow, handlerRefCon, theDrag, userRoutine)
#endif 
  typedef CALLBACK_API(OSErr, DragSendDataProcPtr)(FlavorType theType,
                                                   void *dragSendRefCon,
                                                   DragItemRef theItemRef,
                                                   DragRef theDrag);
  typedef CALLBACK_API(OSErr, DragInputProcPtr)(Point *mouse, SInt16 *modifiers,
                                                void *dragInputRefCon,
                                                DragRef theDrag);
  typedef CALLBACK_API(OSErr,
                       DragDrawingProcPtr)(DragRegionMessage message,
                                           RgnHandle showRegion, Point showOrigin,
                                           RgnHandle hideRegion, Point hideOrigin,
                                           void *dragDrawingRefCon,
                                           DragRef theDrag);
  typedef STACK_UPP_TYPE(DragSendDataProcPtr) DragSendDataUPP;
  typedef STACK_UPP_TYPE(DragInputProcPtr) DragInputUPP;
  typedef STACK_UPP_TYPE(DragDrawingProcPtr) DragDrawingUPP;
  DragSendDataUPP
  NewDragSendDataUPP(DragSendDataProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppDragSendDataProcInfo = 0x00003FE0
  }; 
#ifdef __cplusplus
  inline DragSendDataUPP NewDragSendDataUPP(DragSendDataProcPtr userRoutine)
  {
    return (DragSendDataUPP)NewRoutineDescriptor((ProcPtr)(userRoutine),
                                                 uppDragSendDataProcInfo,
                                                 GetCurrentArchitecture());
  }
#else
#define NewDragSendDataUPP(userRoutine)                                     \
  (DragSendDataUPP)                                                         \
      NewRoutineDescriptor((ProcPtr)(userRoutine), uppDragSendDataProcInfo, \
                           GetCurrentArchitecture())
#endif
#endif
 
  DragInputUPP
  NewDragInputUPP(DragInputProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppDragInputProcInfo = 0x00003FE0
  }; 
#ifdef __cplusplus
  inline DragInputUPP NewDragInputUPP(DragInputProcPtr userRoutine)
  {
    return (DragInputUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppDragInputProcInfo, GetCurrentArchitecture());
  }
#else
#define NewDragInputUPP(userRoutine)   \
  (DragInputUPP) NewRoutineDescriptor( \
      (ProcPtr)(userRoutine), uppDragInputProcInfo, GetCurrentArchitecture())
#endif
#endif
 
  DragDrawingUPP
  NewDragDrawingUPP(DragDrawingProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppDragDrawingProcInfo = 0x000FFFA0
  }; 
#ifdef __cplusplus
  inline DragDrawingUPP NewDragDrawingUPP(DragDrawingProcPtr userRoutine)
  {
    return (DragDrawingUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppDragDrawingProcInfo, GetCurrentArchitecture());
  }
#else
#define NewDragDrawingUPP(userRoutine)                                     \
  (DragDrawingUPP)                                                         \
      NewRoutineDescriptor((ProcPtr)(userRoutine), uppDragDrawingProcInfo, \
                           GetCurrentArchitecture())
#endif
#endif
 
  void
  DisposeDragSendDataUPP(DragSendDataUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeDragSendDataUPP(DragSendDataUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeDragSendDataUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeDragInputUPP(DragInputUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeDragInputUPP(DragInputUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeDragInputUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeDragDrawingUPP(DragDrawingUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeDragDrawingUPP(DragDrawingUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeDragDrawingUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  OSErr
  InvokeDragSendDataUPP(FlavorType theType, void *dragSendRefCon,
                        DragItemRef theItemRef, DragRef theDrag,
                        DragSendDataUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline OSErr InvokeDragSendDataUPP(FlavorType theType, void *dragSendRefCon,
                                     DragItemRef theItemRef, DragRef theDrag,
                                     DragSendDataUPP userUPP)
  {
    return (OSErr)CALL_FOUR_PARAMETER_UPP(userUPP, uppDragSendDataProcInfo,
                                          theType, dragSendRefCon, theItemRef,
                                          theDrag);
  }
#else
#define InvokeDragSendDataUPP(theType, dragSendRefCon, theItemRef, theDrag,  \
                              userUPP)                                       \
  (OSErr)                                                                    \
      CALL_FOUR_PARAMETER_UPP((userUPP), uppDragSendDataProcInfo, (theType), \
                              (dragSendRefCon), (theItemRef), (theDrag))
#endif
#endif
 
  OSErr
  InvokeDragInputUPP(Point *mouse, SInt16 *modifiers, void *dragInputRefCon,
                     DragRef theDrag, DragInputUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline OSErr InvokeDragInputUPP(Point *mouse, SInt16 *modifiers,
                                  void *dragInputRefCon, DragRef theDrag,
                                  DragInputUPP userUPP)
  {
    return (OSErr)CALL_FOUR_PARAMETER_UPP(userUPP, uppDragInputProcInfo, mouse,
                                          modifiers, dragInputRefCon, theDrag);
  }
#else
#define InvokeDragInputUPP(mouse, modifiers, dragInputRefCon, theDrag,      \
                           userUPP)                                         \
  (OSErr) CALL_FOUR_PARAMETER_UPP((userUPP), uppDragInputProcInfo, (mouse), \
                                  (modifiers), (dragInputRefCon), (theDrag))
#endif
#endif
 
  OSErr
  InvokeDragDrawingUPP(DragRegionMessage message, RgnHandle showRegion,
                       Point showOrigin, RgnHandle hideRegion, Point hideOrigin,
                       void *dragDrawingRefCon, DragRef theDrag,
                       DragDrawingUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline OSErr InvokeDragDrawingUPP(DragRegionMessage message,
                                    RgnHandle showRegion, Point showOrigin,
                                    RgnHandle hideRegion, Point hideOrigin,
                                    void *dragDrawingRefCon, DragRef theDrag,
                                    DragDrawingUPP userUPP)
  {
    return (OSErr)CALL_SEVEN_PARAMETER_UPP(
        userUPP, uppDragDrawingProcInfo, message, showRegion, showOrigin,
        hideRegion, hideOrigin, dragDrawingRefCon, theDrag);
  }
#else
#define InvokeDragDrawingUPP(message, showRegion, showOrigin, hideRegion,     \
                             hideOrigin, dragDrawingRefCon, theDrag, userUPP) \
  (OSErr)                                                                     \
      CALL_SEVEN_PARAMETER_UPP((userUPP), uppDragDrawingProcInfo, (message),  \
                               (showRegion), (showOrigin), (hideRegion),      \
                               (hideOrigin), (dragDrawingRefCon), (theDrag))
#endif
#endif
 
#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
#define NewDragSendDataProc(userRoutine) NewDragSendDataUPP(userRoutine)
#define NewDragInputProc(userRoutine) NewDragInputUPP(userRoutine)
#define NewDragDrawingProc(userRoutine) NewDragDrawingUPP(userRoutine)
#define CallDragSendDataProc(userRoutine, theType, dragSendRefCon, theItemRef, \
                             theDrag)                                          \
  InvokeDragSendDataUPP(theType, dragSendRefCon, theItemRef, theDrag,          \
                        userRoutine)
#define CallDragInputProc(userRoutine, mouse, modifiers, dragInputRefCon, \
                          theDrag)                                        \
  InvokeDragInputUPP(mouse, modifiers, dragInputRefCon, theDrag, userRoutine)
#define CallDragDrawingProc(userRoutine, message, showRegion, showOrigin, \
                            hideRegion, hideOrigin, dragDrawingRefCon,    \
                            theDrag)                                      \
  InvokeDragDrawingUPP(message, showRegion, showOrigin, hideRegion,       \
                       hideOrigin, dragDrawingRefCon, theDrag, userRoutine)
#endif 
  OSErr
  InstallTrackingHandler(DragTrackingHandlerUPP trackingHandler,
                         WindowRef theWindow, void *handlerRefCon);
 
  OSErr
  InstallReceiveHandler(DragReceiveHandlerUPP receiveHandler, WindowRef theWindow,
                        void *handlerRefCon);
 
  OSErr
  RemoveTrackingHandler(DragTrackingHandlerUPP trackingHandler,
                        WindowRef theWindow);
 
  OSErr
  RemoveReceiveHandler(DragReceiveHandlerUPP receiveHandler, WindowRef theWindow);
 
  OSErr
  NewDrag(DragRef *theDrag);
 
  OSErr
  DisposeDrag(DragRef theDrag);
 
  OSErr
  AddDragItemFlavor(DragRef theDrag, DragItemRef theItemRef, FlavorType theType,
                    const void *dataPtr, Size dataSize, FlavorFlags theFlags);
 
  OSErr
  SetDragItemFlavorData(DragRef theDrag, DragItemRef theItemRef,
                        FlavorType theType, const void *dataPtr, Size dataSize,
                        UInt32 dataOffset);
 
  OSErr
  SetDragSendProc(DragRef theDrag, DragSendDataUPP sendProc, void *dragSendRefCon);
 
  OSErr
  SetDragInputProc(DragRef theDrag, DragInputUPP inputProc, void *dragInputRefCon);
 
  OSErr
  SetDragDrawingProc(DragRef theDrag, DragDrawingUPP drawingProc,
                     void *dragDrawingRefCon);
 
  OSErr
  SetDragImage(DragRef theDrag, PixMapHandle imagePixMap, RgnHandle imageRgn,
               Point imageOffsetPt, DragImageFlags theImageFlags);
 
  OSErr
  ChangeDragBehaviors(DragRef theDrag, DragBehaviors inBehaviorsToSet,
                      DragBehaviors inBehaviorsToClear);
 
  OSErr
  TrackDrag(DragRef theDrag, const EventRecord *theEvent, RgnHandle theRegion);
 
  OSErr
  CountDragItems(DragRef theDrag, UInt16 *numItems);
 
  OSErr
  GetDragItemReferenceNumber(DragRef theDrag, UInt16 index,
                             DragItemRef *theItemRef);
 
  OSErr
  CountDragItemFlavors(DragRef theDrag, DragItemRef theItemRef,
                       UInt16 *numFlavors);
 
  OSErr
  GetFlavorType(DragRef theDrag, DragItemRef theItemRef, UInt16 index,
                FlavorType *theType);
 
  OSErr
  GetFlavorFlags(DragRef theDrag, DragItemRef theItemRef, FlavorType theType,
                 FlavorFlags *theFlags);
 
  OSErr
  GetFlavorDataSize(DragRef theDrag, DragItemRef theItemRef, FlavorType theType,
                    Size *dataSize);
 
  OSErr
  GetFlavorData(DragRef theDrag, DragItemRef theItemRef, FlavorType theType,
                void *dataPtr, Size *dataSize, UInt32 dataOffset);
 
  OSErr
  GetDragItemBounds(DragRef theDrag, DragItemRef theItemRef, Rect *itemBounds);
 
  OSErr
  SetDragItemBounds(DragRef theDrag, DragItemRef theItemRef,
                    const Rect *itemBounds);
 
  OSErr
  GetDropLocation(DragRef theDrag, AEDesc *dropLocation);
 
  OSErr
  SetDropLocation(DragRef theDrag, const AEDesc *dropLocation);
 
  OSErr
  GetDragAttributes(DragRef theDrag, DragAttributes *flags);
 
  OSErr
  GetDragMouse(DragRef theDrag, Point *mouse, Point *globalPinnedMouse);
 
  OSErr
  SetDragMouse(DragRef theDrag, Point globalPinnedMouse);
 
  OSErr
  GetDragOrigin(DragRef theDrag, Point *globalInitialMouse);
 
  OSErr
  GetDragModifiers(DragRef theDrag, SInt16 *modifiers, SInt16 *mouseDownModifiers,
                   SInt16 *mouseUpModifiers);
 
  OSStatus
  GetDragAllowableActions(DragRef theDrag, DragActions *outActions);
 
  OSStatus
  SetDragAllowableActions(DragRef theDrag, DragActions inActions,
                          Boolean isLocal);
 
  OSStatus
  GetDragDropAction(DragRef theDrag, DragActions *outAction);
 
  OSStatus
  SetDragDropAction(DragRef theDrag, DragActions inAction);
 
  OSErr
  ShowDragHilite(DragRef theDrag, RgnHandle hiliteFrame, Boolean inside);
 
  OSErr
  HideDragHilite(DragRef theDrag);
 
  OSErr
  DragPreScroll(DragRef theDrag, SInt16 dH, SInt16 dV);
 
  OSErr
  DragPostScroll(DragRef theDrag);
 
  OSErr
  UpdateDragHilite(DragRef theDrag, RgnHandle updateRgn);
 
  OSErr
  GetDragHiliteColor(WindowRef window, RGBColor *color);
 
  Boolean
  WaitMouseMoved(Point initialMouse);
 
  OSErr
  ZoomRects(const Rect *fromRect, const Rect *toRect, SInt16 zoomSteps,
            ZoomAcceleration acceleration);
 
  OSErr
  ZoomRegion(RgnHandle region, Point zoomDistance, SInt16 zoomSteps,
             ZoomAcceleration acceleration);
 
  typedef DragRef DragReference;
  typedef DragItemRef ItemReference;
#if OLDROUTINENAMES
  enum
  {
    dragHasLeftSenderWindow =
        kDragHasLeftSenderWindow, 
    dragInsideSenderApplication =
        kDragInsideSenderApplication, 
    dragInsideSenderWindow =
        kDragInsideSenderWindow 
  };
 
  enum
  {
    dragTrackingEnterHandler =
        kDragTrackingEnterHandler, 
    dragTrackingEnterWindow =
        kDragTrackingEnterWindow, 
    dragTrackingInWindow =
        kDragTrackingInWindow, 
    dragTrackingLeaveWindow =
        kDragTrackingLeaveWindow, 
    dragTrackingLeaveHandler =
        kDragTrackingLeaveHandler 
  };
 
  enum
  {
    dragRegionBegin = kDragRegionBegin, 
    dragRegionDraw = kDragRegionDraw,   
    dragRegionHide = kDragRegionHide,   
    dragRegionIdle = kDragRegionIdle,   
    dragRegionEnd = kDragRegionEnd      
  };
 
  enum
  {
    zoomNoAcceleration = kZoomNoAcceleration, 
    zoomAccelerate = kZoomAccelerate,         
    zoomDecelerate = kZoomDecelerate          
  };
 
  enum
  {
    kDragStandardImage =
        kDragStandardTranslucency,              
    kDragDarkImage = kDragDarkTranslucency,     
    kDragDarkerImage = kDragDarkerTranslucency, 
    kDragOpaqueImage =
        kDragOpaqueTranslucency 
  };
 
#endif 
#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