MACD 5/MACD5.iso/workbench/libs/showifflib.lha/ShowIFF/ShowIFF.c

C/C++ Source or Header | 1992-04-23 | 25.6 KB | 854 lines

/****************************************************************************
**                                                                         **
**  ShowIFF - a comfortable IFF picture viewer for CLI and Workbench       **
**                               by                                        **
**  Christian A. Weber, Bruggerweg 2, CH-8037 Zürich, Switzerland          **
**                                                                         **
**  INTERNET: [e-mail]                                  **
**  UUCP:     cbmehq!cbmswi!mighty![e-mail]              **
**                                                                         **
**  For documentation, refer to the file "ShowIFF.doc".                    **
**                                                                         **
**  All known formats (including Overscan, HAM, Halfbrite, SHAM) are       **
**  supported. If a picture is larger than the screen, you may use the     **
**  mouse to scroll around (If you have enough CHIP memory...)             **
**                                                                         **
**  Any suggestions, donations or bug reports are welcome.                 **
**                                                                         **
*****************************************************************************
**                                                                         **
**  This program is in the Public Domain. Use it at your own risk.         **
**                                                                         **
**  Requirements:  - arp.library V39+                                      **
**                 - iff.library V19+                                      **
**                                                                         **
**  To compile:    - Lattice C compiler V5.04 or above (use 32bit ints)    **
**                 - The file 'arpstartup.o' (My ARP startup module)       **
**                 - The file 'arpglue.lib' for Printf etc.                **
**                                                                         **
*****************************************************************************
**                                                                         **
**    Modification History:                                                **
**    --------------------                                                 **
**                                                                         **
**    15-Oct-87  CHW  V1.0   Created this file!                            **
**    30-Jun-88  CHW  V1.4   Directory scan fixed for FFS, cleaned up      **
**    16-Nov-88  CHW  V1.5   Overscan implemented                          **
**    28-Nov-88  CHW  V1.6   Minimal screen size is now 64x64 pixels       **
**    02-Jan-89  CHW  V1.7   Double-buffering implemented                  **
**    25-Sep-89  CHW  V2.01  Changed to Lattice C and ARP library          **
**    27-Sep-89  CHW  V2.02  Screen scrolling implemented                  **
**    22-Nov-89  CHW  V2.03  Rejects Non-ILBM files correctly              **
**    21-Feb-90  CHW  V2.04  'NoMemForGfx' bug fixed, overscan fixed       **
**    28-Feb-90  CHW  V2.10  SHAM support code added                       **
**    14-Mar-90  CHW  V2.11  Memory fragmentation workaround, cleanup      **
**    08-Apr-90  CHW  V2.12  Pics with more than 6 planes don't guru       **
**    22-Apr-90  CHW  V2.14  New startup code, WB cleanup works now.       **
**    16-Jul-90  CHW  V2.15  Works now properly with MoreRows & OS 2.0     **
**    16-Sep-90  CHW  V2.16  Scrolling SHAM pictures implemented           **
**    03-Oct-90  CHW  V2.17  MaxX0 divided by 2 because of a 2.0 bug       **
**    30-Oct-90  MAB  V2.20  ShowIFF can be turned into an appicon         **
**    11-Jan-91  CHW  V2.21  SHAM color errors fixed                       **
**    11-Jan-91  CHW  V2.22  AppIcon image/pos are taken from .info file   **
**    13-Jan-91  CHW  V2.23  COMMAND mode added, overscan bug fixed (?)    **
**    14-Jan-91  CHW  V2.24  Icon tooltypes added, code moved around       **
**    24-Jan-91  CHW  V2.25  Minor bug fixes                               **
**    03-May-91  CHW  V2.26  Vertical centering and NOCENTER option added  **
**    23-May-91  CHW  V2.27  Pointer option added                          **
**    27-May-91  CHW  V2.28  True Color Table fixed and extended           **
**    23-Jun-91  CHW  V2.29  AppIcon's image can be specified (ICON=...)   **
**    23-Apr-92  CHW  V2.30  RasInfo-bug workaround only under V36-38      **
**                                                                         **
****************************************************************************/

#define APPICON_MODE    /* This works only with the 2.0 include files */

