Initial commit

1 files changed, 602 insertions, 0 deletions

diff --git a/Linux_C_12/cprinter_121.c b/Linux_C_12/cprinter_121.c
new file mode 100644
index 0000000..8e635a3
--- /dev/null
+++ b/Linux_C_12/cprinter_121.c
@@ -0,0 +1,602 @@
+/********************************************************************************************

+	Clean OS Windows library module version 1.2.1.

+	This module is part of the Clean Object I/O library and Clean 0.8 I/O library

+	for the Windows platform.

+********************************************************************************************/

+

+/********************************************************************************************

+	About this module:

+	Routines related to printing.

+********************************************************************************************/

+

+#include "util_121.h"

+#include "cpicture_121.h"

+

+#include "cprinter_121.h"

+

+BOOL	bUserAbort;

+int		semaphor=0;

+

+#if 0

+HWND	hDlgPrint;

+HWND	hwndButton,hwndText;

+

+extern HWND   ghMainWindow;

+extern HINSTANCE ghInst;

+#else

+#define CALLBACK

+#define APIENTRY

+typedef void* HANDLE;

+typedef void* HWND;

+typedef void* DEVMODE;

+typedef void* PRINTDLG;

+typedef void** LPHANDLE;

+typedef char* LPCTSTR;

+#endif

+

+

+#define tachtig 80

+void getDevmodeSizeC(int *size, HANDLE *phPrinter,

+					 char **device, char **driver,  char **output)

+{

+#if 0

+	char	szPrinter[80];

+	char	*szDevice, *szDriver, *szOutput;

+

+	GetProfileString("windows", "device", ",,,", szPrinter, 80);

+	szDevice = strtok(szPrinter,",");

+	szDriver = strtok(NULL,", ");

+	szOutput = strtok(NULL,", ");

+	*device	= g_strdup(szDevice);

+	*driver	= g_strdup(szDriver);

+	*output	= g_strdup(szOutput);

+	if (*szDevice=='\0' || *szDriver=='\0' || *szOutput=='\0')

+	{

+		*size	= 0;

+		return;

+	};

+	OpenPrinter(szDevice,phPrinter,NULL);

+	*size = DocumentProperties(NULL,*phPrinter,szDevice,NULL,NULL,0);

+#endif

+}

+

+void getDefaultDevmodeC(char *printSetup, LPHANDLE phPrinter,  char **device)

+{

+#if 0

+	int		size,r1;

+

+	size		= ((int*)printSetup)[0];

+	printSetup	+=4;

+	r1 = DocumentProperties(NULL,phPrinter,((char*)device)+4,

+							(DEVMODE*)printSetup,NULL,DM_OUT_BUFFER);

+	ClosePrinter(phPrinter);

+#endif

+}

+

+#if 0

+static HDC myCreateIC(LPCTSTR driver, LPCTSTR device, DEVMODE *devmode)

+{

+	HDC	icPrint;

+

+	icPrint	= CreateIC(driver,device,NULL,devmode);

+	if (!icPrint)

+		icPrint	= CreateIC(driver,device,NULL,devmode);

+		/* try once again. Adobe printer drivers sometimes need to be told everything twice */

+	return icPrint;

+}

+#endif

+

+#define GetDeviceCapsWithDefault(icPrint, index, defaullt) (icPrint ? GetDeviceCaps(icPrint, index) : defaullt)

+

+void os_getpagedimensionsC(	DEVMODE *devmode, char *device, char *driver,

+							int emulateScreenRes,

+							int *maxX, int *maxY,

+							int *leftPaper, int *topPaper,

+							int *rightPaper, int *bottomPaper,

+							int	*xRes, int *yRes

+						  )

