/*
**	Protos.h
**
**	Global function prototype definitions
**
**	Copyright © 1990-1996 by Olaf `Olsen' Barthel
**		All Rights Reserved
*/

#ifndef _PROTOS_H
#define _PROTOS_H 1

/**********************************************************************/


	// Macros for debugging and simplification

#define DB(x)	;
//#define DB(x)	x

#undef REG
#define REG(x) register __ ## x


/**********************************************************************/


	// debug.lib

VOID __stdargs			kprintf(STRPTR,...);

	// pools.lib

APTR __asm			AsmCreatePool(REG(d0) ULONG MemFlags,REG(d1) ULONG PuddleSize,REG(d2) ULONG ThreshSize,REG(a6) struct ExecBase *SysBase);
VOID __asm			AsmDeletePool(REG(a0) APTR PoolHeader,REG(a6) struct ExecBase *SysBase);
APTR __asm			AsmAllocPooled(REG(a0) APTR PoolHeader, REG(d0) ULONG Size,REG(a6) struct ExecBase *SysBase);
VOID __asm			AsmFreePooled(REG(a0) APTR PoolHeader,REG(a1) APTR Memory,REG(d0) ULONG MemSize,REG(a6) struct ExecBase *SysBase);


/**********************************************************************/


	// Accountant.c

VOID				DeleteAccountant(VOID);
BOOL				CreateAccountant(VOID);
ULONG				QueryAccountantTime(struct timeval *Time);
ULONG				QueryAccountantCost(VOID);
ULONG				StopAccountant(VOID);
VOID				StartAccountant(ULONG OnlineSeconds);

	// ARexx.c

BOOL				IsNumeric(STRPTR String);
STRPTR				CreateResult(STRPTR ResultString,LONG *Results);
STRPTR				CreateResultLen(STRPTR ResultString,LONG *Results,LONG Len);
BOOL __stdargs			CreateVarArgs(STRPTR Value,struct RexxPkt *Packet,STRPTR Stem,...);
STRPTR				CreateVar(STRPTR Value,struct RexxPkt *Packet,STRPTR Name);
STRPTR				CreateMatchBuffer(STRPTR Pattern);
BOOL				MatchBuffer(STRPTR Buffer,STRPTR Name);
VOID				DeleteMatchBuffer(STRPTR Buffer);
LONG				ToMode(STRPTR Name);
LONG				ToList(STRPTR Name);
LONG				ToConfig(STRPTR Name);
LONG				ToRequester(STRPTR Name);
LONG				ToWindow(STRPTR Name);
VOID				RexxPktCleanup(struct RexxPkt *Packet,STRPTR Result);
VOID __saveds			RexxServer(VOID);
BOOL				HandleRexx(VOID);

	// ARexxAttributes.c

STRPTR				RexxGetAttr(struct RexxPkt *Pkt);
STRPTR				RexxSetAttr(struct RexxPkt *Pkt);

	// ARexxCommands.c

STRPTR				RexxActivate(struct RexxPkt *Pkt);
STRPTR				RexxAdd(struct RexxPkt *Pkt);
STRPTR				RexxBaud(struct RexxPkt *Pkt);
STRPTR				RexxBeepScreen(struct RexxPkt *Pkt);
STRPTR				RexxCallMenu(struct RexxPkt *Pkt);
STRPTR				RexxCapture(struct RexxPkt *Pkt);
STRPTR				RexxClear(struct RexxPkt *Pkt);
STRPTR				RexxClearScreen(struct RexxPkt *Pkt);
STRPTR				RexxClose(struct RexxPkt *Pkt);
STRPTR				RexxCloseDevice(struct RexxPkt *Pkt);
STRPTR				RexxCloseRequester(struct RexxPkt *Pkt);
STRPTR				RexxDeactivate(struct RexxPkt *Pkt);
STRPTR				RexxDial(struct RexxPkt *Pkt);
STRPTR				RexxDelay(struct RexxPkt *Pkt);
STRPTR				RexxDuplex(struct RexxPkt *Pkt);
STRPTR				RexxFault(struct RexxPkt *Pkt);
STRPTR				RexxGetClip(struct RexxPkt *Pkt);
STRPTR				RexxGoOnline(struct RexxPkt *Pkt);
STRPTR				RexxHangup(struct RexxPkt *Pkt);
STRPTR				RexxHelp(struct RexxPkt *Pkt);
STRPTR				RexxOpen(struct RexxPkt *Pkt);
STRPTR				RexxOpenDevice(struct RexxPkt *Pkt);
STRPTR				RexxOpenRequester(struct RexxPkt *Pkt);
STRPTR				RexxParity(struct RexxPkt *Pkt);
STRPTR				RexxPasteClip(struct RexxPkt *Pkt);
STRPTR				RexxPrint(struct RexxPkt *Pkt);
STRPTR				RexxProcessIO(struct RexxPkt *Pkt);
STRPTR				RexxProtocol(struct RexxPkt *Pkt);
STRPTR				RexxPutClip(struct RexxPkt *Pkt);
STRPTR				RexxQuit(struct RexxPkt *Pkt);
STRPTR				RexxRead(struct RexxPkt *Pkt);
STRPTR				RexxReceiveFile(struct RexxPkt *Pkt);
STRPTR				RexxRedial(struct RexxPkt *Pkt);
STRPTR				RexxRemove(struct RexxPkt *Pkt);
STRPTR				RexxRequestFile(struct RexxPkt *Pkt);
STRPTR				RexxRequestNotify(struct RexxPkt *Pkt);
STRPTR				RexxRequestNumber(struct RexxPkt *Pkt);
STRPTR				RexxRequestResponse(struct RexxPkt *Pkt);
STRPTR				RexxRequestString(struct RexxPkt *Pkt);
STRPTR				RexxResetScreen(struct RexxPkt *Pkt);
STRPTR				RexxResetStyles(struct RexxPkt *Pkt);
STRPTR				RexxResetText(struct RexxPkt *Pkt);
STRPTR				RexxResetTimer(struct RexxPkt *Pkt);
STRPTR				RexxSaveAs(struct RexxPkt *Pkt);
STRPTR				RexxSave(struct RexxPkt *Pkt);
STRPTR				RexxSelect(struct RexxPkt *Pkt);
STRPTR				RexxSend(struct RexxPkt *Pkt);
STRPTR				RexxSendBreak(struct RexxPkt *Pkt);
STRPTR				RexxSendFile(struct RexxPkt *Pkt);
STRPTR				RexxSpeak(struct RexxPkt *Pkt);
STRPTR				RexxStopBits(struct RexxPkt *Pkt);
STRPTR				RexxTextBuffer(struct RexxPkt *Pkt);
STRPTR				RexxTimeout(struct RexxPkt *Pkt);
STRPTR				RexxTrap(struct RexxPkt *Pkt);
STRPTR				RexxWait(struct RexxPkt *Pkt);
STRPTR				RexxWindow(struct RexxPkt *Pkt);
STRPTR				RexxRX(struct RexxPkt *Pkt);
STRPTR				RexxExecTool(struct RexxPkt *Pkt);

	// ASCIIPanel.c

struct Window *			CreateASCIIWindow(BOOL Send);
VOID				DeleteASCIIWindow(struct Window *Window,BOOL WaitForIt);
VOID __stdargs			AddASCIIMessage(struct Window *Window,STRPTR Message,...);
VOID				UpdateASCIIWindow(struct Window *Window,LONG Bytes,LONG MaxBytes,LONG Lines);
BOOL				HandleASCIIWindow(VOID);

	// ASCIITransfer.c

VOID				ASCIISendSetup(VOID);
BOOL				InternalASCIIUpload(STRPTR SingleFile,BOOL WaitForIt);
BOOL				InternalASCIIDownload(STRPTR Name,BOOL WaitForIt);

	// About.c

BOOL				ShowAbout(LONG Ticks);

	// AmigaGuide.c

VOID				GuideCleanup(VOID);
VOID				GuideContext(LONG NewContextID);
ULONG __saveds __asm		GuideSetupHook(REG(a0) struct Hook *Hook,REG(a1) struct IBox *Bounds,REG(a2) struct HelpMsg *HelpMessage);
VOID				GuideSetup(VOID);
VOID				GuideDisplay(LONG ContextID);

	// Beep.c