#include <proto/exec.h>
#include <exec/memory.h>
#include <proto/graphics.h>
#include <proto/intuition.h>
#include <graphics/gfxbase.h>
#include <graphics/gfxmacros.h>
#include <arp/arpbase.h>
#include <libraries/dosextens.h>
#include <hardware/custom.h>
#include <workbench/startup.h>
#include <string.h>
#include <libraries/iff.h>                /* Not an official CBM file */

#ifdef APPICON_MODE
#include <proto/icon.h>
#include <proto/wb.h>
#endif

#define VERS    "ShowIFF 2.30"
#define VSTRING    VERS " (23.4.92) by Christian A. Weber"

#define MIN(a,b) ((a)<(b)?(a):(b))
#define MAX(a,b) ((a)>(b)?(a):(b))
#define reg register                    /* My favorite alias :-) */

#define ARG_PATTERN        0                /* Argument numbers for GADS() */
#define ARG_ALL            1
#define ARG_LOOP        2
#define ARG_DELAY        3
#define ARG_NOBREAK        4
#define ARG_NOCENTER    5
#define ARG_NOOVERSCAN    6
#define ARG_POINTER        7
#define ARG_COMMAND        8
#define ARG_INVALID        9

#define OPTIONSTOOLTYPE        "OPTIONS"
#define ICONTOOLTYPE        "ICON"
#define XPOSTOOLTYPE        "ICONXPOS"
#define YPOSTOOLTYPE        "ICONYPOS"
#define ICONNAMETOOLTYPE    "ICONNAME"
#define APPICONPORTNAME        "ShowIFF-AppIcon"
#define DEFAULTAPPICONNAME    "IFF Picture Viewer"

#define PICF_DYNA 1

/*** External references ***/

extern void exit(LONG);                    /* My startup code's exit function */
extern struct Process *ProcessBase;        /* Pointer to our process */
extern struct Library *ArpBase;            /* Also used for DOS functions */
extern struct Custom __far custom;        /* For SHAM/DYNA copper list */
extern BYTE NewOS;                        /* 0 if Kick1.2/1.3, >0 if Kick2.x */


/*** Global definitions ***/

char VersionString[] =
    "\0$VER: " VSTRING "\n\r";

char WindowTitle[] =
    "CON:0/24/640/82/" VSTRING;

char CLI_Template[] =
    "Patterns/...,ALL/s,L=LOOP/s,D=DELAY/k,NB=NOBREAK/s,NC=NOCENTER/s,NO=NOOVERSCAN/s,POINTER/s,COMMAND/k";

char CLI_Help[] =
    VSTRING "\n"
    "Usage: ShowIFF [files or patterns] [ALL] [LOOP] [DELAY delay] [NOBREAK]\n"
    "\t\t[NOCENTER] [NOOVERSCAN] [POINTER] [COMMAND \"Command %s args\"]";

char StdWindowName[] = "NIL:";            /* Standard Workbench window name */
struct Library *IconBase,*IFFBase;        /* Some libraries we use */
char *argv[ARG_INVALID+1];                /* Arguments, filled in by GADS() */
BPTR wbwindow;                            /* Output window for Workbench mode */
struct DiskObject *dobj;                /* Our icon */
LONG wbdelay=3145728;                    /* keep window open for 3 seconds */
IFFFILE ifffile;                        /* Pointer to our IFF file */
LONG delay=1000000;                        /* Time (in seconds) for each picture */
WORD *emptysprite;                        /* ShowIFF's mouse pointer sprite */

struct Picture
{
    struct Screen        *Screen;        /* The picture's screen */
    struct Window        *Window;        /* Window for mouse handling */
    struct BitMap        BitMap;            /* CustomBitMap, can be larger than screen */
    PLANEPTR            MorePlanes[16];    /* Extend bitmap to 24 planes */
    UWORD                *SHAMColors;    /* Ptr to SHAM color table array or NULL */
    WORD                Y0;                /* Beginning of picture relative to screen */
    WORD                MaxX0,MaxY0;    /* Scrolling limits */
    UWORD                ColorCount;        /* Number of colors in color palette */
    UWORD                ColorTab[256];    /* The picture's color table */
    UBYTE                Flags;
} pic1,pic2;                            /* 2 pictures for double-buffering */

struct SHAMChunk
{
    struct Chunk    Chunk;
    UWORD            Version;
    UWORD            Colors[1];            /* open array */
};

