#ifndef RECCOON_DOOR_H
#define RECCOON_DOOR_H TRUE
/*
**  $Filename: Reccoon/Door.h $
**  $Release: 0.58 $
**  $Revision: 58.4 $
**  $Date: 94/02/20 $
**
**  Reccoon door structures and commands.
**
**  (C) Copyright 1991-94 Niclas Emdelius.
**          All Rights Reserved
*/ 

#ifndef RECCOON_RECCOON_H
#include <Reccoon/Reccoon2.h>
#endif

/*** INTERNAL DATA!  Be very careful when changing!      ***/
/*** Protect list-modifications with Forbid()/Permit() ! ***/

struct InternalData
{
	UWORD	nevermind;	// Ignore

/* Flags */

	UBYTE	online;		// BBS online flag
	UBYTE	frontdoor;	// Using a frontdoor flag
	UBYTE	useronline;	// User online flag (obsolete)
	UBYTE	chatmode;	// Chatmode flag
	UBYTE	CARRIER;	// Carrier Detect flag (USE!)
	UBYTE	local;		// Local mode flag
	UBYTE	cursor;		// Cursor enabled flag
	UBYTE	disoutput;	// Output disabled flag
	UBYTE	scannedfiles;	// User scanned new files flag
	UBYTE	wantchat;	// Want chat flag
/**/

	UWORD	menupage;	// Current menupage
	UWORD	parentpage;	// Parent menupage
	UWORD	usernum;	// User being online
	UWORD	keyfrom;	// Last character from 0=local 1=serial
	UWORD	callstoday;	// Unused
	UWORD	msgarea;	// Current Msgarea
	UWORD	msgsig;		// Current msgSIG
	UWORD	filearea;	// Current filearea
	UWORD	filesig;	// Current fileSIG
	UWORD	prevmsgarea;	// Previous messagearea
	UWORD	prevfilarea;	// Previous filearea
	UWORD	linecount;	// Screen linecount
	UWORD	line;		// Reccoon line number
	UWORD	old_baudrate;	// Actual baudrate (obsolete, see below)
	UWORD	old_serbaud;	// Serial baudrate (obsolete, see below)
	UWORD	gfxmode;	// Menuset currently loaded
	 WORD	addedtime;	// Time added to user
	 WORD	idlecount;	// Unused
	UWORD	keypeklow;	// Lowest char in keybuff
	UWORD	keypekhi;	// Highest...
	UBYTE	keybuff[130];	// Console and serial keybuffer
	UBYTE	prompt[90];	// Menu prompt
	UBYTE	*xlatetable;	// Character translation table (256 bytes)
	UBYTE	age;		// Age of user being online
	UBYTE	unused1;

	struct RList 		markedfiles; 	// Marked files

	struct Task *		task;		// Reccoon's Task structure
	struct Window *		window;		// Reccoon's Window structure

	struct IOStdReq *	conWriteMsg;	// Device structures
	struct IOExtSer *	serialin;
	struct IOExtSer *	serialout;
	struct IOExtSer *	serialst;
	struct timerequest *	timerreq;
	struct timerequest *	idletimer;
	BOOL 			conwriteip;	// Device progress indicators
	BOOL			serialinip;
	BOOL			serialoutip;
	BOOL			serialstip;
	BOOL			timerip;
	BOOL			idleip;

	struct MsgPort *	rexxport;	// Reccoon's ARexx port
	struct ReccNode	*	rn;		// This line's ReccNode struct
	struct CookData	*	cookdata;	// For use with CookString()
	struct menu *		menu;		// Current menu
	struct {
	 UBYTE *bstrings[STR_MAXSTRINGS];
	} 		*	bstrings;	// Current loaded menuset
	struct RRemember *	remember;	// Some of the memory allocated	by Rcn

	struct MsgPort		doorport;	// Do not use
	BOOL			dooring;	// I'm executing a Door command
	BOOL			rexxing;	// I'm executing an ARexx command

	struct MsgPort * 	appport;	// MsgPort when iconified
	struct DiskObject * 	appobject;	// Icon image
	struct AppIcon * 	appicon;	// AppIcon structure
	BOOL			autoicon;	// Iconify on startup?

	BOOL			fpling;		// Are we executing a fplscript?
	BOOL			fplavail;	// Fpl available
	void *			fplkey;		// fpl.library's key

	BOOL			rexxwait;	// Are we waiting for an ARexx-script to finish?
	BOOL			doorwait;	// Are we waiting for a door to finish?

