/*****************************************************
* localui_DeletePortUI [exported through MONITORUI]
*
* Delete a specific Port
*
* PARAMS
* pName [I] Servername or NULL (local Computer)
* hWnd [I] Handle to parent Window
* pPortName [I] Name of the Port, that should be deleted
*
* RETURNS
* Success: TRUE
* Failure: FALSE
*
* NOTES
* Native localui does not allow to delete a COM / LPT - Port (ERROR_NOT_SUPPORTED)
*
*/
static BOOL WINAPI localui_DeletePortUI(PCWSTR pName, HWND hWnd, PCWSTR pPortName)
{
HANDLE hXcv;
DWORD dummy;
DWORD needed;
DWORD status;
TRACE("(%s, %p, %s)\n", debugstr_w(pName), hWnd, debugstr_w(pPortName));
if ((!pPortName) || (!pPortName[0])) {
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
if (open_monitor_by_name(XcvPortW, pPortName, &hXcv)) {
/* native localui tests here for LPT / COM - Ports and failed with
ERROR_NOT_SUPPORTED. */
if (XcvDataW(hXcv, cmd_DeletePortW, (LPBYTE) pPortName,
(lstrlenW(pPortName)+1) * sizeof(WCHAR), (LPBYTE) &dummy, 0, &needed, &status)) {
ClosePrinter(hXcv);
if (status != ERROR_SUCCESS) SetLastError(status);
return (status == ERROR_SUCCESS);
}
ClosePrinter(hXcv);
return FALSE;
}
SetLastError(ERROR_UNKNOWN_PORT);
return FALSE;
}
//---------------------------------------------------------------------------
bool __fastcall TRawPrint::FechaDispositivo(void)
{
bool Retorno = true;
try
{
if (DispAberto)
{
if (PaginaAberta)
{
if(!EndPagePrinter(hPrinter))
Erro("Erro ao Finalizar Página");
if(!EndDocPrinter(hPrinter))
Erro("Erro ao Finalizar Documento");
else
{
if(!ClosePrinter(hPrinter))
{
Erro("Erro ao Fechar a Impressora");
Retorno = false;
}
DispAberto = false;
}
}
}
}
catch(Exception & E)
{
Erro("Erro ao Fechar a Impressora.\r\n\r\n" + E.Message + "\r\n");
}
return Retorno;
};
bool PrinterUtil::initDeviceSettings( QString printerName, QByteArray& devModeA )
{
bool done;
uint size;
LONG result = IDOK+1;
Qt::HANDLE handle = NULL;
// Get the printer handle
done = OpenPrinterW( (LPWSTR) printerName.utf16(), &handle, NULL );
if(!done)
return false;
// Get size of DEVMODE structure (public + private data)
size = DocumentPropertiesW( ScCore->primaryMainWindow()->winId(), handle, (LPWSTR) printerName.utf16(), NULL, NULL, 0);
// Compare size with DevMode structure size
if( devModeA.size() == size )
{
// Merge printer settings
result = DocumentPropertiesW( ScCore->primaryMainWindow()->winId(), handle, (LPWSTR) printerName.utf16(), (DEVMODEW*) devModeA.data(), (DEVMODEW*) devModeA.data(), DM_IN_BUFFER | DM_OUT_BUFFER);
}
else
{
// Retrieve default settings
devModeA.resize( size );
result = DocumentPropertiesW( ScCore->primaryMainWindow()->winId(), handle, (LPWSTR) printerName.utf16(), (DEVMODEW*) devModeA.data(), NULL, DM_OUT_BUFFER);
}
done = ( result == IDOK);
// Free the printer handle
ClosePrinter( handle );
return done;
}
/*
* Used to get printer device information from a printer name. This
* can fail if the user has no right to read printer properties, so
* this function can return NULL.
*/
GtkPrintWin32Devnames *
gtk_print_win32_devnames_from_printer_name (const char *printer_name)
{
HANDLE hprinter;
gunichar2* win32_printer_name;
GtkPrintWin32Devnames *devnames;
win32_printer_name = g_utf8_to_utf16 (printer_name, -1, NULL, NULL, NULL);
if (OpenPrinterW (win32_printer_name, &hprinter, NULL))
{
DWORD needed;
PRINTER_INFO_2W* printer_info;
GetPrinterW (hprinter, 2, NULL, 0, &needed);
printer_info = (PRINTER_INFO_2W* )g_malloc ((gsize) needed);
GetPrinterW (hprinter, 2, (LPBYTE) printer_info, needed, &needed);
devnames = g_new (GtkPrintWin32Devnames, 1);
devnames->driver = g_utf16_to_utf8 (printer_info->pDriverName, -1, NULL, NULL, NULL);
devnames->device = g_strdup (printer_name);
devnames->output = g_utf16_to_utf8 (printer_info->pPortName, -1, NULL, NULL, NULL);
devnames->flags = 0;
ClosePrinter (hprinter);
g_free (printer_info);
}
else
{
/* Could not open printer */
devnames = NULL;
}
g_free (win32_printer_name);
return devnames;
}
OSStatus
CPrinterSetupWizardSheet::InstallPrinterIPP(Printer * printer, Service * service)
{
DEBUG_UNUSED( service );
HANDLE hPrinter = NULL;
PRINTER_INFO_2 pInfo;
OSStatus err;
//
// add the printer
//
ZeroMemory(&pInfo, sizeof(PRINTER_INFO_2));
pInfo.pPrinterName = printer->actualName.GetBuffer();
pInfo.pPortName = printer->portName.GetBuffer();
pInfo.pDriverName = printer->model.GetBuffer();
pInfo.pPrintProcessor = L"winprint";
pInfo.pLocation = service->location.GetBuffer();
pInfo.Attributes = PRINTER_ATTRIBUTE_NETWORK | PRINTER_ATTRIBUTE_LOCAL;
hPrinter = AddPrinter(NULL, 2, (LPBYTE)&pInfo);
err = translate_errno( hPrinter, errno_compat(), kUnknownErr );
require_noerr( err, exit );
exit:
if ( hPrinter != NULL )
{
ClosePrinter(hPrinter);
}
return err;
}
/*****************************************************
* localui_ConfigurePortUI [exported through MONITORUI]
*
* Display the Configuration-Dialog for a specific Port
*
* PARAMS
* pName [I] Servername or NULL (local Computer)
* hWnd [I] Handle to parent Window for the Dialog-Box or NULL
* pPortName [I] Name of the Port, that should be configured
*
* RETURNS
* Success: TRUE
* Failure: FALSE
*
*/
static BOOL WINAPI localui_ConfigurePortUI(PCWSTR pName, HWND hWnd, PCWSTR pPortName)
{
HANDLE hXcv;
DWORD res;
TRACE("(%s, %p, %s)\n", debugstr_w(pName), hWnd, debugstr_w(pPortName));
if (open_monitor_by_name(XcvPortW, pPortName, &hXcv)) {
res = get_type_from_name(pPortName);
switch(res)
{
case PORT_IS_COM:
res = dlg_configure_com(hXcv, hWnd, pPortName);
break;
case PORT_IS_LPT:
res = dlg_configure_lpt(hXcv, hWnd);
break;
default:
dlg_nothingtoconfig(hWnd);
SetLastError(ERROR_CANCELLED);
res = FALSE;
}
ClosePrinter(hXcv);
return res;
}
return FALSE;
}
void RawPrinter::close()
{
if (opened) {
ClosePrinter(hPrinter);
opened = false;
}
}
printer_job *printer_start_job(char *printer)
{
printer_job *ret = smalloc(sizeof(printer_job));
DOC_INFO_1 docinfo;
int jobstarted = 0, pagestarted = 0;
ret->hprinter = NULL;
if (!OpenPrinter(printer, &ret->hprinter, NULL))
goto error;
docinfo.pDocName = "PuTTY remote printer output";
docinfo.pOutputFile = NULL;
docinfo.pDatatype = "RAW";
if (!StartDocPrinter(ret->hprinter, 1, (LPSTR)&docinfo))
goto error;
jobstarted = 1;
if (!StartPagePrinter(ret->hprinter))
goto error;
pagestarted = 1;
return ret;
error:
if (pagestarted)
EndPagePrinter(ret->hprinter);
if (jobstarted)
EndDocPrinter(ret->hprinter);
if (ret->hprinter)
ClosePrinter(ret->hprinter);
sfree(ret);
return NULL;
}
void PrintDialog::SetOptions()
{
#ifdef HAVE_CUPS
PrinterOpts = "";
if (!cdia)
cdia = new CupsOptions(this, PrintDest->currentText());
if (!cdia->exec())
{
delete cdia; // if options was canceled delete dia
cdia = 0; // so that getoptions() in the okButtonClicked() will get
// the default values from the last succesful run
}
#elif defined(_WIN32)
bool done;
Qt::HANDLE handle = NULL;
// Retrieve the selected printer
QString printerS = PrintDest->currentText();
// Get a printer handle
done = OpenPrinterW( (LPWSTR) printerS.utf16(), &handle, NULL );
if(!done)
return;
// Merge stored settings, prompt user and return user settings
DocumentPropertiesW( winId(), handle, (LPWSTR) printerS.utf16(), (DEVMODEW*) DevMode.data(), (DEVMODEW*) DevMode.data(),
DM_IN_BUFFER | DM_IN_PROMPT | DM_OUT_BUFFER);
// Free the printer handle
ClosePrinter( handle );
#endif
}
/************************************************************************
* PSDRV_EndDoc
*/
INT PSDRV_EndDoc( PHYSDEV dev )
{
PSDRV_PDEVICE *physDev = get_psdrv_dev( dev );
INT ret = 1;
if(!physDev->job.id) {
FIXME("hJob == 0. Now what?\n");
return 0;
}
if(!physDev->job.OutOfPage) {
WARN("Somebody forgot an EndPage\n");
PSDRV_EndPage( dev );
}
if (physDev->job.PageNo)
PSDRV_WriteFooter( dev );
ret = EndDocPrinter(physDev->job.hprinter);
ClosePrinter(physDev->job.hprinter);
physDev->job.hprinter = NULL;
physDev->job.id = 0;
HeapFree( GetProcessHeap(), 0, physDev->job.doc_name );
physDev->job.doc_name = NULL;
return ret;
}
void mswin_printer_thread(void *arg)
{
int fd = (int)arg;
char pname[gp_file_name_sizeof];
char data[4096];
HANDLE hprinter = INVALID_HANDLE_VALUE;
int count;
DWORD written;
DOC_INFO_1 di;
/* Read from pipe and write to Windows printer.
* First gp_file_name_sizeof bytes are name of the printer.
*/
if (read(fd, pname, sizeof(pname)) != sizeof(pname)) {
/* Didn't get the printer name */
close(fd);
return;
}
while ( (count = read(fd, data, sizeof(data))) > 0 ) {
if (hprinter == INVALID_HANDLE_VALUE) {
if (!OpenPrinter(pname, &hprinter, NULL)) {
close(fd);
return;
}
di.pDocName = (LPTSTR)gs_product;
di.pOutputFile = NULL;
di.pDatatype = "RAW";
if (!StartDocPrinter(hprinter, 1, (LPBYTE) & di)) {
AbortPrinter(hprinter);
close(fd);
return;
}
}
if (!StartPagePrinter(hprinter)) {
AbortPrinter(hprinter);
close(fd);
return;
}
if (!WritePrinter(hprinter, (LPVOID) data, count, &written)) {
AbortPrinter(hprinter);
close(fd);
return;
}
}
if (hprinter != INVALID_HANDLE_VALUE) {
if (count == 0) {
/* EOF */
EndPagePrinter(hprinter);
EndDocPrinter(hprinter);
ClosePrinter(hprinter);
}
else {
/* Error */
AbortPrinter(hprinter);
}
}
close(fd);
}
Bool
apc_prn_setup( Handle self)
{
void * lph;
LONG sz, ret;
DEVMODE * dm;
HWND who = GetActiveWindow();
HDC dc;
objCheck false;
if ( !OpenPrinter( sys s. prn. ppi. pPrinterName, &lph, nil))
apiErrRet;
sz = DocumentProperties( nil, lph, sys s. prn. ppi. pPrinterName, nil, nil, 0);
if ( sz <= 0) {
apiErr;
ClosePrinter( lph);
return false;
}
dm = ( DEVMODE * ) malloc( sz);
if ( !dm) {
ClosePrinter( lph);
return false;
}
sys s. prn. ppi. pDevMode-> dmFields = -1;
ret = DocumentProperties( hwnd_to_view( who) ? who : nil, lph, sys s. prn. ppi. pPrinterName,
dm, sys s. prn. ppi. pDevMode, DM_IN_BUFFER|DM_IN_PROMPT|DM_OUT_BUFFER);
ClosePrinter( lph);
if ( ret != IDOK) {
free( dm);
return false;
}
free( sys s. prn. ppi. pDevMode);
sys s. prn. ppi. pDevMode = dm;
if ( !( dc = prn_info_dc( self))) return false;
sys res. x = ( float) GetDeviceCaps( dc, LOGPIXELSX);
sys res. y = ( float) GetDeviceCaps( dc, LOGPIXELSY);
sys lastSize. x = GetDeviceCaps( dc, HORZRES);
sys lastSize. y = GetDeviceCaps( dc, VERTRES);
if ( !DeleteDC( dc)) apiErr;
return true;
}
int main (int argc, char* argv[])
{
HANDLE printer;
DWORD i, status, needed, returned;
PRINTER_ENUM_VALUES *buffer = NULL;
if (argc < 2)
{
fprintf (stderr, "useage: %s <printername>\n", argv[0]);
exit (-1);
}
/* open the server */
if (!OpenPrinter (argv[1], &printer, NULL))
PrintLastError();
else
printf ("Printer [%s] opened successfully.\n\n", argv[1]);
needed = returned = 0;
status = EnumPrinterDataEx(printer, ENUM_KEY_NAME, (LPBYTE)buffer, 0, &needed, &returned);
if (status == ERROR_MORE_DATA)
{
if ((buffer = malloc(needed)) == NULL)
{
fprintf (stderr, "Unable to malloc enough space for [%d] bytes\n", needed);
exit (-1);
}
status = EnumPrinterDataEx(printer, ENUM_KEY_NAME, (LPBYTE)buffer, needed, &needed, &returned);
if (status == ERROR_SUCCESS)
{
printf ("Printer Enum Values :\n");
for (i=0; i<returned; i++)
{
print_printer_enum_values (&buffer[i]);
printf ("\n");
}
}
free (buffer);
}
else if (status != ERROR_SUCCESS)
PrintLastError();
/* close the server */
if (!ClosePrinter(printer))
PrintLastError();
else
printf ("Printer [%s] closed successfully.\n", argv[1]);
return 0;
}
bool DeleteShare(UserManager *panel,bool selection)
{
bool res=false;
CFarPanelSelection sp((HANDLE)panel,selection);
if(sp.Number())
{
TCHAR warning[TINY_BUFFER];
if(sp.Number()==1)
{
TCHAR Truncated[MAX_PATH];
_tcscpy(Truncated,sp[0].FileName);
FSF.TruncPathStr(Truncated,50);
FSF.sprintf(warning,GetMsg(mDelOne),Truncated);
}
else
FSF.sprintf(warning,GetMsg(mDelShareN+NumberType(sp.Number())),sp.Number());
const TCHAR *MsgItems[]={GetMsg(mButtonDelete),warning,GetMsg(mButtonDelete),GetMsg(mButtonCancel)};
if(!Info.Message(&MainGuid,&DelShareMessageGuid,0,NULL,MsgItems,sizeof(MsgItems)/sizeof(MsgItems[0]),2))
{
res=true;
for(int i=0;i<sp.Number();i++)
if(panel->level==levelPrinterShared)
{
HANDLE printer; PRINTER_DEFAULTSW defaults; PRINTER_INFO_2W *data=NULL;
memset(&defaults,0,sizeof(defaults));
defaults.DesiredAccess=PRINTER_ALL_ACCESS;
if(OpenPrinterW(panel->hostfile,&printer,&defaults))
{
DWORD Needed;
if(!GetPrinterW(printer,2,NULL,0,&Needed))
{
if(GetLastError()==ERROR_INSUFFICIENT_BUFFER)
{
data=(PRINTER_INFO_2W *)malloc(Needed);
if(data)
{
if(GetPrinterW(printer,2,(PBYTE)data,Needed,&Needed))
{
data->Attributes&=~PRINTER_ATTRIBUTE_SHARED;
if(SetPrinterW(printer,2,(PBYTE)data,0)) res=true;
}
free(data); data=NULL;
}
}
}
ClosePrinter(printer);
}
}
else if(sp[i].UserData.FreeData)
{
NetShareDel(panel->computer_ptr,GetWideNameFromUserData(sp[i].UserData.Data),0);
}
}
}
return res;
}
void getDefaultDevmodeC(char *printSetup, LPHANDLE phPrinter, char **device)
{
int size,r1;
size = ((int*)printSetup)[0];
printSetup +=4;
r1 = DocumentProperties(NULL,phPrinter,((char*)device)+4,
(DEVMODE*)printSetup,NULL,DM_OUT_BUFFER);
ClosePrinter(phPrinter);
}
void printer_finish_job(printer_job *pj)
{
if (!pj)
return;
EndPagePrinter(pj->hprinter);
EndDocPrinter(pj->hprinter);
ClosePrinter(pj->hprinter);
sfree(pj);
}
void
printer_finish_job(void)
{
if (printer) {
EndPagePrinter(printer);
EndDocPrinter(printer);
ClosePrinter(printer);
printer = 0;
}
}
BOOL Close()
{
BOOL result = TRUE;
if( m_hPrinter )
{
result = ClosePrinter( m_hPrinter );
m_hPrinter = (HANDLE)NULL;
}
return result;
}
/************************************************************************
* PSDRV_StartDoc
*/
INT PSDRV_StartDoc( PHYSDEV dev, const DOCINFOW *doc )
{
PSDRV_PDEVICE *physDev = get_psdrv_dev( dev );
DOC_INFO_1W di;
PRINTER_DEFAULTSW prn_def;
TRACE("(%p, %p) => %s, %s, %s\n", physDev, doc, debugstr_w(doc->lpszDocName),
debugstr_w(doc->lpszOutput), debugstr_w(doc->lpszDatatype));
if(physDev->job.id) {
FIXME("hJob != 0. Now what?\n");
return 0;
}
prn_def.pDatatype = NULL;
prn_def.pDevMode = &physDev->pi->Devmode->dmPublic;
prn_def.DesiredAccess = PRINTER_ACCESS_USE;
if (!OpenPrinterW( physDev->pi->friendly_name, &physDev->job.hprinter, &prn_def ))
{
WARN("OpenPrinter(%s, ...) failed: %d\n",
debugstr_w(physDev->pi->friendly_name), GetLastError());
return 0;
}
di.pDocName = (LPWSTR) doc->lpszDocName;
di.pDatatype = NULL;
if(doc->lpszOutput)
di.pOutputFile = (LPWSTR) doc->lpszOutput;
else if(physDev->job.output)
di.pOutputFile = physDev->job.output;
else
di.pOutputFile = NULL;
TRACE("using output: %s\n", debugstr_w(di.pOutputFile));
/* redirection located in HKCU\Software\Wine\Printing\Spooler
is done during winspool.drv,ScheduleJob */
physDev->job.id = StartDocPrinterW(physDev->job.hprinter, 1, (LPBYTE) &di);
if(!physDev->job.id) {
WARN("StartDocPrinter() failed: %d\n", GetLastError());
ClosePrinter(physDev->job.hprinter);
return 0;
}
physDev->job.banding = FALSE;
physDev->job.OutOfPage = TRUE;
physDev->job.PageNo = 0;
physDev->job.quiet = FALSE;
physDev->job.in_passthrough = FALSE;
physDev->job.had_passthrough_rect = FALSE;
physDev->job.doc_name = strdupW( doc->lpszDocName );
return physDev->job.id;
}
int main (int argc, char* argv[])
{
PRINTER_INFO_2 buffer;
HANDLE printer;
LPVOID lpMsgBuf;
if (argc < 5)
{
fprintf (stderr, "useage: %s <servername> <printername> <sharename> <port name>\n", argv[0]);
exit (-1);
}
memset(&buffer, 0 , sizeof(buffer));
buffer.pServerName = strdup (argv[1]);
buffer.pPrinterName = strdup (argv[2]);
buffer.pShareName = strdup (argv[3]);
buffer.pPortName = strdup (argv[4]);
buffer.pDriverName = strdup ("Apple LaserWriter II NTX v51.8");
buffer.pPrintProcessor = strdup ("winprint");
buffer.pDatatype = strdup ("RAW");
buffer.Attributes = PRINTER_ATTRIBUTE_SHARED;
buffer.pSecurityDescriptor = NULL;
printf ("Attempting to add printer [%s] on server [%s]\n",
buffer.pPrinterName, buffer.pServerName);
printf ("\nPrinter Info 1:\n");
print_printer_info_2 (&buffer);
printf ("\n");
printer = AddPrinter (buffer.pServerName, 2, (LPBYTE)(&buffer));
if ( printer == NULL)
{
FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS, NULL, GetLastError(),
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
(LPTSTR) &lpMsgBuf, 0, NULL);
printf ("ERROR : %s\n", (char*)lpMsgBuf);
LocalFree (lpMsgBuf);
}
else
{
printf ("Printer [%s] added successfully on server [%s]!\n",
buffer.pPrinterName, buffer.pServerName);
if (!ClosePrinter (printer))
fprintf (stderr, "Error closing printer handle!\n");
else
printf ("Printer handle closed successfully.\n");
}
return 0;
}
BOOL BReleasePPData(
_In_ PPRINTPROCESSORDATA * ppData )
{
PPRINTPROCESSORDATA pData = NULL;
if ( NULL == ppData || NULL == *ppData)
{
return FALSE;
}
pData = *ppData;
pData->signature = 0;
/* Release any allocated resources */
if (pData->hPrinter)
ClosePrinter(pData->hPrinter);
if (pData->hDC)
DeleteDC(pData->hDC);
if (pData->pDevmode)
FreeSplMem(pData->pDevmode);
if (pData->pPrinterNameFromOpenData)
FreeSplStr(pData->pPrinterNameFromOpenData);
if (pData->semPaused)
CloseHandle(pData->semPaused);
if (pData->pPrinterName)
FreeSplStr(pData->pPrinterName);
if (pData->pDatatype)
FreeSplStr(pData->pDatatype);
if (pData->pDocument)
FreeSplStr(pData->pDocument);
if (pData->pOutputFile)
FreeSplStr(pData->pOutputFile);
if (pData->pParameters)
FreeSplStr(pData->pParameters);
ZeroMemory ( pData, sizeof (PRINTPROCESSORDATA) );
FreeSplMem(pData);
*ppData = pData = NULL;
return TRUE;
}
/*****************************************************
* localui_AddPortUI [exported through MONITORUI]
*
* Display a Dialog to add a local Port
*
* PARAMS
* pName [I] Servername or NULL (local Computer)
* hWnd [I] Handle to parent Window for the Dialog-Box or NULL
* pMonitorName[I] Name of the Monitor, that should be used to add a Port or NULL
* ppPortName [O] PTR to PTR of a buffer, that receive the Name of the new Port or NULL
*
* RETURNS
* Success: TRUE
* Failure: FALSE
*
* NOTES
* The caller must free the buffer (returned in ppPortName) with GlobalFree().
* Native localui.dll failed with ERROR_INVALID_PARAMETER, when the user tried
* to add a Port, that start with "COM" or "LPT".
*
*/
static BOOL WINAPI localui_AddPortUI(PCWSTR pName, HWND hWnd, PCWSTR pMonitorName, PWSTR *ppPortName)
{
addportui_t data;
HANDLE hXcv;
DWORD needed;
DWORD dummy;
DWORD status;
DWORD res = FALSE;
TRACE( "(%s, %p, %s, %p) (*ppPortName: %p)\n", debugstr_w(pName), hWnd,
debugstr_w(pMonitorName), ppPortName, ppPortName ? *ppPortName : NULL);
if (open_monitor_by_name(XcvMonitorW, pMonitorName, &hXcv)) {
ZeroMemory(&data, sizeof(addportui_t));
data.hXcv = hXcv;
res = DialogBoxParamW(LOCALUI_hInstance, MAKEINTRESOURCEW(ADDPORT_DIALOG), hWnd,
dlgproc_addport, (LPARAM) &data);
TRACE("got %u with %u for %s\n", res, GetLastError(), debugstr_w(data.portname));
if (ppPortName) *ppPortName = NULL;
if (res) {
res = XcvDataW(hXcv, cmd_AddPortW, (PBYTE) data.portname,
(lstrlenW(data.portname)+1) * sizeof(WCHAR),
(PBYTE) &dummy, 0, &needed, &status);
TRACE("got %u with status %u\n", res, status);
if (res && (status == ERROR_SUCCESS) && ppPortName) {
/* Native localui uses GlobalAlloc also.
The caller must GlobalFree the buffer */
*ppPortName = GlobalAlloc(GPTR, (lstrlenW(data.portname)+1) * sizeof(WCHAR));
if (*ppPortName) lstrcpyW(*ppPortName, data.portname);
}
if (res && (status == ERROR_ALREADY_EXISTS)) {
dlg_port_already_exists(hWnd, data.portname);
/* Native localui also return "TRUE" from AddPortUI in this case */
}
HeapFree(GetProcessHeap(), 0, data.portname);
}
else
{
SetLastError(ERROR_CANCELLED);
}
ClosePrinter(hXcv);
}
TRACE("=> %u with %u\n", res, GetLastError());
return res;
}
static void
msprinter_delete_device_internal (struct device *d)
{
if (DEVICE_MSPRINTER_HPRINTER (d))
ClosePrinter (DEVICE_MSPRINTER_HPRINTER (d));
if (DEVICE_MSPRINTER_HDC (d))
DeleteDC (DEVICE_MSPRINTER_HDC (d));
if (DEVICE_MSPRINTER_HCDC (d))
DeleteDC (DEVICE_MSPRINTER_HCDC (d));
DEVICE_MSPRINTER_FONTLIST (d) = Qnil;
}
/*
%F cdKillCanvas para Printer.
Termina a pagina e termina o documento, enviando-o para a impressora.
*/
static void cdkillcanvas (cdCtxCanvas* ctxcanvas)
{
cdwpKillCanvas(ctxcanvas);
EndPage(ctxcanvas->hDC);
EndDoc(ctxcanvas->hDC);
ClosePrinter(ctxcanvas->printerHandle);
DeleteDC(ctxcanvas->hDC);
delete ctxcanvas;
}
void
printer_start_job(char *printer_name)
{
if (OpenPrinter(printer_name, &printer, 0)) {
if (StartDocPrinter(printer, 1, (LPBYTE)&doc_info)) {
if (StartPagePrinter(printer))
return;
EndDocPrinter(printer);
}
ClosePrinter(printer);
printer = 0;
}
}
static BOOL test_ClosePrinter(struct torture_context *tctx,
HANDLE handle)
{
torture_comment(tctx, "Testing ClosePrinter");
if (!ClosePrinter(handle)) {
char tmp[1024];
sprintf(tmp, "failed to close printer, error was: %s\n",
errstr(GetLastError()));
torture_fail(tctx, tmp);
}
return TRUE;
}
BOOL CMainDlg::RawPrint(LPTSTR fileName)
{
HANDLE p, f;
p = f = INVALID_HANDLE_VALUE;
LPBYTE buffer = NULL;
DWORD err = ERROR_SUCCESS, w, size, r;
WTL::CString ballon, message;
CRPTray rwtray;
WTL::CString printer = CMainDlg::GetRawPrinter();
if (!printer.GetLength())
{
::MessageBox(NULL, _(IDS_NOPRINTER), _T("RawPrinter"), MB_OK | MB_ICONERROR);
return FALSE;
}
PRINTER_DEFAULTS defaults = { _T("RAW"), 0, PRINTER_ACCESS_USE };
DOC_INFO_1 doc = { fileName, NULL, _T("RAW") };
if ((f = ::CreateFile(fileName,
GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL, NULL)) == INVALID_HANDLE_VALUE)
{
message.Format(_(IDS_ERROR_CREATEFILE), fileName, AtlGetErrorDescription(::GetLastError()));
::MessageBox(NULL, message, _T("RawPrinter"), MB_OK | MB_ICONERROR);
goto end;
}
size = ::GetFileSize(f, NULL);
buffer = (LPBYTE) new BYTE[size];
::ReadFile(f, buffer, size, &r, NULL);
::CloseHandle(f);
LPTSTR fn = _tcsrchr(fileName, _T('\\'));
ballon.Format(_(IDS_PRINTING), fn ? fn + 1: fileName, printer);
rwtray.Ballon(ballon, 3000);
CALL(::OpenPrinter(printer.GetBuffer(0), &p, &defaults), OpenPrinter);
CALL(::StartDocPrinter(p, 1, (LPBYTE) &doc), StartDocPrinter);
CALL(::StartPagePrinter(p), StartPagePrinter);
CALL(::WritePrinter(p, buffer, size, &w), WritePrinter);
CALL(::EndPagePrinter(p), EndPagePrinter);
CALL(::EndDocPrinter(p), EndDocPrinter);
end:
if (buffer) delete buffer;
ClosePrinter(p);
return TRUE;
}
static void printer_win_close_printjob(rdpPrintJob* printjob)
{
rdpWinPrintJob* win_printjob = (rdpWinPrintJob*)printjob;
DEBUG_WINPR("");
if ( ! EndPagePrinter( ((rdpWinPrinter*)printjob->printer)->hPrinter ) )
DEBUG_WINPR("EndPagePrinter failed");;
if ( ! ClosePrinter( ((rdpWinPrinter*)printjob->printer)->hPrinter ) )
DEBUG_WINPR("ClosePrinter failed");;
((rdpWinPrinter*)printjob->printer)->printjob = NULL;
free(win_printjob) ;
}
void Demo_WritePrinter(void)
{
PRINTDLG pd;
memset(&pd, 0, sizeof(PRINTDLG));
pd.lStructSize = sizeof(PRINTDLG);
if ( PrintDlg(&pd)==IDOK )
{
HANDLE hPrinter;
DEVMODE * pDevMode = (DEVMODE *) GlobalLock(pd.hDevMode);
PRINTER_DEFAULTS prn;
prn.pDatatype = "NT EMF 1.008";
prn.pDevMode = pDevMode;
prn.DesiredAccess = PRINTER_ACCESS_USE;
if ( OpenPrinter((char *) pDevMode->dmDeviceName, & hPrinter, & prn) )
{
KFileDialog fd;
if ( fd.GetOpenFileName(NULL, "spl", "Windows 2000 EMF Spool file") )
{
DOC_INFO_1 docinfo;
docinfo.pDocName = "Testing WritePrinter";
docinfo.pOutputFile = NULL;
docinfo.pDatatype = "NT EMF 1.008";
StartDocPrinter(hPrinter, 1, (BYTE *) & docinfo);
StartPagePrinter(hPrinter);
SendFile(hPrinter, fd.m_TitleName, true);
EndPagePrinter(hPrinter);
EndDocPrinter(hPrinter);
}
ClosePrinter(hPrinter);
}
if ( pd.hDevMode ) GlobalFree(pd.hDevMode);
if ( pd.hDevNames ) GlobalFree(pd.hDevNames);
}
}
/************************************************************************
* PSDRV_StartDocA
*/
INT PSDRV_StartDocA( PSDRV_PDEVICE *physDev, const DOCINFOA *doc )
{
LPCSTR output = "LPT1:";
BYTE buf[300];
HANDLE hprn = INVALID_HANDLE_VALUE;
PRINTER_INFO_5A *pi5 = (PRINTER_INFO_5A*)buf;
DWORD needed;
if(physDev->job.hJob) {
FIXME("hJob != 0. Now what?\n");
return 0;
}
if(doc->lpszOutput)
output = doc->lpszOutput;
else if(physDev->job.output)
output = physDev->job.output;
else {
if(OpenPrinterA(physDev->pi->FriendlyName, &hprn, NULL) &&
GetPrinterA(hprn, 5, buf, sizeof(buf), &needed)) {
output = pi5->pPortName;
}
if(hprn != INVALID_HANDLE_VALUE)
ClosePrinter(hprn);
}
physDev->job.hJob = OpenJob16(output, doc->lpszDocName, HDC_16(physDev->hdc) );
if(!physDev->job.hJob) {
WARN("OpenJob failed\n");
return 0;
}
physDev->job.banding = FALSE;
physDev->job.OutOfPage = TRUE;
physDev->job.PageNo = 0;
physDev->job.quiet = FALSE;
physDev->job.in_passthrough = FALSE;
physDev->job.had_passthrough_rect = FALSE;
if(doc->lpszDocName) {
physDev->job.DocName = HeapAlloc(GetProcessHeap(), 0, strlen(doc->lpszDocName)+1);
strcpy(physDev->job.DocName, doc->lpszDocName);
} else
physDev->job.DocName = NULL;
return physDev->job.hJob;
}