VOID				Beep(VOID);
VOID				BellSignal(VOID);

	// Boxes.c

LONG				SZ_GetLeftEdge(VOID);
VOID				SZ_SetTopEdge(LONG Top);
VOID				SZ_SetLeftEdge(LONG Left);
VOID				SZ_SetAbsoluteTop(LONG Top);
VOID				SZ_SetAbsoluteLeft(LONG Left);
VOID				SZ_SetWidth(LONG Width);
VOID				SZ_AddLeftOffset(LONG Offset);
LONG __stdargs			SZ_LeftOffsetN(LONG DataArray,...);
VOID				SZ_SizeCleanup(VOID);
BOOL				SZ_SizeSetup(struct Screen *Screen,struct TextAttr *TextAttr);
ULONG				SZ_GetLen(STRPTR String);
VOID				SZ_FreeBoxes(struct TextBox *FirstBox);
LONG				SZ_BoxWidth(LONG Chars);
LONG				SZ_BoxHeight(LONG Lines);
VOID				SZ_SetTitlePen(struct TextBox *Box,LONG FgPen,LONG BgPen);
struct TextBox *__stdargs	SZ_CreateTextBox(struct TextBox **FirstBox,...);
VOID __stdargs			SZ_SetBoxTitles(struct TextBox *Box,STRPTR Array,...);
VOID				SZ_SetLine(struct RastPort *RPort,struct TextBox *Box,LONG Line,STRPTR String);
VOID __stdargs			SZ_PrintLine(struct RastPort *RPort,struct TextBox *Box,LONG Line,STRPTR String,...);
VOID				SZ_DrawBoxes(struct RastPort *RPort,struct TextBox *FirstBox);
VOID				SZ_MoveBoxes(struct TextBox *FirstBox,LONG Left,LONG Top);
VOID				SZ_SetBoxes(struct TextBox *FirstBox,LONG Left,LONG Top);
LONG				SZ_GetBoxInfo(struct TextBox *Box,LONG Type);

	// Buffer.c

VOID				AddLine(register STRPTR Line,register LONG Size);
VOID				DeleteBuffer(VOID);
BOOL				CreateBuffer(VOID);
VOID				FreeBuffer(VOID);
VOID				DeleteSearchInfo(struct SearchInfo *Info);
struct SearchInfo *		CreateSearchInfo(STRPTR Pattern,BOOL Forward,BOOL IgnoreCase,BOOL WholeWords);
LONG				SearchTextBuffer(struct SearchInfo *Info);
BOOL				HandleSearchMessage(struct SearchContext *Context,struct IntuiMessage **MessagePtr);
VOID				DeleteSearchContext(struct SearchContext *Context);
struct SearchContext *		CreateSearchContext(struct Window *ParentWindow,STRPTR Buffer,struct Hook *HistoryHook,BOOLEAN *Forward,BOOLEAN *IgnoreCase,BOOLEAN *WholeWords);

	// Call.c

VOID				MakeCall(STRPTR Name,STRPTR Number);
VOID				StopCall(BOOL Finish);

	// Capture.c

VOID				CaptureFilteredTo_Buffer(register APTR Buffer,register LONG Size);
VOID				CaptureFilteredTo_Buffer_File(register APTR Buffer,register LONG Size);
VOID				CaptureFilteredTo_Buffer_File_Printer(register APTR Buffer,register LONG Size);
VOID				CaptureFilteredTo_File(register APTR Buffer,register LONG Size);
VOID				CaptureFilteredTo_File_Printer(register APTR Buffer,register LONG Size);
VOID				CaptureFilteredTo_Printer(register APTR Buffer,register LONG Size);
VOID				CaptureFilteredTo_Buffer_Printer(register APTR Buffer,register LONG Size);
VOID				CaptureRawTo_Buffer(register APTR Buffer,register LONG Size);
VOID				CaptureRawTo_Buffer_File(register APTR Buffer,register LONG Size);
VOID				CaptureRawTo_Buffer_File_Printer(register APTR Buffer,register LONG Size);
VOID				CaptureRawTo_Buffer_Printer(register APTR Buffer,register LONG Size);
VOID				CaptureRawTo_File(register APTR Buffer,register LONG Size);
VOID				CaptureRawTo_File_Printer(register APTR Buffer,register LONG Size);
VOID				CaptureRawTo_Printer(register APTR Buffer,register LONG Size);
VOID				ClosePrinterCapture(BOOL Force);
BOOL				OpenPrinterCapture(BOOL Controller);
VOID				CloseFileCapture(VOID);
BOOL				OpenFileCapture(BOOL Raw);
VOID				CaptureToFile(APTR Buffer,LONG Size);
VOID				CaptureToPrinter(APTR Buffer,LONG Size);

	// CapturePanel.c

BOOL				CapturePanel(struct Window *Parent,struct Configuration *LocalConfig);

	// CaptureParser.c

VOID				CaptureParserExit(VOID);
BOOL				CaptureParserInit(VOID);
VOID				CaptureParser(register ParseContext *Context,register STRPTR Buffer,register LONG Size,register COPTR OutputRoutine);
VOID				DeleteParseContext(ParseContext *Context);
ParseContext *			CreateParseContext(VOID);

	// Chat.c

VOID				HideChatGadget(VOID);
VOID				DeleteChatGadget(VOID);
VOID				UpdateChatGadget(VOID);
VOID				ActivateChat(BOOL Reactivate);
BOOL				CreateChatGadget(VOID);

	// Clip.c

VOID				CloseClip(VOID);
LONG				GetClip(STRPTR Buffer,LONG Len,BOOL Filter);
LONG				OpenClip(LONG Unit);
BOOL				GetClipContents(LONG Unit,APTR *Buffer,LONG *Size);
BOOL				AddClip(STRPTR Buffer,LONG Size);
BOOL				SaveClip(STRPTR Buffer,LONG Size);
LONG				LoadClip(STRPTR Buffer,LONG Size);

	// ClipPanel.c

BOOL				ClipPanel(struct Window *Parent,struct Configuration *LocalConfig);

	// Colour.c

VOID				Colour96xColourTable(const ULONG *Source96,ColourTable *Table,LONG NumColours);
VOID				Colour12xColourTable(const UWORD *Source12,ColourTable *Table,LONG NumColours);
VOID				Colour12x96(const UWORD *Source12,ULONG *Dest96,LONG NumColours);
VOID				Colour96x12(const ULONG *Source96,UWORD *Dest12,LONG NumColours);
VOID				CopyColourEntry(const ColourTable *Source,ColourTable *Destination,LONG From,LONG To);
VOID				ColourTablex96(const ColourTable *Table,ULONG *Dest96);
VOID				DeleteColourTable(ColourTable *Table);
ColourTable *			CreateColourTable(LONG NumEntries,const UWORD *Source12,const ULONG *Source96);
VOID				LoadColourTable(struct ViewPort *VPort,const ColourTable *Table,const UWORD *Colour12,LONG NumColours);
VOID				SetColour12(struct ViewPort *VPort,LONG Number,UWORD r,UWORD g,UWORD b);
VOID				SetColour96(struct ViewPort *VPort,ULONG Number,ULONG r,ULONG g,ULONG b);
VOID				GrabColours(struct ViewPort *VPort,ColourTable *Table);
VOID				CopyColours(const ColourTable *From,ColourTable *To);

	// CommandPanel.c

BOOL				CommandPanel(struct Window *Parent,struct Configuration *LocalConfig);

	// Config.c

