Bug in ScrollRaster() call removed

1 files changed, 1522 insertions, 0 deletions

diff --git a/ShowIFF/ShowIFF.c b/ShowIFF/ShowIFF.c
new file mode 100644
index 0000000..20acec5
--- /dev/null
+++ b/ShowIFF/ShowIFF.c
@@ -0,0 +1,1522 @@
+/*
+**
+**	$Id: $
+**	$Revision: $
+**
+**	$Filename: ShowIFF/ShowIFF.c $
+**	$Author: Christian A. Weber $
+**	$Release: $
+**	$Date: $
+**
+**  NAME
+**		ShowIFF - a fast IFF picture viewer for Workbench and Shell
+**
+**		>>>> For full documentation, see ShowIFF.doc <<<<
+**
+**  DESCRIPTION
+**		ShowIFF can display any Amiga IFF pictures with up to 24 bitplanes
+**		(24 bit pictures are displayed in "true color" with max. colors).
+**		All known formats (HAM, HAM8, Halfbrite) and all display modes
+**		like NTSC, PAL, VGA, A2024, ... are supported.
+**		If a picture is larger than the screen, you can use the mouse to
+**		scroll around.
+**		ShowIFF can be used from Workbench or Shell, it can create an
+**		AppIcon. It can display single files or whole drawers or disks.
+**
+**  REQUIREMENTS
+**		- iff.library V22+
+**		- Amiga OS 2.0 or newer (3.0 for AGA modes)
+**		- Original, Enhanced or AGA chipset
+**		- to compile: SAS/C compiler V6
+**
+**  AUTHOR
+**		Christian A. Weber
+**
+**		Internet:    weber@amiga.icu.net.ch
+**		UUCP:        chris@limmat.net.ch
+**		CBMNET:      chris@mighty.adsp.sub.org
+**		Snail mail:  Bruggerweg 2, CH-8037 Zürich, Switzerland.
+**
+**		Suggestions, bug reports or donations are welcome.
+**
+**		COPYRIGHT (C) 1992 BY CHRISTIAN A. WEBER. ALL RIGHTS RESERVED.
+**		COPYRIGHT (C) 1987-1993 BY CHRISTIAN A. WEBER. ALL RIGHTS RESERVED.
+**		THIS PROGRAM MAY BE DISTRIBUTED FOR NON PROFIT PURPOSES ONLY.
+**		NO WARRANTY. USE AT YOUR OWN RISK.
+**
+**  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
+**    29-Jul-92  CHW  V2.31  Compiles with new IFF includes, 8 bitplanes
+**    15-Oct-92  SG   V3.00  New display code, true AGA support
+**    01-Dec-92  CHW  V3.1   ARP support removed, substancial rewrite
+**    04-Feb-92  CHW  V3.4   Bug in ScrollRaster() call removed (would crop)
+*/
+
+// #define VERBOSE
+
+#include <hardware/custom.h>		/* For SHAM/DYNA support ONLY */
+#include <proto/exec.h>
+#include <exec/memory.h>
+#include <exec/execbase.h>
+#include <proto/utility.h>
+#include <utility/utility.h>
+#include <proto/graphics.h>
+#include <graphics/gfxbase.h>
+#include <graphics/gfxmacros.h>
+#include <graphics/displayinfo.h>
+#include <proto/intuition.h>
+#include <intuition/intuitionbase.h>
+#include <proto/icon.h>
+#include <workbench/icon.h>
+#include <proto/wb.h>
+#include <workbench/startup.h>
+#include <proto/dos.h>
+
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <libraries/iff.h>
+
+#include "showiff_rev.h"
+
+
+/****************************************************************************
+**	Some useful macros
+*/
+
+#define MAX(a,b)		((a)>(b)?(a):(b))
+#define OSVERSION(ver)	(IntuitionBase->LibNode.lib_Version >= (ver))
+#define HAS_AGA			(GfxBase->ChipRevBits0 & GFXF_AA_ALICE)
+
+#define PICF_DYNA		1
+
+#define MAXCOLORS		256
+
+#define XOSCAN			0	/* Scroll if picture is bigger than screen + XOSCAN */
+#define YOSCAN			16	/* Scroll if picture is bigger than screen + YOSCAN */
+
+
+/****************************************************************************
+**	Stuctures
+*/
+
+typedef struct
+{
+	UBYTE	R, G, B;		/* Red, Green, Blue values (0..255) */
+} RGBColor;
+
+
+struct Picture
+{
+	struct Screen	*Screen;			/* The picture's screen */
+	struct Window	*Window;			/* Window for mouse handling */
+	struct BitMap	*BitMap;			/* BitMap, can be larger than screen */
+	UWORD			*SHAMColors;		/* SHAM color table array or NULL */
+	WORD			Y0;					/* Y of picture relative to screen */
+	UWORD			PicW, PicH;			/* Total image dimensions */
+	UWORD			ColorCount;			/* # of colors in color palette */
+	RGBColor		Palette[MAXCOLORS];	/* The picture's color palette */
+	UBYTE			Flags;				/* See PICF_... */
+};
+
+struct SHAMChunk
+{
+	struct IFFL_Chunk	Chunk;
+	UWORD				Version;
+	UWORD				Colors[1];		/* open array */
+};
+
+
+/****************************************************************************
+**	Tooltypes and other constant strings
+*/
+
+#define OPTIONSTOOLTYPE		"OPTIONS"
+#define ICONTOOLTYPE		"ICON"
+#define XPOSTOOLTYPE		"ICONXPOS"
+#define YPOSTOOLTYPE		"ICONYPOS"
+#define ICONNAMETOOLTYPE	"ICONNAME"
+#define APPICONPORTNAME		"ShowIFF-AppIcon"
+#define DEFAULTAPPICONNAME	"IFF Picture Viewer"
+
+
+/****************************************************************************
+**	External references
+*/
+
+extern struct Process *ProcessBase;		/* Pointer to our process */
+extern struct Custom __far custom;		/* For SHAM/DYNA copper list */
+
+
+/****************************************************************************
+**	Global variables
+*/
+
+struct Library			*UtilityBase, *IconBase, *WorkbenchBase;
+struct GfxBase			*GfxBase;
+struct IntuitionBase	*IntuitionBase;
+struct Library			*IFFBase;		/* Nothing goes without that */
+
+struct DiskObject	*dobj;				/* Our icon */
+IFFL_HANDLE			ifffile;			/* IFF file handle */
+struct Picture		pic1, pic2;			/* 2 pictures for double buffering */
+BPTR				wbwindow;			/* Output window for Workbench mode */
+BPTR				oldcos;				/* Old output file handle */
+LONG				delay = 0x7fffffff;	/* Time (in jiffies) for each picture */
+LONG				monitorid;			/* Monitor ID or 0 if no specific monitor */
+
+UWORD __chip		emptysprite[8];		/* ShowIFF's mouse pointer sprite */
+
+
+static char VersionString[] =
+	VERSTAG " by Christian A. Weber and Peter W. Simeon\n\r";
+
+static char WindowTitle[] =
+	"CON:10/24/600/92/" VERS " (" DATE ")/AUTO/CLOSE";
+
+char StdWindowName[] = "NIL:";	/* Default Workbench window name */
+
+
+/*
+**	CLI_Template and argv are used for ArgsStartup20.o. Argv receives the
+**	arguments from a ReadArgs() call in the startup code. CLI_Help will
+**	be printed if no arguments are specified on the command line.
+*/
+
+char CLI_Template[] =
+	"Patterns/M,ALL/S,D=DELAY/N,L=LOOP/S,MONITOR/K,NB=NOBREAK/S,NOCENTER/S,"
+	"NO=NOOVERSCAN/S,POINTER/S,CMD=COMMAND/K";
+
+static char CLI_Help[] =
+	"Usage: ShowIFF [files or patterns] [ALL] [DELAY delay] [LOOP] [MONITOR id]\n"
+	"\t[NOBREAK] [NOCENTER] [NOOVERSCAN] [POINTER] [COMMAND \"Command %s args\"]\n";
+
+struct
+{
+	char	**Patterns;
+	LONG	AllFlag;
+	LONG	*DelayPtr;
+	LONG	LoopFlag;
+	char	*Monitor;
+	LONG	NoBreakFlag;
+	LONG	NoCenterFlag;
+	LONG	NoOverscanFlag;
+	LONG	PointerFlag;
+	char	*Command;
+} argv;
+
+
+/****************************************************************************
+**	Make sure a value is between two borders
+*/
+
+LONG SetBounds(LONG is, LONG min, LONG max)
+{
+	if (is > max) is = max;
+	if (is < min) is = min;
+	return is;
+}
+
+
+/****************************************************************************
+**	Get a positive integer in hex ($1234 or 0x1A2b) or decimal
+*/
+
+static ULONG GetNumber(char *string)
+{
+	ULONG result = 0;
+	char c;
+
+	if ((string[0] == '0') && (string[1] == 'x'))
+	{
+		string++;
+		goto hex;
+	}
+	else if (string[0] == '$')
+	{
+hex:
+		string++;
+		while (c = *string++)
+		{
+			if (c >= '0' && c <= '9')
+				result = result * 16 + c - '0';
+			else if (c >= 'a' && c <= 'f')
+				result = result * 16 + 10 + c - 'a';
+			else if (c >= 'A' && c <= 'F')
+				result = result * 16 + 10 + c - 'A';
+		}
+	}
+	else
+	{
+		while (*string >= '0' && *string <= '9')
+			result = result * 10 + (*string++ - '0');
+	}
+
+	return result;
+}
+
+
+/***************************************************************************
+**	Get the secondary error from iff.library and display an error text
+*/
+
+static void PrintIFFError(void)
+{
+	char *text;
+
+	switch (IFFL_IFFError() )
+	{
+		case IFFL_ERROR_OPEN:
+			text = "Can't open file";
+			break;
+
+		case IFFL_ERROR_READ:
+			text = "Error reading file";
+			break;
+
+		case IFFL_ERROR_NOMEM:
+			text = "Not enough memory";
+			break;
+
+		case IFFL_ERROR_NOTIFF:
+			text = "Not an IFF file";
+			break;
+
+		case IFFL_ERROR_NOBMHD:
+			text = "No IFF BMHD found";
+			break;
+
+		case IFFL_ERROR_NOBODY:
+			text = "No IFF BODY found";
+			break;
+
+		case IFFL_ERROR_BADCOMPRESSION:
+			text = "Unsupported compression mode";
+			break;
+
+		default:
+			text = "Unspecified error";
+			break;
+	}
+
+	Printf("%s\n", text);
+}
+
+
+/***************************************************************************
+**	V37 replacement for FreeBitMap()
+*/
+
+void MyFreeBitMap(struct BitMap *bm)
+{
+	if (OSVERSION(39) )
+	{
+		FreeBitMap(bm);
+	}
+	else					/* Running under V37 */
+	{
+		LONG	planesize = bm->BytesPerRow * bm->Rows;
+		int		i;
+
+		for (i = 0; i < bm->Depth; ++i)
+		{
+			if (bm->Planes[i])
+			{
+				FreeMem(bm->Planes[i], planesize);
+			}
+		}
+		FreeVec(bm);
+	}
+}
+
+
+/***************************************************************************
+**	Allocate a BitMap structure and allocate CHIP memory for the planes.
+*/
+
+struct BitMap *MyAllocBitMap(LONG depth, LONG width, LONG height)
+{
+	struct BitMap *bm;
+
+	if (OSVERSION(39) )
+	{
+		bm = AllocBitMap(width, height, depth, BMF_CLEAR | BMF_DISPLAYABLE, NULL);
+	}
+	else
+	{
+		LONG planesize, bmsize = sizeof(struct BitMap);
+
+		/*
+		**	If the bitmap has more than 8 planes, we add the size of the
+		**	additional plane pointers to the amount of memory we allocate
+		**	for the bitmap structure.
+		*/
+		if (depth > 8)
+			bmsize += sizeof(PLANEPTR) * (depth-8);
+
+		if (bm = AllocVec(bmsize, MEMF_PUBLIC | MEMF_CLEAR) )
+		{
+			int i;
+
+			InitBitMap(bm, depth, width, height);
+			planesize = bm->BytesPerRow * bm->Rows;
+
+			for (i = 0; i < depth; ++i)
+			{
+				if (bm->Planes[i] = AllocMem(planesize, MEMF_CHIP | MEMF_CLEAR) )
+				{
+				}
+				else
+				{
+					MyFreeBitMap(bm);
+					bm = NULL;
+	return bm;
+}
+
+
+/****************************************************************************
+**	Load a color palette (24 bit resolution)
+*/
+
+static void LoadRGB8(struct ViewPort *vp, RGBColor *color, int count)
+{
+	int i;
+
+	/*
+	**	Avoid crash under V39
+	*/
+	if (count > vp->ColorMap->Count)
+		count = vp->ColorMap->Count;
+
+	for (i=0; i < count; ++color, ++i)
+	{
+		if (OSVERSION(39) )
+		{
+			SetRGB32(vp, i, color->R<<24, color->G<<24, color->B<<24);
+		}
+		else
+		{
+			SetRGB4(vp, i, color->R>>4, color->G>>4, color->B>>4);
+		}
+	}
+}
+
+
+/****************************************************************************
+**	Create a truecolor 24bit palette with <1 << totalbits> entries.
+**	The bitplanes will have the order G6G7R7B7 or G4G5G6G7R6R7B6B7 ...
+**	                          Plane#: 0 1 2 3     0 1 2 3 4 5 6 7
+**	The result is the number of green planes (red and blue have always the
+**	same number and can be calculated as (totalbits-greenbits)/2).
+*/
+
+static int CreateTrueColorPalette(RGBColor *palette, int totalbits)
+{
+	int numcolors, i, rbits, gbits, bbits, rlevels, glevels, blevels;
+
+	numcolors = 1 << totalbits;
+
+	/*
+	**	Divide the total number of bits into the bits for r/g/b. Green is
+	**	the most important color, so it gets the remaining bits as well.
+	*/
+	rbits = gbits = bbits = totalbits / 3;
+	gbits += totalbits % 3;
+
+	rlevels = 1 << rbits;
+	glevels = 1 << gbits;
+	blevels = 1 << bbits;
+
+	for (i=0; i<numcolors; ++palette, ++i)
+	{
+		palette->G = (( i                   % glevels) * 0xFF) / (glevels-1);
+		palette->R = (((i >>  gbits)        % rlevels) * 0xFF) / (rlevels-1);
+		palette->B = (((i >> (gbits+rbits)) % blevels) * 0xFF) / (blevels-1);
+	}
+
+	return gbits;
+}
+
+
+/****************************************************************************
+**	Create intermediate SHAM copper list if this is an SHAM picture.
+**	This feature will probably be removed; with AGA it's useless anyway.
+*/
+
+void MakeSHAMCopList(struct Picture *pic)
+{
+	struct UCopList *ucop;
+
+	if (!pic->SHAMColors) return;	/* Not an SHAM picture, no work to do */
+
+	if (ucop = AllocMem(sizeof(*ucop), MEMF_PUBLIC | MEMF_CLEAR) )
+	{
+		struct Screen *s = pic->Screen;
+		LONG i, j, step = (s->ViewPort.Modes&LACE) ? 2:1;
+		UWORD copx = GfxBase->ActiView->DxOffset + s->Width;
+		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(struct Picture *pic)
+{
+	if (pic->Window)
+	{
+		ScreenToBack(pic->Screen);
+		ClearPointer(pic->Window);
+		CloseWindow(pic->Window);
+		pic->Window = NULL;
+	}
+
+	if (pic->Screen)
+	{
+		CloseScreen(pic->Screen);
+		pic->Screen = NULL;
+	}
+
+	if (pic->BitMap)
+	{
+		MyFreeBitMap(pic->BitMap);
+		pic->BitMap = NULL;
+	}
+
+	RemakeDisplay();	/* remake copper list to increase MEMF_LARGEST */
+}
+
+
+/****************************************************************************
+**	Get the view mode for a picture. If there is a CAMG chunk, we just
+**	return its contents. If there is none, we ask the graphics library for
+**	help. If it can't help us (<3.0), we calculate a view mode by hand.
+*/
+
+static ULONG GetBestViewMode(IFFL_HANDLE iff, struct IFFL_BMHD *bmhd)
+{
+	ULONG viewmode;
+
+	/*
+	**	We don't want iff.library to give us a default viewmode if no
+	**	CAMG is present, so we must check first for a CAMG, and only
+	**	if it's there we can call IFFL_GetViewModes()
+	*/
+	if (IFFL_FindChunk(iff, ID_CAMG) )
+	{
+		viewmode = IFFL_GetViewModes(iff);
+#ifdef VERBOSE
+		Printf("CAMG: $%08lx ", viewmode);
+#endif
+	}
+	else
+	{
+		viewmode = INVALID_ID;
+
+		if (OSVERSION(39) )
+		{
+			viewmode = BestModeID(
+							BIDTAG_NominalWidth,	bmhd->w,
+							BIDTAG_NominalHeight,	bmhd->h,
+							BIDTAG_DesiredWidth,	bmhd->w,
+							BIDTAG_DesiredHeight,	bmhd->h,
+							BIDTAG_Depth,			bmhd->nPlanes,
+
+//							BIDTAG_MonitorID,		monitorid,
+
+							monitorid ? BIDTAG_MonitorID : TAG_IGNORE,
+													monitorid,
+							TAG_DONE
+						);
+#ifdef VERBOSE
+			Printf("BESTID: $%08lx ", viewmode);
+#endif
+		}
+	}
+
+	/*
+	**	If we don't have a valid viewmode by now, let's handcraft it...
+	*/
+	if (viewmode == INVALID_ID)
+	{
+#if 0
+		/*
+		**	$$$ This is for non-aga only!!! fix!!
+		*/
+		viewmode = 0;
+		if((bmhd->nPlanes <=4) || (bmhd->nPlanes == 24))
+		{
+			if(bmhd->w > 400) viewmode |= HIRES_KEY;
+		}
+		else if(bmhd->nPlanes == 6) viewmode |= HAM_KEY;
+
+		if(bmhd->h > 320) viewmode |= LORESLACE_KEY;
+#else
+		viewmode = monitorid;		// Test
+#endif
+
+#ifdef VERBOSE
+		Printf("MY GUESS: $%08lx ", viewmode);
+#endif
+	}
+
+	return viewmode;
+}
+
+
+/****************************************************************************
+**	Allocate a picture (Allocate custom BitMap, open screen and window)
+*/
+
+BOOL OpenPicture(struct Picture *pic)
+{
+	struct DimensionInfo	di;
+	struct IFFL_BMHD		*bmhd;
+	ULONG					viewmode, overscan;
+	int						xpos, ypos, width, height, depth;
+
+	/*
+	**	If this picture was already loaded, free it.
+	*/
+	ClosePicture(pic);
+	memset(pic, 0, sizeof(*pic));
+
+
+	/*
+	**	First, we get the BMHD chunk from the file. If there is none,
+	**	we show an error message and return.
+	*/
+	if ( !(bmhd = IFFL_GetBMHD(ifffile)) )
+	{
+		PrintIFFError();
+		return FALSE;
+	}
+
+	Printf("%ld x %ld x %ld ", bmhd->w, bmhd->h, bmhd->nPlanes);
+	Flush(Output());
+
+
+	/*
+	**	Get the viewmodes and its monitor dimension info, and calculate
+	**	the screen position, width and height. If the picture is larger
+	**	than the max overscan area, it is displayed with OSCAN_TEXT, and
+	**	can be scrolled with the mouse.
+	*/
+	viewmode = GetBestViewMode(ifffile, bmhd);
+
+	if (GetDisplayInfoData(NULL,(UBYTE *)&di, sizeof(di), DTAG_DIMS, viewmode) )
+	{
+		BOOL	scroll = FALSE;
+
+		int maxwidth	= di.VideoOScan.MaxX - di.VideoOScan.MinX + 1;
+		int maxheight	= di.VideoOScan.MaxY - di.VideoOScan.MinY + 1;
+
+		int stdwidth	= di.TxtOScan.MaxX - di.TxtOScan.MinX + 1;
+		int stdheight	= di.TxtOScan.MaxY - di.TxtOScan.MinY + 1;
+
+		width			= SetBounds(bmhd->w, di.MinRasterWidth, maxwidth+XOSCAN);
+		height			= SetBounds(bmhd->h, stdheight, maxheight+YOSCAN);
+		depth			= SetBounds(bmhd->nPlanes, 1, di.MaxDepth);
+
+		if (bmhd->w > (maxwidth+XOSCAN))	/* Too wide, scroll horizontally */
+		{
+			width	= stdwidth;
+			scroll	= TRUE;
+		}
+
+		if (bmhd->h > (maxheight+YOSCAN))	/* Too high, scroll vertically */
+		{
+			height	= stdheight;
+			scroll	= TRUE;
+		}
+
+		if (((bmhd->w > stdwidth) || (bmhd->h > stdheight)) && !scroll)
+		{
+			overscan	= OSCAN_VIDEO;
+		}
+		else overscan	= OSCAN_TEXT;
+
+		pic->PicW	= bmhd->w;
+		pic->PicH	= bmhd->h;
+		pic->Y0		= SetBounds((height - bmhd->h) / 2, 0, height);
+
+		if (!argv.NoCenterFlag)
+		{
+			xpos	= (stdwidth  - width)  / 2;
+			ypos	= (stdheight - height) / 2;
+		}
+		else
+		{
+			xpos = ypos = pic->Y0 = 0;
+		}
+
+#ifdef VERBOSE
+		Printf("\nScr(%ld x %ld x %ld) Max(%ld x %ld x %ld) ",
+					width, height, depth, maxwidth, maxheight, di.MaxDepth);
+#endif
+	}
+	else
+	{
+		switch (ModeNotAvailable(viewmode) )
+		{
+			case DI_AVAIL_NOCHIPS:
+				Printf("You need a better chipset for view mode $%08lx\n", viewmode);
+				break;
+
+			case DI_AVAIL_NOMONITOR:
+				Printf("The required monitor ($%08lx) is not available\n", viewmode);
+				break;
+
+			case  DI_AVAIL_NOTWITHGENLOCK:
+				Printf("The monitor $%08lx does not support genlocks\n", viewmode);
+				break;
+
+			default:
+				Printf("View mode $%08lx not available.\n", viewmode);
+				break;
+		}
+
+		return FALSE;
+	}
+
+
+	/*
+	**	Allocate the screen's bitmap
+	*/
+	if (pic->BitMap = MyAllocBitMap(
+				bmhd->nPlanes, MAX(bmhd->w, width), MAX(bmhd->h, height)) )
+	{
+		ULONG	oserror;
+
+		pic->BitMap->Depth = depth;	/* Make OpenScreen() work */
+
+		/*
+		**	Now open the screen
+		*/
+		if (pic->Screen = OpenScreenTags(NULL,
+				SA_Left,		xpos,
+				SA_Top,			ypos,
+				SA_Width,		width,
+				SA_Height,		height,
+				SA_Depth,		depth,
+				SA_BitMap,		pic->BitMap,
+				SA_Behind,		TRUE,
+				SA_Quiet,		TRUE,
+				SA_Type,		CUSTOMSCREEN,
+				SA_DisplayID,	viewmode,
+				SA_Overscan,	overscan,
+				SA_ErrorCode,	&oserror,
+				TAG_DONE
+			))
+		{
+			UBYTE	*colortab;
+
+			pic->BitMap->Depth = bmhd->nPlanes;		/* Undo cheat */
+
+			/*
+			**	Create the color palette (read from CMAP chunk, if any)
+			*/
+			if (bmhd->nPlanes == 24)
+			{
+				/*
+				**	If we have a 24bit true color picture, we calculate a
+				**	"true color" palette and use the screen's most significant
+				**	bitplanes for our reduced true color picture. This doesn't
+				**	look perfect, but is FAST. Feel free to enhance this.
+				*/
+				int greenbits, rbbits, i;
+
+//				depth = 3;
+
+				greenbits	= CreateTrueColorPalette(pic->Palette, depth);
+				rbbits		= (depth-greenbits)/2;
+
+				/*
+				**	Rearrange the bitplane pointers of our screen.
+				**	This is not quite legal, I suppose (but OK for PD :-))
+				*/
+				for (i=0; i<greenbits; ++i)
+				{
+					pic->Screen->BitMap.Planes[i] =
+											pic->BitMap->Planes[16-greenbits+i];
+				}
+
+				for (i=0; i < rbbits; ++i)
+				{
+					pic->Screen->BitMap.Planes[greenbits+i] =
+											pic->BitMap->Planes[8-rbbits+i];
+
+					pic->Screen->BitMap.Planes[greenbits+rbbits+i] =
+											pic->BitMap->Planes[24-rbbits+i];
+				}
+
+				pic->ColorCount = 1 << depth;
+			}
+			else if (colortab = IFFL_FindChunk(ifffile, ID_CMAP) )
+			{
+				pic->ColorCount =
+					SetBounds(*(ULONG *)(colortab+4) / 3, 0, MAXCOLORS);
+
+				CopyMem(colortab+8, pic->Palette,
+									pic->ColorCount * sizeof(RGBColor));
+			}
+			else
+			{
+				/*
+				**	Use default colors for pictures without a CMAP
+				*/
+				static RGBColor white = { 0xEE, 0xCC, 0xAA };
+				pic->ColorCount = 2;
+				pic->Palette[0] = white;
+//				pic->Palette[1] = black;
+			}
+
+			LoadRGB8(&pic->Screen->ViewPort, pic->Palette, pic->ColorCount);
+
+
+			/*
+			**	To get our intuimessages, we open a window in the screen
+			*/
+			if (pic->Window = OpenWindowTags(NULL,
+					WA_Flags,			WFLG_BACKDROP | WFLG_BORDERLESS
+										| WFLG_ACTIVATE | WFLG_SIMPLE_REFRESH
+										| WFLG_NOCAREREFRESH | WFLG_REPORTMOUSE
+										| WFLG_RMBTRAP,
+					WA_IDCMP, 			IDCMP_MOUSEBUTTONS | IDCMP_MOUSEMOVE
+										| IDCMP_DELTAMOVE | IDCMP_VANILLAKEY,
+					WA_CustomScreen,	pic->Screen,
+					TAG_DONE
+				))
+			{
+				/*
+				**	Clear the mouse pointer if desired
+				*/
+				if( !argv.PointerFlag)
+					SetPointer(pic->Window, emptysprite, 1L, 16L, 0L, 0L);
+
+				return TRUE;
+			}
+		}
+		else switch (oserror)			/* OpenScreenTags() failed */
+		{
+			case OSERR_NOMONITOR:
+				PutStr("Monitor not available.\n");
+				break;
+
+			case OSERR_NOCHIPS:
+				PutStr("You need newer custom chips.\n");
+				break;
+
+			case OSERR_NOMEM:
+				PutStr("Not enough free main memory.\n");
+				break;
+
+			case OSERR_NOCHIPMEM:
+				PutStr("Not enough free chip mempry.\n");
+				break;
+
+			case OSERR_UNKNOWNMODE:
+				PutStr("Bad screen mode.\n");
+				break;
+
+			case OSERR_TOODEEP:
+				PutStr("Too many colors requested.\n");
+				break;
+
+			case OSERR_NOTAVAILABLE:
+				PutStr("Can't open screen.\n");
+				break;
+
+			default:
+				PutStr("You're completely lost.\n");
+				break;
+		}
+	}
+	else PutStr("Not enough memory\n");
+
+	ClosePicture(pic);
+	return FALSE;
+}
+
+
+/****************************************************************************
+**	That's the big one! Load and display a picture, handle mouse movement
+**	and other input events.
+**	Returns FALSE if user presses the RMB (abort), else returns TRUE
+*/
+
+BOOL ShowPicture(char *name)
+{
+	BOOL cont = TRUE;
+
+	/*
+	**	Skip icon files
+	*/
+	{
+		int len = strlen(name);
+		if (len >= 5)
+		{
+			if ( !Stricmp(name + len-5, ".info") )
+				return TRUE;
+		}
+	}
+
+	Printf("%s ... ", name);
+	Flush(Output());
+
+
+	/*
+	**	Load the IFF file into memory. If a file was already loaded, free
+	**	its memory first.
+	*/
+	if(ifffile) IFFL_CloseIFF(ifffile);
+
+	if ( !(ifffile = IFFL_OpenIFF(name, IFFL_MODE_READ)) )
+	{
+		PrintIFFError();
+		return TRUE;
+	}
+
+	if ( *(((ULONG *)ifffile)+2) != ID_ILBM)
+	{
+		PutStr("Not an ILBM picture\n");
+		return TRUE;
+	}
+
+retry:
+	if (OpenPicture(&pic1) )
+	{
+		if (IFFL_DecodePic(ifffile, pic1.BitMap) )
+		{
+			struct SHAMChunk	*sham;
+			LONG				i;
+			int					xoff = 0, yoff = 0;
+			int					maxx0 = pic1.PicW - pic1.Screen->Width;
+			int					maxy0 = pic1.PicH - pic1.Screen->Height;
+
+			/*
+			**	In 2.0 there's this RasInfo scrolling bug, it's fixed
+			**	for 3.0, so we'll make an explicit version check, and
+			**	a workaround for the bug.
+			*/
+			if (pic1.Screen->ViewPort.Modes & HIRES)
+			{
+				if(	(GfxBase->LibNode.lib_Version >= 36)
+					&&	(GfxBase->LibNode.lib_Version <= 38) )
+				 maxx0 >>= 1;
+			}
+
+
+			/*
+			**	If the picture is not as high as the screen, we have to
+			**	move it down so it will be centered.
+			*/
+			if (pic1.Y0)
+			{
+//				Printf("ScrollRaster(rp,0,%ld,0,0,%ld,%ld)\n",-pic1.Y0,pic1.PicW-1,pic1.PicH-1);
+				ScrollRaster(&pic1.Screen->RastPort,
+									0, -pic1.Y0, 0, 0, pic1.PicW-1, pic1.PicH+pic1.Y0-1);
+			}
+
+
+			/*
+			**	If an SHAM or DYNA chunk is found, build the appropriate
+			**	copper list to display the picture. This may not be supported
+			**	in future versions.
+			*/
+			if (sham = IFFL_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 = IFFL_FindChunk(ifffile, ID_CTBL) )
+			{
+				Printf("DYNA ");
+				pic1.SHAMColors = &sham->Version;	/* DYNA has no version */
+				pic1.Flags |= PICF_DYNA;
+				MakeSHAMCopList(&pic1);
+			}
+
+			Flush(Output());
+
+
+			/*
+			**	Display the picture, and close a possible old one
+			*/
+			ScreenToFront(pic1.Screen);
+			ClosePicture(&pic2);
+
+
+			/*
+			**	And now for the event loop ...
+			*/
+			for (i = 0; i < delay; ++i)
+			{
+				struct IntuiMessage *msg;
+
+				WaitTOF();
+				while (msg = (struct IntuiMessage *)GetMsg(pic1.Window->UserPort) )
+				{
+newmsg:				switch(msg->Class)
+					{
+					case IDCMP_MOUSEMOVE:
+
+						xoff += msg->MouseX;
+						yoff += msg->MouseY;
+						xoff  = SetBounds(xoff, 0, maxx0);
+						yoff  = SetBounds(yoff, 0, maxy0);
+
+						pic1.Screen->ViewPort.RasInfo->RxOffset = xoff;
+						pic1.Screen->ViewPort.RasInfo->RyOffset = yoff;
+
+						/*
+						**	If there is an SHAM copper list, we must
+						**	update it if the user scrolled the picture.
+						**	This is quite slow, so we collect all mouse
+						**	movement messages during this time.
+						*/
+						if (pic1.SHAMColors)
+						{
+							struct IntuiMessage *m2;
+
+							MakeSHAMCopList(&pic1);
+							while (m2 = (struct IntuiMessage *)GetMsg(pic1.Window->UserPort) )
+							{
+								ReplyMsg(msg); msg = m2;
+
+								if(msg->Class == IDCMP_MOUSEMOVE)
+								{
+									xoff += msg->MouseX;
+									yoff += msg->MouseY;
+								}
+								else goto newmsg;
+							}
+						}
+
+						/*
+						**	Now make the changes visible. Under V39 we
+						**	use the updated ScrollVPort() routine.
+						*/
+#if 0
+						if (OSVERSION(39) )
+						{
+							ScrollVPort(&pic1.Screen->ViewPort);
+						}
+						else
+#endif
+						{
+							MakeScreen(pic1.Screen);
+							RethinkDisplay();
+						}
+						break;
+
+					case IDCMP_VANILLAKEY:
+						if (msg->Code == 'c')
+						{
+							if (argv.Command)
+							{
+								char buf[200];
+								sprintf(buf, argv.Command, name, name);
+								Execute(buf, NULL, Output());
+							}
+						}
+						break;
+
+					case IDCMP_MOUSEBUTTONS:
+						if (!argv.NoBreakFlag)
+						{
+							if (msg->Code == MENUDOWN)		goto usrbreak;
+							if (msg->Code == SELECTDOWN)	goto showend;
+						}
+						break;
+					}
+
+					ReplyMsg(msg);
+				}
+
+				/*
+				**	If the user hits Ctrl-C we quit, if not NOBREAK
+				*/
+				if (!argv.NoBreakFlag)
+				{
+					if (CheckSignal(SIGBREAKF_CTRL_C) )
+					{
+usrbreak:				PutStr("***BREAK\n");
+						cont = FALSE;
+						goto showend2;
+					}
+				}
+			}
+
+showend:
+			PutStr("- Done\n");
+
+showend2:
+			pic2 = pic1;
+			memset(&pic1, 0, sizeof(pic1) );
+		}
+		else
+		{
+			ClosePicture(&pic1);
+			PrintIFFError();
+		}
+	}
+	else if(pic2.Window)
+	{
+		ClosePicture(&pic2);
+		goto retry;
+	}
+
+	return cont;
+}
+
+
+/****************************************************************************
+**	Expand a pattern and call ShowPicture() for each matching file.
+**	Rreturn FALSE if the user presses ^C, or if ShowPicture() returned FALSE.
+*/
+
+BOOL ShowPattern(char *pathname)
+{
+	char buf[256];
+	BPTR file;
+	BOOL cont = TRUE;
+
+	/*
+	**	Check if the supplied pathname contains any wildcards. In this
+	**	case (ParsePattern() returns TRUE) we scan the directory.
+	**	If no wildcards are found, we just pass along the name to
+	**	ShowPicture(), if it is not the name of a directory.
+	*/
+	if (ParsePatternNoCase(pathname, buf, sizeof(buf)) )
+	{
+		struct
+		{
+			struct AnchorPath APath;
+			char   FullPath[255];		/* cheap way to extend ap_Buf[] */
+		} *myanchor;
+
+iswild:
+		if (myanchor = AllocVec(sizeof(*myanchor), MEMF_PUBLIC | MEMF_CLEAR) )
+		{
+			BOOL showit = TRUE;
+			LONG error;
+
+			myanchor->APath.ap_Strlen		= sizeof(myanchor->FullPath);
+			myanchor->APath.ap_Flags		= APF_DOWILD;
+			myanchor->APath.ap_BreakBits	= SIGBREAKF_CTRL_C;
+
+			error = MatchFirst(pathname, myanchor);
+
+			while (!error)
+			{
+				if (CheckSignal(SIGBREAKF_CTRL_E) )
+				{
+					PutStr("***DIR BREAK\n"); showit=FALSE;
+					/* myanchor->APath.ap_Flags &= ~APF_DODIR; */
+				}
+
+				if(myanchor->APath.ap_Info.fib_DirEntryType >= 0)	/* Dir */
+				{
+					if (argv.AllFlag)
+					{
+						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 = MatchNext(myanchor);
+			}
+
+			MatchEnd(myanchor);
+
+
+			/*
+			**	Find out why the loop terminated
+			*/
+			switch(error)
+			{
+				case 0:
+					break;
+
+				case ERROR_BREAK:
+					PutStr("***BREAK\n");
+					cont = FALSE;
+					break;
+
+				case ERROR_OBJECT_NOT_FOUND:
+					PutStr("File not found\n");
+					cont = FALSE;
+					break;
+
+				case ERROR_BUFFER_OVERFLOW:
+					PutStr("Path too long\n");
+					break;
+
+				case ERROR_NO_MORE_ENTRIES:		/* Normal termination */
+					break;
+
+				default:
+					PrintFault(error, "");
+					break;
+			}
+
+			FreeVec(myanchor);
+		}
+		else PutStr("No memory for anchor\n");
+	}
+	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);
+		AddPart(pathname=buf, "#?", sizeof(buf));
+		goto iswild;				/* Not really elegant, but it works */
+	}
+
+	return cont;
+}
+
+
+/****************************************************************************
+**	Started without arguments: create or delete our appicon
+*/
+
+void AppIconStuff(void)
+{
+	struct MsgPort		*msgport;
+  	struct AppIcon		*ai;
+	struct AppMessage	*amsg;
+
+	if (msgport = FindPort(APPICONPORTNAME) )			/* Already running ? */
+	{
+		Signal(msgport->mp_SigTask, SIGBREAKF_CTRL_C);	/* Yes ---> Kill it */
+	}	
+	else if(msgport = CreateMsgPort() ) 
+	{
+		struct DiskObject	*appdobj = NULL;
+		char				*tooltype;
+
+		msgport->mp_Node.ln_Name = APPICONPORTNAME;
+		AddPort(msgport);
+
+		/*
+		**	If an "ICON" tooltype is specified, we use this as the
+		**	appicon for ShowIFF. Default is ShowIFF's own icon image.
+		*/
+		if (tooltype = FindToolType(dobj->do_ToolTypes, ICONTOOLTYPE) )
+			appdobj = GetDiskObject(tooltype);
+
+		if (appdobj == NULL) appdobj = dobj;
+
+		/*
+		**	Position of the appicon can be specified with "ICON[XY]POS"
+		*/
+		if (tooltype = FindToolType(dobj->do_ToolTypes, XPOSTOOLTYPE) )
+			appdobj->do_CurrentX = GetNumber(tooltype);
+		else
+			appdobj->do_CurrentX = NO_ICON_POSITION;
+
+		if (tooltype = FindToolType(dobj->do_ToolTypes, YPOSTOOLTYPE) )
+			appdobj->do_CurrentY = GetNumber(tooltype);
+		else
+			appdobj->do_CurrentY = NO_ICON_POSITION;
+
+		/*
+		**	The appicon's name is set with "ICONNAME"
+		*/
+		if ( !(tooltype = FindToolType(dobj->do_ToolTypes, ICONNAMETOOLTYPE)) )
+			tooltype = DEFAULTAPPICONNAME;
+
+		/*
+		**	Add our appicon
+		*/
+		if (ai = AddAppIconA(0, 0, tooltype, msgport, NULL, appdobj, NULL) ) 
+		{
+			while ( !(Wait(1L << msgport->mp_SigBit | SIGBREAKF_CTRL_C)
+						 & SIGBREAKF_CTRL_C) )
+			{
+				if (wbwindow = Open(WindowTitle, MODE_OLDFILE) )
+				{
+					oldcos = SelectOutput(wbwindow);
+				}
+
+				while(amsg = (struct AppMessage *)GetMsg(msgport) )
+				{
+					struct WBArg	*arg = amsg->am_ArgList;
+					int				i, cont = TRUE;
+
+  					for(i=0; (i < amsg->am_NumArgs) && cont; i++,arg++)
+  					{
+						BPTR oldcd = 0;
+						if(arg->wa_Lock)	oldcd = CurrentDir(arg->wa_Lock);
+						else				DisplayBeep(NULL);
+
+						cont = ShowPattern(arg->wa_Name && *arg->wa_Name
+												? (STRPTR)arg->wa_Name : "#?");
+						if(oldcd) CurrentDir(oldcd);
+					}
+					ReplyMsg(amsg);
+				}
+
+				ClosePicture(&pic2); 		/* Close last screen */
+
+
+				if(wbwindow)
+				{
+					WaitForChar(wbwindow, 2L<<20);		/* Wait 2 seconds */
+					SelectOutput(oldcos);
+					oldcos = 0;
+					Close(wbwindow);
+					wbwindow = NULL;
+					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 = (struct AppMessage *)GetMsg(msgport) )
+			ReplyMsg(amsg);
+
+		RemPort(msgport);
+		DeleteMsgPort(msgport);
+	}
+}
+
+
+/****************************************************************************
+**	The entry point, called from ArgsStartup20.o
+*/
+
+LONG Main(struct WBStartup *startup, LONG arglen)
+{
+	#define argline ((char *)startup)
+
+	/*
+	**	Open all needed libraries
+	*/
+	if ( !(UtilityBase = OpenLibrary(UTILITYNAME, 36L)) )
+		goto quit;
+
+	if ( !(GfxBase = (struct GfxBase *)OpenLibrary(GRAPHICSNAME, 36L)) )
+		goto quit;
+
+	if ( !(IntuitionBase = (void *)OpenLibrary("intuition.library", 36L)) )
+		goto quit;
+
+   	if ( !(IconBase = OpenLibrary(ICONNAME, 36L)) )
+		goto quit;
+
+	if ( !(WorkbenchBase = OpenLibrary(WORKBENCH_NAME, 36L)) )
+		goto quit;
+
+	if ( !(IFFBase = OpenLibrary(IFFNAME, 19L)) )
+		goto quit;
+
+	if (IFFBase->lib_Version < IFFVERSION)
+		PutStr("WARNING: you have an old version of iff.library\n");
+
+
+	/*
+	**	Get args from WB or CLI as appropriate
+	*/
+	if (arglen)		/* From CLI */
+	{
+		if (*argline != '\n')
+		{
+			if (argv.DelayPtr)
+				delay = *argv.DelayPtr * SysBase->VBlankFrequency + 1;
+
+			if (argv.Monitor)
+				monitorid = GetNumber(argv.Monitor);
+
+			do
+			{
+				char **pattern = argv.Patterns;
+
+				if (*pattern)
+				{
+					while (*pattern)
+						if (!ShowPattern(*pattern++) )
+							goto done;
+				}
+				else ShowPattern("#?");
+
+			} while (argv.LoopFlag);
+done:
+			PutStr("All done.\n");
+		}
+		else
+		{
+			PutStr(VersionString+7);
+			PutStr(CLI_Help);
+		}
+	}
+	else	/* Called from Workbench */
+	{
+		/*
+		**	Set defaults for Workbench
+		*/
+		argv.AllFlag		= TRUE;
+//		argv.LoopFlag		= FALSE;
+//		argv.NoBreakFlag	= FALSE;
+//		argv.NoOverscanFlag	= FALSE;
+
+	    if (dobj = GetDiskObject(startup->sm_ArgList->wa_Name))
+		{
+			char *tooltype;
+
+#if 0
+			if (tooltype = FindToolType(dobj->do_ToolTypes, OPTIONSTOOLTYPE) )
+			{
+				GADS(tooltype, strlen(tooltype), NULL, argv, CLI_Template);
+				if (argv.DelayPtr)
+					delay = *argv.DelayPtr * SysBase->VBlankFrequency + 1;
+			}
+#endif
+
+			if (tooltype = FindToolType(dobj->do_ToolTypes, "MONITOR") )
+				monitorid = GetNumber(tooltype);
+		}
+
+		if (startup->sm_NumArgs > 1)	/* Started with some arguments */
+		{
+			struct WBArg	*arg = startup->sm_ArgList;
+			int				i;
+
+			/*
+			**	Open our output window
+			*/
+			if (wbwindow = Open(WindowTitle, MODE_OLDFILE) )
+				oldcos = SelectOutput(wbwindow);
+
+			for (i=1; i<startup->sm_NumArgs; ++i)
+			{
+				arg++;
+				if (arg->wa_Lock)	CurrentDir(arg->wa_Lock);
+				else				PutStr("Can't lock directory\n");
+
+				if (arg->wa_Name && *arg->wa_Name)
+				{
+					if (!ShowPattern(arg->wa_Name) )
+						break;
+				}
+				else ShowPattern("#?");
+			}
+
+			PutStr("All done.\n");
+		}
+		else	/* no arguments, just clicked */
+		{
+			AppIconStuff();
+		}
+	}
+
+
+	/*
+	**	Cleanup
+	*/
+quit:
+	ClosePicture(&pic1);
+	ClosePicture(&pic2);
+
+	if(ifffile) IFFL_CloseIFF(ifffile);
+
+	if (dobj)
+	{
+		FreeDiskObject(dobj);
+//		dobj = NULL;
+	}
+
+	if(wbwindow)
+	{
+		WaitForChar(wbwindow, 3L<<20);	/* Wait 3 seconds */
+		Close(wbwindow);
+//		wbwindow = 0;
+	}
+
+	if (oldcos)
+	{
+		SelectOutput(oldcos);
+//		oldcos = 0;
+	}
+
+	CloseLibrary(IFFBase);
+	CloseLibrary(WorkbenchBase);
+	CloseLibrary(IconBase);
+	CloseLibrary(IntuitionBase);
+	CloseLibrary(GfxBase);
+	CloseLibrary(UtilityBase);
+
+	return RETURN_OK;
+}