home *** CD-ROM | disk | FTP | other *** search
/ QuickTime 2.0 Developer Kit / QuickTime 2.0 Developer Kit.iso / mac / MAC / Programming Stuff / Interfaces / PInterfaces / Drag.p < prev    next >
Encoding:
Text File  |  1994-11-11  |  13.7 KB  |  408 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        Drag.p
  3.  
  4.      Copyright:    © 1984-1994 by Apple Computer, Inc.
  5.                  All rights reserved.
  6.  
  7.      Version:    Universal Interfaces 2.0a3  ETO #16, MPW prerelease.  Friday, November 11, 1994. 
  8.  
  9.      Bugs?:        If you find a problem with this file, send the file and version
  10.                  information (from above) and the problem description to:
  11.  
  12.                      Internet:    apple.bugs@applelink.apple.com
  13.                      AppleLink:    APPLE.BUGS
  14.  
  15. }
  16.  
  17. {$IFC UNDEFINED UsingIncludes}
  18. {$SETC UsingIncludes := 0}
  19. {$ENDC}
  20.  
  21. {$IFC NOT UsingIncludes}
  22.  UNIT Drag;
  23.  INTERFACE
  24. {$ENDC}
  25.  
  26. {$IFC UNDEFINED __DRAG__}
  27. {$SETC __DRAG__ := 1}
  28.  
  29. {$I+}
  30. {$SETC DragIncludes := UsingIncludes}
  31. {$SETC UsingIncludes := 1}
  32.  
  33.  
  34. {$IFC UNDEFINED __APPLEEVENTS__}
  35. {$I AppleEvents.p}
  36. {$ENDC}
  37. {    Errors.p                                                    }
  38. {        ConditionalMacros.p                                        }
  39. {    Types.p                                                        }
  40. {    Memory.p                                                    }
  41. {        MixedMode.p                                                }
  42. {    OSUtils.p                                                    }
  43. {    Events.p                                                    }
  44. {        Quickdraw.p                                                }
  45. {            QuickdrawText.p                                        }
  46. {    EPPC.p                                                        }
  47. {        PPCToolbox.p                                            }
  48. {            AppleTalk.p                                            }
  49. {        Processes.p                                                }
  50. {            Files.p                                                }
  51. {    Notification.p                                                }
  52.  
  53. {$IFC UNDEFINED __TEXTEDIT__}
  54. {$I TextEdit.p}
  55. {$ENDC}
  56.  
  57. {$PUSH}
  58. {$ALIGN MAC68K}
  59. {$LibExport+}
  60.  
  61. CONST
  62. { Flavor Flags }
  63.     flavorSenderOnly            = $00000001;                    { flavor is available to sender only }
  64.     flavorSenderTranslated        = $00000002;                    { flavor is translated by sender }
  65.     flavorNotSaved                = $00000004;                    { flavor should not be saved }
  66.     flavorSystemTranslated        = $00000100;                    { flavor is translated by system }
  67.  
  68.     
  69. TYPE
  70.     FlavorFlags = LONGINT;
  71.  
  72.  
  73. CONST
  74. { Drag Attributes }
  75.     dragHasLeftSenderWindow        = $00000001;                    { drag has left the source window since TrackDrag }
  76.     dragInsideSenderApplication    = $00000002;                    { drag is occurring within the sender application }
  77.     dragInsideSenderWindow        = $00000004;                    { drag is occurring within the sender window }
  78.  
  79.     
  80. TYPE
  81.     DragAttributes = LONGINT;
  82.  
  83.  
  84. CONST
  85. { Special Flavor Types }
  86.     flavorTypeHFS                = 'hfs ';                        { flavor type for HFS data }
  87.     flavorTypePromiseHFS        = 'phfs';                        { flavor type for promised HFS data }
  88.     flavorTypeDirectory            = 'diry';
  89.  
  90. { Drag Tracking Handler Messages }
  91.     dragTrackingEnterHandler    = 1;                            { drag has entered handler }
  92.     dragTrackingEnterWindow        = 2;                            { drag has entered window }
  93.     dragTrackingInWindow        = 3;                            { drag is moving within window }
  94.     dragTrackingLeaveWindow        = 4;                            { drag has exited window }
  95.     dragTrackingLeaveHandler    = 5;                            { drag has exited handler }
  96.  
  97.     
  98. TYPE
  99.     DragTrackingMessage = INTEGER;
  100.  
  101.  
  102. CONST
  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. TYPE
  112.     DragRegionMessage = INTEGER;
  113.  
  114.  
  115. CONST
  116. { Zoom Acceleration }
  117.     zoomNoAcceleration            = 0;                            { use linear interpolation }
  118.     zoomAccelerate                = 1;                            { ramp up step size }
  119.     zoomDecelerate                = 2;                            { ramp down step size }
  120.  
  121.     
  122. TYPE
  123.     ZoomAcceleration = INTEGER;
  124.  
  125. { Drag Manager Data Types }
  126.     DragReference = LONGINT;
  127.  
  128.     ItemReference = LONGINT;
  129.  
  130.     FlavorType = ResType;
  131.  
  132. { HFS Flavors }
  133.     HFSFlavor = RECORD
  134.         fileType:                OSType;                                    { file type }
  135.         fileCreator:            OSType;                                    { file creator }
  136.         fdFlags:                INTEGER;                                { Finder flags }
  137.         fileSpec:                FSSpec;                                    { file system specification }
  138.     END;
  139.     PromiseHFSFlavor = RECORD
  140.         fileType:                OSType;                                    { file type }
  141.         fileCreator:            OSType;                                    { file creator }
  142.         fdFlags:                INTEGER;                                { Finder flags }
  143.         promisedFlavor:            FlavorType;                                { promised flavor containing an FSSpec }
  144.     END;
  145. { Application-Defined Drag Handler Routines }
  146.     DragTrackingHandlerProcPtr = ProcPtr;  { FUNCTION DragTrackingHandler(message: DragTrackingMessage; theWindow: WindowPtr; handlerRefCon: UNIV Ptr; theDragRef: DragReference): OSErr; }
  147.     DragTrackingHandlerUPP = UniversalProcPtr;
  148.  
  149. CONST
  150.     uppDragTrackingHandlerProcInfo = $00003FA0; { FUNCTION (2 byte param, 4 byte param, 4 byte param, 4 byte param): 2 byte result; }
  151.  
  152. FUNCTION NewDragTrackingHandlerProc(userRoutine: DragTrackingHandlerProcPtr): DragTrackingHandlerUPP;
  153.     {$IFC NOT GENERATINGCFM }
  154.     INLINE $2E9F;
  155.     {$ENDC}
  156.  
  157. FUNCTION CallDragTrackingHandlerProc(message: DragTrackingMessage; theWindow: WindowPtr; handlerRefCon: UNIV Ptr; theDragRef: DragReference; userRoutine: DragTrackingHandlerUPP): OSErr;
  158.     {$IFC NOT GENERATINGCFM}
  159.     INLINE $205F, $4E90;
  160.     {$ENDC}
  161.     
  162. TYPE
  163.     DragTrackingHandler = DragTrackingHandlerUPP;
  164.  
  165.     DragReceiveHandlerProcPtr = ProcPtr;  { FUNCTION DragReceiveHandler(theWindow: WindowPtr; handlerRefCon: UNIV Ptr; theDragRef: DragReference): OSErr; }
  166.     DragReceiveHandlerUPP = UniversalProcPtr;
  167.  
  168. CONST
  169.     uppDragReceiveHandlerProcInfo = $00000FE0; { FUNCTION (4 byte param, 4 byte param, 4 byte param): 2 byte result; }
  170.  
  171. FUNCTION NewDragReceiveHandlerProc(userRoutine: DragReceiveHandlerProcPtr): DragReceiveHandlerUPP;
  172.     {$IFC NOT GENERATINGCFM }
  173.     INLINE $2E9F;
  174.     {$ENDC}
  175.  
  176. FUNCTION CallDragReceiveHandlerProc(theWindow: WindowPtr; handlerRefCon: UNIV Ptr; theDragRef: DragReference; userRoutine: DragReceiveHandlerUPP): OSErr;
  177.     {$IFC NOT GENERATINGCFM}
  178.     INLINE $205F, $4E90;
  179.     {$ENDC}
  180.     
  181. TYPE
  182.     DragReceiveHandler = DragReceiveHandlerUPP;
  183.  
  184. { Application-Defined Routines }
  185.     DragSendDataProcPtr = ProcPtr;  { FUNCTION DragSendData(theType: FlavorType; dragSendRefCon: UNIV Ptr; theItemRef: ItemReference; theDragRef: DragReference): OSErr; }
  186.     DragSendDataUPP = UniversalProcPtr;
  187.  
  188. CONST
  189.     uppDragSendDataProcInfo = $00003FE0; { FUNCTION (4 byte param, 4 byte param, 4 byte param, 4 byte param): 2 byte result; }
  190.  
  191. FUNCTION NewDragSendDataProc(userRoutine: DragSendDataProcPtr): DragSendDataUPP;
  192.     {$IFC NOT GENERATINGCFM }
  193.     INLINE $2E9F;
  194.     {$ENDC}
  195.  
  196. FUNCTION CallDragSendDataProc(theType: FlavorType; dragSendRefCon: UNIV Ptr; theItemRef: ItemReference; theDragRef: DragReference; userRoutine: DragSendDataUPP): OSErr;
  197.     {$IFC NOT GENERATINGCFM}
  198.     INLINE $205F, $4E90;
  199.     {$ENDC}
  200.     
  201. TYPE
  202.     DragSendDataProc = DragSendDataUPP;
  203.  
  204.     DragInputProcPtr = ProcPtr;  { FUNCTION DragInput(VAR mouse: Point; VAR modifiers: INTEGER; dragInputRefCon: UNIV Ptr; theDragRef: DragReference): OSErr; }
  205.     DragInputUPP = UniversalProcPtr;
  206.  
  207. CONST
  208.     uppDragInputProcInfo = $00003FE0; { FUNCTION (4 byte param, 4 byte param, 4 byte param, 4 byte param): 2 byte result; }
  209.  
  210. FUNCTION NewDragInputProc(userRoutine: DragInputProcPtr): DragInputUPP;
  211.     {$IFC NOT GENERATINGCFM }
  212.     INLINE $2E9F;
  213.     {$ENDC}
  214.  
  215. FUNCTION CallDragInputProc(VAR mouse: Point; VAR modifiers: INTEGER; dragInputRefCon: UNIV Ptr; theDragRef: DragReference; userRoutine: DragInputUPP): OSErr;
  216.     {$IFC NOT GENERATINGCFM}
  217.     INLINE $205F, $4E90;
  218.     {$ENDC}
  219.     
  220. TYPE
  221.     DragInputProc = DragInputUPP;
  222.  
  223.     DragDrawingProcPtr = ProcPtr;  { FUNCTION DragDrawing(message: DragRegionMessage; showRegion: RgnHandle; showOrigin: Point; hideRegion: RgnHandle; hideOrigin: Point; dragDrawingRefCon: UNIV Ptr; theDragRef: DragReference): OSErr; }
  224.     DragDrawingUPP = UniversalProcPtr;
  225.  
  226. CONST
  227.     uppDragDrawingProcInfo = $000FFFA0; { FUNCTION (2 byte param, 4 byte param, 4 byte param, 4 byte param, 4 byte param, 4 byte param, 4 byte param): 2 byte result; }
  228.  
  229. FUNCTION NewDragDrawingProc(userRoutine: DragDrawingProcPtr): DragDrawingUPP;
  230.     {$IFC NOT GENERATINGCFM }
  231.     INLINE $2E9F;
  232.     {$ENDC}
  233.  
  234. FUNCTION CallDragDrawingProc(message: DragRegionMessage; showRegion: RgnHandle; showOrigin: Point; hideRegion: RgnHandle; hideOrigin: Point; dragDrawingRefCon: UNIV Ptr; theDragRef: DragReference; userRoutine: DragDrawingUPP): OSErr;
  235.     {$IFC NOT GENERATINGCFM}
  236.     INLINE $205F, $4E90;
  237.     {$ENDC}
  238.     
  239. TYPE
  240.     DragDrawingProc = DragDrawingUPP;
  241.  
  242. { Drag Manager Routines }
  243. { Installing and Removing Drag Handlers }
  244.  
  245. FUNCTION InstallTrackingHandler(trackingHandler: DragTrackingHandler; theWindow: WindowPtr; handlerRefCon: UNIV Ptr): OSErr;
  246.     {$IFC NOT GENERATINGCFM}
  247.     INLINE $7001, $ABED;
  248.     {$ENDC}
  249. FUNCTION InstallReceiveHandler(receiveHandler: DragReceiveHandler; theWindow: WindowPtr; handlerRefCon: UNIV Ptr): OSErr;
  250.     {$IFC NOT GENERATINGCFM}
  251.     INLINE $7002, $ABED;
  252.     {$ENDC}
  253. FUNCTION RemoveTrackingHandler(trackingHandler: DragTrackingHandler; theWindow: WindowPtr): OSErr;
  254.     {$IFC NOT GENERATINGCFM}
  255.     INLINE $7003, $ABED;
  256.     {$ENDC}
  257. FUNCTION RemoveReceiveHandler(receiveHandler: DragReceiveHandler; theWindow: WindowPtr): OSErr;
  258.     {$IFC NOT GENERATINGCFM}
  259.     INLINE $7004, $ABED;
  260.     {$ENDC}
  261. { Creating and Disposing Drag References }
  262. FUNCTION NewDrag(VAR theDragRef: DragReference): OSErr;
  263.     {$IFC NOT GENERATINGCFM}
  264.     INLINE $7005, $ABED;
  265.     {$ENDC}
  266. FUNCTION DisposeDrag(theDragRef: DragReference): OSErr;
  267.     {$IFC NOT GENERATINGCFM}
  268.     INLINE $7006, $ABED;
  269.     {$ENDC}
  270. { Adding Drag Item Flavors }
  271. FUNCTION AddDragItemFlavor(theDragRef: DragReference; theItemRef: ItemReference; theType: FlavorType; dataPtr: UNIV Ptr; dataSize: Size; theFlags: FlavorFlags): OSErr;
  272.     {$IFC NOT GENERATINGCFM}
  273.     INLINE $7007, $ABED;
  274.     {$ENDC}
  275. FUNCTION SetDragItemFlavorData(theDragRef: DragReference; theItemRef: ItemReference; theType: FlavorType; dataPtr: UNIV Ptr; dataSize: Size; dataOffset: LONGINT): OSErr;
  276.     {$IFC NOT GENERATINGCFM}
  277.     INLINE $7009, $ABED;
  278.     {$ENDC}
  279. { Providing Drag Callback Procedures }
  280. FUNCTION SetDragSendProc(theDragRef: DragReference; sendProc: DragSendDataProc; dragSendRefCon: UNIV Ptr): OSErr;
  281.     {$IFC NOT GENERATINGCFM}
  282.     INLINE $700A, $ABED;
  283.     {$ENDC}
  284. FUNCTION SetDragInputProc(theDragRef: DragReference; inputProc: DragInputProc; dragInputRefCon: UNIV Ptr): OSErr;
  285.     {$IFC NOT GENERATINGCFM}
  286.     INLINE $700B, $ABED;
  287.     {$ENDC}
  288. FUNCTION SetDragDrawingProc(theDragRef: DragReference; drawingProc: DragDrawingProc; dragDrawingRefCon: UNIV Ptr): OSErr;
  289.     {$IFC NOT GENERATINGCFM}
  290.     INLINE $700C, $ABED;
  291.     {$ENDC}
  292. { Performing a Drag }
  293. FUNCTION TrackDrag(theDragRef: DragReference; {CONST}VAR theEvent: EventRecord; theRegion: RgnHandle): OSErr;
  294.     {$IFC NOT GENERATINGCFM}
  295.     INLINE $700D, $ABED;
  296.     {$ENDC}
  297. { Getting Drag Item Information }
  298. FUNCTION CountDragItems(theDragRef: DragReference; VAR numItems: INTEGER): OSErr;
  299.     {$IFC NOT GENERATINGCFM}
  300.     INLINE $700E, $ABED;
  301.     {$ENDC}
  302. FUNCTION GetDragItemReferenceNumber(theDragRef: DragReference; index: INTEGER; VAR theItemRef: ItemReference): OSErr;
  303.     {$IFC NOT GENERATINGCFM}
  304.     INLINE $700F, $ABED;
  305.     {$ENDC}
  306. FUNCTION CountDragItemFlavors(theDragRef: DragReference; theItemRef: ItemReference; VAR numFlavors: INTEGER): OSErr;
  307.     {$IFC NOT GENERATINGCFM}
  308.     INLINE $7010, $ABED;
  309.     {$ENDC}
  310. FUNCTION GetFlavorType(theDragRef: DragReference; theItemRef: ItemReference; index: INTEGER; VAR theType: FlavorType): OSErr;
  311.     {$IFC NOT GENERATINGCFM}
  312.     INLINE $7011, $ABED;
  313.     {$ENDC}
  314. FUNCTION GetFlavorFlags(theDragRef: DragReference; theItemRef: ItemReference; theType: FlavorType; VAR theFlags: FlavorFlags): OSErr;
  315.     {$IFC NOT GENERATINGCFM}
  316.     INLINE $7012, $ABED;
  317.     {$ENDC}
  318. FUNCTION GetFlavorDataSize(theDragRef: DragReference; theItemRef: ItemReference; theType: FlavorType; VAR dataSize: Size): OSErr;
  319.     {$IFC NOT GENERATINGCFM}
  320.     INLINE $7013, $ABED;
  321.     {$ENDC}
  322. FUNCTION GetFlavorData(theDragRef: DragReference; theItemRef: ItemReference; theType: FlavorType; dataPtr: UNIV Ptr; VAR dataSize: Size; dataOffset: LONGINT): OSErr;
  323.     {$IFC NOT GENERATINGCFM}
  324.     INLINE $7014, $ABED;
  325.     {$ENDC}
  326. FUNCTION GetDragItemBounds(theDragRef: DragReference; theItemRef: ItemReference; VAR itemBounds: Rect): OSErr;
  327.     {$IFC NOT GENERATINGCFM}
  328.     INLINE $7015, $ABED;
  329.     {$ENDC}
  330. FUNCTION SetDragItemBounds(theDragRef: DragReference; theItemRef: ItemReference; {CONST}VAR itemBounds: Rect): OSErr;
  331.     {$IFC NOT GENERATINGCFM}
  332.     INLINE $7016, $ABED;
  333.     {$ENDC}
  334. FUNCTION GetDropLocation(theDragRef: DragReference; VAR dropLocation: AEDesc): OSErr;
  335.     {$IFC NOT GENERATINGCFM}
  336.     INLINE $7017, $ABED;
  337.     {$ENDC}
  338. FUNCTION SetDropLocation(theDragRef: DragReference; {CONST}VAR dropLocation: AEDesc): OSErr;
  339.     {$IFC NOT GENERATINGCFM}
  340.     INLINE $7018, $ABED;
  341.     {$ENDC}
  342. { Getting Information About a Drag }
  343. FUNCTION GetDragAttributes(theDragRef: DragReference; VAR flags: DragAttributes): OSErr;
  344.     {$IFC NOT GENERATINGCFM}
  345.     INLINE $7019, $ABED;
  346.     {$ENDC}
  347. FUNCTION GetDragMouse(theDragRef: DragReference; VAR mouse: Point; VAR pinnedMouse: Point): OSErr;
  348.     {$IFC NOT GENERATINGCFM}
  349.     INLINE $701A, $ABED;
  350.     {$ENDC}
  351. FUNCTION SetDragMouse(theDragRef: DragReference; pinnedMouse: Point): OSErr;
  352.     {$IFC NOT GENERATINGCFM}
  353.     INLINE $701B, $ABED;
  354.     {$ENDC}
  355. FUNCTION GetDragOrigin(theDragRef: DragReference; VAR initialMouse: Point): OSErr;
  356.     {$IFC NOT GENERATINGCFM}
  357.     INLINE $701C, $ABED;
  358.     {$ENDC}
  359. FUNCTION GetDragModifiers(theDragRef: DragReference; VAR modifiers: INTEGER; VAR mouseDownModifiers: INTEGER; VAR mouseUpModifiers: INTEGER): OSErr;
  360.     {$IFC NOT GENERATINGCFM}
  361.     INLINE $701D, $ABED;
  362.     {$ENDC}
  363. { Drag Highlighting }
  364. FUNCTION ShowDragHilite(theDragRef: DragReference; hiliteFrame: RgnHandle; inside: BOOLEAN): OSErr;
  365.     {$IFC NOT GENERATINGCFM}
  366.     INLINE $701E, $ABED;
  367.     {$ENDC}
  368. FUNCTION HideDragHilite(theDragRef: DragReference): OSErr;
  369.     {$IFC NOT GENERATINGCFM}
  370.     INLINE $701F, $ABED;
  371.     {$ENDC}
  372. FUNCTION DragPreScroll(theDragRef: DragReference; dH: INTEGER; dV: INTEGER): OSErr;
  373.     {$IFC NOT GENERATINGCFM}
  374.     INLINE $7020, $ABED;
  375.     {$ENDC}
  376. FUNCTION DragPostScroll(theDragRef: DragReference): OSErr;
  377.     {$IFC NOT GENERATINGCFM}
  378.     INLINE $7021, $ABED;
  379.     {$ENDC}
  380. FUNCTION UpdateDragHilite(theDragRef: DragReference; updateRgn: RgnHandle): OSErr;
  381.     {$IFC NOT GENERATINGCFM}
  382.     INLINE $7022, $ABED;
  383.     {$ENDC}
  384. { Drag Manager Utilities }
  385. FUNCTION WaitMouseMoved(initialMouse: Point): BOOLEAN;
  386.     {$IFC NOT GENERATINGCFM}
  387.     INLINE $7023, $ABED;
  388.     {$ENDC}
  389. FUNCTION ZoomRects({CONST}VAR fromRect: Rect; {CONST}VAR toRect: Rect; zoomSteps: INTEGER; acceleration: ZoomAcceleration): OSErr;
  390.     {$IFC NOT GENERATINGCFM}
  391.     INLINE $7024, $ABED;
  392.     {$ENDC}
  393. FUNCTION ZoomRegion(region: RgnHandle; zoomDistance: Point; zoomSteps: INTEGER; acceleration: ZoomAcceleration): OSErr;
  394.     {$IFC NOT GENERATINGCFM}
  395.     INLINE $7025, $ABED;
  396.     {$ENDC}
  397.  
  398. {$ALIGN RESET}
  399. {$POP}
  400.  
  401. {$SETC UsingIncludes := DragIncludes}
  402.  
  403. {$ENDC} {__DRAG__}
  404.  
  405. {$IFC NOT UsingIncludes}
  406.  END.
  407. {$ENDC}
  408.