+{

+#if 0

+	HDC	icPrint;

+	int horPaperPixels, verPaperPixels,

+		xResolution,yResolution,

+		scNX, scNY, scDX, scDY;

+

+

+	icPrint	= myCreateIC(driver,device, devmode);

+

+	xResolution = GetDeviceCapsWithDefault(icPrint, LOGPIXELSX, 300);

+	yResolution = GetDeviceCapsWithDefault(icPrint, LOGPIXELSY, 300);

+	if (emulateScreenRes)						/* for emulation of the screen resolution */

+		{

+            scNX = WinGetHorzResolution();		/* all the deviceCaps will be scaled */

+			scNY = WinGetVertResolution();

+			scDX = xResolution;

+			scDY = yResolution;

+		}

+	  else

+		{	scNX = 1; scNY = 1; scDX = 1; scDY = 1;	};

+

+	horPaperPixels	= (GetDeviceCapsWithDefault(icPrint, PHYSICALWIDTH, 2246)*scNX)/scDX;

+	verPaperPixels	= (GetDeviceCapsWithDefault(icPrint, PHYSICALHEIGHT, 3250)*scNY)/scDY;

+

+	*maxX			= (GetDeviceCapsWithDefault(icPrint, HORZRES, 2241)*scNX)/scDX;

+	*maxY			= (GetDeviceCapsWithDefault(icPrint, VERTRES, 3254)*scNY)/scDY;

+

+    *leftPaper		= (-GetDeviceCapsWithDefault(icPrint, PHYSICALOFFSETX, 116)*scNX)/scDX;

+	*topPaper		= (-GetDeviceCapsWithDefault(icPrint, PHYSICALOFFSETY, 129)*scNY)/scDY;

+	*rightPaper		= horPaperPixels - *leftPaper;

+	*bottomPaper	= verPaperPixels - *topPaper;

+

+	if (emulateScreenRes)

+		{	*xRes = scNX;	*yRes = scNY; }

+	  else

+		{	*xRes = xResolution ;	*yRes = yResolution; };

+	DeleteDC(icPrint);

+#endif

+}

+

+static HANDLE setupDevnames(int deviceLength,int driverLength,int outputLength,

+							char *device,char *driver,char *output)

+{

+	HANDLE		hDevnames;

+#if 0

+	DEVNAMES	*pDevnames;

+	hDevnames	= (HANDLE) LocalAlloc(LMEM_MOVEABLE, 16+deviceLength+driverLength+outputLength);

+	pDevnames	= LocalLock(hDevnames);

+	pDevnames->wDriverOffset	= 16;

+	pDevnames->wDeviceOffset	= 16+driverLength;

+	pDevnames->wOutputOffset	= 16+driverLength+deviceLength;

+	pDevnames->wDefault			= 0;

+	strcpy(((char*)pDevnames)+pDevnames->wDriverOffset, driver);

+	strcpy(((char*)pDevnames)+pDevnames->wDeviceOffset, device);

+	strcpy(((char*)pDevnames)+pDevnames->wOutputOffset, output);

+	LocalUnlock(hDevnames);

+#endif

+	return hDevnames;

+}

+

+static HANDLE setupDevmode(int size, char *pData)

+{

+	HANDLE	hDevmode;

+#if 0

+	DEVMODE	*pDevmode;

+

+	hDevmode	= (HANDLE) LocalAlloc(LMEM_MOVEABLE, size);

+	pDevmode	= LocalLock(hDevmode);

+	memcpy((char*)pDevmode, pData, size);

+	LocalUnlock(hDevmode);

+#endif

+	return hDevmode;

+}

+

+void get_printSetup_with_PRINTDLG(PRINTDLG *pd, char **o_devmode,

+						char **o_device, char **o_driver, char **o_output)

+{

+#if 0

+	char		*newDriver, *newDevice, *newOutput;

+	DEVMODE		*pDevmode;

+	DEVNAMES	*pDevnames;

+

+	pDevmode	= LocalLock(pd->hDevMode);

+	*o_devmode	= g_strdup(pDevmode->dmDeviceName);

+	LocalUnlock(pd->hDevMode);

+	pDevnames	= LocalLock(pd->hDevNames);

+	newDriver	= ((char*)pDevnames)+(pDevnames->wDriverOffset);

+	newDevice	= ((char*)pDevnames)+(pDevnames->wDeviceOffset);

+	newOutput	= ((char*)pDevnames)+(pDevnames->wOutputOffset);

+	*o_driver	= g_strdup(newDriver);

+	*o_device	= g_strdup(newDevice);

+	*o_output	= g_strdup(newOutput);

+	LocalUnlock(pd->hDevNames);

+#endif

+}

