/* Tera Term
 Copyright(C) 1994-1998 T. Teranishi
 All rights reserved. */

/* TERATERM.EXE, Printing routines */
#include "stdafx.h"
#include "teraterm.h"
#include "tttypes.h"
#include <commdlg.h>
#include <stdio.h>

#include "ttwinman.h"
#include "commlib.h"
#include "ttcommon.h"
#include "ttlib.h"

#include "tt_res.h"
#include "prnabort.h"

#include "teraprn.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

static PRINTDLG PrnDlg;

static HDC PrintDC;
static LOGFONT Prnlf;
static HFONT PrnFont[AttrFontMask+1];
static int PrnFW, PrnFH;
static RECT Margin;
static COLORREF White, Black;
static int PrnX, PrnY;
static int PrnDx[256];
static TCharAttr PrnAttr;

static BOOL Printing = FALSE;
static BOOL PrintAbortFlag = FALSE;

/* pass-thru printing */
static char PrnFName[MAX_PATH];
static int HPrnFile = 0;
static char PrnBuff[TermWidthMax];
static int PrnBuffCount = 0;

static CPrnAbortDlg *PrnAbortDlg;
static HWND HPrnAbortDlg;

/* Print Abortion Call Back Function */
BOOL CALLBACK PrnAbortProc(HDC PDC, int Code)
{
	MSG m;

	while ((! PrintAbortFlag) && PeekMessage(&m, 0,0,0, PM_REMOVE))
		if ((HPrnAbortDlg==NULL) || (! IsDialogMessage(HPrnAbortDlg, &m))) {
			TranslateMessage(&m);
			DispatchMessage(&m);
		}

	if (PrintAbortFlag) {
		HPrnAbortDlg = NULL;
		PrnAbortDlg = NULL;
		return FALSE;
	}
	else {
		return TRUE;
	}
}

extern "C" {
HDC PrnBox(HWND HWin, PBOOL Sel)
{
	/* initialize PrnDlg record */
	memset(&PrnDlg, 0, sizeof(PRINTDLG));
	PrnDlg.lStructSize = sizeof(PRINTDLG);
	PrnDlg.hwndOwner = HWin;
	PrnDlg.Flags = PD_RETURNDC | PD_NOPAGENUMS | PD_SHOWHELP;
	if (! *Sel) {
		PrnDlg.Flags = PrnDlg.Flags | PD_NOSELECTION;	/* when there is nothing select, gray out the "Selection" radio button */
	} else {
		PrnDlg.Flags = PrnDlg.Flags | PD_SELECTION;	/* when there is something select, select the "Selection" radio button by default */
	}
	PrnDlg.nCopies = 1;

	/* 'Print' dialog box */
	if (! PrintDlg(&PrnDlg)) {
		return NULL; /* if 'Cancel' button clicked, exit */
	}
	if (PrnDlg.hDC == NULL) {
		return NULL;
	}
	PrintDC = PrnDlg.hDC;
	*Sel = (PrnDlg.Flags & PD_SELECTION) != 0;
	return PrintDC;
}
}

