/*
 * This source file is Copyright 1995 by Evan Scott.
 * All rights reserved.
 * Permission is granted to distribute this file provided no
 * fees beyond distribution costs are levied.
 */

#include <exec/types.h>
#include <exec/memory.h>
#include <exec/alerts.h>

#include <intuition/intuition.h>
#include <intuition/sghooks.h>

#include <dos/dos.h>
#include <dos/dosextens.h>

#include <libraries/commodities.h>
#include <libraries/gadtools.h>

#include <proto/exec.h>
#include <proto/graphics.h>
#include <proto/intuition.h>
#include <proto/commodities.h>
#include <proto/gadtools.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "evtypes.h"
#include "verify.h"
#include "ftp.h"
#include "site.h"

#include "globals.h"
#include "strings.h"

#include "request.h"

#define V_IntuiText 18798
#define V_Gadget 18273

#define V_rastport 1001
#define V_bitmap 1008

struct RastPort *make_rastport(b32 width, b32 height, b32 depth, struct GfxBase *GfxBase)
{
	struct RastPort *rp;
	struct BitMap *bm;
	int i;
	b8 *z;
	
	rp = (struct RastPort *)allocate_flags(sizeof(*rp), MEMF_PUBLIC | MEMF_CLEAR, V_rastport);
	if (!rp) return 0;
	
	bm = (struct BitMap *)allocate_flags(sizeof(*bm), MEMF_PUBLIC | MEMF_CLEAR, V_bitmap);
	if (bm) {		
		InitBitMap(bm, depth, width, height);
		
		bm->Planes[0] = AllocRaster(width, height * depth);
		if (bm->Planes[0]) {
			z = (b8 *)bm->Planes[0];
			for (i = 1; i < depth; i++) {
				z += bm->BytesPerRow * bm->Rows;
				bm->Planes[i] = (void *)z;
			}
			InitRastPort(rp);
			
			rp->BitMap = bm;
			rp->Mask = 0xff;
			
			return rp;
		}
		
		deallocate(bm, V_bitmap);
	}
	
	deallocate(rp, V_rastport);
	
	return 0;
}

void free_rastport(struct RastPort *rp, struct GfxBase *GfxBase)
{
	FreeRaster(rp->BitMap->Planes[0], rp->BitMap->BytesPerRow * 8, rp->BitMap->Rows * rp->BitMap->Depth);

	deallocate(rp->BitMap, V_bitmap);
	deallocate(rp, V_rastport);
}

struct IntuiText nulltext = {
	0, 0,
	JAM1,
	0, 0,
	(void *)0,
	"",
	(void *)0
};

struct gim *make_gim(b8 *name, b32 textpen, b32 lightpen, b32 darkpen, struct Screen *s, 
			struct IntuitionBase *IntuitionBase, struct GfxBase *GfxBase)
{
	struct IntuiText txt;
	int width, height, owidth, oheight;
	struct gim *gim;
	sb32 x, y, Rx, Ry, Rx2, Ry2, R2, new_delta, old_delta;
	
	txt.FrontPen = textpen;
	txt.BackPen = 0;
	txt.DrawMode = JAM2;
	txt.LeftEdge = 0;
	txt.TopEdge = 0;
	txt.ITextFont = s->Font;
	txt.IText = name;
	txt.NextText = nil;
	
	if (s->Font) height = s->Font->ta_YSize;
	else height = 8;
	
	width = IntuiTextLength(&txt);
	
	owidth = width + height;
	oheight = 3 * height / 2;
	
	gim = (struct gim *)allocate(sizeof(*gim), V_gim);
	if (!gim) return nil;
	
	ensure(gim, V_gim);
	
	gim->rp1 = make_rastport(owidth, oheight, 3, GfxBase);
	if (!gim->rp1) {
		deallocate(gim, V_gim);
		return nil;
	}
	
	gim->rp2 = make_rastport(owidth, oheight, 3, GfxBase);
	if (!gim->rp2) {
		free_rastport(gim->rp1, GfxBase);
		deallocate(gim, V_gim);
		return nil;
	}
	
	gim->im1.LeftEdge = 0;
	gim->im1.TopEdge = 0;
	gim->im1.Width = owidth;
	gim->im1.Height = oheight;
	gim->im1.Depth = 3;
	gim->im1.ImageData = (void *)gim->rp1->BitMap->Planes[0];
	
	gim->im1.PlanePick = 7;
	gim->im1.PlaneOnOff = 0;
	gim->im1.NextImage = nil;
	
	gim->im2 = gim->im1;
	gim->im2.ImageData = (void *)gim->rp2->BitMap->Planes[0];
	
	SetRast(gim->rp1, 0);
	SetRast(gim->rp2, 0);
	
	PrintIText(gim->rp1, &txt, height / 2, height / 4);
	PrintIText(gim->rp2, &txt, height / 2 + 1, height / 4 + 1);
	
	Rx = Ry = 2 * height / 3;
	
	Rx2 = Rx * Rx;
	Ry2 = Ry * Ry;
	
	R2 = Rx2 * Ry2;
	
	for (x = 0; x < Rx; x++) {
		y = 0;
		new_delta = abs(R2 - Ry2*x*x - Rx2*y*y);
		do {
			old_delta = new_delta;
			y++;
			new_delta = abs(R2 - Ry2*x*x - Rx2*y*y);
		} while (old_delta > new_delta);
		
		SetAPen(gim->rp1, lightpen);
		
		WritePixel(gim->rp1, Rx - x, Ry - (y - 1));
		WritePixel(gim->rp1, owidth - Rx - 1 + x, Ry - (y - 1));
		
		SetAPen(gim->rp1, darkpen);
		
		WritePixel(gim->rp1, Rx - x, oheight - Ry - 1 + (y - 1));
		WritePixel(gim->rp1, owidth - Rx - 1 + x, oheight - Ry - 1 + (y - 1));
		
		SetAPen(gim->rp2, darkpen);
		
		WritePixel(gim->rp2, Rx - x, Ry - (y - 1));
		WritePixel(gim->rp2, owidth - Rx - 1 + x, Ry - (y - 1));
		
		SetAPen(gim->rp2, lightpen);
		
		WritePixel(gim->rp2, Rx - x, oheight - Ry - 1 + (y - 1));
		WritePixel(gim->rp2, owidth - Rx - 1 + x, oheight - Ry - 1 + (y - 1));
	}
	
