/*----------------------------------------------------------------------------*\
| Win32::Printer |
| V 0.9.1 (2008-04-28) |
| Copyright (C) 2003-2005 Edgars Binans |
\*----------------------------------------------------------------------------*/
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"
#ifdef EBBL
#define EBBL_NAL
#include "ebblwc.h"
#endif
#ifdef FREE
#include "FreeImage.h"
#endif
#ifdef GHOST
#include "iapi.h"
#endif
#include <winspool.h>
#include <commdlg.h>
//----------------------------------------------------------------------------//
LPWSTR ToWide(
LPCSTR lpString,
int cbString,
int* sz)
{
LPWSTR lpwString;
// Determine required buffer
*sz = MultiByteToWideChar(CP_UTF8, 0, lpString, cbString, 0, 0);
if (*sz == 0) { return 0; }
// Allocate memory
lpwString = (LPWSTR)malloc(*sz * sizeof(wchar_t));
if (lpwString == 0) { return 0; }
// Convert utf-8 to wide character
*sz = MultiByteToWideChar(CP_UTF8, 0, lpString, cbString, lpwString, *sz);
if (*sz == 0) {
free(lpwString);
return 0;
}
return lpwString;
}
//----------------------------------------------------------------------------//
BOOL GetTextExtentPoint32UTF8(
HDC hdc,
LPCSTR lpString,
int cbString,
LPSIZE lpSize)
{
int sz;
LPWSTR lpwString;
BOOL retVal;
lpwString = ToWide(lpString, cbString, &sz);
// Do unicode GetTextExtentPoint32
retVal = GetTextExtentPoint32W(hdc, lpwString, sz, lpSize);
// Free buffer
free(lpwString);
return retVal;
}
//----------------------------------------------------------------------------//
BOOL
GetTextExtentExPointUTF8(
HDC hdc,
LPCSTR lpszStr,
int cchString,
int nMaxExtent,
LPINT lpnFit,
LPINT alpDx,
LPSIZE lpSize)
{
int sz;
LPWSTR lpwString;
BOOL retVal;
lpwString = ToWide(lpszStr, cchString, &sz);
// Do unicode GetTextExtentExPoint
retVal = GetTextExtentExPointW(hdc, lpwString, sz, nMaxExtent, lpnFit, alpDx, lpSize);
// Free buffer
free(lpwString);
return retVal;
}
//----------------------------------------------------------------------------//
BOOL
TabbedTextOutUTF8(
HDC hdc,
int nXStart,
int nYStart,
LPCSTR lpString,
int cbString,
int nTabPositions,
CONST LPINT lpnTabStopPositions,
int nTabOrigin)
{
int sz;
LPWSTR lpwString;
BOOL retVal;
// Correction for null
int np = (cbString == -1) ? 1 : 0;
lpwString = ToWide(lpString, cbString, &sz);
// Do unicode TextOut
retVal = TabbedTextOutW(hdc, nXStart, nYStart, lpwString, sz - np, nTabPositions, lpnTabStopPositions, nTabOrigin);
// Free buffer
free(lpwString);
return retVal;
}
//----------------------------------------------------------------------------//
int
DrawTextExUTF8(
HDC hdc,
LPSTR lpchText,
int cchText,
LPRECT lprc,
UINT dwDTFormat,
LPDRAWTEXTPARAMS lpDTParams)
{
int sz;
LPWSTR lpwchText;
BOOL retVal;
// Correction for null
int np = (cchText == -1) ? 1 : 0;
lpwchText = ToWide(lpchText, cchText, &sz);
// Do unicode DrawTextExW
retVal = DrawTextExW(hdc, lpwchText, sz - np, lprc, dwDTFormat, lpDTParams);
// Free buffer
free(lpwchText);
return retVal;
}
//----------------------------------------------------------------------------//
int __stdcall
EnumFontFamExProc(
const LOGFONT* lpelfe,
const TEXTMETRIC* lpntme,
DWORD FontType,
LPARAM lParam)
{
char fStyle[12]; fStyle[0] = '\0';
if (lpelfe->lfItalic && lpelfe->lfWeight == 700) { sprintf(fStyle, "bold italic"); }
else if (lpelfe->lfWeight == 700) { sprintf(fStyle, "bold"); }
else if (lpelfe->lfItalic) { sprintf(fStyle, "italic"); }
sv_catpvf((SV*)lParam, "%s\t%d\t%s\t%d\n",
lpelfe->lfFaceName,
lpelfe->lfCharSet,
fStyle,
FontType & 0x0FFFFFFF);
return 1;
}
//----------------------------------------------------------------------------//
#define DI_ERR_SUCCESS 1
#define DI_ERR_ALLOC -1
#define DI_ERR_OPENF -2
#define DI_ERR_OPENPRN -3
#define DI_ERR_START -4
#define DI_ERR_WRITE -5
#define DI_ERR_END -6
#define DI_ERR_CLOSE -7
BOOL
printfile(char* printer, char* filename)
{
HANDLE prnhandle;
DOC_INFO_1 dci1;
char* buffer;
FILE* f;
DWORD count;
DWORD written;
if ((buffer = malloc(4096)) == (char *)NULL) {
return DI_ERR_ALLOC;
}
if ((f = fopen(filename, "rb")) == (FILE *)NULL) {
free(buffer);
return DI_ERR_OPENF;
}
if (!OpenPrinter(printer, &prnhandle, NULL)) {
free(buffer);
fclose(f);
return DI_ERR_OPENPRN;
}
dci1.pDocName = filename;
dci1.pOutputFile = NULL;
dci1.pDatatype = "RAW";
if (!StartDocPrinter(prnhandle, 1, (LPBYTE)&dci1)) {
free(buffer);
fclose(f);
AbortPrinter(prnhandle);
return DI_ERR_START;
}
while ((count = fread(buffer, 1, 4096, f)) != 0 ) {
if (!WritePrinter(prnhandle, (LPVOID)buffer, count, &written)) {
free(buffer);
fclose(f);
AbortPrinter(prnhandle);
return DI_ERR_WRITE;
}
}
free(buffer);
fclose(f);
if (!EndDocPrinter(prnhandle)) {
AbortPrinter(prnhandle);
return DI_ERR_END;
}
if (!ClosePrinter(prnhandle)) {
return DI_ERR_CLOSE;
}
return DI_ERR_SUCCESS;
}
//----------------------------------------------------------------------------//
LONG
exfilt()
{
return EXCEPTION_EXECUTE_HANDLER;
}
//----------------------------------------------------------------------------//
MODULE = Win32::Printer PACKAGE = Win32::Printer
PROTOTYPES: DISABLE
#------------------------------------------------------------------------------#
int
_IsNo(pv)
const char* pv;
CODE:
RETVAL = grok_number(pv, strlen(pv), NULL);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
LPSTR
_GetLastError()
PREINIT:
char msg[255];
CODE:
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(), 0, msg, 255, NULL);
RETVAL = msg;
OUTPUT:
RETVAL
unsigned int
_Get3PLibs()
CODE:
RETVAL = 0x00000000;
#ifdef FREE
RETVAL |= 0x00000001;
#endif
#ifdef GHOST
RETVAL |= 0x00000002;
#endif
#ifdef EBBL
RETVAL |= 0x00000004;
#endif
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
HDC
_CreatePrinter(printer, dialog, Flags, copies, collate, minp, maxp, orient, papersize, duplex, source, color, height, width)
LPSTR printer;
BOOL dialog;
int Flags;
int copies;
int collate;
int minp;
int maxp;
int orient;
int papersize;
int duplex;
int source;
int color;
int height;
int width;
PREINIT:
DWORD error;
PRINTDLG *lppd;
DEVMODE *lpdm;
DEVNAMES *lpdn;
LPSTR pPrinterName;
int printlen;
HGLOBAL newDevNames;
LPSTR dnch;
LPSTR winspool = "winspool";
CODE:
RETVAL = (HDC) NULL;
Newz(0, lppd, 1, PRINTDLG);
lppd->lStructSize = sizeof(PRINTDLG);
lppd->Flags = PD_RETURNDEFAULT;
if (PrintDlg(lppd)) {
lpdm = GlobalLock(lppd->hDevMode);
if (height > 0 && width > 0) {
lpdm->dmFields |= DM_PAPERLENGTH;
lpdm->dmFields |= DM_PAPERWIDTH;
lpdm->dmPaperLength = height;
lpdm->dmPaperWidth = width;
} else {
lpdm->dmFields |= DM_PAPERSIZE;
lpdm->dmPaperSize = papersize;
}
if (orient == 1 || orient == 2) {
lpdm->dmFields |= DM_ORIENTATION;
lpdm->dmOrientation = orient;
}
if (duplex == 1 || duplex == 2 || duplex == 3) {
lpdm->dmFields |= DM_DUPLEX;
lpdm->dmDuplex = duplex;
}
lpdm->dmFields |= DM_COPIES | DM_COLLATE | DM_DEFAULTSOURCE | DM_COLOR;
lpdm->dmCopies = copies;
lpdm->dmCollate = collate;
lpdm->dmDefaultSource = source;
lpdm->dmColor = color;
if (dialog == 0) {
lpdn = GlobalLock(lppd->hDevNames);
if (strlen(printer) != 0) {
RETVAL = CreateDC("winspool", printer, NULL, lpdm);
} else {
New(0, pPrinterName, lpdn->wOutputOffset - lpdn->wDeviceOffset, char);
Copy((LPSTR )lpdn + lpdn->wDeviceOffset, pPrinterName, lpdn->wOutputOffset - lpdn->wDeviceOffset, char);
RETVAL = CreateDC("winspool", pPrinterName, NULL, lpdm);
Safefree(pPrinterName);
}
} else {
lppd->nFromPage = minp;
lppd->nToPage = maxp;
lppd->nMinPage = minp;
lppd->nMaxPage = maxp;
printlen = strlen(printer) < 32 ? (strlen(printer) + 1) : 32;
newDevNames = GlobalAlloc(GMEM_MOVEABLE, 17 + printlen);
dnch = GlobalLock(newDevNames);
Copy(winspool, dnch + 8, 9, char);
Copy(printer, dnch + 17, printlen, char);
dnch[17 + printlen] = '\0';
lpdn = (DEVNAMES *)dnch;
lpdn->wDriverOffset = 8;
lpdn->wDeviceOffset = 17;
lpdn->wOutputOffset = 17 + printlen;
lpdn->wDefault = 1;
lppd->hDevNames = newDevNames;
Copy(printer, lpdm->dmDeviceName, printlen, char);
lppd->Flags = PD_RETURNDC | Flags;
if (PrintDlg(lppd)) {
RETVAL = lppd->hDC;
Flags = lppd->Flags;
copies = lpdm->dmCopies;
collate = lpdm->dmCollate;
minp = lppd->nFromPage;
maxp = lppd->nToPage;
}
}
error = GetLastError();
GlobalUnlock(lppd->hDevNames);
GlobalUnlock(lppd->hDevMode);
}
Safefree(lppd);
if (RETVAL) {
SetGraphicsMode(RETVAL, GM_ADVANCED);
} else {
if (dialog == 0) {
SetLastError(error);
} else {
if (CommDlgExtendedError()) {
croak("Print dialog error!\n");
} else {
SetLastError(ERROR_CANCELLED);
}
}
}
OUTPUT:
Flags
copies
collate
minp
maxp
RETVAL
#------------------------------------------------------------------------------#
LPCSTR
_SaveAs(index, suggest, indir)
int index;
LPSTR suggest;
LPCSTR indir;
PREINIT:
OPENFILENAME ofn;
char file[MAX_PATH];
CODE:
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.hwndOwner = NULL;
ofn.lpstrFilter = "Print files (*.prn, *.ps, *.pcl, *.afp)\0*.prn;*.ps;*.pcl;*.afp\0PDF files (*.pdf)\0*.pdf\0Enhenced Metafiles (*.emf)\0*.emf\0All files (*.*)\0*.*\0";
ofn.lpstrCustomFilter = NULL;
ofn.nFilterIndex = index;
strcpy(file, suggest);
ofn.lpstrFile = file;
ofn.nMaxFile = MAX_PATH;
ofn.lpstrFileTitle = NULL;
if (indir[0] == '\0') {
ofn.lpstrInitialDir = PerlEnv_get_childdir();
} else {
ofn.lpstrInitialDir = indir;
}
ofn.lpstrTitle = "Win32::Printer - Save As";
ofn.Flags = OFN_NOCHANGEDIR | OFN_EXPLORER | OFN_PATHMUSTEXIST;
if (index == 3) {
ofn.Flags |= OFN_OVERWRITEPROMPT;
}
if (GetSaveFileName(&ofn)) {
RETVAL = ofn.lpstrFile;
} else {
if (CommDlgExtendedError()) {
croak("Save As dialog error!\n");
} else {
SetLastError(ERROR_CANCELLED);
}
RETVAL = "";
}
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
LPCSTR
_Open(index, multi)
int index;
int multi;
PREINIT:
OPENFILENAME ofn;
char file[MAX_PATH];
CODE:
int x = 0;
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.hwndOwner = NULL;
ofn.lpstrFilter = "Print files (*.prn, *.ps, *.pcl, *.afp)\0*.prn;*.ps;*.pcl;*.afp\0PDF files (*.pdf)\0*.pdf\0Enhenced Metafiles (*.emf)\0*.emf\0All files (*.*)\0*.*\0";
ofn.lpstrCustomFilter = NULL;
ofn.nFilterIndex = index;
file[0] = '\0';
ofn.lpstrFile = file;
ofn.nMaxFile = 65535;
ofn.lpstrFileTitle = NULL;
ofn.lpstrInitialDir = NULL;
ofn.lpstrTitle = "Win32::Printer - Open";
ofn.Flags = OFN_NOCHANGEDIR | OFN_EXPLORER | OFN_HIDEREADONLY;
if (multi == 1) {
ofn.Flags |= OFN_ALLOWMULTISELECT;
}
if (GetOpenFileName(&ofn)) {
if (multi == 1) {
while (1) {
if ((ofn.lpstrFile[x] == '\0') && (ofn.lpstrFile[x + 1] != '\0')) {
ofn.lpstrFile[x] = 42;
} else if ((ofn.lpstrFile[x] == '\0') && (ofn.lpstrFile[x + 1] == '\0')) {
break;
}
x++;
}
}
RETVAL = ofn.lpstrFile;
} else {
if (CommDlgExtendedError()) {
croak("Open dialog error!\n");
} else {
SetLastError(ERROR_CANCELLED);
}
RETVAL = "";
}
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
BOOL
_DeleteDC(hdc)
HDC hdc;
CODE:
RETVAL = DeleteDC(hdc);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
int
_StartDoc(hdc, DocName, FileName)
HDC hdc;
LPCSTR DocName;
LPCSTR FileName;
PREINIT:
DOCINFO di;
CODE:
di.cbSize = sizeof(DOCINFO);
di.lpszDocName = DocName;
di.lpszOutput = FileName;
di.lpszDatatype = NULL;
di.fwType = 0;
RETVAL = StartDoc(hdc, &di);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
int
_EndDoc(hdc)
HDC hdc;
CODE:
RETVAL = EndDoc(hdc);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
int
_AbortDoc(hdc)
HDC hdc;
CODE:
RETVAL = AbortDoc(hdc);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
int
_StartPage(hdc)
HDC hdc;
CODE:
RETVAL = StartPage(hdc);
SetBkMode(hdc, TRANSPARENT);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
int
_EndPage(hdc)
HDC hdc;
CODE:
RETVAL = EndPage(hdc);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
HGDIOBJ
_SelectObject(hdc, hgdiobj)
HDC hdc;
HGDIOBJ hgdiobj;
CODE:
RETVAL = SelectObject(hdc, hgdiobj);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
HGDIOBJ
_CopyObject(hdc1, hdc2, ot)
HDC hdc1;
HDC hdc2;
UINT ot;
CODE:
RETVAL = SelectObject(hdc2, GetCurrentObject(hdc1, ot));
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
BOOL
_DeleteObject(hObject);
HGDIOBJ hObject;
CODE:
RETVAL = DeleteObject(hObject);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
int
_GetDeviceCaps(hdc, nIndex)
HDC hdc;
int nIndex;
CODE:
RETVAL = GetDeviceCaps(hdc, nIndex);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
BOOL
_SetWorldTransform(hdc, eM11, eM12, eM21, eM22, eDx, eDy)
HDC hdc;
FLOAT eM11;
FLOAT eM12;
FLOAT eM21;
FLOAT eM22;
FLOAT eDx;
FLOAT eDy;
PREINIT:
XFORM Xform;
CODE:
Xform.eM11 = eM11;
Xform.eM12 = eM12;
Xform.eM21 = eM21;
Xform.eM22 = eM22;
Xform.eDx = eDx;
Xform.eDy = eDy;
RETVAL = SetWorldTransform(hdc, &Xform);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
int
_IsNT()
CODE:
OSVERSIONINFO osi;
osi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
GetVersionEx(&osi);
if (osi.dwPlatformId == VER_PLATFORM_WIN32_NT) {
RETVAL = 1;
} else {
RETVAL = 0;
}
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
HFONT
_CreateFont(Height, Escapement, Orientation, Weight, Italic, Underline, StrikeOut, CharSet, FaceName)
long Height;
long Escapement;
long Orientation;
long Weight;
BYTE Italic;
BYTE Underline;
BYTE StrikeOut;
BYTE CharSet;
LPCSTR FaceName;
CODE:
LOGFONT lf;
int len = strlen(FaceName);
lf.lfHeight = -Height;
lf.lfWidth = 0;
lf.lfEscapement = Escapement;
lf.lfOrientation = Orientation;
lf.lfWeight = Weight;
lf.lfItalic = Italic;
lf.lfUnderline = Underline;
lf.lfStrikeOut = StrikeOut;
lf.lfCharSet = CharSet;
lf.lfOutPrecision = OUT_DEFAULT_PRECIS;
lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
lf.lfQuality = PROOF_QUALITY;
lf.lfPitchAndFamily = DEFAULT_PITCH;
if (len > 31) {
memcpy(lf.lfFaceName, FaceName, 32);
} else {
memcpy(lf.lfFaceName, FaceName, len + 1);
}
RETVAL = CreateFontIndirect(&lf);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
SV*
_GetTextFace(hdc)
HDC hdc;
CODE:
char face[32];
RETVAL = newSVpvn("", 0);
GetTextFace(hdc, 32, face);
sv_catpv(RETVAL, face);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
BOOL
_GetTextExtentPoint(vers, hdc, lpszStr, nMaxExtent, nFit, cx, cy)
int vers;
HDC hdc;
LPCSTR lpszStr;
int nMaxExtent;
int nFit;
LONG cx;
LONG cy;
PREINIT:
SIZE Size;
CODE:
switch (vers) {
case 1:
RETVAL = GetTextExtentExPointUTF8(hdc, lpszStr, strlen(lpszStr), nMaxExtent, &nFit, NULL, &Size);
break;
default:
RETVAL = GetTextExtentExPoint(hdc, lpszStr, strlen(lpszStr), nMaxExtent, &nFit, NULL, &Size);
}
cx = Size.cx;
cy = Size.cy;
OUTPUT:
nFit
cx
cy
RETVAL
#------------------------------------------------------------------------------#
LONG
_TextOut(vers, hdc, nXStart, nYStart, lpString, align)
int vers;
HDC hdc;
int nXStart;
int nYStart;
LPCSTR lpString;
int align;
CODE:
SetTextAlign(hdc, align);
switch (vers) {
case 1:
RETVAL = TabbedTextOutUTF8(hdc, nXStart, nYStart, lpString, strlen(lpString), 0, NULL, nXStart);
break;
default:
RETVAL = TabbedTextOut(hdc, nXStart, nYStart, lpString, strlen(lpString), 0, NULL, nXStart);
}
SetTextAlign(hdc, TA_LEFT);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
int
_DrawText(vers, hdc, lpString, x1, y1, x2, y2, uFormat, uiLengthDrawn, tabStop)
int vers;
HDC hdc;
LPSTR lpString;
LONG x1;
LONG y1;
LONG x2;
LONG y2;
UINT uFormat;
UINT uiLengthDrawn;
UINT tabStop;
PREINIT:
RECT Rect;
DRAWTEXTPARAMS DTParams;
CODE:
Rect.left = x1;
Rect.top = y1;
Rect.right = x2;
Rect.bottom = y2;
DTParams.cbSize = sizeof(DRAWTEXTPARAMS);
DTParams.iTabLength = tabStop;
DTParams.iLeftMargin = 0;
DTParams.iRightMargin = 0;
switch (vers) {
case 1:
RETVAL = DrawTextExUTF8(hdc, lpString, -1, &Rect, uFormat | DT_TABSTOP | DT_NOPREFIX, &DTParams);
break;
default:
RETVAL = DrawTextEx(hdc, lpString, -1, &Rect, uFormat | DT_TABSTOP | DT_NOPREFIX, &DTParams);
}
x2 = Rect.right;
y2 = Rect.bottom;
uiLengthDrawn = DTParams.uiLengthDrawn;
OUTPUT:
x2
uiLengthDrawn
lpString
RETVAL
#------------------------------------------------------------------------------#
COLORREF
_SetTextColor(hdc, coloRef)
HDC hdc;
int coloRef;
CODE:
RETVAL = SetTextColor(hdc, coloRef);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
COLORREF
_CopyTextColor(hdc1, hdc2)
HDC hdc1;
HDC hdc2;
CODE:
RETVAL = SetTextColor(hdc2, GetTextColor(hdc1));
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
int
_SetTextCharacterExtra(hdc, nCharExtra)
HDC hdc;
int nCharExtra;
CODE:
RETVAL = SetTextCharacterExtra(hdc, nCharExtra);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
BOOL
_SetJustify(vers, hdc, string, width)
int vers;
HDC hdc;
LPCSTR string;
int width;
PREINIT:
SIZE size;
TEXTMETRIC tm;
BOOL gtep = FALSE;
int spaces = 0;
int len = 0;
LPCSTR str = string;
CODE:
if (width > -1) {
GetTextMetrics(hdc, &tm);
while (*str != '\0') {
if (*str == tm.tmBreakChar) {
spaces++;
}
str++;
len++;
}
switch (vers) {
case 1:
gtep = GetTextExtentPoint32UTF8(hdc, string, len, &size);
break;
default:
gtep = GetTextExtentPoint32(hdc, string, len, &size);
}
if (gtep) {
RETVAL = SetTextJustification(hdc, width - size.cx, spaces);
} else {
RETVAL = FALSE;
}
} else {
RETVAL = SetTextJustification(hdc, 0, 0);
}
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
HPEN
_CreatePen(fnPenStyle, nWidth, cRed, cGreen, cBlue)
int fnPenStyle;
int nWidth;
BYTE cRed;
BYTE cGreen;
BYTE cBlue;
PREINIT:
LOGBRUSH lb;
CODE:
lb.lbStyle = BS_SOLID;
lb.lbColor = RGB(cRed, cGreen, cBlue);
lb.lbHatch = NULL;
RETVAL = ExtCreatePen(fnPenStyle, nWidth, &lb, 0, NULL);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
BOOL
_MoveTo(hdc, X, Y)
HDC hdc;
int X;
int Y;
PREINIT:
POINT Point;
CODE:
RETVAL = MoveToEx(hdc, X, Y, &Point);
X = Point.x;
Y = Point.y;
OUTPUT:
X
Y
RETVAL
#------------------------------------------------------------------------------#
BOOL
_Polyline(hdc, ...)
HDC hdc;
PREINIT:
POINT *lpPoints;
int i, j;
CODE:
New(0, lpPoints, items, POINT);
i = 1; j = 0;
while (i < items) {
lpPoints[j].x = SvIV(ST(i));
i++;
lpPoints[j].y = SvIV(ST(i));
i++; j++;
}
RETVAL = Polyline(hdc, lpPoints, (items-1) / 2);
Safefree(lpPoints);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
BOOL
_PolylineTo(hdc, ...)
HDC hdc;
PREINIT:
POINT *lpPoints;
int i, j;
CODE:
New(0, lpPoints, items, POINT);
i = 1; j = 0;
while (i < items) {
lpPoints[j].x = SvIV(ST(i));
i++;
lpPoints[j].y = SvIV(ST(i));
i++; j++;
}
RETVAL = PolylineTo(hdc, lpPoints, (items - 1) / 2);
Safefree(lpPoints);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
HBRUSH
_CreateBrushIndirect(lbStyle, lbHatch, cRed, cGreen, cBlue)
UINT lbStyle;
LONG lbHatch;
BYTE cRed;
BYTE cGreen;
BYTE cBlue;
PREINIT:
LOGBRUSH lb;
CODE:
lb.lbStyle = lbStyle;
lb.lbColor = RGB(cRed, cGreen, cBlue);
lb.lbHatch = lbHatch;
RETVAL = CreateBrushIndirect(&lb);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
int
_SetPolyFillMode(hdc, iPolyFillMode)
HDC hdc;
int iPolyFillMode;
CODE:
RETVAL = SetPolyFillMode(hdc, iPolyFillMode);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
BOOL
_Rectangle(hdc, nLeftRect, nTopRect, nRightRect, nBottomRect)
HDC hdc;
int nLeftRect;
int nTopRect;
int nRightRect;
int nBottomRect;
CODE:
RETVAL = Rectangle(hdc, nLeftRect, nTopRect, nRightRect, nBottomRect);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
BOOL
_RoundRect(hdc, nLeftRect, nTopRect, nRightRect, nBottomRect, nWidth, nHeight)
HDC hdc;
int nLeftRect;
int nTopRect;
int nRightRect;
int nBottomRect;
int nWidth;
int nHeight;
CODE:
RETVAL = RoundRect(hdc, nLeftRect, nTopRect, nRightRect, nBottomRect, nWidth, nHeight);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
BOOL
_Ellipse(hdc, nLeftRect, nTopRect, nRightRect, nBottomRect)
HDC hdc;
int nLeftRect;
int nTopRect;
int nRightRect;
int nBottomRect;
CODE:
RETVAL = Ellipse(hdc, nLeftRect, nTopRect, nRightRect, nBottomRect);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
BOOL
_Chord(hdc, nLeftRect, nTopRect, nRightRect, nBottomRect, nXRadial1, nYRadial1, nXRadial2, nYRadial2)
HDC hdc;
int nLeftRect;
int nTopRect;
int nRightRect;
int nBottomRect;
int nXRadial1;
int nYRadial1;
int nXRadial2;
int nYRadial2;
CODE:
RETVAL = Chord(hdc, nLeftRect, nTopRect, nRightRect, nBottomRect, nXRadial1, nYRadial1, nXRadial2, nYRadial2);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
BOOL
_Pie(hdc, nLeftRect, nTopRect, nRightRect, nBottomRect, nXRadial1, nYRadial1, nXRadial2, nYRadial2)
HDC hdc;
int nLeftRect;
int nTopRect;
int nRightRect;
int nBottomRect;
int nXRadial1;
int nYRadial1;
int nXRadial2;
int nYRadial2;
CODE:
RETVAL = Pie(hdc, nLeftRect, nTopRect, nRightRect, nBottomRect, nXRadial1, nYRadial1, nXRadial2, nYRadial2);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
BOOL
_Polygon(hdc, ...)
HDC hdc;
PREINIT:
POINT *Points;
int i, j;
CODE:
New(0, Points, items, POINT);
i = 1; j = 0;
while (i < items) {
Points[j].x = SvIV(ST(i));
i++;
Points[j].y = SvIV(ST(i));
i++; j++;
}
RETVAL = Polygon(hdc, Points, (items-1) / 2);
Safefree(Points);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
BOOL
_PolyBezier(hdc, ...)
HDC hdc;
PREINIT:
POINT *Points;
int i, j;
CODE:
New(0, Points, items, POINT);
i = 1; j = 0;
while (i < items) {
Points[j].x = SvIV(ST(i));
i++;
Points[j].y = SvIV(ST(i));
i++; j++;
}
RETVAL = PolyBezier(hdc, Points, (items-1) / 2);
Safefree(Points);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
BOOL
_PolyBezierTo(hdc, ...)
HDC hdc;
PREINIT:
POINT *Points;
int i, j;
CODE:
New(0, Points, items, POINT);
i = 1; j = 0;
while (i < items) {
Points[j].x = SvIV(ST(i));
i++;
Points[j].y = SvIV(ST(i));
i++; j++;
}
RETVAL = PolyBezierTo(hdc, Points, (items-1) / 2);
Safefree(Points);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
BOOL
_Arc(hdc, nLeftRect, nTopRect, nRightRect, nBottomRect, nXRadial1, nYRadial1, nXRadial2, nYRadial2)
HDC hdc;
int nLeftRect;
int nTopRect;
int nRightRect;
int nBottomRect;
int nXRadial1;
int nYRadial1;
int nXRadial2;
int nYRadial2;
CODE:
RETVAL = Arc(hdc, nLeftRect, nTopRect, nRightRect, nBottomRect, nXRadial1, nYRadial1, nXRadial2, nYRadial2);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
BOOL
_ArcTo(hdc, nLeftRect, nTopRect, nRightRect, nBottomRect, nXRadial1, nYRadial1, nXRadial2, nYRadial2)
HDC hdc;
int nLeftRect;
int nTopRect;
int nRightRect;
int nBottomRect;
int nXRadial1;
int nYRadial1;
int nXRadial2;
int nYRadial2;
CODE:
RETVAL = ArcTo(hdc, nLeftRect, nTopRect, nRightRect, nBottomRect, nXRadial1, nYRadial1, nXRadial2, nYRadial2);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
BOOL
_BeginPath(hdc)
HDC hdc;
CODE:
RETVAL = BeginPath(hdc);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
BOOL
_EndPath(hdc)
HDC hdc;
CODE:
RETVAL = EndPath(hdc);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
BOOL
_AbortPath(hdc)
HDC hdc;
CODE:
RETVAL = AbortPath(hdc);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
BOOL
_StrokeAndFillPath(hdc)
HDC hdc;
CODE:
RETVAL = StrokeAndFillPath(hdc);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
BOOL
_SelectClipPath(hdc, iMode)
HDC hdc;
int iMode;
CODE:
RETVAL = SelectClipPath(hdc, iMode);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
int
_DeleteClipPath(hdc)
HDC hdc;
CODE:
RETVAL = SelectClipRgn(hdc, NULL);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
HENHMETAFILE
_GetWinMetaFile(hdc, lpszMetaFile)
HDC hdc;
LPCSTR lpszMetaFile;
PREINIT:
typedef struct {
DWORD key;
WORD hmf;
_int16 left;
_int16 top;
_int16 right;
_int16 bottom;
WORD inch;
DWORD reserved;
WORD checksum;
} METAFILE_HEADER, *PMETAFILE_HEADER;
HMETAFILE hmf;
HENHMETAFILE hemf = NULL;
LPVOID mfb;
BYTE *Data;
PerlIO *file;
METAFILEPICT mfp;
METAFILE_HEADER MfHdr;
UINT nSize;
LPCSTR lpPathName = PerlEnv_get_childdir();
CODE:
SetCurrentDirectory(lpPathName);
hmf = GetMetaFile(lpszMetaFile);
mfp.mm = MM_ANISOTROPIC;
mfp.xExt = -1;
mfp.yExt = -1;
mfp.hMF = NULL;
if (hmf == NULL) {
file = PerlIO_open(lpszMetaFile, "rb");
if (file != NULL) {
PerlIO_read(file, &MfHdr, sizeof(METAFILE_HEADER));
mfp.xExt = (long)((MfHdr.right - MfHdr.left) * 2540.9836 / MfHdr.inch);
mfp.yExt = (long)((MfHdr.bottom - MfHdr.top) * 2540.9836 / MfHdr.inch);
PerlIO_seek(file, 0, SEEK_END);
nSize = (UINT) PerlIO_tell(file) - 22;
New(0, Data, nSize, BYTE);
PerlIO_seek(file, 22, 0);
PerlIO_read(file, Data, nSize);
hmf = SetMetaFileBitsEx(nSize, Data);
Safefree(Data);
PerlIO_close(file);
}
}
if (hmf != NULL) {
nSize = GetMetaFileBitsEx(hmf, NULL, NULL);
New(0, mfb, nSize, LPVOID);
nSize = GetMetaFileBitsEx(hmf, nSize, mfb);
hemf = SetWinMetaFileBits(nSize, mfb, hdc, &mfp);
Safefree(mfb);
}
RETVAL = hemf;
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
int
_EBbl(hdc, emf, string, x, y, flags, baw, bah)
HDC hdc;
HENHMETAFILE emf;
LPSTR string;
int x;
int y;
unsigned flags;
int baw;
int bah;
PREINIT:
#ifdef EBBL
ebc_t ebc;
HPEN pen;
HPEN prepen;
HFONT font;
HBRUSH brush;
#endif
CODE:
RETVAL = NULL;
#ifdef EBBL
ebc.flags = flags;
ebc.baw = baw;
ebc.bah = bah;
__try {
if (emf) {
brush = GetCurrentObject(hdc, OBJ_BRUSH);
font = GetCurrentObject(hdc, OBJ_FONT);
hdc = CreateEnhMetaFile(hdc, NULL, NULL, NULL);
SelectObject(hdc, brush);
SelectObject(hdc, font);
SetBkMode(hdc, TRANSPARENT);
}
pen = CreatePen(PS_NULL, 1, 0xFFFFFFFF);
prepen = SelectObject(hdc, pen);
ebc.hdc = hdc;
RETVAL = EBbl(&ebc, string, x, y);
SelectObject(hdc, prepen);
DeleteObject(pen);
if (emf) {
emf = CloseEnhMetaFile(hdc);
}
}
__except (exfilt()) {
RETVAL = 64;
}
#else
croak("EBbl is not supported in this build!\n");
#endif
OUTPUT:
emf
RETVAL
#------------------------------------------------------------------------------#
HENHMETAFILE
_GetEnhMetaFile(lpszMetaFile)
LPCSTR lpszMetaFile;
PREINIT:
HENHMETAFILE hemf;
LPSTR dir = PerlEnv_get_childdir();
CODE:
SetCurrentDirectory(dir);
hemf = GetEnhMetaFile(lpszMetaFile);
RETVAL = hemf;
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
HENHMETAFILE
_LoadBitmap(hdc, BmpFile, Type, du);
HDC hdc;
LPCSTR BmpFile;
int Type;
int du;
PREINIT:
#ifdef FREE
LPSTR dir = PerlEnv_get_childdir();
FIBITMAP *Image;
BITMAPINFO *lpbmi;
double resolutionX = 72;
double resolutionY = 72;
#endif
CODE:
RETVAL = NULL;
#ifdef FREE
SetCurrentDirectory(dir);
__try {
if (Type == FIF_UNKNOWN) {
Type = FreeImage_GetFIFFromFilename(BmpFile);
if (Type == FIF_UNKNOWN) {
Type = FreeImage_GetFileType(BmpFile, 16);
}
}
if ((Type != FIF_UNKNOWN) && FreeImage_FIFSupportsReading(Type)) {
Image = FreeImage_Load(Type, BmpFile, 0);
if (Image) {
lpbmi = (BITMAPINFO *) FreeImage_GetInfo(Image);
hdc = CreateEnhMetaFile(hdc, NULL, NULL, NULL);
if (du) {
if (lpbmi->bmiHeader.biXPelsPerMeter && lpbmi->bmiHeader.biYPelsPerMeter) {
resolutionX = lpbmi->bmiHeader.biXPelsPerMeter / 39.35483881;
resolutionY = lpbmi->bmiHeader.biYPelsPerMeter / 39.35483881;
}
StretchDIBits(hdc, 0, 0, (int)(GetDeviceCaps(hdc, LOGPIXELSX) * lpbmi->bmiHeader.biWidth / resolutionX), (int)(GetDeviceCaps(hdc, LOGPIXELSY) * lpbmi->bmiHeader.biHeight / resolutionY), 0, 0, lpbmi->bmiHeader.biWidth, lpbmi->bmiHeader.biHeight, (CONST VOID *) FreeImage_GetBits(Image), lpbmi, DIB_RGB_COLORS, SRCCOPY);
} else {
StretchDIBits(hdc, 0, 0, lpbmi->bmiHeader.biWidth, lpbmi->bmiHeader.biHeight, 0, 0, lpbmi->bmiHeader.biWidth, lpbmi->bmiHeader.biHeight, (CONST VOID *) FreeImage_GetBits(Image), lpbmi, DIB_RGB_COLORS, SRCCOPY);
}
RETVAL = CloseEnhMetaFile(hdc);
FreeImage_Unload(Image);
} else {
if (!GetLastError()) {
SetLastError(ERROR_INVALID_DATA);
}
}
} else {
Image = 0;
}
}
__except (exfilt()) {
Image = 0;
}
#else
croak("FreeImage is not supported in this build!\n");
#endif
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
BOOL
_PlayEnhMetaFile(hdc, hemf, nLeftRect, nTopRect, nRightRect, nBottomRect)
HDC hdc;
HENHMETAFILE hemf;
int nLeftRect;
int nTopRect;
int nRightRect;
int nBottomRect;
PREINIT:
RECT Rect;
CODE:
Rect.left = nLeftRect;
Rect.top = nTopRect;
Rect.right = nRightRect;
Rect.bottom = nBottomRect;
RETVAL = PlayEnhMetaFile(hdc, hemf, &Rect);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
UINT
_GetEnhSize(hdc, hemf, right, bottom, du)
HDC hdc;
HENHMETAFILE hemf;
double right;
double bottom;
int du;
PREINIT:
ENHMETAHEADER emh;
CODE:
RETVAL = GetEnhMetaFileHeader(hemf, sizeof(ENHMETAHEADER), &emh);
if (du) {
right = (emh.rclFrame.right - emh.rclFrame.left) * GetDeviceCaps(hdc, LOGPIXELSX) / 2540.9836;
bottom = (emh.rclFrame.bottom - emh.rclFrame.top) * GetDeviceCaps(hdc, LOGPIXELSY) / 2540.9836;
} else {
right = (emh.rclBounds.right - emh.rclBounds.left);
bottom = (emh.rclBounds.bottom - emh.rclBounds.top);
}
OUTPUT:
right
bottom
#------------------------------------------------------------------------------#
BOOL
_DeleteEnhMetaFile(hemf)
HENHMETAFILE hemf;
CODE:
RETVAL = DeleteEnhMetaFile(hemf);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
SV*
_EnumPrinters(Flags, Server)
int Flags;
LPSTR Server;
PREINIT:
int rc;
LPBYTE buffer;
DWORD needed, returned;
PRINTER_INFO_2 *pri2;
unsigned int i;
CODE:
SV* retval = newSVpvn("", 0);
EnumPrinters(Flags, Server, 2, NULL, 0, &needed, &returned);
New(0, buffer, needed, BYTE);
rc = EnumPrinters(Flags, Server, 2, buffer, needed, &needed, &returned);
pri2 = (PRINTER_INFO_2 *) buffer;
if ((rc) && (returned)) {
for (i = 0; i < returned; i++) {
sv_catpvf(retval, "%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t\n",
pri2[i].pServerName,
pri2[i].pPrinterName,
pri2[i].pShareName,
pri2[i].pPortName,
pri2[i].pDriverName,
pri2[i].pComment,
pri2[i].pLocation,
pri2[i].pSepFile,
pri2[i].pPrintProcessor,
pri2[i].pDatatype,
pri2[i].pParameters,
pri2[i].Attributes,
pri2[i].Priority,
pri2[i].DefaultPriority,
pri2[i].StartTime,
pri2[i].UntilTime,
pri2[i].Status,
pri2[i].cJobs,
pri2[i].AveragePPM
);
}
}
Safefree(buffer);
RETVAL = retval;
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
SV*
_EnumPrinterDrivers(Server, Env)
LPSTR Server;
LPSTR Env;
PREINIT:
int rc;
LPBYTE buffer;
DWORD needed, returned;
DRIVER_INFO_3 *dri3;
unsigned int i;
unsigned int x = 0;
CODE:
SV* retval = newSVpvn("", 0);
EnumPrinterDrivers(Server, Env, 3, NULL, 0, &needed, &returned);
New(0, buffer, needed, BYTE);
rc = EnumPrinterDrivers(Server, Env, 3, buffer, needed, &needed, &returned);
dri3 = (DRIVER_INFO_3 *) buffer;
if ((rc) && (returned)) {
for (i = 0; i < returned; i++) {
if (dri3[i].pDependentFiles != NULL) {
while (1) {
if ((dri3[i].pDependentFiles[x] == '\0') && (dri3[i].pDependentFiles[x + 1] != '\0')) {
dri3[i].pDependentFiles[x] = 42;
} else if ((dri3[i].pDependentFiles[x] == '\0') && (dri3[i].pDependentFiles[x + 1] == '\0')) {
break;
}
x++;
}
}
sv_catpvf(retval, "%d\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n",
dri3[i].cVersion,
dri3[i].pName,
dri3[i].pEnvironment,
dri3[i].pDriverPath,
dri3[i].pDataFile,
dri3[i].pConfigFile,
dri3[i].pHelpFile,
dri3[i].pDependentFiles,
dri3[i].pMonitorName,
dri3[i].pDefaultDataType
);
}
}
Safefree(buffer);
RETVAL = retval;
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
SV*
_EnumPorts(Server)
LPSTR Server;
PREINIT:
int rc;
LPBYTE buffer;
DWORD needed, returned;
PORT_INFO_2 *pi2;
unsigned int i;
CODE:
SV* retval = newSVpvn("", 0);
EnumPorts(Server, 2, NULL, 0, &needed, &returned);
New(0, buffer, needed, BYTE);
rc = EnumPorts(Server, 2, buffer, needed, &needed, &returned);
pi2 = (PORT_INFO_2 *) buffer;
if ((rc) && (returned)) {
for (i = 0; i < returned; i++) {
sv_catpvf(retval, "%s\t%s\t%s\t%d\n",
pi2[i].pPortName,
pi2[i].pMonitorName,
pi2[i].pDescription,
pi2[i].fPortType
);
}
}
Safefree(buffer);
RETVAL = retval;
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
SV*
_EnumMonitors(Server)
LPSTR Server;
PREINIT:
int rc;
LPBYTE buffer;
DWORD needed, returned;
MONITOR_INFO_2 *mi2;
unsigned int i;
CODE:
SV* retval = newSVpvn("", 0);
EnumMonitors(Server, 2, NULL, 0, &needed, &returned);
New(0, buffer, needed, BYTE);
rc = EnumMonitors(Server, 2, buffer, needed, &needed, &returned);
mi2 = (MONITOR_INFO_2 *) buffer;
if ((rc) && (returned)) {
for (i = 0; i < returned; i++) {
sv_catpvf(retval, "%s\t%s\t%s\n",
mi2[i].pName,
mi2[i].pEnvironment,
mi2[i].pDLLName
);
}
}
Safefree(buffer);
RETVAL = retval;
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
SV*
_EnumPrintProcessors(Server, Env)
LPSTR Server;
LPSTR Env;
PREINIT:
int rc;
LPBYTE buffer;
DWORD needed, returned;
PRINTPROCESSOR_INFO_1 *ppi1;
unsigned int i;
CODE:
SV* retval = newSVpvn("", 0);
EnumPrintProcessors(Server, Env, 1, NULL, 0, &needed, &returned);
New(0, buffer, needed, BYTE);
rc = EnumPrintProcessors(Server, Env, 1, buffer, needed, &needed, &returned);
ppi1 = (PRINTPROCESSOR_INFO_1 *)buffer;
if ((rc) && (returned)) {
for (i = 0; i < returned; i++) {
sv_catpvf(retval, "%s\n", ppi1[i].pName);
}
}
Safefree(buffer);
RETVAL = retval;
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
SV*
_EnumPrintProcessorDatatypes(Server, Processor)
LPSTR Server;
LPSTR Processor;
PREINIT:
int rc;
LPBYTE buffer;
DWORD needed, returned;
DATATYPES_INFO_1 *dti1;
unsigned int i;
CODE:
SV* retval = newSVpvn("", 0);
EnumPrintProcessorDatatypes(Server, Processor, 1, NULL, 0, &needed, &returned);
New(0, buffer, needed, BYTE);
rc = EnumPrintProcessorDatatypes(Server, Processor, 1, buffer, needed, &needed, &returned);
dti1 = (DATATYPES_INFO_1 *)buffer;
if ((rc) && (returned)) {
for (i = 0; i < returned; i++) {
sv_catpvf(retval, "%s\n", dti1[i].pName);
}
}
Safefree(buffer);
RETVAL = retval;
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
SV*
_EnumJobs(EnPrinter, begin, end)
LPSTR EnPrinter;
int begin;
int end;
PREINIT:
HANDLE hPrinter;
int rc;
LPBYTE buffer;
DWORD needed, returned;
JOB_INFO_2 *ji2;
unsigned int i;
CODE:
SV* retval = newSVpvn("", 0);
if (OpenPrinter(EnPrinter, &hPrinter, NULL)) {
EnumJobs(hPrinter, begin, end, 2, NULL, 0, &needed, &returned);
New(0, buffer, needed, BYTE);
rc = EnumJobs(hPrinter, begin, end, 2, buffer, needed, &needed, &returned);
ji2 = (JOB_INFO_2 *)buffer;
if ((rc) && (returned)) {
for (i = 0; i < returned; i++) {
sv_catpvf(retval, "%d\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\n",
ji2[i].JobId,
ji2[i].pPrinterName,
ji2[i].pMachineName,
ji2[i].pUserName,
ji2[i].pDocument,
ji2[i].pNotifyName,
ji2[i].pDatatype,
ji2[i].pPrintProcessor,
ji2[i].pParameters,
ji2[i].pDriverName,
ji2[i].pStatus,
ji2[i].Status,
ji2[i].Priority,
ji2[i].Position,
ji2[i].StartTime,
ji2[i].UntilTime,
ji2[i].TotalPages,
ji2[i].Size,
ji2[i].PagesPrinted
);
}
}
Safefree(buffer);
}
RETVAL = retval;
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
SV*
_FontEnum(hdc, FaceName, ChSet)
HDC hdc;
LPCSTR FaceName;
int ChSet;
PREINIT:
LOGFONT Logfont;
CODE:
SV* retval = newSVpvn("", 0);
int len = strlen(FaceName);
if (len > 31) {
memcpy(Logfont.lfFaceName, FaceName, 32);
} else {
memcpy(Logfont.lfFaceName, FaceName, len + 1);
}
Logfont.lfCharSet = ChSet;
Logfont.lfPitchAndFamily = 0;
EnumFontFamiliesEx(hdc, &Logfont, EnumFontFamExProc, (LPARAM)retval, 0);
RETVAL = retval;
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
LPSTR
_GetTempPath()
PREINIT:
char msg[MAX_PATH];
CODE:
GetTempPath(MAX_PATH, msg);
RETVAL = msg;
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
int
_GhostPDF(ps, pdf)
LPSTR ps;
LPSTR pdf;
PREINIT:
#ifdef GHOST
void *minst;
int gsargc = 13;
char pdfpath[MAX_PATH];
LPSTR gsargv[] = { "Printer",
"-dORIENT1=true",
"-dDOINTERPOLATE",
"-sstdout=%stderr",
"-dNOPAUSE",
"-dBATCH",
"-dSAFER",
"-sDEVICE=pdfwrite",
pdfpath,
"-c",
".setpdfwrite",
"-f",
ps };
#endif
CODE:
RETVAL = NULL;
#ifdef GHOST
__try {
if (gsapi_new_instance(&minst, NULL) == 0) {
sprintf(pdfpath, "-sOutputFile=%s", pdf);
if (gsapi_init_with_args(minst, gsargc, (LPSTR *)gsargv) == 0) {
RETVAL = 1;
gsapi_exit(minst);
}
gsapi_delete_instance(minst);
}
}
__except (exfilt()) { }
#else
croak("Ghostscript is not supported in this build!\n");
#endif
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
HDC
_CreateMeta(hdc, file, right, bottom)
HDC hdc;
LPCSTR file;
LONG right;
LONG bottom;
PREINIT:
RECT rect;
CODE:
if (file[0] == '\0') { file = NULL; }
if (right | bottom) {
rect.left = 0;
rect.top = 0;
rect.right = right;
rect.bottom = bottom;
RETVAL = CreateEnhMetaFile(hdc, file, &rect, NULL);
} else {
RETVAL = CreateEnhMetaFile(hdc, file, NULL, NULL);
}
SetGraphicsMode(RETVAL, GM_ADVANCED);
SetBkMode(RETVAL, TRANSPARENT);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
HENHMETAFILE
_CloseMeta(edc)
HDC edc;
CODE:
RETVAL = CloseEnhMetaFile(edc);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
int
_Inject(hdc, point, page, data)
HDC hdc;
int point;
int page;
LPSTR data;
PREINIT:
PSINJECTDATA psd;
char* injdata;
int len;
CODE:
DWORD psc = PSIDENT_PSCENTRIC;
RETVAL = 0;
len = strlen(data);
psd.DataBytes = len;
psd.InjectionPoint = point;
psd.PageNumber = page;
if (New(0, injdata, len + 1 + sizeof(PSINJECTDATA), char)) {
memcpy(injdata, &psd, sizeof(PSINJECTDATA));
memcpy(injdata + sizeof(PSINJECTDATA), data, len);
ExtEscape(hdc, POSTSCRIPT_IDENTIFY, sizeof(DWORD), (LPCSTR)&psc, 0, NULL);
RETVAL = ExtEscape(hdc, POSTSCRIPT_INJECTION, sizeof(PSINJECTDATA) + len, injdata, 0, NULL);
Safefree(injdata);
}
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
int
_EmfH2BMP(hdc, enh, file, width, height, format, flag, bpp)
HDC hdc;
HENHMETAFILE enh;
LPSTR file;
int width;
int height;
int format;
int flag;
int bpp;
PREINIT:
#ifdef FREE
HDC memDC;
HBITMAP memBM;
RECT rect;
FIBITMAP* fbmp;
FIBITMAP* fbmp2;
LOGBRUSH lb;
HBRUSH brush;
HBRUSH obrush;
#endif
CODE:
RETVAL = 0;
#ifdef FREE
if (format == FIF_UNKNOWN) {
format = FreeImage_GetFIFFromFilename(file);
}
if (format != FIF_UNKNOWN) {
if (FreeImage_FIFSupportsExportBPP(format, bpp) && (bpp == 8 || bpp == 24)) {
if(FreeImage_FIFSupportsWriting(format)) {
rect.top = 0; rect.bottom = height;
rect.left = 0; rect.right = width;
if (memDC = CreateCompatibleDC(hdc)) {
if (memBM = CreateCompatibleBitmap(hdc, width, height)) {
if (SelectObject(memDC, memBM)) {
lb.lbStyle = BS_SOLID;
lb.lbColor = RGB(0xff, 0xff, 0xff);
brush = CreateBrushIndirect(&lb);
obrush = SelectObject(memDC, &brush);
PatBlt(memDC, 0, 0, width, height, PATCOPY);
DeleteObject(SelectObject(memDC, &obrush));
if (PlayEnhMetaFile(memDC, enh, &rect)) {
if (fbmp = FreeImage_Allocate(width, height, 24, 0, 0, 0)) {
if (GetDIBits(memDC, memBM, 0, FreeImage_GetHeight(fbmp),
FreeImage_GetBits(fbmp),
FreeImage_GetInfo(fbmp),
DIB_RGB_COLORS)) {
if (bpp == 8) {
if (fbmp2 = FreeImage_ColorQuantize(fbmp, FIQ_WUQUANT)) {
FreeImage_Unload(fbmp);
fbmp = fbmp2;
}
}
if (FreeImage_Save(format, fbmp, file, flag)) {
FreeImage_Unload(fbmp);
RETVAL = 1;
}
}
}
}
}
DeleteObject(memBM);
}
DeleteObject(memDC);
}
} else {
RETVAL = -3; // not supported format
}
} else {
RETVAL = -2; // not supported bit
}
} else {
RETVAL = -1; // cannot guess
}
#else
croak("FreeImage is not supported in this build!\n");
#endif
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#
int
_Printfile(printer, filename)
char* printer;
char* filename;
CODE:
RETVAL = printfile(printer, filename);
OUTPUT:
RETVAL
#------------------------------------------------------------------------------#