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