	for (y = 0; y < Ry; y++) {
		x = 0;
		new_delta = abs(R2 - Ry2 * x * x - Rx2 * y * y);
		do {
			old_delta = new_delta;
			x++;
			new_delta = abs(R2 - Ry2 * x * x - Rx2 * y * y);
		} while (old_delta > new_delta);
		
		SetAPen(gim->rp1, lightpen);
		
		WritePixel(gim->rp1, Rx - (x - 1), Ry - y);
		WritePixel(gim->rp1, Rx - (x - 1), oheight - Ry - 1 + y);

		SetAPen(gim->rp1, darkpen);

		WritePixel(gim->rp1, owidth - Rx - 1 + (x - 1), Ry - y);
		WritePixel(gim->rp1, owidth - Rx - 1 + (x - 1), oheight - Ry - 1 + y);
		
		SetAPen(gim->rp2, darkpen);
		
		WritePixel(gim->rp2, Rx - (x - 1), Ry - y);
		WritePixel(gim->rp2, Rx - (x - 1), oheight - Ry - 1 + y);

		SetAPen(gim->rp2, lightpen);

		WritePixel(gim->rp2, owidth - Rx - 1 + (x - 1), Ry - y);
		WritePixel(gim->rp2, owidth - Rx - 1 + (x - 1), oheight - Ry - 1 + y);
	}
	
	SetAPen(gim->rp1, lightpen);
	
	Move(gim->rp1, Rx, 0);
	Draw(gim->rp1, owidth - Rx - 1, 0);
	
	Move(gim->rp1, 0, Ry);
	Draw(gim->rp1, 0, oheight - Ry - 1);
	
	SetAPen(gim->rp1, darkpen);
	
	Move(gim->rp1, Rx, oheight - 1);
	Draw(gim->rp1, owidth - Rx - 1, oheight - 1);
	
	Move(gim->rp1, owidth - 1, Ry);
	Draw(gim->rp1, owidth - 1, oheight - Ry - 1);

	SetAPen(gim->rp2, darkpen);
	
	Move(gim->rp2, Rx, 0);
	Draw(gim->rp2, owidth - Rx - 1, 0);
	
	Move(gim->rp2, 0, Ry);
	Draw(gim->rp2, 0, oheight - Ry - 1);
	
	SetAPen(gim->rp2, lightpen);
	
	Move(gim->rp2, Rx, oheight - 1);
	Draw(gim->rp2, owidth - Rx - 1, oheight - 1);
	
	Move(gim->rp2, owidth - 1, Ry);
	Draw(gim->rp2, owidth - 1, oheight - Ry - 1);
	
	return gim;
}

void free_gim(struct gim *gim, struct IntuitionBase *IntuitionBase, struct GfxBase *GfxBase)
{
	verify(gim, V_gim);

	free_rastport(gim->rp1, GfxBase);
	free_rastport(gim->rp2, GfxBase);
	deallocate(gim, V_gim);
	
	return;
}

struct Gadget *make_gadget(struct gim *gim)
{
	struct Gadget *g;
	
	if (!gim) return nil;

	verify(gim, V_gim);
	
	g = (struct Gadget *)allocate(sizeof(*g), V_Gadget);
	if (!g) return nil;
	
	g->NextGadget = nil;
	g->LeftEdge = 0;
	g->TopEdge = 0;
	g->Width = gim->im1.Width;
	g->Height = gim->im1.Height;
	
	g->Flags = GFLG_GADGHIMAGE | GFLG_GADGIMAGE;
	g->Activation = GACT_RELVERIFY;
	g->GadgetType = GTYP_BOOLGADGET;
	g->GadgetRender = &gim->im1;
	g->SelectRender = &gim->im2;
	g->GadgetText = &nulltext;
	
	g->MutualExclude = 0;
	g->SpecialInfo = nil;
	g->GadgetID = 0;
	g->UserData = nil;
	
	return g;
}

void free_gadget(struct Gadget *g)
{
	deallocate(g, V_Gadget);
}

struct Window *connect_req(site *sp, b8 *s)
{
	struct Window *w;
	struct IntuitionBase *IntuitionBase;
	struct GfxBase *GfxBase;
	struct Screen *pub_screen;
	b32 screen_modeID;
	struct Rectangle rect;
	struct Gadget *cancel;
	struct IntuiText txt;
	int width, swidth, sheight, fheight;
	b8 *z;
	
	verify(sp, V_site);
	
	GfxBase = sp->GBase;
	IntuitionBase = sp->IBase;
	
	pub_screen = LockPubScreen(nil);
	if (pub_screen) {
		screen_modeID = GetVPModeID(&pub_screen->ViewPort);
		if (screen_modeID != INVALID_ID) {
			if (QueryOverscan(screen_modeID, &rect, OSCAN_TEXT)) {
				cancel = make_gadget(cancel_gim);
				if (cancel) {
					z = (b8 *)allocate(strlen(s) + 19, V_cstr);
					if (z) {
						strcpy(z, strings[MSG_CONNECTING_TO]);
						strcat(z, s);
						strcat(z, " ...");
						
						txt.FrontPen = 1;
						txt.BackPen = 0;
						txt.DrawMode = JAM1;
						txt.LeftEdge = 0;
						txt.TopEdge = 0;
						txt.ITextFont = pub_screen->Font;
						txt.IText = z;
						txt.NextText = nil;
						
						if (pub_screen->Font) fheight = pub_screen->Font->ta_YSize;
						else fheight = 8;
						
						width = IntuiTextLength(&txt) * 4 / 3;
						
						txt.LeftEdge = width / 8;
						txt.TopEdge = fheight / 2;
						
						swidth = rect.MaxX - rect.MinX + 1;
						sheight = rect.MaxY - rect.MinY + 1;
						
						if (pub_screen->TopEdge > 0)
							sheight -= pub_screen->TopEdge;
						
						if (sheight > pub_screen->Height) sheight = pub_screen->Height;
						if (swidth > pub_screen->Width) swidth = pub_screen->Width;
						
						if (sheight < fheight * 6) sheight = fheight * 6;
						if (swidth < width) swidth = width;
						
						w = OpenWindowTags(nil,
							WA_Left,	swidth / 2 - pub_screen->LeftEdge - width / 2,
							WA_Top,		sheight / 2 - pub_screen->TopEdge - fheight * 3,
							WA_Width,	width,
							WA_Height,	fheight * 6,
							WA_Flags,	WFLG_DEPTHGADGET | WFLG_DRAGBAR |
									WFLG_SMART_REFRESH | 
									WFLG_NOCAREREFRESH,
							WA_IDCMP,	IDCMP_GADGETUP,
							WA_PubScreen,	pub_screen,
							WA_Title,	strings[MSG_CONNECTING],
							TAG_END,	0
						);
						
						if (w) {
							UnlockPubScreen(nil, pub_screen);
							PrintIText(w->RPort, &txt, 0, w->BorderTop);
							deallocate(z, V_cstr);
							w->UserData = (void *)cancel;
							cancel->LeftEdge = w->Width - w->BorderRight - fheight / 2 - cancel->Width;
							cancel->TopEdge = w->Height - w->BorderBottom - fheight / 3 - cancel->Height;
							AddGadget(w, cancel, (b32)0);
							RefreshGList(cancel, w, nil, 1);
							
							return w;
						}
						
						deallocate(z, V_cstr);
					}
					
					free_gadget(cancel);
				}
			}
		}
		UnlockPubScreen(nil, pub_screen);
	}
	
