/*
**	termCapture.c
**
**	File and printer capture support routines
**
**	Copyright © 1990-1995 by Olaf `Olsen' Barthel
**		All Rights Reserved
*/

#include "termGlobal.h"

STATIC VOID __regargs
CaptureCallback1(register APTR Buffer,register LONG Size)
{
	AddLine(Buffer,Size);

	CaptureToFile(Buffer,Size);
	CaptureToFile("\n",1);
}

STATIC VOID __regargs
CaptureCallback3(register APTR Buffer,register LONG Size)
{
	AddLine(Buffer,Size);

	CaptureToFile(Buffer,Size);
	CaptureToFile("\n",1);

	CaptureToPrinter(Buffer,Size);
	CaptureToPrinter("\n",1);
}

STATIC VOID __regargs
CaptureCallback4(register APTR Buffer,register LONG Size)
{
	CaptureToFile(Buffer,Size);
	CaptureToFile("\n",1);
}

STATIC VOID __regargs
CaptureCallback5(register APTR Buffer,register LONG Size)
{
	CaptureToFile(Buffer,Size);
	CaptureToFile("\n",1);

	CaptureToPrinter(Buffer,Size);
	CaptureToPrinter("\n",1);
}

STATIC VOID __regargs
CaptureCallback6(register APTR Buffer,register LONG Size)
{
	CaptureToPrinter(Buffer,Size);
	CaptureToPrinter("\n",1);
}

STATIC VOID __regargs
CaptureCallback7(register APTR Buffer,register LONG Size)
{
	AddLine(Buffer,Size);

	CaptureToPrinter(Buffer,Size);
	CaptureToPrinter("\n",1);
}

VOID __regargs
CaptureFilteredTo_Buffer(register APTR Buffer,register LONG Size)
{
	CaptureParser(Buffer,Size,AddLine);
}

VOID __regargs
CaptureFilteredTo_Buffer_File(register APTR Buffer,register LONG Size)
{
	CaptureParser(Buffer,Size,CaptureCallback1);
}

VOID __regargs
CaptureFilteredTo_Buffer_File_Printer(register APTR Buffer,register LONG Size)
{
	CaptureParser(Buffer,Size,CaptureCallback3);
}

VOID __regargs
CaptureFilteredTo_File(register APTR Buffer,register LONG Size)
{
	CaptureParser(Buffer,Size,CaptureCallback4);
}

VOID __regargs
CaptureFilteredTo_File_Printer(register APTR Buffer,register LONG Size)
{
	CaptureParser(Buffer,Size,CaptureCallback5);
}

VOID __regargs
CaptureFilteredTo_Printer(register APTR Buffer,register LONG Size)
{
	CaptureParser(Buffer,Size,CaptureCallback6);
}

VOID __regargs
CaptureFilteredTo_Buffer_Printer(register APTR Buffer,register LONG Size)
{
	CaptureParser(Buffer,Size,CaptureCallback7);
}

VOID __regargs
CaptureRawTo_Buffer(register APTR Buffer,register LONG Size)
{
	CaptureParser(Buffer,Size,AddLine);
}

VOID __regargs
CaptureRawTo_Buffer_File(register APTR Buffer,register LONG Size)
{
	CaptureParser(Buffer,Size,AddLine);

	CaptureToFile(Buffer,Size);
}

VOID __regargs
CaptureRawTo_Buffer_File_Printer(register APTR Buffer,register LONG Size)
{
	CaptureParser(Buffer,Size,AddLine);

	CaptureToFile(Buffer,Size);
	CaptureToPrinter(Buffer,Size);
}

VOID __regargs
CaptureRawTo_Buffer_Printer(register APTR Buffer,register LONG Size)
{
	CaptureParser(Buffer,Size,AddLine);

	CaptureToPrinter(Buffer,Size);
}

VOID __regargs
CaptureRawTo_File(register APTR Buffer,register LONG Size)
{
	CaptureToFile(Buffer,Size);
}

VOID __regargs
CaptureRawTo_File_Printer(register APTR Buffer,register LONG Size)
{
	CaptureToFile(Buffer,Size);
	CaptureToPrinter(Buffer,Size);
}

VOID __regargs
CaptureRawTo_Printer(register APTR Buffer,register LONG Size)
{
	CaptureToPrinter(Buffer,Size);
}

	/* ClosePrinterCapture(BYTE Force):
	 *
	 *	Closes printer capture file.
	 */

