printing/printing_context_win.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "printing/printing_context_win.h"
   6
   7 #include <algorithm>
   8 #include <vector>
   9
  10 #include "base/bind.h"
  11 #include "base/memory/free_deleter.h"
  12 #include "base/memory/ptr_util.h"
  13 #include "base/message_loop/message_loop_current.h"
  14 #include "base/strings/string_number_conversions.h"
  15 #include "base/strings/utf_string_conversions.h"
  16 #include "printing/backend/print_backend.h"
  17 #include "printing/backend/win_helper.h"
  18 #include "printing/buildflags/buildflags.h"
  19 #include "printing/print_settings_initializer_win.h"
  20 #include "printing/printed_document.h"
  21 #include "printing/printing_context_system_dialog_win.h"
  22 #include "printing/printing_utils.h"
  23 #include "printing/units.h"
  24 #include "skia/ext/skia_utils_win.h"
  25 #include "ui/aura/window.h"
  26 #include "ui/aura/window_tree_host.h"
  27
  28 namespace printing {
  29
  30 namespace {
  31
  32 void AssignResult(PrintingContext::Result* out, PrintingContext::Result in) {
  33   *out = in;
  34 }
  35
  36 }  // namespace
  37
  38 // static
  39 std::unique_ptr<PrintingContext> PrintingContext::Create(Delegate* delegate) {
  40 #if BUILDFLAG(ENABLE_PRINTING)
  41   return base::WrapUnique(new PrintingContextSystemDialogWin(delegate));
  42 #else
  43   // The code in printing/ is still built when the GN |enable_basic_printing|
  44   // variable is set to false. Just return PrintingContextWin as a dummy
  45   // context.
  46   return base::WrapUnique(new PrintingContextWin(delegate));
  47 #endif
  48 }
  49
  50 PrintingContextWin::PrintingContextWin(Delegate* delegate)
  51     : PrintingContext(delegate), context_(nullptr) {}
  52
  53 PrintingContextWin::~PrintingContextWin() {
  54   ReleaseContext();
  55 }
  56
  57 void PrintingContextWin::AskUserForSettings(int max_pages,
  58                                             bool has_selection,
  59                                             bool is_scripted,
  60                                             PrintSettingsCallback callback) {
  61   NOTIMPLEMENTED();
  62 }
  63
  64 PrintingContext::Result PrintingContextWin::UseDefaultSettings() {
  65   DCHECK(!in_print_job_);
  66
  67   scoped_refptr<PrintBackend> backend = PrintBackend::CreateInstance(nullptr);
  68   base::string16 default_printer =
  69       base::UTF8ToWide(backend->GetDefaultPrinterName());
  70   if (!default_printer.empty()) {
  71     ScopedPrinterHandle printer;
  72     if (printer.OpenPrinter(default_printer.c_str())) {
  73       std::unique_ptr<DEVMODE, base::FreeDeleter> dev_mode =
  74           CreateDevMode(printer.Get(), nullptr);
  75       if (InitializeSettings(default_printer, dev_mode.get()) == OK)
  76         return OK;
  77     }
  78   }
  79
  80   ReleaseContext();
  81
  82   // No default printer configured, do we have any printers at all?
  83   DWORD bytes_needed = 0;
  84   DWORD count_returned = 0;
  85   (void)::EnumPrinters(PRINTER_ENUM_LOCAL | PRINTER_ENUM_CONNECTIONS, nullptr,
  86                        2, nullptr, 0, &bytes_needed, &count_returned);
  87   if (bytes_needed) {
  88     DCHECK_GE(bytes_needed, count_returned * sizeof(PRINTER_INFO_2));
  89     std::vector<BYTE> printer_info_buffer(bytes_needed);
  90     BOOL ret = ::EnumPrinters(PRINTER_ENUM_LOCAL | PRINTER_ENUM_CONNECTIONS,
  91                               nullptr, 2, printer_info_buffer.data(),
  92                               bytes_needed, &bytes_needed, &count_returned);
  93     if (ret && count_returned) {  // have printers
  94       // Open the first successfully found printer.
  95       const PRINTER_INFO_2* info_2 =
  96           reinterpret_cast<PRINTER_INFO_2*>(printer_info_buffer.data());
  97       const PRINTER_INFO_2* info_2_end = info_2 + count_returned;
  98       for (; info_2 < info_2_end; ++info_2) {
  99         ScopedPrinterHandle printer;
 100         if (!printer.OpenPrinter(info_2->pPrinterName))
 101           continue;
 102         std::unique_ptr<DEVMODE, base::FreeDeleter> dev_mode =
 103             CreateDevMode(printer.Get(), nullptr);
 104         if (InitializeSettings(info_2->pPrinterName, dev_mode.get()) == OK)
 105           return OK;
 106       }
 107       if (context_)
 108         return OK;
 109     }
 110   }
 111
 112   return OnError();
 113 }
 114
 115 gfx::Size PrintingContextWin::GetPdfPaperSizeDeviceUnits() {
 116   // Default fallback to Letter size.
 117   gfx::SizeF paper_size(kLetterWidthInch, kLetterHeightInch);
 118
 119   // Get settings from locale. Paper type buffer length is at most 4.
 120   const int paper_type_buffer_len = 4;
 121   wchar_t paper_type_buffer[paper_type_buffer_len] = {0};
 122   GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_IPAPERSIZE, paper_type_buffer,
 123                 paper_type_buffer_len);
 124   if (wcslen(paper_type_buffer)) {  // The call succeeded.
 125     int paper_code = _wtoi(paper_type_buffer);
 126     switch (paper_code) {
 127       case DMPAPER_LEGAL:
 128         paper_size.SetSize(kLegalWidthInch, kLegalHeightInch);
 129         break;
 130       case DMPAPER_A4:
 131         paper_size.SetSize(kA4WidthInch, kA4HeightInch);
 132         break;
 133       case DMPAPER_A3:
 134         paper_size.SetSize(kA3WidthInch, kA3HeightInch);
 135         break;
 136       default:  // DMPAPER_LETTER is used for default fallback.
 137         break;
 138     }
 139   }
 140   return gfx::Size(
 141       paper_size.width() * settings_.device_units_per_inch(),
 142       paper_size.height() * settings_.device_units_per_inch());
 143 }
 144
 145 PrintingContext::Result PrintingContextWin::UpdatePrinterSettings(
 146     bool external_preview,
 147     bool show_system_dialog,
 148     int page_count) {
 149   DCHECK(!in_print_job_);
 150   DCHECK(!external_preview) << "Not implemented";
 151
 152   ScopedPrinterHandle printer;
 153   if (!printer.OpenPrinter(settings_.device_name().c_str()))
 154     return OnError();
 155
 156   // Make printer changes local to Chrome.
 157   // See MSDN documentation regarding DocumentProperties.
 158   std::unique_ptr<DEVMODE, base::FreeDeleter> scoped_dev_mode =
 159       CreateDevModeWithColor(printer.Get(), settings_.device_name(),
 160                              settings_.color() != GRAY);
 161   if (!scoped_dev_mode)
 162     return OnError();
 163
 164   {
 165     DEVMODE* dev_mode = scoped_dev_mode.get();
 166     dev_mode->dmCopies = std::max(settings_.copies(), 1);
 167     if (dev_mode->dmCopies > 1) {  // do not change unless multiple copies
 168       dev_mode->dmFields |= DM_COPIES;
 169       dev_mode->dmCollate = settings_.collate() ? DMCOLLATE_TRUE :
 170                                                   DMCOLLATE_FALSE;
 171     }
 172
 173     switch (settings_.duplex_mode()) {
 174       case LONG_EDGE:
 175         dev_mode->dmFields |= DM_DUPLEX;
 176         dev_mode->dmDuplex = DMDUP_VERTICAL;
 177         break;
 178       case SHORT_EDGE:
 179         dev_mode->dmFields |= DM_DUPLEX;
 180         dev_mode->dmDuplex = DMDUP_HORIZONTAL;
 181         break;
 182       case SIMPLEX:
 183         dev_mode->dmFields |= DM_DUPLEX;
 184         dev_mode->dmDuplex = DMDUP_SIMPLEX;
 185         break;
 186       default:  // UNKNOWN_DUPLEX_MODE
 187         break;
 188     }
 189
 190     dev_mode->dmFields |= DM_ORIENTATION;
 191     dev_mode->dmOrientation = settings_.landscape() ? DMORIENT_LANDSCAPE :
 192                                                       DMORIENT_PORTRAIT;
 193
 194     if (settings_.dpi_horizontal() > 0) {
 195       dev_mode->dmPrintQuality = settings_.dpi_horizontal();
 196       dev_mode->dmFields |= DM_PRINTQUALITY;
 197     }
 198     if (settings_.dpi_vertical() > 0) {
 199       dev_mode->dmYResolution = settings_.dpi_vertical();
 200       dev_mode->dmFields |= DM_YRESOLUTION;
 201     }
 202
 203     const PrintSettings::RequestedMedia& requested_media =
 204         settings_.requested_media();
 205     unsigned id = 0;
 206     // If the paper size is a custom user size, setting by ID may not work.
 207     if (base::StringToUint(requested_media.vendor_id, &id) && id &&
 208         id < DMPAPER_USER) {
 209       dev_mode->dmFields |= DM_PAPERSIZE;
 210       dev_mode->dmPaperSize = static_cast<short>(id);
 211     } else if (!requested_media.size_microns.IsEmpty()) {
 212       static constexpr int kFromUm = 100;  // Windows uses 0.1mm.
 213       dev_mode->dmFields |= DM_PAPERWIDTH | DM_PAPERLENGTH;
 214       dev_mode->dmPaperWidth = requested_media.size_microns.width() / kFromUm;
 215       dev_mode->dmPaperLength = requested_media.size_microns.height() / kFromUm;
 216     }
 217   }
 218
 219   // Update data using DocumentProperties.
 220   if (show_system_dialog) {
 221     PrintingContext::Result result = PrintingContext::FAILED;
 222     AskUserForSettings(page_count, false, false,
 223                        base::BindOnce(&AssignResult, &result));
 224     return result;
 225   }
 226   // Set printer then refresh printer settings.
 227   scoped_dev_mode = CreateDevMode(printer.Get(), scoped_dev_mode.get());
 228   return InitializeSettings(settings_.device_name(), scoped_dev_mode.get());
 229 }
 230
 231 PrintingContext::Result PrintingContextWin::InitWithSettingsForTest(
 232     const PrintSettings& settings) {
 233   DCHECK(!in_print_job_);
 234
 235   settings_ = settings;
 236
 237   // TODO(maruel): settings_.ToDEVMODE()
 238   ScopedPrinterHandle printer;
 239   if (!printer.OpenPrinter(settings_.device_name().c_str()))
 240     return FAILED;
 241
 242   std::unique_ptr<DEVMODE, base::FreeDeleter> dev_mode =
 243       CreateDevMode(printer.Get(), nullptr);
 244
 245   return InitializeSettings(settings_.device_name(), dev_mode.get());
 246 }
 247
 248 PrintingContext::Result PrintingContextWin::NewDocument(
 249     const base::string16& document_name) {
 250   DCHECK(!in_print_job_);
 251   if (!context_)
 252     return OnError();
 253
 254   // Set the flag used by the AbortPrintJob dialog procedure.
 255   abort_printing_ = false;
 256
 257   in_print_job_ = true;
 258
 259   // Register the application's AbortProc function with GDI.
 260   if (SP_ERROR == SetAbortProc(context_, &AbortProc))
 261     return OnError();
 262
 263   DCHECK(SimplifyDocumentTitle(document_name) == document_name);
 264   DOCINFO di = { sizeof(DOCINFO) };
 265   di.lpszDocName = document_name.c_str();
 266
 267   // Is there a debug dump directory specified? If so, force to print to a file.
 268   if (PrintedDocument::HasDebugDumpPath()) {
 269     base::FilePath debug_dump_path = PrintedDocument::CreateDebugDumpPath(
 270         document_name, FILE_PATH_LITERAL(".prn"));
 271     if (!debug_dump_path.empty())
 272       di.lpszOutput = debug_dump_path.value().c_str();
 273   }
 274
 275   // No message loop running in unit tests.
 276   DCHECK(!base::MessageLoopCurrent::Get() ||
 277          !base::MessageLoopCurrent::Get()->NestableTasksAllowed());
 278
 279   // Begin a print job by calling the StartDoc function.
 280   // NOTE: StartDoc() starts a message loop. That causes a lot of problems with
 281   // IPC. Make sure recursive task processing is disabled.
 282   if (StartDoc(context_, &di) <= 0)
 283     return OnError();
 284
 285   return OK;
 286 }
 287
 288 PrintingContext::Result PrintingContextWin::NewPage() {
 289   if (abort_printing_)
 290     return CANCEL;
 291   DCHECK(context_);
 292   DCHECK(in_print_job_);
 293
 294   // Intentional No-op. MetafileSkia::SafePlayback takes care of calling
 295   // ::StartPage().
 296
 297   return OK;
 298 }
 299
 300 PrintingContext::Result PrintingContextWin::PageDone() {
 301   if (abort_printing_)
 302     return CANCEL;
 303   DCHECK(in_print_job_);
 304
 305   // Intentional No-op. MetafileSkia::SafePlayback takes care of calling
 306   // ::EndPage().
 307
 308   return OK;
 309 }
 310
 311 PrintingContext::Result PrintingContextWin::DocumentDone() {
 312   if (abort_printing_)
 313     return CANCEL;
 314   DCHECK(in_print_job_);
 315   DCHECK(context_);
 316
 317   // Inform the driver that document has ended.
 318   if (EndDoc(context_) <= 0)
 319     return OnError();
 320
 321   ResetSettings();
 322   return OK;
 323 }
 324
 325 void PrintingContextWin::Cancel() {
 326   abort_printing_ = true;
 327   in_print_job_ = false;
 328   if (context_)
 329     CancelDC(context_);
 330 }
 331
 332 void PrintingContextWin::ReleaseContext() {
 333   if (context_) {
 334     DeleteDC(context_);
 335     context_ = nullptr;
 336   }
 337 }
 338
 339 printing::NativeDrawingContext PrintingContextWin::context() const {
 340   return context_;
 341 }
 342
 343 // static
 344 BOOL PrintingContextWin::AbortProc(HDC hdc, int nCode) {
 345   if (nCode) {
 346     // TODO(maruel):  Need a way to find the right instance to set. Should
 347     // leverage PrintJobManager here?
 348     // abort_printing_ = true;
 349   }
 350   return true;
 351 }
 352
 353 PrintingContext::Result PrintingContextWin::InitializeSettings(
 354     const std::wstring& device_name,
 355     DEVMODE* dev_mode) {
 356   if (!dev_mode)
 357     return OnError();
 358
 359   ReleaseContext();
 360   context_ = CreateDC(L"WINSPOOL", device_name.c_str(), nullptr, dev_mode);
 361   if (!context_)
 362     return OnError();
 363
 364   skia::InitializeDC(context_);
 365
 366   DCHECK(!in_print_job_);
 367   settings_.set_device_name(device_name);
 368   PrintSettingsInitializerWin::InitPrintSettings(
 369       context_, *dev_mode, &settings_);
 370
 371   return OK;
 372 }
 373
 374 HWND PrintingContextWin::GetRootWindow(gfx::NativeView view) {
 375   HWND window = nullptr;
 376   if (view && view->GetHost())
 377     window = view->GetHost()->GetAcceleratedWidget();
 378   if (!window) {
 379     // TODO(maruel):  b/1214347 Get the right browser window instead.
 380     return GetDesktopWindow();
 381   }
 382   return window;
 383 }
 384
 385 }  // namespace printing