/***************************************************************************/
/* Free all planes of a bitmap */

void MyFreeBitMap(reg struct BitMap *bm)
{
    reg LONG planesize=bm->BytesPerRow*bm->Rows,i;

    for(i=0; i<bm->Depth; ++i)
        if(bm->Planes[i])
        {
            FreeMem(bm->Planes[i],planesize);
            bm->Planes[i]=0;
        }
}

/***************************************************************************/
/* Initialize a BitMap structure and allocate CHIP memory for the planes */

BOOL MyAllocBitMap(reg struct BitMap *bm,LONG d,LONG w,LONG h)
{
    reg LONG planesize,i;

    InitBitMap(bm,d,w,h);
    planesize=bm->BytesPerRow*bm->Rows;

    for(i=0; i<d; ++i)
        if(!(bm->Planes[i]=AllocMem(planesize,MEMF_CHIP|MEMF_CLEAR)))
        {
            MyFreeBitMap(bm); return FALSE;
        }
    return TRUE;
}

/***************************************************************************/
/* Adjust the X/Y position of a screen for correct overscan display */

void SetOverscan(reg struct Screen *screen)
{
    reg x=GfxBase->NormalDisplayColumns,y=GfxBase->NormalDisplayRows;

    if(!(screen->ViewPort.Modes & HIRES)) x >>= 1;
    if(  screen->ViewPort.Modes & LACE  ) y <<= 1;

    x = (x-screen->Width ) >> 1;
    y = (y-screen->Height) >> 1; if(y>0) y=0;

    /* Avoid garbled pictures: */
    if(GfxBase->ActiView->DyOffset+y < 0) y = 0-GfxBase->ActiView->DyOffset;

    /* Correct overscan HAM color distortions: */
    if(screen->ViewPort.Modes & HAM)
    {
        if(GfxBase->ActiView->DxOffset+x < 96)
            x=96-GfxBase->ActiView->DxOffset;
    }

#if 0
    Printf("S(%ld,%ld) O(%ld,%ld) ",screen->Width,screen->Height,x,y);
#endif

//    if(NewOS) MoveScreen(screen,x,y);
//    else
    {
        screen->ViewPort.DxOffset = x; screen->ViewPort.DyOffset = y;
        MakeScreen(screen); RethinkDisplay();
    }
}

/***************************************************************************/
/* Create intermediate SHAM copper list if this is an SHAM picture */

void MakeSHAMCopList(struct Picture *pic)
{
    reg struct UCopList *ucop;

    if(!pic->SHAMColors) return;    /* Not an SHAM picture, no work to do */

    if(ucop=AllocMem(sizeof(struct UCopList),MEMF_CLEAR))
    {
        reg struct Screen *s=pic->Screen;
        reg LONG i,j,step=(s->ViewPort.Modes&LACE) ? 2:1;
        reg UWORD copx=GfxBase->ActiView->DxOffset+s->Width;
        reg UWORD y0=s->ViewPort.RasInfo->RyOffset;

        if(pic->Flags & PICF_DYNA) step=1;
        for(i=1; i<(s->Height/step); ++i)
        {
            CWAIT(ucop,pic->Y0+(i-1)*step,(UWORD)((copx>>1)%(UWORD)228))
            for(j=1; j<16; ++j)
                CMOVE(ucop,custom.color[j],pic->SHAMColors[16*(y0+i)+j])
        }
        CEND(ucop)
//        FreeVPortCopLists(&s->ViewPort);
        s->ViewPort.UCopIns = ucop;
        pic->SHAMColors[16*y0]=pic->ColorTab[0];    /* Fix some weird SHAM pics */
        LoadRGB4(&s->ViewPort,&pic->SHAMColors[16*y0],16);
    }
}

/***************************************************************************/
/* Free a picture (that is a window, screen and a custom BitMap) */

void ClosePicture(reg struct Picture *pic)
{
    if(pic->Window)
    {
        ScreenToBack(pic->Screen);
        if(!argv[ARG_POINTER]) ClearPointer(pic->Window);
        CloseWindow(pic->Window);
        pic->Window=0;
    }

    if(pic->Screen)
    {
        CloseScreen(pic->Screen);
        pic->Screen=0;
    }

    MyFreeBitMap(&pic->BitMap);
    RemakeDisplay();    /* remake copperlist to increase MEMF_LARGEST */
}

