From 62e509e9c90d728c9f65145947276f79112ab48c Mon Sep 17 00:00:00 2001 From: "Christian A. Weber" Date: Tue, 2 Nov 1993 18:53:33 +0000 Subject: Initial revision --- ARexx.c | 483 +++++++++++ About.c | 47 ++ AboutWindow.h | 211 +++++ Anim.c | 196 +++++ BMapSupport.c | 90 +++ Bob.c | 532 +++++++++++++ BobStructure.h | 112 +++ Bobi.c | 372 +++++++++ Bobi.doc | 122 +++ Bobi.h | 260 ++++++ Bobi.info | Bin 0 -> 1459 bytes Bobi_rev.h | 8 + ByteMap.S | 591 ++++++++++++++ ByteMap.h | 13 + Color.c | 999 +++++++++++++++++++++++ ConvertDate.S | 130 +++ CreateRastPort.S | 121 +++ FileRequest.c | 77 ++ GadgetSupport.S | 123 +++ Generate.c | 764 ++++++++++++++++++ GenerateWindow.h | 651 +++++++++++++++ Get.c | 268 +++++++ HunkDefs.h | 27 + IFFAnim.c | 155 ++++ IFFError.c | 50 ++ ImsgHandler.c | 263 ++++++ Layer.c | 289 +++++++ LoadBobs.c | 425 ++++++++++ MainWindow.h | 2166 ++++++++++++++++++++++++++++++++++++++++++++++++++ Makefile | 85 ++ Misc.c | 204 +++++ Picture.c | 174 ++++ PropGadgets.c | 61 ++ Rotate.c | 208 +++++ RotateWindow.h | 202 +++++ SCOPTIONS | 24 + ShowRequest.c | 293 +++++++ Sleep.c | 56 ++ Snooze.S | 95 +++ Startup.S | 406 ++++++++++ Stubs.c | 93 +++ ToolWindow.h | 402 ++++++++++ Zoom.c | 152 ++++ ZoomWindow.h | 255 ++++++ pw/AboutWindow.pw | Bin 0 -> 2280 bytes pw/CHW.Brush | Bin 0 -> 1564 bytes pw/GenerateWindow.pw | Bin 0 -> 3631 bytes pw/MainWindow.pw | Bin 0 -> 8927 bytes pw/RotateWindow.pw | Bin 0 -> 1245 bytes pw/ZoomWindow.pw | Bin 0 -> 1488 bytes 50 files changed, 12255 insertions(+) create mode 100644 ARexx.c create mode 100644 About.c create mode 100644 AboutWindow.h create mode 100644 Anim.c create mode 100644 BMapSupport.c create mode 100644 Bob.c create mode 100644 BobStructure.h create mode 100644 Bobi.c create mode 100644 Bobi.doc create mode 100644 Bobi.h create mode 100644 Bobi.info create mode 100644 Bobi_rev.h create mode 100644 ByteMap.S create mode 100644 ByteMap.h create mode 100644 Color.c create mode 100644 ConvertDate.S create mode 100644 CreateRastPort.S create mode 100644 FileRequest.c create mode 100644 GadgetSupport.S create mode 100644 Generate.c create mode 100644 GenerateWindow.h create mode 100644 Get.c create mode 100644 HunkDefs.h create mode 100644 IFFAnim.c create mode 100644 IFFError.c create mode 100644 ImsgHandler.c create mode 100644 Layer.c create mode 100644 LoadBobs.c create mode 100644 MainWindow.h create mode 100644 Makefile create mode 100644 Misc.c create mode 100644 Picture.c create mode 100644 PropGadgets.c create mode 100644 Rotate.c create mode 100644 RotateWindow.h create mode 100644 SCOPTIONS create mode 100644 ShowRequest.c create mode 100644 Sleep.c create mode 100644 Snooze.S create mode 100644 Startup.S create mode 100644 Stubs.c create mode 100644 ToolWindow.h create mode 100644 Zoom.c create mode 100644 ZoomWindow.h create mode 100644 pw/AboutWindow.pw create mode 100644 pw/CHW.Brush create mode 100644 pw/GenerateWindow.pw create mode 100644 pw/MainWindow.pw create mode 100644 pw/RotateWindow.pw create mode 100644 pw/ZoomWindow.pw 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 +#include +#include +#include +#include +#include +#include +#include + +#include + +#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<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 +#include +#include + +#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 +#include +#include +#include + +#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 or RMB to stop animation"); + mainmenus = mainwindow->MenuStrip; + ClearMenuStrip(mainwindow); + + if(toolwindow) + { + oldtooltitle=toolwindow->ScreenTitle; + SetWindowTitles(toolwindow,(STRPTR)(~0L),"Hit 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; iUserPort); + 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) || (bobnumlastanimbob) bobnum = firstanimbob; + if(bobnum +#include +#include +#include +#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; iPlanes[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 +#include +#include +#include +#include +#include +#include + +#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; iPlanes[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; iDepth; ++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=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)||(x1Depth0) /* 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(yyh) val |= 2; + if(xxh) 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; iSourceLabel,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; iCollX0 = 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 +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#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; iTopEdge; + 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 Grad (0-360) rotie- + ren und dabei neue Bobs + generieren + +Zoom Faktor1 Faktor2 Anzahl Bob von (Start-Faktor nach + (End-Faktor) zoomen und + dabei 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 als + erstes Animations-Bob setzen + +AnimLast [Nummer] Aktuelles Bob oder Bob 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 +#include +#include +#include + +#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 Binary files /dev/null and b/Bobi.info differ 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 +#include +#include +#include +#include + + +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;i9) {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;iClass==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>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;iLeftEdge; + 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<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 +#include +#include +#include +#include + +#include + + +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 +#include +#include +#include + +#include +#include + +#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; iDepth; 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<Depth)-1; + bob->PlaneOnOff = 0; + + for(i=0; iDepth; ++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<PlaneOnOff |= (1<PlanePick &= ~(1<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; xWidth; 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; iDepth; ++i) + { + if(bob->PlanePick&(1<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; iDepth; ++i) + { + if(bob->PlanePick & (1<Planes[i],bob->PlaneSize); + else + if(bob->PlaneOnOff & (1<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; yHeight; ++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; yHeight; ++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; iSourceLabel); + else fputf(",%s",BobTable[i]->SourceLabel); + if((i%4)==3) fputf("\n"); + } + fputf("\n"); + + for(i=0; i>=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; iSourceLabel)) /* 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; iSourceLabel)) /* 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 +#include +#include +#include + +#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((x0)) + { + int i; + + for(i=y; iRastPort,x,i)) + goto xlgot; + } + x++; w--; + } + xlgot: + + while((y0)) + { + int i; + + for(i=x; iRastPort,i,y)) + goto ylgot; + } + y++; h--; + } + ylgot: + + while(w>0) + { + int i; + + for(i=y; iRastPort,x1-1,i)) + goto xhgot; + } + x1--; w--; + } + xhgot: + + while(h>0) + { + int i; + + for(i=x; iRastPort,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(numbobsSourceLabel,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 +#include +#include +#include +#include + +#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 +#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 +#include + +#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(actbobnum0) 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 +#include +#include +#include + +#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 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 +#include +#include +#include +#include +#include + +#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; iDepth; ++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 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 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; iPlanes[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; iX0,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; iX0,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 +#include +#include +#include + +#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 +#include +#include +#include +#include +#include +#include + +#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 +#include +#include +#include + +#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 +#include +#include +#include +#include +#include +#include + +#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 +#include +#include +#include +#include +#include +#include + +#include + +#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 +#include +#include +#include + +#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 +#include +#include + +#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 +#include +#include +#include +#include +#include +#include +#include + +#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