VOID				StripGlobals(struct Configuration *Config);
VOID				FinalFix(struct Configuration *Config,BOOL IsPhonebook,LONG Version,LONG Revision);
VOID				FixOldConfig(struct Configuration *Config,UBYTE ConfigChunkType,BOOL IsPhonebook,LONG Version,LONG Revision);
VOID				FixScreenPens(struct ScreenSettings *ScreenConfig);
VOID				ResetConfig(struct Configuration *Config,STRPTR PathBuffer);
VOID				DeleteConfigEntry(struct Configuration *Config,LONG Type);
VOID				ResetConfigEntry(struct Configuration *LocalConfig,LONG Type,BOOL Default);
APTR				GetConfigEntry(const struct Configuration *Config,LONG Type);
BOOL				CreateConfigEntry(struct Configuration *Config,LONG Type);
VOID				DeleteConfiguration(struct Configuration *Config);
struct Configuration *		CreateConfiguration(BOOL Fill);
VOID				SaveConfig(const struct Configuration *Src,struct Configuration *Dst);
VOID				UpdateConfig(const struct Configuration *Src,struct Configuration *Dst);
VOID				SwapConfig(struct Configuration *Src,struct Configuration *Dst);
BOOL				SavePhonebook(STRPTR Name);
BOOL				LoadPhonebook(STRPTR Name,PhonebookHandle *BookHandle);
BOOL				WriteConfig(STRPTR Name,struct Configuration *Config);
BOOL				ReadConfig(STRPTR Name,struct Configuration *Config);

	// Console.c

VOID				ConProcessUpdate(VOID);
VOID				ConOutputUpdate(VOID);
VOID				ConFontScaleUpdate(VOID);
VOID				ConTransWrite(STRPTR Buffer,LONG Size);
VOID				ConProcessDataTransExternal(register STRPTR String,register LONG Size);
VOID				ConProcessDataExternal(register STRPTR String,register LONG Size);
VOID				ConProcessData7(register STRPTR String,register LONG Size);
VOID				ConProcessData8(register STRPTR String,register LONG Size);
VOID				ConProcessDataHex7(register STRPTR String,register LONG Size);
VOID				ConProcessDataHex8(register STRPTR String,register LONG Size);
VOID				ConTransferHost(STRPTR Buffer,LONG Len);
VOID				ConsoleCommand(STRPTR String);
VOID				ConBypass(STRPTR String,LONG Size);
VOID				ConProcess(register STRPTR String,register LONG Size);
VOID __stdargs			ConWrites(STRPTR String,...);
VOID				FlowInit(BOOL FullReset);
VOID				GfxText(struct RastPort *RPort,STRPTR Buffer,LONG Length);
LONG				ConvertTheKey(STRPTR Buffer,LONG *Len,UWORD Code,UWORD Qualifier,ULONG Prev);
LONG				KeyConvert(struct IntuiMessage *Massage,STRPTR Buffer,LONG *Len);
BOOL				DoBackspace(VOID);
BOOL				DoBeep(VOID);
BOOL				DoxON(VOID);
BOOL				DoLF(VOID);
BOOL				DoShiftIn(VOID);
BOOL				DoShiftOut(VOID);
BOOL				DoCR_LF(VOID);
BOOL				DoFF(VOID);
BOOL				DoLF_FF_VT(VOID);
BOOL				DoCR(VOID);
BOOL				DoTab(VOID);
BOOL				DoEnq(VOID);
BOOL				DoEsc(VOID);
BOOL				DoCsi(VOID);
BOOL				DoNewEsc(LONG Char);
BOOL				DoNewCsi(LONG Char);
VOID				Update_CR_LF_Translation(VOID);

	// CopyPanel.c

BOOL				CopyPanel(struct Window *Parent,struct Configuration *MyConfig,BOOL Selective);

	// Crypt.c

VOID				Encrypt(UBYTE *Source,LONG SourceLen,UBYTE *Destination,UBYTE *Key,LONG KeyLen);
VOID				Decrypt(UBYTE *Source,LONG SourceLen,UBYTE *Destination,UBYTE *Key,LONG KeyLen);

	// CursorPanel.c

BOOL				CursorPanelConfig(struct Configuration *LocalConfig,struct CursorKeys *CursorKeys,STRPTR LastCursorKeys,struct Window *Parent,BOOLEAN *ChangedPtr);

	// CustomRequest.c

LONG __stdargs			ShowInfo(struct Window *Parent,STRPTR Title,STRPTR Continue,STRPTR FormatString,...);

	// DatePanel.c

BOOL				DatePanel(struct Window *Parent,struct TimeDateNode *Node);

	// DayPanel.c

BOOL				DayPanel(struct Window *Parent,struct TimeDateNode *Node);

	// Dial.c

BOOL				DialPanel(VOID);

	// Emulation.c

VOID				UpdatePens(VOID);
LONG				GetFontWidth(VOID);
VOID				RethinkRasterLimit(VOID);
VOID				ScrollRegion(LONG Direction);
BOOL				DoCancel(VOID);
VOID				CSIFake(VOID);
BOOL				ParseCode(LONG c);
VOID				NormalCursor(VOID);
VOID				GhostCursor(VOID);
VOID				RepositionCursor(VOID);
VOID				ClearCursor(VOID);
VOID				DrawCursor(VOID);
VOID				BackupRender(VOID);
VOID				ShiftChar(LONG Size);
VOID				Ignore(VOID);
VOID				ScrollDown(STRPTR Buffer);
VOID				ScrollUp(STRPTR Buffer);
VOID				CursorScrollDown(VOID);
VOID				DownLine(VOID);
VOID				CursorScrollUp(VOID);
VOID				NextLine(VOID);
VOID				SaveCursor(VOID);
VOID				FontStuff(STRPTR Buffer);
VOID				LoadCursor(VOID);
VOID				ScaleFont(STRPTR Buffer);
VOID				AlignmentTest(VOID);
VOID				SetTab(VOID);
VOID				RequestTerminal(STRPTR Buffer);
VOID				SoftReset(VOID);
VOID				Reset(VOID);
VOID				PrinterController(STRPTR Buffer);
VOID				RequestInformation(STRPTR Buffer);
VOID				SetSomething(STRPTR Buffer);
VOID				NumericAppMode(STRPTR Buffer);
VOID				MoveCursor(STRPTR Buffer);
VOID				MoveColumn(STRPTR Buffer);
VOID				EraseLine(STRPTR Buffer);
VOID				EraseScreen(STRPTR Buffer);
VOID				EraseCharacters(STRPTR Buffer);
VOID				InsertCharacters(STRPTR Buffer);
VOID				InsertLine(STRPTR Buffer);
VOID				ClearLine(STRPTR Buffer);
VOID				SetTabs(STRPTR Buffer);
VOID				SetAbsolutePosition(STRPTR Buffer);
VOID				SetTopPosition(STRPTR Buffer);
VOID				SetAttributes(STRPTR Buffer);
VOID				SetRegion(STRPTR Buffer);
VOID				ResetCursor(VOID);
VOID				MoveCursorUp(STRPTR Buffer);
VOID				MoveCursorDown(STRPTR Buffer);
VOID				VT52_CursorUp(STRPTR Buffer);
VOID				VT52_CursorDown(STRPTR Buffer);
VOID				VT52_CursorRight(STRPTR Buffer);
VOID				VT52_CursorLeft(STRPTR Buffer);
VOID				VT52_CursorHome(STRPTR Buffer);
VOID				VT52_RevLF(STRPTR Buffer);
VOID				VT52_EraseEOS(STRPTR Buffer);
VOID				VT52_EraseEOL(STRPTR Buffer);
VOID				VT52_SetCursor(STRPTR Buffer);
VOID				VT52_PrintOn(STRPTR Buffer);
VOID				VT52_PrintOff(STRPTR Buffer);
VOID				VT52_PrintScreen(STRPTR Buffer);
VOID				VT52_PrintLine(STRPTR Buffer);
VOID				VT52_EnterANSI(STRPTR Buffer);

	// EmulationPanel.c

BOOL				EmulationPanel(struct Window *Parent,struct Configuration *LocalConfig);

	// EmulationProcess.c

VOID				DeleteEmulationProcess(VOID);
BOOL				CreateEmulationProcess(VOID);

	// FastMacroPanel.c

BOOL				FastMacroPanelConfig(struct Configuration *LocalConfig,struct List *FastMacroList,STRPTR LastFastMacros,struct Window *Parent,BOOLEAN *pFastMacrosChanged);

	// FastMacroWindow.c

