home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
The Fred Fish Collection 1.5
/
ffcollection-1-5-1992-11.iso
/
ff_disks
/
200-299
/
ff274.lzh
/
HP11
/
amiga
/
amiga.c
next >
Wrap
C/C++ Source or Header
|
1989-11-16
|
23KB
|
807 lines
#include "exec/types.h"
#include "exec/ports.h"
#include "exec/io.h"
#include "exec/memory.h"
#include "graphics/gfx.h"
#include "devices/timer.h"
#include "libraries/dos.h"
#include "workbench/startup.h"
#include "proto/exec.h"
#include "proto/graphics.h"
#include "proto/layers.h"
#include "proto/intuition.h"
#include "proto/timer.h"
#include "proto/dos.h"
#include "string.h"
#include "ctype.h"
#include "dos.h"
#include "hp11/hp11.h"
#include "hp11/amiga/internal.h"
#include "hp11/amiga/amiga.h"
#include "hp11/amiga/menus.h"
#define MAXWIDTH 29 /* X distance between 2 keys */
#define MAXHEIGHT 29 /* Y distance bewteen 2 keys */
#define KEYWIDTH 20 /* Width of actual key */
#define KEYHEIGHT 16 /* Height of actual key */
#define TOPKEYHEIGHT 9 /* Height of top of key */
#define KEYX (19 + HP11X) /* Position of first key */
#define KEYY (61 + HP11Y)
#define CHAROFFX -1 /* offset in display for first char */
#define CHAROFFY 3
#define CHARWIDTH 14 /* Size of char */
#define CHARHEIGHT 13
#define SCRX0 (53 + HP11X) /* Limits of display for chars */
#define SCRX1 (208 + HP11X)
#define SCRY0 (11 + HP11Y)
#define SCRY1 (37 + HP11Y)
#define fX (SCRX0 + 3 * CHARWIDTH + 2) /* Position of indicators */
#define gX (SCRX0 + 4 * CHARWIDTH - 1)
#define GX (SCRX0 + (int)(6.5 * CHARWIDTH))
#define RADX (GX + 5)
#define PRGMX (SCRX0 + 10 * CHARWIDTH - 6)
#define USERX (SCRX0 + CHARWIDTH)
#define INDICY (SCRY0 + 19)
#define CR 13
#define BS 8
#define ESC 27
#define COPY 0xc0 /* minterm for straight copy */
struct Library *TimerBase; /* Base for calling timer routines */
extern struct Border *hp11char[]; /* Character descriptions (as connected lines) */
/* Indicator shapes (as bitmaps) */
extern struct Image fImage, gImage, USERImage, GImage, RADImage, PRGMImage;
extern struct Image off_image; /* Image for sleep */
extern struct IntuitionBase *IntuitionBase;
extern struct GfxBase *GfxBase;
struct LayersBase *LayersBase;
struct Window *hp11; /* The window containing the hp11 */
/* These informations are for RelKey() */
/* The method by which the latest key was obtained :
From the menus, from the CLOSE gadget, from the keyboard, or by selecting with the mouse */
static enum {menu, gadget, keyboard, mouse} keytype;
/* The keycode of the last key read */
static short lastkey;
/* The Time at which the last key was read */
static ULONG secs, micros;
/* Path to executable */
char *hp11name;
char hp11path[PATHLEN];
static struct timerequest *timer; /* The timer which is used */
static struct NewWindow hp11new = { /* Desired window */
0,0, /* Position of top left corner */
HP11WIDTH + 6, HP11HEIGHT + 14, /* Width, Height */
-1,-1, /* Use default pens to draw window */
CLOSEWINDOW | MOUSEBUTTONS | VANILLAKEY | MENUPICK,
WINDOWDEPTH | WINDOWCLOSE | WINDOWDRAG | SMART_REFRESH | NOCAREREFRESH,
NULL, NULL,
"HP11C", NULL,
NULL,
0, 0, 0, 0,
WBENCHSCREEN /* It opens in the main screen */
};
static struct IntuiText canceltext = {
AUTOFRONTPEN, AUTOBACKPEN,
AUTODRAWMODE,
AUTOLEFTEDGE, AUTOTOPEDGE,
AUTOITEXTFONT,
"Cancel",
AUTONEXTTEXT
};
static struct IntuiText nomemtext = {
AUTOFRONTPEN, AUTOBACKPEN,
AUTODRAWMODE,
20, 10,
AUTOITEXTFONT,
"Not enough memory",
NULL
};
char *mygetpath(to, l)
register char *to;
register BPTR l;
{
register BPTR tl;
register int notfirst = FALSE;
register struct FileInfoBlock *fib = (struct FileInfoBlock *)AllocMem(sizeof(struct FileInfoBlock), 0);
if (!fib) return(NULL);
to[0] = '\0';
do {
if (!Examine(l, fib)) return(NULL);
if (fib->fib_DirEntryType > 0) strins(to, "/");
if (fib->fib_FileName[0] == '\0') strins(to, "RAM");
else strins(to, fib->fib_FileName);
tl = l;
l = ParentDir(l);
if (notfirst) UnLock(tl);
notfirst = TRUE;
} while (l);
*(strchr(to, '/')) = ':';
FreeMem((char *)fib, sizeof(struct FileInfoBlock));
return(to);
}
void split(char *file, char *path, char **name)
{
int l = strlen(file);
*name = file + l;
while (--l >= 0 && (*--*name != '/' && **name != ':')) ;
if (l < 0)
path[0] = '\0';
else
{
++*name;
strncpy(path, file, l + 1);
path[l + 1] = '\0';
}
}
/* Delete a timer */
static void DeleteTimer(struct timerequest *tr)
{
TimerBase = (struct Library *)(-1); /* Don't call any more ! */
if (tr != NULL)
{
/* Remove the port */
if (tr->tr_node.io_Message.mn_ReplyPort) DeletePort(tr->tr_node.io_Message.mn_ReplyPort);
CloseDevice((struct IORequest *)tr); /* Close the device */
DeleteExtIO((struct IORequest *)tr); /* Free the IO request */
}
}
/* Create a timer of type unit */
static struct timerequest *CreateTimer(ULONG unit)
{
register long error;
register struct MsgPort *timerport;
register struct timerequest *timermsg;
if ((timerport = CreatePort(NULL, 0)) == NULL) /* first get a port */
return(NULL); /* failed */
if ((timermsg = (struct timerequest *) /* Then create an IO request for the timer */
CreateExtIO(timerport, sizeof(struct timerequest))) == NULL)
return(NULL); /* failed */
if ((error = OpenDevice(TIMERNAME, unit, (struct IORequest *)timermsg, 0)) != 0) /* Finally, open the timer device */
{ /* failed */
DeleteTimer(timermsg);
return(NULL);
}
TimerBase = (struct Library *)timermsg->tr_node.io_Device; /* Allow calls to the time arithmetic routines */
return(timermsg);
}
/* Wait for a specified duration */
static void WaitFor(struct timeval *tv)
{
timer->tr_node.io_Command = TR_ADDREQUEST;
timer->tr_time = *tv;
DoIO((struct IORequest *)timer); /* Wait for completion of request */
}
/* Obtain the system time, assume global timer contains a valid timer */
static void GetSysTime(struct timeval *tv)
{
timer->tr_node.io_Command = TR_GETSYSTIME;
DoIO((struct IORequest *)timer);
*tv = timer->tr_time; /* Copy obtained time */
}
/* Reverse the key on the keyboard (as if user was holding it down) */
static void ReverseKey(int key)
{
register int kx, ky, h;
if (key == 30) h = KEYHEIGHT - 1; /* ON, higher than average */
else if (key == 25) h = MAXHEIGHT + TOPKEYHEIGHT - 1; /* ENTER, even taller */
else h = TOPKEYHEIGHT - 1;
/* -------------------- */
/* Check for bug when using short int */
kx = (key % 10) * MAXWIDTH + KEYX; /* Calc. key position */
ky = (key / 10) * MAXHEIGHT + KEYY;
SetDrMd(hp11->RPort, COMPLEMENT); /* Draw in reverse */
RectFill(hp11->RPort, (long)kx, (long)ky, (long)(kx + (KEYWIDTH - 1)), (long)(ky + h));
}
/* From positions x & y, deduce which key was pressed */
static int DecodeKey(int x, int y)
{
register int kx, ky, px, py;
kx = (x - KEYX) / MAXWIDTH; px = (x - KEYX) % MAXWIDTH;
ky = (y - KEYY) / MAXHEIGHT; py = (y - KEYY) % MAXHEIGHT;
if (/* first, check if in keyboard. x & y are tested (instead of kx, ky)
because kx & ky suffer a roundoff towards zero for negative values */
(x >= KEYX && y >= KEYY && kx <= 9 && ky <= 3)
&&
/* now the condition on width */
(px < KEYWIDTH && px >= 0) /* same for all keys */
&&
/* condition on height, 2 cases for ENTER is different */
(
(kx == 5 && (ky == 2 || (ky == 3 && py < KEYHEIGHT) && (ky = 2))) /* ENTER, set ky to correct value when ky == 3 */
|| /* condition on height */
(py < KEYHEIGHT && py >= 0)
)
) return(ky * 10 + kx);
else return(-1);
}
/* Mouse was pressed at x,y. Is this a key ? */
static int GetMouseKey(int x, int y)
{
int key;
if ((key = DecodeKey(x, y)) != -1) { /* yes */
ReverseKey(key);
keytype = mouse; /* info for RelKey() */
}
return(key);
}
/* Key keycode was pressed by the user */
static int GetKeyKey(int _keycode)
{
register int key = -1, keycode = tolower(_keycode);
switch (keycode) {
case ESC: key = 30; break;
case '7': case '8': case '9': key = keycode - ('7' - 6); break;
case '4': case '5': case '6': key = keycode - ('4' - 16); break;
case '1': case '2': case '3': key = keycode - ('1' - 26); break;
case '0': key = 36; break;
case '.': key = 37; break;
case '^': key = 3; break;
case '*': key = 19; break;
case '-': key = 29; break;
case '+': key = 39; break;
case '/': key = 9; break;
case '_': key = 5; break;
case CR : key = 25; break;
case 'f': key = 31; break;
case 'g': key = 32; break;
case BS : key = 24; break;
case 's': key = 12; break;
case 'c': key = 13; break;
case 't': key = 14; break;
}
if (key != -1) { /* A valid key was given */
ReverseKey(key);
keytype = keyboard; /* for RelKey() */
}
return(key);
}
/* Get a key from the keyboard with/without waiting */
int PollKey(wait)
int wait;
{
register int key;
register struct IntuiMessage *msg;
register ULONG class;
register UWORD code;
register WORD x, y;
register APTR address;
key = -1; /* no key yet */
do {
if (wait) WaitPort(hp11->UserPort); /* No active waits in multi-tasking ! */
msg = (struct IntuiMessage *)GetMsg(hp11->UserPort); /* Get the message if there is one */
if (msg) { /* yes, there is */
/* Copy relevant information */
class = msg->Class;
code = msg->Code;
address = msg->IAddress;
x = msg->MouseX;
y = msg->MouseY;
secs = msg->Seconds;
micros = msg->Micros;
ReplyMsg((struct Message *)msg); /* & reply to it */
switch (class) { /* type of message */
case CLOSEWINDOW: /* Window closed = Quit */
quit = TRUE;
key = BRESET;
keytype = gadget;
break;
case MOUSEBUTTONS: /* A mouse button was pressed */
if (code == SELECTDOWN)
key = GetMouseKey(x, y);
break;
case VANILLAKEY: /* a key was pressed */
key = GetKeyKey(code);
break;
case MENUPICK: /* A menu option was chosen */
key = MenuHandler(code); /* Call menu handler */
keytype = menu; /* for RelKey() */
break;
}
}
} while (key == -1 && (msg || wait));
/* Exit if key read or, if not waiting, no message ready */
lastkey = key; /* save key for RelKey() */
return(key);
}
/* Wait for latest key to be released, returns true if button released
over key (valid only for mouse) */
BOOL RelKey()
{
register WORD x, y;
register BOOL Released;
register struct IntuiMessage *msg;
struct timeval event, now, delay;
register int key = lastkey; /* key last pressed */
lastkey = -1; /* Only release it once ! */
if (key != -1)
switch (keytype) {
case keyboard: /* Key reversed for a max of .08 secs
(There is no easy way to wait for its release on the keyboard) */
event.tv_secs = secs; event.tv_micro = micros;
GetSysTime(&now);
SubTime(&now, &event); /* Time elapsed since key pressed */
delay.tv_secs = 0; delay.tv_micro = 80000;
if (CmpTime(&now, &delay) == 1) { /* now < delay */
SubTime(&delay, &now);
WaitFor(&delay); /* Wait long enough */
}
ReverseKey(key); /* un-reverse key */
return(TRUE);
case mouse:
Released = FALSE;
do { /* Wait for mouse button to be released */
WaitPort(hp11->UserPort);
msg = (struct IntuiMessage *)GetMsg(hp11->UserPort);
x = msg->MouseX;
y = msg->MouseY;
Released = (msg->Class == MOUSEBUTTONS && msg->Code == SELECTUP);
ReplyMsg((struct Message *)msg);
} while (!Released);
ReverseKey(key); /* un-reverse key */
return((BOOL)(DecodeKey(x, y) == key)); /* Button released over key? */
}
return(TRUE); /* if already released */
}
/* load picture from open file file, width pixel wide, height pixels high,
depth bitplanes deep into bitmap bm & colormap cols (if non-null) */
static BOOL LoadBitMap(LONG file, struct BitMap *bm, int width, int height,
int depth)
{
register int i;
register LONG nb, plsize;
InitBitMap(bm, (long)depth, (long)width, (long)height);
plsize = bm->BytesPerRow * bm->Rows; /* size of 1 plane */
/* Allocate enough memory for all planes, initialise plane pointers */
if (!(bm->Planes[0] = (PLANEPTR)AllocMem(plsize * depth, MEMF_CHIP))) return((BOOL) FALSE);
for (i = 1; i < depth; i++) bm->Planes[i] = bm->Planes[0] + plsize * i;
/* Read data from disk */
for (i = 0; i < bm->Depth; i++) {
nb = Read(file, bm->Planes[i], plsize);
if (nb < plsize) return((BOOL) FALSE);
}
return((BOOL) TRUE);
}
void alert(struct Window *win, char *msg1, char *msg2)
{
static struct TextAttr alert_attr = { "topaz.font", 8 };
struct TextFont *alert_font;
struct IntuiText text1, text2, negative;
const static struct IntuiText template = {
0, 1, JAM1,
8, 0,
&alert_attr
};
int width, height;
int ysize;
alert_font = OpenFont(&alert_attr);
ysize = alert_font ? alert_font->tf_YSize : 8;
text1 = text2 = negative = template;
text1.TopEdge = 8;
text1.IText = msg1;
width = IntuiTextLength(&text1) + 40;
height = 37 + 2 * ysize;
if (msg2 != NULL)
{
int w;
text1.NextText = &text2;
text2.TopEdge = text1.TopEdge + ysize;
text2.IText = msg2;
height += ysize;
w = IntuiTextLength(&text2) + 20;
if (w > width) width = w;
}
negative.LeftEdge = 6;
negative.TopEdge = 4;
negative.IText = "Ok";
AutoRequest(win, &text1, NULL, &negative, 0L, 0L, width, height);
}
/* Amiga specific initialisation */
#define argw ((struct WBStartup *)argv)
BOOL AmigaInit(argc, argv)
int argc;
APTR argv;
{
register LONG file;
register BOOL loaded;
struct BitMap hp11bitmap;
BPTR hp11dir, old;
char filename[PATHLEN + 8];
if (!(GfxBase = (struct GfxBase *)OpenLibrary("graphics.library", 33))) /* Open graphics library (1.2) */
return(FALSE);
if (!(IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library", 33))) /* Open intuition library (1.2) */
return(FALSE);
if (!(LayersBase = (struct LayersBase *)OpenLibrary("layers.library", 0)))
return(FALSE);
/* Find path to command (if possible) */
if (argc == 0) /* WB */
{
old = CurrentDir(argw->sm_ArgList[0].wa_Lock);
split(argw->sm_ArgList[0].wa_Name, hp11path, &hp11name);
hp11dir = Lock(hp11path, ACCESS_READ);
if (!mygetpath(hp11path, hp11dir)) hp11path[0] = '\0';
CurrentDir(old);
UnLock(hp11dir);
}
else
{ /* CLI */
split(((char **)argv)[0], hp11path, &hp11name);
}
/* Read the picture */
if (!(file = Open(strcat(strcpy(filename, hp11path), "hp11.pic"), MODE_OLDFILE)))
if (!(file = Open("hp11.pic", MODE_OLDFILE)))
{
alert(NULL, "Can't find hp11.pic", NULL);
return(FALSE);
}
loaded = LoadBitMap(file, &hp11bitmap, HP11WIDTH, HP11HEIGHT, 2);
Close(file);
if (!loaded) return(FALSE);
/* Open the window */
if (!(hp11 = OpenWindow(&hp11new))) return(FALSE);
/* Move picture into window */
BltBitMapRastPort(&hp11bitmap, 0, 0, hp11->RPort, HP11X, HP11Y, HP11WIDTH, HP11HEIGHT, COPY);
FreeMem(hp11bitmap.Planes[0], (long)(hp11bitmap.BytesPerRow * hp11bitmap.Rows * hp11bitmap.Depth));
/* Create timer */
if ((timer = CreateTimer(UNIT_MICROHZ)) == NULL) return(FALSE);
/* Init menus */
return(MenusInit(argc, argv));
}
#undef argw
void AmigaCleanUp()
{
MenusCleanUp();
if (timer) DeleteTimer(timer); /* Close timer */
if (hp11) CloseWindow(hp11);
if (LayersBase) CloseLibrary((struct Library *)LayersBase);
if (IntuitionBase) CloseLibrary((struct Library *)IntuitionBase); /* Close libraries */
if (GfxBase) CloseLibrary((struct Library *)GfxBase);
}
/* Display s */
void Display(s)
register char *s;
{
register int posx;
register int chr;
register struct RastPort *rport = hp11->RPort;
/* Clear display */
SetDrMd(rport, JAM1); SetAPen(rport, 2);
RectFill(rport, SCRX0 + 1, SCRY0, SCRX1 - 1, SCRY1);
/* Initial position */
posx = SCRX0 + CHAROFFX;
while (*s) {
switch (*s) { /* Position of char in char array */
case '0': case '1': case '2': case '3': case '4': case '5': case '6':
case '7': case '8': case '9': chr = *s - '0'; break;
case '-': chr = 10; break;
case 'E': chr = 11; break;
case 'r': chr = 12; break;
case 'o': chr = 13; break;
case 'R': chr = 14; break;
case 'u': chr = 15; break;
case 'n': chr = 16; break;
case 'i': chr = 17; break;
case 'g': chr = 18; break;
case '.': chr = 19; break;
case ',': chr = 20; break;
case 'P': chr = 21; break;
default: chr = -1; break;
}
if (chr != -1)
DrawBorder(rport, hp11char[chr], (long)posx, SCRY0 + CHAROFFY);
if (*s != '.' && *s != ',') posx += CHARWIDTH;
s++;
}
}
/* Set image to be drawn/erased according to on */
static void SetCol(struct Image *im, int on)
{
if (on) {
im->PlanePick = 3;
im->PlaneOnOff = 0;
}
else {
im->PlanePick = 0;
im->PlaneOnOff = 2;
}
}
/* Display the indicators */
void Dispf(on)
int on;
{
SetCol(&fImage, on);
DrawImage(hp11->RPort, &fImage, fX, INDICY);
}
void Dispg(on)
int on;
{
SetCol(&gImage, on);
DrawImage(hp11->RPort, &gImage, gX, INDICY);
}
void DispUSER(on)
int on;
{
SetCol(&USERImage, on);
DrawImage(hp11->RPort, &USERImage, USERX, INDICY);
}
void DispG(on)
int on;
{
SetCol(&GImage, on);
DrawImage(hp11->RPort, &GImage, GX, INDICY);
}
void DispRAD(on)
int on;
{
SetCol(&RADImage, on);
DrawImage(hp11->RPort, &RADImage, RADX, INDICY);
}
void DispPRGM(on)
int on;
{
SetCol(&PRGMImage, on);
DrawImage(hp11->RPort, &PRGMImage, PRGMX, INDICY);
}
void beep(void)
{
DisplayBeep(NULL);
}
static struct Window *MakeIcon(struct Image *image,
struct BitMap *bm, struct BitMap *tmpbm,
LONG x, LONG y, LONG w, LONG h)
{
register struct Window *win;
register ULONG size;
static struct NewWindow new_win =
{ 0, 0, 0, 0, -1, -1, MOUSEBUTTONS | MOUSEMOVE | INACTIVEWINDOW | NOCAREREFRESH,
SMART_REFRESH | BORDERLESS | REPORTMOUSE | RMBTRAP,
NULL, NULL, NULL, NULL, NULL, 0, 0, 0, 0, WBENCHSCREEN };
new_win.LeftEdge = x; new_win.TopEdge = y;
new_win.Width = w; new_win.Height = h;
InitBitMap(bm, 2, w, h);
size = bm->BytesPerRow * bm->Rows; /* size of 1 plane */
bm->Planes[0] = (PLANEPTR)image->ImageData;
bm->Planes[1] = (PLANEPTR)(image->ImageData) + size;
InitBitMap(tmpbm, 2, w, h);
if (!(tmpbm->Planes[0] = (PLANEPTR)AllocMem(2 * size, MEMF_CHIP)))
return(NULL);
tmpbm->Planes[1] = tmpbm->Planes[0] + size;
if (win = OpenWindow(&new_win)) DrawImage(win->RPort, image, 0, 0);
else FreeMem(tmpbm->Planes[0], 2 * size);
return(win);
}
static void GetBounds(struct Window *win, LONG *mx, LONG *my,
LONG w, LONG h, LONG wx, LONG wy)
{
struct Screen *scr = win->WScreen;
*mx = scr->MouseX - wx; *my = scr->MouseY - wy;
if (*mx + w > scr->Width) *mx = scr->Width - w;
else if (*mx < 0) *mx = 0;
if (*my + h > scr->Height) *my = scr->Height - h;
else if (*my < 0) *my = 0;
}
static void SwapImage(struct BitMap *scrbm, struct BitMap *drawing,
struct BitMap *buf, LONG x, LONG y, LONG w, LONG h)
{
BltBitMap(scrbm, x, y, buf, 0, 0, w, h, COPY, 0xff, NULL);
BltBitMap(drawing, 0, 0, scrbm, x, y, w, h, COPY, 0xff, NULL);
BltBitMap(buf, 0, 0, drawing, 0, 0, w, h, COPY, 0xff, NULL);
}
static void Iconize(struct Image *image, LONG x, LONG y)
{
register struct Window *win;
register struct Screen *scr;
register struct IntuiMessage *msg;
LONG mx, my, wx, wy;
register LONG w, h;
ULONG oldsecs = 0, oldmicros = 0;
BOOL cont, moved;
register BOOL down, wasdown;
struct BitMap image_bm, tmpbm;
w = image->Width; h = image->Height;
win = MakeIcon(image, &image_bm, &tmpbm, x, y, w, h);
if (win)
{
scr = win->WScreen;
cont = TRUE;
down = FALSE;
do {
moved = FALSE; wasdown = down;
WaitPort(win->UserPort);
while (msg = (struct IntuiMessage *)GetMsg(win->UserPort))
{
switch (msg->Class)
{
case MOUSEBUTTONS:
if (msg->Code == SELECTUP)
{
if (DoubleClick(oldsecs, oldmicros, msg->Seconds, msg->Micros))
cont = FALSE;
else {
oldsecs = msg->Seconds;
oldmicros = msg->Micros;
}
}
down = (msg->Code == SELECTDOWN);
break;
case INACTIVEWINDOW: down = FALSE; break;
case MOUSEMOVE: moved = TRUE; break;
}
ReplyMsg((struct Message *)msg);
}
if (!wasdown && down)
{
wx = win->MouseX; wy = win->MouseY;
GetBounds(win, &mx, &my, w, h, wx, wy);
LockLayers(&scr->LayerInfo);
SwapImage(&scr->BitMap, &image_bm, &tmpbm, mx, my, w, h);
}
else if (wasdown)
if (down)
{
if (moved)
{
SwapImage(&scr->BitMap, &image_bm, &tmpbm, mx, my, w, h);
GetBounds(win, &mx, &my, w, h, wx, wy);
SwapImage(&scr->BitMap, &image_bm, &tmpbm, mx, my, w, h);
}
}
else
{
SwapImage(&scr->BitMap, &image_bm, &tmpbm, mx, my, w, h);
UnlockLayers(&scr->LayerInfo);
MoveWindow(win, (long)(mx - win->LeftEdge), (long)(my - win->TopEdge));
}
} while (cont || down);
CloseWindow(win);
FreeMem(tmpbm.Planes[0], 2 * RASSIZE(w, h));
}
}
void sleep()
{
struct BitMap hp11bitmap;
struct RastPort hp11rport;
register LONG plsize;
register LONG x, y;
/* Save picture in bitmap */
InitBitMap(&hp11bitmap, 2, HP11WIDTH, HP11HEIGHT);
plsize = hp11bitmap.BytesPerRow * hp11bitmap.Rows; /* size of 1 plane */
/* Allocate enough memory for all planes, initialise plane pointers */
if (!(hp11bitmap.Planes[0] = (PLANEPTR)AllocMem(plsize * 2, MEMF_CHIP)))
Message("Not enough memory");
else
{
hp11bitmap.Planes[1] = hp11bitmap.Planes[0] + plsize;
InitRastPort(&hp11rport);
hp11rport.BitMap = &hp11bitmap;
ClipBlit(hp11->RPort, HP11X, HP11Y, &hp11rport, 0, 0,
HP11WIDTH, HP11HEIGHT, COPY);
Forbid();
x = hp11->LeftEdge; y = hp11->TopEdge;
Permit();
ClearMenuStrip(hp11);
CloseWindow(hp11);
Iconize(&off_image, x, y);
/* Open the window */
hp11new.LeftEdge = x; hp11new.TopEdge = y;
if (!(hp11 = OpenWindow(&hp11new)))
{
AutoRequest(NULL, &nomemtext, NULL, &canceltext, NULL, NULL, 250, 60);
quit = TRUE;
}
else {
/* Move picture into window */
BltBitMapRastPort(&hp11bitmap, 0, 0, hp11->RPort, HP11X, HP11Y, HP11WIDTH, HP11HEIGHT, COPY);
FreeMem(hp11bitmap.Planes[0], (long)(hp11bitmap.BytesPerRow * hp11bitmap.Rows * hp11bitmap.Depth));
SetMenuStrip(hp11, hp11menu);
on = TRUE;
}
}
}