Initial revision

50 files changed, 12255 insertions, 0 deletions

diff --git a/ARexx.c b/ARexx.c
new file mode 100644
index 0000000..ebcee2d
--- /dev/null
+++ b/ARexx.c
@@ -0,0 +1,483 @@
+/*
+**  Bobi - The Ultimate Amiga Bob Manipulator
+**
+**  ARexx.c - ARexx-Port für Bobi (created from TopScan/ARexx.c)
+**
+**  COPYRIGHT (C) 1989-1993 BY CHRISTIAN A. WEBER, ZUERICH, SWITZERLAND.
+**  ALL RIGHTS RESERVED. NO PART OF THIS SOFTWARE MAY BE COPIED, REPRODUCED,
+**  OR TRANSMITTED IN ANY FORM OR BY ANY MEANS, WITHOUT THE PRIOR WRITTEN
+**  PERMISSION OF THE AUTHOR. NO WARRANTY. USE AT YOUR OWN RISK.
+*/
+
+#include <proto/exec.h>
+#include <rexx/rxslib.h>
+#include <rexx/storage.h>
+#include <rexx/errors.h>
+#include <clib/rexxsyslib_protos.h>
+#include <pragmas/rexxsyslib_pragmas.h>
+#include <proto/dos.h>
+#include <proto/intuition.h>
+
+#include <string.h>
+
+#include "Bobi.h"
+#include "BobStructure.h"
+
+#define MYREXXPORTNAME	"rexx_bobi"
+#define MYREXXSUFFIX	"brx"
+
+
+/****************************************************************************
+**	Globals
+*/
+
+BYTE	arexxflag;			/* TRUE wenn ein Kommando von ARexx am laufen ist */
+char	arexxfilename[200];	/* Filename z.B. für LoadBobs() */
+BYTE	debugflag;
+
+extern struct Screen		*mainscreen;
+extern struct MyBob			*BobTable[];
+extern WORD					numbobs,actbobnum,options,mainx0,mainy0;
+
+
+/****************************************************************************
+**	Locals
+*/
+
+static struct Library		*RexxSysBase;
+static struct MsgPort		*myrexxport;		/* TopScan's rexx port */
+static LONG					commandcounter;		/* Zählt abgeschickte Kommandos */
+static char					resultstring[256];	/* Puffer für ARexx-Resultate */
+
+
+/****************************************************************************
+**	ASCII String holen, Anführungszeichen interpretieren.
+**	Der Char*-Zeiger wird auf den Text nach dem String gesetzt.
+*/
+
+static void GetRexxString(char **strptr,char *dest)
+{
+	char *s=*strptr;
+
+	/*
+	**	Führende Spaces überlesen
+	*/
+	while(*s == ' ') s++;
+
+	/*
+	**	Text kopieren
+	*/
+	if(*s == '"')		/* Anführungszeichen --> plain copy */
+	{
+		s++;
+		while(*s)
+		{
+			if(*s == '\\')		/* Escape-Sequenz */
+			{
+				switch(*++s)
+				{
+					case '\0':					goto ende;
+					case 'n':	*dest++ = '\n';	break;
+					default:	*dest++ = *s;	break;
+				}
+				s++;
+			}
+			else if(*s == '"') break;
+ 			else *dest++ = *s++;
+		}
+ende: ;
+	}
+	else				/* Keine Anführungszeichen --> bis Space */
+	{
+		while(*s)
+		{
+			if(*s == '\\')		/* Escape-Sequenz */
+			{
+				switch(*++s)
+				{
+					case '\0':					goto ende2;
+					case 'n':	*dest++ = '\n';	break;
+					default:	*dest++ = *s;	break;
+				}
+				s++;
+			}
+			else if(*s == ' ') break;
+ 			else *dest++ = *s++;
+		}
+ende2: ;
+	}
+	*dest = '\0';
+
+	/*
+	**	Spaces am Schluss überlesen
+	*/
+	while(*s == ' ') s++;
+
+	*strptr = s;
+}
+
+
+/****************************************************************************
+**	ASCII nach Integer wandeln, Nachkommastellen werden unterdrückt.
+**	Der Char*-Zeiger wird auf den Text nach der Zahl gesetzt.
+*/
+
+static LONG GetRexxInteger(char **strptr)
+{
+	char	*s=*strptr;
+	LONG	zahl=0,sign=1;
+
+	while(*s == ' ') s++;
+
+	if(*s == '-')
+	{
+		sign=-1;
+		s++;
+	}
+	else if(*s == '+') s++;
+
+	while((*s >= '0') && (*s <= '9'))
+	{
+		zahl = zahl*10+(*s++-'0');
+	}
+
+	while(*s == ' ') s++;
+
+	*strptr = s;
+	return zahl*sign;
+}
+
+
+/****************************************************************************
+**	Die Interface-Routinen zu den ARexx-Kommandos
+*/
+
+static LONG RX_BobiToFrontFunc(char *args)
+{
+	ScreenToFront(mainscreen);
+	return RC_OK;
+}
+
+static LONG RX_BobiToBackFunc(char *args)
+{
+	ScreenToBack(mainscreen);
+	return RC_OK;
+}
+
+static LONG RX_ClearAllFunc(char *args)
+{
+	ClearAll();
+	return RC_OK;
+}
+
+static LONG RX_LoadBobsFunc(char *args)
+{
+	GetRexxString(&args,arexxfilename);
+	LoadBobsFunc();
+	return RC_OK;
+}
+
+static LONG RX_InsertBobsFunc(char *args)
+{
+	GetRexxString(&args,arexxfilename);
+	InsertBobsFunc();
+	return RC_OK;
+}
+
+static LONG RX_SaveBobsFunc(char *args)
+{
+	GetRexxString(&args,arexxfilename);
+	SaveBobsFunc();
+	return RC_OK;
+}
+
+static LONG RX_GenerateCodeFunc(char *args)
+{
+	GetRexxString(&args,arexxfilename);
+	GenerateCodeFunc();
+	return RC_OK;
+}
+
+static LONG RX_LoadIFFFunc(char *args)
+{
+	GetRexxString(&args,arexxfilename);
+	LoadPicFunc();
+	return RC_OK;
+}
+
+static LONG RX_ClosePictureFunc(char *args)
+{
+	CloseScreenFunc();
+	return RC_OK;
+}
+
+static LONG RX_GetBobFunc(char *args)
+{
+	int x,y,w,h;
+
+	x = GetRexxInteger(&args);	y = GetRexxInteger(&args);
+	w = GetRexxInteger(&args);	h = GetRexxInteger(&args);
+
+	if(GetBob(x,y,w,h))
+	{
+		actbobnum++;
+		return RC_OK;
+	}
+	else return RC_ERROR;
+}
+
+static LONG RX_InsertNewFunc(char *args)
+{
+	InsertNewBobFunc();
+	return RC_OK;
+}
+
+static LONG RX_SetOrgFunc(char *args)
+{
+	if((numbobs>0) && (numbobs!=actbobnum))
+	{
+		BobTable[actbobnum]->X0 = GetRexxInteger(&args);
+		BobTable[actbobnum]->Y0 = GetRexxInteger(&args);
+		return RC_OK;
+	}
+	else return RC_ERROR;
+}
+
+#if 0
+static LONG RX_DebugFunc(char *args)
+{
+	debugflag=GetRexxInteger(&args);
+	return RC_OK;
+}
+#endif
+
+
+/****************************************************************************
+**	Ein Rexx-Kommando auswerten, geht auch wenn ARexx NICHT läuft
+*/
+
+LONG PerformRexxCommand(char *commandline)
+{
+	static struct MyRexxCmd
+	{
+		char	*Name;				/* Name des Kommandos */
+		LONG	(*Func)(char *);	/* Aufzurufende Routine */
+	}
+	rexxcmdtab[] =
+	{
+		"BOBITOFRONT",			RX_BobiToFrontFunc,
+		"BOBITOBACK",			RX_BobiToBackFunc,
+
+		"CLEARALL",				RX_ClearAllFunc,
+		"LOADBOBS",				RX_LoadBobsFunc,
+		"INSERTBOBS",			RX_InsertBobsFunc,
+		"SAVEBOBS",				RX_SaveBobsFunc,
+		"GENERATECODE",			RX_GenerateCodeFunc,
+
+		"LOADIFF",				RX_LoadIFFFunc,
+		"CLOSEPICTURE",			RX_ClosePictureFunc,
+
+		"GETBOB",				RX_GetBobFunc,
+		"INSERTNEW",			RX_InsertNewFunc,
+		"SETORG",				RX_SetOrgFunc,
+
+#if 0
+		"DEFAULTORG",			RX_DefaultOrgFunc,
+		"SETCOLLISION",			RX_SetCollisionFunc,
+		"FLIPX",				RX_FlipXFunc,
+		"FLIPY",				RX_FlipYFunc,
+		"ROTATE",				RX_RotateFunc,
+		"ZOOM",					RX_ZoomFunc,
+		"DELETEBOB",			RX_DeleteBobFunc,
+
+		"LOADANIM",				RX_LoadAnimFunc,
+		"SAVEANIM",				RX_SaveAnimFunc,
+		"ANIMFIRST",			RX_AnimFirstFunc,
+		"ANIMLAST",				RX_AnimLastFunc,
+		"ANIMMODE",				RX_AnimModeFunc,
+		"STARTANIM",			RX_StartAnimFunc,
+		"STOPANIM",				RX_StopAnimFunc,
+
+		"TOOLWINDOW",			RX_ToolWindowFunc,
+		"LAYERMODE",			RX_LayerModeFunc,
+		"ORGGRID",				RX_OrgGridFunc,
+		"BOBBORDERS",			RX_BobBordersFunc,
+		"BOBCOLLISION",			RX_BobCollisionFunc,
+		"SETMAINORG",			RX_SetMainOrgFunc,
+		"LOADOFFSETS",			RX_LoadOffsetsFunc,
+		"SAVEOFFSETS",			RX_SaveOffsetsFunc,
+		"REMAKELABELS",			RX_RemakeLabelsFunc,
+		"REMAKECOLLISION",		RX_RemakeCollisionFunc
+#endif
+		NULL,					NULL				/* End-Markierung */
+	};
+
+	struct MyRexxCmd *cptr;
+
+	*resultstring = '\0';			/* Resultat löschen */
+
+	for(cptr=rexxcmdtab; cptr->Name; cptr++)
+	{
+		char *s,*d;
+		for(s=commandline,d=cptr->Name; *d; s++,d++)
+		{
+			if(*s != *d) break;
+		}
+
+		if(*s <= ' ')				/* Kommandoname fertig <-> das richtige */
+		{
+			LONG result;
+
+			while(*s == ' ') s++;		/* Spaces überhüpfen */
+
+			arexxflag = TRUE;
+			result = cptr->Func(s);		/* Funktion aufrufen */
+			arexxflag = FALSE;
+
+			return result;
+		}
+	}
+	return RC_ERROR;
+}
+
+
+/****************************************************************************
+**	ARexx initialisieren, 1x gerufen bei Programmstart
+**	Öffnet rexxsyslib und erstellt rexx_topscan Port
+**	Resultat: 0 falls ARexx nicht läuft, sonst Signalmaske von neuem RexxPort
+*/
+
+ULONG InitARexx(void)
+{
+	if(RexxSysBase=OpenLibrary(RXSNAME,0))
+	{
+		if(myrexxport=CreatePort(MYREXXPORTNAME,0))
+		{
+			return 1U<<myrexxport->mp_SigBit;
+		}
+	}
+	CloseARexx();
+	return 0;
+}
+
+
+/****************************************************************************
+**	ARexx cleanup, 1x gerufen bei Programmende
+**	Zerstört den ARexx-Port und schliesst rexxsyslib, falls kein Kommando
+**	am Laufen ist, sonst wird FALSE zurückgegeben
+*/
+
+ULONG CloseARexx(void)
+{
+	if(commandcounter)
+	{
+		ShowMonoReq2("Can't quit yet, there are\nARexx-Commands pending.");
+		return FALSE;
+	}
+
+	if(myrexxport)
+	{
+		DeletePort(myrexxport);
+		myrexxport = NULL;
+	}
+
+	if(RexxSysBase)
+	{
+		CloseLibrary(RexxSysBase);
+		RexxSysBase = NULL;
+	}
+
+	return TRUE;
+}
+
+
+/****************************************************************************
+**	RexxMessage holen und Kommando starten falls ARexx läuft
+*/
+
+void RexxMsgHandler(void)
+{
+	struct RexxMsg *msg;
+	if(!myrexxport) return;		/* Sofort zurück falls ARexx nicht läuft */
+
+	while (msg = (struct RexxMsg *)GetMsg(myrexxport))
+	{
+		if(msg->rm_Node.mn_Node.ln_Type != NT_REPLYMSG)
+		/*
+		**	Es ist eine gültige Message und keine Antwort.
+		*/
+		{
+			if(IsRexxMsg(msg))
+			{
+				/* Sollen wir ein Kommando auführen ? */
+				if((msg->rm_Action & RXCODEMASK) == RXCOMM)
+				{
+					msg->rm_Result1 = 0;
+					msg->rm_Result2 = 0;
+
+					if(msg->rm_Result1 = PerformRexxCommand(msg->rm_Args[0]))
+					{
+						/* Func returned an error */
+					}
+					else if((*resultstring)	&& (msg->rm_Action & RXFF_RESULT))
+					{
+						msg->rm_Result2 = (LONG)
+							CreateArgstring(resultstring,strlen(resultstring));
+					}
+				}
+//				else INTERNAL_ERROR;
+			}
+//			else INTERNAL_ERROR;
+			ReplyMsg(msg);
+		}
+		else
+		/*
+		**	Diese Message ist ein reply auf eine Message welche wir
+		**	früher mal geschickt haben
+		*/
+		{
+			DeleteArgstring(msg->rm_Args[0]);
+			if(msg->rm_Stdin) Close(msg->rm_Stdin);
+			DeleteRexxMsg(msg);
+			commandcounter--;
+		}
+	}
+}
+
+
+/****************************************************************************
+**	Eine RexxMessage schicken (Speicher wird von RexxMsgHandler freigegeben)
+**	Parameter: Kommando-String
+*/
+
+void SendRexxCommand(char *command)
+{
+	BPTR window;
+
+	if(window=Open("CON:0/20/600/160/Bobi ARexx Output Window/AUTO/CLOSE",MODE_OLDFILE))
+	{
+		struct MsgPort *masterport;
+
+		Forbid();
+		if(masterport=FindPort(RXSDIR))
+		{
+			struct RexxMsg *msg;
+
+			if(msg=CreateRexxMsg(myrexxport,MYREXXSUFFIX,MYREXXPORTNAME))
+			{
+				if(msg->rm_Args[0] = CreateArgstring(command,strlen(command)))
+				{
+					msg->rm_Action	= RXCOMM;
+					msg->rm_Stdin	= window;
+					msg->rm_Stdout	= window;
+					window			= NULL;
+					commandcounter++;
+					PutMsg(masterport,(struct Message *)msg);
+				}
+			}
+		}
+		Permit();
+
+		if(window) Close(window);	/* Schliessen falls Error */
+	}
+}
diff --git a/About.c b/About.c
new file mode 100644
index 0000000..ddd9083
--- /dev/null
+++ b/About.c
@@ -0,0 +1,47 @@
+/*
+**  Bobi - The Ultimate Amiga Bob Manipulator
+**
+**  About.c - About-Requester anzeigen
+**
+**  COPYRIGHT (C) 1989-1993 BY CHRISTIAN A. WEBER, ZUERICH, SWITZERLAND.
+**  ALL RIGHTS RESERVED. NO PART OF THIS SOFTWARE MAY BE COPIED, REPRODUCED,
+**  OR TRANSMITTED IN ANY FORM OR BY ANY MEANS, WITHOUT THE PRIOR WRITTEN
+**  PERMISSION OF THE AUTHOR. NO WARRANTY. USE AT YOUR OWN RISK.
+*/
+
+#include <proto/exec.h>
+#include <proto/intuition.h>
+#include <intuition/intuition.h>
+
+#include "Bobi.h"
+
+char nametext1[] = "Chris Haller, René Straub";
+char nametext2[] = "René Straub, Chris Haller";
+
+#include "AboutWindow.h"
+
+static char *t1 = nametext1, *t2 = nametext2;
+
+void AboutFunc(void)
+{
+	extern struct Screen *mainscreen;
+	extern char idstring[];
+	char *tmp;
+
+	struct Window *w;
+
+	LockWindows();
+	NewWindowStructure1.Screen = mainscreen;
+	IText2.IText = idstring;
+	IText5.IText = t1;
+	if (w = OpenWindow(&NewWindowStructure1))
+	{
+		PrintIText(w->RPort, &IntuiTextList1, 0L, 0L);
+		WaitPort(w->UserPort);
+		CloseWindow(w);
+	}
+	UnLockWindows();
+
+	/* Namen tauschen */
+	tmp = t1; t1 = t2; t2 = tmp;
+}
diff --git a/AboutWindow.h b/AboutWindow.h
new file mode 100644
index 0000000..2e4c94a
--- /dev/null
+++ b/AboutWindow.h
@@ -0,0 +1,211 @@
+
+static USHORT __chip ImageData1[] = {
+	0x0480,0x1000,0x0200,0x0004,0x0000,0x0000,0x0007,0x9000,
+	0x0008,0x4100,0x0200,0x0000,0x0000,0x0BC2,0xA800,0x0700,
+	0x004E,0x0000,0x0000,0x001F,0xF800,0x001C,0xE380,0x1500,
+	0x0000,0x0000,0x16FD,0x7000,0x0380,0x00A7,0x0000,0x0000,
+	0x003F,0xF800,0x003D,0x75C0,0x0E00,0x0000,0x0000,0x2F7E,
+	0x7000,0x0100,0x01C2,0x0000,0x0000,0x007E,0xB800,0x001C,
+	0xF3C0,0x0E00,0x0000,0x0000,0x5F3C,0x7000,0x0000,0x01C0,
+	0x0000,0x0000,0x007B,0x7800,0x001C,0x71C0,0x0E00,0x0000,
+	0x0000,0xE728,0x7108,0xC10F,0x17E2,0x3F42,0x1000,0x0067,
+	0xB800,0x001C,0x71C6,0x0E20,0xC08C,0x0000,0xE730,0x779D,
+	0xE39F,0xEBF7,0x5FA7,0x7800,0x0025,0x3800,0x007C,0x71DB,
+	0x8EF3,0x71DE,0x0000,0xE718,0x7BFE,0xF7FD,0xF1CF,0xA1CF,
+	0xBC00,0x001A,0x3800,0x00BC,0x71FD,0xCF7F,0xBBEF,0x0000,
+	0xE70C,0x7DDF,0x2BB8,0xA1C7,0x11C7,0xDE00,0x001C,0x3800,
+	0x005C,0x71DD,0xEFBB,0xBDF2,0x8000,0xE700,0x71DC,0x139B,
+	0xC1C7,0x79C7,0x1C00,0x003F,0xF800,0x001C,0x71DE,0xCE3B,
+	0xD9C1,0x0000,0x6700,0x71DC,0x038F,0xE1C7,0x7DC7,0x1C00,
+	0x005F,0xF800,0x001C,0x71DD,0x0E3B,0xA1C0,0x0000,0x3702,
+	0x71DC,0x0387,0xB1C7,0x73C7,0x1C00,0x00A0,0x3800,0x001C,
+	0x71DE,0x0E3B,0xC1C0,0x0000,0x1E05,0xF1FE,0x078A,0x3BEF,
+	0x77CF,0x1E00,0x03E1,0x7800,0x003C,0xFABD,0x1E7F,0xA3E0,
+	0x0000,0x0FFA,0x71DD,0x039F,0x79D7,0x7BE7,0x1D00,0x05FE,
+	0xB900,0x005F,0x7D1E,0x8FBB,0xD1D0,0x0000,0x07FC,0x398E,
+	0x01EF,0xF0E3,0xBC53,0x0E00,0x061F,0x1F80,0x00A7,0x9E0D,
+	0x07C1,0xA0E0,0x0000,0x01F0,0x1084,0x0093,0xE041,0x1021,
+	0x0400,0x030E,0x09C0,0x00C3,0x0C06,0x0200,0xC040,0x0000,
+	0x0000,0x0040,0x0000,0x0000,0x0000,0x0000,0x0180,0x0080,
+	0x0060,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
+	0x0000,0x0000,0x0000,0x0000,0x0000,0x0030,0x0000,0x0000,
+	0x0000,0x0000,0x0480,0x1000,0x0200,0x0004,0x0000,0x0000,
+	0x0007,0x9000,0x0008,0x4100,0x0200,0x0000,0x0000,0x09C2,
+	0xA000,0x0700,0x004E,0x0000,0x0000,0x001F,0xF000,0x0018,
+	0xE380,0x1400,0x0000,0x0000,0x12FC,0x6000,0x0200,0x0084,
+	0x0000,0x0000,0x0030,0x7000,0x0039,0x6580,0x0C00,0x0000,
+	0x0000,0x2678,0x6000,0x0000,0x0180,0x0000,0x0000,0x0066,
+	0xB000,0x0018,0x6180,0x0C00,0x0000,0x0000,0x4E10,0x6000,
+	0x0000,0x0180,0x0000,0x0000,0x004B,0x3000,0x0018,0x6180,
+	0x0C00,0x0000,0x0000,0xC620,0x6108,0xC10F,0x17E2,0x3F42,
+	0x1000,0x0042,0x3000,0x0018,0x6186,0x0C20,0xC08C,0x0000,
+	0xC620,0x6799,0xE39B,0xE187,0x4386,0x7800,0x0024,0x3000,
+	0x0078,0x619B,0x8CF3,0x719E,0x0000,0xC618,0x79BE,0x1730,
+	0x418E,0x218F,0x9C00,0x0018,0x3000,0x00B8,0x61B9,0xCF37,
+	0x3BE1,0x0000,0xC600,0x6198,0x2330,0x8186,0x1186,0x1800,
+	0x0010,0x3000,0x0018,0x6199,0x8C33,0x3182,0x0000,0xC600,
+	0x6198,0x031B,0xC186,0x7986,0x1800,0x003F,0xF000,0x0018,
+	0x619A,0x0C33,0x4180,0x0000,0x6600,0x6198,0x030F,0x6186,
+	0x6586,0x1800,0x0040,0x3000,0x0018,0x619C,0x0C33,0x8180,
+	0x0000,0x3402,0x6198,0x0304,0x3186,0x6386,0x1800,0x0080,
+	0x3000,0x0010,0x7118,0x0C33,0x0180,0x0000,0x1C04,0xE1BA,
+	0x0708,0x33AE,0x678E,0x1A00,0x03E1,0x7000,0x003C,0xF239,
+	0x1C77,0x23A0,0x0000,0x0FF8,0x711C,0x039F,0x61C7,0x78A6,
+	0x1C00,0x043E,0x3900,0x004F,0x3C1A,0x0F83,0x41C0,0x0000,
+	0x03E0,0x2108,0x0127,0xC082,0x2042,0x0800,0x041C,0x1380,
+	0x0086,0x180C,0x0401,0x8080,0x0000,0x0000,0x0080,0x0000,
+	0x0000,0x0000,0x0000,0x0300,0x0100,0x0080,0x0000,0x0000,
+	0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
+	0x0000,0x0000,0x0060,0x0000,0x0000,0x0000,0x0000,0x0000,
+	0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
+	0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
+	0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
+	0x0000,0x0200,0x0800,0x0000,0x0000,0x0000,0x0000,0x0000,
+	0x0800,0x0004,0x0000,0x0100,0x0000,0x0000,0x0401,0x1000,
+	0x0180,0x0023,0x0000,0x0000,0x000F,0x8800,0x0004,0x1040,
+	0x0200,0x0000,0x0000,0x0906,0x1000,0x0100,0x0042,0x0000,
+	0x0000,0x0018,0x0800,0x0004,0x9240,0x0200,0x0000,0x0000,
+	0x112C,0x1000,0x0000,0x0040,0x0000,0x0000,0x0030,0x4800,
+	0x0004,0x1040,0x0200,0x0000,0x0000,0x2108,0x1000,0x0000,
+	0x0000,0x0000,0x0000,0x0025,0x8800,0x0004,0x1040,0x0200,
+	0x0000,0x0000,0x2110,0x1004,0x0004,0x0A70,0x1C21,0x0000,
+	0x0001,0x0800,0x0004,0x1040,0x0200,0x0040,0x0000,0x2100,
+	0x0240,0xE0CD,0xB041,0x8040,0x2000,0x0002,0x0800,0x0004,
+	0x1044,0x0048,0x800E,0x0000,0x210C,0x1C47,0x0888,0x2041,
+	0x0041,0xC600,0x000C,0x0800,0x0044,0x1044,0x6388,0x8C70,
+	0x8000,0x2100,0x1044,0x1080,0x0041,0x0041,0x0400,0x0000,
+	0x0800,0x0004,0x1044,0xC208,0x9841,0x0000,0x0100,0x1044,
+	0x0080,0x8041,0x1841,0x0400,0x001F,0xC800,0x0004,0x1041,
+	0x0208,0x2040,0x0000,0x0300,0x1044,0x0083,0x8041,0x1041,
+	0x0400,0x0020,0x0800,0x000C,0x00C6,0x0208,0xC040,0x0000,
+	0x0201,0x1044,0x0082,0x0841,0x1041,0x0400,0x0000,0x0800,
+	0x0000,0x0884,0x0208,0x8040,0x0000,0x0002,0x00C1,0x0000,
+	0x1810,0x0341,0x0100,0x01C0,0x8000,0x0010,0x4104,0x8038,
+	0x9010,0x0000,0x041C,0x1886,0x00C8,0x3061,0x9C11,0x0600,
+	0x0203,0x0C00,0x0021,0x8601,0x03C0,0x2060,0x0000,0x01F0,
+	0x1004,0x0093,0xE041,0x1021,0x0400,0x000E,0x08C0,0x0043,
+	0x0C06,0x0200,0xC040,0x0000,0x0000,0x0040,0x0000,0x0000,
+	0x0000,0x0000,0x0180,0x0080,0x0000,0x0000,0x0000,0x0000,
+	0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
+	0x0000,0x0030,0x0000,0x0000,0x0000,0x0000
+};
+
+static struct Image Image1 = {
+	0,0,
+	193,18,
+	5,
+	ImageData1,
+	0x0015,0x0000,
+	NULL
+};
+
+static struct Gadget Gadget2 = {
+	NULL,
+	18,34,
+	193,18,
+	GADGHBOX+GADGHIMAGE+GADGIMAGE,
+	NULL,
+	BOOLGADGET,
+	(APTR)&Image1,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+static SHORT BorderVectors1[] = {
+	0,0,
+	83,0,
+	83,13,
+	0,13,
+	0,0
+};
+static struct Border Border1 = {
+	-1,-1,
+	31,0,JAM1,
+	5,
+	BorderVectors1,
+	NULL
+};
+
+static struct IntuiText IText1 = {
+	28,0,JAM2,
+	32,2,
+	NULL,
+	"OK",
+	NULL
+};
+
+static struct Gadget OKGadget = {
+	&Gadget2,
+	73,-19,
+	82,12,
+	GRELBOTTOM,
+	RELVERIFY,
+	BOOLGADGET,
+	(APTR)&Border1,
+	NULL,
+	&IText1,
+	NULL,
+	NULL,
+	101,
+	NULL
+};
+
+#define GadgetList1 OKGadget
+
+static struct TextAttr TOPAZ80 = {
+	(STRPTR)"topaz.font",
+	TOPAZ_EIGHTY,0,0
+};
+static struct IntuiText IText5 = {
+	10,0,JAM1,
+	14,76,
+	&TOPAZ80,
+	"René Straub, Chris Haller",
+	NULL
+};
+
+static struct IntuiText IText4 = {
+	2,0,JAM1,
+	78,60,
+	&TOPAZ80,
+	"Thanx to:",
+	&IText5
+};
+
+static struct IntuiText IText3 = {
+	18,0,JAM2,
+	106,20,
+	&TOPAZ80,
+	"by",
+	&IText4
+};
+
+static struct IntuiText IText2 = {
+	8,0,JAM2,
+	19,7,
+	&TOPAZ80,
+	"Bobi 0.00a (Jan  1 1978)",
+	&IText3
+};
+
+#define IntuiTextList1 IText2
+
+static struct NewWindow NewWindowStructure1 = {
+	46,50,
+	228,116,
+	0,12,
+	GADGETDOWN+GADGETUP,
+	SIMPLE_REFRESH+ACTIVATE+RMBTRAP,
+	&OKGadget,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	5,5,
+	1024,1024,
+	CUSTOMSCREEN
+};
diff --git a/Anim.c b/Anim.c
new file mode 100644
index 0000000..c4aa3c0
--- /dev/null
+++ b/Anim.c
@@ -0,0 +1,196 @@
+/*
+**  Bobi - The Ultimate Amiga Bob Manipulator
+**
+**  Anim.c - Bobs animieren
+**
+**  COPYRIGHT (C) 1989-1993 BY CHRISTIAN A. WEBER, ZUERICH, SWITZERLAND.
+**  ALL RIGHTS RESERVED. NO PART OF THIS SOFTWARE MAY BE COPIED, REPRODUCED,
+**  OR TRANSMITTED IN ANY FORM OR BY ANY MEANS, WITHOUT THE PRIOR WRITTEN
+**  PERMISSION OF THE AUTHOR. NO WARRANTY. USE AT YOUR OWN RISK.
+*/
+
+#include <proto/exec.h>
+#include <proto/graphics.h>
+#include <proto/intuition.h>
+#include <proto/dos.h>
+
+#include "Bobi.h"
+#include "BobStructure.h"
+
+#define MAXANIMDELAY 50
+
+extern struct Gadget AnimSpeedGadget;
+extern struct PropInfo AnimSpeedGadgetSInfo;
+extern struct MyBob *BobTable[];
+extern struct Window *mainwindow,*toolwindow;
+extern WORD numbobs,actbobnum;
+extern WORD firstanimbob,lastanimbob,animflags;
+
+extern struct MenuItem ForwardItem,BackwardItem,PingPongItem;
+
+
+/*************************************************************************/
+
+void SetFirstBobFunc()
+{
+	if(BobTable[actbobnum]) firstanimbob = actbobnum;
+	else                    ShowMonoReq2("No bob selected!");
+}
+
+
+/*************************************************************************/
+
+void SetLastBobFunc()
+{
+	if(BobTable[actbobnum]) lastanimbob = actbobnum;
+	else                    ShowMonoReq2("No bob selected!");
+}
+
+
+/*************************************************************************/
+
+void StartAnimFunc()
+{
+	register struct IntuiMessage *msg;
+	register LONG bobnum,dir,delay,i;
+	struct Menu *mainmenus,*toolmenus;
+	STRPTR oldmaintitle,oldtooltitle;
+
+	oldmaintitle=mainwindow->ScreenTitle;
+	SetWindowTitles(mainwindow,(STRPTR)(~0L),"Hit <ESC> or RMB to stop animation");
+	mainmenus = mainwindow->MenuStrip;
+	ClearMenuStrip(mainwindow);
+
+	if(toolwindow)
+	{
+		oldtooltitle=toolwindow->ScreenTitle;
+		SetWindowTitles(toolwindow,(STRPTR)(~0L),"Hit <ESC> or RMB to stop animation");
+		toolmenus = toolwindow->MenuStrip;
+		ClearMenuStrip(toolwindow);
+	}
+
+	if(lastanimbob < firstanimbob)
+	{
+		bobnum = lastanimbob;
+		lastanimbob = firstanimbob;
+		firstanimbob = bobnum;
+	}
+	bobnum = firstanimbob;
+	dir=1; if(animflags & AF_BACKWARD) dir=-1;
+
+	for(;;)
+	{
+		delay = (GetAnimSpeed()*MAXANIMDELAY+0x7fffL)>>16;
+		for(i=0; i<delay; ++i)
+		{
+			WaitTOF();
+			msg=(struct IntuiMessage *)GetMsg(mainwindow->UserPort);
+			if(toolwindow)
+			{
+				if(!msg) msg=(struct IntuiMessage *)GetMsg(toolwindow->UserPort);
+			}
+
+			if(msg)
+			{
+				if((msg->Class==MENUPICK) ||
+				   ((msg->Class==RAWKEY)     && (msg->Code==0x45)))
+				{
+					ReplyMsg((struct Message *)msg);
+					goto endanim;
+				}
+				ReplyMsg((struct Message *)msg);
+			}
+		}
+		bobnum += dir;
+		if(animflags & AF_BOUNCE)
+		{
+			if((bobnum>lastanimbob) || (bobnum<firstanimbob))
+			{
+				dir = (-dir);
+				bobnum += dir;
+				bobnum += dir;
+			}
+		}
+		else
+		{
+			if(bobnum>lastanimbob)  bobnum = firstanimbob;
+			if(bobnum<firstanimbob) bobnum = lastanimbob;
+		}
+		ShowBob(BobTable[bobnum]);
+	}
+endanim:
+	actbobnum = bobnum;
+	SetWindowTitles(mainwindow,(STRPTR)(~0L),oldmaintitle);
+	if(toolwindow) SetWindowTitles(toolwindow,(STRPTR)(~0L),oldtooltitle);
+	ShowFrame(actbobnum);
+	SetMenuStrip(mainwindow,mainmenus);
+	if(toolwindow) SetMenuStrip(toolwindow,toolmenus);
+}
+
+
+/*************************************************************************/
+
+UWORD GetAnimSpeed()
+{
+	return(AnimSpeedGadgetSInfo.VertPot);
+}
+
+
+/*************************************************************************/
+
+void SetAnimSpeed(UWORD speed)
+{
+	AnimSpeedGadgetSInfo.VertBody = 0xffffL/MAXANIMDELAY;
+	AnimSpeedGadgetSInfo.VertPot  = speed;
+
+	if(toolwindow)
+		RefreshGList(&AnimSpeedGadget,toolwindow,0,1);
+}
+
+
+/*************************************************************************/
+
+void SetAnimFlags(WORD flags)
+{
+	ForwardItem.MutualExclude  = 6;
+	BackwardItem.MutualExclude = 5;
+	PingPongItem.MutualExclude = 3;
+
+	ForwardItem.Flags  &= ~CHECKED;
+	BackwardItem.Flags &= ~CHECKED;
+	PingPongItem.Flags &= ~CHECKED;
+
+	if(flags & AF_FORWARD)
+	{
+		ForwardItem.Flags  |= CHECKED;
+	}
+	if(flags & AF_BACKWARD)
+	{
+		BackwardItem.Flags |= CHECKED;
+	}
+	if(flags & AF_BOUNCE)
+	{
+		PingPongItem.Flags |= CHECKED;
+	}
+
+	animflags = flags;
+}
+
+
+/*************************************************************************/
+
+void SetAnimModeFunc()
+{
+	if(ForwardItem.Flags & CHECKED)
+	{
+		animflags = AF_FORWARD;
+	}
+	else if(BackwardItem.Flags & CHECKED)
+	{
+		animflags = 0;
+	}
+	else /* if(PingPongItem.Flags & CHECKED) */
+	{
+		animflags = AF_BOUNCE;
+	}
+}
diff --git a/BMapSupport.c b/BMapSupport.c
new file mode 100644
index 0000000..569cdf3
--- /dev/null
+++ b/BMapSupport.c
@@ -0,0 +1,90 @@
+/*
+**  Bobi - The Ultimate Amiga Bob Manipulator
+**
+**  BMapSupport.c - Erstellen und Vernichten von BitMaps und ByteMaps
+**
+**  COPYRIGHT (C) 1989-1993 BY CHRISTIAN A. WEBER, ZUERICH, SWITZERLAND.
+**  ALL RIGHTS RESERVED. NO PART OF THIS SOFTWARE MAY BE COPIED, REPRODUCED,
+**  OR TRANSMITTED IN ANY FORM OR BY ANY MEANS, WITHOUT THE PRIOR WRITTEN
+**  PERMISSION OF THE AUTHOR. NO WARRANTY. USE AT YOUR OWN RISK.
+*/
+
+#include <proto/exec.h>
+#include <exec/memory.h>
+#include <graphics/gfx.h>
+#include <proto/graphics.h>
+#include "ByteMap.h"
+
+
+struct BitMap *MakeBitMap(WORD width, WORD height, WORD depth)
+{
+	register long i;
+	register struct BitMap *b;
+	register WORD planesize;
+
+	if(b = AllocMem(sizeof(struct BitMap),MEMF_CLEAR))
+	{
+		InitBitMap(b,depth,width,height);
+		planesize=b->BytesPerRow*b->Rows;
+
+		if(b->Planes[0]=AllocMem(planesize*depth,MEMF_CHIP|MEMF_CLEAR))
+		{
+			for(i=1; i<depth; ++i)
+				b->Planes[i] = b->Planes[0]+i*planesize;
+		}
+		else
+		{
+			FreeMem(b,sizeof(*b));
+			b=0;
+		}
+	}
+	return(b);
+}
+
+
+/*************************************************************************/
+
+void MyFreeBitMap(struct BitMap *b)
+{
+	FreeMem(b->Planes[0],b->BytesPerRow*b->Rows*b->Depth);
+	FreeMem(b,sizeof(*b));
+}
+
+
+/*************************************************************************/
+
+struct ByteMap *MakeByteMap(register WORD width,register WORD height)
+{
+	register struct ByteMap *b;
+	register long planesize;
+
+	planesize = width*height;
+
+	if(b = AllocMem(sizeof(struct ByteMap),MEMF_CLEAR))
+	{
+		if(b->Plane = AllocMem(planesize,MEMF_CLEAR))
+		{
+			b->Width = width;
+			b->Height = height;
+			b->PlaneSize = planesize;
+		}
+		else
+		{
+			FreeMem(b,sizeof(*b));
+			b=0;
+		}
+	}
+	return b;
+}
+
+
+/*************************************************************************/
+
+void FreeByteMap(struct ByteMap *b)
+{
+	if(b->Plane)
+	{
+		FreeMem(b->Plane,b->PlaneSize);
+	}
+	FreeMem(b,sizeof(*b));
+}
diff --git a/Bob.c b/Bob.c
new file mode 100644
index 0000000..910d0d7
--- /dev/null
+++ b/Bob.c
@@ -0,0 +1,532 @@
+/*
+**  Bobi - The Ultimate Amiga Bob Manipulator
+**
+**  Bob.c - Verschiedene Bob-Manipulations- und Anzeigeroutinen
+**
+**  COPYRIGHT (C) 1989-1993 BY CHRISTIAN A. WEBER, ZUERICH, SWITZERLAND.
+**  ALL RIGHTS RESERVED. NO PART OF THIS SOFTWARE MAY BE COPIED, REPRODUCED,
+**  OR TRANSMITTED IN ANY FORM OR BY ANY MEANS, WITHOUT THE PRIOR WRITTEN
+**  PERMISSION OF THE AUTHOR. NO WARRANTY. USE AT YOUR OWN RISK.
+*/
+
+#include <exec/types.h>
+#include <exec/memory.h>
+#include <graphics/gfx.h>
+#include <proto/exec.h>
+#include <proto/graphics.h>
+#include <proto/intuition.h>
+#include <string.h>
+
+#include "Bobi.h"
+#include "BobStructure.h"
+#include "ByteMap.h"
+
+extern struct Window *mainwindow,*toolwindow;
+extern struct RastPort *mainrastport,*toolrastport;
+
+extern struct Gadget LabelGadget;
+extern struct Gadget AutoSizeGadget,AutoOrgGadget,AnimKeyGadget;
+extern struct StringInfo LabelGadgetSInfo;
+extern char LabelGadgetSIBuff[];
+
+extern struct MyBob *BobTable[];
+extern WORD numbobs,actbobnum,mainwidth,mainheight,mainx0,mainy0;
+extern WORD options;
+extern BYTE	defaultorg;
+
+
+/*************************************************************************/
+
+struct MyBob *MakeBob(WORD width, WORD height, WORD depth)
+{
+	register struct MyBob *bob;
+	register long i;
+
+	if(bob=AllocMem(sizeof(struct MyBob),MEMF_CLEAR))
+	{
+		bob->Width       = width;
+		bob->Height      = height;
+		bob->Depth       = depth;
+		bob->BytesPerRow = ((width+15)>>3)&(~1);
+		bob->PlaneSize   = bob->BytesPerRow*bob->Height;
+		bob->CollX0      = 0;
+		bob->CollY0      = 0;
+		bob->CollX1      = width-1;
+		bob->CollY1      = height-1;
+
+		SetBobDefaultOrg(bob);
+
+		if(AutoSizeGadget.Flags & SELECTED) bob->Flags   |= BOBF_AUTOSIZE;
+		if(AutoOrgGadget.Flags & SELECTED)  bob->Flags   |= BOBF_AUTOORG;
+		if(AnimKeyGadget.Flags & SELECTED)  bob->Flags   |= BODF_ANIMKEY;
+		sprintf(bob->SourceLabel,LabelGadgetSIBuff,actbobnum);
+
+		if(bob->Planes[0] = AllocMem(bob->PlaneSize*depth,MEMF_CLEAR))
+		{
+			for(i=1; i<depth; ++i)
+				bob->Planes[i] = bob->Planes[0]+i*bob->PlaneSize;
+		}
+		else
+		{
+			FreeBob(bob);
+			bob=0;
+			ShowMonoReq2("No memory for bob planes!");
+		}
+	}
+	else ShowMonoReq2("No memory for bob node!");
+
+	return bob;
+}
+
+
+/*************************************************************************/
+
+void FreeBob(struct MyBob *bob)
+{
+	if(bob->Planes[0]) FreeMem(bob->Planes[0],bob->PlaneSize*bob->Depth);
+	if(bob->Mask) FreeMem(bob->Mask,bob->PlaneSize);
+	FreeMem(bob,sizeof(*bob));
+}
+
+
+/*************************************************************************/
+
+struct MyBob *BitMapToBob(struct MyBob *oldbob,struct BitMap *bm, WORD width)
+{
+	register struct MyBob *bob;
+	register long i;
+
+	if(bob=MakeBob(width,bm->Rows,bm->Depth))
+	{
+		for(i=0; i<bm->Depth; ++i)
+			CopyMem(bm->Planes[i],bob->Planes[i],bob->PlaneSize);
+		if(oldbob)
+		{
+			bob->Flags  = oldbob->Flags;
+			bob->X0     = oldbob->X0;		/* Nur für Flip etc. erwünscht! */
+			bob->Y0     = oldbob->Y0;
+			strcpy(bob->SourceLabel,oldbob->SourceLabel);
+		}
+		return(bob);
+	}
+	else return 0;
+}
+
+
+/*************************************************************************/
+
+struct BitMap *BobToBitMap(struct MyBob *bob)
+{
+	register struct BitMap *bm;
+
+	if(bm=MakeBitMap(bob->Width,bob->Height,bob->Depth))
+	{
+		CopyMem(bob->Planes[0],bm->Planes[0],bob->PlaneSize*bob->Depth);
+		return(bm);
+	}
+	else return 0;
+}
+
+
+/*************************************************************************/
+
+void DeleteBob(WORD num)
+{
+	register int i;
+
+	if(BobTable[num])
+	{
+		FreeBob(BobTable[num]);
+		for(i=num; i<numbobs; ++i)
+		{
+			BobTable[i]   = BobTable[i+1];
+			BobTable[i+1] = 0;
+		}
+		numbobs--;
+	}
+	if(numbobs==0) actbobnum=0;
+	RefreshBobNum();
+}
+
+
+/*************************************************************************/
+
+void InsertBob(struct MyBob *bob,WORD num)
+{
+	register int i;
+
+	if(numbobs<MAXNUMBOBS)
+	{
+		numbobs++;
+		for(i=numbobs; i>=num; --i) BobTable[i+1] = BobTable[i];
+		BobTable[num] = bob;
+		RefreshBobNum();
+	}
+	else ShowMonoReq2("Too many bobs!");
+}
+
+
+/*************************************************************************/
+
+void DeleteActBobFunc()
+{
+	DeleteBob(actbobnum);
+}
+
+
+/*************************************************************************/
+
+void InsertNewBobFunc()
+{
+	register struct MyBob *bob;
+	register struct RastPort *rp;
+
+	if(rp=CreateRastPort(5,34,26))
+	{
+		SetFont(rp,mainwindow->RPort->Font);
+		SetAPen(rp,1);
+		Move(rp,1,7);  Text(rp,"Your",4);
+		Move(rp,5,15); Text(rp,"new",3);
+		Move(rp,5,23); Text(rp,"Bob",3);
+		if(bob=BitMapToBob(0,rp->BitMap,34)) InsertBob(bob,actbobnum);
+		DeleteRastPort(rp);
+	}
+}
+
+
+/*************************************************************************/
+
+void ShowBob(struct MyBob *bob)
+{
+	static WORD lastx0=50,lasty0=50,lastx1=52,lasty1=52,lastd=0;
+	static WORD lastcx0=-1,lastcy0,lastcx1,lastcy1;
+	register struct BitMap *tmpmap;
+	register WORD x0,y0,x1,y1;
+
+	if(!bob) goto clearit;
+
+	x0 = mainx0-bob->X0;
+	y0 = mainy0-bob->Y0;
+	x1 = x0+bob->Width;
+	y1 = y0+bob->Height;
+
+	if((x0>lastx0)||(y0>lasty0)||(x1<lastx1)||(y1<lasty1)||(bob->Depth<lastd))
+	{
+clearit:
+		SetAPen(mainrastport,0);
+		RectFill(mainrastport,lastx0-1,lasty0-1,lastx1,lasty1);
+	}
+
+	if(lastcx0>0)	/* Falls altes CollisionRect gültig: löschen*/
+	{
+		if(bob == NULL) goto clearrect;
+
+		if((lastcx0!=(x0+bob->CollX0))
+		|| (lastcy0!=(y0+bob->CollY0))
+		|| (lastcx1!=(x0+bob->CollX1))
+		|| (lastcy1!=(y0+bob->CollY1)) || (!(options & GOF_COLLISIONRECT)))
+		{
+clearrect:
+			DrawRect(mainrastport,lastcx0,lastcy0,lastcx1,lastcy1,0);
+		}
+		lastcx0=-1;	/* LastCollisionRect als ungültig markieren */
+	}
+
+	if(bob && bob->Planes[0])
+	{
+		lastx0 = x0;
+		lasty0 = y0;
+		lastx1 = x1;
+		lasty1 = y1;
+		lastd  = bob->Depth;
+
+		DrawRect(mainrastport,(WORD)(x0-1),(WORD)(y0-1),x1,y1,
+		   (WORD)((options & GOF_BOBBORDERS) ? 1 : 0));
+
+		if(tmpmap=BobToBitMap(bob))
+		{
+			BltBitMapRastPort(tmpmap,0,0,mainrastport,x0,y0,
+			 bob->Width,bob->Height,0xc0);
+
+			MyFreeBitMap(tmpmap);
+		}
+		else ShowMonoReq2("Not enough memory to show bob!");
+
+		if(options & GOF_COLLISIONRECT)
+		{
+			lastcx0=x0+bob->CollX0;	/* Dieses CollisionRect merken */
+			lastcy0=y0+bob->CollY0;
+			lastcx1=x0+bob->CollX1;
+			lastcy1=y0+bob->CollY1;
+
+			mainrastport->LinePtrn = 0xAAAA;
+			DrawRect(mainrastport,lastcx0,lastcy0,lastcx1,lastcy1,1);
+			mainrastport->LinePtrn = 0xFFFF;
+		}
+	}
+}
+
+
+/*************************************************************************/
+
+void ShowFrame(WORD nr)
+{
+	register struct MyBob *bob;
+	char buf[16];
+
+	bob = BobTable[nr];
+	ShowBob(bob);
+
+	SetAPen(mainrastport,1);
+	SetBPen(mainrastport,0);
+	SetDrMd(mainrastport,JAM2);
+
+	if(toolrastport)
+	{
+		SetAPen(toolrastport,1);
+		SetBPen(toolrastport,0);
+		SetDrMd(toolrastport,JAM2);
+	}
+
+	if(bob)
+		sprintf(buf,"%3ld",(long)nr);
+	else
+		strcpy(buf,"new");
+	Move(mainrastport,mainwidth-25,19);
+	Text(mainrastport,buf,3);
+
+	sprintf(buf,"%3ld",(long)numbobs);
+	Move(mainrastport,mainwidth-25,mainheight-3);
+	Text(mainrastport,buf,3);
+
+	if(toolwindow)
+	{
+		if(bob)
+			sprintf(buf,"W%3ld",bob->Width);
+		else
+			sprintf(buf,"W   ");
+		Move(toolrastport,98,19);
+		Text(toolrastport,buf,4);
+
+		if(bob)
+			sprintf(buf,"H%3ld",bob->Height);
+		else
+			sprintf(buf,"H   ");
+		Move(toolrastport,138,19);
+		Text(toolrastport,buf,4);
+
+		if(bob)
+			sprintf(buf,"X%3ld",bob->X0);
+		else
+			sprintf(buf,"X   ");
+		Move(toolrastport,178,19);
+		Text(toolrastport,buf,4);
+
+		if(bob)
+			sprintf(buf,"Y%3ld",bob->Y0);
+		else
+			sprintf(buf,"Y   ");
+		Move(toolrastport,218,19);
+		Text(toolrastport,buf,4);
+
+	}
+
+	if(bob) LabelGadgetSInfo.Buffer = bob->SourceLabel;
+	else    LabelGadgetSInfo.Buffer = LabelGadgetSIBuff;
+	if(toolwindow) RefreshGList(&LabelGadget,toolwindow,0,1);
+
+
+	if(bob)
+	{
+		if(bob->Flags & BOBF_AUTOSIZE)
+		{
+			SelectGadget(toolwindow,&AutoSizeGadget);
+		}
+		else
+		{
+			DeselectGadget(toolwindow,&AutoSizeGadget);
+		}
+
+		if(bob->Flags & BOBF_AUTOORG)
+			SelectGadget(toolwindow,&AutoOrgGadget);
+		else
+			DeselectGadget(toolwindow,&AutoOrgGadget);
+
+		if(bob->Flags & BODF_ANIMKEY)
+			SelectGadget(toolwindow,&AnimKeyGadget);
+		else
+			DeselectGadget(toolwindow,&AnimKeyGadget);
+	}
+}
+
+
+/*************************************************************************/
+
+/* BobHit() liefert 'Position' des Punkts X/Y relativ zum Bob zurück:
+	Bit 0: Punkt zuweit oben
+	Bit 1: Punkt zuweit unten
+	Bit 2: Punkt zuweit links
+	Bit 3: Punkt zuweit rechts
+ */
+
+WORD BobHit(struct MyBob *bob,WORD x,WORD y)
+{
+	register WORD xl,yl,xh,yh,val;
+
+	xl = mainx0-bob->X0;	/* inklusive xl/yl */
+	yl = mainy0-bob->Y0;
+	xh = xl+bob->Width;		/* exklusive xh/yh */
+	yh = yl+bob->Height;
+	val = 0;
+
+	if(y<yl) val |= 1;
+	if(y>yh) val |= 2;
+	if(x<xl) val |= 4;
+	if(x>xh) val |= 8;
+	return(val);
+}
+
+
+/*************************************************************************/
+
+struct MyBob *AutoResizeBob(bob)
+register struct MyBob *bob;
+{
+	struct BitMap *bim;
+	register struct ByteMap *bym;
+	struct MyBob *newbob=0;
+
+	if(AutoSizeGadget.Flags & SELECTED)
+	{
+		if(bim=BobToBitMap(bob))
+		{
+			if(bym=MakeByteMap((WORD)(bim->BytesPerRow*8),bim->Rows))
+			{
+				BitMapToByteMap(bim,bym);
+				MyFreeBitMap(bim);
+
+				if(!AutoResizeByteMap(bym))
+				{
+					bym->Width=1; bym->Height=1;
+				}
+
+				bob->X0 -= (bob->Width-bym->Width)/2;	/* Bob-Org anpassen */
+				bob->Y0 -= (bob->Height-bym->Height)/2;
+
+				if(bim=MakeBitMap(bym->Width,bym->Height,bob->Depth))
+				{
+					ByteMapToBitMap(bym,bim);
+					if(newbob=BitMapToBob(bob,bim,bym->Width))
+					{
+						;
+					}
+					MyFreeBitMap(bim); bim=0;
+				}
+				else ShowMonoReq2("Not enough memory to resize bob");
+				FreeByteMap(bym);
+			}
+			else ShowMonoReq2("Not enough memory to resize bob");
+			if(bim) MyFreeBitMap(bim);
+		}
+		else ShowMonoReq2("Not enough memory to resize bob");
+
+	}	/* if AutoSizeGadget.Flags & SELECTED */
+	return newbob;
+}
+
+
+/*************************************************************************/
+
+void RemakeLabelsFunc()
+{
+	char buf[200];
+	register LONG i;
+
+	sprintf(buf,"Do you really want to overwrite\n"
+		"all your labels with the new\nlabel '%s' ?",LabelGadgetSIBuff);
+
+	if(ShowRequest2(buf,"Dänk scho!"))
+		for(i=0; i<numbobs; ++i)
+		{
+			sprintf(BobTable[i]->SourceLabel,LabelGadgetSIBuff,i);
+		}
+}
+
+
+/****************************************************************************
+**	Alle Collision-Rectangles auf Bob-Grösse setzen
+*/
+
+void RemakeCollisionFunc()
+{
+
+	if(ShowRequest2("Do you really want to change all\n"
+		"collision rects to the bob size ?","Yes, please!"))
+	{
+		register LONG i;
+		for(i=0; i<numbobs; ++i)
+		{
+			register struct MyBob *bob=BobTable[i];
+			bob->CollX0 = 0;
+			bob->CollY0 = 0;
+			bob->CollX1 = bob->Width-1;
+			bob->CollY1 = bob->Height-1;
+		}
+	}
+}
+
+
+/****************************************************************************
+**	Den Nullpunkt eines Bobs auf Default-Wert setzen
+*/
+
+void SetBobDefaultOrg(struct MyBob *bob)
+{
+	switch(defaultorg)
+	{
+		case 0:							// Oben links
+			bob->X0 = 0;
+			bob->Y0 = 0;
+			break;
+
+		case 1:							// Oben Mitte
+			bob->X0 = bob->Width/2;
+			bob->Y0 = 0;
+			break;
+
+		case 2:							// Oben rechts
+			bob->X0 = bob->Width-1;
+			bob->Y0 = 0;
+			break;
+
+		case 3:							// Mitte links
+			bob->X0 = 0;
+			bob->Y0 = bob->Height/2;
+			break;
+
+		case 4:							// Mitte Mitte
+			bob->X0 = bob->Width/2;
+			bob->Y0 = bob->Height/2;
+			break;
+
+		case 5:							// Mitte rechts
+			bob->X0 = bob->Width-1;
+			bob->Y0 = bob->Height/2;
+			break;
+
+		case 6:							// Unten links
+			bob->X0 = 0;
+			bob->Y0 = bob->Height-1;
+			break;
+
+		case 7:							// Unten Mitte
+			bob->X0 = bob->Width/2;
+			bob->Y0 = bob->Height-1;
+			break;
+
+		case 8:							// Unten rechts
+			bob->X0 = bob->Width-1;
+			bob->Y0 = bob->Height-1;
+			break;
+	}	
+}
diff --git a/BobStructure.h b/BobStructure.h
new file mode 100644
index 0000000..d180fef
--- /dev/null
+++ b/BobStructure.h
@@ -0,0 +1,112 @@
+/*
+**  Bobi - The Ultimate Amiga Bob Manipulator
+**
+**  BobStructure.h - MyBob, BobFileHeader, BobData
+**
+**  COPYRIGHT (C) 1989-1993 BY CHRISTIAN A. WEBER, ZUERICH, SWITZERLAND.
+**  ALL RIGHTS RESERVED. NO PART OF THIS SOFTWARE MAY BE COPIED, REPRODUCED,
+**  OR TRANSMITTED IN ANY FORM OR BY ANY MEANS, WITHOUT THE PRIOR WRITTEN
+**  PERMISSION OF THE AUTHOR. NO WARRANTY. USE AT YOUR OWN RISK.
+*/
+
+struct MyBob
+{
+	PLANEPTR	Planes[8];		/* Alle Planes sind aneinander!! */
+	PLANEPTR	Mask;			/* Zeiger auf Masken-Plane */
+	WORD		BytesPerRow;	/* Aufgerundetes ((Width+15)/8)&~1 */
+	WORD		Width;
+	WORD		Height;
+	WORD		Depth;
+	WORD		Flags;			/* Siehe BOBF_ Definitionen */
+	WORD		PlaneSize;		/* BytesPerRow*Height */
+
+	WORD		X0;				/* Nullpunkt X-Koordinate */
+	WORD		Y0;				/* Nullpunkt Y-Koordinate */
+	WORD		CollX0;			/* X0 des Kollisions-Bereiches */
+	WORD		CollY0;			/* Y0 des Kollisions-Bereiches */
+	WORD		CollX1;			/* X1 des Kollisions-Bereiches */
+	WORD		CollY1;			/* Y1 des Kollisions-Bereiches */
+
+	BYTE		PlanePick;		/* Für welche Planes existieren Daten */
+	BYTE		PlaneOnOff;		/* wie bei Image Struktur */
+	char		SourceLabel[64];
+};
+
+/* Folgende Flags (MyBob.Flags) sind nur für Bobi's Gebrauch */
+
+#define BOBF_AUTOSIZE  1		/* Bob-Größe wird automatisch errechnet */
+#define BOBF_AUTOORG   2		/* Bob bekommt neuen Org beim Manipulieren */
+#define BOB_PRIVATEMASK 0xff	/* Diese Flags werden nicht generiert */
+
+/* Folgende Flags (MyBob.Flags) sind für Bobol's Gebrauch und werden generiert */
+
+#define BODF_ANIMKEY 256		/* 1. Bob einer Animation */
+
+
+/*************************************************************************/
+
+struct BobFileHeader
+{
+	LONG	Magic;				/* Muss BF_MAGIC sein */
+	WORD	Version;			/* Versionsnummer des File-Formats */
+	WORD	NumBobs;
+	WORD	ColorTable[32];
+	char	OutputName[127];
+	BYTE	DefaultOrg;			/* 0=OL, 1=OM, 2=OR, 3=ML, 4=M, 5=MR, usw. */
+	WORD	OutputFlags;		/* Siehe OF_ - Definitionen */
+	char	SectionName[64];
+	char	DefaultLabel[64];
+	WORD	FirstAnimBob;
+	WORD	LastAnimBob;
+	UWORD	AnimSpeed;
+	WORD	AnimFlags;			/* Siehe AF_ - Definitionen */
+	WORD	GlobalOptions;		/* Siehe GO_ - in MyFunctions.h */
+	WORD	MainX0,MainY0;		/* ORG-Werte, z.B. von SetMainOrgFunc() */
+	BYTE	reserved[2];
+};
+
+#define BF_MAGIC 0x42424932		/* 'BBI2' */
+#define BF_VERSION 111			/* Version des File-Formats */
+
+
+/* Bit-Definitionen für das OutputFlags-Feld der BobFileHeader-Struktur: */
+
+#define OF_ASSEMBLER 1
+#define OF_OBJECT 2
+#define OF_RAWDATA 4
+
+#define OF_COLORTABLE 16
+#define OF_BOBDATA 32
+#define OF_BOBMASK 64
+
+#define OF_GENERATEBOBS 256		/* Bobs generieren */
+#define OF_GENERATESPRITES 512	/* Sprites generieren */
+
+
+/* Bit-Definitionen für das AnimFlags-Feld der BobFileHeader-Struktur: */
+
+#define AF_FORWARD 1			/* Animations-Richtung vorwärts */
+#define AF_BACKWARD 2			/* Animations-Richtung rückwärts */
+#define AF_BOUNCE 4				/* Modus: Normal/Bounce */
+
+
+/*************************************************************************/
+
+struct BobData	/* Steht im Source vor jedem Bob */
+{
+	WORD	Width;		/* Breite in Pixel */
+	WORD	Height;		/* Höhe in Linien */
+	WORD	X0;			/* X-Offset des Bob-Nullpunkts */
+	WORD	Y0;			/* Y-Offset des Bob-Nullpunkts */
+	WORD	CollX0;		/* X0 des Kollisions-Bereiches */
+	WORD	CollY0;		/* Y0 des Kollisions-Bereiches */
+	WORD	CollX1;		/* X1 des Kollisions-Bereiches */
+	WORD	CollY1;		/* Y1 des Kollisions-Bereiches */
+	BYTE	PlanePick;	/* Für welche Planes sind Daten vorhanden */
+	BYTE	PlaneOnOff;	/* Was tun mit den restlichen Planes */
+	WORD	Flags;		/* Verschiedene Flags, siehe BODF_ weiter oben */
+	WORD	WordSize;	/* Bob-Breite in WORDs +1 */
+	WORD	PlaneSize;	/* Anzahl Bytes bis zur nächsten Plane */
+	WORD	TotalSize;	/* Komplette Größe des Bobs/Sprites mit Header */
+};
+
diff --git a/Bobi.c b/Bobi.c
new file mode 100644
index 0000000..a898c45
--- /dev/null
+++ b/Bobi.c
@@ -0,0 +1,372 @@
+/*
+**  $Id$
+**
+**  Bobi.c - Hautprogramm
+**
+**  COPYRIGHT (C) 1989-1993 BY CHRISTIAN A. WEBER, ZUERICH, SWITZERLAND.
+**  ALL RIGHTS RESERVED. NO PART OF THIS SOFTWARE MAY BE COPIED, REPRODUCED,
+**  OR TRANSMITTED IN ANY FORM OR BY ANY MEANS, WITHOUT THE PRIOR WRITTEN
+**  PERMISSION OF THE AUTHOR. NO WARRANTY. USE AT YOUR OWN RISK.
+**
+**  Modification History
+**  --------------------
+**
+**  05-Mar-89  CHW   V2.01   Project started
+**  11-Jun-89  CHW   V2.15   InsertBobs added
+**  15-Jun-89  CHW   V2.16   SaveOffsets() added
+**  25-Jun-89  CHW   V2.20   An ch.lib angepasst
+**  04-Jul-89  CHW   V2.22   Generate Code Window versch?nert
+**  07-Jul-89  CHW   V2.24   AutoResizeBob() implementiert
+**  26-Jul-89  CHW   V2.30   Sprites, neues BobData-Format etc.
+**  05-Nov-89  CHW   V2.36   bod_Flags implementiert, Lattice 5.04
+**  07-Nov-89  CHW   V2.37   CollisionRects gr?sser als Bob m?glich
+**  12-Nov-89  CHW   V2.38   Generiert EQU-Headerfile f?r RawData
+**  17-Nov-89  CHW   V2.39   Default-Pfade werden aus '.bobi' gelesen
+**  23-Nov-89  CHW   V2.40   Aufger?umt, Bobsize nicht mehr begrenzt,
+**                           SetMainOrg() implementiert, 2 bugs fixed
+**  30-Nov-89  CHW   V2.42   About() verbessert, Collision auto on
+**  03-Dec-89  CHW   V2.43   Zoom funktioniert jetzt mit Clipping
+**  14-Dec-89  CHW   V2.44   LayerMode- & CustomBitmap-Bug fixed
+**  20-Jan-90  CHW   V2.99   ToolWindow implemented, LevelEd support added
+**  04-Mar-90  CHW   V2.99c  DecodeAnim benutzt iff.library
+**  09-Mar-90  CHW   V2.99d  Save Sprite OK f?r width < 16
+**  03-Apr-90  CHW   V2.99e  Pfad bleibt erhalten (f?r CHH)
+**  17-Jul-90  CHW   V2.99f  Default-Font definiert, Screen-Width var.
+**  12-Feb-91  CHW   V2.99i  Bei Sprites wird auch eine BobData-
+**                           Struktur definiert
+**  18-Feb-92  CHW   V2.99j  Ich kann's wieder compilieren :-)
+**  12-Apr-92  CHW   V2.99m  Picture-Screen scrollt unter 2.0
+**  12-Apr-92  CHW   V2.99n  BitMap<->ByteMap k?nnen auch <5 Planes,
+**                           deshalb haben Bobs jetzt nicht immer >=5 Pl.
+**  20-May-92  CHW   V2.99o  GenerateCode-ARexx-Befehl eingebaut
+**  06-Jun-92  CHW   V2.99p  Default-Org funktioniert jetzt
+**  11-Jul-92  CHW   V2.99q  Main-Screen ist jetzt Halfbrite
+**  02-Nov-93  CHW   V3.0    Compiliert mit sc6, ASL-Filerequester
+**  13-Jun-20  CHW   V3.1    Kann beim Startup Bob-File laden (CLI+WB)
+*/
+#include <proto/exec.h>
+#include <exec/libraries.h>
+#include <proto/graphics.h>
+#include <graphics/gfxbase.h>
+#include <proto/intuition.h>
+#include <intuition/intuitionbase.h>
+#include <proto/dos.h>
+#include <workbench/startup.h>
+
+#include <string.h>
+#include <libraries/iff.h>
+
+#include "Bobi_rev.h"
+#include "Bobi.h"
+#include "BobStructure.h"
+#include "MainWindow.h"
+
+extern void exit(LONG);
+extern void HandleImsg(struct IntuiMessage *, struct Menu *);
+
+#define ns NewScreenStructure
+
+extern struct Process *ProcessBase;		/* Zeiger auf unseren Prozess, siehe Startup.o */
+
+struct Library *MathBase, *MathTransBase;
+
+
+/****************************************************************************
+**	Globale Variable
+*/
+
+struct Library	*AslBase, *IFFBase;
+
+struct Screen	*mainscreen;
+struct Window	*mainwindow, *toolwindow;
+struct RastPort	*mainrastport, *toolrastport;
+
+struct Screen	*picturescreen;
+struct Window	*picturewindow;
+
+struct MyBob	*BobTable[MAXNUMBOBS+3];
+
+char idstring_versiontag[7] = { '\0', '$', 'V', 'E', 'R', ':', ' ' };
+char idstring[] = VERS " (" DATE ")";		/* Wird ?berall verwendet */
+
+
+WORD options;				/* Globale Optionen, siehe GO_ Bobi.h */
+BYTE defaultorg;			/* 0=OL, 1=OM, 2=OR, 3=ML, 4=M, 5=MR, usw. */
+WORD numbobs;				/* Momentane Anzahl benutzte Bobs */
+WORD actbobnum;				/* Nummer des aktuellen Bobs */
+
+UWORD mainpalette[64];		/* Palette des Bobi-Screens */
+UWORD picturepalette[64];	/* Palette des geladenen Bildes */
+
+char outputname[80];		/* Name des zu generierenden Files */
+char sectionname[80];		/* Name der Section des zu generierenden Files */
+WORD outputflags;			/* Sprache und so */
+
+WORD mainwidth,mainheight;	/* Ausmasse des Screens */
+WORD mainx0,mainy0;			/* Globaler Nullpunkt der Bobs */
+
+WORD firstanimbob,lastanimbob,animspeed,animflags;
+
+struct TextAttr MyScreenTextAttr =
+{
+	(STRPTR)"topaz.font", TOPAZ_EIGHTY, 0, 0
+};
+
+ULONG rexxsigmask;			/* ARexx Signal Bit Maske */
+
+
+/****************************************************************************
+**	L?scht alle Bobs
+*/
+
+void ClearAll()
+{
+	register long i;
+
+	for(i=0; i<numbobs; ++i)
+	{
+		FreeBob(BobTable[i]);
+		BobTable[i]=0;
+	}
+	numbobs   = 0;
+	actbobnum = 0;
+	SetGlobalOptions(GOF_LAYERMODE|GOF_BOBBORDERS|GOF_COLLISIONRECT,7);
+	outputflags = 0;
+	if(mainwindow) RefreshBobNum();
+
+	firstanimbob=lastanimbob=animspeed=0;
+	SetAnimFlags(AF_FORWARD);
+
+	strcpy(outputname,"RAM:TestBobs.S");
+	strcpy(sectionname,"BobData");
+	strcpy(LabelGadgetSIBuff,"Bob%ld");
+	if(!picturescreen)
+	{
+		CopyMem(Palette,mainpalette,PaletteColorCount*2);
+		if(mainscreen) LoadPalette(mainpalette);
+	}
+}	
+
+
+/****************************************************************************
+**	Alles freigeben und evtl. Programm verlassen
+*/
+
+void Cleanup(BOOL reallyquit)
+{
+	if(reallyquit)
+	{
+		CloseARexx();		/* Rexx-Stuff freigeben */
+		ClearAll();			/* Alle Bobs freigeben */
+	}
+
+	CloseScreenFunc();					/* Geladenes Bild freigeben */
+
+	if(toolwindow)
+	{
+		ToolNW.TopEdge=toolwindow->TopEdge;
+		ClearMenuStrip(toolwindow);
+		CloseWindow(toolwindow);
+		toolwindow=0; toolrastport=0;
+	}
+
+	if(mainwindow)
+	{
+		ClearMenuStrip(mainwindow);
+		ProcessBase->pr_WindowPtr=0;
+		CloseWindow(mainwindow);
+		mainwindow=0; mainrastport=0;
+	}
+
+	if(mainscreen)
+	{
+		CloseScreen(mainscreen);
+		mainscreen = NULL;
+	}
+
+	if(reallyquit)
+	{
+		if(IFFBase)
+		{
+			CloseLibrary(IFFBase);
+			IFFBase = NULL;
+		}
+
+		if (AslBase)
+		{
+			CloseLibrary(AslBase);
+			AslBase = NULL;
+		}
+
+		if(MathTransBase)
+		{
+			CloseLibrary(MathTransBase);
+			MathTransBase = NULL;
+		}
+
+		if(MathBase)
+		{
+			CloseLibrary(MathBase);
+			MathBase = NULL;
+		}
+
+		if(IntuitionBase)
+		{
+			CloseLibrary((struct Library *)IntuitionBase);
+			IntuitionBase = NULL;
+		}
+
+		if(GfxBase)
+		{
+			CloseLibrary((struct Library *)GfxBase);
+			GfxBase = NULL;
+		}
+		exit(0);
+	}
+}
+
+
+/****************************************************************************
+**	Fehlertext ausgeben und Programm verlassen
+*/
+
+void Fail(char *reason)
+{
+	char buf[200];
+	sprintf(buf,"%s:\n%s\nPlease consult your manual.",idstring,reason);
+	ShowRequest(buf,0,"OKAY",0x8000);
+	Cleanup(TRUE);
+}
+
+
+/****************************************************************************
+**	Gerufen bei Control-C-Signal
+*/
+
+void __stdargs __saveds _abort(void)
+{
+	if(CloseARexx())	/* D?rfen wir Quit machen ? */
+	{
+		Fail("*** BREAK  -  Bobi aborted.");
+	}
+}
+
+
+/****************************************************************************
+**	Screen und Window ?ffnen
+*/
+
+void OpenMain()
+{
+	ns.Width  = GfxBase->NormalDisplayColumns>>1;	/* /2 weil Lo-Res */
+	ns.Height = STDSCREENHEIGHT;
+	ns.Font   = &MyScreenTextAttr;
+	ns.DefaultTitle = idstring;
+
+	if(!(mainscreen = OpenScreen(&ns)))
+	{
+		Fail("Can't open screen");
+	}
+	LoadPalette(Palette);
+
+	MainNW.Screen = mainscreen;
+	MainNW.Width  = mainwidth  = mainscreen->Width;
+	MainNW.Height = mainheight = mainscreen->Height;
+	if(!(mainwindow = OpenWindow(&MainNW)))
+	{
+		Fail("Can't open window");
+	}
+	ProcessBase->pr_WindowPtr = (APTR)mainwindow;
+	mainrastport = mainwindow->RPort;
+	DrawRect(mainrastport,mainwidth-26,23,mainwidth-1,mainheight-13,1);
+
+	ToolWindowFunc();		/* ToolWindow ?ffnen falls enabled */
+}
+
+
+/****************************************************************************
+**	Hauptprogramm
+*/
+
+LONG Main(LONG arglen, char *argline)
+{
+	struct WBStartup *startup = (struct WBStartup *)argline;
+	char filename[200] = "\0";	/* File beim Start laden? */
+
+	ToolNW.TopEdge=10000;	/* ToolWindow ganz unten */
+
+	if(!(GfxBase = (struct GfxBase *)OpenLibrary("graphics.library",0L)))
+		return 0;
+
+	if(!(IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library",0L)))
+		return 0;
+
+	if(!(AslBase = OpenLibrary("asl.library", 0L)))
+		Fail("Can't open asl.library");
+
+	if(!(IFFBase = OpenLibrary(IFFNAME,0L)))
+		Fail("Can't open iff.library");
+
+	if(!(MathBase = OpenLibrary("mathffp.library",0L)))
+		Fail("Can't open mathffp.library");
+
+	if(!(MathTransBase = OpenLibrary("mathtrans.library",0L)))
+		Fail("Can't open mathtrans.library");
+
+	if(IFFBase->lib_Version < IFFVERSION)
+		Fail("Your iff.library is too old");
+
+	rexxsigmask=InitARexx();
+
+	LoadConfigFile(".bobi");
+	ClearAll();
+	mainx0=MAXX/2; mainy0=(MAXY*2)/3;
+
+	OpenMain();
+
+
+	/*
+	**	Tada! Die Hauptschleife
+	*/
+	for(;;)
+	{
+		struct IntuiMessage msgcopy,*msg;
+
+		SetMenuStrip(mainwindow,&MenuList1);
+		if(toolwindow) SetMenuStrip(toolwindow,&MenuList1);
+		actbobnum=ReadBobNum();
+		ShowFrame(actbobnum);
+		ModifyIDCMP(mainwindow,mainidcmpflags|MENUVERIFY);
+		if(toolwindow) ModifyIDCMP(toolwindow,toolidcmpflags|MENUVERIFY);
+
+		for(;;)
+		{
+			if(toolwindow && (mainwindow->Flags & WINDOWACTIVE))
+				ActivateWindow(toolwindow);
+			if(msg=(struct IntuiMessage *)GetMsg(mainwindow->UserPort)) break;
+			if(toolwindow)
+				if(msg=(struct IntuiMessage *)GetMsg(toolwindow->UserPort))
+					break;
+
+			if(toolwindow) Wait(SIGMASK(mainwindow)|SIGMASK(toolwindow)|rexxsigmask);
+			else Wait(SIGMASK(mainwindow)|rexxsigmask);
+			RexxMsgHandler();
+		}
+
+		CopyMem(msg,&msgcopy,sizeof(msgcopy));
+		ReplyMsg((struct Message *)msg);
+		if(msgcopy.Class == MENUVERIFY)
+		{
+			LoadPalette(Palette);					/* Default-Farben */
+		}
+		else
+		{
+			ModifyIDCMP(mainwindow,mainidcmpflags);		/* MENUVERIFY off */
+			if(toolwindow) ModifyIDCMP(toolwindow,toolidcmpflags);
+			GetGlobalOptions();						/* options updaten */
+			HandleImsg(&msgcopy,&MenuList1);
+		}
+	}
+
+	return 0;
+}
diff --git a/Bobi.doc b/Bobi.doc
new file mode 100644
index 0000000..f9b0fa4
--- /dev/null
+++ b/Bobi.doc
@@ -0,0 +1,122 @@
+AREXX Kommandos für Bobi V2.99m  (12. April 1992)
+-------------------------------------------------
+
+Port:		"rexx_bobi"
+
+
+Allgemeine Steuer-Kommandos
+---------------------------
+
+BobiToFront				Bobi-Screen in den Vordergrund
+
+BobiToBack				Bobi-Screen in den Hintergrund
+
+
+Project-Menu
+------------
+
+ClearAll				Alles löschen
+
+LoadBobs	Filename		Bobi-File laden
+
+InsertBobs	Filename Position	Bobi-File einfügen
+
+SaveBobs	Filename		Bobi-File speichern
+
+GenerateCode	Filename [Modus]	Code generieren
+					Werte für Modus:
+						ASM = Assembler-Source
+						OBJ = Objekt-Modul
+						RAW = Raw-Data
+
+
+Picture-Menu
+------------
+
+LoadIFF 	Filename		IFF-Bild laden
+
+ClosePicture				IFF-Bild-Screen schliessen
+
+
+Bob-Menu
+--------
+
+GetBob		X Y Breite Höhe		Bob ausschneiden 
+
+SetOrg		X Y			Bob-Nullpunkt setzen
+
+DefaultOrg	Position		Default-Nullpunkt setzen, die 9 Mög-
+					lichkeiten entsprechen den Zahlen
+					1-9 auf dem Zehnerblock
+
+SetCollision	X Y Breite Höhe		Bob-Kollisions-Bereich setzen
+
+FlipX					Bob in X-Richtung spiegeln
+
+FlipY					Bob in Y-Richtung spiegeln
+
+Rotate		Winkel Anzahl		Bob um <Winkel> Grad (0-360) rotie-
+					ren und dabei <Anzahl> neue Bobs
+					generieren
+
+Zoom		Faktor1 Faktor2 Anzahl	Bob von <Faktor1> (Start-Faktor nach
+					<Faktor2> (End-Faktor) zoomen und
+					dabei <Anzahl> neue Bobs generieren.
+					Die Faktoren müssen in Prozent ange-
+					geben werden (0-1000)
+
+InsertNew				Neuen Bob an die aktuelle Stelle
+					einfügen
+
+DeleteBob				Aktuelles Bob löschen
+
+
+Anim-Menu
+---------
+
+LoadAnim	Filename		IFF-Animation laden und in Bobs
+					umwandeln
+
+SaveAnim	Filename		Bobs als IFF-Animation speichern
+					(nicht implementiert :-))
+
+AnimFirst	[Nummer]		Aktuelles Bob oder Bob <Nummer> als
+					erstes Animations-Bob setzen
+
+AnimLast	[Nummer]		Aktuelles Bob oder Bob <Nummer> als
+					letztes Animations-Bob setzen
+
+AnimMode	Modus			Animations-Modus setzen:
+					FORWARD   = Vorwärts
+					BACKWARD  = Rückwärts
+					PING-PONG = Hin und zurück
+
+StartAnim				Animation starten
+
+StopAnim				Animation wieder anhalten
+
+
+Global-Menu
+-----------
+
+ToolWindow	ON | OFF		Werkzeugfenster ein / aus
+
+LayerMode	ON | OFF		Verschiebemodus ein / aus
+
+OrgGrid		ON | OFF		Nullpunkts-Fadenkreuz ein / aus
+
+BobBorders	ON | OFF		Bob-Rahmen ein / aus
+
+BobCollision	ON | OFF		Kollisions-Rahmen ein / aus
+
+SetMainOrg	X Y			Globalen Nullpunkt setzen
+
+LoadOffsets	Filename		Bob-Offset-Tabelle laden
+
+SaveOffsets	Filename		Bob-Offset-Tabelle speichern
+
+RemakeLabels				Alle Labels neu generieren
+
+RemakeCollision				Alle Kollisions-Rechtecke auf die
+					Bob-Grösse zurücksetzen
+
diff --git a/Bobi.h b/Bobi.h
new file mode 100644
index 0000000..102573a
--- /dev/null
+++ b/Bobi.h
@@ -0,0 +1,260 @@
+/*
+**  Bobi - The Ultimate Amiga Bob Manipulator
+**
+**  Bobi.h - Haupt-Include-File
+**
+**  COPYRIGHT (C) 1989-1993 BY CHRISTIAN A. WEBER, ZUERICH, SWITZERLAND.
+**  ALL RIGHTS RESERVED. NO PART OF THIS SOFTWARE MAY BE COPIED, REPRODUCED,
+**  OR TRANSMITTED IN ANY FORM OR BY ANY MEANS, WITHOUT THE PRIOR WRITTEN
+**  PERMISSION OF THE AUTHOR. NO WARRANTY. USE AT YOUR OWN RISK.
+*/
+
+#include <dos/dos.h>
+#include <libraries/iff.h>
+#include <stdio.h>
+#include <string.h>
+
+#define ClearMem(buf,len) memset(buf, 0, len)
+
+
+#define MAXNUMBOBS 500	/* Maximale Anzahl Bobs */
+
+
+/****************************************************************************
+**	Definition des für Bobs benützbaren Bereichs des Bobi-Screens
+*/
+
+#define MINX 1
+#define MINY 12
+#define MAXX 292
+#define MAXY 197
+
+/****************************************************************************
+**	Bit-Definitionen für die globalen Optionen:
+*/
+
+#define GOF_LAYERMODE 1			/* Layer-Modus ein/aus */
+#define GOF_ORGGRID 2			/* MainOrg-Fadenkreuz sichtbar */
+#define GOF_BOBBORDERS 4		/* Bob-Rähmchen sichtbar */
+#define GOF_COLLISIONRECT 8		/* Kollisions-Grenzen sichtbar */
+
+
+/****************************************************************************
+**	Aliases die das Leben leichter machen:
+*/
+
+#define MainNW NewWindowStructure1
+#define ToolNW NewWindowStructure2
+#define SIGMASK(w) (1L<<(w)->UserPort->mp_SigBit)
+
+
+/****************************************************************************
+**	MenuItem-Aliases
+*/
+
+#define ForwardItem SubItem1				/* Anim Modes */
+#define BackwardItem SubItem2
+#define PingPongItem SubItem3
+#define FirstDefaultOrgSubItem SubItem4		/* 9 Items insgesamt */
+#define ToolWindowMenuItem MenuItem1
+#define LayerModeMenuItem MenuItem2			/* Layer Mode on/off */
+#define OrgGridMenuItem MenuItem3			/* Main Org Grid */
+#define BobBordersMenuItem MenuItem4		/* Gadget Borders */
+#define CollisionRectMenuItem MenuItem5		/* Show Collision Bounds */
+
+
+/*
+**	Macro zum Abfragen der aktuellen Betriebssystem-Version
+*/
+
+#define OSVERSION(ver)	(IntuitionBase->LibNode.lib_Version >= (ver))
+
+
+/********************** Menu 1: Project **********************************/
+
+void ClearAllFunc(void);				/* Bobi.c */
+void LoadBobsFunc(void);				/* LoadBobs.c */
+void InsertBobsFunc(void);				/* LoadBobs.c */
+void SaveBobsFunc(void);				/* LoadBobs.c */
+void DeleteFileFunc(void);				/* LoadBobs.c */
+void GenerateCodeFunc(void);			/* Generate.c */
+void AboutFunc(void);					/* About.c */
+void SleepFunc(void);					/* Sleep.c */
+void QuitFunc(void);					/* Stubs.c */
+
+
+/********************** Menu 2: Picture **********************************/
+
+void LoadPicFunc(void);					/* Picture.c */
+void GrabDPaintFunc(void);				/* Stubs.c */
+void GrabScreenFunc(void);				/* Stubs.c */
+void CloseScreenFunc(void);				/* Picture.c */
+
+
+/********************** Menu 3: Bob **************************************/
+
+void GetBobFunc(void);					/* Menu 3 & Gadget */
+void GetMultiFunc(void);				/* Menu 3 & Gadget */
+void SetOrgFunc(void);					/* Menu 3 & Gadget */
+void SetCollBoundsFunc(void);			/* Menu 3 & Gadget */
+void FlipXFunc(void);					/* Menu 3 */
+void FlipYFunc(void);					/* Menu 3 */
+void RotateFunc(void);					/* Rotate.c */
+void ZoomFunc(void);					/* Zoom.c */
+void InsertNewBobFunc(void);			/* Menu 3 */
+void DeleteActBobFunc(void);			/* Menu 3 */
+
+
+/********************** Menu 4: Anim *************************************/
+
+void LoadIFFAnimFunc(void);				/* Menu 4 */
+void SaveIFFAnimFunc(void);				/* Menu 4 */
+void SetFirstBobFunc(void);				/* Menu 4 */
+void SetLastBobFunc(void);				/* Menu 4 */
+void StartAnimFunc(void);				/* Menu 4 */
+void SetAnimModeFunc(void);				/* Menu 4 */
+
+
+/********************** Menu 5: Global ***********************************/
+
+void ToolWindowFunc(void);				/* Stubs.c */
+void SetMainOrgFunc(void);				/* Menu 5 */
+void EditPaletteFunc(void);				/* Menu 5 */
+void NewCLIFunc(void);					/* Menu 5 */
+void LoadOffsetsFunc(void);				/* Menu 5 */
+void SaveOffsetsFunc(void);				/* Menu 5 */
+void RemakeLabelsFunc(void);			/* Menu 5 */
+void RemakeCollisionFunc(void);			/* Menu 5 */
+
+
+/********************** Globale Prozeduren *******************************/
+
+/***** Anim.c: *****/
+
+UWORD GetAnimSpeed(void);
+void SetAnimFlags(WORD);
+void SetAnimSpeed(UWORD);
+
+
+/***** ARexx.c: *****/
+
+ULONG InitARexx(void);
+ULONG CloseARexx(void);
+void RexxMsgHandler(void);
+
+
+/***** Bob.c: *****/
+
+struct MyBob *MakeBob(WORD,WORD,WORD);
+void FreeBob(struct MyBob *);
+struct MyBob *BitMapToBob(struct MyBob *,struct BitMap *,WORD);
+struct BitMap *BobToBitMap(struct MyBob *);
+void DeleteBob(WORD);
+void InsertBob(struct MyBob *,WORD);
+void ShowBob(struct MyBob *);
+void ShowFrame(WORD);
+WORD BobHit(struct MyBob *,WORD,WORD);
+struct MyBob *AutoResizeBob(struct MyBob *);
+void SetBobDefaultOrg(struct MyBob *);
+
+
+/***** Bobi.c: *****/
+
+void ClearAll(void);
+void OpenMain(void);
+void Cleanup(BOOL);
+
+
+/***** BMapSupport.c *****/
+
+struct BitMap *MakeBitMap(WORD,WORD,WORD);
+void MyFreeBitMap(struct BitMap *);
+struct ByteMap *MakeByteMap(WORD,WORD);
+void FreeByteMap(struct ByteMap *);
+
+
+/***** ByteMap.a: *****/
+
+void BitMapToByteMap(struct BitMap *,struct ByteMap *);
+void BobToByteMap(struct MyBob *,struct ByteMap *);
+void ByteMapToBitMap(struct ByteMap *,struct BitMap *);
+BOOL AutoResizeByteMap(struct ByteMap *);
+void RotateByteMap(struct ByteMap *,struct ByteMap *,LONG,LONG,LONG,LONG);
+void FlipXByteMap(struct ByteMap *);
+void FlipYByteMap(struct ByteMap *);
+void ZoomByteMap(struct ByteMap *,struct ByteMap *,LONG);
+
+
+/***** Color.c: *****/
+
+WORD *RequestColor(struct Screen *);
+
+
+/***** ConvertDate.S *****/
+
+char  __regargs *ConvertDate(struct DateStamp *, char *);
+
+
+/***** CreateRastPort.S ****/
+
+struct RastPort * __regargs CreateRastPort(WORD, WORD, WORD);
+void __regargs DeleteRastPort(struct RastPort *);
+
+
+/***** FileRequest.c: *****/
+
+STRPTR FileRequest(STRPTR wtitle, STRPTR postext, STRPTR drawer, STRPTR file);
+
+
+/***** GadgetSupport.S *****/
+
+BOOL __regargs DeselectGadget(struct Window *,struct Gadget *);
+BOOL __regargs SelectGadget(struct Window *,struct Gadget *);
+
+
+/***** Get.c: *****/
+
+BOOL GetBob(int x,int y,int w,int h);
+
+
+/***** LoadBobs.c: *****/
+
+void LoadBobs(char *);
+void LoadConfigFile(char *);
+
+
+/***** Misc.c: *****/
+
+void ShowMonoReq2(char *);
+BOOL ShowRequest2(char *,char *);
+void ShowFileError(char *);
+BPTR OpenNewFileSafely(char *);
+void DrawRect(struct RastPort *,WORD,WORD,WORD,WORD,WORD);
+void DrawCross(struct Screen *,WORD,WORD);
+void LoadPalette(UWORD *);
+void LockWindows(void);
+void UnLockWindows(void);
+void SetGlobalOptions(WORD opts, BYTE defaultorg);
+void GetGlobalOptions(void);
+
+
+/***** PropGadgets.c: *****/
+
+void MovePosFunc(void);
+void RefreshBobNum(void);
+WORD ReadBobNum(void);
+
+
+/***** Snooze.S *****/
+
+void __regargs Snooze(struct Window *);
+void __regargs UnSnooze(struct Window *);
+
+
+/***** Verschiedenes: *****/
+
+void DragBobFunc(void);				/* Layer.c */
+void HandleEvent(APTR);				/* MainWindow.h, PW2 */
+void ShowIFFError(char *);			/* IFFError.c */
+LONG ShowRequest(char *text, char *postext, char *negtext, ULONG flags);	/* ShowRequest.c */
+
diff --git a/Bobi.info b/Bobi.info
new file mode 100644
index 0000000..49da4d0
--- /dev/null
+++ b/Bobi.info
diff --git a/Bobi_rev.h b/Bobi_rev.h
new file mode 100644
index 0000000..cf15dc2
--- /dev/null
+++ b/Bobi_rev.h
@@ -0,0 +1,8 @@
+/* $VER: 3.0 - File 'Bobi_rev.h' */
+#define	VERSION		3
+#define	REVISION	0
+#define	DATE	"2.11.93"
+#define	VERS	"Bobi 3.0"
+#define	VSTRING	"Bobi 3.0 (2.11.93)\n\r"
+#define	VERSTAG	"\0$VER: Bobi 3.0 (2.11.93)"
+/* Bumper 37.116 (12.7.91) was here */
diff --git a/ByteMap.S b/ByteMap.S
new file mode 100644
index 0000000..d2a0c04
--- /dev/null
+++ b/ByteMap.S
@@ -0,0 +1,591 @@
+**
+**  Bobi - The Ultimate Amiga Bob Manipulator
+**
+**  ByteMap.S - ByteMaps konvertieren, spiegeln, rotieren, zoomen usw.
+**
+**  COPYRIGHT (C) 1989-1993 BY CHRISTIAN A. WEBER, ZUERICH, SWITZERLAND.
+**  ALL RIGHTS RESERVED. NO PART OF THIS SOFTWARE MAY BE COPIED, REPRODUCED,
+**  OR TRANSMITTED IN ANY FORM OR BY ANY MEANS, WITHOUT THE PRIOR WRITTEN
+**  PERMISSION OF THE AUTHOR. NO WARRANTY. USE AT YOUR OWN RISK.
+**
+
+
+		IDNT	ByteMap
+		SECTION	text,CODE
+
+		INCLUDE	"exec/types.i"
+		INCLUDE	"graphics/gfx.i"
+
+		XDEF	@BitMapToByteMap,@BobToByteMap,@ByteMapToBitMap
+		XDEF	@AutoResizeByteMap
+		XDEF	@FlipXByteMap,@FlipYByteMap
+		XDEF	@RotateByteMap,@ZoomByteMap
+
+
+*****************************************************************************
+
+   STRUCTURE MyBob,0
+	STRUCT	mb_Planes,8*4		; Alle Planes sind aneinander!!
+	APTR	mb_Mask			; Zeiger auf Masken-Plane
+	WORD	mb_BytesPerRow		; Aufgerundetes ((Width+15)/8)&~1
+	WORD	mb_Width
+	WORD	mb_Height
+	WORD	mb_Depth
+	WORD	mb_Flags		; Siehe BOBF_ Definitionen
+	WORD	mb_PlaneSize		; BytesPerRow*Height
+
+	WORD	mb_X0			; Nullpunkt X-Koordinate
+	WORD	mb_Y0			; Nullpunkt Y-Koordinate
+	WORD	mb_CollX0		; X0 des Kollisions-Bereiches
+	WORD	mb_CollY0		; Y0 des Kollisions-Bereiches
+	WORD	mb_CollX1		; X1 des Kollisions-Bereiches
+	WORD	mb_CollY1		; Y1 des Kollisions-Bereiches
+
+	BYTE	mb_PlanePick		; Für welche Planes existieren Daten
+	BYTE	mb_PlaneOnOff		; wie bei Image Struktur
+	STRUCT	mb_SourceLabel,64
+
+	LABEL	mb_SIZEOF
+
+
+*****************************************************************************
+
+   STRUCTURE ByteMap,0
+
+	WORD bym_Width		; Breite der ByteMap in Pixel
+	WORD bym_Height		; Höhe der ByteMap in Pixel
+	LONG bym_PlaneSize	; Grösse für Alloc/FreeMem der Plane
+	APTR bym_Plane		; Zeiger auf die aktuelle Datenplane
+
+	LABEL bym_SIZEOF
+
+
+***************************************************************************
+**                                                                       **
+**   BitMapToByteMap  -  BitMap in ByteMap umwandeln (1Byte=1Pixel)      **
+**                                                                       **
+***************************************************************************
+**                                                                       **
+**   Parameter :  A0.L :  Zeiger auf struct BitMap  (Source)             **
+**                A1.L :  Zeiger auf struct ByteMap (Destination)        **
+**                                                                       **
+**   Resultat :   nix                                                    **
+**                                                                       **
+***************************************************************************
+
+@BitMapToByteMap:
+		movem.l	d0-d7/a0-a6,-(SP)
+		movem.l	bm_Planes(a0),a2-a6	; IMMER 5 Planes
+		bra.b	ToByteMap		; --->
+
+
+***************************************************************************
+**                                                                       **
+**   BobToByteMap  -  struct MyBob in ByteMap umwandeln (1Byte=1Pixel)   **
+**                                                                       **
+***************************************************************************
+**                                                                       **
+**   Parameter :  A0.L :  Zeiger auf struct MyBob   (Source)             **
+**                A1.L :  Zeiger auf struct ByteMap (Destination)        **
+**                                                                       **
+**   Resultat :   nix                                                    **
+**                                                                       **
+***************************************************************************
+
+@BobToByteMap:	movem.l	d0-d7/a0-a6,-(SP)
+		movem.l	mb_Planes(a0),a2-a6	; IMMER 5 Planes
+	;;	bra.b	ToByteMap		; --->
+
+ToByteMap:	bsr	ValidatePlanePointers	; Falls weniger als 5 Planes
+		move.w	bym_Height(a1),-(SP)
+		move.w	bym_Width(a1),-(SP)
+		movea.l	bym_Plane(a1),a1	; Destination-Plane
+		movea.w	#16,a0			; 16 Bits pro Word
+
+1$:		move.w	(SP),d7			; Breite in Pixel
+2$:		move.w	(a2)+,d2
+		move.w	(a3)+,d3
+		move.w	(a4)+,d4
+		move.w	(a5)+,d5
+		move.w	(a6)+,d6
+		moveq	#15,d1
+		cmp.w	a0,d7			; Noch mehr als 16 Bit ?
+		bge.b	3$			; ja --->
+		move.w	d7,d1
+		bra.b	4$			; für dbf
+3$:	;;	moveq	#0,d0
+		addx.w	d6,d6			; roxl.w #1,d6
+		addx.w	d0,d0
+		addx.w	d5,d5
+		addx.w	d0,d0
+		addx.w	d4,d4
+		addx.w	d0,d0
+		addx.w	d3,d3
+		addx.w	d0,d0
+		addx.w	d2,d2
+		addx.w	d0,d0
+		move.b	d0,(a1)+
+4$:		dbf	d1,3$
+		sub.w	a0,d7			; D7 -= 16
+		bgt.b	2$
+		subq.w	#1,2(SP)		; DEC Rows
+		bgt.b	1$
+		addq.l	#4,SP			; Lokalen Datenraum freigeben
+		movem.l	(SP)+,d0-d7/a0-a6
+		rts
+
+
+***************************************************************************
+**                                                                       **
+**   ByteMapToBitMap  -  ByteMap in BitMap umwandeln (1Byte=1Pixel)      **
+**                                                                       **
+***************************************************************************
+**                                                                       **
+**   Parameter :  A0.L :  Zeiger auf struct ByteMap (Source)             **
+**                A1.L :  Zeiger auf struct BitMap  (Destination)        **
+**                                                                       **
+**   Resultat :   nix                                                    **
+**                                                                       **
+***************************************************************************
+
+@ByteMapToBitMap:
+		movem.l	d0-d7/a0-a6,-(SP)
+		move.w	bym_Height(a0),-(SP)
+		move.w	bym_Width(a0),-(SP)
+		movea.l	bym_Plane(a0),a0	; Source-ByteMap-Plane
+		movem.l	bm_Planes(a1),a2-a6	; IMMER 5 Destination-Planes
+		bsr	ValidatePlanePointers	; Falls weniger als 5 Planes
+		movea.w	#16,a1			; 16 Bits pro Word
+
+1$:		move.w	(SP),d7			; Breite in Pixel
+2$:		moveq	#15,d1
+3$:		move.b	(a0)+,d0		; Color-Wert
+		roxr.w	#1,d0
+		roxl.w	#1,d2
+		roxr.w	#1,d0
+		roxl.w	#1,d3
+		roxr.w	#1,d0
+		roxl.w	#1,d4
+		roxr.w	#1,d0
+		roxl.w	#1,d5
+		roxr.w	#1,d0
+		roxl.w	#1,d6
+		dbf	d1,3$
+		move.w	d2,(a2)+
+		move.w	d3,(a3)+
+		move.w	d4,(a4)+
+		move.w	d5,(a5)+
+		move.w	d6,(a6)+
+
+		sub.w	a1,d7			; D7 -= 16
+		bgt.b	2$
+		neg.w	d7			; D7 := #zuvielgenommene Pixel
+		suba.w	d7,a0			; Correct Source
+		add.w	d7,d7			; Index in WORD-Tabelle
+		move.w	MaskTab(PC,d7.w),d0
+		and.w	d0,-2(a2)		; Rest-Pixel löschen
+		and.w	d0,-2(a3)
+		and.w	d0,-2(a4)
+		and.w	d0,-2(a5)
+		and.w	d0,-2(a6)
+		subq.w	#1,2(SP)		; DEC Rows
+		bgt.b	1$
+
+		addq.l	#4,SP			; Lokalen Datenraum freigeben
+		movem.l	(SP)+,d0-d7/a0-a6
+		rts
+
+MaskTab:	dc.w	%1111111111111111
+		dc.w	%1111111111111110
+		dc.w	%1111111111111100
+		dc.w	%1111111111111000
+		dc.w	%1111111111110000
+		dc.w	%1111111111100000
+		dc.w	%1111111111000000
+		dc.w	%1111111110000000
+		dc.w	%1111111100000000
+		dc.w	%1111111000000000
+		dc.w	%1111110000000000
+		dc.w	%1111100000000000
+		dc.w	%1111000000000000
+		dc.w	%1110000000000000
+		dc.w	%1100000000000000
+		dc.w	%1000000000000000
+
+
+***************************************************************************
+**                                                                       **
+**   AutoResizeByteMap  -  ByteMap auf kleinstmögliche Grösse reduzieren **
+**                                                                       **
+***************************************************************************
+**                                                                       **
+**   Parameter :  A0.L :  Zeiger auf struct ByteMap                      **
+**                                                                       **
+**   Resultat :   D0.L :  0 falls ByteMap leer, 1 sonst                  **
+**                                                                       **
+***************************************************************************
+
+@AutoResizeByteMap:
+		movem.l	d1-d6/a0-a3,-(SP)
+		moveq	#0,d0			; D0 :  X0
+		moveq	#0,d1			; D1 :  Y0
+		move.w	bym_Width(a0),d2	; D2 :  Breite in Pixel
+		move.w	bym_Height(a0),d3	; D3 :  Höhe in Pixel
+		move.w	d2,d4			; D4 :  Originalbreite const.
+		movea.l	bym_Plane(a0),a1	; A1 :  Plane
+
+	*** Neues Y0 finden
+
+FindY0:		movea.l	a1,a2			; Plane
+1$:		move.w	d2,d5			; Breite
+		bra.b	3$			; für dbf
+2$:		tst.b	(a2)+			; Pixel == 0 ?
+		bne.b	4$			; nein ---> Y0 gefunden
+3$:		dbf	d5,2$
+		addq.w	#1,d1			; INC Y0
+		subq.w	#1,d3			; DEC Höhe
+		bgt.b	1$			; Noch grösse als 0 ---> Loop
+		bra	ByteMapEmpty
+4$:
+	*** Neues Y1 finden
+
+FindY1:		movea.l	a1,a2			; Plane
+		move.w	d2,d5			; Breite
+		mulu.w	bym_Height(a0),d5	; mal Original-Höhe
+		adda.l	d5,a2			; Plane-Ende
+1$:		move.w	d2,d5			; Breite
+		bra.b	3$			; für dbf
+2$:		tst.b	-(a2)			; Pixel == 0 ?
+		bne.b	4$			; nein ---> Y1 gefunden
+3$:		dbf	d5,2$
+		subq.w	#1,d3			; DEC Höhe
+		bgt.b	1$			; > 0 ---> Loop
+		bra	ByteMapEmpty
+4$:
+	*** Neues X0 finden
+
+FindX0:		movea.l	a1,a2			; Plane
+		move.w	d1,d5			; Y0
+		mulu.w	d4,d5			; * Original-Width
+		adda.l	d5,a2
+		move.w	d4,d5			; Original-Breite
+1$:		movea.l	a2,a3			; Plane
+		move.w	d3,d6			; Höhe
+		bra.b	3$
+2$:		tst.b	(a3)			; Pixel == 0 ?
+		bne.b	4$			; nein ---> X0 gefunden
+		adda.w	d5,a3			; Plane += Width
+3$:		dbf	d6,2$
+		addq.l	#1,a2			; INC Plane
+		addq.w	#1,d0			; INC X0
+		subq.w	#1,d2			; DEC Width
+		bgt.b	1$			; > 0 ---> Loop
+		bra	ByteMapEmpty
+4$:
+	*** Neues X1 finden
+
+FindX1:		movea.l	a1,a2			; Plane
+		move.w	d1,d5			; Y0
+		addq.w	#1,d5			; Ganz rechts + 1
+		mulu.w	d4,d5			; * Original-Width
+		adda.l	d5,a2
+		move.w	d4,d5			; Original-Breite
+1$:		subq.l	#1,a2			; DEC Plane
+		movea.l	a2,a3			; Plane
+		move.w	d3,d6			; Höhe
+		bra.b	3$
+2$:		tst.b	(a3)			; Pixel == 0 ?
+		bne.b	4$			; nein ---> X0 gefunden
+		adda.w	d5,a3			; Plane += Width
+3$:		dbf	d6,2$
+		subq.w	#1,d2			; DEC Width
+		bgt.b	1$			; > 0 ---> Loop
+		bra	ByteMapEmpty
+4$:
+	*** Neue Parameter in ByteMap eintragen
+
+		subq.w	#1,d2			; Nur so stimmt's weiss auch nicht wieso
+		move.w	d2,bym_Width(a0)
+		move.w	d3,bym_Height(a0)
+
+	*** ByteMap an neues Format anpassen
+
+ResizeBM:	movea.l	a1,a2			; Destination
+		adda.w	d0,a1			; A1 += X0
+		mulu.w	d4,d1			; Y0 *= Old Width
+		adda.l	d1,a1			; A1 += Y0
+		move.w	d4,d0			; Original-Width
+		sub.w	d2,d0			; D0 := Width-Modulo
+		move.w	d3,d6			; Height
+		bra.b	4$			; Für dbf
+1$:		move.w	d2,d5			; Neue Breite
+		bra.b	3$			; Für dbf
+2$:		move.b	(a1)+,(a2)+		; Tada!
+3$:		dbf	d5,2$
+		adda.w	d0,a1			; A1 += Width-Modulo
+4$:		dbf	d6,1$			; DEC Höhe, Loop
+
+		moveq.l	#1,d0			; 'Not empty'
+		bra.b	AutoResizeEnd		; --->
+
+ByteMapEmpty:	moveq.l	#0,d0			; 'Empty'
+
+AutoResizeEnd:	movem.l	(SP)+,d1-d6/a0-a3
+		rts
+
+
+***************************************************************************
+**                                                                       **
+**   FlipXByteMap  -  ByteMap in X-Richtung spiegeln                     **
+**                                                                       **
+***************************************************************************
+**                                                                       **
+**   Parameter :  A0.L :  Zeiger auf struct ByteMap                      **
+**                                                                       **
+**   Resultat :   nix                                                    **
+**                                                                       **
+***************************************************************************
+
+@FlipXByteMap:	movem.l	d0-d3/a0-a2,-(SP)
+		move.w	bym_Width(a0),d0	; Breite in Pixel
+		move.w	bym_Height(a0),d1	; Höhe in Pixel
+		movea.l	bym_Plane(a0),a0	; Plane
+		bra.b	4$			; für dbf
+1$:		move.w	d0,d2
+		asr.w	#1,d2			; X/2
+		movea.l	a0,a1			; links
+		lea	0(a1,d0.w),a2		; rechts
+		bra.b	3$			; für dbf
+
+2$:		move.b	(a1),d3			; Pixel swappen
+		move.b	-(a2),(a1)+
+		move.b	d3,(a2)
+
+3$:		dbf	d2,2$
+		adda.w	d0,a0			; Nächste Linie
+4$:		dbf	d1,1$
+		movem.l	(SP)+,d0-d3/a0-a2
+		rts
+
+
+***************************************************************************
+**                                                                       **
+**   FlipYByteMap  -  ByteMap in Y-Richtung spiegeln                     **
+**                                                                       **
+***************************************************************************
+**                                                                       **
+**   Parameter :  A0.L :  Zeiger auf struct ByteMap                      **
+**                                                                       **
+**   Resultat :   nix                                                    **
+**                                                                       **
+***************************************************************************
+
+@FlipYByteMap:	movem.l	d0-d3/a0-a1,-(SP)
+		move.w	bym_Width(a0),d0	; Breite in Pixel
+		move.w	bym_Height(a0),d1	; Höhe in Pixel
+		movea.l	bym_Plane(a0),a0	; Plane
+
+		move.w	d1,d2
+		subq.w	#1,d2
+		mulu.w	d0,d2
+		movea.l	a0,a1
+		adda.l	d2,a1			; A1: Letzte Linie
+		lsr.w	#1,d1			; D1: Höhe/2
+		bra.b	4$			; für dbf
+
+1$:		move.w	d0,d2			; Breite
+		bra.b	3$			; für dbf
+2$:		move.b	(a0),d3
+		move.b	(a1),(a0)+
+		move.b	d3,(a1)+
+3$:		dbf	d2,2$
+		suba.w	d0,a1
+		suba.w	d0,a1
+4$:		dbf	d1,1$
+
+		movem.l	(SP)+,d0-d3/a0-a1
+		rts
+
+
+***************************************************************************
+**                                                                       **
+**   RotateByteMap  -  ByteMap um einen bestimmten Punkt/Winkel rotieren **
+**                                                                       **
+**                                                                       **
+***************************************************************************
+**                                                                       **
+**   Parameter :  A0.L :  Zeiger auf struct ByteMap (Source)             **
+**                A1.L :  Zeiger auf struct ByteMap (Destination)        **
+**                D0.L :  Rotationsmittelpunkt X                         **
+**                D1.L :  Rotationsmittelpunkt Y                         **
+**                D2.L :  Sinus des Rotationswinkels <<10                **
+**                D3.L :  Cosinus des Rotationswinkels <<10              **
+**                                                                       **
+**   Resultat :   nix                                                    **
+**                                                                       **
+***************************************************************************
+
+* x2 = (x1-xm)*cos - (y1-ym)*sin +xm
+* y2 = (x1-xm)*sin + (y1-ym)*cos +ym
+
+@RotateByteMap:	movem.l	d0-d7/a0-a4,-(SP)
+
+		movem.l	13*4+4(SP),d2-d3
+
+		move.w	bym_Width(a0),d4	; D4 :  Breite in Pixel
+		move.w	bym_Height(a0),d5	; D5 :  Höhe in Pixel
+		movea.l	bym_Plane(a0),a0	; A0 :  Source-Plane
+		movea.l	bym_Plane(a1),a1	; A1 :  Destination-Plane
+		suba.l	a3,a3			; A3 :  Y-Zähler
+1$:		suba.l	a2,a2			; A2 :  X-Zähler
+
+2$:		move.w	a2,d6			; X
+		sub.w	d0,d6			; -Xm
+		muls.w	d3,d6			; *cos
+		move.w	a3,d7			; Y
+		sub.w	d1,d7			; -Ym
+		muls.w	d2,d7			; *sin
+		sub.l	d7,d6
+		asr.l	#5,d6			; Fixkomma to int
+		asr.l	#5,d6
+		add.l	d0,d6			; +Xm
+		bpl.b	4$
+3$:		clr.b	(a1)+
+		bra.b	5$
+4$:		cmp.w	d4,d6
+		bge.b	3$
+		move.l	d6,a4			; X2
+
+		move.w	a2,d6			; X
+		sub.w	d0,d6			; -Xm
+		muls.w	d2,d6			; *sin
+		move.w	a3,d7			; Y
+		sub.w	d1,d7			; -Ym
+		muls.w	d3,d7			; *cos
+		add.l	d7,d6
+		asr.l	#5,d6			; Fixkomma to int
+		asr.l	#5,d6
+		add.w	d1,d6			; +Ym gibt Y2
+		bmi.b	3$
+		cmp.w	d5,d6
+		bge.b	3$
+		muls.w	d4,d6			; * Breite
+		add.l	a4,d6			; + X2 gibt Offset
+
+		move.b	0(a0,d6.l),(a1)+	; Tada!
+5$:
+		addq.w	#1,a2			; INC X
+		cmp.w	d4,a2			; == width ?
+		blt.b	2$			; nope --->
+
+		addq.w	#1,a3			; INC Y
+		cmp.w	d5,a3			; == height ?
+		blt.b	1$			; nope --->
+
+		movem.l	(SP)+,d0-d7/a0-a4
+		rts
+
+
+***************************************************************************
+**                                                                       **
+**   ZoomByteMap  -  ByteMap um einen bestimmten Faktor zoomen           **
+**                                                                       **
+**                                                                       **
+***************************************************************************
+**                                                                       **
+**   Parameter :  A0.L :  Zeiger auf struct ByteMap (Source)             **
+**                A1.L :  Zeiger auf struct ByteMap (Destination)        **
+**                D0.L :  Zoomfaktor in Prozent                          **
+**                                                                       **
+**   Resultat :   nix                                                    **
+**                                                                       **
+***************************************************************************
+
+* x2 = (x1-xm)*f + xm
+* y2 = (y1-ym)*f + ym
+
+@ZoomByteMap:	movem.l	d0-d7/a0-a2,-(SP)
+		tst.l	d0
+		beq	.ZoomEnd
+		move.w	bym_Width(a1),d4	; D4 :  Breite in Pixel
+		move.w	bym_Height(a1),d5	; D5 :  Höhe in Pixel
+		movea.l	bym_Plane(a0),a0	; A0 :  Source-Plane
+		movea.l	bym_Plane(a1),a1	; A1 :  Destination-Plane
+		move.w	d4,d6
+		lsr.w	#1,d6			; D6 :  Mittelpunkt X
+		move.w	d5,d7
+		lsr.w	#1,d7			; D7 :  Mittelpunkt Y
+
+		moveq	#0,d2			; D2 :  Y-Zähler
+.YLoop:		moveq	#0,d3			; D3 :  X-Zähler
+
+.XLoop:		move.w	d3,d1			; X1
+		sub.w	d6,d1			; -xm
+		muls.w	#100,d1
+		divs.w	d0,d1			; * f
+		add.w	d6,d1			; +xm
+		bmi.b	.Next			; X < 0    ---> unsichtbar
+		cmp.w	d4,d1
+		bge.b	.Next			; X > xmax ---> unsichtbar
+		movea.w	d1,a2			; macht auch ext.l
+
+		move.w	d2,d1			; Y1
+		sub.w	d7,d1			; -ym
+		muls.w	#100,d1
+		divs.w	d0,d1			; * f
+		add.w	d7,d1			; +ym
+		bmi.b	.Next			; Y < 0    ---> unsichtbar
+		cmp.w	d5,d1
+		bge.b	.Next			; Y > xmax ---> unsichtbar
+		mulu.w	d4,d1			; mal Breite
+		add.l	a2,d1			; +X
+
+		move.b	0(a0,d1.l),(a1)		; Tada!
+.Next:		addq.l	#1,a1			; INC destination
+
+		addq.w	#1,d3			; INC X
+		cmp.w	d4,d3			; X == Width ?
+		blt.b	.XLoop			; noch nicht ---> Loop
+
+		addq.w	#1,d2			; INC Y
+		cmp.w	d5,d2			; Y == Height ?
+		blt.b	.YLoop			; noch nicht ---> Loop
+
+.ZoomEnd:	movem.l	(SP)+,d0-d7/a0-a2
+		rts
+
+
+***************************************************************************
+**                                                                       **
+**   ValidatePlanePointers  -  Letzten gültigen Plane-Pointer in alle    **
+**                             ungültigen Plane-Pointers kopieren        **
+**                                                                       **
+***************************************************************************
+**                                                                       **
+**   Parameter :  A2-A6:  Zeiger auf Bitplanes oder NULL wenn ungültig   **
+**                                                                       **
+**   Resultat :   A2-A6:  Zeiger auf BitPlanes, nirgends mehr NULL       **
+**                                                                       **
+***************************************************************************
+
+ValidatePlanePointers:
+		move.l	a3,d0		; Plane 1 gültig ?
+		bne.b	1$		; ja --->
+		movea.l	a2,a3		; Sonst Plane 0 übernehmen
+1$:
+		move.l	a4,d0		; Plane 2 gültig ?
+		bne.b	2$		; ja --->
+		movea.l	a3,a4		; Sonst Plane 0 übernehmen
+2$:
+		move.l	a5,d0		; Plane 3 gültig ?
+		bne.b	3$		; ja --->
+		movea.l	a4,a5		; Sonst Plane 0 übernehmen
+3$:
+		move.l	a6,d0		; Plane 4 gültig ?
+		bne.b	4$		; ja --->
+		movea.l	a5,a6		; Sonst Plane 0 übernehmen
+4$:
+		rts
+
+
+		END
diff --git a/ByteMap.h b/ByteMap.h
new file mode 100644
index 0000000..5f9cd62
--- /dev/null
+++ b/ByteMap.h
@@ -0,0 +1,13 @@
+/*
+**	In der 'ByteMap'-Struktur hat jeder Pixel ein Byte mit dem Farbwert.
+**	Änderungen müssen auch in ByteMap.S übernommen werden.
+*/
+
+struct ByteMap
+{
+	WORD Width;			/* Breite der ByteMap in Pixel */
+	WORD Height;		/* Höhe der ByteMap in Pixel */
+	LONG PlaneSize;		/* Grösse für Alloc/FreeMem der Plane */
+	APTR Plane;			/* Zeiger auf die aktuelle Datenplane */
+};
+
diff --git a/Color.c b/Color.c
new file mode 100644
index 0000000..ddc8ab9
--- /dev/null
+++ b/Color.c
@@ -0,0 +1,999 @@
+/*************************************************************************
+**                                                             			**
+**   R E Q U E S T C O L O R                  		  Copyright : -C5-	**
+**   -----------------------	                               			**
+**                                                             			**
+**   Der geniale Farbrequester     		                       			**
+**                                                             			**
+**   Created : 04-Mar-89 (-C5-)          Last Update: 16-Jul-89 (-C5-)	**
+**                                                             			**
+**************************************************************************
+**                                                             			**
+**   Format  : RequestColor(Screen)							   			**
+**                                                             			**
+*************************************************************************/
+
+
+#include <proto/intuition.h>
+#include <proto/graphics.h>
+#include <graphics/gfx.h>
+#include <proto/exec.h>
+#include <proto/dos.h>
+
+
+static void HandleEvent(APTR);
+static void HandleColor(APTR);
+static void CleanUp(void);
+static void Exchange(APTR);
+static void Spread(APTR);
+static void Default(APTR);
+static void SelectColor(APTR);
+static void EndColor(APTR);
+static void QuitColor(APTR);
+static void Undo(APTR);
+static void CopyColor(APTR);
+static void PrintRGB(UWORD, UWORD, UWORD);
+static void PrintXY(WORD, WORD, UWORD);
+static void DoBorder(UWORD);
+static void MakeBorder(void);
+
+static void DoBox(void);
+static void SetColor(UWORD);
+static void HelpKey(UWORD);
+
+APTR RequestColor(struct Screen *);
+
+#define CopyPtrHeight 20
+#define CopyPtrWidht 16
+#define CopyPtrMem CopyPtrHeight*4+4
+
+static struct Window *MyWindow;
+static struct Screen *MyScreen;
+static struct MsgPort *MyPort;
+static struct IntuiMessage *MyMsg;
+static struct RastPort *MyRapo;
+static struct ViewPort *MyViewPort;
+
+static UWORD *ctable;
+static UWORD actcol=1;
+static UWORD ColorBuf[32];
+static UWORD UndoBuf[32];
+static UWORD BorderX,BorderY;
+
+static UBYTE xstep,ystep;
+static BYTE endflag;
+static BYTE plane,numcols;
+static APTR PtrBase;
+
+static char rgb[] = " ";
+
+
+static SHORT BorderVectors1[] = {
+	0,0,
+	55,0,
+	55,14,
+	0,14,
+	0,0
+};
+static struct Border Border1 = {
+	-1,-1,
+	1,0,JAM1,
+	5,
+	BorderVectors1,
+	NULL
+};
+
+static struct IntuiText IText1 = {
+	1,0,JAM2,
+	3,3,
+	NULL,
+	"SPREAD",
+	NULL
+};
+
+static struct Gadget Gadget11 = {
+	NULL,
+	9,121,
+	54,13,
+	NULL,
+	RELVERIFY,
+	BOOLGADGET,
+	(APTR)&Border1,
+	NULL,
+	&IText1,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+static SHORT BorderVectors2[] = {
+	0,0,
+	73,0,
+	73,14,
+	0,14,
+	0,0
+};
+static struct Border Border2 = {
+	-1,-1,
+	1,0,JAM1,
+	5,
+	BorderVectors2,
+	NULL
+};
+
+static struct IntuiText IText2 = {
+	1,0,JAM2,
+	5,3,
+	NULL,
+	"EXCHANGE",
+	NULL
+};
+
+static struct Gadget Gadget10 = {
+	&Gadget11,
+	9,105,
+	72,13,
+	NULL,
+	RELVERIFY,
+	BOOLGADGET,
+	(APTR)&Border2,
+	NULL,
+	&IText2,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+static SHORT BorderVectors3[] = {
+	0,0,
+	43,0,
+	43,14,
+	0,14,
+	0,0
+};
+static struct Border Border3 = {
+	-1,-1,
+	1,0,JAM1,
+	5,
+	BorderVectors3,
+	NULL
+};
+
+static struct IntuiText IText3 = {
+	1,0,JAM2,
+	5,3,
+	NULL,
+	"COPY",
+	NULL
+};
+
+static struct Gadget Gadget9 = {
+	&Gadget10,
+	66,121,
+	42,13,
+	NULL,
+	RELVERIFY,
+	BOOLGADGET,
+	(APTR)&Border3,
+	NULL,
+	&IText3,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+static SHORT BorderVectors4[] = {
+	0,0,
+	42,0,
+	42,14,
+	0,14,
+	0,0
+};
+static struct Border Border4 = {
+	-1,-1,
+	1,0,JAM1,
+	5,
+	BorderVectors4,
+	NULL
+};
+
+static struct IntuiText IText4 = {
+	1,0,JAM2,
+	4,3,
+	NULL,
+	"UNDO",
+	NULL
+};
+
+static struct Gadget Gadget8 = {
+	&Gadget9,
+	111,121,
+	41,13,
+	NULL,
+	RELVERIFY,
+	BOOLGADGET,
+	(APTR)&Border4,
+	NULL,
+	&IText4,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+static SHORT BorderVectors5[] = {
+	0,0,
+	69,0,
+	69,14,
+	0,14,
+	0,0
+};
+static struct Border Border5 = {
+	-1,-1,
+	1,0,JAM1,
+	5,
+	BorderVectors5,
+	NULL
+};
+
+static struct IntuiText IText5 = {
+	1,0,JAM2,
+	6,3,
+	NULL,
+	"DEFAULT",
+	NULL
+};
+
+static struct Gadget Gadget7 = {
+	&Gadget8,
+	84,105,
+	68,13,
+	NULL,
+	RELVERIFY,
+	BOOLGADGET,
+	(APTR)&Border5,
+	NULL,
+	&IText5,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+static SHORT BorderVectors6[] = {
+	0,0,
+	66,0,
+	66,14,
+	0,14,
+	0,0
+};
+static struct Border Border6 = {
+	-1,-1,
+	1,0,JAM1,
+	5,
+	BorderVectors6,
+	NULL
+};
+
+static struct IntuiText IText6 = {
+	1,0,JAM2,
+	10,3,
+	NULL,
+	"CANCEL",
+	NULL
+};
+
+static struct Gadget Gadget6 = {
+	&Gadget7,
+	87,137,
+	65,13,
+	NULL,
+	RELVERIFY,
+	BOOLGADGET,
+	(APTR)&Border6,
+	NULL,
+	&IText6,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+static SHORT BorderVectors7[] = {
+	0,0,
+	47,0,
+	47,14,
+	0,14,
+	0,0
+};
+static struct Border Border7 = {
+	-1,-1,
+	1,0,JAM1,
+	5,
+	BorderVectors7,
+	NULL
+};
+
+static struct IntuiText IText7 = {
+	1,0,JAM2,
+	15,3,
+	NULL,
+	"OK",
+	NULL
+};
+
+static struct Gadget Gadget5 = {
+	&Gadget6,
+	9,137,
+	46,13,
+	NULL,
+	RELVERIFY,
+	BOOLGADGET,
+	(APTR)&Border7,
+	NULL,
+	&IText7,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+static SHORT BorderVectors8[] = {
+	0,0,
+	64,0,
+	64,64,
+	0,64,
+	0,1
+};
+static struct Border Border8 = {
+	-1,-1,
+	0,0,JAM1,
+	5,
+	BorderVectors8,
+	NULL
+};
+
+static struct Gadget SelGadget = {
+	&Gadget5,
+	88,24,
+	64,64,
+	GADGHBOX+GADGHIMAGE,
+	RELVERIFY,
+	BOOLGADGET,
+	(APTR)&Border8,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+static struct PropInfo BlueGadgetSInfo = {
+	AUTOKNOB+FREEVERT,
+	(UWORD)-1,0,
+	(UWORD)-1,4095,
+};
+
+static struct Image Image1 = {
+	0,0,
+	8,4,
+	0,
+	NULL,
+	0x0000,0x0000,
+	NULL
+};
+
+static struct Gadget BlueGadget = {
+	&SelGadget,
+	48,24,
+	16,64,
+	NULL,
+	RELVERIFY+GADGIMMEDIATE,
+	PROPGADGET,
+	(APTR)&Image1,
+	NULL,
+	NULL,
+	NULL,
+	(APTR)&BlueGadgetSInfo,
+	NULL,
+	NULL
+};
+
+static struct PropInfo GreenGadgetSInfo = {
+	AUTOKNOB+FREEVERT,
+	(UWORD)-1,0,
+	(UWORD)-1,4095,
+};
+
+static struct Image Image2 = {
+	0,0,
+	8,4,
+	0,
+	NULL,
+	0x0000,0x0000,
+	NULL
+};
+
+static struct Gadget GreenGadget = {
+	&BlueGadget,
+	30,24,
+	16,64,
+	NULL,
+	RELVERIFY+GADGIMMEDIATE,
+	PROPGADGET,
+	(APTR)&Image2,
+	NULL,
+	NULL,
+	NULL,
+	(APTR)&GreenGadgetSInfo,
+	NULL,
+	NULL
+};
+
+static struct PropInfo RedGadgetSInfo = {
+	AUTOKNOB+FREEVERT,
+	(UWORD)-1,0,
+	(UWORD)-1,4095,
+};
+
+static struct Image Image3 = {
+	0,0,
+	8,4,
+	0,
+	NULL,
+	0x0000,0x0000,
+	NULL
+};
+
+static struct Gadget RedGadget = {
+	&GreenGadget,
+	12,24,
+	16,64,
+	NULL,
+	RELVERIFY+GADGIMMEDIATE,
+	PROPGADGET,
+	(APTR)&Image3,
+	NULL,
+	NULL,
+	NULL,
+	(APTR)&RedGadgetSInfo,
+	NULL,
+	NULL
+};
+
+#define GadgetList1 RedGadget
+
+static struct IntuiText IText10 = {
+	1,0,JAM2,
+	52,14,
+	NULL,
+	"B",
+	NULL
+};
+
+static struct IntuiText IText9 = {
+	1,0,JAM2,
+	34,14,
+	NULL,
+	"G",
+	&IText10
+};
+
+static struct IntuiText IText8 = {
+	1,0,JAM2,
+	16,14,
+	NULL,
+	"R",
+	&IText9
+};
+
+#define IntuiTextList1 IText8
+
+static struct NewWindow NewWindowStructure1 = {
+	75,30,
+	161,160,
+	0,1,
+	REFRESHWINDOW+GADGETDOWN+GADGETUP+CLOSEWINDOW+RAWKEY,
+	WINDOWDRAG+WINDOWCLOSE+ACTIVATE+NOCAREREFRESH,
+	&RedGadget,
+	NULL,
+	"Edit Palette",
+	NULL,
+	NULL,
+	5,5,
+	(UWORD)-1,(UWORD)-1,
+	CUSTOMSCREEN
+};
+
+
+static void HandleEvent(object)
+APTR object;
+{
+  if (object == (APTR)&SelGadget) { SelectColor(object); return; }
+  if (object == (APTR)&Gadget5) { EndColor(object); return; }
+  if (object == (APTR)&Gadget6) { QuitColor(object); return; }
+  if (object == (APTR)&Gadget7) { Default(object); return; }
+  if (object == (APTR)&Gadget8) { Undo(object); return; }
+  if (object == (APTR)&Gadget9) { CopyColor(object); return; }
+  if (object == (APTR)&Gadget10) { Exchange(object); return; }
+  if (object == (APTR)&Gadget11) { Spread(object); return; }
+}
+
+/* end of PowerWindows source generation */
+
+
+static UWORD CopyPtr[] = {
+	0x0000,0x0000,
+	0x0000,0xFC00,
+	0x7C00,0xFE00,
+	0x7C00,0x8600,
+	0x7800,0x8C00,
+	0x7C00,0x8600,
+	0x6E00,0x9300,
+	0x0700,0x6980,
+	0x0380,0x04C0,
+	0x01C0,0x0260,
+	0x0080,0x0140,
+	0x0000,0x0080,
+	0x0000,0x0000,
+	0x3F1C,0xC060,
+	0x0C36,0x30C8,
+	0x0C63,0x318C,
+	0x0C63,0x318C,
+	0x0C63,0x318C,
+	0x0C36,0x30C8,
+	0x0C1C,0x3060,
+	0x0000,0x0000,
+};
+
+static void HelpKey(UWORD Key)
+{
+	if (Key==223)
+	{
+		LoadRGB4(MyViewPort,ColorBuf,2);
+		SetColor(actcol);
+	}
+}
+
+static void SaveUndo(void)
+{
+	register UWORD i;
+
+	for (i=0;i<numcols;i++)
+	{
+		UndoBuf[i]=ctable[i];
+	}
+}
+
+static void PrintXY(x,y,z)
+WORD x,y;
+UWORD z;
+{
+	if (z>9) {z+=7;}
+	rgb[0]=z+48;
+	Move(MyRapo,x,y);
+	Text(MyRapo,(char *)&rgb,1);
+}
+
+static void PrintRGB(r,g,b)
+UWORD r,g,b;
+{
+	SetAPen(MyRapo,1);
+	PrintXY((WORD)(RedGadget.LeftEdge+5),98,r);
+	PrintXY((WORD)(GreenGadget.LeftEdge+5),98,g);
+	PrintXY((WORD)(BlueGadget.LeftEdge+5),98,b);
+}
+
+static void HandleColor(APTR obj)
+{
+	register UWORD r,g,b;
+
+	SaveUndo();
+	for(;;)
+	{
+		r = 0xF-(RedGadgetSInfo.VertPot>>12);
+		g = 0xF-(GreenGadgetSInfo.VertPot>>12);
+		b = 0xF-(BlueGadgetSInfo.VertPot>>12);
+
+		SetRGB4(MyViewPort,actcol,r,g,b);
+
+		PrintRGB(r,g,b);
+
+		WaitTOF();
+		MyMsg = (struct IntuiMessage *)GetMsg(MyPort);
+		if (MyMsg->Class==GADGETUP)
+		{
+			ReplyMsg((struct IntuiMessage *)MyMsg);
+			break;
+		}
+
+		if (MyMsg)
+		{
+			ReplyMsg((struct IntuiMessage *)MyMsg);
+		}
+	}
+}
+
+static void SelectColor(APTR obj)
+{
+	actcol = ReadPixel(MyRapo,MyWindow->MouseX,MyWindow->MouseY);
+	SetColor(actcol);
+}
+
+static void Undo(APTR nix)
+{
+	register UWORD i,temp;
+
+	for (i=0;i<numcols;i++)
+	{
+		temp=UndoBuf[i];
+		UndoBuf[i]=ctable[i];
+		ctable[i]=temp;
+	}
+	LoadRGB4(MyViewPort,ctable,numcols);
+	SetColor(actcol);
+}
+
+static void CopyColor(APTR nix)
+{
+	register UWORD oldcol;
+
+	SaveUndo();
+	SetPointer(MyWindow,(UWORD *)PtrBase,CopyPtrHeight,CopyPtrWidht,0,0);
+
+	for (;;)
+	{
+		WaitPort(MyPort);
+		MyMsg = (struct IntuiMessage *)GetMsg(MyPort);
+		if (MyMsg->Class==GADGETUP)
+		{
+			if (MyMsg->IAddress==(APTR)&SelGadget)
+			{
+				oldcol=actcol;
+				actcol=ReadPixel(MyRapo,MyWindow->MouseX,MyWindow->MouseY);
+				ctable[actcol]=ctable[oldcol];
+				LoadRGB4(MyViewPort,ctable,numcols);
+				SetColor(actcol);
+				break;
+			}
+			else
+			{
+				break;
+			}
+		}
+		ReplyMsg((struct IntuiMessage *)MyMsg);
+	}
+	ClearPointer(MyWindow);
+}
+
+static void Exchange(APTR nix)
+{
+	register UWORD oldcol,old;
+
+	SaveUndo();
+	SetPointer(MyWindow,(UWORD *)PtrBase,CopyPtrHeight,CopyPtrWidht,0,0);
+
+	for (;;)
+	{
+		WaitPort(MyPort);
+		MyMsg = (struct IntuiMessage *)GetMsg(MyPort);
+		if (MyMsg->Class==GADGETUP)
+		{
+			if (MyMsg->IAddress==(APTR)&SelGadget)
+			{
+				oldcol=actcol;
+				actcol=ReadPixel(MyRapo,MyWindow->MouseX,MyWindow->MouseY);
+
+				old=ctable[actcol];
+				ctable[actcol]=ctable[oldcol];
+				ctable[oldcol]=old;
+
+				LoadRGB4(MyViewPort,ctable,numcols);
+				SetColor(actcol);
+				break;
+			}
+			else
+			{
+				break;
+			}
+		}
+		ReplyMsg((struct IntuiMessage *)MyMsg);
+	}
+	ClearPointer(MyWindow);
+}
+
+static void Spread(APTR nix)
+{
+	register UWORD old,new,newcol,i,temp;
+	register WORD oldr,oldg,oldb,newr,newg,newb,diff,diffr,diffg,diffb;
+
+	SaveUndo();
+	SetPointer(MyWindow,(UWORD *)PtrBase,CopyPtrHeight,CopyPtrWidht,0,0);
+
+	old=ctable[actcol];
+
+	for (;;)
+	{
+		WaitPort(MyPort);
+		MyMsg = (struct IntuiMessage *)GetMsg(MyPort);
+		if (MyMsg->Class==GADGETUP)
+		{
+			if (MyMsg->IAddress==(APTR)&SelGadget)
+			{
+				newcol=ReadPixel(MyRapo,MyWindow->MouseX,MyWindow->MouseY);
+				new=ctable[newcol];
+
+				LoadRGB4(MyViewPort,ctable,numcols);
+				SetColor(newcol);
+				break;
+			}
+			else
+			{
+				newcol=actcol;
+				new=old;
+				break;
+			}
+		}
+		ReplyMsg((struct IntuiMessage *)MyMsg);
+	}
+	ClearPointer(MyWindow);
+
+	if (actcol>newcol)
+	{
+		temp=newcol;
+		newcol=actcol;
+		actcol=temp;
+	
+		temp=new;
+		new=old;
+		old=temp;
+	}
+
+	oldr=(UWORD)((old>>8)&0xF)*(UWORD)0x100;
+	oldg=(UWORD)((old>>4)&0xF)*(UWORD)0x100;
+	oldb=(UWORD)(old&0xF)*(UWORD)0x100;
+
+	newr=(UWORD)((new>>8)&0xF)*(UWORD)0x100;
+	newg=(UWORD)((new>>4)&0xF)*(UWORD)0x100;
+	newb=(UWORD)(new&0xF)*(UWORD)0x100;
+
+	diff=(newcol-actcol);
+	if (diff)
+	{
+		diffr=(WORD)(oldr-newr)/(WORD)diff;
+		diffg=(WORD)(oldg-newg)/(WORD)diff;
+		diffb=(WORD)(oldb-newb)/(WORD)diff;
+
+		for (i=actcol+1;i<newcol;i++)
+		{
+			oldr=(oldr-diffr);
+			oldg=(oldg-diffg);
+			oldb=(oldb-diffb);
+
+			if(oldr<0) {oldr=0;}
+			if(oldg<0) {oldg=0;}
+			if(oldb<0) {oldb=0;}
+
+			ctable[i]=(oldr&0xF00)+((oldg/256)<<4)+(oldb/256);
+		}
+	}
+	actcol=newcol;
+	LoadRGB4(MyViewPort,ctable,numcols);
+}
+
+static void MakeBorder(void)
+{
+	Move(MyRapo,BorderX,BorderY);
+	Draw(MyRapo,BorderX+xstep,BorderY);
+	Draw(MyRapo,BorderX+xstep,BorderY+ystep);
+	Draw(MyRapo,BorderX,BorderY+ystep);
+	Draw(MyRapo,BorderX,BorderY);
+}
+
+static void DoBorder(UWORD color)
+{
+	register UWORD y;
+
+	SetAPen(MyRapo,0);
+	MakeBorder();
+
+	y=(ULONG)64/(UWORD)ystep;
+	BorderX=(color/y);
+	BorderY=(color-(BorderX*y));	
+	BorderX=(SelGadget.LeftEdge-1)+(UWORD)BorderX*(UWORD)xstep;
+	BorderY=(SelGadget.TopEdge-1)+(UWORD)BorderY*(UWORD)ystep;
+
+	SetAPen(MyRapo,1);
+	MakeBorder();	
+}
+
+static void SetColor(UWORD col)
+{
+	register UWORD r,g,b;
+
+	r=g=b=ctable[col];
+	r=(r>>8)&0xF;
+	g=(g>>4)&0xF;
+	b=(b&15);
+
+	PrintRGB(r,g,b);
+	DoBorder(col);
+
+	r=(UWORD)(0xF-r)*(UWORD)0x1111;
+	g=(UWORD)(0xF-g)*(UWORD)0x1111;
+	b=(UWORD)(0xF-b)*(UWORD)0x1111;
+
+	RedGadgetSInfo.VertPot=r;
+	GreenGadgetSInfo.VertPot=g;
+	BlueGadgetSInfo.VertPot=b;
+	RefreshGList(&RedGadget,MyWindow,0L,3L);
+}
+
+static void StoreColors(void)
+{
+	register UWORD i;
+
+	for (i=0;i<numcols;i++)
+	{
+		ColorBuf[i]=ctable[i];
+	}
+}
+
+static void ReStoreColors(void)
+{
+	LoadRGB4(MyViewPort,ColorBuf,numcols);
+}
+
+static void EndColor(APTR nix)
+{
+	CleanUp();
+}
+
+static void QuitColor(APTR nix)
+{
+	ReStoreColors();
+	CleanUp();
+}
+
+static void Default(APTR obj)
+{
+	SaveUndo();
+	ReStoreColors();
+	SetColor(actcol);
+}
+
+static void CleanUp()
+{
+	NewWindowStructure1.LeftEdge = MyWindow->LeftEdge;
+	NewWindowStructure1.TopEdge  = MyWindow->TopEdge;
+	CloseWindow(MyWindow);
+	endflag=TRUE;
+}
+
+static void DoBox()
+{
+	UWORD col=0;
+	register UBYTE x,y,xpos,ypos;
+
+	if (plane==1) {xstep=64; ystep=32;}
+	if (plane==2) {xstep=32; ystep=32;}
+	if (plane==3) {xstep=32; ystep=16;}
+	if (plane==4) {xstep=16; ystep=16;}
+	if (plane==5) {xstep=16; ystep=8;}
+
+	xpos=SelGadget.LeftEdge;
+	ypos=SelGadget.TopEdge;
+
+	for (x=0;x<64;x+=xstep)
+	{
+		for (y=0;y<64;y+=ystep)
+		{
+			SetAPen(MyRapo,col);
+			RectFill(MyRapo,x+xpos,y+ypos,x+xpos+xstep-2,y+ypos+ystep-2);		
+			col=col+1;
+		}
+	}
+}
+
+APTR RequestColor(struct Screen *scr)
+{
+	if (scr)
+	{
+		register ULONG class; 
+		register UWORD code;
+		register APTR address;
+
+		if (PtrBase=AllocMem(CopyPtrMem,2))
+		{
+			CopyMem((char *)&CopyPtr,(char *)PtrBase,CopyPtrMem);
+
+			BorderX=SelGadget.LeftEdge-1;
+			BorderY=SelGadget.TopEdge-1;
+			endflag = 0;
+			NewWindowStructure1.Screen = scr;
+
+			NewWindowStructure1.Type = (scr->Flags)&0x000F;
+
+			if (MyWindow = OpenWindow(&NewWindowStructure1))
+
+			{
+				MyPort     = MyWindow->UserPort;
+				MyRapo     = MyWindow->RPort;
+				MyViewPort = &(scr->ViewPort);
+				ctable     = (UWORD *)MyViewPort->ColorMap->ColorTable;
+				plane      = MyRapo->BitMap->Depth; if(plane>5) plane=5;
+				numcols    = 1<<plane;
+	
+				DoBox();
+				PrintIText(MyRapo,&IntuiTextList1,0L,0L);
+	
+				StoreColors();
+				SaveUndo();
+				SetColor(1);
+	
+				do
+				{
+					WaitPort(MyPort);
+					MyMsg	= (struct IntuiMessage *)GetMsg(MyPort);
+		
+					class	= MyMsg->Class;
+					code	= MyMsg->Code;
+					address = MyMsg->IAddress;
+	
+					ReplyMsg((struct IntuiMessage *)MyMsg);
+
+					switch(class)
+					{
+						case RAWKEY:
+							HelpKey(code);
+							break;
+	
+						case GADGETDOWN:
+							HandleColor(address);
+							break;
+		
+						case GADGETUP:
+							HandleEvent(address);
+							break;
+	
+						case CLOSEWINDOW:
+							ReStoreColors();
+							CleanUp();
+	
+						default:
+							break;
+					}
+				}
+				while (!endflag);
+			}
+			FreeMem(PtrBase,CopyPtrMem);
+			return((APTR) MyViewPort->ColorMap->ColorTable);
+		}
+	}
+}
+
+/*
+void __stdargs _main(char *argline)
+{
+	register APTR dummy;
+	register WORD depth;
+
+	IntuitionBase = OpenLibrary("intuition.library",0L);
+	GfxBase       = OpenLibrary("graphics.library",0L);
+
+	for (depth=1;depth<6;depth++)
+	{
+		NewScreenStructure.Depth=depth;
+		MyScreen      = OpenScreen(&NewScreenStructure);
+		dummy=RequestColor(MyScreen);
+		CloseScreen(MyScreen);
+	}
+
+	CloseLibrary(IntuitionBase);
+	CloseLibrary(GfxBase);
+}
+*/
diff --git a/ConvertDate.S b/ConvertDate.S
new file mode 100644
index 0000000..bd0353a
--- /dev/null
+++ b/ConvertDate.S
@@ -0,0 +1,130 @@
+**************************************************************************
+**                                                                      **
+**   ConvertDate  -  DateStamp in Klartext umwandeln (wie CLI's DATE)   **
+**                   Beispiel: "Wednesday 24-Dec-1986 06:15:42"         **
+**                                                                      **
+**   Created: 14-Mar-89 CHW                    Last update: 25-Jun-89   **
+**                                                                      **
+**************************************************************************
+**                                                                      **
+**   Parameter :  A0.L :  Zeiger auf struct DateStamp                   **
+**                A1.L :  Zeiger auf Ausgabepuffer (min. 32 Bytes)      **
+**   Resultat  :  -                                                     **
+**                                                                      **
+**************************************************************************
+
+		IDNT	ConvertDate
+		SECTION	text,CODE
+
+		INCLUDE	"dos/dos.i"
+
+
+		XREF	_sprintf
+
+		XDEF	@ConvertDate
+
+
+@ConvertDate:	movem.l	d1-d4/a0-a2,-(SP)
+
+	; Tag berechnen
+
+		move.l	(a0),d2			; D2 :  Tag
+		move.l	d2,d0			; Tag
+		addq.l	#1,d2			; ist halt so ...
+		moveq.l	#0,d3			; D3 :  Monat
+		move.l	#1978,d4		; D4 :  Jahr
+
+		divu	#7,d0
+		swap	d0			; Tag MOD 7
+		mulu	#10,d0			; Index in Tabelle
+		lea	DayName(PC),a2
+		adda.w	d0,a2
+1$:		move.b	(a2)+,(a1)+		; Wochentag ausgeben
+		bne.b	1$
+		move.b	#' ',-1(a1)
+
+2$:		lea	MonthTab(PC),a2
+3$:		moveq.l	#0,d1
+		move.b	(a2)+,d1		; Anzahl Tage im nächsten Monat
+		bne.s	4$
+		addq.l	#1,d4			; INC Jahr
+		moveq.l	#0,d3			; Monat resetten
+		bra.s	2$			; ---> nochmal
+4$:
+		cmpi.b	#28,d1			; Februar ?
+		bne.s	5$			; nein --->
+		moveq.l	#3,d0
+		and.l	d4,d0			; Schaltjahr ?
+		bne.s	5$			; nein --->
+		addq.l	#1,d1			; sonst INC Monatstage
+5$:
+		cmp.l	d1,d2			; Mehr Tage als dieser Mt ?
+		ble.s	6$			; nein --->
+		sub.l	d1,d2
+		addq.l	#1,d3			; INC Monat
+		bra.s	3$			; ---> loop
+6$:
+		move.l	d2,d0			; Tag
+		bsr	out2			; %02d ausgeben
+		move.b	#'-',(a1)+
+
+		lsl.w	#2,d3			; *4 für Index
+		lea	MonthName(PC,d3.w),a2
+7$:		move.b	(a2)+,(a1)+		; Monatsname ausgeben
+		bne.b	7$
+		move.b	#'-',-1(a1)
+
+		move.l	d4,d0			; Jahr
+		divu	#100,d0
+		swap.w	d0			; modulo 100
+		bsr	out2			; %02d ausgeben
+		move.b	#' ',(a1)+
+
+	; Uhrzeit berechnen
+
+		move.l	ds_Minute(a0),d0	; D0 :  Stunden
+		divu	#60,d0
+		move.l	d0,d1
+		swap	d1			; D1 :  Minuten
+
+		bsr	out2			; Stunden ausgeben
+		move.b	#':',(a1)+
+		move.w	d1,d0
+		bsr	out2			; Minuten ausgeben
+		move.b	#':',(a1)+
+
+		move.l	ds_Tick(a0),d0
+		divu	#50,d0
+		bsr	out2			; Sekunden ausgebemn
+		clr.b	(a1)+			; String abschliessen
+
+end:		movem.l	(SP)+,d1-d4/a0-a2
+		rts
+
+	; D0 als 2-stellige Zahl ausgeben (00-59)
+
+out2:		ext.l	d0
+		divu	#10,d0
+		add.w	#'0',d0
+		move.b	d0,(a1)+		; Zehner
+		swap	d0
+		add.w	#'0',d0
+		move.b	d0,(a1)+		; Einer
+		rts
+
+
+MonthName:	dc.b	"Jan",0,"Feb",0,"Mar",0,"Apr",0
+		dc.b	"May",0,"Jun",0,"Jul",0,"Aug",0
+		dc.b	"Sep",0,"Oct",0,"Nov",0,"Dec",0
+
+DayName:	dc.b	"Sunday",0,0,0,0
+		dc.b	"Monday",0,0,0,0
+		dc.b	"Tuesday",0,0,0
+		dc.b	"Wednesday",0
+		dc.b	"Thursday",0,0
+		dc.b	"Friday",0,0,0,0
+		dc.b	"Saturday",0,0
+
+MonthTab:	dc.b	31,28,31,30,31,30,31,31,30,31,30,31,0
+
+		END
diff --git a/CreateRastPort.S b/CreateRastPort.S
new file mode 100644
index 0000000..32ef457
--- /dev/null
+++ b/CreateRastPort.S
@@ -0,0 +1,121 @@
+**************************************************************************
+**                                                                      **
+**   CreateRastPort  -  Erstellt & initialisiert RastPort mit BitMaps   **
+**                                                                      **
+*+   Created: 12-Aug-88 CHW/CHH            Last update: 25-Nov-89 CHW   +*
+*+                                                                      +*
+**************************************************************************
+**                                                                      **
+**   Parameter :  D0.W :  Depth                                         **
+**                D1.W :  Width in Pixel                                **
+**                D2.W :  Height in Pixel                               **
+**                                                                      **
+**   Resultat  :  D0.L :  Zeiger auf RastPort oder 0 if failed          **
+**                                                                      **
+**************************************************************************
+
+		IDNT	CreateRastPort
+		SECTION	text,CODE
+
+		INCLUDE	"exec/macros.i"
+		INCLUDE	"exec/memory.i"
+		INCLUDE	"exec/types.i"
+		INCLUDE	"graphics/gfx.i"
+		INCLUDE	"graphics/rastport.i"
+
+		XREF	_GfxBase
+
+		XDEF	@CreateRastPort,@DeleteRastPort
+
+
+@CreateRastPort:
+		movem.l	d1-d3/a0-a3/a5-a6,-(SP)
+		movem.l	d0-d2,-(SP)
+		moveq.l	#(rp_SIZEOF+bm_SIZEOF)/2,d0
+		add.l	d0,d0			; Optimierung...
+		moveq	#MEMF_CLEAR>>16,d1
+		swap	d1			; Lattice C lässt grüssen
+		movea.l	4.W,a6
+		JSRLIB	AllocMem
+		tst.l	d0
+		bne.s	1$
+		lea	12(SP),SP		; Pop D0-D2
+		bra.s	EndCreateRP		; No Mem --->
+1$:
+		movea.l	d0,a2			; A2: RastPort
+		lea	rp_SIZEOF(a2),a3	; A3: BitMap
+
+		movea.l	a2,a1			; Rastport
+		movea.l	_GfxBase,a6
+		JSRLIB	InitRastPort
+		move.l	a3,rp_BitMap(a2)	; BitMap in RastPort eintr.
+
+		movem.l	(SP)+,d0-d2		; Depth/Width/Height
+		movea.l	a3,a0			; BitMap
+		JSRLIB	InitBitMap
+
+		move.w	bm_BytesPerRow(a3),d2	; Breite in Bytes
+		mulu.w	bm_Rows(a3),d2		; D2 := Länge einer plane
+
+AllocPlanes:	lea	bm_Planes(a3),a5
+		moveq.l	#0,d3
+		move.b	bm_Depth(a3),d3		; Anzahl Planes
+		bra.s	2$			; für dbf
+1$:		move.l	d2,d0			; Amount
+		move.l	#MEMF_CHIP+MEMF_CLEAR,d1
+		movea.l	4.W,a6
+		JSRLIB	AllocMem
+		move.l	d0,(a5)+		; Plane eintragen
+		bne.s	2$			; OK --->
+
+		movea.l	a2,a0			; RastPort
+		bsr	@DeleteRastPort		; wieder freigeben
+		bra.s	EndCreateRP		; und raus (D0 ist noch 0)
+2$:
+		dbf	d3,1$			; ---> loop
+
+		move.l	a2,d0			; The RastPort
+EndCreateRP:
+		movem.l	(SP)+,d1-d3/a0-a3/a5-a6
+		rts
+
+
+**************************************************************************
+**                                                                      **
+**   DeleteRastPort  -  Mit CreateRastPort() erstellten rp freigeben    **
+**                                                                      **
+**   Parameter :  A0.L :  RastPort                                      **
+**                                                                      **
+**************************************************************************
+
+@DeleteRastPort:
+		movem.l	d0-d3/a0-a3/a5-a6,-(SP)
+		move.l	a0,d0
+		beq.s	EndDeleteRP
+		movea.l	a0,a2			; A2: RastPort
+		lea	rp_SIZEOF(a2),a3	; A3: BitMap
+
+		move.w	bm_BytesPerRow(a3),d2	; Breite in Bytes
+		mulu.w	bm_Rows(a3),d2		; D2 := Länge einer plane
+
+FreePlanes:	lea	bm_Planes(a3),a5
+		moveq.l	#0,d3
+		move.b	bm_Depth(a3),d3		; Anzahl Planes
+		bra.s	2$			; für dbf
+1$:		move.l	d2,d0			; Amount
+		move.l	(a5)+,d1		; Nächste Plane
+		beq.s	2$			; Null --->
+		movea.l	d1,a1
+		movea.l	4.W,a6
+		JSRLIB	FreeMem
+2$:		dbf	d3,1$			; ---> loop
+
+		movea.l	a2,a1			; RastPort & BitMap
+		moveq.l	#(rp_SIZEOF+bm_SIZEOF)/2,d0
+		add.l	d0,d0
+		JSRLIB	FreeMem
+EndDeleteRP:
+		movem.l	(SP)+,d0-d3/a0-a3/a5-a6
+		rts
+
+		END
diff --git a/FileRequest.c b/FileRequest.c
new file mode 100644
index 0000000..b6c82fc
--- /dev/null
+++ b/FileRequest.c
@@ -0,0 +1,77 @@
+/****** FileRequest *********************************************************
+*
+*   NAME
+*       FileRequest -- Bring up an ASL file requester
+*
+*   SYNOPSIS
+*       name = FileRequest(title, postext, path, name)
+*
+*       STRPTR FileRequest(STRPTR, STRPTR, STRPTR, STRPTR);
+*
+*   FUNCTION
+*       Shows a file requester.
+*
+*   INPUTS
+*       title    - The window title
+*       postext  - Text of the left gadget
+*       path     - Buffer for the path. This will be modifierd.
+*       name     - Buffer for the name. This will be modifierd.
+*
+*   RESULTS
+*       pathname - Pathname of the selected file, or NULL if cancel.
+*
+*   SEE ALSO
+*       asl.library
+*
+****************************************************************************/
+
+#include <exec/execbase.h>
+#include <proto/dos.h>
+#include <dos/dosextens.h>
+#include <proto/asl.h>
+#include <libraries/asl.h>
+
+#include <string.h>
+
+
+extern struct TextAttr	MyScreenTextAttr;
+extern struct Screen	*mainscreen;
+
+
+STRPTR FileRequest(STRPTR wtitle, STRPTR postext, STRPTR drawer, STRPTR file)
+{
+	if (AslBase)
+	{
+		struct FileRequester	*f;
+		char					*filename=NULL;
+		static char				buf[256];
+
+		if (f = AllocAslRequestTags( ASL_FileRequest,
+			ASLFR_Screen,			mainscreen,
+			ASLFR_TextAttr,			&MyScreenTextAttr,
+			ASLFR_TitleText,		wtitle,
+			ASLFR_InitialFile,		file,
+
+			(drawer != NULL) ? ASLFR_InitialDrawer : ASLFR_DrawersOnly,
+			(drawer != NULL) ? drawer : (STRPTR)TRUE,
+			TAG_DONE
+		))
+		{
+			if (AslRequest(f, NULL))
+			{
+				strcpy(drawer, f->fr_Drawer);
+				strcpy(file,   f->fr_File);
+				strcpy(buf, drawer );
+				AddPart(buf, file, sizeof(buf));
+				filename = buf;
+			}
+
+			FreeAslRequest(f);
+		}
+
+		return filename;
+	}
+	else return "";
+}
+
+
diff --git a/GadgetSupport.S b/GadgetSupport.S
new file mode 100644
index 0000000..2d8b02b
--- /dev/null
+++ b/GadgetSupport.S
@@ -0,0 +1,123 @@
+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*
+*+                                                                       +*
+*+   GadgetSupport  -  Routinen zum De-/Selektieren v. BoolGadgets       +*
+*+                                                                       +*
+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*
+*+                                                                       +*
+*+   Modification History:                                               +*
+*+   --------------------                                                +*
+*+                                                                       +*
+*+   26-Oct-87  CHW  Created this file!                                  +*
+*+   25-Jun-89  CHW  Cleaned up for chlib                                +*
+*+   20-Jan-90  CHW  Window pointer may be 0                             +*
+*+   10-Sep-90  CHW  A6 wird jetzt auch gerettet, macht jetzt brav       +*
+*+                   RemoveGadget() und wieder AddGadget(), kann jetzt   +*
+*+                   auch GRELRIGHT und GRELHEIGHT                       +*
+*+                                                                       +*
+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*
+
+		IDNT	GadgetSupport
+		SECTION	text,CODE
+
+		INCLUDE	"exec/macros.i"
+		INCLUDE "intuition/intuition.i"
+
+		XREF	_GfxBase,_IntuitionBase
+
+		XDEF	@SelectGadget,@DeselectGadget
+
+
+GB_RELBOTTOM:	EQU	3	; Bit 3 im WORD
+GB_RELRIGHT:	EQU	4	; Bit 4 im WORD
+GB_SELECTED:	EQU	7	; Bit 7 im WORD
+
+
+
+**************************************************************************
+**                                                                      **
+**   SelectGadget  -  Boolean-Gadget selektieren & highlighten          **
+**                                                                      **
+**   Parameter :  A0.L :  Adresse der Window-Struktur oder 0            **
+**                A1.L :  Zeiger auf zu selektierendes Gadget           **
+**   Resultat  :  nix                                                   **
+**                                                                      **
+**************************************************************************
+
+@SelectGadget:
+		movem.l	d0-d4/a0-a3/a6,-(SP)	; muss so bleiben, siehe unten
+
+		movea.l	a0,a2			; A2 : Window
+		movea.l	a1,a3			; A3 : Gadget
+		bset.b	#GB_SELECTED,gg_Flags+1(a3)
+		bne	norefresh		; Gleicher wie vorher ---> fertig
+		bra.s	commoncont		; --->
+
+
+
+**************************************************************************
+**                                                                      **
+**   DeselectGadget  -  Boolean-Gadget deselektieren                    **
+**                                                                      **
+**   Parameter :  A0.L :  Adresse der Window-Struktur oder 0            **
+**                A1.L :  Zeiger auf zu deselektierendes Gadget         **
+**   Resultat  :  nix                                                   **
+**                                                                      **
+**************************************************************************
+
+@DeselectGadget:
+		movem.l	d0-d4/a0-a3/a6,-(SP)	; muss so bleiben
+
+		movea.l	a0,a2			; A2 : Window
+		movea.l	a1,a3			; A3 : Gadget
+		bclr.b	#GB_SELECTED,gg_Flags+1(a3)
+		beq.s	norefresh		; Gleicher wie vorher ---> fertig
+
+commoncont:	move.l	a2,d0			; Window
+		beq.s	norefresh		; Null ---> Kein Refresh
+		movea.l	_IntuitionBase,a6
+		JSRLIB	RemoveGadget
+		move.l	d0,d4			; D4 :  Gadget-Position
+
+		moveq.l	#0,d0			; Farbe 0
+		movea.l	wd_RPort(a2),a1		; Window's RastPort
+		movea.l	_GfxBase,a6
+		JSRLIB	SetAPen			; Farbe setzen
+		moveq.l	#RP_JAM2,d0
+		movea.l	wd_RPort(a2),a1		; Window's RastPort
+		JSRLIB	SetDrMd			; Modus setzen
+
+		movea.l	wd_RPort(a2),a1
+		movem.w	gg_LeftEdge(a3),d0-d3	; Alles auf einmal!
+
+		btst	#GB_RELRIGHT,gg_Flags+1(a3)
+		beq.s	1$
+		add.w	wd_Width(a2),d0		; Korrektur von GRELRIGHT
+		subq.w	#1,d0
+1$:
+		btst	#GB_RELBOTTOM,gg_Flags+1(a3)
+		beq.s	2$
+		add.w	wd_Height(a2),d1	; Korrektur von GRELBOTTOM
+		subq.w	#1,d1
+2$:
+		add.w	d0,d2			; Width ->  X2
+		add.w	d1,d3			; Height -> Y2
+		subq.w	#1,d2
+		subq.w	#1,d3
+		JSRLIB	RectFill		; Gadget löschen
+
+		move.l	d4,d0			; Gadget-Position
+		movea.l	a2,a0			; Window
+		movea.l	a3,a1			; Gadget
+		movea.l	_IntuitionBase,a6
+		JSRLIB	AddGadget
+
+		movea.l	a3,a0			; Gadget
+		movea.l	a2,a1			; Window
+		suba.l	a2,a2			; Requester
+		moveq.l	#1,d0			; nur dieses Gadget
+		JSRLIB	RefreshGList
+
+norefresh:	movem.l	(SP)+,d0-d4/a0-a3/a6
+		rts
+
+		END
diff --git a/Generate.c b/Generate.c
new file mode 100644
index 0000000..f1f6711
--- /dev/null
+++ b/Generate.c
@@ -0,0 +1,764 @@
+/*
+**  Bobi - The Ultimate Amiga Bob Manipulator
+**
+**  Generate.c - Assembler Source, Biärfile oder Objektmodul generieren
+**
+**  COPYRIGHT (C) 1989-1993 BY CHRISTIAN A. WEBER, ZUERICH, SWITZERLAND.
+**  ALL RIGHTS RESERVED. NO PART OF THIS SOFTWARE MAY BE COPIED, REPRODUCED,
+**  OR TRANSMITTED IN ANY FORM OR BY ANY MEANS, WITHOUT THE PRIOR WRITTEN
+**  PERMISSION OF THE AUTHOR. NO WARRANTY. USE AT YOUR OWN RISK.
+*/
+
+#include <proto/exec.h>
+#include <exec/memory.h>
+#include <proto/intuition.h>
+#include <proto/dos.h>
+
+#include <string.h>
+#include <stdarg.h>
+
+#include "HunkDefs.h"
+#include "GenerateWindow.h"
+
+#include "Bobi.h"
+#include "BobStructure.h"
+
+extern struct MyBob		*BobTable[];
+extern struct Screen	*mainscreen;
+extern WORD				numbobs;
+extern UWORD			mainpalette[];
+extern char				idstring[],outputname[],sectionname[],LabelGadgetSIBuff[];
+extern WORD				outputflags;
+extern char				arexxfilename[];
+extern BYTE				arexxflag;
+
+static BPTR file;
+static LONG filesize;
+
+
+/****************************************************************************
+**	Daten in File schreiben und filesize erhöhen
+*/
+
+static void MyWrite(void *adr,LONG len)
+{
+	Write(file,adr,len);
+	filesize += len;
+}
+
+
+/****************************************************************************
+**	C formatierter String auf ein File ausgeben, filesize erhöhen
+*/
+
+static void fputf(char *text,...)
+{
+	char buf[256];
+	va_list	args;
+
+	va_start(args,text);
+	vsprintf(buf,text,args);
+	MyWrite(buf,strlen(buf));
+	va_end(args);
+}
+
+
+/****************************************************************************
+**	Langwort in File schreiben
+*/
+
+static void fputl(LONG loy)
+{
+	 MyWrite(&loy,4);
+}
+
+
+/****************************************************************************
+**	Wort in File schreiben
+*/
+
+static void fputw(UWORD woy)
+{
+	MyWrite(&woy,2);
+}
+
+
+/****************************************************************************
+**	Symbolnamen mit Länge und Typ im Objektmodul-Format ausgeben
+*/
+
+static void fputsym(char *string,LONG type)
+{
+	LONG len;
+	char buf[200];
+
+	ClearMem(buf,200);
+	len = (strlen(string)+3)>>2; type |= len;
+	MyWrite(&type,4);
+	strcpy(buf,string);
+	MyWrite(buf,len<<2);
+}
+
+
+/****************************************************************************
+**	String mit Länge im Objektmodul-Format ausgeben
+*/
+
+static void fpuths(char *string)
+{
+	fputsym(string,0);
+}
+
+
+/****************************************************************************
+**	Bob-Maske berechnen mitels OR-Verknüpfung aller Planes
+*/
+
+static void CalculateMask(struct MyBob *bob)
+{
+	WORD *sptr,*dptr;
+	long i,j;
+
+	if(bob->Mask) FreeMem(bob->Mask,bob->PlaneSize);
+	if(bob->Mask=AllocMem(bob->PlaneSize,MEMF_CLEAR))
+	{
+		for(i=0; i<bob->Depth; i++)
+		{
+			sptr = (WORD *)bob->Planes[i];
+			dptr = (WORD *)bob->Mask;
+			for(j=bob->PlaneSize; j>0; j-=2) *(dptr++) |= *(sptr++);
+		}
+	}
+	else ShowMonoReq2("No memory to create bob mask!");
+}
+
+
+/****************************************************************************
+**	PlanePick und PlaneOnOff berechnen
+*/
+
+static void CalculatePlanePick(struct MyBob *bob)
+{
+	WORD *sptr,*dptr;
+	long i,j,x;
+
+	bob->PlanePick  = (1<<bob->Depth)-1;
+	bob->PlaneOnOff = 0;
+
+	for(i=0; i<bob->Depth; ++i)
+	{
+		sptr = (WORD *)bob->Planes[i];
+		for(j=bob->PlaneSize,x=0; j>0; j-=2) x |= *sptr++;
+		if(x)
+		{
+			sptr = (WORD *)bob->Planes[i];
+			dptr = (WORD *)bob->Mask;
+			for(j=bob->PlaneSize; j>0; j-=2)
+			{
+				if(*dptr++ != *sptr++) goto notequal;
+			}
+			bob->PlanePick  &= ~(1<<i);	/* Plane nicht generieren */
+			bob->PlaneOnOff |= (1<<i);	/* PlaneOnOffBit = 1 */
+		notequal: ;
+		}
+		else
+		{
+			bob->PlanePick &= ~(1<<i);	/* Plane nicht generieren */
+		}
+	}
+}
+
+
+/****************************************************************************
+** Totalen Speicherplatzbedarf eines Bobs berechnen
+*/
+
+static LONG TotBobSize(struct MyBob *bob)
+{
+	LONG x,size;
+
+	size = sizeof(struct BobData);
+	if(outputflags & OF_BOBMASK) size += bob->PlaneSize;
+	x = bob->PlanePick;
+	while(x)
+	{
+		if(x&1) size += bob->PlaneSize;
+		x>>=1;
+	}
+	return size;
+}
+
+
+/****************************************************************************
+**	Totalen Speicherplatzbedarf eines Sprites berechnen
+*/
+
+static LONG TotSpriteSize(struct MyBob *bob)
+{
+	LONG x,size;
+
+	size = sizeof(struct BobData);
+	for(x=0; x<bob->Width; x+=16)
+	{
+		size += 4*sizeof(LONG);		/* 2x 1 LONG Koords, 1 LONG Endmarkierung */
+		size += bob->Height*2*4;	/* 2 Sprites (attached) x 2 WORDs pro Zeile */
+	}
+	return size;
+}
+
+
+/****************************************************************************
+**	Ein Bob ins File schreiben
+*/
+
+static void RawDumpBob(struct MyBob *bob)
+{
+	struct BobData bd;
+	long i;
+
+	bd.Width      = bob->Width;
+	bd.Height     = bob->Height;
+	bd.X0         = bob->X0;
+	bd.Y0         = bob->Y0;
+	bd.CollX0     = bob->CollX0-bob->X0;
+	bd.CollY0     = bob->CollY0-bob->Y0;
+	bd.CollX1     = bob->CollX1-bob->X0;
+	bd.CollY1     = bob->CollY1-bob->Y0;
+	bd.PlanePick  = bob->PlanePick;
+	bd.PlaneOnOff = bob->PlaneOnOff;
+	bd.Flags      = bob->Flags & (~BOB_PRIVATEMASK);
+	bd.WordSize   = bob->BytesPerRow/2+1;
+	bd.PlaneSize  = bob->PlaneSize;
+	bd.TotalSize  = TotBobSize(bob);
+	MyWrite(&bd,sizeof(bd));
+
+	if(outputflags & OF_BOBMASK)
+	{
+		MyWrite(bob->Mask,bob->PlaneSize);
+	}
+
+	for(i=0; i<bob->Depth; ++i)
+	{
+		if(bob->PlanePick&(1<<i)) MyWrite(bob->Planes[i],bob->PlaneSize);
+	}
+}
+
+
+/****************************************************************************
+**	count Bytes ab ptr als Assembler Source ausgeben (DC.L/DC.W)
+*/
+
+static void AsmHexDump(ULONG *ptr, long count)
+{
+	long i,rest;
+
+	rest = count%4; count /= 4;
+
+	for(i=1; count>0; count--,++i)
+	{
+		if(i==1) fputf("\tDC.L\t$%08lx",*ptr++);
+		else     fputf(",$%08lx",*ptr++);
+
+		if((i==6) || (count==1))
+		{
+			fputf("\n"); i=0;
+		}
+	}
+	if(rest==2)	fputf("\tDC.W\t$%04lx\n",*(UWORD *)ptr);
+	fputf("\n");
+}
+
+
+/****************************************************************************
+**	Ein Bob als Assembler-Source ausgeben
+*/
+
+static void AsmDumpBob(struct MyBob *bob,WORD num)
+{
+	long i;
+
+	if(*(bob->SourceLabel))
+		fputf("\n\t*** Bob %ld :  Header & Mask\n\n%s:\n",num,bob->SourceLabel);
+	else
+		fputf("\n\t*** Bob %ld :  Header & Mask\n\n",num);
+
+	fputf("\tDC.W\t%ld,%ld,%ld,%ld,",bob->Width,bob->Height,bob->X0,bob->Y0);
+	fputf("%ld,%ld,%ld,%ld,",bob->CollX0-bob->X0,bob->CollY0-bob->Y0,
+		bob->CollX1-bob->X0,bob->CollY1-bob->Y0);
+	fputf("$%04lx,$%04lx,%ld,%ld,%ld\n",(bob->PlanePick<<8)+bob->PlaneOnOff,
+	      bob->Flags,bob->BytesPerRow/2+1,bob->PlaneSize,TotBobSize(bob));
+	if(outputflags&OF_BOBMASK)
+	{
+		AsmHexDump((ULONG *)bob->Mask,bob->PlaneSize);
+	}
+
+	fputf("\t*** Bob %ld :  %ld Planes\n\n",num,bob->Depth);
+	for(i=0; i<bob->Depth; ++i)
+	{
+		if(bob->PlanePick & (1<<i))
+			AsmHexDump((ULONG *)bob->Planes[i],bob->PlaneSize);
+		else
+			if(bob->PlaneOnOff & (1<<i))
+				fputf("\t; Plane %ld not generated (Plane is equal to mask)\n",i);
+			else
+				fputf("\t; Plane %ld not generated (Plane is empty)\n",i);
+	}
+}
+
+
+/****************************************************************************
+**	Ein Sprite als Assembler-Source ausgeben
+*/
+
+static void AsmDumpSprite(struct MyBob *bob,WORD num)
+{
+	long x,y;
+	UWORD w1,w2;
+
+	fputf("\n\t*** Sprite %ld : %ld Attached Hardware sprites\n\n%s:\n",
+		num,(bob->Width-1)/16+1,bob->SourceLabel);
+
+	fputf("\tDC.W\t%ld,%ld,%ld,%ld,",bob->Width,bob->Height,bob->X0,bob->Y0);
+	fputf("%ld,%ld,%ld,%ld,",bob->CollX0-bob->X0,bob->CollY0-bob->Y0,
+		bob->CollX1-bob->X0,bob->CollY1-bob->Y0);
+	fputf("$%04lx,$%04lx,%ld,%ld,%ld\n",(bob->PlanePick<<8)+bob->PlaneOnOff,
+	      bob->Flags,bob->BytesPerRow/2+1,bob->PlaneSize,TotSpriteSize(bob));
+
+	if(bob->Width>16)
+		fputf("\tDC.L\t%s.1,%s.2,%s.3,%s.4\n\n",bob->SourceLabel,
+			bob->SourceLabel,bob->SourceLabel,bob->SourceLabel);
+	else
+		fputf("\tDC.L\t%s.1,%s.2\n\n",bob->SourceLabel,bob->SourceLabel);
+
+	for(x=0; x < ((bob->Width-1)/16+1); ++x)
+	{
+		fputf("%s.%ld:\n",bob->SourceLabel,2*x+1);
+		fputf("\tDC.W\t$0000,$0000\t; Koordinaten\n");
+		for(y=0; y<bob->Height; ++y)
+		{
+			w1=*(UWORD *)(bob->Planes[0]+y*bob->BytesPerRow+2*x);
+			w2=*(UWORD *)(bob->Planes[1]+y*bob->BytesPerRow+2*x);
+			fputf("\tDC.W\t$%04lx,$%04lx\n",w1,w2);
+		}
+		fputf("\tDC.W\t$0000,$0000\t; End-Markierung\n\n\n");
+
+		fputf("%s.%ld:\n",bob->SourceLabel,2*x+2);
+		fputf("\tDC.W\t$0000,$0000\t; Koordinaten\n");
+		for(y=0; y<bob->Height; ++y)
+		{
+			w1=*(UWORD *)(bob->Planes[2]+y*bob->BytesPerRow+2*x);
+			w2=*(UWORD *)(bob->Planes[3]+y*bob->BytesPerRow+2*x);
+			fputf("\tDC.W\t$%04lx,$%04lx\n",w1,w2);
+		}
+		fputf("\tDC.W\t$0000,$0000\t; End-Markierung\n\n\n");
+	}
+}
+
+
+/****************************************************************************
+**	Assembler-Source generieren
+*/
+
+static void GenerateAssemblerSource(void)
+{
+	WORD i;
+	struct DateStamp date;
+	char datebuf[32];
+
+	if(file=Open(outputname,MODE_NEWFILE))
+	{
+		DateStamp(&date);
+		ConvertDate(&date,datebuf);
+		fputf("* Source generated on %s by %s\n\n\tSECTION\t%s,DATA_C\n\n",datebuf,idstring,sectionname);
+
+		if(outputflags & OF_COLORTABLE)
+		{
+			fputf("\tXDEF\tColorPalette\nColorPalette:\n");
+			AsmHexDump((ULONG *)mainpalette,2*32);
+		}
+
+		if(outputflags & OF_BOBDATA)
+		{
+			if(outputflags & OF_GENERATEBOBS)
+			{
+				fputf("* Bob structure:  WORD  Width, Height, X0, Y0, Collision X0/Y0/X1/Y1\n"
+				      "*                 BYTE  PlanePick, PlaneOnOff\n"
+				      "*                 WORD  Flags, WORDSize+1, PlaneSize, TotalSize\n\n");
+			}
+
+			for(i=0; i<numbobs; ++i)
+			{
+				if((i%4)==0) fputf("\tXDEF\t%s",BobTable[i]->SourceLabel);
+				else         fputf(",%s",BobTable[i]->SourceLabel);
+				if((i%4)==3) fputf("\n");
+			}
+			fputf("\n");
+
+			for(i=0; i<numbobs; ++i)
+			{
+				if(outputflags & OF_GENERATEBOBS)
+					 AsmDumpBob(BobTable[i],i);
+				else
+					 AsmDumpSprite(BobTable[i],i);
+			}
+		}
+
+		if(outputflags & OF_GENERATEBOBS)
+		{
+			fputf("\n\tDC.L\t-1\t; End of bob list\n\n");
+		}
+
+		fputf("\t; End of %s source generation.\n\n\tEND\n",idstring);
+		Close(file);
+	}
+	else ShowFileError(outputname);
+}
+
+
+/****************************************************************************
+**	Raw-Daten generieren
+*/
+
+static void GenerateRawData(void)
+{
+	WORD i;
+
+	if(file=Open(outputname,MODE_NEWFILE))
+	{
+		if(outputflags & OF_COLORTABLE) MyWrite(mainpalette,2*32);
+
+		if(outputflags & OF_BOBDATA)
+		{
+			for(i=0; i<numbobs; ++i) RawDumpBob(BobTable[i]);
+			fputl(-1);	/* Ende der Bob-Animation */
+		}
+		Close(file);
+	}
+	else ShowFileError(outputname);
+}
+
+
+/****************************************************************************
+**	Objekt-Modul generieren
+*/
+
+static void GenerateObjectModule(void)
+{
+	long datasize,offset=0;
+	WORD i;
+
+	for(i=0,datasize=4; i<numbobs; ++i) datasize += TotBobSize(BobTable[i]);
+	datasize+=3; datasize >>=2;
+
+	if(file=Open(outputname,MODE_NEWFILE))
+	{
+		filesize=0;
+		fputl(HUNK_UNIT); fpuths(idstring);
+
+		if(outputflags & OF_COLORTABLE)
+		{
+			fputl(HUNK_NAME); fpuths(sectionname);
+			fputl(HUNK_DATA); fputl(64>>2);
+			MyWrite(mainpalette,2*32);
+			fputl(HUNK_EXT);
+			fputsym("ColorPalette",EXT_DEF);
+			fputl(0);
+			fputl(0);
+			fputl(HUNK_END);
+		}
+
+		if(outputflags & OF_BOBDATA)
+		{
+			fputl(HUNK_NAME); fpuths(sectionname);
+			fputl(HUNK_DATA|HUNKF_CHIP); fputl(datasize);
+
+			for(i=0; i<numbobs; ++i) RawDumpBob(BobTable[i]);
+			fputl(-1);	/* Ende der Bob-Animation */
+			if(filesize&3) fputw(0x9876);	/* Pad to longword */
+			fputl(HUNK_EXT);
+			for(i=0; i<numbobs; ++i)
+			{
+				if(*(BobTable[i]->SourceLabel))	/* Nur Symbols mit Länge >0 */
+				{
+					fputsym(BobTable[i]->SourceLabel,EXT_DEF);
+					fputl(offset);
+				}
+				offset += TotBobSize(BobTable[i]);
+			}
+			fputl(0);
+			fputl(HUNK_END);
+		}
+		Close(file);
+	}
+	else ShowFileError(outputname);
+}
+
+
+/****************************************************************************
+**	Assembler-Include-File der Bob-Offsets generieren
+*/
+
+static void GenerateHeaderFile(void)
+{
+	char name[256],datebuf[32];
+	struct DateStamp date;
+	LONG len,offset=0;
+
+	if(!strnicmp(outputname,"/DISK/",6))
+		strcpy(name,outputname+6);		/* '/DISK/'-Anfang ignorieren */
+	else
+		strcpy(name,outputname);
+
+	len=strlen(name);
+	if(name[len-2]=='.') name[len-1]='i';
+	else
+	{
+		name[len]   = '.' ;
+		name[len+1] = 'i' ;
+		name[len+2] = '\0';
+	}
+
+	if(file=Open(name,MODE_NEWFILE))
+	{
+		DateStamp(&date);
+		ConvertDate(&date,datebuf);
+		fputf("* Header file generated on %s by %s\n",datebuf,idstring);
+
+		if(outputflags & OF_COLORTABLE) offset=2*32;
+		if(outputflags & OF_BOBDATA)
+		{
+			LONG i;
+			char sizelabel[100];
+
+			for(i=0; i<numbobs; ++i)
+			{
+				if(*(BobTable[i]->SourceLabel))	/* Nur Symbols mit Länge >0 */
+				{
+					char *sym=BobTable[i]->SourceLabel;
+					if(BobTable[i]->Flags & BODF_ANIMKEY) fputf("\n");
+					fputf("%s:",sym);
+					if(strlen(sym)<7)  Write(file,"\t",1);
+					if(strlen(sym)<15) Write(file,"\t",1);
+					else			   Write(file," ",1);
+					fputf("EQU\t%ld\n",offset);
+				}
+				offset += TotBobSize(BobTable[i]);
+			}
+			strcpy(sizelabel,LabelGadgetSIBuff);
+			if(!strnicmp(sizelabel+strlen(sizelabel)-3,"%ld",3))
+				sizelabel[strlen(sizelabel)-3]='\0';
+			fputf("\n%s_FILESIZE:\tEQU\t%ld\n",sizelabel,offset+4);
+		}
+		Close(file);
+	}
+	else ShowFileError(name);
+}
+
+
+/****************************************************************************
+**	outputflags neu berechnen aus den Gadget-Werten
+*/
+
+static void GetOutputFlags(void)
+{
+	outputflags = 0;
+
+	if(GenerateBobsGadget.Flags & SELECTED) outputflags |= OF_GENERATEBOBS;
+	else                                    outputflags |= OF_GENERATESPRITES;
+
+	if(AssemGadget.Flags & SELECTED)       outputflags |= OF_ASSEMBLER;
+	else if(ObjectGadget.Flags & SELECTED) outputflags |= OF_OBJECT;
+	else                                   outputflags |= OF_RAWDATA;
+
+	if(ColorGadget.Flags & SELECTED)   outputflags |= OF_COLORTABLE;
+	if(BobDataGadget.Flags & SELECTED) outputflags |= OF_BOBDATA;
+	if(MaskGadget.Flags & SELECTED)    outputflags |= OF_BOBMASK;
+}
+
+
+/****************************************************************************
+**	Gadget-Flags gemäss outputflags setzen
+*/
+
+static void SetOutputFlags(void)
+{
+	if(outputflags & OF_GENERATEBOBS)
+	{
+		GenerateBobsGadget.Flags |=  SELECTED;
+	}
+	else
+	{
+		GenerateBobsGadget.Flags &= ~SELECTED;
+	}
+
+	if(outputflags & OF_GENERATESPRITES)
+	{
+		GenerateSpritesGadget.Flags |=  SELECTED;
+		MaskGadget.Flags &= ~SELECTED;
+		MaskGadget.Flags |= GADGDISABLED;
+	}
+	else
+	{
+		GenerateSpritesGadget.Flags &= ~SELECTED;
+		MaskGadget.Flags |= SELECTED;
+		MaskGadget.Flags &= ~GADGDISABLED;
+	}
+
+
+	if(outputflags & OF_ASSEMBLER) AssemGadget.Flags |=  SELECTED;
+	else                           AssemGadget.Flags &= ~SELECTED;
+
+	if(outputflags & OF_OBJECT) ObjectGadget.Flags |=  SELECTED;
+	else                        ObjectGadget.Flags &= ~SELECTED;
+
+	if(outputflags & OF_RAWDATA)
+	{
+		RawDataGadget.Flags     |= SELECTED;
+		SectionNameGadget.Flags |= GADGDISABLED;
+	}
+	else
+	{
+		RawDataGadget.Flags     &= ~SELECTED;
+		SectionNameGadget.Flags &= ~GADGDISABLED;
+	}
+
+	if(outputflags & OF_COLORTABLE) ColorGadget.Flags |=  SELECTED;
+	else                            ColorGadget.Flags &= ~SELECTED;
+
+	if(outputflags & OF_BOBDATA) BobDataGadget.Flags |=  SELECTED;
+	else                         BobDataGadget.Flags &= ~SELECTED;
+
+	if(outputflags & OF_BOBMASK) MaskGadget.Flags |=  SELECTED;
+	else                         MaskGadget.Flags &= ~SELECTED;
+}
+
+
+/****************************************************************************
+**	Menuitem oder ARexx-Kommando: Generate code
+*/
+
+void GenerateCodeFunc()
+{
+	int flag;
+
+	LockWindows();
+
+	if(outputflags == 0)
+		outputflags = OF_RAWDATA | OF_OBJECT | OF_BOBDATA | OF_BOBMASK;
+
+	if(arexxflag)
+	{
+		strcpy(outputname,arexxfilename);
+		flag = 1;
+	}
+	else
+	{
+		struct Window		*w;
+		struct IntuiMessage	*msg;
+
+		NewWindowStructure1.Screen    = mainscreen;
+		FileNameGadgetSInfo.Buffer    = outputname;
+		SectionNameGadgetSInfo.Buffer = sectionname;
+
+		SetOutputFlags();
+
+		if(w=OpenWindow(&NewWindowStructure1))
+		{
+			PrintIText(w->RPort,&IntuiTextList1,0L,0L);
+			flag=0;
+			do
+			{
+				WaitPort(w->UserPort);
+				msg=(struct IntuiMessage *)GetMsg(w->UserPort);
+				if(msg->Class == CLOSEWINDOW)
+				{
+					flag = -1;
+				}
+				else if(msg->Class == GADGETUP)
+				{
+					if(msg->IAddress == (APTR)&OKGadget)
+					{
+							flag = 1;
+					}
+					else if(msg->IAddress == (APTR)&CancelGadget)
+					{
+							flag = -1;
+					}
+				}
+				else if(msg->Class == GADGETDOWN)
+				{
+					if(msg->IAddress == (APTR)&GenerateBobsGadget)
+					{
+						SelectGadget(w,&GenerateBobsGadget);
+						DeselectGadget(w,&GenerateSpritesGadget);
+						OnGadget(&MaskGadget,w,0);
+						OnGadget(&ObjectGadget,w,0);
+						OnGadget(&RawDataGadget,w,0);
+						SelectGadget(w,&MaskGadget);
+					}
+					else if(msg->IAddress == (APTR)&GenerateSpritesGadget)
+					{
+						SelectGadget(w,&GenerateSpritesGadget);
+						DeselectGadget(w,&GenerateBobsGadget);
+						DeselectGadget(w,&MaskGadget);
+						SelectGadget(w,&AssemGadget);
+						OffGadget(&MaskGadget,w,0);
+						OffGadget(&ObjectGadget,w,0);
+						OffGadget(&RawDataGadget,w,0);
+					}
+					else if(msg->IAddress == (APTR)&AssemGadget)
+					{
+						SelectGadget(w,&AssemGadget);
+						DeselectGadget(w,&ObjectGadget);
+						DeselectGadget(w,&RawDataGadget);
+						OnGadget(&SectionNameGadget,w,0);
+					}
+					else if(msg->IAddress == (APTR)&ObjectGadget)
+					{
+						DeselectGadget(w,&AssemGadget);
+						SelectGadget(w,&ObjectGadget);
+						DeselectGadget(w,&RawDataGadget);
+						OnGadget(&SectionNameGadget,w,0);
+					}
+					else if(msg->IAddress == (APTR)&RawDataGadget)
+					{
+						DeselectGadget(w,&AssemGadget);
+						DeselectGadget(w,&ObjectGadget);
+						SelectGadget(w,&RawDataGadget);
+						OffGadget(&SectionNameGadget,w,0);
+					}
+				}
+			} while(!flag);
+
+			CloseWindow(w);
+			GetOutputFlags();
+		}
+		else
+		{
+			ShowMonoReq2("Can't open window!");
+			goto error;
+		}
+	}		/* not ARexx */
+
+	if(flag>0)	/* Falls OK-Gadget angeklickt */
+	{
+		int i;
+
+		for(i=0; i<numbobs; ++i)
+		{
+			CalculateMask(BobTable[i]);
+			CalculatePlanePick(BobTable[i]);
+		}
+
+		if(outputflags & OF_ASSEMBLER)		GenerateAssemblerSource();
+		else if(outputflags & OF_OBJECT)	GenerateObjectModule();
+		else if(outputflags & OF_RAWDATA)	GenerateRawData();
+
+		if(outputflags & OF_RAWDATA)		GenerateHeaderFile();
+	}
+
+error:
+
+	UnLockWindows();
+}
+
diff --git a/GenerateWindow.h b/GenerateWindow.h
new file mode 100644
index 0000000..80cb9e8
--- /dev/null
+++ b/GenerateWindow.h
@@ -0,0 +1,651 @@
+
+static UBYTE UNDOBUFFER[80];
+
+static SHORT BorderVectors3[] = {
+	0,0,
+	67,0,
+	67,86,
+	0,86,
+	0,0
+};
+static struct Border Border3 = {
+	138,12,
+	3,0,JAM1,
+	5,
+	BorderVectors3,
+	NULL
+};
+
+static SHORT BorderVectors2[] = {
+	0,0,
+	61,0,
+	61,86,
+	0,86,
+	0,0
+};
+static struct Border Border2 = {
+	4,12,
+	3,0,JAM1,
+	5,
+	BorderVectors2,
+	&Border3
+};
+
+static SHORT BorderVectors1[] = {
+	0,0,
+	67,0,
+	67,86,
+	0,86,
+	0,0
+};
+static struct Border Border1 = {
+	68,12,
+	3,0,JAM1,
+	5,
+	BorderVectors1,
+	&Border2
+};
+
+static struct Gadget Gadget13 = {
+	NULL,
+	0,0,
+	1,1,
+	GADGHBOX+GADGHIMAGE,
+	NULL,
+	BOOLGADGET,
+	(APTR)&Border1,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+static SHORT BorderVectors4[] = {
+	0,0,
+	99,0,
+	99,14,
+	0,14,
+	0,0
+};
+static struct Border Border4 = {
+	-1,-1,
+	31,0,JAM1,
+	5,
+	BorderVectors4,
+	NULL
+};
+
+static struct IntuiText IText1 = {
+	1,0,JAM1,
+	26,3,
+	NULL,
+	"CANCEL",
+	NULL
+};
+
+static struct Gadget CancelGadget = {
+	&Gadget13,
+	-102,-16,
+	98,13,
+	GRELBOTTOM+GRELRIGHT,
+	RELVERIFY,
+	BOOLGADGET,
+	(APTR)&Border4,
+	NULL,
+	&IText1,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+static SHORT BorderVectors5[] = {
+	0,0,
+	99,0,
+	99,14,
+	0,14,
+	0,0
+};
+static struct Border Border5 = {
+	-1,-1,
+	31,0,JAM1,
+	5,
+	BorderVectors5,
+	NULL
+};
+
+static struct IntuiText IText2 = {
+	1,0,JAM1,
+	26,3,
+	NULL,
+	"Do it!",
+	NULL
+};
+
+static struct Gadget OKGadget = {
+	&CancelGadget,
+	5,-16,
+	98,13,
+	GRELBOTTOM,
+	RELVERIFY,
+	BOOLGADGET,
+	(APTR)&Border5,
+	NULL,
+	&IText2,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+static UBYTE FileNameGadgetSIBuff[80] =
+	"RAM:BobTest.o";
+static struct StringInfo FileNameGadgetSInfo = {
+	FileNameGadgetSIBuff,
+	UNDOBUFFER,
+	0,
+	80,
+	0,
+	0,0,0,0,0,
+	0,
+	0,
+	NULL
+};
+
+static SHORT BorderVectors6[] = {
+	0,0,
+	201,0,
+	201,20,
+	0,20,
+	0,1
+};
+static struct Border Border6 = {
+	-1,-11,
+	3,0,JAM1,
+	5,
+	BorderVectors6,
+	NULL
+};
+
+static struct Gadget FileNameGadget = {
+	&OKGadget,
+	5,135,
+	200,9,
+	SELECTED,
+	RELVERIFY,
+	STRGADGET,
+	(APTR)&Border6,
+	NULL,
+	NULL,
+	NULL,
+	(APTR)&FileNameGadgetSInfo,
+	NULL,
+	NULL
+};
+
+static UBYTE SectionNameGadgetSIBuff[80] =
+	"BobTestData";
+static struct StringInfo SectionNameGadgetSInfo = {
+	SectionNameGadgetSIBuff,
+	UNDOBUFFER,
+	0,
+	80,
+	0,
+	0,0,0,0,0,
+	0,
+	0,
+	NULL
+};
+
+static SHORT BorderVectors7[] = {
+	0,0,
+	201,0,
+	201,20,
+	0,20,
+	0,1
+};
+static struct Border Border7 = {
+	-1,-11,
+	3,0,JAM1,
+	5,
+	BorderVectors7,
+	NULL
+};
+
+static struct Gadget SectionNameGadget = {
+	&FileNameGadget,
+	5,112,
+	200,9,
+	NULL,
+	RELVERIFY,
+	STRGADGET,
+	(APTR)&Border7,
+	NULL,
+	NULL,
+	NULL,
+	(APTR)&SectionNameGadgetSInfo,
+	NULL,
+	NULL
+};
+
+static SHORT BorderVectors8[] = {
+	0,0,
+	57,0,
+	57,21,
+	0,21,
+	0,0
+};
+static struct Border Border8 = {
+	-1,-1,
+	1,0,JAM1,
+	5,
+	BorderVectors8,
+	NULL
+};
+
+static struct IntuiText IText4 = {
+	1,0,JAM1,
+	12,11,
+	NULL,
+	"Mask",
+	NULL
+};
+
+static struct IntuiText IText3 = {
+	1,0,JAM1,
+	16,2,
+	NULL,
+	"Bob",
+	&IText4
+};
+
+static struct Gadget MaskGadget = {
+	&SectionNameGadget,
+	144,75,
+	56,20,
+	NULL,
+	TOGGLESELECT,
+	BOOLGADGET,
+	(APTR)&Border8,
+	NULL,
+	&IText3,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+static SHORT BorderVectors9[] = {
+	0,0,
+	57,0,
+	57,21,
+	0,21,
+	0,0
+};
+static struct Border Border9 = {
+	-1,-1,
+	1,0,JAM1,
+	5,
+	BorderVectors9,
+	NULL
+};
+
+static struct IntuiText IText6 = {
+	1,0,JAM1,
+	12,11,
+	NULL,
+	"Data",
+	NULL
+};
+
+static struct IntuiText IText5 = {
+	1,0,JAM1,
+	16,2,
+	NULL,
+	"Bob",
+	&IText6
+};
+
+static struct Gadget BobDataGadget = {
+	&MaskGadget,
+	144,51,
+	56,20,
+	NULL,
+	TOGGLESELECT,
+	BOOLGADGET,
+	(APTR)&Border9,
+	NULL,
+	&IText5,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+static SHORT BorderVectors10[] = {
+	0,0,
+	57,0,
+	57,21,
+	0,21,
+	0,0
+};
+static struct Border Border10 = {
+	-1,-1,
+	1,0,JAM1,
+	5,
+	BorderVectors10,
+	NULL
+};
+
+static struct IntuiText IText8 = {
+	1,0,JAM1,
+	8,11,
+	NULL,
+	"Table",
+	NULL
+};
+
+static struct IntuiText IText7 = {
+	1,0,JAM1,
+	8,2,
+	NULL,
+	"Color",
+	&IText8
+};
+
+static struct Gadget ColorGadget = {
+	&BobDataGadget,
+	144,27,
+	56,20,
+	NULL,
+	TOGGLESELECT,
+	BOOLGADGET,
+	(APTR)&Border10,
+	NULL,
+	&IText7,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+static SHORT BorderVectors11[] = {
+	0,0,
+	57,0,
+	57,21,
+	0,21,
+	0,0
+};
+static struct Border Border11 = {
+	-1,-1,
+	1,0,JAM1,
+	5,
+	BorderVectors11,
+	NULL
+};
+
+static struct IntuiText IText10 = {
+	1,0,JAM1,
+	4,11,
+	NULL,
+	"Module",
+	NULL
+};
+
+static struct IntuiText IText9 = {
+	1,0,JAM1,
+	4,2,
+	NULL,
+	"Object",
+	&IText10
+};
+
+static struct Gadget ObjectGadget = {
+	&ColorGadget,
+	74,51,
+	56,20,
+	NULL,
+	GADGIMMEDIATE,
+	BOOLGADGET,
+	(APTR)&Border11,
+	NULL,
+	&IText9,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+static SHORT BorderVectors12[] = {
+	0,0,
+	57,0,
+	57,21,
+	0,21,
+	0,0
+};
+static struct Border Border12 = {
+	-1,-1,
+	1,0,JAM1,
+	5,
+	BorderVectors12,
+	NULL
+};
+
+static struct IntuiText IText12 = {
+	1,0,JAM1,
+	12,11,
+	NULL,
+	"Data",
+	NULL
+};
+
+static struct IntuiText IText11 = {
+	1,0,JAM1,
+	16,2,
+	NULL,
+	"Raw",
+	&IText12
+};
+
+static struct Gadget RawDataGadget = {
+	&ObjectGadget,
+	74,75,
+	56,20,
+	NULL,
+	GADGIMMEDIATE,
+	BOOLGADGET,
+	(APTR)&Border12,
+	NULL,
+	&IText11,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+static SHORT BorderVectors13[] = {
+	0,0,
+	57,0,
+	57,21,
+	0,21,
+	0,0
+};
+static struct Border Border13 = {
+	-1,-1,
+	1,0,JAM1,
+	5,
+	BorderVectors13,
+	NULL
+};
+
+static struct IntuiText IText14 = {
+	1,0,JAM1,
+	4,11,
+	NULL,
+	"Source",
+	NULL
+};
+
+static struct IntuiText IText13 = {
+	1,0,JAM1,
+	8,2,
+	NULL,
+	"Assem",
+	&IText14
+};
+
+static struct Gadget AssemGadget = {
+	&RawDataGadget,
+	74,27,
+	56,20,
+	NULL,
+	GADGIMMEDIATE,
+	BOOLGADGET,
+	(APTR)&Border13,
+	NULL,
+	&IText13,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+static SHORT BorderVectors14[] = {
+	0,0,
+	53,0,
+	53,33,
+	0,33,
+	0,0
+};
+static struct Border Border14 = {
+	-1,-1,
+	1,0,JAM1,
+	5,
+	BorderVectors14,
+	NULL
+};
+
+static struct IntuiText IText15 = {
+	1,0,JAM1,
+	2,12,
+	NULL,
+	"Sprite",
+	NULL
+};
+
+static struct Gadget GenerateSpritesGadget = {
+	&AssemGadget,
+	9,63,
+	52,32,
+	NULL,
+	GADGIMMEDIATE,
+	BOOLGADGET,
+	(APTR)&Border14,
+	NULL,
+	&IText15,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+static SHORT BorderVectors15[] = {
+	0,0,
+	53,0,
+	53,33,
+	0,33,
+	0,0
+};
+static struct Border Border15 = {
+	-1,-1,
+	1,0,JAM1,
+	5,
+	BorderVectors15,
+	NULL
+};
+
+static struct IntuiText IText16 = {
+	1,0,JAM1,
+	14,12,
+	NULL,
+	"Bob",
+	NULL
+};
+
+static struct Gadget GenerateBobsGadget = {
+	&GenerateSpritesGadget,
+	9,27,
+	52,32,
+	NULL,
+	GADGIMMEDIATE,
+	BOOLGADGET,
+	(APTR)&Border15,
+	NULL,
+	&IText16,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+#define GadgetList1 GenerateBobsGadget
+
+static struct IntuiText IText21 = {
+	3,0,JAM1,
+	83,15,
+	NULL,
+	"Mode:",
+	NULL
+};
+
+static struct IntuiText IText20 = {
+	3,0,JAM1,
+	53,104,
+	NULL,
+	"Section Name:",
+	&IText21
+};
+
+static struct IntuiText IText19 = {
+	3,0,JAM1,
+	141,15,
+	NULL,
+	"Options:",
+	&IText20
+};
+
+static struct IntuiText IText18 = {
+	3,0,JAM1,
+	16,15,
+	NULL,
+	"Type:",
+	&IText19
+};
+
+static struct IntuiText IText17 = {
+	3,0,JAM1,
+	69,127,
+	NULL,
+	"Filename:",
+	&IText18
+};
+
+#define IntuiTextList1 IText17
+
+static struct NewWindow NewWindowStructure1 = {
+	50,21,
+	210,165,
+	0,1,
+	GADGETDOWN+GADGETUP+CLOSEWINDOW,
+	WINDOWDRAG+WINDOWCLOSE+ACTIVATE+RMBTRAP+NOCAREREFRESH,
+	&GenerateBobsGadget,
+	NULL,
+	"     Generate Code      ",
+	NULL,
+	NULL,
+	5,5,
+	(UWORD)-1,(UWORD)-1,
+	CUSTOMSCREEN
+};
diff --git a/Get.c b/Get.c
new file mode 100644
index 0000000..d99ca13
--- /dev/null
+++ b/Get.c
@@ -0,0 +1,268 @@
+/*
+**  Bobi - The Ultimate Amiga Bob Manipulator
+**
+**  Get.c - Bob aus einem Bild ausschneiden
+**
+**  COPYRIGHT (C) 1989-1993 BY CHRISTIAN A. WEBER, ZUERICH, SWITZERLAND.
+**  ALL RIGHTS RESERVED. NO PART OF THIS SOFTWARE MAY BE COPIED, REPRODUCED,
+**  OR TRANSMITTED IN ANY FORM OR BY ANY MEANS, WITHOUT THE PRIOR WRITTEN
+**  PERMISSION OF THE AUTHOR. NO WARRANTY. USE AT YOUR OWN RISK.
+*/
+
+#include <proto/exec.h>
+#include <proto/graphics.h>
+#include <proto/intuition.h>
+#include <graphics/rastport.h>
+
+#include "Bobi.h"
+#include "BobStructure.h"
+
+extern struct MyBob		*BobTable[];
+extern struct Screen	*mainscreen,*picturescreen;
+extern struct Window	*mainwindow,*toolwindow,*picturewindow;
+extern WORD				numbobs,actbobnum;
+extern struct Gadget	AutoSizeGadget;
+extern char				LabelGadgetSIBuff[];
+
+static int x0,x1,y0,y1;
+
+/****************************************************************************
+**	Der Benutzer kann auf dem Picture-Screen ein Bob ausschneiden,
+**	die Koordinaten werden in x0/y0/x1/y1 gespeichert
+*/
+
+static BOOL CutBob(BOOL multiflag)
+{
+	struct IntuiMessage *msg;
+	BOOL looping=TRUE, okflag=FALSE;
+
+	x0 = -1;					/* Startwerte, gegen MultiCutNoMove-Bug */
+	x1 = picturewindow->MouseX;
+	y1 = picturewindow->MouseY;
+	DrawCross(picturescreen,x1,y1);
+
+	ScreenToFront(picturescreen);
+	ActivateWindow(picturewindow);
+	ModifyIDCMP(picturewindow,MOUSEMOVE+MOUSEBUTTONS);
+	do
+	{
+		WaitPort(picturewindow->UserPort);
+		while(msg = (struct IntuiMessage *)GetMsg(picturewindow->UserPort))
+		{
+			if(msg->Class == MOUSEBUTTONS)
+			{
+				switch(msg->Code)
+				{
+					case SELECTDOWN:
+						x0 = x1;
+						y0 = y1;
+						DrawCross(picturescreen,x0,y0);
+						break;
+
+					case SELECTUP:
+						okflag=TRUE;		/* hier kein break! */
+
+					default:
+						looping=FALSE;
+						break;
+				}
+				break;
+			}
+			else /* Muss MOUSEMOVE sein */
+			{
+				DrawCross(picturescreen,x1,y1);
+				x1 = msg->MouseX;
+				if(x1>=picturescreen->Width) x1=picturescreen->Width-1;
+				y1 = msg->MouseY;
+				if(x0>=0)
+				{
+		/*			if((x1-x0) > MAXBOBWIDTH) x1=x0+MAXBOBWIDTH;
+					if((x0-x1) > MAXBOBWIDTH) x1=x0-MAXBOBWIDTH;
+					if((y1-y0) > MAXBOBHEIGHT) y1=y0+MAXBOBHEIGHT;
+					if((y0-y1) > MAXBOBHEIGHT) y1=y0-MAXBOBHEIGHT;
+		*/		}
+				DrawCross(picturescreen,x1,y1);
+			}
+			ReplyMsg((struct Message *)msg);
+		}
+	} while(looping);
+
+	DrawCross(picturescreen,x1,y1);
+	DrawCross(picturescreen,x0,y0);
+	ModifyIDCMP(picturewindow,0);
+
+	if(!multiflag)	/* Falls nur 1 Bob zu cutten: mainscreen hervorbringen */
+	{
+		ScreenToFront(mainscreen);
+		ActivateWindow(toolwindow?toolwindow:mainwindow);
+	}
+
+	if(x0>x1) {	WORD dummy=x0; x0=x1; x1=dummy; }
+	if(y0>y1) {	WORD dummy=y0; y0=y1; y1=dummy; }
+
+	return okflag;
+}
+
+/****************************************************************************
+**	Bob an der gewünschten Stelle des Bildes ausschneiden
+*/
+
+BOOL GetBob(int x,int y,int w,int h)
+{
+	BOOL success = FALSE;
+
+	if(picturescreen == NULL) return FALSE;		/* Nix auszuschneiden! */
+
+	if(w<0)
+	{
+		x += w; w = -w;
+	}
+
+	if(h<0)
+	{
+		y += h; h = -h;
+	}
+
+	if(AutoSizeGadget.Flags & SELECTED)
+	{
+		int x1 = x+w-1, y1 = y+h-1;
+
+		while((x<x1) && (w>0))
+		{
+			int i;
+
+			for(i=y; i<y1; i++)
+			{
+				if(ReadPixel(&picturescreen->RastPort,x,i))
+					goto xlgot;
+			}
+			x++; w--;
+		}
+		xlgot:
+
+		while((y<y1) && (h>0))
+		{
+			int i;
+
+			for(i=x; i<x1; i++)
+			{
+				if(ReadPixel(&picturescreen->RastPort,i,y))
+					goto ylgot;
+			}
+			y++; h--;
+		}
+		ylgot:
+
+		while(w>0)
+		{
+			int i;
+
+			for(i=y; i<y1; i++)
+			{
+				if(ReadPixel(&picturescreen->RastPort,x1-1,i))
+					goto xhgot;
+			}
+			x1--; w--;
+		}
+		xhgot:
+
+		while(h>0)
+		{
+			int i;
+
+			for(i=x; i<x1; i++)
+			{
+				if(ReadPixel(&picturescreen->RastPort,i,y1-1))
+					goto yhgot;
+			}
+			y1--; h--;
+		}
+		yhgot: ;
+
+	}	/* if(autosize) */
+
+	if((w>0) && (h>0))
+	{
+		struct BitMap *tmpmap;
+
+		if(tmpmap=MakeBitMap(w,h,picturescreen->BitMap.Depth))
+		{
+			struct MyBob *bob;
+
+			BltBitMap(&(picturescreen->BitMap),x,y,tmpmap,0,0,w,h,0xc0,0xff,0);
+			if(bob=BitMapToBob(BobTable[actbobnum],tmpmap,w))
+			{
+				if(numbobs<MAXNUMBOBS)
+				{
+					if(BobTable[actbobnum])	/* Falls Bob existiert */
+					{
+						FreeBob(BobTable[actbobnum]);
+					}
+					else	/* Neues Bob an Tabellenende anhängen */
+					{
+						numbobs++;
+						sprintf(bob->SourceLabel,LabelGadgetSIBuff,actbobnum);
+						RefreshBobNum();	/* Prop-Gadget anpassen */
+					}
+					BobTable[actbobnum] = bob;
+					ShowBob(bob);
+					success = TRUE;
+				}
+				else ShowMonoReq2("Too many bobs!");
+			}
+			else ShowMonoReq2("Not enough memory for this bob");
+			MyFreeBitMap(tmpmap);
+		}
+		else ShowMonoReq2("Not enough memory for tmp BitMap");
+	}
+
+	return success;
+}
+
+/****************************************************************************
+**	Aus Bild ausschneiden und Bob generieren
+*/
+
+static BOOL GetOneBob(BOOL multiflag)
+{
+	if(picturescreen)
+	{
+		if(CutBob(multiflag))
+		{
+			return GetBob(x0,y0,x1-x0+1,y1-y0+1);
+		}
+		else			/* CutBob()==0: mit rechter Maustaste abgebrochen */
+		{
+			if(multiflag)
+			{
+				ScreenToFront(mainscreen);
+				ActivateWindow(toolwindow?toolwindow:mainwindow);
+			}
+			else ShowMonoReq2("Operation cancelled");
+		}
+	}
+	else ShowMonoReq2("No picture loaded, use 'Load IFF'");
+
+	return FALSE;
+}
+
+/****************************************************************************
+**	Ein Bob ausschneiden
+*/
+
+void GetBobFunc()
+{
+	GetOneBob(FALSE);
+}
+
+/****************************************************************************
+**	Mehrere Bobs ausschneiden
+*/
+
+void GetMultiFunc()
+{
+	while(GetOneBob(TRUE)) actbobnum++;
+	if(actbobnum>0) --actbobnum;
+	RefreshBobNum();
+}
+
diff --git a/HunkDefs.h b/HunkDefs.h
new file mode 100644
index 0000000..4fa2197
--- /dev/null
+++ b/HunkDefs.h
@@ -0,0 +1,27 @@
+#define HUNK_UNIT 999
+#define HUNK_NAME 1000
+#define HUNK_CODE 1001
+#define HUNK_DATA 1002
+#define HUNK_BSS 1003
+#define HUNK_RELOC32 1004
+#define HUNK_RELOC16 1005
+#define HUNK_RELOC8 1006
+#define HUNK_EXT 1007
+#define HUNK_SYMBOL 1008
+#define HUNK_DEBUG 1009
+#define HUNK_END 1010
+#define HUNK_HEADER 1011
+#define HUNK_OVERLAY 1013
+#define HUNK_BREAK 1014
+
+#define HUNKF_CHIP 0x40000000
+
+#define EXT_SYMB 0
+#define EXT_DEF 0x01000000
+#define EXT_ABS 0x02000000
+#define EXT_RES 0x03000000
+#define EXT_REF32 0x81000000
+#define EXT_COMMON 0x82000000
+#define EXT_REF16 0x83000000
+#define EXT_REF8 0x84000000
+
diff --git a/IFFAnim.c b/IFFAnim.c
new file mode 100644
index 0000000..8bb5e4d
--- /dev/null
+++ b/IFFAnim.c
@@ -0,0 +1,155 @@
+/*
+**  Bobi - The Ultimate Amiga Bob Manipulator
+**
+**  IFFAnim.c - Bobs aus einer IFF-Animation ausschneiden
+**
+**  COPYRIGHT (C) 1989-1993 BY CHRISTIAN A. WEBER, ZUERICH, SWITZERLAND.
+**  ALL RIGHTS RESERVED. NO PART OF THIS SOFTWARE MAY BE COPIED, REPRODUCED,
+**  OR TRANSMITTED IN ANY FORM OR BY ANY MEANS, WITHOUT THE PRIOR WRITTEN
+**  PERMISSION OF THE AUTHOR. NO WARRANTY. USE AT YOUR OWN RISK.
+*/
+
+#include <libraries/iff.h>
+#include <proto/exec.h>
+#include <proto/graphics.h>
+#include <proto/dos.h>
+#include <proto/intuition.h>
+
+#include "Bobi.h"
+#include "ByteMap.h"
+
+extern struct Screen *mainscreen;
+extern WORD actbobnum;
+
+static char AnimPath[128];
+static char AnimName[80];
+
+/****************************************************************************
+**	Ein Bob aus einer Animation ausschneiden
+*/
+
+static BOOL GetNextBob(struct BitMap *bim)
+{
+	struct ByteMap	*bym;
+	struct MyBob	*bob;
+	BOOL			success = FALSE;
+	WORD			width;
+
+	if(bym=MakeByteMap((WORD)(bim->BytesPerRow*8),bim->Rows))
+	{
+		BitMapToByteMap(bim,bym);
+		if(!AutoResizeByteMap(bym))
+		{
+			bym->Width=1; bym->Height=1;
+		}
+
+		if(bim=MakeBitMap(bym->Width,bym->Height,(WORD)bim->Depth))
+		{
+			ByteMapToBitMap(bym,bim);
+			width = bym->Width;
+			FreeByteMap(bym);
+			if(bob=BitMapToBob(0,bim,width))
+			{
+				InsertBob(bob,(WORD)(actbobnum++));
+				success = TRUE;
+			}
+			else ShowMonoReq2("Not enough memory to insert bob");
+			MyFreeBitMap(bim);
+		}
+		else
+		{
+			ShowMonoReq2("Not enough memory to insert bob");
+			FreeByteMap(bym);
+		}
+	}
+	else ShowMonoReq2("Not enough memory to insert bob");
+
+	return success;
+}
+
+/****************************************************************************
+**	IFF-Animation laden und ins Bobi-Format umwandeln
+*/
+
+void LoadIFFAnimFunc()
+{
+	ULONG				*ifffile,*formptr;
+	struct IFFL_BMHD	*bmhd;
+	LONG				count;
+	char				*path;
+	struct NewScreen	ns;
+	struct Screen		*s1, *s2=NULL;
+	UWORD				palette[128];
+
+	LockWindows();
+	if (path = FileRequest("Load IFF animation from Disk", "LOAD", AnimPath, AnimName))
+	{
+		if (ifffile = (ULONG *)IFFL_OpenIFF(path, IFFL_MODE_READ))
+		{
+			if(ifffile[2] == ID_ANIM)
+			{
+				formptr = ifffile+3;
+
+				if(bmhd = IFFL_GetBMHD(formptr))
+				{
+					ClearMem(&ns,sizeof(ns));
+					ns.Width  = (bmhd->w > 64) ? bmhd->w : 64;
+					ns.Height = (bmhd->h > 64) ? bmhd->h : 64;
+					ns.Depth  = (bmhd->nPlanes > 5) ? bmhd->nPlanes : 5;
+					ns.ViewModes  = IFFL_GetViewModes(formptr);
+					ns.Type   = CUSTOMSCREEN|SCREENQUIET|SCREENBEHIND;
+
+					if((s1 = OpenScreen(&ns)) && (s2 = OpenScreen(&ns)))
+					{
+						count = IFFL_GetColorTab(formptr,(WORD *)palette);
+						if(count>32) count = 32;
+						LoadRGB4(&s1->ViewPort,palette,count);
+						LoadRGB4(&s2->ViewPort,palette,count);
+
+						if(IFFL_DecodePic(formptr,&s1->BitMap))
+						{
+							ClearAll();
+							ScreenToFront(s1);
+							IFFL_DecodePic(formptr,&s2->BitMap);
+							formptr = IFFL_FindChunk(formptr,0L);	/* 1st DLTA */
+							if(GetNextBob(&s1->BitMap))
+							{
+								while(*formptr==ID_FORM)
+								{
+									LONG tmp;
+									if(!IFFL_ModifyFrame(formptr,&s2->BitMap))
+									{
+										ShowIFFError("Bad ANIM format");
+										break;
+									}
+									tmp=(LONG)s2; s2=s1; s1=(struct Screen *)tmp;
+									ScreenToFront(s1);
+									if(!GetNextBob(&(s1->BitMap))) break;
+									formptr=IFFL_FindChunk(formptr,0L);
+								}
+							}
+							ScreenToFront(mainscreen);
+						}
+						else ShowIFFError("Error decoding picture");
+					}
+					else ShowMonoReq2("Can't open anim screens");
+					if(s1) CloseScreen(s1);
+					if(s2) CloseScreen(s2);
+				}
+				else ShowIFFError("Mangled IFF ANIM");
+			}
+			else
+			{
+				char buf[150];
+				sprintf(buf,"'%s':\nNot an IFF ANIM file!",path);
+				ShowMonoReq2(buf);
+			}
+			IFFL_CloseIFF(ifffile);
+		}
+		else ShowIFFError(path);
+
+	}	/* if(FileRequest()) */
+
+	UnLockWindows();
+}
+
diff --git a/IFFError.c b/IFFError.c
new file mode 100644
index 0000000..e0146c2
--- /dev/null
+++ b/IFFError.c
@@ -0,0 +1,50 @@
+#include <libraries/iff.h>
+#include "Bobi.h"
+
+void ShowIFFError(char *text1)
+{
+	char	buf[250];
+	char	*text2;
+
+	switch(IFFL_IFFError())
+	{
+		case IFFL_ERROR_OPEN:			text2 = "Can't open file";
+										break;
+
+		case IFFL_ERROR_READ:			text2 = "Read error";
+										break;
+
+		case IFFL_ERROR_NOMEM:			text2 = "Not enough memory";
+										break;
+
+		case IFFL_ERROR_NOTIFF:			text2 = "Not an IFF file";
+										break;
+
+		case IFFL_ERROR_WRITE:			text2 = "Error writing file";
+										break;
+
+		case IFFL_ERROR_NOILBM:			text2 = "Not a picture";
+										break;
+
+		case IFFL_ERROR_NOBMHD:			text2 = "No BitMapHeader found";
+										break;
+
+		case IFFL_ERROR_NOBODY:			text2 = "No BODY chunk found";
+										break;
+
+		case IFFL_ERROR_BADCOMPRESSION:	text2 = "Unknown compression type";
+										break;
+
+		case IFFL_ERROR_NOANHD:			text2 = "No ANHD chunk found";
+										break;
+
+		case IFFL_ERROR_NODLTA:			text2 = "No DLTA chunk found";
+										break;
+
+		default:						text2 = "Unknown IFF error";
+										break;
+	}
+
+	sprintf(buf,"%s:\n%s!",text1,text2); ShowMonoReq2(buf);
+}
+
diff --git a/ImsgHandler.c b/ImsgHandler.c
new file mode 100644
index 0000000..285d344
--- /dev/null
+++ b/ImsgHandler.c
@@ -0,0 +1,263 @@
+#include <proto/exec.h>
+#include <proto/intuition.h>
+
+#include "Bobi.h"
+#include "BobStructure.h"
+
+extern struct MenuItem ToolWindowMenuItem,LayerModeMenuItem,
+						OrgGridMenuItem,BobBordersMenuItem,
+						CollisionRectMenuItem;
+extern struct Screen *mainscreen;
+extern struct MyBob *BobTable[];
+extern WORD options,mainx0,mainy0,actbobnum,numbobs;
+extern UWORD mainpalette[];
+extern struct Gadget PosPropGadget,AutoSizeGadget,AutoOrgGadget,AnimKeyGadget;
+
+/************************************************************************/
+
+void HandleImsg(struct IntuiMessage *imsg,struct Menu *menustrip)
+{
+	register struct MyBob *bob;
+	register ULONG class;
+	register UWORD code;
+	register WORD hitflags;
+
+	class = imsg->Class;
+	code  = imsg->Code;
+	bob   = BobTable[actbobnum];
+
+	switch(class)
+	{
+		case CLOSEWINDOW:
+			ToolWindowMenuItem.Flags &= ~CHECKED;
+			ToolWindowFunc();
+			break;
+
+		case MOUSEBUTTONS:
+			switch(code)
+			{
+			case SELECTDOWN:
+				if((options & GOF_LAYERMODE) && bob)
+				{
+					hitflags=BobHit(bob,imsg->MouseX,imsg->MouseY);
+					if(!hitflags) DragBobFunc();
+					else
+					{
+						if(hitflags&1) bob->Y0++;
+						if(hitflags&2) bob->Y0--;
+						if(hitflags&4) bob->X0++;
+						if(hitflags&8) bob->X0--;
+					}
+				}
+				break;
+
+			case MENUUP:
+				LoadPalette(mainpalette);
+				break;
+
+			default:
+				break;
+			}
+			break;
+
+		case GADGETDOWN:
+			if(imsg->IAddress == (APTR)&PosPropGadget)
+			{
+				MovePosFunc();
+			}
+			break;
+
+		case GADGETUP:
+			if(bob)
+			{
+				if(AutoSizeGadget.Flags & SELECTED)
+					bob->Flags |=  BOBF_AUTOSIZE;
+				else
+					bob->Flags &= ~BOBF_AUTOSIZE;
+
+				if(AutoOrgGadget.Flags & SELECTED)
+					bob->Flags |=  BOBF_AUTOORG;
+				else
+					bob->Flags &= ~BOBF_AUTOORG;
+
+				if(AnimKeyGadget.Flags & SELECTED)
+					bob->Flags |=  BODF_ANIMKEY;
+				else
+					bob->Flags &= ~BODF_ANIMKEY;
+			}
+
+			HandleEvent((APTR)imsg->IAddress);
+			break;
+
+		case MENUPICK:
+			LoadPalette(mainpalette);
+			if(code != MENUNULL)
+				HandleEvent((APTR)ItemAddress(menustrip,(LONG)code));
+			break;
+
+		case RAWKEY:
+#ifdef DEBUG
+			if(code&0x80)
+			{
+				printf("Rohe Taste losgelassen: $%02lx\n",code&0x7f);
+			}
+			else
+#endif
+			{
+				switch(code)
+				{
+					case 0x5f:			/* HELP */
+						AboutFunc();
+						break;
+
+					case 0x50:			/* F1 GetBob */
+						GetBobFunc();
+						break;
+
+					case 0x51:			/* F2 Get multiple bobs */
+						GetMultiFunc();
+						break;
+
+					case 0x52:			/* F3 SetOrg */
+						SetOrgFunc();
+						break;
+
+					case 0x53:			/* F4 Set CollisionBounds */
+						SetCollBoundsFunc();
+						break;
+
+					case 0x58:			/* F9 Insert New */
+						InsertNewBobFunc();
+						break;
+
+					case 0x59:			/* F10 DeleteBob */
+						DeleteActBobFunc();
+						break;
+
+					case 0x4c:			/* Cursor rauf: 1. Bob */
+						actbobnum=0;
+						RefreshBobNum();
+						break;
+
+					case 0x4d:			/* Cursor runter: letztes Bob */
+						actbobnum=numbobs;
+						RefreshBobNum();
+						break;
+
+					case 0x4e:			/* Cursor rechts: 1 Bob vor */
+						if(actbobnum<numbobs) actbobnum++;
+						RefreshBobNum();
+						break;
+
+					case 0x4f:			/* Cursor links: 1 Bob zurück */
+						if(actbobnum>0) actbobnum--;
+						RefreshBobNum();
+						break;
+
+					case 0x3e:			/* NumPad 8: Bob rauf schieben */
+						if(bob)
+							/* if((mainy0-bob->Y0) > MINY) */
+								bob->Y0++;
+						break;
+
+					case 0x1e:			/* NumPad 2: Bob runter */
+						if(bob)
+							/* if((mainy0+bob->Height-bob->Y0) < MAXY) */
+								bob->Y0--;
+						break;
+
+					case 0x2d:			/* NumPad 4: Bob links */
+						if(bob)
+							/* if((mainx0-bob->X0) > MINX) */
+								bob->X0++;
+						break;
+
+					case 0x2f:			/* NumPad 6: Bob rechts */
+						if(bob)
+							/* if((mainx0+bob->Width-bob->X0) < MAXX) */
+								bob->X0--;
+						break;
+
+					case 0x2e:		/* NumPad 5: Bob zentrieren gemäss Modus */
+						if(bob)
+						{
+							SetBobDefaultOrg(bob);
+						}
+						break;
+
+					case 0x40:			/* Space-Taste : Redraw screen */
+						Cleanup(FALSE);	
+						OpenMain();
+						LoadPalette(mainpalette);
+						break;
+
+					case 0x01:			/* Normale '1': SetFirstAnimBob */
+						SetFirstBobFunc();
+						break;
+
+					case 0x02:			/* Normale '2': SetLastAnimBob */
+						SetLastBobFunc();
+						break;
+
+					case 0x20:			/* 'A': Start Animation */
+						StartAnimFunc();
+						break;
+
+					case 0x11:			/* 'W': Tool Window on/off */
+						ToolWindowMenuItem.Flags ^= CHECKED;
+						ToolWindowFunc();
+						break;
+
+					case 0x35:			/* 'B': Bob Border on/off */
+						BobBordersMenuItem.Flags ^= CHECKED;
+						break;
+
+					case 0x33:			/* 'C': Collision Border on/off */
+						CollisionRectMenuItem.Flags ^= CHECKED;
+						break;
+
+					case 0x28:			/* 'L': Layer mode on/off */
+						LayerModeMenuItem.Flags ^= CHECKED;
+						break;
+
+					case 0x18:			/* 'O': Org Grid on/off */
+						OrgGridMenuItem.Flags ^= CHECKED;
+						break;
+
+					case 0x19:			/* 'P': Edit Palette */
+						EditPaletteFunc();
+						break;
+
+					case 0x13:			/* 'R': Rotate */
+						RotateFunc();
+						break;
+
+					case 0x32:			/* 'X': Flip X */
+						FlipXFunc();
+						break;
+
+					case 0x15:			/* 'Y' (on ASCII keyboards ONLY) */
+						FlipYFunc();
+						break;
+
+					case 0x31:			/* 'Z' (on ASCII keyboards ONLY) */
+						ZoomFunc();
+						break;
+
+					default:
+						/* DisplayBeep(mainscreen); */
+						/* printf("Rohe Taste gedrückt: $%02lx\n",code); */
+						break;
+				}
+			}
+			break;
+
+		default:
+		{
+			char buf[100];
+			sprintf(buf,"HandleImsg(): class=$%08lx, code=$%04lx",class,code);
+			ShowMonoReq2(buf);
+		}
+		break;
+	}
+}
diff --git a/Layer.c b/Layer.c
new file mode 100644
index 0000000..0e56e1c
--- /dev/null
+++ b/Layer.c
@@ -0,0 +1,289 @@
+#include <proto/exec.h>
+#include <proto/graphics.h>
+#include <proto/intuition.h>
+#include <graphics/rastport.h>
+
+#include "Bobi.h"
+#include "BobStructure.h"
+
+extern struct MyBob *BobTable[];
+extern struct Screen *mainscreen;
+extern struct Window *mainwindow,*toolwindow;
+extern struct RastPort *mainrastport;
+extern WORD numbobs,actbobnum,options,mainx0,mainy0;
+extern struct Gadget AutoSizeGadget;
+extern char LabelGadgetSIBuff[];
+extern struct MenuItem CollisionRectMenuItem;
+
+/************************************************************************/
+
+static void DrawBobCross(struct MyBob *bob,WORD x,WORD y)
+{
+	register struct RastPort *rp=mainrastport;
+	register WORD xl,yl;
+
+	xl = mainx0-bob->X0;
+	yl = mainy0-bob->Y0;
+
+	SetDrMd(rp,COMPLEMENT);
+	Move(rp,xl,y);
+	Draw(rp,xl+bob->Width-1,y);
+	Move(rp,x,yl);
+	Draw(rp,x,yl+bob->Height-1);
+}
+
+/************************************************************************/
+
+void SetOrgFunc()
+{
+	register struct MyBob *bob;
+	register struct IntuiMessage *msg;
+	register BOOL looping=TRUE;
+	register ULONG oldidcmp;
+	register WORD x,y;
+
+	if((numbobs>0) && (numbobs!=actbobnum))
+	{
+		bob = BobTable[actbobnum];
+		x = mainx0;
+		y = mainy0;
+		DrawBobCross(bob,x,y);
+		oldidcmp = mainwindow->IDCMPFlags;
+		mainwindow->Flags |= RMBTRAP;
+		ModifyIDCMP(mainwindow,MOUSEBUTTONS);
+		do
+		{
+			WaitTOF();
+			if(msg = (struct IntuiMessage *)GetMsg(mainwindow->UserPort))
+			{
+				switch(msg->Code)
+				{
+					case SELECTDOWN:
+						if(!BobHit(bob,msg->MouseX,msg->MouseY))
+						{
+							bob->X0 = x-mainx0+bob->X0;
+							bob->Y0 = y-mainy0+bob->Y0;
+						}
+												/* hier kein break! */
+					case MENUDOWN:
+						looping=FALSE;
+						break;
+				}
+			}
+			else if(!BobHit(bob,mainwindow->MouseX,mainwindow->MouseY))
+			{
+				DrawBobCross(bob,x,y);
+				x = mainwindow->MouseX;
+				y = mainwindow->MouseY;
+				DrawBobCross(bob,x,y);
+			}
+		} while(looping);
+
+		DrawBobCross(bob,x,y);
+		mainwindow->Flags &= ~RMBTRAP;
+		ModifyIDCMP(mainwindow,oldidcmp);
+	}
+	else ShowMonoReq2("Please select a bob first!");
+}
+
+/************************************************************************/
+
+void SetMainOrgFunc()
+{
+	register ULONG oldidcmp;
+	register WORD x,y;
+
+	x=mainx0; y=mainy0;
+	DrawCross(mainscreen,x,y);
+
+	oldidcmp = mainwindow->IDCMPFlags;
+	mainwindow->Flags |= RMBTRAP;
+	ModifyIDCMP(mainwindow,MOUSEBUTTONS);
+	DrawCross(mainscreen,mainx0,mainy0); /* Am alten Ort zur Orientierung */
+	for(;;)
+	{
+		register struct IntuiMessage *msg;
+
+		WaitTOF();
+		if(msg = (struct IntuiMessage *)GetMsg(mainwindow->UserPort))
+		{
+			DrawCross(mainscreen,mainx0,mainy0);
+			if(msg->Code==SELECTDOWN)
+			{
+				mainx0=x;	/* Werte nur übernehmen wenn linke Maustaste */
+				mainy0=y;
+			}
+			DrawCross(mainscreen,x,y);
+			ReplyMsg((struct Message *)msg);
+			break;
+		}
+		else
+		{
+			DrawCross(mainscreen,x,y);
+			x = mainwindow->MouseX;
+			y = mainwindow->MouseY;
+			DrawCross(mainscreen,x,y);
+		}
+	}
+	mainwindow->Flags &= ~RMBTRAP;
+	ModifyIDCMP(mainwindow,oldidcmp);
+}
+
+/************************************************************************/
+
+void DragBobFunc()
+{
+	WORD xold,yold,dx,dy;
+	register struct MyBob *bob;
+	register struct IntuiMessage *msg;
+	register struct BitMap *tmpmap;
+	register WORD x,y,xoff,yoff;
+	BOOL looping=TRUE;
+	LONG oldidcmp;
+
+	if((numbobs>0) && (numbobs!=actbobnum))
+	{
+		bob = BobTable[actbobnum];
+		if(tmpmap=MakeBitMap(bob->Width,bob->Height,bob->Depth))
+		{
+			CopyMem(bob->Planes[0],tmpmap->Planes[0],bob->PlaneSize*bob->Depth);
+
+			xoff = mainwindow->MouseX+bob->X0-mainx0;
+			yoff = mainwindow->MouseY+bob->Y0-mainy0;
+			x = xold = mainwindow->MouseX-xoff;
+			y = yold = mainwindow->MouseY-yoff;
+			oldidcmp = mainwindow->IDCMPFlags;
+			mainwindow->Flags |= RMBTRAP;
+			ModifyIDCMP(mainwindow,MOUSEBUTTONS);
+			DrawRect(mainrastport,(WORD)(x-1),(WORD)(y-1),(WORD)(x+bob->Width),
+				(WORD)(y+bob->Height),0);	/* Macht SetAPen,0 */
+			do
+			{
+				WaitTOF();
+				msg=(struct IntuiMessage *)GetMsg(mainwindow->UserPort);
+				if(toolwindow) if(!msg)
+					msg=(struct IntuiMessage *)GetMsg(toolwindow->UserPort);
+				if(msg)
+				{
+					switch(msg->Code)
+					{
+						case SELECTUP:
+							bob->X0 = mainx0-x;
+							bob->Y0 = mainy0-y;
+							looping=FALSE;
+							break;
+
+						case MENUDOWN:
+							RectFill(mainrastport,x-1,y-1,x+bob->Width,
+							   y+bob->Height);
+							looping=FALSE;
+							break;
+					}
+					ReplyMsg((struct Message *)msg);
+				}
+				else
+				{
+					xold=x; yold=y;
+					x = mainwindow->MouseX-xoff;
+					y = mainwindow->MouseY-yoff;
+		/*			if(x<MINX) x = MINX;
+					if(y<MINY) y = MINY;
+					if(x > MAXX-bob->Width)  x = MAXX-bob->Width;
+					if(y > MAXY-bob->Height) y = MAXY-bob->Height;
+		*/
+					dx = x-xold; dy = y-yold;
+
+					if(dx>0)
+						RectFill(mainrastport,xold-1,yold-1,x-1,yold+bob->Height);
+					else
+						RectFill(mainrastport,x+bob->Width,yold-1,xold+bob->Width,yold+bob->Height);
+
+					if(dy>0)
+						RectFill(mainrastport,xold-1,yold-1,xold+bob->Width,y);
+					else
+						RectFill(mainrastport,xold-1,y+bob->Height,xold+bob->Width,yold+bob->Height);
+
+					WaitTOF();
+					BltBitMapRastPort(tmpmap,0,0,mainrastport,x,y,
+					   bob->Width,bob->Height,0xc0);
+				}
+			} while(looping);
+			mainwindow->Flags &= ~RMBTRAP;
+			ModifyIDCMP(mainwindow,oldidcmp);
+			MyFreeBitMap(tmpmap);
+		}
+		else ShowMonoReq2("Not enough memory to move bob!");
+	}
+	else ShowMonoReq2("Internal Error 193 in Layer.c !");
+}
+
+/************************************************************************/
+
+void SetCollBoundsFunc()
+{
+	register struct MyBob *bob;
+	register struct IntuiMessage *msg;
+	register BOOL looping=TRUE;
+	register ULONG oldidcmp;
+	register WORD x,y;
+
+	if((numbobs>0) && (numbobs!=actbobnum))
+	{
+		CollisionRectMenuItem.Flags |= CHECKED;	/* Enable collision */
+		options |= GOF_COLLISIONRECT;
+
+		bob = BobTable[actbobnum];
+		x = mainx0-bob->X0+bob->CollX0;
+		y = mainy0-bob->Y0+bob->CollY0;
+		DrawCross(mainscreen,x,y);
+
+		oldidcmp = mainwindow->IDCMPFlags;
+		mainwindow->Flags |= RMBTRAP;
+		ModifyIDCMP(mainwindow,MOUSEBUTTONS);
+		do
+		{
+			WaitTOF();
+			if(msg = (struct IntuiMessage *)GetMsg(mainwindow->UserPort))
+			{
+				switch(msg->Code)
+				{
+				case SELECTDOWN:
+					/* if(!BobHit(bob,msg->MouseX,msg->MouseY)) */
+					{
+						DrawCross(mainscreen,x,y);
+						bob->CollX0 = x+bob->X0-mainx0;
+						bob->CollY0 = y+bob->Y0-mainy0;
+						ShowBob(bob);
+						x = mainx0-bob->X0+bob->CollX1;
+						y = mainy0-bob->Y0+bob->CollY1;
+						DrawCross(mainscreen,x,y);
+					}
+					break;
+
+				case SELECTUP:
+					/* if(!BobHit(bob,msg->MouseX,msg->MouseY)) */
+					{
+						DrawCross(mainscreen,x,y);
+						bob->CollX1 = x+bob->X0-mainx0;
+						bob->CollY1 = y+bob->Y0-mainy0;
+					}
+					looping=FALSE;
+					break;
+				}
+				ReplyMsg((struct Message *)msg);
+			}
+			else /* if(!BobHit(bob,mainwindow->MouseX,mainwindow->MouseY)) */
+			{
+				DrawCross(mainscreen,x,y);
+				x = mainwindow->MouseX;
+				y = mainwindow->MouseY;
+				DrawCross(mainscreen,x,y);
+			}
+		} while(looping);
+
+		mainwindow->Flags &= ~RMBTRAP;
+		ModifyIDCMP(mainwindow,oldidcmp);
+	}
+	else ShowMonoReq2("Please select a bob first!");
+}
+
diff --git a/LoadBobs.c b/LoadBobs.c
new file mode 100644
index 0000000..84c8848
--- /dev/null
+++ b/LoadBobs.c
@@ -0,0 +1,425 @@
+#include <exec/types.h>
+#include <exec/memory.h>
+#include <proto/exec.h>
+#include <proto/dos.h>
+#include <graphics/gfx.h>
+#include <string.h>
+
+#include "Bobi.h"
+#include "BobStructure.h"
+
+extern struct MyBob		*BobTable[];
+extern struct Screen	*mainscreen;
+
+extern WORD	options,numbobs,actbobnum,firstanimbob,lastanimbob,animflags;
+extern BYTE defaultorg;
+extern WORD	mainpalette[];
+extern char	idstring[],outputname[],sectionname[];
+extern WORD	outputflags,mainx0,mainy0;
+extern char	LabelGadgetSIBuff[];
+
+extern BYTE	arexxflag;
+extern char arexxfilename[];
+
+static char BobPath[128];		/* Load / Save Bobs */
+static char BobName[80];
+static char InsertPath[128];	/* Insert Bobs */
+static char InsertName[80];
+static char OPath[128];			/* Load / Save Offsets */
+static char OName[80];
+
+char PicPath[128];				/* Benötigt von Picture.c */
+char PicName[80];
+
+/****************************************************************************
+**	Konfigurations-File laden und auswerten
+*/
+
+void LoadConfigFile(char *name)
+{
+	char buf[500];
+	register BPTR file;
+
+	ClearMem(buf,sizeof(buf));
+
+	if(file=Open(name,MODE_OLDFILE))
+	{
+		register char *sptr,*dptr;
+
+		Read(file,buf,490);
+		Close(file);
+
+		sptr=buf;
+		dptr=BobPath; while((*dptr=*sptr++)>' ') dptr++; *dptr='\0';
+		dptr=PicPath; while((*dptr=*sptr++)>' ') dptr++; *dptr='\0';
+		strcpy(InsertPath,BobPath);
+	}
+}
+
+/****************************************************************************
+**	Ein Bob aus file laden
+*/
+
+static struct MyBob *LoadOneBob(register BPTR file,register WORD version)
+{
+	register struct MyBob *bob;
+	register long i;
+
+	if(bob=AllocMem(sizeof(struct MyBob),MEMF_CLEAR))
+	{
+		Read(file,bob,sizeof(*bob));
+		if(version<108)
+		{
+			char buf[66];
+			Seek(file,-8,OFFSET_CURRENT);	/* Antiskip Collsion Coords */
+			CopyMem(&bob->CollX0,buf,66);
+			CopyMem(buf,&bob->PlanePick,66);
+			bob->CollX0=bob->CollX1=bob->CollY0=bob->CollY1=0;
+		}
+
+		if(bob->Planes[0] = AllocMem(bob->PlaneSize*bob->Depth,0L))
+		{
+			for(i=1; i<bob->Depth; ++i)
+				bob->Planes[i] = bob->Planes[0]+i*bob->PlaneSize;
+			Read(file,bob->Planes[0],bob->PlaneSize*bob->Depth);
+
+			bob->Mask = 0;	/* jaja! */
+			return bob;
+		}
+		else
+		{
+			FreeMem(bob,sizeof(*bob));
+			ShowMonoReq2("Not enough memory for bob planes!");
+		}
+	}
+	else
+	{
+		ShowMonoReq2("Not enough memory for bob structure!");
+	}
+	return 0;
+}
+
+/****************************************************************************
+**	Bobs laden
+*/
+
+void LoadBobsFunc()
+{
+	LockWindows();
+	LoadBobs(arexxflag ? arexxfilename
+		: FileRequest("Load Bobs from Disk", "LOAD", BobPath, BobName));
+	UnLockWindows();
+}
+
+
+void LoadBobs(char *name)
+{
+	struct BobFileHeader bfh;
+	register struct MyBob *bob;
+	register BPTR file;
+	register long i;
+	char buf[64];
+
+	LockWindows();
+
+	if(name)
+	{
+		if(file=Open(name,MODE_OLDFILE))
+		{
+			Read(file,&bfh,sizeof(bfh));
+			if(bfh.Magic == BF_MAGIC)
+			{
+				if((bfh.Version>=106) && (bfh.Version<=BF_VERSION))
+				{
+					if(bfh.Version < 110)
+					{
+						ShowMonoReq2("Warning:\nThis is an old Bobi file.\n"
+								"MainOrg is not saved.");
+					}
+
+					if(bfh.Version < 109)
+					{
+						ShowMonoReq2("Warning:\nThis is a very old Bobi file.\n"
+								"AnimKey bobs are not marked.");
+					}
+
+					if(bfh.Version < 108)
+					{
+						ShowMonoReq2("Warning:\nThis is a very very old Bobi file.\n"
+								"Collision info is not set.");
+					}
+
+					if(bfh.Version < 107)
+					{
+						ShowMonoReq2("Warning:\nThis is a very very very old Bobi file!\n"
+								"Bob/Sprite flags and Collision info\n"
+								"may be wrong.");
+						bfh.OutputFlags |= OF_GENERATEBOBS;
+					}
+					ClearAll();
+
+					if(bfh.Version >= 110)
+					{
+						mainx0 = bfh.MainX0;
+						mainy0 = bfh.MainY0;
+					}
+
+					if(bfh.Version >= 111)
+					{
+						defaultorg = bfh.DefaultOrg;
+					}
+
+					CopyMem(bfh.ColorTable,mainpalette,2*32);
+					strcpy(outputname,bfh.OutputName);
+					strcpy(sectionname,bfh.SectionName);
+					SetGlobalOptions(bfh.GlobalOptions,defaultorg);
+					outputflags = bfh.OutputFlags;
+					strcpy(LabelGadgetSIBuff,bfh.DefaultLabel);
+					firstanimbob = bfh.FirstAnimBob;
+					lastanimbob  = bfh.LastAnimBob;
+					SetAnimSpeed(bfh.AnimSpeed);
+					SetAnimFlags(bfh.AnimFlags);
+
+					numbobs = bfh.NumBobs;
+					for(i=0; i<bfh.NumBobs; ++i)
+					{
+						if(bob=LoadOneBob(file,bfh.Version)) BobTable[i]=bob;
+						else
+						{
+							numbobs = i;
+							sprintf(buf,"%ld of %ld bobs loaded.",i,bfh.NumBobs);
+							ShowMonoReq2(buf);
+							break;
+						}
+					}
+					RefreshBobNum();
+				}
+				else if(bfh.Version > BF_VERSION)
+				{
+					ShowMonoReq2("You need a newer Bobi version\nto handle this file!");
+				}
+				else ShowMonoReq2("This is a mangled or\ntoo old Bobi file!");
+			}
+			else
+			{
+				sprintf(buf,"This is not a %s file !",idstring);
+				ShowMonoReq2(buf);
+			}
+			Close(file);
+		}
+		else ShowFileError(name);
+	}
+	UnLockWindows();
+}
+
+/****************************************************************************
+**	Bobs aus File an aktueller Position einfügen
+*/
+
+void InsertBobsFunc()
+{
+	struct BobFileHeader bfh;
+	register char *name;
+	register struct MyBob *bob;
+	register BPTR file;
+	register long i;
+	char buf[64];
+
+	LockWindows();
+
+	if(arexxflag)
+		name = arexxfilename;
+	else
+		name = FileRequest("Insert Bobs from Disk", "INSERT", InsertPath, InsertName);
+
+	if(name)
+	{
+		if(file=Open(name,MODE_OLDFILE))
+		{
+			Read(file,&bfh,sizeof(bfh));
+			if(bfh.Magic == BF_MAGIC)
+			{
+				if((bfh.Version>=106) && (bfh.Version<=BF_VERSION))
+				{
+					for(i=0; i<bfh.NumBobs; ++i)
+					{
+						if(bob=LoadOneBob(file,bfh.Version))
+						{
+							InsertBob(bob,(WORD)(actbobnum+i));
+						}
+						else
+						{
+							sprintf(buf,"%ld of %ld bobs inserted.",i,bfh.NumBobs);
+							ShowMonoReq2(buf);
+							break;
+						}
+					}
+					RefreshBobNum();
+				}
+				else if(bfh.Version > BF_VERSION)
+				{
+					ShowMonoReq2("You need a newer Bobi version\nto handle this file!");
+				}
+				else ShowMonoReq2("This is a mangled or\ntoo old Bobi file!");
+			}
+			else
+			{
+				sprintf(buf,"This is not a %s file !",idstring);
+				ShowMonoReq2(buf);
+			}
+			Close(file);
+		}
+		else ShowFileError(name);
+	}
+	UnLockWindows();
+}
+
+/****************************************************************************
+**	Bobs in eine Datei speichern
+*/
+
+void SaveBobsFunc()
+{
+	struct BobFileHeader bfh;
+	register char *name;
+	register BPTR file;
+	register long i;
+
+	ClearMem(&bfh,sizeof(bfh));
+	LockWindows();
+
+	if(arexxflag)
+		name = arexxfilename;
+	else
+		name = FileRequest("Save Bobs to Disk", "SAVE", BobPath, BobName);
+
+	if(name)
+	{
+		bfh.Magic         = BF_MAGIC;
+		bfh.Version       = BF_VERSION;
+		bfh.NumBobs       = numbobs;
+		bfh.OutputFlags   = outputflags;
+		bfh.FirstAnimBob  = firstanimbob;
+		bfh.LastAnimBob   = lastanimbob;
+		bfh.AnimSpeed     = GetAnimSpeed();
+		bfh.AnimFlags     = animflags;
+		bfh.DefaultOrg    = defaultorg;
+		bfh.GlobalOptions = options;
+		bfh.MainX0        = mainx0;
+		bfh.MainY0        = mainy0;
+
+		CopyMem(mainpalette,bfh.ColorTable,2*32);
+		strcpy(bfh.OutputName,outputname);
+		strcpy(bfh.SectionName,sectionname);
+		strcpy(bfh.DefaultLabel,LabelGadgetSIBuff);
+
+		if(file=OpenNewFileSafely(name))
+		{
+			Write(file,&bfh,sizeof(bfh));
+			for(i=0; i<numbobs; ++i)
+			{
+				Write(file,BobTable[i],sizeof(struct MyBob));
+				Write(file,BobTable[i]->Planes[0],BobTable[i]->PlaneSize*BobTable[i]->Depth);
+			}
+			Close(file);
+		}
+	}
+	UnLockWindows();
+}
+
+/****************************************************************************
+**	Eine Datei von der Disk löschen
+*/
+
+void DeleteFileFunc()
+{
+	register char *name;
+	char buf[160];
+
+	LockWindows();
+	if (name = FileRequest("Delete File on Disk", "DELETE", BobPath, BobName))
+	{
+		sprintf(buf,"Do you really want to delete the\nfile '%s' ?",name);
+		if(ShowRequest2(buf,"YEP!"))
+		{
+			if(DeleteFile(name))
+			{
+//				sprintf(buf,"%s%s.fd",BobPath,*BobPath?"/":"");
+//				DeleteFile(buf);
+			}
+			else ShowFileError(name);
+		}
+	}
+	UnLockWindows();
+}
+
+/****************************************************************************
+**	Bob-Offset-Tabelle von Disk laden
+*/
+
+void LoadOffsetsFunc()
+{
+	register char *name;
+	register BPTR file;
+	register long i;
+
+	LockWindows();
+	OPath[0] = OName[0] = '\0';
+
+	if(arexxflag)
+		name = arexxfilename;
+	else
+		name = FileRequest("Load Bob Offsets from Disk", "LOAD", OPath, OName);
+
+	if(name)
+	{
+		if(file=Open(name,MODE_OLDFILE))
+		{
+			for(i=0; i<numbobs; ++i)
+			{
+				Read(file,&BobTable[i]->X0,2);
+				Read(file,&BobTable[i]->Y0,2);
+			}
+			Close(file);
+		}
+		else ShowFileError(name);
+	}
+	UnLockWindows();
+}
+
+/****************************************************************************
+**	Bob-Offsets in Datei speichern
+*/
+
+void SaveOffsetsFunc()
+{
+	register char *name;
+	register BPTR file;
+	register long i;
+
+	LockWindows();
+	OPath[0] = OName[0] = '\0';
+
+	if(arexxflag)
+		name = arexxfilename;
+	else
+		name = FileRequest("Save Bob Offsets to Disk", "SAVE", OPath, OName);
+
+	if(name)
+	{
+		if(file=OpenNewFileSafely(name))
+		{
+			for(i=0; i<numbobs; ++i)
+			{
+				Write(file,&BobTable[i]->X0,2);
+				Write(file,&BobTable[i]->Y0,2);
+//				sprintf(buf,"\t\tDC.W\t%ld,%ld\t; %s\n",
+//					BobTable[i]->X0,BobTable[i]->Y0,BobTable[i]->SourceLabel);
+//				Write(file,buf,strlen(buf));
+			}
+			Close(file);
+		}
+	}
+	UnLockWindows();
+}
+
diff --git a/MainWindow.h b/MainWindow.h
new file mode 100644
index 0000000..4b72e64
--- /dev/null
+++ b/MainWindow.h
@@ -0,0 +1,2166 @@
+
+struct TextAttr TOPAZ80 = {
+	(STRPTR)"topaz.font",
+	TOPAZ_EIGHTY,0,0
+};
+struct NewScreen NewScreenStructure = {
+	0,0,
+	320,256,
+	6,
+	0,1,
+	EXTRA_HALFBRITE,
+	CUSTOMSCREEN,
+	&TOPAZ80,
+	NULL,
+	NULL,
+	NULL
+};
+
+#define NEWSCREENSTRUCTURE NewScreenStructure
+
+USHORT Palette[] = {
+	0x0000,
+	0x0ECA,
+	0x035D,
+	0x0AAA,
+	0x0D80,
+	0x0FE0,
+	0x08F0,
+	0x0444,
+	0x00B6,
+	0x00DD,
+	0x00AF,
+	0x007C,
+	0x000F,
+	0x070F,
+	0x0C0E,
+	0x0C08,
+	0x0620,
+	0x0E52,
+	0x0A52,
+	0x0FCA,
+	0x0333,
+	0x0444,
+	0x0555,
+	0x0666,
+	0x0777,
+	0x0888,
+	0x0999,
+	0x0AAA,
+	0x0CCC,
+	0x014A,
+	0x0B98,
+	0x0C00
+#define PaletteColorCount 32
+};
+
+#define PALETTE Palette
+
+UBYTE UNDOBUFFER[64];
+
+SHORT BorderVectors1[] = {
+	0,0,
+	25,0,
+	25,10,
+	0,10,
+	0,0
+};
+struct Border Border1 = {
+	-1,-1,
+	1,0,JAM1,
+	5,
+	BorderVectors1,
+	NULL
+};
+
+struct Gadget Gadget3 = {
+	NULL,
+	-24,12,
+	24,9,
+	GADGHBOX+GADGHIMAGE+GRELRIGHT,
+	NULL,
+	BOOLGADGET,
+	(APTR)&Border1,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+SHORT BorderVectors2[] = {
+	0,0,
+	25,0,
+	25,10,
+	0,10,
+	0,0
+};
+struct Border Border2 = {
+	-1,-1,
+	1,0,JAM1,
+	5,
+	BorderVectors2,
+	NULL
+};
+
+struct Gadget Gadget2 = {
+	&Gadget3,
+	-24,-9,
+	24,9,
+	GADGHBOX+GADGHIMAGE+GRELBOTTOM+GRELRIGHT,
+	NULL,
+	BOOLGADGET,
+	(APTR)&Border2,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+struct PropInfo PosPropGadgetSInfo = {
+	AUTOKNOB+FREEVERT+PROPBORDERLESS,
+	(UWORD)-1,(UWORD)-1,
+	(UWORD)-1,(UWORD)-1,
+};
+
+struct Image Image1 = {
+	0,0,
+	22,161,
+	0,
+	NULL,
+	0x0000,0x0000,
+	NULL
+};
+
+struct Gadget PosPropGadget = {
+	&Gadget2,
+	-23,25,
+	22,-39,
+	GRELRIGHT+GRELHEIGHT,
+	RELVERIFY+GADGIMMEDIATE,
+	PROPGADGET,
+	(APTR)&Image1,
+	NULL,
+	NULL,
+	NULL,
+	(APTR)&PosPropGadgetSInfo,
+	NULL,
+	NULL
+};
+
+#define GadgetList1 PosPropGadget
+
+struct IntuiText IText1 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"Remake Collision",
+	NULL
+};
+
+struct MenuItem MenuItem15 = {
+	NULL,
+	-50,112,
+	136,8,
+	ITEMTEXT+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText1,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText2 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"Remake Labels",
+	NULL
+};
+
+struct MenuItem MenuItem14 = {
+	&MenuItem15,
+	-50,104,
+	136,8,
+	ITEMTEXT+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText2,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText3 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"-----------------",
+	NULL
+};
+
+struct MenuItem MenuItem13 = {
+	&MenuItem14,
+	-50,96,
+	136,8,
+	ITEMTEXT+HIGHCOMP+HIGHBOX,
+	0,
+	(APTR)&IText3,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText4 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"Save Offsets",
+	NULL
+};
+
+struct MenuItem MenuItem12 = {
+	&MenuItem13,
+	-50,88,
+	136,8,
+	ITEMTEXT+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText4,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText5 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"Load Offsets",
+	NULL
+};
+
+struct MenuItem MenuItem11 = {
+	&MenuItem12,
+	-50,80,
+	136,8,
+	ITEMTEXT+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText5,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText6 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"-----------------",
+	NULL
+};
+
+struct MenuItem MenuItem10 = {
+	&MenuItem11,
+	-50,72,
+	136,8,
+	ITEMTEXT+HIGHCOMP+HIGHBOX,
+	0,
+	(APTR)&IText6,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText7 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"Edit Palette.. P",
+	NULL
+};
+
+struct MenuItem MenuItem9 = {
+	&MenuItem10,
+	-50,64,
+	136,8,
+	ITEMTEXT+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText7,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText8 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"-----------------",
+	NULL
+};
+
+struct MenuItem MenuItem8 = {
+	&MenuItem9,
+	-50,56,
+	136,8,
+	ITEMTEXT+HIGHCOMP,
+	0,
+	(APTR)&IText8,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText9 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"Set Main Org",
+	NULL
+};
+
+struct MenuItem MenuItem7 = {
+	&MenuItem8,
+	-50,48,
+	136,8,
+	ITEMTEXT+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText9,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText10 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"-----------------",
+	NULL
+};
+
+struct MenuItem MenuItem6 = {
+	&MenuItem7,
+	-50,40,
+	136,8,
+	ITEMTEXT+HIGHCOMP+HIGHBOX,
+	0,
+	(APTR)&IText10,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText11 = {
+	2,1,JAM1,
+	19,0,
+	&TOPAZ80,
+	"Collision    C",
+	NULL
+};
+
+struct MenuItem MenuItem5 = {
+	&MenuItem6,
+	-50,32,
+	136,8,
+	CHECKIT+ITEMTEXT+MENUTOGGLE+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText11,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText12 = {
+	2,1,JAM1,
+	19,0,
+	&TOPAZ80,
+	"Borders      B",
+	NULL
+};
+
+struct MenuItem MenuItem4 = {
+	&MenuItem5,
+	-50,24,
+	136,8,
+	CHECKIT+ITEMTEXT+MENUTOGGLE+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText12,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText13 = {
+	2,1,JAM1,
+	19,0,
+	&TOPAZ80,
+	"Org Grid     O",
+	NULL
+};
+
+struct MenuItem MenuItem3 = {
+	&MenuItem4,
+	-50,16,
+	136,8,
+	CHECKIT+ITEMTEXT+MENUTOGGLE+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText13,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText14 = {
+	2,1,JAM1,
+	19,0,
+	&TOPAZ80,
+	"Layer Mode   L",
+	NULL
+};
+
+struct MenuItem MenuItem2 = {
+	&MenuItem3,
+	-50,8,
+	136,8,
+	CHECKIT+ITEMTEXT+MENUTOGGLE+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText14,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText15 = {
+	2,1,JAM1,
+	19,0,
+	&TOPAZ80,
+	"Tool Window  W",
+	NULL
+};
+
+struct MenuItem MenuItem1 = {
+	&MenuItem2,
+	-50,0,
+	136,8,
+	CHECKIT+ITEMTEXT+MENUTOGGLE+ITEMENABLED+HIGHCOMP+CHECKED,
+	0,
+	(APTR)&IText15,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct Menu Menu5 = {
+	NULL,
+	224,0,
+	55,0,
+	MENUENABLED,
+	"Global",
+	&MenuItem1
+};
+
+struct IntuiText IText16 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"Start         A",
+	NULL
+};
+
+struct MenuItem MenuItem22 = {
+	NULL,
+	-64,48,
+	120,8,
+	ITEMTEXT+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText16,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText17 = {
+	2,1,JAM1,
+	19,0,
+	&TOPAZ80,
+	"Ping-Pong",
+	NULL
+};
+
+struct MenuItem SubItem3 = {
+	NULL,
+	105,15,
+	91,8,
+	CHECKIT+ITEMTEXT+MENUTOGGLE+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText17,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText18 = {
+	2,1,JAM1,
+	19,0,
+	&TOPAZ80,
+	"Backward",
+	NULL
+};
+
+struct MenuItem SubItem2 = {
+	&SubItem3,
+	105,7,
+	91,8,
+	CHECKIT+ITEMTEXT+MENUTOGGLE+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText18,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText19 = {
+	2,1,JAM1,
+	19,0,
+	&TOPAZ80,
+	"Forward",
+	NULL
+};
+
+struct MenuItem SubItem1 = {
+	&SubItem2,
+	105,-1,
+	91,8,
+	CHECKIT+ITEMTEXT+MENUTOGGLE+ITEMENABLED+HIGHCOMP+CHECKED,
+	0,
+	(APTR)&IText19,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText20 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"Mode          »",
+	NULL
+};
+
+struct MenuItem MenuItem21 = {
+	&MenuItem22,
+	-64,40,
+	120,8,
+	ITEMTEXT+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText20,
+	NULL,
+	NULL,
+	&SubItem1,
+	MENUNULL
+};
+
+struct IntuiText IText21 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"Last Bob      2",
+	NULL
+};
+
+struct MenuItem MenuItem20 = {
+	&MenuItem21,
+	-64,32,
+	120,8,
+	ITEMTEXT+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText21,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText22 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"First Bob     1",
+	NULL
+};
+
+struct MenuItem MenuItem19 = {
+	&MenuItem20,
+	-64,24,
+	120,8,
+	ITEMTEXT+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText22,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText23 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"---------------",
+	NULL
+};
+
+struct MenuItem MenuItem18 = {
+	&MenuItem19,
+	-64,16,
+	120,8,
+	ITEMTEXT+HIGHCOMP+HIGHBOX,
+	0,
+	(APTR)&IText23,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText24 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"Save IFF Anim..",
+	NULL
+};
+
+struct MenuItem MenuItem17 = {
+	&MenuItem18,
+	-64,8,
+	120,8,
+	ITEMTEXT+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText24,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText25 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"Load IFF Anim..",
+	NULL
+};
+
+struct MenuItem MenuItem16 = {
+	&MenuItem17,
+	-64,0,
+	120,8,
+	ITEMTEXT+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText25,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct Menu Menu4 = {
+	&Menu5,
+	178,0,
+	39,0,
+	MENUENABLED,
+	"Anim",
+	&MenuItem16
+};
+
+struct IntuiText IText26 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"Delete     F10",
+	NULL
+};
+
+struct MenuItem MenuItem36 = {
+	NULL,
+	0,104,
+	112,8,
+	ITEMTEXT+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText26,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText27 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"Insert New  F9",
+	NULL
+};
+
+struct MenuItem MenuItem35 = {
+	&MenuItem36,
+	0,96,
+	112,8,
+	ITEMTEXT+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText27,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText28 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"--------------",
+	NULL
+};
+
+struct MenuItem MenuItem34 = {
+	&MenuItem35,
+	0,88,
+	112,8,
+	ITEMTEXT+HIGHCOMP+HIGHBOX,
+	0,
+	(APTR)&IText28,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText29 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"Zoom         Z",
+	NULL
+};
+
+struct MenuItem MenuItem33 = {
+	&MenuItem34,
+	0,80,
+	112,8,
+	ITEMTEXT+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText29,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText30 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"Rotate       R",
+	NULL
+};
+
+struct MenuItem MenuItem32 = {
+	&MenuItem33,
+	0,72,
+	112,8,
+	ITEMTEXT+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText30,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText31 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"Flip Y       Y",
+	NULL
+};
+
+struct MenuItem MenuItem31 = {
+	&MenuItem32,
+	0,64,
+	112,8,
+	ITEMTEXT+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText31,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText32 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"Flip X       X",
+	NULL
+};
+
+struct MenuItem MenuItem30 = {
+	&MenuItem31,
+	0,56,
+	112,8,
+	ITEMTEXT+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText32,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText33 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"--------------",
+	NULL
+};
+
+struct MenuItem MenuItem29 = {
+	&MenuItem30,
+	0,48,
+	112,8,
+	ITEMTEXT+HIGHCOMP+HIGHBOX,
+	0,
+	(APTR)&IText33,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText34 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"Set Collis. F4",
+	NULL
+};
+
+struct MenuItem MenuItem28 = {
+	&MenuItem29,
+	0,40,
+	112,8,
+	ITEMTEXT+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText34,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText35 = {
+	3,1,COMPLEMENT,
+	0,0,
+	NULL,
+	".",
+	NULL
+};
+
+struct MenuItem SubItem12 = {
+	NULL,
+	111,15,
+	7,8,
+	CHECKIT+ITEMTEXT+MENUTOGGLE+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText35,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText36 = {
+	3,1,COMPLEMENT,
+	0,0,
+	NULL,
+	".",
+	NULL
+};
+
+struct MenuItem SubItem11 = {
+	&SubItem12,
+	104,15,
+	7,8,
+	CHECKIT+ITEMTEXT+MENUTOGGLE+ITEMENABLED+HIGHCOMP+CHECKED,
+	0,
+	(APTR)&IText36,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText37 = {
+	3,1,COMPLEMENT,
+	0,0,
+	NULL,
+	".",
+	NULL
+};
+
+struct MenuItem SubItem10 = {
+	&SubItem11,
+	97,15,
+	7,8,
+	CHECKIT+ITEMTEXT+MENUTOGGLE+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText37,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText38 = {
+	3,1,COMPLEMENT,
+	0,0,
+	NULL,
+	".",
+	NULL
+};
+
+struct MenuItem SubItem9 = {
+	&SubItem10,
+	111,7,
+	7,8,
+	CHECKIT+ITEMTEXT+MENUTOGGLE+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText38,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText39 = {
+	3,1,COMPLEMENT,
+	0,0,
+	NULL,
+	".",
+	NULL
+};
+
+struct MenuItem SubItem8 = {
+	&SubItem9,
+	104,7,
+	7,8,
+	CHECKIT+ITEMTEXT+MENUTOGGLE+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText39,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText40 = {
+	3,1,COMPLEMENT,
+	0,0,
+	NULL,
+	".",
+	NULL
+};
+
+struct MenuItem SubItem7 = {
+	&SubItem8,
+	97,7,
+	7,8,
+	CHECKIT+ITEMTEXT+MENUTOGGLE+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText40,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText41 = {
+	3,1,COMPLEMENT,
+	0,0,
+	NULL,
+	".",
+	NULL
+};
+
+struct MenuItem SubItem6 = {
+	&SubItem7,
+	111,-1,
+	7,8,
+	CHECKIT+ITEMTEXT+MENUTOGGLE+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText41,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText42 = {
+	3,1,COMPLEMENT,
+	0,0,
+	NULL,
+	".",
+	NULL
+};
+
+struct MenuItem SubItem5 = {
+	&SubItem6,
+	104,-1,
+	7,8,
+	CHECKIT+ITEMTEXT+MENUTOGGLE+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText42,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText43 = {
+	3,1,COMPLEMENT,
+	0,0,
+	NULL,
+	".",
+	NULL
+};
+
+struct MenuItem SubItem4 = {
+	&SubItem5,
+	97,-1,
+	7,8,
+	CHECKIT+ITEMTEXT+MENUTOGGLE+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText43,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText44 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"DefaultOrg   »",
+	NULL
+};
+
+struct MenuItem MenuItem27 = {
+	&MenuItem28,
+	0,32,
+	112,8,
+	ITEMTEXT+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText44,
+	NULL,
+	NULL,
+	&SubItem4,
+	MENUNULL
+};
+
+struct IntuiText IText45 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"Set Org     F3",
+	NULL
+};
+
+struct MenuItem MenuItem26 = {
+	&MenuItem27,
+	0,24,
+	112,8,
+	ITEMTEXT+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText45,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText46 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"--------------",
+	NULL
+};
+
+struct MenuItem MenuItem25 = {
+	&MenuItem26,
+	0,16,
+	112,8,
+	ITEMTEXT+HIGHCOMP+HIGHBOX,
+	0,
+	(APTR)&IText46,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText47 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"Get multi   F2",
+	NULL
+};
+
+struct MenuItem MenuItem24 = {
+	&MenuItem25,
+	0,8,
+	112,8,
+	ITEMTEXT+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText47,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText48 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"Get single  F1",
+	NULL
+};
+
+struct MenuItem MenuItem23 = {
+	&MenuItem24,
+	0,0,
+	112,8,
+	ITEMTEXT+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText48,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct Menu Menu3 = {
+	&Menu4,
+	140,0,
+	31,0,
+	MENUENABLED,
+	"Bob",
+	&MenuItem23
+};
+
+struct IntuiText IText49 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"Close Screen",
+	NULL
+};
+
+struct MenuItem MenuItem41 = {
+	NULL,
+	0,32,
+	144,8,
+	ITEMTEXT+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText49,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText50 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"------------------",
+	NULL
+};
+
+struct MenuItem MenuItem40 = {
+	&MenuItem41,
+	0,24,
+	144,8,
+	ITEMTEXT+HIGHCOMP+HIGHBOX,
+	0,
+	(APTR)&IText50,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText51 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"Grab Screen..",
+	NULL
+};
+
+struct MenuItem MenuItem39 = {
+	&MenuItem40,
+	0,16,
+	144,8,
+	ITEMTEXT+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText51,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText52 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"Grab DPaint",
+	NULL
+};
+
+struct MenuItem MenuItem38 = {
+	&MenuItem39,
+	0,8,
+	144,8,
+	ITEMTEXT+COMMSEQ+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText52,
+	NULL,
+	'D',
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText53 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"Load IFF..",
+	NULL
+};
+
+struct MenuItem MenuItem37 = {
+	&MenuItem38,
+	0,0,
+	144,8,
+	ITEMTEXT+COMMSEQ+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText53,
+	NULL,
+	'P',
+	NULL,
+	MENUNULL
+};
+
+struct Menu Menu2 = {
+	&Menu3,
+	70,0,
+	63,0,
+	MENUENABLED,
+	"Picture",
+	&MenuItem37
+};
+
+struct IntuiText IText54 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"Quit",
+	NULL
+};
+
+struct MenuItem MenuItem56 = {
+	NULL,
+	0,112,
+	144,8,
+	ITEMTEXT+COMMSEQ+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText54,
+	NULL,
+	'Q',
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText55 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"------------------",
+	NULL
+};
+
+struct MenuItem MenuItem55 = {
+	&MenuItem56,
+	0,104,
+	144,8,
+	ITEMTEXT+HIGHCOMP+HIGHBOX,
+	0,
+	(APTR)&IText55,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText56 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"Sleep",
+	NULL
+};
+
+struct MenuItem MenuItem54 = {
+	&MenuItem55,
+	0,96,
+	144,8,
+	ITEMTEXT+COMMSEQ+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText56,
+	NULL,
+	'`',
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText57 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"------------------",
+	NULL
+};
+
+struct MenuItem MenuItem53 = {
+	&MenuItem54,
+	0,88,
+	144,8,
+	ITEMTEXT+HIGHCOMP+HIGHBOX,
+	0,
+	(APTR)&IText57,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText58 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"About..",
+	NULL
+};
+
+struct MenuItem MenuItem52 = {
+	&MenuItem53,
+	0,80,
+	144,8,
+	ITEMTEXT+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText58,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText59 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"------------------",
+	NULL
+};
+
+struct MenuItem MenuItem51 = {
+	&MenuItem52,
+	0,72,
+	144,8,
+	ITEMTEXT+HIGHCOMP+HIGHBOX,
+	0,
+	(APTR)&IText59,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText60 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"Do Script..",
+	NULL
+};
+
+struct MenuItem SubItem16 = {
+	NULL,
+	129,23,
+	136,8,
+	ITEMTEXT+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText60,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText61 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"-----------------",
+	NULL
+};
+
+struct MenuItem SubItem15 = {
+	&SubItem16,
+	129,15,
+	136,8,
+	ITEMTEXT+HIGHCOMP+HIGHBOX,
+	0,
+	(APTR)&IText61,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText62 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"Stop Recording",
+	NULL
+};
+
+struct MenuItem SubItem14 = {
+	&SubItem15,
+	129,7,
+	136,8,
+	ITEMTEXT+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText62,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText63 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"Start Recording..",
+	NULL
+};
+
+struct MenuItem SubItem13 = {
+	&SubItem14,
+	129,-1,
+	136,8,
+	ITEMTEXT+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText63,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText64 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"ARexx            »",
+	NULL
+};
+
+struct MenuItem MenuItem50 = {
+	&MenuItem51,
+	0,64,
+	144,8,
+	ITEMTEXT+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText64,
+	NULL,
+	NULL,
+	&SubItem13,
+	MENUNULL
+};
+
+struct IntuiText IText65 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"Generate Code",
+	NULL
+};
+
+struct MenuItem MenuItem49 = {
+	&MenuItem50,
+	0,56,
+	144,8,
+	ITEMTEXT+COMMSEQ+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText65,
+	NULL,
+	'G',
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText66 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"------------------",
+	NULL
+};
+
+struct MenuItem MenuItem48 = {
+	&MenuItem49,
+	0,48,
+	144,8,
+	ITEMTEXT+HIGHCOMP+HIGHBOX,
+	0,
+	(APTR)&IText66,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText67 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"Delete File..",
+	NULL
+};
+
+struct MenuItem MenuItem47 = {
+	&MenuItem48,
+	0,40,
+	144,8,
+	ITEMTEXT+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText67,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText68 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"Save Bobs..",
+	NULL
+};
+
+struct MenuItem MenuItem46 = {
+	&MenuItem47,
+	0,32,
+	144,8,
+	ITEMTEXT+COMMSEQ+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText68,
+	NULL,
+	'S',
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText69 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"Insert Bobs..",
+	NULL
+};
+
+struct MenuItem MenuItem45 = {
+	&MenuItem46,
+	0,24,
+	144,8,
+	ITEMTEXT+COMMSEQ+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText69,
+	NULL,
+	'I',
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText70 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"Load Bobs",
+	NULL
+};
+
+struct MenuItem MenuItem44 = {
+	&MenuItem45,
+	0,16,
+	144,8,
+	ITEMTEXT+COMMSEQ+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText70,
+	NULL,
+	'O',
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText71 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"------------------",
+	NULL
+};
+
+struct MenuItem MenuItem43 = {
+	&MenuItem44,
+	0,8,
+	144,8,
+	ITEMTEXT+HIGHCOMP+HIGHBOX,
+	0,
+	(APTR)&IText71,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct IntuiText IText72 = {
+	2,1,JAM1,
+	0,0,
+	&TOPAZ80,
+	"Clear All..",
+	NULL
+};
+
+struct MenuItem MenuItem42 = {
+	&MenuItem43,
+	0,0,
+	144,8,
+	ITEMTEXT+ITEMENABLED+HIGHCOMP,
+	0,
+	(APTR)&IText72,
+	NULL,
+	NULL,
+	NULL,
+	MENUNULL
+};
+
+struct Menu Menu1 = {
+	&Menu2,
+	0,0,
+	63,0,
+	MENUENABLED,
+	"Project",
+	&MenuItem42
+};
+
+#define MenuList1 Menu1
+
+struct NewWindow NewWindowStructure1 = {
+	0,0,
+	320,200,
+	0,1,
+	MOUSEBUTTONS+GADGETDOWN+GADGETUP+MENUPICK+RAWKEY,
+	BACKDROP+REPORTMOUSE+BORDERLESS+ACTIVATE+NOCAREREFRESH,
+	&PosPropGadget,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	0,0,
+	0,0,
+	CUSTOMSCREEN
+};
+
+SHORT BorderVectors6[] = {
+	0,0,
+	37,0,
+	37,10,
+	0,10,
+	0,0
+};
+struct Border Border6 = {
+	134,11,
+	1,0,JAM1,
+	5,
+	BorderVectors6,
+	NULL
+};
+
+SHORT BorderVectors5[] = {
+	0,0,
+	37,0,
+	37,10,
+	0,10,
+	0,0
+};
+struct Border Border5 = {
+	94,11,
+	1,0,JAM1,
+	5,
+	BorderVectors5,
+	&Border6
+};
+
+SHORT BorderVectors4[] = {
+	0,0,
+	37,0,
+	37,10,
+	0,10,
+	0,0
+};
+struct Border Border4 = {
+	174,11,
+	1,0,JAM1,
+	5,
+	BorderVectors4,
+	&Border5
+};
+
+SHORT BorderVectors3[] = {
+	0,0,
+	37,0,
+	37,10,
+	0,10,
+	0,0
+};
+struct Border Border3 = {
+	214,11,
+	1,0,JAM1,
+	5,
+	BorderVectors3,
+	&Border4
+};
+
+struct Gadget Gadget11 = {
+	NULL,
+	0,0,
+	1,1,
+	GADGHBOX+GADGHIMAGE,
+	NULL,
+	BOOLGADGET,
+	(APTR)&Border3,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+UBYTE LabelGadgetSIBuff[64];
+struct StringInfo LabelGadgetSInfo = {
+	LabelGadgetSIBuff,
+	UNDOBUFFER,
+	0,
+	64,
+	0,
+	0,0,0,0,0,
+	0,
+	0,
+	NULL
+};
+
+SHORT BorderVectors7[] = {
+	0,0,
+	157,0,
+	157,11,
+	0,11,
+	0,1
+};
+struct Border Border7 = {
+	-2,-2,
+	1,0,JAM1,
+	5,
+	BorderVectors7,
+	NULL
+};
+
+struct IntuiText IText73 = {
+	1,0,JAM1,
+	28,-11,
+	NULL,
+	"Source Label:",
+	NULL
+};
+
+struct Gadget LabelGadget = {
+	&Gadget11,
+	96,46,
+	154,9,
+	NULL,
+	RELVERIFY,
+	STRGADGET,
+	(APTR)&Border7,
+	NULL,
+	&IText73,
+	NULL,
+	(APTR)&LabelGadgetSInfo,
+	NULL,
+	NULL
+};
+
+SHORT BorderVectors8[] = {
+	0,0,
+	33,0,
+	33,21,
+	0,21,
+	0,0
+};
+struct Border Border8 = {
+	-1,-1,
+	1,0,JAM1,
+	5,
+	BorderVectors8,
+	NULL
+};
+
+struct IntuiText IText75 = {
+	1,0,JAM1,
+	4,11,
+	NULL,
+	"Org",
+	NULL
+};
+
+struct IntuiText IText74 = {
+	1,0,JAM1,
+	4,2,
+	NULL,
+	"Set",
+	&IText75
+};
+
+struct Gadget SetOrgGadget = {
+	&LabelGadget,
+	255,35,
+	32,20,
+	NULL,
+	RELVERIFY,
+	BOOLGADGET,
+	(APTR)&Border8,
+	NULL,
+	&IText74,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+SHORT BorderVectors9[] = {
+	0,0,
+	33,0,
+	33,21,
+	0,21,
+	0,0
+};
+struct Border Border9 = {
+	-1,-1,
+	1,0,JAM1,
+	5,
+	BorderVectors9,
+	NULL
+};
+
+struct IntuiText IText77 = {
+	1,0,JAM1,
+	4,11,
+	NULL,
+	"Bob",
+	NULL
+};
+
+struct IntuiText IText76 = {
+	1,0,JAM1,
+	4,2,
+	NULL,
+	"Get",
+	&IText77
+};
+
+struct Gadget GetBobGadget = {
+	&SetOrgGadget,
+	255,12,
+	32,20,
+	NULL,
+	RELVERIFY,
+	BOOLGADGET,
+	(APTR)&Border9,
+	NULL,
+	&IText76,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+struct PropInfo AnimSpeedGadgetSInfo = {
+	AUTOKNOB+FREEVERT,
+	(UWORD)-1,20755,
+	(UWORD)-1,4095,
+};
+
+struct Image Image2 = {
+	0,11,
+	6,4,
+	0,
+	NULL,
+	0x0000,0x0000,
+	NULL
+};
+
+struct Gadget AnimSpeedGadget = {
+	&GetBobGadget,
+	4,11,
+	14,45,
+	NULL,
+	NULL,
+	PROPGADGET,
+	(APTR)&Image2,
+	NULL,
+	NULL,
+	NULL,
+	(APTR)&AnimSpeedGadgetSInfo,
+	NULL,
+	NULL
+};
+
+SHORT BorderVectors10[] = {
+	0,0,
+	71,0,
+	71,11,
+	0,11,
+	0,0
+};
+struct Border Border10 = {
+	-1,-1,
+	1,0,JAM1,
+	5,
+	BorderVectors10,
+	NULL
+};
+
+struct IntuiText IText78 = {
+	1,0,JAM1,
+	4,1,
+	NULL,
+	"Anim Key",
+	NULL
+};
+
+struct Gadget AnimKeyGadget = {
+	&AnimSpeedGadget,
+	21,45,
+	70,10,
+	SELECTED,
+	RELVERIFY+TOGGLESELECT,
+	BOOLGADGET,
+	(APTR)&Border10,
+	NULL,
+	&IText78,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+SHORT BorderVectors11[] = {
+	0,0,
+	71,0,
+	71,11,
+	0,11,
+	0,0
+};
+struct Border Border11 = {
+	-1,-1,
+	1,0,JAM1,
+	5,
+	BorderVectors11,
+	NULL
+};
+
+struct IntuiText IText79 = {
+	1,0,JAM1,
+	4,1,
+	NULL,
+	"Auto Org",
+	NULL
+};
+
+struct Gadget AutoOrgGadget = {
+	&AnimKeyGadget,
+	21,28,
+	70,10,
+	SELECTED,
+	RELVERIFY+TOGGLESELECT,
+	BOOLGADGET,
+	(APTR)&Border11,
+	NULL,
+	&IText79,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+SHORT BorderVectors12[] = {
+	0,0,
+	71,0,
+	71,11,
+	0,11,
+	0,0
+};
+struct Border Border12 = {
+	-1,-1,
+	1,0,JAM1,
+	5,
+	BorderVectors12,
+	NULL
+};
+
+struct IntuiText IText80 = {
+	1,0,JAM1,
+	4,1,
+	NULL,
+	"AutoSize",
+	NULL
+};
+
+struct Gadget AutoSizeGadget = {
+	&AutoOrgGadget,
+	21,12,
+	70,10,
+	SELECTED,
+	RELVERIFY+TOGGLESELECT,
+	BOOLGADGET,
+	(APTR)&Border12,
+	NULL,
+	&IText80,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+#define GadgetList2 AutoSizeGadget
+
+struct NewWindow NewWindowStructure2 = {
+	0,11,
+	292,58,
+	0,1,
+	MOUSEBUTTONS+GADGETDOWN+GADGETUP+MENUPICK+CLOSEWINDOW+RAWKEY,
+	WINDOWDRAG+WINDOWCLOSE+REPORTMOUSE+ACTIVATE+NOCAREREFRESH,
+	&AutoSizeGadget,
+	NULL,
+	"Bobi Tool Window",
+	NULL,
+	NULL,
+	0,0,
+	0,0,
+	CUSTOMSCREEN
+};
+
+
+void HandleEvent(object)
+APTR object;
+{
+  if (object == (APTR)&GetBobGadget) { GetBobFunc(      ); return; }
+  if (object == (APTR)&SetOrgGadget) { SetOrgFunc(      ); return; }
+  if (object == (APTR)&MenuItem42) { ClearAllFunc(      ); return; }
+  if (object == (APTR)&MenuItem44) { LoadBobsFunc(      ); return; }
+  if (object == (APTR)&MenuItem45) { InsertBobsFunc(      ); return; }
+  if (object == (APTR)&MenuItem46) { SaveBobsFunc(      ); return; }
+  if (object == (APTR)&MenuItem47) { DeleteFileFunc(      ); return; }
+  if (object == (APTR)&MenuItem49) { GenerateCodeFunc(      ); return; }
+  if (object == (APTR)&MenuItem52) { AboutFunc(      ); return; }
+  if (object == (APTR)&MenuItem54) { SleepFunc(      ); return; }
+  if (object == (APTR)&MenuItem56) { QuitFunc(      ); return; }
+  if (object == (APTR)&MenuItem37) { LoadPicFunc(      ); return; }
+  if (object == (APTR)&MenuItem38) { GrabDPaintFunc(      ); return; }
+  if (object == (APTR)&MenuItem39) { GrabScreenFunc(      ); return; }
+  if (object == (APTR)&MenuItem41) { CloseScreenFunc(      ); return; }
+  if (object == (APTR)&MenuItem23) { GetBobFunc(      ); return; }
+  if (object == (APTR)&MenuItem24) { GetMultiFunc(      ); return; }
+  if (object == (APTR)&MenuItem26) { SetOrgFunc(      ); return; }
+  if (object == (APTR)&MenuItem28) { SetCollBoundsFunc(      ); return; }
+  if (object == (APTR)&MenuItem30) { FlipXFunc(      ); return; }
+  if (object == (APTR)&MenuItem31) { FlipYFunc(      ); return; }
+  if (object == (APTR)&MenuItem32) { RotateFunc(      ); return; }
+  if (object == (APTR)&MenuItem33) { ZoomFunc(      ); return; }
+  if (object == (APTR)&MenuItem35) { InsertNewBobFunc(      ); return; }
+  if (object == (APTR)&MenuItem36) { DeleteActBobFunc(      ); return; }
+  if (object == (APTR)&MenuItem16) { LoadIFFAnimFunc(      ); return; }
+  if (object == (APTR)&MenuItem17) { SaveIFFAnimFunc(      ); return; }
+  if (object == (APTR)&MenuItem19) { SetFirstBobFunc(      ); return; }
+  if (object == (APTR)&MenuItem20) { SetLastBobFunc(      ); return; }
+  if (object == (APTR)&SubItem1) { SetAnimModeFunc(      ); return; }
+  if (object == (APTR)&SubItem2) { SetAnimModeFunc(      ); return; }
+  if (object == (APTR)&SubItem3) { SetAnimModeFunc(      ); return; }
+  if (object == (APTR)&MenuItem22) { StartAnimFunc(      ); return; }
+  if (object == (APTR)&MenuItem1) { ToolWindowFunc(      ); return; }
+  if (object == (APTR)&MenuItem7) { SetMainOrgFunc(      ); return; }
+  if (object == (APTR)&MenuItem9) { EditPaletteFunc(      ); return; }
+  if (object == (APTR)&MenuItem11) { LoadOffsetsFunc(      ); return; }
+  if (object == (APTR)&MenuItem12) { SaveOffsetsFunc(      ); return; }
+  if (object == (APTR)&MenuItem14) { RemakeLabelsFunc(      ); return; }
+  if (object == (APTR)&MenuItem15) { RemakeCollisionFunc(      ); return; }
+}
+#define HANDLEEVENT HandleEvent
+
+/* end of PowerWindows source generation */
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..7045ed9
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,85 @@
+##
+##  Bobi - The Ultimate Amiga Bob Manipulator
+##
+##  COPYRIGHT (C) 1992-1994 BY CHRISTIAN A. WEBER, ZUERICH, SWITZERLAND.
+##  ALL RIGHTS RESERVED. NO PART OF THIS SOFTWARE MAY BE COPIED, REPRODUCED,
+##  OR TRANSMITTED IN ANY FORM OR BY ANY MEANS, WITHOUT THE PRIOR WRITTEN
+##  PERMISSION OF THE AUTHOR. NO WARRANTY. USE AT YOUR OWN RISK.
+##
+
+
+ALL:		Bobi
+
+
+#############################################################################
+##	Parameters und Flags
+
+PROJECT		= Bobi
+
+ASM		= Genam
+AFLAGS		= -iINCLUDE: -l
+
+CC		= sc
+CFLAGS		=
+
+LD		= SLINK
+LDDEF		= _STACKSIZE=20000 __XCEXIT=@Exit
+LFLAGS		= NOICONS ADDSYM MAP RAM:$(PROJECT).map
+
+
+#############################################################################
+##	Regeln
+
+.c.o:
+		$(CC) $(CFLAGS) $*.c
+
+.S.o:
+		-@Delete $@ 
+		$(ASM) $(AFLAGS) $*.S
+
+
+#############################################################################
+## Module für Bobi:
+
+LIBS		= LIB:scmffp.lib LIB:sc.lib LIB:small.lib LIB:debug.lib
+
+MODS		= Bobi.o About.o Anim.o AREXX.o Bob.o BMapSupport.o ByteMap.o\
+		  Color.o FileRequest.o Generate.o Get.o IFFAnim.o IFFError.o\
+		  IMSGHandler.o Layer.o LoadBobs.o Misc.o Picture.o PropGadgets.o\
+		  Rotate.o Sleep.o Stubs.o Zoom.o\
+		  ConvertDate.o CreateRastPort.o GadgetSupport.o ShowRequest.o Snooze.o
+
+
+#############################################################################
+## Abhängigkeiten:
+
+$(MODS):	Bobi.h BobStructure.h
+Bobi.o:		MainWindow.h
+About.o:	AboutWindow.h
+Generate.o:	GenerateWindow.h
+Rotate.o:	RotateWindow.h
+
+Startup.o:	Startup.S
+		-@Delete $@ 
+		$(ASM) $(AFLAGS) -e DETACH=1 -e TINY=1 $*.S
+
+
+#############################################################################
+## Targets:
+
+Bobi:		Startup.o $(MODS) $(LIBS)
+		-@Delete $@ 
+		$(LD) $(LFLAGS) FROM Startup.o $(MODS) TO $@ LIB $(LIBS) DEFINE $(LDDEF)
+
+
+install:	Bobi
+		$(LD) FROM Bobi TO SYS:C-User/Proprietary/Bobi NOICONS NODEBUG
+
+clean:
+		-@Delete *.o Bobi
+
+dist:
+		-@Delete Bobi.LHA
+		-@LHA -x -a a Bobi.LHA c:Bobi Bobi.doc BobiTest.rexx BobiTest.bobs BobiTest.pic
+		-@LHA v Bobi.LHA
+
diff --git a/Misc.c b/Misc.c
new file mode 100644
index 0000000..b4d2fdb
--- /dev/null
+++ b/Misc.c
@@ -0,0 +1,204 @@
+#include <proto/exec.h>
+#include <proto/graphics.h>
+#include <proto/intuition.h>
+#include <proto/dos.h>
+
+#include "Bobi.h"
+
+extern struct Screen	*mainscreen;
+extern struct Window	*mainwindow,*toolwindow;
+extern WORD				options;
+extern UWORD			mainpalette[],Palette[];
+extern BYTE				defaultorg;
+extern struct MenuItem	LayerModeMenuItem,OrgGridMenuItem,
+						BobBordersMenuItem,CollisionRectMenuItem,
+						FirstDefaultOrgSubItem;
+extern BYTE				arexxflag;
+
+/****************************************************************************
+**	Requester mit einem OK-Gadget anzeigen
+*/
+
+void ShowMonoReq2(char *text)
+{
+	LockWindows();
+	ShowRequest(text,0," OK ",0x8000);
+	UnLockWindows();
+}
+
+/****************************************************************************
+**	Requester mit PosText und "Cancel" anzeigen
+*/
+
+BOOL ShowRequest2(char *text,char *postext)
+{
+	BOOL val;
+	LockWindows();
+	val = ShowRequest(text,postext,"CANCEL",0x8000);
+	UnLockWindows();
+	return(val);
+}
+
+/****************************************************************************
+**	'Can't open file' plus Text ausgeben
+*/
+
+void ShowFileError(char *name)
+{
+	char buf[200];
+	sprintf(buf,"Can't open file\n'%s' !",name);
+	ShowMonoReq2(buf);
+}
+
+/****************************************************************************
+**	File zum Schreiben öffnen und Requester bringen falls es schon existiert
+*/
+
+BPTR OpenNewFileSafely(char *name)
+{
+	register BPTR file;
+	char buf[200];
+
+	if(!arexxflag)		/* Wenn das Kommando von ARexx kommt wird nix getestet */
+	{
+		if(file=Lock(name,ACCESS_READ))
+		{
+			UnLock(file);
+			sprintf(buf,"Warning: The file\n'%s'\nexists. Save over top of it?",name);
+			if(!ShowRequest2(buf,"YES")) return 0;
+		}
+	}
+
+	if(!(file=Open(name,MODE_NEWFILE)))
+	{
+		ShowFileError(name);
+		return 0;
+	}
+
+	return file;
+}
+
+/****************************************************************************
+**	Rahmen in gewünschter Farbe zeichnen
+*/
+
+void DrawRect(struct RastPort *rp,WORD x0,WORD y0,WORD x1,WORD y1,WORD col)
+{
+	SetDrMd(rp,JAM1);
+	SetAPen(rp,col);
+	Move(rp,x0,y0);
+	Draw(rp,x1,y0);
+	Draw(rp,x1,y1);
+	Draw(rp,x0,y1);
+	Draw(rp,x0,y0);
+}
+
+/****************************************************************************
+**	Fadenkreuz zeichnen
+*/
+
+void DrawCross(struct Screen *screen,WORD x,WORD y)
+{
+	if(x>=0)
+	{
+		register struct RastPort *rp = &(screen->RastPort);
+		SetDrMd(rp,COMPLEMENT);
+		Move(rp,0,y);
+		Draw(rp,screen->Width-1,y);
+		Move(rp,x,0);
+		Draw(rp,x,screen->Height-1);
+	}
+}
+
+/****************************************************************************
+**	MainScreen-Farbpalette setzen
+*/
+
+void LoadPalette(UWORD *pal)
+{
+	LoadRGB4(&(mainscreen->ViewPort),pal,32);
+}
+
+/****************************************************************************
+**	Menus abschalten und Snooze-Pointer setzen
+*/
+
+static WORD LockCntr;
+
+void LockWindows()
+{
+	if(!LockCntr)
+	{
+		LoadPalette(Palette);
+		Snooze(mainwindow);
+		if(toolwindow) Snooze(toolwindow);
+	}
+	LockCntr++;
+}
+
+/****************************************************************************
+**	Windows wieder unlocken
+*/
+
+void UnLockWindows()
+{
+	if(LockCntr>0) --LockCntr;
+
+	if(!LockCntr)
+	{
+		if(toolwindow) UnSnooze(toolwindow);
+		UnSnooze(mainwindow);
+		LoadPalette(mainpalette);
+	}
+}
+
+/****************************************************************************
+** Globale Optionen setzen und in den Menuitems updaten
+*/
+
+void SetGlobalOptions(WORD opts, BYTE deforg)
+{
+	struct MenuItem	*item;
+	int				i;
+
+	options = opts;
+	if(opts & GOF_LAYERMODE)     LayerModeMenuItem.Flags  |=  CHECKED;
+	else                         LayerModeMenuItem.Flags  &= ~CHECKED;
+	if(opts & GOF_ORGGRID)       OrgGridMenuItem.Flags    |=  CHECKED;
+	else                         OrgGridMenuItem.Flags    &= ~CHECKED;
+	if(opts & GOF_BOBBORDERS)    BobBordersMenuItem.Flags |=  CHECKED;
+	else                         BobBordersMenuItem.Flags &= ~CHECKED;
+	if(opts & GOF_COLLISIONRECT) CollisionRectMenuItem.Flags |=  CHECKED;
+	else                         CollisionRectMenuItem.Flags &= ~CHECKED;
+
+	defaultorg = deforg;
+
+	for(i=0,item = &FirstDefaultOrgSubItem; item; item=item->NextItem,++i)
+	{
+		if(i == defaultorg)		item->Flags |= CHECKED;
+		else					item->Flags &= ~CHECKED;
+	}
+}
+
+/****************************************************************************
+**	Globale Optionen aus den Menuitems auslesen
+*/
+
+void GetGlobalOptions()
+{
+	struct MenuItem *item;
+
+	options=0;
+	if(LayerModeMenuItem.Flags     & CHECKED) options |= GOF_LAYERMODE;
+	if(OrgGridMenuItem.Flags       & CHECKED) options |= GOF_ORGGRID;
+	if(BobBordersMenuItem.Flags    & CHECKED) options |= GOF_BOBBORDERS;
+	if(CollisionRectMenuItem.Flags & CHECKED) options |= GOF_COLLISIONRECT;
+
+	defaultorg=0;
+	for(item = &FirstDefaultOrgSubItem; item; item=item->NextItem)
+	{
+		if(item->Flags & CHECKED) break;
+		defaultorg++;
+	}
+}
+
diff --git a/Picture.c b/Picture.c
new file mode 100644
index 0000000..19213fe
--- /dev/null
+++ b/Picture.c
@@ -0,0 +1,174 @@
+#include <proto/exec.h>
+#include <proto/graphics.h>
+#include <proto/dos.h>
+#include <proto/intuition.h>
+#include <intuition/intuitionbase.h>
+#include <libraries/iff.h>
+#include <graphics/gfxbase.h>
+
+#include "Bobi.h"
+#define MAX(a,b) ((a)>(b)?(a):(b))
+
+extern struct Screen *mainscreen;
+extern struct Screen *picturescreen;
+extern struct Window *picturewindow;
+
+extern UWORD mainpalette[],picturepalette[];
+
+extern char PicPath[];	/* Definiert in LoadBobs.c wegen '.bobi' */
+extern char PicName[];
+
+extern BYTE arexxflag;
+extern char arexxfilename[];
+
+static struct RastPort *picturerastport;
+
+
+/****************************************************************************
+**	Ein IFF-Bild von Disk laden
+*/
+
+void LoadPicFunc()
+{
+	ULONG				*formptr;
+	struct IFFL_BMHD	*bmhd;
+	LONG				count;
+	IFFL_HANDLE			ifffile;
+	char				*name;
+
+	LockWindows();
+
+	if(arexxflag)
+		name = arexxfilename;
+	else
+		name=FileRequest("Load Picture from Disk", "LOAD", PicPath, PicName);
+
+	if(name)
+	{
+		if(ifffile = IFFL_OpenIFF(name, IFFL_MODE_READ))
+		{
+			formptr = ifffile;
+			if(formptr[2]==ID_ANIM) formptr+=3;
+
+			if(bmhd = IFFL_GetBMHD(formptr))
+			{
+				CloseScreenFunc();
+				if(picturerastport = CreateRastPort(bmhd->nPlanes,
+					MAX(bmhd->w,GfxBase->NormalDisplayColumns>>1),
+					MAX(bmhd->h,GfxBase->NormalDisplayRows)))
+				{
+					static struct TagItem mytagitems[] =
+					{
+						SA_Overscan,OSCAN_TEXT,
+						SA_AutoScroll,TRUE,
+					};
+					struct ExtNewScreen ns;
+					struct NewWindow nw;
+
+					ClearMem(&ns,sizeof(ns));
+					ClearMem(&nw,sizeof(nw));
+
+					if(OSVERSION(37))
+					{
+						ns.Width	= bmhd->w;
+						ns.Height	= bmhd->h;
+					}
+					else
+					{
+						ns.Width    = GfxBase->NormalDisplayColumns>>1;
+						ns.Height   = GfxBase->NormalDisplayRows;
+					}
+					ns.Depth        = bmhd->nPlanes;
+		//			ns.Depth        = (bmhd->nPlanes > 5) ? bmhd->nPlanes:5;
+					ns.ViewModes	= IFFL_GetViewModes(formptr);
+					ns.CustomBitMap = picturerastport->BitMap;
+					ns.Type         = CUSTOMSCREEN|CUSTOMBITMAP|SCREENQUIET|SCREENBEHIND|NS_EXTENDED;
+					ns.Extension	= mytagitems;
+
+					nw.IDCMPFlags   = IDCMP_MOUSEBUTTONS | IDCMP_MOUSEMOVE | IDCMP_DELTAMOVE;
+					nw.Flags        = WFLG_BACKDROP | WFLG_BORDERLESS
+										| WFLG_SIMPLE_REFRESH | WFLG_NOCAREREFRESH
+										| WFLG_REPORTMOUSE | WFLG_RMBTRAP;
+					nw.Type         = CUSTOMSCREEN;
+
+					if(picturescreen = OpenScreen(&ns))
+					{
+						nw.Screen = picturescreen;
+						nw.Width  = picturescreen->Width;
+						nw.Height = picturescreen->Height;
+						if(picturewindow = OpenWindow(&nw))
+						{
+							ShowTitle(picturescreen,FALSE);
+							count = IFFL_GetColorTab(formptr,(WORD *)picturepalette);
+							if(count>32) count = 32;
+							CopyMem(picturepalette,mainpalette,count*2);
+							LoadRGB4(&picturescreen->ViewPort,picturepalette,count);
+
+							if(IFFL_DecodePic(formptr,&(picturescreen->BitMap)))
+							{
+								if(!arexxflag)
+								{
+									ScreenToFront(picturescreen);
+									MoveScreen(mainscreen,0,-255);
+									MoveScreen(mainscreen,0,255);
+									Delay(15);
+									ScreenToFront(mainscreen);
+									for(count=28; count>0; --count)
+										MoveScreen(mainscreen,0,-10);
+								}
+							}
+							else
+							{
+								CloseScreenFunc();
+								ShowIFFError("Error decoding picture");
+							}
+						}
+						else
+						{
+							CloseScreenFunc();
+							ShowMonoReq2("Can't open window!");
+						}
+					}
+					else
+					{
+						CloseScreenFunc();
+						ShowMonoReq2("Can't open screen!");
+					}
+				}
+				else ShowMonoReq2("No mem for rastport!");
+			}
+			else ShowIFFError("Mangled IFF picture");
+			IFFL_CloseIFF(ifffile);
+		}
+		else ShowIFFError(name);
+
+	}	/* if(FileRequest()) */
+	UnLockWindows();
+}
+
+/****************************************************************************
+**	Picture-Screen schliessen und Bild freigeben
+*/
+
+void CloseScreenFunc()
+{
+	if(picturewindow)
+	{
+		CloseWindow(picturewindow);
+		picturewindow = 0;
+	}
+
+	if(picturescreen)
+	{
+		CloseScreen(picturescreen);
+		picturescreen = 0;
+	}
+
+	if(picturerastport)
+	{
+		DeleteRastPort(picturerastport);
+		picturerastport = 0;
+	}
+
+}
+
diff --git a/PropGadgets.c b/PropGadgets.c
new file mode 100644
index 0000000..dbbbd8e
--- /dev/null
+++ b/PropGadgets.c
@@ -0,0 +1,61 @@
+#include <proto/exec.h>
+#include <proto/graphics.h>
+#include <proto/intuition.h>
+#include <proto/dos.h>
+
+#include "Bobi.h"
+#include "BobStructure.h"
+
+extern struct MyBob *BobTable[];
+extern struct Window *mainwindow;
+extern struct Gadget PosPropGadget;
+extern struct PropInfo PosPropGadgetSInfo;
+extern WORD numbobs,actbobnum;
+
+/*************************************************************************/
+
+void MovePosFunc()
+{
+	register struct Message *msg;
+	register WORD oldnum=-1;
+
+	for(;;)
+	{
+		WaitTOF();
+		if(msg = GetMsg(mainwindow->UserPort))
+		{
+			ReplyMsg(msg);
+			break;
+		}
+		actbobnum = ReadBobNum();
+		if(actbobnum != oldnum)
+		{
+			ShowFrame(actbobnum);
+			/* ShowBob(BobTable[actbobnum]); */
+			oldnum = actbobnum;
+		}
+	}
+	actbobnum = ReadBobNum();
+	ShowFrame(actbobnum);
+}
+
+/*************************************************************************/
+
+WORD ReadBobNum()
+{
+	return((WORD)((((UWORD)numbobs*PosPropGadgetSInfo.VertPot)+0x7fffL)>>16));
+}
+
+/*************************************************************************/
+
+void RefreshBobNum()
+{
+	PosPropGadgetSInfo.VertBody = 0xffffL/(numbobs+1);
+	if(numbobs>0)
+	{
+		PosPropGadgetSInfo.VertPot  = (actbobnum*0xffffL)/numbobs;
+	}
+	else PosPropGadgetSInfo.VertPot = 0;
+
+	RefreshGList(&PosPropGadget,mainwindow,0,1);
+}
diff --git a/Rotate.c b/Rotate.c
new file mode 100644
index 0000000..b79f803
--- /dev/null
+++ b/Rotate.c
@@ -0,0 +1,208 @@
+#include <proto/exec.h>
+#include <proto/graphics.h>
+#include <proto/intuition.h>
+#include <proto/mathffp.h>
+#include <proto/mathtrans.h>
+#include <exec/memory.h>
+#include <graphics/gfx.h>
+
+#include "Bobi.h"
+#include "BobStructure.h"
+#include "ByteMap.h"
+#include "RotateWindow.h"
+
+#define PI 3.14159265358979323846
+
+extern struct MyBob *BobTable[];
+extern struct Screen *mainscreen;
+extern struct RastPort *mainrastport;
+extern UWORD mainpalette[];
+extern WORD actbobnum,mainx0,mainy0;
+
+/*************************************************************************/
+
+static void RotateBobs(register LONG numframes, register LONG totangle)
+{
+	struct ByteMap *sbym,*dbym;
+	register struct BitMap *sbim,*dbim;
+	register WORD width,height;
+	register struct MyBob *bob,*sbob=BobTable[actbobnum];
+
+
+	if(sbob->Flags & BOBF_AUTOSIZE)
+	{
+		register float wq,hq;
+		wq = SPFlt(sbob->Width);  wq = SPMul(wq,wq);
+		hq = SPFlt(sbob->Height); hq = SPMul(hq,hq);
+		width = height = SPFix(SPSqrt(SPAdd(wq,hq)))+1;
+	}
+	else
+	{
+		width = sbob->Width; height = sbob->Height;
+	}
+
+	if(sbym=MakeByteMap(width,height))
+	{
+		if(dbym=MakeByteMap(width,height))
+		{
+			if(sbim=BobToBitMap(sbob))
+			{
+				if(dbim=MakeBitMap(width,height,sbob->Depth))
+				{
+					register LONG i;
+
+					BltBitMap(sbim,0,0,dbim,(width-sbob->Width)/2,
+						(height-sbob->Height)/2,sbob->Width,sbob->Height,0xc0,0xff,0);
+					BitMapToByteMap(dbim,sbym);
+					for(i=numframes; i>0; --i)
+					{
+						register float winkel;
+						register LONG si,co;
+
+						winkel = SPMul((float)(totangle*i)/numframes,PI/180.0);
+						si = SPFix(SPMul(SPSin(winkel),1024.0)); /* 10 Dualstellen */
+						co = SPFix(SPMul(SPCos(winkel),1024.0));
+
+						RotateByteMap(sbym,dbym,width/2,height/2,si,co);
+						ByteMapToBitMap(dbym,dbim);
+
+						if(bob=BitMapToBob(sbob,dbim,width))
+						{
+							ShowBob(bob);
+							InsertBob(bob,(WORD)(actbobnum+1));
+						}
+						else
+						{
+							ShowMonoReq2("No memory for new bobs,\nrotation cancelled.");
+							break;
+						}
+					}
+					MyFreeBitMap(dbim);
+				}
+				else ShowMonoReq2("Not enough memory for rotate!");
+				MyFreeBitMap(sbim);
+			}
+			else ShowMonoReq2("Not enough memory for rotate!");
+			FreeByteMap(dbym);
+		}
+		else ShowMonoReq2("Not enough memory for rotate!");
+		FreeByteMap(sbym);
+	}
+	else ShowMonoReq2("Not enough memory for rotate!");
+}
+
+/*************************************************************************/
+
+void RotateFunc()
+{
+	register struct Window *w;
+
+	if(!BobTable[actbobnum])
+	{
+		ShowMonoReq2("Select a bob to rotate!");
+		return;
+	}
+
+	LockWindows();
+	NewWindowStructure1.Screen = mainscreen;
+	if(w=OpenWindow(&NewWindowStructure1))
+	{
+		register WORD flag = 0;
+
+		do
+		{
+			register struct IntuiMessage *msg;
+
+			WaitPort(w->UserPort);
+			msg=(struct IntuiMessage *)GetMsg(w->UserPort);
+			if(msg->Class == CLOSEWINDOW)
+			{
+				flag = -1;
+			}
+			else if(msg->Class == GADGETUP)
+			{
+				if(msg->IAddress == (APTR)&OKGadget)
+				{
+						flag = 1;
+				}
+				else if(msg->IAddress == (APTR)&CancelGadget)
+				{
+						flag = -1;
+				}
+			}
+		} while(!flag);
+		CloseWindow(w);
+		LoadPalette(mainpalette);
+
+		if(flag>0)
+		{
+			register LONG i;
+			register struct MyBob *bob;
+
+			RotateBobs(FramesGadgetSInfo.LongInt,AngleGadgetSInfo.LongInt);
+
+			for(i=1; i<=FramesGadgetSInfo.LongInt; ++i)
+			{
+				if(bob=AutoResizeBob(BobTable[actbobnum+i]))
+				{
+					FreeBob(BobTable[actbobnum+i]);
+					BobTable[actbobnum+i] = bob;
+					ShowBob(bob);
+				}
+				else ShowMonoReq2("Rotate:noresize");
+			}
+		}
+	}
+	UnLockWindows();
+}
+
+/*************************************************************************/
+
+static void FlipXYBob(BOOL xflag)
+{
+	register struct MyBob *bob;
+	register struct BitMap *bim;
+	struct ByteMap *bym;
+	register struct MyBob *flippedbob;
+
+	if(bob=BobTable[actbobnum])
+	{
+		if(bim=BobToBitMap(bob))
+		{
+			if(bym=MakeByteMap(bob->Width,bim->Rows))
+			{
+				BitMapToByteMap(bim,bym);
+				if(xflag)
+				{
+					FlipXByteMap(bym);
+					bob->X0 = bob->Width-bob->X0;
+	/*				if(bob->X0 < 0) bob->X0 = 0;
+	*/			}
+				else
+				{
+					FlipYByteMap(bym);
+					bob->Y0 = bob->Height-bob->Y0;
+	/*				if(bob->Y0 < 0) bob->Y0 = 0;
+	*/			}
+				ByteMapToBitMap(bym,bim);
+				FreeByteMap(bym);
+				if(flippedbob=BitMapToBob(bob,bim,bob->Width))
+				{
+					FreeBob(bob);
+					BobTable[actbobnum]=flippedbob;
+				}
+				else ShowMonoReq2("No memory to flip bob!");
+			}
+			else ShowMonoReq2("No memory to flip bob!");
+			MyFreeBitMap(bim);
+		}
+		else ShowMonoReq2("No memory to flip bob!");
+	}
+	else ShowMonoReq2("Select a bob to flip, you fool!");
+}
+
+/*************************************************************************/
+
+void FlipXFunc(void) { FlipXYBob(TRUE);  }
+void FlipYFunc(void) { FlipXYBob(FALSE); }
+
diff --git a/RotateWindow.h b/RotateWindow.h
new file mode 100644
index 0000000..6c0a990
--- /dev/null
+++ b/RotateWindow.h
@@ -0,0 +1,202 @@
+
+static UBYTE FramesGadgetSIBuff[5] =
+	"36";
+static struct StringInfo FramesGadgetSInfo = {
+	FramesGadgetSIBuff,
+	NULL,
+	0,
+	5,
+	0,
+	0,0,0,0,0,
+	0,
+	36,
+	NULL
+};
+
+static SHORT BorderVectors1[] = {
+	0,0,
+	174,0,
+	174,12,
+	0,12,
+	0,1
+};
+static struct Border Border1 = {
+	-1,-3,
+	3,0,JAM1,
+	5,
+	BorderVectors1,
+	NULL
+};
+
+static struct IntuiText IText1 = {
+	3,0,JAM1,
+	4,0,
+	NULL,
+	"# of Frames",
+	NULL
+};
+
+static struct Gadget FramesGadget = {
+	NULL,
+	6,34,
+	173,11,
+	NULL,
+	RELVERIFY+STRINGRIGHT+LONGINT,
+	STRGADGET,
+	(APTR)&Border1,
+	NULL,
+	&IText1,
+	NULL,
+	(APTR)&FramesGadgetSInfo,
+	NULL,
+	NULL
+};
+
+static UBYTE AngleGadgetSIBuff[5] =
+	"360";
+static struct StringInfo AngleGadgetSInfo = {
+	AngleGadgetSIBuff,
+	NULL,
+	0,
+	5,
+	0,
+	0,0,0,0,0,
+	0,
+	360,
+	NULL
+};
+
+static SHORT BorderVectors2[] = {
+	0,0,
+	174,0,
+	174,12,
+	0,12,
+	0,1
+};
+static struct Border Border2 = {
+	-1,-3,
+	3,0,JAM1,
+	5,
+	BorderVectors2,
+	NULL
+};
+
+static struct IntuiText IText2 = {
+	3,0,JAM1,
+	4,0,
+	NULL,
+	"Angle (Total)",
+	NULL
+};
+
+static struct Gadget AngleGadget = {
+	&FramesGadget,
+	6,17,
+	173,11,
+	NULL,
+	RELVERIFY+STRINGRIGHT+LONGINT,
+	STRGADGET,
+	(APTR)&Border2,
+	NULL,
+	&IText2,
+	NULL,
+	(APTR)&AngleGadgetSInfo,
+	NULL,
+	NULL
+};
+
+static SHORT BorderVectors3[] = {
+	0,0,
+	81,0,
+	81,12,
+	0,12,
+	0,0
+};
+static struct Border Border3 = {
+	-1,-1,
+	1,0,JAM1,
+	5,
+	BorderVectors3,
+	NULL
+};
+
+static struct IntuiText IText3 = {
+	1,0,JAM1,
+	16,2,
+	NULL,
+	"ROTATE",
+	NULL
+};
+
+static struct Gadget OKGadget = {
+	&AngleGadget,
+	6,-15,
+	80,11,
+	GRELBOTTOM,
+	RELVERIFY,
+	BOOLGADGET,
+	(APTR)&Border3,
+	NULL,
+	&IText3,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+static SHORT BorderVectors4[] = {
+	0,0,
+	81,0,
+	81,12,
+	0,12,
+	0,0
+};
+static struct Border Border4 = {
+	-1,-1,
+	31,0,JAM1,
+	5,
+	BorderVectors4,
+	NULL
+};
+
+static struct IntuiText IText4 = {
+	31,0,JAM1,
+	16,2,
+	NULL,
+	"CANCEL",
+	NULL
+};
+
+static struct Gadget CancelGadget = {
+	&OKGadget,
+	-85,-15,
+	80,11,
+	GRELBOTTOM+GRELRIGHT,
+	RELVERIFY,
+	BOOLGADGET,
+	(APTR)&Border4,
+	NULL,
+	&IText4,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+#define GadgetList1 CancelGadget
+
+static struct NewWindow NewWindowStructure1 = {
+	63,39,
+	185,70,
+	0,1,
+	GADGETUP+CLOSEWINDOW,
+	WINDOWDRAG+WINDOWDEPTH+WINDOWCLOSE+ACTIVATE+NOCAREREFRESH,
+	&CancelGadget,
+	NULL,
+	"   Rotate Bobs   ",
+	NULL,
+	NULL,
+	5,5,
+	(UWORD)-1,(UWORD)-1,
+	CUSTOMSCREEN
+};
diff --git a/SCOPTIONS b/SCOPTIONS
new file mode 100644
index 0000000..504d97c
--- /dev/null
+++ b/SCOPTIONS
@@ -0,0 +1,24 @@
+MATH=FFP
+PARAMETERS=REGISTERS
+NOSTACKCHECK
+STRINGMERGE
+UNSIGNEDCHARS
+STRUCTUREEQUIVALENCE
+OPTIMIZE
+MAP
+MAPHUNK
+MAPSYMBOLS
+MAPLIB
+MAPXREFERENCE
+MAPOVERLAY
+NOVERSION
+NOICONS
+MEMORYSIZE=HUGE
+INCLUDEDIR=SC:Include
+INCLUDEDIR=INCUSR:
+DEFINE __USE_SYSBASE
+CODENAME=text
+DATANAME=data
+BSSNAME=bss
+MAPFILE=RAM:slink.map
+MAXIMUMWARNINGS=50
diff --git a/ShowRequest.c b/ShowRequest.c
new file mode 100644
index 0000000..a995a41
--- /dev/null
+++ b/ShowRequest.c
@@ -0,0 +1,293 @@
+/**************************************************************************
+**                                                                       **
+**   ShowRequest  -  Super-Requester unter dem Mauspfeil ausgeben        **
+**                                                                       **
+*+   Original version by René Straub 18-Jul-89                           +*
+*+                                                                       +*
+*+   Modification History:                                               +*
+*+   --------------------                                                +*
+*+                                                                       +*
+*+   23-Jul-89  CHW  Created this file (99% rewritten :-)                +*
+*+   08-Aug-89  CHW  Zulange Textzeilen werden automatisch getrennt      +*
+*+   06-Oct-89  CHW  ShowMonoReq() hier hereingenommen                   +*
+*+   31-Oct-89  CHW  ToUpper-Bug bei VANILLAKEY fixed                    +*
+*+   04-Nov-89  CHW  ToUpper-Bug bei VANILLAKEY really fixed, Amiga-v/b  +*
+*+   05-Nov-89  CHW  No more gurus if word longer than 1 line            +*
+*+   18-Jul-90  CHW  itext->Font is now set for IntuiTextLength()        +*
+*+   02-Nov-93  CHW  Benutzt jetzt strlen statt StrLen (->Bobi)          +*
+*+                                                                       +*
+***************************************************************************
+**                                                                       **
+**   Parameter :  A0.L :  Zeiger auf Text, Linien durch \n getrennt      **
+**                A1.L :  Zeiger auf PosText                             **
+**                A2.L :  Zeiger auf NegText                             **
+**                D0.W :  Bit  0: 1=Default PosText, 0=Default NegText   **
+**                        Bit 15: 1=Text hat Schatten, 0=normal          **
+**                                                                       **
+**   Resultat :   D0.L :  0=NegText angewählt, 1=PosText angewählt       **
+**                                                                       **
+**************************************************************************/
+
+/* #define DEBUG */
+
+#include <proto/exec.h>
+#include <proto/intuition.h>
+#include <proto/graphics.h>
+#include <exec/memory.h>
+#include <intuition/intuition.h>
+#include <intuition/intuitionbase.h>
+#include <libraries/dosextens.h>
+
+#include <string.h>
+
+#include "Bobi.h"
+
+
+extern struct IntuitionBase *IntuitionBase;
+
+#define reg register
+#define MAXTEXTLENGTH 160		/* Maximale Länge einer Textzeile */
+#define REQF_DEFAULT  1			/* Gadget unter dem Mauszeiger */
+#define REQF_SHADOW 0x8000		/* Text hat Schatten */
+
+struct MyIText
+{
+	struct IntuiText ShadowIText;
+	struct IntuiText IText;
+	char Text[MAXTEXTLENGTH];
+};
+
+/*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*/
+
+static BYTE alerttext[] = {
+	0, 24, 14,
+	'N','o',' ','m','e','m',' ','f','o','r',' ','r','e','q','u','e','s','t','e','r',
+	0, 0, 0
+};
+
+/*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*/
+
+static WORD PosBorderVecs[] = {	0,0, -1,0, -1,12, 0,12, 0,1 };
+static WORD NegBorderVecs[] = {	0,0, -1,0, -1,12, 0,12, 0,1 };
+
+static struct Border PosBorder = {
+	-3,-2,1,0,0,5,PosBorderVecs,NULL
+};
+static struct Border NegBorder = {
+	-3,-2,1,0,0,5,NegBorderVecs,NULL
+};
+
+static struct IntuiText PosIText = {
+	1,0,JAM1,2,1,NULL,NULL,NULL
+};
+static struct IntuiText NegIText = {
+	1,0,JAM1,2,1,NULL,NULL,NULL
+};
+
+static struct Gadget PosGadget = {
+	NULL,10,-1234,1234,1234,GRELBOTTOM,RELVERIFY,BOOLGADGET,
+	(APTR)&PosBorder,NULL,&PosIText,NULL,NULL,NULL,NULL
+};
+static struct Gadget NegGadget = {
+	&PosGadget,-1234,-1234,1234,1234,GRELBOTTOM|GRELRIGHT,RELVERIFY,BOOLGADGET,
+	(APTR)&NegBorder,NULL,&NegIText,NULL,NULL,NULL,NULL
+};
+
+/*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*/
+
+LONG ShowRequest(char *text, char *postext, char *negtext, ULONG flags)
+{
+	struct NewWindow nw;
+	struct Window *w,*prwindow;
+	struct Screen *s;
+	struct MyIText itext;
+	register struct MyIText *iptr=&itext;
+	UWORD poswidth,negwidth;
+	register LONG endflag=-1;
+
+	/* NewWindow-Struktur initialisieren */
+
+	ClearMem(&nw,sizeof(nw));
+	nw.Width=180;
+	nw.Height=4;
+
+	/* Zeiger auf Screen holen und nw entsprechend anpassen */
+
+	if (prwindow=(struct Window *)(((struct Process *)FindTask(0L))->pr_WindowPtr))
+	{
+		nw.DetailPen = prwindow->DetailPen;
+		nw.BlockPen  = prwindow->BlockPen;
+		nw.Screen= s = prwindow->WScreen;
+		nw.Type      = CUSTOMSCREEN;
+		ScreenToFront(s);
+	}
+	else
+	{
+		WBenchToFront();
+		nw.DetailPen = 0;
+		nw.BlockPen  = 1;
+		nw.Screen    = 0;
+		nw.Type      = WBENCHSCREEN;
+		s = IntuitionBase->FirstScreen;
+	}
+
+	/* Gadgets und IntuiTexts initialisieren */
+
+	itext.IText.NextText = 0;
+	NegIText.ITextFont   = s->Font;
+	PosIText.ITextFont   = s->Font;
+	NegIText.IText       = negtext;
+	PosIText.IText       = postext;
+	NegGadget.Width      = negwidth=IntuiTextLength(&NegIText)+4;
+	PosGadget.Width      = poswidth=IntuiTextLength(&PosIText)+4;
+	NegBorderVecs[2]     = NegBorderVecs[4] = negwidth+5;
+	PosBorderVecs[2]     = PosBorderVecs[4] = poswidth+5;
+	NegGadget.Height     = s->RastPort.TxHeight+2;
+	PosGadget.Height     = s->RastPort.TxHeight+2;
+	NegBorderVecs[5]     = NegBorderVecs[7]  = NegGadget.Height+3;
+	PosBorderVecs[5]     = PosBorderVecs[7]  = PosGadget.Height+3;
+	PosBorder.FrontPen   = PosIText.FrontPen = flags&REQF_DEFAULT ? 3:1;
+	NegBorder.FrontPen   = NegIText.FrontPen = flags&REQF_DEFAULT ? 1:3;
+	NegGadget.LeftEdge   = -negwidth-10;
+	NegGadget.TopEdge    = PosGadget.TopEdge = -NegGadget.Height-4;
+	NegGadget.NextGadget = postext?&PosGadget:0;	/* PosGadget ein/aus */
+
+	if(nw.Width < (negwidth+poswidth+18)) nw.Width=negwidth+poswidth+18;
+
+	do
+	{
+		register char *dptr;
+		register LONG ilen;
+
+		nw.Height += s->RastPort.TxHeight+2;
+		iptr->IText.NextText=AllocMem(sizeof(*iptr),MEMF_CLEAR);
+		if(!(iptr=(struct MyIText *)iptr->IText.NextText)) break;
+		iptr->ShadowIText.NextText = &(iptr->IText);
+		iptr->IText.LeftEdge       = 8;
+		iptr->ShadowIText.LeftEdge = 10;
+		iptr->IText.TopEdge        = nw.Height;
+		iptr->ShadowIText.TopEdge  = nw.Height+1;
+		iptr->IText.FrontPen       = 1;
+		iptr->ShadowIText.FrontPen = 2;
+		iptr->IText.IText=iptr->ShadowIText.IText=dptr=iptr->Text;
+
+		for(;;)
+		{
+			register ULONG olddptr=(ULONG)dptr,oldtext=(ULONG)text;
+
+			while((*dptr=*text) > ' ') { text++; dptr++; } *dptr=0;
+			if((ilen=TextLength(&s->RastPort,iptr->Text, strlen(iptr->Text)))
+				> (s->Width-20))
+			{
+				dptr=(char *)olddptr;
+				if(dptr!=iptr->Text) /* Falls nicht 1. Wort d.Zeile (überlang) */
+				{
+					*dptr=0; /* String vor nächstem Wort begrenzen */
+					text=(char *)oldtext-1; /* Source-Ptr zurückstellen */
+				}
+				break;
+			}
+			if(*text != ' ') break;
+			*dptr++=*text++;
+		}
+
+		if(ilen > nw.Width) nw.Width=ilen;
+		if(!(flags & REQF_SHADOW)) iptr->ShadowIText.IText=0;
+	}
+	while(*text++);
+	nw.Height += (s->RastPort.TxHeight<<1)+14;
+
+	nw.Width       += 16;
+	nw.LeftEdge    = flags&REQF_DEFAULT?s->MouseX-24:s->MouseX-nw.Width+24;
+	nw.TopEdge     = s->MouseY-nw.Height+12;
+	nw.IDCMPFlags  = GADGETUP|VANILLAKEY;
+	nw.Flags       = WINDOWDRAG+WINDOWDEPTH+ACTIVATE+NOCAREREFRESH+RMBTRAP;
+	nw.FirstGadget = &NegGadget;
+	nw.Title       = "Click to continue";
+	nw.Screen      = s;
+
+	if(nw.Width  > s->Width)  nw.Width =s->Width;
+	if(nw.Height > s->Height) nw.Height=s->Height;
+
+
+	/* Randbegrenzungen abfragen */
+	{
+		register WORD maxx0=s->Width-nw.Width,maxy0=s->Height-nw.Height;
+
+		if(nw.LeftEdge<0)     nw.LeftEdge = 0;
+		if(nw.TopEdge<0)      nw.TopEdge  = 0;
+		if(nw.LeftEdge>maxx0) nw.LeftEdge = maxx0;
+		if(nw.TopEdge>maxy0)  nw.TopEdge  = maxy0;
+	}
+
+	if(w=OpenWindow(&nw))
+	{
+		register struct IntuiMessage *msg;
+		register LONG code;
+
+		/* Pos/NegText raufsetzen, damit Taste geht wenn's Spaces davor hat */
+
+		if(postext) while(*postext <= ' ') postext++;
+		while(*negtext <= ' ') negtext++;
+
+		PrintIText(w->RPort,itext.IText.NextText,0,0);
+		do
+		{
+			WaitPort(w->UserPort);
+			msg  = (struct IntuiMessage *)GetMsg(w->UserPort);
+			code = msg->Code;
+
+			switch(msg->Class)
+			{
+				case VANILLAKEY:
+					code &= 0xDF;	/* ToUpper */
+					if(msg->Qualifier & AMIGALEFT)
+					{
+						if(code=='V') endflag=TRUE;
+						if(code=='B') endflag=FALSE;
+						break;
+					}
+					if(!postext) { endflag=FALSE; break; }
+					if(code==13) { endflag=flags&REQF_DEFAULT; }
+					if(code==(*postext&0xDF)) endflag=TRUE;
+					if(code==(*negtext&0xDF)) endflag=FALSE;
+					break;
+
+				default: /* case GADGETUP: */
+					endflag = (msg->IAddress==(APTR)&PosGadget);
+					break;
+			}
+			ReplyMsg((struct Message *)msg);
+		}	
+		while(endflag<0);
+		CloseWindow(w);
+	}
+	else
+	{
+#ifdef DEBUG
+		for(iptr=(struct MyIText *)itext.IText.NextText; iptr; iptr=(struct MyIText *)iptr->IText.NextText)
+		{
+			printf("'%s'\n",iptr->IText.IText);
+		}
+		printf("\nWindow: %ld/%ld %ld/%ld\n",nw.LeftEdge,nw.TopEdge,nw.Width,nw.Height);
+#endif
+		DisplayAlert(0,alerttext,24);
+		endflag=FALSE;
+	}
+
+	for(iptr=(struct MyIText *)itext.IText.NextText; iptr;)
+	{
+		register struct MyIText *temp=iptr;
+		iptr = (struct MyIText *)iptr->IText.NextText;
+		FreeMem(temp,sizeof(*temp));
+	}
+
+	return endflag;
+}
+
+/*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*/
+
+void __regargs ShowMonoReq(char *text)
+{
+	ShowRequest(text,0," OK ",REQF_SHADOW);
+}
diff --git a/Sleep.c b/Sleep.c
new file mode 100644
index 0000000..550f932
--- /dev/null
+++ b/Sleep.c
@@ -0,0 +1,56 @@
+#include <proto/exec.h>
+#include <proto/intuition.h>
+#include <graphics/gfxbase.h>
+#include <string.h>
+
+#include "Bobi.h"
+
+extern struct GfxBase	*GfxBase;
+extern struct Screen	*mainscreen;
+extern char				idstring[];
+extern UWORD			mainpalette[];
+extern ULONG			rexxsigmask;
+
+/****************************************************************************
+**	Screen und so schliessen und schlafen gehn
+*/
+
+void SleepFunc(void)
+{
+	struct Screen *wb;
+
+	static struct NewWindow NewW =
+	{
+		-1,-1,-1,-1,0,1,CLOSEWINDOW,
+		WINDOWDRAG+WINDOWDEPTH+WINDOWCLOSE+NOCAREREFRESH,
+		NULL,NULL,idstring,NULL,NULL,0,0,(UWORD)-1,(UWORD)-1,WBENCHSCREEN
+	};
+
+	if(wb=(void *)OpenWorkBench())
+	{
+		struct Window *w;
+
+		if(NewW.LeftEdge<0)
+		{
+			NewW.Width    = 85+8*strlen(idstring);
+			NewW.Height   = wb->RastPort.TxHeight+3;
+			NewW.LeftEdge = wb->Width-NewW.Width;
+			NewW.TopEdge  = wb->Height-NewW.Height;
+		}
+
+		if(w=OpenWindow(&NewW))
+		{
+			Cleanup(FALSE);
+			Wait(SIGMASK(w)|rexxsigmask);
+			NewW.LeftEdge = w->LeftEdge;
+			NewW.TopEdge  = w->TopEdge;
+			CloseWindow(w);
+			OpenMain();
+			LoadPalette(mainpalette);
+			RexxMsgHandler();
+		}
+		else ShowMonoReq2("Can't open sleep window!");
+	}
+	else ShowMonoReq2("Can't open the Workbench screen!");
+}
+
diff --git a/Snooze.S b/Snooze.S
new file mode 100644
index 0000000..44e9737
--- /dev/null
+++ b/Snooze.S
@@ -0,0 +1,95 @@
+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*
+*+                                                                       +*
+*+   Snooze  -  ZZ-Mauszeiger setzen/löschen                             +*
+*+                                                                       +*
+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*
+*+                                                                       +*
+*+   Modification History:                                               +*
+*+   --------------------                                                +*
+*+                                                                       +*
+*+   17-Dec-87  CHW  Created this file!                                  +*
+*+   20-Jan-90  CHW  Uses w->UserData instead of static var -> reentrant +*
+*+                                                                       +*
+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*
+
+		IDNT	Snooze
+		SECTION	text,CODE
+
+		INCLUDE	"exec/macros.i"
+		INCLUDE "intuition/intuition.i"
+
+
+		XREF	_IntuitionBase
+		XDEF	@Snooze,@UnSnooze
+
+
+**************************************************************************
+**                                                                      **
+**   Snooze   -  Mauszeiger für bestimmtes Window auf zz setzen         **
+**               und Menus abschalten                                   **
+**                                                                      **
+**   WARNUNG: Benutzt wd_UserData als Zwischenspeicher für MenuStrip    **
+**                                                                      **
+**   Parameter :  A0.L :  Adresse der Window-Struktur                   **
+**   Resultat  :  ALLE REGISTER BLEIBEN ERHALTEN                        **
+**                                                                      **
+**************************************************************************
+
+@Snooze:	movem.l	d0-d3/a0-a2/a6,-(SP)
+		movea.l	a0,a2			; A2 :  WindowPtr
+
+	*+* Snooze-Pointer anzeigen
+
+		movea.l	a2,a0			; Window
+		lea	SnoozeDaten,a1		; Snooze-Pointer
+		moveq	#24,d0			; Height
+		moveq	#16,d1			; Width
+		moveq	#-8,d2			; Xoffset
+		moveq	#-3,d3			; Yoffset
+		movea.l	_IntuitionBase,a6
+		JSRLIB	SetPointer
+
+98$:		movea.l	a2,a0			; Window
+		move.l	wd_MenuStrip(a0),wd_UserData(a0)
+		JSRLIB	ClearMenuStrip		; Menus disable
+
+99$:		movem.l	(SP)+,d0-d3/a0-a2/a6
+		rts
+
+
+**************************************************************************
+**                                                                      **
+**   UnSnooze  -  Mauszeiger für bestimmtes Window wieder zurücksetzen  **
+**                und Menus wieder anschalten                           **
+**                                                                      **
+**   Parameter :  A0.L :  Adresse der Window-Struktur                   **
+**   Resultat  :  ALLE REGISTER BLEIBEN ERHALTEN                        **
+**                                                                      **
+**************************************************************************
+
+@UnSnooze:	movem.l	d0-d1/a0-a2/a6,-(SP)
+		movea.l	a0,a2
+		movea.l	_IntuitionBase,a6
+		JSRLIB	ClearPointer
+		movea.l	a2,a0			; Window
+		movea.l	wd_UserData(a2),a1	; Geretteter MenuStrip
+		JSRLIB	SetMenuStrip
+
+		movem.l	(SP)+,d0-d1/a0-a2/a6
+		rts
+
+
+		SECTION	datachip,DATA_C
+
+SnoozeDaten:	dc.w	$0000,$0000
+		dc.w	$0600,$0000,$0F40,$0600,$3FE0,$0F40
+		dc.w	$7FF0,$3FE0,$FFF0,$7FE0,$E1F8,$7FF0
+		dc.w	$FBFC,$7FF8,$F7FC,$FFF8,$E1FE,$7FFC
+		dc.w	$FF0E,$7FFC,$7FDE,$3FFE,$FFBE,$7FFC
+		dc.w	$7F0E,$3FFC,$3FFC,$1FF8,$1FF8,$07F0
+		dc.w	$07F0,$01C0,$0FC0,$0700,$1FE0,$0FC0
+		dc.w	$0FC0,$0680,$07C0,$0000,$03E0,$01C0
+		dc.w	$07F0,$03E0,$03E0,$00C0,$00C0,$0000
+		dc.w	$0000,$0000
+
+		END
diff --git a/Startup.S b/Startup.S
new file mode 100644
index 0000000..503bc3f
--- /dev/null
+++ b/Startup.S
@@ -0,0 +1,406 @@
+*****************************************************************************
+**                                                                         **
+**   S T A R T U P  -  Universeller Startup-Code für Workbench und CLI     **
+**                                                                         **
+**              by Christian A. Weber, Zürich/Switzwerland                 **
+**                                                                         **
+*****************************************************************************
+**                                                                         **
+**   Universeller Startup-Code für CLI und WorkBench, öffnet die dos-      **
+**   library (DOSBase), schreibt Adresse unseres Tasks nach 'Process-      **
+**   Base'. Falls wir von der WorkBench gestartet wurden, wird die         **
+**   WorkBenchStartupMessage abgeholt und auf unser Directory ein Cur-     **
+**   rentDir() gemacht. Alle Register  bleiben erhalten (BCPL...),         **
+**   z.B. steht bei Start vom CLI in D0 die Länge der Argument-Zeile,      **
+**   und in A0 steht ein Zeiger darauf. Bei Start von der WorkBench        **
+**   steht in D0 eine 0 und in A0 ein Zeiger auf die WBStartupMessage.     **
+**                                                                         **
+**   Das Programm kann durch RTS beendet werden (ReturnCode D0) oder       **
+**   mittels der Routinen '@Exit' oder '@exit' (auch ReturnCode D0).       **
+**                                                                         **
+*****************************************************************************
+**                                                                         **
+**   Es existieren zur Zeit 3 verschiedene Versionen:                      **
+**                                                                         **
+**   Startup.o         -   Standard Startup-Code                           **
+**                                                                         **
+**   DetachStartup.o   -   Hängt sich vom CLI ab                           **
+**                         Die Stacksize des Prozesses kann beim Linken    **
+**                         mit DEFINE _STACKSIZE=12345 angegeben werden.   **
+**                                                                         **
+**   TinyStartup.o     -   Öffnet keine Windows, kein StdIn/Out/Err        **
+**                                                                         **
+*****************************************************************************
+**                                                                         **
+**   Modification History                                                  **
+**   --------------------                                                  **
+**                                                                         **
+**   07-Sep-87   V1.0   Project started                                    **
+**                                                                         **
+**   01-Feb-88   V1.5   Versteht nun Strings in Gänsefüßchen (tnx JMH)     **
+**   17-Jun-88   V1.6   'dos.library' moved from data to code segment      **
+**   12-Jul-88   V2.0   _CliParse extracted to separate file, no stack     **
+**   16-Nov-88   V2.1   Gründlich aufgeräumt, ist jetzt nur in chw.lib     **
+**   21-Nov-88   V2.2   Default-StdWindowName added                        **
+**   02-Jan-88   V2.3   Default-StdWindowName wieder rausgeworfen          **
+**   06-Feb-89   V2.4   An neues Library-Konzept angepasst (Labelnamen)    **
+**   10-Feb-89   V2.5   Läuft nun auch mit Lattice asm und C               **
+**   12-Feb-89   V2.6   Läuft nun auch mit SmallCode Aztec C               **
+**   18-Mar-89   V3.0   Detach added (tnx CHH!)                            **
+**   02-Apr-89   V3.1   Lattice exit() has now registerized parameters     **
+**   25-Jun-89   V3.2   An Genim2 angepasst und gekürzt, Detach besser     **
+**   16-Jul-89   V3.3   Prozessname bei Detach stimmt wieder               **
+**   12-Aug-89   V3.4   stderr implementiert                               **
+**   25-Sep-89   V3.5   ARP version implementiert                          **
+**   03-Nov-89   V3.6   Tiny-Version (ohne stdin/out/err/window) impl.     **
+**   12-Jan-90   V3.7   ARP-Version von Exit rettet D2 (für result2)       **
+**   15-Jan-90   V3.8   ARP-Version in separaten Source verlegt            **
+**   21-Jul-90   V3.9   NewOS-Flag added (nicht im TinyStartup)            **
+**   22-Jul-90   V4.0   Öffnet GfxBase und IntuitionBase                   **
+**   05-May-91   V4.1   NewOS erst ab V37 (früher V36)                     **
+**   30-May-91   V4.2   _STACKSIZE von ARPStartup auch hier eingebaut      **
+**   21-Jul-91   V4.3   BSS-Bereich wird gelöscht -> kürzere Programme     **
+**   02-Apr-92   V4.4   Genam statt asm -> Detach läuft wieder             **
+**                                                                         **
+*****************************************************************************
+
+		IDNT	Startup
+		SECTION	text,CODE
+
+		INCLUDE	"exec/types.i"
+		INCLUDE	"exec/macros.i"
+		INCLUDE	"exec/execbase.i"
+		INCLUDE	"dos/dosextens.i"
+		INCLUDE	"workbench/startup.i"
+
+*****************************************************************************
+**  Referenzen
+
+		XREF	@Main		; Hauptprogramm, das aufgerufen wird
+
+		XREF	_LinkerDB	; Start des Datenbereichs
+		XREF	__BSSBAS	; Start des __MERGED BSS-Bereichs
+		XREF	__BSSLEN	; Länge in LONGS des __MERGED BSS-Bereichs
+
+	IFD DETACH
+		XREF	_STACKSIZE	; Grösse des Stapels
+	ENDC
+
+	IFND TINY
+		XREF	_StdWindowName	; Workbench-Window-Name, z.B. 'NIL:'
+	ENDC
+
+*****************************************************************************
+**  Definitionen
+
+		XDEF	_geta4		; A4 holen für Small Data
+		XDEF	@exit,@Exit	; Fehler-Ausgang
+		XDEF	_SysBase
+		XDEF	_DOSBase
+		XDEF	_ProcessBase	; Zeiger auf unseren Prozess
+	IFND TINY
+		XDEF	StdErr,_StdErr	; Immer CLI-Window oder WB-Window
+		XDEF	NewOS,_NewOS	; Flag ob Kick 2.x
+	ENDC
+
+*****************************************************************************
+**  Einsprung
+
+FirstByte:
+		bra.b	_WbStartup
+	;;	dc.w	$4AFC			; ARP Magic
+	;;	dc.l	_STACKSIZE		; ARP StackSize
+	;;	dc.l	0			; ARP data size if resident
+
+		dc.b	"CHW",0			; Für mein Ego :-)
+		dc.b	"4.4",0			; Startup-Version
+
+DOSName:	dc.b	"dos.library",0
+
+	*** A4 holen, Testen ob 2. Durchgang von Detach
+
+_WbStartup:	bsr	_geta4
+
+	IFD DETACH
+		tst.b	FirstTime(a4)		; 1. Mal hier ?
+		bne	SecondTime		; nein --->
+	ENDC
+
+	*** BSS-Bereich löschen
+
+		lea	__BSSBAS(a4),a3		; get base of BSS
+		move.l	#__BSSLEN,d3		; get length of BSS in longwords
+		bra.b	.ClearDBF		; and clear for length given
+.ClearLoop:	clr.l	(a3)+
+.ClearDBF:	dbf	d3,.ClearLoop
+
+	IFD DETACH
+		st.b	FirstTime(a4)		; Flag setzen (jaja erst hier :-( )
+	ENDC
+
+	*** D0/A0/SP retten, ExecBase und ThisTask holen
+
+		movem.l	d0/a0/a7,InitRegs(a4)
+		movea.l	(4).W,a6
+		move.l	a6,_SysBase(a4)
+		movea.l	ThisTask(a6),a3		; A3 :  Task/Process pointer
+
+	*** DOS öffnen, Verzweigung WorkBench/CLI
+
+		lea	DOSName(PC),a1
+		JSRLIB	OldOpenLibrary		; DOS-Bibliothek öffnen
+		movea.l	d0,a6			; A6 :  DOSBase
+		move.l	a6,_DOSBase(a4)
+	IFND TINY
+		cmpi.w	#36,LIB_VERSION(a6)
+		scc.b	NewOS(a4)		; Flag setzen falls Kick 2.x
+	ENDC
+		move.l	pr_CLI(a3),d0		; Vom CLI aufgerufen ?
+		beq	FromWorkBench		; nein --->
+
+*****************       *****************************************************
+**  Start vom CLI
+
+	*** Falls erwünscht detachen
+
+	IFD DETACH
+		lsl.l	#2,d0				; BPTR to APTR
+		movea.l	d0,a2				; A2 :  struct CLI
+		move.l	cli_Module(a2),CliSegList(a4)	; SegList retten
+		clr.l	cli_Module(a2)			; für CLI löschen
+
+		move.l	pr_CurrentDir(a3),d1		; Unser CurrentDir
+		JSRLIB	DupLock				; duplizieren
+		move.l	d0,ActDir(a4)			; und merken
+
+	*** Kommandozeile in unseren Buffer kopieren
+
+CopyCmdLine:	movea.l	InitialA0(a4),a0		; Original-ArgLine
+		lea	CommandLine,a1			; Unsere ArgLine
+		move.l	a1,InitialA0(a4)		; reinpatchen
+1$:		move.b	(a0),(a1)+			; char kopieren
+		beq.s	2$				; ---> fertig
+		cmpi.b	#10,(a0)+			; Endmarkierung ?
+		bne.b	1$				; nein ---> Loop
+2$:		clr.b	(a1)+				; Endmarkierung
+
+	*** Command-Name als Prozess-Name von BCPL nach CSTR konvertieren
+	*** a1 zeigt auf freien Platz für Tasknamen
+
+GetProcName:	move.l	a1,d1			; D1: Name für CreateProc()
+		move.l	cli_CommandName(a2),d0	; PrgName holen
+		beq.b	3$			; kein Name --->
+		lsl.l	#2,d0			; BPTR to APTR
+		movea.l	d0,a0
+		moveq.l	#0,d0
+		move.b	(a0)+,d0		; Länge des Strings holen
+		bra.b	2$			; für dbf
+1$:		move.b	(a0)+,(a1)+		; kopieren
+2$:		dbf	d0,1$
+		clr.b	(a1)			; mit NULL abschliessen
+3$:
+	*** Prozess kreieren und zurück zum CLI
+
+		moveq	#0,d2
+		move.b	LN_PRI(a3),d2		; D2: Priority
+		move.l	CliSegList(a4),d3	; D3: SegList, ist schon BPTR
+	;;	move.l	pr_StackSize(a3),d4	; D4: StackSize
+	;;	lsl.l	#2,d4			; Stimmt das ??
+		move.l	#_STACKSIZE,d4
+		JSRLIB	CreateProc		; Neuen prozess starten
+		moveq	#0,d0			; Zum CLI zurück
+EndDet:		rts
+
+	*** Einsprung des neuen Prozesses, hat schon _geta4 gemacht
+
+SecondTime:	move.l	SP,InitialSP(a4)
+		movea.l	_SysBase(a4),a6
+		movea.l	ThisTask(a6),a3		; Neue ProcessBase holen
+		movea.l	_DOSBase(a4),a6
+		move.l	ActDir(a4),d1		; Unser CurrentDir
+		JSRLIB	CurrentDir		; setzen
+
+		bra.b	Windy			; --->
+	ELSE
+
+	   IFND TINY
+		lea	StdErrName(PC),a0
+		move.l	a0,d1
+		move.l	#MODE_OLDFILE,d2
+		JSRLIB	Open
+		move.l	d0,_StdErr(a4)
+	   ENDC
+		bra.b	StartMain		; --->
+	ENDC
+
+*****************************************************************************
+**  Register A4 holen für small data
+
+_geta4:		lea	_LinkerDB,a4
+		rts
+
+*****************************************************************************
+**  Start von der Werkbank
+
+FromWorkBench:	movea.l	_SysBase(a4),a6
+		lea	pr_MsgPort(a3),a0
+		JSRLIB	WaitPort
+		lea	pr_MsgPort(a3),a0
+		JSRLIB	GetMsg
+		move.l	d0,WBenchMsg(a4)
+
+		clr.l	InitialD0(a4)		; D0 :  Null
+		move.l	d0,InitialA0(a4)	; A0 :  WBStartup-Message
+		movea.l	d0,a0			; Workbench Startup Message
+		movea.l	sm_ArgList(a0),a0	; erstes Argument: wir selbst!
+		move.l	wa_Lock(a0),d1		; Lock unseres Directories
+		movea.l	_DOSBase(a4),a6
+		JSRLIB	CurrentDir		; als Current Dir setzen
+
+Windy:
+	IFND TINY
+		move.l	#_StdWindowName,d1	; Zu öffnendes Dos-Fenster
+		move.l	#MODE_OLDFILE,d2
+		JSRLIB	Open			; Window öffnen
+		move.l	d0,OurWindow(a4)	; für Exit()
+	   IFND DETACH
+		move.l	d0,_StdErr(a4)
+	   ENDC
+		move.l	d0,pr_CIS(a3)		; für Input()
+		move.l	d0,pr_COS(a3)		; für Output()
+		lsl.l	#2,d0			; BPTR to APTR
+		movea.l	d0,a0
+		move.l	fh_Type(a0),pr_ConsoleTask(a3) ; für Open("*",mode);
+	ENDC
+
+****************        *****************************************************
+**  Hauptprogramm starten
+
+StartMain:	move.l	a3,ProcessBase(a4)	; für die Aussenwelt
+		movem.l	InitRegs(a4),d0/a0
+		jsr	@Main(PC)		; PROGRAMM AUSFÜHREN!
+
+	*** Programm-Termination durch Exit(val) oder return(val)
+
+@exit:
+@Exit:		bsr.b	_geta4
+	IFND DETACH
+		move.l	d0,d7			; return-code retten
+	ENDC
+		movea.l	InitialSP(a4),SP	; Stackpointer restaurieren
+
+	IFND TINY
+		movea.l	_DOSBase(a4),a6
+		move.l	OurWindow(a4),d1	; Fenster oder 0
+		beq.b	1$
+		JSRLIB	Close			; Fenster schliessen
+1$:
+	ENDC
+		move.l	WBenchMsg(a4),d2	; gibt's was zu beantworten?
+		beq.b	2$			; nein, CLI --->
+		movea.l	_SysBase(a4),a6
+		JSRLIB	Forbid			; sonst werden wir 'entladen' !
+		movea.l	d2,a1
+		JSRLIB	ReplyMsg
+	IFND TINY
+		bra.b	QuitnDie		; ---> raus!
+	ENDC
+2$:
+	IFND DETACH
+	   IFND TINY
+		move.l	_StdErr(a4),d1		; StdErr schliessen if CLI
+		movea.l	_DOSBase(a4),a6
+		JSRLIB	Close
+	   ENDC
+	ENDC
+
+****************        *****************************************************
+
+	*** Uns selber und unseren Lock freigeben falls degetacht (CLI)
+
+	IFD DETACH
+	;;	movea.l	ProcessBase(a4),a3
+	;;	clr.l	pr_CIS(a3)		; Input handle ungültig
+	;;	clr.l	pr_COS(a3)		; Output handle ungültig
+		movea.l	_DOSBase(a4),a6
+		move.l	ActDir(a4),d1
+		JSRLIB	UnLock			; Altes CD freigeben
+
+		move.l	CliSegList(a4),d1	; Uns selbst
+		JMPLIB	UnLoadSeg		; freigeben
+		* NOT REACHED
+	ENDC
+
+*****************************************************************************
+**  Returncode von D7 holen und Programm beenden
+
+QuitnDie:	move.l	d7,d0			; return-code
+		rts				; ZURÜCK ZUM DOS!
+
+*****************************************************************************
+
+	IFND DETACH
+	   IFND TINY
+StdErrName:	dc.b	"*",0
+	   ENDC
+	ENDC
+
+*****************************************************************************
+
+		SECTION	__MERGED,DATA
+
+; Anscheinend darf die Data-Size im __MERGED-Segment nicht 0 sein, sonst
+; erzeugt der Linker einen BSS-Hunk mit Länge 0 im Hunk und Länge 20 im
+; Header (?!)
+
+_DOSBase:
+DOSBase:	ds.l	1	; wird hier geöffnet & geschlossen
+
+
+		SECTION	__MERGED,BSS
+
+_SysBase:	ds.l	1
+
+_ProcessBase:
+ProcessBase:	ds.l	1	; Address of this process
+
+WBenchMsg:	ds.l	1	; Startup-Message oder NULL
+
+
+	IFND TINY
+_StdErr:			; MUSS vor OurWindow stehen, weil if ..
+StdErr:				; .. detach, StdErr=OurWindow
+	   IFND DETACH
+		ds.l	1	; Standard Error FileHandle
+	   ENDC
+
+OurWindow:	ds.l	1	; Zeiger auf unser Window oder NULL
+
+_NewOS:
+NewOS:		ds.l	1	; Flag ob Kick 2.x
+	ENDC
+
+
+InitRegs:			; Die 3 geretteten Register D0/A0/SP:
+InitialD0:	ds.l	1
+InitialA0:	ds.l	1
+InitialSP:	ds.l	1
+
+	IFD DETACH
+
+CliSegList:	ds.l	1	; Unsere Segmentliste
+ActDir:		ds.l	1	; Lock auf unser Current Directory
+FirstTime:	ds.l	1	; Flag ob 1. Mal durch
+
+	ENDC
+
+
+	IFD DETACH
+
+		SECTION	bss,BSS
+
+CommandLine:	ds.b	2100	; Kommandozeile und Task-Name
+
+	ENDC
+
+		END
diff --git a/Stubs.c b/Stubs.c
new file mode 100644
index 0000000..fab0209
--- /dev/null
+++ b/Stubs.c
@@ -0,0 +1,93 @@
+#include <proto/exec.h>
+#include <proto/intuition.h>
+#include <proto/dos.h>
+
+#include "Bobi.h"
+
+extern struct NewWindow ToolNW;
+extern struct Screen *mainscreen;
+extern struct Window *mainwindow,*toolwindow;
+extern struct RastPort *toolrastport;
+extern WORD mainpalette[];
+extern struct MenuItem ToolWindowMenuItem;
+
+/*************************************************************************/
+
+void ClearAllFunc()
+{
+	if(ShowRequest2("Do you really want to\ndelete all bobs?","OF COURSE!"))
+		ClearAll();
+}
+
+/*************************************************************************/
+
+void QuitFunc()
+{
+	if(ShowRequest2("Do you really want to quit ?","JAJA!"))
+		Cleanup(TRUE);
+	else ShowMonoReq2("Da hast du nochmals Glück gehabt!");
+}
+
+/*************************************************************************/
+
+void GrabDPaintFunc()
+{
+	ShowMonoReq2("Can't find the DPaint screen :-)");
+}
+
+/*************************************************************************/
+
+void GrabScreenFunc()
+{
+	ShowMonoReq2("Sorry, this function will\nnever be implemented!");
+}
+
+/*************************************************************************/
+
+void SaveIFFAnimFunc()
+{
+	ShowMonoReq2("Sorry, this function is not\nyet implemented!");
+}
+
+/*************************************************************************/
+
+void EditPaletteFunc()
+{
+	Snooze(mainwindow);		/* nicht LockWindows() wegen Farbpalette! */
+	if(toolwindow) Snooze(toolwindow);
+	CopyMem(RequestColor(mainscreen),mainpalette,2*32);
+	if(toolwindow) UnSnooze(toolwindow);
+	UnSnooze(mainwindow);
+}
+
+/*************************************************************************/
+
+void ToolWindowFunc()
+{
+	if(ToolWindowMenuItem.Flags & CHECKED)
+	{
+		if(!toolwindow)
+		{
+			ToolNW.Screen  = mainscreen;
+			if(ToolNW.TopEdge>mainscreen->Height-ToolNW.Height)
+				ToolNW.TopEdge=mainscreen->Height-ToolNW.Height;
+			if(!(toolwindow = OpenWindow(&ToolNW)))
+			{
+				ShowMonoReq2("Can't open tool window!\n");
+			}
+			toolrastport = toolwindow->RPort;
+		}
+	}
+	else
+	{
+		if(toolwindow)
+		{
+			ToolNW.TopEdge=toolwindow->TopEdge;
+			ClearMenuStrip(toolwindow);
+			CloseWindow(toolwindow);
+			toolwindow=0; toolrastport=0;
+			ActivateWindow(mainwindow);
+		}
+	}
+}
+
diff --git a/ToolWindow.h b/ToolWindow.h
new file mode 100644
index 0000000..dbfed27
--- /dev/null
+++ b/ToolWindow.h
@@ -0,0 +1,402 @@
+
+static UBYTE UNDOBUFFER[64];
+
+static SHORT BorderVectors4[] = {
+	0,0,
+	37,0,
+	37,10,
+	0,10,
+	0,0
+};
+static struct Border Border4 = {
+	135,-23280,
+	1,0,JAM1,
+	5,
+	BorderVectors4,
+	NULL
+};
+
+static SHORT BorderVectors3[] = {
+	0,0,
+	37,0,
+	37,10,
+	0,10,
+	0,0
+};
+static struct Border Border3 = {
+	95,-17624,
+	1,0,JAM1,
+	5,
+	BorderVectors3,
+	&Border4
+};
+
+static SHORT BorderVectors2[] = {
+	0,0,
+	37,0,
+	37,10,
+	0,10,
+	0,0
+};
+static struct Border Border2 = {
+	175,-3208,
+	1,0,JAM1,
+	5,
+	BorderVectors2,
+	&Border3
+};
+
+static SHORT BorderVectors1[] = {
+	0,0,
+	37,0,
+	37,10,
+	0,10,
+	0,0
+};
+static struct Border Border1 = {
+	215,-3072,
+	1,0,JAM1,
+	5,
+	BorderVectors1,
+	&Border2
+};
+
+static struct Gadget Gadget8 = {
+	NULL,
+	0,0,
+	1,1,
+	GADGHBOX+GADGHIMAGE,
+	NULL,
+	BOOLGADGET,
+	(APTR)&Border1,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+static UBYTE LabelGadgetSIBuff[64] =
+	"abcdefghhhhhhhhhhhk";
+static struct StringInfo LabelGadgetSInfo = {
+	LabelGadgetSIBuff,
+	UNDOBUFFER,
+	0,
+	64,
+	0,
+	0,0,0,0,0,
+	0,
+	0,
+	NULL
+};
+
+static SHORT BorderVectors5[] = {
+	0,0,
+	155,0,
+	155,10,
+	0,10,
+	0,1
+};
+static struct Border Border5 = {
+	-1,-2,
+	3,0,JAM1,
+	5,
+	BorderVectors5,
+	NULL
+};
+
+static struct IntuiText IText1 = {
+	3,0,JAM2,
+	28,-11,
+	NULL,
+	"Source Label:",
+	NULL
+};
+
+static struct Gadget LabelGadget = {
+	&Gadget8,
+	96,-13,
+	154,9,
+	GRELBOTTOM,
+	RELVERIFY,
+	STRGADGET,
+	(APTR)&Border5,
+	NULL,
+	&IText1,
+	NULL,
+	(APTR)&LabelGadgetSInfo,
+	NULL,
+	NULL
+};
+
+static SHORT BorderVectors6[] = {
+	0,0,
+	33,0,
+	33,21,
+	0,21,
+	0,0
+};
+static struct Border Border6 = {
+	-1,-1,
+	3,0,JAM1,
+	5,
+	BorderVectors6,
+	NULL
+};
+
+static struct IntuiText IText3 = {
+	1,0,JAM1,
+	4,11,
+	NULL,
+	"Org",
+	NULL
+};
+
+static struct IntuiText IText2 = {
+	1,0,JAM1,
+	4,2,
+	NULL,
+	"Set",
+	&IText3
+};
+
+static struct Gadget Gadget6 = {
+	&LabelGadget,
+	257,-25,
+	32,20,
+	GRELBOTTOM,
+	RELVERIFY,
+	BOOLGADGET,
+	(APTR)&Border6,
+	NULL,
+	&IText2,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+static SHORT BorderVectors7[] = {
+	0,0,
+	33,0,
+	33,21,
+	0,21,
+	0,0
+};
+static struct Border Border7 = {
+	-1,-1,
+	3,0,JAM1,
+	5,
+	BorderVectors7,
+	NULL
+};
+
+static struct IntuiText IText5 = {
+	1,0,JAM1,
+	4,11,
+	NULL,
+	"Bob",
+	NULL
+};
+
+static struct IntuiText IText4 = {
+	1,0,JAM1,
+	4,2,
+	NULL,
+	"Get",
+	&IText5
+};
+
+static struct Gadget Gadget5 = {
+	&Gadget6,
+	257,-50,
+	32,20,
+	GRELBOTTOM,
+	RELVERIFY,
+	BOOLGADGET,
+	(APTR)&Border7,
+	NULL,
+	&IText4,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+static struct PropInfo AnimSpeedGadgetSInfo = {
+	AUTOKNOB+FREEVERT,
+	-1,20755,
+	-1,4095,
+};
+
+static struct Image Image1 = {
+	0,12,
+	6,4,
+	0,
+	NULL,
+	0x0000,0x0000,
+	NULL
+};
+
+static struct Gadget AnimSpeedGadget = {
+	&Gadget5,
+	4,-51,
+	14,47,
+	GRELBOTTOM,
+	NULL,
+	PROPGADGET,
+	(APTR)&Image1,
+	NULL,
+	NULL,
+	NULL,
+	(APTR)&AnimSpeedGadgetSInfo,
+	NULL,
+	NULL
+};
+
+static SHORT BorderVectors8[] = {
+	0,0,
+	71,0,
+	71,11,
+	0,11,
+	0,0
+};
+static struct Border Border8 = {
+	-1,-1,
+	3,0,JAM1,
+	5,
+	BorderVectors8,
+	NULL
+};
+
+static struct IntuiText IText6 = {
+	1,0,JAM1,
+	4,1,
+	NULL,
+	"Anim Key",
+	NULL
+};
+
+static struct Gadget AnimKeyGadget = {
+	&AnimSpeedGadget,
+	21,-15,
+	70,10,
+	GRELBOTTOM+SELECTED,
+	RELVERIFY+TOGGLESELECT,
+	BOOLGADGET,
+	(APTR)&Border8,
+	NULL,
+	&IText6,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+static SHORT BorderVectors9[] = {
+	0,0,
+	71,0,
+	71,11,
+	0,11,
+	0,0
+};
+static struct Border Border9 = {
+	-1,-1,
+	3,0,JAM1,
+	5,
+	BorderVectors9,
+	NULL
+};
+
+static struct IntuiText IText7 = {
+	1,0,JAM1,
+	4,1,
+	NULL,
+	"Auto Org",
+	NULL
+};
+
+static struct Gadget AutoOrgGadget = {
+	&AnimKeyGadget,
+	21,-33,
+	70,10,
+	GRELBOTTOM+SELECTED,
+	RELVERIFY+TOGGLESELECT,
+	BOOLGADGET,
+	(APTR)&Border9,
+	NULL,
+	&IText7,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+static SHORT BorderVectors10[] = {
+	0,0,
+	71,0,
+	71,11,
+	0,11,
+	0,0
+};
+static struct Border Border10 = {
+	-1,-1,
+	3,0,JAM1,
+	5,
+	BorderVectors10,
+	NULL
+};
+
+static struct IntuiText IText8 = {
+	1,0,JAM1,
+	4,1,
+	NULL,
+	"AutoSize",
+	NULL
+};
+
+static struct Gadget AutoSizeGadget = {
+	&AutoOrgGadget,
+	21,-50,
+	70,10,
+	GRELBOTTOM+SELECTED,
+	RELVERIFY+TOGGLESELECT,
+	BOOLGADGET,
+	(APTR)&Border10,
+	NULL,
+	&IText8,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+#define GadgetList1 AutoSizeGadget
+
+static struct NewWindow NewWindowStructure1 = {
+	0,61,
+	295,65,
+	0,1,
+	MOUSEBUTTONS+GADGETDOWN+GADGETUP+MENUPICK+RAWKEY,
+	WINDOWDRAG+WINDOWCLOSE+REPORTMOUSE+ACTIVATE+NOCAREREFRESH,
+	&AutoSizeGadget,
+	NULL,
+	"Bobi Tool Window",
+	NULL,
+	NULL,
+	0,0,
+	0,0,
+	CUSTOMSCREEN
+};
+
+
+void HandleEvent(object)
+APTR object;
+{
+  if (object == (APTR)&Gadget5) { GetBobFunc(      ); return; }
+  if (object == (APTR)&Gadget6) { SetOrgFunc(      ); return; }
+}
+#define HANDLEEVENT HandleEvent
+
+/* end of PowerWindows source generation */
diff --git a/Zoom.c b/Zoom.c
new file mode 100644
index 0000000..eb0d9fc
--- /dev/null
+++ b/Zoom.c
@@ -0,0 +1,152 @@
+#include <exec/types.h>
+#include <exec/memory.h>
+#include <graphics/gfx.h>
+#include <proto/exec.h>
+#include <proto/graphics.h>
+#include <proto/intuition.h>
+#include <proto/mathffp.h>
+#include <proto/mathtrans.h>
+
+#include "Bobi.h"
+#include "BobStructure.h"
+#include "ByteMap.h"
+#include "ZoomWindow.h"
+
+extern struct MyBob *BobTable[];
+extern struct Screen *mainscreen;
+extern struct RastPort *mainrastport;
+extern UWORD mainpalette[];
+extern WORD actbobnum,mainx0,mainy0;
+
+/*************************************************************************/
+
+static void ZoomBitMap(struct BitMap *bim, LONG faktor)
+{
+	register struct ByteMap *sbym,*dbym;	/* Source & Destination */
+
+	if(sbym=MakeByteMap((WORD)(bim->BytesPerRow*8),bim->Rows))
+	{
+		if(dbym=MakeByteMap((WORD)(bim->BytesPerRow*8),bim->Rows))
+		{
+			BitMapToByteMap(bim,sbym);
+			ZoomByteMap(sbym,dbym,faktor);
+			ByteMapToBitMap(dbym,bim);
+			FreeByteMap(dbym);
+		}
+		else ShowMonoReq2("No memory for zoom");
+		FreeByteMap(sbym);
+	}
+	else ShowMonoReq2("No memory for zoom");
+}
+
+/*************************************************************************/
+
+static struct MyBob *ZoomBob(struct MyBob *bob,register LONG faktor)
+{
+	register struct BitMap *sbim,*dbim;
+	register WORD width,height;
+
+	if((bob->Flags & BOBF_AUTOSIZE) && (faktor>100))
+	{
+		width  = (bob->Width*faktor)/100+1;
+		height = (bob->Height*faktor)/100+1;
+	}
+	else
+	{
+		width = bob->Width; height = bob->Height;
+	}
+
+	if(sbim=BobToBitMap(bob))
+	{
+		if(dbim=MakeBitMap(width,height,bob->Depth))
+		{
+			BltBitMap(sbim,0,0,dbim,(width-bob->Width)/2,
+				(height-bob->Height)/2,bob->Width,bob->Height,0xc0,0xff,0);
+			ZoomBitMap(dbim,faktor);
+			bob=BitMapToBob(bob,dbim,width);
+			MyFreeBitMap(dbim);
+		}
+		else bob = 0;
+		MyFreeBitMap(sbim);
+	}
+	else bob = 0;
+	return(bob);
+}
+
+/*************************************************************************/
+
+void ZoomFunc()
+{
+	register struct Window *w;
+	register WORD flag = 0;
+	register LONG i,increment;
+
+	if(BobTable[actbobnum])
+	{
+		LockWindows();
+		NewWindowStructure1.Screen = mainscreen;
+		if(w=OpenWindow(&NewWindowStructure1))
+		{
+			do
+			{
+				register struct IntuiMessage *msg;
+
+				WaitPort(w->UserPort);
+				msg=(struct IntuiMessage *)GetMsg(w->UserPort);
+				if(msg->Class == CLOSEWINDOW)
+				{
+					flag = -1;
+				}
+				else if(msg->Class == GADGETUP)
+				{
+					if(msg->IAddress == (APTR)&OKGadget)
+					{
+							flag = 1;
+					}
+					else if(msg->IAddress == (APTR)&CancelGadget)
+					{
+							flag = -1;
+					}
+				}
+			} while(!flag);
+			CloseWindow(w);
+			LoadPalette(mainpalette);
+
+			if(flag>0)
+			{
+				register struct MyBob *bob;
+
+				increment=LastGadgetSInfo.LongInt-FirstGadgetSInfo.LongInt;
+				increment/=FramesGadgetSInfo.LongInt;
+
+				for(i=0; i<FramesGadgetSInfo.LongInt; ++i)
+				{
+					if(bob=ZoomBob(BobTable[actbobnum],i*increment))
+					{
+						ShowBob(bob);
+						InsertBob(bob,(WORD)(actbobnum+i+1));
+					}
+					else
+					{
+						ShowMonoReq2("No memory for new bobs, Zoom aborted.");
+						break;
+					}
+				}
+
+				for(i=1; i<=FramesGadgetSInfo.LongInt; ++i)
+				{
+					if(bob=AutoResizeBob(BobTable[actbobnum+i]))
+					{
+						FreeBob(BobTable[actbobnum+i]);
+						BobTable[actbobnum+i] = bob;
+						ShowBob(bob);
+					}
+					else ShowMonoReq2("Zoom:noresize");
+				}
+			}
+		}
+		UnLockWindows();
+	}
+	else ShowMonoReq2("Select a bob to zoom!");
+}
+
diff --git a/ZoomWindow.h b/ZoomWindow.h
new file mode 100644
index 0000000..8fb6c1a
--- /dev/null
+++ b/ZoomWindow.h
@@ -0,0 +1,255 @@
+
+static UBYTE LastGadgetSIBuff[5] =
+	"200";
+static struct StringInfo LastGadgetSInfo = {
+	LastGadgetSIBuff,
+	NULL,
+	0,
+	5,
+	0,
+	0,0,0,0,0,
+	0,
+	200,
+	NULL
+};
+
+static SHORT BorderVectors1[] = {
+	0,0,
+	174,0,
+	174,12,
+	0,12,
+	0,1
+};
+static struct Border Border1 = {
+	-1,-3,
+	3,0,JAM1,
+	5,
+	BorderVectors1,
+	NULL
+};
+
+static struct IntuiText IText1 = {
+	3,0,JAM1,
+	4,0,
+	NULL,
+	"Last  (0-1000%)",
+	NULL
+};
+
+static struct Gadget LastGadget = {
+	NULL,
+	6,33,
+	173,11,
+	NULL,
+	RELVERIFY+STRINGRIGHT+LONGINT,
+	STRGADGET,
+	(APTR)&Border1,
+	NULL,
+	&IText1,
+	NULL,
+	(APTR)&LastGadgetSInfo,
+	NULL,
+	NULL
+};
+
+static UBYTE FramesGadgetSIBuff[5] =
+	"20";
+static struct StringInfo FramesGadgetSInfo = {
+	FramesGadgetSIBuff,
+	NULL,
+	0,
+	5,
+	0,
+	0,0,0,0,0,
+	0,
+	20,
+	NULL
+};
+
+static SHORT BorderVectors2[] = {
+	0,0,
+	174,0,
+	174,12,
+	0,12,
+	0,1
+};
+static struct Border Border2 = {
+	-1,-3,
+	3,0,JAM1,
+	5,
+	BorderVectors2,
+	NULL
+};
+
+static struct IntuiText IText2 = {
+	3,0,JAM1,
+	4,0,
+	NULL,
+	"# of Frames",
+	NULL
+};
+
+static struct Gadget FramesGadget = {
+	&LastGadget,
+	6,49,
+	173,11,
+	NULL,
+	RELVERIFY+STRINGRIGHT+LONGINT,
+	STRGADGET,
+	(APTR)&Border2,
+	NULL,
+	&IText2,
+	NULL,
+	(APTR)&FramesGadgetSInfo,
+	NULL,
+	NULL
+};
+
+static UBYTE FirstGadgetSIBuff[5] =
+	"0";
+static struct StringInfo FirstGadgetSInfo = {
+	FirstGadgetSIBuff,
+	NULL,
+	0,
+	5,
+	0,
+	0,0,0,0,0,
+	0,
+	0,
+	NULL
+};
+
+static SHORT BorderVectors3[] = {
+	0,0,
+	174,0,
+	174,12,
+	0,12,
+	0,1
+};
+static struct Border Border3 = {
+	-1,-3,
+	3,0,JAM1,
+	5,
+	BorderVectors3,
+	NULL
+};
+
+static struct IntuiText IText3 = {
+	3,0,JAM1,
+	4,0,
+	NULL,
+	"First (0-1000%)",
+	NULL
+};
+
+static struct Gadget FirstGadget = {
+	&FramesGadget,
+	6,17,
+	173,11,
+	NULL,
+	RELVERIFY+STRINGRIGHT+LONGINT,
+	STRGADGET,
+	(APTR)&Border3,
+	NULL,
+	&IText3,
+	NULL,
+	(APTR)&FirstGadgetSInfo,
+	NULL,
+	NULL
+};
+
+static SHORT BorderVectors4[] = {
+	0,0,
+	81,0,
+	81,12,
+	0,12,
+	0,0
+};
+static struct Border Border4 = {
+	-1,-1,
+	1,0,JAM1,
+	5,
+	BorderVectors4,
+	NULL
+};
+
+static struct IntuiText IText4 = {
+	1,0,JAM1,
+	24,2,
+	NULL,
+	"ZOOM",
+	NULL
+};
+
+static struct Gadget OKGadget = {
+	&FirstGadget,
+	6,-15,
+	80,11,
+	GRELBOTTOM,
+	RELVERIFY,
+	BOOLGADGET,
+	(APTR)&Border4,
+	NULL,
+	&IText4,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+static SHORT BorderVectors5[] = {
+	0,0,
+	81,0,
+	81,12,
+	0,12,
+	0,0
+};
+static struct Border Border5 = {
+	-1,-1,
+	31,0,JAM1,
+	5,
+	BorderVectors5,
+	NULL
+};
+
+static struct IntuiText IText5 = {
+	31,0,JAM1,
+	16,2,
+	NULL,
+	"CANCEL",
+	NULL
+};
+
+static struct Gadget CancelGadget = {
+	&OKGadget,
+	-85,-15,
+	80,11,
+	GRELBOTTOM+GRELRIGHT,
+	RELVERIFY,
+	BOOLGADGET,
+	(APTR)&Border5,
+	NULL,
+	&IText5,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+#define GadgetList1 CancelGadget
+
+static struct NewWindow NewWindowStructure1 = {
+	63,39,
+	185,82,
+	0,1,
+	GADGETUP+CLOSEWINDOW,
+	WINDOWDRAG+WINDOWDEPTH+WINDOWCLOSE+ACTIVATE+NOCAREREFRESH,
+	&CancelGadget,
+	NULL,
+	"    Zoom Bobs    ",
+	NULL,
+	NULL,
+	5,5,
+	(UWORD)-1,(UWORD)-1,
+	CUSTOMSCREEN
+};
diff --git a/pw/AboutWindow.pw b/pw/AboutWindow.pw
new file mode 100644
index 0000000..23ad3e2
--- /dev/null
+++ b/pw/AboutWindow.pw
diff --git a/pw/CHW.Brush b/pw/CHW.Brush
new file mode 100644
index 0000000..d17b82d
--- /dev/null
+++ b/pw/CHW.Brush
diff --git a/pw/GenerateWindow.pw b/pw/GenerateWindow.pw
new file mode 100644
index 0000000..bbabf46
--- /dev/null
+++ b/pw/GenerateWindow.pw
diff --git a/pw/MainWindow.pw b/pw/MainWindow.pw
new file mode 100644
index 0000000..55afd92
--- /dev/null
+++ b/pw/MainWindow.pw
diff --git a/pw/RotateWindow.pw b/pw/RotateWindow.pw
new file mode 100644
index 0000000..c6ef09b
--- /dev/null
+++ b/pw/RotateWindow.pw
diff --git a/pw/ZoomWindow.pw b/pw/ZoomWindow.pw
new file mode 100644
index 0000000..b02c485
--- /dev/null
+++ b/pw/ZoomWindow.pw