VOID __regargs
ClosePrinterCapture(BYTE Force)
{
	if(PrinterCapture)
	{
		if(ControllerActive && StandardPrinterCapture && !Force)
			FPrintf(PrinterCapture,LocaleString(MSG_CONSOLE_TERMINAL_TRANSCRIPT_ENDING_TXT));

		if(Force)
		{
			Close(PrinterCapture);

			CheckItem(MEN_CAPTURE_TO_PRINTER,FALSE);

			PrinterCapture = NULL;

			ConOutputUpdate();

			StandardPrinterCapture = FALSE;
		}
	}

	ControllerActive = FALSE;

	ConOutputUpdate();
}

	/* OpenPrinterCapture(BYTE Controller):
	 *
	 *	Opens printer capture file.
	 */

BYTE __regargs
OpenPrinterCapture(BYTE Controller)
{
	if(PrinterCapture)
	{
		if(Controller && !ControllerActive)
		{
			ControllerActive = TRUE;

			ConOutputUpdate();

			FPrintf(PrinterCapture,LocaleString(MSG_CONSOLE_TERMINAL_TRANSCRIPT_FOLLOWS_TXT));
		}

		return(TRUE);
	}
	else
	{
		if(PrinterCapture = Open("PRT:",MODE_NEWFILE))
			CheckItem(MEN_CAPTURE_TO_PRINTER,TRUE);
		else
		{
			CheckItem(MEN_CAPTURE_TO_PRINTER,FALSE);

			BlockWindows();

			MyEasyRequest(Window,LocaleString(MSG_TERMMAIN_ERROR_OPENING_PRINTER_TXT),LocaleString(MSG_GLOBAL_CONTINUE_TXT),"PRT:");

			ReleaseWindows();
		}

		if(Controller)
		{
			ControllerActive	= TRUE;
			StandardPrinterCapture	= FALSE;
		}
		else
		{
			StandardPrinterCapture = FALSE;

			if(ControllerActive)
				FPrintf(PrinterCapture,LocaleString(MSG_CONSOLE_USER_TERMINAL_TRANSCRIPT_FOLLOWS_TXT));
		}

		ConOutputUpdate();

		if(PrinterCapture)
			return(TRUE);
		else
			return(FALSE);
	}
}

	/* CloseFileCapture():
	 *
	 *	Close the capture file.
	 */

VOID
CloseFileCapture()
{
	if(FileCapture)
	{
		BufferClose(FileCapture);

		FileCapture = NULL;

		if(!GetFileSize(CaptureName))
			DeleteFile(CaptureName);
		else
		{
			AddProtection(CaptureName,FIBF_EXECUTE);

			if(Config -> MiscConfig -> CreateIcons)
				AddIcon(CaptureName,FILETYPE_TEXT,FALSE);
		}
	}

	CheckItem(MEN_CAPTURE_TO_FILE,FALSE);
	CheckItem(MEN_CAPTURE_TO_RAW_FILE,FALSE);

	RawCapture = FALSE;

	ConOutputUpdate();
}

	/* OpenFileCapture():
	 *
	 *	Open a capture file.
	 */

BYTE __regargs
OpenFileCapture(BOOL Raw)
{
	struct FileRequester	*FileRequest;
	UBYTE			 DummyBuffer[MAX_FILENAME_LENGTH],
				*DummyChar;
	BYTE			 Aborted = FALSE;

	CloseFileCapture();

	BlockWindows();

	if(!CaptureName[0])
	{
		strcpy(CaptureName,Config -> CaptureConfig -> CapturePath);

		if(!AddPart(CaptureName,LocaleString(MSG_DIALPANEL_CAPTURE_NAME_TXT),MAX_FILENAME_LENGTH))
			CaptureName[0] = 0;
	}

	strcpy(DummyBuffer,CaptureName);

	DummyChar = PathPart(DummyBuffer);

	*DummyChar = 0;

	if(FileRequest = GetFile(Window,LocaleString(MSG_TERMMAIN_CAPTURE_TO_DISK_TXT),DummyBuffer,FilePart(CaptureName),DummyBuffer,NULL,TRUE,FALSE,FALSE,LocaleString(MSG_GLOBAL_OPEN_TXT),FALSE))
	{
		if(GetFileSize(DummyBuffer))
		{
			switch(MyEasyRequest(Window,LocaleString(MSG_GLOBAL_FILE_ALREADY_EXISTS_TXT),LocaleString(MSG_GLOBAL_CREATE_APPEND_CANCEL_TXT),DummyBuffer))
			{
				case 1:

					FileCapture = BufferOpen(DummyBuffer,"w");
					break;

				case 2:

					FileCapture = BufferOpen(DummyBuffer,"a");
					break;

				case 0:

					FileCapture = NULL;

					Aborted = TRUE;

					break;
			}
		}
		else
			FileCapture = BufferOpen(DummyBuffer,"w");

		if(!Aborted)
		{
			if(!FileCapture)
				ShowError(Window,ERR_SAVE_ERROR,IoErr(),DummyBuffer);
			else
				strcpy(CaptureName,DummyBuffer);
		}

		FreeAslRequest(FileRequest);
	}

	if(Raw)
	{
		if(FileCapture)
			CheckItem(MEN_CAPTURE_TO_RAW_FILE,TRUE);
		else
			CheckItem(MEN_CAPTURE_TO_RAW_FILE,FALSE);

		RawCapture = TRUE;
	}
	else
	{
		if(FileCapture)
			CheckItem(MEN_CAPTURE_TO_FILE,TRUE);
		else
			CheckItem(MEN_CAPTURE_TO_FILE,FALSE);

		RawCapture = FALSE;
	}

	ConOutputUpdate();

	ReleaseWindows();

	if(FileCapture)
		return(TRUE);
	else
		return(FALSE);
}

	/* CaptureToFile(APTR Buffer,LONG Size):
	 *
	 *	Send data to the capture file.
	 */