VOID				RefreshFastWindow(BOOL FullRefresh);
VOID				CloseFastWindow(VOID);
BOOL				OpenFastWindow(VOID);
VOID				HandleFastWindowGadget(ULONG IClass,LONG ICode,LONG GadgetID);

	// FastMacros.c

struct MacroNode *		NewFastMacro(STRPTR Macro,STRPTR Code);
BOOL				SaveFastMacros(STRPTR Name,struct List *FastMacroList);
BOOL				LoadFastMacros(STRPTR Name,struct List *FastMacroList);

	// FileBuffer.c

LONG __stdargs			BPrintf(struct Buffer *Buffer,STRPTR Format,...);
BOOL				BufferFlush(struct Buffer *Buffer);
BOOL				BufferClose(struct Buffer *Buffer);
struct Buffer *			BufferOpen(STRPTR Name,STRPTR AccessMode);
BOOL				BufferSeek(struct Buffer *Buffer,LONG Offset,LONG Origin);
LONG				BufferRead(struct Buffer *Buffer,STRPTR Destination,LONG Size);
LONG				BufferWrite(struct Buffer *Buffer,STRPTR Source,LONG Size);

	// FixPath.c

VOID				AttachCLI(struct WBStartup *Startup);

	// HotkeyPanel.c

BOOL				HotkeyPanelConfig(struct Configuration *LocalConfig,struct Hotkeys *Hotkeys,STRPTR LastKeys,BOOLEAN *ChangePtr);

	// Hotkeys.c

VOID				ShutdownCx(VOID);
BOOL				SetupCx(VOID);
BOOL				LoadHotkeys(STRPTR Name,struct Hotkeys *Keys);

	// Identify.c

LONG				GetFileType(STRPTR Name,BOOL AttachComment);
VOID				Identify(STRPTR Name,BOOL AttachComment);
VOID				AddIcon(STRPTR Name,LONG Index,BOOL Override);

	// ImportPanel.c

BOOL				ImportPanel(struct Window *Parent,struct PhoneEntry *Entry,struct List *PhoneList,struct List *TimeDateList);

	// InfoWindow.c

VOID				CloseInfoWindow(VOID);
VOID				OpenInfoWindow(VOID);

	// Init.c

struct Library *		SafeOpenLibrary(STRPTR Name,LONG Version);
VOID				TTYResize(VOID);
BOOL				AttachMenu(struct Menu *ThisMenu);
VOID				DisconnectDialMenu(VOID);
struct Menu *			BuildMenu(VOID);
VOID				UpdateTerminalLimits(VOID);
VOID				Current2DefaultPalette(struct Configuration *SomeConfig);
VOID				Default2CurrentPalette(struct Configuration *SomeConfig);
VOID				PaletteSetup(struct Configuration *SomeConfig);
VOID				ResetCursorKeys(struct CursorKeys *Keys);
VOID				ScreenSizeStuff(VOID);
VOID				PubScreenStuff(VOID);
BOOL				DisplayReset(VOID);
BOOL				DeleteDisplay(VOID);
STRPTR				CreateDisplay(BOOL FirstSetup);
VOID				CloseAll(BOOL CloseDOS);
STRPTR				OpenAll(STRPTR ConfigPath);
VOID				ConfigSetup(VOID);

	// LibPanel.c

BOOL				SignaturePanel(struct Window *Parent,STRPTR String,LONG ReceiveMode);
BOOL				LibPanel(struct Window *Parent,struct Configuration *LocalConfig);

	// LibPanelPlus.c

VOID				ASCIITransferPanel(struct Window *Window,struct Configuration *Config);
BOOL				ExternalCommandPanel(struct Window *Parent,STRPTR Command);

	// Lists.c

VOID				ClearGenericList(struct GenericList *List);
VOID				DeleteGenericList(struct GenericList *List);
struct GenericList *		CreateGenericList(VOID);
struct Node *			FirstGenericListNode(struct GenericList *List);
struct Node *			LastGenericListNode(struct GenericList *List);
struct Node *			NextGenericListNode(struct GenericList *List);
struct Node *			PrevGenericListNode(struct GenericList *List);
VOID				DeleteGenericListNode(struct GenericList *List,struct Node *Node);
struct Node *			CreateGenericListNode(LONG Size,STRPTR Name);
VOID				AddGenericListNode(struct GenericList *List,struct Node *Node,LONG Mode);
LONG				GenericListCount(struct GenericList *List);

	// Locale.c

VOID				LocaleOpen(STRPTR CatalogName,STRPTR BuiltIn,LONG Version);
VOID				LocaleClose(VOID);
VOID				LanguageCheck(VOID);
STRPTR				LocaleSeconds(LONG Seconds);
STRPTR				SmallCurrency(VOID);
VOID				InsertGrouping(STRPTR Buffer,STRPTR GroupData,STRPTR GroupSeparator);
VOID				ConvertMonetaryQuantity(LONG Units,STRPTR Destination,BOOL UseCurrency);
STRPTR				CreateSum(LONG Quantity,BOOL UseCurrency);
VOID				LocalizeString(STRPTR *Strings,LONG From,LONG To);
VOID				LocalizeStringTable(STRPTR *Strings,LONG *Table);
VOID				LocalizeMenuTable(struct NewMenu *Menu,LONG *Table);
STRPTR				LocaleString(ULONG ID);
STRPTR __saveds __asm		LocaleHookFunc(REG(a0) struct Hook *Hook,REG(a1) LONG ID);
BOOL				FormatStamp(struct DateStamp *Stamp,STRPTR DateBuffer,STRPTR TimeBuffer,STRPTR BothBuffer,BOOL SubstituteDay);
VOID				FormatTime(STRPTR Buffer,LONG Hours,LONG Minutes,LONG Seconds);
STRPTR __saveds __stdargs	StandardShowTime(struct Gadget *SomeGadget,LONG Level);

	// MacroPanel.c

BOOL				MacroPanelConfig(struct Configuration *LocalConfig,struct MacroKeys *MacroKeys,STRPTR LastMacros,struct Window *Parent,BOOLEAN *ChangePtr);

	// Main.c

LONG				main(VOID);
VOID __saveds			HandleInput(VOID);
BOOL				HandleWindow(VOID);
VOID				HandleMenuCode(ULONG Code,ULONG Qualifier);
VOID				HandleMenu(ULONG Code,ULONG Qualifier);
BOOL				HandleWorkbenchWindow(VOID);
VOID				HandleIconify(VOID);
VOID				HandleOnlineCleanup(BOOL Hangup);
VOID				HandleFlowChange(VOID);
VOID				HandleSerialReset(VOID);
VOID				HandleSerialRelease(VOID);
VOID				HandleExternalEmulation(VOID);
BOOL				HandleSerialCheck(VOID);
BOOL				HandleQueueMsg(VOID);
BOOL				HandleOwnDevUnit(VOID);
VOID				FullHangup(BOOL ForceIt);

	// Marker.c

VOID				BM_Draw(struct BlockMarker *,VOID (*Select)(struct BlockMarker *,LONG Left,LONG Top,LONG Width,LONG Height));
VOID				BM_ClearMark(struct BlockMarker *);
struct BlockMarker *		BM_SetMark(APTR Object,VPTR Select,VPTR Unselect,LONG Width,LONG Height,LONG LeftEdge,LONG TopEdge,LONG Top,LONG Lines,LONG X,LONG Y,LONG TextFontWidth,LONG TextFontHeight);
VOID				BM_ExtendMark(struct BlockMarker *,LONG X,LONG Y,LONG Delta);
VOID				ToggleSelect(struct BlockMarker *,LONG Left,LONG Top,LONG Width,LONG Height);
VOID				WriteTrimmedString(struct IFFHandle *Handle,STRPTR String,LONG Len,BOOL NeedClipConversion);
VOID				MarkWord(LONG MouseX,LONG MouseY);
VOID				SetMarker(LONG MouseX,LONG MouseY);
VOID				MoveMarker(LONG MouseX,LONG MouseY);
VOID				DropMarker(VOID);
VOID				FreeMarker(VOID);
VOID				ClipMarker(BOOL Append);

	// Matrix.c