+

+/*	PA: called in Clean. */

+int release_memory_handles(PRINTDLG *pd, int os) {

+#if 0

+	LocalFree(pd->hDevNames);

+	LocalFree(pd->hDevMode);

+#endif

+	return os;

+	}

+

+/*

+ * This function hooks the Print dialog. It's purpose is to set the dialog in

+ * the foreground.

+ */

+static UINT APIENTRY DialogToFrontHook(HWND hdl, UINT msg, WPARAM wParam, LPARAM lParam)

+{

+#if 0

+     if (msg==WM_INITDIALOG)

+		{ SetForegroundWindow(hdl);

+		};

+#endif

+	 return FALSE;

+}

+

+void printSetup(int calledFromCleanThread, int devmodeSize,

+			   char *devmode, char *device, char *driver, char *output,

+			   int *ok, PRINTDLG **pdPtr)

+{

+#if 0

+  	int			deviceLength, driverLength, outputLength;

+	HANDLE		hDevnames,hDevmode;

+	static PRINTDLG	pd;

+

+	/* Set up DEVNAMES structure */

+

+	/*rMessageBox(NULL, MB_APPLMODAL, "in printSetup", ""); */

+	deviceLength	= strlen(device)+1;

+	driverLength	= strlen(driver)+1;

+	outputLength	= strlen(output)+1;

+

+	hDevnames	= setupDevnames(deviceLength,driverLength,outputLength,device,driver,output);

+

+	/* Set up DEVMODE structure */

+	hDevmode	= setupDevmode(devmodeSize,devmode);

+

+	/* Set up print dialog record */

+	pd.lStructSize = sizeof(PRINTDLG);

+	pd.hwndOwner = calledFromCleanThread ? NULL : ghMainWindow;	/* (NULL = desktop) */

+/*	pd.hwndOwner = NULL;	// (NULL = desktop) */

+		/*

+         * The handle must belong to the active thread, otherwise PrintDlg

+         * will crash.  When this function is called from the Clean thread,

+         * ghMainWindow will not belong to the active thread.

+         */

+	pd.hDevMode = hDevmode;

+	pd.hDevNames = hDevnames;

+	pd.hDC = NULL;

+	pd.Flags =	PD_PRINTSETUP | PD_ENABLESETUPHOOK;

+	pd.nFromPage = 1;

+	pd.nToPage = 1;

+	pd.nMinPage = 1;

+	pd.nMaxPage = USHRT_MAX;

+	pd.nCopies = 1;

+	pd.hInstance = NULL;

+	pd.lCustData = 0L;

+	pd.lpfnPrintHook = NULL;

+	pd.lpfnSetupHook =  DialogToFrontHook;

+	pd.lpPrintTemplateName = NULL;

+	pd.lpSetupTemplateName = NULL;

+	pd.hPrintTemplate = NULL;

+	pd.hSetupTemplate = NULL;

+

+	/* Open print dialog */

+	*ok	= PrintDlg(&pd);

+	*pdPtr = &pd;

+

+	if (hDevnames!=pd.hDevNames) LocalFree(hDevnames);

+	if (hDevmode!=pd.hDevMode) LocalFree(hDevmode);

+#endif

+}

+

+

+int startPage(int hdc)

+{

+#if 0

+	/*rMessageBox(NULL, MB_APPLMODAL, "in startPage", ""); */

+	return StartPage((HDC) hdc) > 0;

+#else

+    return 0;

+#endif

+}

+

+int endPage(int hdc)

