home *** CD-ROM | disk | FTP | other *** search
/ Mac Power 1997 January / macpower199701.bin / AMUG / Programming_10 / WASTE 1.3a1.sit / WASTE 1.3a1 Distribution / Extras / Provisional Translucency APIs / Drag.h next >
Encoding:
C/C++ Source or Header  |  1996-08-23  |  17.0 KB  |  438 lines  |  [TEXT/CWIE]
  1. /*
  2.      File:        Drag.h
  3.  
  4.      Contains:    Drag and Drop Interfaces.
  5.  
  6.      Version:    Technology:    Macintosh Drag and Drop 1.1
  7.                  Package:    Universal Interfaces 2.1 in ﾒMPW Latestﾓ on ETO #18
  8.                  1996-06-20 MP: Added translucency APIs
  9.  
  10.      Copyright:    ｩ 1984-1995 by Apple Computer, Inc.
  11.                  All rights reserved.
  12.  
  13.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  14.                  stack.  Include the file and version information (from above)
  15.                  in the problem description and send to:
  16.                      Internet:    apple.bugs@applelink.apple.com
  17.                      AppleLink:    APPLE.BUGS
  18.  
  19. */
  20.  
  21. #ifndef __DRAG__
  22. #define __DRAG__
  23.  
  24.  
  25. #ifndef __APPLEEVENTS__
  26. #include <AppleEvents.h>
  27. #endif
  28. /*    #include <Errors.h>                                            */
  29. /*        #include <ConditionalMacros.h>                            */
  30. /*    #include <Types.h>                                            */
  31. /*    #include <Memory.h>                                            */
  32. /*        #include <MixedMode.h>                                    */
  33. /*    #include <OSUtils.h>                                        */
  34. /*    #include <Events.h>                                            */
  35. /*        #include <Quickdraw.h>                                    */
  36. /*            #include <QuickdrawText.h>                            */
  37. /*    #include <EPPC.h>                                            */
  38. /*        #include <AppleTalk.h>                                    */
  39. /*        #include <Files.h>                                        */
  40. /*            #include <Finder.h>                                    */
  41. /*        #include <PPCToolbox.h>                                    */
  42. /*        #include <Processes.h>                                    */
  43. /*    #include <Notification.h>                                    */
  44.  
  45. #ifndef __TEXTEDIT__
  46. #include <TextEdit.h>
  47. #endif
  48.  
  49. #ifdef __cplusplus
  50. extern "C" {
  51. #endif
  52.  
  53. #if PRAGMA_ALIGN_SUPPORTED
  54. #pragma options align=mac68k
  55. #endif
  56.  
  57. #if PRAGMA_IMPORT_SUPPORTED
  58. #pragma import on
  59. #endif
  60.  
  61.  
  62. enum {
  63. /* Flavor Flags */
  64.     flavorSenderOnly            = 0x00000001L,                    /* flavor is available to sender only */
  65.     flavorSenderTranslated        = 0x00000002L,                    /* flavor is translated by sender */
  66.     flavorNotSaved                = 0x00000004L,                    /* flavor should not be saved */
  67.     flavorSystemTranslated        = 0x00000100L                    /* flavor is translated by system */
  68. };
  69.  
  70. typedef unsigned long FlavorFlags;
  71.  
  72.  
  73. enum {
  74. /* Drag Attributes */
  75.     dragHasLeftSenderWindow        = 0x00000001L,                    /* drag has left the source window since TrackDrag */
  76.     dragInsideSenderApplication    = 0x00000002L,                    /* drag is occurring within the sender application */
  77.     dragInsideSenderWindow        = 0x00000004L                    /* drag is occurring within the sender window */
  78. };
  79.  
  80. typedef unsigned long DragAttributes;
  81.  
  82.  
  83. enum {
  84. /* Special Flavor Types */
  85.     flavorTypeHFS                = 'hfs ',                        /* flavor type for HFS data */
  86.     flavorTypePromiseHFS        = 'phfs',                        /* flavor type for promised HFS data */
  87.     flavorTypeDirectory            = 'diry'
  88. };
  89.  
  90. enum {
  91. /* Drag Tracking Handler Messages */
  92.     dragTrackingEnterHandler    = 1,                            /* drag has entered handler */
  93.     dragTrackingEnterWindow        = 2,                            /* drag has entered window */
  94.     dragTrackingInWindow        = 3,                            /* drag is moving within window */
  95.     dragTrackingLeaveWindow        = 4,                            /* drag has exited window */
  96.     dragTrackingLeaveHandler    = 5                                /* drag has exited handler */
  97. };
  98.  
  99. typedef short DragTrackingMessage;
  100.  
  101.  
  102. enum {
  103. /* Drag Drawing Procedure Messages */
  104.     dragRegionBegin                = 1,                            /* initialize drawing */
  105.     dragRegionDraw                = 2,                            /* draw drag feedback */
  106.     dragRegionHide                = 3,                            /* hide drag feedback */
  107.     dragRegionIdle                = 4,                            /* drag feedback idle time */
  108.     dragRegionEnd                = 5                                /* end of drawing */
  109. };
  110.  
  111. typedef short DragRegionMessage;
  112.  
  113.  
  114. enum {
  115. /* Drag Imaging Flags */
  116.     dragStandardImage            =    0x00000000,
  117.     dragDarkImage                =    0x00000001,
  118.     dragDarkerImage                =    0x00000002,
  119.     dragOpaqueImage                =    0x00000003,
  120.     dragRegionAndImage            =    0x00000010
  121. };
  122.  
  123. typedef unsigned long DragImageFlags;
  124.  
  125.  
  126. enum {
  127. /* Zoom Acceleration */
  128.     zoomNoAcceleration            = 0,                            /* use linear interpolation */
  129.     zoomAccelerate                = 1,                            /* ramp up step size */
  130.     zoomDecelerate                = 2                                /* ramp down step size */
  131. };
  132.  
  133. typedef short ZoomAcceleration;
  134.  
  135. /* Drag Manager Data Types */
  136. typedef unsigned long DragReference;
  137.  
  138. typedef unsigned long ItemReference;
  139.  
  140. typedef ResType FlavorType;
  141.  
  142. /* HFS Flavors */
  143. struct HFSFlavor {
  144.     OSType                            fileType;                    /* file type */
  145.     OSType                            fileCreator;                /* file creator */
  146.     unsigned short                    fdFlags;                    /* Finder flags */
  147.     FSSpec                            fileSpec;                    /* file system specification */
  148. };
  149. typedef struct HFSFlavor HFSFlavor;
  150.  
  151. struct PromiseHFSFlavor {
  152.     OSType                            fileType;                    /* file type */
  153.     OSType                            fileCreator;                /* file creator */
  154.     unsigned short                    fdFlags;                    /* Finder flags */
  155.     FlavorType                        promisedFlavor;                /* promised flavor containing an FSSpec */
  156. };
  157. typedef struct PromiseHFSFlavor PromiseHFSFlavor;
  158.  
  159. /* Application-Defined Drag Handler Routines */
  160. typedef pascal OSErr (*DragTrackingHandlerProcPtr)(DragTrackingMessage message, WindowPtr theWindow, void *handlerRefCon, DragReference theDragRef);
  161.  
  162. #if GENERATINGCFM
  163. typedef UniversalProcPtr DragTrackingHandlerUPP;
  164. #else
  165. typedef DragTrackingHandlerProcPtr DragTrackingHandlerUPP;
  166. #endif
  167.  
  168. enum {
  169.     uppDragTrackingHandlerProcInfo = kPascalStackBased
  170.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  171.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(DragTrackingMessage)))
  172.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(WindowPtr)))
  173.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void*)))
  174.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(DragReference)))
  175. };
  176.  
  177. #if GENERATINGCFM
  178. #define NewDragTrackingHandlerProc(userRoutine)        ¥
  179.         (DragTrackingHandlerUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppDragTrackingHandlerProcInfo, GetCurrentArchitecture())
  180. #else
  181. #define NewDragTrackingHandlerProc(userRoutine)        ¥
  182.         ((DragTrackingHandlerUPP) (userRoutine))
  183. #endif
  184.  
  185. #if GENERATINGCFM
  186. #define CallDragTrackingHandlerProc(userRoutine, message, theWindow, handlerRefCon, theDragRef)        ¥
  187.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppDragTrackingHandlerProcInfo, (message), (theWindow), (handlerRefCon), (theDragRef))
  188. #else
  189. #define CallDragTrackingHandlerProc(userRoutine, message, theWindow, handlerRefCon, theDragRef)        ¥
  190.         (*(userRoutine))((message), (theWindow), (handlerRefCon), (theDragRef))
  191. #endif
  192.  
  193. typedef DragTrackingHandlerUPP DragTrackingHandler;
  194.  
  195. typedef pascal OSErr (*DragReceiveHandlerProcPtr)(WindowPtr theWindow, void *handlerRefCon, DragReference theDragRef);
  196.  
  197. #if GENERATINGCFM
  198. typedef UniversalProcPtr DragReceiveHandlerUPP;
  199. #else
  200. typedef DragReceiveHandlerProcPtr DragReceiveHandlerUPP;
  201. #endif
  202.  
  203. enum {
  204.     uppDragReceiveHandlerProcInfo = kPascalStackBased
  205.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  206.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(WindowPtr)))
  207.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(void*)))
  208.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(DragReference)))
  209. };
  210.  
  211. #if GENERATINGCFM
  212. #define NewDragReceiveHandlerProc(userRoutine)        ¥
  213.         (DragReceiveHandlerUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppDragReceiveHandlerProcInfo, GetCurrentArchitecture())
  214. #else
  215. #define NewDragReceiveHandlerProc(userRoutine)        ¥
  216.         ((DragReceiveHandlerUPP) (userRoutine))
  217. #endif
  218.  
  219. #if GENERATINGCFM
  220. #define CallDragReceiveHandlerProc(userRoutine, theWindow, handlerRefCon, theDragRef)        ¥
  221.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppDragReceiveHandlerProcInfo, (theWindow), (handlerRefCon), (theDragRef))
  222. #else
  223. #define CallDragReceiveHandlerProc(userRoutine, theWindow, handlerRefCon, theDragRef)        ¥
  224.         (*(userRoutine))((theWindow), (handlerRefCon), (theDragRef))
  225. #endif
  226.  
  227. typedef DragReceiveHandlerUPP DragReceiveHandler;
  228.  
  229. /* Application-Defined Routines */
  230. typedef pascal OSErr (*DragSendDataProcPtr)(FlavorType theType, void *dragSendRefCon, ItemReference theItemRef, DragReference theDragRef);
  231.  
  232. #if GENERATINGCFM
  233. typedef UniversalProcPtr DragSendDataUPP;
  234. #else
  235. typedef DragSendDataProcPtr DragSendDataUPP;
  236. #endif
  237.  
  238. enum {
  239.     uppDragSendDataProcInfo = kPascalStackBased
  240.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  241.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(FlavorType)))
  242.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(void*)))
  243.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(ItemReference)))
  244.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(DragReference)))
  245. };
  246.  
  247. #if GENERATINGCFM
  248. #define NewDragSendDataProc(userRoutine)        ¥
  249.         (DragSendDataUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppDragSendDataProcInfo, GetCurrentArchitecture())
  250. #else
  251. #define NewDragSendDataProc(userRoutine)        ¥
  252.         ((DragSendDataUPP) (userRoutine))
  253. #endif
  254.  
  255. #if GENERATINGCFM
  256. #define CallDragSendDataProc(userRoutine, theType, dragSendRefCon, theItemRef, theDragRef)        ¥
  257.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppDragSendDataProcInfo, (theType), (dragSendRefCon), (theItemRef), (theDragRef))
  258. #else
  259. #define CallDragSendDataProc(userRoutine, theType, dragSendRefCon, theItemRef, theDragRef)        ¥
  260.         (*(userRoutine))((theType), (dragSendRefCon), (theItemRef), (theDragRef))
  261. #endif
  262.  
  263. typedef DragSendDataUPP DragSendDataProc;
  264.  
  265. typedef pascal OSErr (*DragInputProcPtr)(Point *mouse, short *modifiers, void *dragInputRefCon, DragReference theDragRef);
  266.  
  267. #if GENERATINGCFM
  268. typedef UniversalProcPtr DragInputUPP;
  269. #else
  270. typedef DragInputProcPtr DragInputUPP;
  271. #endif
  272.  
  273. enum {
  274.     uppDragInputProcInfo = kPascalStackBased
  275.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  276.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(Point*)))
  277.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(short*)))
  278.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void*)))
  279.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(DragReference)))
  280. };
  281.  
  282. #if GENERATINGCFM
  283. #define NewDragInputProc(userRoutine)        ¥
  284.         (DragInputUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppDragInputProcInfo, GetCurrentArchitecture())
  285. #else
  286. #define NewDragInputProc(userRoutine)        ¥
  287.         ((DragInputUPP) (userRoutine))
  288. #endif
  289.  
  290. #if GENERATINGCFM
  291. #define CallDragInputProc(userRoutine, mouse, modifiers, dragInputRefCon, theDragRef)        ¥
  292.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppDragInputProcInfo, (mouse), (modifiers), (dragInputRefCon), (theDragRef))
  293. #else
  294. #define CallDragInputProc(userRoutine, mouse, modifiers, dragInputRefCon, theDragRef)        ¥
  295.         (*(userRoutine))((mouse), (modifiers), (dragInputRefCon), (theDragRef))
  296. #endif
  297.  
  298. typedef DragInputUPP DragInputProc;
  299.  
  300. typedef pascal OSErr (*DragDrawingProcPtr)(DragRegionMessage message, RgnHandle showRegion, Point showOrigin, RgnHandle hideRegion, Point hideOrigin, void *dragDrawingRefCon, DragReference theDragRef);
  301.  
  302. #if GENERATINGCFM
  303. typedef UniversalProcPtr DragDrawingUPP;
  304. #else
  305. typedef DragDrawingProcPtr DragDrawingUPP;
  306. #endif
  307.  
  308. enum {
  309.     uppDragDrawingProcInfo = kPascalStackBased
  310.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  311.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(DragRegionMessage)))
  312.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(RgnHandle)))
  313.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(Point)))
  314.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(RgnHandle)))
  315.          | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(Point)))
  316.          | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(void*)))
  317.          | STACK_ROUTINE_PARAMETER(7, SIZE_CODE(sizeof(DragReference)))
  318. };
  319.  
  320. #if GENERATINGCFM
  321. #define NewDragDrawingProc(userRoutine)        ¥
  322.         (DragDrawingUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppDragDrawingProcInfo, GetCurrentArchitecture())
  323. #else
  324. #define NewDragDrawingProc(userRoutine)        ¥
  325.         ((DragDrawingUPP) (userRoutine))
  326. #endif
  327.  
  328. #if GENERATINGCFM
  329. #define CallDragDrawingProc(userRoutine, message, showRegion, showOrigin, hideRegion, hideOrigin, dragDrawingRefCon, theDragRef)        ¥
  330.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppDragDrawingProcInfo, (message), (showRegion), (showOrigin), (hideRegion), (hideOrigin), (dragDrawingRefCon), (theDragRef))
  331. #else
  332. #define CallDragDrawingProc(userRoutine, message, showRegion, showOrigin, hideRegion, hideOrigin, dragDrawingRefCon, theDragRef)        ¥
  333.         (*(userRoutine))((message), (showRegion), (showOrigin), (hideRegion), (hideOrigin), (dragDrawingRefCon), (theDragRef))
  334. #endif
  335.  
  336. typedef DragDrawingUPP DragDrawingProc;
  337.  
  338. /* Drag Manager Routines */
  339. /* Installing and Removing Drag Handlers */
  340. extern pascal OSErr InstallTrackingHandler(DragTrackingHandler trackingHandler, WindowPtr theWindow, void *handlerRefCon)
  341.  TWOWORDINLINE(0x7001, 0xABED);
  342. extern pascal OSErr InstallReceiveHandler(DragReceiveHandler receiveHandler, WindowPtr theWindow, void *handlerRefCon)
  343.  TWOWORDINLINE(0x7002, 0xABED);
  344. extern pascal OSErr RemoveTrackingHandler(DragTrackingHandler trackingHandler, WindowPtr theWindow)
  345.  TWOWORDINLINE(0x7003, 0xABED);
  346. extern pascal OSErr RemoveReceiveHandler(DragReceiveHandler receiveHandler, WindowPtr theWindow)
  347.  TWOWORDINLINE(0x7004, 0xABED);
  348. /* Creating and Disposing Drag References */
  349. extern pascal OSErr NewDrag(DragReference *theDragRef)
  350.  TWOWORDINLINE(0x7005, 0xABED);
  351. extern pascal OSErr DisposeDrag(DragReference theDragRef)
  352.  TWOWORDINLINE(0x7006, 0xABED);
  353. /* Adding Drag Item Flavors */
  354. extern pascal OSErr AddDragItemFlavor(DragReference theDragRef, ItemReference theItemRef, FlavorType theType, void *dataPtr, Size dataSize, FlavorFlags theFlags)
  355.  TWOWORDINLINE(0x7007, 0xABED);
  356. extern pascal OSErr SetDragItemFlavorData(DragReference theDragRef, ItemReference theItemRef, FlavorType theType, const void *dataPtr, Size dataSize, unsigned long dataOffset)
  357.  TWOWORDINLINE(0x7009, 0xABED);
  358. /* Providing Drag Callback Procedures */
  359. extern pascal OSErr SetDragSendProc(DragReference theDragRef, DragSendDataProc sendProc, void *dragSendRefCon)
  360.  TWOWORDINLINE(0x700A, 0xABED);
  361. extern pascal OSErr SetDragInputProc(DragReference theDragRef, DragInputProc inputProc, void *dragInputRefCon)
  362.  TWOWORDINLINE(0x700B, 0xABED);
  363. extern pascal OSErr SetDragDrawingProc(DragReference theDragRef, DragDrawingProc drawingProc, void *dragDrawingRefCon)
  364.  TWOWORDINLINE(0x700C, 0xABED);
  365. extern pascal OSErr TrackDrag(DragReference theDragRef, const EventRecord *theEvent, RgnHandle theRegion)
  366.  TWOWORDINLINE(0x700D, 0xABED);
  367. /* Getting Drag Item Information */
  368. extern pascal OSErr CountDragItems(DragReference theDragRef, unsigned short *numItems)
  369.  TWOWORDINLINE(0x700E, 0xABED);
  370. extern pascal OSErr GetDragItemReferenceNumber(DragReference theDragRef, unsigned short index, ItemReference *theItemRef)
  371.  TWOWORDINLINE(0x700F, 0xABED);
  372. extern pascal OSErr CountDragItemFlavors(DragReference theDragRef, ItemReference theItemRef, unsigned short *numFlavors)
  373.  TWOWORDINLINE(0x7010, 0xABED);
  374. extern pascal OSErr GetFlavorType(DragReference theDragRef, ItemReference theItemRef, unsigned short index, FlavorType *theType)
  375.  TWOWORDINLINE(0x7011, 0xABED);
  376. extern pascal OSErr GetFlavorFlags(DragReference theDragRef, ItemReference theItemRef, FlavorType theType, FlavorFlags *theFlags)
  377.  TWOWORDINLINE(0x7012, 0xABED);
  378. extern pascal OSErr GetFlavorDataSize(DragReference theDragRef, ItemReference theItemRef, FlavorType theType, Size *dataSize)
  379.  TWOWORDINLINE(0x7013, 0xABED);
  380. extern pascal OSErr GetFlavorData(DragReference theDragRef, ItemReference theItemRef, FlavorType theType, void *dataPtr, Size *dataSize, unsigned long dataOffset)
  381.  TWOWORDINLINE(0x7014, 0xABED);
  382. extern pascal OSErr GetDragItemBounds(DragReference theDragRef, ItemReference theItemRef, Rect *itemBounds)
  383.  TWOWORDINLINE(0x7015, 0xABED);
  384. extern pascal OSErr SetDragItemBounds(DragReference theDragRef, ItemReference theItemRef, const Rect *itemBounds)
  385.  TWOWORDINLINE(0x7016, 0xABED);
  386. extern pascal OSErr GetDropLocation(DragReference theDragRef, AEDesc *dropLocation)
  387.  TWOWORDINLINE(0x7017, 0xABED);
  388. extern pascal OSErr SetDropLocation(DragReference theDragRef, const AEDesc *dropLocation)
  389.  TWOWORDINLINE(0x7018, 0xABED);
  390. /* Getting Information About a Drag */
  391. extern pascal OSErr GetDragAttributes(DragReference theDragRef, DragAttributes *flags)
  392.  TWOWORDINLINE(0x7019, 0xABED);
  393. extern pascal OSErr GetDragMouse(DragReference theDragRef, Point *mouse, Point *pinnedMouse)
  394.  TWOWORDINLINE(0x701A, 0xABED);
  395. extern pascal OSErr SetDragMouse(DragReference theDragRef, Point pinnedMouse)
  396.  TWOWORDINLINE(0x701B, 0xABED);
  397. extern pascal OSErr GetDragOrigin(DragReference theDragRef, Point *initialMouse)
  398.  TWOWORDINLINE(0x701C, 0xABED);
  399. extern pascal OSErr GetDragModifiers(DragReference theDragRef, short *modifiers, short *mouseDownModifiers, short *mouseUpModifiers)
  400.  TWOWORDINLINE(0x701D, 0xABED);
  401. /* Drag Highlighting */
  402. extern pascal OSErr ShowDragHilite(DragReference theDragRef, RgnHandle hiliteFrame, Boolean inside)
  403.  TWOWORDINLINE(0x701E, 0xABED);
  404. extern pascal OSErr HideDragHilite(DragReference theDragRef)
  405.  TWOWORDINLINE(0x701F, 0xABED);
  406. extern pascal OSErr DragPreScroll(DragReference theDragRef, short dH, short dV)
  407.  TWOWORDINLINE(0x7020, 0xABED);
  408. extern pascal OSErr DragPostScroll(DragReference theDragRef)
  409.  TWOWORDINLINE(0x7021, 0xABED);
  410. extern pascal OSErr UpdateDragHilite(DragReference theDragRef, RgnHandle updateRgn)
  411.  TWOWORDINLINE(0x7022, 0xABED);
  412. /* Drag Manager Utilities */
  413. extern pascal Boolean WaitMouseMoved(Point initialMouse)
  414.  TWOWORDINLINE(0x7023, 0xABED);
  415. extern pascal OSErr ZoomRects(const Rect *fromRect, const Rect *toRect, short zoomSteps, ZoomAcceleration acceleration)
  416.  TWOWORDINLINE(0x7024, 0xABED);
  417. extern pascal OSErr ZoomRegion(RgnHandle region, Point zoomDistance, short zoomSteps, ZoomAcceleration acceleration)
  418.  TWOWORDINLINE(0x7025, 0xABED);
  419. /* New Drag Manager Calls available in System 7.5.3 */
  420. extern pascal OSErr GetDragHiliteColor(WindowRef window, RGBColor *color)
  421.  TWOWORDINLINE(0x7026, 0xABED);
  422. extern pascal OSErr SetDragImage(DragReference drag, PixMapHandle imagePixMap, RgnHandle imageRgn, Point imageOffsetPt, DragImageFlags imageFlags)
  423.  TWOWORDINLINE(0x7027,0xABED);
  424.  
  425. #if PRAGMA_IMPORT_SUPPORTED
  426. #pragma import off
  427. #endif
  428.  
  429. #if PRAGMA_ALIGN_SUPPORTED
  430. #pragma options align=reset
  431. #endif
  432.  
  433. #ifdef __cplusplus
  434. }
  435. #endif
  436.  
  437. #endif /* __DRAG__ */
  438.