	return nil;
}

void close_req(site *sp, struct Window *w)
{
	struct Gadget *cancel;
	struct Message *msg;
	
	struct IntuitionBase *IntuitionBase;
	
	verify(sp, V_site);
	
	IntuitionBase = sp->IBase;
	
	Forbid();
	while (msg = GetMsg(w->UserPort)) ReplyMsg(msg);

	cancel = (struct Gadget *)w->UserData;
	RemoveGadget(w, cancel);

	free_gadget(cancel);
	
	CloseWindow(w);
	Permit();
}

struct phdata {
	b8 password[MAX_PASS_LENGTH + 1];
	b8 undo[MAX_PASS_LENGTH + 1];
};

boolean __saveds __asm password_hook(register __a0 struct Hook *hook, 
				register __a1 b32 *msg, 
				register __a2 struct SGWork *sgw)
{
	struct phdata *phd;
	
	phd = hook->h_Data;
	
	if (*msg == SGH_KEY) {
		switch (sgw->EditOp) {
		case EO_REPLACECHAR:
		case EO_INSERTCHAR:
			phd->password[sgw->BufferPos - 1] = sgw->WorkBuffer[sgw->BufferPos - 1];
			sgw->WorkBuffer[sgw->BufferPos - 1] = '*';
			break;
		case EO_MOVECURSOR:
			sgw->Actions &=~ SGA_USE;
			sgw->Actions |= SGA_BEEP;
			break;
		case EO_RESET:
			strcpy(phd->password, phd->undo);
			break;
		}
		if (sgw->BufferPos != sgw->NumChars) {
			sgw->BufferPos = sgw->NumChars;
			sgw->Actions |= SGA_REDISPLAY;
		}
		phd->password[sgw->NumChars] = 0;
		return true;
	} else if (*msg == SGH_CLICK) {
		sgw->BufferPos = sgw->NumChars;
		sgw->Actions |= SGA_REDISPLAY;
		return true;
	} else {
		return false;
	}
}

