/***************************************************** * 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; }