自学教程：C++ ClosePrinter函数代码示例

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

OSStatusCPrinterSetupWizardSheet::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;}

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

Boolapc_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);}

voidprinter_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 voidmsprinter_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;}

voidprinter_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;}