VOID				CloseMatrixWindow(VOID);
BOOL				DispatchMatrixWindow(ULONG *MsgClass,UWORD MsgCode,ULONG MsgQualifier,UBYTE Char);
struct Window *			OpenMatrixWindow(struct Window *Parent);

	// MemStubs.a

VOID __asm			FreeVecPooled(REG(a0) APTR Memory);
APTR __asm			AllocVecPooled(REG(d0) ULONG Size,REG(d1) ULONG Flags);

	// Memory.c

BOOL				MemorySetup(VOID);
VOID				MemoryCleanup(VOID);

	// MiscPanel.c

BOOL				MiscPanel(struct Window *Parent,struct Configuration *LocalConfig);

	// ModemPanel.c

BOOL				ModemPanel(struct Window *Parent,struct Configuration *LocalConfig);

	// MsgQueue.c

APTR				GetMsgItem(struct MsgQueue *Queue);
VOID				PutMsgItem(struct MsgQueue *Queue,struct MsgItem *Item);
VOID				DeleteMsgItem(struct MsgItem *Item);
struct MsgItem *		CreateMsgItem(LONG Size);
struct MsgItem *		CreateMinMsgItem(LONG Size);
VOID				UnlockMsgQueue(struct MsgQueue *Queue);
VOID				DeleteMsgQueue(struct MsgQueue *Queue);
struct MsgQueue *		CreateMsgQueue(ULONG SigMask,LONG MaxSize);
VOID				SetQueueDiscard(struct MsgQueue *Queue,BOOL Mode);

	// OldConfig.c

BOOL				LoadOldPhonebook(STRPTR Name,PhonebookHandle *BookHandle);
BOOL				ReadOldConfig(STRPTR Name,struct Configuration *Config);

	// Packet.c

VOID				ClearPacketHistory(VOID);
VOID				AddPacketHistory(STRPTR Buffer);
VOID				DeletePacketWindow(BOOL WindowOnly);
BOOL				CreatePacketWindow(VOID);

	// PathPanel.c

BOOL				PathPanel(struct Window *Parent,struct Configuration *LocalConfig);

	// PatternPanel.c

BOOL				PatternPanelConfig(struct List *PatternList,STRPTR LastPattern,BOOLEAN *ChangedPtr);

	// Phone.c

VOID				RemoveDialEntry(struct PhoneNode *Node);
VOID				RemoveDialNode(struct PhoneNode *Node);
BOOL				SortToList(struct PhoneNode *PhoneNode,struct PhoneEntry *Entry);
VOID				FreeDialList(BOOL ClearAll);
struct List *			CreatePhoneList(VOID);
VOID				UpdatePhoneList(struct List *PhoneList);
VOID				DeletePhoneList(struct List *PhoneList);
VOID				SortPhoneEntries(struct List *List,LONG How,BOOL ReverseOrder);
VOID				FreeTimeDateNode(struct TimeDateNode *Node);
VOID				FreeTimeDateList(struct List *List);
VOID				CopyTimeDateList(struct List *From,struct List *To,BOOL SkipFirst);
VOID				AdaptTimeDateNode(struct TimeDateNode *Node);
VOID				SortTimeTable(struct TimeDateNode *Node);
struct List *			BuildTimeList(struct TimeDateNode *Node);
BOOL				ResizeTimeDateNode(struct TimeDateNode *Node,LONG Count,UBYTE Time);
BOOL				DeleteTimeDateNode(struct TimeDateNode *Node,LONG Index);
struct TimeDateNode *		CreateTimeDateNode(LONG Month,LONG Day,STRPTR Comment,LONG Count);
VOID				RemPhoneEntry(struct PhoneNode *Node,LONG Num);
struct PhoneEntry *		NewPhoneEntry(VOID);
struct PhoneEntry **		MergePhonebook(PhonebookHandle *BookHandle);
struct PhoneEntry **		CreatePhonebook(LONG Size,LONG *AllocSize,BOOL CreateEntries);
VOID				DeletePhonebook(struct PhoneEntry **Phonebook,LONG Size,BOOL FreeEntries);
VOID				DeletePhoneGroupNode(PhoneGroupNode *GroupNode);
VOID				DeletePhoneGroupList(struct MinList *List);
PhoneGroupNode *		CreatePhoneGroup(STRPTR Name,struct MinList *List);
struct PhoneNode *		AddGroupEntry(PhoneGroupNode *NewGroup,struct PhoneNode *Node);
VOID				CopyPhoneHeader(struct PhoneHeader *From,struct PhoneHeader *To);

	// PhonePanel.c

BOOL				PhonePanel(ULONG MsgQualifier);

	// PhonePanelPlus.c

BOOL				SaveChanges(struct Window *Parent);
BOOL				EditConfig(struct Configuration *Config,LONG Type,ULONG Qualifier,struct Window *Window);
BOOL				ChangeState(LONG Type,LONG Default,struct PhoneNode *Node);
STRPTR *			BuildLabels(VOID);
VOID				FindGroup(struct List **pCurrentList,LONG *pSelected,ULONG *pGrouper,struct List *PhoneList,struct MinList *List,struct PhoneNode *This);

	// PhonePanelUI.c

struct LayoutHandle *		CreateEditorHandle(struct Window *Parent,struct List *PhoneList,ULONG Count,struct PhoneNode *Node,BOOL Activate,struct MsgPort *UserPort);
struct LayoutHandle *		CreateManagerHandle(struct Window *Parent,struct List *PhoneList,ULONG Count,ULONG *Grouper,STRPTR *Labels,struct MsgPort *UserPort,STRPTR WindowTitle);
struct LayoutHandle *		CreateSelectorHandle(struct Window *Parent,STRPTR Name,STRPTR Number,STRPTR Comment,BYTE *Mode);
struct LayoutHandle *		CreateGroupHandle(struct Window *Parent,STRPTR *Labels,ULONG Group);
struct LayoutHandle *		CreateSortHandle(struct Window *Parent,WORD *Criteria,BOOLEAN *Reverse);
VOID				UpdatePasswordWindow(struct LayoutHandle *Handle);
BOOL				GetWindowPassword(struct LayoutHandle *Handle,STRPTR Password);
struct LayoutHandle *		CreatePasswordHandle(struct Window *Parent,BOOL PasswordEnabled);


	// PickDisplayMode.c

BOOL				PickDisplayMode(struct Window *Parent,ULONG *CurrentMode,struct Configuration *Config);

	// PickFile.c

BOOL				ValidateFile(STRPTR FileName,LONG Type,STRPTR RealName);
BOOL				PickFile(struct Window *Window,STRPTR Directory,STRPTR Pattern,STRPTR Prompt,STRPTR Name,LONG Type);

	// PickScreen.c

BOOL				PickScreen(struct Window *Window,STRPTR Name);

	// Print.c

BOOL __stdargs			PrintText(BPTR File,struct Window *ReqWindow,LONG *Error,STRPTR String,...);
BOOL				PrintFileInformation(BPTR File,struct Window *ReqWindow,LONG *Error,STRPTR Name,ULONG Flags);
BOOL				PrintEntry(BPTR File,struct Window *ReqWindow,BOOL Plain,LONG *Error,struct PhoneEntry *Entry,ULONG Flags);
BOOL				PrintScreen(BPTR File,struct Window *ReqWindow,LONG *Error);
BOOL				PrintClip(BPTR File,struct Window *ReqWindow,LONG *Error);
BOOL				PrintBuffer(BPTR File,struct Window *ReqWindow,LONG *Error);
VOID				PrintSomething(LONG Source);
VOID				PrintRegion(LONG Top,LONG Bottom,BOOL FormFeed);
BOOL				PrintScreenGfx(VOID);

	// PrintPanel.c

VOID				PrintPanel(struct Window *Window,struct List *PhoneList,LONG Count);

	// QuickSort.a

VOID __stdargs			QuickSort(APTR Base,LONG Count,LONG Size,LONG (* __stdargs Compare)(APTR Arg1,APTR Arg2));

	// Raster.c