/***************************************************************************/
/* Allocate a picture (Allocate custom BitMap, open screen and window) */

BOOL OpenPicture(reg struct Picture *pic,reg struct BitMapHeader *bmhd)
{
    struct NewScreen ns;
    struct NewWindow nw;

    ClosePicture(pic);

    memset(&ns,0,sizeof(ns));
    memset(&nw,0,sizeof(nw));
    memset(pic,0,sizeof(*pic));

    ns.Width        = GfxBase->NormalDisplayColumns;
    ns.Height       = GfxBase->NormalDisplayRows;
    ns.Depth        = MAX(1,bmhd->nPlanes);    if(ns.Depth>6) ns.Depth=4;
    ns.ViewModes    = (UWORD)GetViewModes(ifffile);
    ns.Type         = CUSTOMSCREEN|CUSTOMBITMAP|SCREENQUIET|SCREENBEHIND;
    ns.CustomBitMap = &pic->BitMap;

    if(!(ns.ViewModes & HIRES))    { ns.Width  >>= 1; }
    if(  ns.ViewModes & LACE)    { ns.Height <<= 1; }

    if(argv[ARG_NOCENTER])    ns.Height = MIN(bmhd->h,ns.Height);
    else                    ns.Width  = MIN(bmhd->w,ns.Width);

    ns.Width  = MAX(128,ns.Width);
    ns.Height = MAX(128,ns.Height);

    if(!argv[ARG_NOOVERSCAN])
    {
        if((bmhd->w > ns.Width) && (bmhd->w <= (ns.ViewModes&HIRES ? 768:384)))
            ns.Width = bmhd->w;

        if((bmhd->h>ns.Height) && (bmhd->h<=(ns.Height+(ns.ViewModes&LACE?80:40))))
            ns.Height = bmhd->h;
    }

    if(MyAllocBitMap(&pic->BitMap,MAX(bmhd->nPlanes,ns.Depth),
                MAX(bmhd->w,ns.Width),MAX(bmhd->h,ns.Height)))
    {
        reg olddepth      = pic->BitMap.Depth;
        pic->BitMap.Depth = ns.Depth;
        pic->Screen       = OpenScreen(&ns);
        pic->BitMap.Depth = olddepth;

        if(nw.Screen=pic->Screen)
        {
            nw.Width      = ns.Width;
            nw.Height     = ns.Height;
            nw.IDCMPFlags = MOUSEBUTTONS|MOUSEMOVE|DELTAMOVE|VANILLAKEY;
            nw.Flags      = BACKDROP|BORDERLESS|ACTIVATE|SIMPLE_REFRESH
                                |NOCAREREFRESH|REPORTMOUSE|RMBTRAP;
            nw.Type       = CUSTOMSCREEN;

            if(pic->Window=OpenWindow(&nw))
            {
                pic->Y0=(ns.Height-bmhd->h)>>1; if(pic->Y0<0) pic->Y0=0;

                pic->MaxX0 = bmhd->w-ns.Width;
                pic->MaxY0 = bmhd->h-ns.Height;

                /*
                **    In 2.0 there's this RasInfo scrolling bug, they
                **    said they'll fix it for newer ROMs, so we'll do an
                **    explicit version check
                */
                if(ns.ViewModes & HIRES)
                {
                    if(    (GfxBase->LibNode.lib_Version >= 36)
                    &&    (GfxBase->LibNode.lib_Version <= 38))
                     pic->MaxX0 >>= 1;
                }

                if(!argv[ARG_POINTER])
                    SetPointer(pic->Window,emptysprite,1L,16L,0L,0L);

                if(bmhd->nPlanes == 24)
                {
                    static UWORD truecoltab[32] =
                    {
                        0x000,0x00C,0x0C0,0x0CC,0xC00,0xC0C,0xCC0,0xCCC,
                        0x080,0x08C,0x0F0,0x0FC,0xC80,0xC8C,0xCF0,0xCFC,
                        0x800,0x80C,0x8C0,0x8CC,0xF00,0xF0C,0xFC0,0xFCC,
                        0x880,0x88C,0x8F0,0x8FC,0xF80,0xF8C,0xFF0,0xFFC
                    };
                    memcpy(pic->ColorTab,truecoltab,sizeof(truecoltab));
                    pic->Screen->BitMap.Planes[0]=pic->BitMap.Planes[23];    /* B7 */
                    pic->Screen->BitMap.Planes[1]=pic->BitMap.Planes[15];    /* G7 */
                    pic->Screen->BitMap.Planes[2]=pic->BitMap.Planes[7];    /* R7 */
                    pic->Screen->BitMap.Planes[3]=pic->BitMap.Planes[14];    /* G6 */
                    pic->Screen->BitMap.Planes[4]=pic->BitMap.Planes[6];    /* R7 */
                    pic->ColorCount = (ns.ViewModes&HIRES) ? 16:32;
                }
                else
                {
                    if(!(pic->ColorCount=GetColorTab(ifffile,pic->ColorTab)))
                    {
                        /* Provide default colors for pictures without a CMAP */
                        pic->ColorCount=2;
                        pic->ColorTab[0]=0xeca; pic->ColorTab[1]=0x000;
                    }
                }

                if(pic->ColorCount>32) pic->ColorCount = 32; /* Old DigiView */
                LoadRGB4(&pic->Screen->ViewPort,pic->ColorTab,pic->ColorCount);
                SetOverscan(pic->Screen);
                return TRUE;
            }
        }
    }
    ClosePicture(pic);
    return FALSE;
}

