home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Frozen Fish 1: Amiga
/
FrozenFish-Apr94.iso
/
bbs
/
alib
/
d9xx
/
d944
/
blocked.lha
/
BlockEd
/
BlockEd.c
< prev
next >
Wrap
C/C++ Source or Header
|
1993-12-20
|
29KB
|
1,212 lines
/*
* Copyright (C) 1989 Andrew Kemmis
*
* All Rights Reserved
*
* Date: Mar 1989
*/
#define AK___CRYPT
#include <ak/stdak.h>
char Program_name[] = "BlockEd";
int Version = CRYPTNUM(1);
int MinorVer = CRYPTNUM(4);
char Date[] = "Oct 1993";
char CRDate[] = "1989-93";
#include <ak/err.h>
#include <ak/err_num.h>
#include <ak/pool.h>
#include <ak/dev.h>
#include <ak/dos.h>
#include <ak/menu.h>
#include <ak/gad.h>
#include <ak/filesystem.h>
#include <ak/rawkey.h>
#include <intuition/intuition.h>
#include <graphics/gfxbase.h>
#include <ctype.h>
#include "blocked.qi"
#define STRINGJUST (Hex ? STRINGCENTER : (Left ? 0L : STRINGRIGHT))
#define INTUITION_MESSAGE (1L<<MyWin->UserPort->mp_SigBit)
extern char *strchr();
extern char *strrchr();
extern struct Window *OpenWindow();
extern struct Screen *OpenScreen();
extern struct IntuiMessage *GetMsg();
extern struct MenuItem *ItemAddress();
extern struct TextFont *OpenDiskFont();
extern LONG Wait();
extern void *AllocMem();
int cli;
struct IBASE *IBASE = (struct IBASE *)NULL;
struct GfxBase *GfxBase = (struct GfxBase *)NULL;
struct Library *DiskfontBase = (struct Library *)NULL;
Static struct AkMenu AkMenu = AKMENUINIT;
Static struct TextFont *Opal = (struct TextFont *)NULL;
Static struct TextAttr OpalAttr = { (STRPTR)NULL, 0, 0, 0 }; /* Setup in main */
Static UWORD FXSize;
Static UWORD FYSize;
Static UWORD FYBase;
Static int Inhibited = 0;
Static struct AkGad AkGad = AKGADINIT;
Static struct Gadget *BlkGad;
Static struct Gadget *DirGad;
Static struct Gadget *NumGad;
Static char *Device;
Static struct AkDevStuff Stuff = DEVSTUFFINIT;
Static ulong TheBlock;
Static char TheBlockBuf[10+1];
Static ulong CurBlock = 0;
Static ulong *Buffer;
Static ulong *Buffer2;
Static uchar *BufPtr;
Static long Dev = -1;
Static int LongPos = 0;
Static int BytePos = 0;
Static struct Menu *ProjectMenu;
Static struct MenuItem *RestoreItem;
Static struct RastPort *rp;
Static char DirBuf[FILENAMELENGTH+1];
Static char NumBuf[10+1];
#define EDIT_NO 0
#define EDIT_YES 1
Static int Edit = EDIT_NO;
#define MENUFLAGS (USHORT)MENUENABLED
#define ITEMFLAGS (USHORT)(ITEMTEXT | COMMSEQ | HIGHBOX)
#define MOREITEMFLAGS (USHORT)(ITEMENABLED | ITEMFLAGS)
#define EXTRAITEMFLAGS (USHORT)(CHECKIT | MENUTOGGLE | MOREITEMFLAGS)
Static struct PoolKey GenPoolKey;
Static struct Screen *MyScreen = (struct Screen *)NULL;
Static struct NewScreen MyNewScreen =
{
0, 0, 640, 330, 2,
0, 1,
LACE | SPRITES | HIRES,
CUSTOMSCREEN | SCREENBEHIND | BEEPING,
&OpalAttr,
(UBYTE *)Program_name,
(struct Gadget *)NULL,
(struct BitMap *)NULL
};
Static struct Window *MyWin = (struct Window *)NULL;
Static struct NewWindow MyNewWin =
{
0, 7,
640, 323,
-1, -1,
MENUVERIFY | MOUSEBUTTONS | GADGETDOWN | GADGETUP | MENUPICK | CLOSEWINDOW | RAWKEY,
WINDOWCLOSE | SMART_REFRESH | REPORTMOUSE | NOCAREREFRESH | ACTIVATE,
(struct Gadget *)NULL,
(struct Image *)NULL,
(UBYTE *)Program_name,
(struct Screen *)NULL,
(struct BitMap *)NULL,
0, 0, 0, 0,
CUSTOMSCREEN
};
#define MoveTo(x, y) Move(rp, (long)(x), (long)(y))
#define TextTo(s, n) Text(rp, (s), (long)(n))
Static send(str, x, y, len)
REG char *str;
REG int x;
REG int y;
REG int len;
{
MoveTo(x, y);
TextTo(str, len);
}
#define DSP_BIG 1
#define DSP_MEDIUM 2
#define DSP_TINY 4
Static display_num(x, y, num, size, buf)
REG int x;
REG int y;
REG ulong num;
int size;
char *buf;
{
static char Str[11];
REG int hex;
REG int dec;
switch (size)
{
case DSP_BIG:
hex = 8;
dec = 10;
break;
case DSP_MEDIUM:
hex = 4;
dec = 6;
break;
case DSP_TINY:
hex = 2;
dec = 4;
break;
}
if (!buf)
{ if (Hex)
sprintf(Str, " %0*lx ", hex, num);
else
if (Left)
sprintf(Str, "%-*lu", dec, num);
else
sprintf(Str, "%*lu", dec, num);
send(Str, x, y, dec);
}
else
{ if (Hex)
sprintf(buf, "%0*lx", hex, num);
else
sprintf(buf, "%lu", num);
}
}
#define NXTIMES ((FXSize * 10) + 4)
#define NYTIMES FYSize
#define AXTIMES FXSize
#define AYTIMES FYSize
#define NXPLUS 7
#define NYPLUS (FYSize * 4)
#define AXPLUS ((FXSize * 42) + 6)
#define AYPLUS (FYSize * 4)
#define ACTIVE 1
#define BACKGR 0
Static display_pos(pos, active)
REG int pos;
REG int active;
{
REG int xn;
REG int xs;
REG int y;
REG uchar ptr[4];
int i;
for (i = (ByteMove ? 0 : 3); i >= 0; i--)
if (isprint(BufPtr[i+pos]))
ptr[i] = BufPtr[i+pos];
else
ptr[i] = NullChar;
xn = (pos / 4) % 4;
xs = pos % 16;
y = pos / 16;
if (active == ACTIVE)
{ SetAPen(rp, SelectPen);
SetBPen(rp, OtherPen);
}
else
{ SetAPen(rp, DataPen);
SetBPen(rp, BackPen);
}
display_num(xn * NXTIMES + NXPLUS, y * NYTIMES + NYPLUS, Buffer[pos/4], DSP_BIG, NULL);
send(ptr, xs * AXTIMES + AXPLUS, y * AYTIMES + AYPLUS, ByteMove ? 1 : 4);
}
#define PT_STR 0
#define PT_NUM 1
#define PT_BUF 2
#define PT_PTR 3
#define PT_NPT 4
#define PT_DEV 5
#define PT_LON 6
#define PT_BYT 7
#define PT_SAV 8
#define PT_END 9
#define DRAW_ONCE_ONLY 1
#define DRAW_EACH_BLOCK 2
#define DRAW_EACH_CHECKSUM 4
#define DRAW_EACH_MOVE 8
#define DRAW_MARK_EDIT 16
#define DRAW_UNMARK_EDIT 32
#define BLKGAD_SAV 0L
#define DIRGAD_SAV 1L
#define MAX_SAV 1L
Static struct
{ int x;
int y;
} saves[MAX_SAV+1];
Static draw_page(often)
REG int often;
{
static struct ScrDat
{ char *str;
int often;
int reset;
int xt;
int xa;
int yt;
int ya;
int type;
long *pen;
} Page[] =
{
"Offset", 1, 1, 1, 2, 2, 4, PT_STR, &DataPen,
"O", 1, 0, 0, 0, 0, 0, PT_STR, &SelectPen,
(char *)BLKGAD_SAV, 1, 0, 7, 0, 0, 0, PT_SAV, NULL,
"Long", 1, 0, 16, 0, 0, 0, PT_STR, &DataPen,
(char *)&LongPos, 10, 0, 5, 0, 0, 0, PT_LON, &SelectPen,
"Byte", 1, 0, 11, 0, 0, 0, PT_STR, &DataPen,
(char *)&BytePos, 10, 0, 5, 0, 0, 0, PT_BYT, &SelectPen,
"Root", 1, 0, 14, 4, 0, 0, PT_STR, &OtherPen,
"R", 1, 0, 0, 0, 0, 0, PT_STR, &SelectPen,
(char *)&Stuff.Info.Root, 3, 0, 10, -4, 0, 0, PT_NUM, &DataPen,
"Parent", 1, 0, -10, 4, 1, 4, PT_STR, &OtherPen,
"P", 1, 0, 0, 0, 0, 0, PT_STR, &SelectPen,
(char *)POS_PAR, 3, 0, 10, -4, 0, 0, PT_BUF, &DataPen,
"Key", 1, 0, -10, 4, 1, 0, PT_STR, &OtherPen,
"K", 1, 0, 0, 0, 0, 0, PT_STR, &SelectPen,
(char *)POS_KEY, 3, 0, 10, -4, 0, 0, PT_BUF, &DataPen,
"HashChain", 1, 0, -10, 4, 1, 0, PT_STR, &OtherPen,
"H", 1, 0, 0, 0, 0, 0, PT_STR, &SelectPen,
(char *)POS_HASH_CH, 3, 0, 10, -4, 0, 0, PT_BUF, &DataPen,
"Extension", 1, 0, -10, 4, 1, 0, PT_STR, &OtherPen,
"E", 1, 0, 0, 0, 0, 0, PT_STR, &SelectPen,
(char *)POS_EXT, 3, 0, 10, -4, 0, 0, PT_BUF, &DataPen,
"FirstData", 1, 0, -10, 4, 1, 0, PT_STR, &OtherPen,
"F", 1, 0, 0, 0, 0, 0, PT_STR, &SelectPen,
(char *)POS_FST_DAT, 3, 0, 10, -4, 0, 0, PT_BUF, &DataPen,
"NextData", 1, 0, -10, 4, 1, 0, PT_STR, &OtherPen,
"N", 1, 0, 0, 0, 0, 0, PT_STR, &SelectPen,
(char *)POS_D_NXT_DAT, 3, 0, 10, -4, 0, 0, PT_BUF, &DataPen,
"CheckSum", 1, 0, -10, 4, 1, 0, PT_STR, &OtherPen,
"C", 1, 0, 0, 0, 0, 0, PT_STR, &SelectPen,
(char *)POS_CHKSUM, 3, 0, 10, -4, 0, 0, PT_BUF, &DataPen,
"+/= Advance One", 1, 0, -10, 4, 1, 4, PT_STR, &OtherPen,
"+/=", 1, 0, 0, 0, 0, 0, PT_STR, &SelectPen,
"+/", 1, 0, 0, 0, 0, 0, PT_STR, &OtherPen,
"+", 1, 0, 0, 0, 0, 0, PT_STR, &SelectPen,
"-/_ Retreat One", 1, 0, 0, 0, 1, 0, PT_STR, &OtherPen,
"-/_", 1, 0, 0, 0, 0, 0, PT_STR, &SelectPen,
"-/", 1, 0, 0, 0, 0, 0, PT_STR, &OtherPen,
"-", 1, 0, 0, 0, 0, 0, PT_STR, &SelectPen,
"Goto Current", 1, 0, 0, 0, 1, 0, PT_STR, &OtherPen,
"G", 1, 0, 0, 0, 0, 0, PT_STR, &SelectPen,
"Zero Goto", 1, 0, 0, 0, 1, 0, PT_STR, &OtherPen,
"Z", 1, 0, 0, 0, 0, 0, PT_STR, &SelectPen,
"ALT-ReRead", 1, 0, 0, 0, 1, 4, PT_STR, &OtherPen,
"ALT-R", 1, 0, 0, 0, 0, 0, PT_STR, &SelectPen,
"ALT-Update", 1, 0, 0, 0, 1, 0, PT_STR, &OtherPen,
"ALT-U", 1, 0, 0, 0, 0, 0, PT_STR, &SelectPen,
"*", 16, 0, -1, 0, 1, 4, PT_STR, &SelectPen,
"*", 32, 0, 0, 0, 0, 0, PT_STR, &BackPen,
"Ascii/Number Edit", 1, 0, 1, 0, 0, 0, PT_STR, &OtherPen,
"A", 1, 0, 0, 0, 0, 0, PT_STR, &SelectPen,
"Spread Current", 1, 0, 0, 0, 1, 0, PT_STR, &OtherPen,
"S", 1, 0, 0, 0, 0, 0, PT_STR, &SelectPen,
"Byte/Long Move", 1, 0, 0, 0, 1, 4, PT_STR, &OtherPen,
"B", 1, 0, 0, 0, 0, 0, PT_STR, &SelectPen,
"Mode Hex/Dec", 1, 0, 0, 0, 1, 0, PT_STR, &OtherPen,
"M", 1, 0, 0, 0, 0, 0, PT_STR, &SelectPen,
"Justify Left/Right", 1, 0, 0, 0, 1, 0, PT_STR, &OtherPen,
"J", 1, 0, 0, 0, 0, 0, PT_STR, &SelectPen,
"Driver", 1, 0, 0, 0, 1, 4, PT_STR, &OtherPen,
(char *)&Stuff.Info.dname, 1, 0, 7, 0, 0, 0, PT_DEV, &DataPen,
"Unit", 1, 0, -7, 0, 1, 0, PT_STR, &OtherPen,
(char *)&Stuff.Info.unit, 1, 0, 11, 0, 0, 0, PT_NPT, &DataPen,
"Device", 1, 0, -11, 0, 1, 0, PT_STR, &OtherPen,
(char *)&Stuff.Info.name, 1, 0, 11, 0, 0, 0, PT_PTR, &DataPen,
"LowCyl", 1, 0, -11, 0, 1, 0, PT_STR, &OtherPen,
(char *)&Stuff.Info.lowcyl, 1, 0, 11, 0, 0, 0, PT_NPT, &DataPen,
"HiCyl", 1, 0, -11, 0, 1, 0, PT_STR, &OtherPen,
(char *)&Stuff.Info.hicyl, 1, 0, 11, 0, 0, 0, PT_NPT, &DataPen,
"Heads", 1, 0, -11, 0, 1, 0, PT_STR, &OtherPen,
(char *)&Stuff.Info.heads, 1, 0, 11, 0, 0, 0, PT_NPT, &DataPen,
"BlksPerTrk", 1, 0, -11, 0, 1, 0, PT_STR, &OtherPen,
(char *)&Stuff.Info.bpt, 1, 0, 11, 0, 0, 0, PT_NPT, &DataPen,
"Reserved", 1, 0, -11, 0, 1, 0, PT_STR, &OtherPen,
(char *)&Stuff.Info.res, 1, 0, 11, 0, 0, 0, PT_NPT, &DataPen,
"Directory/Filename", 1, 0, -11, 0, 1, 4, PT_STR, &OtherPen,
"D", 1, 0, 0, 0, 0, 0, PT_STR, &SelectPen,
(char *)DIRGAD_SAV, 1, 0, 0, 0, 1, 4, PT_SAV, NULL,
NULL, 0, 0, 0, 0, 0, 0, PT_END
};
REG struct ScrDat *ScrPtr = Page;
REG int x;
REG int y;
REG long pen = -1;
char NBuf[9];
char *ptr;
char *str;
SetBPen(rp, BackPen);
while (ScrPtr->type != PT_END)
{ if (ScrPtr->reset)
(x = 0), (y = 0);
x += (ScrPtr->xt * FXSize + ScrPtr->xa);
y += (ScrPtr->yt * FYSize + ScrPtr->ya);
if (ScrPtr->often & often)
{ if (pen != *(ScrPtr->pen))
{ pen = *(ScrPtr->pen);
SetAPen(rp, pen);
}
switch(ScrPtr->type)
{
case PT_STR:
send(ScrPtr->str, x, y, strlen(ScrPtr->str));
break;
case PT_NUM:
display_num(x, y, *(ulong *)(ScrPtr->str), DSP_BIG, NULL);
break;
case PT_BUF:
display_num(x, y, Buffer[(long)(ScrPtr->str)], DSP_BIG, NULL);
break;
case PT_PTR:
send(*(char **)(ScrPtr->str), x, y, strlen(*(char **)(ScrPtr->str)));
break;
case PT_NPT:
sprintf(NBuf, "%ld", *(ulong *)(ScrPtr->str));
send(NBuf, x, y, strlen(NBuf));
break;
case PT_DEV:
str = *(char **)(ScrPtr->str);
ptr = strrchr(str, '.');
if (!ptr)
ptr = strchr(str, '\0');
send(str, x, y, ptr - str);
break;
case PT_BYT:
display_num(x, y, (ulong)(*(int *)(ScrPtr->str)), DSP_MEDIUM, NULL);
break;
case PT_LON:
display_num(x, y, (ulong)(*(int *)(ScrPtr->str)), DSP_TINY, NULL);
break;
case PT_SAV:
saves[(long)(ScrPtr->str)].x = x;
saves[(long)(ScrPtr->str)].y = y;
}
}
ScrPtr++;
}
if (often & DRAW_EACH_BLOCK)
BlkGadRefresh();
}
Static int NotBeenHere = !0;
Static display_block()
{
REG int x;
REG int y;
REG ulong *Buf = Buffer;
REG uchar *Ptr = BufPtr;
char Str[20];
if (NotBeenHere)
{ NotBeenHere = 0;
draw_page(DRAW_ONCE_ONLY); /* Fills in saves[] */
add_gadgets();
}
draw_page(DRAW_EACH_BLOCK);
SetAPen(rp, DataPen);
SetBPen(rp, BackPen);
for (y = 0; y < 32; y++)
{ for (x = 0; x < 4; x++)
{ display_num(x * NXTIMES + NXPLUS, y * NYTIMES + NYPLUS, *Buf, DSP_BIG, NULL);
Buf++;
}
for (x = 0; x < 16; x++)
{ send(isprint(*Ptr) ? Ptr : &((uchar)NullChar),
x * AXTIMES + AXPLUS, y * AYTIMES + AYPLUS, 1);
Ptr++;
}
}
display_pos(BytePos, ACTIVE);
}
Static read(ignore)
REG int ignore;
{
REG ulong l = TheBlock;
REG LONG ret;
if (l != CurBlock || ignore)
{ if (l < 0 || l > (Stuff.Info.End - Stuff.Info.Begin))
{ sprintf(err_buf,
"Invalid block Min = 0 Max = %lu (0x%08lx)",
Stuff.Info.End - Stuff.Info.Begin,
Stuff.Info.End - Stuff.Info.Begin);
WinMistake(MyWin, err_buf);
EnableRestore();
TheBlock = CurBlock;
}
else
{ AkMotorOn(&Stuff);
ret = AkDevRead(l + Stuff.Info.Begin, Buffer, &Stuff, BLOCK_SIZE);
AkMotorOff(&Stuff);
if (ret != 0)
{ sprintf(err_buf, "Read Failed Status = 0x%lx (IoErr - 0x%lx)", ret, IoErr());
WinMistake(MyWin, err_buf);
EnableRestore();
TheBlock = CurBlock;
if (NotBeenHere)
display_block();
}
else
{ CurBlock = l;
display_block();
}
}
}
}
Static Update()
{
REG ulong lb = TheBlock + Stuff.Info.Begin;
REG LONG ret;
AkMotorOn(&Stuff);
ret = AkDevRead(lb, Buffer2, &Stuff, BLOCK_SIZE);
if (ret != 0)
{ sprintf(err_buf, "Read for Update Failed Status = 0x%lx (IoErr - 0x%lx)", ret, IoErr());
WinMistake(MyWin, err_buf);
EnableRestore();
}
else
{ for (ret = 0; ret < LBlockSize; ret++)
if (Buffer[ret] != Buffer2[ret])
{ ret = AkDevWrite(lb, Buffer, &Stuff, BLOCK_SIZE);
if (ret != 0)
{ sprintf(err_buf,
"Write Failed Status = 0x%lx (IoErr - 0x%lx)",
ret, IoErr());
WinMistake(MyWin, err_buf);
EnableRestore();
}
else
{ ret = AkDevUpdate(&Stuff);
if (ret != 0)
{ sprintf(err_buf,
"Update Failed Status = 0x%lx (IoErr - 0x%lx)",
ret, IoErr());
WinMistake(MyWin, err_buf);
EnableRestore();
}
}
break;
}
}
AkMotorOff(&Stuff);
}
Static Checksum()
{
REG ulong *Chk = &Buffer[POS_CHKSUM];
*Chk -= DosChecksum(Buffer);
display_pos((int)(POS_CHKSUM)*4, BACKGR);
display_pos(BytePos, ACTIVE);
draw_page(DRAW_EACH_BLOCK);
}
Static BlkGadRefresh()
{
RemoveGad(&AkGad, BlkGad, 0);
BlkGad->Activation &= (~(STRINGRIGHT | STRINGCENTER));
BlkGad->Activation |= STRINGJUST;
display_num(0, 0, TheBlock, DSP_BIG, TheBlockBuf);
ActivateGad(&AkGad, BlkGad);
}
Static DoBlk(Class, Gad)
ULONG Class;
struct Gadget *Gad;
{
int ret;
switch(Class)
{
case GADGETUP:
if (Hex)
ret = sscanf(TheBlockBuf, "%lx", &TheBlock);
else
ret = sscanf(TheBlockBuf, "%ld", &TheBlock);
if (ret)
read(0);
else
{ TheBlock = CurBlock;
BlkGadRefresh();
}
break;
case GADGETDOWN:
break;
default: /* Ignore */
break;
}
}
Static DoDir(Class, Gad)
ULONG Class;
struct Gadget *Gad;
{
int NewLongPos;
switch(Class)
{
case GADGETUP:
NewLongPos = DosHash(DirBuf);
if (LongPos != NewLongPos)
{ display_pos(BytePos, BACKGR);
LongPos = NewLongPos;
BytePos = LongPos * 4;
display_pos(BytePos, ACTIVE);
draw_page(DRAW_EACH_MOVE);
}
break;
case GADGETDOWN:
break;
default: /* Ignore */
break;
}
}
Static DoNum(Class, Gad)
ULONG Class;
struct Gadget *Gad;
{
int ret;
ulong NewNum;
switch(Class)
{
case GADGETUP:
if (Hex)
ret = sscanf(NumBuf, "%lx", &NewNum);
else
ret = sscanf(NumBuf, "%ld", &NewNum);
RemoveGad(&AkGad, NumGad, 1);
if (ret)
{ Buffer[LongPos] = NewNum;
display_pos(BytePos, BACKGR);
if (++LongPos > 127)
LongPos -= 128;
BytePos = LongPos * 4;
}
display_pos(BytePos, ACTIVE);
Edit = EDIT_NO;
ActivateGad(&AkGad, BlkGad);
ActivateGad(&AkGad, DirGad);
draw_page(DRAW_EACH_MOVE|DRAW_EACH_BLOCK);
break;
case GADGETDOWN:
break;
default: /* Ignore */
break;
}
}
#define BIT_DOREAD 1
#define BIT_TESTVAL 2
#define BIT_DOBYTE 4
Static no_edit(key)
ushort key;
{
REG int tests = 0;
REG int NewLongPos;
REG int NewBytePos;
switch(key)
{
case RAW_R | RAWB_SHIFT:
case RAW_R:
TheBlock = Stuff.Info.Root;
tests = BIT_DOREAD;
break;
case RAW_P | RAWB_SHIFT:
case RAW_P:
TheBlock = Buffer[POS_PAR];
tests = BIT_DOREAD | BIT_TESTVAL;
break;
case RAW_K | RAWB_SHIFT:
case RAW_K:
TheBlock = Buffer[POS_KEY];
tests = BIT_DOREAD | BIT_TESTVAL;
break;
case RAW_H | RAWB_SHIFT:
case RAW_H:
TheBlock = Buffer[POS_HASH_CH];
tests = BIT_DOREAD | BIT_TESTVAL;
break;
case RAW_E | RAWB_SHIFT:
case RAW_E:
TheBlock = Buffer[POS_EXT];
tests = BIT_DOREAD | BIT_TESTVAL;
break;
case RAW_F | RAWB_SHIFT:
case RAW_F:
TheBlock = Buffer[POS_FST_DAT];
tests = BIT_DOREAD | BIT_TESTVAL;
break;
case RAW_N | RAWB_SHIFT:
case RAW_N:
TheBlock = Buffer[POS_D_NXT_DAT];
tests = BIT_DOREAD | BIT_TESTVAL;
break;
case RAW_G | RAWB_SHIFT:
case RAW_G:
TheBlock = Buffer[LongPos];
tests = BIT_DOREAD | BIT_TESTVAL;
break;
case RAW_UP:
if (ByteMove)
NewBytePos = BytePos - 16;
else
NewLongPos = LongPos - 4;
tests = BIT_DOBYTE;
break;
case RAW_UP | RAWB_SHIFT:
if (ByteMove)
NewBytePos = BytePos % 16;
else
NewLongPos = LongPos % 4;
tests = BIT_DOBYTE;
break;
case RAW_LEFT:
if (ByteMove)
NewBytePos = BytePos - 1;
else
NewLongPos = LongPos - 1;
tests = BIT_DOBYTE;
break;
case RAW_LEFT | RAWB_SHIFT:
if (ByteMove)
NewBytePos = BytePos - (BytePos % 16);
else
NewLongPos = LongPos - (LongPos % 4);
tests = BIT_DOBYTE;
break;
case RAW_LEFT | RAWB_LALT:
case RAW_LEFT | RAWB_RALT:
if (ByteMove)
{ NewBytePos = BytePos - 1;
if (NewBytePos < 0)
NewBytePos = 511;
while (NewBytePos != BytePos && !BufPtr[NewBytePos])
{ NewBytePos--;
if (NewBytePos < 0)
NewBytePos = 511;
}
}
else
{ NewLongPos = LongPos - 1;
if (NewLongPos < 0)
NewLongPos = 127;
while (NewLongPos != LongPos && !Buffer[NewLongPos])
{ NewLongPos--;
if (NewLongPos < 0)
NewLongPos = 127;
}
}
tests = BIT_DOBYTE;
break;
case RAW_DOWN:
if (ByteMove)
NewBytePos = BytePos + 16;
else
NewLongPos = LongPos + 4;
tests = BIT_DOBYTE;
break;
case RAW_DOWN | RAWB_SHIFT:
if (ByteMove)
NewBytePos = (512-16) + (BytePos % 16);
else
NewLongPos = (128-4) + (LongPos % 4);
tests = BIT_DOBYTE;
break;
case RAW_RIGHT:
if (ByteMove)
NewBytePos = BytePos + 1;
else
NewLongPos = LongPos + 1;
tests = BIT_DOBYTE;
break;
case RAW_RIGHT | RAWB_SHIFT:
if (ByteMove)
NewBytePos = BytePos - (BytePos % 16) + 15;
else
NewLongPos = LongPos - (LongPos % 4) + 3;
tests = BIT_DOBYTE;
break;
case RAW_RIGHT | RAWB_LALT:
case RAW_RIGHT | RAWB_RALT:
if (ByteMove)
{ NewBytePos = BytePos + 1;
if (NewBytePos > 511)
NewBytePos = 0;
while (NewBytePos != BytePos && !BufPtr[NewBytePos])
{ NewBytePos++;
if (NewBytePos > 511)
NewBytePos = 0;
}
}
else
{ NewLongPos = LongPos + 1;
if (NewLongPos > 127)
NewLongPos = 0;
while (NewLongPos != LongPos && !Buffer[NewLongPos])
{ NewLongPos++;
if (NewLongPos > 127)
NewLongPos = 0;
}
}
tests = BIT_DOBYTE;
break;
case RAW_EQ | RAWB_SHIFT:
case RAW_EQ:
TheBlock++;
tests = BIT_DOREAD;
break;
case RAW_MINUS | RAWB_SHIFT:
case RAW_MINUS:
TheBlock--;
tests = BIT_DOREAD;
break;
case RAW_J | RAWB_SHIFT:
case RAW_J:
Left = !Left;
if (!Hex)
display_block();
break;
case RAW_M | RAWB_SHIFT:
case RAW_M:
Hex = !Hex;
display_block();
break;
case RAW_U | RAWB_LALT:
case RAW_U | RAWB_RALT:
Update();
break;
case RAW_C | RAWB_SHIFT:
case RAW_C:
Checksum();
break;
case RAW_O | RAWB_SHIFT:
case RAW_O:
ActivateGadget(BlkGad, MyWin, NULL);
break;
case RAW_D | RAWB_SHIFT:
case RAW_D:
ActivateGadget(DirGad, MyWin, NULL);
break;
case RAW_S | RAWB_SHIFT:
case RAW_S:
if (ByteMove)
for (NewBytePos = 0; NewBytePos < 512; NewBytePos++)
BufPtr[NewBytePos] = BufPtr[BytePos];
else
for (NewLongPos = 0; NewLongPos < 128; NewLongPos++)
Buffer[NewLongPos] = Buffer[LongPos];
display_block();
break;
case RAW_B | RAWB_SHIFT:
case RAW_B:
display_pos(BytePos, BACKGR);
if (ByteMove)
BytePos = LongPos * 4;
ByteMove = !ByteMove;
display_pos(BytePos, ACTIVE);
break;
case RAW_R | RAWB_LALT:
case RAW_R | RAWB_RALT:
read(!0);
break;
case RAW_Z | RAWB_SHIFT:
case RAW_Z:
TheBlock = 0;
tests = BIT_DOREAD;
break;
case RAW_A | RAWB_SHIFT:
case RAW_A:
Edit = EDIT_YES;
RemoveGad(&AkGad, BlkGad, 0);
RemoveGad(&AkGad, DirGad, 0);
if (ByteMove)
draw_page(DRAW_MARK_EDIT);
else
{ display_pos(BytePos, BACKGR);
NumGad->LeftEdge = (LongPos % 4) * NXTIMES + NXPLUS;
NumGad->TopEdge = (LongPos / 4) * NYTIMES + NYPLUS - FYBase;
NumGad->Activation &= (~(STRINGRIGHT | STRINGCENTER));
NumGad->Activation |= STRINGJUST;
display_num(0, 0, Buffer[LongPos], DSP_BIG, NumBuf);
ActivateGad(&AkGad, NumGad);
ActivateGadget(NumGad, MyWin, NULL);
}
break;
default:
break;
}
if (tests & BIT_DOBYTE)
{ if (ByteMove)
{ if (NewBytePos < 0)
NewBytePos += 512;
if (NewBytePos > 511)
NewBytePos -= 512;
if (BytePos != NewBytePos)
{ display_pos(BytePos, BACKGR);
BytePos = NewBytePos;
LongPos = BytePos / 4;
display_pos(BytePos, ACTIVE);
draw_page(DRAW_EACH_MOVE);
}
}
else
{ if (NewLongPos < 0)
NewLongPos += 128;
if (NewLongPos > 127)
NewLongPos -= 128;
if (LongPos != NewLongPos)
{ display_pos(BytePos, BACKGR);
LongPos = NewLongPos;
BytePos = LongPos * 4;
display_pos(BytePos, ACTIVE);
draw_page(DRAW_EACH_MOVE);
}
}
}
if (tests & BIT_TESTVAL)
if (TheBlock == 0)
TheBlock = CurBlock;
if (tests & BIT_DOREAD)
read(0);
}
Static edit(key)
ushort key;
{
REG int NewBytePos;
REG char ch;
REG int modify = FALSE;
NewBytePos = BytePos;
switch (key)
{
case RAW_RIGHT:
NewBytePos++;
break;
case RAW_LEFT:
NewBytePos--;
break;
case RAW_DOWN:
NewBytePos += 16;
break;
case RAW_UP:
NewBytePos -= 16;
break;
default:
ch = AKCOOK(key);
switch(ch)
{
case '\033':
Edit = EDIT_NO;
ActivateGad(&AkGad, BlkGad);
ActivateGad(&AkGad, DirGad);
draw_page(DRAW_UNMARK_EDIT);
break;
case '\0':
break;
default:
BufPtr[BytePos] = ch;
NewBytePos++;
modify = TRUE;
break;
}
break;
}
if (NewBytePos < 0)
NewBytePos += 512;
if (NewBytePos > 511)
NewBytePos -= 512;
if (BytePos != NewBytePos)
{ display_pos(BytePos, BACKGR);
BytePos = NewBytePos;
LongPos = BytePos / 4;
display_pos(BytePos, ACTIVE);
if (modify)
draw_page(DRAW_EACH_MOVE|DRAW_EACH_BLOCK);
else
draw_page(DRAW_EACH_MOVE);
}
}
Static gotkey(key)
ushort key;
{
switch(Edit)
{
case EDIT_NO:
no_edit(key);
break;
case EDIT_YES:
if (ByteMove)
edit(key);
break;
}
}
#define KEYS_WANTED (RAWB_CHARS | RAWB_SHIFT | RAWB_CTRL | RAWB_LALT | RAWB_RALT)
Static BlockEd()
{
REG struct IntuiMessage *Msg;
REG ULONG WaitMask;
TheBlock = Stuff.Info.Root;
read(!0);
WaitMask = INTUITION_MESSAGE;
while (1)
{ Wait(WaitMask);
while ((Msg = GetMsg(MyWin->UserPort)))
{ switch(Msg->Class)
{
case RAWKEY:
AkCookKey(Msg->Code, gotkey, KEYS_WANTED);
ReplyMsg(Msg);
break;
case CLOSEWINDOW:
cleanup();
break;
case MENUPICK:
MnuMsg(&AkMenu, Msg);
break;
case GADGETUP:
case GADGETDOWN:
GadMsg(&AkGad, Msg);
break;
default:
ReplyMsg(Msg);
break;
}
}
}
}
Static EnableRestore()
{
(RestoreItem->Flags) |= ITEMENABLED;
}
Static Restore(Menu, MenuItem, Item)
struct Menu *Menu;
struct MenuItem *MenuItem;
USHORT Item;
{
(RestoreItem->Flags) &= (~ITEMENABLED);
WinMistake(MyWin, NULL);
}
Static add_gadgets()
{
GadInit(&AkGad, MyWin);
BlkGad = AddStrGad(&AkGad, 0L, saves[BLKGAD_SAV].x, saves[BLKGAD_SAV].y-FYBase, FXSize*10, FYSize, STRINGJUST, TheBlockBuf, sizeof(TheBlockBuf), DoBlk);
DirGad = AddStrGad(&AkGad, 0L, saves[DIRGAD_SAV].x, saves[DIRGAD_SAV].y-FYBase, FXSize*18, FYSize, 0L, DirBuf, sizeof(DirBuf), DoDir);
ActivateGads(&AkGad);
NumGad = AddStrGad(&AkGad, 0L, 0, 0, FXSize*10, FYBase, 0L, NumBuf, sizeof(NumBuf), DoNum);
}
main(argc, argv)
int argc;
char *argv[];
{
cli = argc;
DECRYPT();
DO_QUAL();
Device = argv[1];
if (!Quiet && cli)
STARTUP_MSG;
OPEN_LIB(IBASE, "intuition.library", INTUITION_REV);
OPEN_LIB(GfxBase, "graphics.library", GRAPHICS_REV);
OPEN_LIB(DiskfontBase, "diskfont.library", 0L);
OpalAttr.ta_Name = (STRPTR)FontName;
OpalAttr.ta_YSize = FontSize;
Opal = OpenDiskFont(&OpalAttr);
if (!Opal)
error("Can't open font", ERR_NOVAL);
FXSize = Opal->tf_XSize;
FYSize = Opal->tf_YSize + 1;
FYBase = Opal->tf_Baseline;
PoolInit(&GenPoolKey, 0L, MEMF_CHIP|MEMF_CLEAR);
PoolAlloc(Buffer, (long)BLOCK_SIZE, &GenPoolKey);
BufPtr = (uchar *)Buffer;
PoolAlloc(Buffer2, (long)BLOCK_SIZE, &GenPoolKey);
if (Dev = AkDevOpen(Device, &Stuff))
error(Device, Dev);
if (Inhibit)
Inhibited = AkDevInhibit(&Stuff, -1L);
if (!(MyScreen = OpenScreen(&MyNewScreen)))
error(MyNewScreen.DefaultTitle, ERR_NOSCR);
SetRGB4(&(MyScreen->ViewPort), 0L, (long)((ColTbl0 & 0xf00) >> 8),
(long)((ColTbl0 & 0x0f0) >> 4),
(long)((ColTbl0 & 0x00f) >> 0));
SetRGB4(&(MyScreen->ViewPort), 1L, (long)((ColTbl1 & 0xf00) >> 8),
(long)((ColTbl1 & 0x0f0) >> 4),
(long)((ColTbl1 & 0x00f) >> 0));
SetRGB4(&(MyScreen->ViewPort), 2L, (long)((ColTbl2 & 0xf00) >> 8),
(long)((ColTbl2 & 0x0f0) >> 4),
(long)((ColTbl2 & 0x00f) >> 0));
SetRGB4(&(MyScreen->ViewPort), 3L, (long)((ColTbl3 & 0xf00) >> 8),
(long)((ColTbl3 & 0x0f0) >> 4),
(long)((ColTbl3 & 0x00f) >> 0));
ScreenToFront(MyScreen);
MyNewWin.Screen = MyScreen;
if (!(MyWin = OpenWindow(&MyNewWin)))
error(MyNewWin.Title, ERR_NOWIN);
rp = MyWin->RPort;
WinMistake(MyWin, NULL);
MenuInit(&AkMenu, MyWin, (struct TextAttr *)NULL);
ProjectMenu = AddMenu(&AkMenu," Project ", MENUFLAGS, NULL, 0);
AddItem(&AkMenu, ProjectMenu, " Quit ", MOREITEMFLAGS, NULL, 0, 'Q', cleanup);
RestoreItem = AddItem(&AkMenu, ProjectMenu, " Restore ", ITEMFLAGS, NULL, 0, 'R', Restore);
AlignMenus(&AkMenu, NULL);
BlockEd();
cleanup();
}
error(why, num)
char *why;
long num;
{
ERROR_INIT
FreeGads(&AkGad);
ClearMenu(&AkMenu);
if (MyWin)
CloseWindow(MyWin);
if (MyScreen)
CloseScreen(MyScreen);
if (Inhibited)
AkDevInhibit(&Stuff, 0L);
if (!Dev)
AkDevClose(&Stuff);
if (Opal)
CloseFont(Opal);
ERROR_TEST
CASE_ERR_NOGADDEV
CASE_ERR_AKDEVALL
CASE_ERR_NOVAL
CASE_ERR_NOMEM
CASE_ERR_NOWIN
CASE_ERR_NOSCR
CASE_ERR_NOLIB
ERROR_END(FACILITY_BLOCKED)
PoolFree(&GenPoolKey);
if (DiskfontBase)
CloseLibrary(DiskfontBase);
if (GfxBase)
CloseLibrary(GfxBase);
if (IBASE)
CloseLibrary(IBASE);
CLEANUP_QUAL();
ERROR_EXIT
}