+{

+#if 0

+	/*rMessageBox(NULL, MB_APPLMODAL, "in endPage", ""); */

+	return EndPage((HDC) hdc) > 0;

+#else

+    return 0;

+#endif

+}

+

+int startDoc(int hdc)

+			/* err code: >0:no error, <=0: user cancelled file dialog */

+{

+#if 0

+	static DOCINFO docInfo = { sizeof (DOCINFO), "Clean", NULL, NULL, 0 } ;

+

+	/*rMessageBox(NULL, MB_APPLMODAL, "in startDoc", "");*/

+	bUserAbort = FALSE ;

+

+	return StartDoc((HDC) hdc, &docInfo);

+#else

+    return 0;

+#endif

+}

+

+void endDoc(int hdc)

+{

+#if 0

+	/*rMessageBox(NULL, MB_APPLMODAL, "in endDoc", ""); */

+	if (bUserAbort)

+		AbortDoc((HDC) hdc);

+	  else

+		EndDoc((HDC) hdc);

+#endif

+}

+

+void deleteDC(int hdc)

+{

+#if 0

+	/*rMessageBox(NULL, MB_APPLMODAL, "in deleteDC", ""); */

+	DeleteDC((HDC) hdc);

+#endif

+}

+

+int wasCanceled(void)

+{

+#if 0

+	/*rMessageBox(NULL, MB_APPLMODAL, "in wasCanceled", ""); */

+	return bUserAbort;

+#else

+    return 0;

+#endif

+}

+

+/* getDC opens the print job dialog and

+ * lets the user change various settings or gets the default printer

+ */

+

+/* c-strings are passed to this function ! */

+void getDC( int doDialog, int emulateScreen, int calledFromCleanThread, int devmodeLength,

+			char *devmode,char *device,char *driver,char *output,

+			int *err,

+			int *first, int *last, int *copies,

+			PRINTDLG	**ppPrintDlg,

+			int *deviceContext

+	 		)

+					/* err code: -1:no error, others: non fatal error */