/***************************************************************************/
/* Close all resources and exit to CLI/WorkBench */

void Fail(reg char *reason)
{
    Puts(reason);

    ClosePicture(&pic1); ClosePicture(&pic2);
    if(ifffile)    CloseIFF(ifffile);
    if(dobj)    FreeDiskObject(dobj);

    if(wbwindow)
    {
        WaitForChar(wbwindow,wbdelay);    /* Let them see our text */
        Close(wbwindow);
    }

    if(IFFBase)        CloseLibrary(IFFBase);
    if(IconBase)    CloseLibrary(IconBase);

    exit(0L);    /* Back to the startup code (important for Workbench) */
}

/***************************************************************************/
/* That's the big one! Load & display a picture (with mouse-scrolling),
   return FALSE if user presses the RMB (abort), else return TRUE */

BOOL ShowPicture(reg char *name)
{
    reg BOOL cont=TRUE;
    reg struct BitMapHeader *bmhd;

    if(!strcmp(name+strlen(name)-5,".info")) return TRUE;    /* Skip icons */
    Printf("%s ... ",name);

    if(ifffile) CloseIFF(ifffile);

    if(!(ifffile=OpenIFF(name)))
    {
        Puts("- not an IFF file!");
        return TRUE;
    }

    if(*(((ULONG *)ifffile)+2) != ID_ILBM)
    {
        Puts("- not an ILBM file!");
        return TRUE;
    }

    if(!(bmhd=GetBMHD(ifffile)))
    {
        Printf("- Mangled IFF file (Error %ld)\n",IFFError());
        return TRUE;
    }

    Printf("%ld x %ld x %ld ",bmhd->w,bmhd->h,bmhd->nPlanes);
retry:
    if(OpenPicture(&pic1,bmhd))
    {
        if(DecodePic(ifffile,&pic1.BitMap))
        {
            reg struct SHAMChunk *sham;
            reg LONG i;
            reg WORD xoff=0,yoff=0;

            if(pic1.Y0)
            {
                struct Screen *s=pic1.Screen;
                ScrollRaster(&s->RastPort,0,-pic1.Y0,0,0,
                    s->BitMap.BytesPerRow<<3,s->BitMap.Rows);
            }

            if(sham=FindChunk(ifffile,ID_SHAM))
            {
                Printf("SHAM ");
                if(sham->Version == 0)
                {
                    pic1.SHAMColors = sham->Colors;
                }
                else Printf("Unsupported mode: %ld ",(LONG)sham->Version);

                MakeSHAMCopList(&pic1);
            }

            if(sham=FindChunk(ifffile,ID_CTBL))
            {
                Printf("DYNA ");
                pic1.SHAMColors = &sham->Version;    /* DYNA has no version */
                pic1.Flags |= PICF_DYNA;
                MakeSHAMCopList(&pic1);
            }

            ScreenToFront(pic1.Screen);
            ClosePicture(&pic2);
            for(i=delay*50L; i>=0; --i)
            {
                reg struct IntuiMessage *msg;

                WaitTOF();
                while(msg=(struct IntuiMessage *)GetMsg(pic1.Window->UserPort))
                {
newmsg:                switch(msg->Class)
                    {
                    case MOUSEMOVE:

                        xoff+=msg->MouseX;
                        yoff+=msg->MouseY;
                        if(xoff>pic1.MaxX0) xoff=pic1.MaxX0;
                        if(xoff<0) xoff=0;
                        if(yoff>pic1.MaxY0) yoff=pic1.MaxY0;
                        if(yoff<0) yoff=0;
                        pic1.Screen->ViewPort.RasInfo->RxOffset=xoff;
                        pic1.Screen->ViewPort.RasInfo->RyOffset=yoff;
                        if(pic1.SHAMColors)
                        {
                            reg struct IntuiMessage *m2;
                            MakeSHAMCopList(&pic1);
                            while(m2=GetMsg(pic1.Window->UserPort))
                            {
                                ReplyMsg(msg); msg=m2;
                                if(msg->Class == MOUSEMOVE)
                                {
                                    xoff+=msg->MouseX;
                                    yoff+=msg->MouseY;
                                }
                                else goto newmsg;
                            }
                        }
                        /* ScrollVPort(&pic1.Screen->ViewPort); */
                        MakeScreen(pic1.Screen); RethinkDisplay();
                        break;

                    case VANILLAKEY:
                        if(msg->Code == 'c') if(argv[ARG_COMMAND])
                        {
                            char buf[200];
                            SPrintf(buf,argv[ARG_COMMAND],name,name);
                            Execute(buf,NULL,Output());
                        }
                        break;

                    case MOUSEBUTTONS:
                        if(!argv[ARG_NOBREAK])
                        {
                            if(msg->Code == MENUDOWN)    goto usrbreak;
                            if(msg->Code == SELECTDOWN)    goto showend;
                        }
                        break;
                    }
                    ReplyMsg(msg);
                }
                if(!argv[ARG_NOBREAK]) if(CheckAbort(NULL))
                {
usrbreak:            Puts("***BREAK"); cont=FALSE; goto showend2;
                }
            }
showend:    Puts("- Done");
showend2:    pic2=pic1; memset(&pic1,0,sizeof(pic1));
        }
        else
        {
            ClosePicture(&pic1);
            Printf("- Decode error: %ld\n",IFFError());
        }
    }
    else if(pic2.Window)
    {
        ClosePicture(&pic2); goto retry;
    }
    else Puts("- Can't open screen!");
    return cont;
}