boolean user_pass_request(site *sp, struct Window *canw)
/*
 * open a requester asking for username and password, filled in as appropriate
 * Inputs:
 *	sp	: site pointer
 *	canw	: cancel window (will still be open in the background, and may be used)
 *
 * Result:
 *	false if cancel is selected in either canw or the requester, or a major failure occurred
 *	true if login is selected, or return is pressed in password field
 */
{
	struct Gadget *glist, *gad, *login, *cancel, *userg, *passg;
	struct NewGadget user, pass;
	struct Screen *s;
	void *vi;
	b32 screen_modeID;
	struct Rectangle rect;
	struct Window *w;
	sb32 swidth, sheight, fheight, wheight;
	b32 signals, csig;
	struct IntuiMessage *im;
	struct Hook pass_hook;
	b8 *z;
	struct phdata phd;

	struct IntuitionBase *IntuitionBase;
	struct Library *GadToolsBase;
	struct GfxBase *GfxBase;
	
	verify(sp, V_site);
	
	IntuitionBase = sp->IBase;
	GfxBase = sp->GBase;
	GadToolsBase = sp->GTBase;

	glist = nil;
	
	pass_hook.h_Entry = (b32 (*)())password_hook;
	pass_hook.h_SubEntry = (b32 (*)())nil;
	pass_hook.h_Data = (void *)&phd;
	
	s = LockPubScreen(nil);
	if (!s) return false;

	ScreenToFront(s);
	
	if (s->Font) fheight = s->Font->ta_YSize;
	else fheight = 8;
	
	if (sp->password) {
		strcpy(phd.password, sp->password);
		strcpy(phd.undo, sp->password);
		
		z = sp->password;
		while (*z) {
			*z++ = '*';
		}
	} else {
		phd.password[0] = 0;
		phd.undo[0] = 0;
	}
	
	wheight = fheight * 8;
	
	vi = GetVisualInfo(s, TAG_END);
	if (vi != nil) {
		screen_modeID = GetVPModeID(&s->ViewPort);
		if (screen_modeID != INVALID_ID) {
			if (QueryOverscan(screen_modeID, &rect, OSCAN_TEXT)) {
				swidth = rect.MaxX - rect.MinX + 1;
				sheight = rect.MaxY - rect.MinY + 1;
				
				sprintf(sp->read_buffer, strings[MSG_LOGIN_TO], sp->host);
				
				w = OpenWindowTags(nil,
					WA_Left,	swidth / 4 - s->LeftEdge,
					WA_Top,		sheight / 2 - wheight / 2 - s->TopEdge,
					WA_Width,	swidth / 2,
					WA_Height,	wheight,
					WA_IDCMP,	IDCMP_ACTIVEWINDOW | IDCMP_REFRESHWINDOW | 
							BUTTONIDCMP | STRINGIDCMP,
					WA_PubScreen,	s,
					WA_Activate,	true,
					WA_DragBar,	true,
					WA_DepthGadget,	true,
					WA_Title,	sp->read_buffer,
					WA_AutoAdjust,	true,
					TAG_END
				);
				if (w) {
					gad = CreateContext(&glist);
					if (gad) {
						user.ng_LeftEdge = w->Width / 4;
						user.ng_TopEdge = w->BorderTop + fheight / 2;
						user.ng_Width = (w->Width * 3 / 4) - w->BorderRight - fheight / 2;
						user.ng_Height = fheight * 3 / 2;
						user.ng_GadgetText = strings[MSG_USER_NAME];
						user.ng_TextAttr = s->Font;
						user.ng_GadgetID = 1;
						user.ng_Flags = PLACETEXT_LEFT;
						user.ng_VisualInfo = vi;
						
						pass.ng_LeftEdge = w->Width / 4;
						pass.ng_TopEdge = w->BorderTop + (fheight * 5 / 2);
						pass.ng_Width = (w->Width * 3 / 4) - w->BorderRight - fheight / 2;
						pass.ng_Height = fheight * 3 / 2;
						pass.ng_GadgetText = strings[MSG_PASSWORD_NAME];
						pass.ng_TextAttr = s->Font;
						pass.ng_GadgetID = 2;
						pass.ng_Flags = PLACETEXT_LEFT;
						pass.ng_VisualInfo = vi;
						
						userg = gad = CreateGadget(STRING_KIND, gad, &user,
							GTST_String,	sp->user,
							GTST_MaxChars,	MAX_USER_LENGTH,
							TAG_END
						);
						
						passg = gad = CreateGadget(STRING_KIND, gad, &pass,
							GTST_String,	sp->password,
							GTST_MaxChars,	MAX_PASS_LENGTH,
							GTST_EditHook,	(b32)&pass_hook,
							TAG_END
						);
						
						if (gad) {
							login = make_gadget(login_gim);
							if (login) {
								cancel = make_gadget(cancel_gim);
								if (cancel) {
									login->LeftEdge = fheight / 2 + w->BorderLeft;
									login->TopEdge = w->Height - w->BorderBottom - login->Height - fheight / 2;
									
									cancel->LeftEdge = w->Width - w->BorderRight - cancel->Width - fheight / 2;
									cancel->TopEdge = login->TopEdge;
									
									login->GadgetID = 3;
									cancel->GadgetID = 4;
									
									AddGadget(w, cancel, 100);
									AddGadget(w, login, 100);
							
									AddGList(w, glist, 0, 100, nil);
									
									RefreshGadgets(glist, w, nil);
									GT_RefreshWindow(w, nil);
							
									goto listen;
								}
								free_gadget(login);
							}
						}
						
						FreeGadgets(glist);
					}
					CloseWindow(w);
				}
			}
		}
		FreeVisualInfo(vi);
	}
	
	UnlockPubScreen(nil, s);
	
	return false;

listen:
	csig = 1 << canw->UserPort->mp_SigBit | sp->abort_signals | sp->disconnect_signals;
	signals = (1 << w->UserPort->mp_SigBit) | csig;

	while (1) {
		if (Wait(signals) & csig) {
			CloseWindow(w);

			FreeGadgets(glist);

			free_gadget(cancel);
			free_gadget(login);

			FreeVisualInfo(vi);
			UnlockPubScreen(nil, s);
							
			return false;
		}
		
		while (im = GT_GetIMsg(w->UserPort)) {
			gad = (struct Gadget *)im->IAddress;
			
			switch (im->Class) {
			case IDCMP_ACTIVEWINDOW:
				if (sp->needs_user) {
					ActivateGadget(userg, w, nil);
				} else {
					ActivateGadget(passg, w, nil);
				}
				break;
			case IDCMP_GADGETUP:
				switch (gad->GadgetID) {
				case 1:
					if (im->Code == 0) {
						ActivateGadget(passg, w, nil);
					}
					sp->needs_user = false;
					break;
				case 2:
					if (im->Code != 0) {
						break;
					}
					/* else fall through to Login */
				case 3:
					if (sp->user) deallocate(sp->user, V_cstr);
					if (sp->password) deallocate(sp->password, V_cstr);
					
					z = ((struct StringInfo *)userg->SpecialInfo)->Buffer;
					if (z[0] != '\0') {
						sp->user = (b8 *)allocate(strlen(z) + 1, V_cstr);
						if (sp->user) {
							strcpy(sp->user, z);
						}
					} else {
						sp->user = nil;
					}
					
					z = phd.password;
					if (z[0] != '\0') {
						sp->password = (b8 *)allocate(strlen(z) + 1, V_cstr);
						if (sp->password) {
							strcpy(sp->password, z);
						}
					} else {
						sp->password = nil;
					}
					
					Forbid();
					GT_ReplyIMsg(im);
					
					CloseWindow(w);
					Permit();
					
					FreeGadgets(glist);
					free_gadget(cancel);
					free_gadget(login);

					FreeVisualInfo(vi);
					UnlockPubScreen(nil, s);
							
					return true;
				case 4:
					Forbid();
					GT_ReplyIMsg(im);
					
					CloseWindow(w);
					Permit();
					
					FreeGadgets(glist);
					
					free_gadget(cancel);
					free_gadget(login);

					FreeVisualInfo(vi);
					UnlockPubScreen(nil, s);
							
					return false;
				}
				break;
			case IDCMP_REFRESHWINDOW:
				GT_BeginRefresh(w);
				GT_EndRefresh(w, true);
				break;
			}
			
			GT_ReplyIMsg(im);
		}
	}
}

struct Window *open_main_window(struct List *site_labels, struct IntuitionBase *IntuitionBase, struct Library *GadToolsBase, struct GfxBase *GfxBase)
{
	struct Gadget *glist, *gad;
	struct NewGadget ng;
	struct Screen *s;
	void *vi;
	b32 screen_modeID;
	struct Rectangle rect;
	struct Window *w;
	sb32 swidth, sheight;
	
	glist = nil;
	
	s = LockPubScreen(nil);
	if (!s) return nil;
	
	vi = GetVisualInfo(s, TAG_END);
	if (vi != nil) {
		screen_modeID = GetVPModeID(&s->ViewPort);
		if (screen_modeID != INVALID_ID) {
			if (QueryOverscan(screen_modeID, &rect, OSCAN_TEXT)) {
				swidth = rect.MaxX - rect.MinX + 1;
				sheight = rect.MaxY - rect.MinY + 1;
				
				w = OpenWindowTags(nil,
					WA_Left,	swidth / 3 - s->LeftEdge,
					WA_Top,		sheight / 4 - s->TopEdge,
					WA_Width,	swidth / 3,
					WA_Height,	sheight / 2,
					WA_IDCMP,	IDCMP_CLOSEWINDOW | IDCMP_REFRESHWINDOW | LISTVIEWIDCMP,
					WA_PubScreen,	s,
					WA_Activate,	true,
					WA_DragBar,	true,
					WA_DepthGadget,	true,
					WA_CloseGadget,	true,
					WA_Title,	strings[MSG_CURRENT_SITES],
					WA_AutoAdjust,	true,
					TAG_END
				);
				if (w) {
					gad = CreateContext(&glist);
					if (gad) {
						ng.ng_TextAttr = s->Font;
						ng.ng_VisualInfo = vi;
						ng.ng_LeftEdge = w->BorderLeft;
						ng.ng_TopEdge = w->BorderTop;
						ng.ng_Width = w->Width - w->BorderLeft - w->BorderRight;
						ng.ng_Height = w->Height - w->BorderTop - w->BorderBottom;
						ng.ng_GadgetText = nil;
						ng.ng_GadgetID = 0;
						ng.ng_Flags = 0;
						gad = CreateGadget(LISTVIEW_KIND, gad, &ng, 
							GTLV_ReadOnly,	false, 
							GTLV_Labels,	site_labels,
							TAG_END
						);
						if (gad) {
							AddGList(w, glist, 0, -1, nil);
							
							RefreshGadgets(glist, w, nil);
							GT_RefreshWindow(w, nil);
							
							w->UserData = (void *)glist;
							
							FreeVisualInfo(vi);
							UnlockPubScreen(nil, s);
							
							return w;
						}
						FreeGadgets(glist);
					}
					CloseWindow(w);
				}
			}
		}
		FreeVisualInfo(vi);
	}
	
