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 <winspool.h>
      8 
      9 #include <algorithm>
     10 
     11 #include "base/i18n/file_util_icu.h"
     12 #include "base/i18n/time_formatting.h"
     13 #include "base/message_loop/message_loop.h"
     14 #include "base/metrics/histogram.h"
     15 #include "base/strings/utf_string_conversions.h"
     16 #include "base/time/time.h"
     17 #include "base/values.h"
     18 #include "base/win/metro.h"
     19 #include "printing/backend/print_backend.h"
     20 #include "printing/backend/printing_info_win.h"
     21 #include "printing/backend/win_helper.h"
     22 #include "printing/print_job_constants.h"
     23 #include "printing/print_settings_initializer_win.h"
     24 #include "printing/printed_document.h"
     25 #include "printing/units.h"
     26 #include "skia/ext/platform_device.h"
     27 #include "win8/util/win8_util.h"
     28 
     29 #if defined(USE_AURA)
     30 #include "ui/aura/remote_root_window_host_win.h"
     31 #include "ui/aura/root_window.h"
     32 #include "ui/aura/window.h"
     33 #endif
     34 
     35 using base::Time;
     36 
     37 namespace {
     38 
     39 // Constants for setting default PDF settings.
     40 const int kPDFDpi = 300;  // 300 dpi
     41 // LETTER: 8.5 x 11 inches
     42 const int kPDFLetterWidth = 8.5 * kPDFDpi;
     43 const int kPDFLetterHeight = 11 * kPDFDpi;
     44 // LEGAL: 8.5 x 14 inches
     45 const int kPDFLegalWidth = 8.5 * kPDFDpi;
     46 const int kPDFLegalHeight = 14 * kPDFDpi;
     47 // A4: 8.27 x 11.69 inches
     48 const int kPDFA4Width = 8.27 * kPDFDpi;
     49 const int kPDFA4Height = 11.69 * kPDFDpi;
     50 // A3: 11.69 x 16.54 inches
     51 const int kPDFA3Width = 11.69 * kPDFDpi;
     52 const int kPDFA3Height = 16.54 * kPDFDpi;
     53 
     54 HWND GetRootWindow(gfx::NativeView view) {
     55   HWND window = NULL;
     56 #if defined(USE_AURA)
     57   if (view)
     58     window = view->GetRootWindow()->GetAcceleratedWidget();
     59 #else
     60   if (view && IsWindow(view)) {
     61     window = GetAncestor(view, GA_ROOTOWNER);
     62   }
     63 #endif
     64   if (!window) {
     65     // TODO(maruel):  bug 1214347 Get the right browser window instead.
     66     return GetDesktopWindow();
     67   }
     68   return window;
     69 }
     70 
     71 }  // anonymous namespace
     72 
     73 namespace printing {
     74 
     75 class PrintingContextWin::CallbackHandler : public IPrintDialogCallback,
     76                                             public IObjectWithSite {
     77  public:
     78   CallbackHandler(PrintingContextWin& owner, HWND owner_hwnd)
     79       : owner_(owner),
     80         owner_hwnd_(owner_hwnd),
     81         services_(NULL) {
     82   }
     83 
     84   ~CallbackHandler() {
     85     if (services_)
     86       services_->Release();
     87   }
     88 
     89   IUnknown* ToIUnknown() {
     90     return static_cast<IUnknown*>(static_cast<IPrintDialogCallback*>(this));
     91   }
     92 
     93   // IUnknown
     94   virtual HRESULT WINAPI QueryInterface(REFIID riid, void**object) {
     95     if (riid == IID_IUnknown) {
     96       *object = ToIUnknown();
     97     } else if (riid == IID_IPrintDialogCallback) {
     98       *object = static_cast<IPrintDialogCallback*>(this);
     99     } else if (riid == IID_IObjectWithSite) {
    100       *object = static_cast<IObjectWithSite*>(this);
    101     } else {
    102       return E_NOINTERFACE;
    103     }
    104     return S_OK;
    105   }
    106 
    107   // No real ref counting.
    108   virtual ULONG WINAPI AddRef() {
    109     return 1;
    110   }
    111   virtual ULONG WINAPI Release() {
    112     return 1;
    113   }
    114 
    115   // IPrintDialogCallback methods
    116   virtual HRESULT WINAPI InitDone() {
    117     return S_OK;
    118   }
    119 
    120   virtual HRESULT WINAPI SelectionChange() {
    121     if (services_) {
    122       // TODO(maruel): Get the devmode for the new printer with
    123       // services_->GetCurrentDevMode(&devmode, &size), send that information
    124       // back to our client and continue. The client needs to recalculate the
    125       // number of rendered pages and send back this information here.
    126     }
    127     return S_OK;
    128   }
    129 
    130   virtual HRESULT WINAPI HandleMessage(HWND dialog,
    131                                        UINT message,
    132                                        WPARAM wparam,
    133                                        LPARAM lparam,
    134                                        LRESULT* result) {
    135     // Cheap way to retrieve the window handle.
    136     if (!owner_.dialog_box_) {
    137       // The handle we receive is the one of the groupbox in the General tab. We
    138       // need to get the grand-father to get the dialog box handle.
    139       owner_.dialog_box_ = GetAncestor(dialog, GA_ROOT);
    140       // Trick to enable the owner window. This can cause issues with navigation
    141       // events so it may have to be disabled if we don't fix the side-effects.
    142       EnableWindow(owner_hwnd_, TRUE);
    143     }
    144     return S_FALSE;
    145   }
    146 
    147   virtual HRESULT WINAPI SetSite(IUnknown* site) {
    148     if (!site) {
    149       DCHECK(services_);
    150       services_->Release();
    151       services_ = NULL;
    152       // The dialog box is destroying, PrintJob::Worker don't need the handle
    153       // anymore.
    154       owner_.dialog_box_ = NULL;
    155     } else {
    156       DCHECK(services_ == NULL);
    157       HRESULT hr = site->QueryInterface(IID_IPrintDialogServices,
    158                                         reinterpret_cast<void**>(&services_));
    159       DCHECK(SUCCEEDED(hr));
    160     }
    161     return S_OK;
    162   }
    163 
    164   virtual HRESULT WINAPI GetSite(REFIID riid, void** site) {
    165     return E_NOTIMPL;
    166   }
    167 
    168  private:
    169   PrintingContextWin& owner_;
    170   HWND owner_hwnd_;
    171   IPrintDialogServices* services_;
    172 
    173   DISALLOW_COPY_AND_ASSIGN(CallbackHandler);
    174 };
    175 
    176 // static
    177 PrintingContext* PrintingContext::Create(const std::string& app_locale) {
    178   return static_cast<PrintingContext*>(new PrintingContextWin(app_locale));
    179 }
    180 
    181 PrintingContextWin::PrintingContextWin(const std::string& app_locale)
    182     : PrintingContext(app_locale),
    183       context_(NULL),
    184       dialog_box_(NULL),
    185       print_dialog_func_(&PrintDlgEx) {
    186 }
    187 
    188 PrintingContextWin::~PrintingContextWin() {
    189   ReleaseContext();
    190 }
    191 
    192 // TODO(vitalybuka): Implement as ui::BaseShellDialog crbug.com/180997.
    193 void PrintingContextWin::AskUserForSettings(
    194     gfx::NativeView view, int max_pages, bool has_selection,
    195     const PrintSettingsCallback& callback) {
    196   DCHECK(!in_print_job_);
    197   if (win8::IsSingleWindowMetroMode()) {
    198     // The system dialog can not be opened while running in Metro.
    199     // But we can programatically launch the Metro print device charm though.
    200     HMODULE metro_module = base::win::GetMetroModule();
    201     if (metro_module != NULL) {
    202       typedef void (*MetroShowPrintUI)();
    203       MetroShowPrintUI metro_show_print_ui =
    204           reinterpret_cast<MetroShowPrintUI>(
    205               ::GetProcAddress(metro_module, "MetroShowPrintUI"));
    206       if (metro_show_print_ui) {
    207         // TODO(mad): Remove this once we can send user metrics from the metro
    208         // driver. crbug.com/142330
    209         UMA_HISTOGRAM_ENUMERATION("Metro.Print", 1, 2);
    210         metro_show_print_ui();
    211       }
    212     }
    213     return callback.Run(CANCEL);
    214   }
    215   dialog_box_dismissed_ = false;
    216 
    217   HWND window = GetRootWindow(view);
    218   DCHECK(window);
    219 
    220   // Show the OS-dependent dialog box.
    221   // If the user press
    222   // - OK, the settings are reset and reinitialized with the new settings. OK is
    223   //   returned.
    224   // - Apply then Cancel, the settings are reset and reinitialized with the new
    225   //   settings. CANCEL is returned.
    226   // - Cancel, the settings are not changed, the previous setting, if it was
    227   //   initialized before, are kept. CANCEL is returned.
    228   // On failure, the settings are reset and FAILED is returned.
    229   PRINTDLGEX dialog_options = { sizeof(PRINTDLGEX) };
    230   dialog_options.hwndOwner = window;
    231   // Disable options we don't support currently.
    232   // TODO(maruel):  Reuse the previously loaded settings!
    233   dialog_options.Flags = PD_RETURNDC | PD_USEDEVMODECOPIESANDCOLLATE  |
    234                          PD_NOCURRENTPAGE | PD_HIDEPRINTTOFILE;
    235   if (!has_selection)
    236     dialog_options.Flags |= PD_NOSELECTION;
    237 
    238   PRINTPAGERANGE ranges[32];
    239   dialog_options.nStartPage = START_PAGE_GENERAL;
    240   if (max_pages) {
    241     // Default initialize to print all the pages.
    242     memset(ranges, 0, sizeof(ranges));
    243     ranges[0].nFromPage = 1;
    244     ranges[0].nToPage = max_pages;
    245     dialog_options.nPageRanges = 1;
    246     dialog_options.nMaxPageRanges = arraysize(ranges);
    247     dialog_options.nMinPage = 1;
    248     dialog_options.nMaxPage = max_pages;
    249     dialog_options.lpPageRanges = ranges;
    250   } else {
    251     // No need to bother, we don't know how many pages are available.
    252     dialog_options.Flags |= PD_NOPAGENUMS;
    253   }
    254 
    255   HRESULT hr = (*print_dialog_func_)(&dialog_options);
    256   if (hr != S_OK) {
    257     ResetSettings();
    258     callback.Run(FAILED);
    259   }
    260 
    261   // TODO(maruel):  Support PD_PRINTTOFILE.
    262   callback.Run(ParseDialogResultEx(dialog_options));
    263 }
    264 
    265 PrintingContext::Result PrintingContextWin::UseDefaultSettings() {
    266   DCHECK(!in_print_job_);
    267 
    268   PRINTDLG dialog_options = { sizeof(PRINTDLG) };
    269   dialog_options.Flags = PD_RETURNDC | PD_RETURNDEFAULT;
    270   if (PrintDlg(&dialog_options))
    271     return ParseDialogResult(dialog_options);
    272 
    273   // No default printer configured, do we have any printers at all?
    274   DWORD bytes_needed = 0;
    275   DWORD count_returned = 0;
    276   (void)::EnumPrinters(PRINTER_ENUM_LOCAL|PRINTER_ENUM_CONNECTIONS,
    277                        NULL, 2, NULL, 0, &bytes_needed, &count_returned);
    278   if (bytes_needed) {
    279     DCHECK(bytes_needed >= count_returned * sizeof(PRINTER_INFO_2));
    280     scoped_ptr<BYTE[]> printer_info_buffer(new BYTE[bytes_needed]);
    281     BOOL ret = ::EnumPrinters(PRINTER_ENUM_LOCAL|PRINTER_ENUM_CONNECTIONS,
    282                               NULL, 2, printer_info_buffer.get(),
    283                               bytes_needed, &bytes_needed,
    284                               &count_returned);
    285     if (ret && count_returned) {  // have printers
    286       // Open the first successfully found printer.
    287       for (DWORD count = 0; count < count_returned; ++count) {
    288         PRINTER_INFO_2* info_2 = reinterpret_cast<PRINTER_INFO_2*>(
    289             printer_info_buffer.get() + count * sizeof(PRINTER_INFO_2));
    290         std::wstring printer_name = info_2->pPrinterName;
    291         if (info_2->pDevMode == NULL || printer_name.length() == 0)
    292           continue;
    293         if (!AllocateContext(printer_name, info_2->pDevMode, &context_))
    294           break;
    295         if (InitializeSettings(*info_2->pDevMode, printer_name,
    296                                NULL, 0, false)) {
    297           break;
    298         }
    299         ReleaseContext();
    300       }
    301       if (context_)
    302         return OK;
    303     }
    304   }
    305 
    306   ResetSettings();
    307   return FAILED;
    308 }
    309 
    310 PrintingContext::Result PrintingContextWin::UpdatePrinterSettings(
    311     const DictionaryValue& job_settings,
    312     const PageRanges& ranges) {
    313   DCHECK(!in_print_job_);
    314 
    315   bool collate;
    316   int color;
    317   bool landscape;
    318   bool print_to_pdf;
    319   bool is_cloud_dialog;
    320   int copies;
    321   int duplex_mode;
    322   string16 device_name;
    323 
    324   if (!job_settings.GetBoolean(kSettingLandscape, &landscape) ||
    325       !job_settings.GetBoolean(kSettingCollate, &collate) ||
    326       !job_settings.GetInteger(kSettingColor, &color) ||
    327       !job_settings.GetBoolean(kSettingPrintToPDF, &print_to_pdf) ||
    328       !job_settings.GetInteger(kSettingDuplexMode, &duplex_mode) ||
    329       !job_settings.GetInteger(kSettingCopies, &copies) ||
    330       !job_settings.GetString(kSettingDeviceName, &device_name) ||
    331       !job_settings.GetBoolean(kSettingCloudPrintDialog, &is_cloud_dialog)) {
    332     return OnError();
    333   }
    334 
    335   bool print_to_cloud = job_settings.HasKey(kSettingCloudPrintId);
    336 
    337   if (print_to_pdf || print_to_cloud || is_cloud_dialog) {
    338     // Default fallback to Letter size.
    339     gfx::Size paper_size;
    340     gfx::Rect paper_rect;
    341     paper_size.SetSize(kPDFLetterWidth, kPDFLetterHeight);
    342 
    343     // Get settings from locale. Paper type buffer length is at most 4.
    344     const int paper_type_buffer_len = 4;
    345     wchar_t paper_type_buffer[paper_type_buffer_len] = {0};
    346     GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_IPAPERSIZE, paper_type_buffer,
    347                   paper_type_buffer_len);
    348     if (wcslen(paper_type_buffer)) {  // The call succeeded.
    349       int paper_code = _wtoi(paper_type_buffer);
    350       switch (paper_code) {
    351         case DMPAPER_LEGAL:
    352           paper_size.SetSize(kPDFLegalWidth, kPDFLegalHeight);
    353           break;
    354         case DMPAPER_A4:
    355           paper_size.SetSize(kPDFA4Width, kPDFA4Height);
    356           break;
    357         case DMPAPER_A3:
    358           paper_size.SetSize(kPDFA3Width, kPDFA3Height);
    359           break;
    360         default:  // DMPAPER_LETTER is used for default fallback.
    361           break;
    362       }
    363     }
    364     paper_rect.SetRect(0, 0, paper_size.width(), paper_size.height());
    365     settings_.SetPrinterPrintableArea(paper_size, paper_rect, kPDFDpi);
    366     settings_.set_dpi(kPDFDpi);
    367     settings_.SetOrientation(landscape);
    368     settings_.ranges = ranges;
    369     return OK;
    370   }
    371 
    372   ScopedPrinterHandle printer;
    373   LPWSTR device_name_wide = const_cast<wchar_t*>(device_name.c_str());
    374   if (!printer.OpenPrinter(device_name_wide))
    375     return OnError();
    376 
    377   // Make printer changes local to Chrome.
    378   // See MSDN documentation regarding DocumentProperties.
    379   scoped_ptr<uint8[]> buffer;
    380   DEVMODE* dev_mode = NULL;
    381   LONG buffer_size = DocumentProperties(NULL, printer, device_name_wide,
    382                                         NULL, NULL, 0);
    383   if (buffer_size > 0) {
    384     buffer.reset(new uint8[buffer_size]);
    385     memset(buffer.get(), 0, buffer_size);
    386     if (DocumentProperties(NULL, printer, device_name_wide,
    387                            reinterpret_cast<PDEVMODE>(buffer.get()), NULL,
    388                            DM_OUT_BUFFER) == IDOK) {
    389       dev_mode = reinterpret_cast<PDEVMODE>(buffer.get());
    390     }
    391   }
    392   if (dev_mode == NULL) {
    393     buffer.reset();
    394     return OnError();
    395   }
    396 
    397   if (color == GRAY)
    398     dev_mode->dmColor = DMCOLOR_MONOCHROME;
    399   else
    400     dev_mode->dmColor = DMCOLOR_COLOR;
    401 
    402   dev_mode->dmCopies = std::max(copies, 1);
    403   if (dev_mode->dmCopies > 1)  // do not change collate unless multiple copies
    404     dev_mode->dmCollate = collate ? DMCOLLATE_TRUE : DMCOLLATE_FALSE;
    405   switch (duplex_mode) {
    406     case LONG_EDGE:
    407       dev_mode->dmDuplex = DMDUP_VERTICAL;
    408       break;
    409     case SHORT_EDGE:
    410       dev_mode->dmDuplex = DMDUP_HORIZONTAL;
    411       break;
    412     case SIMPLEX:
    413       dev_mode->dmDuplex = DMDUP_SIMPLEX;
    414       break;
    415     default:  // UNKNOWN_DUPLEX_MODE
    416       break;
    417   }
    418   dev_mode->dmOrientation = landscape ? DMORIENT_LANDSCAPE : DMORIENT_PORTRAIT;
    419 
    420   // Update data using DocumentProperties.
    421   if (DocumentProperties(NULL, printer, device_name_wide, dev_mode, dev_mode,
    422                          DM_IN_BUFFER | DM_OUT_BUFFER) != IDOK) {
    423     return OnError();
    424   }
    425 
    426   // Set printer then refresh printer settings.
    427   if (!AllocateContext(device_name, dev_mode, &context_)) {
    428     return OnError();
    429   }
    430   PrintSettingsInitializerWin::InitPrintSettings(context_, *dev_mode,
    431                                                  ranges, device_name,
    432                                                  false, &settings_);
    433   return OK;
    434 }
    435 
    436 PrintingContext::Result PrintingContextWin::InitWithSettings(
    437     const PrintSettings& settings) {
    438   DCHECK(!in_print_job_);
    439 
    440   settings_ = settings;
    441 
    442   // TODO(maruel): settings_.ToDEVMODE()
    443   ScopedPrinterHandle printer;
    444   if (!printer.OpenPrinter(settings_.device_name().c_str())) {
    445     return FAILED;
    446   }
    447 
    448   Result status = OK;
    449 
    450   if (!GetPrinterSettings(printer, settings_.device_name()))
    451     status = FAILED;
    452 
    453   if (status != OK)
    454     ResetSettings();
    455   return status;
    456 }
    457 
    458 PrintingContext::Result PrintingContextWin::NewDocument(
    459     const string16& document_name) {
    460   DCHECK(!in_print_job_);
    461   if (!context_)
    462     return OnError();
    463 
    464   // Set the flag used by the AbortPrintJob dialog procedure.
    465   abort_printing_ = false;
    466 
    467   in_print_job_ = true;
    468 
    469   // Register the application's AbortProc function with GDI.
    470   if (SP_ERROR == SetAbortProc(context_, &AbortProc))
    471     return OnError();
    472 
    473   DCHECK(PrintBackend::SimplifyDocumentTitle(document_name) == document_name);
    474   DOCINFO di = { sizeof(DOCINFO) };
    475   const std::wstring& document_name_wide = UTF16ToWide(document_name);
    476   di.lpszDocName = document_name_wide.c_str();
    477 
    478   // Is there a debug dump directory specified? If so, force to print to a file.
    479   base::FilePath debug_dump_path = PrintedDocument::debug_dump_path();
    480   if (!debug_dump_path.empty()) {
    481     // Create a filename.
    482     std::wstring filename;
    483     Time now(Time::Now());
    484     filename = base::TimeFormatShortDateNumeric(now);
    485     filename += L"_";
    486     filename += base::TimeFormatTimeOfDay(now);
    487     filename += L"_";
    488     filename += UTF16ToWide(document_name);
    489     filename += L"_";
    490     filename += L"buffer.prn";
    491     file_util::ReplaceIllegalCharactersInPath(&filename, '_');
    492     debug_dump_path.Append(filename);
    493     di.lpszOutput = debug_dump_path.value().c_str();
    494   }
    495 
    496   // No message loop running in unit tests.
    497   DCHECK(!base::MessageLoop::current() ||
    498          !base::MessageLoop::current()->NestableTasksAllowed());
    499 
    500   // Begin a print job by calling the StartDoc function.
    501   // NOTE: StartDoc() starts a message loop. That causes a lot of problems with
    502   // IPC. Make sure recursive task processing is disabled.
    503   if (StartDoc(context_, &di) <= 0)
    504     return OnError();
    505 
    506   return OK;
    507 }
    508 
    509 PrintingContext::Result PrintingContextWin::NewPage() {
    510   if (abort_printing_)
    511     return CANCEL;
    512   DCHECK(context_);
    513   DCHECK(in_print_job_);
    514 
    515   // Intentional No-op. NativeMetafile::SafePlayback takes care of calling
    516   // ::StartPage().
    517 
    518   return OK;
    519 }
    520 
    521 PrintingContext::Result PrintingContextWin::PageDone() {
    522   if (abort_printing_)
    523     return CANCEL;
    524   DCHECK(in_print_job_);
    525 
    526   // Intentional No-op. NativeMetafile::SafePlayback takes care of calling
    527   // ::EndPage().
    528 
    529   return OK;
    530 }
    531 
    532 PrintingContext::Result PrintingContextWin::DocumentDone() {
    533   if (abort_printing_)
    534     return CANCEL;
    535   DCHECK(in_print_job_);
    536   DCHECK(context_);
    537 
    538   // Inform the driver that document has ended.
    539   if (EndDoc(context_) <= 0)
    540     return OnError();
    541 
    542   ResetSettings();
    543   return OK;
    544 }
    545 
    546 void PrintingContextWin::Cancel() {
    547   abort_printing_ = true;
    548   in_print_job_ = false;
    549   if (context_)
    550     CancelDC(context_);
    551   if (dialog_box_) {
    552     DestroyWindow(dialog_box_);
    553     dialog_box_dismissed_ = true;
    554   }
    555 }
    556 
    557 void PrintingContextWin::ReleaseContext() {
    558   if (context_) {
    559     DeleteDC(context_);
    560     context_ = NULL;
    561   }
    562 }
    563 
    564 gfx::NativeDrawingContext PrintingContextWin::context() const {
    565   return context_;
    566 }
    567 
    568 // static
    569 BOOL PrintingContextWin::AbortProc(HDC hdc, int nCode) {
    570   if (nCode) {
    571     // TODO(maruel):  Need a way to find the right instance to set. Should
    572     // leverage PrintJobManager here?
    573     // abort_printing_ = true;
    574   }
    575   return true;
    576 }
    577 
    578 bool PrintingContextWin::InitializeSettings(const DEVMODE& dev_mode,
    579                                             const std::wstring& new_device_name,
    580                                             const PRINTPAGERANGE* ranges,
    581                                             int number_ranges,
    582                                             bool selection_only) {
    583   skia::InitializeDC(context_);
    584   DCHECK(GetDeviceCaps(context_, CLIPCAPS));
    585   DCHECK(GetDeviceCaps(context_, RASTERCAPS) & RC_STRETCHDIB);
    586   DCHECK(GetDeviceCaps(context_, RASTERCAPS) & RC_BITMAP64);
    587   // Some printers don't advertise these.
    588   // DCHECK(GetDeviceCaps(context_, RASTERCAPS) & RC_SCALING);
    589   // DCHECK(GetDeviceCaps(context_, SHADEBLENDCAPS) & SB_CONST_ALPHA);
    590   // DCHECK(GetDeviceCaps(context_, SHADEBLENDCAPS) & SB_PIXEL_ALPHA);
    591 
    592   // StretchDIBits() support is needed for printing.
    593   if (!(GetDeviceCaps(context_, RASTERCAPS) & RC_STRETCHDIB) ||
    594       !(GetDeviceCaps(context_, RASTERCAPS) & RC_BITMAP64)) {
    595     NOTREACHED();
    596     ResetSettings();
    597     return false;
    598   }
    599 
    600   DCHECK(!in_print_job_);
    601   DCHECK(context_);
    602   PageRanges ranges_vector;
    603   if (!selection_only) {
    604     // Convert the PRINTPAGERANGE array to a PrintSettings::PageRanges vector.
    605     ranges_vector.reserve(number_ranges);
    606     for (int i = 0; i < number_ranges; ++i) {
    607       PageRange range;
    608       // Transfer from 1-based to 0-based.
    609       range.from = ranges[i].nFromPage - 1;
    610       range.to = ranges[i].nToPage - 1;
    611       ranges_vector.push_back(range);
    612     }
    613   }
    614 
    615   PrintSettingsInitializerWin::InitPrintSettings(context_,
    616                                                  dev_mode,
    617                                                  ranges_vector,
    618                                                  new_device_name,
    619                                                  selection_only,
    620                                                  &settings_);
    621 
    622   return true;
    623 }
    624 
    625 bool PrintingContextWin::GetPrinterSettings(HANDLE printer,
    626                                             const std::wstring& device_name) {
    627   DCHECK(!in_print_job_);
    628 
    629   UserDefaultDevMode user_settings;
    630 
    631   if (!user_settings.Init(printer) ||
    632       !AllocateContext(device_name, user_settings.get(), &context_)) {
    633     ResetSettings();
    634     return false;
    635   }
    636 
    637   return InitializeSettings(*user_settings.get(), device_name, NULL, 0, false);
    638 }
    639 
    640 // static
    641 bool PrintingContextWin::AllocateContext(const std::wstring& device_name,
    642                                          const DEVMODE* dev_mode,
    643                                          gfx::NativeDrawingContext* context) {
    644   *context = CreateDC(L"WINSPOOL", device_name.c_str(), NULL, dev_mode);
    645   DCHECK(*context);
    646   return *context != NULL;
    647 }
    648 
    649 PrintingContext::Result PrintingContextWin::ParseDialogResultEx(
    650     const PRINTDLGEX& dialog_options) {
    651   // If the user clicked OK or Apply then Cancel, but not only Cancel.
    652   if (dialog_options.dwResultAction != PD_RESULT_CANCEL) {
    653     // Start fresh.
    654     ResetSettings();
    655 
    656     DEVMODE* dev_mode = NULL;
    657     if (dialog_options.hDevMode) {
    658       dev_mode =
    659           reinterpret_cast<DEVMODE*>(GlobalLock(dialog_options.hDevMode));
    660       DCHECK(dev_mode);
    661     }
    662 
    663     std::wstring device_name;
    664     if (dialog_options.hDevNames) {
    665       DEVNAMES* dev_names =
    666           reinterpret_cast<DEVNAMES*>(GlobalLock(dialog_options.hDevNames));
    667       DCHECK(dev_names);
    668       if (dev_names) {
    669         device_name =
    670             reinterpret_cast<const wchar_t*>(
    671                 reinterpret_cast<const wchar_t*>(dev_names) +
    672                     dev_names->wDeviceOffset);
    673         GlobalUnlock(dialog_options.hDevNames);
    674       }
    675     }
    676 
    677     bool success = false;
    678     if (dev_mode && !device_name.empty()) {
    679       context_ = dialog_options.hDC;
    680       PRINTPAGERANGE* page_ranges = NULL;
    681       DWORD num_page_ranges = 0;
    682       bool print_selection_only = false;
    683       if (dialog_options.Flags & PD_PAGENUMS) {
    684         page_ranges = dialog_options.lpPageRanges;
    685         num_page_ranges = dialog_options.nPageRanges;
    686       }
    687       if (dialog_options.Flags & PD_SELECTION) {
    688         print_selection_only = true;
    689       }
    690       success = InitializeSettings(*dev_mode,
    691                                    device_name,
    692                                    page_ranges,
    693                                    num_page_ranges,
    694                                    print_selection_only);
    695     }
    696 
    697     if (!success && dialog_options.hDC) {
    698       DeleteDC(dialog_options.hDC);
    699       context_ = NULL;
    700     }
    701 
    702     if (dev_mode) {
    703       GlobalUnlock(dialog_options.hDevMode);
    704     }
    705   } else {
    706     if (dialog_options.hDC) {
    707       DeleteDC(dialog_options.hDC);
    708     }
    709   }
    710 
    711   if (dialog_options.hDevMode != NULL)
    712     GlobalFree(dialog_options.hDevMode);
    713   if (dialog_options.hDevNames != NULL)
    714     GlobalFree(dialog_options.hDevNames);
    715 
    716   switch (dialog_options.dwResultAction) {
    717     case PD_RESULT_PRINT:
    718       return context_ ? OK : FAILED;
    719     case PD_RESULT_APPLY:
    720       return context_ ? CANCEL : FAILED;
    721     case PD_RESULT_CANCEL:
    722       return CANCEL;
    723     default:
    724       return FAILED;
    725   }
    726 }
    727 
    728 PrintingContext::Result PrintingContextWin::ParseDialogResult(
    729     const PRINTDLG& dialog_options) {
    730   // If the user clicked OK or Apply then Cancel, but not only Cancel.
    731   // Start fresh.
    732   ResetSettings();
    733 
    734   DEVMODE* dev_mode = NULL;
    735   if (dialog_options.hDevMode) {
    736     dev_mode =
    737         reinterpret_cast<DEVMODE*>(GlobalLock(dialog_options.hDevMode));
    738     DCHECK(dev_mode);
    739   }
    740 
    741   std::wstring device_name;
    742   if (dialog_options.hDevNames) {
    743     DEVNAMES* dev_names =
    744         reinterpret_cast<DEVNAMES*>(GlobalLock(dialog_options.hDevNames));
    745     DCHECK(dev_names);
    746     if (dev_names) {
    747       device_name =
    748           reinterpret_cast<const wchar_t*>(
    749               reinterpret_cast<const wchar_t*>(dev_names) +
    750                   dev_names->wDeviceOffset);
    751       GlobalUnlock(dialog_options.hDevNames);
    752     }
    753   }
    754 
    755   bool success = false;
    756   if (dev_mode && !device_name.empty()) {
    757     context_ = dialog_options.hDC;
    758     success = InitializeSettings(*dev_mode, device_name, NULL, 0, false);
    759   }
    760 
    761   if (!success && dialog_options.hDC) {
    762     DeleteDC(dialog_options.hDC);
    763     context_ = NULL;
    764   }
    765 
    766   if (dev_mode) {
    767     GlobalUnlock(dialog_options.hDevMode);
    768   }
    769 
    770   if (dialog_options.hDevMode != NULL)
    771     GlobalFree(dialog_options.hDevMode);
    772   if (dialog_options.hDevNames != NULL)
    773     GlobalFree(dialog_options.hDevNames);
    774 
    775   return context_ ? OK : FAILED;
    776 }
    777 
    778 }  // namespace printing
    779