home *** CD-ROM | disk | FTP | other *** search
/ Network PC / Network PC.iso / amiga utilities / communication / bbs / termv4.6 / extras / source / term-source.lha / PickFile.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-03-18  |  14.4 KB  |  715 lines
  1. /*
  2. **    PickFile.c
  3. **
  4. **    Simplified file selection routines
  5. **
  6. **    Copyright © 1990-1996 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #ifndef _GLOBAL_H
  11. #include "Global.h"
  12. #endif
  13.  
  14. #include <exec/resident.h>
  15.  
  16. enum    {    GAD_LIST=1,GAD_USE,GAD_SELECT,GAD_CANCEL };
  17.  
  18. BOOL
  19. ValidateFile(STRPTR FileName,LONG Type,STRPTR RealName)
  20. {
  21.     BOOL    Valid = FALSE;
  22.     BPTR    Segment;
  23.  
  24.     if(Segment = LoadSeg(FileName))
  25.     {
  26.         ULONG    *SegmentData;
  27.         BPTR     SegPtr = Segment;
  28.         UWORD    *Match;
  29.         BOOL     GotIt = FALSE;
  30.         LONG     Size;
  31.  
  32.         do
  33.         {
  34.             SegmentData = (ULONG *)BADDR(SegPtr);
  35.  
  36.             SegPtr    = (BPTR)SegmentData[0];
  37.             Size    = SegmentData[-1] - 2 * sizeof(ULONG) - sizeof(struct Resident);
  38.             Match    = (UWORD *)(SegmentData + 1);
  39.  
  40.             while(!GotIt && Size > 0)
  41.             {
  42.                 if(*Match == RTC_MATCHWORD)
  43.                 {
  44.                     struct Resident *Resident = (struct Resident *)Match;
  45.  
  46.                     if(Resident -> rt_MatchTag == Resident)
  47.                     {
  48.                         if(Resident -> rt_Type == Type && Resident -> rt_Name)
  49.                         {
  50.                             if(!Stricmp(FilePart(FileName),Resident -> rt_Name))
  51.                             {
  52.                                 if(RealName)
  53.                                     strcpy(RealName,Resident -> rt_Name);
  54.  
  55.                                 Valid = TRUE;
  56.                             }
  57.                         }
  58.  
  59.                         GotIt = TRUE;
  60.                     }
  61.                 }
  62.  
  63.                 Match    += 2;
  64.                 Size    -= sizeof(ULONG);
  65.             }
  66.         }
  67.         while(!GotIt && SegPtr);
  68.  
  69.         UnLoadSeg(Segment);
  70.     }
  71.  
  72.     return(Valid);
  73. }
  74.  
  75.     /* AddFile(struct List *List,STRPTR Name):
  76.      *
  77.      *    Add another file to the list:
  78.      */
  79.  
  80. STATIC VOID
  81. AddFile(struct List *List,STRPTR Name)
  82. {
  83.     struct Node *NewNode;
  84.  
  85.     if(NewNode = CreateNode(Name))
  86.     {
  87.         struct Node    *Node,
  88.                 *Next;
  89.         BOOL         GotIt = FALSE;
  90.         LONG         Result;
  91.  
  92.         Node = List -> lh_Head;
  93.  
  94.         while(Next = Node -> ln_Succ)
  95.         {
  96.             if((Result = Stricmp(Name,Node -> ln_Name)) < 0)
  97.             {
  98.                 Insert(List,NewNode,Node -> ln_Pred);
  99.  
  100.                 GotIt = TRUE;
  101.  
  102.                 break;
  103.             }
  104.             else
  105.             {
  106.                     /* Don't add two identical names. */
  107.  
  108.                 if(!Result)
  109.                 {
  110.                     FreeVecPooled(NewNode);
  111.  
  112.                     return;
  113.                 }
  114.             }
  115.  
  116.             Node = Next;
  117.         }
  118.  
  119.         if(!GotIt)
  120.             AddTail(List,NewNode);
  121.     }
  122. }
  123.  
  124.     /* FileMultiScan(struct List *FileList,STRPTR Directory,STRPTR Pattern):
  125.      *
  126.      *    Scan an assignment, also handles multipath assignments.
  127.      */
  128.  
  129. STATIC VOID
  130. FileMultiScan(struct List *FileList,STRPTR Directory,STRPTR Pattern,LONG Type)
  131. {
  132.     struct DevProc        *DevProc    = NULL;
  133.     struct MsgPort        *FileSysTask    = GetFileSysTask();
  134.     struct FileInfoBlock    *FileInfo;
  135.     UBYTE             MatchBuffer[MAX_FILENAME_LENGTH];
  136.  
  137.     if(ParsePatternNoCase(Pattern,MatchBuffer,MAX_FILENAME_LENGTH) != -1)
  138.     {
  139.             /* Allocate the fileinfo data. */
  140.  
  141.         if(FileInfo = (struct FileInfoBlock *)AllocDosObjectTags(DOS_FIB,TAG_DONE))
  142.         {
  143.                 /* Loop until all assignments are
  144.                  * processed.
  145.                  */
  146.  
  147.             do
  148.             {
  149.                     /* Get the default filesystem task
  150.                      * in case we stumble upon NULL
  151.                      * directory locks.
  152.                      */
  153.  
  154.                 if(DevProc = GetDeviceProc(Directory,DevProc))
  155.                 {
  156.                         /* Set the default filesystem task. */
  157.  
  158.                     SetFileSysTask(DevProc -> dvp_Port);
  159.  
  160.                         /* Check the object type. */
  161.  
  162.                     if(Examine(DevProc -> dvp_Lock,FileInfo))
  163.                     {
  164.                             /* Is it really a directory? */
  165.  
  166.                         if(FileInfo -> fib_DirEntryType > 0)
  167.                         {
  168.                                 /* Scan the directory... */
  169.  
  170.                             while(ExNext(DevProc -> dvp_Lock,FileInfo))
  171.                             {
  172.                                     /* Did we find a file? */
  173.  
  174.                                 if(FileInfo -> fib_DirEntryType < 0)
  175.                                 {
  176.                                         /* Does the name match the template? */
  177.  
  178.                                     if(MatchPatternNoCase(MatchBuffer,FileInfo -> fib_FileName))
  179.                                     {
  180.                                         if(Type == -1)
  181.                                             AddFile(FileList,FileInfo -> fib_FileName);
  182.                                         else
  183.                                         {
  184.                                             UBYTE LocalBuffer[MAX_FILENAME_LENGTH],RealName[MAX_FILENAME_LENGTH];
  185.  
  186.                                             strcpy(LocalBuffer,Directory);
  187.  
  188.                                             if(AddPart(LocalBuffer,FileInfo -> fib_FileName,MAX_FILENAME_LENGTH))
  189.                                             {
  190.                                                 if(ValidateFile(LocalBuffer,Type,RealName))
  191.                                                     AddFile(FileList,RealName);
  192.                                             }
  193.                                         }
  194.                                     }
  195.                                 }
  196.                             }
  197.                         }
  198.                     }
  199.                 }
  200.                 else
  201.                     break;
  202.             }
  203.             while(DevProc && (DevProc -> dvp_Flags & DVPF_ASSIGN));
  204.  
  205.                 /* Free the fileinfo data. */
  206.  
  207.             FreeDosObject(DOS_FIB,FileInfo);
  208.         }
  209.     }
  210.  
  211.         /* Reset the default filesystem task. */
  212.  
  213.     SetFileSysTask(FileSysTask);
  214.  
  215.         /* Free device process data. */
  216.  
  217.     if(DevProc)
  218.         FreeDeviceProc(DevProc);
  219. }
  220.  
  221.     /* BuildFileList(STRPTR Directory,STRPTR Pattern):
  222.      *
  223.      *    Build a list of files in an assigned directory
  224.      *    matching a certain pattern.
  225.      */
  226.  
  227. STATIC struct List *
  228. BuildFileList(STRPTR Directory,STRPTR Pattern,LONG Type)
  229. {
  230.     APTR         OldPtr = ThisProcess -> pr_WindowPtr;
  231.     struct List    *FileList = NULL;
  232.     BPTR         NewDir;
  233.  
  234.         /* No DOS requesters, please! */
  235.  
  236.     ThisProcess -> pr_WindowPtr = (APTR)-1;
  237.  
  238.         /* Is the assignment present? */
  239.  
  240.     if(NewDir = Lock(Directory,ACCESS_READ))
  241.     {
  242.             /* Allocate space for the new list. */
  243.  
  244.         if(FileList = (struct List *)AllocVecPooled(sizeof(struct List),MEMF_ANY))
  245.         {
  246.                 /* Initialize the list. */
  247.  
  248.             NewList(FileList);
  249.  
  250.                 /* Will we have to deal with
  251.                  * an assignment or a volume?
  252.                  */
  253.  
  254.             if(IsAssign(Directory))
  255.                 FileMultiScan(FileList,Directory,Pattern,Type);
  256.             else
  257.             {
  258.                 struct FileInfoBlock    *FileInfo;
  259.                 UBYTE             MatchBuffer[MAX_FILENAME_LENGTH];
  260.  
  261.                 if(ParsePatternNoCase(Pattern,MatchBuffer,MAX_FILENAME_LENGTH) != -1)
  262.                 {
  263.                         /* Allocate space for a fileinfo block. */
  264.  
  265.                     if(FileInfo = (struct FileInfoBlock *)AllocDosObjectTags(DOS_FIB,TAG_DONE))
  266.                     {
  267.                             /* Take a look at the assignment. */
  268.  
  269.                         if(Examine(NewDir,FileInfo))
  270.                         {
  271.                                 /* Does it really refer to a directory? */
  272.  
  273.                             if(FileInfo -> fib_DirEntryType > 0)
  274.                             {
  275.                                     /* Examine the whole directory. */
  276.  
  277.                                 while(ExNext(NewDir,FileInfo))
  278.                                 {
  279.                                         /* Is it a file? */
  280.  
  281.                                     if(FileInfo -> fib_DirEntryType < 0)
  282.                                     {
  283.                                         if(MatchPatternNoCase(MatchBuffer,FileInfo -> fib_FileName))
  284.                                         {
  285.                                             if(Type == -1)
  286.                                                 AddFile(FileList,FileInfo -> fib_FileName);
  287.                                             else
  288.                                             {
  289.                                                 UBYTE LocalBuffer[MAX_FILENAME_LENGTH],RealName[MAX_FILENAME_LENGTH];
  290.  
  291.                                                 strcpy(LocalBuffer,Directory);
  292.  
  293.                                                 if(AddPart(LocalBuffer,FileInfo -> fib_FileName,MAX_FILENAME_LENGTH))
  294.                                                 {
  295.                                                     if(ValidateFile(LocalBuffer,Type,RealName))
  296.                                                         AddFile(FileList,RealName);
  297.                                                 }
  298.                                             }
  299.                                         }
  300.                                     }
  301.                                 }
  302.                             }
  303.                         }
  304.  
  305.                             /* Free the fileinfo data. */
  306.  
  307.                         FreeDosObject(DOS_FIB,FileInfo);
  308.                     }
  309.                 }
  310.             }
  311.  
  312.             if(Type == NT_DEVICE)
  313.             {
  314.                 UBYTE MatchBuffer[MAX_FILENAME_LENGTH];
  315.  
  316.                 if(ParsePatternNoCase(Pattern,MatchBuffer,MAX_FILENAME_LENGTH) != -1)
  317.                 {
  318.                     struct Node *Node;
  319.  
  320.                     Forbid();
  321.  
  322.                     for(Node = SysBase -> DeviceList . lh_Head ; Node -> ln_Succ ; Node = Node -> ln_Succ)
  323.                     {
  324.                         if(MatchPatternNoCase(MatchBuffer,Node -> ln_Name))
  325.                             AddFile(FileList,Node -> ln_Name);
  326.                     }
  327.  
  328.                     Permit();
  329.                 }
  330.             }
  331.  
  332.             if(Type == NT_LIBRARY)
  333.             {
  334.                 UBYTE MatchBuffer[MAX_FILENAME_LENGTH];
  335.  
  336.                 if(ParsePatternNoCase(Pattern,MatchBuffer,MAX_FILENAME_LENGTH) != -1)
  337.                 {
  338.                     struct Node *Node;
  339.  
  340.                     Forbid();
  341.  
  342.                     for(Node = SysBase -> LibList . lh_Head ; Node -> ln_Succ ; Node = Node -> ln_Succ)
  343.                     {
  344.                         if(MatchPatternNoCase(MatchBuffer,Node -> ln_Name))
  345.                             AddFile(FileList,Node -> ln_Name);
  346.                     }
  347.  
  348.                     Permit();
  349.                 }
  350.             }
  351.  
  352.                 /* Does the list contain any entries? */
  353.  
  354.             if(!FileList -> lh_Head -> ln_Succ)
  355.             {
  356.                 FreeVecPooled(FileList);
  357.  
  358.                 FileList = NULL;
  359.             }
  360.         }
  361.  
  362.             /* Release the lock on the directory. */
  363.  
  364.         UnLock(NewDir);
  365.     }
  366.  
  367.         /* Enable DOS requesters again. */
  368.  
  369.     ThisProcess -> pr_WindowPtr = OldPtr;
  370.  
  371.         /* Return the file name list. */
  372.  
  373.     return(FileList);
  374. }
  375.  
  376.     /* PickFile(STRPTR Directory,STRPTR Pattern,STRPTR Prompt,STRPTR Name):
  377.      *
  378.      *    Your nice file selection routine. No need to hunt for
  379.      *    a library/device by checking all assignments by hand.
  380.      */
  381.  
  382. BOOL
  383. PickFile(struct Window *Window,STRPTR Directory,STRPTR Pattern,STRPTR Prompt,STRPTR Name,LONG Type)
  384. {
  385.     UBYTE              DummyBuffer[MAX_FILENAME_LENGTH],
  386.                 *DummyChar;
  387.     struct FileRequester    *FileRequest;
  388.     struct List        *FileList;
  389.     BOOL             Result = FALSE;
  390.  
  391.     if(FileList = BuildFileList(Directory,Pattern,Type))
  392.     {
  393.         struct LayoutHandle *Handle;
  394.  
  395.         if(Handle = LT_CreateHandleTags(Window -> WScreen,
  396.             LH_LocaleHook,    &LocaleHook,
  397.         TAG_DONE))
  398.         {
  399.             struct Window    *PanelWindow;
  400.             ULONG         Index = (ULONG)~0,i;
  401.             struct Node    *Node;
  402.  
  403.             for(Node = FileList -> lh_Head, i = 0 ; Node -> ln_Succ ; Node = Node -> ln_Succ, i++)
  404.             {
  405.                 if(!Stricmp(Node -> ln_Name,Name))
  406.                 {
  407.                     Index = i;
  408.  
  409.                     break;
  410.                 }
  411.             }
  412.  
  413.             LT_New(Handle,
  414.                 LA_Type,    VERTICAL_KIND,
  415.             TAG_DONE);
  416.             {
  417.                 LT_New(Handle,
  418.                     LA_Type,    VERTICAL_KIND,
  419.                 TAG_DONE);
  420.                 {
  421.                     LONG MaxWidth,MaxHeight;
  422.  
  423.                     MaxWidth = MaxHeight = 0;
  424.  
  425.                     if(FileList)
  426.                     {
  427.                         struct Node *Node;
  428.                         LONG Len;
  429.  
  430.                         for(Node = FileList -> lh_Head ; Node -> ln_Succ ; Node = Node -> ln_Succ)
  431.                         {
  432.                             Len = strlen(Node -> ln_Name);
  433.  
  434.                             if(Len > MaxWidth)
  435.                                 MaxWidth = Len;
  436.  
  437.                             MaxHeight++;
  438.                         }
  439.                     }
  440.  
  441.                     if(MaxWidth < 30)
  442.                         MaxWidth = 30;
  443.  
  444.                     if(MaxHeight < 10)
  445.                         MaxHeight = 10;
  446.                     else
  447.                     {
  448.                         if(MaxHeight > 20)
  449.                             MaxHeight = 20;
  450.                     }
  451.  
  452.                     LT_New(Handle,
  453.                         LA_Type,    LISTVIEW_KIND,
  454.                         LA_Chars,    30,
  455.                         LA_ID,        GAD_LIST,
  456.                         LA_Lines,    10,
  457.                         LALV_MaxGrowX,    MaxWidth,
  458.                         LALV_MaxGrowY,    MaxHeight,
  459.                         LALV_ResizeY,    TRUE,
  460.                         GTLV_Labels,    FileList,
  461.                         GTLV_Selected,    Index,
  462.                         LALV_Link,    NIL_LINK,
  463.                         LALV_CursorKey,    TRUE,
  464.                     TAG_DONE);
  465.  
  466.                     LT_EndGroup(Handle);
  467.                 }
  468.  
  469.                 LT_New(Handle,
  470.                     LA_Type,VERTICAL_KIND,
  471.                 TAG_DONE);
  472.                 {
  473.                     LT_New(Handle,
  474.                         LA_Type,    XBAR_KIND,
  475.                         LAXB_FullSize,    TRUE,
  476.                     TAG_DONE);
  477.  
  478.                     LT_EndGroup(Handle);
  479.                 }
  480.  
  481.                 LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  482.                     LAGR_SameSize,    TRUE,
  483.                     LAGR_Spread,    TRUE,
  484.                 TAG_DONE);
  485.                 {
  486.                     LT_New(Handle,
  487.                         LA_Type,    BUTTON_KIND,
  488.                         LA_LabelID,    MSG_GLOBAL_USE_GAD,
  489.                         LA_ID,        GAD_USE,
  490.                         LABT_ReturnKey,    TRUE,
  491.                         LABT_ExtraFat,    TRUE,
  492.                     TAG_DONE);
  493.  
  494.                     LT_New(Handle,
  495.                         LA_Type,    BUTTON_KIND,
  496.                         LA_LabelID,    MSG_TERMPICKFILE_SELECT_GAD,
  497.                         LA_ID,        GAD_SELECT,
  498.                         LABT_ExtraFat,    TRUE,
  499.                     TAG_DONE);
  500.  
  501.                     LT_New(Handle,
  502.                         LA_Type,    BUTTON_KIND,
  503.                         LA_LabelID,    MSG_GLOBAL_CANCEL_GAD,
  504.                         LA_ID,        GAD_CANCEL,
  505.                         LABT_EscKey,    TRUE,
  506.                         LABT_ExtraFat,    TRUE,
  507.                     TAG_DONE);
  508.  
  509.                     LT_EndGroup(Handle);
  510.                 }
  511.  
  512.                 LT_EndGroup(Handle);
  513.             }
  514.  
  515.             if(PanelWindow = LT_Build(Handle,
  516.                 LAWN_TitleText,        Prompt,
  517.                 LAWN_IDCMP,        IDCMP_CLOSEWINDOW,
  518.                 LAWN_HelpHook,        &GuideHook,
  519.                 LAWN_Parent,        Window,
  520.                 WA_DepthGadget,        TRUE,
  521.                 WA_CloseGadget,        TRUE,
  522.                 WA_DragBar,        TRUE,
  523.                 WA_RMBTrap,        TRUE,
  524.                 WA_Activate,        TRUE,
  525.                 WA_SimpleRefresh,    TRUE,
  526.             TAG_DONE))
  527.             {
  528.                 struct IntuiMessage    *Message;
  529.                 BOOL             Done = FALSE;
  530.                 ULONG             MsgClass;
  531.                 UWORD             MsgCode;
  532.                 struct Gadget        *MsgGadget;
  533.  
  534.                 LT_ShowWindow(Handle,TRUE);
  535.  
  536.                 PushWindow(PanelWindow);
  537.  
  538.                 do
  539.                 {
  540.                     if(Wait(PORTMASK(PanelWindow -> UserPort) | SIG_BREAK) & SIG_BREAK)
  541.                         break;
  542.  
  543.                     while(Message = (struct IntuiMessage *)LT_GetIMsg(Handle))
  544.                     {
  545.                         MsgClass    = Message -> Class;
  546.                         MsgCode        = Message -> Code;
  547.                         MsgGadget    = (struct Gadget *)Message -> IAddress;
  548.  
  549.                         LT_ReplyIMsg(Message);
  550.  
  551.                         if(MsgClass == IDCMP_CLOSEWINDOW)
  552.                             Done = TRUE;
  553.  
  554.                         if(MsgClass == IDCMP_GADGETUP)
  555.                         {
  556.                             switch(MsgGadget -> GadgetID)
  557.                             {
  558.                                 case GAD_USE:
  559.  
  560.                                     if(Index != (ULONG)~0)
  561.                                     {
  562.                                         struct Node *Node = GetListNode(Index,FileList);
  563.  
  564.                                         if(Node)
  565.                                         {
  566.                                             strcpy(Name,Node -> ln_Name);
  567.  
  568.                                             Result = TRUE;
  569.                                         }
  570.                                     }
  571.  
  572.                                     Done = TRUE;
  573.                                     break;
  574.  
  575.                                 case GAD_CANCEL:
  576.  
  577.                                     Done = TRUE;
  578.                                     break;
  579.  
  580.                                 case GAD_LIST:
  581.  
  582.                                     Index = MsgCode;
  583.                                     break;
  584.  
  585.                                 case GAD_SELECT:
  586.  
  587.                                     SplitFileName(Name,&DummyChar,DummyBuffer);
  588.  
  589.                                     if(FileRequest = GetFile(PanelWindow,Prompt,DummyBuffer,DummyChar,DummyBuffer,Pattern,FALSE,FALSE,FALSE,LocaleString(MSG_GLOBAL_SELECT_TXT),TRUE))
  590.                                     {
  591.                                         STRPTR FileName;
  592.  
  593.                                         if(FileRequest -> fr_NumArgs > 1 && FileRequest -> fr_ArgList)
  594.                                             FileName = FileRequest -> fr_ArgList -> wa_Name;
  595.                                         else
  596.                                             FileName = FileRequest -> fr_File;
  597.  
  598.                                         if(!Stricmp(FileRequest -> fr_Drawer,Directory))
  599.                                             strcpy(Name,FileName);
  600.                                         else
  601.                                             strcpy(Name,DummyBuffer);
  602.  
  603.                                         if(Type != -1)
  604.                                         {
  605.                                             UBYTE LocalBuffer[MAX_FILENAME_LENGTH];
  606.  
  607.                                             if(!Stricmp(FileRequest -> fr_Drawer,Directory))
  608.                                             {
  609.                                                 strcpy(LocalBuffer,Directory);
  610.  
  611.                                                 if(AddPart(LocalBuffer,Name,MAX_FILENAME_LENGTH))
  612.                                                     ValidateFile(LocalBuffer,Type,Name);
  613.                                             }
  614.                                             else
  615.                                             {
  616.                                                 if(ValidateFile(DummyBuffer,Type,LocalBuffer))
  617.                                                 {
  618.                                                     strcpy(Name,DummyBuffer);
  619.  
  620.                                                     DummyChar = PathPart(Name);
  621.  
  622.                                                     *DummyChar = 0;
  623.  
  624.                                                     AddPart(Name,LocalBuffer,MAX_FILENAME_LENGTH);
  625.                                                 }
  626.                                             }
  627.                                         }
  628.  
  629.                                         FreeAslRequest(FileRequest);
  630.  
  631.                                         Done = Result = TRUE;
  632.                                     }
  633.  
  634.                                     break;
  635.                             }
  636.                         }
  637.  
  638.                         if(MsgClass == IDCMP_IDCMPUPDATE)
  639.                         {
  640.                             struct Node *Node = GetListNode(Index = MsgCode,FileList);
  641.  
  642.                             if(Node)
  643.                             {
  644.                                 strcpy(Name,Node -> ln_Name);
  645.  
  646.                                 Done = Result = TRUE;
  647.  
  648.                                 LT_PressButton(Handle,GAD_USE);
  649.                             }
  650.                         }
  651.                     }
  652.                 }
  653.                 while(!Done);
  654.  
  655.                 PopWindow();
  656.             }
  657.  
  658.             LT_DeleteHandle(Handle);
  659.         }
  660.  
  661.         DeleteList(FileList);
  662.     }
  663.     else
  664.     {
  665.         SplitFileName(Name,&DummyChar,DummyBuffer);
  666.  
  667.         if(FileRequest = GetFile(Window,Prompt,DummyBuffer,DummyChar,DummyBuffer,Pattern,FALSE,FALSE,FALSE,LocaleString(MSG_GLOBAL_SELECT_TXT),TRUE))
  668.         {
  669.             STRPTR FileName;
  670.  
  671.             if(FileRequest -> fr_NumArgs > 1 && FileRequest -> fr_ArgList)
  672.                 FileName = FileRequest -> fr_ArgList -> wa_Name;
  673.             else
  674.                 FileName = FileRequest -> fr_File;
  675.  
  676.             if(!Stricmp(FileRequest -> fr_Drawer,Directory))
  677.                 strcpy(Name,FileName);
  678.             else
  679.                 strcpy(Name,DummyBuffer);
  680.  
  681.             if(Type != -1)
  682.             {
  683.                 UBYTE LocalBuffer[MAX_FILENAME_LENGTH];
  684.  
  685.                 if(!Stricmp(FileRequest -> fr_Drawer,Directory))
  686.                 {
  687.                     strcpy(LocalBuffer,Directory);
  688.  
  689.                     if(AddPart(LocalBuffer,Name,MAX_FILENAME_LENGTH))
  690.                         ValidateFile(LocalBuffer,Type,Name);
  691.                 }
  692.                 else
  693.                 {
  694.                     if(ValidateFile(DummyBuffer,Type,LocalBuffer))
  695.                     {
  696.                         strcpy(Name,DummyBuffer);
  697.  
  698.                         DummyChar = PathPart(Name);
  699.  
  700.                         *DummyChar = 0;
  701.  
  702.                         AddPart(Name,LocalBuffer,MAX_FILENAME_LENGTH);
  703.                     }
  704.                 }
  705.             }
  706.  
  707.             FreeAslRequest(FileRequest);
  708.  
  709.             return(TRUE);
  710.         }
  711.     }
  712.  
  713.     return(Result);
  714. }
  715.