home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / HyperCard / GetFileXFCN / FileName.p next >
Text File  |  1987-11-01  |  6KB  |  210 lines
  1. { 
  2. Name:                “FileName” -- a HyperCard "XFCN" (External Function) resource
  3.  
  4. Written By: Steve Maller
  5.                         Apple Computer Training Support
  6.                         Copyright © 1987 Apple Computer
  7.                         AppleLink: MALLER1
  8.                         Saturday, August 22, 1987 
  9.  
  10. Language:        MPW Pascal
  11.  
  12. To build:        pascal FileName.p
  13.                         link -m ENTRYPOINT -rt XFCN=913 -sn Main=FileName ∂
  14.                             -t STAK -c WILD ∂
  15.                             FileName.p.o ∂
  16.                             hd:dev:mpw:libraries:Interface.o ∂
  17.                             hd:dev:mpw:PLibraries:Paslib.o ∂
  18.                             -o "hd:hyper:hypercard stacks:TestXFCN"
  19.  
  20. Usage:            FileName("fileType")    -- "fileType" is optional
  21.  
  22. Examples:        FileName("STAK")            -- limits list to HyperCard Stacks
  23.                         FileName("TEXT")            -- limits list to text files
  24.                         FileName("APPL")            -- limits list to applications
  25.                         FileName()                      -- lists ALL files
  26.  
  27. Result:            The full pathname of the selected file.
  28.                         For example, if you selected the file "Address Stack" which is
  29.                         in the folder "My Stacks" in the folder "HyperCard" on the
  30.                         disk "HD" the result is:
  31.                                     HD:HyperCard:My Stacks:Address Stack
  32.                         If the user clicks “Cancel” an empty string is returned.
  33.                         
  34. Warning:        A word of caution: the Mac's file system can NOT accept
  35.                         pathnames longer than 255 characters. Be careful...
  36.                         
  37. Script
  38. Example:        on mouseUp
  39.                             put FileName("TEXT") into theFile
  40.                             if theFile is not empty then
  41.                                 open file theFile
  42.                                 read from file theFile for 2000
  43.                                 put it into bkgnd field 1
  44.                                 close file theFile
  45.                             end if
  46.                         end mouseUp
  47.  
  48. Why?                You must access files in HyperCard by their full pathname.
  49.                         Unfortunately, HyperCard offers you no clear way of finding
  50.                         out what that full name is. If files are on a hard disk, it
  51.                         can be a real pain to remember the entire pathname. This
  52.                         function simplifies that task for both the stackware developer
  53.                         and the end user.
  54.  
  55. Thanks to:    Ted Kaehler, Dan Winkler, and Bill Atkinson - my hero!
  56.  
  57. }
  58.  
  59. {$S FileName }
  60.  
  61. UNIT Snoopy_Vs_TheRedBaron;        { obviously this is irrelevant }
  62.  
  63.     INTERFACE
  64.  
  65.         USES
  66.             {$LOAD HD:Hyper:XCMDs:PasSymDump}
  67.             MemTypes, QuickDraw, OSIntf, ToolIntf, PackIntf, HyperXCmd;
  68.  
  69.         PROCEDURE EntryPoint(paramPtr: XCmdPtr);
  70.  
  71.     IMPLEMENTATION
  72.  
  73.         TYPE
  74.             Str31 = String[31];
  75.  
  76.         PROCEDURE FileName(paramPtr: XCmdPtr);
  77.             FORWARD;
  78.  
  79.         PROCEDURE EntryPoint(paramPtr: XCmdPtr);
  80.  
  81.             BEGIN
  82.                 FileName(paramPtr);
  83.             END;
  84.  
  85.         PROCEDURE FileName(paramPtr: XCmdPtr);
  86.  
  87.             VAR
  88.                 myWDPB: WDPBPtr;                            { some variants of the same animal }
  89.                 myCPB: CInfoPBPtr;
  90.                 myPB: HParmBlkPtr;
  91.                 fullPathName: Str255;
  92.                 numTypes: Integer;
  93.                 reply: SFReply;
  94.                 typeList: SFTypeList;
  95.  
  96.                 {$I XCmdGlue.inc }
  97.  
  98.             FUNCTION TheyChoseAFile: Boolean;
  99.  
  100.                 VAR
  101.                     pt: Point;
  102.  
  103.                 BEGIN
  104.                     TheyChoseAFile := FALSE;
  105.                     pt.v := 60;
  106.                     pt.h := 82;
  107.                     SFGetFile(pt, '', NIL, numTypes, typeList, NIL, reply);
  108.                                                                                                 { have 'em pick a file }
  109.                     IF reply.good THEN                                         { if they didn't choose Cancel }
  110.                         BEGIN
  111.                             TheyChoseAFile := TRUE;
  112.                             fullPathName := reply.fName;             { start the ball rolling }
  113.                         END;
  114.                 END;
  115.  
  116.             PROCEDURE BuildThePathName;
  117.  
  118.                 VAR
  119.                     name: Str255;
  120.                     err: Integer;
  121.  
  122.                 BEGIN
  123.                     name := '';                                                        { start with an empty name }
  124.                     myPB^.ioNamePtr := @name;                            { we want the Volume name }
  125.                   myPB^.ioCompletion := pointer(0);
  126.                     myPB^.ioVRefNum := reply.vRefNum;            { returned from SFGetFile }
  127.                     myPB^.ioVolIndex := 0;                                { use the vRefNum and name }
  128.                     err := PBHGetVInfo(myPB, FALSE);            { fill in the Volume info }
  129.                     IF err <> noErr THEN
  130.                         Exit(FileName);
  131.  
  132. { Now we need the Working Directory (WD) information because we're going 
  133.     to step backwards from the file through all of the the folders until
  134.     we reach the root directory }
  135.     
  136.                     myWDPB^.ioVRefNum := reply.vRefNum;        { this got set to 0 above }
  137.                     myWDPB^.ioWDProcID := 0;                            { use the vRefNum }
  138.                     myWDPB^.ioWDIndex := 0;                                { we want ALL directories }
  139.                     err := PBGetWDInfo(myWDPB, FALSE);        { do it }
  140.                     IF err <> noErr THEN
  141.                         Exit(FileName);
  142.  
  143.                     myCPB^.ioFDirIndex := - 1;                        { use the ioDirID field only }
  144.                     myCPB^.ioDrDirID := myWDPB^.ioWDDirID;{ info returned above }
  145.                     err := PBGetCatInfo(myCPB, FALSE);        { do it }
  146.                     IF err <> noErr THEN
  147.                         Exit(FileName);
  148.  
  149. { Here starts the real work - start to climb the tree by continually
  150.     looking in the ioDrParId field for the next directory above until we
  151.     fail... }
  152.     
  153.                     myCPB^.ioDrDirID := myCPB^.ioDrParId;    { the first folder}
  154.                     fullPathName := Concat(myCPB^.ioNamePtr^, ':', reply.fName);
  155.                     REPEAT
  156.                         myCPB^.ioDrDirID := myCPB^.ioDrParId;
  157.                         err := PBGetCatInfo(myCPB, FALSE);    { the next level }
  158.  
  159. { Be careful of an error returned here - it means the user chose a file 
  160.     on the desktop level of this volume. If this is the case, just stop
  161.     here and return "VolumeName:FileName", otherwise loop until failure }
  162.                         IF err = noErr THEN
  163.                             fullPathName := Concat(myCPB^.ioNamePtr^, ':', fullPathName);
  164.  
  165.                     UNTIL err <> noErr;
  166.                     
  167.                 END;        { PROCEDURE BuildThePathName }
  168.  
  169.             BEGIN        { PROCEDURE FileName }
  170.             
  171. { First we allocate some memory in the heap for the parameter block. This
  172.     could in theory work on the stack, but in reality it makes no difference
  173.     as we're entirely modal (ugh) here... }
  174.     
  175.                 fullPathName := '';
  176.     
  177.                 myCPB := CInfoPBPtr(NewPtr(SizeOf(HParamBlockRec)));
  178.                 IF ord4(myCPB) <= 0 THEN
  179.                     Exit(FileName);                            { Rats! Bill didn't leave enough room }
  180.                 myWDPB := WDPBPtr(myCPB);            { icky Pascal type coercions follow }
  181.                 myPB := HParmBlkPtr(myCPB);
  182.  
  183.                 numTypes := 1;                                { for SFGetFile }
  184.                 WITH paramPtr^ DO
  185.                     BEGIN
  186.                         IF paramCount = 0 THEN
  187.                             numTypes := - 1                    { FileName() - get all files }
  188.                         ELSE
  189.                             BlockMove(params[1]^, @typeList[0], 4);
  190.                                                                             { FileName("TYPE") }
  191.  
  192.                         IF TheyChoseAFile THEN
  193.                             BuildThePathName;
  194.  
  195. { PasToZero is very interesting - it is a HyperTalk command
  196.     that you can actually call from OUTSIDE of HyperCard.
  197.     You need it because HyperCard uses C format strings with
  198.     no length byte; they are terminated by a null byte. They are
  199.     actually HANDLES to C format strings. Nice work, Dan! }
  200.     
  201.                         returnValue := PasToZero(fullPathName);
  202.  
  203.                     END;        { WITH paramPtr^ DO }
  204.  
  205.                 DisposPtr(pointer(myCPB));             { Clean Up Your Heap! }
  206.  
  207.             END;        { PROCEDURE FileName }
  208.  
  209. END.
  210.