	struct Screen *		screen;		// Copy of ctrl->screen OR an own screenpointer.
	BOOL			ownscreen;	// Is above RCtrl's screen or my own?

	BOOL			hooking;	// Executing a fpl-hook function?

	ULONG			baudrate;	// Actual baudrate
	ULONG			serbaud;	// Serial baudrate
};

/*** Internal callback functions. Use the OpenDoor() function before ***/
/*** you use any other callback function, and use ContinueBBS()      ***/
/*** followed by CloseDoor() before your door exits.                 ***/
/*** your door exits.						     ***/

struct DoorCallback
{
	/** Door-handling **/

	void *		(*OpenDoor)	( void );
	void		(*CloseDoor)	( void * );
	void		(*ContinueBBS)	( void * );
	void		(*AsyncMode)	( void *, struct Task *, ULONG signals );
	ULONG		(*GetAsyncRes)	( void * );
	void		(*SyncMode)	( void * );

	void *		reserved[8];	// Future expansion

	/** Internal callback-functions **/

	ULONG		reserved1;
	ULONG		reserved2;
	BOOL		(*LinkMenu)	( void *, UWORD menupage );
	ULONG		reserved3;
	BOOL		(*CheckMore)	( void * );
	void		(*TitleBar)	( void * );
	
	void		(*Chat)		( void * );
	void		(*DoMenu)	( void * );
	void		(*RunDoor)	( void *, UBYTE *filename );
	UBYTE		(*ShowMenu)	( void *, UBYTE *filename );
	void		(*UserList)	( void *, UBYTE *searchstr );
	void		(*Quest)	( void *, UBYTE *filename );
	void		(*GetReturn)	( void * );
	void		(*LogOff)	( void * ); // Very dangerous!
	void		(*LogOn)	( void * );
	void		(*NewUser)	( void *, UBYTE *name );

	BOOL		(*MenuCommands) ( void *, UWORD command, UBYTE *args );

	ULONG		(*ReadMsg)	( void *, ULONG msgnum, ULONG msgarea );
	ULONG		reserved4;
	void		(*Replya)	( void *, struct msg *, ULONG msgarea );
	void		(*WaitingMail)	( void *, UWORD usernum );
	void		(*WriteMsg)	( void *, UBYTE *to, ULONG msgarea );
	UBYTE *		(*FSEdit)	( void *, ULONG * );
	void		(*MakeQuote)	( void *, struct msg *, ULONG msgarea );
	void		(*ScanMessages)	( void *, UBYTE *searchstr, ULONG msgarea );

	void		(*Download)	( void * );
	void		(*Upload)	( void * );
	BOOL		(*ChangeProtocol)(void * );
	BOOL		(*InitXPR)	( void * );
	void		(*WinSkriv)	( void *, UBYTE *str, UBYTE col, UWORD x, UWORD y );
	void		(*AddUledFiles)	( void * );
	BOOL		(*CopyFile)	( void *, UBYTE *source, UBYTE *dest, UBYTE *buff, ULONG buffsize );

	WORD		(*ListFiles)	( void *, ULONG area, UWORD mode, void *arg );
	BOOL		(*ListFile)	( void *, struct fil *, UWORD nr, UBYTE verbose );
	BOOL		(*MarkFile)	( void *, struct RList *, ULONG area, UBYTE *name, BOOL noratio, BOOL quiet);
	UWORD		(*MarkFiles)	( void *, struct RList *, struct FileList *, UBYTE *name, BOOL noratio, BOOL quiet);
	BYTE		(*AddMarked)	( void *, struct RList *, struct fil *, struct FileList *, ULONG nr, BOOL noratio);
	void		(*ViewFile)	( void *, ULONG area, UBYTE *name );
	void		(*EditFiles)	( void *, ULONG area, UBYTE *name );
	void		(*EditFile)	( void *, struct MarkedFile * );
	BOOL		(*KillFile)	( void *, struct MarkedFile * );
	BOOL		(*MoveFile)	( void *, struct MarkedFile *, ULONG destarea );
	void		(*ListMarked)	( void *, struct RList * );
	UWORD		(*UploadFile)	( void *, ULONG area, UBYTE *name, UBYTE *d1, UBYTE *d2, ULONG sz );
	void		(*GetDesc)	( void *, struct fil *, UBYTE *d1, UBYTE *d2 );
	BOOL		(*RemoveFiles)	( void *, struct RList * );
	void		(*PurgeFiles)	( void *, struct RList * );
	UBYTE *		(*NiceFilename)	( void *, UBYTE * );