/***************************************************************************/
/* Expand a pattern and call ShowPicture() for each matching file,
   return FALSE if the user presses ^C or ShowPicture() returns FALSE */

BOOL ShowPattern(char *pathname)
{
    char buf[256];
    reg BPTR file;
    reg BOOL cont=TRUE;

    if(PreParse(pathname,buf))    /* TRUE if name contains any wildcards */
    {
        reg struct {
            struct AnchorPath APath;
            char   FullPath[255];        /* cheap way to extend ap_Buf[] */
        } *myanchor;
iswild:
        if(myanchor=ArpAlloc(sizeof(*myanchor)))
        {
            reg BOOL showit=TRUE;
            reg LONG error;

            myanchor->APath.ap_StrLen = 255;    /* Want full path built */
            myanchor->APath.ap_Flags = APF_DOWILD;
            myanchor->APath.ap_BreakBits=SIGBREAKF_CTRL_C;

            error=FindFirst(pathname,&myanchor->APath);
            while(!error)
            {
                /* +1 because of a lattice bug */
                if(SetSignal(0L,SIGBREAKF_CTRL_E+1) & SIGBREAKF_CTRL_E)
                {
                    Puts("***DIR BREAK"); showit=FALSE;
                    /* myanchor->APath.ap_Flags &= ~APF_DODIR; */
                }

                if(myanchor->APath.ap_Info.fib_DirEntryType>=0)    /* Dir */
                {
                    if(argv[ARG_ALL])
                    {
                        if(!(myanchor->APath.ap_Flags & APF_DIDDIR))
                        {
                            myanchor->APath.ap_Flags |= APF_DODIR;
                            showit=TRUE;
                        }
                        myanchor->APath.ap_Flags &= ~APF_DIDDIR;
                    }
                }
                else if(showit) if(!ShowPicture(myanchor->APath.ap_Buf))
                {
                    cont = FALSE; break;
                }
                error=FindNext(&myanchor->APath);
            }

            FreeAnchorChain(&myanchor->APath);

            switch(error)
            {
                case 0:                            break;

                case ERROR_BREAK:                Puts("***BREAK"); cont=FALSE; break;

                case ERROR_OBJECT_NOT_FOUND:    Puts("File not found."); break;

                case ERROR_BUFFER_OVERFLOW:        Puts("Path too long!"); break;

                case ERROR_NO_MORE_ENTRIES:        break;    /* Normal termination */

                default:    Printf("IO error %ld!\n",error); break;
            }
        }
        else Fail("No mem for anchor!");
    }
    else if(file=Open(pathname,MODE_OLDFILE))    /* Just one file ? */
    {
        Close(file); return ShowPicture(pathname);
    }
    else    /* No wildcards, and not a file: it's a device or a directory */
    {
        strcpy(buf,pathname); TackOn(pathname=buf,"*");
        goto iswild;    /* Not really elegant, but it works */
    }

    return cont;
}