+{

+#if 0

+	static PRINTDLG pd;

+	HDC hdcPrint;

+	int ok;

+

+	*err = -1;

+

+	if (doDialog)

+	  {	/* Set up print dialog record */

+		HANDLE	hDevnames, hDevmode;

+		int deviceLength,driverLength,outputLength;

+

+		deviceLength	= strlen(device)+1;

+		driverLength	= strlen(driver)+1;

+		outputLength	= strlen(output)+1;

+

+		hDevnames	= setupDevnames(deviceLength,driverLength,outputLength,

+									device,driver,output);

+		hDevmode	= setupDevmode(devmodeLength,devmode);

+

+		pd.lStructSize = sizeof(PRINTDLG);

+		pd.hwndOwner = calledFromCleanThread ? NULL : ghMainWindow;	/* (NULL = desktop) */

+			/*

+             * The handle must belong to the active thread, otherwise PrintDlg

+             * will crash.  When this function is called from the Clean thread,

+             * ghMainWindow will not belong to the active thread.

+             */

+		pd.hDevMode = hDevmode;

+		pd.hDevNames = hDevnames;

+		pd.hDC = NULL;

+		pd.Flags = PD_ALLPAGES | PD_COLLATE | PD_RETURNDC | PD_NOSELECTION

+				 | PD_ENABLEPRINTHOOK;

+		      /* hide some options from print dialog */

+		pd.nFromPage = 1;

+		pd.nToPage = 1;

+		pd.nMinPage = 1;

+		pd.nMaxPage = USHRT_MAX;

+		pd.nCopies = 1;

+		pd.hInstance = NULL;

+		pd.lCustData = 0L;

+		pd.lpfnPrintHook = DialogToFrontHook;

+		pd.lpfnSetupHook = NULL;

+		pd.lpPrintTemplateName = NULL;

+		pd.lpSetupTemplateName = NULL;

+		pd.hPrintTemplate = NULL;

+		pd.hSetupTemplate = NULL;

+

+		/* Open print dialog */

+

+		ok = PrintDlg(&pd);

+

+		if (hDevnames!=pd.hDevNames) LocalFree(hDevnames);

+		if (hDevmode!=pd.hDevMode) LocalFree(hDevmode);

+

+		if (!ok)

+			{

+			*err = CommDlgExtendedError();	/* will return 0 iff user canceled, otherwise positive value */

+			release_memory_handles(&pd, 0);

+			return;

+			}

+

+

+		if (pd.Flags & PD_PAGENUMS)

+			{ *first	= pd.nFromPage;

+			  *last		= pd.nToPage;

+			}

+		  else

+			{ *first	= 1;

+			  *last		= 9999;

+			};

+		*copies			= pd.nCopies;

+		*ppPrintDlg		= &pd;

+		hdcPrint		= pd.hDC;

+	  }

+

+	else

+

+		{

+		hdcPrint = CreateDC(driver, device, output, NULL);

+		if (hdcPrint==NULL)

+		  { *err = 0;	/* non fatal error, iff e.g. no printer driver is installed */

+	 	    return;

+		  };

+		*first	= 1;

+		*last	= 9999;

+		*copies	= 1;

+		*ppPrintDlg		= NULL;

+		};

+

+	if (emulateScreen)

+		{	int pXdpi,pYdpi,sXdpi,sYdpi;

+			pXdpi = GetDeviceCaps(hdcPrint, LOGPIXELSX);

+			pYdpi = GetDeviceCaps(hdcPrint, LOGPIXELSY);

+			sXdpi = WinGetHorzResolution();

+			sYdpi = WinGetVertResolution();

+			SetMapMode(hdcPrint, MM_ISOTROPIC);

+			SetWindowExtEx  (hdcPrint,sXdpi, sYdpi, NULL);

+			SetViewportExtEx(hdcPrint,pXdpi, pYdpi, NULL);

+		};

+

+	*deviceContext	= (int) hdcPrint;

+	/*rMessageBox(NULL, MB_APPLMODAL, "leaving getDC","");*/

+#endif

+}

+

+

+#if 0

+BOOL CALLBACK PrintDlgProc (HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)

+     {

+     switch (msg)

+          {

+          case WM_INITDIALOG :

+               EnableMenuItem (GetSystemMenu (hDlg, FALSE), SC_CLOSE,

+                                                            MF_GRAYED) ;

+               return TRUE ;

+          case WM_COMMAND :

+               bUserAbort = TRUE ;

+               EnableWindow (ghMainWindow, TRUE) ;

+               DestroyWindow (hDlg) ;

+               hDlgPrint = 0 ;

+               return TRUE ;

+          }

+     return FALSE;

+	 }

+

+BOOL CALLBACK AbortProc (HDC hdcPrn, int iCode)

+     {

+     MSG   msg ;

+

+     while (!bUserAbort && PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))

+          {

+          if (!hDlgPrint || !IsDialogMessage (hDlgPrint, &msg))

+               {

+               TranslateMessage (&msg) ;

+               DispatchMessage (&msg) ;

+               }

+          }

+     return !bUserAbort ;

+     }

+#endif

+

+

+#define DIALOG_WIDTH 100

+#define DIALOG_HEIGHT 60

+	/* in dialog units */

+

+#if 0

+HWND CreateCancelDialog(void)

