windows-nt/Source/XPSP1/NT/admin/pchealth/helpctr/shell/printing/cprint.cpp

613 lines
14 KiB
C++
Raw Normal View History

2020-09-26 03:20:57 -05:00
/******************************************************************************
Copyright (c) 2000 Microsoft Corporation
Module Name:
CPrint.cpp
Abstract:
Class that wraps the multi-topic printing process
Revision History:
Davide Massarenti (Dmassare) 05/07/2000
created
******************************************************************************/
#include "stdafx.h"
////////////////////////////////////////////////////////////////////////////////
static const DWORD c_MaxWait = 30000; // Max time to wait for temp file to change, before aborting.
////////////////////////////////////////////////////////////////////////////////
static DWORD WaitMultipleObjectsWithMessageLoop( HANDLE* rgEvents, DWORD dwNum )
{
DWORD dwRet;
MSG msg;
while(1)
{
dwRet = ::MsgWaitForMultipleObjects( dwNum, rgEvents, FALSE, INFINITE, QS_ALLINPUT );
if(/*dwRet >= WAIT_OBJECT_0 &&*/
dwRet < WAIT_OBJECT_0 + dwNum)
{
return dwRet - WAIT_OBJECT_0; // An event was signaled.
}
if(dwRet >= WAIT_ABANDONED_0 &&
dwRet < WAIT_ABANDONED_0 + dwNum )
{
return dwRet - WAIT_ABANDONED_0; // An event was abandoned.
}
if(dwRet != WAIT_OBJECT_0 + dwNum)
{
return -1;
}
// There is one or more window message available. Dispatch them
while(PeekMessage( &msg, NULL, NULL, NULL, PM_REMOVE ))
{
TranslateMessage( &msg );
DispatchMessage ( &msg );
dwRet = ::WaitForMultipleObjects( dwNum, rgEvents, FALSE, 0 );
if(/*dwRet >= WAIT_OBJECT_0 &&*/
dwRet < WAIT_OBJECT_0 + dwNum)
{
return dwRet - WAIT_OBJECT_0; // An event was signaled.
}
if(dwRet >= WAIT_ABANDONED_0 &&
dwRet < WAIT_ABANDONED_0 + dwNum )
{
return dwRet - WAIT_ABANDONED_0; // An event was abandoned.
}
}
}
return -1;
}
////////////////////////////////////////////////////////////////////////////////
Printing::Print::Print()
{
m_pCallback = NULL; // Notification* m_pCallback;
//
// MPC::WStringList m_lstURLs;
//
m_hwnd = NULL; // HWND m_hwnd;
// WindowHandle m_wnd;
// CComPtr<IWebBrowser2> m_spWebBrowser2;
//
// CComPtr<CDispatchSink> m_spObjDisp;
m_eventDocComplete = NULL; // HANDLE m_eventDocComplete;
m_eventAbortPrint = NULL; // HANDLE m_eventAbortPrint;
//
// CComPtr<IUnknown> m_spUnkControl;
m_dwCookie = 0; // DWORD m_dwCookie;
// CComPtr<IOleCommandTarget> m_spOleCmdTarg;
// MPC::wstring m_szPrintDir;
// MPC::wstring m_szPrintFile;
//
// CComPtr<IStream> m_streamPrintData;
}
Printing::Print::~Print()
{
Terminate();
}
////////////////////////////////////////
HRESULT Printing::Print::Initialize( /*[in]*/ HWND hwnd )
{
__HCP_FUNC_ENTRY( "Printing::Print::Initialize" );
HRESULT hr;
__MPC_EXIT_IF_METHOD_FAILS(hr, Terminate());
m_hwnd = hwnd;
__MPC_EXIT_IF_CALL_RETURNS_NULL(hr, (m_eventDocComplete = ::CreateEvent( NULL, FALSE, FALSE, NULL )));
__MPC_EXIT_IF_CALL_RETURNS_NULL(hr, (m_eventAbortPrint = ::CreateEvent( NULL, FALSE, FALSE, NULL )));
m_wnd.SetAbortEvent( m_eventAbortPrint );
hr = S_OK;
__HCP_FUNC_CLEANUP;
__HCP_FUNC_EXIT(hr);
}
HRESULT Printing::Print::Terminate()
{
if(m_spObjDisp)
{
if(m_dwCookie != 0)
{
::AtlUnadvise( m_spUnkControl, DIID_DWebBrowserEvents2, m_dwCookie );
}
m_spObjDisp.Release();
}
m_spWebBrowser2.Release();
m_spUnkControl .Release();
m_spOleCmdTarg .Release();
if(m_wnd.m_hWnd)
{
m_wnd.DestroyWindow();
}
//
// Delete temp files.
//
m_streamPrintData.Release();
if(m_szPrintFile.size())
{
(void)MPC::DeleteFile( m_szPrintFile, true, true );
m_szPrintFile.erase();
}
if(m_szPrintDir.size())
{
if(!::RemoveDirectoryW( m_szPrintDir.c_str() ))
{
(void)::MoveFileExW( m_szPrintDir.c_str(), NULL, MOVEFILE_DELAY_UNTIL_REBOOT );
}
m_szPrintDir.erase();
}
return S_OK;
}
////////////////////////////////////////////////////////////////////////////////
HRESULT Printing::Print::AddUrl( /*[in]*/ LPCWSTR szUrl )
{
m_lstURLs.push_back( szUrl );
return S_OK;
}
HRESULT Printing::Print::PrintAll( /*[in]*/ Notification* pCallback )
{
__HCP_FUNC_ENTRY( "Printing::Print::PrintAll" );
HRESULT hr;
int iLen = m_lstURLs.size();
int iPos = 0;
m_pCallback = pCallback;
if(iLen > 0)
{
__MPC_EXIT_IF_METHOD_FAILS(hr, PreparePrintFileLoc());
//
// Make sure the host window knows what's going on.
//
m_wnd.SetMultiTopic ( true );
m_wnd.SetPrintFileName( m_szPrintFile.c_str() );
for(MPC::WStringIter it = m_lstURLs.begin(); it != m_lstURLs.end(); it++, iPos++)
{
if(m_pCallback)
{
__MPC_EXIT_IF_METHOD_FAILS(hr, m_pCallback->Progress( it->c_str(), iPos, iLen ));
}
__MPC_EXIT_IF_METHOD_FAILS(hr, PrintSingleURL( *it ));
}
//
// ok, send it all to the printer...
//
__MPC_EXIT_IF_METHOD_FAILS(hr, RawDataToPrinter());
if(m_pCallback)
{
__MPC_EXIT_IF_METHOD_FAILS(hr, m_pCallback->Progress( NULL, iLen, iLen ));
}
}
hr = S_OK;
__HCP_FUNC_CLEANUP;
__HCP_FUNC_EXIT(hr);
}
////////////////////////////////////////////////////////////////////////////////
HRESULT Printing::Print::PrintSingleURL( /*[in]*/ MPC::wstring& szUrl )
{
__HCP_FUNC_ENTRY( "Printing::Print::PrintSingleURL" );
HRESULT hr;
//
// Navigate to the url, creating the control if necessary
//
if(!m_wnd.m_hWnd)
{
RECT rect = { 0, 0, 800, 600 };
DWORD dwStyles = WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
if(m_hwnd) dwStyles |= WS_CHILD;
if(!m_wnd.Create( m_hwnd, rect, szUrl.c_str(), dwStyles, WS_EX_CLIENTEDGE ))
{
__MPC_SET_ERROR_AND_EXIT(hr, E_FAIL);
}
m_wnd.ShowWindow( SW_SHOW );
__MPC_EXIT_IF_METHOD_FAILS(hr, HookUpEventSink());
}
else
{
if(!m_spWebBrowser2)
{
__MPC_EXIT_IF_METHOD_FAILS(hr, m_spUnkControl->QueryInterface( &m_spWebBrowser2 ));
}
__MPC_EXIT_IF_METHOD_FAILS(hr, m_spWebBrowser2->Navigate( CComBSTR( szUrl.c_str() ), NULL, NULL, NULL, NULL ));
}
//
// Wait for document to be loaded
//
__MPC_EXIT_IF_METHOD_FAILS(hr, WaitForDocComplete());
//
// If the URL don't match, it means the URL doesn't exist...
//
if(MPC::StrICmp( szUrl, m_spObjDisp->GetCurrentURL() ))
{
__MPC_SET_ERROR_AND_EXIT(hr, S_FALSE);
}
__MPC_EXIT_IF_METHOD_FAILS(hr, DoPrint());
//
// Since we now do a synchronous print operation, there's no need for snooping at the spool directory state.
//
//__MPC_EXIT_IF_METHOD_FAILS(hr, WaitForPrintComplete());
__MPC_EXIT_IF_METHOD_FAILS(hr, UpdatePrintBuffer());
hr = S_OK;
__HCP_FUNC_CLEANUP;
if(m_wnd.GetAbortState() == true)
{
hr = E_ABORT;
}
__HCP_FUNC_EXIT(hr);
}
HRESULT Printing::Print::HookUpEventSink()
{
__HCP_FUNC_ENTRY( "Printing::Print::HookUpEventSink" );
HRESULT hr;
m_spUnkControl.Release();
if(!m_wnd.m_hWnd)
{
__MPC_SET_ERROR_AND_EXIT(hr, E_FAIL);
}
//
// Hook up the connection point
//
__MPC_EXIT_IF_METHOD_FAILS(hr, MPC::CreateInstance( &m_spObjDisp ));
m_spObjDisp->SetNotificationEvent( m_eventDocComplete );
__MPC_EXIT_IF_METHOD_FAILS(hr, m_wnd.QueryControl( &m_spUnkControl ));
__MPC_EXIT_IF_METHOD_FAILS(hr, ::AtlAdvise( m_spUnkControl, m_spObjDisp, DIID_DWebBrowserEvents2, &m_dwCookie ));
hr = S_OK;
__HCP_FUNC_CLEANUP;
__HCP_FUNC_EXIT(hr);
}
HRESULT Printing::Print::WaitForDocComplete()
{
__HCP_FUNC_ENTRY( "Printing::Print::WaitForDocComplete" );
HRESULT hr;
if(MPC::WaitForSingleObject( m_eventDocComplete ) != WAIT_OBJECT_0)
{
__MPC_SET_ERROR_AND_EXIT(hr, E_ABORT);
}
hr = S_OK;
__HCP_FUNC_CLEANUP;
__HCP_FUNC_EXIT(hr);
}
HRESULT Printing::Print::WaitForPrintComplete()
{
__HCP_FUNC_ENTRY( "Printing::Print::WaitForPrintComplete" );
HRESULT hr;
HANDLE hFileChangeNotify;
HANDLE rgEventsToWait[2];
__MPC_EXIT_IF_CALL_RETURNS_NULL(hr, (hFileChangeNotify = ::FindFirstChangeNotificationW( m_szPrintDir.c_str(), FALSE, FILE_NOTIFY_CHANGE_SIZE )));
rgEventsToWait[0] = hFileChangeNotify;
rgEventsToWait[1] = m_eventAbortPrint;
for(;;)
{
DWORD dwRet;
dwRet = MPC::WaitForMultipleObjects( 2, rgEventsToWait, c_MaxWait );
if(dwRet == WAIT_OBJECT_0)
{
HANDLE hFile = ::CreateFileW( m_szPrintFile.c_str(), GENERIC_READ, FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL );
if(hFile != INVALID_HANDLE_VALUE)
{
DWORD dwSize = ::GetFileSize( hFile, NULL );
::CloseHandle( hFile );
if(dwSize != 0) break;
}
(void)::FindNextChangeNotification(hFileChangeNotify);
}
if(dwRet == WAIT_TIMEOUT ||
dwRet == WAIT_OBJECT_0 + 1 )
{
__MPC_SET_ERROR_AND_EXIT(hr, E_ABORT);
}
}
hr = S_OK;
__HCP_FUNC_CLEANUP;
if(hFileChangeNotify) ::FindCloseChangeNotification( hFileChangeNotify );
__HCP_FUNC_EXIT(hr);
}
HRESULT Printing::Print::DoPrint()
{
__HCP_FUNC_ENTRY( "Printing::Print::DoPrint" );
HRESULT hr;
// send the command to print
if(!m_spOleCmdTarg)
{
__MPC_EXIT_IF_METHOD_FAILS(hr, m_wnd.QueryControl( &m_spOleCmdTarg ));
}
//
// Make a synchronous print operation.
//
{
VARIANT vArgIN;
vArgIN.vt = VT_I2;
vArgIN.iVal = PRINT_WAITFORCOMPLETION;
__MPC_EXIT_IF_METHOD_FAILS(hr, m_spOleCmdTarg->Exec( NULL, OLECMDID_PRINT, OLECMDEXECOPT_PROMPTUSER, &vArgIN, NULL ));
}
hr = S_OK;
__HCP_FUNC_CLEANUP;
if(m_wnd.GetAbortState() == true)
{
hr = E_ABORT;
}
__HCP_FUNC_EXIT(hr);
}
HRESULT Printing::Print::PreparePrintFileLoc()
{
__HCP_FUNC_ENTRY( "Printing::Print::PreparePrintFileLoc" );
HRESULT hr;
MPC::wstring szWritablePath;
MPC::wstring szPrintData;
CComPtr<MPC::FileStream> stream;
__MPC_EXIT_IF_METHOD_FAILS(hr, MPC::GetUserWritablePath( m_szPrintDir, HC_ROOT_HELPCTR L"\\Spool" ));
__MPC_EXIT_IF_METHOD_FAILS(hr, MPC::GetTemporaryFileName( m_szPrintFile, m_szPrintDir.c_str() ));
__MPC_EXIT_IF_METHOD_FAILS(hr, MPC::GetTemporaryFileName( szPrintData , m_szPrintDir.c_str() ));
//
// Create a stream for a temporary file.
//
__MPC_EXIT_IF_METHOD_FAILS(hr, MPC::CreateInstance( &stream ));
__MPC_EXIT_IF_METHOD_FAILS(hr, stream->InitForReadWrite( szPrintData.c_str() ));
__MPC_EXIT_IF_METHOD_FAILS(hr, stream->DeleteOnRelease ( ));
m_streamPrintData = stream;
hr = S_OK;
__HCP_FUNC_CLEANUP;
__HCP_FUNC_EXIT(hr);
}
HRESULT Printing::Print::UpdatePrintBuffer()
{
__HCP_FUNC_ENTRY( "Printing::Print::UpdatePrintBuffer" );
HRESULT hr;
CComPtr<MPC::FileStream> stream;
//
// Open the single-topic print file and copy it to the multi-topic print file.
//
__MPC_EXIT_IF_METHOD_FAILS(hr, MPC::CreateInstance( &stream ));
__MPC_EXIT_IF_METHOD_FAILS(hr, stream->InitForRead ( m_szPrintFile.c_str() ));
__MPC_EXIT_IF_METHOD_FAILS(hr, stream->DeleteOnRelease( ));
__MPC_EXIT_IF_METHOD_FAILS(hr, MPC::BaseStream::TransferData( stream, m_streamPrintData ));
hr = S_OK;
__HCP_FUNC_CLEANUP;
__HCP_FUNC_EXIT(hr);
}
HRESULT Printing::Print::RawDataToPrinter()
{
__HCP_FUNC_ENTRY( "Printing::Print::RawDataToPrinter" );
HRESULT hr;
HANDLE hPrinter = NULL;
DWORD dwJob = 0;
//
// Reset stream to beginning.
//
{
LARGE_INTEGER li;
li.LowPart = 0;
li.HighPart = 0;
__MPC_EXIT_IF_METHOD_FAILS(hr, m_streamPrintData->Seek( li, STREAM_SEEK_SET, NULL ));
}
//
// Open the printer, create a job and copy all the data into it.
//
{
DOC_INFO_1W docinfo;
BYTE rgBuf[1024];
ULONG dwRead;
DWORD dwWritten;
MPC::wstring strTitle; MPC::LocalizeString( IDS_HELPCTR_PRINT_TITLE, strTitle );
// Fill in the structure with info about this "document."
docinfo.pDocName = (LPWSTR)strTitle.c_str();;
docinfo.pOutputFile = NULL;
docinfo.pDatatype = L"RAW";
__MPC_EXIT_IF_CALL_RETURNS_FALSE(hr, ::OpenPrinterW( m_wnd.GetPrinterName(), &hPrinter, NULL ));
// Inform the spooler the document is beginning.
__MPC_EXIT_IF_CALL_RETURNS_ZERO(hr, (dwJob = ::StartDocPrinterW( hPrinter, 1, (LPBYTE)&docinfo )));
__MPC_EXIT_IF_CALL_RETURNS_FALSE(hr, ::StartPagePrinter( hPrinter ));
while(1)
{
__MPC_EXIT_IF_METHOD_FAILS(hr, m_streamPrintData->Read( rgBuf, sizeof(rgBuf), &dwRead ));
if(hr == S_FALSE || dwRead == 0) // End of File.
{
break;
}
__MPC_EXIT_IF_CALL_RETURNS_FALSE(hr, ::WritePrinter( hPrinter, rgBuf, dwRead, &dwWritten ));
}
}
hr = S_OK;
__HCP_FUNC_CLEANUP;
if(hPrinter)
{
if(dwJob)
{
// End the page.
if(!::EndPagePrinter( hPrinter ))
{
if(SUCCEEDED(hr))
{
hr = HRESULT_FROM_WIN32(::GetLastError());
}
}
// Inform the spooler that the document is ending.
if(!::EndDocPrinter( hPrinter ))
{
if(SUCCEEDED(hr))
{
hr = HRESULT_FROM_WIN32(::GetLastError());
}
}
}
// Tidy up the printer handle.
if(!::ClosePrinter( hPrinter ))
{
if(SUCCEEDED(hr))
{
hr = HRESULT_FROM_WIN32(::GetLastError());
}
}
}
__HCP_FUNC_EXIT(hr);
}