#ifdef APPICON_MODE
/***************************************************************************/
/* Started without arguments: create or delete our appicon */

void AppIconStuff(void)
{
    struct Library *WorkbenchBase;
    struct MsgPort *msgport;
      struct AppIcon *ai;
    struct AppMessage *amsg;

    if(!(WorkbenchBase = OpenLibrary(WORKBENCH_NAME,36))) return;

    if(msgport=FindPort(APPICONPORTNAME))    /* Already running ? */
    {
        Signal(msgport->mp_SigTask,SIGBREAKF_CTRL_C);    /* Kill it */
    }
    else if(msgport = CreatePort(APPICONPORTNAME,0))
    {
        char *tooltype;
        struct DiskObject *appdobj=NULL;

        if(tooltype=FindToolType(dobj->do_ToolTypes,ICONTOOLTYPE))
            appdobj=GetDiskObject(tooltype);
        if(!appdobj) appdobj=dobj;

        if(tooltype=FindToolType(dobj->do_ToolTypes,XPOSTOOLTYPE))
            appdobj->do_CurrentX = Atol(tooltype);
        else
            appdobj->do_CurrentX = NO_ICON_POSITION;

        if(tooltype=FindToolType(dobj->do_ToolTypes,YPOSTOOLTYPE))
            appdobj->do_CurrentY = Atol(tooltype);
        else
            appdobj->do_CurrentY = NO_ICON_POSITION;

        if(!(tooltype=FindToolType(dobj->do_ToolTypes,ICONNAMETOOLTYPE)))
            tooltype = DEFAULTAPPICONNAME;

        if(ai = AddAppIconA(0,0,tooltype,msgport,NULL,appdobj,NULL))
        {
            while(!(Wait(1L << msgport->mp_SigBit | SIGBREAKF_CTRL_C)
                         & SIGBREAKF_CTRL_C))
            {
                reg BPTR oldcos;

                if(wbwindow=Open(WindowTitle,MODE_OLDFILE))
                {
                    oldcos = ProcessBase->pr_COS;
                    ProcessBase->pr_COS = wbwindow;
                }

                while(amsg = GetMsg(msgport))
                {
                    reg i,cont=TRUE;
                    struct WBArg *arg = amsg->am_ArgList;
                      for(i=0; (i < amsg->am_NumArgs) && cont; i++,arg++)
                      {
                        reg BPTR oldcd=0;
                        if(arg->wa_Lock) oldcd=CurrentDir(arg->wa_Lock);
                        else DisplayBeep(NULL);
                        cont=ShowPattern(arg->wa_Name&&*arg->wa_Name ? arg->wa_Name:"*");
                        if(oldcd) CurrentDir(oldcd);
                    }
                    ReplyMsg(amsg);
                }
                ClosePicture(&pic2);         /* Close last screen */
                if(wbwindow)
                {
                    WaitForChar(wbwindow,2097152);    /* Wait 2 seconds */
                    ProcessBase->pr_COS = oldcos;
                    Close(wbwindow); wbwindow=0;
                    SetSignal(0,SIGBREAKF_CTRL_C);    /* Clear break sig */
                }
            }
            RemoveAppIcon(ai);
        }

        if(appdobj != dobj) FreeDiskObject(appdobj);

        /* Make sure there are no more messages pending */
        while(amsg = GetMsg(msgport)) ReplyMsg(amsg);
        DeletePort(msgport);
    }
    CloseLibrary(WorkbenchBase);
}
#endif