	UnlockPubScreen(nil, s);
	
	return nil;
}

void close_main_window(struct Window *w, struct IntuitionBase *IntuitionBase, struct Library *GadToolsBase)
{
	struct Gadget *glist;
	struct IntuiMessage *im;
	
	Forbid();
	while (im = GT_GetIMsg(w->UserPort)) {
		if (im->Class == IDCMP_REFRESHWINDOW) {
			GT_BeginRefresh(w);
			GT_EndRefresh(w, true);
		}
		GT_ReplyIMsg(im);
	}
	
	glist = (struct Gadget *)w->UserData;
	
	CloseWindow(w);
	FreeGadgets(glist);
	Permit();
}

#define V_List 19561
#define V_Node 20079

struct List *site_list(void)
{
	struct List *l;
	struct Node *n;
	site *sp;
	
	l = (struct List *)allocate(sizeof(*l), V_List);
	if (!l) return l;
	
	NewList(l);
	
	Forbid();
	sp = sites;
	while (sp) {
		n = (struct Node *)allocate(sizeof(*n), V_Node);
		if (!n) {
			Permit();
			return l;
		}
		
		n->ln_Name = (b8 *)allocate(strlen(sp->name) + 1, V_cstr);
		if (!n->ln_Name) {
			Permit();
			deallocate(n, V_Node);
			return l;
		}
		
		strcpy(n->ln_Name, sp->name);
		
		n->ln_Pri = 0;
		AddTail(l, n);
		sp = sp->next;
	}
	Permit();
	
	return l;
}

void free_labels(struct List *l)
{
	struct Node *n;
	
	while (n = RemHead(l)) {
		deallocate(n->ln_Name, V_cstr);
		deallocate(n, V_Node);
	}
	
	deallocate(l, V_List);
}

void draw_fill_bar(site *sp, struct IntuitionBase *IntuitionBase, struct GfxBase *GfxBase)
{
	struct Window *w;
	struct RastPort *rp;
	b32 x1, y1, x2, y2, gap;
	
	verify(sp, V_site);
	
	w = sp->status_window;
	if (!w) return;
	
	rp = w->RPort;
	
	x1 = w->BorderLeft;
	y1 = w->BorderTop;
	
	x2 = w->Width - w->BorderRight - 1;
	y2 = sp->abort_gadget->TopEdge - 1;
	
	gap = (y2 - y1) / 4;
	
	x2 = x1 + (x2 - x1) * 3 / 4;
	
	x1 += gap;
	y1 += gap;
	y2 -= gap;
	
	SetDrMd(rp, JAM2);
	
	SetAPen(rp, lightpen);
	Move(rp, x2, y1);
	Draw(rp, x2, y2);
	Draw(rp, x1, y2);
	SetAPen(rp, darkpen);
	Draw(rp, x1, y1);
	Draw(rp, x2, y1);
	
	SetAPen(rp, fillpen);
	
	x1++;
	y1++;
	y2--;
	x2--;
	
	if (sp->file_list) {
		verify(sp->file_list, V_file_info);
		
		x2 = x1 + ((x2 - x1) * sp->file_list->rpos) / sp->file_list->end;
		RectFill(rp, x1, y1, x2, y2);
	}
}

void update_fill_bar(site *sp, struct IntuitionBase *IntuitionBase, struct GfxBase *GfxBase)
{
	struct Window *w;
	struct RastPort *rp;
	b32 x1, y1, x2, y2, gap;
	struct IntuiText txt;
	b8 buffer[20], *z;
	file_info *fip;
	
	verify(sp, V_site);
	
	w = sp->status_window;
	if (!w) return;
	
	Forbid();
	fip = sp->file_list;
	if (!fip) {
		Permit();
		return;
	}
	verify(fip, V_file_info);
	
	z = fip->fname + strlen(fip->fname) - 1;
	while (z > fip->fname && *z != '/') z--;
	if (*z == '/') z++;
	
	rp = w->RPort;
	
	x1 = w->BorderLeft;
	y1 = w->BorderTop;
	
	x2 = w->Width - w->BorderRight - 1;
	y2 = sp->abort_gadget->TopEdge - 1;
	
	gap = (y2 - y1) / 4;
	
	x2 = x1 + (x2 - x1) * 3 / 4 - 1;
	
	x1 += gap + 1;
	y1 += gap + 1;
	y2 -= gap + 1;
	
	if (sp->site_state == SS_WRITING || !fip->end) {	/* just print how many k we have transferred */
		txt.FrontPen = textpen;
		txt.BackPen = 0;
		txt.DrawMode = JAM2;
		txt.LeftEdge = x1;
		txt.TopEdge = y1;
		txt.ITextFont = sp->status_window->WScreen->Font;
		txt.NextText = nil;
		txt.IText = z;
		PrintIText(rp, &txt, 0, 0);
		
		txt.LeftEdge += IntuiTextLength(&txt);
		txt.FrontPen = textpen;
		txt.IText = buffer;

		buffer[0] = ':';
		buffer[1] = ' ';
		x1 = 2;
		y1 = fip->rpos / 1024;
		buffer[x1] = '0';
		while (y1 >= 100000) {
			buffer[x1]++;
			y1 -= 100000;
		}
		if (buffer[x1] > '0') x1++;
		buffer[x1] = '0';
		while (y1 >= 10000) {
			buffer[x1]++;
			y1 -= 10000;
		}
		if (buffer[x1] > '0' || x1 != 2) x1++;
		buffer[x1] = '0';
		while (y1 >= 1000) {
			buffer[x1]++;
			y1 -= 1000;
		}
		if (buffer[x1] > '0' || x1 != 2) x1++;
		buffer[x1] = '0';
		while (y1 >= 100) {
			buffer[x1]++;
			y1 -= 100;
		}
		if (buffer[x1] > '0' || x1 != 2) x1++;
		buffer[x1] = '0';
		while (y1 >= 10) {
			buffer[x1]++;
			y1 -= 10;
		}
		if (buffer[x1] > '0' || x1 != 2) x1++;
		buffer[x1++] = y1 + '0';
		buffer[x1++] = ' ';
		buffer[x1++] = 'k';
		buffer[x1++] = ' ';
		buffer[x1++] = ' ';
		buffer[x1] = 0;

		PrintIText(rp, &txt, 0, 0);
		
		Permit();
		
		return;
	}
	
	/* reading ... can do a filler bar */
	
	SetDrMd(rp, JAM2);
	SetAPen(rp, fillpen);

	txt.FrontPen = lightpen;
	txt.BackPen = 0;
	txt.DrawMode = JAM1;
	txt.TopEdge = y1;
	txt.ITextFont = sp->status_window->WScreen->Font;
	txt.NextText = nil;
	txt.IText = z;
	
	txt.LeftEdge = (x1 + x2) / 2 - IntuiTextLength(&txt) / 2;
	
	x2 = x1 + ((x2 - x1) * sp->file_list->rpos) / sp->file_list->end;
	RectFill(rp, x1, y1, x2, y2);

	PrintIText(rp, &txt, 0, 0);
	
	Permit();
	
	return;
}