VOID __regargs
CaptureToFile(APTR Buffer,LONG Size)
{
	if(Size)
	{
		if(BufferWrite(FileCapture,Buffer,Size) != Size)
		{
			BlockWindows();

				/* We had an error writing to the file. */

			switch(MyEasyRequest(NULL,LocaleString(MSG_CONSOLE_ERROR_WRITING_TO_CAPTURE_FILE_TXT),LocaleString(MSG_CONSOLE_IGNORE_DISCARD_CLOSE_TXT),CaptureName))
			{
				case 1:

					BufferClose(FileCapture);

					DeleteFile(CaptureName);

					CheckItem(MEN_CAPTURE_TO_FILE,FALSE);

					FileCapture = NULL;

					ConOutputUpdate();

					break;

				case 2:

					BufferClose(FileCapture);

					CheckItem(MEN_CAPTURE_TO_FILE,FALSE);

					FileCapture = NULL;

					if(!GetFileSize(CaptureName))
						DeleteFile(CaptureName);
					else
					{
						AddProtection(CaptureName,FIBF_EXECUTE);

						if(Config -> MiscConfig -> CreateIcons)
							AddIcon(CaptureName,FILETYPE_TEXT,FALSE);
					}

					ConOutputUpdate();

					break;
			}

			ReleaseWindows();
		}
	}
}

	/* CaptureToPrinter(APTR Buffer,LONG Size):
	 *
	 *	Send capture data to the printer, convert the
	 *	characters as necessary to avoid shocking the
	 *	printer.
	 */

VOID __regargs
CaptureToPrinter(APTR Buffer,LONG Size)
{
	if(!Config -> CaptureConfig -> ConvertChars && Config -> TerminalConfig -> FontMode != FONT_STANDARD)
	{
		UBYTE	 LocalBuffer[BUFFER_LINE_MAX];

		UBYTE	*Src = Buffer,
			*Dst,
			 c;

		ULONG	 Count;

		while(Size > 0)
		{
			Count = MIN(Size,BUFFER_LINE_MAX);

			Size -= Count;

			Dst = LocalBuffer;

			do
			{
				if(c = ISOConversion[*Src++])
					*Dst++ = c;
				else
					*Dst++ = ' ';
			}
			while(--Count > 0);

			Count = (ULONG)Dst - (ULONG)&LocalBuffer[0];

			while(Count > 0 && LocalBuffer[Count - 1] == ' ')
				Count--;

			if(Count > 0)
			{
				if(FWrite(PrinterCapture,LocalBuffer,Count,1) != 1)
				{
					BlockWindows();

					if(!MyEasyRequest(Window,LocaleString(MSG_CONSOLE_ERROR_WRITING_TO_PRINTER_TXT),LocaleString(MSG_CONSOLE_IGNORE_CLOSE_PRINTER_TXT)))
					{
						Close(PrinterCapture);

						CheckItem(MEN_CAPTURE_TO_PRINTER,FALSE);

						PrinterCapture = NULL;

						ConOutputUpdate();

						Size = 0;
					}

					ReleaseWindows();
				}
			}
		}
	}
	else
	{
		if(Size > 0)
		{
				/* Send the buffer to the printer. */

			if(FWrite(PrinterCapture,Buffer,Size,1) != 1)
			{
				BlockWindows();

				if(!MyEasyRequest(Window,LocaleString(MSG_CONSOLE_ERROR_WRITING_TO_PRINTER_TXT),LocaleString(MSG_CONSOLE_IGNORE_CLOSE_PRINTER_TXT)))
				{
					Close(PrinterCapture);

					CheckItem(MEN_CAPTURE_TO_PRINTER,FALSE);

					PrinterCapture = NULL;

					ConOutputUpdate();
				}

				ReleaseWindows();
			}
		}
	}
}