// Copyright (c) 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #include "printing/printing_context_win.h" #include #include #include #include #include "base/bind.h" #include "base/check.h" #include "base/check_op.h" #include "base/memory/free_deleter.h" #include "base/strings/string_number_conversions.h" #include "base/strings/utf_string_conversions.h" #include "base/task/current_thread.h" #include "printing/backend/print_backend.h" #include "printing/backend/win_helper.h" #include "printing/buildflags/buildflags.h" #include "printing/metafile.h" #include "printing/metafile_skia.h" #include "printing/mojom/print.mojom.h" #include "printing/page_setup.h" #include "printing/print_settings_initializer_win.h" #include "printing/printed_document.h" #include "printing/printed_page_win.h" #include "printing/printing_context_system_dialog_win.h" #include "printing/printing_features.h" #include "printing/printing_utils.h" #include "printing/units.h" #include "skia/ext/skia_utils_win.h" #include "ui/aura/window.h" #include "ui/aura/window_tree_host.h" namespace printing { namespace { // Helper class to ensure that a saved device context state gets restored at end // of scope. class ScopedSavedState { public: ScopedSavedState(HDC context) : context_(context), saved_state_(SaveDC(context)) { DCHECK_NE(saved_state_, 0); } ~ScopedSavedState() { BOOL res = RestoreDC(context_, saved_state_); DCHECK_NE(res, 0); } private: HDC context_; int saved_state_; }; void AssignResult(mojom::ResultCode* out, mojom::ResultCode in) { *out = in; } void SimpleModifyWorldTransform(HDC context, int offset_x, int offset_y, float shrink_factor) { XFORM xform = {0}; xform.eDx = static_cast(offset_x); xform.eDy = static_cast(offset_y); xform.eM11 = xform.eM22 = 1.f / shrink_factor; BOOL res = ModifyWorldTransform(context, &xform, MWT_LEFTMULTIPLY); DCHECK_NE(res, 0); } } // namespace // static std::unique_ptr PrintingContext::CreateImpl( Delegate* delegate, bool skip_system_calls) { std::unique_ptr context; context = std::make_unique(delegate); #if BUILDFLAG(ENABLE_OOP_PRINTING) if (skip_system_calls) context->set_skip_system_calls(); #endif return context; } PrintingContextWin::PrintingContextWin(Delegate* delegate) : PrintingContext(delegate), context_(nullptr) {} PrintingContextWin::~PrintingContextWin() { ReleaseContext(); } void PrintingContextWin::AskUserForSettings(int max_pages, bool has_selection, bool is_scripted, PrintSettingsCallback callback) { NOTIMPLEMENTED(); } mojom::ResultCode PrintingContextWin::UseDefaultSettings() { DCHECK(!in_print_job_); scoped_refptr backend = PrintBackend::CreateInstance(delegate_->GetAppLocale()); std::string default_printer_name; mojom::ResultCode result = backend->GetDefaultPrinterName(default_printer_name); if (result != mojom::ResultCode::kSuccess) return result; std::wstring default_printer = base::UTF8ToWide(default_printer_name); if (!default_printer.empty()) { ScopedPrinterHandle printer; if (printer.OpenPrinterWithName(default_printer.c_str())) { std::unique_ptr dev_mode = CreateDevMode(printer.Get(), nullptr); if (InitializeSettings(default_printer, dev_mode.get()) == mojom::ResultCode::kSuccess) { return mojom::ResultCode::kSuccess; } } } ReleaseContext(); // No default printer configured, do we have any printers at all? DWORD bytes_needed = 0; DWORD count_returned = 0; (void)::EnumPrinters(PRINTER_ENUM_LOCAL | PRINTER_ENUM_CONNECTIONS, nullptr, 2, nullptr, 0, &bytes_needed, &count_returned); if (bytes_needed) { DCHECK_GE(bytes_needed, count_returned * sizeof(PRINTER_INFO_2)); std::vector printer_info_buffer(bytes_needed); BOOL ret = ::EnumPrinters(PRINTER_ENUM_LOCAL | PRINTER_ENUM_CONNECTIONS, nullptr, 2, printer_info_buffer.data(), bytes_needed, &bytes_needed, &count_returned); if (ret && count_returned) { // have printers // Open the first successfully found printer. const PRINTER_INFO_2* info_2 = reinterpret_cast(printer_info_buffer.data()); const PRINTER_INFO_2* info_2_end = info_2 + count_returned; for (; info_2 < info_2_end; ++info_2) { ScopedPrinterHandle printer; if (!printer.OpenPrinterWithName(info_2->pPrinterName)) continue; std::unique_ptr dev_mode = CreateDevMode(printer.Get(), nullptr); if (InitializeSettings(info_2->pPrinterName, dev_mode.get()) == mojom::ResultCode::kSuccess) { return mojom::ResultCode::kSuccess; } } if (context_) return mojom::ResultCode::kSuccess; } } return OnError(); } gfx::Size PrintingContextWin::GetPdfPaperSizeDeviceUnits() { // Default fallback to Letter size. gfx::SizeF paper_size(kLetterWidthInch, kLetterHeightInch); // Get settings from locale. Paper type buffer length is at most 4. const int paper_type_buffer_len = 4; wchar_t paper_type_buffer[paper_type_buffer_len] = {0}; GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_IPAPERSIZE, paper_type_buffer, paper_type_buffer_len); if (wcslen(paper_type_buffer)) { // The call succeeded. int paper_code = _wtoi(paper_type_buffer); switch (paper_code) { case DMPAPER_LEGAL: paper_size.SetSize(kLegalWidthInch, kLegalHeightInch); break; case DMPAPER_A4: paper_size.SetSize(kA4WidthInch, kA4HeightInch); break; case DMPAPER_A3: paper_size.SetSize(kA3WidthInch, kA3HeightInch); break; default: // DMPAPER_LETTER is used for default fallback. break; } } return gfx::Size(paper_size.width() * settings_->device_units_per_inch(), paper_size.height() * settings_->device_units_per_inch()); } mojom::ResultCode PrintingContextWin::UpdatePrinterSettings( const PrinterSettings& printer_settings) { DCHECK(!in_print_job_); ScopedPrinterHandle printer; if (!printer.OpenPrinterWithName(base::as_wcstr(settings_->device_name()))) return OnError(); // Make printer changes local to Chrome. // See MSDN documentation regarding DocumentProperties. std::unique_ptr scoped_dev_mode = CreateDevModeWithColor(printer.Get(), base::UTF16ToWide(settings_->device_name()), settings_->color() != mojom::ColorModel::kGray); if (!scoped_dev_mode) return OnError(); { DEVMODE* dev_mode = scoped_dev_mode.get(); dev_mode->dmCopies = std::max(settings_->copies(), 1); if (dev_mode->dmCopies > 1) { // do not change unless multiple copies dev_mode->dmFields |= DM_COPIES; dev_mode->dmCollate = settings_->collate() ? DMCOLLATE_TRUE : DMCOLLATE_FALSE; } switch (settings_->duplex_mode()) { case mojom::DuplexMode::kLongEdge: dev_mode->dmFields |= DM_DUPLEX; dev_mode->dmDuplex = DMDUP_VERTICAL; break; case mojom::DuplexMode::kShortEdge: dev_mode->dmFields |= DM_DUPLEX; dev_mode->dmDuplex = DMDUP_HORIZONTAL; break; case mojom::DuplexMode::kSimplex: dev_mode->dmFields |= DM_DUPLEX; dev_mode->dmDuplex = DMDUP_SIMPLEX; break; default: // kUnknownDuplexMode break; } dev_mode->dmFields |= DM_ORIENTATION; dev_mode->dmOrientation = settings_->landscape() ? DMORIENT_LANDSCAPE : DMORIENT_PORTRAIT; if (settings_->dpi_horizontal() > 0) { dev_mode->dmPrintQuality = settings_->dpi_horizontal(); dev_mode->dmFields |= DM_PRINTQUALITY; } if (settings_->dpi_vertical() > 0) { dev_mode->dmYResolution = settings_->dpi_vertical(); dev_mode->dmFields |= DM_YRESOLUTION; } const PrintSettings::RequestedMedia& requested_media = settings_->requested_media(); unsigned id = 0; // If the paper size is a custom user size, setting by ID may not work. if (base::StringToUint(requested_media.vendor_id, &id) && id && id < DMPAPER_USER) { dev_mode->dmFields |= DM_PAPERSIZE; dev_mode->dmPaperSize = static_cast(id); } else if (!requested_media.size_microns.IsEmpty()) { static constexpr int kFromUm = 100; // Windows uses 0.1mm. dev_mode->dmFields |= DM_PAPERWIDTH | DM_PAPERLENGTH; dev_mode->dmPaperWidth = requested_media.size_microns.width() / kFromUm; dev_mode->dmPaperLength = requested_media.size_microns.height() / kFromUm; } } // Update data using DocumentProperties. if (printer_settings.show_system_dialog) { mojom::ResultCode result = mojom::ResultCode::kFailed; AskUserForSettings(printer_settings.page_count, /*has_selection=*/false, /*is_scripted=*/false, base::BindOnce(&AssignResult, &result)); return result; } // Set printer then refresh printer settings. scoped_dev_mode = CreateDevMode(printer.Get(), scoped_dev_mode.get()); if (!scoped_dev_mode) return OnError(); // Since CreateDevMode() doesn't honor color settings through the GDI call // to DocumentProperties(), ensure the requested values persist here. scoped_dev_mode->dmFields |= DM_COLOR; scoped_dev_mode->dmColor = settings_->color() != mojom::ColorModel::kGray ? DMCOLOR_COLOR : DMCOLOR_MONOCHROME; return InitializeSettings(base::UTF16ToWide(settings_->device_name()), scoped_dev_mode.get()); } mojom::ResultCode PrintingContextWin::InitWithSettingsForTest( std::unique_ptr settings) { DCHECK(!in_print_job_); settings_ = std::move(settings); // TODO(maruel): settings_.ToDEVMODE() ScopedPrinterHandle printer; if (!printer.OpenPrinterWithName(base::as_wcstr(settings_->device_name()))) { return logging::GetLastSystemErrorCode() == ERROR_ACCESS_DENIED ? mojom::ResultCode::kAccessDenied : mojom::ResultCode::kFailed; } std::unique_ptr dev_mode = CreateDevMode(printer.Get(), nullptr); return InitializeSettings(base::UTF16ToWide(settings_->device_name()), dev_mode.get()); } mojom::ResultCode PrintingContextWin::NewDocument( const std::u16string& document_name) { DCHECK(!in_print_job_); if (!context_ && !skip_system_calls()) return OnError(); // Set the flag used by the AbortPrintJob dialog procedure. abort_printing_ = false; in_print_job_ = true; if (skip_system_calls()) return mojom::ResultCode::kSuccess; if (base::FeatureList::IsEnabled(printing::features::kUseXpsForPrinting)) { // This is all the new document context needed when using XPS. return mojom::ResultCode::kSuccess; } // Need more context setup when using GDI. // Register the application's AbortProc function with GDI. if (SP_ERROR == SetAbortProc(context_, &AbortProc)) return OnError(); DCHECK(SimplifyDocumentTitle(document_name) == document_name); DOCINFO di = {sizeof(DOCINFO)}; di.lpszDocName = base::as_wcstr(document_name); // Is there a debug dump directory specified? If so, force to print to a file. if (PrintedDocument::HasDebugDumpPath()) { base::FilePath debug_dump_path = PrintedDocument::CreateDebugDumpPath( document_name, FILE_PATH_LITERAL(".prn")); if (!debug_dump_path.empty()) di.lpszOutput = debug_dump_path.value().c_str(); } // No message loop running in unit tests. DCHECK(!base::CurrentThread::Get() || !base::CurrentThread::Get()->NestableTasksAllowed()); // Begin a print job by calling the StartDoc function. // NOTE: StartDoc() starts a message loop. That causes a lot of problems with // IPC. Make sure recursive task processing is disabled. if (StartDoc(context_, &di) <= 0) return OnError(); return mojom::ResultCode::kSuccess; } mojom::ResultCode PrintingContextWin::RenderPage(const PrintedPage& page, const PageSetup& page_setup) { if (abort_printing_) return mojom::ResultCode::kCanceled; DCHECK(context_); DCHECK(in_print_job_); gfx::Rect content_area = GetCenteredPageContentRect( page_setup.physical_size(), page.page_size(), page.page_content_rect()); // Save the state to make sure the context this function call does not modify // the device context. ScopedSavedState saved_state(context_); skia::InitializeDC(context_); { // Save the state (again) to apply the necessary world transformation. ScopedSavedState saved_state_inner(context_); // Setup the matrix to translate and scale to the right place. Take in // account the actual shrinking factor. // Note that the printing output is relative to printable area of the page. // That is 0,0 is offset by PHYSICALOFFSETX/Y from the page. SimpleModifyWorldTransform( context_, content_area.x() - page_setup.printable_area().x(), content_area.y() - page_setup.printable_area().y(), page.shrink_factor()); if (::StartPage(context_) <= 0) return mojom::ResultCode::kFailed; bool played_back = page.metafile()->SafePlayback(context_); DCHECK(played_back); if (::EndPage(context_) <= 0) return mojom::ResultCode::kFailed; } return mojom::ResultCode::kSuccess; } mojom::ResultCode PrintingContextWin::PrintDocument( const MetafilePlayer& metafile, const PrintSettings& settings, uint32_t num_pages) { // TODO(crbug.com/1008222) NOTIMPLEMENTED(); return mojom::ResultCode::kFailed; } mojom::ResultCode PrintingContextWin::DocumentDone() { if (abort_printing_) return mojom::ResultCode::kCanceled; DCHECK(in_print_job_); DCHECK(context_); // Inform the driver that document has ended. if (EndDoc(context_) <= 0) return OnError(); ResetSettings(); return mojom::ResultCode::kSuccess; } void PrintingContextWin::Cancel() { abort_printing_ = true; in_print_job_ = false; if (context_) CancelDC(context_); } void PrintingContextWin::ReleaseContext() { if (context_) { DeleteDC(context_); context_ = nullptr; } } printing::NativeDrawingContext PrintingContextWin::context() const { return context_; } // static BOOL PrintingContextWin::AbortProc(HDC hdc, int nCode) { if (nCode) { // TODO(maruel): Need a way to find the right instance to set. Should // leverage PrintJobManager here? // abort_printing_ = true; } return true; } mojom::ResultCode PrintingContextWin::InitializeSettings( const std::wstring& device_name, DEVMODE* dev_mode) { if (!dev_mode) return OnError(); ReleaseContext(); context_ = CreateDC(L"WINSPOOL", device_name.c_str(), nullptr, dev_mode); if (!context_) return OnError(); skia::InitializeDC(context_); DCHECK(!in_print_job_); settings_->set_device_name(base::WideToUTF16(device_name)); PrintSettingsInitializerWin::InitPrintSettings(context_, *dev_mode, settings_.get()); return mojom::ResultCode::kSuccess; } mojom::ResultCode PrintingContextWin::OnError() { mojom::ResultCode result; if (abort_printing_) { result = mojom::ResultCode::kCanceled; } else { result = logging::GetLastSystemErrorCode() == ERROR_ACCESS_DENIED ? mojom::ResultCode::kAccessDenied : mojom::ResultCode::kFailed; } ResetSettings(); return result; } HWND PrintingContextWin::GetRootWindow(gfx::NativeView view) { HWND window = nullptr; if (view && view->GetHost()) window = view->GetHost()->GetAcceleratedWidget(); if (!window) { // TODO(maruel): b/1214347 Get the right browser window instead. return GetDesktopWindow(); } return window; } } // namespace printing