Amiga Times/AmigaTimes.iso/internet/Term/Extras/Source/term-source.lha/PickFile.c

C/C++ Source or Header | 1996-10-20 | 12.1 KB | 643 lines

/*
**    PickFile.c
**
**    Simplified file selection routines
**
**    Copyright © 1990-1996 by Olaf `Olsen' Barthel
**        All Rights Reserved
**
**    :ts=4
*/

#ifndef _GLOBAL_H
#include "Global.h"
#endif

enum    {    GAD_LIST=1,GAD_USE,GAD_SELECT,GAD_CANCEL };

BOOL
ValidateFile(STRPTR FileName,LONG Type,STRPTR RealName)
{
    BPTR Segment;
    BOOL Valid;

    Valid = FALSE;

    if(Segment = LoadSeg(FileName))
    {
        ULONG *SegmentData;
        UWORD *Match;
        BPTR SegPtr;
        BOOL GotIt;
        LONG Size;

        SegPtr = Segment;
        GotIt = FALSE;

        do
        {
            SegmentData = (ULONG *)BADDR(SegPtr);

            SegPtr    = (BPTR)SegmentData[0];
            Size    = SegmentData[-1] - 2 * sizeof(ULONG) - sizeof(struct Resident);
            Match    = (UWORD *)(SegmentData + 1);

            while(!GotIt && Size > 0)
            {
                if(*Match == RTC_MATCHWORD)
                {
                    struct Resident *Resident = (struct Resident *)Match;

                    if(Resident->rt_MatchTag == Resident)
                    {
                        if(Resident->rt_Type == Type && Resident->rt_Name)
                        {
                            if(!Stricmp(FilePart(FileName),Resident->rt_Name))
                            {
                                if(RealName)
                                    strcpy(RealName,Resident->rt_Name);

                                Valid = TRUE;
                            }
                        }

                        GotIt = TRUE;
                    }
                }

                Match    += 2;
                Size    -= sizeof(ULONG);
            }
        }
        while(!GotIt && SegPtr);

        UnLoadSeg(Segment);
    }

    return(Valid);
}

    /* AddFile(struct List *List,STRPTR Name):
     *
     *    Add another file to the list:
     */

STATIC VOID
AddFile(struct List *List,STRPTR Name)
{
    struct Node *NewNode;

    if(NewNode = CreateNode(Name))
    {
        struct Node *Node;
        LONG Result;

        for(Node = List->lh_Head ; Node->ln_Succ ; Node = Node->ln_Succ)
        {
            Result = Stricmp(Name,Node->ln_Name);

            if(Result < 0)
            {
                Insert(List,NewNode,Node->ln_Pred);
                return;
            }

            if(Result == 0)
            {
                FreeVecPooled(NewNode);
                return;
            }
        }

        AddTail(List,NewNode);
    }
}

    /* FileMultiScan(struct List *FileList,STRPTR Directory,STRPTR Pattern):
     *
     *    Scan an assignment, also handles multipath assignments.
     */