extern "C" {
BOOL PrnStart(LPSTR DocumentName)
{
	DOCINFO Doc;
	char DocName[50];
	CWnd* pParent;
	char uimsg[MAX_UIMSG];

	Printing = FALSE;
	PrintAbortFlag = FALSE;

	PrnAbortDlg = new CPrnAbortDlg();
	if (PrnAbortDlg==NULL) {
		return FALSE;
	}
	if (ActiveWin==IdVT) {
		pParent = (CWnd*)pVTWin;
	}
	else {
		pParent = (CWnd*)pTEKWin;
	}
	PrnAbortDlg->Create(pParent,&PrintAbortFlag,&ts);
	HPrnAbortDlg = PrnAbortDlg->GetSafeHwnd();

	GetDlgItemText(HPrnAbortDlg, IDC_PRNABORT_PRINTING, uimsg, sizeof(uimsg));
	get_lang_msg("DLG_PRNABORT_PRINTING", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
	SetDlgItemText(HPrnAbortDlg, IDC_PRNABORT_PRINTING, ts.UIMsg);
	GetDlgItemText(HPrnAbortDlg, IDCANCEL, uimsg, sizeof(uimsg));
	get_lang_msg("BTN_CANCEL", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile);
	SetDlgItemText(HPrnAbortDlg, IDCANCEL, ts.UIMsg);

	SetAbortProc(PrintDC,PrnAbortProc);

	Doc.cbSize = sizeof(DOCINFO);
	strncpy_s(DocName,sizeof(DocName),DocumentName,_TRUNCATE);
	Doc.lpszDocName = DocName;
	Doc.lpszOutput = NULL;
	Doc.lpszDatatype = NULL;
	Doc.fwType = 0;
	if (StartDoc(PrintDC, &Doc) > 0) {
		Printing = TRUE;
	}
	else {
		if (PrnAbortDlg != NULL) {
			PrnAbortDlg->DestroyWindow();
			PrnAbortDlg = NULL;
			HPrnAbortDlg = NULL;
		}
	}
	return Printing;
}
}

extern "C" {
void PrnStop()
{
	if (Printing) {
		EndDoc(PrintDC);
		DeleteDC(PrintDC);
		Printing = FALSE;
	}
	if (PrnAbortDlg != NULL) {
		PrnAbortDlg->DestroyWindow();
		PrnAbortDlg = NULL;
		HPrnAbortDlg = NULL;
	}
}
}

extern "C" {
int VTPrintInit(int PrnFlag)
// Initialize printing of VT window
//   PrnFlag: specifies object to be printed
//	= IdPrnScreen		Current screen
//	= IdPrnSelectedText	Selected text
//	= IdPrnScrollRegion	Scroll region
//	= IdPrnFile		Spooled file (printer sequence)
//   Return: print object ID specified by user
//	= IdPrnCancel		(user clicks "Cancel" button)
//	= IdPrnScreen		(user don't select "print selection" option)
//	= IdPrnSelectedText	(user selects "print selection")
//	= IdPrnScrollRegion	(always when PrnFlag=IdPrnScrollRegion)
//	= IdPrnFile		(always when PrnFlag=IdPrnFile)
{	
	BOOL Sel;
	TEXTMETRIC Metrics;
	POINT PPI, PPI2;
	HDC DC;
	int i;
	TCharAttr TempAttr = {
		AttrDefault,
		AttrDefault,
		AttrDefaultFG,
		AttrDefaultBG
	};

	Sel = (PrnFlag & IdPrnSelectedText)!=0;
	if (PrnBox(HVTWin,&Sel)==NULL) {
		return (IdPrnCancel);
	}

	if (PrintDC==0) {
		return (IdPrnCancel);
	}

	/* start printing */
	if (! PrnStart(ts.Title)) {
		return (IdPrnCancel);
	}

	/* initialization */
	StartPage(PrintDC);

	/* pixels per inch */
	if ((ts.VTPPI.x>0) && (ts.VTPPI.y>0)) {
		PPI = ts.VTPPI;
	}
	else {
		PPI.x = GetDeviceCaps(PrintDC,LOGPIXELSX);
		PPI.y = GetDeviceCaps(PrintDC,LOGPIXELSY);
	}

	/* left margin */
	Margin.left = (int)((float)ts.PrnMargin[0] / 100.0 * (float)PPI.x);
	/* right margin */
	Margin.right = GetDeviceCaps(PrintDC,HORZRES) -
	               (int)((float)ts.PrnMargin[1] / 100.0 * (float)PPI.x);
	/* top margin */
	Margin.top = (int)((float)ts.PrnMargin[2] / 100.0 * (float)PPI.y);
	/* bottom margin */
	Margin.bottom =  GetDeviceCaps(PrintDC,VERTRES) -
	                 (int)((float)ts.PrnMargin[3] / 100.0 * (float)PPI.y);

	/* create test font */
	memset(&Prnlf, 0, sizeof(LOGFONT));

	if (ts.PrnFont[0]==0) {
		Prnlf.lfHeight = ts.VTFontSize.y;
		Prnlf.lfWidth = ts.VTFontSize.x;
		Prnlf.lfCharSet = ts.VTFontCharSet;
		strncpy_s(Prnlf.lfFaceName, sizeof(Prnlf.lfFaceName), ts.VTFont, _TRUNCATE);
	}
	else {
		Prnlf.lfHeight = ts.PrnFontSize.y;
		Prnlf.lfWidth = ts.PrnFontSize.x;
		Prnlf.lfCharSet = ts.PrnFontCharSet;
		strncpy_s(Prnlf.lfFaceName, sizeof(Prnlf.lfFaceName), ts.PrnFont, _TRUNCATE);
	}
	Prnlf.lfWeight = FW_NORMAL;
	Prnlf.lfItalic = 0;
	Prnlf.lfUnderline = 0;
	Prnlf.lfStrikeOut = 0;
	Prnlf.lfOutPrecision = OUT_CHARACTER_PRECIS;
	Prnlf.lfClipPrecision = CLIP_CHARACTER_PRECIS;
	Prnlf.lfQuality = DEFAULT_QUALITY;
	Prnlf.lfPitchAndFamily = FIXED_PITCH | FF_DONTCARE;

	PrnFont[0] = CreateFontIndirect(&Prnlf);

	DC = GetDC(HVTWin);
	SelectObject(DC, PrnFont[0]);
	GetTextMetrics(DC, &Metrics);
	PPI2.x = GetDeviceCaps(DC,LOGPIXELSX);
	PPI2.y = GetDeviceCaps(DC,LOGPIXELSY);
	ReleaseDC(HVTWin,DC);
	DeleteObject(PrnFont[0]); /* Delete test font */

	/* Adjust font size */
	Prnlf.lfHeight = (int)((float)Metrics.tmHeight * (float)PPI.y / (float)PPI2.y);
	Prnlf.lfWidth = (int)((float)Metrics.tmAveCharWidth * (float)PPI.x / (float)PPI2.x);

	/* Create New Fonts */

	/* Normal Font */
	Prnlf.lfWeight = FW_NORMAL;
	Prnlf.lfUnderline = 0;
	PrnFont[0] = CreateFontIndirect(&Prnlf);
	SelectObject(PrintDC,PrnFont[0]);
	GetTextMetrics(PrintDC, &Metrics);
	PrnFW = Metrics.tmAveCharWidth;
	PrnFH = Metrics.tmHeight;
	/* Under line */
	Prnlf.lfUnderline = 1;
	PrnFont[AttrUnder] = CreateFontIndirect(&Prnlf);

	if (ts.FontFlag & FF_BOLD) {
		/* Bold */
		Prnlf.lfUnderline = 0;
		Prnlf.lfWeight = FW_BOLD;
		PrnFont[AttrBold] = CreateFontIndirect(&Prnlf);
		/* Bold + Underline */
		Prnlf.lfUnderline = 1;
		PrnFont[AttrBold | AttrUnder] = CreateFontIndirect(&Prnlf);
	}
	else {
		PrnFont[AttrBold] = PrnFont[AttrDefault];
		PrnFont[AttrBold | AttrUnder] = PrnFont[AttrUnder];
	}
	/* Special font */
	Prnlf.lfWeight = FW_NORMAL;
	Prnlf.lfUnderline = 0;
	Prnlf.lfWidth = PrnFW; /* adjust width */
	Prnlf.lfHeight = PrnFH;
	Prnlf.lfCharSet = SYMBOL_CHARSET;

	strncpy_s(Prnlf.lfFaceName, sizeof(Prnlf.lfFaceName),"Tera Special", _TRUNCATE);
	PrnFont[AttrSpecial] = CreateFontIndirect(&Prnlf);
	PrnFont[AttrSpecial | AttrBold] = PrnFont[AttrSpecial];
	PrnFont[AttrSpecial | AttrUnder] = PrnFont[AttrSpecial];
	PrnFont[AttrSpecial | AttrBold | AttrUnder] = PrnFont[AttrSpecial];

	Black = RGB(0,0,0);
	White = RGB(255,255,255);
	for (i = 0 ; i <= 255 ; i++) {
		PrnDx[i] = PrnFW;
	}
	PrnSetAttr(TempAttr);

	PrnY = Margin.top;
	PrnX = Margin.left;

	if (PrnFlag == IdPrnScrollRegion) {
		return (IdPrnScrollRegion);
	}
	if (PrnFlag == IdPrnFile) {
		return (IdPrnFile);
	}
	if (Sel) {
		return (IdPrnSelectedText);
	}
	else {
		return (IdPrnScreen);
	}
}
}
extern "C" {
void PrnSetAttr(TCharAttr Attr)
//  Set text attribute of printing
//
{
	PrnAttr = Attr;
	SelectObject(PrintDC, PrnFont[Attr.Attr & AttrFontMask]);

	if ((Attr.Attr & AttrReverse) != 0) {
		SetTextColor(PrintDC,White);
		SetBkColor(  PrintDC,Black);
	}
	else {
		SetTextColor(PrintDC,Black);
		SetBkColor(  PrintDC,White);
	}
}
}

extern "C" {
void PrnOutText(PCHAR Buff, int Count)
//  Print out text
//    Buff: points text buffer
//    Count: number of characters to be printed
{
	int i;
	RECT RText;
	PCHAR Ptr, Ptr1, Ptr2;
	char Buff2[256];

	if (Count<=0) {
		return;
	}
	if (Count>(sizeof(Buff2)-1)) {
		Count=sizeof(Buff2)-1;
	}
	memcpy(Buff2,Buff,Count);
	Buff2[Count] = 0;
	Ptr = Buff2;

	if (ts.Language==IdRussian) {
		if (ts.PrnFont[0]==0) {
			RussConvStr(ts.RussClient,ts.RussFont,Buff2,Count);
		}
		else {
			RussConvStr(ts.RussClient,ts.RussPrint,Buff2,Count);
		}
	}

	do {
		if (PrnX+PrnFW > Margin.right) {
			/* new line */
			PrnX = Margin.left;
			PrnY = PrnY + PrnFH;
		}
		if (PrnY+PrnFH > Margin.bottom) {
			/* next page */
			EndPage(PrintDC);
			StartPage(PrintDC);
			PrnSetAttr(PrnAttr);
			PrnY = Margin.top;
		}

		i = (Margin.right-PrnX) / PrnFW;
		if (i==0) {
			i=1;
		}
		if (i>Count) {
			i=Count;
		}

		if (i<Count) {
			Ptr2 = Ptr;
			do {
				Ptr1 = Ptr2;
				Ptr2 = CharNext(Ptr1);
			} while ((Ptr2!=NULL) && ((Ptr2-Ptr)<=i));
			i = Ptr1-Ptr;
			if (i<=0) {
				i=1;
			}
		}

		RText.left = PrnX;
		RText.right = PrnX + i*PrnFW;
		RText.top = PrnY;
		RText.bottom = PrnY+PrnFH;
		ExtTextOut(PrintDC,PrnX,PrnY,6,&RText,Ptr,i,&PrnDx[0]);
		PrnX = RText.right;
		Count=Count-i;
		Ptr = Ptr + i;
	} while (Count>0);

}
}

extern "C" {
void PrnNewLine()
//  Moves to the next line in printing
{
	PrnX = Margin.left;
	PrnY = PrnY + PrnFH;
}
}

extern "C" {
void VTPrintEnd()
{
	int i, j;

	EndPage(PrintDC);

	for (i = 0 ; i <= AttrFontMask ; i++) {
		for (j = i+1 ; j <= AttrFontMask ; j++) {
			if (PrnFont[j]==PrnFont[i]) {
				PrnFont[j] = NULL;
			}
		}
		if (PrnFont[i] != NULL) {
			DeleteObject(PrnFont[i]);
		}
	}

	PrnStop();
	return;
}
}

/* printer emulation routines */
extern "C" {
void OpenPrnFile()
{
	char Temp[MAX_PATH];

	KillTimer(HVTWin,IdPrnStartTimer);
	if (HPrnFile > 0) {
		return;
	}
	if (PrnFName[0] == 0) {
		GetTempPath(sizeof(Temp),Temp);
		if (GetTempFileName(Temp,"tmp",0,PrnFName)==0) {
			return;
		}
		HPrnFile = _lcreat(PrnFName,0);
	}
	else {
		HPrnFile = _lopen(PrnFName,OF_WRITE);
		if (HPrnFile <= 0) {
			HPrnFile = _lcreat(PrnFName,0);
		}
	}
	if (HPrnFile > 0) {
		_llseek(HPrnFile,0,2);
	}
}
}

void PrintFile()
{
	char Buff[256];
	BOOL CRFlag = FALSE;
	int c, i;
	BYTE b;

	if (VTPrintInit(IdPrnFile)==IdPrnFile) {
		HPrnFile = _lopen(PrnFName,OF_READ);
		if (HPrnFile>0) {
			do {
				i = 0;
				do {
					c = _lread(HPrnFile,&b,1);
					if (c==1) {
						switch (b) {
							case HT:
								memset(&(Buff[i]),0x20,8);
								i = i + 8;
								CRFlag = FALSE;
								break;
							case LF:
								CRFlag = ! CRFlag;
								break;
							case FF:
							case CR:
								CRFlag = TRUE;
								break;
							default:
								if (b >= 0x20) {
									Buff[i] = b;
									i++;
								}
								CRFlag = FALSE;
								break;
						}
					}
					if (i>=(sizeof(Buff)-7)) {
						CRFlag=TRUE;
					}
				} while ((c>0) && (! CRFlag));
				if (i>0) {
					PrnOutText(Buff, i);
				}
				if (CRFlag) {
					PrnX = Margin.left;
					if ((b==FF) && (ts.PrnConvFF==0)) { // new page
						PrnY = Margin.bottom;
					}
					else { // new line
						PrnY = PrnY + PrnFH;
					}
				}
				CRFlag = (b==CR);
			} while (c>0);
			_lclose(HPrnFile);
		}
		HPrnFile = 0;
		VTPrintEnd();
	}
	remove(PrnFName);
	PrnFName[0] = 0;
}

void PrintFileDirect()
{
	CWnd* pParent;

	PrnAbortDlg = new CPrnAbortDlg();
	if (PrnAbortDlg==NULL) {
		remove(PrnFName);
		PrnFName[0] = 0;
		return;
	}
	if (ActiveWin==IdVT) {
		pParent = (CWnd*)pVTWin;
	}
	else {
		pParent = (CWnd*)pTEKWin;
	}
	PrnAbortDlg->Create(pParent,&PrintAbortFlag,&ts);
	HPrnAbortDlg = PrnAbortDlg->GetSafeHwnd();

	HPrnFile = _lopen(PrnFName,OF_READ);
	PrintAbortFlag = (HPrnFile<=HFILE_ERROR) || ! PrnOpen(ts.PrnDev);
	PrnBuffCount = 0;
	SetTimer(HVTWin,IdPrnProcTimer,0,NULL);
}

void PrnFileDirectProc()
{
	int c;

	if (HPrnFile==0) {
		return;
	}
	if (PrintAbortFlag) {
		HPrnAbortDlg = NULL;
		PrnAbortDlg = NULL;
		PrnCancel();
	}
	if (!PrintAbortFlag && (HPrnFile>0)) {
		do {
			if (PrnBuffCount==0) {
				PrnBuffCount = _lread(HPrnFile,PrnBuff,1);
				if (ts.Language==IdRussian) {
					RussConvStr(ts.RussClient,ts.RussPrint,PrnBuff,PrnBuffCount);
				}
			}

			if (PrnBuffCount==1) {
				c = PrnWrite(PrnBuff,1);
				if (c==0) {
					SetTimer(HVTWin,IdPrnProcTimer,10,NULL);
					return;
				}
				PrnBuffCount = 0;
			}
			else {
				c = 0;
			}
		} while (c>0);
	}
	if (HPrnFile > 0) {
		_lclose(HPrnFile);
	}
	HPrnFile = 0;
	PrnClose();
	remove(PrnFName);
	PrnFName[0] = 0;
	if (PrnAbortDlg!=NULL) {
		PrnAbortDlg->DestroyWindow();
		PrnAbortDlg = NULL;
		HPrnAbortDlg = NULL;
	}
}

void PrnFileStart()
{
	if (HPrnFile>0) {
		return;
	}
	if (PrnFName[0]==0) {
		return;
	}
	if (ts.PrnDev[0]!=0) {
		PrintFileDirect(); // send file directry to printer port
	}
	else { // print file by using Windows API
		PrintFile();
	}
}

extern "C" {
void ClosePrnFile()
{
	PrnBuffCount = 0;
	if (HPrnFile > 0) {
		_lclose(HPrnFile);
	}
	HPrnFile = 0;
	SetTimer(HVTWin,IdPrnStartTimer,ts.PassThruDelay*1000,NULL);
}
}

extern "C" {
void WriteToPrnFile(BYTE b, BOOL Write)
//  (b,Write) =
//    (0,FALSE): clear buffer
//    (0,TRUE):  write buffer to file
//    (b,FALSE): put b in buff
//    (b,TRUE):  put b in buff and
//		 write buffer to file
{
	if ((b>0) && (PrnBuffCount<sizeof(PrnBuff))) {
		PrnBuff[PrnBuffCount++] = b;
	}

	if (Write) {
		_lwrite(HPrnFile,PrnBuff,PrnBuffCount);
		PrnBuffCount = 0;
	}
	if ((b==0) && ! Write) {
		PrnBuffCount = 0;
	}
}
}