void draw_state(site *sp, struct IntuitionBase *IntuitionBase, struct GfxBase *GfxBase)
{
	struct IntuiText txt;
	
	/* gadget states */
	switch (sp->site_state) {
	case SS_DISCONNECTED:
	case SS_DISCONNECTING:
		if (!(sp->abort_gadget->Flags & GFLG_DISABLED)) {
			OffGadget(sp->abort_gadget, sp->status_window, nil);
		}
		if (!(sp->disconnect_gadget->Flags & GFLG_DISABLED)) {
			OffGadget(sp->disconnect_gadget, sp->status_window, nil);
		}
		break;
	case SS_CONNECTING:
	case SS_IDLE:
	case SS_LOGIN:
	case SS_ABORTING:
		if (!(sp->abort_gadget->Flags & GFLG_DISABLED)) {
			OffGadget(sp->abort_gadget, sp->status_window, nil);
		}
		if (sp->disconnect_gadget->Flags & GFLG_DISABLED) {
			OnGadget(sp->disconnect_gadget, sp->status_window, nil);
		}
		break;
	default:
		if (sp->abort_gadget->Flags & GFLG_DISABLED) {
			OnGadget(sp->abort_gadget, sp->status_window, nil);
		}
		if (sp->disconnect_gadget->Flags & GFLG_DISABLED) {
			OnGadget(sp->disconnect_gadget, sp->status_window, nil);
		}
		break;
	}
	
	txt.FrontPen = textpen;
	txt.BackPen = 0;
	txt.DrawMode = JAM2;
	txt.LeftEdge = 2;
	txt.TopEdge = 0;
	txt.ITextFont = sp->status_window->WScreen->Font;
	txt.NextText = nil;
	txt.IText = strings[MSG_STATE_UNKNOWN + sp->site_state];
	
	PrintIText(sp->status_window->RPort, &txt, sp->status_window->BorderLeft,
		sp->abort_gadget->TopEdge + sp->abort_gadget->Height / 4);
	
	if (sp->quick) {
		txt.LeftEdge += IntuiTextLength(&txt);
		txt.IText = strings[MSG_QUICK_FLAG];
		PrintIText(sp->status_window->RPort, &txt, sp->status_window->BorderLeft,
			sp->abort_gadget->TopEdge + sp->abort_gadget->Height / 4);
	}
	
	if (sp->site_state == SS_READING && sp->file_list && sp->file_list->end > 0) {
		draw_fill_bar(sp, IntuitionBase, GfxBase);
	}
}

void clear_state(site *sp, struct IntuitionBase *IntuitionBase, struct GfxBase *GfxBase)
{
	verify(sp, V_site);
	truth(sp->status_window != nil);

	SetAPen(sp->status_window->RPort, 0);
	SetDrMd(sp->status_window->RPort, JAM1);
	
	RectFill(sp->status_window->RPort, sp->status_window->BorderLeft, sp->status_window->BorderTop,
		sp->abort_gadget->LeftEdge - 1, sp->status_window->Height - sp->status_window->BorderBottom - 1);
	
	RectFill(sp->status_window->RPort, sp->abort_gadget->LeftEdge, sp->status_window->BorderTop,
		sp->status_window->Width - sp->status_window->BorderRight - 1, 
		sp->abort_gadget->TopEdge - 1);
}