STATIC VOID
FileMultiScan(struct List *FileList,STRPTR Directory,STRPTR Pattern,LONG Type)
{
    UBYTE MatchBuffer[MAX_FILENAME_LENGTH];
    struct MsgPort *FileSysTask;
    struct DevProc *DevProc;
    D_S(struct FileInfoBlock,FileInfo);

    DevProc        = NULL;
    FileSysTask    = GetFileSysTask();

    if(ParsePatternNoCase(Pattern,MatchBuffer,sizeof(MatchBuffer)) != -1)
    {
            /* Loop until all assignments are
             * processed.
             */

        do
        {
                /* Get the default filesystem task
                 * in case we stumble upon NULL
                 * directory locks.
                 */

            if(DevProc = GetDeviceProc(Directory,DevProc))
            {
                    /* Set the default filesystem task. */

                SetFileSysTask(DevProc->dvp_Port);

                    /* Check the object type. */

                if(Examine(DevProc->dvp_Lock,FileInfo))
                {
                        /* Is it really a directory? */

                    if(FileInfo->fib_DirEntryType > 0)
                    {
                            /* Scan the directory... */

                        while(ExNext(DevProc->dvp_Lock,FileInfo))
                        {
                                /* Did we find a file? */

                            if(FileInfo->fib_DirEntryType < 0)
                            {
                                    /* Does the name match the template? */

                                if(MatchPatternNoCase(MatchBuffer,FileInfo->fib_FileName))
                                {
                                    if(Type == -1)
                                        AddFile(FileList,FileInfo->fib_FileName);
                                    else
                                    {
                                        UBYTE LocalBuffer[MAX_FILENAME_LENGTH],RealName[MAX_FILENAME_LENGTH];

                                        strcpy(LocalBuffer,Directory);

                                        if(AddPart(LocalBuffer,FileInfo->fib_FileName,sizeof(LocalBuffer)))
                                        {
                                            if(ValidateFile(LocalBuffer,Type,RealName))
                                                AddFile(FileList,RealName);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            else
                break;
        }
        while(DevProc && (DevProc->dvp_Flags & DVPF_ASSIGN));
    }

        /* Reset the default filesystem task. */

    SetFileSysTask(FileSysTask);

        /* Free device process data. */

    if(DevProc)
        FreeDeviceProc(DevProc);
}

    /* BuildFileList(STRPTR Directory,STRPTR Pattern):
     *
     *    Build a list of files in an assigned directory
     *    matching a certain pattern.
     */

STATIC struct List *
BuildFileList(STRPTR Directory,STRPTR Pattern,LONG Type)
{
    struct List    *FileList;
    APTR OldPtr;
    BPTR NewDir;

    FileList = NULL;

        /* No DOS requesters, please! */

    DisableDOSRequesters(&OldPtr);

        /* Is the assignment present? */

    if(NewDir = Lock(Directory,ACCESS_READ))
    {
            /* Allocate space for the new list. */

        if(FileList = CreateList())
        {
                /* Will we have to deal with
                 * an assignment or a volume?
                 */

            if(IsAssign(Directory))
                FileMultiScan(FileList,Directory,Pattern,Type);
            else
            {
                UBYTE MatchBuffer[MAX_FILENAME_LENGTH];
                D_S(struct FileInfoBlock,FileInfo);

                if(ParsePatternNoCase(Pattern,MatchBuffer,sizeof(MatchBuffer)) != -1)
                {
                        /* Take a look at the assignment. */

                    if(Examine(NewDir,FileInfo))
                    {
                            /* Does it really refer to a directory? */

                        if(FileInfo->fib_DirEntryType > 0)
                        {
                                /* Examine the whole directory. */

                            while(ExNext(NewDir,FileInfo))
                            {
                                    /* Is it a file? */

                                if(FileInfo->fib_DirEntryType < 0)
                                {
                                    if(MatchPatternNoCase(MatchBuffer,FileInfo->fib_FileName))
                                    {
                                        if(Type == -1)
                                            AddFile(FileList,FileInfo->fib_FileName);
                                        else
                                        {
                                            UBYTE LocalBuffer[MAX_FILENAME_LENGTH],RealName[MAX_FILENAME_LENGTH];

                                            strcpy(LocalBuffer,Directory);

                                            if(AddPart(LocalBuffer,FileInfo->fib_FileName,sizeof(LocalBuffer)))
                                            {
                                                if(ValidateFile(LocalBuffer,Type,RealName))
                                                    AddFile(FileList,RealName);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }

            if(Type == NT_DEVICE)
            {
                UBYTE MatchBuffer[MAX_FILENAME_LENGTH];

                if(ParsePatternNoCase(Pattern,MatchBuffer,sizeof(MatchBuffer)) != -1)
                {
                    struct Node *Node;

                    Forbid();

                    for(Node = SysBase->DeviceList.lh_Head ; Node->ln_Succ ; Node = Node->ln_Succ)
                    {
                        if(MatchPatternNoCase(MatchBuffer,Node->ln_Name))
                            AddFile(FileList,Node->ln_Name);
                    }

                    Permit();
                }
            }

            if(Type == NT_LIBRARY)
            {
                UBYTE MatchBuffer[MAX_FILENAME_LENGTH];

                if(ParsePatternNoCase(Pattern,MatchBuffer,sizeof(MatchBuffer)) != -1)
                {
                    struct Node *Node;

                    Forbid();

                    for(Node = SysBase->LibList.lh_Head ; Node->ln_Succ ; Node = Node->ln_Succ)
                    {
                        if(MatchPatternNoCase(MatchBuffer,Node->ln_Name))
                            AddFile(FileList,Node->ln_Name);
                    }

                    Permit();
                }
            }

                /* Does the list contain any entries? */

            if(IsListEmpty(FileList))
            {
                FreeVecPooled(FileList);

                FileList = NULL;
            }
        }

            /* Release the lock on the directory. */

        UnLock(NewDir);
    }

        /* Enable DOS requesters again. */

    EnableDOSRequesters(OldPtr);

        /* Return the file name list. */

    return(FileList);
}

    /* PickFile(STRPTR Directory,STRPTR Pattern,STRPTR Prompt,STRPTR Name):
     *
     *    Your nice file selection routine. No need to hunt for
     *    a library/device by checking all assignments by hand.
     */

BOOL
PickFile(struct Window *Window,STRPTR Directory,STRPTR Pattern,STRPTR Prompt,STRPTR Name,LONG Type)
{
    UBYTE DummyBuffer[MAX_FILENAME_LENGTH];
    struct FileRequester *FileRequest;
    struct List *FileList;
    BOOL Result;

    Result = FALSE;

    if(FileList = BuildFileList(Directory,Pattern,Type))
    {
        struct LayoutHandle *Handle;

        if(Handle = LT_CreateHandleTags(Window->WScreen,
            LAHN_LocaleHook,    &LocaleHook,
        TAG_DONE))
        {
            struct Window *PanelWindow;
            struct Node *Node;
            ULONG Index,i;

            Index = (ULONG)~0;

            for(Node = FileList->lh_Head, i = 0 ; Node->ln_Succ ; Node = Node->ln_Succ, i++)
            {
                if(!Stricmp(Node->ln_Name,Name))
                {
                    Index = i;

                    break;
                }
            }

            LT_New(Handle,
                LA_Type,    VERTICAL_KIND,
            TAG_DONE);
            {
                LT_New(Handle,
                    LA_Type,    VERTICAL_KIND,
                TAG_DONE);
                {
                    LONG MaxWidth,MaxHeight;

                    MaxWidth    = 0;
                    MaxHeight    = 0;

                    if(FileList)
                    {
                        struct Node *Node;
                        LONG Len;

                        for(Node = FileList->lh_Head ; Node->ln_Succ ; Node = Node->ln_Succ)
                        {
                            Len = strlen(Node->ln_Name);

                            if(Len > MaxWidth)
                                MaxWidth = Len;

                            MaxHeight++;
                        }
                    }

                    if(MaxWidth < 30)
                        MaxWidth = 30;

                    if(MaxHeight < 10)
                        MaxHeight = 10;
                    else
                    {
                        if(MaxHeight > 20)
                            MaxHeight = 20;
                    }

                    LT_New(Handle,
                        LA_Type,        LISTVIEW_KIND,
                        LA_Chars,        30,
                        LA_ID,            GAD_LIST,
                        LALV_Lines,        10,
                        LALV_MaxGrowX,    MaxWidth,
                        LALV_MaxGrowY,    MaxHeight,
                        LALV_ResizeY,    TRUE,
                        GTLV_Labels,    FileList,
                        GTLV_Selected,    Index,
                        LALV_Link,        NIL_LINK,
                        LALV_CursorKey,    TRUE,
                    TAG_DONE);

                    LT_EndGroup(Handle);
                }

                LT_New(Handle,
                    LA_Type,VERTICAL_KIND,
                TAG_DONE);
                {
                    LT_New(Handle,
                        LA_Type,        XBAR_KIND,
                        LAXB_FullSize,    TRUE,
                    TAG_DONE);

                    LT_EndGroup(Handle);
                }

                LT_New(Handle,LA_Type,HORIZONTAL_KIND,
                    LAGR_SameSize,    TRUE,
                    LAGR_Spread,    TRUE,
                TAG_DONE);
                {
                    LT_New(Handle,
                        LA_Type,        BUTTON_KIND,
                        LA_LabelID,        MSG_GLOBAL_USE_GAD,
                        LA_ID,            GAD_USE,
                        LABT_ReturnKey,    TRUE,
                        LABT_ExtraFat,    TRUE,
                    TAG_DONE);

                    LT_New(Handle,
                        LA_Type,        BUTTON_KIND,
                        LA_LabelID,        MSG_TERMPICKFILE_SELECT_GAD,
                        LA_ID,            GAD_SELECT,
                        LABT_ExtraFat,    TRUE,
                    TAG_DONE);

                    LT_New(Handle,
                        LA_Type,        BUTTON_KIND,
                        LA_LabelID,        MSG_GLOBAL_CANCEL_GAD,
                        LA_ID,            GAD_CANCEL,
                        LABT_EscKey,    TRUE,
                        LABT_ExtraFat,    TRUE,
                    TAG_DONE);

                    LT_EndGroup(Handle);
                }

                LT_EndGroup(Handle);
            }

            if(PanelWindow = LT_Build(Handle,
                LAWN_TitleText,        Prompt,
                LAWN_HelpHook,        &GuideHook,
                LAWN_Parent,        Window,
                WA_DepthGadget,        TRUE,
                WA_DragBar,            TRUE,
                WA_RMBTrap,            TRUE,
                WA_Activate,        TRUE,
                WA_SimpleRefresh,    TRUE,
            TAG_DONE))
            {
                struct IntuiMessage    *Message;
                struct Gadget *MsgGadget;
                ULONG MsgClass;
                UWORD MsgCode;
                BOOL Done;

                LT_ShowWindow(Handle,TRUE);

                PushWindow(PanelWindow);

                Done = FALSE;

                do
                {
                    if(Wait(PORTMASK(PanelWindow->UserPort) | SIG_BREAK) & SIG_BREAK)
                        break;

                    while(Message = (struct IntuiMessage *)LT_GetIMsg(Handle))
                    {
                        MsgClass    = Message->Class;
                        MsgCode        = Message->Code;
                        MsgGadget    = (struct Gadget *)Message->IAddress;

                        LT_ReplyIMsg(Message);

                        if(MsgClass == IDCMP_GADGETUP)
                        {
                            switch(MsgGadget->GadgetID)
                            {
                                case GAD_USE:

                                    if(Index != (ULONG)~0)
                                    {
                                        struct Node *Node = GetListNode(Index,FileList);

                                        if(Node)
                                        {
                                            strcpy(Name,Node->ln_Name);

                                            Result = TRUE;
                                        }
                                    }

                                    Done = TRUE;
                                    break;

                                case GAD_CANCEL:

                                    Done = TRUE;
                                    break;

                                case GAD_LIST:

                                    Index = MsgCode;
                                    break;

                                case GAD_SELECT:

                                    strcpy(DummyBuffer,Name);

                                    if(FileRequest = OpenSingleFile(PanelWindow,Prompt,LocaleString(MSG_GLOBAL_SELECT_TXT),Pattern,DummyBuffer,sizeof(DummyBuffer)))
                                    {
                                        FreeAslRequest(FileRequest);

                                        strcpy(Name,DummyBuffer);

                                        if(Type != -1)
                                        {
                                            UBYTE LocalBuffer[MAX_FILENAME_LENGTH];

                                            if(ValidateFile(DummyBuffer,Type,LocalBuffer))
                                            {
                                                *PathPart(Name) = 0;

                                                AddPart(Name,LocalBuffer,sizeof(LocalBuffer));
                                            }
                                        }

                                        Done = Result = TRUE;
                                    }

                                    break;
                            }
                        }

                        if(MsgClass == IDCMP_IDCMPUPDATE)
                        {
                            struct Node *Node;

                            if(Node = GetListNode(Index = MsgCode,FileList))
                            {
                                strcpy(Name,Node->ln_Name);

                                Done = Result = TRUE;

                                LT_PressButton(Handle,GAD_USE);
                            }
                        }
                    }
                }
                while(!Done);

                PopWindow();
            }

            LT_DeleteHandle(Handle);
        }

        DeleteList(FileList);
    }
    else
    {
        strcpy(DummyBuffer,Name);

        if(FileRequest = OpenSingleFile(Window,Prompt,LocaleString(MSG_GLOBAL_SELECT_TXT),Pattern,DummyBuffer,sizeof(DummyBuffer)))
        {
            FreeAslRequest(FileRequest);

            strcpy(Name,DummyBuffer);

            if(Type != -1)
            {
                UBYTE LocalBuffer[MAX_FILENAME_LENGTH];

                if(ValidateFile(DummyBuffer,Type,LocalBuffer))
                {
                    *PathPart(Name) = 0;

                    AddPart(Name,LocalBuffer,sizeof(LocalBuffer));
                }
            }

            return(TRUE);
        }
    }

    return(Result);
}