--- /dev/null
+
+/*
+ * bltWinPrnt.c --
+ *
+ * This module implements Win32 printer access.
+ *
+ * Copyright 1998 by Bell Labs Innovations for Lucent Technologies.
+ *
+ * Permission to use, copy, modify, and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice appear in all
+ * copies and that both that the copyright notice and warranty
+ * disclaimer appear in supporting documentation, and that the names
+ * of Lucent Technologies any of their entities not be used in
+ * advertising or publicity pertaining to distribution of the software
+ * without specific, written prior permission.
+ *
+ * Lucent Technologies disclaims all warranties with regard to this
+ * software, including all implied warranties of merchantability and
+ * fitness. In no event shall Lucent Technologies be liable for any
+ * special, indirect or consequential damages or any damages
+ * whatsoever resulting from loss of use, data or profits, whether in
+ * an action of contract, negligence or other tortuous action, arising
+ * out of or in connection with the use or performance of this
+ * software.
+ *
+ */
+
+#include <bltInt.h>
+#include <bltHash.h>
+#ifndef NO_PRINTER
+#include <X11/Xutil.h>
+#undef Status
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+#include <winspool.h>
+#endif /* _MSC_VER || __BORLANDC__ */
+
+/*
+ set pid [printer open name]
+ printer close $pid
+ printer write $pid $data
+ printer snap $pid .window
+ printer names
+ printer enum things
+ printer getattr $pid
+ printer setattr $pid
+
+ set pid [open ]
+ blt::printer open {\\alprint\2a211} p1
+ p1 getattr varName
+ p1 setattr varName
+ p1 write $data
+ .graph print p1
+ p1 snap .window
+ p1 close
+ blt::printer names
+ blt::printer emum things
+*/
+
+#define PRINTER_THREAD_KEY "BLT Printer Data"
+
+typedef struct {
+ Blt_HashTable printerTable; /* Hash table of printer structures keyed by
+ * the name of the printer. */
+ int nextId;
+} PrinterInterpData;
+
+typedef struct {
+ int type;
+ HDC hDC;
+} PrintDrawable;
+
+typedef struct {
+ Tcl_Interp *interp;
+ Tcl_Command cmdToken; /* Token for vector's Tcl command. */
+ char *name;
+ char *fileName;
+ PrintDrawable drawable;
+ HANDLE hPrinter;
+ Blt_HashEntry *hashPtr;
+ Blt_HashTable *tablePtr;
+ char *driverName;
+ char *deviceName;
+ char *printerName;
+ char *docName;
+ char *portName;
+ DEVMODE *dmPtr;
+ int dmSize;
+} PrintQueue;
+
+typedef struct {
+ DWORD token;
+ char *string;
+} TokenString;
+
+static TokenString sizeTable[] =
+{
+ /* Letter 8 1/2 x 11 in */
+ { DMPAPER_LETTER, "Letter" },
+ /* Letter Small 8 1/2 x 11 in */
+ { DMPAPER_LETTERSMALL, "Letter Small" },
+ /* Tabloid 11 x 17 in */
+ { DMPAPER_TABLOID, "Tabloid" },
+ /* Ledger 17 x 11 in */
+ { DMPAPER_LEDGER, "Ledger" },
+ /* Legal 8 1/2 x 14 in */
+ { DMPAPER_LEGAL, "Legal" },
+ /* Statement 5 1/2 x 8 1/2 in */
+ { DMPAPER_STATEMENT, "Statement" },
+ /* Executive 7 1/4 x 10 1/2 in */
+ { DMPAPER_EXECUTIVE, "Executive" },
+ /* A3 297 x 420 mm */
+ { DMPAPER_A3, "A3" },
+ /* A4 210 x 297 mm */
+ { DMPAPER_A4, "A4" },
+ /* A4 Small 210 x 297 mm */
+ { DMPAPER_A4SMALL, "A4 Small" },
+ /* A5 148 x 210 mm */
+ { DMPAPER_A5, "A5" },
+ /* B4 (JIS) 250 x 354 */
+ { DMPAPER_B4, "B4 (JIS)" },
+ /* B5 (JIS) 182 x 257 mm */
+ { DMPAPER_B5, "B5 (JIS)" },
+ /* Folio 8 1/2 x 13 in */
+ { DMPAPER_FOLIO, "Folio" },
+ /* Quarto 215 x 275 mm */
+ { DMPAPER_QUARTO, "Quarto" },
+ /* 10x14 in */
+ { DMPAPER_10X14, "10x14" },
+ /* 11x17 in */
+ { DMPAPER_11X17, "11x17" },
+ /* Note 8 1/2 x 11 in */
+ { DMPAPER_NOTE, "Note" },
+ /* Envelope #9 3 7/8 x 8 7/8 */
+ { DMPAPER_ENV_9, "Envelope #9" },
+ /* Envelope #10 4 1/8 x 9 1/2 */
+ { DMPAPER_ENV_10, "Envelope #10" },
+ /* Envelope #11 4 1/2 x 10 3/8 */
+ { DMPAPER_ENV_11, "Envelope #11" },
+ /* Envelope #12 4 \276 x 11 */
+ { DMPAPER_ENV_12, "Envelope #12" },
+ /* Envelope #14 5 x 11 1/2 */
+ { DMPAPER_ENV_14, "Envelope #14" },
+ /* C size sheet */
+ { DMPAPER_CSHEET, "C size sheet" },
+ /* D size sheet */
+ { DMPAPER_DSHEET, "D size sheet" },
+ /* E size sheet */
+ { DMPAPER_ESHEET, "E size sheet" },
+ /* Envelope DL 110 x 220mm */
+ { DMPAPER_ENV_DL, "Envelope DL" },
+ /* Envelope C5 162 x 229 mm */
+ { DMPAPER_ENV_C5, "Envelope C5" },
+ /* Envelope C3 324 x 458 mm */
+ { DMPAPER_ENV_C3, "Envelope C3" },
+ /* Envelope C4 229 x 324 mm */
+ { DMPAPER_ENV_C4, "Envelope C4" },
+ /* Envelope C6 114 x 162 mm */
+ { DMPAPER_ENV_C6, "Envelope C6" },
+ /* Envelope C65 114 x 229 mm */
+ { DMPAPER_ENV_C65, "Envelope C65" },
+ /* Envelope B4 250 x 353 mm */
+ { DMPAPER_ENV_B4, "Envelope B4" },
+ /* Envelope B5 176 x 250 mm */
+ { DMPAPER_ENV_B5, "Envelope B5" },
+ /* Envelope B6 176 x 125 mm */
+ { DMPAPER_ENV_B6, "Envelope B6" },
+ /* Envelope 110 x 230 mm */
+ { DMPAPER_ENV_ITALY, "Envelope Italy" },
+ /* Env Monarch 3 7/8 x 7 1/2 in */
+ { DMPAPER_ENV_MONARCH, "Envelope Monarch" },
+ /* 6 3/4 Envelope 3 5/8 x 6 1/2 in */
+ { DMPAPER_ENV_PERSONAL, "6 3/4 Envelope" },
+ /* US Std Fanfold 14 7/8 x 11 in */
+ { DMPAPER_FANFOLD_US, "US Std Fanfold" },
+ /* German Std Fanfold 8 1/2 x 12 in */
+ { DMPAPER_FANFOLD_STD_GERMAN, "German Std Fanfold" },
+ /* German Legal Fanfold 8 1/2 x 13 in */
+ { DMPAPER_FANFOLD_LGL_GERMAN, "German Legal Fanfold" },
+ /* B4 (ISO) 250 x 353 mm */
+ { DMPAPER_ISO_B4, "ISOB4" },
+ /* Japanese Postcard 100 x 148 mm */
+ { DMPAPER_JAPANESE_POSTCARD, "Postcard (JIS)" },
+ /* 9 x 11 in */
+ { DMPAPER_9X11, "9x11" },
+ /* 10 x 11 in */
+ { DMPAPER_10X11, "10x11" },
+ /* 15 x 11 in */
+ { DMPAPER_15X11, "15x11" },
+ /* Envelope Invite 220 x 220 mm */
+ { DMPAPER_ENV_INVITE, "Envelope Invite" },
+ /* Letter Extra 9 \275 x 12 in */
+ { DMPAPER_LETTER_EXTRA, "Letter Extra" },
+ /* Legal Extra 9 \275 x 15 in */
+ { DMPAPER_LEGAL_EXTRA, "Legal Extra" },
+ /* Tabloid Extra 11.69 x 18 in */
+ { DMPAPER_TABLOID_EXTRA, "Tabloid Extra" },
+ /* A4 Extra 9.27 x 12.69 in */
+ { DMPAPER_A4_EXTRA, "A4 Extra" },
+ /* Letter Transverse 8 \275 x 11 in */
+ { DMPAPER_LETTER_TRANSVERSE, "Letter Transverse" },
+ /* A4 Transverse 210 x 297 mm */
+ { DMPAPER_A4_TRANSVERSE, "A4 Transverse" },
+ /* Letter Extra Transverse 9\275 x 12 in */
+ { DMPAPER_LETTER_EXTRA_TRANSVERSE, "Letter Extra Transverse" },
+ /* SuperA/SuperA/A4 227 x 356 mm */
+ { DMPAPER_A_PLUS, "Super A Plus" },
+ /* SuperB/SuperB/A3 305 x 487 mm */
+ { DMPAPER_B_PLUS, "Super B Plus" },
+ /* Letter Plus 8.5 x 12.69 in */
+ { DMPAPER_LETTER_PLUS, "Letter Plus" },
+ /* A4 Plus 210 x 330 mm */
+ { DMPAPER_A4_PLUS, "A4 Plus" },
+ /* A5 Transverse 148 x 210 mm */
+ { DMPAPER_A5_TRANSVERSE, "A5 Transverse" },
+ /* B5 (JIS) Transverse 182 x 257 mm */
+ { DMPAPER_B5_TRANSVERSE, "B5 Transverse" },
+ /* A3 Extra 322 x 445 mm */
+ { DMPAPER_A3_EXTRA, "A3 Extra" },
+ /* A5 Extra 174 x 235 mm */
+ { DMPAPER_A5_EXTRA, "A5 Extra" },
+ /* B5 (ISO) Extra 201 x 276 mm */
+ { DMPAPER_B5_EXTRA, "B5 Extra" },
+ /* A2 420 x 594 mm */
+ { DMPAPER_A2, "A2" },
+ /* A3 Transverse 297 x 420 mm */
+ { DMPAPER_A3_TRANSVERSE, "A3 Transverse" },
+ /* A3 Extra Transverse 322 x 445 mm */
+ { DMPAPER_A3_EXTRA_TRANSVERSE, "A3 Extra Transverse" },
+ { 0, NULL }
+};
+
+static TokenString statusTable[] =
+{
+ { PRINTER_STATUS_BUSY, "Busy" },
+ { PRINTER_STATUS_DOOR_OPEN, "Door Open" },
+ { PRINTER_STATUS_ERROR, "Error" },
+ { PRINTER_STATUS_INITIALIZING, "Initializing" },
+ { PRINTER_STATUS_IO_ACTIVE, "IO Active" },
+ { PRINTER_STATUS_MANUAL_FEED, "Manual Feed" },
+ { PRINTER_STATUS_NOT_AVAILABLE, "Not Available" },
+ { PRINTER_STATUS_NO_TONER, "No Toner" },
+ { PRINTER_STATUS_OFFLINE, "Offline" },
+ { PRINTER_STATUS_OUTPUT_BIN_FULL, "Bin Full" },
+ { PRINTER_STATUS_OUT_OF_MEMORY, "Out Of Memory" },
+ { PRINTER_STATUS_PAGE_PUNT, "Page Punt" },
+ { PRINTER_STATUS_PAPER_JAM, "Paper Jam" },
+ { PRINTER_STATUS_PAPER_OUT, "Paper Out" },
+ { PRINTER_STATUS_PAPER_PROBLEM, "Paper Problem" },
+ { PRINTER_STATUS_PAUSED, "Paused" },
+ { PRINTER_STATUS_PENDING_DELETION, "Pending Deletion" },
+ { PRINTER_STATUS_POWER_SAVE, "Power Save" },
+ { PRINTER_STATUS_PRINTING, "Printing" },
+ { PRINTER_STATUS_PROCESSING, "Processing" },
+ { PRINTER_STATUS_SERVER_UNKNOWN, "Server Unknown" },
+ { PRINTER_STATUS_TONER_LOW, "Toner Low" },
+ { PRINTER_STATUS_USER_INTERVENTION, "User Intervention" },
+ { PRINTER_STATUS_WAITING, "Waiting" },
+ { PRINTER_STATUS_WARMING_UP, "Warming Up" },
+ { 0, NULL }
+};
+
+static TokenString attributeTable[] =
+{
+ { PRINTER_ATTRIBUTE_DEFAULT, "Default" },
+ { PRINTER_ATTRIBUTE_DIRECT, "Direct" },
+ { PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST, "Do Complete First" },
+ { PRINTER_ATTRIBUTE_ENABLE_BIDI, "Enable BIDI" },
+ { PRINTER_ATTRIBUTE_ENABLE_DEVQ, "Enable Devq" },
+ { PRINTER_ATTRIBUTE_HIDDEN, "Hidden" },
+ { PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS, "Keep Printed Jobs" },
+ { PRINTER_ATTRIBUTE_LOCAL, "Local" },
+ { PRINTER_ATTRIBUTE_NETWORK, "Network" },
+ { PRINTER_ATTRIBUTE_QUEUED, "Queued" },
+ { PRINTER_ATTRIBUTE_RAW_ONLY, "Raw Only" },
+ { PRINTER_ATTRIBUTE_SHARED, "Shared" },
+ { PRINTER_ATTRIBUTE_WORK_OFFLINE, "Offline" },
+ { 0, NULL }
+};
+
+static TokenString binTable[] =
+{
+ { DMBIN_UPPER, "Upper" },
+ { DMBIN_LOWER, "Lower" },
+ { DMBIN_MIDDLE, "Middle" },
+ { DMBIN_MANUAL, "Manual" },
+ { DMBIN_ENVELOPE, "Envelope" },
+ { DMBIN_ENVMANUAL, "Envelope Manual" },
+ { DMBIN_AUTO, "Automatic" },
+ { DMBIN_TRACTOR, "Tractor" },
+ { DMBIN_SMALLFMT, "Small Format" },
+ { DMBIN_LARGEFMT, "Large Format" },
+ { DMBIN_LARGECAPACITY, "Large Capacity" },
+ { DMBIN_CASSETTE, "Cassette" },
+ { DMBIN_FORMSOURCE, "Form Source" },
+ { 0, NULL }
+};
+
+static TokenString orientationTable[] =
+{
+ { DMORIENT_PORTRAIT, "Portrait" },
+ { DMORIENT_LANDSCAPE, "Landscape" },
+ { 0, NULL }
+};
+
+static TokenString qualityTable[] =
+{
+ { DMRES_HIGH, "High" },
+ { DMRES_MEDIUM, "Medium" },
+ { DMRES_LOW, "Low" },
+ { DMRES_DRAFT, "Draft" },
+ { 0, NULL }
+};
+
+static TokenString colorTable[] =
+{
+ { DMCOLOR_COLOR, "Color" },
+ { DMCOLOR_MONOCHROME, "Monochrome" },
+ { 0, NULL }
+};
+
+static TokenString duplexTable[] =
+{
+ { DMDUP_SIMPLEX, "Simplex" },
+ { DMDUP_HORIZONTAL, "Horizontal" },
+ { DMDUP_VERTICAL, "Vertical" },
+ { 0, NULL }
+};
+
+static TokenString ttOptionTable[] =
+{
+ { DMTT_BITMAP, "Bitmap" },
+ { DMTT_DOWNLOAD, "Download" },
+ { DMTT_SUBDEV, "Substitute Device" },
+ { DMTT_DOWNLOAD_OUTLINE, "Download Outline" },
+ { 0, NULL }
+};
+
+static Tcl_ObjCmdProc PrinterCmd;
+static Tcl_InterpDeleteProc PrinterInterpDeleteProc;
+
+void
+Blt_GetPrinterScale(HDC printerDC, double *xRatioPtr, double *yRatioPtr)
+{
+ double xScreen, yScreen;
+ double xPrinter, yPrinter;
+ HDC screenDC;
+
+ xPrinter = (double)GetDeviceCaps(printerDC, LOGPIXELSX);
+ yPrinter = (double)GetDeviceCaps(printerDC, LOGPIXELSY);
+ screenDC = GetDC(NULL);
+ xScreen = (double)GetDeviceCaps(screenDC, LOGPIXELSX);
+ yScreen = (double)GetDeviceCaps(screenDC, LOGPIXELSY);
+ ReleaseDC(NULL, screenDC);
+ *xRatioPtr = (xPrinter / xScreen);
+ *yRatioPtr = (yPrinter / yScreen);
+}
+
+static PrinterInterpData *
+GetPrinterInterpData(Tcl_Interp *interp)
+{
+ PrinterInterpData *dataPtr;
+ Tcl_InterpDeleteProc *proc;
+
+ dataPtr = (PrinterInterpData *)
+ Tcl_GetAssocData(interp, PRINTER_THREAD_KEY, &proc);
+ if (dataPtr == NULL) {
+ dataPtr = Blt_Malloc(sizeof(PrinterInterpData));
+ dataPtr->nextId = 0;
+ assert(dataPtr);
+ Tcl_SetAssocData(interp, PRINTER_THREAD_KEY, PrinterInterpDeleteProc,
+ dataPtr);
+ Blt_InitHashTable(&dataPtr->printerTable, BLT_STRING_KEYS);
+ }
+ return dataPtr;
+}
+
+static int
+GetQueue(
+ Tcl_Interp *interp,
+ const char *name,
+ PrintQueue **queuePtrPtr)
+{
+ Blt_HashEntry *hPtr;
+ PrinterInterpData *dataPtr;
+
+ dataPtr = GetPrinterInterpData(interp);
+ hPtr = Blt_FindHashEntry(&dataPtr->printerTable, name);
+ if (hPtr == NULL) {
+ Tcl_AppendResult(interp, "can't find printer \"", name, "\"",
+ (char *)NULL);
+ return TCL_ERROR;
+ }
+ *queuePtrPtr = (PrintQueue *)Blt_GetHashValue(hPtr);
+ return TCL_OK;
+}
+
+static int
+GetQueueFromObj(
+ Tcl_Interp *interp,
+ Tcl_Obj *objPtr,
+ PrintQueue **queuePtrPtr)
+{
+ return GetQueue(interp, Tcl_GetString(objPtr), queuePtrPtr);
+}
+
+static void
+CloseQueue(
+ PrintQueue *queuePtr)
+{
+ ClosePrinter(queuePtr->hPrinter);
+ queuePtr->hPrinter = NULL;
+}
+
+static int
+OpenQueue(
+ Tcl_Interp *interp,
+ PrintQueue *queuePtr)
+{
+ PRINTER_DEFAULTS pd;
+ HANDLE hPrinter;
+
+ ZeroMemory(&pd, sizeof(pd));
+ pd.DesiredAccess = PRINTER_ALL_ACCESS;
+ if (!OpenPrinter(queuePtr->printerName, &hPrinter, &pd)) {
+ Tcl_AppendResult(interp, "can't open printer \"",
+ queuePtr->printerName, "\": ", Blt_LastError(), (char *)NULL);
+ queuePtr->hPrinter = NULL;
+ return TCL_ERROR;
+ }
+ queuePtr->hPrinter = hPrinter;
+ return TCL_OK;
+}
+
+static HGLOBAL
+GetQueueProperties(
+ PrintQueue *queuePtr,
+ DEVMODE **dmPtrPtr)
+{
+ HWND hWnd;
+ unsigned int dmSize;
+ HGLOBAL hMem;
+ DEVMODE *dmPtr;
+
+ hWnd = GetDesktopWindow();
+ dmSize = DocumentProperties(hWnd, queuePtr->hPrinter,
+ queuePtr->printerName, NULL, NULL, 0);
+ if (dmSize == 0) {
+ Tcl_AppendResult(queuePtr->interp,
+ "can't get document properties for \"",
+ queuePtr->printerName,
+ "\": ", Blt_LastError(), (char *)NULL);
+ return NULL;
+ }
+ hMem = GlobalAlloc(GHND, dmSize);
+ dmPtr = (DEVMODE *)GlobalLock(hMem);
+ if (!DocumentProperties(hWnd, queuePtr->hPrinter, queuePtr->printerName,
+ dmPtr, NULL, DM_OUT_BUFFER)) {
+ Tcl_AppendResult(queuePtr->interp,
+ "can't allocate document properties for \"",
+ queuePtr->printerName, "\": ", Blt_LastError(),
+ (char *)NULL);
+ GlobalUnlock(hMem);
+ GlobalFree(hMem);
+ return NULL;
+ }
+ *dmPtrPtr = dmPtr;
+ queuePtr->dmSize = dmSize;
+ return hMem;
+}
+
+static int
+SetQueueProperties(
+ Tcl_Interp *interp,
+ PrintQueue *queuePtr,
+ DEVMODE *dmPtr)
+{
+ HWND hWnd;
+ int result;
+
+ hWnd = GetDesktopWindow();
+ result = DocumentProperties(hWnd, queuePtr->hPrinter,
+ queuePtr->printerName, dmPtr, dmPtr, DM_IN_BUFFER | DM_OUT_BUFFER);
+ if (result == 0) {
+ Tcl_AppendResult(interp, "can't set document properties for \"",
+ queuePtr->printerName, "\": ", Blt_LastError(), (char *)NULL);
+ return TCL_ERROR;
+ }
+ if (queuePtr->dmPtr != NULL) {
+ Blt_Free(queuePtr->dmPtr);
+ }
+ queuePtr->dmPtr = Blt_Malloc(queuePtr->dmSize);
+ *queuePtr->dmPtr = *dmPtr;
+ return TCL_OK;
+}
+
+static void
+DestroyQueue(PrintQueue *queuePtr)
+{
+ if (queuePtr->drawable.hDC != NULL) {
+ DeleteDC(queuePtr->drawable.hDC);
+ }
+ if (queuePtr->printerName != NULL) {
+ Blt_Free(queuePtr->printerName);
+ }
+ if (queuePtr->deviceName != NULL) {
+ Blt_Free(queuePtr->deviceName);
+ }
+ if (queuePtr->portName != NULL) {
+ Blt_Free(queuePtr->portName);
+ }
+ if (queuePtr->driverName != NULL) {
+ Blt_Free(queuePtr->driverName);
+ }
+ if (queuePtr->hashPtr != NULL) {
+ Blt_DeleteHashEntry(queuePtr->tablePtr, queuePtr->hashPtr);
+ }
+ if (queuePtr->dmPtr != NULL) {
+ Blt_Free(queuePtr->dmPtr);
+ }
+ Blt_Free(queuePtr);
+}
+
+static char *
+AttributesToString(DWORD attributes, Tcl_DString * resultPtr)
+{
+ register TokenString *p;
+
+ Tcl_DStringInit(resultPtr);
+ for (p = attributeTable; p->string != NULL; p++) {
+ if (attributes & p->token) {
+ Tcl_DStringAppendElement(resultPtr, p->string);
+ }
+ }
+ return Tcl_DStringValue(resultPtr);
+}
+
+static char *
+StatusToString(DWORD status, Tcl_DString * resultPtr)
+{
+ register TokenString *p;
+
+ Tcl_DStringInit(resultPtr);
+ for (p = statusTable; p->string != NULL; p++) {
+ if (status & p->token) {
+ Tcl_DStringAppendElement(resultPtr, p->string);
+ }
+ }
+ return Tcl_DStringValue(resultPtr);
+}
+
+static char *
+TokenToString(TokenString *table, DWORD token)
+{
+ register TokenString *p;
+
+ for (p = table; p->string != NULL; p++) {
+ if (token == p->token) {
+ return p->string;
+ }
+ }
+ return "???";
+}
+
+static DWORD
+StringToToken(TokenString * table, char *string)
+{
+ register TokenString *p;
+ char c;
+
+ c = toupper(string[0]);
+ for (p = table; p->string != NULL; p++) {
+ if ((c == toupper(p->string[0])) &&
+ (strcasecmp(string, p->string) == 0)) {
+ return p->token;
+ }
+ }
+ return 0;
+}
+
+static void
+GetFormInfo(
+ Tcl_Interp *interp,
+ FORM_INFO_1 * infoArr,
+ int nForms,
+ char *varName)
+{
+ Tcl_DString dString;
+ register int i;
+
+ Tcl_DStringInit(&dString);
+ for (i = 0; i < nForms; i++) {
+ Tcl_DStringAppendElement(&dString, infoArr[i].pName);
+ }
+ Tcl_SetVar2(interp, varName, "EnumForms", Tcl_DStringValue(&dString),
+ TCL_LEAVE_ERR_MSG);
+ Tcl_DStringFree(&dString);
+}
+
+
+static int
+GetPrinterAttributes(
+ Tcl_Interp *interp, /* Interpreter context. */
+ PrintQueue *queuePtr,
+ Tcl_Obj *objPtr) /* Name of array variable to contain
+ * printer device information. */
+{
+ char *string;
+ Tcl_DString dString;
+ DEVMODE *dmPtr;
+ DWORD bytesNeeded;
+ HGLOBAL hMem1, hMem2;
+ PRINTER_INFO_2* pi2Ptr;
+ LPVOID buffer;
+ int result = TCL_ERROR;
+ char *varName;
+
+ if (OpenQueue(interp, queuePtr) != TCL_OK) {
+ return TCL_ERROR;
+ }
+ Tcl_DStringInit(&dString);
+ hMem2 = NULL;
+
+ GetPrinter(queuePtr->hPrinter, 2, NULL, 0, &bytesNeeded);
+
+ /* Windows 95/98 seems to only want locked memory. Allocating
+ * unlocked memory will sometimes crash the printer driver and
+ * therefore Windows itself. */
+
+ hMem1 = GlobalAlloc(GHND, bytesNeeded);
+ if (hMem1 == NULL) {
+ Tcl_AppendResult(interp, "can't allocate memory for printer \"",
+ queuePtr->name, "\": ", Blt_LastError(), (char *)NULL);
+ goto error;
+ }
+ buffer = (LPVOID)GlobalLock(hMem1);
+ if (!GetPrinter(queuePtr->hPrinter, 2, buffer, bytesNeeded,
+ &bytesNeeded)) {
+ Tcl_AppendResult(interp, "can't get printer \"", queuePtr->name, "\": ",
+ Blt_LastError(), (char *)NULL);
+ goto error;
+ }
+ hMem2 = GetQueueProperties(queuePtr, &dmPtr);
+ if (hMem2 == NULL) {
+ Tcl_AppendResult(interp, "can't allocate memory for printer \"",
+ queuePtr->name, "\" properties: ", Blt_LastError(), (char *)NULL);
+ goto error;
+ }
+ pi2Ptr = (PRINTER_INFO_2 *)buffer;
+ varName = Tcl_GetString(objPtr);
+ Tcl_SetVar2(interp, varName, "ServerName", pi2Ptr->pServerName, 0);
+ Tcl_SetVar2(interp, varName, "PrinterName", pi2Ptr->pPrinterName, 0);
+ Tcl_SetVar2(interp, varName, "PortName", pi2Ptr->pPortName, 0);
+ Tcl_SetVar2(interp, varName, "DriverName", pi2Ptr->pDriverName, 0);
+ Tcl_SetVar2(interp, varName, "Comment", pi2Ptr->pComment, 0);
+ Tcl_SetVar2(interp, varName, "Location", pi2Ptr->pLocation, 0);
+ Tcl_SetVar2(interp, varName, "SepFile", pi2Ptr->pSepFile, 0);
+ Tcl_SetVar2(interp, varName, "PrintProcessor", pi2Ptr->pPrintProcessor, 0);
+ Tcl_SetVar2(interp, varName, "Datatype", pi2Ptr->pDatatype, 0);
+ Tcl_SetVar2(interp, varName, "Parameters", pi2Ptr->pParameters, 0);
+ Tcl_SetVar2(interp, varName, "Attributes",
+ AttributesToString(pi2Ptr->Attributes, &dString), 0);
+ Tcl_SetVar2(interp, varName, "Priority", Blt_Itoa(pi2Ptr->Priority), 0);
+ Tcl_SetVar2(interp, varName, "DefaultPriority",
+ Blt_Itoa(pi2Ptr->DefaultPriority), 0);
+ Tcl_SetVar2(interp, varName, "StartTime", Blt_Itoa(pi2Ptr->StartTime), 0);
+ Tcl_SetVar2(interp, varName, "UntilTime", Blt_Itoa(pi2Ptr->UntilTime), 0);
+ Tcl_SetVar2(interp, varName, "Status",
+ StatusToString(pi2Ptr->Status, &dString), 0);
+ Tcl_SetVar2(interp, varName, "Jobs", Blt_Itoa(pi2Ptr->cJobs), 0);
+ Tcl_SetVar2(interp, varName, "AveragePPM", Blt_Itoa(pi2Ptr->AveragePPM), 0);
+
+ if (dmPtr->dmFields & DM_ORIENTATION) {
+ Tcl_SetVar2(interp, varName, "Orientation",
+ TokenToString(orientationTable, dmPtr->dmOrientation), 0);
+ }
+ if (dmPtr->dmFields & DM_PAPERSIZE) {
+ Tcl_SetVar2(interp, varName, "PaperSize",
+ TokenToString(sizeTable, dmPtr->dmPaperSize), 0);
+ }
+ if (dmPtr->dmFields & DM_PAPERWIDTH) {
+ Tcl_SetVar2(interp, varName, "PaperWidth",
+ Blt_Itoa(dmPtr->dmPaperWidth), 0);
+ }
+ if (dmPtr->dmFields & DM_PAPERLENGTH) {
+ Tcl_SetVar2(interp, varName, "PaperLength",
+ Blt_Itoa(dmPtr->dmPaperLength), 0);
+ }
+ if (dmPtr->dmFields & DM_SCALE) {
+ Tcl_SetVar2(interp, varName, "Scale", Blt_Itoa(dmPtr->dmScale), 0);
+ }
+ if (dmPtr->dmFields & DM_COPIES) {
+ Tcl_SetVar2(interp, varName, "Copies", Blt_Itoa(dmPtr->dmCopies), 0);
+ }
+ if (dmPtr->dmFields & DM_DEFAULTSOURCE) {
+ Tcl_SetVar2(interp, varName, "DefaultSource",
+ TokenToString(binTable, dmPtr->dmDefaultSource), 0);
+ }
+ if (dmPtr->dmFields & DM_PRINTQUALITY) {
+ if (dmPtr->dmPrintQuality < 0) {
+ string = TokenToString(qualityTable, dmPtr->dmPrintQuality);
+ } else {
+ string = Blt_Itoa(dmPtr->dmPrintQuality);
+ }
+ Tcl_SetVar2(interp, varName, "PrintQuality", string, 0);
+ }
+ if (dmPtr->dmFields & DM_COLOR) {
+ Tcl_SetVar2(interp, varName, "Color",
+ TokenToString(colorTable, dmPtr->dmColor), 0);
+ }
+ if (dmPtr->dmFields & DM_DUPLEX) {
+ Tcl_SetVar2(interp, varName, "Duplex",
+ TokenToString(duplexTable, dmPtr->dmDuplex), 0);
+ }
+ if (dmPtr->dmFields & DM_YRESOLUTION) {
+ Tcl_SetVar2(interp, varName, "YResolution",
+ Blt_Itoa(dmPtr->dmYResolution), 0);
+ }
+ if (dmPtr->dmFields & DM_TTOPTION) {
+ Tcl_SetVar2(interp, varName, "TTOption",
+ TokenToString(ttOptionTable, dmPtr->dmTTOption), 0);
+ }
+ if (dmPtr->dmFields & DM_COLLATE) {
+ if (dmPtr->dmCollate == DMCOLLATE_TRUE) {
+ string = "true";
+ } else if (dmPtr->dmCollate == DMCOLLATE_FALSE) {
+ string = "false";
+ } else {
+ string = "???";
+ }
+ Tcl_SetVar2(interp, varName, "Collate", string, 0);
+ }
+ if (dmPtr->dmFields & DM_FORMNAME) {
+ Tcl_SetVar2(interp, varName, "FormName", dmPtr->dmFormName, 0);
+ }
+ Tcl_SetVar2(interp, varName, "OutputFile", dmPtr->dmDeviceName, 0);
+ result = TCL_OK;
+
+ error:
+ Tcl_DStringFree(&dString);
+ CloseQueue(queuePtr);
+ if (hMem1 != NULL) {
+ GlobalUnlock(hMem1);
+ GlobalFree(hMem1);
+ }
+ if (hMem2 != NULL) {
+ GlobalUnlock(hMem2);
+ GlobalFree(hMem2);
+ }
+ return result;
+}
+
+static int
+SetQueueAttributes(
+ Tcl_Interp *interp,
+ PrintQueue *queuePtr,
+ Tcl_Obj *objPtr)
+{
+ char *string;
+ DEVMODE *dmPtr;
+ int value;
+ HGLOBAL hMem;
+ int result;
+ char *varName;
+
+ if (OpenQueue(interp, queuePtr) != TCL_OK) {
+ return TCL_ERROR;
+ }
+ hMem = GetQueueProperties(queuePtr, &dmPtr);
+ CloseQueue(queuePtr);
+ if (hMem == NULL) {
+ return TCL_ERROR;
+ }
+ dmPtr->dmFields = 0;
+ varName = Tcl_GetString(objPtr);
+ string = (char *)Tcl_GetVar2(interp, varName, "Orientation", 0);
+ if (string != NULL) {
+ value = StringToToken(orientationTable, string);
+ if (value > 0) {
+ dmPtr->dmFields |= DM_ORIENTATION;
+ dmPtr->dmOrientation = value;
+ }
+ }
+ string = (char *)Tcl_GetVar2(interp, varName, "PaperSize", 0);
+ if (string != NULL) {
+ value = StringToToken(sizeTable, string);
+ if (value > 0) {
+ dmPtr->dmFields |= DM_PAPERSIZE;
+ dmPtr->dmPaperSize = value;
+ }
+ }
+ string = (char *)Tcl_GetVar2(interp, varName, "PaperWidth", 0);
+ if (string != NULL) {
+ if (Tcl_GetInt(interp, string, &value) == TCL_OK) {
+ dmPtr->dmFields |= DM_PAPERWIDTH;
+ dmPtr->dmPaperWidth = value;
+ }
+ }
+ string = (char *)Tcl_GetVar2(interp, varName, "PaperLength", 0);
+ if (string != NULL) {
+ if (Tcl_GetInt(interp, string, &value) == TCL_OK) {
+ dmPtr->dmFields |= DM_PAPERLENGTH;
+ dmPtr->dmPaperLength = value;
+ }
+ }
+ string = (char *)Tcl_GetVar2(interp, varName, "Scale", 0);
+ if (string != NULL) {
+ if (Tcl_GetInt(interp, string, &value) == TCL_OK) {
+ dmPtr->dmFields |= DM_SCALE;
+ dmPtr->dmScale = value;
+ }
+ }
+ string = (char *)Tcl_GetVar2(interp, varName, "Copies", 0);
+ if (string != NULL) {
+ if (Tcl_GetInt(interp, string, &value) == TCL_OK) {
+ dmPtr->dmFields |= DM_COPIES;
+ dmPtr->dmCopies = value;
+ }
+ }
+ string = (char *)Tcl_GetVar2(interp, varName, "DefaultSource", 0);
+ if (string != NULL) {
+ value = StringToToken(binTable, string);
+ if (value > 0) {
+ dmPtr->dmFields |= DM_DEFAULTSOURCE;
+ dmPtr->dmDefaultSource = value;
+ }
+ }
+ string = (char *)Tcl_GetVar2(interp, varName, "PrintQuality", 0);
+ if (string != NULL) {
+ value = StringToToken(qualityTable, string);
+ if (value > 0) {
+ dmPtr->dmFields |= DM_PRINTQUALITY;
+ dmPtr->dmPrintQuality = value;
+ }
+ }
+ string = (char *)Tcl_GetVar2(interp, varName, "Color", 0);
+ if (string != NULL) {
+ value = StringToToken(colorTable, string);
+ if (value > 0) {
+ dmPtr->dmFields |= DM_COLOR;
+ dmPtr->dmColor = value;
+ }
+ }
+ string = (char *)Tcl_GetVar2(interp, varName, "Duplex", 0);
+ if (string != NULL) {
+ value = StringToToken(duplexTable, string);
+ if (value > 0) {
+ dmPtr->dmFields |= DM_DUPLEX;
+ dmPtr->dmDuplex = value;
+ }
+ }
+ string = (char *)Tcl_GetVar2(interp, varName, "YResolution", 0);
+ if (string != NULL) {
+ if (Tcl_GetInt(interp, string, &value) == TCL_OK) {
+ dmPtr->dmFields |= DM_YRESOLUTION;
+ dmPtr->dmYResolution = value;
+ }
+ }
+ string = (char *)Tcl_GetVar2(interp, varName, "TTOption", 0);
+ if (string != NULL) {
+ value = StringToToken(ttOptionTable, string);
+ if (value > 0) {
+ dmPtr->dmFields |= DM_TTOPTION;
+ dmPtr->dmTTOption = value;
+ }
+ }
+ string = (char *)Tcl_GetVar2(interp, varName, "Collate", 0);
+ if (string != NULL) {
+ if (Tcl_GetBoolean(interp, string, &value) == TCL_OK) {
+ dmPtr->dmFields |= DM_COLLATE;
+ dmPtr->dmCollate = value;
+ }
+ }
+ string = (char *)Tcl_GetVar2(interp, varName, "OutputFile", 0);
+ if (string != NULL) {
+ if (queuePtr->fileName != NULL) {
+ Blt_Free(queuePtr->fileName);
+ }
+ queuePtr->fileName = Blt_Strdup(string);
+ }
+ if (queuePtr->dmPtr != NULL) {
+ Blt_Free(queuePtr->dmPtr);
+ }
+ string = (char *)Tcl_GetVar2(interp, varName, "DocumentName", 0);
+ if (string != NULL) {
+ if (queuePtr->docName != NULL) {
+ Blt_Free(queuePtr->docName);
+ }
+ queuePtr->docName = Blt_Strdup(string);
+ }
+ result = SetQueueProperties(interp, queuePtr, dmPtr);
+ GlobalUnlock(hMem);
+ GlobalFree(hMem);
+ CloseQueue(queuePtr);
+ return result;
+}
+
+/*ARGSUSED*/
+static int
+EnumOp(
+ ClientData clientData, /* Not used. */
+ Tcl_Interp *interp,
+ int objc,
+ Tcl_Obj *CONST *objv)
+{
+ TokenString *p;
+ char c;
+ unsigned int length;
+ char *attr;
+
+ attr = Tcl_GetStringFromObj(objv[2], &length);
+ c = attr[0];
+ if ((c == 'p') && (strncmp(attr, "paper", length) == 0)) {
+ p = sizeTable;
+ } else if ((c == 'q') && (strncmp(attr, "quality", length) == 0)) {
+ p = qualityTable;
+ } else if ((c == 'b') && (strncmp(attr, "bin", length) == 0)) {
+ p = binTable;
+ } else if ((c == 'o') && (strncmp(attr, "orientation", length) == 0)) {
+ p = orientationTable;
+ } else if ((c == 'c') && (strncmp(attr, "color", length) == 0)) {
+ p = colorTable;
+ } else if ((c == 'd') && (strncmp(attr, "duplex", length) == 0)) {
+ p = duplexTable;
+ } else if ((c == 't') && (strncmp(attr, "ttoption", length) == 0)) {
+ p = ttOptionTable;
+ } else {
+ Tcl_AppendResult(interp, "bad enumeration field \"", attr,
+"\": should be \"paper\", \"quality\", \"bin\", \"orientation\", \"color\", \"duplex\", or \"ttoption\"",
+ (char *)NULL);
+ return TCL_ERROR;
+ }
+ for ( /*empty*/ ; p->string != NULL; p++) {
+ Tcl_AppendElement(interp, p->string);
+ }
+ return TCL_OK;
+}
+
+/*ARGSUSED*/
+static int
+OpenOp(
+ ClientData clientData, /* Interpreter-specific data. */
+ Tcl_Interp *interp,
+ int objc,
+ Tcl_Obj *CONST *objv)
+{
+ PrinterInterpData *dataPtr = clientData;
+ PrintQueue *queuePtr;
+ LPVOID buffer;
+ PRINTER_INFO_2* pi2Ptr;
+ DWORD bytesNeeded;
+ int isNew;
+ Blt_HashEntry *hPtr;
+ HANDLE hMem;
+ char *name;
+
+ name = Tcl_GetString(objv[2]);
+ hPtr = Blt_CreateHashEntry(&dataPtr->printerTable, name, &isNew);
+ if (isNew) {
+ queuePtr = Blt_Calloc(1, sizeof(PrintQueue));
+ queuePtr->name = Blt_GetHashKey(&dataPtr->printerTable, hPtr);
+ queuePtr->interp = interp;
+ Tcl_SetResult(interp, name, TCL_VOLATILE);
+ Blt_SetHashValue(hPtr, queuePtr);
+ queuePtr->hashPtr = hPtr;
+ queuePtr->tablePtr = &dataPtr->printerTable;
+ queuePtr->printerName = Blt_Strdup(name);
+ } else {
+ Tcl_AppendResult(interp, "printer \"", name, "\" is already open",
+ (char *)NULL);
+ return TCL_ERROR;
+ }
+ if (OpenQueue(interp, queuePtr) != TCL_OK) {
+ DestroyQueue(queuePtr);
+ return TCL_ERROR;
+ }
+ /* Call the first time to determine the amount of memory needed. */
+ GetPrinter(queuePtr->hPrinter, 2, NULL, 0, &bytesNeeded);
+ if ((bytesNeeded == 0) || (GetLastError() != ERROR_INSUFFICIENT_BUFFER)) {
+ Tcl_AppendResult(interp, "can't get size of attribute buffer for \"",
+ name, "\": ", Blt_LastError(), (char *)NULL);
+ return TCL_ERROR;
+ }
+ /* Allocate a buffer to contain all printer information. */
+ hMem = GlobalAlloc(GHND, bytesNeeded);
+ if (hMem == NULL) {
+ return TCL_ERROR;
+ }
+ buffer = (LPVOID)GlobalLock(hMem);
+
+ /* And call the again to actually get the printer. */
+ if (!GetPrinter(queuePtr->hPrinter, 2, buffer, bytesNeeded,
+ &bytesNeeded)) {
+ Tcl_AppendResult(interp, "can't get printer attributes for \"",
+ name, "\": ", Blt_LastError(), (char *)NULL);
+ GlobalUnlock(hMem);
+ GlobalFree(hMem);
+ return TCL_ERROR;
+ }
+ pi2Ptr = (PRINTER_INFO_2 *)buffer;
+ if (pi2Ptr->pDevMode != NULL) {
+ queuePtr->deviceName = Blt_Strdup(pi2Ptr->pDevMode->dmDeviceName);
+ }
+ queuePtr->driverName = Blt_Strdup(pi2Ptr->pDriverName);
+ /*
+ queuePtr->printerName = Blt_Strdup(pi2Ptr->pPrinterName);
+ */
+ queuePtr->portName = Blt_Strdup(pi2Ptr->pPortName);
+ GlobalUnlock(hMem);
+ GlobalFree(hMem);
+ return TCL_OK;
+}
+
+/*ARGSUSED*/
+static int
+NamesOp(
+ ClientData clientData, /* Interpreter-specific data. */
+ Tcl_Interp *interp,
+ int objc, /* Not used. */
+ Tcl_Obj *CONST *objv) /* Not used. */
+{
+ DWORD nPrinters, bytesNeeded;
+ int elemSize, level;
+ unsigned char *buffer;
+ int result, flags;
+ HANDLE hMem;
+
+ if (Blt_GetPlatformId() == VER_PLATFORM_WIN32_NT) {
+ level = 4;
+ elemSize = sizeof(PRINTER_INFO_4);
+ flags = PRINTER_ENUM_NAME;
+ } else {
+ level = 5;
+ elemSize = sizeof(PRINTER_INFO_5);
+ flags = PRINTER_ENUM_LOCAL;
+ }
+ result = EnumPrinters(
+ flags, /* Flags */
+ NULL, /* Printer name */
+ level, /* Information level: 1, 2, 4, or 5 */
+ NULL, /* Array of returned information */
+ 0, /* Size of array */
+ &bytesNeeded, /* Size needed for array */
+ &nPrinters); /* Number of structures returned */
+
+ if ((!result) && (GetLastError() != ERROR_INSUFFICIENT_BUFFER)) {
+ Tcl_AppendResult(interp, "can't enumerate printers (memory alloc): ",
+ Blt_LastError(), (char *)NULL);
+ return TCL_ERROR;
+ }
+ hMem = GlobalAlloc(GHND, bytesNeeded);
+ buffer = (unsigned char *)GlobalLock(hMem);
+
+ result = EnumPrinters(
+ flags, /* Flags */
+ NULL, /* Printer name */
+ level, /* Information level: 1, 2, 4, or 5 */
+ buffer, /* Array of returned information */
+ bytesNeeded, /* Size of array */
+ &bytesNeeded, /* Size needed for array */
+ &nPrinters); /* Number of structures returned */
+
+ if (!result) {
+ Tcl_AppendResult(interp, "can't enumerate printers: ",
+ Blt_LastError(), (char *)NULL);
+ return TCL_ERROR;
+ }
+ if (objc > 2) {
+ register unsigned int i;
+ char *pattern;
+ char *p;
+
+ p = buffer;
+ pattern = Tcl_GetString(objv[2]);
+ for (i = 0; i < nPrinters; i++) {
+ if (Tcl_StringMatch(p, pattern)) {
+ Tcl_AppendElement(interp, *(char **)p);
+ }
+ p += elemSize;
+ }
+ } else {
+ register unsigned int i;
+ char *p;
+
+ p = buffer;
+ for (i = 0; i < nPrinters; i++) {
+ Tcl_AppendElement(interp, *(char **)p);
+ p += elemSize;
+ }
+ }
+ GlobalUnlock(hMem);
+ GlobalFree(hMem);
+ return TCL_OK;
+}
+
+/*ARGSUSED*/
+static int
+CloseOp(
+ ClientData clientData, /* Interpreter-specific data. */
+ Tcl_Interp *interp,
+ int objc, /* Not used. */
+ Tcl_Obj *CONST *objv)
+{
+ PrintQueue *queuePtr;
+
+ if (GetQueueFromObj(interp, objv[2], &queuePtr) != TCL_OK) {
+ return TCL_ERROR;
+ }
+ DestroyQueue(queuePtr);
+ return TCL_OK;
+}
+
+/*ARGSUSED*/
+static int
+GetAttrOp(
+ ClientData clientData, /* Interpreter-specific data. */
+ Tcl_Interp *interp,
+ int objc, /* Not used. */
+ Tcl_Obj *CONST *objv)
+{
+ PrintQueue *queuePtr;
+
+ if (GetQueueFromObj(interp, objv[2], &queuePtr) != TCL_OK) {
+ return TCL_ERROR;
+ }
+ return GetPrinterAttributes(interp, queuePtr, objv[3]);
+}
+
+/*ARGSUSED*/
+static int
+SetAttrOp(
+ ClientData clientData, /* Interpreter-specific data. */
+ Tcl_Interp *interp,
+ int objc, /* Not used. */
+ Tcl_Obj *CONST *objv)
+{
+ PrintQueue *queuePtr;
+
+ if (GetQueueFromObj(interp, objv[2], &queuePtr) != TCL_OK) {
+ return TCL_ERROR;
+ }
+ return SetQueueAttributes(interp, queuePtr, objv[3]);
+}
+
+/*
+ * --------------------------------------------------------------------------
+ *
+ * SnapOp --
+ *
+ * Prints a snapshot of a Tk_Window to the designated printer.
+ *
+ * Results:
+ * Returns a standard Tcl result. If an error occurred
+ * TCL_ERROR is returned and interp->result will contain an
+ * error message.
+ *
+ * -------------------------------------------------------------------------
+ */
+static int
+SnapOp(
+ ClientData clientData, /* Interpreter-specific data. */
+ Tcl_Interp *interp,
+ int objc,
+ Tcl_Obj *CONST *objv)
+{
+ BITMAPINFO bi;
+ DIBSECTION ds;
+ HBITMAP hBitmap;
+ HPALETTE hPalette;
+ HDC hDC, printDC, memDC;
+ void *data;
+ Tk_Window tkwin;
+ TkWinDCState state;
+ int result;
+ PrintQueue *queuePtr;
+ DOCINFO di;
+ double pageWidth, pageHeight;
+ int jobId;
+ char *driverName;
+ DEVMODE *dmPtr;
+ HGLOBAL hMem;
+ Tcl_DString dString;
+ char *path;
+
+ Tcl_DStringInit(&dString);
+ if (GetQueueFromObj(interp, objv[2], &queuePtr) != TCL_OK) {
+ return TCL_ERROR;
+ }
+ path = Tcl_GetString(objv[3]);
+ tkwin = Tk_NameToWindow(interp, path, Tk_MainWindow(interp));
+ if (tkwin == NULL) {
+ return TCL_ERROR;
+ }
+ if (Tk_WindowId(tkwin) == None) {
+ Tk_MakeWindowExist(tkwin);
+ }
+
+ result = TCL_ERROR;
+ hDC = TkWinGetDrawableDC(Tk_Display(tkwin), Tk_WindowId(tkwin), &state);
+
+ ZeroMemory(&bi, sizeof(bi));
+ bi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
+ bi.bmiHeader.biWidth = Tk_Width(tkwin);
+ bi.bmiHeader.biHeight = Tk_Height(tkwin);
+ bi.bmiHeader.biPlanes = 1;
+ bi.bmiHeader.biBitCount = 32;
+ bi.bmiHeader.biCompression = BI_RGB;
+ hBitmap = CreateDIBSection(hDC, &bi, DIB_RGB_COLORS, &data, NULL, 0);
+ memDC = CreateCompatibleDC(hDC);
+ SelectBitmap(memDC, hBitmap);
+ hPalette = Blt_GetSystemPalette();
+ if (hPalette != NULL) {
+ SelectPalette(hDC, hPalette, FALSE);
+ RealizePalette(hDC);
+ SelectPalette(memDC, hPalette, FALSE);
+ RealizePalette(memDC);
+ }
+ /* Copy the window contents to the memory surface. */
+ if (!BitBlt(memDC, 0, 0, Tk_Width(tkwin), Tk_Height(tkwin), hDC, 0, 0,
+ SRCCOPY)) {
+ Tcl_AppendResult(interp, "can't blit \"", Tk_PathName(tkwin), "\": ",
+ Blt_LastError(), (char *)NULL);
+ goto done;
+ }
+ /* Now that the DIB contains the image of the window, get the
+ * databits and write them to the printer device, stretching the
+ * image to the fit the printer's resolution. */
+ if (GetObject(hBitmap, sizeof(DIBSECTION), &ds) == 0) {
+ Tcl_AppendResult(interp, "can't get DIB object: ", Blt_LastError(),
+ (char *)NULL);
+ goto done;
+ }
+ driverName = NULL;
+ if (Blt_GetPlatformId() == VER_PLATFORM_WIN32_NT) {
+ driverName = queuePtr->driverName;
+ }
+ if (OpenQueue(interp, queuePtr) != TCL_OK) {
+ goto done;
+ }
+ hMem = GetQueueProperties(queuePtr, &dmPtr);
+ if (hMem == NULL) {
+ goto done;
+ }
+ printDC = CreateDC(driverName, queuePtr->deviceName, NULL, dmPtr);
+ GlobalUnlock(hMem);
+ GlobalFree(hMem);
+ if (printDC == NULL) {
+ Tcl_AppendResult(interp, "can't allocate printer DC for \"",
+ queuePtr->name, "\": ", Blt_LastError(), (char *)NULL);
+ goto done;
+ }
+ {
+ double scale, sx, sy;
+
+ /* Get the resolution of the printer device. */
+ sx = (double)GetDeviceCaps(printDC, HORZRES)/(double)Tk_Width(tkwin);
+ sy = (double)GetDeviceCaps(printDC, VERTRES)/(double)Tk_Height(tkwin);
+ scale = MIN(sx, sy);
+ pageWidth = scale * Tk_Width(tkwin);
+ pageHeight = scale * Tk_Height(tkwin);
+ }
+ ZeroMemory(&di, sizeof(di));
+ di.cbSize = sizeof(di);
+ Tcl_DStringAppend(&dString, "Snapshot of \"", -1);
+ Tcl_DStringAppend(&dString, Tk_PathName(tkwin), -1);
+ Tcl_DStringAppend(&dString, "\"", -1);
+ di.lpszDocName = Tcl_DStringValue(&dString);
+ jobId = StartDoc(printDC, &di);
+ if (jobId <= 0) {
+ Tcl_AppendResult(interp, "can't start document: ", Blt_LastError(),
+ (char *)NULL);
+ goto done;
+ }
+ if (StartPage(printDC) <= 0) {
+ Tcl_AppendResult(interp, "error starting page: ", Blt_LastError(),
+ (char *)NULL);
+ goto done;
+ }
+ StretchDIBits(printDC, 0, 0, ROUND(pageWidth), ROUND(pageHeight), 0, 0,
+ Tk_Width(tkwin), Tk_Height(tkwin), ds.dsBm.bmBits,
+ (LPBITMAPINFO)&ds.dsBmih, DIB_RGB_COLORS, SRCCOPY);
+ EndPage(printDC);
+ EndDoc(printDC);
+ DeleteDC(printDC);
+ Tcl_SetResult(interp, Blt_Itoa(jobId), TCL_VOLATILE);
+ result = TCL_OK;
+
+ done:
+ Tcl_DStringFree(&dString);
+ if (queuePtr->hPrinter != NULL) {
+ CloseQueue(queuePtr);
+ }
+ DeleteBitmap(hBitmap);
+ DeleteDC(memDC);
+ TkWinReleaseDrawableDC(Tk_WindowId(tkwin), hDC, &state);
+ if (hPalette != NULL) {
+ DeletePalette(hPalette);
+ }
+ return result;
+}
+
+/*ARGSUSED*/
+static int
+WriteOp(
+ ClientData clientData, /* Interpreter-specific data. */
+ Tcl_Interp *interp,
+ int objc, /* Not used. */
+ Tcl_Obj *CONST *objv)
+{
+ DWORD bytesLeft, nBytes;
+ DOC_INFO_1 di1;
+ DWORD jobId;
+ char *title;
+ register char *data;
+ static int nextJob = 0;
+ char string[200];
+ PrintQueue *queuePtr;
+ int result;
+
+ if (GetQueueFromObj(interp, objv[2], &queuePtr) != TCL_OK) {
+ return TCL_ERROR;
+ }
+ if (OpenQueue(interp, queuePtr) != TCL_OK) {
+ return TCL_ERROR;
+ }
+ if (objc == 5) {
+ title = Tcl_GetString(objv[3]);
+ data = Tcl_GetStringFromObj(objv[4], &bytesLeft);
+ } else {
+ sprintf(string, "Print Job #%d", nextJob++);
+ title = string;
+ data = Tcl_GetStringFromObj(objv[3], &bytesLeft);
+ }
+ ZeroMemory(&di1, sizeof(DOC_INFO_1));
+ di1.pDocName = title;
+ if (queuePtr->fileName != NULL) {
+ di1.pOutputFile = queuePtr->fileName;
+ } else {
+ di1.pOutputFile = NULL;
+ }
+ di1.pDatatype = "RAW";
+
+ result = TCL_ERROR;
+ /* Start new document */
+ jobId = StartDocPrinter(queuePtr->hPrinter, 1, (unsigned char *)&di1);
+ if (jobId == 0) {
+ Tcl_AppendResult(interp, "error starting document on \"",
+ queuePtr->printerName, "\": ", Blt_LastError(), (char *)NULL);
+ goto error;
+ }
+ /* Start new page */
+ if (!StartPagePrinter(queuePtr->hPrinter)) {
+ Tcl_AppendResult(interp, "error starting page on \"",
+ queuePtr->printerName, "\": ", Blt_LastError(), (char *)NULL);
+ goto error;
+ }
+ do {
+ if (!WritePrinter(queuePtr->hPrinter, data, bytesLeft, &nBytes)) {
+ Tcl_AppendResult(interp, "can't write data to \"",
+ queuePtr->printerName, "\": ", Blt_LastError(), (char *)NULL);
+ EndDocPrinter(queuePtr->hPrinter);
+ goto error;
+ }
+ data += nBytes;
+ bytesLeft -= nBytes;
+ } while (bytesLeft > 0);
+ /* End last page */
+ if (!EndPagePrinter(queuePtr->hPrinter)) {
+ Tcl_AppendResult(interp, "error ending page on \"",
+ queuePtr->printerName, "\": ", Blt_LastError(), (char *)NULL);
+ goto error;
+ }
+ /* End document */
+ if (!EndDocPrinter(queuePtr->hPrinter)) {
+ Tcl_AppendResult(interp, "error ending document on \"",
+ queuePtr->printerName, "\": ", Blt_LastError(), (char *)NULL);
+ goto error;
+ }
+ result = TCL_OK;
+ error:
+ CloseQueue(queuePtr);
+ return result;
+}
+
+static Blt_OpSpec printerOps[] =
+{
+ {"close", 1, (Blt_Op)CloseOp, 3, 3, "pid",},
+ {"enum", 1, (Blt_Op)EnumOp, 3, 3, "attribute",},
+ {"getattrs", 1, (Blt_Op)GetAttrOp, 4, 4, "pid varName",},
+ {"names", 1, (Blt_Op)NamesOp, 2, 3, "?pattern?",},
+ {"open", 1, (Blt_Op)OpenOp, 3, 3, "printerName",},
+ {"setattrs", 1, (Blt_Op)SetAttrOp, 4, 4, "pid varName",},
+ {"snap", 1, (Blt_Op)SnapOp, 4, 4, "pid window",},
+ {"write", 1, (Blt_Op)WriteOp, 4, 5, "pid ?title? string",},
+};
+static int nPrinterOps = sizeof(printerOps) / sizeof(Blt_OpSpec);
+
+/* ARGSUSED */
+static int
+PrinterCmd(
+ ClientData clientData, /* Not used. */
+ Tcl_Interp *interp,
+ int objc,
+ Tcl_Obj *CONST *objv)
+{
+ Blt_Op proc;
+ int result;
+
+ proc = Blt_GetOpFromObj(interp, nPrinterOps, printerOps, BLT_OP_ARG1,
+ objc, objv, 0);
+ if (proc == NULL) {
+ return TCL_ERROR;
+ }
+ result = (*proc) (clientData, interp, objc, objv);
+ return result;
+}
+
+/*
+ * -----------------------------------------------------------------------
+ *
+ * PrinterInterpDeleteProc --
+ *
+ * This is called when the interpreter hosting one or more printer
+ * commands is destroyed.
+ *
+ * Results:
+ * None.
+ *
+ * Side effects:
+ * Closes and removes all open printers.
+ *
+ * ------------------------------------------------------------------------
+ */
+/* ARGSUSED */
+static void
+PrinterInterpDeleteProc(clientData, interp)
+ ClientData clientData; /* Interpreter-specific data. */
+ Tcl_Interp *interp;
+{
+ PrinterInterpData *dataPtr = clientData;
+ Blt_HashEntry *hPtr;
+ Blt_HashSearch cursor;
+ PrintQueue *queuePtr;
+
+ for (hPtr = Blt_FirstHashEntry(&dataPtr->printerTable, &cursor);
+ hPtr != NULL; hPtr = Blt_NextHashEntry(&cursor)) {
+ queuePtr = (PrintQueue *)Blt_GetHashValue(hPtr);
+ queuePtr->hashPtr = NULL;
+ DestroyQueue(queuePtr);
+ }
+ Blt_DeleteHashTable(&dataPtr->printerTable);
+ Tcl_DeleteAssocData(interp, PRINTER_THREAD_KEY);
+ Blt_Free(dataPtr);
+}
+
+
+int
+Blt_PrinterInit(Tcl_Interp *interp)
+{
+ static Blt_ObjCmdSpec cmdSpec = {
+ "printer", PrinterCmd
+ };
+ PrinterInterpData *dataPtr;
+
+ dataPtr = GetPrinterInterpData(interp);
+ cmdSpec.clientData = dataPtr;
+ if (Blt_InitObjCmd(interp, "blt", &cmdSpec) == NULL) {
+ return TCL_ERROR;
+ }
+ return TCL_OK;
+}
+\f
+
+/* Public routines */
+int
+Blt_GetOpenPrinter(
+ Tcl_Interp *interp,
+ const char *name,
+ Drawable *drawablePtr)
+{
+ PrintQueue *queuePtr;
+
+ if (GetQueue(interp, name, &queuePtr) != TCL_OK) {
+ return TCL_ERROR;
+ }
+ if (queuePtr->drawable.hDC == NULL) {
+ char *driverName;
+ HGLOBAL hMem;
+ DEVMODE *dmPtr;
+ HDC hDC;
+
+ driverName = NULL;
+ if (Blt_GetPlatformId() == VER_PLATFORM_WIN32_NT) {
+ driverName = queuePtr->driverName;
+ }
+ if (OpenQueue(interp, queuePtr) != TCL_OK) {
+ return TCL_ERROR;
+ }
+ hMem = GetQueueProperties(queuePtr, &dmPtr);
+ if (hMem == NULL) {
+ CloseQueue(queuePtr);
+ return TCL_ERROR;
+ }
+ if (queuePtr->dmPtr != NULL) {
+ *dmPtr = *queuePtr->dmPtr;
+ }
+ hDC = CreateDC(driverName, queuePtr->deviceName, NULL, dmPtr);
+ GlobalUnlock(hMem);
+ GlobalFree(hMem);
+ CloseQueue(queuePtr);
+ if (hDC == NULL) {
+ Tcl_AppendResult(interp, "can't allocate printer DC for \"",
+ queuePtr->name, "\": ", Blt_LastError(), (char *)NULL);
+ return TCL_ERROR;
+ }
+ queuePtr->drawable.hDC = hDC;
+ queuePtr->drawable.type = TWD_WINDC;
+ }
+ *drawablePtr = (Drawable)(&queuePtr->drawable);
+ return TCL_OK;
+}
+
+#include <commdlg.h>
+
+int
+Blt_PrintDialog(
+ Tcl_Interp *interp,
+ Drawable *drawablePtr)
+{
+ PRINTDLG dlg;
+ static PrintDrawable drawable;
+ int mode, result;
+
+ ZeroMemory(&dlg, sizeof(PRINTDLG));
+ dlg.lStructSize = sizeof(PRINTDLG);
+ dlg.Flags = PD_RETURNDC | PD_NOPAGENUMS | PD_NOSELECTION;
+ mode = Tcl_SetServiceMode(TCL_SERVICE_NONE);
+ result = PrintDlg(&dlg);
+ Tcl_SetServiceMode(mode);
+ if (!result) {
+ if (!CommDlgExtendedError()) {
+ return TCL_RETURN; /* User canceled. */
+ }
+ Tcl_AppendResult(interp, "can't access printer:", Blt_LastError(),
+ (char *)NULL);
+ return TCL_ERROR;
+ }
+ *drawablePtr = (Drawable)&drawable;
+ drawable.type = TWD_WINDC;
+ drawable.hDC = dlg.hDC;
+ return TCL_OK;
+}
+
+int
+Blt_StartPrintJob(
+ Tcl_Interp *interp,
+ Drawable drawable)
+{
+ DOCINFO di;
+ PrintDrawable *drawPtr = (PrintDrawable *)drawable;
+ int jobId;
+
+ ZeroMemory((char *)&di, sizeof(DOCINFO));
+ di.cbSize = sizeof(DOCINFO);
+ di.lpszDocName = "Unknown";
+ jobId = StartDoc(drawPtr->hDC, &di);
+ if (jobId == 0) {
+ Tcl_AppendResult(interp, "error starting document: ",
+ Blt_LastError(), (char *)NULL);
+ return TCL_ERROR;
+ }
+ return TCL_OK;
+}
+
+int
+Blt_EndPrintJob(
+ Tcl_Interp *interp,
+ Drawable drawable)
+{
+ PrintDrawable *drawPtr = (PrintDrawable *)drawable;
+
+ EndPage(drawPtr->hDC);
+ EndDoc(drawPtr->hDC);
+ return TCL_OK;
+}
+
+#endif /*NO_PRINTER*/
OSDN Git Service