+{

+	HWND hwndButton,dlgHdl;

+

+	WORD *p, *pdlgtemplate,baseunitX,baseunitY;

+	int nchar;

+	int scrnWidth,scrnHeight;

+	int buttonX, buttonY, buttonWidth, buttonHeight;

+	int textX, textY, textWidth, textHeight;

+	DWORD lStyle,baseunits;

+	HDC screen;

+	LOGFONT lf;

+

+	/* allocate some memory to play with  */

+	pdlgtemplate = p = (PWORD) rmalloc (1000);

+

+	screen = CreateDC ("DISPLAY", NULL, NULL, NULL);

+	scrnWidth  = GetDeviceCaps (screen, HORZRES);

+	scrnHeight = GetDeviceCaps (screen, VERTRES);

+	DeleteDC (screen);

+	baseunits = GetDialogBaseUnits();

+

+	/* start to fill in the dlgtemplate information.  addressing by WORDs */

+	lStyle = WS_CAPTION | DS_MODALFRAME | WS_SYSMENU;

+

+	baseunitX=LOWORD(baseunits);

+	baseunitY=HIWORD(baseunits);

+

+	*p++ = LOWORD (lStyle);

+	*p++ = HIWORD (lStyle);

+	*p++ = 0;		/* LOWORD (lExtendedStyle) */

+	*p++ = 0;		/* HIWORD (lExtendedStyle) */

+	*p++ = 0;		/* NumberOfItems */

+	*p++ = ((scrnWidth*4)/3)/baseunitX;		/* x */

+	*p++ = ((scrnHeight*8)/3)/baseunitY;	/* y */

+	*p++ = DIALOG_WIDTH;	/* cx */

+	*p++ = DIALOG_HEIGHT;	/* cy */

+	*p++ = 0;		/* Menu */

+	*p++ = 0;		/* Class */

+

+	/* copy the title of the dialog */

+	nchar = NULL; /*nCopyAnsiToWideChar (p, (char *) "Printing in Progress");*/

+	p += nchar;

+

+	dlgHdl = CreateDialogIndirectParam (ghInst, (LPDLGTEMPLATE) pdlgtemplate, ghMainWindow,

+										(DLGPROC) PrintDlgProc, (LPARAM) 0);

+

+	rfree(pdlgtemplate);

+

+	/* Add a text field */

+	textWidth = 19*baseunitX;

+	textHeight = baseunitY;

+	textX =    (((DIALOG_WIDTH*baseunitX)/4) - textWidth)

+		       / 2;

+	textY =    (((DIALOG_HEIGHT*baseunitY)/8) - textHeight)

+			   / 4;

+	hwndText = CreateWindow ("static", "",WS_VISIBLE | WS_CHILD | SS_CENTER,

+									textX, textY, textWidth, textHeight,

+									dlgHdl, (HMENU) 0, ghInst, 0);

+

+

+	/* Add a Cancel button: */

+	buttonWidth = 10*baseunitX;

+	buttonHeight = (3*baseunitY)/2;

+	buttonX =    (((DIALOG_WIDTH*baseunitX)/4) - buttonWidth)

+		       / 2;

+	buttonY =  (3 *  (((DIALOG_HEIGHT*baseunitY)/8) - buttonHeight))

+			   / 5;

+	hwndButton = CreateWindow ("button", "Cancel", WS_VISIBLE | WS_CHILD | BS_PUSHBUTTON,

+									buttonX, buttonY, buttonWidth, buttonHeight,

+									dlgHdl, (HMENU) 0, ghInst, 0);

+/*	WinSetFont (&lf,"MS Sans Serif",0,8); */

+	SendMessage(hwndButton,WM_SETFONT,(WPARAM)CreateFontIndirect (&lf),MAKELPARAM (TRUE,0));

+	SendMessage(hwndText,WM_SETFONT,(WPARAM)CreateFontIndirect (&lf),MAKELPARAM (TRUE,0));

+

+	ShowWindow (dlgHdl,SW_SHOWNORMAL);

+	return dlgHdl;

+}

+#endif

+

+/*	PA: Called in Clean. */

+int addSemaphor(int add)

+{

+	int old=semaphor;

+	semaphor+=add;

+	return old;

+}

+

+int os_printsetupvalidC(DEVMODE *devmode, char *device, char *driver)

+{

+#if 0

+	HDC	icPrint;

+

+	icPrint	= myCreateIC(driver,device,devmode);

+	if (icPrint)

+		DeleteDC(icPrint);

+	return icPrint!=NULL;

+#else

+    return 0;

+#endif

+}

+