VOID				DeleteRaster(VOID);
BOOL				CreateRaster(VOID);
VOID				RasterEraseScreen(LONG Mode);
VOID				RasterEraseLine(LONG Mode);
VOID				RasterEraseCharacters(LONG Chars);
VOID				RasterClearLine(LONG Lines,LONG Top);
VOID				RasterInsertLine(LONG Lines,LONG Top);
VOID				RasterScrollRegion(LONG Direction,LONG RasterTop,LONG RasterBottom,LONG RasterLines);
VOID				RasterShiftChar(LONG Size);
VOID				RasterPutString(STRPTR String,LONG Length);
VOID				SaveRasterDummy(LONG First,LONG Last);
VOID				SaveRasterReal(LONG First,LONG Last);

	// RatePanel.c

BOOL				RatePanel(struct Window *Parent,struct List *PhoneList,struct PhoneEntry *Entry,struct List *TimeDateList);

	// Remember.c

VOID				FinishRecord(VOID);
BOOL				CreateRecord(STRPTR BBSName);
VOID				DeleteRecord(VOID);
VOID				RememberResetOutput(VOID);
VOID				RememberOutputText(register STRPTR String,register LONG Size);
VOID				RememberResetInput(VOID);
VOID				RememberInputText(register STRPTR String,register LONG Size);
VOID				RememberSpill(VOID);

	// Response.c

VOID				HandleResponse(VOID);

	// SaveWindow.c

BOOL				SaveWindow(STRPTR Name,struct Window *Window);

	// Scale.c

VOID				DeleteScale(VOID);
BOOL				CreateScale(struct Window *Parent);
VOID				PrintScaled(STRPTR Buffer,LONG Size,LONG Scale);

	// ScreenPanel.c

BOOL				ScreenPanel(struct Window *Parent,struct Configuration *LocalConfig);

	// Scroll.c

VOID				ScrollLineRectFill(struct RastPort *RPort,LONG MinX,LONG MinY,LONG MaxX,LONG MaxY);
VOID				ScrollLineRectFillNoTabChange(struct RastPort *RPort,LONG MinX,LONG MinY,LONG MaxX,LONG MaxY);
VOID				ScrollLineRaster(struct RastPort *RPort,LONG DeltaX,LONG DeltaY,LONG MinX,LONG MinY,LONG MaxX,LONG MaxY,BOOL Smooth);
VOID				ScrollLineRasterNoTabChange(struct RastPort *RPort,LONG DeltaX,LONG DeltaY,LONG MinX,LONG MinY,LONG MaxX,LONG MaxY,BOOL Smooth);
VOID				ScrollLineEraseScreen(LONG Mode);
VOID				ScrollLineEraseLine(LONG Mode);
VOID				ScrollLineEraseCharacters(LONG Chars);
VOID				ScrollLineShiftChar(LONG Size);
VOID				ScrollLinePutString(LONG Length);

	// SendText.c

BOOL				MatchPrompt(register STRPTR Data,register LONG Size,register STRPTR Prompt,register LONG PromptLen);
BOOL				SendLinePrompt(STRPTR Line,LONG Len);
BOOL				SendLineSimple(STRPTR Line,LONG Len);
BOOL				SendLineDial(STRPTR Line,LONG Len);
BOOL				SendLineDelay(STRPTR Line,LONG Len);
BOOL				SendLineEcho(STRPTR Line,LONG Len);
BOOL				SendLineAnyEcho(STRPTR Line,LONG Len);
BOOL				SendLineKeyDelay(STRPTR Line,LONG Len);
VOID				SendSetup(VOID);

	// Serial.c

VOID				SendBreak(VOID);
VOID				HangUp(VOID);
BOOL				DropDTR(VOID);
VOID				CopyWriteFlags(VOID);
VOID				SerialCommand(STRPTR String);
VOID				SerWriteVerbatim(APTR Buffer,LONG Size,BOOL Echo);
VOID				SerWrite(APTR Buffer,LONG Size);
VOID				RestartSerial(VOID);
VOID				ClearSerial(VOID);
VOID				DeleteSerial(VOID);
STRPTR				GetSerialError(LONG Error,BOOL *Reset);
STRPTR				CreateSerial(VOID);
LONG				ReconfigureSerial(struct Window *Window,struct SerialSettings *SerialConfig);
VOID				ReopenSerial(VOID);
BOOL				HandleSerial(VOID);

	// SerialIO.c

VOID				ResetSerialRead(VOID);
BOOL				CheckSerialRead(VOID);
BYTE				WaitSerialRead(VOID);
BYTE				FlushSerialRead(VOID);
VOID				StopSerialRead(VOID);
VOID				StartSerialRead(register APTR Data,register ULONG Length);
BYTE				DoSerialRead(register APTR Data,register ULONG Length);
VOID				ResetSerialWrite(VOID);
BOOL				CheckSerialWrite(VOID);
BYTE				WaitSerialWrite(VOID);
VOID				StopSerialWrite(VOID);
VOID				StartSerialWrite(register APTR Data,register ULONG Length);
BYTE				DoSerialWrite(register APTR Data,register ULONG Length);
BYTE				DoSerialCmd(register LONG Command);
ULONG				GetSerialWaiting(VOID);
LONG				GetSerialStatus(VOID);
VOID				GetSerialInfo(register ULONG *Waiting,register UWORD *Status);
BYTE __stdargs			SetBothSerialAttributes(Tag FirstTag,...);
BYTE __stdargs			SetSerialReadAttributes(Tag FirstTag,...);
BYTE __stdargs			SetSerialWriteAttributes(Tag FirstTag,...);
ULONG __stdargs			GetSerialReadAttributes(Tag FirstTag,...);
ULONG __stdargs			GetSerialWriteAttributes(Tag FirstTag,...);

	// SerialPanel.c

BOOL				SerialPanel(struct Window *Parent,struct Configuration *LocalConfig);

	// Sound.c

VOID				FreeSound(struct SoundInfo *SoundInfo);
struct SoundInfo *		LoadSound(STRPTR Name,BOOL Warn);
VOID				PlaySound(struct SoundInfo *SoundInfo);
VOID				SoundExit(VOID);
VOID				SoundInit(VOID);
VOID				SoundPlay(LONG Sound);

	// SoundPanel.c

BOOL				SoundPanelConfig(struct SoundConfig *SoundConfig,STRPTR LastSound,BOOLEAN *ChangedPtr);

	// Speech.c

VOID				DeleteSpeech(VOID);
BOOL				CreateSpeech(VOID);
VOID __stdargs			Say(STRPTR String,...);
VOID				SpeechSetup(VOID);

	// SpeechPanel.c

BOOL				SpeechPanelConfig(struct SpeechConfig *SpeechConfig,STRPTR LastSpeech,BOOLEAN *ChangePtr);

	// StackCall.a

LONG __stdargs			StackCall(LONG *Success,LONG StackSize,LONG ArgCount,LONG (* __stdargs Function)(...),...);
LONG				StackSize(struct Task *Task);

	// Start.c

LONG __saveds __stdargs		Start(VOID);

	// StatusDisplay.c

VOID __saveds			StatusServer(VOID);
VOID				ForceStatusUpdate(VOID);

	// TerminalPanel.c

BOOL				TerminalPanel(struct Window *Parent,struct Configuration *LocalConfig);

	// TextBuffer.c

BOOL				LaunchBuffer(VOID);
VOID				TerminateBuffer(VOID);
VOID				MoveBuffer(struct SignalSemaphore *Access,const struct TextBufferInfo **Data,LONG Mode);
VOID				NotifyBuffer(struct SignalSemaphore *Access,const struct TextBufferInfo **Data,ULONG Signals);
VOID				MoveReview(LONG Mode);
VOID				DeleteReview(VOID);
BOOL				CreateReview(VOID);

	// TimeDate.c

VOID				SelectTime(struct PhoneEntry *SomeEntry,struct List *List,struct timeval *TimeVal);
struct List *			FindTimeDate(struct List *Patterns,STRPTR Number);
VOID				DeletePatternNode(struct PatternNode *Pattern);
struct PatternNode *		CreatePatternNode(STRPTR Comment);
VOID				DeletePatternList(struct List *List);
VOID				FreePatternList(struct List *List);
VOID				ConvertTimeDate(struct TimeDateOld *Old,struct TimeDate *New);
struct List *			LoadTimeDateList(STRPTR Name,LONG *Error);
BOOL				SaveTimeDateList(STRPTR Name,struct List *List,LONG *Error);

	// TimePanel.c