void open_status_window(site *sp, struct MsgPort *wport, struct IntuitionBase *IntuitionBase, struct GfxBase *GfxBase)
{
	struct Screen *s;
	struct Rectangle rect;
	b32 screen_modeID;
	struct Gadget *aborg, *disg;
	b16 swidth, sheight, fheight;
	struct Window *w;

	verify(sp, V_site);
	
	if (sp->status_window) {
		WindowToFront(sp->status_window);
		ActivateWindow(sp->status_window);
		return;
	}
	
	s = LockPubScreen(nil);
	if (!s) return;
	
	if (s->Font) fheight = s->Font->ta_YSize;
	else fheight = 8;
	
	screen_modeID = GetVPModeID(&s->ViewPort);
	if (screen_modeID != INVALID_ID) {
		if (QueryOverscan(screen_modeID, &rect, OSCAN_TEXT)) {
			aborg = make_gadget(abort_gim);
			if (aborg) {
				aborg->GadgetID = 1;
				disg = make_gadget(disconnect_gim);
				if (disg) {
					disg->GadgetID = 2;
					swidth = rect.MaxX - rect.MinX + 1;
					sheight = rect.MaxY - rect.MinY + 1;
					
					w = OpenWindowTags(nil,
						WA_Left,	swidth / 4 - s->LeftEdge,
						WA_Top,		sheight / 3 - s->TopEdge,
						WA_Width,	swidth / 2,
						WA_Height,	fheight * 4 + disg->Height,
						WA_Flags,	WFLG_DEPTHGADGET | WFLG_DRAGBAR |
								WFLG_SMART_REFRESH | 
								WFLG_CLOSEGADGET |
								WFLG_NOCAREREFRESH,
						WA_IDCMP,	0,
						WA_PubScreen,	s,
						WA_Title,	sp->name,
						TAG_END,	0
					);
					if (w) {
						UnlockPubScreen(nil, s);
						w->UserPort = wport;
						ModifyIDCMP(w, IDCMP_CLOSEWINDOW | IDCMP_GADGETUP);
						
						aborg->NextGadget = disg;
						disg->NextGadget = nil;
						
						sp->abort_gadget = aborg;
						sp->disconnect_gadget = disg;
						
						disg->LeftEdge = w->Width - w->BorderRight - disg->Width - fheight / 2;
						disg->TopEdge = w->Height - w->BorderBottom - disg->Height - fheight / 3;
						
						aborg->TopEdge = disg->TopEdge;
						aborg->LeftEdge = disg->LeftEdge - aborg->Width - fheight / 2;
						
						AddGList(w, aborg, (b32)-1, 2, nil);
						RefreshGadgets(aborg, w, nil);
						
						sp->status_window = w;
						w->UserData = (void *)sp;
						
						draw_state(sp, IntuitionBase, GfxBase);
						
						return;
					}
					free_gadget(disg);
				}
				free_gadget(aborg);
			}
		}
	}
	
	UnlockPubScreen(nil, s);
	return;
}

void close_status_window(site *sp, struct MsgPort *wport, struct IntuitionBase *IntuitionBase)
{
	struct IntuiMessage *im;
	struct Node *succ;
	struct Window *w;
	
	verify(sp, V_site);
	
	w = sp->status_window;
	
	if (!w) return;
	
	Forbid();
	im = (struct IntuiMessage *)wport->mp_MsgList.lh_Head;
	while (succ = im->ExecMessage.mn_Node.ln_Succ) {
		if (im->IDCMPWindow == w) {
			Remove((struct Node *)im);
			ReplyMsg((struct Message *)im);
		}
		im = (struct IntuiMessage *)succ;
	}
	
	w->UserPort = nil;
	ModifyIDCMP(w, 0);
	Permit();
	
	CloseWindow(w);
	
	free_gadget(sp->abort_gadget);
	free_gadget(sp->disconnect_gadget);
	
	sp->status_window = nil;
	
	return;
}