/***************************************************************************/
/* Main program: parse the command line or WorkBench-args */

void ARPMain(LONG arglen,reg char *argline)
{
       if(!(IconBase = OpenLibrary("icon.library",0)))    Fail("No icon.library!");
    if(!(IFFBase  = OpenLibrary(IFFNAME,0L)))        Fail("No iff.library!");

    if(IFFBase->lib_Version < IFFVERSION)
        Puts("WARNING: you have an old version of iff.library!");

    emptysprite=ArpAllocMem(20L,MEMF_CHIP|MEMF_CLEAR);

    if(arglen)        /* From CLI */
    {
        if(*argline != '\n')
        {
            if(GADS(argline,strlen(argline),CLI_Help,argv,CLI_Template)>0)
            {
                if(argv[ARG_DELAY]) delay=Atol(argv[ARG_DELAY]);
                do
                {
                    reg char **pattern=(char **)argv[ARG_PATTERN];
                    if(*pattern)
                    {
                        while(*pattern) if(!ShowPattern(*pattern++)) goto done;
                    }
                    else ShowPattern("*");
                } while(argv[ARG_LOOP]);
done: ;
            }
            else Fail(CLI_Help);
        }
        else Fail(CLI_Help);
    }
    else    /* Called from Workbench */
    {
        reg struct WBStartup *startup = (struct WBStartup *)argline;

        argv[ARG_ALL]        = (void *)TRUE;            /* Set defaults */
//        argv[ARG_LOOP]       = (void *)FALSE;
//        argv[ARG_NOBREAK]    = (void *)FALSE;
//        argv[ARG_NOOVERSCAN] = (void *)FALSE;

        if(dobj = GetDiskObject(startup->sm_ArgList->wa_Name))
        {
            reg char *tooltype;
            if(tooltype=FindToolType(dobj->do_ToolTypes,OPTIONSTOOLTYPE))
            {
                GADS(tooltype,strlen(tooltype),NULL,argv,CLI_Template);
                if(argv[ARG_DELAY]) delay=Atol(argv[ARG_DELAY]);
            }
        }
        if(startup->sm_NumArgs > 1)    /* Started with some arguments */
        {
            reg i;
            struct WBArg *arg = startup->sm_ArgList;

            if(wbwindow=Open(WindowTitle,MODE_OLDFILE))        /* Open window */
                ProcessBase->pr_COS=wbwindow;

            for(i=1; i<startup->sm_NumArgs; ++i)
            {
                arg++;
                if(arg->wa_Lock) CurrentDir(arg->wa_Lock);
                else Puts("Can't lock dir!");
                if(arg->wa_Name && *arg->wa_Name)
                {
                    if(!ShowPattern(arg->wa_Name)) break;
                }
                else ShowPattern("*");
            }
        }
        else    /* no arguments, just clicked */
#ifdef APPICON_MODE
        if(NewOS) AppIconStuff(); else
#endif
        {
            if(wbwindow=Open(WindowTitle,MODE_OLDFILE))        /* Open window */
                ProcessBase->pr_COS=wbwindow;

            wbdelay=6291456;    /* 6 seconds delay */
#ifdef GERMAN
            Fail("Bitte klicken Sie alle gewünschten Bild-Dateien oder Schubladen bei ge-\n"
             "drückter SHIFT-Taste an, klicken Sie danach 2x auf das ShowIFF-Piktogramm.");
#else
            Fail("Please select all drawers and files to view while holding\n"
             "down the SHIFT key, then double-click the ShowIFF icon.");
#endif
        }
    }
    wbdelay=1048576;            /* One second delay */
#ifdef GERMAN
    Fail("Fertig.");
#else
    Fail("All done.");
#endif

}