BOOL				TimePanel(struct Window *Parent,UBYTE *StartTime);

	// Tools.c

VOID				ListViewStateFill(struct LVDrawMsg *Msg);
VOID				EraseWindow(struct Window *Window,UWORD *Pens);
LONG				GetListMaxPen(const UWORD *Pens);
VOID				FillBox(struct RastPort *RPort,LONG Left,LONG Top,LONG Width,LONG Height);
VOID				PlaceText(struct RastPort *RPort,LONG Left,LONG Top,STRPTR String,LONG Len);
VOID				SetPens(struct RastPort *RPort,ULONG APen,ULONG BPen,ULONG DrMd);
VOID __stdargs			SPrintf(STRPTR Buffer,STRPTR FormatString,...);
VOID				VSPrintf(STRPTR Buffer,STRPTR FormatString,va_list VarArgs);
LONG				Atol(STRPTR Buffer);
VOID				StripSpaces(STRPTR String);
VOID				ReplaceWindowInfo(struct WindowInfo *NewInfo);
VOID				PutWindowInfo(LONG ID,LONG Left,LONG Top,LONG Width,LONG Height);
VOID				GetWindowInfo(LONG ID,LONG *Left,LONG *Top,LONG *Width,LONG *Height,LONG DefWidth,LONG DefHeight);
LONG				GetBitMapDepth(struct BitMap *BitMap);
VOID				GetDPI(ULONG Mode,ULONG *X_DPI,ULONG *Y_DPI);
VOID				AddProtection(STRPTR Name,ULONG Mask);
BOOL				GetPubScreenName(struct Screen *Screen,STRPTR Name);
VOID				InitSinglePort(struct MsgPort *Port);
BOOL				GoodStream(BPTR Stream);
struct DiskObject *		GetProgramIcon(VOID);
LONG				GetPenIndex(LONG Pen);
LONG				GetScreenWidth(struct Window *Window);
LONG				GetScreenHeight(struct Window *Window);
LONG				GetScreenLeft(struct Window *Window);
LONG				GetScreenTop(struct Window *Window);
ULONG				OldGetAPen(struct RastPort *RPort);
ULONG				OldGetBPen(struct RastPort *RPort);
ULONG				OldGetDrMd(struct RastPort *RPort);
ULONG				OldSetWrMsk(struct RastPort *RPort,ULONG Mask);
ULONG				NewGetAPen(struct RastPort *RPort);
ULONG				NewGetBPen(struct RastPort *RPort);
ULONG				NewGetDrMd(struct RastPort *RPort);
ULONG				NewSetWrMsk(struct RastPort *RPort,ULONG Mask);
VOID				SetWait(struct Window *Window);
VOID				ClrWait(struct Window *Window);
STRPTR				GetModeName(ULONG Mode);
BOOL				ModeOkay(ULONG ID);
VOID				SetClipMenu(BOOL Mode);
VOID				SetRedialMenu(VOID);
VOID				SetDialMenu(BOOL Mode);
VOID				SetTransferMenu(BOOL Mode);
VOID				SetRasterMenu(BOOL Mode);
BOOL				PickFont(struct Window *Window,STRPTR Name,WORD *Points,BOOL MonoSpaced);
STRPTR				ExtractString(STRPTR String,STRPTR Destination,BOOL ReturnEnd);
LONG				GetListSize(struct List *List);
struct Node *			GetListNode(LONG Offset,struct List *List);
struct Node *			CreateNode(STRPTR Name);
VOID				FreeNode(struct Node *Node);
VOID				FreeList(struct List *List);
LONG				GetNodeOffset(struct Node *Node,struct List *List);
VOID				MoveList(struct List *From,struct List *To);
VOID __stdargs			LogAction(STRPTR String,...);
VOID				FlushMsg(struct Window *Window);
BOOL				GetString(BOOL LoadGadget,BOOL Password,LONG MaxChars,STRPTR Prompt,STRPTR Buffer);
VOID				WakeUp(struct Window *Window,LONG Sound);
VOID				SendAmigaDOSCommand(STRPTR Name);
VOID				SendARexxCommand(STRPTR Name,BOOL QueueIt);
VOID				BlockWindows(VOID);
VOID				ReleaseWindows(VOID);
LONG				LineRead(BPTR File,STRPTR Buffer,LONG MaxChars);
LONG				GetBaudRate(STRPTR Buffer);
struct MenuItem *		FindThisItem(struct Menu *FirstMenu,ULONG MenuID);
struct Menu *			FindThisMenu(struct Menu *FirstMenu,ULONG MenuID);
BOOL				GetItem(ULONG MenuID);
VOID				SetItem(ULONG MenuID,BOOL Mode);
LONG				GetFileSize(STRPTR Name);
VOID				PutDimensionTags(struct Window *Reference,LONG Left,LONG Top,LONG Width,LONG Height);
struct TagItem *		GetDimensionTags(struct Window *Reference,struct TagItem *Tags);
struct FileRequester *		GetFile(struct Window *Parent,STRPTR Title,STRPTR Directory,STRPTR Name,STRPTR Buffer,STRPTR Pattern,BOOL SaveFlag,BOOL MultiSelect,BOOL DirsOnly,STRPTR OKText,BOOL AskWrite);
LONG __stdargs			ShowRequest(struct Window *Window,STRPTR Text,STRPTR Gadgets,...);
VOID				CloseWindowSafely(struct Window *Window);
VOID				DelayTime(LONG Secs,LONG Micros);
VOID				WaitTime(VOID);
VOID				StopTime(VOID);
VOID				StartTime(LONG Secs,LONG Micros);
STRPTR				GetEnvDOS(STRPTR Name,STRPTR Buffer);
BOOL				SetEnvDOS(STRPTR Name,STRPTR Value);
VOID				BumpWindow(struct Window *SomeWindow);
VOID				PushWindow(struct Window *Window);
VOID				PopWindow(VOID);
BOOL				LoadMacros(STRPTR Name,struct MacroKeys *Keys);
BOOL				WriteIFFData(STRPTR Name,APTR Data,LONG Size,ULONG Type);
BOOL				ReadIFFData(STRPTR Name,APTR Data,LONG Size,ULONG Type);
VOID				SplitFileName(STRPTR FullName,STRPTR *FileName,STRPTR DrawerName);
struct List *			CreateList(VOID);
VOID				DeleteList(struct List *List);
VOID __saveds __asm		BackfillRoutine(REG(a0) struct Hook *Hook,REG(a1) struct LayerMsg *Bounds,REG(a2) struct RastPort *RPort);
UBYTE *				ShrinkName(const UBYTE *Source,UBYTE *Destination,LONG MaxLength,BOOL FixSuffix);
VOID				BuildFontName(STRPTR Destination,const STRPTR Name,LONG Size);
BOOL				CreateMenuGlyphs(struct Screen *Screen,struct DrawInfo *DrawInfo,struct Image **AmigaPtr,struct Image **CheckPtr);
VOID				FixName(STRPTR Name);
VOID				ShowError(struct Window *Window,LONG Primary,LONG Secondary,STRPTR String);
RendezvousData * __saveds __asm	RendezvousLogin(REG(a0) struct MsgPort *ReadPort,REG(a1) struct MsgPort *WritePort,REG(a2) struct TagItem *TagList);
VOID __saveds __asm		RendezvousLogoff(REG(a0) RendezvousData *Data);
struct Node * __saveds __asm	RendezvousNewNode(REG(a0) STRPTR Name);
struct List *			BuildModeList(LONG *Index,ULONG DisplayMode,ULONG (*__asm ModeFilter)(REG(d0) ULONG ID,REG(a0) APTR UserData), APTR UserData);
BOOL				IsAssign(STRPTR Name);
BOOL				LockInAssign(BPTR TheLock,STRPTR TheAssignment);
VOID				DeleteBitMap(struct BitMap *BitMap);
struct BitMap *			CreateBitMap(ULONG Width,ULONG Height,ULONG Depth,ULONG Flags,struct BitMap *Friend);
LONG				LaunchCommand(STRPTR Command);
BOOL				AskDial(struct Window *Parent);
LONG				Strcoll(STRPTR a1,STRPTR b1);
struct Process *		LaunchProcess(STRPTR Name,VOID (*Entry)(VOID),BPTR Stream);
BOOL				String2Boolean(STRPTR String);
VOID				SendMessageGetReply(struct MsgPort *Port,struct Message *Message);
VOID				SetOnlineState(BOOL IsOnline);

	// Transfer.c