void __saveds status_handler(void)
{
	struct Process *me;
	struct MsgPort *rank, *sync, *myport, *cxport, *winport;
	status_message *reserve, *startup, *sm;
	struct Library *GadToolsBase, *CxBase;
	struct IntuitionBase *IntuitionBase;
	struct GfxBase *GfxBase;
	CxObj *broker, *filter, *sender, *translate;
	CxMsg *cxmsg;
	b32 signals;
	b32 msgid, msgtype;
	struct Window *mainw;
	struct NewBroker nb;
	struct List *site_labels;
	struct IntuiMessage *imsg;
	struct Node *n;
	site *sp;
	
	mainw = nil;
	site_labels = nil;
	
	me = (struct Process *)FindTask(0l);
	myport = &me->pr_MsgPort;
	
	WaitPort(myport);
	startup = (status_message *)GetMsg(myport);
	
	mem_tracking_on();
	
	IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library", 36);
	if (IntuitionBase) {
		GfxBase = (struct GfxBase *)OpenLibrary("graphics.library", 36);
		if (GfxBase) {
			GadToolsBase = OpenLibrary("gadtools.library", 0);
			if (GadToolsBase) {
				CxBase = OpenLibrary("commodities.library", 0);
				if (CxBase) {
					rank = CreatePort(0, 0);
					if (rank) {
						sync = CreatePort(0, 0);
						if (sync) {
							cxport = CreatePort(0, 0);
							if (cxport) {
								winport = CreatePort(0, 0);
								if (winport) {
									reserve = (status_message *)allocate_flags(sizeof(*reserve), MEMF_PUBLIC, V_status_message);
									if (reserve) {
										ensure(reserve, V_status_message);
	
										reserve->header.mn_Length = sizeof(*reserve);
										reserve->header.mn_ReplyPort = sync;
										reserve->header.mn_Node.ln_Name = "ftpstatus reserve message";
										reserve->header.mn_Node.ln_Type = NT_MESSAGE;
										reserve->header.mn_Node.ln_Pri = 0;
								
										nb.nb_Version = NB_VERSION;
										nb.nb_Name = strings[MSG_BROKER_NAME];
										nb.nb_Title = "FTPMount v" VERSION "." REVISION;
										nb.nb_Descr = strings[MSG_BROKER_DESCR];
										nb.nb_Unique = NBU_DUPLICATE;
										nb.nb_Flags = COF_SHOW_HIDE;
										nb.nb_Pri = 0;
										nb.nb_Port = cxport;
										nb.nb_ReservedChannel = 0;
				
										broker = CxBroker(&nb, nil);
										if (broker) {
											/* this hotkey stuff taken directly from RKM example */
											if (filter = CxFilter(strings[MSG_HOTKEY])) {
												/* if we can't add the hotkey stuff, don't fail */
												if (sender = CxSender(cxport, 1)) {
													if (translate = (CxTranslate(nil))) {
														AttachCxObj(broker, filter);
														AttachCxObj(filter, sender);
														AttachCxObj(filter, translate);
													}
												}
											}
											ActivateCxObj(broker, 1l);
									
											startup->command = 0;
											ReplyMsg(&startup->header);
											goto begin_listening;
										}
										deallocate(reserve, V_status_message);
									}
									DeletePort(winport);
								}
								DeletePort(cxport);
							}
							DeletePort(sync);
						}
						DeletePort(rank);
					}
					CloseLibrary(CxBase);
				}
				CloseLibrary(GadToolsBase);
			}
			CloseLibrary((struct Library *)GfxBase);
		}
		CloseLibrary((struct Library *)IntuitionBase);
	}
	
	startup->command = SM_KILL;
	Forbid();
	ReplyMsg(&startup->header);
	return;

begin_listening:
	signals = (1 << myport->mp_SigBit) | (1 << cxport->mp_SigBit) | (1 << winport->mp_SigBit);

	while (1) {
		Wait(signals);
		
		while (cxmsg = (CxMsg *)GetMsg(cxport)) {
			msgid = CxMsgID(cxmsg);
			msgtype = CxMsgType(cxmsg);
			
			ReplyMsg((struct Message *)cxmsg);
			
			switch (msgtype) {
			case CXM_IEVENT:	/* copied from CXCMD_APPEAR below */
				if (mainw != nil) {
					close_main_window(mainw, IntuitionBase, GadToolsBase);
					mainw = nil;
					free_labels(site_labels);
				}
				
				site_labels = site_list();
				mainw = open_main_window(site_labels, IntuitionBase, GadToolsBase, GfxBase);
				signals = (1 << cxport->mp_SigBit) |
						(1 << myport->mp_SigBit) |
						(1 << winport->mp_SigBit);
				if (mainw != nil) {
					signals |= (1 << mainw->UserPort->mp_SigBit);
				}
				
				break;
			case CXM_COMMAND:
				switch (msgid) {
				case CXCMD_DISABLE:
					reserve->command = SM_SUSPEND;
					PutMsg(status_control, &reserve->header);
					WaitPort(sync); GetMsg(sync);
					
					ActivateCxObj(broker, 0l);
					break;
				case CXCMD_ENABLE:
					reserve->command = SM_RESUME;
					PutMsg(status_control, &reserve->header);
					WaitPort(sync); GetMsg(sync);
					
					ActivateCxObj(broker, 1l);
					break;
				case CXCMD_KILL:
					reserve->command = SM_KILL;
					PutMsg(status_control, &reserve->header);
					WaitPort(sync); GetMsg(sync);
					
					break;
				case CXCMD_APPEAR:
					if (mainw != nil) {
						close_main_window(mainw, IntuitionBase, GadToolsBase);
						mainw = nil;
						free_labels(site_labels);
					}
					
					site_labels = site_list();
					mainw = open_main_window(site_labels, IntuitionBase, GadToolsBase, GfxBase);
					signals = (1 << cxport->mp_SigBit) |
							(1 << myport->mp_SigBit) |
							(1 << winport->mp_SigBit);
					if (mainw != nil) {
						signals |= (1 << mainw->UserPort->mp_SigBit);
					}
					
					break;
				case CXCMD_DISAPPEAR:
					if (mainw != nil) {
						close_main_window(mainw, IntuitionBase, GadToolsBase);
						mainw = nil;
						free_labels(site_labels);
						
						signals = (1 << cxport->mp_SigBit) |
								(1 << myport->mp_SigBit) |
								(1 << winport->mp_SigBit);
					}
					break;
				}
			}
		}
		
		while (mainw && (imsg = GT_GetIMsg(mainw->UserPort))) {
			switch (imsg->Class) {
			case IDCMP_CLOSEWINDOW:
				GT_ReplyIMsg(imsg);
				close_main_window(mainw, IntuitionBase, GadToolsBase);
				mainw = nil;
				free_labels(site_labels);
				
				signals = (1 << cxport->mp_SigBit) |
						(1 << myport->mp_SigBit) |
						(1 << winport->mp_SigBit);
				continue;
			case IDCMP_REFRESHWINDOW:
				GT_BeginRefresh(mainw);
				GT_EndRefresh(mainw, true);
				break;
			case IDCMP_GADGETUP:
				msgid = imsg->Code;
				GT_ReplyIMsg(imsg);
				close_main_window(mainw, IntuitionBase, GadToolsBase);
				mainw = nil;
				
				n = site_labels->lh_Head;
				while (msgid-- && (n->ln_Succ)) {
					n = n->ln_Succ;
				}
				
				if (n->ln_Succ) {
					sp = sites;
					while (sp) {
						if (strcmp(sp->name, n->ln_Name) == 0) {
							break;
						}
						sp = sp->next;
					}
					
					if (sp) {
						open_status_window(sp, winport, IntuitionBase, GfxBase);
					}
				}
				
				free_labels(site_labels);
				
				signals = (1 << cxport->mp_SigBit) |
						(1 << myport->mp_SigBit) |
						(1 << winport->mp_SigBit);
				continue;
			default:
				break;
			}
			GT_ReplyIMsg(imsg);
		}
		
		while (imsg = (struct IntuiMessage *)GetMsg(winport)) {
			sp = (site *)imsg->IDCMPWindow->UserData;
			verify(sp, V_site);
			
			switch (imsg->Class) {
			case IDCMP_CLOSEWINDOW:
				ReplyMsg((struct Message *)imsg);
				close_status_window(sp, winport, IntuitionBase);
				continue;
			case IDCMP_GADGETUP:
				if (((struct Gadget *)imsg->IAddress)->GadgetID == 1) {
					/* abort */
					Signal(sp->port->mp_SigTask, sp->abort_signals);
				} else {
					/* disconnect */
					Signal(sp->port->mp_SigTask, sp->disconnect_signals);
				}
				break;
			}
		
			ReplyMsg((struct Message *)imsg);
		}
		
		while (sm = (status_message *)GetMsg(myport)) {
			verify(sm, V_status_message);
			
			switch (sm->command) {
			case SM_KILL:
				if (mainw != nil) {
					close_main_window(mainw, IntuitionBase, GadToolsBase);
					free_labels(site_labels);
				}
				
				Forbid();
				while (cxmsg = (CxMsg *)GetMsg(cxport)) {
					ReplyMsg((struct Message *)cxmsg);
				}
				
				DeleteCxObjAll(broker);
				Permit();
				
				deallocate(reserve, V_status_message);
				
				DeletePort(winport);
				DeletePort(cxport);
				DeletePort(sync);
				DeletePort(rank);
				
				check_memory();

				CloseLibrary(CxBase);
				CloseLibrary(GadToolsBase);
				CloseLibrary((struct Library *)GfxBase);
				CloseLibrary((struct Library *)IntuitionBase);
				
				Forbid();
				ReplyMsg(&sm->header);
				return;
			case SM_NEW_SITE:
				if (sm->data) {
					open_status_window(sm->this_site, winport, IntuitionBase, GfxBase);
				}
				break;
			case SM_DEAD_SITE:
				close_status_window(sm->this_site, winport, IntuitionBase);
				break;
			case SM_STATE_CHANGE:
				if (sm->this_site->status_window) {
					clear_state(sm->this_site, IntuitionBase, GfxBase);
					draw_state(sm->this_site, IntuitionBase, GfxBase);
				}
				break;
			case SM_PROGRESS:
				if (sm->this_site->status_window) {
					update_fill_bar(sm->this_site, IntuitionBase, GfxBase);
				}
				break;
			}
			ReplyMsg(&sm->header);
		}
	}
}