	/* IO */

	void		(*CheckEvents)	( void * );
	void		(*DoMenupick)	( void *, WORD, WORD );
	UBYTE		(*GetChar)	( void *, UWORD flags );
	UWORD		(*GetString)	( void *, UBYTE *str, UWORD len, UWORD flags);
	BOOL		(*YesNo)	( void *, UBYTE *prompt, UBYTE yes, UBYTE no );
	BOOL		(*NoYes)	( void *, UBYTE *prompt, UBYTE yes, UBYTE no );
	void		(*SendChar)	( void *, UBYTE ascii );
	BOOL		(*SendString)	( void *, UBYTE *string, UWORD flags );
	BOOL		(*RSendString)	( void *, UBYTE *string, ULONG flags );
	BYTE		(*ShowFile)	( void *, UBYTE *name, UWORD flags );
	ULONG		reserved5;
	void		(*Skriv)	( void *, UBYTE *string );
	void		(*SkrivChar)	( void *, UBYTE );
	void		(*StartTimer)	( void *, ULONG secs, ULONG micros, BOOL wait );
	void		(*DosCommand)	( void *, UBYTE *command );
	UBYTE		(*CheckTime)	( void *, UBYTE mode );

	/* fifo inputbuffer commands */
	UBYTE		(*GetBottom)	( void * );
	UBYTE		(*GetTop)	( void * );
	UBYTE		(*ExamineBottom)( void * );
	UBYTE		(*ExamineTop)	( void * );
	UBYTE		(*PutTop)	( void *, UBYTE *str, UBYTE len );
	UBYTE		(*PutBottom)	( void *, UBYTE *str, UBYTE len );

	/* misc commands */

	UBYTE		(*AbortReq)	( void *, struct IORequest * );

	void		(*SendUsrMsg)	( void *, UBYTE *str );		// Not working
	BYTE		(*ShowAnyFile)	( void *, UBYTE *name, UWORD flags );

	void		(*WaitRCN)	( void * );
	void		(*AbortWaitRCN)	( void * );

	BOOL		(*RunARexx)	( void *, UBYTE *filename );
	LONG		(*FplHook)	( void *, UBYTE *funcname, void *arg, UWORD argtype);


};

/** Paragon door-message. Used when emulating Paragon. */

struct ParDoorMsg
{
	struct Message	Door_Msg;
	WORD		command;
	WORD		data;
	UBYTE		string[80];
	UWORD		carrier;
};

/** Arg-types for FplHook() **/

#define FPLHOOK_VOID 0		// No argument
#define FPLHOOK_ULONG 1		// Arg is a ULONG
#define FPLHOOK_UBYTE 2		// Arg is a UBYTE *

// FplHook() returns -1 if the hook could not be executed. Otherwise
// it returns what the hook returned.


	/*********************************************************/
	/* Everything beyond this point is PRIVATE! DO NOT USE!! */
	/*********************************************************/

/*
** Quite strange, I know...
** BUT YOU SHOULDN'T CARE!! THIS IS PRIVATE STUFF!! KEEP OUT!!!!! 
**
** (Don't make me regret showing this structure!)
*/

#ifdef LATTICE
struct DoorMsg
{
	struct Message	door_msg;
	ULONG  		(*CmdFuncStd)	(ULONG,ULONG,ULONG,ULONG,ULONG,ULONG,
					ULONG,ULONG,ULONG,ULONG,ULONG,ULONG,ULONG );
	ULONG 	(* __asm CmdFuncAsm)	(register __d0 ULONG,register __d1 ULONG,
					register __d2 ULONG,register __d3 ULONG,
					register __d4 ULONG,register __d5 ULONG,
					register __d6 ULONG,register __d7 ULONG,
					register __a0 ULONG,register __a1 ULONG,
					register __a2 ULONG,register __a3 ULONG,
					register __a4 ULONG );

	ULONG		d1;
	ULONG		d2;
	ULONG		d3;
	ULONG		d4;
	ULONG		d5;
	ULONG		d6;
	ULONG		d7;
	ULONG		d8;
	ULONG		d9;
	ULONG		d10;
	ULONG		d11;
	ULONG		d12;
	ULONG		d13;
	ULONG		retvalue;
	UBYTE		async;
	UBYTE		progress;
	UBYTE		dofree;
	struct Task *	task;
	ULONG		signals;
};
#endif

#define DCMD_CONTINUE 1

#endif