VOID				FreeFileTransferInfo(struct FileTransferInfo *Info);
struct FileTransferInfo *	AllocFileTransferInfo(VOID);
BOOL				AddFileTransferNode(struct FileTransferInfo *Info,STRPTR Name,ULONG Size);
VOID				SortFileTransferInfo(struct FileTransferInfo *Info);
struct FileTransferInfo *	BuildFileTransferInfo(struct FileRequester *FileRequester);
VOID				SendTextFile(LONG Type,STRPTR TheFile);
VOID				StartXprReceive(LONG Type,STRPTR Name,BOOL WaitForIt);
BOOL				StartXprSend(LONG Type,BOOL WaitForIt);
BOOL				StartXprSendFromList(LONG Type,BOOL WaitForIt);
BOOL				ChangeProtocol(STRPTR ProtocolName,LONG Type);
VOID				ResetProtocol(VOID);
BOOL				ProtocolSetup(BOOL IgnoreOptions);
VOID				SaveProtocolOpts(VOID);
BOOL				SelectProtocol(STRPTR Name,struct Window *ParentWindow);
VOID				TransferCleanup(VOID);
VOID				RemoveUploadListItem(STRPTR Name);
VOID				CloseXPR(VOID);

	// TransferPanel.c

VOID __stdargs			AddTransferInfo(BOOL Error,STRPTR Message,...);
BOOL				TransferPanel(STRPTR Title);
VOID				DeleteTransferPanel(BOOL WaitForPrompt);

	// Translate.c

VOID				TranslateSetup(struct TranslationHandle *Handle,STRPTR SourceBuffer,LONG SourceLen,STRPTR DestinationBuffer,LONG DestinationLen,struct TranslationEntry **Table);
LONG				TranslateBuffer(struct TranslationHandle *Handle);
UBYTE				NameToCode(STRPTR Name);
STRPTR				CodeToName(UBYTE Code);
VOID				FreeTranslationTable(struct TranslationEntry **Table);
struct TranslationEntry **	AllocTranslationTable(VOID);
VOID				FreeTranslationEntry(struct TranslationEntry *Entry);
LONG				TranslateString(STRPTR From,STRPTR To);
struct TranslationEntry *	AllocTranslationEntry(STRPTR String);
BOOL				FillTranslationTable(struct TranslationEntry **Table);
BOOL				IsStandardTable(struct TranslationEntry **Table);
VOID				TranslateBack(STRPTR From,LONG Len,STRPTR To);
BOOL				SaveTranslationTables(STRPTR Name,struct TranslationEntry **SendTable,struct TranslationEntry **ReceiveTable);
BOOL				LoadTranslationTables(STRPTR Name,struct TranslationEntry **SendTable,struct TranslationEntry **ReceiveTable);

	// TranslationPanel.c

BOOL				TranslationPanelConfig(struct Configuration *LocalConfig,struct TranslationEntry ***SendTablePtr,struct TranslationEntry ***ReceiveTablePtr,STRPTR LastTranslation,struct Window *Parent,BOOLEAN *ChangePtr);

	// TrapPanel.c

BOOL				TrapPanelConfig(struct Configuration *LocalConfig,BOOLEAN *ChangedPtr);

	// Traps.c

struct TrapNode *		ChangeTrapNode(struct GenericList *TrapList,struct TrapNode *Current,STRPTR Sequence,STRPTR Command);
struct TrapNode *		CreateTrapNode(STRPTR SequenceBuffer,STRPTR CommandBuffer);
BOOL				SaveTraps(STRPTR Name,struct List *TrapList);
BOOL				LoadTraps(STRPTR Name,struct GenericList *TrapList);

	// UploadPanel.c

LONG				UploadPanel(LONG SendMode);

	// UploadQueue.c

VOID				CloseQueueWindow(VOID);
VOID				DeleteQueueProcess(VOID);
BOOL				CreateQueueProcess(VOID);
struct List *			GetUploadList(VOID);
BOOL				CheckUpload(VOID);
VOID				StartUpload(UBYTE Type);
VOID				ToggleUploadQueueIcon(BOOL Mode);

	// Verify.c

BOOL				FindPath(struct Window *Parent,STRPTR Path,BOOL CanCreate,LONG *Error);
BOOL				FindDrawer(struct Window *Parent,STRPTR Drawer,BOOL CanCreate,LONG *Error);
BOOL				FindFile(struct Window *Parent,STRPTR File,LONG *Error);
BOOL				FindProgram(struct Window *Parent,STRPTR Program,LONG *Error);
BOOL				FindLibDev(struct Window *Parent,STRPTR File,LONG Type,LONG *Error);

	// XEM.c

BOOL				SetEmulatorOptions(LONG Mode);
VOID				CloseEmulator(BOOL Exit);
BOOL				OpenEmulator(STRPTR Name);
VOID				SetupXEM_MacroKeys(struct MacroKeys *Keys);

	// XPR.c

LONG __saveds __asm		xpr_fopen(REG(a0) STRPTR FileName,REG(a1) STRPTR AccessMode);
LONG __saveds __asm		xpr_fclose(REG(a0) struct Buffer *File);
LONG __saveds __asm		xpr_fread(REG(a0) APTR Buffer,REG(d0) LONG Size,REG(d1) LONG Count,REG(a1) struct Buffer *File);
LONG __saveds __asm		xpr_fwrite(REG(a0) APTR Buffer,REG(d0) LONG Size,REG(d1) LONG Count,REG(a1) struct Buffer *File);
LONG __saveds __asm		xpr_fseek(REG(a0) struct Buffer *File,REG(d0) LONG Offset,REG(d1) LONG Origin);
LONG __saveds __asm		xpr_sread(REG(a0) APTR Buffer,REG(d0) LONG Size,REG(d1) ULONG Timeout);
LONG __saveds __asm		xpr_swrite(REG(a0) APTR Buffer,REG(d0) LONG Size);
LONG __saveds __asm		xpr_sflush(VOID);
LONG __saveds __asm		xpr_update(REG(a0) struct XPR_UPDATE *UpdateInfo);
VOID				xpr_display_update(struct XPR_UPDATE *UpdateInfo);
VOID				xpr_store_update(struct XPR_UPDATE *UpdateInfo);
LONG __saveds __asm		xpr_chkabort(VOID);
LONG __saveds __asm		xpr_gets(REG(a0) STRPTR Prompt,REG(a1) STRPTR Buffer);
LONG __saveds __asm		xpr_setserial(REG(d0) LONG Status);
LONG __saveds __asm		xpr_ffirst(REG(a0) STRPTR Buffer,REG(a1) STRPTR Pattern);
LONG __saveds __asm		xpr_fnext(REG(d0) LONG OldState,REG(a0) STRPTR Buffer,REG(a1) STRPTR Pattern);
LONG __saveds __asm		xpr_finfo(REG(a0) STRPTR FileName,REG(d0) LONG InfoType);
ULONG __saveds __asm		xpr_options(REG(d0) LONG NumOpts,REG(a0) struct xpr_option **Opts);
LONG __saveds __asm		xpr_unlink(REG(a0) STRPTR FileName);
LONG __saveds __asm		xpr_squery(VOID);
LONG __saveds __asm		xpr_getptr(REG(d0) LONG InfoType);
LONG __saveds __asm		xpr_stealopts(REG(a0) STRPTR Prompt,REG(a1) STRPTR Buffer);

#endif	// _PROTOS_H